信号的捕捉与sigaction函数

最新推荐文章于 2022-03-13 21:39:41 发布
最新推荐文章于 2022-03-13 21:39:41 发布
阅读量142 收藏
点赞数
文章标签： c/c++

一、内核如何实现信号的捕捉

如果信号的处理动作是用户自定义函数，在信号递达时就调用这个函数，这称为捕捉信号。由于信号处理函数的代码是在用户空间的，处理过程比较复杂，举例如下：
1. 用户程序注册了SIGQUIT信号的处理函数sighandler。
2. 当前正在执行main函数，这时发生中断或异常切换到内核态。
3. 在中断处理完毕后要返回用户态的main函数之前检查到有信号SIGQUIT递达。
4. 内核决定返回用户态后不是恢复main函数的上下文继续执行，而是执行sighandler函数，sighandler和main函数使用不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程。


 

1
2
 
(By  default,  the  signal  handler  is invoked on the normal process stack.  It is possible to arrange that the signal handler
 uses an alternate stack; see sigaltstack(2) for a discussion of how to do this and when it might be useful.)


5. sighandler函数返回后自动执行特殊的系统调用sigreturn再次进入内核态。
6. 如果没有新的信号要递达，这次再返回用户态就是恢复main函数的上下文继续执行了。


上图出自ULK。


二、sigaction函数

#include <signal.h>

int sigaction(int signo, const struct sigaction *act, struct sigaction *oact);


sigaction函数可以读取和修改与指定信号相关联的处理动作。调用成功则返回0，出错则返回-1。signo是指定信号的编号。若act指针非空，则根据act修改该信号的处理动作。若oact指针非空，则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体：  struct sigaction {
               void     (*sa_handler)(int);
               void     (*sa_sigaction)(int, siginfo_t *, void *);
               sigset_t   sa_mask;
               int        sa_flags;
               void     (*sa_restorer)(void);
           };


将sa_handler赋值为常数SIG_IGN传给sigaction表示忽略信号，赋值为常数SIG_DFL表示执行系统默认动作，赋值为一个函数指针表示用自定义函数捕捉信号，或者说向内核注册了一个信号处理函数，该函数返回值为void，可以带一个int参数，通过参数可以得知当前信号的编号，这样就可以用同一个函数处理多种信号。显然，这也是一个回调函数，不是被main函数调用，而是被系统所调用。
当某个信号的处理函数被调用时，内核自动将当前信号加入进程的信号屏蔽字，当信号处理函数返回时自动恢复原来的信号屏蔽字，这样就保证了在处理某个信号时，如果这种信号再次产生，那么它会被阻塞到当前处理结束为止。如果在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望自动屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时自动恢复原来的信号屏蔽字。


需要注意的是sa_restorer 参数已经废弃不用，sa_handler主要用于不可靠信号（实时信号当然也可以，只是不能带信息），sa_sigaction用于实时信号可以带信息(siginfo_t)，两者不能同时出现。sa_flags有几个选项，比较重要的有两个：SA_NODEFER 和 SA_SIGINFO，当SA_NODEFER设置时在信号处理函数执行期间不会屏蔽当前信号；当SA_SIGINFO设置时与sa_sigaction 搭配出现，sa_sigaction函数的第一个参数与sa_handler一样表示当前信号的编号，第二个参数是一个siginfo_t 结构体，第三个参数一般不用。当使用sa_handler时sa_flags设置为0即可。


 siginfo_t {
               int      si_signo;    /* Signal number */
               int      si_errno;    /* An errno value */
               int      si_code;     /* Signal code */
               int      si_trapno;   /* Trap number that caused
                                        hardware-generated signal
                                        (unused on most architectures) */
               pid_t    si_pid;      /* Sending process ID */
               uid_t    si_uid;      /* Real user ID of sending process */
               int      si_status;   /* Exit value or signal */
               clock_t  si_utime;    /* User time consumed */
               clock_t  si_stime;    /* System time consumed */
               sigval_t si_value;    /* Signal value */
               int      si_int;      /* POSIX.1b signal */
               void    *si_ptr;      /* POSIX.1b signal */
               int      si_overrun;  /* Timer overrun count; POSIX.1b timers */
               int      si_timerid;  /* Timer ID; POSIX.1b timers */
               void    *si_addr;     /* Memory location which caused fault */
               long     si_band;     /* Band event (was int in
                                        glibc 2.3.2 and earlier) */
               int      si_fd;       /* File descriptor */
               short    si_addr_lsb; /* Least significant bit of address
                                        (since kernel 2.6.32) */
           }


需要注意的是并不是所有成员都在所有信号中存在定义，有些成员是共用体，读取的时候需要读取对某个信号来说恰当的有定义的部分。


下面用sigaction函数举个小例子：

 

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
/*************************************************************************
    > File Name: process_.c
    > Author: Simba
    > Mail: dameng34@163.com
    > Created Time: Sat 23 Feb 2013 02:34:02 PM CST
 ************************************************************************/
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<signal.h>

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)

void handler(int sig);


int main(int argc, char *argv[])
{
    struct sigaction act;
    act.sa_handler = handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;

    if (sigaction(SIGINT, &act, NULL) < 0)
        ERR_EXIT("sigaction error");

    for (; ;)
        pause();

    return 0;

}

void handler(int sig)
{
    printf("rev sig=%d\n", sig);
}

simba@ubuntu:~/Documents/code/linux_programming/APUE/signal$ ./sigaction 
^Crev sig=2
^Crev sig=2
^Crev sig=2

...........................

即按下ctrl+c 会一直产生信号而被处理打印recv语句。


其实我们在前面文章说过的signal 函数是调用sigaction 实现的，而sigaction函数底层是调用 do_sigaction() 函数实现的。可以自己实现一个my_signal 函数，如下：

 

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
/*************************************************************************
    > File Name: process_.c
    > Author: Simba
    > Mail: dameng34@163.com
    > Created Time: Sat 23 Feb 2013 02:34:02 PM CST
 ************************************************************************/
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<signal.h>

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)

void handler(int sig);
/* 系统调用signal()实际上调用了sigaction() */
__sighandler_t my_signal(int sig, __sighandler_t handler);

int main(int argc, char *argv[])
{
    my_signal(SIGINT, handler);

    for (; ;)
        pause();

    return 0;

}

__sighandler_t my_signal(int sig, __sighandler_t handler)
{
    struct sigaction act;
    struct sigaction oldact;
    act.sa_handler = handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;

    if (sigaction(sig, &act, &oldact) < 0)
        return SIG_ERR;

    return oldact.sa_handler; // 返回先前的处理函数指针
}

void handler(int sig)
{
    printf("rev sig=%d\n", sig);
}

输出测试是一样的，需要注意的是 signal函数成功返回先前的handler，失败返回SIG_ERR。而sigaction 是通过oact 参数返回先前的handler，成功返回0，失败返回-1。


下面再举个小例子说明sa_mask 的作用：

 

 C++ Code 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
/*************************************************************************
    > File Name: process_.c
    > Author: Simba
    > Mail: dameng34@163.com
    > Created Time: Sat 23 Feb 2013 02:34:02 PM CST
 ************************************************************************/
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>
#include<signal.h>

#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)

void handler(int sig);


int main(int argc, char *argv[])
{
    struct sigaction act;
    act.sa_handler = handler;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask, SIGQUIT); // 在信号处理函数执行期间屏蔽SIGQUIT信号，完毕后会抵达
    /* 注意sigprocmask中屏蔽的信号是一直不能抵达的，除非解除了阻塞*/
    act.sa_flags = 0;

    if (sigaction(SIGINT, &act, NULL) < 0)
        ERR_EXIT("sigaction error");

    for (; ;)
        pause();

    return 0;

}

void handler(int sig)
{
    printf("rev sig=%d\n", sig);
    sleep(5);
}

先按下ctrl+c ，然后马上ctrl+\，程序是不会马上终止的，即等到handler处理完毕SIGQUIT信号才会抵达。

simba@ubuntu:~/Documents/code/linux_programming/APUE/signal$ ./sa_mask 
^Crev sig=2
^\

5s过后接着才输出Quit (core dumped)，即在信号处理函数执行期间sa_mask集合中的信号被阻塞直到运行完毕。


sa_flags 和 sa_sigaction 参数的示例看这里。


在多线程环境下，编写信号处理函数需要安全地处理，可以参考这篇文章：

 

tgkill()发给指定进程中的指定线程；

pthread_kill()由一个线程发给同进程中的另一个线程，实际上是通过封装tgkill()实现的；

《Linux 多线程应用中如何编写安全的信号处理函数》

http://www.ibm.com/developerworks/cn/linux/l-cn-signalsec/


参考：《APUE》、《linux c 编程一站式学习》

 

 

 

 

Linux 多线程应用中如何编写安全的信号处理函数

 

 

Linux 多线程应用中编写安全的信号处理函数

 

在开发多线程应用时，开发人员一般都会考虑线程安全，会使用 pthread_mutex 去保护全局变量。如果应用中使用了信号，而且信号的产生不是因为程序运行出错，而是程序逻辑需要，譬如 SIGUSR1、SIGRTMIN 等，信号在被处理后应用程序还将正常运行。在编写这类信号处理函数时，应用层面的开发人员却往往忽略了信号处理函数执行的上下文背景，没有考虑编写安全的信号处理函数的一些规则。本文首先介绍编写信号处理函数时需要考虑的一些规则；然后举例说明在多线程应用中如何构建模型让因为程序逻辑需要而产生的异步信号在指定的线程中以同步的方式处理。

 

线程和信号

 

Linux 多线程应用中，每个线程可以通过调用 pthread_sigmask() 设置本线程的信号掩码。一般情况下，被阻塞的信号将不能中断此线程的执行，除非此信号的产生是因为程序运行出错如 SIGSEGV；另外不能被忽略处理的信号 SIGKILL 和 SIGSTOP 也无法被阻塞。

 

当一个线程调用 pthread_create() 创建新的线程时，此线程的信号掩码会被新创建的线程继承。

 

POSIX.1 标准定义了一系列线程函数的接口，即 POSIX threads(Pthreads)。Linux C 库提供了两种关于线程的实现：LinuxThreads 和 NPTL(Native POSIX Threads Library)。LinuxThreads 已经过时，一些函数的实现不遵循POSIX.1 规范。NPTL 依赖 Linux 2.6 内核，更加遵循 POSIX..1 规范，但也不是完全遵循。

 

基于 NPTL 的线程库，多线程应用中的每个线程有自己独特的线程 ID，并共享同一个进程ID。应用程序可以通过调用 kill(getpid(),signo) 将信号发送到进程，如果进程中当前正在执行的线程没有阻碍此信号，则会被中断，线号处理函数会在此线程的上下文背景中执行。应用程序也可以通过调用 pthread_kill(pthread_t thread, int sig) 将信号发送给指定的线程，则线号处理函数会在此指定线程的上下文背景中执行。

 

基于 LinuxThreads 的线程库，多线程应用中的每个线程拥有自己独特的进程 ID，getpid（） 在不同的线程中调用会返回不同的值，所以无法通过调用 kill(getpid(),signo) 将信号发送到整个进程。

 

下文介绍的在指定的线程中以同步的方式处理异步信号是基于使用了 NPTL 的 Linux C 库。请参考“Linux 线程模型的比较：LinuxThreads 和 NPTL”和“pthreads(7) - Linux man page”进一步了解 Linux 的线程模型，以及不同版本的 Linux C 库对 NPTL 的支持。

 

编写安全的异步信号处理函数

 

信号的产生可以是：

 

  • 用户从控制终端终止程序运行，如 Ctrk + C 产生 SIGINT；

 

  • 程序运行出错时由硬件产生信号，如访问非法地址产生 SIGSEGV；
  • 程序运行逻辑需要，如调用 kill、raise 产生信号。

 

因为信号是异步事件，即信号处理函数执行的上下文背景是不确定的，譬如一个线程在调用某个库函数时可能会被信号中断，库函数提前出错返回，转而去执行信号处理函数。对于上述第三种信号的产生，信号在产生、处理后，应用程序不会终止，还是会继续正常运行，在编写此类信号处理函数时尤其需要小心，以免破坏应用程序的正常运行。关于编写安全的信号处理函数主要有以下一些规则：

 

  • 信号处理函数尽量只执行简单的操作，譬如只是设置一个外部变量，其它复杂的操作留在信号处理函数之外执行；
  • errno 是线程安全，即每个线程有自己的 errno，但不是异步信号安全。如果信号处理函数比较复杂，且调用了可能会改变 errno 值的库函数，必须考虑在信号处理函数开始时保存、结束的时候恢复被中断线程的 errno 值；

 

  • 信号处理函数只能调用可以重入的 C 库函数；譬如不能调用 malloc（），free（）以及标准 I/O 库函数等；
  • 信号处理函数如果需要访问全局变量，在定义此全局变量时须将其声明为 volatile，以避免编译器不恰当的优化。

 

从整个 Linux 应用的角度出发，因为应用中使用了异步信号，程序中一些库函数在调用时可能被异步信号中断，此时必须根据errno 的值考虑这些库函数调用被信号中断后的出错恢复处理，譬如socket 编程中的读操作：

 

rlen = recv(sock_fd, buf, len, MSG_WAITALL);
if ((rlen == -1) && (errno == EINTR)){
     // this kind of error is recoverable, we can set the offset change
     //‘rlen’ as 0 and continue to recv
}

 

在指定的线程中以同步的方式处理异步信号

 

如上文所述，不仅编写安全的异步信号处理函数本身有很多的规则束缚；应用中其它地方在调用可被信号中断的库函数时还需考虑被中断后的出错恢复处理。这让程序的编写变得复杂，幸运的是，POSIX.1 规范定义了sigwait()、 sigwaitinfo() 和 pthread_sigmask() 等接口，可以实现：

 

  • 以同步的方式处理异步信号；

 

  • 在指定的线程中处理信号。

 

这种在指定的线程中以同步方式处理信号的模型可以避免因为处理异步信号而给程序运行带来的不确定性和潜在危险。

 

sigwait

 

sigwait() 提供了一种等待信号的到来，以串行的方式从信号队列中取出信号进行处理的机制。sigwait（）只等待函数参数中指定的信号集，即如果新产生的信号不在指定的信号集内，则 sigwait（）继续等待。对于一个稳定可靠的程序，我们一般会有一些疑问：

 

  • 多个相同的信号可不可以在信号队列中排队？

 

  • 如果信号队列中有多个信号在等待，在信号处理时有没有优先级规则？
  • 实时信号和非实时信号在处理时有没有什么区别？

 

笔者写了一小段测试程序来测试 sigwait 在信号处理时的一些规则。

 

清单 1. sigwait_test.c

 

#include < signal.h >
#include < errno.h >
#include < pthread.h >
#include < unistd.h >
#include < sys /types.h>
 
void sig_handler(int signum)
{
     printf("Receive signal. %d\n", signum);
}
 
void* sigmgr_thread()
{
     sigset_t   waitset, oset;
     int        sig;
     int        rc;
     pthread_t  ppid = pthread_self();
 
     pthread_detach(ppid);
 
     sigemptyset(&waitset);
     sigaddset(&waitset, SIGRTMIN);
     sigaddset(&waitset, SIGRTMIN+2);
     sigaddset(&waitset, SIGRTMAX);
     sigaddset(&waitset, SIGUSR1);
     sigaddset(&waitset, SIGUSR2);
 
     while (1)  {
         rc = sigwait(&waitset, &sig);
         if (rc != -1) {
             sig_handler(sig);
         } else {
             printf("sigwaitinfo() returned err: %d; %s\n", errno, strerror(errno));
         }
     }
}
 
 
int main()
{
     sigset_t bset, oset;
     int             i;
     pid_t           pid = getpid();
     pthread_t       ppid;
 
     sigemptyset(&bset);
     sigaddset(&bset, SIGRTMIN);
     sigaddset(&bset, SIGRTMIN+2);
     sigaddset(&bset, SIGRTMAX);
     sigaddset(&bset, SIGUSR1);
     sigaddset(&bset, SIGUSR2);
 
     if (pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
         printf("!! Set pthread mask failed\n");
 
     kill(pid, SIGRTMAX);
     kill(pid, SIGRTMAX);
     kill(pid, SIGRTMIN+2);
     kill(pid, SIGRTMIN);
     kill(pid, SIGRTMIN+2);
     kill(pid, SIGRTMIN);
     kill(pid, SIGUSR2);
     kill(pid, SIGUSR2);
     kill(pid, SIGUSR1);
kill(pid, SIGUSR1);
 
     // Create the dedicated thread sigmgr_thread() which will handle signals synchronously
     pthread_create(&ppid, NULL, sigmgr_thread, NULL);
 
     sleep(10);
 
     exit (0);
}

 

程序编译运行在 RHEL4 的结果如下：

 

图 1. sigwait 测试程序执行结果

sigwait 测试程序执行结果

从以上测试程序发现以下规则：

 

  • 对于非实时信号，相同信号不能在信号队列中排队；对于实时信号，相同信号可以在信号队列中排队。

 

  • 如果信号队列中有多个实时以及非实时信号排队，实时信号并不会先于非实时信号被取出，信号数字小的会先被取出：如 SIGUSR1（10）会先于 SIGUSR2 (12)，SIGRTMIN（34）会先于 SIGRTMAX (64)， 非实时信号因为其信号数字小而先于实时信号被取出。

 

sigwaitinfo（） 以及 sigtimedwait() 也提供了与 sigwait（） 函数相似的功能。

 

Linux 多线程应用中的信号处理模型

 

在基于 Linux 的多线程应用中，对于因为程序逻辑需要而产生的信号，可考虑调用 sigwait（）使用同步模型进行处理。其程序流程如下：

 

  1. 主线程设置信号掩码，阻碍希望同步处理的信号；主线程的信号掩码会被其创建的线程继承；
  2. 主线程创建信号处理线程；信号处理线程将希望同步处理的信号集设为 sigwait（）的第一个参数。
  3. 主线程创建工作线程。

 

图 2. 在指定的线程中以同步方式处理异步信号的模型

在指定的线程中以同步方式处理异步信号的模型

代码示例

 

以下为一个完整的在指定的线程中以同步的方式处理异步信号的程序。

 

主线程设置信号掩码阻碍 SIGUSR1 和 SIGRTMIN 两个信号，然后创建信号处理线程sigmgr_thread（）和五个工作线程 worker_thread（）。主线程每隔10秒调用 kill() 对本进程发送 SIGUSR1 和 SIGTRMIN 信号。信号处理线程 sigmgr_thread（）在接收到信号时会调用信号处理函数 sig_handler()。

 

程序编译：gcc -o signal_sync signal_sync.c -lpthread

 

程序执行：./signal_sync

 

从程序执行输出结果可以看到主线程发出的所有信号都被指定的信号处理线程接收到，并以同步的方式处理。

 

清单 2. signal_sync.c

 

#include < signal.h >
#include < errno.h >
#include < pthread.h >
#include < unistd.h >
#include < sys /types.h>
  
void sig_handler(int signum)
{
     static int j = 0;
     static int k = 0;
     pthread_t  sig_ppid = pthread_self();
     // used to show which thread the signal is handled in.
    
     if (signum == SIGUSR1) {
         printf("thread %d, receive SIGUSR1 No. %d\n", sig_ppid, j);
         j++;
     //SIGRTMIN should not be considered constants from userland,
     //there is compile error when use switch case
     } else if (signum == SIGRTMIN) {
         printf("thread %d, receive SIGRTMIN No. %d\n", sig_ppid, k);
         k++;
     }
}
 
void* worker_thread()
{
     pthread_t  ppid = pthread_self();
     pthread_detach(ppid);
     while (1) {
         printf("I'm thread %d, I'm alive\n", ppid);
         sleep(10);
     }
}
 
void* sigmgr_thread()
{
     sigset_t   waitset, oset;
     siginfo_t  info;
     int        rc;
     pthread_t  ppid = pthread_self();
 
     pthread_detach(ppid);
 
     sigemptyset(&waitset);
     sigaddset(&waitset, SIGRTMIN);
     sigaddset(&waitset, SIGUSR1);
 
     while (1)  {
         rc = sigwaitinfo(&waitset, &info);
         if (rc != -1) {
             printf("sigwaitinfo() fetch the signal - %d\n", rc);
             sig_handler(info.si_signo);
         } else {
             printf("sigwaitinfo() returned err: %d; %s\n", errno, strerror(errno));
         }
     }
}
 
 
int main()
{
     sigset_t bset, oset;
     int             i;
     pid_t           pid = getpid();
     pthread_t       ppid;
     
 
     // Block SIGRTMIN and SIGUSR1 which will be handled in
     //dedicated thread sigmgr_thread()
     // Newly created threads will inherit the pthread mask from its creator
     sigemptyset(&bset);
     sigaddset(&bset, SIGRTMIN);
     sigaddset(&bset, SIGUSR1);
     if (pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
         printf("!! Set pthread mask failed\n");
     
     // Create the dedicated thread sigmgr_thread() which will handle
     // SIGUSR1 and SIGRTMIN synchronously
     pthread_create(&ppid, NULL, sigmgr_thread, NULL);
   
     // Create 5 worker threads, which will inherit the thread mask of
     // the creator main thread
     for (i = 0; i < 5; i++) {
         pthread_create(&ppid, NULL, worker_thread, NULL);
     }
 
     // send out 50 SIGUSR1 and SIGRTMIN signals
     for (i = 0; i < 50; i++) {
         kill(pid, SIGUSR1);
         printf("main thread, send SIGUSR1 No. %d\n", i);
         kill(pid, SIGRTMIN);
         printf("main thread, send SIGRTMIN No. %d\n", i);
         sleep(10);
     }
     exit (0);
}

 

注意事项

 

在基于 Linux 的多线程应用中，对于因为程序逻辑需要而产生的信号，可考虑使用同步模型进行处理；而对会导致程序运行终止的信号如 SIGSEGV 等，必须按照传统的异步方式使用 signal（）、 sigaction（）注册信号处理函数进行处理。这两种信号处理模型可根据所处理的信号的不同同时存在一个 Linux 应用中：

 

  • 不要在线程的信号掩码中阻塞不能被忽略处理的两个信号 SIGSTOP 和 SIGKILL。
  • 不要在线程的信号掩码中阻塞 SIGFPE、SIGILL、SIGSEGV、SIGBUS。
  • 确保 sigwait() 等待的信号集已经被进程中所有的线程阻塞。
  • 在主线程或其它工作线程产生信号时，必须调用 kill() 将信号发给整个进程，而不能使用 pthread_kill() 发送某个特定的工作线程，否则信号处理线程无法接收到此信号。
  • 因为 sigwait（）使用了串行的方式处理信号的到来，为避免信号的处理存在滞后，或是非实时信号被丢失的情况，处理每个信号的代码应尽量简洁、快速，避免调用会产生阻塞的库函数。

 

小结

 

在开发 Linux 多线程应用中， 如果因为程序逻辑需要引入信号， 在信号处理后程序仍将继续正常运行。在这种背景下，如果以异步方式处理信号，在编写信号处理函数一定要考虑异步信号处理函数的安全； 同时， 程序中一些库函数可能会被信号中断，错误返回，这时需要考虑对 EINTR 的处理。另一方面，也可考虑使用上文介绍的同步模型处理信号，简化信号处理函数的编写，避免因为信号处理函数执行上下文的不确定性而带来的风险。

 

免责声明：

 

  1. 本文所提出的方式方法仅代表作者个人观点。
  2. 本文属于原创作品，资料来源不超出参考文献所列范畴，其中任何部分都不会侵犯任何第三方的知识产权。

 

相关主题

 

 

weixin_33895657
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
信号捕捉函数sigaction
10-21
sigaction函数的功能是检查或修改与指定信号相关联的处理动作（可同时两种操作）
APUE函数笔记八: 信号
二斗墨汁
03-28 600
第十章  信号: 0 < signo < NSIG #include void (*signal(int signo, void(*func)(int)))(int); if error return SIG_ERR, else return previous handler #include int kill(pid_t pid, int signo); pid:
sigsuspend 将重设signal mask和等待合成原子操作
RichardYSteven的专栏
08-10 1046
<br />先来看一段代码<br />  sigset_t newmask, oldmask;<br /><br /> sigemptyset(&newmask);<br /> sigaddset(&newmask, SIGINT);<br /><br /> /* block SIGINT and save current signal mask */<br /> if (sigprocmask(SIG_BLOCK, &newmask
Linux操作系统之进程间通信
Carroll的博客
08-28 648
文章目录进程间通信的各种模式信号管道IPC（Inter-Process Communication，进程间通信） 进程间通信的各种模式 管道模型：类似瀑布开发模式的管道 消息队列模型：类似邮件模式的消息队列 共享内存模型：类似会议室联合开发的共享内存加信号量 信号量：类似应急预案的信号 信号量其实是一个计数器，主要用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。 将信号量初始化为一个数值，来代表某种资源的总体数量。对于信号量来讲，会定义两种原子操作，一个是P 操作，我们称为申请资源操作。
好文值得收藏：LINUX内核--信号实现原理
Gezhengzhong的专栏
09-16 1934
信号简介 信号在最早的UNIX系统引入，用于进程间通信，是内核的一种软件机制，通过内核代码实现的。 内核对信号的响应机制有点像中断，信号来了后需要打断当前进程的执行，去执行信号处理函数， 执行完毕后，再恢复原来的上下文继续执行。 内核对信号是如何管理的？信号在内核中是如何响应的？当前进程执行过程中，代码执行流是如何 跳转到信号处理函数的？执行完信号处理函数后，又是如何再跳回来的？ 请看下文，下文是基于X86处理器，4.18的内核为基础写的。 信号最原始的作用 信号是很短的消息，...
linux 内核信号机制需要解决的两个关键问题
龙瑜的博客
12-20 838
struct sigaction { #ifndef __ARCH_HAS_IRIX_SIGACTION __sighandler_t sa_handler; unsigned long sa_flags; #else unsigned int sa_flags; __sighandler_t sa_handler; #endif #ifdef __ARCH_HAS_SA_RESTORER __sigrestore_t sa_restorer; #endif sigset_t sa_mask; /* mas
Linux系统调用 sigaction 的用法
01-09
sigaction 函数原型定义如下： 　int sigaction(int signum， const struct sigaction *act，struct sigaction *oldact) 　这个系统调用的作用是改变进程接收到的指定信号的行动。 　使用这个函数需要包含头文件#...
Linux线程编程之信号处理
01-09
前言 　Linux多线程环境中的信号处理不同于进程的信号处理。一方面线程间信号处理函数的共享性使得信号处理更为复杂，另一方面普通异步信号又可转换为同步... 　1.1 进程与信号 　信号是向进程异步发送的软件通知，通
进程信号
01-20
信号基本概念 软件中断,打断正在运行的进程,使之去处理信号 信号种类 62种 1-31 : 不可靠信号, 有可能会丢失, 不是实时信号 ...调用函数 kill(int pid, int signal); abort() 谁调用给谁发送 SIGABRT 信号 int al
sigaction.c 文件
06-12
sigaction.c 文件下载后直接编译运行，详情看博客
Linux信号机制分析(七)
kessity的博客
08-29 314
信号 信号安装 信号集 信号掩码
linux内存访问信号,linux – 内存访问错误sys_rt_sigaction(信号处理程序)
weixin_32965939的博客
05-01 302
在x86-64 linux中,必须提供sa_restorer而你还没有这样做./* x86-64 should always use SA_RESTORER. */if (ksig->ka.sa.sa_flags & SA_RESTORER) {put_user_ex(ksig->ka.sa.sa_restorer, &frame->pretcode);} els...
Linux多线程编程-信号机制（sigwait、sigaction和pthread_sigmask、sigprocmask和pthread_kill、kill的区别）
Haomione的博客
01-13 1352
Linux多线程编程-信号机制（sigwait、sigaction和pthread_sigmask、sigprocmask和pthread_kill、kill的区别）
sigaction函数的使用和优点
pdx_ll的博客
03-13 563
NAME sigaction, rt_sigaction - examine and change a signal action SYNOPSIS #include <signal.h> int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); signum: 所要操作的信号 .
「ANR」Android SIGQUIT(3) 信号拦截与处理
qq_32198115的博客
10-12 4031
作者：非台 背景 Android的ANR频次（Application Not Responding）一直是Android用户体验的重要指标，然而在Android 6.0+的设备上，由于设备anr目录权限的收敛，已经不能通过扫描/data/anr/traces.txt文件来获取ANR文件了，因此今天我们来简单聊聊获取ANR的另一种方式，Android环境下，信号SIGQUIT(3)拦截。 信号量处理 关于信号SIGQUIT的拦截，我们需要了解信号量处理的部分相关函数，kill、signal、s...
linux中sigaction函数详解
热门推荐
魏波
08-04 9万+
一、函数原型：sigaction函数的功能是检查或修改与指定信号相关联的处理动作（可同时两种操作） int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact); signum参数指出要捕获的信号类型，act参数指定新的信号处理方式，oldact参数...
【Linux内核及驱动编程】Linux信号机制分析
踏雪无痕
11-25 2719
Linux信号机制分析   Sailor_forever [email protected]转载请注明 http://blog.csdn.net/sailor_8318/archive/2008/09/27/2990077.aspx   【摘要】本文分析了Linux内核对于信号的实现机制和应用层的相关处理。首先介绍了软中断信号的本质及信号的两种不同分类方法尤其是不可靠信号的原理。接
信号创建
轰轰烈烈的生活
11-29 767
函数  sigaction（查询或设置信号处理方式） int sigaction(int signum,const struct sigaction *act ,struct sigaction *oldact);会依参数signum指定的信号编号来设置该信号的处理函数。参数signum可以指定SIGKILL和SIGSTOP以外的所有信号。 参数 结构sigaction定义如下 str
sigaction函数
sgling0440的专栏
08-20 423
sigaction函数的功能是检查或修改与指定信号相关联的处理动作（可同时两种操作）。 他是POSIX的信号接口，而signal()是标准C的信号接口(如果程序必须在非POSIX系统上运行，那么就应该使用这个接口) 给信号signum设置新的信号处理函数act， 同时保留该信

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值