Linux內核信號SIGIO使用實例講解

一、信號

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給出
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驅動系列文章合集》

完整代碼和執行環境，請關注，一口君的號，后台回復：ubuntu
B站也有同步視頻，