Fix IA32 build failure: Use MultU64x32 for 64bit * 32bit.

[mirror_edk2.git] / ArmPlatformPkg / FileSystem / BootMonFs / BootMonFsOpenClose.c

/** @file\r
*\r
*  Copyright (c) 2012-2014, ARM Limited. All rights reserved.\r
*\r
*  This program and the accompanying materials\r
*  are licensed and made available under the terms and conditions of the BSD License\r
*  which accompanies this distribution.  The full text of the license may be found at\r
*  http://opensource.org/licenses/bsd-license.php\r
*\r
*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
*\r
**/\r
\r
#include <Library/PathLib.h>\r
#include "BootMonFsInternal.h"\r
\r
// Clear a file's image description on storage media:\r
// UEFI allows you to seek past the end of a file, a subsequent write will grow\r
// the file. It does not specify how space between the former end of the file\r
// and the beginning of the write should be filled. It's therefore possible that\r
// BootMonFs metadata, that comes after the end of a file, could be left there\r
// and wrongly detected by BootMonFsImageInBlock.\r
STATIC\r
EFI_STATUS\r
InvalidateImageDescription (\r
  IN  BOOTMON_FS_FILE  *File\r
  )\r
{\r
  EFI_DISK_IO_PROTOCOL   *DiskIo;\r
  EFI_BLOCK_IO_PROTOCOL  *BlockIo;\r
  UINT32                  MediaId;\r
  VOID                   *Buffer;\r
  EFI_STATUS              Status;\r
\r
  DiskIo = File->Instance->DiskIo;\r
  BlockIo = File->Instance->BlockIo;\r
  MediaId = BlockIo->Media->MediaId;\r
\r
  Buffer = AllocateZeroPool (sizeof (HW_IMAGE_DESCRIPTION));\r
\r
  if (Buffer == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Status = DiskIo->WriteDisk (DiskIo,\r
                    MediaId,\r
                    File->HwDescAddress,\r
                    sizeof (HW_IMAGE_DESCRIPTION),\r
                    Buffer\r
                    );\r
\r
  FreePool(Buffer);\r
\r
  return Status;\r
}\r
\r
/**\r
  Write the description of a file to storage media.\r
\r
  This function uses DiskIo to write to the media, so call BlockIo->FlushBlocks()\r
  after calling it to ensure the data are written on the media.\r
\r
  @param[in]  File       Description of the file whose description on the\r
                         storage media has to be updated.\r
  @param[in]  FileName   Name of the file. Its length is assumed to be\r
                         lower than MAX_NAME_LENGTH.\r
  @param[in]  DataSize   Number of data bytes of the file.\r
  @param[in]  FileStart  File's starting position on media. FileStart must\r
                         be aligned to the media's block size.\r
\r
  @retval  EFI_WRITE_PROTECTED  The device cannot be written to.\r
  @retval  EFI_DEVICE_ERROR     The device reported an error while performing\r
                                the write operation.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
WriteFileDescription (\r
  IN  BOOTMON_FS_FILE  *File,\r
  IN  CHAR8            *FileName,\r
  IN  UINT32            DataSize,\r
  IN  UINT64            FileStart\r
  )\r
{\r
  EFI_STATUS            Status;\r
  EFI_DISK_IO_PROTOCOL  *DiskIo;\r
  UINTN                 BlockSize;\r
  UINT32                FileSize;\r
  HW_IMAGE_DESCRIPTION  *Description;\r
\r
  DiskIo    = File->Instance->DiskIo;\r
  BlockSize = File->Instance->BlockIo->Media->BlockSize;\r
  ASSERT (FileStart % BlockSize == 0);\r
\r
  //\r
  // Construct the file description\r
  //\r
\r
  FileSize = DataSize + sizeof (HW_IMAGE_DESCRIPTION);\r
  Description = &File->HwDescription;\r
  Description->Attributes = 1;\r
  Description->BlockStart = FileStart / BlockSize;\r
  Description->BlockEnd   = Description->BlockStart + (FileSize / BlockSize);\r
  AsciiStrCpy (Description->Footer.Filename, FileName);\r
\r
#ifdef MDE_CPU_ARM\r
  Description->Footer.Offset  = HW_IMAGE_FOOTER_OFFSET;\r
  Description->Footer.Version = HW_IMAGE_FOOTER_VERSION;\r
#else\r
  Description->Footer.Offset  = HW_IMAGE_FOOTER_OFFSET2;\r
  Description->Footer.Version = HW_IMAGE_FOOTER_VERSION2;\r
#endif\r
  Description->Footer.FooterSignature1 = HW_IMAGE_FOOTER_SIGNATURE_1;\r
  Description->Footer.FooterSignature2 = HW_IMAGE_FOOTER_SIGNATURE_2;\r
  Description->RegionCount = 1;\r
  Description->Region[0].Checksum = 0;\r
  Description->Region[0].Offset = Description->BlockStart * BlockSize;\r
  Description->Region[0].Size = DataSize;\r
\r
  Status = BootMonFsComputeFooterChecksum (Description);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  File->HwDescAddress = ((Description->BlockEnd + 1) * BlockSize) - sizeof (HW_IMAGE_DESCRIPTION);\r
\r
  // Update the file description on the media\r
  Status = DiskIo->WriteDisk (\r
                    DiskIo,\r
                    File->Instance->Media->MediaId,\r
                    File->HwDescAddress,\r
                    sizeof (HW_IMAGE_DESCRIPTION),\r
                    Description\r
                    );\r
  ASSERT_EFI_ERROR (Status);\r
\r
  return Status;\r
}\r
\r
// Find a space on media for a file that has not yet been flushed to disk.\r
// Just returns the first space that's big enough.\r
// This function could easily be adapted to:\r
// - Find space for moving an existing file that has outgrown its space\r
//   (We do not currently move files, just return EFI_VOLUME_FULL)\r
// - Find space for a fragment of a file that has outgrown its space\r
//   (We do not currently fragment files - it's not clear whether fragmentation\r
//    is actually part of BootMonFs as there is no spec)\r
// - Be more clever about finding space (choosing the largest or smallest\r
//   suitable space)\r
// Parameters:\r
// File - the new (not yet flushed) file for which we need to find space.\r
// FileStart - the position on media of the file (in bytes).\r
STATIC\r
EFI_STATUS\r
BootMonFsFindSpaceForNewFile (\r
  IN  BOOTMON_FS_FILE     *File,\r
  IN  UINT64              FileSize,\r
  OUT UINT64              *FileStart\r
  )\r
{\r
  LIST_ENTRY              *FileLink;\r
  BOOTMON_FS_FILE         *RootFile;\r
  BOOTMON_FS_FILE         *FileEntry;\r
  UINTN                    BlockSize;\r
  EFI_BLOCK_IO_MEDIA      *Media;\r
\r
  Media = File->Instance->BlockIo->Media;\r
  BlockSize = Media->BlockSize;\r
  RootFile = File->Instance->RootFile;\r
\r
  // This function must only be called for file which has not been flushed into\r
  // Flash yet\r
  ASSERT (File->HwDescription.RegionCount == 0);\r
\r
  *FileStart = 0;\r
  // Go through all the files in the list\r
  for (FileLink = GetFirstNode (&RootFile->Link);\r
         !IsNull (&RootFile->Link, FileLink);\r
         FileLink = GetNextNode (&RootFile->Link, FileLink)\r
         )\r
  {\r
    FileEntry = BOOTMON_FS_FILE_FROM_LINK_THIS (FileLink);\r
    // Skip files that aren't on disk yet\r
    if (FileEntry->HwDescription.RegionCount == 0) {\r
      continue;\r
    }\r
\r
    // If the free space preceding the file is big enough to contain the new\r
    // file then use it!\r
    if (((FileEntry->HwDescription.BlockStart * BlockSize) - *FileStart)\r
        >= FileSize) {\r
      // The file list must be in disk-order\r
      RemoveEntryList (&File->Link);\r
      File->Link.BackLink = FileLink->BackLink;\r
      File->Link.ForwardLink = FileLink;\r
      FileLink->BackLink->ForwardLink = &File->Link;\r
      FileLink->BackLink = &File->Link;\r
\r
      return EFI_SUCCESS;\r
    } else {\r
      *FileStart = (FileEntry->HwDescription.BlockEnd + 1) * BlockSize;\r
    }\r
  }\r
  // See if there's space after the last file\r
  if ((((Media->LastBlock + 1) * BlockSize) - *FileStart) >= FileSize) {\r
    return EFI_SUCCESS;\r
  } else {\r
    return EFI_VOLUME_FULL;\r
  }\r
}\r
\r
// Free the resources in the file's Region list.\r
STATIC\r
VOID\r
FreeFileRegions (\r
  IN  BOOTMON_FS_FILE *File\r
  )\r
{\r
  LIST_ENTRY              *RegionToFlushLink;\r
  BOOTMON_FS_FILE_REGION  *Region;\r
\r
  RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);\r
  while (!IsNull (&File->RegionToFlushLink, RegionToFlushLink)) {\r
    // Repeatedly remove the first node from the list and free its resources.\r
    Region = (BOOTMON_FS_FILE_REGION *) RegionToFlushLink;\r
    RemoveEntryList (RegionToFlushLink);\r
    FreePool (Region->Buffer);\r
    FreePool (Region);\r
\r
    RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);\r
  }\r
}\r
\r
/**\r
  Flush all modified data associated with a file to a device.\r
\r
  @param[in]  This  A pointer to the EFI_FILE_PROTOCOL instance that is the\r
                    file handle to flush.\r
\r
  @retval  EFI_SUCCESS            The data was flushed.\r
  @retval  EFI_ACCESS_DENIED      The file was opened read-only.\r
  @retval  EFI_DEVICE_ERROR       The device reported an error.\r
  @retval  EFI_VOLUME_FULL        The volume is full.\r
  @retval  EFI_OUT_OF_RESOURCES   Not enough resources were available to flush the data.\r
  @retval  EFI_INVALID_PARAMETER  At least one of the parameters is invalid.\r
\r
**/\r
EFIAPI\r
EFI_STATUS\r
BootMonFsFlushFile (\r
  IN EFI_FILE_PROTOCOL  *This\r
  )\r
{\r
  EFI_STATUS               Status;\r
  BOOTMON_FS_INSTANCE     *Instance;\r
  EFI_FILE_INFO           *Info;\r
  EFI_BLOCK_IO_PROTOCOL   *BlockIo;\r
  EFI_BLOCK_IO_MEDIA      *Media;\r
  EFI_DISK_IO_PROTOCOL    *DiskIo;\r
  UINTN                    BlockSize;\r
  CHAR8                    AsciiFileName[MAX_NAME_LENGTH];\r
  LIST_ENTRY              *RegionToFlushLink;\r
  BOOTMON_FS_FILE         *File;\r
  BOOTMON_FS_FILE         *NextFile;\r
  BOOTMON_FS_FILE_REGION  *Region;\r
  LIST_ENTRY              *FileLink;\r
  UINTN                    CurrentPhysicalSize;\r
  UINT64                   FileStart;\r
  UINT64                   FileEnd;\r
  UINT64                   RegionStart;\r
  UINT64                   RegionEnd;\r
  UINT64                   NewDataSize;\r
  UINT64                   NewFileSize;\r
  UINT64                   EndOfAppendSpace;\r
  BOOLEAN                  HasSpace;\r
\r
  if (This == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);\r
  if (File->Info == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (File->OpenMode == EFI_FILE_MODE_READ) {\r
    return EFI_ACCESS_DENIED;\r
  }\r
\r
  Instance  = File->Instance;\r
  Info      = File->Info;\r
  BlockIo   = Instance->BlockIo;\r
  Media     = BlockIo->Media;\r
  DiskIo    = Instance->DiskIo;\r
  BlockSize = Media->BlockSize;\r
\r
  UnicodeStrToAsciiStr (Info->FileName, AsciiFileName);\r
\r
  // If the file doesn't exist then find a space for it\r
  if (File->HwDescription.RegionCount == 0) {\r
    Status = BootMonFsFindSpaceForNewFile (\r
               File,\r
               Info->FileSize + sizeof (HW_IMAGE_DESCRIPTION),\r
               &FileStart\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  } else {\r
    FileStart = File->HwDescription.BlockStart * BlockSize;\r
  }\r
  // FileEnd is the current NOR address of the end of the file's data\r
  FileEnd = FileStart + File->HwDescription.Region[0].Size;\r
\r
  for (RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);\r
       !IsNull (&File->RegionToFlushLink, RegionToFlushLink);\r
       RegionToFlushLink = GetNextNode (&File->RegionToFlushLink, RegionToFlushLink)\r
       )\r
  {\r
    Region = (BOOTMON_FS_FILE_REGION*)RegionToFlushLink;\r
    if (Region->Size == 0) {\r
      continue;\r
    }\r
\r
    // RegionStart and RegionEnd are the the intended NOR address of the\r
    // start and end of the region\r
    RegionStart = FileStart   + Region->Offset;\r
    RegionEnd   = RegionStart + Region->Size;\r
\r
    if (RegionEnd < FileEnd) {\r
      // Handle regions representing edits to existing portions of the file\r
      // Write the region data straight into the file\r
      Status = DiskIo->WriteDisk (DiskIo,\r
                        Media->MediaId,\r
                        RegionStart,\r
                        Region->Size,\r
                        Region->Buffer\r
                        );\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
    } else {\r
      // Handle regions representing appends to the file\r
      //\r
      // Note: Since seeking past the end of the file with SetPosition() is\r
      //  valid, it's possible there will be a gap between the current end of\r
      //  the file and the beginning of the new region. Since the UEFI spec\r
      //  says nothing about this case (except "a subsequent write would grow\r
      //  the file"), we just leave garbage in the gap.\r
\r
      // Check if there is space to append the new region\r
      HasSpace = FALSE;\r
      NewDataSize = RegionEnd - FileStart;\r
      NewFileSize = NewDataSize + sizeof (HW_IMAGE_DESCRIPTION);\r
      CurrentPhysicalSize = BootMonFsGetPhysicalSize (File);\r
      if (NewFileSize <= CurrentPhysicalSize) {\r
        HasSpace = TRUE;\r
      } else {\r
        // Get the File Description for the next file\r
        FileLink = GetNextNode (&Instance->RootFile->Link, &File->Link);\r
        if (!IsNull (&Instance->RootFile->Link, FileLink)) {\r
          NextFile = BOOTMON_FS_FILE_FROM_LINK_THIS (FileLink);\r
\r
          // If there is space between the beginning of the current file and the\r
          // beginning of the next file then use it\r
          EndOfAppendSpace = NextFile->HwDescription.BlockStart * BlockSize;\r
        } else {\r
          // We are flushing the last file.\r
          EndOfAppendSpace = (Media->LastBlock + 1) * BlockSize;\r
        }\r
        if (EndOfAppendSpace - FileStart >= NewFileSize) {\r
          HasSpace = TRUE;\r
        }\r
      }\r
\r
      if (HasSpace == TRUE) {\r
        // Invalidate the current image description of the file if any.\r
        if (File->HwDescAddress != 0) {\r
          Status = InvalidateImageDescription (File);\r
          if (EFI_ERROR (Status)) {\r
            return Status;\r
          }\r
        }\r
\r
        // Write the new file data\r
        Status = DiskIo->WriteDisk (\r
                    DiskIo,\r
                    Media->MediaId,\r
                    RegionStart,\r
                    Region->Size,\r
                    Region->Buffer\r
                    );\r
        if (EFI_ERROR (Status)) {\r
          return Status;\r
        }\r
\r
        Status = WriteFileDescription (File, AsciiFileName, NewDataSize, FileStart);\r
        if (EFI_ERROR (Status)) {\r
          return Status;\r
        }\r
\r
      } else {\r
        // There isn't a space for the file.\r
        // Options here are to move the file or fragment it. However as files\r
        // may represent boot images at fixed positions, these options will\r
        // break booting if the bootloader doesn't use BootMonFs to find the\r
        // image.\r
\r
        return EFI_VOLUME_FULL;\r
      }\r
    }\r
  }\r
\r
  FreeFileRegions (File);\r
  Info->PhysicalSize = BootMonFsGetPhysicalSize (File);\r
\r
  if ((AsciiStrCmp (AsciiFileName, File->HwDescription.Footer.Filename) != 0) ||\r
      (Info->FileSize != File->HwDescription.Region[0].Size)               ) {\r
    Status = WriteFileDescription (File, AsciiFileName, Info->FileSize, FileStart);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  // Flush DiskIo Buffers (see UEFI Spec 12.7 - DiskIo buffers are flushed by\r
  // calling FlushBlocks on the same device's BlockIo).\r
  BlockIo->FlushBlocks (BlockIo);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Close a specified file handle.\r
\r
  @param[in]  This  A pointer to the EFI_FILE_PROTOCOL instance that is the file\r
                    handle to close.\r
\r
  @retval  EFI_SUCCESS            The file was closed.\r
  @retval  EFI_INVALID_PARAMETER  The parameter "This" is NULL or is not an open\r
                                  file handle.\r
\r
**/\r
EFIAPI\r
EFI_STATUS\r
BootMonFsCloseFile (\r
  IN EFI_FILE_PROTOCOL  *This\r
  )\r
{\r
  BOOTMON_FS_FILE  *File;\r
\r
  if (This == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);\r
  if (File->Info == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  // In the case of a file and not the root directory\r
  if (This != &File->Instance->RootFile->File) {\r
    This->Flush (This);\r
    FreePool (File->Info);\r
    File->Info = NULL;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Open a file on the boot monitor file system.\r
\r
  The boot monitor file system does not allow for sub-directories. There is only\r
  one directory, the root one. On any attempt to create a directory, the function\r
  returns in error with the EFI_WRITE_PROTECTED error code.\r
\r
  @param[in]   This        A pointer to the EFI_FILE_PROTOCOL instance that is\r
                           the file handle to source location.\r
  @param[out]  NewHandle   A pointer to the location to return the opened\r
                           handle for the new file.\r
  @param[in]   FileName    The Null-terminated string of the name of the file\r
                           to be opened.\r
  @param[in]   OpenMode    The mode to open the file : Read or Read/Write or\r
                           Read/Write/Create\r
  @param[in]   Attributes  Attributes of the file in case of a file creation\r
\r
  @retval  EFI_SUCCESS            The file was open.\r
  @retval  EFI_NOT_FOUND          The specified file could not be found or the specified\r
                                  directory in which to create a file could not be found.\r
  @retval  EFI_DEVICE_ERROR       The device reported an error.\r
  @retval  EFI_WRITE_PROTECTED    Attempt to create a directory. This is not possible\r
                                  with the Boot Monitor file system.\r
  @retval  EFI_OUT_OF_RESOURCES   Not enough resources were available to open the file.\r
  @retval  EFI_INVALID_PARAMETER  At least one of the parameters is invalid.\r
\r
**/\r
EFIAPI\r
EFI_STATUS\r
BootMonFsOpenFile (\r
  IN EFI_FILE_PROTOCOL   *This,\r
  OUT EFI_FILE_PROTOCOL  **NewHandle,\r
  IN CHAR16              *FileName,\r
  IN UINT64              OpenMode,\r
  IN UINT64              Attributes\r
  )\r
{\r
  EFI_STATUS           Status;\r
  BOOTMON_FS_FILE      *Directory;\r
  BOOTMON_FS_FILE      *File;\r
  BOOTMON_FS_INSTANCE  *Instance;\r
  CHAR8                *Buf;\r
  CHAR16               *Path;\r
  CHAR16               *Separator;\r
  CHAR8                *AsciiFileName;\r
  EFI_FILE_INFO        *Info;\r
\r
  if (This == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Directory = BOOTMON_FS_FILE_FROM_FILE_THIS (This);\r
  if (Directory->Info == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if ((FileName == NULL) || (NewHandle == NULL)) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // The only valid modes are read, read/write, and read/write/create\r
  //\r
  if ( (OpenMode != EFI_FILE_MODE_READ) &&\r
       (OpenMode != (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE)) &&\r
       (OpenMode != (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE)) ) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Instance = Directory->Instance;\r
\r
  //\r
  // If the instance has not been initialized yet then do it ...\r
  //\r
  if (!Instance->Initialized) {\r
    Status = BootMonFsInitialize (Instance);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  //\r
  // Copy the file path to be able to work on it. We do not want to\r
  // modify the input file name string "FileName".\r
  //\r
  Buf = AllocateCopyPool (StrSize (FileName), FileName);\r
  if (Buf == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
  Path = (CHAR16*)Buf;\r
  AsciiFileName = NULL;\r
  Info = NULL;\r
\r
  //\r
  // Handle single periods, double periods and convert forward slashes '/'\r
  // to backward '\' ones. Does not handle a '.' at the beginning of the\r
  // path for the time being.\r
  //\r
  if (PathCleanUpDirectories (Path) == NULL) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Error;\r
  }\r
\r
  //\r
  // Detect if the first component of the path refers to a directory.\r
  // This is done to return the correct error code when trying to\r
  // access or create a directory other than the root directory.\r
  //\r
\r
  //\r
  // Search for the '\\' sequence and if found return in error\r
  // with the EFI_INVALID_PARAMETER error code. ere in the path.\r
  //\r
  if (StrStr (Path, L"\\\\") != NULL) {\r
    Status = EFI_INVALID_PARAMETER;\r
    goto Error;\r
  }\r
  //\r
  // Get rid of the leading '\' if any.\r
  //\r
  Path += (Path[0] == L'\\');\r
\r
  //\r
  // Look for a '\' in the file path. If one is found then\r
  // the first component of the path refers to a directory\r
  // that is not the root directory.\r
  //\r
  Separator = StrStr (Path, L"\\");\r
  if (Separator != NULL) {\r
    //\r
    // In the case '<dir name>\' and a creation, return\r
    // EFI_WRITE_PROTECTED if this is for a directory\r
    // creation, EFI_INVALID_PARAMETER otherwise.\r
    //\r
    if ((*(Separator + 1) == '\0') && ((OpenMode & EFI_FILE_MODE_CREATE) != 0)) {\r
      if (Attributes & EFI_FILE_DIRECTORY) {\r
        Status = EFI_WRITE_PROTECTED;\r
      } else {\r
        Status = EFI_INVALID_PARAMETER;\r
      }\r
    } else {\r
      //\r
      // Attempt to open a file or a directory that is not in the\r
      // root directory or to open without creation a directory\r
      // located in the root directory, returns EFI_NOT_FOUND.\r
      //\r
      Status = EFI_NOT_FOUND;\r
    }\r
    goto Error;\r
  }\r
\r
  //\r
  // BootMonFs interface requires ASCII filenames\r
  //\r
  AsciiFileName = AllocatePool (StrLen (Path) + 1);\r
  if (AsciiFileName == NULL) {\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto Error;\r
  }\r
  UnicodeStrToAsciiStr (Path, AsciiFileName);\r
  if (AsciiStrSize (AsciiFileName) > MAX_NAME_LENGTH) {\r
   AsciiFileName[MAX_NAME_LENGTH - 1] = '\0';\r
  }\r
\r
  if ((AsciiFileName[0] == '\0') ||\r
      (AsciiFileName[0] == '.' )    ) {\r
    //\r
    // Opening the root directory\r
    //\r
\r
    *NewHandle = &Instance->RootFile->File;\r
    Instance->RootFile->Position = 0;\r
    Status = EFI_SUCCESS;\r
  } else {\r
\r
    if ((OpenMode & EFI_FILE_MODE_CREATE) &&\r
        (Attributes & EFI_FILE_DIRECTORY)    ) {\r
      Status = EFI_WRITE_PROTECTED;\r
      goto Error;\r
    }\r
\r
    //\r
    // Allocate a buffer to store the characteristics of the file while the\r
    // file is open. We allocate the maximum size to not have to reallocate\r
    // if the file name is changed.\r
    //\r
    Info = AllocateZeroPool (\r
             SIZE_OF_EFI_FILE_INFO + (sizeof (CHAR16) * MAX_NAME_LENGTH));\r
    if (Info == NULL) {\r
      Status = EFI_OUT_OF_RESOURCES;\r
      goto Error;\r
    }\r
\r
    //\r
    // Open or create a file in the root directory.\r
    //\r
\r
    Status = BootMonGetFileFromAsciiFileName (Instance, AsciiFileName, &File);\r
    if (Status == EFI_NOT_FOUND) {\r
      if ((OpenMode & EFI_FILE_MODE_CREATE) == 0) {\r
        goto Error;\r
      }\r
\r
      Status = BootMonFsCreateFile (Instance, &File);\r
      if (EFI_ERROR (Status)) {\r
        goto Error;\r
      }\r
      InsertHeadList (&Instance->RootFile->Link, &File->Link);\r
      Info->Attribute = Attributes;\r
    } else {\r
      //\r
      // File already open, not supported yet.\r
      //\r
      if (File->Info != NULL) {\r
        Status = EFI_UNSUPPORTED;\r
        goto Error;\r
      }\r
    }\r
\r
    Info->FileSize     = BootMonFsGetImageLength (File);\r
    Info->PhysicalSize = BootMonFsGetPhysicalSize (File);\r
    AsciiStrToUnicodeStr (AsciiFileName, Info->FileName);\r
\r
    File->Info = Info;\r
    Info = NULL;\r
    File->Position = 0;\r
    File->OpenMode = OpenMode;\r
\r
    *NewHandle = &File->File;\r
  }\r
\r
Error:\r
\r
  FreePool (Buf);\r
  if (AsciiFileName != NULL) {\r
    FreePool (AsciiFileName);\r
  }\r
  if (Info != NULL) {\r
    FreePool (Info);\r
  }\r
\r
  return Status;\r
}\r
\r
// Delete() for the root directory's EFI_FILE_PROTOCOL instance\r
EFIAPI\r
EFI_STATUS\r
BootMonFsDeleteFail (\r
  IN EFI_FILE_PROTOCOL *This\r
  )\r
{\r
  This->Close(This);\r
  // You can't delete the root directory\r
  return EFI_WARN_DELETE_FAILURE;\r
}\r
\r
/**\r
  Close and delete a file from the boot monitor file system.\r
\r
  @param[in]  This  A pointer to the EFI_FILE_PROTOCOL instance that is the file\r
                    handle to delete.\r
\r
  @retval  EFI_SUCCESS              The file was closed and deleted.\r
  @retval  EFI_INVALID_PARAMETER    The parameter "This" is NULL or is not an open\r
                                    file handle.\r
  @retval  EFI_WARN_DELETE_FAILURE  The handle was closed, but the file was not deleted.\r
\r
**/\r
EFIAPI\r
EFI_STATUS\r
BootMonFsDelete (\r
  IN EFI_FILE_PROTOCOL *This\r
  )\r
{\r
  EFI_STATUS               Status;\r
  BOOTMON_FS_FILE         *File;\r
  LIST_ENTRY              *RegionToFlushLink;\r
  BOOTMON_FS_FILE_REGION  *Region;\r
\r
  if (This == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);\r
  if (File->Info == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (!IsListEmpty (&File->RegionToFlushLink)) {\r
    // Free the entries from the Buffer List\r
    RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);\r
    do {\r
      Region = (BOOTMON_FS_FILE_REGION*)RegionToFlushLink;\r
\r
      //\r
      // Get next element of the list before deleting the region description\r
      // that contain the LIST_ENTRY structure.\r
      //\r
      RegionToFlushLink = RemoveEntryList (RegionToFlushLink);\r
\r
      // Free the buffers\r
      FreePool (Region->Buffer);\r
      FreePool (Region);\r
    } while (!IsListEmpty (&File->RegionToFlushLink));\r
  }\r
\r
  // If (RegionCount is greater than 0) then the file already exists\r
  if (File->HwDescription.RegionCount > 0) {\r
    // Invalidate the last Block\r
    Status = InvalidateImageDescription (File);\r
    ASSERT_EFI_ERROR (Status);\r
    if (EFI_ERROR (Status)) {\r
      return  EFI_WARN_DELETE_FAILURE;\r
    }\r
  }\r
\r
  // Remove the entry from the list\r
  RemoveEntryList (&File->Link);\r
  FreePool (File->Info);\r
  FreePool (File);\r
\r
  return EFI_SUCCESS;\r
}\r