一、訊號

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

非法的系統呼叫。

三、 訊號行為說明

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

四、訊號分類

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

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站也有同步視訊，