mountaindancer
mountaindancer

Android init 进程源码分析

基于Linux内核的android系统，在内核启动完成后将创建一个Init用户进程，实现了内核空间到用户空间的转变。在Android 启动过程介绍一文中介绍了Android系统的各个启动阶段，init进程启动后会读取init.rc配置文件，通过fork系统调用启动init.rc文件中配置的各个Service进程。init进程首先启动启动android的服务大管家ServiceManager服务，然后启动Zygote进程。Zygote进程的启动开创了Java世界，无论是SystemServer进程还是android的应用进程都是Zygote的子进程，Zygote进程启动过程的源代码分析一文中详细介绍了Zygote进程的启动过程，System Server进程启动过程源码分析则详细介绍了在Zygote进程启动完成后创建的第一个进程SystemServer进程的启动过程，SystemServer进程的启动包括两个阶段，在第一阶段主要是启动C++相关的本地服务，如SurfaceFlinger等，在第二阶段通过在ServerThread线程中启动android的各大关键Java服务。Zygote孵化应用进程过程的源码分析一文中详细介绍了Zygote进程创建android应用进程的过程，当用户点击Luncher上的应用图标时，Luncher进程通过socket向Zygote进程发送进程创建请求，Zygote进程接受客户端的请求后，通过fork系统调用为应用程序创建相应的进程。本文则介绍android用户进程的始祖Init进程，Init进程是Linux系统中用户空间的第一个进程，负责创建系统中的关键进程，同时提供属性服务来管理系统属性。

Android进程模型

Linux通过调用start_kernel函数来启动内核，当内核启动模块启动完成后，将启动用户空间的第一个进程——Init进程，下图为Android系统的进程模型图：

从上图可以看出，Linux内核在启动过程中，创建一个名为Kthreadd的内核进程，PID=2，用于创建内核空间的其他进程；同时创建第一个用户空间Init进程，该进程PID = 1，用于启动一些本地进程，比如Zygote进程，而Zygote进程也是一个专门用于孵化Java进程的本地进程，上图清晰地描述了整个Android系统的进程模型，为了证明以上进程模型的正确性，可以通过ps命令来查看进程的PID级PPID，下图显示了Init进程的PID为1，其他的本地进程的PPID都是1，说明它们的父进程都是Init进程，都是由Init进程启动的。

下图显示kthreadd进程的PID=2，有一部分内核进程如binder、dhd_watchdog等进程的PPID=2，说明这些进程都是由kthreadd进程创建：

上图中显示zygote进程PID=107，下图显示了zygote进程创建的子进程，从图中可以看到，zygote进程创建的都是Java进程，证明了zygote进程开创了Android系统的Java世界。

上面介绍了Android系统的进程模型设计，接下来将详细分析Init进程。

Init进程源码分析

上节介绍了Init进程在Linux内核启动时被创建的，那它是如何启动的呢？

Init进程启动分析

在Linux内核启动过程中，将调用Start_kernel来初始化配置：

[cpp]  view plain  copy
  1. asmlinkage void __init start_kernel(void)  
  2. {  
  3.     .............. //执行初始化工作  
  4.     rest_init();   
  5. }  
start_kernel函数调用一些初始化函数完成初始化工作后，调用rest_init()函数来创建新的进程：

[cpp]  view plain  copy
  1. static noinline void __init_refok rest_init(void)  
  2.     __releases(kernel_lock)  
  3. {  
  4.     int pid;  
  5.   
  6.     rcu_scheduler_starting();  
  7.     //创建一个kernel_init进程，该进程实质上是Init进程，用于启动用户空间进程  
  8.     kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);   
  9.     numa_default_policy();  
  10.     //创建一个kthreadd内核线程，用于创建新的内核进程  
  11.     pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);  
  12.    
  13.     rcu_read_lock();  
  14.     kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);  
  15.     rcu_read_unlock();  
  16.     complete(&kthreadd_done);  
  17.     unlock_kernel();  
  18.   
  19.     /* 
  20.      * The boot idle thread must execute schedule() 
  21.      * at least once to get things moving: 
  22.      */  
  23.     init_idle_bootup_task(current);  
  24.     preempt_enable_no_resched();  
  25.     schedule();   
  26.     preempt_disable();  
  27.   
  28.     /* Call into cpu_idle with preempt disabled */  
  29.     cpu_idle();  
  30. }  
在rest_init函数里完成两个新进程的创建：Init进程和kthreadd进程，因为Init进程创建在先，所以其PID=1而kthreadd的PID=2，本文只对Init进程进行详细分析，如果读者对kthreadd进行感兴趣，可自行分析。

kernel_thread函数仅仅调用了fork系统调用来创建新的进程，创建的子进程和父进程都执行在fork函数调用之后的代码，子进程是父进程的一个拷贝。

[cpp]  view plain  copy
  1. static int __init kernel_init(void * unused)  
  2. {  
  3.     /* 
  4.      * Wait until kthreadd is all set-up. 
  5.      */  
  6.     wait_for_completion(&kthreadd_done);  
  7.     /* 
  8.      * init can allocate pages on any node 
  9.      */  
  10.     set_mems_allowed(node_states[N_HIGH_MEMORY]);  
  11.     /* 
  12.      * init can run on any cpu. 
  13.      */  
  14.     set_cpus_allowed_ptr(current, cpu_all_mask);  
  15.   
  16.     cad_pid = task_pid(current);  
  17.   
  18.     smp_prepare_cpus(setup_max_cpus);  
  19.     //执行保存在__initcall_start与__early_initcall_end之间的函数  
  20.     do_pre_smp_initcalls();  
  21.     lockup_detector_init();  
  22.     //smp 多核初始化处理  
  23.     smp_init();  
  24.     sched_init_smp();  
  25.     //内核驱动模块初始化  
  26.     do_basic_setup();  
  27.   
  28.     /* Open the /dev/console on the rootfs, this should never fail */  
  29.     if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)  
  30.         printk(KERN_WARNING "Warning: unable to open an initial console.\n");  
  31.   
  32.     (void) sys_dup(0);  
  33.     (void) sys_dup(0);  
  34.     /* 
  35.      * check if there is an early userspace init.  If yes, let it do all 
  36.      * the work 
  37.      */  
  38.     if (!ramdisk_execute_command)  
  39.         ramdisk_execute_command = "/init";  
  40.   
  41.     if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {  
  42.         ramdisk_execute_command = NULL;  
  43.         prepare_namespace();  
  44.     }  
  45.     /* 
  46.      * Ok, we have completed the initial bootup, and 
  47.      * we're essentially up and running. Get rid of the 
  48.      * initmem segments and start the user-mode stuff.. 
  49.      * 进入用户空间，执行用户空间代码 
  50.      */  
  51.   
  52.     init_post();  
  53.     return 0;  
  54. }  
在kernel_init函数中调用__initcall_start到__initcall_end之间保存的函数进行驱动模块初始化，然后直接调用init_post()函数进入用户空间，执行Init 进程代码。

[cpp]  view plain  copy
  1. static noinline int init_post(void)  
  2. {  
  3.     /* need to finish all async __init code before freeing the memory */  
  4.     async_synchronize_full();  
  5.     free_initmem();  
  6.     mark_rodata_ro();  
  7.     system_state = SYSTEM_RUNNING;  
  8.     numa_default_policy();  
  9.   
  10.     current->signal->flags |= SIGNAL_UNKILLABLE;  
  11.     //如果ramdisk_execute_command不为空，ramdisk_execute_command下的Init程序  
  12.     if (ramdisk_execute_command) {  
  13.         run_init_process(ramdisk_execute_command);  
  14.         printk(KERN_WARNING "Failed to execute %s\n",ramdisk_execute_command);  
  15.     }  
  16.     //如果execute_command不为空，execute_command下的Init程序  
  17.     if (execute_command) {  
  18.         run_init_process(execute_command);  
  19.         printk(KERN_WARNING "Failed to execute %s.  Attempting ""defaults...\n", execute_command);  
  20.     }  
  21.     //如果以上路径下都没有init程序，就从/sbin、/etc、/bin三个路径下寻找init程序，同时启动一个sh进程  
  22.     run_init_process("/sbin/init");  
  23.     run_init_process("/etc/init");  
  24.     run_init_process("/bin/init");  
  25.     run_init_process("/bin/sh");  
  26.     //如果以上路径都没有找到init程序，调用内核panic  
  27.     panic("No init found.  Try passing init= option to kernel. "  
  28.           "See Linux Documentation/init.txt for guidance.");  
  29. }  
当根文件系统顶层目录中不存在init进程，或未指定启动选项"init="时，内核会到/sbin、/etc、/bin目录下查找init文件。如果在这些目录中仍未找到init文件，内核就会中止执行init进程，并引发Kernel Panic。run_init_process函数通过系统调用do_execve从内核空间跳转到用户空间，并且执行用户空间的Init程序的入口函数。

[cpp]  view plain  copy
  1. static void run_init_process(const char *init_filename)  
  2. {  
  3.     argv_init[0] = init_filename;  
  4.     kernel_execve(init_filename, argv_init, envp_init);  
  5. }  
这里就介绍完了内核启动流程，run_init_process函数的将执行Init程序的入口函数，Init的入口函数位于/system/core/init/init.c

Init进程源码分析

Android的init进程主要功能：
1)、分析init.rc启动脚本文件，根据文件内容执行相应的功能；
2)、当一些关键进程死亡时，重启该进程；
3)、提供Android系统的属性服务；

[cpp]  view plain  copy
  1. int main(int argc, char **argv)  
  2. {  
  3.     int fd_count = 0;  
  4.     struct pollfd ufds[4];  
  5.     char *tmpdev;  
  6.     char* debuggable;  
  7.     char tmp[32];  
  8.     int property_set_fd_init = 0;  
  9.     int signal_fd_init = 0;  
  10.     int keychord_fd_init = 0;  
  11.     bool is_charger = false;  
  12.   
  13.     if (!strcmp(basename(argv[0]), "ueventd"))  
  14.         return ueventd_main(argc, argv);  
  15.   
  16.     /* clear the umask */  
  17.     umask(0);  
  18.     //挂载tmpfs，devpts，proc，sysfs 4类文件系统  
  19.     mkdir("/dev", 0755);  
  20.     mkdir("/proc", 0755);  
  21.     mkdir("/sys", 0755);  
  22.     mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");  
  23.     mkdir("/dev/pts", 0755);  
  24.     mkdir("/dev/socket", 0755);  
  25.     mount("devpts", "/dev/pts", "devpts", 0, NULL);  
  26.     mount("proc", "/proc", "proc", 0, NULL);  
  27.     mount("sysfs", "/sys", "sysfs", 0, NULL);  
  28.   
  29.     /* indicate that booting is in progress to background fw loaders, etc */  
  30.     close(open("/dev/.booting", O_WRONLY | O_CREAT, 0000));  
  31.     //屏蔽标准的输入输出，即标准的输入输出定向到NULL设备。  
  32.     open_devnull_stdio();  
  33.     // log 初始化  
  34.     klog_init();  
  35.     // 属性存储空间初始化  
  36.     property_init();  
  37.     //读取机器硬件名称  
  38.     get_hardware_name(hardware, &revision);  
  39.     //设置基本属性  
  40.     process_kernel_cmdline();  
  41.   
  42. #ifdef HAVE_SELINUX  
  43.     INFO("loading selinux policy\n");  
  44.     selinux_load_policy();  
  45. #endif  
  46.     //判断当前启动模式  
  47.     is_charger = !strcmp(bootmode, "charger");  
  48.       
  49.     INFO("property init\n");  
  50.     if (!is_charger)  
  51.         //读取默认的属性文件  
  52.         property_load_boot_defaults();  
  53.     //解析init.rc文件  
  54.     INFO("reading config file\n");  
  55.     init_parse_config_file("/init.rc");  
  56.     //将early-init动作添加到链表action_queue中   
  57.     action_for_each_trigger("early-init", action_add_queue_tail);  
  58.     //创建wait_for_coldboot_done 动作并添加到链表action_queue和action_list中  
  59.     queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");  
  60.     //创建keychord_init动作并添加到链表action_queue和action_list中  
  61.     queue_builtin_action(keychord_init_action, "keychord_init");  
  62.     //创建console_init动作并添加到链表action_queue和action_list中  
  63.     queue_builtin_action(console_init_action, "console_init");  
  64.     //将init动作添加到链表action_queue中  
  65.     action_for_each_trigger("init", action_add_queue_tail);  
  66.     //将early-fs动作添加到链表action_queue中  
  67.     action_for_each_trigger("early-fs", action_add_queue_tail);  
  68.     //将fs动作添加到链表action_queue中  
  69.     action_for_each_trigger("fs", action_add_queue_tail);  
  70.     //将post-fs动作添加到链表action_queue中  
  71.     action_for_each_trigger("post-fs", action_add_queue_tail);  
  72.     //非充电模式下，将post-fs-data动作添加到链表action_queue中  
  73.     if (!is_charger) {  
  74.         action_for_each_trigger("post-fs-data", action_add_queue_tail);  
  75.     }  
  76.     //创建property_service_init动作并添加到链表action_queue和action_list中  
  77.     queue_builtin_action(property_service_init_action, "property_service_init");  
  78.     //创建signal_init动作并添加到链表action_queue和action_list中  
  79.     queue_builtin_action(signal_init_action, "signal_init");  
  80.     //创建check_startup动作并添加到链表action_queue和action_list中  
  81.     queue_builtin_action(check_startup_action, "check_startup");  
  82.   
  83.     if (!strcmp(bootmode, "alarm")) {  
  84.         action_for_each_trigger("alarm", action_add_queue_tail);  
  85.     }  
  86.       
  87.     if (is_charger) {  
  88.         //充电模式下，将charger动作添加到链表action_queue中  
  89.         action_for_each_trigger("charger", action_add_queue_tail);  
  90.     } else {  
  91.         //非充电模式下，将early-boot、boot动作添加到链表action_queue中  
  92.         action_for_each_trigger("early-boot", action_add_queue_tail);  
  93.         action_for_each_trigger("boot", action_add_queue_tail);  
  94.     }  
  95.     //创建queue_property_triggers动作并添加到链表action_queue和action_list中  
  96.     queue_builtin_action(queue_property_triggers_action, "queue_property_triggers");  
  97.   
  98.   
  99. #if BOOTCHART  
  100.     //如果BOOTCHART宏定义了，创建bootchart_init动作并添加到链表action_queue和action_list中  
  101.     queue_builtin_action(bootchart_init_action, "bootchart_init");  
  102. #endif  
  103.   
  104.     for(;;) {  
  105.         int nr, i, timeout = -1;  
  106.         //按序执行action_queue里的action  
  107.         execute_one_command();  
  108.         //重启一些关键进程  
  109.         restart_processes();  
  110.         //添加事件句柄到句柄次  
  111.         if (!property_set_fd_init && get_property_set_fd() > 0) {  
  112.             ufds[fd_count].fd = get_property_set_fd();  
  113.             ufds[fd_count].events = POLLIN;  
  114.             ufds[fd_count].revents = 0;  
  115.             fd_count++;  
  116.             property_set_fd_init = 1;  
  117.         }  
  118.         if (!signal_fd_init && get_signal_fd() > 0) {  
  119.             ufds[fd_count].fd = get_signal_fd();  
  120.             ufds[fd_count].events = POLLIN;  
  121.             ufds[fd_count].revents = 0;  
  122.             fd_count++;  
  123.             signal_fd_init = 1;  
  124.         }  
  125.         if (!keychord_fd_init && get_keychord_fd() > 0) {  
  126.             ufds[fd_count].fd = get_keychord_fd();  
  127.             ufds[fd_count].events = POLLIN;  
  128.             ufds[fd_count].revents = 0;  
  129.             fd_count++;  
  130.             keychord_fd_init = 1;  
  131.         }  
  132.         //计算超时时间  
  133.         if (process_needs_restart) {  
  134.             timeout = (process_needs_restart - gettime()) * 1000;  
  135.             if (timeout < 0)  
  136.                 timeout = 0;  
  137.         }  
  138.   
  139.         if (!action_queue_empty() || cur_action)  
  140.             timeout = 0;  
  141.   
  142. #if BOOTCHART  
  143.         if (bootchart_count > 0) {  
  144.             if (timeout < 0 || timeout > BOOTCHART_POLLING_MS)  
  145.                 timeout = BOOTCHART_POLLING_MS;  
  146.             if (bootchart_step() < 0 || --bootchart_count == 0) {  
  147.                 bootchart_finish();  
  148.                 bootchart_count = 0;  
  149.             }  
  150.         }  
  151. #endif  
  152.         //监控句柄池中的事件  
  153.         nr = poll(ufds, fd_count, timeout);  
  154.         if (nr <= 0)  
  155.             continue;  
  156.         //事件处理  
  157.         for (i = 0; i < fd_count; i++) {  
  158.             if (ufds[i].revents == POLLIN) {  
  159.                 if (ufds[i].fd == get_property_set_fd())  
  160.                     handle_property_set_fd();  
  161.                 else if (ufds[i].fd == get_keychord_fd())  
  162.                     handle_keychord();  
  163.                 else if (ufds[i].fd == get_signal_fd())  
  164.                     handle_signal();  
  165.             }  
  166.         }  
  167.     }  
  168.     return 0;  
  169. }  

文件系统简介

tmpfs文件系统

    tmpfs是一种虚拟内存文件系统，因此它会将所有的文件存储在虚拟内存中，并且tmpfs下的所有内容均为临时性的内容，如果你将tmpfs文件系统卸载后，那么其下的所有的内容将不复存在。tmpfs是一个独立的文件系统，不是块设备，只要挂接，立即就可以使用。

devpts文件系统   

    devpts文件系统为伪终端提供了一个标准接口，它的标准挂接点是/dev/pts。只要pty的主复合设备/dev/ptmx被打开，就会在/dev/pts下动态的创建一个新的pty设备文件。

proc文件系统

    proc文件系统是一个非常重要的虚拟文件系统，它可以看作是内核内部数据结构的接口，通过它我们可以获得系统的信息，同时也能够在运行时修改特定的内核参数。

sysfs文件系统

    与proc文件系统类似，sysfs文件系统也是一个不占有任何磁盘空间的虚拟文件系统。它通常被挂接在/sys目录下。sysfs文件系统是Linux2.6内核引入的，它把连接在系统上的设备和总线组织成为一个分级的文件，使得它们可以在用户空间存取。

屏蔽标准的输入输出

[cpp]  view plain  copy
  1. void open_devnull_stdio(void)  
  2. {  
  3.     int fd;  
  4.     //创建一个字符专用文件/dev/__null__   
  5.     static const char *name = "/dev/__null__";  
  6.     if (mknod(name, S_IFCHR | 0600, (1 << 8) | 3) == 0) {  
  7.         //获取/dev/__null__的文件描述符，并输出该文件  
  8.         fd = open(name, O_RDWR);  
  9.         unlink(name);  
  10.         if (fd >= 0) {  
  11.         //将与进程相关的标准输入(0),标准输出(1),标准错误输出(2)，均定向到NULL设备  
  12.             dup2(fd, 0);  
  13.             dup2(fd, 1);  
  14.             dup2(fd, 2);  
  15.             if (fd > 2) {  
  16.                 close(fd);  
  17.             }  
  18.             return;  
  19.         }  
  20.     }  
  21.   
  22.     exit(1);  
  23. }  
将标准输入输出，错误输出重定向到/dev/_null_设备中

初始化内核log系统

[cpp]  view plain  copy
  1. void klog_init(void)  
  2. {  
  3.     static const char *name = "/dev/__kmsg__";  
  4.     //创建/dev/__kmsg__设备节点  
  5.     if (mknod(name, S_IFCHR | 0600, (1 << 8) | 11) == 0) {  
  6.         klog_fd = open(name, O_WRONLY);  
  7.         //当进程在进行exec系统调用时，要确保log_fd是关闭的  
  8.         fcntl(klog_fd, F_SETFD, FD_CLOEXEC);  
  9.         unlink(name);  
  10.     }  
  11. }  

属性存储空间初始化

[cpp]  view plain  copy
  1. void property_init(void)  
  2. {  
  3.     init_property_area();  
  4. }  
关于Android的属性系统，请查看 Android 系统属性SystemProperty分析一文，在这篇文章中详细分析了Android的属性系统。

读取机器硬件名称

从/proc/cpuinfo中获取“Hardware”字段信息写入；“Reversion” 字段信息写入

[cpp]  view plain  copy
  1. void get_hardware_name(char *hardware, unsigned int *revision)  
  2. {  
  3.     char data[1024];  
  4.     int fd, n;  
  5.     char *x, *hw, *rev;  
  6.     /* Hardware string was provided on kernel command line */  
  7.     if (hardware[0])  
  8.         return;  
  9.     //打开/proc/cpuinfo文件  
  10.     fd = open("/proc/cpuinfo", O_RDONLY);  
  11.     if (fd < 0) return;  
  12.     //读取/proc/cpuinfo文件内容  
  13.     n = read(fd, data, 1023);  
  14.     close(fd);  
  15.     if (n < 0) return;  
  16.     data[n] = 0;  
  17.     hw = strstr(data, "\nHardware");  
  18.     rev = strstr(data, "\nRevision");  
  19.     if (hw) {  
  20.         x = strstr(hw, ": ");  
  21.         if (x) {  
  22.             x += 2;  
  23.             n = 0;  
  24.             while (*x && *x != '\n') {  
  25.                 if (!isspace(*x))  
  26.                     hardware[n++] = tolower(*x);  
  27.                 x++;  
  28.                 if (n == 31) break;  
  29.             }  
  30.             hardware[n] = 0;  
  31.         }  
  32.     }  
  33.     if (rev) {  
  34.         x = strstr(rev, ": ");  
  35.         if (x) {  
  36.             *revision = strtoul(x + 2, 0, 16);  
  37.         }  
  38.     }  
  39. }  
get_hardware_name函数从/proc/cpuinfo文件中读取硬件名称等信息，/proc/cpuinfo文件内容如下：

[plain]  view plain  copy
  1. Processor   : ARMv7 Processor rev 1 (v7l)  
  2. BogoMIPS    : 1024.00  
  3. Features    : swp half thumb fastmult vfp edsp thumbee neon vfpv3   
  4. CPU implementer : 0x41  
  5. CPU architecture: 7  
  6. CPU variant : 0x0  
  7. CPU part    : 0xc05  
  8. CPU revision    : 1  
  9. Hardware    : sc7710g  
  10. Revision    : 0000  
  11. Serial      : 0000000000000000  

设置命令行参数属性

[cpp]  view plain  copy
  1. static void process_kernel_cmdline(void)  
  2. {  
  3.     /* don't expose the raw commandline to nonpriv processes */  
  4.     chmod("/proc/cmdline", 0440);  
  5.   
  6.     /* first pass does the common stuff, and finds if we are in qemu. 
  7.      * second pass is only necessary for qemu to export all kernel params 
  8.      * as props. 
  9.      */  
  10.     import_kernel_cmdline(0, import_kernel_nv);  
  11.     if (qemu[0])  
  12.         import_kernel_cmdline(1, import_kernel_nv);  
  13.   
  14.     /* now propogate the info given on command line to internal variables 
  15.      * used by init as well as the current required properties 
  16.      */  
  17.     export_kernel_boot_props();  
  18. }  
process_kernel_cmdline函数首先修改/proc/cmdline文件权限，然后调用import_kernel_cmdline函数来读取/proc/cmdline文件的内容，并查找格式为： = 的字串，调用import_kernel_nv函数来设置属性。函数export_kernel_boot_props()用于设置内核启动时需要的属性。

[cpp]  view plain  copy
  1. void import_kernel_cmdline(int in_qemu,void (*import_kernel_nv)(char *name, int in_qemu))  
  2. {  
  3.     char cmdline[1024];  
  4.     char *ptr;  
  5.     int fd;  
  6.     //打开并读取/proc/cmdline文件  
  7.     fd = open("/proc/cmdline", O_RDONLY);  
  8.     if (fd >= 0) {  
  9.         int n = read(fd, cmdline, 1023);  
  10.         if (n < 0) n = 0;  
  11.         /* get rid of trailing newline, it happens */  
  12.         if (n > 0 && cmdline[n-1] == '\n') n--;  
  13.         cmdline[n] = 0;  
  14.         close(fd);  
  15.     } else {  
  16.         cmdline[0] = 0;  
  17.     }  
  18.       
  19.     ptr = cmdline;  
  20.     while (ptr && *ptr) {  
  21.         char *x = strchr(ptr, ' ');  
  22.         if (x != 0) *x++ = 0;  
  23.         //回调import_kernel_nv函数，in_qemu =0  
  24.         import_kernel_nv(ptr, in_qemu);  
  25.         ptr = x;  
  26.     }  
  27. }  
/proc/cmdline文件内容如下：

[plain]  view plain  copy
  1. initrd=0x4c00000,0x1118e8 lpj=3350528 apv="sp7710ga-userdebug 4.1.2 JZO54K W13.23.2-010544 test-keys" mem=256M init=/init mtdparts=sprd-nand:256k(spl),512k(2ndbl),256k(params),512k(vmjaluna),10m(modem),3840k(fixnv),3840k(backupfixnv),5120k(dsp),3840k(runtimenv),10m(boot),10m(recovery),260m(system),160m(userdata),20m(cache),256k(misc),1m(boot_logo),1m(fastboot_logo),3840k(productinfo),512k(kpanic),15m(firmware) console=null  lcd_id=ID18 ram=256M  
[cpp]  view plain  copy
  1. static void import_kernel_nv(char *name, int for_emulator)  
  2. {  
  3.     char *value = strchr(name, '=');  
  4.     int name_len = strlen(name);  
  5.     if (value == 0) return;  
  6.     *value++ = 0;  
  7.     if (name_len == 0) return;  
  8.   
  9. #ifdef HAVE_SELINUX  
  10.     if (!strcmp(name,"enforcing")) {  
  11.         selinux_enforcing = atoi(value);  
  12.     } else if (!strcmp(name,"selinux")) {  
  13.         selinux_enabled = atoi(value);  
  14.     }  
  15. #endif  
  16.     //判断是否为模拟器  
  17.     if (for_emulator) {  
  18.         /* in the emulator, export any kernel option with the 
  19.          * ro.kernel. prefix */  
  20.         char buff[PROP_NAME_MAX];  
  21.         int len = snprintf( buff, sizeof(buff), "ro.kernel.%s", name );  
  22.         if (len < (int)sizeof(buff))  
  23.             property_set( buff, value );  
  24.         return;  
  25.     }  
  26.     //如果/proc/cmdline文件中有qemu关键字  
  27.     if (!strcmp(name,"qemu")) {  
  28.         strlcpy(qemu, value, sizeof(qemu));  
  29.     //如果/proc/cmdline文件中有以androidboot.开头的关键字  
  30.     } else if (!strncmp(name, "androidboot.", 12) && name_len > 12) {  
  31.         const char *boot_prop_name = name + 12;  
  32.         char prop[PROP_NAME_MAX];  
  33.         int cnt;  
  34.         //格式化为ro.boot.xx 属性  
  35.         cnt = snprintf(prop, sizeof(prop), "ro.boot.%s", boot_prop_name);  
  36.         if (cnt < PROP_NAME_MAX)  
  37.             property_set(prop, value);  
  38.     }  
  39. }  
最后调用函数export_kernel_boot_props设置内核启动属性

[cpp]  view plain  copy
  1. static void export_kernel_boot_props(void)  
  2. {  
  3.     char tmp[PROP_VALUE_MAX];  
  4.     const char *pval;  
  5.     unsigned i;  
  6.     //属性表  
  7.     struct {  
  8.         const char *src_prop;  
  9.         const char *dest_prop;  
  10.         const char *def_val;  
  11.     } prop_map[] = {  
  12.         { "ro.boot.serialno", "ro.serialno", "", },  
  13.         { "ro.boot.mode", "ro.bootmode", "unknown", },  
  14.         { "ro.boot.baseband", "ro.baseband", "unknown", },  
  15.         { "ro.boot.bootloader", "ro.bootloader", "unknown", },  
  16.     };  
  17.     //循环读取ro.boot.xxx属性值，并设置ro.xxx属性  
  18.     for (i = 0; i < ARRAY_SIZE(prop_map); i++) {  
  19.         pval = property_get(prop_map[i].src_prop);  
  20.         property_set(prop_map[i].dest_prop, pval ?: prop_map[i].def_val);  
  21.     }  
  22.     //读取ro.boot.console属性值  
  23.     pval = property_get("ro.boot.console");  
  24.     if (pval)  
  25.         strlcpy(console, pval, sizeof(console));  
  26.     //读取ro.bootmode属性值  
  27.     strlcpy(bootmode, property_get("ro.bootmode"), sizeof(bootmode));  
  28.     //读取ro.boot.hardware属性值  
  29.     pval = property_get("ro.boot.hardware");  
  30.     if (pval)  
  31.         strlcpy(hardware, pval, sizeof(hardware));  
  32.     //设置ro.hardware属性  
  33.     property_set("ro.hardware", hardware);  
  34.     //设置ro.revision属性  
  35.     snprintf(tmp, PROP_VALUE_MAX, "%d", revision);  
  36.     property_set("ro.revision", tmp);  
  37.     //设置ro.factorytest属性  
  38.     if (!strcmp(bootmode,"factory"))  
  39.         property_set("ro.factorytest", "1");  
  40.     else if (!strcmp(bootmode,"factory2"))  
  41.         property_set("ro.factorytest", "2");  
  42.     else  
  43.         property_set("ro.factorytest", "0");  
  44. }  

init.rc 文件解析

[cpp]  view plain  copy
  1. init_parse_config_file(const char *fn)  
  2. {  
  3.     char *data;  
  4.     //读取/init.rc文件内容  
  5.     data = read_file(fn, 0);  
  6.     if (!data) return -1;  
  7.     //解析读取到的文件内容  
  8.     parse_config(fn, data);  
  9.     DUMP();  
  10.     return 0;  
  11. }  
函数首先调用read_file函数将init.rc文件的内容读取保存到data中，在调用parse_config对其进行解析
[cpp]  view plain  copy
  1. void *read_file(const char *fn, unsigned *_sz)  
  2. {  
  3.     char *data;  
  4.     int sz;  
  5.     int fd;  
  6.     struct stat sb;  
  7.     data = 0;  
  8.     //打开/init.rc文件  
  9.     fd = open(fn, O_RDONLY);  
  10.     if(fd < 0) return 0;  
  11.   
  12.     // for security reasons, disallow world-writable  
  13.     // or group-writable files  
  14.     if (fstat(fd, &sb) < 0) {  
  15.         ERROR("fstat failed for '%s'\n", fn);  
  16.         goto oops;  
  17.     }  
  18.     if ((sb.st_mode & (S_IWGRP | S_IWOTH)) != 0) {  
  19.         ERROR("skipping insecure file '%s'\n", fn);  
  20.         goto oops;  
  21.     }  
  22.     //将文件指针移到文件尾部，得到文件内容长度  
  23.     sz = lseek(fd, 0, SEEK_END);  
  24.     if(sz < 0) goto oops;  
  25.   
  26.     if(lseek(fd, 0, SEEK_SET) != 0) goto oops;  
  27.     //分配buffer  
  28.     data = (char*) malloc(sz + 2);  
  29.     if(data == 0) goto oops;  
  30.     //读取文件  
  31.     if(read(fd, data, sz) != sz) goto oops;  
  32.     close(fd);  
  33.     data[sz] = '\n';  
  34.     data[sz+1] = 0;  
  35.     if(_sz) *_sz = sz;  
  36.     return data;  
  37. oops:  
  38.     close(fd);  
  39.     if(data != 0) free(data);  
  40.     return 0;  
  41. }  

init.rc文件语法介绍

在Android根文件系统下存在多个.rc文件，该文件为Android启动配置脚本文件，文件内容如下：

[plain]  view plain  copy
  1. # Copyright (C) 2012 The Android Open Source Project  
  2. #  
  3. # IMPORTANT: Do not create world writable files or directories.  
  4. # This is a common source of Android security bugs.  
  5. #  
  6.   
  7. import /init.${ro.hardware}.rc  
  8. import /init.usb.rc  
  9. import /init.trace.rc  
  10.   
  11. on early-init  
  12.     # Set init and its forked children's oom_adj.  
  13.     write /proc/1/oom_adj -16  
  14.     start ueventd  
  15.     mkdir /mnt 0775 root system  
  16.   
  17. on init  
  18.     sysclktz 0  
  19.     loglevel 3  
  20. # setup the global environment  
  21.     export PATH /sbin:/vendor/bin:/system/sbin:/system/bin:/system/xbin  
  22.     export LD_LIBRARY_PATH /vendor/lib:/system/lib  
  23.     export ANDROID_BOOTLOGO 1  
  24.     export ANDROID_ROOT /system  
  25.     export ANDROID_ASSETS /system/app  
  26.     export ANDROID_DATA /data  
  27.     export ASEC_MOUNTPOINT /mnt/asec  
  28.     export LOOP_MOUNTPOINT /mnt/obb  
  29.     export BOOTCLASSPATH /system/framework/core.jar:/system/framework/core-junit.jar:/system/framework/bouncycastle.jar:/system/framework/ext.jar:/system/framework/framework.jar:/system/framework/framework2.jar:/system/framework/android.policy.jar:/system/framework/services.jar:/system/framework/apache-xml.jar  
  30.   
  31. # Backward compatibility  
  32.     symlink /system/etc /etc  
  33.     symlink /sys/kernel/debug /d  
  34.   
  35. # Right now vendor lives on the same filesystem as system,  
  36. # but someday that may change.  
  37.     symlink /system/vendor /vendor  
  38.   
  39. # Create cgroup mount point for cpu accounting  
  40.     mkdir /acct  
  41.     mount cgroup none /acct cpuacct  
  42.     mkdir /acct/uid  
  43.   
  44.     mkdir /system  
  45.     mkdir /data 0771 system system  
  46.     mkdir /cache 0770 system cache  
  47.     mkdir /runtimenv 0774 system system  
  48.     mkdir /backupfixnv 0774 system system  
  49.     mkdir /productinfo 0774 system system  
  50.     mkdir /fixnv 0774 system system  
  51.     mkdir /config 0500 root root  
  52.   
  53. # Create cgroup mount points for process groups  
  54.     mkdir /dev/cpuctl  
  55.     mount cgroup none /dev/cpuctl cpu  
  56.     chown system system /dev/cpuctl  
  57.     chown system system /dev/cpuctl/tasks  
  58.     chmod 0660 /dev/cpuctl/tasks  
  59.     write /dev/cpuctl/cpu.shares 1024  
  60.     write /dev/cpuctl/cpu.rt_runtime_us 950000  
  61.     write /dev/cpuctl/cpu.rt_period_us 1000000  
  62.   
  63.     mkdir /dev/cpuctl/apps  
  64.     chown system system /dev/cpuctl/apps/tasks  
  65.     chmod 0666 /dev/cpuctl/apps/tasks  
  66.     write /dev/cpuctl/apps/cpu.shares 1024  
  67.     write /dev/cpuctl/apps/cpu.rt_runtime_us 800000  
  68.     write /dev/cpuctl/apps/cpu.rt_period_us 1000000  
  69.   
  70. on fs  
  71. # mount mtd partitions  
  72.     # Mount /system rw first to give the filesystem a chance to save a checkpoint  
  73.   
  74.     chmod 0744 /modem_control  
  75.     start modem_control  
  76.   
  77.     mount yaffs2 mtd@system /system  
  78.     mount yaffs2 mtd@system /system ro remount  
  79.     mount yaffs2 mtd@userdata /data nosuid nodev  
  80.     mount yaffs2 mtd@cache /cache nosuid nodev  
  81.   
  82. on post-fs  
  83.     # once everything is setup, no need to modify /  
  84.     mount rootfs rootfs / ro remount  
  85.   
  86.     mount yaffs2 mtd@fixnv /fixnv nosuid nodev no-checkpoint  
  87.     chown system system /fixnv  
  88.     chmod 0774 /fixnv  
  89.   
  90.     mount yaffs2 mtd@runtimenv /runtimenv nosuid nodev no-checkpoint  
  91.     chown system system /runtimenv  
  92.     chmod 0774 /runtimenv  
  93.   
  94.     # We chown/chmod /cache again so because mount is run as root + defaults  
  95.     chown system cache /cache  
  96.     chmod 0770 /cache  
  97.   
  98.     mount yaffs2 mtd@backupfixnv /backupfixnv nosuid nodev no-checkpoint  
  99.     chown system system /backupfixnv  
  100.     chmod 0774 /backupfixnv  
  101.   
  102.     mount yaffs2 mtd@productinfo /productinfo nosuid nodev no-checkpoint  
  103.     chown system system /productinfo  
  104.     chmod 0774 /productinfo  
  105.   
  106.     chmod 0660 /fixnv/fixnv.bin  
  107.     chmod 0660 /backupfixnv/fixnv.bin  
  108.     chmod 0660 /productinfo/productinfo.bin  
  109.     chmod 0660 /productinfo/productinfobkup.bin  
  110.     chown system system /fixnv/fixnv.bin  
  111.     chown system system /backupfixnv/fixnv.bin  
  112.     chown system system /productinfo/productinfo.bin  
  113.     chown system system /productinfo/productinfobkup.bin  
  114.   
  115.     # This may have been created by the recovery system with odd permissions  
  116.     chown system cache /cache/recovery  
  117.     chmod 0770 /cache/recovery  
  118.   
  119.     #change permissions on vmallocinfo so we can grab it from bugreports  
  120.     chown root log /proc/vmallocinfo  
  121.     chmod 0440 /proc/vmallocinfo  
  122.   
  123.     #change permissions on kmsg & sysrq-trigger so bugreports can grab kthread stacks  
  124.     chown root system /proc/kmsg  
  125.     chmod 0440 /proc/kmsg  
  126.     chown root system /proc/sysrq-trigger  
  127.     chmod 0220 /proc/sysrq-trigger  
  128.   
  129.     # create the lost+found directories, so as to enforce our permissions  
  130.     mkdir /cache/lost+found 0770 root root  
  131.   
  132. on post-fs-data  
  133.     # create basic filesystem structure  
  134.     mkdir /data/misc 01771 system misc  
  135.     mkdir /data/misc/bluetoothd 0770 bluetooth bluetooth  
  136.     mkdir /data/misc/bluetooth 0770 system system  
  137.     mkdir /data/misc/keystore 0700 keystore keystore  
  138.     mkdir /data/misc/keychain 0771 system system  
  139.     mkdir /data/misc/ 0770 system   
  140.     mkdir /data/misc/systemkeys 0700 system system  
  141.   
  142. on boot  
  143. # basic network init  
  144.     ifup lo  
  145.     hostname localhost  
  146.     domainname localdomain  
  147.   
  148. # set RLIMIT_NICE to allow priorities from 19 to -20  
  149.     setrlimit 13 40 40  
  150.   
  151. # Memory management.  Basic kernel parameters, and allow the high  
  152. # level system server to be able to adjust the kernel OOM driver  
  153. # parameters to match how it is managing things.  
  154.     write /proc/sys/vm/overcommit_memory 1  
  155.     write /proc/sys/vm/min_free_order_shift 4  
  156.     chown root system /sys/module/lowmemorykiller/parameters/adj  
  157.   
  158.     # Tweak background writeout  
  159.     write /proc/sys/vm/dirty_expire_centisecs 200  
  160.     write /proc/sys/vm/dirty_background_ratio  5  
  161.   
  162.     class_start core  
  163.     class_start main  
  164.   
  165. on nonencrypted  
  166.     class_start late_start  
  167.   
  168. on charger  
  169.     class_start core  
  170.     class_start charger  
  171.   
  172. on alarm  
  173.     insmod /system/lib/modules/ft5306_ts.ko  
  174.     class_start core  
  175.     start media  
  176.     exec /bin/poweroff_alarm  
  177.   
  178. on property:vold.decrypt=trigger_reset_main  
  179.     class_reset main  
  180.   
  181. on property:vold.decrypt=trigger_load_persist_props  
  182.     load_persist_props  
  183.   
  184. on property:vold.decrypt=trigger_post_fs_data  
  185.     trigger post-fs-data  
  186.   
  187. on property:vold.decrypt=trigger_restart_min_framework  
  188.     class_start main  
  189.   
  190. on property:vold.decrypt=trigger_restart_framework  
  191.     class_start main  
  192.     class_start late_start  
  193.   
  194. on property:vold.decrypt=trigger_shutdown_framework  
  195.     class_reset late_start  
  196.     class_reset main  
  197.   
  198. ## Daemon processes to be run by init.  
  199. ##  
  200. service ueventd /sbin/ueventd  
  201.     class core  
  202.     critical  
  203.   
  204. service console /system/bin/sh  
  205.     class core  
  206.     console  
  207.     disabled  
  208.     user shell  
  209.     group log  
  210.   
  211. on property:ro.debuggable=1  
  212.     start console  
  213.   
  214. # adbd is controlled via property triggers in init..usb.rc  
  215. service adbd /sbin/adbd  
  216.     class core  
  217.     disabled  
  218.   
  219. # adbd on at boot in emulator  
  220. on property:ro.kernel.qemu=1  
  221.     start adbd  
  222.   
  223. # This property trigger has added to imitiate the previous behavior of "adb root".  
  224. # The adb gadget driver used to reset the USB bus when the adbd daemon exited,  
  225. # and the host side adb relied on this behavior to force it to reconnect with the  
  226. # new adbd instance after init relaunches it. So now we force the USB bus to reset  
  227. # here when adbd sets the service.adb.root property to 1.  We also restart adbd here  
  228. # rather than waiting for init to notice its death and restarting it so the timing  
  229. # of USB resetting and adb restarting more closely matches the previous behavior.  
  230. on property:service.adb.root=1  
  231.     write /sys/class/android_usb/android0/enable 0  
  232.     restart adbd  
  233.     write /sys/class/android_usb/android0/enable 1  
  234.   
  235. service servicemanager /system/bin/servicemanager  
  236.     class core  
  237.     user system  
  238.     group system  
  239.     critical  
  240.     onrestart restart zygote  
  241.     onrestart restart media  
  242.     onrestart restart surfaceflinger  
  243.     onrestart restart drm  
  244.   
  245. service vold /system/bin/vold  
  246.     class core  
  247.     socket vold stream 0660 root mount  
  248.     ioprio be 2  
  249.   
  250. service netd /system/bin/netd  
  251.     class main  
  252.     socket netd stream 0660 root system  
  253.     socket dnsproxyd stream 0660 root inet  
  254.     socket mdns stream 0660 root system  
  255.   
  256. service debuggerd /system/bin/debuggerd  
  257.     class main  
  258.   
  259. #service ril-daemon /system/bin/rild  
  260. #    class main  
  261. #    socket rild stream 660 root radio  
  262. #    socket rild-debug stream 660 radio system  
  263. #    user root  
  264. #    group radio cache inet misc audio sdcard_r sdcard_rw log  
  265.   
  266. service surfaceflinger /system/bin/surfaceflinger  
  267.     class main  
  268.     user system  
  269.     group graphics  
  270.     onrestart restart zygote  
  271.   
  272. service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server  
  273.     class main  
  274.     socket zygote stream 660 root system  
  275.     onrestart write /sys/android_power/request_state wake  
  276.     onrestart write /sys/power/state on  
  277.     onrestart restart media  
  278.     onrestart restart netd  
  279.   
  280. service bootanim /system/bin/bootanimation  
  281.     class main  
  282.     user graphics  
  283.     group graphics  
  284.     disabled  
  285.     oneshot  
  286.   
  287. service dbus /system/bin/dbus-daemon --system --nofork  
  288.     class main  
  289.     socket dbus stream 660 bluetooth bluetooth  
  290.     user bluetooth  
  291.     group bluetooth net_bt_admin  
  292.   
  293. service bluetoothd /system/bin/bluetoothd -n  
  294.     class main  
  295.     socket bluetooth stream 660 bluetooth bluetooth  
  296.     socket dbus_bluetooth stream 660 bluetooth bluetooth  
  297.     # init.rc does not yet support applying capabilities, so run as root and  
  298.     # let bluetoothd drop uid to bluetooth with the right linux capabilities  
  299.     group bluetooth net_bt_admin misc  
  300.     disabled  
  301.   
  302. service installd /system/bin/installd  
  303.     class main  
  304.     socket installd stream 600 system system  
  305.   
  306. service flash_recovery /system/etc/install-recovery.sh  
  307.     class main  
  308.     oneshot  
  309.   
  310. service racoon /system/bin/racoon  
  311.     class main  
  312.     socket racoon stream 600 system system  
  313.     # IKE uses UDP port 500. Racoon will setuid to  after binding the port.  
  314.     group  net_admin inet  
  315.     disabled  
  316.     oneshot  
  317.   
  318. service mtpd /system/bin/mtpd  
  319.     class main  
  320.     socket mtpd stream 600 system system  
  321.     user   
  322.     group  net_admin inet net_raw  
  323.     disabled  
  324.     oneshot  
  325.   
  326. service keystore /system/bin/keystore /data/misc/keystore  
  327.     class main  
  328.     user keystore  
  329.     group keystore drmrpc  
  330.     socket keystore stream 666  
init.rc是一个可配置的初始化文件,通常定制厂商可以配置额外的初始化配置，如果关键字中有空格，处理方法类似于C语言，使用/表示转义，使用“”防止关键字被断开，另外注意/在末尾表示换行，由 # （前面允许有空格）开始的行都是注释行。init.rc包含4种状态类别：Actions/Commands/Services/Options。当声明一个service或者action的时候，它将隐式声明一个section，它之后跟随的command或者option都将属于这个section，action和service不能重名，否则忽略为error。

Action

actions就是在某种条件下触发一系列的命令，通常有一个trigger，形式如：  

on
     
     

trigger主要包括：

boot 当/init.conf加载完毕时
= 当被设置为时
device-added- 设备被添加时
device-removed- 设备被移除时
service-exited- 服务退出时

Service

service就是要启动的本地服务进程

service [ ]*
     

Option

option是service的修饰词，由它来指定何时并且如何启动Services程序，主要包括：
     critical  表示如果服务在4分钟内存在多于4次，则系统重启到recovery mode
     disabled   表示服务不会自动启动，需要手动调用名字启动
     setEnv   设置启动环境变量
     socket [ []] 开启一个unix域的socket，名字为/dev/socket/ , 只能是dgram或者stream,和默认为0
     user 表示将用户切换为,用户名已经定义好了，只能是system/root
     group   表示将组切换为
     oneshot 表示这个service只启动一次
     class 指定一个要启动的类，这个类中如果有多个service，将会被同时启动。默认的class将会是“default”
     onrestart  在重启时执行一条命令

Command

comand主要包括：

 exec [ ]*执行一个指定的程序
 export 设置一个全局变量
 ifup 使网络接口连接
 import 引入其他的配置文件
 hostname 设置主机名
 chdir 切换工作目录
 chmod 设置访问权限
 chown 设置用户和组
 chroot 设置根目录
 class_start 启动类中的service
 class_stop 停止类中的service
 domainname 设置域名
 insmod 安装模块
 mkdir [mode] [owner] [group] 创建一个目录，并可以指定权限，用户和组
 mount

[ ]* 加载指定设备到目录下 包括"ro", "rw", "remount", "noatime"
 setprop 设置系统属性
 setrlimit 设置资源访问权限
 start 开启服务
 stop 停止服务
 symlink 创建一个动态链接
 sysclktz 设置系统时钟
 trigger 触发事件
 write [ ]* 向路径的文件写入多个

Properties（属性）

Init更新一些系统属性以提供对正在发生的事件的监控能力:
       init.action 此属性值为正在被执行的action的名字，如果没有则为""。
       init.command  此属性值为正在被执行的command的名字，如果没有则为""。
       init.svc. 名为的service的状态("stopped"（停止）, "running"（运行）, "restarting"（重启）)


在默认情况下，程序在被init执行时会将标准输出和标准错误都重定向到/dev/null（丢弃）。若你想要获得调试信息，你可以通过Andoird系统中的logwrapper程序执行你的程序。它会将标准输出/标准错误都重定向到Android日志系统(通过logcat访问)。
例如：
    service akmd /system/bin/logwrapper /sbin/akmd

init.rc解析过程

1. 扫描init.rc中的token
    找到其中的 文件结束EOF/文本TEXT/新行NEWLINE，其中的空格‘ ’、‘\t’、‘\r’会被忽略，#开头的行也被忽略掉；而对于TEXT，空格‘ ’、‘\t’、‘\r’、‘\n’都是TEXT的结束标志。
2. 对每一个TEXT token，都加入到args[]数组中
3. 当遇到新一行（‘\n’）的时候，用args[0]通过lookup_keyword()检索匹配关键字；

   1) 对Section（on和service），调用parse_new_section() 解析：
     - 对on section，调用parse_action()，并设置解析函数parse_line为parse_line_action()
     - 对service section，调用parse_service()，并设置解析函数parse_line为parse_line_service()
   2) 对其他关键字的行（非on或service开头的地方，也就是没有切换section）调用parse_line()
     - 对于on section内的命令行，调用parse_line_action()解析；
     - 对于service section内的命令行，调用parse_line_service()解析。

Token的定义

[cpp]  view plain  copy
  1. #define T_EOF 0  
  2. #define T_TEXT 1  
  3. #define T_NEWLINE 2  
 解析过程中的双向循环链表的使用，android用到了一个非常巧妙的链表实现方法，一般情况下如果链表的节点是一个单独的数据结构的话，那么针对不同的数据结构，都需要定义不同链表操作。而在初始化过程中使用到的链表则解决了这个问题，它将链表的节点定义为了一个非常精简的结构，只包含前向和后向指针，那么在定义不同的数据结构时，只需要将链表节点嵌入到数据结构中即可。链表节点定义如下：

[cpp]  view plain  copy
  1. struct listnode  
  2. {  
  3.     struct listnode *next;  
  4.     struct listnode *prev;  
  5. };  
对于Action数据结构为例：
[cpp]  view plain  copy
  1. struct action {  
  2.     /* node in list of all actions */  
  3.     struct listnode alist;  
  4.     /* node in the queue of pending actions */  
  5.     struct listnode qlist;  
  6.     /* node in list of actions for a trigger */  
  7.     struct listnode tlist;  
  8.   
  9.     unsigned hash;  
  10.     const char *name;  
  11.      
  12.     struct listnode commands;  
  13.     struct command *current;  
  14. };  
这样的话，所有的链表的基本操作，例如插入，删除等只会针对listnode进行操作，而不是针对特定的数据结构，链表的实现得到了统一，即精简了代码，又提高了效率。 但是这样的链表实现，存在一个问题，链表节点listnode中只有前向和后向指针，并且前向和后向指针均指向listnode，那么我们通过什么方式来访问数据结构action的内容呢？我们使用offsetof宏来计算链表节点在数据结构中的偏移量，从而计算数据结构实例的地址。

[cpp]  view plain  copy
  1. #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)  

[cpp]  view plain  copy
  1. #define node_to_item(node, container, member) \  
  2.     (container *) (((char*) (node)) - offsetof(container, member))  
这种链表的优点：(1)所有链表基本操作都是基于listnode指针的，因此添加类型时，不需要重复写链表基本操作函数(2)一个container数据结构可以含有多个listnode成员，这样就可以同时挂到多个不同的链表中。

Service数据结构定义：

[cpp]  view plain  copy
  1. struct service {  
  2.         /* list of all services */  
  3.     struct listnode slist;  
  4.     const char *name;  
  5.     const char *classname;  
  6.     unsigned flags;  
  7.     pid_t pid;  
  8.     time_t time_started;    /* time of last start */  
  9.     time_t time_crashed;    /* first crash within inspection window */  
  10.     int nr_crashed;         /* number of times crashed within window */  
  11.       
  12.     uid_t uid;  
  13.     gid_t gid;  
  14.     gid_t supp_gids[NR_SVC_SUPP_GIDS];  
  15.     size_t nr_supp_gids;  
  16.   
  17. #ifdef HAVE_SELINUX  
  18.     char *seclabel;  
  19. #endif  
  20.     struct socketinfo *sockets;  
  21.     struct svcenvinfo *envvars;  
  22.     struct action onrestart;  /* Actions to execute on restart. */    
  23.     /* keycodes for triggering this service via /dev/keychord */  
  24.     int *keycodes;  
  25.     int nkeycodes;  
  26.     int keychord_id;  
  27.     int ioprio_class;  
  28.     int ioprio_pri;  
  29.     int nargs;  
  30.     /* "MUST BE AT THE END OF THE STRUCT" */  
  31.     char *args[1];  
  32. };  
对于某些Service可能采用Socket来实现进程间通信，因此该Service需要创建多个socket，比如：

[cpp]  view plain  copy
  1. service wril-daemon /system/bin/rild_sp -l /system/lib/libreference-ril_sp.so -m w -n 0  
  2.     class core  
  3.     socket rild stream 660 root radio  
  4.     socket rild-debug stream 660 radio system  
  5.     disabled  
  6.     user root  
  7.     group radio cache inet misc audio sdcard_rw log  
该service需要创建rild 和rild-debug socket，这些socket的信息在解析init.rc文件时保存在Service的成员变量sockets链表中。socketinfo 数据结构定义如下:

[cpp]  view plain  copy
  1. struct socketinfo {  
  2.     struct socketinfo *next;  
  3.     const char *name;  
  4.     const char *type;  
  5.     uid_t uid;  
  6.     gid_t gid;  
  7.     int perm;  
  8. };  

某些Service在运行时需要设置环境变量，这些环境变量被保存在Service的成员变量envvars链表中,svcenvinfo 数据结构定义如下：

[cpp]  view plain  copy
  1. struct svcenvinfo {  
  2.     struct svcenvinfo *next;  
  3.     const char *name;  
  4.     const char *value;  
  5. };  
在每个Action或Service下可能需要执行多个Command，关于command数据结构定义如下：

[cpp]  view plain  copy
  1. struct command  
  2. {  
  3.         /* list of commands in an action */  
  4.     struct listnode clist;  
  5.   
  6.     int (*func)(int nargs, char **args);  
  7.     int nargs;  
  8.     char *args[1];  
  9. };  

在Init进程中分别使用了3个链表来存储init.rc文件中的Action和Service：

[cpp]  view plain  copy
  1. static list_declare(service_list);  
  2. static list_declare(action_list);  
  3. static list_declare(action_queue);  
service_list链表用于保存init.rc文件中的Service配置信息，service_list链表的存储如下图所示：

service_list 链表保存init.rc文件中的所有service，每个service下的所有socket信息保存在该service的成员变量sockets链表中，当该service重启时，需要重启某些服务，对于重启某些服务的命令以Action的形式保存在Service的成员变量onrestart链表中，而真正执行的命令却存放在该Action下的commands链表里。

action_list用于保存init.rc文件中的所有以on开头的section，action_list链表的存储如下图所示：

从上图可以看出action_queue和action_list都是用来保存所有的Action，它们之间的区别是action_list用于保存从init.rc中解析出来的所有Action,而action_queue却是用于保存待执行的Action，action_queue是一个待执行队列。

在system\core\init\keywords.h文件中定义了解析关键字，其内容如下：

[cpp]  view plain  copy
  1. #ifndef KEYWORD  
  2. int do_chroot(int nargs, char **args);  
  3. int do_chdir(int nargs, char **args);  
  4. int do_class_start(int nargs, char **args);  
  5. int do_class_stop(int nargs, char **args);  
  6. int do_class_reset(int nargs, char **args);  
  7. int do_domainname(int nargs, char **args);  
  8. int do_exec(int nargs, char **args);  
  9. int do_export(int nargs, char **args);  
  10. int do_hostname(int nargs, char **args);  
  11. int do_ifup(int nargs, char **args);  
  12. int do_insmod(int nargs, char **args);  
  13. int do_mkdir(int nargs, char **args);  
  14. int do_mount_all(int nargs, char **args);  
  15. int do_mount(int nargs, char **args);  
  16. int do_restart(int nargs, char **args);  
  17. int do_restorecon(int nargs, char **args);  
  18. int do_rm(int nargs, char **args);  
  19. int do_rmdir(int nargs, char **args);  
  20. int do_setcon(int nargs, char **args);  
  21. int do_setenforce(int nargs, char **args);  
  22. int do_setkey(int nargs, char **args);  
  23. int do_setprop(int nargs, char **args);  
  24. int do_setrlimit(int nargs, char **args);  
  25. int do_setsebool(int nargs, char **args);  
  26. int do_start(int nargs, char **args);  
  27. int do_stop(int nargs, char **args);  
  28. int do_trigger(int nargs, char **args);  
  29. int do_symlink(int nargs, char **args);  
  30. int do_sysclktz(int nargs, char **args);  
  31. int do_write(int nargs, char **args);  
  32. int do_copy(int nargs, char **args);  
  33. int do_chown(int nargs, char **args);  
  34. int do_chmod(int nargs, char **args);  
  35. int do_loglevel(int nargs, char **args);  
  36. int do_load_persist_props(int nargs, char **args);  
  37. int do_pipe(int nargs, char **args);  
  38. int do_wait(int nargs, char **args);  
  39. #define __MAKE_KEYWORD_ENUM__  
  40. #define KEYWORD(symbol, flags, nargs, func) K_##symbol,  
  41. enum {  
  42.     K_UNKNOWN,  
  43. #endif  
  44.     KEYWORD(capability,  OPTION,  0, 0)  
  45.     KEYWORD(chdir,       COMMAND, 1, do_chdir)  
  46.     KEYWORD(chroot,      COMMAND, 1, do_chroot)  
  47.     KEYWORD(class,       OPTION,  0, 0)  
  48.     KEYWORD(class_start, COMMAND, 1, do_class_start)  
  49.     KEYWORD(class_stop,  COMMAND, 1, do_class_stop)  
  50.     KEYWORD(class_reset, COMMAND, 1, do_class_reset)  
  51.     KEYWORD(console,     OPTION,  0, 0)  
  52.     KEYWORD(critical,    OPTION,  0, 0)  
  53.     KEYWORD(disabled,    OPTION,  0, 0)  
  54.     KEYWORD(domainname,  COMMAND, 1, do_domainname)  
  55.     KEYWORD(exec,        COMMAND, 1, do_exec)  
  56.     KEYWORD(export,      COMMAND, 2, do_export)  
  57.     KEYWORD(group,       OPTION,  0, 0)  
  58.     KEYWORD(hostname,    COMMAND, 1, do_hostname)  
  59.     KEYWORD(ifup,        COMMAND, 1, do_ifup)  
  60.     KEYWORD(insmod,      COMMAND, 1, do_insmod)  
  61.     KEYWORD(import,      SECTION, 1, 0)  
  62.     KEYWORD(keycodes,    OPTION,  0, 0)  
  63.     KEYWORD(mkdir,       COMMAND, 1, do_mkdir)  
  64.     KEYWORD(mount_all,   COMMAND, 1, do_mount_all)  
  65.     KEYWORD(mount,       COMMAND, 3, do_mount)  
  66.     KEYWORD(on,          SECTION, 0, 0)  
  67.     KEYWORD(oneshot,     OPTION,  0, 0)  
  68.     KEYWORD(onrestart,   OPTION,  0, 0)  
  69.     KEYWORD(restart,     COMMAND, 1, do_restart)  
  70.     KEYWORD(restorecon,  COMMAND, 1, do_restorecon)  
  71.     KEYWORD(rm,          COMMAND, 1, do_rm)  
  72.     KEYWORD(rmdir,       COMMAND, 1, do_rmdir)  
  73.     KEYWORD(seclabel,    OPTION,  0, 0)  
  74.     KEYWORD(service,     SECTION, 0, 0)  
  75.     KEYWORD(setcon,      COMMAND, 1, do_setcon)  
  76.     KEYWORD(setenforce,  COMMAND, 1, do_setenforce)  
  77.     KEYWORD(setenv,      OPTION,  2, 0)  
  78.     KEYWORD(setkey,      COMMAND, 0, do_setkey)  
  79.     KEYWORD(setprop,     COMMAND, 2, do_setprop)  
  80.     KEYWORD(setrlimit,   COMMAND, 3, do_setrlimit)  
  81.     KEYWORD(setsebool,   COMMAND, 1, do_setsebool)  
  82.     KEYWORD(socket,      OPTION,  0, 0)  
  83.     KEYWORD(start,       COMMAND, 1, do_start)  
  84.     KEYWORD(stop,        COMMAND, 1, do_stop)  
  85.     KEYWORD(trigger,     COMMAND, 1, do_trigger)  
  86.     KEYWORD(symlink,     COMMAND, 1, do_symlink)  
  87.     KEYWORD(sysclktz,    COMMAND, 1, do_sysclktz)  
  88.     KEYWORD(user,        OPTION,  0, 0)  
  89.     KEYWORD(wait,        COMMAND, 1, do_wait)  
  90.     KEYWORD(write,       COMMAND, 2, do_write)  
  91.     KEYWORD(copy,        COMMAND, 2, do_copy)  
  92.     KEYWORD(chown,       COMMAND, 2, do_chown)  
  93.     KEYWORD(chmod,       COMMAND, 2, do_chmod)  
  94.     KEYWORD(loglevel,    COMMAND, 1, do_loglevel)  
  95.     KEYWORD(load_persist_props,    COMMAND, 0, do_load_persist_props)  
  96.     KEYWORD(pipe,        COMMAND, 2, do_pipe)  
  97.     KEYWORD(ioprio,      OPTION,  0, 0)  
  98. #ifdef __MAKE_KEYWORD_ENUM__  
  99.     KEYWORD_COUNT,  
  100. };  
  101. #undef __MAKE_KEYWORD_ENUM__  
  102. #undef KEYWORD  
  103. #endif  
宏KEYWORD并未定义，因此将定义宏__MAKE_KEYWORD_ENUM__ 及KEYWORD，KEYWORD宏定义如下：

[cpp]  view plain  copy
  1. #define KEYWORD(symbol, flags, nargs, func) K_##symbol,  
同时定义了枚举：

[cpp]  view plain  copy
  1. enum {  
  2.     K_UNKNOWN,  
  3.     KEYWORD(capability,  OPTION,  0, 0)  
  4.     KEYWORD(chdir,       COMMAND, 1, do_chdir)  
  5.     KEYWORD(chroot,      COMMAND, 1, do_chroot)  
  6.     KEYWORD(class,       OPTION,  0, 0)  
  7.     KEYWORD(class_start, COMMAND, 1, do_class_start)  
  8.     KEYWORD(class_stop,  COMMAND, 1, do_class_stop)  
  9.     KEYWORD(class_reset, COMMAND, 1, do_class_reset)  
  10.     KEYWORD(console,     OPTION,  0, 0)  
  11.     KEYWORD(critical,    OPTION,  0, 0)  
  12.     KEYWORD(disabled,    OPTION,  0, 0)  
  13.     KEYWORD(domainname,  COMMAND, 1, do_domainname)  
  14.     KEYWORD(exec,        COMMAND, 1, do_exec)  
  15.     KEYWORD(export,      COMMAND, 2, do_export)  
  16.     KEYWORD(group,       OPTION,  0, 0)  
  17.     KEYWORD(hostname,    COMMAND, 1, do_hostname)  
  18.     KEYWORD(ifup,        COMMAND, 1, do_ifup)  
  19.     KEYWORD(insmod,      COMMAND, 1, do_insmod)  
  20.     KEYWORD(import,      SECTION, 1, 0)  
  21.     KEYWORD(keycodes,    OPTION,  0, 0)  
  22.     KEYWORD(mkdir,       COMMAND, 1, do_mkdir)  
  23.     KEYWORD(mount_all,   COMMAND, 1, do_mount_all)  
  24.     KEYWORD(mount,       COMMAND, 3, do_mount)  
  25.     KEYWORD(on,          SECTION, 0, 0)  
  26.     KEYWORD(oneshot,     OPTION,  0, 0)  
  27.     KEYWORD(onrestart,   OPTION,  0, 0)  
  28.     KEYWORD(restart,     COMMAND, 1, do_restart)  
  29.     KEYWORD(restorecon,  COMMAND, 1, do_restorecon)  
  30.     KEYWORD(rm,          COMMAND, 1, do_rm)  
  31.     KEYWORD(rmdir,       COMMAND, 1, do_rmdir)  
  32.     KEYWORD(seclabel,    OPTION,  0, 0)  
  33.     KEYWORD(service,     SECTION, 0, 0)  
  34.     KEYWORD(setcon,      COMMAND, 1, do_setcon)  
  35.     KEYWORD(setenforce,  COMMAND, 1, do_setenforce)  
  36.     KEYWORD(setenv,      OPTION,  2, 0)  
  37.     KEYWORD(setkey,      COMMAND, 0, do_setkey)  
  38.     KEYWORD(setprop,     COMMAND, 2, do_setprop)  
  39.     KEYWORD(setrlimit,   COMMAND, 3, do_setrlimit)  
  40.     KEYWORD(setsebool,   COMMAND, 1, do_setsebool)  
  41.     KEYWORD(socket,      OPTION,  0, 0)  
  42.     KEYWORD(start,       COMMAND, 1, do_start)  
  43.     KEYWORD(stop,        COMMAND, 1, do_stop)  
  44.     KEYWORD(trigger,     COMMAND, 1, do_trigger)  
  45.     KEYWORD(symlink,     COMMAND, 1, do_symlink)  
  46.     KEYWORD(sysclktz,    COMMAND, 1, do_sysclktz)  
  47.     KEYWORD(user,        OPTION,  0, 0)  
  48.     KEYWORD(wait,        COMMAND, 1, do_wait)  
  49.     KEYWORD(write,       COMMAND, 2, do_write)  
  50.     KEYWORD(copy,        COMMAND, 2, do_copy)  
  51.     KEYWORD(chown,       COMMAND, 2, do_chown)  
  52.     KEYWORD(chmod,       COMMAND, 2, do_chmod)  
  53.     KEYWORD(loglevel,    COMMAND, 1, do_loglevel)  
  54.     KEYWORD(load_persist_props,    COMMAND, 0, do_load_persist_props)  
  55.     KEYWORD(pipe,        COMMAND, 2, do_pipe)  
  56.     KEYWORD(ioprio,      OPTION,  0, 0)  
  57.     KEYWORD_COUNT,  
  58. };  
该枚举的通过宏展开后定义为：

[cpp]  view plain  copy
  1. enum {  
  2.     K_UNKNOWN,  
  3.     K_capability,  
  4.     K_chdir,  
  5.     K_chroot,  
  6.     K_class,  
  7.     K_class_start,  
  8.     K_class_stop,  
  9.     K_class_reset,  
  10.     K_console,  
  11.     K_critical,  
  12.     K_disabled,  
  13.     K_domainname,  
  14.     K_exec,  
  15.     K_export,  
  16.     K_group,  
  17.     K_hostname,  
  18.     K_ifup,  
  19.     K_insmod,  
  20.     K_import,  
  21.     K_keycodes,  
  22.     K_mkdir,  
  23.     K_mount_all,  
  24.     K_mount,  
  25.     K_on,  
  26.     K_oneshot,  
  27.     K_onrestart,  
  28.     K_restart,  
  29.     K_restorecon,  
  30.     K_rm,  
  31.     K_rmdir  
  32.     K_seclabel  
  33.     K_service  
  34.     K_setcon  
  35.     K_setenforce  
  36.     K_setenv  
  37.     K_setkey  
  38.     K_setprop  
  39.     K_setrlimit  
  40.     K_setsebool  
  41.     K_socket  
  42.     K_start  
  43.     K_stop  
  44.     K_trigger  
  45.     K_symlink  
  46.     K_sysclktz  
  47.     K_user  
  48.     K_wait  
  49.     K_write  
  50.     K_copy  
  51.     K_chown  
  52.     K_chmod  
  53.     K_loglevel  
  54.     K_load_persist_props  
  55.     K_pipe  
  56.     K_ioprio  
  57.     KEYWORD_COUNT,  
  58. };  
该枚举的定义主要是为每个命令指定对应的序号。在keywords.h文件最后取消了宏__MAKE_KEYWORD_ENUM__ 及KEYWORD的定义，在system\core\init\init_parser.c文件中又重定义了KEYWORD宏：

[cpp]  view plain  copy
  1. #define KEYWORD(symbol, flags, nargs, func) \  
  2.     [ K_##symbol ] = { #symbol, func, nargs + 1, flags, },  
该宏的定义是为了给接下来定义的keyword_info这个关键字信息数组的赋值，keyword_info定义如下：

[cpp]  view plain  copy
  1. struct {  
  2.     const char *name;  
  3.     int (*func)(int nargs, char **args);  
  4.     unsigned char nargs;  
  5.     unsigned char flags;  
  6. } keyword_info[KEYWORD_COUNT] = {  
  7.     [ K_UNKNOWN ] = { "unknown", 0, 0, 0 },  
  8. #include "keywords.h"  
  9. };  
keyword_info数组元素是keywords.h文件中的内容，因为此时KEYWORD宏已经被定义了同时__MAKE_KEYWORD_ENUM__被取消定义，因此keywords.h文件内容此时变为：

[cpp]  view plain  copy
  1. KEYWORD(capability,  OPTION,  0, 0)  
  2. KEYWORD(chdir,       COMMAND, 1, do_chdir)  
  3. KEYWORD(chroot,      COMMAND, 1, do_chroot)  
  4. KEYWORD(class,       OPTION,  0, 0)  
  5. KEYWORD(class_start, COMMAND, 1, do_class_start)  
  6. KEYWORD(class_stop,  COMMAND, 1, do_class_stop)  
  7. KEYWORD(class_reset, COMMAND, 1, do_class_reset)  
  8. KEYWORD(console,     OPTION,  0, 0)  
  9. KEYWORD(critical,    OPTION,  0, 0)  
  10. KEYWORD(disabled,    OPTION,  0, 0)  
  11. KEYWORD(domainname,  COMMAND, 1, do_domainname)  
  12. KEYWORD(exec,        COMMAND, 1, do_exec)  
  13. KEYWORD(export,      COMMAND, 2, do_export)  
  14. KEYWORD(group,       OPTION,  0, 0)  
  15. KEYWORD(hostname,    COMMAND, 1, do_hostname)  
  16. KEYWORD(ifup,        COMMAND, 1, do_ifup)  
  17. KEYWORD(insmod,      COMMAND, 1, do_insmod)  
  18. KEYWORD(import,      SECTION, 1, 0)  
  19. KEYWORD(keycodes,    OPTION,  0, 0)  
  20. KEYWORD(mkdir,       COMMAND, 1, do_mkdir)  
  21. KEYWORD(mount_all,   COMMAND, 1, do_mount_all)  
  22. KEYWORD(mount,       COMMAND, 3, do_mount)  
  23. KEYWORD(on,          SECTION, 0, 0)  
  24. KEYWORD(oneshot,     OPTION,  0, 0)  
  25. KEYWORD(onrestart,   OPTION,  0, 0)  
  26. KEYWORD(restart,     COMMAND, 1, do_restart)  
  27. KEYWORD(restorecon,  COMMAND, 1, do_restorecon)  
  28. KEYWORD(rm,          COMMAND, 1, do_rm)  
  29. KEYWORD(rmdir,       COMMAND, 1, do_rmdir)  
  30. KEYWORD(seclabel,    OPTION,  0, 0)  
  31. KEYWORD(service,     SECTION, 0, 0)  
  32. KEYWORD(setcon,      COMMAND, 1, do_setcon)  
  33. KEYWORD(setenforce,  COMMAND, 1, do_setenforce)  
  34. KEYWORD(setenv,      OPTION,  2, 0)  
  35. KEYWORD(setkey,      COMMAND, 0, do_setkey)  
  36. KEYWORD(setprop,     COMMAND, 2, do_setprop)  
  37. KEYWORD(setrlimit,   COMMAND, 3, do_setrlimit)  
  38. KEYWORD(setsebool,   COMMAND, 1, do_setsebool)  
  39. KEYWORD(socket,      OPTION,  0, 0)  
  40. KEYWORD(start,       COMMAND, 1, do_start)  
  41. KEYWORD(stop,        COMMAND, 1, do_stop)  
  42. KEYWORD(trigger,     COMMAND, 1, do_trigger)  
  43. KEYWORD(symlink,     COMMAND, 1, do_symlink)  
  44. KEYWORD(sysclktz,    COMMAND, 1, do_sysclktz)  
  45. KEYWORD(user,        OPTION,  0, 0)  
  46. KEYWORD(wait,        COMMAND, 1, do_wait)  
  47. KEYWORD(write,       COMMAND, 2, do_write)  
  48. KEYWORD(copy,        COMMAND, 2, do_copy)  
  49. KEYWORD(chown,       COMMAND, 2, do_chown)  
  50. KEYWORD(chmod,       COMMAND, 2, do_chmod)  
  51. KEYWORD(loglevel,    COMMAND, 1, do_loglevel)  
  52. KEYWORD(load_persist_props,    COMMAND, 0, do_load_persist_props)  
  53. KEYWORD(pipe,        COMMAND, 2, do_pipe)  
  54. KEYWORD(ioprio,      OPTION,  0, 0)  

使用上述KEYWORD宏展开得到keyword_info数组内容如下：

[cpp]  view plain  copy
  1. [ K_capability      ] = { capability,   0,              1,  OPTION, },  
  2. [ K_class           ] = { class,        0,              1,  OPTION, },  
  3. [ K_console         ] = { console,      0,              1,  OPTION, },  
  4. [ K_critical        ] = { critical,     0,              1,  OPTION, },  
  5. [ K_group           ] = { group,        0,              1,  OPTION, },  
  6. [ K_disabled        ] = { disabled,     0,              1,  OPTION, },  
  7. [ K_keycodes        ] = { keycodes,     0,              1,  OPTION, },  
  8. [ K_oneshot         ] = { oneshot,      0,              1,  OPTION, },  
  9. [ K_onrestart       ] = { onrestart,    0,              1,  OPTION, },  
  10. [ K_socket          ] = { socket,       0,              1,  OPTION, },  
  11. [ K_setenv          ] = { setenv,       0,              3,  OPTION, },  
  12. [ K_ioprio          ] = { ioprio,       0,              1,  OPTION, },  
  13. [ K_user            ] = { user,         0,              1,  OPTION, },  
  14. [ K_seclabel        ] = { seclabel,     0,              1,  OPTION, },  
  15.   
  16. [ K_service         ] = { service,      0,              1, SECTION, },  
  17. [ K_on              ] = { on,           0,              1, SECTION, },  
  18. [ K_import          ] = { import,       0,              2, SECTION, },  
  19.   
  20. [ K_chdir           ] = { chdir,        do_chdir,       2, COMMAND, },  
  21. [ K_chroot          ] = { chroot,       do_chroot,      2, COMMAND, },  
  22. [ K_class_start     ] = { class_start,  do_class_start, 2, COMMAND, },  
  23. [ K_class_stop      ] = { class_stop,   do_class_stop,  2, COMMAND, },  
  24. [ K_class_reset     ] = { class_reset,  do_class_reset, 2, COMMAND, },  
  25. [ K_domainname      ] = { domainname,   do_domainname,  2, COMMAND, },  
  26. [ K_exec            ] = { exec,         do_exec,        2, COMMAND, },  
  27. [ K_export          ] = { export,       do_export,      3, COMMAND, },  
  28. [ K_hostname        ] = { hostname,     do_hostname,    2, COMMAND, },  
  29. [ K_ifup            ] = { ifup,         do_ifup,        2, COMMAND, },  
  30. [ K_insmod          ] = { insmod,       do_insmod,      3, COMMAND, },  
  31. [ K_mkdir           ] = { mkdir,        do_mkdir,       2, COMMAND, },  
  32. [ K_mount_all       ] = { mount_all,    do_mount_all,   2, COMMAND, },  
  33. [ K_mount           ] = { mount,        do_mount,       4, COMMAND, },  
  34. [ K_restart         ] = { restart,      do_restart,     2, COMMAND, },  
  35. [ K_restorecon      ] = { restorecon,   do_restorecon,  2, COMMAND, },  
  36. [ K_rm              ] = { rm,           do_rm,          2, COMMAND, }  
  37. [ K_rmdir           ] = { rmdir,        do_rmdir,       2, COMMAND, },  
  38. [ K_setcon          ] = { setcon,       do_setcon,      2, COMMAND, },  
  39. [ K_setenforce      ] = { setenforce,   do_setenforce,  2, COMMAND, },  
  40. [ K_setkey          ] = { setkey,       do_setkey,      1, COMMAND, },  
  41. [ K_setprop         ] = { setprop,      do_setprop,     3, COMMAND, },  
  42. [ K_setrlimit       ] = { setrlimit,    do_setrlimit,   4, COMMAND, },  
  43. [ K_setsebool       ] = { setsebool,    do_setsebool,   2, COMMAND, },  
  44. [ K_start           ] = { start,        do_start,       2, COMMAND, },  
  45. [ K_stop            ] = { stop,         do_stop,        2, COMMAND, },  
  46. [ K_trigger         ] = { trigger,      do_trigger,     2, COMMAND, },  
  47. [ K_symlink         ] = { symlink,      do_symlink,     2, COMMAND, },  
  48. [ K_sysclktz        ] = { sysclktz,     do_sysclktz,    2, COMMAND, },  
  49. [ K_wait            ] = { wait,         do_wait,        2, COMMAND, },  
  50. [ K_write           ] = { write,        do_write,       3, COMMAND, },  
  51. [ K_copy            ] = { copy,         do_copy,        3, COMMAND, },  
  52. [ K_chown           ] = { chown,        do_chown,       3, COMMAND, },  
  53. [ K_chmod           ] = { chmod,        do_chmod,       3, COMMAND, },  
  54. [ K_loglevel        ] = { loglevel,     do_loglevel,    2, COMMAND, },  
  55. [ K_load_persist_props] = { load_persist_props, do_load_persist_props,1, COMMAND, },  
  56. [ K_pipe            ] = { pipe,         do_pipe,        3, COMMAND, },  

了解了这些内容之后，我们开始分析init.rc文件的真正解析过程：

[cpp]  view plain  copy
  1. static void parse_config(const char *fn, char *s)  
  2. {  
  3.     struct parse_state state;  
  4.     struct listnode import_list;  
  5.     struct listnode *node;  
  6.     char *args[INIT_PARSER_MAXARGS];  
  7.     int nargs;  
  8.   
  9.     nargs = 0;  
  10.     state.filename = fn; //文件名称  
  11.     state.line = 0; //统计文件行数  
  12.     state.ptr = s; //文件内容  
  13.     state.nexttoken = 0;  
  14.     state.parse_line = parse_line_no_op; //解析函数指针  
  15.     //初始化import_list链表，该链表用于保存通过import关键字引入的其他.rc文件  
  16.     list_init(&import_list);  
  17.     state.priv = &import_list;  
  18.       
  19.     for (;;) {  
  20.     //next_token函数用于扫描init.rc中的token  
  21.         switch (next_token(&state)) {  
  22.     //文件结束EOF  
  23.         case T_EOF:  
  24.             state.parse_line(&state, 0, 0);  
  25.             goto parser_done;  
  26.     //新行NEWLINE  
  27.         case T_NEWLINE:  
  28.             state.line++;   
  29.             if (nargs) {  
  30.         //根据行头查找关键字类型  
  31.                 int kw = lookup_keyword(args[0]);  
  32.         //如果是SECTION类型，SECTION包括以关键字service，on，import开头的语句  
  33.                 if (kw_is(kw, SECTION)) {  
  34.             //解析该行，此时parse_line指向的回调函数为parse_line_no_op，该函数什么也不做  
  35.                     state.parse_line(&state, 0, 0);  
  36.             //解析该SECTION  
  37.                     parse_new_section(&state, kw, nargs, args);  
  38.         //如果不是SECTION类型，则调用parse_line指向的回调函数  
  39.                 } else {  
  40.                     state.parse_line(&state, nargs, args);  
  41.                 }  
  42.                 nargs = 0;  
  43.             }  
  44.             break;  
  45.         //文本TEXT  
  46.         case T_TEXT:  
  47.             if (nargs < INIT_PARSER_MAXARGS) {  
  48.                 args[nargs++] = state.text;  
  49.             }  
  50.             break;  
  51.         }  
  52.     }  
  53.   
  54. parser_done:  
  55.      //init.rc 文件解析结束后，解析通过import关键字导入的.rc文件  
  56.     list_for_each(node, &import_list) {  
  57.       //从import_list链表中循环取出导入的.rc文件路径  
  58.          struct import *import = node_to_item(node, struct import, list);  
  59.          int ret;  
  60.   
  61.          INFO("importing '%s'", import->filename);  
  62.          //读取并解析导入的.rc文件  
  63.          ret = init_parse_config_file(import->filename);  
  64.          if (ret)  
  65.              ERROR("could not import file '%s' from '%s'\n",import->filename, fn);  
  66.     }  
  67. }  
函数parse_config通过调用next_token函数来查找3个定义的token，当查找到T_NEWLINE  token时，使用lookup_keyword函数来判断关键字类型，如果属于SECTION类型，则调用parse_new_section函数进行解析，如果是其他类型，则调用parse_line指向的回调函数来解析。

在前面介绍了通过定义枚举来为每个命令分配类型，lookup_keyword函数通过比较命令名称来返回对应命令的类型，如下所示：

[cpp]  view plain  copy
  1. int lookup_keyword(const char *s)  
  2. {  
  3.     switch (*s++) {  
  4.     case 'c':  
  5.     if (!strcmp(s, "opy")) return K_copy;  
  6.         if (!strcmp(s, "apability")) return K_capability;  
  7.         if (!strcmp(s, "hdir")) return K_chdir;  
  8.         if (!strcmp(s, "hroot")) return K_chroot;  
  9.         if (!strcmp(s, "lass")) return K_class;  
  10.         if (!strcmp(s, "lass_start")) return K_class_start;  
  11.         if (!strcmp(s, "lass_stop")) return K_class_stop;  
  12.         if (!strcmp(s, "lass_reset")) return K_class_reset;  
  13.         if (!strcmp(s, "onsole")) return K_console;  
  14.         if (!strcmp(s, "hown")) return K_chown;  
  15.         if (!strcmp(s, "hmod")) return K_chmod;  
  16.         if (!strcmp(s, "ritical")) return K_critical;  
  17.         break;  
  18.     case 'd':  
  19.         if (!strcmp(s, "isabled")) return K_disabled;  
  20.         if (!strcmp(s, "omainname")) return K_domainname;  
  21.         break;  
  22.     case 'e':  
  23.         if (!strcmp(s, "xec")) return K_exec;  
  24.         if (!strcmp(s, "xport")) return K_export;  
  25.         break;  
  26.     case 'g':  
  27.         if (!strcmp(s, "roup")) return K_group;  
  28.         break;  
  29.     case 'h':  
  30.         if (!strcmp(s, "ostname")) return K_hostname;  
  31.         break;  
  32.     case 'i':  
  33.         if (!strcmp(s, "oprio")) return K_ioprio;  
  34.         if (!strcmp(s, "fup")) return K_ifup;  
  35.         if (!strcmp(s, "nsmod")) return K_insmod;  
  36.         if (!strcmp(s, "mport")) return K_import;  
  37.         break;  
  38.     case 'k':  
  39.         if (!strcmp(s, "eycodes")) return K_keycodes;  
  40.         break;  
  41.     case 'l':  
  42.         if (!strcmp(s, "oglevel")) return K_loglevel;  
  43.         if (!strcmp(s, "oad_persist_props")) return K_load_persist_props;  
  44.         break;  
  45.     case 'm':  
  46.         if (!strcmp(s, "kdir")) return K_mkdir;  
  47.         if (!strcmp(s, "ount_all")) return K_mount_all;  
  48.         if (!strcmp(s, "ount")) return K_mount;  
  49.         break;  
  50.     case 'o':  
  51.         if (!strcmp(s, "n")) return K_on;  
  52.         if (!strcmp(s, "neshot")) return K_oneshot;  
  53.         if (!strcmp(s, "nrestart")) return K_onrestart;  
  54.         break;  
  55.     case 'r':  
  56.         if (!strcmp(s, "estart")) return K_restart;  
  57.         if (!strcmp(s, "estorecon")) return K_restorecon;  
  58.         if (!strcmp(s, "mdir")) return K_rmdir;  
  59.         if (!strcmp(s, "m")) return K_rm;  
  60.         

你可能感兴趣的:(Android init 进程源码分析)

  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • 【Git】常见命令(仅笔记) 好想有猫猫 GitLinux学习笔记git笔记elasticsearchlinuxc++
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
  • 2.2.6 通知类控件 Toast、Menu 常思行
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）... weixin_39762838 mac备份android手机通讯录导入iphone
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • 5月23日能量阅读打卡 free森
    当我走在人生路上的时候，我只能往前因为身后是飞逝的光阴。如果我因为过去与未来而瞻前顾后我的道路与生命进程就会停下来我的生命就会成为恐惧的俘虏所以我不应该因为过去与未来而驻足即便我的道路上充满了坎坷，即便我的道路上充满了考验，可是坎坷与考验都不能成为我停下的理由！我要跟坎坷说对不起，我爱你！我要跟考验说请原谅，谢谢你！我要在人生路上勇往直前，面对坎坷与重重生命的考验，我要毅然高歌猛进去追求精彩的人生
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • python结束子进程_如何清除python中的子进程 weixin_39995943 python结束子进程
    我们使用python进程来管理长时间运行的python子进程。有时需要终止子进程。kill命令不会完全终止进程，只会使其失效。运行以下脚本将演示此行为。importsubprocessp=subprocess.Popen(['sleep','400'],stdout=subprocess.PIPE,shell=False)或者p=subprocess.Popen('sleep400',stdout
  • python获取子进程返回值_Python对进程Multiprocessing子进程返回值 weixin_39752157 python获取子进程返回值
    在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
  • 经纬恒润二面&三七互娱一面&元象二面 Redstone Monstrosity 面试前端
    1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
  • Python编程 - 初识面向对象 易辰君 Python核心编程python开发语言
    目录前言一、面向对象二、类和对象（一）类简介定义类（二）对象简介创建对象（三）总结三、实例属性和实例方法（一）实例属性创建的基本语法使用示例（二）实例方法定义实例方法的基本语法调用示例方法的示例（三）总结四、类中的self（一）基本概念（二）作用访问实例属性调用其他实例方法在构造函数中初始化对象（三）总结五、__init__方法（一）__init__方法的特点（二）基本语法（三）示例（四）总结前言
  • Android实现监听事件的方法 Amy木婉清
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
  • wandb一直上传 解决方案 行业边缘的摸鱼怪 bug解决方案服务器linux服务器
    问题描述运行带有wandb的代码时，虽然可以实现及时同步非常方便，但当设置错参数或其他原因不得不使用ctrl+C停止运行时，总会出现wandb一直上传个不停的现象，给在同一终端重新运行新的代码造成困难。解决方案运行以下代码把wandb的进程直接杀死。psaux|grepwandb|grep-vgrep|awk'{print$2}'|xargskill-9参考链接[CLI]:Ctrl+Ctokill
  • TC27x启动过程（2）-TC277 赞哥哥s TC277学习笔记gnu单片机
    接上文，继续学习TC277的启动过程。分析启动函数有关用的寄存器说明，参考文章TC27x寄存器学习目录TC27x寄存器学习start函数分析isync汇编指令（同步指令）dsync汇编指令（同步数据），1清除endinit2设置中断堆栈3启用对系统全局寄存器的写访问4初始化SDA基指针5关闭对系统全局寄存器的写访问6关闭看门狗，恢复Endinit位7初始化CSA8初始化ram,拷贝rom数据到ra
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • 高级UI<第二十四篇>：Android中用到的矩阵常识 NoBugException
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
  • RK3229_Android9.0_Box 4G模块EC200A调试 suifen_ 网络
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
  • JVM源码分析之堆外内存完全解读 HeapDump性能社区
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
  • swing窗体打jar包后找不到图片的问题 zoyation javajarswingclassloaderimageeclipsejava
    今天打jar包遇到一个怪问题:打成jar包后双击运行没反应cmd运行有反应但出现下列问题Causedby:java.lang.ExceptionInInitializerErroratcom.zou.ui.MyDialog.init(MyDialog.java:92)atcom.zou.ui.MyDialog.(MyDialog.java:45)atcom.zou.ui.LoginDialog.(
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作 铭空间 kt文件和java文件
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
  • 史上最全git命令,git回滚,git命令大全 騒周 其他git
    git命令大全一、Git整体理解二、由暂存区本地仓库三、由本地仓->远程仓库四、冲突处理五、Git分支操作六、bug的分支七、feature分支八、暂存的使用九、远程仓的操作十、标签的使用十一、Git配置全局信息十二、Linux的一些简单操作和一些符号的解释十三、符号解释十四、显示安装详细信息十五、gitconfig十六、Gitclone十七、Gitinit十八、gitstatus十九、gitre
  • 【显示 后台运行 & 的命令】 晨春计 debuglinux服务器运维
    目录背景步骤详解示例背景当你在Linuxshell中使用&符号将一个命令放到后台运行时，你可以使用jobs命令来查看这些后台进程的状态。但是，jobs命令并不会直接显示进程的PID（进程ID）。它会显示一个作业列表，其中包括每个作业的状态和一个作业标识符（通常是百分号%后面跟着一个数字），但不会直接显示PID。获取后台进程的PID步骤：1、使用jobs命令查看后台作业。2、使用ps命令配合grep
  • Android shell 常用 debug 命令 晨春计 Audiodebugandroidlinux
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
  • tcp线程进程多并发 @莫福瑞 算法
    tcp线程多并发#include#defineSERPORT8888#defineSERIP"192.168.0.118"#defineBACKLOG20typedefstruct{intnewfd;structsockaddr_incin;}BMH;void*fun1(void*sss){intnewfd=accept((BMH*)sss)->newfd;structsockaddr_incin
  • linux下好用的任务管理器htop WittXie Linuxlinux服务器运维
    给大家推荐个好用的任务管理器htop，简直好用的不得了。完虐top。不解释了，看文章！！！在Linux系统中，top命令用来显示系统中正在运行的进程的实时状态，它显示了一些非常有用的信息，比如CPU利用情况、内存消耗情况，以及每个进程情况等。但是，你知道吗？还有另外一个命令行工具'htop'，它与传统的top命令功能一样，但它有更加强大的功能及能显示更多的信息。这篇文章，我们会用实例来讨论这个'h
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • Hadoop(一) 朱辉辉33 hadooplinux
    今天在诺基亚第一天开始培训大数据，因为之前没接触过Linux，所以这次一起学了，任务量还是蛮大的。 首先下载安装了Xshell软件，然后公司给了账号密码连接上了河南郑州那边的服务器，接下来开始按照给的资料学习，全英文的，头也不讲解，说锻炼我们的学习能力，然后就开始跌跌撞撞的自学。这里写部分已经运行成功的代码吧.    在hdfs下，运行hadoop fs -mkdir /u
  • maven An error occurred while filtering resources blackproof maven报错
    转：http://stackoverflow.com/questions/18145774/eclipse-an-error-occurred-while-filtering-resources   maven报错： maven An error occurred while filtering resources   Maven -> Update Proje
  • jdk常用故障排查命令 daysinsun jvm
    linux下常见定位命令： 1、jps      输出Java进程       -q       只输出进程ID的名称，省略主类的名称；       -m      输出进程启动时传递给main函数的参数；     &nb
  • java 位移运算与乘法运算 周凡杨 java位移运算乘法
      对于 JAVA 编程中，适当的采用位移运算，会减少代码的运行时间，提高项目的运行效率。这个可以从一道面试题说起：     问题： 用最有效率的方法算出2 乘以8 等於几?” 答案：2 << 3 由此就引发了我的思考，为什么位移运算会比乘法运算更快呢？其实简单的想想，计算机的内存是用由 0 和 1 组成的二
  • java中的枚举(enmu) g21121 java
    从jdk1.5开始，java增加了enum(枚举)这个类型，但是大家在平时运用中还是比较少用到枚举的，而且很多人和我一样对枚举一知半解，下面就跟大家一起学习下enmu枚举。先看一个最简单的枚举类型，一个返回类型的枚举： public enum ResultType { /** * 成功 */ SUCCESS, /** * 失败 */ FAIL,
  • MQ初级学习 510888780 activemq
    1.下载ActiveMQ 去官方网站下载：http://activemq.apache.org/ 2.运行ActiveMQ 解压缩apache-activemq-5.9.0-bin.zip到C盘，然后双击apache-activemq-5.9.0-\bin\activemq-admin.bat运行ActiveMQ程序。 启动ActiveMQ以后，登陆：http://localhos
  • Spring_Transactional_Propagation 布衣凌宇 springtransactional
    //事务传播属性 @Transactional(propagation=Propagation.REQUIRED)//如果有事务，那么加入事务，没有的话新创建一个 @Transactional(propagation=Propagation.NOT_SUPPORTED)//这个方法不开启事务 @Transactional(propagation=Propagation.REQUIREDS_N
  • 我的spring学习笔记12-idref与ref的区别 aijuans spring
    idref用来将容器内其他bean的id传给<constructor-arg>/<property>元素，同时提供错误验证功能。例如： <bean id ="theTargetBean" class="..." /> <bean id ="theClientBean" class=&quo
  • Jqplot之折线图 antlove jsjqueryWebtimeseriesjqplot
    timeseriesChart.html <script type="text/javascript" src="jslib/jquery.min.js"></script> <script type="text/javascript" src="jslib/excanvas.min.js&
  • JDBC中事务处理应用 百合不是茶 javaJDBC编程事务控制语句
      解释事务的概念; 事务控制是sql语句中的核心之一;事务控制的作用就是保证数据的正常执行与异常之后可以恢复   事务常用命令:             Commit提交         
  • [转]ConcurrentHashMap Collections.synchronizedMap和Hashtable讨论 bijian1013 java多线程线程安全HashMap
    在Java类库中出现的第一个关联的集合类是Hashtable，它是JDK1.0的一部分。 Hashtable提供了一种易于使用的、线程安全的、关联的map功能，这当然也是方便的。然而，线程安全性是凭代价换来的――Hashtable的所有方法都是同步的。此时，无竞争的同步会导致可观的性能代价。Hashtable的后继者HashMap是作为JDK1.2中的集合框架的一部分出现的，它通过提供一个不同步的
  • ng-if与ng-show、ng-hide指令的区别和注意事项 bijian1013 JavaScriptAngularJS
            angularJS中的ng-show、ng-hide、ng-if指令都可以用来控制dom元素的显示或隐藏。ng-show和ng-hide根据所给表达式的值来显示或隐藏HTML元素。当赋值给ng-show指令的值为false时元素会被隐藏，值为true时元素会显示。ng-hide功能类似，使用方式相反。元素的显示或
  • 【持久化框架MyBatis3七】MyBatis3定义typeHandler bit1129 TypeHandler
    什么是typeHandler? typeHandler用于将某个类型的数据映射到表的某一列上，以完成MyBatis列跟某个属性的映射   内置typeHandler MyBatis内置了很多typeHandler，这写typeHandler通过org.apache.ibatis.type.TypeHandlerRegistry进行注册，比如对于日期型数据的typeHandler，
  • 上传下载文件rz,sz命令 bitcarter linux命令rz
    刚开始使用rz上传和sz下载命令： 因为我们是通过secureCRT终端工具进行使用的所以会有上传下载这样的需求： 我遇到的问题： sz下载A文件10M左右，没有问题 但是将这个文件A再传到另一天服务器上时就出现传不上去，甚至出现乱码，死掉现象，具体问题 解决方法： 上传命令改为;rz -ybe 下载命令改为：sz -be filename 如果还是有问题： 那就是文
  • 通过ngx-lua来统计nginx上的虚拟主机性能数据 ronin47 ngx-lua　统计 解禁ip
    介绍 以前我们为nginx做统计,都是通过对日志的分析来完成.比较麻烦,现在基于ngx_lua插件,开发了实时统计站点状态的脚本,解放生产力.项目主页: https://github.com/skyeydemon/ngx-lua-stats 功能 支持分不同虚拟主机统计, 同一个虚拟主机下可以分不同的location统计. 可以统计与query-times request-time
  • java-68-把数组排成最小的数。一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的。例如输入数组{32, 321}，则输出32132 bylijinnan java
    import java.util.Arrays; import java.util.Comparator; public class MinNumFromIntArray { /** * Q68输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的一个。 * 例如输入数组{32, 321}，则输出这两个能排成的最小数字32132。请给出解决问题
  • Oracle基本操作 ccii Oracle SQL总结Oracle SQL语法Oracle基本操作Oracle SQL
    一、表操作 1. 常用数据类型 NUMBER(p,s)：可变长度的数字。p表示整数加小数的最大位数，s为最大小数位数。支持最大精度为38位 NVARCHAR2(size)：变长字符串，最大长度为4000字节（以字符数为单位） VARCHAR2(size)：变长字符串，最大长度为4000字节（以字节数为单位） CHAR(size)：定长字符串，最大长度为2000字节，最小为1字节，默认
  • [强人工智能]实现强人工智能的路线图 comsci 人工智能
        1：创建一个用于记录拓扑网络连接的矩阵数据表      2:自动构造或者人工复制一个包含10万个连接(1000*1000)的流程图      3：将这个流程图导入到矩阵数据表中      4：在矩阵的每个有意义的节点中嵌入一段简单的
  • 给Tomcat，Apache配置gzip压缩(HTTP压缩)功能 cwqcwqmax9 apache
    背景： HTTP 压缩可以大大提高浏览网站的速度，它的原理是，在客户端请求网页后，从服务器端将网页文件压缩，再下载到客户端，由客户端的浏览器负责解压缩并浏览。相对于普通的浏览过程HTML ,CSS,Javascript , Text ，它可以节省40%左右的流量。更为重要的是，它可以对动态生成的，包括CGI、PHP , JSP , ASP , Servlet,SHTML等输出的网页也能进行压缩，
  • SpringMVC and Struts2 dashuaifu struts2springMVC
    SpringMVC VS Struts2 1: spring3开发效率高于struts 2: spring3 mvc可以认为已经100%零配置 3: struts2是类级别的拦截， 一个类对应一个request上下文， springmvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应 所以说从架构本身上 spring3 mvc就容易实现r
  • windows常用命令行命令 dcj3sjt126com windowscmdcommand
    在windows系统中，点击开始－运行，可以直接输入命令行，快速打开一些原本需要多次点击图标才能打开的界面，如常用的输入cmd打开dos命令行，输入taskmgr打开任务管理器。此处列出了网上搜集到的一些常用命令。winver 检查windows版本 wmimgmt.msc 打开windows管理体系结构(wmi) wupdmgr windows更新程序 wscrip
  • 再看知名应用背后的第三方开源项目 dcj3sjt126com ios
    知名应用程序的设计和技术一直都是开发者需要学习的，同样这些应用所使用的开源框架也是不可忽视的一部分。此前《 iOS第三方开源库的吐槽和备忘》中作者ibireme列举了国内多款知名应用所使用的开源框架，并对其中一些框架进行了分析，同样国外开发者 @iOSCowboy也在博客中给我们列出了国外多款知名应用使用的开源框架。另外txx's blog中详细介绍了 Facebook Paper使用的第三
  • Objective-c单例模式的正确写法 jsntghf 单例iosiPhone
    一般情况下，可能我们写的单例模式是这样的： #import <Foundation/Foundation.h> @interface Downloader : NSObject + (instancetype)sharedDownloader; @end #import "Downloader.h" @implementation
  • jquery easyui datagrid 加载成功，选中某一行 hae jqueryeasyuidatagrid数据加载
    1.首先你需要设置datagrid的onLoadSuccess $( '#dg' ).datagrid({onLoadSuccess :  function (data){      $( '#dg' ).datagrid( 'selectRow' ,3); }});   2.onL
  • jQuery用户数字打分评价效果 ini JavaScripthtmljqueryWebcss
    效果体验：http://hovertree.com/texiao/jquery/5.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>jQuery用户数字打分评分代码 - HoverTree</
  • mybatis的paramType kerryg DAOsql
    MyBatis传多个参数： 1、采用#{0},#{1}获得参数：    Dao层函数方法：     public User selectUser(String name,String area); 对应的Mapper.xml    <select id="selectUser" result
  • centos 7安装mysql5.5 MrLee23 centos
    首先centos7 已经不支持mysql，因为收费了你懂得，所以内部集成了mariadb，而安装mysql的话会和mariadb的文件冲突，所以需要先卸载掉mariadb，以下为卸载mariadb，安装mysql的步骤。   #列出所有被安装的rpm package rpm -qa | grep mariadb   #卸载 rpm -e mariadb-libs-5.
  • 利用thrift来实现消息群发 qifeifei thrift
               Thrift项目一般用来做内部项目接偶用的，还有能跨不同语言的功能，非常方便，一般前端系统和后台server线上都是3个节点，然后前端通过获取client来访问后台server，那么如果是多太server，就是有一个负载均衡的方法，然后最后访问其中一个节点。那么换个思路，能不能发送给所有节点的server呢，如果能就
  • 实现一个sizeof获取Java对象大小 teasp javaHotSpot内存对象大小sizeof
       由于Java的设计者不想让程序员管理和了解内存的使用，我们想要知道一个对象在内存中的大小变得比较困难了。本文提供了可以获取对象的大小的方法，但是由于各个虚拟机在内存使用上可能存在不同，因此该方法不能在各虚拟机上都适用，而是仅在hotspot 32位虚拟机上，或者其它内存管理方式与hotspot 32位虚拟机相同的虚拟机上 适用。     
  • SVN错误及处理 xiangqian0505 SVN提交文件时服务器强行关闭
    在SVN服务控制台打开资源库“SVN无法读取current” ---摘自网络 写道 SVN无法读取current修复方法 Can't read file : End of file found 文件：repository/db/txn_current、repository/db/current   其中current记录当前最新版本号，txn_current记录版本库中版本
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他