转：http://blog.csdn.net/caimouse/
android系统的初始化过程是从那里开始呢？它在加载linux基本内核后，就开始运行一个初始化进程，叫做init进程，那么怎么样知道它是加载init进程的呢？难道上天就注定的吗？呵呵，不是的，原来是从android加载linux内核时，就设置了下面的参数：
Kernelcommand line: noinitrd root=/dev/nfs console=ttySAC0 init=/initnfsroot=192.168.1.103:/nfsbootip=192.168.1.20:192.168.1.103:192.168.1.1:255.255.255.0::eth0:on
在这行命令里，就是告诉linux内核初始化完成后开始运行init进程，由于init进程就是放在系统根目录下面。而这个进程的代码，就是位于源码的目录system/core/init下面，现在就来仔细地分析这个进程到底做了什么事情，以便理解整个系统运行情况。在分析过程中，会学习很多有用知识，甚至linux编程知识。这么有用，还等什么呢？现在就开始，找到目录system/core/init/init.c代码，先从main函数开始，如下：
#001 intmain(int argc, char **argv)
#002 {
#003 intdevice_fd = -1;
#004 intproperty_set_fd = -1;
#005 intsignal_recv_fd = -1;
#006 intkeychord_fd = -1;
#007 intfd_count;
#008 ints[2];
#009 intfd;
#010 structsigaction act;
#011 chartmp[PROP_VALUE_MAX];
#012 structpollfd ufds[4];
#013 char*tmpdev;
#014 char*debuggable;
#015
#016
#017 act.sa_handler= sigchld_handler;
#018 act.sa_flags= SA_NOCLDSTOP;
#019 act.sa_mask= 0;
#020 act.sa_restorer= NULL;
#021 sigaction(SIGCHLD,&act, 0);
在上面这段代码里，调用函数sigaction来设置处理子进程发送回来的关闭信号，其中SIGCHLD是设置子进程信号处理，SA_NOCLDSTOP是表示子进程结束时不要向父进程发送SIGCHLD，sigchld_handler是信号SIGCHLD的处理函数。这样做的作用，就是如果父进程不等待子进程结束，子进程将成为僵尸进程（zombie）从而占用系统资源。因此需要对SIGCHLD信号做出处理，回收僵尸进程的资源，避免造成不必要的资源浪费。
#022
#023 /*clear the umask */
#024 umask(0);
在上面这段代码里，调用函数umask来设置屏蔽位为0值。这样的意思是什么呢？是告诉系统做了那些工作呢？要了解这个，就得深入查看一下linux函数大全了，因为它的作用就一目了然了，它的解释如下：
linux中的 umask 函数主要用于：在创建新文件或目录时 屏蔽掉新文件或目录不应有的访问允许权限。文件的访问允许权限共有9种，分别是：rw x r w x r w x（它们分别代表：用户读 用户写 用户执行 组读 组写 组执行 其它读 其它写 其它执行）。
其实这个函数的作用，就是设置允许当前进程创建文件或者目录最大可操作的权限，比如这里设置为0，它的意思就是0取反再创建文件时权限相与，也就是：(~0)& mode 等于八进制的值0777&mode了，这样就是给后面的代码调用函数mkdir给出最大的权限，避免了创建目录或文件的权限不确定性，指定明确的标志，可谓是开发人员对代码健壮性深刻的反映，高度明确性。
#025
#026 /*Get the basic filesystem setup we need put
#027 *together in the initramdisk on / and then we'll
#028 *let the rc file figure out the rest.
#029 */
#030 mkdir("/dev",0755);
#031 mkdir("/proc",0755);
#032 mkdir("/sys",0755);
在上面这段代码里，主要就是在当前内存模拟磁盘里建立一个基本的文件系统，以便后面加载rc文件来做其它事情。其中就是创建设备目录dev，进程文件系统目录proc，系统目录sys。
/dev是devfs（设备文件系统）或者udev的挂在点所在。在使用devfs的内核里如果没有/dev，根本见不到Shell启动的信息，因为内核找不到/dev/console；在使用udev的系统里，也事先需要在/dev下建立console和null这两个节点。关于devfs和udev的区别，网上很多文章说。当然如果你的内核已经不支持devfs了（2.6.12以后），可以使用纯纯的静态节点。也就是用mknod人工生成。
/proc是用来挂载存放系统信息虚拟文件系统——“proc文件系统”，“proc文件系统”在内核里面可以选。如果没有“proc文件系统”，很多Shell自己的命令就没有办法运行，比如ifconfig。“proc文件系统”不像devfs可以自动挂载，它需要使用初始化脚本挂载。另外，udev也需要“proc文件系统”的支持。
/sys用于挂载“sysfs文件系统”，“sysfs文件系统”在内核里面可以选。
#033
#034 mount("tmpfs","/dev", "tmpfs", 0, "mode=0755");
#035 mkdir("/dev/pts",0755);
#036 mkdir("/dev/socket",0755);
#037 mount("devpts","/dev/pts", "devpts", 0, NULL);
#038 mount("proc","/proc", "proc", 0, NULL);
#039 mount("sysfs","/sys", "sysfs", 0, NULL);
在 Linux 中将一个文件系统与一个存储设备关联起来的过程称为挂装（mount）。使用 mount 命令将一个文件系统附着到当前文件系统层次结构中（根）。在执行挂装时，要提供文件系统类型、文件系统和一个挂装点。因此，这里就是把tmpfs文件系统加到目录/dev下面，文件系统的名称是tmpfs。tmpfs是一个虚拟内存文件系统，它不同于传统的用块设备形式来实现的Ramdisk，也不同于针对物理内存的Ramfs。Tmpfs可以使用物理内存，也可以使用交换分区。在Linux内核中，虚拟内存资源由物理内存(RAM)和交换分区组成，这些资源是由内核中的虚拟内存子系统来负责分配和管理。Tmpfs向虚拟内存子系统请求页来存储文件，它同Linux的其它请求页的部分一样，不知道分配给自己的页是在内存中还是在交换分区中。同Ramfs一样，其大小也不是固定的，而是随着所需要的空间而动态的增减。接着创建pts和socket目录，在/dev/pts挂装devpts虚拟文件系统，在目录/proc挂装proc文件系统，在目录/sys挂装sysfs文件系统。
#040
#041 /*We must have some place other than / to create the
#042 *device nodes for kmsg and null, otherwise we won't
#043 *be able to remount / read-only later on.
#044 *Now that tmpfs is mounted on /dev, we can actually
#045 *talk to the outside world.
#046 */
#047 open_devnull_stdio();
这段代码是创建空的设备节点（/dev/null）。
#048 log_init();
这段代码是创建kmsg(/dev/kmsg)节点，主要用来输出LOG信息。比如把LOG信息输出到开发板的串口上，再在电脑上打印出来，方便跟踪和调试系统的功能。
#049
#050 //caijs addtest. 2010-07-13
#051 ERROR("Init::main()'%s'/n", "caijunsheng 2010-07-13");
这里是我测试系统引导输出的一行LOG代码。
#052
#053 INFO("readingconfig file/n");
#054 parse_config_file("/init.rc");
这段代码是分析根目录下面的init.rc配置文件，并且把里面的参数组成链表的方式，以便后面使用，后面再来仔细地分析init.rc文件的格式和内容。
#055
#056 /*pull the kernel commandline and ramdisk properties file in */
#057 qemu_init();
这里初始化qemu模拟器运行计数，这里是指模拟ARM指令的虚拟系统。
#058 import_kernel_cmdline(0);
这段代码是从linux内核里获取引导系统给内核的引导参数，并保存到全局变量，以便使用。
#059
#060 get_hardware_name();
这段代码是获取当前android系统运行的硬件信息，比如硬件的CPU名称。主要从/proc/cpuinfo里读到相关的信息。
#061 snprintf(tmp,sizeof(tmp), "/init.%s.rc", hardware);
#062 parse_config_file(tmp);
这段代码是从前面获取到的硬件名称，然后以硬件的名称（/init.硬件名称.rc）来获取相应硬件的配置文件，并且把配置文件参数加载到链表里。
#063
#064 action_for_each_trigger("early-init",action_add_queue_tail);
#065 drain_action_queue();
这段代码是先把有early-init标识的命令提前添加到一个命令队列，以便函数drain_action_queue一个一个命令地执行配置文件里的函数，这样可以在不同的配置文件里，只要标明是最先执行的函数，就可以优先地运行。
#066
#067 INFO("deviceinit/n");
#068 device_fd= device_init();
这段代码是遍历为/sys，添加设备事件响应，创建设备节点。
#069
#070 property_init();
这段代码是进行属性初始化。每个属性都有一个名称和值，它们都是字符串格式。属性被大量使用在Android系统中，用来记录系统设置或进程之间的信息交换。属性是在整个系统中全局可见的。每个进程可以get/set属性。在系统初始化时，Android将分配一个共享内存区来存储的属性，这里主要是从/default.prop属性文件读取属性。这个有点像Windows下的注册表的作用。
#071
#072 //only listen for keychords if ro.debuggable is true
#073 debuggable= property_get("ro.debuggable");
#074 if(debuggable && !strcmp(debuggable, "1")) {
#075 keychord_fd= open_keychord();
#076 }
这段代码是从属性里获取调试标志，如果是可以调试，就打开组合按键输入驱动程序。
#077
#078 if(console[0]) {
#079 snprintf(tmp,sizeof(tmp), "/dev/%s", console);
#080 console_name= strdup(tmp);
#081 }
#082
#083 fd= open(console_name, O_RDWR);
#084 if(fd >= 0)
#085 have_console= 1;
#086 close(fd);
这段代码是判断是否有控制台，如果没有，就尝试是否是可以打缺省的控制台。
#087
#088 if(load_565rle_image(INIT_IMAGE_FILE) ) {
#089 fd= open("/dev/tty0", O_WRONLY);
#090 if(fd >= 0) {
#091 constchar *msg;
#092 msg= "/n"
#093 "/n"
#094 "/n"
#095 "/n"
#096 "/n"
#097 "/n"
#098 "/n" //console is 40 cols x 30 lines
#099 "/n"
#100 "/n"
#101 "/n"
#102 "/n"
#103 "/n"
#104 "/n"
#105 "/n"
#106 " AN D R O I D ";
#107 write(fd,msg, strlen(msg));
#108 close(fd);
#109 }
#110 }
这段代码是先调用load_565rle_image函数来尝试加载定制的显示的LOGO图片，如果不成功，就直接在屏幕上显示字符串android。通过这里可以定制不同厂家的LOGO图片显示，以便在系统初始化时，进行更人性化的等待，更加漂亮个性。
#111
#112 if(qemu[0])
#113 import_kernel_cmdline(1);
这段代码是用来判断是否使用模拟器运行，如果时，就加载内核命令行参数。
#114
#115 if(!strcmp(bootmode,"factory"))
#116 property_set("ro.factorytest","1");
#117 elseif (!strcmp(bootmode,"factory2"))
#118 property_set("ro.factorytest","2");
#119 else
#120 property_set("ro.factorytest","0");
这段代码是根据内核命令行参数来设置工厂模式测试，比如在工厂生产手机过程里需要自动化演示功能，就可以根据这个标志来进行特别处理。
#121
#122 property_set("ro.serialno",serialno[0] ? serialno : "");
这段代码是设置手机序列号到属性里保存，以便上层应用程序可以识别这台手机。
#123 property_set("ro.bootmode",bootmode[0] ? bootmode : "unknown");
这段代码是保存启动模式到属性里。
#124 property_set("ro.baseband",baseband[0] ? baseband : "unknown");
这段代码是保存手机基带频率到属性里。
#125 property_set("ro.carrier",carrier[0] ? carrier : "unknown");
这段代码是保存手机硬件载波的方式到属性里。
#126 property_set("ro.bootloader",bootloader[0] ? bootloader : "unknown");
这里是保存引导程序的版本号到属性里，以便系统知道引导程序有什么特性。
#127
#128 property_set("ro.hardware",hardware);
这里是保存硬件信息到属性里，其实就是获取CPU的信息。
#129 snprintf(tmp,PROP_VALUE_MAX, "%d", revision);
#130 property_set("ro.revision",tmp);
这里是保存硬件修订的版本号到属性里，这样可以方便应用程序区分不同的硬件版本。
#131
#132 /*execute all the boot actions to get us started */
#133 action_for_each_trigger("init",action_add_queue_tail);
#134 drain_action_queue();
这段代码是先把所有init命令添加队列，然后再执行。
#135
#136 /*read any property files on system or data and
#137 *fire up the property service. This must happen
#138 *after the ro.foo properties are set above so
#139 *that /data/local.prop cannot interfere with them.
#140 */
#141 property_set_fd= start_property_service();
这段代码是加载system和data目录下的属性，并启动属性监听服务。
#142
#143 /*create a signalling mechanism for the sigchld handler */
#144 if(socketpair(AF_UNIX, SOCK_STREAM, 0, s) == 0) {
#145 signal_fd= s[0];
#146 signal_recv_fd= s[1];
#147 fcntl(s[0],F_SETFD, FD_CLOEXEC);
#148 fcntl(s[0],F_SETFL, O_NONBLOCK);
#149 fcntl(s[1],F_SETFD, FD_CLOEXEC);
#150 fcntl(s[1],F_SETFL, O_NONBLOCK);
#151 }
这段代码是创建一个全双工的通讯机制的两个SOCKET，信号可以在signal_fd和signal_recv_fd双向通讯，从而建立起沟通的管道。其实这个信号管理，就是用来让init进程与它的子进程进行沟通的，子进程从signal_fd写入信息，init进程从signal_recv_fd收到信息，然后再做处理。
#152
#153 /*make sure we actually have all the pieces we need */
#154 if((device_fd < 0) ||
#155 (property_set_fd< 0) ||
#156 (signal_recv_fd< 0)) {
#157 ERROR("initstartup failure/n");
#158 return1;
#159 }
这段代码是判断关键的几个组件是否成功初始化，主要就是设备文件系统是否成功初始化，属性服务是否成功初始化，信号通讯机制是否成功初始化。
#160
#161 /*execute all the boot actions to get us started */
#162 action_for_each_trigger("early-boot",action_add_queue_tail);
#163 action_for_each_trigger("boot",action_add_queue_tail);
#164 drain_action_queue();
这段代码是执行early-boot和boot属性的命令。
#165
#166 /*run all property triggers based on current state of the properties */
#167 queue_all_property_triggers();
#168 drain_action_queue();
这段代码是根据当前属性，运行属性命令。
#169
#170 /*enable property triggers */
#171 property_triggers_enabled= 1;
这段代码是标明属性触发器已经初始化完成。
#172
#173 ufds[0].fd= device_fd;
#174 ufds[0].events= POLLIN;
#175 ufds[1].fd= property_set_fd;
#176 ufds[1].events= POLLIN;
#177 ufds[2].fd= signal_recv_fd;
#178 ufds[2].events= POLLIN;
#179 fd_count= 3;
这段代码是保存三个重要的服务socket，以便后面轮询使用。
#180
#181 if(keychord_fd > 0) {
#182 ufds[3].fd= keychord_fd;
#183 ufds[3].events= POLLIN;
#184 fd_count++;
#185 }else {
#186 ufds[3].events= 0;
#187 ufds[3].revents= 0;
#188 }
这段代码是判断是否处理组合键轮询。
#189
#190 #ifBOOTCHART
#191 bootchart_count= bootchart_init();
#192 if(bootchart_count < 0) {
#193 ERROR("bootchartinginit failure/n");
#194 }else if (bootchart_count > 0) {
#195 NOTICE("bootchartingstarted (period=%d ms)/n",bootchart_count*BOOTCHART_POLLING_MS);
#196 }else {
#197 NOTICE("bootchartingignored/n");
#198 }
#199 #endif
这段代码是初始化linux程序启动速度的性能分析工具，这个工具有一个好处，就是图形化显示每个进程启动顺序和占用时间，如果想优化系统的启动速度，记得启用这个工具。
#200
#201 for(;;){
#202 intnr, i, timeout = -1;
这段代码是进入死循环处理，以便这个init进程变成一个服务。
#203
#204 for(i = 0; i < fd_count; i++)
#205 ufds[i].revents= 0;
这段代码是清空每个socket的事件计数。
#206
#207 drain_action_queue();
这段代码是执行队列里的命令。
#208 restart_processes();
这句代码是用来判断那些服务需要重新启动。
#209
#210 if(process_needs_restart) {
#211 timeout= (process_needs_restart - gettime()) * 1000;
#212 if(timeout < 0)
#213 timeout= 0;
#214 }
这段代码是用来判断那些进程启动超时。
#215
#216 #ifBOOTCHART
#217 if(bootchart_count > 0) {
#218 if(timeout < 0 || timeout > BOOTCHART_POLLING_MS)
#219 timeout= BOOTCHART_POLLING_MS;
#220 if(bootchart_step() < 0 || --bootchart_count == 0) {
#221 bootchart_finish();
#222 bootchart_count= 0;
#223 }
#224 }
#225 #endif
这段代码是用来计算运行性能。
#226 nr= poll(ufds, fd_count, timeout);
#227 if(nr <= 0)
#228 continue;
这段代码用来轮询几个socket是否有事件处理。
#229
#230 if(ufds[2].revents == POLLIN) {
#231 /*we got a SIGCHLD - reap and restart as needed */
#232 read(signal_recv_fd,tmp, sizeof(tmp));
#233 while(!wait_for_one_process(0))
#234 ;
#235 continue;
#236 }
这段代码是用来处理子进程的通讯，并且能删除任何已经退出或者杀死死进程，这样做可以保持系统更加健壮性，增强容错能力。
#237
#238 if(ufds[0].revents == POLLIN)
#239 handle_device_fd(device_fd);
这段代码是处理设备事件。
#240
#241 if(ufds[1].revents == POLLIN)
#242 handle_property_set_fd(property_set_fd);
这段代码是处理属性服务事件。
#243 if(ufds[3].revents == POLLIN)
#244 handle_keychord(keychord_fd);
这段代码是处理调试模式下的组合按键。
#245 }
#246
#247 return0;
#248 }
#249
到这里已经分析完成init进程的主流程，后面再来详细地其它功能实现。
在主函数main里调用这个函数来做什么呢？而这个函数是怎么样实现的呢？下面就来了解这个函数的功能与产现，具代码如下：
#001 voidopen_devnull_stdio(void)
#002 {
#003 intfd;
#004 staticconst char *name = "/dev/__null__";
这段代码是指明创建设备节点的名称，这是空设备。
#005 if(mknod(name, S_IFCHR | 0600, (1 << 8) | 3) == 0) {
这行是调用函数mknod来创建设备节点/dev/__null__。空节点当作输出的黑洞，只进不出，写入它的字符永远不会满。
#006 fd= open(name, O_RDWR);
这行代码是打开空设备，进行读写。
#007 unlink(name);
这行代码是从文件系统中删除一个名称。如果名称是文件的最后一个连接，并且没有其它进程将文件打开，名称对应的文件会实际被删除。
#008 if(fd >= 0) {
#009 dup2(fd,0);
#010 dup2(fd,1);
#011 dup2(fd,2);
#012 if(fd > 2) {
#013 close(fd);
#014 }
#015 return;
#016 }
这段代码是用来检查是否打开空设备成功，是否重定向设备成功，如果成功就返回。
#017 }
#018
#019 exit(1);
这行代码是当创建空设备节点出错时退出。
#020 }
#021
通过上面的代码，就可以创建/dev/__null__空设备，并测试是否创建成功。
parse_config_file函数是分析*.rc配置文件，并且把里面的参数组成链表的方式。下面来仔细地分析代码，如下：
#001 intparse_config_file(const char *fn)
#002 {
输入来的参数是文件名称的路径。
#003 char*data;
#004 data= read_file(fn, 0);
#005 if(!data) return -1;
这段代码是从文件里读取数据，并保存数据缓冲区的指针在data里。
#006
#007 parse_config(fn,data);
这行代码是分析data数据里，然后把里面的参数组成链表的方式。
#008 DUMP();
这行代码是用来调试时输出配置文件里的内容。
#009 return0;
#010 }
接着下来分析函数read_file的代码，如下：
#001 /*reads a file, making sure it is terminated with /n /0 */
#002 void*read_file(const char *fn, unsigned *_sz)
#003 {
#004 char*data;
#005 intsz;
#006 intfd;
#007
#008 data= 0;
#009 fd= open(fn, O_RDONLY);
#010 if(fd< 0) return 0;
这段代码是打开文件路径为fn的文件，使用只读的方式打开。
#011
#012 sz= lseek(fd, 0, SEEK_END);
#013 if(sz< 0) goto oops;
这段代码是移动文件指针到文件末尾，然后计算出文件的长度。
#014
#015 if(lseek(fd,0, SEEK_SET) != 0) goto oops;
这段代码是移动到文件头开始位置。
#016
#017 data= (char*) malloc(sz + 2);
#018 if(data== 0) goto oops;
这段代码是分配文件所需内存大小。
#019
#020 if(read(fd,data, sz) != sz) goto oops;
#021 close(fd);
#022 data[sz]= '/n';
#023 data[sz+1]= 0;
这段代码是读取文件数据到缓冲区，并设置缓冲区最后的结束字符为换行符和0字符。
#024 if(_sz)*_sz = sz;
#025 returndata;
这段代码是返回文件的长度和文件缓冲区的指针。
#026
#027 oops:
#028 close(fd);
#029 if(data!= 0) free(data);
#030 return0;
#031 }
这段代码是读取文件出错，删除缓冲区。
再接着来分析函数parse_config，主要实现从缓冲区里分析配置数据，生成链表。它的代码如下：
#001 staticvoid parse_config(const char *fn, char *s)
#002 {
#003 structparse_state state;
#004 char*args[SVC_MAXARGS];
#005 intnargs;
#006
#007 nargs= 0;
#008 state.filename= fn;
#009 state.line= 1;
#010 state.ptr= s;
#011 state.nexttoken= 0;
#012 state.parse_line= parse_line_no_op;
这段代码是设置分析开始状态，其实state.filename指向文件名称；state.line是第一行；state.ptr是指向数据缓冲区；state.nexttoken是下一个词位置；state.parse_line是指向空操作行函数。
下面开始循环适别所有配置文件。
#013 for(;;) {
下面根据三种状态进行处理。
#014 switch(next_token(&state)) {
#015 caseT_EOF:
已经到了文件结尾字符处理。
#016 state.parse_line(&state,0, 0);
#017 return;
新一行配置文件处理。
#018 caseT_NEWLINE:
#019 if(nargs) {
查找这一行里配置的关键字。
#020 intkw = lookup_keyword(args[0]);
#021 if(kw_is(kw, SECTION)) {
是关键字处理，分近这一行字符。
#022 state.parse_line(&state,0, 0);
调用函数parse_new_section来分析这一节配置文件的意思，比如服务或者动作，或者参数等等。
#023 parse_new_section(&state,kw, nargs, args);
#024 }else {
保存一行的参数。
#025 state.parse_line(&state,nargs, args);
#026 }
#027 nargs= 0;
#028 }
#029 break;
保存命令配置的参数。
#030 caseT_TEXT:
#031 if(nargs < SVC_MAXARGS) {
#032 args[nargs++]= state.text;
#033 }
#034 break;
#035 }
#036 }
#037 }
在上面函数主要识别的关键字有：
copycapability chdir chroot class class_start class_stop console chownchmod critical disabled domainname device exec export group hostname
ifupinsmod import keycodes loglevel mkdir mount on oneshot onrestartrestart service setenv setkey setprop setrlimit socket start stop
symlinksysclktz trigger user write。
也就是配置文件只能使用上面的关键字，其它都是作为标识符的。这些关键的作用，其实是通过预先定义的操作来决定的，如下代码所示：
#001 #defineKEYWORD(symbol, flags, nargs, func) K_##symbol,
#002 enum{
#003 K_UNKNOWN,
#004 #endif
#005 KEYWORD(capability, OPTION, 0,0)
这个关键字是用来执行linux服务之前检查linux内核的兼容性，它是一个选项。
#006 KEYWORD(chdir, COMMAND,1, do_chdir)
这个关键字是用来改变当前工作的目录，它是一个命令。
#007 KEYWORD(chroot, COMMAND,1, do_chroot)
这个关键字是用来更改某个进程所能看到的根目录，即将某进程限制在指定目录中，保证该进程只能对该目录及其子目录的文件有所动作，从而保证整个服务器的安全，它是一个命令。
#008 KEYWORD(class, OPTION, 0,0)
这个关键字是为一个服务指明一个类名称，它是一个选项。
#009 KEYWORD(class_start,COMMAND, 1, do_class_start)
这个关键字是启动所有指定服务类下的未运行服务，它是一个命令。
#010 KEYWORD(class_stop, COMMAND,1, do_class_stop)
这个关键字是停止指定服务类下的所有已运行的服务，它是一个命令。
#011 KEYWORD(console, OPTION, 0,0)
这个关键字是控制台选项，它是一个选项。
#012 KEYWORD(critical, OPTION, 0,0)
这个关键字是说明这是一个对于设备关键的服务。如果他四分钟内退出大于四次，系统将会重启并进入recovery（恢复）模式。
#013 KEYWORD(disabled, OPTION, 0,0)
这个关键字是说明这个服务不会同与他同trigger（触发器）下的服务自动启动。他必须被明确的按名启动。。
#014 KEYWORD(domainname, COMMAND,1, do_domainname)
这个关键字是设置域名，它是一个命令。
#015 KEYWORD(exec, COMMAND,1, do_exec)
这个关键字是创建或执行一个程序，它是一个命令。
#016 KEYWORD(export, COMMAND,2, do_export)
这个关键字是用来设置全局环境变量的值，它是一个命令。
#017 KEYWORD(group, OPTION, 0,0)
这个关键字是用来改服务的组名，它是一个选项。
#018 KEYWORD(hostname, COMMAND,1, do_hostname)
这个关键字是用来主机名称，它是一个命令。
#019 KEYWORD(ifup, COMMAND,1, do_ifup)
这个关键字是用来启动网络接口，它是一个命令。
#020 KEYWORD(insmod, COMMAND,1, do_insmod)
这个关键字是用来加载指定路径的模块，它是一个命令。
#021 KEYWORD(import, COMMAND,1, do_import)
这个关键字是用来加载一个init能识别的rc文件，它是一个命令。
#022 KEYWORD(keycodes, OPTION, 0,0)
这个关键字是用来定义按键码的选项。
#023 KEYWORD(mkdir, COMMAND,1, do_mkdir)
这个关键字是用来建立一个目录，它是一个命令。
#024 KEYWORD(mount, COMMAND,3, do_mount)
这个关键字是用来指定目录加载设备，它是一个命令。
#025 KEYWORD(on, SECTION,0, 0)
这个关键字是用来设置一段命令按什么事件进行触发运行，它是一个段描述符。
#026 KEYWORD(oneshot, OPTION, 0,0)
这个关键字是用来设置服务器只运行一次就关闭，它是一个选项。
#027 KEYWORD(onrestart, OPTION, 0,0)
这个关键字是用来设置当服务重启动，执行一个命令，它是一个选项。
#028 KEYWORD(restart, COMMAND,1, do_restart)
这个关键字是用来重新启动服务，它是一个命令。
#029 KEYWORD(service, SECTION,0, 0)
这个关键字是用来设置一段服务的命令，往往一段服务里需要有多个选项组成。
#030 KEYWORD(setenv, OPTION, 2,0)
这个关键字是用来设置环境变量，它是一个选项。
#031 KEYWORD(setkey, COMMAND,0, do_setkey)
这个关键字是用来设置按键的索引和键值，它是一个命令。
#032 KEYWORD(setprop, COMMAND,2, do_setprop)
这个关键字是用来设置系统属性名称为某个值，它是一个命令。
#033 KEYWORD(setrlimit, COMMAND,3, do_setrlimit)
这个关键字是用来设置系统资源限制，它是一个命令。
#034 KEYWORD(socket, OPTION, 0,0)
这个关键字是用来设置socket给一个应用程序，它是一个选项。
#035 KEYWORD(start, COMMAND,1, do_start)
这个关键字是用来启动一个服务，它是一个命令。
#036 KEYWORD(stop, COMMAND,1, do_stop)
这个关键字是用来停止一个服务，它是一个命令。
#037 KEYWORD(trigger, COMMAND,1, do_trigger)
这个关键字是用来标志一个触发命令，它是一个命令。
#038 KEYWORD(symlink, COMMAND,1, do_symlink)
这个关键字是用来设置一个路径的符号连接，它是一个命令。
#039 KEYWORD(sysclktz, COMMAND,1, do_sysclktz)
这个关键字是用来设置系统时钟基准，它是一个命令。
#040 KEYWORD(user, OPTION, 0,0)
这个关键字是用来设置服务、文件或目录所属的用户，它是一个选项。
#041 KEYWORD(write, COMMAND,2, do_write)
这个关键字是用来打开一个文件写多个字符串，它是一个命令。
#042 KEYWORD(copy, COMMAND,2, do_copy)
这个关键字是用来拷贝文件，它是一个命令。
#043 KEYWORD(chown, COMMAND,2, do_chown)
这个关键字是用来改变文件或目录的属某个用户的属性，它是一个命令。
#044 KEYWORD(chmod, COMMAND,2, do_chmod)
这个关键字是用来改变文件或目录的访问权限，它是一个命令。
#045 KEYWORD(loglevel, COMMAND,1, do_loglevel)
这个关键字是用来设置log输出的级别，它是一个命令。
#046 KEYWORD(device, COMMAND,4, do_device)
这个关键字是用来设置设备的名称，它是一个命令。
#047 #ifdef__MAKE_KEYWORD_ENUM__
#048 KEYWORD_COUNT,
#049 };
Android初始化语言包含了四种类型的声明：Actions（行动）、Commands（命令）、Services（服务）和Options（选 项）。
通上面的函数就可以把服务和事件触发的命令添加队列里。其实是在文件parser.c头部，就声明了下面三个链表，如下：
staticlist_declare(service_list);
staticlist_declare(action_list);
staticlist_declare(action_queue);
service_list是定义添加分析所有资源文件里的服务，action_list是定义添加分析所有资源文件里的事件触发的命令列表，action_queue是定义添加当前需要执行操作的命令动作或者服务等。
那么又有下面一个问题了，init进程是在那里添加这些服务或命令到运行队列呢？在init.c文件看到下面的代码：
action_for_each_trigger("early-init",action_add_queue_tail);
drain_action_queue();
原来是通过函数action_for_each_trigger来把所有需要按事件触发运行的命令添加到队列里，函数action_add_queue_tail把需要执行命令放到队列，函数drain_action_queue把添加到队列里的命令进行运行。
#001 voidaction_for_each_trigger(const char *trigger,
#002 void(*func)(struct action *act))
#003 {
#004 structlistnode *node;
#005 structaction *act;
#006 list_for_each(node,&action_list) {
这行代码是遍历链表所有项。
#007 act= node_to_item(node, struct action, alist);
这行代码是把动作节点转换为动作项。
#008 if(!strcmp(act->name, trigger)) {
#009 func(act);
这段代码是当找到与用户输入相同事件触发的动作，比如上面是查找“early-init”事件。这时就把动作项添加到将要运行的队列里。
#010 }
#011 }
#012 }
在init初始化进程里，设备初始化是怎么进行的呢？如果要了解这方面，就需要仔细分析下面的代码，如下：
#001 intdevice_init(void)
#002 {
#003 suseconds_tt0, t1;
#004 intfd;
#005
#006 fd= open_uevent_socket();
#007 if(fd< 0)
#008 return-1;
这段代码是调用函数open_uevent_socket来创建一个用户事件空间的socket。
#009
#010 fcntl(fd,F_SETFD, FD_CLOEXEC);
#011 fcntl(fd,F_SETFL, O_NONBLOCK);
这段代码是设置socket的属性，FD_CLOEXEC用来设置文件的close-on-exec状态标准。在exec()调用后，close-on-exec标志为0的情况，此文件不被关闭。非零则在exec()后被关闭。默认close-on-exec状态为0，需要通过FD_CLOEXEC设置。O_NONBLOCK设置这个socket是异步的通讯方式。
#012
#013 t0= get_usecs();
这行代码是用来获取当前用户的时间。
#014 coldboot(fd,"/sys/class");
#015 coldboot(fd,"/sys/block");
#016 coldboot(fd,"/sys/devices");
这段代码是用来遍历所有在init进程前已经创建的设备，并找到设备的事件文件发送事件通知。
#017 t1= get_usecs();
这行代码是用来获取当前用户的时间。
#018
#019 log_event_print("coldboot%ld uS/n", ((long) (t1 - t0)));
这行代码是用来打印输出冷启动的时间是多少秒。
#020
#021 returnfd;
#022 }
#023
在android系统里，设计有一种系统叫做属性系统，它是用来做什么呢？这样设计有什么优势呢？其实这个属性系统主要是用来保存系统配置，或者用来交换不同进程的信息。这样的系统最大的优势是统一了系统配置的方式，统一了信息交换方式，通过共享内存的方式提高系统的性能。
下面就来分析属性系统的初始化函数，代码如下：
#001 voidproperty_init(void)
#002 {
#003 init_property_area();
这行代码是调用函数init_property_area来设置属性内存的区域。
#004 load_properties_from_file(PROP_PATH_RAMDISK_DEFAULT);
这行代码是从ramdisk盘里加载属性文件。
#005 }
在这个函数里，需要查看一下宏定义，如下：
#definePROP_PATH_RAMDISK_DEFAULT "/default.prop"
也就是从内存盘里加载属性文件/default.prop，并把这些属性放到属性系统里。
接着来分析函数init_property_area是怎么创建共享内存，并把属性放到里面给所有进程共享使用的，代码如下：
#001 staticint init_property_area(void)
#002 {
#003 prop_area*pa;
#004
#005 if(pa_info_array)
#006 return-1;
这段代码是判断当属性信息数组已经初始化，就直接返回。
#007
#008 if(init_workspace(&pa_workspace,PA_SIZE))
#009 return-1;
这段代码是调用函数init_workspace创建共享内存。
#010
#011 fcntl(pa_workspace.fd,F_SETFD, FD_CLOEXEC);
这行代码是设置共享内存的执行结束后关闭。
#012
#013 pa_info_array= (void*) (((char*) pa_workspace.data) + PA_INFO_START);
这行代码是保存创建共享内存指针。
#014
#015 pa= pa_workspace.data;
#016 memset(pa,0, PA_SIZE);
这段代码是清空属性共享的内存。
#017 pa->magic= PROP_AREA_MAGIC;
#018 pa->version= PROP_AREA_VERSION;
这段代码是设置属性共享内存的版本号。
#019
#020 /*plug into the lib property services */
#021 __system_property_area__= pa;
这行代码是设置属性共享内存可以给库的属性共享服务使用。
#022
#023 return0;
#024 }
#025
从上面的函数里可以看到一个创建共享内存的函数，它是怎么样实现创建共享内存的呢？现在来分析它的代码
前面学习了属性系统的初始化和加载，还有保存到属性文件等功能，下面来学习属性服务的方面，它主要用来提供一种服务的方式给java虚拟机上层使用，或者java应用程序使用。start_property_service函数的代码如下：
#001 intstart_property_service(void)
#002 {
#003 intfd;
#004
#005 load_properties_from_file(PROP_PATH_SYSTEM_BUILD);
#006 load_properties_from_file(PROP_PATH_SYSTEM_DEFAULT);
#007 load_properties_from_file(PROP_PATH_LOCAL_OVERRIDE);
这段代码是用来加载下面几个缺省的属性文件：
/system/build.prop
/system/default.prop
/data/local.prop
#008 /*Read persistent properties after all default values have been loaded.*/
#009 load_persistent_properties();
这行代码是用来加载保存为属性文件的属性。
#010
#011 fd= create_socket(PROP_SERVICE_NAME, SOCK_STREAM, 0666, 0, 0);
#012 if(fd< 0) return -1;
#013 fcntl(fd,F_SETFD, FD_CLOEXEC);
#014 fcntl(fd,F_SETFL, O_NONBLOCK);
这段代码是用来创建服务的socket，并设置相应的属性。
#015
#016 listen(fd,8);
这行代码是让属性服务进入监听状态。
#017 returnfd;
#018 }
在初始化过程里，会显示一个LOGO图片,那么它是怎么实现显示这个图片的呢？它的代码如下：
#001 /*565RLE image format: [count(2 bytes), rle(2 bytes)] */
#002
#003 intload_565rle_image(char *fn)
#004 {
这段代码是加载565RLE格式的LOGO图片，函数的参数是图片路径。
#005 structFB fb;
#006 structstat s;
#007 unsignedshort *data, *bits, *ptr;
#008 unsignedcount, max;
#009 intfd;
#010
#011 if(vt_set_mode(1))
#012 return-1;
这段代码是设置显示输出为图片模式。
#013
#014 fd= open(fn, O_RDONLY);
#015 if(fd < 0) {
#016 ERROR("cannotopen '%s'/n", fn);
#017 gotofail_restore_text;
#018 }
这段代码是打开要显示的图片。
#019
#020 if(fstat(fd, &s) < 0) {
#021 gotofail_close_file;
#022 }
这段代码是获取打开文件的信息，比如文件的大小。
#023
#024 data= mmap(0, s.st_size, PROT_READ, MAP_SHARED, fd, 0);
#025 if(data == MAP_FAILED)
#026 gotofail_close_file;
这段代码是映射图片文件到内存。
#027
#028 if(fb_open(&fb))
#029 gotofail_unmap_data;
这段代码是打开显示缓存内存，以便把图片数据放到显示缓存里。
#030
#031 max= fb_width(&fb) * fb_height(&fb);
#032 ptr= data;
#033 count= s.st_size;
#034 bits= fb.bits;
#035 while(count > 3) {
#036 unsignedn = ptr[0];
#037 if(n > max)
#038 break;
#039 android_memset16(bits,ptr[1], n << 1);
#040 bits+= n;
#041 max-= n;
#042 ptr+= 2;
#043 count-= 4;
#044 }
这段代码是把图片数据填入显示缓存。
#045
#046 munmap(data,s.st_size);
#047 fb_update(&fb);
这段代码是更新显示缓存，并把LOGO显示出来。
#048 fb_close(&fb);
#049 close(fd);
#050 unlink(fn);
这段代码关闭上面打开的资源，并删除LOGO图片文件，由于android把LOGO图片加载到内存里，并且LOGO显示完成后，再没有作用了，及时回收资源。如果想不删除这个图片，就需要把这行代码删除掉，或者每次显示前动态地拷贝到这里。
#051 return0;
#052
#053 fail_unmap_data:
#054 munmap(data,s.st_size);
#055 fail_close_file:
#056 close(fd);
#057 fail_restore_text:
#058 vt_set_mode(0);
#059 return-1;
这段代码是处理失败情况。
#060 }
通过上面的分析，可以知道LOGO图片是RLE编码的565格式的图片，也就是采用行程编码的方式，颜色位数采用16位的方式（红色5位，绿色6位，蓝色5位）。因此，所有其它图片的格式都需要转换为这种标准的格式，初始化进程才可以显示出来。下面就来详细地介绍定制一个LOGO图片的显示过程。
这个图片的像素大小为480X272，显示屏的大小为4.3寸。直接在Windows平台里使用画笔就可以制作出来，然后保存为png文件，比如保存为xiyang.png。然后在linux里打开windows共享的文件夹，再把这个文件拷贝到linux的目录里，进行如下操作：
1. 下载imgageMagick工具，通过命令进行：sudoapt-get install imagemagick，这样就安装好图片文件转换工具，它是用来把png文件转换为rgb原始格式的文件。
2. 把png格式的logo图片转换为raw原始格式图片：
convert-depth 8 xiyang.png rgb: xiyang.raw
3. 把raw原始格式图片转换为rle格式图片：
Android-2.0/out/host/linux-x86/bin/rgb2565–rle < xiyang.raw > initlogo.rle
当转换成功时，就会输出多少个像素的提示。
把文件initlogo.rle拷贝到nfsboot的目录。