1. 信號的概念

信號是一個軟體中斷；

接下來我們舉個例子說明什么是軟體中斷：中斷就是打斷的意思，相當于我們過馬路看見的紅綠燈，當紅燈亮時，會給我們傳遞一個暫停的信號，傳遞給我們的紅燈信號就相當于一個軟體中斷，因為信號傳遞過來了，至于執行不執行還是看我們自己

2. 如何查看信號的資訊以及查看信號的默認處理動作

可以通過man 7 signal查看

2.1 作業系統對信號的處理動作

通過man手冊查看如下：

• Term ：終止行程
• Ign ：忽略信號
• Core ：終止行程并產生coredump檔案
• Stop ：停止行程
• Cont ：繼續運行
  
  如果某一個信號的處理動作是“Core”
  （1）默認是需要完成終止行程+產生coredump檔案
  （2）產生coredump檔案，依賴ulimit -a ==> "core file size"和磁盤大小，把core file size 設定成unlimited
  

2.2 信號具體的資訊

信號名稱+信號的值(整數)+action+描述

3. 信號的種類

目前Linux的信號數量為62個，分為如下兩種型別：

可通過 kill -l 命令羅列具體的信號值

3.1 非實時信號(非可靠信號)

1~31號信號

特點：有可能信號會丟失

3.2 實時信號(可靠信號)

34~64號信號

特點：信號不會丟失

4. 信號的產生

4.1 硬體產生

• ctrl+c ：SIGINT(2)
• ctrl+z ：SIGTSTP(20)
• ctrl+| ：SIGQUIT(3)

4.2 軟體產生

kill命令：

• kill [pid] ：可以終止一個行程
• kill -[num] [pid] ：給行程號為pid的行程發送一個信號值為num的信號
  eg：kill -9 [pid]

kill函式：

• int kill(pid_t,int sig);
  功能：給pid行程發送sig信號
  eg：kill(getpid(),9);

驗證如下，我們分別列印begin和end并在兩者中加上kill函式并給自己傳遞9號信號，此時我們應該看到的效果是列印完begin后行程接收到9號信號，然后被殺死，代碼如下：

  1 #include<stdio.h>  
  2 #include<signal.h>  
  3 #include<unistd.h>  
  4 
  5 int main()
  6 {
  7     printf("----------begin----------\n");
  8 
  9     kill(getpid(),9);
 10 
 11     printf("----------end------------\n");
 12     return 0;
 13 }    

讓程式跑起來，我們會看到begin被列印出來，然后列印一個killed，證明剛才的行程接收到了9好信號，并執行了

• int raise(int sig);
  功能 ：誰呼叫給誰發送sig信號

驗證如下，我們在剛才的kill函式前加上一個raise函式，并給它傳入2好信號，此時我們應該看到的效果是列印完begin后行程接收到2好信號，然后行程終止，不會在執行后面的，所以我們看不到killed：

  1 #include<stdio.h>
  2 #include<signal.h>
  3 #include<unistd.h>
  4 
  5 int main()
  6 {
  7     printf("----------begin----------\n");
  8 
  9     raise(2);
 10     kill(getpid(),9);
 11                                                                                                                                                     
 12     printf("----------end------------\n");                                                                                                     
 13     return 0;                                                                                                                                  
 14 }

驗證結果如下符合我們的預期

5. 信號的注冊

5.1 從PCB的角度理解信號的注冊

5.1.1 查看原始碼

查看原始碼，在/root/rpmbuild/BUILD/kernel-3.10.0-957.el7/linux-3.10.0-957.el7.x86_64/include/linux路徑下，vim 打開sched.h，我們可以看到一個"struct sigpending pending;"結構體，如下圖所示：


還在剛才哪個路徑下，vim打開signal.h，我們可以找到一個”struct sigpending“結構體如下圖所示：

• （1）在作業系統內核”struct task_struct“結構體內部有一個變數"struct sigpending pending;"
• （2）內核定義的結構體"struct sigpending"當中有兩個變數：一個是內核定義的雙向鏈表；一個是：”sigset_t signal“
• （3）內核定義的型別”sigset_t“為一個結構體，在結構體內部有一個變數，該變數為一個陣列(無符號長整型的陣列)

5.1.2 信號注冊的原理

• （1）信號注冊的本質就是在使用sig陣列，但并不是按照陣列型別的方式在使用，而是按照位圖(位元位)的方式在使用
  eg：某一個信號注冊，則將某一個信號對應的位元位置為1
• （2）sig陣列的位元位個數遠遠大于62(64為作業系統下一個long是64個位元位，一個sig陣列遠遠大于62(信號數量))，剩余的位元位為保留位
• （3）"struct sigpending"結構體當中有一個”sigset_t signal“當中有一個sig[xxx]陣列，一般在信號注冊的時候，稱這個sig陣列為操作sig位圖
• （4）內核當中對于注冊的時候，還有一個sigqueue佇列，信號的注冊邏輯為，將信號對應的sig位圖當中的位元位置為1，并且在sigqueue佇列當中添加一個sigqueue節點
  
  

5.2 信號的注冊

通過注冊同一個信號兩次，來區分可靠信號和非可靠信號的注冊邏輯

5.2.1 非可靠信號的注冊

如果同一個信號多次注冊，那么對于非可靠信號而言，只會添加一次sigqueue節點，即只注冊一次

第一次：
（1）更改信號對應的sig位圖當中的位元位(0—>1，位元位從0改為1)
（2）在sigqueue佇列當中添加sigqueue節點

第二次：
（1）更改信號對應的sig位圖當中的位元位(1—>1，位元位從1改為1)
（2）對于第二次信號，不添加sigqueue節點到sigqueue佇列當中

5.2.2 可靠信號的注冊

如果同一個可靠信號多次注冊，那么對于可靠信號而言，會添加多次sigqueue節點，即會注冊多次

第一次：
（1）更改信號對應的sig位圖當中的位元位(0—>1，位元位從0改為1)
（2）在sigqueue佇列當中添加sigqueue節點

第二次：
（1）更改sig位圖(1—>1，位元位從1改為1)
（2）在sigqueue佇列當中添加sigqueue節點

6. 信號的注銷

6.1 非可靠訊息：

（1）將信號對應的sig位圖當中的位元位置為0

（2）將對應的非可靠信號的sigqueue節點進行出隊操作

6.2 可靠信號：

（1）先將可靠信號對應的sigqueue進行出隊操作

（2）判斷sigqueue佇列當中是否有同類的可靠信號的sigqueue節點

• 有：不會將sig位圖當中對應的位元位置為0

• 沒有：將sig位圖當中對應的位元位置為0

7. 信號的處理方式

7.1 默認處理方式

默認處理方式：在作業系統內核當中已經定義好了

定義為一個宏：SIG_DFL

7.2 忽略處理方式

忽略處理方式：作業系統定義行程收到某一個信號之后，忽略掉(行程即使收到了某個信號，行程也不會做任何事情)

定義為一個宏：SIG_IGN

此時我們可以對僵尸行程的產生進行一個新的理解：子行程先于父行程退出，子行程會向父行程發送SIGCHLD(17)信號，父行程對SIGCHLD(17)信號是忽略處理的，所以父行程并不會做任何事情，導致子行程的資源沒有行程進行回收，從而導致子行程變成僵尸行程

7.3 自定義處理方式

（1）程式員可以定義某一個信號的處理方式
（2）函式==>sighandler_t signal(int signum, sighandler_t handler);

• signum：待更改的信號的值
• handler：函式指標，接收了一個函式的地址，這個函式沒有回傳值，有一個int型別的引數；typedef void (*sighandler_t)(int);
• 自定義signum這個信號的處理方式，定義為handler這個函式指標保存的函式地址對應的函式，也就是說，當行程收到signum這個信號時，就會呼叫handler當中保存的函式

如上理解轉換為圖解如下：

我們將2好信號改為列印一句話，驗證代碼如下：

  1 #include<stdio.h>  
  2 #include<signal.h>  
  3 #include<unistd.h>  
  4 
  5 void sigcallback(int signo)
  6 {
  7     printf("i am sigcallback,i am signo is %d\n",signo);
  8 }
  9 
 10 int main()
 11 {
 12     signal(2,sigcallback);
 13 
 14     while(1)
 15     {
 16         printf("i am main func\n");
 17         sleep(1);                                                                                                                                   
 18     }                                                                                                                                        
 19     return 0;                                                                                                                                
 20 }  

當程式運行起來，預期效果為當我們傳入2號信號(ctrl+c)不會終止行程，而是會列印一句話，測驗結果如下：

signal函式向內核注冊了一個信號處理函式，呼叫signal函式的時候，并沒有呼叫注冊函式(注冊函式在行程收到信號之后才呼叫)，將這種方式稱之為“回呼”，內核在呼叫

（3）int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);此函式和signal函式功能相同

• signum：待要自定義處理的信號
• act：要將信號處理方式改為act
• oldact：原來的處理方式
• struct aigaction結構體
  
  struct sigaction {
  
  //保存信號默認函式處理方式的函式指標
  void (*sa_handler)(int);
  
  //函式指標，但這個函式指標需要配合sa_flags一起使用，當sa_flags
  //當中的值為SA_SIGINFO的時候，信號處理是按照"sa_sigaction"當中
  //保存到函式地址來處理的
  void (*sa_sigaction)(int, siginfo_t *, void *);
  
  //當行程在處理某一個信號的時候，有可能還會收到其他的信號，此時，
  //其他的信號就暫時存在sa_mask當中
  sigset_t sa_mask;
  
  int sa_flags;
  
  void (*sa_restorer)(void);//保存欄位
  };
  

驗證代碼如下：

  1 #include<stdio.h>
  2 #include<signal.h>
  3 #include<unistd.h>
  4 
  5 void sigcallback(int signo)
  6 {
  7     printf("i am sigcallback,i am signo is %d\n",signo);
  8 }
  9 
 10 int main()
 11 {
 12     struct sigaction sa;
 13     sa.sa_handler = sigcallback;
 14     //int sigemptyset(sigset_t *set);
 15     //初始化
 16     sigemptyset(&sa.sa_mask);
 17     sa.sa_flags = 0;
 18     sigaction(2,&sa,NULL);                                                                                                                          
 19 
 20     while(1)
 21     {
 22         printf("i am main func\n");
 23         sleep(1);
 24     }
 25     return 0;
 26 }

驗證結果如下：

8. 從內核角度分析信號自定義處理方式

在/root/rpmbuild/BUILD/kernel-3.10.0-957.el7/linux-3.10.0-957.el7.x86_64/include/linux路徑下，vim打開sched.h，我們可以看到一個“struct sighand_struct *sighand;”，如下圖所示：

回傳上級目錄，grep查找"struct sighand_struct"，并打開查看"struct sighand_struct"，如下圖所示，我們可以看到這個結構體中有一個action陣列，陣列的每一個元素都是一個”struct k_sigaction“

cd…回傳上級目錄后，使用grep查找“struct k_sigaction {”，并打開，我們會在這個結構體中看到一個“struct sigaction sa;”，如下圖所示：

繼續查看“struct sigaction“這個結構體，此時我們可以看到此結構體和sigaction函式的引數 struct aigaction 結構體相似，此結構體中有個”__sighandler_t sa_handler;“

而上面的”__sighandler_t“實際是”typedef void (*sighandler_t)(int)“ 是typedef出來的

• signal函式的內部也是在呼叫sigaction函式
• signal函式修改的是__sighandler_t保存的地址
• sigaction函式修改的是struct sigaction 這個結構體

圖解如下：