arm-linux啟動過程

http://www.uplinux.com/shizi/wenxian/4445.html

1. kernel運行的史前時期和內存布局

     在 arm平台下，zImage.bin壓縮鏡像是由bootloader加載到物理內存，然后跳到zImage.bin里一段程序，它專門於將被壓縮的 kernel解壓縮到KERNEL_RAM_PADDR開始的一段內存中，接着跳進真正的kernel去執行。該kernel的執行起點是stext函數，定義於arch/arm/kernel/head.S。

     1在分析stext函數前，先介紹此時內存的布局如下圖所示

     在開發板tqs3c2440中，SDRAM連接到內存控制器的Bank6中，它的開始內存地址是0x30000000，大小為64M，即 0x20000000。 arm Linux kernel將SDRAM的開始地址定義為PHYS_OFFSET。經bootloader加載kernel並由自解壓部分代碼運行后，最終kernel 被放置到KERNEL_RAM_PADDR（=PHYS_OFFSET + TEXT_OFFSET，即0x30008000）地址上的一段內存，經此放置后，kernel代碼以后均不會被移動。

     1在進入kernel代碼前，即bootloader和自解壓縮階段，arm未開啟MMU功能。因此kernel啟動代碼一個重要功能是設置好相應的頁表，並開啟MMU功能。為了支持MMU功能，kernel鏡像中的所有符號，包括代碼段和數據段的符號，在鏈接時都生成了它在開啟MMU時，所在物理內存地址映射到的虛擬內存地址。

     1以arm kernel第一個符號（函數）stext為例，在編譯鏈接，它生成的虛擬地址是0xc0008000，而放置它的物理地址為0x30008000（還記得這是PHYS_OFFSET+TEXT_OFFSET嗎？）。實際上這個變換可以利用簡單的公式進行表示：va = pa – PHYS_OFFSET + PAGE_OFFSET。arm linux最終的kernel空間的頁表，就是按照這個關系來建立。

     之所以較早提及arm linux 的內存映射，原因是在進入kernel代碼，里面所有符號地址值為清一色的0xCXXXXXXX地址，而此時arm未開啟MMU功能，故在執行stext 函數第一條執行時，它的PC值就是stext所在的內存地址（即物理地址，0x30008000）。因此，下面有些代碼，需要使用地址無關技術。

     2．一覽stext函數

     stext函數定義在Arch/arm/kernel/head.S，它的功能是獲取處理器類型和機器類型信息，並創建臨時的頁表，然后開啟MMU功能，並跳進第一個C語言函數start_kernel。

     stext函數的在前置條件是：MMU, D-cache, 關閉; r0 = 0, r1 = machine nr, r2 = atags prointer.

     代碼如下：

[cpp] view plaincopyprint?

1.   .section ".text.head", "ax" 
3. (stext) 
5. /* 設置CPU運行模式為SVC，並關中斷 */ 
7.   msr  cpsr_c, #PSR_F_BIT | PSR_I_BIT | SVC_MODE @ ensure svc mode 
9.                                      @ and irqs disabled 
11.   mrc p15, 0, r9, c0, c0        @ get processor id 
13.   bl    __lookup_processor_type         @ r5=procinfo r9=cupid 
15. /* r10指向cpu對應的proc_info記錄 */ 
17.    movs  r10, r5                         @ invalid processor (r5=0)? 
19.   beq __error_p                    @ yes, error 'p' 
21.   bl    __lookup_machine_type            @ r5=machinfo 
23. /* r8 指向開發板對應的arch_info記錄 */ 
25.    movs  r8, r5                           @ invalid machine (r5=0)? 
27.   beq __error_a                    @ yes, error 'a' 
29. /* __vet_atags函數涉及bootloader造知kernel物理內存的情況，我們暫時不分析它。 */ 
31.   bl    __vet_atags 
33. /*  創建臨時頁表 */ 
35.   bl    __create_page_tables 
39.   /*
41.    * The following calls CPU specific code in a position independent
43.    * manner.  See arch/arm/mm/proc-*.S for details.  r10 = base of
45.    * xxx_proc_info structure selected by __lookup_machine_type
47.    * above.  On return, the CPU will be ready for the MMU to be
49.    * turned on, and r0 will hold the CPU control register value.
51.    */ 
53. /* 這里的邏輯關系相當復雜，先是從proc_info結構中的中跳進__arm920_setup函數，
55.   * 然后執__enable_mmu 函數。最后在__enable_mmu函數通過mov pc, r13來執行__switch_data，
57.   * __switch_data函數在最后一條語句，魚躍龍門，跳進第一個C語言函數start_kernel。
58.    */ 
60.   ldr   r13, __switch_data             @ address to jump to after 
62.                                      @ mmu has been enabled 
64.   adr  lr, __enable_mmu        @ return (PIC) address 
66.   add pc, r10, #PROCINFO_INITFUNC 
68. OC(stext) 

     3 __lookup_processor_type 函數

__lookup_processor_type 函數是一個非常講究技巧的函數，如果你將它領會，也將領會kernel了一些魔法。

     Kernel 代碼將所有CPU信息的定義都放到.proc.info.init段中，因此可以認為.proc.info.init段就是一個數組，每個元素都定義了一個或一種CPU的信息。目前__lookup_processor_type使用該元素的前兩個字段cpuid和mask來匹配當前CPUID，如果滿足 CPUID & mask == cpuid，則找到當前cpu的定義並返回。

     下面是tqs3c2440開發板，CPU的定義信息，cpuid = 0x41009200，mask = 0xff00fff0。如果是碼是運行在tqs3c2440開發板上，那么函數返回下面的定義：

[cpp] view plaincopyprint?

1.        .section ".proc.info.init", #alloc, #execinstr 
5.        .type       __arm920_proc_info,#object 
7. __arm920_proc_info: 
9.        .long       0x41009200 
11.        .long       0xff00fff0 
13.        .long   PMD_TYPE_SECT | \ 
15.               PMD_SECT_BUFFERABLE | \ 
17.               PMD_SECT_CACHEABLE | \ 
19.               PMD_BIT4 | \ 
21.               PMD_SECT_AP_WRITE | \ 
23.               PMD_SECT_AP_READ 
25.        .long   PMD_TYPE_SECT | \ 
27.               PMD_BIT4 | \ 
29.               PMD_SECT_AP_WRITE | \ 
31.               PMD_SECT_AP_READ 
33.       /* __arm920_setup函數在stext的未尾被調用，請往回看。*/ 
35.        b     __arm920_setup 
37.        .long       cpu_arch_name 
39.        .long       cpu_elf_name 
41.        .long       HWCAP_SWP | HWCAP_HALF | HWCAP_THUMB 
43.        .long       cpu_arm920_name 
45.        .long       arm920_processor_functions 
47.        .long       v4wbi_tlb_fns 
49.        .long       v4wb_user_fns 
51. #ifndef CONFIG_CPU_DCACHE_WRITETHROUGH 
53.        .long       arm920_cache_fns 
55. #else 
57.        .long       v4wt_cache_fns 
59. #endif 
61.        .size __arm920_proc_info, . - __arm920_proc_info 

[cpp] view plaincopyprint?

1. /*
2. * Read processor ID register (CP#15, CR0), and look up in the linker-built
3. * supported processor list.  Note that we can't use the absolute addresses
4. * for the __proc_info lists since we aren't running with the MMU on
5. * (and therefore, we are not in the correct address space).  We have to
6. * calculate the offset.
7. *
8. *   r9 = cpuid
9. * Returns:
10. *   r3, r4, r6 corrupted
11. *   r5 = proc_info pointer in physical address space
12. *   r9 = cpuid (preserved)
13. */  
14. __lookup_processor_type: 
15.       /* adr 是相對尋址，它的尋計算結果是將當前PC值加上3f符號與PC的偏移量，
16.        * 而PC是物理地址，因此r3的結果也是3f符號的物理地址 */ 
18.        adr  r3, 3f 
20.       /* r5值為__proc_info_bein, r6值為__proc_ino_end，而r7值為.，
21.        * 也即3f符號的鏈接地址。請注意，在鏈接期間，__proc_info_begin和
22.        * __proc_info_end以及.均是鏈接地址，也即虛執地址。
23.        */ 
25.        ldmda     r3, {r5 - r7} 
27.      /* r3為3f的物理地址，而r7為3f的虛擬地址。結果是r3為虛擬地址與物理地址的差值，即PHYS_OFFSET - PAGE_OFFSET。*/ 
29.        sub  r3, r3, r7                     @ get offset between virt&phys 
31.      /* r5為__proc_info_begin的物理地址, 即r5指針__proc_info數組的首地址 */ 
33.        add r5, r5, r3                     @ convert virt addresses to 
35.      /* r6為__proc_info_end的物理地址 */ 
37.        add r6, r6, r3                     @ physical address space 
39.      /* 讀取r5指向的__proc_info數組元素的CPUID和mask值 */ 
41. 1:    ldmia      r5, {r3, r4}                  @ value, mask 
43.      /* 將當前CPUID和mask相與，並與數組元素中的CPUID比較是否相同
44.       * 若相同，則找到當前CPU的__proc_info定義，r5指向訪元素並返回。
45.       */ 
47.        and  r4, r4, r9                     @ mask wanted bits 
49.        teq  r3, r4 
51.        beq 2f 
53.      /* r5指向下一個__proc_info元素 */ 
55.        add r5, r5, #PROC_INFO_SZ        @ sizeof(proc_info_list) 
57.      /* 是否遍歷完所有__proc_info元素 */ 
59.        cmp r5, r6 
61.        blo  1b 
63.      /* 找不到則返回NULL */ 
65.        mov r5, #0                          @ unknown processor 
67. 2:    mov pc, lr 
69. ENDPROC(__lookup_processor_type) 
71.        .long       __proc_info_begin 
72.        .long       __proc_info_end 
73. 3:    .long       . 
74.        .long       __arch_info_begin 
75.        .long       __arch_info_end 

      4 __lookup_machine_type 函數

__lookup_machine_type 和__lookup_processor_type像對孿生兄弟，它們的行為都是很類似的：__lookup_machine_type根據r1寄存器的機器編號到.arch.info.init段的數組中依次查找機器編號與r1相同的記錄。它使了與它孿生兄弟同樣的手法進行虛擬地址到物理地址的轉換計算。

     在介紹函數，我們先分析tqs3c2440開發板的機器信息的定義：

[cpp] view plaincopyprint?

1. Arch/arm/include/asm/mach/arch.h  
3. #define MACHINE_START(_type,_name)                  \ 
5. static const struct machine_desc __mach_desc_##_type      \ 
7. __used                                           \ 
9. __attribute__((__section__(".arch.info.init"))) = { \ 
11.        .nr          = MACH_TYPE_##_type,              \ 
13.        .name            = _name, 
17. #define MACHINE_END                       \ 
19. }; 

     MACHINE_START宏用於定義一個.arch.info.init段的數組元素。.nr元素就是函數要比較的變量。Tqs3c2440開發板相應的定義如下：

[cpp] view plaincopyprint?

1. MACHINE_START(S3C2440, "TQ2440") 
3.        .phys_io = S3C2410_PA_UART, 
5.        .io_pg_offst   = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc, 
7.        .boot_params       = S3C2410_SDRAM_PA + 0x100, 
11.        .init_irq   = s3c24xx_init_irq, 
13.        .map_io         = tq2440_map_io, 
15.        .init_machine  = tq2440_machine_init, 
17.        .timer             = &s3c24xx_timer, 
19. MACHINE_END 

     這是一個struct machine_desc結構，在后面的C代碼（start_kernel開始執行的代碼）會使用該變量對象。在tqs3c2440開發中的__lookup_machine_type函數就是返回該對象指針。

     這里涉及很多函數指針，它們都是在start_kernel函數里在各種階段進行初始化的回函數。如map_io指向的tq2440_map_io就是在建立好內核頁表后，再調用它來針對開發板的各種IO端口來建立相關的映射和頁表。

     至於__loopup_machine_type的代碼就不作詳細分析，請對比__lookup_processor_type來自行分析。代碼如下：

[cpp] view plaincopyprint?

1. /*
3. * Lookup machine architecture in the linker-build list of architectures.
5. * Note that we can't use the absolute addresses for the __arch_info
7. * lists since we aren't running with the MMU on (and therefore, we are
9. * not in the correct address space).  We have to calculate the offset.
11. *
13. *  r1 = machine architecture number
15. * Returns:
17. *  r3, r4, r6 corrupted
19. *  r5 = mach_info pointer in physical address space
21. */ 
23. __lookup_machine_type: 
25.        adr  r3, 3b 
27.        ldmia      r3, {r4, r5, r6} 
29.        sub  r3, r3, r4                     @ get offset between virt&phys 
31.        add r5, r5, r3                     @ convert virt addresses to 
33.        add r6, r6, r3                     @ physical address space 
35. 1:    ldr   r3, [r5, #MACHINFO_TYPE] @ get machine type 
37.        teq  r3, r1                           @ matches loader number? 
39.        beq 2f                         @ found 
41.        add r5, r5, #SIZEOF_MACHINE_DESC     @ next machine_desc 
43.        cmp r5, r6 
45.        blo  1b 
47.        mov r5, #0                          @ unknown machine 
49. 2:    mov pc, lr 
51. ENDPROC(__lookup_machine_type) 

     5. 為kernel建立臨時頁表

     前面提及到，kernel里面的所有符號在鏈接時，都使用了虛擬地址值。在完成基本的初始化后，kernel代碼將跳到第一個C語言函數 start_kernl來執行，在哪個時候，這些虛擬地址必須能夠對它所存放在真正內存位置，否則運行將為出錯。為此，CPU必須開啟MMU，但在開啟 MMU前，必須為虛擬地址到物理地址的映射建立相應的面表。在開啟MMU后，kernel指並不馬上將PC值指向start_kernl，而是要做一些C 語言運行期的設置，如堆棧，重定義等工作后才跳到start_kernel去執行。在此過程中，PC值還是物理地址，因此還需要為這段內存空間建立va = pa的內存映射關系。當然，本函數建立的所有頁表都會在將來paging_init銷毀再重建，這是臨時過度性的映射關系和頁表。

     在介紹__create_table_pages前，先認識一個macro pgtbl，它將KERNL_RAM_PADDR – 0x4000的值賦給rd寄存器，從下面的使用中可以看它，該值是頁表在物理內存的基礎，也即頁表放在kernel開始地址下的16K的地方。

[cpp] view plaincopyprint?

3. .macro    pgtbl, rd  
5.        ldr   \rd, =(KERNEL_RAM_PADDR - 0x4000)  
7. .endm 

cpp] view plaincopyprint?

1. /* 
2. * Setup the initial page tables.  We only setup the barest 
3. * amount which are required to get the kernel running, which 
4. * generally means mapping in the kernel code. 
5. * 
6. * r8  = machinfo 
7. * r9  = cpuid 
8. * r10 = procinfo 
9. * 
10. * Returns: 
11. *  r0, r3, r6, r7 corrupted 
12. *  r4 = physical page table address 
13. */  
14. __create_page_tables:  
15.   /* r4 = KERNEL_RAM_PADDR – 0x4000 = 0x30004000 
16.    * 后面的C代碼中的swapper_pg_dir變量，它的值也指向0x30004000 
17.    * 內存地址，不過它的值是虛擬內存地址，即0xc0004000 
18.    */  
19.        pgtbl       r4                         @ page table address  
21.    /* 將從r4到KERNEL_RAP_PADDR的16K頁表空間清空。 */  
23.        mov r0, r4  
24.        mov r3, #0  
25.        add r6, r0, #0x4000  
27. 1:     str   r3, [r0], #4  
28.        str   r3, [r0], #4  
29.        str   r3, [r0], #4  
30.        str   r3, [r0], #4  
31.        teq  r0, r6  
32.        bne  1b  
35.      /* 還記得r10指向開發板相應的proc_info元素嗎？這里它將的mm_mmuflags值讀到r7中。 
36.       * PROCINFO_MM_MMUFLAGS值為8，可對應上面列出來的__arm920_proc_info結構或你相應開發板結構的值來查看該mmu_flags值。 
37.       * 這里的flags就是用於設置目錄項的flags。查看該mmu_flags的定義，發現它是要求一級頁表是section。 
38.       */  
40.        ldr   r7, [r10, #PROCINFO_MM_MMUFLAGS] @ mm_mmuflags  
42.        /* 
43.         * Create identity mapping for first MB of kernel to 
44.         * cater for the MMU enable.  This identity mapping 
45.         * will be removed by paging_init().  We use our current program 
46.         * counter to determine corresponding section base address. 
47.         */  
49.        /* r3 = ((pc >> 20) << 20) | r7， 即取PC以1M向下對齊的地址。R6 = pc >> 20也即r6 = 0x300(pgd_idx)， 
50.         * 即PC對所有1M內存空間，在頁表中的下標。                                     
51.         * R7值表明該目錄項是section，即它映射的大小是1M。故剛好一個目錄項就可以映射kernel上的1M空間。 
52.         * 這個暫時的va = pa映射只建立1M大小內存的，而不需要建立整個kernel鏡像范圍的映射。 
53.         * 因為這個va = pa的映射只有當前匯編語言才使用，一量跳進start_kernl后，這將不會用到了。而匯編代碼在鏈接時， 
54.         * 已將它安排到代碼段的最前面了。 
56.         mov r6, pc, lsr #20                     @ start of kernel section 
57.         orr   r3, r7, r6, lsl #20         @ flags + kernel base 
59.        /* 將目錄內空寫到頁表相應位置，即((uint32_t *)r4)[pgd_idx] = r3 */  
61.        str   r3, [r4, r6, lsl #2]         @ identity mapping  
64.        /* 上面代碼段為[pc &(~0xfffff), (pc + 0xfffff) &(~0xfffff)]的物理內存空間建立了va = pa的映射關系。*/  
66.        /* 下面為kernel鏡像所占有空間，即KERNL_START到KERNEL_END建立內存映射， 
67.         * 映射關系為：va = pa – PHYS + PAGR_OFFSET。注意，這里的KENEL_START是kernel空間開始的虛擬地址。 
68.         * 這里的目錄表項同樣是section，即一個項映射1M的內存。 
69.         */  
72.        /* KERNEL_START = PAGE_OFFSET + TEXT_OFFSET， 
73.         * r0 = ((uint32_t *)(r4))[ (KERNEL_START & 0xff000000) >> 20]， 
74.         * 即r0指向KERNEL_START& 0xff000000(即kernel以16M向下對齊的)虛擬地址，所在項表目錄中的位置。 
76.        add r0, r4,  #(KERNEL_START & 0xff000000) >> 18 
78.       /* r0 = ((uint32_t *)r0)[(KERNEL_START & 0x00f00000) >> 20] 
79.        * 執行前r0指向kernel以16M向下對齊的虛執地址，而這里再加上KERNEL_START未以16M向對齊部分的偏移量。 
80.        * 將原來r3的值寫到頁表目錄中。R3的值就是之前已建立好va=pa映射的那個PA值。 
81.        */  
83.        str   r3, [r0, #(KERNEL_START & 0x00f00000) >> 18]!  
85.       /* r6為kernel鏡像的尾部虛擬地址。*/  
87.        ldr   r6, =(KERNEL_END - 1)  
89.       /* 指向下一個即將要填寫的目錄項 */  
91.        add r0, r0, #4  
93.       /* r6指向KERNEL_END- 1虛擬地址所在的目錄表項的位置 */  
95.       add r6, r4, r6, lsr #18  
96. 1:    cmp       r0, r6  
98.       /* 每填一個目錄項，后一個比前一個所指向的物理地址大1M。*/  
99.       add r3, r3, #1 << 20  
100.       strls r3, [r0], #4  
101.       bls   1b  
103. #ifdef CONFIG_XIP_KERNEL  
104.        /* 忽略，不分析這種情況 */  
105. #endif  
107.     /* 通常kernel的啟動參數由bootloader放到了物理內存的第1個M上，所以需要為RAM上的第1個M建立映射。 
108.      * 上面已為PHYS_OFFSET + TEXT_OFFSET建立了映射，如果TEXT_OFFSET小於0x00100000的話， 
109.      * 上面代碼應該也為SDRAM的第一個M建立了映射，但如果大於0x0010000則不會。 
110.      * 所以這里無論如何均為SDRAM的第一個M建立映射（不知分析對否，還請指正）。 
111.      */  
112.        add r0, r4, #PAGE_OFFSET >> 18  
113.        orr   r6, r7, #(PHYS_OFFSET & 0xff000000)  
114.        .if    (PHYS_OFFSET & 0x00f00000)  
115.        orr   r6, r6, #(PHYS_OFFSET & 0x00f00000)  
116.        .endif  
117.        str   r6, [r0]  
119. #ifdef CONFIG_DEBUG_LL  
120.        /*略去 */  
121. #if defined(CONFIG_ARCH_NETWINDER) || defined(CONFIG_ARCH_CATS)  
122.        /* 略去 */  
123. #endif  
125. #ifdef CONFIG_ARCH_RPC  
126. /* 略去 */  
127. #endif  
129. #endif  
131.        mov pc, lr  
132. ENDPROC(__create_page_tables) 

     一口氣將__create_pages_table分析完，但里涉及的代碼還是需要細細品讀。尤其是右移20位和18位兩個地方與頁表目錄項的地址關系比較復雜。執行完該函數后，虛擬內存和物理內存的映射關系.

     6. 開啟MMU

     看完頁表的建立，想必開啟MMU的代碼也是小菜一碟吧。此函數的主要功能是將頁表的基址加到cp15中的面表指針寄存器，同時設置域訪問(domain access)寄存器。

[cpp] view plaincopyprint?

1. /* 
2. * Setup common bits before finally enabling the MMU.  Essentially 
3. * this is just loading the page table pointer and domain access 
4. * registers. 
5. */  
6. __enable_mmu:  
7. /* 這里設置是否為非對齊內存訪問產生異常 */  
8. #ifdef CONFIG_ALIGNMENT_TRAP  
9.        orr   r0, r0, #CR_A  
10. #else  
11.        bic   r0, r0, #CR_A  
12. #endif  
13. /* 是否禁用數據緩存功能*/  
14. #ifdef CONFIG_CPU_DCACHE_DISABLE  
15.        bic   r0, r0, #CR_C  
16. #endif  
17. /* 是否禁用CPU_BPREDICT ?，不是很清楚此選項 */  
18. #ifdef CONFIG_CPU_BPREDICT_DISABLE  
19.        bic   r0, r0, #CR_Z  
20. #endif  
21. /* 是否禁用指令緩存功能 */  
22. #ifdef CONFIG_CPU_ICACHE_DISABLE  
23.        bic   r0, r0, #CR_I  
24. #endif  
26.       /* 設置域訪問寄存器的值。這里設置每個domain的屬性是否上面建立的頁表中， 
27.        * 每個目錄項的damon值一起進行訪問控制檢查。具體情況請參考arm處理器手冊。 
28.        */  
30.        mov r5, #(domain_val(DOMAIN_USER, DOMAIN_MANAGER) | \  
31.                     domain_val(DOMAIN_KERNEL, DOMAIN_MANAGER) | \  
32.                     domain_val(DOMAIN_TABLE, DOMAIN_MANAGER) | \  
33.                     domain_val(DOMAIN_IO, DOMAIN_CLIENT))  
34.        mcr p15, 0, r5, c3, c0, 0           @ load domain access register  
35.        mcr p15, 0, r4, c2, c0, 0           @ load page table pointer  
36.        b     __turn_mmu_on  
37. ENDPROC(__enable_mmu)  
39. /* 
40. * Enable the MMU.  This completely changes the structure of the visible 
41. * memory space.  You will not be able to trace execution through this. 
42. * If you have an enquiry about this, *please* check the linux-arm-kernel 
43. * mailing list archives BEFORE sending another post to the list. 
44. * 
45. *  r0  = cp#15 control register 
46. *  r13 = *virtual* address to jump to upon completion 
47. * 
48. * other registers depend on the function called upon completion 
49. */  
51.        .align      5  
52. __turn_mmu_on:  
53.        mov r0, r0  
55.       /* 將r0的值寫到控制寄存器中。這里，終於開啟MMU功能了。 
56.        * 查閱手冊說控制寄存器的0位置1表示開啟MMU，但這里r0的第0是多少呢（還請大家指正） 
57.        */  
59.        mcr p15, 0, r0, c1, c0, 0           @ write control reg  
60.        mrc p15, 0, r3, c0, c0, 0           @ read id reg  
62.      /* 這里的兩個mov似乎是否流水線有關的，開啟MMU語句后面幾條是不能進行內存尋址的。但仍未搞明白具體東西的。*/  
63.        mov r3, r3  
64.        mov r3, r3  
66.      /* 轉跳到r13的函數中去，r13為__mmap_switched函數的虛擬地址， 
67.       * 從stext函數的未尾可以找到它的賦值。故從此開始pc的值就真正在內存的虛擬地址空間了。 
68.       */  
70.        mov pc, r13  
71. ENDPROC(__turn_mmu_on) 

     7．__mmap_switched函數

__mmap_switched函數專用來設置C語言的執行環境，比如重定位工作，堆棧，以及BSS段的清零。

__switch_data變量先定義了一系里面處量的數據，如重定位和數據段的地址，BSS段的地址，pocessor_id和__mach_arch_type變量的地址等。

[cpp] view plaincopyprint?

1.        .type       __switch_data, %object  
2. __switch_data:  
3.        .long       __mmap_switched  
4.        .long       __data_loc                  @ r4  
5.        .long       _data                           @ r5  
6.        .long       __bss_start                  @ r6  
7.        .long       _end                            @ r7  
8.        .long       processor_id               @ r4  
9.        .long       __machine_arch_type         @ r5  
10.        .long       __atags_pointer                  @ r6  
11.        .long       cr_alignment                @ r7  
12.        .long       init_thread_union + THREAD_START_SP @ sp  
14. /* 
15. * The following fragment of code is executed with the MMU on in MMU mode, 
16. * and uses absolute addresses; this is not position independent. 
17. * 
18. *  r0  = cp#15 control register 
19. *  r1  = machine ID 
20. *  r2  = atags pointer 
21. *  r9  = processor ID 
22. */  
23. __mmap_switched:  
24.        adr  r3, __switch_data + 4  
25.        /* r4 = __data_loc, r5 = _data, r6 = _bss_start, r7 = _end */  
26.        ldmia      r3!, {r4, r5, r6, r7}  
28.       /* 下面這段代碼類似於這段C代碼, 即將整個數據段從__data_loc拷貝到_data段。 
29.        * if (__data_loc  == _data || _data != _bass_start) 
30.        *    memcpy(_data, __data_loc, _bss_start - _data); 
31.        */  
33.        cmp      r4, r5                           @ Copy data segment if needed  
34. 1:     cmpne    r5, r6  
35.        ldrne       fp, [r4], #4  
36.        strne       fp, [r5], #4  
37.        bne  1b  
39.        /* 將BSS段，也即從_bss_start到_end的內存清零。 */  
41.        mov fp, #0                          @ Clear BSS (and zero fp)  
42. 1:     cmp     r6, r7  
43.        strcc       fp, [r6],#4  
44.        bcc  1b  
46.    /* r4 = processor_id, 
47.     * r5 = __machine_arch_type 
48.     * r6 = __atags_pointer 
49.     * r7 = cr_alignment 
50.     * sp = init_thread_union + THREAD_START_SP 
51.     * 為什么將棧頂指針設置為init_thread_union + THREAD_START_SP 
52.     * init_head_union 變量是一個大小為THREAD_SIZE的union，它在編譯時，放到數據段的前面。 
53.     * 初步估計這塊空間是內核堆棧。故在跳入C語言代碼時，它SP的值設置為init_thread_union + THREAD_START_SP。 
54.     * 注意THREAD_START_SP定義為THREAD_SIZE – 8，中間為什么留出8個字節呢？是與arm的堆棧操作有關嗎？ 還有用專向start_kernel函數傳遞參數？ 
55.     */  
57.        ldmia      r3, {r4, r5, r6, r7, sp}  
58.        str   r9, [r4]                 @ Save processor ID  
59.        str   r1, [r5]                 @ Save machine type  
60.        str   r2, [r6]                 @ Save atags pointer  
61.        bic   r4, r0, #CR_A                    @ Clear 'A' bit  
63.     /* cr_alignment變量的后面接着放置cr_no_alignment,  
64.      * r0為打開alignment檢測時，控制寄存器的值，而r4為關閉時的值, 
65.      * 這里分將將打開和關閉alignment檢查的控制寄存器的值寫到 
66.      * cr_alignment和cr_no_alignement變量中。 
67.      */  
69.        stmia      r7, {r0, r4}                  @ Save control register values  
71.      /* 跳到start_kernel函數，此函數代碼用純C來實現，它會調用各個平台的相關初始化函數， 
72.       * 來實現不同平台的初始化工作。至此，arm linux的啟動工作完成。 
73.       */  
75.        b     start_kernel  
76. ENDPROC(__mmap_switched)