Misc.c

Go to the documentation of this file.

 
#include "Fat.h"
UINT8  mMonthDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
FAT_TASK *
FatCreateTask (
  FAT_IFILE          *IFile,
  EFI_FILE_IO_TOKEN  *Token
  )
{
  FAT_TASK  *Task;
 
  Task = AllocateZeroPool (sizeof (*Task));
  if (Task != NULL) {
    Task->Signature   = FAT_TASK_SIGNATURE;
    Task->IFile       = IFile;
    Task->FileIoToken = Token;
    InitializeListHead (&Task->Subtasks);
    InitializeListHead (&Task->Link);
  }
 
  return Task;
}
 
VOID
FatDestroyTask (
  FAT_TASK  *Task
  )
{
  LIST_ENTRY   *Link;
  FAT_SUBTASK  *Subtask;
 
  Link = GetFirstNode (&Task->Subtasks);
  while (!IsNull (&Task->Subtasks, Link)) {
    Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);
    Link    = FatDestroySubtask (Subtask);
  }
 
  FreePool (Task);
}
 
VOID
FatWaitNonblockingTask (
  FAT_IFILE  *IFile
  )
{
  BOOLEAN  TaskQueueEmpty;
 
  do {
    EfiAcquireLock (&FatTaskLock);
    TaskQueueEmpty = IsListEmpty (&IFile->Tasks);
    EfiReleaseLock (&FatTaskLock);
  } while (!TaskQueueEmpty);
}
 
LIST_ENTRY *
FatDestroySubtask (
  FAT_SUBTASK  *Subtask
  )
{
  LIST_ENTRY  *Link;
 
  gBS->CloseEvent (Subtask->DiskIo2Token.Event);
 
  Link = RemoveEntryList (&Subtask->Link);
  FreePool (Subtask);
 
  return Link;
}
 
EFI_STATUS
FatQueueTask (
  IN FAT_IFILE  *IFile,
  IN FAT_TASK   *Task
  )
{
  EFI_STATUS   Status;
  LIST_ENTRY   *Link;
  LIST_ENTRY   *NextLink;
  FAT_SUBTASK  *Subtask;
 
  //
  // Sometimes the Task doesn't contain any subtasks, signal the event directly.
  //
  if (IsListEmpty (&Task->Subtasks)) {
    Task->FileIoToken->Status = EFI_SUCCESS;
    gBS->SignalEvent (Task->FileIoToken->Event);
    FreePool (Task);
    return EFI_SUCCESS;
  }
 
  EfiAcquireLock (&FatTaskLock);
  InsertTailList (&IFile->Tasks, &Task->Link);
  EfiReleaseLock (&FatTaskLock);
 
  Status = EFI_SUCCESS;
  //
  // Use NextLink to store the next link of the list, because Link might be remove from the
  // doubly-linked list and get freed in the end of current loop.
  //
  // Also, list operation APIs like IsNull() and GetNextNode() are avoided during the loop, since
  // they may check the validity of doubly-linked lists by traversing them. These APIs cannot
  // handle list elements being removed during the traverse.
  //
  for ( Link = GetFirstNode (&Task->Subtasks), NextLink = GetNextNode (&Task->Subtasks, Link)
        ; Link != &Task->Subtasks
        ; Link = NextLink, NextLink = Link->ForwardLink
        )
  {
    Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);
    if (Subtask->Write) {
      Status = IFile->OFile->Volume->DiskIo2->WriteDiskEx (
                                                IFile->OFile->Volume->DiskIo2,
                                                IFile->OFile->Volume->MediaId,
                                                Subtask->Offset,
                                                &Subtask->DiskIo2Token,
                                                Subtask->BufferSize,
                                                Subtask->Buffer
                                                );
    } else {
      Status = IFile->OFile->Volume->DiskIo2->ReadDiskEx (
                                                IFile->OFile->Volume->DiskIo2,
                                                IFile->OFile->Volume->MediaId,
                                                Subtask->Offset,
                                                &Subtask->DiskIo2Token,
                                                Subtask->BufferSize,
                                                Subtask->Buffer
                                                );
    }
 
    if (EFI_ERROR (Status)) {
      break;
    }
  }
 
  if (EFI_ERROR (Status)) {
    EfiAcquireLock (&FatTaskLock);
    //
    // Remove all the remaining subtasks when failure.
    // We shouldn't remove all the tasks because the non-blocking requests have
    // been submitted and cannot be canceled.
    //
    while (!IsNull (&Task->Subtasks, Link)) {
      Subtask = CR (Link, FAT_SUBTASK, Link, FAT_SUBTASK_SIGNATURE);
      Link    = FatDestroySubtask (Subtask);
    }
 
    if (IsListEmpty (&Task->Subtasks)) {
      RemoveEntryList (&Task->Link);
      FreePool (Task);
    } else {
      //
      // If one or more subtasks have been already submitted, set FileIoToken
      // to NULL so that the callback won't signal the event.
      //
      Task->FileIoToken = NULL;
    }
 
    EfiReleaseLock (&FatTaskLock);
  }
 
  return Status;
}
 
EFI_STATUS
FatAccessVolumeDirty (
  IN FAT_VOLUME  *Volume,
  IN IO_MODE     IoMode,
  IN VOID        *DirtyValue
  )
{
  UINTN  WriteCount;
 
  WriteCount = Volume->FatEntrySize;
  return FatDiskIo (Volume, IoMode, Volume->FatPos + WriteCount, WriteCount, DirtyValue, NULL);
}
 
VOID
EFIAPI
FatOnAccessComplete (
  IN  EFI_EVENT  Event,
  IN  VOID       *Context
  )
{
  EFI_STATUS   Status;
  FAT_SUBTASK  *Subtask;
  FAT_TASK     *Task;
 
  //
  // Avoid someone in future breaks the below assumption.
  //
  ASSERT (EfiGetCurrentTpl () == FatTaskLock.Tpl);
 
  Subtask = (FAT_SUBTASK *)Context;
  Task    = Subtask->Task;
  Status  = Subtask->DiskIo2Token.TransactionStatus;
 
  ASSERT (Task->Signature    == FAT_TASK_SIGNATURE);
  ASSERT (Subtask->Signature == FAT_SUBTASK_SIGNATURE);
 
  //
  // Remove the task unconditionally
  //
  FatDestroySubtask (Subtask);
 
  //
  // Task->FileIoToken is NULL which means the task will be ignored (just recycle the subtask and task memory).
  //
  if (Task->FileIoToken != NULL) {
    if (IsListEmpty (&Task->Subtasks) || EFI_ERROR (Status)) {
      Task->FileIoToken->Status = Status;
      gBS->SignalEvent (Task->FileIoToken->Event);
      //
      // Mark Task->FileIoToken to NULL so that the subtasks belonging to the task will be ignored.
      //
      Task->FileIoToken = NULL;
    }
  }
 
  if (IsListEmpty (&Task->Subtasks)) {
    RemoveEntryList (&Task->Link);
    FreePool (Task);
  }
}
 
EFI_STATUS
FatDiskIo (
  IN     FAT_VOLUME  *Volume,
  IN     IO_MODE     IoMode,
  IN     UINT64      Offset,
  IN     UINTN       BufferSize,
  IN OUT VOID        *Buffer,
  IN     FAT_TASK    *Task
  )
{
  EFI_STATUS            Status;
  EFI_DISK_IO_PROTOCOL  *DiskIo;
  EFI_DISK_READ         IoFunction;
  FAT_SUBTASK           *Subtask;
 
  //
  // Verify the IO is in devices range
  //
  Status = EFI_VOLUME_CORRUPTED;
  if (Offset + BufferSize <= Volume->VolumeSize) {
    if (CACHE_ENABLED (IoMode)) {
      //
      // Access cache
      //
      Status = FatAccessCache (Volume, CACHE_TYPE (IoMode), RAW_ACCESS (IoMode), Offset, BufferSize, Buffer, Task);
    } else {
      //
      // Access disk directly
      //
      if (Task == NULL) {
        //
        // Blocking access
        //
        DiskIo     = Volume->DiskIo;
        IoFunction = (IoMode == ReadDisk) ? DiskIo->ReadDisk : DiskIo->WriteDisk;
        Status     = IoFunction (DiskIo, Volume->MediaId, Offset, BufferSize, Buffer);
      } else {
        //
        // Non-blocking access
        //
        Subtask = AllocateZeroPool (sizeof (*Subtask));
        if (Subtask == NULL) {
          Status = EFI_OUT_OF_RESOURCES;
        } else {
          Subtask->Signature  = FAT_SUBTASK_SIGNATURE;
          Subtask->Task       = Task;
          Subtask->Write      = (BOOLEAN)(IoMode == WriteDisk);
          Subtask->Offset     = Offset;
          Subtask->Buffer     = Buffer;
          Subtask->BufferSize = BufferSize;
          Status              = gBS->CreateEvent (
                                       EVT_NOTIFY_SIGNAL,
                                       TPL_NOTIFY,
                                       FatOnAccessComplete,
                                       Subtask,
                                       &Subtask->DiskIo2Token.Event
                                       );
          if (!EFI_ERROR (Status)) {
            InsertTailList (&Task->Subtasks, &Subtask->Link);
          } else {
            FreePool (Subtask);
          }
        }
      }
    }
  }
 
  if (EFI_ERROR (Status)) {
    Volume->DiskError = TRUE;
    DEBUG ((DEBUG_ERROR, "FatDiskIo: error %r\n", Status));
  }
 
  return Status;
}
 
VOID
FatAcquireLock (
  VOID
  )
{
  EfiAcquireLock (&FatFsLock);
}
 
EFI_STATUS
FatAcquireLockOrFail (
  VOID
  )
{
  return EfiAcquireLockOrFail (&FatFsLock);
}
 
VOID
FatReleaseLock (
  VOID
  )
{
  EfiReleaseLock (&FatFsLock);
}
 
VOID
FatFreeDirEnt (
  IN FAT_DIRENT  *DirEnt
  )
{
  if (DirEnt->FileString != NULL) {
    FreePool (DirEnt->FileString);
  }
 
  FreePool (DirEnt);
}
 
VOID
FatFreeVolume (
  IN FAT_VOLUME  *Volume
  )
{
  //
  // Free disk cache
  //
  if (Volume->CacheBuffer != NULL) {
    FreePool (Volume->CacheBuffer);
  }
 
  //
  // Free directory cache
  //
  FatCleanupODirCache (Volume);
  FreePool (Volume);
}
 
VOID
FatEfiTimeToFatTime (
  IN  EFI_TIME       *ETime,
  OUT FAT_DATE_TIME  *FTime
  )
{
  //
  // ignores timezone info in source ETime
  //
  if (ETime->Year > 1980) {
    FTime->Date.Year = (UINT16)(ETime->Year - 1980);
  }
 
  if (ETime->Year >= 1980 + FAT_MAX_YEAR_FROM_1980) {
    FTime->Date.Year = FAT_MAX_YEAR_FROM_1980;
  }
 
  FTime->Date.Month        = ETime->Month;
  FTime->Date.Day          = ETime->Day;
  FTime->Time.Hour         = ETime->Hour;
  FTime->Time.Minute       = ETime->Minute;
  FTime->Time.DoubleSecond = (UINT16)(ETime->Second / 2);
}
 
VOID
FatFatTimeToEfiTime (
  IN  FAT_DATE_TIME  *FTime,
  OUT EFI_TIME       *ETime
  )
{
  ETime->Year       = (UINT16)(FTime->Date.Year + 1980);
  ETime->Month      = (UINT8)FTime->Date.Month;
  ETime->Day        = (UINT8)FTime->Date.Day;
  ETime->Hour       = (UINT8)FTime->Time.Hour;
  ETime->Minute     = (UINT8)FTime->Time.Minute;
  ETime->Second     = (UINT8)(FTime->Time.DoubleSecond * 2);
  ETime->Nanosecond = 0;
  ETime->TimeZone   = EFI_UNSPECIFIED_TIMEZONE;
  ETime->Daylight   = 0;
}
 
VOID
FatGetCurrentFatTime (
  OUT FAT_DATE_TIME  *FatNow
  )
{
  EFI_STATUS  Status;
  EFI_TIME    Now;
 
  Status = gRT->GetTime (&Now, NULL);
  if (!EFI_ERROR (Status)) {
    FatEfiTimeToFatTime (&Now, FatNow);
  } else {
    ZeroMem (&Now, sizeof (EFI_TIME));
    Now.Year  = 1980;
    Now.Month = 1;
    Now.Day   = 1;
    FatEfiTimeToFatTime (&Now, FatNow);
  }
}
 
BOOLEAN
FatIsValidTime (
  IN EFI_TIME  *Time
  )
{
  UINTN    Day;
  BOOLEAN  ValidTime;
 
  ValidTime = TRUE;
 
  //
  // Check the fields for range problems
  // Fat can only support from 1980
  //
  if ((Time->Year < 1980) ||
      (Time->Month < 1) ||
      (Time->Month > 12) ||
      (Time->Day < 1) ||
      (Time->Day > 31) ||
      (Time->Hour > 23) ||
      (Time->Minute > 59) ||
      (Time->Second > 59) ||
      (Time->Nanosecond > 999999999)
      )
  {
    ValidTime = FALSE;
  } else {
    //
    // Perform a more specific check of the day of the month
    //
    Day = mMonthDays[Time->Month - 1];
    if ((Time->Month == 2) && IS_LEAP_YEAR (Time->Year)) {
      Day += 1;
      //
      // 1 extra day this month
      //
    }
 
    if (Time->Day > Day) {
      ValidTime = FALSE;
    }
  }
 
  return ValidTime;
}