1. kernel執行的史前時期和記憶體佈局

在arm平臺下，zImage.bin壓縮映象是由bootloader載入到實體記憶體，然後跳到zImage.bin裡一段程式，它專門於將被壓縮的kernel解壓縮到KERNEL_RAM_PADDR開始的一段記憶體中，接著跳進真正的kernel去執行。該kernel的執行起點是stext函式，定義於arch/arm/kernel/head.S。

在分析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程式碼以後均不會被移動。

在進入kernel程式碼前，即bootloader和自解壓縮階段，ARM未開啟MMU功能。因此kernel啟動程式碼一個重要功能是設定好相應的頁表，並開啟MMU功能。為了支援MMU功能，kernel映象中的所有符號，包括程式碼段和資料段的符號，在連結時都生成了它在開啟MMU時，所在實體記憶體地址對映到的虛擬記憶體地址。

以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函式

這裡的啟動流程指的是解壓後kernel開始執行的一部分程式碼，這部分程式碼和ARM體系結構是緊密聯絡在一起的，所以最好是將ARM ARCHITECTURE REFERENCE MANUL仔細讀讀，尤其裡面關於控制暫存器啊，MMU方面的內容～

stext函式定義在Arch/arm/kernel/head.S，它的功能是獲取處理器型別和機器型別資訊，並建立臨時的頁表，然後開啟MMU功能，並跳進第一個C語言函式start_kernel。

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

      前面說過解壓以後，程式碼會跳到解壓完成以後的vmlinux開始執行，具體從什麼地方開始執行我們可以看看生成的vmlinux.lds(arch/arm/kernel/)這個檔案：

   1. OUTPUT_ARCH(arm)  
   2. ENTRY(stext)  
   3. jiffies = jiffies_64;  
   4. SECTIONS  
   5. {  
   6.  . = 0x80000000 + 0x00008000;  
   7.  .text.head : {   
   8.   _stext = .;  
   9.   _sinittext = .;  
  10.   *(.text.h  

很明顯我們的vmlinx最開頭的section是.text.head，這裡我們不能看ENTRY的內容，以為這時候我們沒有作業系統，根本不知道如何來解析這裡的入口地址，我們只能來分析他的section(不過一般來說這裡的ENTRY和我們從seciton分析的結果是一樣的)，這裡的.text.head section我們很容易就能在arch/arm/kernel/head.S裡面找到，而且它裡面的第一個符號就是我們的stext：

# .section ".text.head", "ax"  
#   
# ENTRY(stext) 
#   
#  /* 設定CPU執行模式為SVC，並關中斷 */  
#   
#   msr  cpsr_c, #PSR_F_BIT | PSR_I_BIT | SVC_MODE @ ensure svc mode  
#   
#                                      @ and irqs disabled  
#   
#   mrc p15, 0, r9, c0, c0        @ get processor id  
#   
#   bl    __lookup_processor_type         @ r5=procinfo r9=cupid  
#   
# /* r10指向cpu對應的proc_info記錄 */  
#   
#    movs  r10, r5                         @ invalid processor (r5=0)?  
#   
#   beq __error_p                    @ yes, error 'p'  
#   
#   bl    __lookup_machine_type            @ r5=machinfo  
#   
# /* r8 指向開發板對應的arch_info記錄 */  
#   
#    movs  r8, r5                           @ invalid machine (r5=0)?  
#   
#   beq __error_a                    @ yes, error 'a'  
#   
# /* __vet_atags函式涉及bootloader造知kernel實體記憶體的情況，我們暫時不分析它。 */  
#   
#   bl    __vet_atags  
#   
# /*  建立臨時頁表 */  
#   
#   bl    __create_page_tables  
  
#   /* 
#  
#    * The following calls CPU specific code in a position independent 
#  
#    * manner.  See arch/arm/mm/proc-*.S for details.  r10 = base of 
#  
#    * xxx_proc_info structure selected by __lookup_machine_type 
#  
#    * above.  On return, the CPU will be ready for the MMU to be 
#  
#    * turned on, and r0 will hold the CPU control register value. 
#  
#    */  
#   
#  /* 這裡的邏輯關係相當複雜，先是從proc_info結構中的中跳進__arm920_setup函式， 
#  
#   * 然後執__enable_mmu 函式。最後在__enable_mmu函式通過mov pc, r13來執行__switch_data， 
#  
#   * __switch_data函式在最後一條語句，魚躍龍門，跳進第一個C語言函式start_kernel。 
#    */  
#   
#   ldr   r13, __switch_data             @ address to jump to after  
#   
#                                      @ mmu has been enabled  
#   
#   adr  lr, __enable_mmu        @ return (PIC) address  
#   
#   add pc, r10, #PROCINFO_INITFUNC  
#   
# ENDPROC(stext)

 這裡的ENTRY這個巨集實際我們可以在include/linux/linkage.h裡面找到，可以看到他實際上就是宣告一個GLOBAL Symbol，後面的ENDPROC和END唯一的區別是前面的聲明瞭一個函式，可以在c裡面被呼叫。

   1. #ifndef ENTRY  
   2. #define ENTRY(name) /  
   3.   .globl name; /  
   4.   ALIGN; /  
   5.   name:  
   6. #endif  
   7. #ifndef WEAK  
   8. #define WEAK(name)     /  
   9.     .weak name;    /  
  10.     name:  
  11. #endif  
  12. #ifndef END  
  13. #define END(name) /  
  14.   .size name, .-name  
  15. #endif  
  16. /* If symbol 'name' is treated as a subroutine (gets called, and returns) 
  17.  * then please use ENDPROC to mark 'name' as STT_FUNC for the benefit of 
  18.  * static analysis tools such as stack depth analyzer. 
  19.  */  
  20. #ifndef ENDPROC  
  21. #define ENDPROC(name) /  
  22.   .type name, @function; /  
  23.   END(name)  
  24. #endif  

找到了vmlinux的起始程式碼我們就來進行分析了，先總體概括一下這部分程式碼所完成的功能，head.S會首先檢查proc和arch以及atag的有效性，然後會建立初始化頁表，並進行CPU必要的處理以後開啟MMU，並跳轉到start_kernel這個symbol開始執行後面的C程式碼。這裡有很多變數都是我們進行kernel移植時需要特別注意的，下面會一一講到。

      在這裡我們首先看看這段彙編開始跑的時候的暫存器資訊，這裡的暫存器內容實際上是同bootloader跳轉到解壓程式碼是一樣的，就是r1=arch  r2=atag addr。下面我們就具體來看看這個head.S跑的過程：

   1. msr cpsr_c, #PSR_F_BIT | PSR_I_BIT | SVC_MODE @ ensure svc mode  
   2.                     @ and irqs disabled  
   3. mrc p15, 0, r9, c0, c0      @ get processor id  

 首先進入SVC模式並關閉所有中斷，並從arm協處理器裡面讀到CPU ID，這裡的CPU主要是指arm架構相關的CPU型號，比如ARM9，ARM11等等。

3 __lookup_processor_type 函式

然後跳轉到__lookup_processor_type，這個函式定義在head-common.S裡面，這裡的bl指令會儲存當前的pc在lr裡面

 __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開發板上，那麼函式返回下面的定義：

最後__lookup_processor_type會從這個函式返回，我們具體看看這個函式：   

# __lookup_processor_type:  
#       /* adr 是相對定址，它的尋計算結果是將當前PC值加上3f符號與PC的偏移量， 
#        * 而PC是實體地址，因此r3的結果也是3f符號的實體地址 */  
#   
#        adr  r3, 3f  
#   
#       /* r5值為__proc_info_bein, r6值為__proc_ino_end，而r7值為.， 
#        * 也即3f符號的連結地址。請注意，在連結期間，__proc_info_begin和 
#        * __proc_info_end以及.均是連結地址，也即虛執地址。 
#        */  
#   
#        ldmda     r3, {r5 - r7}  
#   
#      /* r3為3f的實體地址，而r7為3f的虛擬地址。結果是r3為虛擬地址與實體地址的差值，即PHYS_OFFSET - PAGE_OFFSET。*/  
#   
#        sub  r3, r3, r7                     @ get offset between virt&phys  
#   
#      /* r5為__proc_info_begin的實體地址, 即r5指標__proc_info陣列的首地址 */  
#   
#        add r5, r5, r3                     @ convert virt addresses to  
#   
#      /* r6為__proc_info_end的實體地址 */  
#   
#        add r6, r6, r3                     @ physical address space  
#   
#      /* 讀取r5指向的__proc_info陣列元素的CPUID和mask值 */  
#   
# 1:    ldmia      r5, {r3, r4}                  @ value, mask  
#   
#      /* 將當前CPUID和mask相與，並與陣列元素中的CPUID比較是否相同 
#       * 若相同，則找到當前CPU的__proc_info定義，r5指向訪元素並返回。 
#       */  
#   
#        and  r4, r4, r9                     @ mask wanted bits  
#   
#        teq  r3, r4  
#   
#        beq 2f  
#   
#      /* r5指向下一個__proc_info元素 */  
#   
#        add r5, r5, #PROC_INFO_SZ        @ sizeof(proc_info_list)  
#   
#      /* 是否遍歷完所有__proc_info元素 */  
#   
#        cmp r5, r6  
#   
#        blo  1b  
#   
#      /* 找不到則返回NULL */  
#   
#        mov r5, #0                          @ unknown processor  
#   
# 2:    mov pc, lr  
#   
# ENDPROC(__lookup_processor_type)  
#   
#        .long       __proc_info_begin  
#        .long       __proc_info_end  
# 3:    .long       .  
#        .long       __arch_info_begin  
#        .long       __arch_info_end

他這裡的執行過程其實比較簡單就是在__proc_info_begin和__proc_info_end這個段裡面裡面去讀取我們註冊在裡面的proc_info_list這個結構體，這個結構體的定義在arch/arm/include/asm/procinfo.h，具體實現根據你使用的cpu的架構在arch/arm/mm/裡面找到具體的實現，這裡我們使用的ARM11是proc-v6.S，我們可以看看這個結構體：

   1. .section ".proc.info.init", #alloc, #execinstr  
   2. /*  
   3.  * Match any ARMv6 processor core. 
   4.  */  
   5. .type   __v6_proc_info, #object  
   6. _proc_info:  
   7. .long   0x0007b000  
   8. .long   0x0007f000  
   9. .long   PMD_TYPE_SECT | /  
  10.     PMD_SECT_BUFFERABLE | /          
  11.     PMD_SECT_CACHEABLE | /  
  12.     PMD_SECT_AP_WRITE | /  
  13.     PMD_SECT_AP_READ  
  14. .long   PMD_TYPE_SECT | /  
  15.     PMD_SECT_XN | /  
  16.     PMD_SECT_AP_WRITE | /  
  17.     PMD_SECT_AP_READ  
  18. b   __v6_setup  
  19. .long   cpu_arch_name  
  20. .long   cpu_elf_name  
  21. .long   HWCAP_SWP|HWCAP_HALF|HWCAP_THUMB|HWCAP_FAST_MULT|HWCAP_EDSP|HWCAP_JAVA  
  22. .long   cpu_v6_name  
  23. .long   v6_processor_functions   
  24. .long   v6wbi_tlb_fns  
  25. .long   v6_user_fns  
  26. .long   v6_cache_fns  
  27. .size   __v6_proc_info, . - __v6_proc_info  

對著.h我們就知道各個成員變數的含義了，他這裡lookup的過程實際上是先求出這個proc_info_list的實際實體地址，並將其內容讀出，然後將其中的mask也就是我們這裡的0x007f000與暫存器與之後與0x007b00進行比較，如果一樣的話呢就校驗成功了，如果不一樣呢就會讀下一個proc_info的資訊，因為proc一般都是隻有一個的，所以這裡一般不會迴圈，如果檢測正確暫存器就會將正確的proc_info_list的實體地址賦給暫存器，如果檢測不到就會將暫存器值賦0，然後通過LR返回

   1. bl  __lookup_machine_type       @ r5=machinfo  
   2. movs    r8, r5              @ invalid machine (r5=0)?        
   3. beq __error_a           @ yes, error 'a'  

檢測完proc_info_list以後就開始檢測machine_type了，這個函式的實現也在head－common.S裡面，__lookup_machine_type 和__lookup_processor_type像對孿生兄弟，它們的行為都是很類似的：__lookup_machine_type根據r1暫存器的機器編號到.arch.info.init段的陣列中依次查詢機器編號與r1相同的記錄。它使了與它孿生兄弟同樣的手法進行虛擬地址到實體地址的轉換計算。

我們看看它具體的實現：

   1. __lookup_machine_type:  
   2.     adr r3, 3b  
   3.     ldmia   r3, {r4, r5, r6}  
   4.     sub r3, r3, r4          @ get offset between virt&phys   
   5.     add r5, r5, r3          @ convert virt addresses to      
   6.     add r6, r6, r3          @ physical address space         
   7. 1:  ldr r3, [r5, #MACHINFO_TYPE]    @ get machine type  
   8.     teq r3, r1              @ matches loader number?         
   9.     beq 2f              @ found      
  10.     add r5, r5, #SIZEOF_MACHINE_DESC    @ next machine_desc  
  11.     cmp r5, r6  
  12.     blo 1b  
  13.     mov r5, #0              @ unknown machine  
  14. 2:  mov pc, lr  
  15. ENDPROC(__lookup_machine_type)  

這裡的過程基本上是同proc的檢查是一樣的，這裡主要檢查晶片的型別，比如我們現在的晶片是MSM7X27FFA，這也是一個結構體，它的標頭檔案在arch/arm/include/asm/arch/arch.h裡面(machine_desc)，它具體的實現根據你對晶片型別的選擇而不同，這裡我們使用的是高通的7x27,具體實現在arch/arm/mach-msm/board-msm7x27.c裡面，這些結構體最後都會註冊到_arch_info_begin和_arch_info_end段裡面，具體的大家可以看看vmlinux.lds或者system.map，這裡的lookup會根據bootloader傳過來的nr來在__arch_info裡面的相匹配的型別，沒有的話就尋找下一個machin_desk結構體，直到找到相應的結構體，並會將結構體的地址賦值給暫存器，如果沒有的話就會賦值為0的。一般來說這裡的machine_type會有好幾個，因為不同的晶片型別可能使用的都是同一個cpu架構。

       對processor和machine的檢查完以後就會檢查atags parameter的有效性，關於這個atag具體的定義我們可以在./include/asm/setup.h裡面看到，它實際是一個結構體和一個聯合體構成的結合體，裡面的size都是以字來計算的。這裡的atags param是bootloader建立的，裡面包含了ramdisk以及其他memory分配的一些資訊，儲存在boot.img頭部結構體定義的地址中，具體的大家可以看咱以後對bootloader的分析～

   1. __vet_atags:  
   2.     tst r2, #0x3            @ aligned?   
   3.     bne 1f  
   4.     ldr r5, [r2, #0]            @ is first tag ATAG_CORE?        
   5.     cmp r5, #ATAG_CORE_SIZE  
   6.     cmpne   r5, #ATAG_CORE_SIZE_EMPTY  
   7.     bne 1f  
   8.     ldr r5, [r2, #4]  
   9.     ldr r6, =ATAG_CORE  
  10.     cmp r5, r6  
  11.     bne 1f  
  12.     mov pc, lr              @ atag pointer is ok             
  13. 1:  mov r2, #0  
  14.     mov pc, lr  
  15. ENDPROC(__vet_atags)  

這裡對atag的檢查主要檢查其是不是以ATAG_CORE開頭，size對不對，基本沒什麼好分析的，程式碼也比較好看～ 下面我們來看後面一個重頭戲，就是建立初始化頁表，說實話這段內容我沒弄清楚，它需要對ARM VIRT MMU具有相當的理解，這裡我沒有太多的時間去分析spec，只是粗略了翻了ARM V7的manu，知道這裡建立的頁表是arm的secition頁表，完成記憶體開始1m記憶體的對映，這個頁表建立在kernel和atag paramert之間，一般是4000-8000之間～具體的程式碼和過程我這裡就不貼了，大家可以看看參考的連結，看看其他大蝦的分析，我還沒怎麼看明白，等以後仔細研究ARM MMU的時候再回頭來仔細研究了，不過程式碼雖然不分析，這裡有幾個重要的地址需要特別分析下～

      這幾個地址都定義在arch/arm/include/asm/memory.h，我們來稍微分析下這個標頭檔案，首先它包含了arch/memory.h，我們來看看arch/arm/mach-msm/include/mach/memory.h，在這個裡面定義了#define PHYS_OFFSET     UL(0x00200000) 這個實際上是memory的實體記憶體初始地址，這個地址和我們以前在boardconfig.h裡面定義的是一致的。然後我們再看asm/memory.h，他裡面定義了我們的memory虛擬地址的首地址#define PAGE_OFFSET     UL(CONFIG_PAGE_OFFSET)。      

      另外我們在head.S裡面看到kernel的物理或者虛擬地址的定義都有一個偏移，這個偏移又是從哪來的呢，實際我們可以從arch/arm/Makefile裡面找到：textofs-y   := 0x00008000     TEXT_OFFSET := $(textofs-y) 這樣我們再看kernel啟動時候的實體地址和連結地址，實際上它和我們前面在boardconfig.h和Makefile.boot裡面定義的都是一致的～

      建立初始化頁表以後，會首先將__switch_data這個symbol的連結地址放在sp裡面，然後獲得__enable_mmu的實體地址，然後會跳到__proc_info_list裡面的INITFUNC執行，這個偏移是定義在arch/arm/kernel/asm-offset.c裡面，實際上就是取得__proc_info_list裡面的__cpu_flush這個函式執行。

   1. ldr r13, __switch_data      @ address to jump to after       
   2.                     @ mmu has been enabled           
   3. adr lr, __enable_mmu        @ return (PIC) address  
   4. add pc, r10, #PROCINFO_INITFUNC  

這個__cpu_flush在這裡就是我們proc-v6.S裡面的__v6_setup函數了，具體它的實現我就不分析了，都是對arm控制暫存器的操作，這裡轉一下它對這部分操作的註釋，看完之後就基本知道它完成的功能了。

 /*

 *  __v6_setup

 *

 *  Initialise TLB, Caches, and MMU state ready to switch the MMU

 *  on.  Return in r0 the new CP15 C1 control register setting.

 *

 *  We automatically detect if we have a Harvard cache, and use the

 *  Harvard cache control instructions insead of the unified cache

 *  control instructions.

 *

 *  This should be able to cover all ARMv6 cores.

 *

 *  It is assumed that:       

 *  - cache type register is implemented

 */    

        完成這部分關於CPU的操作以後，下面就是開啟MMU了，這部分內容也沒什麼好說的，也是對arm控制暫存器的操作，開啟MMU以後我們就可以使用虛擬地址了，而不需要我們自己來進行地址的重定位，ARM硬體會完成這部分的工作。開啟MMU以後，會將SP的值賦給PC，這樣程式碼就會跳到__switch_data來執行，這個__switch_data是一個定義在head-common.S裡面的結構體，我們實際上是跳到它地一個函式指標__mmap_switched處執行的。

        這個switch的執行過程我們只是簡單看一下，前面的copy data_loc段以及清空.bss段就不用說了，它後面會將proc的資訊和machine的資訊儲存在__switch_data這個結構體裡面，而這個結構體將來會在start_kernel的setup_arch裡面被使用到。這個在後面的對start_kernel的詳細分析中會講到。另外這個switch還涉及到控制暫存器的一些操作，這裡我不沒仔細研究spec，不懂也就不說了～

4. 為kernel建立臨時頁表create_table_pages

前面提及到，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的地方。

# __create_page_tables:  
#   /* r4 = KERNEL_RAM_PADDR – 0x4000 = 0x30004000 
#    * 後面的C程式碼中的swapper_pg_dir變數，它的值也指向0x30004000 
#    * 記憶體地址，不過它的值是虛擬記憶體地址，即0xc0004000 
#    */  
#        pgtbl       r4                         @ page table address  
#   
#    /* 將從r4到KERNEL_RAP_PADDR的16K頁表空間清空。 */  
#   
#        mov r0, r4  
#        mov r3, #0  
#        add r6, r0, #0x4000  
#   
# 1:     str   r3, [r0], #4  
#        str   r3, [r0], #4  
#        str   r3, [r0], #4  
#        str   r3, [r0], #4  
#        teq  r0, r6  
#        bne  1b  
#   
#    
#      /* 還記得r10指向開發板相應的proc_info元素嗎？這裡它將的mm_mmuflags值讀到r7中。 
#       * PROCINFO_MM_MMUFLAGS值為8，可對應上面列出來的__arm920_proc_info結構或你相應開發板結構的值來檢視該mmu_flags值。 
#       * 這裡的flags就是用於設定目錄項的flags。檢視該mmu_flags的定義，發現它是要求一級頁表是section。 
#       */  
#   
#        ldr   r7, [r10, #PROCINFO_MM_MMUFLAGS] @ mm_mmuflags  
#   
#        /* 
#         * Create identity mapping for first MB of kernel to 
#         * cater for the MMU enable.  This identity mapping 
#         * will be removed by paging_init().  We use our current program 
#         * counter to determine corresponding section base address. 
#         */  
#   
#        /* r3 = ((pc >> 20) << 20) | r7， 即取PC以1M向下對齊的地址。R6 = pc >> 20也即r6 = 0x300(pgd_idx)， 
#         * 即PC對所有1M記憶體空間，在頁表中的下標。                                     
#         * R7值表明該目錄項是section，即它對映的大小是1M。故剛好一個目錄項就可以對映kernel上的1M空間。 
#         * 這個暫時的va = pa對映只建立1M大小記憶體的，而不需要建立整個kernel映象範圍的對映。 
#         * 因為這個va = pa的對映只有當前組合語言才使用，一量跳進start_kernl後，這將不會用到了。而彙編程式碼在連結時， 
#         * 已將它安排到程式碼段的最前面了。 
#   
#         mov r6, pc, lsr #20                     @ start of kernel section 
#         orr   r3, r7, r6, lsl #20         @ flags + kernel base 
#  
#        /* 將目錄內空寫到頁表相應位置，即((uint32_t *)r4)[pgd_idx] = r3 */  
#    
#        str   r3, [r4, r6, lsl #2]         @ identity mapping  
#   
#    
#        /* 上面程式碼段為[pc &(~0xfffff), (pc + 0xfffff) &(~0xfffff)]的實體記憶體空間建立了va = pa的對映關係。*/  
#   
#        /* 下面為kernel映象所佔有空間，即KERNL_START到KERNEL_END建立記憶體對映， 
#         * 對映關係為：va = pa – PHYS + PAGR_OFFSET。注意，這裡的KENEL_START是kernel空間開始的虛擬地址。 
#         * 這裡的目錄表項同樣是section，即一個項對映1M的記憶體。 
#         */  
#   
#   
#        /* KERNEL_START = PAGE_OFFSET + TEXT_OFFSET， 
#         * r0 = ((uint32_t *)(r4))[ (KERNEL_START & 0xff000000) >> 20]， 
#         * 即r0指向KERNEL_START& 0xff000000(即kernel以16M向下對齊的)虛擬地址，所在項表目錄中的位置。 
#  
#        add r0, r4,  #(KERNEL_START & 0xff000000) >> 18 
#  
#       /* r0 = ((uint32_t *)r0)[(KERNEL_START & 0x00f00000) >> 20] 
#        * 執行前r0指向kernel以16M向下對齊的虛執地址，而這裡再加上KERNEL_START未以16M向對齊部分的偏移量。 
#        * 將原來r3的值寫到頁表目錄中。R3的值就是之前已建立好va=pa對映的那個PA值。 
#        */  
#   
#        str   r3, [r0, #(KERNEL_START & 0x00f00000) >> 18]!  
#   
#       /* r6為kernel映象的尾部虛擬地址。*/  
#   
#        ldr   r6, =(KERNEL_END - 1)  
#   
#       /* 指向下一個即將要填寫的目錄項 */  
#   
#        add r0, r0, #4  
#   
#       /* r6指向KERNEL_END- 1虛擬地址所在的目錄表項的位置 */  
#   
#       add r6, r4, r6, lsr #18  
# 1:    cmp       r0, r6  
#   
#       /* 每填一個目錄項，後一個比前一個所指向的實體地址大1M。*/  
#       add r3, r3, #1 << 20  
#       strls r3, [r0], #4  
#       bls   1b  
#   
#  #ifdef CONFIG_XIP_KERNEL  
#        /* 忽略，不分析這種情況 */  
# #endif  
#   
#     /* 通常kernel的啟動引數由bootloader放到了實體記憶體的第1個M上，所以需要為RAM上的第1個M建立對映。 
#      * 上面已為PHYS_OFFSET + TEXT_OFFSET建立了對映，如果TEXT_OFFSET小於0x00100000的話， 
#      * 上面程式碼應該也為SDRAM的第一個M建立了對映，但如果大於0x0010000則不會。 
#      * 所以這裡無論如何均為SDRAM的第一個M建立對映（不知分析對否，還請指正）。 
#      */  
#        add r0, r4, #PAGE_OFFSET >> 18  
#        orr   r6, r7, #(PHYS_OFFSET & 0xff000000)  
#        .if    (PHYS_OFFSET & 0x00f00000)  
#        orr   r6, r6, #(PHYS_OFFSET & 0x00f00000)  
#        .endif  
#        str   r6, [r0]  
#   
# #ifdef CONFIG_DEBUG_LL  
#        /*略去 */  
# #if defined(CONFIG_ARCH_NETWINDER) || defined(CONFIG_ARCH_CATS)  
#        /* 略去 */  
# #endif  
#   
# #ifdef CONFIG_ARCH_RPC  
#  /* 略去 */  
# #endif  
#   
# #endif  
#   
#        mov pc, lr  
# ENDPROC(__create_page_tables) 

5. 開啟MMU

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

   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  
  25.   
  26.       /* 設定域訪問暫存器的值。這裡設定每個domain的屬性是否上面建立的頁表中， 
  27.        * 每個目錄項的damon值一起進行訪問控制檢查。具體情況請參考ARM處理器手冊。 
  28.        */  
  29.   
  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)  
  38.   
  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.  */  
  50.   
  51.        .align      5  
  52. __turn_mmu_on:  
  53.        mov r0, r0  
  54.   
  55.       /* 將r0的值寫到控制暫存器中。這裡，終於開啟MMU功能了。 
  56.        * 查閱手冊說控制暫存器的0位置1表示開啟MMU，但這裡r0的第0是多少呢（還請大家指正） 
  57.        */  
  58.   
  59.        mcr p15, 0, r0, c1, c0, 0           @ write control reg  
  60.        mrc p15, 0, r3, c0, c0, 0           @ read id reg  
  61.   
  62.      /* 這裡的兩個mov似乎是否流水線有關的，開啟MMU語句後面幾條是不能進行記憶體定址的。但仍未搞明白具體東西的。*/  
  63.        mov r3, r3  
  64.        mov r3, r3  
  65.   
  66.      /* 轉跳到r13的函式中去，r13為__mmap_switched函式的虛擬地址， 
  67.       * 從stext函式的未尾可以找到它的賦值。故從此開始pc的值就真正在記憶體的虛擬地址空間了。 
  68.       */  
  69.   
  70.        mov pc, r13  
  71. ENDPROC(__turn_mmu_on)  

6.__mmap_switched函式

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

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

#       .type       __switch_data, %object  
# __switch_data:  
#        .long       __mmap_switched  
#        .long       __data_loc                  @ r4  
#        .long       _data                           @ r5  
#        .long       __bss_start                  @ r6  
#        .long       _end                            @ r7  
#        .long       processor_id               @ r4  
#        .long       __machine_arch_type         @ r5  
#        .long       __atags_pointer                  @ r6  
#        .long       cr_alignment                @ r7  
#        .long       init_thread_union + THREAD_START_SP @ sp  
#    
# /* 
#  * The following fragment of code is executed with the MMU on in MMU mode, 
#  * and uses absolute addresses; this is not position independent. 
#  * 
#  *  r0  = cp#15 control register 
#  *  r1  = machine ID 
#  *  r2  = atags pointer 
#  *  r9  = processor ID 
#  */  
# __mmap_switched:  
#        adr  r3, __switch_data + 4  
#        /* r4 = __data_loc, r5 = _data, r6 = _bss_start, r7 = _end */  
#        ldmia      r3!, {r4, r5, r6, r7}  
#   
#       /* 下面這段程式碼類似於這段C程式碼, 即將整個資料段從__data_loc拷貝到_data段。 
#        * if (__data_loc  == _data || _data != _bass_start) 
#        *    memcpy(_data, __data_loc, _bss_start - _data); 
#        */  
#   
#        cmp      r4, r5                           @ Copy data segment if needed  
# 1:     cmpne    r5, r6  
#        ldrne       fp, [r4], #4  
#        strne       fp, [r5], #4  
#        bne  1b  
#   
#        /* 將BSS段，也即從_bss_start到_end的記憶體清零。 */  
#   
#        mov fp, #0                          @ Clear BSS (and zero fp)  
# 1:     cmp     r6, r7  
#        strcc       fp, [r6],#4  
#        bcc  1b  
#   
#    /* r4 = processor_id, 
#     * r5 = __machine_arch_type 
#     * r6 = __atags_pointer 
#     * r7 = cr_alignment 
#     * sp = init_thread_union + THREAD_START_SP 
#     * 為什麼將棧頂指標設定為init_thread_union + THREAD_START_SP 
#     * init_head_union 變數是一個大小為THREAD_SIZE的union，它在編譯時，放到資料段的前面。 
#     * 初步估計這塊空間是核心堆疊。故在跳入C語言程式碼時，它SP的值設定為init_thread_union + THREAD_START_SP。 
#     * 注意THREAD_START_SP定義為THREAD_SIZE – 8，中間為什麼留出8個位元組呢？是與ARM的堆疊操作有關嗎？ 還有用專向start_kernel函式傳遞引數？ 
#     */  
#    
#        ldmia      r3, {r4, r5, r6, r7, sp}  
#        str   r9, [r4]                 @ Save processor ID  
#        str   r1, [r5]                 @ Save machine type  
#        str   r2, [r6]                 @ Save atags pointer  
#        bic   r4, r0, #CR_A                    @ Clear 'A' bit  
#   
#     /* cr_alignment變數的後面接著放置cr_no_alignment,  
#      * r0為開啟alignment檢測時，控制暫存器的值，而r4為關閉時的值, 
#      * 這裡分將將開啟和關閉alignment檢查的控制暫存器的值寫到 
#      * cr_alignment和cr_no_alignement變數中。 
#      */  
#   
#        stmia      r7, {r0, r4}                  @ Save control register values  
#   
#      /* 跳到start_kernel函式，此函式程式碼用純C來實現，它會呼叫各個平臺的相關初始化函式， 
#       * 來實現不同平臺的初始化工作。至此，arm linux的啟動工作完成。 
#       */  
#   
#        b     start_kernel  
# ENDPROC(__mmap_switched)  

        好啦，switch操作完成以後就會b start_kernel了～ 這樣就進入了c程式碼的運行了，下一篇文章仔細研究這個start_kernel的函式～～