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

* 将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

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -2,7 +2,7 @@
use super::spinlock::RawSpinlock;
use crate::{
arch::asm::cmpxchg::try_cmpxchg_q,
include::bindings::bindings::{ENOTSUP, ETIMEDOUT},
syscall::SystemError,
};
use core::{fmt::Debug, intrinsics::size_of};
@ -46,14 +46,14 @@ impl LockRef {
/// @brief 为X86架构实现cmpxchg循环以支持无锁操作。
///
/// @return 操作成功返回Ok(new.count)
/// @return 操作失败,原因:超时 => 返回Err(-ETIMEDOUT)
/// @return 操作失败,原因:不满足规则 => 返回Err(1)
/// @return 操作失败,原因:超时 => 返回Err(SystemError::ETIMEDOUT)
/// @return 操作失败,原因:不满足规则 => 返回Err(SystemError::E2BIG)
#[cfg(target_arch = "x86_64")]
#[inline]
fn cmpxchg_loop(&mut self, mode: CmpxchgMode) -> Result<i32, i32> {
use core::ptr::read_volatile;
use crate::arch::cpu::cpu_relax;
use crate::{arch::cpu::cpu_relax};
let mut old: LockRef = LockRef::INIT;
old.count = unsafe { read_volatile(&self.count) };
@ -114,16 +114,16 @@ impl LockRef {
}
}
return Err(-(ETIMEDOUT as i32));
return Err(SystemError::ETIMEDOUT.to_posix_errno());
}
/// @brief 对于不支持无锁lockref的架构直接返回Err(-ENOTSUP),表示不支持
/// @brief 对于不支持无锁lockref的架构直接返回Err(SystemError::ENOTSUP),表示不支持
#[cfg(not(target_arch = "x86_64"))]
#[inline]
fn cmpxchg_loop(&mut self, mode: CmpxchgMode) -> Result<i32, i32> {
use crate::include::bindings::bindings::ENOTSUP;
return Err(-(ENOTSUP as i32));
return Err(SystemError::ENOTSUP.to_posix_errno());
}
/// @brief 原子的将引用计数加1
@ -141,21 +141,20 @@ impl LockRef {
/**
* @brief 1.count0
*
* @return Result<i32, i32> =>Ok(self.count)
* =>Err(-1)
* @return Ok(self.count)
* @return Err(SystemError::EPERM)
*/
pub fn inc_not_zero(&mut self) -> Result<i32, i32> {
pub fn inc_not_zero(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_res = self.cmpxchg_loop(CmpxchgMode::IncreaseNotZero);
if cmpxchg_res.is_ok() {
return cmpxchg_res;
} else if cmpxchg_res.unwrap_err() == 1 {
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::IncreaseNotZero);
if cmpxchg_result.is_ok() {
return Ok(cmpxchg_result.unwrap());
} else if cmpxchg_result.unwrap_err() == 1 {
// 不满足not zero 的条件
return Err(-1);
return Err(SystemError::EPERM);
}
}
let mut retval = Err(-1);
let mut retval = Err(SystemError::EPERM);
self.lock.lock();
if self.count > 0 {
@ -171,19 +170,19 @@ impl LockRef {
* @brief 1lockref已经被标记为死亡
*
* @return Ok(self.count)
* @return Err(-1) lockref已死亡
* @return Err(SystemError::EPERM) lockref已死亡
*/
pub fn inc_not_dead(&mut self) -> Result<i32, i32> {
pub fn inc_not_dead(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::IncreaseNotDead);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
return Ok(cmpxchg_result.unwrap());
} else if cmpxchg_result.unwrap_err() == 1 {
return Err(-1);
return Err(SystemError::EPERM);
}
}
// 快捷路径操作失败,尝试加锁
let mut retval = Err(-1);
let mut retval = Err(SystemError::EPERM);
self.lock.lock();
if self.count >= 0 {
@ -195,29 +194,29 @@ impl LockRef {
}
/**
* @brief -1count0Err(-1)
* @brief -1count0SystemError::EPERM
*
* lockref_dec_return()cmpxchg()count<=0
*
*
* @return int =>
* lockref处于count0 => -1
* @return Ok(self.count) ,
* @return Err(SystemError::EPERM) ,lockref处于count0
*/
pub fn dec(&mut self) -> Result<i32, i32> {
pub fn dec(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::Decrease);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
return Ok(cmpxchg_result.unwrap());
}
}
let retval: Result<i32, i32>;
let retval: Result<i32, SystemError>;
self.lock.lock();
if self.count > 0 {
self.count -= 1;
retval = Ok(self.count);
} else {
retval = Err(-1);
retval = Err(SystemError::EPERM);
}
self.lock.unlock();
@ -226,26 +225,25 @@ impl LockRef {
}
/**
* @brief 1count0-1
* @brief 1count0SystemError::EPERM
* cmpxchg退self.dec()
*
* lockref_dec()cmpxchg()count<=0
*
*
* @return int =>
* lockref处于已加锁或count0 => -1
* @return Ok(self.count) ,
* @return Err(SystemError::EPERM) lockref处于已加锁或count0
*/
pub fn dec_return(&mut self) -> Result<i32, i32> {
pub fn dec_return(&mut self) -> Result<i32, SystemError> {
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::DecreaseReturn);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
} else if cmpxchg_result.unwrap_err() == 1 {
return Err(-1);
return Ok(cmpxchg_result.unwrap());
} else if *cmpxchg_result.as_ref().unwrap_err() == 1 {
return Err(SystemError::EPERM);
}
// 由于cmpxchg超时操作失败
if cmpxchg_result.unwrap_err() != -(ENOTSUP as i32) {
return Err(-1);
if *cmpxchg_result.as_ref().unwrap_err() != SystemError::ENOTSUP.to_posix_errno() {
return Err(SystemError::EFAULT);
}
// 能走到这里代表架构当前不支持cmpxchg
@ -256,29 +254,29 @@ impl LockRef {
/**
* @brief 11
*
* lockref_dec_or_lock_not_zero()cmpxchg()old.count1Err(-1)
* lockref_dec_or_lock_not_zero()cmpxchg()old.count1Err(SystemError::EPERM)
*
*
* @return Ok(self.count) 1
* @return Err(-1) 1
* @return Err(SystemError::EPERM) 1
*/
pub fn dec_not_zero(&mut self) -> Result<i32, i32> {
pub fn dec_not_zero(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::DecreaseNotZero);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
} else if cmpxchg_result.unwrap_err() == 1 {
return Err(-1);
return Ok(cmpxchg_result.unwrap());
} else if cmpxchg_result.unwrap_err() == 1{
return Err(SystemError::EPERM);
}
}
let retval: Result<i32, i32>;
let retval: Result<i32, SystemError>;
self.lock.lock();
if self.count > 1 {
self.count -= 1;
retval = Ok(self.count);
} else {
retval = Err(-1);
retval = Err(SystemError::EPERM);
}
self.lock.unlock();
return retval;
@ -288,26 +286,26 @@ impl LockRef {
* @brief 11
*
* lockref_dec_not_zero()cmpxchg()old.count1
* Err(-1).
* Err(SystemError::EPERM).
*
* @return Ok(self.count) 1
* @return Err(-1) 1
* @return Err(SystemError::EPERM) 1
*/
pub fn dec_or_lock_not_zero(&mut self) -> Result<i32, i32> {
pub fn dec_or_lock_not_zero(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::DecreaseOrLockNotZero);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
return Ok(cmpxchg_result.unwrap());
}
}
let retval: Result<i32, i32>;
let retval: Result<i32, SystemError>;
self.lock.lock();
if self.count > 1 {
self.count -= 1;
retval = Ok(self.count);
} else {
retval = Err(-1);
retval = Err(SystemError::EPERM);
}
self.lock.unlock();
return retval;

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

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