SimpleFsSetInfo.c

Go to the documentation of this file.

 
#include <Guid/FileSystemInfo.h>            // gEfiFileSystemInfoGuid
#include <Guid/FileSystemVolumeLabelInfo.h> // gEfiFileSystemVolumeLabelInfo...
#include <Library/BaseLib.h>                // StrCmp()
#include <Library/BaseMemoryLib.h>          // CompareGuid()
#include <Library/MemoryAllocationLib.h>    // FreePool()
 
#include "VirtioFsDxe.h"
 
STATIC
EFI_STATUS
ValidateInfoStructure (
  IN UINTN    SizeByProtocolCaller,
  IN UINTN    MinimumStructSize,
  IN BOOLEAN  IsSizeByInfoPresent,
  IN VOID     *Buffer
  )
{
  UINTN   NameFieldByteOffset;
  UINTN   NameFieldBytes;
  UINTN   NameFieldChar16s;
  CHAR16  *NameField;
 
  //
  // Make sure the internal function asking for validation passes in sane
  // values.
  //
  ASSERT (MinimumStructSize >= sizeof (CHAR16));
  NameFieldByteOffset = MinimumStructSize - sizeof (CHAR16);
 
  if (IsSizeByInfoPresent) {
    ASSERT (MinimumStructSize >= sizeof (UINT64) + sizeof (CHAR16));
    ASSERT (NameFieldByteOffset >= sizeof (UINT64));
  }
 
  //
  // Check whether the protocol caller provided enough bytes for the minimum
  // size of this info structure.
  //
  if (SizeByProtocolCaller < MinimumStructSize) {
    return EFI_BAD_BUFFER_SIZE;
  }
 
  //
  // If the info structure starts with a UINT64 Size field, check if that
  // agrees with the protocol caller-provided size.
  //
  if (IsSizeByInfoPresent) {
    UINT64  *SizeByInfo;
 
    SizeByInfo = Buffer;
    if (*SizeByInfo != SizeByProtocolCaller) {
      return EFI_INVALID_PARAMETER;
    }
  }
 
  //
  // The CHAR16 Name field at the end of the structure must have an even number
  // of bytes.
  //
  // The subtraction below cannot underflow, and yields at least
  // sizeof(CHAR16).
  //
  ASSERT (SizeByProtocolCaller >= NameFieldByteOffset);
  NameFieldBytes = SizeByProtocolCaller - NameFieldByteOffset;
  ASSERT (NameFieldBytes >= sizeof (CHAR16));
  if (NameFieldBytes % sizeof (CHAR16) != 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // The CHAR16 Name field at the end of the structure must be NUL-terminated.
  //
  NameFieldChar16s = NameFieldBytes / sizeof (CHAR16);
  ASSERT (NameFieldChar16s >= 1);
 
  NameField = (CHAR16 *)((UINT8 *)Buffer + NameFieldByteOffset);
  if (NameField[NameFieldChar16s - 1] != L'\0') {
    return EFI_INVALID_PARAMETER;
  }
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
Rename (
  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;
 
  VirtioFs = VirtioFsFile->OwnerFs;
 
  //
  // The root directory cannot be renamed.
  //
  if (AsciiStrCmp (VirtioFsFile->CanonicalPathname, "/") == 0) {
    if (StrCmp (NewFileName, L"") == 0) {
      //
      // Not a rename request anyway.
      //
      return EFI_SUCCESS;
    }
 
    return EFI_ACCESS_DENIED;
  }
 
  //
  // Compose the canonical pathname for the destination.
  //
  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.
  //
  if (AsciiStrCmp (VirtioFsFile->CanonicalPathname, Destination) == 0) {
    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;
 
    PathLen = AsciiStrLen (VirtioFsFile->CanonicalPathname);
    BASE_LIST_FOR_EACH (OpenFilesEntry, &VirtioFs->OpenFiles) {
      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] == '/')))
      {
        //
        // OtherFile refers to the same directory as VirtioFsFile, or is a
        // (possibly indirect) child of the directory referred to by
        // VirtioFsFile.
        //
        Status = EFI_ACCESS_DENIED;
        goto FreeDestination;
      }
    }
  }
 
  //
  // From this point on, the file needs to be open for writing.
  //
  if (!VirtioFsFile->IsOpenForWriting) {
    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
             );
  if (EFI_ERROR (Status)) {
    goto FreeDestination;
  }
 
  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
             );
  if (EFI_ERROR (Status)) {
    goto ForgetNewParentDirNodeId;
  }
 
  //
  // Swap in the new canonical pathname.
  //
  FreePool (VirtioFsFile->CanonicalPathname);
  VirtioFsFile->CanonicalPathname = Destination;
  Destination                     = NULL;
  Status                          = EFI_SUCCESS;
 
  //
  // Fall through.
  //
ForgetNewParentDirNodeId:
  if (NewParentDirNodeId != VIRTIO_FS_FUSE_ROOT_DIR_NODE_ID) {
    VirtioFsFuseForget (VirtioFs, NewParentDirNodeId);
  }
 
ForgetOldParentDirNodeId:
  if (OldParentDirNodeId != VIRTIO_FS_FUSE_ROOT_DIR_NODE_ID) {
    VirtioFsFuseForget (VirtioFs, OldParentDirNodeId);
  }
 
FreeDestination:
  if (Destination != NULL) {
    FreePool (Destination);
  }
 
  return Status;
}
 
STATIC
EFI_STATUS
UpdateAttributes (
  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;
 
  VirtioFs = VirtioFsFile->OwnerFs;
 
  //
  // Fetch the current attributes first, so we can build the difference between
  // them and NewFileInfo.
  //
  Status = VirtioFsFuseGetAttr (VirtioFs, VirtioFsFile->NodeId, &FuseAttr);
  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
      );
  }
 
  Status = VirtioFsGetFuseTimeUpdates (
             &FileInfo,
             NewFileInfo,
             &UpdateAtime,
             &UpdateMtime,
             &Atime,
             &Mtime
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = VirtioFsGetFuseModeUpdate (
             &FileInfo,
             NewFileInfo,
             &UpdateMode,
             &Mode
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // If no attribute updates are necessary, we're done.
  //
  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))
  {
    return EFI_ACCESS_DENIED;
  }
 
  //
  // Send the FUSE_SETATTR request now.
  //
  Status = VirtioFsFuseSetAttr (
             VirtioFs,
             VirtioFsFile->NodeId,
             UpdateFileSize ? &FileSize : NULL,
             UpdateAtime    ? &Atime    : NULL,
             UpdateMtime    ? &Mtime    : NULL,
             UpdateMode     ? &Mode     : NULL
             );
  return Status;
}
 
STATIC
EFI_STATUS
SetFileInfo (
  IN EFI_FILE_PROTOCOL  *This,
  IN UINTN              BufferSize,
  IN VOID               *Buffer
  )
{
  VIRTIO_FS_FILE  *VirtioFsFile;
  EFI_STATUS      Status;
  EFI_FILE_INFO   *FileInfo;
 
  VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
 
  //
  // Validate if Buffer passes as EFI_FILE_INFO.
  //
  Status = ValidateInfoStructure (
             BufferSize,                    // SizeByProtocolCaller
             OFFSET_OF (
               EFI_FILE_INFO,
               FileName
               ) + sizeof (CHAR16),         // MinimumStructSize
             TRUE,                          // IsSizeByInfoPresent
             Buffer
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  FileInfo = Buffer;
 
  //
  // Perform the rename/move request, if any.
  //
  Status = Rename (VirtioFsFile, FileInfo->FileName);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Update any attributes requested.
  //
  Status = UpdateAttributes (VirtioFsFile, FileInfo);
  //
  // The UEFI spec does not speak about partial failure in
  // EFI_FILE_PROTOCOL.SetInfo(); we won't try to roll back the rename (if
  // there was one) in case the attribute updates fail.
  //
  return Status;
}
 
STATIC
EFI_STATUS
SetFileSystemInfo (
  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;
 
  VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
  VirtioFs     = VirtioFsFile->OwnerFs;
 
  //
  // Validate if Buffer passes as EFI_FILE_SYSTEM_INFO.
  //
  Status = ValidateInfoStructure (
             BufferSize,                       // SizeByProtocolCaller
             OFFSET_OF (
               EFI_FILE_SYSTEM_INFO,
               VolumeLabel
               ) + sizeof (CHAR16),            // MinimumStructSize
             TRUE,                             // IsSizeByInfoPresent
             Buffer
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  FileSystemInfo = Buffer;
 
  //
  // EFI_FILE_SYSTEM_INFO fields other than VolumeLabel cannot be changed, per
  // spec.
  //
  // If the label is being changed to its current value, report success;
  // otherwise, reject the request, as the Virtio Filesystem device does not
  // support changing the label.
  //
  if (StrCmp (FileSystemInfo->VolumeLabel, VirtioFs->Label) == 0) {
    return EFI_SUCCESS;
  }
 
  return EFI_WRITE_PROTECTED;
}
 
STATIC
EFI_STATUS
SetFileSystemVolumeLabelInfo (
  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;
 
  VirtioFsFile = VIRTIO_FS_FILE_FROM_SIMPLE_FILE (This);
  VirtioFs     = VirtioFsFile->OwnerFs;
 
  //
  // Validate if Buffer passes as EFI_FILE_SYSTEM_VOLUME_LABEL.
  //
  Status = ValidateInfoStructure (
             BufferSize,                              // SizeByProtocolCaller
             OFFSET_OF (
               EFI_FILE_SYSTEM_VOLUME_LABEL,
               VolumeLabel
               ) + sizeof (CHAR16),                   // MinimumStructSize
             FALSE,                                   // IsSizeByInfoPresent
             Buffer
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  FileSystemVolumeLabel = Buffer;
 
  //
  // If the label is being changed to its current value, report success;
  // otherwise, reject the request, as the Virtio Filesystem device does not
  // support changing the label.
  //
  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
  )
{
  if (CompareGuid (InformationType, &gEfiFileInfoGuid)) {
    return SetFileInfo (This, BufferSize, Buffer);
  }
 
  if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid)) {
    return SetFileSystemInfo (This, BufferSize, Buffer);
  }
 
  if (CompareGuid (InformationType, &gEfiFileSystemVolumeLabelInfoIdGuid)) {
    return SetFileSystemVolumeLabelInfo (This, BufferSize, Buffer);
  }
 
  return EFI_UNSUPPORTED;
}