From e2fe0cb8c8bc54122026af5b487d05d0a6a9f3c8 Mon Sep 17 00:00:00 2001 From: Chaoqun Zheng Date: Sat, 31 Jan 2026 18:16:23 +0800 Subject: [PATCH] Fix the issue that all pseudofs's `container_dev_id` is zero --- kernel/libs/device-id/src/lib.rs | 5 ----- kernel/src/fs/cgroupfs/fs.rs | 6 +++++- kernel/src/fs/configfs/fs.rs | 6 +++++- kernel/src/fs/devpts/mod.rs | 17 +++++++++++++++-- kernel/src/fs/devpts/ptmx.rs | 13 +++++++++++-- kernel/src/fs/devpts/slave.rs | 11 ++++++++++- kernel/src/fs/exfat/fs.rs | 15 ++++++++++++++- kernel/src/fs/exfat/inode.rs | 3 +-- kernel/src/fs/ext2/fs.rs | 9 +++++++++ kernel/src/fs/ext2/impl_for_vfs/fs.rs | 22 ++++++++-------------- kernel/src/fs/ext2/inode.rs | 4 ++-- kernel/src/fs/ext2/mod.rs | 2 +- kernel/src/fs/overlayfs/fs.rs | 9 ++++++++- kernel/src/fs/procfs/mod.rs | 6 +++++- kernel/src/fs/procfs/template/mod.rs | 11 ++++++++++- kernel/src/fs/pseudofs.rs | 20 +++++++++++++++++--- kernel/src/fs/ramfs/fs.rs | 9 +++++++-- kernel/src/fs/sysfs/fs.rs | 6 +++++- kernel/src/fs/utils/fs.rs | 5 ++++- kernel/src/fs/utils/inode.rs | 10 +++++----- kernel/src/fs/utils/systree_inode.rs | 6 ++++-- kernel/src/syscall/stat.rs | 2 +- kernel/src/syscall/statx.rs | 5 +++-- kernel/src/vm/vmar/vm_mapping.rs | 7 ++++++- 24 files changed, 156 insertions(+), 53 deletions(-) diff --git a/kernel/libs/device-id/src/lib.rs b/kernel/libs/device-id/src/lib.rs index 4de3adf51..3c1ba560f 100644 --- a/kernel/libs/device-id/src/lib.rs +++ b/kernel/libs/device-id/src/lib.rs @@ -79,11 +79,6 @@ impl DeviceId { Self(((major.get() as u32) << 20) | minor.get()) } - /// FIXME: just a placeholder for now. - pub const fn none() -> Self { - Self(0) - } - /// Returns the encoded `u32` value. pub fn to_raw(&self) -> u32 { self.0 diff --git a/kernel/src/fs/cgroupfs/fs.rs b/kernel/src/fs/cgroupfs/fs.rs index b9da1ed2d..62b878f76 100644 --- a/kernel/src/fs/cgroupfs/fs.rs +++ b/kernel/src/fs/cgroupfs/fs.rs @@ -41,7 +41,11 @@ impl CgroupFs { } fn new(root_node: Arc) -> Arc { - let sb = SuperBlock::new(MAGIC_NUMBER, BLOCK_SIZE, NAME_MAX); + let dev_id = device_id::PSEUDO_FS_DEVICE_ID_ALLOCATOR + .get() + .expect("PSEUDO_FS_DEVICE_ID_ALLOCATOR not initialized") + .allocate(); + let sb = SuperBlock::new(MAGIC_NUMBER, BLOCK_SIZE, NAME_MAX, dev_id); let root_inode = CgroupInode::new_root(root_node); Arc::new(Self { diff --git a/kernel/src/fs/configfs/fs.rs b/kernel/src/fs/configfs/fs.rs index 760e38456..5d71827ba 100644 --- a/kernel/src/fs/configfs/fs.rs +++ b/kernel/src/fs/configfs/fs.rs @@ -46,7 +46,11 @@ impl ConfigFs { } fn new(root_node: Arc) -> Arc { - let sb = SuperBlock::new(MAGIC_NUMBER, BLOCK_SIZE, NAME_MAX); + let dev_id = device_id::PSEUDO_FS_DEVICE_ID_ALLOCATOR + .get() + .expect("PSEUDO_FS_DEVICE_ID_ALLOCATOR not initialized") + .allocate(); + let sb = SuperBlock::new(MAGIC_NUMBER, BLOCK_SIZE, NAME_MAX, dev_id); let root_inode = ConfigInode::new_root(root_node); Arc::new(Self { diff --git a/kernel/src/fs/devpts/mod.rs b/kernel/src/fs/devpts/mod.rs index 86b83afa5..88107f132 100644 --- a/kernel/src/fs/devpts/mod.rs +++ b/kernel/src/fs/devpts/mod.rs @@ -53,8 +53,12 @@ pub struct DevPts { impl DevPts { pub fn new() -> Arc { + let dev_id = device_id::PSEUDO_FS_DEVICE_ID_ALLOCATOR + .get() + .expect("PSEUDO_FS_DEVICE_ID_ALLOCATOR not initialized") + .allocate(); Arc::new_cyclic(|weak_self| Self { - sb: SuperBlock::new(DEVPTS_MAGIC, BLOCK_SIZE, NAME_MAX), + sb: SuperBlock::new(DEVPTS_MAGIC, BLOCK_SIZE, NAME_MAX, dev_id), root: RootInode::new(weak_self.clone()), index_alloc: Mutex::new(IdAlloc::with_capacity(MAX_PTY_NUM)), fs_event_subscriber_stats: FsEventSubscriberStats::new(), @@ -196,7 +200,16 @@ impl Inode for RootInode { } fn metadata(&self) -> Metadata { - *self.metadata.read() + let metadata = *self.metadata.read(); + if metadata.container_dev_id.is_none() + && let Some(devpts) = self.fs.upgrade() + { + let dev_id = devpts.sb().dev_id; + let mut metadata_lock = self.metadata.write(); + metadata_lock.container_dev_id = Some(dev_id); + return *metadata_lock; + } + metadata } fn extension(&self) -> &Extension { diff --git a/kernel/src/fs/devpts/ptmx.rs b/kernel/src/fs/devpts/ptmx.rs index 8d8d87d51..8a5c619e0 100644 --- a/kernel/src/fs/devpts/ptmx.rs +++ b/kernel/src/fs/devpts/ptmx.rs @@ -28,7 +28,7 @@ struct Inner(Weak); impl Ptmx { pub fn new(fs: Weak) -> Arc { - let inner = Inner(fs); + let inner = Inner(fs.clone()); Arc::new(Self { metadata: RwLock::new(Metadata::new_device( PTMX_INO, @@ -78,7 +78,16 @@ impl Inode for Ptmx { } fn metadata(&self) -> Metadata { - *self.metadata.read() + let metadata = *self.metadata.read(); + if metadata.container_dev_id.is_none() + && let Some(devpts) = self.inner.0.upgrade() + { + let dev_id = devpts.sb().dev_id; + let mut metadata_lock = self.metadata.write(); + metadata_lock.container_dev_id = Some(dev_id); + return *metadata_lock; + } + metadata } fn extension(&self) -> &Extension { diff --git a/kernel/src/fs/devpts/slave.rs b/kernel/src/fs/devpts/slave.rs index f4db71faa..36953b6c4 100644 --- a/kernel/src/fs/devpts/slave.rs +++ b/kernel/src/fs/devpts/slave.rs @@ -77,7 +77,16 @@ impl Inode for PtySlaveInode { } fn metadata(&self) -> Metadata { - *self.metadata.read() + let metadata = *self.metadata.read(); + if metadata.container_dev_id.is_none() + && let Some(devpts) = self.fs.upgrade() + { + let dev_id = devpts.sb().dev_id; + let mut metadata_lock = self.metadata.write(); + metadata_lock.container_dev_id = Some(dev_id); + return *metadata_lock; + } + metadata } fn extension(&self) -> &Extension { diff --git a/kernel/src/fs/exfat/fs.rs b/kernel/src/fs/exfat/fs.rs index 1c488672d..6f79eede5 100644 --- a/kernel/src/fs/exfat/fs.rs +++ b/kernel/src/fs/exfat/fs.rs @@ -10,6 +10,7 @@ use aster_block::{ bio::{BioDirection, BioSegment, BioWaiter}, id::BlockId, }; +use device_id::DeviceId; use hashbrown::HashMap; use lru::LruCache; use ostd::mm::Segment; @@ -38,6 +39,7 @@ use crate::{ pub struct ExfatFs { block_device: Arc, super_block: ExfatSuperBlock, + dev_id: DeviceId, bitmap: Arc>, @@ -71,10 +73,12 @@ impl ExfatFs { ) -> Result> { // Load the super_block let super_block = Self::read_super_block(block_device.as_ref())?; + let dev_id = block_device.id(); let fs_size = super_block.num_clusters as usize * super_block.cluster_size as usize; let exfat_fs = Arc::new_cyclic(|weak_self| ExfatFs { block_device, super_block, + dev_id, bitmap: Arc::new(Mutex::new(ExfatBitmap::default())), upcase_table: Arc::new(SpinLock::new(ExfatUpcaseTable::empty())), mount_option, @@ -310,6 +314,10 @@ impl ExfatFs { self.block_device.as_ref() } + pub(super) fn dev_id(&self) -> DeviceId { + self.dev_id + } + pub(super) fn super_block(&self) -> ExfatSuperBlock { self.super_block } @@ -421,7 +429,12 @@ impl FileSystem for ExfatFs { } fn sb(&self) -> SuperBlock { - SuperBlock::new(BOOT_SIGNATURE as u64, self.sector_size(), MAX_NAME_LENGTH) + SuperBlock::new( + BOOT_SIGNATURE as u64, + self.sector_size(), + MAX_NAME_LENGTH, + self.dev_id, + ) } fn fs_event_subscriber_stats(&self) -> &FsEventSubscriberStats { diff --git a/kernel/src/fs/exfat/inode.rs b/kernel/src/fs/exfat/inode.rs index f69accda4..fde320d2d 100644 --- a/kernel/src/fs/exfat/inode.rs +++ b/kernel/src/fs/exfat/inode.rs @@ -12,7 +12,6 @@ use aster_block::{ bio::{BioDirection, BioSegment, BioWaiter}, id::{Bid, BlockId}, }; -use device_id::DeviceId; use ostd::mm::{Segment, VmIo, io_util::HasVmReaderWriter}; use super::{ @@ -1371,7 +1370,7 @@ impl Inode for ExfatInode { nr_hard_links: nlinks, uid: Uid::new(inner.fs().mount_option().fs_uid as u32), gid: Gid::new(inner.fs().mount_option().fs_gid as u32), - container_dev_id: DeviceId::none(), // FIXME: placeholder + container_dev_id: Some(inner.fs().dev_id()), self_dev_id: None, } } diff --git a/kernel/src/fs/ext2/fs.rs b/kernel/src/fs/ext2/fs.rs index 76ad34818..a9ad87d7f 100644 --- a/kernel/src/fs/ext2/fs.rs +++ b/kernel/src/fs/ext2/fs.rs @@ -2,6 +2,8 @@ #![expect(dead_code)] +use device_id::DeviceId; + use super::{ block_group::{BlockGroup, RawGroupDescriptor}, block_ptr::Ext2Bid, @@ -22,6 +24,7 @@ const ROOT_INO: u32 = 2; pub struct Ext2 { block_device: Arc, super_block: RwMutex>, + dev_id: DeviceId, block_groups: Vec, inodes_per_group: u32, blocks_per_group: Ext2Bid, @@ -90,6 +93,7 @@ impl Ext2 { blocks_per_group: super_block.blocks_per_group(), inode_size: super_block.inode_size(), block_size: super_block.block_size(), + dev_id: block_device.id(), block_groups: load_block_groups( weak_ref.clone(), block_device.as_ref(), @@ -110,6 +114,11 @@ impl Ext2 { self.block_device.as_ref() } + /// Returns the device ID containing this filesystem. + pub fn dev_id(&self) -> DeviceId { + self.dev_id + } + /// Returns the size of block. pub fn block_size(&self) -> usize { self.block_size diff --git a/kernel/src/fs/ext2/impl_for_vfs/fs.rs b/kernel/src/fs/ext2/impl_for_vfs/fs.rs index f8b66a300..de431acf6 100644 --- a/kernel/src/fs/ext2/impl_for_vfs/fs.rs +++ b/kernel/src/fs/ext2/impl_for_vfs/fs.rs @@ -1,10 +1,8 @@ // SPDX-License-Identifier: MPL-2.0 -use ostd::sync::RwMutexReadGuard; - use crate::{ fs::{ - ext2::{Ext2, MAGIC_NUM as EXT2_MAGIC, SuperBlock as Ext2SuperBlock, utils::Dirty}, + ext2::{Ext2, MAGIC_NUM as EXT2_MAGIC}, utils::{FileSystem, FsEventSubscriberStats, Inode, NAME_MAX, SuperBlock}, }, prelude::*, @@ -28,17 +26,8 @@ impl FileSystem for Ext2 { } fn sb(&self) -> SuperBlock { - SuperBlock::from(self.super_block()) - } - - fn fs_event_subscriber_stats(&self) -> &FsEventSubscriberStats { - self.fs_event_subscriber_stats() - } -} - -impl From>> for SuperBlock { - fn from(ext2_sb: RwMutexReadGuard>) -> Self { - Self { + let ext2_sb = self.super_block(); + SuperBlock { magic: EXT2_MAGIC as _, bsize: ext2_sb.block_size(), blocks: ext2_sb.total_blocks() as _, @@ -50,6 +39,11 @@ impl From>> for SuperBlock { namelen: NAME_MAX, frsize: ext2_sb.fragment_size(), flags: 0, // TODO + dev_id: self.dev_id(), } } + + fn fs_event_subscriber_stats(&self) -> &FsEventSubscriberStats { + self.fs_event_subscriber_stats() + } } diff --git a/kernel/src/fs/ext2/inode.rs b/kernel/src/fs/ext2/inode.rs index 74f7392dc..bfc06e8a0 100644 --- a/kernel/src/fs/ext2/inode.rs +++ b/kernel/src/fs/ext2/inode.rs @@ -105,7 +105,7 @@ impl Inode { pub fn metadata(&self) -> Metadata { let inner = self.inner.read(); - let id = self.fs.upgrade().unwrap().block_device().id(); + let dev_id = self.fs.upgrade().unwrap().dev_id(); Metadata { ino: self.ino() as _, size: inner.file_size() as _, @@ -119,7 +119,7 @@ impl Inode { nr_hard_links: inner.hard_links() as _, uid: Uid::new(inner.uid()), gid: Gid::new(inner.gid()), - container_dev_id: id, + container_dev_id: Some(dev_id), self_dev_id: if self.device_id() != 0 { DeviceId::from_encoded_u64(self.device_id()) } else { diff --git a/kernel/src/fs/ext2/mod.rs b/kernel/src/fs/ext2/mod.rs index 90b61b06f..040f46e8b 100644 --- a/kernel/src/fs/ext2/mod.rs +++ b/kernel/src/fs/ext2/mod.rs @@ -38,7 +38,7 @@ pub use fs::Ext2; pub use inode::{FilePerm, Inode}; -pub use super_block::{MAGIC_NUM, SuperBlock}; +pub use super_block::MAGIC_NUM; use crate::fs::ext2::fs::Ext2Type; diff --git a/kernel/src/fs/overlayfs/fs.rs b/kernel/src/fs/overlayfs/fs.rs index a64e37e18..903d8b8d4 100644 --- a/kernel/src/fs/overlayfs/fs.rs +++ b/kernel/src/fs/overlayfs/fs.rs @@ -50,6 +50,8 @@ pub struct OverlayFs { config: OverlayConfig, /// Super block. sb: OverlaySB, + /// The device ID containing this filesystem. + dev_id: device_id::DeviceId, /// Unique inode number generator. next_ino: AtomicU64, /// FS event subscriber stats for this file system. @@ -123,12 +125,17 @@ impl OverlayFs { Self::validate_work_and_upper(&work, &upper)?; Self::validate_work_empty(&work)?; + let dev_id = device_id::PSEUDO_FS_DEVICE_ID_ALLOCATOR + .get() + .expect("PSEUDO_FS_DEVICE_ID_ALLOCATOR not initialized") + .allocate(); Ok(Arc::new_cyclic(|weak| Self { upper: OverlayUpper { path: upper }, lower: OverlayLower { paths: lower }, work: OverlayWork { path: work }, config: OverlayConfig::default(), sb: OverlaySB, + dev_id, next_ino: AtomicU64::new(0), fs_event_subscriber_stats: FsEventSubscriberStats::new(), self_: weak.clone(), @@ -194,7 +201,7 @@ impl FileSystem for OverlayFs { fn sb(&self) -> SuperBlock { // TODO: Fill the super block with valid field values. - SuperBlock::new(OVERLAY_FS_MAGIC, BLOCK_SIZE, NAME_MAX) + SuperBlock::new(OVERLAY_FS_MAGIC, BLOCK_SIZE, NAME_MAX, self.dev_id) } fn fs_event_subscriber_stats(&self) -> &FsEventSubscriberStats { diff --git a/kernel/src/fs/procfs/mod.rs b/kernel/src/fs/procfs/mod.rs index 690ffb14c..6c978651c 100644 --- a/kernel/src/fs/procfs/mod.rs +++ b/kernel/src/fs/procfs/mod.rs @@ -74,8 +74,12 @@ struct ProcFs { impl ProcFs { pub(self) fn new() -> Arc { + let dev_id = device_id::PSEUDO_FS_DEVICE_ID_ALLOCATOR + .get() + .expect("PSEUDO_FS_DEVICE_ID_ALLOCATOR not initialized") + .allocate(); Arc::new_cyclic(|weak_fs| Self { - sb: SuperBlock::new(PROC_MAGIC, BLOCK_SIZE, NAME_MAX), + sb: SuperBlock::new(PROC_MAGIC, BLOCK_SIZE, NAME_MAX, dev_id), root: RootDirOps::new_inode(weak_fs.clone()), inode_allocator: AtomicU64::new(PROC_ROOT_INO + 1), fs_event_subscriber_stats: FsEventSubscriberStats::new(), diff --git a/kernel/src/fs/procfs/template/mod.rs b/kernel/src/fs/procfs/template/mod.rs index 021b7b56c..4b42bd3ac 100644 --- a/kernel/src/fs/procfs/template/mod.rs +++ b/kernel/src/fs/procfs/template/mod.rs @@ -42,7 +42,16 @@ impl Common { } pub fn metadata(&self) -> Metadata { - *self.metadata.read() + let metadata = *self.metadata.read(); + if metadata.container_dev_id.is_none() + && let Some(fs) = self.fs.upgrade() + { + let dev_id = fs.sb().dev_id; + let mut metadata_lock = self.metadata.write(); + metadata_lock.container_dev_id = Some(dev_id); + return *metadata_lock; + } + metadata } pub fn ino(&self) -> u64 { diff --git a/kernel/src/fs/pseudofs.rs b/kernel/src/fs/pseudofs.rs index e5ac2eb09..b559ca154 100644 --- a/kernel/src/fs/pseudofs.rs +++ b/kernel/src/fs/pseudofs.rs @@ -67,9 +67,13 @@ impl PseudoFs { ) -> &'static Arc { // Reference: fs.call_once(|| { + let dev_id = device_id::PSEUDO_FS_DEVICE_ID_ALLOCATOR + .get() + .expect("PSEUDO_FS_DEVICE_ID_ALLOCATOR not initialized") + .allocate(); Arc::new_cyclic(|weak_fs: &Weak| Self { name, - sb: SuperBlock::new(magic, aster_block::BLOCK_SIZE, NAME_MAX), + sb: SuperBlock::new(magic, aster_block::BLOCK_SIZE, NAME_MAX, dev_id), root: Arc::new(PseudoInode::new( ROOT_INO, PseudoInodeType::Root, @@ -77,6 +81,7 @@ impl PseudoFs { Uid::new_root(), Gid::new_root(), weak_fs.clone(), + dev_id, )), inode_allocator: AtomicU64::new(ROOT_INO + 1), fs_event_subscriber_stats: FsEventSubscriberStats::new(), @@ -91,7 +96,15 @@ impl PseudoFs { uid: Uid, gid: Gid, ) -> PseudoInode { - PseudoInode::new(self.alloc_id(), type_, mode, uid, gid, Arc::downgrade(self)) + PseudoInode::new( + self.alloc_id(), + type_, + mode, + uid, + gid, + Arc::downgrade(self), + self.sb.dev_id, + ) } fn alloc_id(&self) -> u64 { @@ -368,6 +381,7 @@ impl PseudoInode { uid: Uid, gid: Gid, fs: Weak, + dev_id: DeviceId, ) -> Self { let now = now(); let type_ = InodeType::from(type_); @@ -385,7 +399,7 @@ impl PseudoInode { nr_hard_links: 1, uid, gid, - container_dev_id: DeviceId::none(), // FIXME: placeholder + container_dev_id: Some(dev_id), self_dev_id: None, }; diff --git a/kernel/src/fs/ramfs/fs.rs b/kernel/src/fs/ramfs/fs.rs index bf411bfc2..5ce57b4ef 100644 --- a/kernel/src/fs/ramfs/fs.rs +++ b/kernel/src/fs/ramfs/fs.rs @@ -51,8 +51,12 @@ pub struct RamFs { impl RamFs { pub fn new() -> Arc { + let dev_id = device_id::PSEUDO_FS_DEVICE_ID_ALLOCATOR + .get() + .expect("PSEUDO_FS_DEVICE_ID_ALLOCATOR not initialized") + .allocate(); Arc::new_cyclic(|weak_fs| Self { - sb: SuperBlock::new(RAMFS_MAGIC, BLOCK_SIZE, NAME_MAX), + sb: SuperBlock::new(RAMFS_MAGIC, BLOCK_SIZE, NAME_MAX, dev_id), root: Arc::new_cyclic(|weak_root| RamInode { inner: Inner::new_dir(weak_root.clone(), weak_root.clone()), metadata: SpinLock::new(InodeMeta::new_dir( @@ -1169,6 +1173,7 @@ impl Inode for RamInode { fn metadata(&self) -> Metadata { let rdev = self.inner.device_id().unwrap_or(0); let inode_metadata = self.metadata.lock(); + let container_dev_id = self.fs().sb().dev_id; Metadata { ino: self.ino as _, size: inode_metadata.size, @@ -1182,7 +1187,7 @@ impl Inode for RamInode { nr_hard_links: inode_metadata.nlinks, uid: inode_metadata.uid, gid: inode_metadata.gid, - container_dev_id: DeviceId::none(), // FIXME: placeholder + container_dev_id: Some(container_dev_id), self_dev_id: if rdev == 0 { None } else { diff --git a/kernel/src/fs/sysfs/fs.rs b/kernel/src/fs/sysfs/fs.rs index e23e4e77a..4c707a49e 100644 --- a/kernel/src/fs/sysfs/fs.rs +++ b/kernel/src/fs/sysfs/fs.rs @@ -41,7 +41,11 @@ impl SysFs { } fn new() -> Arc { - let sb = SuperBlock::new(MAGIC_NUMBER, BLOCK_SIZE, NAME_MAX); + let dev_id = device_id::PSEUDO_FS_DEVICE_ID_ALLOCATOR + .get() + .expect("PSEUDO_FS_DEVICE_ID_ALLOCATOR not initialized") + .allocate(); + let sb = SuperBlock::new(MAGIC_NUMBER, BLOCK_SIZE, NAME_MAX, dev_id); let systree_ref = sysfs::systree_singleton(); let root_inode = SysFsInode::new_root(systree_ref.root().clone()); diff --git a/kernel/src/fs/utils/fs.rs b/kernel/src/fs/utils/fs.rs index 7eeac3cd6..f5286e984 100644 --- a/kernel/src/fs/utils/fs.rs +++ b/kernel/src/fs/utils/fs.rs @@ -3,6 +3,7 @@ use core::sync::atomic::{AtomicI64, AtomicU32, Ordering}; use atomic_integer_wrapper::define_atomic_version_of_integer_like_type; +use device_id::DeviceId; use super::Inode; use crate::prelude::*; @@ -20,10 +21,11 @@ pub struct SuperBlock { pub namelen: usize, pub frsize: usize, pub flags: u64, + pub dev_id: DeviceId, } impl SuperBlock { - pub fn new(magic: u64, block_size: usize, name_max_len: usize) -> Self { + pub fn new(magic: u64, block_size: usize, name_max_len: usize, dev_id: DeviceId) -> Self { Self { magic, bsize: block_size, @@ -36,6 +38,7 @@ impl SuperBlock { namelen: name_max_len, frsize: block_size, flags: 0, + dev_id, } } } diff --git a/kernel/src/fs/utils/inode.rs b/kernel/src/fs/utils/inode.rs index 3043bd839..6085ff6ee 100644 --- a/kernel/src/fs/utils/inode.rs +++ b/kernel/src/fs/utils/inode.rs @@ -210,7 +210,7 @@ pub struct Metadata { /// For pseudo files (e.g., those on sockfs), this device is also "pseudo". /// /// Corresponds to `st_dev`. - pub container_dev_id: DeviceId, + pub container_dev_id: Option, /// The device ID of the inode itself, if this inode represents a special device file (character or block). /// @@ -234,7 +234,7 @@ impl Metadata { nr_hard_links: 2, uid: Uid::new_root(), gid: Gid::new_root(), - container_dev_id: DeviceId::none(), // FIXME: placeholder + container_dev_id: None, self_dev_id: None, } } @@ -254,7 +254,7 @@ impl Metadata { nr_hard_links: 1, uid: Uid::new_root(), gid: Gid::new_root(), - container_dev_id: DeviceId::none(), // FIXME: placeholder + container_dev_id: None, self_dev_id: None, } } @@ -274,7 +274,7 @@ impl Metadata { nr_hard_links: 1, uid: Uid::new_root(), gid: Gid::new_root(), - container_dev_id: DeviceId::none(), // FIXME: placeholder + container_dev_id: None, self_dev_id: None, } } @@ -294,7 +294,7 @@ impl Metadata { nr_hard_links: 1, uid: Uid::new_root(), gid: Gid::new_root(), - container_dev_id: DeviceId::none(), // FIXME: placeholder + container_dev_id: None, self_dev_id: Some(device.id()), } } diff --git a/kernel/src/fs/utils/systree_inode.rs b/kernel/src/fs/utils/systree_inode.rs index 1861f10a9..e4ec94154 100644 --- a/kernel/src/fs/utils/systree_inode.rs +++ b/kernel/src/fs/utils/systree_inode.rs @@ -12,7 +12,6 @@ use core::time::Duration; use aster_systree::{ SysAttr, SysBranchNode, SysNode, SysNodeId, SysNodeType, SysObj, SysStr, SysSymlink, }; -use device_id::DeviceId; use super::Extension; use crate::{ @@ -88,7 +87,7 @@ pub(in crate::fs) trait SysTreeInodeTy: Send + Sync + 'static { nr_hard_links: 1, uid: Uid::new_root(), gid: Gid::new_root(), - container_dev_id: DeviceId::none(), // FIXME: placeholder + container_dev_id: None, self_dev_id: None, } } @@ -336,6 +335,9 @@ impl Inode for KInode { default fn metadata(&self) -> Metadata { let mut metadata = *self.metadata(); metadata.mode = self.mode().unwrap(); + if metadata.container_dev_id.is_none() { + metadata.container_dev_id = Some(self.fs().sb().dev_id); + } metadata } diff --git a/kernel/src/syscall/stat.rs b/kernel/src/syscall/stat.rs index 132c81a83..b37f65faf 100644 --- a/kernel/src/syscall/stat.rs +++ b/kernel/src/syscall/stat.rs @@ -175,7 +175,7 @@ struct Stat { impl From for Stat { fn from(info: Metadata) -> Self { Self { - st_dev: info.container_dev_id.as_encoded_u64(), + st_dev: info.container_dev_id.map_or(0, |id| id.as_encoded_u64()), st_ino: info.ino, st_nlink: info.nr_hard_links as _, st_mode: info.type_ as u32 | info.mode.bits() as u32, diff --git a/kernel/src/syscall/statx.rs b/kernel/src/syscall/statx.rs index 4da358256..fb65452fc 100644 --- a/kernel/src/syscall/statx.rs +++ b/kernel/src/syscall/statx.rs @@ -128,8 +128,9 @@ impl Statx { fn new(path: &Path) -> Self { let info = path.metadata(); - let (stx_dev_major, stx_dev_minor) = - device_id::decode_device_numbers(info.container_dev_id.as_encoded_u64()); + let (stx_dev_major, stx_dev_minor) = device_id::decode_device_numbers( + info.container_dev_id.map_or(0, |id| id.as_encoded_u64()), + ); let (stx_rdev_major, stx_rdev_minor) = device_id::decode_device_numbers(info.self_dev_id.map_or(0, |id| id.as_encoded_u64())); diff --git a/kernel/src/vm/vmar/vm_mapping.rs b/kernel/src/vm/vmar/vm_mapping.rs index bc76e62dc..6f05f9fcd 100644 --- a/kernel/src/vm/vmar/vm_mapping.rs +++ b/kernel/src/vm/vmar/vm_mapping.rs @@ -243,7 +243,12 @@ impl VmMapping { let (dev_major, dev_minor) = self .inode() .map(|inode| { - device_id::decode_device_numbers(inode.metadata().container_dev_id.as_encoded_u64()) + device_id::decode_device_numbers( + inode + .metadata() + .container_dev_id + .map_or(0, |id| id.as_encoded_u64()), + ) }) .unwrap_or((0, 0)); let ino = self.inode().map(|inode| inode.ino()).unwrap_or(0);