git clone --recurse-submodules -j8 https://github.com/ionescu007/VisualUefi.git

Shell> fs1:
FS1:\> load UefiDriver.efi

FS1:\> unload BA

FS1:\> UefiApplication.efi

EFI_STATUS
EFIAPI
UefiUnload (
    IN EFI_HANDLE ImageHandle
    )
{
    //
    // Do not allow unload
    //
    return EFI_ACCESS_DENIED;
}
EFI_STATUS
EFIAPI
UefiMain (
    IN EFI_HANDLE ImageHandle,
    IN EFI_SYSTEM_TABLE *SystemTable
    )
{
    EFI_STATUS efiStatus;
    //
    // Install required driver binding components
    //
    efiStatus = EfiLibInstallDriverBindingComponentName2(ImageHandle,
                                                         SystemTable,
                                                         &gDriverBindingProtocol,
                                                         ImageHandle,
                                                         &gComponentNameProtocol,
                                                         &gComponentName2Protocol);
    return efiStatus;
}

// _DriverUnloadHandler manages to call UefiUnload
Status = gBS->HandleProtocol (
                    ImageHandle,
                    &gEfiLoadedImageProtocolGuid,
                    (VOID **)&LoadedImage
              );
ASSERT_EFI_ERROR (Status);
LoadedImage->Unload = _DriverUnloadHandler;

//
// EFI Driver Binding Protocol
//
EFI_DRIVER_BINDING_PROTOCOL gDriverBindingProtocol =
{
    SampleDriverSupported,
    SampleDriverStart,
    SampleDriverStop,
    10,
    NULL,
    NULL
};
…
//
// Install our custom protocol on top of a new device handle
//
efiStatus = gBS->InstallMultipleProtocolInterfaces(&deviceExtension->DeviceHandle,
                                                       &gEfiSampleDriverProtocolGuid,
                                                       &deviceExtension->DeviceProtocol,
                                                       NULL);
//
// Bind the PCI I/O protocol between our new device handle and the controller
//
efiStatus = gBS->OpenProtocol(Controller,
                                  &gEfiPciIoProtocolGuid,
                                  (VOID**)&childPciIo,
                                  This->DriverBindingHandle,
                                  deviceExtension->DeviceHandle,
                                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER);

// install component name and binding
Status = gBS->InstallMultipleProtocolInterfaces (
                       &DriverBinding->DriverBindingHandle,
                       &gEfiDriverBindingProtocolGuid, DriverBinding,
                       &gEfiComponentNameProtocolGuid, ComponentName,
                       &gEfiComponentName2ProtocolGuid, ComponentName2,
                       NULL
                       );

EFI_STATUS
EFIAPI
UefiUnload (
    IN EFI_HANDLE ImageHandle
    )
{
  gBS->UninstallMultipleProtocolInterfaces(
    ImageHandle,
    &gEfiDriverBindingProtocolGuid, &gDriverBindingProtocol,
    &gEfiComponentNameProtocolGuid, &gComponentNameProtocol,
    &gEfiComponentName2ProtocolGuid, &gComponentName2Protocol,
    NULL
  );
    //
    // Changed from access denied in order to unload in boot
    //
    return EFI_SUCCESS;
}

gST = *SystemTable;
gBS = gST->BootServices;
gRT = gST->RuntimeServices;

EFI_STATUS
OpenVolume(
  OUT EFI_FILE_PROTOCOL** Volume
)
{
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL* fsProto = NULL;
  EFI_STATUS status;
  *Volume = NULL;
  // get file system protocol
  status = gBS->LocateProtocol(
    &gEfiSimpleFileSystemProtocolGuid,
    NULL,
    (VOID**)&fsProto
  );
  if (EFI_ERROR(status))
  {
    return status;
  }
  status = fsProto->OpenVolume(
    fsProto,
    Volume
  );
  return status;
}

EFI_STATUS
OpenFile(
  IN  EFI_FILE_PROTOCOL* Volume,
  OUT EFI_FILE_PROTOCOL** File,
  IN  CHAR16* Path
)
{
  EFI_STATUS status;
  *File = NULL;
  //  from root file we open file specified by path
  status = Volume->Open(
    Volume,
    File,
    Path,
    EFI_FILE_MODE_CREATE |
    EFI_FILE_MODE_WRITE |
    EFI_FILE_MODE_READ,
    0
  );
  return status;
}
EFI_STATUS
CloseFile(
  IN EFI_FILE_PROTOCOL* File
)
{
  //  flush unwritten data
  File->Flush(File);
  //  close file
  File->Close(File);
  return EFI_SUCCESS;
}

EFI_STATUS
WriteDataToFile(
  IN VOID* Buffer,
  IN UINTN BufferSize,
  IN EFI_FILE_PROTOCOL* File
)
{
  UINTN infoBufferSize = 0;
  EFI_FILE_INFO* fileInfo = NULL;
  //  retrieve file info to know it size
  EFI_STATUS status = File->GetInfo(
    File,
    &gEfiFileInfoGuid,
    &infoBufferSize,
    (VOID*)fileInfo
  );
  if (EFI_BUFFER_TOO_SMALL != status)
  {
    return status;
  }
  fileInfo = AllocatePool(infoBufferSize);
  if (NULL == fileInfo)
  {
    status = EFI_OUT_OF_RESOURCES;
    return status;
  }
  //    we need to know file size
  status = File->GetInfo(
    File,
    &gEfiFileInfoGuid,
    &infoBufferSize,
    (VOID*)fileInfo
  );
  if (EFI_ERROR(status))
  {
    goto FINALLY;
  }
  //    we move carriage to the end of the file
  status = File->SetPosition(
    File,
    fileInfo->FileSize
  );
  if (EFI_ERROR(status))
  {
    goto FINALLY;
  }
  //    write buffer
  status = File->Write(
    File,
    &BufferSize,
    Buffer
  );
  if (EFI_ERROR(status))
  {
    goto FINALLY;
  }
  //    flush data
  status = File->Flush(File);
FINALLY:
  if (NULL != fileInfo)
  {
    FreePool(fileInfo);
  }
  return status;
}

EFI_STATUS
WriteToFile(
  VOID
)
{
  CHAR16 path[] = L"\\example.txt";
  EFI_FILE_PROTOCOL* file = NULL;
  EFI_FILE_PROTOCOL* volume = NULL;
  CHAR16 something[] = L"Hello from UEFI driver";
  //
  //  Open file
  //
  EFI_STATUS status = OpenVolume(&volume);
  if (EFI_ERROR(status))
  {
    return status;
  }
  status = OpenFile(volume, &file, path);
  if (EFI_ERROR(status))
  {
    CloseFile(volume);
    return status;
  }
  status = WriteDataToFile(something, sizeof(something), file);
  CloseFile(file);
  CloseFile(volume);
  return status;
}

#include <Library/ShellLib.h>
EFI_STATUS
WriteToFile2(
  VOID
)
{
  SHELL_FILE_HANDLE fileHandle = NULL;
  CHAR16 path[] = L"fs1:\\example2.txt";
  CHAR16 something[] = L"Hello from UEFI driver";
  UINTN writeSize = sizeof(something);
  EFI_STATUS status = ShellInitialize();
  if (EFI_ERROR(status))
  {
    return status;
  }
  status = ShellOpenFileByName(path,
    &fileHandle,
    EFI_FILE_MODE_CREATE |
    EFI_FILE_MODE_WRITE |
    EFI_FILE_MODE_READ,
    0);
  if (EFI_ERROR(status))
  {
    return status;
  }
  status = ShellWriteFile(fileHandle, &writeSize, something);
  ShellCloseFile(&fileHandle);
  return status;
}

// just pseudo code
...
// open protocol to replace callbacks
gBS->OpenProtocol(
      Controller,
      Guid,
      (VOID**)&protocol,
      DriverBindingHandle,
      Controller,
      EFI_OPEN_PROTOCOL_GET_PROTOCOL
    );
// raise Task Priority Level to max avaliable
gBS->RaiseTPL(TPL_NOTIFY);
VOID** protocolBase = EFI_FIELD_BY_OFFSET(VOID**, FilterContainer, 0);
VOID** oldCallback = EFI_FIELD_BY_OFFSET(VOID**, *protocolBase, oldCallbackOffset);
VOID** originalCallback = EFI_FIELD_BY_OFFSET(VOID**, FilterContainer, originalCallbackOffset);
//  yes, I know that it is not super obvious
//  but if first and third is equal (placeholder and function)
//  then the first one is not the function it is offset!
//  and function itself is by offset of third one
if ((UINTN) newCallback == originalCallbackOffset)
{
  newCallback = *originalCallback;
}
PRINT_DEBUG(DEBUG_INFO, L"[UefiMonitor] 0x%x -> 0x%x\n", *oldCallback, newCallback);
//saving original functions
*originalCallback = *oldCallback;
//replacing them by filter function
*oldCallback = newCallback;
// restore TPL
gBS->RestoreTPL(oldTpl);

// event on exit
gBS->CreateEvent(
      EVT_SIGNAL_EXIT_BOOT_SERVICES,
      TPL_NOTIFY,
      ExitBootServicesNotifyCallback,
      NULL,
      &mExitBootServicesEvent
    );