!256 fix: 解决kill进程时无法保证进程持有的系统资源合理释放

Merge pull request !256 from zhushengle/Sig

arch/arm/arm/src/los_dispatch.S

@@ -173,6 +173,7 @@ OsIrqHandler:
     POP_FPU_REGS R0
     LDR   R4, [SP, #0]
 
+#ifdef LOSCFG_KERNEL_VM
     /* Obtain the CPSR to determine the mode the system is in when the interrupt is triggered */
     LDR     R3, [SP, #(11 * 4)]
     AND     R1, R3, #CPSR_MASK_MODE
@@ -187,6 +188,7 @@ OsIrqHandler:
     BLX     OsSaveSignalContext
     MOV     SP, R0
 1:
+#endif
     ADD     SP, SP, #(2 * 4)
     /* load user sp and lr, and jump cpsr */
     LDMFD   SP, {R13, R14}^

arch/arm/arm/src/los_exc.c

@@ -220,7 +220,9 @@ UINT32 OsArmSharedPageFault(UINT32 excType, ExcContext *frame, UINT32 far, UINT3
             pfFlags |= user ? VM_MAP_PF_FLAG_USER : 0;
             pfFlags |= instructionFault ? VM_MAP_PF_FLAG_INSTRUCTION : 0;
             pfFlags |= VM_MAP_PF_FLAG_NOT_PRESENT;
+            OsSigIntLock();
             ret = OsVmPageFaultHandler(far, pfFlags, frame);
+            OsSigIntUnlock();
             break;
         }
         default:
@@ -537,7 +539,9 @@ STATIC VOID OsExcRestore(VOID)
 
 STATIC VOID OsUserExcHandle(ExcContext *excBufAddr)
 {
+    UINT32 intSave;
     UINT32 currCpu = ArchCurrCpuid();
+    LosTaskCB *runTask = OsCurrTaskGet();
     LosProcessCB *runProcess = OsCurrProcessGet();
 
     if (g_excFromUserMode[ArchCurrCpuid()] == FALSE) {
@@ -565,16 +569,28 @@ STATIC VOID OsUserExcHandle(ExcContext *excBufAddr)
 #endif
 #endif
 
+    SCHEDULER_LOCK(intSave);
 #ifdef LOSCFG_SAVE_EXCINFO
     OsProcessExitCodeCoreDumpSet(runProcess);
 #endif
     OsProcessExitCodeSignalSet(runProcess, SIGUSR2);
 
-    /* Exception handling All operations should be kept prior to that operation */
+    /* An exception was raised by a task that is not the current main thread during the exit process of
-    OsExcRestore();
+     * the current process.
+     */
+    if ((runProcess->processStatus & OS_PROCESS_FLAG_EXIT) && (runProcess->threadGroupID != runTask->taskID)) {
+        SCHEDULER_UNLOCK(intSave);
+        /* Exception handling All operations should be kept prior to that operation */
+        OsExcRestore();
+        OsTaskToExit(runTask, OS_PRO_EXIT_OK);
+    } else {
+        SCHEDULER_UNLOCK(intSave);
 
-    /* kill user exc process */
+        /* Exception handling All operations should be kept prior to that operation */
-    LOS_Exit(OS_PRO_EXIT_OK);
+        OsExcRestore();
+        /* kill user exc process */
+        LOS_Exit(OS_PRO_EXIT_OK);
+    }
 
     /* User mode exception handling failed , which normally does not exist */
     g_curNestCount[currCpu]++;
@@ -940,7 +956,6 @@ STATIC VOID WaitAllCpuStop(UINT32 cpuID)
 
 STATIC VOID OsWaitOtherCoresHandleExcEnd(UINT32 currCpuID)
 {
-    OsProcessSuspendAllTask();
     while (1) {
         LOS_SpinLock(&g_excSerializerSpin);
         if ((g_currHandleExcCpuID == INVALID_CPUID) || (g_currHandleExcCpuID == currCpuID)) {
@@ -967,6 +982,7 @@ STATIC VOID OsCheckAllCpuStatus(VOID)
     LOCKDEP_CLEAR_LOCKS();
 
     LOS_SpinLock(&g_excSerializerSpin);
+    /* Only the current nuclear anomaly */
     if (g_currHandleExcCpuID == INVALID_CPUID) {
         g_currHandleExcCpuID = currCpuID;
         g_currHandleExcPID = OsCurrProcessGet()->processID;
@@ -976,13 +992,14 @@ STATIC VOID OsCheckAllCpuStatus(VOID)
             HalIrqSendIpi(target, LOS_MP_IPI_HALT);
         }
     } else if (g_excFromUserMode[currCpuID] == TRUE) {
+        /* Both cores raise exceptions, and the current core is a user-mode exception.
+         * Both cores are abnormal and come from the same process
+         */
         if (OsCurrProcessGet()->processID == g_currHandleExcPID) {
             LOS_SpinUnlock(&g_excSerializerSpin);
             OsExcRestore();
-            while (1) {
+            ret = LOS_TaskDelete(OsCurrTaskGet()->taskID);
-                ret = LOS_TaskSuspend(OsCurrTaskGet()->taskID);
+            LOS_Panic("%s supend task :%u failed: 0x%x\n", __FUNCTION__, OsCurrTaskGet()->taskID, ret);
-                PrintExcInfo("%s supend task :%u failed: 0x%x\n", __FUNCTION__, OsCurrTaskGet()->taskID, ret);
-            }
         }
         LOS_SpinUnlock(&g_excSerializerSpin);
 
@@ -1017,10 +1034,6 @@ STATIC VOID OsCheckCpuStatus(VOID)
 
 LITE_OS_SEC_TEXT VOID STATIC OsExcPriorDisposal(ExcContext *excBufAddr)
 {
-#if (LOSCFG_KERNEL_SMP == YES)
-    UINT16 runCount;
-#endif
-
     if ((excBufAddr->regCPSR & CPSR_MASK_MODE) == CPSR_USER_MODE) {
         g_minAddr = USER_ASPACE_BASE;
         g_maxAddr = USER_ASPACE_BASE + USER_ASPACE_SIZE;
@@ -1033,22 +1046,6 @@ LITE_OS_SEC_TEXT VOID STATIC OsExcPriorDisposal(ExcContext *excBufAddr)
 
     OsCheckCpuStatus();
 
-    if (g_excFromUserMode[ArchCurrCpuid()] == TRUE) {
-        while (1) {
-            OsProcessSuspendAllTask();
-#if (LOSCFG_KERNEL_SMP == YES)
-            LOS_SpinLock(&g_taskSpin);
-            runCount = OS_PROCESS_GET_RUNTASK_COUNT(OsCurrProcessGet()->processStatus);
-            LOS_SpinUnlock(&g_taskSpin);
-            if (runCount == 1) {
-                break;
-            }
-#else
-            break;
-#endif
-        }
-    }
-
 #if (LOSCFG_KERNEL_SMP == YES)
 #ifdef LOSCFG_FS_VFS
     /* Wait for the end of the Console task to avoid multicore printing code */

arch/arm/arm/src/los_hw_exc.S

@@ -325,6 +325,14 @@ _osExceptDataAbortHdl:
 #ifdef LOSCFG_KERNEL_VM
 _osExcPageFaultReturn:
     LDMFD  SP!, {R4-R11}
+
+    MOV     R0, SP
+    STR     R7, [SP, #0]
+    SUB     SP, SP, #(12 * 4)                                @ sp - sizeof(IrqContext), reserved for signal
+    MOV     R1, SP
+    BLX     OsSaveSignalContext
+    MOV     SP, R0
+
     ADD    SP, SP, #(2 * 4)
     LDMFD  SP, {R13, R14}^
     ADD    SP, SP, #(2 * 4)                                  @ Jump reserved fileds

kernel/base/core/los_process.c

@@ -179,7 +179,7 @@ STATIC LosProcessCB *OsFindExitChildProcess(const LosProcessCB *processCB, INT32
     return NULL;
 }
 
-STATIC INLINE VOID OsWaitWakeTask(LosTaskCB *taskCB, UINT32 wakePID)
+VOID OsWaitWakeTask(LosTaskCB *taskCB, UINT32 wakePID)
 {
     taskCB->waitID = wakePID;
     OsSchedTaskWake(taskCB);
@@ -410,7 +410,9 @@ STATIC VOID OsProcessNaturalExit(LosTaskCB *runTask, UINT32 status)
 
         processCB->processStatus |= OS_PROCESS_STATUS_ZOMBIES;
 
+#ifdef LOSCFG_KERNEL_VM
         (VOID)OsKill(processCB->parentProcessID, SIGCHLD, OS_KERNEL_KILL_PERMISSION);
+#endif
         LOS_ListHeadInsert(&g_processRecyleList, &processCB->pendList);
         OsRunTaskToDelete(runTask);
         return;
@@ -909,27 +911,6 @@ LITE_OS_SEC_TEXT INT32 LOS_GetProcessPriority(INT32 pid)
     return OsGetProcessPriority(LOS_PRIO_PROCESS, pid);
 }
 
-LITE_OS_SEC_TEXT VOID OsWaitSignalToWakeProcess(LosProcessCB *processCB)
-{
-    LosTaskCB *taskCB = NULL;
-
-    if (processCB == NULL) {
-        return;
-    }
-
-    /* only suspend process can continue */
-    if (!(processCB->processStatus & OS_PROCESS_STATUS_PENDING)) {
-        return;
-    }
-
-    if (!LOS_ListEmpty(&processCB->waitList)) {
-        taskCB = OS_TCB_FROM_PENDLIST(LOS_DL_LIST_FIRST(&processCB->waitList));
-        OsWaitWakeTask(taskCB, OS_INVALID_VALUE);
-    }
-
-    return;
-}
-
 STATIC VOID OsWaitInsertWaitListInOrder(LosTaskCB *runTask, LosProcessCB *processCB)
 {
     LOS_DL_LIST *head = &processCB->waitList;
@@ -1595,9 +1576,9 @@ STATIC UINT32 OsCopyParent(UINT32 flags, LosProcessCB *childProcessCB, LosProces
     childProcessCB->priority = runProcessCB->priority;
 
     if (flags & CLONE_PARENT) {
-        parentProcessCB = OS_PCB_FROM_PID(runProcessCB->parentProcessID);        
+        parentProcessCB = OS_PCB_FROM_PID(runProcessCB->parentProcessID);
     } else {
-        parentProcessCB = runProcessCB;         
+        parentProcessCB = runProcessCB;
     }
     childProcessCB->parentProcessID = parentProcessCB->processID;
     LOS_ListTailInsert(&parentProcessCB->childrenList, &childProcessCB->siblingList);
@@ -1793,6 +1774,18 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsUserInitProcess(VOID)
 
 LITE_OS_SEC_TEXT VOID LOS_Exit(INT32 status)
 {
+    UINT32 intSave;
+
+    /* The exit of a kernel - state process must be kernel - state and all threads must actively exit */
+    LosProcessCB *processCB = OsCurrProcessGet();
+    SCHEDULER_LOCK(intSave);
+    if (!OsProcessIsUserMode(processCB) && (processCB->threadNumber != 1)) {
+        SCHEDULER_UNLOCK(intSave);
+        PRINT_ERR("Kernel-state processes with multiple threads are not allowed to exit directly\n");
+        return;
+    }
+    SCHEDULER_UNLOCK(intSave);
+
     OsTaskExitGroup((UINT32)status);
     OsProcessExit(OsCurrTaskGet(), (UINT32)status);
 }

kernel/base/core/los_task.c

@@ -46,6 +46,7 @@
 #include "los_process_pri.h"
 #include "los_vm_map.h"
 #include "los_vm_syscall.h"
+#include "los_signal.h"
 
 #ifdef LOSCFG_KERNEL_CPUP
 #include "los_cpup_pri.h"
@@ -267,30 +268,29 @@ LITE_OS_SEC_TEXT UINT32 LOS_CurTaskIDGet(VOID)
 LITE_OS_SEC_TEXT VOID OsTaskToExit(LosTaskCB *taskCB, UINT32 status)
 {
     UINT32 intSave;
-    LosProcessCB *runProcess = NULL;
-    LosTaskCB *mainTask = NULL;
 
-    SCHEDULER_LOCK(intSave);
+    LosProcessCB *runProcess = OS_PCB_FROM_PID(taskCB->processID);
-    runProcess = OS_PCB_FROM_PID(taskCB->processID);
+    LosTaskCB *mainTask = OS_TCB_FROM_TID(runProcess->threadGroupID);
-    mainTask = OS_TCB_FROM_TID(runProcess->threadGroupID);
-    SCHEDULER_UNLOCK(intSave);
     if (mainTask == taskCB) {
         OsTaskExitGroup(status);
     }
 
     SCHEDULER_LOCK(intSave);
+
     if (runProcess->threadNumber == 1) { /* 1: The last task of the process exits */
         SCHEDULER_UNLOCK(intSave);
         (VOID)OsProcessExit(taskCB, status);
         return;
     }
 
-    if (taskCB->taskStatus & OS_TASK_FLAG_DETACHED) {
+    /* The thread being killed must be able to exit automatically and will have the detached property */
+    OsTaskJoinPostUnsafe(taskCB);
+
+    if (taskCB->taskStatus & (OS_TASK_FLAG_DETACHED | OS_TASK_FLAG_EXIT_KILL)) {
         UINT32 ret = OsTaskDeleteUnsafe(taskCB, status, intSave);
         LOS_Panic("Task delete failed! ERROR : 0x%x\n", ret);
     }
 
-    OsTaskJoinPostUnsafe(taskCB);
     OsSchedResched();
     SCHEDULER_UNLOCK(intSave);
     return;
@@ -536,8 +536,8 @@ LITE_OS_SEC_TEXT_INIT STATIC VOID OsTaskCBInitBase(LosTaskCB *taskCB,
     if (initParam->uwResved & OS_TASK_FLAG_DETACHED) {
         taskCB->taskStatus |= OS_TASK_FLAG_DETACHED;
     } else {
-        LOS_ListInit(&taskCB->joinList);
         taskCB->taskStatus |= OS_TASK_FLAG_PTHREAD_JOIN;
+        LOS_ListInit(&taskCB->joinList);
     }
 
     taskCB->futex.index = OS_INVALID_VALUE;
@@ -870,6 +870,7 @@ STATIC INLINE VOID OsTaskReleaseHoldLock(LosProcessCB *processCB, LosTaskCB *tas
 
     if (processCB->processMode == OS_USER_MODE) {
         OsTaskJoinPostUnsafe(taskCB);
+
 #ifdef LOSCFG_KERNEL_VM
         OsFutexNodeDeleteFromFutexHash(&taskCB->futex, TRUE, NULL, NULL);
 #endif
@@ -878,15 +879,16 @@ STATIC INLINE VOID OsTaskReleaseHoldLock(LosProcessCB *processCB, LosTaskCB *tas
     OsTaskSyncWake(taskCB);
 }
 
-LITE_OS_SEC_TEXT VOID OsRunTaskToDelete(LosTaskCB *taskCB)
+LITE_OS_SEC_TEXT VOID OsRunTaskToDelete(LosTaskCB *runTask)
 {
-    LosProcessCB *processCB = OS_PCB_FROM_PID(taskCB->processID);
+    LosProcessCB *processCB = OS_PCB_FROM_PID(runTask->processID);
-    OsTaskReleaseHoldLock(processCB, taskCB);
-    OsTaskStatusUnusedSet(taskCB);
 
-    LOS_ListDelete(&taskCB->threadList);
+    OsTaskReleaseHoldLock(processCB, runTask);
+    OsTaskStatusUnusedSet(runTask);
+
+    LOS_ListDelete(&runTask->threadList);
     processCB->threadNumber--;
-    LOS_ListTailInsert(&g_taskRecyleList, &taskCB->pendList);
+    LOS_ListTailInsert(&g_taskRecyleList, &runTask->pendList);
     OsEventWriteUnsafe(&g_resourceEvent, OS_RESOURCE_EVENT_FREE, FALSE, NULL);
 
     OsSchedResched();
@@ -1033,7 +1035,7 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskDelete(UINT32 taskID)
     }
 
     processCB = OS_PCB_FROM_PID(taskCB->processID);
-    if (processCB->threadNumber == 1) {
+    if (processCB->threadNumber == 1) { /* 1: The last task of the process exits */
         if (processCB == OsCurrProcessGet()) {
             SCHEDULER_UNLOCK(intSave);
             OsProcessExit(taskCB, OS_PRO_EXIT_OK);
@@ -1399,57 +1401,70 @@ EXIT:
     return err;
 }
 
+STATIC VOID OsExitGroupActiveTaskKilled(LosProcessCB *processCB, LosTaskCB *taskCB)
+{
+    INT32 ret;
+
+    taskCB->taskStatus |= OS_TASK_FLAG_EXIT_KILL;
+#if (LOSCFG_KERNEL_SMP == YES)
+    /* The other core that the thread is running on and is currently running in a non-system call */
+    if (!taskCB->sig.sigIntLock && (taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
+        taskCB->signal = SIGNAL_KILL;
+        LOS_MpSchedule(taskCB->currCpu);
+    } else
+#endif
+    {
+        ret = OsTaskKillUnsafe(taskCB->taskID, SIGKILL);
+        if (ret != LOS_OK) {
+            PRINT_ERR("pid %u exit, Exit task group %u kill %u failed! ERROR: %d\n",
+                      taskCB->processID, OsCurrTaskGet()->taskID, taskCB->taskID, ret);
+        }
+    }
+
+    if (!(taskCB->taskStatus & OS_TASK_FLAG_PTHREAD_JOIN)) {
+        taskCB->taskStatus |= OS_TASK_FLAG_PTHREAD_JOIN;
+        LOS_ListInit(&taskCB->joinList);
+    }
+
+    ret = OsTaskJoinPendUnsafe(taskCB);
+    if (ret != LOS_OK) {
+        PRINT_ERR("pid %u exit, Exit task group %u to wait others task %u(0x%x) exit failed! ERROR: %d\n",
+                  taskCB->processID, OsCurrTaskGet()->taskID, taskCB->taskID, taskCB->taskStatus, ret);
+    }
+}
+
 LITE_OS_SEC_TEXT VOID OsTaskExitGroup(UINT32 status)
 {
-    LosProcessCB *processCB = NULL;
-    LosTaskCB *taskCB = NULL;
-    LOS_DL_LIST *list = NULL;
-    LOS_DL_LIST *head = NULL;
-    LosTaskCB *runTask[LOSCFG_KERNEL_CORE_NUM] = { 0 };
     UINT32 intSave;
-#if (LOSCFG_KERNEL_SMP == YES)
-    UINT16 cpu;
-#endif
 
+    LosProcessCB *processCB = OsCurrProcessGet();
+    LosTaskCB *currTask = OsCurrTaskGet();
     SCHEDULER_LOCK(intSave);
-    processCB = OsCurrProcessGet();
+    if ((processCB->processStatus & OS_PROCESS_FLAG_EXIT) || !OsProcessIsUserMode(processCB)) {
-    if (processCB->processStatus & OS_PROCESS_FLAG_EXIT) {
         SCHEDULER_UNLOCK(intSave);
         return;
     }
 
     processCB->processStatus |= OS_PROCESS_FLAG_EXIT;
-    runTask[ArchCurrCpuid()] = OsCurrTaskGet();
+    processCB->threadGroupID = currTask->taskID;
-    runTask[ArchCurrCpuid()]->sig.sigprocmask = OS_INVALID_VALUE;
 
-    list = &processCB->threadSiblingList;
+    LOS_DL_LIST *list = &processCB->threadSiblingList;
-    head = list;
+    LOS_DL_LIST *head = list;
     do {
-        taskCB = LOS_DL_LIST_ENTRY(list->pstNext, LosTaskCB, threadList);
+        LosTaskCB *taskCB = LOS_DL_LIST_ENTRY(list->pstNext, LosTaskCB, threadList);
-        if (!(taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
+        if ((taskCB->taskStatus & (OS_TASK_STATUS_INIT | OS_TASK_STATUS_EXIT)) &&
+            !(taskCB->taskStatus & OS_TASK_STATUS_RUNNING)) {
             OsTaskDeleteInactive(processCB, taskCB);
         } else {
-#if (LOSCFG_KERNEL_SMP == YES)
+            if (taskCB != currTask) {
-            if (taskCB->currCpu != ArchCurrCpuid()) {
+                OsExitGroupActiveTaskKilled(processCB, taskCB);
-                taskCB->signal = SIGNAL_KILL;
+            } else {
-                runTask[taskCB->currCpu] = taskCB;
+                /* Skip the current task */
-                LOS_MpSchedule(taskCB->currCpu);
+                list = list->pstNext;
             }
-#endif
-            list = list->pstNext;
         }
     } while (head != list->pstNext);
 
-#if (LOSCFG_KERNEL_SMP == YES)
-    for (cpu = 0; cpu < LOSCFG_KERNEL_CORE_NUM; cpu++) {
-        if ((cpu == ArchCurrCpuid()) || (runTask[cpu] == NULL)) {
-            continue;
-        }
-
-        (VOID)OsTaskSyncWait(runTask[cpu]);
-    }
-#endif
-    processCB->threadGroupID = OsCurrTaskGet()->taskID;
     SCHEDULER_UNLOCK(intSave);
 
     LOS_ASSERT(processCB->threadNumber == 1);
@@ -1462,38 +1477,6 @@ LITE_OS_SEC_TEXT VOID OsExecDestroyTaskGroup(VOID)
     OsTaskCBRecycleToFree();
 }
 
-LITE_OS_SEC_TEXT VOID OsProcessSuspendAllTask(VOID)
-{
-    LosProcessCB *process = NULL;
-    LosTaskCB *taskCB = NULL;
-    LosTaskCB *runTask = NULL;
-    LOS_DL_LIST *list = NULL;
-    LOS_DL_LIST *head = NULL;
-    UINT32 intSave;
-    UINT32 ret;
-
-    SCHEDULER_LOCK(intSave);
-    process = OsCurrProcessGet();
-    runTask = OsCurrTaskGet();
-
-    list = &process->threadSiblingList;
-    head = list;
-    do {
-        taskCB = LOS_DL_LIST_ENTRY(list->pstNext, LosTaskCB, threadList);
-        if (taskCB != runTask) {
-            ret = OsTaskSuspend(taskCB);
-            if ((ret != LOS_OK) && (ret != LOS_ERRNO_TSK_ALREADY_SUSPENDED)) {
-                PRINT_ERR("process(%d) suspend all task(%u) failed! ERROR: 0x%x\n",
-                          process->processID, taskCB->taskID, ret);
-            }
-        }
-        list = list->pstNext;
-    } while (head != list->pstNext);
-
-    SCHEDULER_UNLOCK(intSave);
-    return;
-}
-
 UINT32 OsUserTaskOperatePermissionsCheck(LosTaskCB *taskCB)
 {
     if (taskCB == NULL) {
@@ -1640,6 +1623,11 @@ LITE_OS_SEC_TEXT VOID OsWriteResourceEvent(UINT32 events)
     (VOID)LOS_EventWrite(&g_resourceEvent, events);
 }
 
+LITE_OS_SEC_TEXT VOID OsWriteResourceEventUnsafe(UINT32 events)
+{
+    (VOID)OsEventWriteUnsafe(&g_resourceEvent, events, FALSE, NULL);
+}
+
 STATIC VOID OsResourceRecoveryTask(VOID)
 {
     UINT32 ret;

kernel/base/include/los_process_pri.h

@@ -448,7 +448,6 @@ extern UINT32 OsUserInitProcess(VOID);
 extern VOID OsTaskSchedQueueDequeue(LosTaskCB *taskCB, UINT16 status);
 extern VOID OsTaskSchedQueueEnqueue(LosTaskCB *taskCB, UINT16 status);
 extern INT32 OsClone(UINT32 flags, UINTPTR sp, UINT32 size);
-extern VOID OsWaitSignalToWakeProcess(LosProcessCB *processCB);
 extern UINT32 OsExecRecycleAndInit(LosProcessCB *processCB, const CHAR *name,
                                    LosVmSpace *oldAspace, UINTPTR oldFiles);
 extern UINT32 OsExecStart(const TSK_ENTRY_FUNC entry, UINTPTR sp, UINTPTR mapBase, UINT32 mapSize);
@@ -463,6 +462,8 @@ extern INT32 OsSetCurrProcessGroupID(UINT32 gid);
 extern UINT32 OsGetKernelInitProcessID(VOID);
 extern VOID OsSetSigHandler(UINTPTR addr);
 extern UINTPTR OsGetSigHandler(VOID);
+extern VOID OsWaitWakeTask(LosTaskCB *taskCB, UINT32 wakePID);
+
 #ifdef __cplusplus
 #if __cplusplus
 }

kernel/base/include/los_signal.h

@@ -135,11 +135,12 @@ typedef struct sq_queue_s sq_queue_t;
 typedef struct {
     sigset_t sigFlag;
     sigset_t sigPendFlag;
-    sigset_t sigprocmask; /* Signals that are blocked            */
+    sigset_t sigprocmask; /* Signals that are blocked */
     sq_queue_t sigactionq;
     LOS_DL_LIST waitList;
-    sigset_t sigwaitmask; /* Waiting for pending signals         */
+    sigset_t sigwaitmask; /* Waiting for pending signals */
-    siginfo_t sigunbinfo; /* Signal info when task unblocked     */
+    siginfo_t sigunbinfo; /* Signal info when task unblocked */
+    unsigned int sigIntLock;
     void *sigContext;
     unsigned int count;
 } sig_cb;
@@ -163,6 +164,9 @@ int OsSigTimedWait(sigset_t *set, siginfo_t *info, unsigned int timeout);
 int OsPause(void);
 int OsSigPending(sigset_t *set);
 int OsSigSuspend(const sigset_t *set);
+VOID OsSigIntLock(VOID);
+VOID OsSigIntUnlock(VOID);
+INT32 OsTaskKillUnsafe(UINT32 taskID, INT32 signo);
 
 #ifdef __cplusplus
 #if __cplusplus

kernel/base/include/los_task_pri.h

@@ -208,7 +208,15 @@ extern SPIN_LOCK_S g_taskSpin;
  *
  * The task is no-delete system task, like resourceTask.
  */
-#define OS_TASK_FLAG_NO_DELETE    0x2000U
+#define OS_TASK_FLAG_NO_DELETE      0x2000U
+
+/**
+ * @ingroup los_task
+ * Flag that indicates the task property.
+ *
+ * Kills the thread during process exit.
+ */
+#define OS_TASK_FLAG_EXIT_KILL       0x4000U
 
 /**
  * @ingroup los_task
@@ -216,7 +224,7 @@ extern SPIN_LOCK_S g_taskSpin;
  *
  * Specifies the process creation task.
  */
-#define OS_TASK_FLAG_SPECIFIES_PROCESS 0x4000U
+#define OS_TASK_FLAG_SPECIFIES_PROCESS 0x0U
 
 /**
  * @ingroup los_task
@@ -453,47 +461,23 @@ STATIC INLINE BOOL OsTaskIsInactive(const LosTaskCB *taskCB)
     return FALSE;
 }
 
+STATIC INLINE BOOL OsTaskIsPending(const LosTaskCB *taskCB)
+{
+    if (taskCB->taskStatus & OS_TASK_STATUS_PENDING) {
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
 #define OS_TID_CHECK_INVALID(taskID) ((UINT32)(taskID) >= g_taskMaxNum)
 
 /* get task info */
 #define OS_ALL_TASK_MASK  0xFFFFFFFF
 
-extern UINT32 OsTaskSetDetachUnsafe(LosTaskCB *taskCB);
-extern VOID OsTaskJoinPostUnsafe(LosTaskCB *taskCB);
-extern UINT32 OsTaskJoinPendUnsafe(LosTaskCB *taskCB);
-extern BOOL OsTaskCpuAffiSetUnsafe(UINT32 taskID, UINT16 newCpuAffiMask, UINT16 *oldCpuAffiMask);
-extern VOID OsTaskSchedule(LosTaskCB *, LosTaskCB *);
-extern VOID OsTaskContextLoad(LosTaskCB *newTask);
-extern VOID OsIdleTask(VOID);
-extern UINT32 OsIdleTaskCreate(VOID);
-extern UINT32 OsTaskInit(VOID);
-extern UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv);
-extern UINT32 OsShellCmdTskInfoGet(UINT32 taskID, VOID *seqfile, UINT16 flag);
-extern LosTaskCB *OsGetMainTask(VOID);
-extern VOID OsSetMainTask(VOID);
-extern UINT32 OsGetIdleTaskId(VOID);
-extern VOID OsTaskEntry(UINT32 taskID);
-extern SortLinkAttribute *OsTaskSortLinkGet(VOID);
-extern VOID OsTaskProcSignal(VOID);
-extern UINT32 OsTaskDeleteUnsafe(LosTaskCB *taskCB, UINT32 status, UINT32 intSave);
-extern VOID OsTaskResourcesToFree(LosTaskCB *taskCB);
-extern VOID OsRunTaskToDelete(LosTaskCB *taskCB);
-extern UINT32 OsTaskSyncWait(const LosTaskCB *taskCB);
-extern UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S *initParam);
-extern INT32 OsSetTaskName(LosTaskCB *taskCB, const CHAR *name, BOOL setPName);
-extern VOID OsTaskCBRecycleToFree(VOID);
-extern VOID OsTaskExitGroup(UINT32 status);
-extern VOID OsTaskToExit(LosTaskCB *taskCB, UINT32 status);
-extern VOID OsExecDestroyTaskGroup(VOID);
-extern VOID OsProcessSuspendAllTask(VOID);
-extern UINT32 OsUserTaskOperatePermissionsCheck(LosTaskCB *taskCB);
-extern VOID OsWriteResourceEvent(UINT32 events);
-extern UINT32 OsResourceFreeTaskCreate(VOID);
-
 #define OS_TASK_WAIT_ANYPROCESS (1 << 0U)
 #define OS_TASK_WAIT_PROCESS    (1 << 1U)
 #define OS_TASK_WAIT_GID        (1 << 2U)
-#ifdef LOSCFG_DEBUG_VERSION
 #define OS_TASK_WAIT_SEM        (OS_TASK_WAIT_GID + 1)
 #define OS_TASK_WAIT_QUEUE      (OS_TASK_WAIT_SEM + 1)
 #define OS_TASK_WAIT_JOIN       (OS_TASK_WAIT_QUEUE + 1)
@@ -530,6 +514,39 @@ STATIC INLINE VOID OsTaskWakeClearPendMask(LosTaskCB *resumeTask)
 #endif
 }
 
+extern UINT32 OsTaskSetDetachUnsafe(LosTaskCB *taskCB);
+extern VOID OsTaskJoinPostUnsafe(LosTaskCB *taskCB);
+extern UINT32 OsTaskJoinPendUnsafe(LosTaskCB *taskCB);
+extern BOOL OsTaskCpuAffiSetUnsafe(UINT32 taskID, UINT16 newCpuAffiMask, UINT16 *oldCpuAffiMask);
+extern VOID OsTaskSchedule(LosTaskCB *, LosTaskCB *);
+extern VOID OsTaskContextLoad(LosTaskCB *newTask);
+extern VOID OsIdleTask(VOID);
+extern UINT32 OsIdleTaskCreate(VOID);
+extern UINT32 OsTaskInit(VOID);
+extern UINT32 OsShellCmdDumpTask(INT32 argc, const CHAR **argv);
+extern UINT32 OsShellCmdTskInfoGet(UINT32 taskID, VOID *seqfile, UINT16 flag);
+extern LosTaskCB *OsGetMainTask(VOID);
+extern VOID OsSetMainTask(VOID);
+extern UINT32 OsGetIdleTaskId(VOID);
+extern VOID OsTaskEntry(UINT32 taskID);
+extern SortLinkAttribute *OsTaskSortLinkGet(VOID);
+extern VOID OsTaskProcSignal(VOID);
+extern UINT32 OsTaskDeleteUnsafe(LosTaskCB *taskCB, UINT32 status, UINT32 intSave);
+extern VOID OsTaskResourcesToFree(LosTaskCB *taskCB);
+extern VOID OsRunTaskToDelete(LosTaskCB *taskCB);
+extern UINT32 OsTaskSyncWait(const LosTaskCB *taskCB);
+extern UINT32 OsCreateUserTask(UINT32 processID, TSK_INIT_PARAM_S *initParam);
+extern INT32 OsSetTaskName(LosTaskCB *taskCB, const CHAR *name, BOOL setPName);
+extern VOID OsTaskCBRecycleToFree(VOID);
+extern VOID OsTaskExitGroup(UINT32 status);
+extern VOID OsTaskToExit(LosTaskCB *taskCB, UINT32 status);
+extern VOID OsExecDestroyTaskGroup(VOID);
+extern UINT32 OsUserTaskOperatePermissionsCheck(LosTaskCB *taskCB);
+extern VOID OsWriteResourceEvent(UINT32 events);
+extern VOID OsWriteResourceEventUnsafe(UINT32 events);
+extern UINT32 OsResourceFreeTaskCreate(VOID);
+
+#ifdef LOSCFG_DEBUG_VERSION
 STATIC INLINE VOID OsTraceTaskSchedule(LosTaskCB *newTask, LosTaskCB *runTask)
 {
     (VOID)newTask;
@@ -542,8 +559,6 @@ STATIC INLINE VOID OsTraceTaskSchedule(LosTaskCB *newTask, LosTaskCB *runTask)
 
 #else
 
-#define OsTaskWaitSetPendMask(mask, lockID, timeout)
-#define OsTaskWakeClearPendMask(taskCB)
 #define OsTraceTaskSchedule(newTask, runTask)
 
 #endif

kernel/base/ipc/los_signal.c

@@ -38,7 +38,9 @@
 #ifdef LOSCFG_SECURITY_CAPABILITY
 #include "capability_api.h"
 #endif
+#include "los_atomic.h"
 
+#ifdef LOSCFG_KERNEL_VM
 
 int raise(int sig)
 {
@@ -65,6 +67,57 @@ int OsSigIsMember(const sigset_t *set, int signo)
     return ret;
 }
 
+STATIC INLINE VOID OsSigWaitTaskWake(LosTaskCB *taskCB, INT32 signo)
+{
+    sig_cb *sigcb = &taskCB->sig;
+
+    if (!LOS_ListEmpty(&sigcb->waitList) && OsSigIsMember(&sigcb->sigwaitmask, signo)) {
+        OsTaskWakeClearPendMask(taskCB);
+        OsSchedTaskWake(taskCB);
+        OsSigEmptySet(&sigcb->sigwaitmask);
+    }
+}
+
+STATIC UINT32 OsPendingTaskWake(LosTaskCB *taskCB, INT32 signo)
+{
+    if (!OsTaskIsPending(taskCB) || !OsProcessIsUserMode(OS_PCB_FROM_PID(taskCB->processID))) {
+        return 0;
+    }
+
+    if ((signo != SIGKILL) && (taskCB->waitFlag != OS_TASK_WAIT_SIGNAL)) {
+        return 0;
+    }
+
+    switch (taskCB->waitFlag) {
+        case OS_TASK_WAIT_PROCESS:
+        case OS_TASK_WAIT_GID:
+        case OS_TASK_WAIT_ANYPROCESS:
+            OsWaitWakeTask(taskCB, OS_INVALID_VALUE);
+            break;
+        case OS_TASK_WAIT_JOIN:
+            OsTaskWakeClearPendMask(taskCB);
+            OsSchedTaskWake(taskCB);
+            break;
+        case OS_TASK_WAIT_SIGNAL:
+            OsSigWaitTaskWake(taskCB, signo);
+            break;
+        case OS_TASK_WAIT_LITEIPC:
+            taskCB->ipcStatus &= ~IPC_THREAD_STATUS_PEND;
+            OsTaskWakeClearPendMask(taskCB);
+            OsSchedTaskWake(taskCB);
+            break;
+        case OS_TASK_WAIT_FUTEX:
+            OsFutexNodeDeleteFromFutexHash(&taskCB->futex, TRUE, NULL, NULL);
+            OsTaskWakeClearPendMask(taskCB);
+            OsSchedTaskWake(taskCB);
+            break;
+        default:
+            break;
+    }
+
+    return 0;
+}
+
 int OsTcbDispatch(LosTaskCB *stcb, siginfo_t *info)
 {
     bool masked = FALSE;
@@ -78,24 +131,17 @@ int OsTcbDispatch(LosTaskCB *stcb, siginfo_t *info)
     masked = (bool)OsSigIsMember(&sigcb->sigprocmask, info->si_signo);
     if (masked) {
         /* If signal is in wait list and mask list, need unblock it */
-        if (!LOS_ListEmpty(&sigcb->waitList) && OsSigIsMember(&sigcb->sigwaitmask, info->si_signo)) {
+        if (LOS_ListEmpty(&sigcb->waitList)  ||
-            OsTaskWakeClearPendMask(stcb);
+           (!LOS_ListEmpty(&sigcb->waitList) && !OsSigIsMember(&sigcb->sigwaitmask, info->si_signo))) {
-            OsSchedTaskWake(stcb);
-            OsSigEmptySet(&sigcb->sigwaitmask);
-        } else {
             OsSigAddSet(&sigcb->sigPendFlag, info->si_signo);
         }
     } else {
         /* unmasked signal actions */
         OsSigAddSet(&sigcb->sigFlag, info->si_signo);
-        if (!LOS_ListEmpty(&sigcb->waitList) && OsSigIsMember(&sigcb->sigwaitmask, info->si_signo)) {
-            OsTaskWakeClearPendMask(stcb);
-            OsSchedTaskWake(stcb);
-            OsSigEmptySet(&sigcb->sigwaitmask);
-        }
     }
     (void) memcpy_s(&sigcb->sigunbinfo, sizeof(siginfo_t), info, sizeof(siginfo_t));
-    return 0;
+
+    return OsPendingTaskWake(stcb, info->si_signo);
 }
 
 void OsSigMaskSwitch(LosTaskCB * const rtcb, sigset_t set)
@@ -231,15 +277,7 @@ static int SigProcessKillSigHandler(LosTaskCB *tcb, void *arg)
 {
     struct ProcessSignalInfo *info = (struct ProcessSignalInfo *)arg;
 
-    if ((tcb != NULL) && (info != NULL) && (info->sigInfo != NULL)) {
+    return OsPendingTaskWake(tcb, info->sigInfo->si_signo);
-        sig_cb *sigcb = &tcb->sig;
-        if (!LOS_ListEmpty(&sigcb->waitList) && OsSigIsMember(&sigcb->sigwaitmask, info->sigInfo->si_signo)) {
-            OsTaskWakeClearPendMask(tcb);
-            OsSchedTaskWake(tcb);
-            OsSigEmptySet(&sigcb->sigwaitmask);
-        }
-    }
-    return 0;
 }
 
 static void SigProcessLoadTcb(struct ProcessSignalInfo *info, siginfo_t *sigInfo)
@@ -276,9 +314,8 @@ int OsSigProcessSend(LosProcessCB *spcb, siginfo_t *sigInfo)
 
     /* visit all taskcb and dispatch signal */
     if (info.sigInfo->si_signo == SIGKILL) {
-        (void)OsSigProcessForeachChild(spcb, SigProcessKillSigHandler, &info);
         OsSigAddSet(&spcb->sigShare, info.sigInfo->si_signo);
-        OsWaitSignalToWakeProcess(spcb);
+        (void)OsSigProcessForeachChild(spcb, SigProcessKillSigHandler, &info);
         return 0;
     } else {
         ret = OsSigProcessForeachChild(spcb, SigProcessSignalHandler, &info);
@@ -316,14 +353,14 @@ int OsDispatch(pid_t pid, siginfo_t *info, int permission)
     if (OsProcessIsUnused(spcb)) {
         return -ESRCH;
     }
-#ifdef LOSCFG_SECURITY_CAPABILITY
-    LosProcessCB *current = OsCurrProcessGet();
 
     /* If the process you want to kill had been inactive, but still exist. should return LOS_OK */
     if (OsProcessIsInactive(spcb)) {
         return LOS_OK;
     }
 
+#ifdef LOSCFG_SECURITY_CAPABILITY
+    LosProcessCB *current = OsCurrProcessGet();
     /* Kernel process always has kill permission and user process should check permission */
     if (OsProcessIsUserMode(current) && !(current->processStatus & OS_PROCESS_FLAG_EXIT)) {
         if ((current != spcb) && (!IsCapPermit(CAP_KILL)) && (current->user->userID != spcb->user->userID)) {
@@ -371,11 +408,27 @@ int OsKillLock(pid_t pid, int sig)
     return ret;
 }
 
+INT32 OsTaskKillUnsafe(UINT32 taskID, INT32 signo)
+{
+    siginfo_t info;
+    LosTaskCB *taskCB = OsGetTaskCB(taskID);
+    INT32 ret = OsUserTaskOperatePermissionsCheck(taskCB);
+    if (ret != LOS_OK) {
+        return -ret;
+    }
+
+    /* Create the siginfo structure */
+    info.si_signo = signo;
+    info.si_code = SI_USER;
+    info.si_value.sival_ptr = NULL;
+
+    /* Dispatch the signal to thread, bypassing normal task group thread
+     * dispatch rules. */
+    return OsTcbDispatch(taskCB, &info);
+}
+
 int OsPthreadKill(UINT32 tid, int signo)
 {
-    LosTaskCB *stcb = NULL;
-    siginfo_t info;
-
     int ret;
     UINT32 intSave;
 
@@ -385,23 +438,9 @@ int OsPthreadKill(UINT32 tid, int signo)
         return -ESRCH;
     }
 
-    /* Create the siginfo structure */
-    info.si_signo = signo;
-    info.si_code = SI_USER;
-    info.si_value.sival_ptr = NULL;
     /* Keep things stationary through the following */
     SCHEDULER_LOCK(intSave);
-    /* Get the TCB associated with the thread */
+    ret = OsTaskKillUnsafe(tid, signo);
-    stcb = OsGetTaskCB(tid);
-    OS_GOTO_EXIT_IF(stcb == NULL, -ESRCH);
-
-    ret = OsUserTaskOperatePermissionsCheck(stcb);
-    OS_GOTO_EXIT_IF(ret != LOS_OK, -ret);
-
-    /* Dispatch the signal to thread, bypassing normal task group thread
-     * dispatch rules. */
-    ret = OsTcbDispatch(stcb, &info);
-EXIT:
     SCHEDULER_UNLOCK(intSave);
     return ret;
 }
@@ -556,6 +595,22 @@ int OsSigAction(int sig, const sigaction_t *act, sigaction_t *oact)
     return LOS_OK;
 }
 
+VOID OsSigIntLock(VOID)
+{
+    LosTaskCB *task = OsCurrTaskGet();
+    sig_cb *sigcb = &task->sig;
+
+    (VOID)LOS_AtomicAdd((Atomic *)&sigcb->sigIntLock, 1);
+}
+
+VOID OsSigIntUnlock(VOID)
+{
+    LosTaskCB *task = OsCurrTaskGet();
+    sig_cb *sigcb = &task->sig;
+
+    (VOID)LOS_AtomicSub((Atomic *)&sigcb->sigIntLock, 1);
+}
+
 VOID *OsSaveSignalContext(VOID *sp, VOID *newSp)
 {
     UINTPTR sigHandler;
@@ -565,6 +620,16 @@ VOID *OsSaveSignalContext(VOID *sp, VOID *newSp)
     LosProcessCB *process = OsCurrProcessGet();
     sig_cb *sigcb = &task->sig;
 
+    /* A thread is not allowed to interrupt the processing of its signals during a system call */
+    if (sigcb->sigIntLock > 0) {
+        return sp;
+    }
+
+    if (task->taskStatus & OS_TASK_FLAG_EXIT_KILL) {
+        OsTaskToExit(task, 0);
+        return sp;
+    }
+
     SCHEDULER_LOCK(intSave);
     if ((sigcb->count == 0) && ((sigcb->sigFlag != 0) || (process->sigShare != 0))) {
         sigHandler = OsGetSigHandler();
@@ -618,3 +683,4 @@ VOID *OsRestorSignalContext(VOID *sp)
     return saveContext;
 }
 
+#endif

syscall/los_syscall.c

@@ -118,6 +118,7 @@ VOID OsArmA32SyscallHandle(TaskContext *regs)
         return;
     }
 
+    OsSigIntLock();
     switch (nArgs) {
         case ARG_NUM_0:
         case ARG_NUM_1:
@@ -136,6 +137,7 @@ VOID OsArmA32SyscallHandle(TaskContext *regs)
     }
 
     regs->R0 = ret;
+    OsSigIntUnlock();
 
     return;
 }