信号在进程间通信是异步的,每个进程的task_struct结构有一个sig指针,指向一个signal_struct结构

定义如下
    2. 

  2. struct signal_struct {
    3. 

  3. 	atomic_t		count;
    4. 

  4. 	struct k_sigaction	action[_NSIG];//类似一个信号向量表,每个元素就是一个函数指针
    5. 

  5. 	spinlock_t		siglock;
    6. 

  6. };



    2. 

  2. struct k_sigaction {
    3. 

  3. 	struct sigaction sa;
    4. 

  4. };


    2. 

  2. struct sigaction {
    3. 

  3. 	unsigned int	sa_flags;
    4. 

  4. 	__sighandler_t	sa_handler;
    5. 

  5. 	sigset_t	sa_mask;
    6. 

  6. 	void		(*sa_restorer)(void);
    7. 

  7. 	int		sa_resv[1];	/* reserved */
    8. 

  8. };
由此可见,每个信号向量除了指向一个信号处理函数,他还可以是2个其他特殊的常数
  1. /* Fake signal functions */
    2. 

  2. #define SIG_DFL	((__sighandler_t)0)	/* default signal handling */
    3. 

  3. #define SIG_IGN	((__sighandler_t)1)	/* ignore signal */
    4. 

  4. #define SIG_ERR	((__sighandler_t)-1)	/* error return from signal */
由于SIG_DFL得数值为0,当向量表为空白时,所有信号向量对被视为SIG_DFL
信号向量与中断向量不同的是:中断向量表在系统空间,每个中断向量所指向中断响应程序也在系统空间,但虽然信号向量表在系统空间,但这些向量指向的信号处理程序缺在用户空间.
对于信号的检测和响应总是发生在系统空间,发生情况:当前进程系统调用,中断,异常而进入系统调用,从系统调用返回到用户空间的前夕.第二,当前进程在内核中进入睡眠后刚被唤醒的时候,由于信号的存在(处于未决状态)提前返回到用户空间.
具体来分析下sigaction结构体
  1. struct sigaction {
    2. 

  2. 	unsigned int	sa_flags;
    3. 

  3. 	__sighandler_t	sa_handler;
    4. 

  4. 	sigset_t	sa_mask;//屏蔽,一个64位的类型
    5. 

  5. 	void		(*sa_restorer)(void);
    6. 

  6. 	int		sa_resv[1];	/* reserved */
    7. 

  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. 

  2. 	struct sigqueue *next;
    3. 

  3. 	siginfo_t info;//挂载信号相关信息
    4. 

  4. };


  1. struct sigpending {
    2. 

  2. 	struct sigqueue *head, **tail;//挂载队列
    3. 

  3. 	sigset_t signal;//位图,信号要处理时,设置为1
    4. 

  4. };



  1. struct task_struct {  
    2. 

  2.     int sigpending;  //表示该进程是否有信号需要处理
    3. 

  3.       
    4. 

  4.     int exit_code, exit_signal;  
    5. 

  5.         /* Protects signal and blocked */  
    6. 

  6.     struct signal_struct *sig;  //指向具体的信号处理动作
    7. 

  7.   
    8. 

  8.     sigset_t blocked;  //阻塞
    9. 

  9.     struct sigpending pending;//位图+信号队列  
    10. 

  10.   
    11. 

  11.       
    12. 

  12. }
结构分析完了,接下来看看信号的安装
    2. 

  2. int
    3. 

  3. do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
    4. 

  4. {
    5. 

  5. 	struct k_sigaction *k;
    6. 

    7. 

  7. 	if (sig < 1 || sig > _NSIG ||
    8. 

  8. 	    (act && (sig == SIGKILL || sig == SIGSTOP)))//不允许对此信号安装信号处理函数
    9. 

  9. 		return -EINVAL;
    10. 

    11. 

  11. 	k = &current->sig->action[sig-1];//获取该信号的旧信号处理函数
    12. 

    13. 

  13. 	spin_lock(&current->sig->siglock);
    14. 

    15. 

  15. 	if (oact)
    16. 

  16. 		*oact = *k;//获取老的信号具体操作
    17. 

    18. 

  18. 	if (act) {
    19. 

  19. 		*k = *act;//获取新的信号处理操作,将阻塞位sigkill跟sigstop删除(不允许屏蔽)
    20. 

  20. 		sigdelsetmask(&k->sa.sa_mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
    21. 

    22. 

  22. 		/*
    23. 

  23. 		 * POSIX 3.3.1.3:
    24. 

  24. 		 *  "Setting a signal action to SIG_IGN for a signal that is
    25. 

  25. 		 *   pending shall cause the pending signal to be discarded,
    26. 

  26. 		 *   whether or not it is blocked."
    27. 

  27. 		 *
    28. 

  28. 		 *  "Setting a signal action to SIG_DFL for a signal that is
    29. 

  29. 		 *   pending and whose default action is to ignore the signal
    30. 

  30. 		 *   (for example, SIGCHLD), shall cause the pending signal to
    31. 

  31. 		 *   be discarded, whether or not it is blocked"
    32. 

  32. 		 *
    33. 

  33. 		 * Note the silly behaviour of SIGCHLD: SIG_IGN means that the
    34. 

  34. 		 * signal isn't actually ignored, but does automatic child
    35. 

  35. 		 * reaping, while SIG_DFL is explicitly said by POSIX to force
    36. 

  36. 		 * the signal to be ignored.
    37. 

  37. 		 */
    38. 

    39. 

  39. 		if (k->sa.sa_handler == SIG_IGN
    40. 

  40. 		    || (k->sa.sa_handler == SIG_DFL
    41. 

  41. 			&& (sig == SIGCONT ||
    42. 

  42. 			    sig == SIGCHLD ||
    43. 

  43. 			    sig == SIGWINCH))) {
    44. 

  44. 			spin_lock_irq(&current->sigmask_lock);
    45. 

  45. 			if (rm_sig_from_queue(sig, current))//如果设置的处理模式是sig_ign或者sig_del
    46. 

  46. 			//而涉及的信号是上面3个,那就直接丢弃已到达信号
    47. 

  47. 				recalc_sigpending(current);//是否有信号等待处理总标志位也需要再计算
    48. 

  48. 			spin_unlock_irq(&current->sigmask_lock);
    49. 

  49. 		}
    50. 

  50. 	}
    51. 

    52. 

  52. 	spin_unlock(&current->sig->siglock);
    53. 

  53. 	return 0;
    54. 

  54. }

rm_sig_from_queue丢弃已到达信号实现
    2. 

  2. /*
    3. 

  3.  * Remove signal sig from t->pending.
    4. 

  4.  * Returns 1 if sig was found.
    5. 

  5.  *
    6. 

  6.  * All callers must be holding t->sigmask_lock.
    7. 

  7.  */
    8. 

  8. static int rm_sig_from_queue(int sig, struct task_struct *t)
    9. 

  9. {
    10. 

  10. 	return rm_from_queue(sig, &t->pending);
    11. 

  11. }
其主体实现是rm_from_queue
    2. 

  2. static int rm_from_queue(int sig, struct sigpending *s)
    3. 

  3. {
    4. 

  4. 	struct sigqueue *q, **pp;
    5. 

    6. 

  6. 	if (!sigismember(&s->signal, sig))//表示该位是否已经置1,一般是已经,否则直接return
    7. 

  7. 		return 0;
    8. 

    9. 

  9. 	sigdelset(&s->signal, sig);//清除该标志位
    10. 

    11. 

  11. 	pp = &s->head;
    12. 

    13. 

  13. 	while ((q = *pp) != NULL) {
    14. 

  14. 		if (q->info.si_signo == sig) {//如果队列中的信号等于sig(针对新类型信号)
    15. 

  15. 			if ((*pp = q->next) == NULL)
    16. 

  16. 				s->tail = pp;
    17. 

  17. 			kmem_cache_free(sigqueue_cachep,q);//删除
    18. 

  18. 			atomic_dec(&nr_queued_signals);//-1
    19. 

  19. 			continue;
    20. 

  20. 		}
    21. 

  21. 		pp = &q->next;
    22. 

  22. 	}
    23. 

  23. 	return 1;
    24. 

  24. }
查看发送信号处理
  1. asmlinkage long
    2. 

  2. sys_kill(int pid, int sig)
    3. 

  3. {
    4. 

  4. 	struct siginfo info;
    5. 

  5.     //收集相关信息
    6. 

  6. 	info.si_signo = sig;//信号类型
    7. 

  7. 	info.si_errno = 0;
    8. 

  8. 	info.si_code = SI_USER;//用户信号
    9. 

  9. 	info.si_pid = current->pid;//进程号
    10. 

  10. 	info.si_uid = current->uid;//uid
    11. 

    12. 

  12. 	return kill_something_info(sig, &info, pid);
    13. 

  13. }



    2. 

    3. 

  3. /*
    4. 

  4.  * kill_something_info() interprets pid in interesting ways just like kill(2).
    5. 

  5.  *
    6. 

  6.  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
    7. 

  7.  * is probably wrong.  Should make it like BSD or SYSV.
    8. 

  8.  */
    9. 

    10. 

  10. static int kill_something_info(int sig, struct siginfo *info, int pid)
    11. 

  11. {
    12. 

  12. 	if (!pid) {//pid==0发送给当前进程的所有进程
    13. 

  13. 		return kill_pg_info(sig, info, current->pgrp);
    14. 

  14. 	} else if (pid == -1) { //发送到除当前进程以外的进程
    15. 

  15. 		int retval = 0, count = 0;
    16. 

  16. 		struct task_struct * p;
    17. 

    18. 

  18. 		read_lock(&tasklist_lock);
    19. 

  19. 		for_each_task(p) {
    20. 

  20. 			if (p->pid > 1 && p != current) {
    21. 

  21. 				int err = send_sig_info(sig, info, p);
    22. 

  22. 				++count;
    23. 

  23. 				if (err != -EPERM)
    24. 

  24. 					retval = err;
    25. 

  25. 			}
    26. 

  26. 		}
    27. 

  27. 		read_unlock(&tasklist_lock);
    28. 

  28. 		return count ? retval : -ESRCH;
    29. 

  29. 	} else if (pid < 0) {//小于值,则发送给-pid的进程组
    30. 

  30. 		return kill_pg_info(sig, info, -pid);
    31. 

  31. 	} else {
    32. 

  32. 		return kill_proc_info(sig, info, pid);//发送给具体的进程
    33. 

  33. 	}
    34. 

  34. }



    2. 

  2. inline int
    3. 

  3. kill_proc_info(int sig, struct siginfo *info, pid_t pid)
    4. 

  4. {
    5. 

  5. 	int error;
    6. 

  6. 	struct task_struct *p;
    7. 

    8. 

  8. 	read_lock(&tasklist_lock);
    9. 

  9. 	p = find_task_by_pid(pid);//找到pid对应的task_struct结构
    10. 

  10. 	error = -ESRCH;
    11. 

  11. 	if (p)
    12. 

  12. 		error = send_sig_info(sig, info, p);//发送信号
    13. 

  13. 	read_unlock(&tasklist_lock);
    14. 

  14. 	return error;
    15. 

  15. }
最重要部分send_sig_info

    2. 

  2. int          //信号     信号相关信息           接收信号进程的pcb
    3. 

  3. send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
    4. 

  4. {
    5. 

  5. 	unsigned long flags;
    6. 

  6. 	int ret;
    7. 

    8. 

    9. 

  9. #if DEBUG_SIG
    10. 

  10. printk("SIG queue (%s:%d): %d ", t->comm, t->pid, sig);
    11. 

  11. #endif
    12. 

    13. 

  13. 	ret = -EINVAL;
    14. 

  14. 	if (sig < 0 || sig > _NSIG)//不在信号范围出错
    15. 

  15. 		goto out_nolock;
    16. 

  16. 	/* The somewhat baroque permissions check... */
    17. 

  17. 	ret = -EPERM;
    18. 

  18. 	if (bad_signal(sig, info, t))//进行错误检查
    19. 

  19. 		goto out_nolock;
    20. 

    21. 

  21. 	/* The null signal is a permissions and process existance probe.
    22. 

  22. 	   No signal is actually delivered.  Same goes for zombies. */
    23. 

  23. 	ret = 0;
    24. 

  24. 	if (!sig || !t->sig)//如果信号为0或者,不存在对应操作
    25. 

  25. 		goto out_nolock;
    26. 

    27. 

  27. 	spin_lock_irqsave(&t->sigmask_lock, flags);
    28. 

  28. 	handle_stop_signal(sig, t);//收到某些特定的信号,不可屏蔽一些其他后续信号,这个负责处理
    29. 

    30. 

  30. 	/* Optimize away the signal, if it's a signal that can be
    31. 

  31. 	   handled immediately (ie non-blocked and untraced) and
    32. 

  32. 	   that is ignored (either explicitly or by default).  */
    33. 

    34. 

  34. 	if (ignored_signal(sig, t))//如果响应是忽略,而且不用跟踪,没有屏蔽,那就不用投递信号
    35. 

  35. 		goto out;
    36. 

    37. 

  37. 	/* Support queueing exactly one non-rt signal, so that we
    38. 

  38. 	   can get more detailed information about the cause of
    39. 

  39. 	   the signal. */
    40. 

  40. 	if (sig < SIGRTMIN && sigismember(&t->pending.signal, sig))
    41. 

  41. 		goto out;//老编制的信号,投递,就是把接收信号位图设置为1,不用将信号挂到队列
    42. 

    43. 

  43. 	ret = deliver_signal(sig, info, t);
    44. 

  44. out:
    45. 

  45. 	spin_unlock_irqrestore(&t->sigmask_lock, flags);
    46. 

  46. 	if ((t->state & TASK_INTERRUPTIBLE) && signal_pending(t))//如果接收的进程处于这个状态,
    47. 

  47. 	//而且有信号要处理,则唤醒进程
    48. 

  48. 		wake_up_process(t);
    49. 

  49. out_nolock:
    50. 

  50. #if DEBUG_SIG
    51. 

  51. printk(" %d -> %d\n", signal_pending(t), ret);
    52. 

  52. #endif
    53. 

    54. 

  54. 	return ret;
    55. 

  55. }



    2. 

  2. static int deliver_signal(int sig, struct siginfo *info, struct task_struct *t)
    3. 

  3. {
    4. 

  4. 	int retval = send_signal(sig, info, &t->pending);
    5. 

    6. 

  6. 	if (!retval && !sigismember(&t->blocked, sig))
    7. 

  7. 		signal_wake_up(t);
    8. 

    9. 

  9. 	return retval;
    10. 

  10. }




    2. 

  2. static int send_signal(int sig, struct siginfo *info, struct sigpending *signals)
    3. 

  3. {
    4. 

  4. 	struct sigqueue * q = NULL;//创建一个相关嘟列
    5. 

    6. 

  6. 	/* Real-time signals must be queued if sent by sigqueue, or
    7. 

  7. 	   some other real-time mechanism.  It is implementation
    8. 

  8. 	   defined whether kill() does so.  We attempt to do so, on
    9. 

  9. 	   the principle of least surprise, but since kill is not
    10. 

  10. 	   allowed to fail with EAGAIN when low on memory we just
    11. 

  11. 	   make sure at least one signal gets delivered and don't
    12. 

  12. 	   pass on the info struct.  */
    13. 

    14. 

  14. 	if (atomic_read(&nr_queued_signals) < max_queued_signals) {
    15. 

  15. 		q = kmem_cache_alloc(sigqueue_cachep, GFP_ATOMIC);
    16. 

  16. 	}
    17. 

    18. 

  18. 	if (q) {
    19. 

  19. 		atomic_inc(&nr_queued_signals);
    20. 

  20. 		q->next = NULL;//新创建的,设置为null
    21. 

  21. 		*signals->tail = q;//指向尾部
    22. 

  22. 		signals->tail = &q->next;//
    23. 

  23. 		switch ((unsigned long) info) {
    24. 

  24. 			case 0:
    25. 

  25. 				q->info.si_signo = sig;
    26. 

  26. 				q->info.si_errno = 0;
    27. 

  27. 				q->info.si_code = SI_USER;
    28. 

  28. 				q->info.si_pid = current->pid;
    29. 

  29. 				q->info.si_uid = current->uid;
    30. 

  30. 				break;
    31. 

  31. 			case 1:
    32. 

  32. 				q->info.si_signo = sig;
    33. 

  33. 				q->info.si_errno = 0;
    34. 

  34. 				q->info.si_code = SI_KERNEL;
    35. 

  35. 				q->info.si_pid = 0;
    36. 

  36. 				q->info.si_uid = 0;
    37. 

  37. 				break;
    38. 

  38. 			default:
    39. 

  39. 				copy_siginfo(&q->info, info);//拷贝相关信息,到队列
    40. 

  40. 				break;
    41. 

  41. 		}
    42. 

  42. 	} else if (sig >= SIGRTMIN && info && (unsigned long)info != 1
    43. 

  43. 		   && info->si_code != SI_USER) {
    44. 

  44. 		/*
    45. 

  45. 		 * Queue overflow, abort.  We may abort if the signal was rt
    46. 

  46. 		 * and sent by user using something other than kill().
    47. 

  47. 		 */
    48. 

  48. 		return -EAGAIN;
    49. 

  49. 	}
    50. 

    51. 

  51. 	sigaddset(&signals->signal, sig);//将接收信号,相应位图设置为1
    52. 

  52. 	return 0;
    53. 

  53. }



    2. 

  2. /*
    3. 

  3.  * Note that 'init' is a special process: it doesn't get signals it doesn't
    4. 

  4.  * want to handle. Thus you cannot kill init even with a SIGKILL even by
    5. 

  5.  * mistake.
    6. 

  6.  */
    7. 

  7. int do_signal(struct pt_regs *regs, sigset_t *oldset)
    8. 

  8. {
    9. 

  9. 	siginfo_t info;
    10. 

  10. 	struct k_sigaction *ka;
    11. 

    12. 

  12. 	/*
    13. 

  13. 	 * We want the common case to go fast, which
    14. 

  14. 	 * is why we may in certain cases get here from
    15. 

  15. 	 * kernel mode. Just return without doing anything
    16. 

  16. 	 * if so.
    17. 

  17. 	 */
    18. 

  18. 	if ((regs->xcs & 3) != 3)
    19. 

  19. 		return 1;
    20. 

    21. 

  21. 	if (!oldset)//如果为0
    22. 

  22. 		oldset = &current->blocked;//获取其屏蔽信号
    23. 

    24. 

  24. 	for (;;) {
    25. 

  25. 		unsigned long signr;
    26. 

    27. 

  27. 		spin_lock_irq(&current->sigmask_lock);
    28. 

  28. 		signr = dequeue_signal(&current->blocked, &info);//取出一个没屏蔽的信号
    29. 

  29. 		spin_unlock_irq(&current->sigmask_lock);
    30. 

    31. 

  31. 		if (!signr)//如果为0则跳出(因为表示当前没有这样的信号了)
    32. 

  32. 			break;
    33. 

  33.         //如果当前
    34. 

  34. 		if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
    35. 

  35. 			/* Let the debugger run.  */
    36. 

  36. 			current->exit_code = signr;
    37. 

  37. 			current->state = TASK_STOPPED;
    38. 

  38. 			notify_parent(current, SIGCHLD);
    39. 

  39. 			schedule();
    40. 

    41. 

  41. 			/* We're back.  Did the debugger cancel the sig?  */
    42. 

  42. 			if (!(signr = current->exit_code))
    43. 

  43. 				continue;
    44. 

  44. 			current->exit_code = 0;
    45. 

    46. 

  46. 			/* The debugger continued.  Ignore SIGSTOP.  */
    47. 

  47. 			if (signr == SIGSTOP)
    48. 

  48. 				continue;
    49. 

    50. 

  50. 			/* Update the siginfo structure.  Is this good?  */
    51. 

  51. 			if (signr != info.si_signo) {
    52. 

  52. 				info.si_signo = signr;
    53. 

  53. 				info.si_errno = 0;
    54. 

  54. 				info.si_code = SI_USER;
    55. 

  55. 				info.si_pid = current->p_pptr->pid;
    56. 

  56. 				info.si_uid = current->p_pptr->uid;
    57. 

  57. 			}
    58. 

    59. 

  59. 			/* If the (new) signal is now blocked, requeue it.  */
    60. 

  60. 			if (sigismember(&current->blocked, signr)) {
    61. 

  61. 				send_sig_info(signr, &info, current);
    62. 

  62. 				continue;
    63. 

  63. 			}
    64. 

  64. 		}
    65. 

    66. 

  66. 		ka = &current->sig->action[signr-1];//获取信号向量
    67. 

  67. 		if (ka->sa.sa_handler == SIG_IGN) {//如果对应的处理是SIG_IGN
    68. 

  68. 			if (signr != SIGCHLD)//忽略则继续取没屏蔽信号,处理
    69. 

  69. 				continue;
    70. 

  70. 			//是儿子信号则等待所有子进程退出
    71. 

  71. 			/* Check for SIGCHLD: it's special.  */
    72. 

  72. 			while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
    73. 

  73. 				/* nothing */;
    74. 

  74. 			continue;
    75. 

  75. 		}
    76. 

  76.         //信号向量设置为SIG_DFL
    77. 

  77. 		if (ka->sa.sa_handler == SIG_DFL) {
    78. 

  78. 			int exit_code = signr;
    79. 

    80. 

  80. 			/* Init gets no signals it doesn't want.  */
    81. 

  81. 			if (current->pid == 1)//不可以对init进程发送相关信号
    82. 

  82. 				continue;
    83. 

    84. 

  84. 			switch (signr) {
    85. 

  85. 			case SIGCONT: case SIGCHLD: case SIGWINCH:
    86. 

  86. 				continue;//如果是SIGCONT之类,continue继续处理信号
    87. 

    88. 

  88. 			case SIGTSTP: case SIGTTIN: case SIGTTOU:
    89. 

  89. 				if (is_orphaned_pgrp(current->pgrp))
    90. 

  90. 					continue;
    91. 

  91. 				/* FALLTHRU */
    92. 

    93. 

  93. 			case SIGSTOP://如果是sigstop信号
    94. 

  94. 				current->state = TASK_STOPPED;//设置标志位
    95. 

  95. 				current->exit_code = signr;
    96. 

  96. 				if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
    97. 

  97. 					notify_parent(current, SIGCHLD);
    98. 

  98. 				schedule();
    99. 

  99. 				continue;
    100. 

    101. 

  101. 			case SIGQUIT: case SIGILL: case SIGTRAP:
    102. 

  102. 			case SIGABRT: case SIGFPE: case SIGSEGV:
    103. 

  103. 			case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
    104. 

  104. 				if (do_coredump(signr, regs))//这类信号默认处理
    105. 

  105. 					exit_code |= 0x80;
    106. 

  106. 				/* FALLTHRU */
    107. 

    108. 

  108. 			default://多数信号的默认处理
    109. 

  109. 				sigaddset(&current->pending.signal, signr);//猜想设置此位表示默认处理,留给父进程查看信息
    110. 

  110. 				recalc_sigpending(current);//检查进程是否有非阻塞的挂起信号
    111. 

  111. 				current->flags |= PF_SIGNALED;
    112. 

  112. 				do_exit(exit_code);//结束接收信号的进程
    113. 

  113. 				/* NOTREACHED */
    114. 

  114. 			}
    115. 

  115. 		}
    116. 

    117. 

  117. 		/* Reenable any watchpoints before delivering the
    118. 

  118. 		 * signal to user space. The processor register will
    119. 

  119. 		 * have been cleared if the watchpoint triggered
    120. 

  120. 		 * inside the kernel.
    121. 

  121. 		 */
    122. 

  122. 		__asm__("movl %0,%%db7"	: : "r" (current->thread.debugreg[7]));
    123. 

    124. 

  124. 		/* Whee!  Actually deliver the signal.  */
    125. 

  125. 		handle_signal(signr, ka, &info, oldset, regs);
    126. 

  126. 		return 1;
    127. 

  127. 	}
    128. 

    129. 

  129. 	/* Did we come from a system call? */
    130. 

  130. 	if (regs->orig_eax >= 0) {
    131. 

  131. 		/* Restart the system call - no handlers present */
    132. 

  132. 		if (regs->eax == -ERESTARTNOHAND ||
    133. 

  133. 		    regs->eax == -ERESTARTSYS ||
    134. 

  134. 		    regs->eax == -ERESTARTNOINTR) {
    135. 

  135. 			regs->eax = regs->orig_eax;
    136. 

  136. 			regs->eip -= 2;
    137. 

  137. 		}
    138. 

  138. 	}
    139. 

  139. 	return 0;
    140. 

  140. }


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

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

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

linux内核情景分析之信号实现的更多相关文章

  1. linux内核情景分析之execve()

    用来描述用户态的cpu寄存器在内核栈中保存情况.可以获取用户空间的信息 struct pt_regs { long ebx; //可执行文件路径的指针(regs.ebx中 long ecx; //命令 ...

  2. Linux内核情景分析之消息队列

    早期的Unix通信只有管道与信号,管道的缺点: 所载送的信息是无格式的字节流,不知道分界线在哪,也没通信规范,另外缺乏控制手段,比如保温优先级,管道机制的大小只有1页,管道很容易写满而读取没有及时,发 ...

  3. Linux内核情景分析之异常访问,用户堆栈的扩展

    情景假设: 在堆内存中申请了一块内存,然后释放掉该内存,然后再去访问这块内存.也就是所说的野指针访问. 当cpu产生页面错误时,会把失败的线性地址放在cr2寄存器.线性地址缺页异常的4种情况 1.如果 ...

  4. Linux内核情景分析的alloc_pages

    NUMA结构的alloc_pages ==================== mm/numa.c 43 43 ==================== 43 #ifdef CONFIG_DISCON ...

  5. linux内核情景分析之exit与Wait

    //第一层系统调用 asmlinkage long sys_exit(int error_code) { do_exit((error_code&0xff)<<8); } 其主体是 ...

  6. linux内核情景分析之内核中的互斥操作

    信号量机制: struct sempahore是其结构,定义如下 struct semaphore { atomic_t count;//资源数目 int sleepers;//等待进程数目 wait ...

  7. linux内核情景分析之匿名管道

    管道的机制由pipe()创建,由pipe()所建立的管道两端都在同一进程.所以必须在fork的配合下,才可以在具有亲缘关系的进程通信 /* * sys_pipe() is the normal C c ...

  8. linux内核情景分析之命名管道

    管道是一种"无名","无形文件,只可以近亲进程使用,不可以再任意两个进程通信使用,所以只能实现"有名","有形"的文件来实现就可以 ...

  9. linux内核情景分析之强制性调度

    从系统调用返回到用户空间是否调度,从ret_with_reschedule可看出,是否真正调度,取决于当前进程的pcb中的need_resched是否设置为1,那如何设置为1取决于以下几种情况: 时间 ...

随机推荐

  1. Ansible学习 Inventory文件

    Ansible可同时操作属于一个组的多台主机,组与主机之间关系配置在inventory文件中,inventory默认的配置文件是/etc/ansible/hosts 1.在/etc/ansible/h ...

  2. js操作地址栏

    //判断地址里是否有?号,如果没有就从最后一个/截到最后,如果有?就从最后一个/截至?号处 listTable.url = location.href.lastIndexOf("?" ...

  3. awk速查手册

    简介awk是一个强大的文本分析工具,相对于grep的查找,sed的编辑,awk在其对数据分析并生成报告时,显得尤为强大.简单来说awk就是把文件逐行的读入,以空格为默认分隔符将每行切片,切开的部分再进 ...

  4. python面向对象之反射和内置方法

    一.静态方法(staticmethod)和类方法(classmethod) 类方法:有个默认参数cls,并且可以直接用类名去调用,可以与类属性交互(也就是可以使用类属性) 静态方法:让类里的方法直接被 ...

  5. HDU - 6514 Monitor（二维差分）

    题意 给定一个\(n×m\)的矩阵.(\(n×m <= 1e7\)). \(p\)次操作,每次可以在这个矩阵中覆盖一个矩形. \(q\)次询问,每次问一个矩形区域中,是否所有的点都被覆盖. 解析 ...

  6. 笔记-python-tutorial-8.errors and exceptions

    笔记-python-tutorial-8.errors and exceptions 1.      errors and exceptions 1.1.    syntax errors >& ...

  7. spark 对hbase 操作

    本文将分两部分介绍,第一部分讲解使用 HBase 新版 API 进行 CRUD 基本操作:第二部分讲解如何将 Spark 内的 RDDs 写入 HBase 的表中,反之,HBase 中的表又是如何以 ...

  8. input框中的必填项之取消当前input框为必填项

    html5新增了一个required属性,可以使用这个属性对文本框设置必填项,直接在input文本框上添加required即可 . 效果如图:   

  9. 将FragmentManger事务添加到返回栈中

    FragmentManger事务添加或替换的 Fragment 后,这时点击 Back 键,程序并不会返回添加之前的状态. 我们可以使用 Transaction 对象的 addToBackStack( ...

  10. IOS开发学习笔记019-动态创建控件

    动态创建控件 一.按钮 二.文本输入框 三.lable标签 注意: 只是简单的拖拽控件会毁了你,所以最好还是手动通过代码创建控件. 如果要通过代码生成按钮的话,可以在系统自带的函数viewDidLoa ...