w10系统好用吗-lenovog470驱动
![offsetof](/uploads/image/0058.jpg)
2023年4月3日发(作者:怎样恢复回收站删除的文件)
⽂件解析过程详解
⼀、⽂件结构介绍
⽂件基本组成单位是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的源代码分析
更多推荐
offsetof
发布评论