Android -- Init进程对信号的处理流程

在Android中，当一个进程退出（exit()）时，会向它的父进程发送一个SIGCHLD信号。父进程收到该信号后，会释放分配给该子进程的系统资源；并且父进程需要调用wait()或waitpid()等待子进程结束。如果父进程没有做这种处理，且父进程初始化时也没有调用signal(SIGCHLD, SIG_IGN)来显示忽略对SIGCHLD的处理，这时子进程将一直保持当前的退出状态，不会完全退出。这样的子进程不能被调度，所做的只是在进程列表中占据一个位置，保存了该进程的PID、终止状态、CPU使用时间等信息；我们将这种进程称为“Zombie”进程，即僵尸进程。

在Linux中，设置僵尸进程的目的是维护子进程的一些信息，以供父进程后续查询获取。特殊的，如果一个父进程终止，那么它的所有僵尸子进程的父进程将被设置为Init进程（PID为1），并由Init进程负责回收这些僵尸进程（Init进程将wait()/waitpid()它们，并清除它们在进程列表中的信息）。

由于僵尸进程仍会在进程列表中占据一个位置，而Linux所支持的最大进程数量是有限的；超过这个界限值后，我们就无法创建进程。所以，我们有必要清理那些僵尸进程，以保证系统的正常运作。

接下来，我们分析下Init进程是如何处理SIGCHLD信号的。

在Init.cpp中，我们是通过signal_handler_init()来初始化SIGCHLD信号处理的：

void signal_handler_init() {
    // Create a signalling mechanism for SIGCHLD.
    int s[2];
	//socketpair()创造一对未命名的、相互连接的UNIX域套接字
    if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, s) == -1) {
        ERROR("socketpair failed: %s\n", strerror(errno));
        exit(1);
    }

    signal_write_fd = s[0];
    signal_read_fd = s[1];

    // Write to signal_write_fd if we catch SIGCHLD.
    struct sigaction act;
    memset(&act, 0, sizeof(act));
    act.sa_handler = SIGCHLD_handler;//设置信号处理函数句柄,当有信号产生时,会向上面创建的socket写入数据,epoll监控到该socket对中的fd可读时,就会调用注册的函数去处理该事件
    act.sa_flags = SA_NOCLDSTOP;//设置标志,表示只有当子进程终止时才接受SIGCHID信号
    sigaction(SIGCHLD, &act, 0);//初始化SIGCHLD信号处理方式

    reap_any_outstanding_children();//处理这之前退出的子进程
    register_epoll_handler(signal_read_fd, handle_signal);
}

Linux中，信号是一种软中断，所以信号的到来会终止当前进程正在处理的操作。所以，我们在注册的信号处理函数中不要调一些不可重入的函数。并且，Linux不会对信号做排队处理，在一个信号的处理期间不管再收到多少个信号，当前信号处理完毕后，内核也只会再发送一个信号给进程；所以这里就存在信号丢失的可能。为了避免丢失信号，我们注册的信号处理函数操作应该越高效、越快越好。

而我们处理SIGCHLD信号时，父进程会做等待操作，这个时间是比较长的。为了解决这个问题，上面的信号初始化代码中创建了一对未命名且相关联的本地socket用于线程间通信。注册的信号处理函数是SIGCHLD_handler()：

static void SIGCHLD_handler(int) {
    if (TEMP_FAILURE_RETRY(write(signal_write_fd, "1", 1)) == -1) {
        ERROR("write(signal_write_fd) failed: %s\n", strerror(errno));
    }
}

#define TEMP_FAILURE_RETRY(exp)              ({                                           decltype(exp) _rc;                         do {                                         _rc = (exp);                             } while (_rc == -1 && errno == EINTR);     _rc;                                     })

static void reap_any_outstanding_children() {
    while (wait_for_one_process()) {
    }
}

最后，通过epoll_ctl()向epoll_fd注册本地socket，监听其是否可读；并注册了epoll事件的处理函数：

register_epoll_handler(signal_read_fd, handle_signal);

void register_epoll_handler(int fd, void (*fn)()) {
    epoll_event ev;
    ev.events = EPOLLIN;//对文件描述符可读
    ev.data.ptr = reinterpret_cast<void*>(fn);//保存指定的函数指针,用于后续的事件处理
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {//向epoll_fd添加要监听的fd,比如property、keychord和signal事件监听
        ERROR("epoll_ctl failed: %s\n", strerror(errno));
    }
}

static void handle_signal() {
    // Clear outstanding requests.
    char buf[32];
    read(signal_read_fd, buf, sizeof(buf));

    reap_any_outstanding_children();
}

static void reap_any_outstanding_children() {
    while (wait_for_one_process()) {
    }
}

static bool wait_for_one_process() {
    int status;
    pid_t pid = TEMP_FAILURE_RETRY(waitpid(-1, &status, WNOHANG));//等待子进程结束,并获取到它的pid进程号,WNOHANG表明若没有进程结束,则立即返回.
    if (pid == 0) {
        return false;
    } else if (pid == -1) {
        ERROR("waitpid failed: %s\n", strerror(errno));
        return false;
    }

    service* svc = service_find_by_pid(pid);//根据pid,在链表中找到这个服务信息

    std::string name;
    if (svc) {
        name = android::base::StringPrintf("Service ‘%s‘ (pid %d)", svc->name, pid);
    } else {
        name = android::base::StringPrintf("Untracked pid %d", pid);
    }

    NOTICE("%s %s\n", name.c_str(), DescribeStatus(status).c_str());

    if (!svc) {
        return true;
    }

    // TODO: all the code from here down should be a member function on service.
	//如果该服务进程没有设定SVC_ONESHOT标志,或者设置了SVC_RESTART标志,则先杀掉当前的进程,在重新创建新的进程;
	//以避免后面重启进程时,因当前服务进程已经存在而发生错误.
    if (!(svc->flags & SVC_ONESHOT) || (svc->flags & SVC_RESTART)) {
        NOTICE("Service ‘%s‘ (pid %d) killing any children in process group\n", svc->name, pid);
        kill(-pid, SIGKILL);
    }

    // Remove any sockets we may have created.
    //如果之前为这个服务进程创建过socket,这时我们需要清除掉该socket
    for (socketinfo* si = svc->sockets; si; si = si->next) {
        char tmp[128];
        snprintf(tmp, sizeof(tmp), ANDROID_SOCKET_DIR"/%s", si->name);
        unlink(tmp);//删除这个socket设备文件
    }

    if (svc->flags & SVC_EXEC) {////服务完全退出,清除掉所有信息,并将该服务从svc-slist中移除
        INFO("SVC_EXEC pid %d finished...\n", svc->pid);
        waiting_for_exec = false;
        list_remove(&svc->slist);
        free(svc->name);
        free(svc);
        return true;
    }

    svc->pid = 0;
    svc->flags &= (~SVC_RUNNING);

    // Oneshot processes go into the disabled state on exit,
    // except when manually restarted.
    //如果该服务进程带有SVC_ONESHOT标志,且没有SVC_RESTART标志,则表明该服务无需重启
    if ((svc->flags & SVC_ONESHOT) && !(svc->flags & SVC_RESTART)) {
        svc->flags |= SVC_DISABLED;
    }

    // Disabled and reset processes do not get restarted automatically.
    //如果服务带有SVC_RESET标志,表示服务无需重启
    if (svc->flags & (SVC_DISABLED | SVC_RESET))  {//从结果看SVC_RESET标志的判断优先级最高
        svc->NotifyStateChange("stopped");
        return true;
    }

	//到此,我们可以得知一个服务进程在init.rc中只要没有声明SVC_ONESHOT和SVC_RESET标志,当该进程死亡时，就会被重启;
	//但是,如果一个服务进程带有SVC_CRITICAL标志,且没有SVC_RESTART标志,当它crash、重启的次数超过4此时,系统会自动重启并进入recovery模式
    time_t now = gettime();
    if ((svc->flags & SVC_CRITICAL) && !(svc->flags & SVC_RESTART)) {
        if (svc->time_crashed + CRITICAL_CRASH_WINDOW >= now) {
            if (++svc->nr_crashed > CRITICAL_CRASH_THRESHOLD) {
                ERROR("critical process ‘%s‘ exited %d times in %d minutes; "
                      "rebooting into recovery mode\n", svc->name,
                      CRITICAL_CRASH_THRESHOLD, CRITICAL_CRASH_WINDOW / 60);
                android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
                return true;
            }
        } else {
            svc->time_crashed = now;
            svc->nr_crashed = 1;
        }
    }

    svc->flags &= (~SVC_RESTART);
    svc->flags |= SVC_RESTARTING;//为服务加上重启标志,表明它需要重启;后续工作要以此判断

    // Execute all onrestart commands for this service.
    struct listnode* node;
    list_for_each(node, &svc->onrestart.commands) {//如果服务有onrestart选项,则遍历进程重启时需要执行的命令列表,并执行
        command* cmd = node_to_item(node, struct command, clist);
        cmd->func(cmd->nargs, cmd->args);
    }
    svc->NotifyStateChange("restarting");
    return true;
}

1. 调用waitpid()等待子进程结束，waitpid()的返回值就是子进程的进程号。如果没有子进程退出，由于设置了WONHANG标志，waitpid()就会立即返回而不会挂起。嵌套的TEMP_FAILURE_RETRY()含义与之前介绍的类似，当waitpid()返回错误且错误码是EINTR，将重复调用waitpid()。
2. 根据pid，从service_list列表中找到对应进程对应的service信息。如果该服务进程的定义在init.rc中没有设定SVC_ONESHOT标志,或者设置了SVC_RESTART标志,则先杀掉当前的进程,再重新创建新的进程；以避免后面重新创建进程时,因当前服务进程已经存在而发生错误。
3. 如果为当前服务创建了socket，则清除这个socket。
4. 如果该服务进程带有SVC_ONESHOT标志,且没有SVC_RESTART标志,则表明该服务无需重启。
5. 如果服务带有SVC_RESET标志,表示服务无需重启。
6. 如果一个服务进程带有SVC_CRITICAL标志,且没有SVC_RESTART标志,当它crash、重启的次数超过4此时,系统会自动重启并进入recovery模式。
7. 如果服务判断为需要重启，则为该服务加上重启标志SVC_RESTARTING,表明它需要重新启动;后续工作要以此判断。//重要
   
8. 最后，如果服务有onrestart选项,则遍历服务重启时需要执行的命令列表,并执行这些命令

如果这个子进程所代表的服务需要重启，则会为该服务加上SVC_RESTARTING标志。

在之前介绍Init进程初始化流程时，我们分析过，当Init进程处理完，它就会进入一个循环化身为守护进程，处理signal、property和keychord等服务：

   while (true) {
        if (!waiting_for_exec) {
            execute_one_command();//执行命令列表中的命令
            restart_processes();//启动服务列表中的进程
        }

        int timeout = -1;
        if (process_needs_restart) {
            timeout = (process_needs_restart - gettime()) * 1000;
            if (timeout < 0)
                timeout = 0;
        }

        if (!action_queue_empty() || cur_action) {
            timeout = 0;
        }

        bootchart_sample(&timeout);//bootchart是一个用可视化方式对启动过程进行性能分析的工具;需要定时唤醒进程

        epoll_event ev;
        int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));//开始轮询,epoll_wait()等待事件产生
        if (nr == -1) {
            ERROR("epoll_wait failed: %s\n", strerror(errno));
        } else if (nr == 1) {
            ((void (*)()) ev.data.ptr)();//调用epoll_event事件存储的函数指针处理事件
        }
    }

static void restart_processes()
{
    process_needs_restart = 0;
    service_for_each_flags(SVC_RESTARTING,
                           restart_service_if_needed);
}

void service_for_each_flags(unsigned matchflags,
                            void (*func)(struct service *svc))
{
    struct listnode *node;
    struct service *svc;
    list_for_each(node, &service_list) {
        svc = node_to_item(node, struct service, slist);
        if (svc->flags & matchflags) {
            func(svc);
        }
    }
}

static void restart_service_if_needed(struct service *svc)
{
    time_t next_start_time = svc->time_started + 5;

    if (next_start_time <= gettime()) {
        svc->flags &= (~SVC_RESTARTING);
        service_start(svc, NULL);
        return;
    }

    if ((next_start_time < process_needs_restart) ||
        (process_needs_restart == 0)) {
        process_needs_restart = next_start_time;
    }
}

Android -- Init进程对信号的处理流程