fixed a compiling error related to RT_DEBUG_LOG and fixed the coding style in module.c
git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2473 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
dzzxzz@gmail.com
parent
7363cd15b9
commit
7151de3e2d
348
src/module.c
348
src/module.c
@ -55,7 +55,9 @@ struct rt_page_info
|
||||
};
|
||||
|
||||
static void *rt_module_malloc_page(rt_size_t npages);
|
||||
static void rt_module_free_page(rt_module_t module, void *page_ptr, rt_size_t npages);
|
||||
static void rt_module_free_page(rt_module_t module,
|
||||
void *page_ptr,
|
||||
rt_size_t npages);
|
||||
|
||||
static struct rt_semaphore mod_sem;
|
||||
#endif
|
||||
@ -94,7 +96,10 @@ static rt_uint32_t rt_module_symbol_find(const char *sym_str)
|
||||
{
|
||||
/* find in kernel symbol table */
|
||||
struct rt_module_symtab *index;
|
||||
for (index = _rt_module_symtab_begin; index != _rt_module_symtab_end; index ++)
|
||||
|
||||
for (index = _rt_module_symtab_begin;
|
||||
index != _rt_module_symtab_end;
|
||||
index ++)
|
||||
{
|
||||
if (rt_strcmp(index->name, sym_str) == 0)
|
||||
return (rt_uint32_t)index->addr;
|
||||
@ -113,13 +118,15 @@ rt_module_t rt_module_self(void)
|
||||
rt_thread_t tid;
|
||||
|
||||
tid = rt_thread_self();
|
||||
if (tid == RT_NULL) return RT_NULL;
|
||||
if (tid == RT_NULL)
|
||||
return RT_NULL;
|
||||
|
||||
/* return current module */
|
||||
return (rt_module_t)tid->module_id;
|
||||
}
|
||||
|
||||
static int rt_module_arm_relocate(struct rt_module *module, Elf32_Rel *rel,
|
||||
static int rt_module_arm_relocate(struct rt_module *module,
|
||||
Elf32_Rel *rel,
|
||||
Elf32_Addr sym_val)
|
||||
{
|
||||
Elf32_Addr *where, tmp;
|
||||
@ -133,7 +140,8 @@ static int rt_module_arm_relocate(struct rt_module *module, Elf32_Rel *rel,
|
||||
break;
|
||||
case R_ARM_ABS32:
|
||||
*where += (Elf32_Addr)sym_val;
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_ARM_ABS32: %x -> %x\n", where, *where));
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("R_ARM_ABS32: %x -> %x\n", where, *where));
|
||||
break;
|
||||
case R_ARM_PC24:
|
||||
case R_ARM_PLT32:
|
||||
@ -145,11 +153,13 @@ static int rt_module_arm_relocate(struct rt_module *module, Elf32_Rel *rel,
|
||||
tmp = sym_val - (Elf32_Addr)where + (addend << 2);
|
||||
tmp >>= 2;
|
||||
*where = (*where & 0xff000000) | (tmp & 0x00ffffff);
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_ARM_PC24: %x -> %x\n", where, *where));
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("R_ARM_PC24: %x -> %x\n", where, *where));
|
||||
break;
|
||||
case R_ARM_REL32:
|
||||
*where += sym_val - (Elf32_Addr)where;
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,("R_ARM_REL32: %x -> %x, sym %x, offset %x\n",
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("R_ARM_REL32: %x -> %x, sym %x, offset %x\n",
|
||||
where, *where, sym_val, rel->r_offset));
|
||||
break;
|
||||
case R_ARM_V4BX:
|
||||
@ -160,20 +170,23 @@ static int rt_module_arm_relocate(struct rt_module *module, Elf32_Rel *rel,
|
||||
case R_ARM_JUMP_SLOT:
|
||||
*where = (Elf32_Addr)sym_val;
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("R_ARM_JUMP_SLOT: 0x%x -> 0x%x 0x%x\n", where, *where, sym_val));
|
||||
("R_ARM_JUMP_SLOT: 0x%x -> 0x%x 0x%x\n",
|
||||
where, *where, sym_val));
|
||||
break;
|
||||
#if 0 /* To do */
|
||||
case R_ARM_GOT_BREL:
|
||||
temp = (Elf32_Addr)sym_val;
|
||||
*where = (Elf32_Addr)&temp;
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("R_ARM_GOT_BREL: 0x%x -> 0x%x 0x%x\n", where, *where, sym_val));
|
||||
("R_ARM_GOT_BREL: 0x%x -> 0x%x 0x%x\n",
|
||||
where, *where, sym_val));
|
||||
break;
|
||||
#endif
|
||||
case R_ARM_RELATIVE:
|
||||
*where = (Elf32_Addr)sym_val + *where;
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("R_ARM_RELATIVE: 0x%x -> 0x%x 0x%x\n", where, *where, sym_val));
|
||||
("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:
|
||||
@ -183,7 +196,8 @@ static int rt_module_arm_relocate(struct rt_module *module, Elf32_Rel *rel,
|
||||
sign = (upper >> 10) & 1;
|
||||
j1 = (lower >> 13) & 1;
|
||||
j2 = (lower >> 11) & 1;
|
||||
offset = (sign << 24) | ((~(j1 ^ sign) & 1) << 23) |
|
||||
offset = (sign << 24) |
|
||||
((~(j1 ^ sign) & 1) << 23) |
|
||||
((~(j2 ^ sign) & 1) << 22) |
|
||||
((upper & 0x03ff) << 12) |
|
||||
((lower & 0x07ff) << 1);
|
||||
@ -191,7 +205,8 @@ static int rt_module_arm_relocate(struct rt_module *module, Elf32_Rel *rel,
|
||||
offset -= 0x02000000;
|
||||
offset += sym_val - (Elf32_Addr)where;
|
||||
|
||||
if (!(offset & 1) || offset <= (rt_int32_t)0xff000000 ||
|
||||
if (!(offset & 1) ||
|
||||
offset <= (rt_int32_t)0xff000000 ||
|
||||
offset >= (rt_int32_t)0x01000000)
|
||||
{
|
||||
rt_kprintf("Module: Only Thumb addresses allowed\n");
|
||||
@ -202,7 +217,8 @@ static int rt_module_arm_relocate(struct rt_module *module, Elf32_Rel *rel,
|
||||
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) |
|
||||
*(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) |
|
||||
@ -323,7 +339,8 @@ void rt_module_unload_sethook(void (*hook)(rt_module_t module))
|
||||
/*@}*/
|
||||
#endif
|
||||
|
||||
static struct rt_module* _load_shared_object(const char *name, void *module_ptr)
|
||||
static struct rt_module *_load_shared_object(const char *name,
|
||||
void *module_ptr)
|
||||
{
|
||||
rt_uint8_t *ptr = RT_NULL;
|
||||
rt_module_t module = RT_NULL;
|
||||
@ -332,7 +349,7 @@ static struct rt_module* _load_shared_object(const char *name, void *module_ptr)
|
||||
|
||||
RT_ASSERT(module_ptr != RT_NULL);
|
||||
|
||||
if(rt_memcmp(elf_module->e_ident, RTMMAG, SELFMAG) == 0)
|
||||
if (rt_memcmp(elf_module->e_ident, RTMMAG, SELFMAG) == 0)
|
||||
{
|
||||
/* rtmlinker finished */
|
||||
linked = RT_TRUE;
|
||||
@ -341,19 +358,22 @@ static struct rt_module* _load_shared_object(const char *name, void *module_ptr)
|
||||
/* get the ELF image size */
|
||||
for (index = 0; index < elf_module->e_phnum; index++)
|
||||
{
|
||||
if(phdr[index].p_type == PT_LOAD)
|
||||
if (phdr[index].p_type == PT_LOAD)
|
||||
module_size += phdr[index].p_memsz;
|
||||
}
|
||||
|
||||
if (module_size == 0)
|
||||
{
|
||||
rt_kprintf("Module: size error\n");
|
||||
|
||||
return RT_NULL;
|
||||
}
|
||||
|
||||
/* allocate module */
|
||||
module = (struct rt_module *)rt_object_allocate(RT_Object_Class_Module, name);
|
||||
if (!module) return RT_NULL;
|
||||
module = (struct rt_module *)rt_object_allocate(RT_Object_Class_Module,
|
||||
name);
|
||||
if (!module)
|
||||
return RT_NULL;
|
||||
|
||||
module->nref = 0;
|
||||
|
||||
@ -393,33 +413,35 @@ static struct rt_module* _load_shared_object(const char *name, void *module_ptr)
|
||||
rt_uint8_t *strtab;
|
||||
static rt_bool_t unsolved = RT_FALSE;
|
||||
|
||||
if (!IS_REL(shdr[index])) continue;
|
||||
if (!IS_REL(shdr[index]))
|
||||
continue;
|
||||
|
||||
/* get relocate item */
|
||||
rel = (Elf32_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
|
||||
|
||||
/* locate .rel.plt and .rel.dyn section */
|
||||
symtab =(Elf32_Sym *) ((rt_uint8_t*)module_ptr +
|
||||
symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr +
|
||||
shdr[shdr[index].sh_link].sh_offset);
|
||||
strtab = (rt_uint8_t*) module_ptr +
|
||||
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));
|
||||
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 shndx %d\n",
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("relocate symbol %s shndx %d\n",
|
||||
strtab + sym->st_name, sym->st_shndx));
|
||||
|
||||
if((sym->st_shndx != SHT_NULL) ||
|
||||
if ((sym->st_shndx != SHT_NULL) ||
|
||||
(ELF_ST_BIND(sym->st_info) == STB_LOCAL))
|
||||
{
|
||||
rt_module_arm_relocate(module, rel,
|
||||
(Elf32_Addr)(module->module_space + sym->st_value));
|
||||
}
|
||||
else if(!linked)
|
||||
else if (!linked)
|
||||
{
|
||||
Elf32_Addr addr;
|
||||
|
||||
@ -453,7 +475,8 @@ static struct rt_module* _load_shared_object(const char *name, void *module_ptr)
|
||||
{
|
||||
/* find .dynsym section */
|
||||
rt_uint8_t *shstrab;
|
||||
shstrab = (rt_uint8_t *)module_ptr + shdr[elf_module->e_shstrndx].sh_offset;
|
||||
shstrab = (rt_uint8_t *)module_ptr +
|
||||
shdr[elf_module->e_shstrndx].sh_offset;
|
||||
if (rt_strcmp((const char *)(shstrab + shdr[index].sh_name), ELF_DYNSYM) == 0)
|
||||
break;
|
||||
}
|
||||
@ -483,7 +506,8 @@ static struct rt_module* _load_shared_object(const char *name, void *module_ptr)
|
||||
rt_size_t length;
|
||||
|
||||
if ((ELF_ST_BIND(symtab[i].st_info) != STB_GLOBAL) ||
|
||||
(ELF_ST_TYPE(symtab[i].st_info) != STT_FUNC)) continue;
|
||||
(ELF_ST_TYPE(symtab[i].st_info) != STT_FUNC))
|
||||
continue;
|
||||
|
||||
length = rt_strlen((const char *)(strtab + symtab[i].st_name)) + 1;
|
||||
|
||||
@ -492,7 +516,8 @@ static struct rt_module* _load_shared_object(const char *name, void *module_ptr)
|
||||
module->symtab[count].name = rt_malloc(length);
|
||||
rt_memset((void *)module->symtab[count].name, 0, length);
|
||||
rt_memcpy((void *)module->symtab[count].name,
|
||||
strtab + symtab[i].st_name, length);
|
||||
strtab + symtab[i].st_name,
|
||||
length);
|
||||
count ++;
|
||||
}
|
||||
}
|
||||
@ -500,7 +525,8 @@ static struct rt_module* _load_shared_object(const char *name, void *module_ptr)
|
||||
return module;
|
||||
}
|
||||
|
||||
static struct rt_module* _load_relocated_object(const char *name, void *module_ptr)
|
||||
static struct rt_module* _load_relocated_object(const char *name,
|
||||
void *module_ptr)
|
||||
{
|
||||
rt_uint32_t index, rodata_addr = 0, bss_addr = 0, data_addr = 0;
|
||||
rt_uint32_t module_addr = 0, module_size = 0;
|
||||
@ -508,7 +534,7 @@ static struct rt_module* _load_relocated_object(const char *name, void *module_p
|
||||
rt_uint8_t *ptr, *strtab, *shstrab;
|
||||
|
||||
/* get the ELF image size */
|
||||
for (index = 0; index < elf_module->e_shnum; index++)
|
||||
for (index = 0; index < elf_module->e_shnum; index ++)
|
||||
{
|
||||
/* text */
|
||||
if (IS_PROG(shdr[index]) && IS_AX(shdr[index]))
|
||||
@ -538,8 +564,8 @@ static struct rt_module* _load_relocated_object(const char *name, void *module_p
|
||||
return RT_NULL;
|
||||
|
||||
/* allocate module */
|
||||
module = (struct rt_module *)rt_object_allocate(RT_Object_Class_Module,
|
||||
(const char *)name);
|
||||
module = (struct rt_module *)
|
||||
rt_object_allocate(RT_Object_Class_Module, (const char *)name);
|
||||
if (module == RT_NULL)
|
||||
return RT_NULL;
|
||||
|
||||
@ -558,14 +584,16 @@ static struct rt_module* _load_relocated_object(const char *name, void *module_p
|
||||
rt_memset(ptr, 0, module_size);
|
||||
|
||||
/* load text and data section */
|
||||
for (index = 0; index < elf_module->e_shnum; index++)
|
||||
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,
|
||||
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",
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("load text 0x%x, size %d\n",
|
||||
ptr, shdr[index].sh_size));
|
||||
ptr += shdr[index].sh_size;
|
||||
}
|
||||
@ -573,22 +601,26 @@ static struct rt_module* _load_relocated_object(const char *name, void *module_p
|
||||
/* load rodata section */
|
||||
if (IS_PROG(shdr[index]) && IS_ALLOC(shdr[index]))
|
||||
{
|
||||
rt_memcpy(ptr, (rt_uint8_t*)elf_module + shdr[index].sh_offset,
|
||||
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));
|
||||
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;
|
||||
}
|
||||
|
||||
/* load data section */
|
||||
if (IS_PROG(shdr[index]) && IS_AW(shdr[index]))
|
||||
{
|
||||
rt_memcpy(ptr, (rt_uint8_t*)elf_module + shdr[index].sh_offset,
|
||||
rt_memcpy(ptr,
|
||||
(rt_uint8_t *)elf_module + shdr[index].sh_offset,
|
||||
shdr[index].sh_size);
|
||||
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));
|
||||
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;
|
||||
}
|
||||
|
||||
@ -597,14 +629,15 @@ static struct rt_module* _load_relocated_object(const char *name, void *module_p
|
||||
{
|
||||
rt_memset(ptr, 0, shdr[index].sh_size);
|
||||
bss_addr = (rt_uint32_t)ptr;
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,("load bss 0x%x, size %d,\n",
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("load bss 0x%x, size %d,\n",
|
||||
ptr, shdr[index].sh_size));
|
||||
}
|
||||
}
|
||||
|
||||
/* set module entry */
|
||||
module->module_entry = (rt_uint8_t*)module->module_space +
|
||||
elf_module->e_entry - module_addr;
|
||||
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 ++)
|
||||
@ -613,80 +646,83 @@ static struct rt_module* _load_relocated_object(const char *name, void *module_p
|
||||
Elf32_Sym *symtab;
|
||||
Elf32_Rel *rel;
|
||||
|
||||
if (!IS_REL(shdr[index])) continue;
|
||||
if (!IS_REL(shdr[index]))
|
||||
continue;
|
||||
|
||||
/* get relocate item */
|
||||
rel = (Elf32_Rel *) ((rt_uint8_t*)module_ptr + shdr[index].sh_offset);
|
||||
rel = (Elf32_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
|
||||
|
||||
/* locate .dynsym and .dynstr */
|
||||
symtab =(Elf32_Sym *) ((rt_uint8_t*)module_ptr +
|
||||
symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr +
|
||||
shdr[shdr[index].sh_link].sh_offset);
|
||||
strtab = (rt_uint8_t*) module_ptr +
|
||||
strtab = (rt_uint8_t *)module_ptr +
|
||||
shdr[shdr[shdr[index].sh_link].sh_link].sh_offset;
|
||||
shstrab = (rt_uint8_t*) module_ptr +
|
||||
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));
|
||||
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));
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("relocate symbol: %s\n", strtab + sym->st_name));
|
||||
|
||||
if (sym->st_shndx != STN_UNDEF)
|
||||
{
|
||||
if((ELF_ST_TYPE(sym->st_info) == STT_SECTION)
|
||||
|| (ELF_ST_TYPE(sym->st_info) == STT_OBJECT))
|
||||
if ((ELF_ST_TYPE(sym->st_info) == STT_SECTION) ||
|
||||
(ELF_ST_TYPE(sym->st_info) == STT_OBJECT))
|
||||
{
|
||||
if (rt_strncmp((const char*)(shstrab +
|
||||
if (rt_strncmp((const char *)(shstrab +
|
||||
shdr[sym->st_shndx].sh_name), ELF_RODATA, 8) == 0)
|
||||
{
|
||||
/* relocate rodata section */
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,("rodata\n"));
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("rodata\n"));
|
||||
rt_module_arm_relocate(module, rel,
|
||||
(Elf32_Addr)(rodata_addr + sym->st_value));
|
||||
}
|
||||
else if(rt_strncmp((const char*)
|
||||
else if (rt_strncmp((const char*)
|
||||
(shstrab + shdr[sym->st_shndx].sh_name), ELF_BSS, 5) == 0)
|
||||
{
|
||||
/* relocate bss section */
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,("bss\n"));
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("bss\n"));
|
||||
rt_module_arm_relocate(module, rel,
|
||||
(Elf32_Addr)bss_addr + sym->st_value);
|
||||
}
|
||||
else if(rt_strncmp((const char*)(shstrab + shdr[sym->st_shndx].sh_name),
|
||||
else if (rt_strncmp((const char *)(shstrab + shdr[sym->st_shndx].sh_name),
|
||||
ELF_DATA, 6) == 0)
|
||||
{
|
||||
/* relocate data section */
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,("data\n"));
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("data\n"));
|
||||
rt_module_arm_relocate(module, rel,
|
||||
(Elf32_Addr)data_addr + sym->st_value);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if(ELF_ST_TYPE(sym->st_info) == STT_FUNC )
|
||||
else if (ELF_ST_TYPE(sym->st_info) == STT_FUNC)
|
||||
{
|
||||
/* relocate function */
|
||||
rt_module_arm_relocate(module, rel, (Elf32_Addr)((rt_uint8_t*)
|
||||
rt_module_arm_relocate(module, rel, (Elf32_Addr)((rt_uint8_t *)
|
||||
module->module_space - module_addr + sym->st_value));
|
||||
}
|
||||
else
|
||||
{
|
||||
Elf32_Addr addr;
|
||||
|
||||
if(ELF32_R_TYPE(rel->r_info) != R_ARM_V4BX)
|
||||
if (ELF32_R_TYPE(rel->r_info) != R_ARM_V4BX)
|
||||
{
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,("relocate symbol: %s\n",
|
||||
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((const char*)(strtab + sym->st_name));
|
||||
addr = rt_module_symbol_find((const char *)(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));
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("symbol addr 0x%x\n", addr));
|
||||
}
|
||||
else
|
||||
rt_kprintf("Module: can't find %s in kernel symbol table\n",
|
||||
@ -719,11 +755,11 @@ rt_module_t rt_module_load(const char *name, void *module_ptr)
|
||||
|
||||
RT_DEBUG_NOT_IN_INTERRUPT;
|
||||
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,("rt_module_load: %s ,", name));
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("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)
|
||||
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");
|
||||
|
||||
@ -731,18 +767,18 @@ rt_module_t rt_module_load(const char *name, void *module_ptr)
|
||||
}
|
||||
|
||||
/* check ELF class */
|
||||
if(elf_module->e_ident[EI_CLASS] != ELFCLASS32)
|
||||
if (elf_module->e_ident[EI_CLASS] != ELFCLASS32)
|
||||
{
|
||||
rt_kprintf("Module: ELF class error\n");
|
||||
|
||||
return RT_NULL;
|
||||
}
|
||||
|
||||
if(elf_module->e_type == ET_REL)
|
||||
if (elf_module->e_type == ET_REL)
|
||||
{
|
||||
module = _load_relocated_object(name, module_ptr);
|
||||
}
|
||||
else if(elf_module->e_type == ET_DYN)
|
||||
else if (elf_module->e_type == ET_DYN)
|
||||
{
|
||||
module = _load_shared_object(name, module_ptr);
|
||||
}
|
||||
@ -753,7 +789,7 @@ rt_module_t rt_module_load(const char *name, void *module_ptr)
|
||||
return RT_NULL;
|
||||
}
|
||||
|
||||
if(module == RT_NULL)
|
||||
if (module == RT_NULL)
|
||||
return RT_NULL;
|
||||
|
||||
/* init module object container */
|
||||
@ -772,8 +808,8 @@ rt_module_t rt_module_load(const char *name, void *module_ptr)
|
||||
module->mem_list = RT_NULL;
|
||||
|
||||
/* create page array */
|
||||
module->page_array = (void *)rt_malloc
|
||||
(PAGE_COUNT_MAX * sizeof(struct rt_page_info));
|
||||
module->page_array =
|
||||
(void *)rt_malloc(PAGE_COUNT_MAX * sizeof(struct rt_page_info));
|
||||
module->page_cnt = 0;
|
||||
#endif
|
||||
|
||||
@ -782,14 +818,19 @@ rt_module_t rt_module_load(const char *name, void *module_ptr)
|
||||
module->thread_priority = RT_THREAD_PRIORITY_MAX - 2;
|
||||
|
||||
/* create module thread */
|
||||
module->module_thread = rt_thread_create(name,
|
||||
(void(*)(void *))module->module_entry, RT_NULL,
|
||||
module->module_thread =
|
||||
rt_thread_create(name,
|
||||
(void(*)(void *))module->module_entry,
|
||||
RT_NULL,
|
||||
module->stack_size,
|
||||
module->thread_priority, 10);
|
||||
module->thread_priority,
|
||||
10);
|
||||
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("thread entry 0x%x\n", module->module_entry));
|
||||
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,("thread entry 0x%x\n", module->module_entry));
|
||||
/* set module id */
|
||||
module->module_thread->module_id = (void*)module;
|
||||
module->module_thread->module_id = (void *)module;
|
||||
module->parent.flag = RT_MODULE_FLAG_WITHENTRY;
|
||||
|
||||
/* startup module thread */
|
||||
@ -820,15 +861,18 @@ static char* _module_name(const char *path)
|
||||
char *name;
|
||||
int size;
|
||||
|
||||
ptr = (char*)path;
|
||||
ptr = (char *)path;
|
||||
first = ptr;
|
||||
end = path + rt_strlen(path);
|
||||
while(*ptr != '\0')
|
||||
{
|
||||
if(*ptr == '/') first = ptr + 1;
|
||||
if(*ptr == '.') end = ptr - 1;
|
||||
|
||||
ptr++;
|
||||
while (*ptr != '\0')
|
||||
{
|
||||
if (*ptr == '/')
|
||||
first = ptr + 1;
|
||||
if (*ptr == '.')
|
||||
end = ptr - 1;
|
||||
|
||||
ptr ++;
|
||||
}
|
||||
|
||||
size = end - first + 1;
|
||||
@ -852,7 +896,7 @@ rt_module_t rt_module_open(const char *path)
|
||||
struct rt_module *module;
|
||||
struct stat s;
|
||||
char *buffer, *offset_ptr;
|
||||
char* name;
|
||||
char *name;
|
||||
|
||||
RT_DEBUG_NOT_IN_INTERRUPT;
|
||||
|
||||
@ -904,7 +948,7 @@ rt_module_t rt_module_open(const char *path)
|
||||
}
|
||||
|
||||
name = _module_name(path);
|
||||
module = rt_module_load(name,(void *)buffer);
|
||||
module = rt_module_load(name, (void *)buffer);
|
||||
rt_free(buffer);
|
||||
rt_free(name);
|
||||
|
||||
@ -913,8 +957,10 @@ rt_module_t rt_module_open(const char *path)
|
||||
|
||||
#if defined(RT_USING_FINSH)
|
||||
#include <finsh.h>
|
||||
|
||||
FINSH_FUNCTION_EXPORT_ALIAS(rt_module_open, exec, exec module from a file);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
/**
|
||||
@ -936,7 +982,9 @@ rt_err_t rt_module_destroy(rt_module_t module)
|
||||
RT_ASSERT(module != RT_NULL);
|
||||
RT_ASSERT(module->nref == 0);
|
||||
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,("rt_module_destroy: %8.*s\n", RT_NAME_MAX, module->parent.name));
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("rt_module_destroy: %8.*s\n",
|
||||
RT_NAME_MAX, module->parent.name));
|
||||
|
||||
/* module has entry point */
|
||||
if (!(module->parent.flag & RT_MODULE_FLAG_WITHOUTENTRY))
|
||||
@ -1090,7 +1138,7 @@ rt_err_t rt_module_destroy(rt_module_t module)
|
||||
|
||||
rt_kprintf("Module: warning - memory still hasn't been free finished\n");
|
||||
|
||||
while(module->page_cnt != 0)
|
||||
while (module->page_cnt != 0)
|
||||
{
|
||||
rt_module_free_page(module, page[0].page_ptr, page[0].npage);
|
||||
}
|
||||
@ -1101,7 +1149,7 @@ rt_err_t rt_module_destroy(rt_module_t module)
|
||||
rt_free(module->module_space);
|
||||
|
||||
/* release module symbol table */
|
||||
for (i=0; i<module->nsym; i++)
|
||||
for (i = 0; i < module->nsym; i ++)
|
||||
{
|
||||
rt_free((void *)module->symtab[i].name);
|
||||
}
|
||||
@ -1109,7 +1157,7 @@ rt_err_t rt_module_destroy(rt_module_t module)
|
||||
rt_free(module->symtab);
|
||||
|
||||
#ifdef RT_USING_SLAB
|
||||
if(module->page_array != RT_NULL)
|
||||
if (module->page_array != RT_NULL)
|
||||
rt_free(module->page_array);
|
||||
#endif
|
||||
|
||||
@ -1200,7 +1248,8 @@ rt_module_t rt_module_find(const char *name)
|
||||
/* try to find device object */
|
||||
information = &rt_object_container[RT_Object_Class_Module];
|
||||
for (node = information->object_list.next;
|
||||
node != &(information->object_list); node = node->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)
|
||||
@ -1246,7 +1295,8 @@ static void *rt_module_malloc_page(rt_size_t npages)
|
||||
self_module->page_cnt ++;
|
||||
|
||||
RT_ASSERT(self_module->page_cnt <= PAGE_COUNT_MAX);
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,"rt_module_malloc_page 0x%x %d\n", chunk, npages);
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("rt_module_malloc_page 0x%x %d\n", chunk, npages));
|
||||
|
||||
return chunk;
|
||||
}
|
||||
@ -1260,7 +1310,9 @@ static void *rt_module_malloc_page(rt_size_t npages)
|
||||
*
|
||||
* @note this function is used for RT-Thread Application Module
|
||||
*/
|
||||
static void rt_module_free_page(rt_module_t module, void *page_ptr, rt_size_t npages)
|
||||
static void rt_module_free_page(rt_module_t module,
|
||||
void *page_ptr,
|
||||
rt_size_t npages)
|
||||
{
|
||||
int i, index;
|
||||
struct rt_page_info *page;
|
||||
@ -1269,23 +1321,25 @@ static void rt_module_free_page(rt_module_t module, void *page_ptr, rt_size_t np
|
||||
self_module = rt_module_self();
|
||||
RT_ASSERT(self_module != RT_NULL);
|
||||
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,"rt_module_free_page 0x%x %d\n", page_ptr, npages);
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("rt_module_free_page 0x%x %d\n", page_ptr, npages));
|
||||
rt_page_free(page_ptr, npages);
|
||||
|
||||
page = (struct rt_page_info*)module->page_array;
|
||||
page = (struct rt_page_info *)module->page_array;
|
||||
|
||||
for(i=0; i<module->page_cnt; i++)
|
||||
for (i = 0; i < module->page_cnt; i ++)
|
||||
{
|
||||
if (page[i].page_ptr == page_ptr)
|
||||
{
|
||||
if (page[i].npage == npages + 1)
|
||||
{
|
||||
page[i].page_ptr += npages * RT_MM_PAGE_SIZE / sizeof(rt_uint32_t);
|
||||
page[i].page_ptr +=
|
||||
npages * RT_MM_PAGE_SIZE / sizeof(rt_uint32_t);
|
||||
page[i].npage -= npages;
|
||||
}
|
||||
else if(page[i].npage == npages)
|
||||
else if (page[i].npage == npages)
|
||||
{
|
||||
for(index=i; index<module->page_cnt-1; index++)
|
||||
for (index = i; index < module->page_cnt-1; index ++)
|
||||
{
|
||||
page[index].page_ptr = page[index + 1].page_ptr;
|
||||
page[index].npage = page[index + 1].npage;
|
||||
@ -1293,23 +1347,23 @@ static void rt_module_free_page(rt_module_t module, void *page_ptr, rt_size_t np
|
||||
page[module->page_cnt - 1].page_ptr = RT_NULL;
|
||||
page[module->page_cnt - 1].npage = 0;
|
||||
|
||||
module->page_cnt--;
|
||||
module->page_cnt --;
|
||||
}
|
||||
else
|
||||
RT_ASSERT(RT_FALSE);
|
||||
self_module->page_cnt--;
|
||||
self_module->page_cnt --;
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* should not be get here */
|
||||
/* should not get here */
|
||||
RT_ASSERT(RT_FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
rt_module_malloc - allocate memory block in free list
|
||||
*/
|
||||
/**
|
||||
* rt_module_malloc - allocate memory block in free list
|
||||
*/
|
||||
void *rt_module_malloc(rt_size_t size)
|
||||
{
|
||||
struct rt_mem_head *b, *n, *up;
|
||||
@ -1323,7 +1377,9 @@ void *rt_module_malloc(rt_size_t size)
|
||||
|
||||
RT_DEBUG_NOT_IN_INTERRUPT;
|
||||
|
||||
nunits = (size + sizeof(struct rt_mem_head) -1)/sizeof(struct rt_mem_head) + 1;
|
||||
nunits = (size + sizeof(struct rt_mem_head) - 1) /
|
||||
sizeof(struct rt_mem_head)
|
||||
+ 1;
|
||||
|
||||
RT_ASSERT(size != 0);
|
||||
RT_ASSERT(nunits != 0);
|
||||
@ -1331,7 +1387,8 @@ void *rt_module_malloc(rt_size_t size)
|
||||
rt_sem_take(&mod_sem, RT_WAITING_FOREVER);
|
||||
|
||||
for (prev = (struct rt_mem_head **)&self_module->mem_list;
|
||||
(b = *prev) != RT_NULL; prev = &(b->next))
|
||||
(b = *prev) != RT_NULL;
|
||||
prev = &(b->next))
|
||||
{
|
||||
if (b->size > nunits)
|
||||
{
|
||||
@ -1342,7 +1399,8 @@ void *rt_module_malloc(rt_size_t size)
|
||||
b->size = nunits;
|
||||
*prev = n;
|
||||
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,"rt_module_malloc 0x%x, %d\n",b + 1, size);
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("rt_module_malloc 0x%x, %d\n", b + 1, size));
|
||||
rt_sem_release(&mod_sem);
|
||||
|
||||
return (void *)(b + 1);
|
||||
@ -1353,7 +1411,8 @@ void *rt_module_malloc(rt_size_t size)
|
||||
/* this node fit, remove this node */
|
||||
*prev = b->next;
|
||||
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,"rt_module_malloc 0x%x, %d\n",b + 1, size);
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,
|
||||
("rt_module_malloc 0x%x, %d\n", b + 1, size));
|
||||
|
||||
rt_sem_release(&mod_sem);
|
||||
|
||||
@ -1362,14 +1421,16 @@ void *rt_module_malloc(rt_size_t size)
|
||||
}
|
||||
|
||||
/* allocate pages from system heap */
|
||||
npage = (size + sizeof(struct rt_mem_head) + RT_MM_PAGE_SIZE - 1)/RT_MM_PAGE_SIZE;
|
||||
npage = (size + sizeof(struct rt_mem_head) + RT_MM_PAGE_SIZE - 1) /
|
||||
RT_MM_PAGE_SIZE;
|
||||
if ((up = (struct rt_mem_head *)rt_module_malloc_page(npage)) == RT_NULL)
|
||||
return RT_NULL;
|
||||
|
||||
up->size = npage * RT_MM_PAGE_SIZE / sizeof(struct rt_mem_head);
|
||||
|
||||
for (prev = (struct rt_mem_head **)&self_module->mem_list;
|
||||
(b = *prev) != RT_NULL; prev = &(b->next))
|
||||
(b = *prev) != RT_NULL;
|
||||
prev = &(b->next))
|
||||
{
|
||||
if (b > up + up->size)
|
||||
break;
|
||||
@ -1383,9 +1444,9 @@ void *rt_module_malloc(rt_size_t size)
|
||||
return rt_module_malloc(size);
|
||||
}
|
||||
|
||||
/*
|
||||
rt_module_free - free memory block in free list
|
||||
*/
|
||||
/**
|
||||
* rt_module_free - free memory block in free list
|
||||
*/
|
||||
void rt_module_free(rt_module_t module, void *addr)
|
||||
{
|
||||
struct rt_mem_head *b, *n, *r;
|
||||
@ -1396,7 +1457,7 @@ void rt_module_free(rt_module_t module, void *addr)
|
||||
RT_ASSERT(addr);
|
||||
RT_ASSERT((((rt_uint32_t)addr) & (sizeof(struct rt_mem_head) -1)) == 0);
|
||||
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE,"rt_module_free 0x%x\n", addr);
|
||||
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("rt_module_free 0x%x\n", addr));
|
||||
|
||||
rt_sem_take(&mod_sem, RT_WAITING_FOREVER);
|
||||
|
||||
@ -1420,12 +1481,15 @@ void rt_module_free(rt_module_t module, void *addr)
|
||||
|
||||
if ((rt_uint32_t)b % RT_MM_PAGE_SIZE == 0)
|
||||
{
|
||||
int npage = b->size * sizeof(struct rt_page_info) / RT_MM_PAGE_SIZE;
|
||||
int npage =
|
||||
b->size * sizeof(struct rt_page_info) / RT_MM_PAGE_SIZE;
|
||||
if (npage > 0)
|
||||
{
|
||||
if ((b->size * sizeof(struct rt_page_info) % RT_MM_PAGE_SIZE) != 0)
|
||||
{
|
||||
rt_size_t nunits = npage * RT_MM_PAGE_SIZE / sizeof(struct rt_mem_head);
|
||||
rt_size_t nunits = npage *
|
||||
RT_MM_PAGE_SIZE /
|
||||
sizeof(struct rt_mem_head);
|
||||
/* split memory */
|
||||
r = b + nunits;
|
||||
r->next = b->next;
|
||||
@ -1454,19 +1518,23 @@ void rt_module_free(rt_module_t module, void *addr)
|
||||
|
||||
if ((rt_uint32_t)n % RT_MM_PAGE_SIZE == 0)
|
||||
{
|
||||
int npage = n->size * sizeof(struct rt_page_info) / RT_MM_PAGE_SIZE;
|
||||
int npage =
|
||||
n->size * sizeof(struct rt_page_info) / RT_MM_PAGE_SIZE;
|
||||
if (npage > 0)
|
||||
{
|
||||
if ((n->size * sizeof(struct rt_page_info) % RT_MM_PAGE_SIZE) != 0)
|
||||
{
|
||||
rt_size_t nunits = npage * RT_MM_PAGE_SIZE / sizeof(struct rt_mem_head);
|
||||
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;
|
||||
}
|
||||
else *prev = n->next;
|
||||
else
|
||||
*prev = n->next;
|
||||
|
||||
rt_module_free_page(module, n, npage);
|
||||
}
|
||||
@ -1495,7 +1563,8 @@ void rt_module_free(rt_module_t module, void *addr)
|
||||
rt_module_free_page(module, n, npage);
|
||||
if (n->size % RT_MM_PAGE_SIZE != 0)
|
||||
{
|
||||
rt_size_t nunits = npage * RT_MM_PAGE_SIZE / sizeof(struct rt_mem_head);
|
||||
rt_size_t nunits =
|
||||
npage * RT_MM_PAGE_SIZE / sizeof(struct rt_mem_head);
|
||||
/* split memory */
|
||||
r = n + nunits;
|
||||
r->next = b;
|
||||
@ -1518,9 +1587,9 @@ void rt_module_free(rt_module_t module, void *addr)
|
||||
rt_sem_release(&mod_sem);
|
||||
}
|
||||
|
||||
/*
|
||||
rt_module_realloc - realloc memory block in free list
|
||||
*/
|
||||
/**
|
||||
* rt_module_realloc - realloc memory block in free list
|
||||
*/
|
||||
void *rt_module_realloc(void *ptr, rt_size_t size)
|
||||
{
|
||||
struct rt_mem_head *b, *p, *prev, *tmpp;
|
||||
@ -1541,7 +1610,9 @@ void *rt_module_realloc(void *ptr, rt_size_t size)
|
||||
return RT_NULL;
|
||||
}
|
||||
|
||||
nunits = (size + sizeof(struct rt_mem_head) - 1) / sizeof(struct rt_mem_head) + 1;
|
||||
nunits = (size + sizeof(struct rt_mem_head) - 1) /
|
||||
sizeof(struct rt_mem_head)
|
||||
+1;
|
||||
b = (struct rt_mem_head *)ptr - 1;
|
||||
|
||||
if (nunits <= b->size)
|
||||
@ -1563,11 +1634,17 @@ void *rt_module_realloc(void *ptr, rt_size_t size)
|
||||
{
|
||||
/* more space then required */
|
||||
prev = (struct rt_mem_head *)self_module->mem_list;
|
||||
for (p = prev->next; p != (b->size + b) && p != RT_NULL; prev = p, p = p->next)
|
||||
for (p = prev->next;
|
||||
p != (b->size + b) && p != RT_NULL;
|
||||
prev = p, p = p->next)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
/* available block after ap in freelist */
|
||||
if (p != RT_NULL && (p->size >= (nunits - (b->size))) && p == (b + b->size))
|
||||
if (p != RT_NULL &&
|
||||
(p->size >= (nunits - (b->size))) &&
|
||||
p == (b + b->size))
|
||||
{
|
||||
/* perfect match */
|
||||
if (p->size == (nunits - (b->size)))
|
||||
@ -1575,7 +1652,7 @@ void *rt_module_realloc(void *ptr, rt_size_t size)
|
||||
b->size = nunits;
|
||||
prev->next = p->next;
|
||||
}
|
||||
else /* more space then required, split block*/
|
||||
else /* more space then required, split block */
|
||||
{
|
||||
/* pointer to old header */
|
||||
tmpp = p;
|
||||
@ -1595,7 +1672,8 @@ void *rt_module_realloc(void *ptr, rt_size_t size)
|
||||
}
|
||||
else /* allocate new memory and copy old data */
|
||||
{
|
||||
if ((p = rt_module_malloc(size)) == RT_NULL) return RT_NULL;
|
||||
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(self_module, (void *)(b + 1));
|
||||
|
||||
@ -1606,6 +1684,7 @@ void *rt_module_realloc(void *ptr, rt_size_t size)
|
||||
|
||||
#ifdef RT_USING_FINSH
|
||||
#include <finsh.h>
|
||||
|
||||
void list_memlist(const char *name)
|
||||
{
|
||||
rt_module_t module;
|
||||
@ -1617,7 +1696,8 @@ void list_memlist(const char *name)
|
||||
return;
|
||||
|
||||
for (prev = (struct rt_mem_head **)&module->mem_list;
|
||||
(b = *prev) != RT_NULL; prev = &(b->next))
|
||||
(b = *prev) != RT_NULL;
|
||||
prev = &(b->next))
|
||||
{
|
||||
rt_kprintf("0x%x--%d\n", b, b->size * sizeof(struct rt_mem_head));
|
||||
}
|
||||
@ -1634,9 +1714,9 @@ void list_mempage(const char *name)
|
||||
if (module == RT_NULL)
|
||||
return;
|
||||
|
||||
page = (struct rt_page_info*)module->page_array;
|
||||
page = (struct rt_page_info *)module->page_array;
|
||||
|
||||
for (i=0; i<module->page_cnt; i++)
|
||||
for (i = 0; i < module->page_cnt; i ++)
|
||||
{
|
||||
rt_kprintf("0x%x--%d\n", page[i].page_ptr, page[i].npage);
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user