摘要

• -内核管理包含：物理内存管理；虚拟内存管理；两者之间的映射。

• -除了内存管理模块，其他都使用虚拟地址（包括进程和内核）

• -虚拟内存空间包含：用户空间(低地址)；内核空间(高地址)

• -用户空间从低到高布局为：代码段(Text Segment); 数据段(Data Segment)；BSS段(未初始化静态变量)；堆段；内存映射段；栈地址空间段

• -多个进程看到的用户空间是独立的

• -内核空间：多个进程看到同一内核空间，但内核栈每个进程不一样

• -内核代码仅能访问内核空间

• -内核也有内核代码段, DATA 段和BSS段；位于内核空间低地址
  -内核代码也是 ELF 格式

• -虚拟内存到物理内存映射有两种方式：分段和分页，Linux 倾向于使用分页方式。

• -分段

  • -虚拟地址 = 段选择子(段寄存器) + 段内偏移量
  • -段选择子 = 段号(段表索引) + 标识位
  • -段表 = 物理基地址 + 段界限(段内偏移量范围）+ 特权等级

• -Linux 分段实现

  • -段表全称为段描述符表，放在全局标识符表中
  • -Linux 将段基地址都初始化为 0 ，不用于地址映射
  • -Linux 分段功能主要用于权限检查

• -Linux 通过分页实现映射

  • -物理内存被分成大小固定的页(4KB),物理页可在内存与硬盘间换出/换入
  • -将暂时不用的页放到硬盘中，称为换出，将需要的页加载进来，称为换入
  • -页表 = 虚拟页号 + 物理页号； 用于定位页
  • -虚拟地址 = 虚拟页号 + 页内偏移
  • -若采用单页表，32 位系统中一个页表将有 1M 页表项，占用 4MB(每项 4B)
  • -Linux 32位系统采用两级页表：页表目录（1K 项，10bit) + 页表（1K 项,10bit) (页大小(4KB，12bit))
  • -映射 4GB 内存理论需要 1K 个页表目录项 + 1K*1K = 1M 页表项，将占用 4KB + 4MB 空间
  • -因为完整的页表目录可以满足所有地址的查询，因此页表只需在对应地址有内存分配时才生成
  • -64位系统采用 4 级页表：全局页目录项 PGD+ 上级页目录项 PUD+ 中间页目录项 PMD+ 页表项 PTE

1 虚拟空间的布局

计算机中的“计算”两个字，其实说的就是两方面，第一，进程和线程对于 CPU 的使用； 第二，对于内存的管理。

内存被分成了一块一块的，并且每一块都变好了号，称为地址。通过这个地址我们就能定位到物理内存的位置。

但是对于进程来说，用的并不是内存的实际物理地址，因为如果多个进程都选择相同物理地址的话就会引起冲突。

于是就使用一种封闭开发的手段，每个项目的物理地址对于进程不可见，谁也不能直接访问这个物理地址。操作系统会给进程分配一个虚拟地址。所有进程看到的这个地址是一样的，里面的内存是从 0 开始编号的。

在程序里面，指令写入的地址是虚拟地址。例如，位置为 10M 的内存区域，操作系统会提供一种机制，将不同进程的虚拟地址和不同内存的物理地址映射起来。

当程序要访问虚拟地址的时候，由内核的数据结构进程转换，转换成不同的物理地址，这样不同的进程运行的时候，写入的是不同的物理地址，这样就不会冲突了。

1.1 规划虚拟地址空间

通过以上的原理分析，我们可以看出，操作系统的内存管理，主要分为三个方面。

第一，物理内存的管理。

第二，虚拟地址的管理

第三，虚拟地址和物理地址如何映射

以下面一个程序为例：

#include <stdio.h>
#include <stdlib.h>int max_length = 128;char * generate(int length){int i;char * buffer = (char*) malloc (length+1);if (buffer == NULL)return NULL;for (i=0; i<length; i++){buffer[i]=rand()%26+'a';}buffer[length]='\0';return buffer;
}int main(int argc, char *argv[])
{int num;char * buffer;printf ("Input the string length : ");scanf ("%d", &num);if(num > max_length){num = max_length;}buffer = generate(num);printf ("Random string is: %s\n",buffer);free (buffer);return 0;
}

根据用户输入的整数来生成字符串，最长是 128。由于字符串的长度是不固定的，因而不能提前知道，需要动态地分配内存，使用 malloc 函数。当然用完了需要释放内存，这就要使用 free 函数。

这里总结以下，这个简单地程序在对于内存管理的需求：

• 代码需要放在内存里面；
• 全局变量，例如 max_length;
• 常量字符串 "Input the string length: ";
• 函数栈，例如局部变量 num 是作为参数传给 generate 函数的，这里面涉及了函数调用，局部变量，函数参数等都是保存在函数栈上面的；
• 堆，malloc 分配内存在堆里面；
• 涉及对 glibc 的调用，所以 glibc 的代码是以 so 文件的形式存在的，也需要放在内存里面。

这里 malloc 会调用系统调用，进入内核，所以这个程序一旦运行起来，内核部分还需要分配内存：

• 内核的代码要在内存里面；
• 内核中也有全局变量；
• 每个进程都要有一个 task_struct;
• 每个进程还有一个内核栈；
• 在内核里卖弄也有动态分配的内存；
• 虚拟地址到物理地址的映射表放在哪里？

对于内存的访问，用户态的进程使用虚拟地址，内核态的也基本都是使用虚拟地址。

如果是 32 位， 有 2^32 = 4G 的虚拟内存空间，不管物理内存是不是真的有 4G。如果是 64 位，在 x86_64 下面，其实只使用了 48 位，48 位地址长度也就是对应了 256TB 的地址空间。

1.3 用户空间与内核空间

现在站在一个进程的角度去看这个虚拟空间，不用管其他进程。

对于普通进程来说，内核空间的那部分虽然在虚拟地址那里，但是不能访问。

我们从最低位开始排起，先是 Text Segmeng、Data Segment 和 BSS Segment。Text Segment 是存放二进制可执行文件代码的位置，Data Segment 存放静态变量，BSS Segment 存放未初始化的静态变量。

接下来是堆（Heap)段。堆是往高地址增长的，是用来分配内存的区域，malloc 就是在这里面分配的。

接下来的区域是 Memory Mappping Segment。这块地址可以用来把文件映射进内存，如果二进制的执行文件依赖于某个动态链接库，就是在这个区域里面将 so 文件映射到了内存中。

再下面就是栈（Stack)地址段。主线程的函数调用的函数栈就是用这里的。

如果普通进程还想进一步访问内核空间，是没办法的。如果需要进行更高权限的工作，就需要调用系统调用，进入内核。

一旦进入了内核，就换了一种视角。刚才是普通的视角，觉得整个空间是它独占的，没有其他进程存在。当然另一个进程也这么认为，因为他们互相看不到对方。

但是到了内核里面，无论是从哪个进程进来的，看到的都是同一个内核空间，看到的都是同一个进程列表。对然内核栈是各用各的，但是如果想知道的话，还是能够知道每个进程的内核栈在哪里。所以，如果要访问一些公共的数据结构，需要进程锁保护。

内核的代码访问内核的数据结构，大部分的情况下都是使用虚拟地址的，虽然内核代码权限很大，但是能够使用的虚拟地址范围也只能在内核空间，也即内核代码访问内核数据结构，只能用到图中 30 号到 39 号这些虚拟编号，不能用到 0 到 29 号，因为这些是被进程空间占用的。而且，进程有多个。你现在在内核，但是你并不知道当前指的 0 号是哪个进程的 0 号。

在内核里面也会有内核的代码，同样有 Text Segment、Data Segment 和 BSS Segment， 在启动内核的时候，内核代码也是 ELF 格式的。

2 虚拟空间到物理空间的映射

2.1 分段

规划虚拟空间的时候，是将空间分成多个段进行保存。

下面看看分段机制的原理。

分段机制下的虚拟地址由两部分组成，段选择子和段内偏移量。段选择子就保存在前面前面讲过的段寄存器里面。段选择子里面最重要的是段号，用作段表的索引。段表里面保存的是这个段的基地址、段的界限和特权等级等。虚拟地址中的段内偏移量应该位于 0 和段界限之间。如果段内偏移量是合法的，就将段基地址加上段内偏移量得到物理内存地址。

例如，将上面的虚拟空间分成以下 4 个段，用 0 ~ 3 来编号。每个段在段表中有一个项，在物理空间中，段的排列如下图右边所示。

如果要访问段 2 中偏移量 600 的虚拟地址，我们可以计算出物理地址为，段 2 基地址 2000 + 偏移量 600 = 2600。

那 Linux 是如何使用这种分段机制的呢？

在 Linux 里面，段表全称段描述符表(segment descriptors),放在全局描述符表 GDT(Global Descriptor Rable) 里面，会有下面的宏来初始化段描述符表里面的表项。

#define GDT_ENTRY_INIT(flags, base, limit) { { { \.a = ((limit) & 0xffff) | (((base) & 0xffff) << 16), \.b = (((base) & 0xff0000) >> 16) | (((flags) & 0xf0ff) << 8) | \((limit) & 0xf0000) | ((base) & 0xff000000), \} } }

一个段表相由段基地址、段界限 limit, 还有一些标识符组成。

DEFINE_PER_CPU_PAGE_ALIGNED(struct gdt_page, gdt_page) = { .gdt = {
#ifdef CONFIG_X86_64[GDT_ENTRY_KERNEL32_CS]    = GDT_ENTRY_INIT(0xc09b, 0, 0xfffff),[GDT_ENTRY_KERNEL_CS]    = GDT_ENTRY_INIT(0xa09b, 0, 0xfffff),[GDT_ENTRY_KERNEL_DS]    = GDT_ENTRY_INIT(0xc093, 0, 0xfffff),[GDT_ENTRY_DEFAULT_USER32_CS]  = GDT_ENTRY_INIT(0xc0fb, 0, 0xfffff),[GDT_ENTRY_DEFAULT_USER_DS]  = GDT_ENTRY_INIT(0xc0f3, 0, 0xfffff),[GDT_ENTRY_DEFAULT_USER_CS]  = GDT_ENTRY_INIT(0xa0fb, 0, 0xfffff),
#else[GDT_ENTRY_KERNEL_CS]    = GDT_ENTRY_INIT(0xc09a, 0, 0xfffff),[GDT_ENTRY_KERNEL_DS]    = GDT_ENTRY_INIT(0xc092, 0, 0xfffff),[GDT_ENTRY_DEFAULT_USER_CS]  = GDT_ENTRY_INIT(0xc0fa, 0, 0xfffff),[GDT_ENTRY_DEFAULT_USER_DS]  = GDT_ENTRY_INIT(0xc0f2, 0, 0xfffff),
......
#endif
} };
EXPORT_PER_CPU_SYMBOL_GPL(gdt_page);

这里面对于 64 位的和 32 位的，都定义了内核代码段、内核数据段、用户代码段和用户数据段。

另外，还会定义下面四个段选择子，指向上面的段描述符表项。在内核初始化的时候，启动第一个用户态进程的时候，即使将这四个选择子复制给段寄存器。

#define __KERNEL_CS      (GDT_ENTRY_KERNEL_CS*8)
#define __KERNEL_DS      (GDT_ENTRY_KERNEL_DS*8)
#define __USER_DS      (GDT_ENTRY_DEFAULT_USER_DS*8 + 3)
#define __USER_CS      (GDT_ENTRY_DEFAULT_USER_CS*8 + 3)

通过分析，我们发现，所有的段的起始地址都是一样的，都是 0。在 Linux 操作系统中，实际上并没有用到全部的分段功能。只是用到了部分分段功能，分段可以做权限审核，例如用户态 DPL 是 3, 内核态 DPL 是 0。当用户态试图访问内核态的时候，会因为权限不足而报错。

2.2 分页

其实 Linux 倾向于另外一种从虚拟地址到物理地址的转换方式，称为分页(Paging）

对于物理内存，操作系统把它分成一块一块大小相同的页，这样更方便管理，例如有的内存页面长时间不用了，可以暂时写到硬盘上，称为换出。一旦需要的时候，再加载进来，叫做换入。这样可以扩大可用物理内存的大小，提高物理内存的利用率。

这个换入和换出都是以页为单位的。页面的大小一般为 4KB。为了能够定位和访问每个页，需要有个页表，保存每个页的起始地址，再加上在页内的偏移量，组成线性地址，就能对内存中的每个位置进行访问了。

虚拟地址分为两部分，页号和页内偏移量。页号作为页表的索引，页表包含每页所在物理内存的基地址。这个基地址与页内偏移的组合就形成了物理内存地址。

下图是页表的例子，虚拟内存中的页通过页表映射为物理内存中的页。

32 位环境下，虚拟地址空间共 4GB。如果分成 4KB 一个页，那就是 1M 个页。每个页表需要 4 个字节来存储，那么整个 4GB 空间的映射就需要 4MB 的内存来存储映射表。如果每个进程都有自己的映射表，100 个进程就需要 400MB 的内存。对于内核来讲，有点大了。

页表中所有页表项必须提前建好，并且要求是连续的。如果不连续，就没有办法通过虚拟地址里面的页号找到对应的页表项了。

占用内存太大，应该怎样解决呢？我们试着将页表再分页，4G 的空间需要 4M 的页表来存储映射。我们把 4M 分成 1K（1024）个 4K, 每个 4K 又能放在一页里面，这样 1K 个 4K 就是 1K 个页，这 1K 个页也需要一个表进行管理，我们称为页目录表，这个页目录表里面有 1K 项，每项需要四个字节，页目录表大小也是 4K。

页目录表有 1K 项，用 10 位就可以表示访问页目录的哪一项。这一项其实是对应的是一整页的页表项，也即 4K 的页表项。每个页表项也是 4 个字节，因而一整页的页表项是 1K 个。再用 10 位就可以表示访问页表项的哪一项，页表项中的一项就是一个页，是存放数据的页，这个页的大小是 4K, 用 12 位就可以定位这个页内的任何一个位置。

这样加起来正好 32 位，也就是用前 10 位定位到页目录中的一项。将这一项对应的页表取出来共 1K 项，再用中间 10 位定位到页表中的一项，将这一项对应的存放数据的页取出来，再用最后 12 位定位到页中的具体位置访问数据。

如果这样的话，映射 4GB 地址空间岂不是需要 4MB + 4KB 的内存，这样不是更大了吗？当然如果页是满的，当然是更大了，但是，我们往往不会为一个进程分配那么多内存。

比如说，上面图中，我们假设只给这个进程分配了一个数据页。如果只使用页表，如果只使用页表，也需要完整的 1M 个页表项共 4M 的内存。但是如果使用了页目录，页目录需要 1K K全部分配，占用 4K, 但是里面只有一项使用了。到了页表项，只需要分配能够管理那个数据页的页表项页就可以了，也就是说，最多 4K, 这样内存就节省多了。

当然对于 64 位的系统，两级肯定不够了，就变成了四级目录，分别是全局页目录项 PGD(Page Global Directory)、上层页目录项 PUD(Page UPPER Directory) )、中间页目录项 PMD(Page Middle Directory)和页表项 PTE(Page Table Entry)。

3 总结

内存管理系统可以精细化为下面三件事情：

1. 虚拟内存的管理，将虚拟内存分成大小相等的页；
2. 物理内存的管理，将物理内存分成大小相等的页；
3. 内存映射，将虚拟内存页和物理内存页映射起来，并且在内存紧张的时候可以换出到硬盘中。

注：
查看内存空间的布局：cat /proc/$pid/maps 如 cat /proc/22528/maps

查询页大小：getconf PAGE_SIZE

参考：
趣谈 Linux 操作系统