Merge branch 'master' into dev-dadk-0.2.0

.github/workflows/docs-multiversion.yml

@@ -44,4 +44,4 @@ jobs:
         AWS_SECRET_ACCESS_KEY: ${{ secrets.DOCS_DEPLOY_S3_SECRET_KEY }}
       
       run: |
-        aws s3 sync ./_build/html s3://dragonos-docs --delete
+        aws s3 sync ./_build/html s3://dragonos-docs --delete --exclude "p/*"

.github/workflows/makefile.yml

@@ -12,14 +12,14 @@ jobs:
     name: Format check ${{ matrix.arch }}
     runs-on: ubuntu-latest
     continue-on-error: true
-    container: dragonos/dragonos-dev:v1.4
+    container: dragonos/dragonos-dev:v1.6
 
     strategy:
       matrix:
         arch: [x86_64, riscv64]
 
     steps:
-    - run: echo "Running in dragonos/dragonos-dev:v1.4"
+    - run: echo "Running in dragonos/dragonos-dev:v1.6"
     - uses: actions/checkout@v3
 
     - name: Format check
@@ -35,14 +35,14 @@ jobs:
     name: Kernel static test ${{ matrix.arch }}
     runs-on: ubuntu-latest
     continue-on-error: true
-    container: dragonos/dragonos-dev:v1.4
+    container: dragonos/dragonos-dev:v1.6
 
     strategy:
       matrix:
         arch: [x86_64, riscv64]
 
     steps:
-    - run: echo "Running in dragonos/dragonos-dev:v1.4"
+    - run: echo "Running in dragonos/dragonos-dev:v1.6"
 
     - uses: actions/checkout@v3
 
@@ -56,10 +56,10 @@ jobs:
   build-x86_64:
 
     runs-on: ubuntu-latest
-    container: dragonos/dragonos-dev:v1.4
+    container: dragonos/dragonos-dev:v1.6
 
     steps:
-    - run: echo "Running in dragonos/dragonos-dev:v1.4"
+    - run: echo "Running in dragonos/dragonos-dev:v1.6"
 
     - uses: actions/checkout@v3
     - name: build the DragonOS
@@ -78,10 +78,10 @@ jobs:
   build-riscv64:
 
     runs-on: ubuntu-latest
-    container: dragonos/dragonos-dev:v1.4
+    container: dragonos/dragonos-dev:v1.6
 
     steps:
-    - run: echo "Running in dragonos/dragonos-dev:v1.4"
+    - run: echo "Running in dragonos/dragonos-dev:v1.6"
 
     - uses: actions/checkout@v3
       with:

build-scripts/Makefile

@@ -5,4 +5,4 @@ fmt:
 clean:
 	@cargo clean
 check:
-	@cargo +nightly-2024-07-23 check --workspace $(CARGO_ZBUILD) --message-format=json
+	@cargo +nightly-2024-11-05 check --workspace $(CARGO_ZBUILD) --message-format=json

docs/index.rst

@@ -30,10 +30,12 @@
    kernel/debug/index
    kernel/ktest/index
    kernel/cpu_arch/index
+   kernel/container/index
    kernel/libs/index
    kernel/trace/index
 
 
+
 .. toctree::
    :maxdepth: 1
    :caption: 应用层

docs/kernel/container/index.rst

@@ -0,0 +1,13 @@
+====================================
+容器化
+====================================
+
+   这里是DragonOS中，与容器化相关的说明文档。
+
+   主要包括namespace，overlayfs和cgroup
+   
+.. toctree::
+   :maxdepth: 2
+
+   namespaces/index
+   filesystem/unionfs/index

docs/kernel/container/namespaces/index.rst

@@ -0,0 +1,14 @@
+====================================
+名称空间
+====================================
+
+DragonOS的namespaces目前支持pid_namespace和mnt_namespace 预计之后会继续完善
+namespace是容器化实现过程中的重要组成部分
+
+由于目前os是单用户，user_namespace为全局静态
+
+.. toctree::
+   :maxdepth: 1
+
+   pid_namespace
+   mnt_namespace

docs/kernel/container/namespaces/mnt_namespace.md

@@ -0,0 +1,19 @@
+# 挂载名称空间
+
+## 底层架构
+
+pcb -> nsproxy -> mnt_namespace
+
+每一个挂载文件系统都有自立独立的挂载点，表现在数据结构上是一个挂载的红黑树，每一个名称空间中挂载是独立的，所以文件系统的挂载和卸载不会影响别的
+
+## 系统调用接口
+ 
+
+- clone
+    - CLONE_NEWNS用于创建一个新的 MNT 命名空间。提供独立的文件系统挂载点
+- unshare 
+    - 使用 CLONE_NEWPID 标志调用 unshare() 后，后续创建的所有子进程都将在新的命名空间中运行。
+- setns
+    - 将进程加入到指定的名称空间
+- chroot 
+    - 将当前进程的根目录更改为指定的路径，提供文件系统隔离。

docs/kernel/container/namespaces/pid_namespace.md

@@ -0,0 +1,21 @@
+# 进程名称空间
+:::{note} 本文作者：操丰毅 [email protected]
+
+2024年10月30日 :::
+pid_namespace 是内核中的一种名称空间，用于实现进程隔离，允许在不同的名称空间中运行的进程有独立的pid试图
+
+## 底层架构
+
+pcb -> nsproxy -> pid_namespace
+- pid_namespace 内有独立的一套进程分配器，以及孤儿进程回收器，独立管理内部的pid
+- 不同进程的详细信息都存放在proc文件系统中，里面的找到对应的pid号里面的信息都在pid中，记录的是pid_namespace中的信息
+- pid_namespace等限制由ucount来控制管理
+
+## 系统调用接口
+
+- clone
+    - CLONE_NEWPID用于创建一个新的 PID 命名空间。使用这个标志时，子进程将在新的 PID 命名空间内运行，进程 ID 从 1 开始。
+- unshare 
+    - 使用 CLONE_NEWPID 标志调用 unshare() 后，后续创建的所有子进程都将在新的命名空间中运行。
+- getpid
+    - 在命名空间中调用 getpid() 会返回进程在当前 PID 命名空间中的进程 ID

docs/kernel/filesystem/index.rst

@@ -13,4 +13,5 @@ todo: 由于文件系统模块重构，文档暂时不可用，预计在2023年4
    vfs/index
    sysfs
    kernfs
+   unionfs/index
 

docs/kernel/filesystem/unionfs/index.rst

@@ -0,0 +1,10 @@
+====================================
+联合文件系统
+====================================
+Union Filesystem：
+OverlayFS 将多个文件系统（称为“层”）合并为一个逻辑文件系统，使用户看到一个统一的目录结构。
+
+.. toctree::
+   :maxdepth: 1
+
+   overlayfs

docs/kernel/filesystem/unionfs/overlayfs.md

@@ -0,0 +1,26 @@
+# overlayfs
+
+OverlayFs是目前使用最多的联合文件系统，原理简单方便使用，主要用于容器中
+在 Docker 中，OverlayFS 是默认的存储驱动之一。Docker 为每个容器创建一个独立的上层目录，而所有容器共享同一个下层镜像文件。这样的设计使得容器之间的资源共享更加高效，同时减少了存储需求。
+## 架构设计
+overlayfs主要有两个层，以及一个虚拟的合并层
+- Lower Layer（下层）：通常是 只读 文件系统。可以包含多层。
+- Upper Layer（上层）：为 可写层，所有的写操作都会在这一层上进行。
+- Merged Layer（合并层）：上层和下层的逻辑视图合并后，向用户呈现的最终文件系统。
+
+
+## 工作原理
+- 读取操作：
+    -  OverlayFS 会优先从 Upper Layer 读取文件。如果文件不存在于上层，则读取 Lower Layer 中的内容。
+- 写入操作：
+    - 如果一个文件位于 Lower Layer 中，并尝试写入该文件，系统会将其 copy-up 到 Upper Layer 并在上层写入。如果文件已经存在于 Upper Layer，则直接在该层写入。
+- 删除操作：
+    - 当删除文件时，OverlayFS 会在上层创建一个标记为 whiteout 的条目，这会隐藏下层的文件。
+
+## Copy-up
+- 写时拷贝
+当一个文件从 下层 被修改时，它会被复制到 上层（称为 copy-up）。之后的所有修改都会发生在上层的文件副本上。
+
+
+## 实现逻辑
+通过构建ovlInode来实现indexnode这个trait来代表上层或者下层的inode，具体的有关文件文件夹的操作都在

kernel/Cargo.toml

@@ -15,7 +15,7 @@ members = [
 ]
 
 [features]
-default = ["backtrace", "kvm", "fatfs", "fatfs-secure"]
+default = ["backtrace", "kvm", "fatfs", "fatfs-secure", "static_keys_test"]
 # 内核栈回溯
 backtrace = []
 # kvm
@@ -27,6 +27,7 @@ driver_ps2_mouse = []
 
 # kprobe
 kprobe_test = []
+static_keys_test = []
 
 # 运行时依赖项
 [dependencies]
@@ -67,6 +68,8 @@ lru = "0.12.3"
 
 rbpf = { path = "crates/rbpf" }
 printf-compat = { version = "0.1.1", default-features = false }
+static-keys = "=0.6.1"
+
 # target为x86_64时，使用下面的依赖
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 mini-backtrace = { git = "https://git.mirrors.dragonos.org.cn/DragonOS-Community/mini-backtrace.git", rev = "e0b1d90940" }

kernel/Makefile

@@ -36,14 +36,14 @@ check: ECHO
 # @echo "Checking kernel... ARCH=$(ARCH)"
 # @exit 1
 ifeq ($(ARCH), x86_64)
-	RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-07-23 check --workspace $(CARGO_ZBUILD) --message-format=json --target ./src/$(TARGET_JSON)
+	RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-11-05 check --workspace $(CARGO_ZBUILD) --message-format=json --target ./src/$(TARGET_JSON)
 else ifeq ($(ARCH), riscv64)
-	RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-07-23 check --workspace $(CARGO_ZBUILD) --message-format=json --target $(TARGET_JSON)
+	RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-11-05 check --workspace $(CARGO_ZBUILD) --message-format=json --target $(TARGET_JSON)
 endif
 
 test:
 # 测试内核库
-	RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-07-23 test --workspace --exclude dragonos_kernel rbpf
+	RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-11-05 test --workspace --exclude dragonos_kernel rbpf
 
 test-rbpf:
-	cd crates/rbpf && RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-07-23 test --features=std,user,cranelift
+	cd crates/rbpf && RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-11-05 test --features=std,user,cranelift

kernel/crates/bitmap/src/alloc_bitmap.rs

@@ -13,7 +13,7 @@ pub struct AllocBitmap {
 
 impl AllocBitmap {
     pub fn new(elements: usize) -> Self {
-        let data = vec![0usize; (elements + usize::BITS as usize - 1) / (usize::BITS as usize)];
+        let data = vec![0usize; elements.div_ceil(usize::BITS as usize)];
         Self {
             elements,
             data,

kernel/crates/bitmap/src/static_bitmap.rs

@@ -8,15 +8,15 @@ use crate::{bitmap_core::BitMapCore, traits::BitMapOps};
 #[derive(Debug, Clone)]
 pub struct StaticBitmap<const N: usize>
 where
-    [(); (N + usize::BITS as usize - 1) / (usize::BITS as usize)]:,
+    [(); N.div_ceil(usize::BITS as usize)]:,
 {
-    pub data: [usize; (N + usize::BITS as usize - 1) / (usize::BITS as usize)],
+    pub data: [usize; N.div_ceil(usize::BITS as usize)],
     core: BitMapCore<usize>,
 }
 
 impl<const N: usize> Default for StaticBitmap<N>
 where
-    [(); (N + usize::BITS as usize - 1) / (usize::BITS as usize)]:,
+    [(); N.div_ceil(usize::BITS as usize)]:,
 {
     fn default() -> Self {
         Self::new()
@@ -25,12 +25,12 @@ where
 
 impl<const N: usize> StaticBitmap<N>
 where
-    [(); (N + usize::BITS as usize - 1) / (usize::BITS as usize)]:,
+    [(); N.div_ceil(usize::BITS as usize)]:,
 {
     /// 创建一个新的静态位图
     pub const fn new() -> Self {
         Self {
-            data: [0; (N + usize::BITS as usize - 1) / (usize::BITS as usize)],
+            data: [0; N.div_ceil(usize::BITS as usize)],
             core: BitMapCore::new(),
         }
     }
@@ -38,7 +38,7 @@ where
 
 impl<const N: usize> BitMapOps<usize> for StaticBitmap<N>
 where
-    [(); (N + usize::BITS as usize - 1) / (usize::BITS as usize)]:,
+    [(); N.div_ceil(usize::BITS as usize)]:,
 {
     #[inline]
     fn get(&self, index: usize) -> Option<bool> {

kernel/crates/crc/src/lib.rs

@@ -1,6 +1,5 @@
 #![cfg_attr(not(test), no_std)]
 #![feature(const_for)]
-#![feature(const_mut_refs)]
 #![feature(const_trait_impl)]
 #![allow(clippy::needless_return)]
 

kernel/crates/ida/src/lib.rs

@@ -16,7 +16,7 @@ struct EmptyIdaItemRef<'a> {
     _marker: PhantomData<&'a EmptyIdaItem>,
 }
 
-impl<'a> Deref for EmptyIdaItemRef<'a> {
+impl Deref for EmptyIdaItemRef<'_> {
     type Target = EmptyIdaItem;
 
     fn deref(&self) -> &Self::Target {
@@ -27,7 +27,10 @@ impl<'a> Deref for EmptyIdaItemRef<'a> {
 struct EmptyIdaItem;
 
 unsafe impl kdepends::xarray::ItemEntry for EmptyIdaItem {
-    type Ref<'a> = EmptyIdaItemRef<'a> where Self: 'a;
+    type Ref<'a>
+        = EmptyIdaItemRef<'a>
+    where
+        Self: 'a;
 
     fn into_raw(self) -> *const () {
         core::ptr::null()
@@ -140,6 +143,11 @@ impl IdAllocator {
     pub fn used(&self) -> usize {
         self.used
     }
+
+    /// 返回最大id数
+    pub fn get_max_id(&self) -> usize {
+        self.max_id
+    }
 }
 
 impl core::fmt::Debug for IdAllocator {

kernel/crates/intertrait/macros/src/lib.rs

@@ -61,7 +61,6 @@ mod item_type;
 /// #[derive(std::fmt::Debug)]
 /// struct Data;
 /// ```
-
 #[proc_macro_attribute]
 pub fn cast_to(args: TokenStream, input: TokenStream) -> TokenStream {
     match parse::<Targets>(args) {

kernel/crates/intertrait/src/lib.rs

@@ -122,6 +122,7 @@ static CASTER_MAP: once_cell::sync::Lazy<HashMap<(TypeId, TypeId), BoxedCaster,
 static mut CASTER_MAP: Option<HashMap<(TypeId, TypeId), BoxedCaster, BuildFastHasher>> = None;
 
 #[cfg(target_os = "none")]
+#[allow(static_mut_refs)]
 pub fn caster_map() -> &'static HashMap<(TypeId, TypeId), BoxedCaster, BuildFastHasher> {
     return unsafe {
         CASTER_MAP.as_ref().unwrap_or_else(|| {

kernel/crates/klog_types/src/lib.rs

@@ -1,5 +1,4 @@
 #![no_std]
-#![feature(const_refs_to_cell)]
 #![feature(const_size_of_val)]
 #![allow(clippy::needless_return)]
 

kernel/crates/rbpf/src/insn_builder.rs

@@ -74,7 +74,7 @@ pub trait IntoBytes {
 }
 
 /// General implementation of `IntoBytes` for `Instruction`
-impl<'i, I: Instruction> IntoBytes for &'i I {
+impl<I: Instruction> IntoBytes for &'_ I {
     type Bytes = Vec<u8>;
 
     /// transform immutable reference of `Instruction` into `Vec<u8>` with size of 8
@@ -347,7 +347,7 @@ impl<'i> Move<'i> {
     }
 }
 
-impl<'i> Instruction for Move<'i> {
+impl Instruction for Move<'_> {
     fn opt_code_byte(&self) -> u8 {
         let op_bits = self.op_bits as u8;
         let src_bit = self.src_bit as u8;
@@ -415,7 +415,7 @@ impl<'i> SwapBytes<'i> {
     }
 }
 
-impl<'i> Instruction for SwapBytes<'i> {
+impl Instruction for SwapBytes<'_> {
     fn opt_code_byte(&self) -> u8 {
         self.endian as u8
     }
@@ -456,20 +456,20 @@ impl<'i> Load<'i> {
     }
 }
 
-impl<'i> Instruction for Load<'i> {
+impl Instruction for Load<'_> {
     fn opt_code_byte(&self) -> u8 {
         let size = self.mem_size as u8;
         let addressing = self.addressing as u8;
         addressing | size | self.source
     }
 
-    fn get_insn_mut(&mut self) -> &mut Insn {
-        &mut self.insn
-    }
-
     fn get_insn(&self) -> &Insn {
         &self.insn
     }
+
+    fn get_insn_mut(&mut self) -> &mut Insn {
+        &mut self.insn
+    }
 }
 
 /// struct representation of STORE instructions
@@ -489,19 +489,19 @@ impl<'i> Store<'i> {
     }
 }
 
-impl<'i> Instruction for Store<'i> {
+impl Instruction for Store<'_> {
     fn opt_code_byte(&self) -> u8 {
         let size = self.mem_size as u8;
         BPF_MEM | BPF_ST | size | self.source
     }
 
-    fn get_insn_mut(&mut self) -> &mut Insn {
-        &mut self.insn
-    }
-
     fn get_insn(&self) -> &Insn {
         &self.insn
     }
+
+    fn get_insn_mut(&mut self) -> &mut Insn {
+        &mut self.insn
+    }
 }
 
 #[derive(Copy, Clone)]
@@ -542,20 +542,20 @@ impl<'i> Jump<'i> {
     }
 }
 
-impl<'i> Instruction for Jump<'i> {
+impl Instruction for Jump<'_> {
     fn opt_code_byte(&self) -> u8 {
         let cmp: u8 = self.cond as u8;
         let src_bit = self.src_bit as u8;
         cmp | src_bit | BPF_JMP
     }
 
-    fn get_insn_mut(&mut self) -> &mut Insn {
-        &mut self.insn
-    }
-
     fn get_insn(&self) -> &Insn {
         &self.insn
     }
+
+    fn get_insn_mut(&mut self) -> &mut Insn {
+        &mut self.insn
+    }
 }
 
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -602,18 +602,18 @@ impl<'i> FunctionCall<'i> {
     }
 }
 
-impl<'i> Instruction for FunctionCall<'i> {
+impl Instruction for FunctionCall<'_> {
     fn opt_code_byte(&self) -> u8 {
         BPF_CALL | BPF_JMP
     }
 
-    fn get_insn_mut(&mut self) -> &mut Insn {
-        &mut self.insn
-    }
-
     fn get_insn(&self) -> &Insn {
         &self.insn
     }
+
+    fn get_insn_mut(&mut self) -> &mut Insn {
+        &mut self.insn
+    }
 }
 
 /// struct representation of EXIT instruction
@@ -631,7 +631,7 @@ impl<'i> Exit<'i> {
     }
 }
 
-impl<'i> Instruction for Exit<'i> {
+impl Instruction for Exit<'_> {
     fn opt_code_byte(&self) -> u8 {
         BPF_EXIT | BPF_JMP
     }

kernel/crates/rbpf/tests/ubpf_vm.rs

@@ -2316,8 +2316,12 @@ fn test_vm_stdw() {
 // If this case is not handled properly in check_mem(), then we may overflow when adding the
 // context address and the offset, and make the thread panic with "attempt to add with overflow".
 // Check that we panic with the expected out-of-bounds error.
+//
+// The new toolchain introduced `assert_unsafe_precondition` which panics with a different message and can't be
+// caught by `#[should_panic]`. This is why we use `#[ignore]` here.
 #[test]
 #[should_panic(expected = "Error: out of bounds memory store (insn #1)")]
+#[ignore]
 fn test_vm_stdw_add_overflow() {
     let prog = assemble(
         "

kernel/crates/rust-slabmalloc/src/lib.rs

@@ -18,11 +18,9 @@
 //! # Implementing GlobalAlloc
 //! See the [global alloc](https://github.com/gz/rust-slabmalloc/tree/master/examples/global_alloc.rs) example.
 #![allow(unused_features)]
-#![cfg_attr(feature = "unstable", feature(const_mut_refs))]
 #![no_std]
 #![crate_name = "slabmalloc"]
 #![crate_type = "lib"]
-#![feature(new_uninit)]
 #![feature(maybe_uninit_as_bytes)]
 
 extern crate alloc;
@@ -65,6 +63,8 @@ pub enum AllocationError {
 /// Needs to adhere to safety requirements of a rust allocator (see GlobalAlloc et. al.).
 pub unsafe trait Allocator<'a> {
     fn allocate(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocationError>;
+    /// # Safety
+    /// The caller must ensure that the memory is valid and that the layout is correct.
     unsafe fn deallocate(
         &mut self,
         ptr: NonNull<u8>,
@@ -85,5 +85,7 @@ pub unsafe trait Allocator<'a> {
 
 /// 将slab_page归还Buddy的回调函数
 pub trait CallBack: Send + Sync {
+    /// # Safety
+    /// The caller must ensure that the memory is valid and that the size is correct.
     unsafe fn free_slab_page(&self, _: *mut u8, _: usize) {}
 }

kernel/crates/rust-slabmalloc/src/pages.rs

@@ -303,10 +303,10 @@ impl<'a> ObjectPage<'a> {
 }
 
 // These needs some more work to be really safe...
-unsafe impl<'a> Send for ObjectPage<'a> {}
-unsafe impl<'a> Sync for ObjectPage<'a> {}
+unsafe impl Send for ObjectPage<'_> {}
+unsafe impl Sync for ObjectPage<'_> {}
 
-impl<'a> AllocablePage for ObjectPage<'a> {
+impl AllocablePage for ObjectPage<'_> {
     const SIZE: usize = OBJECT_PAGE_SIZE;
 
     fn bitfield(&self) -> &[AtomicU64; 8] {
@@ -331,7 +331,7 @@ impl<'a> Default for ObjectPage<'a> {
     }
 }
 
-impl<'a> fmt::Debug for ObjectPage<'a> {
+impl fmt::Debug for ObjectPage<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "ObjectPage")
     }

kernel/crates/rust-slabmalloc/src/sc.rs

@@ -314,6 +314,9 @@ impl<'a, P: AllocablePage> SCAllocator<'a, P> {
     /// May return an error in case an invalid `layout` is provided.
     /// The function may also move internal slab pages between lists partial -> empty
     /// or full -> partial lists.
+    ///
+    /// # Safety
+    /// The caller must ensure that the `layout` is valid.
     pub unsafe fn deallocate(
         &mut self,
         ptr: NonNull<u8>,

kernel/crates/system_error/Cargo.toml

@@ -6,7 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-kdepends = { path = "../kdepends" }
 num-traits = { git = "https://git.mirrors.dragonos.org.cn/DragonOS-Community/num-traits.git", rev="1597c1c", default-features = false }
-num = { version = "0.4.0", default-features = false }
 num-derive = "0.3"

kernel/crates/system_error/src/lib.rs

@@ -1,7 +1,7 @@
 #![no_std]
 #![allow(clippy::needless_return)]
 #![allow(clippy::upper_case_acronyms)]
-
+#![allow(non_local_definitions)]
 use num_derive::{FromPrimitive, ToPrimitive};
 
 #[repr(i32)]

kernel/rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2024-07-23"
+channel = "nightly-2024-11-05"
 components = ["rust-src", "clippy"]

kernel/src/Makefile

@@ -40,7 +40,7 @@ kernel_subdirs := debug
 
 
 kernel_rust:
-	RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-07-23 $(CARGO_ZBUILD) build --release --target $(TARGET_JSON)
+	RUSTFLAGS="$(RUSTFLAGS)" cargo +nightly-2024-11-05 $(CARGO_ZBUILD) build --release --target $(TARGET_JSON)
 
 
 all: kernel

kernel/src/arch/riscv64/interrupt/entry.rs

@@ -4,7 +4,6 @@ use crate::arch::{
     interrupt::TrapFrame,
 };
 use asm_macros::{restore_from_x6_to_x31, save_from_x6_to_x31};
-use core::arch::asm;
 use kdepends::memoffset::offset_of;
 
 /// Riscv64中断处理入口
@@ -12,7 +11,7 @@ use kdepends::memoffset::offset_of;
 #[no_mangle]
 #[repr(align(4))]
 pub unsafe extern "C" fn handle_exception() -> ! {
-    asm!(
+    core::arch::naked_asm!(
         concat!("
         /*
 	        * If coming from userspace, preserve the user thread pointer and load
@@ -27,15 +26,14 @@ pub unsafe extern "C" fn handle_exception() -> ! {
             j {_restore_kernel_tpsp}
         "),
         csr_scratch = const CSR_SSCRATCH,
-        _restore_kernel_tpsp = sym _restore_kernel_tpsp,
-        options(noreturn),
+        _restore_kernel_tpsp = sym _restore_kernel_tpsp
     )
 }
 
 #[naked]
 #[no_mangle]
 unsafe extern "C" fn _restore_kernel_tpsp() -> ! {
-    asm!(
+    core::arch::naked_asm!(
         concat!("
             // 这次是从内核态进入中断
             // 从sscratch寄存器加载当前cpu的上下文
@@ -48,16 +46,14 @@ unsafe extern "C" fn _restore_kernel_tpsp() -> ! {
         "),
         csr_scratch = const CSR_SSCRATCH,
         lc_off_kernel_sp = const offset_of!(LocalContext, kernel_sp),
-        _save_context = sym _save_context,
-
-        options(noreturn),
+        _save_context = sym _save_context
     )
 }
 
 #[naked]
 #[no_mangle]
 unsafe extern "C" fn _save_context() -> ! {
-    asm!(
+    core::arch::naked_asm!(
         concat!("
 
 
@@ -164,15 +160,14 @@ unsafe extern "C" fn _save_context() -> ! {
         csr_epc = const CSR_SEPC,
         csr_tval = const CSR_STVAL,
         csr_cause = const CSR_SCAUSE,
-        csr_scratch = const CSR_SSCRATCH,
-        options(noreturn),
+        csr_scratch = const CSR_SSCRATCH
     )
 }
 
 #[naked]
 #[no_mangle]
 pub unsafe extern "C" fn ret_from_exception() -> ! {
-    asm!(
+    core::arch::naked_asm!(
         concat!("
             ld s0, {off_status}(sp)
             andi s0, s0, {sr_spp}
@@ -249,8 +244,6 @@ pub unsafe extern "C" fn ret_from_exception() -> ! {
         off_t6 = const offset_of!(TrapFrame, t6),
         off_sp = const offset_of!(TrapFrame, sp),
         off_tp = const offset_of!(TrapFrame, tp),
-        off_epc = const offset_of!(TrapFrame, epc),
-
-        options(noreturn),
+        off_epc = const offset_of!(TrapFrame, epc)
     )
 }

kernel/src/arch/riscv64/process/kthread.rs

@@ -66,7 +66,7 @@ impl KernelThreadMechanism {
 pub(super) unsafe extern "C" fn kernel_thread_bootstrap_stage1() {
     // 这个函数要是naked的，只是因为现在还没有实现，而naked func不能打`unimplemented!()`
     // 所以先写成了普通函数
-    asm!(concat!(
+    core::arch::naked_asm!(concat!(
         "
             ld x3, {off_gp}(sp)
             ld x5, {off_t0}(sp)
@@ -111,8 +111,7 @@ pub(super) unsafe extern "C" fn kernel_thread_bootstrap_stage1() {
         off_t4 = const offset_of!(TrapFrame, t4),
         off_t5 = const offset_of!(TrapFrame, t5),
         off_t6 = const offset_of!(TrapFrame, t6),
-        stage2_func = sym jump_to_stage2,
-        options(noreturn),
+        stage2_func = sym jump_to_stage2
     );
 }
 

kernel/src/arch/riscv64/process/mod.rs

@@ -78,9 +78,8 @@ pub unsafe fn arch_switch_to_user(trap_frame: TrapFrame) -> ! {
 
 #[naked]
 unsafe extern "C" fn ready_to_switch_to_user(trap_frame: usize, new_pc: usize) -> ! {
-    asm!(
-        concat!(
-            "
+    core::arch::naked_asm!(concat!(
+        "
             // 设置trap frame
             mv sp, a0
             // 设置返回地址
@@ -88,9 +87,7 @@ unsafe extern "C" fn ready_to_switch_to_user(trap_frame: usize, new_pc: usize) -
             jr a1
             
             "
-        ),
-        options(noreturn)
-    );
+    ));
 }
 
 impl ProcessManager {
@@ -104,7 +101,7 @@ impl ProcessManager {
     pub fn copy_thread(
         current_pcb: &Arc<ProcessControlBlock>,
         new_pcb: &Arc<ProcessControlBlock>,
-        clone_args: KernelCloneArgs,
+        clone_args: &KernelCloneArgs,
         current_trapframe: &TrapFrame,
     ) -> Result<(), SystemError> {
         let clone_flags = clone_args.flags;
@@ -227,7 +224,7 @@ impl ProcessManager {
 /// 参考 https://code.dragonos.org.cn/xref/linux-6.6.21/arch/riscv/kernel/entry.S#233
 #[naked]
 unsafe extern "C" fn switch_to_inner(prev: *mut ArchPCBInfo, next: *mut ArchPCBInfo) {
-    core::arch::asm!(concat!(
+    core::arch::naked_asm!(concat!(
         "
             sd ra, {off_ra}(a0)
             sd sp, {off_sp}(a0)
@@ -304,8 +301,7 @@ unsafe extern "C" fn switch_to_inner(prev: *mut ArchPCBInfo, next: *mut ArchPCBI
     off_s9 = const(offset_of!(ArchPCBInfo, s9)),
     off_s10 = const(offset_of!(ArchPCBInfo, s10)),
     off_s11 = const(offset_of!(ArchPCBInfo, s11)),
-    before_switch_finish_hook = sym before_switch_finish_hook,
-    options(noreturn));
+    before_switch_finish_hook = sym before_switch_finish_hook);
 }
 
 /// 在切换上下文完成后的钩子函数(必须在这里加一个跳转函数，否则会出现relocation truncated to fit: R_RISCV_JAL错误)

kernel/src/arch/riscv64/process/syscall.rs

@@ -1,96 +1,21 @@
-use alloc::{ffi::CString, string::String, vec::Vec};
 use riscv::register::sstatus::{FS, SPP};
 use system_error::SystemError;
 
 use crate::{
-    arch::{interrupt::TrapFrame, CurrentIrqArch},
-    exception::InterruptArch,
-    mm::ucontext::AddressSpace,
-    process::{
-        exec::{load_binary_file, ExecParam, ExecParamFlags},
-        ProcessManager,
-    },
+    arch::interrupt::TrapFrame,
+    mm::VirtAddr,
+    process::exec::{BinaryLoaderResult, ExecParam},
     syscall::Syscall,
 };
 
 impl Syscall {
-    pub fn do_execve(
-        path: String,
-        argv: Vec<CString>,
-        envp: Vec<CString>,
+    pub fn arch_do_execve(
         regs: &mut TrapFrame,
+        param: &ExecParam,
+        load_result: &BinaryLoaderResult,
+        user_sp: VirtAddr,
+        argv_ptr: VirtAddr,
     ) -> Result<(), SystemError> {
-        // 关中断，防止在设置地址空间的时候，发生中断，然后进调度器，出现错误。
-        let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
-        let pcb = ProcessManager::current_pcb();
-        // crate::debug!(
-        //     "pid: {:?}  do_execve: path: {:?}, argv: {:?}, envp: {:?}\n",
-        //     pcb.pid(),
-        //     path,
-        //     argv,
-        //     envp
-        // );
-
-        let mut basic_info = pcb.basic_mut();
-        // 暂存原本的用户地址空间的引用(因为如果在切换页表之前释放了它，可能会造成内存use after free)
-        let old_address_space = basic_info.user_vm();
-
-        // 在pcb中原来的用户地址空间
-        unsafe {
-            basic_info.set_user_vm(None);
-        }
-        // 创建新的地址空间并设置为当前地址空间
-        let address_space = AddressSpace::new(true).expect("Failed to create new address space");
-        unsafe {
-            basic_info.set_user_vm(Some(address_space.clone()));
-        }
-
-        // to avoid deadlock
-        drop(basic_info);
-
-        assert!(
-            AddressSpace::is_current(&address_space),
-            "Failed to set address space"
-        );
-        // debug!("Switch to new address space");
-
-        // 切换到新的用户地址空间
-        unsafe { address_space.read().user_mapper.utable.make_current() };
-
-        drop(old_address_space);
-        drop(irq_guard);
-        // debug!("to load binary file");
-        let mut param = ExecParam::new(path.as_str(), address_space.clone(), ExecParamFlags::EXEC)?;
-
-        // 加载可执行文件
-        let load_result = load_binary_file(&mut param)?;
-        // debug!("load binary file done");
-        // debug!("argv: {:?}, envp: {:?}", argv, envp);
-        param.init_info_mut().args = argv;
-        param.init_info_mut().envs = envp;
-
-        // 把proc_init_info写到用户栈上
-        let mut ustack_message = unsafe {
-            address_space
-                .write()
-                .user_stack_mut()
-                .expect("No user stack found")
-                .clone_info_only()
-        };
-        let (user_sp, argv_ptr) = unsafe {
-            param
-                .init_info()
-                .push_at(
-                    // address_space
-                    //     .write()
-                    //     .user_stack_mut()
-                    //     .expect("No user stack found"),
-                    &mut ustack_message,
-                )
-                .expect("Failed to push proc_init_info to user stack")
-        };
-        address_space.write().user_stack = Some(ustack_message);
-
         // debug!("write proc_init_info to user stack done");
 
         regs.a0 = param.init_info().args.len();
@@ -104,8 +29,6 @@ impl Syscall {
         regs.status.update_fs(FS::Clean);
         regs.status.update_sum(true);
 
-        drop(param);
-
         return Ok(());
     }
 

kernel/src/arch/x86_64/interrupt/entry.rs

@@ -45,7 +45,7 @@ macro_rules! interrupt_handler {
             #[naked]
             #[no_mangle]
             unsafe extern "C" fn [<irq_handler $name>]() {
-                core::arch::asm!(
+                core::arch::naked_asm!(
                     concat!(
                         "
                         push 0x0
@@ -60,8 +60,7 @@ macro_rules! interrupt_handler {
                         jmp x86_64_do_irq
                         "
                     ),
-                    irqnum = const($name),
-                    options(noreturn)
+                    irqnum = const($name)
                 );
             }
         }

kernel/src/arch/x86_64/ipc/signal.rs

@@ -431,8 +431,6 @@ impl SignalArch for X86_64SignalArch {
             return;
         }
 
-        let pcb = ProcessManager::current_pcb();
-
         let mut sig_number: Signal;
         let mut info: Option<SigInfo>;
         let mut sigaction: Sigaction;
@@ -483,9 +481,13 @@ impl SignalArch for X86_64SignalArch {
         //避免死锁
         drop(siginfo_mut_guard);
         drop(sig_guard);
+        drop(pcb);
 
         // 做完上面的检查后，开中断
         CurrentIrqArch::interrupt_enable();
+
+        // 注意！由于handle_signal里面可能会退出进程，
+        // 因此这里需要检查清楚：上面所有的锁、arc指针都被释放了。否则会产生资源泄露的问题！
         let res: Result<i32, SystemError> =
             handle_signal(sig_number, &mut sigaction, &info.unwrap(), &oldset, frame);
         if res.is_err() {

kernel/src/arch/x86_64/mm/mod.rs

@@ -500,7 +500,7 @@ unsafe fn allocator_init() {
         for i in 0..total_num {
             let area = mem_block_manager().get_initial_memory_region(i).unwrap();
             // debug!("area: base={:?}, size={:#x}, end={:?}", area.base, area.size, area.base + area.size);
-            for i in 0..((area.size + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE) {
+            for i in 0..area.size.div_ceil(MMArch::PAGE_SIZE) {
                 let paddr = area.base.add(i * MMArch::PAGE_SIZE);
                 let vaddr = unsafe { MMArch::phys_2_virt(paddr) }.unwrap();
                 let flags = kernel_page_flags::<MMArch>(vaddr);

kernel/src/arch/x86_64/process/kthread.rs

@@ -1,5 +1,3 @@
-use core::arch::asm;
-
 use alloc::sync::Arc;
 use system_error::SystemError;
 
@@ -61,7 +59,7 @@ impl KernelThreadMechanism {
 /// 跳转之后，指向Box<KernelThreadClosure>的指针将传入到stage2的函数
 #[naked]
 pub(super) unsafe extern "sysv64" fn kernel_thread_bootstrap_stage1() {
-    asm!(
+    core::arch::naked_asm!(
         concat!(
             "
 
@@ -92,6 +90,5 @@ pub(super) unsafe extern "sysv64" fn kernel_thread_bootstrap_stage1() {
             "
         ),
         stage2_func = sym kernel_thread_bootstrap_stage2,
-        options(noreturn)
     )
 }

kernel/src/arch/x86_64/process/mod.rs

@@ -299,7 +299,7 @@ impl ProcessManager {
     pub fn copy_thread(
         current_pcb: &Arc<ProcessControlBlock>,
         new_pcb: &Arc<ProcessControlBlock>,
-        clone_args: KernelCloneArgs,
+        clone_args: &KernelCloneArgs,
         current_trapframe: &TrapFrame,
     ) -> Result<(), SystemError> {
         let clone_flags = clone_args.flags;
@@ -425,7 +425,7 @@ impl ProcessManager {
 /// 保存上下文，然后切换进程，接着jmp到`switch_finish_hook`钩子函数
 #[naked]
 unsafe extern "sysv64" fn switch_to_inner(prev: *mut ArchPCBInfo, next: *mut ArchPCBInfo) {
-    asm!(
+    core::arch::naked_asm!(
         // As a quick reminder for those who are unfamiliar with the System V ABI (extern "C"):
         //
         // - the current parameters are passed in the registers `rdi`, `rsi`,
@@ -498,13 +498,12 @@ unsafe extern "sysv64" fn switch_to_inner(prev: *mut ArchPCBInfo, next: *mut Arc
         off_gs = const(offset_of!(ArchPCBInfo, gs)),
 
         switch_hook = sym crate::process::switch_finish_hook,
-        options(noreturn),
     );
 }
 
 #[naked]
 unsafe extern "sysv64" fn switch_back() -> ! {
-    asm!("ret", options(noreturn));
+    core::arch::naked_asm!("ret");
 }
 
 pub unsafe fn arch_switch_to_user(trap_frame: TrapFrame) -> ! {

kernel/src/arch/x86_64/process/syscall.rs

@@ -1,99 +1,27 @@
-use alloc::{ffi::CString, string::String, sync::Arc, vec::Vec};
+use alloc::sync::Arc;
 use system_error::SystemError;
 
 use crate::{
     arch::{
         interrupt::TrapFrame,
         process::table::{USER_CS, USER_DS},
-        CurrentIrqArch,
     },
-    exception::InterruptArch,
-    mm::ucontext::AddressSpace,
+    mm::VirtAddr,
     process::{
-        exec::{load_binary_file, ExecParam, ExecParamFlags},
+        exec::{BinaryLoaderResult, ExecParam},
         ProcessControlBlock, ProcessManager,
     },
     syscall::{user_access::UserBufferWriter, Syscall},
 };
 
 impl Syscall {
-    pub fn do_execve(
-        path: String,
-        argv: Vec<CString>,
-        envp: Vec<CString>,
+    pub fn arch_do_execve(
         regs: &mut TrapFrame,
+        param: &ExecParam,
+        load_result: &BinaryLoaderResult,
+        user_sp: VirtAddr,
+        argv_ptr: VirtAddr,
     ) -> Result<(), SystemError> {
-        // 关中断，防止在设置地址空间的时候，发生中断，然后进调度器，出现错误。
-        let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
-        let pcb = ProcessManager::current_pcb();
-        // log::debug!(
-        //     "pid: {:?}  do_execve: path: {:?}, argv: {:?}, envp: {:?}\n",
-        //     pcb.pid(),
-        //     path,
-        //     argv,
-        //     envp
-        // );
-
-        let mut basic_info = pcb.basic_mut();
-        // 暂存原本的用户地址空间的引用(因为如果在切换页表之前释放了它，可能会造成内存use after free)
-        let old_address_space = basic_info.user_vm();
-
-        // 在pcb中原来的用户地址空间
-        unsafe {
-            basic_info.set_user_vm(None);
-        }
-        // 创建新的地址空间并设置为当前地址空间
-        let address_space = AddressSpace::new(true).expect("Failed to create new address space");
-        unsafe {
-            basic_info.set_user_vm(Some(address_space.clone()));
-        }
-
-        // to avoid deadlock
-        drop(basic_info);
-
-        assert!(
-            AddressSpace::is_current(&address_space),
-            "Failed to set address space"
-        );
-        // debug!("Switch to new address space");
-
-        // 切换到新的用户地址空间
-        unsafe { address_space.read().user_mapper.utable.make_current() };
-
-        drop(old_address_space);
-        drop(irq_guard);
-        // debug!("to load binary file");
-        let mut param = ExecParam::new(path.as_str(), address_space.clone(), ExecParamFlags::EXEC)?;
-
-        // 加载可执行文件
-        let load_result = load_binary_file(&mut param)?;
-        // debug!("load binary file done");
-        // debug!("argv: {:?}, envp: {:?}", argv, envp);
-        param.init_info_mut().args = argv;
-        param.init_info_mut().envs = envp;
-
-        // 把proc_init_info写到用户栈上
-        let mut ustack_message = unsafe {
-            address_space
-                .write()
-                .user_stack_mut()
-                .expect("No user stack found")
-                .clone_info_only()
-        };
-        let (user_sp, argv_ptr) = unsafe {
-            param
-                .init_info()
-                .push_at(
-                    // address_space
-                    //     .write()
-                    //     .user_stack_mut()
-                    //     .expect("No user stack found"),
-                    &mut ustack_message,
-                )
-                .expect("Failed to push proc_init_info to user stack")
-        };
-        address_space.write().user_stack = Some(ustack_message);
-
         // debug!("write proc_init_info to user stack done");
 
         // （兼容旧版libc）把argv的指针写到寄存器内
@@ -114,8 +42,6 @@ impl Syscall {
         regs.rflags = 0x200;
         regs.rax = 1;
 
-        drop(param);
-
         // debug!("regs: {:?}\n", regs);
 
         // crate::debug!(

kernel/src/arch/x86_64/smp/mod.rs

@@ -1,5 +1,4 @@
 use core::{
-    arch::asm,
     hint::spin_loop,
     sync::atomic::{compiler_fence, fence, AtomicBool, Ordering},
 };
@@ -65,14 +64,13 @@ unsafe extern "C" fn smp_ap_start() -> ! {
 
 #[naked]
 unsafe extern "sysv64" fn smp_init_switch_stack(st: &ApStartStackInfo) -> ! {
-    asm!(concat!("
+    core::arch::naked_asm!(concat!("
         mov rsp, [rdi + {off_rsp}]
         mov rbp, [rdi + {off_rsp}]
         jmp {stage1}
     "), 
         off_rsp = const(offset_of!(ApStartStackInfo, vaddr)),
-        stage1 = sym smp_ap_start_stage1,
-    options(noreturn));
+        stage1 = sym smp_ap_start_stage1);
 }
 
 unsafe extern "C" fn smp_ap_start_stage1() -> ! {

kernel/src/cgroup/mem_cgroup.rs

@@ -0,0 +1,6 @@
+use super::CgroupSubsysState;
+
+struct MemCgroup {
+    css: CgroupSubsysState,
+    id: u32,
+}

kernel/src/cgroup/mod.rs

@@ -0,0 +1,48 @@
+#![allow(dead_code, unused_variables, unused_imports)]
+pub mod mem_cgroup;
+
+use alloc::{collections::LinkedList, rc::Weak, sync::Arc, vec::Vec};
+
+use alloc::boxed::Box;
+
+use crate::filesystem::vfs::IndexNode;
+
+pub struct Cgroup {
+    css: Weak<CgroupSubsysState>,
+    /// 当前所在的深度
+    level: u32,
+    /// 支持的最大深度
+    max_depth: u32,
+    /// 可见后代数量
+    nr_descendants: u32,
+    /// 正在死亡后代数量
+    nr_dying_descendants: u32,
+    /// 允许的最大后代数量
+    max_descendants: u32,
+    /// css_set的数量
+    nr_populated_csets: u32,
+    /// 子group中有任务的记数
+    nr_populated_domain_children: u32,
+    /// 线程子group中有任务的记数
+    nr_populated_threaded_children: u32,
+    /// 活跃线程子cgroup数量
+    nr_threaded_children: u32,
+    /// 关联cgroup的inode
+    kernfs_node: Box<dyn IndexNode>,
+}
+
+/// 控制资源的统计信息
+pub struct CgroupSubsysState {
+    cgroup: Arc<Cgroup>,
+    /// 兄弟节点
+    sibling: LinkedList<Arc<Cgroup>>,
+    /// 孩子节点
+    children: LinkedList<Arc<Cgroup>>,
+}
+
+pub struct CgroupSubsys {}
+
+/// cgroup_sub_state 的集合
+pub struct CssSet {
+    subsys: Vec<Arc<CgroupSubsysState>>,
+}

kernel/src/debug/jump_label.rs

@@ -0,0 +1,28 @@
+#[cfg(feature = "static_keys_test")]
+mod tests {
+    use static_keys::{define_static_key_false, static_branch_unlikely};
+    define_static_key_false!(MY_STATIC_KEY);
+    #[inline(always)]
+    fn foo() {
+        println!("Entering foo function");
+        if static_branch_unlikely!(MY_STATIC_KEY) {
+            println!("A branch");
+        } else {
+            println!("B branch");
+        }
+    }
+
+    pub(super) fn static_keys_test() {
+        foo();
+        unsafe {
+            MY_STATIC_KEY.enable();
+        }
+        foo();
+    }
+}
+
+pub fn static_keys_init() {
+    static_keys::global_init();
+    #[cfg(feature = "static_keys_test")]
+    tests::static_keys_test();
+}

kernel/src/debug/mod.rs

@@ -1,2 +1,3 @@
+pub mod jump_label;
 pub mod klog;
 pub mod kprobe;

kernel/src/driver/base/block/block_device.rs

@@ -20,8 +20,8 @@ use system_error::SystemError;
 
 use super::{disk_info::Partition, gendisk::GenDisk, manager::BlockDevMeta};
 
-/// 该文件定义了 Device 和 BlockDevice 的接口
-/// Notice 设备错误码使用 Posix 规定的 int32_t 的错误码表示，而不是自己定义错误enum
+// 该文件定义了 Device 和 BlockDevice 的接口
+// Notice 设备错误码使用 Posix 规定的 int32_t 的错误码表示，而不是自己定义错误enum
 
 // 使用方法:
 // 假设 blk_dev 是块设备

kernel/src/driver/base/block/gendisk.rs

@@ -161,6 +161,7 @@ impl GenDiskMap {
     }
 
     #[inline]
+    #[allow(dead_code)]
     pub fn max_idx(&self) -> u32 {
         self.max_idx.load(Ordering::SeqCst)
     }

kernel/src/driver/base/block/manager.rs

@@ -134,6 +134,7 @@ impl BlockDevManager {
     }
 
     /// 卸载磁盘设备
+    #[allow(dead_code)]
     pub fn unregister(&self, dev: &Arc<dyn BlockDevice>) {
         let mut inner = self.inner();
         inner.disks.remove(dev.dev_name());

kernel/src/driver/base/char/mod.rs

@@ -18,7 +18,7 @@ use super::{
 pub trait CharDevice: Device {
     /// Notice buffer对应设备按字节划分，使用u8类型
     /// Notice offset应该从0开始计数
-
+    ///
     /// @brief: 从设备的第offset个字节开始，读取len个byte，存放到buf中
     /// @parameter offset: 起始字节偏移量
     /// @parameter len: 读取字节的数量

kernel/src/driver/block/virtio_blk.rs

@@ -137,6 +137,7 @@ impl VirtIOBlkManager {
         BlockDevName::new(format!("vd{}", x), id)
     }
 
+    #[allow(dead_code)]
     pub fn free_id(&self, id: usize) {
         if id >= Self::MAX_DEVICES {
             return;
@@ -163,8 +164,14 @@ unsafe impl Sync for VirtIOBlkDevice {}
 
 impl VirtIOBlkDevice {
     pub fn new(transport: VirtIOTransport, dev_id: Arc<DeviceId>) -> Option<Arc<Self>> {
+        // 设置中断
+        if let Err(err) = transport.setup_irq(dev_id.clone()) {
+            error!("VirtIOBlkDevice '{dev_id:?}' setup_irq failed: {:?}", err);
+            return None;
+        }
+
         let devname = virtioblk_manager().alloc_id()?;
-        let irq = transport.irq().map(|irq| IrqNumber::new(irq.data()));
+        let irq = Some(transport.irq());
         let device_inner = VirtIOBlk::<HalImpl, VirtIOTransport>::new(transport);
         if let Err(e) = device_inner {
             error!("VirtIOBlkDevice '{dev_id:?}' create failed: {:?}", e);

kernel/src/driver/disk/ahci/ahci_inode.rs

@@ -1,153 +0,0 @@
-use crate::driver::base::block::block_device::BlockDevice;
-use crate::driver::base::device::device_number::{DeviceNumber, Major};
-use crate::filesystem::devfs::{DevFS, DeviceINode};
-use crate::filesystem::vfs::file::FileMode;
-use crate::filesystem::vfs::syscall::ModeType;
-use crate::filesystem::vfs::{
-    core::generate_inode_id, FilePrivateData, FileSystem, FileType, IndexNode, Metadata,
-};
-use crate::libs::spinlock::SpinLockGuard;
-use crate::{libs::spinlock::SpinLock, time::PosixTimeSpec};
-use alloc::{
-    string::String,
-    sync::{Arc, Weak},
-    vec::Vec,
-};
-use system_error::SystemError;
-
-use super::ahcidisk::LockedAhciDisk;
-
-#[derive(Debug)]
-pub struct AhciInode {
-    /// uuid 暂时不知道有什么用（x
-    // uuid: Uuid,
-    /// 指向自身的弱引用
-    self_ref: Weak<LockedAhciInode>,
-    /// 指向inode所在的文件系统对象的指针
-    fs: Weak<DevFS>,
-    /// INode 元数据
-    metadata: Metadata,
-    /// INode 对应的磁盘
-    disk: Arc<LockedAhciDisk>,
-}
-
-#[derive(Debug)]
-pub struct LockedAhciInode(pub SpinLock<AhciInode>);
-
-impl LockedAhciInode {
-    pub fn new(disk: Arc<LockedAhciDisk>) -> Arc<Self> {
-        let inode = AhciInode {
-            // uuid: Uuid::new_v5(),
-            self_ref: Weak::default(),
-            fs: Weak::default(),
-            disk,
-            metadata: Metadata {
-                dev_id: 1,
-                inode_id: generate_inode_id(),
-                size: 0,
-                blk_size: 0,
-                blocks: 0,
-                atime: PosixTimeSpec::default(),
-                mtime: PosixTimeSpec::default(),
-                ctime: PosixTimeSpec::default(),
-                file_type: FileType::BlockDevice, // 文件夹，block设备，char设备
-                mode: ModeType::from_bits_truncate(0o666),
-                nlinks: 1,
-                uid: 0,
-                gid: 0,
-                raw_dev: DeviceNumber::new(Major::HD_MAJOR, 0),
-            },
-        };
-
-        let result = Arc::new(LockedAhciInode(SpinLock::new(inode)));
-        result.0.lock().self_ref = Arc::downgrade(&result);
-
-        return result;
-    }
-}
-
-impl DeviceINode for LockedAhciInode {
-    fn set_fs(&self, fs: Weak<DevFS>) {
-        self.0.lock().fs = fs;
-    }
-}
-
-impl IndexNode for LockedAhciInode {
-    fn as_any_ref(&self) -> &dyn core::any::Any {
-        self
-    }
-
-    fn open(
-        &self,
-        _data: SpinLockGuard<FilePrivateData>,
-        _mode: &FileMode,
-    ) -> Result<(), SystemError> {
-        Err(SystemError::ENOSYS)
-    }
-
-    fn close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError> {
-        Err(SystemError::ENOSYS)
-    }
-
-    fn metadata(&self) -> Result<Metadata, SystemError> {
-        return Ok(self.0.lock().metadata.clone());
-    }
-
-    fn fs(&self) -> Arc<dyn FileSystem> {
-        return self.0.lock().fs.upgrade().unwrap();
-    }
-
-    fn list(&self) -> Result<Vec<String>, SystemError> {
-        Err(SystemError::ENOSYS)
-    }
-
-    fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
-        let mut inode = self.0.lock();
-        inode.metadata.atime = metadata.atime;
-        inode.metadata.mtime = metadata.mtime;
-        inode.metadata.ctime = metadata.ctime;
-        inode.metadata.mode = metadata.mode;
-        inode.metadata.uid = metadata.uid;
-        inode.metadata.gid = metadata.gid;
-
-        return Ok(());
-    }
-
-    /// 读设备 - 应该调用设备的函数读写，而不是通过文件系统读写
-    fn read_at(
-        &self,
-        offset: usize, // lba地址
-        len: usize,
-        buf: &mut [u8],
-        data: SpinLockGuard<FilePrivateData>,
-    ) -> Result<usize, SystemError> {
-        if buf.len() < len {
-            return Err(SystemError::EINVAL);
-        }
-
-        if let FilePrivateData::Unused = *data {
-            return self.0.lock().disk.read_at_bytes(offset, len, buf);
-        }
-
-        return Err(SystemError::EINVAL);
-    }
-
-    /// 写设备 - 应该调用设备的函数读写，而不是通过文件系统读写
-    fn write_at(
-        &self,
-        offset: usize, // lba地址
-        len: usize,
-        buf: &[u8],
-        data: SpinLockGuard<FilePrivateData>,
-    ) -> Result<usize, SystemError> {
-        if buf.len() < len {
-            return Err(SystemError::EINVAL);
-        }
-
-        if let FilePrivateData::Unused = *data {
-            return self.0.lock().disk.write_at_bytes(offset, len, buf);
-        }
-
-        return Err(SystemError::EINVAL);
-    }
-}

kernel/src/driver/disk/ahci/hba.rs

@@ -1,3 +1,4 @@
+//! 文件说明: 实现了 AHCI 中的控制器 HBA 的相关行为
 use core::{intrinsics::size_of, ptr};
 
 use core::sync::atomic::compiler_fence;
@@ -5,8 +6,6 @@ use core::sync::atomic::compiler_fence;
 use crate::arch::MMArch;
 use crate::mm::{MemoryManagementArch, PhysAddr};
 
-/// 文件说明: 实现了 AHCI 中的控制器 HBA 的相关行为
-
 /// 根据 AHCI 写出 HBA 的 Command
 pub const ATA_CMD_READ_DMA_EXT: u8 = 0x25; // 读操作，并且退出
 pub const ATA_CMD_WRITE_DMA_EXT: u8 = 0x35; // 写操作，并且退出

kernel/src/driver/disk/ahci/mod.rs

@@ -1,24 +1,22 @@
 // 导出 ahci 相关的 module
-pub mod ahci_inode;
 pub mod ahcidisk;
 pub mod hba;
-
 use crate::arch::MMArch;
 use crate::driver::base::block::manager::block_dev_manager;
 use crate::driver::block::cache::cached_block_device::BlockCache;
 use crate::driver::disk::ahci::ahcidisk::LockedAhciDisk;
 use crate::driver::pci::pci::{
-    get_pci_device_structure_mut, PciDeviceStructure, PCI_DEVICE_LINKEDLIST,
+    get_pci_device_structure_mut, PciDeviceLinkedList, PciDeviceStructure, PCI_DEVICE_LINKEDLIST,
 };
+use alloc::sync::Arc;
 
 use crate::driver::disk::ahci::{
     hba::HbaMem,
     hba::{HbaPort, HbaPortType},
 };
-use crate::libs::rwlock::RwLockWriteGuard;
 use crate::libs::spinlock::{SpinLock, SpinLockGuard};
 use crate::mm::{MemoryManagementArch, VirtAddr};
-use alloc::{boxed::Box, collections::LinkedList, vec::Vec};
+use alloc::{boxed::Box, vec::Vec};
 use core::sync::atomic::compiler_fence;
 use log::debug;
 use system_error::SystemError;
@@ -36,9 +34,9 @@ pub const HBA_PxIS_TFES: u32 = 1 << 30;
 /// @brief 寻找所有的ahci设备
 /// @param list 链表的写锁
 /// @return Result<Vec<&'a mut Box<dyn PciDeviceStructure>>, SystemError>   成功则返回包含所有ahci设备结构体的可变引用的链表，失败则返回err
-fn ahci_device_search<'a>(
-    list: &'a mut RwLockWriteGuard<'_, LinkedList<Box<dyn PciDeviceStructure>>>,
-) -> Result<Vec<&'a mut Box<dyn PciDeviceStructure>>, SystemError> {
+fn ahci_device_search(
+    list: &PciDeviceLinkedList,
+) -> Result<Vec<Arc<dyn PciDeviceStructure>>, SystemError> {
     let result = get_pci_device_structure_mut(list, AHCI_CLASS, AHCI_SUBCLASS);
 
     if result.is_empty() {
@@ -50,11 +48,11 @@ fn ahci_device_search<'a>(
 
 /// @brief: 初始化 ahci
 pub fn ahci_init() -> Result<(), SystemError> {
-    let mut list = PCI_DEVICE_LINKEDLIST.write();
-    let ahci_device = ahci_device_search(&mut list)?;
+    let list = &*PCI_DEVICE_LINKEDLIST;
+    let ahci_device = ahci_device_search(list)?;
 
     for device in ahci_device {
-        let standard_device = device.as_standard_device_mut().unwrap();
+        let standard_device = device.as_standard_device().unwrap();
         standard_device.bar_ioremap();
         // 对于每一个ahci控制器分配一块空间
         let ahci_port_base_vaddr =
@@ -62,6 +60,7 @@ pub fn ahci_init() -> Result<(), SystemError> {
         let virtaddr = standard_device
             .bar()
             .ok_or(SystemError::EACCES)?
+            .read()
             .get_bar(5)
             .or(Err(SystemError::EACCES))?
             .virtual_address()

kernel/src/driver/firmware/efi/memmap.rs

@@ -67,7 +67,7 @@ impl<'a> EFIMemoryDescIter<'a> {
     }
 }
 
-impl<'a> Iterator for EFIMemoryDescIter<'a> {
+impl Iterator for EFIMemoryDescIter<'_> {
     type Item = MemoryDescriptor;
 
     fn next(&mut self) -> Option<Self::Item> {

kernel/src/driver/firmware/efi/tables.rs

@@ -74,8 +74,7 @@ impl EFIManager {
             warn!("report systable header: failed to map systable header, err: {fw_ptr:?}");
         }
 
-        let s = CStr::from_bytes_with_nul(&tmp_buf)
-            .unwrap_or_else(|_| CStr::from_bytes_with_nul(b"Unknown\0").unwrap());
+        let s = CStr::from_bytes_with_nul(&tmp_buf).unwrap_or(c"Unknown");
         info!("EFI version: {:?}, vendor: {:?}", header.revision, s);
     }
 

kernel/src/driver/input/serio/serio_driver.rs

@@ -45,8 +45,7 @@ pub trait SerioDriver: Driver {
     fn cleanup(&self, device: &Arc<dyn SerioDevice>) -> Result<(), SystemError>;
 }
 
-///todo: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/input/serio/serio.c#810
-
+/// todo: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/input/serio/serio.c#810
 #[allow(dead_code)]
 #[inline(always)]
 pub fn serio_driver_manager() -> &'static SerioDriverManager {

kernel/src/driver/net/dma.rs

@@ -17,7 +17,9 @@ const PAGE_SIZE: usize = 4096;
 /// @return PhysAddr 获得的内存页的初始物理地址
 pub fn dma_alloc(pages: usize) -> (usize, NonNull<u8>) {
     let page_num = PageFrameCount::new(
-        ((pages * PAGE_SIZE + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE).next_power_of_two(),
+        (pages * PAGE_SIZE)
+            .div_ceil(MMArch::PAGE_SIZE)
+            .next_power_of_two(),
     );
     unsafe {
         let (paddr, count) = allocate_page_frames(page_num).expect("e1000e: alloc page failed");
@@ -44,7 +46,9 @@ pub fn dma_alloc(pages: usize) -> (usize, NonNull<u8>) {
 /// @return i32 0表示成功
 pub unsafe fn dma_dealloc(paddr: usize, vaddr: NonNull<u8>, pages: usize) -> i32 {
     let page_count = PageFrameCount::new(
-        ((pages * PAGE_SIZE + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE).next_power_of_two(),
+        (pages * PAGE_SIZE)
+            .div_ceil(MMArch::PAGE_SIZE)
+            .next_power_of_two(),
     );
 
     // 恢复页面属性

kernel/src/driver/net/e1000e/e1000e.rs

@@ -1,16 +1,6 @@
 // 参考手册: PCIe* GbE Controllers Open Source Software Developer’s Manual
 // Refernce: PCIe* GbE Controllers Open Source Software Developer’s Manual
 
-use alloc::string::ToString;
-use alloc::sync::Arc;
-use alloc::vec::Vec;
-use core::intrinsics::unlikely;
-use core::mem::size_of;
-use core::ptr::NonNull;
-use core::slice::{from_raw_parts, from_raw_parts_mut};
-use core::sync::atomic::{compiler_fence, Ordering};
-use log::{debug, info};
-
 use super::e1000e_driver::e1000e_driver_init;
 use crate::driver::base::device::DeviceId;
 use crate::driver::net::dma::{dma_alloc, dma_dealloc};
@@ -21,6 +11,15 @@ use crate::driver::pci::pci::{
 };
 use crate::driver::pci::pci_irq::{IrqCommonMsg, IrqSpecificMsg, PciInterrupt, PciIrqMsg, IRQ};
 use crate::exception::IrqNumber;
+use alloc::string::ToString;
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use core::intrinsics::unlikely;
+use core::mem::size_of;
+use core::ptr::NonNull;
+use core::slice::{from_raw_parts, from_raw_parts_mut};
+use core::sync::atomic::{compiler_fence, Ordering};
+use log::{debug, info};
 
 use crate::libs::volatile::{ReadOnly, Volatile, WriteOnly};
 
@@ -200,14 +199,14 @@ impl E1000EDevice {
     // init the device for PCI standard device struct
     #[allow(unused_assignments)]
     pub fn new(
-        device: &mut PciDeviceStructureGeneralDevice,
+        device: Arc<PciDeviceStructureGeneralDevice>,
         device_id: Arc<DeviceId>,
     ) -> Result<Self, E1000EPciError> {
         // 从BAR0获取我们需要的寄存器
         // Build registers sturcts from BAR0
         device.bar_ioremap().unwrap()?;
         device.enable_master();
-        let bar = device.bar().ok_or(E1000EPciError::BarGetFailed)?;
+        let bar = device.bar().ok_or(E1000EPciError::BarGetFailed)?.read();
         let bar0 = bar.get_bar(0)?;
         let (address, size) = bar0
             .memory_address_size()
@@ -226,7 +225,7 @@ impl E1000EDevice {
         // 初始化msi中断
         // initialize msi interupt
         let irq_vector = device.irq_vector_mut().unwrap();
-        irq_vector.push(E1000E_RECV_VECTOR);
+        irq_vector.write().push(E1000E_RECV_VECTOR);
         device.irq_init(IRQ::PCI_IRQ_MSI).expect("IRQ Init Failed");
         let msg = PciIrqMsg {
             irq_common_message: IrqCommonMsg::init_from(
@@ -598,26 +597,32 @@ pub fn e1000e_init() {
 }
 
 pub fn e1000e_probe() -> Result<u64, E1000EPciError> {
-    let mut list = PCI_DEVICE_LINKEDLIST.write();
-    let result = get_pci_device_structure_mut(&mut list, NETWORK_CLASS, ETHERNET_SUBCLASS);
+    let list = &*PCI_DEVICE_LINKEDLIST;
+    let result = get_pci_device_structure_mut(list, NETWORK_CLASS, ETHERNET_SUBCLASS);
     if result.is_empty() {
         return Ok(0);
     }
     for device in result {
-        let standard_device = device.as_standard_device_mut().unwrap();
-        let header = &standard_device.common_header;
-        if header.vendor_id == 0x8086 {
+        let standard_device = device.as_standard_device().unwrap();
+        if standard_device.common_header.vendor_id == 0x8086 {
             // intel
-            if E1000E_DEVICE_ID.contains(&header.device_id) {
+            if E1000E_DEVICE_ID.contains(&standard_device.common_header.device_id) {
                 debug!(
                     "Detected e1000e PCI device with device id {:#x}",
-                    header.device_id
+                    standard_device.common_header.device_id
                 );
 
                 // todo: 根据pci的path来生成device id
                 let e1000e = E1000EDevice::new(
-                    standard_device,
-                    DeviceId::new(None, Some(format!("e1000e_{}", header.device_id))).unwrap(),
+                    standard_device.clone(),
+                    DeviceId::new(
+                        None,
+                        Some(format!(
+                            "e1000e_{}",
+                            standard_device.common_header.device_id
+                        )),
+                    )
+                    .unwrap(),
                 )?;
                 e1000e_driver_init(e1000e);
             }

kernel/src/driver/net/loopback.rs

@@ -186,8 +186,14 @@ impl Clone for LoopbackDriver {
 }
 
 impl phy::Device for LoopbackDriver {
-    type RxToken<'a> = LoopbackRxToken where Self: 'a;
-    type TxToken<'a> = LoopbackTxToken where Self: 'a;
+    type RxToken<'a>
+        = LoopbackRxToken
+    where
+        Self: 'a;
+    type TxToken<'a>
+        = LoopbackTxToken
+    where
+        Self: 'a;
     /// ## 返回设备的物理层特性。
     /// lo设备的最大传输单元为65535，最大突发大小为1，传输介质默认为Ethernet
     fn capabilities(&self) -> phy::DeviceCapabilities {

kernel/src/driver/net/virtio_net.rs

@@ -91,6 +91,12 @@ impl Debug for InnerVirtIONetDevice {
 
 impl VirtIONetDevice {
     pub fn new(transport: VirtIOTransport, dev_id: Arc<DeviceId>) -> Option<Arc<Self>> {
+        // 设置中断
+        if let Err(err) = transport.setup_irq(dev_id.clone()) {
+            error!("VirtIONetDevice '{dev_id:?}' setup_irq failed: {:?}", err);
+            return None;
+        }
+
         let driver_net: VirtIONet<HalImpl, VirtIOTransport, 2> =
             match VirtIONet::<HalImpl, VirtIOTransport, 2>::new(transport, 4096) {
                 Ok(net) => net,
@@ -533,8 +539,14 @@ impl VirtioNetToken {
 }
 
 impl phy::Device for VirtIONicDeviceInner {
-    type RxToken<'a> = VirtioNetToken where Self: 'a;
-    type TxToken<'a> = VirtioNetToken where Self: 'a;
+    type RxToken<'a>
+        = VirtioNetToken
+    where
+        Self: 'a;
+    type TxToken<'a>
+        = VirtioNetToken
+    where
+        Self: 'a;
 
     fn receive(
         &mut self,

kernel/src/driver/open_firmware/fdt.rs

@@ -71,6 +71,7 @@ impl OpenFirmwareFdtDriver {
         return Ok(());
     }
 
+    #[allow(dead_code)]
     pub unsafe fn set_fdt_map_guard(&self, guard: Option<MMIOSpaceGuard>) {
         self.inner.write().fdt_map_guard = guard;
     }
@@ -293,6 +294,7 @@ impl OpenFirmwareFdtDriver {
     /// 在UEFI初始化后，扫描FDT中的`/reserved-memory`节点，设置保留的内存
     ///
     /// 参考： https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/of/fdt.c#634
+    #[allow(dead_code)]
     pub fn early_init_fdt_scan_reserved_mem(&self) {
         let vaddr = boot_params().read().fdt();
         if vaddr.is_none() {
@@ -323,7 +325,6 @@ impl OpenFirmwareFdtDriver {
     }
 
     /// 保留fdt自身的内存空间
-
     fn early_reserve_fdt_itself(&self, fdt: &Fdt) {
         #[cfg(target_arch = "riscv64")]
         {

kernel/src/driver/pci/attr.rs

@@ -13,7 +13,7 @@ use crate::{
     },
 };
 
-use super::device::PciDevice;
+use super::{device::PciDevice, pci_irq::IrqType};
 #[derive(Debug)]
 pub struct BasicPciReadOnlyAttrs;
 
@@ -23,7 +23,16 @@ impl AttributeGroup for BasicPciReadOnlyAttrs {
     }
 
     fn attrs(&self) -> &[&'static dyn Attribute] {
-        &[&Vendor, &DeviceID, &SubsystemVendor, &SubsystemDevice]
+        &[
+            &Vendor,
+            &DeviceID,
+            &SubsystemVendor,
+            &SubsystemDevice,
+            &Revision,
+            &Class,
+            &Irq,
+            &Modalias,
+        ]
     }
 
     fn is_visible(
@@ -36,7 +45,7 @@ impl AttributeGroup for BasicPciReadOnlyAttrs {
 }
 
 #[derive(Debug)]
-pub struct Vendor;
+struct Vendor;
 
 impl Attribute for Vendor {
     fn mode(&self) -> ModeType {
@@ -67,7 +76,7 @@ impl Attribute for Vendor {
 }
 
 #[derive(Debug)]
-pub struct DeviceID;
+struct DeviceID;
 
 impl Attribute for DeviceID {
     fn mode(&self) -> ModeType {
@@ -98,7 +107,7 @@ impl Attribute for DeviceID {
 }
 
 #[derive(Debug)]
-pub struct SubsystemVendor;
+struct SubsystemVendor;
 
 impl Attribute for SubsystemVendor {
     fn mode(&self) -> ModeType {
@@ -129,7 +138,7 @@ impl Attribute for SubsystemVendor {
 }
 
 #[derive(Debug)]
-pub struct SubsystemDevice;
+struct SubsystemDevice;
 
 impl Attribute for SubsystemDevice {
     fn mode(&self) -> ModeType {
@@ -158,3 +167,143 @@ impl Attribute for SubsystemDevice {
         SysFSOpsSupport::ATTR_SHOW
     }
 }
+
+#[derive(Debug)]
+struct Revision;
+
+impl Attribute for Revision {
+    fn mode(&self) -> ModeType {
+        SYSFS_ATTR_MODE_RO
+    }
+
+    fn name(&self) -> &str {
+        "revision"
+    }
+
+    fn show(&self, _kobj: Arc<dyn KObject>, _buf: &mut [u8]) -> Result<usize, SystemError> {
+        let dev = _kobj
+            .cast::<dyn PciDevice>()
+            .map_err(|e: Arc<dyn KObject>| {
+                warn!("device:{:?} is not a pci device!", e);
+                SystemError::EINVAL
+            })?;
+        return sysfs_emit_str(_buf, &format!("0x{:02x}", dev.revision()));
+    }
+
+    fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> {
+        todo!()
+    }
+
+    fn support(&self) -> SysFSOpsSupport {
+        SysFSOpsSupport::ATTR_SHOW
+    }
+}
+
+#[derive(Debug)]
+struct Class;
+
+impl Attribute for Class {
+    fn mode(&self) -> ModeType {
+        SYSFS_ATTR_MODE_RO
+    }
+
+    fn name(&self) -> &str {
+        "class"
+    }
+
+    fn show(&self, _kobj: Arc<dyn KObject>, _buf: &mut [u8]) -> Result<usize, SystemError> {
+        let dev = _kobj
+            .cast::<dyn PciDevice>()
+            .map_err(|e: Arc<dyn KObject>| {
+                warn!("device:{:?} is not a pci device!", e);
+                SystemError::EINVAL
+            })?;
+        return sysfs_emit_str(_buf, &format!("0x{:06x}", dev.class_code()));
+    }
+
+    fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> {
+        todo!()
+    }
+
+    fn support(&self) -> SysFSOpsSupport {
+        SysFSOpsSupport::ATTR_SHOW
+    }
+}
+
+#[derive(Debug)]
+struct Irq;
+
+impl Attribute for Irq {
+    fn mode(&self) -> ModeType {
+        SYSFS_ATTR_MODE_RO
+    }
+
+    fn name(&self) -> &str {
+        "irq"
+    }
+
+    fn show(&self, _kobj: Arc<dyn KObject>, _buf: &mut [u8]) -> Result<usize, SystemError> {
+        let dev = _kobj
+            .cast::<dyn PciDevice>()
+            .map_err(|e: Arc<dyn KObject>| {
+                warn!("device:{:?} is not a pci device!", e);
+                SystemError::EINVAL
+            })?;
+        if let IrqType::Msi { .. } = *dev.irq_type().read() {
+            // 见https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/pci/pci-sysfs.c#55
+            return sysfs_emit_str(_buf, "todo:sry,msi device is unimplemented now");
+        }
+        return sysfs_emit_str(_buf, &format!("{}", dev.irq_line()));
+    }
+
+    fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> {
+        todo!()
+    }
+
+    fn support(&self) -> SysFSOpsSupport {
+        SysFSOpsSupport::ATTR_SHOW
+    }
+}
+
+#[derive(Debug)]
+struct Modalias;
+
+impl Attribute for Modalias {
+    fn mode(&self) -> ModeType {
+        SYSFS_ATTR_MODE_RO
+    }
+
+    fn name(&self) -> &str {
+        "modalias"
+    }
+
+    fn show(&self, _kobj: Arc<dyn KObject>, _buf: &mut [u8]) -> Result<usize, SystemError> {
+        let dev = _kobj
+            .cast::<dyn PciDevice>()
+            .map_err(|e: Arc<dyn KObject>| {
+                warn!("device:{:?} is not a pci device!", e);
+                SystemError::EINVAL
+            })?;
+        return sysfs_emit_str(
+            _buf,
+            &format!(
+                "pci:v{:08X}d{:08X}sv{:08X}sd{:08X}bc{:02X}sc{:02X}i{:02X}",
+                dev.vendor(),
+                dev.device_id(),
+                dev.subsystem_vendor(),
+                dev.subsystem_device(),
+                dev.class_code(),
+                dev.subclass(),
+                dev.interface_code(),
+            ),
+        );
+    }
+
+    fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> {
+        todo!()
+    }
+
+    fn support(&self) -> SysFSOpsSupport {
+        SysFSOpsSupport::ATTR_SHOW
+    }
+}

kernel/src/driver/pci/device.rs

@@ -14,13 +14,14 @@ use crate::{
     },
     filesystem::kernfs::KernFSInode,
     libs::{
-        rwlock::RwLockWriteGuard,
+        rwlock::{RwLock, RwLockWriteGuard},
         spinlock::{SpinLock, SpinLockGuard},
     },
 };
 
 use super::{
     dev_id::PciDeviceID,
+    pci_irq::IrqType,
     subsys::{pci_bus, pci_bus_device},
 };
 
@@ -83,6 +84,12 @@ pub trait PciDevice: Device {
     fn device_id(&self) -> u16;
     fn subsystem_vendor(&self) -> u16;
     fn subsystem_device(&self) -> u16;
+    fn revision(&self) -> u8;
+    fn class_code(&self) -> u8;
+    fn irq_type(&self) -> &RwLock<IrqType>;
+    fn irq_line(&self) -> u8;
+    fn subclass(&self) -> u8;
+    fn interface_code(&self) -> u8;
 }
 
 /// #结构功能

kernel/src/driver/pci/pci.rs

@@ -16,7 +16,7 @@ use crate::mm::mmio_buddy::{mmio_pool, MMIOSpaceGuard};
 use crate::mm::VirtAddr;
 
 use alloc::string::String;
-use alloc::sync::Arc;
+use alloc::sync::{Arc, Weak};
 use alloc::vec::Vec;
 use alloc::{boxed::Box, collections::LinkedList};
 use bitflags::bitflags;
@@ -68,7 +68,7 @@ impl Debug for PciAddr {
 
 /// 添加了读写锁的链表，存储PCI设备结构体
 pub struct PciDeviceLinkedList {
-    list: RwLock<LinkedList<Box<dyn PciDeviceStructure>>>,
+    list: RwLock<LinkedList<Arc<dyn PciDeviceStructure>>>,
 }
 
 impl PciDeviceLinkedList {
@@ -80,12 +80,12 @@ impl PciDeviceLinkedList {
     }
     /// @brief 获取可读的linkedlist(读锁守卫)
     /// @return RwLockReadGuard<LinkedList<Box<dyn PciDeviceStructure>>>  读锁守卫
-    pub fn read(&self) -> RwLockReadGuard<LinkedList<Box<dyn PciDeviceStructure>>> {
+    pub fn read(&self) -> RwLockReadGuard<LinkedList<Arc<dyn PciDeviceStructure>>> {
         self.list.read()
     }
     /// @brief 获取可写的linkedlist(写锁守卫)
     /// @return RwLockWriteGuard<LinkedList<Box<dyn PciDeviceStructure>>>  写锁守卫
-    pub fn write(&self) -> RwLockWriteGuard<LinkedList<Box<dyn PciDeviceStructure>>> {
+    pub fn write(&self) -> RwLockWriteGuard<LinkedList<Arc<dyn PciDeviceStructure>>> {
         self.list.write()
     }
     /// @brief 获取链表中PCI结构体数目
@@ -95,7 +95,7 @@ impl PciDeviceLinkedList {
         list.len()
     }
     /// @brief 添加Pci设备结构体到链表中
-    pub fn add(&self, device: Box<dyn PciDeviceStructure>) {
+    pub fn add(&self, device: Arc<dyn PciDeviceStructure>) {
         let mut list = self.list.write();
         list.push_back(device);
     }
@@ -113,15 +113,14 @@ impl PciDeviceLinkedList {
 /// ## 返回值
 ///
 /// - 返回匹配的供应商ID的PCI设备结构的引用。
-pub fn get_pci_device_structures_mut_by_vendor_id<'a>(
-    list: &'a mut RwLockWriteGuard<'_, LinkedList<Box<dyn PciDeviceStructure>>>,
+pub fn get_pci_device_structures_mut_by_vendor_id(
+    list: &PciDeviceLinkedList,
     vendor_id: u16,
-) -> Vec<&'a mut Box<(dyn PciDeviceStructure)>> {
-    let mut result = Vec::new();
-    for box_pci_device_structure in list.iter_mut() {
-        let common_header = (*box_pci_device_structure).common_header();
-        if common_header.vendor_id == vendor_id {
-            result.push(box_pci_device_structure);
+) -> Vec<Arc<(dyn PciDeviceStructure)>> {
+    let mut result: Vec<Arc<(dyn PciDeviceStructure)>> = Vec::new();
+    for box_pci_device_structure in list.write().iter() {
+        if box_pci_device_structure.common_header().vendor_id == vendor_id {
+            result.push(box_pci_device_structure.clone());
         }
     }
     result
@@ -140,16 +139,17 @@ pub fn get_pci_device_structures_mut_by_vendor_id<'a>(
 ///
 /// ## 返回值
 /// - 包含链表中所有满足条件的PCI结构体的可变引用的容器。
-pub fn get_pci_device_structure_mut<'a>(
-    list: &'a mut RwLockWriteGuard<'_, LinkedList<Box<dyn PciDeviceStructure>>>,
+pub fn get_pci_device_structure_mut(
+    list: &PciDeviceLinkedList,
     class_code: u8,
     subclass: u8,
-) -> Vec<&'a mut Box<(dyn PciDeviceStructure)>> {
+) -> Vec<Arc<dyn PciDeviceStructure>> {
     let mut result = Vec::new();
-    for box_pci_device_structure in list.iter_mut() {
-        let common_header = (*box_pci_device_structure).common_header();
-        if (common_header.class_code == class_code) && (common_header.subclass == subclass) {
-            result.push(box_pci_device_structure);
+    for box_pci_device_structure in list.write().iter() {
+        if (box_pci_device_structure.common_header().class_code == class_code)
+            && (box_pci_device_structure.common_header().subclass == subclass)
+        {
+            result.push(box_pci_device_structure.clone());
         }
     }
     result
@@ -317,7 +317,7 @@ pub trait PciDeviceStructure: Send + Sync {
     fn header_type(&self) -> HeaderType;
     /// @brief 当其为standard设备时返回&Pci_Device_Structure_General_Device，其余情况返回None
     #[inline(always)]
-    fn as_standard_device(&self) -> Option<&PciDeviceStructureGeneralDevice> {
+    fn as_standard_device(&self) -> Option<Arc<PciDeviceStructureGeneralDevice>> {
         None
     }
     /// @brief 当其为pci to pci bridge设备时返回&Pci_Device_Structure_Pci_to_Pci_Bridge，其余情况返回None
@@ -333,21 +333,14 @@ pub trait PciDeviceStructure: Send + Sync {
     /// @brief 获取Pci设备共有的common_header
     /// @return 返回其不可变引用
     fn common_header(&self) -> &PciDeviceStructureHeader;
-    /// @brief 当其为standard设备时返回&mut Pci_Device_Structure_General_Device，其余情况返回None
-    #[inline(always)]
-    fn as_standard_device_mut(&mut self) -> Option<&mut PciDeviceStructureGeneralDevice> {
-        None
-    }
     /// @brief 当其为pci to pci bridge设备时返回&mut Pci_Device_Structure_Pci_to_Pci_Bridge，其余情况返回None
     #[inline(always)]
-    fn as_pci_to_pci_bridge_device_mut(&mut self) -> Option<&mut PciDeviceStructurePciToPciBridge> {
+    fn as_pci_to_pci_bridge_device_mut(&self) -> Option<&PciDeviceStructurePciToPciBridge> {
         None
     }
     /// @brief 当其为pci to cardbus bridge设备时返回&mut Pci_Device_Structure_Pci_to_Cardbus_Bridge，其余情况返回None
     #[inline(always)]
-    fn as_pci_to_carbus_bridge_device_mut(
-        &mut self,
-    ) -> Option<&mut PciDeviceStructurePciToCardbusBridge> {
+    fn as_pci_to_carbus_bridge_device_mut(&self) -> Option<&PciDeviceStructurePciToCardbusBridge> {
         None
     }
     /// @brief 返回迭代器，遍历capabilities
@@ -358,14 +351,14 @@ pub trait PciDeviceStructure: Send + Sync {
     fn status_command(&self) -> (Status, Command) {
         let common_header = self.common_header();
         let status = Status::from_bits_truncate(common_header.status);
-        let command = Command::from_bits_truncate(common_header.command);
+        let command = Command::from_bits_truncate(*common_header.command.read());
         (status, command)
     }
     /// @brief 设置Command寄存器的值
-    fn set_command(&mut self, command: Command) {
+    fn set_command(&self, command: Command) {
         let common_header = self.common_header_mut();
         let command = command.bits();
-        common_header.command = command;
+        *common_header.command.write() = command;
         pci_root_0().write_config(
             common_header.bus_device_function,
             STATUS_COMMAND_OFFSET.into(),
@@ -374,22 +367,22 @@ pub trait PciDeviceStructure: Send + Sync {
     }
     /// @brief 获取Pci设备共有的common_header
     /// @return 返回其可变引用
-    fn common_header_mut(&mut self) -> &mut PciDeviceStructureHeader;
+    fn common_header_mut(&self) -> &PciDeviceStructureHeader;
 
     /// @brief 读取standard设备的bar寄存器，映射后将结果加入结构体的standard_device_bar变量
     /// @return 只有standard设备才返回成功或者错误，其余返回None
     #[inline(always)]
-    fn bar_ioremap(&mut self) -> Option<Result<u8, PciError>> {
+    fn bar_ioremap(&self) -> Option<Result<u8, PciError>> {
         None
     }
     /// @brief 获取PCI设备的bar寄存器的引用
     /// @return
     #[inline(always)]
-    fn bar(&mut self) -> Option<&PciStandardDeviceBar> {
+    fn bar(&self) -> Option<&RwLock<PciStandardDeviceBar>> {
         None
     }
     /// @brief 通过设置该pci设备的command
-    fn enable_master(&mut self) {
+    fn enable_master(&self) {
         self.set_command(Command::IO_SPACE | Command::MEMORY_SPACE | Command::BUS_MASTER);
     }
     /// @brief 寻找设备的msix空间的offset
@@ -411,21 +404,21 @@ pub trait PciDeviceStructure: Send + Sync {
         None
     }
     /// @brief 返回结构体中的irq_type的可变引用
-    fn irq_type_mut(&mut self) -> Option<&mut IrqType>;
+    fn irq_type_mut(&self) -> Option<&RwLock<IrqType>>;
     /// @brief 返回结构体中的irq_vector的可变引用
-    fn irq_vector_mut(&mut self) -> Option<&mut Vec<IrqNumber>>;
+    fn irq_vector_mut(&self) -> Option<&RwLock<Vec<IrqNumber>>>;
 }
 
 /// Pci_Device_Structure_Header PCI设备结构体共有的头部
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct PciDeviceStructureHeader {
     // ==== busdevicefunction变量表示该结构体所处的位置
     pub bus_device_function: BusDeviceFunction,
     pub vendor_id: u16, // 供应商ID 0xffff是一个无效值，在读取访问不存在的设备的配置空间寄存器时返回
     pub device_id: u16, // 设备ID，标志特定设备
-    pub command: u16, // 提供对设备生成和响应pci周期的能力的控制 向该寄存器写入0时，设备与pci总线断开除配置空间访问以外的所有连接
-    pub status: u16,  // 用于记录pci总线相关时间的状态信息寄存器
-    pub revision_id: u8, // 修订ID，指定特定设备的修订标志符
+    pub command: RwLock<u16>, // 提供对设备生成和响应pci周期的能力的控制 向该寄存器写入0时，设备与pci总线断开除配置空间访问以外的所有连接
+    pub status: u16,          // 用于记录pci总线相关时间的状态信息寄存器
+    pub revision_id: u8,      // 修订ID，指定特定设备的修订标志符
     pub prog_if: u8, // 编程接口字节，一个只读寄存器，指定设备具有的寄存器级别的编程接口（如果有的话）
     pub subclass: u8, // 子类。指定设备执行的特定功能的只读寄存器
     pub class_code: u8, // 类代码，一个只读寄存器，指定设备执行的功能类型
@@ -440,14 +433,14 @@ pub struct PciDeviceStructureHeader {
 }
 
 /// Pci_Device_Structure_General_Device PCI标准设备结构体
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct PciDeviceStructureGeneralDevice {
     pub common_header: PciDeviceStructureHeader,
     // 中断结构体，包括legacy,msi,msix三种情况
-    pub irq_type: IrqType,
+    pub irq_type: RwLock<IrqType>,
     // 使用的中断号的vec集合
-    pub irq_vector: Vec<IrqNumber>,
-    pub standard_device_bar: PciStandardDeviceBar,
+    pub irq_vector: RwLock<Vec<IrqNumber>>,
+    pub standard_device_bar: RwLock<PciStandardDeviceBar>,
     pub cardbus_cis_pointer: u32, // 指向卡信息结构，供在 CardBus 和 PCI 之间共享芯片的设备使用。
     pub subsystem_vendor_id: u16,
     pub subsystem_id: u16,
@@ -460,6 +453,7 @@ pub struct PciDeviceStructureGeneralDevice {
     pub interrupt_pin: u8, // 指定设备使用的中断引脚。其中值为0x1INTA#、0x2INTB#、0x3INTC#、0x4INTD#，0x0表示设备不使用中断引脚。
     pub min_grant: u8, // 一个只读寄存器，用于指定设备所需的突发周期长度（以 1/4 微秒为单位）（假设时钟速率为 33 MHz）
     pub max_latency: u8, // 一个只读寄存器，指定设备需要多长时间访问一次 PCI 总线（以 1/4 微秒为单位）。
+    pub self_ptr: RwLock<Weak<Self>>,
 }
 impl PciDeviceStructure for PciDeviceStructureGeneralDevice {
     #[inline(always)]
@@ -467,20 +461,16 @@ impl PciDeviceStructure for PciDeviceStructureGeneralDevice {
         HeaderType::Standard
     }
     #[inline(always)]
-    fn as_standard_device(&self) -> Option<&PciDeviceStructureGeneralDevice> {
-        Some(self)
-    }
-    #[inline(always)]
-    fn as_standard_device_mut(&mut self) -> Option<&mut PciDeviceStructureGeneralDevice> {
-        Some(self)
+    fn as_standard_device(&self) -> Option<Arc<PciDeviceStructureGeneralDevice>> {
+        self.self_ptr.read().upgrade()
     }
     #[inline(always)]
     fn common_header(&self) -> &PciDeviceStructureHeader {
         &self.common_header
     }
     #[inline(always)]
-    fn common_header_mut(&mut self) -> &mut PciDeviceStructureHeader {
-        &mut self.common_header
+    fn common_header_mut(&self) -> &PciDeviceStructureHeader {
+        &self.common_header
     }
     fn capabilities(&self) -> Option<CapabilityIterator> {
         Some(CapabilityIterator {
@@ -488,37 +478,37 @@ impl PciDeviceStructure for PciDeviceStructureGeneralDevice {
             next_capability_offset: Some(self.capabilities_pointer),
         })
     }
-    fn bar_ioremap(&mut self) -> Option<Result<u8, PciError>> {
+    fn bar_ioremap(&self) -> Option<Result<u8, PciError>> {
         let common_header = &self.common_header;
         match pci_bar_init(common_header.bus_device_function) {
             Ok(bar) => {
-                self.standard_device_bar = bar;
+                *self.standard_device_bar.write() = bar;
                 Some(Ok(0))
             }
             Err(e) => Some(Err(e)),
         }
     }
-    fn bar(&mut self) -> Option<&PciStandardDeviceBar> {
+    fn bar(&self) -> Option<&RwLock<PciStandardDeviceBar>> {
         Some(&self.standard_device_bar)
     }
     #[inline(always)]
-    fn irq_type_mut(&mut self) -> Option<&mut IrqType> {
-        Some(&mut self.irq_type)
+    fn irq_type_mut(&self) -> Option<&RwLock<IrqType>> {
+        Some(&self.irq_type)
     }
     #[inline(always)]
-    fn irq_vector_mut(&mut self) -> Option<&mut Vec<IrqNumber>> {
-        Some(&mut self.irq_vector)
+    fn irq_vector_mut(&self) -> Option<&RwLock<Vec<IrqNumber>>> {
+        Some(&self.irq_vector)
     }
 }
 
 /// Pci_Device_Structure_Pci_to_Pci_Bridge pci-to-pci桥设备结构体
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct PciDeviceStructurePciToPciBridge {
     pub common_header: PciDeviceStructureHeader,
     // 中断结构体，包括legacy,msi,msix三种情况
-    pub irq_type: IrqType,
+    pub irq_type: RwLock<IrqType>,
     // 使用的中断号的vec集合
-    pub irq_vector: Vec<IrqNumber>,
+    pub irq_vector: RwLock<Vec<IrqNumber>>,
     pub bar0: u32,
     pub bar1: u32,
     pub primary_bus_number: u8,
@@ -554,7 +544,7 @@ impl PciDeviceStructure for PciDeviceStructurePciToPciBridge {
         Some(self)
     }
     #[inline(always)]
-    fn as_pci_to_pci_bridge_device_mut(&mut self) -> Option<&mut PciDeviceStructurePciToPciBridge> {
+    fn as_pci_to_pci_bridge_device_mut(&self) -> Option<&PciDeviceStructurePciToPciBridge> {
         Some(self)
     }
     #[inline(always)]
@@ -562,20 +552,20 @@ impl PciDeviceStructure for PciDeviceStructurePciToPciBridge {
         &self.common_header
     }
     #[inline(always)]
-    fn common_header_mut(&mut self) -> &mut PciDeviceStructureHeader {
-        &mut self.common_header
+    fn common_header_mut(&self) -> &PciDeviceStructureHeader {
+        &self.common_header
     }
     #[inline(always)]
-    fn irq_type_mut(&mut self) -> Option<&mut IrqType> {
-        Some(&mut self.irq_type)
+    fn irq_type_mut(&self) -> Option<&RwLock<IrqType>> {
+        Some(&self.irq_type)
     }
     #[inline(always)]
-    fn irq_vector_mut(&mut self) -> Option<&mut Vec<IrqNumber>> {
-        Some(&mut self.irq_vector)
+    fn irq_vector_mut(&self) -> Option<&RwLock<Vec<IrqNumber>>> {
+        Some(&self.irq_vector)
     }
 }
 /// Pci_Device_Structure_Pci_to_Cardbus_Bridge Pci_to_Cardbus桥设备结构体
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct PciDeviceStructurePciToCardbusBridge {
     pub common_header: PciDeviceStructureHeader,
     pub cardbus_socket_ex_ca_base_address: u32,
@@ -611,9 +601,7 @@ impl PciDeviceStructure for PciDeviceStructurePciToCardbusBridge {
         Some(self)
     }
     #[inline(always)]
-    fn as_pci_to_carbus_bridge_device_mut(
-        &mut self,
-    ) -> Option<&mut PciDeviceStructurePciToCardbusBridge> {
+    fn as_pci_to_carbus_bridge_device_mut(&self) -> Option<&PciDeviceStructurePciToCardbusBridge> {
         Some(self)
     }
     #[inline(always)]
@@ -621,15 +609,15 @@ impl PciDeviceStructure for PciDeviceStructurePciToCardbusBridge {
         &self.common_header
     }
     #[inline(always)]
-    fn common_header_mut(&mut self) -> &mut PciDeviceStructureHeader {
-        &mut self.common_header
+    fn common_header_mut(&self) -> &PciDeviceStructureHeader {
+        &self.common_header
     }
     #[inline(always)]
-    fn irq_type_mut(&mut self) -> Option<&mut IrqType> {
+    fn irq_type_mut(&self) -> Option<&RwLock<IrqType>> {
         None
     }
     #[inline(always)]
-    fn irq_vector_mut(&mut self) -> Option<&mut Vec<IrqNumber>> {
+    fn irq_vector_mut(&self) -> Option<&RwLock<Vec<IrqNumber>>> {
         None
     }
 }
@@ -684,14 +672,14 @@ pub fn capabilities_offset(bus_device_function: BusDeviceFunction) -> Option<u8>
 fn pci_read_header(
     bus_device_function: BusDeviceFunction,
     add_to_list: bool,
-) -> Result<Box<dyn PciDeviceStructure>, PciError> {
+) -> Result<Arc<dyn PciDeviceStructure>, PciError> {
     // 先读取公共header
     let result = pci_root_0().read_config(bus_device_function, 0x00);
     let vendor_id = result as u16;
     let device_id = (result >> 16) as u16;
 
     let result = pci_root_0().read_config(bus_device_function, 0x04);
-    let command = result as u16;
+    let command = RwLock::new(result as u16);
     let status = (result >> 16) as u16;
 
     let result = pci_root_0().read_config(bus_device_function, 0x08);
@@ -727,22 +715,22 @@ fn pci_read_header(
         HeaderType::Standard => {
             let general_device: PciDeviceStructureGeneralDevice =
                 pci_read_general_device_header(header, &bus_device_function);
-            let box_general_device = Box::new(general_device.clone());
-            let box_general_device_clone = box_general_device.clone();
+            let box_general_device = Arc::new(general_device);
+            *box_general_device.self_ptr.write() = Arc::downgrade(&box_general_device);
             if add_to_list {
-                PCI_DEVICE_LINKEDLIST.add(box_general_device);
+                PCI_DEVICE_LINKEDLIST.add(box_general_device.clone());
                 //这里实际上不应该使用clone，因为raw是用于sysfs的结构，但是实际上pci设备是在PCI_DEVICE_LINKEDLIST链表上的，
                 //这就导致sysfs呈现的对pci设备的操控接口实际上操控的是pci设备描述符是一个副本
                 //但是无奈这里没有使用Arc
                 //todo：修改pci设备描述符在静态链表中存在的方式，并修改这里的clone操作
-                let raw = PciGeneralDevice::from(&general_device);
+                let raw = PciGeneralDevice::from(box_general_device.clone());
                 let _ = pci_device_manager().device_add(Arc::new(raw));
             }
-            Ok(box_general_device_clone)
+            Ok(box_general_device)
         }
         HeaderType::PciPciBridge => {
             let pci_to_pci_bridge = pci_read_pci_to_pci_bridge_header(header, &bus_device_function);
-            let box_pci_to_pci_bridge = Box::new(pci_to_pci_bridge);
+            let box_pci_to_pci_bridge = Arc::new(pci_to_pci_bridge);
             let box_pci_to_pci_bridge_clone = box_pci_to_pci_bridge.clone();
             if add_to_list {
                 PCI_DEVICE_LINKEDLIST.add(box_pci_to_pci_bridge);
@@ -752,7 +740,7 @@ fn pci_read_header(
         HeaderType::PciCardbusBridge => {
             let pci_cardbus_bridge =
                 pci_read_pci_to_cardbus_bridge_header(header, &bus_device_function);
-            let box_pci_cardbus_bridge = Box::new(pci_cardbus_bridge);
+            let box_pci_cardbus_bridge = Arc::new(pci_cardbus_bridge);
             let box_pci_cardbus_bridge_clone = box_pci_cardbus_bridge.clone();
             if add_to_list {
                 PCI_DEVICE_LINKEDLIST.add(box_pci_cardbus_bridge);
@@ -772,7 +760,7 @@ fn pci_read_general_device_header(
     common_header: PciDeviceStructureHeader,
     bus_device_function: &BusDeviceFunction,
 ) -> PciDeviceStructureGeneralDevice {
-    let standard_device_bar = PciStandardDeviceBar::default();
+    let standard_device_bar = RwLock::new(PciStandardDeviceBar::default());
     let cardbus_cis_pointer = pci_root_0().read_config(*bus_device_function, 0x28);
 
     let result = pci_root_0().read_config(*bus_device_function, 0x2c);
@@ -795,8 +783,8 @@ fn pci_read_general_device_header(
     let max_latency = (result >> 24) as u8;
     PciDeviceStructureGeneralDevice {
         common_header,
-        irq_type: IrqType::Unused,
-        irq_vector: Vec::new(),
+        irq_type: RwLock::new(IrqType::Unused),
+        irq_vector: RwLock::new(Vec::new()),
         standard_device_bar,
         cardbus_cis_pointer,
         subsystem_vendor_id,
@@ -810,6 +798,7 @@ fn pci_read_general_device_header(
         interrupt_pin,
         min_grant,
         max_latency,
+        self_ptr: RwLock::new(Weak::new()),
     }
 }
 
@@ -865,8 +854,8 @@ fn pci_read_pci_to_pci_bridge_header(
     let bridge_control = (result >> 16) as u16;
     PciDeviceStructurePciToPciBridge {
         common_header,
-        irq_type: IrqType::Unused,
-        irq_vector: Vec::new(),
+        irq_type: RwLock::new(IrqType::Unused),
+        irq_vector: RwLock::new(Vec::new()),
         bar0,
         bar1,
         primary_bus_number,
@@ -1485,7 +1474,7 @@ pub struct ExternalCapabilityIterator<'a> {
     pub bus_device_function: BusDeviceFunction,
     pub next_capability_offset: Option<u16>,
 }
-impl<'a> Iterator for ExternalCapabilityIterator<'a> {
+impl Iterator for ExternalCapabilityIterator<'_> {
     type Item = ExternalCapabilityInfo;
     fn next(&mut self) -> Option<Self::Item> {
         let offset = self.next_capability_offset?;

kernel/src/driver/pci/pci_irq.rs

@@ -155,7 +155,7 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @param self PCI设备的可变引用
     /// @param flag 选择的中断类型（支持多个选择），如PCI_IRQ_ALL_TYPES表示所有中断类型均可，让系统按顺序进行选择
     /// @return Option<IrqType> 失败返回None，成功则返回对应中断类型
-    fn irq_init(&mut self, flag: IRQ) -> Option<IrqType> {
+    fn irq_init(&self, flag: IRQ) -> Option<IrqType> {
         // MSIX中断优先
         if flag.contains(IRQ::PCI_IRQ_MSIX) {
             if let Some(cap_offset) = self.msix_capability_offset() {
@@ -174,7 +174,7 @@ pub trait PciInterrupt: PciDeviceStructure {
                 );
                 let pending_table_bar = (data & 0x07) as u8;
                 let pending_table_offset = data & (!0x07);
-                *self.irq_type_mut()? = IrqType::Msix {
+                *self.irq_type_mut()?.write() = IrqType::Msix {
                     msix_table_bar,
                     msix_table_offset,
                     pending_table_bar,
@@ -201,7 +201,7 @@ pub trait PciInterrupt: PciDeviceStructure {
                 let maskable = (message_control & 0x0100) != 0;
                 let address_64 = (message_control & 0x0080) != 0;
                 let irq_max_num = (1 << (((message_control & 0x000e) >> 1) + 1)) as u16;
-                *self.irq_type_mut()? = IrqType::Msi {
+                *self.irq_type_mut()?.write() = IrqType::Msi {
                     address_64,
                     maskable,
                     irq_max_num,
@@ -217,7 +217,7 @@ pub trait PciInterrupt: PciDeviceStructure {
         }
         // 最后选择legacy#
         if flag.contains(IRQ::PCI_IRQ_LEGACY) {
-            *self.irq_type_mut()? = IrqType::Legacy;
+            *self.irq_type_mut()?.write() = IrqType::Legacy;
             return Some(IrqType::Legacy);
         }
         None
@@ -226,9 +226,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @brief 启动/关闭设备中断
     /// @param self PCI设备的可变引用
     /// @param enable 开启/关闭
-    fn irq_enable(&mut self, enable: bool) -> Result<u8, PciError> {
+    fn irq_enable(&self, enable: bool) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix { .. } => {
                     return self.msix_enable(enable);
                 }
@@ -248,9 +248,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @brief 启动/关闭设备MSIX中断
     /// @param self PCI设备的可变引用
     /// @param enable 开启/关闭
-    fn msix_enable(&mut self, enable: bool) -> Result<u8, PciError> {
+    fn msix_enable(&self, enable: bool) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix { cap_offset, .. } => {
                     let mut message = pci_root_0()
                         .read_config(self.common_header().bus_device_function, cap_offset.into());
@@ -279,9 +279,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @brief 启动/关闭设备MSI中断
     /// @param self PCI设备的可变引用
     /// @param enable 开启/关闭
-    fn msi_enable(&mut self, enable: bool) -> Result<u8, PciError> {
+    fn msi_enable(&self, enable: bool) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msi { cap_offset, .. } => {
                     let mut message = pci_root_0()
                         .read_config(self.common_header().bus_device_function, cap_offset.into());
@@ -315,9 +315,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @param self PCI设备的可变引用
     /// @param msg PCI设备install中断时需要传递的共同参数
     /// @return 一切正常返回Ok(0),有错误返回对应错误原因
-    fn irq_install(&mut self, msg: PciIrqMsg) -> Result<u8, PciError> {
+    fn irq_install(&self, msg: PciIrqMsg) -> Result<u8, PciError> {
         if let Some(irq_vector) = self.irq_vector_mut() {
-            if msg.irq_common_message.irq_index as usize > irq_vector.len() {
+            if msg.irq_common_message.irq_index as usize > irq_vector.read().len() {
                 return Err(PciError::PciIrqError(PciIrqError::InvalidIrqIndex(
                     msg.irq_common_message.irq_index,
                 )));
@@ -325,7 +325,7 @@ pub trait PciInterrupt: PciDeviceStructure {
         }
         self.irq_enable(false)?; //中断设置更改前先关闭对应PCI设备的中断
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix { .. } => {
                     return self.msix_install(msg);
                 }
@@ -346,9 +346,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @param self PCI设备的可变引用
     /// @param msg PCI设备install中断时需要传递的共同参数
     /// @return 一切正常返回Ok(0),有错误返回对应错误原因
-    fn msi_install(&mut self, msg: PciIrqMsg) -> Result<u8, PciError> {
+    fn msi_install(&self, msg: PciIrqMsg) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msi {
                     address_64,
                     irq_max_num,
@@ -356,11 +356,11 @@ pub trait PciInterrupt: PciDeviceStructure {
                     ..
                 } => {
                     // 注意：MSI中断分配的中断号必须连续且大小为2的倍数
-                    if self.irq_vector_mut().unwrap().len() > irq_max_num as usize {
+                    if self.irq_vector_mut().unwrap().read().len() > irq_max_num as usize {
                         return Err(PciError::PciIrqError(PciIrqError::DeviceIrqOverflow));
                     }
-                    let irq_num =
-                        self.irq_vector_mut().unwrap()[msg.irq_common_message.irq_index as usize];
+                    let irq_num = self.irq_vector_mut().unwrap().read()
+                        [msg.irq_common_message.irq_index as usize];
 
                     let irq_num = IrqNumber::new(irq_num.into());
                     let common_msg = &msg.irq_common_message;
@@ -441,7 +441,7 @@ pub trait PciInterrupt: PciDeviceStructure {
                             cap_offset.into(),
                         );
                         let message_control = (data >> 16) as u16;
-                        match self.irq_vector_mut().unwrap().len() {
+                        match self.irq_vector_mut().unwrap().read().len() {
                             1 => {
                                 let temp = message_control & (!0x0070);
                                 pci_root_0().write_config(
@@ -511,20 +511,20 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @param self PCI设备的可变引用
     /// @param msg PCI设备install中断时需要传递的共同参数
     /// @return 一切正常返回Ok(0),有错误返回对应错误原因
-    fn msix_install(&mut self, msg: PciIrqMsg) -> Result<u8, PciError> {
+    fn msix_install(&self, msg: PciIrqMsg) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix {
                     irq_max_num,
                     msix_table_bar,
                     msix_table_offset,
                     ..
                 } => {
-                    if self.irq_vector_mut().unwrap().len() > irq_max_num as usize {
+                    if self.irq_vector_mut().unwrap().read().len() > irq_max_num as usize {
                         return Err(PciError::PciIrqError(PciIrqError::DeviceIrqOverflow));
                     }
-                    let irq_num =
-                        self.irq_vector_mut().unwrap()[msg.irq_common_message.irq_index as usize];
+                    let irq_num = self.irq_vector_mut().unwrap().read()
+                        [msg.irq_common_message.irq_index as usize];
 
                     let common_msg = &msg.irq_common_message;
 
@@ -571,7 +571,8 @@ pub trait PciInterrupt: PciDeviceStructure {
                     //写入Message Data和Message Address
                     let pcistandardbar = self
                         .bar()
-                        .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))?;
+                        .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))?
+                        .read();
                     let msix_bar = pcistandardbar.get_bar(msix_table_bar)?;
                     let vaddr: crate::mm::VirtAddr = msix_bar
                         .virtual_address()
@@ -603,7 +604,7 @@ pub trait PciInterrupt: PciDeviceStructure {
     fn irq_uninstall(&mut self) -> Result<u8, PciError> {
         self.irq_enable(false)?; //中断设置更改前先关闭对应PCI设备的中断
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix { .. } => {
                     return self.msix_uninstall();
                 }
@@ -622,15 +623,15 @@ pub trait PciInterrupt: PciDeviceStructure {
     }
     /// @brief 进行PCI设备中断的卸载（MSI）
     /// @param self PCI设备的可变引用
-    fn msi_uninstall(&mut self) -> Result<u8, PciError> {
+    fn msi_uninstall(&self) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msi {
                     address_64,
                     cap_offset,
                     ..
                 } => {
-                    for vector in self.irq_vector_mut().unwrap() {
+                    for vector in self.irq_vector_mut().unwrap().read().iter() {
                         let irq = IrqNumber::new((*vector).into());
                         irq_manager().free_irq(irq, None);
                     }
@@ -670,9 +671,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     }
     /// @brief 进行PCI设备中断的卸载(MSIX)
     /// @param self PCI设备的可变引用
-    fn msix_uninstall(&mut self) -> Result<u8, PciError> {
+    fn msix_uninstall(&self) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix {
                     irq_max_num,
                     cap_offset,
@@ -680,7 +681,7 @@ pub trait PciInterrupt: PciDeviceStructure {
                     msix_table_offset,
                     ..
                 } => {
-                    for vector in self.irq_vector_mut().unwrap() {
+                    for vector in self.irq_vector_mut().unwrap().read().iter() {
                         let irq = IrqNumber::new((*vector).into());
                         irq_manager().free_irq(irq, None);
                     }
@@ -692,7 +693,8 @@ pub trait PciInterrupt: PciDeviceStructure {
                     let pcistandardbar = self
                         .bar()
                         .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))
-                        .unwrap();
+                        .unwrap()
+                        .read();
                     let msix_bar = pcistandardbar.get_bar(msix_table_bar).unwrap();
                     for index in 0..irq_max_num {
                         let vaddr = msix_bar
@@ -726,7 +728,7 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
     fn irq_mask(&mut self, irq_index: u16) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix { .. } => {
                     return self.msix_mask(irq_index);
                 }
@@ -746,9 +748,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @brief 屏蔽相应位置的中断(MSI)
     /// @param self PCI设备的可变引用
     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
-    fn msi_mask(&mut self, irq_index: u16) -> Result<u8, PciError> {
+    fn msi_mask(&self, irq_index: u16) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msi {
                     maskable,
                     address_64,
@@ -804,9 +806,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @brief 屏蔽相应位置的中断(MSIX)
     /// @param self PCI设备的可变引用
     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
-    fn msix_mask(&mut self, irq_index: u16) -> Result<u8, PciError> {
+    fn msix_mask(&self, irq_index: u16) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix {
                     irq_max_num,
                     msix_table_bar,
@@ -821,7 +823,8 @@ pub trait PciInterrupt: PciDeviceStructure {
                     let pcistandardbar = self
                         .bar()
                         .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))
-                        .unwrap();
+                        .unwrap()
+                        .read();
                     let msix_bar = pcistandardbar.get_bar(msix_table_bar).unwrap();
                     let vaddr = msix_bar.virtual_address().unwrap()
                         + msix_table_offset as usize
@@ -845,9 +848,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @brief 解除屏蔽相应位置的中断
     /// @param self PCI设备的可变引用
     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
-    fn irq_unmask(&mut self, irq_index: u16) -> Result<u8, PciError> {
+    fn irq_unmask(&self, irq_index: u16) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix { .. } => {
                     return self.msix_unmask(irq_index);
                 }
@@ -867,9 +870,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @brief 解除屏蔽相应位置的中断（MSI）
     /// @param self PCI设备的可变引用
     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
-    fn msi_unmask(&mut self, irq_index: u16) -> Result<u8, PciError> {
+    fn msi_unmask(&self, irq_index: u16) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msi {
                     maskable,
                     address_64,
@@ -924,9 +927,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @brief 解除屏蔽相应位置的中断(MSIX)
     /// @param self PCI设备的可变引用
     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
-    fn msix_unmask(&mut self, irq_index: u16) -> Result<u8, PciError> {
+    fn msix_unmask(&self, irq_index: u16) -> Result<u8, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix {
                     irq_max_num,
                     msix_table_bar,
@@ -941,7 +944,8 @@ pub trait PciInterrupt: PciDeviceStructure {
                     let pcistandardbar = self
                         .bar()
                         .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))
-                        .unwrap();
+                        .unwrap()
+                        .read();
                     let msix_bar = pcistandardbar.get_bar(msix_table_bar).unwrap();
                     let vaddr = msix_bar.virtual_address().unwrap()
                         + msix_table_offset as usize
@@ -966,9 +970,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @param self PCI设备的可变引用
     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
     /// @return 是否在挂起过程中产生中断（异常情况也返回false）
-    fn irq_check_pending(&mut self, irq_index: u16) -> Result<bool, PciError> {
+    fn irq_check_pending(&self, irq_index: u16) -> Result<bool, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix { .. } => {
                     return self.msix_check_pending(irq_index);
                 }
@@ -989,9 +993,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @param self PCI设备的可变引用
     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
     /// @return 是否在挂起过程中产生中断（异常情况也返回false）
-    fn msi_check_pending(&mut self, irq_index: u16) -> Result<bool, PciError> {
+    fn msi_check_pending(&self, irq_index: u16) -> Result<bool, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msi {
                     maskable,
                     address_64,
@@ -1038,9 +1042,9 @@ pub trait PciInterrupt: PciDeviceStructure {
     /// @param self PCI设备的可变引用
     /// @param irq_index 中断的位置（在vec中的index和安装的index相同）
     /// @return 是否在挂起过程中产生中断（异常情况也返回false）
-    fn msix_check_pending(&mut self, irq_index: u16) -> Result<bool, PciError> {
+    fn msix_check_pending(&self, irq_index: u16) -> Result<bool, PciError> {
         if let Some(irq_type) = self.irq_type_mut() {
-            match *irq_type {
+            match *irq_type.read() {
                 IrqType::Msix {
                     irq_max_num,
                     pending_table_bar,
@@ -1055,7 +1059,8 @@ pub trait PciInterrupt: PciDeviceStructure {
                     let pcistandardbar = self
                         .bar()
                         .ok_or(PciError::PciIrqError(PciIrqError::PciBarNotInited))
-                        .unwrap();
+                        .unwrap()
+                        .read();
                     let pending_bar = pcistandardbar.get_bar(pending_table_bar).unwrap();
                     let vaddr = pending_bar.virtual_address().unwrap()
                         + pending_table_offset as usize

kernel/src/driver/pci/raw_device.rs

@@ -37,9 +37,9 @@ struct InnerPciGeneralDevice {
     device_common: DeviceCommonData,
 }
 
-impl From<&PciDeviceStructureGeneralDevice> for PciGeneralDevice {
-    fn from(value: &PciDeviceStructureGeneralDevice) -> Self {
-        let value = Arc::new(value.clone());
+impl From<Arc<PciDeviceStructureGeneralDevice>> for PciGeneralDevice {
+    fn from(value: Arc<PciDeviceStructureGeneralDevice>) -> Self {
+        // let value = Arc::new(value.clone());
         let name: String = value.common_header.bus_device_function.into();
         let kobj_state = LockedKObjectState::new(None);
         let dev_id = PciDeviceID::dummpy();
@@ -80,6 +80,30 @@ impl PciDevice for PciGeneralDevice {
     fn subsystem_device(&self) -> u16 {
         self.header.subsystem_id
     }
+
+    fn class_code(&self) -> u8 {
+        self.header.common_header.class_code
+    }
+
+    fn revision(&self) -> u8 {
+        self.header.common_header.revision_id
+    }
+
+    fn irq_type(&self) -> &RwLock<super::pci_irq::IrqType> {
+        &self.header.irq_type
+    }
+
+    fn irq_line(&self) -> u8 {
+        self.header.interrupt_line
+    }
+
+    fn interface_code(&self) -> u8 {
+        self.header.common_header.prog_if
+    }
+
+    fn subclass(&self) -> u8 {
+        self.header.common_header.subclass
+    }
 }
 
 impl Device for PciGeneralDevice {

kernel/src/driver/pci/root.rs

@@ -317,7 +317,7 @@ pub struct PciRootIterator<'a> {
     index: usize,
 }
 
-impl<'a> Iterator for PciRootIterator<'a> {
+impl Iterator for PciRootIterator<'_> {
     type Item = Arc<PciRoot>;
 
     fn next(&mut self) -> Option<Self::Item> {

kernel/src/driver/pci/test/pt_device.rs

@@ -14,7 +14,7 @@ use crate::{
             kobject::{KObjType, KObject, KObjectCommonData, KObjectState, LockedKObjectState},
             kset::KSet,
         },
-        pci::{dev_id::PciDeviceID, device::PciDevice},
+        pci::{dev_id::PciDeviceID, device::PciDevice, pci_irq::IrqType},
     },
     filesystem::{
         kernfs::KernFSInode,
@@ -36,6 +36,7 @@ pub struct TestDevice {
     device_data: RwLock<DeviceCommonData>,
     kobj_data: RwLock<KObjectCommonData>,
     kobj_state: LockedKObjectState,
+    static_type: RwLock<IrqType>,
 }
 
 impl TestDevice {
@@ -46,6 +47,7 @@ impl TestDevice {
             device_data: common_dev,
             kobj_data: common_kobj,
             kobj_state: LockedKObjectState::new(None),
+            static_type: RwLock::new(IrqType::Unused),
         }
     }
 }
@@ -70,6 +72,30 @@ impl PciDevice for TestDevice {
     fn subsystem_device(&self) -> u16 {
         return 0xffff;
     }
+
+    fn class_code(&self) -> u8 {
+        return 0xff;
+    }
+
+    fn irq_line(&self) -> u8 {
+        return 0xff;
+    }
+
+    fn revision(&self) -> u8 {
+        return 0xff;
+    }
+
+    fn irq_type(&self) -> &RwLock<crate::driver::pci::pci_irq::IrqType> {
+        return &self.static_type;
+    }
+
+    fn interface_code(&self) -> u8 {
+        return 0xff;
+    }
+
+    fn subclass(&self) -> u8 {
+        return 0xff;
+    }
 }
 
 impl Device for TestDevice {

kernel/src/driver/scsi/mod.rs

@@ -64,6 +64,7 @@ impl ScsiManager {
         BlockDevName::new(format!("sd{}", x), id)
     }
 
+    #[allow(dead_code)]
     pub fn free_id(&self, id: usize) {
         if id >= Self::MAX_DEVICES {
             return;

kernel/src/driver/tty/tty_ldisc/ntty.rs

@@ -785,14 +785,12 @@ impl NTtyData {
         signal: Signal,
     ) {
         // 先处理信号
-        let mut ctrl_info = tty.core().contorl_info_irqsave();
+        let ctrl_info = tty.core().contorl_info_irqsave();
         let pg = ctrl_info.pgid;
         if let Some(pg) = pg {
             let _ = Syscall::kill(pg, signal as i32);
         }
 
-        ctrl_info.pgid = None;
-
         if !termios.local_mode.contains(LocalMode::NOFLSH) {
             // 重置
             self.echo_head = 0;

kernel/src/driver/video/fbdev/base/fbmem.rs

@@ -181,6 +181,7 @@ impl FrameBufferManager {
     }
 
     /// 根据id查找帧缓冲区
+    #[allow(dead_code)]
     pub fn find_fb_by_id(&self, id: FbId) -> Result<Option<Arc<dyn FrameBuffer>>, SystemError> {
         if unlikely(!id.is_valid()) {
             return Err(SystemError::EINVAL);

kernel/src/driver/video/fbdev/base/mod.rs

@@ -1,4 +1,5 @@
 use alloc::{string::String, sync::Arc, vec::Vec};
+use render_helper::{FrameP, FramePointerStatus};
 use system_error::SystemError;
 
 use crate::{
@@ -69,22 +70,20 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
         let bit_per_pixel = self.current_fb_var().bits_per_pixel;
 
         // 计算图像在帧缓冲中的起始位
-        let mut bitstart = (y * self.current_fb_fix().line_length * 8) + (x * bit_per_pixel);
+        let bitstart = (y * self.current_fb_fix().line_length * 8) + (x * bit_per_pixel);
         let start_index = bitstart & (32 - 1);
         let pitch_index = (self.current_fb_fix().line_length & (byte_per_pixel - 1)) * 8;
-        // 位转字节
-        bitstart /= 8;
-
-        // 对齐到像素字节大小
-        bitstart &= !(byte_per_pixel - 1);
-
-        let dst1 = boot_param.screen_info.lfb_virt_base;
-        if dst1.is_none() {
+        let dst2 = boot_param.screen_info.lfb_virt_base;
+        if dst2.is_none() {
             return;
         }
-        let mut dst1 = dst1.unwrap();
-        dst1 += VirtAddr::new(bitstart as usize);
-
+        let mut safe_pointer = FrameP::new(
+            self.current_fb_var().yres as usize,
+            self.current_fb_var().xres as usize,
+            self.current_fb_var().bits_per_pixel as usize,
+            dst2.unwrap(),
+            image,
+        );
         let _ = self.fb_sync();
 
         if image.depth == 1 {
@@ -107,16 +106,9 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
                 && image.width & (32 / bit_per_pixel - 1) == 0
                 && (8..=32).contains(&bit_per_pixel)
             {
-                unsafe { self.fast_imageblit(image, dst1, fg, bg) }
+                unsafe { self.fast_imageblit(image, &mut safe_pointer, fg, bg) }
             } else {
-                self.slow_imageblit(
-                    image,
-                    dst1,
-                    fg,
-                    bg,
-                    bitstart / 4,
-                    self.current_fb_fix().line_length,
-                )
+                self.slow_imageblit(image, &mut safe_pointer, fg, bg)
             }
         } else {
             todo!("color image blit todo");
@@ -129,7 +121,7 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
     /// 要求 image->width 可以被像素或 dword (ppw) 整除。
     /// 要求 fix->line_length 可以被 4 整除。
     /// 扫描线的开始和结束都是 dword 对齐的。
-    unsafe fn fast_imageblit(&self, image: &FbImage, mut dst1: VirtAddr, fg: u32, bg: u32) {
+    unsafe fn fast_imageblit(&self, image: &FbImage, dst1: &mut FrameP, fg: u32, bg: u32) {
         let bpp = self.current_fb_var().bits_per_pixel;
         let mut fgx = fg;
         let mut bgx = bg;
@@ -161,13 +153,12 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
             color_tab[idx] = (*val & eorx) ^ bgx;
         }
 
-        let mut dst;
         let mut shift;
         let mut src;
         let mut offset = 0;
         let mut j = 0;
+        let mut count = 0;
         for _ in (0..image.height).rev() {
-            dst = dst1.as_ptr::<u32>();
             shift = 8;
             src = offset;
             match ppw {
@@ -175,10 +166,8 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
                     // 8bpp
                     j = k;
                     while j >= 2 {
-                        *dst = color_tab[(image.data[src] as usize >> 4) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize) & bitmask];
-                        dst = dst.add(1);
+                        dst1.write(color_tab[(image.data[src] as usize >> 4) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize) & bitmask]);
                         j -= 2;
                         src += 1;
                     }
@@ -187,14 +176,10 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
                     // 16bpp
                     j = k;
                     while j >= 4 {
-                        *dst = color_tab[(image.data[src] as usize >> 6) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize >> 4) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize >> 2) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize) & bitmask];
-                        dst = dst.add(1);
+                        dst1.write(color_tab[(image.data[src] as usize >> 6) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize >> 4) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize >> 2) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize) & bitmask]);
                         src += 1;
                         j -= 4;
                     }
@@ -203,22 +188,14 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
                     // 32 bpp
                     j = k;
                     while j >= 8 {
-                        *dst = color_tab[(image.data[src] as usize >> 7) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize >> 6) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize >> 5) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize >> 4) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize >> 3) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize >> 2) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize >> 1) & bitmask];
-                        dst = dst.add(1);
-                        *dst = color_tab[(image.data[src] as usize) & bitmask];
-                        dst = dst.add(1);
+                        dst1.write(color_tab[(image.data[src] as usize >> 7) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize >> 6) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize >> 5) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize >> 4) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize >> 3) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize >> 2) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize >> 1) & bitmask]);
+                        dst1.write(color_tab[(image.data[src] as usize) & bitmask]);
                         src += 1;
                         j -= 8;
                     }
@@ -233,8 +210,7 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
              */
             while j != 0 {
                 shift -= ppw;
-                *dst = color_tab[(image.data[src] as usize >> shift) & bitmask];
-                dst = dst.add(1);
+                dst1.write(color_tab[(image.data[src] as usize >> shift) & bitmask]);
                 if shift == 0 {
                     shift = 8;
                     src += 1;
@@ -242,22 +218,15 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
                 j -= 1;
             }
 
-            dst1 += VirtAddr::new(self.current_fb_fix().line_length as usize);
+            count += 1;
+            dst1.move_with_offset(self.current_fb_fix().line_length * count);
             offset += spitch as usize;
         }
     }
 
-    fn slow_imageblit(
-        &self,
-        _image: &FbImage,
-        _dst1: VirtAddr,
-        _fg: u32,
-        _bg: u32,
-        _start_index: u32,
-        _pitch_index: u32,
-    ) {
-        let mut dst = _dst1.as_ptr::<u32>();
+    fn slow_imageblit(&self, _image: &FbImage, safe_dst: &mut FrameP, _fg: u32, _bg: u32) {
         let mut count = 0;
+        let mut pt_status = FramePointerStatus::Normal;
         let iter = BitIter::new(
             _fg,
             _bg,
@@ -268,17 +237,19 @@ pub trait FrameBuffer: FrameBufferInfo + FrameBufferOps + Device {
             _image.width,
         );
         for (content, full) in iter {
-            unsafe {
-                *dst = content;
-
-                dst = dst.add(1);
+            match pt_status {
+                FramePointerStatus::OutOfBuffer => {
+                    return;
+                }
+                FramePointerStatus::OutOfScreen => {}
+                FramePointerStatus::Normal => {
+                    pt_status = safe_dst.write(content);
+                }
             }
-
             if full {
                 count += 1;
-                dst = unsafe {
-                    _dst1.as_ptr::<u8>().add((_pitch_index * count) as usize) as *mut u32
-                };
+                safe_dst.move_with_offset(self.current_fb_fix().line_length * count);
+                pt_status = FramePointerStatus::Normal;
             }
         }
     }

kernel/src/driver/video/fbdev/base/render_helper.rs

@@ -1,4 +1,8 @@
-use core::slice::Iter;
+use core::{ops::Add, slice::Iter};
+
+use crate::mm::VirtAddr;
+
+use super::FbImage;
 
 pub struct BitIter<'a> {
     fgcolor: u32,
@@ -170,3 +174,125 @@ impl PixelLineStatus {
         }
     }
 }
+
+/// # 结构功能
+/// 安全的FrameBufferPointer
+/// 使用该结构体访问FrameBuffer可以防止超出FrameBuffer区域的访问
+/// 需要注意，使用该指针写入时，任何超出屏幕的写入都是无效的！即使仍然可以写入显存。
+/// 此外由于FbImage中的x和y变量采用u32类型，所以并未考虑左越界和上越界的安全性(即Image.x<0或Image.y<0的情况)
+/// ## 成员
+///
+///  - "dst" : 显存base address，通常是0xffffa1003ff00000
+///  - "limit" : 显存区域上界，可以通过公式计算：limit = dst + 分辨率高*分辨率宽*每个像素的**字节**数。也就是说任何对于显存的访问应该限制在[dst,limit)中
+///  - "current" : 当前相对于start_offset的位移
+///  - "start_offset" : 如果你要渲染某个Image，你可能不是总是从屏幕左上角(0,0)开始渲染，你可能从某个offset开始
+///  - "start_xpos" : 表示你要渲染的Image的x位置的字节位置
+///  - "current_xpos" : 当前渲染的x位置的字节位置
+///  - "limit_xpos" : 最大的渲染x位置的字节位置。 例：假设系统的分辨率为640，位深为24，你需要渲染的Image的x坐标为200，那么start_xpos=200*3=600，current_xpos=200*3+当前行已经渲染像素数*3，limit_xpos=640*3
+#[derive(Debug)]
+pub struct FrameP {
+    dst: VirtAddr,
+    limit: VirtAddr,
+    current: usize,
+    start_offset: usize,
+    start_xpos: usize,
+    current_xpos: usize,
+    limit_xpos: usize,
+}
+
+impl FrameP {
+    pub fn new(
+        frame_height: usize,
+        frame_width: usize,
+        bitdepth: usize,
+        dst: VirtAddr,
+        image: &FbImage,
+    ) -> Self {
+        let byte_per_pixel = bitdepth / 8;
+        let limit = VirtAddr::new(frame_height * frame_width * byte_per_pixel) + dst;
+        Self {
+            dst,
+            limit,
+            current: 0,
+            start_offset: start_offset(image, bitdepth as u32, (frame_width * bitdepth / 8) as u32)
+                as usize,
+            start_xpos: image.x as usize * byte_per_pixel,
+            current_xpos: image.x as usize * byte_per_pixel,
+            limit_xpos: frame_width * byte_per_pixel,
+        }
+    }
+
+    /// # 函数功能
+    /// 写入某个数据并将指针增大
+    pub fn write<T>(&mut self, data: T) -> FramePointerStatus {
+        // 首先获取数据大小
+        let size = size_of::<T>();
+        // 复制显存指针防止改变self的dst
+        let mut dst = self.dst;
+
+        // 你最终要写入的位置实际上是[dst+start_offset+current,dst+start_offset+current+size),所以我们要确定你写入的位置是否超过limit
+        if self.dst.data() + self.current + self.start_offset + size > self.limit.data() {
+            return FramePointerStatus::OutOfBuffer;
+        }
+        // 我们也不希望你的x超出屏幕右边，超出屏幕右边的部分会被忽略掉，因为如果写入显存会导致内存风险
+        else if self.current_xpos + size > self.limit_xpos {
+            return FramePointerStatus::OutOfScreen;
+        }
+        // 如果上面两个检查都通过了，我们就可以写入显存了
+        else {
+            // 这里是写入位置的实际虚拟地址
+            dst = dst.add(self.current + self.start_offset);
+        }
+        // 写入操作
+        unsafe {
+            *dst.as_ptr::<T>() = data;
+        }
+        // 写入后更新current和xpos
+        self.current += size;
+        self.current_xpos += size;
+        // 由于写入正常，我们返回正常的状态
+        return FramePointerStatus::Normal;
+    }
+
+    /// # 函数功能
+    /// 移动指针**至**某个offset
+    /// todo: 当前函数应当只用于换行，否则可能会导致安全性问题，即offset应该是每行像素的开头
+    pub fn move_with_offset(&mut self, offset: u32) {
+        self.current = offset as usize;
+        // let x_pos=self.current%self.limit_xpos;
+        // match x_pos{
+        //     n if n<self.start_xpos=>{
+        //         // send_to_default_serial8250_port(format!("Sended by function move_with_offset: Check if there is misusage of offset,the image.x is:{:?} while the xpos indicated by the offset is:{:?},current FP:{:?}\n",self.start_offset,x_pos,self).as_bytes());
+        //     }
+        //     n if n>=self.limit_xpos=>{
+        //         // send_to_default_serial8250_port(format!("Sended by function move_with_offset: Check if there is misusage of offset,The offset:{:?} is so large that it would exceed the limit of frame buffer\n",offset).as_bytes());
+        //     }
+        //     _=>{
+
+        //     }
+        // }
+        self.current_xpos = self.start_xpos;
+    }
+}
+
+pub enum FramePointerStatus {
+    /// 表示状态正常
+    Normal,
+    /// 超出屏幕，一直到换行时才应该恢复到正常状态
+    OutOfScreen,
+    /// 超出缓存，此时应当立即停止渲染
+    OutOfBuffer,
+}
+
+pub fn start_offset(image: &FbImage, bitdepth: u32, line_length: u32) -> u32 {
+    let x = image.x;
+    let y = image.y;
+    let mut bitstart = (y * line_length * 8) + (x * bitdepth);
+    let byte_per_pixel = core::mem::size_of::<u32>() as u32;
+    // 位转字节
+    bitstart /= 8;
+
+    // 对齐到像素字节大小
+    bitstart &= !(byte_per_pixel - 1);
+    return bitstart;
+}

kernel/src/driver/virtio/irq.rs

@@ -77,7 +77,6 @@ impl VirtIOIrqManager {
     /// # 返回
     /// - 如果找到了设备，返回一个包含设备的`Option<Arc<dyn VirtIODevice>>`。
     /// - 如果没有找到设备，返回`None`。
-
     pub fn lookup_device(&self, dev_id: &Arc<DeviceId>) -> Option<Arc<dyn VirtIODevice>> {
         let map = self.map.read_irqsave();
         map.get(dev_id).cloned()

kernel/src/driver/virtio/transport.rs

@@ -1,8 +1,21 @@
-use virtio_drivers::transport::Transport;
+use alloc::{string::ToString, sync::Arc};
 
-use crate::exception::HardwareIrqNumber;
+use virtio_drivers::transport::Transport;
 
-use super::{transport_mmio::VirtIOMmioTransport, transport_pci::PciTransport};
+use crate::{
+    driver::{
+        base::device::DeviceId,
+        pci::{
+            pci::{PciDeviceStructure, PciError},
+            pci_irq::{IrqCommonMsg, IrqSpecificMsg, PciInterrupt, PciIrqError, PciIrqMsg, IRQ},
+        },
+    },
+    exception::IrqNumber,
+};
+
+use super::{
+    irq::DefaultVirtioIrqHandler, transport_mmio::VirtIOMmioTransport, transport_pci::PciTransport,
+};
 
 pub enum VirtIOTransport {
     Pci(PciTransport),
@@ -10,11 +23,34 @@ pub enum VirtIOTransport {
 }
 
 impl VirtIOTransport {
-    pub fn irq(&self) -> Option<HardwareIrqNumber> {
-        match self {
-            VirtIOTransport::Mmio(transport) => Some(transport.irq()),
-            _ => None,
-        }
+    pub fn irq(&self) -> IrqNumber {
+        match self {
+            VirtIOTransport::Pci(transport) => transport.irq(),
+            VirtIOTransport::Mmio(transport) => IrqNumber::new(transport.irq().data()),
+        }
+    }
+
+    /// 设置中断
+    pub fn setup_irq(&self, dev_id: Arc<DeviceId>) -> Result<(), PciError> {
+        if let VirtIOTransport::Pci(transport) = self {
+            let standard_device = transport.pci_device().as_standard_device().unwrap();
+            standard_device
+                .irq_init(IRQ::PCI_IRQ_MSIX | IRQ::PCI_IRQ_MSI)
+                .ok_or(PciError::PciIrqError(PciIrqError::IrqNotInited))?;
+            // 中断相关信息
+            let msg = PciIrqMsg {
+                irq_common_message: IrqCommonMsg::init_from(
+                    0,
+                    "Virtio_IRQ".to_string(),
+                    &DefaultVirtioIrqHandler,
+                    dev_id,
+                ),
+                irq_specific_message: IrqSpecificMsg::msi_default(),
+            };
+            standard_device.irq_install(msg)?;
+            standard_device.irq_enable(true)?;
+        }
+        return Ok(());
     }
 }
 

kernel/src/driver/virtio/transport_pci.rs

@@ -6,7 +6,6 @@ use crate::driver::pci::pci::{
     PciStandardDeviceBar, PCI_CAP_ID_VNDR,
 };
 
-use crate::driver::pci::pci_irq::{IrqCommonMsg, IrqSpecificMsg, PciInterrupt, PciIrqMsg, IRQ};
 use crate::driver::pci::root::pci_root_0;
 
 use crate::exception::IrqNumber;
@@ -16,7 +15,6 @@ use crate::libs::volatile::{
 };
 use crate::mm::VirtAddr;
 
-use alloc::string::ToString;
 use alloc::sync::Arc;
 use core::{
     fmt::{self, Display, Formatter},
@@ -28,7 +26,6 @@ use virtio_drivers::{
     Error, Hal, PhysAddr,
 };
 
-use super::irq::DefaultVirtioIrqHandler;
 use super::VIRTIO_VENDOR_ID;
 
 /// The offset to add to a VirtIO device ID to get the corresponding PCI device ID.
@@ -104,6 +101,7 @@ pub struct PciTransport {
     config_space: Option<NonNull<[u32]>>,
     irq: IrqNumber,
     dev_id: Arc<DeviceId>,
+    device: Arc<PciDeviceStructureGeneralDevice>,
 }
 
 impl PciTransport {
@@ -118,7 +116,7 @@ impl PciTransport {
     /// - `irq_number_offset` - Currently, this parameter is just simple make a offset to the irq number, cause it's not be allowed to have the same irq number within different device
     #[allow(clippy::extra_unused_type_parameters)]
     pub fn new<H: Hal>(
-        device: &mut PciDeviceStructureGeneralDevice,
+        device: Arc<PciDeviceStructureGeneralDevice>,
         dev_id: Arc<DeviceId>,
     ) -> Result<Self, VirtioPciError> {
         let irq = VIRTIO_RECV_VECTOR;
@@ -136,25 +134,12 @@ impl PciTransport {
         let mut device_cfg = None;
         device.bar_ioremap().unwrap()?;
         device.enable_master();
-        let standard_device = device.as_standard_device_mut().unwrap();
+        let standard_device = device.as_standard_device().unwrap();
         // 目前缺少对PCI设备中断号的统一管理，所以这里需要指定一个中断号。不能与其他中断重复
         let irq_vector = standard_device.irq_vector_mut().unwrap();
-        irq_vector.push(irq);
-        standard_device
-            .irq_init(IRQ::PCI_IRQ_MSIX | IRQ::PCI_IRQ_MSI)
-            .ok_or(VirtioPciError::UnableToInitIrq)?;
-        // 中断相关信息
-        let msg = PciIrqMsg {
-            irq_common_message: IrqCommonMsg::init_from(
-                0,
-                "Virtio_IRQ".to_string(),
-                &DefaultVirtioIrqHandler,
-                dev_id.clone(),
-            ),
-            irq_specific_message: IrqSpecificMsg::msi_default(),
-        };
-        standard_device.irq_install(msg)?;
-        standard_device.irq_enable(true)?;
+        irq_vector.write().push(irq);
+
+        // panic!();
         //device_capability为迭代器，遍历其相当于遍历所有的cap空间
         for capability in device.capabilities().unwrap() {
             if capability.id != PCI_CAP_ID_VNDR {
@@ -202,7 +187,7 @@ impl PciTransport {
         }
 
         let common_cfg = get_bar_region::<_>(
-            &device.standard_device_bar,
+            &device.standard_device_bar.read(),
             &common_cfg.ok_or(VirtioPciError::MissingCommonConfig)?,
         )?;
 
@@ -213,14 +198,15 @@ impl PciTransport {
             ));
         }
         //debug!("notify.offset={},notify.length={}",notify_cfg.offset,notify_cfg.length);
-        let notify_region = get_bar_region_slice::<_>(&device.standard_device_bar, &notify_cfg)?;
+        let notify_region =
+            get_bar_region_slice::<_>(&device.standard_device_bar.read(), &notify_cfg)?;
         let isr_status = get_bar_region::<_>(
-            &device.standard_device_bar,
+            &device.standard_device_bar.read(),
             &isr_cfg.ok_or(VirtioPciError::MissingIsrConfig)?,
         )?;
         let config_space = if let Some(device_cfg) = device_cfg {
             Some(get_bar_region_slice::<_>(
-                &device.standard_device_bar,
+                &device.standard_device_bar.read(),
                 &device_cfg,
             )?)
         } else {
@@ -236,8 +222,17 @@ impl PciTransport {
             config_space,
             irq,
             dev_id,
+            device,
         })
     }
+
+    pub fn pci_device(&self) -> Arc<PciDeviceStructureGeneralDevice> {
+        self.device.clone()
+    }
+
+    pub fn irq(&self) -> IrqNumber {
+        self.irq
+    }
 }
 
 impl Transport for PciTransport {
@@ -446,8 +441,6 @@ pub enum VirtioPciError {
     /// `VIRTIO_PCI_CAP_NOTIFY_CFG` capability has a `notify_off_multiplier` that is not a multiple
     /// of 2.
     InvalidNotifyOffMultiplier(u32),
-    /// Unable to find capability such as MSIX or MSI.
-    UnableToInitIrq,
     /// No valid `VIRTIO_PCI_CAP_ISR_CFG` capability was found.
     MissingIsrConfig,
     /// An IO BAR was provided rather than a memory BAR.
@@ -477,7 +470,6 @@ impl Display for VirtioPciError {
                 "PCI device vender ID {:#06x} was not the VirtIO vendor ID {:#06x}.",
                 vendor_id, VIRTIO_VENDOR_ID
             ),
-            Self::UnableToInitIrq => write!(f, "Unable to find capability such as MSIX or MSI."),
             Self::MissingCommonConfig => write!(
                 f,
                 "No valid `VIRTIO_PCI_CAP_COMMON_CFG` capability was found."

kernel/src/driver/virtio/virtio.rs

@@ -6,17 +6,15 @@ use crate::driver::base::device::{Device, DeviceId};
 use crate::driver::block::virtio_blk::virtio_blk;
 use crate::driver::net::virtio_net::virtio_net;
 use crate::driver::pci::pci::{
-    get_pci_device_structures_mut_by_vendor_id, PciDeviceStructure,
-    PciDeviceStructureGeneralDevice, PCI_DEVICE_LINKEDLIST,
+    get_pci_device_structures_mut_by_vendor_id, PciDeviceStructureGeneralDevice,
+    PCI_DEVICE_LINKEDLIST,
 };
 use crate::driver::pci::subsys::pci_bus;
 use crate::driver::virtio::transport::VirtIOTransport;
-use crate::libs::rwlock::RwLockWriteGuard;
 
 use alloc::string::String;
 use alloc::sync::Arc;
 use alloc::vec::Vec;
-use alloc::{boxed::Box, collections::LinkedList};
 use log::{debug, error, warn};
 use virtio_drivers::transport::{DeviceType, Transport};
 
@@ -29,12 +27,11 @@ pub fn virtio_probe() {
 
 #[allow(dead_code)]
 fn virtio_probe_pci() {
-    let mut list = PCI_DEVICE_LINKEDLIST.write();
-    let virtio_list = virtio_device_search(&mut list);
+    let virtio_list = virtio_device_search();
     for virtio_device in virtio_list {
         let dev_id = virtio_device.common_header.device_id;
         let dev_id = DeviceId::new(None, Some(format!("{dev_id}"))).unwrap();
-        match PciTransport::new::<HalImpl>(virtio_device, dev_id.clone()) {
+        match PciTransport::new::<HalImpl>(virtio_device.clone(), dev_id.clone()) {
             Ok(mut transport) => {
                 debug!(
                     "Detected virtio PCI device with device type {:?}, features {:#018x}",
@@ -87,19 +84,17 @@ pub(super) fn virtio_device_init(
 /// ## 返回值
 ///
 /// 返回一个包含所有找到的virtio设备的数组
-fn virtio_device_search<'a>(
-    list: &'a mut RwLockWriteGuard<'_, LinkedList<Box<dyn PciDeviceStructure>>>,
-) -> Vec<&'a mut PciDeviceStructureGeneralDevice> {
+fn virtio_device_search() -> Vec<Arc<PciDeviceStructureGeneralDevice>> {
+    let list = &*PCI_DEVICE_LINKEDLIST;
     let mut virtio_list = Vec::new();
     let result = get_pci_device_structures_mut_by_vendor_id(list, 0x1AF4);
 
     for device in result {
-        let standard_device = device.as_standard_device_mut().unwrap();
+        let standard_device = device.as_standard_device().unwrap();
         let header = &standard_device.common_header;
         if header.device_id >= 0x1000 && header.device_id <= 0x103F {
             virtio_list.push(standard_device);
         }
     }
-
     return virtio_list;
 }

kernel/src/driver/virtio/virtio_impl.rs

@@ -23,7 +23,9 @@ unsafe impl Hal for HalImpl {
         _direction: BufferDirection,
     ) -> (virtio_drivers::PhysAddr, NonNull<u8>) {
         let page_num = PageFrameCount::new(
-            ((pages * PAGE_SIZE + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE).next_power_of_two(),
+            (pages * PAGE_SIZE)
+                .div_ceil(MMArch::PAGE_SIZE)
+                .next_power_of_two(),
         );
         unsafe {
             let (paddr, count) =
@@ -55,7 +57,9 @@ unsafe impl Hal for HalImpl {
         pages: usize,
     ) -> i32 {
         let page_count = PageFrameCount::new(
-            ((pages * PAGE_SIZE + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE).next_power_of_two(),
+            (pages * PAGE_SIZE)
+                .div_ceil(MMArch::PAGE_SIZE)
+                .next_power_of_two(),
         );
 
         // 恢复页面属性

kernel/src/exception/irqdata.rs

@@ -306,6 +306,7 @@ impl IrqCommonData {
         self.inner.lock_irqsave().affinity = affinity;
     }
 
+    #[allow(dead_code)]
     pub fn set_effective_affinity(&self, affinity: CpuMask) {
         self.inner.lock_irqsave().effective_affinity = affinity;
     }
@@ -346,6 +347,7 @@ impl InnerIrqCommonData {
         self.handler_data.clone()
     }
 
+    #[allow(dead_code)]
     pub fn effective_affinity(&self) -> &CpuMask {
         &self.effective_affinity
     }

kernel/src/exception/irqdesc.rs

@@ -286,10 +286,12 @@ impl IrqDesc {
         );
     }
 
+    #[allow(dead_code)]
     pub fn set_probe(&self) {
         self.modify_status(IrqLineStatus::IRQ_NOPROBE, IrqLineStatus::empty());
     }
 
+    #[allow(dead_code)]
     pub fn set_noprobe(&self) {
         self.modify_status(IrqLineStatus::empty(), IrqLineStatus::IRQ_NOPROBE);
     }
@@ -416,6 +418,7 @@ impl InnerIrqDesc {
         self.line_status.insert(IrqLineStatus::IRQ_NOTHREAD);
     }
 
+    #[allow(dead_code)]
     pub fn clear_nothread(&mut self) {
         self.line_status.remove(IrqLineStatus::IRQ_NOTHREAD);
     }
@@ -451,6 +454,7 @@ impl InnerIrqDesc {
         !self.line_status.contains(IrqLineStatus::IRQ_NOAUTOEN)
     }
 
+    #[allow(dead_code)]
     pub fn can_thread(&self) -> bool {
         !self.line_status.contains(IrqLineStatus::IRQ_NOTHREAD)
     }
@@ -486,6 +490,7 @@ impl InnerIrqDesc {
         self.actions.clear();
     }
 
+    #[allow(dead_code)]
     pub fn remove_action(&mut self, action: &Arc<IrqAction>) {
         self.actions.retain(|a| !Arc::ptr_eq(a, action));
     }
@@ -506,14 +511,17 @@ impl InnerIrqDesc {
         &self.common_data
     }
 
+    #[allow(dead_code)]
     pub fn depth(&self) -> u32 {
         self.depth
     }
 
+    #[allow(dead_code)]
     pub fn wake_depth(&self) -> u32 {
         self.wake_depth
     }
 
+    #[allow(dead_code)]
     pub fn set_depth(&mut self, depth: u32) {
         self.depth = depth;
     }
@@ -540,6 +548,7 @@ impl InnerIrqDesc {
         &mut self.percpu_enabled
     }
 
+    #[allow(dead_code)]
     pub fn percpu_affinity(&self) -> &Option<CpuMask> {
         &self.percpu_affinity
     }
@@ -969,6 +978,7 @@ impl IrqDescManager {
     }
 
     /// 设置指定irq的可用cpu为所有cpu
+    #[allow(dead_code)]
     pub fn set_percpu_devid_all(&self, irq: IrqNumber) -> Result<(), SystemError> {
         self.set_percpu_devid(irq, None)
     }

kernel/src/exception/irqdomain.rs

@@ -319,6 +319,7 @@ impl IrqDomainManager {
     /// - `handler_data`: 中断流处理程序数据
     /// - `handler_name`: 中断处理程序名称
     #[allow(clippy::too_many_arguments)]
+    #[allow(dead_code)]
     pub fn domain_set_info(
         &self,
         domain: &Arc<IrqDomain>,
@@ -557,14 +558,17 @@ impl IrqDomain {
     }
 
     /// The number of mapped interrupts
+    #[allow(dead_code)]
     pub fn map_count(&self) -> u32 {
         self.revmap_read_irqsave().map.len() as u32
     }
 
+    #[allow(dead_code)]
     pub fn host_data(&self) -> Option<Arc<dyn IrqChipData>> {
         self.inner.lock_irqsave().host_data.clone()
     }
 
+    #[allow(dead_code)]
     pub fn set_host_data(&self, host_data: Option<Arc<dyn IrqChipData>>) {
         self.inner.lock_irqsave().host_data = host_data;
     }

kernel/src/exception/manage.rs

@@ -785,6 +785,7 @@ impl IrqManager {
         );
     }
 
+    #[allow(dead_code)]
     pub fn irq_set_affinity(
         &self,
         irq_data: &Arc<IrqData>,

kernel/src/exception/softirq.rs

@@ -275,13 +275,13 @@ struct RunningCountGuard<'a> {
 }
 
 impl<'a> RunningCountGuard<'a> {
-    fn new(cpu_running_count: &'a PerCpuVar<AtomicI16>) -> RunningCountGuard {
+    fn new(cpu_running_count: &'a PerCpuVar<AtomicI16>) -> RunningCountGuard<'a> {
         cpu_running_count.get().fetch_add(1, Ordering::SeqCst);
         return RunningCountGuard { cpu_running_count };
     }
 }
 
-impl<'a> Drop for RunningCountGuard<'a> {
+impl Drop for RunningCountGuard<'_> {
     fn drop(&mut self) {
         self.cpu_running_count.get().fetch_sub(1, Ordering::SeqCst);
     }

kernel/src/filesystem/eventfd.rs

@@ -5,6 +5,7 @@ use crate::libs::spinlock::{SpinLock, SpinLockGuard};
 use crate::libs::wait_queue::WaitQueue;
 use crate::net::event_poll::{EPollEventType, EPollItem, EventPoll, KernelIoctlData};
 use crate::process::ProcessManager;
+use crate::sched::SchedMode;
 use crate::syscall::Syscall;
 use alloc::collections::LinkedList;
 use alloc::string::String;
@@ -76,6 +77,11 @@ impl EventFdInode {
 
         Err(SystemError::ENOENT)
     }
+
+    fn readable(&self) -> bool {
+        let count = self.eventfd.lock().count;
+        return count > 0;
+    }
 }
 
 impl IndexNode for EventFdInode {
@@ -104,26 +110,29 @@ impl IndexNode for EventFdInode {
         _offset: usize,
         len: usize,
         buf: &mut [u8],
-        data: SpinLockGuard<FilePrivateData>,
+        data_guard: SpinLockGuard<FilePrivateData>,
     ) -> Result<usize, SystemError> {
+        let data = data_guard.clone();
+        drop(data_guard);
         if len < 8 {
             return Err(SystemError::EINVAL);
         }
-        let mut val = loop {
-            let val = self.eventfd.lock().count;
-            if val != 0 {
-                break val;
-            }
-            if self
-                .eventfd
-                .lock()
-                .flags
-                .contains(EventFdFlags::EFD_NONBLOCK)
-            {
+        let mut lock_efd = self.eventfd.lock();
+        while lock_efd.count == 0 {
+            if lock_efd.flags.contains(EventFdFlags::EFD_NONBLOCK) {
+                drop(lock_efd);
                 return Err(SystemError::EAGAIN_OR_EWOULDBLOCK);
             }
-            self.wait_queue.sleep();
-        };
+
+            drop(lock_efd);
+            let r = wq_wait_event_interruptible!(self.wait_queue, self.readable(), {});
+            if r.is_err() {
+                return Err(SystemError::ERESTARTSYS);
+            }
+
+            lock_efd = self.eventfd.lock();
+        }
+        let mut val = lock_efd.count;
 
         let mut eventfd = self.eventfd.lock();
         if eventfd.flags.contains(EventFdFlags::EFD_SEMAPHORE) {

kernel/src/filesystem/fat/bpb.rs

@@ -266,8 +266,7 @@ impl BiosParameterBlock {
         bpb.trail_sig = cursor.read_u16()?;
 
         // 计算根目录项占用的空间（单位：字节）
-        let root_sectors = ((bpb.root_entries_cnt as u32 * 32) + (bpb.bytes_per_sector as u32 - 1))
-            / (bpb.bytes_per_sector as u32);
+        let root_sectors = (bpb.root_entries_cnt as u32 * 32).div_ceil(bpb.bytes_per_sector as u32);
 
         // 每FAT扇区数
         let fat_size = if bpb.fat_size_16 != 0 {
@@ -347,9 +346,8 @@ impl BiosParameterBlock {
             }
         };
 
-        let root_sectors = ((self.root_entries_cnt as u32 * 32)
-            + (self.bytes_per_sector as u32 - 1))
-            / (self.bytes_per_sector as u32);
+        let root_sectors =
+            (self.root_entries_cnt as u32 * 32).div_ceil(self.bytes_per_sector as u32);
 
         // 当前分区总扇区数
         let total_sectors = if self.total_sectors_16 != 0 {

kernel/src/filesystem/fat/entry.rs

@@ -256,8 +256,7 @@ impl FATFile {
         // 如果还需要更多的簇
         if bytes_remain_in_cluster < extra_bytes {
             let clusters_to_allocate =
-                (extra_bytes - bytes_remain_in_cluster + fs.bytes_per_cluster() - 1)
-                    / fs.bytes_per_cluster();
+                (extra_bytes - bytes_remain_in_cluster).div_ceil(fs.bytes_per_cluster());
             let last_cluster = if let Some(c) = fs.get_last_cluster(self.first_cluster) {
                 c
             } else {
@@ -338,7 +337,7 @@ impl FATFile {
             return Ok(());
         }
 
-        let new_last_cluster = (new_size + fs.bytes_per_cluster() - 1) / fs.bytes_per_cluster();
+        let new_last_cluster = new_size.div_ceil(fs.bytes_per_cluster());
         if let Some(begin_delete) =
             fs.get_cluster_by_relative(self.first_cluster, new_last_cluster as usize)
         {
@@ -463,8 +462,7 @@ impl FATDir {
 
         // 计算需要申请多少个簇
         let clusters_required =
-            (remain_entries * FATRawDirEntry::DIR_ENTRY_LEN + fs.bytes_per_cluster() - 1)
-                / fs.bytes_per_cluster();
+            (remain_entries * FATRawDirEntry::DIR_ENTRY_LEN).div_ceil(fs.bytes_per_cluster());
         let mut first_cluster = Cluster::default();
         let mut prev_cluster = current_cluster;
         // debug!(

kernel/src/filesystem/fat/fs.rs

@@ -326,9 +326,8 @@ impl FATFileSystem {
         };
 
         // 根目录项占用的扇区数（向上取整）
-        let root_dir_sectors: u64 = ((bpb.root_entries_cnt as u64 * 32)
-            + (bpb.bytes_per_sector as u64 - 1))
-            / (bpb.bytes_per_sector as u64);
+        let root_dir_sectors: u64 =
+            (bpb.root_entries_cnt as u64 * 32).div_ceil(bpb.bytes_per_sector as u64);
 
         // FAT表大小（单位：扇区）
         let fat_size = if bpb.fat_size_16 != 0 {
@@ -843,6 +842,7 @@ impl FATFileSystem {
     /// @return Ok(true) 正常
     /// @return Ok(false) 不正常
     /// @return Err(SystemError) 在判断时发生错误
+    #[allow(dead_code)]
     pub fn is_hard_error_bit_ok(&mut self) -> Result<bool, SystemError> {
         match self.bpb.fat_type {
             FATType::FAT32(_) => {
@@ -935,10 +935,8 @@ impl FATFileSystem {
 
             _ => {
                 // FAT12 / FAT16
-                let root_dir_sectors: u64 = (((self.bpb.root_entries_cnt as u64) * 32)
-                    + self.bpb.bytes_per_sector as u64
-                    - 1)
-                    / self.bpb.bytes_per_sector as u64;
+                let root_dir_sectors: u64 = ((self.bpb.root_entries_cnt as u64) * 32)
+                    .div_ceil(self.bpb.bytes_per_sector as u64);
                 // 数据区扇区数
                 let data_sec: u64 = self.bpb.total_sectors_16 as u64
                     - (self.bpb.rsvd_sec_cnt as u64
@@ -1283,6 +1281,7 @@ impl FATFsInfo {
     /// @brief 根据fsinfo的信息，计算当前总的空闲簇数量
     ///
     /// @param 当前文件系统的最大簇号
+    #[allow(dead_code)]
     pub fn count_free_cluster(&self, max_cluster: Cluster) -> Option<u64> {
         let count_clusters = max_cluster.cluster_num - RESERVED_CLUSTERS as u64 + 1;
         // 信息不合理，当前的FsInfo中存储的free count大于计算出来的值
@@ -1301,6 +1300,7 @@ impl FATFsInfo {
     /// @brief 更新FsInfo中的“空闲簇统计信息“为new_count
     ///
     /// 请注意，除非手动调用`flush()`，否则本函数不会将数据刷入磁盘
+    #[allow(dead_code)]
     pub fn update_free_count_abs(&mut self, new_count: u32) {
         self.free_count = new_count;
     }
@@ -1308,6 +1308,7 @@ impl FATFsInfo {
     /// @brief 更新FsInfo中的“空闲簇统计信息“，把它加上delta.
     ///
     /// 请注意，除非手动调用`flush()`，否则本函数不会将数据刷入磁盘
+    #[allow(dead_code)]
     pub fn update_free_count_delta(&mut self, delta: i32) {
         self.free_count = (self.free_count as i32 + delta) as u32;
     }
@@ -1360,6 +1361,7 @@ impl FATFsInfo {
     /// @brief 读取磁盘上的Fs Info扇区，将里面的内容更新到结构体中
     ///
     /// @param partition fs info所在的分区
+    #[allow(dead_code)]
     pub fn update(&mut self, partition: Arc<Partition>) -> Result<(), SystemError> {
         if let Some(off) = self.offset {
             let in_block_offset = off % LBA_SIZE as u64;
@@ -1888,7 +1890,7 @@ struct ClusterIter<'a> {
     fs: &'a FATFileSystem,
 }
 
-impl<'a> Iterator for ClusterIter<'a> {
+impl Iterator for ClusterIter<'_> {
     type Item = Cluster;
 
     fn next(&mut self) -> Option<Self::Item> {

kernel/src/filesystem/mbr.rs

@@ -169,7 +169,7 @@ impl<'a> MbrPartitionIter<'a> {
     }
 }
 
-impl<'a> Iterator for MbrPartitionIter<'a> {
+impl Iterator for MbrPartitionIter<'_> {
     type Item = Partition;
 
     fn next(&mut self) -> Option<Self::Item> {

kernel/src/filesystem/mod.rs

@@ -4,6 +4,7 @@ pub mod eventfd;
 pub mod fat;
 pub mod kernfs;
 pub mod mbr;
+pub mod overlayfs;
 pub mod procfs;
 pub mod ramfs;
 pub mod sysfs;

kernel/src/filesystem/overlayfs/copy_up.rs

@@ -0,0 +1,41 @@
+use super::OvlInode;
+use crate::{
+    filesystem::vfs::{IndexNode, Metadata},
+    libs::spinlock::SpinLock,
+};
+use alloc::sync::Arc;
+use system_error::SystemError;
+
+impl OvlInode {
+    pub fn copy_up(&self) -> Result<(), SystemError> {
+        let mut upper_inode = self.upper_inode.lock();
+        if upper_inode.is_some() {
+            return Ok(());
+        }
+
+        let lower_inode = self.lower_inode.as_ref().ok_or(SystemError::ENOENT)?;
+
+        let metadata = lower_inode.metadata()?;
+        let new_upper_inode = self.create_upper_inode(metadata.clone())?;
+
+        let mut buffer = vec![0u8; metadata.size as usize];
+        let lock = SpinLock::new(crate::filesystem::vfs::FilePrivateData::Unused);
+        lower_inode.read_at(0, metadata.size as usize, &mut buffer, lock.lock())?;
+
+        new_upper_inode.write_at(0, metadata.size as usize, &buffer, lock.lock())?;
+
+        *upper_inode = Some(new_upper_inode);
+
+        Ok(())
+    }
+
+    fn create_upper_inode(&self, metadata: Metadata) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let upper_inode = self.upper_inode.lock();
+        let upper_root_inode = upper_inode
+            .as_ref()
+            .ok_or(SystemError::ENOSYS)?
+            .fs()
+            .root_inode();
+        upper_root_inode.create_with_data(&self.dname()?.0, metadata.file_type, metadata.mode, 0)
+    }
+}

kernel/src/filesystem/overlayfs/entry.rs

@@ -0,0 +1,32 @@
+use alloc::sync::Arc;
+
+use alloc::vec::Vec;
+
+use crate::filesystem::vfs::IndexNode;
+
+use super::{OvlInode, OvlSuperBlock};
+#[derive(Debug)]
+pub struct OvlEntry {
+    numlower: usize, // 下层数量
+    lowerstack: Vec<OvlPath>,
+}
+
+impl OvlEntry {
+    pub fn new() -> Self {
+        Self {
+            numlower: 2,
+            lowerstack: Vec::new(),
+        }
+    }
+}
+#[derive(Debug)]
+pub struct OvlPath {
+    layer: Arc<OvlLayer>,
+    inode: Arc<dyn IndexNode>,
+}
+#[derive(Debug)]
+pub struct OvlLayer {
+    pub mnt: Arc<OvlInode>, // 挂载点
+    pub index: u32,         // 0 是上层读写层，>0 是下层只读层
+    pub fsid: u32,          // 文件系统标识符
+}

kernel/src/filesystem/overlayfs/mod.rs

@@ -0,0 +1,433 @@
+#![allow(dead_code, unused_variables, unused_imports)]
+pub mod copy_up;
+pub mod entry;
+
+use super::ramfs::{LockedRamFSInode, RamFSInode};
+use super::vfs::{self, FileSystem, FileType, FsInfo, IndexNode, Metadata, SuperBlock};
+use super::vfs::{FSMAKER, ROOT_INODE};
+use crate::driver::base::device::device_number::DeviceNumber;
+use crate::driver::base::device::device_number::Major;
+use crate::filesystem::vfs::{FileSystemMaker, FileSystemMakerData};
+use crate::libs::spinlock::SpinLock;
+use alloc::string::String;
+use alloc::sync::Arc;
+use alloc::sync::Weak;
+use alloc::vec::Vec;
+use entry::{OvlEntry, OvlLayer};
+use linkme::distributed_slice;
+use system_error::SystemError;
+
+const WHITEOUT_MODE: u64 = 0o020000 | 0o600; // whiteout字符设备文件模式与权限
+const WHITEOUT_DEV: DeviceNumber = DeviceNumber::new(Major::UNNAMED_MAJOR, 0); // Whiteout 文件设备号
+const WHITEOUT_FLAG: u64 = 0x1;
+
+#[distributed_slice(FSMAKER)]
+static OVERLAYFSMAKER: FileSystemMaker = FileSystemMaker::new(
+    "overlay",
+    &(OverlayFS::make_overlayfs
+        as fn(
+            Option<&dyn FileSystemMakerData>,
+        ) -> Result<Arc<dyn FileSystem + 'static>, SystemError>),
+);
+#[derive(Debug)]
+pub struct OverlayMountData {
+    upper_dir: String,
+    lower_dirs: Vec<String>,
+    work_dir: String,
+}
+
+impl OverlayMountData {
+    pub fn from_row(raw_data: *const u8) -> Result<Self, SystemError> {
+        if raw_data.is_null() {
+            return Err(SystemError::EINVAL);
+        }
+        let len = (0..)
+            .find(|&i| unsafe { raw_data.add(i).read() } == 0)
+            .ok_or(SystemError::EINVAL)?;
+        let slice = unsafe { core::slice::from_raw_parts(raw_data, len) };
+        let raw_str = core::str::from_utf8(slice).map_err(|_| SystemError::EINVAL)?;
+        let mut data = OverlayMountData {
+            upper_dir: String::new(),
+            lower_dirs: Vec::new(),
+            work_dir: String::new(),
+        };
+
+        for pair in raw_str.split(',') {
+            let mut parts = pair.split('=');
+            let key = parts.next().ok_or(SystemError::EINVAL)?;
+            let value = parts.next().ok_or(SystemError::EINVAL)?;
+
+            match key {
+                "upperdir" => data.upper_dir = value.into(),
+                "lowerdir" => data.lower_dirs = value.split(':').map(|s| s.into()).collect(),
+                "workdir" => data.work_dir = value.into(),
+                _ => return Err(SystemError::EINVAL),
+            }
+        }
+        Ok(data)
+    }
+}
+impl FileSystemMakerData for OverlayMountData {
+    fn as_any(&self) -> &dyn core::any::Any {
+        self
+    }
+}
+#[derive(Debug)]
+pub struct OvlSuperBlock {
+    super_block: SuperBlock,
+    pseudo_dev: DeviceNumber, // 虚拟设备号
+    is_lower: bool,
+}
+
+#[derive(Debug)]
+struct OverlayFS {
+    numlayer: usize,
+    numfs: u32,
+    numdatalayer: usize,
+    layers: Vec<OvlLayer>, // 第0层为读写层，后面是只读层
+    workdir: Arc<OvlInode>,
+    root_inode: Arc<OvlInode>,
+}
+
+#[derive(Debug)]
+pub struct OvlInode {
+    redirect: String, // 重定向路径
+    file_type: FileType,
+    flags: SpinLock<u64>,
+    upper_inode: SpinLock<Option<Arc<dyn IndexNode>>>, // 读写层
+    lower_inode: Option<Arc<dyn IndexNode>>,           // 只读层
+    oe: Arc<OvlEntry>,
+    fs: Weak<OverlayFS>,
+}
+impl OvlInode {
+    pub fn new(
+        redirect: String,
+        upper: Option<Arc<dyn IndexNode>>,
+        lower_inode: Option<Arc<dyn IndexNode>>,
+    ) -> Self {
+        Self {
+            redirect,
+            file_type: FileType::Dir,
+            flags: SpinLock::new(0),
+            upper_inode: SpinLock::new(upper),
+            lower_inode,
+            oe: Arc::new(OvlEntry::new()),
+            fs: Weak::default(),
+        }
+    }
+}
+
+impl FileSystem for OverlayFS {
+    fn root_inode(&self) -> Arc<dyn IndexNode> {
+        self.root_inode.clone()
+    }
+
+    fn info(&self) -> vfs::FsInfo {
+        FsInfo {
+            blk_dev_id: 0,
+            max_name_len: 255,
+        }
+    }
+
+    fn as_any_ref(&self) -> &dyn core::any::Any {
+        self
+    }
+
+    fn name(&self) -> &str {
+        "overlayfs"
+    }
+
+    fn super_block(&self) -> SuperBlock {
+        todo!()
+    }
+}
+
+impl OverlayFS {
+    pub fn ovl_upper_mnt(&self) -> Arc<dyn IndexNode> {
+        self.layers[0].mnt.clone()
+    }
+    pub fn make_overlayfs(
+        data: Option<&dyn FileSystemMakerData>,
+    ) -> Result<Arc<dyn FileSystem + 'static>, SystemError> {
+        let mount_data = data
+            .and_then(|d| d.as_any().downcast_ref::<OverlayMountData>())
+            .ok_or(SystemError::EINVAL)?;
+
+        let upper_inode = ROOT_INODE()
+            .lookup(&mount_data.upper_dir)
+            .map_err(|_| SystemError::EINVAL)?;
+        let upper_layer = OvlLayer {
+            mnt: Arc::new(OvlInode::new(
+                mount_data.upper_dir.clone(),
+                Some(upper_inode),
+                None,
+            )),
+            index: 0,
+            fsid: 0,
+        };
+
+        let lower_layers: Result<Vec<OvlLayer>, SystemError> = mount_data
+            .lower_dirs
+            .iter()
+            .enumerate()
+            .map(|(i, dir)| {
+                let lower_inode = ROOT_INODE().lookup(dir).map_err(|_| SystemError::EINVAL)?; // 处理错误
+                Ok(OvlLayer {
+                    mnt: Arc::new(OvlInode::new(dir.clone(), None, Some(lower_inode))),
+                    index: (i + 1) as u32,
+                    fsid: (i + 1) as u32,
+                })
+            })
+            .collect();
+
+        let lower_layers = lower_layers?;
+
+        let workdir = Arc::new(OvlInode::new(mount_data.work_dir.clone(), None, None));
+
+        if lower_layers.is_empty() {
+            return Err(SystemError::EINVAL);
+        }
+
+        let mut layers = Vec::new();
+        layers.push(upper_layer);
+        layers.extend(lower_layers);
+
+        let root_inode = layers[0].mnt.clone();
+
+        let fs = OverlayFS {
+            numlayer: layers.len(),
+            numfs: 1,
+            numdatalayer: layers.len() - 1,
+            layers,
+            workdir,
+            root_inode,
+        };
+        Ok(Arc::new(fs))
+    }
+}
+
+impl OvlInode {
+    pub fn ovl_lower_redirect(&self) -> Option<&str> {
+        if self.file_type == FileType::File || self.file_type == FileType::Dir {
+            Some(&self.redirect)
+        } else {
+            None
+        }
+    }
+
+    pub fn create_whiteout(&self, name: &str) -> Result<(), SystemError> {
+        let whiteout_mode = vfs::syscall::ModeType::S_IFCHR;
+        let mut upper_inode = self.upper_inode.lock();
+        if let Some(ref upper_inode) = *upper_inode {
+            upper_inode.mknod(name, whiteout_mode, WHITEOUT_DEV)?;
+        } else {
+            let new_inode = self
+                .fs
+                .upgrade()
+                .ok_or(SystemError::EROFS)?
+                .root_inode()
+                .create(name, FileType::CharDevice, whiteout_mode)?;
+            *upper_inode = Some(new_inode);
+        }
+        let mut flags = self.flags.lock();
+        *flags |= WHITEOUT_FLAG; // 标记为 whiteout
+        Ok(())
+    }
+
+    fn is_whiteout(&self) -> bool {
+        let flags = self.flags.lock();
+        self.file_type == FileType::CharDevice && (*flags & WHITEOUT_FLAG) != 0
+    }
+
+    fn has_whiteout(&self, name: &str) -> bool {
+        let upper_inode = self.upper_inode.lock();
+        if let Some(ref upper_inode) = *upper_inode {
+            if let Ok(inode) = upper_inode.find(name) {
+                if let Some(ovl_inode) = inode.as_any_ref().downcast_ref::<OvlInode>() {
+                    return ovl_inode.is_whiteout();
+                }
+            }
+        }
+        false
+    }
+}
+
+impl IndexNode for OvlInode {
+    fn read_at(
+        &self,
+        offset: usize,
+        len: usize,
+        buf: &mut [u8],
+        data: crate::libs::spinlock::SpinLockGuard<vfs::FilePrivateData>,
+    ) -> Result<usize, system_error::SystemError> {
+        if let Some(ref upper_inode) = *self.upper_inode.lock() {
+            return upper_inode.read_at(offset, len, buf, data);
+        }
+
+        if let Some(lower_inode) = &self.lower_inode {
+            return lower_inode.read_at(offset, len, buf, data);
+        }
+
+        Err(SystemError::ENOENT)
+    }
+
+    fn write_at(
+        &self,
+        offset: usize,
+        len: usize,
+        buf: &[u8],
+        data: crate::libs::spinlock::SpinLockGuard<vfs::FilePrivateData>,
+    ) -> Result<usize, SystemError> {
+        if (*self.upper_inode.lock()).is_none() {
+            self.copy_up()?;
+        }
+        if let Some(ref upper_inode) = *self.upper_inode.lock() {
+            return upper_inode.write_at(offset, len, buf, data);
+        }
+
+        Err(SystemError::EROFS)
+    }
+
+    fn fs(&self) -> Arc<dyn FileSystem> {
+        self.fs.upgrade().unwrap()
+    }
+
+    fn metadata(&self) -> Result<Metadata, SystemError> {
+        if let Some(ref upper_inode) = *self.upper_inode.lock() {
+            return upper_inode.metadata();
+        }
+
+        if let Some(ref lower_inode) = self.lower_inode {
+            return lower_inode.metadata();
+        }
+        Ok(Metadata::default())
+    }
+
+    fn as_any_ref(&self) -> &dyn core::any::Any {
+        self
+    }
+
+    fn list(&self) -> Result<Vec<String>, system_error::SystemError> {
+        let mut entries: Vec<String> = Vec::new();
+        let upper_inode = self.upper_inode.lock();
+        if let Some(ref upper_inode) = *upper_inode {
+            let upper_entries = upper_inode.list()?;
+            entries.extend(upper_entries);
+        }
+        if let Some(lower_inode) = &self.lower_inode {
+            let lower_entries = lower_inode.list()?;
+            for entry in lower_entries {
+                if !entries.contains(&entry) && !self.has_whiteout(&entry) {
+                    entries.push(entry);
+                }
+            }
+        }
+
+        Ok(entries)
+    }
+
+    fn mkdir(
+        &self,
+        name: &str,
+        mode: vfs::syscall::ModeType,
+    ) -> Result<Arc<dyn IndexNode>, system_error::SystemError> {
+        if let Some(ref upper_inode) = *self.upper_inode.lock() {
+            upper_inode.mkdir(name, mode)
+        } else {
+            Err(SystemError::EROFS)
+        }
+    }
+
+    fn rmdir(&self, name: &str) -> Result<(), SystemError> {
+        let upper_inode = self.upper_inode.lock();
+        if let Some(ref upper_inode) = *upper_inode {
+            upper_inode.rmdir(name)?;
+        } else if let Some(lower_inode) = &self.lower_inode {
+            if lower_inode.find(name).is_ok() {
+                self.create_whiteout(name)?;
+            } else {
+                return Err(SystemError::ENOENT);
+            }
+        } else {
+            return Err(SystemError::ENOENT);
+        }
+
+        Ok(())
+    }
+
+    fn unlink(&self, name: &str) -> Result<(), SystemError> {
+        let upper_inode = self.upper_inode.lock();
+        if let Some(ref upper_inode) = *upper_inode {
+            upper_inode.unlink(name)?;
+        } else if let Some(lower_inode) = &self.lower_inode {
+            if lower_inode.find(name).is_ok() {
+                self.create_whiteout(name)?;
+            } else {
+                return Err(SystemError::ENOENT);
+            }
+        } else {
+            return Err(SystemError::ENOENT);
+        }
+
+        Ok(())
+    }
+
+    fn link(
+        &self,
+        name: &str,
+        other: &Arc<dyn IndexNode>,
+    ) -> Result<(), system_error::SystemError> {
+        if let Some(ref upper_inode) = *self.upper_inode.lock() {
+            upper_inode.link(name, other)
+        } else {
+            Err(SystemError::EROFS)
+        }
+    }
+
+    fn create(
+        &self,
+        name: &str,
+        file_type: vfs::FileType,
+        mode: vfs::syscall::ModeType,
+    ) -> Result<Arc<dyn IndexNode>, system_error::SystemError> {
+        if let Some(ref upper_inode) = *self.upper_inode.lock() {
+            upper_inode.create(name, file_type, mode)
+        } else {
+            Err(SystemError::EROFS)
+        }
+    }
+
+    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, system_error::SystemError> {
+        let upper_inode = self.upper_inode.lock();
+        if let Some(ref upper) = *upper_inode {
+            if let Ok(inode) = upper.find(name) {
+                return Ok(inode);
+            }
+        }
+        if self.has_whiteout(name) {
+            return Err(SystemError::ENOENT);
+        }
+
+        if let Some(lower) = &self.lower_inode {
+            if let Ok(inode) = lower.find(name) {
+                return Ok(inode);
+            }
+        }
+
+        Err(SystemError::ENOENT)
+    }
+
+    fn mknod(
+        &self,
+        filename: &str,
+        mode: vfs::syscall::ModeType,
+        dev_t: crate::driver::base::device::device_number::DeviceNumber,
+    ) -> Result<Arc<dyn IndexNode>, system_error::SystemError> {
+        let upper_inode = self.upper_inode.lock();
+        if let Some(ref inode) = *upper_inode {
+            inode.mknod(filename, mode, dev_t)
+        } else {
+            Err(SystemError::EROFS)
+        }
+    }
+}

kernel/src/filesystem/procfs/syscall.rs

@@ -51,7 +51,6 @@ impl Syscall {
     /// - 成功，Ok(usize)
     /// - 失败，Err(SystemError) 操作失败，返回posix错误码
     ///
-
     pub fn do_syslog(
         syslog_action_type: usize,
         buf: &mut [u8],

kernel/src/filesystem/ramfs/mod.rs

@@ -1,7 +1,7 @@
 use core::any::Any;
 use core::intrinsics::unlikely;
 
-use crate::filesystem::vfs::FSMAKER;
+use crate::filesystem::vfs::{FileSystemMakerData, FSMAKER};
 use crate::libs::rwlock::RwLock;
 use crate::{
     driver::base::device::device_number::DeviceNumber,
@@ -35,7 +35,7 @@ const RAMFS_MAX_NAMELEN: usize = 64;
 const RAMFS_BLOCK_SIZE: u64 = 512;
 /// @brief 内存文件系统的Inode结构体
 #[derive(Debug)]
-struct LockedRamFSInode(SpinLock<RamFSInode>);
+pub struct LockedRamFSInode(pub SpinLock<RamFSInode>);
 
 /// @brief 内存文件系统结构体
 #[derive(Debug)]
@@ -70,6 +70,35 @@ pub struct RamFSInode {
     name: DName,
 }
 
+impl RamFSInode {
+    pub fn new() -> Self {
+        Self {
+            parent: Weak::default(),
+            self_ref: Weak::default(),
+            children: BTreeMap::new(),
+            data: Vec::new(),
+            metadata: Metadata {
+                dev_id: 0,
+                inode_id: generate_inode_id(),
+                size: 0,
+                blk_size: 0,
+                blocks: 0,
+                atime: PosixTimeSpec::default(),
+                mtime: PosixTimeSpec::default(),
+                ctime: PosixTimeSpec::default(),
+                file_type: FileType::Dir,
+                mode: ModeType::from_bits_truncate(0o777),
+                nlinks: 1,
+                uid: 0,
+                gid: 0,
+                raw_dev: DeviceNumber::default(),
+            },
+            fs: Weak::default(),
+            special_node: None,
+            name: Default::default(),
+        }
+    }
+}
 impl FileSystem for RamFS {
     fn root_inode(&self) -> Arc<dyn super::vfs::IndexNode> {
         return self.root_inode.clone();
@@ -105,31 +134,8 @@ impl RamFS {
             RAMFS_MAX_NAMELEN as u64,
         );
         // 初始化root inode
-        let root: Arc<LockedRamFSInode> = Arc::new(LockedRamFSInode(SpinLock::new(RamFSInode {
-            parent: Weak::default(),
-            self_ref: Weak::default(),
-            children: BTreeMap::new(),
-            data: Vec::new(),
-            metadata: Metadata {
-                dev_id: 0,
-                inode_id: generate_inode_id(),
-                size: 0,
-                blk_size: 0,
-                blocks: 0,
-                atime: PosixTimeSpec::default(),
-                mtime: PosixTimeSpec::default(),
-                ctime: PosixTimeSpec::default(),
-                file_type: FileType::Dir,
-                mode: ModeType::from_bits_truncate(0o777),
-                nlinks: 1,
-                uid: 0,
-                gid: 0,
-                raw_dev: DeviceNumber::default(),
-            },
-            fs: Weak::default(),
-            special_node: None,
-            name: Default::default(),
-        })));
+        let root: Arc<LockedRamFSInode> =
+            Arc::new(LockedRamFSInode(SpinLock::new(RamFSInode::new())));
 
         let result: Arc<RamFS> = Arc::new(RamFS {
             root_inode: root,
@@ -147,7 +153,9 @@ impl RamFS {
         return result;
     }
 
-    pub fn make_ramfs() -> Result<Arc<dyn FileSystem + 'static>, SystemError> {
+    pub fn make_ramfs(
+        _data: Option<&dyn FileSystemMakerData>,
+    ) -> Result<Arc<dyn FileSystem + 'static>, SystemError> {
         let fs = RamFS::new();
         return Ok(fs);
     }
@@ -155,7 +163,10 @@ impl RamFS {
 #[distributed_slice(FSMAKER)]
 static RAMFSMAKER: FileSystemMaker = FileSystemMaker::new(
     "ramfs",
-    &(RamFS::make_ramfs as fn() -> Result<Arc<dyn FileSystem + 'static>, SystemError>),
+    &(RamFS::make_ramfs
+        as fn(
+            Option<&dyn FileSystemMakerData>,
+        ) -> Result<Arc<dyn FileSystem + 'static>, SystemError>),
 );
 
 impl IndexNode for LockedRamFSInode {

kernel/src/filesystem/vfs/file.rs

@@ -800,7 +800,7 @@ impl<'a> FileDescriptorIterator<'a> {
     }
 }
 
-impl<'a> Iterator for FileDescriptorIterator<'a> {
+impl Iterator for FileDescriptorIterator<'_> {
     type Item = (i32, Arc<File>);
 
     fn next(&mut self) -> Option<Self::Item> {

kernel/src/filesystem/vfs/mod.rs

@@ -935,12 +935,20 @@ impl FileSystemMaker {
         FileSystemMaker { function, name }
     }
 
-    pub fn call(&self) -> Result<Arc<dyn FileSystem>, SystemError> {
-        (self.function)()
+    pub fn call(
+        &self,
+        data: Option<&dyn FileSystemMakerData>,
+    ) -> Result<Arc<dyn FileSystem>, SystemError> {
+        (self.function)(data)
     }
 }
 
-pub type FileSystemNewFunction = fn() -> Result<Arc<dyn FileSystem>, SystemError>;
+pub trait FileSystemMakerData: Send + Sync {
+    fn as_any(&self) -> &dyn Any;
+}
+
+pub type FileSystemNewFunction =
+    fn(data: Option<&dyn FileSystemMakerData>) -> Result<Arc<dyn FileSystem>, SystemError>;
 
 #[macro_export]
 macro_rules! define_filesystem_maker_slice {
@@ -956,9 +964,18 @@ macro_rules! define_filesystem_maker_slice {
 /// 调用指定数组中的所有初始化器
 #[macro_export]
 macro_rules! producefs {
-    ($initializer_slice:ident,$filesystem:ident) => {
+    ($initializer_slice:ident,$filesystem:ident,$raw_data : ident) => {
         match $initializer_slice.iter().find(|&m| m.name == $filesystem) {
-            Some(maker) => maker.call(),
+            Some(maker) => {
+                let mount_data = match $filesystem {
+                    "overlay" => OverlayMountData::from_row($raw_data).ok(),
+                    _ => None,
+                };
+                let data: Option<&dyn FileSystemMakerData> =
+                    mount_data.as_ref().map(|d| d as &dyn FileSystemMakerData);
+
+                maker.call(data)
+            }
             None => {
                 log::error!("mismatch filesystem type : {}", $filesystem);
                 Err(SystemError::EINVAL)

kernel/src/filesystem/vfs/syscall.rs

@@ -1,4 +1,5 @@
-use core::ffi::c_void;
+use crate::filesystem::overlayfs::OverlayMountData;
+use crate::filesystem::vfs::FileSystemMakerData;
 use core::mem::size_of;
 
 use alloc::{string::String, sync::Arc, vec::Vec};
@@ -1706,7 +1707,7 @@ impl Syscall {
         target: *const u8,
         filesystemtype: *const u8,
         _mountflags: usize,
-        _data: *const c_void,
+        data: *const u8,
     ) -> Result<usize, SystemError> {
         let target = user_access::check_and_clone_cstr(target, Some(MAX_PATHLEN))?
             .into_string()
@@ -1715,7 +1716,7 @@ impl Syscall {
         let fstype_str = user_access::check_and_clone_cstr(filesystemtype, Some(MAX_PATHLEN))?;
         let fstype_str = fstype_str.to_str().map_err(|_| SystemError::EINVAL)?;
 
-        let fstype = producefs!(FSMAKER, fstype_str)?;
+        let fstype = producefs!(FSMAKER, fstype_str, data)?;
 
         Vcore::do_mount(fstype, &target)?;
 

kernel/src/init/boot.rs

@@ -49,6 +49,7 @@ impl BootParams {
         core::str::from_utf8(&self.boot_cmdline()[..self.boot_cmdline_len()]).unwrap()
     }
 
+    #[allow(dead_code)]
     pub fn bootloader_name(&self) -> Option<&str> {
         self.bootloader_name.as_deref()
     }

kernel/src/init/cmdline.rs

@@ -43,6 +43,7 @@ pub struct KernelCmdlineParamBuilder {
     inv: bool,
 }
 
+#[allow(dead_code)]
 impl KernelCmdlineParamBuilder {
     pub const fn new(name: &'static str, ty: KCmdlineParamType) -> Self {
         Self {
@@ -110,6 +111,7 @@ pub enum KernelCmdlineParameter {
     EarlyKV(&'static KernelCmdlineEarlyKV),
 }
 
+#[allow(dead_code)]
 impl KernelCmdlineParameter {
     pub fn name(&self) -> &str {
         match self {
@@ -195,6 +197,7 @@ pub struct KernelCmdlineEarlyKV {
     default: &'static str,
 }
 
+#[allow(dead_code)]
 impl KernelCmdlineEarlyKV {
     pub const VALUE_MAX_LEN: usize = 256;
 

kernel/src/init/init.rs

@@ -57,6 +57,7 @@ fn do_start_kernel() {
 
     unsafe { mm_init() };
 
+    // crate::debug::jump_label::static_keys_init();
     if scm_reinit().is_ok() {
         if let Err(e) = textui_init() {
             warn!("Failed to init textui: {:?}", e);
@@ -90,6 +91,7 @@ fn do_start_kernel() {
     clocksource_boot_finish();
     Futex::init();
     crate::bpf::init_bpf_system();
+    crate::debug::jump_label::static_keys_init();
     #[cfg(all(target_arch = "x86_64", feature = "kvm"))]
     crate::virt::kvm::kvm_init();
 }

kernel/src/init/initial_kthread.rs

@@ -10,6 +10,7 @@ use crate::{
     arch::{interrupt::TrapFrame, process::arch_switch_to_user},
     driver::{net::e1000e::e1000e::e1000e_init, virtio::virtio::virtio_probe},
     filesystem::vfs::core::mount_root_fs,
+    namespaces::NsProxy,
     net::net_core::net_init,
     process::{
         exec::ProcInitInfo, kthread::KernelThreadMechanism, stdio::stdio_init, ProcessFlags,
@@ -140,6 +141,7 @@ fn run_init_process(
     trap_frame: &mut TrapFrame,
 ) -> Result<(), SystemError> {
     compiler_fence(Ordering::SeqCst);
+    ProcessManager::current_pcb().set_nsproxy(NsProxy::new()); // 初始化init进程的namespace
     let path = proc_init_info.proc_name.to_str().unwrap();
 
     Syscall::do_execve(
@@ -148,5 +150,6 @@ fn run_init_process(
         proc_init_info.envs.clone(),
         trap_frame,
     )?;
+
     Ok(())
 }