[mirror_edk2.git] / FatPkg / EnhancedFatDxe / FileSpace.c

/** @file\r
  Routines dealing with disk spaces and FAT table entries.\r
\r
Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
\r
\r
**/\r
\r
#include "Fat.h"\r
\r
/**\r
\r
  Get the FAT entry of the volume, which is identified with the Index.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  Index                 - The index of the FAT entry of the volume.\r
\r
  @return The buffer of the FAT entry\r
\r
**/\r
STATIC\r
VOID *\r
FatLoadFatEntry (\r
  IN FAT_VOLUME  *Volume,\r
  IN UINTN       Index\r
  )\r
{\r
  UINTN       Pos;\r
  EFI_STATUS  Status;\r
\r
  if (Index > (Volume->MaxCluster + 1)) {\r
    Volume->FatEntryBuffer = (UINT32)-1;\r
    return &Volume->FatEntryBuffer;\r
  }\r
\r
  //\r
  // Compute buffer position needed\r
  //\r
  switch (Volume->FatType) {\r
    case Fat12:\r
      Pos = FAT_POS_FAT12 (Index);\r
      break;\r
\r
    case Fat16:\r
      Pos = FAT_POS_FAT16 (Index);\r
      break;\r
\r
    default:\r
      Pos = FAT_POS_FAT32 (Index);\r
  }\r
\r
  //\r
  // Set the position and read the buffer\r
  //\r
  Volume->FatEntryPos = Volume->FatPos + Pos;\r
  Status              = FatDiskIo (\r
                          Volume,\r
                          ReadFat,\r
                          Volume->FatEntryPos,\r
                          Volume->FatEntrySize,\r
                          &Volume->FatEntryBuffer,\r
                          NULL\r
                          );\r
  if (EFI_ERROR (Status)) {\r
    Volume->FatEntryBuffer = (UINT32)-1;\r
  }\r
\r
  return &Volume->FatEntryBuffer;\r
}\r
\r
/**\r
\r
  Get the FAT entry value of the volume, which is identified with the Index.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  Index                 - The index of the FAT entry of the volume.\r
\r
  @return  The value of the FAT entry.\r
\r
**/\r
STATIC\r
UINTN\r
FatGetFatEntry (\r
  IN FAT_VOLUME  *Volume,\r
  IN UINTN       Index\r
  )\r
{\r
  VOID    *Pos;\r
  UINT8   *En12;\r
  UINT16  *En16;\r
  UINT32  *En32;\r
  UINTN   Accum;\r
\r
  Pos = FatLoadFatEntry (Volume, Index);\r
\r
  if (Index > (Volume->MaxCluster + 1)) {\r
    return (UINTN)-1;\r
  }\r
\r
  switch (Volume->FatType) {\r
    case Fat12:\r
      En12  = Pos;\r
      Accum = En12[0] | (En12[1] << 8);\r
      Accum = FAT_ODD_CLUSTER_FAT12 (Index) ? (Accum >> 4) : (Accum & FAT_CLUSTER_MASK_FAT12);\r
      Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT12) ? FAT_CLUSTER_SPECIAL_EXT : 0);\r
      break;\r
\r
    case Fat16:\r
      En16  = Pos;\r
      Accum = *En16;\r
      Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT16) ? FAT_CLUSTER_SPECIAL_EXT : 0);\r
      break;\r
\r
    default:\r
      En32  = Pos;\r
      Accum = *En32 & FAT_CLUSTER_MASK_FAT32;\r
      Accum = Accum | ((Accum >= FAT_CLUSTER_SPECIAL_FAT32) ? FAT_CLUSTER_SPECIAL_EXT : 0);\r
  }\r
\r
  return Accum;\r
}\r
\r
/**\r
\r
  Set the FAT entry value of the volume, which is identified with the Index.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  Index                 - The index of the FAT entry of the volume.\r
  @param  Value                 - The new value of the FAT entry.\r
\r
  @retval EFI_SUCCESS           - Set the new FAT entry value successfully.\r
  @retval EFI_VOLUME_CORRUPTED  - The FAT type of the volume is error.\r
  @return other                 - An error occurred when operation the FAT entries.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
FatSetFatEntry (\r
  IN FAT_VOLUME  *Volume,\r
  IN UINTN       Index,\r
  IN UINTN       Value\r
  )\r
{\r
  VOID        *Pos;\r
  UINT8       *En12;\r
  UINT16      *En16;\r
  UINT32      *En32;\r
  UINTN       Accum;\r
  EFI_STATUS  Status;\r
  UINTN       OriginalVal;\r
\r
  if (Index < FAT_MIN_CLUSTER) {\r
    return EFI_VOLUME_CORRUPTED;\r
  }\r
\r
  OriginalVal = FatGetFatEntry (Volume, Index);\r
  if ((Value == FAT_CLUSTER_FREE) && (OriginalVal != FAT_CLUSTER_FREE)) {\r
    Volume->FatInfoSector.FreeInfo.ClusterCount += 1;\r
    if (Index < Volume->FatInfoSector.FreeInfo.NextCluster) {\r
      Volume->FatInfoSector.FreeInfo.NextCluster = (UINT32)Index;\r
    }\r
  } else if ((Value != FAT_CLUSTER_FREE) && (OriginalVal == FAT_CLUSTER_FREE)) {\r
    if (Volume->FatInfoSector.FreeInfo.ClusterCount != 0) {\r
      Volume->FatInfoSector.FreeInfo.ClusterCount -= 1;\r
    }\r
  }\r
\r
  //\r
  // Make sure the entry is in memory\r
  //\r
  Pos = FatLoadFatEntry (Volume, Index);\r
\r
  //\r
  // Update the value\r
  //\r
  switch (Volume->FatType) {\r
    case Fat12:\r
      En12  = Pos;\r
      Accum = En12[0] | (En12[1] << 8);\r
      Value = Value & FAT_CLUSTER_MASK_FAT12;\r
\r
      if (FAT_ODD_CLUSTER_FAT12 (Index)) {\r
        Accum = (Value << 4) | (Accum & 0xF);\r
      } else {\r
        Accum = Value | (Accum & FAT_CLUSTER_UNMASK_FAT12);\r
      }\r
\r
      En12[0] = (UINT8)(Accum & 0xFF);\r
      En12[1] = (UINT8)(Accum >> 8);\r
      break;\r
\r
    case Fat16:\r
      En16  = Pos;\r
      *En16 = (UINT16)Value;\r
      break;\r
\r
    default:\r
      En32  = Pos;\r
      *En32 = (*En32 & FAT_CLUSTER_UNMASK_FAT32) | (UINT32)(Value & FAT_CLUSTER_MASK_FAT32);\r
  }\r
\r
  //\r
  // If the volume's dirty bit is not set, set it now\r
  //\r
  if (!Volume->FatDirty && (Volume->FatType != Fat12)) {\r
    Volume->FatDirty = TRUE;\r
    FatAccessVolumeDirty (Volume, WriteFat, &Volume->DirtyValue);\r
  }\r
\r
  //\r
  // Write the updated fat entry value to the volume\r
  // The fat is the first fat, and other fat will be in sync\r
  // when the FAT cache flush back.\r
  //\r
  Status = FatDiskIo (\r
             Volume,\r
             WriteFat,\r
             Volume->FatEntryPos,\r
             Volume->FatEntrySize,\r
             &Volume->FatEntryBuffer,\r
             NULL\r
             );\r
  return Status;\r
}\r
\r
/**\r
\r
  Free the cluster chain.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  Cluster               - The first cluster of cluster chain.\r
\r
  @retval EFI_SUCCESS           - The cluster chain is freed successfully.\r
  @retval EFI_VOLUME_CORRUPTED  - There are errors in the file's clusters.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
FatFreeClusters (\r
  IN FAT_VOLUME  *Volume,\r
  IN UINTN       Cluster\r
  )\r
{\r
  UINTN  LastCluster;\r
\r
  while (!FAT_END_OF_FAT_CHAIN (Cluster)) {\r
    if ((Cluster == FAT_CLUSTER_FREE) || (Cluster >= FAT_CLUSTER_SPECIAL)) {\r
      DEBUG ((DEBUG_INIT | DEBUG_ERROR, "FatShrinkEof: cluster chain corrupt\n"));\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
\r
    LastCluster = Cluster;\r
    Cluster     = FatGetFatEntry (Volume, Cluster);\r
    FatSetFatEntry (Volume, LastCluster, FAT_CLUSTER_FREE);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
\r
  Allocate a free cluster and return the cluster index.\r
\r
  @param  Volume                - FAT file system volume.\r
\r
  @return The index of the free cluster\r
\r
**/\r
STATIC\r
UINTN\r
FatAllocateCluster (\r
  IN FAT_VOLUME  *Volume\r
  )\r
{\r
  UINTN  Cluster;\r
\r
  //\r
  // Start looking at FatFreePos for the next unallocated cluster\r
  //\r
  if (Volume->DiskError) {\r
    return (UINTN)FAT_CLUSTER_LAST;\r
  }\r
\r
  for ( ; ;) {\r
    //\r
    // If the end of the list, return no available cluster\r
    //\r
    if (Volume->FatInfoSector.FreeInfo.NextCluster > (Volume->MaxCluster + 1)) {\r
      if (Volume->FreeInfoValid && (0 < (INT32)(Volume->FatInfoSector.FreeInfo.ClusterCount))) {\r
        Volume->FreeInfoValid = FALSE;\r
      }\r
\r
      FatComputeFreeInfo (Volume);\r
      if (Volume->FatInfoSector.FreeInfo.NextCluster > (Volume->MaxCluster + 1)) {\r
        return (UINTN)FAT_CLUSTER_LAST;\r
      }\r
    }\r
\r
    Cluster = FatGetFatEntry (Volume, Volume->FatInfoSector.FreeInfo.NextCluster);\r
    if (Cluster == FAT_CLUSTER_FREE) {\r
      break;\r
    }\r
\r
    //\r
    // Try the next cluster\r
    //\r
    Volume->FatInfoSector.FreeInfo.NextCluster += 1;\r
  }\r
\r
  Cluster                                     = Volume->FatInfoSector.FreeInfo.NextCluster;\r
  Volume->FatInfoSector.FreeInfo.NextCluster += 1;\r
  return Cluster;\r
}\r
\r
/**\r
\r
  Count the number of clusters given a size.\r
\r
  @param  Volume                - The file system volume.\r
  @param  Size                  - The size in bytes.\r
\r
  @return The number of the clusters.\r
\r
**/\r
STATIC\r
UINTN\r
FatSizeToClusters (\r
  IN FAT_VOLUME  *Volume,\r
  IN UINTN       Size\r
  )\r
{\r
  UINTN  Clusters;\r
\r
  Clusters = Size >> Volume->ClusterAlignment;\r
  if ((Size & (Volume->ClusterSize - 1)) > 0) {\r
    Clusters += 1;\r
  }\r
\r
  return Clusters;\r
}\r
\r
/**\r
\r
  Shrink the end of the open file base on the file size.\r
\r
  @param  OFile                 - The open file.\r
\r
  @retval EFI_SUCCESS           - Shrinked successfully.\r
  @retval EFI_VOLUME_CORRUPTED  - There are errors in the file's clusters.\r
\r
**/\r
EFI_STATUS\r
FatShrinkEof (\r
  IN FAT_OFILE  *OFile\r
  )\r
{\r
  FAT_VOLUME  *Volume;\r
  UINTN       NewSize;\r
  UINTN       CurSize;\r
  UINTN       Cluster;\r
  UINTN       LastCluster;\r
\r
  Volume = OFile->Volume;\r
  ASSERT_VOLUME_LOCKED (Volume);\r
\r
  NewSize = FatSizeToClusters (Volume, OFile->FileSize);\r
\r
  //\r
  // Find the address of the last cluster\r
  //\r
  Cluster     = OFile->FileCluster;\r
  LastCluster = FAT_CLUSTER_FREE;\r
\r
  if (NewSize != 0) {\r
    for (CurSize = 0; CurSize < NewSize; CurSize++) {\r
      if ((Cluster == FAT_CLUSTER_FREE) || (Cluster >= FAT_CLUSTER_SPECIAL)) {\r
        DEBUG ((DEBUG_INIT | DEBUG_ERROR, "FatShrinkEof: cluster chain corrupt\n"));\r
        return EFI_VOLUME_CORRUPTED;\r
      }\r
\r
      LastCluster = Cluster;\r
      Cluster     = FatGetFatEntry (Volume, Cluster);\r
    }\r
\r
    FatSetFatEntry (Volume, LastCluster, (UINTN)FAT_CLUSTER_LAST);\r
  } else {\r
    //\r
    // Check to see if the file is already completely truncated\r
    //\r
    if (Cluster == FAT_CLUSTER_FREE) {\r
      return EFI_SUCCESS;\r
    }\r
\r
    //\r
    // The file is being completely truncated.\r
    //\r
    OFile->FileCluster = FAT_CLUSTER_FREE;\r
  }\r
\r
  //\r
  // Set CurrentCluster == FileCluster\r
  // to force a recalculation of Position related stuffs\r
  //\r
  OFile->FileCurrentCluster = OFile->FileCluster;\r
  OFile->FileLastCluster    = LastCluster;\r
  OFile->Dirty              = TRUE;\r
  //\r
  // Free the remaining cluster chain\r
  //\r
  return FatFreeClusters (Volume, Cluster);\r
}\r
\r
/**\r
\r
  Grow the end of the open file base on the NewSizeInBytes.\r
\r
  @param  OFile                 - The open file.\r
  @param  NewSizeInBytes        - The new size in bytes of the open file.\r
\r
  @retval EFI_SUCCESS           - The file is grown successfully.\r
  @retval EFI_UNSUPPORTED       - The file size is larger than 4GB.\r
  @retval EFI_VOLUME_CORRUPTED  - There are errors in the files' clusters.\r
  @retval EFI_VOLUME_FULL       - The volume is full and can not grow the file.\r
\r
**/\r
EFI_STATUS\r
FatGrowEof (\r
  IN FAT_OFILE  *OFile,\r
  IN UINT64     NewSizeInBytes\r
  )\r
{\r
  FAT_VOLUME  *Volume;\r
  EFI_STATUS  Status;\r
  UINTN       Cluster;\r
  UINTN       CurSize;\r
  UINTN       NewSize;\r
  UINTN       LastCluster;\r
  UINTN       NewCluster;\r
  UINTN       ClusterCount;\r
\r
  //\r
  // For FAT file system, the max file is 4GB.\r
  //\r
  if (NewSizeInBytes > 0x0FFFFFFFFL) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Volume = OFile->Volume;\r
  ASSERT_VOLUME_LOCKED (Volume);\r
  //\r
  // If the file is already large enough, do nothing\r
  //\r
  CurSize = FatSizeToClusters (Volume, OFile->FileSize);\r
  NewSize = FatSizeToClusters (Volume, (UINTN)NewSizeInBytes);\r
\r
  if (CurSize < NewSize) {\r
    //\r
    // If we haven't found the files last cluster do it now\r
    //\r
    if ((OFile->FileCluster != 0) && (OFile->FileLastCluster == 0)) {\r
      Cluster      = OFile->FileCluster;\r
      ClusterCount = 0;\r
\r
      while (!FAT_END_OF_FAT_CHAIN (Cluster)) {\r
        if ((Cluster < FAT_MIN_CLUSTER) || (Cluster > Volume->MaxCluster + 1)) {\r
          DEBUG (\r
            (DEBUG_INIT | DEBUG_ERROR,\r
             "FatGrowEof: cluster chain corrupt\n")\r
            );\r
          Status = EFI_VOLUME_CORRUPTED;\r
          goto Done;\r
        }\r
\r
        ClusterCount++;\r
        OFile->FileLastCluster = Cluster;\r
        Cluster                = FatGetFatEntry (Volume, Cluster);\r
      }\r
\r
      if (ClusterCount != CurSize) {\r
        DEBUG (\r
          (DEBUG_INIT | DEBUG_ERROR,\r
           "FatGrowEof: cluster chain size does not match file size\n")\r
          );\r
        Status = EFI_VOLUME_CORRUPTED;\r
        goto Done;\r
      }\r
    }\r
\r
    //\r
    // Loop until we've allocated enough space\r
    //\r
    LastCluster = OFile->FileLastCluster;\r
\r
    while (CurSize < NewSize) {\r
      NewCluster = FatAllocateCluster (Volume);\r
      if (FAT_END_OF_FAT_CHAIN (NewCluster)) {\r
        if (LastCluster != FAT_CLUSTER_FREE) {\r
          FatSetFatEntry (Volume, LastCluster, (UINTN)FAT_CLUSTER_LAST);\r
          OFile->FileLastCluster = LastCluster;\r
        }\r
\r
        Status = EFI_VOLUME_FULL;\r
        goto Done;\r
      }\r
\r
      if ((NewCluster < FAT_MIN_CLUSTER) || (NewCluster > Volume->MaxCluster + 1)) {\r
        Status = EFI_VOLUME_CORRUPTED;\r
        goto Done;\r
      }\r
\r
      if (LastCluster != 0) {\r
        FatSetFatEntry (Volume, LastCluster, NewCluster);\r
      } else {\r
        OFile->FileCluster        = NewCluster;\r
        OFile->FileCurrentCluster = NewCluster;\r
      }\r
\r
      LastCluster = NewCluster;\r
      CurSize    += 1;\r
\r
      //\r
      // Terminate the cluster list\r
      //\r
      // Note that we must do this EVERY time we allocate a cluster, because\r
      // FatAllocateCluster scans the FAT looking for a free cluster and\r
      // "LastCluster" is no longer free!  Usually, FatAllocateCluster will\r
      // start looking with the cluster after "LastCluster"; however, when\r
      // there is only one free cluster left, it will find "LastCluster"\r
      // a second time.  There are other, less predictable scenarios\r
      // where this could happen, as well.\r
      //\r
      FatSetFatEntry (Volume, LastCluster, (UINTN)FAT_CLUSTER_LAST);\r
      OFile->FileLastCluster = LastCluster;\r
    }\r
  }\r
\r
  OFile->FileSize = (UINTN)NewSizeInBytes;\r
  OFile->Dirty    = TRUE;\r
  return EFI_SUCCESS;\r
\r
Done:\r
  FatShrinkEof (OFile);\r
  return Status;\r
}\r
\r
/**\r
\r
  Seek OFile to requested position, and calculate the number of\r
  consecutive clusters from the position in the file\r
\r
  @param  OFile                 - The open file.\r
  @param  Position              - The file's position which will be accessed.\r
  @param  PosLimit              - The maximum length current reading/writing may access\r
\r
  @retval EFI_SUCCESS           - Set the info successfully.\r
  @retval EFI_VOLUME_CORRUPTED  - Cluster chain corrupt.\r
\r
**/\r
EFI_STATUS\r
FatOFilePosition (\r
  IN FAT_OFILE  *OFile,\r
  IN UINTN      Position,\r
  IN UINTN      PosLimit\r
  )\r
{\r
  FAT_VOLUME  *Volume;\r
  UINTN       ClusterSize;\r
  UINTN       Cluster;\r
  UINTN       StartPos;\r
  UINTN       Run;\r
\r
  Volume      = OFile->Volume;\r
  ClusterSize = Volume->ClusterSize;\r
\r
  ASSERT_VOLUME_LOCKED (Volume);\r
\r
  //\r
  // If this is the fixed root dir, then compute its position\r
  // from its fixed info in the fat bpb\r
  //\r
  if (OFile->IsFixedRootDir) {\r
    OFile->PosDisk = Volume->RootPos + Position;\r
    Run            = OFile->FileSize - Position;\r
  } else {\r
    //\r
    // Run the file's cluster chain to find the current position\r
    // If possible, run from the current cluster rather than\r
    // start from beginning\r
    // Assumption: OFile->Position is always consistent with\r
    // OFile->FileCurrentCluster.\r
    // OFile->Position is not modified outside this function;\r
    // OFile->FileCurrentCluster is modified outside this function\r
    // to be the same as OFile->FileCluster\r
    // when OFile->FileCluster is updated, so make a check of this\r
    // and invalidate the original OFile->Position in this case\r
    //\r
    Cluster  = OFile->FileCurrentCluster;\r
    StartPos = OFile->Position;\r
    if ((Position < StartPos) || (OFile->FileCluster == Cluster)) {\r
      StartPos = 0;\r
      Cluster  = OFile->FileCluster;\r
    }\r
\r
    while (StartPos + ClusterSize <= Position) {\r
      StartPos += ClusterSize;\r
      if ((Cluster == FAT_CLUSTER_FREE) || (Cluster >= FAT_CLUSTER_SPECIAL)) {\r
        DEBUG ((DEBUG_INIT | DEBUG_ERROR, "FatOFilePosition:" " cluster chain corrupt\n"));\r
        return EFI_VOLUME_CORRUPTED;\r
      }\r
\r
      Cluster = FatGetFatEntry (Volume, Cluster);\r
    }\r
\r
    if ((Cluster < FAT_MIN_CLUSTER) || (Cluster > Volume->MaxCluster + 1)) {\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
\r
    OFile->PosDisk = Volume->FirstClusterPos +\r
                     LShiftU64 (Cluster - FAT_MIN_CLUSTER, Volume->ClusterAlignment) +\r
                     Position - StartPos;\r
    OFile->FileCurrentCluster = Cluster;\r
    OFile->Position           = StartPos;\r
\r
    //\r
    // Compute the number of consecutive clusters in the file\r
    //\r
    Run = StartPos + ClusterSize - Position;\r
    if (!FAT_END_OF_FAT_CHAIN (Cluster)) {\r
      while ((FatGetFatEntry (Volume, Cluster) == Cluster + 1) && Run < PosLimit) {\r
        Run     += ClusterSize;\r
        Cluster += 1;\r
      }\r
    }\r
  }\r
\r
  OFile->PosRem = Run;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
\r
  Get the size of directory of the open file.\r
\r
  @param  Volume                - The File System Volume.\r
  @param  Cluster               - The Starting cluster.\r
\r
  @return The physical size of the file starting at the input cluster, if there is error in the\r
  cluster chain, the return value is 0.\r
\r
**/\r
UINTN\r
FatPhysicalDirSize (\r
  IN FAT_VOLUME  *Volume,\r
  IN UINTN       Cluster\r
  )\r
{\r
  UINTN  Size;\r
\r
  ASSERT_VOLUME_LOCKED (Volume);\r
  //\r
  // Run the cluster chain for the OFile\r
  //\r
  Size = 0;\r
  //\r
  // N.B. ".." directories on some media do not contain a starting\r
  // cluster.  In the case of "." or ".." we don't need the size anyway.\r
  //\r
  if (Cluster != 0) {\r
    while (!FAT_END_OF_FAT_CHAIN (Cluster)) {\r
      if ((Cluster == FAT_CLUSTER_FREE) || (Cluster >= FAT_CLUSTER_SPECIAL)) {\r
        DEBUG (\r
          (DEBUG_INIT | DEBUG_ERROR,\r
           "FATDirSize: cluster chain corrupt\n")\r
          );\r
        return 0;\r
      }\r
\r
      Size   += Volume->ClusterSize;\r
      Cluster = FatGetFatEntry (Volume, Cluster);\r
    }\r
  }\r
\r
  return Size;\r
}\r
\r
/**\r
\r
  Get the physical size of a file on the disk.\r
\r
  @param  Volume                - The file system volume.\r
  @param  RealSize              - The real size of a file.\r
\r
  @return The physical size of a file on the disk.\r
\r
**/\r
UINT64\r
FatPhysicalFileSize (\r
  IN FAT_VOLUME  *Volume,\r
  IN UINTN       RealSize\r
  )\r
{\r
  UINTN   ClusterSizeMask;\r
  UINT64  PhysicalSize;\r
\r
  ClusterSizeMask = Volume->ClusterSize - 1;\r
  PhysicalSize    = (RealSize + ClusterSizeMask) & (~((UINT64)ClusterSizeMask));\r
  return PhysicalSize;\r
}\r
\r
/**\r
\r
  Update the free cluster info of FatInfoSector of the volume.\r
\r
  @param  Volume                - FAT file system volume.\r
\r
**/\r
VOID\r
FatComputeFreeInfo (\r
  IN FAT_VOLUME  *Volume\r
  )\r
{\r
  UINTN  Index;\r
\r
  //\r
  // If we don't have valid info, compute it now\r
  //\r
  if (!Volume->FreeInfoValid) {\r
    Volume->FreeInfoValid                       = TRUE;\r
    Volume->FatInfoSector.FreeInfo.ClusterCount = 0;\r
    for (Index = Volume->MaxCluster + 1; Index >= FAT_MIN_CLUSTER; Index--) {\r
      if (Volume->DiskError) {\r
        break;\r
      }\r
\r
      if (FatGetFatEntry (Volume, Index) == FAT_CLUSTER_FREE) {\r
        Volume->FatInfoSector.FreeInfo.ClusterCount += 1;\r
        Volume->FatInfoSector.FreeInfo.NextCluster   = (UINT32)Index;\r
      }\r
    }\r
\r
    Volume->FatInfoSector.Signature          = FAT_INFO_SIGNATURE;\r
    Volume->FatInfoSector.InfoBeginSignature = FAT_INFO_BEGIN_SIGNATURE;\r
    Volume->FatInfoSector.InfoEndSignature   = FAT_INFO_END_SIGNATURE;\r
  }\r
}\r