新闻中心

EEPW首页 > 嵌入式系统 > 设计应用 > linux内核中的信号机制--信号发送

linux内核中的信号机制--信号发送

作者： 时间：2016-11-22 来源：网络
收藏
Kernel version：2.6.14

CPU architecture：ARM920T

本文引用地址：https://www.eepw.com.cn/article/201611/320005.htm

Author：ce123(http://blog.csdn.net/ce123)

应用程序发送信号时，主要通过kill进行。注意：不要被“kill”迷惑，它并不是发送SIGKILL信号专用函数。这个函数主要通过系统调用sys_kill()进入内核，它接收两个参数：

第一个参数为目标进程id，kill()可以向进程(或进程组)，线程(轻权线程)发送信号，因此pid有以下几种情况：

  • pid>0：目标进程(可能是轻权进程)由pid指定。
  • pid=0：信号被发送到当前进程组中的每一个进程。
  • pid=-1：信号被发送到任何一个进程，init进程(PID=1)和以及当前进程无法发送信号的进程除外。
  • pid<-1：信号被发送到目标进程组，其id由参数中的pid的绝对值指定。
第二个参数为需要发送的信号。

由于sys_kill处理的情况比较多，分析起来比较复杂，我们从tkill()函数入手，这个函数把信号发送到由参数指定pid指定的线程(轻权进程)中。tkill的内核入口是sys_tkill(kernel/signal.c)，其定义如下：

[plain]view plaincopy
print?
  1. /*
  2. *Sendasignaltoonlyonetask,evenifitsaCLONE_THREADtask.
  3. */
  4. asmlinkagelong
  5. sys_tkill(intpid,intsig)
  6. {
  7. structsiginfoinfo;
  8. interror;
  9. structtask_struct*p;
  11. /*Thisisonlyvalidforsingletasks*/
  12. if(pid<=0)//对参数pid进行检查
  13. return-EINVAL;
  15. info.si_signo=sig;//根据参数初始化一个siginfo结构
  16. info.si_errno=0;
  17. info.si_code=SI_TKILL;
  18. info.si_pid=current->tgid;
  19. info.si_uid=current->uid;
  21. read_lock(&tasklist_lock);
  22. p=find_task_by_pid(pid);//获取由pid指定的线程的task_struct结构
  23. error=-ESRCH;
  24. if(p){
  25. error=check_kill_permission(sig,&info,p);//权限检查
  26. /*
  27. *Thenullsignalisapermissionsandprocessexistence
  28. *probe.Nosignalisactuallydelivered.
  29. */
  30. if(!error&&sig&&p->sighand){
  31. spin_lock_irq(&p->sighand->siglock);
  32. handle_stop_signal(sig,p);
  33. //对某些特殊信号进程处理，例如当收到SIGSTOP时，需要把信号队列中的SIGCONT全部删除
  34. error=specific_send_sig_info(sig,&info,p);//把信号加入到信号队列
  35. spin_unlock_irq(&p->sighand->siglock);
  36. }
  37. }
  38. read_unlock(&tasklist_lock);
  39. returnerror;
  40. }

sys_tkill函数主要是通过pecific_send_sig_info()函数实现的，下面我们看一下pecific_send_sig_info()(kernel/signal.c)的定义：

[plain]view plaincopy
print?
  1. staticint
  2. specific_send_sig_info(intsig,structsiginfo*info,structtask_struct*t)
  3. {
  4. intret=0;
  6. if(!irqs_disabled())
  7. BUG();
  8. assert_spin_locked(&t->sighand->siglock);
  10. if(((unsignedlong)info>2)&&(info->si_code==SI_TIMER))
  11. /*
  12. *Setupareturntoindicatethatwedroppedthesignal.
  13. */
  14. ret=info->si_sys_private;
  15. /*信号被忽略*/
  16. /*Short-circuitignoredsignals.*/
  17. if(sig_ignored(t,sig))
  18. gotoout;
  20. /*Supportqueueingexactlyonenon-rtsignal,sothatwe
  21. cangetmoredetailedinformationaboutthecauseof
  22. thesignal.*/
  23. if(LEGACY_QUEUE(&t->pending,sig))
  24. gotoout;
  26. ret=send_signal(sig,info,t,&t->pending);//实际的发送工作
  27. if(!ret&&!sigismember(&t->blocked,sig))
  28. signal_wake_up(t,sig==SIGKILL);
  29. out:
  30. returnret;
  31. }
首先调用sig_ignored检查信号是否被忽略，然后检查发送的信号是不是普通信号，如果是普通信号，就需要根据信号位图来检查当前信号队列中是否已经存在该信号，如果已经存在，对于普通信号不需要做任何处理。然后调用send_signal来完成实际的发送工作，send_signal()是信号发送的重点，除sys_tkill之外的函数，最终都是通过send_signal()来完成信号的发送工作的。

这里注意到想send_signal()传递的参数时t->pending，也就是连接Private Signal Queue的那条链。最后，如果发送成功就调用signal_wake_up()来唤醒目标进程，这样可以保证该进程进入就绪状态，从而有机会被调度执行信号处理函数。

现在我们来看看send_signal()(kernel/signal.c)函数，这个函数的主要工作就是分配并初始化一个sigqueue结构，然后把它添加到信号队列中。

[plain]view plaincopy
print?
  1. staticintsend_signal(intsig,structsiginfo*info,structtask_struct*t,
  2. structsigpending*signals)
  3. {
  4. structsigqueue*q=NULL;
  5. intret=0;
  7. /*
  8. *fast-pathedsignalsforkernel-internalthingslikeSIGSTOP
  9. *orSIGKILL.
  10. */
  11. if((unsignedlong)info==2)
  12. gotoout_set;
  14. /*Real-timesignalsmustbequeuedifsentbysigqueue,or
  15. someotherreal-timemechanism.Itisimplementation
  16. definedwhetherkill()doesso.Weattempttodoso,on
  17. theprincipleofleastsurprise,butsincekillisnot
  18. allowedtofailwithEAGAINwhenlowonmemorywejust
  19. makesureatleastonesignalgetsdeliveredanddont
  20. passontheinfostruct.*/
  22. q=__sigqueue_alloc(t,GFP_ATOMIC,(sig
  23. ((unsignedlong)info<2||
  24. info->si_code>=0)));//分配sigqueue结构
  25. if(q){//如果成功分配到sigqueue结构，就把它添加到队列中，并对其初始化
  26. list_add_tail(&q->list,&signals->list);
  27. switch((unsignedlong)info){
  28. case0:
  29. q->info.si_signo=sig;
  30. q->info.si_errno=0;
  31. q->info.si_code=SI_USER;
  32. q->info.si_pid=current->pid;
  33. q->info.si_uid=current->uid;
  34. break;
  35. case1:
  36. q->info.si_signo=sig;
  37. q->info.si_errno=0;
  38. q->info.si_code=SI_KERNEL;
  39. q->info.si_pid=0;
  40. q->info.si_uid=0;
  41. break;
  42. default:
  43. copy_siginfo(&q->info,info);//拷贝sigqueue结构
  44. break;
  45. }
  46. }else{
  47. if(sig>=SIGRTMIN&&info&&(unsignedlong)info!=1
  48. &&info->si_code!=SI_USER)
  49. /*
  50. *Queueoverflow,abort.Wemayabortifthesignalwasrt
  51. *andsentbyuserusingsomethingotherthankill().
  52. */
  53. return-EAGAIN;
  54. if(((unsignedlong)info>1)&&(info->si_code==SI_TIMER))
  55. /*
  56. *Setupareturntoindicatethatwedropped
  57. *thesignal.
  58. */
  59. ret=info->si_sys_private;
  60. }
  62. out_set:
  63. sigaddset(&signals->signal,sig);//设置信号位图
  64. returnret;
  65. }
从上面的分析可以看出，我们看到信号被添加到信号队列之后，会调用signal_wake_up()唤醒这个进程，signal_wake_up()(kernel/signal.c)的定义如下：

[plain]view plaincopy
print?
  1. /*
  2. *Tellaprocessthatithasanewactivesignal..
  3. *
  4. *NOTE!werelyonthepreviousspin_lockto
  5. *lockinterruptsforus!Wecanonlybecalledwith
  6. *"siglock"held,andthelocalinterruptmust
  7. *havebeendisabledwhenthatgotacquired!
  8. *
  9. *Noneedtosetneed_reschedsincesignaleventpassing
  10. *goesthrough->blocked
  11. */
  12. voidsignal_wake_up(structtask_struct*t,intresume)
  13. {
  14. unsignedintmask;
  16. set_tsk_thread_flag(t,TIF_SIGPENDING);//为进程设置TIF_SIGPENDING标志
  18. /*
  19. *ForSIGKILL,wewanttowakeitupinthestopped/tracedcase.
  20. *Wedontcheckt->stateherebecausethereisaracewithit
  21. *executinganotherprocessorandjustnowenteringstoppedstate.
  22. *Byusingwake_up_state,weensuretheprocesswillwakeupand
  23. *handleitsdeathsignal.
  24. */
  25. mask=TASK_INTERRUPTIBLE;
  26. if(resume)
  27. mask|=TASK_STOPPED|TASK_TRACED;
  28. if(!wake_up_state(t,mask))
  29. kick_process(t);
  30. }
signal_wake_up()首先为进程设置TIF_SIGPENDING标志，说明该进程有延迟的信号要等待处理。然后再调用wake_up_state()唤醒目标进程，如果目标进程在其他的CPU上运行，wake_up_state()将返回0，此时调用kick_process()向该CPU发送一个处理器间中断。当中断返回前戏，会为当前进程处理延迟的信号。

此后当该进程被调度时，在进程返回用户空间前，会调用do_notify_resume()处理该进程的信号。

关键词： linux内核信号机制信号发

评论


相关推荐

技术专区

关闭