init.rc 语法与解析

版权说明：本文为 开开向前冲 原创文章，转载请注明出处；
注：限于作者水平有限，文中有不对的地方还请指教。

本文基于Android 6.0，涉及源码如下：

/system/core/rootdir/init.rc
/system/core/init/init_parser.cpp

一：init.rc 语法

一个完整的init.rc 脚本由4中类型声明组成。即：
Action（动作）
Commands（命令）
Services（服务）
Options（选项）

Action 和Services 表明一个新语句的开始，这两个关键字后面跟着的Commands 或者 Options 都是属于这个语句；
Action 和Services 都有唯一的名字，如果出现动作或者服务重名，则会被当做错误处理。

1：Action（动作）

语法格式

on    ##触发条件
       ##执行命令
       ##可以同时执行多个命令
     

其中trigger 是触发条件，即当触发条件满足时将 依次 执行commands

举例说明：下面这句话的意思是当属性值满足persist.service.adb.enable=1时，启动adbd 进程；
on property:persist.service.adb.enable=1
   start adbd

具体实现：当系统变化的时候，系统会对init.rc 中的每个进行匹配，只要发现符合条件的Action，就会把它加入 “命令执行队列”的尾部（除非这个Action 在队列中已经存在）， 然后系统在对这些Commands按顺序执行；

2：Commands（命令）

命令将在触发条件发生时被一个个执行。

init.rc中常见的trigger如下：

trigger	Description
boot	init程序启动后触发的第一个事件
=	当属性 满足时触发
device-added/removed-	当设备节点添加/删除时触发此事件
sevice-exited-	当指定服务 存在时触发

init.rc中常见的Commands如下：

Command	Description
exec []*	Fork 并执行一个程序，其路径为。该命令将阻塞 直到该程序启动完成
export	设置某个环境变量 的值为。对全局有效，之后的进程都将继承这个变量
ifup	使网络接口 成功连接
import	解析另一个配置文件，以扩展当前配置
chdir	更换工作目录为
chmod	更改文件访问权限
chown	更改文件所有者和群组
mount []*	尝试在指定路径上挂载一个设备
start	启动一个服务，如果它没有处于运行状态的话
stop	停止一个服务，如果它当前处于运行状态的话
setprop	设置系统属性 的值为
trigger	触发一个事件

很多没有列举完成，但是很多Commands 可以根据名字理解意思，如下举几个例子，例子都是init.rc中的内容；

on init
      symlink /sys/kernel/debug /d
      mount cgroup none /acct cpuacct
      mkdir /acct/uid
      chown root system /sys/fs/cgroup/memory/sw/tasks
      chmod 0660 /sys/fs/cgroup/memory/sw/tasks

on property:sys.boot_from_charger_mode=1
    class_stop charger
    trigger late-init

3：Services（服务）

3.1：命令格式：

service   [  ]*
        
        
        ...

• ——表示service 的名字；
• ——表示service所在路径，此处的service是可执行文件，所以一定有存储路径；
• ——启动service所带的参数；
• ——对此service的约束选项，后面将详细讲解；

Service 样例如下：

service servicemanager /system/bin/servicemanager
    class core
    user system
    group system
    critical
    onrestart restart healthd
    onrestart restart zygote
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart drm

4：Options（选项）

init.rc 中可用的选项如下：

Option	Description
critical	表明这是对设备至关重要的服务；如果它在四分钟内退出超过四次，则设备将进入Recovery 模式
disabled	表示此服务是不会自动启动，而是需要通过显示调用服务名来启动
setenv	设置环境变量 为值
socket [ [] ]	创建一个名为dev/socket/的 socket，然后将它的fd值传给启动它的进，有效的值包括dgram,stream 和seqpacket。ueser 和group 的默认值为0。
user	在启动服务前将用户切换至,默认情况下用户都是root。
group []*	在启动服务前将用户组切换至
oneshot	当次服务退出时，不要主动去重启它
class	为该服务指定一个class 名。同一个class 的所有服务必须同时启动或者停止。默认情况下服务的class名是“default”
onrestart	当次服务重启时，执行某些命令

---

二：init.rc解析

/system/core/init/init.cpp
/system/core/init/init_parser.cpp

1：init.rc脚本基本结构

init.rc 脚本的基本单位为section，即片段，section 分为三类，分别由三个关键字(所谓关键字即每一行的第一列)来区分，这三个关键字是on、service、import。

• on ——即前文的action 的起始关键字；
  on 类型的section 表示一系列命令的组合；

 on init
    loglevel 3
    symlink /system/etc /etc
    symlink /sys/kernel/debug /d
    symlink /system/vendor /vendor
    mount cgroup none /acct cpuacct
    mkdir /acct/uid

这条命令包含上述的命令，命令的执行事以section 为单位执行的，所以这几条命令是一起执行的，而不会单独执行，那它们是在那里执行呢？——这是由init.cpp中的main()方法决定的，init.cpp在某个阶段会执行

action_for_each_trigger("init", action_add_queue_tail);

该方法就是将 on init 开始的section 里面的所有命令加入到一个执行队列，在未来的某个时间会顺序的执行，所以调用action_for_each_trigger的先后决定了命令执行的先后顺序；

• service ——即前文所说的服务起始关键字；
  service类型的section代表了一个可执行程序；

service servicemanager /system/bin/servicemanager
    class core
    user system
    group system
    critical
    onrestart restart healthd
    onrestart restart zygote
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart drm

服务的内容之前已经介绍过，可以看看前文，那service 类型的section标识的服务在什么时候调用呢？—— 是在class_start命令被执行的时候，class_start命令总是存在于on 类型的section中；

class_start core #这样一条命令代表将启动所有类型为core的service
所以可以看出android的启动过程主要就是on类型的section被执行的过程。

• import —— import类型的section代表将引入另外一个.rc文件；

import /init.environ.rc
import /init.usb.rc

相当包含另外一些section, 在解析完init.rc文件后继续会调用init_parse_config_file来解析引入的.rc文件

2：解析过程

init.rc是一个纯文本文件，我们需要程序去解析init.rc，然后交给程序运行，解析init.rc的过程就是识别一个个section的过程，将各个section的信息保存下来，然后在init.c的main()中去执行一个个命令。

android采用双向链表来存储section的信息，解析完成之后，会得到三个双向链表action_list、service_list、import_list来分别存储三种section的信息上。

/system/core/init/init_parser.cpp
static list_declare(service_list);
static list_declare(action_list);
static list_declare(action_queue);

1:init.c中调用init_parse_config_file("/init.rc")

int init_parse_config_file(const char *fn)
{
    char *data;
    data = read_file(fn, 0);//读文件数据
    if (!data) return -1;

    parse_config(fn, data);//解析数据
    DUMP();
    return 0;
}

2:parse_config

static void parse_config(const char *fn, const std::string& data)
{
    struct listnode import_list;
    struct listnode *node;
    char *args[INIT_PARSER_MAXARGS];

    int nargs = 0;

    parse_state state;
    state.filename = fn;
    state.line = 0;
    state.ptr = strdup(data.c_str());  // TODO: fix this code!
    state.nexttoken = 0;
    state.parse_line = parse_line_no_op;

    list_init(&import_list);
    state.priv = &import_list;

    for (;;) {
        switch (next_token(&state)) { //next_token()根据从state.ptr开始遍历
        case T_EOF: //遍历到文件结尾，然后goto解析import的.rc文件
            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)) { // 如果这是一个section的第一行
                    state.parse_line(&state, 0, 0);
                    parse_new_section(&state, kw, nargs, args);
                } else { //如果这不是一个section的第一行
                    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;

         ret = init_parse_config_file(import->filename);
         if (ret)
             ERROR("could not import file '%s' from '%s'\n",
                   import->filename, fn);
    }
}

next_token() 解析完init.rc中一行之后，会返回T_NEWLINE，这时调用lookup_keyword函数来找出这一行的关键字, lookup_keyword返回的是一个整型值，对应keyword_info[]数组的下标，keyword_info[]存放的是keyword_info结构体类型的数据，

struct {
   const char *name;                                    //关键字的名称
   int (*func)(int nargs, char **args);            //对应的处理函数
   unsigned char nargs;                                //参数个数
   unsigned char flags;                                 //flag标识关键字的类型,包括COMMAND、OPTION、SECTION
} keyword_info

keyword_info[]中存放的是所有关键字信息，每一项对应一个关键字；
根据每一项的flags就可以判断出关键字的类型，如新的一行是SECTION，就调用parse_new_section()来解析这一行, 如新的一行不是一个SECTION的第一行，那么调用state.parseline()来解析(state.parseline所对应的函数会根据section类型的不同而不同)，在parse_new_section()中进行动态设置。

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: //解析service
        state->context = parse_service(state, nargs, args);
        if (state->context) {
            state->parse_line = parse_line_service; //Service 对应的parse_line
            return;
        }
        break;
    case K_on://解析 on 开头的action
        state->context = parse_action(state, nargs, args);
        if (state->context) {
            state->parse_line = parse_line_action; //action 对应的parse_line
            return;
        }
        break;
    case K_import: //解析import
        parse_import(state, nargs, args);
        break;
    }
    state->parse_line = parse_line_no_op;
}

三种类型的section: service、on、import, service对应的state.parse_line为parse_line_service,
on对应的state.parse_line为parse_line_action, import section中只有一行所以没有对应的state.parseline。

鉴于篇幅原因，使用文字描述parse_service过程，parse_action，parse_import解析也是类似的：

parse_service会去service_list链表查找有没有该命名的service(svc = service_find_by_name(args[1]);)，如果没有则会构造service 对象并添加到service_list链表中，返回该service 对象；但是这个service 没有Options，然后通过parse_line_service 解析Options选项填充service 对象；

3：相关结构体

一个on类型的section对应一个action， action类型定义如下：

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;

        /* list of actions which triggers the commands*/
    struct listnode triggers;
    struct listnode commands; //command的双向链表
    struct command *current;
};

每个on类型section的第二行开始每一行都解析了一个command, 所有command组成一个双向链表指向该action的commands字段中。

command结构体定义如下：

struct command
{
        /* list of commands in an action */
    struct listnode clist;

    int (*func)(int nargs, char **args);

    int line;
    const char *filename;

    int nargs;
    char *args[1];
};

command结构体比较简单, 用于标识一个命令，包含双向链表指针、对应的执行函数、参数个数以及命令关键字。

service结构体定义如下：

struct service {
    void NotifyStateChange(const char* new_state);

        /* list of all services */
    struct listnode slist;

    char *name;
    const char *classname;

    unsigned flags;
    pid_t pid;
    time_t time_started;    /* time of last start */
    time_t time_crashed;    /* first crash within inspection window */
    int nr_crashed;         /* number of times crashed within window */

    uid_t uid;
    gid_t gid;
    gid_t supp_gids[NR_SVC_SUPP_GIDS];
    size_t nr_supp_gids;

    const char* seclabel;

    struct socketinfo *sockets;
    struct svcenvinfo *envvars;

    struct action onrestart;  /* Actions to execute on restart. */

    std::vector* writepid_files_;

    /* keycodes for triggering this service via /dev/keychord */
    int *keycodes;
    int nkeycodes;
    int keychord_id;

    IoSchedClass ioprio_class;
    int ioprio_pri;

    int nargs;
    /* "MUST BE AT THE END OF THE STRUCT" */
    char *args[1];
}; 

service结构体存储了service的相关信息, 包括进程号、启动时间、名字等， onrestart这个option后面通常跟着一个命令，所以也用action结构体来表示。
例如：

service servicemanager /system/bin/servicemanager
    class core
    user system
    group system
    critical
    onrestart restart healthd
    onrestart restart zygote
    onrestart restart media
    onrestart restart surfaceflinger
    onrestart restart drm

init.rc中配置的service 启动流程：

/system/core/rootdir/init.rc
      class_start core
  on nonencrypted
      class_start main
      class_start late_start

/system/core/init/keywords.h
      KEYWORD(class_start, COMMAND, 1, do_class_start)

/system/core/init/builtins.c
  int do_class_start(int nargs, char **args)
  {
        /* Starting a class does not start services
         * which are explicitly disabled.  They must
         * be started individually.
         */
    service_for_each_class(args[1], service_start_if_not_disabled);
    return 0;
  }

/system/core/init/init_parser.cpp
  void service_for_each_class(const char *classname,
                            void (*func)(struct service *svc))
  {
      struct listnode *node;
      struct service *svc;
      list_for_each(node, &service_list) {
          svc = node_to_item(node, struct service, slist);
          if (!strcmp(svc->classname, classname)) {
              func(svc);
          }
      }
  }

/system/core/init/builtins.cpp
  static void service_start_if_not_disabled(struct service *svc)
  {
      if (!(svc->flags & SVC_DISABLED)) {
          service_start(svc, NULL);
      } else {
          svc->flags |= SVC_DISABLED_START;
      }
  }

/system/core/init/init.c
  void service_start(struct service *svc, const char *dynamic_args)
  {
      struct stat s;
      pid_t pid;
      int needs_console;
      int n;
      char *scon = NULL;
      int rc;

        /* starting a service removes it from the disabled or reset
         * state and immediately takes it out of the restarting
         * state if it was in there
         */
      ......
      pid = fork();//fork 子进程
      ......
      for (si = svc->sockets; si; si = si->next) {
            int socket_type = (
                    !strcmp(si->type, "stream") ? SOCK_STREAM :
                        (!strcmp(si->type, "dgram") ? SOCK_DGRAM : SOCK_SEQPACKET));//判断socket 类型
            int s = create_socket(si->name, socket_type,
                                  si->perm, si->uid, si->gid, si->socketcon ?: scon);//创建socket对应的fd
            if (s >= 0) {
                publish_socket(si->name, s);//发布socket的fd，即将create_socket返回的fd添加到
                                            //以"ANDROID_SOCKET_"为前缀的环境变量；
                                            //Zygote的socket的key 为ANDROID_SOCKET_zygote，也是在这创建的；
            }
       }
      ......