OvmfPkg: Apply uncrustify changes

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

/** @file\r
  EFI_FILE_PROTOCOL.Open() member function for the Virtio Filesystem driver.\r
\r
  Copyright (C) 2020, Red Hat, Inc.\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
**/\r
\r
#include <Library/BaseLib.h>             // AsciiStrCmp()\r
#include <Library/MemoryAllocationLib.h> // AllocatePool()\r
\r
#include "VirtioFsDxe.h"\r
\r
/**\r
  Open the root directory, possibly for writing.\r
\r
  @param[in,out] VirtioFs    The Virtio Filesystem device whose root directory\r
                             should be opened.\r
\r
  @param[out] NewHandle      The new EFI_FILE_PROTOCOL instance through which\r
                             the root directory can be accessed.\r
\r
  @param[in] OpenForWriting  TRUE if the root directory should be opened for\r
                             read-write access. FALSE if the root directory\r
                             should be opened for read-only access. Opening the\r
                             root directory for read-write access is useful for\r
                             calling EFI_FILE_PROTOCOL.Flush() or\r
                             EFI_FILE_PROTOCOL.SetInfo() later, for syncing or\r
                             touching the root directory, respectively.\r
\r
  @retval EFI_SUCCESS        The root directory has been opened successfully.\r
\r
  @retval EFI_ACCESS_DENIED  OpenForWriting is TRUE, but the root directory is\r
                             marked as read-only.\r
\r
  @return                    Error codes propagated from underlying functions.\r
**/\r
STATIC\r
EFI_STATUS\r
OpenRootDirectory (\r
  IN OUT VIRTIO_FS       *VirtioFs,\r
  OUT EFI_FILE_PROTOCOL  **NewHandle,\r
  IN     BOOLEAN         OpenForWriting\r
  )\r
{\r
  EFI_STATUS      Status;\r
  VIRTIO_FS_FILE  *NewVirtioFsFile;\r
\r
  //\r
  // VirtioFsOpenVolume() opens the root directory for read-only access. If the\r
  // current request is to open the root directory for read-write access, so\r
  // that EFI_FILE_PROTOCOL.Flush() or EFI_FILE_PROTOCOL.SetInfo()+timestamps\r
  // can be used on the root directory later, then we have to check for write\r
  // permission first.\r
  //\r
  if (OpenForWriting) {\r
    VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE  FuseAttr;\r
    EFI_FILE_INFO                       FileInfo;\r
\r
    Status = VirtioFsFuseGetAttr (\r
               VirtioFs,\r
               VIRTIO_FS_FUSE_ROOT_DIR_NODE_ID,\r
               &FuseAttr\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    Status = VirtioFsFuseAttrToEfiFileInfo (&FuseAttr, &FileInfo);\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    if ((FileInfo.Attribute & EFI_FILE_READ_ONLY) != 0) {\r
      return EFI_ACCESS_DENIED;\r
    }\r
  }\r
\r
  Status = VirtioFsOpenVolume (&VirtioFs->SimpleFs, NewHandle);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  NewVirtioFsFile                   = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (*NewHandle);\r
  NewVirtioFsFile->IsOpenForWriting = OpenForWriting;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Open an existent regular file or non-root directory.\r
\r
  @param[in,out] VirtioFs      The Virtio Filesystem device on which the\r
                               regular file or directory should be opened.\r
\r
  @param[in] DirNodeId         The inode number of the immediate parent\r
                               directory of the regular file or directory to\r
                               open.\r
\r
  @param[in] Name              The single-component filename of the regular\r
                               file or directory to open, under the immediate\r
                               parent directory identified by DirNodeId.\r
\r
  @param[in] OpenForWriting    TRUE if the regular file or directory should be\r
                               opened for read-write access. FALSE if the\r
                               regular file or directory should be opened for\r
                               read-only access. Opening a directory for\r
                               read-write access is useful for deleting,\r
                               renaming, syncing or touching the directory\r
                               later.\r
\r
  @param[out] NodeId           The inode number of the regular file or\r
                               directory, returned by the Virtio Filesystem\r
                               device.\r
\r
  @param[out] FuseHandle       The open handle to the regular file or\r
                               directory, returned by the Virtio Filesystem\r
                               device.\r
\r
  @param[out] NodeIsDirectory  Set to TRUE on output if Name was found to refer\r
                               to a directory. Set to FALSE if Name was found\r
                               to refer to a regular file.\r
\r
  @retval EFI_SUCCESS        The regular file or directory has been looked up\r
                             and opened successfully.\r
\r
  @retval EFI_ACCESS_DENIED  OpenForWriting is TRUE, but the regular file or\r
                             directory is marked read-only.\r
\r
  @retval EFI_NOT_FOUND      A directory entry called Name was not found in the\r
                             directory identified by DirNodeId. (EFI_NOT_FOUND\r
                             is not returned for any other condition.)\r
\r
  @return                    Errors propagated from underlying functions. If\r
                             the error code to propagate were EFI_NOT_FOUND, it\r
                             is remapped to EFI_DEVICE_ERROR.\r
**/\r
STATIC\r
EFI_STATUS\r
OpenExistentFileOrDirectory (\r
  IN OUT VIRTIO_FS  *VirtioFs,\r
  IN     UINT64     DirNodeId,\r
  IN     CHAR8      *Name,\r
  IN     BOOLEAN    OpenForWriting,\r
  OUT UINT64        *NodeId,\r
  OUT UINT64        *FuseHandle,\r
  OUT BOOLEAN       *NodeIsDirectory\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  UINT64                              ResolvedNodeId;\r
  VIRTIO_FS_FUSE_ATTRIBUTES_RESPONSE  FuseAttr;\r
  EFI_FILE_INFO                       FileInfo;\r
  BOOLEAN                             IsDirectory;\r
  UINT64                              NewFuseHandle;\r
\r
  Status = VirtioFsFuseLookup (\r
             VirtioFs,\r
             DirNodeId,\r
             Name,\r
             &ResolvedNodeId,\r
             &FuseAttr\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = VirtioFsFuseAttrToEfiFileInfo (&FuseAttr, &FileInfo);\r
  if (EFI_ERROR (Status)) {\r
    goto ForgetResolvedNodeId;\r
  }\r
\r
  if (OpenForWriting && ((FileInfo.Attribute & EFI_FILE_READ_ONLY) != 0)) {\r
    Status = EFI_ACCESS_DENIED;\r
    goto ForgetResolvedNodeId;\r
  }\r
\r
  IsDirectory = (BOOLEAN)((FileInfo.Attribute & EFI_FILE_DIRECTORY) != 0);\r
  if (IsDirectory) {\r
    //\r
    // If OpenForWriting is TRUE here, that's not passed to\r
    // VirtioFsFuseOpenDir(); it does not affect the FUSE_OPENDIR request we\r
    // send. OpenForWriting=TRUE will only permit attempts to delete, rename,\r
    // flush (sync), and touch the directory.\r
    //\r
    Status = VirtioFsFuseOpenDir (VirtioFs, ResolvedNodeId, &NewFuseHandle);\r
  } else {\r
    Status = VirtioFsFuseOpen (\r
               VirtioFs,\r
               ResolvedNodeId,\r
               OpenForWriting,\r
               &NewFuseHandle\r
               );\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    goto ForgetResolvedNodeId;\r
  }\r
\r
  *NodeId          = ResolvedNodeId;\r
  *FuseHandle      = NewFuseHandle;\r
  *NodeIsDirectory = IsDirectory;\r
  return EFI_SUCCESS;\r
\r
ForgetResolvedNodeId:\r
  VirtioFsFuseForget (VirtioFs, ResolvedNodeId);\r
  return (Status == EFI_NOT_FOUND) ? EFI_DEVICE_ERROR : Status;\r
}\r
\r
/**\r
  Create a directory.\r
\r
  @param[in,out] VirtioFs  The Virtio Filesystem device on which the directory\r
                           should be created.\r
\r
  @param[in] DirNodeId     The inode number of the immediate parent directory\r
                           of the directory to create.\r
\r
  @param[in] Name          The single-component filename of the directory to\r
                           create, under the immediate parent directory\r
                           identified by DirNodeId.\r
\r
  @param[out] NodeId       The inode number of the directory created, returned\r
                           by the Virtio Filesystem device.\r
\r
  @param[out] FuseHandle   The open handle to the directory created, returned\r
                           by the Virtio Filesystem device.\r
\r
  @retval EFI_SUCCESS  The directory has been created successfully.\r
\r
  @return              Errors propagated from underlying functions.\r
**/\r
STATIC\r
EFI_STATUS\r
CreateDirectory (\r
  IN OUT VIRTIO_FS  *VirtioFs,\r
  IN     UINT64     DirNodeId,\r
  IN     CHAR8      *Name,\r
  OUT UINT64        *NodeId,\r
  OUT UINT64        *FuseHandle\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT64      NewChildDirNodeId;\r
  UINT64      NewFuseHandle;\r
\r
  Status = VirtioFsFuseMkDir (VirtioFs, DirNodeId, Name, &NewChildDirNodeId);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = VirtioFsFuseOpenDir (VirtioFs, NewChildDirNodeId, &NewFuseHandle);\r
  if (EFI_ERROR (Status)) {\r
    goto RemoveNewChildDir;\r
  }\r
\r
  *NodeId     = NewChildDirNodeId;\r
  *FuseHandle = NewFuseHandle;\r
  return EFI_SUCCESS;\r
\r
RemoveNewChildDir:\r
  VirtioFsFuseRemoveFileOrDir (VirtioFs, DirNodeId, Name, TRUE /* IsDir */);\r
  VirtioFsFuseForget (VirtioFs, NewChildDirNodeId);\r
  return Status;\r
}\r
\r
/**\r
  Create a regular file.\r
\r
  @param[in,out] VirtioFs  The Virtio Filesystem device on which the regular\r
                           file should be created.\r
\r
  @param[in] DirNodeId     The inode number of the immediate parent directory\r
                           of the regular file to create.\r
\r
  @param[in] Name          The single-component filename of the regular file to\r
                           create, under the immediate parent directory\r
                           identified by DirNodeId.\r
\r
  @param[out] NodeId       The inode number of the regular file created,\r
                           returned by the Virtio Filesystem device.\r
\r
  @param[out] FuseHandle   The open handle to the regular file created,\r
                           returned by the Virtio Filesystem device.\r
\r
  @retval EFI_SUCCESS  The regular file has been created successfully.\r
\r
  @return              Errors propagated from underlying functions.\r
**/\r
STATIC\r
EFI_STATUS\r
CreateRegularFile (\r
  IN OUT VIRTIO_FS  *VirtioFs,\r
  IN     UINT64     DirNodeId,\r
  IN     CHAR8      *Name,\r
  OUT UINT64        *NodeId,\r
  OUT UINT64        *FuseHandle\r
  )\r
{\r
  return VirtioFsFuseOpenOrCreate (\r
           VirtioFs,\r
           DirNodeId,\r
           Name,\r
           NodeId,\r
           FuseHandle\r
           );\r
}\r
\r
EFI_STATUS\r
EFIAPI\r
VirtioFsSimpleFileOpen (\r
  IN     EFI_FILE_PROTOCOL  *This,\r
  OUT EFI_FILE_PROTOCOL     **NewHandle,\r
  IN     CHAR16             *FileName,\r
  IN     UINT64             OpenMode,\r
  IN     UINT64             Attributes\r
  )\r
{\r
  VIRTIO_FS_FILE  *VirtioFsFile;\r
  VIRTIO_FS       *VirtioFs;\r
  BOOLEAN         OpenForWriting;\r
  BOOLEAN         PermitCreation;\r
  BOOLEAN         CreateDirectoryIfCreating;\r
  VIRTIO_FS_FILE  *NewVirtioFsFile;\r
  EFI_STATUS      Status;\r
  CHAR8           *NewCanonicalPath;\r
  BOOLEAN         RootEscape;\r
  UINT64          DirNodeId;\r
  CHAR8           *LastComponent;\r
  UINT64          NewNodeId;\r
  UINT64          NewFuseHandle;\r
  BOOLEAN         NewNodeIsDirectory;\r
\r
  VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);\r
  VirtioFs     = VirtioFsFile->OwnerFs;\r
\r
  //\r
  // Validate OpenMode.\r
  //\r
  switch (OpenMode) {\r
    case EFI_FILE_MODE_READ:\r
      OpenForWriting = FALSE;\r
      PermitCreation = FALSE;\r
      break;\r
    case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE:\r
      OpenForWriting = TRUE;\r
      PermitCreation = FALSE;\r
      break;\r
    case EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE:\r
      OpenForWriting = TRUE;\r
      PermitCreation = TRUE;\r
      break;\r
    default:\r
      return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Set CreateDirectoryIfCreating to suppress incorrect compiler/analyzer\r
  // warnings.\r
  //\r
  CreateDirectoryIfCreating = FALSE;\r
\r
  //\r
  // Validate the Attributes requested for the case when the file ends up being\r
  // created, provided creation is permitted.\r
  //\r
  if (PermitCreation) {\r
    if ((Attributes & ~EFI_FILE_VALID_ATTR) != 0) {\r
      //\r
      // Unknown attribute requested.\r
      //\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    ASSERT (OpenForWriting);\r
    if ((Attributes & EFI_FILE_READ_ONLY) != 0) {\r
      DEBUG ((\r
        DEBUG_ERROR,\r
        ("%a: Label=\"%s\" CanonicalPathname=\"%a\" FileName=\"%s\" "\r
         "OpenMode=0x%Lx Attributes=0x%Lx: nonsensical request to possibly "\r
         "create a file marked read-only, for read-write access\n"),\r
        __FUNCTION__,\r
        VirtioFs->Label,\r
        VirtioFsFile->CanonicalPathname,\r
        FileName,\r
        OpenMode,\r
        Attributes\r
        ));\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    CreateDirectoryIfCreating = (BOOLEAN)((Attributes &\r
                                           EFI_FILE_DIRECTORY) != 0);\r
  }\r
\r
  //\r
  // Referring to a file relative to a regular file makes no sense (or at least\r
  // it cannot be implemented consistently with how a file is referred to\r
  // relative to a directory).\r
  //\r
  if (!VirtioFsFile->IsDirectory) {\r
    DEBUG ((\r
      DEBUG_ERROR,\r
      ("%a: Label=\"%s\" CanonicalPathname=\"%a\" FileName=\"%s\": "\r
       "nonsensical request to open a file or directory relative to a regular "\r
       "file\n"),\r
      __FUNCTION__,\r
      VirtioFs->Label,\r
      VirtioFsFile->CanonicalPathname,\r
      FileName\r
      ));\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // Allocate the new VIRTIO_FS_FILE object.\r
  //\r
  NewVirtioFsFile = AllocatePool (sizeof *NewVirtioFsFile);\r
  if (NewVirtioFsFile == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Create the canonical pathname at which the desired file is expected to\r
  // exist.\r
  //\r
  Status = VirtioFsAppendPath (\r
             VirtioFsFile->CanonicalPathname,\r
             FileName,\r
             &NewCanonicalPath,\r
             &RootEscape\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeNewVirtioFsFile;\r
  }\r
\r
  if (RootEscape) {\r
    Status = EFI_ACCESS_DENIED;\r
    goto FreeNewCanonicalPath;\r
  }\r
\r
  //\r
  // If the desired file is the root directory, just open the volume one more\r
  // time, without looking up anything.\r
  //\r
  if (AsciiStrCmp (NewCanonicalPath, "/") == 0) {\r
    FreePool (NewCanonicalPath);\r
    FreePool (NewVirtioFsFile);\r
    return OpenRootDirectory (VirtioFs, NewHandle, OpenForWriting);\r
  }\r
\r
  //\r
  // Split the new canonical pathname into most specific parent directory\r
  // (given by DirNodeId) and last pathname component (i.e., immediate child\r
  // within that parent directory).\r
  //\r
  Status = VirtioFsLookupMostSpecificParentDir (\r
             VirtioFs,\r
             NewCanonicalPath,\r
             &DirNodeId,\r
             &LastComponent\r
             );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeNewCanonicalPath;\r
  }\r
\r
  //\r
  // Set NewNodeIsDirectory to suppress incorrect compiler/analyzer warnings.\r
  //\r
  NewNodeIsDirectory = FALSE;\r
\r
  //\r
  // Try to open LastComponent directly under DirNodeId, as an existent regular\r
  // file or directory.\r
  //\r
  Status = OpenExistentFileOrDirectory (\r
             VirtioFs,\r
             DirNodeId,\r
             LastComponent,\r
             OpenForWriting,\r
             &NewNodeId,\r
             &NewFuseHandle,\r
             &NewNodeIsDirectory\r
             );\r
  //\r
  // If LastComponent could not be found under DirNodeId, but the request\r
  // allows us to create a new entry, attempt creating the requested regular\r
  // file or directory.\r
  //\r
  if ((Status == EFI_NOT_FOUND) && PermitCreation) {\r
    ASSERT (OpenForWriting);\r
    if (CreateDirectoryIfCreating) {\r
      Status = CreateDirectory (\r
                 VirtioFs,\r
                 DirNodeId,\r
                 LastComponent,\r
                 &NewNodeId,\r
                 &NewFuseHandle\r
                 );\r
    } else {\r
      Status = CreateRegularFile (\r
                 VirtioFs,\r
                 DirNodeId,\r
                 LastComponent,\r
                 &NewNodeId,\r
                 &NewFuseHandle\r
                 );\r
    }\r
\r
    NewNodeIsDirectory = CreateDirectoryIfCreating;\r
  }\r
\r
  //\r
  // Regardless of the branch taken, we're done with DirNodeId.\r
  //\r
  if (DirNodeId != VIRTIO_FS_FUSE_ROOT_DIR_NODE_ID) {\r
    VirtioFsFuseForget (VirtioFs, DirNodeId);\r
  }\r
\r
  if (EFI_ERROR (Status)) {\r
    goto FreeNewCanonicalPath;\r
  }\r
\r
  //\r
  // Populate the new VIRTIO_FS_FILE object.\r
  //\r
  NewVirtioFsFile->Signature              = VIRTIO_FS_FILE_SIG;\r
  NewVirtioFsFile->SimpleFile.Revision    = EFI_FILE_PROTOCOL_REVISION;\r
  NewVirtioFsFile->SimpleFile.Open        = VirtioFsSimpleFileOpen;\r
  NewVirtioFsFile->SimpleFile.Close       = VirtioFsSimpleFileClose;\r
  NewVirtioFsFile->SimpleFile.Delete      = VirtioFsSimpleFileDelete;\r
  NewVirtioFsFile->SimpleFile.Read        = VirtioFsSimpleFileRead;\r
  NewVirtioFsFile->SimpleFile.Write       = VirtioFsSimpleFileWrite;\r
  NewVirtioFsFile->SimpleFile.GetPosition = VirtioFsSimpleFileGetPosition;\r
  NewVirtioFsFile->SimpleFile.SetPosition = VirtioFsSimpleFileSetPosition;\r
  NewVirtioFsFile->SimpleFile.GetInfo     = VirtioFsSimpleFileGetInfo;\r
  NewVirtioFsFile->SimpleFile.SetInfo     = VirtioFsSimpleFileSetInfo;\r
  NewVirtioFsFile->SimpleFile.Flush       = VirtioFsSimpleFileFlush;\r
  NewVirtioFsFile->IsDirectory            = NewNodeIsDirectory;\r
  NewVirtioFsFile->IsOpenForWriting       = OpenForWriting;\r
  NewVirtioFsFile->OwnerFs                = VirtioFs;\r
  NewVirtioFsFile->CanonicalPathname      = NewCanonicalPath;\r
  NewVirtioFsFile->FilePosition           = 0;\r
  NewVirtioFsFile->NodeId                 = NewNodeId;\r
  NewVirtioFsFile->FuseHandle             = NewFuseHandle;\r
  NewVirtioFsFile->FileInfoArray          = NULL;\r
  NewVirtioFsFile->SingleFileInfoSize     = 0;\r
  NewVirtioFsFile->NumFileInfo            = 0;\r
  NewVirtioFsFile->NextFileInfo           = 0;\r
\r
  //\r
  // One more file is now open for the filesystem.\r
  //\r
  InsertTailList (&VirtioFs->OpenFiles, &NewVirtioFsFile->OpenFilesEntry);\r
\r
  *NewHandle = &NewVirtioFsFile->SimpleFile;\r
  return EFI_SUCCESS;\r
\r
FreeNewCanonicalPath:\r
  FreePool (NewCanonicalPath);\r
\r
FreeNewVirtioFsFile:\r
  FreePool (NewVirtioFsFile);\r
\r
  return Status;\r
}\r