Author: tkreuzer
Date: Sun Oct 2 15:33:39 2011
New Revision: 53928
URL: http://svn.reactos.org/svn/reactos?rev=53928&view=rev
Log:
[EXT2]
Convert comments to preprocessor format
Modified:
trunk/reactos/boot/freeldr/bootsect/ext2.S
Modified: trunk/reactos/boot/freeldr/bootsect/ext2.S
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/bootsect/ext2.S?rev=53928&r1=53927&r2=53928&view=diff
==============================================================================
--- trunk/reactos/boot/freeldr/bootsect/ext2.S [iso-8859-1] (original)
+++ trunk/reactos/boot/freeldr/bootsect/ext2.S [iso-8859-1] Sun Oct 2 15:33:39
2011
@@ -1,11 +1,11 @@
-; 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
+// 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
@@ -29,20 +29,20 @@
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
+//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
@@ -54,83 +54,83 @@
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
+ 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
+ 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
+ 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 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
+ // 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
+ // 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]
+ 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
+// 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 */)
+ 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
+ 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
@@ -138,51 +138,51 @@
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
+ // 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
+// 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
+ 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
+ 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
+ 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
+ // 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
+ 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
@@ -193,131 +193,131 @@
ret
-; Reads logical sectors into [ES:BX]
-; EAX has logical sector number to read
-; CX has number of sectors to read
+// 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
+ 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
+ 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
+ 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 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
+ add eax,ebx //
Increment sector to read
shl ebx,5
mov dx,es
- add dx,bx
; Setup read buffer for next sector
+ 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
+ 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
+// 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
+ 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
+ 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
+ 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
+ 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
+ inc eax
// Increment Sector to Read
mov dx,es
- add dx,byte 20h
; Increment read buffer for next sector
+ 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
+ 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
+ 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
+ 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
@@ -340,318 +340,318 @@
msgDiskError db 'Disk error',0
-; Sorry, need the space...
-;msgAnyKey db 'Press any key to restart',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
+ 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
+ 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
+ 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
+ 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
+ // 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
+ // 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
+ 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
+ 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
+ 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
+ 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
+ rep cmpsb //
Compare the file names
pop di
pop eax
pop edx
jz FoundFile
- ; Nope, didn't find it in this entry, keep looking
+ // 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
+ // 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
+ 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 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 0 ; push segment
(0x0000)
- mov eax, [0x8000 + 0xA8] ; load the RVA of the
EntryPoint into eax
- add eax, 0x8000 ; 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.
+ push 0 // push segment
(0x0000)
+ mov eax, [0x8000 + 0xA8] // load the RVA of the
EntryPoint into eax
+ add eax, 0x8000 // 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
+ // 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
+ // 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
+ 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
+ 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
+ // 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
+ // 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
+ 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
+ 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
+ // 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
+ // 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
+ 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
+ // 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
+ // 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)
+ 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
+ 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
+ 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
+ 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
+ // 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
+// 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
+ 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
+ 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
+ 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
+// 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
+ 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 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
+ 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.
+ // 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
+// Displays a file not found error message
+// And reboots
PrintFileNotFound:
- mov si,msgFreeLdr ; FreeLdr not found message
+ mov si,msgFreeLdr // FreeLdr not found message
jmp short DisplayItAndReboot
-; Displays a file size is 0 error
-; And reboots
+// Displays a file size is 0 error
+// And reboots
PrintFileSizeError:
- mov si,msgFileSize ; Error message
+ mov si,msgFileSize // Error message
jmp short DisplayItAndReboot
-; Displays a file is not a regular file error
-; And reboots
+// Displays a file is not a regular file error
+// And reboots
PrintRegFileError:
- mov si,msgRegFile ; Error message
+ mov si,msgRegFile // Error message
DisplayItAndReboot:
- call PutChars ; Display it
+ call PutChars // Display it
jmp Reboot
msgFreeLdr db 'freeldr.sys not found',0
@@ -660,6 +660,6 @@
filename db 'freeldr.sys'
msgLoading db 'Loading FreeLoader...',0
- times 1022-($-$$) db 0 ; Pad to 1022 bytes
-
- dw 0aa55h ; BootSector signature
+ times 1022-($-$$) db 0 // Pad to 1022 bytes
+
+ dw 0aa55h // BootSector signature
