DragonOS-Community/DragonOS
4
1
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2025-06-12 10:06:47 +00:00
Code Issues Releases Wiki Activity

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

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

Co-authored-by: longjin <longjin@RinGoTek.cn>
This commit is contained in:
Mork 2023-03-29 21:24:11 +08:00 committed by GitHub
parent 64aea4b349
commit 676b8ef62e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
37 changed files with 801 additions and 786 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
DragonOS

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

30
docs/kernel/locking/lockref.md
View File

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

32
kernel/src/driver/disk/ahci/ahci_inode.rs
View File

@ -5,8 +5,8 @@ use crate::filesystem::vfs::{
Metadata, PollStatus, Metadata, PollStatus,
}; };
use crate::io::device::BlockDevice; use crate::io::device::BlockDevice;
use crate::syscall::SystemError;
use crate::{ use crate::{
include::bindings::bindings::{EINVAL, ENOTSUP},
libs::spinlock::SpinLock, libs::spinlock::SpinLock,
time::TimeSpec, time::TimeSpec,
}; };
@ -78,15 +78,15 @@ impl IndexNode for LockedAhciInode {
self self
} }
fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), i32> { fn open(&self, _data: &mut FilePrivateData, _mode: &FileMode) -> Result<(), SystemError> {
Err(-(ENOTSUP as i32)) Err(SystemError::ENOTSUP)
} }
fn close(&self, _data: &mut FilePrivateData) -> Result<(), i32> { fn close(&self, _data: &mut FilePrivateData) -> Result<(), SystemError> {
Err(-(ENOTSUP as i32)) Err(SystemError::ENOTSUP)
} }
fn metadata(&self) -> Result<Metadata, i32> { fn metadata(&self) -> Result<Metadata, SystemError> {
return Ok(self.0.lock().metadata.clone()); return Ok(self.0.lock().metadata.clone());
} }
@ -94,11 +94,11 @@ impl IndexNode for LockedAhciInode {
return self.0.lock().fs.upgrade().unwrap(); return self.0.lock().fs.upgrade().unwrap();
} }
fn list(&self) -> Result<Vec<String>, i32> { fn list(&self) -> Result<Vec<String>, SystemError> {
Err(-(ENOTSUP as i32)) 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(); let mut inode = self.0.lock();
inode.metadata.atime = metadata.atime; inode.metadata.atime = metadata.atime;
inode.metadata.mtime = metadata.mtime; inode.metadata.mtime = metadata.mtime;
@ -110,7 +110,7 @@ impl IndexNode for LockedAhciInode {
return Ok(()); return Ok(());
} }
fn poll(&self) -> Result<PollStatus, i32> { fn poll(&self) -> Result<PollStatus, SystemError> {
return Ok(PollStatus { return Ok(PollStatus {
flags: PollStatus::READ_MASK | PollStatus::WRITE_MASK, flags: PollStatus::READ_MASK | PollStatus::WRITE_MASK,
}); });
@ -123,16 +123,16 @@ impl IndexNode for LockedAhciInode {
len: usize, len: usize,
buf: &mut [u8], buf: &mut [u8],
data: &mut FilePrivateData, data: &mut FilePrivateData,
) -> Result<usize, i32> { ) -> Result<usize, SystemError> {
if buf.len() < len { if buf.len() < len {
return Err(-(EINVAL as i32)); return Err(SystemError::EINVAL);
} }
if let FilePrivateData::Unused = data { if let FilePrivateData::Unused = data {
return self.0.lock().disk.read_at(offset, len, buf); 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, len: usize,
buf: &[u8], buf: &[u8],
data: &mut FilePrivateData, data: &mut FilePrivateData,
) -> Result<usize, i32> { ) -> Result<usize, SystemError> {
if buf.len() < len { if buf.len() < len {
return Err(-(EINVAL as i32)); return Err(SystemError::EINVAL);
} }
if let FilePrivateData::Unused = data { if let FilePrivateData::Unused = data {
return self.0.lock().disk.write_at(offset, len, buf); return self.0.lock().disk.write_at(offset, len, buf);
} }
return Err(-(EINVAL as i32)); return Err(SystemError::EINVAL);
} }
} }

32
kernel/src/driver/disk/ahci/ahcidisk.rs
View File

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

12
kernel/src/driver/disk/ahci/mod.rs
View File

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

24
kernel/src/driver/keyboard/ps2_keyboard.rs
View File

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

4
kernel/src/driver/timers/rtc/rtc.rs
View File

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

27
kernel/src/driver/tty/tty_device.rs
View File

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

1
kernel/src/driver/video/video.c
View File

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

2
kernel/src/driver/virtio/virtio.rs
View File

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

22
kernel/src/exception/softirq.rs
View File

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

89
kernel/src/filesystem/devfs/mod.rs
View File

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

28
kernel/src/filesystem/devfs/null_dev.rs
View File

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

28
kernel/src/filesystem/devfs/zero_dev.rs
View File

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

37
kernel/src/filesystem/fat/bpb.rs
View File

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

160
kernel/src/filesystem/fat/entry.rs
View File

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

136
kernel/src/filesystem/fat/fs.rs
View File

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

97
kernel/src/filesystem/procfs/mod.rs
View File

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

87
kernel/src/filesystem/ramfs/mod.rs
View File

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

74
kernel/src/filesystem/vfs/core.rs
View File

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

44
kernel/src/filesystem/vfs/file.rs
View File

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

88
kernel/src/filesystem/vfs/mod.rs
View File

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

53
kernel/src/filesystem/vfs/mount.rs
View File

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

83
kernel/src/filesystem/vfs/syscall.rs
View File

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

28
kernel/src/io/device.rs
View File

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

80
kernel/src/ipc/signal.rs
View File

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

104
kernel/src/libs/lockref.rs
View File

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

8
kernel/src/libs/mutex.rs
View File

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

6
kernel/src/libs/rwlock.rs
View File

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

6
kernel/src/libs/semaphore.rs
View File

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

57
kernel/src/libs/vec_cursor.rs
View File

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

33
kernel/src/mm/mmio_buddy.rs
View File

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

8
kernel/src/process/fork.rs
View File

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

36
kernel/src/process/process.rs
View File

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

9
kernel/src/sched/core.rs
View File

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

20
kernel/src/syscall/mod.rs
View File

@ -1,5 +1,7 @@
use num_traits::{FromPrimitive, ToPrimitive};
#[repr(i32)] #[repr(i32)]
#[derive(Debug, FromPrimitive)] #[derive(Debug, FromPrimitive, ToPrimitive, PartialEq, Eq, Clone)]
#[allow(dead_code)] #[allow(dead_code)]
pub enum SystemError { pub enum SystemError {
/// 参数列表过长，或者在输出buffer中缺少空间 或者参数比系统内建的最大值要大 Argument list too long. /// 参数列表过长，或者在输出buffer中缺少空间 或者参数比系统内建的最大值要大 Argument list too long.
@ -165,3 +167,19 @@ pub enum SystemError {
/// 跨设备连接 Cross-device link. /// 跨设备连接 Cross-device link.
EXDEV = 81, 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();
}
}

1
tools/run-qemu.sh
View File

@ -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}" 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 if [ $flag_can_run -eq 1 ]; then
case "$1" in case "$1" in
--bios) --bios)