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.

Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6

Pull crypto fixes from Herbert Xu:
"This push fixes a memory corruption issue in caam, as well as
reverting the new optimised crct10dif implementation as it breaks boot
on initrd systems.

Hopefully crct10dif will be reinstated once the supporting code is
added so that it doesn't break boot"

* git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6:
Revert "crypto: crct10dif - Wrap crc_t10dif function all to use crypto transform framework"
crypto: caam - Fixed the memory out of bound overwrite issue

Linus Torvalds b48a97be 04012e30

+44 -1082
-2
arch/x86/crypto/Makefile
··· 27 27 obj-$(CONFIG_CRYPTO_CRC32_PCLMUL) += crc32-pclmul.o 28 28 obj-$(CONFIG_CRYPTO_SHA256_SSSE3) += sha256-ssse3.o 29 29 obj-$(CONFIG_CRYPTO_SHA512_SSSE3) += sha512-ssse3.o 30 - obj-$(CONFIG_CRYPTO_CRCT10DIF_PCLMUL) += crct10dif-pclmul.o 31 30 32 31 # These modules require assembler to support AVX. 33 32 ifeq ($(avx_supported),yes) ··· 81 82 crc32-pclmul-y := crc32-pclmul_asm.o crc32-pclmul_glue.o 82 83 sha256-ssse3-y := sha256-ssse3-asm.o sha256-avx-asm.o sha256-avx2-asm.o sha256_ssse3_glue.o 83 84 sha512-ssse3-y := sha512-ssse3-asm.o sha512-avx-asm.o sha512-avx2-asm.o sha512_ssse3_glue.o 84 - crct10dif-pclmul-y := crct10dif-pcl-asm_64.o crct10dif-pclmul_glue.o
-643
arch/x86/crypto/crct10dif-pcl-asm_64.S
··· 1 - ######################################################################## 2 - # Implement fast CRC-T10DIF computation with SSE and PCLMULQDQ instructions 3 - # 4 - # Copyright (c) 2013, Intel Corporation 5 - # 6 - # Authors: 7 - # Erdinc Ozturk <erdinc.ozturk@intel.com> 8 - # Vinodh Gopal <vinodh.gopal@intel.com> 9 - # James Guilford <james.guilford@intel.com> 10 - # Tim Chen <tim.c.chen@linux.intel.com> 11 - # 12 - # This software is available to you under a choice of one of two 13 - # licenses. You may choose to be licensed under the terms of the GNU 14 - # General Public License (GPL) Version 2, available from the file 15 - # COPYING in the main directory of this source tree, or the 16 - # OpenIB.org BSD license below: 17 - # 18 - # Redistribution and use in source and binary forms, with or without 19 - # modification, are permitted provided that the following conditions are 20 - # met: 21 - # 22 - # * Redistributions of source code must retain the above copyright 23 - # notice, this list of conditions and the following disclaimer. 24 - # 25 - # * Redistributions in binary form must reproduce the above copyright 26 - # notice, this list of conditions and the following disclaimer in the 27 - # documentation and/or other materials provided with the 28 - # distribution. 29 - # 30 - # * Neither the name of the Intel Corporation nor the names of its 31 - # contributors may be used to endorse or promote products derived from 32 - # this software without specific prior written permission. 33 - # 34 - # 35 - # THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION ""AS IS"" AND ANY 36 - # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 37 - # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 38 - # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR 39 - # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 40 - # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 41 - # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 42 - # PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 43 - # LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 44 - # NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 45 - # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 46 - ######################################################################## 47 - # Function API: 48 - # UINT16 crc_t10dif_pcl( 49 - # UINT16 init_crc, //initial CRC value, 16 bits 50 - # const unsigned char *buf, //buffer pointer to calculate CRC on 51 - # UINT64 len //buffer length in bytes (64-bit data) 52 - # ); 53 - # 54 - # Reference paper titled "Fast CRC Computation for Generic 55 - # Polynomials Using PCLMULQDQ Instruction" 56 - # URL: http://www.intel.com/content/dam/www/public/us/en/documents 57 - # /white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf 58 - # 59 - # 60 - 61 - #include <linux/linkage.h> 62 - 63 - .text 64 - 65 - #define arg1 %rdi 66 - #define arg2 %rsi 67 - #define arg3 %rdx 68 - 69 - #define arg1_low32 %edi 70 - 71 - ENTRY(crc_t10dif_pcl) 72 - .align 16 73 - 74 - # adjust the 16-bit initial_crc value, scale it to 32 bits 75 - shl $16, arg1_low32 76 - 77 - # Allocate Stack Space 78 - mov %rsp, %rcx 79 - sub $16*2, %rsp 80 - # align stack to 16 byte boundary 81 - and $~(0x10 - 1), %rsp 82 - 83 - # check if smaller than 256 84 - cmp $256, arg3 85 - 86 - # for sizes less than 128, we can't fold 64B at a time... 87 - jl _less_than_128 88 - 89 - 90 - # load the initial crc value 91 - movd arg1_low32, %xmm10 # initial crc 92 - 93 - # crc value does not need to be byte-reflected, but it needs 94 - # to be moved to the high part of the register. 95 - # because data will be byte-reflected and will align with 96 - # initial crc at correct place. 97 - pslldq $12, %xmm10 98 - 99 - movdqa SHUF_MASK(%rip), %xmm11 100 - # receive the initial 64B data, xor the initial crc value 101 - movdqu 16*0(arg2), %xmm0 102 - movdqu 16*1(arg2), %xmm1 103 - movdqu 16*2(arg2), %xmm2 104 - movdqu 16*3(arg2), %xmm3 105 - movdqu 16*4(arg2), %xmm4 106 - movdqu 16*5(arg2), %xmm5 107 - movdqu 16*6(arg2), %xmm6 108 - movdqu 16*7(arg2), %xmm7 109 - 110 - pshufb %xmm11, %xmm0 111 - # XOR the initial_crc value 112 - pxor %xmm10, %xmm0 113 - pshufb %xmm11, %xmm1 114 - pshufb %xmm11, %xmm2 115 - pshufb %xmm11, %xmm3 116 - pshufb %xmm11, %xmm4 117 - pshufb %xmm11, %xmm5 118 - pshufb %xmm11, %xmm6 119 - pshufb %xmm11, %xmm7 120 - 121 - movdqa rk3(%rip), %xmm10 #xmm10 has rk3 and rk4 122 - #imm value of pclmulqdq instruction 123 - #will determine which constant to use 124 - 125 - ################################################################# 126 - # we subtract 256 instead of 128 to save one instruction from the loop 127 - sub $256, arg3 128 - 129 - # at this section of the code, there is 64*x+y (0<=y<64) bytes of 130 - # buffer. The _fold_64_B_loop will fold 64B at a time 131 - # until we have 64+y Bytes of buffer 132 - 133 - 134 - # fold 64B at a time. This section of the code folds 4 xmm 135 - # registers in parallel 136 - _fold_64_B_loop: 137 - 138 - # update the buffer pointer 139 - add $128, arg2 # buf += 64# 140 - 141 - movdqu 16*0(arg2), %xmm9 142 - movdqu 16*1(arg2), %xmm12 143 - pshufb %xmm11, %xmm9 144 - pshufb %xmm11, %xmm12 145 - movdqa %xmm0, %xmm8 146 - movdqa %xmm1, %xmm13 147 - pclmulqdq $0x0 , %xmm10, %xmm0 148 - pclmulqdq $0x11, %xmm10, %xmm8 149 - pclmulqdq $0x0 , %xmm10, %xmm1 150 - pclmulqdq $0x11, %xmm10, %xmm13 151 - pxor %xmm9 , %xmm0 152 - xorps %xmm8 , %xmm0 153 - pxor %xmm12, %xmm1 154 - xorps %xmm13, %xmm1 155 - 156 - movdqu 16*2(arg2), %xmm9 157 - movdqu 16*3(arg2), %xmm12 158 - pshufb %xmm11, %xmm9 159 - pshufb %xmm11, %xmm12 160 - movdqa %xmm2, %xmm8 161 - movdqa %xmm3, %xmm13 162 - pclmulqdq $0x0, %xmm10, %xmm2 163 - pclmulqdq $0x11, %xmm10, %xmm8 164 - pclmulqdq $0x0, %xmm10, %xmm3 165 - pclmulqdq $0x11, %xmm10, %xmm13 166 - pxor %xmm9 , %xmm2 167 - xorps %xmm8 , %xmm2 168 - pxor %xmm12, %xmm3 169 - xorps %xmm13, %xmm3 170 - 171 - movdqu 16*4(arg2), %xmm9 172 - movdqu 16*5(arg2), %xmm12 173 - pshufb %xmm11, %xmm9 174 - pshufb %xmm11, %xmm12 175 - movdqa %xmm4, %xmm8 176 - movdqa %xmm5, %xmm13 177 - pclmulqdq $0x0, %xmm10, %xmm4 178 - pclmulqdq $0x11, %xmm10, %xmm8 179 - pclmulqdq $0x0, %xmm10, %xmm5 180 - pclmulqdq $0x11, %xmm10, %xmm13 181 - pxor %xmm9 , %xmm4 182 - xorps %xmm8 , %xmm4 183 - pxor %xmm12, %xmm5 184 - xorps %xmm13, %xmm5 185 - 186 - movdqu 16*6(arg2), %xmm9 187 - movdqu 16*7(arg2), %xmm12 188 - pshufb %xmm11, %xmm9 189 - pshufb %xmm11, %xmm12 190 - movdqa %xmm6 , %xmm8 191 - movdqa %xmm7 , %xmm13 192 - pclmulqdq $0x0 , %xmm10, %xmm6 193 - pclmulqdq $0x11, %xmm10, %xmm8 194 - pclmulqdq $0x0 , %xmm10, %xmm7 195 - pclmulqdq $0x11, %xmm10, %xmm13 196 - pxor %xmm9 , %xmm6 197 - xorps %xmm8 , %xmm6 198 - pxor %xmm12, %xmm7 199 - xorps %xmm13, %xmm7 200 - 201 - sub $128, arg3 202 - 203 - # check if there is another 64B in the buffer to be able to fold 204 - jge _fold_64_B_loop 205 - ################################################################## 206 - 207 - 208 - add $128, arg2 209 - # at this point, the buffer pointer is pointing at the last y Bytes 210 - # of the buffer the 64B of folded data is in 4 of the xmm 211 - # registers: xmm0, xmm1, xmm2, xmm3 212 - 213 - 214 - # fold the 8 xmm registers to 1 xmm register with different constants 215 - 216 - movdqa rk9(%rip), %xmm10 217 - movdqa %xmm0, %xmm8 218 - pclmulqdq $0x11, %xmm10, %xmm0 219 - pclmulqdq $0x0 , %xmm10, %xmm8 220 - pxor %xmm8, %xmm7 221 - xorps %xmm0, %xmm7 222 - 223 - movdqa rk11(%rip), %xmm10 224 - movdqa %xmm1, %xmm8 225 - pclmulqdq $0x11, %xmm10, %xmm1 226 - pclmulqdq $0x0 , %xmm10, %xmm8 227 - pxor %xmm8, %xmm7 228 - xorps %xmm1, %xmm7 229 - 230 - movdqa rk13(%rip), %xmm10 231 - movdqa %xmm2, %xmm8 232 - pclmulqdq $0x11, %xmm10, %xmm2 233 - pclmulqdq $0x0 , %xmm10, %xmm8 234 - pxor %xmm8, %xmm7 235 - pxor %xmm2, %xmm7 236 - 237 - movdqa rk15(%rip), %xmm10 238 - movdqa %xmm3, %xmm8 239 - pclmulqdq $0x11, %xmm10, %xmm3 240 - pclmulqdq $0x0 , %xmm10, %xmm8 241 - pxor %xmm8, %xmm7 242 - xorps %xmm3, %xmm7 243 - 244 - movdqa rk17(%rip), %xmm10 245 - movdqa %xmm4, %xmm8 246 - pclmulqdq $0x11, %xmm10, %xmm4 247 - pclmulqdq $0x0 , %xmm10, %xmm8 248 - pxor %xmm8, %xmm7 249 - pxor %xmm4, %xmm7 250 - 251 - movdqa rk19(%rip), %xmm10 252 - movdqa %xmm5, %xmm8 253 - pclmulqdq $0x11, %xmm10, %xmm5 254 - pclmulqdq $0x0 , %xmm10, %xmm8 255 - pxor %xmm8, %xmm7 256 - xorps %xmm5, %xmm7 257 - 258 - movdqa rk1(%rip), %xmm10 #xmm10 has rk1 and rk2 259 - #imm value of pclmulqdq instruction 260 - #will determine which constant to use 261 - movdqa %xmm6, %xmm8 262 - pclmulqdq $0x11, %xmm10, %xmm6 263 - pclmulqdq $0x0 , %xmm10, %xmm8 264 - pxor %xmm8, %xmm7 265 - pxor %xmm6, %xmm7 266 - 267 - 268 - # instead of 64, we add 48 to the loop counter to save 1 instruction 269 - # from the loop instead of a cmp instruction, we use the negative 270 - # flag with the jl instruction 271 - add $128-16, arg3 272 - jl _final_reduction_for_128 273 - 274 - # now we have 16+y bytes left to reduce. 16 Bytes is in register xmm7 275 - # and the rest is in memory. We can fold 16 bytes at a time if y>=16 276 - # continue folding 16B at a time 277 - 278 - _16B_reduction_loop: 279 - movdqa %xmm7, %xmm8 280 - pclmulqdq $0x11, %xmm10, %xmm7 281 - pclmulqdq $0x0 , %xmm10, %xmm8 282 - pxor %xmm8, %xmm7 283 - movdqu (arg2), %xmm0 284 - pshufb %xmm11, %xmm0 285 - pxor %xmm0 , %xmm7 286 - add $16, arg2 287 - sub $16, arg3 288 - # instead of a cmp instruction, we utilize the flags with the 289 - # jge instruction equivalent of: cmp arg3, 16-16 290 - # check if there is any more 16B in the buffer to be able to fold 291 - jge _16B_reduction_loop 292 - 293 - #now we have 16+z bytes left to reduce, where 0<= z < 16. 294 - #first, we reduce the data in the xmm7 register 295 - 296 - 297 - _final_reduction_for_128: 298 - # check if any more data to fold. If not, compute the CRC of 299 - # the final 128 bits 300 - add $16, arg3 301 - je _128_done 302 - 303 - # here we are getting data that is less than 16 bytes. 304 - # since we know that there was data before the pointer, we can 305 - # offset the input pointer before the actual point, to receive 306 - # exactly 16 bytes. after that the registers need to be adjusted. 307 - _get_last_two_xmms: 308 - movdqa %xmm7, %xmm2 309 - 310 - movdqu -16(arg2, arg3), %xmm1 311 - pshufb %xmm11, %xmm1 312 - 313 - # get rid of the extra data that was loaded before 314 - # load the shift constant 315 - lea pshufb_shf_table+16(%rip), %rax 316 - sub arg3, %rax 317 - movdqu (%rax), %xmm0 318 - 319 - # shift xmm2 to the left by arg3 bytes 320 - pshufb %xmm0, %xmm2 321 - 322 - # shift xmm7 to the right by 16-arg3 bytes 323 - pxor mask1(%rip), %xmm0 324 - pshufb %xmm0, %xmm7 325 - pblendvb %xmm2, %xmm1 #xmm0 is implicit 326 - 327 - # fold 16 Bytes 328 - movdqa %xmm1, %xmm2 329 - movdqa %xmm7, %xmm8 330 - pclmulqdq $0x11, %xmm10, %xmm7 331 - pclmulqdq $0x0 , %xmm10, %xmm8 332 - pxor %xmm8, %xmm7 333 - pxor %xmm2, %xmm7 334 - 335 - _128_done: 336 - # compute crc of a 128-bit value 337 - movdqa rk5(%rip), %xmm10 # rk5 and rk6 in xmm10 338 - movdqa %xmm7, %xmm0 339 - 340 - #64b fold 341 - pclmulqdq $0x1, %xmm10, %xmm7 342 - pslldq $8 , %xmm0 343 - pxor %xmm0, %xmm7 344 - 345 - #32b fold 346 - movdqa %xmm7, %xmm0 347 - 348 - pand mask2(%rip), %xmm0 349 - 350 - psrldq $12, %xmm7 351 - pclmulqdq $0x10, %xmm10, %xmm7 352 - pxor %xmm0, %xmm7 353 - 354 - #barrett reduction 355 - _barrett: 356 - movdqa rk7(%rip), %xmm10 # rk7 and rk8 in xmm10 357 - movdqa %xmm7, %xmm0 358 - pclmulqdq $0x01, %xmm10, %xmm7 359 - pslldq $4, %xmm7 360 - pclmulqdq $0x11, %xmm10, %xmm7 361 - 362 - pslldq $4, %xmm7 363 - pxor %xmm0, %xmm7 364 - pextrd $1, %xmm7, %eax 365 - 366 - _cleanup: 367 - # scale the result back to 16 bits 368 - shr $16, %eax 369 - mov %rcx, %rsp 370 - ret 371 - 372 - ######################################################################## 373 - 374 - .align 16 375 - _less_than_128: 376 - 377 - # check if there is enough buffer to be able to fold 16B at a time 378 - cmp $32, arg3 379 - jl _less_than_32 380 - movdqa SHUF_MASK(%rip), %xmm11 381 - 382 - # now if there is, load the constants 383 - movdqa rk1(%rip), %xmm10 # rk1 and rk2 in xmm10 384 - 385 - movd arg1_low32, %xmm0 # get the initial crc value 386 - pslldq $12, %xmm0 # align it to its correct place 387 - movdqu (arg2), %xmm7 # load the plaintext 388 - pshufb %xmm11, %xmm7 # byte-reflect the plaintext 389 - pxor %xmm0, %xmm7 390 - 391 - 392 - # update the buffer pointer 393 - add $16, arg2 394 - 395 - # update the counter. subtract 32 instead of 16 to save one 396 - # instruction from the loop 397 - sub $32, arg3 398 - 399 - jmp _16B_reduction_loop 400 - 401 - 402 - .align 16 403 - _less_than_32: 404 - # mov initial crc to the return value. this is necessary for 405 - # zero-length buffers. 406 - mov arg1_low32, %eax 407 - test arg3, arg3 408 - je _cleanup 409 - 410 - movdqa SHUF_MASK(%rip), %xmm11 411 - 412 - movd arg1_low32, %xmm0 # get the initial crc value 413 - pslldq $12, %xmm0 # align it to its correct place 414 - 415 - cmp $16, arg3 416 - je _exact_16_left 417 - jl _less_than_16_left 418 - 419 - movdqu (arg2), %xmm7 # load the plaintext 420 - pshufb %xmm11, %xmm7 # byte-reflect the plaintext 421 - pxor %xmm0 , %xmm7 # xor the initial crc value 422 - add $16, arg2 423 - sub $16, arg3 424 - movdqa rk1(%rip), %xmm10 # rk1 and rk2 in xmm10 425 - jmp _get_last_two_xmms 426 - 427 - 428 - .align 16 429 - _less_than_16_left: 430 - # use stack space to load data less than 16 bytes, zero-out 431 - # the 16B in memory first. 432 - 433 - pxor %xmm1, %xmm1 434 - mov %rsp, %r11 435 - movdqa %xmm1, (%r11) 436 - 437 - cmp $4, arg3 438 - jl _only_less_than_4 439 - 440 - # backup the counter value 441 - mov arg3, %r9 442 - cmp $8, arg3 443 - jl _less_than_8_left 444 - 445 - # load 8 Bytes 446 - mov (arg2), %rax 447 - mov %rax, (%r11) 448 - add $8, %r11 449 - sub $8, arg3 450 - add $8, arg2 451 - _less_than_8_left: 452 - 453 - cmp $4, arg3 454 - jl _less_than_4_left 455 - 456 - # load 4 Bytes 457 - mov (arg2), %eax 458 - mov %eax, (%r11) 459 - add $4, %r11 460 - sub $4, arg3 461 - add $4, arg2 462 - _less_than_4_left: 463 - 464 - cmp $2, arg3 465 - jl _less_than_2_left 466 - 467 - # load 2 Bytes 468 - mov (arg2), %ax 469 - mov %ax, (%r11) 470 - add $2, %r11 471 - sub $2, arg3 472 - add $2, arg2 473 - _less_than_2_left: 474 - cmp $1, arg3 475 - jl _zero_left 476 - 477 - # load 1 Byte 478 - mov (arg2), %al 479 - mov %al, (%r11) 480 - _zero_left: 481 - movdqa (%rsp), %xmm7 482 - pshufb %xmm11, %xmm7 483 - pxor %xmm0 , %xmm7 # xor the initial crc value 484 - 485 - # shl r9, 4 486 - lea pshufb_shf_table+16(%rip), %rax 487 - sub %r9, %rax 488 - movdqu (%rax), %xmm0 489 - pxor mask1(%rip), %xmm0 490 - 491 - pshufb %xmm0, %xmm7 492 - jmp _128_done 493 - 494 - .align 16 495 - _exact_16_left: 496 - movdqu (arg2), %xmm7 497 - pshufb %xmm11, %xmm7 498 - pxor %xmm0 , %xmm7 # xor the initial crc value 499 - 500 - jmp _128_done 501 - 502 - _only_less_than_4: 503 - cmp $3, arg3 504 - jl _only_less_than_3 505 - 506 - # load 3 Bytes 507 - mov (arg2), %al 508 - mov %al, (%r11) 509 - 510 - mov 1(arg2), %al 511 - mov %al, 1(%r11) 512 - 513 - mov 2(arg2), %al 514 - mov %al, 2(%r11) 515 - 516 - movdqa (%rsp), %xmm7 517 - pshufb %xmm11, %xmm7 518 - pxor %xmm0 , %xmm7 # xor the initial crc value 519 - 520 - psrldq $5, %xmm7 521 - 522 - jmp _barrett 523 - _only_less_than_3: 524 - cmp $2, arg3 525 - jl _only_less_than_2 526 - 527 - # load 2 Bytes 528 - mov (arg2), %al 529 - mov %al, (%r11) 530 - 531 - mov 1(arg2), %al 532 - mov %al, 1(%r11) 533 - 534 - movdqa (%rsp), %xmm7 535 - pshufb %xmm11, %xmm7 536 - pxor %xmm0 , %xmm7 # xor the initial crc value 537 - 538 - psrldq $6, %xmm7 539 - 540 - jmp _barrett 541 - _only_less_than_2: 542 - 543 - # load 1 Byte 544 - mov (arg2), %al 545 - mov %al, (%r11) 546 - 547 - movdqa (%rsp), %xmm7 548 - pshufb %xmm11, %xmm7 549 - pxor %xmm0 , %xmm7 # xor the initial crc value 550 - 551 - psrldq $7, %xmm7 552 - 553 - jmp _barrett 554 - 555 - ENDPROC(crc_t10dif_pcl) 556 - 557 - .data 558 - 559 - # precomputed constants 560 - # these constants are precomputed from the poly: 561 - # 0x8bb70000 (0x8bb7 scaled to 32 bits) 562 - .align 16 563 - # Q = 0x18BB70000 564 - # rk1 = 2^(32*3) mod Q << 32 565 - # rk2 = 2^(32*5) mod Q << 32 566 - # rk3 = 2^(32*15) mod Q << 32 567 - # rk4 = 2^(32*17) mod Q << 32 568 - # rk5 = 2^(32*3) mod Q << 32 569 - # rk6 = 2^(32*2) mod Q << 32 570 - # rk7 = floor(2^64/Q) 571 - # rk8 = Q 572 - rk1: 573 - .quad 0x2d56000000000000 574 - rk2: 575 - .quad 0x06df000000000000 576 - rk3: 577 - .quad 0x9d9d000000000000 578 - rk4: 579 - .quad 0x7cf5000000000000 580 - rk5: 581 - .quad 0x2d56000000000000 582 - rk6: 583 - .quad 0x1368000000000000 584 - rk7: 585 - .quad 0x00000001f65a57f8 586 - rk8: 587 - .quad 0x000000018bb70000 588 - 589 - rk9: 590 - .quad 0xceae000000000000 591 - rk10: 592 - .quad 0xbfd6000000000000 593 - rk11: 594 - .quad 0x1e16000000000000 595 - rk12: 596 - .quad 0x713c000000000000 597 - rk13: 598 - .quad 0xf7f9000000000000 599 - rk14: 600 - .quad 0x80a6000000000000 601 - rk15: 602 - .quad 0x044c000000000000 603 - rk16: 604 - .quad 0xe658000000000000 605 - rk17: 606 - .quad 0xad18000000000000 607 - rk18: 608 - .quad 0xa497000000000000 609 - rk19: 610 - .quad 0x6ee3000000000000 611 - rk20: 612 - .quad 0xe7b5000000000000 613 - 614 - 615 - 616 - mask1: 617 - .octa 0x80808080808080808080808080808080 618 - mask2: 619 - .octa 0x00000000FFFFFFFFFFFFFFFFFFFFFFFF 620 - 621 - SHUF_MASK: 622 - .octa 0x000102030405060708090A0B0C0D0E0F 623 - 624 - pshufb_shf_table: 625 - # use these values for shift constants for the pshufb instruction 626 - # different alignments result in values as shown: 627 - # DDQ 0x008f8e8d8c8b8a898887868584838281 # shl 15 (16-1) / shr1 628 - # DDQ 0x01008f8e8d8c8b8a8988878685848382 # shl 14 (16-3) / shr2 629 - # DDQ 0x0201008f8e8d8c8b8a89888786858483 # shl 13 (16-4) / shr3 630 - # DDQ 0x030201008f8e8d8c8b8a898887868584 # shl 12 (16-4) / shr4 631 - # DDQ 0x04030201008f8e8d8c8b8a8988878685 # shl 11 (16-5) / shr5 632 - # DDQ 0x0504030201008f8e8d8c8b8a89888786 # shl 10 (16-6) / shr6 633 - # DDQ 0x060504030201008f8e8d8c8b8a898887 # shl 9 (16-7) / shr7 634 - # DDQ 0x07060504030201008f8e8d8c8b8a8988 # shl 8 (16-8) / shr8 635 - # DDQ 0x0807060504030201008f8e8d8c8b8a89 # shl 7 (16-9) / shr9 636 - # DDQ 0x090807060504030201008f8e8d8c8b8a # shl 6 (16-10) / shr10 637 - # DDQ 0x0a090807060504030201008f8e8d8c8b # shl 5 (16-11) / shr11 638 - # DDQ 0x0b0a090807060504030201008f8e8d8c # shl 4 (16-12) / shr12 639 - # DDQ 0x0c0b0a090807060504030201008f8e8d # shl 3 (16-13) / shr13 640 - # DDQ 0x0d0c0b0a090807060504030201008f8e # shl 2 (16-14) / shr14 641 - # DDQ 0x0e0d0c0b0a090807060504030201008f # shl 1 (16-15) / shr15 642 - .octa 0x8f8e8d8c8b8a89888786858483828100 643 - .octa 0x000e0d0c0b0a09080706050403020100
-151
arch/x86/crypto/crct10dif-pclmul_glue.c
··· 1 - /* 2 - * Cryptographic API. 3 - * 4 - * T10 Data Integrity Field CRC16 Crypto Transform using PCLMULQDQ Instructions 5 - * 6 - * Copyright (C) 2013 Intel Corporation 7 - * Author: Tim Chen <tim.c.chen@linux.intel.com> 8 - * 9 - * This program is free software; you can redistribute it and/or modify it 10 - * under the terms of the GNU General Public License as published by the Free 11 - * Software Foundation; either version 2 of the License, or (at your option) 12 - * any later version. 13 - * 14 - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 18 - * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 19 - * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 20 - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 - * SOFTWARE. 22 - * 23 - */ 24 - 25 - #include <linux/types.h> 26 - #include <linux/module.h> 27 - #include <linux/crc-t10dif.h> 28 - #include <crypto/internal/hash.h> 29 - #include <linux/init.h> 30 - #include <linux/string.h> 31 - #include <linux/kernel.h> 32 - #include <asm/i387.h> 33 - #include <asm/cpufeature.h> 34 - #include <asm/cpu_device_id.h> 35 - 36 - asmlinkage __u16 crc_t10dif_pcl(__u16 crc, const unsigned char *buf, 37 - size_t len); 38 - 39 - struct chksum_desc_ctx { 40 - __u16 crc; 41 - }; 42 - 43 - /* 44 - * Steps through buffer one byte at at time, calculates reflected 45 - * crc using table. 46 - */ 47 - 48 - static int chksum_init(struct shash_desc *desc) 49 - { 50 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 51 - 52 - ctx->crc = 0; 53 - 54 - return 0; 55 - } 56 - 57 - static int chksum_update(struct shash_desc *desc, const u8 *data, 58 - unsigned int length) 59 - { 60 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 61 - 62 - if (irq_fpu_usable()) { 63 - kernel_fpu_begin(); 64 - ctx->crc = crc_t10dif_pcl(ctx->crc, data, length); 65 - kernel_fpu_end(); 66 - } else 67 - ctx->crc = crc_t10dif_generic(ctx->crc, data, length); 68 - return 0; 69 - } 70 - 71 - static int chksum_final(struct shash_desc *desc, u8 *out) 72 - { 73 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 74 - 75 - *(__u16 *)out = ctx->crc; 76 - return 0; 77 - } 78 - 79 - static int __chksum_finup(__u16 *crcp, const u8 *data, unsigned int len, 80 - u8 *out) 81 - { 82 - if (irq_fpu_usable()) { 83 - kernel_fpu_begin(); 84 - *(__u16 *)out = crc_t10dif_pcl(*crcp, data, len); 85 - kernel_fpu_end(); 86 - } else 87 - *(__u16 *)out = crc_t10dif_generic(*crcp, data, len); 88 - return 0; 89 - } 90 - 91 - static int chksum_finup(struct shash_desc *desc, const u8 *data, 92 - unsigned int len, u8 *out) 93 - { 94 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 95 - 96 - return __chksum_finup(&ctx->crc, data, len, out); 97 - } 98 - 99 - static int chksum_digest(struct shash_desc *desc, const u8 *data, 100 - unsigned int length, u8 *out) 101 - { 102 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 103 - 104 - return __chksum_finup(&ctx->crc, data, length, out); 105 - } 106 - 107 - static struct shash_alg alg = { 108 - .digestsize = CRC_T10DIF_DIGEST_SIZE, 109 - .init = chksum_init, 110 - .update = chksum_update, 111 - .final = chksum_final, 112 - .finup = chksum_finup, 113 - .digest = chksum_digest, 114 - .descsize = sizeof(struct chksum_desc_ctx), 115 - .base = { 116 - .cra_name = "crct10dif", 117 - .cra_driver_name = "crct10dif-pclmul", 118 - .cra_priority = 200, 119 - .cra_blocksize = CRC_T10DIF_BLOCK_SIZE, 120 - .cra_module = THIS_MODULE, 121 - } 122 - }; 123 - 124 - static const struct x86_cpu_id crct10dif_cpu_id[] = { 125 - X86_FEATURE_MATCH(X86_FEATURE_PCLMULQDQ), 126 - {} 127 - }; 128 - MODULE_DEVICE_TABLE(x86cpu, crct10dif_cpu_id); 129 - 130 - static int __init crct10dif_intel_mod_init(void) 131 - { 132 - if (!x86_match_cpu(crct10dif_cpu_id)) 133 - return -ENODEV; 134 - 135 - return crypto_register_shash(&alg); 136 - } 137 - 138 - static void __exit crct10dif_intel_mod_fini(void) 139 - { 140 - crypto_unregister_shash(&alg); 141 - } 142 - 143 - module_init(crct10dif_intel_mod_init); 144 - module_exit(crct10dif_intel_mod_fini); 145 - 146 - MODULE_AUTHOR("Tim Chen <tim.c.chen@linux.intel.com>"); 147 - MODULE_DESCRIPTION("T10 DIF CRC calculation accelerated with PCLMULQDQ."); 148 - MODULE_LICENSE("GPL"); 149 - 150 - MODULE_ALIAS("crct10dif"); 151 - MODULE_ALIAS("crct10dif-pclmul");
-19
crypto/Kconfig
··· 376 376 which will enable any routine to use the CRC-32-IEEE 802.3 checksum 377 377 and gain better performance as compared with the table implementation. 378 378 379 - config CRYPTO_CRCT10DIF 380 - tristate "CRCT10DIF algorithm" 381 - select CRYPTO_HASH 382 - help 383 - CRC T10 Data Integrity Field computation is being cast as 384 - a crypto transform. This allows for faster crc t10 diff 385 - transforms to be used if they are available. 386 - 387 - config CRYPTO_CRCT10DIF_PCLMUL 388 - tristate "CRCT10DIF PCLMULQDQ hardware acceleration" 389 - depends on X86 && 64BIT && CRC_T10DIF 390 - select CRYPTO_HASH 391 - help 392 - For x86_64 processors with SSE4.2 and PCLMULQDQ supported, 393 - CRC T10 DIF PCLMULQDQ computation can be hardware 394 - accelerated PCLMULQDQ instruction. This option will create 395 - 'crct10dif-plcmul' module, which is faster when computing the 396 - crct10dif checksum as compared with the generic table implementation. 397 - 398 379 config CRYPTO_GHASH 399 380 tristate "GHASH digest algorithm" 400 381 select CRYPTO_GF128MUL
-1
crypto/Makefile
··· 83 83 obj-$(CONFIG_CRYPTO_MICHAEL_MIC) += michael_mic.o 84 84 obj-$(CONFIG_CRYPTO_CRC32C) += crc32c.o 85 85 obj-$(CONFIG_CRYPTO_CRC32) += crc32.o 86 - obj-$(CONFIG_CRYPTO_CRCT10DIF) += crct10dif.o 87 86 obj-$(CONFIG_CRYPTO_AUTHENC) += authenc.o authencesn.o 88 87 obj-$(CONFIG_CRYPTO_LZO) += lzo.o 89 88 obj-$(CONFIG_CRYPTO_LZ4) += lz4.o
-178
crypto/crct10dif.c
··· 1 - /* 2 - * Cryptographic API. 3 - * 4 - * T10 Data Integrity Field CRC16 Crypto Transform 5 - * 6 - * Copyright (c) 2007 Oracle Corporation. All rights reserved. 7 - * Written by Martin K. Petersen <martin.petersen@oracle.com> 8 - * Copyright (C) 2013 Intel Corporation 9 - * Author: Tim Chen <tim.c.chen@linux.intel.com> 10 - * 11 - * This program is free software; you can redistribute it and/or modify it 12 - * under the terms of the GNU General Public License as published by the Free 13 - * Software Foundation; either version 2 of the License, or (at your option) 14 - * any later version. 15 - * 16 - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 19 - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 20 - * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 21 - * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 - * SOFTWARE. 24 - * 25 - */ 26 - 27 - #include <linux/types.h> 28 - #include <linux/module.h> 29 - #include <linux/crc-t10dif.h> 30 - #include <crypto/internal/hash.h> 31 - #include <linux/init.h> 32 - #include <linux/string.h> 33 - #include <linux/kernel.h> 34 - 35 - struct chksum_desc_ctx { 36 - __u16 crc; 37 - }; 38 - 39 - /* Table generated using the following polynomium: 40 - * x^16 + x^15 + x^11 + x^9 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1 41 - * gt: 0x8bb7 42 - */ 43 - static const __u16 t10_dif_crc_table[256] = { 44 - 0x0000, 0x8BB7, 0x9CD9, 0x176E, 0xB205, 0x39B2, 0x2EDC, 0xA56B, 45 - 0xEFBD, 0x640A, 0x7364, 0xF8D3, 0x5DB8, 0xD60F, 0xC161, 0x4AD6, 46 - 0x54CD, 0xDF7A, 0xC814, 0x43A3, 0xE6C8, 0x6D7F, 0x7A11, 0xF1A6, 47 - 0xBB70, 0x30C7, 0x27A9, 0xAC1E, 0x0975, 0x82C2, 0x95AC, 0x1E1B, 48 - 0xA99A, 0x222D, 0x3543, 0xBEF4, 0x1B9F, 0x9028, 0x8746, 0x0CF1, 49 - 0x4627, 0xCD90, 0xDAFE, 0x5149, 0xF422, 0x7F95, 0x68FB, 0xE34C, 50 - 0xFD57, 0x76E0, 0x618E, 0xEA39, 0x4F52, 0xC4E5, 0xD38B, 0x583C, 51 - 0x12EA, 0x995D, 0x8E33, 0x0584, 0xA0EF, 0x2B58, 0x3C36, 0xB781, 52 - 0xD883, 0x5334, 0x445A, 0xCFED, 0x6A86, 0xE131, 0xF65F, 0x7DE8, 53 - 0x373E, 0xBC89, 0xABE7, 0x2050, 0x853B, 0x0E8C, 0x19E2, 0x9255, 54 - 0x8C4E, 0x07F9, 0x1097, 0x9B20, 0x3E4B, 0xB5FC, 0xA292, 0x2925, 55 - 0x63F3, 0xE844, 0xFF2A, 0x749D, 0xD1F6, 0x5A41, 0x4D2F, 0xC698, 56 - 0x7119, 0xFAAE, 0xEDC0, 0x6677, 0xC31C, 0x48AB, 0x5FC5, 0xD472, 57 - 0x9EA4, 0x1513, 0x027D, 0x89CA, 0x2CA1, 0xA716, 0xB078, 0x3BCF, 58 - 0x25D4, 0xAE63, 0xB90D, 0x32BA, 0x97D1, 0x1C66, 0x0B08, 0x80BF, 59 - 0xCA69, 0x41DE, 0x56B0, 0xDD07, 0x786C, 0xF3DB, 0xE4B5, 0x6F02, 60 - 0x3AB1, 0xB106, 0xA668, 0x2DDF, 0x88B4, 0x0303, 0x146D, 0x9FDA, 61 - 0xD50C, 0x5EBB, 0x49D5, 0xC262, 0x6709, 0xECBE, 0xFBD0, 0x7067, 62 - 0x6E7C, 0xE5CB, 0xF2A5, 0x7912, 0xDC79, 0x57CE, 0x40A0, 0xCB17, 63 - 0x81C1, 0x0A76, 0x1D18, 0x96AF, 0x33C4, 0xB873, 0xAF1D, 0x24AA, 64 - 0x932B, 0x189C, 0x0FF2, 0x8445, 0x212E, 0xAA99, 0xBDF7, 0x3640, 65 - 0x7C96, 0xF721, 0xE04F, 0x6BF8, 0xCE93, 0x4524, 0x524A, 0xD9FD, 66 - 0xC7E6, 0x4C51, 0x5B3F, 0xD088, 0x75E3, 0xFE54, 0xE93A, 0x628D, 67 - 0x285B, 0xA3EC, 0xB482, 0x3F35, 0x9A5E, 0x11E9, 0x0687, 0x8D30, 68 - 0xE232, 0x6985, 0x7EEB, 0xF55C, 0x5037, 0xDB80, 0xCCEE, 0x4759, 69 - 0x0D8F, 0x8638, 0x9156, 0x1AE1, 0xBF8A, 0x343D, 0x2353, 0xA8E4, 70 - 0xB6FF, 0x3D48, 0x2A26, 0xA191, 0x04FA, 0x8F4D, 0x9823, 0x1394, 71 - 0x5942, 0xD2F5, 0xC59B, 0x4E2C, 0xEB47, 0x60F0, 0x779E, 0xFC29, 72 - 0x4BA8, 0xC01F, 0xD771, 0x5CC6, 0xF9AD, 0x721A, 0x6574, 0xEEC3, 73 - 0xA415, 0x2FA2, 0x38CC, 0xB37B, 0x1610, 0x9DA7, 0x8AC9, 0x017E, 74 - 0x1F65, 0x94D2, 0x83BC, 0x080B, 0xAD60, 0x26D7, 0x31B9, 0xBA0E, 75 - 0xF0D8, 0x7B6F, 0x6C01, 0xE7B6, 0x42DD, 0xC96A, 0xDE04, 0x55B3 76 - }; 77 - 78 - __u16 crc_t10dif_generic(__u16 crc, const unsigned char *buffer, size_t len) 79 - { 80 - unsigned int i; 81 - 82 - for (i = 0 ; i < len ; i++) 83 - crc = (crc << 8) ^ t10_dif_crc_table[((crc >> 8) ^ buffer[i]) & 0xff]; 84 - 85 - return crc; 86 - } 87 - EXPORT_SYMBOL(crc_t10dif_generic); 88 - 89 - /* 90 - * Steps through buffer one byte at at time, calculates reflected 91 - * crc using table. 92 - */ 93 - 94 - static int chksum_init(struct shash_desc *desc) 95 - { 96 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 97 - 98 - ctx->crc = 0; 99 - 100 - return 0; 101 - } 102 - 103 - static int chksum_update(struct shash_desc *desc, const u8 *data, 104 - unsigned int length) 105 - { 106 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 107 - 108 - ctx->crc = crc_t10dif_generic(ctx->crc, data, length); 109 - return 0; 110 - } 111 - 112 - static int chksum_final(struct shash_desc *desc, u8 *out) 113 - { 114 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 115 - 116 - *(__u16 *)out = ctx->crc; 117 - return 0; 118 - } 119 - 120 - static int __chksum_finup(__u16 *crcp, const u8 *data, unsigned int len, 121 - u8 *out) 122 - { 123 - *(__u16 *)out = crc_t10dif_generic(*crcp, data, len); 124 - return 0; 125 - } 126 - 127 - static int chksum_finup(struct shash_desc *desc, const u8 *data, 128 - unsigned int len, u8 *out) 129 - { 130 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 131 - 132 - return __chksum_finup(&ctx->crc, data, len, out); 133 - } 134 - 135 - static int chksum_digest(struct shash_desc *desc, const u8 *data, 136 - unsigned int length, u8 *out) 137 - { 138 - struct chksum_desc_ctx *ctx = shash_desc_ctx(desc); 139 - 140 - return __chksum_finup(&ctx->crc, data, length, out); 141 - } 142 - 143 - static struct shash_alg alg = { 144 - .digestsize = CRC_T10DIF_DIGEST_SIZE, 145 - .init = chksum_init, 146 - .update = chksum_update, 147 - .final = chksum_final, 148 - .finup = chksum_finup, 149 - .digest = chksum_digest, 150 - .descsize = sizeof(struct chksum_desc_ctx), 151 - .base = { 152 - .cra_name = "crct10dif", 153 - .cra_driver_name = "crct10dif-generic", 154 - .cra_priority = 100, 155 - .cra_blocksize = CRC_T10DIF_BLOCK_SIZE, 156 - .cra_module = THIS_MODULE, 157 - } 158 - }; 159 - 160 - static int __init crct10dif_mod_init(void) 161 - { 162 - int ret; 163 - 164 - ret = crypto_register_shash(&alg); 165 - return ret; 166 - } 167 - 168 - static void __exit crct10dif_mod_fini(void) 169 - { 170 - crypto_unregister_shash(&alg); 171 - } 172 - 173 - module_init(crct10dif_mod_init); 174 - module_exit(crct10dif_mod_fini); 175 - 176 - MODULE_AUTHOR("Tim Chen <tim.c.chen@linux.intel.com>"); 177 - MODULE_DESCRIPTION("T10 DIF CRC calculation."); 178 - MODULE_LICENSE("GPL");
-8
crypto/tcrypt.c
··· 1174 1174 ret += tcrypt_test("ghash"); 1175 1175 break; 1176 1176 1177 - case 47: 1178 - ret += tcrypt_test("crct10dif"); 1179 - break; 1180 - 1181 1177 case 100: 1182 1178 ret += tcrypt_test("hmac(md5)"); 1183 1179 break; ··· 1496 1500 1497 1501 case 319: 1498 1502 test_hash_speed("crc32c", sec, generic_hash_speed_template); 1499 - if (mode > 300 && mode < 400) break; 1500 - 1501 - case 320: 1502 - test_hash_speed("crct10dif", sec, generic_hash_speed_template); 1503 1503 if (mode > 300 && mode < 400) break; 1504 1504 1505 1505 case 399:
-10
crypto/testmgr.c
··· 2046 2046 } 2047 2047 } 2048 2048 }, { 2049 - .alg = "crct10dif", 2050 - .test = alg_test_hash, 2051 - .fips_allowed = 1, 2052 - .suite = { 2053 - .hash = { 2054 - .vecs = crct10dif_tv_template, 2055 - .count = CRCT10DIF_TEST_VECTORS 2056 - } 2057 - } 2058 - }, { 2059 2049 .alg = "cryptd(__driver-cbc-aes-aesni)", 2060 2050 .test = alg_test_null, 2061 2051 .fips_allowed = 1,
-33
crypto/testmgr.h
··· 450 450 } 451 451 }; 452 452 453 - #define CRCT10DIF_TEST_VECTORS 3 454 - static struct hash_testvec crct10dif_tv_template[] = { 455 - { 456 - .plaintext = "abc", 457 - .psize = 3, 458 - #ifdef __LITTLE_ENDIAN 459 - .digest = "\x3b\x44", 460 - #else 461 - .digest = "\x44\x3b", 462 - #endif 463 - }, { 464 - .plaintext = "1234567890123456789012345678901234567890" 465 - "123456789012345678901234567890123456789", 466 - .psize = 79, 467 - #ifdef __LITTLE_ENDIAN 468 - .digest = "\x70\x4b", 469 - #else 470 - .digest = "\x4b\x70", 471 - #endif 472 - }, { 473 - .plaintext = 474 - "abcddddddddddddddddddddddddddddddddddddddddddddddddddddd", 475 - .psize = 56, 476 - #ifdef __LITTLE_ENDIAN 477 - .digest = "\xe3\x9c", 478 - #else 479 - .digest = "\x9c\xe3", 480 - #endif 481 - .np = 2, 482 - .tap = { 28, 28 } 483 - } 484 - }; 485 - 486 453 /* 487 454 * SHA1 test vectors from from FIPS PUB 180-1 488 455 * Long vector from CAVS 5.0
+1 -1
drivers/crypto/caam/caamhash.c
··· 429 429 dma_addr_t src_dma, dst_dma; 430 430 int ret = 0; 431 431 432 - desc = kmalloc(CAAM_CMD_SZ * 6 + CAAM_PTR_SZ * 2, GFP_KERNEL | GFP_DMA); 432 + desc = kmalloc(CAAM_CMD_SZ * 8 + CAAM_PTR_SZ * 2, GFP_KERNEL | GFP_DMA); 433 433 if (!desc) { 434 434 dev_err(jrdev, "unable to allocate key input memory\n"); 435 435 return -ENOMEM;
-4
include/linux/crc-t10dif.h
··· 3 3 4 4 #include <linux/types.h> 5 5 6 - #define CRC_T10DIF_DIGEST_SIZE 2 7 - #define CRC_T10DIF_BLOCK_SIZE 1 8 - 9 - __u16 crc_t10dif_generic(__u16 crc, const unsigned char *buffer, size_t len); 10 6 __u16 crc_t10dif(unsigned char const *, size_t); 11 7 12 8 #endif
-2
lib/Kconfig
··· 66 66 67 67 config CRC_T10DIF 68 68 tristate "CRC calculation for the T10 Data Integrity Field" 69 - select CRYPTO 70 - select CRYPTO_CRCT10DIF 71 69 help 72 70 This option is only needed if a module that's not in the 73 71 kernel tree needs to calculate CRC checks for use with the
+43 -30
lib/crc-t10dif.c
··· 11 11 #include <linux/types.h> 12 12 #include <linux/module.h> 13 13 #include <linux/crc-t10dif.h> 14 - #include <linux/err.h> 15 - #include <linux/init.h> 16 - #include <crypto/hash.h> 17 14 18 - static struct crypto_shash *crct10dif_tfm; 15 + /* Table generated using the following polynomium: 16 + * x^16 + x^15 + x^11 + x^9 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1 17 + * gt: 0x8bb7 18 + */ 19 + static const __u16 t10_dif_crc_table[256] = { 20 + 0x0000, 0x8BB7, 0x9CD9, 0x176E, 0xB205, 0x39B2, 0x2EDC, 0xA56B, 21 + 0xEFBD, 0x640A, 0x7364, 0xF8D3, 0x5DB8, 0xD60F, 0xC161, 0x4AD6, 22 + 0x54CD, 0xDF7A, 0xC814, 0x43A3, 0xE6C8, 0x6D7F, 0x7A11, 0xF1A6, 23 + 0xBB70, 0x30C7, 0x27A9, 0xAC1E, 0x0975, 0x82C2, 0x95AC, 0x1E1B, 24 + 0xA99A, 0x222D, 0x3543, 0xBEF4, 0x1B9F, 0x9028, 0x8746, 0x0CF1, 25 + 0x4627, 0xCD90, 0xDAFE, 0x5149, 0xF422, 0x7F95, 0x68FB, 0xE34C, 26 + 0xFD57, 0x76E0, 0x618E, 0xEA39, 0x4F52, 0xC4E5, 0xD38B, 0x583C, 27 + 0x12EA, 0x995D, 0x8E33, 0x0584, 0xA0EF, 0x2B58, 0x3C36, 0xB781, 28 + 0xD883, 0x5334, 0x445A, 0xCFED, 0x6A86, 0xE131, 0xF65F, 0x7DE8, 29 + 0x373E, 0xBC89, 0xABE7, 0x2050, 0x853B, 0x0E8C, 0x19E2, 0x9255, 30 + 0x8C4E, 0x07F9, 0x1097, 0x9B20, 0x3E4B, 0xB5FC, 0xA292, 0x2925, 31 + 0x63F3, 0xE844, 0xFF2A, 0x749D, 0xD1F6, 0x5A41, 0x4D2F, 0xC698, 32 + 0x7119, 0xFAAE, 0xEDC0, 0x6677, 0xC31C, 0x48AB, 0x5FC5, 0xD472, 33 + 0x9EA4, 0x1513, 0x027D, 0x89CA, 0x2CA1, 0xA716, 0xB078, 0x3BCF, 34 + 0x25D4, 0xAE63, 0xB90D, 0x32BA, 0x97D1, 0x1C66, 0x0B08, 0x80BF, 35 + 0xCA69, 0x41DE, 0x56B0, 0xDD07, 0x786C, 0xF3DB, 0xE4B5, 0x6F02, 36 + 0x3AB1, 0xB106, 0xA668, 0x2DDF, 0x88B4, 0x0303, 0x146D, 0x9FDA, 37 + 0xD50C, 0x5EBB, 0x49D5, 0xC262, 0x6709, 0xECBE, 0xFBD0, 0x7067, 38 + 0x6E7C, 0xE5CB, 0xF2A5, 0x7912, 0xDC79, 0x57CE, 0x40A0, 0xCB17, 39 + 0x81C1, 0x0A76, 0x1D18, 0x96AF, 0x33C4, 0xB873, 0xAF1D, 0x24AA, 40 + 0x932B, 0x189C, 0x0FF2, 0x8445, 0x212E, 0xAA99, 0xBDF7, 0x3640, 41 + 0x7C96, 0xF721, 0xE04F, 0x6BF8, 0xCE93, 0x4524, 0x524A, 0xD9FD, 42 + 0xC7E6, 0x4C51, 0x5B3F, 0xD088, 0x75E3, 0xFE54, 0xE93A, 0x628D, 43 + 0x285B, 0xA3EC, 0xB482, 0x3F35, 0x9A5E, 0x11E9, 0x0687, 0x8D30, 44 + 0xE232, 0x6985, 0x7EEB, 0xF55C, 0x5037, 0xDB80, 0xCCEE, 0x4759, 45 + 0x0D8F, 0x8638, 0x9156, 0x1AE1, 0xBF8A, 0x343D, 0x2353, 0xA8E4, 46 + 0xB6FF, 0x3D48, 0x2A26, 0xA191, 0x04FA, 0x8F4D, 0x9823, 0x1394, 47 + 0x5942, 0xD2F5, 0xC59B, 0x4E2C, 0xEB47, 0x60F0, 0x779E, 0xFC29, 48 + 0x4BA8, 0xC01F, 0xD771, 0x5CC6, 0xF9AD, 0x721A, 0x6574, 0xEEC3, 49 + 0xA415, 0x2FA2, 0x38CC, 0xB37B, 0x1610, 0x9DA7, 0x8AC9, 0x017E, 50 + 0x1F65, 0x94D2, 0x83BC, 0x080B, 0xAD60, 0x26D7, 0x31B9, 0xBA0E, 51 + 0xF0D8, 0x7B6F, 0x6C01, 0xE7B6, 0x42DD, 0xC96A, 0xDE04, 0x55B3 52 + }; 19 53 20 54 __u16 crc_t10dif(const unsigned char *buffer, size_t len) 21 55 { 22 - struct { 23 - struct shash_desc shash; 24 - char ctx[2]; 25 - } desc; 26 - int err; 56 + __u16 crc = 0; 57 + unsigned int i; 27 58 28 - desc.shash.tfm = crct10dif_tfm; 29 - desc.shash.flags = 0; 30 - *(__u16 *)desc.ctx = 0; 59 + for (i = 0 ; i < len ; i++) 60 + crc = (crc << 8) ^ t10_dif_crc_table[((crc >> 8) ^ buffer[i]) & 0xff]; 31 61 32 - err = crypto_shash_update(&desc.shash, buffer, len); 33 - BUG_ON(err); 34 - 35 - return *(__u16 *)desc.ctx; 62 + return crc; 36 63 } 37 64 EXPORT_SYMBOL(crc_t10dif); 38 - 39 - static int __init crc_t10dif_mod_init(void) 40 - { 41 - crct10dif_tfm = crypto_alloc_shash("crct10dif", 0, 0); 42 - return PTR_RET(crct10dif_tfm); 43 - } 44 - 45 - static void __exit crc_t10dif_mod_fini(void) 46 - { 47 - crypto_free_shash(crct10dif_tfm); 48 - } 49 - 50 - module_init(crc_t10dif_mod_init); 51 - module_exit(crc_t10dif_mod_fini); 52 65 53 66 MODULE_DESCRIPTION("T10 DIF CRC calculation"); 54 67 MODULE_LICENSE("GPL");