reactos/boot/freeldr/bootsect/ext2.S

689 lines
22 KiB
ArmAsm
Raw Normal View History

// EXT2.ASM
// EXT2 Boot Sector
// Copyright (c) 2002, 2003 Brian Palmer
// [bp-0x04] Here we will store the number of sectors per track
// [bp-0x08] Here we will store the number of heads
// [bp-0x0c] Here we will store the size of the disk as the BIOS reports in CHS form
// [bp-0x10] Here we will store the number of LBA sectors read
#include <asm.inc>
.code16
SECTORS_PER_TRACK = HEX(04)
NUMBER_OF_HEADS = HEX(08)
BIOS_CHS_DRIVE_SIZE = HEX(0C)
LBA_SECTORS_READ = HEX(10)
EXT2_ROOT_INO = 2
EXT2_S_IFMT = HEX(0f0)
EXT2_S_IFREG = HEX(080)
//org 7c00h
start:
jmp short main
nop
BootDrive:
.byte HEX(80)
//BootPartition db 0 // Moved to end of boot sector to have a standard format across all boot sectors
//SectorsPerTrack db 63 // Moved to [bp-SECTORS_PER_TRACK]
//NumberOfHeads dw 16 // Moved to [bp-NUMBER_OF_HEADS]
//BiosCHSDriveSize dd (1024 * 1024 * 63) // Moved to [bp-BIOS_CHS_DRIVE_SIZE]
//LBASectorsRead dd 0 // Moved to [bp-LBA_SECTORS_READ]
Ext2VolumeStartSector:
.long 263088 // Start sector of the ext2 volume
Ext2BlockSize:
.long 2 // Block size in sectors
Ext2BlockSizeInBytes:
.long 1024 // Block size in bytes
Ext2PointersPerBlock:
.long 256 // Number of block pointers that can be contained in one block
Ext2GroupDescPerBlock:
.long 32 // Number of group descriptors per block
Ext2FirstDataBlock:
.long 1 // First data block (1 for 1024-byte blocks, 0 for bigger sizes)
Ext2InodesPerGroup:
.long 2048 // Number of inodes per group
Ext2InodesPerBlock:
.long 8 // Number of inodes per block
Ext2ReadEntireFileLoadSegment:
.word 0
Ext2InodeIndirectPointer:
.long 0
Ext2InodeDoubleIndirectPointer:
.long 0
Ext2BlocksLeftToRead:
.long 0
main:
xor ax,ax // Setup segment registers
mov ds,ax // Make DS correct
mov es,ax // Make ES correct
mov ss,ax // Make SS correct
mov bp, HEX(7c00)
mov sp, HEX(7b00) // Setup a stack
mov si, offset BootDrive
cmp byte ptr [si], HEX(0ff) // If they have specified a boot drive then use it
jne GetDriveParameters
mov [si],dl // Save the boot drive
GetDriveParameters:
mov ah, 8
mov dl,[si] // Get boot drive in dl
int HEX(13) // Request drive parameters from the bios
jnc CalcDriveSize // If the call succeeded then calculate the drive size
// If we get here then the call to the BIOS failed
// so just set CHS equal to the maximum addressable
// size
mov cx, HEX(0ffff)
mov dh,cl
CalcDriveSize:
// Now that we have the drive geometry
// lets calculate the drive size
mov bl,ch // Put the low 8-bits of the cylinder count into BL
mov bh,cl // Put the high 2-bits in BH
shr bh,6 // Shift them into position, now BX contains the cylinder count
and cl, HEX(3f) // Mask off cylinder bits from sector count
// CL now contains sectors per track and DH contains head count
movzx eax,dh // Move the heads into EAX
movzx ebx,bx // Move the cylinders into EBX
movzx ecx,cl // Move the sectors per track into ECX
inc eax // Make it one based because the bios returns it zero based
mov [bp-NUMBER_OF_HEADS],eax // Save number of heads
mov [bp-SECTORS_PER_TRACK],ecx // Save number of sectors per track
inc ebx // Make the cylinder count one based also
mul ecx // Multiply heads with the sectors per track, result in edx:eax
mul ebx // Multiply the cylinders with (heads * sectors) [stored in edx:eax already]
// We now have the total number of sectors as reported
// by the bios in eax, so store it in our variable
mov [bp-BIOS_CHS_DRIVE_SIZE],eax
LoadExtraBootCode:
// First we have to load our extra boot code at
// sector 1 into memory at [0000:7e00h]
//mov eax,01h
xor eax,eax
inc eax // Read logical sector 1, EAX now = 1
mov cx,1 // Read one sector
mov bx, HEX(7e00) // Read sector to [0000:7e00h]
call ReadSectors
jmp LoadRootDirectory
// Reads ext2 group descriptor into [7000:8000]
// We read it to this arbitrary location so
// it will not cross a 64k boundary
// EAX has group descriptor number to read
Ext2ReadGroupDesc:
shl eax,5 // Group = (Group * sizeof(GROUP_DESCRIPTOR) /* 32 */)
xor edx,edx
div dword ptr [bp+Ext2GroupDescPerBlock] // Group = (Group / Ext2GroupDescPerBlock)
add eax, dword ptr [bp+Ext2FirstDataBlock] // Group = Group + Ext2FirstDataBlock + 1
inc eax // EAX now has the group descriptor block number
// EDX now has the group descriptor offset in the block
// Adjust the read offset so that the
// group descriptor is read to 7000:8000
mov ebx, HEX(78000)
sub ebx,edx
shr ebx,4
mov es,bx
xor bx,bx
// Everything is now setup to call Ext2ReadBlock
// Instead of using the call instruction we will
// just put Ext2ReadBlock right after this routine
// Reads ext2 block into ES:[BX]
// EAX has logical block number to read
Ext2ReadBlock:
mov ecx, dword ptr [bp+Ext2BlockSize]
mul ecx
jmp ReadSectors
// Reads ext2 inode into [6000:8000]
// We read it to this arbitrary location so
// it will not cross a 64k boundary
// EAX has inode number to read
Ext2ReadInode:
dec eax // Inode = Inode - 1
xor edx,edx
div dword ptr [bp+Ext2InodesPerGroup] // Inode = (Inode / Ext2InodesPerGroup)
mov ebx,eax // EBX now has the inode group number
mov eax,edx
xor edx,edx
div dword ptr [bp+Ext2InodesPerBlock] // Inode = (Inode / Ext2InodesPerBlock)
shl edx,7 // FIXME: InodeOffset *= 128 (make the array index a byte offset)
// EAX now has the inode offset block number from inode table
// EDX now has the inode offset in the block
// Save the inode values and put the group
// descriptor number in EAX and read it in
push edx
push eax
mov eax,ebx
call Ext2ReadGroupDesc
// Group descriptor has been read, now
// grab the inode table block number from it
push HEX(7000)
pop es
mov di, HEX(8008)
pop eax // Restore inode offset block number from stack
add eax, es:[di] // Add the inode table start block
// Adjust the read offset so that the
// inode we want is read to 6000:8000
pop edx // Restore inode offset in the block from stack
mov ebx, HEX(68000)
sub ebx,edx
shr ebx,4
mov es,bx
xor bx,bx
call Ext2ReadBlock
ret
// Reads logical sectors into ES:[BX]
// EAX has logical sector number to read
// CX has number of sectors to read
ReadSectors:
add eax, dword ptr [bp+Ext2VolumeStartSector] // Add the start of the volume
cmp eax, [bp-BIOS_CHS_DRIVE_SIZE] // Check if they are reading a sector outside CHS range
jae ReadSectorsLBA // Yes - go to the LBA routine
// If at all possible we want to use LBA routines because
// They are optimized to read more than 1 sector per read
pushad // Save logical sector number & sector count
CheckInt13hExtensions: // Now check if this computer supports extended reads
mov ah, HEX(41) // AH = 41h
mov bx, HEX(55aa) // BX = 55AAh
mov dl, byte ptr [bp+BootDrive] // DL = drive (80h-FFh)
int HEX(13) // IBM/MS INT 13 Extensions - INSTALLATION CHECK
jc ReadSectorsCHS // CF set on error (extensions not supported)
cmp bx, HEX(0aa55) // BX = AA55h if installed
jne ReadSectorsCHS
test cl,1 // CX = API subset support bitmap
jz ReadSectorsCHS // Bit 0, extended disk access functions (AH=42h-44h,47h,48h) supported
popad // Restore sector count & logical sector number
ReadSectorsLBA:
pushad // Save logical sector number & sector count
cmp cx, 64 // Since the LBA calls only support 0x7F sectors at a time we will limit ourselves to 64
jbe ReadSectorsSetupDiskAddressPacket // If we are reading less than 65 sectors then just do the read
mov cx,64 // Otherwise read only 64 sectors on this loop iteration
ReadSectorsSetupDiskAddressPacket:
mov [bp-LBA_SECTORS_READ],cx
mov word ptr [bp-LBA_SECTORS_READ+2],0
data32 push 0
push eax // Put 64-bit logical block address on stack
push es // Put transfer segment on stack
push bx // Put transfer offset on stack
push cx // Set transfer count
push 16 // Set size of packet to 10h
mov si,sp // Setup disk address packet on stack
mov dl, byte ptr [bp+BootDrive] // Drive number
mov ah, HEX(42) // Int 13h, AH = 42h - Extended Read
int HEX(13) // Call BIOS
jc PrintDiskError // If the read failed then abort
add sp, 16 // Remove disk address packet from stack
popad // Restore sector count & logical sector number
push bx
mov ebx, [bp-LBA_SECTORS_READ]
add eax,ebx // Increment sector to read
shl ebx,5
mov dx,es
add dx,bx // Setup read buffer for next sector
mov es,dx
pop bx
sub cx,[bp-LBA_SECTORS_READ]
jnz ReadSectorsLBA // Read next sector
ret
// Reads logical sectors into ES:[BX]
// EAX has logical sector number to read
// CX has number of sectors to read
ReadSectorsCHS:
popad // Get logical sector number & sector count off stack
ReadSectorsCHSLoop:
pushad
xor edx,edx
mov ecx, [bp-SECTORS_PER_TRACK]
div ecx // Divide logical by SectorsPerTrack
inc dl // Sectors numbering starts at 1 not 0
mov cl,dl // Sector in CL
mov edx,eax
shr edx,16
div word ptr [bp-NUMBER_OF_HEADS] // Divide logical by number of heads
mov dh,dl // Head in DH
mov dl, byte ptr [bp+BootDrive] // Drive number in DL
mov ch,al // Cylinder in CX
ror ah,2 // Low 8 bits of cylinder in CH, high 2 bits
// in CL shifted to bits 6 & 7
or cl,ah // Or with sector number
mov ax, HEX(0201)
int HEX(13) // DISK - READ SECTORS INTO MEMORY
// AL = number of sectors to read, CH = track, CL = sector
// DH = head, DL = drive, ES:BX -> buffer to fill
// Return: CF set on error, AH = status (see AH=01h), AL = number of sectors read
jc PrintDiskError // If the read failed then abort
popad
inc eax // Increment Sector to Read
mov dx,es
add dx, HEX(20) // Increment read buffer for next sector
mov es,dx
loop ReadSectorsCHSLoop // Read next sector
ret
// Displays a disk error message
// And reboots
PrintDiskError:
mov si,msgDiskError // Bad boot disk message
call PutChars // Display it
Reboot:
mov si,msgAnyKey // Press any key message
call PutChars // Display it
xor ax,ax
int HEX(16) // Wait for a keypress
int HEX(19) // Reboot
PutChars:
lodsb
or al,al
jz short Done
call PutCharsCallBios
jmp short PutChars
PutCharsCallBios:
mov ah, HEX(0e)
mov bx, HEX(07)
int HEX(10)
ret
Done:
mov al, HEX(0d)
call PutCharsCallBios
mov al, HEX(0a)
call PutCharsCallBios
ret
msgDiskError:
.ascii "Disk error", NUL
// Sorry, need the space...
//msgAnyKey db 'Press any key to restart',0
msgAnyKey:
.ascii "Press key", NUL
// times 509-($-$$) db 0 // Pad to 509 bytes
.org 509
BootPartition:
.byte 0
.word HEX(0aa55) // BootSector signature
// End of bootsector
//
// Now starts the extra boot code that we will store
// at sector 1 on a EXT2 volume
LoadRootDirectory:
mov eax,EXT2_ROOT_INO // Put the root directory inode number in EAX
call Ext2ReadInode // Read in the inode
// Point ES:DI to the inode structure at 6000:8000
push HEX(6000)
pop es
mov di, HEX(8000)
push di
push es // Save these for later
// Get root directory size from inode structure
mov eax, es:[di+4]
push eax
// Now that the inode has been read in load
// the root directory file data to 0000:8000
call Ext2ReadEntireFile
// Since the root directory was loaded to 0000:8000
// then add 8000h to the root directory's size
pop eax
mov edx, HEX(8000) // Set EDX to the current offset in the root directory
add eax,edx // Initially add 8000h to the size of the root directory
SearchRootDirectory:
push edx // Save current offset in root directory
push eax // Save the size of the root directory
// Now we have to convert the current offset
// in the root directory to a SEGMENT:OFFSET pair
mov eax,edx
xor edx,edx
mov ecx,16
div ecx // Now AX:DX has segment & offset
mov es,ax
mov di,dx
push di // Save the start of the directory entry
add di, 8 // Add the offset to the filename
mov si,filename
mov cl,11
repe cmpsb // Compare the file names
pop di
pop eax
pop edx
jz FoundFile
// Nope, didn't find it in this entry, keep looking
movzx ecx,word ptr es:[di+4]
add edx,ecx
// Check to see if we have reached the
// end of the root directory
cmp edx,eax
jb SearchRootDirectory
jmp PrintFileNotFound
FoundFile:
mov eax,es:[di] // Get inode number from directory entry
call Ext2ReadInode // Read in the inode
// Point ES:DI to the inode structure at 6000:8000
pop es
pop di // These were saved earlier
mov cx, es:[di] // Get the file mode so we can make sure it's a regular file
and ch,EXT2_S_IFMT // Mask off everything but the file type
cmp ch,EXT2_S_IFREG // Make sure it's a regular file
je LoadFreeLoader
jmp PrintRegFileError
LoadFreeLoader:
mov si,msgLoading // "Loading FreeLoader..." message
call PutChars // Display it
call Ext2ReadEntireFile // Read freeldr.sys to 0000:8000
mov dl, byte ptr [bp+BootDrive]
mov dh, byte ptr [bp+BootPartition]
push 0 // push segment (0x0000)
mov eax, [HEX(8000) + HEX(0A8)] // load the RVA of the EntryPoint into eax
add eax, HEX(8000) // RVA -> VA
push ax // push offset
retf // Transfer control to FreeLoader
// Reads ext2 file data into [0000:8000]
// This function assumes that the file's
// inode has been read in to 6000:8000 *and*
// ES:DI points to 6000:8000
// This will load all the blocks up to
// and including the double-indirect pointers.
// This should be sufficient because it
// allows for ~64MB which is much bigger
// than we need for a boot loader.
Ext2ReadEntireFile:
// Reset the load segment
mov word ptr [bp+Ext2ReadEntireFileLoadSegment], HEX(800)
// Now we must calculate how
// many blocks to read in
// We will do this by rounding the
// file size up to the next block
// size and then dividing by the block size
mov eax, dword ptr [bp+Ext2BlockSizeInBytes] // Get the block size in bytes
push eax
dec eax // Ext2BlockSizeInBytes -= 1
add eax, es:[di+4] // Add the file size
xor edx,edx
pop ecx // Divide by the block size in bytes
div ecx // EAX now contains the number of blocks to load
push eax
// Make sure the file size isn't zero
cmp eax, 0
jnz Ext2ReadEntireFile2
jmp PrintFileSizeError
Ext2ReadEntireFile2:
// Save the indirect & double indirect pointers
mov edx, es:[di+ HEX(58)] // Get indirect pointer
mov dword ptr [bp+Ext2InodeIndirectPointer], edx // Save indirect pointer
mov edx, es:[di+ HEX(5c)] // Get double indirect pointer
mov dword ptr [bp+Ext2InodeDoubleIndirectPointer],edx // Save double indirect pointer
// Now copy the direct pointers to 7000:0000
// so that we can call Ext2ReadDirectBlocks
push ds // Save DS
push es
push HEX(7000)
pop es
pop ds
mov si, HEX(8028)
xor di,di // DS:SI = 6000:8028 ES:DI = 7000:0000
mov cx,24 // Moving 24 words of data
rep movsw
pop ds // Restore DS
// Now we have all the block pointers in the
// right location so read them in
pop eax // Restore the total number of blocks in this file
xor ecx,ecx // Set the max count of blocks to read to 12
mov cl,12 // which is the number of direct block pointers in the inode
call Ext2ReadDirectBlockList
// Check to see if we actually have
// blocks left to read
cmp eax, 0
jz Ext2ReadEntireFileDone
// Now we have read all the direct blocks in
// the inode. So now we have to read the indirect
// block and read all it's direct blocks
push eax // Save the total block count
mov eax, dword ptr [bp+Ext2InodeIndirectPointer] // Get the indirect block pointer
push HEX(7000)
pop es
xor bx,bx // Set the load address to 7000:0000
call Ext2ReadBlock // Read the block
// Now we have all the block pointers from the
// indirect block in the right location so read them in
pop eax // Restore the total block count
mov ecx, dword ptr [bp+Ext2PointersPerBlock] // Get the number of block pointers that one block contains
call Ext2ReadDirectBlockList
// Check to see if we actually have
// blocks left to read
cmp eax, 0
jz Ext2ReadEntireFileDone
// Now we have read all the direct blocks from
// the inode's indirect block pointer. So now
// we have to read the double indirect block
// and read all it's indirect blocks
// (whew, it's a good thing I don't support triple indirect blocks)
mov dword ptr [bp+Ext2BlocksLeftToRead],eax // Save the total block count
mov eax, dword ptr [bp+Ext2InodeDoubleIndirectPointer] // Get the double indirect block pointer
push HEX(7800)
pop es
push es // Save an extra copy of this value on the stack
xor bx,bx // Set the load address to 7000:8000
call Ext2ReadBlock // Read the block
pop es // Put 7800h into ES (saved on the stack already)
xor di,di
Ext2ReadIndirectBlock:
mov eax, es:[di] // Get indirect block pointer
add di, 4 // Update DI for next array index
push es
push di
push HEX(7000)
pop es
xor bx,bx // Set the load address to 7000:0000
call Ext2ReadBlock // Read the indirect block
// Now we have all the block pointers from the
// indirect block in the right location so read them in
mov eax, dword ptr [bp+Ext2BlocksLeftToRead] // Restore the total block count
mov ecx, dword ptr [bp+Ext2PointersPerBlock] // Get the number of block pointers that one block contains
call Ext2ReadDirectBlockList
mov dword ptr [bp+Ext2BlocksLeftToRead],eax // Save the total block count
pop di
pop es
// Check to see if we actually have
// blocks left to read
cmp eax, 0
jnz Ext2ReadIndirectBlock
Ext2ReadEntireFileDone:
ret
// Reads a maximum number of blocks
// from an array at 7000:0000
// and updates the total count
// ECX contains the max number of blocks to read
// EAX contains the number of blocks left to read
// On return:
// EAX contains the new number of blocks left to read
Ext2ReadDirectBlockList:
cmp eax,ecx // Compare it to the maximum number of blocks to read
ja CallExt2ReadDirectBlocks // If it will take more blocks then just read all of the blocks
mov cx,ax // Otherwise adjust the block count accordingly
CallExt2ReadDirectBlocks:
sub eax,ecx // Subtract the number of blocks being read from the total count
push eax // Save the new total count
call Ext2ReadDirectBlocks
pop eax // Restore the total count
ret
// Reads a specified number of blocks
// from an array at 7000:0000
// CX contains the number of blocks to read
Ext2ReadDirectBlocks:
push HEX(7000)
pop es
xor di,di // Set ES:DI = 7000:0000
Ext2ReadDirectBlocksLoop:
mov eax,es:[di] // Get direct block pointer from array
add di, 4 // Update DI for next array index
push cx // Save number of direct blocks left
push es // Save array segment
push di // Save array offset
mov es,[bp+Ext2ReadEntireFileLoadSegment]
xor bx,bx // Setup load address for next read
call Ext2ReadBlock // Read the block (this updates ES for the next read)
mov [bp+Ext2ReadEntireFileLoadSegment],es // Save updated ES
pop di // Restore the array offset
pop es // Restore the array segment
pop cx // Restore the number of blocks left
loop Ext2ReadDirectBlocksLoop
// At this point all the direct blocks should
// be loaded and ES (Ext2ReadEntireFileLoadSegment)
// should be ready for the next read.
ret
// Displays a file not found error message
// And reboots
PrintFileNotFound:
mov si,msgFreeLdr // FreeLdr not found message
jmp short DisplayItAndReboot
// Displays a file size is 0 error
// And reboots
PrintFileSizeError:
mov si,msgFileSize // Error message
jmp short DisplayItAndReboot
// Displays a file is not a regular file error
// And reboots
PrintRegFileError:
mov si,msgRegFile // Error message
DisplayItAndReboot:
call PutChars // Display it
jmp Reboot
msgFreeLdr:
.ascii "freeldr.sys not found", NUL
msgFileSize:
.ascii "File size 0", NUL
msgRegFile:
.ascii "freeldr.sys isnt a regular file", NUL
filename:
.ascii "freeldr.sys"
msgLoading:
.ascii "Loading...", NUL
// times 1022-($-$$) db 0 // Pad to 1022 bytes
.org 1022
.word HEX(0aa55) // BootSector signature
.endcode16
END