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

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

/** @file\r
  Miscellaneous functions.\r
\r
Copyright (c) 2005 - 2018, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
\r
**/\r
\r
#include "Fat.h"\r
UINT8  mMonthDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };\r
\r
/**\r
\r
  Create the task\r
\r
  @param  IFile                 - The instance of the open file.\r
  @param  Token                 - A pointer to the token associated with the transaction.\r
\r
  @return FAT_TASK *            - Return the task instance.\r
\r
**/\r
FAT_TASK *\r
FatCreateTask (\r
  FAT_IFILE           *IFile,\r
  EFI_FILE_IO_TOKEN   *Token\r
  )\r
{\r
  FAT_TASK            *Task;\r
\r
  Task = AllocateZeroPool (sizeof (*Task));\r
  if (Task != NULL) {\r
    Task->Signature   = FAT_TASK_SIGNATURE;\r
    Task->IFile       = IFile;\r
    Task->FileIoToken = Token;\r
    InitializeListHead (&Task->Subtasks);\r
    InitializeListHead (&Task->Link);\r
  }\r
  return Task;\r
}\r
\r
/**\r
\r
  Destroy the task.\r
\r
  @param  Task                  - The task to be destroyed.\r
\r
**/\r
VOID\r
FatDestroyTask (\r
  FAT_TASK            *Task\r
  )\r
{\r
  LIST_ENTRY          *Link;\r
  FAT_SUBTASK         *Subtask;\r
\r
  Link = GetFirstNode (&Task->Subtasks);\r
  while (!IsNull (&Task->Subtasks, Link)) {\r
    Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);\r
    Link = FatDestroySubtask (Subtask);\r
  }\r
  FreePool (Task);\r
}\r
\r
/**\r
\r
  Wait all non-blocking requests complete.\r
\r
  @param  IFile                 - The instance of the open file.\r
\r
**/\r
VOID\r
FatWaitNonblockingTask (\r
  FAT_IFILE           *IFile\r
  )\r
{\r
  BOOLEAN             TaskQueueEmpty;\r
\r
  do {\r
    EfiAcquireLock (&FatTaskLock);\r
    TaskQueueEmpty = IsListEmpty (&IFile->Tasks);\r
    EfiReleaseLock (&FatTaskLock);\r
  } while (!TaskQueueEmpty);\r
}\r
\r
/**\r
\r
  Remove the subtask from subtask list.\r
\r
  @param  Subtask               - The subtask to be removed.\r
\r
  @return LIST_ENTRY *          - The next node in the list.\r
\r
**/\r
LIST_ENTRY *\r
FatDestroySubtask (\r
  FAT_SUBTASK         *Subtask\r
  )\r
{\r
  LIST_ENTRY          *Link;\r
\r
  gBS->CloseEvent (Subtask->DiskIo2Token.Event);\r
\r
  Link = RemoveEntryList (&Subtask->Link);\r
  FreePool (Subtask);\r
\r
  return Link;\r
}\r
\r
/**\r
\r
  Execute the task.\r
\r
  @param  IFile                 - The instance of the open file.\r
  @param  Task                  - The task to be executed.\r
\r
  @retval EFI_SUCCESS           - The task was executed sucessfully.\r
  @return other                 - An error occurred when executing the task.\r
\r
**/\r
EFI_STATUS\r
FatQueueTask (\r
  IN FAT_IFILE        *IFile,\r
  IN FAT_TASK         *Task\r
  )\r
{\r
  EFI_STATUS          Status;\r
  LIST_ENTRY          *Link;\r
  LIST_ENTRY          *NextLink;\r
  FAT_SUBTASK         *Subtask;\r
\r
  //\r
  // Sometimes the Task doesn't contain any subtasks, signal the event directly.\r
  //\r
  if (IsListEmpty (&Task->Subtasks)) {\r
    Task->FileIoToken->Status = EFI_SUCCESS;\r
    gBS->SignalEvent (Task->FileIoToken->Event);\r
    FreePool (Task);\r
    return EFI_SUCCESS;\r
  }\r
\r
  EfiAcquireLock (&FatTaskLock);\r
  InsertTailList (&IFile->Tasks, &Task->Link);\r
  EfiReleaseLock (&FatTaskLock);\r
\r
  Status = EFI_SUCCESS;\r
  //\r
  // Use NextLink to store the next link of the list, because Link might be remove from the\r
  // doubly-linked list and get freed in the end of current loop.\r
  //\r
  // Also, list operation APIs like IsNull() and GetNextNode() are avoided during the loop, since\r
  // they may check the validity of doubly-linked lists by traversing them. These APIs cannot\r
  // handle list elements being removed during the traverse.\r
  //\r
  for ( Link = GetFirstNode (&Task->Subtasks), NextLink = GetNextNode (&Task->Subtasks, Link)\r
      ; Link != &Task->Subtasks\r
      ; Link = NextLink, NextLink = Link->ForwardLink\r
      ) {\r
    Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);\r
    if (Subtask->Write) {\r
\r
      Status = IFile->OFile->Volume->DiskIo2->WriteDiskEx (\r
                                                IFile->OFile->Volume->DiskIo2,\r
                                                IFile->OFile->Volume->MediaId,\r
                                                Subtask->Offset,\r
                                                &Subtask->DiskIo2Token,\r
                                                Subtask->BufferSize,\r
                                                Subtask->Buffer\r
                                                );\r
    } else {\r
      Status = IFile->OFile->Volume->DiskIo2->ReadDiskEx (\r
                                                IFile->OFile->Volume->DiskIo2,\r
                                                IFile->OFile->Volume->MediaId,\r
                                                Subtask->Offset,\r
                                                &Subtask->DiskIo2Token,\r
                                                Subtask->BufferSize,\r
                                                Subtask->Buffer\r
                                                );\r
    }\r
    if (EFI_ERROR (Status)) {\r
      break;\r
    }\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    EfiAcquireLock (&FatTaskLock);\r
    //\r
    // Remove all the remaining subtasks when failure.\r
    // We shouldn't remove all the tasks because the non-blocking requests have\r
    // been submitted and cannot be canceled.\r
    //\r
    while (!IsNull (&Task->Subtasks, Link)) {\r
      Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);\r
      Link = FatDestroySubtask (Subtask);\r
    }\r
\r
    if (IsListEmpty (&Task->Subtasks)) {\r
      RemoveEntryList (&Task->Link);\r
      FreePool (Task);\r
    } else {\r
      //\r
      // If one or more subtasks have been already submitted, set FileIoToken\r
      // to NULL so that the callback won't signal the event.\r
      //\r
      Task->FileIoToken = NULL;\r
    }\r
\r
    EfiReleaseLock (&FatTaskLock);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
\r
  Set the volume as dirty or not.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  IoMode                - The access mode.\r
  @param  DirtyValue            - Set the volume as dirty or not.\r
\r
  @retval EFI_SUCCESS           - Set the new FAT entry value sucessfully.\r
  @return other                 - An error occurred when operation the FAT entries.\r
\r
**/\r
EFI_STATUS\r
FatAccessVolumeDirty (\r
  IN FAT_VOLUME       *Volume,\r
  IN IO_MODE          IoMode,\r
  IN VOID             *DirtyValue\r
  )\r
{\r
  UINTN WriteCount;\r
\r
  WriteCount = Volume->FatEntrySize;\r
  return FatDiskIo (Volume, IoMode, Volume->FatPos + WriteCount, WriteCount, DirtyValue, NULL);\r
}\r
\r
/**\r
  Invoke a notification event.\r
\r
  @param  Event                 Event whose notification function is being invoked.\r
  @param  Context               The pointer to the notification function's context,\r
                                which is implementation-dependent.\r
\r
**/\r
VOID\r
EFIAPI\r
FatOnAccessComplete (\r
  IN  EFI_EVENT                Event,\r
  IN  VOID                     *Context\r
  )\r
{\r
  EFI_STATUS             Status;\r
  FAT_SUBTASK            *Subtask;\r
  FAT_TASK               *Task;\r
\r
  //\r
  // Avoid someone in future breaks the below assumption.\r
  //\r
  ASSERT (EfiGetCurrentTpl () == FatTaskLock.Tpl);\r
\r
  Subtask = (FAT_SUBTASK *) Context;\r
  Task    = Subtask->Task;\r
  Status  = Subtask->DiskIo2Token.TransactionStatus;\r
\r
  ASSERT (Task->Signature    == FAT_TASK_SIGNATURE);\r
  ASSERT (Subtask->Signature == FAT_SUBTASK_SIGNATURE);\r
\r
  //\r
  // Remove the task unconditionally\r
  //\r
  FatDestroySubtask (Subtask);\r
\r
  //\r
  // Task->FileIoToken is NULL which means the task will be ignored (just recycle the subtask and task memory).\r
  //\r
  if (Task->FileIoToken != NULL) {\r
    if (IsListEmpty (&Task->Subtasks) || EFI_ERROR (Status)) {\r
      Task->FileIoToken->Status = Status;\r
      gBS->SignalEvent (Task->FileIoToken->Event);\r
      //\r
      // Mark Task->FileIoToken to NULL so that the subtasks belonging to the task will be ignored.\r
      //\r
      Task->FileIoToken = NULL;\r
    }\r
  }\r
\r
  if (IsListEmpty (&Task->Subtasks)) {\r
    RemoveEntryList (&Task->Link);\r
    FreePool (Task);\r
  }\r
}\r
\r
/**\r
\r
  General disk access function.\r
\r
  @param  Volume                - FAT file system volume.\r
  @param  IoMode                - The access mode (disk read/write or cache access).\r
  @param  Offset                - The starting byte offset to read from.\r
  @param  BufferSize            - Size of Buffer.\r
  @param  Buffer                - Buffer containing read data.\r
  @param  Task                    point to task instance.\r
\r
  @retval EFI_SUCCESS           - The operation is performed successfully.\r
  @retval EFI_VOLUME_CORRUPTED  - The accesss is\r
  @return Others                - The status of read/write the disk\r
\r
**/\r
EFI_STATUS\r
FatDiskIo (\r
  IN     FAT_VOLUME       *Volume,\r
  IN     IO_MODE          IoMode,\r
  IN     UINT64           Offset,\r
  IN     UINTN            BufferSize,\r
  IN OUT VOID             *Buffer,\r
  IN     FAT_TASK         *Task\r
  )\r
{\r
  EFI_STATUS            Status;\r
  EFI_DISK_IO_PROTOCOL  *DiskIo;\r
  EFI_DISK_READ         IoFunction;\r
  FAT_SUBTASK           *Subtask;\r
\r
  //\r
  // Verify the IO is in devices range\r
  //\r
  Status = EFI_VOLUME_CORRUPTED;\r
  if (Offset + BufferSize <= Volume->VolumeSize) {\r
    if (CACHE_ENABLED (IoMode)) {\r
      //\r
      // Access cache\r
      //\r
      Status = FatAccessCache (Volume, CACHE_TYPE (IoMode), RAW_ACCESS (IoMode), Offset, BufferSize, Buffer, Task);\r
    } else {\r
      //\r
      // Access disk directly\r
      //\r
      if (Task == NULL) {\r
        //\r
        // Blocking access\r
        //\r
        DiskIo      = Volume->DiskIo;\r
        IoFunction  = (IoMode == ReadDisk) ? DiskIo->ReadDisk : DiskIo->WriteDisk;\r
        Status      = IoFunction (DiskIo, Volume->MediaId, Offset, BufferSize, Buffer);\r
      } else {\r
        //\r
        // Non-blocking access\r
        //\r
        Subtask = AllocateZeroPool (sizeof (*Subtask));\r
        if (Subtask == NULL) {\r
          Status        = EFI_OUT_OF_RESOURCES;\r
        } else {\r
          Subtask->Signature  = FAT_SUBTASK_SIGNATURE;\r
          Subtask->Task       = Task;\r
          Subtask->Write      = (BOOLEAN) (IoMode == WriteDisk);\r
          Subtask->Offset     = Offset;\r
          Subtask->Buffer     = Buffer;\r
          Subtask->BufferSize = BufferSize;\r
          Status = gBS->CreateEvent (\r
                          EVT_NOTIFY_SIGNAL,\r
                          TPL_NOTIFY,\r
                          FatOnAccessComplete,\r
                          Subtask,\r
                          &Subtask->DiskIo2Token.Event\r
                          );\r
          if (!EFI_ERROR (Status)) {\r
            InsertTailList (&Task->Subtasks, &Subtask->Link);\r
          } else {\r
            FreePool (Subtask);\r
          }\r
        }\r
      }\r
    }\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    Volume->DiskError = TRUE;\r
    DEBUG ((EFI_D_ERROR, "FatDiskIo: error %r\n", Status));\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
\r
  Lock the volume.\r
\r
**/\r
VOID\r
FatAcquireLock (\r
  VOID\r
  )\r
{\r
  EfiAcquireLock (&FatFsLock);\r
}\r
\r
/**\r
\r
  Lock the volume.\r
  If the lock is already in the acquired state, then EFI_ACCESS_DENIED is returned.\r
  Otherwise, EFI_SUCCESS is returned.\r
\r
  @retval EFI_SUCCESS           - The volume is locked.\r
  @retval EFI_ACCESS_DENIED     - The volume could not be locked because it is already locked.\r
\r
**/\r
EFI_STATUS\r
FatAcquireLockOrFail (\r
  VOID\r
  )\r
{\r
  return EfiAcquireLockOrFail (&FatFsLock);\r
}\r
\r
/**\r
\r
  Unlock the volume.\r
\r
**/\r
VOID\r
FatReleaseLock (\r
  VOID\r
  )\r
{\r
  EfiReleaseLock (&FatFsLock);\r
}\r
\r
/**\r
\r
  Free directory entry.\r
\r
  @param  DirEnt                - The directory entry to be freed.\r
\r
**/\r
VOID\r
FatFreeDirEnt (\r
  IN FAT_DIRENT       *DirEnt\r
  )\r
{\r
  if (DirEnt->FileString != NULL) {\r
    FreePool (DirEnt->FileString);\r
  }\r
\r
  FreePool (DirEnt);\r
}\r
\r
/**\r
\r
  Free volume structure (including the contents of directory cache and disk cache).\r
\r
  @param  Volume                - The volume structure to be freed.\r
\r
**/\r
VOID\r
FatFreeVolume (\r
  IN FAT_VOLUME       *Volume\r
  )\r
{\r
  //\r
  // Free disk cache\r
  //\r
  if (Volume->CacheBuffer != NULL) {\r
    FreePool (Volume->CacheBuffer);\r
  }\r
  //\r
  // Free directory cache\r
  //\r
  FatCleanupODirCache (Volume);\r
  FreePool (Volume);\r
}\r
\r
/**\r
\r
  Translate EFI time to FAT time.\r
\r
  @param  ETime                 - The time of EFI_TIME.\r
  @param  FTime                 - The time of FAT_DATE_TIME.\r
\r
**/\r
VOID\r
FatEfiTimeToFatTime (\r
  IN  EFI_TIME        *ETime,\r
  OUT FAT_DATE_TIME   *FTime\r
  )\r
{\r
  //\r
  // ignores timezone info in source ETime\r
  //\r
  if (ETime->Year > 1980) {\r
    FTime->Date.Year = (UINT16) (ETime->Year - 1980);\r
  }\r
\r
  if (ETime->Year >= 1980 + FAT_MAX_YEAR_FROM_1980) {\r
    FTime->Date.Year = FAT_MAX_YEAR_FROM_1980;\r
  }\r
\r
  FTime->Date.Month         = ETime->Month;\r
  FTime->Date.Day           = ETime->Day;\r
  FTime->Time.Hour          = ETime->Hour;\r
  FTime->Time.Minute        = ETime->Minute;\r
  FTime->Time.DoubleSecond  = (UINT16) (ETime->Second / 2);\r
}\r
\r
/**\r
\r
  Translate Fat time to EFI time.\r
\r
  @param  FTime                 - The time of FAT_DATE_TIME.\r
  @param  ETime                 - The time of EFI_TIME..\r
\r
**/\r
VOID\r
FatFatTimeToEfiTime (\r
  IN  FAT_DATE_TIME     *FTime,\r
  OUT EFI_TIME          *ETime\r
  )\r
{\r
  ETime->Year       = (UINT16) (FTime->Date.Year + 1980);\r
  ETime->Month      = (UINT8) FTime->Date.Month;\r
  ETime->Day        = (UINT8) FTime->Date.Day;\r
  ETime->Hour       = (UINT8) FTime->Time.Hour;\r
  ETime->Minute     = (UINT8) FTime->Time.Minute;\r
  ETime->Second     = (UINT8) (FTime->Time.DoubleSecond * 2);\r
  ETime->Nanosecond = 0;\r
  ETime->TimeZone   = EFI_UNSPECIFIED_TIMEZONE;\r
  ETime->Daylight   = 0;\r
}\r
\r
/**\r
\r
  Get Current FAT time.\r
\r
  @param  FatNow                - Current FAT time.\r
\r
**/\r
VOID\r
FatGetCurrentFatTime (\r
  OUT FAT_DATE_TIME   *FatNow\r
  )\r
{\r
  EFI_STATUS Status;\r
  EFI_TIME   Now;\r
\r
  Status = gRT->GetTime (&Now, NULL);\r
  if (!EFI_ERROR (Status)) {\r
    FatEfiTimeToFatTime (&Now, FatNow);\r
  } else {\r
    ZeroMem (&Now, sizeof (EFI_TIME));\r
    Now.Year = 1980;\r
    Now.Month = 1;\r
    Now.Day = 1;\r
    FatEfiTimeToFatTime (&Now, FatNow);\r
  }\r
}\r
\r
/**\r
\r
  Check whether a time is valid.\r
\r
  @param  Time                  - The time of EFI_TIME.\r
\r
  @retval TRUE                  - The time is valid.\r
  @retval FALSE                 - The time is not valid.\r
\r
**/\r
BOOLEAN\r
FatIsValidTime (\r
  IN EFI_TIME         *Time\r
  )\r
{\r
  UINTN         Day;\r
  BOOLEAN       ValidTime;\r
\r
  ValidTime = TRUE;\r
\r
  //\r
  // Check the fields for range problems\r
  // Fat can only support from 1980\r
  //\r
  if (Time->Year < 1980 ||\r
      Time->Month < 1 ||\r
      Time->Month > 12 ||\r
      Time->Day < 1 ||\r
      Time->Day > 31 ||\r
      Time->Hour > 23 ||\r
      Time->Minute > 59 ||\r
      Time->Second > 59 ||\r
      Time->Nanosecond > 999999999\r
      ) {\r
\r
    ValidTime = FALSE;\r
\r
  } else {\r
    //\r
    // Perform a more specific check of the day of the month\r
    //\r
    Day = mMonthDays[Time->Month - 1];\r
    if (Time->Month == 2 && IS_LEAP_YEAR (Time->Year)) {\r
      Day += 1;\r
      //\r
      // 1 extra day this month\r
      //\r
    }\r
    if (Time->Day > Day) {\r
      ValidTime = FALSE;\r
    }\r
  }\r
\r
  return ValidTime;\r
}\r