WinBlockIo.c

Go to the documentation of this file.

 
#include "WinHost.h"
 
#define WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE  SIGNATURE_32 ('N', 'T', 'b', 'k')
typedef struct {
  UINTN                    Signature;
 
  EMU_IO_THUNK_PROTOCOL    *Thunk;
 
  CHAR16                   *FileName;
  BOOLEAN                  Removable;
  BOOLEAN                  Readonly;
 
  HANDLE                   NtHandle;
  UINT32                   BlockSize;
 
  EFI_BLOCK_IO_MEDIA       *Media;
  EMU_BLOCK_IO_PROTOCOL    EmuBlockIo;
} WIN_NT_BLOCK_IO_PRIVATE;
 
#define WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS(a) \
         CR(a, WIN_NT_BLOCK_IO_PRIVATE, EmuBlockIo, WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE)
 
EFI_STATUS
WinNtBlockIoReset (
  IN EMU_BLOCK_IO_PROTOCOL  *This,
  IN BOOLEAN                ExtendedVerification
  );
 
EFI_STATUS
SetFilePointer64 (
  IN  WIN_NT_BLOCK_IO_PRIVATE  *Private,
  IN  INT64                    DistanceToMove,
  OUT UINT64                   *NewFilePointer,
  IN  DWORD                    MoveMethod
  )
 
/*++
 
This function extends the capability of SetFilePointer to accept 64 bit parameters
 
--*/
{
  EFI_STATUS     Status;
  LARGE_INTEGER  LargeInt;
 
  LargeInt.QuadPart = DistanceToMove;
  Status            = EFI_SUCCESS;
 
  LargeInt.LowPart = SetFilePointer (
                       Private->NtHandle,
                       LargeInt.LowPart,
                       &LargeInt.HighPart,
                       MoveMethod
                       );
 
  if ((LargeInt.LowPart == -1) && (GetLastError () != NO_ERROR)) {
    Status = EFI_INVALID_PARAMETER;
  }
 
  if (NewFilePointer != NULL) {
    *NewFilePointer = LargeInt.QuadPart;
  }
 
  return Status;
}
 
EFI_STATUS
WinNtBlockIoOpenDevice (
  IN WIN_NT_BLOCK_IO_PRIVATE  *Private,
  IN EFI_BLOCK_IO_MEDIA       *Media
  )
{
  EFI_STATUS  Status;
  UINT64      FileSize;
 
  //
  // If the device is already opened, close it
  //
  if (Private->NtHandle != INVALID_HANDLE_VALUE) {
    WinNtBlockIoReset (&Private->EmuBlockIo, FALSE);
  }
 
  //
  // Open the device
  //
  Private->NtHandle = CreateFile (
                        Private->FileName,
                        GENERIC_READ | (Private->Readonly ? 0 : GENERIC_WRITE),
                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                        NULL,
                        OPEN_ALWAYS, // Create if it doesn't exist
                        0,
                        NULL
                        );
 
  if (Private->NtHandle == INVALID_HANDLE_VALUE) {
    DEBUG ((DEBUG_INFO, "OpenBlock: Could not open %S, %x\n", Private->FileName, GetLastError ()));
    Media->MediaPresent = FALSE;
    Status              = EFI_NO_MEDIA;
    goto Done;
  }
 
  //
  // get the size of the file
  //
  Status = SetFilePointer64 (Private, 0, &FileSize, FILE_END);
 
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "OpenBlock: Could not get filesize of %s\n", Private->FileName));
    Status = EFI_UNSUPPORTED;
    goto Done;
  }
 
  Media->LastBlock = DivU64x32 (FileSize, (UINT32)Private->BlockSize) - 1;
 
  DEBUG ((DEBUG_INIT, "OpenBlock: opened %S\n", Private->FileName));
  Status = EFI_SUCCESS;
 
Done:
  if (EFI_ERROR (Status)) {
    if (Private->NtHandle != INVALID_HANDLE_VALUE) {
      WinNtBlockIoReset (&Private->EmuBlockIo, FALSE);
    }
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
WinNtBlockIoCreateMapping (
  IN     EMU_BLOCK_IO_PROTOCOL  *This,
  IN     EFI_BLOCK_IO_MEDIA     *Media
  )
{
  WIN_NT_BLOCK_IO_PRIVATE  *Private;
 
  Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
 
  Media->MediaId          = 0;
  Media->RemovableMedia   = Private->Removable;
  Media->MediaPresent     = TRUE;
  Media->LogicalPartition = FALSE;
  Media->ReadOnly         = Private->Readonly;
  Media->WriteCaching     = FALSE;
  Media->IoAlign          = 1;
  Media->LastBlock        = 0; // Filled in by OpenDevice
  Media->BlockSize        = Private->BlockSize;
 
  // EFI_BLOCK_IO_PROTOCOL_REVISION2
  Media->LowestAlignedLba              = 0;
  Media->LogicalBlocksPerPhysicalBlock = 0;
 
  // EFI_BLOCK_IO_PROTOCOL_REVISION3
  Media->OptimalTransferLengthGranularity = 0;
 
  //
  // Remember the Media pointer.
  //
  Private->Media = Media;
  return WinNtBlockIoOpenDevice (Private, Media);
}
 
EFI_STATUS
WinNtBlockIoError (
  IN WIN_NT_BLOCK_IO_PRIVATE  *Private
  )
 
/*++
 
Routine Description:
 
  TODO: Add function description
 
Arguments:
 
  Private - TODO: add argument description
 
Returns:
 
  TODO: add return values
 
--*/
{
  EFI_BLOCK_IO_MEDIA  *Media;
  EFI_STATUS          Status;
 
  Media = Private->Media;
 
  switch (GetLastError ()) {
    case ERROR_NOT_READY:
      Media->ReadOnly     = FALSE;
      Media->MediaPresent = FALSE;
      Status              = EFI_NO_MEDIA;
      break;
 
    case ERROR_WRONG_DISK:
      Media->ReadOnly     = FALSE;
      Media->MediaPresent = TRUE;
      Media->MediaId++;
      Status = EFI_MEDIA_CHANGED;
      break;
 
    case ERROR_WRITE_PROTECT:
      Media->ReadOnly = TRUE;
      Status          = EFI_WRITE_PROTECTED;
      break;
 
    default:
      Status = EFI_DEVICE_ERROR;
      break;
  }
 
  if ((Status == EFI_NO_MEDIA) || (Status == EFI_MEDIA_CHANGED)) {
    WinNtBlockIoReset (&Private->EmuBlockIo, FALSE);
  }
 
  return Status;
}
 
EFI_STATUS
WinNtSignalToken (
  IN OUT EFI_BLOCK_IO2_TOKEN  *Token,
  IN     EFI_STATUS           Status
  )
{
  if (Token != NULL) {
    if (Token->Event != NULL) {
      // Caller is responcible for signaling EFI Event
      Token->TransactionStatus = Status;
      return EFI_SUCCESS;
    }
  }
 
  return Status;
}
 
EFI_STATUS
WinNtBlockIoReadBlocks (
  IN     EMU_BLOCK_IO_PROTOCOL  *This,
  IN     UINT32                 MediaId,
  IN     EFI_LBA                Lba,
  IN OUT EFI_BLOCK_IO2_TOKEN    *Token,
  IN     UINTN                  BufferSize,
  OUT VOID                      *Buffer
  )
{
  WIN_NT_BLOCK_IO_PRIVATE  *Private;
  BOOL                     Flag;
  EFI_STATUS               Status;
  DWORD                    BytesRead;
  UINT64                   DistanceToMove;
  UINT64                   DistanceMoved;
 
  Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
 
  //
  // Seek to proper position
  //
  DistanceToMove = MultU64x32 (Lba, (UINT32)Private->BlockSize);
  Status         = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, FILE_BEGIN);
 
  if (EFI_ERROR (Status) || (DistanceToMove != DistanceMoved)) {
    DEBUG ((DEBUG_INIT, "ReadBlocks: SetFilePointer failed\n"));
    return WinNtBlockIoError (Private->Media);
  }
 
  Flag = ReadFile (Private->NtHandle, Buffer, (DWORD)BufferSize, (LPDWORD)&BytesRead, NULL);
  if (!Flag || (BytesRead != BufferSize)) {
    return WinNtBlockIoError (Private->Media);
  }
 
  Private->Media->MediaPresent = TRUE;
  return WinNtSignalToken (Token, EFI_SUCCESS);
}
 
EFI_STATUS
WinNtBlockIoWriteBlocks (
  IN     EMU_BLOCK_IO_PROTOCOL  *This,
  IN     UINT32                 MediaId,
  IN     EFI_LBA                Lba,
  IN OUT EFI_BLOCK_IO2_TOKEN    *Token,
  IN     UINTN                  BufferSize,
  IN     VOID                   *Buffer
  )
{
  WIN_NT_BLOCK_IO_PRIVATE  *Private;
  UINTN                    BytesWritten;
  BOOL                     Success;
  EFI_STATUS               Status;
  UINT64                   DistanceToMove;
  UINT64                   DistanceMoved;
 
  Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
 
  //
  // Seek to proper position
  //
  DistanceToMove = MultU64x32 (Lba, (UINT32)Private->BlockSize);
  Status         = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, FILE_BEGIN);
 
  if (EFI_ERROR (Status) || (DistanceToMove != DistanceMoved)) {
    DEBUG ((DEBUG_INIT, "WriteBlocks: SetFilePointer failed\n"));
    return WinNtBlockIoError (Private->Media);
  }
 
  Success = WriteFile (Private->NtHandle, Buffer, (DWORD)BufferSize, (LPDWORD)&BytesWritten, NULL);
  if (!Success || (BytesWritten != BufferSize)) {
    return WinNtBlockIoError (Private->Media);
  }
 
  //
  // If the write succeeded, we are not write protected and media is present.
  //
  Private->Media->MediaPresent = TRUE;
  Private->Media->ReadOnly     = FALSE;
  return WinNtSignalToken (Token, EFI_SUCCESS);
}
 
EFI_STATUS
WinNtBlockIoFlushBlocks (
  IN     EMU_BLOCK_IO_PROTOCOL  *This,
  IN OUT EFI_BLOCK_IO2_TOKEN    *Token
  )
{
  return WinNtSignalToken (Token, EFI_SUCCESS);
}
 
EFI_STATUS
WinNtBlockIoReset (
  IN EMU_BLOCK_IO_PROTOCOL  *This,
  IN BOOLEAN                ExtendedVerification
  )
{
  WIN_NT_BLOCK_IO_PRIVATE  *Private;
 
  Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
 
  if (Private->NtHandle != INVALID_HANDLE_VALUE) {
    CloseHandle (Private->NtHandle);
    Private->NtHandle = INVALID_HANDLE_VALUE;
  }
 
  return EFI_SUCCESS;
}
 
EMU_BLOCK_IO_PROTOCOL  gEmuBlockIoProtocol = {
  WinNtBlockIoReset,
  WinNtBlockIoReadBlocks,
  WinNtBlockIoWriteBlocks,
  WinNtBlockIoFlushBlocks,
  WinNtBlockIoCreateMapping
};
 
EFI_STATUS
EFIAPI
WinNtBlockIoThunkOpen (
  IN  EMU_IO_THUNK_PROTOCOL  *This
  )
{
  WIN_NT_BLOCK_IO_PRIVATE  *Private;
  CHAR16                   *Str;
 
  Private = AllocatePool (sizeof (*Private));
  if (Private == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Private->Signature = WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE;
  Private->Thunk     = This;
  CopyMem (&Private->EmuBlockIo, &gEmuBlockIoProtocol, sizeof (gEmuBlockIoProtocol));
  Private->BlockSize = 512;
  Private->NtHandle  = INVALID_HANDLE_VALUE;
 
  Private->FileName = AllocateCopyPool (StrSize (This->ConfigString), This->ConfigString);
  if (Private->FileName == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Parse ConfigString
  // <ConfigString> := <FileName> ':' [RF][OW] ':' <BlockSize>
  //
  Str = StrStr (Private->FileName, L":");
  if (Str == NULL) {
    Private->Removable = FALSE;
    Private->Readonly  = FALSE;
  } else {
    for (*Str++ = L'\0'; *Str != L'\0'; Str++) {
      if ((*Str == 'R') || (*Str == 'F')) {
        Private->Removable = (BOOLEAN)(*Str == L'R');
      }
 
      if ((*Str == 'O') || (*Str == 'W')) {
        Private->Readonly = (BOOLEAN)(*Str == L'O');
      }
 
      if (*Str == ':') {
        Private->BlockSize = wcstol (++Str, NULL, 0);
        break;
      }
    }
  }
 
  This->Interface = &Private->EmuBlockIo;
  This->Private   = Private;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
WinNtBlockIoThunkClose (
  IN  EMU_IO_THUNK_PROTOCOL  *This
  )
{
  WIN_NT_BLOCK_IO_PRIVATE  *Private;
 
  Private = This->Private;
 
  if (Private != NULL) {
    if (Private->FileName != NULL) {
      FreePool (Private->FileName);
    }
 
    FreePool (Private);
  }
 
  return EFI_SUCCESS;
}
 
EMU_IO_THUNK_PROTOCOL  mWinNtBlockIoThunkIo = {
  &gEmuBlockIoProtocolGuid,
  NULL,
  NULL,
  0,
  WinNtBlockIoThunkOpen,
  WinNtBlockIoThunkClose,
  NULL
};