From d98d7e3005cb5222af490355ec87758db318d7a3 Mon Sep 17 00:00:00 2001 From: Laszlo Ersek Date: Wed, 16 Dec 2020 22:11:09 +0100 Subject: [PATCH] OvmfPkg/VirtioFsDxe: add a shared wrapper for FUSE_READ / FUSE_READDIRPLUS MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add the VirtioFsFuseReadFileOrDir() function, for sending the FUSE_READ or FUSE_READDIRPLUS command to the Virtio Filesystem device. Parsing the structured FUSE_READDIRPLUS output is complex, and cannot be integrated into the wrapper function. Given that fact, FUSE_READ and FUSE_READDIRPLUS turn out to need identical low-level handling, except for the opcode. Hence the shared wrapper function. (It's prudent to verify whether the FUSE server supports FUSE_READDIRPLUS, so update the session init code accordingly.) This is the first FUSE request wrapper function that deals with a variable size tail buffer. Cc: Ard Biesheuvel Cc: Jordan Justen Cc: Philippe Mathieu-Daudé Ref: https://bugzilla.tianocore.org/show_bug.cgi?id=3097 Signed-off-by: Laszlo Ersek Message-Id: <20201216211125.19496-33-lersek@redhat.com> Acked-by: Ard Biesheuvel --- OvmfPkg/Include/IndustryStandard/VirtioFs.h | 67 +++++++ OvmfPkg/VirtioFsDxe/FuseInit.c | 10 +- OvmfPkg/VirtioFsDxe/FuseRead.c | 191 ++++++++++++++++++++ OvmfPkg/VirtioFsDxe/VirtioFsDxe.h | 11 ++ OvmfPkg/VirtioFsDxe/VirtioFsDxe.inf | 1 + 5 files changed, 276 insertions(+), 4 deletions(-) create mode 100644 OvmfPkg/VirtioFsDxe/FuseRead.c diff --git a/OvmfPkg/Include/IndustryStandard/VirtioFs.h b/OvmfPkg/Include/IndustryStandard/VirtioFs.h index 800d3651e1..fa8c40019f 100644 --- a/OvmfPkg/Include/IndustryStandard/VirtioFs.h +++ b/OvmfPkg/Include/IndustryStandard/VirtioFs.h @@ -108,6 +108,39 @@ typedef struct { #define VIRTIO_FS_FUSE_OPEN_REQ_F_RDONLY 0 #define VIRTIO_FS_FUSE_OPEN_REQ_F_RDWR 2 +// +// Flags for VirtioFsFuseOpInit. +// +#define VIRTIO_FS_FUSE_INIT_REQ_F_DO_READDIRPLUS BIT13 + +/** + Macro for calculating the size of a directory stream entry. + + The macro may evaluate Namelen multiple times. + + The macro evaluates to a UINTN value that is safe to cast to UINT32. + + @param[in] Namelen The size of the filename byte array that follows + VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE in the directory + stream, as reported by + VIRTIO_FS_FUSE_STATFS_RESPONSE.Namelen or + VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE.Namelen. The filename + byte array is not NUL-terminated. + + @retval 0 Namelen was zero or greater than SIZE_4KB. + + @return The number of bytes in the directory entry, including the + VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE header. +**/ +#define VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE_SIZE(Namelen) \ + ((Namelen) == 0 || (Namelen) > SIZE_4KB ? \ + (UINTN)0 : \ + ALIGN_VALUE ( \ + sizeof (VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE) + (UINTN)(Namelen), \ + sizeof (UINT64) \ + ) \ + ) + // // FUSE operation codes. // @@ -119,6 +152,7 @@ typedef enum { VirtioFsFuseOpUnlink = 10, VirtioFsFuseOpRmDir = 11, VirtioFsFuseOpOpen = 14, + VirtioFsFuseOpRead = 15, VirtioFsFuseOpStatFs = 17, VirtioFsFuseOpRelease = 18, VirtioFsFuseOpFsync = 20, @@ -128,6 +162,7 @@ typedef enum { VirtioFsFuseOpReleaseDir = 29, VirtioFsFuseOpFsyncDir = 30, VirtioFsFuseOpCreate = 35, + VirtioFsFuseOpReadDirPlus = 44, } VIRTIO_FS_FUSE_OPCODE; #pragma pack (1) @@ -234,6 +269,19 @@ typedef struct { UINT32 Padding; } VIRTIO_FS_FUSE_OPEN_RESPONSE; +// +// Header for VirtioFsFuseOpRead and VirtioFsFuseOpReadDirPlus. +// +typedef struct { + UINT64 FileHandle; + UINT64 Offset; + UINT32 Size; + UINT32 ReadFlags; + UINT64 LockOwner; + UINT32 Flags; + UINT32 Padding; +} VIRTIO_FS_FUSE_READ_REQUEST; + // // Header for VirtioFsFuseOpStatFs. // @@ -312,6 +360,25 @@ typedef struct { UINT32 Umask; UINT32 Padding; } VIRTIO_FS_FUSE_CREATE_REQUEST; + +// +// Header for VirtioFsFuseOpReadDirPlus. +// +// Diverging from the rest of the headers, this structure embeds other +// structures. The reason is that a scatter list cannot be used to receive +// NodeResp and AttrResp separately; the record below is followed by a variable +// size filename byte array, and then such pairs are repeated a number of +// times. Thus, later header start offsets depend on earlier filename array +// sizes. +// +typedef struct { + VIRTIO_FS_FUSE_NODE_RESPONSE NodeResp; + VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE AttrResp; + UINT64 NodeId; + UINT64 CookieForNextEntry; + UINT32 Namelen; + UINT32 Type; +} VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE; #pragma pack () #endif // VIRTIO_FS_H_ diff --git a/OvmfPkg/VirtioFsDxe/FuseInit.c b/OvmfPkg/VirtioFsDxe/FuseInit.c index aa19dbdc05..7aa6ee75ca 100644 --- a/OvmfPkg/VirtioFsDxe/FuseInit.c +++ b/OvmfPkg/VirtioFsDxe/FuseInit.c @@ -26,7 +26,8 @@ @retval EFI_SUCCESS The FUSE session has been started. - @retval EFI_UNSUPPORTED FUSE interface version negotiation failed. + @retval EFI_UNSUPPORTED FUSE interface version or feature negotiation + failed. @return The "errno" value mapped to an EFI_STATUS code, if the Virtio Filesystem device explicitly reported an @@ -97,7 +98,7 @@ VirtioFsFuseInitSession ( InitReq.Major = VIRTIO_FS_FUSE_MAJOR; InitReq.Minor = VIRTIO_FS_FUSE_MINOR; InitReq.MaxReadahead = 0; - InitReq.Flags = 0; + InitReq.Flags = VIRTIO_FS_FUSE_INIT_REQ_F_DO_READDIRPLUS; // // Submit the request. @@ -121,10 +122,11 @@ VirtioFsFuseInitSession ( } // - // Check FUSE interface version compatibility. + // Check FUSE interface version / feature compatibility. // if (InitResp.Major < InitReq.Major || - (InitResp.Major == InitReq.Major && InitResp.Minor < InitReq.Minor)) { + (InitResp.Major == InitReq.Major && InitResp.Minor < InitReq.Minor) || + (InitResp.Flags & VIRTIO_FS_FUSE_INIT_REQ_F_DO_READDIRPLUS) == 0) { return EFI_UNSUPPORTED; } diff --git a/OvmfPkg/VirtioFsDxe/FuseRead.c b/OvmfPkg/VirtioFsDxe/FuseRead.c new file mode 100644 index 0000000000..1611e298b9 --- /dev/null +++ b/OvmfPkg/VirtioFsDxe/FuseRead.c @@ -0,0 +1,191 @@ +/** @file + FUSE_READ / FUSE_READDIRPLUS wrapper for the Virtio Filesystem device. + + Copyright (C) 2020, Red Hat, Inc. + + SPDX-License-Identifier: BSD-2-Clause-Patent +**/ + +#include "VirtioFsDxe.h" + +/** + Read a chunk from a regular file or a directory stream, by sending the + FUSE_READ / FUSE_READDIRPLUS request to the Virtio Filesystem device. + + The function may only be called after VirtioFsFuseInitSession() returns + successfully and before VirtioFsUninit() is called. + + @param[in,out] VirtioFs The Virtio Filesystem device to send the FUSE_READ + or FUSE_READDIRPLUS request to. On output, the FUSE + request counter "VirtioFs->RequestId" will have been + incremented. + + @param[in] NodeId The inode number of the regular file or directory + stream to read from. + + @param[in] FuseHandle The open handle to the regular file or directory + stream to read from. + + @param[in] IsDir TRUE if NodeId and FuseHandle refer to a directory, + FALSE if NodeId and FuseHandle refer to a regular + file. + + @param[in] Offset If IsDir is FALSE: the absolute file position at + which to start reading. + + If IsDir is TRUE: the directory stream cookie at + which to start or continue reading. The zero-valued + cookie identifies the start of the directory stream. + Further positions in the directory stream can be + passed in from the CookieForNextEntry field of + VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE. + + @param[in,out] Size On input, the number of bytes to read. On successful + return, the number of bytes actually read, which may + be smaller than the value on input. + + When reading a regular file (i.e., when IsDir is + FALSE), EOF can be detected by passing in a nonzero + Size, and finding a zero Size on output. + + When reading a directory stream (i.e., when IsDir is + TRUE), Data consists of a sequence of variably-sized + records (directory entries). A read operation + returns the maximal sequence of records that fits in + Size, without having to truncate a record. In order + to guarantee progress, call + + VirtioFsFuseStatFs (VirtioFs, NodeId, + &FilesysAttr) + + first, to learn the maximum Namelen for the + directory stream. Then assign Size at least + + VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE_SIZE ( + FilesysAttr.Namelen) + + on input. (Remember that + VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE_SIZE() may return + 0 if its Namelen argument is invalid.) EOF can be + detected if Size is set on input like described + above, and Size is zero on output. + + @param[out] Data Buffer to read the bytes from the regular file or + the directory stream into. The caller is responsible + for providing room for (at least) as many bytes in + Data as Size is on input. + + @retval EFI_SUCCESS Read successful. The caller is responsible for checking + Size to learn the actual byte count transferred. + + @return The "errno" value mapped to an EFI_STATUS code, if the + Virtio Filesystem device explicitly reported an error. + + @return Error codes propagated from VirtioFsSgListsValidate(), + VirtioFsFuseNewRequest(), VirtioFsSgListsSubmit(), + VirtioFsFuseCheckResponse(). +**/ +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 + ) +{ + 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. + // + ReqIoVec[0].Buffer = &CommonReq; + ReqIoVec[0].Size = sizeof CommonReq; + ReqIoVec[1].Buffer = &ReadReq; + ReqIoVec[1].Size = sizeof ReadReq; + ReqSgList.IoVec = ReqIoVec; + ReqSgList.NumVec = ARRAY_SIZE (ReqIoVec); + + RespIoVec[0].Buffer = &CommonResp; + RespIoVec[0].Size = sizeof CommonResp; + RespIoVec[1].Buffer = Data; + RespIoVec[1].Size = *Size; + RespSgList.IoVec = RespIoVec; + RespSgList.NumVec = ARRAY_SIZE (RespIoVec); + + // + // Validate the scatter-gather lists; calculate the total transfer sizes. + // + Status = VirtioFsSgListsValidate (VirtioFs, &ReqSgList, &RespSgList); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Populate the common request header. + // + Status = VirtioFsFuseNewRequest ( + VirtioFs, + &CommonReq, + ReqSgList.TotalSize, + IsDir ? VirtioFsFuseOpReadDirPlus : VirtioFsFuseOpRead, + NodeId + ); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Populate the FUSE_READ- / FUSE_READDIRPLUS-specific fields. + // + ReadReq.FileHandle = FuseHandle; + ReadReq.Offset = Offset; + ReadReq.Size = *Size; + ReadReq.ReadFlags = 0; + ReadReq.LockOwner = 0; + ReadReq.Flags = 0; + ReadReq.Padding = 0; + + // + // Submit the request. + // + Status = VirtioFsSgListsSubmit (VirtioFs, &ReqSgList, &RespSgList); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Verify the response. Note that TailBufferFill is variable. + // + 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)); + Status = VirtioFsErrnoToEfiStatus (CommonResp.Error); + } + return Status; + } + + // + // Report the actual transfer size. + // + // Integer overflow in the (UINT32) cast below is not possible; the + // VIRTIO_FS_SCATTER_GATHER_LIST functions would have caught that. + // + *Size = (UINT32)TailBufferFill; + return EFI_SUCCESS; +} diff --git a/OvmfPkg/VirtioFsDxe/VirtioFsDxe.h b/OvmfPkg/VirtioFsDxe/VirtioFsDxe.h index 948fcfb6b6..f5501af7d0 100644 --- a/OvmfPkg/VirtioFsDxe/VirtioFsDxe.h +++ b/OvmfPkg/VirtioFsDxe/VirtioFsDxe.h @@ -298,6 +298,17 @@ VirtioFsFuseOpen ( 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 + ); + EFI_STATUS VirtioFsFuseStatFs ( IN OUT VIRTIO_FS *VirtioFs, diff --git a/OvmfPkg/VirtioFsDxe/VirtioFsDxe.inf b/OvmfPkg/VirtioFsDxe/VirtioFsDxe.inf index 3cb5c101c3..39c77c7c4e 100644 --- a/OvmfPkg/VirtioFsDxe/VirtioFsDxe.inf +++ b/OvmfPkg/VirtioFsDxe/VirtioFsDxe.inf @@ -93,6 +93,7 @@ FuseOpen.c FuseOpenDir.c FuseOpenOrCreate.c + FuseRead.c FuseRelease.c FuseStatFs.c FuseUnlink.c