linux内核情景分析之信号实现

信号在进程间通信是异步的,每个进程的task_struct结构有一个sig指针,指向一个signal_struct结构
定义如下
  2. struct signal_struct {
  3. 	atomic_t		count;
  4. 	struct k_sigaction	action[_NSIG];//类似一个信号向量表,每个元素就是一个函数指针
  5. 	spinlock_t		siglock;
  6. };
  2. struct k_sigaction {
  3. 	struct sigaction sa;
  4. };
  2. struct sigaction {
  3. 	unsigned int	sa_flags;
  4. 	__sighandler_t	sa_handler;
  5. 	sigset_t	sa_mask;
  6. 	void		(*sa_restorer)(void);
  7. 	int		sa_resv[1];	/* reserved */
  8. };
由此可见,每个信号向量除了指向一个信号处理函数,他还可以是2个其他特殊的常数
  1. /* Fake signal functions */
  2. #define SIG_DFL	((__sighandler_t)0)	/* default signal handling */
  3. #define SIG_IGN	((__sighandler_t)1)	/* ignore signal */
  4. #define SIG_ERR	((__sighandler_t)-1)	/* error return from signal */
由于SIG_DFL得数值为0,当向量表为空白时,所有信号向量对被视为SIG_DFL
信号向量与中断向量不同的是:中断向量表在系统空间,每个中断向量所指向中断响应程序也在系统空间,但虽然信号向量表在系统空间,但这些向量指向的信号处理程序缺在用户空间.
对于信号的检测和响应总是发生在系统空间,发生情况:当前进程系统调用,中断,异常而进入系统调用,从系统调用返回到用户空间的前夕.第二,当前进程在内核中进入睡眠后刚被唤醒的时候,由于信号的存在(处于未决状态)提前返回到用户空间.
具体来分析下sigaction结构体
  1. struct sigaction {
  2. 	unsigned int	sa_flags;
  3. 	__sighandler_t	sa_handler;
  4. 	sigset_t	sa_mask;//屏蔽,一个64位的类型
  5. 	void		(*sa_restorer)(void);
  6. 	int		sa_resv[1];	/* reserved */
  7. };
这里_sa_handler与_sa_sigaction都是函数指针,数据类型__sighandler_t定义为void(*)(int)指针,可见二者只是调用时的参数表不同,ra_restorer弃用.但sa_mask与sa_flags两个字段扮演着重要的角色.
sa_mask是一个位图,每一位对应一种信号,如果位图某一位设置为1,就表示执行当前信号的处理程序期间,要将相应的信号暂时屏蔽,使得执行过程中不会嵌套响应那种信号,特不是不管图的相应位设置为1,当前信号总是屏蔽自己,使得对同一种信号不会嵌套发生,除非sa_flags设置为SA_NODEFER或者SA_NOMASK标志为1
task_struct的信号队列与信号位图合并到一起了
  1. struct sigqueue {
  2. 	struct sigqueue *next;
  3. 	siginfo_t info;//挂载信号相关信息
  4. };
  1. struct sigpending {
  2. 	struct sigqueue *head, **tail;//挂载队列
  3. 	sigset_t signal;//位图,信号要处理时,设置为1
  4. };

  1. struct task_struct {  
  2.     int sigpending;  //表示该进程是否有信号需要处理
  3.       
  4.     int exit_code, exit_signal;  
  5.         /* Protects signal and blocked */  
  6.     struct signal_struct *sig;  //指向具体的信号处理动作
  7.   
  8.     sigset_t blocked;  //阻塞
  9.     struct sigpending pending;//位图+信号队列  
  10.   
  11.       
  12. }
结构分析完了,接下来看看信号的安装
  2. int
  3. do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
  4. {
  5. 	struct k_sigaction *k;
  7. 	if (sig < 1 || sig > _NSIG ||
  8. 	    (act && (sig == SIGKILL || sig == SIGSTOP)))//不允许对此信号安装信号处理函数
  9. 		return -EINVAL;
  11. 	k = &current->sig->action[sig-1];//获取该信号的旧信号处理函数
  13. 	spin_lock(&current->sig->siglock);
  15. 	if (oact)
  16. 		*oact = *k;//获取老的信号具体操作
  18. 	if (act) {
  19. 		*k = *act;//获取新的信号处理操作,将阻塞位sigkill跟sigstop删除(不允许屏蔽)
  20. 		sigdelsetmask(&k->sa.sa_mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
  22. 		/*
  23. 		 * POSIX 3.3.1.3:
  24. 		 *  "Setting a signal action to SIG_IGN for a signal that is
  25. 		 *   pending shall cause the pending signal to be discarded,
  26. 		 *   whether or not it is blocked."
  27. 		 *
  28. 		 *  "Setting a signal action to SIG_DFL for a signal that is
  29. 		 *   pending and whose default action is to ignore the signal
  30. 		 *   (for example, SIGCHLD), shall cause the pending signal to
  31. 		 *   be discarded, whether or not it is blocked"
  32. 		 *
  33. 		 * Note the silly behaviour of SIGCHLD: SIG_IGN means that the
  34. 		 * signal isn't actually ignored, but does automatic child
  35. 		 * reaping, while SIG_DFL is explicitly said by POSIX to force
  36. 		 * the signal to be ignored.
  37. 		 */
  39. 		if (k->sa.sa_handler == SIG_IGN
  40. 		    || (k->sa.sa_handler == SIG_DFL
  41. 			&& (sig == SIGCONT ||
  42. 			    sig == SIGCHLD ||
  43. 			    sig == SIGWINCH))) {
  44. 			spin_lock_irq(&current->sigmask_lock);
  45. 			if (rm_sig_from_queue(sig, current))//如果设置的处理模式是sig_ign或者sig_del
  46. 			//而涉及的信号是上面3个,那就直接丢弃已到达信号
  47. 				recalc_sigpending(current);//是否有信号等待处理总标志位也需要再计算
  48. 			spin_unlock_irq(&current->sigmask_lock);
  49. 		}
  50. 	}
  52. 	spin_unlock(&current->sig->siglock);
  53. 	return 0;
  54. }

rm_sig_from_queue丢弃已到达信号实现
  2. /*
  3.  * Remove signal sig from t->pending.
  4.  * Returns 1 if sig was found.
  5.  *
  6.  * All callers must be holding t->sigmask_lock.
  7.  */
  8. static int rm_sig_from_queue(int sig, struct task_struct *t)
  9. {
  10. 	return rm_from_queue(sig, &t->pending);
  11. }
其主体实现是rm_from_queue
  2. static int rm_from_queue(int sig, struct sigpending *s)
  3. {
  4. 	struct sigqueue *q, **pp;
  6. 	if (!sigismember(&s->signal, sig))//表示该位是否已经置1,一般是已经,否则直接return
  7. 		return 0;
  9. 	sigdelset(&s->signal, sig);//清除该标志位
  11. 	pp = &s->head;
  13. 	while ((q = *pp) != NULL) {
  14. 		if (q->info.si_signo == sig) {//如果队列中的信号等于sig(针对新类型信号)
  15. 			if ((*pp = q->next) == NULL)
  16. 				s->tail = pp;
  17. 			kmem_cache_free(sigqueue_cachep,q);//删除
  18. 			atomic_dec(&nr_queued_signals);//-1
  19. 			continue;
  20. 		}
  21. 		pp = &q->next;
  22. 	}
  23. 	return 1;
  24. }
查看发送信号处理
  1. asmlinkage long
  2. sys_kill(int pid, int sig)
  3. {
  4. 	struct siginfo info;
  5.     //收集相关信息
  6. 	info.si_signo = sig;//信号类型
  7. 	info.si_errno = 0;
  8. 	info.si_code = SI_USER;//用户信号
  9. 	info.si_pid = current->pid;//进程号
  10. 	info.si_uid = current->uid;//uid
  12. 	return kill_something_info(sig, &info, pid);
  13. }

  3. /*
  4.  * kill_something_info() interprets pid in interesting ways just like kill(2).
  5.  *
  6.  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
  7.  * is probably wrong.  Should make it like BSD or SYSV.
  8.  */
  10. static int kill_something_info(int sig, struct siginfo *info, int pid)
  11. {
  12. 	if (!pid) {//pid==0发送给当前进程的所有进程
  13. 		return kill_pg_info(sig, info, current->pgrp);
  14. 	} else if (pid == -1) { //发送到除当前进程以外的进程
  15. 		int retval = 0, count = 0;
  16. 		struct task_struct * p;
  18. 		read_lock(&tasklist_lock);
  19. 		for_each_task(p) {
  20. 			if (p->pid > 1 && p != current) {
  21. 				int err = send_sig_info(sig, info, p);
  22. 				++count;
  23. 				if (err != -EPERM)
  24. 					retval = err;
  25. 			}
  26. 		}
  27. 		read_unlock(&tasklist_lock);
  28. 		return count ? retval : -ESRCH;
  29. 	} else if (pid < 0) {//小于值,则发送给-pid的进程组
  30. 		return kill_pg_info(sig, info, -pid);
  31. 	} else {
  32. 		return kill_proc_info(sig, info, pid);//发送给具体的进程
  33. 	}
  34. }

  2. inline int
  3. kill_proc_info(int sig, struct siginfo *info, pid_t pid)
  4. {
  5. 	int error;
  6. 	struct task_struct *p;
  8. 	read_lock(&tasklist_lock);
  9. 	p = find_task_by_pid(pid);//找到pid对应的task_struct结构
  10. 	error = -ESRCH;
  11. 	if (p)
  12. 		error = send_sig_info(sig, info, p);//发送信号
  13. 	read_unlock(&tasklist_lock);
  14. 	return error;
  15. }
最重要部分send_sig_info

  2. int          //信号     信号相关信息           接收信号进程的pcb
  3. send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
  4. {
  5. 	unsigned long flags;
  6. 	int ret;
  9. #if DEBUG_SIG
  10. printk("SIG queue (%s:%d): %d ", t->comm, t->pid, sig);
  11. #endif
  13. 	ret = -EINVAL;
  14. 	if (sig < 0 || sig > _NSIG)//不在信号范围出错
  15. 		goto out_nolock;
  16. 	/* The somewhat baroque permissions check... */
  17. 	ret = -EPERM;
  18. 	if (bad_signal(sig, info, t))//进行错误检查
  19. 		goto out_nolock;
  21. 	/* The null signal is a permissions and process existance probe.
  22. 	   No signal is actually delivered.  Same goes for zombies. */
  23. 	ret = 0;
  24. 	if (!sig || !t->sig)//如果信号为0或者,不存在对应操作
  25. 		goto out_nolock;
  27. 	spin_lock_irqsave(&t->sigmask_lock, flags);
  28. 	handle_stop_signal(sig, t);//收到某些特定的信号,不可屏蔽一些其他后续信号,这个负责处理
  30. 	/* Optimize away the signal, if it's a signal that can be
  31. 	   handled immediately (ie non-blocked and untraced) and
  32. 	   that is ignored (either explicitly or by default).  */
  34. 	if (ignored_signal(sig, t))//如果响应是忽略,而且不用跟踪,没有屏蔽,那就不用投递信号
  35. 		goto out;
  37. 	/* Support queueing exactly one non-rt signal, so that we
  38. 	   can get more detailed information about the cause of
  39. 	   the signal. */
  40. 	if (sig < SIGRTMIN && sigismember(&t->pending.signal, sig))
  41. 		goto out;//老编制的信号,投递,就是把接收信号位图设置为1,不用将信号挂到队列
  43. 	ret = deliver_signal(sig, info, t);
  44. out:
  45. 	spin_unlock_irqrestore(&t->sigmask_lock, flags);
  46. 	if ((t->state & TASK_INTERRUPTIBLE) && signal_pending(t))//如果接收的进程处于这个状态,
  47. 	//而且有信号要处理,则唤醒进程
  48. 		wake_up_process(t);
  49. out_nolock:
  50. #if DEBUG_SIG
  51. printk(" %d -> %d\n", signal_pending(t), ret);
  52. #endif
  54. 	return ret;
  55. }

  2. static int deliver_signal(int sig, struct siginfo *info, struct task_struct *t)
  3. {
  4. 	int retval = send_signal(sig, info, &t->pending);
  6. 	if (!retval && !sigismember(&t->blocked, sig))
  7. 		signal_wake_up(t);
  9. 	return retval;
  10. }


  2. static int send_signal(int sig, struct siginfo *info, struct sigpending *signals)
  3. {
  4. 	struct sigqueue * q = NULL;//创建一个相关嘟列
  6. 	/* Real-time signals must be queued if sent by sigqueue, or
  7. 	   some other real-time mechanism.  It is implementation
  8. 	   defined whether kill() does so.  We attempt to do so, on
  9. 	   the principle of least surprise, but since kill is not
  10. 	   allowed to fail with EAGAIN when low on memory we just
  11. 	   make sure at least one signal gets delivered and don't
  12. 	   pass on the info struct.  */
  14. 	if (atomic_read(&nr_queued_signals) < max_queued_signals) {
  15. 		q = kmem_cache_alloc(sigqueue_cachep, GFP_ATOMIC);
  16. 	}
  18. 	if (q) {
  19. 		atomic_inc(&nr_queued_signals);
  20. 		q->next = NULL;//新创建的,设置为null
  21. 		*signals->tail = q;//指向尾部
  22. 		signals->tail = &q->next;//
  23. 		switch ((unsigned long) info) {
  24. 			case 0:
  25. 				q->info.si_signo = sig;
  26. 				q->info.si_errno = 0;
  27. 				q->info.si_code = SI_USER;
  28. 				q->info.si_pid = current->pid;
  29. 				q->info.si_uid = current->uid;
  30. 				break;
  31. 			case 1:
  32. 				q->info.si_signo = sig;
  33. 				q->info.si_errno = 0;
  34. 				q->info.si_code = SI_KERNEL;
  35. 				q->info.si_pid = 0;
  36. 				q->info.si_uid = 0;
  37. 				break;
  38. 			default:
  39. 				copy_siginfo(&q->info, info);//拷贝相关信息,到队列
  40. 				break;
  41. 		}
  42. 	} else if (sig >= SIGRTMIN && info && (unsigned long)info != 1
  43. 		   && info->si_code != SI_USER) {
  44. 		/*
  45. 		 * Queue overflow, abort.  We may abort if the signal was rt
  46. 		 * and sent by user using something other than kill().
  47. 		 */
  48. 		return -EAGAIN;
  49. 	}
  51. 	sigaddset(&signals->signal, sig);//将接收信号,相应位图设置为1
  52. 	return 0;
  53. }

  2. /*
  3.  * Note that 'init' is a special process: it doesn't get signals it doesn't
  4.  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  5.  * mistake.
  6.  */
  7. int do_signal(struct pt_regs *regs, sigset_t *oldset)
  8. {
  9. 	siginfo_t info;
  10. 	struct k_sigaction *ka;
  12. 	/*
  13. 	 * We want the common case to go fast, which
  14. 	 * is why we may in certain cases get here from
  15. 	 * kernel mode. Just return without doing anything
  16. 	 * if so.
  17. 	 */
  18. 	if ((regs->xcs & 3) != 3)
  19. 		return 1;
  21. 	if (!oldset)//如果为0
  22. 		oldset = &current->blocked;//获取其屏蔽信号
  24. 	for (;;) {
  25. 		unsigned long signr;
  27. 		spin_lock_irq(&current->sigmask_lock);
  28. 		signr = dequeue_signal(&current->blocked, &info);//取出一个没屏蔽的信号
  29. 		spin_unlock_irq(&current->sigmask_lock);
  31. 		if (!signr)//如果为0则跳出(因为表示当前没有这样的信号了)
  32. 			break;
  33.         //如果当前
  34. 		if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
  35. 			/* Let the debugger run.  */
  36. 			current->exit_code = signr;
  37. 			current->state = TASK_STOPPED;
  38. 			notify_parent(current, SIGCHLD);
  39. 			schedule();
  41. 			/* We're back.  Did the debugger cancel the sig?  */
  42. 			if (!(signr = current->exit_code))
  43. 				continue;
  44. 			current->exit_code = 0;
  46. 			/* The debugger continued.  Ignore SIGSTOP.  */
  47. 			if (signr == SIGSTOP)
  48. 				continue;
  50. 			/* Update the siginfo structure.  Is this good?  */
  51. 			if (signr != info.si_signo) {
  52. 				info.si_signo = signr;
  53. 				info.si_errno = 0;
  54. 				info.si_code = SI_USER;
  55. 				info.si_pid = current->p_pptr->pid;
  56. 				info.si_uid = current->p_pptr->uid;
  57. 			}
  59. 			/* If the (new) signal is now blocked, requeue it.  */
  60. 			if (sigismember(&current->blocked, signr)) {
  61. 				send_sig_info(signr, &info, current);
  62. 				continue;
  63. 			}
  64. 		}
  66. 		ka = &current->sig->action[signr-1];//获取信号向量
  67. 		if (ka->sa.sa_handler == SIG_IGN) {//如果对应的处理是SIG_IGN
  68. 			if (signr != SIGCHLD)//忽略则继续取没屏蔽信号,处理
  69. 				continue;
  70. 			//是儿子信号则等待所有子进程退出
  71. 			/* Check for SIGCHLD: it's special.  */
  72. 			while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
  73. 				/* nothing */;
  74. 			continue;
  75. 		}
  76.         //信号向量设置为SIG_DFL
  77. 		if (ka->sa.sa_handler == SIG_DFL) {
  78. 			int exit_code = signr;
  80. 			/* Init gets no signals it doesn't want.  */
  81. 			if (current->pid == 1)//不可以对init进程发送相关信号
  82. 				continue;
  84. 			switch (signr) {
  85. 			case SIGCONT: case SIGCHLD: case SIGWINCH:
  86. 				continue;//如果是SIGCONT之类,continue继续处理信号
  88. 			case SIGTSTP: case SIGTTIN: case SIGTTOU:
  89. 				if (is_orphaned_pgrp(current->pgrp))
  90. 					continue;
  91. 				/* FALLTHRU */
  93. 			case SIGSTOP://如果是sigstop信号
  94. 				current->state = TASK_STOPPED;//设置标志位
  95. 				current->exit_code = signr;
  96. 				if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
  97. 					notify_parent(current, SIGCHLD);
  98. 				schedule();
  99. 				continue;
  101. 			case SIGQUIT: case SIGILL: case SIGTRAP:
  102. 			case SIGABRT: case SIGFPE: case SIGSEGV:
  103. 			case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
  104. 				if (do_coredump(signr, regs))//这类信号默认处理
  105. 					exit_code |= 0x80;
  106. 				/* FALLTHRU */
  108. 			default://多数信号的默认处理
  109. 				sigaddset(&current->pending.signal, signr);//猜想设置此位表示默认处理,留给父进程查看信息
  110. 				recalc_sigpending(current);//检查进程是否有非阻塞的挂起信号
  111. 				current->flags |= PF_SIGNALED;
  112. 				do_exit(exit_code);//结束接收信号的进程
  113. 				/* NOTREACHED */
  114. 			}
  115. 		}
  117. 		/* Reenable any watchpoints before delivering the
  118. 		 * signal to user space. The processor register will
  119. 		 * have been cleared if the watchpoint triggered
  120. 		 * inside the kernel.
  121. 		 */
  122. 		__asm__("movl %0,%%db7"	: : "r" (current->thread.debugreg[7]));
  124. 		/* Whee!  Actually deliver the signal.  */
  125. 		handle_signal(signr, ka, &info, oldset, regs);
  126. 		return 1;
  127. 	}
  129. 	/* Did we come from a system call? */
  130. 	if (regs->orig_eax >= 0) {
  131. 		/* Restart the system call - no handlers present */
  132. 		if (regs->eax == -ERESTARTNOHAND ||
  133. 		    regs->eax == -ERESTARTSYS ||
  134. 		    regs->eax == -ERESTARTNOINTR) {
  135. 			regs->eax = regs->orig_eax;
  136. 			regs->eip -= 2;
  137. 		}
  138. 	}
  139. 	return 0;
  140. }


信号安装过程
获取旧的信号处理方法
同时安装新的信号处理方法,将信号处理函数掩码的阻塞位sigkill跟sigstop删除,返回旧信号处理方法

信号发送过程
siginfo收集发送信号当前信息(进程号,uid号,信号的对应数值)
如果响应是忽略,而且不用跟踪,没有屏蔽,那就不用投递信号
老编制的信号,投递,就是把接收信号位图设置为1,如果是第一次则挂载到队列,不是第一次则不用将信号挂到队列
接着创建一个队列结构,拷贝siginfo信号,同时将sigpending的signal位图设置为1,完成传递

处理过程(for循环,不断的获取已挂载但没阻塞的信号,直到没有为止)
获取信号向量,如果对应位是SIG_IGN,那就直接continue,是儿子信号则调用wait等待所有子进程退出
默认处理,一般直接退出
否则将调用用户自定义的函数


来自为知笔记(Wiz)


posted on 2016-10-27 10:50  笨拙的菜鸟  阅读(1082)  评论(0)  编辑  收藏  举报

导航