offsetof

⽂件解析过程详解

⼀、⽂件结构介绍

⽂件基本组成单位是section。section分为三种类型，分别由三个关键字(所谓关键字即每⼀⾏的第⼀列)来区分，这三个

关键字是on、service、import。

1、on类型的section表⽰⼀系列命令的组合,例如：

oninit

exportPATH/sbin:/system/sbin:/system/bin

exportANDROID_ROOT/system

exportANDROID_DATA/data

这样⼀个section包含了三个export命令，这些命令的执⾏是以section为单位的，也就是说这三个命令总是⼀起执⾏，

那什么时候执⾏呢？这是由init.c的main函数所决定的，main函数⾥在某个时刻会调⽤如下语句：

action_for_each_trigger("init",action_add_queue_tail);

这个调⽤将"oninit"开始的这样⼀个section⾥的所有命令加⼊到⼀个执⾏队列，在未来的某个时候会顺序执⾏队列⾥的命令，所

以调⽤action_for_each_trigger的先后决定了命令执⾏的先后。

2、service类型的section表⽰⼀个可执⾏程序，例如:

servicesurfaceflinger/system/bin/surfaceflinger

classmain

usersystem

groupgraphicsdrmrpc

onrestartrestartzygote

"surfaceflinger"作为⼀个名字标识了这个service,"/system/bin/surfaceflinger"表⽰可执⾏⽂件的位置，class、user、group、

onrestart这些关键字所对应的⾏都被称为options，options是⽤来描述的service⼀些特点，不同的service有着不同的options。

service类型的section标识了⼀个service(或者说可执⾏程序)，那这个service什么时候被执⾏呢？是在class_start这个命令被执

⾏的时候，class_start命令⾏总是存在于某个on类型的section中，像"class_startcore”这样⼀条命令被执⾏，就会启动类型为core的

所有service。所以可以看出android的启动过程主要就是on类型的section被执⾏的过程。

3、import类型的section表⽰引⼊另外⼀个.rc⽂件，例如：

这种section表⽰包含另外⼀些section(这些section存在于另外的.rc⽂件中),在解析完⽂件后继续会调init_parse_config_file

来解析引⼊的.rc⽂件。

⼆、⽂件解析过程

我们已经知道的结构，应该可以想到解析的过程就是识别⼀个个section的过程，将各个section的信息保存下来，然

后在init.c的main函数中去执⾏⼀个个命令。android采⽤双向链表(关于双向链表详解见本⽂第三部分)来存储section的信息，解析完

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

1、init.c中调⽤init_parse_config_file(“/”)，代码如下：

intinit_parse_config_file(constchar*fn)

{

char*data;

data=read_file(fn,0);//read_file()调⽤openlseekread将读出来

if(!data)return-1;

parse_config(fn,data);//调⽤parse_config开始解析

DUMP();

return0;

}

2、parse_config()代码如下：

staticvoidparse_config(constchar*fn,char*s)

{

structparse_statestate;

structlistnodeimport_list;

structlistnode*node;

char*args[INIT_PARSER_MAXARGS];

intnargs;

nargs=0;

me=fn;

=0;

=s;

ken=0;

_line=parse_line_no_op;

list_init(&import_list);

=&import_list;

for(;;){

switch(next_token(&state)){//next_token()根据从开始遍历

caseT_EOF://遍历到⽂件结尾，然后goto解析import的.rc⽂件

_line(&state,0,0);

gotoparser_done;

caseT_NEWLINE://到了⼀⾏结束

++;

if(nargs){

intkw=lookup_keyword(args[0]);//找到这⼀⾏的关键字

if(kw_is(kw,SECTION)){//如果这是⼀个section的第⼀⾏

_line(&state,0,0);

parse_new_section(&state,kw,nargs,args);

}else{//如果这不是⼀个section的第⼀⾏

_line(&state,nargs,args);

}

nargs=0;

}

break;

caseT_TEXT://遇到普通字符

if(nargs

args[nargs++]=;

}

break;

}

}

parser_done:

list_for_each(node,&import_list){

structimport*import=node_to_item(node,structimport,list);

intret;

INFO("importing'%s'",import->filename);

ret=init_parse_config_file(import->filename);

if(ret)

ERROR("couldnotimportfile'%s'from'%s'n",

import->filename,fn);

}

}

next_token()解析完中⼀⾏之后，会返回T_NEWLINE，这时调⽤lookup_keyword函数来找出这⼀⾏的关键字,

lookup_keyword返回的是⼀个整型值，对应keyword_info[]数组的下标，keyword_info[]存放的是keyword_info结构体类型的数据，

下⾯是keyword_info结构体的定义:

struct{

constchar*name;//关键字的名称

int(*func)(intnargs,char**args);//对应的处理函数

unsignedcharnargs;//参数个数

unsignedcharflags;//flag标识关键字的类型,包括COMMAND、OPTION、SECTION

}keyword_info

因此keyword_info[]中存放的是所有关键字的信息，每⼀项对应⼀个关键字。

根据每⼀项的flags就可以判断出关键字的类型，如新的⼀⾏是SECTION，就调⽤parse_new_section()来解析这⼀⾏,如新的⼀

⾏不是⼀个section的第⼀⾏，那么调⽤ine()来解析(ine所对应的函数会根据section类型的不同⽽不同)，在

parse_new_section()中进⾏动态设置。

三种类型的section：service、on、import,service对应的ine为parse_line_service，on对应的ine为

parse_line_action，importsection中只有⼀⾏所以没有对应的ine。

3、parse_new_section代码如下:

voidparse_new_section(structparse_state*state,intkw,

intnargs,char**args)

{

printf("[%s%s]n",args[0],

nargs>1?args[1]:"");

switch(kw){

caseK_service:解析service类型的section

state->context=parse_service(state,nargs,args);

if(state->context){

state->parse_line=parse_line_service;

return;

}

break;

caseK_on:解析on类型的section

state->context=parse_action(state,nargs,args);

if(state->context){

state->parse_line=parse_line_action;

return;

}

break;

caseK_import:解析import类型的section

parse_import(state,nargs,args);

break;

}

state->parse_line=parse_line_no_op;

}

4、parse_service()和parse_line_service()

parse_service()代码如下：

staticvoid*parse_service(structparse_state*state,intnargs,char**args)

{

structservice*svc;

if(nargs<3){

parse_error(state,"servicesmusthaveanameandaprogramn");

return0;

}

if(!valid_name(args[1])){

parse_error(state,"invalidservicename'%s'n",args[1]);

return0;

}

svc=service_find_by_name(args[1]);//在链表中查找当前⾏对应的service

if(svc){

parse_error(state,"ignoredduplicatedefinitionofservice'%s'n",args[1]);

return0;

}

//如果当前⾏对应的service还没有加⼊service_list链表，则新建⼀个

nargs-=2;

svc=calloc(1,sizeof(*svc)+sizeof(char*)*nargs);

if(!svc){

parse_error(state,"outofmemoryn");

return0;

}

svc->name=args[1];

svc->classname="default";

memcpy(svc->args,args+2,sizeof(char*)*nargs);

svc->args[nargs]=0;

svc->nargs=nargs;

svc->="onrestart";

list_init(&svc->ds);

list_add_tail(&service_list,&svc->slist);//将这个service加⼊到service_list

//注意此时svc对象基本上是⼀个空壳，因为相关的options还没有解析

returnsvc;

}

parse_line_service()解析service对应的options⾏，主要是填充parse_service()中创建的service对象。

5、parse_action()和parse_line_action()

parse_action()函数主要是根据当前⾏的信息创建⼀个action结构体类型的对象，加⼊到action_list双向链表中,代码⽐较简单，有

兴趣可⾃⾏研究。

parse_line_action()解析对应的命令⾏,代码如下:

staticvoidparse_line_action(structparse_state*state,intnargs,char**args)

{

structcommand*cmd;

structaction*act=state->context;

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

intkw,n;

if(nargs==0){

return;

}

kw=lookup_keyword(args[0]);

if(!kw_is(kw,COMMAND)){

parse_error(state,"invalidcommand'%s'n",args[0]);

return;

}

n=kw_nargs(kw);

if(nargs

parse_error(state,"%srequires%d%sn",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类型定义如下：

structaction{

/*nodeinlistofallactions*/

structlistnodealist;

/*nodeinthequeueofpendingactions*/

structlistnodeqlist;

/*nodeinlistofactionsforatrigger*/

structlistnodetlist;

unsignedhash;

constchar*name;

structlistnodecommands;//command的双向链表

structcommand*current;

};

因此，每个on类型section的第⼆⾏开始每⼀⾏都解析了⼀个command,所有command组成⼀个双向链表指向该action的

commands字段中。

三、相关结构体

1、listnode结构体

listnode结构体⽤于建⽴双向链表，这种结构⼴泛⽤于kernel代码中,android源代码中定义了listnode结构体以及相关操作双向链

表的⽅法，与kernel中的定义类似。这种实现的核⼼思想是：在⽤户⾃定义的结构体xx中定义⼀个listnode类型的成员,这个listnode类

型成员的作⽤就是能将xx类型的变量组成⼀个双向链表。下⾯我们来看⼀下是listnode是怎么做到的。

//listnode类型⾥⾯只有两个指针prev,next

structlistnode

{

structlistnode*next;

structlistnode*prev;

};

//将链表中的⼀个node转换成⾃定义结构体中的⼀个对象

#definenode_to_item(node,container,member)

(container*)(((char*)(node))-offsetof(container,member))

//初始化⼀个链表

voidlist_init(structlistnode*node)

{

node->next=node;

node->prev=node;

}

//将⼀个节点到链表

voidlist_add_tail(structlistnode*head,structlistnode*item)

{

item->next=head;

item->prev=head->prev;

head->prev->next=item;

head->prev=item;

}

//删除⼀个节点

voidlist_remove(structlistnode*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结构体定义如下:

structaction{

/*nodeinlistofallactions*/

structlistnodealist;

/*nodeinthequeueofpendingactions*/

structlistnodeqlist;

/*nodeinlistofactionsforatrigger*/

structlistnodetlist;

unsignedhash;

constchar*name;

structlistnodecommands;//节点为command结构体的双向链表

structcommand*current;

};

action结构体除了⽤在on类型的section,也⽤在service类型的section，下⾯介绍service结构体时会说明。

3、command结构体

command结构体定义如下:

structcommand

{

/*listofcommandsinanaction*/

structlistnodeclist;

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

intnargs;

char*args[1];

};

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

4、service结构体

structservice{

/*listofallservices*/

structlistnodeslist;//将结构体链接成service_list⽤

constchar*name;

constchar*classname;

unsignedflags;

pid_tpid;

time_ttime_started;/*timeoflaststart*/

time_ttime_crashed;/*firstcrashwithininspectionwindow*/

intnr_crashed;/*numberoftimescrashedwithinwindow*/

uid_tuid;

gid_tgid;

gid_tsupp_gids[NR_SVC_SUPP_GIDS];

size_tnr_supp_gids;

#ifdefHAVE_SELINUX

char*seclabel;

#endif

structsocketinfo*sockets;

structsvcenvinfo*envvars;

structactiononrestart;/*Actionstoexecuteonrestart.*/

/*keycodesfortriggeringthisservicevia/dev/keychord*/

int*keycodes;

intnkeycodes;

intkeychord_id;

intioprio_class;

intioprio_pri;

intnargs;

/*"MUSTBEATTHEENDOFTHESTRUCT"*/

char*args[1];

};

service结构体存储了service的相关信息,包括进程号、启动时间、名字等,，字段onrestart就⽤到了action结构体，onrestart这个

option后⾯通常跟着⼀个命令，所以也⽤action结构体来表⽰。

注：本⽂基于android4.2的源代码分析