《ORANGE’S：一个操作系统的实现》读书笔记（六）突破512字节（三）

zorro_z

已于 2023-12-14 10:30:31 修改

阅读量70

点赞数 1

分类专栏：操作系统文章标签：笔记汇编

于 2023-12-13 17:51:39 首次发布

本文链接：https://blog.csdn.net/zorro_z/article/details/134978276

版权

操作系统专栏收录该内容

39 篇文章 2 订阅

订阅专栏

上一篇文章记录了如何读取软盘内容和在软盘中查找指定的文件，那么这篇文章就开始记录最后一个环节。读取 Loader 文件内容载入内存，然后将控制权交给 Loader。

由扇区号求FAT项的值

现在我们已经有了Loader.bin的起始扇区号，我们需要用这个扇区号来做两件事：一件是把起始扇区装入内存，另一件则是通过它找到FAT中的项，从而找到Loader占用的其余所有扇区。

在这里，我们把Loader装入内存的 BaseOfLoader:OffsetOfLoader 处，我们之前读取根目录区也是装到这个位置，这样做的好处是资源回收利用。因为我们装入根目录区是为了找到相应的目录条目，找到之后，根目录区对我们就没有用了。所以，我们现在用 Loader 把它覆盖掉，也没有关系。

装入一个扇区对我们来说已经没有什么问题了，但是从FAT中找到一个项还多少有些麻烦。如果 Loader 占用多个扇区的话，我们可能需要重复从FAT中查找相应的项，所以，为了方便起见，还是写一个函数来做这件事情。函数的输入就是扇区号，输出则是其对应的FAT项的值。具体代码如下所示。

BaseOfLoader equ 09000h                 ; 读取软盘扇区加载到的位置 -- 段地址
SectorNoOfFAT1 equ 1                    ; FAT1 的第一个扇区号
wSectorNum db 1                         ; 读取扇区数量，默认：1
bOdd db 0                               ; 奇数还是偶数
......
; 找到序号为 ax 的扇区在 FAT 中的条目, 结果放在 ax 中
GetFATEntry:
    push bx
    push es
    push ax
    ; 在 BaseOfLoader 后面留出 4K 空间用于存放 FAT 扇区内容
    mov ax, BaseOfLoader
    sub ax, 0100h
    mov es, ax

    pop ax                                  ; 恢复 ax
    mov byte [bOdd], 0
    mov bx, 3
    mul bx                                  ; dx:ax = ax * 3    dx：高 16 位，ax：低 16 位
    mov bx, 2
    div bx                                  ; dx:ax / 2         ax：商，dx：余数
    cmp dx, 0
    je LABEL_EVEN
    mov byte [bOdd], 1
LABEL_EVEN:                                 ; 偶数
    ; 现在 ax 中是 FATEntry 在 FAT 中的偏移量,下面来计算 FATEntry 在哪个扇区中(FAT占用不止一个扇区)
    xor dx, dx
    ; dx:ax / 512
    ; ax：商 (FATEntry 所在的扇区相对于 FAT 的扇区号)，dx：余数 (FATEntry 在扇区内的偏移)
    mov bx, 512
    div bx
    push dx
    mov bx, 0                               ; bx：0     将 FAT 扇区读入 es:bx = (BaseOfLoader - 100):00
    add ax, SectorNoOfFAT1                  ; ax：FATEntry 所在的扇区号
    mov byte [wSectorNum], 2                ; 设置读取扇区数量：2，因为一个 FATEntry 可能跨越两个扇区
    call ReadSector

    pop dx
    add bx, dx
    mov ax, [es:bx]
    cmp byte [bOdd], 1
    jne LABEL_EVEN_2
    shr ax, 4
LABEL_EVEN_2:
    and ax, 0FFFh

    pop es
    pop bx
    ret

我们在由扇区号获取FAT项的代码中添加了宏SectorNoOfFAT1，它与前面用到的RootDirSectors等宏在一起，与FAT12有关的几个数字都定义成了宏，而不是在程序中计算。一方面，这是为缩小引导区代码考虑；另一方面，这些数字一般情况下也不会发生改变，写代码计算它们其实是一种浪费。

取得FAT项代码中有一点需要注意的是，需要对扇区号做奇数还是偶数的判断，因为奇数和偶数获取FAT项的方式是不一样的。由于一个FAT项可能跨越两个扇区，所以在代码中一次总是读取两个扇区，以免在边界处发生错误。

加载Loader

好了，现在一切都已经具备了，我们可以开始加载Loader了。加载Loader的代码如下所示。

LABEL_FILENAME_FOUND:            ; 找到 LOADER.BIN 后便来到这里继续
    mov    ax, RootDirSectors
    and    di, 0FFE0h        ; di： 当前条目的开始
    add    di, 01Ah        ; di： 首 Sector
    mov    cx, word [es:di]
    push    cx            ; 保存此 Sector 在 FAT 中的序号
    add    cx, ax
    add    cx, DeltaSectorNo    ; cl <- LOADER.BIN的起始扇区号(0-based)
    mov    ax, BaseOfLoader
    mov    es, ax            ; es <- BaseOfLoader
    mov    bx, OffsetOfLoader    ; bx <- OffsetOfLoader
    mov    ax, cx            ; ax <- Sector 号

LABEL_GOON_LOADING_FILE:

 
    mov    cl, 1
    call    ReadSector
    pop    ax            ; 取出此 Sector 在 FAT 中的序号
    call    GetFATEntry
    cmp    ax, 0FFFh
    jz    LABEL_FILE_LOADED
    push    ax            ; 保存 Sector 在 FAT 中的序号
    mov    dx, RootDirSectors
    add    ax, dx
    add    ax, DeltaSectorNo
    add    bx, 512
    jmp    LABEL_GOON_LOADING_FILE

上述代码中使用了一个新的宏DeltaSectorNo，它的作用是什么呢？我们以文件RIVER.TXT对应的目录条目为例进行说明。RIVER.TXT目录条目的开始簇号是2，但我们要读取的数据扇区显然不是从2中进行读取的。实际上，开始簇号2对应的是数据区的第一个扇区。所以，我们需要一个方法来计算簇号为X代表从引导扇区开始算起第几个扇区。

我们已经知道，根目录区占用RootDirSectors即14个扇区，根目录区的开始扇区号是19，于是我们用“X+RootDirSectors+19-2”来算出“33”这个正确的扇区号。所以，我们定义了一个宏DeltaSectorNo为17（即19-2）来帮助计算正确的扇区号。

向Loader交出控制权

上面的代码成功后，我们就已经成功地将Loader加载入内存，下面执行跳转，开始执行Loader。代码如下所示。

jmp BaseOfLoader:OffsetOfLoader         ; 这一句正式跳转到已加载到内
                                        ; 存中的 LOADER.BIN 的开始处，
                                        ; 开始执行 LOADER.BIN 的代码。
                                        ; Boot Sector 的使命到此结束。

整理 boot.asm

最后，我们对 boot.asm 进行整理，加入一些提示字符串，以便让执行的效果更好一点。整理后的 boot.asm 代码如下所示。

org  07c00h         ; Boot 状态, Bios 将把 Boot Sector 加载到 0:7C00 处并开始执行

;================================================================================================
BaseOfStack         equ 07c00h  ; Boot状态下堆栈基地址(栈底, 从这个位置向低地址生长)

BaseOfLoader        equ 09000h  ; LOADER.BIN 被加载到的位置 ----  段地址
OffsetOfLoader      equ 0100h   ; LOADER.BIN 被加载到的位置 ---- 偏移地址

RootDirSectors      equ 14  ; 根目录占用空间
SectorNoOfRootDirectory equ 19  ; Root Directory 的第一个扇区号
SectorNoOfFAT1      equ 1   ; FAT1 的第一个扇区号 = BPB_RsvdSecCnt
DeltaSectorNo       equ 17  ; DeltaSectorNo = BPB_RsvdSecCnt + (BPB_NumFATs * FATSz) - 2
                    ; 文件的开始Sector号 = DirEntry中的开始Sector号 + 根目录占用Sector数目 + DeltaSectorNo
;================================================================================================

    jmp short LABEL_START       ; Start to boot.
    nop             ; 这个 nop 不可少

    ; 下面是 FAT12 磁盘的头
    BS_OEMName  DB 'ForrestY'   ; OEM String, 必须 8 个字节
    BPB_BytsPerSec  DW 512      ; 每扇区字节数
    BPB_SecPerClus  DB 1        ; 每簇多少扇区
    BPB_RsvdSecCnt  DW 1        ; Boot 记录占用多少扇区
    BPB_NumFATs DB 2        ; 共有多少 FAT 表
    BPB_RootEntCnt  DW 224      ; 根目录文件数最大值
    BPB_TotSec16    DW 2880     ; 逻辑扇区总数
    BPB_Media   DB 0xF0     ; 媒体描述符
    BPB_FATSz16 DW 9        ; 每FAT扇区数
    BPB_SecPerTrk   DW 18       ; 每磁道扇区数
    BPB_NumHeads    DW 2        ; 磁头数(面数)
    BPB_HiddSec DD 0        ; 隐藏扇区数
    BPB_TotSec32    DD 0        ; 如果 wTotalSectorCount 是 0 由这个值记录扇区数
    BS_DrvNum   DB 0        ; 中断 13 的驱动器号
    BS_Reserved1    DB 0        ; 未使用
    BS_BootSig  DB 29h      ; 扩展引导标记 (29h)
    BS_VolID    DD 0        ; 卷序列号
    BS_VolLab   DB 'OrangeS0.02'; 卷标, 必须 11 个字节
    BS_FileSysType  DB 'FAT12   '   ; 文件系统类型, 必须 8个字节  

LABEL_START:    
    mov ax, cs
    mov ds, ax
    mov es, ax
    mov ss, ax
    mov sp, BaseOfStack

    ; 清屏
    mov ax, 0600h       ; AH = 6,  AL = 0h
    mov bx, 0700h       ; 黑底白字(BL = 07h)
    mov cx, 0           ; 左上角: (0, 0)
    mov dx, 0184fh      ; 右下角: (80, 50)
    int 10h         ; int 10h

    mov dh, 0           ; "Booting  "
    call    DispStr         ; 显示字符串
    
    xor ah, ah  ; ┓
    xor dl, dl  ; ┣ 软驱复位
    int 13h ; ┛
    
; 下面在 A 盘的根目录寻找 LOADER.BIN
    mov word [wSectorNo], SectorNoOfRootDirectory
LABEL_SEARCH_IN_ROOT_DIR_BEGIN:
    cmp word [wRootDirSizeForLoop], 0   ; ┓
    jz  LABEL_NO_LOADERBIN      ; ┣ 判断根目录区是不是已经读完
    dec word [wRootDirSizeForLoop]  ; ┛ 如果读完表示没有找到 LOADER.BIN
    mov ax, BaseOfLoader
    mov es, ax          ; es <- BaseOfLoader
    mov bx, OffsetOfLoader  ; bx <- OffsetOfLoader  于是, es:bx = BaseOfLoader:OffsetOfLoader
    mov ax, [wSectorNo] ; ax <- Root Directory 中的某 Sector 号
    mov cl, 1
    call    ReadSector

    mov si, LoaderFileName  ; ds:si -> "LOADER  BIN"
    mov di, OffsetOfLoader  ; es:di -> BaseOfLoader:0100 = BaseOfLoader*10h+100
    cld
    mov dx, 10h
LABEL_SEARCH_FOR_LOADERBIN:
    cmp dx, 0                                       ; ┓循环次数控制,
    jz  LABEL_GOTO_NEXT_SECTOR_IN_ROOT_DIR  ; ┣如果已经读完了一个 Sector,
    dec dx                                          ; ┛就跳到下一个 Sector
    mov cx, 11
LABEL_CMP_FILENAME:
    cmp cx, 0
    jz  LABEL_FILENAME_FOUND    ; 如果比较了 11 个字符都相等, 表示找到
dec cx
    lodsb               ; ds:si -> al
    cmp al, byte [es:di]
    jz  LABEL_GO_ON
    jmp LABEL_DIFFERENT     ; 只要发现不一样的字符就表明本 DirectoryEntry 不是
; 我们要找的 LOADER.BIN
LABEL_GO_ON:
    inc di
    jmp LABEL_CMP_FILENAME  ;   继续循环

LABEL_DIFFERENT:
    and di, 0FFE0h                      ; else ┓    di &= E0 为了让它指向本条目开头
    add di, 20h                         ;     ┃
    mov si, LoaderFileName                  ;     ┣ di += 20h  下一个目录条目
    jmp LABEL_SEARCH_FOR_LOADERBIN;    ┛

LABEL_GOTO_NEXT_SECTOR_IN_ROOT_DIR:
    add word [wSectorNo], 1
    jmp LABEL_SEARCH_IN_ROOT_DIR_BEGIN

LABEL_NO_LOADERBIN:
    mov dh, 2               ; "No LOADER."
    call    DispStr         ; 显示字符串
    jmp $                   ; 没有找到 LOADER.BIN, 死循环在这里

LABEL_FILENAME_FOUND:           ; 找到 LOADER.BIN 后便来到这里继续
    mov ax, RootDirSectors
    and di, 0FFE0h      ; di -> 当前条目的开始
    add di, 01Ah        ; di -> 首 Sector
    mov cx, word [es:di]
    push    cx          ; 保存此 Sector 在 FAT 中的序号
    add cx, ax
    add cx, DeltaSectorNo   ; cl <- LOADER.BIN的起始扇区号(0-based)
    mov ax, BaseOfLoader
    mov es, ax          ; es <- BaseOfLoader
    mov bx, OffsetOfLoader  ; bx <- OffsetOfLoader
    mov ax, cx          ; ax <- Sector 号

LABEL_GOON_LOADING_FILE:
    push    ax          ; `.
    push    bx          ;  |
    mov ah, 0Eh         ;  | 每读一个扇区就在 "Booting  " 后面
    mov al, '.'         ;  | 打一个点, 形成这样的效果:
    mov bl, 0Fh         ;  | Booting ......
    int 10h         ;  |
    pop bx          ;  |
    pop ax          ; /

    mov cl, 1
    call    ReadSector
    pop ax          ; 取出此 Sector 在 FAT 中的序号
    call    GetFATEntry
    cmp ax, 0FFFh
    jz  LABEL_FILE_LOADED
    push    ax          ; 保存 Sector 在 FAT 中的序号
    mov dx, RootDirSectors
    add ax, dx
    add ax, DeltaSectorNo
    add bx, [BPB_BytsPerSec]
    jmp LABEL_GOON_LOADING_FILE
LABEL_FILE_LOADED:
    mov dh, 1           ; "Ready."
    call    DispStr         ; 显示字符串

; *****************************************************************************************************
    jmp BaseOfLoader:OffsetOfLoader ; 这一句正式跳转到已加载到内
                        ; 存中的 LOADER.BIN 的开始处，
                        ; 开始执行 LOADER.BIN 的代码。
                        ; Boot Sector 的使命到此结束。
; *****************************************************************************************************

;============================================================================
;变量
;----------------------------------------------------------------------------
wRootDirSizeForLoop dw  RootDirSectors  ; Root Directory 占用的扇区数, 在循环中会递减至零.
wSectorNo       dw  0       ; 要读取的扇区号
bOdd            db  0       ; 奇数还是偶数

;============================================================================
;字符串
;----------------------------------------------------------------------------
LoaderFileName      db  "LOADER  BIN", 0    ; LOADER.BIN 之文件名
; 为简化代码, 下面每个字符串的长度均为 MessageLength
MessageLength       equ 9
BootMessage:        db  "Booting  "; 9字节, 不够则用空格补齐. 序号 0
Message1        db  "Ready.   "; 9字节, 不够则用空格补齐. 序号 1
Message2        db  "No LOADER"; 9字节, 不够则用空格补齐. 序号 2
;============================================================================

;----------------------------------------------------------------------------
; 函数名: DispStr
;----------------------------------------------------------------------------
; 作用:
;   显示一个字符串, 函数开始时 dh 中应该是字符串序号(0-based)
DispStr:
    mov ax, MessageLength
    mul dh
    add ax, BootMessage
    mov bp, ax          ; ┓
    mov ax, ds          ; ┣ ES:BP = 串地址
    mov es, ax          ; ┛
    mov cx, MessageLength   ; CX = 串长度
    mov ax, 01301h      ; AH = 13,  AL = 01h
    mov bx, 0007h       ; 页号为0(BH = 0) 黑底白字(BL = 07h)
    mov dl, 0
    int 10h         ; int 10h
    ret

;----------------------------------------------------------------------------
; 函数名: ReadSector
;----------------------------------------------------------------------------
; 作用:
;   从第 ax 个 Sector 开始, 将 cl 个 Sector 读入 es:bx 中
ReadSector:
    ; -----------------------------------------------------------------------
    ; 怎样由扇区号求扇区在磁盘中的位置 (扇区号 -> 柱面号, 起始扇区, 磁头号)
    ; -----------------------------------------------------------------------
    ; 设扇区号为 x
    ;                           ┌ 柱面号 = y >> 1
    ;       x           ┌ 商 y ┤
    ; -------------- => ┤      └ 磁头号 = y & 1
    ;  每磁道扇区数     │
    ;                   └ 余 z => 起始扇区号 = z + 1
    push    bp
    mov bp, sp
    sub esp, 2          ; 辟出两个字节的堆栈区域保存要读的扇区数: byte [bp-2]

    mov byte [bp-2], cl
    push    bx          ; 保存 bx
    mov bl, [BPB_SecPerTrk] ; bl: 除数
    div bl          ; y 在 al 中, z 在 ah 中
    inc ah          ; z ++
    mov cl, ah          ; cl <- 起始扇区号
    mov dh, al          ; dh <- y
    shr al, 1           ; y >> 1 (其实是 y/BPB_NumHeads, 这里BPB_NumHeads=2)
    mov ch, al          ; ch <- 柱面号
    and dh, 1           ; dh & 1 = 磁头号
    pop bx          ; 恢复 bx
    ; 至此, "柱面号, 起始扇区, 磁头号" 全部得到 ^^^^^^^^^^^^^^^^^^^^^^^^
    mov dl, [BS_DrvNum]     ; 驱动器号 (0 表示 A 盘)
.GoOnReading:
    mov ah, 2           ; 读
    mov al, byte [bp-2]     ; 读 al 个扇区
    int 13h
    jc  .GoOnReading        ; 如果读取错误 CF 会被置为 1, 这时就不停地读, 直到正确为止

    add esp, 2
    pop bp

    ret

;----------------------------------------------------------------------------
; 函数名: GetFATEntry
;----------------------------------------------------------------------------
; 作用:
;   找到序号为 ax 的 Sector 在 FAT 中的条目, 结果放在 ax 中
;   需要注意的是, 中间需要读 FAT 的扇区到 es:bx 处, 所以函数一开始保存了 es 和 bx
GetFATEntry:
    push    es
    push    bx
    push    ax
    mov ax, BaseOfLoader; `.
    sub ax, 0100h   ;  | 在 BaseOfLoader 后面留出 4K 空间用于存放 FAT
    mov es, ax      ; /
    pop ax
    mov byte [bOdd], 0
    mov bx, 3
    mul bx          ; dx:ax = ax * 3
    mov bx, 2
    div bx          ; dx:ax / 2  ==>  ax <- 商, dx <- 余数
    cmp dx, 0
    jz  LABEL_EVEN
    mov byte [bOdd], 1
LABEL_EVEN:;偶数
    ; 现在 ax 中是 FATEntry 在 FAT 中的偏移量,下面来
    ; 计算 FATEntry 在哪个扇区中(FAT占用不止一个扇区)
    xor dx, dx          
    mov bx, [BPB_BytsPerSec]
    div bx ; dx:ax / BPB_BytsPerSec
           ;  ax <- 商 (FATEntry 所在的扇区相对于 FAT 的扇区号)
           ;  dx <- 余数 (FATEntry 在扇区内的偏移)。
    push    dx
    mov bx, 0 ; bx <- 0 于是, es:bx = (BaseOfLoader - 100):00
    add ax, SectorNoOfFAT1 ; 此句之后的 ax 就是 FATEntry 所在的扇区号
    mov cl, 2
    call    ReadSector ; 读取 FATEntry 所在的扇区, 一次读两个, 避免在边界
               ; 发生错误, 因为一个 FATEntry 可能跨越两个扇区
    pop dx
    add bx, dx
    mov ax, [es:bx]
    cmp byte [bOdd], 1
    jnz LABEL_EVEN_2
    shr ax, 4
LABEL_EVEN_2:
    and ax, 0FFFh

LABEL_GET_FAT_ENRY_OK:

    pop bx
    pop es
    ret
;----------------------------------------------------------------------------

times   510-($-$$)  db  0   ; 填充剩下的空间，使生成的二进制代码恰好为512字节
dw  0xaa55              ; 结束标志

然后我们使用以下命令将 boot.asm 编译成 boot.bin，再将 boot.bin 写入虚拟软盘镜像文件 fd.img，然后执行查看效果。

# 编译
nasm boot.asm -o boot.bin
# 写入软盘镜像
dd if=boot.bin of=fd.img bs=512 count=1 conv=notrunc

好了，到此为止，如何突破512字节的限制就记录完了。

公众号

zorro_z

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录