!130 加入mm_area的映射类型信息

Merge pull request !130 from jesven/add-mm_area-type

components/lwp/lwp_mm_area.c

@@ -12,10 +12,10 @@
 #ifdef RT_USING_USERSPACE
 #include <lwp_mm_area.h>
 
-int lwp_map_area_insert(struct lwp_avl_struct **avl_tree, size_t addr, size_t size, int auto_free)
+int lwp_map_area_insert(struct lwp_avl_struct **avl_tree, size_t addr, size_t size, int ma_type)
 {
-    struct lwp_avl_struct *node;
-    struct rt_mm_area_struct *ma;
+    struct lwp_avl_struct *node = RT_NULL;
+    struct rt_mm_area_struct *ma = RT_NULL;
 
     if (!size)
     {
@@ -28,7 +28,7 @@ int lwp_map_area_insert(struct lwp_avl_struct **avl_tree, size_t addr, size_t si
     }
     ma->addr = addr;
     ma->size = size;
-    ma->auto_free = auto_free;
+    ma->type = ma_type;
 
     node = (struct lwp_avl_struct *)rt_malloc(sizeof(struct lwp_avl_struct));
     if (!node)
@@ -46,7 +46,7 @@ int lwp_map_area_insert(struct lwp_avl_struct **avl_tree, size_t addr, size_t si
 
 void lwp_map_area_remove(struct lwp_avl_struct **avl_tree, size_t addr)
 {
-    struct lwp_avl_struct *node;
+    struct lwp_avl_struct *node = RT_NULL;
 
     node = lwp_avl_find(addr, *avl_tree);
     if (!node)
@@ -60,9 +60,29 @@ void lwp_map_area_remove(struct lwp_avl_struct **avl_tree, size_t addr)
 
 struct lwp_avl_struct* lwp_map_find(struct lwp_avl_struct* ptree, size_t addr)
 {
-    struct lwp_avl_struct *node;
+    struct lwp_avl_struct *node = ptree;
 
-    node = lwp_avl_find(addr, ptree);
+    while (1)
+    {
+        if (!node)
+        {
+            return node;
+        }
+        if ((size_t)node->avl_key <= addr)
+        {
+            struct rt_mm_area_struct *ma = (struct rt_mm_area_struct*)node->data;
+            if ((ma->addr <= addr) && (addr < ma->addr + ma->size))
+            {
+                /* find area */
+                break;
+            }
+            node = node->avl_right;
+        }
+        else
+        {
+            node = node->avl_left;
+        }
+    }
     return node;
 }
 
@@ -75,7 +95,9 @@ struct lwp_avl_struct* lwp_map_find_first(struct lwp_avl_struct* ptree)
     while (1)
     {
         if (!ptree->avl_left)
+        {
             break;
+        }
         ptree = ptree->avl_left;
     }
     return ptree;

components/lwp/lwp_mm_area.h

@@ -21,14 +21,22 @@
 extern "C" {
 #endif
 
+enum
+{
+    MM_AREA_TYPE_PHY = 0,  /* mm_area physical address is IO register or reserved memory */
+    MM_AREA_TYPE_SHM,      /* mm_area physical address is shared memory */
+    MM_AREA_TYPE_AUTO,     /* mm_area physical address is alloced from page manager */
+    MM_AREA_TYPE_UNKNOW,
+};
+
 struct rt_mm_area_struct
 {
     size_t addr;
     size_t size;
-    int auto_free;
+    int type;
 };
 
-int lwp_map_area_insert(struct lwp_avl_struct **avl_tree, size_t addr, size_t size, int auto_free);
+int lwp_map_area_insert(struct lwp_avl_struct **avl_tree, size_t addr, size_t size, int ma_type);
 void lwp_map_area_remove(struct lwp_avl_struct **avl_tree, size_t addr);
 struct lwp_avl_struct* lwp_map_find(struct lwp_avl_struct* ptree, size_t addr);
 struct lwp_avl_struct* lwp_map_find_first(struct lwp_avl_struct* ptree);

components/lwp/lwp_shm.c

@@ -68,8 +68,8 @@ static int _lwp_shmget(size_t key, size_t size, int create)
     int id = -1;
     struct lwp_avl_struct *node_key = 0;
     struct lwp_avl_struct *node_pa = 0;
-    void *page_addr = 0, *page_addr_p;
-    uint32_t bit;
+    void *page_addr = 0, *page_addr_p = RT_NULL;
+    uint32_t bit = 0;
 
     /* try to locate the item with the key in the binary tree */
     node_key = lwp_avl_find(key, shm_tree_key);
@@ -145,10 +145,10 @@ err:
 /* A wrapping function, get the shared memory with interrupts disabled. */
 int lwp_shmget(size_t key, size_t size, int create)
 {
-    int ret;
-    rt_base_t level;
+    int ret = 0;
+    rt_base_t level = 0;
 
-    level= rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
     ret = _lwp_shmget(key, size, create);
     rt_hw_interrupt_enable(level);
     return ret;
@@ -158,7 +158,7 @@ int lwp_shmget(size_t key, size_t size, int create)
 static struct lwp_avl_struct *shm_id_to_node(int id)
 {
     struct lwp_avl_struct *node_key = 0;
-    struct lwp_shm_struct *p;
+    struct lwp_shm_struct *p = RT_NULL;
 
     /* check id */
     if (id < 0 || id >= RT_LWP_SHM_MAX_NR)
@@ -182,10 +182,10 @@ static struct lwp_avl_struct *shm_id_to_node(int id)
 /* Free the shared pages, the shared-memory structure and its binary tree node_key. */
 static int _lwp_shmrm(int id)
 {
-    struct lwp_avl_struct *node_key;
-    struct lwp_avl_struct *node_pa;
-    struct lwp_shm_struct* p;
-    uint32_t bit;
+    struct lwp_avl_struct *node_key = RT_NULL;
+    struct lwp_avl_struct *node_pa = RT_NULL;
+    struct lwp_shm_struct* p = RT_NULL;
+    uint32_t bit = 0;
 
     node_key = shm_id_to_node(id);
     if (!node_key)
@@ -210,10 +210,10 @@ static int _lwp_shmrm(int id)
 /* A wrapping function, free the shared memory with interrupt disabled. */
 int lwp_shmrm(int id)
 {
-    int ret;
-    rt_base_t level;
+    int ret = 0;
+    rt_base_t level = 0;
 
-    level= rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
     ret = _lwp_shmrm(id);
     rt_hw_interrupt_enable(level);
     return ret;
@@ -222,10 +222,10 @@ int lwp_shmrm(int id)
 /* Map the shared memory specified by 'id' to the specified virtual address. */
 static void *_lwp_shmat(int id, void *shm_vaddr)
 {
-    struct rt_lwp *lwp;
-    struct lwp_avl_struct *node_key;
-    struct lwp_shm_struct *p;
-    void *va;
+    struct rt_lwp *lwp  = RT_NULL;
+    struct lwp_avl_struct *node_key = RT_NULL;
+    struct lwp_shm_struct *p = RT_NULL;
+    void *va = RT_NULL;
 
     /* The id is used to locate the node_key in the binary tree, and then get the
      * shared-memory structure linked to the node_key. We don't use the id to refer
@@ -245,7 +245,7 @@ static void *_lwp_shmat(int id, void *shm_vaddr)
     {
         return RT_NULL;
     }
-    va = lwp_map_user_phy(lwp, shm_vaddr, (void*)p->addr, p->size, 1);
+    va = lwp_map_user_type(lwp, shm_vaddr, (void*)p->addr, p->size, 1, MM_AREA_TYPE_SHM);
     if (va)
     {
         p->ref++;
@@ -256,8 +256,8 @@ static void *_lwp_shmat(int id, void *shm_vaddr)
 /* A wrapping function: attach the shared memory to the specified address. */
 void *lwp_shmat(int id, void *shm_vaddr)
 {
-    void *ret;
-    rt_base_t level;
+    void *ret = RT_NULL;
+    rt_base_t level = 0;
 
     if (((size_t)shm_vaddr & ARCH_PAGE_MASK) != 0)
     {
@@ -272,10 +272,10 @@ void *lwp_shmat(int id, void *shm_vaddr)
 /* Unmap the shared memory from the address space of the current thread. */
 int _lwp_shmdt(void *shm_vaddr)
 {
-    struct rt_lwp *lwp;
-    void *pa;
-    struct lwp_avl_struct *node_pa;
-    struct lwp_shm_struct* p;
+    struct rt_lwp *lwp = RT_NULL;
+    void *pa = RT_NULL;
+    struct lwp_avl_struct *node_pa = RT_NULL;
+    struct lwp_shm_struct* p = RT_NULL;
 
     lwp = (struct rt_lwp*)rt_thread_self()->lwp;
     if (!lwp)
@@ -296,15 +296,15 @@ int _lwp_shmdt(void *shm_vaddr)
     }
     p->ref--;
 
-    lwp_unmap_user_phy(lwp, shm_vaddr, p->size);
+    lwp_unmap_user_phy(lwp, shm_vaddr);
     return 0;
 }
 
 /* A wrapping function: detach the mapped shared memory. */
 int lwp_shmdt(void *shm_vaddr)
 {
-    int ret;
-    rt_base_t level;
+    int ret = 0;
+    rt_base_t level = 0;
 
     level = rt_hw_interrupt_disable();
     ret = _lwp_shmdt(shm_vaddr);
@@ -316,8 +316,8 @@ int lwp_shmdt(void *shm_vaddr)
 /* Get the virtual address of a shared memory in kernel. */
 void *_lwp_shminfo(int id)
 {
-    struct lwp_avl_struct *node_key;
-    struct lwp_shm_struct *p;
+    struct lwp_avl_struct *node_key = RT_NULL;
+    struct lwp_shm_struct *p = RT_NULL;
 
     /* the share memory is in use only if it exsits in the binary tree */
     node_key = shm_id_to_node(id);
@@ -333,8 +333,8 @@ void *_lwp_shminfo(int id)
 /* A wrapping function: get the virtual address of a shared memory. */
 void *lwp_shminfo(int id)
 {
-    void *vaddr;
-    rt_base_t level;
+    void *vaddr = RT_NULL;
+    rt_base_t level = 0;
 
     level = rt_hw_interrupt_disable();
     vaddr = _lwp_shminfo(id);
@@ -345,7 +345,7 @@ void *lwp_shminfo(int id)
 #ifdef RT_USING_FINSH
 static void _shm_info(struct lwp_avl_struct* node_key, void *data)
 {
-    int id;
+    int id = 0;
     struct lwp_shm_struct* p = (struct lwp_shm_struct*)node_key->data;
 
     id = p - _shm_ary;
@@ -354,7 +354,7 @@ static void _shm_info(struct lwp_avl_struct* node_key, void *data)
 
 void list_shm(void)
 {
-    rt_base_t level;
+    rt_base_t level = 0;
 
     rt_kprintf("   key        paddr      size       id\n");
     rt_kprintf("---------- ---------- ---------- --------\n");

components/lwp/lwp_syscall.c

@@ -1014,10 +1014,10 @@ void *sys_mmap2(void *addr, size_t length, int prot,
     return lwp_mmap2(addr, length, prot, flags, fd, pgoffset);
 }
 
-extern int lwp_munmap(void *addr, size_t length);
+extern int lwp_munmap(void *addr);
 int sys_munmap(void *addr, size_t length)
 {
-    return lwp_munmap(addr, length);
+    return lwp_munmap(addr);
 }
 #endif
 

components/lwp/lwp_user_mm.c

@@ -34,7 +34,7 @@ void *mmu_table_get(void);
 void lwp_mmu_switch(struct rt_thread *thread)
 {
     struct rt_lwp *l = RT_NULL;
-    void *pre_mmu_table, *new_mmu_table;
+    void *pre_mmu_table = RT_NULL, *new_mmu_table = RT_NULL;
 
     if (thread->lwp)
     {
@@ -42,8 +42,9 @@ void lwp_mmu_switch(struct rt_thread *thread)
         new_mmu_table = (void*)((char*)l->mmu_info.vtable + l->mmu_info.pv_off);
 #ifdef LWP_DEBUG
         {
-            int i;
+            int i = 0;
             size_t *p = l->mmu_info.vtable;
+
             rt_kprintf("vtable = 0x%p\n", l->mmu_info.vtable);
             for (i = 0; i < 0x1000; i++)
             {
@@ -72,7 +73,7 @@ void lwp_mmu_switch(struct rt_thread *thread)
 #ifdef RT_USING_GDBSERVER
     if (l && l->debug)
     {
-        uint32_t step_type;
+        uint32_t step_type = 0;
 
         step_type = gdb_get_step_type();
 
@@ -88,10 +89,10 @@ void lwp_mmu_switch(struct rt_thread *thread)
 #endif
 }
 
-static void free_area(struct rt_lwp *lwp, void *addr, size_t size, int auto_free)
+static void unmap_range(struct rt_lwp *lwp, void *addr, size_t size, int pa_need_free)
 {
-    void *va, *pa;
-    int i;
+    void *va = RT_NULL, *pa = RT_NULL;
+    int i = 0;
 
     for (va = addr, i = 0; i < size; va = (void*)((char*)va + ARCH_PAGE_SIZE), i += ARCH_PAGE_SIZE)
     {
@@ -99,7 +100,7 @@ static void free_area(struct rt_lwp *lwp, void *addr, size_t size, int auto_free
         if (pa)
         {
             rt_hw_mmu_unmap(&lwp->mmu_info, va, ARCH_PAGE_SIZE);
-            if (auto_free)
+            if (pa_need_free)
             {
                 rt_pages_free((void*)((char*)pa - PV_OFFSET), 0);
             }
@@ -109,15 +110,15 @@ static void free_area(struct rt_lwp *lwp, void *addr, size_t size, int auto_free
 
 void lwp_unmap_user_space(struct rt_lwp *lwp)
 {
-    struct lwp_avl_struct* node;
+    struct lwp_avl_struct* node = RT_NULL;
     rt_mmu_info *m_info = &lwp->mmu_info;
 
     while ((node = lwp_map_find_first(lwp->map_area)) != 0)
     {
-        struct rt_mm_area_struct *ma;
+        struct rt_mm_area_struct *ma = (struct rt_mm_area_struct*)node->data;
 
-        ma = (struct rt_mm_area_struct*)node->data;
-        free_area(lwp, (void*)ma->addr, ma->size, ma->auto_free);
+        RT_ASSERT(ma->type < MM_AREA_TYPE_UNKNOW);
+        unmap_range(lwp, (void*)ma->addr, ma->size, (int)(ma->type == MM_AREA_TYPE_AUTO));
         lwp_map_area_remove(&lwp->map_area, ma->addr);
     }
     rt_pages_free(m_info->vtable, 2);
@@ -125,8 +126,8 @@ void lwp_unmap_user_space(struct rt_lwp *lwp)
 
 static void *_lwp_map_user(struct rt_lwp *lwp, void *map_va, size_t map_size)
 {
-    void *va;
-    int ret;
+    void *va = RT_NULL;
+    int ret = 0;
     rt_mmu_info *m_info = &lwp->mmu_info;
 
     va = rt_hw_mmu_map_auto(m_info, map_va, map_size, MMU_MAP_U_RWCB);
@@ -134,62 +135,51 @@ static void *_lwp_map_user(struct rt_lwp *lwp, void *map_va, size_t map_size)
     {
         return 0;
     }
-    ret = lwp_map_area_insert(&lwp->map_area, (size_t)va, map_size, 1);
+    ret = lwp_map_area_insert(&lwp->map_area, (size_t)va, map_size, MM_AREA_TYPE_AUTO);
     if (ret != 0)
     {
-        free_area(lwp, va, map_size, 1);
+        unmap_range(lwp, va, map_size, 1);
         return 0;
     }
     return va;
 }
 
-int lwp_unmap_user(struct rt_lwp *lwp, void *va, size_t size)
+int lwp_unmap_user(struct rt_lwp *lwp, void *va)
 {
-    rt_base_t level;
-    size_t offset;
+    rt_base_t level = 0;
+    struct lwp_avl_struct *ma_avl_node = RT_NULL;
+    struct rt_mm_area_struct *ma = RT_NULL;
 
-    if (!size)
+    level = rt_hw_interrupt_disable();
+    ma_avl_node = lwp_map_find(lwp->map_area, (size_t)va);
+    if (!ma_avl_node)
     {
+        rt_hw_interrupt_enable(level);
         return -1;
     }
-    offset = (size_t)va & ARCH_PAGE_MASK;
-    size += (offset + ARCH_PAGE_SIZE - 1);
-    size &= ~ARCH_PAGE_MASK;
-    va = (void*)((size_t)va & ~ARCH_PAGE_MASK);
-
-    level = rt_hw_interrupt_disable();
-    free_area(lwp, va, size, 1);
+    ma = (struct rt_mm_area_struct *)ma_avl_node->data;
+    RT_ASSERT(ma->type < MM_AREA_TYPE_UNKNOW);
+    unmap_range(lwp, (void *)ma->addr, ma->size, (int)(ma->type == MM_AREA_TYPE_AUTO));
     lwp_map_area_remove(&lwp->map_area, (size_t)va);
     rt_hw_interrupt_enable(level);
     return 0;
 }
 
-int lwp_unmap_user_phy(struct rt_lwp *lwp, void *va, size_t size)
+int lwp_unmap_user_phy(struct rt_lwp *lwp, void *va)
 {
-    rt_base_t level;
-    size_t offset;
-
-    if (!size)
-    {
-        return -1;
-    }
-    offset = (size_t)va & ARCH_PAGE_MASK;
-    size += (offset + ARCH_PAGE_SIZE - 1);
-    size &= ~ARCH_PAGE_MASK;
-    va = (void*)((size_t)va & ~ARCH_PAGE_MASK);
+    return lwp_unmap_user(lwp, va);
+}
 
-    level = rt_hw_interrupt_disable();
-    free_area(lwp, va, size, 0);
-    lwp_map_area_remove(&lwp->map_area, (size_t)va);
-    rt_hw_interrupt_enable(level);
-    return 0;
+int lwp_unmap_user_type(struct rt_lwp *lwp, void *va)
+{
+    return lwp_unmap_user(lwp, va);
 }
 
 void *lwp_map_user(struct rt_lwp *lwp, void *map_va, size_t map_size)
 {
-    rt_base_t level;
-    void *ret;
-    size_t offset;
+    rt_base_t level = 0;
+    void *ret = RT_NULL;
+    size_t offset = 0;
 
     if (!map_size)
     {
@@ -210,12 +200,12 @@ void *lwp_map_user(struct rt_lwp *lwp, void *map_va, size_t map_size)
     return ret;
 }
 
-static void *_lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t map_size, int cached)
+static void *_lwp_map_user_type(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t map_size, int cached, int type)
 {
-    void *va;
+    void *va = RT_NULL;
     rt_mmu_info *m_info = &lwp->mmu_info;
-    size_t attr;
-    int ret;
+    size_t attr = 0;
+    int ret = 0;
 
     if (cached)
     {
@@ -227,20 +217,20 @@ static void *_lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa, s
     }
 
     va = rt_hw_mmu_map(m_info, map_va, map_pa, map_size, attr);
-    ret = lwp_map_area_insert(&lwp->map_area, (size_t)va, map_size, 0);
+    ret = lwp_map_area_insert(&lwp->map_area, (size_t)va, map_size, type);
     if (ret != 0)
     {
-        free_area(lwp, va, map_size, 0);
+        unmap_range(lwp, va, map_size, 0);
         return 0;
     }
     return va;
 }
 
-void *lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t map_size, int cached)
+void *lwp_map_user_type(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t map_size, int cached, int type)
 {
-    rt_base_t level;
-    void *ret;
-    size_t offset;
+    rt_base_t level = 0;
+    void *ret = RT_NULL;
+    size_t offset = 0;
 
     if (!map_size)
     {
@@ -259,7 +249,7 @@ void *lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t ma
     map_pa = (void*)((size_t)map_pa & ~ARCH_PAGE_MASK);
 
     level = rt_hw_interrupt_disable();
-    ret = _lwp_map_user_phy(lwp, map_va, map_pa, map_size, cached);
+    ret = _lwp_map_user_type(lwp, map_va, map_pa, map_size, cached, type);
     rt_hw_interrupt_enable(level);
     if (ret)
     {
@@ -268,11 +258,16 @@ void *lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t ma
     return ret;
 }
 
+void *lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t map_size, int cached)
+{
+    return lwp_map_user_type(lwp, map_va, map_pa, map_size, cached, MM_AREA_TYPE_PHY);
+}
+
 int lwp_brk(void *addr)
 {
-    rt_base_t level;
+    rt_base_t level = 0;
     int ret = -1;
-    struct rt_lwp *lwp;
+    struct rt_lwp *lwp = RT_NULL;
 
     level = rt_hw_interrupt_disable();
     lwp = rt_thread_self()->lwp;
@@ -305,9 +300,9 @@ int lwp_brk(void *addr)
 void* lwp_mmap2(void *addr, size_t length, int prot,
         int flags, int fd, off_t pgoffset)
 {
-    rt_base_t level;
+    rt_base_t level = 0;
     void *ret = (void*)-1;
-    struct rt_lwp *lwp;
+    struct rt_lwp *lwp = RT_NULL;
 
     level = rt_hw_interrupt_disable();
     if (fd == -1)
@@ -323,23 +318,23 @@ void* lwp_mmap2(void *addr, size_t length, int prot,
     return ret;
 }
 
-int lwp_munmap(void *addr, size_t length)
+int lwp_munmap(void *addr)
 {
-    rt_base_t level;
-    int ret;
-    struct rt_lwp *lwp;
+    rt_base_t level = 0;
+    int ret = 0;
+    struct rt_lwp *lwp = RT_NULL;
 
     level = rt_hw_interrupt_disable();
     lwp = rt_thread_self()->lwp;
-    ret = lwp_unmap_user(lwp, addr, length);
+    ret = lwp_unmap_user(lwp, addr);
     rt_hw_interrupt_enable(level);
     return ret;
 }
 
 size_t lwp_get_from_user(void *dst, void *src, size_t size)
 {
-    struct rt_lwp *lwp;
-    rt_mmu_info *m_info;
+    struct rt_lwp *lwp = RT_NULL;
+    rt_mmu_info *m_info = RT_NULL;
 
     /* check src */
     if (src >= (void*)KERNEL_VADDR_START)
@@ -363,8 +358,8 @@ 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)
 {
-    struct rt_lwp *lwp;
-    rt_mmu_info *m_info;
+    struct rt_lwp *lwp = RT_NULL;
+    rt_mmu_info *m_info = RT_NULL;
 
     /* check dst */
     if (dst >= (void*)KERNEL_VADDR_START)
@@ -387,8 +382,8 @@ size_t lwp_put_to_user(void *dst, void *src, size_t size)
 
 int lwp_user_accessable(void *addr, size_t size)
 {
-    void *addr_start, *addr_end, *next_page;
-    void *tmp_addr;
+    void *addr_start = RT_NULL, *addr_end = RT_NULL, *next_page = RT_NULL;
+    void *tmp_addr = RT_NULL;
     struct rt_lwp *lwp = lwp_self();
     rt_mmu_info *mmu_info = RT_NULL;
 
@@ -437,8 +432,8 @@ int lwp_user_accessable(void *addr, size_t size)
 size_t lwp_data_get(rt_mmu_info *mmu_info, void *dst, void *src, size_t size)
 {
     size_t copy_len = 0;
-    void *addr_start, *addr_end, *next_page;
-    void *tmp_dst, *tmp_src;
+    void *addr_start = RT_NULL, *addr_end = RT_NULL, *next_page = RT_NULL;
+    void *tmp_dst = RT_NULL, *tmp_src = RT_NULL;
 
     if (!size || !dst)
     {
@@ -476,8 +471,8 @@ size_t lwp_data_get(rt_mmu_info *mmu_info, void *dst, void *src, size_t size)
 size_t lwp_data_put(rt_mmu_info *mmu_info, void *dst, void *src, size_t size)
 {
     size_t copy_len = 0;
-    void *addr_start, *addr_end, *next_page;
-    void *tmp_dst, *tmp_src;
+    void *addr_start = RT_NULL, *addr_end = RT_NULL, *next_page = RT_NULL;
+    void *tmp_dst = RT_NULL, *tmp_src = RT_NULL;
 
     if (!size || !dst)
     {
@@ -513,7 +508,7 @@ size_t lwp_data_put(rt_mmu_info *mmu_info, void *dst, void *src, size_t size)
 
 void lwp_data_cache_flush(rt_mmu_info *mmu_info, void *vaddr, size_t size)
 {
-    void *paddr;
+    void *paddr = RT_NULL;
 
     paddr = rt_hw_mmu_v2p(mmu_info, vaddr);
     paddr = (void*)((char*)paddr - PV_OFFSET);

components/lwp/lwp_user_mm.h

@@ -24,15 +24,18 @@ extern "C" {
 int lwp_user_space_init(struct rt_lwp *lwp);
 void lwp_unmap_user_space(struct rt_lwp *lwp);
 
-int lwp_unmap_user(struct rt_lwp *lwp, void *va, size_t size);
+int lwp_unmap_user(struct rt_lwp *lwp, void *va);
 void *lwp_map_user(struct rt_lwp *lwp, void *map_va, size_t map_size);
 
 void *lwp_map_user_phy(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t map_size, int cached);
-int lwp_unmap_user_phy(struct rt_lwp *lwp, void *va, size_t size);
+int lwp_unmap_user_phy(struct rt_lwp *lwp, void *va);
+
+void *lwp_map_user_type(struct rt_lwp *lwp, void *map_va, void *map_pa, size_t map_size, int cached, int type);
+int lwp_unmap_user_type(struct rt_lwp *lwp, void *va);
 
 int lwp_brk(void *addr);
 void* lwp_mmap2(void *addr, size_t length, int prot, int flags, int fd, off_t pgoffset);
-int lwp_munmap(void *addr, size_t length);
+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);