EmuSimpleFileSystem.c

/*++ @file
  Produce Simple File System abstractions for directories on your PC using Posix APIs.
  The configuration of what devices to mount or emulate comes from UNIX
  environment variables. The variables must be visible to the Microsoft*
  Developer Studio for them to work.
 
Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
Portions copyright (c) 2011, Apple Inc. All rights reserved.
SPDX-License-Identifier: BSD-2-Clause-Patent
 
**/
 
#include "EmuSimpleFileSystem.h"
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemOpen (
  IN  EFI_FILE_PROTOCOL  *This,
  OUT EFI_FILE_PROTOCOL  **NewHandle,
  IN  CHAR16             *FileName,
  IN  UINT64             OpenMode,
  IN  UINT64             Attributes
  )
{
  EFI_STATUS            Status;
  EFI_TPL               OldTpl;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EMU_EFI_FILE_PRIVATE  *NewPrivateFile;
 
  //
  // Check for obvious invalid parameters.
  //
  if ((This == NULL) || (NewHandle == NULL) || (FileName == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  switch (OpenMode) {
    case EFI_FILE_MODE_CREATE | EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:
      if (Attributes &~EFI_FILE_VALID_ATTR) {
        return EFI_INVALID_PARAMETER;
      }
 
      if (Attributes & EFI_FILE_READ_ONLY) {
        return EFI_INVALID_PARAMETER;
      }
 
    //
    // fall through
    //
    case EFI_FILE_MODE_READ:
    case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:
      break;
 
    default:
      return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  NewPrivateFile = AllocateCopyPool (sizeof (EMU_EFI_FILE_PRIVATE), PrivateFile);
  if (NewPrivateFile == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  Status = PrivateFile->Io->Open (PrivateFile->Io, &NewPrivateFile->Io, FileName, OpenMode, Attributes);
  if (!EFI_ERROR (Status)) {
    *NewHandle = &NewPrivateFile->EfiFile;
  } else {
    *NewHandle = NULL;
    FreePool (NewPrivateFile);
  }
 
Done:
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemClose (
  IN EFI_FILE_PROTOCOL  *This
  )
{
  EFI_STATUS            Status;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EFI_TPL               OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Status = PrivateFile->Io->Close (PrivateFile->Io);
  if (!EFI_ERROR (Status)) {
    gBS->FreePool (PrivateFile);
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemDelete (
  IN EFI_FILE_PROTOCOL  *This
  )
{
  EFI_STATUS            Status;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EFI_TPL               OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  Status = PrivateFile->Io->Delete (PrivateFile->Io);
  if (!EFI_ERROR (Status)) {
    gBS->FreePool (PrivateFile);
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemRead (
  IN     EFI_FILE_PROTOCOL  *This,
  IN OUT UINTN              *BufferSize,
  OUT    VOID               *Buffer
  )
{
  EFI_STATUS            Status;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EFI_TPL               OldTpl;
 
  if ((This == NULL) || (BufferSize == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((*BufferSize != 0) && (Buffer == NULL)) {
    // Buffer can be NULL  if *BufferSize is zero
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  Status = PrivateFile->Io->Read (PrivateFile->Io, BufferSize, Buffer);
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemWrite (
  IN     EFI_FILE_PROTOCOL  *This,
  IN OUT UINTN              *BufferSize,
  IN     VOID               *Buffer
  )
{
  EFI_STATUS            Status;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EFI_TPL               OldTpl;
 
  if ((This == NULL) || (BufferSize == NULL) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  Status = PrivateFile->Io->Write (PrivateFile->Io, BufferSize, Buffer);
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemGetPosition (
  IN  EFI_FILE_PROTOCOL  *This,
  OUT UINT64             *Position
  )
{
  EFI_STATUS            Status;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EFI_TPL               OldTpl;
 
  if ((This == NULL) || (Position == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  Status = PrivateFile->Io->GetPosition (PrivateFile->Io, Position);
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemSetPosition (
  IN EFI_FILE_PROTOCOL  *This,
  IN UINT64             Position
  )
{
  EFI_STATUS            Status;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EFI_TPL               OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  Status = PrivateFile->Io->SetPosition (PrivateFile->Io, Position);
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemGetInfo (
  IN     EFI_FILE_PROTOCOL  *This,
  IN     EFI_GUID           *InformationType,
  IN OUT UINTN              *BufferSize,
  OUT    VOID               *Buffer
  )
{
  EFI_STATUS            Status;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EFI_TPL               OldTpl;
 
  if ((This == NULL) || (InformationType == NULL) || (BufferSize == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  Status = PrivateFile->Io->GetInfo (PrivateFile->Io, InformationType, BufferSize, Buffer);
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemSetInfo (
  IN EFI_FILE_PROTOCOL  *This,
  IN EFI_GUID           *InformationType,
  IN UINTN              BufferSize,
  IN VOID               *Buffer
  )
{
  EFI_STATUS            Status;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EFI_TPL               OldTpl;
 
  //
  // Check for invalid parameters.
  //
  if ((This == NULL) || (InformationType == NULL) || (BufferSize == 0) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  Status = PrivateFile->Io->SetInfo (PrivateFile->Io, InformationType, BufferSize, Buffer);
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemFlush (
  IN EFI_FILE_PROTOCOL  *This
  )
{
  EFI_STATUS            Status;
  EMU_EFI_FILE_PRIVATE  *PrivateFile;
  EFI_TPL               OldTpl;
 
  if (This == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  PrivateFile = EMU_EFI_FILE_PRIVATE_DATA_FROM_THIS (This);
 
  Status = PrivateFile->Io->Flush (PrivateFile->Io);
 
  gBS->RestoreTPL (OldTpl);
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemOpenVolume (
  IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *This,
  OUT EFI_FILE_PROTOCOL               **Root
  )
{
  EFI_STATUS                      Status;
  EMU_SIMPLE_FILE_SYSTEM_PRIVATE  *Private;
  EMU_EFI_FILE_PRIVATE            *PrivateFile;
  EFI_TPL                         OldTpl;
 
  Status = EFI_UNSUPPORTED;
 
  if ((This == NULL) || (Root == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Private = EMU_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (This);
 
  PrivateFile = AllocatePool (sizeof (EMU_EFI_FILE_PRIVATE));
  if (PrivateFile == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  PrivateFile->Signature        = EMU_EFI_FILE_PRIVATE_SIGNATURE;
  PrivateFile->IoThunk          = Private->IoThunk;
  PrivateFile->SimpleFileSystem = This;
 
  ZeroMem (&PrivateFile->EfiFile, sizeof (PrivateFile->EfiFile));
  PrivateFile->EfiFile.Revision    = EFI_FILE_PROTOCOL_REVISION;
  PrivateFile->EfiFile.Open        = EmuSimpleFileSystemOpen;
  PrivateFile->EfiFile.Close       = EmuSimpleFileSystemClose;
  PrivateFile->EfiFile.Delete      = EmuSimpleFileSystemDelete;
  PrivateFile->EfiFile.Read        = EmuSimpleFileSystemRead;
  PrivateFile->EfiFile.Write       = EmuSimpleFileSystemWrite;
  PrivateFile->EfiFile.GetPosition = EmuSimpleFileSystemGetPosition;
  PrivateFile->EfiFile.SetPosition = EmuSimpleFileSystemSetPosition;
  PrivateFile->EfiFile.GetInfo     = EmuSimpleFileSystemGetInfo;
  PrivateFile->EfiFile.SetInfo     = EmuSimpleFileSystemSetInfo;
  PrivateFile->EfiFile.Flush       = EmuSimpleFileSystemFlush;
 
  *Root = &PrivateFile->EfiFile;
 
  Status = Private->Io->OpenVolume (Private->Io, &PrivateFile->Io);
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  AddUnicodeString2 (
    "eng",
    gEmuSimpleFileSystemComponentName.SupportedLanguages,
    &Private->ControllerNameTable,
    Private->IoThunk->ConfigString,
    TRUE
    );
 
  AddUnicodeString2 (
    "en",
    gEmuSimpleFileSystemComponentName.SupportedLanguages,
    &Private->ControllerNameTable,
    Private->IoThunk->ConfigString,
    FALSE
    );
 
Done:
  if (EFI_ERROR (Status)) {
    if (PrivateFile) {
      gBS->FreePool (PrivateFile);
    }
 
    *Root = NULL;
  }
 
  gBS->RestoreTPL (OldTpl);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemDriverBindingSupported (
  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN  EFI_HANDLE                   ControllerHandle,
  IN  EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  EFI_STATUS             Status;
  EMU_IO_THUNK_PROTOCOL  *EmuIoThunk;
 
  //
  // Open the IO Abstraction(s) needed to perform the supported test
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEmuIoThunkProtocolGuid,
                  (VOID **)&EmuIoThunk,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Make sure GUID is for a File System handle.
  //
  Status = EFI_UNSUPPORTED;
  if (CompareGuid (EmuIoThunk->Protocol, &gEfiSimpleFileSystemProtocolGuid)) {
    Status = EFI_SUCCESS;
  }
 
  //
  // Close the I/O Abstraction(s) used to perform the supported test
  //
  gBS->CloseProtocol (
         ControllerHandle,
         &gEmuIoThunkProtocolGuid,
         This->DriverBindingHandle,
         ControllerHandle
         );
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemDriverBindingStart (
  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN  EFI_HANDLE                   ControllerHandle,
  IN  EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  EFI_STATUS                      Status;
  EMU_IO_THUNK_PROTOCOL           *EmuIoThunk;
  EMU_SIMPLE_FILE_SYSTEM_PRIVATE  *Private;
 
  Private = NULL;
 
  //
  // Open the IO Abstraction(s) needed
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEmuIoThunkProtocolGuid,
                  (VOID **)&EmuIoThunk,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Validate GUID
  //
  if (!CompareGuid (EmuIoThunk->Protocol, &gEfiSimpleFileSystemProtocolGuid)) {
    Status = EFI_UNSUPPORTED;
    goto Done;
  }
 
  Private = AllocateZeroPool (sizeof (EMU_SIMPLE_FILE_SYSTEM_PRIVATE));
  if (Private == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto Done;
  }
 
  Status = EmuIoThunk->Open (EmuIoThunk);
  if (EFI_ERROR (Status)) {
    goto Done;
  }
 
  Private->Signature = EMU_SIMPLE_FILE_SYSTEM_PRIVATE_SIGNATURE;
  Private->IoThunk   = EmuIoThunk;
  Private->Io        = EmuIoThunk->Interface;
 
  Private->SimpleFileSystem.Revision   = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;
  Private->SimpleFileSystem.OpenVolume = EmuSimpleFileSystemOpenVolume;
 
  Private->ControllerNameTable = NULL;
 
  AddUnicodeString2 (
    "eng",
    gEmuSimpleFileSystemComponentName.SupportedLanguages,
    &Private->ControllerNameTable,
    EmuIoThunk->ConfigString,
    TRUE
    );
 
  AddUnicodeString2 (
    "en",
    gEmuSimpleFileSystemComponentName2.SupportedLanguages,
    &Private->ControllerNameTable,
    EmuIoThunk->ConfigString,
    FALSE
    );
 
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &ControllerHandle,
                  &gEfiSimpleFileSystemProtocolGuid,
                  &Private->SimpleFileSystem,
                  NULL
                  );
 
Done:
  if (EFI_ERROR (Status)) {
    if (Private != NULL) {
      if (Private->ControllerNameTable != NULL) {
        FreeUnicodeStringTable (Private->ControllerNameTable);
      }
 
      gBS->FreePool (Private);
    }
 
    gBS->CloseProtocol (
           ControllerHandle,
           &gEmuIoThunkProtocolGuid,
           This->DriverBindingHandle,
           ControllerHandle
           );
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EmuSimpleFileSystemDriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN  EFI_HANDLE                   ControllerHandle,
  IN  UINTN                        NumberOfChildren,
  IN  EFI_HANDLE                   *ChildHandleBuffer
  )
{
  EFI_STATUS                       Status;
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *SimpleFileSystem;
  EMU_SIMPLE_FILE_SYSTEM_PRIVATE   *Private;
 
  //
  // Get our context back
  //
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  &gEfiSimpleFileSystemProtocolGuid,
                  (VOID **)&SimpleFileSystem,
                  This->DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return EFI_UNSUPPORTED;
  }
 
  Private = EMU_SIMPLE_FILE_SYSTEM_PRIVATE_DATA_FROM_THIS (SimpleFileSystem);
 
  //
  // Uninstall the Simple File System Protocol from ControllerHandle
  //
  Status = gBS->UninstallMultipleProtocolInterfaces (
                  ControllerHandle,
                  &gEfiSimpleFileSystemProtocolGuid,
                  &Private->SimpleFileSystem,
                  NULL
                  );
  if (!EFI_ERROR (Status)) {
    Status = gBS->CloseProtocol (
                    ControllerHandle,
                    &gEmuIoThunkProtocolGuid,
                    This->DriverBindingHandle,
                    ControllerHandle
                    );
    ASSERT_EFI_ERROR (Status);
    //
    // Destroy the IO interface.
    //
    Status = Private->IoThunk->Close (Private->IoThunk);
    ASSERT_EFI_ERROR (Status);
    //
    // Free our instance data
    //
    FreeUnicodeStringTable (Private->ControllerNameTable);
    gBS->FreePool (Private);
  }
 
  return Status;
}
 
EFI_DRIVER_BINDING_PROTOCOL  gEmuSimpleFileSystemDriverBinding = {
  EmuSimpleFileSystemDriverBindingSupported,
  EmuSimpleFileSystemDriverBindingStart,
  EmuSimpleFileSystemDriverBindingStop,
  0xa,
  NULL,
  NULL
};
 
EFI_STATUS
EFIAPI
InitializeEmuSimpleFileSystem (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  Status = EfiLibInstallDriverBindingComponentName2 (
             ImageHandle,
             SystemTable,
             &gEmuSimpleFileSystemDriverBinding,
             ImageHandle,
             &gEmuSimpleFileSystemComponentName,
             &gEmuSimpleFileSystemComponentName2
             );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}