未经许可谢绝以任何形式对本文内容进行转载！
一、环境配置
关于MIT课程中使用的JOS的配置教程网上已经有很多了，在这里就不做介绍，个人使用的是Ubuntu 16.04 + qemu。另注，本文章中贴出的代码均是JOS中未经修改的源代码，其中有一些细节是MIT课程中要求学生自己实现的。
二、Boot Loader代码分析
1.boot.S（AT&T汇编格式）
#include <inc/mmu.h> # Start the CPU: switch to -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= %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 .globl start
start:
.code16 # Assemble for -bit mode
cli # Disable interrupts
cld # String operations increment # Set up the important data segment registers (DS, ES, SS).
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 is tied low, so that addresses higher than
# 1MB wrap around to zero by default. This code undoes this.
seta20.:
inb $0x64,%al # Wait for not busy
testb $0x2,%al
jnz seta20. movb $0xd1,%al # 0xd1 -> port 0x64
outb %al,$0x64 seta20.:
inb $0x64,%al # Wait for not busy
testb $0x2,%al
jnz seta20. movb $0xdf,%al # 0xdf -> port 0x60
outb %al,$0x60 # Switch from real to protected mode, using a bootstrap GDT
# and segment translation that makes virtual addresses
# identical to their physical addresses, so that the
# effective memory map does not change during the switch.
lgdt gdtdesc
movl %cr0, %eax
orl $CR0_PE_ON, %eax
movl %eax, %cr0 # Jump to next instruction, but in -bit code segment.
# Switches processor into -bit mode.
ljmp $PROT_MODE_CSEG, $protcseg .code32 # Assemble for -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.
movl $start, %esp
call bootmain # If bootmain returns (it shouldn't), loop.
spin:
jmp spin # Bootstrap GDT
.p2align 2 # force 4 byte alignment
gdt:
SEG_NULL # null seg
SEG(STA_X|STA_R, 0x0, 0xffffffff) # code seg
SEG(STA_W, 0x0, 0xffffffff) # data seg gdtdesc:
.word 0x17 # sizeof(gdt) - 1
.long gdt # address gdt
boot.S
boot.S的代码如上所示，这部分代码的作用是将处理器从实模式切换到保护模式，然后再进行后续的加载内核程序的操作。为什么要让处理器切换到保护模式下工作？这就要从PC物理内存的分布来考虑，以现在4GB的内存为例，PC物理内存的分布大致可以用以下的图来表示：
在早期16bits的8088处理器上，地址总线为20位，可寻址空间为2^20，因此只能访问最下方1MB的内存。之后随着技术发展，Intel公司的处理器发展到了32bits寻址，为了兼容原来的软硬件，保留了PC物理内存中最下方1MB内存的布局和使用方式，把这之上的内存高地址部分设置为扩展内存（尽管这部分内存有一部分预留给了32bits的设备，如上图所示），而只有处理器工作在保护模式下才能访问到这部分扩展内存（详见其他关于保护模式的分析）。
在boot.S的开头，使用了.set汇编伪指令定义了Boot Loader代码段和数据段的段选择子（Segment Selector）和标志位CR0_PE_ON（这个标志位与切换到保护模式有关，具体会在后面介绍）。这之后，进行了一系列的初始化，包括关中断、DF寄存器复位、用0初始化部分段寄存器等（还有一部分是通过in、out等汇编指令和端口交换字节信息，因为个人对硬件端口和工作原理并不熟悉，这部分的分析可能以后补上）。再之后就是关键的从实模式切换到保护模式的代码：
lgdt gdtdesc
movl %cr0, %eax
orl $CR0_PE_ON, %eax
movl %eax, %cr0
其中第1行使用lgdt指令载入了事先定义好的GDT（全局描述符表，Global Descriptor Table），这张GDT的内容在boot.S的末尾：
# Bootstrap GDT
.p2align # force byte alignment
gdt:
SEG_NULL # null seg
SEG(STA_X|STA_R, 0x0, 0xffffffff) # code seg
SEG(STA_W, 0x0, 0xffffffff) # data seg gdtdesc:
.word 0x17 # sizeof(gdt) -
.long gdt # address gdt
值得注意的是，lgdt指令需要的参数共6bytes，其中低位的2bytes表示该GDT的大小，高位的4bytes表示指向该GDT的32bits基址（gdtdesc所指向的参数满足这一要求），使用lgdt指令的目的是在实模式切换到保护模式之前进行初始化。接着我们来分析GDT的结构（上述代码的3-6行），其中SEG_NULL、SEG宏均是在“inc/mmu.h”中定义的宏：
#define SEG_NULL \
.word , ; \
.byte , , ,
#define SEG(type,base,lim) \
.word (((lim) >> ) & 0xffff), ((base) & 0xffff); \
.byte (((base) >> ) & 0xff), (0x90 | (type)), \
(0xC0 | (((lim) >> ) & 0xf)), (((base) >> ) & 0xff)
从宏定义来看，SEG_NULL定义了一个空段（根据习惯，GDT的第一个段都是空段），接着
SEG(STA_X|STA_R, 0x0, 0xffffffff) # code seg
定义了可执行的（STA_X）、可读的（STA_R）、基址为0x0且大小为0xffffffff（即占整个PC内存、大小为4GB的）的代码段，而
SEG(STA_W, 0x0, 0xffffffff) # data seg
定义了可读的（STA_W，取这个值时该段不可执行）、基址为0x0且大小为0xffffffff（同上）的数据段，以上就是boot.S中预定义的GDT的内容。
然后我们再回到从模式切换部分的汇编代码的第2-4行（值得注意的是，AT&T汇编和Intel汇编的源操作数和目标操作数的顺序不同），这3行代码利用eax寄存器，让原本的控制寄存器CR0和标志位CR0_PE_ON进行or运算（实质上是将CR0寄存器的第0位置1），将处理器由实模式切换到了保护模式。为什么这3行代码能够做到模式的切换？这就需要了解CR0各位表示的含义：
| 比特位 | 简写 | 全称 | 描述 |
| 0 | PE | Protected Mode Enable | 保护模式使能，PE=1表示CPU处于保护模式，PE=0表示CPU处于实模式 |
| 1 | MP | Monitor co-processor | 协处理器监控，MP=1表示协处理器在工作，MP=0表示协处理器未工作 |
| 2 | EM | Emulation | 协处理器仿真，当MP=0且EM=1表示正在使用软件仿真协处理器工作 |
| 3 | TS | Task switched | 任务转换，每次任务转换时，TS=1表示任务转换完毕 |
| 4 | ET | Extension type | 处理器扩展类型，表示所扩展的协处理器的类型，ET=0表示80287，ET=1表示80387 |
| 5 | NE | Numeric error | 数值异常中断控制，如果运行协处理器指令发生故障，NE=1表示使用异常中断处理，NE=0表示用外部中断处理 |
| 16 | WP | Write protect | 写保护，WP=1表示对只读页面进行写操作时会产生页故障 |
| 18 | AM | Alignment mask | 对齐标志，AM=1表示允许对齐检查，AM=0表示不允许对其检查 |
| 29 | NW | Not-write through | 和CD一起控制CPU内部Cache，NW=0且CD=0表示Cache使能，其他组合参见Intel手册 |
| 30 | CD | Cache disable | 同上 |
| 31 | PG | Paging | 页式管理机制使能，PG=1表示页式管理机制工作，PG=0表示不工作 |
可以看出，CPU的工作模式是依靠CR0的PE位控制的，因此要想切换到保护模式，只需要把CR0的PE位置为1。
在CPU完成从实模式到保护模式的切换之后，boot.S使用一条ljmp指令跳转到模式切换后的第一条指令地址：
# Jump to next instruction, but in -bit code segment.
# Switches processor into -bit mode.
ljmp $PROT_MODE_CSEG, $protcseg
还记得boot.S开头的两个段选择子吗？这里的PROT_MODE_CSEG就是其中的一个标记了代码段的段选择子，在解释为什么PROT_MODE_CSEG要定义为0x8之前，我们有必要先了解一下实模式和保护模式下寻址方式的不同。
在实模式下，要想寻址某个内存单元，需要知道所在段的基地址base和它在段中的偏移量offset，由公式：base<<4 + offset得到。而在保护模式下，寻址不再需要段的基地址，而是换成了段选择子。段选择子的结构如下：
其中RPL（第0、1位）表示特权请求级，TI（第2位）表示描述符表标识符（用于区分GDT和LDT），Index（第3-15位）表示描述符在描述符表中的索引（从0计起）。现在我们再来考虑为什么PROT_MODE_CSEG定义为0x8。我们把PROT_MODE_CSEG用二进制的段选择子的结构表示为：0000 0000 0000 1000，根据段选择子的结构可以得到：
RPL = 00（0），TI = 0，Index = 0000 0000 0000 1（1）
这说明该段选择子访问RPL为0的、GDT中的第1个段。那这个段究竟是什么？我们回顾一下之前在boot.S中预定义的GDT：
gdt:
SEG_NULL # null seg
SEG(STA_X|STA_R, 0x0, 0xffffffff) # code seg
SEG(STA_W, 0x0, 0xffffffff) # data seg
其中第1个段就是代码段（注意是从0开始计数），另一个段选择子PROT_MODE_DSEG的分析同上。到这里上述ljmp指令的功能就很清楚了：跳转到由PROT_MODE_CSEG段选择子和protcseg偏移量指定的代码入口处。而跳转到的代码所完成的工作是：通过.code32伪指令编码的对各段寄存器的初始化，随后利用start标号指向的地址作为esp调用main.c中的bootmain()函数（注意bootmain()函数不需要参数，因此也就没有参数的压栈操作）。
# Set up the stack pointer and call into C.
movl $start, %esp
call bootmain
到此boot.S的功能结束。
2.main.c
#include <inc/x86.h>
#include <inc/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(boot.S and main.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 boot.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.
**********************************************************************/ #define SECTSIZE 512
#define ELFHDR ((struct Elf *) 0x10000) // scratch space void readsect(void*, uint32_t);
void readseg(uint32_t, uint32_t, uint32_t); void
bootmain(void)
{
struct Proghdr *ph, *eph; // read 1st page off disk
readseg((uint32_t) ELFHDR, SECTSIZE*, ); // is this a valid ELF?
if (ELFHDR->e_magic != ELF_MAGIC)
goto bad; // load each program segment (ignores ph flags)
ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff);
eph = ph + ELFHDR->e_phnum;
for (; ph < eph; ph++)
// p_pa is the load address of this segment (as well
// as the physical address)
readseg(ph->p_pa, ph->p_memsz, ph->p_offset); // call the entry point from the ELF header
// note: does not return!
((void (*)(void)) (ELFHDR->e_entry))(); bad:
outw(0x8A00, 0x8A00);
outw(0x8A00, 0x8E00);
while ()
/* do nothing */;
} // Read 'count' bytes at 'offset' from kernel into physical address 'pa'.
// Might copy more than asked
void
readseg(uint32_t pa, uint32_t count, uint32_t offset)
{
uint32_t end_pa; end_pa = pa + count; // round down to sector boundary
pa &= ~(SECTSIZE - ); // translate from bytes to sectors, and kernel starts at sector 1
offset = (offset / SECTSIZE) + ; // 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.
while (pa < end_pa) {
// Since we haven't enabled paging yet and we're using
// an identity segment mapping (see boot.S), we can
// use physical addresses directly. This won't be the
// case once JOS enables the MMU.
readsect((uint8_t*) pa, offset);
pa += SECTSIZE;
offset++;
}
} void
waitdisk(void)
{
// wait for disk reaady
while ((inb(0x1F7) & 0xC0) != 0x40)
/* do nothing */;
} void
readsect(void *dst, uint32_t offset)
{
// wait for disk to be ready
waitdisk(); outb(0x1F2, ); // count = 1
outb(0x1F3, offset);
outb(0x1F4, offset >> );
outb(0x1F5, offset >> );
outb(0x1F6, (offset >> ) | 0xE0);
outb(0x1F7, 0x20); // cmd 0x20 - read sectors // wait for disk to be ready
waitdisk(); // read a sector
insl(0x1F0, dst, SECTSIZE/);
}
main.c
在分析main.c的功能之前，先介绍3种将要使用到的结构体：Elf（Executable and Linkable Format）、Proghdr（Program Header）、Secthdr（Section Header），这三种结构体在“inc/elf.h”中定义如下（详见：https://en.wikipedia.org/wiki/Executable_and_Linkable_Format）：
#define ELF_MAGIC 0x464C457FU /* "\x7FELF" in little endian */
struct Elf {
uint32_t e_magic; //此处必须与ELF_MAGIC相等，否则不是有效Elf文件
uint8_t e_elf[]; //
uint16_t e_type; //
uint16_t e_machine; //标明支持的指令集结构
uint32_t e_version; //
uint32_t e_entry; //kernel进程开始执行的入口地址
uint32_t e_phoff; //Program Header表的偏移量
uint32_t e_shoff; //Section Header表的偏移量
uint32_t e_flags; //
uint16_t e_ehsize; //Elf文件头的大小
uint16_t e_phentsize; //
uint16_t e_phnum; //Program Header表中的条目数量
uint16_t e_shentsize; //
uint16_t e_shnum; //Section Header表中的条目数量
uint16_t e_shstrndx; //
};
struct Proghdr {
uint32_t p_type; //标明该段的类型
uint32_t p_offset; //该段在文件镜像中的偏移量
uint32_t p_va; //该段在内存中的虚拟地址
uint32_t p_pa; //在使用相对物理地址的系统中，表示该段在内存中的物理地址
uint32_t p_filesz; //该段在文件镜像中的大小（以bytes计，可以为0）
uint32_t p_memsz; //该段在内存中的大小（以bytes计，可以为0）
uint32_t p_flags; //
uint32_t p_align; //
};
struct Secthdr {
uint32_t sh_name; //
uint32_t sh_type; //
uint32_t sh_flags; //
uint32_t sh_addr; //该节在内存中的虚拟地址（对已经加载的扇区而言）
uint32_t sh_offset; //该节在文件镜像中的偏移量
uint32_t sh_size; //该节在文件镜像中的大小（以bytes计，可以为0）
uint32_t sh_link; //
uint32_t sh_info; //
uint32_t sh_addralign; //
uint32_t sh_entsize; //
};接下来我们从函数的角度来分析main.c都做了什么工作。在main.c的开头处我们看到两行函数头，分别是readsect(void *, uint32_t)和readseg(uint32_t, uint32_t, uint32_t)，紧接着是在boot.S中被调用的bootmain()函数体。我们依次对这三个函数进行观察：
首先是readsect(void *dst, uint32_t offset)。该函数中的函数通过__asm __volatile()间接使用了in和out汇编指令（详见“inc/x86.h”）对指定编号（在函数中，编号参数被定义为offset）的磁盘扇区进行读操作，并把读到的信息写到dst指向的内存中。
其次是readseg(uint32_t pa, uint32_t count, uint32_t offset)。从接口上看，该函数是向pa所指向的地址中读入count个bytes的、在磁盘上偏移量为offset的数据。而在函数的实现中，该函数对数据的读取是借助readsect(void *dst, uint32_t offset)，以扇区为单位进行的，即通过offset计算所在的磁盘扇区，然后再将整个扇区读入，最终达到读入所有数据的目的。
最后我们对bootmain()函数进行观察：
在bootmain()函数的开头，先通过
readseg((uint32_t) ELFHDR, SECTSIZE*, );
从磁盘偏移量为0的地方向ELFHDR这个指针指向的地址（在main.c中该地址由宏定义为0x10000）读入1个页（512 * 8 = 4096 bytes，即8个扇区）大小的数据。随后对读入的kernel是否为Elf格式进行了校验。若校验不通过，向特定端口输出特定字信息后进入死循环（bad标号指向的代码，此处也通过__asm __volatile()间接使用了out汇编指令）。若通过文件格式校验，则通过ph和eph两个Proghdr *类型的指针加载该Elf文件中的所有程序段（其中ph指向Program Header表的表头，eph指向Program Header表的表尾，每一次指针的自加操作都是指向当前表中的下一条目，表中条目的数量都保存在ELFHDR->e_phnum中），更具体地说，对于表中的每一项ph（即每个程序段），通过
readseg(ph->p_pa, ph->p_memsz, ph->p_offset);
将ph所对应的偏移量为ph->offset的、大小为ph->memsz的程序段从磁盘中都入到ph->p_pa指向的物理内存中。个人认为，上述部分代码实质上是将整个kernel程序从磁盘部署到内存中等待执行。而最后一行
((void (*)(void)) (ELFHDR->e_entry))();
显然是通过函数指针进行函数调用，这里的ELFHDR->e_entry指向的地址就是上面一开始所介绍的kernel进程的第一条指令的地址，也就是说，这条C语句执行过后，Boot Loader就将执行权交给了kernel，因为理论上kernel并不返回，所以这是Boot Loader所执行的最后一条语句（如果kernel返回说明操作系统出现严重错误，跳转到bad标号指向的代码执行）。
到此main.c的功能结束。到此整个Boot Loader的功能结束。