整个Android系统的启动分为Linux kernel的启动和Android系统的启动。Linux kernel启动起来后，然后就运行第一个用户程序，在Android中，就是init程序，上一博文已经介绍。

Init进程始终是第一个进程。Init进程的对应的代码的main函数在目录system/core/init/init.c，先来总体看一下这个main函数。

main函数

int main(int argc, char **argv)
{
    //首先声明一些局部变量
    int fd_count = 0;
    struct pollfd ufds[4];
    char *tmpdev;
    char* debuggable;
    char tmp[32];
    int property_set_fd_init = 0;
    int signal_fd_init = 0;
    int keychord_fd_init = 0;
    bool is_charger = false;

    //对传入的argv[0]进行判断，决定程序的执行分支
    if (!strcmp(basename(argv[0]), "ueventd"))
        return ueventd_main(argc, argv);

    if (!strcmp(basename(argv[0]), "watchdogd"))
        return watchdogd_main(argc, argv);

    /* clear the umask */
    umask(0);

        /* Get the basic filesystem setup we need put
         * together in the initramdisk on / and then we‘ll
         * let the rc file figure out the rest.
         */
    //建立各种用户空间的目录，挂载与内核空间交互的文件
    mkdir("/dev", 0755);
    mkdir("/proc", 0755);
    mkdir("/sys", 0755);

    mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
    mkdir("/dev/pts", 0755);
    mkdir("/dev/socket", 0755);
    mount("devpts", "/dev/pts", "devpts", 0, NULL);
    mount("proc", "/proc", "proc", 0, NULL);
    mount("sysfs", "/sys", "sysfs", 0, NULL);

    /* indicate that booting is in progress to background fw loaders, etc */
    //创建打开/dev/.booting文件，然后关闭
    close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));

        /* We must have some place other than / to create the
         * device nodes for kmsg and null, otherwise we won‘t
         * be able to remount / read-only later on.
         * Now that tmpfs is mounted on /dev, we can actually
         * talk to the outside world.  
         */
    //system/core/init/util.c。创建设备节点/dev/__null__，利用dup2函数把标准输入、标准输出、标准错误输出重定向到这个设备文件中（0标准输入、1标准输出、2标准错误输出）。重定向操作完成后，就关闭掉fd。
    open_devnull_stdio();
    //system/core/libcutils/klog.c。初始化log系统/dev/__kmsg__
    klog_init();
    //system/core/init/property_service.c。初始化资源/dev/__properties__，主要是映射一些内存空间
    property_init();
    //取得硬件名,hardware通过内核命令行提供或/proc/cpuinfo文件中提供。import /init.${ro.hardware}.rc
    get_hardware_name(hardware, &revision);
    //使用import_kernel_cmdline函数导入内核变量，调用export_kernel_boot_props函数通过属性设置内核变量。就是来回设置一些属性值，包括hardware变量，在此处又通过ro.boot.hardware属性设置了一次值。
    process_kernel_cmdline();

#ifdef HAVE_SELINUX
    //SELinux(Security-Enhanced Linux) 是美国国家安全局（NSA）对于强制访问控制的实现，它是个经过安全强化的Linux操作系统，很多时候是被关闭的。
    union selinux_callback cb;
    cb.func_log = klog_write;
    selinux_set_callback(SELINUX_CB_LOG, cb);

    cb.func_audit = audit_callback;
    selinux_set_callback(SELINUX_CB_AUDIT, cb);

    INFO("loading selinux policy\n");
    if (selinux_enabled) {
        if (selinux_android_load_policy() < 0) {
            selinux_enabled = 0;
            INFO("SELinux: Disabled due to failed policy load\n");
        } else {
            selinux_init_all_handles();
        }
    } else {
        INFO("SELinux:  Disabled by command line option\n");
    }
    /* These directories were necessarily created before initial policy load
     * and therefore need their security context restored to the proper value.
     * This must happen before /dev is populated by ueventd.
     */
    restorecon("/dev");
    restorecon("/dev/socket");
#endif

    is_charger = !strcmp(bootmode, "charger");
    INFO("property init\n");
    if (!is_charger)
        property_load_boot_defaults();

    INFO("reading config file\n");
    //system/core/init/init_parser.c。读取并且解析init.rc文件
    init_parse_config_file("/init.rc");

    //system/core/init/init_parser.c。触发在init脚本文件中名字为early-init的action，并且执行其commands，其实是.rc文件中的: on early-init
    action_for_each_trigger("early-init", action_add_queue_tail);

    //system/core/init/init_parser.c。内建action并添加到action_queue中，到execute_one_command()中检测执行。
    queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
    queue_builtin_action(keychord_init_action, "keychord_init");
    //显示第二个开机画面
    queue_builtin_action(console_init_action, "console_init");

    /* execute all the boot actions to get us started */
    action_for_each_trigger("init", action_add_queue_tail);

    /* skip mounting filesystems in charger mode */
    if (!is_charger) {
        action_for_each_trigger("early-fs", action_add_queue_tail);
        action_for_each_trigger("fs", action_add_queue_tail);
        action_for_each_trigger("post-fs", action_add_queue_tail);
        action_for_each_trigger("post-fs-data", action_add_queue_tail);
    }

    queue_builtin_action(property_service_init_action, "property_service_init");
    queue_builtin_action(signal_init_action, "signal_init");
    queue_builtin_action(check_startup_action, "check_startup");

    if (is_charger) {
        action_for_each_trigger("charger", action_add_queue_tail);
    } else {
        action_for_each_trigger("early-boot", action_add_queue_tail);
        action_for_each_trigger("boot", action_add_queue_tail);
    }

     /* run all property triggers based on current state of the properties */
    queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");

#if BOOTCHART
    queue_builtin_action(bootchart_init_action, "bootchart_init");
#endif

//进入一个无限循环 to wait for device/property set/child process exit events.例如, 如果SD卡被插入，init会收到一个设备插入事件，它会为这个设备创建节点。系统中比较重要的进程都是由init来fork的，所以如果他们谁崩溃 了，那么init 将会收到一个 SIGCHLD 信号，把这个信号转化为子进程退出事件， 所以在loop中，init 会操作进程退出事件并且执行 *.rc 文件中定义的命令。
    for(;;) {
        int nr, i, timeout = -1;
        //执行action_queue中的action，并将此action移除
        execute_one_command();
        //检查service_list是否有进程需要重启
        restart_processes();

        if (!property_set_fd_init && get_property_set_fd() > 0) {
            ufds[fd_count].fd = get_property_set_fd();
            ufds[fd_count].events = POLLIN;
            ufds[fd_count].revents = 0;
            fd_count++;
            property_set_fd_init = 1;
        }
        if (!signal_fd_init && get_signal_fd() > 0) {
            ufds[fd_count].fd = get_signal_fd();
            ufds[fd_count].events = POLLIN;
            ufds[fd_count].revents = 0;
            fd_count++;
            signal_fd_init = 1;
        }
        if (!keychord_fd_init && get_keychord_fd() > 0) {
            ufds[fd_count].fd = get_keychord_fd();
            ufds[fd_count].events = POLLIN;
            ufds[fd_count].revents = 0;
            fd_count++;
            keychord_fd_init = 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是一个性能统计工具，用于搜集硬件和系统的信息，并将其写入磁盘，以便其他程序使用
#if BOOTCHART
        if (bootchart_count > 0) {
            if (timeout < 0 || timeout > BOOTCHART_POLLING_MS)
                timeout = BOOTCHART_POLLING_MS;
            if (bootchart_step() < 0 || --bootchart_count == 0) {
                bootchart_finish();
                bootchart_count = 0;
            }
        }
#endif
       //  等待下一个命令的提交
        nr = poll(ufds , fd_count, timeout);
        if (nr <= 0)
            continue;

        for (i = 0; i < fd_count; i++) {
            if (ufds[i].revents == POLLIN) {
                if (ufds[i].fd == get_property_set_fd())
                    handle_property_set_fd();
                else if (ufds[i].fd == get_keychord_fd())
                    handle_keychord();
                else if (ufds[i].fd == get_signal_fd())
                    handle_signal();
            }
        }
    }

.rc脚本语言浅析

init.rc文件在core/rootdir/init.rc，我挑部分内容展示如下：

......
on early-init
    # Set init and its forked children‘s oom_adj.
    write /proc/1/oom_adj -16


    # Set the security context for the init process.
    # This should occur before anything else (e.g. ueventd) is started.
    setcon u:r:init:s0


    start ueventd
......
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    socket zygote stream 660 root system
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart media
    onrestart restart netd
......

init脚本语言的规范：

A、Android init.rc文件由系统第一个启动的init程序解析，此文件由语句组成；
B、在init.rc文件中一条语句通常是占据一行；
C、单词之间是通过空格符来相隔的，如果需要在单词内使用空格，那么得使用转义字符"\"；
D、如果在一行的末尾有一个反斜杠，那么是换行折叠符号，应该和下一行合并成一起来处理，这样做主要是为了避免一行的字符太长，与C语言中的含义是一致的；
E、注释是以#号开头（允许以空格开头）。

首先我们先了解一个概念：Section（语句块），相当于C语言中大括号内的一个块。
一个Section语句块以Service或On开头。而以On开头的叫做动作(Action)，以Service开头的Section叫做服务。Actions和Services有唯一的名字。如果有重名的情况，第二个申明的将会被作为错误忽略。上面列出的正好一个是action，一个是service。
另外还有两个概念：Commands（命令）和Options（选项）。
Action和services显式声明了一个语句块，而commands和options属于最近声明的语句块。在第一个语句块之前的commands和options会被忽略。

Actions（动作）

Actions（动作）形式如下： 
        on <trigger>
           <command1>
           <command2>
           <command3>
Actions其实就是用on关键字开头的一序列的Commands（命令）。on后面有一个trigger（触发器），它被用于决定action的执行时间。当一个符合action触发条件的事件发生时，action会被加入到执行队列的末尾，除非它已经在队列里了。队列中的每一个action都被依次提取出，而这个action中的每个command（命令）都将被依次执行，直到下一个Action或下一个Service。
Triggers（触发器）是一个用于匹配特定事件类型的字符串，用于使Actions发生，有如下形式：
   简单的字符串如early-init：
        这是init执行后的第一个被触发的Triggers（触发器）。（在 /init.conf （启动配置文件）被装载之后）
   <name>=<value>：
        这种形式的Triggers（触发器）会在属性<name>被设置为指定的<value>时被触发。
   device-added-<path>：
   device-removed-<path>：
        这种形式的Triggers（触发器）会在一个设备节点文件被增删时触发。
   service-exited-<name>：
        这种形式的Triggers（触发器）会在一个特定的服务退出时触发。

Services（服务）

Services（服务）是一个程序，它在初始化时启动，并在退出时可选择让其重启。
Services（服务）的形式如下： 
        service <name> <pathname> [ <argument> ]*
           <option>
           <option>
           ...
name:服务名
pathname:当前服务对应的程序位置
option：当前服务设置的选项

Options（选项）
    Options（选项）是一个Services（服务）的修正者。他们影响Services（服务）在何时，并以何种方式运行。
     critical：说明这是一个对于设备关键的服务。如果他四分钟内退出大于四次，系统将会重启并进入recovery（恢复）模式。
     disabled：说明这个服务不会同与他同trigger（触发器）下的服务自动启动。他必须被明确的按名启动。
     setenv <name> <value> （设置环境变量）
   在进程启动时将环境变量<name>设置为<value>。

     socket <name> <type> <perm> [ <user> [ <group> ] ]
            创建一个Uinx域的名为/dev/socket/<name> 的套接字，并传递它的文件描述符给已启动的进程。<type> 必须是 "dgram"或"stream"。User 和 group默认为0。

     user <username>
            在启动这个服务前改变该服务的用户名。此时默认为root。（？？？有可能的话应该默认为nobody）。当前，如果你的进程要求Linux capabilities（能力），你无法使用这个命令。即使你是root，你也必须在程序中请求

capabilities（能力）。然后降到你想要的 uid。
     group <groupname> [ <groupname> ]*
            在启动这个服务前改变该服务的组名。除了（必需的）第一个组名，附加的组名通常被用于设置进程的补充组（通过setgroups()）。此时默认为root。（？？？有可能的话应该默认为nobody）。
   
     oneshot
            服务退出时不重启。

     class <name>
            指定一个服务类。所有同一类的服务可以同时启动和停止。如果不通过class选项指定一个类，则默认为"default"类服务。

     onrestart
            当服务重启，执行一个命令（下详）。

Commands（命令）
    exec <path> [ <argument> ]*
         创建和执行一个程序（<path>）。在程序完全执行前，init将会阻塞。由于它不是内置命令，应尽量避免使用exec，它可能会引起init卡死。(??? 是否需要一个超时设置?)
    export <name> <value>
        在全局环境变量中设在环境变量 <name>为<value>。（这将会被所有在这命令之后运行的进程所继承）
    ifup <interface>
        启动网络接口<interface>
    import <filename>
           解析一个init配置文件，扩展当前配置。
    hostname <name>
           设置主机名。
    chmod <octal-mode> <path>
           更改文件访问权限。
    chown <owner> <group> <path>
           更改文件的所有者和组。
    class_start <serviceclass>
           启动所有指定服务类下的未运行服务。
    class_stop <serviceclass>
        停止指定服务类下的所有已运行的服务。
    domainname <name>
           设置域名。
    insmod <path>
           加载<path>中的模块。
    mkdir <path> [mode] [owner] [group]
           创建一个目录<path>，可以选择性地指定mode、owner以及group。如果没有指定，默认的权限为755，并属于root用户和root组。
    mount <type> <device> <dir> [ <mountoption> ]*
        试图在目录<dir>挂载指定的设备。<device> 可以是以 mtd@name 的形式指定一个mtd块设备。<mountoption>包括 "ro"、"rw"、"remount"、"noatime"、 ...
    setprop <name> <value>
           设置系统属性 <name> 为 <value>值。 
    setrlimit <resource> <cur> <max>
        设置<resource>的rlimit（资源限制）。
    start <service>
        启动指定服务（如果此服务还未运行）。
    stop <service>
        停止指定服务（如果此服务在运行中）。
    symlink <target> <path>
        创建一个指向<path>的软连接<target>。
    sysclktz <mins_west_of_gmt>
        设置系统时钟基准（0代表时钟滴答以格林威治平均时（GMT）为准）
    trigger <event>
           触发一个事件。用于将一个action与另一个 action排列。
    write <path> <string> [ <string> ]*
           打开路径为<path>的一个文件，并写入一个或多个字符串。

Properties（属性）
    Init更新一些系统属性以提供对正在发生的事件的监控能力: 
        init.action
               此属性值为正在被执行的action的名字，如果没有则为""。
        init.command
               此属性值为正在被执行的command的名字，如果没有则为""。
        init.svc.<name>
               名为<name>的service的状态("stopped"（停止）, "running"（运行）, "restarting"（重启）)

.rc文件的解析

重要的数据结构有两个列表，一个队列。 
static list_declare(service_list); 
static list_declare(action_list); 
static list_declare(action_queue); 
*.rc 脚本中所有 service关键字定义的服务将会添加到 service_list 列表中。 
*.rc 脚本中所有 on     关键开头的动作将会被会添加到 action_list 列表中。 

main函数中解析init.rc文件的代码是：

init_parse_config_file("/init.rc");

该函数在system/core/init/init_parser.c中，如下：

int parse_config_file(const char *fn) 
{ 
    char *data; 
    data = read_file(fn, 0); 
    if (!data) return -1; 
    parse_config(fn, data); 
    DUMP(); 
    return 0; 
} 

其中的核心方法是parse_config(fn, data);，如下：

static void parse_config(const char *fn, char *s) 
｛ 
    ... 
    case T_NEWLINE: 
        if (nargs) { 
            int kw = lookup_keyword(args[0]); 
            if (kw_is(kw, SECTION)) { 
                state.parse_line(&state, 0, 0); 
                parse_new_section(&state, kw, nargs, args); 
            } else { 
                state.parse_line(&state, nargs, args); 
            } 
            nargs = 0; 
        } 
   ... 
｝ 

parse_config会逐行对脚本进行解析，如果关键字类型为  SECTION ，就是上一模块中说的Section（语句块），那么将会执行 parse_new_section() 。
parse_new_section()中再分别对 service 或者 on 关键字开头的内容进行解析，如下： 

    ... 
    case K_service: 
        state->context = parse_service(state, nargs, args); 
        if (state->context) { 
            state->parse_line = parse_line_service; 
            return; 
        } 
        break; 
    case K_on: 
        state->context = parse_action(state, nargs, args); 
        if (state->context) { 
            state->parse_line = parse_line_action; 
            return; 
        } 
        break; 
    } 
    ... 

对 on 关键字开头的内容进行解析 

static void *parse_action(struct parse_state *state, int nargs, char **args) 
{ 
    ... 
    act = calloc(1, sizeof(*act)); 
    act->name = args[1]; 
    list_init(&act->commands); 
    list_add_tail(&action_list, &act->alist); 
    ... 
} 

对 service 关键字开头的内容进行解析 

static void *parse_service(struct parse_state *state, int nargs, char **args) 
{ 
    struct service *svc; 
    if (nargs name = args[1]; 
    svc->classname = "default"; 
    memcpy(svc->args, args + 2, sizeof(char*) * nargs); 
    svc->args[nargs] = 0; 
    svc->nargs = nargs; 
    svc->onrestart.name = "onrestart"; 
    list_init(&svc->onrestart.commands); 
    //添加该服务到 service_list 列表 
    list_add_tail(&service_list, &svc->slist); 
    return svc; 
} 

解析后的服务表现形式是一个service结构体。例如： 
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server 
    socket zygote stream 666 
    onrestart write /sys/android_power/request_state wake 
服务名称为：                           zygote 
启动该服务执行的命令：                 /system/bin/app_process 
命令的参数：                           -Xzygote /system/bin --zygote --start-system-server 
socket zygote stream 666： 创建一个名为：/dev/socket/zygote 的 socket ，类型为：stream 

android启动之init启动,布布扣,bubuko.com