Android Init进程分析

之前在看android启动过程总是带着完成工作任务的目的去分析代码，但是对于一些代码的细节并不是很清楚，在这里就分析一下Init进程的执行过程。

以下框图简要描述系统进程间层次关系

Init进程是android系统起来之后启动的第一个进程，对于研究android系统的启动过程很重要。它是android系统中的始祖进程，USB守护进程(usbd)，挂载守护进程(vold)，无线接口守护进程(rild)等都是init进程的子进程。以下截图是我手机的运行进程情况，可以明显看出进程间的关系

还有一个PID=2的kthread进程，该进程用来创建内核空间的其它进程

直接根据代码来分析整个进程的执行过程。

int main(int argc, char **argv)
{
    int fd_count = 0;
    struct pollfd ufds[4];//存放pollfd
    char *tmpdev;
    char* debuggable;
    char tmp[32];
    int property_set_fd_init = 0;
    int signal_fd_init = 0;
    int keychord_fd_init = 0;

    if (!strcmp(basename(argv[0]), "ueventd"))
        return ueventd_main(argc, argv);//ueventd是init的软链接，执行这个进程的时候相当于执行init进程，然后根据进程名进入相应的执行流程

    /* 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", 0, "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);

        /* 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.
         */

以上主要创建一些文件系统目录并挂载相应的文件系统，proc文件系统是重要的内核数据的接口，可以通过它读取一些系统信息还能操作内核参数

    open_devnull_stdio();//重定向标准输入，输入，错误到/dev/__null__(dup2复制文件句柄，0,1,2分别代表标准输入 输出 错误) 屏蔽标准输入输出
    log_init();//设置log信息输出设备/dev/__kmsg__,unlink之后其他进程无法访问，阅读源码定向到printk函数输出 初始化log系统
  
    property_init();//初始化属性系统，这个可以以后分析


    get_hardware_name(hardware, &revision);


    process_kernel_cmdline();


#ifdef HAVE_SELINUX
    INFO("loading selinux policy\n");
    selinux_load_policy();
#endif


    is_charger = !strcmp(bootmode, "charger");


    INFO("property init\n");
    if (!is_charger)
        property_load_boot_defaults();

这里导入相应的处理函数，分析执行过程

static void import_kernel_cmdline(int in_qemu)
{
    char cmdline[1024];
    char *ptr;
    int fd;

    fd = open("/proc/cmdline", O_RDONLY);
    if (fd >= 0) {
        int n = read(fd, cmdline, 1023);
        if (n < 0) n = 0;

        /* get rid of trailing newline, it happens */
        if (n > 0 && cmdline[n-1] == '\n') n--;
	//读取/proc/cmdline中的信息，存放在cmdline字符数组并进行处理
        cmdline[n] = 0;
        close(fd);
    } else {
        cmdline[0] = 0;
    }

    ptr = cmdline;
    while (ptr && *ptr) {
        char *x = strchr(ptr, ' ');
        if (x != 0) *x++ = 0;
        import_kernel_nv(ptr, in_qemu);//根据' '间断符逐行分析文本
        ptr = x;
    }

        /* don't expose the raw commandline to nonpriv processes */
    chmod("/proc/cmdline", 0440);
}

static void import_kernel_nv(char *name, int in_qemu)
{
    char *value = strchr(name, '=');

    if (value == 0) {
	if (!strcmp(name, "calibration"))
	    calibration = 1;//表示要校准还是什么？
	return;
    }
    *value++ = 0;
    if (*name == 0) return;

    if (!in_qemu)
    {
        /* on a real device, white-list the kernel options */
        if (!strcmp(name,"qemu")) {
            strlcpy(qemu, value, sizeof(qemu));
        } else if (!strcmp(name,"androidboot.console")) {
            strlcpy(console, value, sizeof(console));
        } else if (!strcmp(name,"androidboot.mode")) {
            strlcpy(bootmode, value, sizeof(bootmode));//启动模式
        } else if (!strcmp(name,"androidboot.serialno")) {
            strlcpy(serialno, value, sizeof(serialno));
        } else if (!strcmp(name,"androidboot.baseband")) {
            strlcpy(baseband, value, sizeof(baseband));//基带
        } else if (!strcmp(name,"androidboot.carrier")) {
            strlcpy(carrier, value, sizeof(carrier));
        } else if (!strcmp(name,"androidboot.bootloader")) {
            strlcpy(bootloader, value, sizeof(bootloader));
        } else if (!strcmp(name,"androidboot.hardware")) {
            strlcpy(hardware, value, sizeof(hardware));
        }//将以上设备信息存放在定义的字符数组中
    } else {
        /* in the emulator, export any kernel option with the
         * ro.kernel. prefix */
        char  buff[32];
        int   len = snprintf( buff, sizeof(buff), "ro.kernel.%s", name );
        if (len < (int)sizeof(buff)) {
            property_set( buff, value );
        }
    }
}

    get_hardware_name(hardware, &revision);
    snprintf(tmp, sizeof(tmp), "/init.%s.rc", hardware);
    init_parse_config_file(tmp);//分析相应硬件版本的rc文件

init.rc文件有自己相应的语法，分析rc文件也是根据对应的语法来分析，这里引入一片简单介绍init.rc语法的文章

Android init.rc脚本解析

int init_parse_config_file(const char *fn)
{
    char *data;
    data = read_file(fn, 0);//这里通过read_file函数将fn文件中的数据全部读取到data缓冲区中，malloc分配空间
    if (!data) return -1;
    //这里开始真正分析脚本中的命令
    parse_config(fn, data);
    DUMP();
    return 0;
}

解析过程会先将init.rc文件action与service进行解析，然后插入到链表中依次执行，查看源码中对链表的定义

#ifndef _CUTILS_LIST_H_
#define _CUTILS_LIST_H_

#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
//声明一个双向链表
struct listnode
{
    struct listnode *next;
    struct listnode *prev;
};
//计算结构体数据变量相对于结构体首地址的偏移量，这个很重要
#define node_to_item(node, container, member) \
    (container *) (((char*) (node)) - offsetof(container, member))
//声明一个双向链表，并且指向自己
#define list_declare(name) \
    struct listnode name = { \
        .next = &name, \
        .prev = &name, \
    }
//遍历链表
#define list_for_each(node, list) \
    for (node = (list)->next; node != (list); node = node->next)
//反向遍历链表
#define list_for_each_reverse(node, list) \
    for (node = (list)->prev; node != (list); node = node->prev)

void list_init(struct listnode *list);//初始化一个双向链表
void list_add_tail(struct listnode *list, struct listnode *item);//将结点添加至双向链表尾部
void list_remove(struct listnode *item);

#define list_empty(list) ((list) == (list)->next)
#define list_head(list) ((list)->next)
#define list_tail(list) ((list)->prev)

#ifdef __cplusplus
};
#endif /* __cplusplus */

#endif

这里声明了三个链表

static list_declare(service_list);
static list_declare(action_list);
static list_declare(action_queue);

static void parse_config(const char *fn, char *s)
{
    struct parse_state state;
    char *args[INIT_PARSER_MAXARGS];//允许解析出来的命令行最多有64个参数
    int nargs;

    nargs = 0;
    state.filename = fn;//文件名
    state.line = 0;
    state.ptr = s;//data
    state.nexttoken = 0;
    state.parse_line = parse_line_no_op;//此时解析函数是空操作
    for (;;) {
        switch (next_token(&state)) {//通过next_token函数来寻找字符数组中的关键标记
        //这里面省略了一些字符的处理(如‘\r’, '\t', '"', ' '等)，只针对有效字符进行处理('\0', '\n'等)
        //#define T_EOF 0    #define T_TEXT 1    #define T_NEWLINE 2
        case T_EOF:
            state.parse_line(&state, 0, 0);                                                                                                     goto parser_done;
            return;
        case T_NEWLINE:
            if (nargs) {
                int kw = lookup_keyword(args[0]);//这里将分析第一个参数所代表的关键字
                //根据字符匹配返回已定义好的宏定义
                if (kw_is(kw, SECTION)) {//当关键字是on或service或import
                    state.parse_line(&state, 0, 0); //此时相当于什么都没做
                    parse_new_section(&state, kw, nargs, args);//对state.parse_line进行填充
                } else {
                    state.parse_line(&state, nargs, args);//对于NEWLINE不是on service import的调用parse_line，而在后面的填充中                                                                     //parse_line函数即parse_line_action

                    //回调相应的处理函数
                }
                nargs = 0;
            }
            break;
        case T_TEXT://不处理
            if (nargs < INIT_PARSER_MAXARGS) {
                args[nargs++] = state.text;
            }
            break;
        }
    }                                                                                                                                   parser_done:
    list_for_each(node, &import_list) {//文件解析结束后解析新导入的rc文件
         struct import *import = node_to_item(node, struct import, list);
         int ret;
      
         //循环取出rc文件的路径   
         INFO("importing '%s'", import->filename);
         ret = init_parse_config_file(import->filename);//重新解析rc文件
         if (ret)
             ERROR("could not import file '%s' from '%s'\n",
                   import->filename, fn);
    }
}

首先查看一下keywords.h这个文件，对分析过程有帮助

#ifndef KEYWORD//防止重复定义
int do_chroot(int nargs, char **args);
int do_chdir(int nargs, char **args);
int do_class_start(int nargs, char **args);
int do_class_stop(int nargs, char **args);
int do_class_reset(int nargs, char **args);
int do_domainname(int nargs, char **args);
int do_exec(int nargs, char **args);
int do_export(int nargs, char **args);
int do_hostname(int nargs, char **args);
int do_ifup(int nargs, char **args);
int do_insmod(i