p71924506
/
kernel_liteos_a
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

!687 feat: liteipc 静态内存优化 

Merge pull request !687 from zhushengle/liteipc
This commit is contained in:
openharmony_ci 2021-11-02 11:05:46 +00:00 committed by Gitee
parent fcb21ffc8a 52379242c1
commit 38163de8f3
6 changed files with 207 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
kernel/base/core/los_process.c
View File

@ -373,10 +373,7 @@ LITE_OS_SEC_TEXT VOID OsProcessResourcesToFree(LosProcessCB *processCB)
#endif
#ifdef LOSCFG_KERNEL_LITEIPC
if (OsProcessIsUserMode(processCB)) {
LiteIpcPoolDelete(&(processCB->ipcInfo), processCB->processID);
(VOID)memset_s(&(processCB->ipcInfo), sizeof(ProcIpcInfo), 0, sizeof(ProcIpcInfo));
}
(VOID)LiteIpcPoolDestroy(processCB->processID);
#endif
if (processCB->resourceLimit != NULL) {
@ -750,16 +747,6 @@ STATIC UINT32 OsProcessCreateInit(LosProcessCB *processCB, UINT32 flags, const C
goto EXIT;
}
#ifdef LOSCFG_KERNEL_LITEIPC
if (OsProcessIsUserMode(processCB)) {
ret = LiteIpcPoolInit(&(processCB->ipcInfo));
if (ret != LOS_OK) {
ret = LOS_ENOMEM;
goto EXIT;
}
}
#endif
#ifdef LOSCFG_FS_VFS
processCB->files = alloc_files();
if (processCB->files == NULL) {
@ -1439,10 +1426,7 @@ LITE_OS_SEC_TEXT UINT32 OsExecRecycleAndInit(LosProcessCB *processCB, const CHAR
}
#ifdef LOSCFG_KERNEL_LITEIPC
ret = LiteIpcPoolInit(&(processCB->ipcInfo));
if (ret != LOS_OK) {
return LOS_NOK;
}
(VOID)LiteIpcPoolDestroy(processCB->processID);
#endif
processCB->sigHandler = 0;
@ -1833,9 +1817,9 @@ STATIC UINT32 OsCopyProcessResources(UINT32 flags, LosProcessCB *child, LosProce
}
#ifdef LOSCFG_KERNEL_LITEIPC
if (OsProcessIsUserMode(child)) {
ret = LiteIpcPoolReInit(&child->ipcInfo, (const ProcIpcInfo *)(&run->ipcInfo));
if (ret != LOS_OK) {
if (run->ipcInfo != NULL) {
child->ipcInfo = LiteIpcPoolReInit((const ProcIpcInfo *)(run->ipcInfo));
if (child->ipcInfo == NULL) {
return LOS_ENOMEM;
}
}

5
kernel/base/core/los_task.c
View File

@ -510,7 +510,7 @@ LITE_OS_SEC_TEXT VOID OsTaskResourcesToFree(LosTaskCB *taskCB)
}
#ifdef LOSCFG_KERNEL_LITEIPC
LiteIpcRemoveServiceHandle(taskCB);
LiteIpcRemoveServiceHandle(taskCB->taskID);
#endif
}
#endif
@ -552,9 +552,6 @@ LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskCBInitBase(LosTaskCB *taskCB,
taskCB->currCpu = OS_TASK_INVALID_CPUID;
taskCB->cpuAffiMask = (initParam->usCpuAffiMask) ?
initParam->usCpuAffiMask : LOSCFG_KERNEL_CPU_MASK;
#endif
#ifdef LOSCFG_KERNEL_LITEIPC
LOS_ListInit(&(taskCB->msgListHead));
#endif
taskCB->policy = (initParam->policy == LOS_SCHED_FIFO) ? LOS_SCHED_FIFO : LOS_SCHED_RR;
taskCB->taskStatus = OS_TASK_STATUS_INIT;

2
kernel/base/include/los_process_pri.h
View File

@ -103,7 +103,7 @@ typedef struct ProcessCB {
UINTPTR sigHandler; /**< Signal handler */
sigset_t sigShare; /**< Signal share bit */
#ifdef LOSCFG_KERNEL_LITEIPC
ProcIpcInfo ipcInfo; /**< Memory pool for lite ipc */
ProcIpcInfo *ipcInfo; /**< Memory pool for lite ipc */
#endif
#ifdef LOSCFG_KERNEL_VM
LosVmSpace *vmSpace; /**< VMM space for processes */

7
kernel/base/include/los_task_pri.h
View File

@ -44,7 +44,9 @@
#ifdef LOSCFG_KERNEL_CPUP
#include "los_cpup_pri.h"
#endif
#ifdef LOSCFG_KERNEL_LITEIPC
#include "hm_liteipc.h"
#endif
#ifdef __cplusplus
#if __cplusplus
extern "C" {
@ -359,8 +361,7 @@ typedef struct {
UINT16 waitFlag; /**< The type of child process that is waiting, belonging to a group or parent,
a specific child process, or any child process */
#ifdef LOSCFG_KERNEL_LITEIPC
LOS_DL_LIST msgListHead;
BOOL accessMap[LOSCFG_BASE_CORE_TSK_LIMIT];
IpcTaskInfo *ipcTaskInfo;
#endif
#ifdef LOSCFG_KERNEL_PERF
UINTPTR pc;

266
kernel/extended/liteipc/hm_liteipc.c
View File

@ -75,7 +75,6 @@ STATIC HandleInfo g_cmsTask;
STATIC HandleInfo g_serviceHandleMap[MAX_SERVICE_NUM];
#endif
STATIC LOS_DL_LIST g_ipcPendlist;
STATIC LOS_DL_LIST g_ipcUsedNodelist[LOSCFG_BASE_CORE_PROCESS_LIMIT];
/* ipc lock */
SPIN_LOCK_INIT(g_ipcSpin);
@ -89,6 +88,7 @@ STATIC int LiteIpcMmap(struct file* filep, LosVmMapRegion *region);
STATIC UINT32 LiteIpcWrite(IpcContent *content);
STATIC UINT32 GetTid(UINT32 serviceHandle, UINT32 *taskID);
STATIC UINT32 HandleSpecialObjects(UINT32 dstTid, IpcListNode *node, BOOL isRollback);
STATIC ProcIpcInfo *LiteIpcPoolCreate(VOID);
STATIC const struct file_operations_vfs g_liteIpcFops = {
.open = LiteIpcOpen, /* open */
@ -99,7 +99,7 @@ STATIC const struct file_operations_vfs g_liteIpcFops = {
LITE_OS_SEC_TEXT_INIT UINT32 OsLiteIpcInit(VOID)
{
UINT32 ret, i;
UINT32 ret;
#if (USE_TASKID_AS_HANDLE == YES)
g_cmsTask.status = HANDLE_NOT_USED;
#else
@ -114,9 +114,6 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsLiteIpcInit(VOID)
PRINT_ERR("register lite_ipc driver failed:%d\n", ret);
}
LOS_ListInit(&(g_ipcPendlist));
for (i = 0; i < LOSCFG_BASE_CORE_PROCESS_LIMIT; i++) {
LOS_ListInit(&(g_ipcUsedNodelist[i]));
}
return ret;
}
@ -125,6 +122,16 @@ LOS_MODULE_INIT(OsLiteIpcInit, LOS_INIT_LEVEL_KMOD_EXTENDED);
LITE_OS_SEC_TEXT STATIC int LiteIpcOpen(struct file *filep)
{
LosProcessCB *pcb = OsCurrProcessGet();
if (pcb->ipcInfo != NULL) {
return 0;
}
pcb->ipcInfo = LiteIpcPoolCreate();
if (pcb->ipcInfo == NULL) {
return -ENOMEM;
}
return 0;
}
@ -133,11 +140,10 @@ LITE_OS_SEC_TEXT STATIC int LiteIpcClose(struct file *filep)
return 0;
}
LITE_OS_SEC_TEXT STATIC BOOL IsPoolMapped(VOID)
LITE_OS_SEC_TEXT STATIC BOOL IsPoolMapped(ProcIpcInfo *ipcInfo)
{
LosProcessCB *pcb = OsCurrProcessGet();
return (pcb->ipcInfo.pool.uvaddr != NULL) && (pcb->ipcInfo.pool.kvaddr != NULL) &&
(pcb->ipcInfo.pool.poolSize != 0);
return (ipcInfo->pool.uvaddr != NULL) && (ipcInfo->pool.kvaddr != NULL) &&
(ipcInfo->pool.poolSize != 0);
}
LITE_OS_SEC_TEXT STATIC INT32 DoIpcMmap(LosProcessCB *pcb, LosVmMapRegion *region)
@ -147,8 +153,8 @@ LITE_OS_SEC_TEXT STATIC INT32 DoIpcMmap(LosProcessCB *pcb, LosVmMapRegion *regio
PADDR_T pa;
UINT32 uflags = VM_MAP_REGION_FLAG_PERM_READ | VM_MAP_REGION_FLAG_PERM_USER;
LosVmPage *vmPage = NULL;
VADDR_T uva = (VADDR_T)(UINTPTR)pcb->ipcInfo.pool.uvaddr;
VADDR_T kva = (VADDR_T)(UINTPTR)pcb->ipcInfo.pool.kvaddr;
VADDR_T uva = (VADDR_T)(UINTPTR)pcb->ipcInfo->pool.uvaddr;
VADDR_T kva = (VADDR_T)(UINTPTR)pcb->ipcInfo->pool.kvaddr;
(VOID)LOS_MuxAcquire(&pcb->vmSpace->regionMux);
@ -191,28 +197,30 @@ LITE_OS_SEC_TEXT STATIC int LiteIpcMmap(struct file *filep, LosVmMapRegion *regi
int ret = 0;
LosVmMapRegion *regionTemp = NULL;
LosProcessCB *pcb = OsCurrProcessGet();
if ((region == NULL) || (region->range.size > LITE_IPC_POOL_MAX_SIZE) ||
ProcIpcInfo *ipcInfo = pcb->ipcInfo;
if ((ipcInfo == NULL) || (region == NULL) || (region->range.size > LITE_IPC_POOL_MAX_SIZE) ||
(!LOS_IsRegionPermUserReadOnly(region)) || (!LOS_IsRegionFlagPrivateOnly(region))) {
ret = -EINVAL;
goto ERROR_REGION_OUT;
}
if (IsPoolMapped()) {
if (IsPoolMapped(ipcInfo)) {
return -EEXIST;
}
if (pcb->ipcInfo.pool.uvaddr != NULL) {
regionTemp = LOS_RegionFind(pcb->vmSpace, (VADDR_T)(UINTPTR)pcb->ipcInfo.pool.uvaddr);
if (ipcInfo->pool.uvaddr != NULL) {
regionTemp = LOS_RegionFind(pcb->vmSpace, (VADDR_T)(UINTPTR)ipcInfo->pool.uvaddr);
if (regionTemp != NULL) {
(VOID)LOS_RegionFree(pcb->vmSpace, regionTemp);
}
}
pcb->ipcInfo.pool.uvaddr = (VOID *)(UINTPTR)region->range.base;
if (pcb->ipcInfo.pool.kvaddr != NULL) {
LOS_VFree(pcb->ipcInfo.pool.kvaddr);
pcb->ipcInfo.pool.kvaddr = NULL;
ipcInfo->pool.uvaddr = (VOID *)(UINTPTR)region->range.base;
if (ipcInfo->pool.kvaddr != NULL) {
LOS_VFree(ipcInfo->pool.kvaddr);
ipcInfo->pool.kvaddr = NULL;
}
/* use vmalloc to alloc phy mem */
pcb->ipcInfo.pool.kvaddr = LOS_VMalloc(region->range.size);
if (pcb->ipcInfo.pool.kvaddr == NULL) {
ipcInfo->pool.kvaddr = LOS_VMalloc(region->range.size);
if (ipcInfo->pool.kvaddr == NULL) {
ret = -ENOMEM;
goto ERROR_REGION_OUT;
}
@ -222,39 +230,58 @@ LITE_OS_SEC_TEXT STATIC int LiteIpcMmap(struct file *filep, LosVmMapRegion *regi
goto ERROR_MAP_OUT;
}
/* ipc pool init */
if (LOS_MemInit(pcb->ipcInfo.pool.kvaddr, region->range.size) != LOS_OK) {
if (LOS_MemInit(ipcInfo->pool.kvaddr, region->range.size) != LOS_OK) {
ret = -EINVAL;
goto ERROR_MAP_OUT;
}
pcb->ipcInfo.pool.poolSize = region->range.size;
ipcInfo->pool.poolSize = region->range.size;
return 0;
ERROR_MAP_OUT:
LOS_VFree(pcb->ipcInfo.pool.kvaddr);
LOS_VFree(ipcInfo->pool.kvaddr);
ERROR_REGION_OUT:
pcb->ipcInfo.pool.uvaddr = NULL;
pcb->ipcInfo.pool.kvaddr = NULL;
ipcInfo->pool.uvaddr = NULL;
ipcInfo->pool.kvaddr = NULL;
return ret;
}
LITE_OS_SEC_TEXT_INIT UINT32 LiteIpcPoolInit(ProcIpcInfo *ipcInfo)
LITE_OS_SEC_TEXT_INIT STATIC UINT32 LiteIpcPoolInit(ProcIpcInfo *ipcInfo)
{
ipcInfo->pool.uvaddr = NULL;
ipcInfo->pool.kvaddr = NULL;
ipcInfo->pool.poolSize = 0;
ipcInfo->ipcTaskID = INVAILD_ID;
LOS_ListInit(&ipcInfo->ipcUsedNodelist);
return LOS_OK;
}
LITE_OS_SEC_TEXT UINT32 LiteIpcPoolReInit(ProcIpcInfo *child, const ProcIpcInfo *parent)
LITE_OS_SEC_TEXT_INIT STATIC ProcIpcInfo *LiteIpcPoolCreate(VOID)
{
child->pool.uvaddr = parent->pool.uvaddr;
child->pool.kvaddr = NULL;
child->pool.poolSize = 0;
child->ipcTaskID = INVAILD_ID;
return LOS_OK;
ProcIpcInfo *ipcInfo = LOS_MemAlloc(m_aucSysMem1, sizeof(ProcIpcInfo));
if (ipcInfo == NULL) {
return NULL;
}
(VOID)memset_s(ipcInfo, sizeof(ProcIpcInfo), 0, sizeof(ProcIpcInfo));
(VOID)LiteIpcPoolInit(ipcInfo);
return ipcInfo;
}
LITE_OS_SEC_TEXT VOID LiteIpcPoolDelete(ProcIpcInfo *ipcInfo, UINT32 processID)
LITE_OS_SEC_TEXT ProcIpcInfo *LiteIpcPoolReInit(const ProcIpcInfo *parent)
{
ProcIpcInfo *ipcInfo = LiteIpcPoolCreate();
if (ipcInfo == NULL) {
return NULL;
}
ipcInfo->pool.uvaddr = parent->pool.uvaddr;
ipcInfo->pool.kvaddr = NULL;
ipcInfo->pool.poolSize = 0;
ipcInfo->ipcTaskID = INVAILD_ID;
return ipcInfo;
}
STATIC VOID LiteIpcPoolDelete(ProcIpcInfo *ipcInfo, UINT32 processID)
{
UINT32 intSave;
IpcUsedNode *node = NULL;
@ -262,8 +289,8 @@ LITE_OS_SEC_TEXT VOID LiteIpcPoolDelete(ProcIpcInfo *ipcInfo, UINT32 processID)
LOS_VFree(ipcInfo->pool.kvaddr);
ipcInfo->pool.kvaddr = NULL;
IPC_LOCK(intSave);
while (!LOS_ListEmpty(&g_ipcUsedNodelist[processID])) {
node = LOS_DL_LIST_ENTRY(g_ipcUsedNodelist[processID].pstNext, IpcUsedNode, list);
while (!LOS_ListEmpty(&ipcInfo->ipcUsedNodelist)) {
node = LOS_DL_LIST_ENTRY(ipcInfo->ipcUsedNodelist.pstNext, IpcUsedNode, list);
LOS_ListDelete(&node->list);
free(node);
}
@ -273,45 +300,75 @@ LITE_OS_SEC_TEXT VOID LiteIpcPoolDelete(ProcIpcInfo *ipcInfo, UINT32 processID)
for (UINT32 i = 0; i < MAX_SERVICE_NUM; i++) {
if (ipcInfo->access[i] == TRUE) {
ipcInfo->access[i] = FALSE;
OS_TCB_FROM_TID(i)->accessMap[processID] = FALSE;
if (OS_TCB_FROM_TID(i)->ipcTaskInfo != NULL) {
OS_TCB_FROM_TID(i)->ipcTaskInfo->accessMap[processID] = FALSE;
}
}
}
}
LITE_OS_SEC_TEXT UINT32 LiteIpcPoolDestroy(UINT32 processID)
{
LosProcessCB *pcb = OS_PCB_FROM_PID(processID);
if (pcb->ipcInfo == NULL) {
return LOS_NOK;
}
LiteIpcPoolDelete(pcb->ipcInfo, pcb->processID);
LOS_MemFree(m_aucSysMem1, pcb->ipcInfo);
pcb->ipcInfo = NULL;
return LOS_OK;
}
LITE_OS_SEC_TEXT_INIT STATIC IpcTaskInfo *LiteIpcTaskInit(VOID)
{
IpcTaskInfo *taskInfo = LOS_MemAlloc((VOID *)m_aucSysMem1, sizeof(IpcTaskInfo));
if (taskInfo == NULL) {
return NULL;
}
(VOID)memset_s(taskInfo, sizeof(IpcTaskInfo), 0, sizeof(IpcTaskInfo));
LOS_ListInit(&taskInfo->msgListHead);
return taskInfo;
}
/* Only when kernenl no longer access ipc node content, can user free the ipc node */
LITE_OS_SEC_TEXT STATIC VOID EnableIpcNodeFreeByUser(UINT32 processID, VOID *buf)
{
UINT32 intSave;
ProcIpcInfo *ipcInfo = OS_PCB_FROM_PID(processID)->ipcInfo;
IpcUsedNode *node = (IpcUsedNode *)malloc(sizeof(IpcUsedNode));
if (node != NULL) {
node->ptr = buf;
IPC_LOCK(intSave);
LOS_ListAdd(&g_ipcUsedNodelist[processID], &node->list);
LOS_ListAdd(&ipcInfo->ipcUsedNodelist, &node->list);
IPC_UNLOCK(intSave);
}
}
LITE_OS_SEC_TEXT STATIC VOID *LiteIpcNodeAlloc(UINT32 processID, UINT32 size)
{
VOID *ptr = LOS_MemAlloc(OS_PCB_FROM_PID(processID)->ipcInfo.pool.kvaddr, size);
VOID *ptr = LOS_MemAlloc(OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, size);
PRINT_INFO("LiteIpcNodeAlloc pid:%d, pool:%x buf:%x size:%d\n",
processID, OS_PCB_FROM_PID(processID)->ipcInfo.pool.kvaddr, ptr, size);
processID, OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, ptr, size);
return ptr;
}
LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcNodeFree(UINT32 processID, VOID *buf)
{
PRINT_INFO("LiteIpcNodeFree pid:%d, pool:%x buf:%x\n",
processID, OS_PCB_FROM_PID(processID)->ipcInfo.pool.kvaddr, buf);
return LOS_MemFree(OS_PCB_FROM_PID(processID)->ipcInfo.pool.kvaddr, buf);
processID, OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, buf);
return LOS_MemFree(OS_PCB_FROM_PID(processID)->ipcInfo->pool.kvaddr, buf);
}
LITE_OS_SEC_TEXT STATIC BOOL IsIpcNode(UINT32 processID, const VOID *buf)
{
IpcUsedNode *node = NULL;
UINT32 intSave;
ProcIpcInfo *ipcInfo = OS_PCB_FROM_PID(processID)->ipcInfo;
IPC_LOCK(intSave);
LOS_DL_LIST_FOR_EACH_ENTRY(node, &g_ipcUsedNodelist[processID], IpcUsedNode, list) {
LOS_DL_LIST_FOR_EACH_ENTRY(node, &ipcInfo->ipcUsedNodelist, IpcUsedNode, list) {
if (node->ptr == buf) {
LOS_ListDelete(&node->list);
IPC_UNLOCK(intSave);
@ -325,14 +382,14 @@ LITE_OS_SEC_TEXT STATIC BOOL IsIpcNode(UINT32 processID, const VOID *buf)
LITE_OS_SEC_TEXT STATIC INTPTR GetIpcUserAddr(UINT32 processID, INTPTR kernelAddr)
{
IpcPool pool = OS_PCB_FROM_PID(processID)->ipcInfo.pool;
IpcPool pool = OS_PCB_FROM_PID(processID)->ipcInfo->pool;
INTPTR offset = (INTPTR)(pool.uvaddr) - (INTPTR)(pool.kvaddr);
return kernelAddr + offset;
}
LITE_OS_SEC_TEXT STATIC INTPTR GetIpcKernelAddr(UINT32 processID, INTPTR userAddr)
{
IpcPool pool = OS_PCB_FROM_PID(processID)->ipcInfo.pool;
IpcPool pool = OS_PCB_FROM_PID(processID)->ipcInfo->pool;
INTPTR offset = (INTPTR)(pool.uvaddr) - (INTPTR)(pool.kvaddr);
return userAddr - offset;
}
@ -341,7 +398,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 CheckUsedBuffer(const VOID *node, IpcListNode **o
{
VOID *ptr = NULL;
LosProcessCB *pcb = OsCurrProcessGet();
IpcPool pool = pcb->ipcInfo.pool;
IpcPool pool = pcb->ipcInfo->pool;
if ((node == NULL) || ((INTPTR)node < (INTPTR)(pool.uvaddr)) ||
((INTPTR)node > (INTPTR)(pool.uvaddr) + pool.poolSize)) {
return -EINVAL;
@ -417,12 +474,18 @@ LITE_OS_SEC_TEXT STATIC UINT32 AddServiceAccess(UINT32 taskID, UINT32 serviceHan
UINT32 serviceTid = 0;
UINT32 ret = GetTid(serviceHandle, &serviceTid);
if (ret != LOS_OK) {
PRINT_ERR("AddServiceAccess GetTid failed\n");
PRINT_ERR("Liteipc AddServiceAccess GetTid failed\n");
return ret;
}
LosTaskCB *tcb = OS_TCB_FROM_TID(serviceTid);
UINT32 processID = OS_TCB_FROM_TID(taskID)->processID;
OS_TCB_FROM_TID(serviceTid)->accessMap[processID] = TRUE;
OS_PCB_FROM_PID(processID)->ipcInfo.access[serviceTid] = TRUE;
LosProcessCB *pcb = OS_PCB_FROM_PID(processID);
if ((tcb->ipcTaskInfo == NULL) || (pcb->ipcInfo == NULL)) {
PRINT_ERR("Liteipc AddServiceAccess ipc not create! pid %u tid %u\n", processID, tcb->taskID);
return -EINVAL;
}
tcb->ipcTaskInfo->accessMap[processID] = TRUE;
pcb->ipcInfo->access[serviceTid] = TRUE;
return LOS_OK;
}
@ -439,28 +502,33 @@ LITE_OS_SEC_TEXT STATIC BOOL HasServiceAccess(UINT32 serviceHandle)
}
ret = GetTid(serviceHandle, &serviceTid);
if (ret != LOS_OK) {
PRINT_ERR("HasServiceAccess GetTid failed\n");
PRINT_ERR("Liteipc HasServiceAccess GetTid failed\n");
return FALSE;
}
if (OS_TCB_FROM_TID(serviceTid)->processID == curProcessID) {
return TRUE;
}
return OS_TCB_FROM_TID(serviceTid)->accessMap[curProcessID];
if (OS_TCB_FROM_TID(serviceTid)->ipcTaskInfo == NULL) {
return FALSE;
}
return OS_TCB_FROM_TID(serviceTid)->ipcTaskInfo->accessMap[curProcessID];
}
LITE_OS_SEC_TEXT STATIC UINT32 SetIpcTask(VOID)
{
if (OsCurrProcessGet()->ipcInfo.ipcTaskID == INVAILD_ID) {
OsCurrProcessGet()->ipcInfo.ipcTaskID = LOS_CurTaskIDGet();
return OsCurrProcessGet()->ipcInfo.ipcTaskID;
if (OsCurrProcessGet()->ipcInfo->ipcTaskID == INVAILD_ID) {
OsCurrProcessGet()->ipcInfo->ipcTaskID = LOS_CurTaskIDGet();
return OsCurrProcessGet()->ipcInfo->ipcTaskID;
}
PRINT_ERR("curprocess %d IpcTask already set!\n", OsCurrProcessGet()->processID);
PRINT_ERR("Liteipc curprocess %d IpcTask already set!\n", OsCurrProcessGet()->processID);
return -EINVAL;
}
LITE_OS_SEC_TEXT BOOL IsIpcTaskSet(VOID)
{
if (OsCurrProcessGet()->ipcInfo.ipcTaskID == INVAILD_ID) {
if (OsCurrProcessGet()->ipcInfo->ipcTaskID == INVAILD_ID) {
return FALSE;
}
return TRUE;
@ -468,10 +536,10 @@ LITE_OS_SEC_TEXT BOOL IsIpcTaskSet(VOID)
LITE_OS_SEC_TEXT STATIC UINT32 GetIpcTaskID(UINT32 processID, UINT32 *ipcTaskID)
{
if (OS_PCB_FROM_PID(processID)->ipcInfo.ipcTaskID == INVAILD_ID) {
if (OS_PCB_FROM_PID(processID)->ipcInfo->ipcTaskID == INVAILD_ID) {
return LOS_NOK;
}
*ipcTaskID = OS_PCB_FROM_PID(processID)->ipcInfo.ipcTaskID;
*ipcTaskID = OS_PCB_FROM_PID(processID)->ipcInfo->ipcTaskID;
return LOS_OK;
}
@ -481,8 +549,13 @@ LITE_OS_SEC_TEXT STATIC UINT32 SendDeathMsg(UINT32 processID, UINT32 serviceHand
UINT32 ret;
IpcContent content;
IpcMsg msg;
LosProcessCB *pcb = OS_PCB_FROM_PID(processID);
OS_PCB_FROM_PID(processID)->ipcInfo.access[serviceHandle] = false;
if (pcb->ipcInfo == NULL) {
return -EINVAL;
}
pcb->ipcInfo->access[serviceHandle] = FALSE;
ret = GetIpcTaskID(processID, &ipcTaskID);
if (ret != LOS_OK) {
@ -498,9 +571,15 @@ LITE_OS_SEC_TEXT STATIC UINT32 SendDeathMsg(UINT32 processID, UINT32 serviceHand
return LiteIpcWrite(&content);
}
LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(LosTaskCB *taskCB)
LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(UINT32 taskID)
{
UINT32 j;
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
IpcTaskInfo *ipcTaskInfo = taskCB->ipcTaskInfo;
if (ipcTaskInfo == NULL) {
return;
}
#if (USE_TASKID_AS_HANDLE == YES)
UINT32 intSave;
@ -509,7 +588,7 @@ LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(LosTaskCB *taskCB)
IpcListNode *node = NULL;
UINT32 processID = taskCB->processID;
listHead = &(taskCB->msgListHead);
listHead = &(ipcTaskInfo->msgListHead);
do {
SCHEDULER_LOCK(intSave);
if (LOS_ListEmpty(listHead)) {
@ -525,10 +604,10 @@ LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(LosTaskCB *taskCB)
}
} while (1);
taskCB->accessMap[processID] = FALSE;
ipcTaskInfo->accessMap[processID] = FALSE;
for (j = 0; j < MAX_SERVICE_NUM; j++) {
if (taskCB->accessMap[j] == TRUE) {
taskCB->accessMap[j] = FALSE;
if (ipcTaskInfo->accessMap[j] == TRUE) {
ipcTaskInfo->accessMap[j] = FALSE;
(VOID)SendDeathMsg(j, taskCB->taskID);
}
}
@ -545,12 +624,15 @@ LITE_OS_SEC_TEXT VOID LiteIpcRemoveServiceHandle(LosTaskCB *taskCB)
/* run deathHandler */
if (i < MAX_SERVICE_NUM) {
for (j = 0; j < MAX_SERVICE_NUM; j++) {
if (taskCB->accessMap[j] == TRUE) {
if (ipcTaskInfo->accessMap[j] == TRUE) {
(VOID)SendDeathMsg(j, i);
}
}
}
#endif
(VOID)LOS_MemFree(m_aucSysMem1, ipcTaskInfo);
taskCB->ipcTaskInfo = NULL;
}
LITE_OS_SEC_TEXT STATIC UINT32 SetCms(UINTPTR maxMsgSize)
@ -650,12 +732,12 @@ LITE_OS_SEC_TEXT STATIC UINT32 HandlePtr(UINT32 processID, SpecialObj *obj, BOOL
}
if (isRollback == FALSE) {
if (LOS_IsUserAddress((vaddr_t)(UINTPTR)(obj->content.ptr.buff)) == FALSE) {
PRINT_ERR("Bad ptr address\n");
PRINT_ERR("Liteipc Bad ptr address\n");
return -EINVAL;
}
buf = LiteIpcNodeAlloc(processID, obj->content.ptr.buffSz);
if (buf == NULL) {
PRINT_ERR("DealPtr alloc mem failed\n");
PRINT_ERR("Liteipc DealPtr alloc mem failed\n");
return -EINVAL;
}
ret = copy_from_user(buf, obj->content.ptr.buff, obj->content.ptr.buffSz);
@ -676,15 +758,15 @@ LITE_OS_SEC_TEXT STATIC UINT32 HandleSvc(UINT32 dstTid, const SpecialObj *obj, B
UINT32 taskID = 0;
if (isRollback == FALSE) {
if (IsTaskAlive(obj->content.svc.handle) == FALSE) {
PRINT_ERR("HandleSvc wrong svctid\n");
PRINT_ERR("Liteipc HandleSvc wrong svctid\n");
return -EINVAL;
}
if (HasServiceAccess(obj->content.svc.handle) == FALSE) {
PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
PRINT_ERR("Liteipc %s, %d\n", __FUNCTION__, __LINE__);
return -EACCES;
}
if (GetTid(obj->content.svc.handle, &taskID) == 0) {
if (taskID == OS_PCB_FROM_PID(OS_TCB_FROM_TID(taskID)->processID)->ipcInfo.ipcTaskID) {
if (taskID == OS_PCB_FROM_PID(OS_TCB_FROM_TID(taskID)->processID)->ipcInfo->ipcTaskID) {
AddServiceAccess(dstTid, obj->content.svc.handle);
}
}
@ -873,7 +955,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 CheckPara(IpcContent *content, UINT32 *dstTid)
return -EINVAL;
}
} else {
PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
PRINT_ERR("Liteipc %s, %d\n", __FUNCTION__, __LINE__);
return -EACCES;
}
#if (USE_TIMESTAMP == YES)
@ -898,7 +980,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 CheckPara(IpcContent *content, UINT32 *dstTid)
#endif
OsHookCall(LOS_HOOK_TYPE_IPC_WRITE_DROP, msg, *dstTid,
(*dstTid == INVAILD_ID) ? INVAILD_ID : OS_TCB_FROM_TID(*dstTid)->processID, 0);
PRINT_ERR("A timeout reply, request timestamp:%lld, now:%lld\n", msg->timestamp, now);
PRINT_ERR("Liteipc A timeout reply, request timestamp:%lld, now:%lld\n", msg->timestamp, now);
return -ETIME;
}
#endif
@ -933,8 +1015,15 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcWrite(IpcContent *content)
return ret;
}
LosTaskCB *tcb = OS_TCB_FROM_TID(dstTid);
LosProcessCB *pcb = OS_PCB_FROM_PID(tcb->processID);
if (pcb->ipcInfo == NULL) {
PRINT_ERR("pid %u Liteipc not create\n", tcb->processID);
return -EINVAL;
}
UINT32 bufSz = sizeof(IpcListNode) + msg->dataSz + msg->spObjNum * sizeof(UINT32);
IpcListNode *buf = (IpcListNode *)LiteIpcNodeAlloc(OS_TCB_FROM_TID(dstTid)->processID, bufSz);
IpcListNode *buf = (IpcListNode *)LiteIpcNodeAlloc(tcb->processID, bufSz);
if (buf == NULL) {
PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
return -ENOMEM;
@ -944,6 +1033,11 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcWrite(IpcContent *content)
PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
goto ERROR_COPY;
}
if (tcb->ipcTaskInfo == NULL) {
tcb->ipcTaskInfo = LiteIpcTaskInit();
}
ret = HandleSpecialObjects(dstTid, buf, FALSE);
if (ret != LOS_OK) {
PRINT_ERR("%s, %d\n", __FUNCTION__, __LINE__);
@ -951,8 +1045,7 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcWrite(IpcContent *content)
}
/* add data to list and wake up dest task */
SCHEDULER_LOCK(intSave);
LosTaskCB *tcb = OS_TCB_FROM_TID(dstTid);
LOS_ListTailInsert(&(tcb->msgListHead), &(buf->listNode));
LOS_ListTailInsert(&(tcb->ipcTaskInfo->msgListHead), &(buf->listNode));
OsHookCall(LOS_HOOK_TYPE_IPC_WRITE, &buf->msg, dstTid, tcb->processID, tcb->waitFlag);
if (tcb->waitFlag == OS_TASK_WAIT_LITEIPC) {
OsTaskWakeClearPendMask(tcb);
@ -1030,7 +1123,11 @@ LITE_OS_SEC_TEXT STATIC UINT32 LiteIpcRead(IpcContent *content)
UINT32 timeout = syncFlag ? LOS_MS2Tick(LITEIPC_TIMEOUT_MS) : LOS_WAIT_FOREVER;
LosTaskCB *tcb = OS_TCB_FROM_TID(selfTid);
listHead = &(tcb->msgListHead);
if (tcb->ipcTaskInfo == NULL) {
tcb->ipcTaskInfo = LiteIpcTaskInit();
}
listHead = &(tcb->ipcTaskInfo->msgListHead);
do {
SCHEDULER_LOCK(intSave);
if (LOS_ListEmpty(listHead)) {
@ -1189,10 +1286,19 @@ LITE_OS_SEC_TEXT STATIC UINT32 HandleCmsCmd(CmsCmdContent *content)
LITE_OS_SEC_TEXT int LiteIpcIoctl(struct file *filep, int cmd, unsigned long arg)
{
UINT32 ret = LOS_OK;
if (IsPoolMapped() == FALSE) {
PRINT_ERR("Ipc pool not init, need to mmap first!\n");
LosProcessCB *pcb = OsCurrProcessGet();
ProcIpcInfo *ipcInfo = pcb->ipcInfo;
if (ipcInfo == NULL) {
PRINT_ERR("Liteipc pool not create!\n");
return -EINVAL;
}
if (IsPoolMapped(ipcInfo) == FALSE) {
PRINT_ERR("Liteipc Ipc pool not init, need to mmap first!\n");
return -ENOMEM;
}
switch (cmd) {
case IPC_SET_CMS:
return SetCms(arg);
@ -1200,7 +1306,7 @@ LITE_OS_SEC_TEXT int LiteIpcIoctl(struct file *filep, int cmd, unsigned long arg
return HandleCmsCmd((CmsCmdContent *)(UINTPTR)arg);
case IPC_SET_IPC_THREAD:
if (IsCmsSet() == FALSE) {
PRINT_ERR("ServiceManager not set!\n");
PRINT_ERR("Liteipc ServiceManager not set!\n");
return -EINVAL;
}
return SetIpcTask();
@ -1209,7 +1315,7 @@ LITE_OS_SEC_TEXT int LiteIpcIoctl(struct file *filep, int cmd, unsigned long arg
return -EINVAL;
}
if (IsCmsSet() == FALSE) {
PRINT_ERR("ServiceManager not set!\n");
PRINT_ERR("Liteipc ServiceManager not set!\n");
return -EINVAL;
}
ret = LiteIpcMsgHandle((IpcContent *)(UINTPTR)arg);

19
kernel/extended/liteipc/hm_liteipc.h
View File

@ -34,7 +34,6 @@
#include "sys/ioctl.h"
#include "los_config.h"
#include "los_task_pri.h"
#include "los_typedef.h"
#include "los_vm_map.h"
@ -70,9 +69,15 @@ typedef struct {
typedef struct {
IpcPool pool;
UINT32 ipcTaskID;
LOS_DL_LIST ipcUsedNodelist;
UINT32 access[LOSCFG_BASE_CORE_TSK_LIMIT];
} ProcIpcInfo;
typedef struct {
LOS_DL_LIST msgListHead;
BOOL accessMap[LOSCFG_BASE_CORE_TSK_LIMIT];
} IpcTaskInfo;
typedef enum {
OBJ_FD,
OBJ_PTR,
@ -172,17 +177,13 @@ typedef struct {
/* init liteipc driver */
extern UINT32 OsLiteIpcInit(VOID);
/* init process liteipc memory pool */
extern UINT32 LiteIpcPoolInit(ProcIpcInfo *ipcInfo);
/* reinit process liteipc memory pool, using in fork situation */
extern UINT32 LiteIpcPoolReInit(ProcIpcInfo *childIpcInfo, const ProcIpcInfo *parentIpcInfo);
/* delete process liteipc memory pool */
extern VOID LiteIpcPoolDelete(ProcIpcInfo *ipcInfo, UINT32 processID);
extern ProcIpcInfo *LiteIpcPoolReInit(const ProcIpcInfo *parentIpcInfo);
/* remove service handle and send death notify */
extern VOID LiteIpcRemoveServiceHandle(LosTaskCB *taskCB);
extern VOID LiteIpcRemoveServiceHandle(UINT32 taskID);
extern UINT32 LiteIpcPoolDestroy(UINT32 processID);
#ifdef __cplusplus
#if __cplusplus