| /* |
| * Copyright 2017, Data61, CSIRO (ABN 41 687 119 230) |
| * |
| * SPDX-License-Identifier: BSD-2-Clause |
| */ |
| |
| /* Include Kconfig variables. */ |
| #include <autoconf.h> |
| #include <sel4test-driver/gen_config.h> |
| #include <sel4test/gen_config.h> |
| |
| #include <stdio.h> |
| #include <assert.h> |
| |
| #include <sel4/sel4.h> |
| #include <vka/object.h> |
| |
| #include "../test.h" |
| |
| #if CONFIG_SIZE_BITS == 64 |
| #define MAGIC_WORD 0xdeadbeefdead0000 |
| #else |
| #define MAGIC_WORD 0x7ead0000u |
| #endif |
| /* |
| * Perform the codeblock given in "code", testing registers before and after to |
| * ensure that cloberring does not occur. |
| */ |
| #if defined(CONFIG_ARCH_AARCH32) |
| #define TEST_MRS 0, 0, 0, 0 |
| #define TEST_REGISTERS(code) \ |
| do { \ |
| register int a00 = 0xdead0000; \ |
| register int a01 = 0xdead0001; \ |
| register int a02 = 0xdead0002; \ |
| register int a03 = 0xdead0003; \ |
| register int a04 = 0xdead0004; \ |
| register int a05 = 0xdead0005; \ |
| register int a06 = 0xdead0006; \ |
| register int a07 = 0xdead0007; \ |
| register int a08 = 0xdead0008; \ |
| register int a09 = 0xdead0009; \ |
| register int a10 = 0xdead000a; \ |
| register int a11 = 0xdead000b; \ |
| __asm__ __volatile__ ("" \ |
| : "+r"(a00), "+r"(a01), "+r"(a02), "+r"(a03), \ |
| "+r"(a04), "+r"(a05), "+r"(a06), "+r"(a07), \ |
| "+r"(a08), "+r"(a09), "+r"(a10), "+r"(a11)); \ |
| code ; \ |
| __asm__ __volatile__ ("" \ |
| : "+r"(a00), "+r"(a01), "+r"(a02), "+r"(a03), \ |
| "+r"(a04), "+r"(a05), "+r"(a06), "+r"(a07), \ |
| "+r"(a08), "+r"(a09), "+r"(a10), "+r"(a11)); \ |
| test_assert(a00 == 0xdead0000); \ |
| test_assert(a01 == 0xdead0001); \ |
| test_assert(a02 == 0xdead0002); \ |
| test_assert(a03 == 0xdead0003); \ |
| test_assert(a04 == 0xdead0004); \ |
| test_assert(a05 == 0xdead0005); \ |
| test_assert(a06 == 0xdead0006); \ |
| test_assert(a07 == 0xdead0007); \ |
| test_assert(a08 == 0xdead0008); \ |
| test_assert(a09 == 0xdead0009); \ |
| test_assert(a10 == 0xdead000a); \ |
| test_assert(a11 == 0xdead000b); \ |
| } while (0) |
| #elif defined(CONFIG_ARCH_AARCH64) |
| #define TEST_MRS 0, 0, 0, 0 |
| #define TEST_REGISTERS(code) \ |
| do { \ |
| register long a00 = 0xdeadbeefdead0000; \ |
| register long a01 = 0xdeadbeefdead0001; \ |
| register long a02 = 0xdeadbeefdead0002; \ |
| register long a03 = 0xdeadbeefdead0003; \ |
| register long a04 = 0xdeadbeefdead0004; \ |
| register long a05 = 0xdeadbeefdead0005; \ |
| register long a06 = 0xdeadbeefdead0006; \ |
| register long a07 = 0xdeadbeefdead0007; \ |
| register long a08 = 0xdeadbeefdead0008; \ |
| register long a09 = 0xdeadbeefdead0009; \ |
| register long a10 = 0xdeadbeefdead000a; \ |
| register long a11 = 0xdeadbeefdead000b; \ |
| register long a12 = 0xdeadbeefdead000c; \ |
| register long a13 = 0xdeadbeefdead000d; \ |
| register long a14 = 0xdeadbeefdead000e; \ |
| register long a15 = 0xdeadbeefdead000f; \ |
| code ; \ |
| __asm__ __volatile__ ("" \ |
| : "+r"(a00), "+r"(a01), "+r"(a02), "+r"(a03), \ |
| "+r"(a04), "+r"(a05), "+r"(a06), "+r"(a07), \ |
| "+r"(a08), "+r"(a10), "+r"(a11), "+r"(a12), \ |
| "+r"(a13)); \ |
| test_assert(a00 == 0xdeadbeefdead0000); \ |
| test_assert(a01 == 0xdeadbeefdead0001); \ |
| test_assert(a02 == 0xdeadbeefdead0002); \ |
| test_assert(a03 == 0xdeadbeefdead0003); \ |
| test_assert(a04 == 0xdeadbeefdead0004); \ |
| test_assert(a05 == 0xdeadbeefdead0005); \ |
| test_assert(a06 == 0xdeadbeefdead0006); \ |
| test_assert(a07 == 0xdeadbeefdead0007); \ |
| test_assert(a08 == 0xdeadbeefdead0008); \ |
| test_assert(a09 == 0xdeadbeefdead0009); \ |
| test_assert(a10 == 0xdeadbeefdead000a); \ |
| test_assert(a11 == 0xdeadbeefdead000b); \ |
| test_assert(a12 == 0xdeadbeefdead000c); \ |
| test_assert(a13 == 0xdeadbeefdead000d); \ |
| test_assert(a14 == 0xdeadbeefdead000e); \ |
| test_assert(a15 == 0xdeadbeefdead000f); \ |
| } while (0) |
| #elif defined(CONFIG_ARCH_X86_64) |
| #define TEST_MRS 0, 0, 0, 0 |
| #define TEST_REGISTERS(code) \ |
| do { \ |
| register long a00 = 0xdeadbeefdead0000; \ |
| register long a01 = 0xdeadbeefdead0001; \ |
| register long a02 = 0xdeadbeefdead0002; \ |
| register long a03 = 0xdeadbeefdead0003; \ |
| register long a04 = 0xdeadbeefdead0004; \ |
| register long a05 = 0xdeadbeefdead0005; \ |
| register long a06 = 0xdeadbeefdead0006; \ |
| register long a07 = 0xdeadbeefdead0007; \ |
| register long a08 = 0xdeadbeefdead0008; \ |
| register long a09 = 0xdeadbeefdead0009; \ |
| register long a10 = 0xdeadbeefdead000a; \ |
| register long a11 = 0xdeadbeefdead000b; \ |
| register long a12 = 0xdeadbeefdead000c; \ |
| register long a13 = 0xdeadbeefdead000d; \ |
| register long a14 = 0xdeadbeefdead000e; \ |
| register long a15 = 0xdeadbeefdead000f; \ |
| code ; \ |
| __asm__ __volatile__ ("" \ |
| : "+r"(a00), "+r"(a01), "+r"(a02), "+r"(a03), \ |
| "+r"(a04), "+r"(a05), "+r"(a06), "+r"(a07), \ |
| "+r"(a08), "+r"(a10), "+r"(a11), "+r"(a12), \ |
| "+r"(a13)); \ |
| test_assert(a00 == 0xdeadbeefdead0000); \ |
| test_assert(a01 == 0xdeadbeefdead0001); \ |
| test_assert(a02 == 0xdeadbeefdead0002); \ |
| test_assert(a03 == 0xdeadbeefdead0003); \ |
| test_assert(a04 == 0xdeadbeefdead0004); \ |
| test_assert(a05 == 0xdeadbeefdead0005); \ |
| test_assert(a06 == 0xdeadbeefdead0006); \ |
| test_assert(a07 == 0xdeadbeefdead0007); \ |
| test_assert(a08 == 0xdeadbeefdead0008); \ |
| test_assert(a09 == 0xdeadbeefdead0009); \ |
| test_assert(a10 == 0xdeadbeefdead000a); \ |
| test_assert(a11 == 0xdeadbeefdead000b); \ |
| test_assert(a12 == 0xdeadbeefdead000c); \ |
| test_assert(a13 == 0xdeadbeefdead000d); \ |
| test_assert(a14 == 0xdeadbeefdead000e); \ |
| test_assert(a15 == 0xdeadbeefdead000f); \ |
| } while (0) |
| #elif defined(CONFIG_ARCH_IA32) |
| #ifdef CONFIG_KERNEL_MCS |
| #define TEST_MRS 0 |
| #else |
| #define TEST_MRS 0, 0 |
| #endif |
| |
| #define TEST_REGISTERS(code) \ |
| do { \ |
| register int a00 = 0xdead0000; \ |
| register int a01 = 0xdead0001; \ |
| register int a02 = 0xdead0002; \ |
| register int a03 = 0xdead0003; \ |
| register int a04 = 0xdead0004; \ |
| register int a05 = 0xdead0005; \ |
| register int a06 = 0xdead0006; \ |
| register int a07 = 0xdead0007; \ |
| code ; \ |
| __asm__ __volatile__ ("" \ |
| : "+r"(a00), "+r"(a01), "+r"(a02), "+r"(a03), \ |
| "+r"(a04), "+r"(a05)); \ |
| test_assert(a00 == 0xdead0000); \ |
| test_assert(a01 == 0xdead0001); \ |
| test_assert(a02 == 0xdead0002); \ |
| test_assert(a03 == 0xdead0003); \ |
| test_assert(a04 == 0xdead0004); \ |
| test_assert(a05 == 0xdead0005); \ |
| test_assert(a06 == 0xdead0006); \ |
| test_assert(a07 == 0xdead0007); \ |
| } while (0) |
| #elif defined(CONFIG_ARCH_RISCV) |
| #define TEST_MRS 0, 0, 0, 0 |
| #define TEST_REGISTERS(code) \ |
| do { \ |
| register unsigned long a00 = MAGIC_WORD + 0; \ |
| register unsigned long a01 = MAGIC_WORD + 1; \ |
| register unsigned long a02 = MAGIC_WORD + 2; \ |
| register unsigned long a03 = MAGIC_WORD + 3; \ |
| register unsigned long a04 = MAGIC_WORD + 4; \ |
| register unsigned long a05 = MAGIC_WORD + 5; \ |
| register unsigned long a06 = MAGIC_WORD + 6; \ |
| register unsigned long a07 = MAGIC_WORD + 7; \ |
| register unsigned long a08 = MAGIC_WORD + 8; \ |
| register unsigned long a09 = MAGIC_WORD + 9; \ |
| register unsigned long a10 = MAGIC_WORD + 10; \ |
| register unsigned long a11 = MAGIC_WORD + 11; \ |
| register unsigned long a12 = MAGIC_WORD + 12; \ |
| register unsigned long a13 = MAGIC_WORD + 13; \ |
| register unsigned long a14 = MAGIC_WORD + 14; \ |
| register unsigned long a15 = MAGIC_WORD + 15; \ |
| code ; \ |
| __asm__ __volatile__ ("" \ |
| : "+r"(a00), "+r"(a01), "+r"(a02), "+r"(a03), \ |
| "+r"(a04), "+r"(a05), "+r"(a06), "+r"(a07), \ |
| "+r"(a08), "+r"(a10), "+r"(a11), "+r"(a12), \ |
| "+r"(a13)); \ |
| test_assert(a00 == MAGIC_WORD + 0); \ |
| test_assert(a01 == MAGIC_WORD + 1); \ |
| test_assert(a02 == MAGIC_WORD + 2); \ |
| test_assert(a03 == MAGIC_WORD + 3); \ |
| test_assert(a04 == MAGIC_WORD + 4); \ |
| test_assert(a05 == MAGIC_WORD + 5); \ |
| test_assert(a06 == MAGIC_WORD + 6); \ |
| test_assert(a07 == MAGIC_WORD + 7); \ |
| test_assert(a08 == MAGIC_WORD + 8); \ |
| test_assert(a09 == MAGIC_WORD + 9); \ |
| test_assert(a10 == MAGIC_WORD + 10); \ |
| test_assert(a11 == MAGIC_WORD + 11); \ |
| test_assert(a12 == MAGIC_WORD + 12); \ |
| test_assert(a13 == MAGIC_WORD + 13); \ |
| test_assert(a14 == MAGIC_WORD + 14); \ |
| test_assert(a15 == MAGIC_WORD + 15); \ |
| } while (0) |
| #else |
| #error "Unknown architecture." |
| #endif |
| |
| /* Generate a stub that tests the code "_code" with TEST_REGISTERS. */ |
| #define GENERATE_SYSCALL_TEST_MAYBE(_test, _syscall, _code, _enabled) \ |
| static int test_ ## _syscall(driver_env_t env) { \ |
| for (int i = 0; i < 10; i++) \ |
| TEST_REGISTERS(_code); \ |
| return sel4test_get_result(); \ |
| } \ |
| DEFINE_TEST_BOOTSTRAP(_test, "Basic " #_syscall "() testing", test_ ## _syscall, _enabled) |
| #define GENERATE_SYSCALL_TEST(_test, _syscall, _code) \ |
| GENERATE_SYSCALL_TEST_MAYBE(_test, _syscall, _code, true) |
| |
| /* |
| * Generate testing stubs for each of the basic system calls. |
| */ |
| |
| GENERATE_SYSCALL_TEST(SYSCALL0000, seL4_Yield, |
| seL4_Yield()); |
| |
| GENERATE_SYSCALL_TEST(SYSCALL0001, seL4_Send, |
| seL4_Send(simple_get_cnode(&env->simple), seL4_MessageInfo_new(0, 0, 0, 0))) |
| |
| GENERATE_SYSCALL_TEST(SYSCALL0002, seL4_NBSend, |
| seL4_NBSend(simple_get_cnode(&env->simple), seL4_MessageInfo_new(0, 0, 0, 0))) |
| |
| GENERATE_SYSCALL_TEST_MAYBE(SYSCALL0003, api_reply, |
| api_reply(0, seL4_MessageInfo_new(0, 0, 0, 0)), !config_set(CONFIG_KERNEL_MCS)) |
| |
| GENERATE_SYSCALL_TEST(SYSCALL0004, seL4_Signal, |
| seL4_Signal(simple_get_cnode(&env->simple))) |
| |
| GENERATE_SYSCALL_TEST(SYSCALL0005, seL4_Call, |
| seL4_Call(simple_get_cnode(&env->simple), seL4_MessageInfo_new(0, 0, 0, 0))) |
| |
| static int |
| test_debug_put_char(driver_env_t env) |
| { |
| for (int i = 0; i < 10; i++) { |
| #ifdef CONFIG_PRINTING |
| TEST_REGISTERS(seL4_DebugPutChar(' ')); |
| #endif |
| } |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST_BOOTSTRAP(SYSCALL0006, "Basic seL4_DebugPutChar() testing", test_debug_put_char, true) |
| |
| /* Slightly more complex tests for waiting, because we actually have |
| * to wait on something real. */ |
| static int |
| test_recv(driver_env_t env) |
| { |
| /* Allocate an notification. */ |
| seL4_CPtr notification; |
| notification = vka_alloc_notification_leaky(&env->vka); |
| |
| for (int i = 0; i < 10; i++) { |
| /* Notify it, so that we don't block. */ |
| seL4_Signal(notification); |
| |
| /* Recv for the notification. */ |
| TEST_REGISTERS(seL4_Wait(notification, NULL)); |
| } |
| |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST_BOOTSTRAP(SYSCALL0010, "Basic seL4_Recv() testing", test_recv, true) |
| |
| static int |
| test_reply_recv(driver_env_t env) |
| { |
| /* Allocate an notification. */ |
| seL4_CPtr notification; |
| notification = vka_alloc_notification_leaky(&env->vka); |
| |
| for (int i = 0; i < 10; i++) { |
| /* Notify it, so that we don't block. */ |
| seL4_Signal(notification); |
| |
| /* ReplyRecv for the notification. */ |
| TEST_REGISTERS(api_reply_recv(notification, seL4_MessageInfo_new(0, 0, 0, 0), NULL, seL4_CapNull)); |
| } |
| |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST_BOOTSTRAP(SYSCALL0011, "Basic seL4_ReplyRecv() testing", test_reply_recv, true) |
| |
| static int |
| test_nb_recv(driver_env_t env) |
| { |
| /* Allocate an notification. */ |
| seL4_CPtr notification; |
| notification = vka_alloc_notification_leaky(&env->vka); |
| |
| for (int i = 0; i < 10; i++) { |
| /* Notify it, so that we don't block. */ |
| seL4_Signal(notification); |
| |
| /* Recv for the notification. */ |
| TEST_REGISTERS(api_nbrecv(notification, NULL, seL4_CapNull)); |
| } |
| |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST_BOOTSTRAP(SYSCALL0012, "Basic seL4_NBRecv() testing", test_nb_recv, true) |
| |
| static int |
| test_wait(driver_env_t env) |
| { |
| /* Allocate an notification. */ |
| seL4_CPtr notification; |
| notification = vka_alloc_notification_leaky(&env->vka); |
| |
| for (int i = 0; i < 10; i++) { |
| /* Notify it, so that we don't block. */ |
| seL4_Signal(notification); |
| |
| /* Recv for the notification. */ |
| TEST_REGISTERS(seL4_Wait(notification, NULL)); |
| } |
| |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST_BOOTSTRAP(SYSCALL0013, "Basic seL4_Wait() testing", test_wait, true) |
| |
| /* |
| * Let's not forget our friends in the *WithMRs community. |
| */ |
| |
| GENERATE_SYSCALL_TEST(SYSCALL0014, seL4_SendWithMRs, |
| seL4_SendWithMRs(simple_get_cnode(&env->simple), seL4_MessageInfo_new(0, 0, 0, 0), TEST_MRS)) |
| |
| GENERATE_SYSCALL_TEST(SYSCALL0015, seL4_NBSendWithMRs, |
| seL4_NBSendWithMRs(simple_get_cnode(&env->simple), seL4_MessageInfo_new(0, 0, 0, 0), TEST_MRS)) |
| |
| #ifndef CONFIG_KERNEL_MCS |
| /* the seL4_ReplyWithMRs symbol is not defined in non RT builds and so we must #ifdef out */ |
| GENERATE_SYSCALL_TEST_MAYBE(SYSCALL0016, seL4_ReplyWithMRs, |
| seL4_ReplyWithMRs(seL4_MessageInfo_new(0, 0, 0, 0), TEST_MRS), !config_set(CONFIG_KERNEL_MCS)) |
| #endif |
| GENERATE_SYSCALL_TEST(SYSCALL0017, seL4_CallWithMRs, |
| seL4_CallWithMRs(simple_get_cnode(&env->simple), seL4_MessageInfo_new(0, 0, 0, 0), TEST_MRS)) |
| |
| #ifdef CONFIG_KERNEL_MCS |
| static int |
| test_nbsend_recv(driver_env_t env) |
| { |
| seL4_CPtr ntfn = vka_alloc_notification_leaky(&env->vka); |
| |
| for (int i = 0; i < 10; i++) { |
| /* Notify it so we don't block */ |
| seL4_Signal(ntfn); |
| TEST_REGISTERS(api_nbsend_recv(simple_get_cnode(&env->simple), seL4_MessageInfo_new(0, 0, 0, 0), |
| ntfn, NULL, seL4_CapNull)); |
| } |
| |
| return sel4test_get_result(); |
| } |
| DEFINE_TEST_BOOTSTRAP(SYSCALL0018, "Basic seL4_NBSendRecv testing", test_nbsend_recv, config_set(CONFIG_KERNEL_MCS)) |
| #endif |
