BaseTools: Library hashing fix and optimization for --hash feature

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

/** @file\r
  Initialization routines.\r
\r
Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "Fat.h"\r
\r
/**\r
\r
  Allocates volume structure, detects FAT file system, installs protocol,\r
  and initialize cache.\r
\r
  @param  Handle                - The handle of parent device.\r
  @param  DiskIo                - The DiskIo of parent device.\r
  @param  DiskIo2               - The DiskIo2 of parent device.\r
  @param  BlockIo               - The BlockIo of parent devicel\r
\r
  @retval EFI_SUCCESS           - Allocate a new volume successfully.\r
  @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.\r
  @return Others                - Allocating a new volume failed.\r
\r
**/\r
EFI_STATUS\r
FatAllocateVolume (\r
  IN  EFI_HANDLE                Handle,\r
  IN  EFI_DISK_IO_PROTOCOL      *DiskIo,\r
  IN  EFI_DISK_IO2_PROTOCOL     *DiskIo2,\r
  IN  EFI_BLOCK_IO_PROTOCOL     *BlockIo\r
  )\r
{\r
  EFI_STATUS  Status;\r
  FAT_VOLUME  *Volume;\r
\r
  //\r
  // Allocate a volume structure\r
  //\r
  Volume = AllocateZeroPool (sizeof (FAT_VOLUME));\r
  if (Volume == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Initialize the structure\r
  //\r
  Volume->Signature                   = FAT_VOLUME_SIGNATURE;\r
  Volume->Handle                      = Handle;\r
  Volume->DiskIo                      = DiskIo;\r
  Volume->DiskIo2                     = DiskIo2;\r
  Volume->BlockIo                     = BlockIo;\r
  Volume->MediaId                     = BlockIo->Media->MediaId;\r
  Volume->ReadOnly                    = BlockIo->Media->ReadOnly;\r
  Volume->VolumeInterface.Revision    = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;\r
  Volume->VolumeInterface.OpenVolume  = FatOpenVolume;\r
  InitializeListHead (&Volume->CheckRef);\r
  InitializeListHead (&Volume->DirCacheList);\r
  //\r
  // Initialize Root Directory entry\r
  //\r
  Volume->RootDirEnt.FileString       = Volume->RootFileString;\r
  Volume->RootDirEnt.Entry.Attributes = FAT_ATTRIBUTE_DIRECTORY;\r
  //\r
  // Check to see if there's a file system on the volume\r
  //\r
  Status = FatOpenDevice (Volume);\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
  //\r
  // Initialize cache\r
  //\r
  Status = FatInitializeDiskCache (Volume);\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
  //\r
  // Install our protocol interfaces on the device's handle\r
  //\r
  Status = gBS->InstallMultipleProtocolInterfaces (\r
                  &Volume->Handle,\r
                  &gEfiSimpleFileSystemProtocolGuid,\r
                  &Volume->VolumeInterface,\r
                  NULL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto Done;\r
  }\r
  //\r
  // Volume installed\r
  //\r
  DEBUG ((EFI_D_INIT, "Installed Fat filesystem on %p\n", Handle));\r
  Volume->Valid = TRUE;\r
\r
Done:\r
  if (EFI_ERROR (Status)) {\r
    FatFreeVolume (Volume);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
\r
  Called by FatDriverBindingStop(), Abandon the volume.\r
\r
  @param  Volume                - The volume to be abandoned.\r
\r
  @retval EFI_SUCCESS           - Abandoned the volume successfully.\r
  @return Others                - Can not uninstall the protocol interfaces.\r
\r
**/\r
EFI_STATUS\r
FatAbandonVolume (\r
  IN FAT_VOLUME *Volume\r
  )\r
{\r
  EFI_STATUS  Status;\r
  BOOLEAN     LockedByMe;\r
\r
  //\r
  // Uninstall the protocol interface.\r
  //\r
  if (Volume->Handle != NULL) {\r
    Status = gBS->UninstallMultipleProtocolInterfaces (\r
                    Volume->Handle,\r
                    &gEfiSimpleFileSystemProtocolGuid,\r
                    &Volume->VolumeInterface,\r
                    NULL\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  LockedByMe = FALSE;\r
\r
  //\r
  // Acquire the lock.\r
  // If the caller has already acquired the lock (which\r
  // means we are in the process of some Fat operation),\r
  // we can not acquire again.\r
  //\r
  Status = FatAcquireLockOrFail ();\r
  if (!EFI_ERROR (Status)) {\r
    LockedByMe = TRUE;\r
  }\r
  //\r
  // The volume is still being used. Hence, set error flag for all OFiles still in\r
  // use. In two cases, we could get here. One is EFI_MEDIA_CHANGED, the other is\r
  // EFI_NO_MEDIA.\r
  //\r
  if (Volume->Root != NULL) {\r
    FatSetVolumeError (\r
      Volume->Root,\r
      Volume->BlockIo->Media->MediaPresent ? EFI_MEDIA_CHANGED : EFI_NO_MEDIA\r
      );\r
  }\r
\r
  Volume->Valid = FALSE;\r
\r
  //\r
  // Release the lock.\r
  // If locked by me, this means DriverBindingStop is NOT\r
  // called within an on-going Fat operation, so we should\r
  // take responsibility to cleanup and free the volume.\r
  // Otherwise, the DriverBindingStop is called within an on-going\r
  // Fat operation, we shouldn't check reference, so just let outer\r
  // FatCleanupVolume do the task.\r
  //\r
  if (LockedByMe) {\r
    FatCleanupVolume (Volume, NULL, EFI_SUCCESS, NULL);\r
    FatReleaseLock ();\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
\r
  Detects FAT file system on Disk and set relevant fields of Volume.\r
\r
  @param Volume                - The volume structure.\r
\r
  @retval EFI_SUCCESS           - The Fat File System is detected successfully\r
  @retval EFI_UNSUPPORTED       - The volume is not FAT file system.\r
  @retval EFI_VOLUME_CORRUPTED  - The volume is corrupted.\r
\r
**/\r
EFI_STATUS\r
FatOpenDevice (\r
  IN OUT FAT_VOLUME           *Volume\r
  )\r
{\r
  EFI_STATUS            Status;\r
  UINT32                BlockSize;\r
  UINT32                DirtyMask;\r
  EFI_DISK_IO_PROTOCOL  *DiskIo;\r
  FAT_BOOT_SECTOR       FatBs;\r
  FAT_VOLUME_TYPE       FatType;\r
  UINTN                 RootDirSectors;\r
  UINTN                 FatLba;\r
  UINTN                 RootLba;\r
  UINTN                 FirstClusterLba;\r
  UINTN                 Sectors;\r
  UINTN                 SectorsPerFat;\r
  UINT8                 SectorsPerClusterAlignment;\r
  UINT8                 BlockAlignment;\r
\r
  //\r
  // Read the FAT_BOOT_SECTOR BPB info\r
  // This is the only part of FAT code that uses parent DiskIo,\r
  // Others use FatDiskIo which utilizes a Cache.\r
  //\r
  DiskIo  = Volume->DiskIo;\r
  Status  = DiskIo->ReadDisk (DiskIo, Volume->MediaId, 0, sizeof (FatBs), &FatBs);\r
\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((EFI_D_INIT, "FatOpenDevice: read of part_lba failed %r\n", Status));\r
    return Status;\r
  }\r
\r
  FatType = FatUndefined;\r
\r
  //\r
  // Use LargeSectors if Sectors is 0\r
  //\r
  Sectors = FatBs.FatBsb.Sectors;\r
  if (Sectors == 0) {\r
    Sectors = FatBs.FatBsb.LargeSectors;\r
  }\r
\r
  SectorsPerFat = FatBs.FatBsb.SectorsPerFat;\r
  if (SectorsPerFat == 0) {\r
    SectorsPerFat = FatBs.FatBse.Fat32Bse.LargeSectorsPerFat;\r
    FatType       = Fat32;\r
  }\r
  //\r
  // Is boot sector a fat sector?\r
  // (Note that so far we only know if the sector is FAT32 or not, we don't\r
  // know if the sector is Fat16 or Fat12 until later when we can compute\r
  // the volume size)\r
  //\r
  if (FatBs.FatBsb.ReservedSectors == 0 || FatBs.FatBsb.NumFats == 0 || Sectors == 0) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  if ((FatBs.FatBsb.SectorSize & (FatBs.FatBsb.SectorSize - 1)) != 0) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  BlockAlignment = (UINT8) HighBitSet32 (FatBs.FatBsb.SectorSize);\r
  if (BlockAlignment > MAX_BLOCK_ALIGNMENT || BlockAlignment < MIN_BLOCK_ALIGNMENT) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  if ((FatBs.FatBsb.SectorsPerCluster & (FatBs.FatBsb.SectorsPerCluster - 1)) != 0) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  SectorsPerClusterAlignment = (UINT8) HighBitSet32 (FatBs.FatBsb.SectorsPerCluster);\r
  if (SectorsPerClusterAlignment > MAX_SECTORS_PER_CLUSTER_ALIGNMENT) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  if (FatBs.FatBsb.Media <= 0xf7 &&\r
      FatBs.FatBsb.Media != 0xf0 &&\r
      FatBs.FatBsb.Media != 0x00 &&\r
      FatBs.FatBsb.Media != 0x01\r
      ) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  //\r
  // Initialize fields the volume information for this FatType\r
  //\r
  if (FatType != Fat32) {\r
    if (FatBs.FatBsb.RootEntries == 0) {\r
      return EFI_UNSUPPORTED;\r
    }\r
    //\r
    // Unpack fat12, fat16 info\r
    //\r
    Volume->RootEntries = FatBs.FatBsb.RootEntries;\r
  } else {\r
    //\r
    // If this is fat32, refuse to mount mirror-disabled volumes\r
    //\r
    if ((SectorsPerFat == 0 || FatBs.FatBse.Fat32Bse.FsVersion != 0) || (FatBs.FatBse.Fat32Bse.ExtendedFlags & 0x80)) {\r
      return EFI_UNSUPPORTED;\r
    }\r
    //\r
    // Unpack fat32 info\r
    //\r
    Volume->RootCluster = FatBs.FatBse.Fat32Bse.RootDirFirstCluster;\r
  }\r
\r
  Volume->NumFats           = FatBs.FatBsb.NumFats;\r
  //\r
  // Compute some fat locations\r
  //\r
  BlockSize                 = FatBs.FatBsb.SectorSize;\r
  RootDirSectors            = ((Volume->RootEntries * sizeof (FAT_DIRECTORY_ENTRY)) + (BlockSize - 1)) / BlockSize;\r
\r
  FatLba                    = FatBs.FatBsb.ReservedSectors;\r
  RootLba                   = FatBs.FatBsb.NumFats * SectorsPerFat + FatLba;\r
  FirstClusterLba           = RootLba + RootDirSectors;\r
\r
  Volume->FatPos            = FatLba * BlockSize;\r
  Volume->FatSize           = SectorsPerFat * BlockSize;\r
\r
  Volume->VolumeSize        = LShiftU64 (Sectors, BlockAlignment);\r
  Volume->RootPos           = LShiftU64 (RootLba, BlockAlignment);\r
  Volume->FirstClusterPos   = LShiftU64 (FirstClusterLba, BlockAlignment);\r
  Volume->MaxCluster        = (Sectors - FirstClusterLba) >> SectorsPerClusterAlignment;\r
  Volume->ClusterAlignment  = (UINT8)(BlockAlignment + SectorsPerClusterAlignment);\r
  Volume->ClusterSize       = (UINTN)1 << (Volume->ClusterAlignment);\r
\r
  //\r
  // If this is not a fat32, determine if it's a fat16 or fat12\r
  //\r
  if (FatType != Fat32) {\r
    if (Volume->MaxCluster >= FAT_MAX_FAT16_CLUSTER) {\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
\r
    FatType = Volume->MaxCluster < FAT_MAX_FAT12_CLUSTER ? Fat12 : Fat16;\r
    //\r
    // fat12 & fat16 fat-entries are 2 bytes\r
    //\r
    Volume->FatEntrySize = sizeof (UINT16);\r
    DirtyMask            = FAT16_DIRTY_MASK;\r
  } else {\r
    if (Volume->MaxCluster < FAT_MAX_FAT16_CLUSTER) {\r
      return EFI_VOLUME_CORRUPTED;\r
    }\r
    //\r
    // fat32 fat-entries are 4 bytes\r
    //\r
    Volume->FatEntrySize = sizeof (UINT32);\r
    DirtyMask            = FAT32_DIRTY_MASK;\r
  }\r
  //\r
  // Get the DirtyValue and NotDirtyValue\r
  // We should keep the initial value as the NotDirtyValue\r
  // in case the volume is dirty already\r
  //\r
  if (FatType != Fat12) {\r
    Status = FatAccessVolumeDirty (Volume, ReadDisk, &Volume->NotDirtyValue);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    Volume->DirtyValue = Volume->NotDirtyValue & DirtyMask;\r
  }\r
  //\r
  // If present, read the fat hint info\r
  //\r
  if (FatType == Fat32) {\r
    Volume->FreeInfoPos = FatBs.FatBse.Fat32Bse.FsInfoSector * BlockSize;\r
    if (FatBs.FatBse.Fat32Bse.FsInfoSector != 0) {\r
      FatDiskIo (Volume, ReadDisk, Volume->FreeInfoPos, sizeof (FAT_INFO_SECTOR), &Volume->FatInfoSector, NULL);\r
      if (Volume->FatInfoSector.Signature == FAT_INFO_SIGNATURE &&\r
          Volume->FatInfoSector.InfoBeginSignature == FAT_INFO_BEGIN_SIGNATURE &&\r
          Volume->FatInfoSector.InfoEndSignature == FAT_INFO_END_SIGNATURE &&\r
          Volume->FatInfoSector.FreeInfo.ClusterCount <= Volume->MaxCluster\r
          ) {\r
        Volume->FreeInfoValid = TRUE;\r
      }\r
    }\r
  }\r
  //\r
  // Just make up a FreeInfo.NextCluster for use by allocate cluster\r
  //\r
  if (FAT_MIN_CLUSTER > Volume->FatInfoSector.FreeInfo.NextCluster ||\r
     Volume->FatInfoSector.FreeInfo.NextCluster > Volume->MaxCluster + 1\r
     ) {\r
    Volume->FatInfoSector.FreeInfo.NextCluster = FAT_MIN_CLUSTER;\r
  }\r
  //\r
  // We are now defining FAT Type\r
  //\r
  Volume->FatType = FatType;\r
  ASSERT (FatType != FatUndefined);\r
\r
  return EFI_SUCCESS;\r
}\r