Ext2Filesystem.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 EXT2FILESYSTEM_H
#define EXT2FILESYSTEM_H
#include "pedigree/kernel/machine/DiskView.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Tree.h"
 
#include <config.h>
 
#include "Ext2Quota.h"
#include "modules/system/vfs/ExtendedAttributes.h"
#include "modules/system/vfs/Filesystem.h"
 
class Disk;
class Ext2Node;
class Ext2File;
struct Ext2InodeState;
class File;
struct GroupDesc;
struct Inode;
struct Superblock;
template <class T>
class Vector;
 
class Ext2Filesystem : public Filesystem {
  friend class Ext2HandlesTestPeer;
  friend class Ext2XattrTestPeer;
  friend class Ext2FillCacheTestPeer;
  friend class Ext2WritebackTestPeer;
  friend class Ext2FilesystemSyncTestPeer;
  friend class Ext2DirectorySyncTestPeer;
  friend class Ext2AllocationTestPeer;
  friend class Ext2QuotaTestPeer;
  friend class Ext2File;
  friend class Ext2Node;
  friend class Ext2Directory;
  friend class Ext2Symlink;
  friend struct Ext2InodeState;
 
 public:
  Ext2Filesystem();
 
  virtual ~Ext2Filesystem();
 
  //
  // Filesystem interface.
  //
  virtual bool initialise(Disk* pDisk);
  static Filesystem* probe(Disk* pDisk);
  virtual File* getRoot() const;
  virtual const String& getVolumeLabel() const;
  virtual bool getUuid(String& uuid) const;
  virtual FileHandleStatus encodeFileHandle(File&, FileHandle&);
  virtual FileHandleStatus decodeFileHandle(const FileHandle&, RetainedFile&);
  virtual FileHandleStatus fileHandleFsid(FileSystemId&);
  virtual SyncStatus sync();
  virtual SyncStatus shutdown();
  virtual bool deviceRemoved(bool deviceAvailable = false);
  virtual QuotaStatus quotaControl(const QuotaRequest&, QuotaResponse&, File* quotaFile = nullptr);
 
 protected:
  virtual bool createFile(File* parent, const String& filename, uint32_t mask);
  virtual bool createDirectory(File* parent, const String& filename, uint32_t mask);
  virtual bool createSymlink(File* parent, const String& filename, const String& value);
  virtual bool createLink(File* parent, const String& filename, File* target);
  virtual bool removeNode(File* parent, const String& filename, File* file);
  virtual bool renameNode(Directory* oldParent, const String& oldName, File* source,
                          Directory* newParent, const String& newName, File* replaced);
 
 private:
  void releaseMetadata();
  static bool quotaSucceeded(QuotaStatus status);
  static QuotaStatus quotaIoStatus();
  static int currentIoError();
  QuotaStatus prepareQuotaInodeLocked(uint32_t inode);
  QuotaStatus scanQuotaInodesLocked();
  QuotaStatus flushQuotaLocked(QuotaType type);
  QuotaStatus flushQuotas();
  bool closeQuotaFiles(bool discardOnFailure = true);
  bool beginWritableMount();
  bool isQuotaFile(uint32_t inode);
  Ext2QuotaLedger m_Quota;
  Mutex m_QuotaControlLock;
  Mutex m_QuotaNamespaceLock;
  Ext2File* m_QuotaFiles[2] = {};
#if defined(PEDIGREE_BUILDUTILS)
  void (*m_QuotaOffTestHook)(void*) = nullptr;
  void* m_QuotaOffTestContext = nullptr;
#endif
  class SyncSnapshot;
  void releaseSyncState(uint32_t inode, Ext2InodeState* state);
  Ext2InodeState* acquireInodeState(uint32_t inode, Inode* metadata);
  Ext2InodeState* acquireInodeStateLocked(uint32_t inode, Inode* metadata);
  FileHandleStatus validateHandleInodeLocked(uint32_t inode, uint32_t generation, Inode*&);
  void releaseInodeState(uint32_t inode, Ext2InodeState* state, Ext2Node* lastNode);
  void retireInodeLocked(uint32_t inode, Ext2Node* lastNode);
  enum class AttributeWriteKind { Payload, Allocation, Inode };
  struct AttributeWrite {
    uint64_t location = 0;
    AttributeWriteKind kind = AttributeWriteKind::Payload;
    bool ownsPin = false;
  };
  static constexpr size_t MaximumAttributeWrites = 64;
  AttributeWrite m_AttributeWrites[MaximumAttributeWrites];
  size_t m_AttributeWriteCount = 0;
  struct AttributeRetirement {
    AttributeRetirement() = default;
    ~AttributeRetirement();
    AttributeRetirement(const AttributeRetirement&) = delete;
    AttributeRetirement& operator=(const AttributeRetirement&) = delete;
    Ext2Filesystem* filesystem = nullptr;
    uint32_t block = 0;
    uintptr_t buffer = 0;
    bool provisional = false;
  };
  XattrStatus attributeFormatStatus() const;
  XattrStatus readAttributeBlockLocked(Inode*, AttributeRetirement&);
  XattrStatus prepareAttributeRetirementLocked(Inode*, AttributeRetirement&);
  void commitAttributeRetirementLocked(AttributeRetirement&);
  XattrStatus allocateAttributeBlockLocked(uint32_t inode, AttributeRetirement&);
  XattrStatus reserveAttributeWritesLocked(size_t additional);
  void recordAttributeWriteLocked(uint64_t, AttributeWriteKind, bool adoptPin = false);
  void recordAttributeAllocationLocked(uint32_t block);
  void recordAttributeInodeLocked(uint32_t inode);
  void forgetAttributeBlockLocked(uint32_t block);
  bool flushAttributeWritesLocked();
  void drainAttributeWrites();
  Mutex m_InodeStateLock;
  Tree<uint32_t, Ext2InodeState*> m_InodeStates;
  virtual bool createNode(File* parent, const String& filename, uint32_t mask, const String& value,
                          size_t type, uint32_t inodeOverride = 0);
 
  Ext2Filesystem(const Ext2Filesystem&);
  void operator=(const Ext2Filesystem&);
 
  uintptr_t readBlock(uint32_t block);
  DiskReadView readBlockView(uint32_t block);
  void writeBlock(uint32_t block);
 
  bool pinBlock(uint64_t location);
  void unpinBlock(uint64_t location);
 
  bool syncBlock(uint32_t block, bool async);
  bool syncInode(uint32_t inode, Ext2Node& node, bool includeNamespaceMetadata = false);
 
  uint32_t findFreeBlock(uint32_t inode);
  bool findFreeBlocks(uint32_t inode, size_t count, Vector<uint32_t>& blocks);
  size_t findFreeBlocksInGroup(uint32_t group, size_t maxCount, Vector<uint32_t>& blocks);
  uint32_t findFreeInode(uint32_t uid = 0, uint32_t gid = 0);
 
  void releaseBlock(uint32_t block, uint32_t inode = 0);
  bool releaseInode(uint32_t inode, Ext2Node* retiringNode = nullptr);
 
  Inode* getInode(uint32_t num);
  void writeInode(uint32_t num);
 
  bool ensureFreeBlockBitmapLoaded(size_t group);
  bool ensureFreeInodeBitmapLoaded(size_t group);
  uintptr_t loadInodeTableBlock(size_t group, size_t block);
 
  void releaseBlockLocked(uint32_t block, uint32_t inode = 0);
  bool prepareBlockReleaseLocked(uint32_t block);
  bool prepareInodeWrite(uint32_t inode);
 
  bool checkOptionalFeature(size_t feature);
  bool checkRequiredFeature(size_t feature);
  bool checkReadOnlyFeature(size_t feature);
 
  void increaseInodeRefcount(uint32_t inode);
  bool decreaseInodeRefcount(uint32_t inode);
 
  Superblock* m_pSuperblock;
  uint16_t m_MountState = 0;
  bool m_ShutdownComplete = false;
  bool m_TeardownFailed = false;
 
  GroupDesc** m_pGroupDescriptors;
 
  Vector<size_t>* m_pInodeTables;
  Vector<size_t>* m_pInodeBitmaps;
  Vector<size_t>* m_pBlockBitmaps;
 
  uint32_t m_BlockSize;
 
  uint32_t m_InodeSize;
 
  size_t m_nGroupDescriptors;
 
#if THREADS || defined(STANDALONE_MUTEXES)
  Mutex m_WriteLock;
 
  Mutex m_InodeTableLoadLock;
#endif
 
  File* m_pRoot;
 
  String m_VolumeLabel;
};
 
#endif