[ros-diffs] [pschweitzer] 70426: [BOOTSECT] fatx.S isn't for the FATX filesystem, it's just a generic naming, so pick up the next variable

Author: pschweitzer
Date: Sat Dec 26 17:44:07 2015
New Revision: 70426

URL: http://svn.reactos.org/svn/reactos?rev=70426&view=rev
Log:
[BOOTSECT]
fatx.S isn't for the FATX filesystem, it's just a generic naming, so pick up the
next variable

Added:
    trunk/reactos/boot/freeldr/bootsect/faty.S
      - copied unchanged from r70425, trunk/reactos/boot/freeldr/bootsect/fatx.S
Removed:
    trunk/reactos/boot/freeldr/bootsect/fatx.S
Modified:
    trunk/reactos/boot/freeldr/bootsect/CMakeLists.txt

Modified: trunk/reactos/boot/freeldr/bootsect/CMakeLists.txt
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/bootsect/CMak…
==============================================================================
--- trunk/reactos/boot/freeldr/bootsect/CMakeLists.txt	[iso-8859-1] (original)
+++ trunk/reactos/boot/freeldr/bootsect/CMakeLists.txt	[iso-8859-1] Sat Dec 26 17:44:07
2015
@@ -7,15 +7,15 @@
     CreateBootSectorTarget(fat ${CMAKE_CURRENT_SOURCE_DIR}/fat.S
${CMAKE_CURRENT_BINARY_DIR}/fat.bin 7c00)
     CreateBootSectorTarget(fat32 ${CMAKE_CURRENT_SOURCE_DIR}/fat32.S
${CMAKE_CURRENT_BINARY_DIR}/fat32.bin 7c00)
 
-    ## New versions using FATX.S (experimental)
+    ## New versions using FATY.S (experimental)
     # add_definitions(-DFAT12)
-    # CreateBootSectorTarget(fat_new ${CMAKE_CURRENT_SOURCE_DIR}/fatx.S
${CMAKE_CURRENT_BINARY_DIR}/fat_new.bin 7c00)
+    # CreateBootSectorTarget(fat_new ${CMAKE_CURRENT_SOURCE_DIR}/faty.S
${CMAKE_CURRENT_BINARY_DIR}/fat_new.bin 7c00)
     # remove_definitions(-DFAT12)
     # add_definitions(-DFAT16)
-    # CreateBootSectorTarget(fat16_new ${CMAKE_CURRENT_SOURCE_DIR}/fatx.S
${CMAKE_CURRENT_BINARY_DIR}/fat16_new.bin 7c00)
+    # CreateBootSectorTarget(fat16_new ${CMAKE_CURRENT_SOURCE_DIR}/faty.S
${CMAKE_CURRENT_BINARY_DIR}/fat16_new.bin 7c00)
     # remove_definitions(-DFAT16)
     # add_definitions(-DFAT32)
-    # CreateBootSectorTarget(fat32_new ${CMAKE_CURRENT_SOURCE_DIR}/fatx.S
${CMAKE_CURRENT_BINARY_DIR}/fat32_new.bin 7c00)
+    # CreateBootSectorTarget(fat32_new ${CMAKE_CURRENT_SOURCE_DIR}/faty.S
${CMAKE_CURRENT_BINARY_DIR}/fat32_new.bin 7c00)
     # remove_definitions(-DFAT32)
 
     CreateBootSectorTarget(isoboot ${CMAKE_CURRENT_SOURCE_DIR}/isoboot.S
${CMAKE_CURRENT_BINARY_DIR}/isoboot.bin 7000)

Removed: trunk/reactos/boot/freeldr/bootsect/fatx.S
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/bootsect/fatx…
==============================================================================
--- trunk/reactos/boot/freeldr/bootsect/fatx.S	[iso-8859-1] (original)
+++ trunk/reactos/boot/freeldr/bootsect/fatx.S	(removed)
@@ -1,589 +0,0 @@
-/*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS Bootsector
- * FILE:            boot/freeldr/bootsect/fatx.S
- * PURPOSE:         Combined FAT16 and FAT32 boot sector
- * PROGRAMMERS:     Brian Palmer
- *                  Timo Kreuzer
- */
-
-#define DISKREADBUFFER HEX(8E000)
-
-/*
- * Layout of a FAT volume:
- *
- * |---------------------------------------------------------
- * | * BootSector                         |
- * | * FS Information Sector (FAT32 only) | ReservedSectors
- * | * ... more reserved sectors ...      |
- * |--------------------------------------------------------
- * | * FAT 1                              | NumberOfFats
- * | * FAT 2                              |      *
- * | * [more FATs]                        | SectorsPerFat
- * |---------------------------------------------------------
- * | * Root Directory (FAT12/FAT16 only)  | MaxRootEntries / 16
- * |---------------------------------------------------------
- * | * File data                          |
- * | ....                                 |
- * |----------------------------------------
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <asm.inc>
-#include <freeldr/include/arch/pc/x86common.h>
-
-#define ADDRESS_FOR_DIRENTRIES HEX(10000)
-
-SizeOfDataArea        = 32
-
-/* Put the stack below the data area */
-BootSectorStackTop    = (HEX(7c00) - SizeOfDataArea)
-
-/* Data area offsets for uninitialized data */
-DataAreaStart         = BootSectorStackTop + 0  /* dword */
-#ifndef FAT32
-RootDirStartSector    = BootSectorStackTop + 4  /* dword */
-#endif
-BiosCHSDriveSize      = BootSectorStackTop + 8  /* dword */
-LBASectorsRead        = BootSectorStackTop + 12 /* dword */
-ReadSectorsOffset     = BootSectorStackTop + 16 /* word */
-ReadClusterOffset     = BootSectorStackTop + 18 /* word */
-PutCharsOffset        = BootSectorStackTop + 20 /* word */
-
-/* Macro for bp relative memory access to reduce code size */
-#define BP_REL(x) ss:[bp + x - BootSectorStackTop]
-
-/* The code starts at 0x7c00 */
-// org 7c00h
-
-.code16
-
-/******************************************************************************
- *                      BIOS Parameter Block (BPB)                            *
- ******************************************************************************/
-/* We have 3 bytes at the entry point to jump over the data area */
-start:
-    jmp short main // FIXME: When compiling FAT32, assembler will complain
-                   // that the label is too far... Need investigation!
-    nop
-
-/* Here starts the BIOS Parameter Block (BPB) data.
-   The real data will be copied during install */
-OEMName:
-    .ascii "FrLdr1.0"
-BytesPerSector:
-    .word 512
-SectorsPerCluster:
-    .byte 0
-ReservedSectors:
-    .word 32
-NumberOfFats:
-    .byte 2
-MaxRootEntries:
-    .word 0            // Always zero for FAT32 volumes
-TotalSectors:
-    .word 0            // Always zero for FAT32 volumes
-MediaDescriptor:
-    .byte HEX(0f8)
-SectorsPerFat:
-    .word 0            // Always zero for FAT32 volumes
-SectorsPerTrack:
-    .word 0
-NumberOfHeads:
-    .word 0
-HiddenSectors:
-    .long 0
-TotalSectorsBig:
-    .long 0
-
-/* Extra data for FAT32 volumes */
-#ifdef FAT32
-SectorsPerFatBig:
-    .long    0
-ExtendedFlags:
-    .word    0
-FSVersion:
-    .word    0
-RootDirStartCluster:
-    .long    0
-FSInfoSector:
-    .word    0
-BackupBootSector:
-    .word    6
-Reserved1:
-    .byte 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-#endif // FAT32
-
-BootDrive:
-    .byte 0
-Reserved:
-    .byte 0
-ExtendSig:
-    .byte HEX(29)
-SerialNumber:
-    .long 0
-VolumeLabel:
-    .ascii "NO NAME    "
-FileSystem:
-    .ascii "FATxx   "
-
-
-/******************************************************************************
- *                             String data                                    *
- ******************************************************************************/
-
-filename:
-    .ascii "FREELDR SYS"
-
-msgBootFailure:
-    .ascii "Load failed!", CR, LF, NUL
-
-msgAnyKey:
-    .ascii "Press any key to reboot...", NUL
-
-
-/******************************************************************************
- *                           Main code entry                                  *
- * Input: DL = Boot drive                                                     *
- ******************************************************************************/
-main:
-    /* First setup the segment registers */
-    xor ax, ax
-    mov ds, ax
-    mov ss, ax
-
-    /* Load the stack pointer */
-    mov sp, BootSectorStackTop
-
-    /* Load bp for relative memory access, which saves us some bytes of code
-       size, when used with 32 bit instructions */
-    mov bp, sp
-
-    /* Load the boot drive from the BPB into al */
-    mov al, byte ptr ds:[BootDrive]
-
-    /* Check if it's valid */
-    cmp al, HEX(0ff)
-    je .SaveBootDrive
-
-    /* Copy it into dl */
-    mov dl, al
-
-.SaveBootDrive:
-    /* Save the bootdrive in the BPB */
-    mov byte ptr ds:[BootDrive], dl
-
-
-/******************************************************************************
- *                        Get drive parameters                                *
- ******************************************************************************/
-
-    /* Call INT 13 to get the drive parameters:
-       AH = 08h
-       DL = drive (bit 7 set for hard disk)
-       ES:DI = 0000h:0000h to guard against BIOS bugs */
-    xor di, di
-    mov ah, 8
-    int HEX(13)
-
-    /* Return from INT 13h/08h:
-        CF set on error -> AH = status (07h)
-        CF clear if successful -> AH = 00h
-        AL = 00h on at least some BIOSes
-        BL = drive type (AT/PS2 floppies only)
-        CH = low eight bits of maximum cylinder number
-        CL = bits 0:5 maximum sector number, bits 7:8 high two bits of maximum cylinder
number
-        DH = maximum head number
-        DL = number of drives
-        ES:DI -> drive parameter table (floppies only) */
-
-    /* Check for failure */
-    jc BootFailure
-
-
-/******************************************************************************
- *                         Calculate drive size                               *
- ******************************************************************************/
-
-    movzx ebx, ch           // Put the low 8-bits of the cylinder count into EBX
-    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
-    movzx ecx, cl           // Move the sectors per track into ECX
-
-    movzx eax, dh           // Move the heads into EAX
-
-    inc eax                 // Make it one based because the bios returns it zero based
-    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 dword ptr BP_REL(BiosCHSDriveSize), eax
-
-
-/******************************************************************************
- *                             Load the FAT                                   *
- ******************************************************************************/
-
-    /* Load the number of first sector of the FAT into eax */
-    movzx eax, word ptr BP_REL(ReservedSectors)
-    add eax, dword ptr BP_REL(HiddenSectors)
-
-    /* Load sector count into ecx */
-#ifdef FAT32
-    mov ecx, dword ptr BP_REL(SectorsPerFatBig)
-#else
-    movzx ecx, word ptr BP_REL(SectorsPerFat)
-#endif
-
-    /* Save FAT sector and size for later use */
-    pushad
-
-    /* Point ES:DI to the memory that is later the disk read buffer for freeldr.
-       This way we cannot overwrite our FAT with freeldr data */
-    mov bx, DISKREADBUFFER / 16
-    mov es,bx
-    xor di, di
-
-    /* Read the sectors */
-    call ReadSectors
-
-    /* Restore FAT sector and size */
-    popad
-
-
-/******************************************************************************
- *                 Get root directory / data area start                       *
- ******************************************************************************/
-
-    /* Copy reserved + hidden sectors to EBX */
-    mov ebx, eax
-
-    /* Calculate (NumberOfFats * SectorsPerFat) */
-    movzx eax, byte ptr BP_REL(NumberOfFats)
-    mul ecx
-
-    /* Add reserved sectors and hidden sectors */
-    add eax, ebx
-
-#ifndef FAT32
-    /* Save the starting sector of the root directory */
-    mov dword ptr BP_REL(RootDirStartSector), eax
-
-    /* Calculate number of sectors for the root dir:
-       sectors = MaxRootEntries * 32 / 512 (rounded up!) */
-    movzx ebx, word ptr BP_REL(MaxRootEntries)
-    add ebx, 15
-    shr ebx, 4
-
-    /* Add the root dir start sector and save it as DataAreaStart */
-    add ebx, eax
-    mov dword ptr BP_REL(DataAreaStart), ebx
-#else
-    mov dword ptr BP_REL(DataAreaStart), eax
-
-    /* On FAT32 volumes the root dir start cluster is stored in the BPB */
-    mov eax, dword ptr BP_REL(RootDirStartCluster)
-#endif
-
-
-/******************************************************************************
- *                 Search the root directory for freeldr                      *
- ******************************************************************************/
-.SearchForFreeldr:
-
-    /* Load ES with the segment where we put the dir entries */
-    mov bx, ADDRESS_FOR_DIRENTRIES / 16
-    mov es, bx
-
-    /* Set the address offset to 0 */
-    xor di, di
-
-#ifdef FAT32
-    /* Read the dir cluster. This loads the next cluster into EAX */
-    call ReadCluster
-
-    /* Calculate the numer of dir entries in this cluster:
-       dx = SectorsPerCluster * 512 / 32 */
-    movzx dx, byte ptr ds:[SectorsPerCluster]
-    shl dx, 4
-#else
-    /* Set the number of sectors to read to 1 */
-    xor cx, cx
-    inc cx
-
-    /* Read the sector, but preserve ES */
-    push es
-    call ReadSectors
-    pop es
-
-    /* Set entry count to entries per sector */
-    mov dx, (512 / 32)
-#endif
-
-    /* Load the start offset of the dir entries into ebx */
-    xor bx, bx
-
-.CheckDirEntry:
-    /* Load the address of the name into di */
-    mov di, bx
-
-    /* If the first byte of the entry is 0 then we have reached the end */
-    cmp byte ptr es:[di], ch
-    jz BootFailure
-
-    /* Compare with freeldr file name */
-    mov si, offset filename
-    mov cx, 11
-    repe cmpsb
-
-    /* Check if we found the file */
-    jz .FoundFreeLoader
-
-    /* File didn't match, go to next entry */
-    add bx, 32
-
-    /* Decrement entry count and check if we reached the end */
-    dec dx
-    jnz .CheckDirEntry
-
-#ifdef FAT32
-    /* Check to see if this was the last cluster in the chain */
-    cmp eax, HEX(0ffffff8)
-    jnb BootFailure
-#endif
-
-    /* Repeat the search process with the next sector / cluster.
-       eax is already incremented in ReadSectors / ReadCluster */
-    jmp .SearchForFreeldr
-
-
-/******************************************************************************
- *                            Load freeldr                                    *
- ******************************************************************************/
-.FoundFreeLoader:
-
-    /* Load the cluster number of freeldr into eax */
-#ifdef FAT32
-#error unsupported
-#else
-    movzx eax, word ptr es:[bx + HEX(1A)]
-#endif
-
-    /* Load es:di with the freeldr start address */
-    mov dx, FREELDR_BASE / 16
-    mov es, dx
-    xor di, di
-
-.LoadNextCluster:
-    /* Load the cluster to the current address. EAX is adjusted to the next
-       cluster and ES is adjusted for the next read */
-    call ReadCluster
-
-    /* Check if this is the last cluster in the chain */
-#if defined(FAT32)
-    cmp eax, HEX(0ffffff8)
-#elif defined(FAT12)
-    cmp ax, HEX(0ff8)
-#else
-    cmp ax, HEX(0fff8)
-#endif
-    jb .LoadNextCluster
-
-    /* Load boot drive into DL, boot partition into DH */
-    mov  dl, byte ptr ds:[BootDrive]
-    mov  dh, byte ptr ds:[BootPartition]
-
-    /* Now the complete freeldr imag is loaded.
-       Jump to the realmode entry point. */
-    ljmp16 0, FREELDR_BASE
-
-
-
-BootFailure:
-    mov  si, offset msgBootFailure
-    call PutChars
-
-
-Reboot:
-    /* Output "Press any key to reboot" message */
-    mov  si, offset msgAnyKey
-    call PutChars
-
-    /* Wait for a keypress */
-    xor  ax, ax
-    int  HEX(16)
-
-    /* Reboot */
-    int  HEX(19)
-
-
-/******************************************************************************
- * PROCEDURE ReadCluster                                                      *
- * Input: EAX = Cluster number, ES:DI = Target                                *
- * Modifies: EAX (next cluster number), BX, DX (undefined)                    *
- ******************************************************************************/
-ReadCluster:
-
-    pushad
-
-    // StartSector = ((Cluster - 2) * SectorsPerCluster) + SectorsForFat +
ReservedSectors + HiddenSectors
-    // StartSector = ((Cluster - 2) * SectorsPerCluster) + DataAreaStart
-
-    /* Substract 2 */
-    dec eax
-    dec eax
-
-    /* Multiply with SectorsPerCluster */
-    movzx ecx, byte ptr BP_REL(SectorsPerCluster)
-    mul ecx
-
-    /* Add DataAreaStart */
-    add eax, dword ptr BP_REL(DataAreaStart)
-
-    /* Call ReadSectors. EAX = SectorNumber, ECX = SectorsPerCluster */
-    call ReadSectors
-
-    /* Restore the cluster number */
-    popad
-
-    /* Save ES */
-    push es
-
-#if defined(FAT32)
-#error FAT32 not implemented
-#elif defined(FAT12)
-#error FAT12 not implemented
-#else
-    /* DX:AX = AX * 2 (since FAT16 entries are 2 bytes) */
-    mov bx, 2
-    mul bx
-
-    /* Shift DX, so that it is the segment offset: DX = DX * (64K / 16) */
-    shl dx, 12
-
-    /* Put segment address of FAT into ES */
-    add dx, DISKREADBUFFER / 16
-    mov es, dx
-
-    /* Put the FAT entry offset into EBX for indirect mov */
-    mov bx, ax
-
-    /* Put the content of the FAT entry into AX */
-    mov ax, es:[bx]
-#endif
-
-    /* Restore ES and return */
-    pop  es
-    ret
-
-
-/******************************************************************************
- * PROCEDURE ReadSectors                                                      *
- * Input: EAX = Sector start number, ECX = number of sectors, ES:DI = Target  *
- * Modifies: EAX (incremented by sector count), CX = 0, ES (incremented),     *
- *           EBX undefined                                                    *
- ******************************************************************************/
-ReadSectors:
-    /* We could possibly also implement CHS, but it's currently unimplemented */
-//jmp $
-ReadSectorsLBA:
-
-    /* Copy number of sectors to ebx */
-    movzx ebx, cx
-
-    /* Since the LBA calls only support 0x7F sectors at a time,
-       we will limit ourselves to 64 */
-    cmp bx, 64
-    jbe .ReadSectorsLBA2
-    mov bx, 64
-
-.ReadSectorsLBA2:
-
-    /* Save logical sector number & sector count */
-    pushad
-
-    /* Setup the disk address packet on the stack */
-    .byte HEX(66) // size overwrite prefix for next push
-    push 0    // Put 64-bit logical block address (high part) on stack
-    push eax  // Put 64-bit logical block address (low part) on stack
-    push es   // Put transfer segment on stack
-    push di   // Put transfer offset on stack
-    push bx   // Set transfer count (for this round)
-    push 16   // Set size of packet to 16
-
-    /* Point si to the disk address packet on stack */
-    mov si, sp
-
-    /* Set the drive number */
-    mov dl, byte ptr ds:[BootDrive]
-//jmp $
-    /* Call INT 13h, AH = 42h - Extended Read
-       Input: ...
-       Modifies: ... */
-    mov ah, HEX(42)
-    int HEX(13)
-//jmp $
-    /* Check for failure */
-    jc BootFailure
-
-    /* Remove disk address packet from stack */
-    add sp, 16
-
-    /* Adjust ES to point to the next sector */
-    shl bx, 5
-    mov ax, es
-    add ax, bx
-    mov es, ax
-
-    /* Restore sector count & logical sector number */
-    popad
-
-    /* Adjust the sector number to the next sector we need to read
-       by adding the number of sectors that we read */
-    add eax, ebx
-
-    /* Adjust remaining sectors */
-    sub cx, bx
-    jnz ReadSectorsLBA
-
-    /* return */
-    ret
-
-
-
-/******************************************************************************
- * PROCEDURE PutChars                                                         *
- * Input: ESI = Points to string to be printed                                *
- * Modifies: AL, AH, SI                                                       *
- ******************************************************************************/
-PutChars2:
-    mov ah, HEX(0e)
-    mov bx, 7
-    int HEX(10)
-PutChars:
-    lodsb
-    or al, al
-    jnz short PutChars2
-    ret
-
-
-/******************************************************************************
- *               Padding and boot sector signature                            *
- ******************************************************************************/
-    /* Pad to 509 bytes */
-    .org 509
-
-BootPartition:
-    .byte 0
-
-BootSignature:
-    .word HEX(0aa55)   // BootSector signature
-
-.endcode16
-
-END