之前写过一篇《CPU是如何访问内存的？》的文章，简单介绍了cpu访问内存的过程。有了之前的感性认识，这篇站在arm的角度再深度讲解一下，看完你会发现不理解arm原理就直接撸内核代码简直是耍流氓。

ARMv8中的访问内存流程

我喜欢用图的方式来说明问题，简单直接：

蓝色部分是cpu，灰色部分是内存，白色部分就是cpu访问内存的过程，也是地址转换的过程。在解释地址转换的本质前我们先理解下几个概念：

• TLB：MMU工作的过程就是查询页表的过程。如果把页表放在内存中查询的时候开销太大，因此为了提高查找效率，专门用一小片访问更快的区域存放地址转换条目。（当页表内容有变化的时候，需要清除TLB，以防止地址映射出错。）

• Caches：cpu和内存之间的缓存机制，用于提高访问速率，armv8架构的话上图的caches其实是L2 Cache，这里就不做进一步解释了。

  
  6 r# n  I9 _) S5 e4 E( W

「那么CPU是如何通过MMU和Cache来访问内存的呢？」

可以看出虚拟地址和物理地址的转换关键是过程Table Walk Unit。

虚拟地址转换为物理地址的本质

我们知道内核中的寻址空间大小是由CONFIG_ARM64_VA_BITS控制的，这里以48位为例，ARMv8中，Kernel Space的页表基地址存放在TTBR1_EL1寄存器中，User Space页表基地址存放在TTBR0_EL0寄存器中，其中内核地址空间的高位为全1，(0xFFFF0000_00000000 ~ 0xFFFFFFFF_FFFFFFFF)，用户地址空间的高位为全0，(0x00000000_00000000 ~ 0x0000FFFF_FFFFFFFF)

有了宏观概念，下面我们以内核态寻址过程为例看下是如何把虚拟地址转换为物理地址的。

我们知道linux采用了分页机制，通常采用四级页表，页全局目录(PGD)，页上级目录(PUD)，页中间目录(PMD)，页表(PTE)。如下：

• 从CR3寄存器中读取页目录所在物理页面的基址(即所谓的页目录基址)，从线性地址的第一部分获取页目录项的索引，两者相加得到页目录项的物理地址。
• 第一次读取内存得到pgd_t结构的目录项，从中取出物理页基址取出，即页上级页目录的物理基地址。
• 从线性地址的第二部分中取出页上级目录项的索引，与页上级目录基地址相加得到页上级目录项的物理地址。
• 第二次读取内存得到pud_t结构的目录项，从中取出页中间目录的物理基地址。
• 从线性地址的第三部分中取出页中间目录项的索引，与页中间目录基址相加得到页中间目录项的物理地址。
• 第三次读取内存得到pmd_t结构的目录项，从中取出页表的物理基地址。
• 从线性地址的第四部分中取出页表项的索引，与页表基址相加得到页表项的物理地址。
• 第四次读取内存得到pte_t结构的目录项，从中取出物理页的基地址。
• 从线性地址的第五部分中取出物理页内偏移量，与物理页基址相加得到最终的物理地址。
• 第五次读取内存得到最终要访问的数据。
  , S+ |! @, b# S1 z

整个过程是比较机械的，每次转换先获取物理页基地址，再从线性地址中获取索引，合成物理地址后再访问内存。不管是页表还是要访问的数据都是以页为单位存放在主存中的，因此每次访问内存时都要先获得基址，再通过索引(或偏移)在页内访问数据，因此可以将线性地址看作是若干个索引的集合。

linux中对地址转换的实现/*描述各级页表中的页表项*/
+ w  y- w$ q% y, Y3 ptypedef struct { pteval_t pte; } pte_t;
+ Z' S1 _$ E& f# Rtypedef struct { pmdval_t pmd; } pmd_t;
' ^" v. b3 u0 ]' T# [7 ?1 Ytypedef struct { pudval_t pud; } pud_t;
typedef struct { pgdval_t pgd; } pgd_t;
& \% Q8 ^; e/ ~
/*  将页表项类型转换成无符号类型 */
#define pte_val(x)        ((x).pte)
#define pmd_val(x)        ((x).pmd)
, `2 _6 u4 E1 M7 \/ U/ s# {' x: E1 g1 n#define pud_val(x)        ((x).pud)
#define pgd_val(x)        ((x).pgd)
+ V% B! v& L0 [. }- F6 X
3 ~% M' V2 |+ A& s1 ]/*  将无符号类型转换成页表项类型 */
+ q8 N# l2 k4 s: i: }, t+ I7 T#define __pte(x)        ((pte_t) { (x) } )
  s* u) q5 @# N5 a% P# {3 C6 i#define __pmd(x)        ((pmd_t) { (x) } )
#define __pud(x)        ((pud_t) { (x) } )
/ b' O) N1 c/ ~# P# v) h; K#define __pgd(x)        ((pgd_t) { (x) } )

; d$ V. W9 @/ s' x/ P/* 获取页表项的索引值 */
#define pgd_index(addr)                (((addr) >> PGDIR_SHIFT) & (PTRS_PER_PGD - 1))
#define pud_index(addr)                (((addr) >> PUD_SHIFT) & (PTRS_PER_PUD - 1))
#define pmd_index(addr)                (((addr) >> PMD_SHIFT) & (PTRS_PER_PMD - 1))
#define pte_index(addr)                (((addr) >> PAGE_SHIFT) & (PTRS_PER_PTE - 1))
  y7 W- e( k% _5 _( @$ D0 s
0 y1 q( t) N6 I7 r$ e/*  获取页表中entry的偏移值 */
* \: L( f1 `  M: d#define pgd_offset(mm, addr)        (pgd_offset_raw((mm)->pgd, (addr)))
#define pgd_offset_k(addr)        pgd_offset(&init_mm, addr)
/ e! X* `5 Q4 K* m- \8 }3 l#define pud_offset_phys(dir, addr)        (pgd_page_paddr(*(dir)) + pud_index(addr) * sizeof(pud_t))
: q; }- Q. u( p& A$ V% M#define pud_offset(dir, addr)                ((pud_t *)__va(pud_offset_phys((dir), (addr))))
#define pmd_offset_phys(dir, addr)        (pud_page_paddr(*(dir)) + pmd_index(addr) * sizeof(pmd_t))
#define pmd_offset(dir, addr)                ((pmd_t *)__va(pmd_offset_phys((dir), (addr))))
; h2 `: L% \1 W% j5 P#define pte_offset_phys(dir,addr)        (pmd_page_paddr(READ_ONCE(*(dir))) + pte_index(addr) * sizeof(pte_t))
' a& d1 |" d# u; M#define pte_offset_kernel(dir,addr)        ((pte_t *)__va(pte_offset_phys((dir), (addr))))
1 r* ^: g% |' l# h9 G) P- Y, D. i

进程在切换的时候就是根据task_struct找到mm_struct里的PGD字段，取得新进程的页全局目录，然后填充到CR3寄存器，就完成了页的切换。

下面我们动手操作一下，通过代码来深度理解下虚拟地址是如何转化为物理地址的。

#include  <linux/module.h>
$ j" S# J# D  b6 S- ?#include <linux/kernel.h>
5 I0 P  P' }1 H#include <linux/init.h>
#include <linux/sched.h>
#include <linux/pid.h>
6 e' w5 H+ |1 N  I1 Z, B7 f#include <linux/mm.h>
#include <asm/pgtable.h>
#include <asm/page.h>

MODULE_DESCRIPTION("vitual address to physics address");

! ?7 u$ E$ L% u/ ?9 q* x- Pstatic int pid;
static unsigned long va;

module_param(pid,int,0644); //从命令行传递参数（变量，类型，权限）
module_param(va,ulong,0644); //va表示的是虚拟地址

. e! ]; q7 }- P' R) C  c% u" @static int find_pgd_init(void)
4 @9 Z- q4 R; V( j5 W{
        unsigned long pa = 0; //pa表示的物理地址
        struct task_struct *pcb_tmp = NULL;
        pgd_t *pgd_tmp = NULL;
        pud_t *pud_tmp = NULL;
        pmd_t *pmd_tmp = NULL;
        pte_t *pte_tmp = NULL;
- I7 a* X6 W) g' h& }
, N3 u* t# j' H! s: s, ]% v        printk(KERN_INFO"PAGE_OFFSET = 0x%lx\n",PAGE_OFFSET);  //页表中有多少个项
    /*pud和pmd等等  在线性地址中占据多少位*/
) a. r- d( k$ s! @" A# S        printk(KERN_INFO"PGDIR_SHIFT = %d\n",PGDIR_SHIFT);
6 {. x6 F3 q8 m4 Z    //注意：在32位系统中  PGD和PUD是相同的
; h7 i+ @* l2 \. Q5 z  w/ i; Z        printk(KERN_INFO"PUD_SHIFT = %d\n",PUD_SHIFT);
        printk(KERN_INFO"PMD_SHIFT = %d\n",PMD_SHIFT);
/ a/ h- c. ~" A3 h/ H9 g        printk(KERN_INFO"PAGE_SHIFT = %d\n",PAGE_SHIFT);

        printk(KERN_INFO"PTRS_PER_PGD = %d\n",PTRS_PER_PGD); //每个PGD里面有多少个ptrs
        printk(KERN_INFO"PTRS_PER_PUD = %d\n",PTRS_PER_PUD);
        printk(KERN_INFO"PTRS_PER_PMD = %d\n",PTRS_PER_PMD); //PMD中有多少个项
( ]: q' r  q# D% t$ }+ p        printk(KERN_INFO"PTRS_PER_PTE = %d\n",PTRS_PER_PTE);
+ U; b* Y3 o! V9 v% [: I: o9 L
- w! c5 ^( H4 Q; m        printk(KERN_INFO"PAGE_MASK = 0x%lx\n",PAGE_MASK); //页的掩码

- O, Y# i2 C# ]1 L( h9 m  struct pid *p = NULL;
7 C) i6 U9 x* E  y: V& v  p = find_vpid(pid); //通过进程的pid号数字找到struct pid的结构体
  pcb_tmp = pid_task(p,PIDTYPE_PID); //通过pid的结构体找到进程的task  struct
, J, y2 w: u1 M        printk(KERN_INFO"pgd = 0x%p\n",pcb_tmp->mm->pgd);
% B/ j: j8 X! p2 J; D               // 判断给出的地址va是否合法(va&lt;vm_end)
1 |' U/ y% r' j6 u9 L3 o7 ]1 I: _    if(!find_vma(pcb_tmp->mm,va)){
  c1 ~: F0 Y, b5 R/ @8 x) j1 g; c                printk(KERN_INFO"virt_addr 0x%lx not available.\n",va);
                return 0;
! U6 G3 J7 w: ^$ q& P. ^% a        }
: m- X5 _5 _$ [        pgd_tmp = pgd_offset(pcb_tmp->mm,va);  //返回线性地址va，在页全局目录中对应表项的线性地址
) w5 U) a5 u$ U! ^- G        printk(KERN_INFO"pgd_tmp = 0x%p\n",pgd_tmp);
& j* S, R# H5 V$ A: v( \* m9 ]2 Q    //pgd_val获得pgd_tmp所指的页全局目录项
* _+ J; J+ ]" q8 l( f# [3 _, N    //pgd_val是将pgd_tmp中的值打印出来
        printk(KERN_INFO"pgd_val(*pgd_tmp) = 0x%lx\n",pgd_val(*pgd_tmp));
- v9 ?9 l  \  h6 X: O        if(pgd_none(*pgd_tmp)){  //判断pgd有没有映射
                printk(KERN_INFO"Not mapped in pgd.\n");
                return 0;
        }
( t& x$ p$ ]% N! s# e        pud_tmp = pud_offset(pgd_tmp,va); //返回va对应的页上级目录项的线性地址
* J: p) d$ M2 X+ h: _+ k! r$ g& h        printk(KERN_INFO"pud_tmp = 0x%p\n",pud_tmp);
        printk(KERN_INFO"pud_val(*pud_tmp) = 0x%lx\n",pud_val(*pud_tmp));
        if(pud_none(*pud_tmp)){
                printk(KERN_INFO"Not mapped in pud.\n");
) j6 u' [9 e' {                return 0;
        }
        pmd_tmp = pmd_offset(pud_tmp,va); //返回va在页中间目录中对应表项的线性地址
        printk(KERN_INFO"pmd_tmp = 0x%p\n",pmd_tmp);
        printk(KERN_INFO"pmd_val(*pmd_tmp) = 0x%lx\n",pmd_val(*pmd_tmp));
0 Q. q8 k! g6 h7 s1 O: ~        if(pmd_none(*pmd_tmp)){
                printk(KERN_INFO"Not mapped in pmd.\n");
                return 0;
        }
        //在这里，把原来的pte_offset_map()改成了pte_offset_kernel
        pte_tmp = pte_offset_kernel(pmd_tmp,va);  //pte指的是  找到表

        printk(KERN_INFO"pte_tmp = 0x%p\n",pte_tmp);
        printk(KERN_INFO"pte_val(*pte_tmp) = 0x%lx\n",pte_val(*pte_tmp));
        if(pte_none(*pte_tmp)){ //判断有没有映射
4 b* R" r  l1 l8 j                printk(KERN_INFO"Not mapped in pte.\n");
                return 0;
# G, ^+ S8 c( K/ N        }
& R# V! ?) M0 A% B& a; F        if(!pte_present(*pte_tmp)){
                printk(KERN_INFO"pte not in RAM.\n");
9 n/ ?3 `1 {8 ~( R( X; \9 V+ `                return 0;
  N* J5 o1 F3 i        }
- t0 Z2 p) E  N8 i        pa = (pte_val(*pte_tmp) & PAGE_MASK) ;//物理地址的计算方法
        printk(KERN_INFO"virt_addr 0x%lx in RAM Page is 0x%lx .\n",va,pa);
        //printk(KERN_INFO"contect in 0x%lx is 0x%lx\n",pa,*(unsigned long *)((char *)pa + PAGE_OFFSET));

% ?8 l$ @, ^7 d        return 0;
# x4 u8 t5 g' X& }
}

- W. f" i/ T( W  A, i7 ]# L5 g" Xstatic void __exit  find_pgd_exit(void)
{
        printk(KERN_INFO"Goodbye!\n");

}

, A# l. d8 ^; Q7 L% N8 x4 w! mmodule_init(find_pgd_init);
module_exit(find_pgd_exit);

MODULE_LICENSE("GPL");
) L, R# x: I$ ]

运行结果如下： 可以看出虚拟地址ffff99b488d48000对应的物理地址是80000000c8d48000。这个过程也是mmu的过程。

小结

我相信你已经对cpu通过MMU访问内存的本质有所掌握(还是不理解的话不要说认识我)，而且通过linux的一个实验，对其软件模拟流程也有所感性的认识。