UefiPayloadPkg: Fix build error

[mirror_edk2.git] / OvmfPkg / VirtioFsDxe / FuseRead.c

/** @file\r
  FUSE_READ / FUSE_READDIRPLUS wrapper for the Virtio Filesystem device.\r
\r
  Copyright (C) 2020, Red Hat, Inc.\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
**/\r
\r
#include "VirtioFsDxe.h"\r
\r
/**\r
  Read a chunk from a regular file or a directory stream, by sending the\r
  FUSE_READ / FUSE_READDIRPLUS request to the Virtio Filesystem device.\r
\r
  The function may only be called after VirtioFsFuseInitSession() returns\r
  successfully and before VirtioFsUninit() is called.\r
\r
  @param[in,out] VirtioFs  The Virtio Filesystem device to send the FUSE_READ\r
                           or FUSE_READDIRPLUS request to. On output, the FUSE\r
                           request counter "VirtioFs->RequestId" will have been\r
                           incremented.\r
\r
  @param[in] NodeId        The inode number of the regular file or directory\r
                           stream to read from.\r
\r
  @param[in] FuseHandle    The open handle to the regular file or directory\r
                           stream to read from.\r
\r
  @param[in] IsDir         TRUE if NodeId and FuseHandle refer to a directory,\r
                           FALSE if NodeId and FuseHandle refer to a regular\r
                           file.\r
\r
  @param[in] Offset        If IsDir is FALSE: the absolute file position at\r
                           which to start reading.\r
\r
                           If IsDir is TRUE: the directory stream cookie at\r
                           which to start or continue reading. The zero-valued\r
                           cookie identifies the start of the directory stream.\r
                           Further positions in the directory stream can be\r
                           passed in from the CookieForNextEntry field of\r
                           VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE.\r
\r
  @param[in,out] Size      On input, the number of bytes to read. On successful\r
                           return, the number of bytes actually read, which may\r
                           be smaller than the value on input.\r
\r
                           When reading a regular file (i.e., when IsDir is\r
                           FALSE), EOF can be detected by passing in a nonzero\r
                           Size, and finding a zero Size on output.\r
\r
                           When reading a directory stream (i.e., when IsDir is\r
                           TRUE), Data consists of a sequence of variably-sized\r
                           records (directory entries). A read operation\r
                           returns the maximal sequence of records that fits in\r
                           Size, without having to truncate a record. In order\r
                           to guarantee progress, call\r
\r
                             VirtioFsFuseStatFs (VirtioFs, NodeId,\r
                               &FilesysAttr)\r
\r
                           first, to learn the maximum Namelen for the\r
                           directory stream. Then assign Size at least\r
\r
                             VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE_SIZE (\r
                               FilesysAttr.Namelen)\r
\r
                           on input. (Remember that\r
                           VIRTIO_FS_FUSE_DIRENTPLUS_RESPONSE_SIZE() may return\r
                           0 if its Namelen argument is invalid.) EOF can be\r
                           detected if Size is set on input like described\r
                           above, and Size is zero on output.\r
\r
  @param[out] Data         Buffer to read the bytes from the regular file or\r
                           the directory stream into. The caller is responsible\r
                           for providing room for (at least) as many bytes in\r
                           Data as Size is on input.\r
\r
  @retval EFI_SUCCESS  Read successful. The caller is responsible for checking\r
                       Size to learn the actual byte count transferred.\r
\r
  @return              The "errno" value mapped to an EFI_STATUS code, if the\r
                       Virtio Filesystem device explicitly reported an error.\r
\r
  @return              Error codes propagated from VirtioFsSgListsValidate(),\r
                       VirtioFsFuseNewRequest(), VirtioFsSgListsSubmit(),\r
                       VirtioFsFuseCheckResponse().\r
**/\r
EFI_STATUS\r
VirtioFsFuseReadFileOrDir (\r
  IN OUT VIRTIO_FS  *VirtioFs,\r
  IN     UINT64     NodeId,\r
  IN     UINT64     FuseHandle,\r
  IN     BOOLEAN    IsDir,\r
  IN     UINT64     Offset,\r
  IN OUT UINT32     *Size,\r
  OUT VOID          *Data\r
  )\r
{\r
  VIRTIO_FS_FUSE_REQUEST         CommonReq;\r
  VIRTIO_FS_FUSE_READ_REQUEST    ReadReq;\r
  VIRTIO_FS_IO_VECTOR            ReqIoVec[2];\r
  VIRTIO_FS_SCATTER_GATHER_LIST  ReqSgList;\r
  VIRTIO_FS_FUSE_RESPONSE        CommonResp;\r
  VIRTIO_FS_IO_VECTOR            RespIoVec[2];\r
  VIRTIO_FS_SCATTER_GATHER_LIST  RespSgList;\r
  EFI_STATUS                     Status;\r
  UINTN                          TailBufferFill;\r
\r
  //\r
  // Set up the scatter-gather lists.\r
  //\r
  ReqIoVec[0].Buffer = &CommonReq;\r
  ReqIoVec[0].Size   = sizeof CommonReq;\r
  ReqIoVec[1].Buffer = &ReadReq;\r
  ReqIoVec[1].Size   = sizeof ReadReq;\r
  ReqSgList.IoVec    = ReqIoVec;\r
  ReqSgList.NumVec   = ARRAY_SIZE (ReqIoVec);\r
\r
  RespIoVec[0].Buffer = &CommonResp;\r
  RespIoVec[0].Size   = sizeof CommonResp;\r
  RespIoVec[1].Buffer = Data;\r
  RespIoVec[1].Size   = *Size;\r
  RespSgList.IoVec    = RespIoVec;\r
  RespSgList.NumVec   = ARRAY_SIZE (RespIoVec);\r
\r
  //\r
  // Validate the scatter-gather lists; calculate the total transfer sizes.\r
  //\r
  Status = VirtioFsSgListsValidate (VirtioFs, &ReqSgList, &RespSgList);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Populate the common request header.\r
  //\r
  Status = VirtioFsFuseNewRequest (\r
             VirtioFs,\r
             &CommonReq,\r
             ReqSgList.TotalSize,\r
             IsDir ? VirtioFsFuseOpReadDirPlus : VirtioFsFuseOpRead,\r
             NodeId\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Populate the FUSE_READ- / FUSE_READDIRPLUS-specific fields.\r
  //\r
  ReadReq.FileHandle = FuseHandle;\r
  ReadReq.Offset     = Offset;\r
  ReadReq.Size       = *Size;\r
  ReadReq.ReadFlags  = 0;\r
  ReadReq.LockOwner  = 0;\r
  ReadReq.Flags      = 0;\r
  ReadReq.Padding    = 0;\r
\r
  //\r
  // Submit the request.\r
  //\r
  Status = VirtioFsSgListsSubmit (VirtioFs, &ReqSgList, &RespSgList);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Verify the response. Note that TailBufferFill is variable.\r
  //\r
  Status = VirtioFsFuseCheckResponse (\r
             &RespSgList,\r
             CommonReq.Unique,\r
             &TailBufferFill\r
             );\r
  if (EFI_ERROR (Status)) {\r
    if (Status == EFI_DEVICE_ERROR) {\r
      DEBUG ((\r
        DEBUG_ERROR,\r
        "%a: Label=\"%s\" NodeId=%Lu FuseHandle=%Lu "\r
        "IsDir=%d Offset=0x%Lx Size=0x%x Data@%p Errno=%d\n",\r
        __FUNCTION__,\r
        VirtioFs->Label,\r
        NodeId,\r
        FuseHandle,\r
        IsDir,\r
        Offset,\r
        *Size,\r
        Data,\r
        CommonResp.Error\r
        ));\r
      Status = VirtioFsErrnoToEfiStatus (CommonResp.Error);\r
    }\r
\r
    return Status;\r
  }\r
\r
  //\r
  // Report the actual transfer size.\r
  //\r
  // Integer overflow in the (UINT32) cast below is not possible; the\r
  // VIRTIO_FS_SCATTER_GATHER_LIST functions would have caught that.\r
  //\r
  *Size = (UINT32)TailBufferFill;\r
  return EFI_SUCCESS;\r
}\r