ramfs 文件系统实现 More...

#include <ramfs.hpp>

Inheritance diagram for ramfs::RamFs:

Collaboration diagram for ramfs::RamFs:

Classes
struct	RamDirEntry
	目录项结构（存储在目录的 data 中） More...

class	RamFsFileOps
	File 操作实现类 More...

class	RamFsInodeOps
	Inode 操作实现类 More...

struct	RamInode
	ramfs 内部 inode 数据 More...

Public Member Functions
auto	GetName () const -> const char *override
	获取文件系统类型名

auto	Mount (vfs::BlockDevice device) -> Expected< vfs::Inode > override
	挂载 ramfs

auto	Unmount () -> Expected< void > override
	卸载 ramfs

auto	Sync () -> Expected< void > override
	同步数据到磁盘（ramfs 无操作）

auto	AllocateInode () -> Expected< vfs::Inode * > override
	分配新 inode

auto	FreeInode (vfs::Inode *inode) -> Expected< void > override
	释放 inode

auto	GetRootInode () const -> vfs::Inode *
	获取根 inode

auto	GetFileOps () -> vfs::FileOps *
	获取文件操作实例

构造/析构函数
	RamFs ()
	构造函数

	~RamFs () override
	析构函数

	RamFs (const RamFs &)=delete

	RamFs (RamFs &&)=delete

auto	operator= (const RamFs &) -> RamFs &=delete

auto	operator= (RamFs &&) -> RamFs &=delete

Public Member Functions inherited from vfs::FileSystem
virtual	~FileSystem ()=default

Private Member Functions
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 *
	Bump-allocate `size` bytes from the file data pool.

auto	AllocateDirEntries (size_t count) -> RamDirEntry *
	Bump-allocate space for `count` RamDirEntry from the dir pool.

Private Attributes
RamInode	inodes_ [kMaxInodes]

RamInode *	free_list_ {nullptr}
	空闲 inode 链表头

vfs::Inode *	root_inode_ {nullptr}
	根目录 inode

size_t	used_inodes_ {0}
	已使用的 inode 数量

bool	mounted_ {false}
	是否已挂载

uint8_t	file_data_pool_ [kFileDataPoolSize]

size_t	file_data_pool_used_ {0}

uint8_t	dir_data_pool_ [kDirDataPoolSize]

size_t	dir_data_pool_used_ {0}

RamFsInodeOps	inode_ops_

RamFsFileOps	file_ops_

Static Private Attributes
static constexpr size_t	kMaxInodes = 1024

static constexpr size_t	kInitialCapacity = 256
	初始文件容量

static constexpr size_t	kFileDataPoolSize = 1024UL * 1024UL
	File data pool: 1 MB for regular file content.

static constexpr size_t	kDirDataPoolSize = 256UL * 1024UL
	Dir data pool: 256 KB for directory entry arrays.

Friends
class	RamFsInodeOps

class	RamFsFileOps

Detailed Description

ramfs 文件系统实现

纯内存文件系统，所有数据存储在内存中，适合用作 rootfs

Definition at line 16 of file ramfs.hpp.

Constructor & Destructor Documentation

◆ RamFs() [1/3]

ramfs::RamFs::RamFs ( )

构造函数

Definition at line 15 of file ramfs.cpp.

    : inodes_{},
      free_list_(nullptr),
      root_inode_(nullptr),
      used_inodes_(0),
      mounted_(false),
      file_data_pool_{},
      file_data_pool_used_(0),
      dir_data_pool_{},
      dir_data_pool_used_(0),
      inode_ops_(this),
      file_ops_(this) {}

◆ ~RamFs()

ramfs::RamFs::~RamFs ( )

override

析构函数

Definition at line 28 of file ramfs.cpp.

              {
  if (mounted_) {
    Unmount();
  }
}

Here is the call graph for this function:

◆ RamFs() [2/3]

ramfs::RamFs::RamFs ( const RamFs & )

delete

◆ RamFs() [3/3]

ramfs::RamFs::RamFs ( RamFs && )

delete

Member Function Documentation

◆ AddToDirectory()

auto ramfs::RamFs::AddToDirectory	(	RamInode *	dir,
		const char *	name,
		vfs::Inode *	inode
	)		-> Expected<void>

private

Definition at line 497 of file ramfs.cpp.

                      {
  if (dir == nullptr || name == nullptr || inode == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  if (dir->inode.type != FileType::kDirectory) {
    return std::unexpected(Error(ErrorCode::kFsNotADirectory));
  }
 
  // 检查是否已存在
  if (FindInDirectory(dir, name) != nullptr) {
    return std::unexpected(Error(ErrorCode::kFsFileExists));
  }
 
  // 扩展目录容量
  size_t current_entries = dir->capacity / sizeof(RamDirEntry);
  if (dir->child_count >= current_entries) {
    size_t new_capacity = (current_entries == 0) ? 16 : current_entries * 2;
    RamDirEntry* new_data = AllocateDirEntries(new_capacity);
    if (new_data == nullptr) {
      return std::unexpected(Error(ErrorCode::kOutOfMemory));
    }
 
    // 复制旧数据
    if (dir->data != nullptr) {
      memcpy(new_data, dir->data, dir->child_count * sizeof(RamDirEntry));
      // Old allocation stays in pool (bump allocator — no per-entry free)
    }
 
    dir->data = new_data;
    dir->capacity = new_capacity * sizeof(RamDirEntry);
  }
 
  // 添加新条目
  RamDirEntry* entries = static_cast<RamDirEntry*>(dir->data);
  RamDirEntry* new_entry = &entries[dir->child_count];
  strncpy(new_entry->name, name, sizeof(new_entry->name) - 1);
  new_entry->name[sizeof(new_entry->name) - 1] = '\0';
  new_entry->inode = inode;
 
  ++dir->child_count;
  ++inode->link_count;
 
  return {};
}

◆ AllocateDirEntries()

auto ramfs::RamFs::AllocateDirEntries ( size_t count ) -> RamDirEntry*

private

Bump-allocate space for count RamDirEntry from the dir pool.

Definition at line 620 of file ramfs.cpp.

                                                           {
  size_t bytes = count * sizeof(RamDirEntry);
  // Align up to alignof(RamDirEntry)
  static constexpr size_t kAlign = alignof(RamDirEntry);
  size_t aligned = (bytes + kAlign - 1UL) & ~(kAlign - 1UL);
  if (dir_data_pool_used_ + aligned > kDirDataPoolSize) {
    return nullptr;
  }
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  auto* ptr =
      reinterpret_cast<RamDirEntry*>(&dir_data_pool_[dir_data_pool_used_]);
  dir_data_pool_used_ += aligned;
  return ptr;
}

◆ AllocateFileData()

auto ramfs::RamFs::AllocateFileData ( size_t size ) -> void*

private

Bump-allocate size bytes from the file data pool.

Definition at line 609 of file ramfs.cpp.

                                                 {
  // Align up to 16 bytes
  size_t aligned = (size + 15UL) & ~15UL;
  if (file_data_pool_used_ + aligned > kFileDataPoolSize) {
    return nullptr;
  }
  void* ptr = &file_data_pool_[file_data_pool_used_];
  file_data_pool_used_ += aligned;
  return ptr;
}

◆ AllocateInode()

auto ramfs::RamFs::AllocateInode ( ) -> Expected<vfs::Inode*>

overridevirtual

分配新 inode

Returns: Expected<vfs::Inode*> 新分配的 inode 或错误

Implements vfs::FileSystem.

Definition at line 109 of file ramfs.cpp.

                                              {
  if (free_list_ == nullptr) {
    return std::unexpected(Error(ErrorCode::kOutOfMemory));
  }
 
  RamInode* ram_inode = free_list_;
  free_list_ = free_list_->next_free;
 
  // 初始化 inode
  ram_inode->inode.ino = reinterpret_cast<uint64_t>(&ram_inode->inode);
  ram_inode->inode.type = FileType::kUnknown;
  ram_inode->inode.size = 0;
  ram_inode->inode.permissions = 0644;
  ram_inode->inode.link_count = 1;
  ram_inode->inode.fs_private = ram_inode;
  ram_inode->inode.fs = this;
  ram_inode->inode.ops = &inode_ops_;
 
  ram_inode->data = nullptr;
  ram_inode->capacity = 0;
  ram_inode->child_count = 0;
  ram_inode->next_free = nullptr;
 
  ++used_inodes_;
  return &ram_inode->inode;
}

◆ ExpandFile()

auto ramfs::RamFs::ExpandFile	(	RamInode *	inode,
		size_t	new_size
	)		-> Expected<void>

private

Definition at line 580 of file ramfs.cpp.

                                                                         {
  if (inode == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  if (new_size <= inode->capacity) {
    return {};
  }
 
  // 计算新容量（按 256 字节对齐）
  size_t new_capacity = ((new_size + 255) / 256) * 256;
 
  uint8_t* new_data = static_cast<uint8_t*>(AllocateFileData(new_capacity));
  if (new_data == nullptr) {
    return std::unexpected(Error(ErrorCode::kOutOfMemory));
  }
 
  // 复制旧数据
  if (inode->data != nullptr) {
    memcpy(new_data, inode->data, inode->inode.size);
    // Old allocation stays in pool (bump allocator — no per-block free)
  }
 
  inode->data = new_data;
  inode->capacity = new_capacity;
 
  return {};
}

◆ FindInDirectory()

auto ramfs::RamFs::FindInDirectory	(	RamInode *	dir,
		const char *	name
	)		-> RamDirEntry*

private

Definition at line 481 of file ramfs.cpp.

                                                                           {
  if (dir == nullptr || dir->inode.type != FileType::kDirectory ||
      dir->data == nullptr) {
    return nullptr;
  }
 
  RamDirEntry* entries = static_cast<RamDirEntry*>(dir->data);
  for (size_t i = 0; i < dir->child_count; ++i) {
    if (strcmp(entries[i].name, name) == 0) {
      return &entries[i];
    }
  }
 
  return nullptr;
}

◆ FreeInode()

auto ramfs::RamFs::FreeInode ( vfs::Inode * inode ) -> Expected<void>

overridevirtual

释放 inode

Parameters

inode 要释放的 inode

Returns: Expected<void> 成功或错误

Implements vfs::FileSystem.

Definition at line 136 of file ramfs.cpp.

                                                    {
  if (inode == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  RamInode* ram_inode = static_cast<RamInode*>(inode->fs_private);
 
  // Data lives in static pools; just clear the pointer (no individual reclaim)
  if (ram_inode->data != nullptr) {
    ram_inode->data = nullptr;
  }
 
  // 重置 inode
  ram_inode->inode.type = FileType::kUnknown;
  ram_inode->inode.size = 0;
  ram_inode->inode.fs_private = nullptr;
  ram_inode->inode.ops = nullptr;
 
  ram_inode->capacity = 0;
  ram_inode->child_count = 0;
 
  // 加入空闲链表
  ram_inode->next_free = free_list_;
  free_list_ = ram_inode;
 
  --used_inodes_;
  return {};
}

◆ GetFileOps()

auto ramfs::RamFs::GetFileOps ( ) -> vfs::FileOps*

virtual

获取文件操作实例

Returns: vfs::FileOps* 文件操作实例指针

Implements vfs::FileSystem.

Definition at line 167 of file ramfs.cpp.

167{ return &file_ops_; }

◆ GetName()

auto ramfs::RamFs::GetName ( ) const -> const char*

overridevirtual

获取文件系统类型名

Returns: "ramfs"

Implements vfs::FileSystem.

Definition at line 34 of file ramfs.cpp.

34{ return "ramfs"; }

◆ GetRootInode()

auto ramfs::RamFs::GetRootInode ( ) const -> vfs::Inode*

获取根 inode

Returns: vfs::Inode* 根目录 inode

Definition at line 165 of file ramfs.cpp.

165{ return root_inode_; }

◆ IsDirectoryEmpty()

auto ramfs::RamFs::IsDirectoryEmpty ( RamInode * dir ) -> bool

private

Definition at line 571 of file ramfs.cpp.

                                                  {
  if (dir == nullptr || dir->inode.type != FileType::kDirectory) {
    return true;
  }
 
  // 只包含 . 和 .. 的目录也是空的
  return dir->child_count == 0;
}

◆ Mount()

auto ramfs::RamFs::Mount ( vfs::BlockDevice * device ) -> Expected<vfs::Inode*>

overridevirtual

挂载 ramfs

Parameters

device 必须为 nullptr（ramfs 不需要块设备）

Returns: Expected<vfs::Inode*> 根目录 inode

Postcondition: 返回的 inode->type == vfs::FileType::kDirectory

Implements vfs::FileSystem.

Definition at line 36 of file ramfs.cpp.

                                                         {
  if (mounted_) {
    return std::unexpected(Error(ErrorCode::kFsAlreadyMounted));
  }
 
  if (device != nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  klog::Info("RamFs: mounting...");
 
  // 初始化 inode 空闲链表
  free_list_ = nullptr;
  for (int i = kMaxInodes - 1; i >= 0; --i) {
    inodes_[i].next_free = free_list_;
    free_list_ = &inodes_[i];
  }
 
  // 分配根目录 inode
  auto root_result = AllocateInode();
  if (!root_result.has_value()) {
    return std::unexpected(root_result.error());
  }
 
  root_inode_ = root_result.value();
  root_inode_->type = FileType::kDirectory;
  root_inode_->permissions = 0755;
 
  // 初始化根目录数据
  RamInode* ram_root = static_cast<RamInode*>(root_inode_->fs_private);
  ram_root->data = nullptr;
  ram_root->capacity = 0;
  ram_root->child_count = 0;
 
  used_inodes_ = 1;
  mounted_ = true;
 
  klog::Info("RamFs: mounted successfully");
  return root_inode_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

auto ramfs::RamFs::operator= ( const RamFs & ) -> RamFs &=delete

delete

◆ operator=() [2/2]

auto ramfs::RamFs::operator= ( RamFs && ) -> RamFs &=delete

delete

◆ RemoveFromDirectory()

auto ramfs::RamFs::RemoveFromDirectory	(	RamInode *	dir,
		const char *	name
	)		-> Expected<void>

private

Definition at line 544 of file ramfs.cpp.

                      {
  if (dir == nullptr || name == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  RamDirEntry* entry = FindInDirectory(dir, name);
  if (entry == nullptr) {
    return std::unexpected(Error(ErrorCode::kFsFileNotFound));
  }
 
  // 减少链接计数
  if (entry->inode != nullptr) {
    --entry->inode->link_count;
  }
 
  // 移除条目（将最后一个条目移到此处）
  RamDirEntry* entries = static_cast<RamDirEntry*>(dir->data);
  size_t last_idx = dir->child_count - 1;
  if (entry != &entries[last_idx]) {
    *entry = entries[last_idx];
  }
 
  --dir->child_count;
  return {};
}

◆ Sync()

auto ramfs::RamFs::Sync ( ) -> Expected<void>

overridevirtual

同步数据到磁盘（ramfs 无操作）

Returns: Expected<void> 成功

Implements vfs::FileSystem.

Definition at line 104 of file ramfs.cpp.

                                   {
  // ramfs 是纯内存文件系统，无需同步
  return {};
}

◆ Unmount()

auto ramfs::RamFs::Unmount ( ) -> Expected<void>

overridevirtual

卸载 ramfs

Returns: Expected<void> 成功或错误

Precondition: 没有打开的文件引用此文件系统

Implements vfs::FileSystem.

Definition at line 77 of file ramfs.cpp.

                                      {
  if (!mounted_) {
    return std::unexpected(Error(ErrorCode::kFsNotMounted));
  }
 
  klog::Info("RamFs: unmounting...");
 
  // Clear all inode data pointers (data lives in static pools)
  for (size_t i = 0; i < kMaxInodes; ++i) {
    if (inodes_[i].inode.type != FileType::kUnknown &&
        inodes_[i].data != nullptr) {
      inodes_[i].data = nullptr;
    }
  }
 
  // 重置状态并释放静态池
  free_list_ = nullptr;
  root_inode_ = nullptr;
  used_inodes_ = 0;
  mounted_ = false;
  file_data_pool_used_ = 0;
  dir_data_pool_used_ = 0;
 
  klog::Info("RamFs: unmounted");
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ RamFsFileOps

friend class RamFsFileOps

friend

Definition at line 126 of file ramfs.hpp.

◆ RamFsInodeOps

friend class RamFsInodeOps

friend

Definition at line 125 of file ramfs.hpp.

Member Data Documentation

◆ dir_data_pool_

uint8_t ramfs::RamFs::dir_data_pool_[kDirDataPoolSize]

private

Definition at line 171 of file ramfs.hpp.

◆ dir_data_pool_used_

size_t ramfs::RamFs::dir_data_pool_used_ {0}

private

Definition at line 172 of file ramfs.hpp.

172{0};

◆ file_data_pool_

uint8_t ramfs::RamFs::file_data_pool_[kFileDataPoolSize]

private

Definition at line 169 of file ramfs.hpp.

◆ file_data_pool_used_

size_t ramfs::RamFs::file_data_pool_used_ {0}

private

Definition at line 170 of file ramfs.hpp.

170{0};

◆ file_ops_

RamFsFileOps ramfs::RamFs::file_ops_

private

Definition at line 176 of file ramfs.hpp.

◆ free_list_

RamInode* ramfs::RamFs::free_list_ {nullptr}

private

空闲 inode 链表头

Definition at line 160 of file ramfs.hpp.

160{nullptr};

◆ inode_ops_

RamFsInodeOps ramfs::RamFs::inode_ops_

private

Definition at line 175 of file ramfs.hpp.

◆ inodes_

RamInode ramfs::RamFs::inodes_[kMaxInodes]

private

Definition at line 158 of file ramfs.hpp.

◆ kDirDataPoolSize

constexpr size_t ramfs::RamFs::kDirDataPoolSize = 256UL * 1024UL

staticconstexprprivate

Dir data pool: 256 KB for directory entry arrays.

Definition at line 156 of file ramfs.hpp.

◆ kFileDataPoolSize

constexpr size_t ramfs::RamFs::kFileDataPoolSize = 1024UL * 1024UL

staticconstexprprivate

File data pool: 1 MB for regular file content.

Definition at line 154 of file ramfs.hpp.

◆ kInitialCapacity

constexpr size_t ramfs::RamFs::kInitialCapacity = 256

staticconstexprprivate

初始文件容量

Definition at line 150 of file ramfs.hpp.

◆ kMaxInodes

constexpr size_t ramfs::RamFs::kMaxInodes = 1024

staticconstexprprivate

Definition at line 148 of file ramfs.hpp.

◆ mounted_

bool ramfs::RamFs::mounted_ {false}

private

是否已挂载

Definition at line 166 of file ramfs.hpp.

166{false};

◆ root_inode_

vfs::Inode* ramfs::RamFs::root_inode_ {nullptr}

private

根目录 inode

Definition at line 162 of file ramfs.hpp.

162{nullptr};

◆ used_inodes_

size_t ramfs::RamFs::used_inodes_ {0}

private

已使用的 inode 数量

Definition at line 164 of file ramfs.hpp.

164{0};

The documentation for this class was generated from the following files:

/workspaces/SimpleKernel/src/filesystem/ramfs/include/ramfs.hpp
/workspaces/SimpleKernel/src/filesystem/ramfs/ramfs.cpp

Classes

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ RamFs() [1/3]

◆ ~RamFs()

◆ RamFs() [2/3]

◆ RamFs() [3/3]

Member Function Documentation

◆ AddToDirectory()

◆ AllocateDirEntries()

◆ AllocateFileData()

◆ AllocateInode()

◆ ExpandFile()

◆ FindInDirectory()

◆ FreeInode()

◆ GetFileOps()

◆ GetName()

◆ GetRootInode()

◆ IsDirectoryEmpty()

◆ Mount()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ RemoveFromDirectory()

◆ Sync()

◆ Unmount()

Friends And Related Symbol Documentation

◆ RamFsFileOps

◆ RamFsInodeOps

Member Data Documentation

◆ dir_data_pool_

◆ dir_data_pool_used_

◆ file_data_pool_

◆ file_data_pool_used_

◆ file_ops_

◆ free_list_

◆ inode_ops_

◆ inodes_

◆ kDirDataPoolSize

◆ kFileDataPoolSize

◆ kInitialCapacity

◆ kMaxInodes

◆ mounted_

◆ root_inode_

◆ used_inodes_