Android研究-linux内核启动到android系统[zz]
2012-05-21 14:49
288 查看
很多人阅读代码，总喜欢从头开始，这样觉得很安全，有依靠，无论如何总是能知道“头”，有头就能找到任何需要的部分。
Android生在linux内核基础上，linux内核启动的最后一步，一定是启动的android的进程，下面看收集到的文章。
1. linux内核启动过程
引用地址：http://blog.csdn.net/ayangke/article/details/6888699
内核版本：2.6.22 为什么要采用这样一个较低的版本进行移植了，因为韦东山大牛说了，低版本的才能学到东西，越是高版本需要移植时做的工作量越少，学的东西越少。
内核启动分为三个阶段，第一是运行head.S文件和head-common.S，第三个阶段是允许第二是运行main.c文件
对于ARM的处理器，内核第一个启动的文件是arc/arm/kernel下面的head.S文件。当然arc/arm/boot/compress下面 也有这个文件，这个文件和上面的文件略有不同，当要生成压缩的内核时zImage时，启动的是后者，后者与前者不同的时，它前面的代码是做自解压的，后面 的代码都相同。我们这里这分析arc/arm/kernel下面的head.S文件。当head.S所作的工作完成后它会跳到init/目录下跌的 main.c的start_kernel函数开始执行。
第一阶段：
首先截取部分head.S文件
ENTRY(stext)
msr cpsr_c,#PSR_F_BIT | PSR_I_BIT | SVC_MODE @ ensure svc mode
@ andirqs disabled
mrc p15,0, r9, c0, c0 @ get processor id
bl __lookup_processor_type @ r5=procinfo r9=cpuid
movs r10,r5 @ invalidprocessor (r5=0)?
beq __error_p @ yes, error 'p'
bl __lookup_machine_type @ r5=machinfo
movs r8,r5 @ invalidmachine (r5=0)?
beq __error_a @ yes, error 'a'
bl __create_page_tables
/*
*The following calls CPU specific code in a position independent
*manner. See arch/arm/mm/proc-*.S fordetails. r10 = base of
*xxx_proc_info structure selected by __lookup_machine_type
*above. On return, the CPU will be readyfor the MMU to be
*turned on, and r0 will hold the CPU control register value.
*/
ldr r13,__switch_data @ address to jump toafter
@ mmuhas been enabled
adr lr,__enable_mmu @ return (PIC)address
第一步,执行的是__lookup_processor_type，这个函数是检查处理器型号，它读取你的电路板的CPU型号与内核支持的处理器进行比较看是否能够处理。这个我们不关心它的具体实现过程，因为现在主流处理器内核都提供了支持。
第二步，执行的是__lookup_machine_type，这个函数是来检查机器型号的，它会读取你bootloader传进来的机器ID和他能够处 理的机器ID进行比较看是否能够处理。内核的ID号定义在arc/arm/tool/mach_types文件中MACH_TYPE_xxxx宏定义。内 核究竟就如何检查是否是它支持的机器的呢？实际上每个机器都会在/arc/arm/mach-xxxx/smdk-xxxx.c文件中有个描述特定机器的 数据结构，如下
[html] view plaincopy
MACHINE_START(S3C2440,"SMDK2440")
/* Maintainer: Ben Dooks<ben@fluff.org> */
.phys_io =S3C2410_PA_UART,
.io_pg_offst = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
.boot_params = S3C2410_SDRAM_PA + 0x100,
.init_irq =s3c24xx_init_irq,
.map_io =smdk2440_map_io,
.init_machine = smdk2440_machine_init,
.timer =&s3c24xx_timer,
MACHINE_END
MACHINE_START和 MACHINE_END实际上被展开成一个结构体
[html] view plaincopy
#defineMACHINE_START(_type,_name) \
staticconst struct machine_desc __mach_desc_##_type \
__used \
__attribute__((__section__(".arch.info.init")))= { \
.nr =MACH_TYPE_##_type, \
.name =_name,
#defineMACHINE_END \
};
于是上面的数据结构就被展开为
[html] view plaincopy
staticconst struct machine_desc __mach_desc_S3C2440 \
__used \
__attribute__((__section__(".arch.info.init")))= { \
.nr =MACH_TYPE_S3C2440, \
.name =”SMDK2440”,};
.phys_io = S3C2410_PA_UART,
.io_pg_offst = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
.boot_params = S3C2410_SDRAM_PA + 0x100,
.init_irq =s3c24xx_init_irq,
.map_io =smdk2440_map_io,
.init_machine = smdk2440_machine_init,
.timer =&s3c24xx_timer,
}
每个机器都会有一个machine_desc__mach_desc结构，内核通过检查每个machine_desc__mach_desc的nr
号和bootloader传上来的ID进行比较，如果相同，内核就认为支持该机器，而且内核在后面的工作中会调用该机器的
machine_desc__mach_desc_结构中的方法进行一些初始化工作。
第三步，创建一级页表。
第四步，在R13中保存__switch_data 这个函数的地址，在第四步使能mmu完成后会跳到该函数执行。
第五步，执行的是__enable_mmu，它是使能MMU，这个函数调用了__turn_mmu_on函数，让后在_turn_mmu_on在最
后将第三步赋给R13的值传给了PC指针 （mov pc, r13），于是内核开始跳到__switch_data这个函数开始执行。
我们再来看arch/arm/kenel/head-common.S这个文件中的__switch_data函数
[html] view plaincopy
__switch_data:
.long __mmap_switched
.long __data_loc @ r4
.long __data_start @ r5
.long __bss_start @ r6
.long _end @ r7
.long processor_id @ r4
.long __machine_arch_type @ r5
.long cr_alignment @ r6
.long init_thread_union+ THREAD_START_SP @ sp
/*
* The following fragment of code is executedwith the MMU on in MMU mode,
* and uses absolute addresses; this is notposition independent.
*
* r0 =cp#15 control register
* r1 = machine ID
* r9 = processor ID
*/
.type __mmap_switched,%function
__mmap_switched:
adr r3,__switch_data + 4
ldmia r3!,{r4, r5, r6, r7}
cmp r4,r5 @ Copy datasegment if needed
1: cmpne r5,r6
ldrne fp,[r4], #4
strne fp,[r5], #4
bne 1b
mov fp,#0 @ Clear BSS(and zero fp)
1: cmp r6,r7
strcc fp,[r6],#4
bcc 1b
ldmia r3,{r4, r5, r6, sp}
str r9, [r4] @ Save processor ID
str r1, [r5] @ Save machine type
bic r4,r0, #CR_A @ Clear 'A' bit
stmia r6,{r0, r4} @ Save controlregister values
b start_kernel
这个函数做的工作是，复制数据段清楚BBS段，设置堆在指针，然后保存处理器内核和机器内核等工作，最后跳到start_kernel函数。于是内核开始执行第二阶段。
第二阶段：
我们再来看init/目录下的main.c的start_kernel函数，这里我只截图了部分。
[html] view plaincopy
asmlinkage void __init start_kernel(void)
{
…………………….
……………………..
printk(KERN_NOTICE);
printk(linux_banner);
setup_arch(&command_line);
setup_command_line(command_line);
parse_early_param();
parse_args("Booting kernel",static_command_line, __start___param,
__stop___param - __start___param,
&unknown_bootoption);
……………………
…………………………
init_IRQ();
pidhash_init();
init_timers();
hrtimers_init();
softirq_init();
timekeeping_init();
time_init();
profile_init();
…………………………
……………………………
console_init();
………………………………
………………………………
rest_init();
}
从上面可以看出start_kernel首先是打印内核信息，然后对bootloader传进来的一些参数进行处理，再接着执行各种各样的初始化，在这其中会初始化控制台。最后会调用rest_init();
我们再来看rest_init()函数
[html] view plaincopy
static void noinline __init_refok rest_init(void)
__releases(kernel_lock)
{
int pid;
kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
............
}
他启动了kernel_init这个函数，再来看kerne_init函数
[html] view plaincopy
static int __init kernel_init(void * unused)
{
..............................
if (!ramdisk_execute_command)
ramdisk_execute_command = "/init";
if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
ramdisk_execute_command = NULL;
prepare_namespace();
}
/*
* Ok, we have completed the initial bootup, and
* we're essentially up and running. Get rid of the
* initmem segments and start the user-mode stuff..
*/
init_post();
return 0;
}
kernel_init先调用了prepare_namespace();然后调用了init_post函数
[html] view plaincopy
void __init prepare_namespace(void)
{
..........................
mount_root();
.....................
}
可以看出prepare_namespace调用了mount_root挂接根文件系统。接着kernel_init再执行init_post
[html] view plaincopy
static int noinline init_post(void)
{
.......................................
/*打开dev/console控制台，并设置为标准输入、输出*/
if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
printk(KERN_WARNING "Warning: unable to open an initial console.\n");
(void) sys_dup(0);
(void) sys_dup(0);
if (ramdisk_execute_command) {
run_init_process(ramdisk_execute_command);
printk(KERN_WARNING "Failed to execute %s\n",
ramdisk_execute_command);
}
/*
* We try each of these until one succeeds.
*
* The Bourne shell can be used instead of init if we are
* trying to recover a really broken machine.
*/
//如果bootloader指定了init参数，则启动init参数指定的进程
if (execute_command) {
run_init_process(execute_command);
printk(KERN_WARNING "Failed to execute %s. Attempting "
"defaults...\n", execute_command);
}
//如果没有指定init参数，则分别带sbin、etc、bin目录下启动init进程
run_init_process("/sbin/init");
run_init_process("/etc/init");
run_init_process("/bin/init");
run_init_process("/bin/sh");
panic("No init found. Try passing init= option to kernel.");
}
注意上面的run_init_process的会等待init进程返回才往后面执行，所有它一旦找到一个init可执行的文件它将一去不复返。
综上，内核启动的过程大致为以下几步：
1.检查CPU和机器类型
2.进行堆栈、MMU等其他程序运行关键的东西进行初始化
3.打印内核信息
4.执行各种模块的初始化
5.挂接根文件系统
6.启动第一个init进程
2. android启动
引用地址：http://monner.iteye.com/blog/728334
设备管理
解析启动脚本
执行启动脚本中的基本功能
执行启动脚本中的各种功能
Commands：命令
Actions：动作
Triggers:触发条件
Services：服务
Options：选项
Propertise：属性
Commands是一些基本的操作，例如：
这些命令在init可执行程序中被解析，然后调用相关的函数来实现。 Actions(动作)表示一系列的命令，通常在Triggers（触发条件）中调用，动作和触发条件例如：
init表示一个触发条件，这个触发事件发生后，进行设置环境变量和建立目录的操作称为一个“动作” Services（服务）通常表示启动一个可执行程序，Options（选项）是服务的附加内容，用于配合服务使用。
vold和bootsound分别是两个服务的名称，/system/bin /vold和/system /bin/playmp3分别是他们所对应的可执行程序。socket、user、group、oneshot就是配合服务使用的选项。 Properties（属性）是系统中使用的一些值，可以进行设置和读取。
setprop 用于设置属性，on property可以用于判断属性，这里的属性在整个Android系统运行中都是一致的。
综上如果想要修改启动过程只需要修改init.c或者init.rc里的内容即可.
3. 总结：
(1)内核的init_post类似接口，会去文件系统中启动init类似的用户进程
(2)android实现了这样的init，这就是android框架启动的地方，当然linux内核也可说是android系统的一部分
(3)init进程无限分裂，启动框架，演变成android系统
(4)android的init进程的代码在system/core/init/init.c中，从main函数开始.
本文完~
Android生在linux内核基础上，linux内核启动的最后一步，一定是启动的android的进程，下面看收集到的文章。
1. linux内核启动过程
引用地址：http://blog.csdn.net/ayangke/article/details/6888699
内核版本：2.6.22 为什么要采用这样一个较低的版本进行移植了，因为韦东山大牛说了，低版本的才能学到东西，越是高版本需要移植时做的工作量越少，学的东西越少。
内核启动分为三个阶段，第一是运行head.S文件和head-common.S，第三个阶段是允许第二是运行main.c文件
对于ARM的处理器，内核第一个启动的文件是arc/arm/kernel下面的head.S文件。当然arc/arm/boot/compress下面 也有这个文件，这个文件和上面的文件略有不同，当要生成压缩的内核时zImage时，启动的是后者，后者与前者不同的时，它前面的代码是做自解压的，后面 的代码都相同。我们这里这分析arc/arm/kernel下面的head.S文件。当head.S所作的工作完成后它会跳到init/目录下跌的 main.c的start_kernel函数开始执行。
第一阶段：
首先截取部分head.S文件
ENTRY(stext)
msr cpsr_c,#PSR_F_BIT | PSR_I_BIT | SVC_MODE @ ensure svc mode
@ andirqs disabled
mrc p15,0, r9, c0, c0 @ get processor id
bl __lookup_processor_type @ r5=procinfo r9=cpuid
movs r10,r5 @ invalidprocessor (r5=0)?
beq __error_p @ yes, error 'p'
bl __lookup_machine_type @ r5=machinfo
movs r8,r5 @ invalidmachine (r5=0)?
beq __error_a @ yes, error 'a'
bl __create_page_tables
/*
*The following calls CPU specific code in a position independent
*manner. See arch/arm/mm/proc-*.S fordetails. r10 = base of
*xxx_proc_info structure selected by __lookup_machine_type
*above. On return, the CPU will be readyfor the MMU to be
*turned on, and r0 will hold the CPU control register value.
*/
ldr r13,__switch_data @ address to jump toafter
@ mmuhas been enabled
adr lr,__enable_mmu @ return (PIC)address
第一步,执行的是__lookup_processor_type，这个函数是检查处理器型号，它读取你的电路板的CPU型号与内核支持的处理器进行比较看是否能够处理。这个我们不关心它的具体实现过程，因为现在主流处理器内核都提供了支持。
第二步，执行的是__lookup_machine_type，这个函数是来检查机器型号的，它会读取你bootloader传进来的机器ID和他能够处 理的机器ID进行比较看是否能够处理。内核的ID号定义在arc/arm/tool/mach_types文件中MACH_TYPE_xxxx宏定义。内 核究竟就如何检查是否是它支持的机器的呢？实际上每个机器都会在/arc/arm/mach-xxxx/smdk-xxxx.c文件中有个描述特定机器的 数据结构，如下
[html] view plaincopy
MACHINE_START(S3C2440,"SMDK2440")
/* Maintainer: Ben Dooks<ben@fluff.org> */
.phys_io =S3C2410_PA_UART,
.io_pg_offst = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
.boot_params = S3C2410_SDRAM_PA + 0x100,
.init_irq =s3c24xx_init_irq,
.map_io =smdk2440_map_io,
.init_machine = smdk2440_machine_init,
.timer =&s3c24xx_timer,
MACHINE_END
MACHINE_START和 MACHINE_END实际上被展开成一个结构体
[html] view plaincopy
#defineMACHINE_START(_type,_name) \
staticconst struct machine_desc __mach_desc_##_type \
__used \
__attribute__((__section__(".arch.info.init")))= { \
.nr =MACH_TYPE_##_type, \
.name =_name,
#defineMACHINE_END \
};
于是上面的数据结构就被展开为
[html] view plaincopy
staticconst struct machine_desc __mach_desc_S3C2440 \
__used \
__attribute__((__section__(".arch.info.init")))= { \
.nr =MACH_TYPE_S3C2440, \
.name =”SMDK2440”,};
.phys_io = S3C2410_PA_UART,
.io_pg_offst = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
.boot_params = S3C2410_SDRAM_PA + 0x100,
.init_irq =s3c24xx_init_irq,
.map_io =smdk2440_map_io,
.init_machine = smdk2440_machine_init,
.timer =&s3c24xx_timer,
}
每个机器都会有一个machine_desc__mach_desc结构，内核通过检查每个machine_desc__mach_desc的nr
号和bootloader传上来的ID进行比较，如果相同，内核就认为支持该机器，而且内核在后面的工作中会调用该机器的
machine_desc__mach_desc_结构中的方法进行一些初始化工作。
第三步，创建一级页表。
第四步，在R13中保存__switch_data 这个函数的地址，在第四步使能mmu完成后会跳到该函数执行。
第五步，执行的是__enable_mmu，它是使能MMU，这个函数调用了__turn_mmu_on函数，让后在_turn_mmu_on在最
后将第三步赋给R13的值传给了PC指针 （mov pc, r13），于是内核开始跳到__switch_data这个函数开始执行。
我们再来看arch/arm/kenel/head-common.S这个文件中的__switch_data函数
[html] view plaincopy
__switch_data:
.long __mmap_switched
.long __data_loc @ r4
.long __data_start @ r5
.long __bss_start @ r6
.long _end @ r7
.long processor_id @ r4
.long __machine_arch_type @ r5
.long cr_alignment @ r6
.long init_thread_union+ THREAD_START_SP @ sp
/*
* The following fragment of code is executedwith the MMU on in MMU mode,
* and uses absolute addresses; this is notposition independent.
*
* r0 =cp#15 control register
* r1 = machine ID
* r9 = processor ID
*/
.type __mmap_switched,%function
__mmap_switched:
adr r3,__switch_data + 4
ldmia r3!,{r4, r5, r6, r7}
cmp r4,r5 @ Copy datasegment if needed
1: cmpne r5,r6
ldrne fp,[r4], #4
strne fp,[r5], #4
bne 1b
mov fp,#0 @ Clear BSS(and zero fp)
1: cmp r6,r7
strcc fp,[r6],#4
bcc 1b
ldmia r3,{r4, r5, r6, sp}
str r9, [r4] @ Save processor ID
str r1, [r5] @ Save machine type
bic r4,r0, #CR_A @ Clear 'A' bit
stmia r6,{r0, r4} @ Save controlregister values
b start_kernel
这个函数做的工作是，复制数据段清楚BBS段，设置堆在指针，然后保存处理器内核和机器内核等工作，最后跳到start_kernel函数。于是内核开始执行第二阶段。
第二阶段：
我们再来看init/目录下的main.c的start_kernel函数，这里我只截图了部分。
[html] view plaincopy
asmlinkage void __init start_kernel(void)
{
…………………….
……………………..
printk(KERN_NOTICE);
printk(linux_banner);
setup_arch(&command_line);
setup_command_line(command_line);
parse_early_param();
parse_args("Booting kernel",static_command_line, __start___param,
__stop___param - __start___param,
&unknown_bootoption);
……………………
…………………………
init_IRQ();
pidhash_init();
init_timers();
hrtimers_init();
softirq_init();
timekeeping_init();
time_init();
profile_init();
…………………………
……………………………
console_init();
………………………………
………………………………
rest_init();
}
从上面可以看出start_kernel首先是打印内核信息，然后对bootloader传进来的一些参数进行处理，再接着执行各种各样的初始化，在这其中会初始化控制台。最后会调用rest_init();
我们再来看rest_init()函数
[html] view plaincopy
static void noinline __init_refok rest_init(void)
__releases(kernel_lock)
{
int pid;
kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
............
}
他启动了kernel_init这个函数，再来看kerne_init函数
[html] view plaincopy
static int __init kernel_init(void * unused)
{
..............................
if (!ramdisk_execute_command)
ramdisk_execute_command = "/init";
if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
ramdisk_execute_command = NULL;
prepare_namespace();
}
/*
* Ok, we have completed the initial bootup, and
* we're essentially up and running. Get rid of the
* initmem segments and start the user-mode stuff..
*/
init_post();
return 0;
}
kernel_init先调用了prepare_namespace();然后调用了init_post函数
[html] view plaincopy
void __init prepare_namespace(void)
{
..........................
mount_root();
.....................
}
可以看出prepare_namespace调用了mount_root挂接根文件系统。接着kernel_init再执行init_post
[html] view plaincopy
static int noinline init_post(void)
{
.......................................
/*打开dev/console控制台，并设置为标准输入、输出*/
if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
printk(KERN_WARNING "Warning: unable to open an initial console.\n");
(void) sys_dup(0);
(void) sys_dup(0);
if (ramdisk_execute_command) {
run_init_process(ramdisk_execute_command);
printk(KERN_WARNING "Failed to execute %s\n",
ramdisk_execute_command);
}
/*
* We try each of these until one succeeds.
*
* The Bourne shell can be used instead of init if we are
* trying to recover a really broken machine.
*/
//如果bootloader指定了init参数，则启动init参数指定的进程
if (execute_command) {
run_init_process(execute_command);
printk(KERN_WARNING "Failed to execute %s. Attempting "
"defaults...\n", execute_command);
}
//如果没有指定init参数，则分别带sbin、etc、bin目录下启动init进程
run_init_process("/sbin/init");
run_init_process("/etc/init");
run_init_process("/bin/init");
run_init_process("/bin/sh");
panic("No init found. Try passing init= option to kernel.");
}
注意上面的run_init_process的会等待init进程返回才往后面执行，所有它一旦找到一个init可执行的文件它将一去不复返。
综上，内核启动的过程大致为以下几步：
1.检查CPU和机器类型
2.进行堆栈、MMU等其他程序运行关键的东西进行初始化
3.打印内核信息
4.执行各种模块的初始化
5.挂接根文件系统
6.启动第一个init进程
2. android启动
引用地址：http://monner.iteye.com/blog/728334
Android 系统启动分析（转）
init进程是Android启动后系统执行的第一个名称为init的可执行程序。这个程序以一个守护进程的方式运行，它提供了以下功能：
设备管理
解析启动脚本
执行启动脚本中的基本功能
执行启动脚本中的各种功能
1、init可执行程序
init 可执行文件是系统运行的第一个用户空间程序，它以守护进程的方式运行。因此这个程序的init.c文件包含main函数的入口，基本分析如下：
int main(int argc,char**argv){
(省略若干。。。)
umask(0); /*对umask进行清零。*/
mkdir("/dev",0755);/*为rootfs建立必要的文件夹，并挂载适当的分区。 */
mkdir("/proc",0755);
mkdir("/sys",0755);
mount("tmpfs","/dev","tmpfs",0,"mode=0755");
mkdir("/dev/pts",0755);
mkdir("/dev/socket",0755);
mount("devpts","/dev/pts","devpts",0, NULL);
mount("proc","/proc","proc",0, NULL);
mount("sysfs","/sys","sysfs",0, NULL);
/*创建/dev/null和/dev/kmsg节点*/
open_devnull_stdio();
log_init();
/*解析/init.rc，将所有服务和操作信息加入链表。*/
INFO("reading config file\n");
parse_config_file("/init.rc");
/*获取内核命令行参数*/
qemu_init();
import_kernel_cmdline(0);
/*先从上一步获得的全局变量中获取信息硬件信息和版本号，如果没有则从/proc/cpuinfo中提取，
*并保存到全局变量。根据硬件信息选择一个/init.(硬件).rc，并解析，将服务和操作信息加入链表。
*/
get_hardware_name();
snprintf(tmp,sizeof(tmp),"/init.%s.rc", hardware);
parse_config_file(tmp);
/*执行链表中带有“early-init”触发的的命令。*/
action_for_each_trigger("early-init", action_add_queue_tail);
drain_action_queue();
/*遍历/sys文件夹，是内核产生设备添加事件（为了自动产生设备节点)。
*初始化属性系统，并导入初始化属性文件。用于在系统运行过程中动态创建设备节点、删除设备节点等操作
*/
INFO("device init\n");
device_fd = device_init();
property_init();
// 从属性系统中得到ro.debuggable，若为1，则初始化keychord监听。
debuggable = property_get("ro.debuggable");
if(debuggable &&!strcmp(debuggable,"1")){
keychord_fd = open_keychord();
}
/*打开console，如果cmdline中没有指定的console则打开默认的/dev/console*/
if(console[0]){
snprintf(tmp,sizeof(tmp),"/dev/%s", console);
console_name = strdup(tmp);
}
fd = open(console_name, O_RDWR);
if(fd >=0)
have_console =1;
close(fd);
/*读取/initlogo.rle（一张位图），如果成功则在/dev/graphics/fb0 显示Logo,如果失败则将/dev/tty0
*设为TEXT模式并打开/dev/tty0,输出文本ANDROID（本人修改为Zhao Rui Jia做为启动项目的修改）。
*/
if( load_565rle_image(INIT_IMAGE_FILE)){
fd = open("/dev/tty0", O_WRONLY);
if(fd >=0){
constchar*msg;
msg ="\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n" // console is 40 cols x 30 lines
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"\n"
/*" A N D R O I D ";*/
" z h a o R u i J i a";
write(fd, msg, strlen(msg));
close(fd);
}
}
/* 判断cmdline 中的參數，并设置属性系统中的参数:
* 1、 如果 bootmode为
* - factory,设置ro.factorytest值为1
* - factory2,设置ro.factorytest值为2
* - 其他的設ro.factorytest值為0
* 2、如果有serialno参数，则设置ro.serialno，否则为""
* 3、如果有bootmod参数，则设置ro.bootmod，否则为"unknown"
* 4、如果有baseband参数，则设置ro.baseband，否则为"unknown"
* 5、如果有carrier参数，则设置ro.carrier，否则为"unknown"
* 6、如果有bootloader参数，则设置ro.bootloader，否则为"unknown"
* 7、通过全局变量（前面从/proc/cpuinfo中提取的）设置ro.hardware和ro.version。
*/
if(qemu[0])
import_kernel_cmdline(1);
if(!strcmp(bootmode,"factory"))
property_set("ro.factorytest","1");
elseif(!strcmp(bootmode,"factory2"))
property_set("ro.factorytest","2");
else
property_set("ro.factorytest","0");
property_set("ro.serialno", serialno[0]? serialno :"");
property_set("ro.bootmode", bootmode[0]? bootmode :"unknown");
property_set("ro.baseband", baseband[0]? baseband :"unknown");
property_set("ro.carrier", carrier[0]? carrier :"unknown");
property_set("ro.bootloader", bootloader[0]? bootloader :"unknown");
property_set("ro.hardware", hardware);
snprintf(tmp, PROP_VALUE_MAX,"%d", revision);
property_set("ro.revision", tmp);
/*执行所有触发标识为init的action。*/
action_for_each_trigger("init", action_add_queue_tail);
drain_action_queue();
property_set_fd = start_property_service();
/* 为sigchld handler创建信号机制*/
if(socketpair(AF_UNIX, SOCK_STREAM,0, s)==0){
signal_fd = s[0];
signal_recv_fd = s[1];
fcntl(s[0], F_SETFD, FD_CLOEXEC);
fcntl(s[0], F_SETFL, O_NONBLOCK);
fcntl(s[1], F_SETFD, FD_CLOEXEC);
fcntl(s[1], F_SETFL, O_NONBLOCK);
}
/* 确认所有初始化工作完成
* device_fd(device init 完成)
* property_set_fd(property server start 完成)
* signal_recv_fd (信号机制建立)
*/
if((device_fd <0)||
(property_set_fd <0)||
(signal_recv_fd <0)){
ERROR("init startup failure\n");
return1;
}
/* execute all the boot actions to get us started */
action_for_each_trigger("early-boot", action_add_queue_tail);
action_for_each_trigger("boot", action_add_queue_tail);
drain_action_queue();
/* run all property triggers based on current state of the properties */
queue_all_property_triggers();
drain_action_queue();
/* enable property triggers */
property_triggers_enabled =1;
/*
* 注册轮询事件:
* - device_fd
* - property_set_fd
* -signal_recv_fd
* -如果有keychord，则注册keychord_fd
*/
ufds[0].fd = device_fd;
ufds[0].events = POLLIN;
ufds[1].fd = property_set_fd;
ufds[1].events = POLLIN;
ufds[2].fd = signal_recv_fd;
ufds[2].events = POLLIN;
fd_count =3;
if(keychord_fd >0){
ufds[3].fd = keychord_fd;
ufds[3].events = POLLIN;
fd_count++;
}else{
ufds[3].events =0;
ufds[3].revents =0;
}/*如果支持BOOTCHART,则初始化BOOTCHART*/#if BOOTCHART
bootchart_count = bootchart_init();
if(bootchart_count <0){
ERROR("bootcharting init failure\n");
}elseif(bootchart_count >0){
NOTICE("bootcharting started (period=%d ms)\n", bootchart_count*BOOTCHART_POLLING_MS);
}else{
NOTICE("bootcharting ignored\n");
}#endif
/*
*进入主进程循环:
* - 重置轮询事件的接受状态，revents为0
* - 查询action队列并执行。
* - 重启需要重启的服务
* - 轮询注册的事件
* - 如果signal_recv_fd的revents为POLLIN，则得到一个信号，获取并处理
* - 如果device_fd的revents为POLLIN,调用handle_device_fd
* - 如果property_fd的revents为POLLIN,调用handle_property_set_fd
* - 如果keychord_fd的revents为POLLIN,调用handle_keychord
*/
for(;;){
int nr, i, timeout =-1;
for(i =0; i < fd_count; i++)
ufds[i].revents =0;
drain_action_queue();
restart_processes();
if(process_needs_restart){
timeout =(process_needs_restart - gettime())*1000;
if(timeout <0)
timeout =0;
}#if BOOTCHART
if(bootchart_count >0){
if(timeout <0|| timeout > BOOTCHART_POLLING_MS)
timeout = BOOTCHART_POLLING_MS;
if(bootchart_step()<0||--bootchart_count ==0){
bootchart_finish();
bootchart_count =0;
}
}#endif
nr = poll(ufds, fd_count, timeout);
if(nr <=0)
continue;
if(ufds[2].revents == POLLIN){
/* we got a SIGCHLD - reap and restart as needed */
read(signal_recv_fd, tmp,sizeof(tmp));
while(!wait_for_one_process(0))
;
continue;
}
if(ufds[0].revents == POLLIN)
handle_device_fd(device_fd);
if(ufds[1].revents == POLLIN)
handle_property_set_fd(property_set_fd);
if(ufds[3].revents == POLLIN)
handle_keychord(keychord_fd);
}
return0;}2、启动脚本init.rc
在 Android中使用启动脚本init.rc,可以在系统的初始化过程中进行一些简单的初始化操作。这个脚本被直接安装到目标系统的根文件系统中，被 init可执行程序解析。 init.rc是在init启动后被执行的启动脚本，其余发主要包含了以下内容：Commands：命令
Actions：动作
Triggers:触发条件
Services：服务
Options：选项
Propertise：属性
Commands是一些基本的操作，例如：
mkdir /sdcard 0000 system system mkdir /system mkdir /data 0771 system system mkdir /cache 0770 system cache mkdir /config 0500 root root mkdir /sqlite_stmt_journals 01777 root root mount tmpfs tmpfs /sqlite_stmt_journals size=4m
这些命令在init可执行程序中被解析，然后调用相关的函数来实现。 Actions(动作)表示一系列的命令，通常在Triggers（触发条件）中调用，动作和触发条件例如：
on init export PATH /sbin:/system/sbin:/system/bin:/system/xbin
init表示一个触发条件，这个触发事件发生后，进行设置环境变量和建立目录的操作称为一个“动作” Services（服务）通常表示启动一个可执行程序，Options（选项）是服务的附加内容，用于配合服务使用。
service vold /system/bin/vold socket vold stream 0660 root mount service bootsound /system/bin/playmp3 user media group audio oneshot
vold和bootsound分别是两个服务的名称，/system/bin /vold和/system /bin/playmp3分别是他们所对应的可执行程序。socket、user、group、oneshot就是配合服务使用的选项。 Properties（属性）是系统中使用的一些值，可以进行设置和读取。
setprop ro.FOREGROUND_APP_MEM 1536 setprop ro.VISIBLE_APP_MEM 2048 start adbd
setprop 用于设置属性，on property可以用于判断属性，这里的属性在整个Android系统运行中都是一致的。
综上如果想要修改启动过程只需要修改init.c或者init.rc里的内容即可.
3. 总结：
(1)内核的init_post类似接口，会去文件系统中启动init类似的用户进程
(2)android实现了这样的init，这就是android框架启动的地方，当然linux内核也可说是android系统的一部分
(3)init进程无限分裂，启动框架，演变成android系统
(4)android的init进程的代码在system/core/init/init.c中，从main函数开始.
本文完~
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Android研究-linux内核启动到android系统
- Android研究-linux内核启动到android系统 .
- Android系统启动研究1
- Android研究-Android系统初始化程序init和初始化配置文件init.rc分析[zz]
- linux内核启动+Android系统启动过程详解
- Android研究-Android系统初始化程序init和初始化配置文件init.rc分析[zz]
- Android系统启动流程 三--linux内核启动
- Android研究-Android系统初始化程序init和初始化配置文件init.rc分析[zz]
- linux内核启动+Android系统启动过程详解
- linux内核启动到android系统
- 【转载】linux内核启动android文件系统过程分析
- [zz] 分析Android 根文件系统启动过程（init守护进程分析）
- [Android 系统源代码研究] SystemService启动
- android系统服务启动分析-binder
- 学习Android系统（kitkat）进程Zygote启动过程
- 源码级分析Android系统启动流程
- Android系统Recovery工作原理之使用update.zip升级过程分析（三）---Android系统的三种启动模式
- android系统启动流程之init.rc详细分析笔记
- Android系统启动流程 -- android
- Android系统的内存管理研究