static int nxflat_loadbinary(struct binary_s *binp)
{
struct nxflat_loadinfo_s loadinfo; /* Contains globals for libnxflat */
int ret;
bvdbg("Loading file: %s\n", binp->filename);
/* Initialize the xflat library to load the program binary. */
ret = nxflat_init(binp->filename, &loadinfo);
nxflat_dumploadinfo(&loadinfo);
if (ret != 0)
{
bdbg("Failed to initialize for load of NXFLT program: %d\n", ret);
goto errout;
}
/* Load the program binary */
ret = nxflat_load(&loadinfo);
nxflat_dumploadinfo(&loadinfo);
if (ret != 0)
{
bdbg("Failed to load NXFLT program binary: %d\n", ret);
goto errout_with_init;
}
/* Bind the program to the exported symbol table */
ret = nxflat_bind(&loadinfo, binp->exports, binp->nexports);
if (ret != 0)
{
bdbg("Failed to bind symbols program binary: %d\n", ret);
goto errout_with_load;
}
/* Return the load information */
binp->entrypt = (main_t)(loadinfo.ispace + loadinfo.entryoffs);
binp->ispace = (void*)loadinfo.ispace;
binp->dspace = (void*)loadinfo.dspace;
binp->isize = loadinfo.isize;
binp->stacksize = loadinfo.stacksize;
nxflat_dumpbuffer("Entry code", (FAR const uint8_t*)binp->entrypt,
MIN(binp->isize - loadinfo.entryoffs,512));
nxflat_uninit(&loadinfo);
return OK;
errout_with_load:
nxflat_unload(&loadinfo);
errout_with_init:
nxflat_uninit(&loadinfo);
errout:
return ret;
}
int nxflat_load(struct nxflat_loadinfo_s *loadinfo)
{
off_t doffset; /* Offset to .data in the NXFLAT file */
uint32_t dreadsize; /* Total number of bytes of .data to be read */
uint32_t relocsize; /* Memory needed to hold relocations */
uint32_t extrasize; /* MAX(BSS size, relocsize) */
int ret = OK;
/* Calculate the extra space we need to allocate. This extra space will be
* the size of the BSS section. This extra space will also be used
* temporarily to hold relocation information. So the allocated size of this
* region will either be the size of .data + size of.bss section OR, the
* size of .data + the relocation entries, whichever is larger
*
* This is the amount of memory that we have to have to hold the
* relocations.
*/
relocsize = loadinfo->reloccount * sizeof(struct nxflat_reloc_s);
/* In the file, the relocations should lie at the same offset as BSS.
* The additional amount that we allocate have to be either (1) the
* BSS size, or (2) the size of the relocation records, whicher is
* larger.
*/
extrasize = MAX(loadinfo->bsssize, relocsize);
/* Use this additional amount to adjust the total size of the dspace
* region.
*/
loadinfo->dsize = loadinfo->datasize + extrasize;
/* The number of bytes of data that we have to read from the file is
* the data size plus the size of the relocation table.
*/
dreadsize = loadinfo->datasize + relocsize;
/* We'll need this a few times. */
doffset = loadinfo->isize;
/* We will make two mmap calls create an address space for the executable.
* We will attempt to map the file to get the ISpace address space and
* to allocate RAM to get the DSpace address space. If the filesystem does
* not support file mapping, the map() implementation should do the
* right thing.
*/
/* The following call will give as a pointer to the mapped file ISpace.
* This may be in ROM, RAM, Flash, ... We don't really care where the memory
* resides as long as it is fully initialized and ready to execute.
*/
loadinfo->ispace = (uint32_t)mmap(NULL, loadinfo->isize, PROT_READ,
MAP_SHARED|MAP_FILE, loadinfo->filfd, 0);
if (loadinfo->ispace == (uint32_t)MAP_FAILED)
{
bdbg("Failed to map NXFLAT ISpace: %d\n", errno);
return -errno;
}
bvdbg("Mapped ISpace (%d bytes) at %08x\n", loadinfo->isize, loadinfo->ispace);
/* The following call allocate D-Space memory and will provide a pointer
* to the allocated (but still uninitialized) D-Space memory.
*/
ret = nxflat_addrenv_alloc(loadinfo, loadinfo->dsize);
if (ret < 0)
{
bdbg("ERROR: nxflat_addrenv_alloc() failed: %d\n", ret);
return ret;
}
bvdbg("Allocated DSpace (%d bytes) at %p\n",
loadinfo->dsize, loadinfo->dspace->region);
/* If CONFIG_ADDRENV=y, then the D-Space allocation lies in an address
* environment that may not be in place. So, in that case, we must call
* nxflat_addrenv_select to temporarily instantiate that address space
* it can be initialized.
*/
#ifdef CONFIG_ADDRENV
ret = nxflat_addrenv_select(loadinfo);
if (ret < 0)
{
bdbg("ERROR: nxflat_addrenv_select() failed: %d\n", ret);
return ret;
}
#endif
/* Now, read the data into allocated DSpace at doffset into the allocated
* DSpace memory.
*/
ret = nxflat_read(loadinfo, (char*)loadinfo->dspace->region, dreadsize, doffset);
if (ret < 0)
{
bdbg("Failed to read .data section: %d\n", ret);
goto errout;
}
bvdbg("TEXT: %08x Entry point offset: %08x Data offset: %08x\n",
loadinfo->ispace, loadinfo->entryoffs, doffset);
/* Restore the original address environment */
#ifdef CONFIG_ADDRENV
ret = nxflat_addrenv_restore(loadinfo);
if (ret < 0)
{
bdbg("ERROR: nxflat_addrenv_restore() failed: %d\n", ret);
return ret;
}
#endif
return OK;
errout:
#ifdef CONFIG_ADDRENV
(void)nxflat_addrenv_restore(loadinfo);
#endif
(void)nxflat_unload(loadinfo);
return ret;
}
