注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

Tsecer的回音岛

Tsecer的博客

 
 
 

日志

 
 

waitpid之status意义解析  

2012-04-23 22:58:51|  分类: Linux内核 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
一、和子进程同步
在linux系统中,父进程通常需要通过waitpid来等待/获取子进程状态变化情况,而这个主要就是通过waitXXX函数族来实现的,例如常见的init函数实现的respawn类配置进程(例如getty)、调试器中对子进程状态的获取,shell对同步子进程状态的监控和获取,以及通常我们工程中使用的子进程和父进程之间的通讯等。
我们在linux下man 一下waitpid,可以看到有下面三个比较常用的函数
YNOPSIS
       #include <sys/types.h>
       #include <sys/wait.h>
       pid_t wait(int *status);
       pid_t waitpid(pid_t pid, int *status, int options);
       int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
‘它们的共同特点就是提供给操作系统一个用户态指针,然后由内核来填充这个值,这里子进程的返回值并不是通过waitpid函数本身的返回值决定,因为waitpid并不总是返回成功,如果传入的pid非法,那么可能返回负数,所以子进程的真正退出情况需要另外提供参数来完成。
可以看到,这个返回值是一个int类型的内存地址,所以父进程和子进程之间所有的状态交互都要通过这个int来表示,这个int如何编码就比较重要了,和IP地址一样,它是比较紧凑的,或者说是比较拥挤的。
二、子进程通过exit退出
这个一般来说相当于正常退出,至少说不是由于不可抗拒的外力导致的退出,例如被SIGKILL杀死,收到SIGPIPE信号的,它的退出时主动退出,也算是个善终。这类错误码直通内核,然后内核中转在返还给用户态的waitpid,这条路还算是通畅,但是内核也是经过了简单加工,因为内核的最低8bits是用来供信号使用的,而真正的exit返回值记录在高8bits,而且只能占用8bits,这意味着如果exit的返回值过大,waitpid并不能够看到,
linux-2.6.37.1\kernel\exit.c
SYSCALL_DEFINE1(exit_group, int, error_code)
{
    do_group_exit((error_code & 0xff) << 8);
    /* NOTREACHED */
    return 0;
}
do_group_exit---.>>>do_exit
tsk->exit_code = code;
对于通过exit退出进程,它首先会成为僵尸进程(tsk->state = TASK_DEAD 并且 tsk->exit_state = EXIT_ZOMBIE),等待父进程通过waitXXX来回收。父进程就通过
SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options)---->>>SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr, int, options, struct rusage __user *, ru)---->>>do_wait---->>>do_wait_thread--->>>wait_consider_task---->>>wait_task_zombie

    status = (p->signal->flags & SIGNAL_GROUP_EXIT)
        ? p->signal->group_exit_code : p->exit_code;
    if (!retval && wo->wo_stat)
        retval = put_user(status, wo->wo_stat);
所以子进程的返回值就是这么确定的,它的低8位为零,次低8位为真正退出码。
[tsecer@Harry waitstat]$ cat exitcode.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
pid_t forker;
if(0 == (forker = fork()))
{
        exit(0x12345678);
}else if ((pid_t)0 > forker)
{
           perror("fork faile\n");
} else {
          int status;
          waitpid(forker,&status,0);
         printf("exit status is %x\n",status);
}
}

[tsecer@Harry waitstat]$ gcc exitcode.c -o exitcode.exe
[tsecer@Harry waitstat]$ ./exitcode.exe
exit status is 7800           可以看到返回值只有最低6bits生效,其它丢失
[tsecer@Harry waitstat]$
三、信号导致退出
这个也比较常见,应该是仅次于exit退出的一个任务消亡方法。如果不安装信号处理函数,通常的信号都是致命的,例如段错误SIGSEGV、非法指令SIGILL、管道断裂SIGPIPE、程序流产SIGABORT等,这些父进程也需要知道原因。
在status的低7bits用来保存进程结束时受到的信号,所以信号最多能够有127个,例如MIPS系统。
get_signal_to_deliver---->>>do_group_exit(info->si_signo)--->>>do_exit(exit_code)
之后的流程和前一个相同。但是在信号退出的时候,这个地方修改了返回值的意义
do_group_exit(int exit_code)
{
    struct signal_struct *sig = current->signal;

    BUG_ON(exit_code & 0x80); /* core dumps don't get here */

    if (signal_group_exit(sig))
        exit_code = sig->group_exit_code;
    else if (!thread_group_empty(current)) {
        struct sighand_struct *const sighand = current->sighand;
        spin_lock_irq(&sighand->siglock);
        if (signal_group_exit(sig))
            /* Another thread got here before we took the lock.  */
            exit_code = sig->group_exit_code;
        else {
            sig->group_exit_code = exit_code;
            sig->flags = SIGNAL_GROUP_EXIT;这两个将会影响到最后status的返回值
            zap_other_threads(current);
        }
        spin_unlock_irq(&sighand->siglock);
    }

    do_exit(exit_code);
    /* NOTREACHED */
}
再次把前一节中的赋值操作拷贝一下
    status = (p->signal->flags & SIGNAL_GROUP_EXIT)
        ? p->signal->group_exit_code : p->exit_code;此时满足前一个条件,返回值的低7bits为导致进程退出信号数值
    if (!retval && wo->wo_stat)
        retval = put_user(status, wo->wo_stat);
同样是上面代码,在子进程中制造访问异常
[tsecer@Harry waitstat]$ cat exitcode.fault.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
pid_t forker;
if(0 == (forker = fork()))
{
    *(int*)0 = 0;
        exit(0x12345678);
}else if ((pid_t)0 > forker)
{
perror("fork faile\n");
} else {
int status;
waitpid(forker,&status,0);
printf("exit status is %x\n",status);
}
}

[tsecer@Harry waitstat]$ gcc exitcode.fault.c -o exitcode.fault.c.exe
[tsecer@Harry waitstat]$ ./exitcode.fault.c.exe
exit status is 8b  低7bits表示导致任务退出的信号数值,SIGSEGV=11,最高一个bit表示是否生成coredump文件
[tsecer@Harry waitstat]$
coredump文件设置的位置为
int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie)
        if (sig_kernel_coredump(signr)) {
            if (print_fatal_signals)
                print_fatal_signal(regs, info->si_signo);
            /*
             * If it was able to dump core, this kills all
             * other threads in the group and synchronizes with
             * their demise.  If we lost the race with another
             * thread getting here, it set group_exit_code
             * first and our do_group_exit call below will use
             * that value and ignore the one we pass it.
             */
            do_coredump(info->si_signo, info->si_signo, regs);
        }

do_coredump
    if (retval)
        current->signal->group_exit_code |= 0x80;
四、进程状态变化
一般是进程转换为STOPPED或者CONTINUED,父进程默认会收到这些信号,这一点可以在注册信号处理函数的时候屏蔽掉这种行为,注册SIGCHLD的时候通过SA_NOCLDSTOP来拒绝当进程变化时接收信号;而父进程默认不会在STOP和CONTINUE的时候唤醒,需要在waitpid的最后一个参数中分别设置WUNTRACED和WCONTINUED标志
get_signal_to_deliver--->>>do_signal_stop
if (!sig->group_stop_count) {
        struct task_struct *t;

        if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
            unlikely(signal_group_exit(sig)))
            return 0;
        /*
         * There is no group stop already in progress.
         * We must initiate one now.
         */
        sig->group_exit_code = signr;
}
……
    if (notify) {
        read_lock(&tasklist_lock);
        do_notify_parent_cldstop(current, notify);
        read_unlock(&tasklist_lock);
    }
对于waitpid系统调用
static int wait_task_stopped(struct wait_opts *wo,  int ptrace, struct task_struct *p)

    p_code = task_stopped_code(p, ptrace);///return &p->signal->group_exit_code;此处返回前面赋值的信号
……
    if (!retval && wo->wo_stat)
        retval = put_user((exit_code << 8) | 0x7f, wo->wo_stat);
也就是低8bits为0x7f,次低8bits为导致任务STOP的信号,这个信号不仅有SIGSTOP,还有SIGTIN和SIGTOUT(大家可以看一下sig_kernel_stop的实现)。

测试程序
[tsecer@Harry waitstat]$ cat exitcode.stop.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>

int main()
{
pid_t forker;
if(0 == (forker = fork()))
{
    setpgrp();
    char buf[0x10];
    while(1) { sleep (1) ;read(0,buf,sizeof(buf));}
    //sleep(10000);
        exit(0x12345678);
}else if ((pid_t)0 > forker)
{
perror("fork faile\n");
} else {
int status;
while (1) {
waitpid(forker,&status,WUNTRACED|WCONTINUED);
printf("exit status is %x\n",status);
}}
}

[tsecer@Harry waitstat]$ gcc exitcode.stop.c -o exitcode.stop.c.exe -static
[tsecer@Harry waitstat]$ ./exitcode.stop.c.exe &      后台运行,所以子进程的read触发SIGTTIN信号,其中SIGTTIN在386系统中为21=0x15
[6] 15452
[tsecer@Harry waitstat]$ exit status is 157f     高byte为信号SIGTTIN,低byte为7f,这个是一个绝对值

[tsecer@Harry waitstat]$ kill -SIGCONT 15453 这个在FC的31内核没有显示CONTINUE对应的0xffff,在2.6.37中有显示,没有追究原因
[tsecer@Harry waitstat]$ exit status is 157f
其中WUNTRACED和WCONTINUED分别在2.6.37内核下面位置使用:
static int wait_task_continued(struct wait_opts *wo, struct task_struct *p)
{
    int retval;
    pid_t pid;
    uid_t uid;

    if (!unlikely(wo->wo_flags & WCONTINUED))
        return 0;
……
}
static int wait_task_stopped(struct wait_opts *wo,
                int ptrace, struct task_struct *p)
{
    struct siginfo __user *infop;
    int retval, exit_code, *p_code, why;
    uid_t uid = 0; /* unneeded, required by compiler */
    pid_t pid;

    /*
     * Traditionally we see ptrace'd stopped tasks regardless of options.
     */
    if (!ptrace && !(wo->wo_flags & WUNTRACED))
        return 0;
……
}
五、C库对返回值的封装
为了避免用户直接判断waitpid的返回值,C库定义了一些宏来判断返回值,有兴趣的同学可以结合之前说明对应一下。
glibc-2.7\posix\sys\wait.h
# define WEXITSTATUS(status)    __WEXITSTATUS(__WAIT_INT(status))
# define WTERMSIG(status)    __WTERMSIG(__WAIT_INT(status))
# define WSTOPSIG(status)    __WSTOPSIG(__WAIT_INT(status))
# define WIFEXITED(status)    __WIFEXITED(__WAIT_INT(status))
# define WIFSIGNALED(status)    __WIFSIGNALED(__WAIT_INT(status))
# define WIFSTOPPED(status)    __WIFSTOPPED(__WAIT_INT(status))
# ifdef __WIFCONTINUED
#  define WIFCONTINUED(status)    __WIFCONTINUED(__WAIT_INT(status))
glibc-2.7\bits\waitstatus.h
/* Everything extant so far uses these same bits.  */


/* If WIFEXITED(STATUS), the low-order 8 bits of the status.  */
#define    __WEXITSTATUS(status)    (((status) & 0xff00) >> 8)

/* If WIFSIGNALED(STATUS), the terminating signal.  */
#define    __WTERMSIG(status)    ((status) & 0x7f)

/* If WIFSTOPPED(STATUS), the signal that stopped the child.  */
#define    __WSTOPSIG(status)    __WEXITSTATUS(status)

/* Nonzero if STATUS indicates normal termination.  */
#define    __WIFEXITED(status)    (__WTERMSIG(status) == 0)

/* Nonzero if STATUS indicates termination by a signal.  */
#define __WIFSIGNALED(status) \
  (((signed char) (((status) & 0x7f) + 1) >> 1) > 0)

/* Nonzero if STATUS indicates the child is stopped.  */
#define    __WIFSTOPPED(status)    (((status) & 0xff) == 0x7f)

/* Nonzero if STATUS indicates the child continued after a stop.  We only
   define this if <bits/waitflags.h> provides the WCONTINUED flag bit.  */
#ifdef WCONTINUED
# define __WIFCONTINUED(status)    ((status) == __W_CONTINUED)
#endif

/* Nonzero if STATUS indicates the child dumped core.  */
#define    __WCOREDUMP(status)    ((status) & __WCOREFLAG)

/* Macros for constructing status values.  */
#define    __W_EXITCODE(ret, sig)    ((ret) << 8 | (sig))
#define    __W_STOPCODE(sig)    ((sig) << 8 | 0x7f)
#define __W_CONTINUED        0xffff
#define    __WCOREFLAG        0x80
  评论这张
 
阅读(3412)| 评论(5)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017