Android init相关知识
init是android运行的第一个程序，在init中，android首先配置一些内核与用户空间交互所需的文件路径，接着开启属性服务，初始化一系列属性信息，解析配置文件，并根据解析的结果开启相关服务进程。init还会循环监听属性服务、多点触控、信号的请求，并作出响应处理。本文分析init流程及大体框架，并对相关知识做出分析。
init流程
分析init流程，就看init.c的main函数。精简后的框架代码如下：
int main(int argc, char **argv) { ... mkdir("/dev", 0755); mkdir("/proc", 0755); mkdir("/sys", 0755); ... open_devnull_stdio(); klog_init(); property_init(); ... init_parse_config_file("/init.rc"); ... action_for_each_trigger("early-init", action_add_queue_tail); queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done"); queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng"); queue_builtin_action(keychord_init_action, "keychord_init"); queue_builtin_action(console_init_action, "console_init"); ... for(;;) { int nr, i, timeout = -1; execute_one_command(); 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; 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(); } } } return 0; }
open_devnull_stdio函数用于把标准输出重定向，每个标准输出需要有一个文件作为承载，这里使用__null__作为临时承载。
void open_devnull_stdio(void) { int fd; static const char *name = "/dev/__null__"; if (mknod(name, S_IFCHR | 0600, (1 << 8) | 3) == 0) { fd = open(name, O_RDWR); unlink(name); if (fd >= 0) { dup2(fd, 0); dup2(fd, 1); dup2(fd, 2); if (fd > 2) { close(fd); } return; } } exit(1); }
这里有几个小知识点：
1.dup2会首先关闭dst文件描述符指向的文件，然后将dst文件描述符绑定到src所指向的文件上。
2.系统输出有3个，分别为0、1、2，代表stdin、stdout及stderr。
3.unlink类似于引用计数-1，当一个文件的打开引用计数为0时，调用close函数会删除该文件。
property_init函数创建了一块共享内存，用于属性的存取，所有进程均可以访问。
属性文件的解析
属性文件的解析是init的重要工作之一，在实际开发工作中，调整服务启动顺序、配置开机启动服务都需要对这部分内容有所了解，因此单独列出来分析。
static void parse_config(const char *fn, char *s) { struct parse_state state; struct listnode import_list; struct listnode *node; char *args[INIT_PARSER_MAXARGS]; int nargs; nargs = 0; state.filename = fn; state.line = 0; state.ptr = s; state.nexttoken = 0; state.parse_line = parse_line_no_op; list_init(&import_list); state.priv = &import_list; for (;;) { switch (next_token(&state)) { case T_EOF: state.parse_line(&state, 0, 0); goto parser_done; case T_NEWLINE: state.line++; 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; } break; case T_TEXT: if (nargs < INIT_PARSER_MAXARGS) { args[nargs++] = state.text; } break; } } parser_done: list_for_each(node, &import_list) { struct import *import = node_to_item(node, struct import, list); int ret; INFO("importing '%s'", import->filename); ret = init_parse_config_file(import->filename); if (ret) ERROR("could not import file '%s' from '%s'\n", import->filename, fn); } }
init_parse_config_file函数最终会调用parse_config做实际的解析。实际的解析工作是基于token的，可以理解为分词。首先将一行的分词保存为多个参数，然后当遇到换行符时，分析第一个参数是哪个关键词。parse_config会首先调用当前的parse_line函数做处理，然后若关键词属于SECTION，调用parse_new_section做解析。
parse_new_section也会根据不同的关键词做不同的处理，同时将parse_line设置对对应的处理函数。
static void parse_new_section(struct parse_state *state, int kw, int nargs, char **args) { printf("[ %s %s ]\n", args[0], nargs > 1 ? args[1] : ""); switch(kw) { 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; case K_import: parse_import(state, nargs, args); break; } state->parse_line = parse_line_no_op; }
解析工作实际做的事情，就是将各个service及action放到对应的全局链表中。其中parse_service将service加到service_list中，parse_action将action加到action_list中。一共有三个全局链表：service_list、action_list、action_queue，service_list及action_list分别存储解析出来的全部service及action，而action_queue用于存储等待执行的action。
完成配置文件的解析后，init会调用action_for_each_trigger，将action_list中符合时间节点要求的action，加入到action_queue中等待执行。例如：action_for_each_trigger("early-init", action_add_queue_tail); 就是将early-init阶段要执行的action加入到action_queue中。
queue_builtin_action函数会直接创建action，并添加到action_list及action_queue中。
那么这些action什么时候被执行呢，答案就是，当init进入for死循环后，会调用execute_one_command函数。如果当前没有正在执行的命令，execute_one_command会找到action_queue头的action，然后找到这个action中应该执行的command，调用command的执行处理函数执行命令。
void execute_one_command(void) { int ret, i; char cmd_str[256] = ""; if (!cur_action || !cur_command || is_last_command(cur_action, cur_command)) { cur_action = action_remove_queue_head(); cur_command = NULL; if (!cur_action) return; INFO("processing action %p (%s)\n", cur_action, cur_action->name); cur_command = get_first_command(cur_action); } else { cur_command = get_next_command(cur_action, cur_command); } if (!cur_command) return; ret = cur_command->func(cur_command->nargs, cur_command->args); if (klog_get_level() >= KLOG_INFO_LEVEL) { for (i = 0; i < cur_command->nargs; i++) { strlcat(cmd_str, cur_command->args[i], sizeof(cmd_str)); if (i < cur_command->nargs - 1) { strlcat(cmd_str, " ", sizeof(cmd_str)); } } INFO("command '%s' action=%s status=%d (%s:%d)\n", cmd_str, cur_action ? cur_action->name : "", ret, cur_command->filename, cur_command->line); } }
pollfd
pollfd用于存放Socket文件描述符，其定义如下：
struct pollfd { int fd; /* 想查询的文件描述符. */ short int events; /* fd 上，我们感兴趣的事件*/ short int revents; /* Types of events that actually occurred. */ };
其中events为我们感兴趣的事件，revents为实际发生的事件。我们可以使用events注册我们想要监听的事件，在poll函数返回时，通过revents与不同时间&操作，得知实际发生的事件。具体用法可参考init的for循环。
listnode分析
Android init定义了一种数据结构listnode，用于双向链表［Tip:双向链表是环形的］。奇妙的是listnode中只有指向前后节点的指针，并没有保存数据，那么listnode如何使用呢？
秘密就在两个宏里
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) #define node_to_item(node, container, member) \ (container *) (((char*) (node)) - offsetof(container, member))
offsetof的作用比较好理解，是获得成员MEMBER在TYPE结构体中的位置偏移。那么node_to_item呢？
其实node_to_item的作用是将一个保存有listnode成员的结构体，根据listnode地址，找到结构体本身。char*的作用是将listnode地址位对齐，再减去listnode节点本身在结构体中的偏移量，即获得了结构体本身地址。这样用的好处是，一个结构体可以通过包含多个listnode成员，使数据同时包含在多个双向链表中。
使用实例如下：
struct action { /* node in list of all actions */ struct listnode alist; /* node in the queue of pending actions */ struct listnode qlist; /* node in list of actions for a trigger */ struct listnode tlist; unsigned hash; const char *name; struct listnode commands; struct command *current; };
