ArmPlatformPkg/FileSystem/BootMonFs/BootMonFsDir.c - device/linaro/bootloader/edk2 - Git at Google

 /** @file
 *
 *  Copyright (c) 2012-2014, ARM Limited. All rights reserved.
 *
 *  This program and the accompanying materials
 *  are licensed and made available under the terms and conditions of the BSD License
 *  which accompanies this distribution.  The full text of the license may be found at
 *  http://opensource.org/licenses/bsd-license.php
 *
 *  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 *
 **/

 #include "BootMonFsInternal.h"

 EFIAPI
 EFI_STATUS
 OpenBootMonFsOpenVolume (
   IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
   OUT EFI_FILE_PROTOCOL              **Root
   )
 {
   BOOTMON_FS_INSTANCE *Instance;

   Instance = BOOTMON_FS_FROM_FS_THIS (This);
   if (Instance == NULL) {
     return EFI_DEVICE_ERROR;
   }

   Instance->RootFile->Info->Attribute = EFI_FILE_READ_ONLY | EFI_FILE_DIRECTORY;

   *Root = &Instance->RootFile->File;

   return EFI_SUCCESS;
 }

 UINT32
 BootMonFsGetImageLength (
   IN BOOTMON_FS_FILE      *File
   )
 {
   UINT32                   Index;
   UINT32                   FileSize;
   LIST_ENTRY              *RegionToFlushLink;
   BOOTMON_FS_FILE_REGION  *Region;

   FileSize = 0;

   // Look at all Flash areas to determine file size
   for (Index = 0; Index < HW_IMAGE_DESCRIPTION_REGION_MAX; Index++) {
     FileSize += File->HwDescription.Region[Index].Size;
   }

   // Add the regions that have not been flushed yet
   for (RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);
        !IsNull (&File->RegionToFlushLink, RegionToFlushLink);
        RegionToFlushLink = GetNextNode (&File->RegionToFlushLink, RegionToFlushLink)
        )
   {
     Region = (BOOTMON_FS_FILE_REGION*)RegionToFlushLink;
     if (Region->Offset + Region->Size > FileSize) {
       FileSize += Region->Offset + Region->Size;
     }
   }

   return FileSize;
 }

 UINTN
 BootMonFsGetPhysicalSize (
   IN BOOTMON_FS_FILE* File
   )
 {
   // Return 0 for files that haven't yet been flushed to media
   if (File->HwDescription.RegionCount == 0) {
     return 0;
   }

   return ((File->HwDescription.BlockEnd - File->HwDescription.BlockStart) + 1 )
           * File->Instance->Media->BlockSize;
 }

 EFIAPI
 EFI_STATUS
 BootMonFsSetDirPosition (
   IN EFI_FILE_PROTOCOL  *This,
   IN UINT64             Position
   )
 {
   BOOTMON_FS_FILE       *File;

   File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
   if (File == NULL) {
     return EFI_INVALID_PARAMETER;
   }

   // UEFI Spec section 12.5:
   // "The seek request for nonzero is not valid on open directories."
   if (Position != 0) {
     return EFI_UNSUPPORTED;
   }
   File->Position = Position;

   return EFI_SUCCESS;
 }

 EFI_STATUS
 BootMonFsOpenDirectory (
   OUT EFI_FILE_PROTOCOL **NewHandle,
   IN CHAR16             *FileName,
   IN BOOTMON_FS_INSTANCE *Volume
   )
 {
   ASSERT(0);

   return EFI_UNSUPPORTED;
 }

 STATIC
 EFI_STATUS
 GetFileSystemVolumeLabelInfo (
   IN BOOTMON_FS_INSTANCE *Instance,
   IN OUT UINTN          *BufferSize,
   OUT VOID              *Buffer
   )
 {
   UINTN                         Size;
   EFI_FILE_SYSTEM_VOLUME_LABEL *Label;
   EFI_STATUS                    Status;

   Label = Buffer;

   // Value returned by StrSize includes null terminator.
   Size = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL
          + StrSize (Instance->FsInfo.VolumeLabel);

   if (*BufferSize >= Size) {
     CopyMem (&Label->VolumeLabel, &Instance->FsInfo.VolumeLabel, Size);
     Status = EFI_SUCCESS;
   } else {
     Status = EFI_BUFFER_TOO_SMALL;
   }
   *BufferSize = Size;
   return Status;
 }

 // Helper function that calculates a rough "free space" by:
 // - Taking the media size
 // - Subtracting the sum of all file sizes
 // - Subtracting the block size times the number of files
 //    (To account for the blocks containing the HW_IMAGE_INFO
 STATIC
 UINT64
 ComputeFreeSpace (
   IN BOOTMON_FS_INSTANCE *Instance
   )
 {
   LIST_ENTRY   *FileLink;
   UINT64        FileSizeSum;
   UINT64        MediaSize;
   UINTN         NumFiles;
   EFI_BLOCK_IO_MEDIA *Media;
   BOOTMON_FS_FILE *File;

   Media = Instance->BlockIo->Media;
   MediaSize = Media->BlockSize * (Media->LastBlock + 1);

   NumFiles = 0;
   FileSizeSum = 0;
   for (FileLink = GetFirstNode (&Instance->RootFile->Link);
          !IsNull (&Instance->RootFile->Link, FileLink);
          FileLink = GetNextNode (&Instance->RootFile->Link, FileLink)
          )
   {
     File = BOOTMON_FS_FILE_FROM_LINK_THIS (FileLink);
     FileSizeSum += BootMonFsGetImageLength (File);

     NumFiles++;
   }

   return MediaSize - (FileSizeSum + (Media->BlockSize + NumFiles));
 }

 STATIC
 EFI_STATUS
 GetFilesystemInfo (
   IN BOOTMON_FS_INSTANCE *Instance,
   IN OUT UINTN          *BufferSize,
   OUT VOID              *Buffer
   )
 {
   EFI_STATUS              Status;

   if (*BufferSize >= Instance->FsInfo.Size) {
     Instance->FsInfo.FreeSpace = ComputeFreeSpace (Instance);
     CopyMem (Buffer, &Instance->FsInfo, Instance->FsInfo.Size);
     Status = EFI_SUCCESS;
   } else {
     Status = EFI_BUFFER_TOO_SMALL;
   }

   *BufferSize = Instance->FsInfo.Size;
   return Status;
 }

 STATIC
 EFI_STATUS
 GetFileInfo (
   IN BOOTMON_FS_INSTANCE  *Instance,
   IN BOOTMON_FS_FILE      *File,
   IN OUT UINTN            *BufferSize,
   OUT VOID                *Buffer
   )
 {
   EFI_FILE_INFO  *Info;
   UINTN          ResultSize;

   ResultSize = SIZE_OF_EFI_FILE_INFO + StrSize (File->Info->FileName);

   if (*BufferSize < ResultSize) {
     *BufferSize = ResultSize;
     return EFI_BUFFER_TOO_SMALL;
   }

   Info = Buffer;

   CopyMem (Info, File->Info, ResultSize);
   // Size of the information
   Info->Size = ResultSize;

   *BufferSize = ResultSize;

   return EFI_SUCCESS;
 }

 STATIC
 EFI_STATUS
 GetBootMonFsFileInfo (
   IN BOOTMON_FS_INSTANCE *Instance,
   IN BOOTMON_FS_FILE     *File,
   IN OUT UINTN           *BufferSize,
   OUT VOID               *Buffer
   )
 {
   EFI_STATUS             Status;
   BOOTMON_FS_FILE_INFO   *Info;
   UINTN                  ResultSize;
   UINTN                  Index;

   if (File == Instance->RootFile) {
     Status = EFI_UNSUPPORTED;
   } else {
     ResultSize = SIZE_OF_BOOTMON_FS_FILE_INFO;

     if (*BufferSize < ResultSize) {
       *BufferSize = ResultSize;
       Status = EFI_BUFFER_TOO_SMALL;
     } else {
       Info = Buffer;

       // Zero out the structure
       ZeroMem (Info, ResultSize);

       // Fill in the structure
       Info->Size = ResultSize;

       Info->EntryPoint  = File->HwDescription.EntryPoint;
       Info->RegionCount = File->HwDescription.RegionCount;
       for (Index = 0; Index < File->HwDescription.RegionCount; Index++) {
         Info->Region[Index].LoadAddress = File->HwDescription.Region[Index].LoadAddress;
         Info->Region[Index].Size        = File->HwDescription.Region[Index].Size;
         Info->Region[Index].Offset      = File->HwDescription.Region[Index].Offset;
         Info->Region[Index].Checksum    = File->HwDescription.Region[Index].Checksum;
       }
       *BufferSize = ResultSize;
       Status = EFI_SUCCESS;
     }
   }

   return Status;
 }

 /**
   Set the name of a file.

   This is a helper function for SetFileInfo().

   @param[in]  Instance  A pointer to the description of the volume
                         the file belongs to.
   @param[in]  File      A pointer to the description of the file.
   @param[in]  FileName  A pointer to the new name of the file.

   @retval  EFI_SUCCESS        The name was set.
   @retval  EFI_ACCESS_DENIED  An attempt is made to change the name of a file
                               to a file that is already present.

 **/
 STATIC
 EFI_STATUS
 SetFileName (
   IN  BOOTMON_FS_INSTANCE  *Instance,
   IN  BOOTMON_FS_FILE      *File,
   IN  CONST CHAR16         *FileName
   )
 {
   CHAR8            AsciiFileName[MAX_NAME_LENGTH];
   BOOTMON_FS_FILE  *SameFile;

   // If the file path start with a \ strip it. The EFI Shell may
   // insert a \ in front of the file name.
   if (FileName[0] == L'\\') {
     FileName++;
   }

   UnicodeStrToAsciiStrS (FileName, AsciiFileName, MAX_NAME_LENGTH);

   if (BootMonGetFileFromAsciiFileName (
         File->Instance,
         AsciiFileName,
         &SameFile
         ) != EFI_NOT_FOUND) {
     // A file with that name already exists.
     return EFI_ACCESS_DENIED;
   } else {
     // OK, change the filename.
     AsciiStrToUnicodeStrS (AsciiFileName, File->Info->FileName,
       (File->Info->Size - SIZE_OF_EFI_FILE_INFO) / sizeof (CHAR16));
     return EFI_SUCCESS;
   }
 }

 /**
   Set the size of a file.

   This is a helper function for SetFileInfo().

   @param[in]  Instance  A pointer to the description of the volume
                         the file belongs to.
   @param[in]  File      A pointer to the description of the file.
   @param[in]  NewSize   The requested new size for the file.

   @retval  EFI_SUCCESS           The size was set.
   @retval  EFI_OUT_OF_RESOURCES  An allocation needed to process the request failed.

 **/
 STATIC
 EFI_STATUS
 SetFileSize (
   IN BOOTMON_FS_INSTANCE  *Instance,
   IN BOOTMON_FS_FILE      *BootMonFsFile,
   IN UINTN                 NewSize
   )
 {
   EFI_STATUS              Status;
   UINT32                  OldSize;
   LIST_ENTRY              *RegionToFlushLink;
   LIST_ENTRY              *NextRegionToFlushLink;
   BOOTMON_FS_FILE_REGION  *Region;
   EFI_FILE_PROTOCOL       *File;
   CHAR8                   *Buffer;
   UINTN                   BufferSize;
   UINT64                  StoredPosition;

   OldSize = BootMonFsFile->Info->FileSize;

   //
   // In case of file truncation, force the regions waiting for writing to
   // not overflow the new size of the file.
   //
   if (NewSize < OldSize) {
     for (RegionToFlushLink = GetFirstNode (&BootMonFsFile->RegionToFlushLink);
          !IsNull (&BootMonFsFile->RegionToFlushLink, RegionToFlushLink);
          )
     {
       NextRegionToFlushLink = GetNextNode (&BootMonFsFile->RegionToFlushLink, RegionToFlushLink);
       Region = (BOOTMON_FS_FILE_REGION*)RegionToFlushLink;
       if (Region->Offset > NewSize) {
         RemoveEntryList (RegionToFlushLink);
         FreePool (Region->Buffer);
         FreePool (Region);
       } else {
         Region->Size = MIN (Region->Size, NewSize - Region->Offset);
       }
       RegionToFlushLink = NextRegionToFlushLink;
     }

   } else if (NewSize > OldSize) {
     // Increasing a file's size is potentially complicated as it may require
     // moving the image description on media. The simplest way to do it is to
     // seek past the end of the file (which is valid in UEFI) and perform a
     // Write.
     File = &BootMonFsFile->File;

     // Save position
     Status = File->GetPosition (File, &StoredPosition);
     if (EFI_ERROR (Status)) {
       return Status;
     }
     // Set position at the end of the file
     Status = File->SetPosition (File, OldSize);
     if (EFI_ERROR (Status)) {
       return Status;
     }

     BufferSize = NewSize - OldSize;
     Buffer = AllocateZeroPool (BufferSize);
     if (Buffer == NULL) {
       return EFI_OUT_OF_RESOURCES;
     }

     Status = File->Write (File, &BufferSize, Buffer);
     FreePool (Buffer);
     if (EFI_ERROR (Status)) {
       return Status;
     }

     // Restore saved position
     Status = File->SetPosition (File, StoredPosition);
     if (EFI_ERROR (Status)) {
       return Status;
     }
   }

   BootMonFsFile->Info->FileSize = NewSize;

   return EFI_SUCCESS;
 }

 /**
   Set information about a file.

   @param[in]  Instance  A pointer to the description of the volume
                         the file belongs to.
   @param[in]  File      A pointer to the description of the file.
   @param[in]  Info      A pointer to the file information to write.

   @retval  EFI_SUCCESS           The information was set.
   @retval  EFI_ACCESS_DENIED     An attempt is being made to change the
                                  EFI_FILE_DIRECTORY Attribute.
   @retval  EFI_ACCESS_DENIED     The file was opened in read-only mode and an
                                  attempt is being made to modify a field other
                                  than Attribute.
   @retval  EFI_ACCESS_DENIED     An attempt is made to change the name of a file
                                  to a file that is already present.
   @retval  EFI_WRITE_PROTECTED   An attempt is being made to modify a read-only
                                  attribute.
   @retval  EFI_OUT_OF_RESOURCES  An allocation needed to process the request
                                  failed.

 **/
 STATIC
 EFI_STATUS
 SetFileInfo (
   IN BOOTMON_FS_INSTANCE  *Instance,
   IN BOOTMON_FS_FILE      *File,
   IN EFI_FILE_INFO        *Info
   )
 {
   EFI_STATUS  Status;
   BOOLEAN     FileSizeIsDifferent;
   BOOLEAN     FileNameIsDifferent;
   BOOLEAN     TimeIsDifferent;

   //
   // A directory can not be changed to a file and a file can
   // not be changed to a directory.
   //
   if ((Info->Attribute & EFI_FILE_DIRECTORY)      !=
       (File->Info->Attribute & EFI_FILE_DIRECTORY)  ) {
     return EFI_ACCESS_DENIED;
   }

   FileSizeIsDifferent = (Info->FileSize != File->Info->FileSize);
   FileNameIsDifferent = (StrnCmp (
                            Info->FileName,
                            File->Info->FileName,
                            MAX_NAME_LENGTH - 1
                            ) != 0);
   //
   // Check if the CreateTime, LastAccess or ModificationTime
   // have been changed. The file system does not support file
   // timestamps thus the three times in "File->Info" are
   // always equal to zero. The following comparison actually
   // checks if all three times are still equal to 0 or not.
   //
   TimeIsDifferent = CompareMem (
                       &Info->CreateTime,
                       &File->Info->CreateTime,
                       3 * sizeof (EFI_TIME)
                       ) != 0;

   //
   // For a file opened in read-only mode, only the Attribute field can be
   // modified. The root directory open mode is forced to read-only at opening
   // thus the following test protects the root directory to be somehow modified.
   //
   if (File->OpenMode == EFI_FILE_MODE_READ) {
     if (FileSizeIsDifferent || FileNameIsDifferent || TimeIsDifferent) {
       return EFI_ACCESS_DENIED;
     }
   }

   if (TimeIsDifferent) {
     return EFI_WRITE_PROTECTED;
   }

   if (FileSizeIsDifferent) {
     Status = SetFileSize (Instance, File, Info->FileSize);
     if (EFI_ERROR (Status)) {
       return Status;
     }
   }

   //
   // Note down in RAM the Attribute field but we can not
   // ask to store it in flash for the time being.
   //
   File->Info->Attribute = Info->Attribute;

   if (FileNameIsDifferent) {
     Status = SetFileName (Instance, File, Info->FileName);
     if (EFI_ERROR (Status)) {
       return Status;
     }
   }

   return EFI_SUCCESS;
 }

 EFIAPI
 EFI_STATUS
 BootMonFsGetInfo (
   IN EFI_FILE_PROTOCOL  *This,
   IN EFI_GUID           *InformationType,
   IN OUT UINTN          *BufferSize,
   OUT VOID              *Buffer
   )
 {
   EFI_STATUS           Status;
   BOOTMON_FS_FILE     *File;
   BOOTMON_FS_INSTANCE *Instance;

   if ((This == NULL)                         ||
       (InformationType == NULL)              ||
       (BufferSize == NULL)                   ||
       ((Buffer == NULL) && (*BufferSize > 0))  ) {
     return EFI_INVALID_PARAMETER;
   }

   File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
   if (File->Info == NULL) {
     return EFI_INVALID_PARAMETER;
   }
   Instance = File->Instance;

   // If the instance has not been initialized yet then do it ...
   if (!Instance->Initialized) {
     Status = BootMonFsInitialize (Instance);
   } else {
     Status = EFI_SUCCESS;
   }

   if (!EFI_ERROR (Status)) {
     if (CompareGuid (InformationType, &gEfiFileSystemVolumeLabelInfoIdGuid)
         != 0) {
       Status = GetFileSystemVolumeLabelInfo (Instance, BufferSize, Buffer);
     } else if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid) != 0) {
       Status = GetFilesystemInfo (Instance, BufferSize, Buffer);
     } else if (CompareGuid (InformationType, &gEfiFileInfoGuid) != 0) {
       Status = GetFileInfo (Instance, File, BufferSize, Buffer);
     } else if (CompareGuid (InformationType, &gArmBootMonFsFileInfoGuid) != 0) {
       Status = GetBootMonFsFileInfo (Instance, File, BufferSize, Buffer);
     } else {
       Status = EFI_UNSUPPORTED;
     }
   }

   return Status;
 }

 /**
   Set information about a file or a volume.

   @param[in]  This             A pointer to the EFI_FILE_PROTOCOL instance that
                                is the file handle the information is for.
   @param[in]  InformationType  The type identifier for the information being set :
                                EFI_FILE_INFO_ID or EFI_FILE_SYSTEM_INFO_ID or
                                EFI_FILE_SYSTEM_VOLUME_LABEL_ID
   @param[in]  BufferSize       The size, in bytes, of Buffer.
   @param[in]  Buffer           A pointer to the data buffer to write. The type of the
                                data inside the buffer is indicated by InformationType.

   @retval  EFI_SUCCESS            The information was set.
   @retval  EFI_UNSUPPORTED        The InformationType is not known.
   @retval  EFI_DEVICE_ERROR       The last issued semi-hosting operation failed.
   @retval  EFI_ACCESS_DENIED      An attempt is made to change the name of a file
                                   to a file that is already present.
   @retval  EFI_ACCESS_DENIED      An attempt is being made to change the
                                   EFI_FILE_DIRECTORY Attribute.
   @retval  EFI_ACCESS_DENIED      InformationType is EFI_FILE_INFO_ID and
                                   the file was opened in read-only mode and an
                                   attempt is being made to modify a field other
                                   than Attribute.
   @retval  EFI_WRITE_PROTECTED    An attempt is being made to modify a read-only
                                   attribute.
   @retval  EFI_BAD_BUFFER_SIZE    The size of the buffer is lower than that indicated by
                                   the data inside the buffer.
   @retval  EFI_OUT_OF_RESOURCES   A allocation needed to process the request failed.
   @retval  EFI_INVALID_PARAMETER  At least one of the parameters is invalid.

 **/
 EFIAPI
 EFI_STATUS
 BootMonFsSetInfo (
   IN EFI_FILE_PROTOCOL  *This,
   IN EFI_GUID           *InformationType,
   IN UINTN              BufferSize,
   IN VOID               *Buffer
   )
 {
   BOOTMON_FS_FILE       *File;
   EFI_FILE_INFO         *Info;
   EFI_FILE_SYSTEM_INFO  *SystemInfo;

   if ((This == NULL)            ||
       (InformationType == NULL) ||
       (Buffer == NULL)             ) {
     return EFI_INVALID_PARAMETER;
   }

   File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
   if (File->Info == NULL) {
     return EFI_INVALID_PARAMETER;
   }

   if (CompareGuid (InformationType, &gEfiFileInfoGuid)) {
     Info = Buffer;
     if (Info->Size < (SIZE_OF_EFI_FILE_INFO + StrSize (Info->FileName))) {
       return EFI_INVALID_PARAMETER;
     }
     if (BufferSize < Info->Size) {
       return EFI_BAD_BUFFER_SIZE;
     }
     return (SetFileInfo (File->Instance, File, Info));
   }

   //
   // The only writable field in the other two information types
   // (i.e. EFI_FILE_SYSTEM_INFO and EFI_FILE_SYSTEM_VOLUME_LABEL) is the
   // filesystem volume label. This can be retrieved with GetInfo, but it is
   // hard-coded into this driver, not stored on media.
   //

   if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid)) {
     SystemInfo = Buffer;
     if (SystemInfo->Size <
         (SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (SystemInfo->VolumeLabel))) {
       return EFI_INVALID_PARAMETER;
     }
     if (BufferSize < SystemInfo->Size) {
       return EFI_BAD_BUFFER_SIZE;
     }
     return EFI_WRITE_PROTECTED;
   }

   if (CompareGuid (InformationType, &gEfiFileSystemVolumeLabelInfoIdGuid)) {
     return EFI_WRITE_PROTECTED;
   }

   return EFI_UNSUPPORTED;
 }

 EFIAPI
 EFI_STATUS
 BootMonFsReadDirectory (
   IN EFI_FILE_PROTOCOL    *This,
   IN OUT UINTN            *BufferSize,
   OUT VOID                *Buffer
   )
 {
   BOOTMON_FS_INSTANCE *Instance;
   BOOTMON_FS_FILE     *RootFile;
   BOOTMON_FS_FILE     *File;
   EFI_FILE_INFO       *Info;
   UINTN               NameSize;
   UINTN               ResultSize;
   EFI_STATUS          Status;
   UINTN               Index;

   RootFile = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
   if (RootFile == NULL) {
     return EFI_INVALID_PARAMETER;
   }

   Instance = RootFile->Instance;
   Status = BootMonGetFileFromPosition (Instance, RootFile->Position, &File);
   if (EFI_ERROR (Status)) {
     // No more file
     *BufferSize = 0;
     return EFI_SUCCESS;
   }

   NameSize   = AsciiStrLen (File->HwDescription.Footer.Filename) + 1;
   ResultSize = SIZE_OF_EFI_FILE_INFO + (NameSize * sizeof (CHAR16));
   if (*BufferSize < ResultSize) {
     *BufferSize = ResultSize;
     return EFI_BUFFER_TOO_SMALL;
   }

   // Zero out the structure
   Info = Buffer;
   ZeroMem (Info, ResultSize);

   // Fill in the structure
   Info->Size         = ResultSize;
   Info->FileSize     = BootMonFsGetImageLength (File);
   Info->PhysicalSize = BootMonFsGetPhysicalSize (File);
   for (Index = 0; Index < NameSize; Index++) {
     Info->FileName[Index] = File->HwDescription.Footer.Filename[Index];
   }

   *BufferSize = ResultSize;
   RootFile->Position++;

   return EFI_SUCCESS;
 }

 EFIAPI
 EFI_STATUS
 BootMonFsFlushDirectory (
   IN EFI_FILE_PROTOCOL  *This
   )
 {
   BOOTMON_FS_FILE *RootFile;
   LIST_ENTRY      *ListFiles;
   LIST_ENTRY      *Link;
   BOOTMON_FS_FILE *File;

   RootFile = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
   if (RootFile == NULL) {
     return EFI_INVALID_PARAMETER;
   }

   ListFiles = &RootFile->Link;

   if (IsListEmpty (ListFiles)) {
     return EFI_SUCCESS;
   }

   //
   // Flush all the files that need to be flushed
   //

   // Go through all the list of files to flush them
   for (Link = GetFirstNode (ListFiles);
        !IsNull (ListFiles, Link);
        Link = GetNextNode (ListFiles, Link)
        )
   {
     File = BOOTMON_FS_FILE_FROM_LINK_THIS (Link);
     File->File.Flush (&File->File);
   }

   return EFI_SUCCESS;
 }
	/** @file
	*
	* Copyright (c) 2012-2014, ARM Limited. All rights reserved.
	*
	* This program and the accompanying materials
	* are licensed and made available under the terms and conditions of the BSD License
	* which accompanies this distribution. The full text of the license may be found at
	* http://opensource.org/licenses/bsd-license.php
	*
	* THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
	* WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
	*
	**/

	#include "BootMonFsInternal.h"

	EFIAPI
	EFI_STATUS
	OpenBootMonFsOpenVolume (
	IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
	OUT EFI_FILE_PROTOCOL **Root
	)
	{
	BOOTMON_FS_INSTANCE *Instance;

	Instance = BOOTMON_FS_FROM_FS_THIS (This);
	if (Instance == NULL) {
	return EFI_DEVICE_ERROR;
	}

	Instance->RootFile->Info->Attribute = EFI_FILE_READ_ONLY \| EFI_FILE_DIRECTORY;

	*Root = &Instance->RootFile->File;

	return EFI_SUCCESS;
	}

	UINT32
	BootMonFsGetImageLength (
	IN BOOTMON_FS_FILE *File
	)
	{
	UINT32 Index;
	UINT32 FileSize;
	LIST_ENTRY *RegionToFlushLink;
	BOOTMON_FS_FILE_REGION *Region;

	FileSize = 0;

	// Look at all Flash areas to determine file size
	for (Index = 0; Index < HW_IMAGE_DESCRIPTION_REGION_MAX; Index++) {
	FileSize += File->HwDescription.Region[Index].Size;
	}

	// Add the regions that have not been flushed yet
	for (RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);
	!IsNull (&File->RegionToFlushLink, RegionToFlushLink);
	RegionToFlushLink = GetNextNode (&File->RegionToFlushLink, RegionToFlushLink)
	)
	{
	Region = (BOOTMON_FS_FILE_REGION*)RegionToFlushLink;
	if (Region->Offset + Region->Size > FileSize) {
	FileSize += Region->Offset + Region->Size;
	}
	}

	return FileSize;
	}

	UINTN
	BootMonFsGetPhysicalSize (
	IN BOOTMON_FS_FILE* File
	)
	{
	// Return 0 for files that haven't yet been flushed to media
	if (File->HwDescription.RegionCount == 0) {
	return 0;
	}

	return ((File->HwDescription.BlockEnd - File->HwDescription.BlockStart) + 1 )
	* File->Instance->Media->BlockSize;
	}

	EFIAPI
	EFI_STATUS
	BootMonFsSetDirPosition (
	IN EFI_FILE_PROTOCOL *This,
	IN UINT64 Position
	)
	{
	BOOTMON_FS_FILE *File;

	File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
	if (File == NULL) {
	return EFI_INVALID_PARAMETER;
	}

	// UEFI Spec section 12.5:
	// "The seek request for nonzero is not valid on open directories."
	if (Position != 0) {
	return EFI_UNSUPPORTED;
	}
	File->Position = Position;

	return EFI_SUCCESS;
	}

	EFI_STATUS
	BootMonFsOpenDirectory (
	OUT EFI_FILE_PROTOCOL **NewHandle,
	IN CHAR16 *FileName,
	IN BOOTMON_FS_INSTANCE *Volume
	)
	{
	ASSERT(0);

	return EFI_UNSUPPORTED;
	}

	STATIC
	EFI_STATUS
	GetFileSystemVolumeLabelInfo (
	IN BOOTMON_FS_INSTANCE *Instance,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
	)
	{
	UINTN Size;
	EFI_FILE_SYSTEM_VOLUME_LABEL *Label;
	EFI_STATUS Status;

	Label = Buffer;

	// Value returned by StrSize includes null terminator.
	Size = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL
	+ StrSize (Instance->FsInfo.VolumeLabel);

	if (*BufferSize >= Size) {
	CopyMem (&Label->VolumeLabel, &Instance->FsInfo.VolumeLabel, Size);
	Status = EFI_SUCCESS;
	} else {
	Status = EFI_BUFFER_TOO_SMALL;
	}
	*BufferSize = Size;
	return Status;
	}

	// Helper function that calculates a rough "free space" by:
	// - Taking the media size
	// - Subtracting the sum of all file sizes
	// - Subtracting the block size times the number of files
	// (To account for the blocks containing the HW_IMAGE_INFO
	STATIC
	UINT64
	ComputeFreeSpace (
	IN BOOTMON_FS_INSTANCE *Instance
	)
	{
	LIST_ENTRY *FileLink;
	UINT64 FileSizeSum;
	UINT64 MediaSize;
	UINTN NumFiles;
	EFI_BLOCK_IO_MEDIA *Media;
	BOOTMON_FS_FILE *File;

	Media = Instance->BlockIo->Media;
	MediaSize = Media->BlockSize * (Media->LastBlock + 1);

	NumFiles = 0;
	FileSizeSum = 0;
	for (FileLink = GetFirstNode (&Instance->RootFile->Link);
	!IsNull (&Instance->RootFile->Link, FileLink);
	FileLink = GetNextNode (&Instance->RootFile->Link, FileLink)
	)
	{
	File = BOOTMON_FS_FILE_FROM_LINK_THIS (FileLink);
	FileSizeSum += BootMonFsGetImageLength (File);

	NumFiles++;
	}

	return MediaSize - (FileSizeSum + (Media->BlockSize + NumFiles));
	}

	STATIC
	EFI_STATUS
	GetFilesystemInfo (
	IN BOOTMON_FS_INSTANCE *Instance,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
	)
	{
	EFI_STATUS Status;

	if (*BufferSize >= Instance->FsInfo.Size) {
	Instance->FsInfo.FreeSpace = ComputeFreeSpace (Instance);
	CopyMem (Buffer, &Instance->FsInfo, Instance->FsInfo.Size);
	Status = EFI_SUCCESS;
	} else {
	Status = EFI_BUFFER_TOO_SMALL;
	}

	*BufferSize = Instance->FsInfo.Size;
	return Status;
	}

	STATIC
	EFI_STATUS
	GetFileInfo (
	IN BOOTMON_FS_INSTANCE *Instance,
	IN BOOTMON_FS_FILE *File,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
	)
	{
	EFI_FILE_INFO *Info;
	UINTN ResultSize;

	ResultSize = SIZE_OF_EFI_FILE_INFO + StrSize (File->Info->FileName);

	if (*BufferSize < ResultSize) {
	*BufferSize = ResultSize;
	return EFI_BUFFER_TOO_SMALL;
	}

	Info = Buffer;

	CopyMem (Info, File->Info, ResultSize);
	// Size of the information
	Info->Size = ResultSize;

	*BufferSize = ResultSize;

	return EFI_SUCCESS;
	}

	STATIC
	EFI_STATUS
	GetBootMonFsFileInfo (
	IN BOOTMON_FS_INSTANCE *Instance,
	IN BOOTMON_FS_FILE *File,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
	)
	{
	EFI_STATUS Status;
	BOOTMON_FS_FILE_INFO *Info;
	UINTN ResultSize;
	UINTN Index;

	if (File == Instance->RootFile) {
	Status = EFI_UNSUPPORTED;
	} else {
	ResultSize = SIZE_OF_BOOTMON_FS_FILE_INFO;

	if (*BufferSize < ResultSize) {
	*BufferSize = ResultSize;
	Status = EFI_BUFFER_TOO_SMALL;
	} else {
	Info = Buffer;

	// Zero out the structure
	ZeroMem (Info, ResultSize);

	// Fill in the structure
	Info->Size = ResultSize;

	Info->EntryPoint = File->HwDescription.EntryPoint;
	Info->RegionCount = File->HwDescription.RegionCount;
	for (Index = 0; Index < File->HwDescription.RegionCount; Index++) {
	Info->Region[Index].LoadAddress = File->HwDescription.Region[Index].LoadAddress;
	Info->Region[Index].Size = File->HwDescription.Region[Index].Size;
	Info->Region[Index].Offset = File->HwDescription.Region[Index].Offset;
	Info->Region[Index].Checksum = File->HwDescription.Region[Index].Checksum;
	}
	*BufferSize = ResultSize;
	Status = EFI_SUCCESS;
	}
	}

	return Status;
	}

	/**
	Set the name of a file.

	This is a helper function for SetFileInfo().

	@param[in] Instance A pointer to the description of the volume
	the file belongs to.
	@param[in] File A pointer to the description of the file.
	@param[in] FileName A pointer to the new name of the file.

	@retval EFI_SUCCESS The name was set.
	@retval EFI_ACCESS_DENIED An attempt is made to change the name of a file
	to a file that is already present.

	**/
	STATIC
	EFI_STATUS
	SetFileName (
	IN BOOTMON_FS_INSTANCE *Instance,
	IN BOOTMON_FS_FILE *File,
	IN CONST CHAR16 *FileName
	)
	{
	CHAR8 AsciiFileName[MAX_NAME_LENGTH];
	BOOTMON_FS_FILE *SameFile;

	// If the file path start with a \ strip it. The EFI Shell may
	// insert a \ in front of the file name.
	if (FileName[0] == L'\\') {
	FileName++;
	}

	UnicodeStrToAsciiStrS (FileName, AsciiFileName, MAX_NAME_LENGTH);

	if (BootMonGetFileFromAsciiFileName (
	File->Instance,
	AsciiFileName,
	&SameFile
	) != EFI_NOT_FOUND) {
	// A file with that name already exists.
	return EFI_ACCESS_DENIED;
	} else {
	// OK, change the filename.
	AsciiStrToUnicodeStrS (AsciiFileName, File->Info->FileName,
	(File->Info->Size - SIZE_OF_EFI_FILE_INFO) / sizeof (CHAR16));
	return EFI_SUCCESS;
	}
	}

	/**
	Set the size of a file.

	This is a helper function for SetFileInfo().

	@param[in] Instance A pointer to the description of the volume
	the file belongs to.
	@param[in] File A pointer to the description of the file.
	@param[in] NewSize The requested new size for the file.

	@retval EFI_SUCCESS The size was set.
	@retval EFI_OUT_OF_RESOURCES An allocation needed to process the request failed.

	**/
	STATIC
	EFI_STATUS
	SetFileSize (
	IN BOOTMON_FS_INSTANCE *Instance,
	IN BOOTMON_FS_FILE *BootMonFsFile,
	IN UINTN NewSize
	)
	{
	EFI_STATUS Status;
	UINT32 OldSize;
	LIST_ENTRY *RegionToFlushLink;
	LIST_ENTRY *NextRegionToFlushLink;
	BOOTMON_FS_FILE_REGION *Region;
	EFI_FILE_PROTOCOL *File;
	CHAR8 *Buffer;
	UINTN BufferSize;
	UINT64 StoredPosition;

	OldSize = BootMonFsFile->Info->FileSize;

	//
	// In case of file truncation, force the regions waiting for writing to
	// not overflow the new size of the file.
	//
	if (NewSize < OldSize) {
	for (RegionToFlushLink = GetFirstNode (&BootMonFsFile->RegionToFlushLink);
	!IsNull (&BootMonFsFile->RegionToFlushLink, RegionToFlushLink);
	)
	{
	NextRegionToFlushLink = GetNextNode (&BootMonFsFile->RegionToFlushLink, RegionToFlushLink);
	Region = (BOOTMON_FS_FILE_REGION*)RegionToFlushLink;
	if (Region->Offset > NewSize) {
	RemoveEntryList (RegionToFlushLink);
	FreePool (Region->Buffer);
	FreePool (Region);
	} else {
	Region->Size = MIN (Region->Size, NewSize - Region->Offset);
	}
	RegionToFlushLink = NextRegionToFlushLink;
	}

	} else if (NewSize > OldSize) {
	// Increasing a file's size is potentially complicated as it may require
	// moving the image description on media. The simplest way to do it is to
	// seek past the end of the file (which is valid in UEFI) and perform a
	// Write.
	File = &BootMonFsFile->File;

	// Save position
	Status = File->GetPosition (File, &StoredPosition);
	if (EFI_ERROR (Status)) {
	return Status;
	}
	// Set position at the end of the file
	Status = File->SetPosition (File, OldSize);
	if (EFI_ERROR (Status)) {
	return Status;
	}

	BufferSize = NewSize - OldSize;
	Buffer = AllocateZeroPool (BufferSize);
	if (Buffer == NULL) {
	return EFI_OUT_OF_RESOURCES;
	}

	Status = File->Write (File, &BufferSize, Buffer);
	FreePool (Buffer);
	if (EFI_ERROR (Status)) {
	return Status;
	}

	// Restore saved position
	Status = File->SetPosition (File, StoredPosition);
	if (EFI_ERROR (Status)) {
	return Status;
	}
	}

	BootMonFsFile->Info->FileSize = NewSize;

	return EFI_SUCCESS;
	}

	/**
	Set information about a file.

	@param[in] Instance A pointer to the description of the volume
	the file belongs to.
	@param[in] File A pointer to the description of the file.
	@param[in] Info A pointer to the file information to write.

	@retval EFI_SUCCESS The information was set.
	@retval EFI_ACCESS_DENIED An attempt is being made to change the
	EFI_FILE_DIRECTORY Attribute.
	@retval EFI_ACCESS_DENIED The file was opened in read-only mode and an
	attempt is being made to modify a field other
	than Attribute.
	@retval EFI_ACCESS_DENIED An attempt is made to change the name of a file
	to a file that is already present.
	@retval EFI_WRITE_PROTECTED An attempt is being made to modify a read-only
	attribute.
	@retval EFI_OUT_OF_RESOURCES An allocation needed to process the request
	failed.

	**/
	STATIC
	EFI_STATUS
	SetFileInfo (
	IN BOOTMON_FS_INSTANCE *Instance,
	IN BOOTMON_FS_FILE *File,
	IN EFI_FILE_INFO *Info
	)
	{
	EFI_STATUS Status;
	BOOLEAN FileSizeIsDifferent;
	BOOLEAN FileNameIsDifferent;
	BOOLEAN TimeIsDifferent;

	//
	// A directory can not be changed to a file and a file can
	// not be changed to a directory.
	//
	if ((Info->Attribute & EFI_FILE_DIRECTORY) !=
	(File->Info->Attribute & EFI_FILE_DIRECTORY) ) {
	return EFI_ACCESS_DENIED;
	}

	FileSizeIsDifferent = (Info->FileSize != File->Info->FileSize);
	FileNameIsDifferent = (StrnCmp (
	Info->FileName,
	File->Info->FileName,
	MAX_NAME_LENGTH - 1
	) != 0);
	//
	// Check if the CreateTime, LastAccess or ModificationTime
	// have been changed. The file system does not support file
	// timestamps thus the three times in "File->Info" are
	// always equal to zero. The following comparison actually
	// checks if all three times are still equal to 0 or not.
	//
	TimeIsDifferent = CompareMem (
	&Info->CreateTime,
	&File->Info->CreateTime,
	3 * sizeof (EFI_TIME)
	) != 0;

	//
	// For a file opened in read-only mode, only the Attribute field can be
	// modified. The root directory open mode is forced to read-only at opening
	// thus the following test protects the root directory to be somehow modified.
	//
	if (File->OpenMode == EFI_FILE_MODE_READ) {
	if (FileSizeIsDifferent \|\| FileNameIsDifferent \|\| TimeIsDifferent) {
	return EFI_ACCESS_DENIED;
	}
	}

	if (TimeIsDifferent) {
	return EFI_WRITE_PROTECTED;
	}

	if (FileSizeIsDifferent) {
	Status = SetFileSize (Instance, File, Info->FileSize);
	if (EFI_ERROR (Status)) {
	return Status;
	}
	}

	//
	// Note down in RAM the Attribute field but we can not
	// ask to store it in flash for the time being.
	//
	File->Info->Attribute = Info->Attribute;

	if (FileNameIsDifferent) {
	Status = SetFileName (Instance, File, Info->FileName);
	if (EFI_ERROR (Status)) {
	return Status;
	}
	}

	return EFI_SUCCESS;
	}

	EFIAPI
	EFI_STATUS
	BootMonFsGetInfo (
	IN EFI_FILE_PROTOCOL *This,
	IN EFI_GUID *InformationType,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
	)
	{
	EFI_STATUS Status;
	BOOTMON_FS_FILE *File;
	BOOTMON_FS_INSTANCE *Instance;

	if ((This == NULL) \|\|
	(InformationType == NULL) \|\|
	(BufferSize == NULL) \|\|
	((Buffer == NULL) && (*BufferSize > 0)) ) {
	return EFI_INVALID_PARAMETER;
	}

	File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
	if (File->Info == NULL) {
	return EFI_INVALID_PARAMETER;
	}
	Instance = File->Instance;

	// If the instance has not been initialized yet then do it ...
	if (!Instance->Initialized) {
	Status = BootMonFsInitialize (Instance);
	} else {
	Status = EFI_SUCCESS;
	}

	if (!EFI_ERROR (Status)) {
	if (CompareGuid (InformationType, &gEfiFileSystemVolumeLabelInfoIdGuid)
	!= 0) {
	Status = GetFileSystemVolumeLabelInfo (Instance, BufferSize, Buffer);
	} else if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid) != 0) {
	Status = GetFilesystemInfo (Instance, BufferSize, Buffer);
	} else if (CompareGuid (InformationType, &gEfiFileInfoGuid) != 0) {
	Status = GetFileInfo (Instance, File, BufferSize, Buffer);
	} else if (CompareGuid (InformationType, &gArmBootMonFsFileInfoGuid) != 0) {
	Status = GetBootMonFsFileInfo (Instance, File, BufferSize, Buffer);
	} else {
	Status = EFI_UNSUPPORTED;
	}
	}

	return Status;
	}

	/**
	Set information about a file or a volume.

	@param[in] This A pointer to the EFI_FILE_PROTOCOL instance that
	is the file handle the information is for.
	@param[in] InformationType The type identifier for the information being set :
	EFI_FILE_INFO_ID or EFI_FILE_SYSTEM_INFO_ID or
	EFI_FILE_SYSTEM_VOLUME_LABEL_ID
	@param[in] BufferSize The size, in bytes, of Buffer.
	@param[in] Buffer A pointer to the data buffer to write. The type of the
	data inside the buffer is indicated by InformationType.

	@retval EFI_SUCCESS The information was set.
	@retval EFI_UNSUPPORTED The InformationType is not known.
	@retval EFI_DEVICE_ERROR The last issued semi-hosting operation failed.
	@retval EFI_ACCESS_DENIED An attempt is made to change the name of a file
	to a file that is already present.
	@retval EFI_ACCESS_DENIED An attempt is being made to change the
	EFI_FILE_DIRECTORY Attribute.
	@retval EFI_ACCESS_DENIED InformationType is EFI_FILE_INFO_ID and
	the file was opened in read-only mode and an
	attempt is being made to modify a field other
	than Attribute.
	@retval EFI_WRITE_PROTECTED An attempt is being made to modify a read-only
	attribute.
	@retval EFI_BAD_BUFFER_SIZE The size of the buffer is lower than that indicated by
	the data inside the buffer.
	@retval EFI_OUT_OF_RESOURCES A allocation needed to process the request failed.
	@retval EFI_INVALID_PARAMETER At least one of the parameters is invalid.

	**/
	EFIAPI
	EFI_STATUS
	BootMonFsSetInfo (
	IN EFI_FILE_PROTOCOL *This,
	IN EFI_GUID *InformationType,
	IN UINTN BufferSize,
	IN VOID *Buffer
	)
	{
	BOOTMON_FS_FILE *File;
	EFI_FILE_INFO *Info;
	EFI_FILE_SYSTEM_INFO *SystemInfo;

	if ((This == NULL) \|\|
	(InformationType == NULL) \|\|
	(Buffer == NULL) ) {
	return EFI_INVALID_PARAMETER;
	}

	File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
	if (File->Info == NULL) {
	return EFI_INVALID_PARAMETER;
	}

	if (CompareGuid (InformationType, &gEfiFileInfoGuid)) {
	Info = Buffer;
	if (Info->Size < (SIZE_OF_EFI_FILE_INFO + StrSize (Info->FileName))) {
	return EFI_INVALID_PARAMETER;
	}
	if (BufferSize < Info->Size) {
	return EFI_BAD_BUFFER_SIZE;
	}
	return (SetFileInfo (File->Instance, File, Info));
	}

	//
	// The only writable field in the other two information types
	// (i.e. EFI_FILE_SYSTEM_INFO and EFI_FILE_SYSTEM_VOLUME_LABEL) is the
	// filesystem volume label. This can be retrieved with GetInfo, but it is
	// hard-coded into this driver, not stored on media.
	//

	if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid)) {
	SystemInfo = Buffer;
	if (SystemInfo->Size <
	(SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (SystemInfo->VolumeLabel))) {
	return EFI_INVALID_PARAMETER;
	}
	if (BufferSize < SystemInfo->Size) {
	return EFI_BAD_BUFFER_SIZE;
	}
	return EFI_WRITE_PROTECTED;
	}

	if (CompareGuid (InformationType, &gEfiFileSystemVolumeLabelInfoIdGuid)) {
	return EFI_WRITE_PROTECTED;
	}

	return EFI_UNSUPPORTED;
	}

	EFIAPI
	EFI_STATUS
	BootMonFsReadDirectory (
	IN EFI_FILE_PROTOCOL *This,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
	)
	{
	BOOTMON_FS_INSTANCE *Instance;
	BOOTMON_FS_FILE *RootFile;
	BOOTMON_FS_FILE *File;
	EFI_FILE_INFO *Info;
	UINTN NameSize;
	UINTN ResultSize;
	EFI_STATUS Status;
	UINTN Index;

	RootFile = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
	if (RootFile == NULL) {
	return EFI_INVALID_PARAMETER;
	}

	Instance = RootFile->Instance;
	Status = BootMonGetFileFromPosition (Instance, RootFile->Position, &File);
	if (EFI_ERROR (Status)) {
	// No more file
	*BufferSize = 0;
	return EFI_SUCCESS;
	}

	NameSize = AsciiStrLen (File->HwDescription.Footer.Filename) + 1;
	ResultSize = SIZE_OF_EFI_FILE_INFO + (NameSize * sizeof (CHAR16));
	if (*BufferSize < ResultSize) {
	*BufferSize = ResultSize;
	return EFI_BUFFER_TOO_SMALL;
	}

	// Zero out the structure
	Info = Buffer;
	ZeroMem (Info, ResultSize);

	// Fill in the structure
	Info->Size = ResultSize;
	Info->FileSize = BootMonFsGetImageLength (File);
	Info->PhysicalSize = BootMonFsGetPhysicalSize (File);
	for (Index = 0; Index < NameSize; Index++) {
	Info->FileName[Index] = File->HwDescription.Footer.Filename[Index];
	}

	*BufferSize = ResultSize;
	RootFile->Position++;

	return EFI_SUCCESS;
	}

	EFIAPI
	EFI_STATUS
	BootMonFsFlushDirectory (
	IN EFI_FILE_PROTOCOL *This
	)
	{
	BOOTMON_FS_FILE *RootFile;
	LIST_ENTRY *ListFiles;
	LIST_ENTRY *Link;
	BOOTMON_FS_FILE *File;

	RootFile = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
	if (RootFile == NULL) {
	return EFI_INVALID_PARAMETER;
	}

	ListFiles = &RootFile->Link;

	if (IsListEmpty (ListFiles)) {
	return EFI_SUCCESS;
	}

	//
	// Flush all the files that need to be flushed
	//

	// Go through all the list of files to flush them
	for (Link = GetFirstNode (ListFiles);
	!IsNull (ListFiles, Link);
	Link = GetNextNode (ListFiles, Link)
	)
	{
	File = BOOTMON_FS_FILE_FROM_LINK_THIS (Link);
	File->File.Flush (&File->File);
	}

	return EFI_SUCCESS;
	}