2010-04-12 00:44:54 +08:00
|
|
|
/*
|
|
|
|
* File : module.c
|
|
|
|
* This file is part of RT-Thread RTOS
|
2012-03-17 14:43:49 +08:00
|
|
|
* COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
|
2010-04-12 00:44:54 +08:00
|
|
|
*
|
|
|
|
* 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:
|
2011-09-21 11:56:42 +08:00
|
|
|
* Date Author Notes
|
|
|
|
* 2010-01-09 Bernard first version
|
|
|
|
* 2010-04-09 yi.qiu implement based on first version
|
|
|
|
* 2010-10-23 yi.qiu implement module memory allocator
|
|
|
|
* 2011-05-25 yi.qiu implement module hook function
|
|
|
|
* 2011-06-23 yi.qiu rewrite module memory allocator
|
2010-04-12 00:44:54 +08:00
|
|
|
*/
|
2010-09-20 07:43:48 +08:00
|
|
|
|
2011-06-12 18:01:48 +08:00
|
|
|
#include <rthw.h>
|
2010-04-12 00:44:54 +08:00
|
|
|
#include <rtthread.h>
|
2010-09-20 07:43:48 +08:00
|
|
|
#include <rtm.h>
|
2010-04-12 00:44:54 +08:00
|
|
|
|
2010-07-21 08:27:11 +08:00
|
|
|
#include "string.h"
|
2010-04-12 00:44:54 +08:00
|
|
|
#include "kservice.h"
|
|
|
|
|
2010-09-26 00:38:00 +08:00
|
|
|
#ifdef RT_USING_MODULE
|
2010-06-11 18:19:13 +08:00
|
|
|
#include "module.h"
|
2010-04-13 01:37:37 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
#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))
|
2010-04-13 01:37:37 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
#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))
|
2010-04-13 01:37:37 +08:00
|
|
|
|
2011-12-31 16:58:40 +08:00
|
|
|
#define PAGE_COUNT_MAX 256
|
2010-11-01 09:03:50 +08:00
|
|
|
|
2010-11-18 00:17:07 +08:00
|
|
|
/* module memory allocator */
|
|
|
|
struct rt_mem_head
|
|
|
|
{
|
|
|
|
rt_size_t size; /* size of memory block */
|
|
|
|
struct rt_mem_head *next; /* next valid memory block */
|
|
|
|
};
|
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
struct rt_page_info
|
|
|
|
{
|
|
|
|
rt_uint32_t *page_ptr;
|
|
|
|
rt_uint32_t npage;
|
|
|
|
};
|
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
#ifdef RT_USING_SLAB
|
2011-07-05 07:48:07 +08:00
|
|
|
static void *rt_module_malloc_page(rt_size_t npages);
|
2011-09-28 10:10:43 +08:00
|
|
|
static void rt_module_free_page(rt_module_t module, void *page_ptr, rt_size_t npages);
|
|
|
|
#endif
|
2010-12-10 08:20:30 +08:00
|
|
|
|
2010-10-28 09:21:47 +08:00
|
|
|
static rt_module_t rt_current_module = RT_NULL;
|
2011-07-05 07:48:07 +08:00
|
|
|
static struct rt_semaphore mod_sem;
|
|
|
|
static struct rt_module_symtab *_rt_module_symtab_begin = RT_NULL, *_rt_module_symtab_end = RT_NULL;
|
2010-10-19 17:25:00 +08:00
|
|
|
rt_list_t rt_module_symbol_list;
|
2011-07-05 07:48:07 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
static char *_strip_name(const char *string)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
int i = 0, p = 0, q = 0;
|
2011-09-21 11:56:42 +08:00
|
|
|
const char *str = string;
|
|
|
|
char *dest = RT_NULL;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
while (*str != '\n' && *str != '\0')
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
if (*str =='/' ) p = i + 1;
|
2011-12-31 16:58:40 +08:00
|
|
|
if (*str == '.') q = i;
|
2011-07-05 07:48:07 +08:00
|
|
|
str++; i++;
|
|
|
|
}
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
if (p < q)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
int len = q - p;
|
2011-09-21 11:56:42 +08:00
|
|
|
dest = (char *)rt_malloc(len + 1);
|
2011-07-05 07:48:07 +08:00
|
|
|
rt_strncpy(dest, &string[p], len);
|
|
|
|
dest[len] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
return dest;
|
|
|
|
}
|
2010-10-19 17:25:00 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @ingroup SystemInit
|
|
|
|
*
|
2010-11-29 08:04:55 +08:00
|
|
|
* This function will initialize system module
|
2010-10-19 17:25:00 +08:00
|
|
|
*/
|
|
|
|
void rt_system_module_init(void)
|
|
|
|
{
|
2011-05-16 09:18:43 +08:00
|
|
|
#ifdef __GNUC__
|
2010-10-19 17:25:00 +08:00
|
|
|
extern int __rtmsymtab_start;
|
|
|
|
extern int __rtmsymtab_end;
|
2011-05-16 09:18:43 +08:00
|
|
|
|
2010-10-19 17:25:00 +08:00
|
|
|
_rt_module_symtab_begin = (struct rt_module_symtab *)&__rtmsymtab_start;
|
|
|
|
_rt_module_symtab_end = (struct rt_module_symtab *)&__rtmsymtab_end;
|
2011-09-21 11:56:42 +08:00
|
|
|
#elif defined (__CC_ARM)
|
2011-05-16 09:18:43 +08:00
|
|
|
extern int RTMSymTab$$Base;
|
|
|
|
extern int RTMSymTab$$Limit;
|
2011-09-21 11:56:42 +08:00
|
|
|
|
2011-05-16 09:18:43 +08:00
|
|
|
_rt_module_symtab_begin = (struct rt_module_symtab *)&RTMSymTab$$Base;
|
|
|
|
_rt_module_symtab_end = (struct rt_module_symtab *)&RTMSymTab$$Limit;
|
2010-10-28 09:21:47 +08:00
|
|
|
#endif
|
2010-10-19 17:25:00 +08:00
|
|
|
|
|
|
|
rt_list_init(&rt_module_symbol_list);
|
2010-11-18 00:17:07 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
/* initialize heap semaphore */
|
|
|
|
rt_sem_init(&mod_sem, "module", 1, RT_IPC_FLAG_FIFO);
|
|
|
|
|
2010-11-18 00:17:07 +08:00
|
|
|
/* init current module */
|
|
|
|
rt_current_module = RT_NULL;
|
2010-10-19 17:25:00 +08:00
|
|
|
}
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
static rt_uint32_t rt_module_symbol_find(const char *sym_str)
|
2010-10-19 17:25:00 +08:00
|
|
|
{
|
|
|
|
/* find in kernel symbol table */
|
2011-09-21 11:56:42 +08:00
|
|
|
struct rt_module_symtab *index;
|
2010-10-19 17:25:00 +08:00
|
|
|
for (index = _rt_module_symtab_begin; index != _rt_module_symtab_end; index ++)
|
|
|
|
{
|
2011-05-16 09:18:43 +08:00
|
|
|
if (rt_strcmp(index->name, sym_str) == 0)
|
|
|
|
return (rt_uint32_t)index->addr;
|
2010-10-19 17:25:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2010-05-29 22:19:56 +08:00
|
|
|
|
2010-09-13 09:03:09 +08:00
|
|
|
/**
|
|
|
|
* This function will return self module object
|
|
|
|
*
|
2010-09-20 07:43:48 +08:00
|
|
|
* @return the self module object
|
2010-09-13 09:03:09 +08:00
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_module_t rt_module_self(void)
|
2010-09-13 09:03:09 +08:00
|
|
|
{
|
2010-09-20 07:43:48 +08:00
|
|
|
/* return current module */
|
2010-09-13 09:03:09 +08:00
|
|
|
return rt_current_module;
|
|
|
|
}
|
|
|
|
|
2010-09-20 07:43:48 +08:00
|
|
|
/**
|
|
|
|
* This function will set current module object
|
|
|
|
*
|
|
|
|
* @return RT_EOK
|
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_err_t rt_module_set(rt_module_t module)
|
2010-09-20 07:43:48 +08:00
|
|
|
{
|
|
|
|
/* set current module */
|
|
|
|
rt_current_module = module;
|
|
|
|
|
|
|
|
return RT_EOK;
|
|
|
|
}
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
static int rt_module_arm_relocate(struct rt_module *module, Elf32_Rel *rel, Elf32_Addr sym_val)
|
2010-04-12 00:44:54 +08:00
|
|
|
{
|
|
|
|
Elf32_Addr *where, tmp;
|
2011-09-28 10:10:43 +08:00
|
|
|
Elf32_Sword addend, offset;
|
|
|
|
rt_uint32_t upper, lower, sign, j1, j2;
|
2010-04-12 00:44:54 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
where = (Elf32_Addr *)((rt_uint8_t *)module->module_space + rel->r_offset);
|
2010-04-12 00:44:54 +08:00
|
|
|
switch (ELF32_R_TYPE(rel->r_info))
|
|
|
|
{
|
|
|
|
case R_ARM_NONE:
|
|
|
|
break;
|
|
|
|
case R_ARM_ABS32:
|
|
|
|
*where += (Elf32_Addr)sym_val;
|
2011-09-21 11:56:42 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_ARM_ABS32: %x -> %x\n", where, *where));
|
2010-04-12 00:44:54 +08:00
|
|
|
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);
|
2011-09-21 11:56:42 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_ARM_PC24: %x -> %x\n", where, *where));
|
2010-04-12 00:44:54 +08:00
|
|
|
break;
|
2011-09-28 10:10:43 +08:00
|
|
|
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;
|
2010-05-29 22:19:56 +08:00
|
|
|
case R_ARM_V4BX:
|
|
|
|
*where &= 0xf000000f;
|
|
|
|
*where |= 0x01a0f000;
|
|
|
|
break;
|
2010-07-21 08:27:11 +08:00
|
|
|
case R_ARM_GLOB_DAT:
|
|
|
|
case R_ARM_JUMP_SLOT:
|
2010-09-23 19:10:17 +08:00
|
|
|
*where = (Elf32_Addr)sym_val;
|
2011-06-12 18:01:48 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
|
|
|
("R_ARM_JUMP_SLOT: 0x%x -> 0x%x 0x%x\n", where, *where, sym_val));
|
2011-09-28 10:10:43 +08:00
|
|
|
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;
|
2011-12-31 16:58:40 +08:00
|
|
|
#endif
|
2010-12-13 22:17:00 +08:00
|
|
|
case R_ARM_RELATIVE:
|
|
|
|
*where += (Elf32_Addr)sym_val;
|
2011-09-28 10:10:43 +08:00
|
|
|
//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;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
if (!(offset & 1) || offset <= (rt_int32_t)0xff000000 ||
|
2011-12-31 16:58:40 +08:00
|
|
|
offset >= (rt_int32_t)0x01000000)
|
2011-09-28 10:10:43 +08:00
|
|
|
{
|
|
|
|
rt_kprintf("only Thumb addresses allowed\n");
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
return -1;
|
|
|
|
}
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
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);
|
2011-12-31 16:58:40 +08:00
|
|
|
break;
|
2010-04-12 00:44:54 +08:00
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
static void rt_module_init_object_container(struct rt_module *module)
|
2010-04-12 00:44:54 +08:00
|
|
|
{
|
|
|
|
RT_ASSERT(module != RT_NULL);
|
|
|
|
|
2010-11-29 08:04:55 +08:00
|
|
|
/* initialize object container - thread */
|
2010-04-12 00:44:54 +08:00
|
|
|
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
|
2010-11-29 08:04:55 +08:00
|
|
|
/* initialize object container - semaphore */
|
2010-04-12 00:44:54 +08:00
|
|
|
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
|
2010-11-29 08:04:55 +08:00
|
|
|
/* initialize object container - mutex */
|
2010-04-12 00:44:54 +08:00
|
|
|
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_EVENT
|
2010-11-29 08:04:55 +08:00
|
|
|
/* initialize object container - event */
|
2010-04-12 00:44:54 +08:00
|
|
|
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
|
2010-11-29 08:04:55 +08:00
|
|
|
/* initialize object container - mailbox */
|
2010-04-12 00:44:54 +08:00
|
|
|
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
|
2010-11-29 08:04:55 +08:00
|
|
|
/* initialize object container - message queue */
|
2010-04-12 00:44:54 +08:00
|
|
|
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
|
2010-11-29 08:04:55 +08:00
|
|
|
/* initialize object container - memory pool */
|
2010-04-12 00:44:54 +08:00
|
|
|
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
|
2010-11-29 08:04:55 +08:00
|
|
|
/* initialize object container - device */
|
2010-04-12 00:44:54 +08:00
|
|
|
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
|
|
|
|
|
2010-11-29 08:04:55 +08:00
|
|
|
/* initialize object container - timer */
|
2010-04-12 00:44:54 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
#ifdef RT_USING_HOOK
|
|
|
|
static void (*rt_module_load_hook)(rt_module_t module);
|
|
|
|
static void (*rt_module_unload_hook)(rt_module_t module);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @addtogroup Hook
|
|
|
|
*/
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
/*@{*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will set a hook function, which will be invoked when module
|
|
|
|
* be loaded to system.
|
|
|
|
*
|
|
|
|
* @param hook the hook function
|
|
|
|
*/
|
|
|
|
void rt_module_load_sethook(void (*hook)(rt_module_t module))
|
|
|
|
{
|
|
|
|
rt_module_load_hook = hook;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will set a hook function, which will be invoked when module
|
|
|
|
* be unloaded from system.
|
|
|
|
*
|
|
|
|
* @param hook the hook function
|
|
|
|
*/
|
|
|
|
void rt_module_unload_sethook(void (*hook)(rt_module_t module))
|
|
|
|
{
|
|
|
|
rt_module_unload_hook = hook;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*@}*/
|
|
|
|
#endif
|
|
|
|
|
2012-03-17 14:43:49 +08:00
|
|
|
static struct rt_module* _load_shared_object(const char *name, void *module_ptr)
|
2010-04-12 00:44:54 +08:00
|
|
|
{
|
2010-12-19 20:12:23 +08:00
|
|
|
rt_uint8_t *ptr = RT_NULL;
|
2010-10-19 17:25:00 +08:00
|
|
|
rt_module_t module = RT_NULL;
|
|
|
|
rt_bool_t linked = RT_FALSE;
|
2010-12-19 20:12:23 +08:00
|
|
|
rt_uint32_t index, module_size = 0;
|
2010-04-12 00:44:54 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
RT_ASSERT(module_ptr != RT_NULL);
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
if(rt_memcmp(elf_module->e_ident, RTMMAG, SELFMAG) == 0)
|
2010-10-19 17:25:00 +08:00
|
|
|
{
|
2011-09-28 10:10:43 +08:00
|
|
|
/* rtmlinker finished */
|
2010-10-19 17:25:00 +08:00
|
|
|
linked = RT_TRUE;
|
|
|
|
}
|
2010-07-21 08:27:11 +08:00
|
|
|
|
2010-04-12 00:44:54 +08:00
|
|
|
/* get the ELF image size */
|
2010-07-21 08:27:11 +08:00
|
|
|
for (index = 0; index < elf_module->e_phnum; index++)
|
2010-04-12 00:44:54 +08:00
|
|
|
{
|
2010-07-21 08:27:11 +08:00
|
|
|
if(phdr[index].p_type == PT_LOAD)
|
|
|
|
module_size += phdr[index].p_memsz;
|
|
|
|
}
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
if (module_size == 0)
|
2010-09-13 09:03:09 +08:00
|
|
|
{
|
|
|
|
rt_kprintf(" module size error\n");
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2010-09-13 09:03:09 +08:00
|
|
|
return module;
|
|
|
|
}
|
2010-04-12 00:44:54 +08:00
|
|
|
|
|
|
|
/* allocate module */
|
2011-07-05 07:48:07 +08:00
|
|
|
module = (struct rt_module *)rt_object_allocate(RT_Object_Class_Module, name);
|
2012-03-17 14:43:49 +08:00
|
|
|
if (!module)
|
|
|
|
return RT_NULL;
|
2010-04-12 00:44:54 +08:00
|
|
|
|
|
|
|
/* allocate module space */
|
|
|
|
module->module_space = rt_malloc(module_size);
|
|
|
|
if (module->module_space == RT_NULL)
|
|
|
|
{
|
|
|
|
rt_object_delete(&(module->parent));
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2010-04-12 00:44:54 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* zero all space */
|
|
|
|
ptr = module->module_space;
|
|
|
|
rt_memset(ptr, 0, module_size);
|
|
|
|
|
2011-05-16 09:18:43 +08:00
|
|
|
rt_kprintf(" load address at 0x%x\n", ptr);
|
|
|
|
|
2010-07-21 08:27:11 +08:00
|
|
|
for (index = 0; index < elf_module->e_phnum; index++)
|
2010-04-12 00:44:54 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
if (phdr[index].p_type == PT_LOAD)
|
2010-04-12 00:44:54 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_memcpy(ptr, (rt_uint8_t *)elf_module + phdr[index].p_offset, phdr[index].p_filesz);
|
2010-07-21 08:27:11 +08:00
|
|
|
ptr += phdr[index].p_memsz;
|
|
|
|
}
|
|
|
|
}
|
2010-04-12 00:44:54 +08:00
|
|
|
|
|
|
|
/* set module entry */
|
2010-09-23 19:10:17 +08:00
|
|
|
module->module_entry = module->module_space + elf_module->e_entry;
|
2010-07-21 08:27:11 +08:00
|
|
|
|
2010-04-12 00:44:54 +08:00
|
|
|
/* 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;
|
2010-12-19 20:12:23 +08:00
|
|
|
rt_uint8_t *strtab;
|
|
|
|
static rt_bool_t unsolved = RT_FALSE;
|
2010-04-12 00:44:54 +08:00
|
|
|
|
|
|
|
/* get relocate item */
|
2011-09-21 11:56:42 +08:00
|
|
|
rel = (Elf32_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
|
2010-04-12 00:44:54 +08:00
|
|
|
|
2010-12-19 20:12:23 +08:00
|
|
|
/* locate .rel.plt and .rel.dyn section */
|
2011-09-28 10:10:43 +08:00
|
|
|
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));
|
2010-04-12 00:44:54 +08:00
|
|
|
|
|
|
|
/* relocate every items */
|
|
|
|
for (i = 0; i < nr_reloc; i ++)
|
|
|
|
{
|
|
|
|
Elf32_Sym *sym = &symtab[ELF32_R_SYM(rel->r_info)];
|
2011-06-12 18:01:48 +08:00
|
|
|
|
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
|
|
|
("relocate symbol %s shndx %d\n", strtab + sym->st_name, sym->st_shndx));
|
|
|
|
|
2011-12-31 16:58:40 +08:00
|
|
|
if((sym->st_shndx != SHT_NULL) || (ELF_ST_BIND(sym->st_info) == STB_LOCAL))
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_module_arm_relocate(module, rel, (Elf32_Addr)(module->module_space + sym->st_value));
|
|
|
|
else if(!linked)
|
2010-10-19 17:25:00 +08:00
|
|
|
{
|
|
|
|
Elf32_Addr addr;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
2011-09-28 10:10:43 +08:00
|
|
|
("relocate symbol: %s\n", strtab + sym->st_name));
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2010-10-19 17:25:00 +08:00
|
|
|
/* need to resolve symbol in kernel symbol table */
|
2011-09-21 11:56:42 +08:00
|
|
|
addr = rt_module_symbol_find((const char *)(strtab + sym->st_name));
|
2010-10-19 17:25:00 +08:00
|
|
|
if (addr == 0)
|
|
|
|
{
|
|
|
|
rt_kprintf("can't find %s in kernel symbol table\n", strtab + sym->st_name);
|
2010-12-19 20:12:23 +08:00
|
|
|
unsolved = RT_TRUE;
|
2010-10-19 17:25:00 +08:00
|
|
|
}
|
2012-03-17 14:43:49 +08:00
|
|
|
else
|
|
|
|
rt_module_arm_relocate(module, rel, addr);
|
2010-10-19 17:25:00 +08:00
|
|
|
}
|
2010-04-12 00:44:54 +08:00
|
|
|
rel ++;
|
|
|
|
}
|
2010-12-19 20:12:23 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
if (unsolved)
|
2010-12-19 20:12:23 +08:00
|
|
|
{
|
|
|
|
rt_object_delete(&(module->parent));
|
|
|
|
rt_free(module);
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2010-12-19 20:12:23 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
2010-04-12 00:44:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
#if 0
|
|
|
|
for (index = 0; index < elf_module->e_shnum; index ++)
|
2011-12-31 16:58:40 +08:00
|
|
|
{
|
2011-09-28 10:10:43 +08:00
|
|
|
/* find .dynsym section */
|
|
|
|
rt_uint8_t* shstrab = (rt_uint8_t*) module_ptr + shdr[elf_module->e_shstrndx].sh_offset;
|
2011-12-31 16:58:40 +08:00
|
|
|
if (rt_strcmp((const char *)(shstrab + shdr[index].sh_name), ELF_GOT) == 0)
|
|
|
|
{
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_hw_set_got_base(module->module_space + shdr[index].sh_offset);
|
|
|
|
break;
|
2011-12-31 16:58:40 +08:00
|
|
|
}
|
2011-09-28 10:10:43 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-12-19 20:12:23 +08:00
|
|
|
/* construct module symbol table */
|
|
|
|
for (index = 0; index < elf_module->e_shnum; index ++)
|
|
|
|
{
|
|
|
|
/* find .dynsym section */
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_uint8_t *shstrab = (rt_uint8_t *)module_ptr + shdr[elf_module->e_shstrndx].sh_offset;
|
2012-03-17 14:43:49 +08:00
|
|
|
if (rt_strcmp((const char *)(shstrab + shdr[index].sh_name), ELF_DYNSYM) == 0)
|
|
|
|
break;
|
2010-12-19 20:12:23 +08:00
|
|
|
}
|
|
|
|
|
2011-01-05 08:40:46 +08:00
|
|
|
/* found .dynsym section */
|
2011-09-21 11:56:42 +08:00
|
|
|
if (index != elf_module->e_shnum)
|
2010-12-19 20:12:23 +08:00
|
|
|
{
|
|
|
|
int i, count = 0;
|
|
|
|
Elf32_Sym *symtab = RT_NULL;
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_uint8_t *strtab = RT_NULL;
|
2010-12-19 20:12:23 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
symtab =(Elf32_Sym *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
|
2011-12-31 16:58:40 +08:00
|
|
|
strtab = (rt_uint8_t *)module_ptr + shdr[shdr[index].sh_link].sh_offset;
|
2010-12-19 20:12:23 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
for (i=0; i<shdr[index].sh_size/sizeof(Elf32_Sym); i++)
|
2010-12-19 20:12:23 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
if ((ELF_ST_BIND(symtab[i].st_info) == STB_GLOBAL) && (ELF_ST_TYPE(symtab[i].st_info) == STT_FUNC))
|
|
|
|
count ++;
|
2010-12-19 20:12:23 +08:00
|
|
|
}
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
module->symtab = (struct rt_module_symtab *)rt_malloc(count * sizeof(struct rt_module_symtab));
|
2010-12-19 20:12:23 +08:00
|
|
|
module->nsym = count;
|
2011-09-21 11:56:42 +08:00
|
|
|
for (i=0, count=0; i<shdr[index].sh_size/sizeof(Elf32_Sym); i++)
|
2010-12-19 20:12:23 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
if ((ELF_ST_BIND(symtab[i].st_info) == STB_GLOBAL) && (ELF_ST_TYPE(symtab[i].st_info) == STT_FUNC))
|
2010-12-19 20:12:23 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_size_t length = rt_strlen((const char *)(strtab + symtab[i].st_name)) + 1;
|
2010-12-19 20:12:23 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
module->symtab[count].addr = (void *)(module->module_space + symtab[i].st_value);
|
2010-12-19 20:12:23 +08:00
|
|
|
module->symtab[count].name = rt_malloc(length);
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_memset((void *)module->symtab[count].name, 0, length);
|
|
|
|
rt_memcpy((void *)module->symtab[count].name, strtab + symtab[i].st_name, length);
|
|
|
|
count ++;
|
2010-12-19 20:12:23 +08:00
|
|
|
}
|
|
|
|
}
|
2011-09-28 10:10:43 +08:00
|
|
|
}
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
return module;
|
|
|
|
}
|
|
|
|
|
2012-03-17 14:43:49 +08:00
|
|
|
static struct rt_module* _load_relocated_object(const char *name, void *module_ptr)
|
2011-09-28 10:10:43 +08:00
|
|
|
{
|
|
|
|
rt_uint32_t index, rodata_addr = 0, bss_addr = 0, data_addr = 0;
|
|
|
|
rt_uint32_t module_addr = 0, module_size = 0;
|
2012-03-17 14:43:49 +08:00
|
|
|
struct rt_module *module = RT_NULL;
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_uint8_t *ptr, *strtab, *shstrab;
|
|
|
|
rt_bool_t linked = RT_FALSE;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
if(rt_memcmp(elf_module->e_ident, RTMMAG, SELFMAG) == 0)
|
|
|
|
{
|
|
|
|
/* rtmlinker finished */
|
|
|
|
linked = RT_TRUE;
|
|
|
|
}
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
/* 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;
|
2011-12-31 16:58:40 +08:00
|
|
|
}
|
2011-09-28 10:10:43 +08:00
|
|
|
/* 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;
|
2011-12-31 16:58:40 +08:00
|
|
|
}
|
2011-09-28 10:10:43 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* no text, data and bss on image */
|
2012-03-17 14:43:49 +08:00
|
|
|
if (module_size == 0)
|
|
|
|
return RT_NULL;
|
2011-09-28 10:10:43 +08:00
|
|
|
|
|
|
|
/* allocate module */
|
2012-03-17 14:43:49 +08:00
|
|
|
module = (struct rt_module *)rt_object_allocate(RT_Object_Class_Module, (const char *)name);
|
|
|
|
if (module == RT_NULL)
|
|
|
|
return RT_NULL;
|
2011-09-28 10:10:43 +08:00
|
|
|
|
|
|
|
/* allocate module space */
|
|
|
|
module->module_space = rt_malloc(module_size);
|
|
|
|
if (module->module_space == RT_NULL)
|
|
|
|
{
|
|
|
|
rt_object_delete(&(module->parent));
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
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 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);
|
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,("load text 0x%x, size %d\n", ptr, shdr[index].sh_size));
|
|
|
|
ptr += shdr[index].sh_size;
|
|
|
|
}
|
2010-11-22 09:24:37 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
/* 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;
|
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,("load rodata 0x%x, size %d, rodata 0x%x\n", ptr, shdr[index].sh_size, *(rt_uint32_t*)data_addr));
|
|
|
|
ptr += shdr[index].sh_size;
|
|
|
|
}
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
/* load data section */
|
|
|
|
if (IS_PROG(shdr[index]) && IS_AW(shdr[index]))
|
|
|
|
{
|
2011-12-31 16:58:40 +08:00
|
|
|
rt_memcpy(ptr, (rt_uint8_t*)elf_module + shdr[index].sh_offset, shdr[index].sh_size);
|
2011-09-28 10:10:43 +08:00
|
|
|
data_addr = (rt_uint32_t)ptr;
|
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,("load data 0x%x, size %d, data 0x%x\n", 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;
|
2011-12-31 16:58:40 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,("load bss 0x%x, size %d,\n", ptr, shdr[index].sh_size));
|
2011-09-28 10:10:43 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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_DEBUG_LOG(RT_DEBUG_MODULE,("relocate symbol: %s\n", strtab + sym->st_name));
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
if (sym->st_shndx != STN_UNDEF)
|
2011-12-31 16:58:40 +08:00
|
|
|
{
|
|
|
|
if((ELF_ST_TYPE(sym->st_info) == STT_SECTION)
|
2011-09-28 10:10:43 +08:00
|
|
|
|| (ELF_ST_TYPE(sym->st_info) == STT_OBJECT))
|
2011-12-31 16:58:40 +08:00
|
|
|
{
|
2011-09-28 10:10:43 +08:00
|
|
|
if (rt_strncmp(shstrab + shdr[sym->st_shndx].sh_name, ELF_RODATA, 8) == 0)
|
|
|
|
{
|
|
|
|
/* relocate rodata section */
|
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,("rodata\n"));
|
|
|
|
rt_module_arm_relocate(module, rel,(Elf32_Addr)(rodata_addr + sym->st_value));
|
|
|
|
}
|
|
|
|
else if(strncmp(shstrab + shdr[sym->st_shndx].sh_name, ELF_BSS, 5) == 0)
|
|
|
|
{
|
2011-12-31 16:58:40 +08:00
|
|
|
/* relocate bss section */
|
2011-09-28 10:10:43 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,("bss\n"));
|
|
|
|
rt_module_arm_relocate(module, rel, (Elf32_Addr)bss_addr + sym->st_value);
|
|
|
|
}
|
|
|
|
else if(strncmp(shstrab + shdr[sym->st_shndx].sh_name, ELF_DATA, 6) == 0)
|
|
|
|
{
|
2011-12-31 16:58:40 +08:00
|
|
|
/* relocate data section */
|
2011-09-28 10:10:43 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,("data\n"));
|
|
|
|
rt_module_arm_relocate(module, rel, (Elf32_Addr)data_addr + sym->st_value);
|
2011-12-31 16:58:40 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-09-28 10:10:43 +08:00
|
|
|
else if(ELF_ST_TYPE(sym->st_info) == STT_FUNC )
|
2011-12-31 16:58:40 +08:00
|
|
|
{
|
2011-09-28 10:10:43 +08:00
|
|
|
/* relocate function */
|
|
|
|
rt_module_arm_relocate(module, rel,
|
2011-12-31 16:58:40 +08:00
|
|
|
(Elf32_Addr)((rt_uint8_t*)module->module_space - module_addr + sym->st_value));
|
2011-09-28 10:10:43 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Elf32_Addr addr;
|
|
|
|
|
|
|
|
if(ELF32_R_TYPE(rel->r_info) != R_ARM_V4BX)
|
2011-12-31 16:58:40 +08:00
|
|
|
{
|
2011-09-28 10:10:43 +08:00
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,("relocate symbol: %s\n", strtab + sym->st_name));
|
|
|
|
/* need to resolve symbol in kernel symbol table */
|
|
|
|
addr = rt_module_symbol_find(strtab + sym->st_name);
|
|
|
|
if (addr != (Elf32_Addr)RT_NULL)
|
|
|
|
{
|
|
|
|
rt_module_arm_relocate(module, rel, addr);
|
|
|
|
RT_DEBUG_LOG(RT_DEBUG_MODULE,("symbol addr 0x%x\n", addr));
|
2011-12-31 16:58:40 +08:00
|
|
|
}
|
2012-03-17 14:43:49 +08:00
|
|
|
else
|
|
|
|
rt_kprintf("can't find %s in kernel symbol table\n", strtab + sym->st_name);
|
2011-09-28 10:10:43 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
rt_module_arm_relocate(module, rel, addr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rel ++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return module;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This function will load a module from memory and create a thread for it
|
|
|
|
*
|
|
|
|
* @param name the name of module, which shall be unique
|
|
|
|
* @param module_ptr the memory address of module image
|
|
|
|
*
|
|
|
|
* @return the module object
|
|
|
|
*/
|
2012-03-17 14:43:49 +08:00
|
|
|
rt_module_t rt_module_load(const char *name, void *module_ptr)
|
2011-09-28 10:10:43 +08:00
|
|
|
{
|
|
|
|
rt_module_t module;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
RT_DEBUG_NOT_IN_INTERRUPT;
|
|
|
|
|
|
|
|
rt_kprintf("rt_module_load: %s ,", name);
|
|
|
|
|
|
|
|
/* 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");
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check ELF class */
|
|
|
|
if(elf_module->e_ident[EI_CLASS] != ELFCLASS32)
|
|
|
|
{
|
|
|
|
rt_kprintf(" module class error\n");
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
if(elf_module->e_type == ET_REL)
|
|
|
|
{
|
|
|
|
module = _load_relocated_object(name, module_ptr);
|
|
|
|
}
|
|
|
|
else if(elf_module->e_type == ET_DYN)
|
|
|
|
{
|
|
|
|
module = _load_shared_object(name, module_ptr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
rt_kprintf("unsupported elf type\n");
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-17 14:43:49 +08:00
|
|
|
if(module == RT_NULL)
|
|
|
|
return RT_NULL;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2010-04-12 00:44:54 +08:00
|
|
|
/* init module object container */
|
|
|
|
rt_module_init_object_container(module);
|
2010-11-22 09:24:37 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
/* increase module reference count */
|
|
|
|
module->nref ++;
|
2010-11-22 09:24:37 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
if (elf_module->e_entry != 0)
|
2010-11-22 09:24:37 +08:00
|
|
|
{
|
|
|
|
/* init module memory allocator */
|
2010-11-24 09:27:45 +08:00
|
|
|
module->mem_list = RT_NULL;
|
2011-07-05 07:48:07 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
#ifdef RT_USING_SLAB
|
2011-07-05 07:48:07 +08:00
|
|
|
/* create page array */
|
|
|
|
module->page_array = (void *)rt_malloc(PAGE_COUNT_MAX * sizeof(struct rt_page_info));
|
|
|
|
module->page_cnt = 0;
|
2011-09-28 10:10:43 +08:00
|
|
|
#endif
|
|
|
|
|
2010-11-22 09:24:37 +08:00
|
|
|
/* create module thread */
|
2010-11-23 09:20:20 +08:00
|
|
|
module->stack_size = 2048;
|
2011-07-05 07:48:07 +08:00
|
|
|
module->thread_priority = 25;
|
2010-11-22 09:24:37 +08:00
|
|
|
module->module_thread = rt_thread_create(name,
|
|
|
|
module->module_entry, RT_NULL,
|
|
|
|
module->stack_size,
|
|
|
|
module->thread_priority, 10);
|
|
|
|
|
|
|
|
module->module_thread->module_id = (void*)module;
|
2011-07-05 07:48:07 +08:00
|
|
|
module->parent.flag = RT_MODULE_FLAG_WITHENTRY;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2010-11-22 09:24:37 +08:00
|
|
|
/* startup module thread */
|
|
|
|
rt_thread_startup(module->module_thread);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* without entry point */
|
|
|
|
module->parent.flag |= RT_MODULE_FLAG_WITHOUTENTRY;
|
|
|
|
}
|
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
#ifdef RT_USING_HOOK
|
2011-09-21 11:56:42 +08:00
|
|
|
if (rt_module_load_hook != RT_NULL)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
rt_module_load_hook(module);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-07-21 08:27:11 +08:00
|
|
|
return module;
|
2010-05-29 22:19:56 +08:00
|
|
|
}
|
|
|
|
|
2010-09-23 19:10:17 +08:00
|
|
|
#ifdef RT_USING_DFS
|
|
|
|
#include <dfs_posix.h>
|
|
|
|
/**
|
2010-11-29 08:04:55 +08:00
|
|
|
* This function will load a module from a file
|
2010-09-23 19:10:17 +08:00
|
|
|
*
|
2011-12-31 16:58:40 +08:00
|
|
|
* @param path the full path of application module
|
2010-09-23 19:10:17 +08:00
|
|
|
*
|
|
|
|
* @return the module object
|
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_module_t rt_module_open(const char *path)
|
2010-09-23 19:10:17 +08:00
|
|
|
{
|
|
|
|
int fd, length;
|
2011-09-21 11:56:42 +08:00
|
|
|
struct rt_module *module;
|
2010-10-22 07:54:55 +08:00
|
|
|
struct stat s;
|
2011-10-11 21:17:54 +08:00
|
|
|
char *buffer, *offset_ptr;
|
2011-01-05 08:40:46 +08:00
|
|
|
|
2011-06-15 07:59:42 +08:00
|
|
|
RT_DEBUG_NOT_IN_INTERRUPT;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2011-01-05 08:40:46 +08:00
|
|
|
/* check parameters */
|
2011-07-05 07:48:07 +08:00
|
|
|
RT_ASSERT(path != RT_NULL);
|
2011-01-05 08:40:46 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
if (stat(path, &s) !=0)
|
2010-11-29 21:11:18 +08:00
|
|
|
{
|
2011-07-05 21:43:52 +08:00
|
|
|
rt_kprintf("access %s failed\n", path);
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2010-11-29 21:11:18 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
2010-09-23 19:10:17 +08:00
|
|
|
buffer = (char *)rt_malloc(s.st_size);
|
2010-11-29 21:11:18 +08:00
|
|
|
if (buffer == RT_NULL)
|
|
|
|
{
|
|
|
|
rt_kprintf("out of memory\n");
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2010-11-29 21:11:18 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
offset_ptr = buffer;
|
2011-07-05 07:48:07 +08:00
|
|
|
fd = open(path, O_RDONLY, 0);
|
2010-11-29 21:11:18 +08:00
|
|
|
if (fd < 0)
|
|
|
|
{
|
2011-07-05 21:43:52 +08:00
|
|
|
rt_kprintf("open %s failed\n", path);
|
2010-11-29 21:11:18 +08:00
|
|
|
rt_free(buffer);
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2010-11-29 21:11:18 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
length = read(fd, offset_ptr, 4096);
|
|
|
|
if (length > 0)
|
|
|
|
{
|
|
|
|
offset_ptr += length;
|
|
|
|
}
|
|
|
|
}while (length > 0);
|
|
|
|
|
|
|
|
/* close fd */
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
if ((rt_uint32_t)offset_ptr - (rt_uint32_t)buffer != s.st_size)
|
2010-09-23 19:10:17 +08:00
|
|
|
{
|
|
|
|
rt_kprintf("check: read file failed\n");
|
|
|
|
rt_free(buffer);
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2010-09-23 19:10:17 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
2011-07-05 07:48:07 +08:00
|
|
|
|
2011-10-11 21:17:54 +08:00
|
|
|
module = rt_module_load(path, (void *)buffer);
|
2010-09-23 19:10:17 +08:00
|
|
|
rt_free(buffer);
|
|
|
|
|
|
|
|
return module;
|
|
|
|
}
|
2010-11-18 00:17:07 +08:00
|
|
|
|
|
|
|
#if defined(RT_USING_FINSH)
|
|
|
|
#include <finsh.h>
|
2010-11-29 21:29:51 +08:00
|
|
|
FINSH_FUNCTION_EXPORT_ALIAS(rt_module_open, exec, exec module from file);
|
2010-11-18 00:17:07 +08:00
|
|
|
#endif
|
2010-09-23 19:10:17 +08:00
|
|
|
#endif
|
|
|
|
|
2010-09-13 09:03:09 +08:00
|
|
|
/**
|
2011-09-21 11:56:42 +08:00
|
|
|
* This function will unload a module from memory and release resources
|
2010-09-13 09:03:09 +08:00
|
|
|
*
|
|
|
|
* @param module the module to be unloaded
|
|
|
|
*
|
|
|
|
* @return the operation status, RT_EOK on OK; -RT_ERROR on error
|
|
|
|
*/
|
|
|
|
rt_err_t rt_module_unload(rt_module_t module)
|
2010-04-12 00:44:54 +08:00
|
|
|
{
|
2010-12-19 20:12:23 +08:00
|
|
|
int i;
|
2011-09-21 11:56:42 +08:00
|
|
|
struct rt_object *object;
|
2010-09-25 23:30:25 +08:00
|
|
|
struct rt_list_node *list;
|
2010-05-29 22:19:56 +08:00
|
|
|
|
2011-06-15 07:59:42 +08:00
|
|
|
RT_DEBUG_NOT_IN_INTERRUPT;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2010-05-29 22:19:56 +08:00
|
|
|
/* check parameter */
|
|
|
|
RT_ASSERT(module != RT_NULL);
|
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
rt_kprintf("rt_module_unload: %s\n", module->parent.name);
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2010-11-23 09:20:20 +08:00
|
|
|
/* module has entry point */
|
2011-09-21 11:56:42 +08:00
|
|
|
if ((module->parent.flag & RT_MODULE_FLAG_WITHOUTENTRY) != RT_MODULE_FLAG_WITHOUTENTRY)
|
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
/* suspend module main thread */
|
2011-09-21 11:56:42 +08:00
|
|
|
if (module->module_thread != RT_NULL)
|
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
if (module->module_thread->stat == RT_THREAD_READY)
|
|
|
|
rt_thread_suspend(module->module_thread);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* delete threads */
|
2011-09-21 11:56:42 +08:00
|
|
|
list = &module->module_object[RT_Object_Class_Thread].object_list;
|
|
|
|
while (list->next != list)
|
2010-04-21 01:00:51 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
object = rt_list_entry(list->next, struct rt_object, list);
|
|
|
|
if (rt_object_is_systemobject(object) == RT_EOK)
|
|
|
|
{
|
2010-11-29 22:29:13 +08:00
|
|
|
/* detach static object */
|
2010-11-22 09:24:37 +08:00
|
|
|
rt_thread_detach((rt_thread_t)object);
|
|
|
|
}
|
|
|
|
else
|
2011-09-21 11:56:42 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete dynamic object */
|
|
|
|
rt_thread_delete((rt_thread_t)object);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2010-09-25 23:30:25 +08:00
|
|
|
}
|
2010-11-22 09:24:37 +08:00
|
|
|
|
2010-09-25 23:30:25 +08:00
|
|
|
#ifdef RT_USING_SEMAPHORE
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete semaphores */
|
|
|
|
list = &module->module_object[RT_Object_Class_Thread].object_list;
|
2011-09-21 11:56:42 +08:00
|
|
|
while (list->next != list)
|
2010-09-25 23:30:25 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
object = rt_list_entry(list->next, struct rt_object, list);
|
|
|
|
if (rt_object_is_systemobject(object) == RT_EOK)
|
|
|
|
{
|
2010-11-29 22:29:13 +08:00
|
|
|
/* detach static object */
|
2010-11-22 09:24:37 +08:00
|
|
|
rt_sem_detach((rt_sem_t)object);
|
|
|
|
}
|
|
|
|
else
|
2011-09-21 11:56:42 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete dynamic object */
|
|
|
|
rt_sem_delete((rt_sem_t)object);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2010-09-25 23:30:25 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef RT_USING_MUTEX
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete mutexs*/
|
|
|
|
list = &module->module_object[RT_Object_Class_Mutex].object_list;
|
2011-09-21 11:56:42 +08:00
|
|
|
while (list->next != list)
|
2010-09-25 23:30:25 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
object = rt_list_entry(list->next, struct rt_object, list);
|
|
|
|
if (rt_object_is_systemobject(object) == RT_EOK)
|
|
|
|
{
|
2010-11-29 22:29:13 +08:00
|
|
|
/* detach static object */
|
2010-11-22 09:24:37 +08:00
|
|
|
rt_mutex_detach((rt_mutex_t)object);
|
|
|
|
}
|
|
|
|
else
|
2011-09-21 11:56:42 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete dynamic object */
|
|
|
|
rt_mutex_delete((rt_mutex_t)object);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2010-09-25 23:30:25 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef RT_USING_EVENT
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete mailboxs */
|
|
|
|
list = &module->module_object[RT_Object_Class_Event].object_list;
|
2011-09-21 11:56:42 +08:00
|
|
|
while (list->next != list)
|
2010-09-25 23:30:25 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
object = rt_list_entry(list->next, struct rt_object, list);
|
|
|
|
if (rt_object_is_systemobject(object) == RT_EOK)
|
|
|
|
{
|
2010-11-29 22:29:13 +08:00
|
|
|
/* detach static object */
|
2010-11-22 09:24:37 +08:00
|
|
|
rt_event_detach((rt_event_t)object);
|
|
|
|
}
|
|
|
|
else
|
2011-09-21 11:56:42 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete dynamic object */
|
|
|
|
rt_event_delete((rt_event_t)object);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2010-04-21 01:00:51 +08:00
|
|
|
}
|
2010-09-25 23:30:25 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef RT_USING_MAILBOX
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete mailboxs */
|
|
|
|
list = &module->module_object[RT_Object_Class_MailBox].object_list;
|
2011-09-21 11:56:42 +08:00
|
|
|
while (list->next != list)
|
2010-09-25 23:30:25 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
object = rt_list_entry(list->next, struct rt_object, list);
|
|
|
|
if (rt_object_is_systemobject(object) == RT_EOK)
|
|
|
|
{
|
2010-11-29 22:29:13 +08:00
|
|
|
/* detach static object */
|
2010-11-22 09:24:37 +08:00
|
|
|
rt_mb_detach((rt_mailbox_t)object);
|
|
|
|
}
|
|
|
|
else
|
2011-09-21 11:56:42 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete dynamic object */
|
|
|
|
rt_mb_delete((rt_mailbox_t)object);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2010-09-25 23:30:25 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef RT_USING_MESSAGEQUEUE
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete msgqueues */
|
2011-09-21 11:56:42 +08:00
|
|
|
list = &module->module_object[RT_Object_Class_MessageQueue].object_list;
|
|
|
|
while (list->next != list)
|
2010-09-25 23:30:25 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
object = rt_list_entry(list->next, struct rt_object, list);
|
|
|
|
if (rt_object_is_systemobject(object) == RT_EOK)
|
|
|
|
{
|
2010-11-29 22:29:13 +08:00
|
|
|
/* detach static object */
|
2010-11-22 09:24:37 +08:00
|
|
|
rt_mq_detach((rt_mq_t)object);
|
|
|
|
}
|
|
|
|
else
|
2011-09-21 11:56:42 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete dynamic object */
|
|
|
|
rt_mq_delete((rt_mq_t)object);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2010-09-25 23:30:25 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef RT_USING_MEMPOOL
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete mempools */
|
|
|
|
list = &module->module_object[RT_Object_Class_MemPool].object_list;
|
2011-09-21 11:56:42 +08:00
|
|
|
while (list->next != list)
|
2010-09-25 23:30:25 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
object = rt_list_entry(list->next, struct rt_object, list);
|
|
|
|
if (rt_object_is_systemobject(object) == RT_EOK)
|
|
|
|
{
|
2010-11-29 22:29:13 +08:00
|
|
|
/* detach static object */
|
2010-11-22 09:24:37 +08:00
|
|
|
rt_mp_detach((rt_mp_t)object);
|
|
|
|
}
|
|
|
|
else
|
2011-09-21 11:56:42 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete dynamic object */
|
|
|
|
rt_mp_delete((rt_mp_t)object);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2010-09-25 23:30:25 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef RT_USING_DEVICE
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete devices */
|
|
|
|
list = &module->module_object[RT_Object_Class_Device].object_list;
|
2011-09-21 11:56:42 +08:00
|
|
|
while (list->next != list)
|
2010-11-22 09:24:37 +08:00
|
|
|
{
|
|
|
|
object = rt_list_entry(list->next, struct rt_object, list);
|
|
|
|
rt_device_unregister((rt_device_t)object);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2010-09-25 23:30:25 +08:00
|
|
|
#endif
|
|
|
|
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete timers */
|
|
|
|
list = &module->module_object[RT_Object_Class_Timer].object_list;
|
2011-09-21 11:56:42 +08:00
|
|
|
while (list->next != list)
|
2010-09-25 23:30:25 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
object = rt_list_entry(list->next, struct rt_object, list);
|
|
|
|
if (rt_object_is_systemobject(object) == RT_EOK)
|
|
|
|
{
|
2010-11-29 22:29:13 +08:00
|
|
|
/* detach static object */
|
2010-11-22 09:24:37 +08:00
|
|
|
rt_timer_detach((rt_timer_t)object);
|
|
|
|
}
|
|
|
|
else
|
2011-09-21 11:56:42 +08:00
|
|
|
{
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete dynamic object */
|
|
|
|
rt_timer_delete((rt_timer_t)object);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
|
|
|
}
|
2011-07-05 07:48:07 +08:00
|
|
|
}
|
2010-11-22 09:24:37 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
#ifdef RT_USING_SLAB
|
2012-03-17 14:43:49 +08:00
|
|
|
if (module->page_cnt > 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
struct rt_page_info *page = (struct rt_page_info *)module->page_array;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
|
|
|
rt_kprintf("warning: module memory still hasn't been free finished\n");
|
2010-11-22 09:24:37 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
while(module->page_cnt != 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_module_free_page(module, page[0].page_ptr, page[0].npage);
|
2011-12-31 16:58:40 +08:00
|
|
|
}
|
2010-11-01 09:03:50 +08:00
|
|
|
}
|
2011-09-28 10:10:43 +08:00
|
|
|
#endif
|
2011-09-21 11:56:42 +08:00
|
|
|
|
2010-11-01 09:03:50 +08:00
|
|
|
/* release module space memory */
|
2010-04-21 01:00:51 +08:00
|
|
|
rt_free(module->module_space);
|
2010-11-22 09:24:37 +08:00
|
|
|
|
2010-12-19 20:12:23 +08:00
|
|
|
/* release module symbol table */
|
2012-03-17 14:43:49 +08:00
|
|
|
for (i=0; i<module->nsym; i++)
|
|
|
|
rt_free((void *)module->symtab[i].name);
|
|
|
|
if (module->symtab != RT_NULL)
|
|
|
|
rt_free(module->symtab);
|
2011-01-05 08:40:46 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
#ifdef RT_USING_HOOK
|
2011-09-21 11:56:42 +08:00
|
|
|
if (rt_module_unload_hook != RT_NULL)
|
|
|
|
{
|
|
|
|
rt_module_unload_hook(module);
|
|
|
|
}
|
2011-07-05 07:48:07 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
rt_free(module->page_array);
|
|
|
|
|
2010-11-22 09:24:37 +08:00
|
|
|
/* delete module object */
|
2010-09-25 23:30:25 +08:00
|
|
|
rt_object_delete((rt_object_t)module);
|
2010-09-13 09:03:09 +08:00
|
|
|
|
|
|
|
return RT_EOK;
|
2010-04-12 00:44:54 +08:00
|
|
|
}
|
|
|
|
|
2010-09-13 09:03:09 +08:00
|
|
|
/**
|
|
|
|
* This function will find the specified module.
|
|
|
|
*
|
|
|
|
* @param name the name of module finding
|
|
|
|
*
|
|
|
|
* @return the module
|
|
|
|
*/
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_module_t rt_module_find(const char *name)
|
2010-04-12 00:44:54 +08:00
|
|
|
{
|
2010-05-04 10:03:11 +08:00
|
|
|
struct rt_object_information *information;
|
2011-09-21 11:56:42 +08:00
|
|
|
struct rt_object *object;
|
|
|
|
struct rt_list_node *node;
|
2010-04-12 00:44:54 +08:00
|
|
|
|
2010-05-04 10:03:11 +08:00
|
|
|
extern struct rt_object_information rt_object_container[];
|
|
|
|
|
2011-06-15 07:59:42 +08:00
|
|
|
RT_DEBUG_NOT_IN_INTERRUPT;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2010-05-04 10:03:11 +08:00
|
|
|
/* enter critical */
|
|
|
|
rt_enter_critical();
|
|
|
|
|
|
|
|
/* try to find device object */
|
2010-11-22 09:24:37 +08:00
|
|
|
information = &rt_object_container[RT_Object_Class_Module];
|
2010-05-04 10:03:11 +08:00
|
|
|
for (node = information->object_list.next; node != &(information->object_list); node = node->next)
|
|
|
|
{
|
|
|
|
object = rt_list_entry(node, struct rt_object, list);
|
|
|
|
if (rt_strncmp(object->name, name, RT_NAME_MAX) == 0)
|
|
|
|
{
|
|
|
|
/* leave critical */
|
|
|
|
rt_exit_critical();
|
|
|
|
|
|
|
|
return (rt_module_t)object;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* leave critical */
|
|
|
|
rt_exit_critical();
|
|
|
|
|
|
|
|
/* not found */
|
|
|
|
return RT_NULL;
|
2010-04-12 00:44:54 +08:00
|
|
|
}
|
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
#ifdef RT_USING_SLAB
|
|
|
|
/*
|
|
|
|
* This function will allocate the numbers page with specified size
|
|
|
|
* in page memory.
|
|
|
|
*
|
|
|
|
* @param size the size of memory to be allocated.
|
|
|
|
* @note this function is used for RT-Thread Application Module
|
|
|
|
*/
|
|
|
|
static void *rt_module_malloc_page(rt_size_t npages)
|
2010-10-28 09:21:47 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
void *chunk;
|
2011-07-05 07:48:07 +08:00
|
|
|
struct rt_page_info *page;
|
2010-11-18 00:17:07 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
chunk = rt_page_alloc(npages);
|
2012-03-17 14:43:49 +08:00
|
|
|
if (chunk == RT_NULL)
|
|
|
|
return RT_NULL;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
page = (struct rt_page_info *)rt_current_module->page_array;
|
2011-07-05 07:48:07 +08:00
|
|
|
page[rt_current_module->page_cnt].page_ptr = chunk;
|
2011-09-21 11:56:42 +08:00
|
|
|
page[rt_current_module->page_cnt].npage = npages;
|
|
|
|
rt_current_module->page_cnt ++;
|
2010-11-18 00:17:07 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
RT_ASSERT(rt_current_module->page_cnt <= PAGE_COUNT_MAX);
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_kprintf("rt_module_malloc_page 0x%x %d\n", chunk, npages);
|
2011-09-21 11:56:42 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
return chunk;
|
|
|
|
}
|
2010-11-18 00:17:07 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
/*
|
2011-09-21 11:56:42 +08:00
|
|
|
* This function will release the previously allocated memory page
|
2011-07-05 07:48:07 +08:00
|
|
|
* by rt_malloc_page.
|
|
|
|
*
|
|
|
|
* @param page_ptr the page address to be released.
|
|
|
|
* @param npages the number of page shall be released.
|
2011-12-31 16:58:40 +08:00
|
|
|
*
|
2011-07-05 07:48:07 +08:00
|
|
|
* @note this function is used for RT-Thread Application Module
|
|
|
|
*/
|
2011-09-28 10:10:43 +08:00
|
|
|
static void rt_module_free_page(rt_module_t module, void *page_ptr, rt_size_t npages)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
int i, index;
|
|
|
|
struct rt_page_info *page;
|
2010-11-18 00:17:07 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_kprintf("rt_module_free_page 0x%x %d\n", page_ptr, npages);
|
2011-07-05 07:48:07 +08:00
|
|
|
rt_page_free(page_ptr, npages);
|
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
page = (struct rt_page_info*)module->page_array;
|
2011-07-05 07:48:07 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
for(i=0; i<module->page_cnt; i++)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
if (page[i].page_ptr == page_ptr)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
if (page[i].npage == npages + 1)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
page[i].page_ptr += npages * RT_MM_PAGE_SIZE / sizeof(rt_uint32_t);
|
2011-09-28 10:10:43 +08:00
|
|
|
page[i].npage -= npages;
|
2011-07-05 07:48:07 +08:00
|
|
|
}
|
2011-09-28 10:10:43 +08:00
|
|
|
else if(page[i].npage == npages)
|
2011-12-31 16:58:40 +08:00
|
|
|
{
|
2011-09-28 10:10:43 +08:00
|
|
|
for(index=i; index<module->page_cnt-1; index++)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
page[index].page_ptr = page[index + 1].page_ptr;
|
|
|
|
page[index].npage = page[index + 1].npage;
|
|
|
|
}
|
2011-09-28 10:10:43 +08:00
|
|
|
page[module->page_cnt - 1].page_ptr = RT_NULL;
|
|
|
|
page[module->page_cnt - 1].npage = 0;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
|
|
|
module->page_cnt--;
|
2011-07-05 07:48:07 +08:00
|
|
|
}
|
2012-03-17 14:43:49 +08:00
|
|
|
else
|
|
|
|
RT_ASSERT(RT_FALSE);
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_current_module->page_cnt--;
|
2011-07-05 21:43:52 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* should not be get here */
|
|
|
|
RT_ASSERT(RT_FALSE);
|
2010-11-18 00:17:07 +08:00
|
|
|
}
|
2010-10-28 09:21:47 +08:00
|
|
|
|
|
|
|
/*
|
2010-11-29 08:04:55 +08:00
|
|
|
rt_module_malloc - allocate memory block in free list
|
2010-10-28 09:21:47 +08:00
|
|
|
*/
|
|
|
|
void *rt_module_malloc(rt_size_t size)
|
|
|
|
{
|
2011-07-05 07:48:07 +08:00
|
|
|
struct rt_mem_head *b, *n, *up;
|
2010-10-28 09:21:47 +08:00
|
|
|
struct rt_mem_head **prev;
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_uint32_t npage;
|
2010-10-28 09:21:47 +08:00
|
|
|
rt_size_t nunits;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2011-06-15 07:59:42 +08:00
|
|
|
RT_DEBUG_NOT_IN_INTERRUPT;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
nunits = (size + sizeof(struct rt_mem_head) -1)/sizeof(struct rt_mem_head) + 1;
|
2010-10-28 09:21:47 +08:00
|
|
|
|
|
|
|
RT_ASSERT(size != 0);
|
|
|
|
RT_ASSERT(nunits != 0);
|
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
rt_sem_take(&mod_sem, RT_WAITING_FOREVER);
|
2010-10-28 09:21:47 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
for (prev = (struct rt_mem_head **)&rt_current_module->mem_list; (b = *prev) != RT_NULL; prev = &(b->next))
|
2010-11-25 00:10:23 +08:00
|
|
|
{
|
2010-10-28 09:21:47 +08:00
|
|
|
if (b->size > nunits)
|
|
|
|
{
|
2010-11-29 08:04:55 +08:00
|
|
|
/* split memory */
|
2010-10-28 09:21:47 +08:00
|
|
|
n = b + nunits;
|
|
|
|
n->next = b->next;
|
|
|
|
n->size = b->size - nunits;
|
|
|
|
b->size = nunits;
|
|
|
|
*prev = n;
|
2011-07-05 07:48:07 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_kprintf("rt_module_malloc 0x%x, %d\n",b + 1, size);
|
2011-07-05 07:48:07 +08:00
|
|
|
rt_sem_release(&mod_sem);
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
return (void *)(b + 1);
|
2010-10-28 09:21:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (b->size == nunits)
|
|
|
|
{
|
|
|
|
/* this node fit, remove this node */
|
|
|
|
*prev = b->next;
|
2011-07-05 07:48:07 +08:00
|
|
|
|
|
|
|
rt_kprintf("rt_module_malloc 0x%x, %d\n",b + 1, size);
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
rt_sem_release(&mod_sem);
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
return (void *)(b + 1);
|
2010-10-28 09:21:47 +08:00
|
|
|
}
|
2011-07-05 07:48:07 +08:00
|
|
|
}
|
2010-10-28 09:21:47 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
/* allocate pages from system heap */
|
|
|
|
npage = (size + sizeof(struct rt_mem_head) + RT_MM_PAGE_SIZE - 1)/RT_MM_PAGE_SIZE;
|
2012-03-17 14:43:49 +08:00
|
|
|
if ((up = (struct rt_mem_head *)rt_module_malloc_page(npage)) == RT_NULL)
|
|
|
|
return RT_NULL;
|
2011-07-05 07:48:07 +08:00
|
|
|
|
|
|
|
up->size = npage * RT_MM_PAGE_SIZE / sizeof(struct rt_mem_head);
|
2011-12-31 16:58:40 +08:00
|
|
|
|
|
|
|
for (prev = (struct rt_mem_head **)&rt_current_module->mem_list; (b = *prev) != RT_NULL; prev = &(b->next))
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
2012-03-17 14:43:49 +08:00
|
|
|
if (b > up + up->size)
|
|
|
|
break;
|
2010-10-28 09:21:47 +08:00
|
|
|
}
|
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
up->next = b;
|
|
|
|
*prev = up;
|
|
|
|
|
|
|
|
rt_sem_release(&mod_sem);
|
2011-09-21 11:56:42 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
return rt_module_malloc(size);
|
2010-10-28 09:21:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-07-05 07:48:07 +08:00
|
|
|
rt_module_free - free memory block in free list
|
2010-10-28 09:21:47 +08:00
|
|
|
*/
|
|
|
|
void rt_module_free(rt_module_t module, void *addr)
|
|
|
|
{
|
2011-07-05 07:48:07 +08:00
|
|
|
struct rt_mem_head *b, *n, *r;
|
2010-10-28 09:21:47 +08:00
|
|
|
struct rt_mem_head **prev;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2011-06-15 07:59:42 +08:00
|
|
|
RT_DEBUG_NOT_IN_INTERRUPT;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2010-11-25 00:10:23 +08:00
|
|
|
RT_ASSERT(addr);
|
2010-10-28 09:21:47 +08:00
|
|
|
RT_ASSERT((((rt_uint32_t)addr) & (sizeof(struct rt_mem_head) -1)) == 0);
|
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_kprintf("rt_module_free 0x%x\n", addr);
|
2011-09-21 11:56:42 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
rt_sem_take(&mod_sem, RT_WAITING_FOREVER);
|
2011-09-21 11:56:42 +08:00
|
|
|
|
2010-10-28 09:21:47 +08:00
|
|
|
n = (struct rt_mem_head *)addr - 1;
|
2010-11-24 09:27:45 +08:00
|
|
|
prev = (struct rt_mem_head **)&module->mem_list;
|
2010-10-28 09:21:47 +08:00
|
|
|
|
|
|
|
while ((b = *prev) != RT_NULL)
|
2011-09-21 11:56:42 +08:00
|
|
|
{
|
2010-10-28 09:21:47 +08:00
|
|
|
RT_ASSERT(b->size > 0);
|
|
|
|
RT_ASSERT(b > n || b + b->size <= n);
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
if (b + b->size == n && ((rt_uint32_t)n % RT_MM_PAGE_SIZE != 0))
|
2010-10-28 09:21:47 +08:00
|
|
|
{
|
2011-07-05 07:48:07 +08:00
|
|
|
if (b + (b->size + n->size) == b->next)
|
2010-10-28 09:21:47 +08:00
|
|
|
{
|
2011-07-05 07:48:07 +08:00
|
|
|
b->size += b->next->size + n->size;
|
|
|
|
b->next = b->next->next;
|
2010-10-28 09:21:47 +08:00
|
|
|
}
|
2012-03-17 14:43:49 +08:00
|
|
|
else
|
|
|
|
b->size += n->size;
|
2011-07-05 07:48:07 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
if ((rt_uint32_t)b % RT_MM_PAGE_SIZE == 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
int npage = b->size * sizeof(struct rt_page_info) / RT_MM_PAGE_SIZE;
|
2011-09-21 11:56:42 +08:00
|
|
|
if (npage > 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
if ((b->size * sizeof(struct rt_page_info) % RT_MM_PAGE_SIZE) != 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
rt_size_t nunits = npage * RT_MM_PAGE_SIZE / sizeof(struct rt_mem_head);
|
|
|
|
/* split memory */
|
|
|
|
r = b + nunits;
|
|
|
|
r->next = b->next;
|
|
|
|
r->size = b->size - nunits;
|
|
|
|
*prev = r;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
*prev = b->next;
|
2011-07-05 07:48:07 +08:00
|
|
|
}
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_module_free_page(module, b, npage);
|
2011-07-05 07:48:07 +08:00
|
|
|
}
|
2011-12-31 16:58:40 +08:00
|
|
|
}
|
2010-10-28 09:21:47 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
/* unlock */
|
|
|
|
rt_sem_release(&mod_sem);
|
2011-09-21 11:56:42 +08:00
|
|
|
|
2010-10-28 09:21:47 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (b == n + n->size)
|
|
|
|
{
|
|
|
|
n->size = b->size + n->size;
|
|
|
|
n->next = b->next;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
if ((rt_uint32_t)n % RT_MM_PAGE_SIZE == 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
int npage = n->size * sizeof(struct rt_page_info) / RT_MM_PAGE_SIZE;
|
2011-09-21 11:56:42 +08:00
|
|
|
if (npage > 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
2011-09-21 11:56:42 +08:00
|
|
|
if ((n->size * sizeof(struct rt_page_info) % RT_MM_PAGE_SIZE) != 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
rt_size_t nunits = npage * RT_MM_PAGE_SIZE / sizeof(struct rt_mem_head);
|
|
|
|
/* split memory */
|
|
|
|
r = n + nunits;
|
|
|
|
r->next = n->next;
|
|
|
|
r->size = n->size - nunits;
|
|
|
|
*prev = r;
|
|
|
|
}
|
2011-09-21 11:56:42 +08:00
|
|
|
else *prev = n->next;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_module_free_page(module, n, npage);
|
2011-07-05 07:48:07 +08:00
|
|
|
}
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2011-07-05 07:48:07 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
*prev = n;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* unlock */
|
|
|
|
rt_sem_release(&mod_sem);
|
2010-10-28 09:21:47 +08:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
2012-03-17 14:43:49 +08:00
|
|
|
if (b > n + n->size)
|
|
|
|
break;
|
2010-10-28 09:21:47 +08:00
|
|
|
|
|
|
|
prev = &(b->next);
|
|
|
|
}
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
if ((rt_uint32_t)n % RT_MM_PAGE_SIZE == 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
int npage = n->size * sizeof(struct rt_page_info) / RT_MM_PAGE_SIZE;
|
2011-09-21 11:56:42 +08:00
|
|
|
if (npage > 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
2011-09-28 10:10:43 +08:00
|
|
|
rt_module_free_page(module, n, npage);
|
2011-09-21 11:56:42 +08:00
|
|
|
if (n->size % RT_MM_PAGE_SIZE != 0)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
rt_size_t nunits = npage * RT_MM_PAGE_SIZE / sizeof(struct rt_mem_head);
|
|
|
|
/* split memory */
|
|
|
|
r = n + nunits;
|
|
|
|
r->next = b;
|
|
|
|
r->size = n->size - nunits;
|
|
|
|
*prev = r;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-12-31 16:58:40 +08:00
|
|
|
*prev = b;
|
|
|
|
}
|
|
|
|
}
|
2011-07-05 07:48:07 +08:00
|
|
|
}
|
2011-09-21 11:56:42 +08:00
|
|
|
else
|
|
|
|
{
|
2011-07-05 07:48:07 +08:00
|
|
|
n->next = b;
|
|
|
|
*prev = n;
|
|
|
|
}
|
2010-11-01 09:03:50 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
/* unlock */
|
2011-09-21 11:56:42 +08:00
|
|
|
rt_sem_release(&mod_sem);
|
2010-10-28 09:21:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
rt_module_realloc - realloc memory block in free list
|
|
|
|
*/
|
|
|
|
void *rt_module_realloc(void *ptr, rt_size_t size)
|
|
|
|
{
|
2010-11-01 09:03:50 +08:00
|
|
|
struct rt_mem_head *b, *p, *prev, *tmpp;
|
|
|
|
rt_size_t nunits;
|
2010-10-28 09:21:47 +08:00
|
|
|
|
2011-06-15 07:59:42 +08:00
|
|
|
RT_DEBUG_NOT_IN_INTERRUPT;
|
2011-06-12 18:01:48 +08:00
|
|
|
|
2012-03-17 14:43:49 +08:00
|
|
|
if (!ptr)
|
|
|
|
return rt_module_malloc(size);
|
2010-11-01 09:03:50 +08:00
|
|
|
if (size == 0)
|
|
|
|
{
|
|
|
|
rt_module_free(rt_current_module, ptr);
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2010-11-01 09:03:50 +08:00
|
|
|
return RT_NULL;
|
|
|
|
}
|
2010-10-28 09:21:47 +08:00
|
|
|
|
2010-11-01 09:03:50 +08:00
|
|
|
nunits = (size + sizeof(struct rt_mem_head) - 1) / sizeof(struct rt_mem_head) + 1;
|
|
|
|
b = (struct rt_mem_head *)ptr - 1;
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
if (nunits <= b->size)
|
|
|
|
{
|
|
|
|
/* new size is smaller or equal then before */
|
2012-03-17 14:43:49 +08:00
|
|
|
if (nunits == b->size)
|
|
|
|
return ptr;
|
2011-09-21 11:56:42 +08:00
|
|
|
else
|
2010-11-01 09:03:50 +08:00
|
|
|
{
|
|
|
|
p = b + nunits;
|
|
|
|
p->size = b->size - nunits;
|
|
|
|
b->size = nunits;
|
|
|
|
rt_module_free(rt_current_module, (void *)(p + 1));
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2010-11-01 09:03:50 +08:00
|
|
|
return (void *)(b + 1);
|
|
|
|
}
|
|
|
|
}
|
2011-09-21 11:56:42 +08:00
|
|
|
else
|
|
|
|
{
|
2010-11-01 09:03:50 +08:00
|
|
|
/* more space then required */
|
2010-11-24 09:27:45 +08:00
|
|
|
prev = (struct rt_mem_head *)rt_current_module->mem_list;
|
2012-03-17 14:43:49 +08:00
|
|
|
for (p = prev->next; p != (b->size + b) && p != RT_NULL; prev = p, p = p->next)
|
|
|
|
break;
|
2010-11-01 09:03:50 +08:00
|
|
|
|
|
|
|
/* available block after ap in freelist */
|
|
|
|
if (p != RT_NULL && (p->size >= (nunits - (b->size))) && p == (b + b->size))
|
|
|
|
{
|
|
|
|
/* perfect match */
|
|
|
|
if (p->size == (nunits - (b->size)))
|
|
|
|
{
|
|
|
|
b->size = nunits;
|
|
|
|
prev->next = p->next;
|
|
|
|
}
|
|
|
|
else /* more space then required, split block*/
|
|
|
|
{
|
|
|
|
/* pointer to old header */
|
2011-09-21 11:56:42 +08:00
|
|
|
tmpp = p;
|
2010-11-01 09:03:50 +08:00
|
|
|
p = b + nunits;
|
|
|
|
|
|
|
|
/* restoring old pointer */
|
|
|
|
p->next = tmpp->next;
|
|
|
|
|
|
|
|
/* new size for p */
|
2011-09-21 11:56:42 +08:00
|
|
|
p->size = tmpp->size + b->size - nunits;
|
2010-11-01 09:03:50 +08:00
|
|
|
b->size = nunits;
|
|
|
|
prev->next = p;
|
|
|
|
}
|
2010-11-24 09:27:45 +08:00
|
|
|
rt_current_module->mem_list = (void *)prev;
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
return (void *)(b + 1);
|
2010-11-01 09:03:50 +08:00
|
|
|
}
|
|
|
|
else /* allocate new memory and copy old data */
|
|
|
|
{
|
|
|
|
if ((p = rt_module_malloc(size)) == RT_NULL) return RT_NULL;
|
|
|
|
rt_memmove(p, (b+1), ((b->size) * sizeof(struct rt_mem_head)));
|
|
|
|
rt_module_free(rt_current_module, (void *)(b + 1));
|
2012-03-17 14:43:49 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
return (void *)(p);
|
2010-11-01 09:03:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-07-05 07:48:07 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef RT_USING_FINSH
|
|
|
|
#include <finsh.h>
|
2012-03-17 14:43:49 +08:00
|
|
|
void list_memlist(const char *name)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
rt_module_t module;
|
|
|
|
struct rt_mem_head **prev;
|
|
|
|
struct rt_mem_head *b;
|
2011-12-31 16:58:40 +08:00
|
|
|
|
2011-07-05 07:48:07 +08:00
|
|
|
module = rt_module_find(name);
|
2012-03-17 14:43:49 +08:00
|
|
|
if (module == RT_NULL)
|
|
|
|
return;
|
2011-07-05 07:48:07 +08:00
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
for (prev = (struct rt_mem_head **)&module->mem_list; (b = *prev) != RT_NULL; prev = &(b->next))
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
rt_kprintf("0x%x--%d\n", b, b->size * sizeof(struct rt_mem_head));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
FINSH_FUNCTION_EXPORT(list_memlist, list module free memory information)
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
void list_mempage(const char *name)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
rt_module_t module;
|
|
|
|
struct rt_page_info *page;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
module = rt_module_find(name);
|
2012-03-17 14:43:49 +08:00
|
|
|
if (module == RT_NULL)
|
|
|
|
return;
|
2011-07-05 07:48:07 +08:00
|
|
|
|
|
|
|
page = (struct rt_page_info*)module->page_array;
|
|
|
|
|
2011-09-21 11:56:42 +08:00
|
|
|
for (i=0; i<module->page_cnt; i++)
|
2011-07-05 07:48:07 +08:00
|
|
|
{
|
|
|
|
rt_kprintf("0x%x--%d\n", page[i].page_ptr, page[i].npage);
|
2011-09-21 11:56:42 +08:00
|
|
|
}
|
2011-07-05 07:48:07 +08:00
|
|
|
}
|
|
|
|
FINSH_FUNCTION_EXPORT(list_mempage, list module using memory page information)
|
|
|
|
#endif
|
2010-10-28 09:21:47 +08:00
|
|
|
|
2010-04-12 00:44:54 +08:00
|
|
|
#endif
|