VFS.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef VFS_H
#define VFS_H
#include "pedigree/kernel/linker/KernelElf.h"
 
#include <config.h>
 
#if THREADS
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/process/WaitQueue.h"
#endif
#include "pedigree/kernel/LockGuard.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/FilesystemContext.h"
#include "pedigree/kernel/process/FilesystemCredentials.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/OperationBarrier.h"
#include "pedigree/kernel/process/Rcu.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/List.h"
#include "pedigree/kernel/utilities/LruCache.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Tree.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include "Filesystem.h"
 
class Process;
class Disk;
class File;
class StringView;
class VfsMountState;
class VfsFilesystemPin;
class VfsMountView;
 
class EXPORTED_PUBLIC VFS {
 public:
  class EXPORTED_PUBLIC NamespaceMutation {
   public:
    explicit NamespaceMutation(VFS& vfs);
    ~NamespaceMutation();
    uint64_t generation() const;
    bool protects(const VFS& vfs) const {
      return &m_Vfs == &vfs;
    }
 
   private:
    NamespaceMutation(const NamespaceMutation&) = delete;
    NamespaceMutation& operator=(const NamespaceMutation&) = delete;
    VFS& m_Vfs;
    LockGuard<Mutex> m_Lock;
  };
 
  uint64_t namespaceGeneration() const;
  VfsMountView* mountView() const;
  VfsMountView* bootMountView() const;
  bool shutdownMountView(Vector<Filesystem*>& ownedBackings);
  bool initialiseMountView();
 
  static Module::UnloadAdmission unloadAdmission(bool terminal);
  class MountOperation;
  class FilesystemPin;
  class EXPORTED_PUBLIC MountIdentity {
   public:
    MountIdentity();
    MountIdentity(const MountIdentity& other);
    MountIdentity(MountIdentity&& other) noexcept;
    ~MountIdentity();
    MountIdentity& operator=(const MountIdentity& other);
    MountIdentity& operator=(MountIdentity&& other) noexcept;
    uint32_t id() const;
    explicit operator bool() const;
    bool acquire(MountOperation& operation) const;
    bool pin(FilesystemPin& pin) const;
    bool subscribeRetirement(const SharedPointer<FileEventObserver>& observer,
                             FileEventSubscription& subscription) const;
 
   private:
    friend class VFS;
    friend class MountOperation;
    friend class FilesystemPin;
    SharedPointer<VfsMountState> m_State;
  };
 
  class EXPORTED_PUBLIC MountOperation {
   public:
    MountOperation();
    MountOperation(MountOperation&& other) noexcept;
    ~MountOperation();
    MountOperation& operator=(MountOperation&& other) noexcept;
    Filesystem* filesystem() const;
    uint32_t id() const;
    MountIdentity identity() const;
    explicit operator bool() const;
    void reset();
 
   private:
    friend class VFS;
    friend class MountIdentity;
    MountOperation(const MountOperation&) = delete;
    MountOperation& operator=(const MountOperation&) = delete;
    TerminationDeferral m_Lifetime;
    SharedPointer<VfsMountState> m_State;
    OperationBarrier::Lease m_Admission;
  };
 
  bool acquireMount(Filesystem* key, MountOperation& operation) const;
 
  class EXPORTED_PUBLIC FilesystemPin {
   public:
    FilesystemPin();
    FilesystemPin(const FilesystemPin& other);
    FilesystemPin(FilesystemPin&& other) noexcept;
    ~FilesystemPin();
    FilesystemPin& operator=(const FilesystemPin& other);
    FilesystemPin& operator=(FilesystemPin&& other) noexcept;
    Filesystem* filesystem() const;
    MountIdentity identity() const;
    explicit operator bool() const;
    void reset();
 
   private:
    friend class VFS;
    friend class MountIdentity;
    SharedPointer<VfsFilesystemPin> m_Pin;
  };
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  class EXPORTED_PUBLIC HostedRootViewScope {
   public:
    HostedRootViewScope();
    ~HostedRootViewScope();
    bool open(Filesystem* filesystem);
    bool installContext(Process& process);
    bool close();
    VfsMountView* view() const {
      return m_View;
    }
 
   private:
    HostedRootViewScope(const HostedRootViewScope&) = delete;
    HostedRootViewScope& operator=(const HostedRootViewScope&) = delete;
    TerminationDeferral m_Lifetime;
    VFS& m_Vfs;
    Filesystem* m_Filesystem = nullptr;
    Filesystem* m_PreviousRoot = nullptr;
    VfsMountView* m_PreviousView = nullptr;
    VfsMountView* m_View = nullptr;
    FilesystemPin m_PreviousRootPin;
    FilesystemContextRef m_PreviousContext;
    bool m_Installed = false;
  };
#endif
 
  bool pinFilesystem(Filesystem* key, FilesystemPin& pin) const;
  bool diskMount(uint32_t id, MountIdentity& identity) const;
  bool snapshotDiskMounts(Vector<MountIdentity>& mounts) const;
 
  typedef void (*MountCallback)();
 
  struct MountSnapshot {
    MountSnapshot() : hasDisk(false) {}
    MountSnapshot(const String& stableName, const String& path, bool hasDisk,
                  const String& diskParentName, const String& diskName)
        : stableName(stableName),
          path(path),
          hasDisk(hasDisk),
          diskParentName(diskParentName),
          diskName(diskName) {}
 
    String stableName;
    String path;
    bool hasDisk;
    String diskParentName;
    String diskName;
  };
 
  VFS();
  ~VFS();
 
  static VFS& instance();
 
  bool mount(Disk* pDisk, String& stableName, Filesystem** pMountedFs = nullptr);
 
  String registerFilesystem(Filesystem* pFs, const String& preferredStableName);
 
  // Terminal failures after admission closes leave the unregistered backend
  // alive for diagnosis; callers must halt instead of resuming filesystem use.
  bool unregisterFilesystem(Filesystem* pFs, bool canDelete = true, bool terminal = false);
  bool retireOwnedFilesystem(Filesystem* filesystem);
  bool removeDiskFilesystem(Filesystem* filesystem, bool deviceAvailable = false);
 
  bool setRootFilesystem(Filesystem* pFs);
 
  Filesystem* getRootFilesystem() const;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  Filesystem* swapRootFilesystemForHostedTest(Filesystem* pFs);
#endif
 
  bool getMountPath(Filesystem* pFs, String& path) const;
 
  Filesystem* getFilesystemAt(const String& path) const;
 
  void getMounts(Vector<MountSnapshot>& mounts) const;
 
  Filesystem::SyncStatus syncFilesystem(Filesystem* key);
 
  Filesystem::SyncStatus syncAll();
 
  bool removeEphemeralFiles();
 
  File* find(const String& path, File* pStartNode = 0);
 
  File* findRetained(const String& path, Directory::ChildLease& result, File* pStartNode = nullptr);
 
  bool createFile(const String& path, uint32_t mask, File* pStartNode = 0);
 
  bool createDirectory(const String& path, uint32_t mask, File* pStartNode = 0);
 
  bool createSymlink(const String& path, const String& value, File* pStartNode = 0);
 
  bool createLink(const String& path, File* target, File* pStartNode = 0);
 
  bool remove(const String& path, File* pStartNode = 0);
 
  bool remove(const String& path, File* pStartNode, File* expected);
 
  bool rename(const String& oldPath, File* oldStart, const String& newPath, File* newStart,
              bool noReplace = false);
 
  void addProbeCallback(Filesystem::ProbeCallback callback);
 
  bool removeProbeCallback(Filesystem::ProbeCallback callback);
 
  void addMountCallback(MountCallback callback);
 
  bool removeMountCallback(MountCallback callback);
 
  static bool checkAccess(File* pFile, bool bRead, bool bWrite, bool bExecute);
  static bool checkAccess(File* file, bool read, bool write, bool execute,
                          const FilesystemCredentials& credentials);
 
  static bool checkAccess(File* pFile, bool bRead, bool bWrite, bool bExecute, int64_t userId,
                          int64_t groupId, const Vector<int64_t>& supplementalGroups);
 
  void trackFile(File* pFile);
  bool tryTrackFile(File* pFile);
 
  MUST_USE_RESULT bool retainTrackedFile(File* pFile);
 
  bool untrackFile(File* pFile, bool destroy = true);
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  using RetainTrackedFileHook = void (*)(File* pFile);
  static void setRetainTrackedFileHookForHostedTest(RetainTrackedFileHook hook);
#endif
 
 private:
  struct TrackedFile;
  static constexpr size_t TrackedFileBuckets = 256;
  RcuPointer<TrackedFile>& trackedFileBucket(File* file);
  bool trackFileLocked(File* file);
 
  struct MountInfo {
    MountInfo(const String& stableName, const String& path,
              const SharedPointer<VfsMountState>& state);
    ~MountInfo();
 
    String stableName;
    String path;
    SharedPointer<VfsMountState> state;
  };
 
  typedef Tree<Filesystem*, MountInfo*> MountTable;
 
  struct CallbackState {
#if THREADS
    size_t sequence = 0;
    size_t inFlight = 0;
    size_t removers = 0;
    bool enabled = true;
    bool draining = false;
    uintptr_t debugAddress = 0;
    WaitQueue drainWaiters;
#endif
  };
 
  struct ProbeCallbackItem {
    explicit ProbeCallbackItem(Filesystem::ProbeCallback callback) : callback(callback) {}
 
    CallbackState state;
    Filesystem::ProbeCallback callback;
  };
 
  struct MountCallbackItem {
    explicit MountCallbackItem(MountCallback callback) : callback(callback) {}
 
    CallbackState state;
    MountCallback callback;
  };
 
#if THREADS
  struct ActiveInvocation {
    CallbackState* state;
    void* owner;
    ActiveInvocation* next;
  };
 
  ProbeCallbackItem* acquireProbeCallback(size_t& afterSequence, size_t boundary,
                                          ActiveInvocation& invocation);
  MountCallbackItem* acquireMountCallback(size_t& afterSequence, size_t boundary,
                                          ActiveInvocation& invocation);
  void finishCallback(CallbackState* state, ActiveInvocation& invocation);
  void drainProbeCallback(ProbeCallbackItem* item);
  void drainMountCallback(MountCallbackItem* item);
  void dispatchMountCallbacks(void* owner);
  bool isCallbackInvocation(void* owner) const;
#endif
 
  File* resolveStartNode(const String& path, File* pStartNode);
  String registerFilesystemLocked(Filesystem* pFs, const String& preferredStableName);
  String getUniqueStableNameLocked(const String& preferredName) const;
  bool attachFilesystem(Filesystem* pRootFs, Filesystem* pFs, const String& path);
  void attachRegisteredFilesystemsLocked();
  void getMountsLocked(Vector<MountSnapshot>& mounts) const;
 
  static VFS m_Instance;
 
  static File* m_EmptyFile;
 
  mutable Mutex m_PathMutationLock;
  uint64_t m_PathGeneration;
  VfsMountView* m_MountView;
  mutable Mutex m_MountMutationLock;
  mutable Mutex m_MountTableLock;
 
  Filesystem* m_pRootFilesystem;
  MountTable m_Mounts;
 
  List<ProbeCallbackItem*> m_ProbeCallbacks;
  List<MountCallbackItem*> m_MountCallbacks;
 
#if THREADS
  Spinlock m_CallbackLock;
  size_t m_NextCallbackSequence;
  ActiveInvocation* m_pActiveCallbacks;
  bool m_CallbacksClosing;
#endif
 
  LruCache<String, File*> m_FindCache;
 
  Mutex m_TrackedFilesLock;
  RcuPointer<TrackedFile> m_TrackedFiles[TrackedFileBuckets];
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static RetainTrackedFileHook m_RetainTrackedFileHook;
#endif
};
 
#endif