【操作系统真象还原系列】8. 解析和加载elf文件（二）

缺乏、安全感 2023-01-11 03:55 178阅读 0赞

### 目录 ###

*  编译mbr和loader
 *  将mbr、loader和kernel文件写入硬盘镜像
 *  修改loader.s，加载elf
 *   *  加载位置选择
     *  32位保护模式下读硬盘扇区
     *  加载原始ELF到临时缓冲内存
     *  内存拷贝函数
     *  根据ELF规范加载所有段
     *  设置堆栈，跳转到内核入口地址
 *  使用Virtualbox调试内核
 *   *  通过命令行启动virtualbox
     *  查看内核运行时的寄存器状态
     *  使用virtualbox反汇编内存中的代码
 *  完整源码
 *   *  mbr.s
     *  loader.s
     *  kernel.c
 *  最终内存布局

# 编译mbr和loader #

> $ nasm -f bin mbr.s -o mbr.bin

> $ nasm -f bin loader.s -o loader.bin

# 将mbr、loader和kernel文件写入硬盘镜像 #

之前我们使用的mbr.bin和loader.bin烧写命令如下所示：

> dd if=mbr.bin of=…/OSLab.vhd bs=512 count=1 conv=notrunc  
> dd if=loader.bin of=…/OSLab.vhd bs=512 count=12 conv=notrunc seek=1

由此可见，我们将mbr.bin烧写到了虚拟硬盘的第0个扇区，将loader.bin烧写到了虚拟硬盘的第1个扇区。

由于loader.bin文件大小后续可能还有变化，所以为了保险起见，我们将kernel.bin文件烧写至第9个扇区。

> dd if=kernel.elf of=…/OSLab.vhd bs=512 count=12 conv=notrunc seek=9

# 修改loader.s，加载elf #

## 加载位置选择 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center]  
我们最终是要把内核加载到内存的低地址处，方便后续内核增加。关于内核要加载到的运行时虚拟地址，我们是通过链接时来指定的。具体内容如下所示：

> ld -m elf\_i386 kernel.o -Ttext 0xc0001500 -e main -o kernel.elf

而由我们之前配置的页表信息可知，0xc0001500是内核空间，对应的物理地址是0x00001500。这正是内存的低地址处。

而对于原始的elf文件，我们需要将其加载到高地址处，之后按照程序头表来解析内核。为此，我们将elf文件的加载地址定为0x70000。从该地址往上，我们还有190KB字节的内存可以使用。

> KERNEL\_START\_DISK\_SECTOR equ 9  
>   
>   
> KERNEL\_BIN\_BASE\_ADDR equ 0x70000

## 32位保护模式下读硬盘扇区 ##

首先我们引入在32位保护模式下读硬盘扇区的函数。我们使用寄存器esi来存储LBA28表示的起始逻辑扇区号，使用寄存器ds:edi来存储目标缓冲区地址，使用寄存器cl来存储待读取的扇区数。

readSectorFromDisk_m32:
    	;注意待读取的字节数不要让di寄存器溢出
    	;保护模式下从硬盘读取指定数量的逻辑扇区
    	;esi=起始逻辑扇区号LBA28
    	;ds:edi=目标缓冲区地址
    	;cl中存放的是待读取的扇区数
    
    DataRegister equ 0x1F0
    FeatureRegister equ 0x1F1
    SectorRegister equ 0x1F2
    LBAlowRegister equ 0x1F3
    LBAmidRegister equ 0x1F4
    LBAhighRegister equ 0x1F5
    DeviceRegister equ 0x1F6
    CommandRegister equ 0x1F7
    
    ReadCMD	equ 0x20
    WriteCMD	equ 0x30
    IDCMD		equ 0xEC
    
    	push eax
    	push ebx
    	push ecx
    	push edx
    	push edi
    
    	mov eax, esi
    	
    	mov dx, LBAlowRegister
    	out dx, al
    
    	mov dx, LBAmidRegister
    	shr eax, 8
    	out dx, al
    
    	mov dx, LBAhighRegister
    	shr eax, 16
    	out dx, al
    	
    	mov dx, DeviceRegister
    	;LBA28 mode, master disk
    	and ah, 0x0F
    	mov al, 0xe0
    	or al, ah
    	out dx, al
    	
    	mov dx, SectorRegister
    	mov al, cl
    	out dx, al
    	
    	mov dx, CommandRegister 
    	mov al, ReadCMD
    	out dx, al
    	
    .wait4Ready:
    	in al, dx
    	and al, 0x88
    	cmp al, 0x08
    	jnz .wait4Ready
    	
    	;计算待循环的总次数
    	;一个扇区512字节，由于每次读取2个字节，所以一个扇区要读取256次
    	mov ax, 256
    	;如果是8位乘法，结果默认放在AX中
    	;如果是16位乘法，结果高位默认在DX中存放，低位在AX中存放
    	;乘以待读取的扇区数
    	mul cx
    	
    	;由于cl中存储的是待读取的扇区数，所以扇区数不超过255
    	;所以乘积不会超过65536，ax寄存器足以放得下乘积结果
    	mov cx, ax
    
    	mov dx, DataRegister
    .readSectorData:
    	in ax, dx
    	mov word [edi], ax
    	add edi, 2
    	loop .readSectorData
    
    	pop edi
    	pop edx
    	pop ecx
    	pop ebx
    	pop eax
    
    	ret

## 加载原始ELF到临时缓冲内存 ##

我们使用的内核编译之后的ELF文件大小大约是100KB，所以我们从第9个扇区开始连续读取250个扇区（512 x 250B = 1024 x 125B = 125KB）。

当我们使用bochs来启动虚拟机时，我们可以一次读取多个扇区。但是当我们使用virtualbox时，我们发现给IDE硬盘控制器传入的一次读取的扇区个数只能是1，否则后续扇区的数据读不出来。

为了兼容这种情况，我们根据要读取的总扇区数，依次每次只读取一个扇区，代码如下所示：

;从LBA扇区1开始读取250个扇区
    	mov ecx, 250
    	mov esi, KERNEL_START_DISK_SECTOR
    	mov edi, KERNEL_BIN_BASE_ADDR
    
    @load_kernel:	
    	push ecx
    	mov ecx, 1
    	call readSectorFromDisk_m32
    	inc esi
    	add edi, 512
    	pop ecx
    	loop @load_kernel

## 内存拷贝函数 ##

为了在内存块之间拷贝数据，我们引入了一个内存拷贝函数memcpy，该函数有三个参数：第1个参数是目的内存块的起始虚拟地址，第2个参数是源内存块的起始虚拟地址，第3个参数是待拷贝的字节数，具体内容如下所示：

;memcpy(virtualDst, virtualSrc, byteSize)
    
    memcpy:
    	cld
    	push ebp
    	mov ebp, esp
    	push ecx
    	
    	mov edi, [ebp + 8] 	;dst
    	mov esi, [ebp + 12] 	;src
    	mov ecx, [ebp + 16]	;size
    	;逐字节拷贝
    	rep movsb
    	
    	pop ecx
    	pop ebp
    	ret

## 根据ELF规范加载所有段 ##

现在我们可以根据elf文件的定义，按照程序头表的内容，将所有的段加载到内存中对应的虚拟地址处了。

kernel_init:
    	;开始解析elf程序头表，加载所有段到对应的虚拟地址
    	xor eax, eax
    	xor ebx, ebx
    	xor ecx, ecx
    	xor edx, edx
    	
    	;ebx记录程序头表的地址，4个字节
    	;因为在ELF Header中e_phoff的字节偏移地址是28
    	mov ebx, [KERNEL_BIN_BASE_ADDR + 28]
    	add ebx, KERNEL_BIN_BASE_ADDR
    	
    	;ecx用来记录程序头表中的段的数量，2个字节
    	;ELF Header中e_phnum的字节偏移地址是44
    	mov cx, [KERNEL_BIN_BASE_ADDR + 44]
    	
    	;edx用来记录程序头表中条目的字节大小，2个字节
    	;ELF Header中e_phentsize的字节偏移地址是42
    	mov dx, [KERNEL_BIN_BASE_ADDR + 42]
    	
    .each_elf_segment:
    	;读取当前段的段类型，如果是PT_NULL，则跳过当前段条目
    	cmp byte [ebx + 0], PT_NULL
    	je .elf_pt_null
    	
    	;段类型检验通过，开始拷贝段条目指向的段到指定的虚拟地址
    	;将memcpy参数压栈，参数从右向左压入
    	;memcpy(virtualDst, virtualSrc, byteSize)
    	;首先压入段的字节大小，p_filesz在Elf32_Phdr的字节偏移是16
    	push dword [ebx + 16]
    	
    	;第二步，压入段的源地址
    	;p_offset在Elf32_Phdr的字节偏移是4
    	;p_offset指明段的起始地址相对于Elf文件开头的字节数
    	mov eax, [ebx + 4]
    	add eax, KERNEL_BIN_BASE_ADDR
    	push eax
    	
    	;第三步，压入目的虚拟地址
    	;p_vaddr在Elf32_Phdr的字节偏移是8
    	push dword [ebx + 8]
    	call memcpy
    	;调用完毕，由调用者清理堆栈
    	add esp, 12
    	
    	
    .elf_pt_null:
    	;让ebx指向程序头表中的下一个段条目
    	add ebx, edx
    	
    	loop .each_elf_segment
    	ret

## 设置堆栈，跳转到内核入口地址 ##

;读取elf内核入口虚拟地址
    	mov eax, [KERNEL_BIN_BASE_ADDR + 24]
    	mov esp, 0xC009F000
    	jmp eax

# 使用Virtualbox调试内核 #

## 通过命令行启动virtualbox ##

> $ VBoxManage startvm “OSLab” -E VBOX\_GUI\_DBG\_AUTO\_SHOW=true -E VBOX\_GUI\_DBG\_ENABLED=true

> $ VBoxManage controlvm “OSLab” resume

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 1]

## 查看内核运行时的寄存器状态 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 2]

## 使用virtualbox反汇编内存中的代码 ##

我们可以看到此时eip寄存器指向0xC0001503，而我们反汇编内核文件，如下所示：

> macrofun@OSLab:~/OSLab/LoadElf2$ objdump -d kernel.elf

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 3]  
我们看到该地址正好对应while循环，kernel.c源码如下所示：

int main(void)
    { 
        while(1)
            ;
        
        return 0;	
    }

我们在反汇编以下0xc0001500之后的指令，如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 4]  
我们可以看到，虚拟内存地址0xc0001500处开始的代码 和 kernel.elf文件反汇编之后的代码完全一致。  
内核加载运行成功。

# 完整源码 #

## mbr.s ##

VideoIndexPort equ 0x3D4
    VideoDataPort equ 0x3D5
    
    CursorPosHigh8Index equ 0xE
    CursorPosLow8Index equ 0xF
    
    video_ram_segment   equ  0xB800
    
    mbr_ram_segment equ 0x7C0
    
    LOADER_BASE_ADDR equ 0x500
    
    [bits 16]
    
    ;设置实模式下的堆栈
    segment mbrLoader align=16 vstart=0x7c00
    	xor ax, ax
    	mov ss, ax
    	mov ds, ax
    	mov sp, 0x7c00
    
    	
    ;关中断
    	cli
    	mov eax, loadLoaderMsg
    	call printString
    	
    	;从LBA扇区1开始读取6个扇区
    	mov ecx, 6
    	mov esi, 1
    	mov di, LOADER_BASE_ADDR
    
    @load_loader:	
    	push ecx
    	mov cx, 1
    	call readSectorFromDisk_m16
    	inc esi
    	add di, 512
    	pop ecx
    	loop @load_loader
    	
    	mov eax, LoaderDoneMsg
    	call printString
    	
    	jmp LOADER_BASE_ADDR
    	jmp $
    	
    ;返回值是光标索引，放在寄存器ax中           
    getCursorPosition:
    	push dx
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	mov ah, al
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	
    	pop dx
    	ret
    	
    setCursorPosition:
    	push ax
    	push bx
    	push dx
    	
    	mov bx, ax
    	
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bh
    	out dx, al 
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bl
    	out dx, al
    	
    	pop dx
    	pop bx
    	pop ax	
    	ret
    	
    
    
    ; 打印一个字符，入参存放在寄存器al中
    printCharacter:
    	push es
    	push ds
    	push eax
    	push edi
    	push ebx
    	push ecx
    	
    	; save character to register bl
    	mov bl, al
    	
    	;set video buffer
    	mov eax, video_ram_segment
       	mov es, eax
       	   		
    	;get cursor pos to ax
    	call getCursorPosition
    	;move current cursor pos to di
    	mov di, ax
    	;1 character consumes 2 bytes
    	shl di, 1
    
    	cmp di, 4000
    	;just return if the screen is full
    	je .doneWithPrintCharacter
    	
    	;before output, test if it is carriage return
    	cmp bl, 0xD
    	je .handleCarriageReturn
    	
    	cmp bl, 0xA
    	je .handleNewLine
    	
    	
    	mov byte [es:di], bl	
    	inc di
    	mov byte [es:di], 0x0f
    	inc di
    	jmp .doneWithPrintCharacter
    	
    .handleCarriageReturn:
    	;move cursor to the front of current line
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	mul bh
    	shl ax, 1
    	mov di, ax
    	jmp .doneWithPrintCharacter
    	
    .handleNewLine:
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	cmp al, 24
    	jl .addAnotherNewLine
    	
    	;roll the Screen
    	push edi
    	mov ax, video_ram_segment
    	mov ds, ax
    	mov es, ax
    	cld
    	mov ecx, 1920
    	mov edi, 0
    	mov esi, 160
    	rep movsw
    	;clear screen last line
    	mov ebx, 3840                     
    	mov ecx, 80
     .cls:
    	mov word [es:bx], 0x0720
    	add bx, 2
    	loop .cls
    	; keep the cursor in the same place of the last line
    	pop edi
    	jmp .doneWithPrintCharacter
    	
    .addAnotherNewLine:
    	;just add another new line if it is not the last line
    	add di, 160
    .doneWithPrintCharacter:	
    	;write new cursor pos to video card
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	call setCursorPosition
    	
    	pop ecx
    	pop ebx
    	pop edi
    	pop eax
    	pop ds
    	pop es
    	ret
    	
    ;字符串打印函数，首地址存储在寄存器eax中
    printString:
    	push eax
    	push esi
    	
    	;save string start address to si
    	mov esi, eax
    	
    @1: mov al, [esi]
    	cmp al, 0
    	je @2
    	
    	call printCharacter
    	
    	inc esi
    	jmp @1
    	
    @2:
    	pop esi
    	pop eax
    	
    	ret	
    	
    readSectorFromDisk_m16:
    	;注意待读取的字节数不要让di寄存器溢出
    	;保护模式下从硬盘读取指定数量的逻辑扇区
    	;esi=起始逻辑扇区号LBA28
    	;ds:di=目标缓冲区地址
    	;cl中存放的是待读取的扇区数
    
    DataRegister equ 0x1F0
    FeatureRegister equ 0x1F1
    SectorRegister equ 0x1F2
    LBAlowRegister equ 0x1F3
    LBAmidRegister equ 0x1F4
    LBAhighRegister equ 0x1F5
    DeviceRegister equ 0x1F6
    CommandRegister equ 0x1F7
    
    ReadCMD	equ 0x20
    WriteCMD	equ 0x30
    IDCMD		equ 0xEC
    
    	push eax
    	push ebx
    	push ecx
    	push edx
    	push edi
    
    	mov eax, esi
    	
    	mov dx, LBAlowRegister
    	out dx, al
    
    	mov dx, LBAmidRegister
    	shr eax, 8
    	out dx, al
    
    	mov dx, LBAhighRegister
    	shr eax, 16
    	out dx, al
    	
    	mov dx, DeviceRegister
    	;LBA28 mode, master disk
    	and ah, 0x0F
    	mov al, 0xe0
    	or al, ah
    	out dx, al
    	
    	mov dx, SectorRegister
    	mov al, cl
    	out dx, al
    	
    	mov dx, CommandRegister 
    	mov al, ReadCMD
    	out dx, al
    	
    .wait4Ready:
    	in al, dx
    	and al, 0x88
    	cmp al, 0x08
    	jnz .wait4Ready
    	
    	;计算待循环的总次数
    	;一个扇区512字节，由于每次读取2个字节，所以一个扇区要读取256次
    	mov ax, 256
    	;如果是8位乘法，结果默认放在AX中
    	;如果是16位乘法，结果高位默认在DX中存放，低位在AX中存放
    	;乘以待读取的扇区数
    	mul cx
    	
    	;由于cl中存储的是待读取的扇区数，所以扇区数不超过255
    	;所以乘积不会超过65536，ax寄存器足以放得下乘积结果
    	mov cx, ax
    
    	mov dx, DataRegister
    .readSectorData:
    	in ax, dx
    	mov word [di], ax
    	add di, 2
    	loop .readSectorData
    
    	pop edi
    	pop edx
    	pop ecx
    	pop ebx
    	pop eax
    
    	ret
    	
    loadLoaderMsg: db 'Loading loader...', 0xA, 0xD, 0
    LoaderDoneMsg: db 'Now transfer control to loader...', 0xA, 0xD, 0
    
    times 510-($-$$) db 0
    db 0x55,0xaa

## loader.s ##

LOADER_BASE_ADDR equ 0x500
    
    PAGE_DIR_TABLE_POS equ 0x100000
    
    KERNEL_START_DISK_SECTOR equ 9
    
    KERNEL_BIN_BASE_ADDR equ 0x70000
    
    ;程序中的段类型
    PT_NULL equ 0x0
    
    
    
    
    ;U为1表示处于User级
    PG_US_U equ (0x1 << 2)
    PG_US_S equ (0x0 << 2)
    
    ;RW为1表示该页可读可写
    PG_RW_W equ (0x1 << 1)
    
    PG_P equ (0x1 << 0)
    
    ;定义描述符表所用到的宏
    DESC_G_4K equ (0x1 << 23)
    DESC_G_1B equ (0x0 << 23)
    
    ;设置D/B为1，表示是32位
    DESC_D_32 equ (0x1 << 22)
    
    
    ;L位是64位代码段标志，设置为0
    DESC_L equ (0x0 << 21)
    
    
    ;AVL位是用户自定义位，通常由操作系统来使用，这里我们暂设置为0
    DESC_AVL equ (0x0 << 20)
    
    ;设置代码段的限长的最高4位
    DESC_LIMIT_CODE_High4 equ (0xF << 16)
    
    ;设置数据段的限长的最高4位
    DESC_LIMIT_DATA_High4 equ (0xF << 16)
    
    ;用于文本模式的显存地址范围是0xB8000~0xBFFFF，一共32KB(215)大小，故显存段界限为0x7FFF，又由于段粒度为1B，所以段界限长度为0x7FFF，即最高的4位是0
    DESC_LIMIT_VIDEO_High4 equ (0x0 << 16)
    
    
    ;段存在位P用于指示描述符所对应的段是否存在。当P=1时，表示段位于内存中
    DESC_P equ (0x1 << 15)
    
    ;4个特权级
    DESC_DPL_0 equ (0x0 << 13)
    DESC_DPL_1 equ (0x1 << 13)
    DESC_DPL_2 equ (0x2 << 13)
    DESC_DPL_3 equ (0x3 << 13)
    
    ;S位用于表示描述符的类型。当S=0时，表示这是一个系统段；当S=1时，表示这是一个代码段或数据段
    DESC_S_CODE_OR_DATA equ (0x1 << 12)
    DESC_S_SYSTEM equ (0x0 << 12)
    
    ;设置代码段为可执行、不可读、非一致性，访问位清零
    DESC_TYPE_CODE equ (0x8 << 8)
    
    
    ;设置数据段为不可执行、可读可写、向上扩展，访问位清零
    DESC_TYPE_DATA equ (0x2 << 8)
    
    
    ;设置代码段和数据段映射整个4GB地址空间
    DESC_CODE_HIGH32 equ (0x00 << 24) + DESC_G_4K + DESC_D_32 + DESC_L + \
    DESC_AVL + DESC_LIMIT_CODE_High4 + DESC_P + DESC_DPL_0 + DESC_S_CODE_OR_DATA + \
    DESC_TYPE_CODE + 0x00
    
    DESC_DATA_HIGH32 equ (0x00 << 24) + DESC_G_4K + DESC_D_32 + DESC_L + \
    DESC_AVL + DESC_LIMIT_DATA_High4 + DESC_P + DESC_DPL_0 + DESC_S_CODE_OR_DATA + \
    DESC_TYPE_DATA + 0x00
    
    DESC_VIDEO_HIGH32 equ (0x00 << 24) + DESC_G_1B + DESC_D_32 + DESC_L + \
    DESC_AVL + DESC_LIMIT_VIDEO_High4 + DESC_P + DESC_DPL_0 + DESC_S_CODE_OR_DATA + \
    DESC_TYPE_DATA + 0x0B
    
    RPL0 equ (0x0)
    RPL1 equ (0x1)
    RPL2 equ (0x2)
    RPL3 equ (0x3)
    
    TI_GDT equ (0x0 << 2)
    TI_LDT equ (0x1 << 2)
    
    ;loader的入口
    ;构造全局描述符表
    section loader vstart=LOADER_BASE_ADDR
    ;栈底设置在0x7C00处，满减栈
    LOADER_STACK_TOP equ 0x7c00
    jmp loader_start
    
    GDT_BASE:
    	dd 0x0
    	dd 0x0
    CODE_DESC:
    	dd 0xFFFF
    	dd DESC_CODE_HIGH32
    DATA_STACK_DESC:
    	dd 0xFFFF
    	dd DESC_DATA_HIGH32 
    VIDEO_DESC:
    	;我们把显存段基址设置为0xB8000，由于显存范围是0xB8000-0xBFFFF
    	;故显存段的段限长为 0x7FFF
    	dd 0x80007FFF
    	dd DESC_VIDEO_HIGH32 
    
    GDT_SIZE equ $ - GDT_BASE
    GDT_LIMIT equ GDT_SIZE - 1
    ;此处预留60个描述符的空位，以备后续使用
    times 60 dq 0
    
    ;定义三个段描述符选择子
    SELECTOR_CODE equ (0x1 << 3) + TI_GDT + RPL0
    SELECTOR_DATA equ (0x2 << 3) + TI_GDT + RPL0
    SELECTOR_VIDEO equ (0x3 << 3) + TI_GDT + RPL0
    
    gdt_ptr:
    	dw GDT_LIMIT
    	dd GDT_BASE
    
    ;在使能保护模式之前，先调用BIOS获取物理内存容量
    ;为编程简单起见，我们先迭代获取所有的ARDS之后，再统一遍历
    ;我们先定义ARDS的缓冲区，每个ARDS大小为20字节，暂定为10个
    ARDS_BUFFER times 200 db 0
    ARDS_COUNT dw 0
    
    totalMemCapacity dd 0
    
    align 32
    
    loader_start:
    	cli
    
    	;第一次调用时，ebx必须为0
    	xor ebx, ebx
    	mov di, ARDS_BUFFER
    	;固定签名标记
    	mov edx, 0x534D4150
    e820_queryMemCapacityLoop:
    	;每次循环都要指定子功能号
    	mov eax, 0xE820
    	;指定ARDS字节大小
    	mov ecx, 20
    	int 0x15
    	jc e820_err
    	;指向用于存储下一个ARDS的缓冲区
    	add di, cx
    	;记录当前已经读取过的ARDS的数量
    	inc word [ARDS_COUNT]
    	cmp ebx, 0
    	jnz e820_queryMemCapacityLoop
    	;此时已成功获取所有ARDS
    	mov ecx, [ARDS_COUNT]
    	mov ebx, ARDS_BUFFER
    	xor edx, edx
    find_max_mem:
    	mov eax, [ebx]
    	add eax, [ebx+8]
    	add ebx, 20
    	cmp edx, eax
    	jge find_next_mem
    	mov edx, eax
    find_next_mem:
    	loop find_max_mem
    	mov [totalMemCapacity], edx
    	jmp enter_protection_mode
    e820_err:
    	mov ax, 0xb800
    	mov es, ax
    	mov byte [es:0x0], 'E'
    	mov byte [es:0x1], 0xF
    	
    	mov byte [es:0x2], 'r'
    	mov byte [es:0x3], 0xF
    	
    	mov byte [es:0x4], 'r'
    	mov byte [es:0x5], 0xF
    	
    	mov byte [es:0x6], 'o'
    	mov byte [es:0x7], 0xF
    	
    	mov byte [es:0x8], 'r'
    	mov byte [es:0x9], 0xF
    	jmp $ 
    
    enter_protection_mode:
    	cli
    
    ;打开A20地址线
    	in al, 0x92          ;南桥芯片内的端口 
    	or al, 0x2
    	out 0x92, al         ;打开A20
    
    ;加载GDTR
    	lgdt  [gdt_ptr]
    
    ;使能CR0中的PE位
    	mov eax, cr0
    	or eax, 0x1
    	mov cr0, eax
    
    ;之后，我们需要使用跳转指令来刷新流水线
    	jmp SELECTOR_CODE : protectionMode_start
    [bits 32]
    protectionMode_start:
    	mov eax, SELECTOR_DATA
    	mov ds, eax
    	mov es, eax
    	mov ss, eax
    	mov esp, LOADER_STACK_TOP
    	mov eax, SELECTOR_VIDEO
    	mov gs, eax
    
    	mov eax, MsgInPE
    	call printString
    
    	mov eax, totalMemCapacity
    	mov ebx, 4
    	
    	call printByteInHex
    	
    	call setup_page
    	
    	;为验证虚拟地址是否生效，我们将GDT中显存的基地址移动到高3GB的内核空间中
    	sgdt [gdt_ptr]
    	;令eax指向GDT表的基地址
    	mov eax, [gdt_ptr + 2]
    	;令eax指向显存段描述符
    	add eax, 8*3
    	;将GDT中显存的基地址移动到高3GB的内核空间中
    	or dword [eax + 4], 0xC0000000
    	
    	;将栈指针同样移动到内核区对应位置
    	add esp, 0xC0000000
    	
    	;将页目录表地址赋给cr3
    	mov eax, PAGE_DIR_TABLE_POS
    	mov cr3, eax
    	
    	;set cr0 PG
    	mov eax, cr0
    	or eax, (0x1 << 31)
    	mov cr0, eax
    	
    	;将GDT的基地址移动到高3GB的内核空间中
    	or dword [gdt_ptr + 2], 0xC0000000
    	lgdt [gdt_ptr]
    	
    	;由于更改了显存段的基地址，所以需要重新加载gs段寄存器，从而更新gs段信息
    	mov eax, 0x18
    	mov gs, eax
    	
    	mov eax, MsgInVirtualAddr
    	call printString
    	
    	cli
    	mov eax, BeginLoadKernelMsg
    	call printString
    	
    	;从LBA扇区1开始读取250个扇区
    	mov ecx, 250
    	mov esi, KERNEL_START_DISK_SECTOR
    	mov edi, KERNEL_BIN_BASE_ADDR
    
    @load_kernel:	
    	push ecx
    	mov ecx, 1
    	call readSectorFromDisk_m32
    	inc esi
    	add edi, 512
    	pop ecx
    	loop @load_kernel
    	
    	mov eax, LoadKernelDoneMsg
    	call printString
    	
    	
    	call kernel_init
    	;读取elf内核入口虚拟地址
    	mov eax, [KERNEL_BIN_BASE_ADDR + 24]
    	mov esp, 0xC009F000
    	jmp eax
    	
    	jmp $
    
    MsgInPE: db 'Now running in protection mode!', 0xA, 0xD, 0
    MsgInVirtualAddr: db 'Now running in virtual address space!', 0xA, 0xD, 0
    
    BeginLoadKernelMsg: db 'Now begin to load kernel...', 0xA, 0xD, 0
    LoadKernelDoneMsg: db 'Kernel is loaded.', 0xA, 0xD, 0
    
    VideoIndexPort equ 0x3D4
    VideoDataPort equ 0x3D5
    
    CursorPosHigh8Index equ 0xE
    CursorPosLow8Index equ 0xF
    ;返回值是光标索引，放在寄存器ax中           
    getCursorPosition:
    	push dx
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	mov ah, al
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	in al, dx
    	
    	pop dx
    	ret
    	
    setCursorPosition:
    	push ax
    	push bx
    	push dx
    	
    	mov bx, ax
    	
    	mov dx, VideoIndexPort
    	mov al, CursorPosHigh8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bh
    	out dx, al 
    
    	mov dx, VideoIndexPort
    	mov al, CursorPosLow8Index
    	out dx, al
    
    	mov dx, VideoDataPort
    	mov al, bl
    	out dx, al
    	
    	pop dx
    	pop bx
    	pop ax	
    	ret
    	
    
    
    ; 打印一个字符，入参存放在寄存器al中
    printCharacter:
    	push es
    	push ds
    	push eax
    	push edi
    	push ebx
    	push ecx
    	
    	; save character to register bl
    	mov bl, al
    	
    	;set video buffer
    	mov eax, SELECTOR_VIDEO
       	mov es, eax
       	   		
    	;get cursor pos to ax
    	call getCursorPosition
    	;move current cursor pos to di
    	mov di, ax
    	;1 character consumes 2 bytes
    	shl di, 1
    
    	cmp di, 4000
    	;just return if the screen is full
    	je .doneWithPrintCharacter
    	
    	;before output, test if it is carriage return
    	cmp bl, 0xD
    	je .handleCarriageReturn
    	
    	cmp bl, 0xA
    	je .handleNewLine
    	
    	
    	mov byte [es:di], bl	
    	inc di
    	mov byte [es:di], 0x0f
    	inc di
    	jmp .doneWithPrintCharacter
    	
    .handleCarriageReturn:
    	;move cursor to the front of current line
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	mul bh
    	shl ax, 1
    	mov di, ax
    	jmp .doneWithPrintCharacter
    	
    .handleNewLine:
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	cmp al, 24
    	jl .addAnotherNewLine
    	
    	;roll the Screen
    	push edi
    	mov ax, SELECTOR_VIDEO
    	mov ds, ax
    	mov es, ax
    	cld
    	mov ecx, 1920
    	mov edi, 0
    	mov esi, 160
    	rep movsw
    	;clear screen last line
    	mov ebx, 3840                     
    	mov ecx, 80
     .cls:
    	mov word [es:bx], 0x0720
    	add bx, 2
    	loop .cls
    	; keep the cursor in the same place of the last line
    	pop edi
    	jmp .doneWithPrintCharacter
    	
    .addAnotherNewLine:
    	;just add another new line if it is not the last line
    	add di, 160
    .doneWithPrintCharacter:	
    	;write new cursor pos to video card
    	xor eax, eax
    	mov ax, di
    	shr ax, 1
    	call setCursorPosition
    	
    	pop ecx
    	pop ebx
    	pop edi
    	pop eax
    	pop ds
    	pop es
    	ret
    	
    ;字符串打印函数，首地址存储在寄存器eax中
    printString:
    	push eax
    	push esi
    	
    	;save string start address to si
    	mov esi, eax
    	
    @1: mov al, [esi]
    	cmp al, 0
    	je @2
    	
    	call printCharacter
    	
    	inc esi
    	jmp @1
    	
    @2:
    	pop esi
    	pop eax
    	
    	ret	
    
    ;ax start address
    ;bx bytes	
    printByteInHex:
    	;对本函数中使用到的寄存器入栈保存
    	push eax
    	push di
    	push cx
    	push es
    	push si
    	push bx
    	push dx
    	
    	;si寄存器用于保存当前待打印的字节所在的地址
    	mov si, ax
    	mov cx, bx
    	;dx寄存器用于计数，每行打印16个字符后换行
    	mov dx, 0
    
    	;初始化显存 段寄存器
    	mov eax, SELECTOR_VIDEO
    	mov es, eax
    
    	;di用于显存的索引
    	xor di, di
    	;begin with another line
    	;add di, 160
    myloop:
    	;取出待打印的当前字节到寄存器al中
    	mov al, [si]
    	inc si
    	;将al字节的高4位放到bl的低4位中
    	mov bl, 0xF0
    	and bl, al
    	shr bl, 4
    	;将高4位对应的数字转换为 数字字符形式
    	add bl, 0x30
    	;如果该数字超过10，则使用A~F来表示
    	cmp bl, 0x3A
    	jl @number0
    	add bl, 7
    @number0:
    	;将转换好的高4位以十六进制字符形式输出到显存上
    	mov [es:di], bl
    	inc di
    	mov byte [es:di], 0x07
    	inc di
    	;按照上述步骤 同样处理本字节的低4位
    	mov bl, 0xF
    	and bl, al
    	add bl, 0x30
    	cmp bl, 0x3A
    	jl @number1
    	add bl, 7
    @number1:
    	mov [es:di], bl
    	inc di
    	mov byte [es:di], 0x07
    	inc di
    	;之后添加空格
    	mov byte [es:di], 0x20
    	inc di
    	mov byte [es:di], 0x07
    	inc di
    	
    	;统计每行已打印的字节数，满16个字节换行
    	inc dx
    	cmp dx, 0x10
    	jne noNewLine
    	;因为文本模式每行可显示80个字符，而 一个字节对应两个十六进制的字符外加一个空格
    	;所以当打印完毕16个字节后，本行已打印的字符数为16*3=48，故本行还剩余的字符数为80-48=32
    	;又由于一个字符对应显存的两个字节位置，所以本行需要的偏移值为32*2=64
    	add di, 64
    	mov dx, 0
    noNewLine:	
    	loop myloop
    
    	;全部字节打印完毕，弹栈
    	pop dx
    	pop bx
    	pop si
    	pop es
    	pop cx
    	pop di
    	pop eax
    	ret	
    	
    	
    setup_page:
    	mov ecx, 1024
    	mov esi, 0
    .clear_page_dir:
    	mov dword [esi + PAGE_DIR_TABLE_POS], 0
    	add esi, 4
    	loop .clear_page_dir
    	
    @create_pde:
    	mov eax, PAGE_DIR_TABLE_POS
    	;我们将第一个页表放在紧挨着页目录表存放
    	add eax, 0x1000
    	or eax, PG_US_U | PG_RW_W | PG_P
    	;在页目录表中第0项处写入第0个页表的起始地址及其属性
    	mov [PAGE_DIR_TABLE_POS + 0x0], eax
    	;我们将虚拟地址3GB处对应的页目录表项也指向同一个二级页表
    	mov [PAGE_DIR_TABLE_POS+0xC00], eax
    	
    	;为了可以通过虚拟地址访问页目录表和页表，我们将最后一个页目录表项指向页目录表的基地址
    	sub eax, 0x1000
    	mov [PAGE_DIR_TABLE_POS + (0x3FF*4)], eax
    	
    	;下面开始创建页表
    	;由于我们只需要映射低1MB的地址空间，所以对于二级页表来说，我们只需设置前256项
    	mov ecx, 256
    	mov esi, 0
    	;edx指向的是要映射到的物理地址
    	mov edx, 0
    	or edx, PG_US_U | PG_RW_W | PG_P
    	mov eax, PAGE_DIR_TABLE_POS
    	add eax, 0x1000
    @create_pte:
    	mov [eax + esi*4], edx
    	add edx, 4096
    	inc esi
    	loop @create_pte
    	
    	;为了方便后续所有进程共享整个高1GB的内核虚拟地址空间，我们现在就将内核空间的页目录表项全部映射到二级页表
    	mov eax, PAGE_DIR_TABLE_POS
    	add eax, 0x2000
    	;此时eax指向的是第二个页表的物理基地址
    	or eax, PG_US_U | PG_RW_W | PG_P
    	
    	mov ebx, PAGE_DIR_TABLE_POS
    	;和内核相关的页目录表项共有256项
    	;其中第0项和最后一项都已经映射过了，所以现在处理中间的254项
    	mov ecx, 254
    	mov esi, 769
    @create_kernel_pde:
    	mov [ebx + esi*4], eax
    	;一个页表大小为4KB
    	add eax, 0x1000
    	inc esi
    	loop @create_kernel_pde
    	
    	ret
    	
    readSectorFromDisk_m32:
    	;注意待读取的字节数不要让di寄存器溢出
    	;保护模式下从硬盘读取指定数量的逻辑扇区
    	;esi=起始逻辑扇区号LBA28
    	;ds:edi=目标缓冲区地址
    	;cl中存放的是待读取的扇区数
    
    DataRegister equ 0x1F0
    FeatureRegister equ 0x1F1
    SectorRegister equ 0x1F2
    LBAlowRegister equ 0x1F3
    LBAmidRegister equ 0x1F4
    LBAhighRegister equ 0x1F5
    DeviceRegister equ 0x1F6
    CommandRegister equ 0x1F7
    
    ReadCMD	equ 0x20
    WriteCMD	equ 0x30
    IDCMD		equ 0xEC
    
    	push eax
    	push ebx
    	push ecx
    	push edx
    	push edi
    
    	mov eax, esi
    	
    	mov dx, LBAlowRegister
    	out dx, al
    
    	mov dx, LBAmidRegister
    	shr eax, 8
    	out dx, al
    
    	mov dx, LBAhighRegister
    	shr eax, 16
    	out dx, al
    	
    	mov dx, DeviceRegister
    	;LBA28 mode, master disk
    	and ah, 0x0F
    	mov al, 0xe0
    	or al, ah
    	out dx, al
    	
    	mov dx, SectorRegister
    	mov al, cl
    	out dx, al
    	
    	mov dx, CommandRegister 
    	mov al, ReadCMD
    	out dx, al
    	
    .wait4Ready:
    	in al, dx
    	and al, 0x88
    	cmp al, 0x08
    	jnz .wait4Ready
    	
    	;计算待循环的总次数
    	;一个扇区512字节，由于每次读取2个字节，所以一个扇区要读取256次
    	mov ax, 256
    	;如果是8位乘法，结果默认放在AX中
    	;如果是16位乘法，结果高位默认在DX中存放，低位在AX中存放
    	;乘以待读取的扇区数
    	mul cx
    	
    	;由于cl中存储的是待读取的扇区数，所以扇区数不超过255
    	;所以乘积不会超过65536，ax寄存器足以放得下乘积结果
    	mov cx, ax
    
    	mov dx, DataRegister
    .readSectorData:
    	in ax, dx
    	mov word [edi], ax
    	add edi, 2
    	loop .readSectorData
    
    	pop edi
    	pop edx
    	pop ecx
    	pop ebx
    	pop eax
    
    	ret
    	
    kernel_init:
    	;开始解析elf程序头表，加载所有段到对应的虚拟地址
    	xor eax, eax
    	xor ebx, ebx
    	xor ecx, ecx
    	xor edx, edx
    	
    	;ebx记录程序头表的地址，4个字节
    	;因为在ELF Header中e_phoff的字节偏移地址是28
    	mov ebx, [KERNEL_BIN_BASE_ADDR + 28]
    	add ebx, KERNEL_BIN_BASE_ADDR
    	
    	;ecx用来记录程序头表中的段的数量，2个字节
    	;ELF Header中e_phnum的字节偏移地址是44
    	mov cx, [KERNEL_BIN_BASE_ADDR + 44]
    	
    	;edx用来记录程序头表中条目的字节大小，2个字节
    	;ELF Header中e_phentsize的字节偏移地址是42
    	mov dx, [KERNEL_BIN_BASE_ADDR + 42]
    	
    .each_elf_segment:
    	;读取当前段的段类型，如果是PT_NULL，则跳过当前段条目
    	cmp byte [ebx + 0], PT_NULL
    	je .elf_pt_null
    	
    	;段类型检验通过，开始拷贝段条目指向的段到指定的虚拟地址
    	;将memcpy参数压栈，参数从右向左压入
    	;memcpy(virtualDst, virtualSrc, byteSize)
    	;首先压入段的字节大小，p_filesz在Elf32_Phdr的字节偏移是16
    	push dword [ebx + 16]
    	
    	;第二步，压入段的源地址
    	;p_offset在Elf32_Phdr的字节偏移是4
    	;p_offset指明段的起始地址相对于Elf文件开头的字节数
    	mov eax, [ebx + 4]
    	add eax, KERNEL_BIN_BASE_ADDR
    	push eax
    	
    	;第三步，压入目的虚拟地址
    	;p_vaddr在Elf32_Phdr的字节偏移是8
    	push dword [ebx + 8]
    	call memcpy
    	;调用完毕，由调用者清理堆栈
    	add esp, 12
    	
    	
    .elf_pt_null:
    	;让ebx指向程序头表中的下一个段条目
    	add ebx, edx
    	
    	loop .each_elf_segment
    	ret
    	
    
    
    ;memcpy(virtualDst, virtualSrc, byteSize)
    
    memcpy:
    	cld
    	push ebp
    	mov ebp, esp
    	push ecx
    	
    	mov edi, [ebp + 8] 	;dst
    	mov esi, [ebp + 12] 	;src
    	mov ecx, [ebp + 16]	;size
    	;逐字节拷贝
    	rep movsb
    	
    	pop ecx
    	pop ebp
    	ret

## kernel.c ##

int main(void)
    { 
        while(1)
            ;
        
        return 0;	
    }

# 最终内存布局 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221119/92bea73f2367427ca20248360177eb04.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20210130194944939.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20210130195204428.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20210130200019738.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20210130200807187.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20210130203426520.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Jha2VyVGhlR3JlYXQ=,size_16,color_FFFFFF,t_70#pic_center