sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
21501f65b1
nuttx/binfmt/libnxflat/libnxflat_bind.c
Alin Jerpelea 61a4ab8966 binfmt: migrate to SPDX identifier 
Most tools used for compliance and SBOM generation use SPDX identifiers
This change brings us a step closer to an easy SBOM generation.

Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
2024-09-10 11:34:18 +08:00

610 lines
19 KiB
C
Raw Blame History

/****************************************************************************
* binfmt/libnxflat/libnxflat_bind.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <inttypes.h>
#include <stdint.h>
#include <string.h>
#include <nxflat.h>
#include <errno.h>
#include <assert.h>
#include <debug.h>
#include <arpa/inet.h>
#include <nuttx/binfmt/nxflat.h>
#include <nuttx/symtab.h>
#include "libnxflat.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* CONFIG_DEBUG_FEATURES, CONFIG_DEBUG_INFO, and CONFIG_DEBUG_BINFMT have to
* be defined or CONFIG_NXFLAT_DUMPBUFFER does nothing.
*/
#if !defined(CONFIG_DEBUG_INFO) || !defined (CONFIG_DEBUG_BINFMT)
# undef CONFIG_NXFLAT_DUMPBUFFER
#endif
#ifdef CONFIG_NXFLAT_DUMPBUFFER
# define nxflat_dumpbuffer(m,b,n) binfodumpbuffer(m,b,n)
#else
# define nxflat_dumpbuffer(m,b,n)
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: nxflat_bindrel32i
*
* Description:
* Perform the NXFLAT_RELOC_TYPE_REL32I binding:
*
* Meaning: Object file contains a 32-bit offset into I-Space at the
* offset.
* Fixup: Add mapped I-Space address to the offset.
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
static inline int nxflat_bindrel32i(FAR struct nxflat_loadinfo_s *loadinfo,
uint32_t offset)
{
FAR uint32_t *addr;
binfo("NXFLAT_RELOC_TYPE_REL32I Offset: %08" PRIx32
" I-Space: %" PRIxPTR "\n",
offset, loadinfo->ispace + sizeof(struct nxflat_hdr_s));
if (offset < loadinfo->dsize)
{
addr = (FAR uint32_t *)(offset + loadinfo->dspace->region);
binfo(" Before: %08" PRIx32 "\n", *addr);
*addr += (uint32_t)(loadinfo->ispace + sizeof(struct nxflat_hdr_s));
binfo(" After: %08" PRIx32 "\n", *addr);
return OK;
}
else
{
berr("Offset: %08" PRIx32 " does not lie in "
"D-Space size: %08" PRIx32 "\n",
offset, loadinfo->dsize);
return -EINVAL;
}
}
/****************************************************************************
* Name: nxflat_bindrel32d
*
* Description:
* Perform the NXFLAT_RELOC_TYPE_REL32D binding:
*
* Meaning: Object file contains a 32-bit offset into D-Space at the
* offset.
* Fixup: Add allocated D-Space address to the offset.
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
static inline int nxflat_bindrel32d(FAR struct nxflat_loadinfo_s *loadinfo,
uint32_t offset)
{
FAR uint32_t *addr;
binfo("NXFLAT_RELOC_TYPE_REL32D Offset: %08" PRIx32 " D-Space: %p\n",
offset, loadinfo->dspace->region);
if (offset < loadinfo->dsize)
{
addr = (FAR uint32_t *)(offset + loadinfo->dspace->region);
binfo(" Before: %08" PRIx32 "\n", *addr);
*addr += (uint32_t)(loadinfo->dspace->region);
binfo(" After: %08" PRIx32 "\n", *addr);
return OK;
}
else
{
berr("Offset: %08" PRIx32 " does not lie in "
"D-Space size: %08" PRIx32 "\n",
offset, loadinfo->dsize);
return -EINVAL;
}
}
/****************************************************************************
* Name: nxflat_bindrel32id
*
* Description:
* Perform the NXFLAT_RELOC_TYPE_REL32ID binding:
*
* Meaning: Object file contains a 32-bit offset into I-Space at the offset
* that will unfortunately be references relative to the GOT
* Fixup: Add allocated the mapped I-Space address MINUS the allocated
* D-Space address to the offset.
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
#ifdef NXFLAT_RELOC_TYPE_REL32ID
static inline int nxflat_bindrel32id(FAR struct nxflat_loadinfo_s *loadinfo,
uint32_t offset)
{
FAR uint32_t *addr;
binfo("NXFLAT_RELOC_TYPE_REL32D Offset: %08x D-Space: %p\n",
offset, loadinfo->dspace->region);
if (offset < loadinfo->dsize)
{
addr = (FAR uint32_t *)(offset + loadinfo->dspace->region);
binfo(" Before: %08x\n", *addr);
*addr += ((uint32_t)loadinfo->ispace -
(uint32_t)(loadinfo->dspace->region));
binfo(" After: %08x\n", *addr);
return OK;
}
else
{
berr("Offset: %08 does not lie in D-Space size: %08x\n",
offset, loadinfo->dsize);
return -EINVAL;
}
}
#endif
/****************************************************************************
* Name: nxflat_gotrelocs
*
* Description:
* Bind all of the GOT relocations in the loaded module described by
* 'loadinfo'
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
static inline int nxflat_gotrelocs(FAR struct nxflat_loadinfo_s *loadinfo)
{
FAR struct nxflat_reloc_s *relocs;
FAR struct nxflat_reloc_s reloc;
FAR struct nxflat_hdr_s *hdr;
uint32_t offset;
uint16_t nrelocs;
int ret;
int result;
int i;
/* The NXFLAT header is the first thing at the beginning of the ISpace. */
hdr = (FAR struct nxflat_hdr_s *)loadinfo->ispace;
/* From this, we can get the offset to the list of relocation entries */
offset = NTOHL(hdr->h_relocstart);
nrelocs = NTOHS(hdr->h_reloccount);
binfo("offset: %08lx nrelocs: %d\n", (long)offset, nrelocs);
/* The value of the relocation list that we get from the header is a
* file offset. We will have to convert this to an offset into the
* DSpace segment to get the pointer to the beginning of the relocation
* list.
*/
DEBUGASSERT(offset >= loadinfo->isize);
DEBUGASSERT(offset + nrelocs * sizeof(struct nxflat_reloc_s)
<= (loadinfo->isize + loadinfo->dsize));
relocs = (FAR struct nxflat_reloc_s *)
(offset - loadinfo->isize + loadinfo->dspace->region);
binfo("isize: %08lx dpsace: %p relocs: %p\n",
(long)loadinfo->isize, loadinfo->dspace->region, relocs);
/* All relocations are performed within the D-Space allocation. If
* CONFIG_ARCH_ADDRENV=y, then that 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
* before the relocations can be performed.
*/
#ifdef CONFIG_ARCH_ADDRENV
ret = nxflat_addrenv_select(loadinfo);
if (ret < 0)
{
berr("ERROR: nxflat_addrenv_select() failed: %d\n", ret);
return ret;
}
#endif
/* Now, traverse the relocation list of and bind each GOT relocation. */
ret = OK; /* Assume success */
for (i = 0; i < nrelocs; i++)
{
/* Handle the relocation by the relocation type */
reloc = *relocs++;
result = OK;
switch (NXFLAT_RELOC_TYPE(reloc.r_info))
{
/* NXFLAT_RELOC_TYPE_REL32I Meaning: Object file contains a 32-bit
* offset into I-Space at the
* offset.
* Fixup: Add mapped I-Space address
* to the offset.
*/
case NXFLAT_RELOC_TYPE_REL32I:
{
result = nxflat_bindrel32i(loadinfo,
NXFLAT_RELOC_OFFSET(reloc.r_info));
}
break;
/* NXFLAT_RELOC_TYPE_REL32D Meaning: Object file contains a 32-bit
* offset into D-Space at the
* offset.
* Fixup: Add allocated D-Space address
* to the offset.
*/
case NXFLAT_RELOC_TYPE_REL32D:
{
result = nxflat_bindrel32d(loadinfo,
NXFLAT_RELOC_OFFSET(reloc.r_info));
}
break;
/* NXFLAT_RELOC_TYPE_REL32ID Meaning: Object file contains a 32-bit
* offset into I-Space at the
* offset that will unfortunately
* be references relative to the
* GOT
* Fixup: Add allocated the mapped
* I-Space address MINUS the
* allocated D-Space address to
* the offset.
*/
#ifdef NXFLAT_RELOC_TYPE_REL32ID
case NXFLAT_RELOC_TYPE_REL32ID:
{
result = nxflat_bindrel32id(loadinfo,
NXFLAT_RELOC_OFFSET(reloc.r_info));
}
break;
#endif
default:
{
berr("ERROR: Unrecognized relocation type: %" PRId32 "\n",
(uint32_t)NXFLAT_RELOC_TYPE(reloc.r_info));
result = -EINVAL;
}
break;
}
/* Check for failures */
if (result < 0 && ret == OK)
{
ret = result;
}
}
/* Dump the relocation got */
#ifdef CONFIG_NXFLAT_DUMPBUFFER
if (ret == OK && nrelocs > 0)
{
relocs = (FAR struct nxflat_reloc_s *)
(offset - loadinfo->isize + loadinfo->dspace->region);
nxflat_dumpbuffer("GOT", (FAR const uint8_t *)relocs,
nrelocs * sizeof(struct nxflat_reloc_s));
}
#endif
/* Restore the original address environment */
#ifdef CONFIG_ARCH_ADDRENV
ret = nxflat_addrenv_restore(loadinfo);
if (ret < 0)
{
berr("ERROR: nxflat_addrenv_restore() failed: %d\n", ret);
}
#endif
return ret;
}
/****************************************************************************
* Name: nxflat_bindimports
*
* Description:
* Bind the imported symbol names in the loaded module described by
* 'loadinfo' using the exported symbol values provided by 'symtab'
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
static inline int nxflat_bindimports(FAR struct nxflat_loadinfo_s *loadinfo,
FAR const struct symtab_s *exports,
int nexports)
{
FAR struct nxflat_import_s *imports;
FAR struct nxflat_hdr_s *hdr;
FAR const struct symtab_s *symbol;
FAR char *symname;
uint32_t offset;
uint16_t nimports;
#ifdef CONFIG_ARCH_ADDRENV
int ret;
#endif
int i;
/* The NXFLAT header is the first thing at the beginning of the ISpace. */
hdr = (FAR struct nxflat_hdr_s *)loadinfo->ispace;
/* From this, we can get the offset to the list of symbols imported by
* this module and the number of symbols imported by this module.
*/
offset = NTOHL(hdr->h_importsymbols);
nimports = NTOHS(hdr->h_importcount);
binfo("Imports offset: %08" PRIx32 " nimports: %d\n", offset, nimports);
/* The import[] table resides within the D-Space allocation. If
* CONFIG_ARCH_ADDRENV=y, then that 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
* before the import[] table can be modified.
*/
#ifdef CONFIG_ARCH_ADDRENV
ret = nxflat_addrenv_select(loadinfo);
if (ret < 0)
{
berr("ERROR: nxflat_addrenv_select() failed: %d\n", ret);
return ret;
}
#endif
/* Verify that this module requires imported symbols */
if (offset != 0 && nimports > 0)
{
/* It does.. make sure that exported symbols are provided */
DEBUGASSERT(exports && nexports > 0);
/* If non-zero, the value of the imported symbol list that we get
* from the header is a file offset. We will have to convert this
* to an offset into the DSpace segment to get the pointer to the
* beginning of the imported symbol list.
*/
DEBUGASSERT(offset >= loadinfo->isize &&
offset < loadinfo->isize + loadinfo->dsize);
imports = (FAR struct nxflat_import_s *)
(offset - loadinfo->isize + loadinfo->dspace->region);
/* Now, traverse the list of imported symbols and attempt to bind
* each symbol to the value exported by from the exported symbol
* table.
*/
for (i = 0; i < nimports; i++)
{
binfo("Import[%d] (%p) "
"offset: %08" PRIx32 " func: %08" PRIx32 "\n",
i, &imports[i], imports[i].i_funcname,
imports[i].i_funcaddress);
/* Get a pointer to the imported symbol name. The name itself
* lies in the TEXT segment. But the reference to the name
* lies in DATA segment. Therefore, the name reference should
* have been relocated when the module was loaded.
*/
offset = imports[i].i_funcname;
DEBUGASSERT(offset < loadinfo->isize);
symname = (FAR char *)
(offset + loadinfo->ispace + sizeof(struct nxflat_hdr_s));
/* Find the exported symbol value for this symbol name. */
symbol = symtab_findbyname(exports, symname, nexports);
if (!symbol)
{
berr("Exported symbol \"%s\" not found\n", symname);
#ifdef CONFIG_ARCH_ADDRENV
nxflat_addrenv_restore(loadinfo);
#endif
return -ENOENT;
}
/* And put this into the module's import structure. */
imports[i].i_funcaddress = (uint32_t)symbol->sym_value;
binfo("Bound import[%d] (%p) to export '%s' (%08" PRIx32 ")\n",
i, &imports[i], symname, imports[i].i_funcaddress);
}
}
/* Dump the relocation import table */
#ifdef CONFIG_NXFLAT_DUMPBUFFER
if (nimports > 0)
{
nxflat_dumpbuffer("Imports", (FAR const uint8_t *)imports,
nimports * sizeof(struct nxflat_import_s));
}
#endif
/* Restore the original address environment */
#ifdef CONFIG_ARCH_ADDRENV
ret = nxflat_addrenv_restore(loadinfo);
if (ret < 0)
{
berr("ERROR: nxflat_addrenv_restore() failed: %d\n", ret);
}
return ret;
#else
return OK;
#endif
}
/****************************************************************************
* Name: nxflat_clearbss
*
* Description:
* Clear uninitialized .bss memory
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
static inline int nxflat_clearbss(FAR struct nxflat_loadinfo_s *loadinfo)
{
#ifdef CONFIG_ARCH_ADDRENV
int ret;
#endif
/* .bss resides within the D-Space allocation. If CONFIG_ARCH_ADDRENV=y,
* then that 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 before the .bss can be
* accessed.
*/
#ifdef CONFIG_ARCH_ADDRENV
ret = nxflat_addrenv_select(loadinfo);
if (ret < 0)
{
berr("ERROR: nxflat_addrenv_select() failed: %d\n", ret);
return ret;
}
#endif
/* Zero the BSS area */
memset((FAR void *)(loadinfo->dspace->region + loadinfo->datasize), 0,
loadinfo->bsssize);
/* Restore the original address environment */
#ifdef CONFIG_ARCH_ADDRENV
ret = nxflat_addrenv_restore(loadinfo);
if (ret < 0)
{
berr("ERROR: nxflat_addrenv_restore() failed: %d\n", ret);
}
return ret;
#else
return OK;
#endif
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: nxflat_bind
*
* Description:
* Bind the imported symbol names in the loaded module described by
* 'loadinfo' using the exported symbol values provided by 'symtab'.
* After binding the module, clear the BSS region (which held the
* relocation data) in preparation for execution.
*
* Returned Value:
* 0 (OK) is returned on success and a negated errno is returned on
* failure.
*
****************************************************************************/
int nxflat_bind(FAR struct nxflat_loadinfo_s *loadinfo,
FAR const struct symtab_s *exports, int nexports)
{
/* Bind the imported symbol, absolute relocations separately. This is done
* before the standard relocations because that logic may modify the
* import list (for the better hopefully, but we don't want to depend on
* it).
*/
int ret = nxflat_bindimports(loadinfo, exports, nexports);
if (ret == OK)
{
/* Then bind all GOT relocations */
ret = nxflat_gotrelocs(loadinfo);
if (ret == OK)
{
/* Zero the BSS area, trashing the relocations that lived in that
* space in the loaded file.
*/
ret = nxflat_clearbss(loadinfo);
}
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink