Linux 内核学习笔记：进程通信之“信号”

除了前一博文 Linux 内核学习笔记：进程通信之“管道”介绍的管道，Linux 0.11 支持的进程通信方式还有信号。

按照《Linux 内核设计的艺术》，信号机制是 Linux 0.11 为进程提供的一套“局部的类中断机制”，即在进程执行的过程中，如果系统发现某个进程接收到了信号，就暂时打断进程的执行，转而去执行该进程的信号处理程序，处理完毕后，再从进程被打断处继续执行。

下边我们先来看一下信号相关的基础知识。

信号相关的基础知识

在进程描述符 task_struct 中，有 3 个字段是跟信号相关的：

// include/linux/sched.h -----------------------
struct task_struct {
	......
	long signal;	// 信号位图
	struct sigaction sigaction[32];	// 信号执行属性结构
	long blocked;	// 信号屏蔽码（对应信号位图）
	......
}

信号位图

Linux 0.11 用 long 类型的变量 signal 来表示信号位图，总共能表示 32 种。但 Linux 0.11 只用到了 22 种：

// include/signal.h ----------------------------
#define SIGHUP		 1
#define SIGINT		 2
#define SIGQUIT		 3
#define SIGILL		 4
#define SIGTRAP		 5
#define SIGABRT		 6
#define SIGIOT		 6
#define SIGUNUSED	 7
#define SIGFPE		 8
#define SIGKILL		 9
#define SIGUSR1		10
#define SIGSEGV		11
#define SIGUSR2		12
#define SIGPIPE		13
#define SIGALRM		14
#define SIGTERM		15
#define SIGSTKFLT	16
#define SIGCHLD		17
#define SIGCONT		18
#define SIGSTOP		19
#define SIGTSTP		20
#define SIGTTIN		21
#define SIGTTOU		22

信号号为 signo 的信号在 signal 中占第 signo-1 位（从 0 开始算起），如 SIGCHLD 就占 signal 中的第 17-1=16 位。所以，当要将某信号添加到信号位图时，只需要如此操作即可：

signal |= (1 << (signo - 1))

信号屏蔽码

信号屏蔽码 blocked 跟信号位图 signal 位位对应。信号屏蔽码中被置为 1 的位表示，在信号位图中占据同一位置的信号被屏蔽。但 SIGKILL 和 SIGSTOP 是不能屏蔽的。

跟信号屏蔽码相关的程序摘写如下：

// kernel/sched.c ------------------------------
#define _S(nr) (1<<((nr)-1))
#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))	// SIGKILL 和 SIGSTOP 不能屏蔽

void schedule(void)
{
	int i,next,c;
	struct task_struct ** p;

/* check alarm, wake up any interruptible tasks that have got a signal */

	for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
		if (*p) {
			if ((*p)->alarm && (*p)->alarm < jiffies) {
					(*p)->signal |= (1<<(SIGALRM-1));
					(*p)->alarm = 0;
				}
			// ~(_BLOCKABLE & (*p)->blocked)：忽略被屏蔽的信号，但 SIGKILL 和 SIGSTOP 不能屏蔽
			if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
			(*p)->state==TASK_INTERRUPTIBLE)
				(*p)->state=TASK_RUNNING;
		}
	......
}

// kernel/signal.c -----------------------------
int sys_sgetmask()	// get mask
{
	return current->blocked;
}

int sys_ssetmask(int newmask)	// set mask
{
	int old=current->blocked;

	current->blocked = newmask & ~(1<<(SIGKILL-1));	// SIGKILL 不能被屏蔽
	return old;
}

信号执行属性结构

信号执行属性结构 struct sigaction 定义如下：

// include/signal.h ----------------------------
struct sigaction {
	void (*sa_handler)(int);		// 信号处理函数句柄
	sigset_t sa_mask;		// 信号屏蔽码
	int sa_flags;			// 指定信号处理方式标志
	void (*sa_restorer)(void);	// 现场恢复函数句柄
};

其中，sa_flags 是以下这些值的组合（如 SA_ONESHOT | SA_NOMASK）：  
/* Ok, I haven't implemented sigactions, but trying to keep headers POSIX */
#define SA_NOCLDSTOP	1		// 当子进程处于停止状态，就不对 SIGCLD 处理
#define SA_NOMASK	0x40000000	// 不阻止在指定的信号处理函数中再收到该信号
#define SA_ONESHOT	0x80000000	// 信号处理函数一旦被调用过就恢复到默认信号处理函数

信号操作

信号操作的完整例子可参考《Linux 内核设计的艺术》第 8.2 节“信号机制”。不过下文提炼了该例的重要过程并对这些过程进行阐述。

信号处理函数绑定

信号处理函数绑定是由 signal 函数来实现的：

// include/signal.h ----------------------------
// _sig：信号
// *_func：信号处理函数指针（句柄）
void (*signal(int _sig, void (*_func)(int)))(int);

signal 函数经 int 0x80 软中断，映射到 sys_signal 函数：

// kernel/signal.c -----------------------------
// hander：信号处理函数地址
// restorer：现场恢复函数地址
int sys_signal(int signum, long handler, long restorer)
{
	struct sigaction tmp;

	if (signum<1 || signum>32 || signum==SIGKILL)
		return -1;
	tmp.sa_handler = (void (*)(int)) handler;
	tmp.sa_mask = 0;
	tmp.sa_flags = SA_ONESHOT | SA_NOMASK;
	tmp.sa_restorer = (void (*)(void)) restorer;
	handler = (long) current->sigaction[signum-1].sa_handler;
	current->sigaction[signum-1] = tmp;
	return handler;
}

函数执行效果如下图所示：
图片来源：《Linux 内核设计的艺术》

为了能连续地捕获一个指定的信号，signal 函数的通常使用方式如下：

void sig_handler(int sig)	// 信号处理函数
{
	signal(SIGINT, sig_handler);	// 为处理下一次信号发生而重新设置信号处理函数
	......
}

void mian()
{
	signal(SIGINT, sig_handler);	// 主程序中设置信号处理函数
	......
}

其实 signal 函数是一个不可靠的函数，因为当信号已经发生而且已经转到信号处理函数中执行，在重新再一次设置信号处理函数之前，有可能又有一个信号发生，不过此时系统已经把信号处理函数设置成默认值（一般是终止进程），因此有可能造成信号丢失。为了可靠起见，可以使用 sigaction 函数。

发送信号

发送信号的函数是 send_sig 和 tell_father：

// kernel/exit.c -------------------------------
static inline int send_sig(long sig,struct task_struct * p,int priv)
{
	if (!p || sig<1 || sig>32)
		return -EINVAL;
	if (priv || (current->euid==p->euid) || suser())
		p->signal |= (1<<(sig-1));
	else
		return -EPERM;
	return 0;
}

// 该函数专用于 SIGCHLD 信号
static void tell_father(int pid)
{
	int i;

	if (pid)
		for (i=0;i<NR_TASKS;i++) {
			if (!task[i])
				continue;
			if (task[i]->pid != pid)
				continue;
			task[i]->signal |= (1<<(SIGCHLD-1));
			return;
		}
/* if we don't find any fathers, we just release ourselves */
/* This is not really OK. Must change it to make father 1 */
	printk("BAD BAD - no father found\n\r");
	release(current);
}

信号检测

信号检测是在 schedule 函数：

// kernel/sched.c ------------------------------
void schedule(void)
{
	int i,next,c;
	struct task_struct ** p;

	for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
		if (*p) {
			......
			if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
			(*p)->state==TASK_INTERRUPTIBLE)
				(*p)->state=TASK_RUNNING;
		}
	......
}

信号处理

do_signal 函数是内核系统调用（int 0x80）中断处理程序中对信号的预处理程序。在进程每次调用系统调用时，若进程已经收到信号，则该函数就会把信号处理函数句柄插入到用户进程堆栈中。这样，在当前系统调用结束后就会立刻执行该信号处理函数，然后再执行用户的程序。如下图所示：
图片来源：《Linux 内核完全注释》

调用 do_signal 前

我们先来看下调用 do_signal 前的（用户进程内核栈）压栈情况：

// kernel/system_call.s ------------------------
signal	= 12		// signal 在 task_struct 偏移 12 个字节（前边是 long state, long counter, long priority）
sigaction = 16		# MUST be 16 (=len of sigaction)	// 同上
blocked = (33*16)	// 同上

# offsets within sigaction
sa_handler = 0
sa_mask = 4
sa_flags = 8
sa_restorer = 12

.align 2
_system_call:
	......
	push %ds	# 下面 6 个 push 都是 do_signal 函数的参数
	push %es
	push %fs
	pushl %edx
	pushl %ecx		# push %ebx,%ecx,%edx as parameters
	pushl %ebx		# to the system call
	movl $0x10,%edx		# set up ds,es to kernel space	# 下边两句其实非常重要，说明了要切换到内核空间
	mov %dx,%ds
	mov %dx,%es
	movl $0x17,%edx		# fs points to local data space
	mov %dx,%fs
	call _sys_call_table(,%eax,4)	# sys_call_table 定义在 include/linux/sys.h
					# 调用地址 = _sys_call_table + %eax * 4
					# 调用 call _sys_call_table(,%eax,4) 本身也会压栈保护现场。如 copy_process() 函数的第 6 个参数 `long none`。
					# 不过只要 call 返回（ret）了（如调用 sys_signal 返回后），这个压栈的值就被清掉，不再作为接下来调用的 do_signal 的参数
	pushl %eax	# 将 sys_signal 返回的值压栈
	movl _current,%eax
	cmpl $0,state(%eax)		# state
	jne reschedule
	cmpl $0,counter(%eax)		# counter
	je reschedule
ret_from_sys_call:
	movl _current,%eax		# task[0] cannot have signals
	cmpl _task,%eax
	je 3f
	cmpw $0x0f,CS(%esp)		# was old code segment supervisor ?
	jne 3f
	cmpw $0x17,OLDSS(%esp)		# was stack segment = 0x17 ?
	jne 3f
	movl signal(%eax),%ebx	# 取信号位图 -> ebx
	movl blocked(%eax),%ecx	# 取屏蔽信号码 -> ecx
	notl %ecx	# 每位取反
	andl %ebx,%ecx	# 获得许可的信号位图
	bsfl %ecx,%ecx	# 从低位（位 0）开始扫描信号位图，看是否有 1 的位，若有，则 ecx 保留该位的偏移值（即第几位，0~31）
	je 3f		# 否则，则调到标号为 3 处执行
	btrl %ecx,%ebx	# 把 ebx 中的第 ecx 位复位（ebx 含有原信号位图），表示该信号“已经”处理
	movl %ebx,signal(%eax)	# 重新保存信号位图到进程
	incl %ecx	# 将信号号调整为从 1 开始的数（1~32）
	pushl %ecx	# 将该信号号入栈，作为 do_signal 的第一个参数
	call _do_signal
	......

用图可以表示如下：
图片来源：《Linux 内核完全注释》

这些压栈的数据将作为 do_signal 函数的参数。

调用 do_signal

do_signal 函数虽然由内核执行，当该函数却有修改“进程用户栈”的行为。因为内核有能力访问到所有物理内存，所以修改“进程用户栈”不成问题。do_signal 函数定义如下：

// kernel/signal.c -----------------------------
void do_signal(long signr,long eax, long ebx, long ecx, long edx,
	long fs, long es, long ds,
	long eip, long cs, long eflags,
	unsigned long * esp, long ss)
{
	unsigned long sa_handler;
	long old_eip=eip;
	struct sigaction * sa = current->sigaction + signr - 1;
	int longs;
	unsigned long * tmp_esp;

	sa_handler = (unsigned long) sa->sa_handler;
	if (sa_handler==1)
		return;
	if (!sa_handler) {
		if (signr==SIGCHLD)
			return;
		else
			do_exit(1<<(signr-1));
	}
	if (sa->sa_flags & SA_ONESHOT)
		sa->sa_handler = NULL;
	*(&eip) = sa_handler;	// 调整内核栈中 eip 位置，使其指向信号处理函数
	longs = (sa->sa_flags & SA_NOMASK)?7:8;
	*(&esp) -= longs;	// 调整用户栈的 esp 指针，为接下来的数据准备空间
	verify_area(esp,longs*4);
	tmp_esp=esp;
	put_fs_long((long) sa->sa_restorer,tmp_esp++);
	put_fs_long(signr,tmp_esp++);
	if (!(sa->sa_flags & SA_NOMASK))
		put_fs_long(current->blocked,tmp_esp++);
	put_fs_long(eax,tmp_esp++);
	put_fs_long(ecx,tmp_esp++);
	put_fs_long(edx,tmp_esp++);
	put_fs_long(eflags,tmp_esp++);
	put_fs_long(old_eip,tmp_esp++);
	current->blocked |= sa->sa_mask;
}

上述代码可用图表示如下：
图片来源：《Linux 内核完全注释》

iret 之后，被修改后的 eip、cs、eflags、被修改后的 esp、ss 依次恢复给各寄存器。进程从 cs:eip，即信号处理函数开始执行。

调用 restorer

当信号处理函数执行完毕，ret 后就将用户栈顶的数弹出给 eip，开始从 sa_restorer 处执行。sa_restorer 绑定的是库（libc）函数 restorer 的地址。restorer 函数定义如下：

.globl ____sig_restore
.globl ____masksig_restore
# 若没有 blocked，则使用这个 restorer 函数
____sig_restore:
	addl $4,%esp	# 丢弃信号值 signr
	popl %eax		# 恢复系统调用返回值
	popl %ecx		# 恢复原用户程序寄存器值
	popl %edx
	popfl			# 恢复用户程序时的标志寄存器
	ret

# 若有 blocked，则使用这个 restorer 函数
____masksig_restore:
	addl $4,%esp		# 丢弃信号值
	call ____ssetmask	# 设置信号屏蔽码
	addl $4,%esp		# 丢弃 blocked 值
	popl %eax
	popl %ecx
	popl %edx
	popfl
	ret

restorer 函数执行完之后，ret 会导致现在栈顶的 old_eip 弹出给 eip，进程从系统调用前的位置开始执行。

注意：iret 和 ret 是不一样的：

• iret 是中断返回，而在发生中断时 CPU 会将 ss esp eflags cs eip 依次入栈（内核栈），所以中断返回后会将这些压栈的值恢复
• ret 是常规调用（如函数调用）返回，而且 ret 实现的是近转移，只需恢复 eip 的值（retf 实现的是远转移，会同时修改 cs 和 eip 的值）