summaryrefslogtreecommitdiff
path: root/components/libc/libdl
diff options
context:
space:
mode:
authorxuzhuoyi <[email protected]>2018-11-16 20:09:46 +0800
committerxuzhuoyi <[email protected]>2018-11-16 20:09:46 +0800
commit37db67d94a269e1a9893d076ab2bb6b9883cfa8c (patch)
treefaaea1c497b8b50e638f768ed6fcc4ec83e6a90f /components/libc/libdl
parent305307c90c8723dcdb79663f65a8933b5cb1b934 (diff)
parent63a6f6c4d2540b003296594c4b916cc1ba8d0b16 (diff)
Merge remote-tracking branch 'upstream/master'
# Conflicts: # src/thread.c
Diffstat (limited to 'components/libc/libdl')
-rw-r--r--components/libc/libdl/SConscript4
-rw-r--r--components/libc/libdl/arch/arm.c121
-rw-r--r--components/libc/libdl/arch/x86.c50
-rw-r--r--components/libc/libdl/dlclose.c49
-rw-r--r--components/libc/libdl/dlelf.c443
-rw-r--r--components/libc/libdl/dlelf.h285
-rw-r--r--components/libc/libdl/dlerror.c16
-rw-r--r--components/libc/libdl/dlfcn.h11
-rw-r--r--components/libc/libdl/dlmodule.c699
-rw-r--r--components/libc/libdl/dlmodule.h75
-rw-r--r--components/libc/libdl/dlopen.c29
-rw-r--r--components/libc/libdl/dlsym.c38
12 files changed, 1751 insertions, 69 deletions
diff --git a/components/libc/libdl/SConscript b/components/libc/libdl/SConscript
index 493dd4b256..93636e4b7a 100644
--- a/components/libc/libdl/SConscript
+++ b/components/libc/libdl/SConscript
@@ -1,14 +1,14 @@
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')
diff --git a/components/libc/libdl/arch/arm.c b/components/libc/libdl/arch/arm.c
new file mode 100644
index 0000000000..a53c04f0bc
--- /dev/null
+++ b/components/libc/libdl/arch/arm.c
@@ -0,0 +1,121 @@
+/*
+ * 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
diff --git a/components/libc/libdl/arch/x86.c b/components/libc/libdl/arch/x86.c
new file mode 100644
index 0000000000..16f2322fb4
--- /dev/null
+++ b/components/libc/libdl/arch/x86.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2006-2018, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2018/09/15 parai first version
+ */
+
+#include "../dlmodule.h"
+#include "../dlelf.h"
+
+#ifdef __i386__
+
+#define R_X86_64_GLOB_DAT 6 /* Create GOT entry */
+#define R_X86_64_JUMP_SLOT 7 /* Create PLT entry */
+#define R_X86_64_RELATIVE 8 /* Adjust by program base */
+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_X86_64_GLOB_DAT:
+ case R_X86_64_JUMP_SLOT:
+ *where = (Elf32_Addr)sym_val;
+
+ RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_X86_64_JUMP_SLOT: 0x%x -> 0x%x 0x%x\n",
+ (uint32_t)where, *where, sym_val));
+ break;
+ case R_X86_64_RELATIVE:
+ *where = (Elf32_Addr)sym_val + *where;
+ RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_X86_64_RELATIVE: 0x%x -> 0x%x 0x%x\n",
+ (uint32_t)where, *where, sym_val));
+ break;
+ default:
+ RT_DEBUG_LOG(RT_DEBUG_MODULE, ("X86ELF: invalid relocate TYPE %d\n", ELF32_R_TYPE(rel->r_info)));
+ return -1;
+ }
+
+ return 0;
+}
+#endif
diff --git a/components/libc/libdl/dlclose.c b/components/libc/libdl/dlclose.c
index af070891fc..1202e13f2c 100644
--- a/components/libc/libdl/dlclose.c
+++ b/components/libc/libdl/dlclose.c
@@ -1,36 +1,39 @@
/*
- * 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);
- }
+ struct rt_dlmodule *module;
- return RT_TRUE;
-}
+ RT_ASSERT(handle != RT_NULL);
-RTM_EXPORT(dlclose)
+ 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)
diff --git a/components/libc/libdl/dlelf.c b/components/libc/libdl/dlelf.c
new file mode 100644
index 0000000000..6d83424b80
--- /dev/null
+++ b/components/libc/libdl/dlelf.c
@@ -0,0 +1,443 @@
+/*
+ * 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;
+ }
+ module->mem_size = module_size;
+
+ /* 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;
+}
diff --git a/components/libc/libdl/dlelf.h b/components/libc/libdl/dlelf.h
new file mode 100644
index 0000000000..014ebe85c8
--- /dev/null
+++ b/components/libc/libdl/dlelf.h
@@ -0,0 +1,285 @@
+/*
+ * 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
+ */
+
+#ifndef DL_ELF_H__
+#define DL_ELF_H__
+
+typedef rt_uint8_t Elf_Byte;
+
+typedef rt_uint32_t Elf32_Addr; /* Unsigned program address */
+typedef rt_uint32_t Elf32_Off; /* Unsigned file offset */
+typedef rt_int32_t Elf32_Sword; /* Signed large integer */
+typedef rt_uint32_t Elf32_Word; /* Unsigned large integer */
+typedef rt_uint16_t Elf32_Half; /* Unsigned medium integer */
+
+/* e_ident[] magic number */
+#define ELFMAG0 0x7f /* e_ident[EI_MAG0] */
+#define ELFMAG1 'E' /* e_ident[EI_MAG1] */
+#define ELFMAG2 'L' /* e_ident[EI_MAG2] */
+#define ELFMAG3 'F' /* e_ident[EI_MAG3] */
+#define RTMMAG "\177RTM" /* magic */
+#define ELFMAG "\177ELF" /* magic */
+#define SELFMAG 4 /* size of magic */
+
+#define EI_CLASS 4 /* file class */
+#define EI_NIDENT 16 /* Size of e_ident[] */
+
+/* e_ident[] file class */
+#define ELFCLASSNONE 0 /* invalid */
+#define ELFCLASS32 1 /* 32-bit objs */
+#define ELFCLASS64 2 /* 64-bit objs */
+#define ELFCLASSNUM 3 /* number of classes */
+
+/* e_ident[] data encoding */
+#define ELFDATANONE 0 /* invalid */
+#define ELFDATA2LSB 1 /* Little-Endian */
+#define ELFDATA2MSB 2 /* Big-Endian */
+#define ELFDATANUM 3 /* number of data encode defines */
+
+/* e_ident */
+#define IS_ELF(ehdr) ((ehdr).e_ident[EI_MAG0] == ELFMAG0 && \
+ (ehdr).e_ident[EI_MAG1] == ELFMAG1 && \
+ (ehdr).e_ident[EI_MAG2] == ELFMAG2 && \
+ (ehdr).e_ident[EI_MAG3] == ELFMAG3)
+
+#define ET_NONE 0 /* No file type */
+#define ET_REL 1 /* Relocatable file */
+#define ET_EXEC 2 /* Executable file */
+#define ET_DYN 3 /* Shared object file */
+#define ET_CORE 4 /* Core file */
+
+/* ELF Header */
+typedef struct elfhdr
+{
+ unsigned char e_ident[EI_NIDENT]; /* ELF Identification */
+ Elf32_Half e_type; /* object file type */
+ Elf32_Half e_machine; /* machine */
+ Elf32_Word e_version; /* object file version */
+ Elf32_Addr e_entry; /* virtual entry point */
+ Elf32_Off e_phoff; /* program header table offset */
+ Elf32_Off e_shoff; /* section header table offset */
+ Elf32_Word e_flags; /* processor-specific flags */
+ Elf32_Half e_ehsize; /* ELF header size */
+ Elf32_Half e_phentsize; /* program header entry size */
+ Elf32_Half e_phnum; /* number of program header entries */
+ Elf32_Half e_shentsize; /* section header entry size */
+ Elf32_Half e_shnum; /* number of section header entries */
+ Elf32_Half e_shstrndx; /* section header table's "section
+ header string table" entry offset */
+} Elf32_Ehdr;
+
+/* Section Header */
+typedef struct
+{
+ Elf32_Word sh_name; /* name - index into section header
+ string table section */
+ Elf32_Word sh_type; /* type */
+ Elf32_Word sh_flags; /* flags */
+ Elf32_Addr sh_addr; /* address */
+ Elf32_Off sh_offset; /* file offset */
+ Elf32_Word sh_size; /* section size */
+ Elf32_Word sh_link; /* section header table index link */
+ Elf32_Word sh_info; /* extra information */
+ Elf32_Word sh_addralign; /* address alignment */
+ Elf32_Word sh_entsize; /* section entry size */
+} Elf32_Shdr;
+
+/* Section names */
+#define ELF_BSS ".bss" /* uninitialized data */
+#define ELF_DATA ".data" /* initialized data */
+#define ELF_DEBUG ".debug" /* debug */
+#define ELF_DYNAMIC ".dynamic" /* dynamic linking information */
+#define ELF_DYNSTR ".dynstr" /* dynamic string table */
+#define ELF_DYNSYM ".dynsym" /* dynamic symbol table */
+#define ELF_FINI ".fini" /* termination code */
+#define ELF_GOT ".got" /* global offset table */
+#define ELF_HASH ".hash" /* symbol hash table */
+#define ELF_INIT ".init" /* initialization code */
+#define ELF_REL_DATA ".rel.data" /* relocation data */
+#define ELF_REL_FINI ".rel.fini" /* relocation termination code */
+#define ELF_REL_INIT ".rel.init" /* relocation initialization code */
+#define ELF_REL_DYN ".rel.dyn" /* relocaltion dynamic link info */
+#define ELF_REL_RODATA ".rel.rodata" /* relocation read-only data */
+#define ELF_REL_TEXT ".rel.text" /* relocation code */
+#define ELF_RODATA ".rodata" /* read-only data */
+#define ELF_SHSTRTAB ".shstrtab" /* section header string table */
+#define ELF_STRTAB ".strtab" /* string table */
+#define ELF_SYMTAB ".symtab" /* symbol table */
+#define ELF_TEXT ".text" /* code */
+#define ELF_RTMSYMTAB "RTMSymTab"
+
+/* Symbol Table Entry */
+typedef struct elf32_sym
+{
+ Elf32_Word st_name; /* name - index into string table */
+ Elf32_Addr st_value; /* symbol value */
+ Elf32_Word st_size; /* symbol size */
+ unsigned char st_info; /* type and binding */
+ unsigned char st_other; /* 0 - no defined meaning */
+ Elf32_Half st_shndx; /* section header index */
+} Elf32_Sym;
+
+#define STB_LOCAL 0 /* BIND */
+#define STB_GLOBAL 1
+#define STB_WEAK 2
+#define STB_NUM 3
+
+#define STB_LOPROC 13 /* processor specific range */
+#define STB_HIPROC 15
+
+#define STT_NOTYPE 0 /* symbol type is unspecified */
+#define STT_OBJECT 1 /* data object */
+#define STT_FUNC 2 /* code object */
+#define STT_SECTION 3 /* symbol identifies an ELF section */
+#define STT_FILE 4 /* symbol's name is file name */
+#define STT_COMMON 5 /* common data object */
+#define STT_TLS 6 /* thread-local data object */
+#define STT_NUM 7 /* # defined types in generic range */
+#define STT_LOOS 10 /* OS specific range */
+#define STT_HIOS 12
+#define STT_LOPROC 13 /* processor specific range */
+#define STT_HIPROC 15
+
+#define STN_UNDEF 0 /* undefined */
+
+#define ELF_ST_BIND(info) ((info) >> 4)
+#define ELF_ST_TYPE(info) ((info) & 0xf)
+#define ELF_ST_INFO(bind, type) (((bind)<<4)+((type)&0xf))
+
+/* Relocation entry with implicit addend */
+typedef struct
+{
+ Elf32_Addr r_offset; /* offset of relocation */
+ Elf32_Word r_info; /* symbol table index and type */
+} Elf32_Rel;
+
+/* Relocation entry with explicit addend */
+typedef struct
+{
+ Elf32_Addr r_offset; /* offset of relocation */
+ Elf32_Word r_info; /* symbol table index and type */
+ Elf32_Sword r_addend;
+} Elf32_Rela;
+
+/* Extract relocation info - r_info */
+#define ELF32_R_SYM(i) ((i) >> 8)
+#define ELF32_R_TYPE(i) ((unsigned char) (i))
+#define ELF32_R_INFO(s,t) (((s) << 8) + (unsigned char)(t))
+
+/*
+ * Relocation type for arm
+ */
+#define R_ARM_NONE 0
+#define R_ARM_PC24 1
+#define R_ARM_ABS32 2
+#define R_ARM_REL32 3
+#define R_ARM_THM_CALL 10
+#define R_ARM_GLOB_DAT 21
+#define R_ARM_JUMP_SLOT 22
+#define R_ARM_RELATIVE 23
+#define R_ARM_GOT_BREL 26
+#define R_ARM_PLT32 27
+#define R_ARM_CALL 28
+#define R_ARM_JUMP24 29
+#define R_ARM_THM_JUMP24 30
+#define R_ARM_V4BX 40
+
+/*
+ * 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_JMP_SLOT 7
+#define R_386_RELATIVE 8
+#define R_386_GOTOFF 9
+#define R_386_GOTPC 10
+
+/* Program Header */
+typedef struct
+{
+ Elf32_Word p_type; /* segment type */
+ Elf32_Off p_offset; /* segment offset */
+ Elf32_Addr p_vaddr; /* virtual address of segment */
+ Elf32_Addr p_paddr; /* physical address - ignored? */
+ Elf32_Word p_filesz; /* number of bytes in file for seg. */
+ Elf32_Word p_memsz; /* number of bytes in mem. for seg. */
+ Elf32_Word p_flags; /* flags */
+ Elf32_Word p_align; /* memory alignment */
+} Elf32_Phdr;
+
+/* p_type */
+#define PT_NULL 0
+#define PT_LOAD 1
+#define PT_DYNAMIC 2
+#define PT_INTERP 3
+#define PT_NOTE 4
+#define PT_SHLIB 5
+#define PT_PHDR 6
+#define PT_TLS 7
+#define PT_NUM 8
+#define PT_LOOS 0x60000000
+#define PT_HIOS 0x6fffffff
+#define PT_LOPROC 0x70000000
+#define PT_HIPROC 0x7fffffff
+
+/* p_flags */
+#define PF_X 1
+#define PF_W 2
+#define PF_R 4
+
+/* sh_type */
+#define SHT_NULL 0 /* inactive */
+#define SHT_PROGBITS 1 /* program defined information */
+#define SHT_SYMTAB 2 /* symbol table section */
+#define SHT_STRTAB 3 /* string table section */
+#define SHT_RELA 4 /* relocation section with addends*/
+#define SHT_HASH 5 /* symbol hash table section */
+#define SHT_DYNAMIC 6 /* dynamic section */
+#define SHT_NOTE 7 /* note section */
+#define SHT_NOBITS 8 /* no space section */
+#define SHT_REL 9 /* relocation section without addends */
+#define SHT_SHLIB 10 /* reserved - purpose unknown */
+#define SHT_DYNSYM 11 /* dynamic symbol table section */
+#define SHT_NUM 12 /* number of section types */
+#define SHT_LOPROC 0x70000000 /* reserved range for processor */
+#define SHT_HIPROC 0x7fffffff /* specific section header types */
+#define SHT_LOUSER 0x80000000 /* reserved range for application */
+#define SHT_HIUSER 0xffffffff /* specific indexes */
+
+/* Section Attribute Flags - sh_flags */
+#define SHF_WRITE 0x1 /* Writable */
+#define SHF_ALLOC 0x2 /* occupies memory */
+#define SHF_EXECINSTR 0x4 /* executable */
+#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
diff --git a/components/libc/libdl/dlerror.c b/components/libc/libdl/dlerror.c
index dd076412fe..ad9b630e4c 100644
--- a/components/libc/libdl/dlerror.c
+++ b/components/libc/libdl/dlerror.c
@@ -1,15 +1,11 @@
/*
- * 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)
-
diff --git a/components/libc/libdl/dlfcn.h b/components/libc/libdl/dlfcn.h
index 304ba5a777..55273a41eb 100644
--- a/components/libc/libdl/dlfcn.h
+++ b/components/libc/libdl/dlfcn.h
@@ -1,3 +1,13 @@
+/*
+ * 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
-
diff --git a/components/libc/libdl/dlmodule.c b/components/libc/libdl/dlmodule.c
new file mode 100644
index 0000000000..61ffbfc772
--- /dev/null
+++ b/components/libc/libdl/dlmodule.c
@@ -0,0 +1,699 @@
+/*
+ * 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 *module = RT_NULL;
+
+ module = (struct rt_dlmodule*) rt_object_allocate(RT_Object_Class_Module, "module");
+ if (module)
+ {
+ module->stat = RT_DLMODULE_STAT_INIT;
+
+ /* set initial priority and stack size */
+ module->priority = RT_THREAD_PRIORITY_MAX - 1;
+ module->stack_size = 2048;
+
+ rt_list_init(&(module->object_list));
+ }
+
+ return module;
+}
+
+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 ++;
+
+ /* deal with cache */
+#ifdef RT_USING_CACHE
+ rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, module->mem_space, module->mem_size);
+ rt_hw_cpu_icache_ops(RT_HW_CACHE_INVALIDATE, module->mem_space, module->mem_size);
+#endif
+
+ /* 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);
+
+ /* check stack size and priority */
+ if (module->priority > RT_THREAD_PRIORITY_MAX) module->priority = RT_THREAD_PRIORITY_MAX - 1;
+ if (module->stack_size < 2048 || module->stack_size > (1024 * 32)) module->stack_size = 2048;
+
+ tid = rt_thread_create(module->parent.name, _dlmodule_thread_entry, (void*)module,
+ module->stack_size, module->priority, 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);
diff --git a/components/libc/libdl/dlmodule.h b/components/libc/libdl/dlmodule.h
new file mode 100644
index 0000000000..4a4ead3303
--- /dev/null
+++ b/components/libc/libdl/dlmodule.h
@@ -0,0 +1,75 @@
+/*
+ * 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 */
+ rt_uint16_t priority;
+ rt_uint32_t stack_size;
+ struct rt_thread *main_thread;
+ /* the return code */
+ int ret_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
diff --git a/components/libc/libdl/dlopen.c b/components/libc/libdl/dlopen.c
index 6c89cb03c0..a8202ec607 100644
--- a/components/libc/libdl/dlopen.c
+++ b/components/libc/libdl/dlopen.c
@@ -1,11 +1,7 @@
/*
- * 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);
-
diff --git a/components/libc/libdl/dlsym.c b/components/libc/libdl/dlsym.c
index 36c7b01fce..ed0f183d83 100644
--- a/components/libc/libdl/dlsym.c
+++ b/components/libc/libdl/dlsym.c
@@ -1,37 +1,33 @@
/*
- * 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)
-