michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests: x86_mmu_api: remove

Browse source 
This test covers private interfaces that don't exist any more.

This will be replaced by tests of arch_mem_map() that are not
x86-specific.

Signed-off-by: Andrew Boie <andrew.p.boie@intel.com>
This commit is contained in:
Andrew Boie 2020-07-07 13:38:47 -07:00 • committed by Anas Nashif
commit fd07e2557d
5 changed files with 0 additions and 687 deletions
Download patch file Download diff file Expand all files Collapse all files

9
tests/arch/x86/x86_mmu_api/CMakeLists.txt
View file

@ -1,9 +0,0 @@
# SPDX-License-Identifier: Apache-2.0
cmake_minimum_required(VERSION 3.13.1)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(x86_mmu_api)
file(GLOB source_for_app src/*.c)
target_sources(app PRIVATE ${source_for_app})

2
tests/arch/x86/x86_mmu_api/prj.conf
View file

@ -1,2 +0,0 @@
CONFIG_ZTEST=y
CONFIG_X86_MMU=y

45
tests/arch/x86/x86_mmu_api/src/main.c
View file

@ -1,45 +0,0 @@
/*
* Copyright (c) 2017 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <ztest.h>
extern void test_buffer_rw_read(void);
extern void test_buffer_writeable_write(void);
extern void test_buffer_readable_read(void);
extern void test_buffer_readable_write(void);
extern void test_buffer_supervisor_rw(void);
extern void test_buffer_supervisor_w(void);
extern void test_buffer_user_rw_user(void);
extern void test_buffer_user_rw_supervisor(void);
extern void test_multi_page_buffer_user(void);
extern void test_multi_page_buffer_write_user(void);
extern void test_multi_page_buffer_read_user(void);
extern void test_multi_page_buffer_read(void);
extern void test_multi_pde_buffer_rw(void);
extern void test_multi_pde_buffer_writeable_write(void);
extern void test_multi_pde_buffer_readable_read(void);
extern void test_multi_pde_buffer_readable_write(void);
/*test case nain entry*/
void test_main(void)
{
ztest_test_suite(userbuffer_validate,
ztest_unit_test(test_buffer_rw_read),
ztest_unit_test(test_buffer_writeable_write),
ztest_unit_test(test_buffer_readable_read),
ztest_unit_test(test_buffer_readable_write),
ztest_unit_test(test_buffer_supervisor_rw),
ztest_unit_test(test_buffer_supervisor_w),
ztest_unit_test(test_buffer_user_rw_user),
ztest_unit_test(test_buffer_user_rw_supervisor),
ztest_unit_test(test_multi_page_buffer_user),
ztest_unit_test(test_multi_page_buffer_write_user),
ztest_unit_test(test_multi_page_buffer_read_user),
ztest_unit_test(test_multi_page_buffer_read),
ztest_unit_test(test_multi_pde_buffer_rw),
ztest_unit_test(test_multi_pde_buffer_writeable_write),
ztest_unit_test(test_multi_pde_buffer_readable_read),
ztest_unit_test(test_multi_pde_buffer_readable_write));
ztest_run_test_suite(userbuffer_validate);
}

627
tests/arch/x86/x86_mmu_api/src/userbuffer_validate.c
View file

@ -1,627 +0,0 @@
/*
* Copyright (c) 2017 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr.h>
#include <sys/printk.h>
#include <arch/x86/mmustructs.h>
#include <linker/linker-defs.h>
#include <ztest.h>
#define SKIP_SIZE 5
#define BUFF_SIZE 10
static int status;
#define BUFF_READABLE ((uint32_t) 0x0)
#define BUFF_WRITEABLE ((uint32_t) 0x1)
#define BUFF_USER ((uint32_t) 0x2)
void reset_flag(void);
void reset_multi_pte_page_flag(void);
void reset_multi_pde_flag(void);
#define PTABLES (&z_x86_kernel_ptables)
#define ADDR_PAGE_1 ((uint8_t *)__bss_start + SKIP_SIZE * MMU_PAGE_SIZE)
#define ADDR_PAGE_2 ((uint8_t *)__bss_start + (SKIP_SIZE + 1) * MMU_PAGE_SIZE)
#define PRESET_PAGE_1_VALUE set_flags(ADDR_PAGE_1, MMU_PAGE_SIZE, \
MMU_ENTRY_PRESENT, Z_X86_MMU_P)
#define PRESET_PAGE_2_VALUE set_flags(ADDR_PAGE_2, MMU_PAGE_SIZE, \
MMU_ENTRY_PRESENT, Z_X86_MMU_P)
static void set_flags(void *ptr, size_t size, uint64_t flags,
uint64_t mask)
{
z_x86_mmu_set_flags(PTABLES, ptr, size, flags, mask, true);
}
static int buffer_validate(void *addr, size_t size, int write)
{
return z_x86_mmu_validate(PTABLES, addr, size, write);
}
/* if Failure occurs
* buffer_validate return -EPERM
* else return 0.
* Below conditions will be tested accordingly
*
*/
/* read write testing */
static int buffer_rw_read(void)
{
PRESET_PAGE_1_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_READ,
Z_X86_MMU_RW);
status = buffer_validate(ADDR_PAGE_1, BUFF_SIZE, BUFF_WRITEABLE);
if (status != -EPERM) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_flag();
return TC_PASS;
}
static int buffer_writeable_write(void)
{
PRESET_PAGE_1_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE,
Z_X86_MMU_RW);
status = buffer_validate(ADDR_PAGE_1, BUFF_SIZE, BUFF_WRITEABLE);
if (status != 0) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_flag();
return TC_PASS;
}
static int buffer_readable_read(void)
{
PRESET_PAGE_1_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_READ,
Z_X86_MMU_RW);
status = buffer_validate(ADDR_PAGE_1, BUFF_SIZE, BUFF_READABLE);
if (status != 0) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_flag();
return TC_PASS;
}
static int buffer_readable_write(void)
{
PRESET_PAGE_1_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE,
Z_X86_MMU_RW);
status = buffer_validate(ADDR_PAGE_1, BUFF_SIZE, BUFF_READABLE);
if (status != 0) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_flag();
return TC_PASS;
}
/* supervisor test */
static int buffer_supervisor_rw(void)
{
PRESET_PAGE_1_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
status = buffer_validate(ADDR_PAGE_1, BUFF_SIZE, BUFF_READABLE |
BUFF_USER);
if (status != -EPERM) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_flag();
return TC_PASS;
}
static int buffer_supervisor_w(void)
{
PRESET_PAGE_1_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
status = buffer_validate(ADDR_PAGE_1, BUFF_SIZE, BUFF_WRITEABLE);
if (status != -EPERM) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_flag();
return TC_PASS;
}
static int buffer_user_rw_user(void)
{
PRESET_PAGE_1_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_USER,
Z_X86_MMU_RW | Z_X86_MMU_US);
status = buffer_validate(ADDR_PAGE_1, BUFF_SIZE, BUFF_WRITEABLE |
BUFF_USER);
if (status != 0) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_flag();
return TC_PASS;
}
static int buffer_user_rw_supervisor(void)
{
PRESET_PAGE_1_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
status = buffer_validate(ADDR_PAGE_1, BUFF_SIZE, BUFF_WRITEABLE |
BUFF_USER);
if (status != -EPERM) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_flag();
return TC_PASS;
}
/* Check buffer with multiple pages*/
static int multi_page_buffer_user(void)
{
PRESET_PAGE_1_VALUE;
PRESET_PAGE_2_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
status = buffer_validate(ADDR_PAGE_1,
2 * MMU_PAGE_SIZE,
BUFF_WRITEABLE | BUFF_USER);
if (status != -EPERM) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_multi_pte_page_flag();
return TC_PASS;
}
static int multi_page_buffer_write_user(void)
{
PRESET_PAGE_1_VALUE;
PRESET_PAGE_2_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
status = buffer_validate(ADDR_PAGE_1, 2 * MMU_PAGE_SIZE,
BUFF_WRITEABLE);
if (status != -EPERM) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_multi_pte_page_flag();
return TC_PASS;
}
static int multi_page_buffer_read_user(void)
{
PRESET_PAGE_1_VALUE;
PRESET_PAGE_2_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_READ | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_READ | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
status = buffer_validate(ADDR_PAGE_1, 2 * MMU_PAGE_SIZE, BUFF_READABLE
| BUFF_USER);
if (status != -EPERM) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_multi_pte_page_flag();
return TC_PASS;
}
static int multi_page_buffer_read(void)
{
PRESET_PAGE_1_VALUE;
PRESET_PAGE_2_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_READ | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_READ | MMU_ENTRY_SUPERVISOR,
Z_X86_MMU_RW | Z_X86_MMU_US);
status = buffer_validate(ADDR_PAGE_1, 2 * MMU_PAGE_SIZE,
BUFF_WRITEABLE);
if (status != -EPERM) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_multi_pte_page_flag();
return TC_PASS;
}
static int multi_pde_buffer_rw(void)
{
PRESET_PAGE_1_VALUE;
PRESET_PAGE_2_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_READ,
Z_X86_MMU_RW);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_READ,
Z_X86_MMU_RW);
status = buffer_validate(ADDR_PAGE_1, 2 * MMU_PAGE_SIZE,
BUFF_WRITEABLE);
if (status != -EPERM) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_multi_pde_flag();
return TC_PASS;
}
static int multi_pde_buffer_writeable_write(void)
{
PRESET_PAGE_1_VALUE;
PRESET_PAGE_2_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE,
Z_X86_MMU_RW);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE,
Z_X86_MMU_RW);
status = buffer_validate(ADDR_PAGE_1, 2 * MMU_PAGE_SIZE,
BUFF_WRITEABLE);
if (status != 0) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_multi_pde_flag();
return TC_PASS;
}
static int multi_pde_buffer_readable_read(void)
{
PRESET_PAGE_1_VALUE;
PRESET_PAGE_2_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_READ,
Z_X86_MMU_RW);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_READ,
Z_X86_MMU_RW);
status = buffer_validate(ADDR_PAGE_1, 2 * MMU_PAGE_SIZE,
BUFF_READABLE);
if (status != 0) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_multi_pde_flag();
return TC_PASS;
}
static int multi_pde_buffer_readable_write(void)
{
PRESET_PAGE_1_VALUE;
PRESET_PAGE_2_VALUE;
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE,
Z_X86_MMU_RW);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE,
Z_X86_MMU_RW);
status = buffer_validate(ADDR_PAGE_1, 2 * MMU_PAGE_SIZE,
BUFF_READABLE);
if (status != 0) {
TC_PRINT("%s failed\n", __func__);
return TC_FAIL;
}
reset_multi_pde_flag();
return TC_PASS;
}
void reset_flag(void)
{
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_USER,
Z_X86_MMU_RW | Z_X86_MMU_US);
}
void reset_multi_pte_page_flag(void)
{
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_USER,
Z_X86_MMU_RW | Z_X86_MMU_US);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_USER,
Z_X86_MMU_RW | Z_X86_MMU_US);
}
void reset_multi_pde_flag(void)
{
set_flags(ADDR_PAGE_1,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_USER,
Z_X86_MMU_RW | Z_X86_MMU_US);
set_flags(ADDR_PAGE_2,
MMU_PAGE_SIZE,
MMU_ENTRY_WRITE | MMU_ENTRY_USER,
Z_X86_MMU_RW | Z_X86_MMU_US);
}
/**
* @brief Verify read from multiple pages of buffer with write access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_multi_pde_buffer_readable_write(void)
{
zassert_true(multi_pde_buffer_readable_write() == TC_PASS, NULL);
}
/**
* @brief Verify read to multiple pages of buffer with read access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_multi_pde_buffer_readable_read(void)
{
zassert_true(multi_pde_buffer_readable_read() == TC_PASS, NULL);
}
/**
* @brief Verify write to 2 pages of buffer with write access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_multi_pde_buffer_writeable_write(void)
{
zassert_true(multi_pde_buffer_writeable_write() == TC_PASS, NULL);
}
/**
* @brief Read from multiple pages from buffer with write access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_multi_pde_buffer_rw(void)
{
zassert_true(multi_pde_buffer_rw() == TC_PASS, NULL);
}
/**
* @brief Test to write to buffer which has read access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_buffer_rw_read(void)
{
zassert_true(buffer_rw_read() == TC_PASS, NULL);
}
/**
* @brief Test to write to buffer which has write access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_buffer_writeable_write(void)
{
zassert_true(buffer_writeable_write() == TC_PASS, NULL);
}
/**
* @brief Test to read from buffer with read access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_buffer_readable_read(void)
{
zassert_true(buffer_readable_read() == TC_PASS, NULL);
}
/**
* @brief Test to read from a buffer with write access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_buffer_readable_write(void)
{
zassert_true(buffer_readable_write() == TC_PASS, NULL);
}
/**
* @brief Verify read as user from buffer which has write access to supervisor
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_buffer_supervisor_rw(void)
{
zassert_true(buffer_supervisor_rw() == TC_PASS, NULL);
}
/**
* @brief Verify write to buffer which has write access to supervisor
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_buffer_supervisor_w(void)
{
zassert_true(buffer_supervisor_w() == TC_PASS, NULL);
}
/**
* @brief Verify write as user to buffer with write permission
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_buffer_user_rw_user(void)
{
zassert_true(buffer_user_rw_user() == TC_PASS, NULL);
}
/**
* @brief Verify write as user to buffer which has write from supervisor
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_buffer_user_rw_supervisor(void)
{
zassert_true(buffer_user_rw_supervisor() == TC_PASS, NULL);
}
/**
* @brief Verify write/user to buffer with 2 pages having write/supervisor
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_multi_page_buffer_user(void)
{
zassert_true(multi_page_buffer_user() == TC_PASS, NULL);
}
/**
* @brief Verify write to buffer with 2 pages having write/supervisor
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_multi_page_buffer_write_user(void)
{
zassert_true(multi_page_buffer_write_user() == TC_PASS, NULL);
}
/**
* @brief Verify read as user to buffer with read/supervisor access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_multi_page_buffer_read_user(void)
{
zassert_true(multi_page_buffer_read_user() == TC_PASS, NULL);
}
/**
* @brief Verify write to buffer with read/supervisor access
*
* @ingroup kernel_memprotect_tests
*
* @see z_x86_mmu_validate(), z_x86_mmu_set_flags()
*/
void test_multi_page_buffer_read(void)
{
zassert_true(multi_page_buffer_read() == TC_PASS, NULL);
}

4
tests/arch/x86/x86_mmu_api/testcase.yaml
View file

@ -1,4 +0,0 @@
tests:
kernel.memory_protection.mmu:
platform_whitelist: qemu_x86
tags: kernel