汇编语言-实现一个简单的主引导记录(MBR)引导用户程序

Posted hesorchen

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了汇编语言-实现一个简单的主引导记录(MBR)引导用户程序相关的知识,希望对你有一定的参考价值。

本文参考李忠老师的《X86汇编语言:实模式到保护模式》

前言

自己手动实现一个简单的主引导记录来引导用户程序,有助于了解

  • 主引导程序的工作流程
  • 在汇编代码层面如何调用函数(函数调用的原理)
  • 在汇编代码层面如何读写硬盘(CPU与外围设备的交互)

内容虽然不多,但能够综合运用到多方面的知识。

主引导记录

以下内容参考自wiki

主引导记录(Master Boot Record,缩写:MBR),又叫做主引导扇区,是计算机开机后访问硬盘时所必须要读取的首个扇区,它在硬盘上的三维地址为(柱面,磁头,扇区)=(0,0,1)

系统开机的过程:

  1. Bios 加电自检,对系统硬件(包括内存)进行检查
  2. 读取主引导记录。BIOS 将磁盘第一个扇区(也就是 MBR 扇区)读入内存地址 0000:7C00H 处
  3. 根据 MBR 中的引导代码启动引导程序
  4. 引导程序加载操作系统内核

修改主引导记录

我们可以将自己写的机器指令写入到主引导扇区,这样 BIOS 自检后就会执行我们指定的程序。就像这样:

示例汇编代码 demo.asm:

    mov ax, 0x1234
    jmp $

;--------------------------------------------------------------
    ; $  表示当前行的汇编地址
    ; $$ 表示第一行的汇编地址
    ; $-$$得到前面代码占用的字节数
    times (512-2-($-$$)) db 0 ;主引导扇区总长度必须512字节,用0占位
    db 0x55, 0xaa           ;主引导扇区最后两个字节必须是0x55aa

使用 nasm 进行编译得到 demo.bin 文件

用李忠老师的虚拟硬盘写入工具 Vhd writer 将 demo.bin 文件中的内容写入到 Vhd 虚拟硬盘的主引导扇区中

启动 bochsdbg 虚拟机进行调试,因为主引导记录将被加载到物理地址 0x7c00 处,我们使用命令b 0x7c00c连续执行指令,直到 ip 寄存器指向0x7c00时暂停运行

使用s命令进行单步调试,使用r命令观察寄存器的值

主引导记录引导用户程序

我们自己编写主引导程序,就可以让其加载其他内容(将控制权让出),比如某个用户程序。要加载用户程序,有一些必要的信息要给主引导程序:用户程序的总长度、程序的执行入口等。因此,就如同计算机世界中的各种协议头部一样,在用户程序的最前面,需要加上一个头部段。

头部段包含以下内容:

  1. 程序的总长度,占一个 double word,也即 4B
  2. 入口点段内偏移地址,占一个 word,也即 2B
  3. 入口点段汇编地址,占一个 double word,也即 4B
  4. 重定位表项数,占一个 word,也即 2B
  5. 与之对应的n项表项,每个表项占一个double word,也即 4B

用户程序代码示例代码:

;------------------------------------------------------
SECTION head_section vstart=0
                                                            ;用户程序头部段
    app_length: dd app_end
    entry_offset: dw start                                  ;用户程序入口点段内偏移地址
    entry_sec_addr: dd section.code_section.start           ;用户程序入口点段汇编地址
    realloc_tbl_num: dw (head_sec_end-code_sec_base_addr)/4 ;每项4字节
    code_sec_base_addr: dd section.code_section.start       ;代码段汇编地址
    data_sec_base_addr: dd section.data_section.start       ;数据段汇编地址
    stack_sec_base_addr: dd section.stack_section.start     ;栈段汇编地址
    head_sec_end:
;------------------------------------------------------
SECTION code_section align=16 vstart=0                      ;代码段

put_string:
                                                            ;input: ds:si 源字符串起始地址
                                                            ;        es:di 目标位置起始地址
    push ax                                                 ;保存寄存器
@1:
    mov al,[ds:si]
    cmp al,0                                                ;字符串结尾
    je end_loop
    mov ah,0x0f                                             ;字体格式
    mov [es:di],ax
    add di,2
    inc si
    jmp @1
end_loop:
    pop ax                                                  ;恢复寄存器
    ret

start:
                                                            ;设置用户程序的栈空间
    xor ax,ax
    mov sp,ax
    xor ax,[stack_sec_base_addr]
    mov ss,ax
                                                            ;程序主体部分,显示数据段文本
    mov ax,[data_sec_base_addr]
    mov ds,ax
    xor si,si
    mov ax,0xb800
    mov es,ax
    xor di,di
    call put_string

;------------------------------------------------------
SECTION data_section align=16 vstart=0                      ;数据段
    db 'Hello World! ___Written by cy.',0

;------------------------------------------------------
SECTION stack_section align=16 vstart=0                     ;栈段
    resb 256

;------------------------------------------------------
SECTION end_section
    app_end:

有了头部段,我们将用户程序读入到内存中,并将控制权交给它(修改段地址寄存器),就完成了加载工作。简单起见,我们做以下约定:

  1. 用户程序在磁盘第 100 个扇区中顺序存储
  2. 主引导程序始终将用户程序加载到物理内存 0x10000 处

读写硬盘

CPU与外围的 I/O设备传输数据需要借助 I/O接口,I/O接口内部集成了一些寄存器,我们称为端口,不同的端口有不同的作用,比如发送命令、发送数据等。CPU 从端口读写数据,与外围设备进行交互。我们用inout指令从端口读写数据:

in指令:

    ;一般使用ax和dx寄存器
    ;选择ax还是al取决于端口的位宽
    mov dx,0xc30    ;从0x3c0端口读取数据
    in ax,dx
    ;in al,dx

out指令:

    mov dx,0xc30    
    out dx,ax       ;往0x3c0端口写入数据
    ;out dx,al

在我们的计算机中,硬盘接口拥有八个端口,依次是 0x1f0 至 0x1f7,要读写的端口号存放在 dx 中,数据存放在 ax/al 中

读写硬盘的最小单位是扇区,因此硬盘是典型的块设备。读写硬盘有两种模式:

  1. CHS模式(Cylinder Head Sector)柱面-磁头-扇区三元组
  2. LBA模式(Logic Block Address)逻辑扇区号

读取硬盘的基本步骤:

  1. 将要读取的扇区数量写入 0x1f2 端口
    mov dx,0x1f2
    mov al,0x1
    out dx,al
  1. 将选择的硬盘(主/从)、读写模式(CHS/LBA)以及扇区号共32位数据写入0x1f3、0x1f4、0x1f5、0x1f6端口
1010 0000 00000000 00000000 00000000
共写入32位,低28位表示扇区号
第29和31位固定为1
第28位为0表示读写主硬盘,为1表示读写从硬盘
第30位为0表示CHS读写模式,为1表示LBA读写模式在·
    mov dx,0x1f2
    mov al,0x2
    out dx,al;0000 0002

    inc dx 
    xor al,al
    out dx,al;0000 0000

    inc dx 
    out dx,al;0000 0000
    inc dx 

    inc dx 
    mov al,0xe0
    out dx,al;1110 0000
    inc dx 
    ;11100000 00000000 00000000 00000002
    ;选择LBA读写模式,读写主硬盘的2号逻辑扇区
  1. 向端口 0x1f7 写入 0x20 命令,请求读硬盘
    mov dx,0x1f7
    mov al,0x20
    out dx,al
  1. 判断硬盘是否已经准备好被读取

从 0x1f7 端口读取 1B 数据

    mov dx,0x1f7
    in al,dx
00000000
共读取8位
第7位为1表示硬盘正忙
第3位为1表示硬盘已经可以交换数据

轮询等待,直到可以读取数据

    mov dx,0x1f7
.waits:
    in dx,al
    and al,0x88     ;取出第3位和第7位
    cmp al,0x08
    jnz .waits
  1. 硬盘准备好被读取后,从数据端口 0x1f0 读取数据
    ;假定DS:BX已经指向数据要存放的逻辑地址
    mov dx,0x1f0
    mov cx,256      ;512B=256word
.readlo:
    in dx,ax
    mov [bx],ax  
    add bx,2
    loop .readlo

加载用户程序

明白怎么读取硬盘后,接下来的目标是加载整个用户程序。首先要将用户程序头部段加载入内存中,并解析头部段中的信息。

我们在前面已经做好如下约定:

  1. 用户程序在磁盘第 100 个扇区中顺序存储
  2. 主引导程序始终将用户程序加载到物理内存 0x10000 处

因此,我们将逻辑扇区号定义为常数,而物理地址因为后面需要访问,因此存放到一个4字节内存中:

    disk_lba_address equ 100        ;定义常数,约定的逻辑扇区号
    phy_base_address : dd 0x10000   ;约定的用户程序要存放的物理地址

接下来,我们先将第 100 号扇区(包含了头部段)读入内存,并根据头部段中的第一个双字——程序的总长度来读入剩余的全部扇区

具体步骤如下:

  1. 读入第 100 号扇区(包含了头部段),并解析程序的总长度。一个扇区512B,总长度/512就是扇区个数,需要注意的是,无法整除时,还需要一个扇区。
    mov ax,[cs:phy_base_address]
    mov dx,[cs:phy_base_address+2]
    mov bx,16
    div bx                          ;左移四位得到逻辑段地址
    mov ds,ax                       ;令ds指向将要载入的逻辑段地址
    xor bx,bx                       ;对应read_hard_disk的输入

    mov si,disk_lba_address         ;对应read_hard_disk的输入
    xor di,di

    call read_hard_disk             ;读出头部段

    mov ax,[0x00]                   ;dx:ax = 程序总长度
    mov dx,[0x02]
    mov bx,512
    div bx                          ;得到用户程序占用的扇区数
    cmp dx,0
    jz @1                           ;占用整数个扇区
    inc ax                          ;不是刚好占用整数个扇区,需要继续读取一个扇区才能读完
@1:
    dec ax                          ;已经读了一个扇区,减去
  1. 使用loop循环来读取剩余扇区
    mov cx,ax                       ;需要读取的扇区数量
@2:
    mov ax,ds;
    add ax,0x20                     ;0x20<<4=0x200=512B,得到下一个512B的逻辑段地址
    mov ds,ax
    xor bx,bx
    inc si                          ;读下一个逻辑扇区
    call read_hard_disk
    loop @2                         ;循环读取剩余扇区

用户程序的重定位

我们已经成功的将整个用户程序加载入内存之中,接下来的任务是将控制权交给用户程序,显然需要修改 cs:ip 寄存器为用户程序入口点的逻辑地址。

如何计算呢?在头部段中有两个信息:

  1. 用户程序的入口点 段汇编地址。要通过该值计算出 cs,也即段基地址的值,其实很简单,用户程序被加载的起始物理地址是 phy_base_address,只需两者相加就是用户程序入口点的段实际物理地址,左移四位即得到段基地址 cs 的值

  2. 用户程序的入口点 段内偏移地址。直接对应了 ip 的值

计算出结果后,为了后续使用方便,我们直接将结果回填到 头部段中 用户程序的入口点段汇编地址 处。很“巧合”的是,在头部段偏移地址为 [0x04] 处存放的是 ip 的值,在头部段偏移地址为 [0x06] 处存放的是 cs 的值,直接使用jmp far指令即可跳转到用户程序入口点执行。

    jmp far [0x04]

在用户程序中,还有多个SECTION,如果不知道它们的段基地址,就难以使用。这时,重定位表项就派上用场了——我们按照上面的计算过程,将重定位表项中所有SECTION的段基地址计算出来,并一一回填到对应的内存空间中,这样,要访问这些SECTION的时候,只需要将段基地址设置为对应的值即可。

                                    ;计算用户程序入口点逻辑段地址
    mov ax,[0x06]
    mov dx,[0x08]
    call cal_segment_base
    mov [0x06],ax                   ;将计算得到的用户程序入口点段基地址回填到头部段[0x06]处

    mov cx,[0x0a]                   ;重定位表项数
    mov bx,[0x0c]                   ;第一项
@3:
    mov ax,[bx]
    mov dx,[bx+0x02]
    call cal_segment_base
    mov [bx],ax                     ;将计算得到的段基地址回填到重定位表项处
    add bx,4
    loop @3

主引导程序拿回控制权【扩展】

用户程序执行完之后,肯定需要将控制权交回给上级,否则只能运行一个程序了,原理很简单,只需保存各个寄存器的值并恢复即可,但是对于cs/ip/ss/sp寄存器的保存和恢复需要特别小心,比如修改了cs,但是ip还没修改,这时候会直接指向其他指令(cs:ip改变了)。

另外, ip寄存器的值不能直接读写,还记得 call指令吗?它的原理是将 ip寄存器的值压入栈,因此我们可以通过 call指令间接得到 ip寄存器的值,就像这样:

    push cs                         
    call get_ip                     ;等价于push ip
get_ip:
    pop ax                          ;得到ip的值
    push ax

看似天衣无缝了,不过这样保存的 ip是不对的哦,因为此时的 ip指向的是指令pop ax的起始地址,显然,我们想要的是push ax之后那条指令的起始地址。类似于这样的问题还有很多,动手实践的过程中就会遇到。

主引导程序拿回控制权代码(主引导程序部分):

    push ax                         ;保存环境
    push bx
    push cx
    push dx
    push ds
    push es
    push di
    push si

    push cs                         ;【拓展内容】用户程序执行完之后将控制权还给主引导程序
    call get_ip                     ;等价于push ip
get_ip:
    pop ax                          ;得到ip的值
    add ax,delta_2-get_ip
    push ax

    jmp far [0x04]                  ;==执行用户程序==
delta_2:                            ;【拓展内容】主引导程序拿回控制权之后应该从此处开始执行
    pop si
    pop di
    pop es
    pop ds
    pop dx
    pop cx
    pop bx
    pop ax                         ;恢复环境

主引导程序拿回控制权代码(用户程序部分):

mov si,ss                                               ;【拓展内容】记录主引导程序的栈空间
    mov di,sp

                                                            ;设置用户程序的栈空间
    xor ax,ax
    mov sp,ax
    xor ax,[stack_sec_base_addr]
    mov ss,ax

    push di
    push si                                                 ;【拓展内容】记录主引导程序的栈空间

    ;用户程序代码部分
    ;..............
    ;..............
    ;用户程序代码部分


    pop si ;【拓展内容】用户程序执行完之后将控制权还给主引导程序
    pop di
    mov ss,si
    mov sp,di
    retf ;= pop ip & pop cs

However,总感觉控制权需要用户程序主动配合交出怪怪的… …

验证

主引导程序完整汇编代码 my_mbr.asm:

    disk_lba_address equ 100        ;定义常数,约定的逻辑扇区号
SECTION mbr vstart=0x7c00
                                    ;初始化栈寄存器
    xor ax,ax
    mov ss,ax
    mov sp,ax

    mov ax,[cs:phy_base_address]
    mov dx,[cs:phy_base_address+2]
    mov bx,16
    div bx                          ;左移四位得到逻辑段地址
    mov ds,ax                       ;令ds指向将要载入的逻辑段地址

    xor di,di
    mov si,disk_lba_address         ;对应read_hard_disk的输入
    xor bx,bx                       ;对应read_hard_disk的输入
    call read_hard_disk             ;读出头部段

    mov ax,[0x00]                   ;dx:ax = 程序总长度
    mov dx,[0x02]
    mov bx,512
    div bx                          ;得到用户程序占用的扇区数
    cmp dx,0
    jz @1                           ;占用整数个扇区
    inc ax                          ;不是刚好占用整数个扇区,需要继续读取一个扇区才能读完
@1:
    dec ax                          ;已经读了一个扇区,减去
    cmp ax,0
    jz direct                       ;无扇区需要读了

    push ds                         ;保存用户程序的逻辑段地址

    mov cx,ax;
@2:
    mov ax,ds
    add ax,0x20                     ;0x20<<4=0x200=512B,得到下一个512B的逻辑段地址
    mov ds,ax
    xor bx,bx
    inc si                          ;读下一个逻辑扇区
    call read_hard_disk
    loop @2                         ;循环读取剩余扇区

    pop ds                          ;恢复用户程序的逻辑段地址

direct:
                                    ;计算用户程序入口点逻辑段地址
    mov ax,[0x06]
    mov dx,[0x08]
    call cal_segment_base
    mov [0x06],ax                   ;将计算得到的用户程序入口点段基地址回填到头部段[0x06]处

    mov cx,[0x0a]                   ;重定位表项数
    mov bx,0x0c                     ;第一项的地址
@3:
    mov ax,[bx]
    mov dx,[bx+0x02]
    call cal_segment_base
    mov [bx],ax                     ;将计算得到的段基地址回填到重定位表项处
    add bx,4
    loop @3

    push ax                         ;保存环境
    push bx
    push cx
    push dx
    push ds
    push es
    push di
    push si

    push cs                         ;【拓展内容】用户程序执行完之后将控制权还给主引导程序
    call get_ip                     ;等价于push ip
get_ip:
    pop ax                          ;得到ip的值
    add ax,delta_2-get_ip
    push ax

    jmp far [0x04]
delta_2:                            ;【拓展内容】主引导程序拿回控制权之后应该从此处开始执行
    pop si
    pop di
    pop es
    pop ds
    pop dx
    pop cx
    pop bx
    pop ax                         ;恢复环境

    jmp $
;------------------------------------------------------------------------
cal_segment_base:
                                    ;input: dx:ax = 段汇编地址
                                    ;output:ax = 段基地址
    push dx

    add ax,[cs:phy_base_address]
    adc dx,[cs:phy_base_address+2]  ;带进位加法
                                    ;ds:ax=段逻辑地址,要取出第4-19位
    shr ax,4
    ror dx,4
    or ax,dx

    pop dx

    ret
;------------------------------------------------------------------------
read_hard_disk:
                                    ;从硬盘读入一个扇区
                                    ;input: DI:SI = 扇区号
                                    ;       DS:BX = 物理内存
    push di                         ;保存相关寄存器
    push si
    push ds
    push bx
    push ax
    push dx
    push cx

    mov dx,0x1f2
    mov al,1
    out dx,al

    inc dx
    mov ax,si                       ;写入扇区号、读写模式、硬盘
    out dx,al

    inc dx
    shr ax,8
    out dx,al

    inc dx
    mov ax,di
    out dx,al

    inc dx
    mov al,0xe0
    out dx,al

    inc dx                          ;发送请求读命令
    mov al,0x20
    out dx,al

.waits:                             ;轮询硬盘是否可读
    in al,dx
    and al,0x88
    cmp al,0x08
    jnz .waits

    mov dx,0x1f0                    ;开始读硬盘
    mov cx,256
.readlo:
    in ax,dx
    mov [bx],ax
    add bx,2
    loop .readlo

    pop cx
    pop dx
    pop ax
    pop bx
    pop ds
    pop si
    pop di                          ;恢复相关寄存器

    ret
;------------------------------------------------------------------------
    phy_base_address : dd 0x10000   ;约定的用户程序要存放的物理地址
    times (512-2-($-$$)) db 0       ;主引导扇区总长度必须512字节,用0占位
    db 0x55, 0xaa                   ;主引导扇区最后两个字节必须是0x55aa

用户程序完整汇编代码 my_app.asm:

;------------------------------------------------------
SECTION head_section vstart=0
                                                            ;用户程序头部段
    app_length: dd app_end
    entry_offset: dw start                                  ;用户程序入口点段内偏移地址
    entry_sec_addr: dd section.code_section.start           ;用户程序入口点段汇编地址
    realloc_tbl_num: dw (head_sec_end-code_sec_base_addr)/4 ;每项4字节
    code_sec_base_addr: dd section.code_section.start       ;代码段汇编地址
    data_sec_base_addr: dd section.data_section.start       ;数据段汇编地址
    stack_sec_base_addr: dd section.stack_section.start     ;栈段汇编地址
    head_sec_end:
;------------------------------------------------------
SECTION code_section align=16 vstart=0                      ;代码段
put_string:
                                                            ;input: ds:si 源字符串起始地址
                                                            ;        es:di 目标位置起始地址
    push ax                                                 ;保存寄存器
@1:
    mov al,[ds:si]
    cmp al,0                                                ;字符串结尾
    je end_loop
    mov ah,0x0f                                             ;字体格式
    mov [es:di],ax
    add di,2
    inc si
    jmp @1
end_loop:
    pop ax                                                  ;恢复寄存器
    ret

start:
    mov si,ss                                               ;【拓展内容】记录主引导程序的栈空间
    mov di,sp
                                                            ;设置用户程序的栈空间
    xor ax,ax
    mov sp,ax
    xor ax,[stack_sec_base_addr]
    mov ss,ax

    push di
    push si                                                 ;【拓展内容】记录主引导程序的栈空间

    mov ax,[data_sec_base_addr]                             ;程序主体部分,显示数据段文本
    mov ds,ax
    xor si,si
    mov ax,0xb800
    mov es,ax
    xor di,di
    call put_string

    pop si                                                  ;【拓展内容】用户程序执行完之后将控制权还给主引导程序
    pop di
    mov ss,si
    mov sp,di
    retf                                                    ;= pop ip & pop cs

;------------------------------------------------------
SECTION data_section align=16 vstart=0                      ;数据段
    db 'Hello World! ___Written by cy.',0

;------------------------------------------------------
SECTION stack_section align=16 vstart=0                     ;用户栈段
    resb 256                                                ;为栈空间预留256B

;------------------------------------------------------
SECTION end_section
    app_end:

分别将他们编译,生成 my_mbr.asm 和 my_app.asm,使用李忠老师的虚拟硬盘写入工具将它们写入到虚拟硬盘

执行virtual box虚拟机,可以看到正常显示期望的文本内容,证明我们的主引导程序正确的引导了用户程序。

还可以利用Bochsdbg进行调试,观察程序的执行过程,尤其是控制权来回切换时,各个寄存器以及栈空间的状态变化。

小结

真实的主引导程序引导操作系统肯定没这么简单,不过把这个实验写下来也能对相关过程有个大致的了解。与纸上谈兵相比,实践环节会遇到很多细节问题,我本以为一天就能完成这个实验,结果花了三四天,有些问题是由于没有彻底理解之前所学的知识,有些知识理解了,但在使用时又疏忽了。学技术,多实践,才能做到查漏补缺和加深记忆的效果。

以上是关于汇编语言-实现一个简单的主引导记录(MBR)引导用户程序的主要内容,如果未能解决你的问题,请参考以下文章

第二课 一个简单的“引导程序”

有关MBR的问题

电脑开机显示LOadingoperatingsystem是啥意思

第六课 突破512字节的限制 上

硬盘分区表与mbr的关系

硬盘分区的MBR和GPT表有啥区别