Filesystem.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 FILESYSTEM_H
#define FILESYSTEM_H
 
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/DiskPaging.h"
#include "pedigree/kernel/process/FilesystemContext.h"
#include "pedigree/kernel/process/OperationBarrier.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/String.h"
 
#include "Directory.h"
#include "Quota.h"
 
class Disk;
class File;
class StringView;
class Thread;
 
class EXPORTED_PUBLIC Filesystem {
  friend class Directory;
 
  friend class VFS;
  friend class VfsMountView;
 
 public:
  enum class SyncStatus { Success, Unsupported, NoMemory, IoError };
 
  //
  // Public interface
  //
 
  Filesystem();
  virtual ~Filesystem();
 
  virtual bool initialise(Disk* pDisk) = 0;
 
  typedef Filesystem* (*ProbeCallback)(Disk*);
 
  virtual File* find(const StringView& path);
  virtual File* find(const String& path);
  virtual File* find(const StringView& path, File* pStartNode);
  virtual File* find(const String& path, File* pStartNode);
 
  File* findRetained(const StringView& path, Directory::ChildLease& result,
                     File* pStartNode = nullptr);
 
  virtual File* getRoot() const = 0;
 
  virtual const String& getVolumeLabel() const = 0;
 
  virtual bool getUuid(String& uuid) const {
    uuid.clear();
    return false;
  }
 
  virtual FileHandleStatus encodeFileHandle(File& file, FileHandle& handle);
  virtual FileHandleStatus decodeFileHandle(const FileHandle& handle, RetainedFile& file);
  virtual FileHandleStatus fileHandleFsid(FileSystemId& id);
 
  virtual SyncStatus sync();
  virtual SyncStatus shutdown();
  virtual bool deviceRemoved(bool deviceAvailable = false);
  bool tryAcquireOperation(OperationBarrier::Lease& operation) const;
  bool isDeviceRemoved() const;
  virtual QuotaStatus quotaControl(const QuotaRequest&, QuotaResponse&, File* quotaFile = nullptr);
 
  bool createFile(const StringView& path, uint32_t mask, File* pStartNode = 0);
 
  bool createDirectory(const StringView& path, uint32_t mask, File* pStartNode = 0);
 
  bool createSymlink(const StringView& path, const String& value, File* pStartNode = 0);
 
  bool createLink(const StringView& path, File* target, File* pStartNode = 0);
 
  bool remove(const StringView& path, File* pStartNode = 0);
 
  bool remove(const StringView& path, File* pStartNode, File* expected);
 
  bool rename(const StringView& oldPath, File* oldStart, const StringView& newPath, File* newStart,
              bool noReplace = false);
 
  Disk* getDisk() {
    return m_pDisk;
  }
 
  bool isReadOnly() {
    return m_bReadOnly;
  }
 
  virtual bool isCaseSensitive() {
    return true;
  }
 
  bool remove(File* parent, File* file);
 
 protected:
  virtual bool createFile(File* parent, const String& filename, uint32_t mask) = 0;
  virtual bool createDirectory(File* parent, const String& filename, uint32_t mask) = 0;
  virtual bool createSymlink(File* parent, const String& filename, const String& value) = 0;
  virtual bool createLink(File* parent, const String& filename, File* target);
  virtual bool removeNode(File* parent, const String& filename, File* file) = 0;
  virtual bool renameNode(Directory* oldParent, const String& oldName, File* source,
                          Directory* newParent, const String& newName, File* replaced);
  bool m_bReadOnly;
  Disk* m_pDisk;
  DiskUse m_DiskUse;
  mutable OperationBarrier m_Operations;
  bool beginDeviceRemoval(bool deviceAvailable);
 
 private:
  Atomic<Thread*> m_RemovalOwner = nullptr;
#if !THREADS
  bool m_RemovalWrites = false;
#endif
  static Mutex m_StructureLock;
  bool removeChild(File* parent, const String& filename, File* expected,
                   const FilesystemPathRef* parentPath = nullptr);
  bool renameChildren(File* oldParent, const String& oldName, File* newParent,
                      const String& newName, bool noReplace, bool sourceMustBeDirectory,
                      const FilesystemPathRef* oldPath = nullptr,
                      const FilesystemPathRef* newPath = nullptr);
 
  File* findNode(File* pNode, StringView path);
 
  File* findNode(File* pNode, StringView path, File* stableStart, File* trueRoot,
                 File** retainedResult);
 
  File* findParent(StringView path, File* pStartNode, String& filename,
                   File** retainedParent = nullptr);
 
  Filesystem(const Filesystem&);
  void operator=(const Filesystem&);
};
 
#endif