Staskaer

Hi, this is Staskaer

0%

从ucore来总结操作系统(1)----操作系统的镜像、引导和内核调试

Posted on Edited on In Valine:

操作系统的镜像、引导和内核调试

最近看完了《现代操作系统》一书，想着顺便找个lab做做看，体验一下写操作系统的快乐，同时加深一下对操作系统的理解。然后就看到了清华大学的ucore lab，这个lab是清华大学操作系统课程的lab，是一个很好的入门lab，所以就决定做做这个lab玩一玩。

下面给出这个lab对应的视频、github仓库和实验指导书

另外，需要注意的一点就是，这个仓库的代码是存在一些问题的，如果在比较新版本的GCC下运行，容易出现以下两个问题:

  • 生成的bootloader超过一个扇区，导致无法生成镜像
  • 内核初始化在lgdt函数中无限循环

原因是-fPIC在 GCC 的较新版本 (>=7) 中默认启用，会生成位置无关的代码，导致出错。

解决方法是：修改每个Lab中的MakeFile，为两处CFLAG添加-fno-PIC选项

0X00 环境准备

先把ucore的代码拉下来，装好对应的环境。这里要注意的，不带GUI的linux似乎是不可以的(得用X11转发，我觉得挺麻烦的，没弄)。我一开始打算直接vscode+remote ssh来做，然后在make debug的时候报错。猜测是使用QEMU硬件模拟器的问题。

ucore就是一个简单的操作系统，真实操作系统的部分它一个不少，但是它的目的是让我们学习操作系统的原理，所以它的代码量是很少的。同时呢，它也避开了各种先进CPU的奇奇怪怪的特性，针对的是i386这种比较简单的CPU。

但是很明显，我们很难找到一台i386的机器，所以我们需要一个模拟器来模拟这个CPU。这里我们使用的是QEMU，它是一个开源的模拟器，可以模拟很多CPU，包括i386。但是，QEMU是一个硬件模拟器，它模拟的是CPU、内存、硬盘、网卡等等，而不是一个操作系统。

因此，想要运行ucore这个操作系统，就只需要把它制作成一个镜像，然后使用QEMU来运行这个镜像就可以了。

0X01 ucore的镜像

其实，ucore的镜像制作并不需要我们去实现，进入到lab1文件夹中，执行make就会在./bin/中编译出多个程序，其中就包括ucore.img这个镜像文件。我们主要就是来分析一下这个镜像文件是怎么做的，这也是lab1中练习1的内容。

其实只要执行make V=就能更清楚的看到编译的过程，这里就不贴出来了。

我画了一个流程图来表示生成过程

上图中的蓝色的表示为源文件，黄色的为最终bin目录中存在的文件。

制作一个镜像，首先需要编译出整个系统，因此需要把kern/*的文件全部编译出来，这个目录下的文件涉及到了操作系统的内核，包括进程管理、内存管理、中断处理、调试和驱动等等。其中中断处理用到的中断向量表是由tools/vector.c编译的程序动态生成的，因为中断向量表重复性很高。最终，就能得到一个操作系统的内核，也就是bin/kernel这个文件。

但是仅有一个操作系统内核文件是不够的。系统启动时，BIOS会调用bootloader来负责将内核加载到内存中，然后跳转到内核的入口地址执行。因此，我们还需要一个bootloader，目录boot/下的文件就是用于生成这个bootloader的。有一个硬性要求是这个bootloader程序被编译后的大小不能超过512-2个字节，其中512个字节是一个扇区的大小(也就是扇区0，主引导扇区)，剩下两个字节是一个符合规范的硬盘主引导扇区的固定标志位，还有一个要求是代码的起始段地址为0x7c00，这个要求在编译时就能满足。

由于主引导扇区存在上述限制，而我们直接编译出来的bootloader显然不一定符合，我们需要一个程序来检查这个bootloader大小是否满足要求，同时再将固定位置的两个字节填上。这个程序就是tools/sign.c编译得到的。

但是们编译的可执行文件是ELF格式，存在各个段，这些段会显著增加大小，而且我们实际上也用不到这些段，所以要去掉这些段，去除的指令为objcopy -S -O binary obj/bootblock.o obj/bootblock.out。我们来看一下去除前后文件大小的比对

显然，去除前足足由4.1Kb，远远超过了限制。在去除之后就小于512B了，可以放到一个扇区内了。

再使用sign处理之后，就得到了一个512B的符合规范的主引导扇区了，这个二进制文件就是bin/bootblock。

现在我们得到了存有bootloader的bootblock，同时也得到了一个操作系统内核kernel，然后就可以开始正式组装镜像了。首先使用dd命令创建一个含有1000个块的文件，每个块大小512字节。然后把bootblock放到第一块里面，从第二个块开始，放入kernel。最后就得到了需要的镜像ucore.img了。

0X02 ucore的引导

接下来，我们使用QEMU来模拟一个硬件，并在模拟的硬件平台上使用镜像来运行操作系统，同时通过GDB来监测运行情况。

首先先改写MakeFile，让QEMU将运行的汇编指令保存

1
2
3
4
5
6

debug: $(UCOREIMG)
	$(V)$(TERMINAL) -e "$(QEMU) -S -s -d in_asm -D $(BINDIR)/q.log -parallel stdio -hda $< -serial null"
	$(V)sleep 2
	$(V)$(TERMINAL) -e "gdb -q -tui -x tools/gdbinit"

修改tools/gdbinit如下，使得GDB进去后立马进入调试，不需要其默认运行到0x7c00，我们从上电后的代码开始看。

1
2
3
4

target remote :1234
set architecture i8086

然后执行make debug来进行调试

执行b *0x7c00来设置一个断点，然后执行c来继续执行到断点，执行layout asm来显示汇编，再执行若干条代码后退出即可。

我们来看一下记录的汇编指令

可以看到，CPU上电后，指令指针寄存器的值为0xffff fff0，且对应位置是一条长跳转指令。然后剩下的这些代码是BIOS，负责检查硬件、初始化一类的，在我们的模拟中占据了绝大篇幅，我们不必细究，只需要知道BIOS在执行完后会固定跳转到0x7c00处，这个位置就是我们的bootloader。

我们可以对比一下日志中记录的0x7c00处的汇编和boot/asm.s文件中的代码段，两者其实是一样的，这更加说明了0x7c00处的代码就是我们的bootloader。

在调试过程中，可以执行layout asm来显示汇编。但是可以发现BIOS部分的日志中执行的汇编和GDB调试的时候显示的汇编是对不上的。

这是因为BIOS首先运行在16位实模式下，而gdb 默认是32bit线性地址模式，调试BIOS的16bit代码（段地址）需要手动计算地址，计算公式如下：

Linear Addr = ( cs << 4 ) + ip

如果 CS=0x0000，EIP=0xffff，则 Linear Address=0xffff0

可以使用info register查看寄存器

另外，为了正确反汇编16bit指令，可能需要在GDB中执行一下set architecture i8086

下面给出CPU上电后对镜像的引导过程：

  • 首先，CPU上电后处于实模式下，也就是直接引用物理内存，执行的第一条指令位置为0xFFFFFFF0，是一条长跳转指令，会继续执行BIOS中的代码
  • BIOS会做相当长的自检之类的功能，最后会跳转到0x7c00处，这个位置就是我们的bootloader，也就是主引导扇区的代码
  • bootloader会进入到保护模式(下面会分析源码)，然后加载内核镜像到内存中，然后跳转到内核镜像的入口处，开始执行内核代码

实模式就是采用CS:IP这样寻址，寻得是物理地址，共20位(就是8086那种寻址)

保护模式是使用GDT表，寻得是32位地址，可以寻址4G内存(本质上也是寻物理地址)

保护二字体现在CPU会在硬件上自动根据GDT、段选择子等信息，来判断访问的内存是否存在、是否合法

0X03 Bootloader的工作

因此，系统加载的关键就是这个512字节的Bootloader，它从BIOS手上接下控制权，并转入保护模式运行；它将内核加载到内存中，并将控制权交给内核。这个过程我们称之为引导。

我们的Bootloader主要就是boot/bootasm.s和boot/bootmain.c两个文件，下面我们来分析一下这两个文件。首先，先概述一下这两个文件的功能：

  • boot/bootasm.s 是汇编代码，主要是切换到保护模式
  • boot/bootmain.c 是C代码，主要是加载内核镜像到内存中，负责解析ELF格式的内核镜像

A20开关

地址线的第21位，也就是A20比较特殊。因为早期的8086只有20根地址线，寻址1Mb空间(也就是CS:IP，只有IP时只能寻址64k)。

后续的CPU，比如80396，有32根地址线，可以寻址4G空间。但是为了兼容早期的CPU，所以在80386中，引入了A20地址线，用来控制是否开启高位地址。

更具体的说，A20只是一个开关，当它打开的时候，A20线既可以为0，也可以为1，也就是正常工作；而当它关闭时，A20线只能为0。

所以，为了能让地址线全部正常工作，需要打开A20这个开关

但是由于历史原因，A20地址位由键盘控制器芯片8042管理。所以要给8042发命令激活A20。

给8042发命令时，先发送要写哪里，再发送要写什么。所以要两次写入，同时为了避免总线冲突，所以需要在汇编中存在一些循环重复测试

保护模式与A20

CR0是控制寄存器，其中包含了6个预定义标志，0位是保护允许位PE(Protedted Enable)，用于启动保护模式。如果PE位置1，则保护模式启动，如果PE=0，则在实模式下运行。

也就是说，保护模式和A20开关没有必然的关系，即使不打开A20开关也是可以开启保护模式的，只是此时无法寻址一部分空间而已。

打开A20开关只是为了在保护模式时能够"满血"寻址所有的地址位。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
# boot/bootasm.s

#include <asm.h>

#Start the CPU : switch to 32 - bit protected mode, jump into C.
#The BIOS loads this code from the first sector of the hard disk into
#memory at physical address 0x7c00 and starts executing in real mode
#with % cs = 0 % ip = 7c00.

.set PROT_MODE_CSEG,        0x8                     # kernel code segment selector
.set PROT_MODE_DSEG,        0x10                    # kernel data segment selector
.set CR0_PE_ON,             0x1                     # protected mode enable flag

#start address should be 0 : 7c00, in real mode, the beginning address of the running bootloader
.globl start

########################## 从这里开始 ##########################

start:
.code16                                             # Assemble for 16-bit mode
    # 关闭中断
    cli                                             # Disable interrupts
    cld                                             # String operations increment

#Set up the important data segment registers(DS, ES, SS).
    # 将flag置0和将段寄存器置0
    xorw %ax, %ax                                   # Segment number zero
    movw %ax, %ds                                   # -> Data Segment
    movw %ax, %es                                   # -> Extra Segment
    movw %ax, %ss                                   # -> Stack Segment

#Enable A20:
#For backwards compatibility with the earliest PCs, physical
#address line 20 is tied low, so that addresses higher than
# 1MB wrap around to zero by default.This code undoes this.
seta20.1:
    # 先等待8042键盘控制器不忙
    inb $0x64, %al                                  # Wait for not busy(8042 input buffer empty).
    testb $0x2, %al
    jnz seta20.1

    # 发送写8042输出端口的指令
    movb $0xd1, %al                                 # 0xd1 -> port 0x64
    # 这里的意思是下面写8042的P2端口
    outb %al, $0x64                                 # 0xd1 means: write data to 8042's P2 port

seta20.2:
    # 等待8042键盘控制器不忙
    inb $0x64, %al                                  # Wait for not busy(8042 input buffer empty).
    testb $0x2, %al
    jnz seta20.2

    # 打开A20
    movb $0xdf, %al                                 # 0xdf -> port 0x60
    # 这里的意思是传入8042的P2端口的具体数值，其实也就是把A20打开了
    outb %al, $0x60                                 # 0xdf = 11011111, means set P2's A20 bit(the 1 bit) to 1

#Switch from real to protected mode, using a bootstrap GDT
#and segment translation that makes virtual addresses
#identical to physical addresses, so that the
#effective memory map does not change during the switch.
    # 初始化GDT表：一个简单的GDT表和其描述符已经静态储存在引导区中，载入即可
    lgdt gdtdesc
    # 这里开启保护模式，先把cr0存入eax中，然后把eax的第0位置1，然后再把eax存入cr0中
    movl %cr0, %eax
    orl $CR0_PE_ON, %eax
    movl %eax, %cr0
    # 至此，开启了保护模式

#Jump to next instruction, but in 32 - bit code segment.
#Switches processor into 32 - bit mode.
    # 通过长跳转更新cs的基地址，这样就可以进入32位模式了
    ljmp $PROT_MODE_CSEG, $protcseg

.code32                                             # Assemble for 32-bit mode
protcseg:
#Set up the protected - mode data segment registers
    # 设置段寄存器，并建立堆栈
    movw $PROT_MODE_DSEG, %ax                       # Our data segment selector
    movw %ax, %ds                                   # -> DS: Data Segment
    movw %ax, %es                                   # -> ES: Extra Segment
    movw %ax, %fs                                   # -> FS
    movw %ax, %gs                                   # -> GS
    movw %ax, %ss                                   # -> SS: Stack Segment

#Set up the stack pointer and call into C.The stack region is from 0 --start(0x7c00)
    movl $0x0, %ebp
    movl $start, %esp
    # 转到保护模式完成，进入bootmain中
    call bootmain

#If bootmain returns(it shouldn't), loop.
# 如果bootmain返回了，就表示存在错误，就进入到一个死循环中
spin:
    jmp spin

#Bootstrap GDT
# GDT表
.p2align 2                                          # force 4 byte alignment
gdt:
    SEG_NULLASM                                     # null seg
    SEG_ASM(STA_X|STA_R, 0x0, 0xffffffff)           # code seg for bootloader and kernel
    SEG_ASM(STA_W, 0x0, 0xffffffff)                 # data seg for bootloader and kernel

gdtdesc:
    .word 0x17                                      # sizeof(gdt) - 1
    .long gdt                                       # address gdt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

// boot/bootmain.c

#include <defs.h>
#include <x86.h>
#include <elf.h>

/* *********************************************************************
 * This a dirt simple boot loader, whose sole job is to boot
 * an ELF kernel image from the first IDE hard disk.
 *
 * DISK LAYOUT
 *  * This program(bootasm.S and bootmain.c) is the bootloader.
 *    It should be stored in the first sector of the disk.
 *
 *  * The 2nd sector onward holds the kernel image.
 *
 *  * The kernel image must be in ELF format.
 *
 * BOOT UP STEPS
 *  * when the CPU boots it loads the BIOS into memory and executes it
 *
 *  * the BIOS intializes devices, sets of the interrupt routines, and
 *    reads the first sector of the boot device(e.g., hard-drive)
 *    into memory and jumps to it.
 *
 *  * Assuming this boot loader is stored in the first sector of the
 *    hard-drive, this code takes over...
 *
 *  * control starts in bootasm.S -- which sets up protected mode,
 *    and a stack so C code then run, then calls bootmain()
 *
 *  * bootmain() in this file takes over, reads in the kernel and jumps to it.
 * */
unsigned int SECTSIZE = 512;
struct elfhdr *ELFHDR = ((struct elfhdr *)0x10000); // scratch space

/* waitdisk - wait for disk ready */
// 自旋，直到磁盘就绪
static void
waitdisk(void)
{
    while ((inb(0x1F7) & 0xC0) != 0x40)
        /* do nothing */;
}

/* readsect - read a single sector at @secno into @dst */
// 读取扇区secno到dst处
static void
readsect(void *dst, uint32_t secno)
{
    // wait for disk to be ready
    // 等待磁盘就绪
    waitdisk();

    // 一些硬编码，用于读取扇区，控制磁盘驱动器的一些代码
    outb(0x1F2, 1); // count = 1
    outb(0x1F3, secno & 0xFF);
    outb(0x1F4, (secno >> 8) & 0xFF);
    outb(0x1F5, (secno >> 16) & 0xFF);
    outb(0x1F6, ((secno >> 24) & 0xF) | 0xE0);
    outb(0x1F7, 0x20); // cmd 0x20 - read sectors

    // wait for disk to be ready
    waitdisk();

    // read a sector
    // 读取到dst位置
    // 作用为从0x1F0 IO端口读取SECTSIZE / 4个双字 (4Byte)大小的数据到基址为dst的内存中
    insl(0x1F0, dst, SECTSIZE / 4);
}

/* *
 * readseg - read @count bytes at @offset from kernel into virtual address @va,
 * might copy more than asked.
 * */
// 从偏移offset处读取count字节，加载到虚拟内存va处
static void
readseg(uintptr_t va, uint32_t count, uint32_t offset)
{
    // 结束时的虚拟地址
    uintptr_t end_va = va + count;

    // round down to sector boundary
    // 从偏移offset处开始读取，向下取整到扇区边界
    va -= offset % SECTSIZE;

    // translate from bytes to sectors; kernel starts at sector 1
    // 计算读取的开始时的扇区号
    uint32_t secno = (offset / SECTSIZE) + 1;

    // If this is too slow, we could read lots of sectors at a time.
    // We'd write more to memory than asked, but it doesn't matter --
    // we load in increasing order.
    // 调用readsect不断读取
    for (; va < end_va; va += SECTSIZE, secno++)
    {
        readsect((void *)va, secno);
    }
}

/* bootmain - the entry of bootloader */
void bootmain(void)
{
    // read the 1st page off disk
    // 读取ELF格式文件的第一个块
    readseg((uintptr_t)ELFHDR, SECTSIZE * 8, 0);

    // is this a valid ELF?
    // 通过魔数来判断是否是ELF格式
    if (ELFHDR->e_magic != ELF_MAGIC)
    {
        goto bad;
    }

    struct proghdr *ph, *eph;

    // load each program segment (ignores ph flags)
    // ELF头部有描述ELF文件应加载到内存什么位置的描述表，
    // 先将描述表的头地址存在ph中，然后将描述表的尾地址存在eph中，
    ph = (struct proghdr *)((uintptr_t)ELFHDR + ELFHDR->e_phoff);
    eph = ph + ELFHDR->e_phnum;
    // 按照描述表将ELF文件中数据载入内存
    for (; ph < eph; ph++)
    {
        readseg(ph->p_va & 0xFFFFFF, ph->p_memsz, ph->p_offset);
    }

    // call the entry point from the ELF header
    // note: does not return
    // 根据ELF头部储存的入口信息，找到内核的入口
    ((void (*)(void))(ELFHDR->e_entry & 0xFFFFFF))();

bad:
    outw(0x8A00, 0x8A00);
    outw(0x8A00, 0x8E00);

    /* do nothing */
    while (1)
        ;
}

可以看到，两个文件做的事情都相当简单，无非就是打开保护，解析内核的ELF文件并进入内核。

0X04 内核调试之函数调用堆栈跟踪函数

这个其实是lab1的练习5，就是实现一下kern/debug/kdebug.c中的print_stackframe函数，这个函数的作用是打印函数调用堆栈的信息，包括函数名，函数参数，函数返回地址等等。

在实现之前，文档还贴心的介绍了一下CPU相关的寄存器：

  • esp 栈指针寄存器(extended stack pointer)，其内存放着一个指针，该指针永远指向系统栈最上面一个栈帧的栈顶。
  • ebp 基址指针寄存器(extended base pointer)，其内存放着一个指针，该指针永远指向系统栈最上面一个栈帧的底部。
  • eip 指令指针寄存器(extended instruction pointer)，永远指向当前执行的指令的内存地址。

ebp指向的堆栈位置储存着caller的ebp，以此为线索可以得到所有使用堆栈的函数ebp。而ebp+4指向的是调用时的eip，也就是返回地址。ebp+8、+12这些则是可能的参数。

虽然它要求编程，但是lab中的文件不是已经编好了嘛...所以就分析一下叭。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

void print_stackframe(void)
{
    /* LAB1 YOUR CODE : STEP 1 */
    /* (1) call read_ebp() to get the value of ebp. the type is (uint32_t);
     * (2) call read_eip() to get the value of eip. the type is (uint32_t);
     * (3) from 0 .. STACKFRAME_DEPTH
     *    (3.1) printf value of ebp, eip
     *    (3.2) (uint32_t)calling arguments [0..4] = the contents in address (unit32_t)ebp +2 [0..4]
     *    (3.3) cprintf("\n");
     *    (3.4) call print_debuginfo(eip-1) to print the C calling function name and line number, etc.
     *    (3.5) popup a calling stackframe
     *           NOTICE: the calling funciton's return addr eip  = ss:[ebp+4]
     *                   the calling funciton's ebp = ss:[ebp]
     */
    // 先读取ebp和eip的值，分别是栈底和当前指令地址
    uint32_t ebp = read_ebp();
    uint32_t eip = read_eip();
    int i, j;
    // 没有超过最大调用深度或者是ebp不为0的时候，就一直循环
    for (i = 0; i < STACKFRAME_DEPTH && ebp != 0; i++)
    {
        // 16进制输出ebp和eip的值
        cprintf("ebp:0x%08x eip:0x%08x", ebp, eip);
        // 读取ebp+2(32位数据的+2，对应了字节+8)的值，也就是第一个参数的值
        uint32_t *arg = (uint32_t *)ebp + 2;
        cprintf(" arg:");
        // 从ebp+8开始，输出4个参数的值
        // 注意小端存储哦
        for (j = 0; j < 4; j++)
        {
            cprintf("0x%08x ", arg[j]);
        }
        cprintf("\n");
        // 打印调用函数的行数和函数名
        print_debuginfo(eip - 1);
        // 重复获取上一次的ebp和eip
        eip = ((uint32_t *)ebp)[1];
        ebp = ((uint32_t *)ebp)[0];
    }
}

下面是我的一次调用结果

下面解释一下最后一行

此时ebp的值是kern_init函数的栈顶地址，从前面练习我们知道，整个栈的栈顶地址为0x00007c00，ebp指向的栈位置存放调用者的ebp寄存器的值，ebp+4指向的栈位置存放返回地址的值，这意味着kern_init函数的调用者（也就是bootmain函数）没有传递任何输入参数给它！因为单是存放旧的ebp、返回地址已经占用8字节了。

eip的值是kern_init函数的返回地址，也就是bootmain函数调用kern_init对应的指令的下一条指令的地址，反汇编bootmain函数证实了这个判断。

args:0xc031fcfa 0xc08ed88e 0x64e4d08e 0xfa7502a8：一般来说，args存放的4个元素是对应4个输入参数的值。但这里比较特殊，由于bootmain函数调用kern_init并没传递任何输入参数，并且栈顶的位置恰好在bootloader第一条指令存放的地址的上面，而args恰好是kern_int的ebp寄存器指向的栈顶往上第2~5个单元，因此args存放的就是bootloader指令的前16个字节。

(需要注意下图中的数据都是小端存储的，因此每个字节需要反过来看)

0X05 内核调试之中断初始化和处理

众所周知，中断信号发生后，需要传递中断号，然后内核根据中断号来在中断向量表中查找的对应的中断处理函数，然后执行中断处理函数。

BIOS中断、DOS中断、Linux中断的区别

  • BIOS和DOS都存在于实模式下，由它们建立的中断调用都是建立在中断向量表（Interrupt Vector Table，IVT）中的，都是通过软中断指令 int 中断号来调用。
  • BIOS 中断调用的主要功能是提供了硬件访问的方法，该方法使对硬件的操作变得简单易行。
  • DOS 是运行在实模式下的，故其建立的中断调用也建立在中断向量表中，只不过其中断向量号和BIOS的不能冲突。
  • Linux 内核是在进入保护模式后才建立中断例程的，不过在保护模式下，中断向量表已经不存在了，取而代之的是中断描述符表（Interrupt Descriptor Table，IDT）。Linux 的系统调用和DOS中断调用类似，不过Linux是通过int 0x80指令进入一个中断程序后再根据eax寄存器的值来调用不同的子功能函数的。

而中断向量表是在内核初始化的时候建立的。在ucore中，对于中断描述符表IDT的初始化，是在kern_init总控函数中通过idt_init函数进行的。

中断描述符IDT表示一个系统表，它与中断或异常向量相联系。每一个中断或异常向量在这个系统表中有对应的中断或异常处理程序入口地址。中断描述符的表每一项对应一个中断或异常向量，每个向量由8个字节组成。因此，最多需要256*8=2048 字节来存放IDT。

当中断发生时，cpu会得到一个中断向量号，作为IDT（中断描述符表）的索引，IDT表起始地址由IDTR寄存器存储，cpu会从IDT表中找到该中断向量号相应的中断服务程序入口地址，跳转到中断处理程序处执行，并保存当前现场；当中断程序执行完毕，恢复现场，跳转到原中断点处继续执行。而IDT的表项为中断描述符，主要类型有中断门、陷阱门、任务门。

中断门：包含段选择符和中断或异常处理程序的段内偏移量，当控制权转移到一个适当的段时，处理器清IF标志，从而关闭将来会发生的可屏蔽中断

陷阱门：陷阱门是一种特殊的中断门，与中断门相似，只是控制权传递到一个适当的段时处理器不修改IF标志

任务门：当中断信号发生时，必须取代当前进程的那个进程的TSS选择符存放在任务门中。

以上内容来自百度

这些门的描述符格式比较固定，在kern/mm/mmh.c中有一些宏可以直接设置：

  • SETGATE(gate, istrap, sel, off, dpl) : 设置中断、陷阱门描述符
  • SETCALLGATE(gate, ss, off, dpl) : 设置任务门描述符

而且内核所有需要用到的中断函数都被tools/vector.c程序动态生成了，所以只需要把这些写入到IDT表中就可以了。

我们先来看一下生成的kern/trap/vector.s中断表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

.text
.globl __alltraps
.globl vector0
vector0:
  pushl $0
  pushl $0
  jmp __alltraps

...省略一部分

vector255:
  pushl $0
  pushl $255
  jmp __alltraps

# vector table
.data
.globl __vectors
__vectors:
  .long vector0
  .long vector1

...剩下的省略

可以看到，前面是中断号对应的处理程序，后面是一个__vectors数组，数组中给出了对应中断号的中断处理程序的位置。而中断处理程序只是把中断号压栈，然后跳转到__alltraps函数，这个函数在kern/trap/trapentry.S中定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <memlayout.h>

# vectors.S sends all traps here.
.text
.globl __alltraps
__alltraps:
    # push registers to build a trap frame
    # therefore make the stack look like a struct trapframe
    pushl %ds
    pushl %es
    pushl %fs
    pushl %gs
    pushal

    # load GD_KDATA into %ds and %es to set up data segments for kernel
    movl $GD_KDATA, %eax
    movw %ax, %ds
    movw %ax, %es

    # push %esp to pass a pointer to the trapframe as an argument to trap()
    pushl %esp

    # call trap(tf), where tf=%esp
    # 调用trap函数
    call trap

    # pop the pushed stack pointer
    popl %esp

    # return falls through to trapret...
.globl __trapret
__trapret:
    # restore registers from stack
    popal

    # restore %ds, %es, %fs and %gs
    popl %gs
    popl %fs
    popl %es
    popl %ds

    # get rid of the trap number and error code
    addl $0x8, %esp
    iret

可以看到，这个函数就是构造一个trapframe结构体，然后调用trap函数，trap函数在kern/trap/trap.c中定义

1
2
3
4
5
6
7

void trap(struct trapframe *tf)
{
    // dispatch based on what type of trap occurred
    trap_dispatch(tf);
}

显然，ucore的所有中断都会由trap_dispatch进行实际上的处理，这个函数在kern/trap/trap.c中定义。如果我们需要修改对某个中断的处理函数，实际上也只需要在trap_dispatch函数中进行修改即可。

0x06 通过中断进行权限切换

这个实验是一个challenge的实验，就是完成通过中断从用户态(ring 3)切换到内核态(ring 0)的功能。需要先把kern/init:kern_init()中的switch_test()解注释，然后完成kern/init:lab1_switch_to_user()和kern/init:lab1_switch_to_kernel()这两个函数。

CPL、DPL、RPL与IOPL

DPL存储于段描述符中，规定访问该段的权限级别(Descriptor Privilege Level)，每个段的DPL固定。
当进程访问一个段时，需要进程特权级检查。

CPL存在于CS寄存器的低两位，即CPL是CS段描述符的DPL，是当前代码的权限级别(Current Privilege Level)。

RPL存在于段选择子中，说明的是进程对段访问的请求权限(Request Privilege Level)，是对于段选择子而言的，每个段选择子有自己的RPL。而且RPL对每个段来说不是固定的，两次访问同一段时的RPL可以不同。RPL可能会削弱CPL的作用，例如当前CPL=0的进程要访问一个数据段，它把段选择符中的RPL设为3，这样它对该段仍然只有特权为3的访问权限。

IOPL(I/O Privilege Level)即I/O特权标志，位于eflag寄存器中，用两位二进制位来表示，也称为I/O特权级字段。该字段指定了要求执行I/O指令的特权级。如 果当前的特权级别在数值上小于等于IOPL的值，那么，该I/O指令可执行，否则将发生一个保护异常。

只有当CPL=0时，可以改变IOPL的值，当CPL<=IOPL时，可以改变IF标志位。

特权级检查

在下述的特权级比较中，需要注意特权级越低，其ring值越大。

访问门时（中断、陷入、异常），要求DPL[目标代码段] <= CPL <= DPL[门]

访问门的代码权限比门的特权级要高，因为这样才能访问门。

但访问门的代码权限比被访问的段的权限要低，因为通过门的目的是访问特权级更高的段，这样就可以达到低权限应用程序使用高权限内核服务的目的。

访问段时，要求DPL[段] >= max {CPL, RPL}

只能使用CPL, RPL中最低的权限来访问段数据

在之前提到的中断描述符中，有一个DPL位，表示门权限，或者说，只有不低于门的权限的代码才能通过门。要实现从r3到r0的提权，需要先保证有一个中断门在r3就能执行，且该中断门的目标代码段在r0，这样就实现了提权。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// kern/trap/trap.c
// 先设置一个提权用的中断门

void idt_init(void)
{
    extern uintptr_t __vectors[];
    int i;
    for (i = 0; i < sizeof(idt) / 256; i++)
    {
        SETGATE(idt[i], 0, GD_KTEXT, __vectors[i], DPL_KERNEL);
    }
    // 这里设置一个提权用的门
    SETGATE(idt[T_SWITCH_TOK], 0, GD_KTEXT, __vectors[T_SWITCH_TOK], DPL_USER);
    lidt(&idt_pd);
}

另外还需要一个TSS(Task State Segment) ，它是操作系统在进行进程切换时保存进程现场信息的段，CPU能够理解TSS段，是硬件结构，需要用软件来初始化，负责保留ring0、ring1、ring2的栈(ss、esp寄存器值)。当用户程序从ring3跳至ring0时(例如执行中断)，此时的栈就会从用户栈切换到内核栈。切换栈的操作从开始中断的那一瞬间（例如：从int 0x78到中断处理例程之间）就已完成。切换栈的操作为修改esp和ss寄存器。CPU会自动从TSS读取并修改而同时TSS段的段描述符保存在GDT中，其ring0的栈会在初始化GDT时被一起设置。TR寄存器会保存当前TSS的段描述符，以提高索引速度。

那么切换栈是由谁来完成的呢？这个程序我们之前也见过，只是没有具体分析代码含义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# kern/trap/trapentry.s

#include <memlayout.h>

# vectors.S sends all traps here.
.text
.globl __alltraps
__alltraps:
    # push registers to build a trap frame
    # therefore make the stack look like a struct trapframe
    # 保护现场
    pushl %ds
    pushl %es
    pushl %fs
    pushl %gs
    pushal

    # load GD_KDATA into %ds and %es to set up data segments for kernel
    # 内核区的数据段
    movl $GD_KDATA, %eax
    movw %ax, %ds
    movw %ax, %es

    # push %esp to pass a pointer to the trapframe as an argument to trap()
    # 放入trapframe的地址，调用trap函数来处理中断
    pushl %esp

    # call trap(tf), where tf=%esp
    call trap

    # pop the pushed stack pointer
    popl %esp

    # return falls through to trapret...
.globl __trapret
__trapret:
    # restore registers from stack
    popal

    # restore %ds, %es, %fs and %gs
    popl %gs
    popl %fs
    popl %es
    popl %ds

    # get rid of the trap number and error code
    addl $0x8, %esp
    iret

优先级切换中堆栈处理步骤：

  1. 准备调用门
  2. 加载TSS，因为总共有4个优先级（ring0~3),所以每个优先级下面都对应一个堆栈。加载了TSS,就能够根据目标优先级而从TSS中获取想对应的堆栈地址
  3. 临时性保存当前，未切换前的SS_old和ESP_old的值
  4. 根据目标优先级从TSS中获取对应的对应得堆栈地址SS_new和ESP_new，并加载。（因为CPU只有一个SS和一个ESP寄存器，所以，所谓的加载，只是把新的SS_new和ESP_new的地址赋给CPU的SS和ESP寄存器）
  5. 将已经临时保存的SS_old和ESP_old的值保存到新堆栈中
  6. 将当前的CS_old和EIP_old保存入新堆栈
  7. 加载调用门中指定的新的CS和EIP,开始执行被调用者过程

优先级切换返回过程堆栈处理步骤：

  1. 加载被调用者堆栈上的CS_old和EIP_old
  2. 加载SS_old和ESP_old，切换到调用者堆栈，被调用者的SS_new和ESP_new被丢弃

特权级的转变，就是改段寄存器的selecter，还有进行堆栈的变化。CPU认为只有之前发生特权级变化时才会额外压入ss、esp，所以中断返回时如果发现弹出的cs与当前cs不一致时，除了恢复之前栈上的cs(也恢复了CPL)，同时会额外的弹出esp、ss。通过这个机制我们也能欺骗机器进行堆栈的转换

当通过陷入门从ring3切换至ring0（特权提升）时：

  • 在陷入的一瞬间，CPU会因为特权级的改变，索引TSS，切换ss和esp为内核栈，并按顺序自动压入user_ss、user_esp、user_eflags、user_cs、old_eip以及err。(需要注意的是，CPU先切换到内核栈，此时的esp与ss不再指向用户栈。但此时CPU却可以再将用户栈地址存入内核栈。这种操作可能是依赖硬件来完成的。)
  • 之后CPU会在中断处理例程入口处，先将剩余的段寄存器以及所有的通用寄存器压栈，构成一个trapframe。然后将该trapframe传入给真正的中断处理例程并执行
  • 该处理例程会判断传入的中断数(trapno)并执行特定的代码。在提升特权级的代码中，程序会处理传入的trapframe信息中的CS、DS、eflags寄存器，修改上面的DPL、CPL与IOPL以达到提升特权的目的
  • 将修改后的trapframe压入用户栈（这一步没有修改user_esp寄存器），并设置中断处理例程结束后将要弹出esp寄存器的值为用户栈的新地址（与刚刚不同，这一步修改了将要恢复的user_esp寄存器）。（这样在退出中断处理程序，准备恢复上下文的时候，首先弹出的栈寄存器值是修改后的用户栈地址，其次弹出的通用寄存器、段寄存器等等都是存储于用户栈中的trapframe。）

通过陷入门从ring0切换至ring3（特权降低） 的过程与特权提升的操作基本一样，不过有几个不同点需要注意一下：

  • 与ring3调用中断不同，当ring0调用中断时，进入中断前和进入中断后的这个过程，栈不发生改变
  • 因为在调用中断前的权限已经处于ring0了，而中断处理程序里的权限也是ring0，所以这一步陷入操作的特权级没有发生改变，故不需要访问TSS并重新设置ss 、esp寄存器。
  • 修改后的trapFrame不需要像上面那样保存至将要使用的栈，因为当前环境下iret前后特权级会发生改变，执行该命令会弹出ss和esp，所以可以通过iret来设置返回时的栈地址。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

// kern/init/init.c

static void lab1_switch_to_user(void) {
    //LAB1 CHALLENGE 1 : TODO
	asm volatile (
	    "sub $0x8, %%esp \n"
	    "int %0 \n"
	    "movl %%ebp, %%esp"
	    : 
	    : "i"(T_SWITCH_TOU)
	);
}

static void lab1_switch_to_kernel(void) {
    //LAB1 CHALLENGE 1 :  TODO
	asm volatile (
	    "int %0 \n"
	    "movl %%ebp, %%esp \n"
	    : 
	    : "i"(T_SWITCH_TOK)
	);
}

// kern/trap/trap.c
struct trapframe switchk2u, *switchu2k;

static void trap_dispatch(struct trapframe *tf)
{
    ...
    case T_SWITCH_TOU:
        if (tf->tf_cs != USER_CS) {
            switchk2u = *tf;
            switchk2u.tf_cs = USER_CS;
            switchk2u.tf_ds = switchk2u.tf_es = switchk2u.tf_ss = USER_DS;
            switchk2u.tf_esp = (uint32_t)tf + sizeof(struct trapframe) - 8;
		
            // set eflags, make sure ucore can use io under user mode.
            // if CPL > IOPL, then cpu will generate a general protection.
            switchk2u.tf_eflags |= FL_IOPL_MASK;
		
            // set temporary stack
            // then iret will jump to the right stack
            *((uint32_t *)tf - 1) = (uint32_t)&switchk2u;
        }
        break;
    case T_SWITCH_TOK:
        if (tf->tf_cs != KERNEL_CS) {
            tf->tf_cs = KERNEL_CS;
            tf->tf_ds = tf->tf_es = KERNEL_DS;
            tf->tf_eflags &= ~FL_IOPL_MASK;
            switchu2k = (struct trapframe *)(tf->tf_esp - (sizeof(struct trapframe) - 8));
            memmove(switchu2k, tf, sizeof(struct trapframe) - 8);
            *((uint32_t *)tf - 1) = (uint32_t)switchu2k;
        }
        break;
        ...
}

0X07 总结

通过这个lab1，我们学习了以下内容:

  • 操作系统的镜像是如何制作的：第一个扇区是什么、剩下的扇区是什么、bootloader去段的处理、bootloader的大小限制
  • 操作系统是如何启动的：BIOS什么模式、BIOS结束时如何进入bootloader、bootloader两个功能(保护模式、ELF)、bootloader如何进入内核
  • 内核的中断、中断描述符、各种门、在ucore中断函数的实现方法
  • 段和门权限的表示方法，通过中断提权