michaelh/zephyr
1
0
Fork 0
Code Releases Activity

mmu: rename z_mem_map to z_phys_map

Browse source 
Renamed to make its semantics clearer; this function maps
*physical* memory addresses and is not equivalent to
posix mmap(), which might confuse people.

mem_map test case remains the same name as other memory
mapping scenarios will be added in the fullness of time.

Parameter names to z_phys_map adjusted slightly to be more
consistent with names used in other memory mapping functions.

Signed-off-by: Andrew Boie <andrew.p.boie@intel.com>
This commit is contained in:
Andrew Boie 2020-12-15 15:47:18 -08:00 • committed by Anas Nashif
commit d2ad783a97
7 changed files with 36 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

2
arch/x86/core/acpi.c
View file

@ -35,7 +35,7 @@ static void find_rsdp(void)
} }
if (zero_page_base == NULL) { if (zero_page_base == NULL) {
z_mem_map(&zero_page_base, 0, 4096, K_MEM_PERM_RW); z_phys_map(&zero_page_base, 0, 4096, K_MEM_PERM_RW);
} }
/* Physical (real mode!) address 0000:040e stores a (real /* Physical (real mode!) address 0000:040e stores a (real

6
drivers/pcie/host/msi.c
View file

@ -67,9 +67,9 @@ static bool map_msix_table_entries(pcie_bdf_t bdf,
return false; return false;
} }
z_mem_map((uint8_t **)&mapped_table, z_phys_map((uint8_t **)&mapped_table,
bar.phys_addr + table_offset, bar.phys_addr + table_offset,
bar.size, K_MEM_PERM_RW); bar.size, K_MEM_PERM_RW);
for (i = 0; i < n_vector; i++) { for (i = 0; i < n_vector; i++) {
vectors[i].msix_vector = (struct msix_vector *) vectors[i].msix_vector = (struct msix_vector *)

4
include/sys/device_mmio.h
View file

@ -88,8 +88,8 @@ static inline void device_map(mm_reg_t *virt_addr, uintptr_t phys_addr,
/* Pass along flags and add that we want supervisor mode /* Pass along flags and add that we want supervisor mode
* read-write access. * read-write access.
*/ */
z_mem_map((uint8_t **)virt_addr, phys_addr, size, z_phys_map((uint8_t **)virt_addr, phys_addr, size,
flags | K_MEM_PERM_RW); flags | K_MEM_PERM_RW);
#else #else
ARG_UNUSED(size); ARG_UNUSED(size);
ARG_UNUSED(flags); ARG_UNUSED(flags);

8
include/sys/mem_manage.h
View file

@ -79,13 +79,13 @@ extern "C" {
* This API is part of infrastructure still under development and may * This API is part of infrastructure still under development and may
* change. * change.
* *
* @param linear_addr [out] Output linear address storage location * @param virt [out] Output virtual address storage location
* @param phys_addr Physical address base of the memory region * @param phys Physical address base of the memory region
* @param size Size of the memory region * @param size Size of the memory region
* @param flags Caching mode and access flags, see K_MAP_* macros * @param flags Caching mode and access flags, see K_MAP_* macros
*/ */
void z_mem_map(uint8_t **linear_addr, uintptr_t phys_addr, size_t size, void z_phys_map(uint8_t **virt_ptr, uintptr_t phys, size_t size,
uint32_t flags); uint32_t flags);
/** /**
* Given an arbitrary region, provide a aligned region that covers it * Given an arbitrary region, provide a aligned region that covers it

2
kernel/include/kernel_arch_interface.h
View file

@ -244,8 +244,6 @@ static inline bool arch_is_in_isr(void);
* This API is part of infrastructure still under development and may * This API is part of infrastructure still under development and may
* change. * change.
* *
* @see z_mem_map()
*
* @param dest Page-aligned Destination virtual address to map * @param dest Page-aligned Destination virtual address to map
* @param addr Page-aligned Source physical address to map * @param addr Page-aligned Source physical address to map
* @param size Page-aligned size of the mapped memory region in bytes * @param size Page-aligned size of the mapped memory region in bytes

11
kernel/mmu.c
View file

@ -48,7 +48,7 @@ static struct k_spinlock mm_lock;
/* Current position for memory mappings in kernel memory. /* Current position for memory mappings in kernel memory.
* At the moment, all kernel memory mappings are permanent. * At the moment, all kernel memory mappings are permanent.
* z_mem_map() mappings start at the end of the address space, and grow * Memory mappings start at the end of the address space, and grow
* downward. * downward.
* *
* All of this is under heavy development and is subject to change. * All of this is under heavy development and is subject to change.
@ -79,8 +79,7 @@ size_t k_mem_region_align(uintptr_t *aligned_addr, size_t *aligned_size,
return addr_offset; return addr_offset;
} }
void z_mem_map(uint8_t **virt_addr, uintptr_t phys_addr, size_t size, void z_phys_map(uint8_t **virt_ptr, uintptr_t phys, size_t size, uint32_t flags)
uint32_t flags)
{ {
uintptr_t aligned_addr, addr_offset; uintptr_t aligned_addr, addr_offset;
size_t aligned_size; size_t aligned_size;
@ -89,7 +88,7 @@ void z_mem_map(uint8_t **virt_addr, uintptr_t phys_addr, size_t size,
uint8_t *dest_virt; uint8_t *dest_virt;
addr_offset = k_mem_region_align(&aligned_addr, &aligned_size, addr_offset = k_mem_region_align(&aligned_addr, &aligned_size,
phys_addr, size, phys, size,
CONFIG_MMU_PAGE_SIZE); CONFIG_MMU_PAGE_SIZE);
key = k_spin_lock(&mm_lock); key = k_spin_lock(&mm_lock);
@ -120,7 +119,7 @@ void z_mem_map(uint8_t **virt_addr, uintptr_t phys_addr, size_t size,
k_spin_unlock(&mm_lock, key); k_spin_unlock(&mm_lock, key);
if (ret == 0) { if (ret == 0) {
*virt_addr = dest_virt + addr_offset; *virt_ptr = dest_virt + addr_offset;
} else { } else {
/* This happens if there is an insurmountable problem /* This happens if there is an insurmountable problem
* with the selected cache modes or access flags * with the selected cache modes or access flags
@ -133,6 +132,6 @@ void z_mem_map(uint8_t **virt_addr, uintptr_t phys_addr, size_t size,
return; return;
fail: fail:
LOG_ERR("memory mapping 0x%lx (size %zu, flags 0x%x) failed", LOG_ERR("memory mapping 0x%lx (size %zu, flags 0x%x) failed",
phys_addr, size, flags); phys, size, flags);
k_panic(); k_panic();
} }

42
tests/kernel/mem_protect/mem_map/src/main.c
View file

@ -32,7 +32,7 @@ void k_sys_fatal_error_handler(unsigned int reason, const z_arch_esf_t *pEsf)
} }
/* z_mem_map() doesn't have alignment requirements, any oddly-sized buffer /* z_phys_map() doesn't have alignment requirements, any oddly-sized buffer
* can get mapped. This will span two pages. * can get mapped. This will span two pages.
*/ */
#define BUF_SIZE 5003 #define BUF_SIZE 5003
@ -43,7 +43,7 @@ void k_sys_fatal_error_handler(unsigned int reason, const z_arch_esf_t *pEsf)
* *
* @ingroup kernel_memprotect_tests * @ingroup kernel_memprotect_tests
*/ */
void test_z_mem_map_rw(void) void test_z_phys_map_rw(void)
{ {
uint8_t *mapped_rw, *mapped_ro; uint8_t *mapped_rw, *mapped_ro;
uint8_t *buf = test_page + BUF_OFFSET; uint8_t *buf = test_page + BUF_OFFSET;
@ -51,8 +51,8 @@ void test_z_mem_map_rw(void)
expect_fault = false; expect_fault = false;
/* Map in a page that allows writes */ /* Map in a page that allows writes */
z_mem_map(&mapped_rw, (uintptr_t)buf, z_phys_map(&mapped_rw, (uintptr_t)buf,
BUF_SIZE, BASE_FLAGS | K_MEM_PERM_RW); BUF_SIZE, BASE_FLAGS | K_MEM_PERM_RW);
/* Initialize buf with some bytes */ /* Initialize buf with some bytes */
for (int i = 0; i < BUF_SIZE; i++) { for (int i = 0; i < BUF_SIZE; i++) {
@ -60,8 +60,8 @@ void test_z_mem_map_rw(void)
} }
/* Map again this time only allowing reads */ /* Map again this time only allowing reads */
z_mem_map(&mapped_ro, (uintptr_t)buf, z_phys_map(&mapped_ro, (uintptr_t)buf,
BUF_SIZE, BASE_FLAGS); BUF_SIZE, BASE_FLAGS);
/* Check that the mapped area contains the expected data. */ /* Check that the mapped area contains the expected data. */
for (int i = 0; i < BUF_SIZE; i++) { for (int i = 0; i < BUF_SIZE; i++) {
@ -88,7 +88,7 @@ static void transplanted_function(bool *executed)
* *
* @ingroup kernel_memprotect_tests * @ingroup kernel_memprotect_tests
*/ */
void test_z_mem_map_exec(void) void test_z_phys_map_exec(void)
{ {
uint8_t *mapped_rw, *mapped_exec, *mapped_ro; uint8_t *mapped_rw, *mapped_exec, *mapped_ro;
bool executed = false; bool executed = false;
@ -97,22 +97,22 @@ void test_z_mem_map_exec(void)
expect_fault = false; expect_fault = false;
/* Map with write permissions and copy the function into the page */ /* Map with write permissions and copy the function into the page */
z_mem_map(&mapped_rw, (uintptr_t)test_page, z_phys_map(&mapped_rw, (uintptr_t)test_page,
sizeof(test_page), BASE_FLAGS | K_MEM_PERM_RW); sizeof(test_page), BASE_FLAGS | K_MEM_PERM_RW);
memcpy(mapped_rw, (void *)&transplanted_function, CONFIG_MMU_PAGE_SIZE); memcpy(mapped_rw, (void *)&transplanted_function, CONFIG_MMU_PAGE_SIZE);
/* Now map with execution enabled and try to run the copied fn */ /* Now map with execution enabled and try to run the copied fn */
z_mem_map(&mapped_exec, (uintptr_t)test_page, z_phys_map(&mapped_exec, (uintptr_t)test_page,
sizeof(test_page), BASE_FLAGS | K_MEM_PERM_EXEC); sizeof(test_page), BASE_FLAGS | K_MEM_PERM_EXEC);
func = (void (*)(bool *executed))mapped_exec; func = (void (*)(bool *executed))mapped_exec;
func(&executed); func(&executed);
zassert_true(executed, "function did not execute"); zassert_true(executed, "function did not execute");
/* Now map without execution and execution should now fail */ /* Now map without execution and execution should now fail */
z_mem_map(&mapped_ro, (uintptr_t)test_page, z_phys_map(&mapped_ro, (uintptr_t)test_page,
sizeof(test_page), BASE_FLAGS); sizeof(test_page), BASE_FLAGS);
func = (void (*)(bool *executed))mapped_ro; func = (void (*)(bool *executed))mapped_ro;
expect_fault = true; expect_fault = true;
@ -122,7 +122,7 @@ void test_z_mem_map_exec(void)
ztest_test_fail(); ztest_test_fail();
} }
#else #else
void test_z_mem_map_exec(void) void test_z_phys_map_exec(void)
{ {
ztest_test_skip(); ztest_test_skip();
} }
@ -133,18 +133,18 @@ void test_z_mem_map_exec(void)
* *
* @ingroup kernel_memprotect_tests * @ingroup kernel_memprotect_tests
*/ */
void test_z_mem_map_side_effect(void) void test_z_phys_map_side_effect(void)
{ {
uint8_t *mapped; uint8_t *mapped;
expect_fault = false; expect_fault = false;
/* z_mem_map() is supposed to always create fresh mappings. /* z_phys_map() is supposed to always create fresh mappings.
* Show that by mapping test_page to an RO region, we can still * Show that by mapping test_page to an RO region, we can still
* modify test_page. * modify test_page.
*/ */
z_mem_map(&mapped, (uintptr_t)test_page, z_phys_map(&mapped, (uintptr_t)test_page,
sizeof(test_page), BASE_FLAGS); sizeof(test_page), BASE_FLAGS);
/* Should NOT fault */ /* Should NOT fault */
test_page[0] = 42; test_page[0] = 42;
@ -160,9 +160,9 @@ void test_z_mem_map_side_effect(void)
void test_main(void) void test_main(void)
{ {
ztest_test_suite(test_mem_map, ztest_test_suite(test_mem_map,
ztest_unit_test(test_z_mem_map_rw), ztest_unit_test(test_z_phys_map_rw),
ztest_unit_test(test_z_mem_map_exec), ztest_unit_test(test_z_phys_map_exec),
ztest_unit_test(test_z_mem_map_side_effect) ztest_unit_test(test_z_phys_map_side_effect)
); );
ztest_run_test_suite(test_mem_map); ztest_run_test_suite(test_mem_map);
} }