vfs Namespace Reference

Classes
class	BlockDevice
	块设备抽象基类 More...
struct	Dentry
	Dentry — 目录项缓存（路径名 ↔ Inode 的映射） More...
struct	DirEntry
	目录项结构（用于 readdir） More...
struct	File
	File — 打开的文件实例（每次 open 产生一个） More...
class	FileOps
	File 操作接口 More...
class	FileSystem
	文件系统类型基类 More...
struct	Inode
	Inode — 文件元数据（独立于路径名） More...
class	InodeOps
	Inode 操作接口 More...
struct	MountPoint
	挂载点 More...
class	MountTable
	挂载表管理器 More...
struct	VfsState
	VFS 全局状态结构体 More...

Enumerations
enum class	FileType : uint8_t {   kUnknown = 0 , kRegular = 1 , kDirectory = 2 , kCharDevice = 3 ,   kBlockDevice = 4 , kSymlink = 5 , kFifo = 6 }
	文件类型 More...
enum class	OpenFlags : uint32_t {   kOReadOnly = 0x0000 , kOWriteOnly = 0x0001 , kOReadWrite = 0x0002 , kOCreate = 0x0040 ,   kOTruncate = 0x0200 , kOAppend = 0x0400 , kODirectory = 0x010000 }
	文件打开标志（兼容 Linux O_* 定义） More...
enum class	SeekWhence : int { kSet = 0 , kCur = 1 , kEnd = 2 }
	文件 seek 基准 More...

Functions
auto	Close (File *file) -> Expected< void >
	关闭文件
auto	GetMountTable () -> MountTable &
	获取全局挂载表实例
auto	Init () -> Expected< void >
	VFS 全局初始化
auto	Lookup (const char *path) -> Expected< Dentry * >
	路径解析，查找 dentry
auto	Open (const char *path, OpenFlags flags) -> Expected< File * >
	打开文件
auto	Read (File *file, void *buf, size_t count) -> Expected< size_t >
	从文件读取数据
auto	Write (File *file, const void *buf, size_t count) -> Expected< size_t >
	向文件写入数据
auto	Seek (File *file, int64_t offset, SeekWhence whence) -> Expected< uint64_t >
	调整文件偏移量
auto	MkDir (const char *path) -> Expected< void >
	创建目录
auto	RmDir (const char *path) -> Expected< void >
	删除目录
auto	Unlink (const char *path) -> Expected< void >
	删除文件
auto	ReadDir (File *file, DirEntry *dirent, size_t count) -> Expected< size_t >
	读取目录内容
auto	GetRootDentry () -> Dentry *
	获取根目录 dentry
constexpr auto	operator| (OpenFlags lhs, OpenFlags rhs) -> OpenFlags
	按位或
constexpr auto	operator& (OpenFlags lhs, OpenFlags rhs) -> OpenFlags
	按位与
constexpr auto	operator~ (OpenFlags flags) -> OpenFlags
	按位取反
constexpr auto	operator|= (OpenFlags &lhs, OpenFlags rhs) -> OpenFlags &
	按位或赋值
constexpr auto	operator&= (OpenFlags &lhs, OpenFlags rhs) -> OpenFlags &
	按位与赋值
constexpr auto	operator== (OpenFlags flags, uint32_t val) -> bool
	检查 OpenFlags 是否为零（无标志位设置）
constexpr auto	operator!= (OpenFlags flags, uint32_t val) -> bool
	检查 OpenFlags 是否不为零
auto	GetVfsState () -> VfsState &
auto	SkipLeadingSlashes (const char *path) -> const char *
	跳过路径中的前导斜杠
auto	CopyPathComponent (const char *src, char *dst, size_t dst_size) -> size_t
	复制路径组件到缓冲区
auto	FindChild (Dentry *parent, const char *name) -> Dentry *
	在 dentry 的子节点中查找指定名称
auto	AddChild (Dentry *parent, Dentry *child) -> void
	添加子 dentry
auto	RemoveChild (Dentry *parent, Dentry *child) -> void
	从父 dentry 中移除子 dentry
auto	SetRootDentry (Dentry *dentry) -> void
auto	GetMountTableInternal () -> MountTable *

Variables
static constexpr size_t	kMaxPathLength = 4096
	VFS 路径最大长度限制

Detailed Description

Copyright

Copyright The SimpleKernel Contributors

Enumeration Type Documentation

FileType

enum class vfs::FileType : uint8_t

strong

文件类型

Enumerator
kUnknown
kRegular	普通文件
kDirectory	目录
kCharDevice	字符设备
kBlockDevice	块设备
kSymlink	符号链接
kFifo	命名管道

Definition at line 22 of file vfs_types.hpp.

                    : uint8_t {
  kUnknown = 0,
  kRegular = 1,
  kDirectory = 2,
  kCharDevice = 3,
  kBlockDevice = 4,
  kSymlink = 5,
  kFifo = 6,
};

OpenFlags

enum class vfs::OpenFlags : uint32_t

strong

文件打开标志（兼容 Linux O_* 定义）

Enumerator
kOReadOnly
kOWriteOnly
kOReadWrite
kOCreate
kOTruncate
kOAppend
kODirectory	必须是目录

Definition at line 39 of file vfs_types.hpp.

                     : uint32_t {
  kOReadOnly = 0x0000,
  kOWriteOnly = 0x0001,
  kOReadWrite = 0x0002,
  kOCreate = 0x0040,
  kOTruncate = 0x0200,
  kOAppend = 0x0400,
  kODirectory = 0x010000,
};

SeekWhence

enum class vfs::SeekWhence : int

strong

文件 seek 基准

Enumerator
kSet	从文件开头
kCur	从当前位置
kEnd	从文件末尾

Definition at line 94 of file vfs_types.hpp.

                      : int {
  kSet = 0,
  kCur = 1,
  kEnd = 2,
};

Function Documentation

AddChild()

auto vfs::AddChild	(	Dentry *	parent,
		Dentry *	child
	)		-> void

添加子 dentry

Definition at line 53 of file vfs.cpp.

                                                     {
  if (parent == nullptr || child == nullptr) {
    return;
  }
 
  child->parent = parent;
  child->next_sibling = parent->children;
  parent->children = child;
}

Here is the caller graph for this function:

Close()

auto vfs::Close

(

File *

file

)

-> Expected< void >

关闭文件

Parameters

file

文件对象

Returns

Expected<void> 成功或错误

Precondition

file != nullptr

Note

会调用文件系统特定的 close 回调

关闭后 File 指针失效，不应再使用

Definition at line 15 of file close.cpp.

                                         {
  if (file == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  if (file->ops != nullptr) {
    auto result = file->ops->Close(file);
    if (!result.has_value()) {
      return result;
    }
  }
 
  if (file->dentry != nullptr && file->dentry->ref_count > 0) {
    file->dentry->ref_count--;
  }
 
  etl::unique_ptr<File> file_guard(file);
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

CopyPathComponent()

auto vfs::CopyPathComponent	(	const char *	src,
		char *	dst,
		size_t	dst_size
	)		-> size_t

复制路径组件到缓冲区

Parameters

src	源路径（当前位置）
dst	目标缓冲区
dst_size	缓冲区大小

Returns

复制的长度

Definition at line 29 of file vfs.cpp.

                                                                              {
  size_t i = 0;
  while (*src != '\0' && *src != '/' && i < dst_size - 1) {
    dst[i++] = *src++;
  }
  dst[i] = '\0';
  return i;
}

Here is the caller graph for this function:

FindChild()

auto vfs::FindChild	(	Dentry *	parent,
		const char *	name
	)		-> Dentry *

在 dentry 的子节点中查找指定名称

Definition at line 38 of file vfs.cpp.

                                                            {
  if (parent == nullptr || name == nullptr) {
    return nullptr;
  }
 
  Dentry* child = parent->children;
  while (child != nullptr) {
    if (strcmp(child->name, name) == 0) {
      return child;
    }
    child = child->next_sibling;
  }
  return nullptr;
}

Here is the caller graph for this function:

GetMountTable()

auto vfs::GetMountTable

(

)

-> MountTable&

获取全局挂载表实例

Returns

MountTable& 挂载表引用

Definition at line 234 of file mount.cpp.

                                    {
  static MountTable instance;
  return instance;
}

Here is the caller graph for this function:

GetMountTableInternal()

auto vfs::GetMountTableInternal

(

)

-> MountTable*

Definition at line 104 of file vfs.cpp.

                                            {
  return GetVfsState().mount_table;
}

Here is the call graph for this function:

GetRootDentry()

auto vfs::GetRootDentry

(

)

-> Dentry*

获取根目录 dentry

Returns

Dentry* 根目录 dentry

Precondition

VFS 已初始化且根文件系统已挂载

Note

返回 nullptr 表示根文件系统未挂载

返回的指针由 VFS 内部管理，不应释放

Definition at line 96 of file vfs.cpp.

{ return GetVfsState().root_dentry; }

Here is the call graph for this function:

GetVfsState()

auto vfs::GetVfsState

(

)

-> VfsState &

Definition at line 17 of file vfs.cpp.

                                {
  static VfsState state;
  return state;
}

Here is the caller graph for this function:

Init()

auto vfs::Init

(

)

-> Expected<void>

VFS 全局初始化

Returns

Expected<void> 成功或错误

Postcondition

VFS 子系统已准备好接受挂载请求

Note

线程安全：应在系统启动时单线程调用

幂等性：重复调用会返回成功（无操作）

Definition at line 80 of file vfs.cpp.

                              {
  if (GetVfsState().initialized) {
    return {};
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  klog::Info("VFS: initializing...");
 
  // 初始化挂载表（使用全局单例，与 GetMountTable() 统一）
  GetVfsState().mount_table = &GetMountTable();
 
  GetVfsState().initialized = true;
  klog::Info("VFS: initialization complete");
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

Lookup()

auto vfs::Lookup

(

const char *

path

)

-> Expected<Dentry*>

路径解析，查找 dentry

Parameters

path	绝对路径（以 / 开头）

Returns

Expected<Dentry*> 找到的 dentry 或错误

Precondition

path != nullptr && path[0] == '/'

Note

线程安全：是，内部使用 MountTable 锁

会自动跨越挂载点解析路径

Definition at line 14 of file lookup.cpp.

                                                   {
  if (!GetVfsState().initialized) {
    return std::unexpected(Error(ErrorCode::kFsNotMounted));
  }
 
  if (path == nullptr || path[0] != '/') {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  // 注意：Lookup 是内部函数，由持锁的上层 VFS 函数（Open/MkDir 等）调用，
  // 此处不需要额外加锁，否则会导致 SpinLock 递归死锁。
  // 空路径或根目录
  if (path[0] == '/' && (path[1] == '\0' || path[1] == '/')) {
    if (GetVfsState().root_dentry == nullptr) {
      return std::unexpected(Error(ErrorCode::kFsNotMounted));
    }
    return GetVfsState().root_dentry;
  }
 
  // 查找路径对应的挂载点
  MountPoint* mp = GetVfsState().mount_table->Lookup(path);
  if (mp == nullptr || mp->root_dentry == nullptr) {
    return std::unexpected(Error(ErrorCode::kFsNotMounted));
  }
 
  // 从挂载点根开始解析路径
  Dentry* current = mp->root_dentry;
  const char* p = SkipLeadingSlashes(path);
 
  // 如果挂载路径不是根，需要跳过挂载路径部分
  if (mp->mount_path != nullptr && strcmp(mp->mount_path, "/") != 0) {
    const char* mount_path = SkipLeadingSlashes(mp->mount_path);
    while (*mount_path != '\0') {
      char component[256];
      size_t len = CopyPathComponent(mount_path, component, sizeof(component));
      if (len == 0) {
        break;
      }
      mount_path += len;
      mount_path = SkipLeadingSlashes(mount_path);
 
      // 跳过挂载路径的组件
      len = CopyPathComponent(p, component, sizeof(component));
      if (len == 0) {
        break;
      }
      p += len;
      p = SkipLeadingSlashes(p);
    }
  }
 
  // 逐级解析路径组件
  char component[256];
  while (*p != '\0') {
    // 检查当前 dentry 是否是目录
    if (current->inode == nullptr ||
        current->inode->type != FileType::kDirectory) {
      return std::unexpected(Error(ErrorCode::kFsNotADirectory));
    }
 
    // 提取路径组件
    size_t len = CopyPathComponent(p, component, sizeof(component));
    if (len == 0) {
      break;
    }
    p += len;
    p = SkipLeadingSlashes(p);
 
    // 处理 "." 和 ".."
    if (strcmp(component, ".") == 0) {
      continue;
    }
    if (strcmp(component, "..") == 0) {
      if (current->parent != nullptr) {
        current = current->parent;
      }
      continue;
    }
 
    // 在子节点中查找
    Dentry* child = FindChild(current, component);
    if (child == nullptr) {
      // 尝试通过 inode ops 查找
      if (current->inode->ops != nullptr) {
        auto result = current->inode->ops->Lookup(current->inode, component);
        if (!result.has_value()) {
          return std::unexpected(Error(ErrorCode::kFsFileNotFound));
        }
 
        // 创建新的 dentry
        auto new_child = kstd::make_unique<Dentry>();
        if (!new_child) {
          return std::unexpected(Error(ErrorCode::kOutOfMemory));
        }
 
        strncpy(new_child->name, component, sizeof(new_child->name) - 1);
        new_child->name[sizeof(new_child->name) - 1] = '\0';
        new_child->inode = result.value();
        child = new_child.get();
        AddChild(current, new_child.release());
      } else {
        return std::unexpected(Error(ErrorCode::kFsFileNotFound));
      }
    }
 
    current = child;
 
    // 检查是否遇到挂载点
    if (current->inode != nullptr) {
      MountPoint* next_mp =
          GetVfsState().mount_table->FindByMountDentry(current);
      if (next_mp != nullptr && next_mp != mp) {
        mp = next_mp;
        current = next_mp->root_dentry;
      }
    }
  }
 
  return current;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MkDir()

auto vfs::MkDir

(

const char *

path

)

-> Expected<void>

创建目录

Parameters

path

目录路径

Returns

Expected<void> 成功或错误

Precondition

path != nullptr

Note

父目录必须存在

如果目录已存在会返回错误

Definition at line 14 of file mkdir.cpp.

                                               {
  if (path == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  // 解析父目录路径和目录名
  char parent_path[512];
  char dir_name[256];
  const char* last_slash = strrchr(path, '/');
  if (last_slash == nullptr || last_slash == path) {
    strncpy(parent_path, "/", sizeof(parent_path));
    const char* name_start = path[0] == '/' ? path + 1 : path;
    if (strlen(name_start) >= sizeof(dir_name)) {
      return std::unexpected(Error(ErrorCode::kFsInvalidPath));
    }
    strncpy(dir_name, name_start, sizeof(dir_name));
  } else {
    size_t parent_len = last_slash - path;
    if (parent_len >= sizeof(parent_path)) {
      return std::unexpected(Error(ErrorCode::kFsInvalidPath));
    }
    strncpy(parent_path, path, parent_len);
    parent_path[parent_len] = '\0';
    if (strlen(last_slash + 1) >= sizeof(dir_name)) {
      return std::unexpected(Error(ErrorCode::kFsInvalidPath));
    }
    strncpy(dir_name, last_slash + 1, sizeof(dir_name));
  }
  dir_name[sizeof(dir_name) - 1] = '\0';
 
  // 查找父目录
  auto parent_result = Lookup(parent_path);
  if (!parent_result.has_value()) {
    return std::unexpected(parent_result.error());
  }
 
  Dentry* parent_dentry = parent_result.value();
  if (parent_dentry->inode == nullptr ||
      parent_dentry->inode->type != FileType::kDirectory) {
    return std::unexpected(Error(ErrorCode::kFsNotADirectory));
  }
 
  // 检查目录是否已存在
  if (FindChild(parent_dentry, dir_name) != nullptr) {
    return std::unexpected(Error(ErrorCode::kFsFileExists));
  }
 
  // 创建目录
  if (parent_dentry->inode->ops == nullptr) {
    return std::unexpected(Error(ErrorCode::kDeviceNotSupported));
  }
 
  auto result =
      parent_dentry->inode->ops->Mkdir(parent_dentry->inode, dir_name);
  if (!result.has_value()) {
    return std::unexpected(result.error());
  }
 
  // 创建 dentry
  auto new_dentry = kstd::make_unique<Dentry>();
  if (!new_dentry) {
    return std::unexpected(Error(ErrorCode::kOutOfMemory));
  }
 
  strncpy(new_dentry->name, dir_name, sizeof(new_dentry->name) - 1);
  new_dentry->name[sizeof(new_dentry->name) - 1] = '\0';
  new_dentry->inode = result.value();
  AddChild(parent_dentry, new_dentry.release());
 
  klog::Debug("VFS: created directory '{}'", path);
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

Open()

auto vfs::Open	(	const char *	path,
		OpenFlags	flags
	)		-> Expected<File*>

打开文件

Parameters

path	文件路径
flags	打开标志

Returns

Expected<File*> 文件对象或错误

Precondition

path != nullptr

Postcondition

成功时返回有效的 File 对象

Note

调用者负责调用 Close() 释放 File 对象

若 flags 包含 kOCreate，文件不存在时会自动创建

Definition at line 14 of file open.cpp.

                                                                {
  if (!GetVfsState().initialized) {
    return std::unexpected(Error(ErrorCode::kFsNotMounted));
  }
 
  if (path == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  if (strlen(path) >= kMaxPathLength) {
    return std::unexpected(Error(ErrorCode::kFsInvalidPath));
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  // 查找或创建 dentry
  auto lookup_result = Lookup(path);
  Dentry* dentry = nullptr;
 
  if (!lookup_result.has_value()) {
    // 文件不存在，检查是否需要创建
    if ((flags & OpenFlags::kOCreate) == 0U) {
      return std::unexpected(lookup_result.error());
    }
 
    // 创建新文件
    // 找到父目录路径
    char parent_path[512];
    char file_name[256];
    const char* last_slash = strrchr(path, '/');
    if (last_slash == nullptr || last_slash == path) {
      strncpy(parent_path, "/", sizeof(parent_path));
      const char* name_start = path[0] == '/' ? path + 1 : path;
      if (strlen(name_start) >= sizeof(file_name)) {
        return std::unexpected(Error(ErrorCode::kFsInvalidPath));
      }
      strncpy(file_name, name_start, sizeof(file_name));
    } else {
      size_t parent_len = last_slash - path;
      if (parent_len >= sizeof(parent_path)) {
        return std::unexpected(Error(ErrorCode::kFsInvalidPath));
      }
      strncpy(parent_path, path, parent_len);
      parent_path[parent_len] = '\0';
      if (strlen(last_slash + 1) >= sizeof(file_name)) {
        return std::unexpected(Error(ErrorCode::kFsInvalidPath));
      }
      strncpy(file_name, last_slash + 1, sizeof(file_name));
    }
    file_name[sizeof(file_name) - 1] = '\0';
 
    // 查找父目录
    auto parent_result = Lookup(parent_path);
    if (!parent_result.has_value()) {
      return std::unexpected(parent_result.error());
    }
 
    Dentry* parent_dentry = parent_result.value();
    if (parent_dentry->inode == nullptr ||
        parent_dentry->inode->type != FileType::kDirectory) {
      return std::unexpected(Error(ErrorCode::kFsNotADirectory));
    }
 
    // 创建文件
    if (parent_dentry->inode->ops == nullptr) {
      return std::unexpected(Error(ErrorCode::kDeviceNotSupported));
    }
 
    auto create_result = parent_dentry->inode->ops->Create(
        parent_dentry->inode, file_name, FileType::kRegular);
    if (!create_result.has_value()) {
      return std::unexpected(create_result.error());
    }
 
    // 创建 dentry
    auto new_dentry = kstd::make_unique<Dentry>();
    if (!new_dentry) {
      return std::unexpected(Error(ErrorCode::kOutOfMemory));
    }
 
    strncpy(new_dentry->name, file_name, sizeof(new_dentry->name) - 1);
    new_dentry->name[sizeof(new_dentry->name) - 1] = '\0';
    new_dentry->inode = create_result.value();
    dentry = new_dentry.get();
    AddChild(parent_dentry, new_dentry.release());
  } else {
    dentry = lookup_result.value();
  }
 
  if (dentry == nullptr || dentry->inode == nullptr) {
    return std::unexpected(Error(ErrorCode::kFsCorrupted));
  }
 
  // 检查打开模式
  if ((flags & OpenFlags::kODirectory) != 0U &&
      dentry->inode->type != FileType::kDirectory) {
    return std::unexpected(Error(ErrorCode::kFsNotADirectory));
  }
 
  // 创建 File 对象
  auto new_file = kstd::make_unique<File>();
  if (!new_file) {
    return std::unexpected(Error(ErrorCode::kOutOfMemory));
  }
  File* file = new_file.release();
 
  file->inode = dentry->inode;
  file->dentry = dentry;
  file->offset = 0;
  file->flags = flags;
  dentry->ref_count++;
 
  // 从文件系统获取 FileOps
  if (file->inode != nullptr && file->inode->fs != nullptr) {
    file->ops = file->inode->fs->GetFileOps();
  }
 
  // 处理 O_TRUNC
  if ((flags & OpenFlags::kOTruncate) != 0U &&
      dentry->inode->type == FileType::kRegular) {
    // 截断文件，由具体文件系统处理
    // 这里不直接操作，而是通过后续的 write 来处理
  }
 
  klog::Debug("VFS: opened '{}', flags={:#x}", path,
              static_cast<uint32_t>(flags));
  return file;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

constexpr auto vfs::operator!= ( OpenFlags  flags, uint32_t  val  ) -> bool

inlineconstexpr

检查 OpenFlags 是否不为零

Definition at line 88 of file vfs_types.hpp.

            {
  return static_cast<uint32_t>(flags) != val;
}

operator&()

constexpr auto vfs::operator& ( OpenFlags  lhs, OpenFlags  rhs  ) -> OpenFlags

inlineconstexpr

按位与

Definition at line 58 of file vfs_types.hpp.

                 {
  return static_cast<OpenFlags>(static_cast<uint32_t>(lhs) &
                                static_cast<uint32_t>(rhs));
}

operator&=()

constexpr auto vfs::operator&= ( OpenFlags &  lhs, OpenFlags  rhs  ) -> OpenFlags&

inlineconstexpr

按位与赋值

Definition at line 76 of file vfs_types.hpp.

                                                                              {
  lhs = lhs & rhs;
  return lhs;
}

operator==()

constexpr auto vfs::operator== ( OpenFlags  flags, uint32_t  val  ) -> bool

inlineconstexpr

检查 OpenFlags 是否为零（无标志位设置）

Definition at line 82 of file vfs_types.hpp.

            {
  return static_cast<uint32_t>(flags) == val;
}

operator|()

constexpr auto vfs::operator| ( OpenFlags  lhs, OpenFlags  rhs  ) -> OpenFlags

inlineconstexpr

按位或

Definition at line 51 of file vfs_types.hpp.

                 {
  return static_cast<OpenFlags>(static_cast<uint32_t>(lhs) |
                                static_cast<uint32_t>(rhs));
}

operator|=()

constexpr auto vfs::operator|= ( OpenFlags &  lhs, OpenFlags  rhs  ) -> OpenFlags&

inlineconstexpr

按位或赋值

Definition at line 70 of file vfs_types.hpp.

                                                                              {
  lhs = lhs | rhs;
  return lhs;
}

operator~()

constexpr auto vfs::operator~ ( OpenFlags  flags ) -> OpenFlags

inlineconstexpr

按位取反

Definition at line 65 of file vfs_types.hpp.

                                                                            {
  return static_cast<OpenFlags>(~static_cast<uint32_t>(flags));
}

Read()

auto vfs::Read	(	File *	file,
		void *	buf,
		size_t	count
	)		-> Expected<size_t>

从文件读取数据

Parameters

file	文件对象
buf	输出缓冲区
count	最大读取字节数

Returns

Expected<size_t> 实际读取的字节数或错误

Precondition

file != nullptr && buf != nullptr

Note

实际读取字节数可能小于 count（到达文件末尾）

会自动更新 file->offset

Definition at line 13 of file read.cpp.

                                                                   {
  if (file == nullptr || buf == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  if (file->ops == nullptr) {
    return std::unexpected(Error(ErrorCode::kDeviceNotSupported));
  }
 
  return file->ops->Read(file, buf, count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadDir()

auto vfs::ReadDir	(	File *	file,
		DirEntry *	dirent,
		size_t	count
	)		-> Expected<size_t>

读取目录内容

Parameters

file	目录文件对象
dirent	输出目录项数组
count	最多读取的条目数

Returns

Expected<size_t> 实际读取的条目数或错误

Precondition

file != nullptr && file->inode->type == FileType::kDirectory

Note

会返回 . 和 .. 目录项

多次调用可遍历整个目录，自动维护偏移量

Definition at line 13 of file readdir.cpp.

                                                                             {
  if (file == nullptr || dirent == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  if (file->inode == nullptr || file->inode->type != FileType::kDirectory) {
    return std::unexpected(Error(ErrorCode::kFsNotADirectory));
  }
 
  if (file->ops == nullptr) {
    return std::unexpected(Error(ErrorCode::kDeviceNotSupported));
  }
 
  return file->ops->ReadDir(file, dirent, count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveChild()

auto vfs::RemoveChild	(	Dentry *	parent,
		Dentry *	child
	)		-> void

从父 dentry 中移除子 dentry

Definition at line 63 of file vfs.cpp.

                                                        {
  if (parent == nullptr || child == nullptr) {
    return;
  }
 
  Dentry** current = &parent->children;
  while (*current != nullptr) {
    if (*current == child) {
      *current = child->next_sibling;
      child->parent = nullptr;
      child->next_sibling = nullptr;
      return;
    }
    current = &(*current)->next_sibling;
  }
}

Here is the caller graph for this function:

RmDir()

auto vfs::RmDir

(

const char *

path

)

-> Expected<void>

删除目录

Parameters

path

目录路径

Returns

Expected<void> 成功或错误

Precondition

path != nullptr

Note

目录必须为空（不含子项）

不能删除挂载点

Definition at line 15 of file rmdir.cpp.

                                               {
  if (path == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  // 解析父目录路径和目录名
  char parent_path[512];
  char dir_name[256];
  const char* last_slash = strrchr(path, '/');
  if (last_slash == nullptr || last_slash == path) {
    strncpy(parent_path, "/", sizeof(parent_path));
    strncpy(dir_name, path[0] == '/' ? path + 1 : path, sizeof(dir_name));
  } else {
    size_t parent_len = last_slash - path;
    if (parent_len >= sizeof(parent_path)) {
      parent_len = sizeof(parent_path) - 1;
    }
    strncpy(parent_path, path, parent_len);
    parent_path[parent_len] = '\0';
    strncpy(dir_name, last_slash + 1, sizeof(dir_name));
  }
  dir_name[sizeof(dir_name) - 1] = '\0';
 
  // 查找父目录
  auto parent_result = Lookup(parent_path);
  if (!parent_result.has_value()) {
    return std::unexpected(parent_result.error());
  }
 
  Dentry* parent_dentry = parent_result.value();
  if (parent_dentry->inode == nullptr) {
    return std::unexpected(Error(ErrorCode::kFsCorrupted));
  }
 
  // 查找目标目录
  Dentry* target_dentry = FindChild(parent_dentry, dir_name);
  if (target_dentry == nullptr) {
    return std::unexpected(Error(ErrorCode::kFsFileNotFound));
  }
 
  if (target_dentry->inode == nullptr ||
      target_dentry->inode->type != FileType::kDirectory) {
    return std::unexpected(Error(ErrorCode::kFsNotADirectory));
  }
 
  // 检查目录是否为空
  if (target_dentry->children != nullptr) {
    return std::unexpected(Error(ErrorCode::kFsNotEmpty));
  }
 
  // 删除目录
  if (parent_dentry->inode->ops == nullptr) {
    return std::unexpected(Error(ErrorCode::kDeviceNotSupported));
  }
 
  auto result =
      parent_dentry->inode->ops->Rmdir(parent_dentry->inode, dir_name);
  if (!result.has_value()) {
    return std::unexpected(result.error());
  }
 
  // 从父目录中移除 dentry
  RemoveChild(parent_dentry, target_dentry);
 
  if (target_dentry->ref_count > 0) {
    target_dentry->deleted = true;
    target_dentry->inode = nullptr;
  } else {
    etl::unique_ptr<Dentry> dentry_guard(target_dentry);
  }
 
  klog::Debug("VFS: removed directory '{}'", path);
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

Seek()

auto vfs::Seek	(	File *	file,
		int64_t	offset,
		SeekWhence	whence
	)		-> Expected<uint64_t>

调整文件偏移量

Parameters

file	文件对象
offset	偏移量
whence	基准位置

Returns

Expected<uint64_t> 新的偏移量或错误

Precondition

file != nullptr

Note

如果 whence 为 kEnd 且 offset 为正，可能超过文件末尾

返回的偏移量是绝对位置（从文件开头计算）

Definition at line 13 of file seek.cpp.

                                                                               {
  if (file == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  if (file->ops != nullptr) {
    return file->ops->Seek(file, offset, whence);
  }
 
  // 默认实现
  uint64_t new_offset = file->offset;
 
  switch (whence) {
    case SeekWhence::kSet:
      if (offset < 0) {
        return std::unexpected(Error(ErrorCode::kInvalidArgument));
      }
      new_offset = static_cast<uint64_t>(offset);
      break;
    case SeekWhence::kCur:
      if (offset < 0 && static_cast<uint64_t>(-offset) > file->offset) {
        return std::unexpected(Error(ErrorCode::kInvalidArgument));
      }
      new_offset =
          static_cast<uint64_t>(static_cast<int64_t>(file->offset) + offset);
      break;
    case SeekWhence::kEnd:
      if (file->inode == nullptr) {
        return std::unexpected(Error(ErrorCode::kFsCorrupted));
      }
      if (offset < 0 && static_cast<uint64_t>(-offset) > file->inode->size) {
        return std::unexpected(Error(ErrorCode::kInvalidArgument));
      }
      new_offset = static_cast<uint64_t>(
          static_cast<int64_t>(file->inode->size) + offset);
      break;
    default:
      return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  file->offset = new_offset;
  return new_offset;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetRootDentry()

auto vfs::SetRootDentry

(

Dentry *

dentry

)

-> void

Definition at line 99 of file vfs.cpp.

                                           {
  GetVfsState().root_dentry = dentry;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SkipLeadingSlashes()

auto vfs::SkipLeadingSlashes

(

const char *

path

)

-> const char *

跳过路径中的前导斜杠

Parameters

path

输入路径

Returns

跳过前导斜杠后的路径指针

Definition at line 22 of file vfs.cpp.

                                                         {
  while (*path == '/') {
    ++path;
  }
  return path;
}

Here is the caller graph for this function:

Unlink()

auto vfs::Unlink

(

const char *

path

)

-> Expected<void>

删除文件

Parameters

path

文件路径

Returns

Expected<void> 成功或错误

Precondition

path != nullptr

Note

不能删除目录（使用 RmDir）

如果多个硬链接，只会减少链接计数

Definition at line 15 of file unlink.cpp.

                                                {
  if (path == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  // 解析父目录路径和文件名
  char parent_path[512];
  char file_name[256];
  const char* last_slash = strrchr(path, '/');
  if (last_slash == nullptr || last_slash == path) {
    strncpy(parent_path, "/", sizeof(parent_path));
    strncpy(file_name, path[0] == '/' ? path + 1 : path, sizeof(file_name));
  } else {
    size_t parent_len = last_slash - path;
    if (parent_len >= sizeof(parent_path)) {
      parent_len = sizeof(parent_path) - 1;
    }
    strncpy(parent_path, path, parent_len);
    parent_path[parent_len] = '\0';
    strncpy(file_name, last_slash + 1, sizeof(file_name));
  }
  file_name[sizeof(file_name) - 1] = '\0';
 
  // 查找父目录
  auto parent_result = Lookup(parent_path);
  if (!parent_result.has_value()) {
    return std::unexpected(parent_result.error());
  }
 
  Dentry* parent_dentry = parent_result.value();
  if (parent_dentry->inode == nullptr) {
    return std::unexpected(Error(ErrorCode::kFsCorrupted));
  }
 
  // 查找目标文件
  Dentry* target_dentry = FindChild(parent_dentry, file_name);
  if (target_dentry == nullptr) {
    return std::unexpected(Error(ErrorCode::kFsFileNotFound));
  }
 
  if (target_dentry->inode == nullptr) {
    return std::unexpected(Error(ErrorCode::kFsCorrupted));
  }
 
  // 不能删除目录
  if (target_dentry->inode->type == FileType::kDirectory) {
    return std::unexpected(Error(ErrorCode::kFsIsADirectory));
  }
 
  // 删除文件
  if (parent_dentry->inode->ops == nullptr) {
    return std::unexpected(Error(ErrorCode::kDeviceNotSupported));
  }
 
  auto result =
      parent_dentry->inode->ops->Unlink(parent_dentry->inode, file_name);
  if (!result.has_value()) {
    return std::unexpected(result.error());
  }
 
  // 从父目录中移除 dentry
  RemoveChild(parent_dentry, target_dentry);
 
  if (target_dentry->ref_count > 0) {
    target_dentry->deleted = true;
    target_dentry->inode = nullptr;
  } else {
    etl::unique_ptr<Dentry> dentry_guard(target_dentry);
  }
 
  klog::Debug("VFS: unlinked '{}'", path);
  return {};
}

Here is the call graph for this function:

Here is the caller graph for this function:

Write()

auto vfs::Write	(	File *	file,
		const void *	buf,
		size_t	count
	)		-> Expected<size_t>

向文件写入数据

Parameters

file	文件对象
buf	输入缓冲区
count	要写入的字节数

Returns

Expected<size_t> 实际写入的字节数或错误

Precondition

file != nullptr && buf != nullptr

Note

文件系统可能需要在写入前扩展文件大小

会自动更新 file->offset 和 file->inode->size

Definition at line 13 of file write.cpp.

                                                                          {
  if (file == nullptr || buf == nullptr) {
    return std::unexpected(Error(ErrorCode::kInvalidArgument));
  }
 
  // 检查写入权限
  LockGuard<SpinLock> guard(GetVfsState().vfs_lock_);
  if ((file->flags & OpenFlags::kOWriteOnly) == 0U &&
      (file->flags & OpenFlags::kOReadWrite) == 0U) {
    return std::unexpected(Error(ErrorCode::kFsPermissionDenied));
  }
 
  if (file->ops == nullptr) {
    return std::unexpected(Error(ErrorCode::kDeviceNotSupported));
  }
 
  return file->ops->Write(file, buf, count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

kMaxPathLength

constexpr size_t vfs::kMaxPathLength = 4096

staticconstexpr

VFS 路径最大长度限制

Definition at line 14 of file vfs_internal.hpp.