| /* |
| * Copyright (c) 2015, Google Inc. All rights reserved |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining |
| * a copy of this software and associated documentation files |
| * (the "Software"), to deal in the Software without restriction, |
| * including without limitation the rights to use, copy, modify, merge, |
| * publish, distribute, sublicense, and/or sell copies of the Software, |
| * and to permit persons to whom the Software is furnished to do so, |
| * subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be |
| * included in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| |
| #include <assert.h> |
| #include <err.h> |
| #include <kernel/usercopy.h> |
| #include <lib/unittest/unittest.h> |
| #include <lk/init.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <trusty/string.h> |
| #ifdef ARCH_ARM64 |
| #include <arch/safecopy.h> |
| #endif |
| |
| #define PORT_NAME "com.android.kernel.usercopy-unittest" |
| |
| #define TEST_BUF_SIZE (16) |
| #define TEST_BUF1_SIZE (TEST_BUF_SIZE / 2) |
| #define TEST_BUF2_SIZE (TEST_BUF_SIZE - TEST_BUF1_SIZE) |
| #define TEST_BUF_COPY_START (1) |
| #define TEST_BUF_COPY_SIZE (TEST_BUF_SIZE - TEST_BUF_COPY_START - 1) |
| #define TEST_BUF1_COPY_SIZE (TEST_BUF1_SIZE - TEST_BUF_COPY_START) |
| #define TEST_BUF2_COPY_SIZE (TEST_BUF_COPY_SIZE - TEST_BUF1_COPY_SIZE) |
| #define TEST_BUF_COPY_LAST (TEST_BUF_SIZE - 1 - 1) |
| #define TEST_BUF2_COPY_LAST (TEST_BUF_COPY_LAST - TEST_BUF1_SIZE) |
| |
| #define SRC_DATA (0x22) |
| #define DEST_DATA (0x11) |
| |
| #define FLAGS_NO_PAGE (ARCH_MMU_FLAG_INVALID) |
| #define FLAGS_NO_USER (0u) |
| #define FLAGS_RO_USER (ARCH_MMU_FLAG_PERM_USER | ARCH_MMU_FLAG_PERM_RO) |
| #define FLAGS_RW_USER (ARCH_MMU_FLAG_PERM_USER) |
| |
| #define STACK_ADDR_IDX (0) |
| #define HEAP_ADDR_IDX (1) |
| #define GLOBAL_ADDR_IDX (2) |
| |
| #define START_PAGE_ADDR ((void*)(PAGE_SIZE * 0x10)) |
| #define TEST_BUF_ADDR \ |
| ((user_addr_t)((uintptr_t)(START_PAGE_ADDR + PAGE_SIZE - TEST_BUF1_SIZE))) |
| |
| static inline user_addr_t get_addr_param(void) { |
| const void* const* param_arr = GetParam(); |
| const user_addr_t* addr = param_arr[0]; |
| return *addr; |
| } |
| |
| static inline uint32_t get_start_flags_param(void) { |
| const void* const* param_arr = GetParam(); |
| const uint32_t* start_flags = param_arr[1]; |
| return *start_flags; |
| } |
| |
| static inline uint32_t get_end_flags_param(void) { |
| const void* const* param_arr = GetParam(); |
| const uint32_t* end_flags = param_arr[2]; |
| return *end_flags; |
| } |
| |
| static int checkbuf(const char* buf, char c, size_t size) { |
| int error_count = 0; |
| for (size_t i = 0; i < size; i++) { |
| if (buf[i] != c) { |
| error_count++; |
| } |
| } |
| return error_count; |
| } |
| |
| static void usercopy_test_init_buf(char* kbuf1, |
| char* kbuf2, |
| uint8_t val, |
| int null_offset) { |
| if (kbuf1) { |
| memset(kbuf1, val, TEST_BUF1_SIZE); |
| if (null_offset >= 0 && null_offset < TEST_BUF1_SIZE) { |
| kbuf1[null_offset] = '\0'; |
| } |
| } |
| if (kbuf2) { |
| memset(kbuf2, val, TEST_BUF2_SIZE); |
| if (null_offset >= TEST_BUF1_SIZE && null_offset < TEST_BUF_SIZE) { |
| kbuf2[null_offset - TEST_BUF1_SIZE] = '\0'; |
| } |
| } |
| } |
| |
| typedef struct { |
| struct vmm_aspace* aspace; |
| } usercopytest_t; |
| |
| TEST_F_SETUP(usercopytest) { |
| int ret; |
| void* addr = START_PAGE_ADDR; |
| uint32_t start_flags = get_start_flags_param(); |
| uint32_t end_flags = get_end_flags_param(); |
| |
| _state->aspace = NULL; |
| |
| ret = vmm_create_aspace(&_state->aspace, "usercopy_test", 0); |
| ASSERT_EQ(NO_ERROR, ret); |
| |
| if (start_flags != FLAGS_NO_PAGE) { |
| ret = vmm_alloc(_state->aspace, "start-page", PAGE_SIZE, &addr, 0, |
| VMM_FLAG_VALLOC_SPECIFIC | VMM_FLAG_NO_END_GUARD, |
| start_flags | ARCH_MMU_FLAG_PERM_NO_EXECUTE); |
| ASSERT_EQ(NO_ERROR, ret); |
| ASSERT_EQ(START_PAGE_ADDR, addr); |
| } |
| |
| addr += PAGE_SIZE; |
| |
| if (end_flags != FLAGS_NO_PAGE) { |
| ret = vmm_alloc(_state->aspace, "end-page", PAGE_SIZE, &addr, 0, |
| VMM_FLAG_VALLOC_SPECIFIC | VMM_FLAG_NO_START_GUARD, |
| end_flags | ARCH_MMU_FLAG_PERM_NO_EXECUTE); |
| ASSERT_EQ(NO_ERROR, ret); |
| ASSERT_EQ(START_PAGE_ADDR + PAGE_SIZE, addr); |
| } |
| |
| vmm_set_active_aspace(_state->aspace); |
| |
| test_abort: |
| return; |
| } |
| |
| TEST_F_TEARDOWN(usercopytest) { |
| vmm_set_active_aspace(NULL); |
| |
| if (_state->aspace) { |
| vmm_free_aspace(_state->aspace); |
| } |
| } |
| |
| TEST_P(usercopytest, copy_to_user) { |
| user_addr_t addr = get_addr_param(); |
| uint32_t arch_mmu_flags_start = get_start_flags_param(); |
| uint32_t arch_mmu_flags_end = get_end_flags_param(); |
| int ret; |
| char src_buf[TEST_BUF_SIZE]; |
| char* dest_kbuf1; |
| char* dest_kbuf2; |
| char expect1; |
| char expect2; |
| |
| dest_kbuf1 = paddr_to_kvaddr(vaddr_to_paddr((void*)(uintptr_t)addr)); |
| dest_kbuf2 = paddr_to_kvaddr( |
| vaddr_to_paddr((void*)(uintptr_t)addr + TEST_BUF1_SIZE)); |
| |
| /* dest buffs should be NULL iff their flags are FLAGS_NO_PAGE */ |
| EXPECT_EQ((dest_kbuf1 == NULL), (arch_mmu_flags_start == FLAGS_NO_PAGE)); |
| EXPECT_EQ((dest_kbuf2 == NULL), (arch_mmu_flags_end == FLAGS_NO_PAGE)); |
| |
| usercopy_test_init_buf(dest_kbuf1, dest_kbuf2, DEST_DATA, -1); |
| memset(src_buf, SRC_DATA, sizeof(src_buf)); |
| |
| /* Zero-length copy should always succeed */ |
| ret = copy_to_user(addr + TEST_BUF_COPY_START, NULL, 0); |
| EXPECT_EQ(0, ret); |
| |
| /* Dest buffer should be untouched after zero-length copy */ |
| if (dest_kbuf1) { |
| EXPECT_EQ(0, checkbuf(dest_kbuf1, DEST_DATA, TEST_BUF1_SIZE)); |
| } |
| if (dest_kbuf2) { |
| EXPECT_EQ(0, checkbuf(dest_kbuf2, DEST_DATA, TEST_BUF2_SIZE)); |
| } |
| |
| /* Perform non-zero length copy */ |
| ret = copy_to_user(addr + TEST_BUF_COPY_START, |
| src_buf + TEST_BUF_COPY_START, TEST_BUF_COPY_SIZE); |
| |
| /* |
| * If both pages are writeable copy_to_user should succeed otherwise it |
| * should return ERR_FAULT. |
| */ |
| if (arch_mmu_flags_start == ARCH_MMU_FLAG_PERM_USER && |
| arch_mmu_flags_end == ARCH_MMU_FLAG_PERM_USER) { |
| /* |
| * If both pages are writeable from user-space copy_to_user should |
| * return success and every byte should be copied to dest_buf. |
| */ |
| EXPECT_EQ(0, ret); |
| expect1 = SRC_DATA; |
| expect2 = SRC_DATA; |
| } else { |
| /* |
| * If one of the pages is not writeable from user-space copy_to_user |
| * should return ERR_FAULT. If only the first page is writeable everying |
| * should be copied in the first page or nothing should be copied in the |
| * first page. If the first page is not writeable, nothing should be |
| * copied to either page. If the second page is not writeable, no data |
| * should be copied to it, even if the first page was written to. |
| */ |
| EXPECT_EQ(ERR_FAULT, ret); |
| if (arch_mmu_flags_start == ARCH_MMU_FLAG_PERM_USER && |
| dest_kbuf1[TEST_BUF_COPY_START] == SRC_DATA) { |
| expect1 = SRC_DATA; |
| } else { |
| expect1 = DEST_DATA; |
| } |
| expect2 = DEST_DATA; |
| } |
| |
| /* copy_to_user should not modify src_buf at all */ |
| EXPECT_EQ(0, checkbuf(src_buf, SRC_DATA, TEST_BUF_SIZE)); |
| |
| if (dest_kbuf1) { |
| /* Dest byte before copied region should be untouched */ |
| EXPECT_EQ(DEST_DATA, dest_kbuf1[0]); |
| |
| /* Check that copied region match expected value we selected above */ |
| EXPECT_EQ(0, checkbuf(dest_kbuf1 + TEST_BUF_COPY_START, expect1, |
| TEST_BUF1_COPY_SIZE)); |
| } |
| |
| if (dest_kbuf2) { |
| /* Check that copied region match expected value we selected above */ |
| EXPECT_EQ(0, checkbuf(dest_kbuf2, expect2, TEST_BUF2_COPY_SIZE)); |
| |
| /* Dest byte after copied region should be untouched */ |
| EXPECT_EQ(DEST_DATA, dest_kbuf2[TEST_BUF2_SIZE - 1]); |
| } |
| } |
| |
| TEST_P(usercopytest, copy_from_user) { |
| user_addr_t addr = get_addr_param(); |
| uint32_t arch_mmu_flags_start = get_start_flags_param(); |
| uint32_t arch_mmu_flags_end = get_end_flags_param(); |
| int ret; |
| char dest_buf[TEST_BUF_SIZE]; |
| char* src_kbuf1; |
| char* src_kbuf2; |
| char expect1; |
| char expect2; |
| |
| memset(dest_buf, DEST_DATA, sizeof(dest_buf)); |
| src_kbuf1 = paddr_to_kvaddr(vaddr_to_paddr((void*)(uintptr_t)addr)); |
| src_kbuf2 = paddr_to_kvaddr( |
| vaddr_to_paddr((void*)(uintptr_t)addr + TEST_BUF1_SIZE)); |
| |
| /* src buffs should be NULL iff their flags are FLAGS_NO_PAGE */ |
| EXPECT_EQ((src_kbuf1 == NULL), (arch_mmu_flags_start == FLAGS_NO_PAGE)); |
| EXPECT_EQ((src_kbuf2 == NULL), (arch_mmu_flags_end == FLAGS_NO_PAGE)); |
| |
| usercopy_test_init_buf(src_kbuf1, src_kbuf2, SRC_DATA, -1); |
| |
| /* Zero-length copy should always succeed */ |
| ret = copy_from_user(NULL, addr + TEST_BUF_COPY_START, 0); |
| EXPECT_EQ(0, ret); |
| |
| /* Dest buffer should be untouched after zero-length copy */ |
| EXPECT_EQ(0, checkbuf(dest_buf, DEST_DATA, TEST_BUF_SIZE)); |
| |
| /* Perform non-zero length copy */ |
| ret = copy_from_user(dest_buf + TEST_BUF_COPY_START, |
| addr + TEST_BUF_COPY_START, TEST_BUF_COPY_SIZE); |
| if (arch_mmu_flags_start & arch_mmu_flags_end & ARCH_MMU_FLAG_PERM_USER) { |
| /* |
| * If both pages are readable from user-space copy_from_user should |
| * return success and every byte should be copied to dest_buf. |
| */ |
| EXPECT_EQ(0, ret); |
| expect1 = SRC_DATA; |
| expect2 = SRC_DATA; |
| } else { |
| /* |
| * If one of the pages is not readable from user-space copy_from_user |
| * should return ERR_FAULT, and the parts of dest_buf that could not be |
| * copied into should be set to 0. |
| * The destination kernel buffer should always be written so |
| * potentially uninitialized kernel data does not leak. |
| */ |
| EXPECT_EQ(ERR_FAULT, ret); |
| if (!(arch_mmu_flags_start & ARCH_MMU_FLAG_PERM_USER) || |
| !dest_buf[TEST_BUF_COPY_START]) { |
| expect1 = 0; |
| } else { |
| expect1 = SRC_DATA; |
| } |
| expect2 = 0; |
| } |
| |
| EXPECT_EQ(0, checkbuf(dest_buf + TEST_BUF_COPY_START, expect1, |
| TEST_BUF1_COPY_SIZE)); |
| EXPECT_EQ(0, checkbuf(dest_buf + TEST_BUF1_SIZE, expect2, |
| TEST_BUF2_COPY_SIZE)); |
| |
| /* Dest bytes before and after copied region should be untouched */ |
| EXPECT_EQ(DEST_DATA, dest_buf[0]); |
| EXPECT_EQ(DEST_DATA, dest_buf[TEST_BUF_SIZE - 1]); |
| |
| /* Src buffer should not be modified */ |
| if (src_kbuf1) { |
| EXPECT_EQ(0, checkbuf(src_kbuf1, SRC_DATA, TEST_BUF1_SIZE)); |
| } |
| if (src_kbuf2) { |
| EXPECT_EQ(0, checkbuf(src_kbuf2, SRC_DATA, TEST_BUF2_SIZE)); |
| } |
| } |
| |
| #if ARCH_ARM64 |
| #define ENABLED_ON_ARM64_NAME(name) name |
| #else |
| #define ENABLED_ON_ARM64_NAME(name) DISABLED_##name |
| #define copy_from_anywhere(dst, src, len) -1 |
| #endif |
| |
| TEST_P(usercopytest, ENABLED_ON_ARM64_NAME(copy_from_anywhere)) { |
| user_addr_t addr = get_addr_param(); |
| uint32_t arch_mmu_flags_start = get_start_flags_param(); |
| uint32_t arch_mmu_flags_end = get_end_flags_param(); |
| int ret; |
| char dest_buf[TEST_BUF_SIZE]; |
| char* src_kbuf1; |
| char* src_kbuf2; |
| char expect1; |
| char expect2; |
| |
| memset(dest_buf, DEST_DATA, sizeof(dest_buf)); |
| src_kbuf1 = paddr_to_kvaddr(vaddr_to_paddr((void*)(uintptr_t)addr)); |
| src_kbuf2 = paddr_to_kvaddr( |
| vaddr_to_paddr((void*)(uintptr_t)addr + TEST_BUF1_SIZE)); |
| |
| /* src buffs should be NULL iff their flags are FLAGS_NO_PAGE */ |
| EXPECT_EQ((src_kbuf1 == NULL), (arch_mmu_flags_start == FLAGS_NO_PAGE)); |
| EXPECT_EQ((src_kbuf2 == NULL), (arch_mmu_flags_end == FLAGS_NO_PAGE)); |
| |
| usercopy_test_init_buf(src_kbuf1, src_kbuf2, SRC_DATA, -1); |
| |
| /* Zero-length copy should always succeed */ |
| ret = copy_from_anywhere(NULL, addr + TEST_BUF_COPY_START, 0); |
| EXPECT_EQ(0, ret); |
| |
| /* Dest buffer should be untouched after zero-length copy */ |
| EXPECT_EQ(0, checkbuf(dest_buf, DEST_DATA, TEST_BUF_SIZE)); |
| |
| /* Perform non-zero length copy */ |
| ret = copy_from_anywhere(dest_buf + TEST_BUF_COPY_START, |
| addr + TEST_BUF_COPY_START, TEST_BUF_COPY_SIZE); |
| if (arch_mmu_flags_start != FLAGS_NO_PAGE && |
| arch_mmu_flags_end != FLAGS_NO_PAGE) { |
| /* |
| * If both pages are readable, copy_from_anywhere should return |
| * success and every byte should be copied to dest_buf. |
| */ |
| EXPECT_EQ(0, ret); |
| expect1 = SRC_DATA; |
| expect2 = SRC_DATA; |
| } else { |
| /* |
| * If one of the pages is not readable copy_from_anywhere should |
| * return ERR_FAULT, and the parts of dest_buf that could not be |
| * copied into should be set to 0. |
| * The destination kernel buffer should always be written so |
| * potentially uninitialized kernel data does not leak. |
| */ |
| EXPECT_EQ(ERR_FAULT, ret); |
| if (arch_mmu_flags_start == FLAGS_NO_PAGE) { |
| expect1 = 0; |
| } else { |
| expect1 = SRC_DATA; |
| } |
| expect2 = 0; |
| } |
| |
| EXPECT_EQ(0, checkbuf(dest_buf + TEST_BUF_COPY_START, expect1, |
| TEST_BUF1_COPY_SIZE)); |
| EXPECT_EQ(0, checkbuf(dest_buf + TEST_BUF1_SIZE, expect2, |
| TEST_BUF2_COPY_SIZE)); |
| |
| /* Dest bytes before and after copied region should be untouched */ |
| EXPECT_EQ(DEST_DATA, dest_buf[0]); |
| EXPECT_EQ(DEST_DATA, dest_buf[TEST_BUF_SIZE - 1]); |
| |
| /* Src buffer should not be modified */ |
| if (src_kbuf1) { |
| EXPECT_EQ(0, checkbuf(src_kbuf1, SRC_DATA, TEST_BUF1_SIZE)); |
| } |
| if (src_kbuf2) { |
| EXPECT_EQ(0, checkbuf(src_kbuf2, SRC_DATA, TEST_BUF2_SIZE)); |
| } |
| } |
| |
| static void usercopy_test_strlcpy_from_user_inner(user_addr_t addr, |
| uint arch_mmu_flags_start, |
| uint arch_mmu_flags_end, |
| int copy_size, |
| int null_off) { |
| int ret; |
| char dest_buf[TEST_BUF_SIZE]; |
| char* src_kbuf1; |
| char* src_kbuf2; |
| size_t dest_len; |
| int copy_len = copy_size ? copy_size - 1 : 0; |
| |
| memset(dest_buf, DEST_DATA, sizeof(dest_buf)); |
| src_kbuf1 = paddr_to_kvaddr(vaddr_to_paddr((void*)(uintptr_t)addr)); |
| src_kbuf2 = paddr_to_kvaddr( |
| vaddr_to_paddr((void*)(uintptr_t)addr + TEST_BUF1_SIZE)); |
| |
| /* src buffs should be NULL iff their flags are FLAGS_NO_PAGE */ |
| EXPECT_EQ((src_kbuf1 == NULL), (arch_mmu_flags_start == FLAGS_NO_PAGE)); |
| EXPECT_EQ((src_kbuf2 == NULL), (arch_mmu_flags_end == FLAGS_NO_PAGE)); |
| |
| usercopy_test_init_buf(src_kbuf1, src_kbuf2, SRC_DATA, null_off); |
| |
| ret = strlcpy_from_user(dest_buf + TEST_BUF_COPY_START, |
| addr + TEST_BUF_COPY_START, copy_size); |
| |
| dest_len = strnlen(dest_buf + TEST_BUF_COPY_START, TEST_BUF_COPY_SIZE); |
| if (copy_size) { |
| /* |
| * Kernel buffer should always be null terminated. |
| */ |
| EXPECT_NE(TEST_BUF_COPY_SIZE, dest_len, " null_off=%d, copy_size=%d\n", |
| null_off, copy_size); |
| } else { |
| /* |
| * If copy_size is 0, then kernel buffer will not be null terminated. |
| */ |
| EXPECT_EQ(TEST_BUF_COPY_SIZE, dest_len, " null_off=%d, copy_size=%d\n", |
| null_off, copy_size); |
| dest_len = 0; |
| } |
| |
| /* |
| * If the string in dest_buf is not empty it should only contain data from |
| * the source string. |
| */ |
| EXPECT_EQ(0, checkbuf(dest_buf + TEST_BUF_COPY_START, SRC_DATA, dest_len), |
| " null_off=%d, copy_size=%d\n", null_off, copy_size); |
| |
| if ((arch_mmu_flags_start & ARCH_MMU_FLAG_PERM_USER) && |
| ((arch_mmu_flags_end & ARCH_MMU_FLAG_PERM_USER) || |
| null_off < TEST_BUF1_SIZE)) { |
| /* |
| * If the pages readable from user-space contain a 0 terminated string, |
| * strlcpy_from_user should return the length of that string and every |
| * byte up to the 0 terminator that fits in dest_buf should be copied |
| * there. dest_buf should always be 0 terminated. |
| */ |
| EXPECT_EQ(null_off - TEST_BUF_COPY_START, ret, |
| " wrong strlen returned, null_off=%d, copy_size=%d\n", |
| null_off, copy_size); |
| EXPECT_EQ(MIN(null_off - TEST_BUF_COPY_START, copy_len), dest_len, |
| " null_off=%d, copy_size=%d\n", null_off, copy_size); |
| } else { |
| /* |
| * If one of the pages is not readable from user-space strlcpy_from_user |
| * should return ERR_FAULT, and dest_buf should have a null terminator |
| * at the start of the faulting page or at the start of the string. |
| */ |
| EXPECT_EQ(ERR_FAULT, ret, " null_off=%d, copy_size=%d\n", null_off, |
| copy_size); |
| if (!(arch_mmu_flags_start & ARCH_MMU_FLAG_PERM_USER)) { |
| EXPECT_EQ(0, dest_len, " null_off=%d, copy_size=%d\n", null_off, |
| copy_size); |
| } else if (dest_len) { |
| EXPECT_EQ(MIN(TEST_BUF1_COPY_SIZE, copy_len), dest_len, |
| " null_off=%d, copy_size=%d\n", null_off, copy_size); |
| } |
| } |
| |
| /* Src buffer should not be modified */ |
| if (src_kbuf1) { |
| if (null_off < TEST_BUF1_SIZE) { |
| EXPECT_EQ(0, checkbuf(src_kbuf1, SRC_DATA, null_off)); |
| EXPECT_EQ('\0', src_kbuf1[null_off]); |
| EXPECT_EQ(0, checkbuf(src_kbuf1 + null_off + 1, SRC_DATA, |
| TEST_BUF1_SIZE - null_off - 1)); |
| } else { |
| EXPECT_EQ(0, checkbuf(src_kbuf1, SRC_DATA, TEST_BUF1_SIZE)); |
| } |
| } |
| if (src_kbuf2) { |
| if (null_off >= TEST_BUF1_SIZE) { |
| size_t null_off2 = null_off - TEST_BUF1_SIZE; |
| EXPECT_EQ(0, checkbuf(src_kbuf2, SRC_DATA, null_off2)); |
| EXPECT_EQ('\0', src_kbuf2[null_off2]); |
| EXPECT_EQ(0, checkbuf(src_kbuf2 + null_off2 + 1, SRC_DATA, |
| TEST_BUF2_SIZE - null_off2 - 1)); |
| } else { |
| EXPECT_EQ(0, checkbuf(src_kbuf2, SRC_DATA, TEST_BUF2_SIZE)); |
| } |
| } |
| |
| /* Dest bytes before and after copied region should be untouched */ |
| EXPECT_EQ(DEST_DATA, dest_buf[0]); |
| EXPECT_EQ(DEST_DATA, dest_buf[TEST_BUF_COPY_START + copy_size]); |
| EXPECT_EQ(DEST_DATA, dest_buf[TEST_BUF_SIZE - 1]); |
| } |
| |
| TEST_P(usercopytest, strlcpy_from_user) { |
| user_addr_t addr = get_addr_param(); |
| uint32_t arch_mmu_flags_start = get_start_flags_param(); |
| uint32_t arch_mmu_flags_end = get_end_flags_param(); |
| size_t copy_sizes[] = {0, TEST_BUF1_COPY_SIZE, TEST_BUF_COPY_SIZE}; |
| size_t copy_sizes_index; |
| int null_off; |
| int copy_size; |
| |
| for (copy_sizes_index = 0; copy_sizes_index < countof(copy_sizes); |
| copy_sizes_index++) { |
| copy_size = copy_sizes[copy_sizes_index]; |
| for (null_off = TEST_BUF_COPY_START; null_off < TEST_BUF_SIZE; |
| null_off++) { |
| usercopy_test_strlcpy_from_user_inner(addr, arch_mmu_flags_start, |
| arch_mmu_flags_end, copy_size, |
| null_off); |
| } |
| } |
| } |
| |
| static const char* flags_to_str(uint32_t flags) { |
| switch (flags) { |
| case FLAGS_NO_PAGE: |
| return "--"; |
| case FLAGS_NO_USER: |
| return "ko"; |
| case FLAGS_RO_USER: |
| return "ro"; |
| case FLAGS_RW_USER: |
| return "rw"; |
| default: |
| return "??"; |
| } |
| } |
| |
| static void user_param_to_string(const void* param, |
| char* buf, |
| size_t buf_size) { |
| uint32_t start_flags = get_start_flags_param(); |
| uint32_t end_flags = get_end_flags_param(); |
| size_t count = 0; |
| |
| count = scnprintf(buf + count, buf_size - count, "%s", |
| flags_to_str(start_flags)); |
| scnprintf(buf + count, buf_size - count, "%s", flags_to_str(end_flags)); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(UserCopyTestParams, |
| usercopytest, |
| testing_Combine(testing_Values(TEST_BUF_ADDR), |
| testing_Values(FLAGS_NO_PAGE, |
| FLAGS_NO_USER, |
| FLAGS_RO_USER, |
| FLAGS_RW_USER), |
| testing_Values(FLAGS_NO_PAGE, |
| FLAGS_NO_USER, |
| FLAGS_RO_USER, |
| FLAGS_RW_USER)), |
| user_param_to_string); |
| |
| #if IS_64BIT && USER_32BIT |
| /* |
| * Tests with Kernel addresses are not applicable to arm64u32 since kernel |
| * addresses do not fit in a user_addr_t. |
| */ |
| static_assert(KERNEL_BASE > UINT32_MAX); |
| |
| PORT_TEST(usercopy_tests, PORT_NAME) |
| |
| #else |
| /* These are filled in before the tests are run */ |
| static user_addr_t kernel_addrs[3]; |
| |
| static void kernel_param_to_string(const void* param, |
| char* buf, |
| size_t buf_size) { |
| const void* const* kernel_param = param; |
| size_t idx = ((user_addr_t*)kernel_param[0] - kernel_addrs); |
| const char* str; |
| |
| switch (idx) { |
| case STACK_ADDR_IDX: |
| str = "kernel-stack"; |
| break; |
| case HEAP_ADDR_IDX: |
| str = "kernel-heap"; |
| break; |
| case GLOBAL_ADDR_IDX: |
| str = "kernel-global"; |
| break; |
| default: |
| str = "unknown-address-type"; |
| } |
| |
| scnprintf(buf, buf_size, "%s", str); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(KernelUserCopyTestParams, |
| usercopytest, |
| testing_Combine(testing_ValuesIn(kernel_addrs), |
| testing_Values(FLAGS_NO_USER), |
| testing_Values(FLAGS_NO_USER)), |
| kernel_param_to_string); |
| |
| static bool run_usercopy_test(struct unittest* test) { |
| bool tests_passed; |
| static uint8_t global_buf[TEST_BUF_SIZE]; |
| uint8_t stack_buf[TEST_BUF_SIZE]; |
| uint8_t* heap_buf = malloc(TEST_BUF_SIZE); |
| |
| ASSERT(heap_buf); |
| |
| kernel_addrs[STACK_ADDR_IDX] = (user_addr_t)stack_buf; |
| kernel_addrs[HEAP_ADDR_IDX] = (user_addr_t)heap_buf; |
| kernel_addrs[GLOBAL_ADDR_IDX] = (user_addr_t)global_buf; |
| |
| tests_passed = RUN_ALL_TESTS(); |
| |
| free(heap_buf); |
| |
| return tests_passed; |
| } |
| |
| static void usercopy_test_init(uint level) { |
| static struct unittest usercopy_unittest = { |
| .port_name = PORT_NAME, |
| .run_test = run_usercopy_test, |
| }; |
| |
| unittest_add(&usercopy_unittest); |
| } |
| |
| LK_INIT_HOOK(usercopy_test, usercopy_test_init, LK_INIT_LEVEL_APPS); |
| #endif // !(IS_64BIT && USER_32BIT) |
