tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

lib/raid6: replace custom zero page with ZERO_PAGE

Use the system-wide zero page instead of a custom zero page.

[herbert@gondor.apana.org.au: update lib/raid6/recov_rvv.c, per Klara]
Link: https://lkml.kernel.org/r/aFkUnXWtxcgOTVkw@gondor.apana.org.au
Link: https://lkml.kernel.org/r/Z9flJNkWQICx0PXk@gondor.apana.org.au
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Cc: Song Liu <song@kernel.org>
Cc: Yu Kuai <yukuai3@huawei.com>
Cc: Klara Modin <klarasmodin@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

authored by

Herbert Xu and committed by
Andrew Morton 1857fcc8 41a7f737

+38 -31
+1 -1
crypto/async_tx/async_pq.c
··· 119 119 for (i = 0; i < disks; i++) { 120 120 if (blocks[i] == NULL) { 121 121 BUG_ON(i > disks - 3); /* P or Q can't be zero */ 122 - srcs[i] = (void*)raid6_empty_zero_page; 122 + srcs[i] = raid6_get_zero_page(); 123 123 } else { 124 124 srcs[i] = page_address(blocks[i]) + offsets[i]; 125 125
+2 -2
crypto/async_tx/async_raid6_recov.c
··· 414 414 async_tx_quiesce(&submit->depend_tx); 415 415 for (i = 0; i < disks; i++) 416 416 if (blocks[i] == NULL) 417 - ptrs[i] = (void *) raid6_empty_zero_page; 417 + ptrs[i] = raid6_get_zero_page(); 418 418 else 419 419 ptrs[i] = page_address(blocks[i]) + offs[i]; 420 420 ··· 497 497 async_tx_quiesce(&submit->depend_tx); 498 498 for (i = 0; i < disks; i++) 499 499 if (blocks[i] == NULL) 500 - ptrs[i] = (void*)raid6_empty_zero_page; 500 + ptrs[i] = raid6_get_zero_page(); 501 501 else 502 502 ptrs[i] = page_address(blocks[i]) + offs[i]; 503 503
+11 -1
include/linux/raid/pq.h
··· 11 11 #ifdef __KERNEL__ 12 12 13 13 #include <linux/blkdev.h> 14 + #include <linux/mm.h> 14 15 15 - extern const char raid6_empty_zero_page[PAGE_SIZE]; 16 + /* This should be const but the raid6 code is too convoluted for that. */ 17 + static inline void *raid6_get_zero_page(void) 18 + { 19 + return page_address(ZERO_PAGE(0)); 20 + } 16 21 17 22 #else /* ! __KERNEL__ */ 18 23 /* Used for testing in user space */ ··· 194 189 struct timeval tv; 195 190 gettimeofday(&tv, NULL); 196 191 return tv.tv_sec*1000 + tv.tv_usec/1000; 192 + } 193 + 194 + static inline void *raid6_get_zero_page(void) 195 + { 196 + return raid6_empty_zero_page; 197 197 } 198 198 199 199 #endif /* ! __KERNEL__ */
-3
lib/raid6/algos.c
··· 18 18 #else 19 19 #include <linux/module.h> 20 20 #include <linux/gfp.h> 21 - /* In .bss so it's zeroed */ 22 - const char raid6_empty_zero_page[PAGE_SIZE] __attribute__((aligned(256))); 23 - EXPORT_SYMBOL(raid6_empty_zero_page); 24 21 #endif 25 22 26 23 struct raid6_calls raid6_call;
+3 -3
lib/raid6/recov.c
··· 31 31 Use the dead data pages as temporary storage for 32 32 delta p and delta q */ 33 33 dp = (u8 *)ptrs[faila]; 34 - ptrs[faila] = (void *)raid6_empty_zero_page; 34 + ptrs[faila] = raid6_get_zero_page(); 35 35 ptrs[disks-2] = dp; 36 36 dq = (u8 *)ptrs[failb]; 37 - ptrs[failb] = (void *)raid6_empty_zero_page; 37 + ptrs[failb] = raid6_get_zero_page(); 38 38 ptrs[disks-1] = dq; 39 39 40 40 raid6_call.gen_syndrome(disks, bytes, ptrs); ··· 72 72 /* Compute syndrome with zero for the missing data page 73 73 Use the dead data page as temporary storage for delta q */ 74 74 dq = (u8 *)ptrs[faila]; 75 - ptrs[faila] = (void *)raid6_empty_zero_page; 75 + ptrs[faila] = raid6_get_zero_page(); 76 76 ptrs[disks-1] = dq; 77 77 78 78 raid6_call.gen_syndrome(disks, bytes, ptrs);
+3 -3
lib/raid6/recov_avx2.c
··· 28 28 Use the dead data pages as temporary storage for 29 29 delta p and delta q */ 30 30 dp = (u8 *)ptrs[faila]; 31 - ptrs[faila] = (void *)raid6_empty_zero_page; 31 + ptrs[faila] = raid6_get_zero_page(); 32 32 ptrs[disks-2] = dp; 33 33 dq = (u8 *)ptrs[failb]; 34 - ptrs[failb] = (void *)raid6_empty_zero_page; 34 + ptrs[failb] = raid6_get_zero_page(); 35 35 ptrs[disks-1] = dq; 36 36 37 37 raid6_call.gen_syndrome(disks, bytes, ptrs); ··· 196 196 /* Compute syndrome with zero for the missing data page 197 197 Use the dead data page as temporary storage for delta q */ 198 198 dq = (u8 *)ptrs[faila]; 199 - ptrs[faila] = (void *)raid6_empty_zero_page; 199 + ptrs[faila] = raid6_get_zero_page(); 200 200 ptrs[disks-1] = dq; 201 201 202 202 raid6_call.gen_syndrome(disks, bytes, ptrs);
+3 -3
lib/raid6/recov_avx512.c
··· 37 37 */ 38 38 39 39 dp = (u8 *)ptrs[faila]; 40 - ptrs[faila] = (void *)raid6_empty_zero_page; 40 + ptrs[faila] = raid6_get_zero_page(); 41 41 ptrs[disks-2] = dp; 42 42 dq = (u8 *)ptrs[failb]; 43 - ptrs[failb] = (void *)raid6_empty_zero_page; 43 + ptrs[failb] = raid6_get_zero_page(); 44 44 ptrs[disks-1] = dq; 45 45 46 46 raid6_call.gen_syndrome(disks, bytes, ptrs); ··· 238 238 */ 239 239 240 240 dq = (u8 *)ptrs[faila]; 241 - ptrs[faila] = (void *)raid6_empty_zero_page; 241 + ptrs[faila] = raid6_get_zero_page(); 242 242 ptrs[disks-1] = dq; 243 243 244 244 raid6_call.gen_syndrome(disks, bytes, ptrs);
+6 -6
lib/raid6/recov_loongarch_simd.c
··· 42 42 * delta p and delta q 43 43 */ 44 44 dp = (u8 *)ptrs[faila]; 45 - ptrs[faila] = (void *)raid6_empty_zero_page; 45 + ptrs[faila] = raid6_get_zero_page(); 46 46 ptrs[disks - 2] = dp; 47 47 dq = (u8 *)ptrs[failb]; 48 - ptrs[failb] = (void *)raid6_empty_zero_page; 48 + ptrs[failb] = raid6_get_zero_page(); 49 49 ptrs[disks - 1] = dq; 50 50 51 51 raid6_call.gen_syndrome(disks, bytes, ptrs); ··· 197 197 * Use the dead data page as temporary storage for delta q 198 198 */ 199 199 dq = (u8 *)ptrs[faila]; 200 - ptrs[faila] = (void *)raid6_empty_zero_page; 200 + ptrs[faila] = raid6_get_zero_page(); 201 201 ptrs[disks - 1] = dq; 202 202 203 203 raid6_call.gen_syndrome(disks, bytes, ptrs); ··· 316 316 * delta p and delta q 317 317 */ 318 318 dp = (u8 *)ptrs[faila]; 319 - ptrs[faila] = (void *)raid6_empty_zero_page; 319 + ptrs[faila] = raid6_get_zero_page(); 320 320 ptrs[disks - 2] = dp; 321 321 dq = (u8 *)ptrs[failb]; 322 - ptrs[failb] = (void *)raid6_empty_zero_page; 322 + ptrs[failb] = raid6_get_zero_page(); 323 323 ptrs[disks - 1] = dq; 324 324 325 325 raid6_call.gen_syndrome(disks, bytes, ptrs); ··· 436 436 * Use the dead data page as temporary storage for delta q 437 437 */ 438 438 dq = (u8 *)ptrs[faila]; 439 - ptrs[faila] = (void *)raid6_empty_zero_page; 439 + ptrs[faila] = raid6_get_zero_page(); 440 440 ptrs[disks - 1] = dq; 441 441 442 442 raid6_call.gen_syndrome(disks, bytes, ptrs);
+3 -3
lib/raid6/recov_neon.c
··· 36 36 * delta p and delta q 37 37 */ 38 38 dp = (u8 *)ptrs[faila]; 39 - ptrs[faila] = (void *)raid6_empty_zero_page; 39 + ptrs[faila] = raid6_get_zero_page(); 40 40 ptrs[disks - 2] = dp; 41 41 dq = (u8 *)ptrs[failb]; 42 - ptrs[failb] = (void *)raid6_empty_zero_page; 42 + ptrs[failb] = raid6_get_zero_page(); 43 43 ptrs[disks - 1] = dq; 44 44 45 45 raid6_call.gen_syndrome(disks, bytes, ptrs); ··· 74 74 * Use the dead data page as temporary storage for delta q 75 75 */ 76 76 dq = (u8 *)ptrs[faila]; 77 - ptrs[faila] = (void *)raid6_empty_zero_page; 77 + ptrs[faila] = raid6_get_zero_page(); 78 78 ptrs[disks - 1] = dq; 79 79 80 80 raid6_call.gen_syndrome(disks, bytes, ptrs);
+3 -3
lib/raid6/recov_s390xc.c
··· 35 35 Use the dead data pages as temporary storage for 36 36 delta p and delta q */ 37 37 dp = (u8 *)ptrs[faila]; 38 - ptrs[faila] = (void *)raid6_empty_zero_page; 38 + ptrs[faila] = raid6_get_zero_page(); 39 39 ptrs[disks-2] = dp; 40 40 dq = (u8 *)ptrs[failb]; 41 - ptrs[failb] = (void *)raid6_empty_zero_page; 41 + ptrs[failb] = raid6_get_zero_page(); 42 42 ptrs[disks-1] = dq; 43 43 44 44 raid6_call.gen_syndrome(disks, bytes, ptrs); ··· 82 82 /* Compute syndrome with zero for the missing data page 83 83 Use the dead data page as temporary storage for delta q */ 84 84 dq = (u8 *)ptrs[faila]; 85 - ptrs[faila] = (void *)raid6_empty_zero_page; 85 + ptrs[faila] = raid6_get_zero_page(); 86 86 ptrs[disks-1] = dq; 87 87 88 88 raid6_call.gen_syndrome(disks, bytes, ptrs);
+3 -3
lib/raid6/recov_ssse3.c
··· 30 30 Use the dead data pages as temporary storage for 31 31 delta p and delta q */ 32 32 dp = (u8 *)ptrs[faila]; 33 - ptrs[faila] = (void *)raid6_empty_zero_page; 33 + ptrs[faila] = raid6_get_zero_page(); 34 34 ptrs[disks-2] = dp; 35 35 dq = (u8 *)ptrs[failb]; 36 - ptrs[failb] = (void *)raid6_empty_zero_page; 36 + ptrs[failb] = raid6_get_zero_page(); 37 37 ptrs[disks-1] = dq; 38 38 39 39 raid6_call.gen_syndrome(disks, bytes, ptrs); ··· 203 203 /* Compute syndrome with zero for the missing data page 204 204 Use the dead data page as temporary storage for delta q */ 205 205 dq = (u8 *)ptrs[faila]; 206 - ptrs[faila] = (void *)raid6_empty_zero_page; 206 + ptrs[faila] = raid6_get_zero_page(); 207 207 ptrs[disks-1] = dq; 208 208 209 209 raid6_call.gen_syndrome(disks, bytes, ptrs);