xin/rt-thread-am
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

import RT-Thread@9217865c without bsp, libcpu and components/net

Browse source
This commit is contained in:
Zihao Yu 2023-05-20 16:23:33 +08:00
commit e2376a3709
1414 changed files with 390370 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

12
components/libc/posix/libdl/SConscript Normal file
View file

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

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

@ -0,0 +1,121 @@
/*
* Copyright (c) 2006-2021, 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

60
components/libc/posix/libdl/arch/riscv.c Normal file
View file

@ -0,0 +1,60 @@
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2021/04/23 chunyexixiaoyu first version
*/
#include "../dlmodule.h"
#include "../dlelf.h"
#if (__riscv_xlen == 64)
#define R_RISCV_NONE 0
#define R_RISCV_32 1
#define R_RISCV_64 2
#define R_RISCV_RELATIVE 3
#define R_RISCV_COPY 4
#define R_RISCV_JUMP_SLOT 5
#define R_RISCV_TLS_DTPMOD32 6
#define R_RISCV_TLS_DTPMOD64 7
#define R_RISCV_TLS_DTPREL32 8
#define R_RISCV_TLS_DTPREL64 9
#define R_RISCV_TLS_TPREL32 10
#define R_RISCV_TLS_TPREL64 11
int dlmodule_relocate(struct rt_dlmodule *module, Elf_Rel *rel, Elf_Addr sym_val)
{
Elf64_Addr *where, tmp;
Elf64_Sword addend, offset;
rt_uint64_t upper, lower, sign, j1, j2;
where = (Elf64_Addr *)((rt_uint8_t *)module->mem_space
+ rel->r_offset
- module->vstart_addr);
switch (ELF64_R_TYPE(rel->r_info))
{
case R_RISCV_NONE:
break;
case R_RISCV_64:
*where = (Elf64_Addr)(sym_val + rel->r_addend);
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_RISCV_64: %x -> %x\n",where, *where));
break;
case R_RISCV_RELATIVE:
*where = (Elf64_Addr)((rt_uint8_t *)module->mem_space - module->vstart_addr + rel->r_addend);
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_RISCV_RELATIVE: %x -> %x\n",where, *where));
break;
case R_RISCV_JUMP_SLOT:
*where = (Elf64_Addr)sym_val;
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_RISCV_JUMP_SLOT: %x -> %x\n",where, *where));
break;
default:
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("__riscv__ELF: invalid relocate TYPE %d\n", ELF64_R_TYPE(rel->r_info)));
return -1;
}
return 0;
}
#endif

50
components/libc/posix/libdl/arch/x86.c Normal file
View file

@ -0,0 +1,50 @@
/*
* Copyright (c) 2006-2021, 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

39
components/libc/posix/libdl/dlclose.c Normal file
View file

@ -0,0 +1,39 @@
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2010-11-17 yi.qiu first version
*/
#include <rtthread.h>
#include <rtm.h>
#include "dlmodule.h"
int dlclose(void *handle)
{
struct rt_dlmodule *module;
RT_ASSERT(handle != RT_NULL);
module = (struct rt_dlmodule *)handle;
rt_enter_critical();
module->nref--;
if (module->nref <= 0)
{
rt_exit_critical();
dlmodule_destroy(module);
}
else
{
rt_exit_critical();
}
return RT_TRUE;
}
RTM_EXPORT(dlclose)

493
components/libc/posix/libdl/dlelf.c Normal file
View file

@ -0,0 +1,493 @@
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2018/08/29 Bernard first version
* 2021/04/23 chunyexixiaoyu distinguish 32-bit and 64-bit
*/
#include "dlmodule.h"
#include "dlelf.h"
#define DBG_TAG "DLMD"
#define DBG_LVL DBG_INFO
#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_ubase_t index, module_size = 0;
Elf_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)
{
LOG_E("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)
{
LOG_E("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)
{
LOG_E("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)
{
LOG_E("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)
{
LOG_E("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_ubase_t i, nr_reloc;
Elf_Sym *symtab;
Elf_Rel *rel;
rt_uint8_t *strtab;
static rt_bool_t unsolved = RT_FALSE;
#if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32))
if (!IS_REL(shdr[index]))
continue;
#elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64))
if (!IS_RELA(shdr[index]))
continue;
#endif
/* get relocate item */
rel = (Elf_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
/* locate .rel.plt and .rel.dyn section */
symtab = (Elf_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_ubase_t)(shdr[index].sh_size / sizeof(Elf_Rel));
/* relocate every items */
for (i = 0; i < nr_reloc; i ++)
{
#if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32))
Elf_Sym *sym = &symtab[ELF32_R_SYM(rel->r_info)];
#elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64))
Elf_Sym *sym = &symtab[ELF64_R_SYM(rel->r_info)];
#endif
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))
{
Elf_Addr addr;
addr = (Elf_Addr)(module->mem_space + sym->st_value - vstart_addr);
dlmodule_relocate(module, rel, addr);
}
else if (!linked)
{
Elf_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;
Elf_Sym *symtab = RT_NULL;
rt_uint8_t *strtab = RT_NULL;
symtab = (Elf_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(Elf_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(Elf_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 ++;
}
/* get priority & stack size params*/
rt_uint32_t flag = 0;
rt_uint16_t priority;
rt_uint32_t stacksize;
for (i = 0; i < shdr[index].sh_size / sizeof(Elf_Sym); i++)
{
if (((flag & 0x01) == 0) &&
(rt_strcmp((const char *)(strtab + symtab[i].st_name), "dlmodule_thread_priority") == 0))
{
flag |= 0x01;
priority = *(rt_uint16_t*)(module->mem_space + symtab[i].st_value - module->vstart_addr);
if (priority < RT_THREAD_PRIORITY_MAX)
{
module->priority = priority;
}
}
if (((flag & 0x02) == 0) &&
(rt_strcmp((const char *)(strtab + symtab[i].st_name), "dlmodule_thread_stacksize") == 0))
{
flag |= 0x02;
stacksize = *(rt_uint32_t*)(module->mem_space + symtab[i].st_value - module->vstart_addr);
if ((stacksize < 2048) || (stacksize > 1024 * 32))
{
module->stack_size = stacksize;
}
}
if ((flag & 0x03) == 0x03)
{
break;
}
}
}
return RT_EOK;
}
rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module_ptr)
{
rt_ubase_t index, rodata_addr = 0, bss_addr = 0, data_addr = 0;
rt_ubase_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)
{
LOG_E("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_ubase_t i, nr_reloc;
Elf_Sym *symtab;
Elf_Rel *rel;
#if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32))
if (!IS_REL(shdr[index]))
continue;
#elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64))
if (!IS_RELA(shdr[index]))
continue;
#endif
/* get relocate item */
rel = (Elf_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
/* locate .dynsym and .dynstr */
symtab = (Elf_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(Elf_Rel));
/* relocate every items */
for (i = 0; i < nr_reloc; i ++)
{
#if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32))
Elf_Sym *sym = &symtab[ELF32_R_SYM(rel->r_info)];
#elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64))
Elf_Sym *sym = &symtab[ELF64_R_SYM(rel->r_info)];
#endif
LOG_D("relocate symbol: %s", strtab + sym->st_name);
if (sym->st_shndx != STN_UNDEF)
{
Elf_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 = (Elf_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 = (Elf_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 = (Elf_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 = (Elf_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,
(Elf_Addr)((rt_uint8_t *)
module->mem_space
- module_addr
+ sym->st_value));
}
else
{
Elf_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 != (Elf_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 = (Elf_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value);
dlmodule_relocate(module, rel, addr);
}
}
rel ++;
}
}
return RT_EOK;
}

381
components/libc/posix/libdl/dlelf.h Normal file
View file

@ -0,0 +1,381 @@
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2018/08/29 Bernard first version
* 2021/04/23 chunyexixiaoyu distinguish 32-bit and 64-bit
*/
#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 */
typedef rt_uint64_t Elf64_Addr;
typedef rt_uint16_t Elf64_Half;
typedef rt_int16_t Elf64_SHalf;
typedef rt_uint64_t Elf64_Off;
typedef rt_int32_t Elf64_Sword;
typedef rt_uint32_t Elf64_Word;
typedef rt_uint64_t Elf64_Xword;
typedef rt_int64_t Elf64_Sxword;
typedef rt_uint16_t Elf64_Section;
/* 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;
typedef struct elf64_hdr
{
unsigned char e_ident[EI_NIDENT]; /* ELF Identification */
Elf64_Half e_type; /* object file type */
Elf64_Half e_machine; /* machine */
Elf64_Word e_version; /* object file version */
Elf64_Addr e_entry; /* virtual entry point */
Elf64_Off e_phoff; /* program header table offset */
Elf64_Off e_shoff; /* section header table offset */
Elf64_Word e_flags; /* processor-specific flags */
Elf64_Half e_ehsize; /* ELF header size */
Elf64_Half e_phentsize; /* program header entry size */
Elf64_Half e_phnum; /* number of program header entries */
Elf64_Half e_shentsize; /* section header entry size */
Elf64_Half e_shnum; /* number of section header entries */
Elf64_Half e_shstrndx; /* section header table's "section
header string table" entry offset */
} Elf64_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;
typedef struct
{
Elf64_Word sh_name; /* Section name (string tbl index) */
Elf64_Word sh_type; /* Section type */
Elf64_Xword sh_flags; /* Section flags */
Elf64_Addr sh_addr; /* Section virtual addr at execution */
Elf64_Off sh_offset; /* Section file offset */
Elf64_Xword sh_size; /* Section size in bytes */
Elf64_Word sh_link; /* Link to another section */
Elf64_Word sh_info; /* Additional section information */
Elf64_Xword sh_addralign; /* Section alignment */
Elf64_Xword sh_entsize; /* Entry size if section holds table */
} Elf64_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;
typedef struct
{
Elf64_Word st_name; /* Symbol name (string tbl index) */
unsigned char st_info; /* Symbol type and binding */
unsigned char st_other; /* Symbol visibility */
Elf64_Section st_shndx; /* Section index */
Elf64_Addr st_value; /* Symbol value */
Elf64_Xword st_size; /* Symbol size */
} Elf64_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;
typedef struct
{
Elf64_Addr r_offset; /* Address */
Elf64_Xword r_info; /* Relocation type and symbol index */
} Elf64_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;
typedef struct
{
Elf64_Addr r_offset; /* Address */
Elf64_Xword r_info; /* Relocation type and symbol index */
Elf64_Sxword r_addend; /* Addend */
} Elf64_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))
#define ELF64_R_SYM(i) ((i) >> 32)
#define ELF64_R_TYPE(i) ((i) & 0xffffffff)
#define ELF64_R_INFO(sym,type) ((((Elf64_Xword) (sym)) << 32) + (type))
/*
* 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;
typedef struct
{
Elf64_Word p_type; /* Segment type */
Elf64_Word p_flags; /* Segment flags */
Elf64_Off p_offset; /* Segment file offset */
Elf64_Addr p_vaddr; /* Segment virtual address */
Elf64_Addr p_paddr; /* Segment physical address */
Elf64_Xword p_filesz; /* Segment size in file */
Elf64_Xword p_memsz; /* Segment size in memory */
Elf64_Xword p_align; /* Segment alignment */
} Elf64_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))
#if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32))
#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))
typedef Elf32_Sym Elf_Sym;
typedef Elf32_Rel Elf_Rel;
typedef Elf32_Addr Elf_Addr;
#elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64))
#define elf_module ((Elf64_Ehdr *)module_ptr)
#define shdr ((Elf64_Shdr *)((rt_uint8_t *)module_ptr + elf_module->e_shoff))
#define phdr ((Elf64_Phdr *)((rt_uint8_t *)module_ptr + elf_module->e_phoff))
typedef Elf64_Sym Elf_Sym;
typedef Elf64_Rela Elf_Rel;
typedef Elf64_Addr Elf_Addr;
#endif
int dlmodule_relocate(struct rt_dlmodule *module, Elf_Rel *rel, Elf_Addr sym_val);
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);
#endif

18
components/libc/posix/libdl/dlerror.c Normal file
View file

@ -0,0 +1,18 @@
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2010-11-17 yi.qiu first version
*/
#include <rtthread.h>
#include <rtm.h>
const char *dlerror(void)
{
return "TODO";
}
RTM_EXPORT(dlerror)

28
components/libc/posix/libdl/dlfcn.h Normal file
View file

@ -0,0 +1,28 @@
/*
* Copyright (c) 2006-2021, 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_
#define RTLD_LAZY 0x00000
#define RTLD_NOW 0x00001
#define RTLD_LOCAL 0x00000
#define RTLD_GLOBAL 0x10000
#define RTLD_DEFAULT ((void*)1)
#define RTLD_NEXT ((void*)2)
void *dlopen (const char *filename, int flag);
const char *dlerror(void);
void *dlsym(void *handle, const char *symbol);
int dlclose (void *handle);
#endif

893
components/libc/posix/libdl/dlmodule.c Normal file
View file

@ -0,0 +1,893 @@
/*
* Copyright (c) 2006-2021, 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"
#ifdef RT_USING_POSIX_FS
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/statfs.h>
#endif
#define DBG_TAG "DLMD"
#define DBG_LVL DBG_INFO
#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->parent.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->parent.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->parent.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)
{
#ifdef RT_USING_POSIX_FS
int fd = -1, length = 0;
#endif
rt_err_t ret = RT_EOK;
rt_uint8_t *module_ptr = RT_NULL;
struct rt_dlmodule *module = RT_NULL;
#ifdef RT_USING_POSIX_FS
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;
}
else
{
goto __exit;
}
#endif
if (!module_ptr) goto __exit;
/* 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)&&(elf_module->e_ident[EI_CLASS] != ELFCLASS64))
{
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:
#ifdef RT_USING_POSIX_FS
if (fd >= 0) close(fd);
#endif
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->parent.module_id= module;
module->main_thread = tid;
rt_thread_startup(tid);
}
else
{
/* destory dl module */
dlmodule_destroy(module);
module = RT_NULL;
}
}
}
return module;
}
#if defined(RT_USING_CUSTOM_DLMODULE)
struct rt_dlmodule* dlmodule_load_custom(const char* filename, struct rt_dlmodule_ops* ops)
{
#ifdef RT_USING_POSIX_FS
int fd = -1, length = 0;
#endif
rt_err_t ret = RT_EOK;
rt_uint8_t *module_ptr = RT_NULL;
struct rt_dlmodule *module = RT_NULL;
if (ops)
{
RT_ASSERT(ops->load);
RT_ASSERT(ops->unload);
module_ptr = ops->load(filename);
}
#ifdef RT_USING_POSIX_FS
else
{
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;
}
else
{
goto __exit;
}
}
#endif
if (!module_ptr) goto __exit;
/* 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 */
if (ops)
{
ops->unload(module_ptr);
}
else
{
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:
#ifdef RT_USING_POSIX_FS
if (fd >= 0) close(fd);
#endif
if (module_ptr)
{
if (ops)
{
ops->unload(module_ptr);
}
else
{
rt_free(module_ptr);
}
}
if (module) dlmodule_destroy(module);
return RT_NULL;
}
struct rt_dlmodule* dlmodule_exec_custom(const char* pgname, const char* cmd, int cmd_size, struct rt_dlmodule_ops* ops)
{
struct rt_dlmodule *module = RT_NULL;
module = dlmodule_load_custom(pgname, ops);
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->parent.module_id= module;
module->main_thread = tid;
rt_thread_startup(tid);
}
else
{
/* destory dl module */
dlmodule_destroy(module);
module = RT_NULL;
}
}
}
return module;
}
#endif
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);

87
components/libc/posix/libdl/dlmodule.h Normal file
View file

@ -0,0 +1,87 @@
/*
* Copyright (c) 2006-2021, 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_ops
{
rt_uint8_t *(*load)(const char* filename); /* load dlmodule file data */
rt_err_t (*unload)(rt_uint8_t *param); /* unload dlmodule file data */
};
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);
#if defined(RT_USING_CUSTOM_DLMODULE)
struct rt_dlmodule* dlmodule_load_custom(const char* filename, struct rt_dlmodule_ops* ops);
struct rt_dlmodule* dlmodule_exec_custom(const char* pgname, const char* cmd, int cmd_size, struct rt_dlmodule_ops* ops);
#endif
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

64
components/libc/posix/libdl/dlopen.c Normal file
View file

@ -0,0 +1,64 @@
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2010-11-17 yi.qiu first version
*/
#include <rtthread.h>
#include <rtm.h>
#include <string.h>
#include "dlmodule.h"
#define MODULE_ROOT_DIR "/modules"
void* dlopen(const char *filename, int flags)
{
struct rt_dlmodule *module;
char *fullpath;
const char*def_path = MODULE_ROOT_DIR;
/* check parameters */
RT_ASSERT(filename != RT_NULL);
if (filename[0] != '/') /* it's a relative path, prefix with MODULE_ROOT_DIR */
{
fullpath = rt_malloc(strlen(def_path) + strlen(filename) + 2);
/* join path and file name */
rt_snprintf(fullpath, strlen(def_path) + strlen(filename) + 2,
"%s/%s", def_path, filename);
}
else
{
fullpath = (char*)filename; /* absolute path, use it directly */
}
rt_enter_critical();
/* find in module list */
module = dlmodule_find(fullpath);
if(module != RT_NULL)
{
rt_exit_critical();
module->nref++;
}
else
{
rt_exit_critical();
module = dlmodule_load(fullpath);
}
if(fullpath != filename)
{
rt_free(fullpath);
}
return (void*)module;
}
RTM_EXPORT(dlopen);

33
components/libc/posix/libdl/dlsym.c Normal file
View file

@ -0,0 +1,33 @@
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* 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;
struct rt_dlmodule *module;
RT_ASSERT(handle != RT_NULL);
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;
}
return RT_NULL;
}
RTM_EXPORT(dlsym)

53
components/libc/posix/libdl/dlsyms.c Normal file
View file

@ -0,0 +1,53 @@
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2017/10/15 bernard the first version
*/
#include <rtthread.h>
#include <rtm.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
RTM_EXPORT(strcpy);
RTM_EXPORT(strncpy);
RTM_EXPORT(strlen);
RTM_EXPORT(strcat);
RTM_EXPORT(strstr);
RTM_EXPORT(strchr);
RTM_EXPORT(strcmp);
RTM_EXPORT(strtol);
RTM_EXPORT(strtoul);
RTM_EXPORT(strncmp);
RTM_EXPORT(memcpy);
RTM_EXPORT(memcmp);
RTM_EXPORT(memmove);
RTM_EXPORT(memset);
RTM_EXPORT(memchr);
RTM_EXPORT(putchar);
RTM_EXPORT(puts);
RTM_EXPORT(printf);
RTM_EXPORT(sprintf);
RTM_EXPORT(snprintf);
RTM_EXPORT(fwrite);
#include <setjmp.h>
RTM_EXPORT(longjmp);
RTM_EXPORT(setjmp);
RTM_EXPORT(exit);
RTM_EXPORT(abort);
RTM_EXPORT(rand);
#include <assert.h>
RTM_EXPORT(__assert_func);