Início / coding / Perguntas / 79544204
Accepted
Ryan Grube
Asked: 2025-03-30 13:07:39 +0800 CST

Executando multiplicação de números de 32 bits em modo real de 16 bits para percorrer tabela FAT

  • 772

Estou escrevendo um bootloader simples (e, espero que em breve, um sistema operacional). Tenho feito progressos, mas esta parte está me deixando um pouco perplexo.

Estou gravando este sistema operacional e bootloader em uma imagem de disco, que consiste em:

  1. Um setor de inicialização MBR e um bootloader de primeiro estágio
  2. Uma área reservada de 32kb para o bootloader de segundo estágio
  3. Uma partição FAT32 que contém o sistema operacional ekernel.bin

Meu objetivo é carregar kernel.bin na memória e pular para ele, e para fazer isso preciso percorrer as tabelas FAT.

Muita lógica envolvida na leitura da partição FAT32 requer valores de 32 bits (como muitos valores BPB)

Como estou essencialmente bloqueado no modo real por enquanto, não tenho certeza de como lidar com esses números de 32 bits ao executar cálculos como multiplicação. Sei que posso usar registradores de 32 bits usando o prefixo de tamanho do operando e/ou prefixo de tamanho do endereço, mas não posso realmente usar operações aritméticas neles de forma significativa.

Exemplo

Aqui está uma seção do assembly que armazena valores importantes do BPB:

BPB_info:

    ; BPB info from the FAT32 boot sector
    BPB_NumFATs: db 0 ; Number of FATs (1 byte)
    BPB_FATSz32: dd 0 ; Size of each FAT in sectors (4 bytes)
    BPB_RootClus: dd 0 ; First cluster of the root directory (4 bytes)
    BPB_SecPerClus: db 0 ; Sectors per cluster (1 byte)
    BPB_RsvdSecCnt: dw 0 ; Reserved sectors count (2 bytes)

    ; Calculated values used in the bootloader
    FAT_root_dir_start: dq 0 ; Start of the root directory in sectors (calculated)
    FAT_lba: dq 0 ; Logical block address of the FAT tables (calculated)

Para calcular FAT_root_dir_start, devo usar a seguinte fórmula:

BPB_RsvdSecCnt + ((BPB_RootClus - 2) * BPB_SecPerClus)

Mas como BPB_RootClusé uma doubleword (32 bits), não tenho certeza de como realizar essa operação.

Qualquer conselho seria apreciado! Estou no caminho certo? Devo abordar isso de forma completamente diferente? Talvez mudar para o modo protegido? Não tenho certeza.

assembly

1 respostas

  1. Best Answer

    Se você quiser se ater a um conjunto de instruções x86 estrito, então você está olhando para um típico problema de multiplicação longa ( Multiplicando um número de 64 bits por um número de 32 bits em 8086 asm para uma explicação, conforme apontado por @user207421). Em assembly:

    mov cx, [BPB_RootClus + 2]
mov ax, [BPB_RootClus]
sub ax, 2  ; cx:ax = BPB_RootClus - 2 = X; cx = Xh, ax=Xl
sbb cx, 0
mov bl, [BPB_SecPerClus] ; bx = y
mov bh, 0
mul bx  ; dx:ax = Xl * y
xchg ax, bx ; dx:bx = Xl * y, ax = y
mov bp, dx ; bp:bx = Xl * y
mul cx ; dx:ax = Xh * y
add ax, bp 
; adc dx, 0 - that'd be a carry-over but we'll assume that mutiplication result can fit into 32 bit

; now X * y is in ax:bx pair, add BPB_RsvdSecCnt
add bx, [BPB_RsvdSecCnt]
adc ax, 0

    Entretanto, se você estiver de acordo em usar instruções 80386 de 32 bits (usando substituição de tamanho de OPERANDO, mas não uma substituição de tamanho de endereço), então não vejo problema algum em simplesmente usar aritmética de 32 bits:

    bits 16
cpu 386
...
mov eax, [BPB_RootClus]
sub eax, 2
movzx edx, byte [BPB_SecPerClus]
mul edx
movzx edx, word [BPB_RsvdSecCnt]
add eax, edx

    Isso deve compilar e funcionar perfeitamente.

    • 3

relate perguntas