标签：android
整个Android系统的启动分为Linux kernel的启动和Android系统的启动。Linux kernel启动起来后，然后就运行第一个用户程序，在Android中，就是init程序，上一博文已经介绍。Init进程始终是第一个进程。Init进程的对应的代码的main函数在目录system/core/init/init.c，先来总体看一下这个main函数。
int main(int argc, char **argv)
{
//首先声明一些局部变量
int fd_count = 0;
struct pollfd ufds[4];
char *tmpdev;
char* debuggable;
char tmp[32];
int property_set_fd_init = 0;
int signal_fd_init = 0;
int keychord_fd_init = 0;
bool is_charger = false;
//对传入的argv[0]进行判断，决定程序的执行分支
if (!strcmp(basename(argv[0]), "ueventd"))
return ueventd_main(argc, argv);
if (!strcmp(basename(argv[0]), "watchdogd"))
return watchdogd_main(argc, argv);
/* clear the umask */
umask(0);
/* Get the basic filesystem setup we need put
* together in the initramdisk on / and then we‘ll
* let the rc file figure out the rest.
*/
//建立各种用户空间的目录，挂载与内核空间交互的文件
mkdir("/dev", 0755);
mkdir("/proc", 0755);
mkdir("/sys", 0755);
mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
mkdir("/dev/pts", 0755);
mkdir("/dev/socket", 0755);
mount("devpts", "/dev/pts", "devpts", 0, NULL);
mount("proc", "/proc", "proc", 0, NULL);
mount("sysfs", "/sys", "sysfs", 0, NULL);
/* indicate that booting is in progress to background fw loaders, etc */
//创建打开/dev/.booting文件，然后关闭
close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));
/* We must have some place other than / to create the
* device nodes for kmsg and null, otherwise we won‘t
* be able to remount / read-only later on.
* Now that tmpfs is mounted on /dev, we can actually
* talk to the outside world.
*/
//system/core/init/util.c。创建设备节点/dev/__null__，利用dup2函数把标准输入、标准输出、标准错误输出重定向到这个设备文件中（0标准输入、1标准输出、2标准错误输出）。重定向操作完成后，就关闭掉fd。
open_devnull_stdio();
//system/core/libcutils/klog.c。初始化log系统/dev/__kmsg__
klog_init();
//system/core/init/property_service.c。初始化资源/dev/__properties__，主要是映射一些内存空间
property_init();
//取得硬件名,hardware通过内核命令行提供或/proc/cpuinfo文件中提供。import /init.${ro.hardware}.rc
get_hardware_name(hardware, &revision);
//使用import_kernel_cmdline函数导入内核变量，调用export_kernel_boot_props函数通过属性设置内核变量。就是来回设置一些属性值，包括hardware变量，在此处又通过ro.boot.hardware属性设置了一次值。
process_kernel_cmdline();
#ifdef HAVE_SELINUX
//SELinux(Security-Enhanced Linux) 是美国国家安全局（NSA）对于强制访问控制的实现，它是个经过安全强化的Linux操作系统，很多时候是被关闭的。
union selinux_callback cb;
cb.func_log = klog_write;
selinux_set_callback(SELINUX_CB_LOG, cb);
cb.func_audit = audit_callback;
selinux_set_callback(SELINUX_CB_AUDIT, cb);
INFO("loading selinux policy\n");
if (selinux_enabled) {
if (selinux_android_load_policy() < 0) {
selinux_enabled = 0;
INFO("SELinux: Disabled due to failed policy load\n");
} else {
selinux_init_all_handles();
}
} else {
INFO("SELinux: Disabled by command line option\n");
}
/* These directories were necessarily created before initial policy load
* and therefore need their security context restored to the proper value.
* This must happen before /dev is populated by ueventd.
*/
restorecon("/dev");
restorecon("/dev/socket");
#endif
is_charger = !strcmp(bootmode, "charger");
INFO("property init\n");
if (!is_charger)
property_load_boot_defaults();
INFO("reading config file\n");
//system/core/init/init_parser.c。读取并且解析init.rc文件
init_parse_config_file("/init.rc");
//system/core/init/init_parser.c。触发在init脚本文件中名字为early-init的action，并且执行其commands，其实是.rc文件中的: on early-init
action_for_each_trigger("early-init", action_add_queue_tail);
//system/core/init/init_parser.c。内建action并添加到action_queue中，到execute_one_command()中检测执行。
queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");
queue_builtin_action(keychord_init_action, "keychord_init");
//显示第二个开机画面
queue_builtin_action(console_init_action, "console_init");
/* execute all the boot actions to get us started */
action_for_each_trigger("init", action_add_queue_tail);
/* skip mounting filesystems in charger mode */
if (!is_charger) {
action_for_each_trigger("early-fs", action_add_queue_tail);
action_for_each_trigger("fs", action_add_queue_tail);
action_for_each_trigger("post-fs", action_add_queue_tail);
action_for_each_trigger("post-fs-data", action_add_queue_tail);
}
queue_builtin_action(property_service_init_action, "property_service_init");
queue_builtin_action(signal_init_action, "signal_init");
queue_builtin_action(check_startup_action, "check_startup");
if (is_charger) {
action_for_each_trigger("charger", action_add_queue_tail);
} else {
action_for_each_trigger("early-boot", action_add_queue_tail);
action_for_each_trigger("boot", action_add_queue_tail);
}
/* run all property triggers based on current state of the properties */
queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");
#if BOOTCHART
queue_builtin_action(bootchart_init_action, "bootchart_init");
#endif
//进入一个无限循环 to wait for device/property set/child process exit events.例如, 如果SD卡被插入，init会收到一个设备插入事件，它会为这个设备创建节点。系统中比较重要的进程都是由init来fork的，所以如果他们谁崩溃 了，那么init 将会收到一个 SIGCHLD 信号，把这个信号转化为子进程退出事件， 所以在loop中，init 会操作进程退出事件并且执行 *.rc 文件中定义的命令。
for(;;) {
int nr, i, timeout = -1;
//执行action_queue中的action，并将此action移除
execute_one_command();
//检查service_list是否有进程需要重启
restart_processes();
if (!property_set_fd_init && get_property_set_fd() > 0) {
ufds[fd_count].fd = get_property_set_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
property_set_fd_init = 1;
}
if (!signal_fd_init && get_signal_fd() > 0) {
ufds[fd_count].fd = get_signal_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
signal_fd_init = 1;
}
if (!keychord_fd_init && get_keychord_fd() > 0) {
ufds[fd_count].fd = get_keychord_fd();
ufds[fd_count].events = POLLIN;
ufds[fd_count].revents = 0;
fd_count++;
keychord_fd_init = 1;
}
if (process_needs_restart) {
timeout = (process_needs_restart - gettime()) * 1000;
if (timeout < 0)
timeout = 0;
}
if (!action_queue_empty() || cur_action)
timeout = 0;
// bootchart是一个性能统计工具，用于搜集硬件和系统的信息，并将其写入磁盘，以便其他程序使用
#if BOOTCHART
if (bootchart_count > 0) {
if (timeout < 0 || timeout > BOOTCHART_POLLING_MS)
timeout = BOOTCHART_POLLING_MS;
if (bootchart_step() < 0 || --bootchart_count == 0) {
bootchart_finish();
bootchart_count = 0;
}
}
#endif
// 等待下一个命令的提交
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();
}
}
}init.rc文件在core/rootdir/init.rc，我挑部分内容展示如下：
......
on early-init
# Set init and its forked children‘s oom_adj.
write /proc/1/oom_adj -16
# Set the security context for the init process.
# This should occur before anything else (e.g. ueventd) is started.
setcon u:r:init:s0
start ueventd
......
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
class main
socket zygote stream 660 root system
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd
......
重要的数据结构有两个列表，一个队列。
static list_declare(service_list);
static list_declare(action_list);
static list_declare(action_queue);
*.rc 脚本中所有 service关键字定义的服务将会添加到 service_list 列表中。
*.rc 脚本中所有 on 关键开头的动作将会被会添加到 action_list 列表中。
main函数中解析init.rc文件的代码是：
init_parse_config_file("/init.rc");
该函数在system/core/init/init_parser.c中，如下：
int parse_config_file(const char *fn)
{
char *data;
data = read_file(fn, 0);
if (!data) return -1;
parse_config(fn, data);
DUMP();
return 0;
}
其中的核心方法是parse_config(fn, data);，如下：
static void parse_config(const char *fn, char *s)
｛
...
case T_NEWLINE:
if (nargs) {
int kw = lookup_keyword(args[0]);
if (kw_is(kw, SECTION)) {
state.parse_line(&state, 0, 0);
parse_new_section(&state, kw, nargs, args);
} else {
state.parse_line(&state, nargs, args);
}
nargs = 0;
}
...
｝
parse_config会逐行对脚本进行解析，如果关键字类型为 SECTION ，就是上一模块中说的Section（语句块），那么将会执行 parse_new_section() 。
parse_new_section()中再分别对 service 或者 on 关键字开头的内容进行解析，如下：
...
case K_service:
state->context = parse_service(state, nargs, args);
if (state->context) {
state->parse_line = parse_line_service;
return;
}
break;
case K_on:
state->context = parse_action(state, nargs, args);
if (state->context) {
state->parse_line = parse_line_action;
return;
}
break;
}
... 对 on 关键字开头的内容进行解析
static void *parse_action(struct parse_state *state, int nargs, char **args)
{
...
act = calloc(1, sizeof(*act));
act->name = args[1];
list_init(&act->commands);
list_add_tail(&action_list, &act->alist);
...
} 对 service 关键字开头的内容进行解析
static void *parse_service(struct parse_state *state, int nargs, char **args)
{
struct service *svc;
if (nargs name = args[1];
svc->classname = "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);
//添加该服务到 service_list 列表
list_add_tail(&service_list, &svc->slist);
return svc;
} 解析后的服务表现形式是一个service结构体。例如：
android启动之init启动,布布扣,bubuko.com
标签：android
原文地址：http://blog.csdn.net/w2865673691/article/details/25027659
