訊號(signal)是一種程序間通訊機制，它給應用程式提供一種非同步的軟體中斷，使應用程式有機會接受其他程式活終端傳送的命令(即訊號)。應用程式收到訊號後，有三種處理方式：忽略，預設，或捕捉。程序收到一個訊號後，會檢查對該訊號的處理機制。如果是SIG_IGN，就忽略該訊號；如果是SIG_DFT，則會採用系統預設的處理動作，通常是終止程序或忽略該訊號；如果給該訊號指定了一個處理函式(捕捉)，則會中斷當前程序正在執行的任務，轉而去執行該訊號的處理函式，返回後再繼續執行被中斷的任務。

SIGHUP     終止程序     終端線路結束通話
SIGINT     終止程序     中斷程序

SIGQUIT   建立CORE檔案終止程序，並且生成core檔案
SIGILL   建立CORE檔案       非法指令
SIGTRAP   建立CORE檔案       跟蹤自陷
SIGBUS   建立CORE檔案       匯流排錯誤
SIGSEGV   建立CORE檔案       段非法錯誤
SIGFPE   建立CORE檔案       浮點異常
SIGIOT   建立CORE檔案       執行I/O自陷
SIGKILL   終止程序     殺死程序
SIGPIPE   終止程序     向一個沒有讀程序的管道寫資料
SIGALARM   終止程序     計時器到時
SIGTERM   終止程序     軟體終止訊號
SIGSTOP   停止程序     非終端來的停止訊號
SIGTSTP   停止程序     終端來的停止訊號
SIGCONT   忽略訊號     繼續執行一個停止的程序
SIGURG   忽略訊號     I/O緊急訊號
SIGIO     忽略訊號     描述符上可以進行I/O
SIGCHLD   忽略訊號     當子程序停止或退出時通知父程序
SIGTTOU   停止程序     後臺程序寫終端
SIGTTIN   停止程序     後臺程序讀終端
SIGXGPU   終止程序     CPU時限超時
SIGXFSZ   終止程序     檔案長度過長
SIGWINCH   忽略訊號     視窗大小發生變化
SIGPROF   終止程序     統計分佈圖用計時器到時
SIGUSR1   終止程序     使用者定義訊號1
SIGUSR2   終止程序     使用者定義訊號2
SIGVTALRM 終止程序     虛擬計時器到時

1) SIGHUP 本訊號在使用者終端連線(正常或非正常)結束時發出, 通常是在終端的控 制程序結束時, 通知同一session內的各個作業, 這時它們與控制終端不再關聯. 
2) SIGINT 程式終止(interrupt)訊號, 在使用者鍵入INTR字元(通常是Ctrl-C)時發出 
3) SIGQUIT 和SIGINT類似, 但由QUIT字元(通常是Ctrl-)來控制. 程序在因收到SIGQUIT退出時會產生core檔案, 在這個意義上類似於一個程式錯誤信號. 
4) SIGILL 執行了非法指令. 通常是因為可執行檔案本身出現錯誤, 或者試圖執行資料段. 堆疊溢位時也有可能產生這個訊號. 
5) SIGTRAP 由斷點指令或其它trap指令產生. 由debugger使用. 
6) SIGABRT 程式自己發現錯誤並呼叫abort時產生. 
6) SIGIOT 在PDP-11上由iot指令產生, 在其它機器上和SIGABRT一樣. 
7) SIGBUS 非法地址, 包括記憶體地址對齊(alignment)出錯. eg: 訪問一個四個字長的整數, 但其地址不是4的倍數. 
8) SIGFPE 在發生致命的算術運算錯誤時發出. 不僅包括浮點運算錯誤, 還包括溢出及除數為0等其它所有的算術的錯誤. 
9) SIGKILL 用來立即結束程式的執行. 本訊號不能被阻塞, 處理和忽略. 
10) SIGUSR1 留給使用者使用 
11) SIGSEGV 試圖訪問未分配給自己的記憶體, 或試圖往沒有寫許可權的記憶體地址寫資料. 
12) SIGUSR2 留給使用者使用 
13) SIGPIPE Broken pipe 
14) SIGALRM 時鐘定時訊號, 計算的是實際的時間或時鐘時間. alarm函式使用該訊號. 
15) SIGTERM 程式結束(terminate)訊號, 與SIGKILL不同的是該訊號可以被阻塞和處理. 通常用來要求程式自己正常退出. shell命令kill預設產生這個訊號. 
17) SIGCHLD 子程序結束時, 父程序會收到這個訊號. 
18) SIGCONT 讓一個停止(stopped)的程序繼續執行. 本訊號不能被阻塞. 可以用一個handler來讓程式在由stopped狀態變為繼續執行時完成特定的工作. 例如, 重新顯示提示符 
19) SIGSTOP 停止(stopped)程序的執行. 注意它和terminate以及interrupt的區別: 該程序還未結束, 只是暫停執行. 本訊號不能被阻塞, 處理或忽略. 
20) SIGTSTP 停止程序的執行, 但該訊號可以被處理和忽略. 使用者鍵入SUSP字元時(通常是Ctrl-Z)發出這個訊號 
21) SIGTTIN 當後臺作業要從使用者終端讀資料時, 該作業中的所有程序會收到SIGTTIN訊號. 預設時這些程序會停止執行. 
22) SIGTTOU 類似於SIGTTIN, 但在寫終端(或修改終端模式)時收到. 
23) SIGURG 有"緊急"資料或out-of-band資料到達socket時產生. 
24) SIGXCPU 超過CPU時間資源限制. 這個限制可以由getrlimit/setrlimit來讀取/改變 
25) SIGXFSZ 超過檔案大小資源限制. 
26) SIGVTALRM 虛擬時鐘訊號. 類似於SIGALRM, 但是計算的是該程序佔用的CPU時間. 
27) SIGPROF 類似於SIGALRM/SIGVTALRM, 但包括該程序用的CPU時間以及系統呼叫的時間. 
28) SIGWINCH 視窗大小改變時發出. 
29) SIGIO 檔案描述符準備就緒, 可以開始進行輸入/輸出操作. 
30) SIGPWR Power failure 

有兩個訊號可以停止程序:SIGTERM和SIGKILL。 SIGTERM比較友好，程序能捕捉這個訊號，根據您的需要來關閉程式。在關閉程式之前，您可以結束開啟的記錄檔案和完成正在做的任務。在某些情況下，假如程序正在進行作業而且不能中斷，那麼程序可以忽略這個SIGTERM訊號。

對於SIGKILL訊號，程序是不能忽略的。這是一個 “我不管您在做什麼,立刻停止”的訊號。假如您傳送SIGKILL訊號給程序，Linux就將程序停止在那裡。 

下面就來說說與訊號有關的函式吧。

最簡單signal函式

typedef void (*sighandler_t) (int)

sighandler_t signal(int signum, sighandler_t handler);

返回原訊號處理函式，或SIG_ERR

signal()是最簡單的給程序安裝訊號處理器的函式，第一個引數指定訊號，第二個引數為該訊號指定一個處理函式。

如下是一個最簡單的處理訊號的程式，它捕捉SIGUSR1，忽略SIGUSR2，按系統預設處理SIGINT，SIGUSR1和SIGUSR2是Linux提供的使用者定義訊號，可用於任何應用程式。主程式什麼都不幹，只用pause()迴圈等待訊號。

 
例程1 最簡單的訊號處理

1.static void pr_mask(const char * string) {
2.    sigset_t procmask;
3.

4.    sigprocmask(SIG_SETMASK, NULL, &procmask);
5.

6.    printf("%s: ", string);
7.    if(sigismember(&procmask, SIGINT))
8.        printf("SIGINT ");
9.    if(sigismember(&procmask, SIGUSR1))
10.        printf("SIGUSR1 ");
11.    if(sigismember(&procmask, SIGUSR2))
12.        printf("SIGUSR2 ");
13.    if(sigismember(&procmask, SIGTERM))
14.        printf("SIGTERM ");
15.    if(sigismember(&procmask, SIGQUIT))
16.        printf("SIGQUIT ");
17.    printf("/n");
18.}
19.

20.static void sigusr(int signum)
21.{
22.    pr_mask(“int sigusr”);
23.

24.    if(signum == SIGUSR1)
25.        printf(“SIGUSR1 received/n”);
26.    else if(signum == SIGUSR2)
27.        printf(“SIGUSR2 received/n”);
28.    else29.        printf(“signal %d received/n”, signum);
30.}
31.

32.int main(void)
33.{
34.    if(signal(SIGUSR1, sig_usr) == SIG_ERR) {
35.        printf(“error catching SIGUSR1/n”);
36.        exit(1);
37.    }
38.

39.    if(signal(SIGUSR2, SIG_IGN) == SIG_ERR) {
40.        printf(“error ignoring SIGUSR2/n”);
41.        exit(1);
42.    }
43.

44.    if(signal(SIGINT, SIG_DFT) == SIG_ERR) {
45.        printf(“error setting SIGINT to default/n”);
46.        exit(1);
47.    }
48.

49.    while(1)
50.        pause();
51.

52.    exit(0);
53.}

後臺執行該程式，並用kill傳送訊號給它。

$./a.out &

[1] 3725

$kill -USR1 3725

in sigusr: SIGUSR1

SIGUSR1 received

$kill -USR2 3725

[1]+ User defined signal 2 ./a.out

我們可以看到，Linux系統對SIGUSR2的預設動作是終止程序。

中斷與自動重啟動

前面說過，訊號是一種軟體中斷機制，這就產生了一個問題：如果訊號到來時進城正在執行某個低速系統呼叫，系統應該怎麼處理？是暫時阻塞系統呼叫返回，在訊號處理程式完成後繼續沒完成的系統呼叫呢，還是讓系統調用出錯返回，同時把errno設定為EINTR，讓呼叫者去做進一步的出錯檢查呢？用事實說話，讓我們做一個試驗先吧。

下面的程式讀取標準輸入並把它輸出到標準輸出，在此期間，我們給程序傳送SIGUSR1訊號，以此來確定Linux在收到訊號後是如何對處理系統呼叫的。

例程2 訊號與自動重啟動的signal版本

1.int main(void)
2.{
3.    char buf[BUFSIZ];
4.    int n;
5.

6.    signal(SIGUSR1, sig_usr);
7.

8.    while(1) {
9.        if((n = read(STDIN_FILENO, buf, BUFSIZ)) == -1) {
10.            if(errno == EINTR)
11.                printf(“read is interrupted/n”);
12.        }
13.        else {
14.            write(STDOUT_FILENO, buf, n);
15.        }
16.    }
17.

18.    exit(0);
19.}

執行該程式，並從另一個終端給該程序傳送訊號SIGUSR1。

$./a.out

first line

first line

in sigusr: SIGUSR1

SIGUSR1 received

second line

second line

in sigusr: SIGUSR1

SIGUSR1 received

^C

可見對由signal()函式安裝的訊號處理程式，系統預設會自動重啟動被中斷的系統呼叫，而不是讓它出錯返回，所以應用程式不必針對慢速系統呼叫的errno，做EINTR檢查，這就是自動重啟動機制。

我們再來看另外一個例子，它使用另一個函式sigaction()來安裝訊號處理程式。sigaction()允許程序對訊號進行更多的控制：

例程3 訊號與自動重啟動的sigaction版本

1.int main(void)
2.{
3.    char buf[BUFSIZ];
4.    int n;
5.

6.    struct sigaction sa_usr;
7.    sa_usr.flags = 0; //SA_RESART

8.    sa_usr.sa_handler = sig_usr;
9.    sigaction(SIGUSR1, &sa_usr, NULL);
10.

11.    //signal(SIGUSR1, sig_usr);

12.

13.    while(1) {
14.        if((n = read(STDIN_FILENO, buf, BUFSIZ)) == -1) {
15.            if(errno == EINTR)
16.                printf(“read is interrupted/n”);
17.        }
18.        else {
19.            write(STDOUT_FILENO, buf, n);
20.      }
21.    }
22.

23.    exit(0);
24.}

此時再執行這個程式，並從另一終端給該程序傳送訊號SIGUSR1，我們會得到如下結果。

$./a.out

first line

first line

in sigusr: SIGUSR1

SIGUSR1 received

read is interrupted

second line

second line

in sigusr: SIGUSR1

SIGUSR1 received

read is interrupted

^C

由此我們可以得出，Linux對sigaction()的預設動作是不自動重啟動被中斷的系統呼叫，因此如果我們在使用sigaction()時需要自動重啟動被中斷的系統呼叫，就需要使用sigaction的SA_RESTART選項，見上例註釋，關於sigaction()，下文會有更多的描述。這和《UNIX環境高階程式設計》中對Linux訊號處理的描述是一致的。

可重入函式

如前所述，程序在收到訊號並對其進行處理時，會暫時中斷當前正在執行的指令序列，轉而去執行訊號處理程式。但是訊號的到來，往往是無法預測的，我們無法確定程序會在何時收到訊號。如果程序在收到訊號時正在執行malloc()呼叫，而此時捕捉到訊號，進城就會轉而去執行訊號處理程式，而訊號處理程式中又再次呼叫了malloc()函式，那結果將會怎樣呢？程序的棧空間很可能就會受到破壞，從而產生無法預料的結果。所以有些函式是不能在訊號處理程式中呼叫的，這些函式被稱為不可重入函式，而那些允許在訊號處理函式中呼叫的函式，則稱為可重入函式。下表列出了Linux系統中的可重入函式(摘自《UNIX環境高階程式設計》)，對不在該表中的函式，訊號處理函式中要慎用。

表1 可重入函式

 

傳送訊號的kill和raise函式

int kill(pid_t pid, int sig);

int raise(int sig);

kill()傳送訊號給指定程序，raise()傳送訊號給程序本身。對kill()的pid，有如下描述：

pid > 0 將訊號傳送給ID為pid的程序

pid == 0 將訊號傳送給與傳送程序屬於同意個程序組的所有程序

pid < 0 將訊號傳送給程序組ID等於pid絕對值的所有程序

pid == -1 將訊號傳送給該程序有許可權傳送的系統裡的所有程序

 
所有訊號的傳送都要先經過許可權檢查，如果程序沒有相應傳送的許可權，kill()會出錯返回，並把errno設為EPERM。但也有一個例外，對SIGCONT，程序可以將它傳送給當前會話的所有程序。

 
產生時鐘訊號SIGALRM的alarm函式

 
unsigned int alarm(unsigned int seconds);

alarm()函式可設定一個計時器，計時器超時就產生SIGALRM訊號。由於每個程序只能有一個SIGALRM處理程式，所以只能為一個程序設定一個計時器，所以alarm()和setitimer()會共享同一個SIGALRM訊號和該訊號的處理函式。也就是說，alarm()和 setitimer()彼此會互相影響。呼叫alarm()，會使先前設定的計時器失效，並把沒有超時的時間作為當前alarm的返回值。如先前設定的時鐘為100秒，當前呼叫alarm()時才經過30秒，剩餘的70秒就作為alarm()的返回值，並用alarm()中指定的秒數重新設定計時器。如果 seconds為0，則會取消先前設定的計時器，並將其餘留值作為alarm()的返回值。

等待訊號的pause函式

int pause(void);

pause()會使當前程序掛起，直到捕捉到一個訊號，對指定為忽略的訊號，pause()不會返回。只有執行了一個訊號處理函式，並從其返回，puase()才返回-1，並將errno設為EINTR。詳見前面的第一個例子。

 
訊號遮蔽字(process signal mask)

每個程序都會有一個訊號遮蔽字，它規定了當前程序要阻塞的訊號集。對於每種可能的訊號，訊號遮蔽字中都會有一位與之對應，如果該位被設定，該訊號當前就是阻塞的。程序可以通過sigprocmask()來獲得和修改當前程序的訊號遮蔽字。

訊號集(signal set)

訊號集是一種特殊的資料型別，由於無法確定訊號的多少，所以不能用簡單資料型別來包含所有可能的訊號，所以系統就定義了一個 sigset_t的資料型別專門用於訊號集。同時還定義了一族用於處理訊號集的函式。這樣使用者可以不必關心訊號集的實現，只要使用這組函式來處理訊號集就可以了。

訊號集函式

 
int sigemptyset(sigset_t * set);

int sigfillset(sigset_t * set);

int sigaddset(sigset_t * set, int signum);

int sigdelset(sigset_t * set, int signum);

int sigismember(sigset_t * set, int signum);

sigemptyset()和sigfillset()都用於初始化一個訊號集，前者用於清空訊號集中所有的訊號，後者則用於設定訊號集中所有的訊號；訊號集在使用前必須要經過初始化，初始化後，就可以用sigaddset()和sigdelset()往訊號集裡新增刪除訊號了。 sigismember()用於判斷指定訊號是否在訊號集中。

修改訊號遮蔽字的sigprocmask函式

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

sigpromask()根據how指定的方式，設定程序的當前訊號遮蔽字為set，並將舊的訊號遮蔽字儲存在oldset中返回。如果set為 NULL，則不修改當前訊號遮蔽字，而將其通過oldset返回；如果oldset為NULL，則不會返回舊的訊號遮蔽字。how支援三種方式，見下表。

 
表2 設定訊號遮蔽字的方式

 
 

 如果我們想阻塞SIGUSR1，有兩種方式。

1.// using SIG_BLOCK 2.sigset_t sigset;
3.sigemptyset(&sigset);
4.sigaddset(&sigset, SIGUSR1);
5.sigprocmask(SIG_BLOCK, &sigset, NULL);
6.

7.// or using SIG_SETMASK

8.sigset_t set, oldset;
9.// get current signal mask

10.sigprocmask(SIG_SETMASK, NULL, &set);
11.// add SIGUSR1 into the signal mask

12.sigaddset(&set, SIGUSR1);
13.sigprocmask(SIG_SETMASK, &set, &oldset);
14.
同樣，如果要解除阻塞SIGUSR1，也有兩種方式。

1.// using SIG_UNBLOCK

2.sigset_t sigset;
3.sigemptyset(&sigset);
4.sigaddset(&sigset, SIGUSR1);
5.sigprocmask(SIG_UNBLOCK, &sigset, NULL);
6.

7.// or using SIG_SETMASK

8.sigset_t set, oldset;
9.// get current signal mask

10.sigprocmask(SIG_SETMASK, NULL, &set);
11.// delete SIGUSR1 from the signal mask

12.sigdelset(&set, SIGUSR1);
13.sigprocmask(SIG_SETMASK, &set, &oldset);
訊號未決(pending)

訊號是由某些事件產生的，這些事件可能是硬體異常(如被零除)，軟體條件(如計時器超時)，終端訊號或呼叫kill()/raise()函式。訊號產生時，核心通常會在程序表中設定某種標誌，表示當前訊號的狀態。當核心對訊號採取某種動作時，我們說向程序遞送(deliver)了一個訊號，而在訊號產生和遞送之間的間隔內，該訊號的狀態是未決的(pending)。

獲得未決的訊號sigpending

int sigpending(sigset_t * set);

該函式在set中返回程序中當前尚未遞送的訊號集。

功能更全的sigaction函式

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

 
struct sigaction {

void (*sa_handler) (int);

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

sigset_t sa_mask;

相關推薦