x86架构：保护模式下加载并运行用户程序
2024-09-04 21:03:56
本章的代码分3个模块：
- MBR 引导：加载内核core程序
- core：包含内核代码段（从磁盘加载用户程序并重定位）、内核数据段（存放api名称、临时缓冲、字符串等）、API段（供用户程序调用）
- 用户程序：调用内核API打印字符串、读写磁盘
- 内核程序、用户程序：这里的重定位，本质上是根据在内存中的实际位置和段的读写属性定制化构造描述符与选择子，后续可以根据业务需求通过给段寄存器赋值不同的选择子来灵活读写各个段；
所有代码加起来有近900行，为了便于理解整体的思路，我整理了一下代码的核心逻辑，如下：
- MBR程序会在实模式下在0x7e00处设置4个描述符，分别打开A20和CR0的PE位后进入保护模式；
- 从LBA=1处出去core代码，存放在0x40000开始的位置；
- core有内核代码段、内核数据段、API段，分别构造段描述符，并追加在原描述符的末尾，然后重新lgdt，内核加载完毕
- 内核代码段从LBA=50处加载用户程序，并根据段的数量和属性，再次在现有的GDT表末尾追加段描述符，并重新lgdt
- 用户程序调用系统API打印和读取磁盘数据
- 从用户程序jmpf回内核core代码，终止用户程序
下面详细解读各个阶段的细节要点：
1、MBR程序
（1）实模式下构造GDT：
- cs和ss段基址相同，但cs向高地址扩展，ss向低地址扩展，不冲突
- 数据段对地址没限制，使用的时候需要注意不要写到其他段了
- GDT的基址在0x7e00处，距离0x7c00还有512字节，刚好是一个扇区的距离，所以不会覆盖MBR本身的任何代码
;跳过0#号描述符的槽位
;创建1#描述符，这是一个数据段，对应0~4GB的线性地址空间
mov dword [ebx+0x08],0x0000ffff ;基地址为0，段界限为0xFFFFF
mov dword [ebx+0x0c],0x00cf9200 ;粒度为4KB，存储器段描述符 ;创建保护模式下初始代码段描述符
mov dword [ebx+0x10],0x7c0001ff ;基地址为0x00007c00，界限0x1FF
mov dword [ebx+0x14],0x00409800 ;粒度为1个字节，代码段描述符 ;建立保护模式下的堆栈段描述符 ;基地址为0x00007C00，界限0xFFFFE
mov dword [ebx+0x18],0x7c00fffe ;粒度为4KB
mov dword [ebx+0x1c],0x00cf9600 ;建立保护模式下的显示缓冲区描述符
mov dword [ebx+0x20],0x80007fff ;基地址为0x000B8000，界限0x07FFF
mov dword [ebx+0x24],0x0040920b ;粒度为字节 ;初始化描述符表寄存器GDTR
mov word [cs: pgdt+0x7c00], ;描述符表的界限 lgdt [cs: pgdt+0x7c00]
（2）打开A20、设置CR0的PE位，https://www.cnblogs.com/theseventhson/p/13042476.html 有详细解释，供参考；
2、从磁盘LBA=1处读取core完整代码，存放在内存0x40000开始处；
一般情况下，加载磁盘的目标文件之前是不知道文件大小的，所以并不知道需要从磁盘读取多少字节，也不知道应该申请多少内存存储这些数据，所以需要在程序头部标明该文件的大小、各个段的起始地址（方便重定位），这就是windows下PE文件、linux下ELF文件的雏形；
mov edi,core_base_address
mov eax,core_start_sector
mov ebx,edi ;起始地址
call read_hard_disk_0 ;以下读取程序的起始部分（一个扇区）
;以下判断整个程序有多大
mov eax,[edi] ;核心程序尺寸
xor edx,edx
mov ecx, ;512字节每扇区
div ecx
or edx,edx
jnz @1 ;未除尽，因此结果比实际扇区数少1
dec eax ;已经读了一个扇区，扇区总数减1
@1:
or eax,eax ;考虑实际长度≤512个字节的情况
jz setup ;EAX=0 ?
;读取剩余的扇区
mov ecx,eax ;32位模式下的LOOP使用ECX
mov eax,core_start_sector
inc eax ;从下一个逻辑扇区接着读
@2:
call read_hard_disk_0
inc eax
loop @2 ;循环读，直到读完整个内核
3、core内核程序有3个段：内核代码段、内核数据段、API段，根据各个段的实际情况构造描述符，并在原0x7e00已有的描述符后追加各个段的描述符，然后重新加载
setup: ;系统各个段在0x00040000内存中重定位
mov esi,[0x7c00+pgdt+0x02] ;不可以在代码段内寻址pgdt，但可以
;通过4GB的段来访问, esi=0x7e00
;建立公用例程段描述符
mov eax,[edi+0x04] ;公用例程sys_routine代码段起始汇编地址=0x18；edi=0x00040000
mov ebx,[edi+0x08] ;核心数据段core_data汇编地址=0x01e4
sub ebx,eax ;core_data紧跟着sys_routine，core_data-sys_routine得到sys_routine长度
dec ebx ;core_data的前面，也就是公用例程段sys_routine界限
add eax,edi ;公用例程段基地址：sys_routine=0x18，加上0x00040000得到sys_routine在内存的地址；
mov ecx,0x00409800 ;字节粒度的代码段描述符
call make_gdt_descriptor
mov [esi+0x28],eax ;描述符低32位eax=0x001801cb
mov [esi+0x2c],edx ;描述符高32位edx=0x00409804
;00409804`001801cb: 段基址00040018，limit=0x01cb;4:G=0,D/B=1,L=0,AVL=0;9:p=1,DPL=00,s=1;TYPE=8是代码段;
;在0x7e00处原描述符的末尾追加新描述符，原有描述符不变 ;建立核心数据段描述符
mov eax,[edi+0x08] ;核心数据段起始汇编地址
mov ebx,[edi+0x0c] ;核心代码段汇编地址
sub ebx,eax
dec ebx ;核心数据段界限
add eax,edi ;核心数据段基地址
mov ecx,0x00409200 ;字节粒度的数据段描述符
call make_gdt_descriptor
mov [esi+0x30],eax
mov [esi+0x34],edx ;建立核心代码段描述符
mov eax,[edi+0x0c] ;核心代码段core_code起始汇编地址
mov ebx,[edi+0x00] ;程序总长度
sub ebx,eax
dec ebx ;核心代码段界限
add eax,edi ;核心代码段基地址
mov ecx,0x00409800 ;字节粒度的代码段描述符
call make_gdt_descriptor
mov [esi+0x38],eax
mov [esi+0x3c],edx mov word [0x7c00+pgdt], ;描述符表的界限 lgdt [0x7c00+pgdt] ;保护模式新增3个段，分别对应内核3个段
4、加载用户程序到0x100000处，并重定位
（1）先读取一个扇区的数据到内核数据段的core_buf处：
mov eax,core_data_seg_sel
mov ds,eax ;切换DS到内核数据段 mov eax,esi ;esi=50,用户程序所在扇区
mov ebx,core_buf ;core_buf相对段偏移0x516
call sys_routine_seg_sel:read_hard_disk_0 ;先读取用户程序头部一个扇区，包括程序大小、各个段的开始位置
- core_buf 位于 ds:0x516= 0x401e4+0x516=0x406fa，此时还并未在0x100000处；
- 用户程序大小：0x7bc=1980byte；
（2）再看看用户程序的大小，为后续申请内存空间做准备；大小如果不是512字节对齐，要先去掉零头（低9位清零），再增加512字节，即 “申请的空间大小 - 用户程序大小<512“ ，并且”申请的空间大小%512=0” ；
;以下判断整个程序有多大
mov eax,[core_buf] ;用户程序head前4字节program_length存储了整个程序大小eax=0x7bc；读取的时候以00结尾
mov ebx,eax
and ebx,0xfffffe00 ;低9位清零，才能被512整除；相当于去掉除以512后的余数（零头）；ebx=0x600
add ebx, ;低9位都为0 ebx=0x800
test eax,0x000001ff ;程序的大小正好是512的倍数吗?
cmovnz eax,ebx ;不是。使用凑整的结果 eax = ebx =0x800
（3）用户程序需要分配0x800字节的内存，调用allocate_memory函数在0x100000处申请0x800的空间；
mov ecx,eax ;实际需要申请的内存数量ecx=0x800
call sys_routine_seg_sel:allocate_memory
mov ebx,ecx ;ebx=0x100000 -> 申请到的内存首地址 ecx = 0x100000
push ebx ;保存该首地址
xor edx,edx
mov ecx, ;eax=0800，除以512=4
div ecx
mov ecx,eax ;总扇区数ecx=4
allocate_memory 在0x100000处开始分配内存：
这次申请了0x800的空间，那么下次再申请就从0x100800开始，也要把这个值写回ram_alloc处；
（4）这次重新从LBA=50的扇区循环读4个扇区的数据到刚申请的内存空间0x100000处；之前读了一个扇区是为了获取用户程序的长度，进而确定所需的内存空间，core_buf只是临时存放地点；
mov eax,mem_0_4_gb_seg_sel ;切换DS到0-4GB的段
mov ds,eax mov eax,esi ;用户程序在磁盘的起始扇区号eax=50
.b1:
call sys_routine_seg_sel:read_hard_disk_0 ;DS:EBX=用户程序在内存中的存储地址
inc eax
loop .b1 ;循环读，直到读完整个用户程序
（5）根据用户程序头部构造相应的描述符：
;建立程序头部段描述符
pop edi ;恢复程序装载的首地址：上面push ebx，把分配的内存首地址0x100000入栈
mov eax,edi ;程序头部起始线性地址eax=edi=0x100000，为用户程序分配的内存首地址
mov ebx,[edi+0x04] ;ebx=段长度=0x328
dec ebx ;ebx=段界限=0x327
mov ecx,0x00409200 ;字节粒度的数据段描述符
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [edi+0x04],cx ;选择子写回 ;建立程序代码段描述符
mov eax,edi
add eax,[edi+0x14] ;代码起始线性地址
mov ebx,[edi+0x18] ;段长度
dec ebx ;段界限
mov ecx,0x00409800 ;字节粒度的代码段描述符
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [edi+0x14],cx ;建立程序数据段描述符
mov eax,edi
add eax,[edi+0x1c] ;数据段起始线性地址
mov ebx,[edi+0x20] ;段长度
dec ebx ;段界限
mov ecx,0x00409200 ;字节粒度的数据段描述符
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [edi+0x1c],cx ;建立程序堆栈段描述符
mov ecx,[edi+0x0c] ;4KB的倍率
mov ebx,0x000fffff
sub ebx,ecx ;得到段界限
mov eax,
mul dword [edi+0x0c]
mov ecx,eax ;准备为堆栈分配内存
call sys_routine_seg_sel:allocate_memory
add eax,ecx ;得到堆栈的高端物理地址
mov ecx,0x00c09600 ;4KB粒度的堆栈段描述符
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [edi+0x08],cx
构造好的描述符同样会在原0x7e00的尾部逐个追加保存：
set_up_gdt_descriptor: ;在现有GDT尾部新增新描述符
;输入：EDX:EAX=描述符
;输出：CX=描述符的选择子
push eax
push ebx
push edx push ds
push es mov ebx,core_data_seg_sel ;切换到核心数据段
mov ds,ebx sgdt [pgdt] ;以便开始处理GDT mov ebx,mem_0_4_gb_seg_sel
mov es,ebx ;es=0x8 movzx ebx,word [pgdt] ;ebx=GDT界限limit=0x003f
inc bx ;ebx=GDT表总字节数=0x40=64，也是下一个描述符偏移
add ebx,[pgdt+] ;ebx=0x7e40下一个描述符的线性地址 mov [es:ebx],eax
mov [es:ebx+],edx add word [pgdt], ;增加一个描述符的大小 lgdt [pgdt] ;对GDT的更改生效 mov ax,[pgdt] ;eax=GDT界限值=0x47
xor dx,dx
mov bx,
div bx ;除以8，去掉余数
mov cx,ax ;尾部新增描述符的索引位置=8
shl cx, ;将索引号移到正确位置 pop es
pop ds pop edx
pop ebx
pop eax retf
以下是执行过程：
- 保存现GDT表的base（0x7e00）和limit（0x3f）到原地址：ds=0x401e4,偏移=0
- GDT表的基址还是0x7e00，在以前的结尾处新增一个描述符，同时limit增加8字节；
- 尾部新增描述符在第8个，每个描述符8字节，那么新增描述符偏移就是8*8，相当于索引号左移3位，cx就是新增描述符的偏移（字节为单位）；
- 新增4个描述符的结果
- 这些描述符的选择子又被写回用户程序的头部保存
（6）用户程序各个段重定位，这里相当于导入表，详细记录了本程序需要调用的API名称：
;重定位SALT
mov eax,[edi+0x04] ;用户程序头部长度（注意不是整个长度）eax=0x40
mov es,eax ;es -> 用户程序头部
mov eax,core_data_seg_sel
mov ds,eax ;ds=0x30,base=0x000401e4, limit=0x00000d57
取出用户程序头部的选择子，放入es；同时让ds指向内核数据段：
ecx：存放了导入函数个数=3
这里用户程序调用系统API的查找过程比较简单粗暴：直接对比函数名，匹配上了就把系统API的段选择子、偏移写回用户程序的导入表，用户程序调用时才能跳转到系统API处执行；这里多说一句，windows下的系统调用过程类似，只不过是根据调用号在SSDT查询内核API地址，同时还涉及到0环与3环之间的通过sysenter/sysexit或syscall/sysret进出，后续会专门介绍；
注意：这里rdi=128，是16进制的，转成10进制是296，减去256=40=0x28，刚好是PrintString标签的开始处：
（7）用户程序加载、重定位完毕，保存内核堆栈，跳转到用户程序执行：
mov [esp_pointer],esp ;临时保存堆栈指针
mov ds,ax
jmp far [0x10] ;控制权交给用户程序（入口点）
;堆栈可能切换
5、用户程序：比较简单，直接调用系统API打印和读取磁盘数据，再跳回内核程序
start:
mov eax,ds
mov fs,eax mov eax,[stack_seg]
mov ss,eax
mov esp, mov eax,[data_seg]
mov ds,eax mov ebx,message_1
call far [fs:PrintString] mov eax, ;逻辑扇区号100
mov ebx,buffer ;缓冲区偏移地址
call far [fs:ReadDiskData] ;段间调用 mov ebx,message_2
call far [fs:PrintString] mov ebx,buffer
call far [fs:PrintString] ;too. jmp far [fs:TerminateProgram] ;将控制权返回到系统 code_end:
6、jmp far [fs:TerminateProgram] 跳转回内核程序：ds切回内核数据段，sp切回内核堆栈段，可额外新增结束用户程序的代码，比如调用allocte_memory时分配内存的回收，各种临时缓存、数据结构（windwos下进程相关的PEB、EPROCESS、TEB等关键结构体）的清零；
新手注意：
1、jmp指令（call指令类似）
直接跳转：
- 实模式 jmp 0x7c00:0x10 = 0x7c00<<4+0x10 = 0x7c010
- 保护模式：jmp 0x38:0x10 先根据selector查找基址，再加上0x10
间接跳转：
- jmp far [edi+0x10]
默认用数据段，这里ds.selector=0x08, ds基址=0x0，edi=0x40000，所以需要取0x40010开始的6byte，高2byte作为cs.selector，低4byte作为偏移，如下：
cs.selector=0x38，偏移=0x15d；cs基址=0x40f3c，加上0x15d的偏移=0x41099，就是jmp的目标地址，如下：
完整代码：
1、MBR引导代码
core_base_address equ 0x00040000 ;常数，内核加载的起始内存地址
core_start_sector equ 0x00000001 ;常数，内核的起始逻辑扇区号 mov ax,cs
mov ss,ax
mov sp,0x7c00 ;计算GDT所在的逻辑段地址
mov eax,[cs:pgdt+0x7c00+0x02] ;GDT的32位物理地址
xor edx,edx
mov ebx,
div ebx ;分解成16位逻辑地址 mov ds,eax ;令DS指向该段以进行操作;ds=0x7e0
mov ebx,edx ;段内起始偏移地址,ebx =0x00 ;跳过0#号描述符的槽位
;创建1#描述符，这是一个数据段，对应0~4GB的线性地址空间
mov dword [ebx+0x08],0x0000ffff ;基地址为0，段界限为0xFFFFF
mov dword [ebx+0x0c],0x00cf9200 ;粒度为4KB，存储器段描述符 ;创建保护模式下初始代码段描述符
mov dword [ebx+0x10],0x7c0001ff ;基地址为0x00007c00，界限0x1FF
mov dword [ebx+0x14],0x00409800 ;粒度为1个字节，代码段描述符 ;建立保护模式下的堆栈段描述符 ;基地址为0x00007C00，界限0xFFFFE
mov dword [ebx+0x18],0x7c00fffe ;粒度为4KB
mov dword [ebx+0x1c],0x00cf9600 ;建立保护模式下的显示缓冲区描述符
mov dword [ebx+0x20],0x80007fff ;基地址为0x000B8000，界限0x07FFF
mov dword [ebx+0x24],0x0040920b ;粒度为字节 ;初始化描述符表寄存器GDTR
mov word [cs: pgdt+0x7c00], ;描述符表的界限 lgdt [cs: pgdt+0x7c00] in al,0x92 ;南桥芯片内的端口
or al,0000_0010B
out 0x92,al ;打开A20 cli ;中断机制尚未工作 mov eax,cr0
or eax,
mov cr0,eax ;设置PE位 ;以下进入保护模式... ...
jmp dword 0x0010:flush ;16位的描述符选择子：32位偏移
;清流水线并串行化处理器
[bits ]
flush:
mov eax,0x0008 ;以前是实模式的段基址，现在重新加载保护模式的数据段(0..4GB)选择子
mov ds,eax mov eax,0x0018 ;加载堆栈段选择子
mov ss,eax
xor esp,esp ;堆栈指针 <- 0 ;以下加载系统核心程序
mov edi,core_base_address mov eax,core_start_sector
mov ebx,edi ;起始地址
call read_hard_disk_0 ;以下读取程序的起始部分（一个扇区） ;以下判断整个程序有多大
mov eax,[edi] ;核心程序尺寸
xor edx,edx
mov ecx, ;512字节每扇区
div ecx or edx,edx
jnz @1 ;未除尽，因此结果比实际扇区数少1
dec eax ;已经读了一个扇区，扇区总数减1
@1:
or eax,eax ;考虑实际长度≤512个字节的情况
jz setup ;EAX=0 ? ;读取剩余的扇区
mov ecx,eax ;32位模式下的LOOP使用ECX
mov eax,core_start_sector
inc eax ;从下一个逻辑扇区接着读
@2:
call read_hard_disk_0
inc eax
loop @2 ;循环读，直到读完整个内核 setup: ;系统各个段在0x00040000内存中重定位
mov esi,[0x7c00+pgdt+0x02] ;不可以在代码段内寻址pgdt，但可以
;通过4GB的段来访问, esi=0x7e00
;建立公用例程段描述符
mov eax,[edi+0x04] ;公用例程sys_routine代码段起始汇编地址=0x18；edi=0x00040000
mov ebx,[edi+0x08] ;核心数据段core_data汇编地址=0x01e4
sub ebx,eax ;core_data紧跟着sys_routine，core_data-sys_routine得到sys_routine长度
dec ebx ;core_data的前面，也就是公用例程段sys_routine界限
add eax,edi ;公用例程段基地址：sys_routine=0x18，加上0x00040000得到sys_routine在内存的地址；
mov ecx,0x00409800 ;字节粒度的代码段描述符
call make_gdt_descriptor
mov [esi+0x28],eax ;描述符低32位eax=0x001801cb
mov [esi+0x2c],edx ;描述符高32位edx=0x00409804
;00409804`001801cb: 段基址00040018，limit=0x01cb;4:G=0,D/B=1,L=0,AVL=0;9:p=1,DPL=00,s=1;TYPE=8是代码段;
;在0x7e00处原描述符的末尾追加新描述符，原有描述符不变 ;建立核心数据段描述符
mov eax,[edi+0x08] ;核心数据段起始汇编地址
mov ebx,[edi+0x0c] ;核心代码段汇编地址
sub ebx,eax
dec ebx ;核心数据段界限
add eax,edi ;核心数据段基地址
mov ecx,0x00409200 ;字节粒度的数据段描述符
call make_gdt_descriptor
mov [esi+0x30],eax
mov [esi+0x34],edx ;建立核心代码段描述符
mov eax,[edi+0x0c] ;核心代码段core_code起始汇编地址
mov ebx,[edi+0x00] ;程序总长度
sub ebx,eax
dec ebx ;核心代码段界限
add eax,edi ;核心代码段基地址
mov ecx,0x00409800 ;字节粒度的代码段描述符
call make_gdt_descriptor
mov [esi+0x38],eax
mov [esi+0x3c],edx mov word [0x7c00+pgdt], ;描述符表的界限 lgdt [0x7c00+pgdt] ;保护模式新增3个段，分别对应内核3个段 jmp far [edi+0x10] ;edi=0x00040000，edi+0x10=core_code ;-------------------------------------------------------------------------------
read_hard_disk_0: ;从硬盘读取一个逻辑扇区
;EAX=逻辑扇区号
;DS:EBX=目标缓冲区地址
;返回：EBX=EBX+512
push eax
push ecx
push edx push eax mov dx,0x1f2
mov al,
out dx,al ;读取的扇区数 inc dx ;0x1f3
pop eax
out dx,al ;LBA地址7~0 inc dx ;0x1f4
mov cl,
shr eax,cl
out dx,al ;LBA地址15~8 inc dx ;0x1f5
shr eax,cl
out dx,al ;LBA地址23~16 inc dx ;0x1f6
shr eax,cl
or al,0xe0 ;第一硬盘 LBA地址27~24
out dx,al inc dx ;0x1f7
mov al,0x20 ;读命令
out dx,al .waits:
in al,dx
and al,0x88
cmp al,0x08
jnz .waits ;不忙，且硬盘已准备好数据传输 mov ecx, ;总共要读取的字数
mov dx,0x1f0
.readw:
in ax,dx
mov [ebx],ax
add ebx,
loop .readw pop edx
pop ecx
pop eax ret ;-------------------------------------------------------------------------------
make_gdt_descriptor: ;构造描述符
;输入：EAX=线性基地址,比如sys_routine=0x00040018；
; EBX=段界限，比如sys_routine=0x1e4-0x18-1=0x1cb
; ECX=属性（各属性位都在原始 比如sys_routine=0x00409800
; 位置，其它没用到的位置0）
;返回：EDX:EAX=完整的描述符
mov edx,eax
shl eax, ;eax从0x00040018变为0x00180000；
or ax,bx ;描述符前32位(EAX)构造完毕，eax=0x001801cb; and edx,0xffff0000 ;清除基地址中无关的位 edx=0x00040000
rol edx, ;edx = 0x04000000
bswap edx ;装配基址的31~24和23~16 (80486+); edx = 0x00000004; 31-24于0-7交换，23-16与8-15交换 xor bx,bx ;ebx=0x00000000
or edx,ebx ;装配段界限的高4位,edx=0x00000004 or edx,ecx ;装配属性 edx=0x00409804 ret ;-------------------------------------------------------------------------------
pgdt dw
dd 0x00007e00 ;GDT的物理地址
;-------------------------------------------------------------------------------
times -($-$$) db
db 0x55,0xaa
2、内核代码
;以下常量定义部分。内核的大部分内容都应当固定
core_code_seg_sel equ 0x38 ;内核代码段选择子
core_data_seg_sel equ 0x30 ;内核数据段选择子
sys_routine_seg_sel equ 0x28 ;系统公共例程代码段的选择子
video_ram_seg_sel equ 0x20 ;视频显示缓冲区的段选择子
core_stack_seg_sel equ 0x18 ;内核堆栈段选择子
mem_0_4_gb_seg_sel equ 0x08 ;整个0-4GB内存的段的选择子 ;-------------------------------------------------------------------------------
;以下是系统核心的头部，用于加载核心程序
core_length dd core_end ;核心程序总长度#00 sys_routine_seg dd section.sys_routine.start
;系统公用例程段位置#04 core_data_seg dd section.core_data.start
;核心数据段位置#08 core_code_seg dd section.core_code.start
;核心代码段位置#0c core_entry dd start ;核心代码段入口点#10
dw core_code_seg_sel ;0x38 ;===============================================================================
[bits ]
;===============================================================================
SECTION sys_routine vstart= ;系统公共例程代码段
;-------------------------------------------------------------------------------
;字符串显示例程
put_string: ;显示0终止的字符串并移动光标
;输入：DS:EBX=串地址
push ecx
.getc:
mov cl,[ebx]
or cl,cl
jz .exit
call put_char
inc ebx
jmp .getc .exit:
pop ecx
retf ;段间返回 ;-------------------------------------------------------------------------------
put_char: ;在当前光标处显示一个字符,并推进
;光标。仅用于段内调用
;输入：CL=字符ASCII码
pushad ;以下取当前光标位置
mov dx,0x3d4
mov al,0x0e
out dx,al
inc dx ;0x3d5
in al,dx ;高字
mov ah,al dec dx ;0x3d4
mov al,0x0f
out dx,al
inc dx ;0x3d5
in al,dx ;低字
mov bx,ax ;BX=代表光标位置的16位数 cmp cl,0x0d ;回车符？
jnz .put_0a
mov ax,bx
mov bl,
div bl
mul bl
mov bx,ax
jmp .set_cursor .put_0a:
cmp cl,0x0a ;换行符？
jnz .put_other
add bx,
jmp .roll_screen .put_other: ;正常显示字符
push es
mov eax,video_ram_seg_sel ;0xb8000段的选择子
mov es,eax
shl bx,
mov [es:bx],cl
pop es ;以下将光标位置推进一个字符
shr bx,
inc bx .roll_screen:
cmp bx, ;光标超出屏幕？滚屏
jl .set_cursor push ds
push es
mov eax,video_ram_seg_sel
mov ds,eax
mov es,eax
cld
mov esi,0xa0 ;小心！32位模式下movsb/w/d
mov edi,0x00 ;使用的是esi/edi/ecx
mov ecx,
rep movsd
mov bx, ;清除屏幕最底一行
mov ecx, ;32位程序应该使用ECX
.cls:
mov word[es:bx],0x0720
add bx,
loop .cls pop es
pop ds mov bx, .set_cursor:
mov dx,0x3d4
mov al,0x0e
out dx,al
inc dx ;0x3d5
mov al,bh
out dx,al
dec dx ;0x3d4
mov al,0x0f
out dx,al
inc dx ;0x3d5
mov al,bl
out dx,al popad
ret ;-------------------------------------------------------------------------------
read_hard_disk_0: ;从硬盘读取一个逻辑扇区
;EAX=磁盘逻辑扇区号
;DS:EBX=用户程序在内存中的存储地址
;返回：EBX=EBX+512
push eax
push ecx
push edx push eax mov dx,0x1f2
mov al,
out dx,al ;读取的扇区数 inc dx ;0x1f3
pop eax
out dx,al ;LBA地址7~0 inc dx ;0x1f4
mov cl,
shr eax,cl
out dx,al ;LBA地址15~8 inc dx ;0x1f5
shr eax,cl
out dx,al ;LBA地址23~16 inc dx ;0x1f6
shr eax,cl
or al,0xe0 ;第一硬盘 LBA地址27~24
out dx,al inc dx ;0x1f7
mov al,0x20 ;读命令
out dx,al .waits:
in al,dx
and al,0x88
cmp al,0x08
jnz .waits ;不忙，且硬盘已准备好数据传输 mov ecx, ;总共要读取的字数
mov dx,0x1f0
.readw:
in ax,dx
mov [ebx],ax
add ebx, ;ecx=256次循环，每次读取2字节，一共读取512字节
loop .readw pop edx
pop ecx
pop eax retf ;段间返回 ;-------------------------------------------------------------------------------
;汇编语言程序是极难一次成功，而且调试非常困难。这个例程可以提供帮助
put_hex_dword: ;在当前光标处以十六进制形式显示
;一个双字并推进光标
;输入：EDX=要转换并显示的数字
;输出：无
pushad
push ds mov ax,core_data_seg_sel ;切换到核心数据段
mov ds,ax mov ebx,bin_hex ;指向核心数据段内的转换表
mov ecx,
.xlt:
rol edx,
mov eax,edx
and eax,0x0000000f
xlat push ecx
mov cl,al
call put_char
pop ecx loop .xlt pop ds
popad
retf ;-------------------------------------------------------------------------------
allocate_memory: ;分配内存
;输入：ECX=希望分配的字节数
;输出：ECX=起始线性地址
push ds
push eax
push ebx mov eax,core_data_seg_sel
mov ds,eax mov eax,[ram_alloc] ;eax=0x100000
add eax,ecx ;下一次分配时的起始地址eax=0x100000+0x800=0x100800 ;这里应当有检测可用内存数量的指令 mov ecx,[ram_alloc] ;返回分配的起始地址0x100000 mov ebx,eax ;ebx=0x100800
and ebx,0xfffffffc ;低2位强制清零，使得512字节对齐；ebx=0x100800
add ebx, ;强制4字节对齐，便于内存快速寻址； ebx=0x100804
test eax,0x00000003 ;下次分配的起始地址最好是4字节对齐 eax=0x100800
cmovnz eax,ebx ;如果eax=0x100800没有对齐，则强制用ebx=0x100804对齐;
mov [ram_alloc],eax ;下次从该地址分配内存
;cmovcc指令可以避免控制转移 ram_alloc=0x100800
pop ebx
pop eax
pop ds retf ;-------------------------------------------------------------------------------
set_up_gdt_descriptor: ;在现有GDT尾部新增新描述符
;输入：EDX:EAX=描述符
;输出：CX=描述符的选择子
push eax
push ebx
push edx push ds
push es mov ebx,core_data_seg_sel ;切换到核心数据段
mov ds,ebx sgdt [pgdt] ;以便开始处理GDT mov ebx,mem_0_4_gb_seg_sel
mov es,ebx ;es=0x8 movzx ebx,word [pgdt] ;ebx=GDT界限limit=0x003f
inc bx ;ebx=GDT表总字节数=0x40=64，也是下一个描述符偏移
add ebx,[pgdt+] ;ebx=0x7e40下一个描述符的线性地址 mov [es:ebx],eax
mov [es:ebx+],edx add word [pgdt], ;增加一个描述符的大小 lgdt [pgdt] ;对GDT的更改生效 mov ax,[pgdt] ;eax=GDT界限值=0x47
xor dx,dx
mov bx,
div bx ;除以8，去掉余数
mov cx,ax ;尾部新增描述符的索引位置=8
shl cx, ;将索引号移到正确位置 pop es
pop ds pop edx
pop ebx
pop eax retf
;-------------------------------------------------------------------------------
make_seg_descriptor: ;构造存储器和系统的段描述符
;输入：EAX=线性基地址
; EBX=段界限
; ECX=属性。各属性位都在原始
; 位置，无关的位清零
;返回：EDX:EAX=描述符
mov edx,eax ;edx=eax=0x00100000
shl eax, ;eax=0x00000000
or ax,bx ;描述符前32位(EAX)构造完毕;eax=ebx=0x327 and edx,0xffff0000 ;清除基地址中无关的位 edx=0x00100000
rol edx, ;edx=0x10000000
bswap edx ;装配基址的31~24和23~16 (80486+);edx=0x10 xor bx,bx
or edx,ebx ;装配段界限的高4位edx=0x10 or edx,ecx ;装配属性edx=0x00409210 retf ;===============================================================================
SECTION core_data vstart= ;系统核心的数据段
;-------------------------------------------------------------------------------
pgdt dw ;用于设置和修改GDT 0x0
dd ;0x2 ram_alloc dd 0x00100000 ;分配内存起始地址;0x100000是初始地址，每分配一次内存，起始地址都会增加;0x6 ;符号地址检索表
salt:
salt_1 db '@PrintString';0xa
times -($-salt_1) db ;0xa+0xb=0x15开始
dd put_string ; 256=0x100,0x100+0xa=0x10a开始;put_string是API段第一个函数，偏移是0
dw sys_routine_seg_sel;0x10a+0x4=0x10e salt_2 db '@ReadDiskData'
times -($-salt_2) db
dd read_hard_disk_0
dw sys_routine_seg_sel salt_3 db '@PrintDwordAsHexString'
times -($-salt_3) db
dd put_hex_dword
dw sys_routine_seg_sel salt_4 db '@TerminateProgram'
times -($-salt_4) db
dd return_point
dw core_code_seg_sel salt_item_len equ $-salt_4
salt_items equ ($-salt)/salt_item_len message_1 db ' If you seen this message,that means we '
db 'are now in protect mode,and the system '
db 'core is loaded,and the video display '
db 'routine works perfectly.',0x0d,0x0a, message_5 db ' Loading user program...', do_status db 'Done.',0x0d,0x0a, message_6 db 0x0d,0x0a,0x0d,0x0a,0x0d,0x0a
db ' User program terminated,control returned.', bin_hex db '0123456789ABCDEF'
;put_hex_dword子过程用的查找表
core_buf times db ;内核用的缓冲区 esp_pointer dd ;内核用来临时保存自己的栈指针 cpu_brnd0 db 0x0d,0x0a,' ',
cpu_brand times db
cpu_brnd1 db 0x0d,0x0a,0x0d,0x0a, ;===============================================================================
SECTION core_code vstart=
;-------------------------------------------------------------------------------
load_relocate_program: ;加载并重定位用户程序
;输入：ESI=起始逻辑扇区号
;返回：AX=指向用户程序头部的选择子
push ebx
push ecx
push edx
push esi
push edi push ds
push es mov eax,core_data_seg_sel
mov ds,eax ;切换DS到内核数据段 mov eax,esi ;esi=50,用户程序所在扇区
mov ebx,core_buf ;core_buf相对段偏移0x516
call sys_routine_seg_sel:read_hard_disk_0 ;先读取用户程序头部一个扇区，包括程序大小、各个段的开始位置 ;以下判断整个程序有多大
mov eax,[core_buf] ;用户程序head前4字节program_length存储了整个程序大小eax=0x7bc；读取的时候以00结尾
mov ebx,eax
and ebx,0xfffffe00 ;低9位清零，才能被512整除；相当于去掉除以512后的余数（零头）；ebx=0x600
add ebx, ;低9位都为0 ebx=0x800
test eax,0x000001ff ;程序的大小正好是512的倍数吗?
cmovnz eax,ebx ;不是。使用凑整的结果 eax = ebx =0x800 mov ecx,eax ;实际需要申请的内存数量ecx=0x800
call sys_routine_seg_sel:allocate_memory
mov ebx,ecx ;ebx=0x100000 -> 申请到的内存首地址 ecx = 0x100000
push ebx ;保存该首地址
xor edx,edx
mov ecx, ;eax=0800，除以512=4
div ecx
mov ecx,eax ;总扇区数ecx=4 mov eax,mem_0_4_gb_seg_sel ;切换DS到0-4GB的段
mov ds,eax mov eax,esi ;用户程序在磁盘的起始扇区号eax=50
.b1:
call sys_routine_seg_sel:read_hard_disk_0 ;DS:EBX=用户程序在内存中的存储地址
inc eax
loop .b1 ;循环读，直到读完整个用户程序 ;建立程序头部段描述符
pop edi ;恢复程序装载的首地址：上面push ebx，把分配的内存首地址0x100000入栈
mov eax,edi ;程序头部起始线性地址eax=edi=0x100000，为用户程序分配的内存首地址
mov ebx,[edi+0x04] ;ebx=段长度=0x328
dec ebx ;ebx=段界限=0x327
mov ecx,0x00409200 ;字节粒度的数据段描述符
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [edi+0x04],cx ;选择子写回 ;建立程序代码段描述符
mov eax,edi
add eax,[edi+0x14] ;代码起始线性地址
mov ebx,[edi+0x18] ;段长度
dec ebx ;段界限
mov ecx,0x00409800 ;字节粒度的代码段描述符
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [edi+0x14],cx ;建立程序数据段描述符
mov eax,edi
add eax,[edi+0x1c] ;数据段起始线性地址
mov ebx,[edi+0x20] ;段长度
dec ebx ;段界限
mov ecx,0x00409200 ;字节粒度的数据段描述符
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [edi+0x1c],cx ;建立程序堆栈段描述符
mov ecx,[edi+0x0c] ;4KB的倍率
mov ebx,0x000fffff
sub ebx,ecx ;得到段界限
mov eax,
mul dword [edi+0x0c]
mov ecx,eax ;准备为堆栈分配内存
call sys_routine_seg_sel:allocate_memory
add eax,ecx ;得到堆栈的高端物理地址
mov ecx,0x00c09600 ;4KB粒度的堆栈段描述符
call sys_routine_seg_sel:make_seg_descriptor
call sys_routine_seg_sel:set_up_gdt_descriptor
mov [edi+0x08],cx ;重定位SALT
mov eax,[edi+0x04] ;用户程序头部长度（注意不是整个长度）eax=0x40
mov es,eax ;es -> 用户程序头部
mov eax,core_data_seg_sel
mov ds,eax ;ds=0x30,base=0x000401e4, limit=0x00000d57 cld mov ecx,[es:0x24] ;用户程序的SALT条目数,base=0x00100000 [0x100024]=3
mov edi,0x28 ;用户程序内的SALT位于头部内0x2c处
.b2:
push ecx
push edi mov ecx,salt_items ;exc=0x4
mov esi,salt ;esi=0xa
.b3:
push edi
push esi
push ecx mov ecx, ;检索表中，每条目的比较次数
repe cmpsd ;每次比较4字节，一共比较256字节，也是每个API函数最大长度
jnz .b4
mov eax,[esi] ;若匹配，esi恰好指向其后的API函数名（数据段内函数名的偏移，比如第一个是put_string，该标号在核心数据段内偏移是0x10a）;eax存放api函数在段内的偏移，比如第一个put_string在API段内的偏移就是0
mov [es:edi-],eax ;将字符串改写成API的偏移地址，写回用户程序的符号地址检索表
mov ax,[esi+] ;API段的选择子，紧接着函数名
mov [es:edi-],ax ;API函数的段选择子，写回用户程序的符号地址检索表
.b4: pop ecx
pop esi
add esi,salt_item_len
pop edi ;从头比较
loop .b3 pop edi
add edi,
pop ecx
loop .b2 mov ax,[es:0x04] pop es ;恢复到调用此过程前的es段
pop ds ;恢复到调用此过程前的ds段 pop edi
pop esi
pop edx
pop ecx
pop ebx ret ;-------------------------------------------------------------------------------
start:
mov ecx,core_data_seg_sel ;使ds指向核心数据段
mov ds,ecx mov ebx,message_1
call sys_routine_seg_sel:put_string ;显示处理器品牌信息
mov eax,0x80000002
cpuid
mov [cpu_brand + 0x00],eax
mov [cpu_brand + 0x04],ebx
mov [cpu_brand + 0x08],ecx
mov [cpu_brand + 0x0c],edx mov eax,0x80000003
cpuid
mov [cpu_brand + 0x10],eax
mov [cpu_brand + 0x14],ebx
mov [cpu_brand + 0x18],ecx
mov [cpu_brand + 0x1c],edx mov eax,0x80000004
cpuid
mov [cpu_brand + 0x20],eax
mov [cpu_brand + 0x24],ebx
mov [cpu_brand + 0x28],ecx
mov [cpu_brand + 0x2c],edx mov ebx,cpu_brnd0
call sys_routine_seg_sel:put_string
mov ebx,cpu_brand
call sys_routine_seg_sel:put_string
mov ebx,cpu_brnd1
call sys_routine_seg_sel:put_string mov ebx,message_5
call sys_routine_seg_sel:put_string
mov esi, ;用户程序位于逻辑50扇区
call load_relocate_program mov ebx,do_status
call sys_routine_seg_sel:put_string mov [esp_pointer],esp ;临时保存堆栈指针 mov ds,ax jmp far [0x10] ;控制权交给用户程序（入口点）
;堆栈可能切换 return_point: ;用户程序返回点
mov eax,core_data_seg_sel ;使ds指向核心数据段
mov ds,eax mov eax,core_stack_seg_sel ;切换回内核自己的堆栈
mov ss,eax
mov esp,[esp_pointer] mov ebx,message_6
call sys_routine_seg_sel:put_string ;这里可以放置清除用户程序各种描述符的指令
;也可以加载并启动其它程序 hlt ;===============================================================================
SECTION core_trail
;-------------------------------------------------------------------------------
core_end:
3、用户程序
SECTION header vstart=
program_length dd program_end ;程序总长度#0x00
head_len dd header_end ;程序头部的长度#0x04
stack_seg dd ;用于接收堆栈段选择子#0x08
stack_len dd ;程序建议的堆栈大小#0x0c
;以4KB为单位
prgentry dd start ;程序入口#0x10
code_seg dd section.code.start ;代码段描述符位置#0x14，在c13_core.asm第450行确定
code_len dd code_end ;代码段长度#0x18
data_seg dd section.data.start ;数据段描述符位置#0x1c，在c13_core.asm第460行确定
data_len dd data_end ;数据段长度#0x20
;-------------------------------------------------------------------------------
;符号地址检索表
salt_items dd (header_end-salt)/ ;#0x24
salt: ;#0x28
PrintString db '@PrintString'
times -($-PrintString) db
TerminateProgram db '@TerminateProgram'
times -($-TerminateProgram) db
ReadDiskData db '@ReadDiskData'
times -($-ReadDiskData) db
header_end:
;===============================================================================
SECTION data vstart=
buffer times db ;缓冲区
message_1 db 0x0d,0x0a,0x0d,0x0a
db '**********User program is runing**********'
db 0x0d,0x0a,
message_2 db ' Disk data:',0x0d,0x0a,
data_end:
;===============================================================================
[bits ]
;===============================================================================
SECTION code vstart=
start:
mov eax,ds
mov fs,eax
mov eax,[stack_seg]
mov ss,eax
mov esp,
mov eax,[data_seg]
mov ds,eax
mov ebx,message_1
call far [fs:PrintString]
mov eax, ;逻辑扇区号100
mov ebx,buffer ;缓冲区偏移地址
call far [fs:ReadDiskData] ;段间调用
mov ebx,message_2
call far [fs:PrintString]
mov ebx,buffer
call far [fs:PrintString] ;too.
jmp far [fs:TerminateProgram] ;将控制权返回到系统
code_end:
;===============================================================================
SECTION trail
;-------------------------------------------------------------------------------
program_end:
最新文章
- html框架练习
- DataTrigger 绑定枚举
- 在线程中调用SaveFileDialog
- Android其它新控件 （转）
- HDU4632：Palindrome subsequence(区间DP)
- [置顶] Objective-C开发环境介绍以及Cocoa，以及第一个程序
- CodeFirst EF中导航属性的个人理解
- 是男人就下100层【第四层】——Crazy贪吃蛇（1）
- zuul进阶学习（二）
- validate表单验证
- Revit API根据链接文件开洞
- 【Linux】人脸识别的封装
- SAP 打开SAP物料帐期和财务账期
- vue2.0 动画
- [整]Android SlidingMenu Demo 环境搭建
- MySQL Study之--MySQL普通用户无法本地登陆
- <yii 框架学习> yii 框架改为中文提示
- K：图的存储结构
- Cognos TM1_10.1.1服务端配置
- Spark之 SparkSql、DataFrame、DataSet介绍