信号

信号是指示事件发生的进程的通知。 信号也被称为软件中断，不可预测知道它的发生，因此它也被称为异步事件。

信号可以用数字或名称来指定，通常信号名称以SIG开头。 可用的信号可以用命令kill -l(l列出信号名称)来检查，如下所示 -

无论何时发出信号(以编程方式或系统产生的信号)，都会执行默认操作。 如果您不想执行默认操作但希望在接收信号时执行自己的操作。 可以处理信号，但不能处理所有的信号。 如果你想忽略信号，这是可能的吗？ 这是可以忽略信号。 忽略信号意味着既不执行默认操作也不处理信号。 可以忽略或处理几乎所有的信号。 SIGSTOP和SIGKILL不能被忽略或处理/捕获的信号。

总之，对信号执行的操作如下 -

• 默认操作
• 处理信号
• 忽略信号

正如所讨论的，信号可以被处理，改变默认行为的执行。 信号处理可以通过系统调用，signal()和sigaction()两种方式完成。

#include <signal.h>

typedef void (*sighandler_t) (int);
sighandler_t signal(int signum, sighandler_t handler);

系统调用signal()将在符号中提到的信号产生时调用注册的处理程序。 处理程序可以是SIG_IGN(忽略信号)，SIG_DFL(将信号设置回默认机制)或用户定义的信号处理程序或函数地址之一。

这个系统调用成功返回一个函数的地址，该函数接受一个整数参数并且没有返回值。 这个调用在出错的时候返回SIG_ERR。

虽然signal()可以调用用户注册的各自的信号处理程序，但是不可能进行微调，例如掩蔽应该被阻塞的信号，修改信号的行为以及其他功能。 这可以使用sigaction()系统调用。

#include <signal.h>

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

这个系统调用用于检查或改变信号动作。 如果行为不为空，则从行为安装信号的新行为。 如果oldact不为null，则以前的操作将保存在oldact中。

sigaction结构包含以下字段 -

字段1 - 处理程序在sa_handler或sa_sigaction中提到。

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

sa_handler的处理程序指定要根据signum和SIG_DFL指示默认操作执行的操作，或者SIG_IGN忽略指向信号处理函数的信号或指针。
sa_sigaction的处理程序将信号编号指定为第一个参数，将指向siginfo_t结构体的指针指定为第二个参数，并指定用户上下文(有关详细信息，请参阅getcontext()或setcontext())作为第三个参数。

siginfo_t结构包含信号信息，例如要传递的信号数量，信号值，进程ID，发送进程的真实用户ID等。

字段2 - 要阻止的信号集。

int sa_mask;

这个变量指定了信号处理程序执行期间应该被阻塞的信号掩码。

字段3 - 特殊标志。

int sa_flags;

该字段指定一组修改信号行为的标志。

字段4 - 恢复处理程序。

void (*sa_restorer) (void);

这个系统调用在成功时返回0，在失败的情况下为-1。

让我们考虑一些示例程序。

首先，从一个生成异常的示例程序开始。 在这个程序中，试图执行除零运算，这会使系统产生一个异常。

/* signal_fpe.c */
#include<stdio.h>

int main() {
   int result;
   int v1, v2;
   v1 = 121;
   v2 = 0;
   result = v1/v2;
   printf("Result of Divide by Zero is %d\n", result);
   return 0;
}

编译和运行上面示例代码，得到以下结果 -

Floating point exception (core dumped)

因此，当试图执行一个算术运算时，系统已经产生了一个浮点异常，核心转储是信号的默认操作。

现在，修改代码以使用signal()系统调用来处理这个特定的信号。

/* signal_fpe_handler.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>

void handler_dividebyzero(int signum);

int main() {
   int result;
   int v1, v2;
   void (*sigHandlerReturn)(int);
   sigHandlerReturn = signal(SIGFPE, handler_dividebyzero);
   if (sigHandlerReturn == SIG_ERR) {
      perror("Signal Error: ");
      return 1;
   }
   v1 = 121;
   v2 = 0;
   result = v1/v2;
   printf("Result of Divide by Zero is %d\n", result);
   return 0;
}

void handler_dividebyzero(int signum) {
   if (signum == SIGFPE) {
      printf("Received SIGFPE, Divide by Zero Exception\n");
      exit (0);
   } 
   else
      printf("Received %d Signal\n", signum);
      return;
}

执行上面示例代码，得到以下结果 -

Received SIGFPE, Divide by Zero Exception

正如所讨论的那样，信号是由系统产生的(在执行某些操作(例如除以零等)时)，或者用户也可以以编程方式产生信号。 如果要以编程方式生成信号，请使用库函数raise()。

现在，另外一个程序来演示处理和忽略信号。

假设用raise()发出了一个信号，那么会发生什么？ 发出信号后，当前进程的执行停止。 那么停止的过程会发生什么？ 可以有两种情况 - 首先，在需要时继续执行。 其次，终止(用kill命令)这个进程。

要继续执行已停止的进程，请将SIGCONT发送到该特定进程。 也可以发出fg(前景)或bg(后台)命令来继续执行。 在这里，这些命令只会重新开始执行最后一个进程。 如果多个进程停止，则只有最后一个进程被恢复。 如果想恢复先前停止的过程，请使用fg/bg和作业编号恢复作业。

下面的程序用于使用raise()函数来提升信号SIGSTOP。 信号SIGSTOP也可以由用户按下CTRL + Z(Ctrl + Z)键生成。 发出此信号后，程序将停止执行。 发送信号(SIGCONT)继续执行。

在下面的例子中，使用命令fg重新开始停止的进程。

/* signal_raising.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>

int main() {
   printf("Testing SIGSTOP\n");
   raise(SIGSTOP);
   return 0;
}

执行上面示例代码，得到以下结果 -

Testing SIGSTOP
[1]+ Stopped ./a.out
./a.out

现在，增强以前的程序，通过从另一个终端发出SIGCONT来继续执行停止的进程。

/* signal_stop_continue.c */
#include<stdio.h>
#include<signal.h>
#include <sys/types.h>
#include <unistd.h>

void handler_sigtstp(int signum);

int main() {
   pid_t pid;
   printf("Testing SIGSTOP\n");
   pid = getpid();
   printf("Open Another Terminal and issue following command\n");
   printf("kill -SIGCONT %d or kill -CONT %d or kill -18 %d\n", pid, pid, pid);
   raise(SIGSTOP);
   printf("Received signal SIGCONT\n");
   return 0;
}

执行上面示例代码，得到以下结果 -

Testing SIGSTOP
Open Another Terminal and issue following command
kill -SIGCONT 30379 or kill -CONT 30379 or kill -18 30379
[1]+ Stopped ./a.out

Received signal SIGCONT
[1]+ Done ./a.out

在另一个终端执行 -

kill -SIGCONT 30379

到目前为止，我们已经看到了处理系统产生的信号的程序。 现在让我们看看通过程序产生的信号(使用raise()函数或者通过kill命令)。 该程序产生信号SIGTSTP(终端停止)，其默认动作是停止执行。 但是，由于现在正在处理信号，而不是默认的动作，它会来到定义的处理程序。 在这种情况下，只是打印消息并退出。

/* signal_raising_handling.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>

void handler_sigtstp(int signum);

int main() {
   void (*sigHandlerReturn)(int);
   sigHandlerReturn = signal(SIGTSTP, handler_sigtstp);
   if (sigHandlerReturn == SIG_ERR) {
      perror("Signal Error: ");
      return 1;
   }
   printf("Testing SIGTSTP\n");
   raise(SIGTSTP);
   return 0;
}

void handler_sigtstp(int signum) {
   if (signum == SIGTSTP) {
      printf("Received SIGTSTP\n");
      exit(0);
   }
   else
      printf("Received %d Signal\n", signum);
      return;
}

执行上面示例代码，得到以下结果 -

Testing SIGTSTP
Received SIGTSTP

已经看到了执行默认操作或处理信号的情况。 现在是时候忽略这个信号了。 在这个示例程序中，通过SIG_IGN注册信号SIGTSTP忽略，然后发送信号SIGTSTP(终端停止)。 当信号SIGTSTP正在被生成，将被忽略。参考以下代码 -

/* signal_raising_ignoring.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>

void handler_sigtstp(int signum);

int main() {
   void (*sigHandlerReturn)(int);
   sigHandlerReturn = signal(SIGTSTP, SIG_IGN);
   if (sigHandlerReturn == SIG_ERR) {
      perror("Signal Error: ");
      return 1;
   }
   printf("Testing SIGTSTP\n");
   raise(SIGTSTP);
   printf("Signal SIGTSTP is ignored\n");
   return 0;
}

执行上面示例代码，得到以下结果 -

Testing SIGTSTP
Signal SIGTSTP is ignored

到目前为止，我们已经观察到，一个信号处理程序用来处理一个信号。 那么一个信号可以处理多个信号吗？ 答案是肯定的 让我们通过一个程序来实现。

以下程序执行以下操作 -

第1步 - 注册一个处理程序(handleSignals)来捕获或处理信号SIGINT(CTRL + C)或SIGQUIT(CTRL + )

第2步 - 如果用户产生信号SIGQUIT(或者通过kill命令或者用CTRL + \键盘控制)，处理程序简单地将消息打印为返回。

第3步 - 如果用户第一次生成信号SIGINT(通过kill命令或者使用CTRL + C的键盘控制)，则修改信号从下次开始执行默认操作(使用SIG_DFL)。

第4步 - 如果用户第二次生成信号SIGINT，则执行默认操作，即程序终止。

/* Filename: sigHandler.c */
#include<stdio.h>
#include<unistd.h>
#include<signal.h>

void handleSignals(int signum);

int main(void) {
   void (*sigHandlerInterrupt)(int);
   void (*sigHandlerQuit)(int);
   void (*sigHandlerReturn)(int);
   sigHandlerInterrupt = sigHandlerQuit = handleSignals;
   sigHandlerReturn = signal(SIGINT, sigHandlerInterrupt);
   if (sigHandlerReturn == SIG_ERR) {
      perror("signal error: ");
      return 1;
   }
   sigHandlerReturn = signal(SIGQUIT, sigHandlerQuit);

   if (sigHandlerReturn == SIG_ERR) {
      perror("signal error: ");
      return 1;
   }
   while (1) {
      printf("\nTo terminate this program, perform the following: \n");
      printf("1. Open another terminal\n");
      printf("2. Issue command: kill %d or issue CTRL+C 2 times (second time it terminates)\n", getpid());
      sleep(10);
   }
   return 0;
}

void handleSignals(int signum) {
   switch(signum) {
      case SIGINT:
      printf("\nYou pressed CTRL+C \n");
      printf("Now reverting SIGINT signal to default action\n");
      signal(SIGINT, SIG_DFL);
      break;
      case SIGQUIT:
      printf("\nYou pressed CTRL+\\ \n");
      break;
      default:
      printf("\nReceived signal number %d\n", signum);
      break;
   }
   return;
}

编译和执行上面示例代码，得到以下结果 -

To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 74 or issue CTRL+C 2 times (second time it terminates)
^C
You pressed CTRL+C
Now reverting SIGINT signal to default action

To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 74 or issue CTRL+C 2 times (second time it terminates)
^\You pressed CTRL+\
To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 120
Terminated

在另一个终端中执行 -

kill 71

第二种方法 -

To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 71 or issue CTRL+C 2 times (second time it terminates)
^C
You pressed CTRL+C
Now reverting SIGINT signal to default action

To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 71 or issue CTRL+C 2 times (second time it terminates)
^C

我们知道要处理一个信号，有两个系统调用，即signal()或sigaction()。 直到现在我们已经看到了signal()系统调用，现在是时候进行sigaction()系统调用了。 让我们修改上面的程序来执行使用sigaction()，如下所示 -

/* Filename: sigHandlerSigAction.c */
#include<stdio.h>
#include<unistd.h>
#include<signal.h>

void handleSignals(int signum);

int main(void) {
   void (*sigHandlerReturn)(int);
   struct sigaction mysigaction;
   mysigaction.sa_handler = handleSignals;
   sigemptyset(&mysigaction.sa_mask);
   mysigaction.sa_flags = 0;
   sigaction(SIGINT, &mysigaction, NULL);

   if (mysigaction.sa_handler == SIG_ERR) {
      perror("signal error: ");
      return 1;
   }
   mysigaction.sa_handler = handleSignals;
   sigemptyset(&mysigaction.sa_mask);
   mysigaction.sa_flags = 0;
   sigaction(SIGQUIT, &mysigaction, NULL);

   if (mysigaction.sa_handler == SIG_ERR) {
      perror("signal error: ");
      return 1;
   }
   while (-1) {
      printf("\nTo terminate this program, perform either of the following: \n");
      printf("1. Open another terminal and issue command: kill %d\n", getpid());
      printf("2. Issue CTRL+C 2 times (second time it terminates)\n");
      sleep(10);
   }
   return 0;
}

void handleSignals(int signum) {
   switch(signum) {
      case SIGINT:
      printf("\nYou have entered CTRL+C \n");
      printf("Now reverting SIGINT signal to perform default action\n");
      signal(SIGINT, SIG_DFL);
      break;
      case SIGQUIT:
      printf("\nYou have entered CTRL+\\ \n");
      break;
      default:
      printf("\nReceived signal number %d\n", signum);
      break;
   }
   return;
}

让我们编译和执行上面的代码。 在执行过程中，按CTRL + C两次，其余的检查/方式(如上)来尝试执行这个程序。

执行上面示例代码，得到以下结果 -

To terminate this program, perform either of the following:
1. Open another terminal and issue command: kill 3199
2. Issue CTRL+C 2 times (second time it terminates)
^C
You have entered CTRL+C
Now reverting SIGINT signal to perform default action
To terminate this program, perform either of the following:
1. Open another terminal and issue command: kill 3199
2. Issue CTRL+C 2 times (second time it terminates)
^C