tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/Nt32Pkg/WinNtBlockIoDxe/WinNtBlockIo.c

1126 lines
31 KiB
C
Raw Blame History

/**@file
Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
Module Name:
WinNtBlockIo.c
Abstract:
Produce block IO abstractions for real devices on your PC using Win32 APIs.
The configuration of what devices to mount or emulate comes from NT
environment variables. The variables must be visible to the Microsoft*
Developer Studio for them to work.
<F>ixed - Fixed disk like a hard drive.
<R>emovable - Removable media like a floppy or CD-ROM.
Read <O>nly - Write protected device.
Read <W>rite - Read write device.
<block count> - Decimal number of blocks a device supports.
<block size> - Decimal number of bytes per block.
NT envirnonment variable contents. '<' and '>' are not part of the variable,
they are just used to make this help more readable. There should be no
spaces between the ';'. Extra spaces will break the variable. A '!' is
used to seperate multiple devices in a variable.
EFI_WIN_NT_VIRTUAL_DISKS =
<F | R><O | W>;<block count>;<block size>[!...]
EFI_WIN_NT_PHYSICAL_DISKS =
<drive letter>:<F | R><O | W>;<block count>;<block size>[!...]
Virtual Disks: These devices use a file to emulate a hard disk or removable
media device.
Thus a 20 MB emulated hard drive would look like:
EFI_WIN_NT_VIRTUAL_DISKS=FW;40960;512
A 1.44MB emulated floppy with a block size of 1024 would look like:
EFI_WIN_NT_VIRTUAL_DISKS=RW;1440;1024
Physical Disks: These devices use NT to open a real device in your system
Thus a 120 MB floppy would look like:
EFI_WIN_NT_PHYSICAL_DISKS=B:RW;245760;512
Thus a standard CD-ROM floppy would look like:
EFI_WIN_NT_PHYSICAL_DISKS=Z:RO;307200;2048
* Other names and brands may be claimed as the property of others.
**/
#include <Uefi.h>
#include <WinNtDxe.h>
#include <Protocol/WinNtThunk.h>
#include <Protocol/WinNtIo.h>
#include <Protocol/BlockIo.h>
#include <Protocol/ComponentName.h>
#include <Protocol/DriverBinding.h>
//
// The Library classes this module consumes
//
#include <Library/DebugLib.h>
#include <Library/BaseLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/MemoryAllocationLib.h>
#include "WinNtBlockIo.h"
EFI_DRIVER_BINDING_PROTOCOL gWinNtBlockIoDriverBinding = {
WinNtBlockIoDriverBindingSupported,
WinNtBlockIoDriverBindingStart,
WinNtBlockIoDriverBindingStop,
0xa,
NULL,
NULL
};
/**
The user Entry Point for module WinNtBlockIo. The user code starts with this function.
@param[in] ImageHandle The firmware allocated handle for the EFI image.
@param[in] SystemTable A pointer to the EFI System Table.
@retval EFI_SUCCESS The entry point is executed successfully.
@retval other Some error occurs when executing this entry point.
**/
EFI_STATUS
EFIAPI
InitializeWinNtBlockIo(
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
//
// Install driver model protocol(s).
//
Status = EfiLibInstallAllDriverProtocols2 (
ImageHandle,
SystemTable,
&gWinNtBlockIoDriverBinding,
ImageHandle,
&gWinNtBlockIoComponentName,
&gWinNtBlockIoComponentName2,
NULL,
NULL,
&gWinNtBlockIoDriverDiagnostics,
&gWinNtBlockIoDriverDiagnostics2
);
ASSERT_EFI_ERROR (Status);
return Status;
}
EFI_STATUS
EFIAPI
WinNtBlockIoDriverBindingSupported (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Handle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
/*++
Routine Description:
Arguments:
Returns:
None
--*/
// TODO: This - add argument and description to function comment
// TODO: Handle - add argument and description to function comment
// TODO: RemainingDevicePath - add argument and description to function comment
{
EFI_STATUS Status;
EFI_WIN_NT_IO_PROTOCOL *WinNtIo;
//
// Open the IO Abstraction(s) needed to perform the supported test
//
Status = gBS->OpenProtocol (
Handle,
&gEfiWinNtIoProtocolGuid,
(VOID **) &WinNtIo,
This->DriverBindingHandle,
Handle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Make sure the WinNtThunkProtocol is valid
//
Status = EFI_UNSUPPORTED;
if (WinNtIo->WinNtThunk->Signature == EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE) {
//
// Check the GUID to see if this is a handle type the driver supports
//
if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtVirtualDisksGuid) ||
CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtPhysicalDisksGuid) ) {
Status = EFI_SUCCESS;
}
}
//
// Close the I/O Abstraction(s) used to perform the supported test
//
gBS->CloseProtocol (
Handle,
&gEfiWinNtIoProtocolGuid,
This->DriverBindingHandle,
Handle
);
return Status;
}
EFI_STATUS
EFIAPI
WinNtBlockIoDriverBindingStart (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Handle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
)
/*++
Routine Description:
Arguments:
Returns:
None
--*/
// TODO: This - add argument and description to function comment
// TODO: Handle - add argument and description to function comment
// TODO: RemainingDevicePath - add argument and description to function comment
{
EFI_STATUS Status;
EFI_WIN_NT_IO_PROTOCOL *WinNtIo;
WIN_NT_RAW_DISK_DEVICE_TYPE DiskType;
UINT16 Buffer[FILENAME_BUFFER_SIZE];
CHAR16 *Str;
BOOLEAN RemovableMedia;
BOOLEAN WriteProtected;
UINTN NumberOfBlocks;
UINTN BlockSize;
//
// Grab the protocols we need
//
Status = gBS->OpenProtocol (
Handle,
&gEfiWinNtIoProtocolGuid,
(VOID **) &WinNtIo,
This->DriverBindingHandle,
Handle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Set DiskType
//
if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtVirtualDisksGuid)) {
DiskType = EfiWinNtVirtualDisks;
} else if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtPhysicalDisksGuid)) {
DiskType = EfiWinNtPhysicalDisks;
} else {
Status = EFI_UNSUPPORTED;
goto Done;
}
Status = EFI_NOT_FOUND;
Str = WinNtIo->EnvString;
if (DiskType == EfiWinNtVirtualDisks) {
WinNtIo->WinNtThunk->SPrintf (
Buffer,
sizeof (Buffer),
L"Diskfile%d",
WinNtIo->InstanceNumber
);
} else {
if (*Str >= 'A' && *Str <= 'Z' || *Str >= 'a' && *Str <= 'z') {
WinNtIo->WinNtThunk->SPrintf (Buffer, sizeof (Buffer), L"\\\\.\\%c:", *Str);
} else {
WinNtIo->WinNtThunk->SPrintf (Buffer, sizeof (Buffer), L"\\\\.\\PHYSICALDRIVE%c", *Str);
}
Str++;
if (*Str != ':') {
Status = EFI_NOT_FOUND;
goto Done;
}
Str++;
}
if (*Str == 'R' || *Str == 'F') {
RemovableMedia = (BOOLEAN) (*Str == 'R');
Str++;
if (*Str == 'O' || *Str == 'W') {
WriteProtected = (BOOLEAN) (*Str == 'O');
Str = GetNextElementPastTerminator (Str, ';');
NumberOfBlocks = StrDecimalToUintn (Str);
if (NumberOfBlocks != 0) {
Str = GetNextElementPastTerminator (Str, ';');
BlockSize = StrDecimalToUintn (Str);
if (BlockSize != 0) {
//
// If we get here the variable is valid so do the work.
//
Status = WinNtBlockIoCreateMapping (
WinNtIo,
Handle,
Buffer,
WriteProtected,
RemovableMedia,
NumberOfBlocks,
BlockSize,
DiskType
);
}
}
}
}
Done:
if (EFI_ERROR (Status)) {
gBS->CloseProtocol (
Handle,
&gEfiWinNtIoProtocolGuid,
This->DriverBindingHandle,
Handle
);
}
return Status;
}
EFI_STATUS
EFIAPI
WinNtBlockIoDriverBindingStop (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE Handle,
IN UINTN NumberOfChildren,
IN EFI_HANDLE *ChildHandleBuffer
)
/*++
Routine Description:
TODO: Add function description
Arguments:
This - TODO: add argument description
Handle - TODO: add argument description
NumberOfChildren - TODO: add argument description
ChildHandleBuffer - TODO: add argument description
Returns:
EFI_UNSUPPORTED - TODO: Add description for return value
--*/
{
EFI_BLOCK_IO_PROTOCOL *BlockIo;
EFI_STATUS Status;
WIN_NT_BLOCK_IO_PRIVATE *Private;
//
// Get our context back
//
Status = gBS->OpenProtocol (
Handle,
&gEfiBlockIoProtocolGuid,
(VOID **) &BlockIo,
This->DriverBindingHandle,
Handle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
return EFI_UNSUPPORTED;
}
Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (BlockIo);
//
// BugBug: If we need to kick people off, we need to make Uninstall Close the handles.
// We could pass in our image handle or FLAG our open to be closed via
// Unistall (== to saying any CloseProtocol will close our open)
//
Status = gBS->UninstallMultipleProtocolInterfaces (
Private->EfiHandle,
&gEfiBlockIoProtocolGuid,
&Private->BlockIo,
NULL
);
if (!EFI_ERROR (Status)) {
Status = gBS->CloseProtocol (
Handle,
&gEfiWinNtIoProtocolGuid,
This->DriverBindingHandle,
Handle
);
//
// Shut down our device
//
Private->WinNtThunk->CloseHandle (Private->NtHandle);
//
// Free our instance data
//
FreeUnicodeStringTable (Private->ControllerNameTable);
FreePool (Private);
}
return Status;
}
CHAR16 *
GetNextElementPastTerminator (
IN CHAR16 *EnvironmentVariable,
IN CHAR16 Terminator
)
/*++
Routine Description:
Worker function to parse environment variables.
Arguments:
EnvironmentVariable - Envirnment variable to parse.
Terminator - Terminator to parse for.
Returns:
Pointer to next eliment past the first occurence of Terminator or the '\0'
at the end of the string.
--*/
{
CHAR16 *Ptr;
for (Ptr = EnvironmentVariable; *Ptr != '\0'; Ptr++) {
if (*Ptr == Terminator) {
Ptr++;
break;
}
}
return Ptr;
}
EFI_STATUS
WinNtBlockIoCreateMapping (
IN EFI_WIN_NT_IO_PROTOCOL *WinNtIo,
IN EFI_HANDLE EfiDeviceHandle,
IN CHAR16 *Filename,
IN BOOLEAN ReadOnly,
IN BOOLEAN RemovableMedia,
IN UINTN NumberOfBlocks,
IN UINTN BlockSize,
IN WIN_NT_RAW_DISK_DEVICE_TYPE DeviceType
)
/*++
Routine Description:
TODO: Add function description
Arguments:
WinNtIo - TODO: add argument description
EfiDeviceHandle - TODO: add argument description
Filename - TODO: add argument description
ReadOnly - TODO: add argument description
RemovableMedia - TODO: add argument description
NumberOfBlocks - TODO: add argument description
BlockSize - TODO: add argument description
DeviceType - TODO: add argument description
Returns:
TODO: add return values
--*/
{
EFI_STATUS Status;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
WIN_NT_BLOCK_IO_PRIVATE *Private;
UINTN Index;
WinNtIo->WinNtThunk->SetErrorMode (SEM_FAILCRITICALERRORS);
Private = AllocatePool (sizeof (WIN_NT_BLOCK_IO_PRIVATE));
ASSERT (Private != NULL);
EfiInitializeLock (&Private->Lock, TPL_NOTIFY);
Private->WinNtThunk = WinNtIo->WinNtThunk;
Private->Signature = WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE;
Private->LastBlock = NumberOfBlocks - 1;
Private->BlockSize = BlockSize;
for (Index = 0; Filename[Index] != 0; Index++) {
Private->Filename[Index] = Filename[Index];
}
Private->Filename[Index] = 0;
Private->ReadMode = GENERIC_READ | (ReadOnly ? 0 : GENERIC_WRITE);
Private->ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
Private->NumberOfBlocks = NumberOfBlocks;
Private->DeviceType = DeviceType;
Private->NtHandle = INVALID_HANDLE_VALUE;
Private->ControllerNameTable = NULL;
AddUnicodeString2 (
"eng",
gWinNtBlockIoComponentName.SupportedLanguages,
&Private->ControllerNameTable,
Private->Filename,
TRUE
);
AddUnicodeString2 (
"en",
gWinNtBlockIoComponentName2.SupportedLanguages,
&Private->ControllerNameTable,
Private->Filename,
FALSE
);
BlockIo = &Private->BlockIo;
BlockIo->Revision = EFI_BLOCK_IO_PROTOCOL_REVISION;
BlockIo->Media = &Private->Media;
BlockIo->Media->BlockSize = (UINT32)Private->BlockSize;
BlockIo->Media->LastBlock = Private->NumberOfBlocks - 1;
BlockIo->Media->MediaId = 0;;
BlockIo->Reset = WinNtBlockIoResetBlock;
BlockIo->ReadBlocks = WinNtBlockIoReadBlocks;
BlockIo->WriteBlocks = WinNtBlockIoWriteBlocks;
BlockIo->FlushBlocks = WinNtBlockIoFlushBlocks;
BlockIo->Media->ReadOnly = ReadOnly;
BlockIo->Media->RemovableMedia = RemovableMedia;
BlockIo->Media->LogicalPartition = FALSE;
BlockIo->Media->MediaPresent = TRUE;
BlockIo->Media->WriteCaching = FALSE;
if (DeviceType == EfiWinNtVirtualDisks) {
BlockIo->Media->IoAlign = 1;
//
// Create a file to use for a virtual disk even if it does not exist.
//
Private->OpenMode = OPEN_ALWAYS;
} else if (DeviceType == EfiWinNtPhysicalDisks) {
//
// Physical disk and floppy devices require 4 byte alignment.
//
BlockIo->Media->IoAlign = 4;
//
// You can only open a physical device if it exists.
//
Private->OpenMode = OPEN_EXISTING;
} else {
ASSERT (FALSE);
}
Private->EfiHandle = EfiDeviceHandle;
Status = WinNtBlockIoOpenDevice (Private);
if (!EFI_ERROR (Status)) {
Status = gBS->InstallMultipleProtocolInterfaces (
&Private->EfiHandle,
&gEfiBlockIoProtocolGuid,
&Private->BlockIo,
NULL
);
if (EFI_ERROR (Status)) {
FreeUnicodeStringTable (Private->ControllerNameTable);
FreePool (Private);
}
DEBUG ((EFI_D_INIT, "BlockDevice added: %s\n", Filename));
}
return Status;
}
EFI_STATUS
WinNtBlockIoOpenDevice (
WIN_NT_BLOCK_IO_PRIVATE *Private
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Private - TODO: add argument description
Returns:
TODO: add return values
--*/
{
EFI_STATUS Status;
UINT64 FileSize;
UINT64 EndOfFile;
EFI_BLOCK_IO_PROTOCOL *BlockIo;
BlockIo = &Private->BlockIo;
EfiAcquireLock (&Private->Lock);
//
// If the device is already opened, close it
//
if (Private->NtHandle != INVALID_HANDLE_VALUE) {
BlockIo->Reset (BlockIo, FALSE);
}
//
// Open the device
//
Private->NtHandle = Private->WinNtThunk->CreateFile (
Private->Filename,
(DWORD)Private->ReadMode,
(DWORD)Private->ShareMode,
NULL,
(DWORD)Private->OpenMode,
0,
NULL
);
Status = Private->WinNtThunk->GetLastError ();
if (Private->NtHandle == INVALID_HANDLE_VALUE) {
DEBUG ((EFI_D_INFO, "PlOpenBlock: Could not open %s, %x\n", Private->Filename, Private->WinNtThunk->GetLastError ()));
BlockIo->Media->MediaPresent = FALSE;
Status = EFI_NO_MEDIA;
goto Done;
}
if (!BlockIo->Media->MediaPresent) {
//
// BugBug: try to emulate if a CD appears - notify drivers to check it out
//
BlockIo->Media->MediaPresent = TRUE;
EfiReleaseLock (&Private->Lock);
EfiAcquireLock (&Private->Lock);
}
//
// get the size of the file
//
Status = SetFilePointer64 (Private, 0, &FileSize, FILE_END);
if (EFI_ERROR (Status)) {
FileSize = MultU64x32 (Private->NumberOfBlocks, (UINT32)Private->BlockSize);
if (Private->DeviceType == EfiWinNtVirtualDisks) {
DEBUG ((EFI_D_ERROR, "PlOpenBlock: Could not get filesize of %s\n", Private->Filename));
Status = EFI_UNSUPPORTED;
goto Done;
}
}
if (Private->NumberOfBlocks == 0) {
Private->NumberOfBlocks = DivU64x32 (FileSize, (UINT32)Private->BlockSize);
}
EndOfFile = MultU64x32 (Private->NumberOfBlocks, (UINT32)Private->BlockSize);
if (FileSize != EndOfFile) {
//
// file is not the proper size, change it
//
DEBUG ((EFI_D_INIT, "PlOpenBlock: Initializing block device: %hs\n", Private->Filename));
//
// first set it to 0
//
SetFilePointer64 (Private, 0, NULL, FILE_BEGIN);
Private->WinNtThunk->SetEndOfFile (Private->NtHandle);
//
// then set it to the needed file size (OS will zero fill it)
//
SetFilePointer64 (Private, EndOfFile, NULL, FILE_BEGIN);
Private->WinNtThunk->SetEndOfFile (Private->NtHandle);
}
DEBUG ((EFI_D_INIT, "%HPlOpenBlock: opened %s%N\n", Private->Filename));
Status = EFI_SUCCESS;
Done:
if (EFI_ERROR (Status)) {
if (Private->NtHandle != INVALID_HANDLE_VALUE) {
BlockIo->Reset (BlockIo, FALSE);
}
}
EfiReleaseLock (&Private->Lock);
return Status;
}
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_PROTOCOL *BlockIo;
EFI_STATUS Status;
BOOLEAN ReinstallBlockIoFlag;
BlockIo = &Private->BlockIo;
switch (Private->WinNtThunk->GetLastError ()) {
case ERROR_NOT_READY:
Status = EFI_NO_MEDIA;
BlockIo->Media->ReadOnly = FALSE;
BlockIo->Media->MediaPresent = FALSE;
ReinstallBlockIoFlag = FALSE;
break;
case ERROR_WRONG_DISK:
BlockIo->Media->ReadOnly = FALSE;
BlockIo->Media->MediaPresent = TRUE;
BlockIo->Media->MediaId += 1;
ReinstallBlockIoFlag = TRUE;
Status = EFI_MEDIA_CHANGED;
break;
case ERROR_WRITE_PROTECT:
BlockIo->Media->ReadOnly = TRUE;
ReinstallBlockIoFlag = FALSE;
Status = EFI_WRITE_PROTECTED;
break;
default:
ReinstallBlockIoFlag = FALSE;
Status = EFI_DEVICE_ERROR;
break;
}
if (ReinstallBlockIoFlag) {
BlockIo->Reset (BlockIo, FALSE);
gBS->ReinstallProtocolInterface (
Private->EfiHandle,
&gEfiBlockIoProtocolGuid,
BlockIo,
BlockIo
);
}
return Status;
}
EFI_STATUS
WinNtBlockIoReadWriteCommon (
IN WIN_NT_BLOCK_IO_PRIVATE *Private,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
IN VOID *Buffer,
IN CHAR8 *CallerName
)
/*++
Routine Description:
TODO: Add function description
Arguments:
Private - TODO: add argument description
MediaId - TODO: add argument description
Lba - TODO: add argument description
BufferSize - TODO: add argument description
Buffer - TODO: add argument description
CallerName - TODO: add argument description
Returns:
EFI_NO_MEDIA - TODO: Add description for return value
EFI_MEDIA_CHANGED - TODO: Add description for return value
EFI_INVALID_PARAMETER - TODO: Add description for return value
EFI_SUCCESS - TODO: Add description for return value
EFI_BAD_BUFFER_SIZE - TODO: Add description for return value
EFI_INVALID_PARAMETER - TODO: Add description for return value
EFI_SUCCESS - TODO: Add description for return value
--*/
{
EFI_STATUS Status;
UINTN BlockSize;
UINT64 LastBlock;
INT64 DistanceToMove;
UINT64 DistanceMoved;
if (Private->NtHandle == INVALID_HANDLE_VALUE) {
Status = WinNtBlockIoOpenDevice (Private);
if (EFI_ERROR (Status)) {
return Status;
}
}
if (!Private->Media.MediaPresent) {
DEBUG ((EFI_D_INIT, "%s: No Media\n", CallerName));
return EFI_NO_MEDIA;
}
if (Private->Media.MediaId != MediaId) {
return EFI_MEDIA_CHANGED;
}
if ((UINTN) Buffer % Private->Media.IoAlign != 0) {
return EFI_INVALID_PARAMETER;
}
//
// Verify buffer size
//
BlockSize = Private->BlockSize;
if (BufferSize == 0) {
DEBUG ((EFI_D_INIT, "%s: Zero length read\n", CallerName));
return EFI_SUCCESS;
}
if ((BufferSize % BlockSize) != 0) {
DEBUG ((EFI_D_INIT, "%s: Invalid read size\n", CallerName));
return EFI_BAD_BUFFER_SIZE;
}
LastBlock = Lba + (BufferSize / BlockSize) - 1;
if (LastBlock > Private->LastBlock) {
DEBUG ((EFI_D_INIT, "ReadBlocks: Attempted to read off end of device\n"));
return EFI_INVALID_PARAMETER;
}
//
// Seek to End of File
//
DistanceToMove = MultU64x32 (Lba, (UINT32)BlockSize);
Status = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, FILE_BEGIN);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_INIT, "WriteBlocks: SetFilePointer failed\n"));
return WinNtBlockIoError (Private);
}
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
WinNtBlockIoReadBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
OUT VOID *Buffer
)
/*++
Routine Description:
Read BufferSize bytes from Lba into Buffer.
Arguments:
This - Protocol instance pointer.
MediaId - Id of the media, changes every time the media is replaced.
Lba - The starting Logical Block Address to read from
BufferSize - Size of Buffer, must be a multiple of device block size.
Buffer - Buffer containing read data
Returns:
EFI_SUCCESS - The data was read correctly from the device.
EFI_DEVICE_ERROR - The device reported an error while performing the read.
EFI_NO_MEDIA - There is no media in the device.
EFI_MEDIA_CHANGED - The MediaId does not matched the current device.
EFI_BAD_BUFFER_SIZE - The Buffer was not a multiple of the block size of the
device.
EFI_INVALID_PARAMETER - The read request contains device addresses that are not
valid for the device.
--*/
{
WIN_NT_BLOCK_IO_PRIVATE *Private;
BOOL Flag;
EFI_STATUS Status;
DWORD BytesRead;
EFI_TPL OldTpl;
OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
Status = WinNtBlockIoReadWriteCommon (Private, MediaId, Lba, BufferSize, Buffer, "WinNtReadBlocks");
if (EFI_ERROR (Status)) {
goto Done;
}
Flag = Private->WinNtThunk->ReadFile (Private->NtHandle, Buffer, (DWORD) BufferSize, (LPDWORD) &BytesRead, NULL);
if (!Flag || (BytesRead != BufferSize)) {
DEBUG ((EFI_D_INIT, "ReadBlocks: ReadFile failed. (%d)\n", Private->WinNtThunk->GetLastError ()));
Status = WinNtBlockIoError (Private);
goto Done;
}
//
// If we wrote then media is present.
//
This->Media->MediaPresent = TRUE;
Status = EFI_SUCCESS;
Done:
gBS->RestoreTPL (OldTpl);
return Status;
}
EFI_STATUS
EFIAPI
WinNtBlockIoWriteBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
IN VOID *Buffer
)
/*++
Routine Description:
Write BufferSize bytes from Lba into Buffer.
Arguments:
This - Protocol instance pointer.
MediaId - Id of the media, changes every time the media is replaced.
Lba - The starting Logical Block Address to read from
BufferSize - Size of Buffer, must be a multiple of device block size.
Buffer - Buffer containing read data
Returns:
EFI_SUCCESS - The data was written correctly to the device.
EFI_WRITE_PROTECTED - The device can not be written to.
EFI_DEVICE_ERROR - The device reported an error while performing the write.
EFI_NO_MEDIA - There is no media in the device.
EFI_MEDIA_CHNAGED - The MediaId does not matched the current device.
EFI_BAD_BUFFER_SIZE - The Buffer was not a multiple of the block size of the
device.
EFI_INVALID_PARAMETER - The write request contains a LBA that is not
valid for the device.
--*/
{
WIN_NT_BLOCK_IO_PRIVATE *Private;
UINTN BytesWritten;
BOOL Flag;
BOOL Locked;
EFI_STATUS Status;
EFI_TPL OldTpl;
UINTN BytesReturned;
OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
Status = WinNtBlockIoReadWriteCommon (Private, MediaId, Lba, BufferSize, Buffer, "WinNtWriteBlocks");
if (EFI_ERROR (Status)) {
goto Done;
}
//
// According the Windows requirement, first need to lock the volume before
// write to it.
//
if (Private->DeviceType == EfiWinNtPhysicalDisks) {
Locked = Private->WinNtThunk->DeviceIoControl (Private->NtHandle, FSCTL_LOCK_VOLUME, NULL, 0, NULL, 0, &BytesReturned, NULL);
if (Locked == 0) {
DEBUG ((EFI_D_INIT, "ReadBlocks: Lock volume failed. (%d)\n", Private->WinNtThunk->GetLastError ()));
Status = WinNtBlockIoError (Private);
goto Done;
}
} else {
Locked = 0;
}
Flag = Private->WinNtThunk->WriteFile (Private->NtHandle, Buffer, (DWORD) BufferSize, (LPDWORD) &BytesWritten, NULL);
if (Locked != 0) {
Private->WinNtThunk->DeviceIoControl (Private->NtHandle, FSCTL_UNLOCK_VOLUME, NULL, 0, NULL, 0, &BytesReturned, NULL);
}
if (!Flag || (BytesWritten != BufferSize)) {
DEBUG ((EFI_D_INIT, "ReadBlocks: WriteFile failed. (%d)\n", Private->WinNtThunk->GetLastError ()));
Status = WinNtBlockIoError (Private);
goto Done;
}
//
// If the write succeeded, we are not write protected and media is present.
//
This->Media->MediaPresent = TRUE;
This->Media->ReadOnly = FALSE;
Status = EFI_SUCCESS;
Done:
gBS->RestoreTPL (OldTpl);
return Status;
}
EFI_STATUS
EFIAPI
WinNtBlockIoFlushBlocks (
IN EFI_BLOCK_IO_PROTOCOL *This
)
/*++
Routine Description:
Flush the Block Device.
Arguments:
This - Protocol instance pointer.
Returns:
EFI_SUCCESS - All outstanding data was written to the device
EFI_DEVICE_ERROR - The device reported an error while writting back the data
EFI_NO_MEDIA - There is no media in the device.
--*/
{
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
WinNtBlockIoResetBlock (
IN EFI_BLOCK_IO_PROTOCOL *This,
IN BOOLEAN ExtendedVerification
)
/*++
Routine Description:
Reset the Block Device.
Arguments:
This - Protocol instance pointer.
ExtendedVerification - Driver may perform diagnostics on reset.
Returns:
EFI_SUCCESS - The device was reset.
EFI_DEVICE_ERROR - The device is not functioning properly and could
not be reset.
--*/
{
WIN_NT_BLOCK_IO_PRIVATE *Private;
EFI_TPL OldTpl;
OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
if (Private->NtHandle != INVALID_HANDLE_VALUE) {
Private->WinNtThunk->CloseHandle (Private->NtHandle);
Private->NtHandle = INVALID_HANDLE_VALUE;
}
gBS->RestoreTPL (OldTpl);
return EFI_SUCCESS;
}
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
--*/
// TODO: function comment is missing 'Routine Description:'
// TODO: function comment is missing 'Arguments:'
// TODO: function comment is missing 'Returns:'
// TODO: Private - add argument and description to function comment
// TODO: DistanceToMove - add argument and description to function comment
// TODO: NewFilePointer - add argument and description to function comment
// TODO: MoveMethod - add argument and description to function comment
{
EFI_STATUS Status;
LARGE_INTEGER LargeInt;
LargeInt.QuadPart = DistanceToMove;
Status = EFI_SUCCESS;
LargeInt.LowPart = Private->WinNtThunk->SetFilePointer (
Private->NtHandle,
LargeInt.LowPart,
&LargeInt.HighPart,
MoveMethod
);
if (LargeInt.LowPart == -1 && Private->WinNtThunk->GetLastError () != NO_ERROR) {
Status = EFI_INVALID_PARAMETER;
}
if (NewFilePointer != NULL) {
*NewFilePointer = LargeInt.QuadPart;
}
return Status;
}
Reference in New Issue View Git Blame Copy Permalink