sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

OvmfPkg: Apply uncrustify changes

Browse Source 
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3737

Apply uncrustify changes to .c/.h files in the OvmfPkg package

Cc: Andrew Fish <afish@apple.com>
Cc: Leif Lindholm <leif@nuviainc.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Signed-off-by: Michael Kubacki <michael.kubacki@microsoft.com>
Reviewed-by: Andrew Fish <afish@apple.com>
This commit is contained in:
Michael Kubacki
2021-12-05 14:54:09 -08:00
committed by mergify[bot]
parent d1050b9dff
commit ac0a286f4d
445 changed files with 30894 additions and 26369 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
OvmfPkg/VirtioFsDxe/DriverBinding.c
View File

@@ -17,8 +17,8 @@
//
// UEFI Driver Model protocol instances.
//
STATIC EFI_DRIVER_BINDING_PROTOCOL mDriverBinding;
STATIC EFI_COMPONENT_NAME2_PROTOCOL mComponentName2;
STATIC EFI_DRIVER_BINDING_PROTOCOL mDriverBinding;
STATIC EFI_COMPONENT_NAME2_PROTOCOL mComponentName2;
//
// UEFI Driver Model protocol member functions.
@@ -26,18 +26,23 @@ STATIC EFI_COMPONENT_NAME2_PROTOCOL mComponentName2;
EFI_STATUS
EFIAPI
VirtioFsBindingSupported (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
)
{
EFI_STATUS Status;
VIRTIO_DEVICE_PROTOCOL *Virtio;
EFI_STATUS CloseStatus;
EFI_STATUS Status;
VIRTIO_DEVICE_PROTOCOL *Virtio;
EFI_STATUS CloseStatus;
Status = gBS->OpenProtocol (ControllerHandle, &gVirtioDeviceProtocolGuid,
(VOID **)&Virtio, This->DriverBindingHandle,
ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
Status = gBS->OpenProtocol (
ControllerHandle,
&gVirtioDeviceProtocolGuid,
(VOID **)&Virtio,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -46,9 +51,12 @@ VirtioFsBindingSupported (
Status = EFI_UNSUPPORTED;
}
CloseStatus = gBS->CloseProtocol (ControllerHandle,
&gVirtioDeviceProtocolGuid, This->DriverBindingHandle,
ControllerHandle);
CloseStatus = gBS->CloseProtocol (
ControllerHandle,
&gVirtioDeviceProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
ASSERT_EFI_ERROR (CloseStatus);
return Status;
@@ -57,24 +65,30 @@ VirtioFsBindingSupported (
EFI_STATUS
EFIAPI
VirtioFsBindingStart (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
)
{
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
EFI_STATUS CloseStatus;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
EFI_STATUS CloseStatus;
VirtioFs = AllocatePool (sizeof *VirtioFs);
if (VirtioFs == NULL) {
return EFI_OUT_OF_RESOURCES;
}
VirtioFs->Signature = VIRTIO_FS_SIG;
Status = gBS->OpenProtocol (ControllerHandle, &gVirtioDeviceProtocolGuid,
(VOID **)&VirtioFs->Virtio, This->DriverBindingHandle,
ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
Status = gBS->OpenProtocol (
ControllerHandle,
&gVirtioDeviceProtocolGuid,
(VOID **)&VirtioFs->Virtio,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER
);
if (EFI_ERROR (Status)) {
goto FreeVirtioFs;
}
@@ -89,8 +103,13 @@ VirtioFsBindingStart (
goto UninitVirtioFs;
}
Status = gBS->CreateEvent (EVT_SIGNAL_EXIT_BOOT_SERVICES, TPL_CALLBACK,
VirtioFsExitBoot, VirtioFs, &VirtioFs->ExitBoot);
Status = gBS->CreateEvent (
EVT_SIGNAL_EXIT_BOOT_SERVICES,
TPL_CALLBACK,
VirtioFsExitBoot,
VirtioFs,
&VirtioFs->ExitBoot
);
if (EFI_ERROR (Status)) {
goto UninitVirtioFs;
}
@@ -99,9 +118,12 @@ VirtioFsBindingStart (
VirtioFs->SimpleFs.Revision = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;
VirtioFs->SimpleFs.OpenVolume = VirtioFsOpenVolume;
Status = gBS->InstallProtocolInterface (&ControllerHandle,
&gEfiSimpleFileSystemProtocolGuid, EFI_NATIVE_INTERFACE,
&VirtioFs->SimpleFs);
Status = gBS->InstallProtocolInterface (
&ControllerHandle,
&gEfiSimpleFileSystemProtocolGuid,
EFI_NATIVE_INTERFACE,
&VirtioFs->SimpleFs
);
if (EFI_ERROR (Status)) {
goto CloseExitBoot;
}
@@ -116,9 +138,12 @@ UninitVirtioFs:
VirtioFsUninit (VirtioFs);
CloseVirtio:
CloseStatus = gBS->CloseProtocol (ControllerHandle,
&gVirtioDeviceProtocolGuid, This->DriverBindingHandle,
ControllerHandle);
CloseStatus = gBS->CloseProtocol (
ControllerHandle,
&gVirtioDeviceProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
ASSERT_EFI_ERROR (CloseStatus);
FreeVirtioFs:
@@ -130,20 +155,24 @@ FreeVirtioFs:
EFI_STATUS
EFIAPI
VirtioFsBindingStop (
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN UINTN NumberOfChildren,
IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN UINTN NumberOfChildren,
IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
)
{
EFI_STATUS Status;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFs;
VIRTIO_FS *VirtioFs;
Status = gBS->OpenProtocol (ControllerHandle,
&gEfiSimpleFileSystemProtocolGuid, (VOID **)&SimpleFs,
This->DriverBindingHandle, ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL);
Status = gBS->OpenProtocol (
ControllerHandle,
&gEfiSimpleFileSystemProtocolGuid,
(VOID **)&SimpleFs,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -154,8 +183,11 @@ VirtioFsBindingStop (
return EFI_ACCESS_DENIED;
}
Status = gBS->UninstallProtocolInterface (ControllerHandle,
&gEfiSimpleFileSystemProtocolGuid, SimpleFs);
Status = gBS->UninstallProtocolInterface (
ControllerHandle,
&gEfiSimpleFileSystemProtocolGuid,
SimpleFs
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -165,8 +197,12 @@ VirtioFsBindingStop (
VirtioFsUninit (VirtioFs);
Status = gBS->CloseProtocol (ControllerHandle, &gVirtioDeviceProtocolGuid,
This->DriverBindingHandle, ControllerHandle);
Status = gBS->CloseProtocol (
ControllerHandle,
&gVirtioDeviceProtocolGuid,
This->DriverBindingHandle,
ControllerHandle
);
ASSERT_EFI_ERROR (Status);
FreePool (VirtioFs);
@@ -177,14 +213,15 @@ VirtioFsBindingStop (
EFI_STATUS
EFIAPI
VirtioFsGetDriverName (
IN EFI_COMPONENT_NAME2_PROTOCOL *This,
IN CHAR8 *Language,
OUT CHAR16 **DriverName
IN EFI_COMPONENT_NAME2_PROTOCOL *This,
IN CHAR8 *Language,
OUT CHAR16 **DriverName
)
{
if (AsciiStrCmp (Language, "en") != 0) {
return EFI_UNSUPPORTED;
}
*DriverName = L"Virtio Filesystem Driver";
return EFI_SUCCESS;
}
@@ -192,11 +229,11 @@ VirtioFsGetDriverName (
EFI_STATUS
EFIAPI
VirtioFsGetControllerName (
IN EFI_COMPONENT_NAME2_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_HANDLE ChildHandle OPTIONAL,
IN CHAR8 *Language,
OUT CHAR16 **ControllerName
IN EFI_COMPONENT_NAME2_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_HANDLE ChildHandle OPTIONAL,
IN CHAR8 *Language,
OUT CHAR16 **ControllerName
)
{
return EFI_UNSUPPORTED;
@@ -208,11 +245,11 @@ VirtioFsGetControllerName (
EFI_STATUS
EFIAPI
VirtioFsEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_STATUS Status;
mDriverBinding.Supported = VirtioFsBindingSupported;
mDriverBinding.Start = VirtioFsBindingStart;
@@ -225,8 +262,13 @@ VirtioFsEntryPoint (
mComponentName2.GetControllerName = VirtioFsGetControllerName;
mComponentName2.SupportedLanguages = "en";
Status = gBS->InstallMultipleProtocolInterfaces (&ImageHandle,
&gEfiDriverBindingProtocolGuid, &mDriverBinding,
&gEfiComponentName2ProtocolGuid, &mComponentName2, NULL);
Status = gBS->InstallMultipleProtocolInterfaces (
&ImageHandle,
&gEfiDriverBindingProtocolGuid,
&mDriverBinding,
&gEfiComponentName2ProtocolGuid,
&mComponentName2,
NULL
);
return Status;
}

45
OvmfPkg/VirtioFsDxe/FuseFlush.c
View File

@@ -35,19 +35,19 @@
**/
EFI_STATUS
VirtioFsFuseFlush (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_FLUSH_REQUEST FlushReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_FLUSH_REQUEST FlushReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -75,8 +75,13 @@ VirtioFsFuseFlush (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpFlush, NodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpFlush,
NodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -102,10 +107,18 @@ VirtioFsFuseFlush (
//
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"Errno=%d\n", __FUNCTION__, VirtioFs->Label, NodeId, FuseHandle,
CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
NodeId,
FuseHandle,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

23
OvmfPkg/VirtioFsDxe/FuseForget.c
View File

@@ -34,15 +34,15 @@
**/
EFI_STATUS
VirtioFsFuseForget (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_FORGET_REQUEST ForgetReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_FORGET_REQUEST ForgetReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather list (note: only request).
@@ -66,8 +66,13 @@ VirtioFsFuseForget (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpForget, NodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpForget,
NodeId
);
if (EFI_ERROR (Status)) {
return Status;
}

39
OvmfPkg/VirtioFsDxe/FuseFsync.c
View File

@@ -40,20 +40,20 @@
**/
EFI_STATUS
VirtioFsFuseFsyncFileOrDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_FSYNC_REQUEST FsyncReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_FSYNC_REQUEST FsyncReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -112,10 +112,19 @@ VirtioFsFuseFsyncFileOrDir (
//
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"IsDir=%d Errno=%d\n", __FUNCTION__, VirtioFs->Label, NodeId, FuseHandle,
IsDir, CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"IsDir=%d Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
NodeId,
FuseHandle,
IsDir,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

44
OvmfPkg/VirtioFsDxe/FuseGetAttr.c
View File

@@ -37,20 +37,20 @@
**/
EFI_STATUS
VirtioFsFuseGetAttr (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_GETATTR_REQUEST GetAttrReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_GETATTR_RESPONSE GetAttrResp;
VIRTIO_FS_IO_VECTOR RespIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_GETATTR_REQUEST GetAttrReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_GETATTR_RESPONSE GetAttrResp;
VIRTIO_FS_IO_VECTOR RespIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -82,8 +82,13 @@ VirtioFsFuseGetAttr (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpGetAttr, NodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpGetAttr,
NodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -108,9 +113,16 @@ VirtioFsFuseGetAttr (
//
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu Errno=%d\n",
__FUNCTION__, VirtioFs->Label, NodeId, CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
NodeId,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

48
OvmfPkg/VirtioFsDxe/FuseInit.c
View File

@@ -43,18 +43,18 @@
**/
EFI_STATUS
VirtioFsFuseInitSession (
IN OUT VIRTIO_FS *VirtioFs
IN OUT VIRTIO_FS *VirtioFs
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_INIT_REQUEST InitReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_INIT_RESPONSE InitResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_INIT_REQUEST InitReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_INIT_RESPONSE InitResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Initialize the FUSE request counter.
@@ -89,8 +89,13 @@ VirtioFsFuseInitSession (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpInit, 0);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpInit,
0
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -117,20 +122,27 @@ VirtioFsFuseInitSession (
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (EFI_ERROR (Status)) {
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" Errno=%d\n", __FUNCTION__,
VirtioFs->Label, CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}
//
// Check FUSE interface version / feature compatibility.
//
if (InitResp.Major < InitReq.Major ||
(InitResp.Major == InitReq.Major && InitResp.Minor < InitReq.Minor) ||
(InitResp.Flags & VIRTIO_FS_FUSE_INIT_REQ_F_DO_READDIRPLUS) == 0 ||
InitResp.MaxWrite < SIZE_4KB) {
if ((InitResp.Major < InitReq.Major) ||
((InitResp.Major == InitReq.Major) && (InitResp.Minor < InitReq.Minor)) ||
((InitResp.Flags & VIRTIO_FS_FUSE_INIT_REQ_F_DO_READDIRPLUS) == 0) ||
(InitResp.MaxWrite < SIZE_4KB))
{
return EFI_UNSUPPORTED;
}

37
OvmfPkg/VirtioFsDxe/FuseLookup.c
View File

@@ -52,21 +52,21 @@
**/
EFI_STATUS
VirtioFsFuseLookup (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_NODE_RESPONSE NodeResp;
VIRTIO_FS_IO_VECTOR RespIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_NODE_RESPONSE NodeResp;
VIRTIO_FS_IO_VECTOR RespIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -98,8 +98,13 @@ VirtioFsFuseLookup (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpLookup, DirNodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpLookup,
DirNodeId
);
if (EFI_ERROR (Status)) {
goto Fail;
}
@@ -132,8 +137,10 @@ VirtioFsFuseLookup (
if (CommonResp.Error == VIRTIO_FS_FUSE_ERRNO_ENOENT) {
return EFI_NOT_FOUND;
}
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
goto Fail;
}

57
OvmfPkg/VirtioFsDxe/FuseMkDir.c
View File

@@ -41,22 +41,22 @@
**/
EFI_STATUS
VirtioFsFuseMkDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_MKDIR_REQUEST MkDirReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_NODE_RESPONSE NodeResp;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE AttrResp;
VIRTIO_FS_IO_VECTOR RespIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_MKDIR_REQUEST MkDirReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_NODE_RESPONSE NodeResp;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE AttrResp;
VIRTIO_FS_IO_VECTOR RespIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -90,8 +90,13 @@ VirtioFsFuseMkDir (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpMkDir, ParentNodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpMkDir,
ParentNodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -99,9 +104,9 @@ VirtioFsFuseMkDir (
//
// Populate the FUSE_MKDIR-specific fields.
//
MkDirReq.Mode = (VIRTIO_FS_FUSE_MODE_PERM_RWXU |
VIRTIO_FS_FUSE_MODE_PERM_RWXG |
VIRTIO_FS_FUSE_MODE_PERM_RWXO);
MkDirReq.Mode = (VIRTIO_FS_FUSE_MODE_PERM_RWXU |
VIRTIO_FS_FUSE_MODE_PERM_RWXG |
VIRTIO_FS_FUSE_MODE_PERM_RWXO);
MkDirReq.Umask = 0;
//
@@ -118,11 +123,19 @@ VirtioFsFuseMkDir (
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (EFI_ERROR (Status)) {
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" ParentNodeId=%Lu Name=\"%a\" "
"Errno=%d\n", __FUNCTION__, VirtioFs->Label, ParentNodeId, Name,
CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" ParentNodeId=%Lu Name=\"%a\" "
"Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
ParentNodeId,
Name,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

55
OvmfPkg/VirtioFsDxe/FuseOpen.c
View File

@@ -38,21 +38,21 @@
**/
EFI_STATUS
VirtioFsFuseOpen (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN BOOLEAN ReadWrite,
OUT UINT64 *FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN BOOLEAN ReadWrite,
OUT UINT64 *FuseHandle
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_OPEN_REQUEST OpenReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_OPEN_RESPONSE OpenResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_OPEN_REQUEST OpenReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_OPEN_RESPONSE OpenResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -82,8 +82,13 @@ VirtioFsFuseOpen (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpOpen, NodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpOpen,
NodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -91,9 +96,9 @@ VirtioFsFuseOpen (
//
// Populate the FUSE_OPEN-specific fields.
//
OpenReq.Flags = (ReadWrite ?
VIRTIO_FS_FUSE_OPEN_REQ_F_RDWR :
VIRTIO_FS_FUSE_OPEN_REQ_F_RDONLY);
OpenReq.Flags = (ReadWrite ?
VIRTIO_FS_FUSE_OPEN_REQ_F_RDWR :
VIRTIO_FS_FUSE_OPEN_REQ_F_RDONLY);
OpenReq.Unused = 0;
//
@@ -110,11 +115,19 @@ VirtioFsFuseOpen (
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (EFI_ERROR (Status)) {
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu ReadWrite=%d "
"Errno=%d\n", __FUNCTION__, VirtioFs->Label, NodeId, ReadWrite,
CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu ReadWrite=%d "
"Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
NodeId,
ReadWrite,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

44
OvmfPkg/VirtioFsDxe/FuseOpenDir.c
View File

@@ -36,20 +36,20 @@
**/
EFI_STATUS
VirtioFsFuseOpenDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT UINT64 *FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT UINT64 *FuseHandle
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_OPEN_REQUEST OpenReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_OPEN_RESPONSE OpenResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_OPEN_REQUEST OpenReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_OPEN_RESPONSE OpenResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -79,8 +79,13 @@ VirtioFsFuseOpenDir (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpOpenDir, NodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpOpenDir,
NodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -105,10 +110,17 @@ VirtioFsFuseOpenDir (
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (EFI_ERROR (Status)) {
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu Errno=%d\n",
__FUNCTION__, VirtioFs->Label, NodeId, CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
NodeId,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

69
OvmfPkg/VirtioFsDxe/FuseOpenOrCreate.c
View File

@@ -46,24 +46,24 @@
**/
EFI_STATUS
VirtioFsFuseOpenOrCreate (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_CREATE_REQUEST CreateReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_NODE_RESPONSE NodeResp;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE AttrResp;
VIRTIO_FS_FUSE_OPEN_RESPONSE OpenResp;
VIRTIO_FS_IO_VECTOR RespIoVec[4];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_CREATE_REQUEST CreateReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_NODE_RESPONSE NodeResp;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE AttrResp;
VIRTIO_FS_FUSE_OPEN_RESPONSE OpenResp;
VIRTIO_FS_IO_VECTOR RespIoVec[4];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -99,8 +99,13 @@ VirtioFsFuseOpenOrCreate (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpCreate, ParentNodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpCreate,
ParentNodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -113,13 +118,13 @@ VirtioFsFuseOpenOrCreate (
// the only OpenMode of EFI_FILE_PROTOCOL.Open() that enables filesystem
// object creation -- that is, Create/Read/Write.
//
CreateReq.Flags = VIRTIO_FS_FUSE_OPEN_REQ_F_RDWR;
CreateReq.Mode = (VIRTIO_FS_FUSE_MODE_PERM_RUSR |
VIRTIO_FS_FUSE_MODE_PERM_WUSR |
VIRTIO_FS_FUSE_MODE_PERM_RGRP |
VIRTIO_FS_FUSE_MODE_PERM_WGRP |
VIRTIO_FS_FUSE_MODE_PERM_ROTH |
VIRTIO_FS_FUSE_MODE_PERM_WOTH);
CreateReq.Flags = VIRTIO_FS_FUSE_OPEN_REQ_F_RDWR;
CreateReq.Mode = (VIRTIO_FS_FUSE_MODE_PERM_RUSR |
VIRTIO_FS_FUSE_MODE_PERM_WUSR |
VIRTIO_FS_FUSE_MODE_PERM_RGRP |
VIRTIO_FS_FUSE_MODE_PERM_WGRP |
VIRTIO_FS_FUSE_MODE_PERM_ROTH |
VIRTIO_FS_FUSE_MODE_PERM_WOTH);
CreateReq.Umask = 0;
CreateReq.Padding = 0;
@@ -137,11 +142,19 @@ VirtioFsFuseOpenOrCreate (
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (EFI_ERROR (Status)) {
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" ParentNodeId=%Lu Name=\"%a\" "
"Errno=%d\n", __FUNCTION__, VirtioFs->Label, ParentNodeId, Name,
CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" ParentNodeId=%Lu Name=\"%a\" "
"Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
ParentNodeId,
Name,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

58
OvmfPkg/VirtioFsDxe/FuseRead.c
View File

@@ -87,24 +87,24 @@
**/
EFI_STATUS
VirtioFsFuseReadFileOrDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir,
IN UINT64 Offset,
IN OUT UINT32 *Size,
OUT VOID *Data
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir,
IN UINT64 Offset,
IN OUT UINT32 *Size,
OUT VOID *Data
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_READ_REQUEST ReadReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
UINTN TailBufferFill;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_READ_REQUEST ReadReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
UINTN TailBufferFill;
//
// Set up the scatter-gather lists.
@@ -167,16 +167,30 @@ VirtioFsFuseReadFileOrDir (
//
// Verify the response. Note that TailBufferFill is variable.
//
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique,
&TailBufferFill);
Status = VirtioFsFuseCheckResponse (
&RespSgList,
CommonReq.Unique,
&TailBufferFill
);
if (EFI_ERROR (Status)) {
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"IsDir=%d Offset=0x%Lx Size=0x%x Data@%p Errno=%d\n", __FUNCTION__,
VirtioFs->Label, NodeId, FuseHandle, IsDir, Offset, *Size, Data,
CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"IsDir=%d Offset=0x%Lx Size=0x%x Data@%p Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
NodeId,
FuseHandle,
IsDir,
Offset,
*Size,
Data,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

39
OvmfPkg/VirtioFsDxe/FuseRelease.c
View File

@@ -39,20 +39,20 @@
**/
EFI_STATUS
VirtioFsFuseReleaseFileOrDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_RELEASE_REQUEST ReleaseReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_RELEASE_REQUEST ReleaseReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -112,10 +112,19 @@ VirtioFsFuseReleaseFileOrDir (
//
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"IsDir=%d Errno=%d\n", __FUNCTION__, VirtioFs->Label, NodeId, FuseHandle,
IsDir, CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"IsDir=%d Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
NodeId,
FuseHandle,
IsDir,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

52
OvmfPkg/VirtioFsDxe/FuseRename.c
View File

@@ -49,21 +49,21 @@
**/
EFI_STATUS
VirtioFsFuseRename (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 OldParentNodeId,
IN CHAR8 *OldName,
IN UINT64 NewParentNodeId,
IN CHAR8 *NewName
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 OldParentNodeId,
IN CHAR8 *OldName,
IN UINT64 NewParentNodeId,
IN CHAR8 *NewName
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_RENAME2_REQUEST Rename2Req;
VIRTIO_FS_IO_VECTOR ReqIoVec[4];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_RENAME2_REQUEST Rename2Req;
VIRTIO_FS_IO_VECTOR ReqIoVec[4];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -95,8 +95,13 @@ VirtioFsFuseRename (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpRename2, OldParentNodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpRename2,
OldParentNodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -121,11 +126,20 @@ VirtioFsFuseRename (
//
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" OldParentNodeId=%Lu OldName=\"%a\" "
"NewParentNodeId=%Lu NewName=\"%a\" Errno=%d\n", __FUNCTION__,
VirtioFs->Label, OldParentNodeId, OldName, NewParentNodeId, NewName,
CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" OldParentNodeId=%Lu OldName=\"%a\" "
"NewParentNodeId=%Lu NewName=\"%a\" Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
OldParentNodeId,
OldName,
NewParentNodeId,
NewName,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

60
OvmfPkg/VirtioFsDxe/FuseSetAttr.c
View File

@@ -52,24 +52,24 @@
**/
EFI_STATUS
VirtioFsFuseSetAttr (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 *Size OPTIONAL,
IN UINT64 *Atime OPTIONAL,
IN UINT64 *Mtime OPTIONAL,
IN UINT32 *Mode OPTIONAL
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 *Size OPTIONAL,
IN UINT64 *Atime OPTIONAL,
IN UINT64 *Mtime OPTIONAL,
IN UINT32 *Mode OPTIONAL
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_SETATTR_REQUEST AttrReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_GETATTR_RESPONSE GetAttrResp;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE AttrResp;
VIRTIO_FS_IO_VECTOR RespIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_SETATTR_REQUEST AttrReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_GETATTR_RESPONSE GetAttrResp;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE AttrResp;
VIRTIO_FS_IO_VECTOR RespIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -101,8 +101,13 @@ VirtioFsFuseSetAttr (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpSetAttr, NodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpSetAttr,
NodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -130,12 +135,15 @@ VirtioFsFuseSetAttr (
if (Size != NULL) {
AttrReq.Valid |= VIRTIO_FS_FUSE_SETATTR_REQ_F_SIZE;
}
if (Atime != NULL) {
AttrReq.Valid |= VIRTIO_FS_FUSE_SETATTR_REQ_F_ATIME;
}
if (Mtime != NULL) {
AttrReq.Valid |= VIRTIO_FS_FUSE_SETATTR_REQ_F_MTIME;
}
if (Mode != NULL) {
AttrReq.Valid |= VIRTIO_FS_FUSE_SETATTR_REQ_F_MODE;
}
@@ -153,22 +161,32 @@ VirtioFsFuseSetAttr (
//
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu", __FUNCTION__,
VirtioFs->Label, NodeId));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu",
__FUNCTION__,
VirtioFs->Label,
NodeId
));
if (Size != NULL) {
DEBUG ((DEBUG_ERROR, " Size=0x%Lx", *Size));
}
if (Atime != NULL) {
DEBUG ((DEBUG_ERROR, " Atime=%Lu", *Atime));
}
if (Mtime != NULL) {
DEBUG ((DEBUG_ERROR, " Mtime=%Lu", *Mtime));
}
if (Mode != NULL) {
DEBUG ((DEBUG_ERROR, " Mode=0x%x", *Mode)); // no support for octal :/
}
DEBUG ((DEBUG_ERROR, " Errno=%d\n", CommonResp.Error));
DEBUG ((DEBUG_ERROR, " Errno=%d\n", CommonResp.Error));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

42
OvmfPkg/VirtioFsDxe/FuseStatFs.c
View File

@@ -36,18 +36,18 @@
**/
EFI_STATUS
VirtioFsFuseStatFs (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT VIRTIO_FS_FUSE_STATFS_RESPONSE *FilesysAttr
)
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT VIRTIO_FS_FUSE_STATFS_RESPONSE *FilesysAttr
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -75,8 +75,13 @@ VirtioFsFuseStatFs (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpStatFs, NodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpStatFs,
NodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -94,9 +99,16 @@ VirtioFsFuseStatFs (
//
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu Errno=%d\n",
__FUNCTION__, VirtioFs->Label, NodeId, CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
NodeId,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

37
OvmfPkg/VirtioFsDxe/FuseUnlink.c
View File

@@ -41,19 +41,19 @@
**/
EFI_STATUS
VirtioFsFuseRemoveFileOrDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
IN BOOLEAN IsDir
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
IN BOOLEAN IsDir
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_IO_VECTOR RespIoVec[1];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Set up the scatter-gather lists.
@@ -105,10 +105,19 @@ VirtioFsFuseRemoveFileOrDir (
//
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" ParentNodeId=%Lu Name=\"%a\" "
"IsDir=%d Errno=%d\n", __FUNCTION__, VirtioFs->Label, ParentNodeId, Name,
IsDir, CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" ParentNodeId=%Lu Name=\"%a\" "
"IsDir=%d Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
ParentNodeId,
Name,
IsDir,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

57
OvmfPkg/VirtioFsDxe/FuseWrite.c
View File

@@ -52,23 +52,23 @@
**/
EFI_STATUS
VirtioFsFuseWrite (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN UINT64 Offset,
IN OUT UINT32 *Size,
IN VOID *Data
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN UINT64 Offset,
IN OUT UINT32 *Size,
IN VOID *Data
)
{
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_WRITE_REQUEST WriteReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_WRITE_RESPONSE WriteResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
VIRTIO_FS_FUSE_REQUEST CommonReq;
VIRTIO_FS_FUSE_WRITE_REQUEST WriteReq;
VIRTIO_FS_IO_VECTOR ReqIoVec[3];
VIRTIO_FS_SCATTER_GATHER_LIST ReqSgList;
VIRTIO_FS_FUSE_RESPONSE CommonResp;
VIRTIO_FS_FUSE_WRITE_RESPONSE WriteResp;
VIRTIO_FS_IO_VECTOR RespIoVec[2];
VIRTIO_FS_SCATTER_GATHER_LIST RespSgList;
EFI_STATUS Status;
//
// Honor the write buffer size limit of the Virtio Filesystem device.
@@ -107,8 +107,13 @@ VirtioFsFuseWrite (
//
// Populate the common request header.
//
Status = VirtioFsFuseNewRequest (VirtioFs, &CommonReq, ReqSgList.TotalSize,
VirtioFsFuseOpWrite, NodeId);
Status = VirtioFsFuseNewRequest (
VirtioFs,
&CommonReq,
ReqSgList.TotalSize,
VirtioFsFuseOpWrite,
NodeId
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -138,12 +143,22 @@ VirtioFsFuseWrite (
Status = VirtioFsFuseCheckResponse (&RespSgList, CommonReq.Unique, NULL);
if (EFI_ERROR (Status)) {
if (Status == EFI_DEVICE_ERROR) {
DEBUG ((DEBUG_ERROR, "%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"Offset=0x%Lx Size=0x%x Data@%p Errno=%d\n", __FUNCTION__,
VirtioFs->Label, NodeId, FuseHandle, Offset, *Size, Data,
CommonResp.Error));
DEBUG ((
DEBUG_ERROR,
"%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "
"Offset=0x%Lx Size=0x%x Data@%p Errno=%d\n",
__FUNCTION__,
VirtioFs->Label,
NodeId,
FuseHandle,
Offset,
*Size,
Data,
CommonResp.Error
));
Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);
}
return Status;
}

1019
OvmfPkg/VirtioFsDxe/Helpers.c
View File

File diff suppressed because it is too large Load Diff

30
OvmfPkg/VirtioFsDxe/SimpleFsClose.c
View File

@@ -14,11 +14,11 @@
EFI_STATUS
EFIAPI
VirtioFsSimpleFileClose (
IN EFI_FILE_PROTOCOL *This
IN EFI_FILE_PROTOCOL *This
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -34,16 +34,27 @@ VirtioFsSimpleFileClose (
//
if (VirtioFsFile->IsOpenForWriting) {
if (!VirtioFsFile->IsDirectory) {
VirtioFsFuseFlush (VirtioFs, VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle);
VirtioFsFuseFlush (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle
);
}
VirtioFsFuseFsyncFileOrDir (VirtioFs, VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle, VirtioFsFile->IsDirectory);
VirtioFsFuseFsyncFileOrDir (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
VirtioFsFile->IsDirectory
);
}
VirtioFsFuseReleaseFileOrDir (VirtioFs, VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle, VirtioFsFile->IsDirectory);
VirtioFsFuseReleaseFileOrDir (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
VirtioFsFile->IsDirectory
);
//
// VirtioFsFile->FuseHandle is gone at this point, but VirtioFsFile->NodeId
@@ -63,6 +74,7 @@ VirtioFsSimpleFileClose (
if (VirtioFsFile->FileInfoArray != NULL) {
FreePool (VirtioFsFile->FileInfoArray);
}
FreePool (VirtioFsFile);
return EFI_SUCCESS;
}

22
OvmfPkg/VirtioFsDxe/SimpleFsDelete.c
View File

@@ -14,12 +14,12 @@
EFI_STATUS
EFIAPI
VirtioFsSimpleFileDelete (
IN EFI_FILE_PROTOCOL *This
IN EFI_FILE_PROTOCOL *This
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -38,8 +38,12 @@ VirtioFsSimpleFileDelete (
//
// If any action fails below, we still try the others.
//
VirtioFsFuseReleaseFileOrDir (VirtioFs, VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle, VirtioFsFile->IsDirectory);
VirtioFsFuseReleaseFileOrDir (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
VirtioFsFile->IsDirectory
);
//
// VirtioFsFile->FuseHandle is gone at this point, but VirtioFsFile->NodeId
@@ -47,8 +51,8 @@ VirtioFsSimpleFileDelete (
// of this operation determines the return status of the function.
//
if (VirtioFsFile->IsOpenForWriting) {
UINT64 ParentNodeId;
CHAR8 *LastComponent;
UINT64 ParentNodeId;
CHAR8 *LastComponent;
//
// Split our canonical pathname into most specific parent directory
@@ -78,6 +82,7 @@ VirtioFsSimpleFileDelete (
VirtioFsFuseForget (VirtioFs, ParentNodeId);
}
}
if (EFI_ERROR (Status)) {
//
// Map any failure to the spec-mandated warning code.
@@ -105,6 +110,7 @@ VirtioFsSimpleFileDelete (
if (VirtioFsFile->FileInfoArray != NULL) {
FreePool (VirtioFsFile->FileInfoArray);
}
FreePool (VirtioFsFile);
return Status;
}

23
OvmfPkg/VirtioFsDxe/SimpleFsFlush.c
View File

@@ -11,12 +11,12 @@
EFI_STATUS
EFIAPI
VirtioFsSimpleFileFlush (
IN EFI_FILE_PROTOCOL *This
IN EFI_FILE_PROTOCOL *This
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -29,14 +29,21 @@ VirtioFsSimpleFileFlush (
// FUSE_FLUSH is for regular files only.
//
if (!VirtioFsFile->IsDirectory) {
Status = VirtioFsFuseFlush (VirtioFs, VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle);
Status = VirtioFsFuseFlush (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle
);
if (EFI_ERROR (Status)) {
return Status;
}
}
Status = VirtioFsFuseFsyncFileOrDir (VirtioFs, VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle, VirtioFsFile->IsDirectory);
Status = VirtioFsFuseFsyncFileOrDir (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
VirtioFsFile->IsDirectory
);
return Status;
}

111
OvmfPkg/VirtioFsDxe/SimpleFsGetInfo.c
View File

@@ -19,18 +19,18 @@
STATIC
EFI_STATUS
GetFileInfo (
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
UINTN AllocSize;
UINTN BasenameSize;
EFI_STATUS Status;
EFI_FILE_INFO *FileInfo;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
UINTN AllocSize;
UINTN BasenameSize;
EFI_STATUS Status;
EFI_FILE_INFO *FileInfo;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -41,8 +41,11 @@ GetFileInfo (
// Calculate the needed size.
//
BasenameSize = 0;
Status = VirtioFsGetBasename (VirtioFsFile->CanonicalPathname, NULL,
&BasenameSize);
Status = VirtioFsGetBasename (
VirtioFsFile->CanonicalPathname,
NULL,
&BasenameSize
);
ASSERT (Status == EFI_BUFFER_TOO_SMALL);
*BufferSize = OFFSET_OF (EFI_FILE_INFO, FileName) + BasenameSize;
@@ -53,10 +56,13 @@ GetFileInfo (
//
// Set the structure size, and store the basename.
//
FileInfo = Buffer;
FileInfo = Buffer;
FileInfo->Size = *BufferSize;
Status = VirtioFsGetBasename (VirtioFsFile->CanonicalPathname,
FileInfo->FileName, &BasenameSize);
Status = VirtioFsGetBasename (
VirtioFsFile->CanonicalPathname,
FileInfo->FileName,
&BasenameSize
);
ASSERT_EFI_ERROR (Status);
//
@@ -66,6 +72,7 @@ GetFileInfo (
if (!EFI_ERROR (Status)) {
Status = VirtioFsFuseAttrToEfiFileInfo (&FuseAttr, FileInfo);
}
return (Status == EFI_BUFFER_TOO_SMALL) ? EFI_DEVICE_ERROR : Status;
}
@@ -75,19 +82,19 @@ GetFileInfo (
STATIC
EFI_STATUS
GetFileSystemInfo (
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
UINTN AllocSize;
UINTN LabelSize;
EFI_STATUS Status;
VIRTIO_FS_FUSE_STATFS_RESPONSE FilesysAttr;
UINT64 MaxBlocks;
EFI_FILE_SYSTEM_INFO *FilesysInfo;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
UINTN AllocSize;
UINTN LabelSize;
EFI_STATUS Status;
VIRTIO_FS_FUSE_STATFS_RESPONSE FilesysAttr;
UINT64 MaxBlocks;
EFI_FILE_SYSTEM_INFO *FilesysInfo;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -97,7 +104,7 @@ GetFileSystemInfo (
//
// Calculate the needed size.
//
LabelSize = StrSize (VirtioFs->Label);
LabelSize = StrSize (VirtioFs->Label);
*BufferSize = OFFSET_OF (EFI_FILE_SYSTEM_INFO, VolumeLabel) + LabelSize;
if (*BufferSize > AllocSize) {
@@ -111,18 +118,22 @@ GetFileSystemInfo (
if (EFI_ERROR (Status)) {
return (Status == EFI_BUFFER_TOO_SMALL) ? EFI_DEVICE_ERROR : Status;
}
//
// Sanity checks...
//
if (FilesysAttr.Frsize != FilesysAttr.Bsize) {
return EFI_UNSUPPORTED;
}
if (FilesysAttr.Frsize == 0 || FilesysAttr.Blocks == 0 ||
FilesysAttr.Bavail > FilesysAttr.Blocks) {
if ((FilesysAttr.Frsize == 0) || (FilesysAttr.Blocks == 0) ||
(FilesysAttr.Bavail > FilesysAttr.Blocks))
{
return EFI_DEVICE_ERROR;
}
MaxBlocks = DivU64x32 (MAX_UINT64, FilesysAttr.Frsize);
if (FilesysAttr.Blocks > MaxBlocks || FilesysAttr.Bavail > MaxBlocks) {
if ((FilesysAttr.Blocks > MaxBlocks) || (FilesysAttr.Bavail > MaxBlocks)) {
return EFI_DEVICE_ERROR;
}
@@ -132,11 +143,15 @@ GetFileSystemInfo (
FilesysInfo = Buffer;
FilesysInfo->Size = *BufferSize;
FilesysInfo->ReadOnly = FALSE;
FilesysInfo->VolumeSize = MultU64x32 (FilesysAttr.Blocks,
FilesysAttr.Frsize);
FilesysInfo->FreeSpace = MultU64x32 (FilesysAttr.Bavail,
FilesysAttr.Frsize);
FilesysInfo->BlockSize = FilesysAttr.Frsize;
FilesysInfo->VolumeSize = MultU64x32 (
FilesysAttr.Blocks,
FilesysAttr.Frsize
);
FilesysInfo->FreeSpace = MultU64x32 (
FilesysAttr.Bavail,
FilesysAttr.Frsize
);
FilesysInfo->BlockSize = FilesysAttr.Frsize;
CopyMem (FilesysInfo->VolumeLabel, VirtioFs->Label, LabelSize);
return EFI_SUCCESS;
@@ -148,16 +163,16 @@ GetFileSystemInfo (
STATIC
EFI_STATUS
GetFileSystemVolumeLabelInfo (
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
UINTN AllocSize;
UINTN LabelSize;
EFI_FILE_SYSTEM_VOLUME_LABEL *FilesysVolumeLabel;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
UINTN AllocSize;
UINTN LabelSize;
EFI_FILE_SYSTEM_VOLUME_LABEL *FilesysVolumeLabel;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -167,7 +182,7 @@ GetFileSystemVolumeLabelInfo (
//
// Calculate the needed size.
//
LabelSize = StrSize (VirtioFs->Label);
LabelSize = StrSize (VirtioFs->Label);
*BufferSize = (OFFSET_OF (EFI_FILE_SYSTEM_VOLUME_LABEL, VolumeLabel) +
LabelSize);
@@ -187,10 +202,10 @@ GetFileSystemVolumeLabelInfo (
EFI_STATUS
EFIAPI
VirtioFsSimpleFileGetInfo (
IN EFI_FILE_PROTOCOL *This,
IN EFI_GUID *InformationType,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN EFI_GUID *InformationType,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
)
{
if (CompareGuid (InformationType, &gEfiFileInfoGuid)) {

7
OvmfPkg/VirtioFsDxe/SimpleFsGetPosition.c
View File

@@ -12,16 +12,17 @@
EFI_STATUS
EFIAPI
VirtioFsSimpleFileGetPosition (
IN EFI_FILE_PROTOCOL *This,
OUT UINT64 *Position
IN EFI_FILE_PROTOCOL *This,
OUT UINT64 *Position
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS_FILE *VirtioFsFile;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
if (VirtioFsFile->IsDirectory) {
return EFI_UNSUPPORTED;
}
*Position = VirtioFsFile->FilePosition;
return EFI_SUCCESS;
}

223
OvmfPkg/VirtioFsDxe/SimpleFsOpen.c
View File

@@ -38,13 +38,13 @@
STATIC
EFI_STATUS
OpenRootDirectory (
IN OUT VIRTIO_FS *VirtioFs,
OUT EFI_FILE_PROTOCOL **NewHandle,
IN BOOLEAN OpenForWriting
IN OUT VIRTIO_FS *VirtioFs,
OUT EFI_FILE_PROTOCOL **NewHandle,
IN BOOLEAN OpenForWriting
)
{
EFI_STATUS Status;
VIRTIO_FS_FILE *NewVirtioFsFile;
EFI_STATUS Status;
VIRTIO_FS_FILE *NewVirtioFsFile;
//
// VirtioFsOpenVolume() opens the root directory for read-only access. If the
@@ -54,18 +54,23 @@ OpenRootDirectory (
// permission first.
//
if (OpenForWriting) {
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
EFI_FILE_INFO FileInfo;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
EFI_FILE_INFO FileInfo;
Status = VirtioFsFuseGetAttr (VirtioFs, VIRTIO_FS_FUSE_ROOT_DIR_NODE_ID,
&FuseAttr);
Status = VirtioFsFuseGetAttr (
VirtioFs,
VIRTIO_FS_FUSE_ROOT_DIR_NODE_ID,
&FuseAttr
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = VirtioFsFuseAttrToEfiFileInfo (&FuseAttr, &FileInfo);
if (EFI_ERROR (Status)) {
return Status;
}
if ((FileInfo.Attribute & EFI_FILE_READ_ONLY) != 0) {
return EFI_ACCESS_DENIED;
}
@@ -76,7 +81,7 @@ OpenRootDirectory (
return Status;
}
NewVirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (*NewHandle);
NewVirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (*NewHandle);
NewVirtioFsFile->IsOpenForWriting = OpenForWriting;
return EFI_SUCCESS;
}
@@ -132,33 +137,39 @@ OpenRootDirectory (
STATIC
EFI_STATUS
OpenExistentFileOrDirectory (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
IN BOOLEAN OpenForWriting,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle,
OUT BOOLEAN *NodeIsDirectory
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
IN BOOLEAN OpenForWriting,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle,
OUT BOOLEAN *NodeIsDirectory
)
{
EFI_STATUS Status;
UINT64 ResolvedNodeId;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
EFI_FILE_INFO FileInfo;
BOOLEAN IsDirectory;
UINT64 NewFuseHandle;
EFI_STATUS Status;
UINT64 ResolvedNodeId;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
EFI_FILE_INFO FileInfo;
BOOLEAN IsDirectory;
UINT64 NewFuseHandle;
Status = VirtioFsFuseLookup (VirtioFs, DirNodeId, Name, &ResolvedNodeId,
&FuseAttr);
Status = VirtioFsFuseLookup (
VirtioFs,
DirNodeId,
Name,
&ResolvedNodeId,
&FuseAttr
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = VirtioFsFuseAttrToEfiFileInfo (&FuseAttr, &FileInfo);
if (EFI_ERROR (Status)) {
goto ForgetResolvedNodeId;
}
if (OpenForWriting && (FileInfo.Attribute & EFI_FILE_READ_ONLY) != 0) {
if (OpenForWriting && ((FileInfo.Attribute & EFI_FILE_READ_ONLY) != 0)) {
Status = EFI_ACCESS_DENIED;
goto ForgetResolvedNodeId;
}
@@ -173,9 +184,14 @@ OpenExistentFileOrDirectory (
//
Status = VirtioFsFuseOpenDir (VirtioFs, ResolvedNodeId, &NewFuseHandle);
} else {
Status = VirtioFsFuseOpen (VirtioFs, ResolvedNodeId, OpenForWriting,
&NewFuseHandle);
Status = VirtioFsFuseOpen (
VirtioFs,
ResolvedNodeId,
OpenForWriting,
&NewFuseHandle
);
}
if (EFI_ERROR (Status)) {
goto ForgetResolvedNodeId;
}
@@ -216,16 +232,16 @@ ForgetResolvedNodeId:
STATIC
EFI_STATUS
CreateDirectory (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle
)
{
EFI_STATUS Status;
UINT64 NewChildDirNodeId;
UINT64 NewFuseHandle;
EFI_STATUS Status;
UINT64 NewChildDirNodeId;
UINT64 NewFuseHandle;
Status = VirtioFsFuseMkDir (VirtioFs, DirNodeId, Name, &NewChildDirNodeId);
if (EFI_ERROR (Status)) {
@@ -273,41 +289,46 @@ RemoveNewChildDir:
STATIC
EFI_STATUS
CreateRegularFile (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle
)
{
return VirtioFsFuseOpenOrCreate (VirtioFs, DirNodeId, Name, NodeId,
FuseHandle);
return VirtioFsFuseOpenOrCreate (
VirtioFs,
DirNodeId,
Name,
NodeId,
FuseHandle
);
}
EFI_STATUS
EFIAPI
VirtioFsSimpleFileOpen (
IN EFI_FILE_PROTOCOL *This,
OUT EFI_FILE_PROTOCOL **NewHandle,
IN CHAR16 *FileName,
IN UINT64 OpenMode,
IN UINT64 Attributes
IN EFI_FILE_PROTOCOL *This,
OUT EFI_FILE_PROTOCOL **NewHandle,
IN CHAR16 *FileName,
IN UINT64 OpenMode,
IN UINT64 Attributes
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
BOOLEAN OpenForWriting;
BOOLEAN PermitCreation;
BOOLEAN CreateDirectoryIfCreating;
VIRTIO_FS_FILE *NewVirtioFsFile;
EFI_STATUS Status;
CHAR8 *NewCanonicalPath;
BOOLEAN RootEscape;
UINT64 DirNodeId;
CHAR8 *LastComponent;
UINT64 NewNodeId;
UINT64 NewFuseHandle;
BOOLEAN NewNodeIsDirectory;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
BOOLEAN OpenForWriting;
BOOLEAN PermitCreation;
BOOLEAN CreateDirectoryIfCreating;
VIRTIO_FS_FILE *NewVirtioFsFile;
EFI_STATUS Status;
CHAR8 *NewCanonicalPath;
BOOLEAN RootEscape;
UINT64 DirNodeId;
CHAR8 *LastComponent;
UINT64 NewNodeId;
UINT64 NewFuseHandle;
BOOLEAN NewNodeIsDirectory;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -316,20 +337,20 @@ VirtioFsSimpleFileOpen (
// Validate OpenMode.
//
switch (OpenMode) {
case EFI_FILE_MODE_READ:
OpenForWriting = FALSE;
PermitCreation = FALSE;
break;
case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:
OpenForWriting = TRUE;
PermitCreation = FALSE;
break;
case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE:
OpenForWriting = TRUE;
PermitCreation = TRUE;
break;
default:
return EFI_INVALID_PARAMETER;
case EFI_FILE_MODE_READ:
OpenForWriting = FALSE;
PermitCreation = FALSE;
break;
case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:
OpenForWriting = TRUE;
PermitCreation = FALSE;
break;
case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE:
OpenForWriting = TRUE;
PermitCreation = TRUE;
break;
default:
return EFI_INVALID_PARAMETER;
}
//
@@ -366,6 +387,7 @@ VirtioFsSimpleFileOpen (
));
return EFI_INVALID_PARAMETER;
}
CreateDirectoryIfCreating = (BOOLEAN)((Attributes &
EFI_FILE_DIRECTORY) != 0);
}
@@ -401,11 +423,16 @@ VirtioFsSimpleFileOpen (
// Create the canonical pathname at which the desired file is expected to
// exist.
//
Status = VirtioFsAppendPath (VirtioFsFile->CanonicalPathname, FileName,
&NewCanonicalPath, &RootEscape);
Status = VirtioFsAppendPath (
VirtioFsFile->CanonicalPathname,
FileName,
&NewCanonicalPath,
&RootEscape
);
if (EFI_ERROR (Status)) {
goto FreeNewVirtioFsFile;
}
if (RootEscape) {
Status = EFI_ACCESS_DENIED;
goto FreeNewCanonicalPath;
@@ -426,8 +453,12 @@ VirtioFsSimpleFileOpen (
// (given by DirNodeId) and last pathname component (i.e., immediate child
// within that parent directory).
//
Status = VirtioFsLookupMostSpecificParentDir (VirtioFs, NewCanonicalPath,
&DirNodeId, &LastComponent);
Status = VirtioFsLookupMostSpecificParentDir (
VirtioFs,
NewCanonicalPath,
&DirNodeId,
&LastComponent
);
if (EFI_ERROR (Status)) {
goto FreeNewCanonicalPath;
}
@@ -441,22 +472,40 @@ VirtioFsSimpleFileOpen (
// Try to open LastComponent directly under DirNodeId, as an existent regular
// file or directory.
//
Status = OpenExistentFileOrDirectory (VirtioFs, DirNodeId, LastComponent,
OpenForWriting, &NewNodeId, &NewFuseHandle, &NewNodeIsDirectory);
Status = OpenExistentFileOrDirectory (
VirtioFs,
DirNodeId,
LastComponent,
OpenForWriting,
&NewNodeId,
&NewFuseHandle,
&NewNodeIsDirectory
);
//
// If LastComponent could not be found under DirNodeId, but the request
// allows us to create a new entry, attempt creating the requested regular
// file or directory.
//
if (Status == EFI_NOT_FOUND && PermitCreation) {
if ((Status == EFI_NOT_FOUND) && PermitCreation) {
ASSERT (OpenForWriting);
if (CreateDirectoryIfCreating) {
Status = CreateDirectory (VirtioFs, DirNodeId, LastComponent, &NewNodeId,
&NewFuseHandle);
Status = CreateDirectory (
VirtioFs,
DirNodeId,
LastComponent,
&NewNodeId,
&NewFuseHandle
);
} else {
Status = CreateRegularFile (VirtioFs, DirNodeId, LastComponent,
&NewNodeId, &NewFuseHandle);
Status = CreateRegularFile (
VirtioFs,
DirNodeId,
LastComponent,
&NewNodeId,
&NewFuseHandle
);
}
NewNodeIsDirectory = CreateDirectoryIfCreating;
}

21
OvmfPkg/VirtioFsDxe/SimpleFsOpenVolume.c
View File

@@ -21,15 +21,15 @@
EFI_STATUS
EFIAPI
VirtioFsOpenVolume (
IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
OUT EFI_FILE_PROTOCOL **Root
IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
OUT EFI_FILE_PROTOCOL **Root
)
{
VIRTIO_FS *VirtioFs;
VIRTIO_FS_FILE *VirtioFsFile;
EFI_STATUS Status;
CHAR8 *CanonicalPathname;
UINT64 RootDirHandle;
VIRTIO_FS *VirtioFs;
VIRTIO_FS_FILE *VirtioFsFile;
EFI_STATUS Status;
CHAR8 *CanonicalPathname;
UINT64 RootDirHandle;
VirtioFs = VIRTIO_FS_FROM_SIMPLE_FS (This);
@@ -47,8 +47,11 @@ VirtioFsOpenVolume (
//
// Open the root directory.
//
Status = VirtioFsFuseOpenDir (VirtioFs, VIRTIO_FS_FUSE_ROOT_DIR_NODE_ID,
&RootDirHandle);
Status = VirtioFsFuseOpenDir (
VirtioFs,
VIRTIO_FS_FUSE_ROOT_DIR_NODE_ID,
&RootDirHandle
);
if (EFI_ERROR (Status)) {
goto FreeCanonicalPathname;
}

155
OvmfPkg/VirtioFsDxe/SimpleFsRead.c
View File

@@ -37,21 +37,22 @@
STATIC
EFI_STATUS
PopulateFileInfo (
IN VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE *Dirent,
IN UINTN SingleFileInfoSize,
OUT EFI_FILE_INFO *FileInfo
IN VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE *Dirent,
IN UINTN SingleFileInfoSize,
OUT EFI_FILE_INFO *FileInfo
)
{
EFI_STATUS Status;
EFI_STATUS Status;
//
// Convert the name, set the actual size.
//
FileInfo->Size = SingleFileInfoSize;
Status = VirtioFsFuseDirentPlusToEfiFileInfo (Dirent, FileInfo);
Status = VirtioFsFuseDirentPlusToEfiFileInfo (Dirent, FileInfo);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Populate the scalar fields.
//
@@ -65,19 +66,19 @@ PopulateFileInfo (
STATIC
EFI_STATUS
RefillFileInfoCache (
IN OUT VIRTIO_FS_FILE *VirtioFsFile
IN OUT VIRTIO_FS_FILE *VirtioFsFile
)
{
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FUSE_STATFS_RESPONSE FilesysAttr;
UINT32 DirentBufSize;
UINT8 *DirentBuf;
UINTN SingleFileInfoSize;
UINT8 *FileInfoArray;
UINT64 DirStreamCookie;
UINT64 CacheEndsAtCookie;
UINTN NumFileInfo;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FUSE_STATFS_RESPONSE FilesysAttr;
UINT32 DirentBufSize;
UINT8 *DirentBuf;
UINTN SingleFileInfoSize;
UINT8 *FileInfoArray;
UINT64 DirStreamCookie;
UINT64 CacheEndsAtCookie;
UINTN NumFileInfo;
//
// Allocate a DirentBuf that can receive at least
@@ -87,17 +88,20 @@ RefillFileInfoCache (
// check.
//
VirtioFs = VirtioFsFile->OwnerFs;
Status = VirtioFsFuseStatFs (VirtioFs, VirtioFsFile->NodeId, &FilesysAttr);
Status = VirtioFsFuseStatFs (VirtioFs, VirtioFsFile->NodeId, &FilesysAttr);
if (EFI_ERROR (Status)) {
return Status;
}
DirentBufSize = (UINT32)VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE_SIZE (
FilesysAttr.Namelen);
FilesysAttr.Namelen
);
if (DirentBufSize == 0) {
return EFI_UNSUPPORTED;
}
DirentBufSize *= VIRTIO_FS_FILE_MAX_FILE_INFO;
DirentBuf = AllocatePool (DirentBufSize);
DirentBuf = AllocatePool (DirentBufSize);
if (DirentBuf == NULL) {
return EFI_OUT_OF_RESOURCES;
}
@@ -128,8 +132,8 @@ RefillFileInfoCache (
CacheEndsAtCookie = VirtioFsFile->FilePosition;
NumFileInfo = 0;
do {
UINT32 Remaining;
UINT32 Consumed;
UINT32 Remaining;
UINT32 Consumed;
//
// Fetch a chunk of the directory stream. The chunk may hold more entries
@@ -138,15 +142,15 @@ RefillFileInfoCache (
// supported under UEFI (sockets, FIFOs, filenames with backslashes, etc).
//
Remaining = DirentBufSize;
Status = VirtioFsFuseReadFileOrDir (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
TRUE, // IsDir
DirStreamCookie, // Offset
&Remaining, // Size
DirentBuf // Data
);
Status = VirtioFsFuseReadFileOrDir (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
TRUE, // IsDir
DirStreamCookie, // Offset
&Remaining, // Size
DirentBuf // Data
);
if (EFI_ERROR (Status)) {
goto FreeFileInfoArray;
}
@@ -165,12 +169,13 @@ RefillFileInfoCache (
//
Consumed = 0;
while (Remaining >= sizeof (VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE)) {
VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE *Dirent;
UINT32 DirentSize;
VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE *Dirent;
UINT32 DirentSize;
Dirent = (VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE *)(DirentBuf + Consumed);
Dirent = (VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE *)(DirentBuf + Consumed);
DirentSize = (UINT32)VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE_SIZE (
Dirent->Namelen);
Dirent->Namelen
);
if (DirentSize == 0) {
//
// This means one of two things: (a) Dirent->Namelen is zero, or (b)
@@ -182,6 +187,7 @@ RefillFileInfoCache (
Status = EFI_PROTOCOL_ERROR;
goto FreeFileInfoArray;
}
if (DirentSize > Remaining) {
//
// Dirent->Namelen suggests that the filename byte array (plus any
@@ -191,6 +197,7 @@ RefillFileInfoCache (
Status = EFI_PROTOCOL_ERROR;
goto FreeFileInfoArray;
}
if (Dirent->Namelen > FilesysAttr.Namelen) {
//
// This is possible without tripping the truncation check above, due to
@@ -207,7 +214,7 @@ RefillFileInfoCache (
// Dirent to EFI_FILE_INFO.
//
if (NumFileInfo < VIRTIO_FS_FILE_MAX_FILE_INFO) {
EFI_FILE_INFO *FileInfo;
EFI_FILE_INFO *FileInfo;
FileInfo = (EFI_FILE_INFO *)(FileInfoArray +
(NumFileInfo * SingleFileInfoSize));
@@ -224,6 +231,7 @@ RefillFileInfoCache (
//
CacheEndsAtCookie = Dirent->CookieForNextEntry;
}
//
// If Dirent wasn't transformable to an EFI_FILE_INFO, we'll just skip
// it.
@@ -244,8 +252,8 @@ RefillFileInfoCache (
// Advance to the next entry in DirentBuf.
//
DirStreamCookie = Dirent->CookieForNextEntry;
Consumed += DirentSize;
Remaining -= DirentSize;
Consumed += DirentSize;
Remaining -= DirentSize;
}
if (Remaining > 0) {
@@ -257,6 +265,7 @@ RefillFileInfoCache (
Status = EFI_PROTOCOL_ERROR;
goto FreeFileInfoArray;
}
//
// Fetch another DirentBuf from the directory stream, unless we've filled
// the EFI_FILE_INFO cache.
@@ -269,6 +278,7 @@ RefillFileInfoCache (
if (VirtioFsFile->FileInfoArray != NULL) {
FreePool (VirtioFsFile->FileInfoArray);
}
VirtioFsFile->FileInfoArray = FileInfoArray;
VirtioFsFile->SingleFileInfoSize = SingleFileInfoSize;
VirtioFsFile->NumFileInfo = NumFileInfo;
@@ -293,30 +303,32 @@ FreeDirentBuf:
STATIC
EFI_STATUS
ReadFileInfoCache (
IN OUT VIRTIO_FS_FILE *VirtioFsFile,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
IN OUT VIRTIO_FS_FILE *VirtioFsFile,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
)
{
EFI_FILE_INFO *FileInfo;
UINTN CallerAllocated;
EFI_FILE_INFO *FileInfo;
UINTN CallerAllocated;
//
// Refill the cache if needed. If the refill doesn't produce any new
// EFI_FILE_INFO, report End of Directory, by setting (*BufferSize) to 0.
//
if (VirtioFsFile->NextFileInfo == VirtioFsFile->NumFileInfo) {
EFI_STATUS Status;
EFI_STATUS Status;
Status = RefillFileInfoCache (VirtioFsFile);
if (EFI_ERROR (Status)) {
return (Status == EFI_BUFFER_TOO_SMALL) ? EFI_DEVICE_ERROR : Status;
}
if (VirtioFsFile->NumFileInfo == 0) {
*BufferSize = 0;
return EFI_SUCCESS;
}
}
FileInfo = (EFI_FILE_INFO *)(VirtioFsFile->FileInfoArray +
(VirtioFsFile->NextFileInfo *
VirtioFsFile->SingleFileInfoSize));
@@ -337,10 +349,11 @@ ReadFileInfoCache (
// VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE_SIZE().)
//
CallerAllocated = *BufferSize;
*BufferSize = (UINTN)FileInfo->Size;
*BufferSize = (UINTN)FileInfo->Size;
if (CallerAllocated < *BufferSize) {
return EFI_BUFFER_TOO_SMALL;
}
//
// Output FileInfo, and remove it from the cache.
//
@@ -355,23 +368,23 @@ ReadFileInfoCache (
STATIC
EFI_STATUS
ReadRegularFile (
IN OUT VIRTIO_FS_FILE *VirtioFsFile,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
IN OUT VIRTIO_FS_FILE *VirtioFsFile,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
)
{
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
UINTN Transferred;
UINTN Left;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
UINTN Transferred;
UINTN Left;
VirtioFs = VirtioFsFile->OwnerFs;
//
// The UEFI spec forbids reads that start beyond the end of the file.
//
Status = VirtioFsFuseGetAttr (VirtioFs, VirtioFsFile->NodeId, &FuseAttr);
if (EFI_ERROR (Status) || VirtioFsFile->FilePosition > FuseAttr.Size) {
if (EFI_ERROR (Status) || (VirtioFsFile->FilePosition > FuseAttr.Size)) {
return EFI_DEVICE_ERROR;
}
@@ -379,29 +392,30 @@ ReadRegularFile (
Transferred = 0;
Left = *BufferSize;
while (Left > 0) {
UINT32 ReadSize;
UINT32 ReadSize;
//
// FUSE_READ cannot express a >=4GB buffer size.
//
ReadSize = (UINT32)MIN ((UINTN)MAX_UINT32, Left);
Status = VirtioFsFuseReadFileOrDir (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
FALSE, // IsDir
VirtioFsFile->FilePosition + Transferred,
&ReadSize,
(UINT8 *)Buffer + Transferred
);
if (EFI_ERROR (Status) || ReadSize == 0) {
Status = VirtioFsFuseReadFileOrDir (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
FALSE, // IsDir
VirtioFsFile->FilePosition + Transferred,
&ReadSize,
(UINT8 *)Buffer + Transferred
);
if (EFI_ERROR (Status) || (ReadSize == 0)) {
break;
}
Transferred += ReadSize;
Left -= ReadSize;
}
*BufferSize = Transferred;
*BufferSize = Transferred;
VirtioFsFile->FilePosition += Transferred;
//
// If we managed to read some data, return success. If zero bytes were
@@ -415,13 +429,13 @@ ReadRegularFile (
EFI_STATUS
EFIAPI
VirtioFsSimpleFileRead (
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
)
{
VIRTIO_FS_FILE *VirtioFsFile;
EFI_STATUS Status;
VIRTIO_FS_FILE *VirtioFsFile;
EFI_STATUS Status;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
@@ -430,5 +444,6 @@ VirtioFsSimpleFileRead (
} else {
Status = ReadRegularFile (VirtioFsFile, BufferSize, Buffer);
}
return Status;
}

239
OvmfPkg/VirtioFsDxe/SimpleFsSetInfo.c
View File

@@ -56,16 +56,16 @@
STATIC
EFI_STATUS
ValidateInfoStructure (
IN UINTN SizeByProtocolCaller,
IN UINTN MinimumStructSize,
IN BOOLEAN IsSizeByInfoPresent,
IN VOID *Buffer
IN UINTN SizeByProtocolCaller,
IN UINTN MinimumStructSize,
IN BOOLEAN IsSizeByInfoPresent,
IN VOID *Buffer
)
{
UINTN NameFieldByteOffset;
UINTN NameFieldBytes;
UINTN NameFieldChar16s;
CHAR16 *NameField;
UINTN NameFieldByteOffset;
UINTN NameFieldBytes;
UINTN NameFieldChar16s;
CHAR16 *NameField;
//
// Make sure the internal function asking for validation passes in sane
@@ -92,7 +92,7 @@ ValidateInfoStructure (
// agrees with the protocol caller-provided size.
//
if (IsSizeByInfoPresent) {
UINT64 *SizeByInfo;
UINT64 *SizeByInfo;
SizeByInfo = Buffer;
if (*SizeByInfo != SizeByProtocolCaller) {
@@ -172,19 +172,18 @@ ValidateInfoStructure (
STATIC
EFI_STATUS
Rename (
IN OUT VIRTIO_FS_FILE *VirtioFsFile,
IN CHAR16 *NewFileName
IN OUT VIRTIO_FS_FILE *VirtioFsFile,
IN CHAR16 *NewFileName
)
{
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
CHAR8 *Destination;
BOOLEAN RootEscape;
UINT64 OldParentDirNodeId;
CHAR8 *OldLastComponent;
UINT64 NewParentDirNodeId;
CHAR8 *NewLastComponent;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
CHAR8 *Destination;
BOOLEAN RootEscape;
UINT64 OldParentDirNodeId;
CHAR8 *OldLastComponent;
UINT64 NewParentDirNodeId;
CHAR8 *NewLastComponent;
VirtioFs = VirtioFsFile->OwnerFs;
@@ -198,21 +197,28 @@ Rename (
//
return EFI_SUCCESS;
}
return EFI_ACCESS_DENIED;
}
//
// Compose the canonical pathname for the destination.
//
Status = VirtioFsComposeRenameDestination (VirtioFsFile->CanonicalPathname,
NewFileName, &Destination, &RootEscape);
Status = VirtioFsComposeRenameDestination (
VirtioFsFile->CanonicalPathname,
NewFileName,
&Destination,
&RootEscape
);
if (EFI_ERROR (Status)) {
return Status;
}
if (RootEscape) {
Status = EFI_NOT_FOUND;
goto FreeDestination;
}
//
// If the rename would leave VirtioFsFile->CanonicalPathname unchanged, then
// EFI_FILE_PROTOCOL.SetInfo() isn't asking for a rename actually.
@@ -221,24 +227,29 @@ Rename (
Status = EFI_SUCCESS;
goto FreeDestination;
}
//
// Check if the rename would break the canonical pathnames of other
// VIRTIO_FS_FILE instances of the same VIRTIO_FS.
//
if (VirtioFsFile->IsDirectory) {
UINTN PathLen;
LIST_ENTRY *OpenFilesEntry;
UINTN PathLen;
LIST_ENTRY *OpenFilesEntry;
PathLen = AsciiStrLen (VirtioFsFile->CanonicalPathname);
BASE_LIST_FOR_EACH (OpenFilesEntry, &VirtioFs->OpenFiles) {
VIRTIO_FS_FILE *OtherFile;
VIRTIO_FS_FILE *OtherFile;
OtherFile = VIRTIO_FS_FILE_FROM_OPEN_FILES_ENTRY (OpenFilesEntry);
if (OtherFile != VirtioFsFile &&
AsciiStrnCmp (VirtioFsFile->CanonicalPathname,
OtherFile->CanonicalPathname, PathLen) == 0 &&
(OtherFile->CanonicalPathname[PathLen] == '\0' ||
OtherFile->CanonicalPathname[PathLen] == '/')) {
if ((OtherFile != VirtioFsFile) &&
(AsciiStrnCmp (
VirtioFsFile->CanonicalPathname,
OtherFile->CanonicalPathname,
PathLen
) == 0) &&
((OtherFile->CanonicalPathname[PathLen] == '\0') ||
(OtherFile->CanonicalPathname[PathLen] == '/')))
{
//
// OtherFile refers to the same directory as VirtioFsFile, or is a
// (possibly indirect) child of the directory referred to by
@@ -249,6 +260,7 @@ Rename (
}
}
}
//
// From this point on, the file needs to be open for writing.
//
@@ -256,26 +268,41 @@ Rename (
Status = EFI_ACCESS_DENIED;
goto FreeDestination;
}
//
// Split both source and destination canonical pathnames into (most specific
// parent directory, last component) pairs.
//
Status = VirtioFsLookupMostSpecificParentDir (VirtioFs,
VirtioFsFile->CanonicalPathname, &OldParentDirNodeId,
&OldLastComponent);
Status = VirtioFsLookupMostSpecificParentDir (
VirtioFs,
VirtioFsFile->CanonicalPathname,
&OldParentDirNodeId,
&OldLastComponent
);
if (EFI_ERROR (Status)) {
goto FreeDestination;
}
Status = VirtioFsLookupMostSpecificParentDir (VirtioFs, Destination,
&NewParentDirNodeId, &NewLastComponent);
Status = VirtioFsLookupMostSpecificParentDir (
VirtioFs,
Destination,
&NewParentDirNodeId,
&NewLastComponent
);
if (EFI_ERROR (Status)) {
goto ForgetOldParentDirNodeId;
}
//
// Perform the rename. If the destination path exists, the rename will fail.
//
Status = VirtioFsFuseRename (VirtioFs, OldParentDirNodeId, OldLastComponent,
NewParentDirNodeId, NewLastComponent);
Status = VirtioFsFuseRename (
VirtioFs,
OldParentDirNodeId,
OldLastComponent,
NewParentDirNodeId,
NewLastComponent
);
if (EFI_ERROR (Status)) {
goto ForgetNewParentDirNodeId;
}
@@ -285,8 +312,8 @@ Rename (
//
FreePool (VirtioFsFile->CanonicalPathname);
VirtioFsFile->CanonicalPathname = Destination;
Destination = NULL;
Status = EFI_SUCCESS;
Destination = NULL;
Status = EFI_SUCCESS;
//
// Fall through.
@@ -305,6 +332,7 @@ FreeDestination:
if (Destination != NULL) {
FreePool (Destination);
}
return Status;
}
@@ -332,22 +360,22 @@ FreeDestination:
STATIC
EFI_STATUS
UpdateAttributes (
IN OUT VIRTIO_FS_FILE *VirtioFsFile,
IN EFI_FILE_INFO *NewFileInfo
IN OUT VIRTIO_FS_FILE *VirtioFsFile,
IN EFI_FILE_INFO *NewFileInfo
)
{
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
EFI_FILE_INFO FileInfo;
BOOLEAN UpdateFileSize;
UINT64 FileSize;
BOOLEAN UpdateAtime;
BOOLEAN UpdateMtime;
UINT64 Atime;
UINT64 Mtime;
BOOLEAN UpdateMode;
UINT32 Mode;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
EFI_FILE_INFO FileInfo;
BOOLEAN UpdateFileSize;
UINT64 FileSize;
BOOLEAN UpdateAtime;
BOOLEAN UpdateMtime;
UINT64 Atime;
UINT64 Mtime;
BOOLEAN UpdateMode;
UINT32 Mode;
VirtioFs = VirtioFsFile->OwnerFs;
@@ -359,28 +387,44 @@ UpdateAttributes (
if (EFI_ERROR (Status)) {
return Status;
}
Status = VirtioFsFuseAttrToEfiFileInfo (&FuseAttr, &FileInfo);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Collect the updates.
//
if (VirtioFsFile->IsDirectory) {
UpdateFileSize = FALSE;
} else {
VirtioFsGetFuseSizeUpdate (&FileInfo, NewFileInfo, &UpdateFileSize,
&FileSize);
VirtioFsGetFuseSizeUpdate (
&FileInfo,
NewFileInfo,
&UpdateFileSize,
&FileSize
);
}
Status = VirtioFsGetFuseTimeUpdates (&FileInfo, NewFileInfo, &UpdateAtime,
&UpdateMtime, &Atime, &Mtime);
Status = VirtioFsGetFuseTimeUpdates (
&FileInfo,
NewFileInfo,
&UpdateAtime,
&UpdateMtime,
&Atime,
&Mtime
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = VirtioFsGetFuseModeUpdate (&FileInfo, NewFileInfo, &UpdateMode,
&Mode);
Status = VirtioFsGetFuseModeUpdate (
&FileInfo,
NewFileInfo,
&UpdateMode,
&Mode
);
if (EFI_ERROR (Status)) {
return Status;
}
@@ -391,14 +435,17 @@ UpdateAttributes (
if (!UpdateFileSize && !UpdateAtime && !UpdateMtime && !UpdateMode) {
return EFI_SUCCESS;
}
//
// If the file is not open for writing, then only Mode may be updated (for
// toggling EFI_FILE_READ_ONLY).
//
if (!VirtioFsFile->IsOpenForWriting &&
(UpdateFileSize || UpdateAtime || UpdateMtime)) {
(UpdateFileSize || UpdateAtime || UpdateMtime))
{
return EFI_ACCESS_DENIED;
}
//
// Send the FUSE_SETATTR request now.
//
@@ -419,14 +466,14 @@ UpdateAttributes (
STATIC
EFI_STATUS
SetFileInfo (
IN EFI_FILE_PROTOCOL *This,
IN UINTN BufferSize,
IN VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN UINTN BufferSize,
IN VOID *Buffer
)
{
VIRTIO_FS_FILE *VirtioFsFile;
EFI_STATUS Status;
EFI_FILE_INFO *FileInfo;
VIRTIO_FS_FILE *VirtioFsFile;
EFI_STATUS Status;
EFI_FILE_INFO *FileInfo;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
@@ -435,14 +482,17 @@ SetFileInfo (
//
Status = ValidateInfoStructure (
BufferSize, // SizeByProtocolCaller
OFFSET_OF (EFI_FILE_INFO,
FileName) + sizeof (CHAR16), // MinimumStructSize
OFFSET_OF (
EFI_FILE_INFO,
FileName
) + sizeof (CHAR16), // MinimumStructSize
TRUE, // IsSizeByInfoPresent
Buffer
);
if (EFI_ERROR (Status)) {
return Status;
}
FileInfo = Buffer;
//
@@ -452,6 +502,7 @@ SetFileInfo (
if (EFI_ERROR (Status)) {
return Status;
}
//
// Update any attributes requested.
//
@@ -470,15 +521,15 @@ SetFileInfo (
STATIC
EFI_STATUS
SetFileSystemInfo (
IN EFI_FILE_PROTOCOL *This,
IN UINTN BufferSize,
IN VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN UINTN BufferSize,
IN VOID *Buffer
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
EFI_FILE_SYSTEM_INFO *FileSystemInfo;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
EFI_FILE_SYSTEM_INFO *FileSystemInfo;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -488,14 +539,17 @@ SetFileSystemInfo (
//
Status = ValidateInfoStructure (
BufferSize, // SizeByProtocolCaller
OFFSET_OF (EFI_FILE_SYSTEM_INFO,
VolumeLabel) + sizeof (CHAR16), // MinimumStructSize
OFFSET_OF (
EFI_FILE_SYSTEM_INFO,
VolumeLabel
) + sizeof (CHAR16), // MinimumStructSize
TRUE, // IsSizeByInfoPresent
Buffer
);
if (EFI_ERROR (Status)) {
return Status;
}
FileSystemInfo = Buffer;
//
@@ -509,6 +563,7 @@ SetFileSystemInfo (
if (StrCmp (FileSystemInfo->VolumeLabel, VirtioFs->Label) == 0) {
return EFI_SUCCESS;
}
return EFI_WRITE_PROTECTED;
}
@@ -518,15 +573,15 @@ SetFileSystemInfo (
STATIC
EFI_STATUS
SetFileSystemVolumeLabelInfo (
IN EFI_FILE_PROTOCOL *This,
IN UINTN BufferSize,
IN VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN UINTN BufferSize,
IN VOID *Buffer
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
EFI_FILE_SYSTEM_VOLUME_LABEL *FileSystemVolumeLabel;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
EFI_FILE_SYSTEM_VOLUME_LABEL *FileSystemVolumeLabel;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -536,14 +591,17 @@ SetFileSystemVolumeLabelInfo (
//
Status = ValidateInfoStructure (
BufferSize, // SizeByProtocolCaller
OFFSET_OF (EFI_FILE_SYSTEM_VOLUME_LABEL,
VolumeLabel) + sizeof (CHAR16), // MinimumStructSize
OFFSET_OF (
EFI_FILE_SYSTEM_VOLUME_LABEL,
VolumeLabel
) + sizeof (CHAR16), // MinimumStructSize
FALSE, // IsSizeByInfoPresent
Buffer
);
if (EFI_ERROR (Status)) {
return Status;
}
FileSystemVolumeLabel = Buffer;
//
@@ -554,16 +612,17 @@ SetFileSystemVolumeLabelInfo (
if (StrCmp (FileSystemVolumeLabel->VolumeLabel, VirtioFs->Label) == 0) {
return EFI_SUCCESS;
}
return EFI_WRITE_PROTECTED;
}
EFI_STATUS
EFIAPI
VirtioFsSimpleFileSetInfo (
IN EFI_FILE_PROTOCOL *This,
IN EFI_GUID *InformationType,
IN UINTN BufferSize,
IN VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN EFI_GUID *InformationType,
IN UINTN BufferSize,
IN VOID *Buffer
)
{
if (CompareGuid (InformationType, &gEfiFileInfoGuid)) {

17
OvmfPkg/VirtioFsDxe/SimpleFsSetPosition.c
View File

@@ -14,14 +14,14 @@
EFI_STATUS
EFIAPI
VirtioFsSimpleFileSetPosition (
IN EFI_FILE_PROTOCOL *This,
IN UINT64 Position
IN EFI_FILE_PROTOCOL *This,
IN UINT64 Position
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE FuseAttr;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
@@ -32,11 +32,13 @@ VirtioFsSimpleFileSetPosition (
if (Position != 0) {
return EFI_UNSUPPORTED;
}
VirtioFsFile->FilePosition = 0;
if (VirtioFsFile->FileInfoArray != NULL) {
FreePool (VirtioFsFile->FileInfoArray);
VirtioFsFile->FileInfoArray = NULL;
}
VirtioFsFile->SingleFileInfoSize = 0;
VirtioFsFile->NumFileInfo = 0;
VirtioFsFile->NextFileInfo = 0;
@@ -58,10 +60,11 @@ VirtioFsSimpleFileSetPosition (
// Caller is requesting a seek to EOF.
//
VirtioFs = VirtioFsFile->OwnerFs;
Status = VirtioFsFuseGetAttr (VirtioFs, VirtioFsFile->NodeId, &FuseAttr);
Status = VirtioFsFuseGetAttr (VirtioFs, VirtioFsFile->NodeId, &FuseAttr);
if (EFI_ERROR (Status)) {
return Status;
}
VirtioFsFile->FilePosition = FuseAttr.Size;
return EFI_SUCCESS;
}

41
OvmfPkg/VirtioFsDxe/SimpleFsWrite.c
View File

@@ -11,16 +11,16 @@
EFI_STATUS
EFIAPI
VirtioFsSimpleFileWrite (
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
IN VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
IN VOID *Buffer
)
{
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
UINTN Transferred;
UINTN Left;
VIRTIO_FS_FILE *VirtioFsFile;
VIRTIO_FS *VirtioFs;
EFI_STATUS Status;
UINTN Transferred;
UINTN Left;
VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
VirtioFs = VirtioFsFile->OwnerFs;
@@ -28,6 +28,7 @@ VirtioFsSimpleFileWrite (
if (VirtioFsFile->IsDirectory) {
return EFI_UNSUPPORTED;
}
if (!VirtioFsFile->IsOpenForWriting) {
return EFI_ACCESS_DENIED;
}
@@ -36,34 +37,36 @@ VirtioFsSimpleFileWrite (
Transferred = 0;
Left = *BufferSize;
while (Left > 0) {
UINT32 WriteSize;
UINT32 WriteSize;
//
// Honor the write buffer size limit.
//
WriteSize = (UINT32)MIN ((UINTN)VirtioFs->MaxWrite, Left);
Status = VirtioFsFuseWrite (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
VirtioFsFile->FilePosition + Transferred,
&WriteSize,
(UINT8 *)Buffer + Transferred
);
if (!EFI_ERROR (Status) && WriteSize == 0) {
Status = VirtioFsFuseWrite (
VirtioFs,
VirtioFsFile->NodeId,
VirtioFsFile->FuseHandle,
VirtioFsFile->FilePosition + Transferred,
&WriteSize,
(UINT8 *)Buffer + Transferred
);
if (!EFI_ERROR (Status) && (WriteSize == 0)) {
//
// Progress should have been made.
//
Status = EFI_DEVICE_ERROR;
}
if (EFI_ERROR (Status)) {
break;
}
Transferred += WriteSize;
Left -= WriteSize;
}
*BufferSize = Transferred;
*BufferSize = Transferred;
VirtioFsFile->FilePosition += Transferred;
//
// According to the UEFI spec,

356
OvmfPkg/VirtioFsDxe/VirtioFsDxe.h
View File

@@ -18,7 +18,7 @@
#include <Protocol/VirtioDevice.h> // VIRTIO_DEVICE_PROTOCOL
#include <Uefi/UefiBaseType.h> // EFI_EVENT
#define VIRTIO_FS_SIG SIGNATURE_64 ('V', 'I', 'R', 'T', 'I', 'O', 'F', 'S')
#define VIRTIO_FS_SIG SIGNATURE_64 ('V', 'I', 'R', 'T', 'I', 'O', 'F', 'S')
#define VIRTIO_FS_FILE_SIG \
SIGNATURE_64 ('V', 'I', 'O', 'F', 'S', 'F', 'I', 'L')
@@ -45,12 +45,12 @@
// pathnames, separate limits could be used; a common limit is used purely for
// simplicity.
//
#define VIRTIO_FS_MAX_PATHNAME_LENGTH ((UINTN)65535)
#define VIRTIO_FS_MAX_PATHNAME_LENGTH ((UINTN)65535)
//
// Maximum value for VIRTIO_FS_FILE.NumFileInfo.
//
#define VIRTIO_FS_FILE_MAX_FILE_INFO 256
#define VIRTIO_FS_FILE_MAX_FILE_INFO 256
//
// Filesystem label encoded in UCS-2, transformed from the UTF-8 representation
@@ -71,17 +71,17 @@ typedef struct {
//
// field init function init depth
// ----------- ------------------ ----------
UINT64 Signature; // DriverBindingStart 0
VIRTIO_DEVICE_PROTOCOL *Virtio; // DriverBindingStart 0
VIRTIO_FS_LABEL Label; // VirtioFsInit 1
UINT16 QueueSize; // VirtioFsInit 1
VRING Ring; // VirtioRingInit 2
VOID *RingMap; // VirtioRingMap 2
UINT64 RequestId; // FuseInitSession 1
UINT32 MaxWrite; // FuseInitSession 1
EFI_EVENT ExitBoot; // DriverBindingStart 0
LIST_ENTRY OpenFiles; // DriverBindingStart 0
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL SimpleFs; // DriverBindingStart 0
UINT64 Signature; // DriverBindingStart 0
VIRTIO_DEVICE_PROTOCOL *Virtio; // DriverBindingStart 0
VIRTIO_FS_LABEL Label; // VirtioFsInit 1
UINT16 QueueSize; // VirtioFsInit 1
VRING Ring; // VirtioRingInit 2
VOID *RingMap; // VirtioRingMap 2
UINT64 RequestId; // FuseInitSession 1
UINT32 MaxWrite; // FuseInitSession 1
EFI_EVENT ExitBoot; // DriverBindingStart 0
LIST_ENTRY OpenFiles; // DriverBindingStart 0
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL SimpleFs; // DriverBindingStart 0
} VIRTIO_FS;
#define VIRTIO_FS_FROM_SIMPLE_FS(SimpleFsReference) \
@@ -95,8 +95,8 @@ typedef struct {
//
// The following fields originate from the owner of the buffer.
//
VOID *Buffer;
UINTN Size;
VOID *Buffer;
UINTN Size;
//
// All of the fields below, until the end of the structure, are
// zero-initialized when the structure is initially validated.
@@ -105,16 +105,16 @@ typedef struct {
// for VirtioOperationBusMasterRead or VirtioOperationBusMasterWrite. They
// are again updated when the buffer is unmapped.
//
BOOLEAN Mapped;
EFI_PHYSICAL_ADDRESS MappedAddress;
VOID *Mapping;
BOOLEAN Mapped;
EFI_PHYSICAL_ADDRESS MappedAddress;
VOID *Mapping;
//
// Transferred is updated after VirtioFlush() returns successfully:
// - for VirtioOperationBusMasterRead, Transferred is set to Size;
// - for VirtioOperationBusMasterWrite, Transferred is calculated from the
// UsedLen output parameter of VirtioFlush().
//
UINTN Transferred;
UINTN Transferred;
} VIRTIO_FS_IO_VECTOR;
//
@@ -124,13 +124,13 @@ typedef struct {
//
// The following fields originate from the owner of the buffers.
//
VIRTIO_FS_IO_VECTOR *IoVec;
UINTN NumVec;
VIRTIO_FS_IO_VECTOR *IoVec;
UINTN NumVec;
//
// TotalSize is calculated when the scatter-gather list is initially
// validated.
//
UINT32 TotalSize;
UINT32 TotalSize;
} VIRTIO_FS_SCATTER_GATHER_LIST;
//
@@ -138,14 +138,14 @@ typedef struct {
// FUSE file reference.
//
typedef struct {
UINT64 Signature;
EFI_FILE_PROTOCOL SimpleFile;
BOOLEAN IsDirectory;
BOOLEAN IsOpenForWriting;
VIRTIO_FS *OwnerFs;
LIST_ENTRY OpenFilesEntry;
CHAR8 *CanonicalPathname;
UINT64 FilePosition;
UINT64 Signature;
EFI_FILE_PROTOCOL SimpleFile;
BOOLEAN IsDirectory;
BOOLEAN IsOpenForWriting;
VIRTIO_FS *OwnerFs;
LIST_ENTRY OpenFilesEntry;
CHAR8 *CanonicalPathname;
UINT64 FilePosition;
//
// In the FUSE wire protocol, every request except FUSE_INIT refers to a
// file, namely by the "VIRTIO_FS_FUSE_REQUEST.NodeId" field; that is, by the
@@ -158,8 +158,8 @@ typedef struct {
// function must send a FUSE request that needs the file handle *in addition*
// to the inode number, FuseHandle will be at our disposal at once.
//
UINT64 NodeId;
UINT64 FuseHandle;
UINT64 NodeId;
UINT64 FuseHandle;
//
// EFI_FILE_INFO objects cached for an in-flight directory read.
//
@@ -170,10 +170,10 @@ typedef struct {
// EFI_FILE_INFOs immediately. EFI_FILE_PROTOCOL.Read() invocations (on
// directories) will be served from this EFI_FILE_INFO cache.
//
UINT8 *FileInfoArray;
UINTN SingleFileInfoSize;
UINTN NumFileInfo;
UINTN NextFileInfo;
UINT8 *FileInfoArray;
UINTN SingleFileInfoSize;
UINTN NumFileInfo;
UINTN NextFileInfo;
} VIRTIO_FS_FILE;
#define VIRTIO_FS_FILE_FROM_SIMPLE_FILE(SimpleFileReference) \
@@ -189,39 +189,39 @@ typedef struct {
EFI_STATUS
VirtioFsInit (
IN OUT VIRTIO_FS *VirtioFs
IN OUT VIRTIO_FS *VirtioFs
);
VOID
VirtioFsUninit (
IN OUT VIRTIO_FS *VirtioFs
IN OUT VIRTIO_FS *VirtioFs
);
VOID
EFIAPI
VirtioFsExitBoot (
IN EFI_EVENT ExitBootEvent,
IN VOID *VirtioFsAsVoid
IN EFI_EVENT ExitBootEvent,
IN VOID *VirtioFsAsVoid
);
EFI_STATUS
VirtioFsSgListsValidate (
IN VIRTIO_FS *VirtioFs,
IN OUT VIRTIO_FS_SCATTER_GATHER_LIST *RequestSgList,
IN OUT VIRTIO_FS_SCATTER_GATHER_LIST *ResponseSgList OPTIONAL
IN VIRTIO_FS *VirtioFs,
IN OUT VIRTIO_FS_SCATTER_GATHER_LIST *RequestSgList,
IN OUT VIRTIO_FS_SCATTER_GATHER_LIST *ResponseSgList OPTIONAL
);
EFI_STATUS
VirtioFsSgListsSubmit (
IN OUT VIRTIO_FS *VirtioFs,
IN OUT VIRTIO_FS_SCATTER_GATHER_LIST *RequestSgList,
IN OUT VIRTIO_FS_SCATTER_GATHER_LIST *ResponseSgList OPTIONAL
IN OUT VIRTIO_FS *VirtioFs,
IN OUT VIRTIO_FS_SCATTER_GATHER_LIST *RequestSgList,
IN OUT VIRTIO_FS_SCATTER_GATHER_LIST *ResponseSgList OPTIONAL
);
EFI_STATUS
VirtioFsFuseNewRequest (
IN OUT VIRTIO_FS *VirtioFs,
OUT VIRTIO_FS_FUSE_REQUEST *Request,
OUT VIRTIO_FS_FUSE_REQUEST *Request,
IN UINT32 RequestSize,
IN VIRTIO_FS_FUSE_OPCODE Opcode,
IN UINT64 NodeId
@@ -229,36 +229,36 @@ VirtioFsFuseNewRequest (
EFI_STATUS
VirtioFsFuseCheckResponse (
IN VIRTIO_FS_SCATTER_GATHER_LIST *ResponseSgList,
IN UINT64 RequestId,
OUT UINTN *TailBufferFill
IN VIRTIO_FS_SCATTER_GATHER_LIST *ResponseSgList,
IN UINT64 RequestId,
OUT UINTN *TailBufferFill
);
EFI_STATUS
VirtioFsErrnoToEfiStatus (
IN INT32 Errno
IN INT32 Errno
);
EFI_STATUS
VirtioFsAppendPath (
IN CHAR8 *LhsPath8,
IN CHAR16 *RhsPath16,
OUT CHAR8 **ResultPath8,
OUT BOOLEAN *RootEscape
OUT CHAR8 **ResultPath8,
OUT BOOLEAN *RootEscape
);
EFI_STATUS
VirtioFsLookupMostSpecificParentDir (
IN OUT VIRTIO_FS *VirtioFs,
IN OUT CHAR8 *Path,
OUT UINT64 *DirNodeId,
OUT CHAR8 **LastComponent
IN OUT VIRTIO_FS *VirtioFs,
IN OUT CHAR8 *Path,
OUT UINT64 *DirNodeId,
OUT CHAR8 **LastComponent
);
EFI_STATUS
VirtioFsGetBasename (
IN CHAR8 *Path,
OUT CHAR16 *Basename OPTIONAL,
OUT CHAR16 *Basename OPTIONAL,
IN OUT UINTN *BasenameSize
);
@@ -266,47 +266,47 @@ EFI_STATUS
VirtioFsComposeRenameDestination (
IN CHAR8 *LhsPath8,
IN CHAR16 *RhsPath16,
OUT CHAR8 **ResultPath8,
OUT BOOLEAN *RootEscape
OUT CHAR8 **ResultPath8,
OUT BOOLEAN *RootEscape
);
EFI_STATUS
VirtioFsFuseAttrToEfiFileInfo (
IN VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr,
OUT EFI_FILE_INFO *FileInfo
IN VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr,
OUT EFI_FILE_INFO *FileInfo
);
EFI_STATUS
VirtioFsFuseDirentPlusToEfiFileInfo (
IN VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE *FuseDirent,
IN OUT EFI_FILE_INFO *FileInfo
IN VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE *FuseDirent,
IN OUT EFI_FILE_INFO *FileInfo
);
VOID
VirtioFsGetFuseSizeUpdate (
IN EFI_FILE_INFO *Info,
IN EFI_FILE_INFO *NewInfo,
OUT BOOLEAN *Update,
OUT UINT64 *Size
IN EFI_FILE_INFO *Info,
IN EFI_FILE_INFO *NewInfo,
OUT BOOLEAN *Update,
OUT UINT64 *Size
);
EFI_STATUS
VirtioFsGetFuseTimeUpdates (
IN EFI_FILE_INFO *Info,
IN EFI_FILE_INFO *NewInfo,
OUT BOOLEAN *UpdateAtime,
OUT BOOLEAN *UpdateMtime,
OUT UINT64 *Atime,
OUT UINT64 *Mtime
IN EFI_FILE_INFO *Info,
IN EFI_FILE_INFO *NewInfo,
OUT BOOLEAN *UpdateAtime,
OUT BOOLEAN *UpdateMtime,
OUT UINT64 *Atime,
OUT UINT64 *Mtime
);
EFI_STATUS
VirtioFsGetFuseModeUpdate (
IN EFI_FILE_INFO *Info,
IN EFI_FILE_INFO *NewInfo,
OUT BOOLEAN *Update,
OUT UINT32 *Mode
);
IN EFI_FILE_INFO *Info,
IN EFI_FILE_INFO *NewInfo,
OUT BOOLEAN *Update,
OUT UINT32 *Mode
);
//
// Wrapper functions for FUSE commands (primitives).
@@ -314,139 +314,139 @@ VirtioFsGetFuseModeUpdate (
EFI_STATUS
VirtioFsFuseLookup (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 DirNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr
);
EFI_STATUS
VirtioFsFuseForget (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId
);
EFI_STATUS
VirtioFsFuseGetAttr (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE *FuseAttr
);
EFI_STATUS
VirtioFsFuseSetAttr (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 *Size OPTIONAL,
IN UINT64 *Atime OPTIONAL,
IN UINT64 *Mtime OPTIONAL,
IN UINT32 *Mode OPTIONAL
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 *Size OPTIONAL,
IN UINT64 *Atime OPTIONAL,
IN UINT64 *Mtime OPTIONAL,
IN UINT32 *Mode OPTIONAL
);
EFI_STATUS
VirtioFsFuseMkDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId
);
EFI_STATUS
VirtioFsFuseRemoveFileOrDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
IN BOOLEAN IsDir
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
IN BOOLEAN IsDir
);
EFI_STATUS
VirtioFsFuseOpen (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN BOOLEAN ReadWrite,
OUT UINT64 *FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN BOOLEAN ReadWrite,
OUT UINT64 *FuseHandle
);
EFI_STATUS
VirtioFsFuseReadFileOrDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir,
IN UINT64 Offset,
IN OUT UINT32 *Size,
OUT VOID *Data
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir,
IN UINT64 Offset,
IN OUT UINT32 *Size,
OUT VOID *Data
);
EFI_STATUS
VirtioFsFuseWrite (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN UINT64 Offset,
IN OUT UINT32 *Size,
IN VOID *Data
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN UINT64 Offset,
IN OUT UINT32 *Size,
IN VOID *Data
);
EFI_STATUS
VirtioFsFuseStatFs (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT VIRTIO_FS_FUSE_STATFS_RESPONSE *FilesysAttr
);
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT VIRTIO_FS_FUSE_STATFS_RESPONSE *FilesysAttr
);
EFI_STATUS
VirtioFsFuseReleaseFileOrDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir
);
EFI_STATUS
VirtioFsFuseFsyncFileOrDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle,
IN BOOLEAN IsDir
);
EFI_STATUS
VirtioFsFuseFlush (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
IN UINT64 FuseHandle
);
EFI_STATUS
VirtioFsFuseInitSession (
IN OUT VIRTIO_FS *VirtioFs
IN OUT VIRTIO_FS *VirtioFs
);
EFI_STATUS
VirtioFsFuseOpenDir (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT UINT64 *FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 NodeId,
OUT UINT64 *FuseHandle
);
EFI_STATUS
VirtioFsFuseOpenOrCreate (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 ParentNodeId,
IN CHAR8 *Name,
OUT UINT64 *NodeId,
OUT UINT64 *FuseHandle
);
EFI_STATUS
VirtioFsFuseRename (
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 OldParentNodeId,
IN CHAR8 *OldName,
IN UINT64 NewParentNodeId,
IN CHAR8 *NewName
IN OUT VIRTIO_FS *VirtioFs,
IN UINT64 OldParentNodeId,
IN CHAR8 *OldName,
IN UINT64 NewParentNodeId,
IN CHAR8 *NewName
);
//
@@ -457,8 +457,8 @@ VirtioFsFuseRename (
EFI_STATUS
EFIAPI
VirtioFsOpenVolume (
IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
OUT EFI_FILE_PROTOCOL **Root
IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
OUT EFI_FILE_PROTOCOL **Root
);
//
@@ -468,77 +468,77 @@ VirtioFsOpenVolume (
EFI_STATUS
EFIAPI
VirtioFsSimpleFileClose (
IN EFI_FILE_PROTOCOL *This
IN EFI_FILE_PROTOCOL *This
);
EFI_STATUS
EFIAPI
VirtioFsSimpleFileDelete (
IN EFI_FILE_PROTOCOL *This
IN EFI_FILE_PROTOCOL *This
);
EFI_STATUS
EFIAPI
VirtioFsSimpleFileFlush (
IN EFI_FILE_PROTOCOL *This
IN EFI_FILE_PROTOCOL *This
);
EFI_STATUS
EFIAPI
VirtioFsSimpleFileGetInfo (
IN EFI_FILE_PROTOCOL *This,
IN EFI_GUID *InformationType,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN EFI_GUID *InformationType,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
);
EFI_STATUS
EFIAPI
VirtioFsSimpleFileGetPosition (
IN EFI_FILE_PROTOCOL *This,
OUT UINT64 *Position
IN EFI_FILE_PROTOCOL *This,
OUT UINT64 *Position
);
EFI_STATUS
EFIAPI
VirtioFsSimpleFileOpen (
IN EFI_FILE_PROTOCOL *This,
OUT EFI_FILE_PROTOCOL **NewHandle,
IN CHAR16 *FileName,
IN UINT64 OpenMode,
IN UINT64 Attributes
IN EFI_FILE_PROTOCOL *This,
OUT EFI_FILE_PROTOCOL **NewHandle,
IN CHAR16 *FileName,
IN UINT64 OpenMode,
IN UINT64 Attributes
);
EFI_STATUS
EFIAPI
VirtioFsSimpleFileRead (
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
OUT VOID *Buffer
);
EFI_STATUS
EFIAPI
VirtioFsSimpleFileSetInfo (
IN EFI_FILE_PROTOCOL *This,
IN EFI_GUID *InformationType,
IN UINTN BufferSize,
IN VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN EFI_GUID *InformationType,
IN UINTN BufferSize,
IN VOID *Buffer
);
EFI_STATUS
EFIAPI
VirtioFsSimpleFileSetPosition (
IN EFI_FILE_PROTOCOL *This,
IN UINT64 Position
IN EFI_FILE_PROTOCOL *This,
IN UINT64 Position
);
EFI_STATUS
EFIAPI
VirtioFsSimpleFileWrite (
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
IN VOID *Buffer
IN EFI_FILE_PROTOCOL *This,
IN OUT UINTN *BufferSize,
IN VOID *Buffer
);
#endif // VIRTIO_FS_DXE_H_