首页 > 代码库 > Android init.rc 文件解析
Android init.rc 文件解析
init.rc文件解析过程
我们已经知道init.rc的结构，应该可以想到解析init.rc的过程就是识别一个个section的过程，将各个section的信息保存下来，然后在init.c的main()中去执行一个个命令。
android采用双向链表(关于双向链表详解见本文第三部分)来存储section的信息，解析完成之后，会得到三个双向链表action_list、service_list、import_list来分别存储三种section的信息上。
1. init.c中调用init_parse_config_file(“/init.rc”)， 代码如下：
int init_parse_config_file(const char *fn)
{
char *data;
data = http://www.mamicode.com/read_file(fn, 0); >//read_file()调用open\lseek\read 将init.rc读出来
if (!data) return -1;
parse_config(fn, data); //调用parse_config开始解析
DUMP();
return 0;
}
2. parse_config()代码如下：
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)) { //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，只有Service 和 on 满足
state.parse_line(&state, 0, 0);
parse_new_section(&state, kw, nargs, args); //解析on 或service
} else { //如果这不是一个Section的第一行,那就是service 或on 下面的内容
state.parse_line(&state, nargs, args);
}
nargs = 0;
}
break;
case T_TEXT: //遇到普通字符
if (nargs < INIT_PARSER_MAXARGS) {
args[nargs++] = state.text;
}
break;
}/*switch*/
}/*for(;;)*/
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);
}
}/*parse_config*/
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[]中存放的是所有关键字的信息，每一项对应一个关键字。
keyword_info 结构体定义在： system/core/init/init_parser.c
keyword_info[] 定义在： system/core/init/keywords.h
根据每一项的flags就可以判断出关键字的类型，如新的一行是SECTION，就调用parse_new_section()来解析这一行, 如新的一行不是一个SECTION的第一行，那么调用state.parseline()来解析(state.parseline所对应的函数会根据section类型的不同而不同)，在parse_new_section()中进行动态设置。
三种类型的section: service、on、import,
service 对应的state.parseline为 parse_line_service,
on 对应的state.parseline为 parse_line_action,
import section中只有一行所以没有对应的state.parseline。
3、parse_new_section 代码如下:
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类型的section
state->context = parse_service(state, nargs, args);
if (state->context) {
state->parse_line = parse_line_service;
return;
}
break;
case K_on: \\解析on类型的section
state->context = parse_action(state, nargs, args);
if (state->context) {
state->parse_line = parse_line_action;
return;
}
break;
case K_import: \\解析import类型的section
parse_import(state, nargs, args);
break;
}
state->parse_line = parse_line_no_op;
}
4、parse_service()和parse_line_service()
parse_service()代码如下：
static void *parse_service(struct parse_state *state, int nargs, char **args)
{
struct service *svc;
if (nargs < 3) {
parse_error(state, "services must have a name and a program\n");
return 0;
}
if (!valid_name(args[1])) {
parse_error(state, "invalid service name ‘%s‘\n", args[1]);
return 0;
}
svc = service_find_by_name(args[1]); //在链表中查找当前行对应的service
if (svc) {
parse_error(state, "ignored duplicate definition of service ‘%s‘\n", args[1]);
return 0;
}
//如果当前行对应的service还没有加入service_list链表，则新建一个
nargs-= 2;
svc = calloc(1, sizeof(*svc) + sizeof(char*) * nargs);
if (!svc) {
parse_error(state, "out of memory\n");
return 0;
}
svc->name = args[1]; // service 的名字
svc->classname = "default"; //svc 的类名默认为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);
list_add_tail(&service_list,& svc->slist); //将这个service加入到service_list
//注意此时svc对象基本上是一个空壳，因为相关的options还没有解析
return svc;
}
parse_line_service()解析service对应的options行，主要是填充parse_service()中创建的service对象。
5、parse_action()和parse_line_action()
parse_action()函数主要是根据当前行的信息创建一个action结构体类型的对象，加入到action_list双向链表中,代码比较简单，有兴趣可自行研究。
parse_line_action()解析对应的命令行,代码如下:
static void parse_line_action(struct parse_state* state, int nargs, char **args)
{
struct command *cmd;
struct action *act = state->context;
int (*func)(int nargs, char **args);
int kw, n;
if (nargs == 0) {
return;
}
kw = lookup_keyword(args[0]);
if (!kw_is(kw, COMMAND)) {
parse_error(state, "invalid command ‘%s‘\n", args[0]);
return;
}
n = kw_nargs(kw);
if (nargs < n) {
parse_error(state, "%s requires %d %s\n", args[0], n - 1, n> 2 ? "arguments" : "argument");
return;
}
cmd = malloc(sizeof(*cmd) + sizeof(char*) * nargs); //生成一个command类型的对象
cmd->func = kw_func(kw);
cmd->nargs = nargs;
memcpy(cmd->args, args, sizeof(char*) * nargs);
list_add_tail(&act->commands,& cmd->clist); //将这个command对象加入actions->commands
}
一个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;
const char *name;
struct listnode commands; //command的双向链表
struct command *current;
};
因此，每个on类型section的第二行开始每一行都解析了一个command,所有command组成一个双向链表指向该action的commands字段中。
三、相关结构体
1、listnode
listnode 结构体用于建立双向链表，这种结构广泛用于kernel代码中,android源代码中定义了listnode结构体以及相关操作双向链表的方法，与kernel中的定义类似。
listnode 定义在：system/core/include/cutils/list.h
system/core/libcutils/list.c
这个实现的核心思想是：在用户自定义的结构体xx中定义一个listnode类型的成员,
这个listnode类型成员的作用就是能将xx类型的变量组成一个双向链表。下面我们来看一下是listnode是怎么做到的。
//listnode 类型里面只有两个指针prev,next
struct listnode
{
struct listnode *next;
struct listnode *prev;
};
//将链表中的一个node转换成自定义结构体中的一个对象
#define node_to_item(node, container, member) \
(container *) (((char*) (node)) - offsetof(container, member))
//初始化一个链表
void list_init(struct listnode *node)
{
node->next = node;
node->prev = node;
}
//将一个节点到链表
void list_add_tail(struct listnode *head, struct listnode *item)
{
item->next = head;
item->prev = head->prev;
head->prev->next = item;
head->prev = item;
}
//删除一个节点
void list_remove(struct listnode *item)
{
item->next->prev = item->prev;
item->prev->next = item->next;
}
理解node_to_item宏是理解listnode用法的关键，这个宏的作用是将一个listnode指针转换成了一个指定类型（自定义）的指针，这个宏先使用offsetof函数获取到指定结构体中指定成员变量的地址偏移量，然后通过指针运算获得listnode指针变量所在结构体变量的指针。
这种实现与我们课堂上所学的链表实现方法不太一样，教科书上的实现是在listnode中存储了自定义的数据，而这个实现是在自定义的数据当中存储listnode指针。
2、action结构体
前面已经讲过on类型的section解析之后会生成一个双向链表action_list,这个action_list每个node表示就是action结构体的对象，也就是说一个on类型的section都会生成一个action结构体的对象。
action,command,service defined by: system/core/init/init.h
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;
const char *name;
struct listnode commands; //节点为command结构体的双向链表
struct command *current;
};
action结构体除了用在on类型的section,也用在service类型的section，下面介绍service结构体时会说明。
3、command结构体
Command结构体定义如下:
struct command
{
/*list of commands in an action */
struct listnode clist;
int (*func)(int nargs, char **args);
int nargs;
char *args[1];
};
command结构体比较简单,用于标识一个命令，包含双向链表指针、对应的执行函数、参数个数以及命令关键字。
4、service结构体
struct service {
/*list of all services */
struct listnode slist; //将结构体链接成service_list用
const 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;
#ifdef HAVE_SELINUX
char *seclabel;
#endif
struct socketinfo *sockets;
struct svcenvinfo *envvars;
struct action onrestart; /* Actions to execute on restart. */
/*keycodes for triggering this service via /dev/keychord */
int *keycodes;
int nkeycodes;
int keychord_id;
int ioprio_class;
int ioprio_pri;
int nargs;
/* "MUST BE AT THE END OF THE STRUCT" */
char *args[1];
};
service结构体存储了service的相关信息,包括进程号、启动时间、名字等,字段onrestart
就用到了action结构体，onrestart这个option后面通常跟着一个命令，所以也用action结构体来表示。
Ref:
http://wenku.baidu.com/link?url=iMIWW3z5geqsMXf1eYLq7HLeYerrV4_Kwy2a0SRqMCAAeGLGiEeasyXENg5hsCTQrRy-ltbXh7o5EYXPEY15cdrovy_3x_yd_-UzBdySMgG
http://www.docin.com/p-623861334.html