qiurui
/
asterinas
mirror of https://github.com/asterinas/asterinas.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename FsResolver to PathResolver and update all usages

This commit is contained in:
Chen Chengjun 2026-01-12 08:43:24 +00:00
parent e6c7533b43
commit dcd22e0e20
48 changed files with 176 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
kernel/src/device/mod.rs
View File

@ -14,7 +14,10 @@ pub use pty::{PtyMaster, PtySlave, new_pty_pair};
pub use registry::lookup;
use crate::{
fs::{fs_resolver::FsPath, path::PerMountFlags, ramfs::RamFs},
fs::{
path::{FsPath, PerMountFlags},
ramfs::RamFs,
},
prelude::*,
};
@ -29,16 +32,16 @@ pub fn init_in_first_kthread() {
/// Initializes the device nodes in devtmpfs after mounting rootfs.
pub fn init_in_first_process(ctx: &Context) -> Result<()> {
let fs = ctx.thread_local.borrow_fs();
let fs_resolver = fs.resolver().read();
let path_resolver = fs.resolver().read();
// Mount devtmpfs.
let dev_path = fs_resolver.lookup(&FsPath::try_from("/dev")?)?;
let dev_path = path_resolver.lookup(&FsPath::try_from("/dev")?)?;
dev_path.mount(RamFs::new(), PerMountFlags::default(), ctx)?;
tty::init_in_first_process()?;
pty::init_in_first_process(&fs_resolver, ctx)?;
shm::init_in_first_process(&fs_resolver, ctx)?;
registry::init_in_first_process(&fs_resolver)?;
pty::init_in_first_process(&path_resolver, ctx)?;
shm::init_in_first_process(&path_resolver, ctx)?;
registry::init_in_first_process(&path_resolver)?;
Ok(())
}

2
kernel/src/device/pty/master.rs
View File

@ -11,8 +11,8 @@ use crate::{
fs::{
devpts::Ptmx,
file_table::FdFlags,
fs_resolver::FsPath,
inode_handle::FileIo,
path::FsPath,
utils::{AccessMode, InodeIo, OpenArgs, StatusFlags, mkmod},
},
prelude::*,

7
kernel/src/device/pty/mod.rs
View File

@ -3,8 +3,7 @@
use crate::{
fs::{
devpts::{DevPts, Ptmx},
fs_resolver::{FsPath, FsResolver},
path::{Path, PerMountFlags},
path::{FsPath, Path, PathResolver, PerMountFlags},
utils::{InodeType, mkmod},
},
prelude::*,
@ -21,8 +20,8 @@ use spin::Once;
static DEV_PTS: Once<Path> = Once::new();
pub fn init_in_first_process(fs_resolver: &FsResolver, ctx: &Context) -> Result<()> {
let dev = fs_resolver.lookup(&FsPath::try_from("/dev")?)?;
pub fn init_in_first_process(path_resolver: &PathResolver, ctx: &Context) -> Result<()> {
let dev = path_resolver.lookup(&FsPath::try_from("/dev")?)?;
// Create the "pts" directory and mount devpts on it.
let devpts_path = dev.new_fs_child("pts", InodeType::Dir, mkmod!(a+rx, u+w))?;
let devpts_mount = devpts_path.mount(DevPts::new(), PerMountFlags::default(), ctx)?;

6
kernel/src/device/registry/block.rs
View File

@ -9,8 +9,8 @@ use crate::{
events::IoEvents,
fs::{
device::{Device, DeviceType, add_node},
fs_resolver::FsResolver,
inode_handle::FileIo,
path::PathResolver,
utils::{InodeIo, StatusFlags},
},
prelude::*,
@ -35,12 +35,12 @@ pub(super) fn init_in_first_kthread() {
}
}
pub(super) fn init_in_first_process(fs_resolver: &FsResolver) -> Result<()> {
pub(super) fn init_in_first_process(path_resolver: &PathResolver) -> Result<()> {
for device in aster_block::collect_all() {
let device = Arc::new(BlockFile::new(device));
if let Some(devtmpfs_path) = device.devtmpfs_path() {
let dev_id = device.id().as_encoded_u64();
add_node(DeviceType::Block, dev_id, &devtmpfs_path, fs_resolver)?;
add_node(DeviceType::Block, dev_id, &devtmpfs_path, path_resolver)?;
}
}

6
kernel/src/device/registry/char.rs
View File

@ -9,7 +9,7 @@ use device_id::{DeviceId, MajorId};
use crate::{
fs::{
device::{Device, DeviceType, add_node},
fs_resolver::FsResolver,
path::PathResolver,
},
prelude::*,
};
@ -112,11 +112,11 @@ impl Drop for MajorIdOwner {
}
}
pub(super) fn init_in_first_process(fs_resolver: &FsResolver) -> Result<()> {
pub(super) fn init_in_first_process(path_resolver: &PathResolver) -> Result<()> {
for device in collect_all() {
if let Some(devtmpfs_path) = device.devtmpfs_path() {
let dev_id = device.id().as_encoded_u64();
add_node(DeviceType::Char, dev_id, &devtmpfs_path, fs_resolver)?;
add_node(DeviceType::Char, dev_id, &devtmpfs_path, path_resolver)?;
}
}

8
kernel/src/device/registry/mod.rs
View File

@ -5,7 +5,7 @@ use device_id::DeviceId;
use crate::{
fs::{
device::{Device, DeviceType},
fs_resolver::FsResolver,
path::PathResolver,
},
prelude::*,
};
@ -17,9 +17,9 @@ pub(super) fn init_in_first_kthread() {
block::init_in_first_kthread();
}
pub(super) fn init_in_first_process(fs_resolver: &FsResolver) -> Result<()> {
char::init_in_first_process(fs_resolver)?;
block::init_in_first_process(fs_resolver)?;
pub(super) fn init_in_first_process(path_resolver: &PathResolver) -> Result<()> {
char::init_in_first_process(path_resolver)?;
block::init_in_first_process(path_resolver)?;
Ok(())
}

7
kernel/src/device/shm.rs
View File

@ -2,8 +2,7 @@
use crate::{
fs::{
fs_resolver::{FsPath, FsResolver},
path::PerMountFlags,
path::{FsPath, PathResolver, PerMountFlags},
ramfs::RamFs,
utils::{InodeType, chmod},
},
@ -11,10 +10,10 @@ use crate::{
};
/// Initializes "/dev/shm" for POSIX shared memory usage.
pub fn init_in_first_process(fs_resolver: &FsResolver, ctx: &Context) -> Result<()> {
pub fn init_in_first_process(path_resolver: &PathResolver, ctx: &Context) -> Result<()> {
use crate::fs::utils::InodeMode;
let dev_path = fs_resolver.lookup(&FsPath::try_from("/dev")?)?;
let dev_path = path_resolver.lookup(&FsPath::try_from("/dev")?)?;
// Create the "shm" directory under "/dev" and mount a ramfs on it.
let shm_path =

7
kernel/src/fs/device.rs
View File

@ -5,8 +5,7 @@ use device_id::DeviceId;
use super::inode_handle::FileIo;
use crate::{
fs::{
fs_resolver::{FsPath, FsResolver},
path::Path,
path::{FsPath, Path, PathResolver},
utils::{InodeType, MknodType, mkmod},
},
prelude::*,
@ -55,9 +54,9 @@ pub fn add_node(
dev_type: DeviceType,
dev_id: u64,
path: &str,
fs_resolver: &FsResolver,
path_resolver: &PathResolver,
) -> Result<Path> {
let mut dev_path = fs_resolver.lookup(&FsPath::try_from("/dev").unwrap())?;
let mut dev_path = path_resolver.lookup(&FsPath::try_from("/dev").unwrap())?;
let mut relative_path = {
let relative_path = path.trim_start_matches('/');
if relative_path.is_empty() {

15
kernel/src/fs/mod.rs
View File

@ -9,7 +9,6 @@ pub mod exfat;
pub mod ext2;
pub mod file_handle;
pub mod file_table;
pub mod fs_resolver;
pub mod inode_handle;
pub mod notify;
pub mod overlayfs;
@ -28,7 +27,7 @@ pub mod utils;
use crate::{
fs::{
file_table::FdFlags,
fs_resolver::{FsPath, FsResolver},
path::{FsPath, PathResolver},
utils::{AccessMode, OpenArgs, mkmod},
},
prelude::*,
@ -57,19 +56,19 @@ pub fn init_on_each_cpu() {
procfs::init_on_each_cpu();
}
pub fn init_in_first_kthread(fs_resolver: &FsResolver) {
rootfs::init_in_first_kthread(fs_resolver).unwrap();
pub fn init_in_first_kthread(path_resolver: &PathResolver) {
rootfs::init_in_first_kthread(path_resolver).unwrap();
}
pub fn init_in_first_process(ctx: &Context) {
let fs = ctx.thread_local.borrow_fs();
let fs_resolver = fs.resolver().read();
let path_resolver = fs.resolver().read();
// Initialize the file table for the first process.
let tty_path = FsPath::try_from("/dev/console").unwrap();
let stdin = {
let open_args = OpenArgs::from_modes(AccessMode::O_RDONLY, mkmod!(u+r));
fs_resolver
path_resolver
.lookup(&tty_path)
.unwrap()
.open(open_args)
@ -77,7 +76,7 @@ pub fn init_in_first_process(ctx: &Context) {
};
let stdout = {
let open_args = OpenArgs::from_modes(AccessMode::O_WRONLY, mkmod!(u+w));
fs_resolver
path_resolver
.lookup(&tty_path)
.unwrap()
.open(open_args)
@ -85,7 +84,7 @@ pub fn init_in_first_process(ctx: &Context) {
};
let stderr = {
let open_args = OpenArgs::from_modes(AccessMode::O_WRONLY, mkmod!(u+w));
fs_resolver
path_resolver
.lookup(&tty_path)
.unwrap()
.open(open_args)

15
kernel/src/fs/overlayfs/fs.rs
View File

@ -19,9 +19,8 @@ use ostd::{
use crate::{
fs::{
fs_resolver::FsPath,
inode_handle::FileIo,
path::Path,
path::{FsPath, Path},
registry::{FsProperties, FsType},
utils::{
AccessMode, DirentCounter, DirentVisitor, Extension, FallocMode, FileSystem,
@ -1180,14 +1179,18 @@ impl FsType for OverlayFsType {
let task = Task::current().unwrap();
let thread_local = task.as_thread_local().unwrap();
let fs_ref = thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
let upper = fs.lookup(&FsPath::try_from(upper)?)?;
let upper = path_resolver.lookup(&FsPath::try_from(upper)?)?;
let lower = lower
.iter()
.map(|&lower| fs.lookup(&FsPath::try_from(lower).unwrap()).unwrap())
.map(|&lower| {
path_resolver
.lookup(&FsPath::try_from(lower).unwrap())
.unwrap()
})
.collect();
let work = fs.lookup(&FsPath::try_from(work)?)?;
let work = path_resolver.lookup(&FsPath::try_from(work)?)?;
OverlayFs::new(upper, lower, work).map(|fs| fs as _)
}

2
kernel/src/fs/path/mod.rs
View File

@ -7,6 +7,7 @@ use core::time::Duration;
use inherit_methods_macro::inherit_methods;
pub use mount::{Mount, MountPropType, PerMountFlags};
pub use mount_namespace::MountNamespace;
pub use resolver::{AT_FDCWD, FsPath, LookupResult, PathResolver, SplitPath};
use crate::{
fs::{
@ -24,6 +25,7 @@ use crate::{
mod dentry;
mod mount;
mod mount_namespace;
mod resolver;
/// A `Path` is used to represent an exact location in the VFS tree.
///

7
kernel/src/fs/path/mount_namespace.rs
View File

@ -4,8 +4,7 @@ use spin::Once;
use crate::{
fs::{
fs_resolver::FsResolver,
path::{Mount, Path},
path::{Mount, Path, PathResolver},
ramfs::RamFs,
},
prelude::*,
@ -54,10 +53,10 @@ impl MountNamespace {
///
/// The "effective root" refers to the currently visible root directory, which
/// may differ from the original root filesystem if overlay mounts exist.
pub fn new_fs_resolver(&self) -> FsResolver {
pub fn new_path_resolver(&self) -> PathResolver {
let root = Path::new_fs_root(self.root.clone()).get_top_path();
let cwd = Path::new_fs_root(self.root.clone()).get_top_path();
FsResolver::new(root, cwd)
PathResolver::new(root, cwd)
}
/// Creates a deep copy of this mount namespace, including the entire mount tree.

20
kernel/src/fs/path/resolver.rs
View File

@ -4,13 +4,13 @@ use alloc::str;
use ostd::task::Task;
use super::{
file_table::{FileDesc, get_file_fast},
path::Path,
utils::{InodeType, PATH_MAX, SYMLINKS_MAX},
};
use super::Path;
use crate::{
fs::{path::MountNamespace, utils::SymbolicLink},
fs::{
file_table::{FileDesc, get_file_fast},
path::MountNamespace,
utils::{InodeType, PATH_MAX, SYMLINKS_MAX, SymbolicLink},
},
prelude::*,
process::posix_thread::AsThreadLocal,
};
@ -20,13 +20,13 @@ pub const AT_FDCWD: FileDesc = -100;
/// File system resolver.
#[derive(Debug, Clone)]
pub struct FsResolver {
pub struct PathResolver {
root: Path,
cwd: Path,
}
impl FsResolver {
/// Creates a new `FsResolver` with the given `root` and `cwd`.
impl PathResolver {
/// Creates a new `PathResolver` with the given `root` and `cwd`.
pub(super) fn new(root: Path, cwd: Path) -> Self {
Self { root, cwd }
}
@ -51,7 +51,7 @@ impl FsResolver {
self.root = path;
}
/// Switches the `FsResolver` to the given mount namespace.
/// Switches the `PathResolver` to the given mount namespace.
///
/// If the target namespace already owns both the current root and working directory's
/// mount nodes, the operation is a no-op and returns immediately.

4
kernel/src/fs/procfs/pid/task/mountinfo.rs
View File

@ -29,8 +29,8 @@ impl FileOps for MountInfoFileOps {
let posix_thread = thread.as_posix_thread().unwrap();
let fs = posix_thread.read_fs();
let fs_resolver = fs.resolver().read();
let root_mount = fs_resolver.root().mount_node();
let path_resolver = fs.resolver().read();
let root_mount = path_resolver.root().mount_node();
root_mount.read_mount_info(offset, writer)
}

8
kernel/src/fs/rootfs.rs
View File

@ -7,7 +7,7 @@ use libflate::gzip::Decoder as GZipDecoder;
use ostd::boot::boot_info;
use super::{
fs_resolver::{FsPath, FsResolver},
path::{FsPath, PathResolver},
utils::{InodeMode, InodeType},
};
use crate::{fs::path::is_dot, prelude::*};
@ -27,7 +27,7 @@ impl Read for BoxedReader<'_> {
}
/// Unpack and prepare the rootfs from the initramfs CPIO buffer.
pub fn init_in_first_kthread(fs_resolver: &FsResolver) -> Result<()> {
pub fn init_in_first_kthread(path_resolver: &PathResolver) -> Result<()> {
let initramfs_buf = boot_info().initramfs.expect("No initramfs found!");
let reader = {
@ -73,9 +73,9 @@ pub fn init_in_first_kthread(fs_resolver: &FsResolver) -> Result<()> {
// The mkinitramfs script uses `find` command to ensure that the entries are
// sorted that a directory always appears before its child directories and files.
let (parent, name) = if let Some((prefix, last)) = entry_name.rsplit_once('/') {
(fs_resolver.lookup(&FsPath::try_from(prefix)?)?, last)
(path_resolver.lookup(&FsPath::try_from(prefix)?)?, last)
} else {
(fs_resolver.root().clone(), entry_name)
(path_resolver.root().clone(), entry_name)
};
let metadata = entry.metadata();

14
kernel/src/fs/thread_info.rs
View File

@ -4,26 +4,26 @@ use core::sync::atomic::Ordering;
use ostd::sync::RwMutex;
use super::{fs_resolver::FsResolver, utils::AtomicFileCreationMask};
use super::{path::PathResolver, utils::AtomicFileCreationMask};
use crate::fs::utils::FileCreationMask;
/// FS information for a POSIX thread.
pub struct ThreadFsInfo {
resolver: RwMutex<FsResolver>,
resolver: RwMutex<PathResolver>,
umask: AtomicFileCreationMask,
}
impl ThreadFsInfo {
/// Creates a new `ThreadFsInfo` with the given [`FsResolver`].
pub fn new(fs_resolver: FsResolver) -> Self {
/// Creates a new `ThreadFsInfo` with the given [`PathResolver`].
pub fn new(path_resolver: PathResolver) -> Self {
Self {
resolver: RwMutex::new(fs_resolver),
resolver: RwMutex::new(path_resolver),
umask: AtomicFileCreationMask::new(FileCreationMask::default()),
}
}
/// Returns the associated `FsResolver`.
pub fn resolver(&self) -> &RwMutex<FsResolver> {
/// Returns the associated `PathResolver`.
pub fn resolver(&self) -> &RwMutex<PathResolver> {
&self.resolver
}

8
kernel/src/init.rs
View File

@ -8,7 +8,7 @@ use ostd::{cpu::CpuId, util::id_set::Id};
use spin::once::Once;
use crate::{
fs::{fs_resolver::FsResolver, path::MountNamespace},
fs::path::{MountNamespace, PathResolver},
prelude::*,
process::{Process, spawn_init_process},
sched::SchedPolicy,
@ -137,7 +137,7 @@ fn first_kthread() {
println!("[kernel] Spawn the first kernel thread");
let init_mnt_ns = MountNamespace::get_init_singleton();
let fs_resolver = init_mnt_ns.new_fs_resolver();
let fs_resolver = init_mnt_ns.new_path_resolver();
init_in_first_kthread(&fs_resolver);
print_banner();
@ -155,14 +155,14 @@ fn first_kthread() {
static INIT_PROCESS: Once<Arc<Process>> = Once::new();
fn init_in_first_kthread(fs_resolver: &FsResolver) {
fn init_in_first_kthread(path_resolver: &PathResolver) {
component::init_all(InitStage::Kthread, component::parse_metadata!()).unwrap();
// Work queue should be initialized before interrupt is enabled,
// in case any irq handler uses work queue as bottom half
crate::thread::work_queue::init_in_first_kthread();
crate::device::init_in_first_kthread();
crate::net::init_in_first_kthread();
crate::fs::init_in_first_kthread(fs_resolver);
crate::fs::init_in_first_kthread(path_resolver);
crate::ipc::init_in_first_kthread();
#[cfg(any(target_arch = "x86_64", target_arch = "riscv64"))]
crate::vdso::init_in_first_kthread();

11
kernel/src/net/socket/unix/ns/path.rs
View File

@ -4,8 +4,7 @@ use ostd::task::Task;
use crate::{
fs::{
fs_resolver::{FsPath, SplitPath},
path::Path,
path::{FsPath, Path, SplitPath},
utils::{InodeType, Permission, mkmod},
},
prelude::*,
@ -15,9 +14,9 @@ pub fn lookup_socket_file(path: &str) -> Result<Path> {
let path = {
let current = Task::current().unwrap();
let fs_ref = current.as_thread_local().unwrap().borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
let fs_path = FsPath::try_from(path)?;
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
};
if path
@ -44,9 +43,9 @@ pub fn create_socket_file(path_name: &str) -> Result<Path> {
let parent = {
let current = Task::current().unwrap();
let fs_ref = current.as_thread_local().unwrap().borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
let parent_path = FsPath::try_from(parent_path_name)?;
fs.lookup(&parent_path)?
path_resolver.lookup(&parent_path)?
};
parent

6
kernel/src/process/execve.rs
View File

@ -48,14 +48,14 @@ pub fn do_execve(
);
let fs_ref = ctx.thread_local.borrow_fs();
let fs_resolver = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
let elf_inode = elf_file.inode();
let program_to_load =
ProgramToLoad::build_from_inode(elf_inode.clone(), &fs_resolver, argv, envp)?;
ProgramToLoad::build_from_inode(elf_inode.clone(), &path_resolver, argv, envp)?;
let new_vmar = Vmar::new(ProcessVm::new(elf_file.clone()));
let elf_load_info = program_to_load.load_to_vmar(new_vmar.as_ref(), &fs_resolver)?;
let elf_load_info = program_to_load.load_to_vmar(new_vmar.as_ref(), &path_resolver)?;
// Ensure no other thread is concurrently performing exit_group or execve.
// If such an operation is in progress, return EAGAIN.

2
kernel/src/process/namespace/nsproxy.rs
View File

@ -170,7 +170,7 @@ impl ContextSetNsAdminApi for Context<'_> {
// other dependent fields of a posix thread may also need to be updated.
if !Arc::ptr_eq(&thread_local_ns_proxy.unwrap().mnt_ns, &ns_proxy.mnt_ns) {
*self.thread_local.borrow_fs().resolver().write() = ns_proxy.mnt_ns.new_fs_resolver();
*self.thread_local.borrow_fs().resolver().write() = ns_proxy.mnt_ns.new_path_resolver();
}
*pthread_ns_proxy = Some(ns_proxy.clone());

4
kernel/src/process/posix_thread/builder.rs
View File

@ -158,8 +158,8 @@ impl PosixThreadBuilder {
let user_ns = user_ns.unwrap_or_else(|| UserNamespace::get_init_singleton().clone());
let ns_proxy = ns_proxy.unwrap_or_else(|| NsProxy::get_init_singleton().clone());
let fs =
fs.unwrap_or_else(|| Arc::new(ThreadFsInfo::new(ns_proxy.mnt_ns().new_fs_resolver())));
let fs = fs
.unwrap_or_else(|| Arc::new(ThreadFsInfo::new(ns_proxy.mnt_ns().new_path_resolver())));
let vmar = process.upgrade().unwrap().lock_vmar().dup_vmar().unwrap();

11
kernel/src/process/process/init_proc.rs
View File

@ -7,8 +7,7 @@ use ostd::{arch::cpu::context::UserContext, task::Task, user::UserContextApi};
use super::Process;
use crate::{
fs::{
fs_resolver::FsPath,
path::{MountNamespace, Path},
path::{FsPath, MountNamespace, Path},
thread_info::ThreadFsInfo,
},
prelude::*,
@ -49,7 +48,7 @@ fn create_init_process(
envp: Vec<CString>,
) -> Result<Arc<Process>> {
let fs = {
let fs_resolver = MountNamespace::get_init_singleton().new_fs_resolver();
let fs_resolver = MountNamespace::get_init_singleton().new_path_resolver();
ThreadFsInfo::new(fs_resolver)
};
let fs_path = FsPath::try_from(executable_path)?;
@ -108,11 +107,11 @@ fn create_init_task(
let credentials = Credentials::new_root();
let elf_load_info = {
let fs_resolver = fs.resolver().read();
let path_resolver = fs.resolver().read();
let program_to_load =
ProgramToLoad::build_from_inode(elf_path.inode().clone(), &fs_resolver, argv, envp)?;
ProgramToLoad::build_from_inode(elf_path.inode().clone(), &path_resolver, argv, envp)?;
let vmar = process.lock_vmar();
program_to_load.load_to_vmar(vmar.unwrap(), &fs_resolver)?
program_to_load.load_to_vmar(vmar.unwrap(), &path_resolver)?
};
let mut user_ctx = UserContext::default();
user_ctx.set_instruction_pointer(elf_load_info.entry_point as _);

11
kernel/src/process/program_loader/elf/load_elf.rs
View File

@ -10,8 +10,7 @@ use super::{
};
use crate::{
fs::{
fs_resolver::{FsPath, FsResolver},
path::Path,
path::{FsPath, Path, PathResolver},
utils::Inode,
},
prelude::*,
@ -53,12 +52,12 @@ pub struct ElfLoadInfo {
pub fn load_elf_to_vmar(
vmar: &Vmar,
elf_inode: &Arc<dyn Inode>,
fs_resolver: &FsResolver,
path_resolver: &PathResolver,
elf_headers: ElfHeaders,
argv: Vec<CString>,
envp: Vec<CString>,
) -> Result<ElfLoadInfo> {
let ldso = lookup_and_parse_ldso(&elf_headers, elf_inode, fs_resolver)?;
let ldso = lookup_and_parse_ldso(&elf_headers, elf_inode, path_resolver)?;
#[cfg_attr(
not(any(target_arch = "x86_64", target_arch = "riscv64")),
@ -95,7 +94,7 @@ pub fn load_elf_to_vmar(
fn lookup_and_parse_ldso(
headers: &ElfHeaders,
elf_inode: &Arc<dyn Inode>,
fs_resolver: &FsResolver,
path_resolver: &PathResolver,
) -> Result<Option<(Path, ElfHeaders)>> {
let ldso_file = {
let ldso_path = if let Some(interp_phdr) = headers.interp_phdr() {
@ -113,7 +112,7 @@ fn lookup_and_parse_ldso(
})?;
let fs_path = FsPath::try_from(ldso_path.as_str())?;
fs_resolver.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
};
let ldso_elf = {

14
kernel/src/process/program_loader/mod.rs
View File

@ -9,7 +9,7 @@ use self::{
};
use crate::{
fs::{
fs_resolver::{FsPath, FsResolver},
path::{FsPath, PathResolver},
utils::{Inode, InodeType, Permission},
},
prelude::*,
@ -32,7 +32,7 @@ impl ProgramToLoad {
/// necessary.
pub(super) fn build_from_inode(
mut elf_inode: Arc<dyn Inode>,
fs_resolver: &FsResolver,
path_resolver: &PathResolver,
mut argv: Vec<CString>,
envp: Vec<CString>,
) -> Result<Self> {
@ -64,7 +64,7 @@ impl ProgramToLoad {
let interpreter = {
let filename = new_argv[0].to_str()?.to_string();
let fs_path = FsPath::try_from(filename.as_str())?;
fs_resolver.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
};
check_executable_inode(interpreter.inode().as_ref())?;
@ -87,11 +87,15 @@ impl ProgramToLoad {
/// Loads the executable into the specified virtual memory space.
///
/// Returns the information about the ELF loading process.
pub(super) fn load_to_vmar(self, vmar: &Vmar, fs_resolver: &FsResolver) -> Result<ElfLoadInfo> {
pub(super) fn load_to_vmar(
self,
vmar: &Vmar,
path_resolver: &PathResolver,
) -> Result<ElfLoadInfo> {
let elf_load_info = load_elf_to_vmar(
vmar,
&self.elf_inode,
fs_resolver,
path_resolver,
self.elf_headers,
self.argv,
self.envp,

8
kernel/src/syscall/access.rs
View File

@ -4,7 +4,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
utils::{PATH_MAX, Permission},
},
prelude::*,
@ -90,11 +90,11 @@ pub fn do_faccessat(
};
let fs_ref = ctx.thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
if flags.contains(FaccessatFlags::AT_SYMLINK_NOFOLLOW) {
fs.lookup_no_follow(&fs_path)?
path_resolver.lookup_no_follow(&fs_path)?
} else {
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
}
};

8
kernel/src/syscall/chdir.rs
View File

@ -4,7 +4,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::{FileDesc, get_file_fast},
fs_resolver::FsPath,
path::FsPath,
utils::InodeType,
},
prelude::*,
@ -16,19 +16,19 @@ pub fn sys_chdir(path_ptr: Vaddr, ctx: &Context) -> Result<SyscallReturn> {
debug!("path = {:?}", path_name);
let fs_ref = ctx.thread_local.borrow_fs();
let mut fs = fs_ref.resolver().write();
let mut path_resolver = fs_ref.resolver().write();
let path = {
let path_name = path_name.to_string_lossy();
if path_name.is_empty() {
return_errno_with_message!(Errno::ENOENT, "path is empty");
}
let fs_path = FsPath::try_from(path_name.as_ref())?;
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
};
if path.type_() != InodeType::Dir {
return_errno_with_message!(Errno::ENOTDIR, "must be directory");
}
fs.set_cwd(path);
path_resolver.set_cwd(path);
Ok(SyscallReturn::Return(0))
}

8
kernel/src/syscall/chmod.rs
View File

@ -5,7 +5,7 @@ use crate::{
fs,
fs::{
file_table::{FileDesc, get_file_fast},
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
utils::{InodeMode, PATH_MAX},
},
prelude::*,
@ -70,11 +70,11 @@ fn do_fchmodat(
};
let fs_ref = ctx.thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
if flags.contains(ChmodFlags::AT_SYMLINK_NOFOLLOW) {
fs.lookup_no_follow(&fs_path)?
path_resolver.lookup_no_follow(&fs_path)?
} else {
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
}
};

8
kernel/src/syscall/chown.rs
View File

@ -4,7 +4,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::{FileDesc, get_file_fast},
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
utils::PATH_MAX,
},
prelude::*,
@ -78,11 +78,11 @@ pub fn sys_fchownat(
let fs_path = FsPath::from_fd_and_path(dirfd, &path_name)?;
let fs_ref = ctx.thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
if flags.contains(ChownFlags::AT_SYMLINK_NOFOLLOW) {
fs.lookup_no_follow(&fs_path)?
path_resolver.lookup_no_follow(&fs_path)?
} else {
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
}
};

8
kernel/src/syscall/chroot.rs
View File

@ -2,7 +2,7 @@
use super::SyscallReturn;
use crate::{
fs::{fs_resolver::FsPath, utils::InodeType},
fs::{path::FsPath, utils::InodeType},
prelude::*,
syscall::constants::MAX_FILENAME_LEN,
};
@ -12,19 +12,19 @@ pub fn sys_chroot(path_ptr: Vaddr, ctx: &Context) -> Result<SyscallReturn> {
debug!("path_name = {:?}", path_name);
let fs_ref = ctx.thread_local.borrow_fs();
let mut fs = fs_ref.resolver().write();
let mut path_resolver = fs_ref.resolver().write();
let path = {
let path_name = path_name.to_string_lossy();
if path_name.is_empty() {
return_errno_with_message!(Errno::ENOENT, "path is empty");
}
let fs_path = FsPath::try_from(path_name.as_ref())?;
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
};
if path.type_() != InodeType::Dir {
return_errno_with_message!(Errno::ENOTDIR, "must be directory");
}
fs.set_root(path);
path_resolver.set_root(path);
Ok(SyscallReturn::Return(0))
}

9
kernel/src/syscall/execve.rs
View File

@ -6,8 +6,7 @@ use super::{SyscallReturn, constants::*};
use crate::{
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath},
path::Path,
path::{AT_FDCWD, FsPath, Path},
},
prelude::*,
process::do_execve,
@ -67,11 +66,11 @@ fn lookup_executable_file(
};
let fs_ref = ctx.thread_local.borrow_fs();
let fs_resolver = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
if flags.contains(OpenFlags::AT_SYMLINK_NOFOLLOW) {
fs_resolver.lookup_no_follow(&fs_path)?
path_resolver.lookup_no_follow(&fs_path)?
} else {
fs_resolver.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
}
};

2
kernel/src/syscall/inotify.rs
View File

@ -4,8 +4,8 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::{FdFlags, FileDesc, get_file_fast},
fs_resolver::FsPath,
notify::inotify::{InotifyControls, InotifyEvents, InotifyFile},
path::FsPath,
utils::{InodeType, Permission},
},
prelude::*,

10
kernel/src/syscall/link.rs
View File

@ -4,7 +4,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
utils::InodeType,
},
prelude::*,
@ -42,18 +42,18 @@ pub fn sys_linkat(
let new_fs_path = FsPath::from_fd_and_path(new_dirfd, &new_path_name)?;
let fs_ref = ctx.thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
let old_path = if flags.contains(LinkFlags::AT_SYMLINK_FOLLOW) {
fs.lookup(&old_fs_path)?
path_resolver.lookup(&old_fs_path)?
} else {
fs.lookup_no_follow(&old_fs_path)?
path_resolver.lookup_no_follow(&old_fs_path)?
};
if old_path.type_() == InodeType::Dir {
return_errno_with_message!(Errno::EPERM, "the link path is a directory");
}
let (new_path, new_name) = fs
let (new_path, new_name) = path_resolver
.lookup_unresolved_no_follow(&new_fs_path)?
.into_parent_and_filename()?;

2
kernel/src/syscall/mkdir.rs
View File

@ -5,7 +5,7 @@ use crate::{
fs,
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
utils::{InodeMode, InodeType},
},
prelude::*,

2
kernel/src/syscall/mknod.rs
View File

@ -5,7 +5,7 @@ use crate::{
fs::{
self,
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
utils::{InodeMode, InodeType, MknodType},
},
prelude::*,

3
kernel/src/syscall/mount.rs
View File

@ -5,8 +5,7 @@ use device_id::DeviceId;
use super::SyscallReturn;
use crate::{
fs::{
fs_resolver::{AT_FDCWD, FsPath},
path::{MountPropType, Path, PerMountFlags},
path::{AT_FDCWD, FsPath, MountPropType, Path, PerMountFlags},
registry::FsProperties,
utils::{FileSystem, FsFlags, InodeType},
},

12
kernel/src/syscall/open.rs
View File

@ -6,8 +6,8 @@ use crate::{
fs::{
file_handle::FileLike,
file_table::{FdFlags, FileDesc},
fs_resolver::{AT_FDCWD, FsPath, FsResolver, LookupResult},
inode_handle::InodeHandle,
path::{AT_FDCWD, FsPath, LookupResult, PathResolver},
utils::{AccessMode, CreationFlags, InodeMode, InodeType, OpenArgs, StatusFlags},
},
prelude::*,
@ -34,9 +34,9 @@ pub fn sys_openat(
let fs_ref = ctx.thread_local.borrow_fs();
let mask_mode = mode & !fs_ref.umask().get();
let fs_resolver = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
do_open(
&fs_resolver,
&path_resolver,
&fs_path,
flags,
InodeMode::from_bits_truncate(mask_mode),
@ -74,7 +74,7 @@ pub fn sys_creat(path_addr: Vaddr, mode: u16, ctx: &Context) -> Result<SyscallRe
}
fn do_open(
fs_resolver: &FsResolver,
path_resolver: &PathResolver,
fs_path: &FsPath,
flags: u32,
mode: InodeMode,
@ -82,9 +82,9 @@ fn do_open(
let open_args = OpenArgs::from_flags_and_mode(flags, mode)?;
let lookup_res = if open_args.follow_tail_link() {
fs_resolver.lookup_unresolved(fs_path)?
path_resolver.lookup_unresolved(fs_path)?
} else {
fs_resolver.lookup_unresolved_no_follow(fs_path)?
path_resolver.lookup_unresolved_no_follow(fs_path)?
};
let file_handle: Arc<dyn FileLike> = match lookup_res {

2
kernel/src/syscall/readlink.rs
View File

@ -6,7 +6,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
},
prelude::*,
syscall::constants::MAX_FILENAME_LEN,

8
kernel/src/syscall/rename.rs
View File

@ -4,7 +4,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath, SplitPath},
path::{AT_FDCWD, FsPath, SplitPath},
utils::InodeType,
},
prelude::*,
@ -36,13 +36,13 @@ pub fn sys_renameat2(
}
let fs_ref = ctx.thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
let old_path_name = old_path_name.to_string_lossy();
let (old_dir_path, old_name) = {
let (old_parent_path_name, old_name) = old_path_name.split_dirname_and_basename()?;
let old_fs_path = FsPath::from_fd_and_path(old_dirfd, old_parent_path_name)?;
(fs.lookup(&old_fs_path)?, old_name)
(path_resolver.lookup(&old_fs_path)?, old_name)
};
let old_path = old_dir_path.lookup(old_name)?;
if old_path.type_() != InodeType::Dir && old_path_name.ends_with('/') {
@ -56,7 +56,7 @@ pub fn sys_renameat2(
}
let (new_parent_path_name, new_name) = new_path_name.split_dirname_and_basename()?;
let new_fs_path = FsPath::from_fd_and_path(new_dirfd, new_parent_path_name)?;
(fs.lookup(&new_fs_path)?, new_name)
(path_resolver.lookup(&new_fs_path)?, new_name)
};
// Check the absolute path

2
kernel/src/syscall/rmdir.rs
View File

@ -4,7 +4,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath, SplitPath},
path::{AT_FDCWD, FsPath, SplitPath},
},
prelude::*,
syscall::constants::MAX_FILENAME_LEN,

9
kernel/src/syscall/setxattr.rs
View File

@ -8,8 +8,7 @@ use crate::{
fs::{
file_handle::FileLike,
file_table::{FileDesc, get_file_fast},
fs_resolver::{AT_FDCWD, FsPath},
path::Path,
path::{AT_FDCWD, FsPath, Path},
utils::{
XATTR_NAME_MAX_LEN, XATTR_VALUE_MAX_LEN, XattrName, XattrNamespace, XattrSetFlags,
},
@ -136,11 +135,11 @@ pub(super) fn lookup_path_for_xattr<'a>(
let path = path.to_string_lossy();
let fs_path = FsPath::from_fd_and_path(AT_FDCWD, &path)?;
let fs_ref = ctx.thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
let path = if symlink_no_follow {
fs.lookup_no_follow(&fs_path)?
path_resolver.lookup_no_follow(&fs_path)?
} else {
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
};
Ok(Cow::Owned(path))
};

8
kernel/src/syscall/stat.rs
View File

@ -6,7 +6,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::{FileDesc, get_file_fast},
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
utils::Metadata,
},
prelude::*,
@ -65,11 +65,11 @@ pub fn sys_fstatat(
let fs_path = FsPath::from_fd_and_path(dirfd, &filename)?;
let fs_ref = ctx.thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
if flags.contains(StatFlags::AT_SYMLINK_NOFOLLOW) {
fs.lookup_no_follow(&fs_path)?
path_resolver.lookup_no_follow(&fs_path)?
} else {
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
}
};

2
kernel/src/syscall/statfs.rs
View File

@ -6,7 +6,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::{FileDesc, get_file_fast},
fs_resolver::FsPath,
path::FsPath,
utils::{PATH_MAX, SuperBlock},
},
prelude::*,

11
kernel/src/syscall/statx.rs
View File

@ -6,7 +6,10 @@ use ostd::mm::VmIo;
use super::SyscallReturn;
use crate::{
fs::{file_table::FileDesc, fs_resolver::FsPath, path::Path},
fs::{
file_table::FileDesc,
path::{FsPath, Path},
},
prelude::*,
syscall::constants::MAX_FILENAME_LEN,
};
@ -54,11 +57,11 @@ pub fn sys_statx(
};
let fs_ref = ctx.thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
if flags.contains(StatxFlags::AT_SYMLINK_NOFOLLOW) {
fs.lookup_no_follow(&fs_path)?
path_resolver.lookup_no_follow(&fs_path)?
} else {
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
}
};

2
kernel/src/syscall/symlink.rs
View File

@ -5,7 +5,7 @@ use crate::{
fs,
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
utils::{InodeType, mkmod},
},
prelude::*,

2
kernel/src/syscall/truncate.rs
View File

@ -5,7 +5,7 @@ use crate::{
fs,
fs::{
file_table::{FileDesc, get_file_fast},
fs_resolver::{AT_FDCWD, FsPath},
path::{AT_FDCWD, FsPath},
utils::PATH_MAX,
},
prelude::*,

2
kernel/src/syscall/umount.rs
View File

@ -2,7 +2,7 @@
use super::SyscallReturn;
use crate::{
fs::fs_resolver::{AT_FDCWD, FsPath},
fs::path::{AT_FDCWD, FsPath},
prelude::*,
syscall::constants::MAX_FILENAME_LEN,
};

2
kernel/src/syscall/unlink.rs
View File

@ -4,7 +4,7 @@ use super::SyscallReturn;
use crate::{
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath, SplitPath},
path::{AT_FDCWD, FsPath, SplitPath},
},
prelude::*,
syscall::constants::MAX_FILENAME_LEN,

9
kernel/src/syscall/utimens.rs
View File

@ -9,8 +9,7 @@ use crate::{
fs,
fs::{
file_table::FileDesc,
fs_resolver::{AT_FDCWD, FsPath},
path::Path,
path::{AT_FDCWD, FsPath, Path},
},
prelude::*,
time::{clocks::RealTimeCoarseClock, timespec_t, timeval_t},
@ -179,11 +178,11 @@ fn do_utimes(
};
let fs_ref = ctx.thread_local.borrow_fs();
let fs = fs_ref.resolver().read();
let path_resolver = fs_ref.resolver().read();
if flags.contains(UtimensFlags::AT_SYMLINK_NOFOLLOW) {
fs.lookup_no_follow(&fs_path)?
path_resolver.lookup_no_follow(&fs_path)?
} else {
fs.lookup(&fs_path)?
path_resolver.lookup(&fs_path)?
}
};