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

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

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

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
         }