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

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

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

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

1
DragonOS

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

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

@ -59,8 +59,8 @@ struct lockref
### 4.1. 引用计数自增
- `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)`

32
kernel/src/driver/disk/ahci/ahci_inode.rs
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);
}
}

32
kernel/src/driver/disk/ahci/ahcidisk.rs
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();
}

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

@ -10,6 +10,7 @@ use crate::io::disk_info::BLK_GF_AHCI;
use crate::kerror;
use crate::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

24
kernel/src/driver/keyboard/ps2_keyboard.rs
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);
}
}

4
kernel/src/driver/timers/rtc/rtc.rs
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

27
kernel/src/driver/tty/tty_device.rs
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);
}
}

1
kernel/src/driver/video/video.c
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);

2
kernel/src/driver/virtio/virtio.rs
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
}

22
kernel/src/exception/softirq.rs
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 遍历执行软中断

89
kernel/src/filesystem/devfs/mod.rs
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);
}

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

@ -4,7 +4,7 @@ use crate::filesystem::vfs::{
core::generate_inode_id, FilePrivateData, FileSystem, FileType, IndexNode, Metadata, PollStatus,
};
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)

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

@ -4,7 +4,7 @@ use crate::filesystem::vfs::{
core::generate_inode_id, FilePrivateData, FileSystem, FileType, IndexNode, Metadata, PollStatus,
};
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)

37
kernel/src/filesystem/fat/bpb.rs
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(());

160
kernel/src/filesystem/fat/entry.rs
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(

136
kernel/src/filesystem/fat/fs.rs
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)
}

97
kernel/src/filesystem/procfs/mod.rs
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")?;

87
kernel/src/filesystem/ramfs/mod.rs
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();

74
kernel/src/filesystem/vfs/core.rs
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);
}
// 删除文件

44
kernel/src/filesystem/vfs/file.rs
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()

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

@ -11,8 +11,8 @@ use ::core::{any::Any, fmt::Debug};
use alloc::{string::String, sync::Arc, vec::Vec};
use 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;

53
kernel/src/filesystem/vfs/mount.rs
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);
}
// 为新的挂载点创建挂载文件系统

83
kernel/src/filesystem/vfs/syscall.rs
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;

28
kernel/src/io/device.rs
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)
}
}

80
kernel/src/ipc/signal.rs
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中对应的位进行置位

104
kernel/src/libs/lockref.rs
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.如果原来的count≤0，则操作失败。
*
* @return Result<i32, i32> 操作成功=>Ok(self.count)
* 操作失败=>Err(-1)
* @return Ok(self.count) 操作成功
* @return Err(SystemError::EPERM) 操作失败
*/
pub fn inc_not_zero(&mut self) -> Result<i32, i32> {
pub fn inc_not_zero(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_res = self.cmpxchg_loop(CmpxchgMode::IncreaseNotZero);
if cmpxchg_res.is_ok() {
return cmpxchg_res;
} else if cmpxchg_res.unwrap_err() == 1 {
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::IncreaseNotZero);
if cmpxchg_result.is_ok() {
return Ok(cmpxchg_result.unwrap());
} else if cmpxchg_result.unwrap_err() == 1 {
// 不满足not zero 的条件
return Err(-1);
return Err(SystemError::EPERM);
}
}
let mut retval = Err(-1);
let mut retval = Err(SystemError::EPERM);
self.lock.lock();
if self.count > 0 {
@ -171,19 +170,19 @@ impl LockRef {
* @brief 引用计数自增1。（除非该lockref已经被标记为死亡）
*
* @return Ok(self.count) 操作成功
* @return Err(-1) 操作失败，lockref已死亡
* @return Err(SystemError::EPERM) 操作失败，lockref已死亡
*/
pub fn inc_not_dead(&mut self) -> Result<i32, i32> {
pub fn inc_not_dead(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::IncreaseNotDead);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
return Ok(cmpxchg_result.unwrap());
} else if cmpxchg_result.unwrap_err() == 1 {
return Err(-1);
return Err(SystemError::EPERM);
}
}
// 快捷路径操作失败，尝试加锁
let mut retval = Err(-1);
let mut retval = Err(SystemError::EPERM);
self.lock.lock();
if self.count >= 0 {
@ -195,29 +194,29 @@ impl LockRef {
}
/**
* @brief 原子地将引用计数-1。如果已处于count≤0的状态，则返回Err(-1)
* @brief 原子地将引用计数-1。如果已处于count≤0的状态，则返回SystemError::EPERM
*
* 本函数与lockref_dec_return()的区别在于，当在cmpxchg()中检测到count<=0或已加锁，本函数会再次尝试通过加锁来执行操作
* 而后者会直接返回错误
*
* @return int 操作成功 => 返回新的引用变量值
* 操作失败lockref处于count≤0的状态 => 返回-1
* @return Ok(self.count) 操作成功,返回新的引用变量值
* @return Err(SystemError::EPERM) 操作失败,lockref处于count≤0的状态
*/
pub fn dec(&mut self) -> Result<i32, i32> {
pub fn dec(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::Decrease);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
return Ok(cmpxchg_result.unwrap());
}
}
let retval: Result<i32, i32>;
let retval: Result<i32, SystemError>;
self.lock.lock();
if self.count > 0 {
self.count -= 1;
retval = Ok(self.count);
} else {
retval = Err(-1);
retval = Err(SystemError::EPERM);
}
self.lock.unlock();
@ -226,26 +225,25 @@ impl LockRef {
}
/**
* @brief 原子地将引用计数减1。如果处于已加锁或count≤0的状态，则返回-1
* @brief 原子地将引用计数减1。如果处于已加锁或count≤0的状态，则返回SystemError::EPERM
* 若当前处理器架构不支持cmpxchg，则退化为self.dec()
*
* 本函数与lockref_dec()的区别在于，当在cmpxchg()中检测到count<=0或已加锁，本函数会直接返回错误
* 而后者会再次尝试通过加锁来执行操作
*
* @return int 操作成功 => 返回新的引用变量值
* 操作失败，lockref处于已加锁或count≤0的状态 => 返回-1
* @return Ok(self.count) 操作成功,返回新的引用变量值
* @return Err(SystemError::EPERM) 操作失败，lockref处于已加锁或count≤0的状态
*/
pub fn dec_return(&mut self) -> Result<i32, i32> {
pub fn dec_return(&mut self) -> Result<i32, SystemError> {
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::DecreaseReturn);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
} else if cmpxchg_result.unwrap_err() == 1 {
return Err(-1);
return Ok(cmpxchg_result.unwrap());
} else if *cmpxchg_result.as_ref().unwrap_err() == 1 {
return Err(SystemError::EPERM);
}
// 由于cmpxchg超时，操作失败
if cmpxchg_result.unwrap_err() != -(ENOTSUP as i32) {
return Err(-1);
if *cmpxchg_result.as_ref().unwrap_err() != SystemError::ENOTSUP.to_posix_errno() {
return Err(SystemError::EFAULT);
}
// 能走到这里，代表架构当前不支持cmpxchg
@ -256,29 +254,29 @@ impl LockRef {
/**
* @brief 原子地将引用计数减1。若当前的引用计数≤1，则操作失败
*
* 该函数与lockref_dec_or_lock_not_zero()的区别在于，当cmpxchg()时发现old.count≤1时，该函数会直接返回Err(-1)
* 该函数与lockref_dec_or_lock_not_zero()的区别在于，当cmpxchg()时发现old.count≤1时，该函数会直接返回Err(SystemError::EPERM)
* 而后者在这种情况下，会尝试加锁来进行操作。
*
* @return Ok(self.count) 成功将引用计数减1
* @return Err(-1) 如果当前的引用计数≤1，操作失败
* @return Err(SystemError::EPERM) 如果当前的引用计数≤1，操作失败
*/
pub fn dec_not_zero(&mut self) -> Result<i32, i32> {
pub fn dec_not_zero(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::DecreaseNotZero);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
} else if cmpxchg_result.unwrap_err() == 1 {
return Err(-1);
return Ok(cmpxchg_result.unwrap());
} else if cmpxchg_result.unwrap_err() == 1{
return Err(SystemError::EPERM);
}
}
let retval: Result<i32, i32>;
let retval: Result<i32, SystemError>;
self.lock.lock();
if self.count > 1 {
self.count -= 1;
retval = Ok(self.count);
} else {
retval = Err(-1);
retval = Err(SystemError::EPERM);
}
self.lock.unlock();
return retval;
@ -288,26 +286,26 @@ impl LockRef {
* @brief 原子地将引用计数减1。若当前的引用计数≤1，则操作失败
*
* 该函数与lockref_dec_not_zero()的区别在于，当cmpxchg()时发现old.count≤1时，该函数会尝试加锁来进行操作。
* 而后者在这种情况下，会直接返回Err(-1).
* 而后者在这种情况下，会直接返回Err(SystemError::EPERM).
*
* @return Ok(self.count) 成功将引用计数减1
* @return Err(-1) 如果当前的引用计数≤1，操作失败
* @return Err(SystemError::EPERM) 如果当前的引用计数≤1，操作失败
*/
pub fn dec_or_lock_not_zero(&mut self) -> Result<i32, i32> {
pub fn dec_or_lock_not_zero(&mut self) -> Result<i32, SystemError> {
{
let cmpxchg_result = self.cmpxchg_loop(CmpxchgMode::DecreaseOrLockNotZero);
if cmpxchg_result.is_ok() {
return cmpxchg_result;
return Ok(cmpxchg_result.unwrap());
}
}
let retval: Result<i32, i32>;
let retval: Result<i32, SystemError>;
self.lock.lock();
if self.count > 1 {
self.count -= 1;
retval = Ok(self.count);
} else {
retval = Err(-1);
retval = Err(SystemError::EPERM);
}
self.lock.unlock();
return retval;

8
kernel/src/libs/mutex.rs
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;

6
kernel/src/libs/rwlock.rs
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);
}

6
kernel/src/libs/semaphore.rs
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);
}
}

57
kernel/src/libs/vec_cursor.rs
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[..]);

33
kernel/src/mm/mmio_buddy.rs
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;
}

8
kernel/src/process/fork.rs
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中的字段

36
kernel/src/process/process.rs
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();
}
}

9
kernel/src/sched/core.rs
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;

20
kernel/src/syscall/mod.rs
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();
}
}

1
tools/run-qemu.sh
View File

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