mirror of
https://github.com/reactos/reactos.git
synced 2024-12-29 10:35:28 +00:00
273b6dd69f
Otherwise it uses the boot drive passed in the DL register. Updated the EXT2/3 installer to reflect the changes in the boot sector code for EXT2/3. svn path=/trunk/; revision=4540
663 lines
21 KiB
NASM
663 lines
21 KiB
NASM
; 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
|
|
|
|
SECTORS_PER_TRACK equ 0x04
|
|
NUMBER_OF_HEADS equ 0x08
|
|
BIOS_CHS_DRIVE_SIZE equ 0x0C
|
|
LBA_SECTORS_READ equ 0x10
|
|
|
|
|
|
EXT2_ROOT_INO equ 2
|
|
EXT2_S_IFMT equ 0f0h
|
|
EXT2_S_IFREG equ 080h
|
|
|
|
|
|
org 7c00h
|
|
|
|
segment .text
|
|
|
|
bits 16
|
|
|
|
start:
|
|
jmp short main
|
|
nop
|
|
|
|
BootDrive db 0x80
|
|
;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 dd 263088 ; Start sector of the ext2 volume
|
|
Ext2BlockSize dd 2 ; Block size in sectors
|
|
Ext2BlockSizeInBytes dd 1024 ; Block size in bytes
|
|
Ext2PointersPerBlock dd 256 ; Number of block pointers that can be contained in one block
|
|
Ext2GroupDescPerBlock dd 32 ; Number of group descriptors per block
|
|
Ext2FirstDataBlock dd 1 ; First data block (1 for 1024-byte blocks, 0 for bigger sizes)
|
|
Ext2InodesPerGroup dd 2048 ; Number of inodes per group
|
|
Ext2InodesPerBlock dd 8 ; Number of inodes per block
|
|
|
|
Ext2ReadEntireFileLoadSegment:
|
|
dw 0
|
|
Ext2InodeIndirectPointer:
|
|
dd 0
|
|
Ext2InodeDoubleIndirectPointer:
|
|
dd 0
|
|
Ext2BlocksLeftToRead:
|
|
dd 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,7c00h
|
|
mov sp,7b00h ; Setup a stack
|
|
|
|
|
|
cmp BYTE [BYTE bp+BootDrive],BYTE 0xff ; If they have specified a boot drive then use it
|
|
jne GetDriveParameters
|
|
|
|
mov [BYTE bp+BootDrive],dl ; Save the boot drive
|
|
|
|
|
|
GetDriveParameters:
|
|
mov ah,08h
|
|
mov dl,[BYTE bp+BootDrive] ; Get boot drive in dl
|
|
int 13h ; 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,0ffffh
|
|
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,3fh ; 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 [BYTE bp-NUMBER_OF_HEADS],eax ; Save number of heads
|
|
mov [BYTE 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 [BYTE 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,7e00h ; 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 [BYTE bp+Ext2GroupDescPerBlock] ; Group = (Group / Ext2GroupDescPerBlock)
|
|
add eax,DWORD [BYTE 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,78000h
|
|
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 [BYTE 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 [BYTE bp+Ext2InodesPerGroup] ; Inode = (Inode / Ext2InodesPerGroup)
|
|
mov ebx,eax ; EBX now has the inode group number
|
|
mov eax,edx
|
|
xor edx,edx
|
|
div DWORD [BYTE 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 WORD 7000h
|
|
pop es
|
|
mov di,8008h
|
|
pop eax ; Restore inode offset block number from stack
|
|
add eax,DWORD [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,68000h
|
|
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 [BYTE bp+Ext2VolumeStartSector] ; Add the start of the volume
|
|
cmp eax,DWORD [BYTE 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,0x41 ; AH = 41h
|
|
mov bx,0x55aa ; BX = 55AAh
|
|
mov dl,[BYTE bp+BootDrive] ; DL = drive (80h-FFh)
|
|
int 13h ; IBM/MS INT 13 Extensions - INSTALLATION CHECK
|
|
jc ReadSectorsCHS ; CF set on error (extensions not supported)
|
|
cmp bx,0xaa55 ; 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,byte 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 [BYTE bp-LBA_SECTORS_READ],cx
|
|
mov WORD [BYTE bp-LBA_SECTORS_READ+2],0
|
|
o32 push byte 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 byte 0x10 ; Set size of packet to 10h
|
|
mov si,sp ; Setup disk address packet on stack
|
|
|
|
|
|
mov dl,[BYTE bp+BootDrive] ; Drive number
|
|
mov ah,42h ; Int 13h, AH = 42h - Extended Read
|
|
int 13h ; Call BIOS
|
|
jc PrintDiskError ; If the read failed then abort
|
|
|
|
add sp,byte 0x10 ; Remove disk address packet from stack
|
|
|
|
popad ; Restore sector count & logical sector number
|
|
|
|
push bx
|
|
mov ebx,DWORD [BYTE 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,[BYTE 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,DWORD [BYTE 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 [BYTE bp-NUMBER_OF_HEADS] ; Divide logical by number of heads
|
|
mov dh,dl ; Head in DH
|
|
mov dl,[BYTE 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,0201h
|
|
int 13h ; 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,byte 20h ; 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 16h ; Wait for a keypress
|
|
int 19h ; Reboot
|
|
|
|
PutChars:
|
|
lodsb
|
|
or al,al
|
|
jz short Done
|
|
call PutCharsCallBios
|
|
jmp short PutChars
|
|
PutCharsCallBios:
|
|
mov ah,0eh
|
|
mov bx,07h
|
|
int 10h
|
|
retn
|
|
Done:
|
|
mov al,0dh
|
|
call PutCharsCallBios
|
|
mov al,0ah
|
|
call PutCharsCallBios
|
|
retn
|
|
|
|
|
|
|
|
msgDiskError db 'Disk error',0
|
|
; Sorry, need the space...
|
|
;msgAnyKey db 'Press any key to restart',0
|
|
msgAnyKey db 'Press any key',0
|
|
|
|
times 509-($-$$) db 0 ; Pad to 509 bytes
|
|
|
|
BootPartition db 0
|
|
|
|
dw 0aa55h ; 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 WORD 6000h
|
|
pop es
|
|
mov di,8000h
|
|
push di
|
|
push es ; Save these for later
|
|
|
|
; Get root directory size from inode structure
|
|
mov eax,DWORD [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,8000h ; 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,byte 8 ; Add the offset to the filename
|
|
mov si,filename
|
|
mov cl,11
|
|
rep 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 [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 bp+BootDrive]
|
|
mov dh,[BYTE bp+BootPartition]
|
|
push byte 0 ; We loaded at 0000:8000
|
|
push WORD 8000h ; We will do a far return to 0000:8000h
|
|
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 [BYTE bp+Ext2ReadEntireFileLoadSegment],800h
|
|
|
|
; 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 [BYTE bp+Ext2BlockSizeInBytes] ; Get the block size in bytes
|
|
push eax
|
|
dec eax ; Ext2BlockSizeInBytes -= 1
|
|
add eax,DWORD [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,byte 0
|
|
jnz Ext2ReadEntireFile2
|
|
jmp PrintFileSizeError
|
|
|
|
Ext2ReadEntireFile2:
|
|
; Save the indirect & double indirect pointers
|
|
mov edx,DWORD [es:di+0x58] ; Get indirect pointer
|
|
mov [BYTE bp+Ext2InodeIndirectPointer],edx ; Save indirect pointer
|
|
mov edx,DWORD [es:di+0x5c] ; Get double indirect pointer
|
|
mov [BYTE 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 WORD 7000h
|
|
pop es
|
|
pop ds
|
|
mov si,8028h
|
|
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,byte 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 [BYTE bp+Ext2InodeIndirectPointer] ; Get the indirect block pointer
|
|
push WORD 7000h
|
|
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 [BYTE 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,byte 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 [BYTE bp+Ext2BlocksLeftToRead],eax ; Save the total block count
|
|
mov eax,DWORD [BYTE bp+Ext2InodeDoubleIndirectPointer] ; Get the double indirect block pointer
|
|
push WORD 7800h
|
|
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,DWORD [es:di] ; Get indirect block pointer
|
|
add di,BYTE 4 ; Update DI for next array index
|
|
push es
|
|
push di
|
|
|
|
push WORD 7000h
|
|
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 [BYTE bp+Ext2BlocksLeftToRead] ; Restore the total block count
|
|
mov ecx,DWORD [BYTE bp+Ext2PointersPerBlock] ; Get the number of block pointers that one block contains
|
|
call Ext2ReadDirectBlockList
|
|
mov [BYTE 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,byte 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 contians 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 WORD 7000h
|
|
pop es
|
|
xor di,di ; Set ES:DI = 7000:0000
|
|
|
|
Ext2ReadDirectBlocksLoop:
|
|
mov eax,[es:di] ; Get direct block pointer from array
|
|
add di,BYTE 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,[BYTE bp+Ext2ReadEntireFileLoadSegment]
|
|
xor bx,bx ; Setup load address for next read
|
|
|
|
call Ext2ReadBlock ; Read the block (this updates ES for the next read)
|
|
|
|
mov [BYTE 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 db 'freeldr.sys not found',0
|
|
msgFileSize db 'File size is 0',0
|
|
msgRegFile db 'freeldr.sys isnt a regular file',0
|
|
filename db 'freeldr.sys'
|
|
msgLoading db 'Loading FreeLoader...',0
|
|
|
|
times 1022-($-$$) db 0 ; Pad to 1022 bytes
|
|
|
|
dw 0aa55h ; BootSector signature
|