md/raid6: move raid6 data processing to raid6_pq.ko
[linux-2.6.git] / drivers / md / raid6test / test.c
1 /* -*- linux-c -*- ------------------------------------------------------- *
2  *
3  *   Copyright 2002-2007 H. Peter Anvin - All Rights Reserved
4  *
5  *   This file is part of the Linux kernel, and is made available under
6  *   the terms of the GNU General Public License version 2 or (at your
7  *   option) any later version; incorporated herein by reference.
8  *
9  * ----------------------------------------------------------------------- */
10
11 /*
12  * raid6test.c
13  *
14  * Test RAID-6 recovery with various algorithms
15  */
16
17 #include <stdlib.h>
18 #include <stdio.h>
19 #include <string.h>
20 #include <linux/raid/pq.h>
21
22 #define NDISKS          16      /* Including P and Q */
23
24 const char raid6_empty_zero_page[PAGE_SIZE] __attribute__((aligned(256)));
25 struct raid6_calls raid6_call;
26
27 char *dataptrs[NDISKS];
28 char data[NDISKS][PAGE_SIZE];
29 char recovi[PAGE_SIZE], recovj[PAGE_SIZE];
30
31 static void makedata(void)
32 {
33         int i, j;
34
35         for (i = 0; i < NDISKS; i++) {
36                 for (j = 0; j < PAGE_SIZE; j++)
37                         data[i][j] = rand();
38
39                 dataptrs[i] = data[i];
40         }
41 }
42
43 static char disk_type(int d)
44 {
45         switch (d) {
46         case NDISKS-2:
47                 return 'P';
48         case NDISKS-1:
49                 return 'Q';
50         default:
51                 return 'D';
52         }
53 }
54
55 static int test_disks(int i, int j)
56 {
57         int erra, errb;
58
59         memset(recovi, 0xf0, PAGE_SIZE);
60         memset(recovj, 0xba, PAGE_SIZE);
61
62         dataptrs[i] = recovi;
63         dataptrs[j] = recovj;
64
65         raid6_dual_recov(NDISKS, PAGE_SIZE, i, j, (void **)&dataptrs);
66
67         erra = memcmp(data[i], recovi, PAGE_SIZE);
68         errb = memcmp(data[j], recovj, PAGE_SIZE);
69
70         if (i < NDISKS-2 && j == NDISKS-1) {
71                 /* We don't implement the DQ failure scenario, since it's
72                    equivalent to a RAID-5 failure (XOR, then recompute Q) */
73                 erra = errb = 0;
74         } else {
75                 printf("algo=%-8s  faila=%3d(%c)  failb=%3d(%c)  %s\n",
76                        raid6_call.name,
77                        i, disk_type(i),
78                        j, disk_type(j),
79                        (!erra && !errb) ? "OK" :
80                        !erra ? "ERRB" :
81                        !errb ? "ERRA" : "ERRAB");
82         }
83
84         dataptrs[i] = data[i];
85         dataptrs[j] = data[j];
86
87         return erra || errb;
88 }
89
90 int main(int argc, char *argv[])
91 {
92         const struct raid6_calls *const *algo;
93         int i, j;
94         int err = 0;
95
96         makedata();
97
98         for (algo = raid6_algos; *algo; algo++) {
99                 if (!(*algo)->valid || (*algo)->valid()) {
100                         raid6_call = **algo;
101
102                         /* Nuke syndromes */
103                         memset(data[NDISKS-2], 0xee, 2*PAGE_SIZE);
104
105                         /* Generate assumed good syndrome */
106                         raid6_call.gen_syndrome(NDISKS, PAGE_SIZE,
107                                                 (void **)&dataptrs);
108
109                         for (i = 0; i < NDISKS-1; i++)
110                                 for (j = i+1; j < NDISKS; j++)
111                                         err += test_disks(i, j);
112                 }
113                 printf("\n");
114         }
115
116         printf("\n");
117         /* Pick the best algorithm test */
118         raid6_select_algo();
119
120         if (err)
121                 printf("\n*** ERRORS FOUND ***\n");
122
123         return err;
124 }