diff options
| -rw-r--r-- | components/thread/module_thread_dynamic.c | 23 | ||||
| -rw-r--r-- | include/rtm.h | 24 | ||||
| -rw-r--r-- | include/rtthread.h | 42 | ||||
| -rw-r--r-- | src/kservice.c | 7 | ||||
| -rw-r--r-- | src/module.c | 360 | ||||
| -rw-r--r-- | src/module.h | 205 | ||||
| -rw-r--r-- | src/thread.c | 18 |
7 files changed, 663 insertions, 16 deletions
diff --git a/components/thread/module_thread_dynamic.c b/components/thread/module_thread_dynamic.c new file mode 100644 index 0000000000..7a5d3238ce --- /dev/null +++ b/components/thread/module_thread_dynamic.c @@ -0,0 +1,23 @@ +#include <rtthread.h>
+
+static void thread_entry(void* parameter)
+{
+ rt_kprintf("thread dynamicly created ok\n");
+ rt_thread_delay(10);
+ rt_kprintf("thread exit\n");
+}
+
+int rtm_main()
+{
+ rt_thread_t tid;
+
+ tid = rt_thread_create("test",
+ thread_entry, RT_NULL,
+ THREAD_STACK_SIZE, THREAD_PRIORITY, THREAD_TIMESLICE);
+ if (tid != RT_NULL)
+ rt_thread_startup(tid);
+ else
+ tc_stat(TC_STAT_END | TC_STAT_FAILED);
+
+ return 0;
+}
\ No newline at end of file diff --git a/include/rtm.h b/include/rtm.h new file mode 100644 index 0000000000..596d5f7f07 --- /dev/null +++ b/include/rtm.h @@ -0,0 +1,24 @@ +#ifndef __RTM_H__
+#define __RTM_H__
+
+#include <rtdef.h>
+
+#ifdef RT_USING_MODULE
+#define RTM_EXPORT(symbol) \
+const char __rtmsym_##symbol##_name[] = #symbol; \
+const struct rt_module_symtab __rtmsym_##symbol SECTION("RTMSymTab")= \
+{ \
+ (rt_uint32_t)&symbol, \
+ __rtmsym_##symbol##_name, \
+};
+#else
+#define RTM_EXPORT(symbol)
+#endif
+
+struct rt_module_symtab
+{
+ rt_uint32_t addr;
+ const char* name;
+};
+
+#endif
diff --git a/include/rtthread.h b/include/rtthread.h index 9cf3e49978..b3d6621e22 100644 --- a/include/rtthread.h +++ b/include/rtthread.h @@ -14,6 +14,8 @@ * 2006-08-10 Bernard add version information * 2007-01-28 Bernard rename RT_OBJECT_Class_Static to RT_Object_Class_Static * 2007-03-03 Bernard clean up the definitions to rtdef.h + * 2010-04-11 yi.qiu add module feature + */ #ifndef __RT_THREAD_H__ @@ -25,6 +27,16 @@ extern "C" { #endif +#if defined(__CC_ARM) +#ifdef RT_USING_MODULE +#define RTT_API __declspec(dllimport) +#else +#define RTT_API __declspec(dllexport) +#endif +#elif defined(__GNUC__) +#define RTT_API +#endif + /** * @addtogroup KernelObject */ @@ -91,27 +103,27 @@ void rt_timer_timeout_sethook(void (*hook)(struct rt_timer* timer)); /* * thread interface */ -rt_err_t rt_thread_init(struct rt_thread* thread, +RTT_API rt_err_t rt_thread_init(struct rt_thread* thread, const char* name, void (*entry)(void* parameter), void* parameter, void* stack_start, rt_uint32_t stack_size, rt_uint8_t priority, rt_uint32_t tick); -rt_err_t rt_thread_detach(rt_thread_t thread); -rt_thread_t rt_thread_create (const char* name, +RTT_API rt_err_t rt_thread_detach(rt_thread_t thread); +RTT_API rt_thread_t rt_thread_create (const char* name, void (*entry)(void* parameter), void* parameter, rt_uint32_t stack_size, rt_uint8_t priority, rt_uint32_t tick); -rt_thread_t rt_thread_self(void); -rt_thread_t rt_thread_find(char* name); -rt_err_t rt_thread_startup(rt_thread_t thread); -rt_err_t rt_thread_delete(rt_thread_t thread); +RTT_API rt_thread_t rt_thread_self(void); +RTT_API rt_thread_t rt_thread_find(char* name); +RTT_API rt_err_t rt_thread_startup(rt_thread_t thread); +RTT_API rt_err_t rt_thread_delete(rt_thread_t thread); -rt_err_t rt_thread_yield(void); -rt_err_t rt_thread_delay(rt_tick_t tick); -rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void* arg); -rt_err_t rt_thread_suspend(rt_thread_t thread); -rt_err_t rt_thread_resume(rt_thread_t thread); -void rt_thread_timeout(void* parameter); +RTT_API rt_err_t rt_thread_yield(void); +RTT_API rt_err_t rt_thread_delay(rt_tick_t tick); +RTT_API rt_err_t rt_thread_control(rt_thread_t thread, rt_uint8_t cmd, void* arg); +RTT_API rt_err_t rt_thread_suspend(rt_thread_t thread); +RTT_API rt_err_t rt_thread_resume(rt_thread_t thread); +RTT_API void rt_thread_timeout(void* parameter); /* * idle thread interface @@ -312,8 +324,8 @@ void rt_interrupt_leave(void); rt_int32_t rt_sprintf(char *buf ,const char *format,...); rt_int32_t rt_vsprintf(char *dest, const char *format, va_list arg_ptr); rt_int32_t rt_sprintf(char *buf ,const char *format,...); -rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...);
-
+rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...); + rt_device_t rt_console_set_device(const char* name); void rt_kprintf(const char *fmt, ...); diff --git a/src/kservice.c b/src/kservice.c index e950caadc5..cdd0a60907 100644 --- a/src/kservice.c +++ b/src/kservice.c @@ -941,12 +941,12 @@ __weak void rt_hw_console_output(const char* str) */ void rt_kprintf(const char *fmt, ...) { + va_list args; rt_size_t length; static char rt_log_buf[RT_CONSOLEBUF_SIZE]; va_start(args, fmt); - length = vsnprintf(rt_log_buf, sizeof(rt_log_buf), fmt, args); if (_console_device == RT_NULL) { @@ -977,4 +977,9 @@ char *strdup(const char *s) __attribute__((weak, alias("rt_strdup"))); #endif #endif +#ifdef RT_USING_MODULE +#include <rtm.h> +/* some buildin kernel symbol */ +RTM_EXPORT(rt_kprintf) +#endif /*@}*/ diff --git a/src/module.c b/src/module.c new file mode 100644 index 0000000000..4316d171d6 --- /dev/null +++ b/src/module.c @@ -0,0 +1,360 @@ +/* + * File : module.c + * This file is part of RT-Thread RTOS + * COPYRIGHT (C) 2006 - 2010, RT-Thread Development Team + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rt-thread.org/license/LICENSE + * + * Change Logs: + * Date Author Notes + * 2010-01-09 Bernard first version + * 2010-04-09 yi.qiu implement based on first version + */ + +#include <rtm.h> +#include <rtthread.h> + +#include "module.h" +#include "kservice.h" + +#ifdef RT_USING_MODULE +rt_list_t rt_module_symbol_list; +struct rt_module* rt_current_module; +struct rt_module_symtab *_rt_module_symtab_begin = RT_NULL, *_rt_module_symtab_end = RT_NULL; +void rt_system_module_init() +{ +#ifdef __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(__GNUC__) + 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; +#endif + + rt_list_init(&rt_module_symbol_list); +} + +rt_uint32_t rt_module_symbol_find(const rt_uint8_t* 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 (strcmp(index->name, (const char*)sym_str) == 0) + return index->addr; + } + + return 0; +} + +#define elf_module ((Elf32_Ehdr *)module_ptr) +#define shdr ((Elf32_Shdr *)((rt_uint8_t *)module_ptr + elf_module->e_shoff)) + +#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)) + +int rt_module_arm_relocate(struct rt_module* module, Elf32_Rel *rel, Elf32_Addr sym_val, rt_uint32_t module_addr) +{ + Elf32_Addr *where, tmp; + Elf32_Sword addend; + + where = (Elf32_Addr *)((rt_uint8_t*)module->module_space + rel->r_offset - module_addr); + switch (ELF32_R_TYPE(rel->r_info)) + { + case R_ARM_NONE: + break; + + case R_ARM_ABS32: + *where += (Elf32_Addr)sym_val; + rt_kprintf("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_kprintf("R_ARM_PC24: %x -> %x\n", where, *where); + break; + + default: + return -1; + } + + return 0; +} + +static void rt_module_init_object_container(struct rt_module* module) +{ + RT_ASSERT(module != RT_NULL); + + /* init object container - thread */ + rt_list_init(&(module->module_object[RT_Object_Class_Thread].object_list)); + module->module_object[RT_Object_Class_Thread].object_size = sizeof(struct rt_thread); + module->module_object[RT_Object_Class_Thread].type = RT_Object_Class_Thread; + +#ifdef RT_USING_SEMAPHORE + /* init object container - semaphore */ + rt_list_init(&(module->module_object[RT_Object_Class_Semaphore].object_list)); + module->module_object[RT_Object_Class_Semaphore].object_size = sizeof(struct rt_semaphore); + module->module_object[RT_Object_Class_Semaphore].type = RT_Object_Class_Semaphore; +#endif + +#ifdef RT_USING_MUTEX + /* init object container - mutex */ + rt_list_init(&(module->module_object[RT_Object_Class_Mutex].object_list)); + module->module_object[RT_Object_Class_Mutex].object_size = sizeof(struct rt_mutex); + module->module_object[RT_Object_Class_Mutex].type = RT_Object_Class_Mutex; +#endif + +#ifdef RT_USING_FASTEVENT + /* init object container - fast event */ + rt_list_init(&(module->module_object[RT_Object_Class_FastEvent].object_list)); + module->module_object[RT_Object_Class_FastEvent].object_size = sizeof(struct rt_fast_event); + module->module_object[RT_Object_Class_FastEvent].type = RT_Object_Class_FastEvent; +#endif + +#ifdef RT_USING_EVENT + /* init object container - event */ + rt_list_init(&(module->module_object[RT_Object_Class_Event].object_list)); + module->module_object[RT_Object_Class_Event].object_size = sizeof(struct rt_event); + module->module_object[RT_Object_Class_Event].type = RT_Object_Class_Event; +#endif + +#ifdef RT_USING_MAILBOX + /* init object container - mailbox */ + rt_list_init(&(module->module_object[RT_Object_Class_MailBox].object_list)); + module->module_object[RT_Object_Class_MailBox].object_size = sizeof(struct rt_mailbox); + module->module_object[RT_Object_Class_MailBox].type = RT_Object_Class_MailBox; +#endif + +#ifdef RT_USING_MESSAGEQUEUE + /* init object container - message queue */ + rt_list_init(&(module->module_object[RT_Object_Class_MessageQueue].object_list)); + module->module_object[RT_Object_Class_MessageQueue].object_size = sizeof(struct rt_messagequeue); + module->module_object[RT_Object_Class_MessageQueue].type = RT_Object_Class_MessageQueue; +#endif + +#ifdef RT_USING_MEMPOOL + /* init object container - memory pool */ + rt_list_init(&(module->module_object[RT_Object_Class_MemPool].object_list)); + module->module_object[RT_Object_Class_MemPool].object_size = sizeof(struct rt_mempool); + module->module_object[RT_Object_Class_MemPool].type = RT_Object_Class_MemPool; +#endif + +#ifdef RT_USING_DEVICE + /* init object container - device */ + rt_list_init(&(module->module_object[RT_Object_Class_Device].object_list)); + module->module_object[RT_Object_Class_Device].object_size = sizeof(struct rt_device); + module->module_object[RT_Object_Class_Device].type = RT_Object_Class_Device; +#endif + + /* init object container - timer */ + rt_list_init(&(module->module_object[RT_Object_Class_Timer].object_list)); + module->module_object[RT_Object_Class_Timer].object_size = sizeof(struct rt_timer); + module->module_object[RT_Object_Class_Timer].type = RT_Object_Class_Timer; +} + +struct rt_module* rt_module_load(void* module_ptr, const rt_uint8_t* name) +{ + rt_uint32_t index; + rt_uint32_t module_addr = 0, module_size = 0; + struct rt_module* module = RT_NULL; + rt_uint8_t *ptr, *strtab, *shstrab; + + /* check ELF header */ + if (rt_memcmp(elf_module->e_ident, ELFMAG, SELFMAG) != 0 || + elf_module->e_ident[EI_CLASS] != ELFCLASS32) + return RT_NULL; + + /* 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 module; + + /* allocate module */ + module = (struct rt_module *)rt_object_allocate(RT_Object_Class_Module, (const char*)name); + if (module == RT_NULL) return module; + + /* allocate module space */ + module->module_space = rt_malloc(module_size); + if (module->module_space == RT_NULL) + { + rt_object_delete(&(module->parent)); + return RT_NULL; + } + + /* zero all space */ + ptr = module->module_space; + rt_memset(ptr, 0, module_size); + + /* load text and data section */ + for (index = 0; index < elf_module->e_shnum; index++) + { + /* load text and rodata section */ + if (IS_PROG(shdr[index]) && (IS_AX(shdr[index])||IS_ALLOC(shdr[index]))) + { + rt_memcpy(ptr, (rt_uint8_t*)elf_module + shdr[index].sh_offset, shdr[index].sh_size); + ptr += shdr[index].sh_size; + } + + /* load data section */ + if (IS_PROG(shdr[index]) && IS_AW(shdr[index])) + { + module->module_data = (rt_uint32_t)ptr; + rt_memset(ptr, 0, shdr[index].sh_size); + ptr += shdr[index].sh_size; + } + } + + /* set module entry */ + module->module_entry = (rt_uint8_t*)module->module_space + elf_module->e_entry - module_addr; + + /* handle relocation section */ + for (index = 0; index < elf_module->e_shnum; index ++) + { + if (IS_REL(shdr[index])) + { + rt_uint32_t i, nr_reloc; + Elf32_Sym *symtab; + Elf32_Rel *rel; + + /* 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)]; + rt_kprintf("relocate symbol: %s\n", strtab + sym->st_name); + if (sym->st_shndx != STN_UNDEF) + { + if(ELF_ST_TYPE(sym->st_info) == STT_SECTION) + { + if (strncmp(shstrab + shdr[sym->st_shndx].sh_name, ELF_RODATA, 8) == 0) + { + /* relocate rodata section, fix me, module_ptr should be freed */ + rt_module_arm_relocate(module, rel, + (Elf32_Addr)((rt_uint8_t*)module_ptr + shdr[sym->st_shndx].sh_offset), + module_addr); + } + else if(strncmp(shstrab + shdr[sym->st_shndx].sh_name, ELF_BSS, 5) == 0) + { + /* relocate bss section */ + rt_module_arm_relocate(module, rel, (Elf32_Addr)ptr, module_addr); + } + } + else if(ELF_ST_TYPE(sym->st_info) == STT_FUNC ) + { + /* relocate function */ + rt_module_arm_relocate(module, rel, + (Elf32_Addr)((rt_uint8_t*)module->module_space - module_addr + sym->st_value), + module_addr); + } + else if(ELF_ST_TYPE(sym->st_info) == STT_OBJECT) + { + /* relocate object, fix me, module_ptr should be freed */ + rt_module_arm_relocate(module, rel, + (Elf32_Addr)((rt_uint8_t*)module_ptr + shdr[sym->st_shndx].sh_offset + sym->st_value), + module_addr); + } + } + else + { + rt_kprintf("unresolved relocate symbol: %s\n", strtab + sym->st_name); + /* need to resolve symbol in kernel symbol table */ + Elf32_Addr addr = rt_module_symbol_find(strtab + sym->st_name); + if (addr != (Elf32_Addr)RT_NULL) + rt_module_arm_relocate(module, rel, addr, module_addr); + else rt_kprintf("can't find %s in kernel symbol table\n", strtab + sym->st_name); + } + + rel ++; + } + } + } + + /* init module object container */ + rt_module_init_object_container(module); + + /* create module main thread */ + module->module_thread = rt_thread_create((const char*)name, + module->module_entry, RT_NULL, + 512, 90, 10); + module->module_thread->module_parent = module; + rt_thread_startup(module->module_thread); + + return module; +} + +void rt_module_unload(struct rt_module* module) +{ + struct rt_object* object; + + /* suspend module main thread */ + if (module->module_thread->stat == RT_THREAD_READY) + rt_thread_suspend(module->module_thread); + + /* delete all module object */ + + /* release module memory */ +} + +rt_module_t rt_module_find(char* name) +{ + struct rt_module* module; + module = (struct rt_module*)rt_object_find(RT_Object_Class_Module, name); + + return module; +} + +#endif diff --git a/src/module.h b/src/module.h new file mode 100644 index 0000000000..ae2e8b83a8 --- /dev/null +++ b/src/module.h @@ -0,0 +1,205 @@ +#ifndef __MODULE_H__
+#define __MODULE_H__
+
+#include <rtdef.h>
+
+typedef rt_uint8_t Elf_Byte;
+
+typedef rt_uint32_t Elf32_Addr; /* Unsigned program address */
+typedef rt_uint32_t Elf32_Off; /* Unsigned file offset */
+typedef rt_int32_t Elf32_Sword; /* Signed large integer */
+typedef rt_uint32_t Elf32_Word; /* Unsigned large integer */
+typedef rt_uint16_t Elf32_Half; /* Unsigned medium integer */
+
+/* e_ident[] magic number */
+#define ELFMAG0 0x7f /* e_ident[EI_MAG0] */
+#define ELFMAG1 'E' /* e_ident[EI_MAG1] */
+#define ELFMAG2 'L' /* e_ident[EI_MAG2] */
+#define ELFMAG3 'F' /* e_ident[EI_MAG3] */
+#define 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)
+
+/* ELF Header */
+typedef struct elfhdr {
+ unsigned char e_ident[EI_NIDENT]; /* ELF Identification */
+ Elf32_Half e_type; /* object file type */
+ Elf32_Half e_machine; /* machine */
+ Elf32_Word e_version; /* object file version */
+ Elf32_Addr e_entry; /* virtual entry point */
+ Elf32_Off e_phoff; /* program header table offset */
+ Elf32_Off e_shoff; /* section header table offset */
+ Elf32_Word e_flags; /* processor-specific flags */
+ Elf32_Half e_ehsize; /* ELF header size */
+ Elf32_Half e_phentsize; /* program header entry size */
+ Elf32_Half e_phnum; /* number of program header entries */
+ Elf32_Half e_shentsize; /* section header entry size */
+ Elf32_Half e_shnum; /* number of section header entries */
+ Elf32_Half e_shstrndx; /* section header table's "section
+ header string table" entry offset */
+} Elf32_Ehdr;
+
+/* Section Header */
+typedef struct {
+ Elf32_Word sh_name; /* name - index into section header
+ string table section */
+ Elf32_Word sh_type; /* type */
+ Elf32_Word sh_flags; /* flags */
+ Elf32_Addr sh_addr; /* address */
+ Elf32_Off sh_offset; /* file offset */
+ Elf32_Word sh_size; /* section size */
+ Elf32_Word sh_link; /* section header table index link */
+ Elf32_Word sh_info; /* extra information */
+ Elf32_Word sh_addralign; /* address alignment */
+ Elf32_Word sh_entsize; /* section entry size */
+} Elf32_Shdr;
+
+/* Section names */
+#define ELF_BSS ".bss" /* uninitialized data */
+#define ELF_DATA ".data" /* initialized data */
+#define ELF_DEBUG ".debug" /* debug */
+#define ELF_DYNAMIC ".dynamic" /* dynamic linking information */
+#define ELF_DYNSTR ".dynstr" /* dynamic string table */
+#define ELF_DYNSYM ".dynsym" /* dynamic symbol table */
+#define ELF_FINI ".fini" /* termination code */
+#define ELF_GOT ".got" /* global offset table */
+#define ELF_HASH ".hash" /* symbol hash table */
+#define ELF_INIT ".init" /* initialization code */
+#define ELF_REL_DATA ".rel.data" /* relocation data */
+#define ELF_REL_FINI ".rel.fini" /* relocation termination code */
+#define ELF_REL_INIT ".rel.init" /* relocation initialization code */
+#define ELF_REL_DYN ".rel.dyn" /* relocaltion dynamic link info */
+#define ELF_REL_RODATA ".rel.rodata" /* relocation read-only data */
+#define ELF_REL_TEXT ".rel.text" /* relocation code */
+#define ELF_RODATA ".rodata" /* read-only data */
+#define ELF_SHSTRTAB ".shstrtab" /* section header string table */
+#define ELF_STRTAB ".strtab" /* string table */
+#define ELF_SYMTAB ".symtab" /* symbol table */
+#define ELF_TEXT ".text" /* code */
+
+/* Symbol Table Entry */
+typedef struct elf32_sym {
+ Elf32_Word st_name; /* name - index into string table */
+ Elf32_Addr st_value; /* symbol value */
+ Elf32_Word st_size; /* symbol size */
+ unsigned char st_info; /* type and binding */
+ unsigned char st_other; /* 0 - no defined meaning */
+ Elf32_Half st_shndx; /* section header index */
+} Elf32_Sym;
+
+#define STB_LOCAL 0 /* BIND */
+#define STB_GLOBAL 1
+#define STB_WEAK 2
+#define STB_NUM 3
+
+#define STB_LOPROC 13 /* processor specific range */
+#define STB_HIPROC 15
+
+#define STT_NOTYPE 0 /* symbol type is unspecified */
+#define STT_OBJECT 1 /* data object */
+#define STT_FUNC 2 /* code object */
+#define STT_SECTION 3 /* symbol identifies an ELF section */
+#define STT_FILE 4 /* symbol's name is file name */
+#define STT_COMMON 5 /* common data object */
+#define STT_TLS 6 /* thread-local data object */
+#define STT_NUM 7 /* # defined types in generic range */
+#define STT_LOOS 10 /* OS specific range */
+#define STT_HIOS 12
+#define STT_LOPROC 13 /* processor specific range */
+#define STT_HIPROC 15
+
+
+#define ELF_ST_BIND(info) ((info) >> 4)
+#define ELF_ST_TYPE(info) ((info) & 0xf)
+#define ELF_ST_INFO(bind, type) (((bind)<<4)+((type)&0xf))
+
+/* Relocation entry with implicit addend */
+typedef struct {
+ Elf32_Addr r_offset; /* offset of relocation */
+ Elf32_Word r_info; /* symbol table index and type */
+} Elf32_Rel;
+
+/* Relocation entry with explicit addend */
+typedef struct {
+ Elf32_Addr r_offset; /* offset of relocation */
+ Elf32_Word r_info; /* symbol table index and type */
+ Elf32_Sword r_addend;
+} Elf32_Rela;
+
+/* Extract relocation info - r_info */
+#define ELF32_R_SYM(i) ((i) >> 8)
+#define ELF32_R_TYPE(i) ((unsigned char) (i))
+#define ELF32_R_INFO(s,t) (((s) << 8) + (unsigned char)(t))
+
+/*
+ * Relocation type for arm
+ */
+#define R_ARM_NONE 0
+#define R_ARM_PC24 1
+#define R_ARM_ABS32 2
+#define R_ARM_PLT32 27
+#define R_ARM_CALL 28
+#define R_ARM_JUMP24 29
+
+/* 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;
+
+/* 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 /* relation 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 */
+
+/* Symbol table index */
+#define STN_UNDEF 0 /* undefined */
+
+#endif
diff --git a/src/thread.c b/src/thread.c index 8a2f8a7844..875a00aedb 100644 --- a/src/thread.c +++ b/src/thread.c @@ -19,6 +19,7 @@ * 2006-09-03 Bernard implement rt_thread_detach * 2008-02-16 Bernard fix the rt_thread_timeout bug * 2010-03-21 Bernard change the errno of rt_thread_delay/sleep to RT_EOK. + * 2010-04-11 yi.qiu add module feature */ #include <rtthread.h> @@ -627,4 +628,21 @@ rt_thread_t rt_thread_find(char* name) return thread; } +#ifdef RT_USING_MODULE +#include <rtm.h> +/* some buildin kernel symbol */ +RTM_EXPORT(rt_thread_init) +RTM_EXPORT(rt_thread_detach) +RTM_EXPORT(rt_thread_create) +RTM_EXPORT(rt_thread_self) +RTM_EXPORT(rt_thread_find) +RTM_EXPORT(rt_thread_startup) +RTM_EXPORT(rt_thread_delete) +RTM_EXPORT(rt_thread_yield) +RTM_EXPORT(rt_thread_delay) +RTM_EXPORT(rt_thread_control) +RTM_EXPORT(rt_thread_suspend) +RTM_EXPORT(rt_thread_resume) +RTM_EXPORT(rt_thread_timeout) +#endif /*@}*/ |