这里开始分析init进程中配置文件的解析，在配置文件中的命令的执行和服务的启动。
首先init是一个可执行文件，它的对应的Makfile是init/Android.mk。 Android.mk定义了init
程序在编译的时候，使用了哪些源码，以及生成方式。当init程序生成之后，最终会放到/init，
即根目录的init文件。通常所说的init进程就是执行这个init程序。
执行这个init程序的代码是在KERNEL/init/main.c文件中的kernel_init()函数里，当kernel
把一些基本的工作，比如CPU初始化，内存初始化，输入输出初始化等等完成之后，就会找到
根目录下的init程序，然后执行这个程序。
在Android系统中，init程序对应的代码在ANDROID/system/core/init/下，用Android.mk,文件
管理编译的。这个程序的入口函数是init.c的main函数。在Android下init进程的主要功能和其它
发行版的Linux的系统差不多，都是通过解析配置文件，完成Linux系统的基本的操作，比如
用户级别，权限的设定，一些安全策略的启动，如selinux的启动，基本的文件(/dev, /sys等)创建，
然后就是其它基本的进程。 init的进程的id永远为1，在系统中最基本的进程之一。
今天我们主要目的目标如下：
1） init进程是如何解析配置文件的
2） init进程是如何启动其它基本的进程的
1 init进程是如何解析配置文件
1.1 了解init.rc文件的语法(见init.rc语法)
1.2 init.rc对应的数据结构
parse_state这个结构体是用来跟踪整个init.rc文件解析过程的。这个在阅读代码时，把这个结构体理解为一个篮子，
这个篮子中放的都是各种各样的rc文件内容即可。
1 struct parse_state
2 struct command{
3 struct listnode clist;//命令数列
4
5 int (*func)(int nargs, char **args);//当前命令对应的函数，比如write命令，对应do_write(xxx)
6 int nargs; //参数个数
7 char *args[1]; //参数数组
8 };
action就是on xxx对应的部分，action主要是由command组成。Android系统在开机执行的顺序，
是按照这个action顺序执行的。也就是说系统触发不同的trigger，就顺序执行这个trigger对应的action
下的所有命令，这个执行过程是顺序执行的，没有并行进行。而且系统在启动过程中，都是按照action去
执行的。记住，是在开机过程中才是这么执行的。
struct action {
struct listnode alist;//系统中所有的action的队列
struct listnode qlist;//等待触发trigger的队列
struct listnode tlist;//这个队列的意义不明，好在也没人用到这个队列
unsigned hash;
const char *name;//这个名字就是triggeer的名字
struct listnode commands;//在当前这个action下所有的comman的队列
struct command *current;//当前要执行的命令
};
service也是系统的一个SECTION，这样的SECTION仅有service， import， on xxxx这三种。对这三种
不同的SECTION解析的函数是不同的。记住on xxxx就是一个action。这个数据结构就是对应一个service，在
系统中service是不能直接执行的，它仅仅是一个service的属性信息的集合，为service的启动提供全面的信息，
但是它不是一个命令，所以不能直接执行。前面这些command可能仅仅就是在init进程中执行，但是service不同。
service启动是在一个新的进程中进行的。也就是说init进程会先fork一个进程，然后通过exec家族函数去启动
这个service。所以service是运行在一个新的进程中的。
struct service
1.3 init.rc文件的解析
对于init.rc文件的解析主要是通过以下代码实现的[init.c文件中]：
1 init_parse_config_file("/init.rc");
这句代码是解析所有init.rc文件的入口，其他的*.rc文件都是通过init.rc中通过import一级一级地导入的；
所以从这句代码入手是最合适的地方。 init_parse_config_file函数读取init.rc文件，并调用parse_config函数，
这个函数才是真正解析init.rc文件的地方。先看看这个函数的主要部分，如下[init_parce.c文件中]：
1 static void parse_config(const char *fn, char *s)
2 {
3 //第一部分
4 struct parse_state state;
5 struct listnode import_list;
6 struct listnode *node;
7 char *args[INIT_PARSER_MAXARGS];
8 int nargs;
9
10 nargs = 0;
11 state.filename = fn;
12 state.line = 0;
13 state.ptr = s;
14 state.nexttoken = 0;
15 state.parse_line = parse_line_no_op;
16
17 list_init(&import_list);
18 state.priv = &import_list;
19 //第二部分
20 for (;;) {
21 switch (next_token(&state)) {
22 case T_EOF:
23 state.parse_line(&state, 0, 0);
24 goto parser_done;
25 case T_NEWLINE:
26 state.line++;
27 if (nargs) {
28 int kw = lookup_keyword(args[0]);
29 if (kw_is(kw, SECTION)) {
30 state.parse_line(&state, 0, 0);
31 parse_new_section(&state, kw, nargs, args);
32 } else {
33 state.parse_line(&state, nargs, args);
34 }
35 nargs = 0;
36 }
37 break;
38 case T_TEXT:
39 if (nargs < INIT_PARSER_MAXARGS) {
40 args[nargs++] = state.text;
41 }
42 break;
43 }
44 }
45 //第三部分
46 parser_done:
47 list_for_each(node, &import_list) {
48 struct import *import = node_to_item(node, struct import, list);
49 int ret;
50
51 INFO("importing ‘%s‘", import->filename);
52 ret = init_parse_config_file(import->filename);
53 if (ret)
54 ERROR("could not import file ‘%s‘ from ‘%s‘\n",
55 import->filename, fn);
56 }
57 }
把这个函数分成三部分理解会更方便，首先第一部分只是在解析过程中一些变量的初始化，主要是就是parse_state结构体
的初始化。真正解析rc文件的是在第二部分；在当前rc文件解析完成后，会处理当前文件import的其它rc文件，这些是在
第三部分做的。如果有import其它的rc文件，在第三部分中会调用init_parse_config_file函数，接着解析导入的rc文件；
从整体上看，像是一个递归函数。我们把重点放在第二部分上。
在第二部分中next_token函数相当于一个简单的词法分析器，这个函数对应的状态机如下图：
这个图画的不是很标准，我再大概注释下吧：对于rc文件内容逐个字母输入这个状态机，如果是字符的话就继续输入下一个字符，直到输入的是空格或\r或者\t，
那么就进入TEXT状态，并把这个token返回给parse_config函数去处理；同样，要是遇到换行，或者文件结束，都要返回给parse_config去处理。
从第二部分可以看出，rc文件的解析是以行为单位进行的，在每一行中检查到一个TEXT，就会把这个单词放入args数组中；
这样，当一行结束时，这个args数组和nargs变量就初始化完成；然后开始换行；在换行时，需要在如下代码（第二部分代码中）中进行：
1 case T_NEWLINE:
2 state.line++;
3 //nargs非0，说明这行中有命令需要解析
4 if (nargs) {
5 //先看看在本行中第一个词是不是关键词，
6 //关键词列表在keywords.h文件中
7 int kw = lookup_keyword(args[0]);
8 //如果第一参数是关键词，那么就会返回关键词的index
9 //然后判断这个关键词是不是SECTION，只有import，on，service
10 //才是SECTION
11 if (kw_is(kw, SECTION)) {
12 state.parse_line(&state, 0, 0);
13 //在parse_new_section中，会解析这个section，
14 //在解析过程中，最重要的是给parse_line赋值；
15 //因为parse_line是个函数指针
16 parse_new_section(&state, kw, nargs, args);
17 } else {
18 //在一个SECTION中，parse_line会保持不变的，
19 //直到遇到下个SECTION之前，这个parse_line函数
20 //会保持不变的
21 state.parse_line(&state, nargs, args);
22 }
23 nargs = 0;
24 }
25 break;
给parse_line赋值是在parse_new_section中进行的，能够赋值给parse_line的函数有parse_line_service，parse_line_action，
对这个两个函数的理解，有助于对init.rc文件解析的理解。对于这两个函数没必要逐行分析，这里不作介绍；
在lookup_keyword函数中，有个地方说明下；可能是我的基础知识不是很牢固，在看这个函数的时候，有些地方卡了一下；
在init_parse.c文件中有如下宏定义
1 #define KEYWORD(symbol, flags, nargs, func, uev_func) 2 [ K_##symbol ] = { #symbol, func, uev_func, nargs + 1, flags, },
而在keywords.h文件中，还有个宏定义如下：
#define KEYWORD(symbol, flags, nargs, func, uev_func) K_##symbol,
这两个宏是一样的。 C语言中宏的作用范围只是在单文件中。宏是在编译过程中进行的替换，这个过程发生在链接之前，所以
宏的作用范围只能是在当前文件中。这样的话，在init_parse.c文件中的宏定义没人用到，因此哪个宏也是无意义的。
2 init进程是如何启动其它基本的进程的
2.1 init进程中命令和服务启动顺序
在正式开始介绍init进程是如何启动其它服务之前，还有一些内容要介绍，就是系统如何确定开机执行顺序的。在init.c文件中有如下代码：
1 action_for_each_trigger("early-init", action_add_queue_tail);
2 queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
3 queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
4 queue_builtin_action(keychord_init_action, "keychord_init");
5 queue_builtin_action(console_init_action, "console_init");
6 action_for_each_trigger("init", action_add_queue_tail);
7 if (!is_special) {
8 action_for_each_trigger("early-fs", action_add_queue_tail);
9 action_for_each_trigger("fs", action_add_queue_tail);
10 action_for_each_trigger("post-fs", action_add_queue_tail);
11 action_for_each_trigger("post-fs-data", action_add_queue_tail);
12 }
13 /* Repeat mix_hwrng_into_linux_rng in case /dev/hw_random or /dev/random
14 * wasn‘t ready immediately after wait_for_coldboot_done
15 */
16 queue_builtin_action(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
17 queue_builtin_action(property_service_init_action, "property_service_init");
18 queue_builtin_action(signal_init_action, "signal_init");
19 queue_builtin_action(check_startup_action, "check_startup");
20 if (is_special) {
21 action_for_each_trigger(bootmode, action_add_queue_tail);
22 } else {
23 action_for_each_trigger("early-boot", action_add_queue_tail);
24 action_for_each_trigger("boot", action_add_queue_tail);
25 }
26 queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");
这段代码中主要的函数就两个，分别是action_for_each_trigger，queue_builtin_action，这两个函数操作同意队列，
这个队列就是action_queue。init进程启动顺序就是action在action_queue这个队列中的顺序。action_for_each_trigger
函数就是把*.rc文件中， 对应trigger的action放入action_queue队列。 而queue_builtin_action函数是临时需要在action_queue中
新增加一个action，只不过这个action仅仅有一个command,这个command就是queue_builtin_action函数第一个参数对应的函数。
因此从这段代码中，我们可以看出，init执行顺序是：
early-init, wait_for_coldboot_done, mix_hwrng_into_linux_rng, keychord_init,console_init, init,
early-fs, fs, post-fs, post-fs-data, mix_hwrng_into_linux_rng, property_service_init,signal_init,
check_startup, early-boot, boot, queue_property_triggers.
上面这些代码仅仅是把action_queue队列配置完成，安排好每个action的顺序。 但是现在并没有开始按照这个队列去执行各个
命令或者启动各个服务。
2.2 在init进程中执行命令和服务
这里就开始介绍init进程是如何执行命令和启动服务的。这个过程是在如下代码开始执行的：
1 for(;;) {
2 int nr, i, timeout = -1;
3 //第一部分
4 //execute_one_command是开始执行命令的地方
5 execute_one_command();
6 //如果有些进程需要重启的话在这里进行
7 restart_processes();
8 //第二部分
9 //接下来是四个socket，使用Linux的poll机制去监听
10 //这四个文件的状态，与其它进程通信；比如：
11 //当我们通过命令调用 setprop时候，就会和get_property_set_fd
12 //指向的socket通信
13 if (!property_set_fd_init && get_property_set_fd() > 0) {
14 ufds[fd_count].fd = get_property_set_fd();
15 ufds[fd_count].events = POLLIN;
16 ufds[fd_count].revents = 0;
17 fd_count++;
18 property_set_fd_init = 1;
19 }
20 if (!signal_fd_init && get_signal_fd() > 0) {
21 ufds[fd_count].fd = get_signal_fd();
22 ufds[fd_count].events = POLLIN;
23 ufds[fd_count].revents = 0;
24 fd_count++;
25 signal_fd_init = 1;
26 }
27 if (!keychord_fd_init && get_keychord_fd() > 0) {
28 ufds[fd_count].fd = get_keychord_fd();
29 ufds[fd_count].events = POLLIN;
30 ufds[fd_count].revents = 0;
31 fd_count++;
32 keychord_fd_init = 1;
33 }
34
35 if (process_needs_restart) {
36 timeout = (process_needs_restart - gettime()) * 1000;
37 if (timeout < 0)
38 timeout = 0;
39 }
40
41 if (!action_queue_empty() || cur_action)
42 timeout = 0;
43 //这里就是poll机制的利用，
44 //接收到socket通信后，对于这些事件的分配
45 nr = poll(ufds, fd_count, timeout);
46 if (nr <= 0)
47 continue;
48
49 for (i = 0; i < fd_count; i++) {
50 if (ufds[i].revents == POLLIN) {
51 if (ufds[i].fd == get_property_set_fd())
52 handle_property_set_fd();
53 else if (ufds[i].fd == get_keychord_fd())
54 handle_keychord();
55 else if (ufds[i].fd == get_signal_fd())
56 handle_signal();
57 }
58 }
59 }
便于理解，把上述代码分为两个部分。这两个部分都是重点。
不过第一部分更切合我们这一小节的主题：命令的执行和服务的启动。
execute_one_command函数是命令执行和服务启动主要函数，这个函数的代码如下：
1 void execute_one_command(void)
2 {
3 int ret;
4
5 if (!cur_action || !cur_command || is_last_command(cur_action, cur_command)) {
6 //从action_queue中取出第一个action
7 cur_action = action_remove_queue_head();
8 cur_command = NULL;
9 if (!cur_action)
10 return;
11 INFO("processing action %p (%s)\n", cur_action, cur_action->name);
12 //从当前action中取出第一个command
13 cur_command = get_first_command(cur_action);
14 } else {
15 cur_command = get_next_command(cur_action, cur_command);
16 }
17
18 if (!cur_command)
19 return;
20 //执行这个command
21 ret = cur_command->func(cur_command->nargs, cur_command->args);
22 INFO("command ‘%s‘ r=%d\n", cur_command->args[0], ret);
23 }
上面这个过程就是命令执行的过程.这些命令对应的函数，可以从kerwords.h中看到。如果前面的rc文件解析中，仔细分析
了整个流程的话，就很容易回忆起前面的这些内容。对于这个func也不会陌生，这些函数的实现都是在builtins.c文件中实现的。
在rc文件中出现的命令，绝大部分都是很常见的，不多做介绍。不过，下面还是会以其中一个命令说明下整个过程，这个命令就是
class_start--这个命令是专门用来启动service的，在其他Linux系统中也是没有的。
对于这个命令，首先到keywords.h中找到其对应的函数，如下：
1 KEYWORD(class_start, COMMAND, 1, do_class_start, 0)
所以class_start命令对应的函数实际上就是do_class_start。前文已经说过，这些函数都是在builtins.c文件中实现的，那么这个
函数实现如下：
1 int do_class_start(int nargs, char **args){
2 /* Starting a class does not start services
3 * which are explicitly disabled. They must
4 * be started individually.
5 * */
6 service_for_each_class(args[1], service_start_if_not_disabled);
7 return 0;
8 }
9 service_for_each_class函数的实现实在init_parser.c文件中，如下
10 void service_for_each_class(const char *classname, void (*func)(struct service *svc)){
11 struct listnode *node;
12 struct service *svc;
13 list_for_each(node, &service_list) {
14 svc = node_to_item(node, struct service, slist);
15 if (!strcmp(svc->classname, classname)) {
16 func(svc);
17 }
18 }
19 }
到这里，基本已经可以看出这个命令和service之间的关系来。通过这两个函数，实际上就是通过service_start_if_not_disabled
函数启动所有className与给出的classname相同的service。 这些classname指的就是在定义每一个service的时候，定义在class
之后的部分，比如下面这个service：
1 service servicemanager /system/bin/servicemanager 2 class core 3 user system 4 group system 5 critical 6 onrestart restart healthd 7 onrestart restart zygote 8 onrestart restart media 9 onrestart restart surfaceflinger 10 onrestart restart drm
servicemanager服务的classname就是 core. 那么调用class_start命令的地方在哪里呢？
调用class_start命令的地方在init.rc中，当执行boot action的时候，顺序执行就能执行到这个命令，首先启动的core一级别的服务，
然后启动才是main级别的服务
1 on boot 2 ... 3 class_start core 4 class_start main
既然已经找到了命令开始的地方了，那么我们可以继续看看service到底是如何执行的。这就要看service_start_if_not_disabled函数了，
这个函数的代码如下,在builtins.c文件中：
1 static void service_start_if_not_disabled(struct service *svc){
2 if (!(svc->flags & SVC_DISABLED)) {
3 service_start(svc, NULL);
4 }
5 }
这里会检查flags中没有disabled选项的启动。在service_start函数是真正启动一个服务的地方。service_start函数在init.c文件中实现的。
当你在这个函数中看到fork()函数时候，你就明白这个服务启动了。而逐个启动每个服务，这个循环过程实在service_for_each_class中的
list_for_each中的，可以回头再看看。
到这里就是介绍完成来通过rc文件启动一个服务的过程。能读到这里，说明你真的很有耐心啊，给自己一个表扬吧。不过这时候，你也许会有
一个疑问，如果一个service中flags中有disabled项时，这样的服务是怎样启动的呢？
下面就以下面这个含有disabled项服务的启动为例，介绍下这类服务的启动过程，这个服务如下：
1 service bootanim /system/bin/bootanimation 2 class main 3 user graphics 4 group graphics 5 disabled 6 oneshot
这个服务是开机动画，如果使用的是模拟器的话，就是开机闪烁android的那个动画。这个服务中含有disabled, 通过上面的解析，我们知道这个服务
肯定不是通过class_start命令启动的。但是在开机过程中，我们的确看到来开机动画，那么这个服务是在何时由谁启动的呢?
启动开机动画是在SurfaceFlinger初始化完成时，由SurfaceFlinger间接启动这个服务的。在SurfceFlinger初始化完成时，调用来函数startBootAnim(),
这个函数通过设置一个系统属性，然后开机动画就开始来。设置这个属性的代码如下：
1 void SurfaceFlinger::startBootAnim() {
2 // 首先是先退出开机动画。如果开机动画在进行中，那么就退出这个开机动画；
3 // 如果开机动画没有运行，那么这个属性设置上也是没有影响的
4 property_set("service.bootanim.exit", "0");
5 //然后，开始播放动画。init进程会检查这个属性，然后开始动画播放
6 property_set("ctl.start", "bootanim");
7 }
property_set的函数，在实现的时候，实际上是通过写socket和init进程通信。在前面也说到过，init进程在启动后，会监视四个文件的状态，这四个
文件都是socket文件，其中一直就是属性socket文件的描述符get_property_set_fd(). 通过Linux的poll机制，当有有系统属性设置进来的时候，就会
有触发调用下面的函数:
handle_property_set_fd()
这函数是在init.c文件中被调用，它的实现实在property_service.c文件中。这个函数从socket中读取出传递过来的信息。传递过来的信息都是按照键值对
封装好的。如果键值对中的name中前4个字母是"crtl."，那么就会调用handle_control_message()函数。关于函数handle_property_set_fd()的代码在property_service.c
文件中，这里就不再拿出来单独看了.
在调用到handle_control_message函数，这个函数如下：
1 void handle_control_message(const char *msg, const char *arg)
2 {
3 if (!strcmp(msg,"start")) {
4 msg_start(arg);
5 } else if (!strcmp(msg,"stop")) {
6 msg_stop(arg);
7 } else if (!strcmp(msg,"restart")) {
8 msg_restart(arg);
9 } else {
10 ERROR("unknown control msg ‘%s‘\n", msg);
11 }
12 }
13 static void msg_start(const char *name)
14 {
15 ...
16 svc = service_find_by_name(name);
17 ...
18 service_start(svc, args);
19 ...
20 }
如果命令中的start的话,这里把msg_start函数彻底简写了，仅仅保留这两个最核心的代码。根据service的名字找到这个service，
然后启动service。当你看到service_start()函数的时候，想必你已经明白来整个过程来。service_start()函数在前面有过简略
地介绍，这里也不多说来。
就是类似与这样，init进程在设备启动后，还在忙碌地参与这系统的运行。