assembly - ¿Por qué no se carga mi directorio raíz?(FAT12)

x86 filesystems

Question

Estoy escribiendo un gestor de arranque de la etapa 1 en ensamblado con el que intento cargar el sistema de archivos FAT12 en la memoria para poder cargar mi gestor de arranque de la etapa 2. He logrado cargar las FAT en la memoria, sin embargo, estoy luchando por cargar el directorio raíz en la memoria.

Actualmente estoy usando this como referencia y he producido lo siguiente:

.load_root:
    ;es is 0x7c0
    xor dx, dx              ; blank dx for division
    mov si, fat_loaded      ; inform user that FAT is loaded
    call print
    mov al, [FATcount]      ; calculate how many sectors into the disk must be loaded
    mul word [SectorsPerFAT]
    add al, [ReservedSectors]
    div byte [SectorsPerTrack]
    mov ch, ah              ; Store quotient in ch for cylinder number
    mov cl, al              ; Store remainder in cl for sector number

    xor dx, dx
    xor ax, ax
    mov al, ch              ; get back to "absolute" sector number
    mul byte [SectorsPerTrack]
    add al, cl
    mul word [BytesPerSector]
    mov bx,ax               ; Memory offset to load to data into memory after BOTH FATs (should be 0x2600, physical address should be 0xA200)

    xor dx, dx              ; blank dx for division
    mov ax, 32
    mul word [MaxDirEntries]
    div word [BytesPerSector] ; number of sectors root directory takes up (should be 14)

    xor dh, dh              ; head 0
    mov dl, [boot_device]   ; boot device

    mov ah, 0x02            ; select read mode

    int 13h
    cmp ah, 0
    je .load_OS
    mov si, error_text
    call print
    jmp $

Sin embargo, si inspecciono la memoria en 0xA200 con gdb, solo veo 0s. Mi directorio raíz contiene un archivo: he puesto un archivo llamado OS.BIN en el directorio raíz para probar.

El uso de info registers en gdb después de la operación de lectura da el siguiente resultado:

eax            0xe      14
ecx            0x101    257
edx            0x0      0
ebx            0x2600   9728
esp            0x76d0   0x76d0
ebp            0x0      0x0
esi            0x16d    365
edi            0x0      0
eip            0x7cdd   0x7cdd
eflags         0x246    [ PF ZF IF ]
cs             0x0      0
ss             0x53     83
ds             0x7c0    1984
es             0x7c0    1984
fs             0x0      0
gs             0x0      0

El estado de la operación es 0, el número de sectores leídos es 14 y es:bx apunta a 0xA200, pero x/32b 0xa200 muestra 32 0s, cuando esperaba ver los datos de OS.BIN.

EDITAR Hice info registers antes de la interrupción y la salida es la siguiente:

eax            0x20e    526
ecx            0x101    257
edx            0x0      0
ebx            0x2600   9728
esp            0x76d0   0x76d0
ebp            0x0      0x0
esi            0x161    353
edi            0x0      0
eip            0x7cc8   0x7cc8
eflags         0x246    [ PF ZF IF ]
cs             0x0      0
ss             0x53     83
ds             0x7c0    1984
es             0x7c0    1984
fs             0x0      0
gs             0x0      0

Que es lo mismo que después, excepto que el número de solicitud de función ha sido reemplazado por el código de estado.

¿A dónde voy mal? ¿Estoy leyendo desde la dirección incorrecta de CHS? ¿O algún otro simple error? ¿Y cómo puedo corregir esto?

Estoy usando fat_imgen para hacer mi imagen de disco. El comando para crear la imagen de disco es fat_imgen -c -f floppy.flp -F -s bootloader.bin y el comando para agregar OS.BIN a la imagen es fat_imgen -m -f floppy.flp -i OS.BIN

Tengo un bloque de parámetros de BIOS (BPB) que representa un disquete de 1,44 MB con FAT12:

jmp short loader
times 9 db 0

BytesPerSector: dw 512
SectorsPerCluster: db 1
ReservedSectors: dw 1
FATcount: db 2
MaxDirEntries: dw 224
TotalSectors: dw 2880
db 0
SectorsPerFAT: dw 9
SectorsPerTrack: dw 18
NumberOfHeads: dw 2
dd 0
dd 0
dw 0
BootSignature: db 0x29
VolumeID: dd 77
VolumeLabel: db "Bum''dOS   ",0
FSType: db "FAT12   "

Tengo otra función que parece funcionar que carga la tabla FAT12 en la dirección de memoria 0x7c0: 0x0200 (dirección física 0x07e00):

;;;Start loading File Allocation Table (FAT)
.load_fat:
    mov ax, 0x07c0          ; address from start of programs
    mov es, ax
    mov ah, 0x02            ; set to read
    mov al, [SectorsPerFAT]   ; how many sectors to load
    xor ch, ch              ; cylinder 0
    mov cl, [ReservedSectors]  ; Load FAT1
    add cl, byte 1
    xor dh, dh              ; head 0
    mov bx, 0x0200          ; read data to 512B after start of code
    int 13h
    cmp ah, 0
    je .load_root
    mov si, error_text
    call print
    hlt

Answer 1

Análisis del problema

El problema con su código es que no está leyendo desde el punto en el disco que está esperando. Aunque la lectura del disco es exitosa, ha cargado los sectores incorrectos en la memoria.

Si miramos la lista de interrupciones de Ralph Brown para Int 13h / AH = 2 , veremos que las entradas se ven así:

DISCO - LEER SECTOR (S) EN LA MEMORIA

AH = 02h
AL = number of sectors to read (must be nonzero)
CH = low eight bits of cylinder number
CL = sector number 1-63 (bits 0-5)
high two bits of cylinder (bits 6-7, hard disk only)
DH = head number
DL = drive number (bit 7 set for hard disk)
ES:BX -> data buffer

Si revisamos sus registros antes de hacer int 13h en .load_root , vemos estos registros con el siguiente contenido:

eax            0x20e   
ecx            0x101 
edx            0x0
ebx            0x2600 
es             0x7c0

Entonces ES: BX es 0x7c0: 0x2600, que es la dirección física 0xA200. Eso es correcto. AH (0x02) es lectura de disco y el número de sectores a leer en AL es 14 (0x0e). Esto parece razonable. El problema surge en ECX y EDX . Si revisamos su código, parece que está intentando encontrar el sector (Dirección de bloque lógico) en el disco donde comienza el directorio raíz:

mov al, [FATcount]      ; calculate how many sectors into the disk must be loaded
mul word [SectorsPerFAT]
add al, [ReservedSectors]

En su bloque de parámetros de BIOS tiene SectorsPerFat = 9, ReservedSectors = 1 y FATCount = 2. Si revisamos un documento de diseño FAT12 que muestra esta configuración, se vería así:

Tu cálculo es correcto. 2 * 9 + 1 = 19. Los primeros 19 bloques lógicos se ejecutan de LBA 0 a LBA 18. LBA 19 es donde comienza su directorio raíz. Necesitamos convertir esto a Cilindros / Cabezas / Sectores (CHS). Dirección del bloque lógico para el cálculo de CHS :

CHS tuples can be mapped to LBA address with the following formula:

LBA = (C × HPC + H) × SPT + (S - 1)

where C, H and S are the cylinder number, the head number, and the sector number

LBA is the logical block address
HPC is the maximum number of heads per cylinder (reported by 
    disk drive, typically 16 for 28-bit LBA)
SPT is the maximum number of sectors per track (reported by
    disk drive, typically 63 for 28-bit LBA)
LBA addresses can be mapped to CHS tuples with the following formula 
    ("mod" is the modulo operation, i.e. the remainder, and "÷" is 
    integer division, i.e. the quotient of the division where any 
    fractional part is discarded):

    C = LBA ÷ (HPC × SPT)
    H = (LBA ÷ SPT) mod HPC
    S = (LBA mod SPT) + 1

En su código SPT = 18, HPC = 2. Si usamos un LBA de 19 calculamos un CHS de C = 0, H = 1, S = 2. Si observamos los valores que pasó a los registros ( CL , CH , DH ) arriba, descubrimos que utilizó un CHS de C = 1, H = 0, S = 1. Esto pasa a ser LBA 36, no 19. El problema es que sus cálculos son incorrectos. En particular .load_root :

div byte [SectorsPerTrack]
mov ch, ah              ; Store quotient in ch for cylinder number
mov cl, al              ; Store remainder in cl for sector number
[snip]
xor dh, dh              ; head 0
mov dl, [boot_device]   ; boot device
mov ah, 0x02            ; select read mode
int 13h

Desafortunadamente, esta no es una forma correcta de calcular CHS a partir de un LBA. Tiene un problema similar con .load_fat pero tiene la suerte de calcular el valor correcto. Está leyendo los sectores incorrectos en el disco y eso está causando que los datos se carguen a 0xA200 que no esperaba.

Traducción de LBA a CHS

Lo que necesita es una rutina de conversión de LBA a CHS adecuada. Como necesitará dicha función para diferentes aspectos de la navegación de las estructuras de archivos FAT12, es mejor crear una función. Lo llamaremos lba_to_chs .

Antes de escribir dicho código, deberíamos revisar la ecuación anteriormente:

C = LBA ÷ (HPC × SPT)
H = (LBA ÷ SPT) mod HPC
S = (LBA mod SPT) + 1

Podríamos implementar esto tal como está, pero si reelaboramos la ecuación para cilindros podemos reducir la cantidad de trabajo que tenemos que hacer. C = LBA ÷ (HPC × SPT) se puede reescribir como:

C = LBA ÷ (HPC × SPT)
C = LBA ÷ (SPT × HPC)
C = (LBA ÷ SPT) × (1 ÷ HPC)
C = (LBA ÷ SPT) ÷ HPC

Si ahora miramos la fórmula revisada tenemos:

C = (LBA ÷ SPT) ÷ HPC
H = (LBA ÷ SPT) mod HPC
S = (LBA mod SPT) + 1

Ahora deberíamos notar que (LBA ÷ SPT) está duplicado en dos lugares. Solo tenemos que hacer esa ecuación una vez. Además, dado que la instrucción DIV x86 calcula el resto y el cociente al mismo tiempo, también terminamos calculando LBA mod SPT de forma gratuita cuando lo hacemos (LBA ÷ SPT) . El código seguiría esta estructura:

1. Calcule LBA DIV SPT. Esto produce:
   • (LBA ÷ SPT) en el cociente
   • (LBA mod SPT) en el resto
2. Tome el resto del paso (1) y póngalo en un registro temporal
3. Agregue 1 al temporal en el paso (2). Ese registro ahora contiene el sector calculado por S = (LBA mod SPT) + 1
4. Tome el cociente del paso (1) y divida por HPC.
   • El número del cilindro será el cociente
   • La cabeza será el resto.

Hemos reducido la ecuación a un par de instrucciones DIV y un incremento / suma. Podemos simplificar las cosas más. Si suponemos que estamos utilizando formatos de disco compatibles de IBM bien conocidos, también podemos decir que los sectores por pista (SPT), cabezas (HPC), cilindro, cabeza y sector siempre serán inferiores a 256. Cuando el LBA máximo en cualquier pozo el formato de disquete conocido se divide por SPT, el resultado siempre será inferior a 256. Saber esto nos permite evitar que los bits superiores tomen los dos bits superiores del cilindro y los coloquen en los dos bits superiores de CL . También podemos usar instrucciones DIV que hacen una división sin signo de 16 bits por 8 bits.

Código de traducción

Si tomamos el pseudocódigo anterior, podemos crear una función lba_to_chs bastante pequeña que toma un LBA y lo convierte a CHS y solo funciona para formatos de disquete compatibles con IBM.

;    Function: lba_to_chs
; Description: Translate Logical block address to CHS (Cylinder, Head, Sector).
;              Works ONLY for well known IBM PC compatible floppy disk formats.
;
;   Resources: http://www.ctyme.com/intr/rb-0607.htm
;              https://en.wikipedia.org/wiki/Logical_block_addressing#CHS_conversion
;              https://stackoverflow.com/q/45434899/3857942
;              Sector    = (LBA mod SPT) + 1
;              Head      = (LBA / SPT) mod HEADS
;              Cylinder  = (LBA / SPT) / HEADS
;
;      Inputs: SI = LBA
;     Outputs: DL = Boot Drive Number
;              DH = Head
;              CH = Cylinder
;              CL = Sector
;
;       Notes: Output registers match expectation of Int 13h/AH=2 inputs
;
lba_to_chs:
    push ax                    ; Preserve AX
    mov ax, si                 ; Copy 16-bit LBA to AX
    div byte [SectorsPerTrack] ; 16-bit by 8-bit DIV : LBA / SPT
    mov cl, ah                 ; CL = S = LBA mod SPT
    inc cl                     ; CL = S = (LBA mod SPT) + 1
    xor ah, ah                 ; Upper 8-bit of 16-bit value set to 0 for DIV
    div byte [NumberOfHeads]   ; 16-bit by 8-bit DIV : (LBA / SPT) / HEADS
    mov ch, al                 ; CH = C = (LBA / SPT) / HEADS
    mov dh, ah                 ; DH = H = (LBA / SPT) mod HEADS
    mov dl, [boot_device]      ; boot device, not necessary to set but convenient
    pop ax                     ; Restore scratch register
    ret

Si necesita una versión que pueda manejar todas las geometrías de disco válidas admitidas por FAT12, entonces el código tendría que usar instrucciones DIV de 32 bits / 16 bits y uno debe tratar con cilindros de 10 bits en lugar de 8. El código de muestra podría verse me gusta:

;    Function: lba_to_chs
; Description: Translate Logical block address to CHS (Cylinder, Head, Sector).
;              Works for all valid FAT12 compatible disk geometries.
;
;   Resources: http://www.ctyme.com/intr/rb-0607.htm
;              https://en.wikipedia.org/wiki/Logical_block_addressing#CHS_conversion
;              https://stackoverflow.com/q/45434899/3857942
;              Sector    = (LBA mod SPT) + 1
;              Head      = (LBA / SPT) mod HEADS
;              Cylinder  = (LBA / SPT) / HEADS
;
;      Inputs: SI = LBA
;     Outputs: DL = Boot Drive Number
;              DH = Head
;              CH = Cylinder (lower 8 bits of 10-bit cylinder)
;              CL = Sector/Cylinder
;                   Upper 2 bits of 10-bit Cylinders in upper 2 bits of CL
;                   Sector in lower 6 bits of CL
;
;       Notes: Output registers match expectation of Int 13h/AH=2 inputs
;
lba_to_chs:
    push ax                    ; Preserve AX
    mov ax, si                 ; Copy LBA to AX
    xor dx, dx                 ; Upper 16-bit of 32-bit value set to 0 for DIV
    div word [SectorsPerTrack] ; 32-bit by 16-bit DIV : LBA / SPT
    mov cl, dl                 ; CL = S = LBA mod SPT
    inc cl                     ; CL = S = (LBA mod SPT) + 1
    xor dx, dx                 ; Upper 16-bit of 32-bit value set to 0 for DIV
    div word [NumberOfHeads]   ; 32-bit by 16-bit DIV : (LBA / SPT) / HEADS
    mov dh, dl                 ; DH = H = (LBA / SPT) mod HEADS
    mov dl, [boot_device]      ; boot device, not necessary to set but convenient
    mov ch, al                 ; CH = C(lower 8 bits) = (LBA / SPT) / HEADS
    shl ah, 6                  ; Store upper 2 bits of 10-bit Cylinder into
    or  cl, ah                 ;     upper 2 bits of Sector (CL)
    pop ax                     ; Restore scratch registers
    ret

Puede usar cualquiera de estas funciones lba_to_chs la misma manera e integrarlas en su código .load_fat y .load_root . Su código podría verse así:

;;;Start loading File Allocation Table (FAT)
.load_fat:
    mov ax, 0x07c0             ; address from start of programs
    mov es, ax
    mov ah, 0x02               ; set to read
    mov al, [SectorsPerFAT]    ; how many sectors to load

    mov si, [ReservedSectors]  ; Load FAT1 into SI for input to lba_to_chs
    call lba_to_chs            ; Retrieve CHS parameters and boot drive for LBA

    mov bx, 0x0200             ; read data to 512B after start of code
    int 13h
    cmp ah, 0
    je .load_root
    mov si, error_text
    call print
    hlt

;;;Start loading root directory
.load_root:
    mov si, fat_loaded
    call print
    xor ax, ax
    mov al, [FATcount]
    mul word [SectorsPerFAT]
    add ax, [ReservedSectors]  ; Compute LBA of oot directory entries
    mov si, ax                 ; Copy LBA to SI for later call to lba_to_chs

    mul word [BytesPerSector]
    mov bx,ax                  ; Load to after BOTH FATs in memory

    xor dx, dx                 ; blank dx for division
    mov ax, 32
    mul word [MaxDirEntries]
    div word [BytesPerSector]  ; number of sectors to read

    call lba_to_chs            ; Retrieve CHS values and load boot drive
    mov ah, 0x02
    int 13h
    cmp ah, 0
    je .load_OS
    mov si, error_text
    call print
    jmp $

Answer 2

Terminé descartando la carga del directorio raíz después de cargar las FAT. Al final, modifiqué mi rutina .load_fat para cargar las FAT y el directorio raíz al mismo tiempo (esencialmente leyendo 32 sectores después del sector de arranque, pero de una manera que todavía me permite modificar fácilmente la geometría del disco).

El código para esto está abajo:

.load_fat:
    mov ax, 0x07c0          ; address from start of programs
    mov es, ax
    mov al, [SectorsPerFAT] ; how many sectors to load
    mul byte [FATcount]     ; load both FATs
    mov dx, ax
    push dx
    xor dx, dx              ; blank dx for division
    mov ax, 32
    mul word [MaxDirEntries]
    div word [BytesPerSector] ; number of sectors for root directory
    pop dx
    add ax, dx              ; add root directory length and FATs length -- load all three at once
    xor dh,dh
    mov dl, [boot_device]

    xor ch, ch              ; cylinder 0
    mov cl, [ReservedSectors]  ; Load from after boot sector
    add cl, byte 1
    xor dh, dh              ; head 0
    mov bx, 0x0200          ; read data to 512B after start of code
    mov ah, 0x02            ; set to read
    int 13h
    cmp ah, 0
    je .load_root
    mov si, error_text
    call print
    hlt

Aunque no es la forma en que tenía la intención de resolver el problema, hace el trabajo y puedo pasar de esto para continuar el desarrollo.

EDITAR

Creo que resolví dónde andaba mal el viejo código, de todos modos. Estaba incrementando el cilindro después del sector 18, cuando debería haber estado incrementando la cabeza. ¡Es CHS, no HCS, por una razón!