部分函数从返回值为Result<<>,i32>修改为Result<<>,SystemError> (#210)

* 将Result<<>,i32>替换为Result<<>,SystemError>
* bugfix: 显示双缓冲区初始化的时候，连续注册了两次Video Softirq的问题。

Co-authored-by: longjin <longjin@RinGoTek.cn>

DragonOS

@@ -1 +0,0 @@
-Subproject commit 45b8371173b070028457f7ee64be33f68b4f9ada

docs/kernel/locking/lockref.md

@@ -59,8 +59,8 @@ struct lockref
 ### 4.1. 引用计数自增
 
 - `pub fn inc(&mut self)`
-- `pub fn inc_not_zero(&mut self) -> Result<i32, i32>`
-- `pub fn inc_not_dead(&mut self) -> Result<i32, i32>`
+- `pub fn inc_not_zero(&mut self) -> Result<i32, SystemError>`
+- `pub fn inc_not_dead(&mut self) -> Result<i32, SystemError>`
 
 #### 4.1.1. inc
 
@@ -83,7 +83,7 @@ struct lockref
 |   返回值          |      说明    |
 |   :---        |   :---      |
 | Ok(self.count) | 成功，返回新的引用计数 |
-| Err(-1)       | 失败，返回-1 |
+| Err(SystemError::EPERM)       | 失败，返回EPERM |
 
 #### 4.1.3. inc_not_dead
 
@@ -96,19 +96,19 @@ struct lockref
 |   返回值          |      说明    |
 |   :---        |   :---      |
 | Ok(self.count) | 成功，返回新的引用计数 |
-| Err(-1)       | 失败，返回-1 |
+| Err(SystemError::EPERM)       | 失败，返回EPERM |
 
 ### 4.2. 引用计数自减
-- `pub fn dec(&mut self) -> Result<i32, i32>`
-- `pub fn dec_return(&mut self) -> Result<i32, i32>`
-- `pub fn dec_not_zero(&mut self) -> Result<i32, i32>`
-- `pub fn dec_or_lock_not_zero(&mut self) -> Result<i32, i32>`
+- `pub fn dec(&mut self) -> Result<i32, SystemError>`
+- `pub fn dec_return(&mut self) -> Result<i32, SystemError>`
+- `pub fn dec_not_zero(&mut self) -> Result<i32, SystemError>`
+- `pub fn dec_or_lock_not_zero(&mut self) -> Result<i32, SystemError>`
 
 #### 4.2.1. dec
 
 ##### 说明
 
-&emsp;&emsp;原子地将引用计数-1。如果已处于count≤0的状态，则返回Err(-1)
+&emsp;&emsp;原子地将引用计数-1。如果已处于count≤0的状态，则返回Err(SystemError::EPERM)
 
 &emsp;&emsp;本函数与`lockref_dec_return()`的区别在于，当在`cmpxchg()`中检测到`count<=0`或已加锁，本函数会再次尝试通过加锁来执行操作，而`lockref_dec_return()`会直接返回错误
 
@@ -117,11 +117,11 @@ struct lockref
 |   返回值          |      说明    |
 |   :---        |   :---      |
 | Ok(self.count) | 成功，返回新的引用计数 |
-| Err(-1)       | 失败，返回-1 |
+| Err(SystemError::EPERM)       | 失败，返回EPERM |
 
 #### 4.2.2. dec_return
 
-&emsp;&emsp;原子地将引用计数减1。如果处于已加锁或count≤0的状态，则返回-1
+&emsp;&emsp;原子地将引用计数减1。如果处于已加锁或count≤0的状态，则返回SystemError::EPERM
 
 &emsp;&emsp;本函数与`lockref_dec()`的区别在于，当在`cmpxchg()`中检测到`count<=0`或已加锁，本函数会直接返回错误，而`lockref_dec()`会再次尝试通过加锁来执行操作.
 
@@ -134,7 +134,7 @@ struct lockref
 |   返回值          |      说明    |
 |   :---        |   :---      |
 | Ok(self.count) | 成功，返回新的引用计数 |
-| Err(-1)       | 失败，返回-1 |
+| Err(SystemError::EPERM)       | 失败，返回EPERM |
 
 #### 4.2.3. dec_not_zero
 
@@ -149,7 +149,7 @@ struct lockref
 |   返回值          |      说明    |
 |   :---        |   :---      |
 | Ok(self.count) | 成功，返回新的引用计数 |
-| Err(-1)       | 失败，返回-1 |
+| Err(SystemError::EPERM)       | 失败，返回EPERM |
 
 
 #### 4.2.4. dec_or_lock_not_zero
@@ -158,14 +158,14 @@ struct lockref
 
 &emsp;&emsp;原子地将引用计数减1。若当前的引用计数≤1，则操作失败.
 
-&emsp;&emsp;该函数与`lockref_dec_not_zero()`的区别在于，当cmpxchg()时发现`old.count≤1`时，该函数会尝试加锁来进行操作，而`lockref_dec_not_zero()`在这种情况下，会直接返回`Err(-1)`.
+&emsp;&emsp;该函数与`lockref_dec_not_zero()`的区别在于，当cmpxchg()时发现`old.count≤1`时，该函数会尝试加锁来进行操作，而`lockref_dec_not_zero()`在这种情况下，会直接返回`Err(SystemError::EPERM)`.
 
 ##### 返回值
 
 |   返回值          |      说明    |
 |   :---        |   :---      |
 | Ok(self.count) | 成功，返回新的引用计数 |
-| Err(-1)       | 失败，返回-1 |
+| Err(SystemError::EPERM)       | 失败，返回EPERM |
 
 ### 4.3. 其他
 - `pub fn mark_dead(&mut self)`

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

@@ -5,8 +5,8 @@ use crate::filesystem::vfs::{
     Metadata, PollStatus,
 };
 use crate::io::device::BlockDevice;
+use crate::syscall::SystemError;
 use crate::{
-    include::bindings::bindings::{EINVAL, ENOTSUP},
     libs::spinlock::SpinLock,
     time::TimeSpec,
 };
@@ -78,15 +78,15 @@ impl IndexNode for LockedAhciInode {
         self
     }
 
-    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), i32> {
-        Err(-(ENOTSUP as i32))
+    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn close(&self, _data: &mut FilePrivateData) -> Result<(), i32> {
-        Err(-(ENOTSUP as i32))
+    fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn metadata(&self) -> Result<Metadata, i32> {
+    fn metadata(&self) -> Result<Metadata, SystemError> {
         return Ok(self.0.lock().metadata.clone());
     }
 
@@ -94,11 +94,11 @@ impl IndexNode for LockedAhciInode {
         return self.0.lock().fs.upgrade().unwrap();
     }
 
-    fn list(&self) -> Result<Vec<String>, i32> {
-        Err(-(ENOTSUP as i32))
+    fn list(&self) -> Result<Vec<String>, SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn set_metadata(&self, metadata: &Metadata) -> Result<(), i32> {
+    fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
         let mut inode = self.0.lock();
         inode.metadata.atime = metadata.atime;
         inode.metadata.mtime = metadata.mtime;
@@ -110,7 +110,7 @@ impl IndexNode for LockedAhciInode {
         return Ok(());
     }
 
-    fn poll(&self) -> Result<PollStatus, i32> {
+    fn poll(&self) -> Result<PollStatus, SystemError> {
         return Ok(PollStatus {
             flags: PollStatus::READ_MASK | PollStatus::WRITE_MASK,
         });
@@ -123,16 +123,16 @@ impl IndexNode for LockedAhciInode {
         len: usize,
         buf: &mut [u8],
         data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         if buf.len() < len {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if let FilePrivateData::Unused = data {
             return self.0.lock().disk.read_at(offset, len, buf);
         }
 
-        return Err(-(EINVAL as i32));
+        return Err(SystemError::EINVAL);
     }
 
     /// 写设备 - 应该调用设备的函数读写，而不是通过文件系统读写
@@ -142,15 +142,15 @@ impl IndexNode for LockedAhciInode {
         len: usize,
         buf: &[u8],
         data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         if buf.len() < len {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if let FilePrivateData::Unused = data {
             return self.0.lock().disk.write_at(offset, len, buf);
         }
 
-        return Err(-(EINVAL as i32));
+        return Err(SystemError::EINVAL);
     }
 }

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

@@ -1,11 +1,11 @@
 use super::{_port, hba::HbaCmdTable, virt_2_phys};
 use crate::driver::disk::ahci::HBA_PxIS_TFES;
 use crate::filesystem::mbr::MbrDiskPartionTable;
-use crate::include::bindings::bindings::{E2BIG, EIO};
 use crate::io::{device::BlockDevice, disk_info::Partition, SeekFrom};
 
 use crate::libs::{spinlock::SpinLock, vec_cursor::VecCursor};
 use crate::mm::phys_2_virt;
+use crate::syscall::SystemError;
 use crate::{
     driver::disk::ahci::hba::{
         FisRegH2D, FisType, HbaCmdHeader, ATA_CMD_READ_DMA_EXT, ATA_CMD_WRITE_DMA_EXT,
@@ -54,13 +54,13 @@ impl AhciDisk {
         lba_id_start: crate::io::device::BlockId, // 起始lba编号
         count: usize,                             // 读取lba的数量
         buf: &mut [u8],
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         compiler_fence(core::sync::atomic::Ordering::SeqCst);
         let check_length = ((count - 1) >> 4) + 1; // prdt length
         if count * 512 > buf.len() || check_length > u16::MAX as usize {
             kerror!("ahci read: e2big");
             // 不可能的操作
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         } else if count == 0 {
             return Ok(0);
         }
@@ -71,7 +71,7 @@ impl AhciDisk {
         let slot = port.find_cmdslot().unwrap_or(u32::MAX);
 
         if slot == u32::MAX {
-            return Err(-(EIO as i32));
+            return Err(SystemError::EIO);
         }
 
         #[allow(unused_unsafe)]
@@ -161,7 +161,7 @@ impl AhciDisk {
 
         if spin_count == SPIN_LIMIT {
             kerror!("Port is hung");
-            return Err(-(EIO as i32));
+            return Err(SystemError::EIO);
         }
 
         volatile_set_bit!(port.ci, 1 << slot, true); // Issue command
@@ -173,7 +173,7 @@ impl AhciDisk {
             }
             if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 {
                 kerror!("Read disk error");
-                return Err(-(EIO as i32));
+                return Err(SystemError::EIO);
             }
         }
 
@@ -187,12 +187,12 @@ impl AhciDisk {
         lba_id_start: crate::io::device::BlockId,
         count: usize,
         buf: &[u8],
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         compiler_fence(core::sync::atomic::Ordering::SeqCst);
         let check_length = ((count - 1) >> 4) + 1; // prdt length
         if count * 512 > buf.len() || check_length > u16::MAX as usize {
             // 不可能的操作
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         } else if count == 0 {
             return Ok(0);
         }
@@ -204,7 +204,7 @@ impl AhciDisk {
         let slot = port.find_cmdslot().unwrap_or(u32::MAX);
 
         if slot == u32::MAX {
-            return Err(-(EIO as i32));
+            return Err(SystemError::EIO);
         }
 
         compiler_fence(core::sync::atomic::Ordering::SeqCst);
@@ -295,7 +295,7 @@ impl AhciDisk {
             }
             if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 {
                 kerror!("Write disk error");
-                return Err(-(EIO as i32));
+                return Err(SystemError::EIO);
             }
         }
 
@@ -304,7 +304,7 @@ impl AhciDisk {
         return Ok(count * 512);
     }
 
-    fn sync(&self) -> Result<(), i32> {
+    fn sync(&self) -> Result<(), SystemError> {
         // 由于目前没有block cache, 因此sync返回成功即可
         return Ok(());
     }
@@ -316,7 +316,7 @@ impl LockedAhciDisk {
         flags: u16,
         ctrl_num: u8,
         port_num: u8,
-    ) -> Result<Arc<LockedAhciDisk>, i32> {
+    ) -> Result<Arc<LockedAhciDisk>, SystemError> {
         let mut part_s: Vec<Arc<Partition>> = Vec::new();
 
         // 构建磁盘结构体
@@ -351,7 +351,7 @@ impl LockedAhciDisk {
     }
 
     /// @brief: 从磁盘中读取 MBR 分区表结构体 TODO: Cursor
-    pub fn read_mbr_table(&self) -> Result<MbrDiskPartionTable, i32> {
+    pub fn read_mbr_table(&self) -> Result<MbrDiskPartionTable, SystemError> {
         let mut table: MbrDiskPartionTable = Default::default();
 
         // 数据缓冲区
@@ -404,7 +404,7 @@ impl BlockDevice for LockedAhciDisk {
         lba_id_start: crate::io::device::BlockId,
         count: usize,
         buf: &mut [u8],
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         // kdebug!(
         //     "ahci read at {lba_id_start}, count={count}, lock={:?}",
         //     self.0
@@ -418,11 +418,11 @@ impl BlockDevice for LockedAhciDisk {
         lba_id_start: crate::io::device::BlockId,
         count: usize,
         buf: &[u8],
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         self.0.lock().write_at(lba_id_start, count, buf)
     }
 
-    fn sync(&self) -> Result<(), i32> {
+    fn sync(&self) -> Result<(), SystemError> {
         return self.0.lock().sync();
     }
 

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

@@ -10,6 +10,7 @@ use crate::io::disk_info::BLK_GF_AHCI;
 use crate::kerror;
 use crate::libs::spinlock::{SpinLock, SpinLockGuard};
 use crate::mm::virt_2_phys;
+use crate::syscall::SystemError;
 use crate::{
     driver::disk::ahci::{
         ahcidisk::LockedAhciDisk,
@@ -44,11 +45,11 @@ pub extern "C" fn ahci_init() -> i32 {
     if r.is_ok() {
         return 0;
     } else {
-        return r.unwrap_err();
+        return r.unwrap_err().to_posix_errno();
     }
 }
 /// @brief: 初始化 ahci
-pub fn ahci_rust_init() -> Result<(), i32> {
+pub fn ahci_rust_init() -> Result<(), SystemError> {
     compiler_fence(core::sync::atomic::Ordering::SeqCst);
 
     let mut ahci_dev_counts: u32 = 0;
@@ -141,7 +142,7 @@ pub fn ahci_rust_init() -> Result<(), i32> {
                         );
                         if let Err(err) = ret {
                             kerror!(
-                                "Ahci_{} ctrl = {}, port = {} failed to register, error code = {}",
+                                "Ahci_{} ctrl = {}, port = {} failed to register, error code = {:?}",
                                 id,
                                 i,
                                 j,
@@ -166,7 +167,7 @@ pub fn disks() -> Vec<Arc<LockedAhciDisk>> {
 }
 
 /// @brief: 通过 name 获取 disk
-pub fn get_disks_by_name(name: String) -> Result<Arc<LockedAhciDisk>, i32> {
+pub fn get_disks_by_name(name: String) -> Result<Arc<LockedAhciDisk>, SystemError> {
     compiler_fence(core::sync::atomic::Ordering::SeqCst);
     let disks_list: SpinLockGuard<Vec<Arc<LockedAhciDisk>>> = LOCKED_DISKS_LIST.lock();
     for i in 0..disks_list.len() {
@@ -175,7 +176,8 @@ pub fn get_disks_by_name(name: String) -> Result<Arc<LockedAhciDisk>, i32> {
         }
     }
     compiler_fence(core::sync::atomic::Ordering::SeqCst);
-    return Err(-1);
+    return Err(SystemError::ENXIO);
+
 }
 
 /// @brief: 通过 ctrl_num 和 port_num 获取 port

kernel/src/driver/keyboard/ps2_keyboard.rs

@@ -7,9 +7,9 @@ use crate::{
         devfs::{devfs_register, DevFS, DeviceINode},
         vfs::{core::generate_inode_id, file::FileMode, FileType, IndexNode, Metadata, PollStatus},
     },
-    include::bindings::bindings::{vfs_file_operations_t, vfs_file_t, vfs_index_node_t, ENOTSUP},
+    include::bindings::bindings::{vfs_file_operations_t, vfs_file_t, vfs_index_node_t},
     libs::rwlock::RwLock,
-    time::TimeSpec,
+    time::TimeSpec, syscall::SystemError,
 };
 
 #[derive(Debug)]
@@ -83,7 +83,7 @@ impl IndexNode for LockedPS2KeyBoardInode {
         len: usize,
         buf: &mut [u8],
         _data: &mut crate::filesystem::vfs::FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         let guard = self.0.read();
         let func = guard.f_ops.read.unwrap();
         let r = unsafe {
@@ -103,15 +103,15 @@ impl IndexNode for LockedPS2KeyBoardInode {
         _len: usize,
         _buf: &[u8],
         _data: &mut crate::filesystem::vfs::FilePrivateData,
-    ) -> Result<usize, i32> {
-        return Err(-(ENOTSUP as i32));
+    ) -> Result<usize, SystemError> {
+        return Err(SystemError::ENOTSUP);
     }
 
     fn open(
         &self,
         _data: &mut crate::filesystem::vfs::FilePrivateData,
         _mode: &FileMode,
-    ) -> Result<(), i32> {
+    ) -> Result<(), SystemError> {
         let prev_ref_count = self.1.fetch_add(1, core::sync::atomic::Ordering::SeqCst);
         if prev_ref_count == 0 {
             // 第一次打开，需要初始化
@@ -122,7 +122,7 @@ impl IndexNode for LockedPS2KeyBoardInode {
         return Ok(());
     }
 
-    fn close(&self, _data: &mut crate::filesystem::vfs::FilePrivateData) -> Result<(), i32> {
+    fn close(&self, _data: &mut crate::filesystem::vfs::FilePrivateData) -> Result<(), SystemError> {
         let prev_ref_count = self.1.fetch_sub(1, core::sync::atomic::Ordering::SeqCst);
         if prev_ref_count == 1 {
             // 最后一次关闭，需要释放
@@ -133,17 +133,17 @@ impl IndexNode for LockedPS2KeyBoardInode {
         return Ok(());
     }
 
-    fn poll(&self) -> Result<PollStatus, i32> {
+    fn poll(&self) -> Result<PollStatus, SystemError> {
         return Ok(PollStatus {
             flags: PollStatus::READ_MASK,
         });
     }
 
-    fn metadata(&self) -> Result<Metadata, i32> {
+    fn metadata(&self) -> Result<Metadata, SystemError> {
         return Ok(self.0.read().metadata.clone());
     }
 
-    fn set_metadata(&self, metadata: &Metadata) -> Result<(), i32> {
+    fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
         let mut inode = self.0.write();
         inode.metadata.atime = metadata.atime;
         inode.metadata.mtime = metadata.mtime;
@@ -163,7 +163,7 @@ impl IndexNode for LockedPS2KeyBoardInode {
         self
     }
 
-    fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, i32> {
-        return Err(-(ENOTSUP as i32));
+    fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, SystemError> {
+        return Err(SystemError::ENOTSUP);
     }
 }

kernel/src/driver/timers/rtc/rtc.rs

@@ -1,6 +1,6 @@
 use crate::{
     arch::interrupt::{cli, sti},
-    include::bindings::bindings::{io_in8, io_out8},
+    include::bindings::bindings::{io_in8, io_out8}, syscall::SystemError,
 };
 
 pub struct RtcTime {
@@ -30,7 +30,7 @@ impl RtcTime {
     ///
     ///@param self time结构体
     ///@return int 成功则为0
-    pub fn get(&mut self) -> Result<i32, i32> {
+    pub fn get(&mut self) -> Result<i32, SystemError> {
         // 为防止中断请求打断该过程，需要先关中断
         cli();
         //0x0B

kernel/src/driver/tty/tty_device.rs

@@ -5,8 +5,7 @@ use crate::{
         devfs::{DeviceINode, DevFS},
         vfs::{file::FileMode, FilePrivateData, IndexNode},
     },
-    include::bindings::bindings::{ECONNABORTED, EIO, ENOTSUP, EPERM},
-    kerror, libs::rwlock::RwLock,
+    kerror, libs::rwlock::RwLock, syscall::SystemError,
 };
 
 use super::{TtyCore, TtyError, TtyFileFlag, TtyFilePrivateData};
@@ -31,11 +30,11 @@ impl TtyDevice {
     fn verify_file_private_data<'a>(
         &self,
         private_data: &'a mut FilePrivateData,
-    ) -> Result<&'a mut TtyFilePrivateData, i32> {
+    ) -> Result<&'a mut TtyFilePrivateData, SystemError> {
         if let FilePrivateData::Tty(t) = private_data {
             return Ok(t);
         }
-        return Err(-(EIO as i32));
+        return Err(SystemError::EIO);
     }
 }
 
@@ -46,7 +45,7 @@ impl DeviceINode for TtyDevice {
 }
 
 impl IndexNode for TtyDevice {
-    fn open(&self, data: &mut FilePrivateData, mode: &FileMode) -> Result<(), i32> {
+    fn open(&self, data: &mut FilePrivateData, mode: &FileMode) -> Result<(), SystemError> {
         let p = TtyFilePrivateData::default();
         *data = FilePrivateData::Tty(p);
         return Ok(());
@@ -58,7 +57,7 @@ impl IndexNode for TtyDevice {
         len: usize,
         buf: &mut [u8],
         data: &mut crate::filesystem::vfs::FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         let _data: &mut TtyFilePrivateData = match self.verify_file_private_data(data) {
             Ok(t) => t,
             Err(e) => {
@@ -79,7 +78,7 @@ impl IndexNode for TtyDevice {
             }
             x => {
                 kerror!("Error occurred when reading tty, msg={x:?}");
-                return Err(-(ECONNABORTED as i32));
+                return Err(SystemError::ECONNABORTED);
             }
         }
     }
@@ -90,7 +89,7 @@ impl IndexNode for TtyDevice {
         len: usize,
         buf: &[u8],
         data: &mut crate::filesystem::vfs::FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         let data: &mut TtyFilePrivateData = match self.verify_file_private_data(data) {
             Ok(t) => t,
             Err(e) => {
@@ -105,7 +104,7 @@ impl IndexNode for TtyDevice {
         } else if data.flags.contains(TtyFileFlag::STDERR) {
             self.core.stderr(buf, true)
         } else {
-            return Err(-(EPERM as i32));
+            return Err(SystemError::EPERM);
         };
 
         if r.is_ok() {
@@ -114,11 +113,11 @@ impl IndexNode for TtyDevice {
 
         let r: TtyError = r.unwrap_err();
         kerror!("Error occurred when writing tty deivce. Error msg={r:?}");
-        return Err(-(EIO as i32));
+        return Err(SystemError::EIO);
     }
 
-    fn poll(&self) -> Result<crate::filesystem::vfs::PollStatus, i32> {
-        return Err(-(ENOTSUP as i32));
+    fn poll(&self) -> Result<crate::filesystem::vfs::PollStatus, SystemError> {
+        return Err(SystemError::ENOTSUP);
     }
 
     fn fs(&self) -> Arc<dyn crate::filesystem::vfs::FileSystem> {
@@ -129,7 +128,7 @@ impl IndexNode for TtyDevice {
         self
     }
 
-    fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, i32> {
-        return Err(-(ENOTSUP as i32));
+    fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, SystemError> {
+        return Err(SystemError::ENOTSUP);
     }
 }

kernel/src/driver/video/video.c

@@ -105,6 +105,7 @@ int video_reinitialize(bool level) // 这个函数会在main.c调用, 保证 vid
         init_frame_buffer();
     else
     {
+        unregister_softirq(VIDEO_REFRESH_SIRQ);
         // 计算开始时间
         video_refresh_expire_jiffies = cal_next_n_ms_jiffies(10 * REFRESH_INTERVAL);
 

kernel/src/driver/virtio/virtio.rs

@@ -81,7 +81,7 @@ fn virtio_device(transport: impl Transport) {
 ///@brief virtio-net 驱动的初始化与测试
 fn virtio_net<T: Transport>(transport: T) {
     let mut driver_net = match VirtIONet::<HalImpl, T>::new(transport) {
-        Ok(mut net) => {
+        Ok(net) => {
             kdebug!("Virtio-net driver init successfully.");
             net
         }

kernel/src/exception/softirq.rs

@@ -4,9 +4,10 @@ use alloc::boxed::Box;
 
 use crate::{
     arch::interrupt::{cli, sti},
-    include::bindings::bindings::{verify_area, EBUSY, EEXIST, EPERM},
+    include::bindings::bindings::verify_area,
     kBUG,
     libs::spinlock::RawSpinlock,
+    syscall::SystemError, kdebug,
 };
 
 const MAX_SOFTIRQ_NUM: u64 = 64;
@@ -84,7 +85,7 @@ pub extern "C" fn register_softirq(
     data: *mut c_void,
 ) {
     let softirq_handler = __get_softirq_handler_mut();
-    softirq_handler.register_softirq(irq_num, action, data);
+    softirq_handler.register_softirq(irq_num, action, data).expect(&format!("Softirq: Failed to register {}", irq_num));
 }
 
 /// @brief 卸载软中断
@@ -93,7 +94,7 @@ pub extern "C" fn register_softirq(
 #[allow(dead_code)]
 pub extern "C" fn unregister_softirq(irq_num: u32) {
     let softirq_handler = __get_softirq_handler_mut();
-    softirq_handler.unregister_softirq(irq_num);
+    softirq_handler.unregister_softirq(irq_num).expect(&format!("Softirq: Failed to unregister {}", irq_num));
 }
 
 /// 设置软中断的运行状态（只应在do_softirq中调用此宏）
@@ -190,24 +191,24 @@ impl Softirq {
         irq_num: u32,
         action: Option<unsafe extern "C" fn(data: *mut ::core::ffi::c_void)>,
         data: *mut c_void,
-    ) -> i32 {
+    ) -> Result<(), SystemError> {
         if self.table[irq_num as usize].action.is_some() {
-            return -(EEXIST as i32);
+            return Err(SystemError::EEXIST);
         }
 
         if unsafe { verify_area(action.unwrap() as u64, 1) } {
-            return -(EPERM as i32);
+            return Err(SystemError::EPERM);
         }
         self.modify_lock.lock();
         self.table[irq_num as usize].action = action;
         self.table[irq_num as usize].data = data;
         self.modify_lock.unlock();
-        return 0;
+        return Ok(());
     }
 
     /// @brief 解注册软中断向量
     /// @param irq_num 中断向量号码
-    pub fn unregister_softirq(&mut self, irq_num: u32) -> i32 {
+    pub fn unregister_softirq(&mut self, irq_num: u32) -> Result<(), SystemError> {
         for _trial_time in 0..MAX_LOCK_TRIAL_TIME {
             if self.is_running(irq_num) {
                 continue; //running标志位为1
@@ -222,14 +223,15 @@ impl Softirq {
         }
         // 存在尝试加锁规定次数后仍加锁失败的情况,报告错误并退出
         if !self.modify_lock.is_locked() {
-            return -(EBUSY as i32);
+            return Err(SystemError::EBUSY);
         }
+        kdebug!("SOftirq: unregister {irq_num}");
         self.clear_softirq_running(irq_num);
         self.clear_softirq_pending(irq_num);
         self.table[irq_num as usize].action = None;
         self.table[irq_num as usize].data = null_mut();
         self.modify_lock.unlock();
-        return 0;
+        return Ok(());
     }
 
     /// @brief 遍历执行软中断

kernel/src/filesystem/devfs/mod.rs

@@ -8,10 +8,9 @@ use super::vfs::{
     FileSystem, FileType, FsInfo, IndexNode, Metadata, PollStatus,
 };
 use crate::{
-    include::bindings::bindings::{EEXIST, EISDIR, ENOENT, ENOTDIR, ENOTSUP},
     kerror,
     libs::spinlock::{SpinLock, SpinLockGuard},
-    time::TimeSpec,
+    time::TimeSpec, syscall::SystemError,
 };
 use alloc::{
     collections::BTreeMap,
@@ -95,7 +94,7 @@ impl DevFS {
     ///
     /// @param name 设备名称
     /// @param device 设备节点的结构体
-    pub fn register_device<T: DeviceINode>(&self, name: &str, device: Arc<T>) -> Result<(), i32> {
+    pub fn register_device<T: DeviceINode>(&self, name: &str, device: Arc<T>) -> Result<(), SystemError> {
         let dev_root_inode: Arc<LockedDevFSInode> = self.root_inode.clone();
         match device.metadata().unwrap().file_type {
             // 字节设备挂载在 /dev/char
@@ -128,7 +127,7 @@ impl DevFS {
                 device.set_fs(dev_block_inode.0.lock().fs.clone());
             }
             _ => {
-                return Err(-(ENOTSUP as i32));
+                return Err(SystemError::ENOTSUP);
             }
         }
 
@@ -136,13 +135,13 @@ impl DevFS {
     }
 
     /// @brief 卸载设备
-    pub fn unregister_device<T: DeviceINode>(&self, name: &str, device: Arc<T>) -> Result<(), i32> {
+    pub fn unregister_device<T: DeviceINode>(&self, name: &str, device: Arc<T>) -> Result<(), SystemError> {
         let dev_root_inode: Arc<LockedDevFSInode> = self.root_inode.clone();
         match device.metadata().unwrap().file_type {
             // 字节设备挂载在 /dev/char
             FileType::CharDevice => {
                 if let Err(_) = dev_root_inode.find("char") {
-                    return Err(-(ENOENT as i32));
+                    return Err(SystemError::ENOENT);
                 }
 
                 let any_char_inode = dev_root_inode.find("char")?;
@@ -155,7 +154,7 @@ impl DevFS {
             }
             FileType::BlockDevice => {
                 if let Err(_) = dev_root_inode.find("block") {
-                    return Err(-(ENOENT as i32));
+                    return Err(SystemError::ENOENT);
                 }
 
                 let any_block_inode = dev_root_inode.find("block")?;
@@ -167,7 +166,7 @@ impl DevFS {
                 dev_block_inode.remove(name)?;
             }
             _ => {
-                return Err(-(ENOTSUP as i32));
+                return Err(SystemError::ENOTSUP);
             }
         }
 
@@ -231,11 +230,11 @@ impl DevFSInode {
 }
 
 impl LockedDevFSInode {
-    pub fn add_dir(&self, name: &str) -> Result<(), i32> {
+    pub fn add_dir(&self, name: &str) -> Result<(), SystemError> {
         let guard: SpinLockGuard<DevFSInode> = self.0.lock();
 
         if guard.children.contains_key(name) {
-            return Err(-(EEXIST as i32));
+            return Err(SystemError::EEXIST);
         }
 
         match self.do_create_with_data(guard, name, FileType::Dir, 0o755 as u32, 0) {
@@ -248,24 +247,24 @@ impl LockedDevFSInode {
         return Ok(());
     }
 
-    pub fn add_dev(&self, name: &str, dev: Arc<dyn IndexNode>) -> Result<(), i32> {
+    pub fn add_dev(&self, name: &str, dev: Arc<dyn IndexNode>) -> Result<(), SystemError> {
         let mut this = self.0.lock();
 
         if this.children.contains_key(name) {
-            return Err(-(EEXIST as i32));
+            return Err(SystemError::EEXIST);
         }
 
         this.children.insert(name.to_string(), dev);
         return Ok(());
     }
 
-    pub fn remove(&self, name: &str) -> Result<(), i32> {
+    pub fn remove(&self, name: &str) -> Result<(), SystemError> {
         let x = self
             .0
             .lock()
             .children
             .remove(name)
-            .ok_or(-(ENOENT as i32))?;
+            .ok_or(SystemError::ENOENT)?;
 
         drop(x);
         return Ok(());
@@ -278,14 +277,14 @@ impl LockedDevFSInode {
         _file_type: FileType,
         _mode: u32,
         _data: usize,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         if guard.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         // 如果有重名的，则返回
         if guard.children.contains_key(_name) {
-            return Err(-(EEXIST as i32));
+            return Err(SystemError::EEXIST);
         }
 
         // 创建inode
@@ -326,11 +325,11 @@ impl IndexNode for LockedDevFSInode {
         self
     }
 
-    fn open(&self, _data: &mut super::vfs::FilePrivateData, _mode: &FileMode) -> Result<(), i32> {
+    fn open(&self, _data: &mut super::vfs::FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
         return Ok(());
     }
 
-    fn close(&self, _data: &mut super::vfs::FilePrivateData) -> Result<(), i32> {
+    fn close(&self, _data: &mut super::vfs::FilePrivateData) -> Result<(), SystemError> {
         return Ok(());
     }
 
@@ -340,30 +339,30 @@ impl IndexNode for LockedDevFSInode {
         file_type: FileType,
         mode: u32,
         data: usize,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         // 获取当前inode
         let guard: SpinLockGuard<DevFSInode> = self.0.lock();
         // 如果当前inode不是文件夹，则返回
         return self.do_create_with_data(guard, name, file_type, mode, data);
     }
 
-    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, i32> {
+    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
         let inode = self.0.lock();
 
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         match name {
             "" | "." => {
-                return Ok(inode.self_ref.upgrade().ok_or(-(ENOENT as i32))?);
+                return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?);
             }
             ".." => {
-                return Ok(inode.parent.upgrade().ok_or(-(ENOENT as i32))?);
+                return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?);
             }
             name => {
                 // 在子目录项中查找
-                return Ok(inode.children.get(name).ok_or(-(ENOENT as i32))?.clone());
+                return Ok(inode.children.get(name).ok_or(SystemError::ENOENT)?.clone());
             }
         }
     }
@@ -372,10 +371,10 @@ impl IndexNode for LockedDevFSInode {
         return self.0.lock().fs.upgrade().unwrap();
     }
 
-    fn get_entry_name(&self, ino: super::vfs::InodeId) -> Result<String, i32> {
+    fn get_entry_name(&self, ino: super::vfs::InodeId) -> Result<String, SystemError> {
         let inode: SpinLockGuard<DevFSInode> = self.0.lock();
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         match ino {
@@ -396,7 +395,7 @@ impl IndexNode for LockedDevFSInode {
                     .collect();
 
                 match key.len() {
-                    0=>{return Err(-(ENOENT as i32));}
+                    0=>{return Err(SystemError::ENOENT);}
                     1=>{return Ok(key.remove(0));}
                     _ => panic!("Devfs get_entry_name: key.len()={key_len}>1, current inode_id={inode_id}, to find={to_find}", key_len=key.len(), inode_id = inode.metadata.inode_id, to_find=ino)
                 }
@@ -404,14 +403,14 @@ impl IndexNode for LockedDevFSInode {
         }
     }
 
-    fn ioctl(&self, _cmd: u32, _data: usize) -> Result<usize, i32> {
-        Err(-(ENOTSUP as i32))
+    fn ioctl(&self, _cmd: u32, _data: usize) -> Result<usize, SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn list(&self) -> Result<Vec<String>, i32> {
+    fn list(&self) -> Result<Vec<String>, SystemError> {
         let info = self.metadata()?;
         if info.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         let mut keys: Vec<String> = Vec::new();
@@ -422,11 +421,11 @@ impl IndexNode for LockedDevFSInode {
         return Ok(keys);
     }
 
-    fn metadata(&self) -> Result<Metadata, i32> {
+    fn metadata(&self) -> Result<Metadata, SystemError> {
         return Ok(self.0.lock().metadata.clone());
     }
 
-    fn set_metadata(&self, metadata: &Metadata) -> Result<(), i32> {
+    fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
         let mut inode = self.0.lock();
         inode.metadata.atime = metadata.atime;
         inode.metadata.mtime = metadata.mtime;
@@ -438,13 +437,13 @@ impl IndexNode for LockedDevFSInode {
         return Ok(());
     }
 
-    fn poll(&self) -> Result<super::vfs::PollStatus, i32> {
+    fn poll(&self) -> Result<super::vfs::PollStatus, SystemError> {
         // 加锁
         let inode: SpinLockGuard<DevFSInode> = self.0.lock();
 
         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
         if inode.metadata.file_type == FileType::Dir {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         return Ok(PollStatus {
@@ -459,8 +458,8 @@ impl IndexNode for LockedDevFSInode {
         _len: usize,
         _buf: &mut [u8],
         _data: &mut super::vfs::file::FilePrivateData,
-    ) -> Result<usize, i32> {
-        Err(-(ENOTSUP as i32))
+    ) -> Result<usize, SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
     /// 写设备 - 应该调用设备的函数读写，而不是通过文件系统读写
@@ -470,8 +469,8 @@ impl IndexNode for LockedDevFSInode {
         _len: usize,
         _buf: &[u8],
         _data: &mut super::vfs::file::FilePrivateData,
-    ) -> Result<usize, i32> {
-        Err(-(ENOTSUP as i32))
+    ) -> Result<usize, SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 }
 
@@ -484,10 +483,10 @@ pub trait DeviceINode: IndexNode {
 /// @brief 获取devfs实例的强类型不可变引用
 macro_rules! devfs_exact_ref {
     () => {{
-        let devfs_inode: Result<Arc<dyn IndexNode>, i32> = ROOT_INODE().find("dev");
+        let devfs_inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().find("dev");
         if let Err(e) = devfs_inode {
-            kerror!("failed to get DevFS ref. errcode = {e}");
-            return Err(-(ENOENT as i32));
+            kerror!("failed to get DevFS ref. errcode = {:?}",e);
+            return Err(SystemError::ENOENT);
         }
 
         let binding = devfs_inode.unwrap();
@@ -503,12 +502,12 @@ macro_rules! devfs_exact_ref {
     .unwrap()};
 }
 /// @brief devfs的设备注册函数
-pub fn devfs_register<T: DeviceINode>(name: &str, device: Arc<T>) -> Result<(), i32> {
+pub fn devfs_register<T: DeviceINode>(name: &str, device: Arc<T>) -> Result<(), SystemError> {
     return devfs_exact_ref!().register_device(name, device);
 }
 
 /// @brief devfs的设备卸载函数
 #[allow(dead_code)]
-pub fn devfs_unregister<T: DeviceINode>(name: &str, device: Arc<T>) -> Result<(), i32> {
+pub fn devfs_unregister<T: DeviceINode>(name: &str, device: Arc<T>) -> Result<(), SystemError> {
     return devfs_exact_ref!().unregister_device(name, device);
 }

kernel/src/filesystem/devfs/null_dev.rs

@@ -4,7 +4,7 @@ use crate::filesystem::vfs::{
     core::generate_inode_id, FilePrivateData, FileSystem, FileType, IndexNode, Metadata, PollStatus,
 };
 use crate::{
-    include::bindings::bindings::{EINVAL, ENOTSUP},
+    syscall::SystemError,
     libs::spinlock::SpinLock,
     time::TimeSpec,
 };
@@ -73,15 +73,15 @@ impl IndexNode for LockedNullInode {
         self
     }
 
-    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), i32> {
-        Err(-(ENOTSUP as i32))
+    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn close(&self, _data: &mut FilePrivateData) -> Result<(), i32> {
-        Err(-(ENOTSUP as i32))
+    fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn metadata(&self) -> Result<Metadata, i32> {
+    fn metadata(&self) -> Result<Metadata, SystemError> {
         return Ok(self.0.lock().metadata.clone());
     }
 
@@ -89,11 +89,11 @@ impl IndexNode for LockedNullInode {
         return self.0.lock().fs.upgrade().unwrap();
     }
 
-    fn list(&self) -> Result<Vec<String>, i32> {
-        Err(-(ENOTSUP as i32))
+    fn list(&self) -> Result<Vec<String>, SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn set_metadata(&self, metadata: &Metadata) -> Result<(), i32> {
+    fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
         let mut inode = self.0.lock();
         inode.metadata.atime = metadata.atime;
         inode.metadata.mtime = metadata.mtime;
@@ -105,7 +105,7 @@ impl IndexNode for LockedNullInode {
         return Ok(());
     }
 
-    fn poll(&self) -> Result<PollStatus, i32> {
+    fn poll(&self) -> Result<PollStatus, SystemError> {
         return Ok(PollStatus {
             flags: PollStatus::READ_MASK | PollStatus::WRITE_MASK,
         });
@@ -118,9 +118,9 @@ impl IndexNode for LockedNullInode {
         len: usize,
         buf: &mut [u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         if buf.len() < len {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         for i in 0..len {
@@ -137,9 +137,9 @@ impl IndexNode for LockedNullInode {
         len: usize,
         buf: &[u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         if buf.len() < len {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         Ok(len)

kernel/src/filesystem/devfs/zero_dev.rs

@@ -4,7 +4,7 @@ use crate::filesystem::vfs::{
     core::generate_inode_id, FilePrivateData, FileSystem, FileType, IndexNode, Metadata, PollStatus,
 };
 use crate::{
-    include::bindings::bindings::{EINVAL, ENOTSUP},
+    syscall::SystemError,
     libs::spinlock::SpinLock,
     time::TimeSpec,
 };
@@ -73,15 +73,15 @@ impl IndexNode for LockedZeroInode {
         self
     }
 
-    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), i32> {
-        Err(-(ENOTSUP as i32))
+    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn close(&self, _data: &mut FilePrivateData) -> Result<(), i32> {
-        Err(-(ENOTSUP as i32))
+    fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn metadata(&self) -> Result<Metadata, i32> {
+    fn metadata(&self) -> Result<Metadata, SystemError> {
         return Ok(self.0.lock().metadata.clone());
     }
 
@@ -89,11 +89,11 @@ impl IndexNode for LockedZeroInode {
         return self.0.lock().fs.upgrade().unwrap();
     }
 
-    fn list(&self) -> Result<Vec<String>, i32> {
-        Err(-(ENOTSUP as i32))
+    fn list(&self) -> Result<Vec<String>, SystemError> {
+        Err(SystemError::ENOTSUP)
     }
 
-    fn set_metadata(&self, metadata: &Metadata) -> Result<(), i32> {
+    fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
         let mut inode = self.0.lock();
         inode.metadata.atime = metadata.atime;
         inode.metadata.mtime = metadata.mtime;
@@ -105,7 +105,7 @@ impl IndexNode for LockedZeroInode {
         return Ok(());
     }
 
-    fn poll(&self) -> Result<PollStatus, i32> {
+    fn poll(&self) -> Result<PollStatus, SystemError> {
         return Ok(PollStatus {
             flags: PollStatus::READ_MASK | PollStatus::WRITE_MASK,
         });
@@ -118,9 +118,9 @@ impl IndexNode for LockedZeroInode {
         len: usize,
         buf: &mut [u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         if buf.len() < len {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         for i in 0..len {
@@ -137,9 +137,9 @@ impl IndexNode for LockedZeroInode {
         len: usize,
         buf: &[u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         if buf.len() < len {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         Ok(len)

kernel/src/filesystem/fat/bpb.rs

@@ -2,10 +2,9 @@
 use alloc::{sync::Arc, vec::Vec};
 
 use crate::{
-    include::bindings::bindings::EINVAL,
     io::{device::LBA_SIZE, disk_info::Partition, SeekFrom},
     kerror,
-    libs::vec_cursor::VecCursor,
+    libs::vec_cursor::VecCursor, syscall::SystemError,
 };
 
 use super::fs::{Cluster, FATFileSystem};
@@ -181,37 +180,37 @@ impl FATType {
 
 impl BiosParameterBlockLegacy {
     /// @brief 验证FAT12/16 BPB的信息是否合法
-    fn validate(&self, _bpb: &BiosParameterBlock) -> Result<(), i32> {
+    fn validate(&self, _bpb: &BiosParameterBlock) -> Result<(), SystemError> {
         return Ok(());
     }
 }
 
 impl BiosParameterBlockFAT32 {
     /// @brief 验证BPB32的信息是否合法
-    fn validate(&self, bpb: &BiosParameterBlock) -> Result<(), i32> {
+    fn validate(&self, bpb: &BiosParameterBlock) -> Result<(), SystemError> {
         if bpb.fat_size_16 != 0 {
             kerror!("Invalid fat_size_16 value in BPB (should be zero for FAT32)");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if bpb.root_entries_cnt != 0 {
             kerror!("Invalid root_entries value in BPB (should be zero for FAT32)");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if bpb.total_sectors_16 != 0 {
             kerror!("Invalid total_sectors_16 value in BPB (should be zero for FAT32)");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if self.fat_size_32 == 0 {
             kerror!("Invalid fat_size_32 value in BPB (should be non-zero for FAT32)");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if self.fs_version != 0 {
             kerror!("Unknown FAT FS version");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         return Ok(());
@@ -219,7 +218,7 @@ impl BiosParameterBlockFAT32 {
 }
 
 impl BiosParameterBlock {
-    pub fn new(partition: Arc<Partition>) -> Result<BiosParameterBlock, i32> {
+    pub fn new(partition: Arc<Partition>) -> Result<BiosParameterBlock, SystemError> {
         let mut v = Vec::with_capacity(LBA_SIZE);
         v.resize(LBA_SIZE, 0);
 
@@ -302,7 +301,7 @@ impl BiosParameterBlock {
             FATType::FAT32(bpb32)
         } else {
             // 都不符合条件，报错
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         };
 
         // 验证BPB的信息是否合法
@@ -312,32 +311,32 @@ impl BiosParameterBlock {
     }
 
     /// @brief 验证BPB的信息是否合法
-    pub fn validate(&self) -> Result<(), i32> {
+    pub fn validate(&self) -> Result<(), SystemError> {
         // 校验每扇区字节数是否合法
         if self.bytes_per_sector.count_ones() != 1 {
             kerror!("Invalid bytes per sector(not a power of 2)");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         } else if self.bytes_per_sector < 512 {
             kerror!("Invalid bytes per sector (value < 512)");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         } else if self.bytes_per_sector > 4096 {
             kerror!("Invalid bytes per sector (value > 4096)");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if self.rsvd_sec_cnt < 1 {
             kerror!("Invalid rsvd_sec_cnt value in BPB");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if self.num_fats == 0 {
             kerror!("Invalid fats value in BPB");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if (self.total_sectors_16 == 0) && (self.total_sectors_32 == 0) {
             kerror!("Invalid BPB (total_sectors_16 or total_sectors_32 should be non-zero)");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         let fat_size = match self.fat_type {
@@ -368,7 +367,7 @@ impl BiosParameterBlock {
         // 总扇区数应当大于第一个数据扇区的扇区号
         if total_sectors <= first_data_sector {
             kerror!("Total sectors lesser than first data sector");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         return Ok(());

kernel/src/filesystem/fat/entry.rs

@@ -8,13 +8,10 @@ use alloc::{
 };
 
 use crate::{
-    include::bindings::bindings::{
-        EEXIST, EILSEQ, EINVAL, EISDIR, ENAMETOOLONG, ENOENT, ENOSPC, ENOTDIR, ENOTEMPTY, EPERM,
-        EROFS,
-    },
     io::{device::LBA_SIZE, SeekFrom},
     kwarn,
     libs::vec_cursor::VecCursor,
+    syscall::SystemError,
 };
 
 use super::{
@@ -81,8 +78,8 @@ impl FATFile {
     /// @param offset 起始位置在文件中的偏移量
     ///
     /// @return Ok(usize) 成功读取到的字节数
-    /// @return Err(i32) 读取时出现错误，返回错误码
-    pub fn read(&self, fs: &Arc<FATFileSystem>, buf: &mut [u8], offset: u64) -> Result<usize, i32> {
+    /// @return Err(SystemError) 读取时出现错误，返回错误码
+    pub fn read(&self, fs: &Arc<FATFileSystem>, buf: &mut [u8], offset: u64) -> Result<usize, SystemError> {
         if offset >= self.size() {
             return Ok(0);
         }
@@ -153,13 +150,13 @@ impl FATFile {
     /// @param offset 起始位置在文件中的偏移量
     ///
     /// @return Ok(usize) 成功写入的字节数
-    /// @return Err(i32) 写入时出现错误，返回错误码
+    /// @return Err(SystemError) 写入时出现错误，返回错误码
     pub fn write(
         &mut self,
         fs: &Arc<FATFileSystem>,
         buf: &[u8],
         offset: u64,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         self.ensure_len(fs, offset, buf.len() as u64)?;
 
         // 要写入的第一个簇的簇号
@@ -225,8 +222,8 @@ impl FATFile {
     /// @param len 期待的空闲空间长度
     ///
     /// @return Ok(()) 经过操作后，offset后面具有长度至少为len的空闲空间
-    /// @return Err(i32) 处理过程中出现了异常。
-    fn ensure_len(&mut self, fs: &Arc<FATFileSystem>, offset: u64, len: u64) -> Result<(), i32> {
+    /// @return Err(SystemError) 处理过程中出现了异常。
+    fn ensure_len(&mut self, fs: &Arc<FATFileSystem>, offset: u64, len: u64) -> Result<(), SystemError> {
         // 文件内本身就还有空余的空间
         if offset + len <= self.size() {
             return Ok(());
@@ -257,7 +254,7 @@ impl FATFile {
                 c
             } else {
                 kwarn!("FAT: last cluster not found, File = {self:?}");
-                return Err(-(EINVAL as i32));
+                return Err(SystemError::EINVAL);
             };
             // 申请簇
             let mut current_cluster: Cluster = last_cluster;
@@ -311,7 +308,7 @@ impl FATFile {
         fs: &Arc<FATFileSystem>,
         range_start: u64,
         range_end: u64,
-    ) -> Result<(), i32> {
+    ) -> Result<(), SystemError> {
         if range_end <= range_start {
             return Ok(());
         }
@@ -330,8 +327,8 @@ impl FATFile {
     /// @param new_size 新的文件大小，如果它大于当前文件大小，则不做操作。
     ///
     /// @return Ok(()) 操作成功
-    /// @return Err(i32) 在操作时出现错误
-    pub fn truncate(&mut self, fs: &Arc<FATFileSystem>, new_size: u64) -> Result<(), i32> {
+    /// @return Err(SystemError) 在操作时出现错误
+    pub fn truncate(&mut self, fs: &Arc<FATFileSystem>, new_size: u64) -> Result<(), SystemError> {
         if new_size >= self.size() {
             return Ok(());
         }
@@ -400,7 +397,7 @@ impl FATDir {
         &self,
         num_free: u64,
         fs: Arc<FATFileSystem>,
-    ) -> Result<Option<(Cluster, u64)>, i32> {
+    ) -> Result<Option<(Cluster, u64)>, SystemError> {
         let mut free = 0;
         let mut current_cluster: Cluster = self.first_cluster;
         let mut offset = self.root_offset.unwrap_or(0);
@@ -488,14 +485,14 @@ impl FATDir {
     /// @param fs 当前目录所属的文件系统
     ///
     /// @return Ok(FATDirEntry) 找到期待的目录项
-    /// @return Err(i32) 错误码
+    /// @return Err(SystemError) 错误码
     pub fn find_entry(
         &self,
         name: &str,
         expect_dir: Option<bool>,
         mut short_name_gen: Option<&mut ShortNameGenerator>,
         fs: Arc<FATFileSystem>,
-    ) -> Result<FATDirEntry, i32> {
+    ) -> Result<FATDirEntry, SystemError> {
         LongDirEntry::validate_long_name(name)?;
         // 迭代当前目录下的文件/文件夹
         for e in self.to_iter(fs) {
@@ -503,10 +500,10 @@ impl FATDir {
                 if expect_dir.is_some() && Some(e.is_dir()) != expect_dir {
                     if e.is_dir() {
                         // 期望得到文件，但是是文件夹
-                        return Err(-(EISDIR as i32));
+                        return Err(SystemError::EISDIR);
                     } else {
                         // 期望得到文件夹，但是是文件
-                        return Err(-(ENOTDIR as i32));
+                        return Err(SystemError::ENOTDIR);
                     }
                 }
                 // 找到期望的目录项
@@ -518,17 +515,17 @@ impl FATDir {
             }
         }
         // 找不到文件/文件夹
-        return Err(-(ENOENT as i32));
+        return Err(SystemError::ENOENT);
     }
 
     /// @brief 在当前目录下打开文件，获取FATFile结构体
-    pub fn open_file(&self, name: &str, fs: Arc<FATFileSystem>) -> Result<FATFile, i32> {
+    pub fn open_file(&self, name: &str, fs: Arc<FATFileSystem>) -> Result<FATFile, SystemError> {
         let f: FATFile = self.find_entry(name, Some(false), None, fs)?.to_file()?;
         return Ok(f);
     }
 
     /// @brief 在当前目录下打开文件夹，获取FATDir结构体
-    pub fn open_dir(&self, name: &str, fs: Arc<FATFileSystem>) -> Result<FATDir, i32> {
+    pub fn open_dir(&self, name: &str, fs: Arc<FATFileSystem>) -> Result<FATDir, SystemError> {
         let d: FATDir = self.find_entry(name, Some(true), None, fs)?.to_dir()?;
         return Ok(d);
     }
@@ -537,17 +534,18 @@ impl FATDir {
     ///
     /// @param name 文件名
     /// @param fs 当前文件夹所属的文件系统
-    pub fn create_file(&self, name: &str, fs: &Arc<FATFileSystem>) -> Result<FATFile, i32> {
-        let r: Result<FATDirEntryOrShortName, i32> =
+    pub fn create_file(&self, name: &str, fs: &Arc<FATFileSystem>) -> Result<FATFile, SystemError> {
+        let r: Result<FATDirEntryOrShortName, SystemError> =
             self.check_existence(name, Some(false), fs.clone());
         // 检查错误码，如果能够表明目录项已经存在，则返回-EEXIST
         if r.is_err() {
             let err_val = r.unwrap_err();
-            if err_val == (-(EISDIR as i32)) || err_val == (-(ENOTDIR as i32)) {
-                return Err(-(EEXIST as i32));
+            if err_val == (SystemError::EISDIR) || err_val == (SystemError::ENOTDIR) {
+                return Err(SystemError::EEXIST);
             } else {
                 return Err(err_val);
             }
+            
         }
 
         match r.unwrap() {
@@ -555,7 +553,7 @@ impl FATDir {
                 // 确认名称是一个可行的长文件名
                 LongDirEntry::validate_long_name(name)?;
                 // 创建目录项
-                let x: Result<FATFile, i32> = self
+                let x: Result<FATFile, SystemError> = self
                     .create_dir_entries(
                         name.trim(),
                         &short_name,
@@ -571,20 +569,20 @@ impl FATDir {
 
             FATDirEntryOrShortName::DirEntry(_) => {
                 // 已经存在这样的一个目录项了
-                return Err(-(EEXIST as i32));
+                return Err(SystemError::EEXIST);
             }
         }
     }
 
-    pub fn create_dir(&self, name: &str, fs: &Arc<FATFileSystem>) -> Result<FATDir, i32> {
-        let r: Result<FATDirEntryOrShortName, i32> =
+    pub fn create_dir(&self, name: &str, fs: &Arc<FATFileSystem>) -> Result<FATDir, SystemError> {
+        let r: Result<FATDirEntryOrShortName, SystemError> =
             self.check_existence(name, Some(true), fs.clone());
         // kdebug!("check existence ok");
         // 检查错误码，如果能够表明目录项已经存在，则返回-EEXIST
         if r.is_err() {
             let err_val = r.unwrap_err();
-            if err_val == (-(EISDIR as i32)) || err_val == (-(ENOTDIR as i32)) {
-                return Err(-(EEXIST as i32));
+            if err_val == (SystemError::EISDIR) || err_val == (SystemError::ENOTDIR) {
+                return Err(SystemError::EEXIST);
             } else {
                 return Err(err_val);
             }
@@ -644,7 +642,7 @@ impl FATDir {
             }
             FATDirEntryOrShortName::DirEntry(_) => {
                 // 已经存在这样的一个目录项了
-                return Err(-(EEXIST as i32));
+                return Err(SystemError::EEXIST);
             }
         }
     }
@@ -656,17 +654,17 @@ impl FATDir {
     ///
     /// @return Ok(FATDirEntryOrShortName::DirEntry) 找到期待的目录项
     /// @return Ok(FATDirEntryOrShortName::ShortName) 当前文件夹下不存在指定的目录项，因此返回一个可行的短文件名
-    /// @return Err(i32) 错误码
+    /// @return Err(SystemError) 错误码
     pub fn check_existence(
         &self,
         name: &str,
         expect_dir: Option<bool>,
         fs: Arc<FATFileSystem>,
-    ) -> Result<FATDirEntryOrShortName, i32> {
+    ) -> Result<FATDirEntryOrShortName, SystemError> {
         let mut sng = ShortNameGenerator::new(name);
 
         loop {
-            let e: Result<FATDirEntry, i32> =
+            let e: Result<FATDirEntry, SystemError> =
                 self.find_entry(name, expect_dir, Some(&mut sng), fs.clone());
             match e {
                 Ok(e) => {
@@ -675,7 +673,7 @@ impl FATDir {
                 }
                 Err(e) => {
                     // 如果没找到，则不返回错误
-                    if e == -(ENOENT as i32) {
+                    if e == SystemError::ENOENT {
                     } else {
                         // 其他错误，则返回
                         return Err(e);
@@ -708,7 +706,7 @@ impl FATDir {
         short_dentry: Option<ShortDirEntry>,
         attrs: FileAttributes,
         fs: Arc<FATFileSystem>,
-    ) -> Result<FATDirEntry, i32> {
+    ) -> Result<FATDirEntry, SystemError> {
         let mut short_dentry: ShortDirEntry = short_dentry.unwrap_or(ShortDirEntry::default());
         short_dentry.name = short_name.clone();
         short_dentry.attributes = attrs;
@@ -725,7 +723,7 @@ impl FATDir {
         // 目录项开始位置
         let start_loc: (Cluster, u64) = match free_entries {
             Some(c) => c,
-            None => return Err(-(ENOSPC as i32)),
+            None => return Err(SystemError::ENOSPC),
         };
         let offsets: Vec<(Cluster, u64)> =
             FATDirEntryOffsetIter::new(fs.clone(), start_loc, num_entries, None).collect();
@@ -771,18 +769,18 @@ impl FATDir {
     /// @param remove_clusters 是否删除与指定的目录项相关联的数据簇
     ///
     /// @return Ok() 成功时无返回值
-    /// @return Err(i32) 如果目标文件夹不为空，则不能删除，返回-ENOTEMPTY. 或者返回底层传上来的错误
+    /// @return Err(SystemError) 如果目标文件夹不为空，则不能删除，返回-ENOTEMPTY. 或者返回底层传上来的错误
     pub fn remove(
         &self,
         fs: Arc<FATFileSystem>,
         name: &str,
         remove_clusters: bool,
-    ) -> Result<(), i32> {
+    ) -> Result<(), SystemError> {
         let e: FATDirEntry = self.find_entry(name, None, None, fs.clone())?;
 
         // 判断文件夹是否为空，如果空，则不删除，报错。
         if e.is_dir() && !(e.to_dir().unwrap().is_empty(fs.clone())) {
-            return Err(-(ENOTEMPTY as i32));
+            return Err(SystemError::ENOTEMPTY);
         }
 
         if e.first_cluster().cluster_num >= 2 && remove_clusters {
@@ -805,7 +803,7 @@ impl FATDir {
         &self,
         fs: Arc<FATFileSystem>,
         cluster_range: ((Cluster, u64), (Cluster, u64)),
-    ) -> Result<(), i32> {
+    ) -> Result<(), SystemError> {
         // 收集所有的要移除的目录项
         let offsets: Vec<(Cluster, u64)> =
             FATDirEntryOffsetIter::new(fs.clone(), cluster_range.0, 15, Some(cluster_range.1))
@@ -823,8 +821,8 @@ impl FATDir {
     /// @brief 根据名字在当前文件夹下寻找目录项
     ///
     /// @return Ok(FATDirEntry) 目标目录项
-    /// @return Err(i32) 底层传上来的错误码
-    pub fn get_dir_entry(&self, fs: Arc<FATFileSystem>, name: &str) -> Result<FATDirEntry, i32> {
+    /// @return Err(SystemError) 底层传上来的错误码
+    pub fn get_dir_entry(&self, fs: Arc<FATFileSystem>, name: &str) -> Result<FATDirEntry, SystemError> {
         if name == "." || name == "/" {
             return Ok(FATDirEntry::Dir(self.clone()));
         }
@@ -840,7 +838,7 @@ impl FATDir {
         fs: Arc<FATFileSystem>,
         old_name: &str,
         new_name: &str,
-    ) -> Result<FATDirEntry, i32> {
+    ) -> Result<FATDirEntry, SystemError> {
         // 判断源目录项是否存在
         let old_dentry: FATDirEntry = if let FATDirEntryOrShortName::DirEntry(dentry) =
             self.check_existence(old_name, None, fs.clone())?
@@ -848,7 +846,7 @@ impl FATDir {
             dentry
         } else {
             // 如果目标目录项不存在，则返回错误
-            return Err(-(ENOENT as i32));
+            return Err(SystemError::ENOENT);
         };
 
         let short_name = if let FATDirEntryOrShortName::ShortName(s) =
@@ -857,7 +855,7 @@ impl FATDir {
             s
         } else {
             // 如果目标目录项存在，那么就返回错误
-            return Err(-(EEXIST as i32));
+            return Err(SystemError::EEXIST);
         };
 
         let old_short_dentry: Option<ShortDirEntry> = old_dentry.short_dir_entry();
@@ -877,7 +875,7 @@ impl FATDir {
             return Ok(new_dentry);
         } else {
             // 不允许对根目录项进行重命名
-            return Err(-(EPERM as i32));
+            return Err(SystemError::EPERM);
         }
     }
 }
@@ -991,10 +989,10 @@ impl LongDirEntry {
     /// @param name_part 要被填入当前长目录项的名字（数组长度必须为13）
     ///
     /// @return Ok(())
-    /// @return Err(i32) 错误码
-    fn insert_name(&mut self, name_part: &[u16]) -> Result<(), i32> {
+    /// @return Err(SystemError) 错误码
+    fn insert_name(&mut self, name_part: &[u16]) -> Result<(), SystemError> {
         if name_part.len() != Self::LONG_NAME_STR_LEN {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
         self.name1.copy_from_slice(&name_part[0..5]);
         self.name2.copy_from_slice(&name_part[5..11]);
@@ -1004,9 +1002,9 @@ impl LongDirEntry {
 
     /// @brief 将当前长目录项的名称字段，原样地拷贝到一个长度为13的u16数组中。
     /// @param dst 拷贝的目的地，一个[u16]数组，长度必须为13。
-    pub fn copy_name_to_slice(&self, dst: &mut [u16]) -> Result<(), i32> {
+    pub fn copy_name_to_slice(&self, dst: &mut [u16]) -> Result<(), SystemError> {
         if dst.len() != Self::LONG_NAME_STR_LEN {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
         dst[0..5].copy_from_slice(&self.name1);
         dst[5..11].copy_from_slice(&self.name2);
@@ -1025,19 +1023,19 @@ impl LongDirEntry {
     /// @brief 校验字符串是否符合长目录项的命名要求
     ///
     /// @return Ok(()) 名称合法
-    /// @return Err(i32) 名称不合法，返回错误码
-    pub fn validate_long_name(mut name: &str) -> Result<(), i32> {
+    /// @return Err(SystemError) 名称不合法，返回错误码
+    pub fn validate_long_name(mut name: &str) -> Result<(), SystemError> {
         // 去除首尾多余的空格
         name = name.trim();
 
         // 名称不能为0
         if name.len() == 0 {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         // 名称长度不能大于255
         if name.len() > 255 {
-            return Err(-(ENAMETOOLONG as i32));
+            return Err(SystemError::ENAMETOOLONG);
         }
 
         // 检查是否符合命名要求
@@ -1049,7 +1047,7 @@ impl LongDirEntry {
                 | '^' | '#' | '&' => {}
                 '+' | ',' | ';' | '=' | '[' | ']' | '.' | ' ' => {}
                 _ => {
-                    return Err(-(EILSEQ as i32));
+                    return Err(SystemError::EILSEQ);
                 }
             }
         }
@@ -1062,8 +1060,8 @@ impl LongDirEntry {
     /// @param disk_bytes_offset 长目录项所在位置对应的在磁盘上的字节偏移量
     ///
     /// @return Ok(())
-    /// @return Err(i32) 错误码
-    pub fn flush(&self, fs: Arc<FATFileSystem>, disk_bytes_offset: u64) -> Result<(), i32> {
+    /// @return Err(SystemError) 错误码
+    pub fn flush(&self, fs: Arc<FATFileSystem>, disk_bytes_offset: u64) -> Result<(), SystemError> {
         // 从磁盘读取数据
         let blk_offset = fs.get_in_block_offset(disk_bytes_offset);
         let lba = fs.get_lba_from_offset(
@@ -1272,8 +1270,8 @@ impl ShortDirEntry {
     /// @param disk_bytes_offset 短目录项所在位置对应的在磁盘上的字节偏移量
     ///
     /// @return Ok(())
-    /// @return Err(i32) 错误码
-    pub fn flush(&self, fs: &Arc<FATFileSystem>, disk_bytes_offset: u64) -> Result<(), i32> {
+    /// @return Err(SystemError) 错误码
+    pub fn flush(&self, fs: &Arc<FATFileSystem>, disk_bytes_offset: u64) -> Result<(), SystemError> {
         // 从磁盘读取数据
         let blk_offset = fs.get_in_block_offset(disk_bytes_offset);
         let lba = fs.get_lba_from_offset(
@@ -1389,7 +1387,7 @@ impl FATDirIter {
     ///             u64: 下一个要读取的簇内偏移量
     ///             Option<FATDirEntry>: 读取到的目录项（如果没有读取到，就返回失败）
     /// @return Err(错误码) 可能出现了内部错误，或者是磁盘错误等。具体原因看错误码。
-    fn get_dir_entry(&mut self) -> Result<(Cluster, u64, Option<FATDirEntry>), i32> {
+    fn get_dir_entry(&mut self) -> Result<(Cluster, u64, Option<FATDirEntry>), SystemError> {
         loop {
             // 如果当前簇已经被读完，那么尝试获取下一个簇
             if self.offset >= self.fs.bytes_per_cluster() && !self.is_root {
@@ -1497,7 +1495,7 @@ impl FATDirIter {
                         }
                     }
                     // kdebug!("collect dentries done. long_name_entries={long_name_entries:?}");
-                    let dir_entry: Result<FATDirEntry, i32> = FATDirEntry::new(
+                    let dir_entry: Result<FATDirEntry, SystemError> = FATDirEntry::new(
                         long_name_entries,
                         (
                             (start_cluster, start_offset),
@@ -1556,19 +1554,19 @@ impl FATDirEntry {
     ///         格式：[第20个（或者是最大ord的那个）, 19, 18, ..., 1, 短目录项]
     ///
     /// @return Ok(FATDirEntry) 构建好的FATDirEntry类型的对象
-    /// @return Err(i32) 错误码
+    /// @return Err(SystemError) 错误码
     pub fn new(
         mut long_name_entries: Vec<FATRawDirEntry>,
         loc: ((Cluster, u64), (Cluster, u64)),
-    ) -> Result<Self, i32> {
+    ) -> Result<Self, SystemError> {
         if long_name_entries.is_empty() {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         if !long_name_entries[0].is_last() || !long_name_entries.last().unwrap().is_short() {
             // 存在孤立的目录项，文件系统出现异常，因此返回错误，表明其只读。
             // TODO: 标记整个FAT文件系统为只读的
-            return Err(-(EROFS as i32));
+            return Err(SystemError::EROFS);
         }
 
         // 取出短目录项（位于vec的末尾）
@@ -1585,7 +1583,7 @@ impl FATDirEntry {
                 }
 
                 _ => {
-                    return Err(-(EROFS as i32));
+                    return Err(SystemError::EROFS);
                 }
             }
         }
@@ -1595,7 +1593,7 @@ impl FATDirEntry {
             return Ok(short_dentry.to_dir_entry_with_long_name(extractor.to_string(), loc));
         } else {
             // 校验和不相同，认为文件系统出错
-            return Err(-(EROFS as i32));
+            return Err(SystemError::EROFS);
         }
     }
 
@@ -1748,9 +1746,9 @@ impl FATDirEntry {
     }
 
     /// @brief 将FATDirEntry转换为FATFile对象
-    pub fn to_file(&self) -> Result<FATFile, i32> {
+    pub fn to_file(&self) -> Result<FATFile, SystemError> {
         if self.is_file() == false {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         match &self {
@@ -1762,9 +1760,9 @@ impl FATDirEntry {
     }
 
     /// @brief 将FATDirEntry转换为FATDir对象
-    pub fn to_dir(&self) -> Result<FATDir, i32> {
+    pub fn to_dir(&self) -> Result<FATDir, SystemError> {
         if self.is_dir() == false {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
         match &self {
             FATDirEntry::Dir(d) => {
@@ -1973,7 +1971,7 @@ impl ShortNameGenerator {
         }
     }
 
-    pub fn generate(&self) -> Result<[u8; 11], i32> {
+    pub fn generate(&self) -> Result<[u8; 11], SystemError> {
         if self.is_dot() || self.is_dotdot() {
             return Ok(self.name);
         }
@@ -1997,7 +1995,7 @@ impl ShortNameGenerator {
             }
         }
         // 由于产生太多的冲突，因此返回错误（“短文件名已经存在”）
-        return Err(-(EEXIST as i32));
+        return Err(SystemError::EEXIST);
     }
 
     pub fn next_iteration(&mut self) {
@@ -2096,13 +2094,13 @@ impl LongNameExtractor {
     /// @brief 提取长目录项的名称
     /// @param longname_dentry 长目录项
     /// 请注意，必须倒序输入长目录项对象
-    fn process(&mut self, longname_dentry: LongDirEntry) -> Result<(), i32> {
+    fn process(&mut self, longname_dentry: LongDirEntry) -> Result<(), SystemError> {
         let is_last: bool = longname_dentry.is_last();
         let index: u8 = longname_dentry.ord & 0x1f;
 
         if index == 0 {
             self.name.clear();
-            return Err(-(EROFS as i32));
+            return Err(SystemError::EROFS);
         }
 
         // 如果是最后一个LongDirEntry，则初始化当前生成器
@@ -2118,7 +2116,7 @@ impl LongNameExtractor {
             // 如果当前index为0,或者index不连续，或者是校验和不同，那么认为文件系统损坏，清除生成器的名称字段
             // TODO: 对文件系统的变为只读状态状况的拦截
             self.name.clear();
-            return Err(-(EROFS as i32));
+            return Err(SystemError::EROFS);
         } else {
             // 由于dentry倒序输入，因此index是每次减1的
             self.index -= 1;
@@ -2328,7 +2326,7 @@ impl Iterator for FATDirEntryOffsetIter {
 pub fn get_raw_dir_entry(
     fs: &Arc<FATFileSystem>,
     in_disk_bytes_offset: u64,
-) -> Result<FATRawDirEntry, i32> {
+) -> Result<FATRawDirEntry, SystemError> {
     // 块内偏移量
     let blk_offset: u64 = fs.get_in_block_offset(in_disk_bytes_offset);
     let lba = fs.get_lba_from_offset(

kernel/src/filesystem/fat/fs.rs

@@ -14,9 +14,6 @@ use crate::{
         file::{FileMode, FilePrivateData},
         FileSystem, FileType, IndexNode, InodeId, Metadata, PollStatus,
     },
-    include::bindings::bindings::{
-        EFAULT, EINVAL, EISDIR, ENOENT, ENOSPC, ENOTDIR, ENOTEMPTY, ENOTSUP, EPERM, EROFS,
-    },
     io::{device::LBA_SIZE, disk_info::Partition, SeekFrom},
     kerror,
     libs::{
@@ -24,6 +21,7 @@ use crate::{
         vec_cursor::VecCursor,
     },
     time::TimeSpec,
+    syscall::SystemError,
 };
 
 use super::{
@@ -123,7 +121,7 @@ impl FATInode {
         };
     }
 
-    fn find(&mut self, name: &str) -> Result<Arc<LockedFATInode>, i32> {
+    fn find(&mut self, name: &str) -> Result<Arc<LockedFATInode>, SystemError> {
         match &self.inode_type {
             FATDirEntry::Dir(d) => {
                 // 尝试在缓存区查找
@@ -153,7 +151,7 @@ impl FATInode {
                 )
             }
             _ => {
-                return Err(-(ENOTDIR as i32));
+                return Err(SystemError::ENOTDIR);
             }
         }
     }
@@ -251,7 +249,7 @@ impl FATFileSystem {
     /// FAT32允许的最大簇号
     pub const FAT32_MAX_CLUSTER: u32 = 0x0FFFFFF7;
 
-    pub fn new(partition: Arc<Partition>) -> Result<Arc<FATFileSystem>, i32> {
+    pub fn new(partition: Arc<Partition>) -> Result<Arc<FATFileSystem>, SystemError> {
         let bpb = BiosParameterBlock::new(partition.clone())?;
 
         // 从磁盘上读取FAT32文件系统的FsInfo结构体
@@ -281,7 +279,7 @@ impl FATFileSystem {
                 FATType::FAT32(x) => x.fat_size_32 as u64,
                 _ => {
                     kerror!("FAT12 and FAT16 volumes should have non-zero BPB_FATSz16");
-                    return Err(-(EINVAL as i32));
+                    return Err(SystemError::EINVAL);
                 }
             }
         };
@@ -349,8 +347,8 @@ impl FATFileSystem {
     /// @param cluster 当前簇
     ///
     /// @return Ok(FATEntry) 当前簇在FAT表中，存储的信息。（详情见FATEntry的注释）
-    /// @return Err(i32) 错误码
-    pub fn get_fat_entry(&self, cluster: Cluster) -> Result<FATEntry, i32> {
+    /// @return Err(SystemError) 错误码
+    pub fn get_fat_entry(&self, cluster: Cluster) -> Result<FATEntry, SystemError> {
         let current_cluster = cluster.cluster_num;
 
         let fat_type: FATType = self.bpb.fat_type;
@@ -444,8 +442,8 @@ impl FATFileSystem {
     /// @param cluster 当前簇
     ///
     /// @return Ok(u64) 当前簇在FAT表中，存储的信息。
-    /// @return Err(i32) 错误码
-    pub fn get_fat_entry_raw(&self, cluster: Cluster) -> Result<u64, i32> {
+    /// @return Err(SystemError) 错误码
+    pub fn get_fat_entry_raw(&self, cluster: Cluster) -> Result<u64, SystemError> {
         let current_cluster = cluster.cluster_num;
 
         let fat_type: FATType = self.bpb.fat_type;
@@ -545,8 +543,8 @@ impl FATFileSystem {
     /// @param prev_cluster 簇链的前一个簇。本函数将会把新获取的簇，连接到它的后面。
     ///
     /// @return Ok(Cluster) 新获取的空闲簇
-    /// @return Err(i32) 错误码
-    pub fn allocate_cluster(&self, prev_cluster: Option<Cluster>) -> Result<Cluster, i32> {
+    /// @return Err(SystemError) 错误码
+    pub fn allocate_cluster(&self, prev_cluster: Option<Cluster>) -> Result<Cluster, SystemError> {
         let end_cluster: Cluster = self.max_cluster_number();
         let start_cluster: Cluster = match self.bpb.fat_type {
             FATType::FAT32(_) => {
@@ -594,7 +592,7 @@ impl FATFileSystem {
     /// @brief 释放簇链上的所有簇
     ///
     /// @param start_cluster 簇链的第一个簇
-    pub fn deallocate_cluster_chain(&self, start_cluster: Cluster) -> Result<(), i32> {
+    pub fn deallocate_cluster_chain(&self, start_cluster: Cluster) -> Result<(), SystemError> {
         let clusters: Vec<Cluster> = self.clusters(start_cluster);
         for c in clusters {
             self.deallocate_cluster(c)?;
@@ -605,7 +603,7 @@ impl FATFileSystem {
     /// @brief 释放簇
     ///
     /// @param 要释放的簇
-    pub fn deallocate_cluster(&self, cluster: Cluster) -> Result<(), i32> {
+    pub fn deallocate_cluster(&self, cluster: Cluster) -> Result<(), SystemError> {
         let entry: FATEntry = self.get_fat_entry(cluster)?;
         // 如果不是坏簇
         if entry != FATEntry::Bad {
@@ -618,7 +616,7 @@ impl FATFileSystem {
         } else {
             // 不能释放坏簇
             kerror!("Bad clusters cannot be freed.");
-            return Err(-(EFAULT as i32));
+            return Err(SystemError::EFAULT);
         }
     }
 
@@ -771,8 +769,8 @@ impl FATFileSystem {
     ///
     /// @return Ok(true) 正常
     /// @return Ok(false) 不正常
-    /// @return Err(i32) 在判断时发生错误
-    pub fn is_shut_bit_ok(&mut self) -> Result<bool, i32> {
+    /// @return Err(SystemError) 在判断时发生错误
+    pub fn is_shut_bit_ok(&mut self) -> Result<bool, SystemError> {
         match self.bpb.fat_type {
             FATType::FAT32(_) => {
                 // 对于FAT32, error bit位于第一个扇区的第8字节。
@@ -794,8 +792,8 @@ impl FATFileSystem {
     ///
     /// @return Ok(true) 正常
     /// @return Ok(false) 不正常
-    /// @return Err(i32) 在判断时发生错误
-    pub fn is_hard_error_bit_ok(&mut self) -> Result<bool, i32> {
+    /// @return Err(SystemError) 在判断时发生错误
+    pub fn is_hard_error_bit_ok(&mut self) -> Result<bool, SystemError> {
         match self.bpb.fat_type {
             FATType::FAT32(_) => {
                 let bit = self.get_fat_entry_raw(Cluster::new(1))? & 0x0400_0000;
@@ -813,8 +811,8 @@ impl FATFileSystem {
     /// 参考资料：https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html
     ///
     /// @return Ok(()) 设置成功
-    /// @return Err(i32) 在设置过程中，出现错误
-    pub fn set_shut_bit_ok(&mut self) -> Result<(), i32> {
+    /// @return Err(SystemError) 在设置过程中，出现错误
+    pub fn set_shut_bit_ok(&mut self) -> Result<(), SystemError> {
         match self.bpb.fat_type {
             FATType::FAT32(_) => {
                 let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x0800_0000;
@@ -836,8 +834,8 @@ impl FATFileSystem {
     /// 参考资料：https://thestarman.pcministry.com/DOS/DirtyShutdownFlag.html
     ///
     /// @return Ok(()) 设置成功
-    /// @return Err(i32) 在设置过程中，出现错误
-    pub fn set_hard_error_bit_ok(&mut self) -> Result<(), i32> {
+    /// @return Err(SystemError) 在设置过程中，出现错误
+    pub fn set_hard_error_bit_ok(&mut self) -> Result<(), SystemError> {
         match self.bpb.fat_type {
             FATType::FAT32(_) => {
                 let raw_entry = self.get_fat_entry_raw(Cluster::new(1))? | 0x0400_0000;
@@ -855,7 +853,7 @@ impl FATFileSystem {
     }
 
     /// @brief 执行文件系统卸载前的一些准备工作：设置好对应的标志位，并把缓存中的数据刷入磁盘
-    pub fn umount(&mut self) -> Result<(), i32> {
+    pub fn umount(&mut self) -> Result<(), SystemError> {
         self.fs_info.0.lock().flush(&self.partition)?;
 
         self.set_shut_bit_ok()?;
@@ -908,12 +906,12 @@ impl FATFileSystem {
     /// @param end_cluster 终止簇号（不包含）
     ///
     /// @return Ok(Cluster) 寻找到的空闲簇
-    /// @return Err(i32) 错误码。如果磁盘无剩余空间，或者簇号达到给定的最大值，则返回-ENOSPC.
+    /// @return Err(SystemError) 错误码。如果磁盘无剩余空间，或者簇号达到给定的最大值，则返回-ENOSPC.
     pub fn get_free_cluster(
         &self,
         start_cluster: Cluster,
         end_cluster: Cluster,
-    ) -> Result<Cluster, i32> {
+    ) -> Result<Cluster, SystemError> {
         let max_cluster: Cluster = self.max_cluster_number();
         let mut cluster: u64 = start_cluster.cluster_num;
 
@@ -953,7 +951,7 @@ impl FATFileSystem {
 
                     // 磁盘无剩余空间，或者簇号达到给定的最大值
                     if cluster == end_cluster.cluster_num || cluster == max_cluster.cluster_num {
-                        return Err(-(ENOSPC as i32));
+                        return Err(SystemError::ENOSPC);
                     }
 
                     packed_val = match cluster & 1 {
@@ -995,7 +993,7 @@ impl FATFileSystem {
                 }
 
                 // 磁盘无剩余空间，或者簇号达到给定的最大值
-                return Err(-(ENOSPC as i32));
+                return Err(SystemError::ENOSPC);
             }
             FATType::FAT32(_) => {
                 // todo: 优化这里，减少读取磁盘的次数。
@@ -1027,7 +1025,7 @@ impl FATFileSystem {
                 }
 
                 // 磁盘无剩余空间，或者簇号达到给定的最大值
-                return Err(-(ENOSPC as i32));
+                return Err(SystemError::ENOSPC);
             }
         }
     }
@@ -1036,7 +1034,7 @@ impl FATFileSystem {
     ///
     /// @param cluster 目标簇
     /// @param fat_entry 这个簇在FAT表中，存储的信息（下一个簇的簇号）
-    pub fn set_entry(&self, cluster: Cluster, fat_entry: FATEntry) -> Result<(), i32> {
+    pub fn set_entry(&self, cluster: Cluster, fat_entry: FATEntry) -> Result<(), SystemError> {
         // fat表项在分区上的字节偏移量
         let fat_part_bytes_offset: u64 = self.bpb.fat_type.get_fat_bytes_offset(
             cluster,
@@ -1136,7 +1134,7 @@ impl FATFileSystem {
                             "FAT32: Reserved Cluster {:?} cannot be marked as free",
                             cluster
                         );
-                        return Err(-(EPERM as i32));
+                        return Err(SystemError::EPERM);
                     }
 
                     // 计算要写入的值
@@ -1166,7 +1164,7 @@ impl FATFileSystem {
     /// @brief 清空指定的簇
     ///
     /// @param cluster 要被清空的簇
-    pub fn zero_cluster(&self, cluster: Cluster) -> Result<(), i32> {
+    pub fn zero_cluster(&self, cluster: Cluster) -> Result<(), SystemError> {
         // 准备数据，用于写入
         let zeros: Vec<u8> = vec![0u8; self.bytes_per_cluster() as usize];
         let offset: usize = self.cluster_bytes_offset(cluster) as usize;
@@ -1183,7 +1181,7 @@ impl Drop for FATFileSystem {
         let r = self.umount();
         if r.is_err() {
             kerror!(
-                "Umount FAT filesystem failed: errno={}, FS detail:{self:?}",
+                "Umount FAT filesystem failed: errno={:?}, FS detail:{self:?}",
                 r.unwrap_err()
             );
         }
@@ -1205,7 +1203,7 @@ impl FATFsInfo {
         partition: Arc<Partition>,
         in_disk_fs_info_offset: u64,
         bytes_per_sec: usize,
-    ) -> Result<Self, i32> {
+    ) -> Result<Self, SystemError> {
         let mut v = Vec::<u8>::new();
         v.resize(bytes_per_sec, 0);
 
@@ -1233,7 +1231,7 @@ impl FATFsInfo {
             return Ok(fsinfo);
         } else {
             kerror!("Error occurred while parsing FATFsInfo.");
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
     }
 
@@ -1296,7 +1294,7 @@ impl FATFsInfo {
     /// @brief 把fs info刷入磁盘
     ///
     /// @param partition fs info所在的分区
-    pub fn flush(&self, partition: &Arc<Partition>) -> Result<(), i32> {
+    pub fn flush(&self, partition: &Arc<Partition>) -> Result<(), SystemError> {
         if let Some(off) = self.offset {
             let in_block_offset = off % LBA_SIZE as u64;
 
@@ -1325,7 +1323,7 @@ impl FATFsInfo {
     /// @brief 读取磁盘上的Fs Info扇区，将里面的内容更新到结构体中
     ///
     /// @param partition fs info所在的分区
-    pub fn update(&mut self, partition: Arc<Partition>) -> Result<(), i32> {
+    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;
 
@@ -1356,7 +1354,7 @@ impl IndexNode for LockedFATInode {
         len: usize,
         buf: &mut [u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         let mut guard: SpinLockGuard<FATInode> = self.0.lock();
         match &guard.inode_type {
             FATDirEntry::File(f) | FATDirEntry::VolId(f) => {
@@ -1369,11 +1367,11 @@ impl IndexNode for LockedFATInode {
                 return r;
             }
             FATDirEntry::Dir(_) => {
-                return Err(-(EISDIR as i32));
+                return Err(SystemError::EISDIR);
             }
             FATDirEntry::UnInit => {
                 kerror!("FATFS: param: Inode_type uninitialized.");
-                return Err(-(EROFS as i32));
+                return Err(SystemError::EROFS);
             }
         }
     }
@@ -1384,7 +1382,7 @@ impl IndexNode for LockedFATInode {
         len: usize,
         buf: &[u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         let mut guard: SpinLockGuard<FATInode> = self.0.lock();
         let fs: &Arc<FATFileSystem> = &guard.fs.upgrade().unwrap();
 
@@ -1395,22 +1393,22 @@ impl IndexNode for LockedFATInode {
                 return r;
             }
             FATDirEntry::Dir(_) => {
-                return Err(-(EISDIR as i32));
+                return Err(SystemError::EISDIR);
             }
             FATDirEntry::UnInit => {
                 kerror!("FATFS: param: Inode_type uninitialized.");
-                return Err(-(EROFS as i32));
+                return Err(SystemError::EROFS);
             }
         }
     }
 
-    fn poll(&self) -> Result<PollStatus, i32> {
+    fn poll(&self) -> Result<PollStatus, SystemError> {
         // 加锁
         let inode: SpinLockGuard<FATInode> = self.0.lock();
 
         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
         if inode.metadata.file_type == FileType::Dir {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         return Ok(PollStatus {
@@ -1423,7 +1421,7 @@ impl IndexNode for LockedFATInode {
         name: &str,
         file_type: FileType,
         _mode: u32,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         // 由于FAT32不支持文件权限的功能，因此忽略mode参数
 
         let mut guard: SpinLockGuard<FATInode> = self.0.lock();
@@ -1431,7 +1429,7 @@ impl IndexNode for LockedFATInode {
 
         match &mut guard.inode_type {
             FATDirEntry::File(_) | FATDirEntry::VolId(_) => {
-                return Err(-(ENOTDIR as i32));
+                return Err(SystemError::ENOTDIR);
             }
             FATDirEntry::Dir(d) => match file_type {
                 FileType::File => {
@@ -1443,12 +1441,12 @@ impl IndexNode for LockedFATInode {
                     return Ok(guard.find(name)?);
                 }
 
-                FileType::SymLink => return Err(-(ENOTSUP as i32)),
-                _ => return Err(-(EINVAL as i32)),
+                FileType::SymLink => return Err(SystemError::ENOTSUP),
+                _ => return Err(SystemError::EINVAL),
             },
             FATDirEntry::UnInit => {
                 kerror!("FATFS: param: Inode_type uninitialized.");
-                return Err(-(EROFS as i32));
+                return Err(SystemError::EROFS);
             }
         }
     }
@@ -1461,16 +1459,16 @@ impl IndexNode for LockedFATInode {
         return self;
     }
 
-    fn metadata(&self) -> Result<Metadata, i32> {
+    fn metadata(&self) -> Result<Metadata, SystemError> {
         return Ok(self.0.lock().metadata.clone());
     }
 
-    fn list(&self) -> Result<Vec<String>, i32> {
+    fn list(&self) -> Result<Vec<String>, SystemError> {
         let mut guard: SpinLockGuard<FATInode> = self.0.lock();
         let fatent: &FATDirEntry = &guard.inode_type;
         match fatent {
             FATDirEntry::File(_) | FATDirEntry::VolId(_) => {
-                return Err(-(ENOTDIR as i32));
+                return Err(SystemError::ENOTDIR);
             }
             FATDirEntry::Dir(dir) => {
                 // 获取当前目录下的所有目录项
@@ -1503,26 +1501,26 @@ impl IndexNode for LockedFATInode {
             }
             FATDirEntry::UnInit => {
                 kerror!("FATFS: param: Inode_type uninitialized.");
-                return Err(-(EROFS as i32));
+                return Err(SystemError::EROFS);
             }
         }
     }
 
-    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, i32> {
+    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
         let mut guard: SpinLockGuard<FATInode> = self.0.lock();
         let target = guard.find(name)?;
         return Ok(target);
     }
 
-    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), i32> {
+    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
         return Ok(());
     }
 
-    fn close(&self, _data: &mut FilePrivateData) -> Result<(), i32> {
+    fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
         return Ok(());
     }
 
-    fn unlink(&self, name: &str) -> Result<(), i32> {
+    fn unlink(&self, name: &str) -> Result<(), SystemError> {
         let mut guard: SpinLockGuard<FATInode> = self.0.lock();
         let target: Arc<LockedFATInode> = guard.find(name)?;
         // 对目标inode上锁，以防更改
@@ -1532,12 +1530,12 @@ impl IndexNode for LockedFATInode {
 
         let dir = match &guard.inode_type {
             FATDirEntry::File(_) | FATDirEntry::VolId(_) => {
-                return Err(-(ENOTDIR as i32));
+                return Err(SystemError::ENOTDIR);
             }
             FATDirEntry::Dir(d) => d,
             FATDirEntry::UnInit => {
                 kerror!("FATFS: param: Inode_type uninitialized.");
-                return Err(-(EROFS as i32));
+                return Err(SystemError::EROFS);
             }
         };
         // 检查文件是否存在
@@ -1549,7 +1547,7 @@ impl IndexNode for LockedFATInode {
         return r;
     }
 
-    fn rmdir(&self, name: &str) -> Result<(), i32> {
+    fn rmdir(&self, name: &str) -> Result<(), SystemError> {
         let mut guard: SpinLockGuard<FATInode> = self.0.lock();
         let target: Arc<LockedFATInode> = guard.find(name)?;
         // 对目标inode上锁，以防更改
@@ -1559,24 +1557,24 @@ impl IndexNode for LockedFATInode {
 
         let dir = match &guard.inode_type {
             FATDirEntry::File(_) | FATDirEntry::VolId(_) => {
-                return Err(-(ENOTDIR as i32));
+                return Err(SystemError::ENOTDIR);
             }
             FATDirEntry::Dir(d) => d,
             FATDirEntry::UnInit => {
                 kerror!("FATFS: param: Inode_type uninitialized.");
-                return Err(-(EROFS as i32));
+                return Err(SystemError::EROFS);
             }
         };
         // 检查文件夹是否存在
         dir.check_existence(name, Some(true), guard.fs.upgrade().unwrap())?;
 
         // 再从磁盘删除
-        let r: Result<(), i32> = dir.remove(guard.fs.upgrade().unwrap().clone(), name, true);
+        let r: Result<(), SystemError> = dir.remove(guard.fs.upgrade().unwrap().clone(), name, true);
         if r.is_ok() {
             return r;
         } else {
             let r = r.unwrap_err();
-            if r == -(ENOTEMPTY as i32) {
+            if r == SystemError::ENOTEMPTY {
                 // 如果要删除的是目录，且不为空，则删除动作未发生，重新加入缓存
                 guard.children.insert(name.to_uppercase(), target.clone());
                 drop(target_guard);
@@ -1585,10 +1583,10 @@ impl IndexNode for LockedFATInode {
         }
     }
 
-    fn get_entry_name(&self, ino: InodeId) -> Result<String, i32> {
+    fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> {
         let guard: SpinLockGuard<FATInode> = self.0.lock();
         if guard.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
         match ino {
             0 => {
@@ -1608,7 +1606,7 @@ impl IndexNode for LockedFATInode {
                     .collect();
 
                 match key.len() {
-                    0=>{return Err(-(ENOENT as i32));}
+                    0=>{return Err(SystemError::ENOENT);}
                     1=>{return Ok(key.remove(0));}
                     _ => panic!("FatFS get_entry_name: key.len()={key_len}>1, current inode_id={inode_id}, to find={to_find}", key_len=key.len(), inode_id = guard.metadata.inode_id, to_find=ino)
                 }

kernel/src/filesystem/procfs/mod.rs

@@ -15,12 +15,11 @@ use crate::{
         FileType,
     },
     include::bindings::bindings::{
-        pid_t, process_find_pcb_by_pid, EEXIST, EINVAL, EISDIR, ENOBUFS, ENOENT, ENOTDIR,
-        ENOTEMPTY, ENOTSUP, EPERM, ESRCH,
+        pid_t, process_find_pcb_by_pid,
     },
     kerror,
     libs::spinlock::{SpinLock, SpinLockGuard},
-    time::TimeSpec,
+    time::TimeSpec, syscall::SystemError,
 };
 
 use super::vfs::{
@@ -114,7 +113,7 @@ impl ProcFSInode {
 
     /// @brief 打开status文件
     ///
-    fn open_status(&self, pdata: &mut ProcfsFilePrivateData) -> Result<i64, i32> {
+    fn open_status(&self, pdata: &mut ProcfsFilePrivateData) -> Result<i64, SystemError> {
         // 获取该pid对应的pcb结构体
         let pid: &i64 = &self.fdata.pid;
         let pcb = unsafe { process_find_pcb_by_pid(*pid).as_mut() };
@@ -123,7 +122,7 @@ impl ProcFSInode {
                 "ProcFS: Cannot find pcb for pid {} when opening its 'status' file.",
                 pid
             );
-            return Err(-(ESRCH as i32));
+            return Err(SystemError::ESRCH);
         } else {
             pcb.unwrap()
         };
@@ -198,13 +197,13 @@ impl ProcFSInode {
         len: usize,
         buf: &mut [u8],
         _pdata: &mut ProcfsFilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         let start = _pdata.data.len().min(offset);
         let end = _pdata.data.len().min(offset + len);
 
         // buffer空间不足
         if buf.len() < (end - start) {
-            return Err(-(ENOBUFS as i32));
+            return Err(SystemError::ENOBUFS);
         }
 
         // 拷贝数据
@@ -278,7 +277,7 @@ impl ProcFS {
 
     /// @brief 进程注册函数
     /// @usage 在进程中调用并创建进程对应文件
-    pub fn register_pid(&self, pid: i64) -> Result<(), i32> {
+    pub fn register_pid(&self, pid: i64) -> Result<(), SystemError> {
         // 获取当前inode
         let proc: Arc<dyn IndexNode> = self.root_inode();
         // 创建对应进程文件夹
@@ -300,7 +299,7 @@ impl ProcFS {
 
     /// @brief 解除进程注册
     ///
-    pub fn unregister_pid(&self, pid: i64) -> Result<(), i32> {
+    pub fn unregister_pid(&self, pid: i64) -> Result<(), SystemError> {
         // 获取当前inode
         let proc: Arc<dyn IndexNode> = self.root_inode();
         // 获取进程文件夹
@@ -319,7 +318,7 @@ impl ProcFS {
 }
 
 impl IndexNode for LockedProcFSInode {
-    fn open(&self, data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), i32> {
+    fn open(&self, data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
         // 加锁
         let mut inode: SpinLockGuard<ProcFSInode> = self.0.lock();
 
@@ -342,7 +341,7 @@ impl IndexNode for LockedProcFSInode {
         return Ok(());
     }
 
-    fn close(&self, data: &mut FilePrivateData) -> Result<(), i32> {
+    fn close(&self, data: &mut FilePrivateData) -> Result<(), SystemError> {
         let guard: SpinLockGuard<ProcFSInode> = self.0.lock();
         // 如果inode类型为文件夹，则直接返回成功
         if let FileType::Dir = guard.metadata.file_type {
@@ -366,16 +365,16 @@ impl IndexNode for LockedProcFSInode {
         len: usize,
         buf: &mut [u8],
         data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         if buf.len() < len {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
         // 加锁
         let inode: SpinLockGuard<ProcFSInode> = self.0.lock();
 
         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
         if inode.metadata.file_type == FileType::Dir {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         // 获取数据信息
@@ -398,7 +397,7 @@ impl IndexNode for LockedProcFSInode {
 
         // buffer空间不足
         if buf.len() < (end - start) {
-            return Err(-(ENOBUFS as i32));
+            return Err(SystemError::ENOBUFS);
         }
 
         // 拷贝数据
@@ -413,17 +412,17 @@ impl IndexNode for LockedProcFSInode {
         _len: usize,
         _buf: &[u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
-        return Err(-(ENOTSUP as i32));
+    ) -> Result<usize, SystemError> {
+        return Err(SystemError::ENOTSUP);
     }
 
-    fn poll(&self) -> Result<PollStatus, i32> {
+    fn poll(&self) -> Result<PollStatus, SystemError> {
         // 加锁
         let inode: SpinLockGuard<ProcFSInode> = self.0.lock();
 
         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
         if inode.metadata.file_type == FileType::Dir {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         return Ok(PollStatus {
@@ -439,14 +438,14 @@ impl IndexNode for LockedProcFSInode {
         self
     }
 
-    fn metadata(&self) -> Result<Metadata, i32> {
+    fn metadata(&self) -> Result<Metadata, SystemError> {
         let inode = self.0.lock();
         let metadata = inode.metadata.clone();
 
         return Ok(metadata);
     }
 
-    fn set_metadata(&self, metadata: &Metadata) -> Result<(), i32> {
+    fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
         let mut inode = self.0.lock();
         inode.metadata.atime = metadata.atime;
         inode.metadata.mtime = metadata.mtime;
@@ -458,13 +457,13 @@ impl IndexNode for LockedProcFSInode {
         return Ok(());
     }
 
-    fn resize(&self, len: usize) -> Result<(), i32> {
+    fn resize(&self, len: usize) -> Result<(), SystemError> {
         let mut inode = self.0.lock();
         if inode.metadata.file_type == FileType::File {
             inode.data.resize(len, 0);
             return Ok(());
         } else {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
     }
 
@@ -474,16 +473,16 @@ impl IndexNode for LockedProcFSInode {
         file_type: FileType,
         mode: u32,
         data: usize,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         // 获取当前inode
         let mut inode = self.0.lock();
         // 如果当前inode不是文件夹，则返回
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
         // 如果有重名的，则返回
         if inode.children.contains_key(name) {
-            return Err(-(EEXIST as i32));
+            return Err(SystemError::EEXIST);
         }
 
         // 创建inode
@@ -525,26 +524,26 @@ impl IndexNode for LockedProcFSInode {
         return Ok(result);
     }
 
-    fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), i32> {
+    fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
         let other: &LockedProcFSInode = other
             .downcast_ref::<LockedProcFSInode>()
-            .ok_or(-(EPERM as i32))?;
+            .ok_or(SystemError::EPERM)?;
         let mut inode: SpinLockGuard<ProcFSInode> = self.0.lock();
         let mut other_locked: SpinLockGuard<ProcFSInode> = other.0.lock();
 
         // 如果当前inode不是文件夹，那么报错
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         // 如果另一个inode是文件夹，那么也报错
         if other_locked.metadata.file_type == FileType::Dir {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         // 如果当前文件夹下已经有同名文件，也报错。
         if inode.children.contains_key(name) {
-            return Err(-(EEXIST as i32));
+            return Err(SystemError::EEXIST);
         }
 
         inode
@@ -556,19 +555,19 @@ impl IndexNode for LockedProcFSInode {
         return Ok(());
     }
 
-    fn unlink(&self, name: &str) -> Result<(), i32> {
+    fn unlink(&self, name: &str) -> Result<(), SystemError> {
         let mut inode: SpinLockGuard<ProcFSInode> = self.0.lock();
         // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
         // 不允许删除当前文件夹，也不允许删除上一个目录
         if name == "." || name == ".." {
-            return Err(-(ENOTEMPTY as i32));
+            return Err(SystemError::ENOTEMPTY);
         }
 
         // 获得要删除的文件的inode
-        let to_delete = inode.children.get(name).ok_or(-(ENOENT as i32))?;
+        let to_delete = inode.children.get(name).ok_or(SystemError::ENOENT)?;
         // 减少硬链接计数
         to_delete.0.lock().metadata.nlinks -= 1;
         // 在当前目录中删除这个子目录项
@@ -581,36 +580,36 @@ impl IndexNode for LockedProcFSInode {
         _old_name: &str,
         _target: &Arc<dyn IndexNode>,
         _new_name: &str,
-    ) -> Result<(), i32> {
-        return Err(-(ENOTSUP as i32));
+    ) -> Result<(), SystemError> {
+        return Err(SystemError::ENOTSUP);
     }
 
-    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, i32> {
+    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
         let inode = self.0.lock();
 
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         match name {
             "" | "." => {
-                return Ok(inode.self_ref.upgrade().ok_or(-(ENOENT as i32))?);
+                return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?);
             }
 
             ".." => {
-                return Ok(inode.parent.upgrade().ok_or(-(ENOENT as i32))?);
+                return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?);
             }
             name => {
                 // 在子目录项中查找
-                return Ok(inode.children.get(name).ok_or(-(ENOENT as i32))?.clone());
+                return Ok(inode.children.get(name).ok_or(SystemError::ENOENT)?.clone());
             }
         }
     }
 
-    fn get_entry_name(&self, ino: InodeId) -> Result<String, i32> {
+    fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> {
         let inode: SpinLockGuard<ProcFSInode> = self.0.lock();
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         match ino {
@@ -631,7 +630,7 @@ impl IndexNode for LockedProcFSInode {
                     .collect();
 
                 match key.len() {
-                        0=>{return Err(-(ENOENT as i32));}
+                        0=>{return Err(SystemError::ENOENT);}
                         1=>{return Ok(key.remove(0));}
                         _ => panic!("Procfs get_entry_name: key.len()={key_len}>1, current inode_id={inode_id}, to find={to_find}", key_len=key.len(), inode_id = inode.metadata.inode_id, to_find=ino)
                     }
@@ -639,10 +638,10 @@ impl IndexNode for LockedProcFSInode {
         }
     }
 
-    fn list(&self) -> Result<Vec<String>, i32> {
+    fn list(&self) -> Result<Vec<String>, SystemError> {
         let info = self.metadata()?;
         if info.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         let mut keys: Vec<String> = Vec::new();
@@ -665,7 +664,7 @@ pub extern "C" fn rs_procfs_register_pid(pid: pid_t) -> u64 {
 }
 
 /// @brief 向procfs注册进程
-pub fn procfs_register_pid(pid: pid_t) -> Result<(), i32> {
+pub fn procfs_register_pid(pid: pid_t) -> Result<(), SystemError> {
     let procfs_inode = ROOT_INODE().find("proc")?;
 
     let procfs_inode = procfs_inode
@@ -691,7 +690,7 @@ pub extern "C" fn rs_procfs_unregister_pid(pid: pid_t) -> u64 {
 }
 
 /// @brief 在ProcFS中,解除进程的注册
-pub fn procfs_unregister_pid(pid: pid_t) -> Result<(), i32> {
+pub fn procfs_unregister_pid(pid: pid_t) -> Result<(), SystemError> {
     // 获取procfs实例
     let procfs_inode: Arc<dyn IndexNode> = ROOT_INODE().find("proc")?;
 

kernel/src/filesystem/ramfs/mod.rs

@@ -9,11 +9,8 @@ use alloc::{
 
 use crate::{
     filesystem::vfs::{core::generate_inode_id, FileType},
-    include::bindings::bindings::{
-        EEXIST, EINVAL, EISDIR, ENOBUFS, ENOENT, ENOTDIR, ENOTEMPTY, EPERM,
-    },
     libs::spinlock::{SpinLock, SpinLockGuard},
-    time::TimeSpec,
+    time::TimeSpec, syscall::SystemError,
 };
 
 use super::vfs::{
@@ -122,16 +119,16 @@ impl IndexNode for LockedRamFSInode {
         len: usize,
         buf: &mut [u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         if buf.len() < len {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
         // 加锁
         let inode: SpinLockGuard<RamFSInode> = self.0.lock();
 
         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
         if inode.metadata.file_type == FileType::Dir {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         let start = inode.data.len().min(offset);
@@ -139,7 +136,7 @@ impl IndexNode for LockedRamFSInode {
 
         // buffer空间不足
         if buf.len() < (end - start) {
-            return Err(-(ENOBUFS as i32));
+            return Err(SystemError::ENOBUFS);
         }
 
         // 拷贝数据
@@ -154,9 +151,9 @@ impl IndexNode for LockedRamFSInode {
         len: usize,
         buf: &[u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         if buf.len() < len {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
 
         // 加锁
@@ -164,7 +161,7 @@ impl IndexNode for LockedRamFSInode {
 
         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
         if inode.metadata.file_type == FileType::Dir {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         let data: &mut Vec<u8> = &mut inode.data;
@@ -179,13 +176,13 @@ impl IndexNode for LockedRamFSInode {
         return Ok(len);
     }
 
-    fn poll(&self) -> Result<PollStatus, i32> {
+    fn poll(&self) -> Result<PollStatus, SystemError> {
         // 加锁
         let inode: SpinLockGuard<RamFSInode> = self.0.lock();
 
         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
         if inode.metadata.file_type == FileType::Dir {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         return Ok(PollStatus {
@@ -201,7 +198,7 @@ impl IndexNode for LockedRamFSInode {
         self
     }
 
-    fn metadata(&self) -> Result<Metadata, i32> {
+    fn metadata(&self) -> Result<Metadata, SystemError> {
         let inode = self.0.lock();
         let mut metadata = inode.metadata.clone();
         metadata.size = inode.data.len() as i64;
@@ -209,7 +206,7 @@ impl IndexNode for LockedRamFSInode {
         return Ok(metadata);
     }
 
-    fn set_metadata(&self, metadata: &Metadata) -> Result<(), i32> {
+    fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
         let mut inode = self.0.lock();
         inode.metadata.atime = metadata.atime;
         inode.metadata.mtime = metadata.mtime;
@@ -221,13 +218,13 @@ impl IndexNode for LockedRamFSInode {
         return Ok(());
     }
 
-    fn resize(&self, len: usize) -> Result<(), i32> {
+    fn resize(&self, len: usize) -> Result<(), SystemError> {
         let mut inode = self.0.lock();
         if inode.metadata.file_type == FileType::File {
             inode.data.resize(len, 0);
             return Ok(());
         } else {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
     }
 
@@ -237,16 +234,16 @@ impl IndexNode for LockedRamFSInode {
         file_type: FileType,
         mode: u32,
         data: usize,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         // 获取当前inode
         let mut inode = self.0.lock();
         // 如果当前inode不是文件夹，则返回
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
         // 如果有重名的，则返回
         if inode.children.contains_key(name) {
-            return Err(-(EEXIST as i32));
+            return Err(SystemError::EEXIST);
         }
 
         // 创建inode
@@ -283,26 +280,26 @@ impl IndexNode for LockedRamFSInode {
         return Ok(result);
     }
 
-    fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), i32> {
+    fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
         let other: &LockedRamFSInode = other
             .downcast_ref::<LockedRamFSInode>()
-            .ok_or(-(EPERM as i32))?;
+            .ok_or(SystemError::EPERM)?;
         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
         let mut other_locked: SpinLockGuard<RamFSInode> = other.0.lock();
 
         // 如果当前inode不是文件夹，那么报错
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         // 如果另一个inode是文件夹，那么也报错
         if other_locked.metadata.file_type == FileType::Dir {
-            return Err(-(EISDIR as i32));
+            return Err(SystemError::EISDIR);
         }
 
         // 如果当前文件夹下已经有同名文件，也报错。
         if inode.children.contains_key(name) {
-            return Err(-(EEXIST as i32));
+            return Err(SystemError::EEXIST);
         }
 
         inode
@@ -314,21 +311,21 @@ impl IndexNode for LockedRamFSInode {
         return Ok(());
     }
 
-    fn unlink(&self, name: &str) -> Result<(), i32> {
+    fn unlink(&self, name: &str) -> Result<(), SystemError> {
         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
         // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
         // 不允许删除当前文件夹，也不允许删除上一个目录
         if name == "." || name == ".." {
-            return Err(-(ENOTEMPTY as i32));
+            return Err(SystemError::ENOTEMPTY);
         }
 
         // 获得要删除的文件的inode
-        let to_delete = inode.children.get(name).ok_or(-(ENOENT as i32))?;
+        let to_delete = inode.children.get(name).ok_or(SystemError::ENOENT)?;
         if to_delete.0.lock().metadata.file_type == FileType::Dir {
-            return Err(-(EPERM as i32));
+            return Err(SystemError::EPERM);
         }
         // 减少硬链接计数
         to_delete.0.lock().metadata.nlinks -= 1;
@@ -337,16 +334,16 @@ impl IndexNode for LockedRamFSInode {
         return Ok(());
     }
 
-    fn rmdir(&self, name: &str) -> Result<(), i32> {
+    fn rmdir(&self, name: &str) -> Result<(), SystemError> {
         let mut inode: SpinLockGuard<RamFSInode> = self.0.lock();
         // 如果当前inode不是目录，那么也没有子目录/文件的概念了，因此要求当前inode的类型是目录
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
         // 获得要删除的文件夹的inode
-        let to_delete = inode.children.get(name).ok_or(-(ENOENT as i32))?;
+        let to_delete = inode.children.get(name).ok_or(SystemError::ENOENT)?;
         if to_delete.0.lock().metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         to_delete.0.lock().metadata.nlinks -= 1;
@@ -360,7 +357,7 @@ impl IndexNode for LockedRamFSInode {
         old_name: &str,
         target: &Arc<dyn IndexNode>,
         new_name: &str,
-    ) -> Result<(), i32> {
+    ) -> Result<(), SystemError> {
         let old_inode: Arc<dyn IndexNode> = self.find(old_name)?;
 
         // 在新的目录下创建一个硬链接
@@ -374,32 +371,32 @@ impl IndexNode for LockedRamFSInode {
         return Ok(());
     }
 
-    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, i32> {
+    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
         let inode = self.0.lock();
 
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         match name {
             "" | "." => {
-                return Ok(inode.self_ref.upgrade().ok_or(-(ENOENT as i32))?);
+                return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?);
             }
 
             ".." => {
-                return Ok(inode.parent.upgrade().ok_or(-(ENOENT as i32))?);
+                return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?);
             }
             name => {
                 // 在子目录项中查找
-                return Ok(inode.children.get(name).ok_or(-(ENOENT as i32))?.clone());
+                return Ok(inode.children.get(name).ok_or(SystemError::ENOENT)?.clone());
             }
         }
     }
 
-    fn get_entry_name(&self, ino: InodeId) -> Result<String, i32> {
+    fn get_entry_name(&self, ino: InodeId) -> Result<String, SystemError> {
         let inode: SpinLockGuard<RamFSInode> = self.0.lock();
         if inode.metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         match ino {
@@ -420,7 +417,7 @@ impl IndexNode for LockedRamFSInode {
                     .collect();
 
                 match key.len() {
-                    0=>{return Err(-(ENOENT as i32));}
+                    0=>{return Err(SystemError::ENOENT);}
                     1=>{return Ok(key.remove(0));}
                     _ => panic!("Ramfs get_entry_name: key.len()={key_len}>1, current inode_id={inode_id}, to find={to_find}", key_len=key.len(), inode_id = inode.metadata.inode_id, to_find=ino)
                 }
@@ -428,10 +425,10 @@ impl IndexNode for LockedRamFSInode {
         }
     }
 
-    fn list(&self) -> Result<Vec<String>, i32> {
+    fn list(&self) -> Result<Vec<String>, SystemError> {
         let info = self.metadata()?;
         if info.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         let mut keys: Vec<String> = Vec::new();

kernel/src/filesystem/vfs/core.rs

@@ -16,9 +16,9 @@ use crate::{
         ramfs::RamFS,
         vfs::{file::File, mount::MountFS, FileSystem, FileType},
     },
-    include::bindings::bindings::{EBADF, ENAMETOOLONG, ENOENT, ENOTDIR, EPERM, PAGE_4K_SIZE},
+    include::bindings::bindings::{PAGE_4K_SIZE},
     io::SeekFrom,
-    kerror, kinfo,
+    kerror, kinfo, syscall::SystemError,
 };
 
 use super::{file::FileMode, utils::rsplit_path, IndexNode, InodeId};
@@ -99,7 +99,7 @@ fn do_migrate(
     new_root_inode: Arc<dyn IndexNode>,
     mountpoint_name: &str,
     fs: &MountFS,
-) -> Result<(), i32> {
+) -> Result<(), SystemError> {
     let r = new_root_inode.find(mountpoint_name);
     let mountpoint = if r.is_err() {
         new_root_inode
@@ -117,7 +117,7 @@ fn do_migrate(
 
 /// @brief 迁移伪文件系统的inode
 /// 请注意，为了避免删掉了伪文件系统内的信息，因此没有在原root inode那里调用unlink.
-fn migrate_virtual_filesystem(new_fs: Arc<dyn FileSystem>) -> Result<(), i32> {
+fn migrate_virtual_filesystem(new_fs: Arc<dyn FileSystem>) -> Result<(), SystemError> {
     kinfo!("VFS: Migrating filesystems...");
 
     // ==== 在这里获取要被迁移的文件系统的inode ===
@@ -160,7 +160,7 @@ pub extern "C" fn mount_root_fs() -> i32 {
             .partitions[0]
             .clone();
 
-    let fatfs: Result<Arc<FATFileSystem>, i32> = FATFileSystem::new(partiton);
+    let fatfs: Result<Arc<FATFileSystem>, SystemError> = FATFileSystem::new(partiton);
     if fatfs.is_err() {
         kerror!(
             "Failed to initialize fatfs, code={:?}",
@@ -184,20 +184,20 @@ pub extern "C" fn mount_root_fs() -> i32 {
 }
 
 /// @brief 为当前进程打开一个文件
-pub fn do_open(path: &str, mode: FileMode) -> Result<i32, i32> {
+pub fn do_open(path: &str, mode: FileMode) -> Result<i32, SystemError> {
     // 文件名过长
     if path.len() > PAGE_4K_SIZE as usize {
-        return Err(-(ENAMETOOLONG as i32));
+        return Err(SystemError::ENAMETOOLONG);
     }
 
-    let inode: Result<Arc<dyn IndexNode>, i32> = ROOT_INODE().lookup(path);
+    let inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().lookup(path);
 
     let inode: Arc<dyn IndexNode> = if inode.is_err() {
         let errno = inode.unwrap_err();
         // 文件不存在，且需要创建
         if mode.contains(FileMode::O_CREAT)
             && !mode.contains(FileMode::O_DIRECTORY)
-            && errno == -(ENOENT as i32)
+            && errno == SystemError::ENOENT
         {
             let (filename, parent_path) = rsplit_path(path);
             // 查找父目录
@@ -217,7 +217,7 @@ pub fn do_open(path: &str, mode: FileMode) -> Result<i32, i32> {
     let file_type: FileType = inode.metadata()?.file_type;
     // 如果要打开的是文件夹，而目标不是文件夹
     if mode.contains(FileMode::O_DIRECTORY) && file_type != FileType::Dir {
-        return Err(-(ENOTDIR as i32));
+        return Err(SystemError::ENOTDIR);
     }
 
     // 如果O_TRUNC，并且，打开模式包含O_RDWR或O_WRONLY，清空文件
@@ -246,11 +246,11 @@ pub fn do_open(path: &str, mode: FileMode) -> Result<i32, i32> {
 /// @param buf 输出缓冲区。
 ///
 /// @return Ok(usize) 成功读取的数据的字节数
-/// @return Err(i32) 读取失败，返回posix错误码
-pub fn do_read(fd: i32, buf: &mut [u8]) -> Result<usize, i32> {
+/// @return Err(SystemError) 读取失败，返回posix错误码
+pub fn do_read(fd: i32, buf: &mut [u8]) -> Result<usize, SystemError> {
     let file: Option<&mut File> = current_pcb().get_file_mut_by_fd(fd);
     if file.is_none() {
-        return Err(-(EBADF as i32));
+        return Err(SystemError::EBADF);
     }
     let file: &mut File = file.unwrap();
 
@@ -263,11 +263,11 @@ pub fn do_read(fd: i32, buf: &mut [u8]) -> Result<usize, i32> {
 /// @param buf 输入缓冲区。
 ///
 /// @return Ok(usize) 成功写入的数据的字节数
-/// @return Err(i32) 写入失败，返回posix错误码
-pub fn do_write(fd: i32, buf: &[u8]) -> Result<usize, i32> {
+/// @return Err(SystemError) 写入失败，返回posix错误码
+pub fn do_write(fd: i32, buf: &[u8]) -> Result<usize, SystemError> {
     let file: Option<&mut File> = current_pcb().get_file_mut_by_fd(fd);
     if file.is_none() {
-        return Err(-(EBADF as i32));
+        return Err(SystemError::EBADF);
     }
     let file: &mut File = file.unwrap();
 
@@ -280,29 +280,29 @@ pub fn do_write(fd: i32, buf: &[u8]) -> Result<usize, i32> {
 /// @param seek 调整的方式
 ///
 /// @return Ok(usize) 调整后，文件访问指针相对于文件头部的偏移量
-/// @return Err(i32) 调整失败，返回posix错误码
-pub fn do_lseek(fd: i32, seek: SeekFrom) -> Result<usize, i32> {
+/// @return Err(SystemError) 调整失败，返回posix错误码
+pub fn do_lseek(fd: i32, seek: SeekFrom) -> Result<usize, SystemError> {
     let file: Option<&mut File> = current_pcb().get_file_mut_by_fd(fd);
     if file.is_none() {
-        return Err(-(EBADF as i32));
+        return Err(SystemError::EBADF);
     }
     let file: &mut File = file.unwrap();
     return file.lseek(seek);
 }
 
 /// @brief 创建文件/文件夹
-pub fn do_mkdir(path: &str, _mode: FileMode) -> Result<u64, i32> {
+pub fn do_mkdir(path: &str, _mode: FileMode) -> Result<u64, SystemError> {
     // 文件名过长
     if path.len() > PAGE_4K_SIZE as usize {
-        return Err(-(ENAMETOOLONG as i32));
+        return Err(SystemError::ENAMETOOLONG);
     }
 
-    let inode: Result<Arc<dyn IndexNode>, i32> = ROOT_INODE().lookup(path);
+    let inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().lookup(path);
 
     if inode.is_err() {
         let errno = inode.unwrap_err();
         // 文件不存在，且需要创建
-        if errno == -(ENOENT as i32) {
+        if errno == SystemError::ENOENT {
             let (filename, parent_path) = rsplit_path(path);
             // 查找父目录
             let parent_inode: Arc<dyn IndexNode> =
@@ -320,19 +320,19 @@ pub fn do_mkdir(path: &str, _mode: FileMode) -> Result<u64, i32> {
 }
 
 /// @breif 删除文件夹
-pub fn do_remove_dir(path: &str) -> Result<u64, i32> {
+pub fn do_remove_dir(path: &str) -> Result<u64, SystemError> {
     // 文件名过长
     if path.len() > PAGE_4K_SIZE as usize {
-        return Err(-(ENAMETOOLONG as i32));
+        return Err(SystemError::ENAMETOOLONG);
     }
 
-    let inode: Result<Arc<dyn IndexNode>, i32> = ROOT_INODE().lookup(path);
+    let inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().lookup(path);
 
     if inode.is_err() {
         let errno = inode.unwrap_err();
         // 文件不存在
-        if errno == -(ENOENT as i32) {
-            return Err(-(ENOENT as i32));
+        if errno == SystemError::ENOENT {
+            return Err(SystemError::ENOENT);
         }
     }
 
@@ -341,12 +341,12 @@ pub fn do_remove_dir(path: &str) -> Result<u64, i32> {
     let parent_inode: Arc<dyn IndexNode> = ROOT_INODE().lookup(parent_path.unwrap_or("/"))?;
 
     if parent_inode.metadata()?.file_type != FileType::Dir {
-        return Err(-(ENOTDIR as i32));
+        return Err(SystemError::ENOTDIR);
     }
 
     let target_inode: Arc<dyn IndexNode> = parent_inode.find(filename)?;
     if target_inode.metadata()?.file_type != FileType::Dir {
-        return Err(-(ENOTDIR as i32));
+        return Err(SystemError::ENOTDIR);
     }
 
     // 删除文件夹
@@ -356,24 +356,24 @@ pub fn do_remove_dir(path: &str) -> Result<u64, i32> {
 }
 
 /// @brief 删除文件
-pub fn do_unlink_at(path: &str, _mode: FileMode) -> Result<u64, i32> {
+pub fn do_unlink_at(path: &str, _mode: FileMode) -> Result<u64, SystemError> {
     // 文件名过长
     if path.len() > PAGE_4K_SIZE as usize {
-        return Err(-(ENAMETOOLONG as i32));
+        return Err(SystemError::ENAMETOOLONG);
     }
 
-    let inode: Result<Arc<dyn IndexNode>, i32> = ROOT_INODE().lookup(path);
+    let inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().lookup(path);
 
     if inode.is_err() {
         let errno = inode.clone().unwrap_err();
         // 文件不存在，且需要创建
-        if errno == -(ENOENT as i32) {
-            return Err(-(ENOENT as i32));
+        if errno == SystemError::ENOENT {
+            return Err(SystemError::ENOENT);
         }
     }
     // 禁止在目录上unlink
     if inode.unwrap().metadata()?.file_type == FileType::Dir {
-        return Err(-(EPERM as i32));
+        return Err(SystemError::EPERM);
     }
 
     let (filename, parent_path) = rsplit_path(path);
@@ -381,7 +381,7 @@ pub fn do_unlink_at(path: &str, _mode: FileMode) -> Result<u64, i32> {
     let parent_inode: Arc<dyn IndexNode> = ROOT_INODE().lookup(parent_path.unwrap_or("/"))?;
 
     if parent_inode.metadata()?.file_type != FileType::Dir {
-        return Err(-(ENOTDIR as i32));
+        return Err(SystemError::ENOTDIR);
     }
 
     // 删除文件

kernel/src/filesystem/vfs/file.rs

@@ -7,10 +7,10 @@ use crate::{
     driver::tty::TtyFilePrivateData,
     filesystem::procfs::ProcfsFilePrivateData,
     include::bindings::bindings::{
-        process_control_block, EINVAL, ENOBUFS, EOVERFLOW, EPERM, ESPIPE,
+        process_control_block,
     },
     io::SeekFrom,
-    kerror,
+    kerror, syscall::SystemError,
 };
 
 use super::{Dirent, FileType, IndexNode, Metadata};
@@ -99,7 +99,7 @@ impl File {
     ///
     /// @param inode 文件对象对应的inode
     /// @param mode 文件的打开模式
-    pub fn new(inode: Arc<dyn IndexNode>, mode: FileMode) -> Result<Self, i32> {
+    pub fn new(inode: Arc<dyn IndexNode>, mode: FileMode) -> Result<Self, SystemError> {
         let file_type: FileType = inode.metadata()?.file_type;
         let mut f = File {
             inode,
@@ -120,13 +120,13 @@ impl File {
     /// @param buf 目标buffer
     ///
     /// @return Ok(usize) 成功读取的字节数
-    /// @return Err(i32) 错误码
-    pub fn read(&mut self, len: usize, buf: &mut [u8]) -> Result<usize, i32> {
+    /// @return Err(SystemError) 错误码
+    pub fn read(&mut self, len: usize, buf: &mut [u8]) -> Result<usize, SystemError> {
         // 先检查本文件在权限等规则下，是否可读取。
         self.readable()?;
 
         if buf.len() < len {
-            return Err(-(ENOBUFS as i32));
+            return Err(SystemError::ENOBUFS);
         }
 
         let len = self
@@ -142,12 +142,12 @@ impl File {
     /// @param buf 源数据buffer
     ///
     /// @return Ok(usize) 成功写入的字节数
-    /// @return Err(i32) 错误码
-    pub fn write(&mut self, len: usize, buf: &[u8]) -> Result<usize, i32> {
+    /// @return Err(SystemError) 错误码
+    pub fn write(&mut self, len: usize, buf: &[u8]) -> Result<usize, SystemError> {
         // 先检查本文件在权限等规则下，是否可写入。
         self.writeable()?;
         if buf.len() < len {
-            return Err(-(ENOBUFS as i32));
+            return Err(SystemError::ENOBUFS);
         }
         let len = self
             .inode
@@ -157,21 +157,21 @@ impl File {
     }
 
     /// @brief 获取文件的元数据
-    pub fn metadata(&self) -> Result<Metadata, i32> {
+    pub fn metadata(&self) -> Result<Metadata, SystemError> {
         return self.inode.metadata();
     }
 
     /// @brief 根据inode号获取子目录项的名字
-    pub fn get_entry_name(&self, ino: usize) -> Result<String, i32> {
+    pub fn get_entry_name(&self, ino: usize) -> Result<String, SystemError> {
         return self.inode.get_entry_name(ino);
     }
 
     /// @brief 调整文件操作指针的位置
     ///
     /// @param origin 调整的起始位置
-    pub fn lseek(&mut self, origin: SeekFrom) -> Result<usize, i32> {
+    pub fn lseek(&mut self, origin: SeekFrom) -> Result<usize, SystemError> {
         if self.inode.metadata().unwrap().file_type == FileType::Pipe {
-            return Err(-(ESPIPE as i32));
+            return Err(SystemError::ESPIPE);
         }
         let pos: i64;
         match origin {
@@ -186,12 +186,12 @@ impl File {
                 pos = metadata.size + offset;
             }
             SeekFrom::Invalid => {
-                return Err(-(EINVAL as i32));
+                return Err(SystemError::EINVAL);
             }
         }
 
         if pos < 0 || pos > self.metadata()?.size {
-            return Err(-(EOVERFLOW as i32));
+            return Err(SystemError::EOVERFLOW);
         }
         self.offset = pos as usize;
         return Ok(self.offset);
@@ -199,10 +199,10 @@ impl File {
 
     /// @brief 判断当前文件是否可读
     #[inline]
-    pub fn readable(&self) -> Result<(), i32> {
+    pub fn readable(&self) -> Result<(), SystemError> {
         // 暂时认为只要不是write only, 就可读
         if self.mode == FileMode::O_WRONLY {
-            return Err(-(EPERM as i32));
+            return Err(SystemError::EPERM);
         }
 
         return Ok(());
@@ -210,10 +210,10 @@ impl File {
 
     /// @brief 判断当前文件是否可写
     #[inline]
-    pub fn writeable(&self) -> Result<(), i32> {
+    pub fn writeable(&self) -> Result<(), SystemError> {
         // 暂时认为只要不是read only, 就可写
         if self.mode == FileMode::O_RDONLY {
-            return Err(-(EPERM as i32));
+            return Err(SystemError::EPERM);
         }
 
         return Ok(());
@@ -221,7 +221,7 @@ impl File {
 
     /// @biref 充填dirent结构体
     /// @return 返回dirent结构体的大小
-    pub fn readdir(&mut self, dirent: &mut Dirent) -> Result<u64, i32> {
+    pub fn readdir(&mut self, dirent: &mut Dirent) -> Result<u64, SystemError> {
         let inode: &Arc<dyn IndexNode> = &self.inode;
 
         // 如果偏移量为0
@@ -291,11 +291,11 @@ impl File {
 
 impl Drop for File {
     fn drop(&mut self) {
-        let r: Result<(), i32> = self.inode.close(&mut self.private_data);
+        let r: Result<(), SystemError> = self.inode.close(&mut self.private_data);
         // 打印错误信息
         if r.is_err() {
             kerror!(
-                "pid: {} failed to close file: {:?}, errno={}",
+                "pid: {} failed to close file: {:?}, errno={:?}",
                 current_pcb().pid,
                 self,
                 r.unwrap_err()

kernel/src/filesystem/vfs/mod.rs

@@ -11,8 +11,8 @@ use ::core::{any::Any, fmt::Debug};
 use alloc::{string::String, sync::Arc, vec::Vec};
 
 use crate::{
-    include::bindings::bindings::{ENOTDIR, ENOTSUP},
     time::TimeSpec,
+    syscall::SystemError,
 };
 
 use self::file::FileMode;
@@ -92,18 +92,18 @@ pub trait IndexNode: Any + Sync + Send + Debug {
     ///
     /// @return 成功：Ok()
     ///         失败：Err(错误码)
-    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), i32> {
+    fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 关闭文件
     ///
     /// @return 成功：Ok()
     ///         失败：Err(错误码)
-    fn close(&self, _data: &mut FilePrivateData) -> Result<(), i32> {
+    fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 在inode的指定偏移量开始，读取指定大小的数据
@@ -121,7 +121,7 @@ pub trait IndexNode: Any + Sync + Send + Debug {
         len: usize,
         buf: &mut [u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32>;
+    ) -> Result<usize, SystemError>;
 
     /// @brief 在inode的指定偏移量开始，写入指定大小的数据（从buf的第0byte开始写入）
     ///
@@ -138,38 +138,38 @@ pub trait IndexNode: Any + Sync + Send + Debug {
         len: usize,
         buf: &[u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32>;
+    ) -> Result<usize, SystemError>;
 
     /// @brief 获取当前inode的状态。
     ///
     /// @return PollStatus结构体
-    fn poll(&self) -> Result<PollStatus, i32>;
+    fn poll(&self) -> Result<PollStatus, SystemError>;
 
     /// @brief 获取inode的元数据
     ///
     /// @return 成功：Ok(inode的元数据)
     ///         失败：Err(错误码)
-    fn metadata(&self) -> Result<Metadata, i32> {
+    fn metadata(&self) -> Result<Metadata, SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 设置inode的元数据
     ///
     /// @return 成功：Ok()
     ///         失败：Err(错误码)
-    fn set_metadata(&self, _metadata: &Metadata) -> Result<(), i32> {
+    fn set_metadata(&self, _metadata: &Metadata) -> Result<(), SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 重新设置文件的大小
     ///
     /// @return 成功：Ok()
     ///         失败：Err(错误码)
-    fn resize(&self, _len: usize) -> Result<(), i32> {
+    fn resize(&self, _len: usize) -> Result<(), SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 在当前目录下创建一个新的inode
@@ -185,7 +185,7 @@ pub trait IndexNode: Any + Sync + Send + Debug {
         name: &str,
         file_type: FileType,
         mode: u32,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         // 若文件系统没有实现此方法，则默认调用其create_with_data方法。如果仍未实现，则会得到一个Err(-ENOTSUP)的返回值
         return self.create_with_data(name, file_type, mode, 0);
     }
@@ -205,9 +205,9 @@ pub trait IndexNode: Any + Sync + Send + Debug {
         _file_type: FileType,
         _mode: u32,
         _data: usize,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 在当前目录下，创建一个名为Name的硬链接，指向另一个IndexNode
@@ -217,9 +217,9 @@ pub trait IndexNode: Any + Sync + Send + Debug {
     ///
     /// @return 成功：Ok()
     ///         失败：Err(错误码)
-    fn link(&self, _name: &str, _other: &Arc<dyn IndexNode>) -> Result<(), i32> {
+    fn link(&self, _name: &str, _other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 在当前目录下，删除一个名为Name的硬链接
@@ -228,9 +228,9 @@ pub trait IndexNode: Any + Sync + Send + Debug {
     ///
     /// @return 成功：Ok()
     ///         失败：Err(错误码)
-    fn unlink(&self, _name: &str) -> Result<(), i32> {
+    fn unlink(&self, _name: &str) -> Result<(), SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 删除文件夹
@@ -239,8 +239,8 @@ pub trait IndexNode: Any + Sync + Send + Debug {
     /// 
     /// @return 成功 Ok(())
     /// @return 失败 Err(错误码)
-    fn rmdir(&self, _name: &str) ->Result<(), i32>{
-        return Err(-(ENOTSUP as i32));
+    fn rmdir(&self, _name: &str) ->Result<(), SystemError>{
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 将指定名称的子目录项的文件内容，移动到target这个目录下。如果_old_name所指向的inode与_target的相同，那么则直接执行重命名的操作。
@@ -258,9 +258,9 @@ pub trait IndexNode: Any + Sync + Send + Debug {
         _old_name: &str,
         _target: &Arc<dyn IndexNode>,
         _new_name: &str,
-    ) -> Result<(), i32> {
+    ) -> Result<(), SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 寻找一个名为Name的inode
@@ -269,9 +269,9 @@ pub trait IndexNode: Any + Sync + Send + Debug {
     ///
     /// @return 成功：Ok()
     ///         失败：Err(错误码)
-    fn find(&self, _name: &str) -> Result<Arc<dyn IndexNode>, i32> {
+    fn find(&self, _name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 根据inode号，获取子目录项的名字
@@ -280,9 +280,9 @@ pub trait IndexNode: Any + Sync + Send + Debug {
     ///
     /// @return 成功：Ok()
     ///         失败：Err(错误码)
-    fn get_entry_name(&self, _ino: InodeId) -> Result<String, i32> {
+    fn get_entry_name(&self, _ino: InodeId) -> Result<String, SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 根据inode号，获取子目录项的名字和元数据
@@ -291,7 +291,7 @@ pub trait IndexNode: Any + Sync + Send + Debug {
     ///
     /// @return 成功：Ok(String, Metadata)
     ///         失败：Err(错误码)
-    fn get_entry_name_and_metadata(&self, ino: InodeId) -> Result<(String, Metadata), i32> {
+    fn get_entry_name_and_metadata(&self, ino: InodeId) -> Result<(String, Metadata), SystemError> {
         // 如果有条件，请在文件系统中使用高效的方式实现本接口，而不是依赖这个低效率的默认实现。
         let name = self.get_entry_name(ino)?;
         let entry = self.find(&name)?;
@@ -305,9 +305,9 @@ pub trait IndexNode: Any + Sync + Send + Debug {
     ///
     /// @return 成功：Ok()
     ///         失败：Err(错误码)
-    fn ioctl(&self, _cmd: u32, _data: usize) -> Result<usize, i32> {
+    fn ioctl(&self, _cmd: u32, _data: usize) -> Result<usize, SystemError> {
         // 若文件系统没有实现此方法，则返回“不支持”
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 获取inode所在的文件系统的指针
@@ -318,19 +318,19 @@ pub trait IndexNode: Any + Sync + Send + Debug {
     fn as_any_ref(&self) -> &dyn Any;
 
     /// @brief 列出当前inode下的所有目录项的名字
-    fn list(&self) -> Result<Vec<String>, i32>;
+    fn list(&self) -> Result<Vec<String>, SystemError>;
 
     /// @brief 在当前Inode下，挂载一个新的文件系统
     /// 请注意！该函数只能被MountFS实现，其他文件系统不应实现这个函数
-    fn mount(&self, _fs: Arc<dyn FileSystem>) -> Result<Arc<MountFS>, i32> {
-        return Err(-(ENOTSUP as i32));
+    fn mount(&self, _fs: Arc<dyn FileSystem>) -> Result<Arc<MountFS>, SystemError> {
+        return Err(SystemError::ENOTSUP);
     }
 
     /// @brief 截断当前inode到指定的长度。如果当前文件长度小于len,则不操作。
     ///
     /// @param len 要被截断到的目标长度
-    fn truncate(&self, _len: usize) -> Result<(), i32> {
-        return Err(-(ENOTSUP as i32));
+    fn truncate(&self, _len: usize) -> Result<(), SystemError> {
+        return Err(SystemError::ENOTSUP);
     }
 }
 
@@ -346,8 +346,8 @@ impl dyn IndexNode {
     /// @param path 文件路径
     ///
     /// @return Ok(Arc<dyn IndexNode>) 要寻找的目录项的inode
-    /// @return Err(i32) 错误码
-    pub fn lookup(&self, path: &str) -> Result<Arc<dyn IndexNode>, i32> {
+    /// @return Err(SystemError) 错误码
+    pub fn lookup(&self, path: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
         return self.lookup_follow_symlink(path, 0);
     }
 
@@ -357,14 +357,14 @@ impl dyn IndexNode {
     /// @param max_follow_times 最大经过的符号链接的大小
     ///
     /// @return Ok(Arc<dyn IndexNode>) 要寻找的目录项的inode
-    /// @return Err(i32) 错误码
+    /// @return Err(SystemError) 错误码
     pub fn lookup_follow_symlink(
         &self,
         path: &str,
         max_follow_times: usize,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         if self.metadata()?.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         // 处理绝对路径
@@ -381,7 +381,7 @@ impl dyn IndexNode {
         while !rest_path.is_empty() {
             // 当前这一级不是文件夹
             if result.metadata()?.file_type != FileType::Dir {
-                return Err(-(ENOTDIR as i32));
+                return Err(SystemError::ENOTDIR);
             }
 
             let name;
@@ -415,7 +415,7 @@ impl dyn IndexNode {
 
                 // 将读到的数据转换为utf8字符串（先转为str，再转为String）
                 let link_path = String::from(
-                    ::core::str::from_utf8(&content[..len]).map_err(|_| -(ENOTDIR as i32))?,
+                    ::core::str::from_utf8(&content[..len]).map_err(|_| SystemError::ENOTDIR)?,
                 );
 
                 let new_path = link_path + "/" + &rest_path;

kernel/src/filesystem/vfs/mount.rs

@@ -6,8 +6,7 @@ use alloc::{
 };
 
 use crate::{
-    include::bindings::bindings::{EBUSY, ENOTDIR},
-    libs::spinlock::SpinLock,
+    libs::spinlock::SpinLock, syscall::SystemError,
 };
 
 use super::{FilePrivateData, FileSystem, FileType, IndexNode, InodeId, file::FileMode};
@@ -104,7 +103,7 @@ impl MountFSInode {
     }
 
     /// @brief 判断当前inode是否为它所在的文件系统的root inode
-    fn is_mountpoint_root(&self) -> Result<bool, i32> {
+    fn is_mountpoint_root(&self) -> Result<bool, SystemError> {
         return Ok(self.inner_inode.fs().root_inode().metadata()?.inode_id
             == self.inner_inode.metadata()?.inode_id);
     }
@@ -126,11 +125,11 @@ impl MountFSInode {
 }
 
 impl IndexNode for MountFSInode {
-    fn open(&self, data: &mut FilePrivateData, mode: &FileMode) -> Result<(), i32> {
+    fn open(&self, data: &mut FilePrivateData, mode: &FileMode) -> Result<(), SystemError> {
         return self.inner_inode.open(data, mode);
     }
 
-    fn close(&self, data: &mut FilePrivateData) -> Result<(), i32> {
+    fn close(&self, data: &mut FilePrivateData) -> Result<(), SystemError> {
         return self.inner_inode.close(data);
     }
 
@@ -140,13 +139,13 @@ impl IndexNode for MountFSInode {
         file_type: FileType,
         mode: u32,
         data: usize,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         return self
             .inner_inode
             .create_with_data(name, file_type, mode, data);
     }
 
-    fn truncate(&self, len: usize) -> Result<(), i32> {
+    fn truncate(&self, len: usize) -> Result<(), SystemError> {
         return self.inner_inode.truncate(len);
     }
 
@@ -156,7 +155,7 @@ impl IndexNode for MountFSInode {
         len: usize,
         buf: &mut [u8],
         data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         return self.inner_inode.read_at(offset, len, buf, data);
     }
 
@@ -166,14 +165,14 @@ impl IndexNode for MountFSInode {
         len: usize,
         buf: &[u8],
         _data: &mut FilePrivateData,
-    ) -> Result<usize, i32> {
+    ) -> Result<usize, SystemError> {
         return self
             .inner_inode
             .write_at(offset, len, buf, &mut FilePrivateData::Unused);
     }
 
     #[inline]
-    fn poll(&self) -> Result<super::PollStatus, i32> {
+    fn poll(&self) -> Result<super::PollStatus, SystemError> {
         return self.inner_inode.poll();
     }
 
@@ -188,17 +187,17 @@ impl IndexNode for MountFSInode {
     }
 
     #[inline]
-    fn metadata(&self) -> Result<super::Metadata, i32> {
+    fn metadata(&self) -> Result<super::Metadata, SystemError> {
         return self.inner_inode.metadata();
     }
 
     #[inline]
-    fn set_metadata(&self, metadata: &super::Metadata) -> Result<(), i32> {
+    fn set_metadata(&self, metadata: &super::Metadata) -> Result<(), SystemError> {
         return self.inner_inode.set_metadata(metadata);
     }
 
     #[inline]
-    fn resize(&self, len: usize) -> Result<(), i32> {
+    fn resize(&self, len: usize) -> Result<(), SystemError> {
         return self.inner_inode.resize(len);
     }
 
@@ -208,7 +207,7 @@ impl IndexNode for MountFSInode {
         name: &str,
         file_type: FileType,
         mode: u32,
-    ) -> Result<Arc<dyn IndexNode>, i32> {
+    ) -> Result<Arc<dyn IndexNode>, SystemError> {
         return Ok(MountFSInode {
             inner_inode: self.inner_inode.create(name, file_type, mode)?,
             mount_fs: self.mount_fs.clone(),
@@ -217,30 +216,30 @@ impl IndexNode for MountFSInode {
         .wrap());
     }
 
-    fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), i32> {
+    fn link(&self, name: &str, other: &Arc<dyn IndexNode>) -> Result<(), SystemError> {
         return self.inner_inode.link(name, other);
     }
 
     /// @brief 在挂载文件系统中删除文件/文件夹
     #[inline]
-    fn unlink(&self, name: &str) -> Result<(), i32> {
+    fn unlink(&self, name: &str) -> Result<(), SystemError> {
         let inode_id = self.inner_inode.find(name)?.metadata()?.inode_id;
 
         // 先检查这个inode是否为一个挂载点，如果当前inode是一个挂载点，那么就不能删除这个inode
         if self.mount_fs.mountpoints.lock().contains_key(&inode_id) {
-            return Err(-(EBUSY as i32));
+            return Err(SystemError::EBUSY);
         }
         // 调用内层的inode的方法来删除这个inode
         return self.inner_inode.unlink(name);
     }
 
     #[inline]
-    fn rmdir(&self, name: &str) -> Result<(), i32> {
+    fn rmdir(&self, name: &str) -> Result<(), SystemError> {
         let inode_id = self.inner_inode.find(name)?.metadata()?.inode_id;
 
         // 先检查这个inode是否为一个挂载点，如果当前inode是一个挂载点，那么就不能删除这个inode
         if self.mount_fs.mountpoints.lock().contains_key(&inode_id) {
-            return Err(-(EBUSY as i32));
+            return Err(SystemError::EBUSY);
         }
         // 调用内层的rmdir的方法来删除这个inode
         let r = self.inner_inode.rmdir(name);
@@ -254,11 +253,11 @@ impl IndexNode for MountFSInode {
         old_name: &str,
         target: &Arc<dyn IndexNode>,
         new_name: &str,
-    ) -> Result<(), i32> {
+    ) -> Result<(), SystemError> {
         return self.inner_inode.move_(old_name, target, new_name);
     }
 
-    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, i32> {
+    fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
         match name {
             // 查找的是当前目录
             "" | "." => return Ok(self.self_ref.upgrade().unwrap()),
@@ -300,7 +299,7 @@ impl IndexNode for MountFSInode {
     }
 
     #[inline]
-    fn get_entry_name(&self, ino: InodeId) -> Result<alloc::string::String, i32> {
+    fn get_entry_name(&self, ino: InodeId) -> Result<alloc::string::String, SystemError> {
         return self.inner_inode.get_entry_name(ino);
     }
 
@@ -308,27 +307,27 @@ impl IndexNode for MountFSInode {
     fn get_entry_name_and_metadata(
         &self,
         ino: InodeId,
-    ) -> Result<(alloc::string::String, super::Metadata), i32> {
+    ) -> Result<(alloc::string::String, super::Metadata), SystemError> {
         return self.inner_inode.get_entry_name_and_metadata(ino);
     }
 
     #[inline]
-    fn ioctl(&self, cmd: u32, data: usize) -> Result<usize, i32> {
+    fn ioctl(&self, cmd: u32, data: usize) -> Result<usize, SystemError> {
         return self.inner_inode.ioctl(cmd, data);
     }
 
     #[inline]
-    fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, i32> {
+    fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, SystemError> {
         return self.inner_inode.list();
     }
 
     /// @brief 在当前inode下，挂载一个文件系统
     ///
     /// @return Ok(Arc<MountFS>) 挂载成功，返回指向MountFS的指针
-    fn mount(&self, fs: Arc<dyn FileSystem>) -> Result<Arc<MountFS>, i32> {
+    fn mount(&self, fs: Arc<dyn FileSystem>) -> Result<Arc<MountFS>, SystemError> {
         let metadata = self.inner_inode.metadata()?;
         if metadata.file_type != FileType::Dir {
-            return Err(-(ENOTDIR as i32));
+            return Err(SystemError::ENOTDIR);
         }
 
         // 为新的挂载点创建挂载文件系统

kernel/src/filesystem/vfs/syscall.rs

@@ -5,11 +5,10 @@ use alloc::{boxed::Box, string::ToString};
 use crate::{
     arch::asm::{current::current_pcb, ptrace::user_mode},
     include::bindings::bindings::{
-        pt_regs, verify_area, AT_REMOVEDIR, EBADF, EFAULT, EINVAL, ENAMETOOLONG, ENOENT, ENOTDIR,
-        EPERM, PAGE_2M_SIZE, PAGE_4K_SIZE, PROC_MAX_FD_NUM, SEEK_CUR, SEEK_END, SEEK_MAX, SEEK_SET,
+        pt_regs, verify_area, AT_REMOVEDIR, PAGE_2M_SIZE, PAGE_4K_SIZE, PROC_MAX_FD_NUM, SEEK_CUR, SEEK_END, SEEK_MAX, SEEK_SET,
     },
     io::SeekFrom,
-    kerror,
+    kerror, syscall::SystemError,
 };
 
 use super::{
@@ -29,17 +28,17 @@ pub extern "C" fn sys_open(regs: &pt_regs) -> u64 {
     let path: &CStr = unsafe { CStr::from_ptr(regs.r8 as usize as *const c_char) };
     let path: Result<&str, core::str::Utf8Error> = path.to_str();
     if path.is_err() {
-        return (-(EINVAL as i32)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
     let path: &str = path.unwrap();
     let flags = regs.r9;
     let open_flags: FileMode = FileMode::from_bits_truncate(flags as u32);
-    let r: Result<i32, i32> = do_open(path, open_flags);
+    let r: Result<i32, SystemError> = do_open(path, open_flags);
 
     if r.is_ok() {
         return r.unwrap() as u64;
     } else {
-        return r.unwrap_err() as u64;
+        return r.unwrap_err().to_posix_errno() as u64;
     }
 }
 
@@ -49,12 +48,12 @@ pub extern "C" fn sys_open(regs: &pt_regs) -> u64 {
 #[no_mangle]
 pub extern "C" fn sys_close(regs: &pt_regs) -> u64 {
     let fd = regs.r8 as i32;
-    let r: Result<(), i32> = current_pcb().drop_fd(fd);
+    let r: Result<(), SystemError> = current_pcb().drop_fd(fd);
 
     if r.is_ok() {
         return 0;
     } else {
-        return r.unwrap_err() as u64;
+        return r.unwrap_err().to_posix_errno() as u64;
     }
 }
 
@@ -72,18 +71,18 @@ pub extern "C" fn sys_read(regs: &pt_regs) -> u64 {
     // 判断缓冲区是否来自用户态，进行权限校验
     if user_mode(regs) && unsafe { !verify_area(buf_vaddr as u64, len as u64) } {
         // 来自用户态，而buffer在内核态，这样的操作不被允许
-        return (-(EPERM as i32)) as u64;
+        return SystemError::EPERM.to_posix_errno() as u64;
     }
 
     let buf: &mut [u8] =
         unsafe { core::slice::from_raw_parts_mut::<'static, u8>(buf_vaddr as *mut u8, len) };
 
-    let r: Result<usize, i32> = do_read(fd, buf);
+    let r: Result<usize, SystemError> = do_read(fd, buf);
 
     if r.is_ok() {
         return r.unwrap() as u64;
     } else {
-        return r.unwrap_err() as u64;
+        return r.unwrap_err().to_posix_errno() as u64;
     }
 }
 
@@ -101,18 +100,18 @@ pub extern "C" fn sys_write(regs: &pt_regs) -> u64 {
     // 判断缓冲区是否来自用户态，进行权限校验
     if user_mode(regs) && unsafe { !verify_area(buf_vaddr as u64, len as u64) } {
         // 来自用户态，而buffer在内核态，这样的操作不被允许
-        return (-(EPERM as i32)) as u64;
+        return SystemError::EPERM.to_posix_errno() as u64;
     }
 
     let buf: &[u8] =
         unsafe { core::slice::from_raw_parts::<'static, u8>(buf_vaddr as *mut u8, len) };
 
-    let r: Result<usize, i32> = do_write(fd, buf);
+    let r: Result<usize, SystemError> = do_write(fd, buf);
 
     if r.is_ok() {
         return r.unwrap() as u64;
     } else {
-        return r.unwrap_err() as u64;
+        return r.unwrap_err().to_posix_errno() as u64;
     }
 }
 
@@ -132,14 +131,14 @@ pub extern "C" fn sys_lseek(regs: &pt_regs) -> u64 {
         SEEK_CUR => SeekFrom::SeekCurrent(offset),
         SEEK_END => SeekFrom::SeekEnd(offset),
         SEEK_MAX => SeekFrom::SeekEnd(0),
-        _ => return (-(EINVAL as i32)) as u64,
+        _ => return SystemError::EINVAL.to_posix_errno() as u64,
     };
 
-    let r: Result<usize, i32> = do_lseek(fd, w);
+    let r: Result<usize, SystemError> = do_lseek(fd, w);
     if r.is_ok() {
         return r.unwrap() as u64;
     } else {
-        return r.unwrap_err() as u64;
+        return r.unwrap_err().to_posix_errno() as u64;
     }
 }
 
@@ -168,50 +167,50 @@ pub extern "C" fn sys_lseek(regs: &pt_regs) -> u64 {
 #[no_mangle]
 pub extern "C" fn sys_chdir(regs: &pt_regs) -> u64 {
     if regs.r8 == 0 {
-        return -(EFAULT as i32) as u64;
+        return SystemError::EFAULT.to_posix_errno() as u64;
     }
     let ptr = regs.r8 as usize as *const c_char;
     // 权限校验
     if ptr.is_null()
         || (user_mode(regs) && unsafe { !verify_area(ptr as u64, PAGE_2M_SIZE as u64) })
     {
-        return -(EINVAL as i32) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
 
     let dest_path: &CStr = unsafe { CStr::from_ptr(ptr) };
     let dest_path: Result<&str, core::str::Utf8Error> = dest_path.to_str();
 
     if dest_path.is_err() {
-        return (-(EINVAL as i32)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
 
     let dest_path: &str = dest_path.unwrap();
 
     if dest_path.len() == 0 {
-        return (-(EINVAL as i32)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     } else if dest_path.len() >= PAGE_4K_SIZE as usize {
-        return (-(ENAMETOOLONG as i32)) as u64;
+        return SystemError::ENAMETOOLONG.to_posix_errno() as u64;
     }
 
     let path = Box::new(dest_path.clone());
     let inode = match ROOT_INODE().lookup(&path) {
         Err(e) => {
-            kerror!("Change Directory Failed, Error = {}", e);
-            return (-(ENOENT as i32)) as u64;
+            kerror!("Change Directory Failed, Error = {:?}", e);
+            return SystemError::ENOENT.to_posix_errno() as u64;
         }
         Ok(i) => i,
     };
 
     match inode.metadata() {
         Err(e) => {
-            kerror!("INode Get MetaData Failed, Error = {}", e);
-            return (-(ENOENT as i32)) as u64;
+            kerror!("INode Get MetaData Failed, Error = {:?}", e);
+            return SystemError::ENOENT.to_posix_errno() as u64;
         }
         Ok(i) => {
             if let FileType::Dir = i.file_type {
                 return 0;
             } else {
-                return (-(ENOTDIR as i32)) as u64;
+                return SystemError::ENOTDIR.to_posix_errno() as u64;
             }
         }
     }
@@ -233,17 +232,17 @@ pub extern "C" fn sys_getdents(regs: &pt_regs) -> u64 {
     };
 
     if fd < 0 || fd as u32 > PROC_MAX_FD_NUM {
-        return (-(EBADF as i32)) as u64;
+        return SystemError::EBADF.to_posix_errno() as u64;
     }
 
     if count < 0 {
-        return (-(EINVAL as i32)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
 
     // 获取fd
     let file: &mut File = match current_pcb().get_file_mut_by_fd(fd) {
         None => {
-            return (-(EBADF as i32)) as u64;
+            return SystemError::EBADF.to_posix_errno() as u64;
         }
         Some(file) => file,
     };
@@ -266,25 +265,25 @@ pub extern "C" fn sys_mkdir(regs: &pt_regs) -> u64 {
     if ptr.is_null()
         || (user_mode(regs) && unsafe { !verify_area(ptr as u64, PAGE_2M_SIZE as u64) })
     {
-        return -(EINVAL as i32) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
     let path: &CStr = unsafe { CStr::from_ptr(ptr) };
     let path: Result<&str, core::str::Utf8Error> = path.to_str();
     let mode = regs.r9;
 
     if path.is_err() {
-        return (-(EINVAL as i32)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
 
     let path = &path.unwrap().to_string();
     if path.trim() == "" {
-        return (-(EINVAL as i32)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
 
     return match do_mkdir(&path.trim(), FileMode::from_bits_truncate(mode as u32)) {
         Err(err) => {
-            kerror!("Failed in do_mkdir, Error Code = {}", err);
-            err as u64
+            kerror!("Failed in do_mkdir, Error Code = {:#?}", err);
+            err.to_posix_errno() as u64
         }
         Ok(_) => 0,
     };
@@ -306,27 +305,27 @@ pub extern "C" fn sys_unlink_at(regs: &pt_regs) -> u64 {
     if ptr.is_null()
         || (user_mode(regs) && unsafe { !verify_area(ptr as u64, PAGE_2M_SIZE as u64) })
     {
-        return -(EINVAL as i32) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
     let path: &CStr = unsafe { CStr::from_ptr(ptr) };
     let path: Result<&str, core::str::Utf8Error> = path.to_str();
     let flag = regs.r10;
     if path.is_err() {
-        return (-(EINVAL as i32)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
 
     let path = &path.unwrap().to_string();
     // kdebug!("sys_unlink_at={path:?}");
     if (flag & (!(AT_REMOVEDIR as u64))) != 0_u64 {
-        return (-(EINVAL as i32)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
 
     if (flag & (AT_REMOVEDIR as u64)) > 0 {
         // kdebug!("rmdir");
         match do_remove_dir(&path) {
             Err(err) => {
-                kerror!("Failed to Remove Directory, Error Code = {}", err);
-                return err as u64;
+                kerror!("Failed to Remove Directory, Error Code = {:?}", err);
+                return err.to_posix_errno() as u64;
             }
             Ok(_) => {
                 return 0;
@@ -337,8 +336,8 @@ pub extern "C" fn sys_unlink_at(regs: &pt_regs) -> u64 {
     // kdebug!("rm");
     match do_unlink_at(&path, FileMode::from_bits_truncate(flag as u32)) {
         Err(err) => {
-            kerror!("Failed to Remove Directory, Error Code = {}", err);
-            return err as u64;
+            kerror!("Failed to Remove Directory, Error Code = {:?}", err);
+            return err.to_posix_errno() as u64;
         }
         Ok(_) => {
             return 0;

kernel/src/io/device.rs

@@ -1,5 +1,5 @@
 /// 引入Module
-use crate::include::bindings::bindings::E2BIG;
+use crate::{syscall::SystemError};
 use alloc::{sync::Arc, vec::Vec};
 use core::{any::Any, fmt::Debug};
 
@@ -32,17 +32,17 @@ pub trait Device: Any + Send + Sync + Debug {
     /// @parameter len: 读取字节的数量
     /// @parameter buf: 目标数组
     /// @return: 如果操作成功，返回操作的长度(单位是字节)；否则返回错误码；如果操作异常，但是并没有检查出什么错误，将返回已操作的长度
-    fn read_at(&self, offset: usize, len: usize, buf: &mut [u8]) -> Result<usize, i32>;
+    fn read_at(&self, offset: usize, len: usize, buf: &mut [u8]) -> Result<usize, SystemError>;
 
     /// @brief: 从设备的第offset个字节开始，把buf数组的len个byte，写入到设备中
     /// @parameter offset: 起始字节偏移量
     /// @parameter len: 读取字节的数量
     /// @parameter buf: 目标数组
     /// @return: 如果操作成功，返回操作的长度(单位是字节)；否则返回错误码；如果操作异常，但是并没有检查出什么错误，将返回已操作的长度
-    fn write_at(&self, offset: usize, len: usize, buf: &[u8]) -> Result<usize, i32>;
+    fn write_at(&self, offset: usize, len: usize, buf: &[u8]) -> Result<usize, SystemError>;
 
     /// @brief: 同步信息，把所有的dirty数据写回设备 - 待实现
-    fn sync(&self) -> Result<(), i32>;
+    fn sync(&self) -> Result<(), SystemError>;
 
     // TODO: 待实现 open, close
 
@@ -58,7 +58,7 @@ pub trait BlockDevice: Any + Send + Sync + Debug {
     /// @return: 如果操作成功，返回 Ok(操作的长度) 其中单位是字节；
     ///          否则返回Err(错误码)，其中错误码为负数；
     ///          如果操作异常，但是并没有检查出什么错误，将返回Err(已操作的长度)
-    fn read_at(&self, lba_id_start: BlockId, count: usize, buf: &mut [u8]) -> Result<usize, i32>;
+    fn read_at(&self, lba_id_start: BlockId, count: usize, buf: &mut [u8]) -> Result<usize, SystemError>;
 
     /// @brief: 在块设备中，从第lba_id_start个块开始，把buf中的count个块数据，存放到设备中
     /// @parameter lba_id_start: 起始块
@@ -67,10 +67,10 @@ pub trait BlockDevice: Any + Send + Sync + Debug {
     /// @return: 如果操作成功，返回 Ok(操作的长度) 其中单位是字节；
     ///          否则返回Err(错误码)，其中错误码为负数；
     ///          如果操作异常，但是并没有检查出什么错误，将返回Err(已操作的长度)
-    fn write_at(&self, lba_id_start: BlockId, count: usize, buf: &[u8]) -> Result<usize, i32>;
+    fn write_at(&self, lba_id_start: BlockId, count: usize, buf: &[u8]) -> Result<usize, SystemError>;
 
     /// @brief: 同步磁盘信息，把所有的dirty数据写回硬盘 - 待实现
-    fn sync(&self) -> Result<(), i32>;
+    fn sync(&self) -> Result<(), SystemError>;
 
     /// @breif: 每个块设备都必须固定自己块大小，而且该块大小必须是2的幂次
     /// @return: 返回一个固定量，硬编码(编程的时候固定的常量).
@@ -97,9 +97,9 @@ pub trait BlockDevice: Any + Send + Sync + Debug {
 /// 对于所有<块设备>自动实现 Device Trait 的 read_at 和 write_at 函数
 impl<T: BlockDevice> Device for T {
     // 读取设备操作，读取设备内部 [offset, offset + buf.len) 区间内的字符，存放到 buf 中
-    fn read_at(&self, offset: usize, len: usize, buf: &mut [u8]) -> Result<usize, i32> {
+    fn read_at(&self, offset: usize, len: usize, buf: &mut [u8]) -> Result<usize, SystemError> {
         if len > buf.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
 
         let iter = BlockIter::new_multiblock(offset, offset + len, self.blk_size_log2());
@@ -119,7 +119,7 @@ impl<T: BlockDevice> Device for T {
             } else {
                 // 判断块的长度不能超过最大值
                 if self.blk_size_log2() > BLK_SIZE_LOG2_LIMIT {
-                    return Err(-(E2BIG as i32));
+                    return Err(SystemError::E2BIG);
                 }
 
                 let mut temp = Vec::new();
@@ -133,10 +133,10 @@ impl<T: BlockDevice> Device for T {
     }
 
     /// 写入设备操作，把 buf 的数据写入到设备内部 [offset, offset + len) 区间内
-    fn write_at(&self, offset: usize, len: usize, buf: &[u8]) -> Result<usize, i32> {
+    fn write_at(&self, offset: usize, len: usize, buf: &[u8]) -> Result<usize, SystemError> {
         // assert!(len <= buf.len());
         if len > buf.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
 
         let iter = BlockIter::new_multiblock(offset, offset + len, self.blk_size_log2());
@@ -153,7 +153,7 @@ impl<T: BlockDevice> Device for T {
                 BlockDevice::write_at(self, range.lba_start, count, buf_slice)?;
             } else {
                 if self.blk_size_log2() > BLK_SIZE_LOG2_LIMIT {
-                    return Err(-(E2BIG as i32));
+                    return Err(SystemError::E2BIG);
                 }
 
                 let mut temp = Vec::new();
@@ -169,7 +169,7 @@ impl<T: BlockDevice> Device for T {
     }
 
     /// 数据同步
-    fn sync(&self) -> Result<(), i32> {
+    fn sync(&self) -> Result<(), SystemError> {
         BlockDevice::sync(self)
     }
 }

kernel/src/ipc/signal.rs

@@ -13,7 +13,7 @@ use crate::{
     },
     include::bindings::bindings::{
         pid_t, process_control_block, process_do_exit, process_find_pcb_by_pid, pt_regs,
-        spinlock_t, verify_area, EFAULT, EINVAL, ENOTSUP, EPERM, ESRCH, NULL, PF_EXITING,
+        spinlock_t, verify_area, NULL, PF_EXITING,
         PF_KTHREAD, PF_SIGNALED, PF_WAKEKILL, PROC_INTERRUPTIBLE, USER_CS, USER_DS,
         USER_MAX_LINEAR_ADDR,
     },
@@ -29,7 +29,7 @@ use crate::{
     process::{
         pid::PidType,
         process::{process_is_stopped, process_kick, process_wake_up_state},
-    },
+    }, syscall::SystemError,
 };
 
 use super::signal_types::{
@@ -74,7 +74,7 @@ pub extern "C" fn sys_kill(regs: &pt_regs) -> u64 {
     if sig == SignalNumber::INVALID {
         // 传入的signal数值不合法
         kwarn!("Not a valid signal number");
-        return (-(EINVAL as i64)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
 
     // 初始化signal info
@@ -98,7 +98,7 @@ pub extern "C" fn sys_kill(regs: &pt_regs) -> u64 {
     if retval.is_ok() {
         x = retval.unwrap();
     } else {
-        x = retval.unwrap_err();
+        x = retval.unwrap_err().to_posix_errno();
     }
     compiler_fence(core::sync::atomic::Ordering::SeqCst);
 
@@ -113,11 +113,11 @@ fn signal_kill_something_info(
     sig: SignalNumber,
     info: Option<&mut siginfo>,
     pid: pid_t,
-) -> Result<i32, i32> {
+) -> Result<i32, SystemError> {
     // 暂时不支持特殊的kill操作
     if pid <= 0 {
         kwarn!("Kill operation not support: pid={}", pid);
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP);
     }
 
     // kill单个进程
@@ -128,8 +128,8 @@ fn signal_kill_proc_info(
     sig: SignalNumber,
     info: Option<&mut siginfo>,
     pid: pid_t,
-) -> Result<i32, i32> {
-    let mut retval = Err(-(ESRCH as i32));
+) -> Result<i32, SystemError> {
+    let mut retval = Err(SystemError::ESRCH);
 
     // step1: 当进程管理模块拥有pcblist_lock之后，对其加锁
 
@@ -168,16 +168,16 @@ fn signal_send_sig_info(
     sig: SignalNumber,
     info: Option<&mut siginfo>,
     target_pcb: &mut process_control_block,
-) -> Result<i32, i32> {
+) -> Result<i32, SystemError> {
     // kdebug!("signal_send_sig_info");
     // 检查sig是否符合要求，如果不符合要求，则退出。
     if !verify_signal(sig) {
-        return Err(-(EINVAL as i32));
+        return Err(SystemError::EINVAL);
     }
 
     // 信号符合要求，可以发送
 
-    let mut retval = Err(-(ESRCH as i32));
+    let mut retval = Err(SystemError::ESRCH);
     let mut flags: u64 = 0;
     // 如果上锁成功，则发送信号
     if !lock_process_sighand(target_pcb, &mut flags).is_none() {
@@ -229,13 +229,13 @@ fn unlock_process_sighand(pcb: &mut process_control_block, flags: u64) {
 /// @brief 判断是否需要强制发送信号，然后发送信号
 /// 注意，进入该函数前，我们应当对pcb.sighand.siglock加锁。
 ///
-/// @return i32 错误码
+/// @return SystemError 错误码
 fn send_signal_locked(
     sig: SignalNumber,
     info: Option<&mut siginfo>,
     pcb: &mut process_control_block,
     pt: PidType,
-) -> Result<i32, i32> {
+) -> Result<i32, SystemError> {
     // 是否强制发送信号
     let mut force_send = false;
     // signal的信息为空
@@ -258,14 +258,14 @@ fn send_signal_locked(
 /// @param _info 信号携带的信息
 /// @param pcb 目标进程的pcb
 /// @param pt siginfo结构体中，pid字段代表的含义
-/// @return i32 错误码
+/// @return SystemError 错误码
 fn __send_signal_locked(
     sig: SignalNumber,
     info: Option<&mut siginfo>,
     pcb: &mut process_control_block,
     pt: PidType,
     _force_send: bool,
-) -> Result<i32, i32> {
+) -> Result<i32, SystemError> {
     // kdebug!("__send_signal_locked");
 
     // 判断该进入该函数时，是否已经持有了锁
@@ -458,7 +458,7 @@ pub extern "C" fn do_signal(regs: &mut pt_regs) {
         let res = handle_signal(sig_number, ka.unwrap(), &info.unwrap(), &oldset, regs);
         if res.is_err() {
             kerror!(
-                "Error occurred when handling signal: {}, pid={}, errcode={}",
+                "Error occurred when handling signal: {}, pid={}, errcode={:?}",
                 sig_number as i32,
                 current_pcb().pid,
                 res.unwrap_err()
@@ -619,14 +619,14 @@ fn collect_signal(sig: SignalNumber, pending: &mut sigpending) -> siginfo {
 /// @param oldset
 /// @param regs 之前的系统调用将要返回的时候，要弹出的栈帧的拷贝
 ///
-/// @return Result<0,i32> 若Error, 则返回错误码,否则返回Ok(0)
+/// @return Result<0,SystemError> 若Error, 则返回错误码,否则返回Ok(0)
 fn handle_signal(
     sig: SignalNumber,
     ka: &mut sigaction,
     info: &siginfo,
     oldset: &sigset_t,
     regs: &mut pt_regs,
-) -> Result<i32, i32> {
+) -> Result<i32, SystemError> {
     // 设置栈帧
     let retval = setup_frame(sig, ka, info, oldset, regs);
     if retval.is_err() {
@@ -644,7 +644,7 @@ fn setup_frame(
     info: &siginfo,
     oldset: &sigset_t,
     regs: &mut pt_regs,
-) -> Result<i32, i32> {
+) -> Result<i32, SystemError> {
     let mut err = 0;
     let frame: *mut sigframe = get_stack(ka, &regs, size_of::<sigframe>());
     // kdebug!("frame=0x{:016x}", frame as usize);
@@ -654,7 +654,7 @@ fn setup_frame(
         // 如果地址区域位于内核空间，则直接报错
         // todo: 生成一个sigsegv
         kerror!("In setup frame: access check failed");
-        return Err(-(EPERM as i32));
+        return Err(SystemError::EPERM);
     }
 
     unsafe {
@@ -697,7 +697,10 @@ fn setup_frame(
     }
     if err != 0 {
         // todo: 在这里生成一个sigsegv,然后core dump
-        return Err(1);
+        //临时解决方案：退出当前进程
+        unsafe{
+            process_do_exit(1);
+        }
     }
     // 传入信号处理函数的第一个参数
     regs.rdi = sig as u64;
@@ -721,8 +724,8 @@ fn setup_frame(
     // 设置cs和ds寄存器
     regs.cs = (USER_CS | 0x3) as u64;
     regs.ds = (USER_DS | 0x3) as u64;
-
-    return if err == 0 { Ok(0) } else { Err(1) };
+    
+    return if err == 0 { Ok(0) } else { Err(SystemError::EPERM) };
 }
 
 #[inline(always)]
@@ -735,14 +738,14 @@ fn get_stack(_ka: &sigaction, regs: &pt_regs, size: usize) -> *mut sigframe {
 }
 
 /// @brief 将siginfo结构体拷贝到用户栈
-fn copy_siginfo_to_user(to: *mut siginfo, from: &siginfo) -> Result<i32, i32> {
+fn copy_siginfo_to_user(to: *mut siginfo, from: &siginfo) -> Result<i32, SystemError> {
     // 验证目标地址是否为用户空间
     if unsafe { !verify_area(to as u64, size_of::<siginfo>() as u64) } {
         // 如果目标地址空间不为用户空间，则直接返回错误码 -EPERM
-        return Err(-(EPERM as i32));
+        return Err(SystemError::EPERM);
     }
 
-    let retval: Result<i32, i32> = Ok(0);
+    let retval: Result<i32, SystemError> = Ok(0);
 
     // todo: 将这里按照si_code的类型来分别拷贝不同的信息。
     // 这里参考linux-2.6.39  网址： http://opengrok.ringotek.cn/xref/linux-2.6.39/arch/ia64/kernel/signal.c#137
@@ -759,7 +762,7 @@ fn copy_siginfo_to_user(to: *mut siginfo, from: &siginfo) -> Result<i32, i32> {
 /// @param context 要被设置的目标sigcontext
 /// @param mask 要被暂存的信号mask标志位
 /// @param regs 进入信号处理流程前，Restore all要弹出的内核栈栈帧
-fn setup_sigcontext(context: &mut sigcontext, mask: &sigset_t, regs: &pt_regs) -> Result<i32, i32> {
+fn setup_sigcontext(context: &mut sigcontext, mask: &sigset_t, regs: &pt_regs) -> Result<i32, SystemError> {
     let current_thread = current_pcb().thread;
 
     context.oldmask = *mask;
@@ -835,7 +838,7 @@ pub extern "C" fn sys_sigaction(regs: &mut pt_regs) -> u64 {
     if !act.is_null() {
         // 如果参数的范围不在用户空间，则返回错误
         if unsafe { !verify_area(act as usize as u64, size_of::<sigaction>() as u64) } {
-            return (-(EFAULT as i64)) as u64;
+            return SystemError::EFAULT.to_posix_errno() as u64;
         }
         let mask: sigset_t = unsafe { (*act).sa_mask };
         let _input_sah = unsafe { (*act).sa_handler as u64 };
@@ -884,7 +887,7 @@ pub extern "C" fn sys_sigaction(regs: &mut pt_regs) -> u64 {
     let sig = SignalNumber::from(regs.r8 as i32);
     // 如果给出的信号值不合法
     if sig == SignalNumber::INVALID {
-        return (-(EINVAL as i64)) as u64;
+        return SystemError::EINVAL.to_posix_errno() as u64;
     }
 
     let retval = do_sigaction(
@@ -902,9 +905,9 @@ pub extern "C" fn sys_sigaction(regs: &mut pt_regs) -> u64 {
     );
 
     // 将原本的sigaction拷贝到用户程序指定的地址
-    if (retval == 0) && (!old_act.is_null()) {
+    if (retval == Ok(())) && (!old_act.is_null()) {
         if unsafe { !verify_area(old_act as usize as u64, size_of::<sigaction>() as u64) } {
-            return (-(EFAULT as i64)) as u64;
+            return SystemError::EFAULT.to_posix_errno() as u64;
         }
         // ！！！！！！！！！！todo: 检查这里old_ka的mask，是否位SIG_IGN SIG_DFL,如果是，则将_sa_handler字段替换为对应的值
         let sah: u64;
@@ -925,15 +928,20 @@ pub extern "C" fn sys_sigaction(regs: &mut pt_regs) -> u64 {
             (*old_act).sa_restorer = old_ka.sa_restorer as *mut c_void;
         }
     }
-
-    return retval as u64;
+    //return retval as u64;
+    if retval.is_ok(){
+        return 0;
+    }else{
+        return retval.unwrap_err().to_posix_errno() as u64;
+    }
+    
 }
 
 fn do_sigaction(
     sig: SignalNumber,
     act: Option<&mut sigaction>,
     old_act: Option<&mut sigaction>,
-) -> i32 {
+) -> Result<(),SystemError> {
     let pcb = current_pcb();
 
     // 指向当前信号的action的引用
@@ -945,7 +953,7 @@ fn do_sigaction(
 
     if (action.sa_flags & SA_FLAG_IMMUTABLE) != 0 {
         spin_unlock_irq(unsafe { &mut (*(pcb.sighand)).siglock });
-        return -(EINVAL as i32);
+        return Err(SystemError::EINVAL);
     }
 
     // 如果需要保存原有的sigaction
@@ -1005,7 +1013,7 @@ fn do_sigaction(
     }
 
     spin_unlock_irq(unsafe { &mut (*(pcb.sighand)).siglock });
-    return 0;
+    return Ok(());
 }
 
 /// @brief 对于给定的signal number，将u64中对应的位进行置位

kernel/src/libs/lockref.rs

@@ -2,7 +2,7 @@
 use super::spinlock::RawSpinlock;
 use crate::{
     arch::asm::cmpxchg::try_cmpxchg_q,
-    include::bindings::bindings::{ENOTSUP, ETIMEDOUT},
+    syscall::SystemError,
 };
 use core::{fmt::Debug, intrinsics::size_of};
 
@@ -46,14 +46,14 @@ impl LockRef {
     /// @brief 为X86架构实现cmpxchg循环，以支持无锁操作。
     ///
     /// @return 操作成功：返回Ok(new.count)
-    /// @return 操作失败，原因：超时 => 返回Err(-ETIMEDOUT)
-    /// @return 操作失败，原因：不满足规则 => 返回Err(1)
+    /// @return 操作失败，原因：超时 => 返回Err(SystemError::ETIMEDOUT)
+    /// @return 操作失败，原因：不满足规则 => 返回Err(SystemError::E2BIG)
     #[cfg(target_arch = "x86_64")]
     #[inline]
     fn cmpxchg_loop(&mut self, mode: CmpxchgMode) -> Result<i32, i32> {
         use core::ptr::read_volatile;
 
-        use crate::arch::cpu::cpu_relax;
+        use crate::{arch::cpu::cpu_relax};
 
         let mut old: LockRef = LockRef::INIT;
         old.count = unsafe { read_volatile(&self.count) };
@@ -114,16 +114,16 @@ impl LockRef {
             }
         }
 
-        return Err(-(ETIMEDOUT as i32));
+        return Err(SystemError::ETIMEDOUT.to_posix_errno());
     }
 
-    /// @brief 对于不支持无锁lockref的架构，直接返回Err(-ENOTSUP)，表示不支持
+    /// @brief 对于不支持无锁lockref的架构，直接返回Err(SystemError::ENOTSUP)，表示不支持
     #[cfg(not(target_arch = "x86_64"))]
     #[inline]
     fn cmpxchg_loop(&mut self, mode: CmpxchgMode) -> Result<i32, i32> {
         use crate::include::bindings::bindings::ENOTSUP;
 
-        return Err(-(ENOTSUP as i32));
+        return Err(SystemError::ENOTSUP.to_posix_errno());
     }
 
     /// @brief 原子的将引用计数加1
@@ -141,21 +141,20 @@ impl LockRef {
     /**
      * @brief 原子地将引用计数加1.如果原来的count≤0，则操作失败。
      *
-     * @return Result<i32, i32>     操作成功=>Ok(self.count)
-     *                              操作失败=>Err(-1)
+     * @return Ok(self.count) 操作成功
+     * @return Err(SystemError::EPERM) 操作失败
      */
-    pub fn inc_not_zero(&mut self) -> Result<i32, i32> {
+    pub fn inc_not_zero(&mut self) -> Result<i32, SystemError> {
         {
-            let cmpxchg_res = self.cmpxchg_loop(CmpxchgMode::IncreaseNotZero);
-            if cmpxchg_res.is_ok() {
-                return cmpxchg_res;
-            } else if cmpxchg_res.unwrap_err() == 1 {
+            let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::IncreaseNotZero);
+            if cmpxchg_result.is_ok() {
+                return Ok(cmpxchg_result.unwrap());
+            } else if cmpxchg_result.unwrap_err() == 1 {
                 // 不满足not zero 的条件
-                return Err(-1);
+                return Err(SystemError::EPERM);
             }
         }
-
-        let mut retval = Err(-1);
+        let mut retval = Err(SystemError::EPERM);
         self.lock.lock();
 
         if self.count > 0 {
@@ -171,19 +170,19 @@ impl LockRef {
      * @brief 引用计数自增1。（除非该lockref已经被标记为死亡）
      *
      * @return Ok(self.count) 操作成功
-     * @return Err(-1) 操作失败，lockref已死亡
+     * @return Err(SystemError::EPERM) 操作失败，lockref已死亡
      */
-    pub fn inc_not_dead(&mut self) -> Result<i32, i32> {
+    pub fn inc_not_dead(&mut self) -> Result<i32, SystemError> {
         {
             let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::IncreaseNotDead);
             if cmpxchg_result.is_ok() {
-                return cmpxchg_result;
+                return Ok(cmpxchg_result.unwrap());
             } else if cmpxchg_result.unwrap_err() == 1 {
-                return Err(-1);
+                return Err(SystemError::EPERM);
             }
         }
         // 快捷路径操作失败，尝试加锁
-        let mut retval = Err(-1);
+        let mut retval = Err(SystemError::EPERM);
 
         self.lock.lock();
         if self.count >= 0 {
@@ -195,29 +194,29 @@ impl LockRef {
     }
 
     /**
-     * @brief 原子地将引用计数-1。如果已处于count≤0的状态，则返回Err(-1)
+     * @brief 原子地将引用计数-1。如果已处于count≤0的状态，则返回SystemError::EPERM
      *
      * 本函数与lockref_dec_return()的区别在于，当在cmpxchg()中检测到count<=0或已加锁，本函数会再次尝试通过加锁来执行操作
      * 而后者会直接返回错误
      *
-     * @return int 操作成功 => 返回新的引用变量值
-     *             操作失败lockref处于count≤0的状态 => 返回-1
+     * @return Ok(self.count) 操作成功,返回新的引用变量值
+     * @return Err(SystemError::EPERM) 操作失败,lockref处于count≤0的状态
      */
-    pub fn dec(&mut self) -> Result<i32, i32> {
+    pub fn dec(&mut self) -> Result<i32, SystemError> {
         {
             let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::Decrease);
             if cmpxchg_result.is_ok() {
-                return cmpxchg_result;
+                return Ok(cmpxchg_result.unwrap());
             }
         }
-        let retval: Result<i32, i32>;
+        let retval: Result<i32, SystemError>;
         self.lock.lock();
 
         if self.count > 0 {
             self.count -= 1;
             retval = Ok(self.count);
         } else {
-            retval = Err(-1);
+            retval = Err(SystemError::EPERM);
         }
 
         self.lock.unlock();
@@ -226,26 +225,25 @@ impl LockRef {
     }
 
     /**
-     * @brief 原子地将引用计数减1。如果处于已加锁或count≤0的状态，则返回-1
+     * @brief 原子地将引用计数减1。如果处于已加锁或count≤0的状态，则返回SystemError::EPERM
      *      若当前处理器架构不支持cmpxchg，则退化为self.dec()
      *
      * 本函数与lockref_dec()的区别在于，当在cmpxchg()中检测到count<=0或已加锁，本函数会直接返回错误
      * 而后者会再次尝试通过加锁来执行操作
      *
-     * @return int  操作成功 => 返回新的引用变量值
-     *              操作失败，lockref处于已加锁或count≤0的状态 => 返回-1
+     * @return Ok(self.count) 操作成功,返回新的引用变量值
+     * @return Err(SystemError::EPERM) 操作失败，lockref处于已加锁或count≤0的状态
      */
-    pub fn dec_return(&mut self) -> Result<i32, i32> {
+    pub fn dec_return(&mut self) -> Result<i32, SystemError> {
         let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::DecreaseReturn);
         if cmpxchg_result.is_ok() {
-            return cmpxchg_result;
-        } else if cmpxchg_result.unwrap_err() == 1 {
-            return Err(-1);
+            return Ok(cmpxchg_result.unwrap());
+        } else if *cmpxchg_result.as_ref().unwrap_err() == 1 {
+            return Err(SystemError::EPERM);
         }
-
         // 由于cmpxchg超时，操作失败
-        if cmpxchg_result.unwrap_err() != -(ENOTSUP as i32) {
-            return Err(-1);
+        if *cmpxchg_result.as_ref().unwrap_err() != SystemError::ENOTSUP.to_posix_errno() {
+            return Err(SystemError::EFAULT);
         }
 
         // 能走到这里，代表架构当前不支持cmpxchg
@@ -256,29 +254,29 @@ impl LockRef {
     /**
      * @brief 原子地将引用计数减1。若当前的引用计数≤1，则操作失败
      *
-     * 该函数与lockref_dec_or_lock_not_zero()的区别在于，当cmpxchg()时发现old.count≤1时，该函数会直接返回Err(-1)
+     * 该函数与lockref_dec_or_lock_not_zero()的区别在于，当cmpxchg()时发现old.count≤1时，该函数会直接返回Err(SystemError::EPERM)
      * 而后者在这种情况下，会尝试加锁来进行操作。
      *
      * @return Ok(self.count) 成功将引用计数减1
-     * @return Err(-1) 如果当前的引用计数≤1，操作失败
+     * @return Err(SystemError::EPERM) 如果当前的引用计数≤1，操作失败
      */
-    pub fn dec_not_zero(&mut self) -> Result<i32, i32> {
+    pub fn dec_not_zero(&mut self) -> Result<i32, SystemError> {
         {
             let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::DecreaseNotZero);
             if cmpxchg_result.is_ok() {
-                return cmpxchg_result;
-            } else if cmpxchg_result.unwrap_err() == 1 {
-                return Err(-1);
+                return Ok(cmpxchg_result.unwrap());
+            } else if cmpxchg_result.unwrap_err() == 1{
+                return Err(SystemError::EPERM);
             }
         }
 
-        let retval: Result<i32, i32>;
+        let retval: Result<i32, SystemError>;
         self.lock.lock();
         if self.count > 1 {
             self.count -= 1;
             retval = Ok(self.count);
         } else {
-            retval = Err(-1);
+            retval = Err(SystemError::EPERM);
         }
         self.lock.unlock();
         return retval;
@@ -288,26 +286,26 @@ impl LockRef {
      * @brief 原子地将引用计数减1。若当前的引用计数≤1，则操作失败
      *
      * 该函数与lockref_dec_not_zero()的区别在于，当cmpxchg()时发现old.count≤1时，该函数会尝试加锁来进行操作。
-     * 而后者在这种情况下，会直接返回Err(-1).
+     * 而后者在这种情况下，会直接返回Err(SystemError::EPERM).
      *
      * @return Ok(self.count) 成功将引用计数减1
-     * @return Err(-1) 如果当前的引用计数≤1，操作失败
+     * @return Err(SystemError::EPERM) 如果当前的引用计数≤1，操作失败
      */
-    pub fn dec_or_lock_not_zero(&mut self) -> Result<i32, i32> {
+    pub fn dec_or_lock_not_zero(&mut self) -> Result<i32, SystemError> {
         {
             let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::DecreaseOrLockNotZero);
             if cmpxchg_result.is_ok() {
-                return cmpxchg_result;
+                return Ok(cmpxchg_result.unwrap());
             }
         }
 
-        let retval: Result<i32, i32>;
+        let retval: Result<i32, SystemError>;
         self.lock.lock();
         if self.count > 1 {
             self.count -= 1;
             retval = Ok(self.count);
         } else {
-            retval = Err(-1);
+            retval = Err(SystemError::EPERM);
         }
         self.lock.unlock();
         return retval;

kernel/src/libs/mutex.rs

@@ -8,9 +8,9 @@ use alloc::collections::LinkedList;
 use crate::{
     arch::{asm::current::current_pcb, sched::sched},
     include::bindings::bindings::{
-        pid_t, process_control_block, process_wakeup, EBUSY, PROC_INTERRUPTIBLE, PROC_RUNNING,
+        pid_t, process_control_block, process_wakeup,  PROC_INTERRUPTIBLE, PROC_RUNNING,
     },
-    libs::spinlock::SpinLockGuard,
+    libs::spinlock::SpinLockGuard, syscall::SystemError,
 };
 
 use super::spinlock::SpinLock;
@@ -88,12 +88,12 @@ impl<T> Mutex<T> {
     /// @return Err 如果Mutex当前已经上锁，则返回Err.
     #[inline(always)]
     #[allow(dead_code)]
-    pub fn try_lock(&self) -> Result<MutexGuard<T>, i32> {
+    pub fn try_lock(&self) -> Result<MutexGuard<T>, SystemError> {
         let mut inner = self.inner.lock();
 
         // 如果当前mutex已经上锁，则失败
         if inner.is_locked {
-            return Err(-(EBUSY as i32));
+            return Err(SystemError::EBUSY);
         } else {
             // 加锁成功
             inner.is_locked = true;

kernel/src/libs/rwlock.rs

@@ -7,7 +7,7 @@ use core::{
     sync::atomic::{AtomicU32, Ordering},
 };
 
-use crate::include::bindings::bindings::EOVERFLOW;
+use crate::{syscall::SystemError};
 
 ///RwLock读写锁
 
@@ -91,7 +91,7 @@ impl<T> RwLock<T> {
     #[allow(dead_code)]
     #[inline]
     /// @brief 获取实时的读者数并尝试加1,如果增加值成功则返回增加1后的读者数,否则panic
-    fn current_reader(&self) -> Result<u32, i32> {
+    fn current_reader(&self) -> Result<u32, SystemError> {
         const MAX_READERS: u32 = core::u32::MAX >> READER_BIT >> 1; //右移3位
 
         let value = self.lock.fetch_add(READER, Ordering::Acquire);
@@ -100,7 +100,7 @@ impl<T> RwLock<T> {
         if value > MAX_READERS << READER_BIT {
             self.lock.fetch_sub(READER, Ordering::Release);
             //panic!("Too many lock readers, cannot safely proceed");
-            return Err(-(EOVERFLOW as i32));
+            return Err(SystemError::EOVERFLOW);
         } else {
             return Ok(value);
         }

kernel/src/libs/semaphore.rs

@@ -1,6 +1,6 @@
 use core::sync::atomic::{AtomicI32, Ordering};
 
-use crate::{arch::asm::current::current_pcb, include::bindings::bindings::EOVERFLOW, kdebug};
+use crate::{arch::asm::current::current_pcb, kdebug, syscall::SystemError};
 
 use super::wait_queue::WaitQueue;
 
@@ -18,14 +18,14 @@ impl Semaphore {
     ///
     /// @param count 信号量的初始值
     /// @return 条件满足返回semaphore对象,条件不满足返回err信息
-    fn new(counter: i32) -> Result<Self, i32> {
+    fn new(counter: i32) -> Result<Self, SystemError> {
         if counter > 0 {
             Ok(Self {
                 counter: AtomicI32::new(counter),
                 wait_queue: WaitQueue::INIT,
             })
         } else {
-            return Err(-(EOVERFLOW as i32));
+            return Err(SystemError::EOVERFLOW);
         }
     }
 

kernel/src/libs/vec_cursor.rs

@@ -4,10 +4,7 @@ use core::mem::size_of;
 
 use alloc::vec::Vec;
 
-use crate::{
-    include::bindings::bindings::{E2BIG, EINVAL, EOVERFLOW},
-    io::SeekFrom,
-};
+use crate::{io::SeekFrom, syscall::SystemError};
 
 /// @brief 本模块用于为数组提供游标的功能，以简化其操作。
 #[derive(Debug)]
@@ -45,18 +42,18 @@ impl VecCursor {
     }
 
     /// @brief 读取一个u8的数据（小端对齐）
-    pub fn read_u8(&mut self) -> Result<u8, i32> {
+    pub fn read_u8(&mut self) -> Result<u8, SystemError> {
         if self.pos >= self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
         self.pos += 1;
         return Ok(self.data[self.pos - 1]);
     }
 
     /// @brief 读取一个u16的数据（小端对齐）
-    pub fn read_u16(&mut self) -> Result<u16, i32> {
+    pub fn read_u16(&mut self) -> Result<u16, SystemError> {
         if self.pos + 2 > self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
         let mut res = 0u16;
         res |= (self.data[self.pos] as u16) & 0xff;
@@ -68,9 +65,9 @@ impl VecCursor {
     }
 
     /// @brief 读取一个u32的数据（小端对齐）
-    pub fn read_u32(&mut self) -> Result<u32, i32> {
+    pub fn read_u32(&mut self) -> Result<u32, SystemError> {
         if self.pos + 4 > self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
         let mut res = 0u32;
         for i in 0..4 {
@@ -82,9 +79,9 @@ impl VecCursor {
     }
 
     /// @brief 读取一个u64的数据（小端对齐）
-    pub fn read_u64(&mut self) -> Result<u64, i32> {
+    pub fn read_u64(&mut self) -> Result<u64, SystemError> {
         if self.pos + 8 > self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
         let mut res = 0u64;
         for i in 0..8 {
@@ -101,9 +98,9 @@ impl VecCursor {
     ///
     /// @return Ok(()) 成功读取
     /// @retunr Err(-E2BIG) 没有这么多数据，读取失败
-    pub fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), i32> {
+    pub fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), SystemError> {
         if self.pos + buf.len() > self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
         buf.copy_from_slice(&self.data[self.pos..self.pos + buf.len()]);
         self.pos += buf.len();
@@ -113,9 +110,9 @@ impl VecCursor {
     /// @brief 小端对齐，读取数据到u16数组.
     ///
     /// @param buf 目标u16数组
-    pub fn read_u16_into(&mut self, buf: &mut [u16]) -> Result<(), i32> {
+    pub fn read_u16_into(&mut self, buf: &mut [u16]) -> Result<(), SystemError> {
         if self.pos + buf.len() * size_of::<u16>() > self.data.len() * size_of::<u16>() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
 
         for i in 0..buf.len() {
@@ -130,8 +127,8 @@ impl VecCursor {
     /// @param 调整的相对值
     ///
     /// @return Ok(新的游标位置) 调整成功，返回新的游标位置
-    /// @return Err(-EOVERFLOW) 调整失败，游标超出正确的范围。（失败时游标位置不变）
-    pub fn seek(&mut self, origin: SeekFrom) -> Result<usize, i32> {
+    /// @return Err(SystemError::EOVERFLOW) 调整失败，游标超出正确的范围。（失败时游标位置不变）
+    pub fn seek(&mut self, origin: SeekFrom) -> Result<usize, SystemError> {
         let pos: i64;
         match origin {
             SeekFrom::SeekSet(offset) => {
@@ -145,21 +142,21 @@ impl VecCursor {
                 pos = self.data.len() as i64 + offset;
             }
             SeekFrom::Invalid => {
-                return Err(-(EINVAL as i32));
+                return Err(SystemError::EINVAL);
             }
         }
 
         if pos < 0 || pos > self.data.len() as i64 {
-            return Err(-(EOVERFLOW as i32));
+            return Err(SystemError::EOVERFLOW);
         }
         self.pos = pos as usize;
         return Ok(self.pos);
     }
 
     /// @brief 写入一个u8的数据（小端对齐）
-    pub fn write_u8(&mut self, value: u8) -> Result<u8, i32> {
+    pub fn write_u8(&mut self, value: u8) -> Result<u8, SystemError> {
         if self.pos >= self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
 
         self.data[self.pos] = value;
@@ -169,9 +166,9 @@ impl VecCursor {
     }
 
     /// @brief 写入一个u16的数据（小端对齐）
-    pub fn write_u16(&mut self, value: u16) -> Result<u16, i32> {
+    pub fn write_u16(&mut self, value: u16) -> Result<u16, SystemError> {
         if self.pos + 2 > self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
 
         self.data[self.pos] = (value & 0xff) as u8;
@@ -183,9 +180,9 @@ impl VecCursor {
     }
 
     /// @brief 写入一个u32的数据（小端对齐）
-    pub fn write_u32(&mut self, value: u32) -> Result<u32, i32> {
+    pub fn write_u32(&mut self, value: u32) -> Result<u32, SystemError> {
         if self.pos + 4 > self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
 
         for i in 0..4 {
@@ -197,9 +194,9 @@ impl VecCursor {
     }
 
     /// @brief 写入一个u64的数据（小端对齐）
-    pub fn write_u64(&mut self, value: u64) -> Result<u64, i32> {
+    pub fn write_u64(&mut self, value: u64) -> Result<u64, SystemError> {
         if self.pos + 8 > self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
 
         for i in 0..8 {
@@ -216,9 +213,9 @@ impl VecCursor {
     ///
     /// @return Ok(()) 成功写入
     /// @retunr Err(-E2BIG) 没有这么多数据，写入失败
-    pub fn write_exact(&mut self, buf: &[u8]) -> Result<(), i32> {
+    pub fn write_exact(&mut self, buf: &[u8]) -> Result<(), SystemError> {
         if self.pos + buf.len() > self.data.len() {
-            return Err(-(E2BIG as i32));
+            return Err(SystemError::E2BIG);
         }
 
         self.data[self.pos..self.pos + buf.len()].copy_from_slice(&buf[..]);

kernel/src/mm/mmio_buddy.rs

@@ -1,9 +1,10 @@
 use crate::libs::spinlock::{SpinLock, SpinLockGuard};
+use crate::syscall::SystemError;
 use crate::{
     arch::asm::current::current_pcb,
     include::bindings::bindings::{
         initial_mm, mm_create_vma, mm_unmap, vm_area_del, vm_area_free, vm_area_struct, vm_flags_t,
-        vma_find, EINVAL, ENOMEM, EPERM, MMIO_BASE, MMIO_TOP, PAGE_1G_SHIFT, PAGE_1G_SIZE,
+        vma_find, MMIO_BASE, MMIO_TOP, PAGE_1G_SHIFT, PAGE_1G_SIZE,
         PAGE_2M_SIZE, PAGE_4K_SHIFT, PAGE_4K_SIZE, VM_DONTCOPY, VM_IO,
     },
     kdebug, kerror,
@@ -73,11 +74,11 @@ impl MmioBuddyMemPool {
     ///
     /// @return Ok(i32) 返回0
     ///
-    /// @return Err(i32) 返回错误码
-    fn give_back_block(&self, vaddr: u64, exp: u32) -> Result<i32, i32> {
+    /// @return Err(SystemError) 返回错误码
+    fn give_back_block(&self, vaddr: u64, exp: u32) -> Result<i32, SystemError> {
         // 确保内存对齐，低位都要为0
         if (vaddr & ((1 << exp) - 1)) != 0 {
-            return Err(-(EINVAL as i32));
+            return Err(SystemError::EINVAL);
         }
         let region: Box<MmioBuddyAddrRegion> = self.create_region(vaddr);
         // 加入buddy
@@ -440,16 +441,16 @@ impl MmioBuddyMemPool {
     ///
     /// @return Ok(i32) 成功返回0
     ///
-    /// @return Err(i32) 失败返回错误码
+    /// @return Err(SystemError) 失败返回错误码
     pub fn create_mmio(
         &self,
         size: u32,
         vm_flags: vm_flags_t,
         res_vaddr: *mut u64,
         res_length: *mut u64,
-    ) -> Result<i32, i32> {
+    ) -> Result<i32, SystemError> {
         if size > PAGE_1G_SIZE || size == 0 {
-            return Err(-(EPERM as i32));
+            return Err(SystemError::EPERM);
         }
         let mut retval: i32 = 0;
         // 计算前导0
@@ -502,7 +503,7 @@ impl MmioBuddyMemPool {
                             vm_area_del(*vma);
                             vm_area_free(*vma);
                         }
-                        return Err(retval);
+                        return Err(SystemError::from_posix_errno(retval).unwrap());
                     }
                     loop_i += PAGE_2M_SIZE as u64;
                 }
@@ -532,14 +533,14 @@ impl MmioBuddyMemPool {
                             vm_area_del(*vma);
                             vm_area_free(*vma);
                         }
-                        return Err(retval);
+                        return Err(SystemError::from_posix_errno(retval).unwrap());
                     }
                     loop_i += PAGE_4K_SIZE as u64;
                 }
             }
             Err(_) => {
                 kdebug!("failed to create mmio vma.pid = {:?}", current_pcb().pid);
-                return Err(-(ENOMEM as i32));
+                return Err(SystemError::ENOMEM);
             }
         }
         return Ok(retval);
@@ -553,8 +554,8 @@ impl MmioBuddyMemPool {
     ///
     /// @return Ok(i32) 成功返回0
     ///
-    /// @return Err(i32) 失败返回错误码
-    pub fn release_mmio(&self, vaddr: u64, length: u64) -> Result<i32, i32> {
+    /// @return Err(SystemError) 失败返回错误码
+    pub fn release_mmio(&self, vaddr: u64, length: u64) -> Result<i32, SystemError> {
         //先将要释放的空间取消映射
         unsafe {
             mm_unmap(&mut initial_mm, vaddr, length, false);
@@ -572,7 +573,7 @@ impl MmioBuddyMemPool {
                     vaddr + loop_i,
                     current_pcb().pid
                 );
-                return Err(-(EINVAL as i32));
+                return Err(SystemError::EINVAL);
             }
             // 检查vma起始地址是否正确
             if unsafe { (*vma).vm_start != (vaddr + loop_i) } {
@@ -581,7 +582,7 @@ impl MmioBuddyMemPool {
                     vaddr + loop_i,
                     current_pcb().pid
                 );
-                return Err(-(EINVAL as i32));
+                return Err(SystemError::EINVAL);
             }
             // 将vma对应空间归还
             match MMIO_POOL.give_back_block(unsafe { (*vma).vm_start }, unsafe {
@@ -699,7 +700,7 @@ pub extern "C" fn mmio_create(
     res_length: *mut u64,
 ) -> i32 {
     if let Err(err) = MMIO_POOL.create_mmio(size, vm_flags, res_vaddr, res_length) {
-        return err;
+        return err.to_posix_errno();
     } else {
         return 0;
     }
@@ -717,7 +718,7 @@ pub extern "C" fn mmio_create(
 #[no_mangle]
 pub extern "C" fn mmio_release(vaddr: u64, length: u64) -> i32 {
     if let Err(err) = MMIO_POOL.release_mmio(vaddr, length) {
-        return err;
+        return err.to_posix_errno();
     } else {
         return 0;
     }

kernel/src/process/fork.rs

@@ -5,7 +5,7 @@ use alloc::boxed::Box;
 use crate::{
     arch::asm::current::current_pcb,
     include::bindings::bindings::{
-        process_control_block, CLONE_CLEAR_SIGHAND, CLONE_SIGHAND, CLONE_THREAD, ENOMEM,
+        process_control_block, CLONE_CLEAR_SIGHAND, CLONE_SIGHAND, CLONE_THREAD,
     },
     ipc::{
         signal::{flush_signal_handlers, DEFAULT_SIGACTION},
@@ -16,7 +16,7 @@ use crate::{
         ffi_convert::FFIBind2Rust,
         refcount::{refcount_inc, RefCount},
         spinlock::{spin_lock_irqsave, spin_unlock_irqrestore},
-    },
+    }, syscall::SystemError,
 };
 
 #[no_mangle]
@@ -31,7 +31,7 @@ pub extern "C" fn process_copy_sighand(clone_flags: u64, pcb: *mut process_contr
     // 在这里使用Box::leak将动态申请的内存的生命周期转换为static的
     let mut sig: &mut sighand_struct = Box::leak(Box::new(sighand_struct::default()));
     if (sig as *mut sighand_struct) == null_mut() {
-        return -(ENOMEM as i32);
+        return SystemError::ENOMEM.to_posix_errno();
     }
 
     // 将新的sighand赋值给pcb
@@ -87,7 +87,7 @@ pub extern "C" fn process_copy_signal(clone_flags: u64, pcb: *mut process_contro
     }
     let sig: &mut signal_struct = Box::leak(Box::new(signal_struct::default()));
     if (sig as *mut signal_struct) == null_mut() {
-        return -(ENOMEM as i32);
+        return SystemError::ENOMEM.to_posix_errno();
     }
     atomic_set(&mut sig.sig_cnt, 1);
     // 将sig赋值给pcb中的字段

kernel/src/process/process.rs

@@ -9,11 +9,11 @@ use crate::{
     arch::{asm::current::current_pcb, fpu::FpState},
     filesystem::vfs::file::{File, FileDescriptorVec},
     include::bindings::bindings::{
-        process_control_block, CLONE_FS, EBADF, EFAULT, ENFILE, EPERM, PROC_INTERRUPTIBLE,
+        process_control_block, CLONE_FS, PROC_INTERRUPTIBLE,
         PROC_RUNNING, PROC_STOPPED, PROC_UNINTERRUPTIBLE,
     },
     sched::core::{cpu_executing, sched_enqueue},
-    smp::core::{smp_get_processor_id, smp_send_reschedule},
+    smp::core::{smp_get_processor_id, smp_send_reschedule}, syscall::SystemError,
 };
 
 use super::preempt::{preempt_disable, preempt_enable};
@@ -112,11 +112,11 @@ pub fn process_is_executing(pcb: *const process_control_block) -> bool {
 impl process_control_block {
     /// @brief 初始化进程PCB的文件描述符数组。
     /// 请注意，如果当前进程已经有文件描述符数组，那么本操作将被禁止
-    pub fn init_files(&mut self) -> Result<(), i32> {
+    pub fn init_files(&mut self) -> Result<(), SystemError> {
         if self.fds != null_mut() {
             // 这个操作不被允许，否则会产生内存泄露。
             // 原因是，C的pcb里面，文件描述符数组的生命周期是static的，如果继续执行，会产生内存泄露的问题。
-            return Err(-(EPERM as i32));
+            return Err(SystemError::EPERM);
         }
         let fd_vec: &mut FileDescriptorVec = Box::leak(FileDescriptorVec::new());
         self.fds = fd_vec as *mut FileDescriptorVec as usize as *mut c_void;
@@ -129,12 +129,12 @@ impl process_control_block {
     /// @param from 源pcb。从它里面拷贝文件描述符
     ///
     /// @return Ok(()) 拷贝成功
-    /// @return Err(i32) 拷贝失败，错误码
+    /// @return Err(SystemError) 拷贝失败，错误码
     pub fn copy_files(
         &mut self,
         clone_flags: u64,
         from: &'static process_control_block,
-    ) -> Result<(), i32> {
+    ) -> Result<(), SystemError> {
         // 不拷贝父进程的文件描述符
         if clone_flags & CLONE_FS as u64 != 0 {
             // 由于拷贝pcb的时候，直接copy的指针，因此这里置为空
@@ -159,7 +159,7 @@ impl process_control_block {
     }
 
     /// @brief 释放文件描述符数组。本函数会drop掉整个文件描述符数组，并把pcb的fds字段设置为空指针。
-    pub fn exit_files(&mut self) -> Result<(), i32> {
+    pub fn exit_files(&mut self) -> Result<(), SystemError> {
         if self.fds.is_null() {
             return Ok(());
         }
@@ -174,8 +174,8 @@ impl process_control_block {
     /// @brief 申请文件描述符，并把文件对象存入其中。
     ///
     /// @return Ok(i32) 申请到的文件描述符编号
-    /// @return Err(i32) 申请失败，返回错误码，并且，file对象将被drop掉
-    pub fn alloc_fd(&mut self, file: File) -> Result<i32, i32> {
+    /// @return Err(SystemError) 申请失败，返回错误码，并且，file对象将被drop掉
+    pub fn alloc_fd(&mut self, file: File) -> Result<i32, SystemError> {
         // 获取pcb的文件描述符数组的引用
         let fds: &mut FileDescriptorVec =
             if let Some(f) = FileDescriptorVec::from_pcb(current_pcb()) {
@@ -187,7 +187,7 @@ impl process_control_block {
                 if r.is_none() {
                     drop(file);
                     // 初始化失败
-                    return Err(-(EFAULT as i32));
+                    return Err(SystemError::EFAULT);
                 }
                 r.unwrap()
             };
@@ -201,7 +201,7 @@ impl process_control_block {
             }
             cnt += 1;
         }
-        return Err(-(ENFILE as i32));
+        return Err(SystemError::ENFILE);
     }
 
     /// @brief 根据文件描述符序号，获取文件结构体的可变引用
@@ -234,17 +234,17 @@ impl process_control_block {
     /// @brief 释放文件描述符，同时关闭文件。
     ///
     /// @param fd 文件描述符序号
-    pub fn drop_fd(&self, fd: i32) -> Result<(), i32> {
+    pub fn drop_fd(&self, fd: i32) -> Result<(), SystemError> {
         // 判断文件描述符的数字是否超过限制
         if !FileDescriptorVec::validate_fd(fd) {
-            return Err(-(EBADF as i32));
+            return Err(SystemError::EBADF);
         }
         let r: &mut FileDescriptorVec = FileDescriptorVec::from_pcb(current_pcb()).unwrap();
 
         let f: Option<&File> = r.fds[fd as usize].as_deref();
         if f.is_none() {
             // 如果文件描述符不存在，报错
-            return Err(-(EBADF as i32));
+            return Err(SystemError::EBADF);
         }
         // 释放文件
         drop(f);
@@ -284,7 +284,7 @@ pub extern "C" fn process_init_files() -> i32 {
     if r.is_ok() {
         return 0;
     } else {
-        return r.unwrap_err();
+        return r.unwrap_err().to_posix_errno();
     }
 }
 
@@ -301,7 +301,7 @@ pub extern "C" fn process_copy_files(
     if r.is_ok() {
         return 0;
     } else {
-        return r.unwrap_err();
+        return r.unwrap_err().to_posix_errno();
     }
 }
 
@@ -312,11 +312,11 @@ pub extern "C" fn process_copy_files(
 /// @return i32
 #[no_mangle]
 pub extern "C" fn process_exit_files(pcb: &'static mut process_control_block) -> i32 {
-    let r: Result<(), i32> = pcb.exit_files();
+    let r: Result<(), SystemError> = pcb.exit_files();
     if r.is_ok() {
         return 0;
     } else {
-        return r.unwrap_err();
+        return r.unwrap_err().to_posix_errno();
     }
 }
 

kernel/src/sched/core.rs

@@ -8,10 +8,11 @@ use crate::{
     },
     include::bindings::bindings::smp_get_total_cpu,
     include::bindings::bindings::{
-        process_control_block, pt_regs, EINVAL, EPERM, MAX_CPU_NUM, PF_NEED_MIGRATE, PROC_RUNNING,
-        SCHED_FIFO, SCHED_NORMAL, SCHED_RR,
+        process_control_block, pt_regs, MAX_CPU_NUM, PF_NEED_MIGRATE, PROC_RUNNING, SCHED_FIFO,
+        SCHED_NORMAL, SCHED_RR,
     },
     process::process::process_cpu,
+    syscall::SystemError,
 };
 
 use super::cfs::{sched_cfs_init, SchedulerCFS, __get_cfs_scheduler};
@@ -175,7 +176,7 @@ pub extern "C" fn sys_sched(regs: &'static mut pt_regs) -> u64 {
     cli();
     // 进行权限校验，拒绝用户态发起调度
     if user_mode(regs) {
-        return (-(EPERM as i64)) as u64;
+        return SystemError::EPERM.to_posix_errno() as u64;
     }
     // 根据调度结果统一进行切换
     let pcb = __sched();
@@ -204,7 +205,7 @@ pub extern "C" fn sched_migrate_process(
 ) -> i32 {
     if target > MAX_CPU_NUM.try_into().unwrap() {
         // panic!("sched_migrate_process: target > MAX_CPU_NUM");
-        return -(EINVAL as i32);
+        return SystemError::EINVAL.to_posix_errno();
     }
 
     pcb.flags |= PF_NEED_MIGRATE as u64;

kernel/src/syscall/mod.rs

@@ -1,5 +1,7 @@
+use num_traits::{FromPrimitive, ToPrimitive};
+
 #[repr(i32)]
-#[derive(Debug, FromPrimitive)]
+#[derive(Debug, FromPrimitive, ToPrimitive, PartialEq, Eq, Clone)]
 #[allow(dead_code)]
 pub enum SystemError {
     /// 参数列表过长，或者在输出buffer中缺少空间 或者参数比系统内建的最大值要大 Argument list too long.
@@ -165,3 +167,19 @@ pub enum SystemError {
     /// 跨设备连接 Cross-device link.
     EXDEV = 81,
 }
+
+impl SystemError {
+    /// @brief 把posix错误码转换为系统错误枚举类型。
+    pub fn from_posix_errno(errno: i32) -> Option<SystemError> {
+        // posix 错误码是小于0的
+        if errno >= 0 {
+            return None;
+        }
+        return <Self as FromPrimitive>::from_i32(-errno);
+    }
+
+    /// @brief 把系统错误枚举类型转换为负数posix错误码。
+    pub fn to_posix_errno(&self) -> i32 {
+        return -<Self as ToPrimitive>::to_i32(self).unwrap();
+    }
+}

tools/run-qemu.sh

@@ -35,6 +35,7 @@ QEMU_ARGUMENT="-d ${QEMU_DISK_IMAGE} -m ${QEMU_MEMORY} -smp ${QEMU_SMP} -boot or
 
 QEMU_ARGUMENT+="-s -S -cpu ${QEMU_CPU_FEATURES} -rtc ${QEMU_RTC_CLOCK} -serial ${QEMU_SERIAL} -drive ${QEMU_DRIVE} ${QEMU_DEVICES}"
 
+
 if [ $flag_can_run -eq 1 ]; then
     case "$1" in
         --bios)