内核启动过程，第三部分

显示模式初始化和进入保护模式

这一章是内核启动过程的第三部分，在前一章中，我们的内核启动过程之旅停在了对 set_video 函数的调用（这个函数定义在 main.c）。在这一章中，我们将接着上一章继续我们的内核启动之旅。在这一章你将读到下面的内容：

  • 显示模式的初始化，
  • 在进入保护模式之前的准备工作，
  • 正式进入保护模式

注意 如果你对保护模式一无所知，你可以查看前一章 的相关内容。另外，你也可以查看下面这些链接 以了解更多关于保护模式的内容。

就像我们前面所说的，我们将从 set_video 函数开始我们这章的内容，你可以在 arch/x86/boot/video.c 找到这个函数的定义。 这个函数首先从 boot_params.hdr 数据结构获取显示模式设置：

u16 mode = boot_params.hdr.vid_mode;

至于 boot_params.hdr 数据结构中的内容，是通过 copy_boot_params 函数实现的 （关于这个函数的实现细节请查看上一章的内容），boot_params.hdr 中的 vid_mode 是引导程序必须填入的字段。你可以在 kernel boot protocol 文档中找到关于 vid_mode 的详细信息：

Offset  Proto   Name        Meaning
/Size
01FA/2  ALL     vid_mode    Video mode control

而在 linux kernel boot protocol 文档中定义了如何通过命令行参数的方式为 vid_mode 字段传入相应的值：

**** SPECIAL COMMAND LINE OPTIONS
vga=<mode>
    <mode> here is either an integer (in C notation, either
    decimal, octal, or hexadecimal) or one of the strings
    "normal" (meaning 0xFFFF), "ext" (meaning 0xFFFE) or "ask"
    (meaning 0xFFFD).  This value should be entered into the
    vid_mode field, as it is used by the kernel before the command
    line is parsed.

根据上面的描述，我们可以通过将 vga 选项写入 grub 或者写到引导程序的配置文件，从而让内核命令行得到相应的显示模式设置信息。这个选项可以接受不同类型的值来表示相同的意思。比如你可以传入 0XFFFD 或者 ask，这2个值都表示需要显示一个菜单让用户选择想要的显示模式。下面的链接就给出了这个菜单：

video mode setup menu

通过这个菜单，用户可以选择想要进入的显示模式。不过在我们进一步了解显示模式的设置过程之前，让我们先回头了解一些重要的概念。

内核数据类型

在前面的章节中，我们已经接触到了一个类似于 u16 的内核数据类型。下面列出了更多内核支持的数据类型：

Type char short int long u8 u16 u32 u64
Size 1 2 4 8 1 2 4 8

如果你尝试阅读内核代码，最好能够牢记这些数据类型。

堆操作 API

在 set_video 函数将 vid_mod 的值设置完成之后，将调用 RESET_HEAP 宏将 HEAP 头指向 _end 符号。RESET_HEAP 宏定义在 boot.h：

#define RESET_HEAP() ((void *)( HEAP = _end ))

如果你阅读过第二部分，你应该还记得在第二部分中，我们通过 init_heap 函数完成了 HEAP 的初始化。在 boot.h 中定义了一系列的方法来操作被初始化之后的 HEAP。这些操作包括：

#define RESET_HEAP() ((void *)( HEAP = _end ))

就像我们在前面看到的，这个宏只是简单的将 HEAP 头设置到 _end 标号。在上一章中我们已经说明了 _end 标号，在 boot.h 中通过 extern char _end[]; 来引用（从这里可以看出，在内核初始化的时候堆和栈是共享内存空间的，详细的信息可以查看第一章的堆栈初始化和第二章的堆初始化）：

下面一个是 GET_HEAP 宏：

#define GET_HEAP(type, n) \
    ((type *)__get_heap(sizeof(type),__alignof__(type),(n)))

可以看出这个宏调用了 __get_heap 函数来进行内存的分配。__get_heap 需要下面3个参数来进行内存分配操作：

  • 某个数据类型所占用的字节数
  • __alignof__(type) 返回对于请求的数据类型需要怎样的对齐方式 ( 根据我的了解这个是 gcc 提供的一个功能 ）
  • n 需要分配多少个对应数据类型的对象

下面是 __get_heap 函数的实现：

static inline char *__get_heap(size_t s, size_t a, size_t n)
{
    char *tmp;

    HEAP = (char *)(((size_t)HEAP+(a-1)) & ~(a-1));
    tmp = HEAP;
    HEAP += s*n;
    return tmp;
}

现在让我们来了解这个函数是如何工作的。 这个函数首先根据对齐方式要求（参数 a ）调整 HEAP 的值，然后将 HEAP 值赋值给一个临时变量 tmp。接下来根据需要分配的对象的个数（参数 n ），预留出所需要的内存，然后将 tmp 返回给调用端。

最后一个关于 HEAP 的操作是：

static inline bool heap_free(size_t n)
{
    return (int)(heap_end - HEAP) >= (int)n;
}

这个函数简单做了一个减法 heap_end - HEAP，如果相减的结果大于请求的内存，那么就返回真，否则返回假。

我们已经看到了所有可以对 HEAP 进行操作，下面让我们继续显示模式设置过程。

设置显示模式

在我们分析了内核数据类型以及和 HEAP 相关的操作之后，让我们回来继续分析显示模式的初始化。在 RESET_HEAP() 函数被调用之后，set_video 函数接着调用 store_mode_params 函数将对应显示模式的相关参数写入 boot_params.screen_info 字段。这个字段的结构定义可以在 include/uapi/linux/screen_info.h 中找到。

store_mode_params 函数将调用 store_cursor_position 函数将当前屏幕上光标的位置保存起来。下面让我们来看 store_cursor_poistion 函数是如何实现的。

首先函数初始化一个类型为 biosregs 的变量，将其中的 AH 寄存器内容设置成 0x3，然后调用 0x10 BIOS 中断。当中断调用返回之后，DL 和 DH 寄存器分别包含了当前光标的行和列信息。接着，这2个信息将被保存到 boot_params.screen_info 字段的 orig_x 和 orig_y字段。

在 store_cursor_position 函数执行完毕之后，store_mode_params 函数将调用 store_video_mode 函数将当前使用的显示模式保存到 boot_params.screen_info.orig_video_mode。

接下來 store_mode_params 函数将根据当前显示模式的设定，给 video_segment 变量设置正确的值（实际上就是设置显示内存的起始地址）。在 BIOS 将控制权转移到引导扇区的时候，显示内存地址和显示模式的对应关系如下表所示：

0xB000:0x0000   32 Kb   Monochrome Text Video Memory
0xB800:0x0000   32 Kb   Color Text Video Memory

根据上表，如果当前显示模式是 MDA, HGC 或者单色 VGA 模式，那么 video_sgement 的值将被设置成 0xB000；如果当前显示模式是彩色模式，那么 video_segment 的值将被设置成 0xB800。在这之后，store_mode_params 函数将保存字体大小信息到 boot_params.screen_info.orig_video_points：

//保存字体大小信息
set_fs(0);
font_size = rdfs16(0x485);
boot_params.screen_info.orig_video_points = font_size;

这段代码首先调用 set_fs 函数（在 boot.h 中定义了许多类似的函数进行寄存器操作）将数字 0 放入 FS 寄存器。接着从内存地址 0x485 处获取字体大小信息并保存到 boot_params.screen_info.orig_video_points。

 x = rdfs16(0x44a);
 y = (adapter == ADAPTER_CGA) ? 25 : rdfs8(0x484)+1;

接下来代码将从地址 0x44a 处获得屏幕列信息，从地址 0x484 处获得屏幕行信息，并将它们保存到 boot_params.screen_info.orig_video_cols 和 boot_params.screen_info.orig_video_lines。到这里，store_mode_params 的执行就结束了。

接下来，set_video 函数将调用 save_screen 函数将当前屏幕上的所有信息保存到 HEAP 中。这个函数首先获得当前屏幕的所有信息（包括屏幕大小，当前光标位置，屏幕上的字符信息），并且保存到 saved_screen 结构体中。这个结构体的定义如下所示：

static struct saved_screen {
    int x, y;
    int curx, cury;
    u16 *data;
} saved;

接下来函数将检查 HEAP 中是否有足够的空间保存这个结构体的数据：

if (!heap_free(saved.x*saved.y*sizeof(u16)+512))
        return;

如果 HEAP 有足够的空间，代码将在 HEAP 中分配相应的空间并且将 saved_screen 保存到 HEAP。

接下来 set_video 函数将调用 probe_cards(0)（这个函数定义在 arch/x86/boot/video-mode.c）。 这个函数简单遍历所有的显卡，并通过调用驱动程序设置显卡所支持的显示模式：

for (card = video_cards; card < video_cards_end; card++) {
        if (card->unsafe == unsafe) {
            if (card->probe)
                card->nmodes = card->probe();
            else
                card->nmodes = 0;
        }
}

如果你仔细看上面的代码，你会发现 video_cards 这个变量并没有被声明，那么程序怎么能够正常编译执行呢？实际上很简单，它指向了一个在 arch/x86/boot/setup.ld 中定义的叫做 .videocards 的内存段：

    .videocards : {
        video_cards = .;
        *(.videocards)
        video_cards_end = .;
    }

那么这段内存里面存放的数据是什么呢，下面我们就来详细分析。在内核初始化代码中，对于每个支持的显示模式都是使用下面的代码进行定义的：

static __videocard video_vga = {
    .card_name  = "VGA",
    .probe      = vga_probe,
    .set_mode   = vga_set_mode,
};

__videocard 是一个宏定义，如下所示：

#define __videocard struct card_info __attribute__((used,section(".videocards")))

因此 __videocard 是一个 card_info 结构，这个结构定义如下：

struct card_info {
    const char *card_name;
    int (*set_mode)(struct mode_info *mode);
    int (*probe)(void);
    struct mode_info *modes;
    int nmodes;
    int unsafe;
    u16 xmode_first;
    u16 xmode_n;
};

在 .videocards 内存段实际上存放的就是所有被内核初始化代码定义的 card_info 结构（可以看成是一个数组），所以 probe_cards 函数可以使用 video_cards，通过循环遍历所有的 card_info。

在 probe_cards 执行完成之后，我们终于进入 set_video 函数的主循环了。在这个循环中，如果 vid_mode=ask，那么将显示一个菜单让用户选择想要的显示模式，然后代码将根据用户的选择或者 vid_mod 的值 ，通过调用 set_mode 函数来设置正确的显示模式。如果设置成功，循环结束，否则显示菜单让用户选择显示模式，继续进行设置显示模式的尝试。

for (;;) {
      if (mode == ASK_VGA)
          mode = mode_menu();

      if (!set_mode(mode))
          break;

      printf("Undefined video mode number: %x\n", mode);
      mode = ASK_VGA;
  }

你可以在 video-mode.c 中找到 set_mode 函数的定义。这个函数只接受一个参数，这个参数是对应的显示模式的数字表示（这个数字来自于显示模式选择菜单，或者从内核命令行参数获得）。

set_mode 函数首先检查传入的 mode 参数，然后调用 raw_set_mode 函数。而后者将遍历内核知道的所有 card_info 信息，如果发现某张显卡支持传入的模式，这调用 card_info 结构中保存的 set_mode 函数地址进行显卡显示模式的设置。以 video_vga 这个 card_info 结构来说，保存在其中的 set_mode 函数就指向了 vga_set_mode 函数。下面的代码就是 vga_set_mode 函数的实现，这个函数根据输入的 vga 显示模式，调用不同的函数完成显示模式的设置：

static int vga_set_mode(struct mode_info *mode)
{
    vga_set_basic_mode();

    force_x = mode->x;
    force_y = mode->y;

    switch (mode->mode) {
    case VIDEO_80x25:
        break;
    case VIDEO_8POINT:
        vga_set_8font();
        break;
    case VIDEO_80x43:
        vga_set_80x43();
        break;
    case VIDEO_80x28:
        vga_set_14font();
        break;
    case VIDEO_80x30:
        vga_set_80x30();
        break;
    case VIDEO_80x34:
        vga_set_80x34();
        break;
    case VIDEO_80x60:
        vga_set_80x60();
        break;
    }
    return 0;
}

在上面的代码中，每个 vga_set*** 函数只是简单调用 0x10 BIOS 中断来进行显示模式的设置。

在显卡的显示模式被正确设置之后，这个最终的显示模式被写回 boot_params.hdr.vid_mode。

接下来 set_video 函数将调用 vesa_store_edid 函数， 这个函数只是简单的将 EDID (Extended Display Identification Data) 写入内存，以便于内核访问。最后， set_video 将调用 do_restore 函数将前面保存的当前屏幕信息还原到屏幕上。

到这里为止，显示模式的设置完成，接下来我们可以切换到保护模式了。

在切换到保护模式之前的最后的准备工作

在进入保护模式之前的最后一个函数调用发生在 main.c 中的 go_to_protected_mode 函数，就像这个函数的注释说的，这个函数将进行最后的准备工作然后进入保护模式，下面就让我们来具体看看最后的准备工作是什么，以及系统是如何切换到保护模式的。

go_to_protected_mode 函数本身定义在 arch/x86/boot/pm.c。 这个函数调用了一些其他的函数进行最后的准备工作，下面就让我们来具体看看这些函数。

go_to_protected_mode 函数首先调用的是 realmode_switch_hook 函数，后者如果发现 realmode_switch hook， 那么将调用它并禁止 NMI 中断，反之将直接禁止 NMI 中断。只有当 bootloader 运行在宿主环境下（比如在 DOS 下运行 ）， hook 才会被使用。你可以在 boot protocol (see ADVANCED BOOT LOADER HOOKS) 中详细了解 hook 函数的信息。

/*
 * Invoke the realmode switch hook if present; otherwise
 * disable all interrupts.
 */
static void realmode_switch_hook(void)
{
    if (boot_params.hdr.realmode_swtch) {
        asm volatile("lcallw *%0"
                 : : "m" (boot_params.hdr.realmode_swtch)
                 : "eax", "ebx", "ecx", "edx");
    } else {
        asm volatile("cli");
        outb(0x80, 0x70); /* Disable NMI */
        io_delay();
    }
}

realmode_switch 指向了一个16 位实模式代码地址（远跳转指针），这个16位代码将禁止 NMI 中断。所以在上述代码中，如果 realmode_swtch hook 存在，代码是用了 lcallw 指令进行远函数调用。在我的环境中，因为不存在这个 hook ，所以代码是直接进入 else 部分进行了 NMI 的禁止：

asm volatile("cli");
outb(0x80, 0x70);   /* Disable NMI */
io_delay();

上面的代码首先调用 cli 汇编指令清除了中断标志 IF，这条指令执行之后，外部中断就被禁止了，紧接着的下一行代码就禁止了 NMI 中断。

这里简单介绍一下中断。中断是由硬件或者软件产生的，当中断产生的时候， CPU 将得到通知。这个时候， CPU 将停止当前指令的执行，保存当前代码的环境，然后将控制权移交到中断处理程序。当中断处理程序完成之后，将恢复中断之前的运行环境，从而被中断的代码将继续运行。 NMI 中断是一类特殊的中断，往往预示着系统发生了不可恢复的错误，所以在正常运行的操作系统中，NMI 中断是不会被禁止的，但是在进入保护模式之前，由于特殊需求，代码禁止了这类中断。我们将在后续的章节中对中断做更多的介绍，这里就不展开了。

现在让我们回到上面的代码，在 NMI 中断被禁止之后（通过写 0x80 进 CMOS 地址寄存器 0x70 ），函数接着调用了 io_delay 函数进行了短暂的延时以等待 I/O 操作完成。下面就是 io_delay 函数的实现：

static inline void io_delay(void)
{
    const u16 DELAY_PORT = 0x80;
    asm volatile("outb %%al,%0" : : "dN" (DELAY_PORT));
}

对 I/O 端口 0x80 写入任何的字节都将得到 1 ms 的延时。在上面的代码中，代码将 al 寄存器中的值写到了这个端口。在这个 io_delay 调用完成之后， realmode_switch_hook 函数就完成了所有工作，下面让我们进入下一个函数。

下一个函数调用是 enable_a20，这个函数使能 A20 line，你可以在 arch/x86/boot/a20.c 找到这个函数的定义，这个函数会尝试使用不同的方式来使能 A20 地址线。首先这个函数将调用 a20_test_short（该函数将调用 a20_test 函数） 来检测 A20 地址线是否已经被激活了：

static int a20_test(int loops)
{
    int ok = 0;
    int saved, ctr;

    set_fs(0x0000);
    set_gs(0xffff);

    saved = ctr = rdfs32(A20_TEST_ADDR);

    while (loops--) {
        wrfs32(++ctr, A20_TEST_ADDR);
        io_delay(); /* Serialize and make delay constant */
        ok = rdgs32(A20_TEST_ADDR+0x10) ^ ctr;
        if (ok)
            break;
    }

    wrfs32(saved, A20_TEST_ADDR);
    return ok;
}

这个函数首先将 0x0000 放入 FS 寄存器，将 0xffff 放入 GS 寄存器。然后通过 rdfs32 函数调用，将 A20_TEST_ADDR 内存地址的内容放入 saved 和 ctr 变量。

接下来我们使用 wrfs32 函数将更新过的 ctr 的值写入 fs:gs ，接着延时 1ms， 然后从 GS:A20_TEST_ADDR+0x10 读取内容，如果该地址内容不为0，那么 A20 已经被激活。如果 A20 没有被激活，代码将尝试使用多种方法进行 A20 地址激活。其中的一种方法就是调用 BIOS 0X15 中断激活 A20 地址线。

如果 enabled_a20 函数调用失败，显示一个错误消息并且调用 die 函数结束操作系统运行。die 函数定义在 arch/x86/boot/header.S:

die:
    hlt
    jmp die
    .size   die, .-die

A20 地址线被激活之后，reset_coprocessor 函数被调用：

outb(0, 0xf0);
outb(0, 0xf1);

这个函数非常简单，通过将 0 写入 I/O 端口 0xf0 和 0xf1 以复位数字协处理器。

接下来 mask_all_interrupts 函数将被调用：

outb(0xff, 0xa1);       /* Mask all interrupts on the secondary PIC */
outb(0xfb, 0x21);       /* Mask all but cascade on the primary PIC */

这个函数调用屏蔽了从中断控制器 (注：中断控制器的原文是 Programmable Interrupt Controller) 的所有中断，和主中断控制器上除IRQ2以外的所有中断（IRQ2是主中断控制器上的级联中断，所有从中断控制器的中断将通过这个级联中断报告给 CPU ）。

到这里位置，我们就完成了所有的准备工作，下面我们就将正式开始从实模式转换到保护模式。

设置中断描述符表

现在内核将调用 setup_idt 方法来设置中断描述符表（ IDT ）：

static void setup_idt(void)
{
    static const struct gdt_ptr null_idt = {0, 0};
    asm volatile("lidtl %0" : : "m" (null_idt));
}

上面的代码使用 lidtl 指令将 null_idt 所指向的中断描述符表引入寄存器 IDT。由于 null_idt 没有设定中断描述符表的长度（长度为 0 ），所以这段指令执行之后，实际上没有任何中断调用被设置成功（所有中断调用都是空的），在后面的章节中我们将看到正确的设置。null_idt 是一个 gdt_ptr 结构的数据，这个结构的定义如下所示：

struct gdt_ptr {
    u16 len;
    u32 ptr;
} __attribute__((packed));

在上面的定义中，我们可以看到上面这个结构包含一个 16 bit 的长度字段，和一个 32 bit 的指针字段。__attribute__((packed)) 意味着这个结构就只包含 48 bit 信息（没有字节对齐优化）。在下面一节中，我们将看到相同的结构将被导入 GDTR 寄存器（如果你还记得上一章的内容，应该记得 GDTR 寄存器是 48 bit 长度的）。

设置全局描述符表

在设置完中断描述符表之后，我们将使用 setup_gdt 函数来设置全局描述符表（关于全局描述符表，大家可以参考上一章 的内容）。在 setup_gdt 函数中，使用 boot_gdt 数组定义了需要引入 GDTR 寄存器的段描述符信息：

   //GDT_ENTRY_BOOT_CS 定义在http://lxr.free-electrons.com/source/arch/x86/include/asm/segment.h#L19 = 2
    static const u64 boot_gdt[] __attribute__((aligned(16))) = {
        [GDT_ENTRY_BOOT_CS] = GDT_ENTRY(0xc09b, 0, 0xfffff),
        [GDT_ENTRY_BOOT_DS] = GDT_ENTRY(0xc093, 0, 0xfffff),
        [GDT_ENTRY_BOOT_TSS] = GDT_ENTRY(0x0089, 4096, 103),
    };

在上面的 boot_gdt 数组中，我们定义了代码，数据和 TSS 段(Task State Segment, 任务状态段)的段描述符，因为我们并没有设置任何的中断调用（记得上面说的 null_idt吗？），所以 TSS 段并不会被使用到。TSS 段存在的唯一目的就是让 Intel 处理器能够正确进入保护模式。下面让我们详细了解一下 boot_gdt 这个数组，首先，这个数组被 __attribute__((aligned(16))) 修饰，这就意味着这个数组将以 16 字节为单位对齐。让我们通过下面的例子来了解一下什么叫 16 字节对齐：

#include <stdio.h>

struct aligned {
    int a;
}__attribute__((aligned(16)));

struct nonaligned {
    int b;
};

int main(void)
{
    struct aligned    a;
    struct nonaligned na;

    printf("Not aligned - %zu \n", sizeof(na));
    printf("Aligned - %zu \n", sizeof(a));

    return 0;
}

上面的代码可以看出，一旦指定了 16 字节对齐，即使结构中只有一个 int 类型的字段，整个结构也将占用 16 个字节：

$ gcc test.c -o test && test
Not aligned - 4
Aligned - 16

因为在 boot_gdt 的定义中， GDT_ENTRY_BOOT_CS = 2，所以在数组中有2个空项，第一项是一个空的描述符，第二项在代码中没有使用。在没有 align 16 之前，整个结构占用了（8*5=40）个字节，加了 align 16 之后，结构就占用了 48 字节 。

上面代码中出现的 GDT_ENTRY 是一个宏定义，这个宏接受 3 个参数（标志，基地址，段长度）来产生段描述符结构。让我们来具体分析上面数组中的代码段描述符（ GDT_ENTRY_BOOT_CS ）来看看这个宏是如何工作的，对于这个段，GDT_ENTRY 接受了下面 3 个参数：

  • 基地址 - 0
  • 段长度 - 0xfffff
  • 标志 - 0xc09b

上面这些数字表明，这个段的基地址是 0， 段长度是 0xfffff （ 1 MB ），而标志字段展开之后是下面的二进制数据：

1100 0000 1001 1011

这些二进制数据的具体含义如下:

  • 1 - (G) 这里为 1，表示段的实际长度是 0xfffff * 4kb = 4GB
  • 1 - (D) 表示这个段是一个32位段
  • 0 - (L) 这个代码段没有运行在 long mode
  • 0 - (AVL) Linux 没有使用
  • 0000 - 段长度的4个位
  • 1 - (P) 段已经位于内存中
  • 00 - (DPL) - 段优先级为0
  • 1 - (S) 说明这个段是一个代码或者数据段
  • 101 - 段类型为可执行/可读
  • 1 - 段可访问

关于段描述符的更详细的信息你可以从上一章中获得 上一章，你也可以阅读 Intel® 64 and IA-32 Architectures Software Developer's Manuals 3A获取全部信息。

在定义了数组之后，代码将获取 GDT 的长度：

gdt.len = sizeof(boot_gdt)-1;

接下来是将 GDT 的地址放入 gdt.ptr 中：

gdt.ptr = (u32)&boot_gdt + (ds() << 4);

这里的地址计算很简单，因为我们还在实模式，所以就是 （ ds << 4 + 数组起始地址）。

最后通过执行 lgdtl 指令将 GDT 信息写入 GDTR 寄存器：

asm volatile("lgdtl %0" : : "m" (gdt));

切换进入保护模式

go_to_protected_mode 函数在完成 IDT, GDT 初始化，并禁止了 NMI 中断之后，将调用 protected_mode_jump 函数完成从实模式到保护模式的跳转：

protected_mode_jump(boot_params.hdr.code32_start, (u32)&boot_params + (ds() << 4));

protected_mode_jump 函数定义在 arch/x86/boot/pmjump.S，它接受下面2个参数:

  • 保护模式代码的入口
  • boot_params 结构的地址

第一个参数保存在 eax 寄存器，而第二个参数保存在 edx 寄存器。

代码首先在 boot_params 地址放入 esi 寄存器，然后将 cs 寄存器内容放入 bx 寄存器，接着执行 bx << 4 + 标号为2的代码的地址，这样一来 bx 寄存器就包含了标号为2的代码的地址。接下来代码将把数据段索引放入 cx 寄存器，将 TSS 段索引放入 di 寄存器：

movw    $__BOOT_DS, %cx
movw    $__BOOT_TSS, %di

就像前面我们看到的 GDT_ENTRY_BOOT_CS 的值为2，每个段描述符都是 8 字节，所以 cx 寄存器的值将是 2*8 = 16，di 寄存器的值将是 4*8 =32。

接下来，我们通过设置 CR0 寄存器相应的位使 CPU 进入保护模式：

movl    %cr0, %edx
orb $X86_CR0_PE, %dl
movl    %edx, %cr0

在进入保护模式之后，通过一个长跳转进入 32 位代码：

    .byte   0x66, 0xea
2:  .long   in_pm32
    .word   __BOOT_CS ;(GDT_ENTRY_BOOT_CS*8) = 16，段描述符表索引

这段代码中

  • 0x66 操作符前缀允许我们混合执行 16 位和 32 位代码
  • 0xea - 跳转指令的操作符
  • in_pm32 跳转地址偏移
  • __BOOT_CS 代码段描述符索引

在执行了这个跳转命令之后，我们就在保护模式下执行代码了：

.code32
.section ".text32","ax"

保护模式代码的第一步就是重置所有的段寄存器（除了 CS 寄存器）:

GLOBAL(in_pm32)
movl    %ecx, %ds
movl    %ecx, %es
movl    %ecx, %fs
movl    %ecx, %gs
movl    %ecx, %ss

还记得我们在实模式代码中将 $__BOOT_DS （数据段描述符索引）放入了 cx 寄存器，所以上面的代码设置所有段寄存器（除了 CS 寄存器）指向数据段。接下来代码将所有的通用寄存器清 0 ：

xorl    %ecx, %ecx
xorl    %edx, %edx
xorl    %ebx, %ebx
xorl    %ebp, %ebp
xorl    %edi, %edi

最后使用长跳转跳入正在的 32 位代码（通过参数传入的地址）

jmpl    *%eax ;?jmpl cs:eax?

到这里，我们就进入了保护模式开始执行代码了，下一章我们将分析这段 32 位代码到底做了些什么。

结论

这章到这里就结束了，在下一章中我们将具体介绍这章最后跳转到的 32 位代码，并且了解系统是如何进入 long mode的。

如果你有任何的问题或者建议，你可以留言，也可以直接发消息给我twitter.

如果你发现文中描述有任何问题，请提交一个 PR 到 linux-insides-zh 。

链接

Copyright© 2013-2020

All Rights Reserved 京ICP备2023019179号-8