为了从最底层来学习操作系统的一些基本原理，我们只有抛开操作系统的外衣，从最原始的硬件和编程方式来入手，才能了解到一些根本的知识。

• 什么是代码段?

• 什么是数据段?

• 数据的类型和长度

• 寻址范围

• 栈

• 实模式和保护模式

• Linux 中的分段策略

• 饭是一口一口的吃，计算机也是一步一步的发展，例如下面这张英特尔公司的 CPU 型号历史：

为了利用性能越来越强悍的计算机，操作系统的也是在逐步变得膨胀和复杂。

为了从最底层来学习操作系统的一些基本原理，我们只有抛开操作系统的外衣，从最原始的硬件和编程方式来入手，才能了解到一些根本的知识。

这篇文章我们就来继续挖掘一下，8086 这个开天辟地的处理器中，是如何利用段机制来对内存进行寻址的。

什么是代码段?

在上一篇文章：Linux 从头学 01：CPU 是如何执行一条指令的? 中，已经提到过，在处理器的内部，执行每一条指令码时，CPU 是非常机械、非常单纯地从 CS:IP 这 2 个寄存器计算得到转换后的物理地址，从这个物理地址所指向的内存地址处，读取一定长度的指令，然后交给逻辑运算单元(Arithmetic Logic Unit, ALU)去执行。

物理地址的计算方式是：CS * 16 + IP。

当 CPU 读取一条指令后，根据指令操作码它能够自动知道这条指令一共需要读取多少个字节。

指令被读取之后，IP 寄存器中的内容就会自增，指向内存中下一条指令的地址。

例如，在内存 20000H 开始的地方，存在 2 条指令：

2. mov ax, 1122H  

4. mov bx, 3344H  

当执行第一条指令时，CS = 2000H，IP = 0000H，经过地址转换之后的物理地址是：2000H * 16 + 0000 = 20000H(乘以 16 也就表示十六进制的数左移 1 位)：

当第一条指令码 B8 22 11 这 3 个字节被读取之后，IP 寄存器中的内容自动增加 3`，从而指向下一条指令：

当第二条指令码 BB 44 33 这 3 个字节被读取之后，IP 寄存器中的内容又增加 3，变为 0006H。

正如上篇文章所写，CPU 只是反复的从 CS:IP 指向的内存地址中读取指令码、执行指令，再读取指令码、再执行指令。

可以看出，要完成一个有意义的工作，所有的指令码必须集中在一起，统一放在内存中某个确定的地址空间中，才能被 CPU 依次的读取、执行。

内存中的这块地址空间就叫做一个段，又因为这个段中存储的是代码编译得到的指令，因此又称作代码段。

因此，用来对代码段进行寻址的这两个寄存器 CS 和 IP，它们的含义就非常清楚了：

CS: 段寄存器，其中的值左移 1 位之后，得到的值就表示代码段在内存中的首地址，或者称作基地址;

IP: 指令指针寄存器，表示一条指令的地址，距离基地址的偏移量，也就是说，IP 寄存器是用来帮助 CPU 记住：哪些指令已经被处理过了，下一个要被处理的指令是哪一个;

什么是数据段?

作为一个有意义的程序，仅仅只有指令是不够的，还必须操作数据。

这些数据也应该集中放在一起，位于内存中的某个地址空间中，这块地址空间，也是一个段，称作数据段。

也就是说：代码段和数据段，就是内存中的两个地址空间，其中分别存储了指令和数据。

可以想象一下：假如指令和数据不是分开存放的，而是夹杂放在一起，那么 CPU 在读取一条指令时，肯定就会把数据当做指令来读取、执行，就像下面这样，不发生错误才怪呢!

CPU 对内存中数据段的访问方式，与访问代码段是类似的，也是通过一个基地址，再加上一个偏移量来得到数据段中的某个物理地址。

在 8086 处理其中，数据段的段寄存器是 DS，也就是说，当 CPU 执行一条指令，这条指令需要访问数据段时，就会把 DS 这个数据段寄存器中的值左移 1 位之后得到的地址，当做数据段的基地址。

遗憾的是，CPU 中并没有提供一个类似 IP 寄存器的其他寄存器，来表示数据段的偏移地址寄存器。

这其实并不是坏事，因为一个程序在处理数据时，需要对数据进行什么样操作，程序的开发者是最清楚的，因此我们就可以用更灵活的方式来告诉 CPU 应该如何计算数据的偏移地址。

就像猴子掰苞米一样，不需要按照顺序来掰，想掰哪个就掰哪个。同样的，程序在操作数据时，无论操作哪一个数据，直接给出该数据的偏移地址的值就可以了。

数据的类型和长度

但是，在操作数据段中每一个数据，有一个比较重要的概念需要时刻铭记：数据的类型是什么，这个数据在内存中占据的字节数是多少。

我们在高级语言编程中(eg: C 语言)，在定义一个变量的时候，必须明确这个变量的类型是什么。一旦类型确定了，那么它在被加载到内存中之后，所占据的空间大小也就确定了。

比如下面这张图:

假设 30000H 是数据段的基地址(也就意味着 DS 寄存器中的内容是 3000H)，那么 30000H 地址处的数据大小是多少：11H?2211H?还是 44332211H?

这几个都有可能，因为没有确定数据的类型!

我们知道，在 C 语言中，假如有一个指针 ptr 最终指向了这里的 30000H 物理地址处(C 代码中的 ptr 是虚拟地址，经过地址转换之后执行这里的 30000H 物理地址)。

如果 ptr 定义成：

1. char *ptr; 

那么可以说 ptr 指针指向的数值是 11H。

如果 ptr 定义成：

1. int *ptrt; 

就可以说 ptr 指针指向的数值就是 44332211H(假设是小端格式)。

也就是说，指针 ptr 指向的数据，取决于定义指针变量时的类型。

这是高级语言中的情况，那么在汇编语言中呢?

PS: 之前我曾说过，文章的主要目的是学习 Linux 操作系统，但是为了学习一些相对底层的内容，在开始阶段必须抛开操作系统的外衣，进入到硬件最近的地方去看。

但是该怎么看呢?还是要借助一些原始的手段和工具，那么汇编代码无疑就是最好的、也是唯一的手段;

不过，涉及到的汇编代码都是最简单的，仅仅是为了说明原理;

在汇编语言中，CPU 是通过指令码中的相关寄存器来判断操作数据的长度。

在上一篇文章中说过，相对于寄存器来说，CPU 操作内存的速度是很慢的。

因此，CPU 在对数据段中的数据进行处理的时候，一般都是先把原始数据读取到通用寄存器中(比如：ax, bx, cx dx)，然后进行计算。

得到计算结果之后，再把结果写回到内存的数据段中(如果需要的话)。

那么 CPU 在读写数据时，就根据指令码中使用的寄存器，来决定读写数据的长度。例如:

1. mov ax, [0] 

其中的 [0] 表示内存的数据段中偏移地址是 0 的位置。

CPU 在执行这条指令的时候，就会到 30000H(假设此时数据段寄存器 DS 的值为 3000H) 这个物理地址处，取出 2 个字节的数据，放到通用寄存器 ax 中，此时 ax 寄存器中的值就是 2211H。

为什么取出 2 个字节?因为 ax 寄存器的长度是 16 位，就是 2 个字节。

那如果只想取 1 个字节，该怎么办?

16 位的通用寄存器 ax 可以拆成 2 个 8 位的寄存器里使用：ah 和 al。

1. mov al, [0] 

因为指令码中的 al 寄存器是 8 位，因此 CPU 就只读取 30000H 处的一个字节 11，放到 al 寄存器中。(此时 ax 寄存器的高 8 位，也就是 ah 中的值保持不变)

那如果想取 3 个字节或 4 个字节怎么办?

作为相当古老的处理器，8086 CPU 中是 16 位的，只能对 8 位或 16 位的数据进行操作。

寻址范围

从以上内容可以总结得出：

代码段和数据段都是通过 【基地址 + 偏移地址】的方式进行寻址;

基地址都放在各自的段寄存器中，CPU 会自动把段寄存器的值，左移 1 位之后，作为段的基地址;

偏移地址决定了段中的每一个具体的地址，最大偏移地址是 16 个 bit1，也即是 64KB 的空间;

注意：这里的段寄存器左移 1 位，是指十六进制的左移，相当于是乘以 16，因此段的基地址都是 16 的倍数。

我们再来看一下这里的 64 KB 空间，与 20 根地址线有什么瓜葛。

上篇文章说到：8086 处理器有 20 根地址线，一共可以表示 1MB 的内存空间，即使给它更大的空间，它也没有福气去享受，因为寻址不到大于 1 MB 的地址空间啊!

这 1MB 的内存空间，就可以分割为很多个段。

例如：第 1 个段的地址范围是：

我们来计算最后一个段的空间。

段寄存器和偏移地址都取最大值，就是 FFFF:FFFF，先偏移再相加：FFFF0 + FFFF = 10FFEF =1M + 64K - 16Bytes。

超过了 1 MB 的空间大小，但是毕竟只有 20 根地址线，肯定是无法寻址超过 1 MB 地址空间的，因此系统会采取回绕的方式来定位到一个地址空间，类似与数学中的取模操作。

此外还有一点，在表示一个内存地址的时候，一般不会直接给出物理地址的值(比如：3000A)，而是使用 段地址:偏移地址 这样的形式来表示(比如：3000:000A)。

栈

栈也是数据空间的一种，只不过它的操作方式有些特殊而已。

栈的操作方式就是 4 个字：后进先出。

在上面介绍数据段的时候，我们都是在指令码中手动对数据的偏移地址进行设置，指哪打哪，因为这些数据放在什么位置、表示什么意思、怎么来使用，开发者自己心里最门清。

但是栈有些不一样，虽然它的功能也是用来存储数据的，但是操作栈的方式，是由处理器提供的一些专门的指令来操作的：push 和 pop。

• push(入栈): 往栈空间中放入一个数据;

• pop(出栈): 从栈空间中弹出一个数据;

注意：这里的数据是固定 2 个字节，也就是一个字。

写过 C/C++ 程序的小伙伴都知道：在函数调用的时候，存在入栈操作;在函数返回的时候，存在出栈操作。

既然栈也是指一块内存空间，那么也就是表现为内存中的一个段。

既然是一个段，那肯定就存在一个段寄存器，用来代表它的基地址，这个栈的段寄存器就是 SS。

此外，由于栈在入栈和出栈的时候，是按照连续的地址顺序操作的，因此处理器为栈也提供了一个偏移地址寄存器：SP(称作：栈顶指针)，指向栈空间中最顶上的那个元素的位置。

例如下面这张图：

栈空间的基地址是 1000:0000，SS:SP 执行的地址空间是栈顶，此时栈顶中的元素是 44。

当执行下面这 2 条指令时：

1. mov ax, 1234H 

2. push as 

栈顶指针寄存器 SP 中的值首先减 2，变成 000A：

然后，再把寄存器 ax 中的值 1234H 放入 SS:SP 指向的内存单元处：

出栈的操作顺序是相反的：

1. pop bx 

首先把 SS:SP 指向的内存单元中的数据 1234H 放入寄存器 bx 中，然后把栈顶指针寄存器 SP 中的值加 2，变成 000C：

以上描述的是 8086 处理器中对栈操作的执行过程。

如果你看过其他一些栈相关的描述书籍，可以看出这里使用的是 “满递减” 的栈操作方式，另外还还有：满递增，空递减，空递增 这几种操作方式。

满：是指栈顶指针指向的那个空间中，是一个有效的数据。当一个新数据入栈时，栈顶指针先指向下一个空的位置，然后 把数据放入这个位置;

空：是指栈顶指针指向的那个空间中，是一个无效的数据。当一个新数据入栈时，先把数据放入这个位置，然后栈顶指针指向下一个空的位置;

递增：是指在数据入栈时，栈顶指针向高地址方向增长;

递减：是指在数据入栈时，栈顶指针向低地址方向递减;

实模式和保护模式

从以上对内存的寻址方式中可以看出：只要在可寻址的范围内，我们写的程序是可以对内存中任意一个位置的数据进行操作的。

这样的寻址方式，称之为实模式。实，就是实在、实际的意思，简洁、直接，没有什么弯弯绕。

既然编写代码的是人，就一定会犯一些低级的小错误。或者一些恶意的家伙，故意去操作那些不应该、不可以被操作的内存空间中的代码或数据。

为了对内存进行有效的保护，从 80386 开始，引入了 保护模式 来对内存进行寻址。

有些书籍中会提到 IA-32A 这个概念，IA-32 是英特尔 Architecture 32-bit简称，即英特尔32位体系架构，也是在386中首先采用。

虽然引进了保护模式，但是也存在实模式，即向前兼容。电脑开机后处于实模式，BIOS 加载主引导记录以及进行一些寄存器的设置之后就进入保护模式。

从 386 以后引入的保护模式下，地址线变成了 32 根，最大寻址空间可以达到 4GB。

当然，处理器中的寄存器也变成了 32 位。

我们还是用 段基址 + 偏移量 的方式来计算一个物理地址，假设段寄存器中内容为 0，偏移地址最大长度也是 32 位，那么一个段能表示的最大空间也就是 4GB 。

这也是为什么如今现代处理器中，每个进程的最大可寻址空间是 4GB(一般指的是虚拟地址)。

一句话总结：实模式和保护模式最根本的区别就是 内存是否收到保护。

Linux 中的分段策略

上面描述的分段机制是 x86 处理器中所提供的一种内存寻址机制，这仅仅是一种机制而已。

在 x86 处理器之上，运行着 Windows、Linux 获取其它操作系统。

我们开发者是面对操作系统来编程的，写出来的程序是被操作系统接管，并不是直接被 x86 处理器来接管。

相当于操作系统把应用程序和 x86 处理器之间进行了一层隔离:

因此，如何利用 x86 提供的分段机制是操作系统需要操心的问题。

而操作系统提供什么样的策略给应用程序来使用，这就是另外一个问题了。

那么，Linux 操作系统是如何来包装、使用 x86 提供的段寻址方式的呢?

是否还记得上一篇文章中的这张图：

这是 Linux2.6 版本中四个主要的段描述符，这里先不用管段描述符是什么，它们最终都是用来描述内存中的一块空间而已。

在现代操作系统中，分段和分页都是对内存的划分和管理方式，在功能上是有点重复的。

Linux 以非常有限的方式使用分段，更喜欢使用分页方式。

上面的这张图，一共定义了 4 个段，每一个段的基地址都是 0x00000000，每一个段的 Limit 都是 0xFFFFF。

从 Limit 的值可以得到：最大值是 2 的 20 次方，只有 1 MB 的空间。

但是其中的 G 字段表示了段的粒度，1 表示粒度是 4 K，因此 1 MB * 4K = 4 GB ，也就是说，段的最大空间是 4 GB。

这 4 个段的基地址和寻址范围都是一样的!主要的区别就是 Type 和 DPL 字段不同。

DPL 表示优先级，2 个用户段(代码段和数据段) 的优先级值是 3，优先级最低(值越大，优先级越低);2 个内核段(代码段和数据段)的优先级值是 0，优先级最高。

因此，可以得出 Linux 系统中的一个重要结论：逻辑地址与线性地址，在数值上是相等的，因为基地址是 0x00000000。

关于 Linux 中的内存分段和分页寻址方式更详细的内容，我们以后再慢慢聊。