los_signal.h 文件参考

浏览源代码.

结构体
struct	sigset_t_l
struct	sigactq
struct	sq_entry_s
struct	sigpendq
struct	sq_queue_s
struct	SigInfoListNode
struct	sig_cb
	信号控制块(描述符) 更多...

类型定义
typedef void(*	sa_sighandler_t) (int)
typedef void(*	sa_siginfoaction_t) (int, siginfo_t *, void *)
typedef struct sigaction	sigaction_t
typedef struct sigactq	sigactq_t
typedef struct sq_entry_s	sq_entry_t
typedef struct sigpendq	sigpendq_t
typedef struct sq_queue_s	sq_queue_t
typedef struct SigInfoListNode	SigInfoListNode

函数
static int	GOOD_SIGNO (unsigned int sig)
	信号ID是否有效 更多...
int	sys_sigqueue (pid_t, int, const union sigval)
int	sys_sigpending (sigset_t *)
int	sys_rt_sigtimedwait (const sigset_t *mask, siginfo_t *si, const struct timespec *ts, size_t sigsetsize)
int	sys_sigsuspend (const sigset_t *)
int	OsKillLock (pid_t pid, int sig)
	给发送信号过程加锁 更多...
int	OsSigAction (int sig, const sigaction_t *act, sigaction_t *oact)
int	OsSigprocMask (int how, const sigset_t_l *set, sigset_t_l *oldset)
int	OsPthreadKill (UINT32 tid, int signo)
	发送信号 更多...
int	OsSigEmptySet (sigset_t *)
	信号集全部清0 更多...
int	OsSigAddSet (sigset_t *, int)
	向信号集中加入signo信号 更多...
int	OsSigIsMember (const sigset_t *, int)
	判定信号signo是否存在信号集中。如果信号集里已有该信号则返回1，否则返回0。如果有错误则返回-1 更多...
int	OsKill (pid_t pid, int sig, int permission)
int	OsDispatch (pid_t pid, siginfo_t *info, int permission)
	信号分发,发送信号权限/进程组过滤. 更多...
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)
	用参数set代替进程的原有掩码，并暂停进程执行，直到收到信号再恢复原有掩码并继续执行进程。 更多...
VOID	OsSigIntLock (VOID)
VOID	OsSigIntUnlock (VOID)
INT32	OsTaskKillUnsafe (UINT32 taskID, INT32 signo)
VOID	OsClearSigInfoTmpList (sig_cb *sigcb)

详细描述

   信号是Linux系统中用于进程间互相通信或者操作的一种机制，信号可以在任何时候发给某一进程，而无需知道该进程的状态。
   如果该进程当前并未处于执行状态，则该信号就由内核保存起来，直到该进程被调度执行并传递给它为止。
   如果一个信号被进程设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程。

   软中断信号（signal，又简称为信号）用来通知进程发生了异步事件。在软件层次上是对中断机制的一种模拟，
   在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是进程间通信机制中异步通信机制，
   一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。
   进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件而给进程发送信号，通知进程
   发生了某个事件。信号机制除了基本通知功能外，还可以传递附加信息。

   信号量定义如下: 见于..\third_party\musl\arch\aarch64\bits\signal.h
   #define SIGHUP    1  //终端挂起或者控制进程终止
   #define SIGINT    2  //键盘中断（如break键被按下）
   #define SIGQUIT   3  //键盘的退出键被按下
   #define SIGILL    4  //非法指令
   #define SIGTRAP   5  //跟踪陷阱（trace trap），启动进程，跟踪代码的执行
   #define SIGABRT   6  //由abort(3)发出的退出指令
   #define SIGIOT    SIGABRT //abort发出的信号
   #define SIGBUS    7  //总线错误 
   #define SIGFPE    8  //浮点异常
   #define SIGKILL   9      //常用的命令 kill 9 123 | 不能被忽略、处理和阻塞
   #define SIGUSR1   10 //用户自定义信号1 
   #define SIGSEGV   11 //无效的内存引用, 段违例（segmentation     violation），进程试图去访问其虚地址空间以外的位置 
   #define SIGUSR2   12 //用户自定义信号2
   #define SIGPIPE   13 //向某个非读管道中写入数据 
   #define SIGALRM   14 //由alarm(2)发出的信号,默认行为为进程终止
   #define SIGTERM   15 //终止信号, kill不带参数时默认发送这个信号
   #define SIGSTKFLT 16 //栈溢出
   #define SIGCHLD   17 //子进程结束信号
   #define SIGCONT   18 //进程继续（曾被停止的进程）
   #define SIGSTOP   19 //终止进程       | 不能被忽略、处理和阻塞
   #define SIGTSTP   20 //控制终端（tty）上 按下停止键
   #define SIGTTIN   21 //进程停止，后台进程企图从控制终端读
   #define SIGTTOU   22 //进程停止，后台进程企图从控制终端写
   #define SIGURG    23 //I/O有紧急数据到达当前进程
   #define SIGXCPU   24 //进程的CPU时间片到期
   #define SIGXFSZ   25 //文件大小的超出上限
   #define SIGVTALRM 26 //虚拟时钟超时
   #define SIGPROF   27 //profile时钟超时
   #define SIGWINCH  28 //窗口大小改变
   #define SIGIO     29 //I/O相关
   #define SIGPOLL   29 //
   #define SIGPWR    30 //电源故障,关机
   #define SIGSYS    31 //系统调用中参数错，如系统调用号非法 
   #define SIGUNUSED SIGSYS     //系统调用异常

   #define _NSIG 65 //信号范围,不超过_NSIG

   https://www.cnblogs.com/hoys/archive/2012/08/19/2646377.html

   Musl官网 http://musl.libc.org/ 
   musl是构建在Linux系统调用API之上的C标准库的实现，包括在基本语言标准POSIX中定义的接口，
   以及广泛认可的扩展。musl是轻量级的，快速的，简单的，自由的.    
* 

参数

pathname

返回

int

在文件 los_signal.h 中定义.

类型定义说明

sa_sighandler_t

typedef void(* sa_sighandler_t) (int)

在文件 los_signal.h 第 151 行定义.

sa_siginfoaction_t

typedef void(* sa_siginfoaction_t) (int, siginfo_t *, void *)

在文件 los_signal.h 第 152 行定义.

sigaction_t

typedef struct sigaction sigaction_t

在文件 los_signal.h 第 186 行定义.

sigactq_t

typedef struct sigactq sigactq_t

在文件 los_signal.h 第 193 行定义.

SigInfoListNode

typedef struct SigInfoListNode SigInfoListNode

sigpendq_t

typedef struct sigpendq sigpendq_t

在文件 los_signal.h 第 205 行定义.

sq_entry_t

typedef struct sq_entry_s sq_entry_t

在文件 los_signal.h 第 198 行定义.

sq_queue_t

typedef struct sq_queue_s sq_queue_t

在文件 los_signal.h 第 211 行定义.

函数说明

GOOD_SIGNO()

static int GOOD_SIGNO ( unsigned int  sig )

inlinestatic

信号ID是否有效

在文件 los_signal.h 第 158 行定义.

{
    return (sig < _NSIG) ? 1 : 0;// 
}

这是这个函数的调用关系图:

OsClearSigInfoTmpList()

VOID OsClearSigInfoTmpList

(

sig_cb *

sigcb

)

在文件 los_signal.c 第 123 行定义.

{
    while (sigcb->tmpInfoListHead != NULL) {
        SigInfoListNode *tmpInfoNode = sigcb->tmpInfoListHead;
        sigcb->tmpInfoListHead = sigcb->tmpInfoListHead->next;
        (VOID)LOS_MemFree(m_aucSysMem0, tmpInfoNode);
    }
}

函数调用图:

这是这个函数的调用关系图:

OsDispatch()

int OsDispatch	(	pid_t	pid,
		siginfo_t *	info,
		int	permission
	)

信号分发,发送信号权限/进程组过滤.

在文件 los_signal.c 第 412 行定义.

{
    if (OsProcessIDUserCheckInvalid(pid) || pid < 0) {
        return -ESRCH;
    }
    LosProcessCB *spcb = OS_PCB_FROM_PID(pid);//找到这个进程
    if (OsProcessIsUnused(spcb)) {//进程是否还在使用,不一定是当前进程但必须是个有效进程
        return -ESRCH;
    }
 
    /* If the process you want to kill had been inactive, but still exist. should return LOS_OK */
    if (OsProcessIsInactive(spcb)) {//不向非活动进程发送信息,但返回OK
        return LOS_OK;
    }
 
#ifdef LOSCFG_SECURITY_CAPABILITY   //启用能力安全模式
    LosProcessCB *current = OsCurrProcessGet();//获取当前进程,检查当前进程是否有发送信号的权限.
    /* Kernel process always has kill permission and user process should check permission *///内核进程总是有kill权限，用户进程需要检查权限
    if (OsProcessIsUserMode(current) && !(current->processStatus & OS_PROCESS_FLAG_EXIT)) {//用户进程检查能力范围
        if ((current != spcb) && (!IsCapPermit(CAP_KILL)) && (current->user->userID != spcb->user->userID)) {
            return -EPERM;
        }
    }
#endif
    if ((permission == OS_USER_KILL_PERMISSION) && (OsSignalPermissionToCheck(spcb) < 0)) {
        return -EPERM;
    }
    return OsSigProcessSend(spcb, info);//给参数进程发送信号
}

函数调用图:

这是这个函数的调用关系图:

OsKill()

int OsKill	(	pid_t	pid,
		int	sig,
		int	permission
	)

   用于向进程或进程组发送信号
   shell命令 kill 14 7（kill -14 7效果相同）
   发送信号14（SIGALRM默认行为为进程终止）给7号进程
* 

在文件 los_signal.c 第 450 行定义.

{
    siginfo_t info;
    int ret;
 
    /* Make sure that the para is valid */
    if (!GOOD_SIGNO(sig)) {
        return -EINVAL;
    }
 
    /* Create the siginfo structure */ //创建信号结构体
    info.si_signo = sig;    //信号编号
    info.si_code = SI_USER; //来自用户进程信号
    info.si_value.sival_ptr = NULL;
 
    if (pid > 0) {
        /* Send the signal to the specify process */
    ret = OsDispatch(pid, &info, permission);//发送信号
    } else if (pid == -1) {
        /* Send SIG to all processes */
        ret = OsSendSignalToAllProcess(&info, permission);
    } else {
        /* Send SIG to all processes in process group PGRP.
           If PGRP is zero, send SIG to all processes in
           the current process's process group. */
        ret = OsSendSignalToProcessGroup(pid, &info, permission);
    }
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsKillLock()

int OsKillLock	(	pid_t	pid,
		int	sig
	)

给发送信号过程加锁

在文件 los_signal.c 第 480 行定义.

{
    int ret;
    unsigned int intSave;
 
    SCHEDULER_LOCK(intSave);
    ret = OsKill(pid, sig, OS_USER_KILL_PERMISSION);//用户权限向进程发送信号
    SCHEDULER_UNLOCK(intSave);
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsPause()

int OsPause

(

void

)

通过信号挂起当前任务

在文件 los_signal.c 第 617 行定义.

{
    LosTaskCB *spcb = NULL;
    sigset_t oldSigprocmask;
 
    spcb = OsCurrTaskGet();
    oldSigprocmask = spcb->sig.sigprocmask;
    return OsSigSuspend(&oldSigprocmask);
}

函数调用图:

这是这个函数的调用关系图:

OsPthreadKill()

int OsPthreadKill	(	UINT32	tid,
		int	signo
	)

发送信号

在文件 los_signal.c 第 509 行定义.

{
    int ret;
    UINT32 intSave;
 
    /* Make sure that the signal is valid */
    OS_RETURN_IF(!GOOD_SIGNO(signo), -EINVAL);
    if (OS_TID_CHECK_INVALID(tid)) {
        return -ESRCH;
    }
 
    /* Keep things stationary through the following */
    SCHEDULER_LOCK(intSave);
    ret = OsTaskKillUnsafe(tid, signo);
    SCHEDULER_UNLOCK(intSave);
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsSigAction()

int OsSigAction	(	int	sig,
		const sigaction_t *	act,
		sigaction_t *	oact
	)

   信号安装,函数用于改变进程接收到特定信号后的行为。
   sig:信号的值，可以为除SIGKILL及SIGSTOP外的任何一个特定有效的信号（为这两个信号定义自己的处理函数，将导致信号安装错误）。
   act:设置对signal信号的新处理方式。
   oldact:原来对信号的处理方式。
   如果把第二、第三个参数都设为NULL，那么该函数可用于检查信号的有效性。
   返回值：0 表示成功，-1 表示有错误发生。
* 

在文件 los_signal.c 第 677 行定义.

{
    UINTPTR addr;
    sigaction_t action;
 
    if (!GOOD_SIGNO(sig) || sig < 1 || act == NULL) {
        return -EINVAL;
    }
    //将数据从用户空间拷贝到内核空间
    if (LOS_ArchCopyFromUser(&action, act, sizeof(sigaction_t)) != LOS_OK) {
        return -EFAULT;
    }
    
    if (sig == SIGSYS) {//鸿蒙此处通过错误的系统调用 来安装信号处理函数,有点巧妙. 
        addr = OsGetSigHandler();//是否已存在信号处理函数
        if (addr == 0) {//进程没有设置信号处理函数时
            OsSetSigHandler((unsigned long)(UINTPTR)action.sa_handler);//设置进程信号处理函数
            //void (*sa_handler)(int); //信号处理函数——普通版
            //void (*sa_sigaction)(int, siginfo_t *, void *);//信号处理函数——高级版
            return LOS_OK;
        }
        return -EINVAL;
    }
 
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsSigAddSet()

int OsSigAddSet	(	sigset_t *	set,
		int	signo
	)

向信号集中加入signo信号

在文件 los_signal.c 第 527 行定义.

{
    /* Verify the signal */
    if (!GOOD_SIGNO(signo)) {
        return -EINVAL;
    } else {
        /* In musl, sig No bits 00000100 present sig No 3, but  1<< 3 = 00001000, so signo needs minus 1 */
        signo -= 1;// 信号范围是 [1 ~ 64 ],而保存变量位的范围是[0 ~ 63]
        /* Add the signal to the set */
        *set |= SIGNO2SET((unsigned int)signo);//填充信号集
        return LOS_OK;
    }
}

函数调用图:

这是这个函数的调用关系图:

OsSigEmptySet()

int OsSigEmptySet

(

sigset_t *

set

)

信号集全部清0

在文件 los_signal.c 第 392 行定义.

{
    *set = NULL_SIGNAL_SET;
    return 0;
}

这是这个函数的调用关系图:

OsSigIntLock()

VOID OsSigIntLock

(

VOID

)

在文件 los_signal.c 第 704 行定义.

{
    LosTaskCB *task = OsCurrTaskGet();
    sig_cb *sigcb = &task->sig;
 
    (VOID)LOS_AtomicAdd((Atomic *)&sigcb->sigIntLock, 1);
}

函数调用图:

这是这个函数的调用关系图:

OsSigIntUnlock()

VOID OsSigIntUnlock

(

VOID

)

在文件 los_signal.c 第 712 行定义.

{
    LosTaskCB *task = OsCurrTaskGet();
    sig_cb *sigcb = &task->sig;
 
    (VOID)LOS_AtomicSub((Atomic *)&sigcb->sigIntLock, 1);
}

函数调用图:

这是这个函数的调用关系图:

OsSigIsMember()

int OsSigIsMember	(	const sigset_t *	set,
		int	signo
	)

判定信号signo是否存在信号集中。如果信号集里已有该信号则返回1，否则返回0。如果有错误则返回-1

参数

set
signo

返回

int

在文件 los_signal.c 第 62 行定义.

{
    int ret = LOS_NOK;
    /* In musl, sig No bits 00000100 present sig No 3, but  1<< 3 = 00001000, so signo needs minus 1 */ 
    //在musl中，sig No bits 00000100表示sig No 3，但是在SIGNO2SET中 1<<3 = 00001000,因此signo需要减1
    signo -= 1;
    /* Verify the signal */
    if (GOOD_SIGNO(signo)) {//有效信号判断
        /* Check if the signal is in the set */
        ret = ((*set & SIGNO2SET((unsigned int)signo)) != 0);//检查信号是否还在集合中
    }
 
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsSigPending()

int OsSigPending

(

sigset_t *

set

)

获取阻塞当前任务的信号集

在文件 los_signal.c 第 541 行定义.

{
    LosTaskCB *tcb = NULL;
    unsigned int intSave;
 
    if (set == NULL) {
        return -EFAULT;
    }
 
    SCHEDULER_LOCK(intSave);
    tcb = OsCurrTaskGet();
    *set = tcb->sig.sigPendFlag;//被阻塞的信号集
    SCHEDULER_UNLOCK(intSave);
    return LOS_OK;
}

函数调用图:

这是这个函数的调用关系图:

OsSigprocMask()

int OsSigprocMask	(	int	how,
		const sigset_t_l *	setl,
		sigset_t_l *	oldsetl
	)

   向信号集设置信号屏蔽的方法
       SIG_BLOCK：将set指向信号集中的信号，添加到进程阻塞信号集；
       SIG_UNBLOCK：将set指向信号集中的信号，从进程阻塞信号集删除；
       SIG_SETMASK：将set指向信号集中的信号，设置成进程阻塞信号集；
* 

在文件 los_signal.c 第 233 行定义.

{
    LosTaskCB *spcb = NULL;
    int ret = LOS_OK;
    unsigned int intSave;
    sigset_t set;
 
    SCHEDULER_LOCK(intSave);
    spcb = OsCurrTaskGet();
    /* If requested, copy the old mask to user. | 如果需要，请将旧掩码复制给用户*/
    if (oldsetl != NULL) {
        *(sigset_t *)oldsetl = spcb->sig.sigprocmask;
    }
    /* If requested, modify the current signal mask. | 如有要求，修改当前信号屏蔽*/
    if (setl != NULL) {
        set = *(sigset_t *)setl;
        /* Okay, determine what we are supposed to do */
        switch (how) {
            /* Set the union of the current set and the signal
             * set pointed to by set as the new sigprocmask.
             */
            case SIG_BLOCK:
                spcb->sig.sigprocmask |= set;//增加信号屏蔽位
                break;
            /* Set the intersection of the current set and the
             * signal set pointed to by set as the new sigprocmask.
             */
            case SIG_UNBLOCK:
                spcb->sig.sigprocmask &= ~(set);//解除信号屏蔽位
                break;
            /* Set the signal set pointed to by set as the new sigprocmask. */
            case SIG_SETMASK:
                spcb->sig.sigprocmask = set;//设置一个新的屏蔽掩码
                break;
            default:
                ret = -EINVAL;
                break;
        }
        /* If pending mask not in sigmask, need set sigflag. */
        OsSigMaskSwitch(spcb, spcb->sig.sigprocmask);//更新与屏蔽信号相关的变量
    }
    SCHEDULER_UNLOCK(intSave);
 
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsSigSuspend()

int OsSigSuspend

(

const sigset_t *

set

)

用参数set代替进程的原有掩码，并暂停进程执行，直到收到信号再恢复原有掩码并继续执行进程。

在文件 los_signal.c 第 627 行定义.

{
    unsigned int intSave;
    LosTaskCB *rtcb = NULL;
    sigset_t setSuspend;
    int ret;
 
    if (set == NULL) {
        return -EINVAL;
    }
    SCHEDULER_LOCK(intSave);
    rtcb = OsCurrTaskGet();
 
    /* Wait signal calc */
    setSuspend = FULL_SIGNAL_SET & (~(*set));
 
    /* If pending mask not in sigmask, need set sigflag */
    OsSigMaskSwitch(rtcb, *set);
 
    if (rtcb->sig.sigFlag > 0) {
        SCHEDULER_UNLOCK(intSave);
 
        /*
         * If rtcb->sig.sigFlag > 0, it means that some signal have been
         * received, and we need to do schedule to handle the signal directly.
         */
        LOS_Schedule();
        return -EINTR;
    } else {
        ret = OsSigTimedWaitNoLock(&setSuspend, NULL, LOS_WAIT_FOREVER);
        if (ret < 0) {
            PRINT_ERR("FUNC %s LINE = %d, ret = %x\n", __FUNCTION__, __LINE__, ret);
        }
    }
 
    SCHEDULER_UNLOCK(intSave);
    return -EINTR;
}

函数调用图:

这是这个函数的调用关系图:

OsSigTimedWait()

int OsSigTimedWait	(	sigset_t *	set,
		siginfo_t *	info,
		unsigned int	timeout
	)

让当前任务等待的信号

在文件 los_signal.c 第 604 行定义.

{
    int ret;
    unsigned int intSave;
 
    SCHEDULER_LOCK(intSave);
 
    ret = OsSigTimedWaitNoLock(set, info, timeout);//以不加锁的方式等待
 
    SCHEDULER_UNLOCK(intSave);
    return ret;
}

函数调用图:

这是这个函数的调用关系图:

OsTaskKillUnsafe()

INT32 OsTaskKillUnsafe	(	UINT32	taskID,
		INT32	signo
	)

在文件 los_signal.c 第 490 行定义.

{
    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);
}

函数调用图:

这是这个函数的调用关系图:

sys_rt_sigtimedwait()

int sys_rt_sigtimedwait	(	const sigset_t *	mask,
		siginfo_t *	si,
		const struct timespec *	ts,
		size_t	sigsetsize
	)

sys_sigpending()

int sys_sigpending

(

sigset_t *

)

sys_sigqueue()

int sys_sigqueue	(	pid_t	,
		int	,
		const union sigval
	)

sys_sigsuspend()

int sys_sigsuspend

(

const sigset_t *

)