yystopf/openharmony_kernel_liteos_m
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 支持native动态加载组件

Browse Source 
1.【需求描述】
动态库开发部分：
gcc的sample code。
提供生成暴露接口生成机制，并允许产品新增需要暴露的接口。
提供可以判断库允许资源大小的能力，并提供相关工具辅助开发者确定开发的库要求的资源是否可以满足。

动态库运行部分：
提供elf load的api，可以加载指定路径下的库，并完成符号重映射等运行准备。
提供elf 暴露符号调用的api，用于调用库的api。
elf加载&链接异常时，有明确错误记录，返回明确错误类型。
提供elf 卸载的api。

2.【方案描述】
(1) 通过灌段的形式记录需要导出符号的地址信息，用于暴露内核对外的接口，在加载链接器中通过查询
对应的符号信息获取符号地址。
(2) 加载链接时，解析共享库并将共享库中可加载段通过文件系统读入内存中，并对共享库中未定义的、
需要重定位的符号进行重定位。需要调用符号时，根据符号名通过哈希表即可查询共享库提供的对应符号
的地址。

BREAKING CHANGE:
新增4个对外接口，声明在los_dynlink.h文件中，分别为：
(1) LOS_DynlinkInit: 动态加载模块初始化。
(2) LOS_SoLoad: 加载指定路径的共享库。
(3) LOS_FindSym: 根据共享库句柄查找指定符号。
(4) LOS_SoUnload: 卸载共享库。

close #I418HJ

Signed-off-by: Haryslee <lihao189@huawei.com>
Change-Id: I7669b7ef20096294f9d1094c85ac6602fefad354
This commit is contained in:
Haryslee
2021-07-18 16:47:24 +08:00
parent 7fe9cc9aa0
commit d75383400e
56 changed files with 3160 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
components/dynlink/BUILD.gn Normal file
View File

@@ -0,0 +1,51 @@
# Copyright (c) 2021-2021 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.
config("dynlink_config") {
include_dirs = [
"../../kernel/include",
"../../kernel/arch/include",
"../../utils",
".",
"//third_party/bounds_checking_function/include",
]
if (arch == "arm") {
include_dirs += [ "../../kernel/arch/arm/include" ]
} else {
assert(false,
"Dynlink module does not support for other archs except for arm!")
}
}
static_library("dynlink") {
sources = [ "los_dynlink.c" ]
public_configs = [ ":dynlink_config" ]
deps = [ "//kernel/liteos_m/kal/posix" ]
}

935
components/dynlink/los_dynlink.c Executable file
View File

@@ -0,0 +1,935 @@
/*
* Copyright (c) 2021-2021 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"
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
#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;
}
strcpy(dso->buf, 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:
LOS_MemFree(dso->pool, (VOID *)dso->loadBase);
ERR1:
close(dso->fd);
(VOID)LOS_MuxPost(g_dynlinkMux);
LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo->elfPhdr);
LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo);
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);
LOS_MemFree(dso->pool, (VOID *)dso->loadBase);
LOS_MemFree(OS_SYS_MEM_ADDR, dso->dlInfo);
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 */
#ifdef __cplusplus
#if __cplusplus
}
#endif /* __cplusplus */
#endif /* __cplusplus */

201
components/dynlink/los_dynlink.h Executable file
View File

@@ -0,0 +1,201 @@
/*
* Copyright (c) 2021-2021 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.
*/
#ifndef _LOS_DYNLINK_H
#define _LOS_DYNLINK_H
#include "elf.h"
#include "los_compiler.h"
#include "los_list.h"
#include "los_memory.h"
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif /* __cplusplus */
#endif /* __cplusplus */
#ifdef LOSCFG_AARCH64
typedef Elf64_Ehdr LD_ELF_EHDR;
typedef Elf64_Phdr LD_ELF_PHDR;
typedef Elf64_Sym LD_ELF_SYM;
typedef Elf64_Dyn LD_ELF_DYN;
typedef Elf64_Rel LD_ELF_REL;
typedef Elf64_Rela LD_ELF_RELA;
#define REL_TYPE(x) ELF64_R_TYPE(x)
#define REL_SYM(x) ELF64_R_SYM(x)
#define REL_INFO ELF64_R_INFO
#else
typedef Elf32_Ehdr LD_ELF_EHDR;
typedef Elf32_Phdr LD_ELF_PHDR;
typedef Elf32_Sym LD_ELF_SYM;
typedef Elf32_Dyn LD_ELF_DYN;
typedef Elf32_Rel LD_ELF_REL;
typedef Elf32_Rela LD_ELF_RELA;
#define REL_TYPE(x) ELF32_R_TYPE(x)
#define REL_SYM(x) ELF32_R_SYM(x)
#define REL_INFO ELF32_R_INFO
#endif
#define LD_ELFMAG "\177ELF"
#define LD_SELFMAG 4
#define PHDR_NUM_MAX 128
#define DYNAMIC_CNT 32
#define HASH_MASK 0xf0000000
#define WORD_SHIFT 4
#define HASH_SHIFT 24
#define BUCKET_IDX 2
#define ELF_ALIGN_UP(a, b) (((a) + ((b) - 1)) & ~((b) - 1))
#define ELF_ALIGN_DOWN(a, b) ((a) & ~((b) - 1))
#define ELF_ALIGN_OFFSET(a, b) ((a) & ((b) - 1))
#ifndef PATH_MAX
#define PATH_MAX 256
#endif
#ifndef FILE_LENGTH_MAX
#define FILE_LENGTH_MAX 0x40000
#endif
typedef VOID (*INIT_FINI_FUNC)(VOID);
typedef struct {
UINTPTR relTab;
UINT32 relTabSize;
UINT32 relEntSize;
} RelocInfo;
typedef struct {
RelocInfo rel;
RelocInfo rela;
RelocInfo jmpRel;
} RelocInfoTab;
typedef struct {
UINTPTR func;
UINTPTR array;
UINT32 arraySz;
} InitFiniInfo;
typedef struct {
InitFiniInfo init;
InitFiniInfo fini;
} InitFiniTab;
typedef struct {
LD_ELF_EHDR elfEhdr;
LD_ELF_PHDR *elfPhdr;
UINTPTR dynBase;
UINT32 *hashTab;
LD_ELF_SYM *symTab;
CHAR *symStrings;
RelocInfoTab relInfoTab;
} DynLinkInfo;
typedef struct {
CHAR *fileName;
INT32 fd;
DynLinkInfo *dlInfo;
UINTPTR loadBase;
InitFiniTab initFiniTab;
LOS_DL_LIST dsoNode;
UINT32 ref;
VOID *pool;
CHAR buf[];
} DynSharedObj;
typedef struct {
CHAR *name;
UINTPTR addr;
} SymInfo;
#define SYM_EXPORT(func) \
const SymInfo sym_##func __attribute__((section(".sym."#func))) = { \
.name = #func, \
.addr = (UINTPTR)func \
};
/*
* @brief Load the shared library file named by the NULL-terminated string filename and
* return a valid handle for the loaded library.
*
* @param fileName The name pointer of shared library.
* @param pool The heap for shared library to load. If the parameter, pool, is NULL, then
* the dynamic loader & linker module will use the default heap and the pool is not NULL,
* then the shared library will be loaded to the heap by pool.
*
* @note When the heap, pool, is not NULL, you should call LOS_MemInit() to initialize the
* pool before calling LOS_SoLoad(). By the way, the system will comsume a certain amount
* of memory to initialize the pool. LOS_SoLoad must not be called in interrupt callback.
*
* @return Return NULL if error. Return non-NULL if success.
*/
VOID *LOS_SoLoad(const CHAR *fileName, VOID *pool);
/*
* @brief Get the address of symbol named by the parameter, name, from the parameter, handle.
*
* @param handle The handle for the loaded shared library.
* @param name The name of symbol to search.
*
* @note LOS_FindSym must not be called in interrupt callback.
*
* @return Return NULL if error. Return non-NULL if success.
*/
VOID *LOS_FindSym(VOID *handle, const CHAR *name);
/*
* @brief Decrement the reference count on the loaded shared library refered to by handle.
* If the reference count drops to zero, then the library is unloaded.
*
* This function validates that the handle is valid.
*
* @param handle The handle for the loaded shared library by LOS_SoLoad() interface.
*
* @note LOS_SoUnload must not be called in interrupt callback.
*
* @return Return 1 if error. Return 0 if success.
*/
INT32 LOS_SoUnload(VOID *handle);
/*
* @brief Initialization for dynamic loader & linker module.
*
* @param VOID.
*
* @return Return LOS_NOK if error. Return LOS_OK if success.
*/
INT32 LOS_DynlinkInit(VOID);
#ifdef __cplusplus
#if __cplusplus
}
#endif /* __cplusplus */
#endif /* __cplusplus */
#endif /* _LOS_DYNLINK_H */

65
components/dynlink/script/so_parse Executable file
View File

@@ -0,0 +1,65 @@
#!/bin/bash
# Copyright (c) 2021-2021 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.
# Description: The script is used to calculate the memory size that the specified shared library
# will occupy when loading to the RAM.
READELF=readelf
RM=rm
SIZE=0x0
SIZE_ALL=0x0
SIZE_MAX=0
TMP_FILE=tmp.txt
if [ $# -lt 1 ]; then
echo "Usage: ./so_parse lib.so"
exit 1
fi
parse_line()
{
MEM_SIZE=$(echo $1 | awk '{print $6}')
echo ${MEM_SIZE}
}
${READELF} -l $1 | while read line; do
HEAD_STRING=$(echo ${line} | awk '{print $1}')
if [[ "${HEAD_STRING}" == *"LOAD"* ]]; then
SIZE=`parse_line "${line}"`
SIZE=`echo ${SIZE}`
SIZE_ALL=$((SIZE_ALL+SIZE))
fi
echo ${SIZE_ALL} >> ${TMP_FILE}
done
NEED_SIZE=`tail -n 1 ${TMP_FILE}`
echo "${NEED_SIZE} kb memory to reserve for $1!"
${RM} -f ${TMP_FILE}

4
components/fs/BUILD.gn
View File

@@ -28,9 +28,7 @@
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
static_library("fs_operations") {
sources = [
"./fs.c",
]
sources = [ "./fs.c" ]
include_dirs = [
"../../../kernel/arch/include",

2
components/fs/littlefs/BUILD.gn
View File

@@ -29,9 +29,9 @@
static_library("littlefs") {
sources = [
"lfs_api.c",
"//third_party/littlefs/lfs.c",
"//third_party/littlefs/lfs_util.c",
"lfs_api.c",
]
include_dirs = [

98
components/net/lwip-2.1/BUILD.gn
View File

@@ -1,50 +1,50 @@
# Copyright (c) 2021-2021 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
# Copyright (c) 2021-2021 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.
import("lwip_porting.gni")
import("//third_party/lwip/lwip.gni")
config("lwip_depends") {
defines = [ "_BSD_SOURCE = 1" ]
}
static_library("lwip") {
include_dirs = [
"//kernel/liteos_m/kal/posix/include",
"//kernel/liteos_m/kernel/arch/include",
]
include_dirs += LWIP_PORTING_INCLUDE_DIRS
include_dirs += LWIP_INCLUDE_DIRS
sources = LWIP_PORTING_FILES + LWIPNOAPPSFILES
configs += [ ":lwip_depends" ]
deps = [ "//kernel/liteos_m/kal/posix" ]
}
import("//third_party/lwip/lwip.gni")
import("lwip_porting.gni")
config("lwip_depends") {
defines = [ "_BSD_SOURCE = 1" ]
}
static_library("lwip") {
include_dirs = [
"//kernel/liteos_m/kal/posix/include",
"//kernel/liteos_m/kernel/arch/include",
]
include_dirs += LWIP_PORTING_INCLUDE_DIRS
include_dirs += LWIP_INCLUDE_DIRS
sources = LWIP_PORTING_FILES + LWIPNOAPPSFILES
configs += [ ":lwip_depends" ]
deps = [ "//kernel/liteos_m/kal/posix" ]
}

4
components/shell/BUILD.gn
View File

@@ -34,11 +34,11 @@ static_library("shell") {
"src/base/shmsg.c",
"src/base/show.c",
"src/cmds/date_shell.c",
"src/cmds/fullpath.c",
"src/cmds/mempt_shellcmd.c",
"src/cmds/shell_shellcmd.c",
"src/cmds/task_shellcmd.c",
"src/cmds/vfs_shellcmd.c",
"src/cmds/mempt_shellcmd.c",
"src/cmds/fullpath.c",
]
include_dirs = [

12
components/trace/BUILD.gn
View File

@@ -28,21 +28,21 @@
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
static_library("trace") {
sources = [
"los_trace.c",
"trace_offline.c",
"trace_online.c",
sources = [
"cnv/trace_cnv.c",
"los_trace.c",
"pipeline/serial/trace_pipeline_serial.c",
"pipeline/trace_pipeline.c",
"pipeline/trace_tlv.c",
"pipeline/serial/trace_pipeline_serial.c"
"trace_offline.c",
"trace_online.c",
]
include_dirs = [
"../../kernel/include",
"../../kernel/arch/include",
"../../utils",
"./",
"./",
"cnv",
"pipeline",
"pipeline/serial",