FatPkg/EnhancedFatDxe/Init.c

   1 /** @file
   2   Initialization routines.
   3
   4 Copyright (c) 2005 - 2013, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials are licensed and made available
   6 under the terms and conditions of the BSD License which accompanies this
   7 distribution. The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "Fat.h"
  16
  17 /**
  18
  19   Allocates volume structure, detects FAT file system, installs protocol,
  20   and initialize cache.
  21
  22   @param  Handle                - The handle of parent device.
  23   @param  DiskIo                - The DiskIo of parent device.
  24   @param  DiskIo2               - The DiskIo2 of parent device.
  25   @param  BlockIo               - The BlockIo of parent devicel
  26
  27   @retval EFI_SUCCESS           - Allocate a new volume successfully.
  28   @retval EFI_OUT_OF_RESOURCES  - Can not allocate the memory.
  29   @return Others                - Allocating a new volume failed.
  30
  31 **/
  32 EFI_STATUS
  33 FatAllocateVolume (
  34   IN  EFI_HANDLE                Handle,
  35   IN  EFI_DISK_IO_PROTOCOL      *DiskIo,
  36   IN  EFI_DISK_IO2_PROTOCOL     *DiskIo2,
  37   IN  EFI_BLOCK_IO_PROTOCOL     *BlockIo
  38   )
  39 {
  40   EFI_STATUS  Status;
  41   FAT_VOLUME  *Volume;
  42
  43   //
  44   // Allocate a volume structure
  45   //
  46   Volume = AllocateZeroPool (sizeof (FAT_VOLUME));
  47   if (Volume == NULL) {
  48     return EFI_OUT_OF_RESOURCES;
  49   }
  50
  51   //
  52   // Initialize the structure
  53   //
  54   Volume->Signature                   = FAT_VOLUME_SIGNATURE;
  55   Volume->Handle                      = Handle;
  56   Volume->DiskIo                      = DiskIo;
  57   Volume->DiskIo2                     = DiskIo2;
  58   Volume->BlockIo                     = BlockIo;
  59   Volume->MediaId                     = BlockIo->Media->MediaId;
  60   Volume->ReadOnly                    = BlockIo->Media->ReadOnly;
  61   Volume->VolumeInterface.Revision    = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;
  62   Volume->VolumeInterface.OpenVolume  = FatOpenVolume;
  63   InitializeListHead (&Volume->CheckRef);
  64   InitializeListHead (&Volume->DirCacheList);
  65   //
  66   // Initialize Root Directory entry
  67   //
  68   Volume->RootDirEnt.FileString       = Volume->RootFileString;
  69   Volume->RootDirEnt.Entry.Attributes = FAT_ATTRIBUTE_DIRECTORY;
  70   //
  71   // Check to see if there's a file system on the volume
  72   //
  73   Status = FatOpenDevice (Volume);
  74   if (EFI_ERROR (Status)) {
  75     goto Done;
  76   }
  77   //
  78   // Initialize cache
  79   //
  80   Status = FatInitializeDiskCache (Volume);
  81   if (EFI_ERROR (Status)) {
  82     goto Done;
  83   }
  84   //
  85   // Install our protocol interfaces on the device's handle
  86   //
  87   Status = gBS->InstallMultipleProtocolInterfaces (
  88                   &Volume->Handle,
  89                   &gEfiSimpleFileSystemProtocolGuid,
  90                   &Volume->VolumeInterface,
  91                   NULL
  92                   );
  93   if (EFI_ERROR (Status)) {
  94     goto Done;
  95   }
  96   //
  97   // Volume installed
  98   //
  99   DEBUG ((EFI_D_INIT, "Installed Fat filesystem on %p\n", Handle));
 100   Volume->Valid = TRUE;
 101
 102 Done:
 103   if (EFI_ERROR (Status)) {
 104     FatFreeVolume (Volume);
 105   }
 106
 107   return Status;
 108 }
 109
 110 /**
 111
 112   Called by FatDriverBindingStop(), Abandon the volume.
 113
 114   @param  Volume                - The volume to be abandoned.
 115
 116   @retval EFI_SUCCESS           - Abandoned the volume successfully.
 117   @return Others                - Can not uninstall the protocol interfaces.
 118
 119 **/
 120 EFI_STATUS
 121 FatAbandonVolume (
 122   IN FAT_VOLUME *Volume
 123   )
 124 {
 125   EFI_STATUS  Status;
 126   BOOLEAN     LockedByMe;
 127
 128   //
 129   // Uninstall the protocol interface.
 130   //
 131   if (Volume->Handle != NULL) {
 132     Status = gBS->UninstallMultipleProtocolInterfaces (
 133                     Volume->Handle,
 134                     &gEfiSimpleFileSystemProtocolGuid,
 135                     &Volume->VolumeInterface,
 136                     NULL
 137                     );
 138     if (EFI_ERROR (Status)) {
 139       return Status;
 140     }
 141   }
 142
 143   LockedByMe = FALSE;
 144
 145   //
 146   // Acquire the lock.
 147   // If the caller has already acquired the lock (which
 148   // means we are in the process of some Fat operation),
 149   // we can not acquire again.
 150   //
 151   Status = FatAcquireLockOrFail ();
 152   if (!EFI_ERROR (Status)) {
 153     LockedByMe = TRUE;
 154   }
 155   //
 156   // The volume is still being used. Hence, set error flag for all OFiles still in
 157   // use. In two cases, we could get here. One is EFI_MEDIA_CHANGED, the other is
 158   // EFI_NO_MEDIA.
 159   //
 160   if (Volume->Root != NULL) {
 161     FatSetVolumeError (
 162       Volume->Root,
 163       Volume->BlockIo->Media->MediaPresent ? EFI_MEDIA_CHANGED : EFI_NO_MEDIA
 164       );
 165   }
 166
 167   Volume->Valid = FALSE;
 168
 169   //
 170   // Release the lock.
 171   // If locked by me, this means DriverBindingStop is NOT
 172   // called within an on-going Fat operation, so we should
 173   // take responsibility to cleanup and free the volume.
 174   // Otherwise, the DriverBindingStop is called within an on-going
 175   // Fat operation, we shouldn't check reference, so just let outer
 176   // FatCleanupVolume do the task.
 177   //
 178   if (LockedByMe) {
 179     FatCleanupVolume (Volume, NULL, EFI_SUCCESS, NULL);
 180     FatReleaseLock ();
 181   }
 182
 183   return EFI_SUCCESS;
 184 }
 185
 186 /**
 187
 188   Detects FAT file system on Disk and set relevant fields of Volume.
 189
 190   @param Volume                - The volume structure.
 191
 192   @retval EFI_SUCCESS           - The Fat File System is detected successfully
 193   @retval EFI_UNSUPPORTED       - The volume is not FAT file system.
 194   @retval EFI_VOLUME_CORRUPTED  - The volume is corrupted.
 195
 196 **/
 197 EFI_STATUS
 198 FatOpenDevice (
 199   IN OUT FAT_VOLUME           *Volume
 200   )
 201 {
 202   EFI_STATUS            Status;
 203   UINT32                BlockSize;
 204   UINT32                DirtyMask;
 205   EFI_DISK_IO_PROTOCOL  *DiskIo;
 206   FAT_BOOT_SECTOR       FatBs;
 207   FAT_VOLUME_TYPE       FatType;
 208   UINTN                 RootDirSectors;
 209   UINTN                 FatLba;
 210   UINTN                 RootLba;
 211   UINTN                 FirstClusterLba;
 212   UINTN                 Sectors;
 213   UINTN                 SectorsPerFat;
 214   UINT8                 SectorsPerClusterAlignment;
 215   UINT8                 BlockAlignment;
 216
 217   //
 218   // Read the FAT_BOOT_SECTOR BPB info
 219   // This is the only part of FAT code that uses parent DiskIo,
 220   // Others use FatDiskIo which utilizes a Cache.
 221   //
 222   DiskIo  = Volume->DiskIo;
 223   Status  = DiskIo->ReadDisk (DiskIo, Volume->MediaId, 0, sizeof (FatBs), &FatBs);
 224
 225   if (EFI_ERROR (Status)) {
 226     DEBUG ((EFI_D_INIT, "FatOpenDevice: read of part_lba failed %r\n", Status));
 227     return Status;
 228   }
 229
 230   FatType = FatUndefined;
 231
 232   //
 233   // Use LargeSectors if Sectors is 0
 234   //
 235   Sectors = FatBs.FatBsb.Sectors;
 236   if (Sectors == 0) {
 237     Sectors = FatBs.FatBsb.LargeSectors;
 238   }
 239
 240   SectorsPerFat = FatBs.FatBsb.SectorsPerFat;
 241   if (SectorsPerFat == 0) {
 242     SectorsPerFat = FatBs.FatBse.Fat32Bse.LargeSectorsPerFat;
 243     FatType       = Fat32;
 244   }
 245   //
 246   // Is boot sector a fat sector?
 247   // (Note that so far we only know if the sector is FAT32 or not, we don't
 248   // know if the sector is Fat16 or Fat12 until later when we can compute
 249   // the volume size)
 250   //
 251   if (FatBs.FatBsb.ReservedSectors == 0 || FatBs.FatBsb.NumFats == 0 || Sectors == 0) {
 252     return EFI_UNSUPPORTED;
 253   }
 254
 255   if ((FatBs.FatBsb.SectorSize & (FatBs.FatBsb.SectorSize - 1)) != 0) {
 256     return EFI_UNSUPPORTED;
 257   }
 258
 259   BlockAlignment = (UINT8) HighBitSet32 (FatBs.FatBsb.SectorSize);
 260   if (BlockAlignment > MAX_BLOCK_ALIGNMENT || BlockAlignment < MIN_BLOCK_ALIGNMENT) {
 261     return EFI_UNSUPPORTED;
 262   }
 263
 264   if ((FatBs.FatBsb.SectorsPerCluster & (FatBs.FatBsb.SectorsPerCluster - 1)) != 0) {
 265     return EFI_UNSUPPORTED;
 266   }
 267
 268   SectorsPerClusterAlignment = (UINT8) HighBitSet32 (FatBs.FatBsb.SectorsPerCluster);
 269   if (SectorsPerClusterAlignment > MAX_SECTORS_PER_CLUSTER_ALIGNMENT) {
 270     return EFI_UNSUPPORTED;
 271   }
 272
 273   if (FatBs.FatBsb.Media <= 0xf7 &&
 274       FatBs.FatBsb.Media != 0xf0 &&
 275       FatBs.FatBsb.Media != 0x00 &&
 276       FatBs.FatBsb.Media != 0x01
 277       ) {
 278     return EFI_UNSUPPORTED;
 279   }
 280   //
 281   // Initialize fields the volume information for this FatType
 282   //
 283   if (FatType != Fat32) {
 284     if (FatBs.FatBsb.RootEntries == 0) {
 285       return EFI_UNSUPPORTED;
 286     }
 287     //
 288     // Unpack fat12, fat16 info
 289     //
 290     Volume->RootEntries = FatBs.FatBsb.RootEntries;
 291   } else {
 292     //
 293     // If this is fat32, refuse to mount mirror-disabled volumes
 294     //
 295     if ((SectorsPerFat == 0 || FatBs.FatBse.Fat32Bse.FsVersion != 0) || (FatBs.FatBse.Fat32Bse.ExtendedFlags & 0x80)) {
 296       return EFI_UNSUPPORTED;
 297     }
 298     //
 299     // Unpack fat32 info
 300     //
 301     Volume->RootCluster = FatBs.FatBse.Fat32Bse.RootDirFirstCluster;
 302   }
 303
 304   Volume->NumFats           = FatBs.FatBsb.NumFats;
 305   //
 306   // Compute some fat locations
 307   //
 308   BlockSize                 = FatBs.FatBsb.SectorSize;
 309   RootDirSectors            = ((Volume->RootEntries * sizeof (FAT_DIRECTORY_ENTRY)) + (BlockSize - 1)) / BlockSize;
 310
 311   FatLba                    = FatBs.FatBsb.ReservedSectors;
 312   RootLba                   = FatBs.FatBsb.NumFats * SectorsPerFat + FatLba;
 313   FirstClusterLba           = RootLba + RootDirSectors;
 314
 315   Volume->FatPos            = FatLba * BlockSize;
 316   Volume->FatSize           = SectorsPerFat * BlockSize;
 317
 318   Volume->VolumeSize        = LShiftU64 (Sectors, BlockAlignment);
 319   Volume->RootPos           = LShiftU64 (RootLba, BlockAlignment);
 320   Volume->FirstClusterPos   = LShiftU64 (FirstClusterLba, BlockAlignment);
 321   Volume->MaxCluster        = (Sectors - FirstClusterLba) >> SectorsPerClusterAlignment;
 322   Volume->ClusterAlignment  = (UINT8)(BlockAlignment + SectorsPerClusterAlignment);
 323   Volume->ClusterSize       = (UINTN)1 << (Volume->ClusterAlignment);
 324
 325   //
 326   // If this is not a fat32, determine if it's a fat16 or fat12
 327   //
 328   if (FatType != Fat32) {
 329     if (Volume->MaxCluster >= FAT_MAX_FAT16_CLUSTER) {
 330       return EFI_VOLUME_CORRUPTED;
 331     }
 332
 333     FatType = Volume->MaxCluster < FAT_MAX_FAT12_CLUSTER ? Fat12 : Fat16;
 334     //
 335     // fat12 & fat16 fat-entries are 2 bytes
 336     //
 337     Volume->FatEntrySize = sizeof (UINT16);
 338     DirtyMask            = FAT16_DIRTY_MASK;
 339   } else {
 340     if (Volume->MaxCluster < FAT_MAX_FAT16_CLUSTER) {
 341       return EFI_VOLUME_CORRUPTED;
 342     }
 343     //
 344     // fat32 fat-entries are 4 bytes
 345     //
 346     Volume->FatEntrySize = sizeof (UINT32);
 347     DirtyMask            = FAT32_DIRTY_MASK;
 348   }
 349   //
 350   // Get the DirtyValue and NotDirtyValue
 351   // We should keep the initial value as the NotDirtyValue
 352   // in case the volume is dirty already
 353   //
 354   if (FatType != Fat12) {
 355     Status = FatAccessVolumeDirty (Volume, ReadDisk, &Volume->NotDirtyValue);
 356     if (EFI_ERROR (Status)) {
 357       return Status;
 358     }
 359
 360     Volume->DirtyValue = Volume->NotDirtyValue & DirtyMask;
 361   }
 362   //
 363   // If present, read the fat hint info
 364   //
 365   if (FatType == Fat32) {
 366     Volume->FreeInfoPos = FatBs.FatBse.Fat32Bse.FsInfoSector * BlockSize;
 367     if (FatBs.FatBse.Fat32Bse.FsInfoSector != 0) {
 368       FatDiskIo (Volume, ReadDisk, Volume->FreeInfoPos, sizeof (FAT_INFO_SECTOR), &Volume->FatInfoSector, NULL);
 369       if (Volume->FatInfoSector.Signature == FAT_INFO_SIGNATURE &&
 370           Volume->FatInfoSector.InfoBeginSignature == FAT_INFO_BEGIN_SIGNATURE &&
 371           Volume->FatInfoSector.InfoEndSignature == FAT_INFO_END_SIGNATURE &&
 372           Volume->FatInfoSector.FreeInfo.ClusterCount <= Volume->MaxCluster
 373           ) {
 374         Volume->FreeInfoValid = TRUE;
 375       }
 376     }
 377   }
 378   //
 379   // Just make up a FreeInfo.NextCluster for use by allocate cluster
 380   //
 381   if (FAT_MIN_CLUSTER > Volume->FatInfoSector.FreeInfo.NextCluster ||
 382      Volume->FatInfoSector.FreeInfo.NextCluster > Volume->MaxCluster + 1
 383      ) {
 384     Volume->FatInfoSector.FreeInfo.NextCluster = FAT_MIN_CLUSTER;
 385   }
 386   //
 387   // We are now defining FAT Type
 388   //
 389   Volume->FatType = FatType;
 390   ASSERT (FatType != FatUndefined);
 391
 392   return EFI_SUCCESS;
 393 }