vfs::MountTable Class Reference

挂载表管理器 More...

#include <mount.hpp>

Collaboration diagram for vfs::MountTable:

Public Member Functions
auto	Mount (const char *path, FileSystem *fs, BlockDevice *device) -> Expected< void >
	挂载文件系统到指定路径
auto	Unmount (const char *path) -> Expected< void >
	卸载指定路径的文件系统
auto	Lookup (const char *path) -> MountPoint *
	根据路径查找对应的挂载点
auto	GetRootDentry (MountPoint *mp) -> Dentry *
	获取指定挂载点的根 dentry
auto	FindByMountDentry (const Dentry *dentry) -> MountPoint *
	根据 dentry 查找挂载在其上的文件系统
auto	IsMountPoint (const char *path) -> bool
	检查路径是否是挂载点
auto	GetRootMount () -> MountPoint *
	获取根挂载点
构造/析构函数
	MountTable ()=default
	MountTable (const MountTable &)=delete
	MountTable (MountTable &&)=delete
auto	operator= (const MountTable &) -> MountTable &=delete
auto	operator= (MountTable &&) -> MountTable &=delete
	~MountTable ()=default

Static Public Attributes
static constexpr size_t	kMaxMounts = 16
	最大挂载点数

Private Attributes
MountPoint	mounts_ [kMaxMounts] {}
size_t	mount_count_ {0}
MountPoint *	root_mount_ {nullptr}

Detailed Description

挂载表管理器

Definition at line 34 of file mount.hpp.

Constructor & Destructor Documentation

MountTable() [1/3]

vfs::MountTable::MountTable ( )

default

MountTable() [2/3]

vfs::MountTable::MountTable ( const MountTable &  )

delete

MountTable() [3/3]

vfs::MountTable::MountTable ( MountTable &&  )

delete

~MountTable()

vfs::MountTable::~MountTable ( )

default

Member Function Documentation

FindByMountDentry()

auto vfs::MountTable::FindByMountDentry

(

const Dentry *

dentry

)

-> MountPoint*

根据 dentry 查找挂载在其上的文件系统

Parameters

dentry

目标 dentry

Returns

MountPoint* 挂载在该 dentry 上的挂载点，未找到返回 nullptr

Definition at line 203 of file mount.cpp.

                                                                      {
  if (dentry == nullptr) {
    return nullptr;
  }
 
  for (size_t i = 0; i < kMaxMounts; ++i) {
    if (mounts_[i].active && mounts_[i].mount_dentry == dentry) {
      return &mounts_[i];
    }
  }
 
  return nullptr;
}

GetRootDentry()

auto vfs::MountTable::GetRootDentry

(

MountPoint *

mp

)

-> Dentry*

获取指定挂载点的根 dentry

Parameters

mp

挂载点

Returns

Dentry* 挂载点根 dentry

Definition at line 196 of file mount.cpp.

                                                        {
  if (mp == nullptr || !mp->active) {
    return nullptr;
  }
  return mp->root_dentry;
}

GetRootMount()

auto vfs::MountTable::GetRootMount

(

)

-> MountPoint*

获取根挂载点

Returns

MountPoint* 根挂载点

Definition at line 232 of file mount.cpp.

{ return root_mount_; }

IsMountPoint()

auto vfs::MountTable::IsMountPoint

(

const char *

path

)

-> bool

检查路径是否是挂载点

Parameters

path

路径

Returns

true 是挂载点

false 不是挂载点

Definition at line 217 of file mount.cpp.

                                                      {
  if (path == nullptr) {
    return false;
  }
 
  for (size_t i = 0; i < kMaxMounts; ++i) {
    if (mounts_[i].active && mounts_[i].mount_path != nullptr &&
        strcmp(mounts_[i].mount_path, path) == 0) {
      return true;
    }
  }
 
  return false;
}

Lookup()

auto vfs::MountTable::Lookup

(

const char *

path

)

-> MountPoint*

根据路径查找对应的挂载点

Parameters

path

文件路径

Returns

MountPoint* 最长前缀匹配的挂载点，未找到返回 nullptr

Definition at line 158 of file mount.cpp.

                                                       {
  if (path == nullptr || path[0] != '/') {
    return nullptr;
  }
 
  MountPoint* best_match = nullptr;
  size_t best_match_len = 0;
 
  for (size_t i = 0; i < kMaxMounts; ++i) {
    if (!mounts_[i].active) {
      continue;
    }
 
    const char* mp_path = mounts_[i].mount_path;
    if (mp_path == nullptr) {
      continue;
    }
 
    size_t mp_len = strlen(mp_path);
 
    // 检查路径是否以挂载路径开头
    if (strncmp(path, mp_path, mp_len) == 0) {
      // 确保是完整匹配或下一个字符是 /，或者是根目录挂载
      char next_char = path[mp_len];
      if (next_char == '\0' || next_char == '/' ||
          (mp_len == 1 && mp_path[0] == '/')) {
        // 选择最长的匹配
        if (mp_len > best_match_len) {
          best_match = &mounts_[i];
          best_match_len = mp_len;
        }
      }
    }
  }
 
  return best_match;
}

Here is the caller graph for this function:

Mount()

auto vfs::MountTable::Mount	(	const char *	path,
		FileSystem *	fs,
		BlockDevice *	device
	)		-> Expected<void>

挂载文件系统到指定路径

Parameters

path	挂载点路径
fs	文件系统实例
device	块设备（可为 nullptr）

Returns

Expected<void>

Precondition

path 必须是已存在的目录

Postcondition

后续对 path 下路径的访问将被重定向到新文件系统

Definition at line 16 of file mount.cpp.

                      {
  if (path == nullptr || fs == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  // 检查挂载点数量
  if (mount_count_ >= kMaxMounts) {
    return std::unexpected(Error(ErrorCode::kFsMountFailed));
  }
 
  // 规范化路径（确保以 / 开头）
  if (path[0] != '/') {
    return std::unexpected(Error(ErrorCode::kFsInvalidPath));
  }
 
  // 检查路径是否已被挂载
  for (size_t i = 0; i < mount_count_; ++i) {
    if (mounts_[i].active && strcmp(mounts_[i].mount_path, path) == 0) {
      return std::unexpected(Error(ErrorCode::kFsAlreadyMounted));
    }
  }
 
  // 挂载文件系统
  auto mount_result = fs->Mount(device);
  if (!mount_result.has_value()) {
    klog::Err("MountTable: failed to mount filesystem '{}': {}", fs->GetName(),
              mount_result.error().message());
    return std::unexpected(Error(ErrorCode::kFsMountFailed));
  }
 
  Inode* root_inode = mount_result.value();
  if (root_inode == nullptr || root_inode->type != FileType::kDirectory) {
    return std::unexpected(Error(ErrorCode::kFsCorrupted));
  }
 
  // 为根 inode 创建 dentry
  auto root_dentry_ptr = kstd::make_unique<Dentry>();
  if (!root_dentry_ptr) {
    fs->Unmount();
    return std::unexpected(Error(ErrorCode::kOutOfMemory));
  }
 
  root_dentry_ptr->inode = root_inode;
  strncpy(root_dentry_ptr->name, "/", sizeof(root_dentry_ptr->name));
 
  // 查找挂载点 dentry（如果是非根挂载）
  Dentry* mount_dentry = nullptr;
  if (strcmp(path, "/") != 0) {
    // 需要找到父文件系统中对应的 dentry
    // 这里简化处理，实际应该通过 VFS Lookup 找到
    // 暂时设置为 nullptr，表示根挂载
  }
 
  // 找到空闲挂载点槽位
  size_t slot = 0;
  for (; slot < kMaxMounts; ++slot) {
    if (!mounts_[slot].active) {
      break;
    }
  }
 
  if (slot >= kMaxMounts) {
    // root_dentry_ptr 自动释放（RAII）
    fs->Unmount();
    return std::unexpected(Error(ErrorCode::kFsMountFailed));
  }
 
  // 填充挂载点信息
  mounts_[slot].mount_path = path;
  mounts_[slot].mount_dentry = mount_dentry;
  mounts_[slot].filesystem = fs;
  mounts_[slot].device = device;
  mounts_[slot].root_inode = root_inode;
  mounts_[slot].root_dentry = root_dentry_ptr.release();
  mounts_[slot].active = true;
 
  ++mount_count_;
 
  // 如果是根挂载，设置 root_mount_
  if (strcmp(path, "/") == 0) {
    root_mount_ = &mounts_[slot];
    // 更新 VFS 根 dentry
    extern void SetRootDentry(Dentry*);
    SetRootDentry(mounts_[slot].root_dentry);
  }
 
  klog::Info("MountTable: mounted '{}' on '{}'", fs->GetName(), path);
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

auto vfs::MountTable::operator= ( const MountTable &  ) -> MountTable &=delete

delete

operator=() [2/2]

auto vfs::MountTable::operator= ( MountTable &&  ) -> MountTable &=delete

delete

Unmount()

auto vfs::MountTable::Unmount

(

const char *

path

)

-> Expected<void>

卸载指定路径的文件系统

Parameters

path

挂载点路径

Returns

Expected<void>

Definition at line 108 of file mount.cpp.

                                                           {
  if (path == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  // 查找挂载点
  MountPoint* mp = nullptr;
  size_t mp_index = 0;
  for (size_t i = 0; i < kMaxMounts; ++i) {
    if (mounts_[i].active && strcmp(mounts_[i].mount_path, path) == 0) {
      mp = &mounts_[i];
      mp_index = i;
      break;
    }
  }
 
  if (mp == nullptr) {
    return std::unexpected(Error(ErrorCode::kFsNotMounted));
  }
 
  // 卸载文件系统
  auto result = mp->filesystem->Unmount();
  if (!result.has_value()) {
    return std::unexpected(result.error());
  }
 
  // 清理挂载点（RAII）
  etl::unique_ptr<Dentry> root_guard(mp->root_dentry);
 
  mp->active = false;
  mp->mount_path = nullptr;
  mp->mount_dentry = nullptr;
  mp->filesystem = nullptr;
  mp->device = nullptr;
  mp->root_inode = nullptr;
  mp->root_dentry = nullptr;
 
  --mount_count_;
 
  // 如果是根挂载，清除 root_mount_
  if (root_mount_ == &mounts_[mp_index]) {
    root_mount_ = nullptr;
    extern void SetRootDentry(Dentry*);
    SetRootDentry(nullptr);
  }
 
  klog::Info("MountTable: unmounted '{}'", path);
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

kMaxMounts

constexpr size_t vfs::MountTable::kMaxMounts = 16

staticconstexpr

最大挂载点数

Definition at line 37 of file mount.hpp.

mount_count_

size_t vfs::MountTable::mount_count_ {0}

private

Definition at line 105 of file mount.hpp.

{0};

mounts_

MountPoint vfs::MountTable::mounts_[kMaxMounts] {}

private

Definition at line 104 of file mount.hpp.

{};

root_mount_

MountPoint* vfs::MountTable::root_mount_ {nullptr}

private

Definition at line 106 of file mount.hpp.

{nullptr};

---

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

• /workspaces/SimpleKernel/src/filesystem/vfs/include/mount.hpp
• /workspaces/SimpleKernel/src/filesystem/vfs/mount.cpp