61164e105b
New crc unit adds three different polynomials: T10dif, ieee and iscsi. Signed-off-by: Greg Tucker <greg.b.tucker@intel.com>
569 lines
17 KiB
NASM
569 lines
17 KiB
NASM
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
; Copyright(c) 2011-2015 Intel Corporation All rights reserved.
|
|
;
|
|
; Redistribution and use in source and binary forms, with or without
|
|
; modification, are permitted provided that the following conditions
|
|
; are met:
|
|
; * Redistributions of source code must retain the above copyright
|
|
; notice, this list of conditions and the following disclaimer.
|
|
; * Redistributions in binary form must reproduce the above copyright
|
|
; notice, this list of conditions and the following disclaimer in
|
|
; the documentation and/or other materials provided with the
|
|
; distribution.
|
|
; * Neither the name of Intel Corporation nor the names of its
|
|
; contributors may be used to endorse or promote products derived
|
|
; from this software without specific prior written permission.
|
|
;
|
|
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;; ISCSI CRC 32 Implementation with crc32 and pclmulqdq Instruction
|
|
|
|
%include "reg_sizes.asm"
|
|
|
|
default rel
|
|
%define CONCAT(a,b,c) a %+ b %+ c
|
|
|
|
; Define threshold where buffers are considered "small" and routed to more
|
|
; efficient "by-1" code. This "by-1" code only handles up to 255 bytes, so
|
|
; SMALL_SIZE can be no larger than 256.
|
|
%define SMALL_SIZE 200
|
|
|
|
%if (SMALL_SIZE > 256)
|
|
%error SMALL_ SIZE must be <= 256
|
|
% error ; needed because '%error' actually generates only a warning
|
|
%endif
|
|
|
|
;;; unsigned int crc32_iscsi_01(unsigned char * buffer, int len, unsigned int crc_init);
|
|
;;;
|
|
;;; *buf = rcx
|
|
;;; len = rdx
|
|
;;; crc_init = r8
|
|
|
|
global crc32_iscsi_01:function
|
|
crc32_iscsi_01:
|
|
|
|
%ifidn __OUTPUT_FORMAT__, elf64
|
|
%define bufp rdi
|
|
%define bufp_dw edi
|
|
%define bufp_w di
|
|
%define bufp_b dil
|
|
%define bufptmp rcx
|
|
%define block_0 rcx
|
|
%define block_1 rdx
|
|
%define block_2 r11
|
|
%define len rsi
|
|
%define len_dw esi
|
|
%define len_w si
|
|
%define len_b sil
|
|
%define crc_init_arg rdx
|
|
%else
|
|
%define bufp rcx
|
|
%define bufp_dw ecx
|
|
%define bufp_w cx
|
|
%define bufp_b cl
|
|
%define bufptmp rdi
|
|
%define block_0 rdi
|
|
%define block_1 rsi
|
|
%define block_2 r11
|
|
%define len rdx
|
|
%define len_dw edx
|
|
%define len_w dx
|
|
%define len_b dl
|
|
%endif
|
|
|
|
%define tmp rbx
|
|
%define crc_init r8
|
|
%define crc_init_dw r8d
|
|
%define crc1 r9
|
|
%define crc2 r10
|
|
|
|
push rbx
|
|
push rdi
|
|
push rsi
|
|
|
|
;; Move crc_init for Linux to a different reg
|
|
%ifidn __OUTPUT_FORMAT__, elf64
|
|
mov crc_init, crc_init_arg
|
|
%endif
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; 1) ALIGN: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
mov bufptmp, bufp ;; rdi = *buf
|
|
neg bufp
|
|
and bufp, 7 ;; calculate the unalignment amount of
|
|
;; the address
|
|
je proc_block ;; Skip if aligned
|
|
|
|
;; If len is less than 8 and we're unaligned, we need to jump
|
|
;; to special code to avoid reading beyond the end of the buffer
|
|
cmp len, 8
|
|
jb less_than_8
|
|
|
|
;;;; Calculate CRC of unaligned bytes of the buffer (if any) ;;;
|
|
mov tmp, [bufptmp] ;; load a quadword from the buffer
|
|
add bufptmp, bufp ;; align buffer pointer for quadword
|
|
;; processing
|
|
sub len, bufp ;; update buffer length
|
|
align_loop:
|
|
crc32 crc_init_dw, bl ;; compute crc32 of 1-byte
|
|
shr tmp, 8 ;; get next byte
|
|
dec bufp
|
|
jne align_loop
|
|
|
|
proc_block:
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; 2) PROCESS BLOCKS: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;; compute num of bytes to be processed
|
|
mov tmp, len ;; save num bytes in tmp
|
|
|
|
cmp len, 128*24
|
|
jae full_block
|
|
|
|
continue_block:
|
|
cmp len, SMALL_SIZE
|
|
jb small
|
|
|
|
;; len < 128*24
|
|
mov rax, 2731 ;; 2731 = ceil(2^16 / 24)
|
|
mul len_dw
|
|
shr rax, 16
|
|
|
|
;; eax contains floor(bytes / 24) = num 24-byte chunks to do
|
|
|
|
;; process rax 24-byte chunks (128 >= rax >= 0)
|
|
|
|
;; compute end address of each block
|
|
;; rdi -> block 0 (base addr + RAX * 8)
|
|
;; rsi -> block 1 (base addr + RAX * 16)
|
|
;; r11 -> block 2 (base addr + RAX * 24)
|
|
lea block_0, [bufptmp + rax * 8]
|
|
lea block_1, [block_0 + rax * 8]
|
|
lea block_2, [block_1 + rax * 8]
|
|
|
|
xor crc1,crc1
|
|
xor crc2,crc2
|
|
|
|
;; branch into array
|
|
lea bufp, [jump_table]
|
|
movzx len, word [bufp + rax * 2] ;; len is offset from crc_array
|
|
lea bufp, [bufp + len + crc_array - jump_table]
|
|
jmp bufp
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; 2a) PROCESS FULL BLOCKS: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
full_block:
|
|
mov rax, 128
|
|
lea block_1, [block_0 + 128*8*2]
|
|
lea block_2, [block_0 + 128*8*3]
|
|
add block_0, 128*8*1
|
|
|
|
xor crc1,crc1
|
|
xor crc2,crc2
|
|
|
|
; ;; branch into array
|
|
; jmp CONCAT(crc_,128,)
|
|
; Fall thruogh into top of crc array (crc_128)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; 3) CRC Array: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
crc_array:
|
|
%assign i 128
|
|
%rep 128-1
|
|
CONCAT(crc_,i,:)
|
|
crc32 crc_init, qword [block_0 - i*8]
|
|
crc32 crc1, qword [block_1 - i*8]
|
|
crc32 crc2, qword [block_2 - i*8]
|
|
%assign i (i-1)
|
|
%endrep
|
|
|
|
CONCAT(crc_,i,:)
|
|
crc32 crc_init, qword [block_0 - i*8]
|
|
crc32 crc1, qword [block_1 - i*8]
|
|
; SKIP ;crc32 crc2, [block_2 - i*8] ; Don't do this one yet
|
|
|
|
mov block_0, block_2
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; 4) Combine three results: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
lea bufp, [K_table - 16] ; first entry is for idx 1
|
|
shl rax, 3 ; rax *= 8
|
|
sub tmp, rax ; tmp -= rax*8
|
|
shl rax, 1
|
|
sub tmp, rax ; tmp -= rax*16 (total tmp -= rax*24)
|
|
add bufp, rax
|
|
|
|
movdqa xmm0, [bufp] ; 2 consts: K1:K2
|
|
|
|
movq xmm1, crc_init ; CRC for block 1
|
|
pclmulqdq xmm1, xmm0, 0x00 ; Multiply by K2
|
|
|
|
movq xmm2, crc1 ; CRC for block 2
|
|
pclmulqdq xmm2, xmm0, 0x10 ; Multiply by K1
|
|
|
|
pxor xmm1, xmm2
|
|
movq rax, xmm1
|
|
xor rax, [block_2 - i*8]
|
|
mov crc_init, crc2
|
|
crc32 crc_init, rax
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; 5) Check for end: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
CONCAT(crc_,0,:)
|
|
mov len, tmp
|
|
cmp tmp, 128*24
|
|
jae full_block
|
|
cmp tmp, 24
|
|
jae continue_block
|
|
|
|
fewer_than_24:
|
|
;; now fewer than 24 bytes remain
|
|
cmp tmp, 16
|
|
jae do_16
|
|
cmp tmp, 8
|
|
jae do_8
|
|
|
|
;; 0 <= tmp <= 7
|
|
shl ebx, 29 ; size now in bits 31:29
|
|
jz do_return
|
|
check_4:
|
|
mov bufp, [bufptmp]
|
|
shl ebx, 1 ; shift out into carry MSB (orig size & 4)
|
|
jnc check_2
|
|
crc32 crc_init_dw, bufp_dw
|
|
jz do_return
|
|
shr bufp, 32 ; shift data down by 4 bytes
|
|
check_2:
|
|
shl ebx, 1 ; shift out into carry MSB (orig size & 2)
|
|
jnc check_1
|
|
crc32 crc_init_dw, bufp_w
|
|
jz do_return
|
|
shr bufp, 16 ; shift data down by 2 bytes
|
|
check_1:
|
|
crc32 crc_init_dw, bufp_b
|
|
|
|
do_return:
|
|
mov rax, crc_init
|
|
pop rsi
|
|
pop rdi
|
|
pop rbx
|
|
ret
|
|
|
|
do_8:
|
|
crc32 crc_init, qword [bufptmp]
|
|
add bufptmp, 8
|
|
shl ebx, 29 ; size (0...7) in bits 31:29
|
|
jnz check_4
|
|
mov rax, crc_init
|
|
pop rsi
|
|
pop rdi
|
|
pop rbx
|
|
ret
|
|
|
|
do_16:
|
|
crc32 crc_init, qword [bufptmp]
|
|
crc32 crc_init, qword [bufptmp+8]
|
|
add bufptmp, 16
|
|
shl ebx, 29 ; size (0...7) in bits 31:29
|
|
jnz check_4
|
|
mov rax, crc_init
|
|
pop rsi
|
|
pop rdi
|
|
pop rbx
|
|
ret
|
|
|
|
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; Handle the case of fewer than 8 bytes, unaligned. In this case
|
|
;; we can't read 8 bytes, as this might go beyond the end of the buffer
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
less_than_8:
|
|
test len,4
|
|
jz less_than_4
|
|
crc32 crc_init_dw, dword[bufptmp]
|
|
add bufptmp,4
|
|
less_than_4:
|
|
test len,2
|
|
jz less_than_2
|
|
crc32 crc_init_dw, word[bufptmp]
|
|
add bufptmp,2
|
|
less_than_2:
|
|
test len,1
|
|
jz do_return
|
|
crc32 crc_init_dw, byte[bufptmp]
|
|
mov rax, crc_init
|
|
pop rsi
|
|
pop rdi
|
|
pop rbx
|
|
ret
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;4) LESS THAN 256-bytes REMAIN AT THIS POINT (8-bits of len are full)
|
|
|
|
small:
|
|
mov rax, crc_init
|
|
|
|
bit8:
|
|
shl len_b, 1 ;; shift-out MSB (bit-7)
|
|
jnc bit7 ;; jump to bit-6 if bit-7 == 0
|
|
%assign i 0
|
|
%rep 16
|
|
crc32 rax, qword [bufptmp+i] ;; compute crc32 of 8-byte data
|
|
%assign i (i+8)
|
|
%endrep
|
|
je do_return2 ;; return if remaining data is zero
|
|
add bufptmp, 128 ;; buf +=64; (next 64 bytes)
|
|
|
|
bit7:
|
|
shl len_b, 1 ;; shift-out MSB (bit-7)
|
|
jnc bit6 ;; jump to bit-6 if bit-7 == 0
|
|
%assign i 0
|
|
%rep 8
|
|
crc32 rax, qword [bufptmp+i] ;; compute crc32 of 8-byte data
|
|
%assign i (i+8)
|
|
%endrep
|
|
je do_return2 ;; return if remaining data is zero
|
|
add bufptmp, 64 ;; buf +=64; (next 64 bytes)
|
|
bit6:
|
|
shl len_b, 1 ;; shift-out MSB (bit-6)
|
|
jnc bit5 ;; jump to bit-5 if bit-6 == 0
|
|
%assign i 0
|
|
%rep 4
|
|
crc32 rax, qword [bufptmp+i] ;; compute crc32 of 8-byte data
|
|
%assign i (i+8)
|
|
%endrep
|
|
je do_return2 ;; return if remaining data is zero
|
|
add bufptmp, 32 ;; buf +=32; (next 32 bytes)
|
|
bit5:
|
|
shl len_b, 1 ;; shift-out MSB (bit-5)
|
|
jnc bit4 ;; jump to bit-4 if bit-5 == 0
|
|
%assign i 0
|
|
%rep 2
|
|
crc32 rax, qword [bufptmp+i] ;; compute crc32 of 8-byte data
|
|
%assign i (i+8)
|
|
%endrep
|
|
je do_return2 ;; return if remaining data is zero
|
|
add bufptmp, 16 ;; buf +=16; (next 16 bytes)
|
|
bit4:
|
|
shl len_b, 1 ;; shift-out MSB (bit-4)
|
|
jnc bit3 ;; jump to bit-3 if bit-4 == 0
|
|
crc32 rax, qword [bufptmp] ;; compute crc32 of 8-byte data
|
|
je do_return2 ;; return if remaining data is zero
|
|
add bufptmp, 8 ;; buf +=8; (next 8 bytes)
|
|
bit3:
|
|
mov rbx, qword [bufptmp] ;; load a 8-bytes from the buffer:
|
|
shl len_b, 1 ;; shift-out MSB (bit-3)
|
|
jnc bit2 ;; jump to bit-2 if bit-3 == 0
|
|
crc32 eax, ebx ;; compute crc32 of 4-byte data
|
|
je do_return2 ;; return if remaining data is zero
|
|
shr rbx, 32 ;; get next 3 bytes
|
|
bit2:
|
|
shl len_b, 1 ;; shift-out MSB (bit-2)
|
|
jnc bit1 ;; jump to bit-1 if bit-2 == 0
|
|
crc32 eax, bx ;; compute crc32 of 2-byte data
|
|
je do_return2 ;; return if remaining data is zero
|
|
shr rbx, 16 ;; next byte
|
|
bit1:
|
|
test len_b,len_b
|
|
je do_return2
|
|
crc32 eax, bl ;; compute crc32 of 1-byte data
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
do_return2:
|
|
pop rsi
|
|
pop rdi
|
|
pop rbx
|
|
ret
|
|
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; jump table ;; Table is 129 entries x 2 bytes each
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
align 4
|
|
jump_table:
|
|
%assign i 0
|
|
%rep 129
|
|
dw CONCAT(crc_,i,) - crc_array
|
|
%assign i (i+1)
|
|
%endrep
|
|
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;; PCLMULQDQ tables
|
|
;; Table is 128 entries x 2 quad words each
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
section .data
|
|
align 64
|
|
K_table:
|
|
dq 0x14cd00bd6, 0x105ec76f0
|
|
dq 0x0ba4fc28e, 0x14cd00bd6
|
|
dq 0x1d82c63da, 0x0f20c0dfe
|
|
dq 0x09e4addf8, 0x0ba4fc28e
|
|
dq 0x039d3b296, 0x1384aa63a
|
|
dq 0x102f9b8a2, 0x1d82c63da
|
|
dq 0x14237f5e6, 0x01c291d04
|
|
dq 0x00d3b6092, 0x09e4addf8
|
|
dq 0x0c96cfdc0, 0x0740eef02
|
|
dq 0x18266e456, 0x039d3b296
|
|
dq 0x0daece73e, 0x0083a6eec
|
|
dq 0x0ab7aff2a, 0x102f9b8a2
|
|
dq 0x1248ea574, 0x1c1733996
|
|
dq 0x083348832, 0x14237f5e6
|
|
dq 0x12c743124, 0x02ad91c30
|
|
dq 0x0b9e02b86, 0x00d3b6092
|
|
dq 0x018b33a4e, 0x06992cea2
|
|
dq 0x1b331e26a, 0x0c96cfdc0
|
|
dq 0x17d35ba46, 0x07e908048
|
|
dq 0x1bf2e8b8a, 0x18266e456
|
|
dq 0x1a3e0968a, 0x11ed1f9d8
|
|
dq 0x0ce7f39f4, 0x0daece73e
|
|
dq 0x061d82e56, 0x0f1d0f55e
|
|
dq 0x0d270f1a2, 0x0ab7aff2a
|
|
dq 0x1c3f5f66c, 0x0a87ab8a8
|
|
dq 0x12ed0daac, 0x1248ea574
|
|
dq 0x065863b64, 0x08462d800
|
|
dq 0x11eef4f8e, 0x083348832
|
|
dq 0x1ee54f54c, 0x071d111a8
|
|
dq 0x0b3e32c28, 0x12c743124
|
|
dq 0x0064f7f26, 0x0ffd852c6
|
|
dq 0x0dd7e3b0c, 0x0b9e02b86
|
|
dq 0x0f285651c, 0x0dcb17aa4
|
|
dq 0x010746f3c, 0x018b33a4e
|
|
dq 0x1c24afea4, 0x0f37c5aee
|
|
dq 0x0271d9844, 0x1b331e26a
|
|
dq 0x08e766a0c, 0x06051d5a2
|
|
dq 0x093a5f730, 0x17d35ba46
|
|
dq 0x06cb08e5c, 0x11d5ca20e
|
|
dq 0x06b749fb2, 0x1bf2e8b8a
|
|
dq 0x1167f94f2, 0x021f3d99c
|
|
dq 0x0cec3662e, 0x1a3e0968a
|
|
dq 0x19329634a, 0x08f158014
|
|
dq 0x0e6fc4e6a, 0x0ce7f39f4
|
|
dq 0x08227bb8a, 0x1a5e82106
|
|
dq 0x0b0cd4768, 0x061d82e56
|
|
dq 0x13c2b89c4, 0x188815ab2
|
|
dq 0x0d7a4825c, 0x0d270f1a2
|
|
dq 0x10f5ff2ba, 0x105405f3e
|
|
dq 0x00167d312, 0x1c3f5f66c
|
|
dq 0x0f6076544, 0x0e9adf796
|
|
dq 0x026f6a60a, 0x12ed0daac
|
|
dq 0x1a2adb74e, 0x096638b34
|
|
dq 0x19d34af3a, 0x065863b64
|
|
dq 0x049c3cc9c, 0x1e50585a0
|
|
dq 0x068bce87a, 0x11eef4f8e
|
|
dq 0x1524fa6c6, 0x19f1c69dc
|
|
dq 0x16cba8aca, 0x1ee54f54c
|
|
dq 0x042d98888, 0x12913343e
|
|
dq 0x1329d9f7e, 0x0b3e32c28
|
|
dq 0x1b1c69528, 0x088f25a3a
|
|
dq 0x02178513a, 0x0064f7f26
|
|
dq 0x0e0ac139e, 0x04e36f0b0
|
|
dq 0x0170076fa, 0x0dd7e3b0c
|
|
dq 0x141a1a2e2, 0x0bd6f81f8
|
|
dq 0x16ad828b4, 0x0f285651c
|
|
dq 0x041d17b64, 0x19425cbba
|
|
dq 0x1fae1cc66, 0x010746f3c
|
|
dq 0x1a75b4b00, 0x18db37e8a
|
|
dq 0x0f872e54c, 0x1c24afea4
|
|
dq 0x01e41e9fc, 0x04c144932
|
|
dq 0x086d8e4d2, 0x0271d9844
|
|
dq 0x160f7af7a, 0x052148f02
|
|
dq 0x05bb8f1bc, 0x08e766a0c
|
|
dq 0x0a90fd27a, 0x0a3c6f37a
|
|
dq 0x0b3af077a, 0x093a5f730
|
|
dq 0x04984d782, 0x1d22c238e
|
|
dq 0x0ca6ef3ac, 0x06cb08e5c
|
|
dq 0x0234e0b26, 0x063ded06a
|
|
dq 0x1d88abd4a, 0x06b749fb2
|
|
dq 0x04597456a, 0x04d56973c
|
|
dq 0x0e9e28eb4, 0x1167f94f2
|
|
dq 0x07b3ff57a, 0x19385bf2e
|
|
dq 0x0c9c8b782, 0x0cec3662e
|
|
dq 0x13a9cba9e, 0x0e417f38a
|
|
dq 0x093e106a4, 0x19329634a
|
|
dq 0x167001a9c, 0x14e727980
|
|
dq 0x1ddffc5d4, 0x0e6fc4e6a
|
|
dq 0x00df04680, 0x0d104b8fc
|
|
dq 0x02342001e, 0x08227bb8a
|
|
dq 0x00a2a8d7e, 0x05b397730
|
|
dq 0x168763fa6, 0x0b0cd4768
|
|
dq 0x1ed5a407a, 0x0e78eb416
|
|
dq 0x0d2c3ed1a, 0x13c2b89c4
|
|
dq 0x0995a5724, 0x1641378f0
|
|
dq 0x19b1afbc4, 0x0d7a4825c
|
|
dq 0x109ffedc0, 0x08d96551c
|
|
dq 0x0f2271e60, 0x10f5ff2ba
|
|
dq 0x00b0bf8ca, 0x00bf80dd2
|
|
dq 0x123888b7a, 0x00167d312
|
|
dq 0x1e888f7dc, 0x18dcddd1c
|
|
dq 0x002ee03b2, 0x0f6076544
|
|
dq 0x183e8d8fe, 0x06a45d2b2
|
|
dq 0x133d7a042, 0x026f6a60a
|
|
dq 0x116b0f50c, 0x1dd3e10e8
|
|
dq 0x05fabe670, 0x1a2adb74e
|
|
dq 0x130004488, 0x0de87806c
|
|
dq 0x000bcf5f6, 0x19d34af3a
|
|
dq 0x18f0c7078, 0x014338754
|
|
dq 0x017f27698, 0x049c3cc9c
|
|
dq 0x058ca5f00, 0x15e3e77ee
|
|
dq 0x1af900c24, 0x068bce87a
|
|
dq 0x0b5cfca28, 0x0dd07448e
|
|
dq 0x0ded288f8, 0x1524fa6c6
|
|
dq 0x059f229bc, 0x1d8048348
|
|
dq 0x06d390dec, 0x16cba8aca
|
|
dq 0x037170390, 0x0a3e3e02c
|
|
dq 0x06353c1cc, 0x042d98888
|
|
dq 0x0c4584f5c, 0x0d73c7bea
|
|
dq 0x1f16a3418, 0x1329d9f7e
|
|
dq 0x0531377e2, 0x185137662
|
|
dq 0x1d8d9ca7c, 0x1b1c69528
|
|
dq 0x0b25b29f2, 0x18a08b5bc
|
|
dq 0x19fb2a8b0, 0x02178513a
|
|
dq 0x1a08fe6ac, 0x1da758ae0
|
|
dq 0x045cddf4e, 0x0e0ac139e
|
|
dq 0x1a91647f2, 0x169cf9eb0
|
|
dq 0x1a0f717c4, 0x0170076fa
|
|
|
|
;;; func core, ver, snum
|
|
slversion crc32_iscsi_01, 01, 03, 0015
|
|
|