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

structsignal_struct {
atomic_tcount;
structk_sigaction	action[_NSIG];//类似一个信号向量表,每个元素就是一个函数指针
spinlock_tsiglock;
};

structk_sigaction {
structsigaction sa;
};

structsigaction {
unsignedintsa_flags;
__sighandler_tsa_handler;
sigset_tsa_mask;
void(*sa_restorer)(void);
intsa_resv[1];/* reserved */
};

/* Fake signal functions */
#defineSIG_DFL	((__sighandler_t)0)/* default signal handling */
#defineSIG_IGN	((__sighandler_t)1)/* ignore signal */
#defineSIG_ERR	((__sighandler_t)-1)/* error return from signal */

structsigaction {
unsignedintsa_flags;
__sighandler_tsa_handler;
sigset_tsa_mask;//屏蔽,一个64位的类型
void(*sa_restorer)(void);
intsa_resv[1];/* reserved */
};

structsigqueue {
structsigqueue *next;
siginfo_tinfo;//挂载信号相关信息
};

/*
* Remove signal sig from t->pending.
* Returns 1 if sig was found.
*
* All callers must be holding t->sigmask_lock.
*/
staticintrm_sig_from_queue(intsig,structtask_struct *t)
{
returnrm_from_queue(sig,&t->pending);
}

staticintrm_from_queue(intsig,structsigpending *s)
{
structsigqueue *q,**pp;

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

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

pp =&s->head;

while((q =*pp)!=NULL){
if(q->info.si_signo ==sig){//如果队列中的信号等于sig(针对新类型信号)
if((*pp =q->next)==NULL)
s->tail =pp;
kmem_cache_free(sigqueue_cachep,q);//删除
atomic_dec(&nr_queued_signals);//-1
continue;
}
pp =&q->next;
}
return1;
}

asmlinkage long
sys_kill(intpid,intsig)
{
structsiginfo info;
//收集相关信息
info.si_signo =sig;//信号类型
info.si_errno =0;
info.si_code =SI_USER;//用户信号
info.si_pid =current->pid;//进程号
info.si_uid =current->uid;//uid

returnkill_something_info(sig,&info,pid);
}

/*
* kill_something_info() interprets pid in interesting ways just like kill(2).
*
* POSIX specifies that kill(-1,sig) is unspecified, but what we have
* is probably wrong.  Should make it like BSD or SYSV.
*/

staticintkill_something_info(intsig,structsiginfo *info,intpid)
{
if(!pid){//pid==0发送给当前进程的所有进程
returnkill_pg_info(sig,info,current->pgrp);
}elseif(pid ==-1){//发送到除当前进程以外的进程
intretval =0,count =0;
structtask_struct *p;

read_lock(&tasklist_lock);
for_each_task(p){
if(p->pid >1&&p !=current){
interr =send_sig_info(sig,info,p);
++count;
if(err !=-EPERM)
retval =err;
}
}
read_unlock(&tasklist_lock);
returncount ?retval :-ESRCH;
}elseif(pid <0){//小于值,则发送给-pid的进程组
returnkill_pg_info(sig,info,-pid);
}else{
returnkill_proc_info(sig,info,pid);//发送给具体的进程
}
}

inlineint
kill_proc_info(intsig,structsiginfo *info,pid_tpid)
{
interror;
structtask_struct *p;

read_lock(&tasklist_lock);
p =find_task_by_pid(pid);//找到pid对应的task_struct结构
error =-ESRCH;
if(p)
error =send_sig_info(sig,info,p);//发送信号
read_unlock(&tasklist_lock);
returnerror;
}

int//信号     信号相关信息           接收信号进程的pcb
send_sig_info(intsig,structsiginfo *info,structtask_struct *t)
{
unsignedlongflags;
intret;


#if DEBUG_SIG
printk("SIG queue (%s:%d): %d ",t->comm,t->pid,sig);
#endif

ret =-EINVAL;
if(sig <0||sig >_NSIG)//不在信号范围出错
gotoout_nolock;
/* The somewhat baroque permissions check... */
ret =-EPERM;
if(bad_signal(sig,info,t))//进行错误检查
gotoout_nolock;

/* The null signal is a permissions and process existance probe.
No signal is actually delivered.  Same goes for zombies. */
ret =0;
if(!sig ||!t->sig)//如果信号为0或者,不存在对应操作
gotoout_nolock;

spin_lock_irqsave(&t->sigmask_lock,flags);
handle_stop_signal(sig,t);//收到某些特定的信号,不可屏蔽一些其他后续信号,这个负责处理

/* Optimize away the signal, if it's a signal that can be
handled immediately (ie non-blocked and untraced) and
that is ignored (either explicitly or by default).  */

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

/* Support queueing exactly one non-rt signal, so that we
can get more detailed information about the cause of
the signal. */
if(sig <SIGRTMIN &&sigismember(&t->pending.signal,sig))
gotoout;//老编制的信号,投递,就是把接收信号位图设置为1,不用将信号挂到队列

ret =deliver_signal(sig,info,t);
out:
spin_unlock_irqrestore(&t->sigmask_lock,flags);
if((t->state &TASK_INTERRUPTIBLE)&&signal_pending(t))//如果接收的进程处于这个状态,
//而且有信号要处理,则唤醒进程
wake_up_process(t);
out_nolock:
#if DEBUG_SIG
printk(" %d -> %d
",signal_pending(t),ret);
#endif

returnret;
}

staticintdeliver_signal(intsig,structsiginfo *info,structtask_struct *t)
{
intretval =send_signal(sig,info,&t->pending);

if(!retval &&!sigismember(&t->blocked,sig))
signal_wake_up(t);

returnretval;
}

staticintsend_signal(intsig,structsiginfo *info,structsigpending *signals)
{
structsigqueue *q =NULL;//创建一个相关嘟列

/* Real-time signals must be queued if sent by sigqueue, or
some other real-time mechanism.  It is implementation
defined whether kill() does so.  We attempt to do so, on
the principle of least surprise, but since kill is not
allowed to fail with EAGAIN when low on memory we just
make sure at least one signal gets delivered and don't
pass on the info struct.  */

if(atomic_read(&nr_queued_signals)<max_queued_signals){
q =kmem_cache_alloc(sigqueue_cachep,GFP_ATOMIC);
}

if(q){
atomic_inc(&nr_queued_signals);
q->next =NULL;//新创建的,设置为null
*signals->tail =q;//指向尾部
signals->tail =&q->next;//
switch((unsignedlong)info){
case0:
q->info.si_signo =sig;
q->info.si_errno =0;
q->info.si_code =SI_USER;
q->info.si_pid =current->pid;
q->info.si_uid =current->uid;
break;
case1:
q->info.si_signo =sig;
q->info.si_errno =0;
q->info.si_code =SI_KERNEL;
q->info.si_pid =0;
q->info.si_uid =0;
break;
default:
copy_siginfo(&q->info,info);//拷贝相关信息,到队列
break;
}
}elseif(sig >=SIGRTMIN &&info &&(unsignedlong)info !=1
&&info->si_code !=SI_USER){
/*
* Queue overflow, abort.  We may abort if the signal was rt
* and sent by user using something other than kill().
*/
return-EAGAIN;
}

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

/*
* Note that 'init' is a special process: it doesn't get signals it doesn't
* want to handle. Thus you cannot kill init even with a SIGKILL even by
* mistake.
*/
intdo_signal(structpt_regs *regs,sigset_t*oldset)
{
siginfo_tinfo;
structk_sigaction *ka;

/*
* We want the common case to go fast, which
* is why we may in certain cases get here from
* kernel mode. Just return without doing anything
* if so.
*/
if((regs->xcs &3)!=3)
return1;

if(!oldset)//如果为0
oldset =&current->blocked;//获取其屏蔽信号

for(;;){
unsignedlongsignr;

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

if(!signr)//如果为0则跳出(因为表示当前没有这样的信号了)
break;
//如果当前
if((current->ptrace &PT_PTRACED)&&signr !=SIGKILL){
/* Let the debugger run.  */
current->exit_code =signr;
current->state =TASK_STOPPED;
notify_parent(current,SIGCHLD);
schedule();

/* We're back.  Did the debugger cancel the sig?  */
if(!(signr =current->exit_code))
continue;
current->exit_code =0;

/* The debugger continued.  Ignore SIGSTOP.  */
if(signr ==SIGSTOP)
continue;

/* Update the siginfo structure.  Is this good?  */
if(signr !=info.si_signo){
info.si_signo =signr;
info.si_errno =0;
info.si_code =SI_USER;
info.si_pid =current->p_pptr->pid;
info.si_uid =current->p_pptr->uid;
}

/* If the (new) signal is now blocked, requeue it.  */
if(sigismember(&current->blocked,signr)){
send_sig_info(signr,&info,current);
continue;
}
}

ka =&current->sig->action[signr-1];//获取信号向量
if(ka->sa.sa_handler ==SIG_IGN){//如果对应的处理是SIG_IGN
if(signr !=SIGCHLD)//忽略则继续取没屏蔽信号,处理
continue;
//是儿子信号则等待所有子进程退出
/* Check for SIGCHLD: it's special.  */
while(sys_wait4(-1,NULL,WNOHANG,NULL)>0)
/* nothing */;
continue;
}
//信号向量设置为SIG_DFL
if(ka->sa.sa_handler ==SIG_DFL){
intexit_code =signr;

/* Init gets no signals it doesn't want.  */
if(current->pid ==1)//不可以对init进程发送相关信号
continue;

switch(signr){
caseSIGCONT:caseSIGCHLD:caseSIGWINCH:
continue;//如果是SIGCONT之类,continue继续处理信号

caseSIGTSTP:caseSIGTTIN:caseSIGTTOU:
if(is_orphaned_pgrp(current->pgrp))
continue;
/* FALLTHRU */

caseSIGSTOP://如果是sigstop信号
current->state =TASK_STOPPED;//设置标志位
current->exit_code =signr;
if(!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags &SA_NOCLDSTOP))
notify_parent(current,SIGCHLD);
schedule();
continue;

caseSIGQUIT:caseSIGILL:caseSIGTRAP:
caseSIGABRT:caseSIGFPE:caseSIGSEGV:
caseSIGBUS:caseSIGSYS:caseSIGXCPU:caseSIGXFSZ:
if(do_coredump(signr,regs))//这类信号默认处理
exit_code |=0x80;
/* FALLTHRU */

default://多数信号的默认处理
sigaddset(&current->pending.signal,signr);//猜想设置此位表示默认处理,留给父进程查看信息
recalc_sigpending(current);//检查进程是否有非阻塞的挂起信号
current->flags |=PF_SIGNALED;
do_exit(exit_code);//结束接收信号的进程
/* NOTREACHED */
}
}

/* Reenable any watchpoints before delivering the
* signal to user space. The processor register will
* have been cleared if the watchpoint triggered
* inside the kernel.
*/
__asm__("movl %0,%%db7"::"r"(current->thread.debugreg[7]));

/* Whee!  Actually deliver the signal.  */
handle_signal(signr,ka,&info,oldset,regs);
return1;
}

/* Did we come from a system call? */
if(regs->orig_eax >=0){
/* Restart the system call - no handlers present */
if(regs->eax ==-ERESTARTNOHAND ||
regs->eax ==-ERESTARTSYS ||
regs->eax ==-ERESTARTNOINTR){
regs->eax =regs->orig_eax;
regs->eip -=2;
}
}
return0;
}