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,  
6.    
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  
12.    

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,  
7.         
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,  
9.    
10.        .init_irq   =s3c24xx_init_irq,  
11.        .map_io          =smdk2440_map_io,  
12.        .init_machine  = smdk2440_machine_init,  
13.        .timer             =&s3c24xx_timer,  
14.    
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  
11.    
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  
23.    
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  
30.    
31.        mov fp,#0                           @ Clear BSS(and zero fp)  
32. 1:    cmp r6,r7  
33.        strcc fp,[r6],#4  
34.        bcc  1b  
35.    
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);  
9.         
10.         
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;  
5.   
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.     ..............................  
4.   
5.     if (!ramdisk_execute_command)  
6.         ramdisk_execute_command = "/init";  
7.   
8.     if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {  
9.         ramdisk_execute_command = NULL;  
10.         prepare_namespace();  
11.     }  
12.   
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控制台，並設置為標准輸入、輸出*/  
5.           
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");  
8.   
9.     (void) sys_dup(0);  
10.     (void) sys_dup(0);  
11.   
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.     }  
17.   
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.      */  
24.   
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.     }  
31.   
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");  
37.   
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進程