Linux内核链表的核心思想是：在用户自定义的结构A中声明list_head类型的成员p，这样每个结构类型为A的变量a中，都拥有同样的成员p，如下：

struct A{

int property;

struct list_head p;

}

其中，list_head结构类型定义如下：

struct list_head {

struct list_head *next,*prev;

};

list_head拥有两个指针成员，其类型都为list_head，分别为前驱指针prev和后驱指针next。

假设：

（1）多个结构类型为A的变量a1...an，其list_head结构类型的成员为p1...pn

（2）一个list_head结构类型的变量head，代表头节点

使：

（1）head.next= p1 ; head.prev = pn

（2） p1.prev = head，p1.next = p2;

（3）p2.prev= p1 , p2.next = p3;

…

（n）pn.prev= pn-1 , pn.next = head

以上，则构成了一个循环链表。

因p是嵌入到a中的，p与a的地址偏移量可知，又因为head的地址可知，所以每个结构类型为A的链表节点a1...an的地址也是可以计算出的，从而可实现链表的遍历，在此基础上，则可以实现链表的各种操作。

注：android源码中就是使用的

struct listnode {

struct listnode *next,*prev;

};

#define list_for_each(pos, head) \

for (pos = (head)->next; prefetch(pos->next), pos != (head); pos = pos->next)

从上可以看出list_for_each其实就是一个for循环，

for()实现的就是一个链表的遍历。

同时，为了取得链表中的节点值，还是用了node_to_item函数来取得节点数据。

综合使用如下：

list_for_each(node, &service_list) {

svc = node_to_item(node, struct service, slist);

/*处理函数*/

Fun（）….

}

struct command

{

/* list of commands in an action */

struct listnode clist;

/*在后面分析的parse_line_service函数中的switch语句中的case K_onrestart中会给此函数指针赋值，指向具体的command执行函数*/

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

int nargs;

char *args[1];

};

SVC_DISABLED：不随class自启动(后面会分析class的作用)；

SVC_ONESHOT：退出后不需要重启，也就是说这个service只启动一次；

SVC_RUNNING：正在运行；

SVC_RESTARTING：等待重启；

SVC_CONSOLE：该service需要使用控制台；

SVC_CRITICAL：如果在规定的时间内该service不断重启，则系统会重启并进入恢复模式

SVC_RESET：当系统主动停止一个service的时候使用，这不会让该service变成disable状态，所以，该service可以随着其所属的class的启动而启动；

SVC_RC_DISABLED：记住service的disable标记是否由init.rc脚本显示指定的；

SVC_RESTART：用于安全地重启一个service;

Zygote没有使用任何属性，这表明他它会随着class的处理而自动启动，退出后由init重启；不使用控制台；即使不断重启也不会进入恢复模式。

list_init(&svc->onrestart.commands);

list_add_tail(&service_list, &svc->slist);

kw = lookup_keyword(args[0]);  //将rc中的字符型kw转换成keywords.h中定义的枚举值。

/*根据kw的值，进行相应的操作*/

switch(kw){

case:

……….

};

action_for_each_trigger("boot", action_add_queue_tail);

//将init.rc中boot section 的command加入到执行队列中。

On boot

……

class_start core

class_start main

/* run all property triggers based on current state of the properties */

queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");

int do_class_start(int nargs, char **args)

{

/* Starting a class does not start services

* which are explicitly disabled.  They must

* be started individually.

*/

/*

Args为init.rc文件中class后面的那个参数值(core或main)。下面这个函数将遍历service_list，找到对应名字的service，然后调用service_start_if_not_disable函数——此函数实质上就是调用service_start函数。

*/

service_for_each_class(args[1], service_start_if_not_disabled);

return 0;

}

if (stat(svc->args[0], &s) != 0) {

ERROR("cannot find '%s', disabling '%s'\n", svc->args[0], svc->name);

svc->flags |= SVC_DISABLED;

return;

}

pid = fork();

if (pid == 0) { //表示现在运行在子进程中

struct socketinfo *si;

struct svcenvinfo *ei;

char tmp[32];

int fd, sz;

umask(077); //默认目录权限为700，文件权限为600

if (properties_inited()) { //判断属性是否已经完成初始化了

//得到属性存储空间的信息并加入到环境变量中

get_property_workspace(&fd, &sz);

sprintf(tmp, "%d,%d", dup(fd), sz);

add_environment("ANDROID_PROPERTY_WORKSPACE", tmp);

}

//添加环境变量信息

for (ei = svc->envvars; ei; ei = ei->next)

add_environment(ei->name, ei->value);

//根据socketinfo创建socket，SOCK_STREAM 用于面向流的套接字, SOCK_DGRAM 用于面向数据报的套接字,其可以保存消息界限. Unix 套接字总是可靠的,而且不会重组数据报.

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，这里创建的socket的域名是PF_UNIX:用于本地进程间的通信

int s = create_socket(si->name, socket_type,

si->perm, si->uid, si->gid, si->socketcon ?: scon);

if (s >= 0) {

//在环境变量中添加socket信息

publish_socket(si->name, s);

}

}

freecon(scon); //不懂，什么意思？网上说是：free memory associated with SELinux security contexts. 暂且当作free看待吧~

scon = NULL;

…

//判断service是否需要控制终端

if (needs_console) {

//调用setsid(),使得当前进程成为会话组长。详细信息涉及到pid,gid,sid等，可自行百度。

setsid();

open_console();

} else {

zap_stdio();

}

//然后就是设置gid,uid等

……

if (!dynamic_args) {

// 执行/system/bin/app_process，这样就进入到app_process的MAIN函数中了。

if (execve(svc->args[0], (char**) svc->args, (char**) ENV) < 0) {

ERROR("cannot execve('%s'): %s\n", svc->args[0], strerror(errno));

}

} else {

………

}

……

//父进程init中，设置service的信息：启动时间，进程号，以及状态等。

svc->time_started = gettime();

svc->pid = pid;

svc->flags |= SVC_RUNNING;

if (properties_inited()){

//每一个service都有一个属性，zygote的属性为init.svc.zygote,

现在设置它的值为”running”。

notify_service_state(svc->name, "running");

}

}?end service start?

//执行signal_init_action函数。此函数初始化父子进程信号量处理机制。

queue_builtin_action(signal_init_action, "signal_init");

//signal_init_action函数调用signal_init().

static int signal_init_action(int nargs, char **args)

{

signal_init();

return 0;

}

//重点就是这个函数

void signal_init(void)

{

int s[2];

//声明一个信号量处理结构体

struct sigaction act;

memset(&act, 0, sizeof(act));

act.sa_handler = sigchld_handler;

/*

定义信号量处理函数，当子进程退出时，调用此函数。

static void sigchld_handler(int s)

{

write(signal_fd, &s, 1); //向父进程(init)发送信号

}

*/

act.sa_flags = SA_NOCLDSTOP;

sigaction(SIGCHLD, &act, 0);

/* create a signalling mechanism for the sigchld handler

使用socketpair创建一对socket，只要一个socket发送数据，另一个socket就一定能收到此数据。

*/

if (socketpair(AF_UNIX, SOCK_STREAM, 0, s) == 0) {

signal_fd = s[0];   //发送方socket，一般是子进程使用

signal_recv_fd = s[1]; //接收方socket，一般是父进程(init)使用

fcntl(s[0], F_SETFD, FD_CLOEXEC);

fcntl(s[0], F_SETFL, O_NONBLOCK);

fcntl(s[1], F_SETFD, FD_CLOEXEC);

fcntl(s[1], F_SETFL, O_NONBLOCK);

}

handle_signal(); //处理信号

}

nr = poll(ufds, fd_count, timeout);

if (nr <= 0)

continue;

for (i = 0; i < fd_count; i++) {

if (ufds[i].revents & POLLIN) {

if (ufds[i].fd == get_property_set_fd())

handle_property_set_fd();

else if (ufds[i].fd == get_keychord_fd())

handle_keychord();

/*★get_signal_fd函数返回signal_recv_fd，这里判断是否有来自signal_recv_fd的信息，如果有，那么就调用信号量处理函数handle_signal()

*/

else if (ufds[i].fd == get_signal_fd())

handle_signal();

}

}

void handle_signal(void)

{

char tmp[32];

/* we got a SIGCHLD - reap and restart as needed */

read(signal_recv_fd, tmp, sizeof(tmp)); //读取信号量

while (!wait_for_one_process(0))  //调用该函数进行处理

;

}

if (!(svc->flags & SVC_ONESHOT) || (svc->flags & SVC_RESTART)) {

kill(-pid, SIGKILL);

NOTICE("process '%s' killing any children in process group\n", svc->name);

}

if ((svc->flags & SVC_CRITICAL) && !(svc->flags & SVC_RESTART)) {

if (svc->time_crashed + CRITICAL_CRASH_WINDOW >= now) {

if (++svc->nr_crashed > CRITICAL_CRASH_THRESHOLD) {

ERROR("critical process '%s' exited %d times in %d minutes; "

"rebooting into recovery mode\n", svc->name,

CRITICAL_CRASH_THRESHOLD, CRITICAL_CRASH_WINDOW / 60);

android_reboot(ANDROID_RB_RESTART2, 0, "recovery");

return 0;

}

} else {

svc->time_crashed = now;

svc->nr_crashed = 1;

}

}

svc->flags |= SVC_RESTARTING;

/* Execute all onrestart commands for this service. */

/*★这里onrestart终于派上用场了！*/

list_for_each(node, &svc->onrestart.commands) {

cmd = node_to_item(node, struct command, clist);

cmd->func(cmd->nargs, cmd->args); //调用相应函数处理command

}

execute_one_command();//此函数的逻辑见下面分析。

restart_processes();  //★在这里重启所有标识为restarting的services!

void execute_one_command(void)

{

int ret;

/*如果当前action为空，或者当前command为空，或者当前command是当前action的最后一个命令，那么就在队列头取出一个action。如果取出的action为空(表示队列中已经没有需要执行的action了)，那么就直接返回，否则取得此action的第一条command*/

if (!cur_action || !cur_command || is_last_command(cur_action, cur_command)) {

cur_action = action_remove_queue_head();

cur_command = NULL;

if (!cur_action)

return;

INFO("processing action %p (%s)\n", cur_action, cur_action->name);

cur_command = get_first_command(cur_action);

} else { //如果当前action不为空，且command不为空，且不是最后一条command，那么就执行取得当前action的后一条command.

cur_command = get_next_command(cur_action, cur_command);

}

//如果command为空，就直接返回，否者执行此command。

if (!cur_command)

return;

ret = cur_command->func(cur_command->nargs, cur_command->args);

INFO("command '%s' r=%d\n", cur_command->args[0], ret);

}

open_devnull_stdio();

klog_init();

//属性服务的初始化操作，主要是分配内存什么的

property_init();

//得到硬件名字和版本号

get_hardware_name(hardware, &revision);

//处理内核命令行参数

process_kernel_cmdline();

action_for_each_trigger("early-init", action_add_queue_tail);

//此函数的作用就是将init.rc中early-init section中的action加入到全局队列action-queue中，后面类似。

queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");

//此函数的作用是将第二个参数name = “wait_for_coldboot_done”的action加入到action_queue中，并指定该action的command的执行函数为第一个参数wait_for_coldboot_done_action。后面类似。

mix_hwrng_into_linux_rng：主要用于随机数发生器，android的随机数发生器有两种/dev/hw_random or /dev/random，这里为了加强随机性，将hw_random生成的随机数中的512bytes写入到Linux RNG's via /dev/urandom中。

property_service_init：属性服务的初始化

signal_init：信号量机制的初始化，创建socket对用于init进程同其子进程通信

execute_one_command();//执行action_queue队列中当前action的一条command;

restart_processes();//执行list_service中所有flags为restarting的services;

//然后根据需要来设置ufds[], 分别监听来自属性服务器，由soketpair创建的另一个socket，keychord设备这三个事件

//然后调用poll等待监听事情的发生，如果有来自上面监听的事件，则处理事件，否则，返回for循环，做下一个action

nr = poll(ufds, fd_count, timeout);

if (nr <= 0)

continue;

for (i = 0; i < fd_count; i++) {

if (ufds[i].revents & POLLIN) {

if (ufds[i].fd == get_property_set_fd())

handle_property_set_fd();

else if (ufds[i].fd == get_keychord_fd())

handle_keychord();

else if (ufds[i].fd == get_signal_fd())

handle_signal();

}

}