[Kernel] move module tolibc/libdl.

components/finsh/cmd.c

@@ -584,38 +584,6 @@ FINSH_FUNCTION_EXPORT(list_device, list device in system);
 MSH_CMD_EXPORT(list_device, list device in system);
 #endif
 
-#ifdef RT_USING_MODULE
-#include <rtm.h>
-
-int list_module(void)
-{
-    int maxlen;
-    struct rt_module *module;
-    struct rt_list_node *list, *node;
-    struct rt_object_information *info;
-    const char *item_title = "module";
-
-    info = rt_object_get_information(RT_Object_Class_Module);
-    list = &info->object_list;
-
-    maxlen = object_name_maxlen(item_title, list);
-
-    rt_kprintf("%-*.s ref      address \n", maxlen, item_title); object_split(maxlen);
-    rt_kprintf(         " -------- ------------\n");
-    for (node = list->next; node != list; node = node->next)
-    {
-        module = (struct rt_module *)(rt_list_entry(node, struct rt_object, list));
-        rt_kprintf("%-*.*s %-04d  0x%08x\n",
-                   maxlen, RT_NAME_MAX,
-                   module->parent.name, module->nref, module->module_space);
-    }
-
-    return 0;
-}
-FINSH_FUNCTION_EXPORT(list_module, list module in system);
-MSH_CMD_EXPORT(list_module, list module in system);
-#endif
-
 long list(void)
 {
 #ifndef FINSH_USING_MSH_ONLY

components/finsh/msh.c

@@ -37,8 +37,12 @@
 #include <dfs_posix.h>
 #endif
 
+#ifdef RT_USING_MODULE
+#include <dlmodule.h>
+#endif
+
 #ifndef FINSH_ARG_MAX
-#define FINSH_ARG_MAX    10
+#define FINSH_ARG_MAX    8
 #endif
 
 typedef int (*cmd_function_t)(int argc, char **argv);
@@ -64,7 +68,6 @@ static int msh_exit(int argc, char **argv)
 {
     /* return to finsh shell mode */
     __msh_state = RT_FALSE;
-
     return 0;
 }
 FINSH_FUNCTION_EXPORT_ALIAS(msh_exit, __cmd_exit, return to RT-Thread shell mode.);
@@ -254,7 +257,7 @@ int msh_exec_module(const char *cmd_line, int size)
     {
         /* found program */
         close(fd);
-        rt_module_exec_cmd(pg_name, cmd_line, size);
+        dlmodule_exec(pg_name, cmd_line, size);
         ret = 0;
     }
     else

components/libc/Kconfig

@@ -28,11 +28,9 @@ if RT_USING_LIBC && RT_USING_DFS
         default n
     endif
 
-    if RT_USING_MODULE
-    config RT_USING_LIBDL
-        bool "Enable dlopen/dlsym/dlclose feature"
+    config RT_USING_MODULE
+        bool "Enable dynamic module with dlopen/dlsym/dlclose feature"
         default n
-    endif
 endif
 
 endmenu

components/libc/compilers/newlib/syscalls.c

@@ -11,6 +11,10 @@
 #include <pthread.h>
 #endif
 
+#ifdef RT_USING_MODULE
+#include <dlmodule.h>
+#endif
+
 /* Reentrant versions of system calls.  */
 
 int
@@ -379,18 +383,12 @@ _free_r (struct _reent *ptr, void *addr)
 }
 
 void
-_exit (int status)
+exit (int status)
 {
 #ifdef RT_USING_MODULE
-    rt_module_t module;
-
-    module = rt_module_self();
-    if (module != RT_NULL)
+    if (dlmodule_self())
     {
-        rt_thread_suspend(rt_thread_self());
-
-        /* re-schedule */
-        rt_schedule();
+        dlmodule_exit(status);
     }
 #endif
 

components/libc/libdl/SConscript

 from building import *
 Import('rtconfig')
 
-src = Glob('*.c') + Glob('*.cpp')
+src = Glob('*.c') + Glob('*.cpp') + Glob('arch/*.c')
 cwd = GetCurrentDir()
 group   = []
 CPPPATH = [cwd]
 
 if rtconfig.PLATFORM == 'gcc':
     group = DefineGroup('libc', src, 
-        depend = ['RT_USING_MODULE', 'RT_USING_LIBDL'], 
+        depend = ['RT_USING_MODULE'], 
         CPPPATH = CPPPATH)
 
 Return('group')

components/libc/libdl/arch/arm.c

+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * 
+ * Change Logs:
+ * Date           Author      Notes
+ * 2018/08/29     Bernard     first version
+ */
+
+#include "../dlmodule.h"
+#include "../dlelf.h"
+
+#ifdef __arm__
+int dlmodule_relocate(struct rt_dlmodule *module, Elf32_Rel *rel, Elf32_Addr sym_val)
+{
+    Elf32_Addr *where, tmp;
+    Elf32_Sword addend, offset;
+    rt_uint32_t upper, lower, sign, j1, j2;
+
+    where = (Elf32_Addr *)((rt_uint8_t *)module->mem_space
+                           + rel->r_offset
+                           - module->vstart_addr);
+    switch (ELF32_R_TYPE(rel->r_info))
+    {
+    case R_ARM_NONE:
+        break;
+    case R_ARM_ABS32:
+        *where += (Elf32_Addr)sym_val;
+        RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_ARM_ABS32: %x -> %x\n",
+                                       where, *where));
+        break;
+    case R_ARM_PC24:
+    case R_ARM_PLT32:
+    case R_ARM_CALL:
+    case R_ARM_JUMP24:
+        addend = *where & 0x00ffffff;
+        if (addend & 0x00800000)
+            addend |= 0xff000000;
+        tmp = sym_val - (Elf32_Addr)where + (addend << 2);
+        tmp >>= 2;
+        *where = (*where & 0xff000000) | (tmp & 0x00ffffff);
+        RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_ARM_PC24: %x -> %x\n",
+                                       where, *where));
+        break;
+    case R_ARM_REL32:
+        *where += sym_val - (Elf32_Addr)where;
+        RT_DEBUG_LOG(RT_DEBUG_MODULE,
+                     ("R_ARM_REL32: %x -> %x, sym %x, offset %x\n",
+                      where, *where, sym_val, rel->r_offset));
+        break;
+    case R_ARM_V4BX:
+        *where &= 0xf000000f;
+        *where |= 0x01a0f000;
+        break;
+
+    case R_ARM_GLOB_DAT:
+    case R_ARM_JUMP_SLOT:
+        *where = (Elf32_Addr)sym_val;
+        RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_ARM_JUMP_SLOT: 0x%x -> 0x%x 0x%x\n",
+                                       where, *where, sym_val));
+        break;
+#if 0        /* To do */
+    case R_ARM_GOT_BREL:
+        temp   = (Elf32_Addr)sym_val;
+        *where = (Elf32_Addr)&temp;
+        RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_ARM_GOT_BREL: 0x%x -> 0x%x 0x%x\n",
+                                       where, *where, sym_val));
+        break;
+#endif
+
+    case R_ARM_RELATIVE:
+        *where = (Elf32_Addr)sym_val + *where;
+        RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_ARM_RELATIVE: 0x%x -> 0x%x 0x%x\n",
+                                       where, *where, sym_val));
+        break;
+    case R_ARM_THM_CALL:
+    case R_ARM_THM_JUMP24:
+        upper  = *(rt_uint16_t *)where;
+        lower  = *(rt_uint16_t *)((Elf32_Addr)where + 2);
+
+        sign   = (upper >> 10) & 1;
+        j1     = (lower >> 13) & 1;
+        j2     = (lower >> 11) & 1;
+        offset = (sign << 24) |
+                 ((~(j1 ^ sign) & 1) << 23) |
+                 ((~(j2 ^ sign) & 1) << 22) |
+                 ((upper & 0x03ff) << 12) |
+                 ((lower & 0x07ff) << 1);
+        if (offset & 0x01000000)
+            offset -= 0x02000000;
+        offset += sym_val - (Elf32_Addr)where;
+
+        if (!(offset & 1) ||
+            offset <= (rt_int32_t)0xff000000 ||
+            offset >= (rt_int32_t)0x01000000)
+        {
+            rt_kprintf("Module: Only Thumb addresses allowed\n");
+
+            return -1;
+        }
+
+        sign = (offset >> 24) & 1;
+        j1   = sign ^ (~(offset >> 23) & 1);
+        j2   = sign ^ (~(offset >> 22) & 1);
+        *(rt_uint16_t *)where = (rt_uint16_t)((upper & 0xf800) |
+                                              (sign << 10) |
+                                              ((offset >> 12) & 0x03ff));
+        *(rt_uint16_t *)(where + 2) = (rt_uint16_t)((lower & 0xd000) |
+                                                    (j1 << 13) | (j2 << 11) |
+                                                    ((offset >> 1) & 0x07ff));
+        upper = *(rt_uint16_t *)where;
+        lower = *(rt_uint16_t *)((Elf32_Addr)where + 2);
+        break;
+    default:
+        return -1;
+    }
+
+    return 0;
+}
+#endif

components/libc/libdl/dlclose.c

 /*
- * File      : dlclose.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 2010, RT-Thread Development Team
+ * Copyright (c) 2006-2018, RT-Thread Development Team
  *
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * SPDX-License-Identifier: Apache-2.0
  *
  * Change Logs:
- * Date           Author		Notes
- * 2010-11-17      yi.qiu	first version
+ * Date           Author       Notes
+ * 2010-11-17     yi.qiu       first version
  */
 
 #include <rtthread.h>
 #include <rtm.h>
 
-int dlclose (void *handle)
+#include "dlmodule.h"
+
+int dlclose(void *handle)
 {
-	rt_module_t module;
-	
-	RT_ASSERT(handle != RT_NULL);
-	
-	module = (rt_module_t)handle;
-	module->nref--;
-	
-	if(module->nref <= 0)
-	{
-		rt_module_unload(module);
-	}	
-
-	return RT_TRUE;
-}
+    struct rt_dlmodule *module;
 
-RTM_EXPORT(dlclose)
+    RT_ASSERT(handle != RT_NULL);
+
+    module = (struct rt_dlmodule *)handle;
 
+    rt_enter_critical();
+    module->nref--;
+    if (module->nref <= 0)
+    {
+        rt_exit_critical();
+
+        dlmodule_destroy(module);
+    }
+    else
+    {
+        rt_exit_critical();
+    }
+
+    return RT_TRUE;
+}
+RTM_EXPORT(dlclose)

components/libc/libdl/dlelf.c

+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author      Notes
+ * 2018/08/29     Bernard     first version
+ */
+
+#include "dlmodule.h"
+#include "dlelf.h"
+
+#define DBG_SECTION_NAME    "DLMD"
+#define DBG_ENABLE          // enable debug macro
+#define DBG_LEVEL           DBG_INFO
+#define DBG_COLOR
+#include <rtdbg.h>          // must after of DEBUG_ENABLE or some other options
+
+rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_ptr)
+{
+    rt_bool_t linked   = RT_FALSE;
+    rt_uint32_t index, module_size = 0;
+    Elf32_Addr vstart_addr, vend_addr;
+    rt_bool_t has_vstart;
+
+    RT_ASSERT(module_ptr != RT_NULL);
+
+    if (rt_memcmp(elf_module->e_ident, RTMMAG, SELFMAG) == 0)
+    {
+        /* rtmlinker finished */
+        linked = RT_TRUE;
+    }
+
+    /* get the ELF image size */
+    has_vstart = RT_FALSE;
+    vstart_addr = vend_addr = RT_NULL;
+    for (index = 0; index < elf_module->e_phnum; index++)
+    {
+        if (phdr[index].p_type != PT_LOAD)
+            continue;
+
+        LOG_D("LOAD segment: %d, 0x%p, 0x%08x", index, phdr[index].p_vaddr, phdr[index].p_memsz);
+
+        if (phdr[index].p_memsz < phdr[index].p_filesz)
+        {
+            rt_kprintf("invalid elf: segment %d: p_memsz: %d, p_filesz: %d\n",
+                       index, phdr[index].p_memsz, phdr[index].p_filesz);
+            return RT_NULL;
+        }
+        if (!has_vstart)
+        {
+            vstart_addr = phdr[index].p_vaddr;
+            vend_addr = phdr[index].p_vaddr + phdr[index].p_memsz;
+            has_vstart = RT_TRUE;
+            if (vend_addr < vstart_addr)
+            {
+                rt_kprintf("invalid elf: segment %d: p_vaddr: %d, p_memsz: %d\n",
+                           index, phdr[index].p_vaddr, phdr[index].p_memsz);
+                return RT_NULL;
+            }
+        }
+        else
+        {
+            if (phdr[index].p_vaddr < vend_addr)
+            {
+                rt_kprintf("invalid elf: segment should be sorted and not overlapped\n");
+                return RT_NULL;
+            }
+            if (phdr[index].p_vaddr > vend_addr + 16)
+            {
+                /* There should not be too much padding in the object files. */
+                LOG_W("warning: too much padding before segment %d", index);
+            }
+
+            vend_addr = phdr[index].p_vaddr + phdr[index].p_memsz;
+            if (vend_addr < phdr[index].p_vaddr)
+            {
+                rt_kprintf("invalid elf: "
+                           "segment %d address overflow\n", index);
+                return RT_NULL;
+            }
+        }
+    }
+
+    module_size = vend_addr - vstart_addr;
+    LOG_D("module size: %d, vstart_addr: 0x%p", module_size, vstart_addr);
+    if (module_size == 0)
+    {
+        rt_kprintf("Module: size error\n");
+        return -RT_ERROR;
+    }
+
+    module->vstart_addr = vstart_addr;
+    module->nref = 0;
+
+    /* allocate module space */
+    module->mem_space = rt_malloc(module_size);
+    if (module->mem_space == RT_NULL)
+    {
+        rt_kprintf("Module: allocate space failed.\n");
+        return -RT_ERROR;
+    }
+    module->mem_size = module_size;
+
+    /* zero all space */
+    rt_memset(module->mem_space, 0, module_size);
+    for (index = 0; index < elf_module->e_phnum; index++)
+    {
+        if (phdr[index].p_type == PT_LOAD)
+        {
+            rt_memcpy(module->mem_space + phdr[index].p_vaddr - vstart_addr,
+                      (rt_uint8_t *)elf_module + phdr[index].p_offset,
+                      phdr[index].p_filesz);
+        }
+    }
+
+    /* set module entry */
+    module->entry_addr = module->mem_space + elf_module->e_entry - vstart_addr;
+
+    /* handle relocation section */
+    for (index = 0; index < elf_module->e_shnum; index ++)
+    {
+        rt_uint32_t i, nr_reloc;
+        Elf32_Sym *symtab;
+        Elf32_Rel *rel;
+        rt_uint8_t *strtab;
+        static rt_bool_t unsolved = RT_FALSE;
+
+        if (!IS_REL(shdr[index]))
+            continue;
+
+        /* get relocate item */
+        rel = (Elf32_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
+
+        /* locate .rel.plt and .rel.dyn section */
+        symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr +
+                               shdr[shdr[index].sh_link].sh_offset);
+        strtab = (rt_uint8_t *)module_ptr +
+                 shdr[shdr[shdr[index].sh_link].sh_link].sh_offset;
+        nr_reloc = (rt_uint32_t)(shdr[index].sh_size / sizeof(Elf32_Rel));
+
+        /* relocate every items */
+        for (i = 0; i < nr_reloc; i ++)
+        {
+            Elf32_Sym *sym = &symtab[ELF32_R_SYM(rel->r_info)];
+
+            LOG_D("relocate symbol %s shndx %d", strtab + sym->st_name, sym->st_shndx);
+
+            if ((sym->st_shndx != SHT_NULL) ||(ELF_ST_BIND(sym->st_info) == STB_LOCAL))
+            {
+                Elf32_Addr addr;
+
+                addr = (Elf32_Addr)(module->mem_space + sym->st_value - vstart_addr);
+                dlmodule_relocate(module, rel, addr);
+            }
+            else if (!linked)
+            {
+                Elf32_Addr addr;
+
+                LOG_D("relocate symbol: %s", strtab + sym->st_name);
+                /* need to resolve symbol in kernel symbol table */
+                addr = dlmodule_symbol_find((const char *)(strtab + sym->st_name));
+                if (addr == 0)
+                {
+                    LOG_E("Module: can't find %s in kernel symbol table", strtab + sym->st_name);
+                    unsolved = RT_TRUE;
+                }
+                else
+                {
+                    dlmodule_relocate(module, rel, addr);
+                }
+            }
+            rel ++;
+        }
+
+        if (unsolved) 
+            return -RT_ERROR;
+    }
+
+    /* construct module symbol table */
+    for (index = 0; index < elf_module->e_shnum; index ++)
+    {
+        /* find .dynsym section */
+        rt_uint8_t *shstrab;
+        shstrab = (rt_uint8_t *)module_ptr +
+                  shdr[elf_module->e_shstrndx].sh_offset;
+        if (rt_strcmp((const char *)(shstrab + shdr[index].sh_name), ELF_DYNSYM) == 0)
+            break;
+    }
+
+    /* found .dynsym section */
+    if (index != elf_module->e_shnum)
+    {
+        int i, count = 0;
+        Elf32_Sym  *symtab = RT_NULL;
+        rt_uint8_t *strtab = RT_NULL;
+
+        symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
+        strtab = (rt_uint8_t *)module_ptr + shdr[shdr[index].sh_link].sh_offset;
+
+        for (i = 0; i < shdr[index].sh_size / sizeof(Elf32_Sym); i++)
+        {
+            if ((ELF_ST_BIND(symtab[i].st_info) == STB_GLOBAL) &&
+                (ELF_ST_TYPE(symtab[i].st_info) == STT_FUNC))
+                count ++;
+        }
+
+        module->symtab = (struct rt_module_symtab *)rt_malloc
+                         (count * sizeof(struct rt_module_symtab));
+        module->nsym = count;
+        for (i = 0, count = 0; i < shdr[index].sh_size / sizeof(Elf32_Sym); i++)
+        {
+            rt_size_t length;
+
+            if ((ELF_ST_BIND(symtab[i].st_info) != STB_GLOBAL) ||
+                (ELF_ST_TYPE(symtab[i].st_info) != STT_FUNC))
+                continue;
+
+            length = rt_strlen((const char *)(strtab + symtab[i].st_name)) + 1;
+
+            module->symtab[count].addr =
+                (void *)(module->mem_space + symtab[i].st_value - module->vstart_addr);
+            module->symtab[count].name = rt_malloc(length);
+            rt_memset((void *)module->symtab[count].name, 0, length);
+            rt_memcpy((void *)module->symtab[count].name,
+                      strtab + symtab[i].st_name,
+                      length);
+            count ++;
+        }
+    }
+
+    return RT_EOK;
+}
+
+rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module_ptr)
+{
+    rt_uint32_t index, rodata_addr = 0, bss_addr = 0, data_addr = 0;
+    rt_uint32_t module_addr = 0, module_size = 0;
+    rt_uint8_t *ptr, *strtab, *shstrab;
+
+    /* get the ELF image size */
+    for (index = 0; index < elf_module->e_shnum; index ++)
+    {
+        /* text */
+        if (IS_PROG(shdr[index]) && IS_AX(shdr[index]))
+        {
+            module_size += shdr[index].sh_size;
+            module_addr = shdr[index].sh_addr;
+        }
+        /* rodata */
+        if (IS_PROG(shdr[index]) && IS_ALLOC(shdr[index]))
+        {
+            module_size += shdr[index].sh_size;
+        }
+        /* data */
+        if (IS_PROG(shdr[index]) && IS_AW(shdr[index]))
+        {
+            module_size += shdr[index].sh_size;
+        }
+        /* bss */
+        if (IS_NOPROG(shdr[index]) && IS_AW(shdr[index]))
+        {
+            module_size += shdr[index].sh_size;
+        }
+    }
+
+    /* no text, data and bss on image */
+    if (module_size == 0) return RT_NULL;
+
+    module->vstart_addr = 0;
+
+    /* allocate module space */
+    module->mem_space = rt_malloc(module_size);
+    if (module->mem_space == RT_NULL)
+    {
+        rt_kprintf("Module: allocate space failed.\n");
+        return -RT_ERROR;
+    }
+
+    /* zero all space */
+    ptr = module->mem_space;
+    rt_memset(ptr, 0, module_size);
+
+    /* load text and data section */
+    for (index = 0; index < elf_module->e_shnum; index ++)
+    {
+        /* load text section */
+        if (IS_PROG(shdr[index]) && IS_AX(shdr[index]))
+        {
+            rt_memcpy(ptr,
+                      (rt_uint8_t *)elf_module + shdr[index].sh_offset,
+                      shdr[index].sh_size);
+            LOG_D("load text 0x%x, size %d", ptr, shdr[index].sh_size);
+            ptr += shdr[index].sh_size;
+        }
+
+        /* load rodata section */
+        if (IS_PROG(shdr[index]) && IS_ALLOC(shdr[index]))
+        {
+            rt_memcpy(ptr,
+                      (rt_uint8_t *)elf_module + shdr[index].sh_offset,
+                      shdr[index].sh_size);
+            rodata_addr = (rt_uint32_t)ptr;
+            LOG_D("load rodata 0x%x, size %d, rodata 0x%x", ptr, 
+                shdr[index].sh_size, *(rt_uint32_t *)data_addr);
+            ptr += shdr[index].sh_size;
+        }
+
+        /* load data section */
+        if (IS_PROG(shdr[index]) && IS_AW(shdr[index]))
+        {
+            rt_memcpy(ptr,
+                      (rt_uint8_t *)elf_module + shdr[index].sh_offset,
+                      shdr[index].sh_size);
+            data_addr = (rt_uint32_t)ptr;
+            LOG_D("load data 0x%x, size %d, data 0x%x", ptr, 
+                shdr[index].sh_size, *(rt_uint32_t *)data_addr);
+            ptr += shdr[index].sh_size;
+        }
+
+        /* load bss section */
+        if (IS_NOPROG(shdr[index]) && IS_AW(shdr[index]))
+        {
+            rt_memset(ptr, 0, shdr[index].sh_size);
+            bss_addr = (rt_uint32_t)ptr;
+            LOG_D("load bss 0x%x, size %d", ptr, shdr[index].sh_size);
+        }
+    }
+
+    /* set module entry */
+    module->entry_addr = (rt_dlmodule_entry_func_t)((rt_uint8_t *)module->mem_space + elf_module->e_entry - module_addr);
+
+    /* handle relocation section */
+    for (index = 0; index < elf_module->e_shnum; index ++)
+    {
+        rt_uint32_t i, nr_reloc;
+        Elf32_Sym *symtab;
+        Elf32_Rel *rel;
+
+        if (!IS_REL(shdr[index]))
+            continue;
+
+        /* get relocate item */
+        rel = (Elf32_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
+
+        /* locate .dynsym and .dynstr */
+        symtab   = (Elf32_Sym *)((rt_uint8_t *)module_ptr +
+                                 shdr[shdr[index].sh_link].sh_offset);
+        strtab   = (rt_uint8_t *)module_ptr +
+                   shdr[shdr[shdr[index].sh_link].sh_link].sh_offset;
+        shstrab  = (rt_uint8_t *)module_ptr +
+                   shdr[elf_module->e_shstrndx].sh_offset;
+        nr_reloc = (rt_uint32_t)(shdr[index].sh_size / sizeof(Elf32_Rel));
+
+        /* relocate every items */
+        for (i = 0; i < nr_reloc; i ++)
+        {
+            Elf32_Sym *sym = &symtab[ELF32_R_SYM(rel->r_info)];
+
+            LOG_D("relocate symbol: %s", strtab + sym->st_name);
+
+            if (sym->st_shndx != STN_UNDEF)
+            {
+                Elf32_Addr addr = 0;
+                
+                if ((ELF_ST_TYPE(sym->st_info) == STT_SECTION) ||
+                    (ELF_ST_TYPE(sym->st_info) == STT_OBJECT))
+                {
+                    if (rt_strncmp((const char *)(shstrab +
+                                                  shdr[sym->st_shndx].sh_name), ELF_RODATA, 8) == 0)
+                    {
+                        /* relocate rodata section */
+                        LOG_D("rodata");
+                        addr = (Elf32_Addr)(rodata_addr + sym->st_value);
+                    }
+                    else if (rt_strncmp((const char *)
+                                        (shstrab + shdr[sym->st_shndx].sh_name), ELF_BSS, 5) == 0)
+                    {
+                        /* relocate bss section */
+                        LOG_D("bss");
+                        addr = (Elf32_Addr)bss_addr + sym->st_value;
+                    }
+                    else if (rt_strncmp((const char *)(shstrab + shdr[sym->st_shndx].sh_name),
+                                        ELF_DATA, 6) == 0)
+                    {
+                        /* relocate data section */
+                        LOG_D("data");
+                        addr = (Elf32_Addr)data_addr + sym->st_value;
+                    }
+
+                    if (addr != 0) dlmodule_relocate(module, rel, addr);
+                }
+                else if (ELF_ST_TYPE(sym->st_info) == STT_FUNC)
+                {
+                    addr = (Elf32_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value);
+
+                    /* relocate function */
+                    dlmodule_relocate(module, rel, addr);
+                }
+            }
+            else if (ELF_ST_TYPE(sym->st_info) == STT_FUNC)
+            {
+                /* relocate function */
+                dlmodule_relocate(module, rel,
+                                       (Elf32_Addr)((rt_uint8_t *)
+                                                    module->mem_space
+                                                    - module_addr
+                                                    + sym->st_value));
+            }
+            else
+            {
+                Elf32_Addr addr;
+
+                if (ELF32_R_TYPE(rel->r_info) != R_ARM_V4BX)
+                {
+                    LOG_D("relocate symbol: %s", strtab + sym->st_name);
+
+                    /* need to resolve symbol in kernel symbol table */
+                    addr = dlmodule_symbol_find((const char *)(strtab + sym->st_name));
+                    if (addr != (Elf32_Addr)RT_NULL)
+                    {
+                        dlmodule_relocate(module, rel, addr);
+                        LOG_D("symbol addr 0x%x", addr);
+                    }
+                    else
+                        LOG_E("Module: can't find %s in kernel symbol table",
+                                   strtab + sym->st_name);
+                }
+                else
+                {
+                    addr = (Elf32_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value);
+                    dlmodule_relocate(module, rel, addr);
+                }
+            }
+
+            rel ++;
+        }
+    }
+
+    return RT_EOK;
+}

src/module.h → components/libc/libdl/dlelf.h

 /*
- * File      : module.h
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Copyright (c) 2006-2018, RT-Thread Development Team
  *
+ * SPDX-License-Identifier: Apache-2.0
+ * 
  * Change Logs:
- * Date           Author       Notes
- * 2010-01-09     Bernard      first version
- * 2010-04-09     yi.qiu       implement based on first version
+ * Date           Author      Notes
+ * 2018/08/29     Bernard     first version
  */
 
-#ifndef __MODULE_H__
-#define __MODULE_H__
-
-#include <rtdef.h>
+#ifndef DL_ELF_H__
+#define DL_ELF_H__
 
 typedef rt_uint8_t              Elf_Byte;
 
@@ -209,11 +192,19 @@ typedef struct
 #define R_ARM_V4BX              40
 
 /*
- * Relocation type for arm
+ * Relocation type for x86
  */
+#define R_386_NONE              0
+#define R_386_32                1
+#define R_386_PC32              2
+#define R_386_GOT32             3
+#define R_386_PLT32             4
+#define R_386_COPY              5
 #define R_386_GLOB_DAT          6
-#define R_386_JUMP_SLOT         7
+#define R_386_JMP_SLOT          7
 #define R_386_RELATIVE          8
+#define R_386_GOTOFF            9
+#define R_386_GOTPC             10
 
 /* Program Header */
 typedef struct
@@ -274,4 +265,21 @@ typedef struct
 #define SHF_MASKPROC            0xf0000000     /* reserved bits for processor */
 /* specific section attributes */
 
+#define IS_PROG(s)        (s.sh_type == SHT_PROGBITS)
+#define IS_NOPROG(s)      (s.sh_type == SHT_NOBITS)
+#define IS_REL(s)         (s.sh_type == SHT_REL)
+#define IS_RELA(s)        (s.sh_type == SHT_RELA)
+#define IS_ALLOC(s)       (s.sh_flags == SHF_ALLOC)
+#define IS_AX(s)          ((s.sh_flags & SHF_ALLOC) && (s.sh_flags & SHF_EXECINSTR))
+#define IS_AW(s)          ((s.sh_flags & SHF_ALLOC) && (s.sh_flags & SHF_WRITE))
+
+#define elf_module        ((Elf32_Ehdr *)module_ptr)
+#define shdr              ((Elf32_Shdr *)((rt_uint8_t *)module_ptr + elf_module->e_shoff))
+#define phdr              ((Elf32_Phdr *)((rt_uint8_t *)module_ptr + elf_module->e_phoff))
+
+rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_ptr);
+rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module_ptr);
+
+int dlmodule_relocate(struct rt_dlmodule *module, Elf32_Rel *rel, Elf32_Addr sym_val);
+
 #endif

components/libc/libdl/dlerror.c

 /*
- * File      : dlerror.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 2010, RT-Thread Development Team
- *
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * Copyright (c) 2006-2018, RT-Thread Development Team
  *
+ * SPDX-License-Identifier: Apache-2.0
+ * 
  * Change Logs:
- * Date           Author		Notes
- * 2010-11-17      yi.qiu	first version
+ * Date           Author      Notes
+ * 2010-11-17     yi.qiu      first version
  */
 
 #include <rtthread.h>
@@ -19,6 +15,4 @@ const char *dlerror(void)
 {
 	return "TODO";
 }
-
 RTM_EXPORT(dlerror)
-

components/libc/libdl/dlfcn.h

+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * 
+ * Change Logs:
+ * Date           Author      Notes
+ * 2010-11-17     yi.qiu      first version
+ */
+
 #ifndef __DLFCN_H_
 #define __DLFCN_H_
 
@@ -16,4 +26,3 @@ void *dlsym(void *handle, const char *symbol);
 int dlclose (void *handle);
 
 #endif
-

components/libc/libdl/dlmodule.c

+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author      Notes
+ * 2018/08/29     Bernard     first version
+ */
+
+#include <rthw.h>
+
+#include "dlfcn.h"
+#include "dlmodule.h"
+#include "dlelf.h"
+
+#include <dfs_posix.h>
+
+#define DBG_SECTION_NAME    "DLMD"
+#define DBG_ENABLE          // enable debug macro
+#define DBG_LEVEL           DBG_INFO
+#define DBG_COLOR
+#include <rtdbg.h>          // must after of DEBUG_ENABLE or some other options
+
+static struct rt_module_symtab *_rt_module_symtab_begin = RT_NULL;
+static struct rt_module_symtab *_rt_module_symtab_end   = RT_NULL;
+
+#if defined(__IAR_SYSTEMS_ICC__) /* for IAR compiler */
+    #pragma section="RTMSymTab"
+#endif
+
+/* set the name of module */
+static void _dlmodule_set_name(struct rt_dlmodule *module, const char *path)
+{
+    int size;
+    struct rt_object *object;
+    const char *first, *end, *ptr;
+
+    object = &(module->parent);
+    ptr   = first = (char *)path;
+    end   = path + rt_strlen(path);
+
+    while (*ptr != '\0')
+    {
+        if (*ptr == '/')
+            first = ptr + 1;
+        if (*ptr == '.')
+            end = ptr - 1;
+
+        ptr ++;
+    }
+
+    size = end - first + 1;
+    if (size > RT_NAME_MAX) size = RT_NAME_MAX;
+
+    rt_strncpy(object->name, first, size);
+    object->name[size] = '\0';
+}
+
+#define RT_MODULE_ARG_MAX    8
+static int _rt_module_split_arg(char *cmd, rt_size_t length, char *argv[])
+{
+    int argc = 0;
+    char *ptr = cmd;
+
+    while ((ptr - cmd) < length)
+    {
+        /* strip bank and tab */
+        while ((*ptr == ' ' || *ptr == '\t') && (ptr - cmd) < length)
+            *ptr++ = '\0';
+        /* check whether it's the end of line */
+        if ((ptr - cmd) >= length) break;
+
+        /* handle string with quote */
+        if (*ptr == '"')
+        {
+            argv[argc++] = ++ptr;
+
+            /* skip this string */
+            while (*ptr != '"' && (ptr - cmd) < length)
+                if (*ptr ++ == '\\')  ptr ++;
+            if ((ptr - cmd) >= length) break;
+
+            /* skip '"' */
+            *ptr ++ = '\0';
+        }
+        else
+        {
+            argv[argc++] = ptr;
+            while ((*ptr != ' ' && *ptr != '\t') && (ptr - cmd) < length)
+                ptr ++;
+        }
+
+        if (argc >= RT_MODULE_ARG_MAX) break;
+    }
+
+    return argc;
+}
+
+/* invoked by main thread for exit */
+static void _dlmodule_exit(void)
+{
+    struct rt_dlmodule *module;
+
+    module = dlmodule_self();
+    if (!module) return; /* not a module thread */
+
+    rt_enter_critical();
+    if (module->stat == RT_DLMODULE_STAT_RUNNING)
+    {
+        struct rt_object    *object = RT_NULL;
+        struct rt_list_node *node = RT_NULL;
+
+        /* set stat to closing */
+        module->stat = RT_DLMODULE_STAT_CLOSING;
+
+        /* suspend all threads in this module */
+        for (node = module->object_list.next; node != &(module->object_list); node = node->next)
+        {
+            object = rt_list_entry(node, struct rt_object, list);
+
+            if ((object->type & ~RT_Object_Class_Static) == RT_Object_Class_Thread)
+            {
+                rt_thread_t thread = (rt_thread_t)object;
+
+                /* stop timer and suspend thread*/
+                if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_CLOSE ||
+                    (thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_INIT)
+                {
+                    rt_timer_stop(&(thread->thread_timer));
+                    rt_thread_suspend(thread);
+                }
+            }
+        }
+    }
+    rt_exit_critical();
+
+    return;
+}
+
+static void _dlmodule_thread_entry(void* parameter)
+{
+    int argc = 0;
+    char *argv[RT_MODULE_ARG_MAX];
+
+    struct rt_dlmodule *module = (struct rt_dlmodule*)parameter;
+
+    if (module == RT_NULL || module->cmd_line == RT_NULL)
+        /* malloc for module_cmd_line failed. */
+        return;
+
+    if (module->cmd_line)
+    {
+        rt_memset(argv, 0x00, sizeof(argv));
+        argc = _rt_module_split_arg((char *)module->cmd_line, rt_strlen(module->cmd_line), argv);
+        if (argc == 0) goto __exit;
+    }
+
+    /* set status of module */
+    module->stat = RT_DLMODULE_STAT_RUNNING;
+
+    LOG_D("run main entry: 0x%p with %s",
+        module->entry_addr,
+        module->cmd_line);
+
+    if (module->entry_addr)
+        module->entry_addr(argc, argv);
+
+__exit:
+    _dlmodule_exit();
+
+    return ;
+}
+
+struct rt_dlmodule *dlmodule_create(void)
+{
+    struct rt_dlmodule *ret = RT_NULL;
+
+    ret = (struct rt_dlmodule*) rt_object_allocate(RT_Object_Class_Module, "module");
+    if (ret)
+    {
+        ret->stat = RT_DLMODULE_STAT_INIT;
+        rt_list_init(&(ret->object_list));
+    }
+
+    return ret;
+}
+
+void dlmodule_destroy_subthread(struct rt_dlmodule *module, rt_thread_t thread)
+{
+    RT_ASSERT(thread->module_id == module);
+
+    /* lock scheduler to prevent scheduling in cleanup function. */
+    rt_enter_critical();
+
+    /* remove thread from thread_list (ready or defunct thread list) */
+    rt_list_remove(&(thread->tlist));
+
+    if ((thread->stat & RT_THREAD_STAT_MASK) != RT_THREAD_CLOSE &&
+        (thread->thread_timer.parent.type == (RT_Object_Class_Static | RT_Object_Class_Timer)))
+    {
+        /* release thread timer */
+        rt_timer_detach(&(thread->thread_timer));
+    }
+
+    /* change stat */
+    thread->stat = RT_THREAD_CLOSE;
+
+    /* invoke thread cleanup */
+    if (thread->cleanup != RT_NULL)
+        thread->cleanup(thread);
+
+    rt_exit_critical();
+
+#ifdef RT_USING_SIGNALS
+    rt_thread_free_sig(thread);
+#endif
+
+    if (thread->type & RT_Object_Class_Static)
+    {
+        /* detach object */
+        rt_object_detach((rt_object_t)thread);
+    }
+#ifdef RT_USING_HEAP
+    else
+    {
+        /* release thread's stack */
+        RT_KERNEL_FREE(thread->stack_addr);
+        /* delete thread object */
+        rt_object_delete((rt_object_t)thread);
+    }
+#endif
+}
+
+rt_err_t dlmodule_destroy(struct rt_dlmodule* module)
+{
+    int i;
+
+    RT_DEBUG_NOT_IN_INTERRUPT;
+
+    /* check parameter */
+    if (module == RT_NULL)
+        return -RT_ERROR;
+
+    /* can not destroy a running module */
+    if (module->stat == RT_DLMODULE_STAT_RUNNING)
+        return -RT_EBUSY;
+
+    /* do module cleanup */
+    if (module->cleanup_func)
+    {
+        rt_enter_critical();
+        module->cleanup_func(module);
+        rt_exit_critical();
+    }
+
+    // list_object(&(module->object_list));
+
+    /* cleanup for all kernel objects inside module*/
+    {
+        struct rt_object *object = RT_NULL;
+        struct rt_list_node *node = RT_NULL;
+
+        /* detach/delete all threads in this module */
+        for (node = module->object_list.next; node != &(module->object_list); )
+        {
+            int object_type;
+
+            object = rt_list_entry(node, struct rt_object, list);
+            object_type = object->type & ~RT_Object_Class_Static;
+
+            /* to next node */
+            node = node->next;
+
+            if (object->type & RT_Object_Class_Static)
+            {
+                switch (object_type)
+                {
+                case RT_Object_Class_Thread:
+                    dlmodule_destroy_subthread(module, (rt_thread_t)object);
+                    break;
+#ifdef RT_USING_SEMAPHORE
+                case RT_Object_Class_Semaphore:
+                    rt_sem_detach((rt_sem_t)object);
+                    break;
+#endif
+#ifdef RT_USING_MUTEX
+                case RT_Object_Class_Mutex:
+                    rt_mutex_detach((rt_mutex_t)object);
+                    break;
+#endif
+#ifdef RT_USING_EVENT
+                case RT_Object_Class_Event:
+                    rt_event_detach((rt_event_t)object);
+                    break;
+#endif
+#ifdef RT_USING_MAILBOX
+                case RT_Object_Class_MailBox:
+                    rt_mb_detach((rt_mailbox_t)object);
+                    break;
+#endif
+#ifdef RT_USING_MESSAGEQUEUE
+                case RT_Object_Class_MessageQueue:
+                    rt_mq_detach((rt_mq_t)object);
+                    break;
+#endif
+#ifdef RT_USING_MEMHEAP
+                case RT_Object_Class_MemHeap:
+                    rt_memheap_detach((struct rt_memheap*)object);
+                    break;
+#endif
+#ifdef RT_USING_MEMPOOL
+                case RT_Object_Class_MemPool:
+                    rt_mp_detach((struct rt_mempool*)object);
+                    break;
+#endif
+                case RT_Object_Class_Timer:
+                    rt_timer_detach((rt_timer_t)object);
+                    break;
+                default:
+                    LOG_E("Unsupported oject type in module.");
+                    break;
+                }
+            }
+            else
+            {
+                switch (object_type)
+                {
+                case RT_Object_Class_Thread:
+                    dlmodule_destroy_subthread(module, (rt_thread_t)object);
+                    break;
+#ifdef RT_USING_SEMAPHORE
+                case RT_Object_Class_Semaphore:
+                    rt_sem_delete((rt_sem_t)object);
+                    break;
+#endif
+#ifdef RT_USING_MUTEX
+                case RT_Object_Class_Mutex:
+                    rt_mutex_delete((rt_mutex_t)object);
+                    break;
+#endif
+#ifdef RT_USING_EVENT
+                case RT_Object_Class_Event:
+                    rt_event_delete((rt_event_t)object);
+                    break;
+#endif
+#ifdef RT_USING_MAILBOX
+                case RT_Object_Class_MailBox:
+                    rt_mb_delete((rt_mailbox_t)object);
+                    break;
+#endif
+#ifdef RT_USING_MESSAGEQUEUE
+                case RT_Object_Class_MessageQueue:
+                    rt_mq_delete((rt_mq_t)object);
+                    break;
+#endif
+#ifdef RT_USING_MEMHEAP
+                /* no delete operation */
+#endif
+#ifdef RT_USING_MEMPOOL
+                case RT_Object_Class_MemPool:
+                    rt_mp_delete((struct rt_mempool*)object);
+                    break;
+#endif
+                case RT_Object_Class_Timer:
+                    rt_timer_delete((rt_timer_t)object);
+                    break;
+                default:
+                    LOG_E("Unsupported oject type in module.");
+                    break;
+                }
+            }
+        }
+    }
+
+    if (module->cmd_line) rt_free(module->cmd_line);
+    /* release module symbol table */
+    for (i = 0; i < module->nsym; i ++)
+    {
+        rt_free((void *)module->symtab[i].name);
+    }
+    if (module->symtab != RT_NULL)
+    {
+        rt_free(module->symtab);
+    }
+
+    /* destory module */
+    rt_free(module->mem_space);
+    /* delete module object */
+    rt_object_delete((rt_object_t)module);
+
+    return RT_EOK;
+}
+
+struct rt_dlmodule *dlmodule_self(void)
+{
+    rt_thread_t tid;
+    struct rt_dlmodule *ret = RT_NULL;
+
+    tid = rt_thread_self();
+    if (tid)
+    {
+        ret = (struct rt_dlmodule*) tid->module_id;
+    }
+
+    return ret;
+}
+
+/*
+ * Compatible with old API
+ */
+struct rt_dlmodule *rt_module_self(void)
+{
+    return dlmodule_self();
+}
+
+struct rt_dlmodule* dlmodule_load(const char* filename)
+{
+    int fd, length = 0;
+    rt_err_t ret = RT_EOK;
+    rt_uint8_t *module_ptr = RT_NULL;
+    struct rt_dlmodule *module = RT_NULL;
+
+    fd = open(filename, O_RDONLY, 0);
+    if (fd >= 0)
+    {
+        length = lseek(fd, 0, SEEK_END);
+        lseek(fd, 0, SEEK_SET);
+
+        if (length == 0) goto __exit;
+
+        module_ptr = (uint8_t*) rt_malloc (length);
+        if (!module_ptr) goto __exit;
+
+        if (read(fd, module_ptr, length) != length)
+            goto __exit;
+
+        /* close file and release fd */
+        close(fd);
+        fd = -1;
+    }
+
+    /* check ELF header */
+    if (rt_memcmp(elf_module->e_ident, RTMMAG, SELFMAG) != 0 &&
+        rt_memcmp(elf_module->e_ident, ELFMAG, SELFMAG) != 0)
+    {
+        rt_kprintf("Module: magic error\n");
+        goto __exit;
+    }
+
+    /* check ELF class */
+    if (elf_module->e_ident[EI_CLASS] != ELFCLASS32)
+    {
+        rt_kprintf("Module: ELF class error\n");
+        goto __exit;
+    }
+
+    module = dlmodule_create();
+    if (!module) goto __exit;
+
+    /* set the name of module */
+    _dlmodule_set_name(module, filename);
+
+    LOG_D("rt_module_load: %.*s", RT_NAME_MAX, module->parent.name);
+
+    if (elf_module->e_type == ET_REL)
+    {
+        ret = dlmodule_load_relocated_object(module, module_ptr);
+    }
+    else if (elf_module->e_type == ET_DYN)
+    {
+        ret = dlmodule_load_shared_object(module, module_ptr);
+    }
+    else
+    {
+        rt_kprintf("Module: unsupported elf type\n");
+        goto __exit;
+    }
+
+    /* check return value */
+    if (ret != RT_EOK) goto __exit;
+
+    /* release module data */
+    rt_free(module_ptr);
+
+    /* increase module reference count */
+    module->nref ++;
+
+    /* set module initialization and cleanup function */
+    module->init_func = dlsym(module, "module_init");
+    module->cleanup_func = dlsym(module, "module_cleanup");
+    module->stat = RT_DLMODULE_STAT_INIT;
+    /* do module initialization */
+    if (module->init_func)
+    {
+        module->init_func(module);
+    }
+
+    return module;
+
+__exit:
+    if (fd >= 0) close(fd);
+    if (module_ptr) rt_free(module_ptr);
+    if (module) dlmodule_destroy(module);
+
+    return RT_NULL;
+}
+
+struct rt_dlmodule* dlmodule_exec(const char* pgname, const char* cmd, int cmd_size)
+{
+    struct rt_dlmodule *module = RT_NULL;
+
+    module = dlmodule_load(pgname);
+    if (module)
+    {
+        if (module->entry_addr)
+        {
+            /* exec this module */
+            rt_thread_t tid;
+
+            module->cmd_line = rt_strdup(cmd);
+            tid = rt_thread_create(module->parent.name, _dlmodule_thread_entry, (void*)module, 
+                2048, RT_THREAD_PRIORITY_MAX - 1, 10);
+            if (tid)
+            {
+                tid->module_id = module;
+                module->main_thread = tid;
+
+                rt_thread_startup(tid);
+            }
+            else
+            {
+                /* destory dl module */
+                dlmodule_destroy(module);
+                module = RT_NULL;
+            }
+        }
+    }
+
+    return module;
+}
+
+void dlmodule_exit(int ret_code)
+{
+    rt_thread_t thread;
+    struct rt_dlmodule *module;
+
+    module = dlmodule_self();
+    if (!module) return;
+
+    /* disable scheduling */
+    rt_enter_critical();
+
+    /* module is not running */
+    if (module->stat != RT_DLMODULE_STAT_RUNNING) 
+    {
+        /* restore scheduling */
+        rt_exit_critical();
+
+        return;
+    }
+
+    /* set return code */
+    module->ret_code = ret_code;
+
+    /* do exit for this module */
+    _dlmodule_exit();
+    /* the stat of module was changed to CLOSING in _dlmodule_exit */
+
+    thread = module->main_thread;
+    if ((thread->stat & RT_THREAD_STAT_MASK) == RT_THREAD_CLOSE)
+    {
+        /* main thread already closed */
+        rt_exit_critical();
+
+        return ;
+    }
+
+    /* delete thread: insert to defunct thread list */
+    rt_thread_delete(thread);
+    /* enable scheduling */
+    rt_exit_critical();
+}
+
+rt_uint32_t dlmodule_symbol_find(const char *sym_str)
+{
+    /* find in kernel symbol table */
+    struct rt_module_symtab *index;
+
+    for (index = _rt_module_symtab_begin; index != _rt_module_symtab_end; index ++)
+    {
+        if (rt_strcmp(index->name, sym_str) == 0)
+            return (rt_uint32_t)index->addr;
+    }
+
+    return 0;
+}
+
+int rt_system_dlmodule_init(void)
+{
+#if defined(__GNUC__) && !defined(__CC_ARM)
+    extern int __rtmsymtab_start;
+    extern int __rtmsymtab_end;
+
+    _rt_module_symtab_begin = (struct rt_module_symtab *)&__rtmsymtab_start;
+    _rt_module_symtab_end   = (struct rt_module_symtab *)&__rtmsymtab_end;
+#elif defined (__CC_ARM)
+    extern int RTMSymTab$$Base;
+    extern int RTMSymTab$$Limit;
+
+    _rt_module_symtab_begin = (struct rt_module_symtab *)&RTMSymTab$$Base;
+    _rt_module_symtab_end   = (struct rt_module_symtab *)&RTMSymTab$$Limit;
+#elif defined (__IAR_SYSTEMS_ICC__)
+    _rt_module_symtab_begin = __section_begin("RTMSymTab");
+    _rt_module_symtab_end   = __section_end("RTMSymTab");
+#endif
+
+    return 0;
+}
+INIT_COMPONENT_EXPORT(rt_system_dlmodule_init);
+
+/**
+ * This function will find the specified module.
+ *
+ * @param name the name of module finding
+ *
+ * @return the module
+ */
+struct rt_dlmodule *dlmodule_find(const char *name)
+{
+    rt_object_t object;
+    struct rt_dlmodule *ret = RT_NULL;
+
+    object = rt_object_find(name, RT_Object_Class_Module);
+    if (object)
+    {
+        ret = (struct rt_dlmodule*) object;
+    }
+
+    return ret;
+}
+RTM_EXPORT(dlmodule_find);
+
+int list_symbols(void)
+{
+    extern int __rtmsymtab_start;
+    extern int __rtmsymtab_end;
+
+    /* find in kernel symbol table */
+    struct rt_module_symtab *index;
+
+    for (index = _rt_module_symtab_begin;
+         index != _rt_module_symtab_end;
+         index ++)
+    {
+        rt_kprintf("%s => 0x%08x\n", index->name, index->addr);
+    }
+
+    return 0;
+}
+MSH_CMD_EXPORT(list_symbols, list symbols information);
+
+int list_module(void)
+{
+    struct rt_dlmodule *module;
+    struct rt_list_node *list, *node;
+    struct rt_object_information *info;
+
+    info = rt_object_get_information(RT_Object_Class_Module);
+    list = &info->object_list;
+
+    rt_kprintf("module   ref      address \n");
+    rt_kprintf("-------- -------- ------------\n");
+    for (node = list->next; node != list; node = node->next)
+    {
+        module = (struct rt_dlmodule *)(rt_list_entry(node, struct rt_object, list));
+        rt_kprintf("%-*.*s %-04d  0x%08x\n",
+                   RT_NAME_MAX, RT_NAME_MAX, module->parent.name, module->nref, module->mem_space);
+    }
+
+    return 0;
+}
+MSH_CMD_EXPORT(list_module, list modules in system);

components/libc/libdl/dlmodule.h

+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018/08/11     Bernard      the first version
+ */
+
+#ifndef RT_DL_MODULE_H__
+#define RT_DL_MODULE_H__
+
+#include <rtthread.h>
+
+#define RT_DLMODULE_STAT_INIT       0x00
+#define RT_DLMODULE_STAT_RUNNING    0x01
+#define RT_DLMODULE_STAT_CLOSING    0x02
+#define RT_DLMODULE_STAT_CLOSED     0x03
+
+struct rt_dlmodule;
+typedef void* rt_addr_t;
+
+typedef void (*rt_dlmodule_init_func_t)(struct rt_dlmodule *module);
+typedef void (*rt_dlmodule_cleanup_func_t)(struct rt_dlmodule *module);
+typedef int  (*rt_dlmodule_entry_func_t)(int argc, char** argv);
+
+struct rt_dlmodule
+{
+    struct rt_object parent;
+    rt_list_t object_list;  /* objects inside this module */
+
+    rt_uint8_t stat;        /* status of module */
+
+    /* main thread of this module */
+    struct rt_thread *main_thread;
+    int ret_code;           /* the return code */
+
+    /* VMA base address for the first LOAD segment */
+    rt_uint32_t vstart_addr;
+
+    /* module entry, RT_NULL for dynamic library */
+    rt_dlmodule_entry_func_t  entry_addr;
+    char *cmd_line;         /* command line */
+
+    rt_addr_t   mem_space;  /* memory space */
+    rt_uint32_t mem_size;   /* sizeof memory space */
+
+    /* init and clean function */
+    rt_dlmodule_init_func_t     init_func;
+    rt_dlmodule_cleanup_func_t  cleanup_func;
+
+    rt_uint16_t nref;       /* reference count */
+
+    rt_uint16_t nsym;       /* number of symbols in the module */
+    struct rt_module_symtab *symtab;    /* module symbol table */
+};
+
+struct rt_dlmodule *dlmodule_create(void);
+rt_err_t dlmodule_destroy(struct rt_dlmodule* module);
+
+struct rt_dlmodule *dlmodule_self(void);
+
+struct rt_dlmodule *dlmodule_load(const char* pgname);
+struct rt_dlmodule *dlmodule_exec(const char* pgname, const char* cmd, int cmd_size);
+void dlmodule_exit(int ret_code);
+
+struct rt_dlmodule *dlmodule_find(const char *name);
+
+rt_uint32_t dlmodule_symbol_find(const char *sym_str);
+
+#endif

components/libc/libdl/dlopen.c

 /*
- * File      : dlopen.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 2010, RT-Thread Development Team
+ * Copyright (c) 2006-2018, RT-Thread Development Team
  *
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * SPDX-License-Identifier: Apache-2.0
  *
  * Change Logs:
  * Date           Author        Notes
@@ -16,11 +12,13 @@
 #include <rtm.h>
 #include <string.h>
 
+#include "dlmodule.h"
+
 #define MODULE_ROOT_DIR     "/modules"
 
 void* dlopen(const char *filename, int flags)
 {
-    rt_module_t module;
+    struct rt_dlmodule *module;
     char *fullpath;
     const char*def_path = MODULE_ROOT_DIR;
 
@@ -40,11 +38,21 @@ void* dlopen(const char *filename, int flags)
         fullpath = (char*)filename; /* absolute path, use it directly */
     }
 
+    rt_enter_critical();
+
     /* find in module list */
-    module = rt_module_find(fullpath);
+    module = dlmodule_find(fullpath);
 
-    if(module != RT_NULL) module->nref++;
-    else module = rt_module_open(fullpath);
+    if(module != RT_NULL) 
+    {
+        rt_exit_critical();
+        module->nref++;
+    }
+    else 
+    {
+        rt_exit_critical();
+        module = dlmodule_load(fullpath);
+    }
 
     if(fullpath != filename)
     {
@@ -54,4 +62,3 @@ void* dlopen(const char *filename, int flags)
     return (void*)module;
 }
 RTM_EXPORT(dlopen);
-

components/libc/libdl/dlsym.c

 /*
- * File      : dlsym.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006 - 2010, RT-Thread Development Team
+ * Copyright (c) 2006-2018, RT-Thread Development Team
  *
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * SPDX-License-Identifier: Apache-2.0
  *
  * Change Logs:
- * Date           Author		Notes
- * 2010-11-17      yi.qiu	first version
+ * Date           Author      Notes
+ * 2010-11-17     yi.qiu      first version
  */
 
 #include <rtthread.h>
 #include <rtm.h>
 
+#include "dlmodule.h"
+
 void* dlsym(void *handle, const char* symbol)
 {
-	int i;
-	rt_module_t module;
-	
-	RT_ASSERT(handle != RT_NULL);
+    int i;
+    struct rt_dlmodule *module;
+    
+    RT_ASSERT(handle != RT_NULL);
 
-	module = (rt_module_t)handle;
+    module = (struct rt_dlmodule *)handle;
 
-	for(i=0; i<module->nsym; i++)
-	{
-		if (rt_strcmp(module->symtab[i].name, symbol) == 0)
-			return (void*)module->symtab[i].addr;
-	}	
+    for(i=0; i<module->nsym; i++)
+    {
+        if (rt_strcmp(module->symtab[i].name, symbol) == 0)
+            return (void*)module->symtab[i].addr;
+    }
 
-	return RT_NULL;
+    return RT_NULL;
 }
-
 RTM_EXPORT(dlsym)
-

include/rtdef.h

@@ -1021,59 +1021,6 @@ struct rt_device_graphic_ops
 /*@}*/
 #endif
 
-#ifdef RT_USING_MODULE
-/**
- * @addtogroup Module
- */
-
-/*@{*/
-
-/*
- * module system
- */
-
-#define RT_MODULE_FLAG_WITHENTRY        0x00            /**< with entry point */
-#define RT_MODULE_FLAG_WITHOUTENTRY     0x01            /**< without entry point */
-
-/**
- * Application Module structure
- */
-struct rt_module
-{
-    struct rt_object             parent;                /**< inherit from object */
-
-    rt_uint32_t                  vstart_addr;           /**< VMA base address for the
-                                                          first LOAD segment. */
-    rt_uint8_t                  *module_space;          /**< module memory space */
-
-    void                        *module_entry;          /**< the entry address of module */
-    rt_thread_t                  module_thread;         /**< the main thread of module */
-
-    rt_uint8_t                  *module_cmd_line;       /**< module command line */
-    rt_uint32_t                  module_cmd_size;       /**< the size of module command line */
-
-#ifdef RT_USING_SLAB
-    /* module memory allocator */
-    void                        *mem_list;              /**< module's free memory list */
-    void                        *page_array;            /**< module's using pages */
-    rt_uint32_t                  page_cnt;              /**< module's using pages count */
-#endif
-
-    rt_uint16_t                  nref;                  /**< reference count */
-
-    rt_uint16_t                  nsym;                  /**< number of symbol in the module */
-    struct rt_module_symtab     *symtab;                /**< module symbol table */
-
-    rt_uint32_t                  user_data;             /**< arch data in the module */
-
-    void (*module_init)(void);
-    void (*module_cleanup)(void);
-};
-typedef struct rt_module *rt_module_t;
-
-/*@}*/
-#endif
-
 /* definitions for libc */
 #include "rtlibc.h"
 

include/rtthread.h

@@ -442,44 +442,6 @@ rt_err_t  rt_device_control(rt_device_t dev, int cmd, void *arg);
 /**@}*/
 #endif
 
-#ifdef RT_USING_MODULE
-/**
- * @addtogroup Module
- */
-
-/**@{*/
-
-/*
- * module interface
- */
-rt_module_t rt_module_load(const char *name, void *module_ptr);
-rt_err_t rt_module_unload(rt_module_t module);
-#ifdef RT_USING_DFS
-rt_module_t rt_module_open(const char *filename);
-rt_module_t rt_module_exec_cmd(const char *path, const char *cmd_line, int size);
-#endif
-void *rt_module_malloc(rt_size_t size);
-void *rt_module_realloc(void *ptr, rt_size_t size);
-void rt_module_free(rt_module_t module, void *addr);
-rt_module_t rt_module_self(void);
-rt_module_t rt_module_find(const char *name);
-
-#ifdef RT_USING_HOOK
-void rt_module_load_sethook(void (*hook)(rt_module_t module));
-void rt_module_unload_sethook(void (*hook)(rt_module_t module));
-#endif
-
-void rt_module_init_object_container(struct rt_module *module);
-rt_err_t rt_module_destroy(rt_module_t module);
-
-/*
- * application module system initialization
- */
-int rt_system_module_init(void);
-
-/**@}*/
-#endif
-
 /*
  * interrupt service
  */

src/Kconfig

@@ -295,8 +295,4 @@ menu "Kernel Device Object"
 
 endmenu
 
-config RT_USING_MODULE
-    bool "The dynamic module feature"
-    default n
-
 endmenu

src/idle.c

@@ -32,6 +32,10 @@
 #include <rthw.h>
 #include <rtthread.h>
 
+#ifdef RT_USING_MODULE
+#include <dlmodule.h>
+#endif
+
 #if defined (RT_USING_HOOK)
 #ifndef RT_USING_IDLE_HOOK
 #define RT_USING_IDLE_HOOK
@@ -158,7 +162,7 @@ void rt_thread_idle_excute(void)
         rt_base_t lock;
         rt_thread_t thread;
 #ifdef RT_USING_MODULE
-        rt_module_t module = RT_NULL;
+        struct rt_dlmodule *module = RT_NULL;
 #endif
         RT_DEBUG_NOT_IN_INTERRUPT;
 
@@ -173,14 +177,10 @@ void rt_thread_idle_excute(void)
                                    struct rt_thread,
                                    tlist);
 #ifdef RT_USING_MODULE
-            /* get thread's parent module */
-            module = (rt_module_t)thread->module_id;
-
-            /* if the thread is module's main thread */
-            if (module != RT_NULL && module->module_thread == thread)
+            module = (struct rt_dlmodule*)thread->module_id;
+            if (module)
             {
-                /* detach module's main thread */
-                module->module_thread = RT_NULL;
+                dlmodule_destroy(module);
             }
 #endif
             /* remove defunct thread */

src/kservice.c

@@ -36,6 +36,10 @@
 #include <rtthread.h>
 #include <rthw.h>
 
+#ifdef RT_USING_MODULE
+#include <dlmodule.h>
+#endif
+
 /* use precision */
 #define RT_PRINTF_PRECISION
 
@@ -1323,13 +1327,10 @@ void rt_assert_handler(const char *ex_string, const char *func, rt_size_t line)
     if (rt_assert_hook == RT_NULL)
     {
 #ifdef RT_USING_MODULE
-        if (rt_module_self() != RT_NULL)
+        if (dlmodule_self())
         {
-            /* unload assertion module */
-            rt_module_unload(rt_module_self());
-
-            /* re-schedule */
-            rt_schedule();
+            /* close assertion module */
+            dlmodule_exit(-1);
         }
         else
 #endif

src/object.c

@@ -32,6 +32,10 @@
 #include <rtthread.h>
 #include <rthw.h>
 
+#ifdef RT_USING_MODULE
+#include <dlmodule.h>
+#endif
+
 /*
  * define object_info for the number of rt_object_container items.
  */
@@ -111,7 +115,7 @@ static struct rt_object_information rt_object_container[RT_Object_Info_Unknown]
     {RT_Object_Class_Timer, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Timer), sizeof(struct rt_timer)},
 #ifdef RT_USING_MODULE
     /* initialize object container - module */
-    {RT_Object_Class_Module, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Module), sizeof(struct rt_module)},
+    {RT_Object_Class_Module, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Module), sizeof(struct rt_dlmodule)},
 #endif
 };
 
@@ -251,6 +255,9 @@ void rt_object_init(struct rt_object         *object,
 {
     register rt_base_t temp;
     struct rt_object_information *information;
+#ifdef RT_USING_MODULE
+    struct rt_dlmodule *module = dlmodule_self();
+#endif
 
     /* get object information */
     information = rt_object_get_information(type);
@@ -269,8 +276,18 @@ void rt_object_init(struct rt_object         *object,
     /* lock interrupt */
     temp = rt_hw_interrupt_disable();
 
-    /* insert object into information object list */
-    rt_list_insert_after(&(information->object_list), &(object->list));
+#ifdef RT_USING_MODULE
+    if (module)
+    {
+        rt_list_insert_after(&(module->object_list), &(object->list));
+        object->module_id = (void *)module;
+    }
+    else
+#endif
+    {
+        /* insert object into information object list */
+        rt_list_insert_after(&(information->object_list), &(object->list));
+    }
 
     /* unlock interrupt */
     rt_hw_interrupt_enable(temp);
@@ -318,6 +335,9 @@ rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name)
     struct rt_object *object;
     register rt_base_t temp;
     struct rt_object_information *information;
+#ifdef RT_USING_MODULE
+    struct rt_dlmodule *module = dlmodule_self();
+#endif
 
     RT_DEBUG_NOT_IN_INTERRUPT;
 
@@ -332,6 +352,9 @@ rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name)
         return RT_NULL;
     }
 
+    /* clean memory data of object */
+    rt_memset(object, 0x0, information->object_size);
+
     /* initialize object's parameters */
 
     /* set object type */
@@ -340,14 +363,6 @@ rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name)
     /* set object flag */
     object->flag = 0;
 
-#ifdef RT_USING_MODULE
-    if (rt_module_self() != RT_NULL)
-    {
-        object->flag |= RT_OBJECT_FLAG_MODULE;
-    }
-    object->module_id = (void *)rt_module_self();
-#endif
-
     /* copy name */
     rt_strncpy(object->name, name, RT_NAME_MAX);
 
@@ -356,8 +371,18 @@ rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name)
     /* lock interrupt */
     temp = rt_hw_interrupt_disable();
 
-    /* insert object into information object list */
-    rt_list_insert_after(&(information->object_list), &(object->list));
+#ifdef RT_USING_MODULE
+    if (module)
+    {
+        rt_list_insert_after(&(module->object_list), &(object->list));
+        object->module_id = (void *)module;
+    }
+    else
+#endif
+    {
+        /* insert object into information object list */
+        rt_list_insert_after(&(information->object_list), &(object->list));
+    }
 
     /* unlock interrupt */
     rt_hw_interrupt_enable(temp);

src/thread.c

@@ -185,10 +185,6 @@ static rt_err_t _rt_thread_init(struct rt_thread *thread,
                   0,
                   RT_TIMER_FLAG_ONE_SHOT);
 
-#ifdef RT_USING_MODULE
-    thread->module_id = RT_NULL;
-#endif
-
     /* initialize signal */
 #ifdef RT_USING_SIGNALS
     thread->sig_mask    = 0x00;