版权声明：本文参考@gityuan 袁神相关文章，转载请注明出处。
注：限于作者水平有限，文中有不对的地方还请指教。

本文基于Android 6.0，涉及源码如下：

/system/core/rootdir/init.rc
/system/core/rootdir/init.zygote32.rc
/system/core/init/init.cpp
/system/core/init/init_parser.cpp //解析各个服务都是靠它完成
/system/core/init/signal_handler.cpp

概述

Init 进程属于Linux系统中用户空间第一个进程，进程号（PID）为1；Linux Kernel启动后，就会在用户空间启动Init 进程，对于Init 进程，使用C++ 语言实现，所以该进程的入口函数是main()方法，在Android源码中源码位于：

/system/core/init/init.cpp

作为一个系统工程师，或多或少都知道Init.rc文件，我们可以通过该文件配置一些native 的守护进程，比如：servicemanager，installd，adbd，ueventd 等等；为何我们在该文件中的配置会在系统中有效，这就涉及到系统对于init.rc脚本的解析和执行；init.rc脚本的解析执行就是上述Init进程实现；Init 进程有如下几个功能：

    1. 解析并运行所有init.rc脚本。
    2. 生成设备驱动节点。
    3. 处理子进程终结（Signal方式）。
    4. 提供属性服务。

接下来从代码的角度来分析Init进程是具体做到上述功能的。
由于代码太长，将会提取部分关键代码并添加注释：

一：main 函数

1.1:init.cpp main函数

int main(int argc, char** argv) {
    ......
    add_environment("PATH", _PATH_DEFPATH); //添加path 环境变量
    open_devnull_stdio();
    klog_init();     //初始化Kernel Log
    property_init(); //创建一块共享的内存空间，用于属性服务
    selinux_initialize(is_first_stage); //初始化 selinux
    signal_handler_init();//初始化子进程终止处理
    property_load_boot_defaults(); //加载/default.prop文件
    start_property_service();   //启动属性服务器(通过socket通信)
    init_parse_config_file("/init.rc"); //解析init.rc文件

    action_for_each_trigger("early-init", action_add_queue_tail);//执行init.rc中触发器为on early-init的语句
    queue_builtin_action(console_init_action, "console_init");//屏幕上显示Android静态Logo 见1.2
    action_for_each_trigger("init", action_add_queue_tail);
    action_for_each_trigger("late-init", action_add_queue_tail);
 
    while (true) {
        if (!waiting_for_exec) {
            execute_one_command();
            restart_processes();//*启动有需要的进程
        }
        ......
        epoll_event ev;
        //循环 等待事件发生
        int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
        if (nr == -1) {
            ERROR("epoll_wait failed: %s\n", strerror(errno));
        } else if (nr == 1) {
            ((void (*)()) ev.data.ptr)();
        }
    }
    return 0;
}

1.2:console_init_action

开机显示的底部带ANDROID字样画面。

static int console_init_action(int nargs, char **args)
{
    int fd;
    if (console[0]) {
        snprintf(console_name, sizeof(console_name), "/dev/%s", console);
    }
    fd = open(console_name, O_RDWR);
    if (fd >= 0)
        have_console = 1;
    close(fd);
    fd = open("/dev/tty0", O_WRONLY);
    if (fd >= 0) {
        const char *msg;
            msg = "\n"
        "\n"
        "\n"
        "\n"
        "\n"
        "\n"
        "\n"  // console is 40 cols x 30 lines
        "\n"
        "\n"
        "\n"
        "\n"
        "\n"
        "\n"
        "\n"
        "             A N D R O I D ";//这就是Android 原声底部显示的字样，静态显示
        write(fd, msg, strlen(msg));
        close(fd);
    }
    return 0;
}

二：信号处理

 /system/core/init/signal_handler.cpp //第二节的所有内容都是在该文件

2.1:signal_handler_init

在init进程main 方法中，通过调用signal_handler_init 函数来初始化信号处理过程；signal_handler_init定义于：

void signal_handler_init() {
    // Create a signalling mechanism for SIGCHLD.
    int s[2];
    //sockerpair:调用一对已经存在的socke(socketpair是一个SysCall 命令)
    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 的fd 中写入数据，后面epoll 监控到socket 中的fd可读时，就会调用注册的函数去处理
    act.sa_flags = SA_NOCLDSTOP;//该标志表示init进程只有在子进程终止时才会收到SIGHCLD信号
    sigaction(SIGCHLD, &act, 0);
    reap_any_outstanding_children();
    register_epoll_handler(signal_read_fd, handle_signal); //初始化EPOLL，此处会调用handle_signal方法
}

每个进程在处理其他进程发送的signal信号的时候都会先去注册，当进程的运行状态或者进程死亡的时候会产生某种signal信号，Init进程是所有用户空间进程的父进程，当子进程终止的时候，会产生SIGCHLD信号，sigaction方法将SIGCHLD信号传递给sigaction 结构体；到此信号的处理过程就会结束。
对于具体的信号处理函数可以查看SIGCHLD_handler 实现，实质就是向上面的Socket 写数据；
当socket 的fd 中有数据后，epoll会调用注册的handle_signal来处理，具体可以参考该方法的实现；

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

handle_signal方法大概就是将socket fd中的数据读入到buf 中，然后调用 reap_any_outstanding_children来具体处理服务的退出以及重启工作；在该方法中，就是根据我们在init.rc脚本中的是否有定义各种标志来确定当服务挂掉后是否要重启，以及清理一些数据；reap_any_outstanding_children 具体会会调用wait_for_one_process方法来处理；

2.2:reap_any_outstanding_children()::wait_for_one_process()

static bool wait_for_one_process() {
    int status;
    pid_t pid = TEMP_FAILURE_RETRY(waitpid(-1, &status, 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);

    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.

    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);
    }
    //移除当前服务svc中的所有创建过的socket
    // Remove any sockets we may have created.
    for (socketinfo* si = svc->sockets; si; si = si->next) {
        char tmp[128];
        snprintf(tmp, sizeof(tmp), ANDROID_SOCKET_DIR"/%s", si->name);
        unlink(tmp);
    }
    //当flags为EXEC时，释放相应的服务
    if (svc->flags & SVC_EXEC) {
        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.
    //对于ONESHOT服务，使其进入disabled状态
    if ((svc->flags & SVC_ONESHOT) && !(svc->flags & SVC_RESTART)) {
        svc->flags |= SVC_DISABLED;
    }
    //禁用和重置的服务，都不再自动重启
    // Disabled and reset processes do not get restarted automatically.
    if (svc->flags & (SVC_DISABLED | SVC_RESET))  {
        svc->NotifyStateChange("stopped");
        return true;
    }
    //服务在4分钟内重启次数超过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;
  //执行当前service中所有onrestart命令
    list_for_each(node, &svc->onrestart.commands) {
        command* cmd = node_to_item(node, struct command, clist);
        cmd->func(cmd->nargs, cmd->args);
    }
    //设置相应的service状态为restarting
    svc->NotifyStateChange("restarting");
    return true;
}

该方法会根据init.rc脚本中各个服务的各种标志来进行相关操作；

2.3:register_epoll_handler 注册EPOLL

该方法在signal_handler.cpp中调用，但是在init.cpp 中定义。

void register_epoll_handler(int fd, void (*fn)()) {
    epoll_event ev;
    ev.events = EPOLLIN; //可读
    ev.data.ptr = reinterpret_cast<void*>(fn);
    //将fd中的数据添加到epoll 监听队列中
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
        ERROR("epoll_ctl failed: %s\n", strerror(errno));
    }
}

综上：init进程对子进程退出处理过程：当init子进程退出时，会产生SIGCHLD信号，并发送给init进程，通过socket套接字传递数据，调用到wait_for_one_process()方法，wait_for_one_process根据服务是否有oneshot，onrestart 等标识来进行后续的处理。具体的处理可以顺着该方法继续跟进。