x86架构:保护模式下加载并运行用户程序

本章的代码分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],39      ;描述符表的界限   
 
         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                        ;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],63          ;描述符表的界限
                                        
         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,512                        ;低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,512                        ;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,4096                        
         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+2]                   ;ebx=0x7e40下一个描述符的线性地址 
      
         mov [es:ebx],eax                    
         mov [es:ebx+4],edx                    
      
         add word [pgdt],8                  ;增加一个描述符的大小   
      
         lgdt [pgdt]                        ;对GDT的更改生效 
       
         mov ax,[pgdt]                      ;eax=GDT界限值=0x47
         xor dx,dx
         mov bx,8
         div bx                             ;除以8,去掉余数
         mov cx,ax                          ;尾部新增描述符的索引位置=8
         shl cx,3                           ;将索引号移到正确位置 

         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,0
     
         mov eax,[data_seg]
         mov ds,eax
     
         mov ebx,message_1
         call far [fs:PrintString]
     
         mov eax,100                         ;逻辑扇区号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,16
         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],39      ;描述符表的界限   
 
         lgdt [cs: pgdt+0x7c00]
      
         in al,0x92                         ;南桥芯片内的端口 
         or al,0000_0010B
         out 0x92,al                        ;打开A20

         cli                                ;中断机制尚未工作

         mov eax,cr0
         or eax,1
         mov cr0,eax                        ;设置PE位
      
         ;以下进入保护模式... ...
         jmp dword 0x0010:flush             ;16位的描述符选择子:32位偏移
                                            ;清流水线并串行化处理器
         [bits 32]               
  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                        ;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],63          ;描述符表的界限
                                        
         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,1
         out dx,al                       ;读取的扇区数

         inc dx                          ;0x1f3
         pop eax
         out dx,al                       ;LBA地址7~0

         inc dx                          ;0x1f4
         mov cl,8
         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,256                     ;总共要读取的字数
         mov dx,0x1f0
  .readw:
         in ax,dx
         mov [ebx],ax
         add ebx,2
         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,16                      ;eax从0x00040018变为0x00180000;
         or ax,bx                        ;描述符前32位(EAX)构造完毕,eax=0x001801cb;
      
         and edx,0xffff0000              ;清除基地址中无关的位 edx=0x00040000
         rol edx,8                         ;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 0
                          dd 0x00007e00      ;GDT的物理地址
;-------------------------------------------------------------------------------                             
         times 510-($-$$) db 0
                          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 32]
;===============================================================================
SECTION sys_routine vstart=0                ;系统公共例程代码段 
;-------------------------------------------------------------------------------
         ;字符串显示例程
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,80
         div bl
         mul bl
         mov bx,ax
         jmp .set_cursor

  .put_0a:
         cmp cl,0x0a                        ;换行符?
         jnz .put_other
         add bx,80
         jmp .roll_screen

  .put_other:                               ;正常显示字符
         push es
         mov eax,video_ram_seg_sel          ;0xb8000段的选择子
         mov es,eax
         shl bx,1
         mov [es:bx],cl
         pop es

         ;以下将光标位置推进一个字符
         shr bx,1
         inc bx

  .roll_screen:
         cmp bx,2000                        ;光标超出屏幕?滚屏
         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,1920
         rep movsd
         mov bx,3840                        ;清除屏幕最底一行
         mov ecx,80                         ;32位程序应该使用ECX
  .cls:
         mov word[es:bx],0x0720
         add bx,2
         loop .cls

         pop es
         pop ds

         mov bx,1920

  .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,1
         out dx,al                          ;读取的扇区数

         inc dx                             ;0x1f3
         pop eax
         out dx,al                          ;LBA地址7~0

         inc dx                             ;0x1f4
         mov cl,8
         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,256                        ;总共要读取的字数
         mov dx,0x1f0
  .readw:
         in ax,dx
         mov [ebx],ax
         add ebx,2                            ;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,8
  .xlt:    
         rol edx,4
         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                          ;强制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+2]                   ;ebx=0x7e40下一个描述符的线性地址 
      
         mov [es:ebx],eax                    
         mov [es:ebx+4],edx                    
      
         add word [pgdt],8                  ;增加一个描述符的大小   
      
         lgdt [pgdt]                        ;对GDT的更改生效 
       
         mov ax,[pgdt]                      ;eax=GDT界限值=0x47
         xor dx,dx
         mov bx,8
         div bx                             ;除以8,去掉余数
         mov cx,ax                          ;尾部新增描述符的索引位置=8
         shl cx,3                           ;将索引号移到正确位置 

         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,16                            ;eax=0x00000000
         or ax,bx                           ;描述符前32位(EAX)构造完毕;eax=ebx=0x327

         and edx,0xffff0000                 ;清除基地址中无关的位 edx=0x00100000
         rol edx,8                            ;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=0                  ;系统核心的数据段
;-------------------------------------------------------------------------------
         pgdt             dw  0             ;用于设置和修改GDT 0x0
                          dd  0                ;0x2

         ram_alloc        dd  0x00100000    ;分配内存起始地址;0x100000是初始地址,每分配一次内存,起始地址都会增加;0x6

         ;符号地址检索表
         salt:
         salt_1           db  '@PrintString';0xa
                     times 256-($-salt_1) db 0    ;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 256-($-salt_2) db 0
                          dd  read_hard_disk_0
                          dw  sys_routine_seg_sel

         salt_3           db  '@PrintDwordAsHexString'
                     times 256-($-salt_3) db 0
                          dd  put_hex_dword
                          dw  sys_routine_seg_sel

         salt_4           db  '@TerminateProgram'
                     times 256-($-salt_4) db 0
                          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,0

         message_5        db  '  Loading user program...',0
         
         do_status        db  'Done.',0x0d,0x0a,0
         
         message_6        db  0x0d,0x0a,0x0d,0x0a,0x0d,0x0a
                          db  '  User program terminated,control returned.',0

         bin_hex          db '0123456789ABCDEF'
                                            ;put_hex_dword子过程用的查找表 
         core_buf   times 2048 db 0         ;内核用的缓冲区

         esp_pointer      dd 0              ;内核用来临时保存自己的栈指针     

         cpu_brnd0        db 0x0d,0x0a,'  ',0
         cpu_brand  times 52 db 0
         cpu_brnd1        db 0x0d,0x0a,0x0d,0x0a,0

;===============================================================================
SECTION core_code vstart=0
;-------------------------------------------------------------------------------
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,512                        ;低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,512                        ;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,4096                        
         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,64                         ;检索表中,每条目的比较次数 
         repe cmpsd                         ;每次比较4字节,一共比较256字节,也是每个API函数最大长度 
         jnz .b4
         mov eax,[esi]                      ;若匹配,esi恰好指向其后的API函数名(数据段内函数名的偏移,比如第一个是put_string,该标号在核心数据段内偏移是0x10a);eax存放api函数在段内的偏移,比如第一个put_string在API段内的偏移就是0
         mov [es:edi-256],eax               ;将字符串改写成API的偏移地址,写回用户程序的符号地址检索表 
         mov ax,[esi+4]                        ;API段的选择子,紧接着函数名
         mov [es:edi-252],ax                ;API函数的段选择子,写回用户程序的符号地址检索表
  .b4:
      
         pop ecx
         pop esi
         add esi,salt_item_len
         pop edi                            ;从头比较 
         loop .b3
      
         pop edi
         add edi,256
         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                          ;用户程序位于逻辑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=0

         program_length   dd program_end          ;程序总长度#0x00
         
         head_len         dd header_end           ;程序头部的长度#0x04

         stack_seg        dd 0                    ;用于接收堆栈段选择子#0x08
         stack_len        dd 1                    ;程序建议的堆栈大小#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)/256 ;#0x24
         
         salt:                                     ;#0x28
         PrintString      db  '@PrintString'
                     times 256-($-PrintString) db 0
                     
         TerminateProgram db  '@TerminateProgram'
                     times 256-($-TerminateProgram) db 0
                     
         ReadDiskData     db  '@ReadDiskData'
                     times 256-($-ReadDiskData) db 0
                 
header_end:

;===============================================================================
SECTION data vstart=0    
                         
         buffer times 1024 db  0         ;缓冲区

         message_1         db  0x0d,0x0a,0x0d,0x0a
                           db  '**********User program is runing**********'
                           db  0x0d,0x0a,0
         message_2         db  '  Disk data:',0x0d,0x0a,0

data_end:

;===============================================================================
      [bits 32]
;===============================================================================
SECTION code vstart=0
start:
         mov eax,ds
         mov fs,eax
     
         mov eax,[stack_seg]
         mov ss,eax
         mov esp,0
     
         mov eax,[data_seg]
         mov ds,eax
     
         mov ebx,message_1
         call far [fs:PrintString]
     
         mov eax,100                         ;逻辑扇区号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:

 

  

  

 

posted @ 2020-06-08 14:43  第七子007  阅读(627)  评论(0编辑  收藏  举报