Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 590 insertions, 0 deletions

diff --git a/src/isa-l/crc/crc32_iscsi_01.asm b/src/isa-l/crc/crc32_iscsi_01.asm
new file mode 100644
index 000000000..2a815177a
--- /dev/null
+++ b/src/isa-l/crc/crc32_iscsi_01.asm
@@ -0,0 +1,590 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;  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:ISAL_SYM_TYPE_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
+
+	;; If len is less than 8 we need to jump to special code to avoid
+	;; reading beyond the end of the buffer
+	cmp	len, 8
+	jb	less_than_8
+
+	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	;; 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
+
+	;;;; 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:
+	cmp 	len, 128*24*2
+	jbe 	non_prefetch
+
+%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]
+
+ %if i > 128*8 / 32	; prefetch next 3KB data
+	prefetchnta [block_2 + 128*32 - i*32]
+ %endif
+
+%assign i (i-1)
+%endrep
+ 	jmp next_
+
+non_prefetch:
+%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
+
+next_:
+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[bufp]
+	add	bufp,4
+less_than_4:
+	test	len,2
+	jz	less_than_2
+	crc32	crc_init_dw, word[bufp]
+	add	bufp,2
+less_than_2:
+	test	len,1
+	jz	do_return
+	crc32	crc_init_dw, byte[bufp]
+	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,   04,  0015
+