fix(clippy): 修复内核代码库中的 Clippy 警告并优化 Rust 习惯用法

moyanj · moyanj · commit 70c66ddcb4f0 · 2026-01-31T17:02:51.000+08:00
- 为 DeviceManager, Keyboard, KernFs 等结构体实现 Default trait
- 使用 is_some_and, div_ceil, flatten, strip_prefix 等现代特性
- 优化内存分配，移除 Task 结构体不必要的 Box 包装
- 完善安全文档说明 (# Safety) 并优化测试循环效率
diff --git a/kernel/build.rs b/kernel/build.rs
@@ -27,12 +27,10 @@ fn main() {
     let obj_dir = workspace_root.join("target/obj");
 
     if let Ok(paths) = glob(&format!("{}/*.o", obj_dir.display())) {
-        for path_result in paths {
-            if let Ok(path) = path_result {
-                // Get the absolute path
-                let absolute_path = path.canonicalize().expect("Failed to canonicalize path");
-                println!("cargo:rustc-link-arg={}", absolute_path.display());
-            }
+        for path in paths.flatten() {
+            // Get the absolute path
+            let absolute_path = path.canonicalize().expect("Failed to canonicalize path");
+            println!("cargo:rustc-link-arg={}", absolute_path.display());
         }
     }
 }
diff --git a/kernel/src/drivers/device.rs b/kernel/src/drivers/device.rs
@@ -294,6 +294,7 @@ impl Clone for Device {
     }
 }
 
+#[derive(Default)]
 pub struct DeviceManager {
     devices: Vec<Arc<Device>>,
     next_minor_counters: BTreeMap<u16, u16>,
@@ -302,11 +303,7 @@ pub struct DeviceManager {
 
 impl DeviceManager {
     pub fn new() -> Self {
-        Self {
-            devices: Vec::new(),
-            next_minor_counters: BTreeMap::new(),
-            free_minors: BTreeMap::new(),
-        }
+        Self::default()
     }
 
     pub fn register_device(&mut self, mut device: Device) -> Result<Arc<Device>, DeviceError> {
@@ -396,10 +393,7 @@ impl DeviceManager {
     }
 
     fn reclaim_device_number(&mut self, major: u16, minor: u16) {
-        self.free_minors
-            .entry(major)
-            .or_insert_with(Vec::new)
-            .push(minor);
+        self.free_minors.entry(major).or_default().push(minor);
     }
 
     pub fn get_device(&self, name: &str) -> Option<Arc<Device>> {
diff --git a/kernel/src/drivers/input/keyboard.rs b/kernel/src/drivers/input/keyboard.rs
@@ -20,8 +20,8 @@ pub struct Keyboard {
     name: String,
 }
 
-impl Keyboard {
-    pub fn new() -> Self {
+impl Default for Keyboard {
+    fn default() -> Self {
         Self {
             inner: Mutex::new(KeyboardInner {
                 pc_keyboard: PcKeyboard::new(
@@ -37,6 +37,12 @@ impl Keyboard {
             name: String::from("keyboard"),
         }
     }
+}
+
+impl Keyboard {
+    pub fn new() -> Self {
+        Self::default()
+    }
 
     pub fn set_enabled(&self, enabled: bool) {
         x86_64::instructions::interrupts::without_interrupts(|| {
@@ -121,7 +127,7 @@ impl CharDevice for Keyboard {
                 }
             }
 
-            if read_count == 0 && buf.len() > 0 {
+            if read_count == 0 && !buf.is_empty() {
                 Err(DeviceError::WouldBlock)
             } else {
                 Ok(read_count)
diff --git a/kernel/src/fs/bio.rs b/kernel/src/fs/bio.rs
@@ -27,8 +27,7 @@ impl BlockCache {
         }
 
         let block_size = self.device.block_size();
-        let mut buf = Vec::with_capacity(block_size);
-        buf.resize(block_size, 0);
+        let mut buf = alloc::vec![0; block_size];
 
         if self.device.read_blocks(block_id, 1, &mut buf).is_ok() {
             let mut cache = self.cache.write();
diff --git a/kernel/src/fs/fs_impl/kernfs.rs b/kernel/src/fs/fs_impl/kernfs.rs
@@ -238,12 +238,18 @@ pub struct KernFs {
     root: Arc<KernInode>,
 }
 
-impl KernFs {
-    pub fn new() -> Self {
+impl Default for KernFs {
+    fn default() -> Self {
         let root = KernInode::new_dir();
 
         Self { root }
     }
+}
+
+impl KernFs {
+    pub fn new() -> Self {
+        Self::default()
+    }
 
     pub fn root(&self) -> Arc<KernInode> {
         self.root.clone()
diff --git a/kernel/src/fs/vfs.rs b/kernel/src/fs/vfs.rs
@@ -13,10 +13,7 @@ use lazy_static::lazy_static;
 use spin::{Mutex, RwLock};
 
 lazy_static! {
-    pub static ref VFS: Vfs = {
-        let fs = Vfs::new();
-        fs
-    };
+    pub static ref VFS: Vfs = Vfs::new();
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -201,8 +198,10 @@ pub struct Vfs {
     fs_registry: RwLock<BTreeMap<&'static str, Arc<dyn FileSystem>>>,
 }
 
-impl Vfs {
-    pub fn new() -> Self {
+pub type WalkEntry = (String, Vec<String>, Vec<String>);
+
+impl Default for Vfs {
+    fn default() -> Self {
         let mut registry: BTreeMap<&'static str, Arc<dyn FileSystem>> = BTreeMap::new();
         let kernfs = Arc::new(fs_impl::kernfs::KernFs::new());
         registry.insert("kernfs", kernfs.clone());
@@ -220,6 +219,12 @@ impl Vfs {
             fs_registry: RwLock::new(registry),
         }
     }
+}
+
+impl Vfs {
+    pub fn new() -> Self {
+        Self::default()
+    }
 
     pub fn init_root(&self, root: Arc<dyn Inode>) {
         *self.root.write() = Some(root);
@@ -455,10 +460,7 @@ impl Vfs {
         }
     }
 
-    pub fn walk(
-        &self,
-        start_path: &str,
-    ) -> Result<Vec<(String, Vec<String>, Vec<String>)>, VfsError> {
+    pub fn walk(&self, start_path: &str) -> Result<Vec<WalkEntry>, VfsError> {
         let mut results = Vec::new();
         let mut stack: Vec<String> = Vec::new();
         let normalized_start_path = self.normalize_path(start_path);
diff --git a/kernel/src/interrupts/apic.rs b/kernel/src/interrupts/apic.rs
@@ -15,16 +15,14 @@ const XAPIC_EOI_OFFSET: u64 = 0x0B0;
 const XAPIC_SIVR_OFFSET: u64 = 0xF0;
 pub fn apic_is_available() -> bool {
     let cpuid = CpuId::new();
-    cpuid
-        .get_feature_info()
-        .map_or(false, |info| info.has_apic())
+    cpuid.get_feature_info().is_some_and(|info| info.has_apic())
 }
 
 pub fn x2apic_is_available() -> bool {
     let cpuid = CpuId::new();
     cpuid
         .get_feature_info()
-        .map_or(false, |info| info.has_x2apic())
+        .is_some_and(|info| info.has_x2apic())
 }
 
 /// Enables x2APIC mode
diff --git a/kernel/src/interrupts/gdt.rs b/kernel/src/interrupts/gdt.rs
@@ -13,8 +13,7 @@ lazy_static! {
             static mut STACK: [u8; STACK_SIZE] = [0; STACK_SIZE];
 
             let stack_start = VirtAddr::from_ptr(&raw const STACK);
-            let stack_end = stack_start + STACK_SIZE as u64;
-            stack_end
+            stack_start + STACK_SIZE as u64
         };
         tss
     };
diff --git a/kernel/src/interrupts/idt.rs b/kernel/src/interrupts/idt.rs
@@ -41,22 +41,22 @@ lazy_static! {
         }
         // PIC 中断处理器设置
         // IRQ0 - 时钟中断, IRQ1 - 键盘中断
-        idt[PIC_1_OFFSET as u8].set_handler_fn(handler::pic_interrupt_handler_0); // IRQ0
-        idt[PIC_1_OFFSET as u8 + 1].set_handler_fn(handler::pic_interrupt_handler_1); // IRQ1
-        idt[PIC_1_OFFSET as u8 + 2].set_handler_fn(handler::pic_interrupt_handler_2); // IRQ2
-        idt[PIC_1_OFFSET as u8 + 3].set_handler_fn(handler::pic_interrupt_handler_3); // IRQ3
-        idt[PIC_1_OFFSET as u8 + 4].set_handler_fn(handler::pic_interrupt_handler_4); // IRQ4
-        idt[PIC_1_OFFSET as u8 + 5].set_handler_fn(handler::pic_interrupt_handler_5); // IRQ5
-        idt[PIC_1_OFFSET as u8 + 6].set_handler_fn(handler::pic_interrupt_handler_6); // IRQ6
-        idt[PIC_1_OFFSET as u8 + 7].set_handler_fn(handler::pic_interrupt_handler_7); // IRQ7
-        idt[PIC_2_OFFSET as u8].set_handler_fn(handler::pic_interrupt_handler_8);   // IRQ8
-        idt[PIC_2_OFFSET as u8 + 1].set_handler_fn(handler::pic_interrupt_handler_9);   // IRQ9
-        idt[PIC_2_OFFSET as u8 + 2].set_handler_fn(handler::pic_interrupt_handler_10);  // IRQ10
-        idt[PIC_2_OFFSET as u8 + 3].set_handler_fn(handler::pic_interrupt_handler_11);  // IRQ11
-        idt[PIC_2_OFFSET as u8 + 4].set_handler_fn(handler::pic_interrupt_handler_12);  // IRQ12
-        idt[PIC_2_OFFSET as u8 + 5].set_handler_fn(handler::pic_interrupt_handler_13);  // IRQ13
-        idt[PIC_2_OFFSET as u8 + 6].set_handler_fn(handler::pic_interrupt_handler_14);  // IRQ14
-        idt[PIC_2_OFFSET as u8 + 7].set_handler_fn(handler::pic_interrupt_handler_15);  // IRQ15
+        idt[PIC_1_OFFSET].set_handler_fn(handler::pic_interrupt_handler_0); // IRQ0
+        idt[PIC_1_OFFSET + 1].set_handler_fn(handler::pic_interrupt_handler_1); // IRQ1
+        idt[PIC_1_OFFSET + 2].set_handler_fn(handler::pic_interrupt_handler_2); // IRQ2
+        idt[PIC_1_OFFSET + 3].set_handler_fn(handler::pic_interrupt_handler_3); // IRQ3
+        idt[PIC_1_OFFSET + 4].set_handler_fn(handler::pic_interrupt_handler_4); // IRQ4
+        idt[PIC_1_OFFSET + 5].set_handler_fn(handler::pic_interrupt_handler_5); // IRQ5
+        idt[PIC_1_OFFSET + 6].set_handler_fn(handler::pic_interrupt_handler_6); // IRQ6
+        idt[PIC_1_OFFSET + 7].set_handler_fn(handler::pic_interrupt_handler_7); // IRQ7
+        idt[PIC_2_OFFSET].set_handler_fn(handler::pic_interrupt_handler_8);   // IRQ8
+        idt[PIC_2_OFFSET + 1].set_handler_fn(handler::pic_interrupt_handler_9);   // IRQ9
+        idt[PIC_2_OFFSET + 2].set_handler_fn(handler::pic_interrupt_handler_10);  // IRQ10
+        idt[PIC_2_OFFSET + 3].set_handler_fn(handler::pic_interrupt_handler_11);  // IRQ11
+        idt[PIC_2_OFFSET + 4].set_handler_fn(handler::pic_interrupt_handler_12);  // IRQ12
+        idt[PIC_2_OFFSET + 5].set_handler_fn(handler::pic_interrupt_handler_13);  // IRQ13
+        idt[PIC_2_OFFSET + 6].set_handler_fn(handler::pic_interrupt_handler_14);  // IRQ14
+        idt[PIC_2_OFFSET + 7].set_handler_fn(handler::pic_interrupt_handler_15);  // IRQ15
         idt
     };
 }
diff --git a/kernel/src/lib.rs b/kernel/src/lib.rs
@@ -102,13 +102,3 @@ macro_rules! extern_safe {
         )*
     };
 }
-
-/* The test functions */
-#[cfg(test)]
-mod tests {
-
-    #[test_case]
-    fn test_success() {
-        assert_eq!(2 + 3, 5);
-    }
-}
diff --git a/kernel/src/libs/initrd.rs b/kernel/src/libs/initrd.rs
@@ -1,3 +1,5 @@
+//! This code is originally from https://github.com/rcore-os/cpio/blob/main/src/lib.rs, with minor modifications made here.
+
 extern crate alloc;
 use crate::fs::fs_impl::MemFs;
 use crate::fs::vfs::{File, FileSystem, VNodeType, VfsError, VFS};
@@ -6,8 +8,6 @@ use alloc::string::{String, ToString};
 use alloc::vec::Vec;
 use log::{debug, error, info, warn};
 
-/// This code is originally from https://github.com/rcore-os/cpio/blob/main/src/lib.rs, with minor modifications made here.
-
 /// A CPIO file (newc format) reader.
 ///
 /// # Example
@@ -203,8 +203,8 @@ pub fn load_cpio(initrd_data: &[u8]) -> Result<(), VfsError> {
         // We want absolute paths in VFS, e.g., "/foo/bar".
         let canonical_path = if path.starts_with('/') {
             path.to_string()
-        } else if path.starts_with("./") {
-            format!("/{}", &path[2..])
+        } else if let Some(stripped) = path.strip_prefix("./") {
+            format!("/{}", stripped)
         } else {
             format!("/{}", path)
         };
@@ -242,12 +242,11 @@ pub fn load_cpio(initrd_data: &[u8]) -> Result<(), VfsError> {
                         }
                     }
                     Err(VfsError::NotFound) => {
-                        vfs.create_dir(&current_dir_segment).map_err(|e| {
+                        vfs.create_dir(&current_dir_segment).inspect_err(|e| {
                             error!(
                                 "Failed to create directory {}: {:?}",
                                 current_dir_segment, e
                             );
-                            e
                         })?;
                     }
                     Err(e) => {
diff --git a/kernel/src/libs/logger.rs b/kernel/src/libs/logger.rs
@@ -13,26 +13,15 @@ impl Log for KernelLogger {
         if self.enabled(record.metadata()) {
             let level = record.level();
 
-            let color;
-            match record.level() {
-                log::Level::Error => {
-                    color = "\x1b[31m";
-                }
-                log::Level::Warn => {
-                    color = "\x1b[33m";
-                }
-                log::Level::Info => {
-                    color = "\x1b[37m";
-                }
-                log::Level::Debug => {
-                    color = "\x1b[34m";
-                }
-                log::Level::Trace => {
-                    color = "\x1b[35m";
-                }
-            }
-
-            let _ = println!("{}[{}] {}\x1b[0m", color, level, record.args());
+            let color = match record.level() {
+                log::Level::Error => "\x1b[31m",
+                log::Level::Warn => "\x1b[33m",
+                log::Level::Info => "\x1b[37m",
+                log::Level::Debug => "\x1b[34m",
+                log::Level::Trace => "\x1b[35m",
+            };
+
+            println!("{}[{}] {}\x1b[0m", color, level, record.args());
         }
     }
 
diff --git a/kernel/src/libs/msr.rs b/kernel/src/libs/msr.rs
@@ -1,4 +1,4 @@
-/// Model-Specific Registers (MSRs) definitions
+//! Model-Specific Registers (MSRs) definitions
 
 /// APIC Location and Status (R/W) See Table 35-2. See Section 10.4.4, Local APIC  Status and Location.
 pub const IA32_APIC_BASE: u32 = 0x1b;
diff --git a/kernel/src/memory/frame_allocator.rs b/kernel/src/memory/frame_allocator.rs
@@ -68,7 +68,7 @@ impl BitmapFrameAllocator {
                 let start = region.base as usize;
                 let end = (region.base + region.length) as usize;
                 let start_frame = start / PAGE_SIZE;
-                let end_frame = (end + PAGE_SIZE - 1) / PAGE_SIZE;
+                let end_frame = end.div_ceil(PAGE_SIZE);
 
                 self.alloc.insert(start_frame..end_frame);
                 self.total_frames += end_frame - start_frame;
diff --git a/kernel/src/process/task.rs b/kernel/src/process/task.rs
@@ -1,5 +1,5 @@
 extern crate alloc;
-use alloc::{boxed::Box, vec::Vec};
+use alloc::vec::Vec;
 use lazy_static::lazy_static;
 use spin::Mutex;
 
@@ -39,12 +39,12 @@ pub struct Task {
 
 impl Task {
     /// Create a new task object.
-    pub fn new(id: u16, priority: u8) -> Box<Self> {
-        Box::new(Self {
+    pub fn new(id: u16, priority: u8) -> Self {
+        Self {
             id,
             state: TaskState::Ready,
             priority,
-        })
+        }
     }
 
     /// Change the status of a task.
@@ -56,7 +56,7 @@ impl Task {
 /// The task manager which contains lots of tasks.
 pub struct TaskManager {
     /// The field which contains all tasks.
-    tasks: Vec<Box<Task>>,
+    tasks: Vec<Task>,
 
     /// The task ID which has been allocated.
     allocated_tid: Vec<u16>,
@@ -103,3 +103,9 @@ impl TaskManager {
         Ok(())
     }
 }
+
+impl Default for TaskManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/kernel/src/test.rs b/kernel/src/test.rs
@@ -26,6 +26,10 @@ static FAIL_COUNT: Mutex<usize> = Mutex::new(0);
 
 /// Save the current context into the jump buffer.
 /// Returns 0 when saving, and 1 when returning from long_jmp.
+///
+/// # Safety
+/// This function is unsafe because it manipulates CPU registers directly
+/// and relies on the caller to manage the jump buffer correctly.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn set_jmp() -> u64 {
     let mut jmp_buf = JumpBuffer::default();
@@ -169,5 +173,7 @@ pub extern "C" fn kernel_main() -> ! {
     crate::interrupts::pic::init(); // Initialize PI
     x86_64::instructions::interrupts::enable(); // Enable interrupts
     crate::test_main();
-    loop {}
+    loop {
+        x86_64::instructions::hlt();
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -27,12 +27,10 @@ fn main() {`
`27`	`27`	`let obj_dir = workspace_root.join("target/obj");`
`28`	`28`
`29`	`29`	`if let Ok(paths) = glob(&format!("{}/*.o", obj_dir.display())) {`
`30`		`- for path_result in paths {`
`31`		`- if let Ok(path) = path_result {`
`32`		`- // Get the absolute path`
`33`		`- let absolute_path = path.canonicalize().expect("Failed to canonicalize path");`
`34`		`- println!("cargo:rustc-link-arg={}", absolute_path.display());`
`35`		`- }`
	`30`	`+ for path in paths.flatten() {`
	`31`	`+ // Get the absolute path`
	`32`	`+ let absolute_path = path.canonicalize().expect("Failed to canonicalize path");`
	`33`	`+ println!("cargo:rustc-link-arg={}", absolute_path.display());`
`36`	`34`	`}`
`37`	`35`	`}`
`38`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -294,6 +294,7 @@ impl Clone for Device {`
`294`	`294`	`}`
`295`	`295`	`}`
`296`	`296`
	`297`	`+#[derive(Default)]`
`297`	`298`	`pub struct DeviceManager {`
`298`	`299`	`devices: Vec<Arc<Device>>,`
`299`	`300`	`next_minor_counters: BTreeMap<u16, u16>,`
`@@ -302,11 +303,7 @@ pub struct DeviceManager {`
`302`	`303`
`303`	`304`	`impl DeviceManager {`
`304`	`305`	`pub fn new() -> Self {`
`305`		`- Self {`
`306`		`- devices: Vec::new(),`
`307`		`- next_minor_counters: BTreeMap::new(),`
`308`		`- free_minors: BTreeMap::new(),`
`309`		`- }`
	`306`	`+ Self::default()`
`310`	`307`	`}`
`311`	`308`
`312`	`309`	`pub fn register_device(&mut self, mut device: Device) -> Result<Arc<Device>, DeviceError> {`
`@@ -396,10 +393,7 @@ impl DeviceManager {`
`396`	`393`	`}`
`397`	`394`
`398`	`395`	`fn reclaim_device_number(&mut self, major: u16, minor: u16) {`
`399`		`- self.free_minors`
`400`		`- .entry(major)`
`401`		`- .or_insert_with(Vec::new)`
`402`		`- .push(minor);`
	`396`	`+ self.free_minors.entry(major).or_default().push(minor);`
`403`	`397`	`}`
`404`	`398`
`405`	`399`	`pub fn get_device(&self, name: &str) -> Option<Arc<Device>> {`
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,8 @@ pub struct Keyboard {`
`20`	`20`	`name: String,`
`21`	`21`	`}`
`22`	`22`
`23`		`-impl Keyboard {`
`24`		`- pub fn new() -> Self {`
	`23`	`+impl Default for Keyboard {`
	`24`	`+ fn default() -> Self {`
`25`	`25`	`Self {`
`26`	`26`	`inner: Mutex::new(KeyboardInner {`
`27`	`27`	`pc_keyboard: PcKeyboard::new(`
`@@ -37,6 +37,12 @@ impl Keyboard {`
`37`	`37`	`name: String::from("keyboard"),`
`38`	`38`	`}`
`39`	`39`	`}`
	`40`	`+}`
	`41`	`+`
	`42`	`+impl Keyboard {`
	`43`	`+ pub fn new() -> Self {`
	`44`	`+ Self::default()`
	`45`	`+ }`
`40`	`46`
`41`	`47`	`pub fn set_enabled(&self, enabled: bool) {`
`42`	`48`	`x86_64::instructions::interrupts::without_interrupts(\|\| {`
`@@ -121,7 +127,7 @@ impl CharDevice for Keyboard {`
`121`	`127`	`}`
`122`	`128`	`}`
`123`	`129`
`124`		`- if read_count == 0 && buf.len() > 0 {`
	`130`	`+ if read_count == 0 && !buf.is_empty() {`
`125`	`131`	`Err(DeviceError::WouldBlock)`
`126`	`132`	`} else {`
`127`	`133`	`Ok(read_count)`
Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,7 @@ impl BlockCache {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`let block_size = self.device.block_size();`
`30`		`- let mut buf = Vec::with_capacity(block_size);`
`31`		`- buf.resize(block_size, 0);`
	`30`	`+ let mut buf = alloc::vec![0; block_size];`
`32`	`31`
`33`	`32`	`if self.device.read_blocks(block_id, 1, &mut buf).is_ok() {`
`34`	`33`	`let mut cache = self.cache.write();`