From 3318c2388c3c5e643a963de47cf2c94b463dfaf1 Mon Sep 17 00:00:00 2001 From: Shell Date: Mon, 31 Jul 2023 19:50:58 +0800 Subject: [PATCH 1/4] [components/mm] use fault_try_fix in accessible() --- components/lwp/lwp_user_mm.c | 10 +++++++++- components/mm/mm_fault.c | 6 +++++- components/mm/mm_fault.h | 2 +- 3 files changed, 15 insertions(+), 3 deletions(-) diff --git a/components/lwp/lwp_user_mm.c b/components/lwp/lwp_user_mm.c index dfb87aca9ea..6c5a559f9cd 100644 --- a/components/lwp/lwp_user_mm.c +++ b/components/lwp/lwp_user_mm.c @@ -669,7 +669,15 @@ int lwp_user_accessable(void *addr, size_t size) if (tmp_addr == ARCH_MAP_FAILED) { if ((rt_ubase_t)addr_start >= USER_STACK_VSTART && (rt_ubase_t)addr_start < USER_STACK_VEND) - tmp_addr = *(void **)addr_start; + { + struct rt_aspace_fault_msg msg = { + .fault_op = MM_FAULT_OP_WRITE, + .fault_type = MM_FAULT_TYPE_PAGE_FAULT, + .fault_vaddr = addr_start, + }; + if (!rt_aspace_fault_try_fix(&msg)) + return 0; + } else return 0; } diff --git a/components/mm/mm_fault.c b/components/mm/mm_fault.c index 155be9df4de..40d97f88479 100644 --- a/components/mm/mm_fault.c +++ b/components/mm/mm_fault.c @@ -100,7 +100,10 @@ int rt_aspace_fault_try_fix(struct rt_aspace_fault_msg *msg) if (lwp) { rt_aspace_t aspace = lwp->aspace; - rt_varea_t varea = _aspace_bst_search(aspace, msg->fault_vaddr); + rt_varea_t varea; + + RD_LOCK(aspace); + varea = _aspace_bst_search(aspace, msg->fault_vaddr); if (varea) { void *pa = rt_hw_mmu_v2p(aspace, msg->fault_vaddr); @@ -120,6 +123,7 @@ int rt_aspace_fault_try_fix(struct rt_aspace_fault_msg *msg) break; } } + RD_UNLOCK(aspace); } return err; diff --git a/components/mm/mm_fault.h b/components/mm/mm_fault.h index fc34024431e..1bea2451ebe 100644 --- a/components/mm/mm_fault.h +++ b/components/mm/mm_fault.h @@ -52,7 +52,7 @@ struct rt_aspace_fault_msg struct rt_mm_fault_res response; }; -/* MMU base page fault handler, return 1 is */ +/* MMU base page fault handler, return 1 is fixable */ int rt_aspace_fault_try_fix(struct rt_aspace_fault_msg *msg); #endif /* __MM_FAULT_H__ */ From 134180b42425079d86d252c904547c9b32bb54b0 Mon Sep 17 00:00:00 2001 From: Shell Date: Wed, 16 Aug 2023 09:31:19 +0800 Subject: [PATCH 2/4] [components/mm] add unmap page API Signed-off-by: Shell --- components/lwp/lwp_user_mm.c | 10 +++++--- components/lwp/lwp_user_mm.h | 1 + components/mm/mm_aspace.c | 44 +++++++++++++++++++++++++++++--- components/mm/mm_aspace.h | 26 +++++++++++++++++++ components/mm/mm_fault.c | 6 ++--- components/mm/mm_fault.h | 3 ++- components/mm/mm_flag.h | 20 ++++++++++++--- libcpu/aarch64/common/mmu.c | 3 ++- libcpu/aarch64/common/trap.c | 8 ++++-- libcpu/arm/cortex-a/trap.c | 4 ++- libcpu/risc-v/t-head/c906/trap.c | 4 ++- libcpu/risc-v/virt64/trap.c | 4 ++- 12 files changed, 113 insertions(+), 20 deletions(-) diff --git a/components/lwp/lwp_user_mm.c b/components/lwp/lwp_user_mm.c index 6c5a559f9cd..3fa0dc9345a 100644 --- a/components/lwp/lwp_user_mm.c +++ b/components/lwp/lwp_user_mm.c @@ -622,11 +622,10 @@ size_t lwp_put_to_user(void *dst, void *src, size_t size) return lwp_data_put(lwp, dst, src, size); } -int lwp_user_accessable(void *addr, size_t size) +int lwp_user_accessible_ext(struct rt_lwp *lwp, void *addr, size_t size) { void *addr_start = RT_NULL, *addr_end = RT_NULL, *next_page = RT_NULL; void *tmp_addr = RT_NULL; - struct rt_lwp *lwp = lwp_self(); if (!lwp) { @@ -675,7 +674,7 @@ int lwp_user_accessable(void *addr, size_t size) .fault_type = MM_FAULT_TYPE_PAGE_FAULT, .fault_vaddr = addr_start, }; - if (!rt_aspace_fault_try_fix(&msg)) + if (!rt_aspace_fault_try_fix(lwp->aspace, &msg)) return 0; } else @@ -688,6 +687,11 @@ int lwp_user_accessable(void *addr, size_t size) return 1; } +int lwp_user_accessable(void *addr, size_t size) +{ + return lwp_user_accessible_ext(lwp_self(), addr, size); +} + /* src is in mmu_info space, dst is in current thread space */ size_t lwp_data_get(struct rt_lwp *lwp, void *dst, void *src, size_t size) { diff --git a/components/lwp/lwp_user_mm.h b/components/lwp/lwp_user_mm.h index d2c6681e29f..66f3ebc4b2e 100644 --- a/components/lwp/lwp_user_mm.h +++ b/components/lwp/lwp_user_mm.h @@ -48,6 +48,7 @@ int lwp_munmap(void *addr); size_t lwp_get_from_user(void *dst, void *src, size_t size); size_t lwp_put_to_user(void *dst, void *src, size_t size); int lwp_user_accessable(void *addr, size_t size); +int lwp_user_accessible_ext(struct rt_lwp *lwp, void *addr, size_t size); size_t lwp_data_get(struct rt_lwp *lwp, void *dst, void *src, size_t size); size_t lwp_data_put(struct rt_lwp *lwp, void *dst, void *src, size_t size); diff --git a/components/mm/mm_aspace.c b/components/mm/mm_aspace.c index d79ceacc168..6249e44ac38 100644 --- a/components/mm/mm_aspace.c +++ b/components/mm/mm_aspace.c @@ -400,11 +400,11 @@ static inline int _not_align(void *start, rt_size_t length, rt_size_t mask) (((uintptr_t)start & mask) || (length & mask)); } +/** if the flag is currently supported */ static inline int _not_support(rt_size_t flags) { - rt_size_t support_ops = (MMF_PREFETCH | MMF_MAP_FIXED | MMF_TEXT | - MMF_STATIC_ALLOC | MMF_REQUEST_ALIGN); - return flags & ~(support_ops | _MMF_ALIGN_MASK); + rt_size_t support_ops = MMF_CREATE(((__MMF_INVALID - 1) << 1) - 1, 1); + return flags & ~(support_ops); } int rt_aspace_map(rt_aspace_t aspace, void **addr, rt_size_t length, @@ -855,6 +855,15 @@ int rt_varea_map_page(rt_varea_t varea, void *vaddr, void *page) #define ALIGNED(addr) (!((rt_size_t)(addr) & ARCH_PAGE_MASK)) +int rt_varea_unmap_page(rt_varea_t varea, void *vaddr) +{ + void *va_aligned = (void *)RT_ALIGN_DOWN((rt_base_t)vaddr, ARCH_PAGE_SIZE); + return rt_varea_unmap_range(varea, va_aligned, ARCH_PAGE_SIZE); +} + +/** + * @note Caller should take care of synchronization of its varea among all the map/unmap operation + */ int rt_varea_map_range(rt_varea_t varea, void *vaddr, void *paddr, rt_size_t length) { int err; @@ -883,6 +892,35 @@ int rt_varea_map_range(rt_varea_t varea, void *vaddr, void *paddr, rt_size_t len return err; } +/** + * @note Caller should take care of synchronization of its varea among all the map/unmap operation + */ +int rt_varea_unmap_range(rt_varea_t varea, void *vaddr, rt_size_t length) +{ + int err; + rt_base_t va_align; + + if (!varea || !vaddr || !length) + { + LOG_W("%s(%p,%p,%lx): invalid input", __func__, varea, vaddr, length); + err = -RT_EINVAL; + } + else if (_not_in_range(vaddr, length, varea->start, varea->size)) + { + LOG_W("%s(%p,%lx): not in range of varea(%p,%lx)", __func__, + vaddr, length, varea->start, varea->size); + err = -RT_EINVAL; + } + else + { + va_align = RT_ALIGN_DOWN((rt_base_t)vaddr, ARCH_PAGE_SIZE); + rt_hw_mmu_unmap(varea->aspace, (void *)va_align, length); + rt_hw_tlb_invalidate_range(varea->aspace, (void *)va_align, length, ARCH_PAGE_SIZE); + err = RT_EOK; + } + return err; +} + int rt_aspace_offload_page(rt_aspace_t aspace, void *addr, rt_size_t npage) { return -RT_ENOSYS; diff --git a/components/mm/mm_aspace.h b/components/mm/mm_aspace.h index d7578abad9d..6c240403684 100644 --- a/components/mm/mm_aspace.h +++ b/components/mm/mm_aspace.h @@ -206,9 +206,22 @@ void rt_aspace_print_all(rt_aspace_t aspace); */ int rt_varea_map_page(rt_varea_t varea, void *vaddr, void *page); +/** + * @brief Unmap one page in varea + * + * @param varea target varea + * @param addr user address + * @param page the page frame to be mapped + * @return int + */ +int rt_varea_unmap_page(rt_varea_t varea, void *vaddr); + /** * @brief Map a range of physical address to varea * + * @warning Caller should take care of synchronization of its varea among all + * the map/unmap operation + * * @param varea target varea * @param vaddr user address * @param paddr physical address @@ -217,6 +230,19 @@ int rt_varea_map_page(rt_varea_t varea, void *vaddr, void *page); */ int rt_varea_map_range(rt_varea_t varea, void *vaddr, void *paddr, rt_size_t length); +/** + * @brief Unmap a range of physical address in varea + * + * @warning Caller should take care of synchronization of its varea among all + * the map/unmap operation + * + * @param varea target varea + * @param vaddr user address + * @param length map range + * @return int + */ +int rt_varea_unmap_range(rt_varea_t varea, void *vaddr, rt_size_t length); + /** * @brief Insert page to page manager of varea * The page will be freed by varea on uninstall automatically diff --git a/components/mm/mm_fault.c b/components/mm/mm_fault.c index 40d97f88479..a73c173acfc 100644 --- a/components/mm/mm_fault.c +++ b/components/mm/mm_fault.c @@ -89,17 +89,15 @@ static int _exec_fault(rt_varea_t varea, void *pa, struct rt_aspace_fault_msg *m return err; } -int rt_aspace_fault_try_fix(struct rt_aspace_fault_msg *msg) +int rt_aspace_fault_try_fix(rt_aspace_t aspace, struct rt_aspace_fault_msg *msg) { - struct rt_lwp *lwp = lwp_self(); int err = UNRECOVERABLE; uintptr_t va = (uintptr_t)msg->fault_vaddr; va &= ~ARCH_PAGE_MASK; msg->fault_vaddr = (void *)va; - if (lwp) + if (aspace) { - rt_aspace_t aspace = lwp->aspace; rt_varea_t varea; RD_LOCK(aspace); diff --git a/components/mm/mm_fault.h b/components/mm/mm_fault.h index 1bea2451ebe..eeb413025f0 100644 --- a/components/mm/mm_fault.h +++ b/components/mm/mm_fault.h @@ -52,7 +52,8 @@ struct rt_aspace_fault_msg struct rt_mm_fault_res response; }; +struct rt_aspace; /* MMU base page fault handler, return 1 is fixable */ -int rt_aspace_fault_try_fix(struct rt_aspace_fault_msg *msg); +int rt_aspace_fault_try_fix(struct rt_aspace *aspace, struct rt_aspace_fault_msg *msg); #endif /* __MM_FAULT_H__ */ diff --git a/components/mm/mm_flag.h b/components/mm/mm_flag.h index 390332867fb..4104a60b8fb 100644 --- a/components/mm/mm_flag.h +++ b/components/mm/mm_flag.h @@ -47,22 +47,36 @@ enum mm_flag_cntl */ MMF_PREFETCH = _DEF_FLAG(3), + /** + * @brief Allocate the mapping using "huge" pages + */ MMF_HUGEPAGE = _DEF_FLAG(4), + /** internal reserved flags */ MMF_TEXT = _DEF_FLAG(5), + /** internal reserved flags */ MMF_STATIC_ALLOC = _DEF_FLAG(6), + /** + * @brief Shared mapping. Updates to the mapping are visible to other + * processes mapping the same region, and are carried through to the + * underlying file. + */ + MMF_MAP_SHARED = _DEF_FLAG(7), + /** * @brief a non-locked memory can be swapped out when required, this is * reserved for future */ - MMF_NONLOCKED = _DEF_FLAG(20), + MMF_NONLOCKED = _DEF_FLAG(8), /** * @brief An alignment is specified in flags that the mapping must admit */ - MMF_REQUEST_ALIGN = _DEF_FLAG(21), + MMF_REQUEST_ALIGN = _DEF_FLAG(9), + + __MMF_INVALID, }; #define MMF_GET_ALIGN(src) ((src & _MMF_ALIGN_MASK)) @@ -78,7 +92,7 @@ enum mm_flag_cntl * @brief Create Flags * * example: MMF_CREATE(0, 0) - * MMF_CREATE(MM_MAP_FIXED, 0x2000) + * MMF_CREATE(MMF_MAP_FIXED, 0x2000) * * Direct use of flag is also acceptable: (MMF_MAP_FIXED | MMF_PREFETCH) */ diff --git a/libcpu/aarch64/common/mmu.c b/libcpu/aarch64/common/mmu.c index cd38d74ef3a..e8a0bfeefb8 100644 --- a/libcpu/aarch64/common/mmu.c +++ b/libcpu/aarch64/common/mmu.c @@ -327,7 +327,8 @@ void rt_hw_mmu_unmap(rt_aspace_t aspace, void *v_addr, size_t size) while (npages--) { MM_PGTBL_LOCK(aspace); - _kenrel_unmap_4K(aspace->page_table, v_addr); + if (rt_hw_mmu_v2p(aspace, v_addr) != ARCH_MAP_FAILED) + _kenrel_unmap_4K(aspace->page_table, v_addr); MM_PGTBL_UNLOCK(aspace); v_addr = (char *)v_addr + ARCH_PAGE_SIZE; } diff --git a/libcpu/aarch64/common/trap.c b/libcpu/aarch64/common/trap.c index 8e97a8b0aab..6faa740531a 100644 --- a/libcpu/aarch64/common/trap.c +++ b/libcpu/aarch64/common/trap.c @@ -14,7 +14,7 @@ #include #include "interrupt.h" -#include "mm_fault.h" +#include "mm_aspace.h" #include @@ -82,6 +82,8 @@ int check_user_stack(unsigned long esr, struct rt_hw_exp_stack *regs) ec = (unsigned char)((esr >> 26) & 0x3fU); enum rt_mm_fault_op fault_op; enum rt_mm_fault_type fault_type; + struct rt_lwp *lwp; + switch (ec) { case 0x20: @@ -107,7 +109,9 @@ int check_user_stack(unsigned long esr, struct rt_hw_exp_stack *regs) .fault_type = fault_type, .fault_vaddr = dfar, }; - if (rt_aspace_fault_try_fix(&msg)) + lwp = lwp_self(); + RT_ASSERT(lwp); + if (rt_aspace_fault_try_fix(lwp->aspace, &msg)) { ret = 1; } diff --git a/libcpu/arm/cortex-a/trap.c b/libcpu/arm/cortex-a/trap.c index 0aafa55968a..02a6e5c3164 100644 --- a/libcpu/arm/cortex-a/trap.c +++ b/libcpu/arm/cortex-a/trap.c @@ -46,6 +46,7 @@ void check_user_fault(struct rt_hw_exp_stack *regs, uint32_t pc_adj, char *info) int check_user_stack(struct rt_hw_exp_stack *regs) { void *dfar = RT_NULL; + struct rt_lwp *lwp; asm volatile("MRC p15, 0, %0, c6, c0, 0" : "=r"(dfar)); if ((dfar >= (void *)USER_STACK_VSTART) && (dfar < (void *)USER_STACK_VEND)) @@ -55,7 +56,8 @@ int check_user_stack(struct rt_hw_exp_stack *regs) .fault_type = MM_FAULT_TYPE_PAGE_FAULT, .fault_vaddr = dfar, }; - if (rt_aspace_fault_try_fix(&msg)) + lwp = lwp_self(); + if (lwp && rt_aspace_fault_try_fix(lwp->aspace, &msg)) { regs->pc -= 8; return 1; diff --git a/libcpu/risc-v/t-head/c906/trap.c b/libcpu/risc-v/t-head/c906/trap.c index 184765507b2..35d8255a97b 100644 --- a/libcpu/risc-v/t-head/c906/trap.c +++ b/libcpu/risc-v/t-head/c906/trap.c @@ -155,6 +155,7 @@ static const char *get_exception_msg(int id) void handle_user(rt_size_t scause, rt_size_t stval, rt_size_t sepc, struct rt_hw_stack_frame *sp) { rt_size_t id = __MASKVALUE(scause, __MASK(63UL)); + struct rt_lwp *lwp; /* user page fault */ enum rt_mm_fault_op fault_op; @@ -203,13 +204,14 @@ void handle_user(rt_size_t scause, rt_size_t stval, rt_size_t sepc, struct rt_hw if (fault_op) { + lwp = lwp_self(); struct rt_aspace_fault_msg msg = { .fault_op = fault_op, .fault_type = fault_type, .fault_vaddr = (void *)stval, }; - if (rt_aspace_fault_try_fix(&msg)) + if (lwp && rt_aspace_fault_try_fix(lwp->aspace, &msg)) { return; } diff --git a/libcpu/risc-v/virt64/trap.c b/libcpu/risc-v/virt64/trap.c index f8413c9d78d..3839c03110c 100644 --- a/libcpu/risc-v/virt64/trap.c +++ b/libcpu/risc-v/virt64/trap.c @@ -152,6 +152,7 @@ static const char *get_exception_msg(int id) void handle_user(rt_size_t scause, rt_size_t stval, rt_size_t sepc, struct rt_hw_stack_frame *sp) { rt_size_t id = __MASKVALUE(scause, __MASK(63UL)); + struct rt_lwp *lwp; /* user page fault */ enum rt_mm_fault_op fault_op; @@ -200,13 +201,14 @@ void handle_user(rt_size_t scause, rt_size_t stval, rt_size_t sepc, struct rt_hw if (fault_op) { + lwp = lwp_self(); struct rt_aspace_fault_msg msg = { .fault_op = fault_op, .fault_type = fault_type, .fault_vaddr = (void *)stval, }; - if (rt_aspace_fault_try_fix(&msg)) + if (lwp && rt_aspace_fault_try_fix(lwp->aspace, &msg)) { return; } From 963a5b299d6324c032ca4c74ed0c8dee6dc1b624 Mon Sep 17 00:00:00 2001 From: Shell Date: Tue, 15 Aug 2023 20:05:58 +0800 Subject: [PATCH 3/4] [def] replace RT_USING_MUSL with RT_USING_MUSLLIBC Signed-off-by: Shell --- .../dfs/dfs_v1/filesystems/nfs/rpc/types.h | 2 +- components/lwp/libc_musl.h | 100 ++++++++++++++++++ components/lwp/lwp.c | 2 +- components/lwp/lwp.h | 16 +-- components/lwp/lwp_syscall.c | 10 +- components/lwp/lwp_user_mm.c | 6 +- 6 files changed, 121 insertions(+), 15 deletions(-) create mode 100644 components/lwp/libc_musl.h diff --git a/components/dfs/dfs_v1/filesystems/nfs/rpc/types.h b/components/dfs/dfs_v1/filesystems/nfs/rpc/types.h index 6afc2279b80..a8bc5d98cc4 100644 --- a/components/dfs/dfs_v1/filesystems/nfs/rpc/types.h +++ b/components/dfs/dfs_v1/filesystems/nfs/rpc/types.h @@ -60,7 +60,7 @@ typedef unsigned long u_long; typedef int bool_t; typedef int enum_t; -#if !defined(RT_USING_NEWLIB) && !defined(RT_USING_MUSL) +#if !defined(RT_USING_NEWLIB) && !defined(RT_USING_MUSLLIBC) typedef unsigned long dev_t; #endif diff --git a/components/lwp/libc_musl.h b/components/lwp/libc_musl.h new file mode 100644 index 00000000000..da8d019669b --- /dev/null +++ b/components/lwp/libc_musl.h @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2006-2023, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2023-07-11 RT-Thread first version + */ + +#ifndef __LIBC_MUSL_H__ +#define __LIBC_MUSL_H__ + +/* from internal/futex.h */ + +#define FUTEX_WAIT 0 +#define FUTEX_WAKE 1 +#define FUTEX_FD 2 +#define FUTEX_REQUEUE 3 +#define FUTEX_CMP_REQUEUE 4 +#define FUTEX_WAKE_OP 5 +#define FUTEX_LOCK_PI 6 +#define FUTEX_UNLOCK_PI 7 +#define FUTEX_TRYLOCK_PI 8 +#define FUTEX_WAIT_BITSET 9 + +#define FUTEX_PRIVATE 128 + +#define FUTEX_CLOCK_REALTIME 256 + +/* for pmutex op */ +#define PMUTEX_INIT 0 +#define PMUTEX_LOCK 1 +#define PMUTEX_UNLOCK 2 +#define PMUTEX_DESTROY 3 + +/* for sys/mman.h */ +#define MAP_FAILED ((void *) -1) + +#define MAP_SHARED 0x01 +#define MAP_PRIVATE 0x02 +#define MAP_SHARED_VALIDATE 0x03 +#define MAP_TYPE 0x0f +#define MAP_FIXED 0x10 +#define MAP_ANON 0x20 +#define MAP_ANONYMOUS MAP_ANON +#define MAP_NORESERVE 0x4000 +#define MAP_GROWSDOWN 0x0100 +#define MAP_DENYWRITE 0x0800 +#define MAP_EXECUTABLE 0x1000 +#define MAP_LOCKED 0x2000 +#define MAP_POPULATE 0x8000 +#define MAP_NONBLOCK 0x10000 +#define MAP_STACK 0x20000 +#define MAP_HUGETLB 0x40000 +#define MAP_SYNC 0x80000 +#define MAP_FIXED_NOREPLACE 0x100000 +#define MAP_FILE 0 + +#define MAP_UNINITIALIZED 0x4000000 /** For anonymous mmap, memory could be + * uninitialized */ + +#define MAP_HUGE_SHIFT 26 +#define MAP_HUGE_MASK 0x3f +#define MAP_HUGE_16KB (14 << 26) +#define MAP_HUGE_64KB (16 << 26) +#define MAP_HUGE_512KB (19 << 26) +#define MAP_HUGE_1MB (20 << 26) +#define MAP_HUGE_2MB (21 << 26) +#define MAP_HUGE_8MB (23 << 26) +#define MAP_HUGE_16MB (24 << 26) +#define MAP_HUGE_32MB (25 << 26) +#define MAP_HUGE_256MB (28 << 26) +#define MAP_HUGE_512MB (29 << 26) +#define MAP_HUGE_1GB (30 << 26) +#define MAP_HUGE_2GB (31 << 26) +#define MAP_HUGE_16GB (34U << 26) + +#define PROT_NONE 0 +#define PROT_READ 1 +#define PROT_WRITE 2 +#define PROT_EXEC 4 +#define PROT_GROWSDOWN 0x01000000 +#define PROT_GROWSUP 0x02000000 + +#define MS_ASYNC 1 +#define MS_INVALIDATE 2 +#define MS_SYNC 4 + +#define MCL_CURRENT 1 +#define MCL_FUTURE 2 +#define MCL_ONFAULT 4 + +#define POSIX_MADV_NORMAL 0 +#define POSIX_MADV_RANDOM 1 +#define POSIX_MADV_SEQUENTIAL 2 +#define POSIX_MADV_WILLNEED 3 +#define POSIX_MADV_DONTNEED 4 + +#endif /* __LIBC_MUSL_H__ */ diff --git a/components/lwp/lwp.c b/components/lwp/lwp.c index 96ebdd866cd..ee5d05a33c9 100644 --- a/components/lwp/lwp.c +++ b/components/lwp/lwp.c @@ -1341,7 +1341,7 @@ pid_t lwp_execve(char *filename, int debug, int argc, char **argv, char **envp) return -RT_ERROR; } -#ifdef RT_USING_MUSL +#ifdef RT_USING_MUSLLIBC extern char **__environ; #else char **__environ = 0; diff --git a/components/lwp/lwp.h b/components/lwp/lwp.h index 841ce7725e8..147f0c60519 100644 --- a/components/lwp/lwp.h +++ b/components/lwp/lwp.h @@ -23,6 +23,7 @@ #include #include +#include "lwp_arch.h" #include "lwp_pid.h" #include "lwp_ipc.h" #include "lwp_signal.h" @@ -30,22 +31,25 @@ #include "lwp_avl.h" #include "mm_aspace.h" +#ifdef RT_USING_MUSLLIBC +#include "libc_musl.h" +#endif /* RT_USING_MUSLLIBC */ + #ifdef ARCH_MM_MMU #include "lwp_shm.h" - #include "mmu.h" #include "page.h" #else #include "lwp_mpu.h" -#endif -#include "lwp_arch.h" +#endif /* ARCH_MM_MMU */ -#ifdef RT_USING_MUSL +#ifdef RT_USING_MUSLLIBC #include -#endif +#endif /* RT_USING_MUSLLIBC */ + #ifdef RT_USING_TTY struct tty_struct; -#endif +#endif /* RT_USING_TTY */ #ifdef __cplusplus extern "C" { diff --git a/components/lwp/lwp_syscall.c b/components/lwp/lwp_syscall.c index 547d333f481..8962410fbd6 100644 --- a/components/lwp/lwp_syscall.c +++ b/components/lwp/lwp_syscall.c @@ -764,18 +764,18 @@ sysret_t sys_poll(struct pollfd *fds, nfds_t nfds, int timeout) kmem_put(kfds); return ret; #else -#ifdef RT_USING_MUSL +#ifdef RT_USING_MUSLLIBC for (i = 0; i < nfds; i++) { musl2dfs_events(&fds->events); } -#endif /* RT_USING_MUSL */ +#endif /* RT_USING_MUSLLIBC */ if (!lwp_user_accessable((void *)fds, nfds * sizeof *fds)) { return -EFAULT; } ret = poll(fds, nfds, timeout); -#ifdef RT_USING_MUSL +#ifdef RT_USING_MUSLLIBC if (ret > 0) { for (i = 0; i < nfds; i++) @@ -783,7 +783,7 @@ sysret_t sys_poll(struct pollfd *fds, nfds_t nfds, int timeout) dfs2musl_events(&fds->revents); } } -#endif /* RT_USING_MUSL */ +#endif /* RT_USING_MUSLLIBC */ return ret; #endif /* ARCH_MM_MMU */ } @@ -3986,7 +3986,7 @@ sysret_t sys_rmdir(const char *path) #endif } -#ifdef RT_USING_MUSL +#ifdef RT_USING_MUSLLIBC typedef uint64_t ino_t; #endif diff --git a/components/lwp/lwp_user_mm.c b/components/lwp/lwp_user_mm.c index 3fa0dc9345a..0bbfcafcf37 100644 --- a/components/lwp/lwp_user_mm.c +++ b/components/lwp/lwp_user_mm.c @@ -31,6 +31,10 @@ #include #include +#ifdef RT_USING_MUSLLIBC +#include "libc_musl.h" +#endif + #define DBG_TAG "LwP" #define DBG_LVL DBG_LOG #include @@ -506,8 +510,6 @@ rt_base_t lwp_brk(void *addr) return ret; } -#define MAP_ANONYMOUS 0x20 - void *lwp_mmap2(void *addr, size_t length, int prot, int flags, int fd, off_t pgoffset) { From 8f4d1dcf577e671c29447cfd5ff94aea9419849e Mon Sep 17 00:00:00 2001 From: Shell Date: Tue, 15 Aug 2023 20:06:17 +0800 Subject: [PATCH 4/4] [smart] add unit test case for new supported API Test covering rt_aspace_fault_try_fix, lwp_user_accessible_ext, lwp_user_accessable, rt_varea_unmap_range, rt_varea_unmap_page Signed-off-by: Shell --- examples/utest/testcases/mm/SConscript | 4 +- examples/utest/testcases/mm/common.h | 5 +- examples/utest/testcases/mm/mm_lwp_tc.c | 30 ++++++++- examples/utest/testcases/mm/test_aspace_api.h | 61 ++++++++++++++++++- examples/utest/testcases/mm/test_bst_adpt.h | 1 - 5 files changed, 93 insertions(+), 8 deletions(-) diff --git a/examples/utest/testcases/mm/SConscript b/examples/utest/testcases/mm/SConscript index 876e5cab2c2..68f915a95fa 100644 --- a/examples/utest/testcases/mm/SConscript +++ b/examples/utest/testcases/mm/SConscript @@ -5,10 +5,10 @@ cwd = GetCurrentDir() src = [] CPPPATH = [cwd] -if GetDepend(['UTEST_MM_API_TC']): +if GetDepend(['UTEST_MM_API_TC', 'RT_USING_SMART']): src += ['mm_api_tc.c', 'mm_libcpu_tc.c'] -if GetDepend(['UTEST_MM_LWP_TC']): +if GetDepend(['UTEST_MM_LWP_TC', 'RT_USING_SMART']): src += ['mm_lwp_tc.c'] group = DefineGroup('utestcases', src, depend = ['RT_USING_UTESTCASES'], CPPPATH = CPPPATH) diff --git a/examples/utest/testcases/mm/common.h b/examples/utest/testcases/mm/common.h index cffe0e25e5e..da86ba46ff5 100644 --- a/examples/utest/testcases/mm/common.h +++ b/examples/utest/testcases/mm/common.h @@ -19,10 +19,13 @@ #include #include #include -#include #include #include +#ifdef RT_USING_SMART +#include +#endif + #include #include #include diff --git a/examples/utest/testcases/mm/mm_lwp_tc.c b/examples/utest/testcases/mm/mm_lwp_tc.c index 83c30302739..f3732624a12 100644 --- a/examples/utest/testcases/mm/mm_lwp_tc.c +++ b/examples/utest/testcases/mm/mm_lwp_tc.c @@ -52,9 +52,9 @@ static void test_user_map_varea(void) rt_varea_t varea; lwp = lwp_new(); + /* prepare environment */ uassert_true(!!lwp); - uassert_true(!lwp_user_space_init(lwp, 0)); - + uassert_true(!lwp_user_space_init(lwp, 1)); TEST_VAREA_INSERT( varea = lwp_map_user_varea(lwp, 0, buf_sz), lwp->aspace); @@ -77,7 +77,7 @@ static void test_user_map_varea_ext(void) lwp = lwp_new(); uassert_true(!!lwp); - uassert_true(!lwp_user_space_init(lwp, 0)); + uassert_true(!lwp_user_space_init(lwp, 1)); TEST_VAREA_INSERT( varea = lwp_map_user_varea_ext(lwp, 0, buf_sz, LWP_MAP_FLAG_NOCACHE), @@ -99,6 +99,29 @@ static void user_map_varea_tc(void) CONSIST_HEAP(test_user_map_varea_ext()); } +static void test_user_accessible(void) +{ + /* Prepare Environment */ + char *test_address = (char *)(USER_STACK_VEND); + struct rt_lwp *lwp; + lwp = lwp_new(); + uassert_true(!!lwp); + uassert_true(!lwp_user_space_init(lwp, 0)); + + /* test if user accessible can operate */ + uassert_true(!lwp_user_accessible_ext(lwp, test_address + 0x1, 0x1)); + /* test if mapping exist, accessible can fill the page and return True */ + uassert_true(lwp_user_accessible_ext(lwp, test_address - 0x10, 0x10)); + + /* Cleanup */ + lwp_ref_dec(lwp); +} + +static void accessible_tc(void) +{ + CONSIST_HEAP(test_user_accessible()); +} + static rt_err_t utest_tc_init(void) { return RT_EOK; @@ -112,5 +135,6 @@ static rt_err_t utest_tc_cleanup(void) static void testcase(void) { UTEST_UNIT_RUN(user_map_varea_tc); + UTEST_UNIT_RUN(accessible_tc); } UTEST_TC_EXPORT(testcase, "testcases.lwp.mm_tc", utest_tc_init, utest_tc_cleanup, 20); diff --git a/examples/utest/testcases/mm/test_aspace_api.h b/examples/utest/testcases/mm/test_aspace_api.h index d24204544b4..47f2bac670f 100644 --- a/examples/utest/testcases/mm/test_aspace_api.h +++ b/examples/utest/testcases/mm/test_aspace_api.h @@ -11,7 +11,6 @@ #define __TEST_ASPACE_API_H__ #include "common.h" -#include "lwp_arch.h" #include "test_aspace_api_internal.h" #include "test_synchronization.h" @@ -181,6 +180,7 @@ static void test_varea_map_page(void) void *page = rt_pages_alloc(0); uassert_true(!!page); uassert_true(!rt_varea_map_page(varea, varea->start + i, page)); + uassert_true(rt_kmem_v2p(varea->start + i) == (page + PV_OFFSET)); /* let page manager handle the free of page */ rt_varea_pgmgr_insert(varea, page); @@ -210,10 +210,69 @@ static void test_varea_map_range(void) uassert_true(!rt_aspace_unmap(&rt_kernel_space, varea->start)); } +/** + * @brief rt_varea_unmap_page + * Requirements: cancel the page table entry + */ +static void test_varea_unmap_page(void) +{ + /* Prepare environment */ + const size_t buf_sz = 4 * ARCH_PAGE_SIZE; + rt_varea_t varea = _create_varea(buf_sz); + for (size_t i = 0; i < buf_sz; i += ARCH_PAGE_SIZE) + { + void *page = rt_pages_alloc(0); + uassert_true(!!page); + uassert_true(!rt_varea_map_page(varea, varea->start + i, page)); + + /* let page manager handle the free of page */ + rt_varea_pgmgr_insert(varea, page); + uassert_true(rt_kmem_v2p(varea->start + i) == (page + PV_OFFSET)); + } + + /* test if unmap is success */ + for (size_t i = 0; i < buf_sz; i += ARCH_PAGE_SIZE) + { + uassert_true(rt_varea_unmap_page(varea, varea->start + i) == RT_EOK); + uassert_true(rt_kmem_v2p(varea->start + i) == ARCH_MAP_FAILED); + } + + uassert_true(!rt_aspace_unmap(&rt_kernel_space, varea->start)); +} + +/** + * @brief rt_varea_map_range + * Requirements: complete the page table entry + */ +static void test_varea_unmap_range(void) +{ + const size_t buf_sz = 4 * ARCH_PAGE_SIZE; + rt_varea_t varea = _create_varea(buf_sz); + void *page = rt_pages_alloc(rt_page_bits(buf_sz)); + uassert_true(!!page); + uassert_true(!rt_varea_map_range(varea, varea->start, page + PV_OFFSET, buf_sz)); + for (size_t i = 0; i < buf_sz; i += ARCH_PAGE_SIZE) + { + uassert_true(rt_kmem_v2p(varea->start + i) == (page + i + PV_OFFSET)); + } + + /* test if unmap is success */ + uassert_true(rt_varea_unmap_range(varea, varea->start, buf_sz) == RT_EOK); + for (size_t i = 0; i < buf_sz; i += ARCH_PAGE_SIZE) + { + uassert_true(rt_kmem_v2p(varea->start + i) == ARCH_MAP_FAILED); + } + + uassert_true(rt_pages_free(page, rt_page_bits(buf_sz))); + uassert_true(!rt_aspace_unmap(&rt_kernel_space, varea->start)); +} + static void varea_map_tc(void) { CONSIST_HEAP(test_varea_map_page()); CONSIST_HEAP(test_varea_map_range()); + CONSIST_HEAP(test_varea_unmap_page()); + CONSIST_HEAP(test_varea_unmap_range()); } static void aspace_traversal_tc(void) diff --git a/examples/utest/testcases/mm/test_bst_adpt.h b/examples/utest/testcases/mm/test_bst_adpt.h index eb075db6ed7..ffd153f08ac 100644 --- a/examples/utest/testcases/mm/test_bst_adpt.h +++ b/examples/utest/testcases/mm/test_bst_adpt.h @@ -11,7 +11,6 @@ #define __TEST_BST_ADPT_H__ #include "common.h" -#include "lwp_arch.h" #ifdef RT_USING_SMART #include "lwp_user_mm.h"