]> git.ipfire.org Git - thirdparty/mdadm.git/blob - restripe.c
projects / thirdparty / mdadm.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
platform-intel - cache 'intel_devices' for a few seconds.
[thirdparty/mdadm.git] / restripe.c
1 /*
2 * mdadm - manage Linux "md" devices aka RAID arrays.
3 *
4 * Copyright (C) 2006-2009 Neil Brown <neilb@suse.de>
5 *
6 *
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.
11 *
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.
16 *
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
20 *
21 * Author: Neil Brown
22 * Email: <neilb@suse.de>
23 */
24
25 #include "mdadm.h"
26 #include <stdint.h>
27
28 /* To restripe, we read from old geometry to a buffer, and
29 * read from buffer to new geometry.
30 * When reading, we might have missing devices and so could need
31 * to reconstruct.
32 * When writing, we need to create correct parity and Q.
33 *
34 */
35
36 int geo_map(int block, unsigned long long stripe, int raid_disks,
37 int level, int layout)
38 {
39 /* On the given stripe, find which disk in the array will have
40 * block numbered 'block'.
41 * '-1' means the parity block.
42 * '-2' means the Q syndrome.
43 */
44 int pd;
45
46 /* layout is not relevant for raid0 and raid4 */
47 if ((level == 0) ||
48 (level == 4))
49 layout = 0;
50
51 switch(level*100 + layout) {
52 case 000:
53 case 400:
54 case 500 + ALGORITHM_PARITY_N:
55 /* raid 4 isn't messed around by parity blocks */
56 if (block == -1)
57 return raid_disks-1; /* parity block */
58 return block;
59 case 500 + ALGORITHM_LEFT_ASYMMETRIC:
60 pd = (raid_disks-1) - stripe % raid_disks;
61 if (block == -1) return pd;
62 if (block >= pd)
63 block++;
64 return block;
65
66 case 500 + ALGORITHM_RIGHT_ASYMMETRIC:
67 pd = stripe % raid_disks;
68 if (block == -1) return pd;
69 if (block >= pd)
70 block++;
71 return block;
72
73 case 500 + ALGORITHM_LEFT_SYMMETRIC:
74 pd = (raid_disks - 1) - stripe % raid_disks;
75 if (block == -1) return pd;
76 return (pd + 1 + block) % raid_disks;
77
78 case 500 + ALGORITHM_RIGHT_SYMMETRIC:
79 pd = stripe % raid_disks;
80 if (block == -1) return pd;
81 return (pd + 1 + block) % raid_disks;
82
83 case 500 + ALGORITHM_PARITY_0:
84 return block + 1;
85
86
87 case 600 + ALGORITHM_PARITY_N_6:
88 if (block == -2)
89 return raid_disks - 1;
90 if (block == -1)
91 return raid_disks - 2; /* parity block */
92 return block;
93 case 600 + ALGORITHM_LEFT_ASYMMETRIC_6:
94 if (block == -2)
95 return raid_disks - 1;
96 raid_disks--;
97 pd = (raid_disks-1) - stripe % raid_disks;
98 if (block == -1) return pd;
99 if (block >= pd)
100 block++;
101 return block;
102
103 case 600 + ALGORITHM_RIGHT_ASYMMETRIC_6:
104 if (block == -2)
105 return raid_disks - 1;
106 raid_disks--;
107 pd = stripe % raid_disks;
108 if (block == -1) return pd;
109 if (block >= pd)
110 block++;
111 return block;
112
113 case 600 + ALGORITHM_LEFT_SYMMETRIC_6:
114 if (block == -2)
115 return raid_disks - 1;
116 raid_disks--;
117 pd = (raid_disks - 1) - stripe % raid_disks;
118 if (block == -1) return pd;
119 return (pd + 1 + block) % raid_disks;
120
121 case 600 + ALGORITHM_RIGHT_SYMMETRIC_6:
122 if (block == -2)
123 return raid_disks - 1;
124 raid_disks--;
125 pd = stripe % raid_disks;
126 if (block == -1) return pd;
127 return (pd + 1 + block) % raid_disks;
128
129 case 600 + ALGORITHM_PARITY_0_6:
130 if (block == -2)
131 return raid_disks - 1;
132 return block + 1;
133
134
135 case 600 + ALGORITHM_PARITY_0:
136 if (block == -1)
137 return 0;
138 if (block == -2)
139 return 1;
140 return block + 2;
141
142 case 600 + ALGORITHM_LEFT_ASYMMETRIC:
143 pd = raid_disks - 1 - (stripe % raid_disks);
144 if (block == -1) return pd;
145 if (block == -2) return (pd+1) % raid_disks;
146 if (pd == raid_disks - 1)
147 return block+1;
148 if (block >= pd)
149 return block+2;
150 return block;
151
152 case 600 + ALGORITHM_ROTATING_ZERO_RESTART:
153 /* Different order for calculating Q, otherwize same as ... */
154 case 600 + ALGORITHM_RIGHT_ASYMMETRIC:
155 pd = stripe % raid_disks;
156 if (block == -1) return pd;
157 if (block == -2) return (pd+1) % raid_disks;
158 if (pd == raid_disks - 1)
159 return block+1;
160 if (block >= pd)
161 return block+2;
162 return block;
163
164 case 600 + ALGORITHM_LEFT_SYMMETRIC:
165 pd = raid_disks - 1 - (stripe % raid_disks);
166 if (block == -1) return pd;
167 if (block == -2) return (pd+1) % raid_disks;
168 return (pd + 2 + block) % raid_disks;
169
170 case 600 + ALGORITHM_RIGHT_SYMMETRIC:
171 pd = stripe % raid_disks;
172 if (block == -1) return pd;
173 if (block == -2) return (pd+1) % raid_disks;
174 return (pd + 2 + block) % raid_disks;
175
176
177 case 600 + ALGORITHM_ROTATING_N_RESTART:
178 /* Same a left_asymmetric, by first stripe is
179 * D D D P Q rather than
180 * Q D D D P
181 */
182 pd = raid_disks - 1 - ((stripe + 1) % raid_disks);
183 if (block == -1) return pd;
184 if (block == -2) return (pd+1) % raid_disks;
185 if (pd == raid_disks - 1)
186 return block+1;
187 if (block >= pd)
188 return block+2;
189 return block;
190
191 case 600 + ALGORITHM_ROTATING_N_CONTINUE:
192 /* Same as left_symmetric but Q is before P */
193 pd = raid_disks - 1 - (stripe % raid_disks);
194 if (block == -1) return pd;
195 if (block == -2) return (pd+raid_disks-1) % raid_disks;
196 return (pd + 1 + block) % raid_disks;
197 }
198 return -1;
199 }
200 static int is_ddf(int layout)
201 {
202 switch (layout)
203 {
204 default:
205 return 0;
206 case ALGORITHM_ROTATING_N_CONTINUE:
207 case ALGORITHM_ROTATING_N_RESTART:
208 case ALGORITHM_ROTATING_ZERO_RESTART:
209 return 1;
210 }
211 }
212
213
214 void xor_blocks(char *target, char **sources, int disks, int size)
215 {
216 int i, j;
217 /* Amazingly inefficient... */
218 for (i=0; i<size; i++) {
219 char c = 0;
220 for (j=0 ; j<disks; j++)
221 c ^= sources[j][i];
222 target[i] = c;
223 }
224 }
225
226 void qsyndrome(uint8_t *p, uint8_t *q, uint8_t **sources, int disks, int size)
227 {
228 int d, z;
229 uint8_t wq0, wp0, wd0, w10, w20;
230 for ( d = 0; d < size; d++) {
231 wq0 = wp0 = sources[disks-1][d];
232 for ( z = disks-2 ; z >= 0 ; z-- ) {
233 wd0 = sources[z][d];
234 wp0 ^= wd0;
235 w20 = (wq0&0x80) ? 0xff : 0x00;
236 w10 = (wq0 << 1) & 0xff;
237 w20 &= 0x1d;
238 w10 ^= w20;
239 wq0 = w10 ^ wd0;
240 }
241 p[d] = wp0;
242 q[d] = wq0;
243 }
244 }
245
246
247 /*
248 * The following was taken from linux/drivers/md/mktables.c, and modified
249 * to create in-memory tables rather than C code
250 */
251 static uint8_t gfmul(uint8_t a, uint8_t b)
252 {
253 uint8_t v = 0;
254
255 while (b) {
256 if (b & 1)
257 v ^= a;
258 a = (a << 1) ^ (a & 0x80 ? 0x1d : 0);
259 b >>= 1;
260 }
261
262 return v;
263 }
264
265 static uint8_t gfpow(uint8_t a, int b)
266 {
267 uint8_t v = 1;
268
269 b %= 255;
270 if (b < 0)
271 b += 255;
272
273 while (b) {
274 if (b & 1)
275 v = gfmul(v, a);
276 a = gfmul(a, a);
277 b >>= 1;
278 }
279
280 return v;
281 }
282
283 int tables_ready = 0;
284 uint8_t raid6_gfmul[256][256];
285 uint8_t raid6_gfexp[256];
286 uint8_t raid6_gfinv[256];
287 uint8_t raid6_gfexi[256];
288 uint8_t raid6_gflog[256];
289 uint8_t raid6_gfilog[256];
290 void make_tables(void)
291 {
292 int i, j;
293 uint8_t v;
294 uint32_t b, log;
295
296 /* Compute multiplication table */
297 for (i = 0; i < 256; i++)
298 for (j = 0; j < 256; j++)
299 raid6_gfmul[i][j] = gfmul(i, j);
300
301 /* Compute power-of-2 table (exponent) */
302 v = 1;
303 for (i = 0; i < 256; i++) {
304 raid6_gfexp[i] = v;
305 v = gfmul(v, 2);
306 if (v == 1)
307 v = 0; /* For entry 255, not a real entry */
308 }
309
310 /* Compute inverse table x^-1 == x^254 */
311 for (i = 0; i < 256; i++)
312 raid6_gfinv[i] = gfpow(i, 254);
313
314 /* Compute inv(2^x + 1) (exponent-xor-inverse) table */
315 for (i = 0; i < 256; i ++)
316 raid6_gfexi[i] = raid6_gfinv[raid6_gfexp[i] ^ 1];
317
318 /* Compute log and inverse log */
319 /* Modified code from:
320 * http://web.eecs.utk.edu/~plank/plank/papers/CS-96-332.html
321 */
322 b = 1;
323 raid6_gflog[0] = 0;
324 raid6_gfilog[255] = 0;
325
326 for (log = 0; log < 255; log++) {
327 raid6_gflog[b] = (uint8_t) log;
328 raid6_gfilog[log] = (uint8_t) b;
329 b = b << 1;
330 if (b & 256) b = b ^ 0435;
331 }
332
333 tables_ready = 1;
334 }
335
336 uint8_t *zero;
337 int zero_size;
338
339 void ensure_zero_has_size(int chunk_size)
340 {
341 if (zero == NULL || chunk_size > zero_size) {
342 if (zero)
343 free(zero);
344 zero = xcalloc(1, chunk_size);
345 zero_size = chunk_size;
346 }
347 }
348
349 /* Following was taken from linux/drivers/md/raid6recov.c */
350
351 /* Recover two failed data blocks. */
352 void raid6_2data_recov(int disks, size_t bytes, int faila, int failb,
353 uint8_t **ptrs)
354 {
355 uint8_t *p, *q, *dp, *dq;
356 uint8_t px, qx, db;
357 const uint8_t *pbmul; /* P multiplier table for B data */
358 const uint8_t *qmul; /* Q multiplier table (for both) */
359
360 p = ptrs[disks-2];
361 q = ptrs[disks-1];
362
363 /* Compute syndrome with zero for the missing data pages
364 Use the dead data pages as temporary storage for
365 delta p and delta q */
366 dp = ptrs[faila];
367 ptrs[faila] = zero;
368 dq = ptrs[failb];
369 ptrs[failb] = zero;
370
371 qsyndrome(dp, dq, ptrs, disks-2, bytes);
372
373 /* Restore pointer table */
374 ptrs[faila] = dp;
375 ptrs[failb] = dq;
376
377 /* Now, pick the proper data tables */
378 pbmul = raid6_gfmul[raid6_gfexi[failb-faila]];
379 qmul = raid6_gfmul[raid6_gfinv[raid6_gfexp[faila]^raid6_gfexp[failb]]];
380
381 /* Now do it... */
382 while ( bytes-- ) {
383 px = *p ^ *dp;
384 qx = qmul[*q ^ *dq];
385 *dq++ = db = pbmul[px] ^ qx; /* Reconstructed B */
386 *dp++ = db ^ px; /* Reconstructed A */
387 p++; q++;
388 }
389 }
390
391 /* Recover failure of one data block plus the P block */
392 void raid6_datap_recov(int disks, size_t bytes, int faila, uint8_t **ptrs)
393 {
394 uint8_t *p, *q, *dq;
395 const uint8_t *qmul; /* Q multiplier table */
396
397 p = ptrs[disks-2];
398 q = ptrs[disks-1];
399
400 /* Compute syndrome with zero for the missing data page
401 Use the dead data page as temporary storage for delta q */
402 dq = ptrs[faila];
403 ptrs[faila] = zero;
404
405 qsyndrome(p, dq, ptrs, disks-2, bytes);
406
407 /* Restore pointer table */
408 ptrs[faila] = dq;
409
410 /* Now, pick the proper data tables */
411 qmul = raid6_gfmul[raid6_gfinv[raid6_gfexp[faila]]];
412
413 /* Now do it... */
414 while ( bytes-- ) {
415 *p++ ^= *dq = qmul[*q ^ *dq];
416 q++; dq++;
417 }
418 }
419
420 /* Try to find out if a specific disk has a problem */
421 int raid6_check_disks(int data_disks, int start, int chunk_size,
422 int level, int layout, int diskP, int diskQ,
423 char *p, char *q, char **stripes)
424 {
425 int i;
426 int data_id, diskD;
427 uint8_t Px, Qx;
428 int curr_broken_disk = -1;
429 int prev_broken_disk = -1;
430 int broken_status = 0;
431
432 for(i = 0; i < chunk_size; i++) {
433 Px = (uint8_t)stripes[diskP][i] ^ (uint8_t)p[i];
434 Qx = (uint8_t)stripes[diskQ][i] ^ (uint8_t)q[i];
435
436 if((Px != 0) && (Qx == 0))
437 curr_broken_disk = diskP;
438
439
440 if((Px == 0) && (Qx != 0))
441 curr_broken_disk = diskQ;
442
443
444 if((Px != 0) && (Qx != 0)) {
445 data_id = (raid6_gflog[Qx] - raid6_gflog[Px]);
446 if(data_id < 0) data_id += 255;
447 diskD = geo_map(data_id, start/chunk_size,
448 data_disks + 2, level, layout);
449 curr_broken_disk = diskD;
450 }
451
452 if((Px == 0) && (Qx == 0))
453 curr_broken_disk = curr_broken_disk;
454
455 if(curr_broken_disk >= data_disks + 2)
456 broken_status = 2;
457
458 switch(broken_status) {
459 case 0:
460 if(curr_broken_disk != -1) {
461 prev_broken_disk = curr_broken_disk;
462 broken_status = 1;
463 }
464 break;
465
466 case 1:
467 if(curr_broken_disk != prev_broken_disk)
468 broken_status = 2;
469 break;
470
471 case 2:
472 default:
473 curr_broken_disk = prev_broken_disk = -2;
474 break;
475 }
476 }
477
478 return curr_broken_disk;
479 }
480
481 /*******************************************************************************
482 * Function: save_stripes
483 * Description:
484 * Function reads data (only data without P and Q) from array and writes
485 * it to buf and opcjonaly to backup files
486 * Parameters:
487 * source : A list of 'fds' of the active disks.
488 * Some may be absent
489 * offsets : A list of offsets on disk belonging
490 * to the array [bytes]
491 * raid_disks : geometry: number of disks in the array
492 * chunk_size : geometry: chunk size [bytes]
493 * level : geometry: RAID level
494 * layout : geometry: layout
495 * nwrites : number of backup files
496 * dest : A list of 'fds' for mirrored targets
497 * (e.g. backup files). They are already seeked to right
498 * (write) location. If NULL, data will be wrote
499 * to the buf only
500 * start : start address of data to read (must be stripe-aligned)
501 * [bytes]
502 * length - : length of data to read (must be stripe-aligned)
503 * [bytes]
504 * buf : buffer for data. It is large enough to hold
505 * one stripe. It is stripe aligned
506 * Returns:
507 * 0 : success
508 * -1 : fail
509 ******************************************************************************/
510 int save_stripes(int *source, unsigned long long *offsets,
511 int raid_disks, int chunk_size, int level, int layout,
512 int nwrites, int *dest,
513 unsigned long long start, unsigned long long length,
514 char *buf)
515 {
516 int len;
517 int data_disks = raid_disks - (level == 0 ? 0 : level <=5 ? 1 : 2);
518 int disk;
519 int i;
520 unsigned long long length_test;
521
522 if (!tables_ready)
523 make_tables();
524 ensure_zero_has_size(chunk_size);
525
526 len = data_disks * chunk_size;
527 length_test = length / len;
528 length_test *= len;
529
530 if (length != length_test) {
531 dprintf("Error: save_stripes(): Data are not alligned. EXIT\n");
532 dprintf("\tArea for saving stripes (length) = %llu\n", length);
533 dprintf("\tWork step (len) = %i\n", len);
534 dprintf("\tExpected save area (length_test) = %llu\n",
535 length_test);
536 abort();
537 }
538
539 while (length > 0) {
540 int failed = 0;
541 int fdisk[3], fblock[3];
542 for (disk = 0; disk < raid_disks ; disk++) {
543 unsigned long long offset;
544 int dnum;
545
546 offset = (start/chunk_size/data_disks)*chunk_size;
547 dnum = geo_map(disk < data_disks ? disk : data_disks - disk - 1,
548 start/chunk_size/data_disks,
549 raid_disks, level, layout);
550 if (dnum < 0) abort();
551 if (source[dnum] < 0 ||
552 lseek64(source[dnum], offsets[dnum]+offset, 0) < 0 ||
553 read(source[dnum], buf+disk * chunk_size, chunk_size)
554 != chunk_size)
555 if (failed <= 2) {
556 fdisk[failed] = dnum;
557 fblock[failed] = disk;
558 failed++;
559 }
560 }
561 if (failed == 0 || fblock[0] >= data_disks)
562 /* all data disks are good */
563 ;
564 else if (failed == 1 || fblock[1] >= data_disks+1) {
565 /* one failed data disk and good parity */
566 char *bufs[data_disks];
567 for (i=0; i < data_disks; i++)
568 if (fblock[0] == i)
569 bufs[i] = buf + data_disks*chunk_size;
570 else
571 bufs[i] = buf + i*chunk_size;
572
573 xor_blocks(buf + fblock[0]*chunk_size,
574 bufs, data_disks, chunk_size);
575 } else if (failed > 2 || level != 6)
576 /* too much failure */
577 return -1;
578 else {
579 /* RAID6 computations needed. */
580 uint8_t *bufs[data_disks+4];
581 int qdisk;
582 int syndrome_disks;
583 disk = geo_map(-1, start/chunk_size/data_disks,
584 raid_disks, level, layout);
585 qdisk = geo_map(-2, start/chunk_size/data_disks,
586 raid_disks, level, layout);
587 if (is_ddf(layout)) {
588 /* q over 'raid_disks' blocks, in device order.
589 * 'p' and 'q' get to be all zero
590 */
591 for (i = 0; i < raid_disks; i++)
592 bufs[i] = zero;
593 for (i = 0; i < data_disks; i++) {
594 int dnum = geo_map(i,
595 start/chunk_size/data_disks,
596 raid_disks, level, layout);
597 int snum;
598 /* i is the logical block number, so is index to 'buf'.
599 * dnum is physical disk number
600 * and thus the syndrome number.
601 */
602 snum = dnum;
603 bufs[snum] = (uint8_t*)buf + chunk_size * i;
604 }
605 syndrome_disks = raid_disks;
606 } else {
607 /* for md, q is over 'data_disks' blocks,
608 * starting immediately after 'q'
609 * Note that for the '_6' variety, the p block
610 * makes a hole that we need to be careful of.
611 */
612 int j;
613 int snum = 0;
614 for (j = 0; j < raid_disks; j++) {
615 int dnum = (qdisk + 1 + j) % raid_disks;
616 if (dnum == disk || dnum == qdisk)
617 continue;
618 for (i = 0; i < data_disks; i++)
619 if (geo_map(i,
620 start/chunk_size/data_disks,
621 raid_disks, level, layout) == dnum)
622 break;
623 /* i is the logical block number, so is index to 'buf'.
624 * dnum is physical disk number
625 * snum is syndrome disk for which 0 is immediately after Q
626 */
627 bufs[snum] = (uint8_t*)buf + chunk_size * i;
628
629 if (fblock[0] == i)
630 fdisk[0] = snum;
631 if (fblock[1] == i)
632 fdisk[1] = snum;
633 snum++;
634 }
635
636 syndrome_disks = data_disks;
637 }
638
639 /* Place P and Q blocks at end of bufs */
640 bufs[syndrome_disks] = (uint8_t*)buf + chunk_size * data_disks;
641 bufs[syndrome_disks+1] = (uint8_t*)buf + chunk_size * (data_disks+1);
642
643 if (fblock[1] == data_disks)
644 /* One data failed, and parity failed */
645 raid6_datap_recov(syndrome_disks+2, chunk_size,
646 fdisk[0], bufs);
647 else {
648 if (fdisk[0] > fdisk[1]) {
649 int t = fdisk[0];
650 fdisk[0] = fdisk[1];
651 fdisk[1] = t;
652 }
653 /* Two data blocks failed, P,Q OK */
654 raid6_2data_recov(syndrome_disks+2, chunk_size,
655 fdisk[0], fdisk[1], bufs);
656 }
657 }
658 if (dest) {
659 for (i = 0; i < nwrites; i++)
660 if (write(dest[i], buf, len) != len)
661 return -1;
662 } else {
663 /* build next stripe in buffer */
664 buf += len;
665 }
666 length -= len;
667 start += len;
668 }
669 return 0;
670 }
671
672 /* Restore data:
673 * We are given:
674 * A list of 'fds' of the active disks. Some may be '-1' for not-available.
675 * A geometry: raid_disks, chunk_size, level, layout
676 * An 'fd' to read from. It is already seeked to the right (Read) location.
677 * A start and length.
678 * The length must be a multiple of the stripe size.
679 *
680 * We build a full stripe in memory and then write it out.
681 * We assume that there are enough working devices.
682 */
683 int restore_stripes(int *dest, unsigned long long *offsets,
684 int raid_disks, int chunk_size, int level, int layout,
685 int source, unsigned long long read_offset,
686 unsigned long long start, unsigned long long length,
687 char *src_buf)
688 {
689 char *stripe_buf;
690 char **stripes = xmalloc(raid_disks * sizeof(char*));
691 char **blocks = xmalloc(raid_disks * sizeof(char*));
692 int i;
693 int rv;
694
695 int data_disks = raid_disks - (level == 0 ? 0 : level <= 5 ? 1 : 2);
696
697 if (posix_memalign((void**)&stripe_buf, 4096, raid_disks * chunk_size))
698 stripe_buf = NULL;
699
700 if (zero == NULL || chunk_size > zero_size) {
701 if (zero)
702 free(zero);
703 zero = xcalloc(1, chunk_size);
704 zero_size = chunk_size;
705 }
706
707 if (stripe_buf == NULL || stripes == NULL || blocks == NULL
708 || zero == NULL) {
709 rv = -2;
710 goto abort;
711 }
712 for (i = 0; i < raid_disks; i++)
713 stripes[i] = stripe_buf + i * chunk_size;
714 while (length > 0) {
715 unsigned int len = data_disks * chunk_size;
716 unsigned long long offset;
717 int disk, qdisk;
718 int syndrome_disks;
719 if (length < len) {
720 rv = -3;
721 goto abort;
722 }
723 for (i = 0; i < data_disks; i++) {
724 int disk = geo_map(i, start/chunk_size/data_disks,
725 raid_disks, level, layout);
726 if (src_buf == NULL) {
727 /* read from file */
728 if (lseek64(source, read_offset, 0) !=
729 (off64_t)read_offset) {
730 rv = -1;
731 goto abort;
732 }
733 if (read(source,
734 stripes[disk],
735 chunk_size) != chunk_size) {
736 rv = -1;
737 goto abort;
738 }
739 } else {
740 /* read from input buffer */
741 memcpy(stripes[disk],
742 src_buf + read_offset,
743 chunk_size);
744 }
745 read_offset += chunk_size;
746 }
747 /* We have the data, now do the parity */
748 offset = (start/chunk_size/data_disks) * chunk_size;
749 switch (level) {
750 case 4:
751 case 5:
752 disk = geo_map(-1, start/chunk_size/data_disks,
753 raid_disks, level, layout);
754 for (i = 0; i < data_disks; i++)
755 blocks[i] = stripes[(disk+1+i) % raid_disks];
756 xor_blocks(stripes[disk], blocks, data_disks, chunk_size);
757 break;
758 case 6:
759 disk = geo_map(-1, start/chunk_size/data_disks,
760 raid_disks, level, layout);
761 qdisk = geo_map(-2, start/chunk_size/data_disks,
762 raid_disks, level, layout);
763 if (is_ddf(layout)) {
764 /* q over 'raid_disks' blocks, in device order.
765 * 'p' and 'q' get to be all zero
766 */
767 for (i = 0; i < raid_disks; i++)
768 if (i == disk || i == qdisk)
769 blocks[i] = (char*)zero;
770 else
771 blocks[i] = stripes[i];
772 syndrome_disks = raid_disks;
773 } else {
774 /* for md, q is over 'data_disks' blocks,
775 * starting immediately after 'q'
776 */
777 for (i = 0; i < data_disks; i++)
778 blocks[i] = stripes[(qdisk+1+i) % raid_disks];
779
780 syndrome_disks = data_disks;
781 }
782 qsyndrome((uint8_t*)stripes[disk],
783 (uint8_t*)stripes[qdisk],
784 (uint8_t**)blocks,
785 syndrome_disks, chunk_size);
786 break;
787 }
788 for (i=0; i < raid_disks ; i++)
789 if (dest[i] >= 0) {
790 if (lseek64(dest[i],
791 offsets[i]+offset, 0) < 0) {
792 rv = -1;
793 goto abort;
794 }
795 if (write(dest[i], stripes[i],
796 chunk_size) != chunk_size) {
797 rv = -1;
798 goto abort;
799 }
800 }
801 length -= len;
802 start += len;
803 }
804 rv = 0;
805
806 abort:
807 free(stripe_buf);
808 free(stripes);
809 free(blocks);
810 return rv;
811 }
812
813 #ifdef MAIN
814
815 int test_stripes(int *source, unsigned long long *offsets,
816 int raid_disks, int chunk_size, int level, int layout,
817 unsigned long long start, unsigned long long length)
818 {
819 /* ready the data and p (and q) blocks, and check we got them right */
820 char *stripe_buf = xmalloc(raid_disks * chunk_size);
821 char **stripes = xmalloc(raid_disks * sizeof(char*));
822 char **blocks = xmalloc(raid_disks * sizeof(char*));
823 char *p = xmalloc(chunk_size);
824 char *q = xmalloc(chunk_size);
825
826 int i;
827 int diskP, diskQ;
828 int data_disks = raid_disks - (level == 5 ? 1: 2);
829
830 if (!tables_ready)
831 make_tables();
832
833 for ( i = 0 ; i < raid_disks ; i++)
834 stripes[i] = stripe_buf + i * chunk_size;
835
836 while (length > 0) {
837 int disk;
838
839 for (i = 0 ; i < raid_disks ; i++) {
840 lseek64(source[i], offsets[i]+start, 0);
841 read(source[i], stripes[i], chunk_size);
842 }
843 for (i = 0 ; i < data_disks ; i++) {
844 int disk = geo_map(i, start/chunk_size, raid_disks,
845 level, layout);
846 blocks[i] = stripes[disk];
847 printf("%d->%d\n", i, disk);
848 }
849 switch(level) {
850 case 6:
851 qsyndrome(p, q, (uint8_t**)blocks, data_disks, chunk_size);
852 diskP = geo_map(-1, start/chunk_size, raid_disks,
853 level, layout);
854 if (memcmp(p, stripes[diskP], chunk_size) != 0) {
855 printf("P(%d) wrong at %llu\n", diskP,
856 start / chunk_size);
857 }
858 diskQ = geo_map(-2, start/chunk_size, raid_disks,
859 level, layout);
860 if (memcmp(q, stripes[diskQ], chunk_size) != 0) {
861 printf("Q(%d) wrong at %llu\n", diskQ,
862 start / chunk_size);
863 }
864 disk = raid6_check_disks(data_disks, start, chunk_size,
865 level, layout, diskP, diskQ,
866 p, q, stripes);
867 if(disk >= 0) {
868 printf("Possible failed disk: %d\n", disk);
869 }
870 if(disk == -2) {
871 printf("Failure detected, but disk unknown\n");
872 }
873 break;
874 }
875 length -= chunk_size;
876 start += chunk_size;
877 }
878 return 0;
879 }
880
881 unsigned long long getnum(char *str, char **err)
882 {
883 char *e;
884 unsigned long long rv = strtoull(str, &e, 10);
885 if (e==str || *e) {
886 *err = str;
887 return 0;
888 }
889 return rv;
890 }
891
892 main(int argc, char *argv[])
893 {
894 /* save/restore file raid_disks chunk_size level layout start length devices...
895 */
896 int save;
897 int *fds;
898 char *file;
899 char *buf;
900 int storefd;
901 unsigned long long *offsets;
902 int raid_disks, chunk_size, level, layout;
903 unsigned long long start, length;
904 int i;
905
906 char *err = NULL;
907 if (argc < 10) {
908 fprintf(stderr, "Usage: test_stripe save/restore file raid_disks"
909 " chunk_size level layout start length devices...\n");
910 exit(1);
911 }
912 if (strcmp(argv[1], "save")==0)
913 save = 1;
914 else if (strcmp(argv[1], "restore") == 0)
915 save = 0;
916 else if (strcmp(argv[1], "test") == 0)
917 save = 2;
918 else {
919 fprintf(stderr, "test_stripe: must give 'save' or 'restore'.\n");
920 exit(2);
921 }
922
923 file = argv[2];
924 raid_disks = getnum(argv[3], &err);
925 chunk_size = getnum(argv[4], &err);
926 level = getnum(argv[5], &err);
927 layout = getnum(argv[6], &err);
928 start = getnum(argv[7], &err);
929 length = getnum(argv[8], &err);
930 if (err) {
931 fprintf(stderr, "test_stripe: Bad number: %s\n", err);
932 exit(2);
933 }
934 if (argc != raid_disks + 9) {
935 fprintf(stderr, "test_stripe: wrong number of devices: want %d found %d\n",
936 raid_disks, argc-9);
937 exit(2);
938 }
939 fds = xmalloc(raid_disks * sizeof(*fds));
940 offsets = xcalloc(raid_disks, sizeof(*offsets));
941
942 storefd = open(file, O_RDWR);
943 if (storefd < 0) {
944 perror(file);
945 fprintf(stderr, "test_stripe: could not open %s.\n", file);
946 exit(3);
947 }
948 for (i=0; i<raid_disks; i++) {
949 char *p;
950 p = strchr(argv[9+i], ':');
951
952 if(p != NULL) {
953 *p++ = '\0';
954 offsets[i] = atoll(p) * 512;
955 }
956
957 fds[i] = open(argv[9+i], O_RDWR);
958 if (fds[i] < 0) {
959 perror(argv[9+i]);
960 fprintf(stderr,"test_stripe: cannot open %s.\n", argv[9+i]);
961 exit(3);
962 }
963 }
964
965 buf = xmalloc(raid_disks * chunk_size);
966
967 if (save == 1) {
968 int rv = save_stripes(fds, offsets,
969 raid_disks, chunk_size, level, layout,
970 1, &storefd,
971 start, length, buf);
972 if (rv != 0) {
973 fprintf(stderr,
974 "test_stripe: save_stripes returned %d\n", rv);
975 exit(1);
976 }
977 } else if (save == 2) {
978 int rv = test_stripes(fds, offsets,
979 raid_disks, chunk_size, level, layout,
980 start, length);
981 if (rv != 0) {
982 fprintf(stderr,
983 "test_stripe: test_stripes returned %d\n", rv);
984 exit(1);
985 }
986 } else {
987 int rv = restore_stripes(fds, offsets,
988 raid_disks, chunk_size, level, layout,
989 storefd, 0ULL,
990 start, length, NULL);
991 if (rv != 0) {
992 fprintf(stderr,
993 "test_stripe: restore_stripes returned %d\n",
994 rv);
995 exit(1);
996 }
997 }
998 exit(0);
999 }
1000
1001 #endif /* MAIN */
Unnamed repository; edit this file 'description' to name the repository.