ARM-Linux內核移植

內核版本：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文件中有個描述特定機器的數據結構，如下

1. MACHINE_START(S3C2440,"SMDK2440")
2. /* Maintainer: Ben Dooks<ben@fluff.org> */
3. .phys_io =S3C2410_PA_UART,
4. .io_pg_offst = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
5. .boot_params = S3C2410_SDRAM_PA + 0x100,
7. .init_irq =s3c24xx_init_irq,
8. .map_io =smdk2440_map_io,
9. .init_machine = smdk2440_machine_init,
10. .timer =&s3c24xx_timer,
11. MACHINE_END

MACHINE_START和 MACHINE_END實際上被展開成一個結構體

1. #defineMACHINE_START(_type,_name) \
2. staticconst struct machine_desc __mach_desc_##_type \
3. __used \
4. __attribute__((__section__(".arch.info.init")))= { \
5. .nr =MACH_TYPE_##_type, \
6. .name =_name,
8. #defineMACHINE_END \
9. };

於是上面的數據結構就被展開為

1. staticconst struct machine_desc __mach_desc_S3C2440 \
2. __used \
3. __attribute__((__section__(".arch.info.init")))= { \
4. .nr =MACH_TYPE_S3C2440, \
5. .name =”SMDK2440”,};
6. .phys_io = S3C2410_PA_UART,
7. .io_pg_offst = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
8. .boot_params = S3C2410_SDRAM_PA + 0x100,
10. .init_irq =s3c24xx_init_irq,
11. .map_io =smdk2440_map_io,
12. .init_machine = smdk2440_machine_init,
13. .timer =&s3c24xx_timer,
15. }

每個機器都會有一個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函數

1. __switch_data:
2. .long __mmap_switched
3. .long __data_loc @ r4
4. .long __data_start @ r5
5. .long __bss_start @ r6
6. .long _end @ r7
7. .long processor_id @ r4
8. .long __machine_arch_type @ r5
9. .long cr_alignment @ r6
10. .long init_thread_union+ THREAD_START_SP @ sp
12. /*
13. * The following fragment of code is executedwith the MMU on in MMU mode,
14. * and uses absolute addresses; this is notposition independent.
15. *
16. * r0 =cp#15 control register
17. * r1 = machine ID
18. * r9 = processor ID
19. */
20. .type __mmap_switched,%function
21. __mmap_switched:
22. adr r3,__switch_data + 4
24. ldmia r3!,{r4, r5, r6, r7}
25. cmp r4,r5 @ Copy datasegment if needed
26. 1: cmpne r5,r6
27. ldrne fp,[r4], #4
28. strne fp,[r5], #4
29. bne 1b
31. mov fp,#0 @ Clear BSS(and zero fp)
32. 1: cmp r6,r7
33. strcc fp,[r6],#4
34. bcc 1b
36. ldmia r3,{r4, r5, r6, sp}
37. str r9, [r4] @ Save processor ID
38. str r1, [r5] @ Save machine type
39. bic r4,r0, #CR_A @ Clear 'A' bit
40. stmia r6,{r0, r4} @ Save controlregister values
41. b start_kernel

這個函數做的工作是，復制數據段清楚BBS段，設置堆在指針，然後保存處理器內核和機器內核等工作，最後跳到start_kernel函數。於是內核開始執行第二階段。

第二階段：

我們再來看init/目錄下的main.c的start_kernel函數，這裡我只截圖了部分。

1. asmlinkage void __init start_kernel(void)
2. {
3. …………………….
4. ……………………..
5. printk(KERN_NOTICE);
6. printk(linux_banner);
7. setup_arch(&command_line);
8. setup_command_line(command_line);
11. parse_early_param();
12. parse_args("Booting kernel",static_command_line, __start___param,
13. __stop___param - __start___param,
14. &unknown_bootoption);
15. ……………………
16. …………………………
17. init_IRQ();
18. pidhash_init();
19. init_timers();
20. hrtimers_init();
21. softirq_init();
22. timekeeping_init();
23. time_init();
24. profile_init();
25. …………………………
26. ……………………………
27. console_init();
28. ………………………………
29. ………………………………
30. rest_init();
31. }

從上面可以看出start_kernel首先是打印內核信息，然後對bootloader傳進來的一些參數進行處理，再接著執行各種各樣的初始化，在這其中會初始化控制台。最後會調用rest_init();

我們再來看rest_init()函數

1. static void noinline __init_refok rest_init(void)
2. __releases(kernel_lock)
3. {
4. int pid;
6. kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
7. ............
8. }

他啟動了kernel_init這個函數，再來看kerne_init函數

1. static int __init kernel_init(void * unused)
2. {
3. ..............................
5. if (!ramdisk_execute_command)
6. ramdisk_execute_command = "/init";
8. if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
9. ramdisk_execute_command = NULL;
10. prepare_namespace();
11. }
13. /*
14. * Ok, we have completed the initial bootup, and
15. * we're essentially up and running. Get rid of the
16. * initmem segments and start the user-mode stuff..
17. */
18. init_post();
19. return 0;
20. }

kernel_init先調用了prepare_namespace();然後調用了init_post函數

1. void __init prepare_namespace(void)
2. {
3. ..........................
4. mount_root();
5. .....................
6. }

可以看出prepare_namespace調用了mount_root掛接根文件系統。接著kernel_init再執行init_post

1. static int noinline init_post(void)
2. {
3. .......................................
4. /*打開dev/console控制台，並設置為標准輸入、輸出*/
6. if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
7. printk(KERN_WARNING "Warning: unable to open an initial console.\n");
9. (void) sys_dup(0);
10. (void) sys_dup(0);
12. if (ramdisk_execute_command) {
13. run_init_process(ramdisk_execute_command);
14. printk(KERN_WARNING "Failed to execute %s\n",
15. ramdisk_execute_command);
16. }
18. /*
19. * We try each of these until one succeeds.
20. *
21. * The Bourne shell can be used instead of init if we are
22. * trying to recover a really broken machine.
23. */
25. //如果bootloader指定了init參數，則啟動init參數指定的進程
26. if (execute_command) {
27. run_init_process(execute_command);
28. printk(KERN_WARNING "Failed to execute %s. Attempting "
29. "defaults...\n", execute_command);
30. }
32. //如果沒有指定init參數，則分別帶sbin、etc、bin目錄下啟動init進程
33. run_init_process("/sbin/init");
34. run_init_process("/etc/init");
35. run_init_process("/bin/init");
36. run_init_process("/bin/sh");
38. panic("No init found. Try passing init= option to kernel.");
39. }

注意上面的run_init_process的會等待init進程返回才往後面執行，所有它一旦找到一個init可執行的文件它將一去不復返。

綜上，內核啟動的過程大致為以下幾步：

1.檢查CPU和機器類型

2.進行堆棧、MMU等其他程序運行關鍵的東西進行初始化

3.打印內核信息

4.執行各種模塊的初始化

5.掛接根文件系統

6.啟動第一個init進程