《x86汇编语言从实模式到保护模式》学习实验笔记【11】保护模式下动态加载内核

墨蓝 2022-12-10 08:39 123阅读 0赞

### 目录 ###

*  本文任务
 *  内核结构
 *   *  定义内核段选择子常量
     *  内核头部
 *  加载过程代码
 *  内核代码
 *  程序运行结果

# 本文任务 #

在上一篇博客中，我们实现了由主引导程序控制进入保护模式。在本篇博客中，我们将实现在保护模式下，主引导程序从硬盘加载内核，并将控制权转交给内核。内核中实现函数调用，打印一行信息。

# 内核结构 #

为实现上述目的，我们将内核分为四部分：

*  代码段
 *  数据段
 *  公共例程段
 *  显存段

其中，公共例程段用于提供各种用途的子过程，以方便内核和之后的用户程序调用。

为方便主引导程序加载内核，我们在内核头部记录了内核文件的总大小，以及上述各个段的位置和大小信息。

## 定义内核段选择子常量 ##

为了便于查看代码和后续调整段的位置，我们将内核中的段选择子声明为常数。有上一篇博客可知，主引导程序的段占用到0x0~0x27，所以内核段选择子从0x28开始。  
同时，我们将常用的功能函数单独放在内核公共例程段中；而视频显示段、堆栈段和0-4GB内存段则和主引导程序共用。

## 内核头部 ##

我们约定:

*  0x0~0x3四个字节用于存储整个内核的长度；
 *  0x4~0x7四个字节用于存储内核代码段首地址；
 *  0x8~0xB用于存储内核例程段首地址；
 *  0xC~0xF用于存储内核数据段首地址；
 *  0x10~0x13用于存储内核入口点32位线性地址
 *  0x14~0x15用于储存内核代码段在GDT中对应的段描述符选择子

具体代码如下所示：

kernel_header:
    ;kernel length
    kernel_length dd (kernel_end - kernel_header)  ;0x0
    ;kernel各个段起始线性地址，用于引导程序重定位内核
    kernel_code_segment dd section.kernel_code.start  		;0x4
    kernel_routine_segment dd section.kernel_routine.start	;0x8
    kernel_data_segment dd section.kernel_data.start  		;0xC	
    
    kernel_entry_point:
    dd 0							;0x10
    dw kernel_code_segment_sel					;0x14

看到这里，大家肯定会有疑问：如果只给主引导程序提供了内核段入口地址，而不提供各个内核段的长度的话，怎么构造GDT内核段描述符呢？

这里我们利用了内核中每个段都是在物理内存中紧挨着的这一特点，来计算得到每个段的长度。我们按照各个段的实际先后顺序，在内核头部定义了各个段的起始线性地址。首先是代码段，之后是内核例程段，最后是数据段。

构造段描述符的具体代码如下：

;构造描述符
    make_gdt_descriptor:                     
    ;输入：EAX=线性基地址
    ;      EBX=段界限
    ;      ECX=属性（各属性位都在原始
    ;      位置，其它没用到的位置0） 
    ;返回：EDX:EAX=完整的描述符
    	mov edx,eax
    	shl eax,16                     
    	or ax,bx                        
    ;描述符前32位(EAX)构造完毕
    ;清除基地址中无关的位
    	and edx,0xffff0000              
    	rol edx,8
    ;装配基址的31~24和23~16  (80486+)
    	bswap edx                       
    
    	xor bx,bx
    ;装配段界限的高4位
    	or edx,ebx                      
    ;装配属性 
    	or edx,ecx                      
    	ret

该过程需要三个输入参数，EAX用于输入段的线性地址，EBX用于输入段的界限，ECX用于输入段属性。需要说明的是，ECX中段属性的位置分布和他们在描述符高32位中的时候完全一致。

# 加载过程代码 #

kernel_physical_address equ 0x40000
    kernel_start_lba equ 1
    
    ;0号描述符
    mbr_0_seg_sel		equ	0x0
    ;引导程序代码段描述符
    mbr_code_seg_sel	equ	0x8
    ;4GB数据段
    mbr_0_4_data_seg_sel	equ	0x10
    ;引导程序堆栈段
    mbr_stack_seg_sel	equ	0x18
    ;引导程序显存段
    mbr_video_seg_sel	equ	0x20
    
    
    segment mbrLoader align=16 vstart=0x7c00
    	xor ax, ax
    	mov ss, ax
    	mov sp, ax
    
    ;将GDT的线性地址转换成逻辑地址
    	mov dx, [cs:gdtData + 2 + 2]
    	mov ax, [cs:gdtData + 2]	
    	mov bx, 16
    	div bx
    	mov es, ax
    	mov di, dx
    
    ;现在es中存储的是gdt起始地址对应的段地址
    ;di中存储的是gdt起始地址对应的偏移地址
    
    ;接下来在实模式下构造GDT
    
    ;首先构造0号描述符
    	mov dword [es:di + mbr_0_seg_sel], 0
    	mov dword [es:di + mbr_0_seg_sel + 4], 0
    
    ;构造引导程序代码段描述符
    	mov dword [es:di + mbr_code_seg_sel], 0x7C0001FF
    	mov dword [es:di + mbr_code_seg_sel + 4], 0x00409800
    	
    ;构造4GB数据段
    	mov dword [es:di + mbr_0_4_data_seg_sel], 0x0000FFFF
    	mov dword [es:di + mbr_0_4_data_seg_sel + 4], 0x00CF9200
    	
    ;构造堆栈段
    	mov dword [es:di + mbr_stack_seg_sel], 0x7c00fffe
    	mov dword [es:di + mbr_stack_seg_sel + 4], 0x00cf9600
    	
    ;构造文本模式 显存段
    	mov dword [es:di + mbr_video_seg_sel], 0x8000FFFF
    	mov dword [es:di + mbr_video_seg_sel + 4], 0x0040920B
    	
    ;初始化GDT表大小
    	mov word [cs:gdtData], 39
    	
    ;加载gdt
    	lgdt [cs:gdtData]
    	
    ;关中断
    	cli
    	
    ;打开A20
    	in al, 0x92
    	or al, 0x2
    	out 0x92, al
    	
    ;使能pe位，进入保护模式
    	mov eax, cr0
    	or eax, 1
    	mov cr0, eax
    	
    ;现在CPU处于保护模式中
    ;清空流水线，串行化CPU
    	jmp dword mbr_code_seg_sel:flush-0x7C00
    	
    [bits 32]
    
    flush:
    ;下面设置保护模式下的段寄存器
    
    ;设置保护模式下的堆栈
    	mov ax, mbr_stack_seg_sel
    	mov ss, ax
    	xor esp,esp
    	
    ;设置保护模式下的数据段
    	mov ax, mbr_0_4_data_seg_sel
    	mov ds, ax
    	
    ;让es指向显存段
    	mov ax, mbr_video_seg_sel
    	mov es, ax		
    ;下面开始从硬盘加载内核	
    	 
    	mov esi, [loading_kernel_lba28]
    	mov edi, [loading_physical_address]
    	
    	call readSectorFromDisk
    	
    	;从内核头部前4个字节读取内核总大小
    	;小端字节序
    	xor eax, eax
    	mov ax, [edi-512]
    	mov dx, [edi-512 + 2]
    	mov bx, 512
    	div bx
    	
    	cmp dx, 0
    	jne @1
    	dec ax
    @1:
    	;考虑实际长度 不超过512个字节的情况
    	or eax, eax
    	jz setup
    	
    	;set loop count
    	;32位模式下的LOOP使用ECX
    	mov ecx, eax
    	
    	;read remain sectors
    	;read next sector
    .readRemainSectors:
    	add esi, 1
    	
    	call readSectorFromDisk
    	loop .readRemainSectors
    ;内核加载完毕
    ;向GDT中添加内核的段描述符号
    ;因为要修改GDT表，所以需要使用数据段来访问GDT
    ;重定位内核入口地址	
    setup:
    ;不可以在代码段内寻址gdtData，但可以通过4GB的段来访问
    	mov esi, [gdtData + 0x02]         
    	mov edi, [loading_physical_address]                                
    	;建立公用例程段描述符
    	;建立kernel代码段描述符
    	;加载kernel代码段起始汇编地址
    	mov eax, [edi+0x04]    
    	;加载kernel公用例程段汇编地址             
    	mov ebx, [edi+0x08]   
    	;两个相邻的段起始地址相减，得到kernel代码段的长度              
    	sub ebx, eax
    	;长度减1即为kernel代码段界限 
    	dec ebx                            
    	;重定位kernel代码段的实际线性地址
    	add eax, edi         
    	;字节粒度的代码段描述符            
    	mov ecx, 0x00409800                 
    	call make_gdt_descriptor
    	mov [esi + 0x28], eax
    	mov [esi + 0x2c], edx
    
    	
    	;建立kernel公共例程段段描述符
    	mov eax, [edi+0x08]                 ;kernel_routine起始汇编地址
    	mov ebx, [edi+0x0c]                 ;kernel_data汇编地址 
    	sub ebx, eax
    	;减1得到kernel_routine段界限
    	dec ebx
    	;重定位kernel_routine段的实际线性地址
    	add eax, edi                        
    	mov ecx,0x00409800                 ;字节粒度的代码段描述符
    	call make_gdt_descriptor
    	mov [esi+0x30],eax
    	mov [esi+0x34],edx 
    
    	;建立kernel_data段描述符
    	;kernel_data起始汇编地址
    	mov eax,[edi+0x0c]   
    	;程序总长度              
    	mov ebx,[edi+0x00]                 
    	sub ebx,eax
    	;减1得到kernel_data段界限
    	dec ebx      
    	;重定位kernel_data段的实际线性地址                      
    	add eax, edi
    	mov ecx, 0x00409200                 ;字节粒度的数据段描述符 
    	call make_gdt_descriptor
    	mov [esi+0x38],eax
    	mov [esi+0x3c],edx
    	
    	;GDT表的界限
    	mov word [gdtData], 63          
    		                
    	lgdt [gdtData]                  
    	;32位下的段间远跳转是 48位远转移
    	jmp far [edi+0x10]  
             
             
    
    loading_kernel_lba28 dd kernel_start_lba
    loading_physical_address dd kernel_physical_address
    
    readSectorFromDisk:
    	;保护模式下从硬盘读取一个逻辑扇区
    	;esi=起始逻辑扇区号LBA28
    	;ds:edi=目标缓冲区地址
    	;返回：edi=edi+512
    
    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
    
    	mov eax, esi
    	
    	mov dx, LBAlowRegister
    	out dx, al
    
    	mov dx, LBAmidRegister
    	shr eax, 8
    	out dx, al
    
    	mov dx, LBAhighRegister
    	mov cl, 16
    	shr eax, cl
    	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, 0x1
    	out dx, al
    	
    	mov dx, CommandRegister 
    	mov al, ReadCMD
    	out dx, al
    	
    .wait4Ready:
    	in al, dx
    	and al, 0x88
    	cmp al, 0x08
    	jnz .wait4Ready
    	
    	mov ecx, 256
    	mov dx, DataRegister
    .readSectorData:
    	in ax, dx
    	mov word [edi], ax
    	add edi, 2
    	loop .readSectorData
    
    	pop edx
    	pop ecx
    	pop ebx
    	pop eax
    
    	ret
      
    ;构造描述符
    make_gdt_descriptor:                     
    ;输入：EAX=线性基地址
    ;      EBX=段界限
    ;      ECX=属性（各属性位都在原始
    ;      位置，其它没用到的位置0） 
    ;返回：EDX:EAX=完整的描述符
    	mov edx,eax
    	shl eax,16                     
    	or ax,bx                        
    ;描述符前32位(EAX)构造完毕
    ;清除基地址中无关的位
    	and edx,0xffff0000              
    	rol edx,8
    ;装配基址的31~24和23~16  (80486+)
    	bswap edx                       
    
    	xor bx,bx
    ;装配段界限的高4位
    	or edx,ebx                      
    ;装配属性 
    	or edx,ecx                      
    	ret
                    
    gdtData:
    	dw 0x0
    	dd 0x7E00		
    
    times 510-($-$$) db 0
    db 0x55,0xaa

# 内核代码 #

;内核代码段选择子
    kernel_code_segment_sel     equ  0x28 
    ;内核公共例程代码段的选择子   
    kernel_routine_segment_sel   equ  0x30
    ;内核数据段选择子    
    kernel_data_segment_sel     equ  0x38  
    
    
    ;视频显示缓冲区的段选择子    
    video_ram_segment_sel     equ  0x20 
    ;内核堆栈段选择子   堆栈和主引导程序共用
    kernel_stack_segment_sel    equ  0x18    
    ;整个0-4GB内存的段的选择子
    mem_0_4_gb_segment_sel    equ  0x10    
             
             
             
    VideoIndexPort equ 0x3D4
    VideoDataPort equ 0x3D5
    
    CursorPosHigh8Index equ 0xE
    CursorPosLow8Index equ 0xF
    
    kernel_header:
    ;kernel length
    kernel_length dd (kernel_end - kernel_header)  ;0x0
    ;kernel各个段起始线性地址，用于引导程序重定位内核
    kernel_code_segment dd section.kernel_code.start  		;0x4
    kernel_routine_segment dd section.kernel_routine.start	;0x8
    kernel_data_segment dd section.kernel_data.start  		;0xC	
    
    
    ;segment relocator item count
    ;dw	(kernel_entry_point - kernel_code_segment)/4		;0x10
    
    kernel_entry_point:
    dd 0							;0x10
    dw kernel_code_segment_sel					;0x14
    
    [bits 32]
    SECTION kernel_code align=16 vstart=0x0
    start:
    	;使用mbr堆栈段
    	mov eax, kernel_stack_segment_sel
    	mov ss, ax
    	xor esp, esp
    	
    
    	mov eax, kernel_data_segment_sel
    	mov ds, ax
    	
    	mov eax, cursorMsg
    	call kernel_routine_segment_sel:printString
    	
    	mov eax, cursorMsg2
    	call kernel_routine_segment_sel:printString
    	
    	mov eax, cursorMsg3
    	call kernel_routine_segment_sel:printString
    
    	mov eax, cursorMsg4
    	call kernel_routine_segment_sel:printString
    	
    	mov eax, cursorMsg5
    	call kernel_routine_segment_sel:printString
    	
    	mov eax, cursorMsg6
    	call kernel_routine_segment_sel:printString
    	
    	;halt
    	hlt
    
    
    ;系统公共例程代码段 
    section kernel_routine vstart=0                
    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
    	retf
    
    setCursorPosition:
    ;ax中存储光标的位置，值域[0, 1999]
    	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	
    	retf
    	
    printString:
    	push eax
    	push esi
    	
    	;save string start address to si
    	mov esi, eax
    	
    ;获取字符串中当前字符，若是0,则结束
    @1: mov al, [esi]
    	cmp al, 0
    	je @2
    	
    	call kernel_routine_segment_sel:printCharacter
    	
    	inc esi
    	jmp @1
    	
    @2:
    	pop esi
    	pop eax
    	
    	retf	
    
    printCharacter:
    	push es
    	push ds
    	push esi
    	push eax
    	push edi
    	push ebx
    	push ecx
    	
    	mov ebx, eax
    	
    	;set video buffer selector
    	mov eax, video_ram_segment_sel
       	mov es, eax
       	   		
    	;get cursor pos to ax
    	call kernel_routine_segment_sel:getCursorPosition
    	;move current cursor pos to di
    	mov di, ax
    	;1 character consumes 2 bytes
    	shl di, 1
    
    ;由于默认的文本模式下屏幕是25行x80列，共计2000个字符
    ;每个字符占据两个字节（一个是字符，一个是显示属性）
    	cmp di, 4000
    ;若屏幕满，则滚屏
    	jne .ScreenIsNotFull
    	call kernel_routine_segment_sel:rollTheScreen
    ;滚屏之后，需要将光标位置索引减去80*2
    	sub di, 80*2
    .ScreenIsNotFull:	
    	;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
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    	mul bh
    	shl ax, 1
    	mov di, ax
    	jmp .doneWithPrintCharacter
    	
    .handleNewLine:
    	mov ax, di
    	shr ax, 1
    	mov bh, 80
    	div bh
    ;判断如果光标处于屏幕最后一行，由于现在输出的是换行符0xA，所以需要滚屏，并将光标置于最后一行第一列
    	cmp al, 24
    	jl .addAnotherNewLine
    	
    	;roll the Screen
    	call kernel_routine_segment_sel:rollTheScreen
    	jmp .doneWithPrintCharacter
    	mov di, (2000-80)*2
    .addAnotherNewLine:
    	;just add another new line if it is not the last line
    	add di, 160
    .doneWithPrintCharacter:	
    	;write new cursor pos to video card
    	mov ax, di
    	shr ax, 1
    	call kernel_routine_segment_sel:setCursorPosition
    	
    	pop ecx
    	pop ebx
    	pop edi
    	pop eax
    	pop esi
    	pop ds
    	pop es
    	retf
    
    
    
    rollTheScreen:
    	push edi
    	push eax
    	push ds
    	push es
    	push ebx
    	
    	mov ax, video_ram_segment_sel
    	mov ds, ax
    	mov es, ax
    ;方向标志DF清零，使得SI和DI往地址增大方向移动
    	cld
    ;将屏幕从第二行到最后一行内容，依次向上移动一行
    	mov ecx, 2000-80
    	mov edi, 0
    	mov esi, 160
    	rep movsw
    	;clear screen last line
    	mov ebx, (2000-80)*2                     
    	mov ecx, 80
     .cls:
    ;使用空格填充屏幕最后一行
    	mov word [es:bx], 0x0720
    	add bx, 2
    	loop .cls
    	;将光标置于最后一行行首
    	mov eax, 2000-80
    	call kernel_routine_segment_sel:setCursorPosition
    	
    	pop ebx
    	pop es
    	pop ds
    	pop eax
    	pop edi
    	retf
    	
    section kernel_data align=16 vstart=0
    
    cursorMsg: db 'Congratulations! We are in kernel now!', 0
    cursorMsg2: db ' Everything goes well.', 0
    cursorMsg3: db 0xd, 0xa, 'Start from Head.', 0
    
    cursorMsg4: db 0xd, 0xa,0xa,0xa,0xa,0xa,'After change line.', 0xa, 'Another line.', 0
    cursorMsg5: db 0xa, 'the 8th line.', 0xa, '9th', 0xa, '10th', 0xa, 0xa, 0xa, 0xa,0xa,0xa
    db 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 0xa, 'This is the last line.', 0
    cursorMsg6: db 0xa, 0xd, 'Congratulations! Everything runs well in kernel!', 0
    
    
    section end align=16
    kernel_end:

# 程序运行结果 #

![在这里插入图片描述][20201001203720799.gif_pic_center]

[20201001203720799.gif_pic_center]: /images/20221123/89e87e7dd3c74303a1cf53640f35203c.png