ramfs.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "filesystem.hpp"
#include "vfs.hpp"
 
namespace ramfs {
 
class RamFs : public vfs::FileSystem {
 public:
 
  RamFs();
 
  ~RamFs() override;
 
  // 禁止拷贝和移动
  RamFs(const RamFs&) = delete;
  RamFs(RamFs&&) = delete;
  auto operator=(const RamFs&) -> RamFs& = delete;
  auto operator=(RamFs&&) -> RamFs& = delete;
 
 
  [[nodiscard]] auto GetName() const -> const char* override;
 
  auto Mount(vfs::BlockDevice* device) -> Expected<vfs::Inode*> override;
 
  auto Unmount() -> Expected<void> override;
 
  auto Sync() -> Expected<void> override;
 
  auto AllocateInode() -> Expected<vfs::Inode*> override;
 
  auto FreeInode(vfs::Inode* inode) -> Expected<void> override;
 
  [[nodiscard]] auto GetRootInode() const -> vfs::Inode*;
 
  [[nodiscard]] auto GetFileOps() -> vfs::FileOps*;
 
  class RamFsInodeOps : public vfs::InodeOps {
   public:
    explicit RamFsInodeOps(RamFs* fs) : fs_(fs) {}
    auto Lookup(vfs::Inode* dir, const char* name)
        -> Expected<vfs::Inode*> override;
    auto Create(vfs::Inode* dir, const char* name, vfs::FileType type)
        -> Expected<vfs::Inode*> override;
    auto Unlink(vfs::Inode* dir, const char* name) -> Expected<void> override;
    auto Mkdir(vfs::Inode* dir, const char* name)
        -> Expected<vfs::Inode*> override;
    auto Rmdir(vfs::Inode* dir, const char* name) -> Expected<void> override;
 
   private:
    RamFs* fs_;
  };
 
  class RamFsFileOps : public vfs::FileOps {
   public:
    explicit RamFsFileOps(RamFs* fs) : fs_(fs) {}
    auto Read(vfs::File* file, void* buf, size_t count)
        -> Expected<size_t> override;
    auto Write(vfs::File* file, const void* buf, size_t count)
        -> Expected<size_t> override;
    auto Seek(vfs::File* file, int64_t offset, vfs::SeekWhence whence)
        -> Expected<uint64_t> override;
    auto Close(vfs::File* file) -> Expected<void> override;
    auto ReadDir(vfs::File* file, vfs::DirEntry* dirent, size_t count)
        -> Expected<size_t> override;
 
   private:
    RamFs* fs_;
  };
 
  friend class RamFsInodeOps;
  friend class RamFsFileOps;
 
 private:
  struct RamInode {
    vfs::Inode inode;
    void* data;
    size_t capacity;
    size_t child_count;
    RamInode* next_free;
  };
 
  struct RamDirEntry {
    char name[256];
    vfs::Inode* inode;
  };
 
  static constexpr size_t kMaxInodes = 1024;
  static constexpr size_t kInitialCapacity = 256;
 
  // Static pool constants — zero heap allocation
  static constexpr size_t kFileDataPoolSize = 1024UL * 1024UL;
  static constexpr size_t kDirDataPoolSize = 256UL * 1024UL;
 
  RamInode inodes_[kMaxInodes];
  RamInode* free_list_{nullptr};
  vfs::Inode* root_inode_{nullptr};
  size_t used_inodes_{0};
  bool mounted_{false};
 
  // Static pools (bump allocator, reset on Unmount)
  alignas(16) uint8_t file_data_pool_[kFileDataPoolSize];
  size_t file_data_pool_used_{0};
  alignas(alignof(RamDirEntry)) uint8_t dir_data_pool_[kDirDataPoolSize];
  size_t dir_data_pool_used_{0};
 
  // 操作实例
  RamFsInodeOps inode_ops_;
  RamFsFileOps file_ops_;
 
  // 辅助函数
  auto FindInDirectory(RamInode* dir, const char* name) -> RamDirEntry*;
  auto AddToDirectory(RamInode* dir, const char* name, vfs::Inode* inode)
      -> Expected<void>;
  auto RemoveFromDirectory(RamInode* dir, const char* name) -> Expected<void>;
  auto IsDirectoryEmpty(RamInode* dir) -> bool;
  auto ExpandFile(RamInode* inode, size_t new_size) -> Expected<void>;
  auto AllocateFileData(size_t size) -> void*;
  auto AllocateDirEntries(size_t count) -> RamDirEntry*;
};
 
}  // namespace ramfs