sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Mostly cosmetic renaming to straighten out namespace

Browse Source
This commit is contained in:
Gregory Nutt 2015-12-10 16:56:10 -06:00
parent 8bcf35ff39
commit 251e8395c7
16 changed files with 176 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
binfmt/libmodule/libmodule.h
View File

@ -57,7 +57,7 @@
****************************************************************************/
/****************************************************************************
* Name: mod_verifyheader
* Name: libmod_verifyheader
*
* Description:
* Given the header from a possible ELF executable, verify that it is
@ -69,10 +69,10 @@
*
****************************************************************************/
int mod_verifyheader(FAR const Elf32_Ehdr *header);
int libmod_verifyheader(FAR const Elf32_Ehdr *header);
/****************************************************************************
* Name: mod_read
* Name: libmod_read
*
* Description:
* Read 'readsize' bytes from the object file at 'offset'. The data is
@ -84,11 +84,11 @@ int mod_verifyheader(FAR const Elf32_Ehdr *header);
*
****************************************************************************/
int mod_read(FAR struct mod_loadinfo_s *loadinfo, FAR uint8_t *buffer,
size_t readsize, off_t offset);
int libmod_read(FAR struct libmod_loadinfo_s *loadinfo, FAR uint8_t *buffer,
size_t readsize, off_t offset);
/****************************************************************************
* Name: mod_loadshdrs
* Name: libmod_loadshdrs
*
* Description:
* Loads section headers into memory.
@ -99,10 +99,10 @@ int mod_read(FAR struct mod_loadinfo_s *loadinfo, FAR uint8_t *buffer,
*
****************************************************************************/
int mod_loadshdrs(FAR struct mod_loadinfo_s *loadinfo);
int libmod_loadshdrs(FAR struct libmod_loadinfo_s *loadinfo);
/****************************************************************************
* Name: mod_findsection
* Name: libmod_findsection
*
* Description:
* A section by its name.
@ -117,11 +117,11 @@ int mod_loadshdrs(FAR struct mod_loadinfo_s *loadinfo);
*
****************************************************************************/
int mod_findsection(FAR struct mod_loadinfo_s *loadinfo,
FAR const char *sectname);
int libmod_findsection(FAR struct libmod_loadinfo_s *loadinfo,
FAR const char *sectname);
/****************************************************************************
* Name: mod_findsymtab
* Name: libmod_findsymtab
*
* Description:
* Find the symbol table section.
@ -132,10 +132,10 @@ int mod_findsection(FAR struct mod_loadinfo_s *loadinfo,
*
****************************************************************************/
int mod_findsymtab(FAR struct mod_loadinfo_s *loadinfo);
int libmod_findsymtab(FAR struct libmod_loadinfo_s *loadinfo);
/****************************************************************************
* Name: mod_readsym
* Name: libmod_readsym
*
* Description:
* Read the ELFT symbol structure at the specfied index into memory.
@ -151,11 +151,11 @@ int mod_findsymtab(FAR struct mod_loadinfo_s *loadinfo);
*
****************************************************************************/
int mod_readsym(FAR struct mod_loadinfo_s *loadinfo, int index,
FAR Elf32_Sym *sym);
int libmod_readsym(FAR struct libmod_loadinfo_s *loadinfo, int index,
FAR Elf32_Sym *sym);
/****************************************************************************
* Name: mod_symvalue
* Name: libmod_symvalue
*
* Description:
* Get the value of a symbol. The updated value of the symbol is returned
@ -179,11 +179,11 @@ int mod_readsym(FAR struct mod_loadinfo_s *loadinfo, int index,
*
****************************************************************************/
int mod_symvalue(FAR struct mod_loadinfo_s *loadinfo, FAR Elf32_Sym *sym,
FAR const struct symtab_s *exports, int nexports);
int libmod_symvalue(FAR struct libmod_loadinfo_s *loadinfo, FAR Elf32_Sym *sym,
FAR const struct symtab_s *exports, int nexports);
/****************************************************************************
* Name: mod_freebuffers
* Name: libmod_freebuffers
*
* Description:
* Release all working buffers.
@ -194,10 +194,10 @@ int mod_symvalue(FAR struct mod_loadinfo_s *loadinfo, FAR Elf32_Sym *sym,
*
****************************************************************************/
int mod_freebuffers(FAR struct mod_loadinfo_s *loadinfo);
int libmod_freebuffers(FAR struct libmod_loadinfo_s *loadinfo);
/****************************************************************************
* Name: mod_allocbuffer
* Name: libmod_allocbuffer
*
* Description:
* Perform the initial allocation of the I/O buffer, if it has not already
@ -209,10 +209,10 @@ int mod_freebuffers(FAR struct mod_loadinfo_s *loadinfo);
*
****************************************************************************/
int mod_allocbuffer(FAR struct mod_loadinfo_s *loadinfo);
int libmod_allocbuffer(FAR struct libmod_loadinfo_s *loadinfo);
/****************************************************************************
* Name: mod_reallocbuffer
* Name: libmod_reallocbuffer
*
* Description:
* Increase the size of I/O buffer by the specified buffer increment.
@ -223,10 +223,10 @@ int mod_allocbuffer(FAR struct mod_loadinfo_s *loadinfo);
*
****************************************************************************/
int mod_reallocbuffer(FAR struct mod_loadinfo_s *loadinfo, size_t increment);
int libmod_reallocbuffer(FAR struct libmod_loadinfo_s *loadinfo, size_t increment);
/****************************************************************************
* Name: mod_findctors
* Name: libmod_findctors
*
* Description:
* Find C++ static constructors.
@ -241,11 +241,11 @@ int mod_reallocbuffer(FAR struct mod_loadinfo_s *loadinfo, size_t increment);
****************************************************************************/
#ifdef CONFIG_BINFMT_CONSTRUCTORS
int mod_loadctors(FAR struct mod_loadinfo_s *loadinfo);
int libmod_loadctors(FAR struct libmod_loadinfo_s *loadinfo);
#endif
/****************************************************************************
* Name: mod_loaddtors
* Name: libmod_loaddtors
*
* Description:
* Load pointers to static destructors into an in-memory array.
@ -260,7 +260,7 @@ int mod_loadctors(FAR struct mod_loadinfo_s *loadinfo);
****************************************************************************/
#ifdef CONFIG_BINFMT_CONSTRUCTORS
int mod_loaddtors(FAR struct mod_loadinfo_s *loadinfo);
int libmod_loaddtors(FAR struct libmod_loadinfo_s *loadinfo);
#endif
#endif /* __BINFMT_LIBELF_LIBELF_H */

48
binfmt/libmodule/libmodule_bind.c
View File

@ -68,9 +68,9 @@
#endif
#ifdef CONFIG_ELF_DUMPBUFFER
# define mod_dumpbuffer(m,b,n) bvdbgdumpbuffer(m,b,n)
# define libmod_dumpbuffer(m,b,n) bvdbgdumpbuffer(m,b,n)
#else
# define mod_dumpbuffer(m,b,n)
# define libmod_dumpbuffer(m,b,n)
#endif
/****************************************************************************
@ -86,16 +86,16 @@
****************************************************************************/
/****************************************************************************
* Name: mod_readrel
* Name: libmod_readrel
*
* Description:
* Read the ELF32_Rel structure into memory.
*
****************************************************************************/
static inline int mod_readrel(FAR struct mod_loadinfo_s *loadinfo,
FAR const Elf32_Shdr *relsec,
int index, FAR Elf32_Rel *rel)
static inline int libmod_readrel(FAR struct libmod_loadinfo_s *loadinfo,
FAR const Elf32_Shdr *relsec,
int index, FAR Elf32_Rel *rel)
{
off_t offset;
@ -113,11 +113,11 @@ static inline int mod_readrel(FAR struct mod_loadinfo_s *loadinfo,
/* And, finally, read the symbol table entry into memory */
return mod_read(loadinfo, (FAR uint8_t *)rel, sizeof(Elf32_Rel), offset);
return libmod_read(loadinfo, (FAR uint8_t *)rel, sizeof(Elf32_Rel), offset);
}
/****************************************************************************
* Name: mod_relocate and mod_relocateadd
* Name: libmod_relocate and libmod_relocateadd
*
* Description:
* Perform all relocations associated with a section.
@ -128,8 +128,8 @@ static inline int mod_readrel(FAR struct mod_loadinfo_s *loadinfo,
*
****************************************************************************/
static int mod_relocate(FAR struct mod_loadinfo_s *loadinfo, int relidx,
FAR const struct symtab_s *exports, int nexports)
static int libmod_relocate(FAR struct libmod_loadinfo_s *loadinfo, int relidx,
FAR const struct symtab_s *exports, int nexports)
{
FAR Elf32_Shdr *relsec = &loadinfo->shdr[relidx];
@ -153,7 +153,7 @@ static int mod_relocate(FAR struct mod_loadinfo_s *loadinfo, int relidx,
/* Read the relocation entry into memory */
ret = mod_readrel(loadinfo, relsec, i, &rel);
ret = libmod_readrel(loadinfo, relsec, i, &rel);
if (ret < 0)
{
bdbg("Section %d reloc %d: Failed to read relocation entry: %d\n",
@ -169,7 +169,7 @@ static int mod_relocate(FAR struct mod_loadinfo_s *loadinfo, int relidx,
/* Read the symbol table entry into memory */
ret = mod_readsym(loadinfo, symidx, &sym);
ret = libmod_readsym(loadinfo, symidx, &sym);
if (ret < 0)
{
bdbg("Section %d reloc %d: Failed to read symbol[%d]: %d\n",
@ -179,7 +179,7 @@ static int mod_relocate(FAR struct mod_loadinfo_s *loadinfo, int relidx,
/* Get the value of the symbol (in sym.st_value) */
ret = mod_symvalue(loadinfo, &sym, exports, nexports);
ret = libmod_symvalue(loadinfo, &sym, exports, nexports);
if (ret < 0)
{
/* The special error -ESRCH is returned only in one condition: The
@ -230,8 +230,8 @@ static int mod_relocate(FAR struct mod_loadinfo_s *loadinfo, int relidx,
return OK;
}
static int mod_relocateadd(FAR struct mod_loadinfo_s *loadinfo, int relidx,
FAR const struct symtab_s *exports, int nexports)
static int libmod_relocateadd(FAR struct libmod_loadinfo_s *loadinfo, int relidx,
FAR const struct symtab_s *exports, int nexports)
{
bdbg("Not implemented\n");
return -ENOSYS;
@ -242,7 +242,7 @@ static int mod_relocateadd(FAR struct mod_loadinfo_s *loadinfo, int relidx,
****************************************************************************/
/****************************************************************************
* Name: mod_bind
* Name: libmod_bind
*
* Description:
* Bind the imported symbol names in the loaded module described by
@ -254,28 +254,28 @@ static int mod_relocateadd(FAR struct mod_loadinfo_s *loadinfo, int relidx,
*
****************************************************************************/
int mod_bind(FAR struct mod_loadinfo_s *loadinfo,
FAR const struct symtab_s *exports, int nexports)
int libmod_bind(FAR struct libmod_loadinfo_s *loadinfo,
FAR const struct symtab_s *exports, int nexports)
{
int ret;
int i;
/* Find the symbol and string tables */
ret = mod_findsymtab(loadinfo);
ret = libmod_findsymtab(loadinfo);
if (ret < 0)
{
return ret;
}
/* Allocate an I/O buffer. This buffer is used by mod_symname() to
/* Allocate an I/O buffer. This buffer is used by libmod_symname() to
* accumulate the variable length symbol name.
*/
ret = mod_allocbuffer(loadinfo);
ret = libmod_allocbuffer(loadinfo);
if (ret < 0)
{
bdbg("mod_allocbuffer failed: %d\n", ret);
bdbg("libmod_allocbuffer failed: %d\n", ret);
return -ENOMEM;
}
@ -304,11 +304,11 @@ int mod_bind(FAR struct mod_loadinfo_s *loadinfo,
if (loadinfo->shdr[i].sh_type == SHT_REL)
{
ret = mod_relocate(loadinfo, i, exports, nexports);
ret = libmod_relocate(loadinfo, i, exports, nexports);
}
else if (loadinfo->shdr[i].sh_type == SHT_RELA)
{
ret = mod_relocateadd(loadinfo, i, exports, nexports);
ret = libmod_relocateadd(loadinfo, i, exports, nexports);
}
if (ret < 0)

16
binfmt/libmodule/libmodule_ctors.c
View File

@ -72,7 +72,7 @@
****************************************************************************/
/****************************************************************************
* Name: mod_loadctors
* Name: libmod_loadctors
*
* Description:
* Load pointers to static constructors into an in-memory array.
@ -86,7 +86,7 @@
*
****************************************************************************/
int mod_loadctors(FAR struct mod_loadinfo_s *loadinfo)
int libmod_loadctors(FAR struct libmod_loadinfo_s *loadinfo)
{
FAR Elf32_Shdr *shdr;
size_t ctorsize;
@ -97,13 +97,13 @@ int mod_loadctors(FAR struct mod_loadinfo_s *loadinfo)
DEBUGASSERT(loadinfo->ctors == NULL);
/* Allocate an I/O buffer if necessary. This buffer is used by
* mod_sectname() to accumulate the variable length symbol name.
* libmod_sectname() to accumulate the variable length symbol name.
*/
ret = mod_allocbuffer(loadinfo);
ret = libmod_allocbuffer(loadinfo);
if (ret < 0)
{
bdbg("mod_allocbuffer failed: %d\n", ret);
bdbg("libmod_allocbuffer failed: %d\n", ret);
return -ENOMEM;
}
@ -114,14 +114,14 @@ int mod_loadctors(FAR struct mod_loadinfo_s *loadinfo)
* in either case.
*/
ctoridx = mod_findsection(loadinfo, ".ctors");
ctoridx = libmod_findsection(loadinfo, ".ctors");
if (ctoridx < 0)
{
/* This may not be a failure. -ENOENT indicates that the file has no
* static constructor section.
*/
bvdbg("mod_findsection .ctors section failed: %d\n", ctoridx);
bvdbg("libmod_findsection .ctors section failed: %d\n", ctoridx);
return ret == -ENOENT ? OK : ret;
}
@ -174,7 +174,7 @@ int mod_loadctors(FAR struct mod_loadinfo_s *loadinfo)
/* Read the section header table into memory */
ret = mod_read(loadinfo, (FAR uint8_t *)loadinfo->ctors, ctorsize,
ret = libmod_read(loadinfo, (FAR uint8_t *)loadinfo->ctors, ctorsize,
shdr->sh_offset);
if (ret < 0)
{

16
binfmt/libmodule/libmodule_dtors.c
View File

@ -72,7 +72,7 @@
****************************************************************************/
/****************************************************************************
* Name: mod_loaddtors
* Name: libmod_loaddtors
*
* Description:
* Load pointers to static destructors into an in-memory array.
@ -86,7 +86,7 @@
*
****************************************************************************/
int mod_loaddtors(FAR struct mod_loadinfo_s *loadinfo)
int libmod_loaddtors(FAR struct libmod_loadinfo_s *loadinfo)
{
FAR Elf32_Shdr *shdr;
size_t dtorsize;
@ -97,13 +97,13 @@ int mod_loaddtors(FAR struct mod_loadinfo_s *loadinfo)
DEBUGASSERT(loadinfo->dtors == NULL);
/* Allocate an I/O buffer if necessary. This buffer is used by
* mod_sectname() to accumulate the variable length symbol name.
* libmod_sectname() to accumulate the variable length symbol name.
*/
ret = mod_allocbuffer(loadinfo);
ret = libmod_allocbuffer(loadinfo);
if (ret < 0)
{
bdbg("mod_allocbuffer failed: %d\n", ret);
bdbg("libmod_allocbuffer failed: %d\n", ret);
return -ENOMEM;
}
@ -114,14 +114,14 @@ int mod_loaddtors(FAR struct mod_loadinfo_s *loadinfo)
* in either case.
*/
dtoridx = mod_findsection(loadinfo, ".dtors");
dtoridx = libmod_findsection(loadinfo, ".dtors");
if (dtoridx < 0)
{
/* This may not be a failure. -ENOENT indicates that the file has no
* static destructor section.
*/
bvdbg("mod_findsection .dtors section failed: %d\n", dtoridx);
bvdbg("libmod_findsection .dtors section failed: %d\n", dtoridx);
return ret == -ENOENT ? OK : ret;
}
@ -174,7 +174,7 @@ int mod_loaddtors(FAR struct mod_loadinfo_s *loadinfo)
/* Read the section header table into memory */
ret = mod_read(loadinfo, (FAR uint8_t *)loadinfo->dtors, dtorsize,
ret = libmod_read(loadinfo, (FAR uint8_t *)loadinfo->dtors, dtorsize,
shdr->sh_offset);
if (ret < 0)
{

33
binfmt/libmodule/libmodule_init.c
View File

@ -65,9 +65,9 @@
#endif
#ifdef CONFIG_ELF_DUMPBUFFER
# define mod_dumpbuffer(m,b,n) bvdbgdumpbuffer(m,b,n)
# define libmod_dumpbuffer(m,b,n) bvdbgdumpbuffer(m,b,n)
#else
# define mod_dumpbuffer(m,b,n)
# define libmod_dumpbuffer(m,b,n)
#endif
/****************************************************************************
@ -79,7 +79,7 @@
****************************************************************************/
/****************************************************************************
* Name: mod_filelen
* Name: libmod_filelen
*
* Description:
* Get the size of the ELF file
@ -90,8 +90,8 @@
*
****************************************************************************/
static inline int mod_filelen(FAR struct mod_loadinfo_s *loadinfo,
FAR const char *filename)
static inline int libmod_filelen(FAR struct libmod_loadinfo_s *loadinfo,
FAR const char *filename)
{
struct stat buf;
int ret;
@ -129,7 +129,7 @@ static inline int mod_filelen(FAR struct mod_loadinfo_s *loadinfo,
****************************************************************************/
/****************************************************************************
* Name: mod_initialize
* Name: libmod_initialize
*
* Description:
* This function is called to configure the library to process an ELF
@ -141,7 +141,8 @@ static inline int mod_filelen(FAR struct mod_loadinfo_s *loadinfo,
*
****************************************************************************/
int mod_initialize(FAR const char *filename, FAR struct mod_loadinfo_s *loadinfo)
int libmod_initialize(FAR const char *filename,
FAR struct libmod_loadinfo_s *loadinfo)
{
int ret;
@ -149,14 +150,14 @@ int mod_initialize(FAR const char *filename, FAR struct mod_loadinfo_s *loadinfo
/* Clear the load info structure */
memset(loadinfo, 0, sizeof(struct mod_loadinfo_s));
memset(loadinfo, 0, sizeof(struct libmod_loadinfo_s));
/* Get the length of the file. */
ret = mod_filelen(loadinfo, filename);
ret = libmod_filelen(loadinfo, filename);
if (ret < 0)
{
bdbg("mod_filelen failed: %d\n", ret);
bdbg("libmod_filelen failed: %d\n", ret);
return ret;
}
@ -172,24 +173,26 @@ int mod_initialize(FAR const char *filename, FAR struct mod_loadinfo_s *loadinfo
/* Read the ELF ehdr from offset 0 */
ret = mod_read(loadinfo, (FAR uint8_t *)&loadinfo->ehdr, sizeof(Elf32_Ehdr), 0);
ret = libmod_read(loadinfo, (FAR uint8_t *)&loadinfo->ehdr,
sizeof(Elf32_Ehdr), 0);
if (ret < 0)
{
bdbg("Failed to read ELF header: %d\n", ret);
return ret;
}
mod_dumpbuffer("ELF header", (FAR const uint8_t *)&loadinfo->ehdr, sizeof(Elf32_Ehdr));
libmod_dumpbuffer("ELF header", (FAR const uint8_t *)&loadinfo->ehdr,
sizeof(Elf32_Ehdr));
/* Verify the ELF header */
ret = mod_verifyheader(&loadinfo->ehdr);
ret = libmod_verifyheader(&loadinfo->ehdr);
if (ret < 0)
{
/* This may not be an error because we will be called to attempt loading
* EVERY binary. If mod_verifyheader() does not recognize the ELF header,
* EVERY binary. If libmod_verifyheader() does not recognize the ELF header,
* it will -ENOEXEC whcih simply informs the system that the file is not an
* ELF file. mod_verifyheader() will return other errors if the ELF header
* ELF file. libmod_verifyheader() will return other errors if the ELF header
* is not correctly formed.
*/

10
binfmt/libmodule/libmodule_iobuffer.c
View File

@ -1,5 +1,5 @@
/****************************************************************************
* binfmt/libmodule/mod_iobuffer.c
* binfmt/libmodule/libmodule_iobuffer.c
*
* Copyright (C) 2012-2013 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
@ -64,7 +64,7 @@
****************************************************************************/
/****************************************************************************
* Name: mod_allocbuffer
* Name: libmod_allocbuffer
*
* Description:
* Perform the initial allocation of the I/O buffer, if it has not already
@ -76,7 +76,7 @@
*
****************************************************************************/
int mod_allocbuffer(FAR struct mod_loadinfo_s *loadinfo)
int libmod_allocbuffer(FAR struct libmod_loadinfo_s *loadinfo)
{
/* Has a buffer been allocated> */
@ -98,7 +98,7 @@ int mod_allocbuffer(FAR struct mod_loadinfo_s *loadinfo)
}
/****************************************************************************
* Name: mod_reallocbuffer
* Name: libmod_reallocbuffer
*
* Description:
* Increase the size of I/O buffer by the specified buffer increment.
@ -109,7 +109,7 @@ int mod_allocbuffer(FAR struct mod_loadinfo_s *loadinfo)
*
****************************************************************************/
int mod_reallocbuffer(FAR struct mod_loadinfo_s *loadinfo, size_t increment)
int libmod_reallocbuffer(FAR struct libmod_loadinfo_s *loadinfo, size_t increment)
{
FAR void *buffer;
size_t newsize;

38
binfmt/libmodule/libmodule_load.c
View File

@ -79,7 +79,7 @@
****************************************************************************/
/****************************************************************************
* Name: mod_elfsize
* Name: libmod_elfsize
*
* Description:
* Calculate total memory allocation for the ELF file.
@ -90,7 +90,7 @@
*
****************************************************************************/
static void mod_elfsize(struct mod_loadinfo_s *loadinfo)
static void libmod_elfsize(struct libmod_loadinfo_s *loadinfo)
{
size_t textsize;
size_t datasize;
@ -133,7 +133,7 @@ static void mod_elfsize(struct mod_loadinfo_s *loadinfo)
}
/****************************************************************************
* Name: mod_loadfile
* Name: libmod_loadfile
*
* Description:
* Read the section data into memory. Section addresses in the shdr[] are
@ -145,7 +145,7 @@ static void mod_elfsize(struct mod_loadinfo_s *loadinfo)
*
****************************************************************************/
static inline int mod_loadfile(FAR struct mod_loadinfo_s *loadinfo)
static inline int libmod_loadfile(FAR struct libmod_loadinfo_s *loadinfo)
{
FAR uint8_t *text;
FAR uint8_t *data;
@ -192,7 +192,7 @@ static inline int mod_loadfile(FAR struct mod_loadinfo_s *loadinfo)
{
/* Read the section data from sh_offset to the memory region */
ret = mod_read(loadinfo, *pptr, shdr->sh_size, shdr->sh_offset);
ret = libmod_read(loadinfo, *pptr, shdr->sh_size, shdr->sh_offset);
if (ret < 0)
{
bdbg("ERROR: Failed to read section %d: %d\n", i, ret);
@ -229,7 +229,7 @@ static inline int mod_loadfile(FAR struct mod_loadinfo_s *loadinfo)
****************************************************************************/
/****************************************************************************
* Name: mod_load
* Name: libmod_load
*
* Description:
* Loads the binary into memory, allocating memory, performing relocations
@ -241,7 +241,7 @@ static inline int mod_loadfile(FAR struct mod_loadinfo_s *loadinfo)
*
****************************************************************************/
int mod_load(FAR struct mod_loadinfo_s *loadinfo)
int libmod_load(FAR struct libmod_loadinfo_s *loadinfo)
{
size_t heapsize;
#ifdef CONFIG_UCLIBCXX_EXCEPTION
@ -254,16 +254,16 @@ int mod_load(FAR struct mod_loadinfo_s *loadinfo)
/* Load section headers into memory */
ret = mod_loadshdrs(loadinfo);
ret = libmod_loadshdrs(loadinfo);
if (ret < 0)
{
bdbg("ERROR: mod_loadshdrs failed: %d\n", ret);
bdbg("ERROR: libmod_loadshdrs failed: %d\n", ret);
goto errout_with_buffers;
}
/* Determine total size to allocate */
mod_elfsize(loadinfo);
libmod_elfsize(loadinfo);
/* Determine the heapsize to allocate. */
@ -285,36 +285,36 @@ int mod_load(FAR struct mod_loadinfo_s *loadinfo)
/* Load ELF section data into memory */
ret = mod_loadfile(loadinfo);
ret = libmod_loadfile(loadinfo);
if (ret < 0)
{
bdbg("ERROR: mod_loadfile failed: %d\n", ret);
bdbg("ERROR: libmod_loadfile failed: %d\n", ret);
goto errout_with_buffers;
}
/* Load static constructors and destructors. */
#ifdef CONFIG_BINFMT_CONSTRUCTORS
ret = mod_loadctors(loadinfo);
ret = libmod_loadctors(loadinfo);
if (ret < 0)
{
bdbg("ERROR: mod_loadctors failed: %d\n", ret);
bdbg("ERROR: libmod_loadctors failed: %d\n", ret);
goto errout_with_buffers;
}
ret = mod_loaddtors(loadinfo);
ret = libmod_loaddtors(loadinfo);
if (ret < 0)
{
bdbg("ERROR: mod_loaddtors failed: %d\n", ret);
bdbg("ERROR: libmod_loaddtors failed: %d\n", ret);
goto errout_with_buffers;
}
#endif
#ifdef CONFIG_UCLIBCXX_EXCEPTION
exidx = mod_findsection(loadinfo, CONFIG_ELF_EXIDX_SECTNAME);
exidx = libmod_findsection(loadinfo, CONFIG_ELF_EXIDX_SECTNAME);
if (exidx < 0)
{
bvdbg("mod_findsection: Exception Index section not found: %d\n", exidx);
bvdbg("libmod_findsection: Exception Index section not found: %d\n", exidx);
}
else
{
@ -327,7 +327,7 @@ int mod_load(FAR struct mod_loadinfo_s *loadinfo)
/* Error exits */
errout_with_buffers:
mod_unload(loadinfo);
libmod_unload(loadinfo);
return ret;
}

14
binfmt/libmodule/libmodule_read.c
View File

@ -64,11 +64,11 @@
****************************************************************************/
/****************************************************************************
* Name: mod_dumpreaddata
* Name: libmod_dumpreaddata
****************************************************************************/
#if defined(ELF_DUMP_READDATA)
static inline void mod_dumpreaddata(FAR char *buffer, int buflen)
static inline void libmod_dumpreaddata(FAR char *buffer, int buflen)
{
FAR uint32_t *buf32 = (FAR uint32_t *)buffer;
int i;
@ -86,7 +86,7 @@ static inline void mod_dumpreaddata(FAR char *buffer, int buflen)
}
}
#else
# define mod_dumpreaddata(b,n)
# define libmod_dumpreaddata(b,n)
#endif
/****************************************************************************
@ -94,7 +94,7 @@ static inline void mod_dumpreaddata(FAR char *buffer, int buflen)
****************************************************************************/
/****************************************************************************
* Name: mod_read
* Name: libmod_read
*
* Description:
* Read 'readsize' bytes from the object file at 'offset'. The data is
@ -106,8 +106,8 @@ static inline void mod_dumpreaddata(FAR char *buffer, int buflen)
*
****************************************************************************/
int mod_read(FAR struct mod_loadinfo_s *loadinfo, FAR uint8_t *buffer,
size_t readsize, off_t offset)
int libmod_read(FAR struct libmod_loadinfo_s *loadinfo, FAR uint8_t *buffer,
size_t readsize, off_t offset)
{
ssize_t nbytes; /* Number of bytes read */
off_t rpos; /* Position returned by lseek */
@ -158,6 +158,6 @@ int mod_read(FAR struct mod_loadinfo_s *loadinfo, FAR uint8_t *buffer,
}
}
mod_dumpreaddata(buffer, readsize);
libmod_dumpreaddata(buffer, readsize);
return OK;
}

30
binfmt/libmodule/libmodule_sections.c
View File

@ -63,7 +63,7 @@
****************************************************************************/
/****************************************************************************
* Name: mod_sectname
* Name: libmod_sectname
*
* Description:
* Get the symbol name in loadinfo->iobuffer[].
@ -74,8 +74,8 @@
*
****************************************************************************/
static inline int mod_sectname(FAR struct mod_loadinfo_s *loadinfo,
FAR const Elf32_Shdr *shdr)
static inline int libmod_sectname(FAR struct libmod_loadinfo_s *loadinfo,
FAR const Elf32_Shdr *shdr)
{
FAR Elf32_Shdr *shstr;
FAR uint8_t *buffer;
@ -136,7 +136,7 @@ static inline int mod_sectname(FAR struct mod_loadinfo_s *loadinfo,
/* Read that number of bytes into the array */
buffer = &loadinfo->iobuffer[bytesread];
ret = mod_read(loadinfo, buffer, readlen, offset);
ret = libmod_read(loadinfo, buffer, readlen, offset);
if (ret < 0)
{
bdbg("Failed to read section name\n");
@ -156,10 +156,10 @@ static inline int mod_sectname(FAR struct mod_loadinfo_s *loadinfo,
/* No.. then we have to read more */
ret = mod_reallocbuffer(loadinfo, CONFIG_ELF_BUFFERINCR);
ret = libmod_reallocbuffer(loadinfo, CONFIG_ELF_BUFFERINCR);
if (ret < 0)
{
bdbg("mod_reallocbuffer failed: %d\n", ret);
bdbg("libmod_reallocbuffer failed: %d\n", ret);
return ret;
}
}
@ -174,7 +174,7 @@ static inline int mod_sectname(FAR struct mod_loadinfo_s *loadinfo,
****************************************************************************/
/****************************************************************************
* Name: mod_loadshdrs
* Name: libmod_loadshdrs
*
* Description:
* Loads section headers into memory.
@ -185,7 +185,7 @@ static inline int mod_sectname(FAR struct mod_loadinfo_s *loadinfo,
*
****************************************************************************/
int mod_loadshdrs(FAR struct mod_loadinfo_s *loadinfo)
int libmod_loadshdrs(FAR struct libmod_loadinfo_s *loadinfo)
{
size_t shdrsize;
int ret;
@ -221,8 +221,8 @@ int mod_loadshdrs(FAR struct mod_loadinfo_s *loadinfo)
/* Read the section header table into memory */
ret = mod_read(loadinfo, (FAR uint8_t *)loadinfo->shdr, shdrsize,
loadinfo->ehdr.e_shoff);
ret = libmod_read(loadinfo, (FAR uint8_t *)loadinfo->shdr, shdrsize,
loadinfo->ehdr.e_shoff);
if (ret < 0)
{
bdbg("Failed to read section header table: %d\n", ret);
@ -232,7 +232,7 @@ int mod_loadshdrs(FAR struct mod_loadinfo_s *loadinfo)
}
/****************************************************************************
* Name: mod_findsection
* Name: libmod_findsection
*
* Description:
* A section by its name.
@ -247,8 +247,8 @@ int mod_loadshdrs(FAR struct mod_loadinfo_s *loadinfo)
*
****************************************************************************/
int mod_findsection(FAR struct mod_loadinfo_s *loadinfo,
FAR const char *sectname)
int libmod_findsection(FAR struct libmod_loadinfo_s *loadinfo,
FAR const char *sectname)
{
FAR const Elf32_Shdr *shdr;
int ret;
@ -261,10 +261,10 @@ int mod_findsection(FAR struct mod_loadinfo_s *loadinfo,
/* Get the name of this section */
shdr = &loadinfo->shdr[i];
ret = mod_sectname(loadinfo, shdr);
ret = libmod_sectname(loadinfo, shdr);
if (ret < 0)
{
bdbg("mod_sectname failed: %d\n", ret);
bdbg("libmod_sectname failed: %d\n", ret);
return ret;
}

34
binfmt/libmodule/libmodule_symbols.c
View File

@ -67,7 +67,7 @@
****************************************************************************/
/****************************************************************************
* Name: mod_symname
* Name: libmod_symname
*
* Description:
* Get the symbol name in loadinfo->iobuffer[].
@ -82,8 +82,8 @@
*
****************************************************************************/
static int mod_symname(FAR struct mod_loadinfo_s *loadinfo,
FAR const Elf32_Sym *sym)
static int libmod_symname(FAR struct libmod_loadinfo_s *loadinfo,
FAR const Elf32_Sym *sym)
{
FAR uint8_t *buffer;
off_t offset;
@ -126,10 +126,10 @@ static int mod_symname(FAR struct mod_loadinfo_s *loadinfo,
/* Read that number of bytes into the array */
buffer = &loadinfo->iobuffer[bytesread];
ret = mod_read(loadinfo, buffer, readlen, offset);
ret = libmod_read(loadinfo, buffer, readlen, offset);
if (ret < 0)
{
bdbg("mod_read failed: %d\n", ret);
bdbg("libmod_read failed: %d\n", ret);
return ret;
}
@ -146,10 +146,10 @@ static int mod_symname(FAR struct mod_loadinfo_s *loadinfo,
/* No.. then we have to read more */
ret = mod_reallocbuffer(loadinfo, CONFIG_ELF_BUFFERINCR);
ret = libmod_reallocbuffer(loadinfo, CONFIG_ELF_BUFFERINCR);
if (ret < 0)
{
bdbg("mod_reallocbuffer failed: %d\n", ret);
bdbg("libmod_reallocbuffer failed: %d\n", ret);
return ret;
}
}
@ -164,7 +164,7 @@ static int mod_symname(FAR struct mod_loadinfo_s *loadinfo,
****************************************************************************/
/****************************************************************************
* Name: mod_findsymtab
* Name: libmod_findsymtab
*
* Description:
* Find the symbol table section.
@ -175,7 +175,7 @@ static int mod_symname(FAR struct mod_loadinfo_s *loadinfo,
*
****************************************************************************/
int mod_findsymtab(FAR struct mod_loadinfo_s *loadinfo)
int libmod_findsymtab(FAR struct libmod_loadinfo_s *loadinfo)
{
int i;
@ -203,7 +203,7 @@ int mod_findsymtab(FAR struct mod_loadinfo_s *loadinfo)
}
/****************************************************************************
* Name: mod_readsym
* Name: libmod_readsym
*
* Description:
* Read the ELFT symbol structure at the specfied index into memory.
@ -219,8 +219,8 @@ int mod_findsymtab(FAR struct mod_loadinfo_s *loadinfo)
*
****************************************************************************/
int mod_readsym(FAR struct mod_loadinfo_s *loadinfo, int index,
FAR Elf32_Sym *sym)
int libmod_readsym(FAR struct libmod_loadinfo_s *loadinfo, int index,
FAR Elf32_Sym *sym)
{
FAR Elf32_Shdr *symtab = &loadinfo->shdr[loadinfo->symtabidx];
off_t offset;
@ -239,11 +239,11 @@ int mod_readsym(FAR struct mod_loadinfo_s *loadinfo, int index,
/* And, finally, read the symbol table entry into memory */
return mod_read(loadinfo, (FAR uint8_t *)sym, sizeof(Elf32_Sym), offset);
return libmod_read(loadinfo, (FAR uint8_t *)sym, sizeof(Elf32_Sym), offset);
}
/****************************************************************************
* Name: mod_symvalue
* Name: libmod_symvalue
*
* Description:
* Get the value of a symbol. The updated value of the symbol is returned
@ -265,8 +265,8 @@ int mod_readsym(FAR struct mod_loadinfo_s *loadinfo, int index,
*
****************************************************************************/
int mod_symvalue(FAR struct mod_loadinfo_s *loadinfo, FAR Elf32_Sym *sym,
FAR const struct symtab_s *exports, int nexports)
int libmod_symvalue(FAR struct libmod_loadinfo_s *loadinfo, FAR Elf32_Sym *sym,
FAR const struct symtab_s *exports, int nexports)
{
FAR const struct symtab_s *symbol;
uintptr_t secbase;
@ -294,7 +294,7 @@ int mod_symvalue(FAR struct mod_loadinfo_s *loadinfo, FAR Elf32_Sym *sym,
{
/* Get the name of the undefined symbol */
ret = mod_symname(loadinfo, sym);
ret = libmod_symname(loadinfo, sym);
if (ret < 0)
{
/* There are a few relocations for a few architectures that do

14
binfmt/libmodule/libmodule_uninit.c
View File

@ -65,11 +65,11 @@
****************************************************************************/
/****************************************************************************
* Name: mod_uninit
* Name: libmod_uninitialize
*
* Description:
* Releases any resources committed by mod_initialize(). This essentially
* undoes the actions of mod_initialize.
* Releases any resources committed by libmod_initialize(). This essentially
* undoes the actions of libmod_initialize.
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
@ -77,11 +77,11 @@
*
****************************************************************************/
int mod_uninit(struct mod_loadinfo_s *loadinfo)
int libmod_uninitialize(struct libmod_loadinfo_s *loadinfo)
{
/* Free all working buffers */
mod_freebuffers(loadinfo);
libmod_freebuffers(loadinfo);
/* Close the ELF file */
@ -94,7 +94,7 @@ int mod_uninit(struct mod_loadinfo_s *loadinfo)
}
/****************************************************************************
* Name: mod_freebuffers
* Name: libmod_freebuffers
*
* Description:
* Release all working buffers.
@ -105,7 +105,7 @@ int mod_uninit(struct mod_loadinfo_s *loadinfo)
*
****************************************************************************/
int mod_freebuffers(struct mod_loadinfo_s *loadinfo)
int libmod_freebuffers(struct libmod_loadinfo_s *loadinfo)
{
/* Release all working allocations */

8
binfmt/libmodule/libmodule_unload.c
View File

@ -64,11 +64,11 @@
****************************************************************************/
/****************************************************************************
* Name: mod_unload
* Name: libmod_unload
*
* Description:
* This function unloads the object from memory. This essentially undoes
* the actions of mod_load. It is called only under certain error
* the actions of libmod_load. It is called only under certain error
* conditions after the module has been loaded but not yet started.
*
* Returned Value:
@ -77,11 +77,11 @@
*
****************************************************************************/
int mod_unload(struct mod_loadinfo_s *loadinfo)
int libmod_unload(struct libmod_loadinfo_s *loadinfo)
{
/* Free all working buffers */
mod_freebuffers(loadinfo);
libmod_freebuffers(loadinfo);
/* Release memory holding the relocated ELF image */

6
binfmt/libmodule/libmodule_verify.c
View File

@ -1,5 +1,5 @@
/****************************************************************************
* binfmt/libmodule/mod_verify.c
* binfmt/libmodule/libmodule_verify.c
*
* Copyright (C) 2012 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
@ -67,7 +67,7 @@ static const char g_modmagic[EI_MAGIC_SIZE] =
****************************************************************************/
/****************************************************************************
* Name: mod_verifyheader
* Name: libmod_verifyheader
*
* Description:
* Given the header from a possible ELF executable, verify that it
@ -83,7 +83,7 @@ static const char g_modmagic[EI_MAGIC_SIZE] =
*
****************************************************************************/
int mod_verifyheader(FAR const Elf32_Ehdr *ehdr)
int libmod_verifyheader(FAR const Elf32_Ehdr *ehdr)
{
if (!ehdr)
{

50
binfmt/module.c
View File

@ -182,34 +182,8 @@ static void mod_dumploadinfo(FAR struct mod_loadinfo_s *loadinfo)
static void mod_dumpentrypt(FAR struct binary_s *binp,
FAR struct mod_loadinfo_s *loadinfo)
{
#ifdef CONFIG_ARCH_ADDRENV
int ret;
/* If CONFIG_ARCH_ADDRENV=y, then the loaded ELF lies in a virtual address
* space that may not be in place now. mod_addrenv_select() will
* temporarily instantiate that address space.
*/
ret = mod_addrenv_select(loadinfo);
if (ret < 0)
{
bdbg("ERROR: mod_addrenv_select() failed: %d\n", ret);
return;
}
#endif
mod_dumpbuffer("Entry code", (FAR const uint8_t *)binp->entrypt,
MIN(loadinfo->textsize - loadinfo->ehdr.e_entry, 512));
#ifdef CONFIG_ARCH_ADDRENV
/* Restore the original address environment */
ret = mod_addrenv_restore(loadinfo);
if (ret < 0)
{
bdbg("ERROR: mod_addrenv_restore() failed: %d\n", ret);
}
#endif
}
#else
# define mod_dumpentrypt(b,l)
@ -233,7 +207,7 @@ static int mod_loadbinary(FAR struct binary_s *binp)
/* Initialize the ELF library to load the program binary. */
ret = mod_init(binp->filename, &loadinfo);
ret = libmod_initialize(binp->filename, &loadinfo);
mod_dumploadinfo(&loadinfo);
if (ret != 0)
{
@ -243,7 +217,7 @@ static int mod_loadbinary(FAR struct binary_s *binp)
/* Load the program binary */
ret = mod_load(&loadinfo);
ret = libmod_load(&loadinfo);
mod_dumploadinfo(&loadinfo);
if (ret != 0)
{
@ -253,7 +227,7 @@ static int mod_loadbinary(FAR struct binary_s *binp)
/* Bind the program to the exported symbol table */
ret = mod_bind(&loadinfo, binp->exports, binp->nexports);
ret = libmod_bind(&loadinfo, binp->exports, binp->nexports);
if (ret != 0)
{
bdbg("Failed to bind symbols program binary: %d\n", ret);
@ -273,11 +247,7 @@ static int mod_loadbinary(FAR struct binary_s *binp)
* a memory leak?
*/
#ifdef CONFIG_ARCH_ADDRENV
# warning "REVISIT"
#else
binp->alloc[0] = (FAR void *)loadinfo.textalloc;
#endif
#ifdef CONFIG_BINFMT_CONSTRUCTORS
/* Save information about constructors. NOTE: destructors are not
@ -293,22 +263,14 @@ static int mod_loadbinary(FAR struct binary_s *binp)
binp->ndtors = loadinfo.ndtors;
#endif
#ifdef CONFIG_ARCH_ADDRENV
/* Save the address environment in the binfmt structure. This will be
* needed when the module is executed.
*/
up_addrenv_clone(&loadinfo.addrenv, &binp->addrenv);
#endif
mod_dumpentrypt(binp, &loadinfo);
mod_uninit(&loadinfo);
libmod_uninitialize(&loadinfo);
return OK;
errout_with_load:
mod_unload(&loadinfo);
libmod_unload(&loadinfo);
errout_with_init:
mod_uninit(&loadinfo);
libmod_uninitialize(&loadinfo);
errout:
return ret;
}

1
include/nuttx/binfmt/elf.h
View File

@ -336,6 +336,7 @@ int up_relocateadd(FAR const Elf32_Rela *rel,
* Always returns Zero (OK).
*
****************************************************************************/
int up_init_exidx(Elf32_Addr address, Elf32_Word size);
#endif

10
include/nuttx/binfmt/module.h
View File

@ -161,7 +161,7 @@ extern "C"
****************************************************************************/
/****************************************************************************
* Name: mod_init
* Name: libmod_initialize
*
* Description:
* This function is called to configure the library to process an kernel
@ -173,10 +173,11 @@ extern "C"
*
****************************************************************************/
int mod_init(FAR const char *filename, FAR struct mod_loadinfo_s *loadinfo);
int libmod_initalize(FAR const char *filename,
FAR struct mod_loadinfo_s *loadinfo);
/****************************************************************************
* Name: mod_uninit
* Name: libmod_uninitialize
*
* Description:
* Releases any resources committed by mod_init(). This essentially
@ -188,7 +189,7 @@ int mod_init(FAR const char *filename, FAR struct mod_loadinfo_s *loadinfo);
*
****************************************************************************/
int mod_uninit(FAR struct mod_loadinfo_s *loadinfo);
int libmod_uninitialize(FAR struct mod_loadinfo_s *loadinfo);
/****************************************************************************
* Name: mod_load
@ -336,6 +337,7 @@ int up_relocateadd(FAR const Elf32_Rela *rel,
* Always returns Zero (OK).
*
****************************************************************************/
int up_init_exidx(Elf32_Addr address, Elf32_Word size);
#endif