]>
git.ipfire.org Git - thirdparty/mdadm.git/blob - raid6check.c
2 * raid6check - extended consistency check for RAID-6
4 * Copyright (C) 2011 Piergiorgio Sartor
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 * Author: Piergiorgio Sartor
22 * Based on "restripe.c" from "mdadm" codebase
30 #define CHECK_PAGE_BITS (12)
31 #define CHECK_PAGE_SIZE (1 << CHECK_PAGE_BITS)
33 char const Name
[] = "raid6check";
41 int geo_map(int block
, unsigned long long stripe
, int raid_disks
,
42 int level
, int layout
);
43 void qsyndrome(uint8_t *p
, uint8_t *q
, uint8_t **sources
, int disks
, int size
);
44 void make_tables(void);
45 void ensure_zero_has_size(int chunk_size
);
46 void raid6_datap_recov(int disks
, size_t bytes
, int faila
, uint8_t **ptrs
);
47 void raid6_2data_recov(int disks
, size_t bytes
, int faila
, int failb
,
49 void xor_blocks(char *target
, char **sources
, int disks
, int size
);
51 /* Collect per stripe consistency information */
52 void raid6_collect(int chunk_size
, uint8_t *p
, uint8_t *q
,
53 char *chunkP
, char *chunkQ
, int *results
)
58 extern uint8_t raid6_gflog
[];
60 for(i
= 0; i
< chunk_size
; i
++) {
61 Px
= (uint8_t)chunkP
[i
] ^ (uint8_t)p
[i
];
62 Qx
= (uint8_t)chunkQ
[i
] ^ (uint8_t)q
[i
];
64 if((Px
!= 0) && (Qx
== 0))
67 if((Px
== 0) && (Qx
!= 0))
70 if((Px
!= 0) && (Qx
!= 0)) {
71 data_id
= (raid6_gflog
[Qx
] - raid6_gflog
[Px
]);
72 if(data_id
< 0) data_id
+= 255;
76 if((Px
== 0) && (Qx
== 0))
81 /* Try to find out if a specific disk has problems in a CHECK_PAGE_SIZE page size */
82 int raid6_stats_blk(int *results
, int raid_disks
)
85 int curr_broken_disk
= -255;
86 int prev_broken_disk
= -255;
87 int broken_status
= 0;
89 for(i
= 0; i
< CHECK_PAGE_SIZE
; i
++) {
91 if(results
[i
] != -255)
92 curr_broken_disk
= results
[i
];
94 if(curr_broken_disk
>= raid_disks
)
97 switch(broken_status
) {
99 if(curr_broken_disk
!= -255) {
100 prev_broken_disk
= curr_broken_disk
;
106 if(curr_broken_disk
!= prev_broken_disk
)
112 curr_broken_disk
= prev_broken_disk
= -65535;
117 return curr_broken_disk
;
120 /* Collect disks status for a strip in CHECK_PAGE_SIZE page size blocks */
121 void raid6_stats(int *disk
, int *results
, int raid_disks
, int chunk_size
)
125 for(i
= 0, j
= 0; i
< chunk_size
; i
+= CHECK_PAGE_SIZE
, j
++) {
126 disk
[j
] = raid6_stats_blk(&results
[i
], raid_disks
);
130 int lock_stripe(struct mdinfo
*info
, unsigned long long start
,
131 int chunk_size
, int data_disks
, sighandler_t
*sig
) {
133 if(mlockall(MCL_CURRENT
| MCL_FUTURE
) != 0) {
137 sig
[0] = signal(SIGTERM
, SIG_IGN
);
138 sig
[1] = signal(SIGINT
, SIG_IGN
);
139 sig
[2] = signal(SIGQUIT
, SIG_IGN
);
141 rv
= sysfs_set_num(info
, NULL
, "suspend_lo", start
* chunk_size
* data_disks
);
142 rv
|= sysfs_set_num(info
, NULL
, "suspend_hi", (start
+ 1) * chunk_size
* data_disks
);
146 int unlock_all_stripes(struct mdinfo
*info
, sighandler_t
*sig
) {
148 rv
= sysfs_set_num(info
, NULL
, "suspend_lo", 0x7FFFFFFFFFFFFFFFULL
);
149 rv
|= sysfs_set_num(info
, NULL
, "suspend_hi", 0);
150 rv
|= sysfs_set_num(info
, NULL
, "suspend_lo", 0);
152 signal(SIGQUIT
, sig
[2]);
153 signal(SIGINT
, sig
[1]);
154 signal(SIGTERM
, sig
[0]);
156 if(munlockall() != 0)
162 int autorepair(int *disk
, int diskP
, int diskQ
, unsigned long long start
, int chunk_size
,
163 char *name
[], int raid_disks
, int data_disks
, char **blocks_page
,
164 char **blocks
, uint8_t *p
, char **stripes
, int *block_index_for_slot
,
165 int *source
, unsigned long long *offsets
)
168 int pages_to_write_count
= 0;
169 int page_to_write
[chunk_size
>> CHECK_PAGE_BITS
];
170 for(j
= 0; j
< (chunk_size
>> CHECK_PAGE_BITS
); j
++) {
172 printf("Auto-repairing slot %d (%s)\n", disk
[j
], name
[disk
[j
]]);
173 pages_to_write_count
++;
174 page_to_write
[j
] = 1;
175 for(i
= 0; i
< raid_disks
; i
++) {
176 blocks_page
[i
] = blocks
[i
] + j
* CHECK_PAGE_SIZE
;
178 if (disk
[j
] == diskQ
) {
179 qsyndrome(p
, (uint8_t*)stripes
[diskQ
] + j
* CHECK_PAGE_SIZE
, (uint8_t**)blocks_page
, data_disks
, CHECK_PAGE_SIZE
);
182 char *all_but_failed_blocks
[data_disks
];
183 int failed_block_index
= block_index_for_slot
[disk
[j
]];
184 for(i
= 0; i
< data_disks
; i
++) {
185 if (failed_block_index
== i
) {
186 all_but_failed_blocks
[i
] = stripes
[diskP
] + j
* CHECK_PAGE_SIZE
;
189 all_but_failed_blocks
[i
] = blocks_page
[i
];
192 xor_blocks(stripes
[disk
[j
]] + j
* CHECK_PAGE_SIZE
,
193 all_but_failed_blocks
, data_disks
, CHECK_PAGE_SIZE
);
197 page_to_write
[j
] = 0;
201 if(pages_to_write_count
> 0) {
203 for(j
= 0; j
< (chunk_size
>> CHECK_PAGE_BITS
); j
++) {
204 if(page_to_write
[j
] == 1) {
205 lseek64(source
[disk
[j
]], offsets
[disk
[j
]] + start
* chunk_size
+ j
* CHECK_PAGE_SIZE
, SEEK_SET
);
206 write_res
+= write(source
[disk
[j
]], stripes
[disk
[j
]] + j
* CHECK_PAGE_SIZE
, CHECK_PAGE_SIZE
);
210 if (write_res
!= (CHECK_PAGE_SIZE
* pages_to_write_count
)) {
211 fprintf(stderr
, "Failed to write a full chunk.\n");
220 int manual_repair(int diskP
, int diskQ
, int chunk_size
, int raid_disks
, int data_disks
,
221 int failed_disk1
, int failed_disk2
, unsigned long long start
, int *block_index_for_slot
,
222 char *name
[], char **stripes
, char **blocks
, uint8_t *p
, struct mdinfo
*info
, sighandler_t
*sig
,
223 int *source
, unsigned long long *offsets
)
227 printf("Repairing stripe %llu\n", start
);
228 printf("Assuming slots %d (%s) and %d (%s) are incorrect\n",
229 failed_disk1
, name
[failed_disk1
],
230 failed_disk2
, name
[failed_disk2
]);
232 if (failed_disk1
== diskQ
|| failed_disk2
== diskQ
) {
233 char *all_but_failed_blocks
[data_disks
];
234 int failed_data_or_p
;
235 int failed_block_index
;
237 if (failed_disk1
== diskQ
) {
238 failed_data_or_p
= failed_disk2
;
241 failed_data_or_p
= failed_disk1
;
243 printf("Repairing D/P(%d) and Q\n", failed_data_or_p
);
244 failed_block_index
= block_index_for_slot
[failed_data_or_p
];
245 for (i
= 0; i
< data_disks
; i
++) {
246 if (failed_block_index
== i
) {
247 all_but_failed_blocks
[i
] = stripes
[diskP
];
250 all_but_failed_blocks
[i
] = blocks
[i
];
253 xor_blocks(stripes
[failed_data_or_p
],
254 all_but_failed_blocks
, data_disks
, chunk_size
);
255 qsyndrome(p
, (uint8_t*)stripes
[diskQ
], (uint8_t**)blocks
, data_disks
, chunk_size
);
258 ensure_zero_has_size(chunk_size
);
259 if (failed_disk1
== diskP
|| failed_disk2
== diskP
) {
260 int failed_data
, failed_block_index
;
261 if (failed_disk1
== diskP
) {
262 failed_data
= failed_disk2
;
265 failed_data
= failed_disk1
;
267 failed_block_index
= block_index_for_slot
[failed_data
];
268 printf("Repairing D(%d) and P\n", failed_data
);
269 raid6_datap_recov(raid_disks
, chunk_size
, failed_block_index
, (uint8_t**)blocks
);
272 printf("Repairing D and D\n");
273 int failed_block_index1
= block_index_for_slot
[failed_disk1
];
274 int failed_block_index2
= block_index_for_slot
[failed_disk2
];
275 if (failed_block_index1
> failed_block_index2
) {
276 int t
= failed_block_index1
;
277 failed_block_index1
= failed_block_index2
;
278 failed_block_index2
= t
;
280 raid6_2data_recov(raid_disks
, chunk_size
, failed_block_index1
, failed_block_index2
, (uint8_t**)blocks
);
284 err
= lock_stripe(info
, start
, chunk_size
, data_disks
, sig
);
292 int write_res1
, write_res2
;
295 seek_res
= lseek64(source
[failed_disk1
],
296 offsets
[failed_disk1
] + start
* chunk_size
, SEEK_SET
);
298 fprintf(stderr
, "lseek failed for failed_disk1\n");
301 write_res1
= write(source
[failed_disk1
], stripes
[failed_disk1
], chunk_size
);
303 seek_res
= lseek64(source
[failed_disk2
],
304 offsets
[failed_disk2
] + start
* chunk_size
, SEEK_SET
);
306 fprintf(stderr
, "lseek failed for failed_disk1\n");
309 write_res2
= write(source
[failed_disk2
], stripes
[failed_disk2
], chunk_size
);
311 err
= unlock_all_stripes(info
, sig
);
316 if (write_res1
!= chunk_size
|| write_res2
!= chunk_size
) {
317 fprintf(stderr
, "Failed to write a complete chunk.\n");
324 int check_stripes(struct mdinfo
*info
, int *source
, unsigned long long *offsets
,
325 int raid_disks
, int chunk_size
, int level
, int layout
,
326 unsigned long long start
, unsigned long long length
, char *name
[],
327 enum repair repair
, int failed_disk1
, int failed_disk2
)
329 /* read the data and p and q blocks, and check we got them right */
330 char *stripe_buf
= xmalloc(raid_disks
* chunk_size
);
331 char **stripes
= xmalloc(raid_disks
* sizeof(char*));
332 char **blocks
= xmalloc(raid_disks
* sizeof(char*));
333 char **blocks_page
= xmalloc(raid_disks
* sizeof(char*));
334 int *block_index_for_slot
= xmalloc(raid_disks
* sizeof(int));
335 uint8_t *p
= xmalloc(chunk_size
);
336 uint8_t *q
= xmalloc(chunk_size
);
337 int *results
= xmalloc(chunk_size
* sizeof(int));
338 sighandler_t
*sig
= xmalloc(3 * sizeof(sighandler_t
));
342 int data_disks
= raid_disks
- 2;
345 extern int tables_ready
;
350 for ( i
= 0 ; i
< raid_disks
; i
++)
351 stripes
[i
] = stripe_buf
+ i
* chunk_size
;
354 int disk
[chunk_size
>> CHECK_PAGE_BITS
];
356 err
= lock_stripe(info
, start
, chunk_size
, data_disks
, sig
);
359 unlock_all_stripes(info
, sig
);
362 for (i
= 0 ; i
< raid_disks
; i
++) {
363 off64_t seek_res
= lseek64(source
[i
], offsets
[i
] + start
* chunk_size
,
366 fprintf(stderr
, "lseek to source %d failed\n", i
);
367 unlock_all_stripes(info
, sig
);
371 int read_res
= read(source
[i
], stripes
[i
], chunk_size
);
372 if (read_res
< chunk_size
) {
373 fprintf(stderr
, "Failed to read complete chunk disk %d, aborting\n", i
);
374 unlock_all_stripes(info
, sig
);
380 for (i
= 0 ; i
< data_disks
; i
++) {
381 int disk
= geo_map(i
, start
, raid_disks
, level
, layout
);
382 blocks
[i
] = stripes
[disk
];
383 block_index_for_slot
[disk
] = i
;
386 qsyndrome(p
, q
, (uint8_t**)blocks
, data_disks
, chunk_size
);
387 diskP
= geo_map(-1, start
, raid_disks
, level
, layout
);
388 diskQ
= geo_map(-2, start
, raid_disks
, level
, layout
);
389 blocks
[data_disks
] = stripes
[diskP
];
390 block_index_for_slot
[diskP
] = data_disks
;
391 blocks
[data_disks
+1] = stripes
[diskQ
];
392 block_index_for_slot
[diskQ
] = data_disks
+1;
394 raid6_collect(chunk_size
, p
, q
, stripes
[diskP
], stripes
[diskQ
], results
);
395 raid6_stats(disk
, results
, raid_disks
, chunk_size
);
397 for(j
= 0; j
< (chunk_size
>> CHECK_PAGE_BITS
); j
++) {
399 disk
[j
] = geo_map(disk
[j
], start
, raid_disks
, level
, layout
);
402 printf("Error detected at stripe %llu, page %d: possible failed disk slot: %d --> %s\n",
403 start
, j
, disk
[j
], name
[disk
[j
]]);
405 if(disk
[j
] == -65535) {
406 printf("Error detected at stripe %llu, page %d: disk slot unknown\n", start
, j
);
410 if(repair
== AUTO_REPAIR
) {
411 err
= autorepair(disk
, diskP
, diskQ
, start
, chunk_size
,
412 name
, raid_disks
, data_disks
, blocks_page
,
413 blocks
, p
, stripes
, block_index_for_slot
,
416 unlock_all_stripes(info
, sig
);
421 err
= unlock_all_stripes(info
, sig
);
426 if(repair
== MANUAL_REPAIR
) {
427 err
= manual_repair(diskP
, diskQ
, chunk_size
, raid_disks
, data_disks
,
428 failed_disk1
, failed_disk2
, start
, block_index_for_slot
,
429 name
, stripes
, blocks
, p
, info
, sig
,
432 unlock_all_stripes(info
, sig
);
447 free(block_index_for_slot
);
456 unsigned long long getnum(char *str
, char **err
)
459 unsigned long long rv
= strtoull(str
, &e
, 10);
467 int main(int argc
, char *argv
[])
469 /* md_device start length */
472 char **disk_name
= NULL
;
473 unsigned long long *offsets
= NULL
;
479 enum repair repair
= NO_REPAIR
;
480 int failed_disk1
= -1;
481 int failed_disk2
= -1;
482 unsigned long long start
, length
;
485 struct mdinfo
*info
= NULL
, *comp
= NULL
;
489 char *prg
= strrchr(argv
[0], '/');
497 fprintf(stderr
, "Usage: %s md_device start_stripe length_stripes [autorepair]\n", prg
);
498 fprintf(stderr
, " or: %s md_device repair stripe failed_slot_1 failed_slot_2\n", prg
);
503 mdfd
= open(argv
[1], O_RDONLY
);
506 fprintf(stderr
, "%s: cannot open %s\n", prg
, argv
[1]);
511 info
= sysfs_read(mdfd
, NULL
,
523 fprintf(stderr
, "%s: Error reading sysfs information of %s\n", prg
, argv
[1]);
528 if(info
->array
.level
!= level
) {
529 fprintf(stderr
, "%s: %s not a RAID-6\n", prg
, argv
[1]);
534 if(info
->array
.failed_disks
> 0) {
535 fprintf(stderr
, "%s: %s degraded array\n", prg
, argv
[1]);
540 printf("layout: %d\n", info
->array
.layout
);
541 printf("disks: %d\n", info
->array
.raid_disks
);
542 printf("component size: %llu\n", info
->component_size
* 512);
543 printf("total stripes: %llu\n", (info
->component_size
* 512) / info
->array
.chunk_size
);
544 printf("chunk size: %d\n", info
->array
.chunk_size
);
548 for(i
= 0, active_disks
= 0; active_disks
< info
->array
.raid_disks
; i
++) {
549 printf("disk: %d - offset: %llu - size: %llu - name: %s - slot: %d\n",
550 i
, comp
->data_offset
* 512, comp
->component_size
* 512,
551 map_dev(comp
->disk
.major
, comp
->disk
.minor
, 0),
552 comp
->disk
.raid_disk
);
553 if(comp
->disk
.raid_disk
>= 0)
561 raid_disks
= info
->array
.raid_disks
;
562 chunk_size
= info
->array
.chunk_size
;
563 layout
= info
->array
.layout
;
564 if (strcmp(argv
[2], "repair")==0) {
566 fprintf(stderr
, "For repair mode, call %s md_device repair stripe failed_slot_1 failed_slot_2\n", prg
);
570 repair
= MANUAL_REPAIR
;
571 start
= getnum(argv
[3], &err
);
573 failed_disk1
= getnum(argv
[4], &err
);
574 failed_disk2
= getnum(argv
[5], &err
);
576 if(failed_disk1
>= info
->array
.raid_disks
) {
577 fprintf(stderr
, "%s: failed_slot_1 index is higher than number of devices in raid\n", prg
);
581 if(failed_disk2
>= info
->array
.raid_disks
) {
582 fprintf(stderr
, "%s: failed_slot_2 index is higher than number of devices in raid\n", prg
);
586 if(failed_disk1
== failed_disk2
) {
587 fprintf(stderr
, "%s: failed_slot_1 and failed_slot_2 are the same\n", prg
);
593 start
= getnum(argv
[2], &err
);
594 length
= getnum(argv
[3], &err
);
595 if (argc
>= 5 && strcmp(argv
[4], "autorepair")==0)
596 repair
= AUTO_REPAIR
;
600 fprintf(stderr
, "%s: Bad number: %s\n", prg
, err
);
605 if(start
> ((info
->component_size
* 512) / chunk_size
)) {
606 start
= (info
->component_size
* 512) / chunk_size
;
607 fprintf(stderr
, "%s: start beyond disks size\n", prg
);
611 ((length
+ start
) > ((info
->component_size
* 512) / chunk_size
))) {
612 length
= (info
->component_size
* 512) / chunk_size
- start
;
615 disk_name
= xmalloc(raid_disks
* sizeof(*disk_name
));
616 fds
= xmalloc(raid_disks
* sizeof(*fds
));
617 offsets
= xcalloc(raid_disks
, sizeof(*offsets
));
618 buf
= xmalloc(raid_disks
* chunk_size
);
620 for(i
=0; i
<raid_disks
; i
++) {
626 for (i
=0, active_disks
=0; active_disks
<raid_disks
; i
++) {
627 int disk_slot
= comp
->disk
.raid_disk
;
629 disk_name
[disk_slot
] = map_dev(comp
->disk
.major
, comp
->disk
.minor
, 0);
630 offsets
[disk_slot
] = comp
->data_offset
* 512;
631 fds
[disk_slot
] = open(disk_name
[disk_slot
], O_RDWR
| O_SYNC
);
632 if (fds
[disk_slot
] < 0) {
633 perror(disk_name
[disk_slot
]);
634 fprintf(stderr
,"%s: cannot open %s\n", prg
, disk_name
[disk_slot
]);
643 int rv
= check_stripes(info
, fds
, offsets
,
644 raid_disks
, chunk_size
, level
, layout
,
645 start
, length
, disk_name
, repair
, failed_disk1
, failed_disk2
);
647 fprintf(stderr
, "%s: check_stripes returned %d\n", prg
, rv
);
655 for(i
= 0; i
< raid_disks
; i
++)