libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

[Kernel] move module tolibc/libdl.

This commit is contained in:
Bernard Xiong 2018-08-30 20:27:45 +08:00
parent 240451b978
commit efe4523132
23 changed files with 1499 additions and 1559 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
components/finsh/cmd.c
View File

@ -584,38 +584,6 @@ FINSH_FUNCTION_EXPORT(list_device, list device in system);
MSH_CMD_EXPORT(list_device, list device in system); MSH_CMD_EXPORT(list_device, list device in system);
#endif #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) long list(void)
{ {
#ifndef FINSH_USING_MSH_ONLY #ifndef FINSH_USING_MSH_ONLY

9
components/finsh/msh.c
View File

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

6
components/libc/Kconfig
View File

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

16
components/libc/compilers/newlib/syscalls.c
View File

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

4
components/libc/libdl/SConscript
View File

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

121
components/libc/libdl/arch/arm.c Normal file
View File

@ -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

43
components/libc/libdl/dlclose.c
View File

@ -1,36 +1,39 @@
/* /*
* File : dlclose.c * Copyright (c) 2006-2018, RT-Thread Development Team
* 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 * SPDX-License-Identifier: Apache-2.0
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2010-11-17 yi.qiu first version * 2010-11-17 yi.qiu first version
*/ */
#include <rtthread.h> #include <rtthread.h>
#include <rtm.h> #include <rtm.h>
int dlclose (void *handle) #include "dlmodule.h"
int dlclose(void *handle)
{ {
rt_module_t module; struct rt_dlmodule *module;
RT_ASSERT(handle != RT_NULL); RT_ASSERT(handle != RT_NULL);
module = (rt_module_t)handle; module = (struct rt_dlmodule *)handle;
module->nref--;
if(module->nref <= 0) rt_enter_critical();
{ module->nref--;
rt_module_unload(module); if (module->nref <= 0)
} {
rt_exit_critical();
return RT_TRUE; dlmodule_destroy(module);
}
else
{
rt_exit_critical();
}
return RT_TRUE;
} }
RTM_EXPORT(dlclose) RTM_EXPORT(dlclose)

442
components/libc/libdl/dlelf.c Normal file
View File

@ -0,0 +1,442 @@
/*
* 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;
}

58
src/module.h → components/libc/libdl/dlelf.h
View File

@ -1,32 +1,15 @@
/* /*
* File : module.h * Copyright (c) 2006-2018, RT-Thread Development Team
* 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 * SPDX-License-Identifier: Apache-2.0
* 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.
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2010-01-09 Bernard first version * 2018/08/29 Bernard first version
* 2010-04-09 yi.qiu implement based on first version
*/ */
#ifndef __MODULE_H__ #ifndef DL_ELF_H__
#define __MODULE_H__ #define DL_ELF_H__
#include <rtdef.h>
typedef rt_uint8_t Elf_Byte; typedef rt_uint8_t Elf_Byte;
@ -209,11 +192,19 @@ typedef struct
#define R_ARM_V4BX 40 #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_GLOB_DAT 6
#define R_386_JUMP_SLOT 7 #define R_386_JMP_SLOT 7
#define R_386_RELATIVE 8 #define R_386_RELATIVE 8
#define R_386_GOTOFF 9
#define R_386_GOTPC 10
/* Program Header */ /* Program Header */
typedef struct typedef struct
@ -274,4 +265,21 @@ typedef struct
#define SHF_MASKPROC 0xf0000000 /* reserved bits for processor */ #define SHF_MASKPROC 0xf0000000 /* reserved bits for processor */
/* specific section attributes */ /* 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 #endif

14
components/libc/libdl/dlerror.c
View File

@ -1,15 +1,11 @@
/* /*
* File : dlerror.c * Copyright (c) 2006-2018, RT-Thread Development Team
* 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 * SPDX-License-Identifier: Apache-2.0
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2010-11-17 yi.qiu first version * 2010-11-17 yi.qiu first version
*/ */
#include <rtthread.h> #include <rtthread.h>
@ -19,6 +15,4 @@ const char *dlerror(void)
{ {
return "TODO"; return "TODO";
} }
RTM_EXPORT(dlerror) RTM_EXPORT(dlerror)

11
components/libc/libdl/dlfcn.h
View File

@ -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_ #ifndef __DLFCN_H_
#define __DLFCN_H_ #define __DLFCN_H_
@ -16,4 +26,3 @@ void *dlsym(void *handle, const char *symbol);
int dlclose (void *handle); int dlclose (void *handle);
#endif #endif

683
components/libc/libdl/dlmodule.c Normal file
View File

@ -0,0 +1,683 @@
/*
* 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);

72
components/libc/libdl/dlmodule.h Normal file
View File

@ -0,0 +1,72 @@
/*
* 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

31
components/libc/libdl/dlopen.c
View File

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

36
components/libc/libdl/dlsym.c
View File

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

53
include/rtdef.h
View File

@ -1021,59 +1021,6 @@ struct rt_device_graphic_ops
/*@}*/ /*@}*/
#endif #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 */ /* definitions for libc */
#include "rtlibc.h" #include "rtlibc.h"

38
include/rtthread.h
View File

@ -442,44 +442,6 @@ rt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg);
/**@}*/ /**@}*/
#endif #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 * interrupt service
*/ */

4
src/Kconfig
View File

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

16
src/idle.c
View File

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

13
src/kservice.c
View File

@ -36,6 +36,10 @@
#include <rtthread.h> #include <rtthread.h>
#include <rthw.h> #include <rthw.h>
#ifdef RT_USING_MODULE
#include <dlmodule.h>
#endif
/* use precision */ /* use precision */
#define RT_PRINTF_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) if (rt_assert_hook == RT_NULL)
{ {
#ifdef RT_USING_MODULE #ifdef RT_USING_MODULE
if (rt_module_self() != RT_NULL) if (dlmodule_self())
{ {
/* unload assertion module */ /* close assertion module */
rt_module_unload(rt_module_self()); dlmodule_exit(-1);
/* re-schedule */
rt_schedule();
} }
else else
#endif #endif

1289
src/module.c
View File

File diff suppressed because it is too large Load Diff

51
src/object.c
View File

@ -32,6 +32,10 @@
#include <rtthread.h> #include <rtthread.h>
#include <rthw.h> #include <rthw.h>
#ifdef RT_USING_MODULE
#include <dlmodule.h>
#endif
/* /*
* define object_info for the number of rt_object_container items. * 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)}, {RT_Object_Class_Timer, _OBJ_CONTAINER_LIST_INIT(RT_Object_Info_Timer), sizeof(struct rt_timer)},
#ifdef RT_USING_MODULE #ifdef RT_USING_MODULE
/* initialize object container - 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 #endif
}; };
@ -251,6 +255,9 @@ void rt_object_init(struct rt_object *object,
{ {
register rt_base_t temp; register rt_base_t temp;
struct rt_object_information *information; struct rt_object_information *information;
#ifdef RT_USING_MODULE
struct rt_dlmodule *module = dlmodule_self();
#endif
/* get object information */ /* get object information */
information = rt_object_get_information(type); information = rt_object_get_information(type);
@ -269,8 +276,18 @@ void rt_object_init(struct rt_object *object,
/* lock interrupt */ /* lock interrupt */
temp = rt_hw_interrupt_disable(); temp = rt_hw_interrupt_disable();
/* insert object into information object list */ #ifdef RT_USING_MODULE
rt_list_insert_after(&(information->object_list), &(object->list)); 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 */ /* unlock interrupt */
rt_hw_interrupt_enable(temp); 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; struct rt_object *object;
register rt_base_t temp; register rt_base_t temp;
struct rt_object_information *information; struct rt_object_information *information;
#ifdef RT_USING_MODULE
struct rt_dlmodule *module = dlmodule_self();
#endif
RT_DEBUG_NOT_IN_INTERRUPT; 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; return RT_NULL;
} }
/* clean memory data of object */
rt_memset(object, 0x0, information->object_size);
/* initialize object's parameters */ /* initialize object's parameters */
/* set object type */ /* 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 */ /* set object flag */
object->flag = 0; 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 */ /* copy name */
rt_strncpy(object->name, name, RT_NAME_MAX); 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 */ /* lock interrupt */
temp = rt_hw_interrupt_disable(); temp = rt_hw_interrupt_disable();
/* insert object into information object list */ #ifdef RT_USING_MODULE
rt_list_insert_after(&(information->object_list), &(object->list)); 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 */ /* unlock interrupt */
rt_hw_interrupt_enable(temp); rt_hw_interrupt_enable(temp);

4
src/thread.c
View File

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