926 lines
26 KiB
C
926 lines
26 KiB
C
/*
|
|
* Copyright (c) 2021-2022 Huawei Device Co., Ltd. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
* conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
* of conditions and the following disclaimer in the documentation and/or other materials
|
|
* provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
|
* to endorse or promote products derived from this software without specific prior written
|
|
* permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
#include "los_dynlink.h"
|
|
#include "stdlib.h"
|
|
#include "string.h"
|
|
#include "unistd.h"
|
|
#include "fcntl.h"
|
|
#include "errno.h"
|
|
#include "limits.h"
|
|
#include "sys/stat.h"
|
|
#include "securec.h"
|
|
#include "arch_elf.h"
|
|
#include "los_task.h"
|
|
#include "los_debug.h"
|
|
#include "los_mux.h"
|
|
|
|
#if (LOSCFG_DYNLINK == 1)
|
|
|
|
#if defined(__ICCARM__) || defined(__CC_ARM)
|
|
/**
|
|
* Place instructions below in .icf linker file:
|
|
*
|
|
* keep {section .TABLE.START};
|
|
* keep {section .sym.*};
|
|
* keep {section .table.end};
|
|
* define block SYMBOL_TABLE with fixed order
|
|
* {
|
|
* section .TABLE.START,
|
|
* section .sym.*,
|
|
* section .table.end
|
|
* };
|
|
* place in ROM_region {readonly, block SYMBOL_TABLE};
|
|
*/
|
|
const SymInfo symTableStart __attribute__((section(".TABLE.START"))) = {
|
|
.name = "start",
|
|
.addr = 0
|
|
};
|
|
|
|
const SymInfo symTableEnd __attribute__((section(".table.end"))) = {
|
|
.name = "end",
|
|
.addr = 0
|
|
};
|
|
#pragma section = ".TABLE.START"
|
|
#pragma section = ".table.end"
|
|
#elif defined(__CLANG_ARM) || defined(__GNUC__)
|
|
/**
|
|
* Place instructions below in rodata segment of .ld linker file:
|
|
*
|
|
* __sym_table_start = .;
|
|
* KEEP(*( SORT (.sym.*)));
|
|
* __sym_table_end = .;
|
|
*/
|
|
extern char __sym_table_start[];
|
|
extern char __sym_table_end[];
|
|
#else
|
|
#error Unknown compiler.
|
|
#endif
|
|
|
|
STATIC LOS_DL_LIST g_dynSharedObjLink;
|
|
STATIC UINT32 g_dynlinkMux;
|
|
|
|
STATIC DynSharedObj *OsIsPreLoaded(const CHAR *fileName)
|
|
{
|
|
DynSharedObj *dso = NULL;
|
|
|
|
LOS_DL_LIST_FOR_EACH_ENTRY(dso, &g_dynSharedObjLink, DynSharedObj, dsoNode) {
|
|
if (!strcmp(fileName, dso->fileName)) {
|
|
++dso->ref;
|
|
return dso;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
STATIC INT32 OsVerifyEhdr(const LD_ELF_EHDR *ehdr, UINT32 fileLen)
|
|
{
|
|
if (memcmp(ehdr->e_ident, LD_ELFMAG, LD_SELFMAG) != LOS_OK) {
|
|
PRINT_ERR("The file is not elf format\n");
|
|
return LOS_NOK;
|
|
}
|
|
if (ehdr->e_type != ET_DYN) {
|
|
PRINT_ERR("The file is not shared library\n");
|
|
return LOS_NOK;
|
|
}
|
|
if (!check_arch(ehdr)) {
|
|
PRINT_ERR("The file can not load in current platform\n");
|
|
return LOS_NOK;
|
|
}
|
|
if (ehdr->e_phnum > PHDR_NUM_MAX) {
|
|
PRINT_ERR("The num of program header is out of limit\n");
|
|
return LOS_NOK;
|
|
}
|
|
if (ehdr->e_phoff > fileLen) {
|
|
PRINT_ERR("The offset of program header is invalid, elf file is bad\n");
|
|
return LOS_NOK;
|
|
}
|
|
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC INT32 OsReadELFInfo(INT32 fd, UINT8 *buffer, size_t readSize, off_t offset)
|
|
{
|
|
ssize_t byteNum;
|
|
off_t returnPos;
|
|
|
|
if (readSize > 0) {
|
|
returnPos = lseek(fd, offset, SEEK_SET);
|
|
if (returnPos != offset) {
|
|
PRINT_ERR("Failed to seek the position!, offset: %#x\n", offset);
|
|
return LOS_NOK;
|
|
}
|
|
|
|
byteNum = read(fd, buffer, readSize);
|
|
if (byteNum <= 0) {
|
|
PRINT_ERR("Failed to read from offset: %#x!\n", offset);
|
|
return LOS_NOK;
|
|
}
|
|
}
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC INT32 OsGetFileLength(UINT32 *fileLen, const CHAR *fileName)
|
|
{
|
|
struct stat buf;
|
|
INT32 ret;
|
|
|
|
ret = stat(fileName, &buf);
|
|
if (ret < 0) {
|
|
PRINT_ERR("Failed to stat file: %s, errno: %d\n", fileName, errno);
|
|
return LOS_NOK;
|
|
}
|
|
|
|
if (buf.st_size > FILE_LENGTH_MAX) {
|
|
PRINT_ERR("The file: %s length is out of limit!\n", fileName);
|
|
return LOS_NOK;
|
|
}
|
|
|
|
*fileLen = (UINT32)buf.st_size;
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC INT32 OsReadEhdr(INT32 fd, UINT32 fileLen, DynLinkInfo *dlInfo)
|
|
{
|
|
INT32 ret;
|
|
|
|
ret = OsReadELFInfo(fd, (UINT8 *)&dlInfo->elfEhdr, sizeof(LD_ELF_EHDR), 0);
|
|
if (ret != LOS_OK) {
|
|
return -EIO;
|
|
}
|
|
|
|
ret = OsVerifyEhdr(&dlInfo->elfEhdr, fileLen);
|
|
if (ret != LOS_OK) {
|
|
return -ELIBBAD;
|
|
}
|
|
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC INT32 OsReadPhdrs(INT32 fd, UINT32 fileLen, DynLinkInfo *dlInfo)
|
|
{
|
|
INT32 ret;
|
|
UINT32 size;
|
|
LD_ELF_EHDR *ehdr = &dlInfo->elfEhdr;
|
|
|
|
if ((ehdr->e_phnum == 0) || (ehdr->e_phentsize != sizeof(LD_ELF_PHDR))) {
|
|
goto ERR;
|
|
}
|
|
|
|
size = sizeof(LD_ELF_PHDR) * ehdr->e_phnum;
|
|
if ((ehdr->e_phoff + size) > fileLen) {
|
|
goto ERR;
|
|
}
|
|
|
|
dlInfo->elfPhdr = (LD_ELF_PHDR *)LOS_MemAlloc(OS_SYS_MEM_ADDR, size);
|
|
if (dlInfo->elfPhdr == NULL) {
|
|
return -ENOMEM;
|
|
}
|
|
|
|
ret = OsReadELFInfo(fd, (UINT8 *)dlInfo->elfPhdr, size, ehdr->e_phoff);
|
|
if (ret != LOS_OK) {
|
|
LOS_MemFree(OS_SYS_MEM_ADDR, dlInfo->elfPhdr);
|
|
return -EIO;
|
|
}
|
|
|
|
return LOS_OK;
|
|
|
|
ERR:
|
|
PRINT_ERR("the file is bad\n");
|
|
return -ELIBBAD;
|
|
}
|
|
|
|
STATIC DynSharedObj *OsLoadInit(const CHAR *fileName, VOID *pool)
|
|
{
|
|
DynSharedObj *dso = NULL;
|
|
UINT32 allocSize, nameLen;
|
|
UINT32 fileLen = 0;
|
|
INT32 ret;
|
|
|
|
nameLen = strlen(fileName);
|
|
if (nameLen > PATH_MAX) {
|
|
PRINT_ERR("file name length is too long\n");
|
|
errno = ENAMETOOLONG;
|
|
return NULL;
|
|
}
|
|
allocSize = sizeof(DynSharedObj) + nameLen + 1;
|
|
|
|
dso = (DynSharedObj *)LOS_MemAlloc(OS_SYS_MEM_ADDR, allocSize);
|
|
if (dso == NULL) {
|
|
PRINT_ERR("failed to alloc for dso\n");
|
|
errno = ENOMEM;
|
|
return NULL;
|
|
}
|
|
(VOID)memset_s(dso, allocSize, 0, allocSize);
|
|
|
|
dso->dlInfo = (DynLinkInfo *)LOS_MemAlloc(OS_SYS_MEM_ADDR, sizeof(DynLinkInfo));
|
|
if (dso->dlInfo == NULL) {
|
|
LOS_MemFree(OS_SYS_MEM_ADDR, dso);
|
|
PRINT_ERR("failed to alloc for loadInfo\n");
|
|
errno = ENOMEM;
|
|
return NULL;
|
|
}
|
|
(VOID)memset_s(dso->dlInfo, sizeof(DynLinkInfo), 0, sizeof(DynLinkInfo));
|
|
|
|
ret = OsGetFileLength(&fileLen, fileName);
|
|
if (ret != LOS_OK) {
|
|
errno = ENOENT;
|
|
goto ERR1;
|
|
}
|
|
|
|
dso->fd = open(fileName, O_RDONLY);
|
|
if (dso->fd < 0) {
|
|
PRINT_ERR("Failed to open ELF file: %s!\n", fileName);
|
|
goto ERR1;
|
|
}
|
|
|
|
ret = OsReadEhdr(dso->fd, fileLen, dso->dlInfo);
|
|
if (ret != LOS_OK) {
|
|
errno = -ret;
|
|
goto ERR2;
|
|
}
|
|
|
|
ret = OsReadPhdrs(dso->fd, fileLen, dso->dlInfo);
|
|
if (ret != LOS_OK) {
|
|
errno = -ret;
|
|
goto ERR2;
|
|
}
|
|
|
|
(void)strcpy_s(dso->buf, nameLen + 1, fileName);
|
|
dso->fileName = dso->buf;
|
|
dso->ref = 1;
|
|
dso->pool = (pool ? pool : OS_SYS_MEM_ADDR);
|
|
LOS_ListInit(&dso->dsoNode);
|
|
|
|
return dso;
|
|
|
|
ERR2:
|
|
close(dso->fd);
|
|
ERR1:
|
|
LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo);
|
|
LOS_MemFree(OS_SYS_MEM_ADDR, dso);
|
|
return NULL;
|
|
}
|
|
|
|
STATIC INT32 OsReserveSpace(const DynLinkInfo *dlInfo, UINT32 *boundary)
|
|
{
|
|
const LD_ELF_PHDR *elfPhdrTemp = dlInfo->elfPhdr;
|
|
INT32 phdrNum = dlInfo->elfEhdr.e_phnum;
|
|
UINTPTR addrMin = SIZE_MAX;
|
|
UINTPTR addrMax = 0;
|
|
UINT32 offStart = 0;
|
|
UINT64 size;
|
|
INT32 i;
|
|
|
|
for (i = 0; i < phdrNum; ++i, ++elfPhdrTemp) {
|
|
if (elfPhdrTemp->p_type == PT_TLS) {
|
|
PRINT_ERR("unsupport tls\n");
|
|
return 0;
|
|
}
|
|
if (elfPhdrTemp->p_type != PT_LOAD) {
|
|
continue;
|
|
}
|
|
|
|
if (*boundary == 0) {
|
|
*boundary = elfPhdrTemp->p_align;
|
|
}
|
|
|
|
if (elfPhdrTemp->p_vaddr < addrMin) {
|
|
addrMin = elfPhdrTemp->p_vaddr;
|
|
offStart = elfPhdrTemp->p_offset;
|
|
}
|
|
if ((elfPhdrTemp->p_vaddr + elfPhdrTemp->p_memsz) > addrMax) {
|
|
addrMax = elfPhdrTemp->p_vaddr + elfPhdrTemp->p_memsz;
|
|
}
|
|
}
|
|
|
|
if ((addrMin == addrMax) || (addrMax < addrMin)) {
|
|
return 0;
|
|
}
|
|
size = ELF_ALIGN_UP(addrMax, *boundary) - ELF_ALIGN_DOWN(addrMin, *boundary) + ELF_ALIGN_DOWN(offStart, *boundary);
|
|
|
|
return (size > UINT_MAX) ? 0 : (UINT32)size;
|
|
}
|
|
|
|
STATIC UINTPTR OsDoLoadFile(INT32 fd, UINTPTR addr, const LD_ELF_PHDR *elfPhdr, UINT32 boundary)
|
|
{
|
|
INT32 ret;
|
|
UINT32 offset = elfPhdr->p_offset - ELF_ALIGN_OFFSET(elfPhdr->p_vaddr, boundary);
|
|
UINT32 size = elfPhdr->p_filesz + ELF_ALIGN_OFFSET(elfPhdr->p_vaddr, boundary);
|
|
if (size == 0) {
|
|
return 0;
|
|
}
|
|
|
|
addr = ELF_ALIGN_DOWN(addr, boundary);
|
|
ret = OsReadELFInfo(fd, (UINT8 *)addr, size, offset);
|
|
if (ret != LOS_OK) {
|
|
return 0;
|
|
}
|
|
|
|
return addr;
|
|
}
|
|
|
|
STATIC INT32 OsLoadELFFile(DynSharedObj *dso, UINT32 boundary)
|
|
{
|
|
DynLinkInfo *dlInfo = dso->dlInfo;
|
|
const LD_ELF_PHDR *elfPhdrTemp = dlInfo->elfPhdr;
|
|
const LD_ELF_EHDR *elfEhdr = &dlInfo->elfEhdr;
|
|
UINTPTR loadBase = dso->loadBase;
|
|
UINTPTR vAddr, loadAddr, bssStart, bssEnd;
|
|
INT32 i;
|
|
|
|
for (i = 0; i < elfEhdr->e_phnum; ++i, ++elfPhdrTemp) {
|
|
if (elfPhdrTemp->p_type != PT_LOAD) {
|
|
continue;
|
|
}
|
|
|
|
if ((elfPhdrTemp->p_flags & PF_R) == 0) {
|
|
return -ENOEXEC;
|
|
}
|
|
vAddr = elfPhdrTemp->p_vaddr;
|
|
|
|
loadAddr = OsDoLoadFile(dso->fd, (vAddr + loadBase), elfPhdrTemp, boundary);
|
|
if (loadAddr == 0) {
|
|
return -EFAULT;
|
|
}
|
|
|
|
if ((elfPhdrTemp->p_memsz > elfPhdrTemp->p_filesz) && (elfPhdrTemp->p_flags & PF_W)) {
|
|
bssStart = loadAddr + ELF_ALIGN_OFFSET(vAddr, boundary) + elfPhdrTemp->p_filesz;
|
|
bssEnd = loadAddr + ELF_ALIGN_OFFSET(vAddr, boundary) + elfPhdrTemp->p_memsz;
|
|
(VOID)memset_s((VOID *)bssStart, bssEnd - bssStart, 0, bssEnd - bssStart);
|
|
}
|
|
}
|
|
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC INT32 OsLoadLibrary(DynSharedObj *dso)
|
|
{
|
|
UINT32 loadSize;
|
|
UINT32 boundary = 0;
|
|
INT32 ret;
|
|
|
|
loadSize = OsReserveSpace(dso->dlInfo, &boundary);
|
|
if (loadSize == 0) {
|
|
PRINT_ERR("failed to reserve space!\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
dso->loadBase = (UINTPTR)LOS_MemAllocAlign(dso->pool, loadSize, boundary);
|
|
if (dso->loadBase == 0) {
|
|
PRINT_ERR("failed to alloc memory for loading shared library\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
ret = OsLoadELFFile(dso, boundary);
|
|
if (ret != LOS_OK) {
|
|
LOS_MemFree(dso->pool, (VOID *)dso->loadBase);
|
|
PRINT_ERR("failed to load shared library\n");
|
|
return ret;
|
|
}
|
|
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC INT32 OsGetDynBase(DynSharedObj *dso)
|
|
{
|
|
DynLinkInfo *dlInfo = dso->dlInfo;
|
|
const LD_ELF_PHDR *elfPhdrTemp = dlInfo->elfPhdr;
|
|
INT32 phdrNum = dlInfo->elfEhdr.e_phnum;
|
|
INT32 i;
|
|
|
|
for (i = 0; i < phdrNum; ++i, ++elfPhdrTemp) {
|
|
if (elfPhdrTemp->p_type != PT_DYNAMIC) {
|
|
continue;
|
|
}
|
|
dlInfo->dynBase = dso->loadBase + elfPhdrTemp->p_vaddr;
|
|
return LOS_OK;
|
|
}
|
|
|
|
return LOS_NOK;
|
|
}
|
|
|
|
STATIC INT32 OsParseDynamic(DynSharedObj *dso)
|
|
{
|
|
LD_ELF_DYN *dyn = NULL;
|
|
DynLinkInfo *dlInfo = dso->dlInfo;
|
|
RelocInfoTab *relInfoTab = &dlInfo->relInfoTab;
|
|
|
|
for (dyn = (LD_ELF_DYN *)dlInfo->dynBase; dyn->d_tag != DT_NULL; ++dyn) {
|
|
switch (dyn->d_tag) {
|
|
case DT_NEEDED:
|
|
PRINT_ERR("shared library should not depend on others\n");
|
|
return -ENOTSUP;
|
|
case DT_TEXTREL:
|
|
PRINT_ERR("you should recompile shared library with -fPIC\n");
|
|
return -EFAULT;
|
|
case DT_HASH:
|
|
dlInfo->hashTab = (UINT32 *)(dso->loadBase + dyn->d_un.d_ptr);
|
|
break;
|
|
case DT_SYMTAB:
|
|
dlInfo->symTab = (LD_ELF_SYM *)(dso->loadBase + dyn->d_un.d_ptr);
|
|
break;
|
|
case DT_STRTAB:
|
|
dlInfo->symStrings = (CHAR *)(dso->loadBase + dyn->d_un.d_ptr);
|
|
break;
|
|
case DT_REL:
|
|
relInfoTab->rel.relTab = dso->loadBase + dyn->d_un.d_ptr;
|
|
relInfoTab->rel.relEntSize = sizeof(LD_ELF_REL);
|
|
break;
|
|
case DT_RELSZ:
|
|
relInfoTab->rel.relTabSize = dyn->d_un.d_val;
|
|
break;
|
|
case DT_RELA:
|
|
relInfoTab->rela.relTab = dso->loadBase + dyn->d_un.d_ptr;
|
|
relInfoTab->rela.relEntSize = sizeof(LD_ELF_RELA);
|
|
break;
|
|
case DT_RELASZ:
|
|
relInfoTab->rela.relTabSize = dyn->d_un.d_val;
|
|
break;
|
|
case DT_JMPREL:
|
|
relInfoTab->jmpRel.relTab = dso->loadBase + dyn->d_un.d_ptr;
|
|
break;
|
|
case DT_PLTRELSZ:
|
|
relInfoTab->jmpRel.relTabSize = dyn->d_un.d_val;
|
|
break;
|
|
case DT_PLTREL:
|
|
relInfoTab->jmpRel.relEntSize = (dyn->d_un.d_val == DT_REL) ? sizeof(LD_ELF_REL) : sizeof(LD_ELF_RELA);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC UINT32 OsGetHashVal(const CHAR *name)
|
|
{
|
|
UINT32 hashVal = 0;
|
|
UINT32 tmp;
|
|
const UINT8 *str = (const UINT8 *)name;
|
|
|
|
while (*str) {
|
|
hashVal = (*str) + (hashVal << WORD_SHIFT);
|
|
tmp = hashVal & HASH_MASK;
|
|
if (tmp != 0) {
|
|
hashVal ^= tmp >> HASH_SHIFT;
|
|
}
|
|
|
|
hashVal &= ~tmp;
|
|
++str;
|
|
}
|
|
|
|
return hashVal;
|
|
}
|
|
|
|
STATIC LD_ELF_SYM *OsFindSymInDso(const DynLinkInfo *dlInfo, const CHAR *name)
|
|
{
|
|
LD_ELF_SYM *symTab = dlInfo->symTab;
|
|
LD_ELF_SYM *sym = NULL;
|
|
CHAR *symStr = dlInfo->symStrings;
|
|
UINT32 *hashTab = dlInfo->hashTab;
|
|
UINT32 bucketNum = hashTab[0];
|
|
UINT32 *bucket = &hashTab[BUCKET_IDX];
|
|
UINT32 *chain = &bucket[bucketNum];
|
|
UINT32 hashVal = OsGetHashVal(name);
|
|
UINT32 symIdx;
|
|
|
|
for (symIdx = bucket[hashVal % bucketNum]; symIdx; symIdx = chain[symIdx]) {
|
|
if (strcmp(name, symStr + symTab[symIdx].st_name) != 0) {
|
|
continue;
|
|
}
|
|
|
|
sym = symTab + symIdx;
|
|
if ((sym->st_value == 0) || (sym->st_shndx == 0)) {
|
|
return NULL;
|
|
}
|
|
return symTab + symIdx;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
STATIC SymInfo *OsFindSymInTable(const CHAR *name)
|
|
{
|
|
#if defined(__ICCARM__) || defined(__CC_ARM)
|
|
SymInfo *symTab = (SymInfo *)__section_end(".TABLE.START");
|
|
UINT32 symTableSize = ((UINTPTR)__section_begin(".table.end") -
|
|
(UINTPTR)__section_end(".TABLE.START")) / sizeof(SymInfo);
|
|
#elif defined(__CLANG_ARM) || defined(__GNUC__)
|
|
SymInfo *symTab = (SymInfo *)__sym_table_start;
|
|
UINT32 symTableSize = (__sym_table_end - __sym_table_start) / sizeof(SymInfo);
|
|
#endif
|
|
INT32 startIdx = 0;
|
|
INT32 endIdx = symTableSize - 1;
|
|
INT32 ret, midIdx;
|
|
|
|
while (startIdx <= endIdx) {
|
|
midIdx = startIdx + ((UINT32)(endIdx - startIdx) >> 1);
|
|
ret = strcmp(symTab[midIdx].name, name);
|
|
if (ret > 0) {
|
|
endIdx = midIdx - 1;
|
|
} else if (ret < 0) {
|
|
startIdx = midIdx + 1;
|
|
} else {
|
|
return symTab + midIdx;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
STATIC UINTPTR OsFindSym(const DynSharedObj *dso, INT32 symIdx)
|
|
{
|
|
DynLinkInfo *dlInfo = dso->dlInfo;
|
|
CHAR *symStrings = dlInfo->symStrings;
|
|
CHAR *symStr = NULL;
|
|
LD_ELF_SYM *symTab = dlInfo->symTab;
|
|
LD_ELF_SYM *sym = NULL;
|
|
LD_ELF_SYM *symInDso = NULL;
|
|
SymInfo *symInTab = NULL;
|
|
|
|
sym = symTab + symIdx;
|
|
symStr = symStrings + sym->st_name;
|
|
if ((symInDso = OsFindSymInDso(dlInfo, symStr)) != NULL) {
|
|
return dso->loadBase + symInDso->st_value;
|
|
} else if ((symInTab = OsFindSymInTable(symStr)) != NULL) {
|
|
return symInTab->addr;
|
|
} else {
|
|
PRINT_ERR("failed to relocate %s, symbol: %s not found\n", dso->fileName, symStr);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
STATIC INT32 OsDoReloc(const DynSharedObj *dso, INT32 type, UINTPTR relocAddr, UINT32 addend, UINTPTR symAddr)
|
|
{
|
|
switch (type) {
|
|
case R_ARCH_NONE:
|
|
break;
|
|
case R_ARCH_GLOB_DAT:
|
|
case R_ARCH_JUMP_SLOT:
|
|
*(UINTPTR *)relocAddr = symAddr + addend;
|
|
break;
|
|
case R_ARCH_ABS32:
|
|
*(UINTPTR *)relocAddr = symAddr + ((addend != 0) ? addend : *(UINTPTR *)relocAddr);
|
|
break;
|
|
case R_ARCH_RELATIVE:
|
|
*(UINTPTR *)relocAddr = dso->loadBase + ((addend != 0) ? addend : *(UINTPTR *)relocAddr);
|
|
break;
|
|
default:
|
|
PRINT_ERR("failed to relocate %s, unsupported reloc type: %d\n", dso->fileName, type);
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC INT32 OsDoRelocSyms(DynSharedObj *dso, RelocInfo *relInfo)
|
|
{
|
|
UINT32 relStride = relInfo->relEntSize / sizeof(UINT32);
|
|
UINT32 *relTab = (UINT32 *)relInfo->relTab;
|
|
UINT32 addend;
|
|
UINTPTR relocAddr, symAddr;
|
|
INT32 i, symIdx, ret, type;
|
|
|
|
for (i = 0; i < relInfo->relTabSize; i += relInfo->relEntSize, relTab += relStride) {
|
|
type = REL_TYPE(relTab[1]);
|
|
if (type == R_ARCH_NONE) {
|
|
continue;
|
|
}
|
|
|
|
symIdx = REL_SYM(relTab[1]);
|
|
if (symIdx == 0) {
|
|
symAddr = 0;
|
|
} else {
|
|
symAddr = OsFindSym(dso, symIdx);
|
|
if (symAddr == 0) {
|
|
return -EFAULT;
|
|
}
|
|
}
|
|
|
|
relocAddr = dso->loadBase + relTab[0];
|
|
addend = (relInfo->relEntSize == sizeof(LD_ELF_REL)) ? 0 : relTab[relStride - 1];
|
|
ret = OsDoReloc(dso, type, relocAddr, addend, symAddr);
|
|
if (ret != LOS_OK) {
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC INT32 OsRelocSyms(DynSharedObj *dso)
|
|
{
|
|
DynLinkInfo *dlInfo = dso->dlInfo;
|
|
RelocInfo *relInfo = (RelocInfo *)&dlInfo->relInfoTab;
|
|
INT32 relTypes = sizeof(RelocInfoTab) / sizeof(RelocInfo);
|
|
INT32 i, ret;
|
|
|
|
for (i = 0; i < relTypes; ++i, ++relInfo) {
|
|
if (relInfo->relTab == 0) {
|
|
continue;
|
|
}
|
|
|
|
ret = OsDoRelocSyms(dso, relInfo);
|
|
if (ret != LOS_OK) {
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC INT32 OsDoDynLink(DynSharedObj *dso)
|
|
{
|
|
INT32 ret;
|
|
|
|
ret = OsGetDynBase(dso);
|
|
if (ret != LOS_OK) {
|
|
PRINT_ERR("there are no dynamic segments in elf file\n");
|
|
return -ELIBBAD;
|
|
}
|
|
|
|
ret = OsParseDynamic(dso);
|
|
if (ret != LOS_OK) {
|
|
return ret;
|
|
}
|
|
|
|
ret = OsRelocSyms(dso);
|
|
if (ret != LOS_OK) {
|
|
return ret;
|
|
}
|
|
|
|
return LOS_OK;
|
|
}
|
|
|
|
STATIC VOID OsDeLoadInit(DynSharedObj *dso)
|
|
{
|
|
LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo->elfPhdr);
|
|
dso->dlInfo->elfPhdr = NULL;
|
|
close(dso->fd);
|
|
}
|
|
|
|
STATIC VOID OsGetInitFini(DynSharedObj *dso)
|
|
{
|
|
LD_ELF_DYN *dyn = NULL;
|
|
DynLinkInfo *dlInfo = dso->dlInfo;
|
|
InitFiniTab *initFiniTab = &dso->initFiniTab;
|
|
|
|
for (dyn = (LD_ELF_DYN *)dlInfo->dynBase; dyn->d_tag != DT_NULL; ++dyn) {
|
|
switch (dyn->d_tag) {
|
|
case DT_INIT:
|
|
initFiniTab->init.func = dyn->d_un.d_ptr;
|
|
break;
|
|
case DT_INIT_ARRAY:
|
|
initFiniTab->init.array = dyn->d_un.d_ptr;
|
|
break;
|
|
case DT_INIT_ARRAYSZ:
|
|
initFiniTab->init.arraySz = dyn->d_un.d_val;
|
|
break;
|
|
case DT_FINI:
|
|
initFiniTab->fini.func = dyn->d_un.d_ptr;
|
|
break;
|
|
case DT_FINI_ARRAY:
|
|
initFiniTab->fini.array = dyn->d_un.d_ptr;
|
|
break;
|
|
case DT_FINI_ARRAYSZ:
|
|
initFiniTab->fini.arraySz = dyn->d_un.d_val;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
STATIC VOID OsDoInit(DynSharedObj *dso)
|
|
{
|
|
InitFiniTab *initFiniTab = &dso->initFiniTab;
|
|
INIT_FINI_FUNC initFunc = NULL;
|
|
UINTPTR *func = NULL;
|
|
UINT32 funcNum;
|
|
|
|
OsGetInitFini(dso);
|
|
if (initFiniTab->init.func != 0) {
|
|
initFunc = (INIT_FINI_FUNC)(dso->loadBase + initFiniTab->init.func);
|
|
initFunc();
|
|
}
|
|
|
|
if (initFiniTab->init.array == 0) {
|
|
return;
|
|
}
|
|
|
|
funcNum = initFiniTab->init.arraySz / sizeof(UINTPTR);
|
|
func = (UINTPTR *)(dso->loadBase + initFiniTab->init.array);
|
|
while (funcNum--) {
|
|
initFunc = (INIT_FINI_FUNC)(*func);
|
|
initFunc();
|
|
++func;
|
|
}
|
|
}
|
|
|
|
VOID *LOS_SoLoad(const CHAR *fileName, VOID *pool)
|
|
{
|
|
INT32 ret;
|
|
DynSharedObj *dso = NULL;
|
|
|
|
if (fileName == NULL) {
|
|
PRINT_ERR("invalid file name\n");
|
|
errno = EINVAL;
|
|
return NULL;
|
|
}
|
|
|
|
(VOID)LOS_MuxPend(g_dynlinkMux, LOS_WAIT_FOREVER);
|
|
dso = OsIsPreLoaded(fileName);
|
|
if (dso != NULL) {
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
return dso;
|
|
}
|
|
|
|
dso = OsLoadInit(fileName, pool);
|
|
if (dso == NULL) {
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
return NULL;
|
|
}
|
|
|
|
ret = OsLoadLibrary(dso);
|
|
if (ret != LOS_OK) {
|
|
errno = -ret;
|
|
goto ERR1;
|
|
}
|
|
|
|
ret = OsDoDynLink(dso);
|
|
if (ret != LOS_OK) {
|
|
errno = -ret;
|
|
goto ERR2;
|
|
}
|
|
|
|
OsDoInit(dso);
|
|
|
|
LOS_ListAdd(&g_dynSharedObjLink, &dso->dsoNode);
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
OsDeLoadInit(dso);
|
|
|
|
return dso;
|
|
|
|
ERR2:
|
|
(VOID)LOS_MemFree(dso->pool, (VOID *)dso->loadBase);
|
|
ERR1:
|
|
close(dso->fd);
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
(VOID)LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo->elfPhdr);
|
|
(VOID)LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo);
|
|
(VOID)LOS_MemFree(OS_SYS_MEM_ADDR, dso);
|
|
return NULL;
|
|
}
|
|
|
|
STATIC DynSharedObj *OsCheckHandle(VOID *handle)
|
|
{
|
|
DynSharedObj *dso = NULL;
|
|
|
|
LOS_DL_LIST_FOR_EACH_ENTRY(dso, &g_dynSharedObjLink, DynSharedObj, dsoNode) {
|
|
if (handle == dso) {
|
|
return dso;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
VOID *LOS_FindSym(VOID *handle, const CHAR *name)
|
|
{
|
|
LD_ELF_SYM *sym = NULL;
|
|
DynSharedObj *dso = NULL;
|
|
VOID *symAddr = NULL;
|
|
|
|
if ((handle == NULL) || (name == NULL)) {
|
|
goto ERR;
|
|
}
|
|
|
|
(VOID)LOS_MuxPend(g_dynlinkMux, LOS_WAIT_FOREVER);
|
|
dso = OsCheckHandle(handle);
|
|
if (dso == NULL) {
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
goto ERR;
|
|
}
|
|
|
|
sym = OsFindSymInDso(dso->dlInfo, name);
|
|
if (sym == NULL) {
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
PRINT_ERR("failed to find symbol: %s\n", name);
|
|
errno = EFAULT;
|
|
return NULL;
|
|
}
|
|
symAddr = (VOID *)(dso->loadBase + sym->st_value);
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
return symAddr;
|
|
|
|
ERR:
|
|
PRINT_ERR("invalid input param\n");
|
|
errno = EINVAL;
|
|
return NULL;
|
|
}
|
|
|
|
STATIC VOID OsDoFini(DynSharedObj *dso)
|
|
{
|
|
InitFiniTab *initFiniTab = &dso->initFiniTab;
|
|
INIT_FINI_FUNC finiFunc = NULL;
|
|
UINTPTR *func = NULL;
|
|
UINT32 funcNum;
|
|
|
|
if (initFiniTab->fini.array != 0) {
|
|
funcNum = initFiniTab->fini.arraySz / sizeof(UINTPTR);
|
|
func = (UINTPTR *)(dso->loadBase + initFiniTab->fini.array) + funcNum;
|
|
while (funcNum--) {
|
|
--func;
|
|
finiFunc = (INIT_FINI_FUNC)(*func);
|
|
finiFunc();
|
|
}
|
|
}
|
|
|
|
if (initFiniTab->fini.func != 0) {
|
|
finiFunc = (INIT_FINI_FUNC)(dso->loadBase + initFiniTab->fini.func);
|
|
finiFunc();
|
|
}
|
|
}
|
|
|
|
INT32 LOS_SoUnload(VOID *handle)
|
|
{
|
|
DynSharedObj *dso = NULL;
|
|
|
|
if (handle == NULL) {
|
|
goto ERR;
|
|
}
|
|
|
|
(VOID)LOS_MuxPend(g_dynlinkMux, LOS_WAIT_FOREVER);
|
|
dso = OsCheckHandle(handle);
|
|
if (dso == NULL) {
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
goto ERR;
|
|
}
|
|
|
|
if (dso->ref > 1) {
|
|
--dso->ref;
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
return LOS_OK;
|
|
}
|
|
|
|
OsDoFini(dso);
|
|
|
|
LOS_ListDelete(&dso->dsoNode);
|
|
(VOID)LOS_MuxPost(g_dynlinkMux);
|
|
|
|
(VOID)LOS_MemFree(dso->pool, (VOID *)dso->loadBase);
|
|
if (dso->dlInfo != NULL) {
|
|
(VOID)LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo->elfPhdr);
|
|
}
|
|
(VOID)LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo);
|
|
(VOID)LOS_MemFree(OS_SYS_MEM_ADDR, dso);
|
|
|
|
return LOS_OK;
|
|
ERR:
|
|
PRINT_ERR("invalid handle\n");
|
|
errno = EINVAL;
|
|
return LOS_NOK;
|
|
}
|
|
|
|
INT32 LOS_DynlinkInit(VOID)
|
|
{
|
|
UINT32 ret;
|
|
|
|
LOS_ListInit(&g_dynSharedObjLink);
|
|
ret = LOS_MuxCreate(&g_dynlinkMux);
|
|
if (ret != LOS_OK) {
|
|
return LOS_NOK;
|
|
}
|
|
return LOS_OK;
|
|
}
|
|
|
|
#endif /* LOSCFG_DYNLINK */
|