linux 程序收到sigsegv信号_信号

当其他方式不起作用时（例如标准输入被冻结），信号是提供低优先级信息和用户与其程序交互的便捷方式。它们允许程序在事件发生时清理或执行操作。有时，程序可以选择忽略受支持的事件。由于处理信号的方式，制作一个使用信号的程序很棘手。因此，信号通常用于终止和清理。它们很少被用于编程逻辑。

对于那些具有架构背景的人来说，这里使用的中断不是硬件生成的中断。这些中断几乎总是由内核处理，因为它们需要更高级别的权限。相反，我们讨论的是由内核生成的软件中断 - 尽管它们可以响应像SIGSEGV这样的硬件事件。

本章将介绍如何从已退出或已发出信号的进程中读取信息。然后，它将深入研究什么是信号，内核如何处理信号，以及进程可以处理有线和无线信号的各种方式。

信号的深度挖掘

信号允许一个进程异步地将事件或消息发送到另一个进程。如果该过程想要接受信号，那么对于大多数信号，它可以决定如何处理该信号。

首先，一些术语。信号处理是一个每进程属性，用于确定信号在传送后的处理方式 。将其视为信号 - 动作对的表。 操作是

1. TERM，终止过程
2. IGN， 忽视
3. CORE，生成核心转储
4. STOP，停止一个过程
5. CONT，继续一个过程
6. 执行自定义功能。

信号掩码确定是否传送特定信号。内核如何发送信号的整个过程如下。

1. 如果没有信号到达，则该过程可以安装自己的信号处理程序。这告诉内核当进程获得信号X时它应该跳转到函数Y.
2. 创建的信号处于“生成”状态。
3. 生成信号和内核可以应用掩码规则之间的时间称为挂起状态。
4. 然后内核检查进程的信号掩码。如果掩码表示进程中的所有线程都阻塞了该信号，则该信号当前被阻塞，并且在线程解除阻塞之前没有任何反应。
5. 如果单个线程可以接受该信号，则内核在处置表中执行该操作。如果操作是默认操作，则不需要暂停任何线程。
6. 否则，内核通过停止提供信号的任何特定线程目前正在做，并跳转该线程信号处理程序。信号现在处于交付阶段。现在可以生成更多信号，但是在信号处理程序完成时（即交付阶段结束时），它们无法传递。
7. 最后，如果在信号传递后过程保持完好，我们会考虑捕获信号。

作为流程图

以下是您将看到的一些常见信号。

| C | C | C | 名称和便携式编号和默认操作和常用使用
SIGINT＆2＆终止（可以捕获）并很好地停止流程
SIGQUIT＆3＆终止（可以捕获）并严格停止流程
SIGTERM＆15＆终止流程并停止流程甚至更严厉的
SIGSTOP＆N / A和停止流程（无法捕获）＆暂停流程
SIGCONT＆N / A＆继续流程并在停止
SIGKILL＆9＆终止流程（无法捕获）后启动＆您想要流程走了

我们最喜欢的轶事之一是永远不会kill -9出于各种原因使用。以下是http://porkmail.org/era/unix/award.html的摘录

不不不。不要使用kill -9。

它没有给这个过程一个干净的机会：

1）关闭连接

2）清理临时文件

3）告知孩子它正在消失

4）重置其终端特性

依此类推等等。

一般情况下，发送15，等待一两秒，如果不起作用，发送2，如果不起作用，发送1.如果不成功，删除二进制，因为程序表现不好！

我们仍然保留kill -9是为了应对需要消除这个过程的极端情况。

发送信号

信号可以以多种方式生成。

1. 用户可以发送信号。例如，您在终端，然后按CTRL-C。也可以使用内置kill发送任何信号。
2. 系统可以发送事件。例如，如果进程访问了不应该访问的页面，则硬件会生成一个被内核拦截的中断。内核找到导致此问题的进程并发送软件中断信号SIGSEGV。还有其他内核事件，例如正在创建子项或需要恢复进程。
3. 最后，另一个进程可以发送消息。这可以用于进程之间事件的低风险通信。如果您依靠信号作为程序中的驱动程序，则应重新考虑应用程序设计。使用POSIX /实时信号进行异步通信有许多缺点。处理进程间通信的最佳方法是使用专门为您手头的任务设计的进程间通信方法。

您或其他进程可以通过向其发送SIGSTOP信号来暂时暂停正在运行的进程。如果成功，它将冻结一个过程。该进程将不再分配CPU时间。要允许进程恢复执行，请将SIGCONT信号发送给它。例如，以下是每秒缓慢打印一个点的程序，最多59个点。

#include <unistd.h>

#include <stdio.h>

int main() {

printf("My pid is %dn", getpid() );

int i = 60;

while(--i) {

write(1, ".",1);

sleep(1);

}

write(1, "Done!",5);

return 0;

}

我们将首先在后台启动该过程（注意＆结束）。然后，使用kill命令从shell进程发送一个信号。

$ ./program &

My pid is 403

...

$ kill -SIGSTOP 403

$ kill -SIGCONT 403

...

在C中，程序可以使用killPOSIX调用向孩子发送信号，

kill(child, SIGUSR1); // Send a user-defined signal

kill(child, SIGSTOP); // Stop the child process (the child cannot prevent this)

kill(child, SIGTERM); // Terminate the child process (the child can prevent this)

kill(child, SIGINT); // The equivalent to CTRL-C (by default closes the process)

如上所述kill，shell中还有一个命令。另一个命令killall以完全相同的方式工作，但它不是通过PID查找，而是尝试匹配进程的名称。ps是一个重要的实用程序，可以帮助您找到进程的pid。

# First let's use ps and grep to find the process we want to send a signal to

$ ps au | grep myprogram

angrave 4409 0.0 0.0 2434892 512 s004 R+ 2:42PM 0:00.00 myprogram 1 2 3

#Send SIGINT signal to process 4409 (The equivalent of `CTRL-C`)

$ kill -SIGINT 4409

# Send SIGKILL (terminate the process)

$ kill -SIGKILL 4409

$ kill -9 4409

# Use kill all instead to kill a process by executable name

$ killall -l firefox

要发送信号到正在运行的进程，使用raise或kill用 getpid()。

raise(int sig); // Send a signal to myself!

kill(getpid(), int sig); // Same as above

对于非根进程，信号只能发送给同一用户的进程。你不能SIGKILL任何过程！man -s2 kill更多细节。

处理信号

信号处理程序中的可执行代码有严格的限制。大多数库和系统调用都async-signal-unsafe意味着它们可能不会在信号处理程序中使用，因为它们不是可重入的。可重入安全意味着您的功能可以在任何时候被冻结并再次执行，您能保证您的功能不会失败吗？我们来看看以下内容

int func(const char *str) {

static char buffer[200];

strncpy(buffer, str, 199);

# Here is where we get paused

printf("%sn", buffer)

}

1. 我们执行(func（“Hello”））
2. 字符串被完全复制到缓冲区（strcmp（缓冲区，“Hello”）== 0）
3. 传递信号并且功能状态冻结，我们也停止接受任何新信号，直到处理程序之后（为方便起见，我们这样做）
4. 我们执行 func("World")
5. 现在（strcmp（缓冲区，“世界”）== 0）并且缓冲区打印出“世界”。
6. 我们恢复中断的功能，现在再次打印出缓冲区“World”而不是函数调用原本打算“Hello”

通过删除共享缓冲区无法解决保证函数是信号处理程序安全的问题。您还必须考虑多线程和同步 - 当我双重锁定互斥锁时会发生什么？您还必须确保每个函数调用都是可重入的安全。假设您的原始程序在执行库代码时被中断 malloc。malloc使用的内存结构将不一致。调用printf，malloc作为信号处理程序的一部分使用，是不安全的，将导致未定义的行为。避免此行为的一种安全方法是设置变量并让程序恢复运行。设计模式还有助于我们设计可以接收信号两次并正确运行的程序。

int pleaseStop ; // See notes on why "volatile sig_atomic_t" is better

void handle_sigint(int signal) {

pleaseStop = 1;

}

int main() {

signal(SIGINT, handle_sigint);

pleaseStop = 0;

while (!pleaseStop) {

/* application logic here */

}

/* clean up code here */

}

上面的代码似乎在纸上是正确的。但是，我们需要为编译器和将执行main()循环的CPU核心提供提示 。我们需要阻止编译器优化。表达式 pleaseStop不会在循环体中发生变化，因此一些编译器会将其优化为trueTODO：需要引用。其次，我们需要确保pleaseStop使用CPU寄存器来缓存值，而是始终读取和写入主存储器。该sig_atomic_t类型意味着变量的所有位都可以作为atomic operation单个不间断操作读取或修改。不可能读取由一些新位值和旧位值组成的值。

通过pleaseStop使用正确的类型 指定volatile sig_atomic_t，我们可以编写可移植代码，其中主循环将在信号处理程序返回后退出。该sig_atomic_t类型可以与int大多数现代平台上的类型一样大，但在嵌入式系统上可以像a一样小，char并且只能表示（-127到127）个值。

volatile sig_atomic_t pleaseStop;

在COMP基于终端的1Hz 4bit计算机（Šorn ＃ref-Sorn_2015）中可以找到这种模式的两个例子。使用两个布尔标志。一个用于标记SIGINT（CTRL-C）的传送，并正常关闭程序，另一个用于标记SIGWINCH 信号以检测终端调整大小并重绘整个显示。

您也可以异步或同步选择句柄待处理信号。要安装信号处理程序以异步处理信号，请使用sigaction。为了同步捕获待处理信号，使用 sigwait哪些阻塞直到信号被传递或者signalfd还阻塞并提供可以read()检索未决信号的文件描述符。

sigaction

您应该使用sigaction而不是signal因为它具有更好的定义语义。signal在不同的操作系统上做不同的事情是不好的。sigaction更便携，更好地为线程定义。您可以使用系统调用sigaction来设置信号的当前处理程序和处置，或者读取特定信号的当前信号处理程序。

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

sigaction结构包括两个回调函数（我们只会查看'handler'版本），一个信号掩码和一个flags字段 -

struct sigaction {

void (*sa_handler)(int);

void (*sa_sigaction)(int, siginfo_t *, void *);

sigset_t sa_mask;

int sa_flags;

};

假设您偶然发现了使用的遗留代码signal。以下代码段myhandler作为SIGALRM处理程序安装。

signal(SIGALRM, myhandler);

等效sigaction代码是：

struct sigaction sa;

sa.sa_handler = myhandler;

sigemptyset(&sa.sa_mask);

sa.sa_flags = 0;

sigaction(SIGALRM, &sa, NULL)

但是，我们通常也可以设置掩码和标志字段。掩码是在信号处理程序执行期间使用的临时信号掩码。如果在系统调用过程中中断服务于该信号的线程，该SA_RESTART标志将自动重新启动一些系统调用，否则这些调用将在EINTR错误的早期返回。后者意味着我们可以稍微简化代码的其余部分，因为可能不再需要重启循环。

sigfillset(&sa.sa_mask);

sa.sa_flags = SA_RESTART; /* Restart functions if interrupted by handler */

由于标志的选择性，让代码检查错误并重新启动自身通常会更好。

阻止信号

阻止信号使用sigprocmask！使用sigprocmask，您可以设置新掩码，将要阻止的新信号添加到进程掩码，以及取消阻止当前阻塞的信号。您还可以通过传入oldset的非null值来确定现有掩码（并在以后使用它）。

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

在sigprocmask的Linux手册页中，以下是how TODO：cite的可能值 。

• SIG_BLOCK。阻塞信号集是当前集和set参数的并集。
• SIG_UNBLOCK。设置中的信号从当前阻塞信号集中移除。允许尝试解锁未被阻塞的信号。
• SIG_SETMASK。阻塞信号集被设置为参数集。

sigset类型表现为一组。忘记在添加到集合之前初始化信号集是一个常见错误。

sigset_t set, oldset;

sigaddset(&set, SIGINT); // Ooops!

sigprocmask(SIG_SETMASK, &set, &oldset)

正确的代码将该集初始化为全部打开或全部关闭。例如，

sigfillset(&set); // all signals

sigprocmask(SIG_SETMASK, &set, NULL); // Block all the signals which can be blocked

sigemptyset(&set); // no signals

sigprocmask(SIG_SETMASK, &set, NULL); // set the mask to be empty again

如果您阻止信号既具有sigprocmask或者pthread_sigmask，然后用注册的处理程序sigaction，

sigwait

Sigwait可用于一次读取一个待处理信号。sigwait用于同步等待信号，而不是在回调中处理它们。下面显示了多线程程序中sigwait的典型用法。请注意，首先设置线程信号掩码（并且将由新线程继承）。掩码可防止信号被 传递，因此它们将保持挂起状态，直到调用sigwait。另请注意sigset_t，sigwait使用相同的set 变量

• 除了设置阻塞信号集之外，它被用作sigwait可以捕获和返回的信号集。

编写自定义信号处理线程（例如下面的示例）而不是回调函数的一个优点是，您现在可以安全地使用更多C库和系统函数。

基于sigmask代码（＃ref-pthread_sigmask）

static sigset_t signal_mask; /* signals to block */

int main(int argc, char *argv[]) {

pthread_t sig_thr_id; /* signal handler thread ID */

sigemptyset (&signal_mask);

sigaddset (&signal_mask, SIGINT);

sigaddset (&signal_mask, SIGTERM);

pthread_sigmask (SIG_BLOCK, &signal_mask, NULL);

/* New threads will inherit this thread's mask */

pthread_create (&sig_thr_id, NULL, signal_thread, NULL);

/* APPLICATION CODE */

...

}

void *signal_thread(void *arg) {

int sig_caught;

/* Use the same mask as the set of signals that we'd like to know about! */

sigwait(&signal_mask, &sig_caught);

switch (sig_caught) {

case SIGINT:

...

break;

case SIGTERM:

...

break;

default:

fprintf (stderr, "nUnexpected signal %dn", sig_caught);

break;

}

}

子进程和线程中的信号

这是流程章节的回顾。在分叉之后，子进程继承父级信号处置的副本和父级信号掩码的副本。如果在分叉之前已经安装了SIGINT处理程序，那么如果将SIGINT传递给子进程，子进程也将调用处理程序。如果SIGINT在父级中被阻止，它也将在子级中被阻止。请注意，在分叉期间不会继承子项的挂起信号。信号处理程序将重置为其原始操作，因为原始处理程序代码可能与旧进程一起消失。

每个线程都有自己的掩码。新线程继承调用线程掩码的副本。在初始化时，调用线程的掩码与进程掩码完全相同。创建新线程后，进程信号掩码变为灰色区域。相反，内核喜欢将进程视为线程集合，每个线程都可以构建信号掩码并接收信号。要开始设置面具，你可以使用，

pthread_sigmask(...); // set my mask to block delivery of some signals

pthread_create(...); // new thread will start with a copy of the same mask

阻塞信号在多线程程序中类似于单线程程序，具有以下转换。

1. 用pthread_sigmask而不是sigprocmask
2. 阻止所有线程中的信号以防止其异步传递

确保信号在所有线程中被阻止的最简单方法是在创建新线程之前在主线程中设置信号掩码。

sigemptyset(&set);

sigaddset(&set, SIGQUIT);

sigaddset(&set, SIGINT);

pthread_sigmask(SIG_BLOCK, &set, NULL);

// this thread and the new thread will block SIGQUIT and SIGINT

pthread_create(&thread_id, NULL, myfunc, funcparam);

正如我们所看到的sigprocmask，pthread_sigmask包括一个'how'参数，它定义了如何使用信号集：

pthread_sigmask(SIG_SETMASK, &set, NULL) - replace the thread's mask with given signal set

pthread_sigmask(SIG_BLOCK, &set, NULL) - add the signal set to the thread's mask

pthread_sigmask(SIG_UNBLOCK, &set, NULL) - remove the signal set from the thread's mask

然后可以将信号传递给愿意接受该信号的任何信号线程。如果两个或多个线程可以接收信号，那么哪个线程将被中断是任意的！通常的做法是让一个线程可以接收所有信号，或者如果某个信号需要特殊逻辑，则有多个线程用于多个信号。即使来自外部的程序无法向特定线程发送信号，您也可以在内部执行此操作 pthread_kill(pthread_t thread, int sig)。在下面的示例中，新创建的线程执行func将被中断SIGINT

pthread_create(&tid, NULL, func, args);

pthread_kill(tid, SIGINT);

pthread_kill(pthread_self(), SIGKILL); // send SIGKILL to myself

一句警告pthread_kill(threadid, SIGKILL)将杀死整个过程。虽然单个线程可以设置信号掩码，但信号处理是按进程而不是每个线程。这意味着 sigaction可以从任何线程调用，因为您将为进程中的所有线程设置信号处理程序。