init. 1AQQW051HEADmaster

1 files changed, 2601 insertions, 0 deletions

diff --git a/Core/EM/FileSystem/Open.c b/Core/EM/FileSystem/Open.c
new file mode 100644
index 0000000..cdfdabf
--- /dev/null
+++ b/Core/EM/FileSystem/Open.c
@@ -0,0 +1,2601 @@
+//**********************************************************************
+//**********************************************************************
+//**                                                                  **
+//**        (C)Copyright 1985-2011, American Megatrends, Inc.         **
+//**                                                                  **
+//**                       All Rights Reserved.                       **
+//**                                                                  **
+//**         5555 Oakbrook Pkwy, Suite 200, Norcross, GA 30093        **
+//**                                                                  **
+//**                       Phone: (770)-246-8600                      **
+//**                                                                  **
+//**********************************************************************
+//**********************************************************************
+
+//**********************************************************************
+// $Header: /Alaska/SOURCE/Core/Modules/FileSystem/Open.c 25    4/30/12 2:02p Pats $
+//
+// $Revision: 25 $
+//
+// $Date: 4/30/12 2:02p $
+//**********************************************************************
+// Revision History
+// ----------------
+// $Log: /Alaska/SOURCE/Core/Modules/FileSystem/Open.c $
+// 
+// 25    4/30/12 2:02p Pats
+// [TAG] EIP87352
+// [Category] Bug Fix
+// [Symptom] FAT Direcotry Opean/Creation Issue
+// [RootCause] If a directory open was attempted with EFI_FILE_MODE_CREATE
+// set, check for existing directory was not done.
+// [Solution] Check for existing directory if opened with
+// EFI_FILE_MODE_CREATE set in ProcessOpenFileHandle(). 
+// [Files] Open.c
+// 
+// 24    11/28/11 11:09a Pats
+// [TAG] - EIP 75631
+// [Category] - BUG FIX
+// [Severity] - Major
+// [Symptom] - If an application name includes a path, it won't run.
+// [Root Cause] - In the function ProcessOpenFileHandle(), the driver
+// attempts to replace "\" in the path with a zero, but the code was one
+// off, and the character past the "\" was being replaced.
+// [Solution] - Modified the function ProcessOpenFileHandle() to replace
+// the proper character.
+// [Files] - Open.c
+// 
+// 23    10/24/11 10:55a Artems
+// EIP 73254: Remove "magic number" from source
+// 
+// 22    5/05/11 3:44p Pats
+// [TAG] - EIP 58999 
+// [Category]- BUG FIX
+// [Severity]- Major
+// [Symptom] - Cannot launch Shell from USB Filesystem device in Debug
+// mode with latest Filesystem driver.
+// [RootCause] - Functions using DISKIO were raising TPL to a fixed level.
+// [Solution] - Modified above functions to check for the higher of the
+// fixed level or current level.
+// [Files] - Info.c, MediaAccess.c, Open.c, FileSystem.h
+// 
+// 21    2/05/11 3:20p Artems
+// Bug fix - restore original TPL in all branches of OpenFileHandle
+// function
+// 
+// 20    1/13/11 12:24p Pats
+// [TAG] - EIP 51705 
+// [Category]- BUG FIX
+// [Severity]- Major
+// [Symptom] - If the volume label is the same name as a directory or
+// file, the directory or file cannot be accessed. Also, a new directory
+// cannot be created with the same name as the volume.
+// [RootCause] - The functions FindMatchingFH() and FindMatchingDirEntry()
+// did not check for ATTR_VOLUME_ID.
+// [Solution] - Modified above functions to check for ATTR_VOLUME_ID.
+// [Files] - open.c
+// 
+// 19    1/06/11 5:53p Oleksiyy
+// [TAG]  		EIP28607 
+// [Category]  	Improvement
+// [Description]  	System was hanging for some time if Floppy Media
+// removed while writing in meda in progress.
+// EFI_TPL_CALLBACK priority level rised during media related calls.
+// 
+// [Files]  		DiskIo.c, Info.c, MediaAccess.c, Open.c, Partition.c
+// 
+// 18    1/06/11 5:03p Pats
+// [TAG] - EIP 49934
+// [Category]- BUG FIX
+// [Severity]- Minor
+// [Symptom] - The new EDKII shell was not displaying filesystem devices
+// properly.
+// [RootCause] - Root directory file name was "\", with a size of one.
+// Shell expected a null name for the root directory.
+// [Solution] - Changed root directory name to null.
+// [Files] - open.c, function OpenRoot().
+// 
+// 17    12/03/10 10:08a Pats
+// EIP 44532: USB key is not returning file list as expected.
+// Problem: ReadFIleHandle was not resetting pointers when a directory
+// read returned an error.
+// Solution. Changed ReadFileHandle to reset pointers on error condition.
+// 
+// 16    7/07/10 3:00p Pats
+// EIP 38291: Fails Klocwork test.
+// Problem: No error return if file handle is null in
+// ProcessOpenFileHandle()
+// Solution: Added error return.
+// Problem: Variable vi initialized improperly.
+// Solution: Changed initialization (moved to after possible error exit).
+// 
+// 15    6/11/10 5:39p Pats
+// EIP 39171: Long name sometimes not displayed, only short name.
+// FetchLongName() in Open.c did not handle case where long name spilt
+// over 2 clusters. Function modified to handle the case.
+// 
+// 14    1/22/10 4:39p Yul
+// Refer to EIP 32983.
+// 
+// 13    12/17/09 12:44p Felixp
+// SCT workaround: CloseFileHandle function is updated to validate input
+// parameter before using it (EIP 32474).
+// SCT passes handle of the deleted file.
+// 
+// 12    7/02/09 5:47p Pats
+// Updated to latest coding standard. No code changes.
+//
+// 11    7/30/08 11:36a Pats
+// Bug fix for file renaming.
+//
+// 10    4/13/07 7:07p Pats
+// Edited to conform with coding standards. No code changes.
+//
+// 9     8/24/06 9:32a Felixp
+// bug fix in CreateDirEntryInDisk
+//
+// 8     8/16/06 12:03p Markw
+// Fixed UINTN* and UINT32* 64-bit issues.
+//
+// Fixed VC7.1 warning msg.
+//
+// 4     6/21/05 4:00p Pats
+// Modified to call MarkVolumeDirty when EFI_VOLUME_CORRUPTED error
+// occurs. Removed commented-out debug code.
+//
+// 3     6/21/05 9:57a Pats
+// Corrected some spelling to match changes in Info.c.
+//
+// 2     5/27/05 10:02a Srinin
+// Fix for Media change and free space calculation.
+//
+// 1     4/26/05 6:05p Srinin
+//
+//
+//
+//**********************************************************************
+
+//<AMI_FHDR_START>
+//----------------------------------------------------------------------
+//
+// Name: Open.c
+//
+// Description:  Handles Opening File Handles.
+//
+//----------------------------------------------------------------------
+//<AMI_FHDR_END>
+
+//----------------------------------------------------------------------
+
+#include "FileSystem.h"
+#define EFI_TPL_CALLBACK TPL_CALLBACK
+//----------------------------------------------------------------------
+
+extern EFI_GUID gEfiFileSystemVolumeLabelGuid;
+extern EFI_GUID gEfiFileInfoGuid;
+extern EFI_GUID gEfiFileSystemInfoGuid;
+
+//----------------------------------------------------------------------
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   OpenVolume
+//
+// Description: Opens a file system Volume.
+//
+// Parameters:
+//  IN  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This - File System Protocol Instance
+//  OUT EFI_FILE_PROTOCOL **Root
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+OpenVolume (
+    IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
+    OUT EFI_FILE_PROTOCOL              **Root
+)
+{
+
+    EFI_STATUS           Status;
+    FILE_HANDLE          *RootHandle = NULL;
+    FILE_HANDLE_INSTANCE *RootInstance = NULL;
+    VOLUME_INFO          *VolumeInfo = (VOLUME_INFO *)This;
+    FAT_TYPE             Old_FAT_Type = VolumeInfo->FatType;
+    UINT32               Length;
+    
+    if (VolumeInfo->RootFH && (VolumeInfo->VolumeStatus == EFI_MEDIA_CHANGED || VolumeInfo->VolumeStatus == EFI_NO_MEDIA)) {
+        FreeUpResources (VolumeInfo, VolumeInfo->VolumeStatus); // Media changed occurred earlier
+    }
+    
+    if (VolumeInfo->RootFH) {
+        if (VolumeInfo->BlkIo->Media->RemovableMedia) {
+            Status = DetectVolume(VolumeInfo, TRUE); // Just reads the sector 0
+            
+            if (EFI_ERROR(Status)) {
+                FreeUpResources (VolumeInfo, Status);
+                goto ContinueOpen;
+            }
+        }
+        
+        RootHandle = VolumeInfo->RootFH;  // Everything is fine
+        
+    } else {
+ContinueOpen:
+        VolumeInfo->VolumeStatus = EFI_UNSUPPORTED;
+        VolumeInfo->BlockSize = VolumeInfo->BlkIo->Media->BlockSize;
+        VolumeInfo->ReadOnly = VolumeInfo->BlkIo->Media->ReadOnly;
+        VolumeInfo->MediaID = VolumeInfo->BlkIo->Media->MediaId;
+        Status = DetectVolume(VolumeInfo, FALSE);
+        
+        if (EFI_ERROR(Status)) return Status;
+        
+        if (Old_FAT_Type && Old_FAT_Type != VolumeInfo->FatType) return EFI_UNSUPPORTED;
+        
+//  Create a FILE_HANDLE for Root Directory. Called for the first time.
+//  VolumeInfo->VolumeSize = VolumeInfo->TotalSectors * VolumeInfo->VolumeBPB.BPB_BytePerSec;
+//  Only count Data Sectors when determining Volume Size, to match DOS
+        VolumeInfo->VolumeSize = Mul64((UINT64)VolumeInfo->DataSectors, (UINT32)VolumeInfo->VolumeBPB.BPB_BytePerSec);
+        VolumeInfo->FreeSpaceinClusters = (UINTN)-1; // Means not calculated yet
+        VolumeInfo->FreeSpaceinSector1 = (UINTN)-1;
+        Status= OpenRoot(VolumeInfo, &RootHandle);
+        VolumeInfo->LastFreeCluster = (UINTN)-1;
+        
+        if (EFI_ERROR(Status)) return Status;
+        
+        VolumeInfo->RootFH = RootHandle;
+		DListAdd((DLIST *)(UINTN)&(VolumeInfo->OpenFHs),(DLINK *)(UINTN)&(RootHandle->ViFHLink)); 
+    }
+    
+    if (!VolumeInfo->FileSystemName) {
+        Status = pBS->AllocatePool (EfiBootServicesData, 80, (VOID**)&VolumeInfo->FileSystemName);
+        Wcscpy (VolumeInfo->FileSystemName, L"FAT");
+        Length = (UINT32) Wcslen(VolumeInfo->FileSystemName);
+        
+        switch (VolumeInfo->FatType) {
+            case  FAT12:
+                Wcscpy (VolumeInfo->FileSystemName + Length, L"12 ");
+                break;
+            case  FAT16:
+                Wcscpy (VolumeInfo->FileSystemName + Length, L"16 ");
+                break;
+            case  FAT32:
+                Wcscpy (VolumeInfo->FileSystemName + Length, L"32 ");
+                break;
+            default:
+                Wcscpy (VolumeInfo->FileSystemName + Length, L"UnKnown ");
+        };
+        
+        Length = (UINT32) Wcslen(VolumeInfo->FileSystemName);
+        
+        Wcscpy (VolumeInfo->FileSystemName + Length, L"File System [");
+        
+        Length = (UINT32) Wcslen(VolumeInfo->FileSystemName);
+        
+        if (VolumeInfo->VolumeSize < 0x100000)  { //Less than 1MB
+            ItowEx(Shr64 (VolumeInfo->VolumeSize, 10), VolumeInfo->FileSystemName + Length, 10, FALSE);
+            Length = (UINT32) Wcslen(VolumeInfo->FileSystemName);
+            Wcscpy (VolumeInfo->FileSystemName + Length, L"KB]");
+            
+        } else if (VolumeInfo->VolumeSize < 0x40000000)  { //Less than 1GB
+            ItowEx(Shr64 (VolumeInfo->VolumeSize, 20), VolumeInfo->FileSystemName + Length, 10, FALSE);
+            Length = (UINT32) Wcslen(VolumeInfo->FileSystemName);
+            Wcscpy (VolumeInfo->FileSystemName + Length, L"MB]");
+            
+        } else {
+            ItowEx(Shr64 (VolumeInfo->VolumeSize, 30), VolumeInfo->FileSystemName + Length, 10, FALSE);
+            Length = (UINT32) Wcslen(VolumeInfo->FileSystemName);
+            Wcscpy (VolumeInfo->FileSystemName + Length, L"GB]");
+        }
+    }
+    
+    
+//  Create a FILE_HANDLE_INSTANCE
+    Status = CreateFileHandleInstance(RootHandle, &RootInstance, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE);
+    
+//  Return FILE_HANDLE_INSTANCE
+    if (Status == EFI_SUCCESS) *Root = (EFI_FILE_PROTOCOL *)RootInstance;
+    
+    VolumeInfo->VolumeStatus = Status;
+    return Status;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure: OpenRoot
+//
+// Description: Opens the Root Directory on the Volume.
+//
+// Parameters:
+//  IN VOLUME_INFO        *VolumeInfo - Volume Info Structure
+//  IN OUT FILE_HANDLE    **Root - Root directory handle
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+OpenRoot(
+    IN VOLUME_INFO     *VolumeInfo,
+    IN OUT FILE_HANDLE **Root
+)
+{
+
+    EFI_STATUS  Status;
+    FILE_HANDLE *RootHandle;
+    
+    Status = fsAllocateMemory(VolumeInfo, sizeof(FILE_HANDLE), (VOID**)&RootHandle, TRUE);
+    
+    if (EFI_ERROR(Status)) return EFI_OUT_OF_RESOURCES;
+    
+    Status = fsAllocateMemory(VolumeInfo, 4, (VOID**)&(RootHandle->FileNameLFN), FALSE);
+    
+    RootHandle->FileNameLFN[0]= 0;
+    RootHandle->ROOTDIR = TRUE;
+    RootHandle->VolumeInterface = VolumeInfo;
+    RootHandle->DirectoryEntry.Dir_Attr =  EFI_FILE_DIRECTORY;
+    RootHandle->HandleStatus=  EFI_SUCCESS;
+    
+    if (VolumeInfo->FatType == FAT32) {
+        RootHandle->DirCluster = VolumeInfo->VolumeBPB.BPB_FAT.BPB_FAT32.BPB_RootClus;
+        RootHandle->DirOffset = 0;
+    }
+    
+	DListInit((DLIST *)(UINTN)&(RootHandle->DirList));
+    *Root = RootHandle;
+    
+    return EFI_SUCCESS;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   CreateFileHandleInstance
+//
+// Description: Creates an instance of a file handle
+//
+// Parameters:
+//  IN FILE_HANDLE              *fh - Handle of the file to work on
+//  IN OUT FILE_HANDLE_INSTANCE **fhi - File handle instance
+//  IN UINT64                   OpenMode - Open mode (read, write, both)
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+CreateFileHandleInstance (
+    IN FILE_HANDLE              *fh,
+    IN OUT FILE_HANDLE_INSTANCE **fhi,
+    IN UINT64                   OpenMode
+)
+{
+
+    EFI_STATUS           Status;
+    VOLUME_INFO          *Vi = fh->VolumeInterface;
+    FILE_HANDLE_INSTANCE *nfi;
+    
+    Status = fsAllocateMemory(Vi, sizeof(FILE_HANDLE_INSTANCE), (VOID**)&nfi, TRUE);
+    
+    if (EFI_ERROR(Status)) return EFI_OUT_OF_RESOURCES;
+    
+    nfi->Position = 0;
+    nfi->HandleInstanceStatus = EFI_SUCCESS;
+    nfi->CurrentCluster = FIRSTCLUSTER(fh->DirectoryEntry);
+    nfi->pFH = fh;
+    nfi->OpenMode = OpenMode;
+    InitEFIFileInterface(&(nfi->FileHandle));
+    fh->InstancesCount++;
+	DListAdd((DLIST *)(UINTN)&(Vi->OpenFIs), (DLINK *)(UINTN)&(nfi->ViFILink));
+    *fhi = nfi;
+    return EFI_SUCCESS;
+    
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   InitEFIFileInterface
+//
+// Description: Initializes the EFI_FILE_PROTOCOL interface
+//
+// Parameters:
+//  EFI_FILE_PROTOCOL *EFIFileInterface - Interface structure
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: OpenProtocol CloseProtocol
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+void
+InitEFIFileInterface (
+    EFI_FILE_PROTOCOL *EFIFileInterface
+)
+{
+
+    EFIFileInterface->Revision = SIMPLE_FILE_SYSTEM_DRIVER_VERSION;
+    EFIFileInterface->Open = OpenFileHandle;
+    EFIFileInterface->Close = CloseFileHandle;
+    EFIFileInterface->Delete = DeleteFileHandle;
+    EFIFileInterface->Read = ReadFileHandle;
+    EFIFileInterface->Write = WriteFileHandle;
+    EFIFileInterface->GetPosition = GetPositionFileHandle;
+    EFIFileInterface->SetPosition = SetPositionFileHandleThis;
+    EFIFileInterface->GetInfo = GetInfoFileHandle;
+    EFIFileInterface->SetInfo = SetInfoFileHandle;
+    EFIFileInterface->Flush = FlushFileHandle;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   OpenFileHandle
+//
+// Description: Opens a file handle (when a file is opened)
+//
+// Parameters:
+//  IN EFI_FILE_PROTOCOL  *This - File System Protocol instance
+//  OUT EFI_FILE_PROTOCOL **NewHandle - Handle of open file
+//  IN CHAR16             *FileName - Unicode name of file
+//  IN UINT64             OpenMode - Open mode (read, write, both)
+//  IN UINT64             Attributes - Attributes of open file
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+OpenFileHandle (
+    IN EFI_FILE_PROTOCOL  *This,
+    OUT EFI_FILE_PROTOCOL **NewHandle,
+    IN CHAR16             *FileName,
+    IN UINT64             OpenMode,
+    IN UINT64             Attributes
+)
+{
+
+    EFI_STATUS           Status;
+    FILE_HANDLE_INSTANCE *Fi= (FILE_HANDLE_INSTANCE *) This;
+	FILE_HANDLE				*ParentFh;
+	VOLUME_INFO				*Vi;
+    EFI_TPL                 SaveTpl;
+    EFI_TPL                 NextTpl;
+#ifdef Debug_OpenFile
+    EfiDebugPrint(-1,"OpenFile: %S OpenMode %lx Attribute %lx\n", FileName, OpenMode, Attributes);
+#endif
+    
+//  Validate Inputs
+    switch (OpenMode) {
+        case (EFI_FILE_MODE_READ):
+        case (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE):
+        case (EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE):
+            break;
+        default:
+            return EFI_INVALID_PARAMETER;
+    }
+    NextTpl = FindNextTpl (EFI_TPL_CALLBACK);
+    SaveTpl = pBS->RaiseTPL (NextTpl);
+	Status = ValidateCurrentStatus (Fi);
+	if (EFI_ERROR(Status)) 
+    {
+        pBS->RestoreTPL(SaveTpl);
+        return Status;
+    }
+    ParentFh = Fi->pFH;
+    Vi = ParentFh->VolumeInterface;
+	if (Vi->ReadOnly && OpenMode & EFI_FILE_MODE_WRITE) 
+    {
+        pBS->RestoreTPL(SaveTpl);
+        return EFI_WRITE_PROTECTED;
+    }
+    if (FileName == NULL) 
+    {
+        pBS->RestoreTPL(SaveTpl);
+        return EFI_NOT_FOUND;
+    }
+    if ( Attributes & ~EFI_FILE_VALID_ATTR) 
+    {
+        pBS->RestoreTPL(SaveTpl);
+        return EFI_NOT_FOUND;
+    }
+    Status = ProcessOpenFileHandle (Fi, &FileName, NewHandle, OpenMode, Attributes);
+    pBS->RestoreTPL(SaveTpl);    
+#ifdef Debug_OpenFile
+    EfiDebugPrint(-1,"OpenFile Status:  %x\n", Status);
+#endif
+    return Status;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   ReadFileHandle
+//
+// Description: Read from a file (normal file or directory)
+//
+// Parameters:
+//  IN EFI_FILE_PROTOCOL *This - File System Protocol instance
+//  IN OUT UINTN         *BufferSize - Size of read buffer
+//  OUT VOID             *Buffer - Points to read buffer
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+ReadFileHandle (
+    IN EFI_FILE_PROTOCOL *This,
+    IN OUT UINTN         *BufferSize,
+    OUT VOID             *Buffer
+)
+{
+
+    EFI_STATUS              Status = EFI_UNSUPPORTED;
+    FILE_HANDLE_INSTANCE    *fhi = (FILE_HANDLE_INSTANCE *)This;
+	FILE_HANDLE				*Pfh;
+	FILE_HANDLE				*fh1; 
+	DIR_ENTRY_LIST			*Del;
+	UINT32					Position;
+    FILE_HANDLE_INSTANCE    TempFhi;
+    FILE_HANDLE             TempPfh;
+    EFI_TPL                 SaveTpl;
+    EFI_TPL                 NextTpl;
+
+    if (*BufferSize > 0xffffffff) return EFI_INVALID_PARAMETER;
+
+    TempFhi = *fhi;
+	Status = ValidateCurrentStatus (fhi);
+	if (EFI_ERROR(Status)) return Status;
+    Pfh = fhi->pFH;
+    TempPfh = *Pfh;
+#ifdef Debug_ReadFile
+	EfiDebugPrint(TRACE_ALWAYS,"ReadFile: %S Position %lx Length %x \n", Pfh->FileNameLFN, fhi->Position, *BufferSize);
+#endif
+    NextTpl = FindNextTpl (EFI_TPL_CALLBACK);
+    SaveTpl = pBS->RaiseTPL (NextTpl);
+
+//  Check if this Instance is a Directory.
+    if (Pfh->DirectoryEntry.Dir_Attr & ATTR_DIRECTORY) {
+    
+//  Check if Dir List has been changed. If so, release the list and read it again.
+        if (Pfh->DirListChanged == TRUE) {
+            RemoveAllDirList (Pfh);
+            Pfh->DirListChanged = FALSE;
+        }
+        
+//  Check if the file Handle has a valid DIR_ENTRY_LIST
+        if (!Pfh->DirList.pHead) {
+            Status = ReadAllDirectoryEntries (Pfh);
+            
+            if (EFI_ERROR(Status)) {
+                pBS->RestoreTPL(SaveTpl);
+                return Status;
+            }
+        }
+        
+//  If Dir_List has been changed, this should take care of it.
+        if (fhi->Position != 0) {
+            Status = LocateDel (Pfh->DirList.pHead, fhi->CurrentCluster, fhi->CurrentClusterOffset, &Del, &Position);
+            fhi->Position = Position;
+        }
+        
+        
+        for (;; fhi->Position++) {
+            Status = GetDirListAtPosition (Pfh, fhi->Position, &Del);
+            
+            if (!Del) {
+                *BufferSize = 0;    //  End of entries
+                pBS->RestoreTPL(SaveTpl);
+                return EFI_SUCCESS;
+            }
+            
+//    Check whether it is a Label
+            if ((Del->DirectoryEntry.Dir_Attr & (ATTR_DIRECTORY | ATTR_VOLUME_ID)) != ATTR_VOLUME_ID)
+                break;
+        }
+        
+///////////////////////////////////////////////
+//A long Process. Do we need to reduce it
+        Status = CreateFHFromDirEntryList(Del, Pfh, &fh1);
+        
+        if (EFI_ERROR(Status)){
+            pBS->RestoreTPL(SaveTpl);
+            return Status;
+        }
+        
+        Status = GetFileInfoFromFH (fh1, BufferSize, Buffer);
+
+        if (EFI_ERROR(Status)) {
+            *fhi = TempFhi;
+            *Pfh = TempPfh;
+            pBS->RestoreTPL(SaveTpl);
+            return Status;
+        }
+
+//A long Process. Do we need to reduce it
+///////////////////////////////////////////////
+
+        fhi->Position++;
+        
+//  Make sure CurrentCluster and CurrentClusterOffset gets updated to the new position
+        for (;; fhi->Position++) {
+            Status = GetDirListAtPosition (Pfh, fhi->Position, &Del);
+            
+            if (!Del) break;
+            
+//    Check whether it is a Label
+            if ((Del->DirectoryEntry.Dir_Attr & (ATTR_DIRECTORY | ATTR_VOLUME_ID)) != ATTR_VOLUME_ID)
+                break;
+        }
+        
+//  Update the CurrentCluster, CurrentClusterOffset for the new position
+        if (Del) {
+            fhi->CurrentCluster =  Del->Cluster;
+            fhi->CurrentClusterOffset = Del->Offset;
+            
+        } else {
+            fhi->CurrentCluster = (UINTN) -1;
+            fhi->CurrentClusterOffset = (UINTN)-1;
+            Status = EFI_SUCCESS;
+        }
+        
+        RemoveFH(fh1);
+        
+    } else {
+//  It is File.
+        //Buffer size is on input is required to be less than 4G.
+        Status = ReadFromFile (fhi, Buffer, (UINT32*)BufferSize, DATA_REGION);
+    }
+    pBS->RestoreTPL(SaveTpl);
+    return Status;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   WriteFileHandle
+//
+// Description: Writes to a file
+//
+// Parameters:
+//  IN EFI_FILE_PROTOCOL *This,
+//  IN OUT UINTN         *BufferSize,
+//  IN VOID              *Buffer
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+WriteFileHandle (
+    IN EFI_FILE_PROTOCOL *This,
+    IN OUT UINTN         *BufferSize,
+    IN VOID              *Buffer
+)
+{
+    EFI_TPL              SaveTpl;
+    EFI_TPL              NextTpl;
+    EFI_STATUS           Status;
+    FILE_HANDLE_INSTANCE *fhi = (FILE_HANDLE_INSTANCE *)This;
+    
+#ifdef Debug_WriteFile
+	FILE_HANDLE				*Pfh;
+	VOLUME_INFO				*vi;
+#endif
+
+    if (*BufferSize > 0xffffffff) return EFI_INVALID_PARAMETER;
+
+	Status = ValidateCurrentStatus (fhi);
+	if (EFI_ERROR(Status)) return Status;
+    NextTpl = FindNextTpl (EFI_TPL_CALLBACK);
+    SaveTpl = pBS->RaiseTPL (NextTpl);
+#ifdef Debug_WriteFile
+	Pfh = fhi->pFH;
+	vi = Pfh->VolumeInterface;	
+	EfiDebugPrint(TRACE_ALWAYS,"WriteFile: %S FSize %x Pos %lx Len %x LoCluster %x\n", 
+				Pfh->FileNameLFN, Pfh->DirectoryEntry.Dir_FileSize, fhi->Position, *BufferSize, Pfh->DirectoryEntry.Dir_FstClusLO);
+#endif
+     
+	Status = CheckFileWrite (fhi, FALSE);
+    if (EFI_ERROR(Status)){
+        pBS->RestoreTPL(SaveTpl); 
+        return Status;
+    }
+    
+    //Buffer size is on input is required to be less than 4G.
+    Status = WriteToFile (fhi, Buffer, (UINT32*)BufferSize, DATA_REGION);
+    pBS->RestoreTPL(SaveTpl);
+    return Status;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   SetInfoFileHandle
+//
+// Description: Sets file info
+//
+// Parameters:
+//  IN EFI_FILE_PROTOCOL  *This,
+//  IN EFI_GUID           *InformationType,
+//  IN UINTN              BufferSize,
+//  IN VOID               *Buffer
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+SetInfoFileHandle(
+    IN EFI_FILE_PROTOCOL *This,
+    IN EFI_GUID          *InformationType,
+    IN UINTN             BufferSize,
+    IN VOID              *Buffer
+)
+{
+
+
+    EFI_STATUS           Status = EFI_UNSUPPORTED;
+    FILE_HANDLE_INSTANCE *fhi = (FILE_HANDLE_INSTANCE *)This;
+	FILE_HANDLE				*Pfh;
+	VOLUME_INFO				*vi;	
+    EFI_TPL                 SaveTpl;
+    EFI_TPL                 NextTpl;
+
+	Status = ValidateCurrentStatus (fhi);
+	if (EFI_ERROR(Status)) return Status;
+    Pfh = fhi->pFH;
+    vi = Pfh->VolumeInterface;
+	if (vi->ReadOnly) return EFI_WRITE_PROTECTED;
+    
+//  Compare the GUID
+    NextTpl = FindNextTpl (EFI_TPL_CALLBACK);
+    SaveTpl = pBS->RaiseTPL (NextTpl);
+    if (!guidcmp(InformationType, &gEfiFileInfoGuid)) {
+        Status = SetfileInfo (This, fhi, BufferSize, Buffer);
+        
+        if (EFI_ERROR(Status)){
+            pBS->RestoreTPL(SaveTpl);
+            return Status;
+        }
+    }
+    
+    else {
+        if (!guidcmp(InformationType, &gEfiFileSystemInfoGuid)) {
+            Status = SetSystemInfo (vi, BufferSize, (EFI_FILE_SYSTEM_INFO *)Buffer);
+            
+            if (EFI_ERROR(Status)){
+                pBS->RestoreTPL(SaveTpl);
+                return Status;
+            }
+            
+            Status = FlushFileHandle(This);
+            
+            if (EFI_ERROR(Status)){
+                pBS->RestoreTPL(SaveTpl);
+                return Status;
+            }
+            
+        } else {
+            if (!guidcmp(InformationType, &gEfiFileSystemVolumeLabelGuid)) {
+                Status = SetVolumeLabel (vi, BufferSize, Buffer);
+                
+                if (EFI_ERROR(Status)){
+                    pBS->RestoreTPL(SaveTpl);
+                    return Status;
+                }
+                
+                Status = FlushFileHandle(This);
+                
+                if (EFI_ERROR(Status)) {
+                    pBS->RestoreTPL(SaveTpl);
+                    return Status;
+                }
+                
+            } else {
+                pBS->RestoreTPL(SaveTpl);
+                return EFI_UNSUPPORTED;
+            }
+        }
+    }
+    
+    pBS->RestoreTPL(SaveTpl);
+    return Status;
+    
+}
+
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   DeleteFileHandle
+//
+// Description: Deletes a file
+//
+// Parameters:
+//  IN EFI_FILE_PROTOCOL *This - File Protocol instance
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes: For FAT32, Cluster(s) occupied by root directory will not be released
+//      as Del/rm command will not give a call to delete RootHandle.
+//      In a empty FAt32 disk, free space will be less by clusters occupied by ROOT Directory
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+DeleteFileHandle (
+    IN EFI_FILE_PROTOCOL *This
+)
+{
+
+    EFI_STATUS           Status;
+    FILE_HANDLE_INSTANCE *fhi = (FILE_HANDLE_INSTANCE *)This, *fhi1;
+	FILE_HANDLE				*fh;
+	FILE_HANDLE				*PPfh;
+	VOLUME_INFO				*vi;	
+	UINT32					ClusterCount;
+//	UINT32					Sector, SectorOffset, ClusterCount;
+	UINT8					DirErase = DIR_ENTRY_ERASE;
+	DLINK					*dlink;
+	DIR_ENTRY_LIST			*Del;
+	UINT32					Position;
+    EFI_TPL                 SaveTpl;
+    EFI_TPL                 NextTpl;
+
+	Status = ValidateCurrentStatus (fhi);
+	if (EFI_ERROR(Status)) return Status;
+
+    fh = fhi->pFH;
+    vi = fh->VolumeInterface;
+    PPfh = fh->Parent;
+    dlink = PPfh->DirList.pHead ;
+
+#ifdef Debug_DeleteFile
+	EfiDebugPrint(TRACE_ALWAYS,"Del File: %S Dir Cluster %x Dir Offset %x\n", fh->FileNameLFN, fh->DirCluster, fh->DirOffset);
+#endif
+    
+
+	if ( vi->ReadOnly || fh->ROOTDIR 
+       || fh->DirectoryEntry.Dir_Attr & ATTR_READ_ONLY
+       || !(fhi->OpenMode & EFI_FILE_MODE_WRITE)){
+
+        CloseFileHandle (This);
+        
+#ifdef Debug_DeleteFile
+        EfiDebugPrint(-1,"DEL WARN FAILURE Instances Open %x\n", fh->InstancesCount);
+#endif
+        return EFI_WARN_DELETE_FAILURE;
+    }
+    
+    if (fh->DirectoryEntry.Dir_Attr & ATTR_DIRECTORY) {
+        if (fh->DirList.Size > 2) {
+            CloseFileHandle (This);
+#ifdef Debug_DeleteFile
+            EfiDebugPrint(-1,"DEL WARN FAILURE Dir Not Empty\n");
+#endif
+            return EFI_WARN_DELETE_FAILURE;
+        }
+        
+//###DEBUG
+//  TODO TODO TODO
+//  Before removing the Directory Entry, check if it is empty.
+//  TODO TODO TODO
+//##DEBUG END
+//    Release all Dir_List
+        RemoveAllDirList(fh);
+    }
+    
+    NextTpl = FindNextTpl (EFI_TPL_CALLBACK);
+    SaveTpl = pBS->RaiseTPL (NextTpl);
+    
+    if (fh->DirCluster || fh->DirOffset) {
+        fh->DirectoryEntry.Dir_Name[0] = DirErase;
+        fh->DirEntryChanged = TRUE;
+//  Update the FAT Chain
+        UnlinkFat(vi, FIRSTCLUSTER(fh->DirectoryEntry), &ClusterCount);
+    }
+    
+//  Check if DIR_LIST is valid. If yes, remove from the list.
+    Status = LocateDel (fh->Parent->DirList.pHead, fh->DirCluster, fh->DirOffset, &Del, &Position);
+    
+    if (!EFI_ERROR(Status)) RemoveDirList(PPfh, Del);
+    
+//  Force next Scan for the parent directory to begin from the beginning
+    fh->Parent->FreeDirEntryCluster = 0;
+    fh->Parent->FreeDirEntryOffset = 0;
+    
+//  Remove File Handle and File List
+    CloseFileHandle (This);
+    
+//  Check for multiple instances
+    if (fh->InstancesCount ) {
+        dlink = vi->OpenFIs.pHead;
+        
+        for ( ; dlink; ) {
+            fhi1 = OUTTER(dlink, ViFILink, FILE_HANDLE_INSTANCE);
+            
+            if (fhi1->pFH == fh) {
+                fhi1->HandleInstanceStatus = EFI_NOT_FOUND;
+                fhi1->pFH = NULL;
+                fh->InstancesCount--;
+            }
+            
+            dlink = dlink->pNext;
+        }
+    }
+    
+    Status = RemoveFH(fh);
+    pBS->RestoreTPL(SaveTpl);    
+#ifdef Debug_DeleteFile
+    EfiDebugPrint(-1,"Del File Success\n");
+#endif
+    
+    return EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   FlushFileHandle
+//
+// Description: Flushes a file (writes any portion left in cache)
+//
+// Parameters:
+//  IN EFI_FILE_PROTOCOL *This - File Protocol instance
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+FlushFileHandle (
+    IN EFI_FILE_PROTOCOL *This
+)
+{
+
+    EFI_STATUS           Status;
+    FILE_HANDLE_INSTANCE *fhi = (FILE_HANDLE_INSTANCE *)This;
+	FILE_HANDLE				*Pfh;
+	VOLUME_INFO				*vi;
+	DLINK					*dlink;
+	CACHE_HEADER			*ch;
+    EFI_TPL                 SaveTpl;
+    EFI_TPL                 NextTpl;
+
+	Status = ValidateCurrentStatus (fhi);
+	if (EFI_ERROR(Status)) return Status;
+
+    Pfh =fhi->pFH;
+    vi = Pfh->VolumeInterface;
+    dlink = vi->CacheList.pHead;
+    if (fhi->OpenMode == EFI_FILE_MODE_READ) return EFI_ACCESS_DENIED;
+    
+    if (vi->ReadOnly) return EFI_ACCESS_DENIED;
+    NextTpl = FindNextTpl (EFI_TPL_CALLBACK);
+    SaveTpl = pBS->RaiseTPL (NextTpl);
+    for ( ; dlink; ) {
+    
+        ch = OUTTER(dlink, CacheLink, CACHE_HEADER);
+        
+        if (ch->DIRTY_FLAG) {
+            Status= vi->DiskIo->WriteDisk (vi->DiskIo, vi->MediaID, ch->AbsoluteOffset, (UINT32) (ch->AbsoluteOffsetEnd - ch->AbsoluteOffset), ch->Buffer);
+            
+            if (EFI_ERROR(Status)) {
+                HandleDiskIoError(vi, Status);
+                pBS->RestoreTPL(SaveTpl);
+                return Status;
+            }
+            
+            ch->DIRTY_FLAG = FALSE;
+        }
+        
+        dlink = dlink->pNext;
+        
+    }
+    pBS->RestoreTPL(SaveTpl);
+    return EFI_SUCCESS;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   ProcessOpenFileHandle
+//
+// Description: Performs whatever is needed to process an open handle
+//              (create dir. entry, create instance, allocate clusters)
+//
+// Parameters:
+//  IN  FILE_HANDLE_INSTANCE  *ParentFi - Parent file handle instance
+//  IN  CHAR16                **FileName - Unicode file name
+//  OUT EFI_FILE_PROTOCOL     **NewHandle - New file handle
+//  IN UINT64                 OpenMode - Open mode (read, write, both)
+//  IN UINT64                 Attributes - File attributes
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+ProcessOpenFileHandle(
+    IN FILE_HANDLE_INSTANCE *Fi,
+    IN CHAR16               **FileName,
+    OUT EFI_FILE_PROTOCOL   **NewHandle,
+    IN UINT64               OpenMode,
+    IN UINT64               Attributes
+)
+{
+
+    EFI_STATUS           Status;
+    FILE_HANDLE          *fh = Fi->pFH, *fh1;
+    VOLUME_INFO          *Vi = fh->VolumeInterface;
+    CHAR16               *Next;
+    UINT32               Length;
+    CHAR16               NextCompName[MAX_TOTAL_PATH_LENGTH];
+    FILE_HANDLE_INSTANCE *fhi;
+    DIR_ENTRY_LIST       *Del;
+    CHAR16               CurrentDir[] = {'.', 0};
+    CHAR16               ParentDir[] = {'.', '.', 0};
+    UINT8                *Buffer;
+    BOOLEAN              DirFound = FALSE;
+
+    if (EFI_ERROR(fh->HandleStatus)) return fh->HandleStatus;
+    
+    Next = *FileName;
+    
+    if ((*FileName)[0] == '\\') {
+        fh = Vi->RootFH;
+        (*FileName) += 1;
+    }
+    
+//  Check for '\\' at the end of the FileName. If so remove it. Eg: \windows\system
+    Length = (UINT32) Wcslen(*FileName);
+    
+    if (Length > 2 && (*FileName)[Length-1] == '\\') (*FileName)[Length-1] = 0;
+    
+    Status = EFI_SUCCESS;
+    
+    while (!          EFI_ERROR(Status)) {
+    
+        if (          EFI_ERROR(GetNextCompName (FileName, NextCompName))) return EFI_NOT_FOUND;
+        
+        if (NextCompName[0] == 0) break;
+        
+        if (!FatLfnIsValid (NextCompName)) return EFI_NOT_FOUND;
+        
+        if (!Wcscmp(NextCompName, CurrentDir)) continue;
+        
+        if (!Wcscmp(NextCompName, ParentDir)) {
+            if (fh == Vi->RootFH) {
+                Status = EFI_NOT_FOUND;
+                break;
+            }
+            
+            fh = fh->Parent;
+            
+            if (!fh) {
+                Status = EFI_NOT_FOUND;
+                break;
+            }
+            
+            continue;
+        }
+        
+//  A component name is present. Parent should be directory. Else return error
+        if (!(fh->DirectoryEntry.Dir_Attr & ATTR_DIRECTORY)) {
+            Status = EFI_NOT_FOUND;
+            break;
+        }
+        
+//  Check whether a match can be found for nextcompname
+        if (FindMatchingFH(Vi, NextCompName, fh, &fh1)) {
+            fh = fh1;
+            Status = EFI_SUCCESS;
+            continue;
+        }
+        
+//  See if the Linked List is Valid
+        if (!fh->DirList.pHead) {
+            ReadAllDirectoryEntries (fh);
+            
+            if (EFI_ERROR(Status)) return Status;
+        }
+        
+        Status = EFI_NOT_FOUND;
+        
+        DirFound = FALSE;
+        if (FindMatchingDirEntry (fh, NextCompName, &Del)) {
+            DirFound = TRUE; // Flag existing directory found
+            Status = CreateFHFromDirEntryList(Del, fh, &fh1);
+            
+            //  Add to the List in Volume Interface
+            if (Status == EFI_SUCCESS) {
+                fh = fh1;
+            }
+        }
+    }
+    
+    if (EFI_ERROR(Status)) {
+    
+//  Make sure NextCompName is the last compname.
+        if ((*FileName[0]) != 0) return EFI_NOT_FOUND;
+        
+//  If it is a file that needs to be openend, and not found create one. For directories return error.
+        if (OpenMode & EFI_FILE_MODE_CREATE) {
+
+            if (!fh) return EFI_NOT_FOUND;
+
+            if (!(fh->DirectoryEntry.Dir_Attr & ATTR_DIRECTORY)) {
+                // if this is not a directory then the input is just a filename. So get the parent handle of this instance
+                fh = fh->Parent;
+            }
+
+//    Create a file entry in the parent directory
+            Status = CreateDirectoryEntry (fh, NextCompName, &fh1, Attributes);
+            
+            if (EFI_ERROR(Status)) return Status;
+            
+            fh = fh1;
+            
+        } else return EFI_NOT_FOUND;
+    }
+    
+//  Create an instance
+    Status = CreateFileHandleInstance (fh, &fhi, OpenMode);
+    *NewHandle = (EFI_FILE_PROTOCOL *) fhi;
+    
+//  If asked to create a directory, and it already exists, the UEFI spec says to
+//  just open and return EFI_SUCCESS.
+    if (DirFound && (OpenMode & EFI_FILE_MODE_CREATE)) {
+        return EFI_SUCCESS;
+    }
+
+    if ((fhi->pFH->DirectoryEntry.Dir_Attr == ATTR_DIRECTORY) &&
+            (OpenMode & EFI_FILE_MODE_CREATE)) { // If creating a new directory, create dot and dotdot entries
+
+//  Allocate Cluster for the sub Directory that was created before.
+//  The new allocated cluster should be cleared.
+//  fsAllocateMemory (Vi, Vi->BytesPerCluster, (void **)&Buffer, TRUE);
+        GetTempBuffer (Vi, &Buffer);
+        Zeromemory (Buffer, Vi->BytesPerCluster);
+        Length = Vi->BytesPerCluster;
+        Status = WriteToFile (fhi, Buffer, &Length, DIRECTORY_REGION);
+        
+        if (EFI_ERROR(Status)) return Status;
+        
+//  fsDeAllocateMemory(Vi, Buffer);
+        ReleaseTempBuffer(Vi);
+        
+        fhi->Position = 0;
+        fhi->pFH->DirectoryEntry.Dir_FileSize = 0;
+        
+        if (fhi->pFH->DirEntryChanged == TRUE) UpdateDirListFromFHDir(fhi->pFH);
+        
+        fhi->pFH->DirEntryChanged = FALSE;
+        fhi->pFH->FreeDirEntryCluster = FIRSTCLUSTER(fh->DirectoryEntry);
+        fhi->pFH->FreeDirEntryOffset = 0;
+        
+//  Create '.' entry
+        Status = CreateDirectoryEntry(fh, CurrentDir, &fh1, ATTR_DIRECTORY);
+        
+        if (EFI_ERROR(Status)) return Status;
+        
+        RemoveFH(fh1);
+        
+//  Create'..' entry
+        Status = CreateDirectoryEntry(fh, ParentDir, &fh1, ATTR_DIRECTORY);
+        
+        if (EFI_ERROR(Status)) return Status;
+        
+        RemoveFH(fh1);
+        
+    }
+    
+    return Status;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   ReadAllDirectoryEntries
+//
+// Description: Reads entries in a directory
+//
+// Parameters:
+//  IN FILE_HANDLE    *fh - File handle structure
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ReadFileHandle, ProcessOpenFileHandle
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+ReadAllDirectoryEntries (
+    IN FILE_HANDLE *fh
+)
+{
+
+    EFI_STATUS  Status;
+    CHAR16      lfn[256], *lfnBuffer;
+    UINT32      Offset, SlotNumber = 0, BufferSize, OrgBufferSize, Slots;
+    UINT32      BytesReadPerLoop;
+    UINT8       *Buffer;
+    VOLUME_INFO *Vi = fh->VolumeInterface;
+    UINT32      ClusterNumber, Cluster;
+    
+    if (Vi->TotalDirEntryList > DIRECTORTY_ENTRIES_CACHED) FreeUpDirEntries (Vi, NULL);
+    
+// Allocate space for a temp buffer.
+    BytesReadPerLoop = Vi->BytesPerCluster;
+    
+    if (fh->ROOTDIR && (Vi->FatType != FAT32))
+        BytesReadPerLoop = Vi->RootDirSectorCount << Vi->BytesPerSecPowerof2;
+        
+    GetTempBuffer (Vi, &Buffer);
+    
+    for (ClusterNumber = 0; ; ClusterNumber++, Cluster = 0) {
+    
+        Status = ReadClusterOfDirectoryEntries(fh, ClusterNumber, &Cluster, Buffer, &BytesReadPerLoop);
+        
+        if (Status == EFI_SUCCESS && BytesReadPerLoop == 0) {
+            break;      // Empty Directory or End of Directory reached
+        }
+        
+        if (EFI_ERROR(Status)) break;
+        
+        OrgBufferSize = BytesReadPerLoop;
+        BufferSize = BytesReadPerLoop;
+        Offset = 0;
+        
+        for ( ; BufferSize; Offset += sizeof (DIR_ENTRY_32), BufferSize = OrgBufferSize - Offset) {
+        
+            if (!(FindShortName (Buffer, &Offset, BufferSize))) break;
+            
+//    Find a matching LFN
+            Slots = FetchLongName(fh, (DIR_ENTRY_32 *)(Buffer), Offset, lfn, ClusterNumber, BytesReadPerLoop);
+            
+            if (Slots == 0) ExtractShortFileName (Vi, lfn, Buffer + Offset);
+            
+            Status = fsAllocateMemory (Vi, (UINT32)((Wcslen(lfn) * sizeof (CHAR16))+ 2), (VOID**)&lfnBuffer, FALSE);
+            pBS->CopyMem (lfnBuffer, lfn, (Wcslen(lfn) * sizeof (CHAR16))+ 2);
+            
+//    Create a Dir Entry List and add it to the Parent File Handle
+//    Valid Entry has been found. *lfn, DirectoryEntry, Offset
+            AddToDirList (fh, *(DIR_ENTRY_32 *)(Buffer + Offset), lfnBuffer, Cluster, Offset, SlotNumber);
+            SlotNumber++;
+        }
+        
+        if (Offset == -1) break;          // No more directory Entries.
+        
+        if (fh->ROOTDIR && (Vi->FatType != FAT32)) break; // Only one loop.
+    }
+    
+    ReleaseTempBuffer (Vi);
+    
+    return Status;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   ReadClusterOfDirectoryEntries
+//
+// Description: Reads one cluster of directory entries
+//
+// Parameters:
+//  IN FILE_HANDLE    *fh,
+//  IN UINT32         ClusterNumber -- 0-based number of which cluster to read
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ReadAllDirectoryEntries
+//
+// Notes: For end of cluster, BufferSize = 0 and EFI_SUCCESS returned.
+//      For FAT12/16, All the Root Directories are read in one shot.
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+ReadClusterOfDirectoryEntries (
+    IN FILE_HANDLE *fh,
+    IN UINT32      ClusterNumber,
+    OUT UINT32     *ClusterRead,
+    UINT8          *Buffer,
+    UINT32         *BufferSize
+)
+{
+    EFI_STATUS  Status;
+    VOLUME_INFO *Vi = fh->VolumeInterface;
+    UINT32      Cluster;
+    UINT32      Sector;
+    UINT32      i;
+    
+// Find the starting sector of the cluster to read.
+    Cluster = FIRSTCLUSTER(fh->DirectoryEntry);
+    
+    if (fh->ROOTDIR && (Vi->FatType != FAT32)) {
+//        Offset = ClusterNumber * (UINT32)Vi->VolumeBPB.BPB_SecPerClus;
+//        if(Offset >= Vi->RootDirSectorCount) return EFI_NOT_FOUND; // Requested cluster is beyond directory
+        if (ClusterNumber) {
+            *BufferSize = 0;
+            return EFI_SUCCESS; // For FAT12/16 root dir, Clusternumber should be always zero.
+        }
+        
+        Sector = Vi->VolumeBPB.BPB_RsvdSecCnt + Vi->FATSz * Vi->VolumeBPB.BPB_NumFATs;
+        *ClusterRead  = Sector;
+        
+    } else {
+        if (Vi->FatType == FAT32 && fh->ROOTDIR) Cluster = Vi->VolumeBPB.BPB_FAT.BPB_FAT32.BPB_RootClus;
+        
+        if (ClusterNumber != 0) {
+            for (i=0; i<ClusterNumber ; i++) { // Follow the fat chain to find the desired cluster
+                Status = ReadFatClusterNumber(Vi, Cluster, 0, &Cluster);
+                
+                if (EFI_ERROR(Status)) return EFI_NOT_FOUND;
+                
+                if (Cluster < 2) {
+                    MarkVolumeDirty (Vi);
+                    return EFI_VOLUME_CORRUPTED;
+                }
+                
+                if (Cluster >= Vi->EOCMark) {
+                    *BufferSize = 0; // End of Directory reached.
+                    return EFI_SUCCESS; // Requested cluster is beyond directory end
+                }
+            }
+        }
+        
+//    Convert this cluster to a sector.
+        Sector = ClusterToSector(Vi, Cluster);
+        *ClusterRead = Cluster;
+    }
+    
+// Read one cluster of the directory into the temp buffer.
+    Status = FsReadMedia (Vi,
+                          Buffer,
+                          (UINT64)Sector,
+                          0,
+                          *BufferSize,
+                          DIRECTORY_REGION);
+                          
+    return Status;
+    
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   AddToDirList
+//
+// Description: Adds a directory entry to DirList
+//
+// Parameters:
+//  IN FILE_HANDLE    *fh - File Handle
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ReadAllDirectoryEntries
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+AddToDirList (
+    FILE_HANDLE  *fh,
+    DIR_ENTRY_32 DirectoryEntry,
+    CHAR16       *lfn,
+    UINT32       Cluster,
+    UINT32       Offset,
+    UINT32       SlotNumber
+
+)
+{
+    DIR_ENTRY_LIST *Del;
+    EFI_STATUS     Status;
+    
+    Status = fsAllocateMemory(fh->VolumeInterface, sizeof(DIR_ENTRY_LIST), (VOID**)&Del, FALSE);
+    
+    if (EFI_ERROR(Status)) return Status;
+    
+    pBS->CopyMem (&(Del->DirectoryEntry), &DirectoryEntry, sizeof(DIR_ENTRY_32));
+    Del->FileNameLFN = lfn;
+    Del->Cluster = Cluster;
+    Del->Offset= Offset;
+    Del->SlotNumber= SlotNumber;
+	DListAdd((DLIST *)(UINTN)&(fh->DirList), (DLINK *)(UINTN)&(Del->DirLink));
+    fh->VolumeInterface->TotalDirEntryList++;
+    return EFI_SUCCESS;
+    
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   CreateFHFromDirEntryList
+//
+// Description: Creates a file handle from directory entry list
+//
+// Parameters:
+//  IN DIR_ENTRY_LIST *Del - Directory entry list
+//  IN FILE_HANDLE    *fh - Directory file handle
+//  OUT FILE_HANDLE   **fh1 - New file handle
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ReadFileHandle, ProcessOpenFileHandle
+//
+// Notes: Should not link the FH to any LIST
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+CreateFHFromDirEntryList(
+    IN DIR_ENTRY_LIST *Del,
+    IN FILE_HANDLE    *fh,
+    OUT FILE_HANDLE   **fh1
+)
+{
+
+    FILE_HANDLE *nfh;
+    EFI_STATUS  Status;
+    
+    Status = fsAllocateMemory(fh->VolumeInterface, sizeof(FILE_HANDLE), (VOID**)&nfh, TRUE);
+    
+    if (EFI_ERROR(Status)) return Status;
+    
+    Status = fsAllocateMemory(fh->VolumeInterface, (UINT32)((Wcslen(Del->FileNameLFN) * sizeof(CHAR16)) + 2), (VOID**)&(nfh->FileNameLFN), FALSE);
+    
+    if (EFI_ERROR(Status)) return Status;
+    
+//  Initialize FILE_HANDLE_STRUCTURE
+    nfh->VolumeInterface = fh->VolumeInterface;
+    nfh->HandleStatus = EFI_SUCCESS;
+    nfh->ROOTDIR = FALSE;
+    pBS->CopyMem (&(nfh->DirectoryEntry), &(Del->DirectoryEntry), sizeof(DIR_ENTRY_32));
+    Wcscpy(nfh->FileNameLFN, Del->FileNameLFN);
+    nfh->DirCluster = Del->Cluster;
+    nfh->DirOffset = Del->Offset;
+    nfh->SlotNumber = Del->SlotNumber;
+    nfh->Parent = fh;
+    *fh1 = nfh;
+    
+//  Add the new FH to the parent's Child List
+	DListAdd((DLIST *)(UINTN)&(fh->ChildList), (DLINK *)(UINTN)&(nfh->ChildLink));
+
+//	Add to VolumeInterface List
+	DListAdd((DLIST *)(UINTN)&(fh->VolumeInterface->OpenFHs), (DLINK *)(UINTN)&(nfh->ViFHLink));
+    
+    return EFI_SUCCESS;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   FindMatchingFH
+//
+// Description: Finds the Child FH, whose name matches with the input.
+//              In the Attributes, check whther both are file or Directory
+//
+// Parameters:
+//  IN VOLUME_INFO  *Vi - Volume info structure
+//  IN CHAR16       *NextCompName - Unicode name to compare
+//  IN FILE_HANDLE  *fh - Parent file handle
+//  OUT FILE_HANDLE **fh1 - Child file handle
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ProcessOpenFileHandle
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+BOOLEAN
+FindMatchingFH (
+    IN VOLUME_INFO  *Vi,
+    IN CHAR16       *NextCompName,
+    IN FILE_HANDLE  *fh,
+    OUT FILE_HANDLE **fh1
+)
+{
+
+
+    DLINK       *fhlink = fh->ChildList.pHead;
+    FILE_HANDLE *fh2;
+    
+    for ( ; fhlink; ) {
+        fh2 = OUTTER(fhlink, ChildLink, FILE_HANDLE);
+        
+        if (!Wcscmpcaseinsensitive (fh2->FileNameLFN, NextCompName)) {
+            if (!(fh2->DirectoryEntry.Dir_Attr & ATTR_VOLUME_ID)) {
+                if (fh2->HandleStatus == EFI_SUCCESS) {
+                    *fh1 = fh2;
+                    return TRUE;
+                }
+            }
+        }
+        
+        fhlink = fhlink->pNext;
+    }
+    
+    return FALSE;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   FindMatchingDirEntry
+//
+// Description: Finds a directory entry matching the input name
+//
+// Parameters:
+//  IN FILE_HANDLE     *fh - Directory file handle
+//  IN CHAR16          *NextCompName - Unicode name to match
+//  OUT DIR_ENTRY_LIST **Del - Directory list where found
+//
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ProcessOpenFileHandle
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+BOOLEAN
+FindMatchingDirEntry (
+    IN FILE_HANDLE     *fh,
+    IN CHAR16          *NextCompName,
+    OUT DIR_ENTRY_LIST **Del
+)
+{
+
+    DLINK          *dlink = fh->DirList.pHead;
+    DIR_ENTRY_LIST *del;
+    
+    for ( ; dlink; ) {
+        del = OUTTER(dlink, DirLink, DIR_ENTRY_LIST);
+        
+        if (!Wcscmpcaseinsensitive (del->FileNameLFN, NextCompName)) {
+            if (!(del->DirectoryEntry.Dir_Attr & ATTR_VOLUME_ID)) {
+                *Del = del;
+                return TRUE;
+            }
+        }
+        
+        dlink = dlink->pNext;
+    }
+    
+    return FALSE;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   FindMatchingSFNDirEntry
+//
+// Description: Finds short file name directory entry matching input
+//
+// Parameters:
+//  IN FILE_HANDLE     *fh - Directory file handle
+//  IN CHAR8           *ShortFileName - Name to find
+//  OUT DIR_ENTRY_LIST **Del - Directory list where found
+//
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals:
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+BOOLEAN
+FindMatchingSFNDirEntry (
+    IN FILE_HANDLE     *fh,
+    IN CHAR8           *ShortFileName,
+    OUT DIR_ENTRY_LIST **Del
+)
+{
+
+    DLINK          *dlink = fh->DirList.pHead;
+    DIR_ENTRY_LIST *del;
+    UINT8          Attrb;
+    
+    for ( ; dlink; ) {
+        del = OUTTER(dlink, DirLink, DIR_ENTRY_LIST);
+        Attrb = del->DirectoryEntry.Dir_Attr;
+        del->DirectoryEntry.Dir_Attr = 0; // Generate a NULL terminated string
+        
+        if (!Strcmp((CHAR8 *)&del->DirectoryEntry, ShortFileName)) {
+            del->DirectoryEntry.Dir_Attr = Attrb; // restore Attribute
+            *Del = del;
+            return TRUE;
+        }
+        
+        del->DirectoryEntry.Dir_Attr = Attrb; // restore Attribute
+        dlink = dlink->pNext;
+    }
+    
+    return FALSE;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   Wcscmpcaseinsensitive
+//
+// Description: Case insensitive unicode string compare
+//
+// Parameters:
+//  CHAR16 *string1 - First string
+//  CHAR16 *string2 - Second string
+//
+// Return Value:
+//  INT - Difference where mis-matched
+//
+// Modified:
+//
+// Referrals: FindMatchingFH, FindMatchingDirEntry
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+int Wcscmpcaseinsensitive(
+    CHAR16 *string1,
+    CHAR16 *string2
+)
+{
+
+    CHAR16 ch1, ch2;
+    
+    while (*string1) {
+        if (*string1 >=0x61 && *string1<=0x7a) ch1 = *string1 - 0x20;
+        
+        else ch1 = *string1;
+        
+        if (*string2 >=0x61 && *string2<=0x7a) ch2 = *string2 - 0x20;
+        
+        else ch2 = *string2;
+        
+        if (ch1 != ch2) break;
+        
+        *string1++;
+        *string2++;
+    }
+    
+    return *string1 - *string2;     // Don't use ch1 - ch2
+}
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   GetDirListAtPosition
+//
+// Description: Get directory list at current position in directory file
+//
+// Parameters:
+//  FILE_HANDLE       *Pfh - Parent file handle
+//  UINT64            Position - Current position
+//  DIR_ENTRY_LIST    **Del - Directory entry list
+//
+// Return Value:
+//
+// Modified:
+//
+// Referrals: ReadFileHandle
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+GetDirListAtPosition(
+    FILE_HANDLE    *Pfh,
+    UINT64         Position,
+    DIR_ENTRY_LIST **Del
+)
+{
+
+    EFI_STATUS Status = EFI_NOT_FOUND;
+    DLINK      *dlink = Pfh->DirList.pHead;
+    
+    *Del = NULL;
+    
+    if (!dlink) return Status;
+    
+    while (Position && dlink) {
+        if (!dlink->pNext) break;
+        
+        dlink = dlink->pNext;
+        Position--;
+    };
+    
+    if (Position == 0 && dlink) {
+        Status = EFI_SUCCESS;
+        *Del = OUTTER(dlink, DirLink, DIR_ENTRY_LIST);
+    }
+    
+    return Status;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   CloseFileHandle
+//
+// Description: Closes an open file
+//
+// Parameters:
+//  IN EFI_FILE_PROTOCOL *This - File Protocol instance
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: DeleteFileHandle
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+CloseFileHandle (
+    IN EFI_FILE_PROTOCOL *This
+)
+{
+
+    EFI_STATUS           Status;
+    FILE_HANDLE_INSTANCE *fhi = (FILE_HANDLE_INSTANCE *)This;
+    FILE_HANDLE          *Pfh = fhi->pFH;
+    VOLUME_INFO          *vi;	
+    void                 *Buffer;
+    UINT32               BufferSize, Difference;
+    EFI_TPL              SaveTpl;
+    EFI_TPL              NextTpl;
+
+	Status = ValidateCurrentStatus (fhi);
+	if (EFI_ERROR(Status)) return Status;
+    
+#ifdef Debug_CloseFileHandle
+    EfiDebugPrint(-1,"CloseFileHandle: %S Dir Cluster %x Dir Offset %x\n", Pfh->FileNameLFN, Pfh->DirCluster, Pfh->DirOffset);
+#endif
+    
+//  Device Removal or Media Not Present
+    if (!Pfh) {
+        Status = pBS->FreePool(fhi);
+        return EFI_SUCCESS;
+    }
+    NextTpl = FindNextTpl (EFI_TPL_CALLBACK);
+    SaveTpl = pBS->RaiseTPL (NextTpl);    
+    vi = Pfh->VolumeInterface;
+
+//  Check if FreeSpace and Last Free Cluster needs to be updated for FAT32
+    if (vi->FatType == FAT32 && vi->FreeSpaceinClusters != -1) {
+        Difference = vi->FreeSpaceinSector1 - vi->FreeSpaceinClusters;
+        
+        if (vi->FreeSpaceinSector1 < vi->FreeSpaceinClusters) Difference = vi->FreeSpaceinClusters - vi->FreeSpaceinSector1;
+        
+        if (Difference > 0x100) {
+//      ReadFSInfo
+            BufferSize = vi->VolumeBPB.BPB_BytePerSec;
+            GetTempBuffer (vi, &Buffer);
+            
+            Status = FsReadMedia (vi, Buffer, (UINT64)vi->VolumeBPB.BPB_FAT.BPB_FAT32.BPB_FSInfo, FSI_Free_Count, 8, FAT_REGION);
+            
+            if (EFI_ERROR(Status)) goto Memallocate_error;
+            
+            *(UINT32 *) ((UINT8 *)Buffer) = vi->FreeSpaceinClusters;
+            *(UINT32 *) ((UINT8 *)Buffer + 4) = vi->LastFreeCluster;
+            Status = FsWriteMedia (vi, Buffer, (UINT64)vi->VolumeBPB.BPB_FAT.BPB_FAT32.BPB_FSInfo, FSI_Free_Count, 8, FAT_REGION);
+            vi->FreeSpaceinSector1 = vi->FreeSpaceinClusters;
+            ReleaseTempBuffer(vi);
+        }
+    }
+    
+Memallocate_error:
+
+    if (Pfh->DirEntryChanged == TRUE) {
+        UpdateDirListFromFHDir(Pfh);
+        Pfh->DirEntryChanged = FALSE;
+    }
+    
+	DListDelete ((DLIST *)(UINTN)&(vi->OpenFIs), (DLINK *)(UINTN)&(fhi->ViFILink));
+    fsDeAllocateMemory (vi, fhi);
+    
+    if (vi->TotalDirEntryList > DIRECTORTY_ENTRIES_CACHED) {
+        if (vi->OpenFHs.Size > MAX_OPEN_FHS) FreeUpFHEntries (vi, NULL);
+        
+        FreeUpDirEntries (vi, Pfh->Parent);
+    }
+    
+//  This should be always after FreeUpDirEntries. When called from 
+//  DeleteFileHandle will have problem otherwise.
+    if (Pfh) Pfh->InstancesCount -= 1;  
+    
+    FlushFileHandle(This);
+    
+    pBS->RestoreTPL(SaveTpl);
+
+    return EFI_SUCCESS;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   FreeUpFHEntries
+//
+// Description: Release all file handles whose instance count is 0
+//
+// Parameters:
+//  VOLUME_INFO       *vi - Volume info
+//  FILE_HANDLE       *pfh - Parent file handle
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: CloseFileHandle
+//
+// Notes:
+//  Don't remove pfh
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+FreeUpFHEntries (
+    VOLUME_INFO *vi,
+    FILE_HANDLE *pfh
+)
+{
+
+    DLINK       *dlink = vi->OpenFHs.pHead;
+    FILE_HANDLE *lfh;
+    
+//  Go through all the FHs in Volume Interface and release all whose Instance
+//  count is 0, no DIR list is present and childlist is NULL
+//  Don't delete:
+//  1. If Instance count is more than 0 
+//  2. If Dir List is present,
+//  3. If it is a Root Dir, 
+//  4. If Child List is present, 
+//  5. If it is a i/p fh
+//  6. If the i/p FH is the parent of the fh.
+    for ( ; dlink; ) {
+        lfh = OUTTER(dlink, ViFHLink, FILE_HANDLE);
+        dlink = dlink->pNext;
+        
+        if (lfh->InstancesCount == 0 && !(lfh->DirList.pHead) &&
+                !(lfh->ROOTDIR) && !(lfh->ChildList.pHead) && lfh != pfh) RemoveFH(lfh);
+    }
+    
+    return EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   FreeUpDirEntries
+//
+// Description: Free up cached directory entries
+//
+// Parameters:
+//  VOLUME_INFO       *vi - Volume info
+//  FILE_HANDLE       *pfh - Parent file handle
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ReadAllDirectoryEntries, CloseFileHandle
+//
+// Notes:
+//  Don't remove pfh
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+FreeUpDirEntries (
+    VOLUME_INFO *vi,
+    FILE_HANDLE *pfh
+)
+{
+
+    DLINK       *dlink = vi->OpenFHs.pHead;
+    FILE_HANDLE *lfh;
+    
+    for ( ; dlink; ) {
+        if (vi->TotalDirEntryList <= DIRECTORTY_ENTRIES_CACHED) break;
+        
+        lfh = OUTTER(dlink, ViFHLink, FILE_HANDLE);
+        
+        if (lfh != pfh && lfh->DirList.pHead) RemoveAllDirList(lfh);
+        
+        dlink = dlink->pNext;
+    }
+    
+    return EFI_SUCCESS;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   RemoveAllDirList
+//
+// Description: Removes all directory lists from cache (needs to be re-read)
+//
+// Parameters:
+//  FILE_HANDLE *lfh - list file handle
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ReadFileHandle, DeleteFileHandle, FreeUpDirEntries
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+RemoveAllDirList(
+    FILE_HANDLE *lfh
+)
+{
+
+    DLINK          *dlink = lfh->DirList.pHead;
+    DIR_ENTRY_LIST *Del;
+    
+    for ( ; dlink; ) {
+        Del = OUTTER(dlink, DirLink, DIR_ENTRY_LIST);
+        dlink = dlink->pNext;
+        RemoveDirList (lfh, Del);
+    }
+    
+    return EFI_SUCCESS;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   RemoveDirList
+//
+// Description: Removes a directory list from cache
+//
+// Parameters:
+//  FILE_HANDLE    *fh - Directory file handle
+//  DIR_ENTRY_LIST *Del - Directory list
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: DeleteFileHandle, RemoveAllDirList
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+RemoveDirList (
+    FILE_HANDLE    *fh,
+    DIR_ENTRY_LIST *Del
+)
+{
+
+    fh->VolumeInterface->TotalDirEntryList--;
+    
+    fsDeAllocateMemory (fh->VolumeInterface, Del->FileNameLFN);
+	DListDelete ((DLIST *)(UINTN)&(fh->DirList), (DLINK *)(UINTN)&(Del->DirLink));
+    fsDeAllocateMemory (fh->VolumeInterface, Del);
+    return EFI_SUCCESS;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   FetchLongName
+//
+// Description: Fetch a long name from a directory entry
+//
+// Parameters:
+//  FILE_HANDLE  *fh - File handle of the directory
+//  DIR_ENTRY_32 *Buffer - Buffer containing directory entry
+//  UINT32       BufferPos - Position in buffer
+//  UINT16       *Name - Unicode name placed here
+//  UINT32       ClusterNumber - Current directory cluster
+//  UINT32       ClusterSize - Cluster size in bytes
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ReadAllDirectoryEntries
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+UINT8
+FetchLongName (
+    FILE_HANDLE  *fh,
+    DIR_ENTRY_32 *Buffer,
+    UINT32       BufferPos,
+    UINT16       *Name,
+    UINT32       ClusterNumber,
+    UINT32       ClusterSize
+)
+{
+
+    DIR_ENTRY_LFN *LfnSlot  = (DIR_ENTRY_LFN *) ((UINT8 *)Buffer + BufferPos);
+    UINT8         Checksum = LfnChecksum((UINT8 *) Buffer + BufferPos);
+    CHAR8         Order    = 0;
+    UINT32        NamePos  = 0;
+    UINT32        k;
+    UINT32        Cluster = 0;
+    EFI_STATUS    Status;
+    BOOLEAN       Backup = FALSE;
+    
+    do {
+        if (--LfnSlot < (DIR_ENTRY_LFN *) Buffer) { // Long name is split over 2 clusters
+            Status = ReadClusterOfDirectoryEntries(fh, ClusterNumber-1, &Cluster, (UINT8*)Buffer, &ClusterSize);
+            Backup = TRUE; // We had to back up into the previous cluster to get the whole name
+            if (EFI_ERROR(Status) || (Status == EFI_SUCCESS && ClusterSize == 0)) { Order = 0; goto exit; };
+            LfnSlot  = (DIR_ENTRY_LFN *) ((UINT8 *)Buffer + ClusterSize);
+            LfnSlot--;
+        }
+        if (Order > MAX_LFN_SLOTS) { Order = 0; goto exit; };    // Max of 20 LFN slots are possible 255 chars max.
+        
+        if ((LfnSlot->Dir_Attr & ATTR_LONG_NAME_MASK) != (ATTR_LONG_NAME)) { Order = 0; goto exit; };
+        
+        if (++Order != (LfnSlot->Dir_Order & 0x1F)) { Order = 0; goto exit; };
+        
+        if (Checksum != LfnSlot->Dir_Checksum) { Order = 0; goto exit; };
+        
+        // Ok, the LFN slot is valid, attach it to the long name
+        for (k = 0; k < 5; k++) Name[NamePos++] = LfnSlot->Dir_Name0_4[k];
+        
+        for (k = 0; k < 6; k++) Name[NamePos++] = LfnSlot->Dir_Name5_10[k];
+        
+        for (k = 0; k < 2; k++) Name[NamePos++] = LfnSlot->Dir_Name11_12[k];
+    } while (!(LfnSlot->Dir_Order & 0x40));
+    
+// If the name was exactly 13 characters long in the last slot, add a terminating zero.
+// Otherwise, it will already end in a zero.
+    if (Name[NamePos - 1] != 0x0000) Name[NamePos] = 0x0000;
+exit:
+    if (Backup) { // Re-read the old cluster if we had to back up
+        Status = ReadClusterOfDirectoryEntries(fh, ClusterNumber, &Cluster, (UINT8*)Buffer, &ClusterSize);
+        if (EFI_ERROR(Status)) Order = 0;
+    }
+    return Order;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   LfnChecksum
+//
+// Description: Calculate long file name entry section checksum
+//
+// Parameters:
+//  UINT8 *D - Pointer to long name entry
+//
+//
+// Return Value:
+//  UINT8 - Checksum
+//
+// Modified:
+//
+// Referrals: FetchLongName
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+UINT8
+LfnChecksum(
+    UINT8 *D
+)
+{
+    UINT8 Sum = 0;
+    UINT8 i;
+    
+    for (i = 11; i != 0; i--) {
+        Sum = ((Sum & 1)  ? 0x80 : 0) + (Sum >> 1) + *D++;
+    }
+    
+    return Sum;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   FindShortName
+//
+// Description: Return a valid short name Directory Entry from DirCluster
+//              beginning from ReadPosition.
+//
+// Parameters:
+//    UINT8       *Buffer - Buffer to search in
+//    UINT32      *Offset - Offset in buffer where entry found
+//    UINT32      BufferSize - Size of buffer
+//
+//
+// Return Value:
+//  BOOLEAN - True = name found
+//
+// Modified:
+//
+// Referrals: ReadAllDirectoryEntries
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+BOOLEAN
+FindShortName (
+    UINT8  *Buffer,
+    UINT32 *Offset,
+    UINT32 BufferSize
+)
+{
+    DIR_ENTRY_32 *Entry  = (DIR_ENTRY_32 *)(Buffer + *Offset);
+    UINT32       i;
+    
+    for (i = *Offset; BufferSize; i+=sizeof(DIR_ENTRY_32),BufferSize-=sizeof(DIR_ENTRY_32)) {
+        if (Entry->Dir_Name[0] == 0) {
+			*Offset = (UINTN)-1;
+            return FALSE; // no more directory Entries.
+        }
+        
+        if (((Entry->Dir_Attr & ATTR_LONG_NAME_MASK) != (ATTR_LONG_NAME)) &&
+                (Entry->Dir_Name[0] > 0x1f) &&
+                (Entry->Dir_Name[0] != 0xe5)) {
+            *Offset = i; // Point offset to short name found
+            
+            return TRUE;
+        }
+        
+        Entry++;
+    }
+    
+    return FALSE;
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   CreateDirectoryEntry
+//
+// Description: Creates a directory entry
+//
+// Parameters:
+//  IN  FILE_HANDLE       *fh - File handle
+//  IN  CHAR16            *NextCompName - Unicode name to create
+//  OUT FILE_HANDLE       **fh1 - File handle for new name
+//  IN UINT64             Attributes
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ProcessOpenFileHandle
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+CreateDirectoryEntry (
+    IN FILE_HANDLE  *fh,
+    IN CHAR16       *NextCompName,
+    OUT FILE_HANDLE **fh1,
+    IN UINT64       Attributes
+)
+{
+
+    EFI_STATUS     Status;
+    UINT32         DirCluster, DirClusterOffset;
+    UINT32         Length;
+    CHAR8          DirEntry[32];
+    DIR_ENTRY_32   *Entry = (DIR_ENTRY_32 *) &DirEntry;
+    CHAR16         *lfn;
+    DIR_ENTRY_LIST *Del;
+    
+    Status = CreateDirEntryInDisk (fh, NextCompName, Attributes, &DirCluster, &DirClusterOffset, Entry);
+    
+    if (EFI_ERROR(Status)) return Status;
+    
+//  Create a Dir_List Entry
+    Length = (UINT32)(Wcslen(NextCompName) * sizeof(CHAR16)) + 2;
+    Status = fsAllocateMemory(fh->VolumeInterface, (UINT32) Length, (VOID**)&lfn, FALSE);
+    pBS->CopyMem(lfn, NextCompName, Length);
+    AddToDirList (fh, *Entry, lfn, DirCluster, DirClusterOffset, (UINTN)-1);
+    
+    Del = OUTTER(fh->DirList.pTail, DirLink, DIR_ENTRY_LIST);
+//  Create a File Handle
+    Status = CreateFHFromDirEntryList(Del, fh, fh1);
+    return Status;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   CreateDirEntryInDisk
+//
+// Description: Creates a directory entry on the disk
+//
+// Parameters:
+//  IN  FILE_HANDLE     *fh - File handle
+//  IN  CHAR16          *NextCompName - Name to create
+//  IN  UINT64          Attributes - Attributes for entry
+//  OUT UINT32          *DirCluster - Cluster of entry created
+//  OUT UINT32          *DirClusterOffset - Offset in cluster
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: CreateDirectoryEntry
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+EFI_STATUS
+CreateDirEntryInDisk (
+    IN FILE_HANDLE *fh,
+    IN CHAR16      *NextCompName,
+    IN UINT64      Attributes,
+    OUT UINT32     *DirCluster,
+    OUT UINT32     *DirClusterOffset,
+    DIR_ENTRY_32   *Entry
+)
+{
+
+    EFI_STATUS            Status;
+    VOLUME_INFO           *Vi = fh->VolumeInterface;
+    CHAR8                 ShortFileName[11];
+    EFI_TIME              EfiTime;
+    EFI_TIME_CAPABILITIES Capabilities;
+    UINT32                Sector, SectorOffset;
+    BOOLEAN               LastDirEntry = FALSE;
+    UINT32                Length;
+    BOOLEAN               LfnNeeded = FALSE;
+    UINT8                 *Slots;
+    UINT32                NumSlots = 0;
+    
+    if (Vi->ReadOnly) return EFI_WRITE_PROTECTED;
+    
+    Status = GenUniqueShortFname (fh, NextCompName, ShortFileName, &LfnNeeded);
+    
+    if (EFI_ERROR(Status)) return Status;
+    
+//  Create Short Directory entry
+    Zeromemory (Entry, sizeof(DIR_ENTRY_32));
+    pBS->CopyMem(Entry, ShortFileName, 11);
+    Entry->Dir_Attr         = (UINT8)Attributes;
+    pRS->GetTime(&EfiTime, &Capabilities);
+    EfiToFatTime (EfiTime, &Entry->Dir_CrtDate, &Entry->Dir_CrtTime);
+    Entry->Dir_LstAccDate   = Entry->Dir_CrtDate;
+    Entry->Dir_WrtTime      = Entry->Dir_CrtTime;
+    Entry->Dir_WrtDate      = Entry->Dir_CrtDate;
+    
+//  Update the Cluster number in case of '.' entry.
+    if (NextCompName[0] == '.' && NextCompName[1] == 0) {
+        Length = FIRSTCLUSTER(fh->DirectoryEntry);
+        Entry->Dir_FstClusHI = (UINT16)  (Length >> 16);
+        Entry->Dir_FstClusLO = (UINT16)  Length;
+    }
+    
+    
+    fsAllocateMemory (Vi, (MAX_LFN_SLOTS + 2) * sizeof(DIR_ENTRY_32), (void **)&Slots, FALSE);
+    
+    if (LfnNeeded) {
+        Status = SplitLFN (NextCompName, Entry, (DIR_ENTRY_LFN *)Slots, &NumSlots);
+        
+        if (EFI_ERROR(Status)) goto Error;
+    }
+    
+// Assuming a short filename FILENAME.EXT (FILENAMEEXT), generate a
+// name in the form FILENA~1.EXT, where n is a count beginning with 1.
+//  GenUniqueFileName(fh, NextCompName, &ShortFileName);
+
+//  Append Short Directory Entry at the End of Long File Name slots
+    Length = NumSlots * sizeof(DIR_ENTRY_32);
+    pBS->CopyMem(Slots + Length, Entry, sizeof(DIR_ENTRY_32));
+    Length += sizeof(DIR_ENTRY_32);   // This is the total length
+    
+    Status = LocateFreeDirEntry(fh, Length, DirCluster,
+                                DirClusterOffset,  &LastDirEntry);
+                                
+    if (EFI_ERROR(Status)) goto Error;
+    
+    GetSectorAddressDir(fh, *DirCluster, *DirClusterOffset, &Sector, &SectorOffset);
+    Status = FsWriteMedia (Vi, Slots, Sector, SectorOffset, Length, DIRECTORY_REGION);
+    
+    if (EFI_ERROR(Status)) goto Error;
+    
+    *DirClusterOffset += Length;
+    
+    if (LastDirEntry == TRUE) {
+        fh->FreeDirEntryCluster = *DirCluster;
+        fh->FreeDirEntryOffset = *DirClusterOffset;
+        
+    } else {
+        fh->DirListChanged = TRUE;
+    }
+    
+    *DirClusterOffset -= sizeof(DIR_ENTRY_32);
+    
+Error:
+
+    fsDeAllocateMemory (Vi, Slots);
+    
+    return Status;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   GetTempBuffer
+//
+// Description: Gets a temporary buffer
+//
+// Parameters:
+//    VOLUME_INFO     *Vi - Volume info
+//    VOID            **Buffer - Buffer
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ProcessOpenFileHandle, ReadAllDirectoryEntries, CloseFileHandle
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+VOID
+GetTempBuffer (
+    VOLUME_INFO *Vi,
+    VOID        **Buffer
+)
+{
+
+    *Buffer = (UINT8 *)(Vi->TempBuffer);
+    Vi->TempBufferInUse = TRUE;
+    
+}
+
+
+//<AMI_PHDR_START>
+//----------------------------------------------------------------------
+//
+// Procedure:   ReleaseTempBuffer
+//
+// Description: Releases a temporary buffer
+//
+// Parameters:
+//  VOLUME_INFO     *Vi - Volume Info
+//
+// Return Value:
+//  EFI_STATUS
+//
+// Modified:
+//
+// Referrals: ProcessOpenFileHandle, ReadAllDirectoryEntries, CloseFileHandle
+//
+// Notes:
+//
+//----------------------------------------------------------------------
+//<AMI_PHDR_END>
+
+VOID
+ReleaseTempBuffer (
+    VOLUME_INFO *Vi
+)
+{
+    Vi->TempBufferInUse = FALSE;
+}
+
+//**********************************************************************
+//**********************************************************************
+//**                                                                  **
+//**        (C)Copyright 1985-2011, American Megatrends, Inc.         **
+//**                                                                  **
+//**                       All Rights Reserved.                       **
+//**                                                                  **
+//**         5555 Oakbrook Pkwy, Suite 200, Norcross, GA 30093        **
+//**                                                                  **
+//**                       Phone: (770)-246-8600                      **
+//**                                                                  **
+//**********************************************************************
+//**********************************************************************