FatPkg/EnhancedFatDxe/ReadWrite.c - third_party/edk2 - Git at Google

 /** @file
   Functions that perform file read/write.

 Copyright (c) 2005 - 2017, Intel Corporation. All rights reserved.<BR>
 SPDX-License-Identifier: BSD-2-Clause-Patent


 **/

 #include "Fat.h"

 /**

   Get the file's position of the file.


   @param  FHand                 - The handle of file.
   @param  Position              - The file's position of the file.

   @retval EFI_SUCCESS           - Get the info successfully.
   @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
   @retval EFI_UNSUPPORTED       - The open file is not a file.

 **/
 EFI_STATUS
 EFIAPI
 FatGetPosition (
   IN  EFI_FILE_PROTOCOL  *FHand,
   OUT UINT64             *Position
   )
 {
   FAT_IFILE  *IFile;
   FAT_OFILE  *OFile;

   IFile = IFILE_FROM_FHAND (FHand);
   OFile = IFile->OFile;

   if (OFile->Error == EFI_NOT_FOUND) {
     return EFI_DEVICE_ERROR;
   }

   if (OFile->ODir != NULL) {
     return EFI_UNSUPPORTED;
   }

   *Position = IFile->Position;
   return EFI_SUCCESS;
 }

 /**

   Set the file's position of the file.

   @param  FHand                 - The handle of file.
   @param  Position              - The file's position of the file.

   @retval EFI_SUCCESS           - Set the info successfully.
   @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
   @retval EFI_UNSUPPORTED       - Set a directory with a not-zero position.

 **/
 EFI_STATUS
 EFIAPI
 FatSetPosition (
   IN EFI_FILE_PROTOCOL  *FHand,
   IN UINT64             Position
   )
 {
   FAT_IFILE  *IFile;
   FAT_OFILE  *OFile;

   IFile = IFILE_FROM_FHAND (FHand);
   OFile = IFile->OFile;

   if (OFile->Error == EFI_NOT_FOUND) {
     return EFI_DEVICE_ERROR;
   }

   FatWaitNonblockingTask (IFile);

   //
   // If this is a directory, we can only set back to position 0
   //
   if (OFile->ODir != NULL) {
     if (Position != 0) {
       //
       // Reset current directory cursor;
       //
       return EFI_UNSUPPORTED;
     }

     FatResetODirCursor (OFile);
   }

   //
   // Set the position
   //
   if (Position == (UINT64)-1) {
     Position = OFile->FileSize;
   }

   //
   // Set the position
   //
   IFile->Position = Position;
   return EFI_SUCCESS;
 }

 /**

   Get the file info from the open file of the IFile into Buffer.

   @param  IFile                 - The instance of the open file.
   @param  BufferSize            - Size of Buffer.
   @param  Buffer                - Buffer containing read data.

   @retval EFI_SUCCESS           - Get the file info successfully.
   @retval other                 - An error occurred when operation the disk.

 **/
 EFI_STATUS
 FatIFileReadDir (
   IN     FAT_IFILE  *IFile,
   IN OUT UINTN      *BufferSize,
   OUT VOID          *Buffer
   )
 {
   EFI_STATUS  Status;
   FAT_OFILE   *OFile;
   FAT_ODIR    *ODir;
   FAT_DIRENT  *DirEnt;
   UINT32      CurrentPos;

   OFile      = IFile->OFile;
   ODir       = OFile->ODir;
   CurrentPos = ((UINT32)IFile->Position) / sizeof (FAT_DIRECTORY_ENTRY);

   //
   // We need to relocate the directory
   //
   if (CurrentPos < ODir->CurrentPos) {
     //
     // The directory cursor has been modified by another IFile, we reset the cursor
     //
     FatResetODirCursor (OFile);
   }

   //
   // We seek the next directory entry's position
   //
   do {
     Status = FatGetNextDirEnt (OFile, &DirEnt);
     if (EFI_ERROR (Status) || (DirEnt == NULL)) {
       //
       // Something error occurred or reach the end of directory,
       // return 0 buffersize
       //
       *BufferSize = 0;
       goto Done;
     }
   } while (ODir->CurrentPos <= CurrentPos);

   Status = FatGetDirEntInfo (OFile->Volume, DirEnt, BufferSize, Buffer);

 Done:
   //
   // Update IFile's Position
   //
   if (!EFI_ERROR (Status)) {
     //
     // Update IFile->Position, if everything is all right
     //
     CurrentPos      = ODir->CurrentPos;
     IFile->Position = CurrentPos * sizeof (FAT_DIRECTORY_ENTRY);
   }

   return Status;
 }

 /**

   Get the file info from the open file of the IFile into Buffer.

   @param FHand                 - The file handle to access.
   @param  IoMode                - Indicate whether the access mode is reading or writing.
   @param  BufferSize            - Size of Buffer.
   @param  Buffer                - Buffer containing read data.
   @param  Token                 - A pointer to the token associated with the transaction.

   @retval EFI_SUCCESS           - Get the file info successfully.
   @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
   @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
   @retval EFI_WRITE_PROTECTED   - The disk is write protect.
   @retval EFI_ACCESS_DENIED     - The file is read-only.
   @return other                 - An error occurred when operating on the disk.

 **/
 EFI_STATUS
 FatIFileAccess (
   IN     EFI_FILE_PROTOCOL  *FHand,
   IN     IO_MODE            IoMode,
   IN OUT UINTN              *BufferSize,
   IN OUT VOID               *Buffer,
   IN     EFI_FILE_IO_TOKEN  *Token
   )
 {
   EFI_STATUS  Status;
   FAT_IFILE   *IFile;
   FAT_OFILE   *OFile;
   FAT_VOLUME  *Volume;
   UINT64      EndPosition;
   FAT_TASK    *Task;

   IFile  = IFILE_FROM_FHAND (FHand);
   OFile  = IFile->OFile;
   Volume = OFile->Volume;
   Task   = NULL;

   //
   // Write to a directory is unsupported
   //
   if ((OFile->ODir != NULL) && (IoMode == WriteData)) {
     return EFI_UNSUPPORTED;
   }

   if (OFile->Error == EFI_NOT_FOUND) {
     return EFI_DEVICE_ERROR;
   }

   if (IoMode == ReadData) {
     //
     // If position is at EOF, then return device error
     //
     if (IFile->Position > OFile->FileSize) {
       return EFI_DEVICE_ERROR;
     }
   } else {
     //
     // Check if the we can write data
     //
     if (Volume->ReadOnly) {
       return EFI_WRITE_PROTECTED;
     }

     if (IFile->ReadOnly) {
       return EFI_ACCESS_DENIED;
     }
   }

   if (Token == NULL) {
     FatWaitNonblockingTask (IFile);
   } else {
     //
     // Caller shouldn't call the non-blocking interfaces if the low layer doesn't support DiskIo2.
     // But if it calls, the below check can avoid crash.
     //
     if (FHand->Revision < EFI_FILE_PROTOCOL_REVISION2) {
       return EFI_UNSUPPORTED;
     }

     Task = FatCreateTask (IFile, Token);
     if (Task == NULL) {
       return EFI_OUT_OF_RESOURCES;
     }
   }

   FatAcquireLock ();

   Status = OFile->Error;
   if (!EFI_ERROR (Status)) {
     if (OFile->ODir != NULL) {
       //
       // Read a directory is supported
       //
       ASSERT (IoMode == ReadData);
       Status = FatIFileReadDir (IFile, BufferSize, Buffer);
       OFile  = NULL;
     } else {
       //
       // Access a file
       //
       EndPosition = IFile->Position + *BufferSize;
       if (EndPosition > OFile->FileSize) {
         //
         // The position goes beyond the end of file
         //
         if (IoMode == ReadData) {
           //
           // Adjust the actual size read
           //
           *BufferSize -= (UINTN)EndPosition - OFile->FileSize;
         } else {
           //
           // We expand the file size of OFile
           //
           Status = FatGrowEof (OFile, EndPosition);
           if (EFI_ERROR (Status)) {
             //
             // Must update the file's info into the file's Directory Entry
             // and then flush the dirty cache info into disk.
             //
             *BufferSize = 0;
             FatOFileFlush (OFile);
             OFile = NULL;
             goto Done;
           }

           FatUpdateDirEntClusterSizeInfo (OFile);
         }
       }

       Status           = FatAccessOFile (OFile, IoMode, (UINTN)IFile->Position, BufferSize, Buffer, Task);
       IFile->Position += *BufferSize;
     }
   }

   if (Token != NULL) {
     if (!EFI_ERROR (Status)) {
       Status = FatQueueTask (IFile, Task);
     } else {
       FatDestroyTask (Task);
     }
   }

 Done:
   //
   // On EFI_SUCCESS case, not calling FatCleanupVolume():
   // 1) The Cache flush operation is avoided to enhance
   // performance. Caller is responsible to call Flush() when necessary.
   // 2) The volume dirty bit is probably set already, and is expected to be
   // cleaned in subsequent Flush() or other operations.
   // 3) Write operation doesn't affect OFile/IFile structure, so
   // Reference checking is not necessary.
   //
   if (EFI_ERROR (Status)) {
     Status = FatCleanupVolume (Volume, OFile, Status, NULL);
   }

   FatReleaseLock ();
   return Status;
 }

 /**

   Get the file info.

   @param  FHand                 - The handle of the file.
   @param  BufferSize            - Size of Buffer.
   @param  Buffer                - Buffer containing read data.


   @retval EFI_SUCCESS           - Get the file info successfully.
   @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
   @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
   @return other                 - An error occurred when operation the disk.

 **/
 EFI_STATUS
 EFIAPI
 FatRead (
   IN     EFI_FILE_PROTOCOL  *FHand,
   IN OUT UINTN              *BufferSize,
   OUT VOID                  *Buffer
   )
 {
   return FatIFileAccess (FHand, ReadData, BufferSize, Buffer, NULL);
 }

 /**

   Get the file info.

   @param  FHand                 - The handle of the file.
   @param  Token                 - A pointer to the token associated with the transaction.

   @retval EFI_SUCCESS           - Get the file info successfully.
   @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
   @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
   @return other                 - An error occurred when operation the disk.

 **/
 EFI_STATUS
 EFIAPI
 FatReadEx (
   IN     EFI_FILE_PROTOCOL  *FHand,
   IN OUT EFI_FILE_IO_TOKEN  *Token
   )
 {
   return FatIFileAccess (FHand, ReadData, &Token->BufferSize, Token->Buffer, Token);
 }

 /**

   Write the content of buffer into files.

   @param  FHand                 - The handle of the file.
   @param  BufferSize            - Size of Buffer.
   @param  Buffer                - Buffer containing write data.

   @retval EFI_SUCCESS           - Set the file info successfully.
   @retval EFI_WRITE_PROTECTED   - The disk is write protect.
   @retval EFI_ACCESS_DENIED     - The file is read-only.
   @retval EFI_DEVICE_ERROR      - The OFile is not valid.
   @retval EFI_UNSUPPORTED       - The open file is not a file.
                         - The writing file size is larger than 4GB.
   @return other                 - An error occurred when operation the disk.

 **/
 EFI_STATUS
 EFIAPI
 FatWrite (
   IN     EFI_FILE_PROTOCOL  *FHand,
   IN OUT UINTN              *BufferSize,
   IN     VOID               *Buffer
   )
 {
   return FatIFileAccess (FHand, WriteData, BufferSize, Buffer, NULL);
 }

 /**

   Get the file info.

   @param  FHand                 - The handle of the file.
   @param  Token                 - A pointer to the token associated with the transaction.

   @retval EFI_SUCCESS           - Get the file info successfully.
   @retval EFI_DEVICE_ERROR      - Can not find the OFile for the file.
   @retval EFI_VOLUME_CORRUPTED  - The file type of open file is error.
   @return other                 - An error occurred when operation the disk.

 **/
 EFI_STATUS
 EFIAPI
 FatWriteEx (
   IN     EFI_FILE_PROTOCOL  *FHand,
   IN OUT EFI_FILE_IO_TOKEN  *Token
   )
 {
   return FatIFileAccess (FHand, WriteData, &Token->BufferSize, Token->Buffer, Token);
 }

 /**

   This function reads data from a file or writes data to a file.
   It uses OFile->PosRem to determine how much data can be accessed in one time.

   @param  OFile                 - The open file.
   @param  IoMode                - Indicate whether the access mode is reading or writing.
   @param  Position              - The position where data will be accessed.
   @param  DataBufferSize        - Size of Buffer.
   @param  UserBuffer            - Buffer containing data.
   @param  Task                    point to task instance.

   @retval EFI_SUCCESS           - Access the data successfully.
   @return other                 - An error occurred when operating on the disk.

 **/
 EFI_STATUS
 FatAccessOFile (
   IN     FAT_OFILE  *OFile,
   IN     IO_MODE    IoMode,
   IN     UINTN      Position,
   IN OUT UINTN      *DataBufferSize,
   IN OUT UINT8      *UserBuffer,
   IN FAT_TASK       *Task
   )
 {
   FAT_VOLUME  *Volume;
   UINTN       Len;
   EFI_STATUS  Status;
   UINTN       BufferSize;

   BufferSize = *DataBufferSize;
   Volume     = OFile->Volume;
   ASSERT_VOLUME_LOCKED (Volume);

   Status = EFI_SUCCESS;
   while (BufferSize > 0) {
     //
     // Seek the OFile to the file position
     //
     Status = FatOFilePosition (OFile, Position, BufferSize);
     if (EFI_ERROR (Status)) {
       break;
     }

     //
     // Clip length to block run
     //
     Len = BufferSize > OFile->PosRem ? OFile->PosRem : BufferSize;

     //
     // Write the data
     //
     Status = FatDiskIo (Volume, IoMode, OFile->PosDisk, Len, UserBuffer, Task);
     if (EFI_ERROR (Status)) {
       break;
     }

     //
     // Data was successfully accessed
     //
     Position   += Len;
     UserBuffer += Len;
     BufferSize -= Len;
     if (IoMode == WriteData) {
       OFile->Dirty   = TRUE;
       OFile->Archive = TRUE;
     }

     //
     // Make sure no outbound occurred
     //
     ASSERT (Position <= OFile->FileSize);
   }

   //
   // Update the number of bytes accessed
   //
   *DataBufferSize -= BufferSize;
   return Status;
 }

 /**

   Expand OFile by appending zero bytes at the end of OFile.

   @param  OFile                 - The open file.
   @param  ExpandedSize          - The number of zero bytes appended at the end of the file.

   @retval EFI_SUCCESS           - The file is expanded successfully.
   @return other                 - An error occurred when expanding file.

 **/
 EFI_STATUS
 FatExpandOFile (
   IN FAT_OFILE  *OFile,
   IN UINT64     ExpandedSize
   )
 {
   EFI_STATUS  Status;
   UINTN       WritePos;

   WritePos = OFile->FileSize;
   Status   = FatGrowEof (OFile, ExpandedSize);
   if (!EFI_ERROR (Status)) {
     Status = FatWriteZeroPool (OFile, WritePos);
   }

   return Status;
 }

 /**

   Write zero pool from the WritePos to the end of OFile.

   @param  OFile                 - The open file to write zero pool.
   @param  WritePos              - The number of zero bytes written.

   @retval EFI_SUCCESS           - Write the zero pool successfully.
   @retval EFI_OUT_OF_RESOURCES  - Not enough memory to perform the operation.
   @return other                 - An error occurred when writing disk.

 **/
 EFI_STATUS
 FatWriteZeroPool (
   IN FAT_OFILE  *OFile,
   IN UINTN      WritePos
   )
 {
   EFI_STATUS  Status;
   VOID        *ZeroBuffer;
   UINTN       AppendedSize;
   UINTN       BufferSize;
   UINTN       WriteSize;

   AppendedSize = OFile->FileSize - WritePos;
   BufferSize   = AppendedSize;
   if (AppendedSize > FAT_MAX_ALLOCATE_SIZE) {
     //
     // If the appended size is larger, maybe we can not allocate the whole
     // memory once. So if the growed size is larger than 10M, we just
     // allocate 10M memory (one healthy system should have 10M available
     // memory), and then write the zerobuffer to the file several times.
     //
     BufferSize = FAT_MAX_ALLOCATE_SIZE;
   }

   ZeroBuffer = AllocateZeroPool (BufferSize);
   if (ZeroBuffer == NULL) {
     return EFI_OUT_OF_RESOURCES;
   }

   do {
     WriteSize     = AppendedSize > BufferSize ? BufferSize : (UINTN)AppendedSize;
     AppendedSize -= WriteSize;
     Status        = FatAccessOFile (OFile, WriteData, WritePos, &WriteSize, ZeroBuffer, NULL);
     if (EFI_ERROR (Status)) {
       break;
     }

     WritePos += WriteSize;
   } while (AppendedSize > 0);

   FreePool (ZeroBuffer);
   return Status;
 }

 /**

   Truncate the OFile to smaller file size.

   @param  OFile                 - The open file.
   @param  TruncatedSize         - The new file size.

   @retval EFI_SUCCESS           - The file is truncated successfully.
   @return other                 - An error occurred when truncating file.

 **/
 EFI_STATUS
 FatTruncateOFile (
   IN FAT_OFILE  *OFile,
   IN UINTN      TruncatedSize
   )
 {
   OFile->FileSize = TruncatedSize;
   return FatShrinkEof (OFile);
 }
	/** @file
	Functions that perform file read/write.

	Copyright (c) 2005 - 2017, Intel Corporation. All rights reserved.<BR>
	SPDX-License-Identifier: BSD-2-Clause-Patent


	**/

	#include "Fat.h"

	/**

	Get the file's position of the file.


	@param FHand - The handle of file.
	@param Position - The file's position of the file.

	@retval EFI_SUCCESS - Get the info successfully.
	@retval EFI_DEVICE_ERROR - Can not find the OFile for the file.
	@retval EFI_UNSUPPORTED - The open file is not a file.

	**/
	EFI_STATUS
	EFIAPI
	FatGetPosition (
	IN EFI_FILE_PROTOCOL *FHand,
	OUT UINT64 *Position
	)
	{
	FAT_IFILE *IFile;
	FAT_OFILE *OFile;

	IFile = IFILE_FROM_FHAND (FHand);
	OFile = IFile->OFile;

	if (OFile->Error == EFI_NOT_FOUND) {
	return EFI_DEVICE_ERROR;
	}

	if (OFile->ODir != NULL) {
	return EFI_UNSUPPORTED;
	}

	*Position = IFile->Position;
	return EFI_SUCCESS;
	}

	/**

	Set the file's position of the file.

	@param FHand - The handle of file.
	@param Position - The file's position of the file.

	@retval EFI_SUCCESS - Set the info successfully.
	@retval EFI_DEVICE_ERROR - Can not find the OFile for the file.
	@retval EFI_UNSUPPORTED - Set a directory with a not-zero position.

	**/
	EFI_STATUS
	EFIAPI
	FatSetPosition (
	IN EFI_FILE_PROTOCOL *FHand,
	IN UINT64 Position
	)
	{
	FAT_IFILE *IFile;
	FAT_OFILE *OFile;

	IFile = IFILE_FROM_FHAND (FHand);
	OFile = IFile->OFile;

	if (OFile->Error == EFI_NOT_FOUND) {
	return EFI_DEVICE_ERROR;
	}

	FatWaitNonblockingTask (IFile);

	//
	// If this is a directory, we can only set back to position 0
	//
	if (OFile->ODir != NULL) {
	if (Position != 0) {
	//
	// Reset current directory cursor;
	//
	return EFI_UNSUPPORTED;
	}

	FatResetODirCursor (OFile);
	}

	//
	// Set the position
	//
	if (Position == (UINT64)-1) {
	Position = OFile->FileSize;
	}

	//
	// Set the position
	//
	IFile->Position = Position;
	return EFI_SUCCESS;
	}

	/**

	Get the file info from the open file of the IFile into Buffer.

	@param IFile - The instance of the open file.
	@param BufferSize - Size of Buffer.
	@param Buffer - Buffer containing read data.

	@retval EFI_SUCCESS - Get the file info successfully.
	@retval other - An error occurred when operation the disk.

	**/
	EFI_STATUS
	FatIFileReadDir (
	IN FAT_IFILE *IFile,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
	)
	{
	EFI_STATUS Status;
	FAT_OFILE *OFile;
	FAT_ODIR *ODir;
	FAT_DIRENT *DirEnt;
	UINT32 CurrentPos;

	OFile = IFile->OFile;
	ODir = OFile->ODir;
	CurrentPos = ((UINT32)IFile->Position) / sizeof (FAT_DIRECTORY_ENTRY);

	//
	// We need to relocate the directory
	//
	if (CurrentPos < ODir->CurrentPos) {
	//
	// The directory cursor has been modified by another IFile, we reset the cursor
	//
	FatResetODirCursor (OFile);
	}

	//
	// We seek the next directory entry's position
	//
	do {
	Status = FatGetNextDirEnt (OFile, &DirEnt);
	if (EFI_ERROR (Status) \|\| (DirEnt == NULL)) {
	//
	// Something error occurred or reach the end of directory,
	// return 0 buffersize
	//
	*BufferSize = 0;
	goto Done;
	}
	} while (ODir->CurrentPos <= CurrentPos);

	Status = FatGetDirEntInfo (OFile->Volume, DirEnt, BufferSize, Buffer);

	Done:
	//
	// Update IFile's Position
	//
	if (!EFI_ERROR (Status)) {
	//
	// Update IFile->Position, if everything is all right
	//
	CurrentPos = ODir->CurrentPos;
	IFile->Position = CurrentPos * sizeof (FAT_DIRECTORY_ENTRY);
	}

	return Status;
	}

	/**

	Get the file info from the open file of the IFile into Buffer.

	@param FHand - The file handle to access.
	@param IoMode - Indicate whether the access mode is reading or writing.
	@param BufferSize - Size of Buffer.
	@param Buffer - Buffer containing read data.
	@param Token - A pointer to the token associated with the transaction.

	@retval EFI_SUCCESS - Get the file info successfully.
	@retval EFI_DEVICE_ERROR - Can not find the OFile for the file.
	@retval EFI_VOLUME_CORRUPTED - The file type of open file is error.
	@retval EFI_WRITE_PROTECTED - The disk is write protect.
	@retval EFI_ACCESS_DENIED - The file is read-only.
	@return other - An error occurred when operating on the disk.

	**/
	EFI_STATUS
	FatIFileAccess (
	IN EFI_FILE_PROTOCOL *FHand,
	IN IO_MODE IoMode,
	IN OUT UINTN *BufferSize,
	IN OUT VOID *Buffer,
	IN EFI_FILE_IO_TOKEN *Token
	)
	{
	EFI_STATUS Status;
	FAT_IFILE *IFile;
	FAT_OFILE *OFile;
	FAT_VOLUME *Volume;
	UINT64 EndPosition;
	FAT_TASK *Task;

	IFile = IFILE_FROM_FHAND (FHand);
	OFile = IFile->OFile;
	Volume = OFile->Volume;
	Task = NULL;

	//
	// Write to a directory is unsupported
	//
	if ((OFile->ODir != NULL) && (IoMode == WriteData)) {
	return EFI_UNSUPPORTED;
	}

	if (OFile->Error == EFI_NOT_FOUND) {
	return EFI_DEVICE_ERROR;
	}

	if (IoMode == ReadData) {
	//
	// If position is at EOF, then return device error
	//
	if (IFile->Position > OFile->FileSize) {
	return EFI_DEVICE_ERROR;
	}
	} else {
	//
	// Check if the we can write data
	//
	if (Volume->ReadOnly) {
	return EFI_WRITE_PROTECTED;
	}

	if (IFile->ReadOnly) {
	return EFI_ACCESS_DENIED;
	}
	}

	if (Token == NULL) {
	FatWaitNonblockingTask (IFile);
	} else {
	//
	// Caller shouldn't call the non-blocking interfaces if the low layer doesn't support DiskIo2.
	// But if it calls, the below check can avoid crash.
	//
	if (FHand->Revision < EFI_FILE_PROTOCOL_REVISION2) {
	return EFI_UNSUPPORTED;
	}

	Task = FatCreateTask (IFile, Token);
	if (Task == NULL) {
	return EFI_OUT_OF_RESOURCES;
	}
	}

	FatAcquireLock ();

	Status = OFile->Error;
	if (!EFI_ERROR (Status)) {
	if (OFile->ODir != NULL) {
	//
	// Read a directory is supported
	//
	ASSERT (IoMode == ReadData);
	Status = FatIFileReadDir (IFile, BufferSize, Buffer);
	OFile = NULL;
	} else {
	//
	// Access a file
	//
	EndPosition = IFile->Position + *BufferSize;
	if (EndPosition > OFile->FileSize) {
	//
	// The position goes beyond the end of file
	//
	if (IoMode == ReadData) {
	//
	// Adjust the actual size read
	//
	*BufferSize -= (UINTN)EndPosition - OFile->FileSize;
	} else {
	//
	// We expand the file size of OFile
	//
	Status = FatGrowEof (OFile, EndPosition);
	if (EFI_ERROR (Status)) {
	//
	// Must update the file's info into the file's Directory Entry
	// and then flush the dirty cache info into disk.
	//
	*BufferSize = 0;
	FatOFileFlush (OFile);
	OFile = NULL;
	goto Done;
	}

	FatUpdateDirEntClusterSizeInfo (OFile);
	}
	}

	Status = FatAccessOFile (OFile, IoMode, (UINTN)IFile->Position, BufferSize, Buffer, Task);
	IFile->Position += *BufferSize;
	}
	}

	if (Token != NULL) {
	if (!EFI_ERROR (Status)) {
	Status = FatQueueTask (IFile, Task);
	} else {
	FatDestroyTask (Task);
	}
	}

	Done:
	//
	// On EFI_SUCCESS case, not calling FatCleanupVolume():
	// 1) The Cache flush operation is avoided to enhance
	// performance. Caller is responsible to call Flush() when necessary.
	// 2) The volume dirty bit is probably set already, and is expected to be
	// cleaned in subsequent Flush() or other operations.
	// 3) Write operation doesn't affect OFile/IFile structure, so
	// Reference checking is not necessary.
	//
	if (EFI_ERROR (Status)) {
	Status = FatCleanupVolume (Volume, OFile, Status, NULL);
	}

	FatReleaseLock ();
	return Status;
	}

	/**

	Get the file info.

	@param FHand - The handle of the file.
	@param BufferSize - Size of Buffer.
	@param Buffer - Buffer containing read data.


	@retval EFI_SUCCESS - Get the file info successfully.
	@retval EFI_DEVICE_ERROR - Can not find the OFile for the file.
	@retval EFI_VOLUME_CORRUPTED - The file type of open file is error.
	@return other - An error occurred when operation the disk.

	**/
	EFI_STATUS
	EFIAPI
	FatRead (
	IN EFI_FILE_PROTOCOL *FHand,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
	)
	{
	return FatIFileAccess (FHand, ReadData, BufferSize, Buffer, NULL);
	}

	/**

	Get the file info.

	@param FHand - The handle of the file.
	@param Token - A pointer to the token associated with the transaction.

	@retval EFI_SUCCESS - Get the file info successfully.
	@retval EFI_DEVICE_ERROR - Can not find the OFile for the file.
	@retval EFI_VOLUME_CORRUPTED - The file type of open file is error.
	@return other - An error occurred when operation the disk.

	**/
	EFI_STATUS
	EFIAPI
	FatReadEx (
	IN EFI_FILE_PROTOCOL *FHand,
	IN OUT EFI_FILE_IO_TOKEN *Token
	)
	{
	return FatIFileAccess (FHand, ReadData, &Token->BufferSize, Token->Buffer, Token);
	}

	/**

	Write the content of buffer into files.

	@param FHand - The handle of the file.
	@param BufferSize - Size of Buffer.
	@param Buffer - Buffer containing write data.

	@retval EFI_SUCCESS - Set the file info successfully.
	@retval EFI_WRITE_PROTECTED - The disk is write protect.
	@retval EFI_ACCESS_DENIED - The file is read-only.
	@retval EFI_DEVICE_ERROR - The OFile is not valid.
	@retval EFI_UNSUPPORTED - The open file is not a file.
	- The writing file size is larger than 4GB.
	@return other - An error occurred when operation the disk.

	**/
	EFI_STATUS
	EFIAPI
	FatWrite (
	IN EFI_FILE_PROTOCOL *FHand,
	IN OUT UINTN *BufferSize,
	IN VOID *Buffer
	)
	{
	return FatIFileAccess (FHand, WriteData, BufferSize, Buffer, NULL);
	}

	/**

	Get the file info.

	@param FHand - The handle of the file.
	@param Token - A pointer to the token associated with the transaction.

	@retval EFI_SUCCESS - Get the file info successfully.
	@retval EFI_DEVICE_ERROR - Can not find the OFile for the file.
	@retval EFI_VOLUME_CORRUPTED - The file type of open file is error.
	@return other - An error occurred when operation the disk.

	**/
	EFI_STATUS
	EFIAPI
	FatWriteEx (
	IN EFI_FILE_PROTOCOL *FHand,
	IN OUT EFI_FILE_IO_TOKEN *Token
	)
	{
	return FatIFileAccess (FHand, WriteData, &Token->BufferSize, Token->Buffer, Token);
	}

	/**

	This function reads data from a file or writes data to a file.
	It uses OFile->PosRem to determine how much data can be accessed in one time.

	@param OFile - The open file.
	@param IoMode - Indicate whether the access mode is reading or writing.
	@param Position - The position where data will be accessed.
	@param DataBufferSize - Size of Buffer.
	@param UserBuffer - Buffer containing data.
	@param Task point to task instance.

	@retval EFI_SUCCESS - Access the data successfully.
	@return other - An error occurred when operating on the disk.

	**/
	EFI_STATUS
	FatAccessOFile (
	IN FAT_OFILE *OFile,
	IN IO_MODE IoMode,
	IN UINTN Position,
	IN OUT UINTN *DataBufferSize,
	IN OUT UINT8 *UserBuffer,
	IN FAT_TASK *Task
	)
	{
	FAT_VOLUME *Volume;
	UINTN Len;
	EFI_STATUS Status;
	UINTN BufferSize;

	BufferSize = *DataBufferSize;
	Volume = OFile->Volume;
	ASSERT_VOLUME_LOCKED (Volume);

	Status = EFI_SUCCESS;
	while (BufferSize > 0) {
	//
	// Seek the OFile to the file position
	//
	Status = FatOFilePosition (OFile, Position, BufferSize);
	if (EFI_ERROR (Status)) {
	break;
	}

	//
	// Clip length to block run
	//
	Len = BufferSize > OFile->PosRem ? OFile->PosRem : BufferSize;

	//
	// Write the data
	//
	Status = FatDiskIo (Volume, IoMode, OFile->PosDisk, Len, UserBuffer, Task);
	if (EFI_ERROR (Status)) {
	break;
	}

	//
	// Data was successfully accessed
	//
	Position += Len;
	UserBuffer += Len;
	BufferSize -= Len;
	if (IoMode == WriteData) {
	OFile->Dirty = TRUE;
	OFile->Archive = TRUE;
	}

	//
	// Make sure no outbound occurred
	//
	ASSERT (Position <= OFile->FileSize);
	}

	//
	// Update the number of bytes accessed
	//
	*DataBufferSize -= BufferSize;
	return Status;
	}

	/**

	Expand OFile by appending zero bytes at the end of OFile.

	@param OFile - The open file.
	@param ExpandedSize - The number of zero bytes appended at the end of the file.

	@retval EFI_SUCCESS - The file is expanded successfully.
	@return other - An error occurred when expanding file.

	**/
	EFI_STATUS
	FatExpandOFile (
	IN FAT_OFILE *OFile,
	IN UINT64 ExpandedSize
	)
	{
	EFI_STATUS Status;
	UINTN WritePos;

	WritePos = OFile->FileSize;
	Status = FatGrowEof (OFile, ExpandedSize);
	if (!EFI_ERROR (Status)) {
	Status = FatWriteZeroPool (OFile, WritePos);
	}

	return Status;
	}

	/**

	Write zero pool from the WritePos to the end of OFile.

	@param OFile - The open file to write zero pool.
	@param WritePos - The number of zero bytes written.

	@retval EFI_SUCCESS - Write the zero pool successfully.
	@retval EFI_OUT_OF_RESOURCES - Not enough memory to perform the operation.
	@return other - An error occurred when writing disk.

	**/
	EFI_STATUS
	FatWriteZeroPool (
	IN FAT_OFILE *OFile,
	IN UINTN WritePos
	)
	{
	EFI_STATUS Status;
	VOID *ZeroBuffer;
	UINTN AppendedSize;
	UINTN BufferSize;
	UINTN WriteSize;

	AppendedSize = OFile->FileSize - WritePos;
	BufferSize = AppendedSize;
	if (AppendedSize > FAT_MAX_ALLOCATE_SIZE) {
	//
	// If the appended size is larger, maybe we can not allocate the whole
	// memory once. So if the growed size is larger than 10M, we just
	// allocate 10M memory (one healthy system should have 10M available
	// memory), and then write the zerobuffer to the file several times.
	//
	BufferSize = FAT_MAX_ALLOCATE_SIZE;
	}

	ZeroBuffer = AllocateZeroPool (BufferSize);
	if (ZeroBuffer == NULL) {
	return EFI_OUT_OF_RESOURCES;
	}

	do {
	WriteSize = AppendedSize > BufferSize ? BufferSize : (UINTN)AppendedSize;
	AppendedSize -= WriteSize;
	Status = FatAccessOFile (OFile, WriteData, WritePos, &WriteSize, ZeroBuffer, NULL);
	if (EFI_ERROR (Status)) {
	break;
	}

	WritePos += WriteSize;
	} while (AppendedSize > 0);

	FreePool (ZeroBuffer);
	return Status;
	}

	/**

	Truncate the OFile to smaller file size.

	@param OFile - The open file.
	@param TruncatedSize - The new file size.

	@retval EFI_SUCCESS - The file is truncated successfully.
	@return other - An error occurred when truncating file.

	**/
	EFI_STATUS
	FatTruncateOFile (
	IN FAT_OFILE *OFile,
	IN UINTN TruncatedSize
	)
	{
	OFile->FileSize = TruncatedSize;
	return FatShrinkEof (OFile);
	}