Branch data Line data Source code
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/algos.c
15 : : *
16 : : * Algorithm list and algorithm selection for RAID-6
17 : : */
18 : :
19 : : #include <linux/raid/pq.h>
20 : : #ifndef __KERNEL__
21 : : #include <sys/mman.h>
22 : : #include <stdio.h>
23 : : #else
24 : : #include <linux/module.h>
25 : : #include <linux/gfp.h>
26 : : #if !RAID6_USE_EMPTY_ZERO_PAGE
27 : : /* In .bss so it's zeroed */
28 : : const char raid6_empty_zero_page[PAGE_SIZE] __attribute__((aligned(256)));
29 : : EXPORT_SYMBOL(raid6_empty_zero_page);
30 : : #endif
31 : : #endif
32 : :
33 : : struct raid6_calls raid6_call;
34 : : EXPORT_SYMBOL_GPL(raid6_call);
35 : :
36 : : const struct raid6_calls * const raid6_algos[] = {
37 : : #if defined(__ia64__)
38 : : &raid6_intx16,
39 : : &raid6_intx32,
40 : : #endif
41 : : #if defined(__i386__) && !defined(__arch_um__)
42 : : &raid6_mmxx1,
43 : : &raid6_mmxx2,
44 : : &raid6_sse1x1,
45 : : &raid6_sse1x2,
46 : : &raid6_sse2x1,
47 : : &raid6_sse2x2,
48 : : #ifdef CONFIG_AS_AVX2
49 : : &raid6_avx2x1,
50 : : &raid6_avx2x2,
51 : : #endif
52 : : #endif
53 : : #if defined(__x86_64__) && !defined(__arch_um__)
54 : : &raid6_sse2x1,
55 : : &raid6_sse2x2,
56 : : &raid6_sse2x4,
57 : : #ifdef CONFIG_AS_AVX2
58 : : &raid6_avx2x1,
59 : : &raid6_avx2x2,
60 : : &raid6_avx2x4,
61 : : #endif
62 : : #endif
63 : : #ifdef CONFIG_ALTIVEC
64 : : &raid6_altivec1,
65 : : &raid6_altivec2,
66 : : &raid6_altivec4,
67 : : &raid6_altivec8,
68 : : #endif
69 : : #if defined(CONFIG_TILEGX)
70 : : &raid6_tilegx8,
71 : : #endif
72 : : &raid6_intx1,
73 : : &raid6_intx2,
74 : : &raid6_intx4,
75 : : &raid6_intx8,
76 : : #ifdef CONFIG_KERNEL_MODE_NEON
77 : : &raid6_neonx1,
78 : : &raid6_neonx2,
79 : : &raid6_neonx4,
80 : : &raid6_neonx8,
81 : : #endif
82 : : NULL
83 : : };
84 : :
85 : : void (*raid6_2data_recov)(int, size_t, int, int, void **);
86 : : EXPORT_SYMBOL_GPL(raid6_2data_recov);
87 : :
88 : : void (*raid6_datap_recov)(int, size_t, int, void **);
89 : : EXPORT_SYMBOL_GPL(raid6_datap_recov);
90 : :
91 : : const struct raid6_recov_calls *const raid6_recov_algos[] = {
92 : : #if (defined(__i386__) || defined(__x86_64__)) && !defined(__arch_um__)
93 : : #ifdef CONFIG_AS_AVX2
94 : : &raid6_recov_avx2,
95 : : #endif
96 : : &raid6_recov_ssse3,
97 : : #endif
98 : : &raid6_recov_intx1,
99 : : NULL
100 : : };
101 : :
102 : : #ifdef __KERNEL__
103 : : #define RAID6_TIME_JIFFIES_LG2 4
104 : : #else
105 : : /* Need more time to be stable in userspace */
106 : : #define RAID6_TIME_JIFFIES_LG2 9
107 : : #define time_before(x, y) ((x) < (y))
108 : : #endif
109 : :
110 : : static inline const struct raid6_recov_calls *raid6_choose_recov(void)
111 : : {
112 : : const struct raid6_recov_calls *const *algo;
113 : : const struct raid6_recov_calls *best;
114 : :
115 [ # # ]: 0 : for (best = NULL, algo = raid6_recov_algos; *algo; algo++)
116 [ # # ][ # # ]: 0 : if (!best || (*algo)->priority > best->priority)
117 [ # # ][ # # ]: 0 : if (!(*algo)->valid || (*algo)->valid())
118 : 0 : best = *algo;
119 : :
120 [ # # ]: 0 : if (best) {
121 : 0 : raid6_2data_recov = best->data2;
122 : 0 : raid6_datap_recov = best->datap;
123 : :
124 : 0 : printk("raid6: using %s recovery algorithm\n", best->name);
125 : : } else
126 : 0 : printk("raid6: Yikes! No recovery algorithm found!\n");
127 : :
128 : : return best;
129 : : }
130 : :
131 : : static inline const struct raid6_calls *raid6_choose_gen(
132 : : void *(*const dptrs)[(65536/PAGE_SIZE)+2], const int disks)
133 : : {
134 : : unsigned long perf, bestperf, j0, j1;
135 : : const struct raid6_calls *const *algo;
136 : : const struct raid6_calls *best;
137 : :
138 [ # # ]: 0 : for (bestperf = 0, best = NULL, algo = raid6_algos; *algo; algo++) {
139 [ # # ][ # # ]: 0 : if (!best || (*algo)->prefer >= best->prefer) {
140 [ # # ][ # # ]: 0 : if ((*algo)->valid && !(*algo)->valid())
141 : 0 : continue;
142 : :
143 : : perf = 0;
144 : :
145 : 0 : preempt_disable();
146 : 0 : j0 = jiffies;
147 [ # # ]: 0 : while ((j1 = jiffies) == j0)
148 : 0 : cpu_relax();
149 [ # # ]: 0 : while (time_before(jiffies,
150 : : j1 + (1<<RAID6_TIME_JIFFIES_LG2))) {
151 : 0 : (*algo)->gen_syndrome(disks, PAGE_SIZE, *dptrs);
152 : 0 : perf++;
153 : : }
154 : 0 : preempt_enable();
155 : :
156 [ # # ]: 0 : if (perf > bestperf) {
157 : : bestperf = perf;
158 : 0 : best = *algo;
159 : : }
160 : 0 : printk("raid6: %-8s %5ld MB/s\n", (*algo)->name,
161 : 0 : (perf*HZ) >> (20-16+RAID6_TIME_JIFFIES_LG2));
162 : : }
163 : : }
164 : :
165 [ # # ]: 0 : if (best) {
166 : 0 : printk("raid6: using algorithm %s (%ld MB/s)\n",
167 : : best->name,
168 : 0 : (bestperf*HZ) >> (20-16+RAID6_TIME_JIFFIES_LG2));
169 : 0 : raid6_call = *best;
170 : : } else
171 : 0 : printk("raid6: Yikes! No algorithm found!\n");
172 : :
173 : : return best;
174 : : }
175 : :
176 : :
177 : : /* Try to pick the best algorithm */
178 : : /* This code uses the gfmul table as convenient data set to abuse */
179 : :
180 : 0 : int __init raid6_select_algo(void)
181 : : {
182 : : const int disks = (65536/PAGE_SIZE)+2;
183 : :
184 : : const struct raid6_calls *gen_best;
185 : : const struct raid6_recov_calls *rec_best;
186 : : char *syndromes;
187 : : void *dptrs[(65536/PAGE_SIZE)+2];
188 : : int i;
189 : :
190 [ # # ]: 0 : for (i = 0; i < disks-2; i++)
191 : 0 : dptrs[i] = ((char *)raid6_gfmul) + PAGE_SIZE*i;
192 : :
193 : : /* Normal code - use a 2-page allocation to avoid D$ conflict */
194 : 0 : syndromes = (void *) __get_free_pages(GFP_KERNEL, 1);
195 : :
196 [ # # ]: 0 : if (!syndromes) {
197 : 0 : printk("raid6: Yikes! No memory available.\n");
198 : 0 : return -ENOMEM;
199 : : }
200 : :
201 : 0 : dptrs[disks-2] = syndromes;
202 : 0 : dptrs[disks-1] = syndromes + PAGE_SIZE;
203 : :
204 : : /* select raid gen_syndrome function */
205 : : gen_best = raid6_choose_gen(&dptrs, disks);
206 : :
207 : : /* select raid recover functions */
208 : : rec_best = raid6_choose_recov();
209 : :
210 : 0 : free_pages((unsigned long)syndromes, 1);
211 : :
212 [ # # ]: 0 : return gen_best && rec_best ? 0 : -EINVAL;
213 : : }
214 : :
215 : 0 : static void raid6_exit(void)
216 : : {
217 : : do { } while (0);
218 : 0 : }
219 : :
220 : : subsys_initcall(raid6_select_algo);
221 : : module_exit(raid6_exit);
222 : : MODULE_LICENSE("GPL");
223 : : MODULE_DESCRIPTION("RAID6 Q-syndrome calculations");
|
