android启动之init启动

整个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启动,,5-wow.com

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。