| /* |
| * Copyright 2019, Data61, CSIRO (ABN 41 687 119 230) |
| * |
| * SPDX-License-Identifier: BSD-2-Clause |
| */ |
| |
| #include <autoconf.h> |
| /* test_registers (below) runs in a context without a valid SP. At the end it |
| * needs to call into a C function and needs a valid stack to do this. We |
| * provide it a stack it can switch to here. |
| */ |
| .section .bss |
| .align 4 |
| .space 4096 |
| _safe_stack: |
| .section .text |
| #if defined(CONFIG_ARCH_AARCH32) |
| |
| /* Trampoline for providing the thread a valid stack before entering |
| * reply_to_parent. No blx required because reply_to_parent does not |
| * return. |
| */ |
| reply_trampoline: |
| ldr sp, =_safe_stack |
| b reply_to_parent |
| |
| .global test_registers |
| test_registers: |
| /* Assume the PC and CPSR are correct because there's no good way of |
| * testing them. Test each of the registers against the magic numbers our |
| * parent set. |
| */ |
| cmp sp, #13 |
| bne test_registers_fail |
| cmp r0, #15 |
| bne test_registers_fail |
| cmp r1, #1 |
| bne test_registers_fail |
| cmp r2, #2 |
| bne test_registers_fail |
| cmp r3, #3 |
| bne test_registers_fail |
| cmp r4, #4 |
| bne test_registers_fail |
| cmp r5, #5 |
| bne test_registers_fail |
| cmp r6, #6 |
| bne test_registers_fail |
| cmp r7, #7 |
| bne test_registers_fail |
| cmp r8, #8 |
| bne test_registers_fail |
| cmp r9, #9 |
| bne test_registers_fail |
| cmp r10, #10 |
| bne test_registers_fail |
| cmp r11, #11 |
| bne test_registers_fail |
| cmp r12, #12 |
| bne test_registers_fail |
| cmp r14, #14 |
| bne test_registers_fail |
| |
| /* Return success. Note that we don't bother saving registers or bl because |
| * we're not planning to return here and we don't have a valid stack. |
| */ |
| mov r0, #0 |
| b reply_trampoline |
| |
| /* Return failure. */ |
| test_registers_fail: |
| mov r0, #1 |
| b reply_trampoline |
| |
| #elif defined(CONFIG_ARCH_AARCH64) |
| /* Trampoline for providing the thread a valid stack before entering |
| * reply_to_parent. No blx required because reply_to_parent does not |
| * return. |
| */ |
| reply_trampoline: |
| ldr x1, =_safe_stack |
| mov sp, x1 |
| b reply_to_parent |
| |
| .global test_registers |
| test_registers: |
| cmp sp, #1 |
| bne test_registers_fail |
| cmp x0, #2 |
| bne test_registers_fail |
| cmp x1, #3 |
| bne test_registers_fail |
| cmp x2, #4 |
| bne test_registers_fail |
| cmp x3, #5 |
| bne test_registers_fail |
| cmp x4, #6 |
| bne test_registers_fail |
| cmp x5, #7 |
| bne test_registers_fail |
| cmp x6, #8 |
| bne test_registers_fail |
| cmp x7, #9 |
| bne test_registers_fail |
| cmp x8, #10 |
| bne test_registers_fail |
| cmp x9, #11 |
| bne test_registers_fail |
| cmp x10, #12 |
| bne test_registers_fail |
| cmp x11, #13 |
| bne test_registers_fail |
| cmp x12, #14 |
| bne test_registers_fail |
| cmp x13, #15 |
| bne test_registers_fail |
| cmp x14, #16 |
| bne test_registers_fail |
| cmp x15, #17 |
| bne test_registers_fail |
| cmp x16, #18 |
| bne test_registers_fail |
| cmp x17, #19 |
| bne test_registers_fail |
| cmp x18, #20 |
| bne test_registers_fail |
| cmp x19, #21 |
| bne test_registers_fail |
| cmp x20, #22 |
| bne test_registers_fail |
| cmp x21, #23 |
| bne test_registers_fail |
| cmp x22, #24 |
| bne test_registers_fail |
| cmp x23, #25 |
| bne test_registers_fail |
| cmp x24, #26 |
| bne test_registers_fail |
| cmp x25, #27 |
| bne test_registers_fail |
| cmp x26, #28 |
| bne test_registers_fail |
| cmp x27, #29 |
| bne test_registers_fail |
| cmp x28, #30 |
| bne test_registers_fail |
| cmp x29, #31 |
| bne test_registers_fail |
| cmp x30, #32 |
| bne test_registers_fail |
| |
| /* Return success. Note that we don't bother saving registers or bl because |
| * we're not planning to return here and we don't have a valid stack. |
| */ |
| mov x0, #0 |
| b reply_trampoline |
| |
| /* Return failure. */ |
| test_registers_fail: |
| mov x0, #1 |
| b reply_trampoline |
| |
| #elif defined(CONFIG_ARCH_X86_64) |
| reply_trampoline: |
| leaq _safe_stack, %rsp |
| movq %rax, %rdi |
| call reply_to_parent |
| .global test_registers |
| test_registers: |
| jb rflags_ok |
| jmp test_registers_fail |
| rflags_ok: |
| cmpq $0x0000000a, %rax |
| jne test_registers_fail |
| movq $2, %rax |
| cmpq $0x0000000b, %rbx |
| jne test_registers_fail |
| movq $3, %rax |
| cmpq $0x0000000c, %rcx |
| jne test_registers_fail |
| movq $4, %rax |
| cmpq $0x0000000d, %rdx |
| jne test_registers_fail |
| movq $5, %rax |
| cmpq $0x00000005, %rsi |
| jne test_registers_fail |
| movq $6, %rax |
| cmpq $0x00000002, %rdi |
| jne test_registers_fail |
| movq $7, %rax |
| cmpq $0x00000003, %rbp |
| jne test_registers_fail |
| movq $8, %rax |
| cmpq $0x00000004, %rsp |
| jne test_registers_fail |
| movq $9, %rax |
| cmpq $0x00000088, %r8 |
| jne test_registers_fail |
| movq $100, %rax |
| cmpq $0x00000099, %r9 |
| jne test_registers_fail |
| movq $11, %rax |
| cmpq $0x00000010, %r10 |
| jne test_registers_fail |
| movq $12, %rax |
| cmpq $0x00000011, %r11 |
| jne test_registers_fail |
| movq $13, %rax |
| cmpq $0x00000012, %r12 |
| jne test_registers_fail |
| movq $14, %rax |
| cmpq $0x00000013, %r13 |
| jne test_registers_fail |
| movq $15, %rax |
| cmpq $0x00000014, %r14 |
| jne test_registers_fail |
| movq $16, %rax |
| cmpq $0x00000015, %r15 |
| jne test_registers_fail |
| movq $0, %rax |
| jmp reply_trampoline |
| test_registers_fail: |
| movq $1, %rax |
| jmp reply_trampoline |
| |
| #elif defined(CONFIG_ARCH_X86) |
| /* As for the ARM implementation above, but we also need to massage the |
| * calling convention by taking the value test_registers passed us in EAX |
| * and put it on the stack where reply_to_parent expects it. |
| */ |
| reply_trampoline: |
| leal _safe_stack, %esp |
| pushl %eax |
| call reply_to_parent |
| |
| .global test_registers |
| test_registers: |
| /* Assume EIP, GS and FS are correct. Is there a good way to |
| * test these? |
| * EIP - If this is incorrect we'll never arrive at this function. |
| * GS - With an incorrect GDT selector we fault and die immediately. |
| * FS - Overwritten by the kernel before we jump here. |
| */ |
| |
| /* We need to test EFLAGS indirectly because we can't cmp it. The jb |
| * should only be taken if CF (bit 0) is set. |
| */ |
| jb eflags_ok |
| jmp test_registers_fail |
| eflags_ok: |
| cmpl $0x0000000a, %eax |
| jne test_registers_fail |
| cmpl $0x0000000b, %ebx |
| jne test_registers_fail |
| cmpl $0x0000000c, %ecx |
| jne test_registers_fail |
| cmpl $0x0000000d, %edx |
| jne test_registers_fail |
| cmpl $0x00000005, %esi |
| jne test_registers_fail |
| cmpl $0x00000002, %edi |
| jne test_registers_fail |
| cmpl $0x00000003, %ebp |
| jne test_registers_fail |
| cmpl $0x00000004, %esp |
| jne test_registers_fail |
| |
| /* Return success. Note we use a custom calling convention because we |
| * don't have a valid stack. |
| */ |
| movl $0, %eax |
| jmp reply_trampoline |
| |
| /* Return failure. */ |
| test_registers_fail: |
| movl $1, %eax |
| jmp reply_trampoline |
| #elif defined(CONFIG_ARCH_RISCV) |
| /* Trampoline for providing the thread a valid stack before entering |
| * reply_to_parent. No jal required because reply_to_parent does not |
| * return. |
| */ |
| reply_trampoline: |
| la a1, _safe_stack |
| mv sp, a1 |
| j reply_to_parent |
| |
| .global test_registers |
| test_registers: |
| |
| li a0, 1 |
| bne ra, a0, test_registers_fail |
| li a0, 2 |
| bne sp, a0, test_registers_fail |
| li a0, 4 |
| bne t0, a0, test_registers_fail |
| li a0, 5 |
| bne t1, a0, test_registers_fail |
| li a0, 6 |
| bne t2, a0, test_registers_fail |
| li a0, 7 |
| bne s0, a0, test_registers_fail |
| li a0, 8 |
| bne s1, a0, test_registers_fail |
| li a0, 10 |
| bne a1, a0, test_registers_fail |
| li a0, 11 |
| bne a2, a0, test_registers_fail |
| li a0, 12 |
| bne a0, a3, test_registers_fail |
| li a0, 13 |
| bne a0, a4, test_registers_fail |
| li a0, 14 |
| bne a0, a5, test_registers_fail |
| li a0, 15 |
| bne a0, a6, test_registers_fail |
| #if 0 |
| /* skip x3, see below */ |
| context.x4 = 3; |
| #endif |
| |
| /* Return success. Note that we don't bother saving registers or bl because |
| * we're not planning to return here and we don't have a valid stack. |
| */ |
| mv a0, x0 |
| j reply_trampoline |
| |
| /* Return failure. */ |
| test_registers_fail: |
| li a0, 1 |
| j reply_trampoline |
| |
| #else |
| #error Unsupported architecture |
| #endif |
| |
