重启系统调用探究 （ 转）

 
     但是linux世界上还有另外一种东东，叫做信号，来处理突发事件。如果系统调用尤其是阻塞型的系统调用遇到信号，怎么办呢？是等系统调用game over以后再处理信号，还是中断系统调用，尽快将信号投递到进程呢？ 想想前面提到的例子，如果wait等的子进程5天后才能退出，父进程的信号投递将等的花儿都谢了。所以对于阻塞性的调用，必须阻止这种情况的发生。
 
     一般来讲，一个系统调用，要么成功，要么失败，但是由于为了及时处理信号，出现了第三种情况，系统调用被信号中断，为了标识这种情况，错误码errno 置为EINTR。我们看到了，这个世界并不完美，编程同样也不完美。这也就是前文引用的errno == EINTR时，重启wait的原因。
 
    我们可以看到这种方式并不优美，程序员需要自己判断errno，如果被信号终端，那么还需要自己来重启系统调用。这是System V UNITX的实现方式。
 
     BSD 内核想程序员之所想，急程序员之所急，采用了另外一种实现，就是如果中断系统调用，切换到用户态来执行信号处理程序，那么系统调用没有返回值，内核在信号 处理函数结束后，自动重启系统调用。这种方式很贴心阿，程序员再也不用自己判断errno，然后重启系统调用了。
 
     LINUX不愧是UNIX世界的杰出新秀，他通过SA_RESTART 就可以支持BSD方案。下面我通过一个例子来讲述这个重启问题。
      
     下面这个实例捕捉SIGALRM信号，捕捉到信号后，执行sig_alrm_func函数。我们可以看到因为errno ==EINTR这一段被注释掉，所以，没有重启系统调用wait，导致系统调用wait返回失败，并且父进程没有delay 50 second，从而，父进程先结束了，生成的子进程变成了孤儿。
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<unistd.h>
  4. #include<sys/wait.h>
  5. #include<errno.h>
  6. #include<string.h>
  8. pid_t r_wait(int *stat_loc)
  9. {
  10.     int ret;
  11.         while(((ret = wait(stat_loc)) == -1) )
  12.         {
  13.                 /*if(errno == EINTR)
  14.                 {
  15.                      fprintf(stderr,"may be interrupted by a signal,let wait again \n");
  16.                 }
  17.                 else*/
  18.                 {
  19.                         break;
  20.                 }
  21.         }
  23.         return ret;
  24. }
  26. void sig_alrm_func()
  27. {
  28.     printf("catch an alarm signal\n");
  29.     return;
  30. }
  32. int main(int argc,char** argv)
  33. {
  34.     pid_t childpid;
  35.         int i,n;
  36.         struct sigaction act;
  38.         if(argc != 2)
  39.         {
  40.          fprintf(stderr,"usage : test n \n",argv[0]);
  41.              return -1;
  42.         }
  44.         n = atoi(argv[1]);
  45.         
  46.         act.sa_handler = sig_alrm_func;
  47.         sigemptyset(&act.sa_mask);
  48.         act.sa_flags |= 0;//SA_RESTART;
  49.         sigaction(SIGALRM,&act,NULL);
  50.         for(i = 0;i<n;i++)
  51.         {
  52.          if((childpid = fork()) <= 0)
  53.                                 break;
  54.         }
  56.        if(childpid == 0 )
  57.         {
  58.                sleep(50);
  59.         }
  60.         while(r_wait(NULL) >0) ;
  61.         fprintf(stderr," i :%d process ID : %ld,\t parent ID :%ld \tchild ID : %ld\n",
  62.                                         i,(long)getpid(),(long)getppid(),(long)childpid);
  64.         return 0;
  65. }
  1. root@libin:~/program/C/UNP/research# ./test 6
  另外一个端口查看ps -ef ,并向父进程发送SIGALRM信号。
  2. root      8679  7694  0 15:04 pts/0    00:00:00 ./test 6
  3. root      8680  8679  0 15:04 pts/0    00:00:00 ./test 6
  4. root      8681  8679  0 15:04 pts/0    00:00:00 ./test 6
  5. root      8682  8679  0 15:04 pts/0    00:00:00 ./test 6
  6. root      8683  8679  0 15:04 pts/0    00:00:00 ./test 6
  7. root      8684  8679  0 15:04 pts/0    00:00:00 ./test 6
  8. root      8685  8679  0 15:04 pts/0    00:00:00 ./test 6
  10. root@libin:~# kill -SIGALRM 8679
  12. 发送信号SIGALRM后 执行端口显示
  13. catch an alarm signal
  14.  i :6  process ID : 8679, parent ID :7694 child ID : 8685
  15.  
  16. 过了若干秒后，子进程完成自己的生命周期，退出。脱出之前，我们看到，子进程的父进程已经不再是8679.因为8679已经退出了，他们的新父亲是1号进程。
  20. root@libin:~/program/C/UNP/research#  i :0  process ID : 8680, parent ID :1 child ID : 0
  21.  i :1  process ID : 8681, parent ID :1 child ID : 0
  22.  i :2  process ID : 8682, parent ID :1 child ID : 0
  23.  i :3  process ID : 8683, parent ID :1 child ID : 0
  24.  i :4  process ID : 8684, parent ID :1 child ID : 0
  25.  i :5  process ID : 8685, parent ID :1 child ID : 0
    通过前面的例子，我们看到了，如果我们收到信号，中断了系统调用，如果我们不重启系统调用，那么，程序不是按照我们预想的方式运行。
 
    OK，我们将r_wait函数中的注释去掉，我们判断错误码errno，如果errno == EINTR，那么我们重启wait函数，那么，我们可以看到如下情景：
 
  1. root@libin:~/program/C/UNP/research# ./test 6
在另外一个端口执行ps -ef并且给父进程发送SIGALRM信号
 
root      8733  7694  0 15:21 pts/0    00:00:00 ./test 6
root      8734  8733  0 15:21 pts/0    00:00:00 ./test 6
root      8735  8733  0 15:21 pts/0    00:00:00 ./test 6
root      8736  8733  0 15:21 pts/0    00:00:00 ./test 6
root      8737  8733  0 15:21 pts/0    00:00:00 ./test 6
root      8738  8733  0 15:21 pts/0    00:00:00 ./test 6
root      8739  8733  0 15:21 pts/0    00:00:00 ./test 6
 
root@libin:~# kill -SIGALRM 8733
 
在执行端口，我们看到，程序运行50s后，有如下打印：
  1. catch an alarm signal
  2. may be interrupted by a signal,let wait again
  3.  i :1 process ID : 8735,     parent ID :8733     child ID : 0
  4.  i :0 process ID : 8734,     parent ID :8733     child ID : 0
  5.  i :2 process ID : 8736,     parent ID :8733     child ID : 0
  6.  i :3 process ID : 8737,     parent ID :8733     child ID : 0
  7.  i :4 process ID : 8738,     parent ID :8733     child ID : 0
  8.  i :5 process ID : 8739,     parent ID :8733     child ID : 0
  9.  i :6 process ID : 8733,     parent ID :7694     child ID : 8739
    最后，我们试一下BSD方案，r_wait函数不判断errno，不重启wait，但是act.sa_flags = SA_RESTART.
 
  1. root@libin:~/program/C/UNP/research# ./test 6
  2. catch an alarm signal
  3. i :0 process ID : 8775, parent ID :8774 child ID : 0
  4. i :1 process ID : 8776, parent ID :8774 child ID : 0
  5. i :2 process ID : 8777, parent ID :8774 child ID : 0
  6. i :3 process ID : 8778, parent ID :8774 child ID : 0
  7. i :4 process ID : 8779, parent ID :8774 child ID : 0
  8. i :5 process ID : 8780, parent ID :8774 child ID : 0
  9. i :6 process ID : 8774, parent ID :7694 child ID : 8780
    看到了，情况和sa_flags = 0同时重启系统调用是一样的。
原文出处：http://blog.chinaunix.net/uid-24774106-id-3065234.html
posted @ 2013-07-31 09:03  Mr.Shadow  阅读(363)  评论(0)  编辑  收藏  举报