Author: tkreuzer
Date: Sun Oct 2 15:47:52 2011
New Revision: 53930
URL: http://svn.reactos.org/svn/reactos?rev=53930&view=rev
Log:
[EXT2]
- Use HEX() macro
- remove BYTE modifiers
- [es:di] -> es:[di]
- equ -> =
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=53930&r1=53929&r2=53930&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:47:52
2011
@@ -7,15 +7,15 @@
// [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
+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
@@ -28,7 +28,7 @@
jmp short main
nop
-BootDrive db 0x80
+BootDrive db 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]
@@ -58,26 +58,26 @@
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 bp, HEX(7c00)
+ mov sp, HEX(7b00) // Setup a stack
+
+
+ cmp byte ptr [bp+BootDrive], HEX(0ff) // If they have
specified a boot drive then use it
jne GetDriveParameters
- mov [BYTE bp+BootDrive],dl // Save the
boot drive
+ mov [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
+ mov dl,[bp+BootDrive] // 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,0ffffh
+ mov cx, HEX(0ffff)
mov dh,cl
CalcDriveSize:
@@ -86,21 +86,21 @@
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
+ 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 [BYTE bp-NUMBER_OF_HEADS],eax // Save number
of heads
- mov [BYTE bp-SECTORS_PER_TRACK],ecx // Save number of
sectors per track
+ 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 [BYTE bp-BIOS_CHS_DRIVE_SIZE],eax
+ mov [bp-BIOS_CHS_DRIVE_SIZE],eax
LoadExtraBootCode:
@@ -110,7 +110,7 @@
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]
+ mov bx, HEX(7e00)
// Read sector to [0000:7e00h]
call ReadSectors
jmp LoadRootDirectory
@@ -124,14 +124,14 @@
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
+ div dword ptr [bp+Ext2GroupDescPerBlock] //
Group = (Group / Ext2GroupDescPerBlock)
+ add eax, [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
+ mov ebx, HEX(78000)
sub ebx,edx
shr ebx,4
mov es,bx
@@ -145,7 +145,7 @@
// Reads ext2 block into [ES:BX]
// EAX has logical block number to read
Ext2ReadBlock:
- mov ecx,DWORD [BYTE bp+Ext2BlockSize]
+ mov ecx, [bp+Ext2BlockSize]
mul ecx
jmp ReadSectors
@@ -156,11 +156,11 @@
Ext2ReadInode:
dec eax
// Inode = Inode - 1
xor edx,edx
- div DWORD [BYTE bp+Ext2InodesPerGroup] //
Inode = (Inode / Ext2InodesPerGroup)
+ 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 [BYTE bp+Ext2InodesPerBlock] //
Inode = (Inode / Ext2InodesPerBlock)
+ 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
@@ -174,16 +174,16 @@
// Group descriptor has been read, now
// grab the inode table block number from it
- push WORD 7000h
+ push HEX(7000)
pop es
- mov di,8008h
+ mov di, HEX(8008)
pop eax
// Restore inode offset block number from stack
- add eax,DWORD [es:di]
// Add the inode table start block
+ 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,68000h
+ mov ebx, HEX(68000)
sub ebx,edx
shr ebx,4
mov es,bx
@@ -197,8 +197,8 @@
// 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
+ add eax, [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
@@ -206,12 +206,12 @@
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
+ mov ah, HEX(41)
// AH = 41h
+ mov bx, HEX(55aa)
// BX = 55AAh
+ mov dl,[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,0xaa55
// BX = AA55h if installed
+ 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
@@ -221,33 +221,33 @@
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
+ 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 [BYTE bp-LBA_SECTORS_READ],cx
- mov WORD [BYTE bp-LBA_SECTORS_READ+2],0
- o32 push byte 0
+ mov [bp-LBA_SECTORS_READ],cx
+ mov word ptr [bp-LBA_SECTORS_READ+2],0
+ o32 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 byte 0x10
// Set size of packet to 10h
+ push 16
// Set size of packet to 10h
mov si,sp
// Setup disk address packet on stack
- mov dl,[BYTE bp+BootDrive] // Drive number
+ mov dl, [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
+ add sp, 16
// Remove disk address packet from stack
popad
// Restore sector count & logical sector number
push bx
- mov ebx,DWORD [BYTE bp-LBA_SECTORS_READ]
+ mov ebx,DWORD [bp-LBA_SECTORS_READ]
add eax,ebx //
Increment sector to read
shl ebx,5
mov dx,es
@@ -255,7 +255,7 @@
mov es,dx
pop bx
- sub cx,[BYTE bp-LBA_SECTORS_READ]
+ sub cx,[bp-LBA_SECTORS_READ]
jnz ReadSectorsLBA // Read
next sector
ret
@@ -270,21 +270,21 @@
ReadSectorsCHSLoop:
pushad
xor edx,edx
- mov ecx,DWORD [BYTE bp-SECTORS_PER_TRACK]
+ mov ecx,DWORD [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
+ div WORD [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 dl,[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
+ 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
@@ -296,7 +296,7 @@
inc eax
// Increment Sector to Read
mov dx,es
- add dx,byte 20h
// Increment read buffer for next sector
+ add dx, HEX(20)
// Increment read buffer for next sector
mov es,dx
loop ReadSectorsCHSLoop // Read
next sector
@@ -351,7 +351,7 @@
BootPartition:
db 0
- dw 0aa55h // BootSector signature
+ dw HEX(0aa55) // BootSector signature
// End of bootsector
@@ -367,14 +367,14 @@
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 WORD 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,DWORD [es:di+4]
+ mov eax, [es:di+4]
push eax
// Now that the inode has been read in load
@@ -384,7 +384,7 @@
// 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
+ 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:
@@ -400,17 +400,17 @@
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
+ add di, 8 // Add the
offset to the filename
mov si,filename
mov cl,11
- rep cmpsb //
Compare the file names
+ 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 [es:di+4]
+ movzx ecx,word ptr [es:di+4]
add edx,ecx
// Check to see if we have reached the
@@ -439,11 +439,11 @@
call Ext2ReadEntireFile // Read freeldr.sys to
0000:8000
- mov dl,[BYTE bp+BootDrive]
- mov dh,[BYTE bp+BootPartition]
+ mov dl,[bp+BootDrive]
+ mov dh,[bp+BootPartition]
push 0 // push segment
(0x0000)
- mov eax, [0x8000 + 0xA8] // load the RVA of the
EntryPoint into eax
- add eax, 0x8000 // RVA -> VA
+ 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
@@ -463,17 +463,17 @@
Ext2ReadEntireFile:
// Reset the load segment
- mov WORD [BYTE bp+Ext2ReadEntireFileLoadSegment],800h
+ 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 [BYTE bp+Ext2BlockSizeInBytes] // Get
the block size in bytes
+ mov eax,DWORD [bp+Ext2BlockSizeInBytes] // Get
the block size in bytes
push eax
dec eax
// Ext2BlockSizeInBytes -= 1
- add eax,DWORD [es:di+4]
// Add the file size
+ 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
@@ -486,19 +486,19 @@
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
+ mov edx,DWORD [es:di+ HEX(58)]
// Get indirect pointer
+ mov [bp+Ext2InodeIndirectPointer],edx // Save
indirect pointer
+ mov edx,DWORD [es:di+ HEX(5c)]
// Get double indirect pointer
+ mov [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
+ push WORD HEX(7000)
pop es
pop ds
- mov si,8028h
+ 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
@@ -521,7 +521,7 @@
// 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
+ push WORD HEX(7000)
pop es
xor bx,bx
// Set the load address to 7000:0000
call Ext2ReadBlock
// Read the block
@@ -534,7 +534,7 @@
// Check to see if we actually have
// blocks left to read
- cmp eax,byte 0
+ cmp eax, 0
jz Ext2ReadEntireFileDone
// Now we have read all the direct blocks from
@@ -542,9 +542,9 @@
// 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
+ mov [bp+Ext2BlocksLeftToRead],eax
// Save the total block count
+ mov eax,DWORD [bp+Ext2InodeDoubleIndirectPointer] // Get
the double indirect block pointer
+ push WORD 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
@@ -559,17 +559,17 @@
push es
push di
- push WORD 7000h
+ push WORD 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 [BYTE bp+Ext2BlocksLeftToRead] //
Restore the total block count
- mov ecx,DWORD [BYTE bp+Ext2PointersPerBlock] // Get
the number of block pointers that one block contains
+ mov eax,DWORD [bp+Ext2BlocksLeftToRead] //
Restore the total block count
+ mov ecx,DWORD [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 [bp+Ext2BlocksLeftToRead],eax
// Save the total block count
pop di
pop es
@@ -606,23 +606,23 @@
// CX contains the number of blocks to read
Ext2ReadDirectBlocks:
- push WORD 7000h
+ push WORD 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,BYTE 4
// Update DI for next array index
+ 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,[BYTE bp+Ext2ReadEntireFileLoadSegment]
+ 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 [BYTE bp+Ext2ReadEntireFileLoadSegment],es // Save
updated ES
+ mov [bp+Ext2ReadEntireFileLoadSegment],es // Save
updated ES
pop di
// Restore the array offset
pop es
// Restore the array segment
@@ -670,4 +670,4 @@
times 1022-($-$$) db 0 // Pad to 1022 bytes
- dw 0aa55h // BootSector signature
+ dw HEX(0aa55) // BootSector signature
