[FREELDR] Add a mechanism to determine the actual size of a mounted storage filesystem volume (reactos#8423)

CORE-14603

- Each filesystem exposes a `*GetVolumeSize()` routine that returns the
  volume size it claims it reports (this is based on data from FAT/NTFS
  BIOS Parameter Blocks, or EXTn/BTRFS superblocks, similarly to what
  their NT filesystem drivers do).

- Given a device ID corresponding to a mountable drive, a top-level
  `FsGetVolumeSize()` routine attempts to mount the corresponding filesystem.
  This may fail if the device is not a drive, or if the filesystem is
  not recognized. If it succeeds, then the per-filesytem `*GetVolumeSize()`
  is invoked and the corresponding volume size is returned.

Author: HBelusca

boot/freeldr/freeldr/include/fs.h

@@ -53,6 +53,11 @@ FsOpenFile(
     IN OPENMODE OpenMode,
     OUT PULONG FileId);
 
+ARC_STATUS
+FsGetVolumeSize(
+    _In_ ULONG DeviceId,
+    _Out_ PULONGLONG VolumeSize);
+
 ULONG FsGetNumPathParts(PCSTR Path);
 VOID  FsGetFirstNameFromPath(PCHAR Buffer, PCSTR Path);
 

boot/freeldr/freeldr/include/fs/btrfs.h

@@ -422,4 +422,8 @@ typedef struct {
     CHAR FileName[RTL_FIELD_SIZE(FILEINFORMATION, FileName)];
 } btrfs_file_info, *pbtrfs_file_info;
 
+ULONGLONG
+BtrFsGetVolumeSize(
+    _In_ ULONG DeviceId);
+
 const DEVVTBL* BtrFsMount(ULONG DeviceId);

boot/freeldr/freeldr/include/fs/ext.h

@@ -100,8 +100,20 @@ typedef struct _ExtSuperBlock
     UCHAR DefHashVersion;
     UCHAR JournalBackupType;
     USHORT GroupDescSize;
-    UCHAR Reserved[768];
+
+    ULONG DefaultMountOpts;
+    ULONG FirstMetaBg;
+    ULONG MkfsTime;
+    ULONG JnlBlocks[17];
+
+    /* 64bit support valid if EXT4_FEATURE_COMPAT_64BIT */
+    ULONG BlocksCountHi;
+    ULONG RBlocksCountHi;
+    ULONG FreeBlocksCountHi;
+
+    UCHAR Reserved[676];
 } EXT_SUPER_BLOCK, *PEXT_SUPER_BLOCK;
+C_ASSERT(sizeof(EXT_SUPER_BLOCK) == 0x400);
 
 typedef struct _ExtGroupDescriptor
 {
@@ -230,4 +242,8 @@ typedef struct _EXT_FILE_INFO
     CHAR FileName[RTL_FIELD_SIZE(FILEINFORMATION, FileName)];
 } EXT_FILE_INFO, *PEXT_FILE_INFO;
 
+ULONGLONG
+ExtGetVolumeSize(
+    _In_ ULONG DeviceId);
+
 const DEVVTBL* ExtMount(ULONG DeviceId);

boot/freeldr/freeldr/include/fs/fat.h

@@ -174,4 +174,8 @@ typedef struct _FAT_FILE_INFO
     CHAR FileName[RTL_FIELD_SIZE(FILEINFORMATION, FileName)];
 } FAT_FILE_INFO, *PFAT_FILE_INFO;
 
+ULONGLONG
+FatGetVolumeSize(
+    _In_ ULONG DeviceId);
+
 const DEVVTBL* FatMount(ULONG DeviceId);

boot/freeldr/freeldr/include/fs/iso.h

@@ -106,4 +106,8 @@ typedef struct _ISO_FILE_INFO
     CHAR FileName[RTL_FIELD_SIZE(FILEINFORMATION, FileName)];
 } ISO_FILE_INFO, *PISO_FILE_INFO;
 
+ULONGLONG
+IsoGetVolumeSize(
+    _In_ ULONG DeviceId);
+
 const DEVVTBL* IsoMount(ULONG DeviceId);

boot/freeldr/freeldr/include/fs/ntfs.h

@@ -258,4 +258,8 @@ typedef struct _NTFS_FILE_HANDLE
     CHAR FileName[RTL_FIELD_SIZE(FILEINFORMATION, FileName)];
 } NTFS_FILE_HANDLE, *PNTFS_FILE_HANDLE;
 
+ULONGLONG
+NtfsGetVolumeSize(
+    _In_ ULONG DeviceId);
+
 const DEVVTBL* NtfsMount(ULONG DeviceId);

boot/freeldr/freeldr/lib/fs/btrfs.c

@@ -1332,6 +1332,24 @@ ARC_STATUS BtrFsSeek(ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
     return ESUCCESS;
 }
 
+
+/**
+ * @brief
+ * Returns the size of the BTRFS volume laid on the storage media device
+ * opened via @p DeviceId.
+ **/
+ULONGLONG
+BtrFsGetVolumeSize(
+    _In_ ULONG DeviceId)
+{
+    PBTRFS_INFO Volume = BtrFsVolumes[DeviceId];
+    ASSERT(Volume);
+
+    /* NOTE: BytesPerSector is given by Volume->SuperBlock.sectorsize */
+    return Volume->SuperBlock.total_bytes;
+}
+
+
 const DEVVTBL BtrFsFuncTable =
 {
     BtrFsClose,

boot/freeldr/freeldr/lib/fs/ext.c

@@ -702,6 +702,13 @@ BOOLEAN ExtReadSuperBlock(PEXT_VOLUME_INFO Volume)
     TRACE("DefHashVersion: %d\n", SuperBlock->DefHashVersion);
     TRACE("JournalBackupType: %d\n", SuperBlock->JournalBackupType);
     TRACE("GroupDescSize: %d\n", SuperBlock->GroupDescSize);
+    TRACE("DefaultMountOpts: %d\n", SuperBlock->DefaultMountOpts);
+    TRACE("FirstMetaBg: %d\n", SuperBlock->FirstMetaBg);
+    TRACE("MkfsTime: %d\n", SuperBlock->MkfsTime);
+    // ULONG JnlBlocks[17];
+    TRACE("BlocksCountHi: %d\n", SuperBlock->BlocksCountHi);
+    TRACE("RBlocksCountHi: %d\n", SuperBlock->RBlocksCountHi);
+    TRACE("FreeBlocksCountHi: %d\n", SuperBlock->FreeBlocksCountHi);
 
     //
     // Check the super block magic
@@ -1387,6 +1394,30 @@ ARC_STATUS ExtSeek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode)
     return ESUCCESS;
 }
 
+
+/**
+ * @brief
+ * Returns the size of the EXT2/3/4 volume laid on the storage media device
+ * opened via @p DeviceId.
+ **/
+ULONGLONG
+ExtGetVolumeSize(
+    _In_ ULONG DeviceId)
+{
+    PEXT_VOLUME_INFO Volume;
+    ULARGE_INTEGER BlocksCount;
+
+    Volume = ExtVolumes[DeviceId];
+    ASSERT(Volume);
+
+    BlocksCount.LowPart  = Volume->SuperBlock->BlocksCountLo;
+    BlocksCount.HighPart = Volume->SuperBlock->BlocksCountHi;
+
+    /* NOTE: Volume->BlockSizeInBytes == Volume->BlockSizeInSectors * Volume->BytesPerSector */
+    return BlocksCount.QuadPart * Volume->BlockSizeInBytes;
+}
+
+
 const DEVVTBL ExtFuncTable =
 {
     ExtClose,

boot/freeldr/freeldr/lib/fs/fat.c

@@ -47,11 +47,13 @@ typedef struct _FAT_VOLUME_INFO
     ULONG RootDirSectors; /* Number of sectors of the root directory (non-fat32) */
     ULONG RootDirStartCluster; /* Starting cluster number of the root directory (fat32 only) */
     ULONG DataSectorStart; /* Starting sector of the data area */
+    // ULONG NumberOfClusters; /* Number of clusters of the data area */
     ULONG DeviceId;
+    ULONG TotalSectors; /* Total number of sectors on the volume */
     UINT16 BytesPerSector; /* Number of bytes per sector */
-    UINT8 FatType; /* FAT12, FAT16, FAT32, FATX16 or FATX32 */
-    UINT8 NumberOfFats; /* Number of FAT tables */
     UINT8 SectorsPerCluster; /* Number of sectors per cluster */
+    UINT8 NumberOfFats; /* Number of FAT tables */
+    UINT8 FatType; /* FAT12, FAT16, FAT32, FATX16 or FATX32 */
 } FAT_VOLUME_INFO;
 
 PFAT_VOLUME_INFO FatVolumes[MAX_FDS];
@@ -134,6 +136,27 @@ VOID FatSwapFatXDirEntry(PFATX_DIRENTRY Obj)
     SW(Obj, LastAccessDate);
 }
 
+/**
+ * @brief
+ * Returns the number of clusters of the data area of the FAT volume.
+ * This value is computed by taking the total sectors on the disk, subtracting
+ * up to the first file area sector, then dividing by the sectors per cluster count.
+ *
+ * @note
+ * Relies on the FAT_VOLUME_INFO fields already computed by FatOpenVolume().
+ *
+ * @see
+ * https://github.com/reactos/reactos/blob/435482912c6dc0aaa4371e37b7336b2b1291e65f/drivers/filesystems/fastfat/fat.h#L460
+ * https://github.com/reactos/reactos/blob/435482912c6dc0aaa4371e37b7336b2b1291e65f/drivers/filesystems/vfatfs/fsctl.c#L24
+ **/
+FORCEINLINE
+ULONG
+FatNumberOfClusters(
+    _In_ PFAT_VOLUME_INFO Volume)
+{
+    return ((Volume->TotalSectors - Volume->DataSectorStart) / Volume->SectorsPerCluster);
+}
+
 BOOLEAN FatOpenVolume(PFAT_VOLUME_INFO Volume, PFAT_BOOTSECTOR BootSector, ULONGLONG PartitionSectorCount)
 {
     char ErrMsg[80];
@@ -254,21 +277,38 @@ BOOLEAN FatOpenVolume(PFAT_VOLUME_INFO Volume, PFAT_BOOTSECTOR BootSector, ULONG
         return FALSE;
     }
 
-    //
-    // Get the sectors per FAT,
-    // root directory starting sector,
-    // and data sector start
-    //
     if (ISFATX(Volume->FatType))
     {
-        Volume->BytesPerSector = 512;
+        Volume->TotalSectors = PartitionSectorCount;
+    }
+    else
+    {
+        /*
+         * After DOS 4.0, at least one of TotalSectors or TotalSectorsBig will be zero.
+         * In DOS version 3.2 or before, both of these might contain some value,
+         * because, before 3.2, there was no TotalSectorsBig entry. Thus some disks
+         * might have an unexpected value in the field, and we will use TotalSectorsBig
+         * only if TotalSectors equals zero.
+         */
+        C_ASSERT(FIELD_OFFSET(FAT_BOOTSECTOR, TotalSectors) ==
+                 FIELD_OFFSET(FAT32_BOOTSECTOR, TotalSectors));
+        C_ASSERT(FIELD_OFFSET(FAT_BOOTSECTOR, TotalSectorsBig) ==
+                 FIELD_OFFSET(FAT32_BOOTSECTOR, TotalSectorsBig));
+        Volume->TotalSectors = (FatVolumeBootSector->TotalSectors ? FatVolumeBootSector->TotalSectors
+                                                                  : FatVolumeBootSector->TotalSectorsBig);
+    }
+
+    /* Get the sectors per FAT, root directory sector start, and data sector start */
+    if (ISFATX(Volume->FatType))
+    {
+        Volume->BytesPerSector = SECTOR_SIZE;
         Volume->SectorsPerCluster = SWAPD(FatXVolumeBootSector->SectorsPerCluster);
-        Volume->FatSectorStart = (0x1000 / Volume->BytesPerSector);
+        Volume->FatSectorStart = 4096 / Volume->BytesPerSector;
         Volume->ActiveFatSectorStart = Volume->FatSectorStart;
-        Volume->NumberOfFats = 1;
+        Volume->NumberOfFats = 1; // FatXVolumeBootSector->NumberOfFats;
         FatSize = (ULONG)(PartitionSectorCount / Volume->SectorsPerCluster *
                   (Volume->FatType == FATX16 ? 2 : 4));
-        Volume->SectorsPerFat = ROUND_UP(FatSize, 0x1000) / Volume->BytesPerSector;
+        Volume->SectorsPerFat = ROUND_UP(FatSize, 4096) / Volume->BytesPerSector;
 
         Volume->RootDirSectorStart = Volume->FatSectorStart + Volume->NumberOfFats * Volume->SectorsPerFat;
         Volume->RootDirSectors = FatXVolumeBootSector->SectorsPerCluster;
@@ -286,6 +326,7 @@ BOOLEAN FatOpenVolume(PFAT_VOLUME_INFO Volume, PFAT_BOOTSECTOR BootSector, ULONG
 
         Volume->RootDirSectorStart = Volume->FatSectorStart + Volume->NumberOfFats * Volume->SectorsPerFat;
         Volume->RootDirSectors = ((FatVolumeBootSector->RootDirEntries * 32) + (Volume->BytesPerSector - 1)) / Volume->BytesPerSector;
+        // Volume->RootDirSectors = (FatVolumeBootSector->RootDirEntries * sizeof(DIRENT) / Volume->BytesPerSector);
 
         Volume->DataSectorStart = Volume->RootDirSectorStart + Volume->RootDirSectors;
     }
@@ -294,10 +335,12 @@ BOOLEAN FatOpenVolume(PFAT_VOLUME_INFO Volume, PFAT_BOOTSECTOR BootSector, ULONG
         Volume->BytesPerSector = Fat32VolumeBootSector->BytesPerSector;
         Volume->SectorsPerCluster = Fat32VolumeBootSector->SectorsPerCluster;
         Volume->FatSectorStart = Fat32VolumeBootSector->ReservedSectors;
-        Volume->ActiveFatSectorStart = Volume->FatSectorStart +
-                                       ((Fat32VolumeBootSector->ExtendedFlags & 0x80) ? ((Fat32VolumeBootSector->ExtendedFlags & 0x0f) * Fat32VolumeBootSector->SectorsPerFatBig) : 0);
+        Volume->ActiveFatSectorStart =
+            Volume->FatSectorStart + ((Fat32VolumeBootSector->ExtendedFlags & 0x80) ?
+                                      ((Fat32VolumeBootSector->ExtendedFlags & 0x0f) * Fat32VolumeBootSector->SectorsPerFatBig) : 0);
         Volume->NumberOfFats = Fat32VolumeBootSector->NumberOfFats;
         Volume->SectorsPerFat = Fat32VolumeBootSector->SectorsPerFatBig;
+        // Volume->SectorsPerFat = (Fat32VolumeBootSector->SectorsPerFat ? Fat32VolumeBootSector->SectorsPerFat : Fat32VolumeBootSector->SectorsPerFatBig);
 
         Volume->RootDirStartCluster = Fat32VolumeBootSector->RootDirStartCluster;
         Volume->DataSectorStart = Volume->FatSectorStart + Volume->NumberOfFats * Volume->SectorsPerFat;
@@ -312,6 +355,7 @@ BOOLEAN FatOpenVolume(PFAT_VOLUME_INFO Volume, PFAT_BOOTSECTOR BootSector, ULONG
             return FALSE;
         }
     }
+    // Volume->NumberOfClusters = FatNumberOfClusters(Volume);
 
     Volume->FatCacheSize = min(Volume->SectorsPerFat, FAT_MAX_CACHE_SIZE / Volume->BytesPerSector);
     TRACE("FAT cache is %d sectors, %d bytes\n", Volume->FatCacheSize, Volume->FatCacheSize * Volume->BytesPerSector);
@@ -1562,6 +1606,22 @@ ARC_STATUS FatSeek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode)
     return ESUCCESS;
 }
 
+
+/**
+ * @brief
+ * Returns the size of the FAT volume laid on the storage media device
+ * opened via @p DeviceId.
+ **/
+ULONGLONG
+FatGetVolumeSize(
+    _In_ ULONG DeviceId)
+{
+    PFAT_VOLUME_INFO Volume = FatVolumes[DeviceId];
+    ASSERT(Volume);
+    return (ULONGLONG)Volume->TotalSectors * Volume->BytesPerSector;
+}
+
+
 const DEVVTBL FatFuncTable =
 {
     FatClose,
@@ -1585,7 +1645,7 @@ const DEVVTBL FatXFuncTable =
 const DEVVTBL* FatMount(ULONG DeviceId)
 {
     PFAT_VOLUME_INFO Volume;
-    UCHAR Buffer[512];
+    UCHAR Buffer[SECTOR_SIZE];
     PFAT_BOOTSECTOR BootSector = (PFAT_BOOTSECTOR)Buffer;
     PFAT32_BOOTSECTOR BootSector32 = (PFAT32_BOOTSECTOR)Buffer;
     PFATX_BOOTSECTOR BootSectorX = (PFATX_BOOTSECTOR)Buffer;

boot/freeldr/freeldr/lib/fs/fs.c

@@ -532,6 +532,83 @@ FsOpenFile(
     return ArcOpen(FullPath, OpenMode, FileId);
 }
 
+/**
+ * @brief
+ * Returns the (useful) size of a file-system volume laid on the
+ * storage media device opened via @p DeviceId.
+ **/
+ARC_STATUS
+FsGetVolumeSize(
+    _In_ ULONG DeviceId,
+    _Out_ PULONGLONG VolumeSize)
+{
+    DEVICE* pDevice;
+    const DEVVTBL* FuncTable;
+    PCWSTR ServiceName;
+    ULONGLONG (*pFsGetVolumeSize)(_In_ ULONG DeviceId);
+
+    /* Check whether this file actually references a device */
+    pDevice = FsGetDeviceById(DeviceId);
+    if (!pDevice)
+        return EBADF; /* It doesn't, fail */
+
+    *VolumeSize = 0;
+
+    // TODO: Mount the device, if not already done?
+#if 1 // FIXME: TEMP HACK!
+    if (!pDevice->FileFuncTable && (pDevice->ReferenceCount <= 1))
+    {
+        for (ULONG fs = 0; fs < _countof(FileSystems); ++fs)
+        {
+            pDevice->FileFuncTable = FileSystems[fs](DeviceId);
+            if (pDevice->FileFuncTable)
+                break;
+        }
+    }
+#endif
+    // TODO: Use a virtual table function member for easily handling other file systems.
+
+    /* Check that the device is mounted (non-NULL FileFuncTable)
+     * and there is an associated "service" (file-system) name. */
+    FuncTable = pDevice->FileFuncTable;
+    ServiceName = (FuncTable && FuncTable->ServiceName)
+                    ? FuncTable->ServiceName : NULL;
+    if (!ServiceName)
+    {
+        ERR("Non-mounted device %lu\n", DeviceId);
+        return ENXIO;
+    }
+
+    /* HACK: Since we don't currently use a virtual table function member,
+     * we instead do a manual lookup over the file-system name.
+     * The ordering follows that of the FileSystems[] table. */
+#ifndef _M_ARM
+    if (!_wcsicmp(ServiceName, L"cdfs"))
+        pFsGetVolumeSize = IsoGetVolumeSize;
+    else
+#endif
+    if (!_wcsicmp(ServiceName, L"fastfat") || !_wcsicmp(ServiceName, L"vfatfs"))
+        pFsGetVolumeSize = FatGetVolumeSize;
+    else
+    if (!_wcsicmp(ServiceName, L"btrfs"))
+        pFsGetVolumeSize = BtrFsGetVolumeSize;
+    else
+#ifndef _M_ARM
+    if (!_wcsicmp(ServiceName, L"ntfs"))
+        pFsGetVolumeSize = NtfsGetVolumeSize;
+    else
+    if (!_wcsicmp(ServiceName, L"ext2fs"))
+        pFsGetVolumeSize = ExtGetVolumeSize;
+    else
+#endif
+    {
+        ERR("Unsupported file system '%S' on storage device %lu\n", ServiceName, DeviceId);
+        return EIO; // ENXIO;
+    }
+    *VolumeSize = pFsGetVolumeSize(DeviceId);
+    return ESUCCESS;
+}
+
 /*
  * FsGetNumPathParts()
  * This function parses a path in the form of dir1\dir2\file1.ext