From 8f537c13bc1fe4b3a24c941d469316d61483cbcb Mon Sep 17 00:00:00 2001 From: Paul Mackerras Date: Sat, 25 Jan 2025 09:14:02 +1100 Subject: [PATCH] tests: Add a test for the hash instructions hash{st,cmp}[p] Signed-off-by: Paul Mackerras --- tests/hash/Makefile | 3 + tests/hash/hash.c | 465 ++++++++++++++++++++++++++++++++++++ tests/hash/head.S | 231 ++++++++++++++++++ tests/hash/powerpc.lds | 27 +++ tests/test_hash.bin | Bin 0 -> 16432 bytes tests/test_hash.console_out | 4 + tests/test_hash.metavalue | 1 + 7 files changed, 731 insertions(+) create mode 100644 tests/hash/Makefile create mode 100644 tests/hash/hash.c create mode 100644 tests/hash/head.S create mode 100644 tests/hash/powerpc.lds create mode 100755 tests/test_hash.bin create mode 100644 tests/test_hash.console_out create mode 100644 tests/test_hash.metavalue diff --git a/tests/hash/Makefile b/tests/hash/Makefile new file mode 100644 index 0000000..175df3d --- /dev/null +++ b/tests/hash/Makefile @@ -0,0 +1,3 @@ +TEST=hash + +include ../Makefile.test diff --git a/tests/hash/hash.c b/tests/hash/hash.c new file mode 100644 index 0000000..5d48893 --- /dev/null +++ b/tests/hash/hash.c @@ -0,0 +1,465 @@ +#include +#include +#include + +#include "console.h" + +#define MSR_LE 0x1 +#define MSR_DR 0x10 +#define MSR_IR 0x20 +#define MSR_SF 0x8000000000000000ul + +extern unsigned long hash1(unsigned long, unsigned long); +extern unsigned long hash1b(unsigned long, unsigned long); +extern unsigned long hash2(unsigned long, unsigned long); +extern unsigned long hash2b(unsigned long, unsigned long); +extern unsigned long hash3(unsigned long, unsigned long); +extern unsigned long hash3b(unsigned long, unsigned long); +extern unsigned long hash4(unsigned long, unsigned long); +extern unsigned long hash4b(unsigned long, unsigned long); + +extern unsigned long callit(unsigned long arg1, unsigned long arg2, + unsigned long fn(unsigned long, unsigned long), + unsigned long msr); + +static inline void do_tlbie(unsigned long rb, unsigned long rs) +{ + __asm__ volatile("tlbie %0,%1" : : "r" (rb), "r" (rs) : "memory"); +} + +#define DSISR 18 +#define DAR 19 +#define SRR0 26 +#define SRR1 27 +#define PID 48 +#define SPRG0 272 +#define SPRG1 273 +#define SPRG3 275 +#define HSRR0 314 +#define HSRR1 315 +#define PTCR 464 +#define HASHKEY 468 +#define HASHPKEY 469 + +static inline unsigned long mfspr(int sprnum) +{ + long val; + + __asm__ volatile("mfspr %0,%1" : "=r" (val) : "i" (sprnum)); + return val; +} + +static inline void mtspr(int sprnum, unsigned long val) +{ + __asm__ volatile("mtspr %0,%1" : : "i" (sprnum), "r" (val)); +} + +static inline unsigned long mfmsr(void) +{ + unsigned long val; + + __asm__ volatile("mfmsr %0" : "=r" (val)); + return val; +} + +static inline void store_pte(unsigned long *p, unsigned long pte) +{ + __asm__ volatile("stdbrx %1,0,%0" : : "r" (p), "r" (pte) : "memory"); +} + +void print_string(const char *str) +{ + for (; *str; ++str) + putchar(*str); +} + +void print_hex(unsigned long val, int ndigit) +{ + int i, x; + + for (i = (ndigit - 1) * 4; i >= 0; i -= 4) { + x = (val >> i) & 0xf; + if (x >= 10) + putchar(x + 'a' - 10); + else + putchar(x + '0'); + } +} + +// i < 100 +void print_test_number(int i) +{ + print_string("test "); + putchar(48 + i/10); + putchar(48 + i%10); + putchar(':'); +} + +#define CACHE_LINE_SIZE 64 + +void zero_memory(void *ptr, unsigned long nbytes) +{ + unsigned long nb, i, nl; + void *p; + + for (; nbytes != 0; nbytes -= nb, ptr += nb) { + nb = -((unsigned long)ptr) & (CACHE_LINE_SIZE - 1); + if (nb == 0 && nbytes >= CACHE_LINE_SIZE) { + nl = nbytes / CACHE_LINE_SIZE; + p = ptr; + for (i = 0; i < nl; ++i) { + __asm__ volatile("dcbz 0,%0" : : "r" (p) : "memory"); + p += CACHE_LINE_SIZE; + } + nb = nl * CACHE_LINE_SIZE; + } else { + if (nb > nbytes) + nb = nbytes; + for (i = 0; i < nb; ++i) + ((unsigned char *)ptr)[i] = 0; + } + } +} + +#define PERM_EX 0x001 +#define PERM_WR 0x002 +#define PERM_RD 0x004 +#define PERM_PRIV 0x008 +#define ATTR_NC 0x020 +#define CHG 0x080 +#define REF 0x100 + +#define DFLT_PERM (PERM_EX | PERM_WR | PERM_RD | REF | CHG) + +/* + * Set up an MMU translation tree using memory starting at the 64k point. + * We use 3 levels, mapping 512GB, with 4kB PGD/PMD/PTE pages. + */ +unsigned long *part_tbl = (unsigned long *) 0x10000; +unsigned long *proc_tbl = (unsigned long *) 0x11000; +unsigned long *pgdir = (unsigned long *) 0x12000; +unsigned long free_ptr = 0x13000; + +void init_mmu(void) +{ + /* set up partition table */ + store_pte(&part_tbl[1], (unsigned long)proc_tbl); + /* set up process table */ + zero_memory(proc_tbl, 512 * sizeof(unsigned long)); + mtspr(PTCR, (unsigned long)part_tbl); + mtspr(PID, 1); + zero_memory(pgdir, 512 * sizeof(unsigned long)); + /* RTS = 8 (512GB address space), RPDS = 9 (512-entry top level) */ + store_pte(&proc_tbl[2 * 1], (unsigned long) pgdir | 0x2000000000000009); + do_tlbie(0xc00, 0); /* invalidate all TLB entries */ +} + +static unsigned long *read_pd(unsigned long *pdp, unsigned long i) +{ + unsigned long ret; + + __asm__ volatile("ldbrx %0,%1,%2" : "=r" (ret) : "b" (pdp), + "r" (i * sizeof(unsigned long))); + return (unsigned long *) (ret & 0x00ffffffffffff00); +} + +void map(unsigned long ea, unsigned long pa, unsigned long perm_attr) +{ + unsigned long epn = ea >> 12; + unsigned long h, i, j; + unsigned long *ptep; + unsigned long *pmdp; + + h = (epn >> 18) & 0x1ff; + i = (epn >> 9) & 0x1ff; + j = epn & 0x1ff; + if (pgdir[h] == 0) { + zero_memory((void *)free_ptr, 512 * sizeof(unsigned long)); + store_pte(&pgdir[h], 0x8000000000000000 | free_ptr | 9); + free_ptr += 512 * sizeof(unsigned long); + } + pmdp = read_pd(pgdir, h); + if (pmdp[i] == 0) { + zero_memory((void *)free_ptr, 512 * sizeof(unsigned long)); + store_pte(&pmdp[i], 0x8000000000000000 | free_ptr | 9); + free_ptr += 512 * sizeof(unsigned long); + } + ptep = read_pd(pmdp, i); + if (ptep[j]) { + ptep[j] = 0; + do_tlbie(ea & ~0xfff, 0); + } + store_pte(&ptep[j], 0xc000000000000000 | (pa & 0x00fffffffffff000) | + perm_attr); +} + +void unmap(void *ea) +{ + unsigned long epn = (unsigned long) ea >> 12; + unsigned long h, i, j; + unsigned long *ptep, *pmdp; + + h = (epn >> 18) & 0x1ff; + i = (epn >> 9) & 0x1ff; + j = epn & 0x1ff; + if (pgdir[h] == 0) + return; + pmdp = read_pd(pgdir, h); + if (pmdp[i] == 0) + return; + ptep = read_pd(pmdp, i); + ptep[j] = 0; + do_tlbie(((unsigned long)ea & ~0xfff), 0); +} + +static inline unsigned short rot_r_16(unsigned short x, int n) +{ + return (x >> n) | (x << (16 - n)); +} + +static inline unsigned short rot_l_16(unsigned short x, int n) +{ + return (x << n) | (x >> (16 - n)); +} + +unsigned int simon_like_32_64(unsigned int x, unsigned long long key, + unsigned int lane) +{ + unsigned short c = 0xfffc; + unsigned long long z0 = 0xFA2561CDF44AC398ull; + unsigned int result; + unsigned short z, temp; + unsigned short k[33], eff_k[33], xleft[33], xright[33], fxleft[33]; + int i; + + z = 0; + k[0] = key >> 48; + k[1] = key >> 32; + k[2] = key >> 16; + k[3] = key; + xleft[0] = x; + xright[0] = x >> 16; + for (i = 0; i < 28; ++i) { + z = (z0 >> (63 - i)) & 1; + temp = rot_r_16(k[i+3], 3) ^ k[i+1]; + k[i+4] = c ^ z ^ k[i] ^ temp ^ rot_r_16(temp, 1); + } + for (i = 0; i < 8; ++i) { + eff_k[4*i + 0] = k[4*i + ((0 + lane) % 4)]; + eff_k[4*i + 1] = k[4*i + ((1 + lane) % 4)]; + eff_k[4*i + 2] = k[4*i + ((2 + lane) % 4)]; + eff_k[4*i + 3] = k[4*i + ((3 + lane) % 4)]; + } + for (i = 0; i < 32; ++i) { + fxleft[i] = (rot_l_16(xleft[i], 1) & rot_l_16(xleft[i], 8)) ^ + rot_l_16(xleft[i], 2); + xleft[i+1] = xright[i] ^ fxleft[i] ^ eff_k[i]; + xright[i+1] = xleft[i]; + } + result = ((unsigned int)xright[32] << 16) | xleft[32]; + return result; +} + +unsigned long long hash_digest(unsigned long long x, unsigned long long y, + unsigned long long key) +{ + unsigned int stage0[4]; + unsigned int stage1[4]; + unsigned long long result; + unsigned int i; + + for (i = 0; i < 4; ++i) + stage0[i] = 0; + for (i = 0; i < 8; ++i) + stage0[i/2] = (stage0[i/2] << 16) | (((y >> (i * 8)) & 0xff) << 8) | + ((x >> (56 - (i * 8))) & 0xff); + for (i = 0; i < 4; ++i) + stage1[i] = simon_like_32_64(stage0[i], key, i); + result = (((unsigned long long)stage1[0] << 32) | stage1[1]) ^ + (((unsigned long long)stage1[2] << 32) | stage1[3]); + return result; +} + +unsigned long notstack[33]; +unsigned long correct_hash; +unsigned long rb = 0x0f0e0d0c0b0a0908ul; +unsigned long key = 0x123456789abcdef0ul; + +int hash_test_1(void) +{ + unsigned long ret; + + ret = callit((unsigned long) ¬stack[32], rb, hash1, mfmsr()); + if (ret) + return ret; + if (notstack[31] != correct_hash) { + print_hex(notstack[31], 16); + putchar(' '); + return 1; + } + notstack[31] = 0; + ret = callit((unsigned long) ¬stack[32], rb, hash1b, mfmsr()); + if (ret) + return ret; + if (notstack[0] != correct_hash) { + print_hex(notstack[0], 16); + putchar(' '); + return 2; + } + return 0; +} + +int hash_test_2(void) +{ + unsigned long ret; + + notstack[31] = correct_hash; + ret = callit((unsigned long) ¬stack[32], rb, hash2, mfmsr()); + if (ret) + return ret; + notstack[31] ^= 0x1000; + ret = callit((unsigned long) ¬stack[32], rb, hash2, mfmsr()); + if (ret != 0x700) { + print_hex(notstack[31], 16); + putchar(' '); + return ret | 1; + } + if (mfspr(SPRG0) != (unsigned long) &hash2) { + print_hex(mfspr(SPRG0), 16); + putchar(' '); + return 2; + } + if ((mfspr(SPRG3) & 0xffff0000ul) != 0x00020000) { + print_hex(mfspr(SPRG3), 8); + putchar(' '); + return 3; + } + notstack[0] = correct_hash; + ret = callit((unsigned long) ¬stack[32], rb, hash2b, mfmsr()); + if (ret) + return ret | 4; + notstack[0] ^= 0x1000; + ret = callit((unsigned long) ¬stack[32], rb, hash2b, mfmsr()); + if (ret != 0x700) { + print_hex(notstack[31], 16); + putchar(' '); + return ret | 5; + } + return 0; +} + +int hash_test_3(void) +{ + unsigned long ret; + + ret = callit((unsigned long) ¬stack[32], rb, hash3, mfmsr()); + if (ret) + return ret; + if (notstack[31] != correct_hash) { + print_hex(notstack[31], 16); + putchar(' '); + return 1; + } + notstack[31] = 0; + ret = callit((unsigned long) ¬stack[32], rb, hash3b, mfmsr()); + if (ret) + return ret; + if (notstack[0] != correct_hash) { + print_hex(notstack[0], 16); + putchar(' '); + return 2; + } + return 0; +} + +int hash_test_4(void) +{ + unsigned long ret; + + notstack[31] = correct_hash; + ret = callit((unsigned long) ¬stack[32], rb, hash4, mfmsr()); + if (ret) + return ret; + notstack[31] ^= 0x1000; + ret = callit((unsigned long) ¬stack[32], rb, hash4, mfmsr()); + if (ret != 0x700) { + print_hex(notstack[31], 16); + putchar(' '); + return ret | 1; + } + if (mfspr(SPRG0) != (unsigned long) &hash4) { + print_hex(mfspr(SPRG0), 16); + putchar(' '); + return 2; + } + if ((mfspr(SPRG3) & 0xffff0000ul) != 0x00020000) { + print_hex(mfspr(SPRG3), 8); + putchar(' '); + return 3; + } + notstack[0] = correct_hash; + ret = callit((unsigned long) ¬stack[32], rb, hash4b, mfmsr()); + if (ret) + return ret | 4; + notstack[0] ^= 0x1000; + ret = callit((unsigned long) ¬stack[32], rb, hash4b, mfmsr()); + if (ret != 0x700) { + print_hex(notstack[31], 16); + putchar(' '); + return ret | 5; + } + return 0; +} + +int fail = 0; + +void do_test(int num, int (*test)(void)) +{ + int ret; + + print_test_number(num); + ret = test(); + if (ret == 0) { + print_string("PASS\r\n"); + } else { + fail = 1; + print_string("FAIL "); + print_hex(ret, 8); + if (ret != 0 && (ret & ~0xfe0ul) == 0) { + print_string(" SRR0="); + print_hex(mfspr(SPRG0), 16); + print_string(" SRR1="); + print_hex(mfspr(SPRG1), 16); + } + print_string("\r\n"); + } +} + +int main(void) +{ + unsigned long ra; + + console_init(); + + ra = (unsigned long)¬stack[32]; + /* cache the usual value */ + if (ra == 0x4190) { + correct_hash = 0xcd57657a24afdd14ul; + } else { + correct_hash = hash_digest(ra, rb, key); + print_hex(ra, 16); + putchar(' '); + print_hex(correct_hash, 16); + print_string("\r\n"); + } + + mtspr(HASHKEY, key); + do_test(1, hash_test_1); + do_test(2, hash_test_2); + mtspr(HASHKEY, ~0ul); + mtspr(HASHPKEY, key); + do_test(3, hash_test_3); + do_test(4, hash_test_4); + + return fail; +} diff --git a/tests/hash/head.S b/tests/hash/head.S new file mode 100644 index 0000000..b669a3d --- /dev/null +++ b/tests/hash/head.S @@ -0,0 +1,231 @@ +/* Copyright 2013-2014 IBM Corp. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + * implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* Load an immediate 64-bit value into a register */ +#define LOAD_IMM64(r, e) \ + lis r,(e)@highest; \ + ori r,r,(e)@higher; \ + rldicr r,r, 32, 31; \ + oris r,r, (e)@h; \ + ori r,r, (e)@l; + + .section ".head","ax" + + /* + * Microwatt currently enters in LE mode at 0x0, so we don't need to + * do any endian fix ups + */ + . = 0 +.global _start +_start: + LOAD_IMM64(%r10,__bss_start) + LOAD_IMM64(%r11,__bss_end) + subf %r11,%r10,%r11 + addi %r11,%r11,63 + srdi. %r11,%r11,6 + beq 2f + mtctr %r11 +1: dcbz 0,%r10 + addi %r10,%r10,64 + bdnz 1b + +2: LOAD_IMM64(%r1,__stack_top) + li %r0,0 + stdu %r0,-16(%r1) + mtsprg2 %r0 + LOAD_IMM64(%r12, main) + mtctr %r12 + bctrl + attn // terminate on exit + b . + +exception: + mfsprg2 %r0 + cmpdi %r0,0 + bne call_ret + attn + +#define EXCEPTION(nr) \ + .= nr ;\ + li %r3,nr ;\ + b exception + + EXCEPTION(0x300) + EXCEPTION(0x380) + EXCEPTION(0x400) + EXCEPTION(0x480) + EXCEPTION(0x500) + EXCEPTION(0x600) + EXCEPTION(0x700) + EXCEPTION(0x800) + EXCEPTION(0x900) + EXCEPTION(0x980) + EXCEPTION(0xa00) + EXCEPTION(0xb00) + EXCEPTION(0xd00) + EXCEPTION(0xe00) + EXCEPTION(0xe20) + EXCEPTION(0xe40) + EXCEPTION(0xe60) + EXCEPTION(0xe80) + EXCEPTION(0xf00) + EXCEPTION(0xf20) + EXCEPTION(0xf40) + EXCEPTION(0xf60) + EXCEPTION(0xf80) + + /* + * Call a function in a context with a given MSR value. + * r3, r4 = args; r5 = function; r6 = MSR + */ + .globl callit +callit: + mflr %r0 + std %r0,16(%r1) + stdu %r1,-256(%r1) + mfcr %r8 + stw %r8,100(%r1) + std %r13,104(%r1) + std %r14,112(%r1) + std %r15,120(%r1) + std %r16,128(%r1) + std %r17,136(%r1) + std %r18,144(%r1) + std %r19,152(%r1) + std %r20,160(%r1) + std %r21,168(%r1) + std %r22,176(%r1) + std %r23,184(%r1) + std %r24,192(%r1) + std %r25,200(%r1) + std %r26,208(%r1) + std %r27,216(%r1) + std %r28,224(%r1) + std %r29,232(%r1) + std %r30,240(%r1) + std %r31,248(%r1) + li %r0,restore@l + mtsprg0 %r0 + mtsprg1 %r1 + mtsprg2 %r2 + mfmsr %r9 + mtsprg3 %r9 + li %r10,call_ret@l + mtlr %r10 + mtsrr0 %r5 + mtsrr1 %r6 + mr %r12,%r5 + rfid +call_ret: + tdi 0,%r0,0x48 /* b .+8 if wrong endian */ + b 2f /* if endian OK */ + /* reverse-endian version of instructions from 2: on */ + .long 0xa642107c + .long 0xa642937c + .long 0xa602ba7c + .long 0xa602db7c + .long 0xa643b07c + .long 0xa643d37c + .long 0xa6031a7c + .long 0xa6039b7c + .long 0x2400004c +2: mfsprg0 %r0 + mfsprg3 %r4 + mfsrr0 %r5 + mfsrr1 %r6 + mtsprg0 %r5 + mtsprg3 %r6 + mtsrr0 %r0 + mtsrr1 %r4 + rfid +restore: + mfsprg1 %r1 + mfsprg2 %r2 + li %r7,0 + mtsprg2 %r7 + lwz %r8,100(%r1) + mtcr %r8 + ld %r13,104(%r1) + ld %r14,112(%r1) + ld %r15,120(%r1) + ld %r16,128(%r1) + ld %r17,136(%r1) + ld %r18,144(%r1) + ld %r19,152(%r1) + ld %r20,160(%r1) + ld %r21,168(%r1) + ld %r22,176(%r1) + ld %r23,184(%r1) + ld %r24,192(%r1) + ld %r25,200(%r1) + ld %r26,208(%r1) + ld %r27,216(%r1) + ld %r28,224(%r1) + ld %r29,232(%r1) + ld %r30,240(%r1) + ld %r31,248(%r1) + addi %r1,%r1,256 + ld %r0,16(%r1) + mtlr %r0 + blr + + .globl hash1 +hash1: + hashst %r4,-8(%r3) + li %r3,0 + blr + + .globl hash1b +hash1b: + hashst %r4,-256(%r3) + li %r3,0 + blr + + .globl hash2 +hash2: + hashchk %r4,-8(%r3) + li %r3,0 + blr + + .globl hash2b +hash2b: + hashchk %r4,-256(%r3) + li %r3,0 + blr + + .globl hash3 +hash3: + hashstp %r4,-8(%r3) + li %r3,0 + blr + + .globl hash3b +hash3b: + hashstp %r4,-256(%r3) + li %r3,0 + blr + + .globl hash4 +hash4: + hashchkp %r4,-8(%r3) + li %r3,0 + blr + + .globl hash4b +hash4b: + hashchkp %r4,-256(%r3) + li %r3,0 + blr diff --git a/tests/hash/powerpc.lds b/tests/hash/powerpc.lds new file mode 100644 index 0000000..99611ab --- /dev/null +++ b/tests/hash/powerpc.lds @@ -0,0 +1,27 @@ +SECTIONS +{ + . = 0; + _start = .; + .head : { + KEEP(*(.head)) + } + . = ALIGN(0x1000); + .text : { *(.text) *(.text.*) *(.rodata) *(.rodata.*) } + . = ALIGN(0x1000); + .data : { *(.data) *(.data.*) *(.got) *(.toc) } + . = ALIGN(0x80); + __bss_start = .; + .bss : { + *(.dynsbss) + *(.sbss) + *(.scommon) + *(.dynbss) + *(.bss) + *(.common) + *(.bss.*) + } + . = ALIGN(0x80); + __bss_end = .; + . = . + 0x4000; + __stack_top = .; +} diff --git a/tests/test_hash.bin b/tests/test_hash.bin new file mode 100755 index 0000000000000000000000000000000000000000..0a7074b97763b29bd2484c21dc0cedf1e9c35ffc GIT binary patch literal 16432 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