您的位置 首页 数字

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

2020年9月18日 14:43 阅读(339)

Kernelversion：2614CPUarchitecture：ARM920TAuthor：ce123(http:blogcsdnnetce123)当进程被调度时，会调用do_notify_res

Kernel version：2.6.14

CPU architecture：ARM920T

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(&current->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(&current->sighand->siglock);
  29. current->blocked=set;
  30. recalc_sigpending();
  31. spin_unlock_irq(&currentt->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()回来用户态时，就顺畅地过渡到处理之前的状况了。

声明：本文内容来自网络转载或用户投稿，文章版权归原作者和原出处所有。文中观点，不代表本站立场。若有侵权请联系本站删除（kf@86ic.com）https://www.86ic.net/zhishi/shuzi/262419.html
6赞
标签:

为您推荐

示波器并非千篇一律：ADC 和低本底噪声为何至关重要

激光与二级管

为什么A2B能够支持更复杂的新数据和音频传输系统

DC－DC 系统级电源设计

运用双MOSFET避免SEU的影响

如何找到一款更适合高压BMS解决方案

联系我们

联系我们

在线咨询: QQ交谈

邮箱: kf@86ic.com

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部