新闻中心

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

linux内核中的信号机制--信号处理

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

CPU architecture：ARM920T

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

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

当进程被调度时，会调用do_notify_resume()来处理信号队列中的信号。信号处理主要就是调用sighand_struct结构中对应的信号处理函数。do_notify_resume()(arch/arm/kernel/signal.c)函数的定义如下：

[plain]view plaincopy
print?
  1. asmlinkagevoid
  2. do_notify_resume(structpt_regs*regs,unsignedintthread_flags,intsyscall)
  3. {
  4. if(thread_flags&_TIF_SIGPENDING)
  5. do_signal(¤t->blocked,regs,syscall);
  6. }
_TIF_SIGPENDING标志是在signal_wake_up()函数中设置的，检查该标志后，接下来就调用do_signal()函数，我们来看看do_signal()(arch/arm/kernel/signal.c)的具体定义：

[plain]view plaincopy
print?
  1. /*
  2. *Notethatinitisaspecialprocess:itdoesntgetsignalsitdoesnt
  3. *wanttohandle.ThusyoucannotkillinitevenwithaSIGKILLevenby
  4. *mistake.
  5. *
  6. *Notethatwegothroughthesignalstwice:oncetocheckthesignalsthat
  7. *thekernelcanhandle,andthenwebuildalltheuser-levelsignalhandling
  8. *stack-framesinonegoafterthat.
  9. */
  10. staticintdo_signal(sigset_t*oldset,structpt_regs*regs,intsyscall)
  11. {
  12. structk_sigactionka;
  13. siginfo_tinfo;
  14. intsignr;
  16. /*
  17. *Wewantthecommoncasetogofast,which
  18. *iswhywemayincertaincasesgetherefrom
  19. *kernelmode.Justreturnwithoutdoinganything
  20. *ifso.
  21. */
  22. if(!user_mode(regs))//regs保存的是进入内核态之前的寄存器现场，必须为用户模式，否则直接返回
  23. return0;
  25. if(try_to_freeze())
  26. gotono_signal;
  28. if(current->ptrace&PT_SINGLESTEP)
  29. ptrace_cancel_bpt(current);//和调试相关，我们在后面的文章中会具体分析
  31. signr=get_signal_to_deliver(&info,&ka,regs,NULL);//取出等待处理的信号
  32. if(signr>0){
  33. handle_signal(signr,&ka,&info,oldset,regs,syscall);//处理信号
  34. if(current->ptrace&PT_SINGLESTEP)
  35. ptrace_set_bpt(current);
  36. return1;
  37. }
  39. no_signal:
  40. /*
  41. *Nosignaltodelivertotheprocess-restartthesyscall.
  42. */
  43. if(syscall){
  44. if(regs->ARM_r0==-ERESTART_RESTARTBLOCK){
  45. if(thumb_mode(regs)){
  46. regs->ARM_r7=__NR_restart_syscall;
  47. regs->ARM_pc-=2;
  48. }else{
  49. u32__user*usp;
  51. regs->ARM_sp-=12;
  52. usp=(u32__user*)regs->ARM_sp;
  54. put_user(regs->ARM_pc,&usp[0]);
  55. /*swi__NR_restart_syscall*/
  56. put_user(0xef000000|__NR_restart_syscall,&usp[1]);
  57. /*ldrpc,[sp],#12*/
  58. put_user(0xe49df00c,&usp[2]);
  60. flush_icache_range((unsignedlong)usp,
  61. (unsignedlong)(usp+3));
  63. regs->ARM_pc=regs->ARM_sp+4;
  64. }
  65. }
  66. if(regs->ARM_r0==-ERESTARTNOHAND||
  67. regs->ARM_r0==-ERESTARTSYS||
  68. regs->ARM_r0==-ERESTARTNOINTR){
  69. restart_syscall(regs);
  70. }
  71. }
  72. if(current->ptrace&PT_SINGLESTEP)
  73. ptrace_set_bpt(current);
  74. return0;
  75. }

执行do_signal()函数时，进程一定处于内核空间，通常进程只有通过中断或者系统调用才能进入内核空间，regs保存着系统调用或者中断时的现场。user_mode()根据regs中的cpsr寄存器来判断是中断现场环境还是用户态环境。如果不是用户态环境，就不对信号进行任何处理，直接从do_signal()函数返回。

如果user_mode()函数发现regs的现场是内核态，那就意味着这不是一次系统调用的返回，也不是一次普通的中断返回，而是一次嵌套中断返回(或者在系统调用过程中发生了中断)。此时大概的执行路径应该是这样的：假设进场现在运行在用户态，此时发生一次中断，进场进入内核态(此时user_mode(regs)返回1，意味着中断现场是用户态。)，此后在中断返回前，发生了一个更高优先级的中断，于是CPU开始执行高优先级的处理函数(此时user_mode(regs)返回0，意味着中断现场是在内核态)。当高优先级中断处理结束后，在它返回时，是不应该处理信号的，因为信号的优先级比中断的优先级低。在这种情况下，对信号的处理将会延迟到低优先级中断处理结束之后。相对于Windows内核来说，尽管linux内核中没有一组显式的操作函数来实现这一系列的优先级管理方案，但是linux内核和Windows内核都使用了同样的机制，优先级关系为：高优先级中断->低优先级中断->软中断(类似Windows内中的DPC)->信号(类似Windows内核中的APC)->进程运行。

如果user_mode(regs)返回1，接下来会执行(中间略去一下和本文关系不大的代码)get_signal_to_deliver()，这个函数从当前进程的信号队列(保存Private Signal Queue和Shared Signal Queue)取出等待处理的信号(调用dequeue_signal()函数)，然后根据信号定位到对应的signal_struct结构，如果信号的处理函数sa_handler为SIG_IGN，就忽略该信号，继续取下一个信号；如果信号的处理函数sa_handler为SIG_DFL，意味着按照信号默认的处理方式对待就可以了(例如直接调用do_coredump()等)。

如果get_signal_to_deliver()函数返回值大于0，说明这个信号的处理函数是在用户态空间(通过signal()和sigaction()等函数设置的自定义信号处理函数。)，将调用handle_signal()函数进行处理。handle_signal()函数的定义如下：

[plain]view plaincopy
print?
  1. /*
  2. *OK,wereinvokingahandler
  3. */
  4. staticvoid
  5. handle_signal(unsignedlongsig,structk_sigaction*ka,
  6. siginfo_t*info,sigset_t*oldset,
  7. structpt_regs*regs,intsyscall)
  8. {
  9. structthread_info*thread=current_thread_info();
  10. structtask_struct*tsk=current;
  11. intusig=sig;
  12. intret;
  14. /*
  15. *Ifwewerefromasystemcall,checkforsystemcallrestarting...
  16. */
  17. if(syscall){
  18. switch(regs->ARM_r0){
  19. case-ERESTART_RESTARTBLOCK:
  20. case-ERESTARTNOHAND:
  21. regs->ARM_r0=-EINTR;
  22. break;
  23. case-ERESTARTSYS:
  24. if(!(ka->sa.sa_flags&SA_RESTART)){
  25. regs->ARM_r0=-EINTR;
  26. break;
  27. }
  28. /*fallthrough*/
  29. case-ERESTARTNOINTR:
  30. restart_syscall(regs);
  31. }
  32. }
  34. /*
  35. *translatethesignal
  36. */
  37. if(usig<32&&thread->exec_domain&&thread->exec_domain->signal_invmap)
  38. usig=thread->exec_domain->signal_invmap[usig];
  40. /*
  41. *Setupthestackframe//设置栈帧
  42. */
  43. if(ka->sa.sa_flags&SA_SIGINFO)
  44. ret=setup_rt_frame(usig,ka,info,oldset,regs);
  45. else
  46. ret=setup_frame(usig,ka,oldset,regs);
  48. /*
  49. *Checkthattheresultingregistersareactuallysane.
  50. */
  51. ret|=!valid_user_regs(regs);
  53. /*
  54. *Blockthesignalifwewereunsuccessful.
  55. */
  56. if(ret!=0){
  57. spin_lock_irq(&tsk->sighand->siglock);
  58. sigorsets(&tsk->blocked,&tsk->blocked,
  59. &ka->sa.sa_mask);
  60. if(!(ka->sa.sa_flags&SA_NODEFER))
  61. sigaddset(&tsk->blocked,sig);
  62. recalc_sigpending();
  63. spin_unlock_irq(&tsk->sighand->siglock);
  64. }
  66. if(ret==0)
  67. return;
  69. force_sigsegv(sig,tsk);
  70. }
在这样情况下，进程当前处于内核态，而信号处理函数却处于用户态，为此必须在进程的用户态构造一个临时的堆栈环境(因为进程的信号处理函数在进行函数调用以及使用局部变量时需要使用堆栈。)，然后进入用户态执行信号处理函数，最后再返回内核态继续执行。在这个过程中，有以下几个问题需要解决：

1.临时的用户态堆栈在哪里呢？这个很好解决，因为可以直接使用进程现有的用户态堆栈，这里要保证的是：使用结束后这个堆栈必须和使用前是一模一样的。

2.临时堆栈解决后，需要确定的是通过什么方法来保证返回到用户态后，进程执行的是信号的处理函数。我们知道在进入内核态时，内核态堆栈中保存了一个中断现场，也就是一个pt_regs结构，中断返回地址就保存在pt_regts中的pc中，因此我们这里只要把当前进程的pt_regs中pc设置为sa_handler，然后返回到用户态就开始从sa_handler处开始执行了。

[plain]view plaincopy
print?
  1. unsignedlonghandler=(unsignedlong)ka->sa.sa_handler;
  2. regs->ARM_pc=handler;

3.当信号的用户态处理函数执行结束时，需要再次进入内核态，还原用户态堆栈，并且修改pt_regs中的pc，保证将来能够按照正常的方式返回用户态。我们知道进程要主动进入内核态只有通过系统调用，出发异常等方法，为此内核专门提供了一个系统调用sys_sigreturn()(还有一个sys_rt_sigreturn())，但是如何调用sys_sigreturn()呢？强制安装信号处理函数最后必须调用一个sigreturn()不是一个好办法，因为不了解内核的程序员会对这个限制感到不解，为此程序员常常忘记在它们的信号处理函数的末尾调用sigreturn()，如果真是这样，arm-linux-gcc也检测不出这个错误。为此，内核修改regs的ARM_lr值，：

[plain]view plaincopy
print?
  1. regs->ARM_lr=retcode;

当用户态信号处理函数运行结束时，会从lr取出返回地址，因此内核在构建临时regs时，会把上面这段代码的入口地址保存在lr，这样当信号处理完成后，就会顺利的通过系统调用sys_sigreturn()进入内核。

4.当通过构造的sys_sigreturn()返回到内核态之后，内核需要顺利的返回到用户态执行原来的代码(信号处理前应该返回的用户空间状态)，但是此时进入内核空间的pt_regs上下文是通过sys_sigreturn()构造的，而最初的内核堆栈中的pt_regs上下文在第一次返回用户空间执行信号处理函数时，就已经被“销毁”了(内核态堆栈的pt_regs上下文在中断返回后就不复存在了)。而现在必须通过最初的pt_regs上下文返回用户态，为此，在构建临时堆栈环境时，内核会把最初的pt_regs上下文备份到临时堆栈中(位于用户态堆栈)，当通过系统调用sys_sigreturn()再次进入内核时，内核从用户态空间还原出原始的pt_regs。最后正常返回。

通过上面的讨论，我们知道在这个迂回的处理过程中，关键在于用户态的临时堆栈环境的建立，这是一个sigframe结构：

[plain]view plaincopy
print?
  1. /*
  2. *Doasignalreturn;undothesignalstack.Thesearealignedto64-bit.
  3. */
  4. structsigframe{
  5. structsigcontextsc;//保存一组寄存器上下文
  6. unsignedlongextramask[_NSIG_WORDS-1];
  7. unsignedlongretcode;//保存返回地址
  8. structaux_sigframeaux__attribute__((aligned(8)));
  9. };
  11. structrt_sigframe{
  12. structsiginfo__user*pinfo;
  13. void__user*puc;
  14. structsiginfoinfo;
  15. structucontextuc;
  16. unsignedlongretcode;
  17. structaux_sigframeaux__attribute__((aligned(8)));
  18. };
其中的sigcontext的作用类似于pt_regs用于保存相关寄存器上下文，原始的pt_regs的相关信息就备份在这里。而整个sigframe结构是通过get_sigframe()函数在进程用户态空间分配的，get_sigframe()定义如下：

[plain]view plaincopy
print?
  1. staticinlinevoid__user*
  2. get_sigframe(structk_sigaction*ka,structpt_regs*regs,intframesize)
  3. {
  4. unsignedlongsp=regs->ARM_sp;
  5. void__user*frame;
  7. /*
  8. *ThisistheX/Opensanctionedsignalstackswitching.
  9. */
  10. if((ka->sa.sa_flags&SA_ONSTACK)&&!sas_ss_flags(sp))
  11. sp=current->sas_ss_sp+current->sas_ss_size;
  13. /*
  14. *ATPCSB01mandates8-bytealignment
  15. */
  16. frame=(void__user*)((sp-framesize)&~7);
  18. /*
  19. *Checkthatwecanactuallywritetothesignalframe.
  20. */
  21. if(!access_ok(VERIFY_WRITE,frame,framesize))
  22. frame=NULL;
  24. returnframe;
  25. }
get_sigframe()通过用户态空间堆栈的sp-sizeof(struct sigframe)在用户态堆栈的顶部分配了一篇存储空间，将来使用完成后，再通过sp+sizeof(struct sigframe)还原。

通过上面的讨论，我们再回到do_signal()中来，如果有用户态的信号处理函数，do_signal()会调用handle_signal()，handle_signal()将调用setup_frame()或者setup_rt_frame()来完成实际的工作，这里我们以setup_frame()为例进行进一步讨论。

[plain]view plaincopy
print?
  1. staticint
  2. setup_frame(intusig,structk_sigaction*ka,sigset_t*set,structpt_regs*regs)
  3. {
  4. //在用户态堆栈上分配一个sigframe结构
  5. structsigframe__user*frame=get_sigframe(ka,regs,sizeof(*frame));
  6. interr=0;
  8. if(!frame)
  9. return1;
  11. //把相关信息从内核态备份到用户态堆栈的sigframe结构中
  12. err|=setup_sigcontext(&frame->sc,&frame->aux,regs,set->sig[0]);
  14. if(_NSIG_WORDS>1){
  15. err|=__copy_to_user(frame->extramask,&set->sig[1],
  16. sizeof(frame->extramask));
  17. }
  19. if(err==0)
  20. err=setup_return(regs,ka,&frame->retcode,frame,usig);
  22. returnerr;
  23. }
setup_return()设置返回地址，其定义如下：

[plain]view plaincopy
print?
  1. staticint
  2. setup_return(structpt_regs*regs,structk_sigaction*ka,
  3. unsignedlong__user*rc,void__user*frame,intusig)
  4. {
  5. unsignedlonghandler=(unsignedlong)ka->sa.sa_handler;
  6. unsignedlongretcode;
  7. intthumb=0;
  8. unsignedlongcpsr=regs->ARM_cpsr&~PSR_f;
  10. /*
  11. *Maybeweneedtodelivera32-bitsignaltoa26-bittask.
  12. */
  13. if(ka->sa.sa_flags&SA_THIRTYTWO)
  14. cpsr=(cpsr&~MODE_MASK)|USR_MODE;
  16. #ifdefCONFIG_ARM_THUMB
  17. if(elf_hwcap&HWCAP_THUMB){
  18. /*
  19. *TheLSBofthehandlerdeterminesifweregoingto
  20. *beusingTHUMBorARMmodeforthissignalhandler.
  21. */
  22. thumb=handler&1;
  24. if(thumb)
  25. cpsr|=PSR_T_BIT;
  26. else
  27. cpsr&=~PSR_T_BIT;
  28. }
  29. #endif
  30. //这里的retcode就是保存手工构造的sigreturn()代码
  31. if(ka->sa.sa_flags&SA_RESTORER){
  32. retcode=(unsignedlong)ka->sa.sa_restorer;
  33. }else{
  34. unsignedintidx=thumb;
  36. if(ka->sa.sa_flags&SA_SIGINFO)
  37. idx+=2;
  39. if(__put_user(sigreturn_codes[idx],rc))
  40. return1;
  42. if(cpsr&MODE32_BIT){
  43. /*
  44. *32-bitcodecanusethenewhigh-page
  45. *signalreturncodesupport.
  46. */
  47. retcode=KERN_SIGRETURN_CODE+(idx<<2)+thumb;
  48. }else{
  49. /*
  50. *Ensurethattheinstructioncachesees
  51. *thereturncodewrittenontothestack.
  52. */
  53. flush_icache_range((unsignedlong)rc,
  54. (unsignedlong)(rc+1));
  56. retcode=((unsignedlong)rc)+thumb;
  57. }
  58. }
  60. regs->ARM_r0=usig;
  61. regs->ARM_sp=(unsignedlong)frame;//堆栈
  62. regs->ARM_lr=retcode;//返回地址，当用户态信号处理函数结束时，就会把这个地址作为返回地址
  63. regs->ARM_pc=handler;//信号处理函数
  64. regs->ARM_cpsr=cpsr;
  66. return0;
  67. }

当setup_frame()返回后，一切准备就绪，因此可以从内核态返回了，这样就顺利过渡到用户态的信号处理函数。当这个函数处理结束后，会通过retcode再次进入内核态，现在我们看看retcode是如何处理的，下面的代码选自glibc(2.3.2)：

[plain]view plaincopy
print?
  1. #include
  3. /*IfnoSA_RESTORERfunctionwasspecifiedbytheapplicationweuse
  4. oneofthese.Thisavoidstheneedforthekerneltosynthesiseareturn
  5. instructiononthestack,whichwouldinvolveexpensivecacheflushes.*/
  7. ENTRY(__default_sa_restorer)
  8. swiSYS_ify(sigreturn)
  10. #ifdef__NR_rt_sigreturn
  12. ENTRY(__default_rt_sa_restorer)
  13. swiSYS_ify(rt_sigreturn)
  15. #defineSYS_ify(syscall_name)(__NR_##syscall_name)

下面具体看看sys_sigreturn()的定义：

[plain]view plaincopy
print?
  1. asmlinkageintsys_sigreturn(structpt_regs*regs)
  2. {
  3. structsigframe__user*frame;
  4. sigset_tset;
  6. /*Alwaysmakeanypendingrestartedsystemcallsreturn-EINTR*/
  7. current_thread_info()->restart_block.fn=do_no_restart_syscall;
  9. /*
  10. *Sincewestackedthesignalona64-bitboundary,
  11. *thenspshouldbewordalignedhere.Ifits
  12. *not,thentheuseristryingtomesswithus.
  13. */
  14. if(regs->ARM_sp&7)
  15. gotobadframe;
  17. frame=(structsigframe__user*)regs->ARM_sp;
  19. if(!access_ok(VERIFY_READ,frame,sizeof(*frame)))
  20. gotobadframe;
  21. if(__get_user(set.sig[0],&frame->sc.oldmask)
  22. ||(_NSIG_WORDS>1
  23. &&__copy_from_user(&set.sig[1],&frame->extramask,
  24. sizeof(frame->extramask))))
  25. gotobadframe;
  27. sigdelsetmask(&set,~_BLOCKABLE);
  28. spin_lock_irq(¤t->sighand->siglock);
  29. current->blocked=set;
  30. recalc_sigpending();
  31. spin_unlock_irq(¤tt->sighand->siglock);
  33. if(restore_sigcontext(regs,&frame->sc,&frame->aux))
  34. gotobadframe;
  36. /*SendSIGTRAPifweresingle-stepping*/
  37. if(current->ptrace&PT_SINGLESTEP){
  38. ptrace_cancel_bpt(current);
  39. send_sig(SIGTRAP,current,1);
  40. }
  42. returnregs->ARM_r0;
  44. badframe:
  45. force_sig(SIGSEGV,current);
  46. return0;
  47. }
这个函数主要调用restore_sigcontext()根据用户态态堆栈上的sigframe备份还原pt_regs。

[plain]view plaincopy
print?
  1. staticint
  2. restore_sigcontext(structpt_regs*regs,structsigcontext__user*sc,
  3. structaux_sigframe__user*aux)
  4. {
  5. interr=0;
  7. __get_user_error(regs->ARM_r0,&sc->arm_r0,err);
  8. __get_user_error(regs->ARM_r1,&sc->arm_r1,err);
  9. __get_user_error(regs->ARM_r2,&sc->arm_r2,err);
  10. __get_user_error(regs->ARM_r3,&sc->arm_r3,err);
  11. __get_user_error(regs->ARM_r4,&sc->arm_r4,err);
  12. __get_user_error(regs->ARM_r5,&sc->arm_r5,err);
  13. __get_user_error(regs->ARM_r6,&sc->arm_r6,err);
  14. __get_user_error(regs->ARM_r7,&sc->arm_r7,err);
  15. __get_user_error(regs->ARM_r8,&sc->arm_r8,err);
  16. __get_user_error(regs->ARM_r9,&sc->arm_r9,err);
  17. __get_user_error(regs->ARM_r10,&sc->arm_r10,err);
  18. __get_user_error(regs->ARM_fp,&sc->arm_fp,err);
  19. __get_user_error(regs->ARM_ip,&sc->arm_ip,err);
  20. __get_user_error(regs->ARM_sp,&sc->arm_sp,err);
  21. __get_user_error(regs->ARM_lr,&sc->arm_lr,err);
  22. __get_user_error(regs->ARM_pc,&sc->arm_pc,err);
  23. __get_user_error(regs->ARM_cpsr,&sc->arm_cpsr,err);
  25. err|=!valid_user_regs(regs);
  27. #ifdefCONFIG_IWMMXT
  28. if(err==0&&test_thread_flag(TIF_USING_IWMMXT))
  29. err|=restore_iwmmxt_context(&aux->iwmmxt);
  30. #endif
  31. #ifdefCONFIG_VFP
  32. //if(err==0)
  33. //err|=vfp_restore_state(&aux->vfp);
  34. #endif
  36. returnerr;
  37. }
restore_sigcontext()很简单，当它返回后，通过sys_sigreturn()在内核态堆栈建立的pt_regs已经变为调用信号处理函数之前的pt_regs。这样，sys_sigreturn()返回用户态时，就顺利地过渡到处理之前的状态了。

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

评论


相关推荐

技术专区

关闭