[[410753]]

一、信號

1. 基本概念

信號是在軟件層次上對中斷機制的一種模擬，在原理上，一個進程收到一個信號與處理器收到一個中斷請求可以說是一樣的。信號是異步的，一個進程不必通過任何操作來等待信號的到達，事實上，進程也不知道信號到底什么時候到達。

例如鍵盤輸入中斷按鍵(^C)，它的發生在程序執行過程中是不可預測的。

信號是進程間通信機制中唯一的異步通信機制，可以看作是異步通知，通知接收信號的進程有哪些事情發生了。

硬件異常也能產生信號，例如被零除、無效內存引用(test里產生的就是這種錯誤)等。這些條件通常先由內核硬件檢測到，然后通知內核。內核將決定產生什么樣的信號。

同一個信號的額外發生通常不會被排隊。如果信號在被阻塞時發生了5次，當我們反阻塞這個信號時，這個信號的信號處理函數通常只被調用一次。

同一時刻只能處理一個信號，在信號處理函數發信號給自己時，該信號會被pending。

信號的數值越小，則優先級越高。當進程收到多個待處理信號時，總是先處理優先級別高的信號。

信號處理函數的棧可以使用被中斷的也可以使用獨立的，具體可以通過系統調用設置。

信號機制經過POSIX實時擴展后，功能更加強大，除了基本通知功能外，還可以傳遞附加信息。

2. 處理方式

忽略：接收到信號后不做任何反應。捕獲：用自定義的信號處理函數來執行特定的動作。默認：接收到信號后按系統默認的行為處理該信號。這是多數應用采取的處理方式。

二、Linux下的信號類型

使用kill -l就會顯示出linux支持的信號列表。

其中列表中，編號為1 ~ 31的信號為傳統UNIX支持的信號，是不可靠信號(非實時的)，編號為32 ~ 63的信號是后來擴充的，稱做可靠信號(實時信號)。不可靠信號和可靠信號的區別在于前者不支持排隊，可能會造成信號丟失，而后者不會。

下面我們對編號小于SIGRTMIN的信號進行討論(下面的編號 依次對應信號 的數值為1 - 31)。

1) SIGHUP

本信號在用戶終端連接(正常或非正常)結束時發出, 通常是在終端的控制進程結束時, 通知同一session內的各個作業, 這時它們與控制終端不再關聯。

登錄Linux時，系統會分配給登錄用戶一個終端(Session)。在這個終端運行的所有程序，包括前臺進程組和后臺進程組，一般都 屬于這個 Session。當用戶退出Linux登錄時，前臺進程組和后臺有對終端輸出的進程將會收到SIGHUP信號。這個信號的默認操作為終止進程，因此前臺進 程組和后臺有終端輸出的進程就會中止。不過可以捕獲這個信號，比如wget能捕獲SIGHUP信號，并忽略它，這樣就算退出了Linux登錄，wget也 能繼續下載。

此外，對于與終端脫離關系的守護進程，這個信號用于通知它重新讀取配置文件。

2) SIGINT

程序終止(interrupt)信號, 在用戶鍵入INTR字符(通常是Ctrl-C)時發出，用于通知前臺進程組終止進程。

3) SIGQUIT

和SIGINT類似, 但由QUIT字符(通常是Ctrl-)來控制. 進程在因收到SIGQUIT退出時會產生core文件, 在這個意義上類似于一個程序錯誤信號。

4) SIGILL

執行了非法指令. 通常是因為可執行文件本身出現錯誤, 或者試圖執行數據段. 堆棧溢出時也有可能產生這個信號。

5) SIGTRAP

由斷點指令或其它trap指令產生. 由debugger使用。

6) SIGABRT

調用abort函數生成的信號。

7) SIGBUS

非法地址, 包括內存地址對齊(alignment)出錯。比如訪問一個四個字長的整數, 但其地址不是4的倍數。它與SIGSEGV的區別在于后者是由于對合法存儲地址的非法訪問觸發的(如訪問不屬于自己存儲空間或只讀存儲空間)。

8) SIGFPE

在發生致命的算術運算錯誤時發出. 不僅包括浮點運算錯誤, 還包括溢出及除數為0等其它所有的算術的錯誤。

9) SIGKILL

用來立即結束程序的運行. 本信號不能被阻塞、處理和忽略。如果管理員發現某個進程終止不了，可嘗試發送這個信號。

10) SIGUSR1

留給用戶使用

11) SIGSEGV

試圖訪問未分配給自己的內存, 或試圖往沒有寫權限的內存地址寫數據.

信號 11，即表示程序中可能存在特定條件下的非法內存訪問。

12) SIGUSR2

留給用戶使用

13) SIGPIPE

管道破裂。這個信號通常在進程間通信產生，比如采用FIFO(管道)通信的兩個進程，讀管道沒打開或者意外終止就往管道寫，寫進程會收到SIGPIPE信號。此外用Socket通信的兩個進程，寫進程在寫Socket的時候，讀進程已經終止。

14) SIGALRM

時鐘定時信號, 計算的是實際的時間或時鐘時間. alarm函數使用該信號.

15) SIGTERM

程序結束(terminate)信號, 與SIGKILL不同的是該信號可以被阻塞和處理。通常用來要求程序自己正常退出，shell命令kill缺省產生這個信號。如果進程終止不了，我們才會嘗試SIGKILL。

17) SIGCHLD

子進程結束時, 父進程會收到這個信號。

如果父進程沒有處理這個信號，也沒有等待(wait)子進程，子進程雖然終止，但是還會在內核進程表中占有表項，這時的子進程稱為僵尸 進程。這種情 況我們應該避免(父進程或者忽略SIGCHILD信號，或者捕捉它，或者wait它派生的子進程，或者父進程先終止，這時子進程的終止自動由init進程 來接管)。

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

31) SIGSYS

非法的系統調用。

三、 信號行為說明

不通的信號在不同的標準下，功能有所差別，下面列出主要的信號的默認行為和說明：

名稱	數字	標準	默認行為	說明
SIGILL	4	ANSI	終止+coredump	執行了非法指令. 通常是因為可執行文件本身出現錯誤, 或者試圖執行數據段. 堆棧溢出時也有可能產生這個信號
SIGABRT	6	ANSI	終止+coredump	調用abort函數生成的信號
SIGBUS	7	4.2 BSD	終止+coredump	非法地址, 包括內存地址對齊(alignment)出錯。比如訪問一個四個字長的整數, 但其地址不是4的倍數。它與SIGSEGV的區別在于后者是由于對合法存儲地址的非法訪問觸發的(如訪問不屬于自己存儲空間或只讀存儲空間)
SIGFPE	8	ANSI	終止+coredump	在發生致命的算術運算錯誤時發出. 不僅包括浮點運算錯誤, 還包括溢出及除數為0等其它所有的算術的錯誤
SIGSEGV	11	ANSI	終止+coredump	試圖訪問未分配給自己的內存, 或試圖往沒有寫權限的內存地址寫數據。訪問空指針，野指針基本都產生這個信號，也是最常見的信號
SIGSTKFLT	16	N/A	終止	堆棧錯誤
SIGPIPE	13	POSIX	終止	管道破裂。這個信號通常在進程間通信產生，比如采用FIFO(管道)通信的兩個進程，讀管道沒打開或者意外終止就往管道寫，寫進程會收到SIGPIPE信號。此外用Socket通信的兩個進程，寫進程在寫Socket的時候，讀進程已經終止
SIGTRAP	5	POSIX	終止+coredump	由斷點指令或其它trap指令產生. 由debugger使用
SIGHUP	1	POSIX	終止	用戶終端連接(正常或非正常)結束時發出, 通常是在終端的控制進程結束時, 通知同一session內的各個作業, 這時它們與控制終端不再關聯
SIGINT	2	ANSI	終止	程序終止(interrupt)信號, 在用戶鍵入INTR字符(通常是Ctrl-C)時發出，用于通知前臺進程組終止進程
SIGQUIT	3	POSIX	終止+coredump	和SIGINT類似, 但由QUIT字符(通常是Ctrl-)來控制. 進程在因收到SIGQUIT退出時會產生core文件, 在這個意義上類似于一個程序錯誤信號
SIGKILL	9	POSIX	終止	用來立即結束程序的運行. 本信號不能被阻塞、捕獲和忽略。如果管理員發現某個進程終止不了，可嘗試發送這個信號
SIGCHLD	17	POSIX	忽略	子進程結束時, 父進程會收到這個信號。如果父進程沒有處理這個信號，也沒有等待(wait)子進程，子進程雖然終止，但是還會在內核進程表中占有表項，這時的子進程稱為僵尸進程。這種情 況我們應該避免(父進程或者忽略SIGCHILD信號，或者捕捉它，或者wait它派生的子進程，或者父進程先終止，這時子進程的終止自動由init進程來接管)
SIGCONT	18	POSIX	繼續/忽略	讓一個停止(stopped)的進程繼續執行. 本信號不能被阻塞 . 可以用一個handler來讓程序在由stopped狀態變為繼續執行時完成特定的工作. 例如, 重新顯示提示符..在進程掛起時是繼續，否則是忽略
SIGSTOP	19	POSIX	暫停	暫停進程的執行. 注意它和terminate以及interrupt的區別:該進程還未結束, 只是暫停執行. 本信號不能被阻塞、捕獲或忽略
SIGALRM	14	POSIX	終止	時鐘定時信號, 計算的是實際的時間或時鐘時間. alarm函數使用該信號

四、信號分類

在以上列出的信號中，程序不可捕獲、阻塞或忽略的信號有：

SIGKILL,SIGSTOP  

不能恢復至默認動作的信號有：

SIGILL,SIGTRAP  

默認會導致進程流產的信，有：

SIGABRT,SIGBUS,SIGFPE,SIGILL,SIGIOT,SIGQUIT,SIGSEGV,SIGTRAP,SIGXCPU,SIGXFSZ  

默認會導致進程退出的信號有：

SIGALRM,SIGHUP,SIGINT,SIGKILL,SIGPIPE,SIGPOLL,SIGPROF,SIGSYS,SIGTERM,SIGUSR1,SIGUSR2,SIGVTALRM  

默認會導致進程停止的信號有：

SIGSTOP,SIGTSTP,SIGTTIN,SIGTTOU  

默認進程忽略的信號有：

SIGCHLD,SIGPWR,SIGURG,SIGWINCH 

此外，SIGIO在SVR4是退出，在4.3BSD中是忽略;

SIGCONT在進程掛起時是繼續，否則是忽略，不能被阻塞

終止程序的時候在不得已的情況下不能用SIGKILL，因為SIGKILL不會對子進程進行處理，只是把對自己進行處理。

五、信號驅動IO-SIGIO-29

下面我們主要講SIGIO-29的使用。

參考上圖：

• 時刻1 通過sigaction系統調用建立信號SIGIO的信號處理函數，該函數壺立即返回，注意，對應的驅動必須支持方法.fastnc
• 時刻2 數據此時沒有準備好，應進程會繼續執行，而內核會繼續等待數據，也就是說等待數據階段應用進程是非阻塞的。
• 時刻3 內核準備好了數據，要向應用進程復制數據，通過函數kill_fasync()向應用程序遞交SIGIO信號，二應用程序的信號處理程序會被調用到，在該函數中我們可以通過read等系統調用從內核賦值程序到進程
• 時刻4 在賦值數據期間，進程阻塞
• 時刻5 數據復制完成，會返回成功的指示，應用程序可以繼續處理數據

信號驅動 I/O 的 CPU 利用率很高，因為在圖中，等待數據的那段時間2，應用程序可以繼續執行其他操作。

六、程序實現

1. 信號注冊函數signal()

#include <signal.h> 
typedef void (*sighandler_t)(int); 
sighandler_t signal(int signum, sighandler_t handler); 

功能：

給信號signum注冊處理函數，函數原型是void (*sighandler_t)(int) 
當收到信號signum后，就會調用注冊的函數 

參數:

int signum  信號值 
sighandler_t handler  信號處理函數 

2.內核函數

void kill_fasync(struct fasync_struct **fp, int sig, int band) 

功能：

發送信號sig給進程，通知進程是可讀還是可寫，由band給出

發送信號sig給進程，通知進程是可讀還是可寫，由band給出 
POLLIN    ：可讀 
POLLOUT：可寫 

通用字符設備的.fasync方法，一般都是固定的寫法，我們暫時可以不用關心他的原理，會用即可，具體寫法如下：

static ssize_t hello_write (struct file *filep, const char __user *buf, size_t size, loff_t *pos) 
{ 
 int error; 
………… 
 kill_fasync(&hello_fasync,SIGIO,POLLIN); 
 return size; 
} 
 
static struct file_operations hello_ops =  
{ 
………… 
 .fasync = hello_fasync_func, 
}; 

2. 源程序

驅動程序：hello.c

/*   
 *公眾號：一口Linux 
 *2021.6.21 
 *version: 1.0.0 
*/ 
#include <linux/init.h> 
#include <linux/module.h> 
#include <linux/kdev_t.h> 
#include <linux/fs.h> 
#include <linux/cdev.h> 
#include <linux/uaccess.h> 
#include <linux/poll.h>  
#include<asm/signal.h> 
 
static int major = 237; 
static int minor = 0; 
static dev_t devno; 
static struct cdev cdev; 
struct device *class_dev = NULL; 
struct class *cls; 
 
struct fasync_struct *hello_fasync; 
 
static int hello_open (struct inode *inode, struct file *filep) 
{ 
 printk("hello_open()\n"); 
 return 0; 
} 
static int hello_release (struct inode *inode, struct file *filep) 
{ 
 printk("hello_release()\n"); 
 
 return 0; 
} 
 
#define KMAX_LEN 32 
char kbuf[KMAX_LEN+1] = "kernel"; 
 
 
//read(fd,buff,40); 
 
static ssize_t hello_read (struct file *filep, char __user *buf, size_t size, loff_t *pos) 
{ 
 int error; 
 
  
 if(size > strlen(kbuf)) 
 { 
  size = strlen(kbuf); 
 } 
 
 if(copy_to_user(buf,kbuf, size)) 
 { 
  error = -EFAULT; 
  return error; 
 } 
 
 return size; 
} 
//write(fd,buff,40); 
static ssize_t hello_write (struct file *filep, const char __user *buf, size_t size, loff_t *pos) 
{ 
 int error; 
 
 if(size > KMAX_LEN) 
 { 
  size = KMAX_LEN; 
 } 
 memset(kbuf,0,sizeof(kbuf)); 
 if(copy_from_user(kbuf, buf, size)) 
 { 
  error = -EFAULT; 
  return error; 
 } 
 printk("%s\n",kbuf); 
 kill_fasync(&hello_fasync,SIGIO,POLLIN); 
 return size; 
} 
 
int hello_fasync_func(int fd,struct file* filep,int on) 
{ 
 printk("led_fasync \n"); 
 return fasync_helper(fd,filep,on,&hello_fasync); 
} 
 
static struct file_operations hello_ops =  
{ 
 .open = hello_open, 
 .release = hello_release, 
 .read = hello_read, 
 .write = hello_write, 
 .fasync = hello_fasync_func, 
}; 
static int hello_init(void) 
{ 
 int result; 
 int error; 
  
 printk("hello_init \n"); 
 result = register_chrdev( major, "hello", &hello_ops); 
 if(result < 0) 
 { 
  printk("register_chrdev fail \n"); 
  return result; 
 } 
 cls = class_create(THIS_MODULE, "hellocls"); 
 if (IS_ERR(cls)) { 
  printk(KERN_ERR "class_create() failed for cls\n"); 
  result = PTR_ERR(cls); 
  goto out_err_1; 
 } 
 devno = MKDEV(major, minor); 
  
 class_dev = device_create(cls, NULL, devno, NULL, "hellodev"); 
 if (IS_ERR(class_dev)) { 
  result = PTR_ERR(class_dev); 
  goto out_err_2; 
 } 
  
 return 0; 
 
out_err_2: 
 class_destroy(cls); 
out_err_1: 
 unregister_chrdev(major,"hello"); 
 return  result; 
} 
static void hello_exit(void) 
{ 
 printk("hello_exit \n"); 
 device_destroy(cls, devno); 
 class_destroy(cls); 
 unregister_chrdev(major,"hello"); 
 return; 
} 
module_init(hello_init); 
module_exit(hello_exit); 
MODULE_LICENSE("GPL"); 
//proc/devices 

write.c

/*   
 *一口Linux 
 *2021.6.21 
 *version: 1.0.0 
*/ 
 
#include <stdio.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
main() 
{ 
 int fd; 
 int len; 
 char buf[64]={0}; 
 char buf2[64+1]="peng"; 
  
  
 fd = open("/dev/hellodev",O_RDWR); 
 if(fd<0) 
 { 
  perror("open fail \n"); 
  return; 
 } 
 
  
 printf("before write\n"); 
 len = write(fd,buf2,strlen(buf2)); 
 printf("after write\n"); 
 
 printf("len = %d\n",len); 
  
   
 close(fd); 
} 

test.c

/*   
 *公眾號：一口Linux 
 *2021.6.21 
 *version: 1.0.0 
*/ 
#include <stdio.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include<signal.h> 
 
char buff[64] = {0}; 
int fd; 
 
void func(int signo) 
{ 
 printf("signo= %d\n",signo); 
 read(fd,buff,sizeof(buff)); 
 printf("buff=%s\n",buff); 
 return ; 
} 
 
main() 
{ 
 int flage; 
 
 fd = open("/dev/hellodev",O_RDWR); 
 if(fd<0) 
 { 
  perror("open fail \n"); 
  return; 
 } 
 fcntl(fd,F_SETOWN,getpid()); 
 flage=fcntl(fd,F_GETFL); 
 fcntl(fd,F_SETFL,flage|FASYNC); 
    signal(SIGIO,func); 
 while(1);  
 close(fd); 
} 

3. 執行結果

編譯

make 
gcc test.c -o run 
gcc write.c -o run 

執行:

insmod hello.ko 

先開啟一個終端 ，執行

./run 

再開啟一個終端 ，執行

./w 

執行結果如下：

 

可以看到，寫入數據后，信號處理程序被調用到，并且打印出信號的值29，同時從驅動力讀取出數據。

本文轉載自微信公眾號「一口Linux」，可以通過以下二維碼關注。轉載本文請聯系一口Linux公眾號。