| lh | 9ed821d | 2023-04-07 01:36:19 -0700 | [diff] [blame] | 1 | /* -*- linux-c -*- ------------------------------------------------------- * |
| 2 | * |
| 3 | * Copyright 2002 H. Peter Anvin - All Rights Reserved |
| 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License as published by |
| 7 | * the Free Software Foundation, Inc., 53 Temple Place Ste 330, |
| 8 | * Boston MA 02111-1307, USA; either version 2 of the License, or |
| 9 | * (at your option) any later version; incorporated herein by reference. |
| 10 | * |
| 11 | * ----------------------------------------------------------------------- */ |
| 12 | |
| 13 | /* |
| 14 | * raid6/recov.c |
| 15 | * |
| 16 | * RAID-6 data recovery in dual failure mode. In single failure mode, |
| 17 | * use the RAID-5 algorithm (or, in the case of Q failure, just reconstruct |
| 18 | * the syndrome.) |
| 19 | */ |
| 20 | |
| 21 | #include <linux/export.h> |
| 22 | #include <linux/raid/pq.h> |
| 23 | |
| 24 | /* Recover two failed data blocks. */ |
| 25 | void raid6_2data_recov(int disks, size_t bytes, int faila, int failb, |
| 26 | void **ptrs) |
| 27 | { |
| 28 | u8 *p, *q, *dp, *dq; |
| 29 | u8 px, qx, db; |
| 30 | const u8 *pbmul; /* P multiplier table for B data */ |
| 31 | const u8 *qmul; /* Q multiplier table (for both) */ |
| 32 | |
| 33 | p = (u8 *)ptrs[disks-2]; |
| 34 | q = (u8 *)ptrs[disks-1]; |
| 35 | |
| 36 | /* Compute syndrome with zero for the missing data pages |
| 37 | Use the dead data pages as temporary storage for |
| 38 | delta p and delta q */ |
| 39 | dp = (u8 *)ptrs[faila]; |
| 40 | ptrs[faila] = (void *)raid6_empty_zero_page; |
| 41 | ptrs[disks-2] = dp; |
| 42 | dq = (u8 *)ptrs[failb]; |
| 43 | ptrs[failb] = (void *)raid6_empty_zero_page; |
| 44 | ptrs[disks-1] = dq; |
| 45 | |
| 46 | raid6_call.gen_syndrome(disks, bytes, ptrs); |
| 47 | |
| 48 | /* Restore pointer table */ |
| 49 | ptrs[faila] = dp; |
| 50 | ptrs[failb] = dq; |
| 51 | ptrs[disks-2] = p; |
| 52 | ptrs[disks-1] = q; |
| 53 | |
| 54 | /* Now, pick the proper data tables */ |
| 55 | pbmul = raid6_gfmul[raid6_gfexi[failb-faila]]; |
| 56 | qmul = raid6_gfmul[raid6_gfinv[raid6_gfexp[faila]^raid6_gfexp[failb]]]; |
| 57 | |
| 58 | /* Now do it... */ |
| 59 | while ( bytes-- ) { |
| 60 | px = *p ^ *dp; |
| 61 | qx = qmul[*q ^ *dq]; |
| 62 | *dq++ = db = pbmul[px] ^ qx; /* Reconstructed B */ |
| 63 | *dp++ = db ^ px; /* Reconstructed A */ |
| 64 | p++; q++; |
| 65 | } |
| 66 | } |
| 67 | EXPORT_SYMBOL_GPL(raid6_2data_recov); |
| 68 | |
| 69 | /* Recover failure of one data block plus the P block */ |
| 70 | void raid6_datap_recov(int disks, size_t bytes, int faila, void **ptrs) |
| 71 | { |
| 72 | u8 *p, *q, *dq; |
| 73 | const u8 *qmul; /* Q multiplier table */ |
| 74 | |
| 75 | p = (u8 *)ptrs[disks-2]; |
| 76 | q = (u8 *)ptrs[disks-1]; |
| 77 | |
| 78 | /* Compute syndrome with zero for the missing data page |
| 79 | Use the dead data page as temporary storage for delta q */ |
| 80 | dq = (u8 *)ptrs[faila]; |
| 81 | ptrs[faila] = (void *)raid6_empty_zero_page; |
| 82 | ptrs[disks-1] = dq; |
| 83 | |
| 84 | raid6_call.gen_syndrome(disks, bytes, ptrs); |
| 85 | |
| 86 | /* Restore pointer table */ |
| 87 | ptrs[faila] = dq; |
| 88 | ptrs[disks-1] = q; |
| 89 | |
| 90 | /* Now, pick the proper data tables */ |
| 91 | qmul = raid6_gfmul[raid6_gfinv[raid6_gfexp[faila]]]; |
| 92 | |
| 93 | /* Now do it... */ |
| 94 | while ( bytes-- ) { |
| 95 | *p++ ^= *dq = qmul[*q ^ *dq]; |
| 96 | q++; dq++; |
| 97 | } |
| 98 | } |
| 99 | EXPORT_SYMBOL_GPL(raid6_datap_recov); |
| 100 | |
| 101 | #ifndef __KERNEL__ |
| 102 | /* Testing only */ |
| 103 | |
| 104 | /* Recover two failed blocks. */ |
| 105 | void raid6_dual_recov(int disks, size_t bytes, int faila, int failb, void **ptrs) |
| 106 | { |
| 107 | if ( faila > failb ) { |
| 108 | int tmp = faila; |
| 109 | faila = failb; |
| 110 | failb = tmp; |
| 111 | } |
| 112 | |
| 113 | if ( failb == disks-1 ) { |
| 114 | if ( faila == disks-2 ) { |
| 115 | /* P+Q failure. Just rebuild the syndrome. */ |
| 116 | raid6_call.gen_syndrome(disks, bytes, ptrs); |
| 117 | } else { |
| 118 | /* data+Q failure. Reconstruct data from P, |
| 119 | then rebuild syndrome. */ |
| 120 | /* NOT IMPLEMENTED - equivalent to RAID-5 */ |
| 121 | } |
| 122 | } else { |
| 123 | if ( failb == disks-2 ) { |
| 124 | /* data+P failure. */ |
| 125 | raid6_datap_recov(disks, bytes, faila, ptrs); |
| 126 | } else { |
| 127 | /* data+data failure. */ |
| 128 | raid6_2data_recov(disks, bytes, faila, failb, ptrs); |
| 129 | } |
| 130 | } |
| 131 | } |
| 132 | |
| 133 | #endif |