vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions 10 Packages Projects Releases Wiki Activity

Rustfmt.

Browse Source
This commit is contained in:
4lDO2
2024-09-08 20:32:32 +02:00
parent 99f49db824
commit 1d098c4e1d
21 changed files with 1051 additions and 692 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/scheme/mod.rs
+14 -9
View File
@@ -1,12 +1,11 @@
use core::{slice, str};
use crate::{Error, Result, EOPNOTSUPP, ESKMSG, Packet, SKMSG_FRETURNFD};
use crate::{Error, Packet, Result, EOPNOTSUPP, ESKMSG, SKMSG_FRETURNFD};
pub use self::scheme::Scheme;
pub use self::scheme_mut::SchemeMut;
pub use self::scheme_block::SchemeBlock;
pub use self::scheme_block_mut::SchemeBlockMut;
pub use self::seek::*;
pub use self::{
scheme::Scheme, scheme_block::SchemeBlock, scheme_block_mut::SchemeBlockMut,
scheme_mut::SchemeMut, seek::*,
};
unsafe fn str_from_raw_parts(ptr: *const u8, len: usize) -> Option<&'static str> {
let slice = slice::from_raw_parts(ptr, len);
@@ -14,9 +13,9 @@ unsafe fn str_from_raw_parts(ptr: *const u8, len: usize) -> Option<&'static str>
}
mod scheme;
mod scheme_mut;
mod scheme_block;
mod scheme_block_mut;
mod scheme_mut;
mod seek;
pub struct CallerCtx {
@@ -37,7 +36,10 @@ pub(crate) fn convert_to_this_scheme(r: Result<usize>) -> Result<OpenResult> {
pub(crate) fn convert_to_this_scheme_block(r: Result<Option<usize>>) -> Result<Option<OpenResult>> {
r.map(|o| o.map(|number| OpenResult::ThisScheme { number }))
}
pub(crate) fn convert_in_scheme_handle_block(_: &Packet, result: Result<Option<OpenResult>>) -> Result<Option<usize>> {
pub(crate) fn convert_in_scheme_handle_block(
_: &Packet,
result: Result<Option<OpenResult>>,
) -> Result<Option<usize>> {
match result {
Ok(Some(OpenResult::ThisScheme { number })) => Ok(Some(number)),
Ok(Some(OpenResult::OtherScheme { .. })) => Err(Error::new(EOPNOTSUPP)),
@@ -45,7 +47,10 @@ pub(crate) fn convert_in_scheme_handle_block(_: &Packet, result: Result<Option<O
Err(err) => Err(err),
}
}
pub(crate) fn convert_in_scheme_handle(packet: &mut Packet, result: Result<OpenResult>) -> Result<usize> {
pub(crate) fn convert_in_scheme_handle(
packet: &mut Packet,
result: Result<OpenResult>,
) -> Result<usize> {
match result {
Ok(OpenResult::ThisScheme { number }) => Ok(number),
Ok(OpenResult::OtherScheme { fd }) => {
src/scheme/scheme.rs
+93 -51
View File
@@ -1,70 +1,112 @@
use core::{mem, slice};
use crate::CallerCtx;
use crate::OpenResult;
use crate::data::*;
use crate::error::*;
use crate::flag::*;
use crate::number::*;
use crate::scheme::*;
use crate::{data::*, error::*, flag::*, number::*, scheme::*, CallerCtx, OpenResult};
pub trait Scheme {
fn handle(&self, packet: &mut Packet) {
let res = match packet.a {
SYS_OPEN => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
convert_in_scheme_handle(packet, self.xopen(path, packet.d, &CallerCtx::from_packet(&packet)))
SYS_OPEN => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
convert_in_scheme_handle(
packet,
self.xopen(path, packet.d, &CallerCtx::from_packet(&packet)),
)
} else {
Err(Error::new(EINVAL))
}
}
SYS_RMDIR => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.rmdir(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
SYS_UNLINK => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.unlink(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
else {
Err(Error::new(EINVAL))
},
SYS_RMDIR => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.rmdir(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_UNLINK => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.unlink(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_DUP => convert_in_scheme_handle(packet, self.xdup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, &CallerCtx::from_packet(&packet))),
SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }),
SYS_LSEEK => self.seek(packet.b, packet.c as isize, packet.d).map(|o| o as usize),
SYS_DUP => convert_in_scheme_handle(
packet,
self.xdup(
packet.b,
unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) },
&CallerCtx::from_packet(&packet),
),
),
SYS_READ => self.read(packet.b, unsafe {
slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
}),
SYS_WRITE => self.write(packet.b, unsafe {
slice::from_raw_parts(packet.c as *const u8, packet.d)
}),
SYS_LSEEK => self
.seek(packet.b, packet.c as isize, packet.d)
.map(|o| o as usize),
SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16),
SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32),
SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d),
SYS_FEVENT => self.fevent(packet.b, EventFlags::from_bits_truncate(packet.c)).map(|f| f.bits()),
SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
SYS_FRENAME => if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } {
self.frename(packet.b, path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_FSTAT => if packet.d >= mem::size_of::<Stat>() {
self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) })
} else {
Err(Error::new(EFAULT))
},
SYS_FSTATVFS => if packet.d >= mem::size_of::<StatVfs>() {
self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) })
} else {
Err(Error::new(EFAULT))
},
SYS_FEVENT => self
.fevent(packet.b, EventFlags::from_bits_truncate(packet.c))
.map(|f| f.bits()),
SYS_FPATH => self.fpath(packet.b, unsafe {
slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
}),
SYS_FRENAME => {
if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } {
self.frename(packet.b, path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
SYS_FSTAT => {
if packet.d >= mem::size_of::<Stat>() {
self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) })
} else {
Err(Error::new(EFAULT))
}
}
SYS_FSTATVFS => {
if packet.d >= mem::size_of::<StatVfs>() {
self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) })
} else {
Err(Error::new(EFAULT))
}
}
SYS_FSYNC => self.fsync(packet.b),
SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c),
SYS_FUTIMENS => if packet.d >= mem::size_of::<TimeSpec>() {
self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::<TimeSpec>()) })
} else {
Err(Error::new(EFAULT))
},
SYS_FUTIMENS => {
if packet.d >= mem::size_of::<TimeSpec>() {
self.futimens(packet.b, unsafe {
slice::from_raw_parts(
packet.c as *const TimeSpec,
packet.d / mem::size_of::<TimeSpec>(),
)
})
} else {
Err(Error::new(EFAULT))
}
}
SYS_CLOSE => self.close(packet.b),
KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)),
KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MunmapFlags::from_bits_truncate(packet.d)),
KSMSG_MMAP_PREP => self.mmap_prep(
packet.b,
u64::from(packet.uid) | (u64::from(packet.gid) << 32),
packet.c,
MapFlags::from_bits_truncate(packet.d),
),
KSMSG_MUNMAP => self.munmap(
packet.b,
u64::from(packet.uid) | (u64::from(packet.gid) << 32),
packet.c,
MunmapFlags::from_bits_truncate(packet.d),
),
_ => Err(Error::new(ENOSYS))
_ => Err(Error::new(ENOSYS)),
};
packet.a = Error::mux(res);
src/scheme/scheme_block.rs
+107 -53
View File
@@ -1,70 +1,112 @@
use core::{mem, slice};
use crate::CallerCtx;
use crate::OpenResult;
use crate::data::*;
use crate::error::*;
use crate::flag::*;
use crate::number::*;
use crate::scheme::*;
use crate::{data::*, error::*, flag::*, number::*, scheme::*, CallerCtx, OpenResult};
pub trait SchemeBlock {
fn handle(&self, packet: &Packet) -> Option<usize> {
let res = match packet.a {
SYS_OPEN => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
convert_in_scheme_handle_block(packet, self.xopen(path, packet.d, &CallerCtx::from_packet(&packet)))
SYS_OPEN => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
convert_in_scheme_handle_block(
packet,
self.xopen(path, packet.d, &CallerCtx::from_packet(&packet)),
)
} else {
Err(Error::new(EINVAL))
}
}
SYS_RMDIR => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.rmdir(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
SYS_UNLINK => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.unlink(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
else {
Err(Error::new(EINVAL))
},
SYS_RMDIR => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.rmdir(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_UNLINK => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.unlink(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_DUP => convert_in_scheme_handle_block(packet, self.xdup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, &CallerCtx::from_packet(&packet))),
SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }),
SYS_LSEEK => self.seek(packet.b, packet.c as isize, packet.d).map(|o| o.map(|o| o as usize)),
SYS_DUP => convert_in_scheme_handle_block(
packet,
self.xdup(
packet.b,
unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) },
&CallerCtx::from_packet(&packet),
),
),
SYS_READ => self.read(packet.b, unsafe {
slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
}),
SYS_WRITE => self.write(packet.b, unsafe {
slice::from_raw_parts(packet.c as *const u8, packet.d)
}),
SYS_LSEEK => self
.seek(packet.b, packet.c as isize, packet.d)
.map(|o| o.map(|o| o as usize)),
SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16),
SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32),
SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d),
SYS_FEVENT => self.fevent(packet.b, EventFlags::from_bits_truncate(packet.c)).map(|f| f.map(|f| f.bits())),
SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
SYS_FRENAME => if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } {
self.frename(packet.b, path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_FSTAT => if packet.d >= mem::size_of::<Stat>() {
self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) })
} else {
Err(Error::new(EFAULT))
},
SYS_FSTATVFS => if packet.d >= mem::size_of::<StatVfs>() {
self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) })
} else {
Err(Error::new(EFAULT))
},
SYS_FEVENT => self
.fevent(packet.b, EventFlags::from_bits_truncate(packet.c))
.map(|f| f.map(|f| f.bits())),
SYS_FPATH => self.fpath(packet.b, unsafe {
slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
}),
SYS_FRENAME => {
if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } {
self.frename(packet.b, path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
SYS_FSTAT => {
if packet.d >= mem::size_of::<Stat>() {
self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) })
} else {
Err(Error::new(EFAULT))
}
}
SYS_FSTATVFS => {
if packet.d >= mem::size_of::<StatVfs>() {
self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) })
} else {
Err(Error::new(EFAULT))
}
}
SYS_FSYNC => self.fsync(packet.b),
SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c),
SYS_FUTIMENS => if packet.d >= mem::size_of::<TimeSpec>() {
self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::<TimeSpec>()) })
} else {
Err(Error::new(EFAULT))
},
SYS_FUTIMENS => {
if packet.d >= mem::size_of::<TimeSpec>() {
self.futimens(packet.b, unsafe {
slice::from_raw_parts(
packet.c as *const TimeSpec,
packet.d / mem::size_of::<TimeSpec>(),
)
})
} else {
Err(Error::new(EFAULT))
}
}
SYS_CLOSE => self.close(packet.b),
KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)),
KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MunmapFlags::from_bits_truncate(packet.d)),
KSMSG_MMAP_PREP => self.mmap_prep(
packet.b,
u64::from(packet.uid) | (u64::from(packet.gid) << 32),
packet.c,
MapFlags::from_bits_truncate(packet.d),
),
KSMSG_MUNMAP => self.munmap(
packet.b,
u64::from(packet.uid) | (u64::from(packet.gid) << 32),
packet.c,
MunmapFlags::from_bits_truncate(packet.d),
),
_ => Err(Error::new(ENOSYS))
_ => Err(Error::new(ENOSYS)),
};
res.transpose().map(Error::mux)
@@ -183,12 +225,24 @@ pub trait SchemeBlock {
}
#[allow(unused_variables)]
fn mmap_prep(&self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result<Option<usize>> {
fn mmap_prep(
&self,
id: usize,
offset: u64,
size: usize,
flags: MapFlags,
) -> Result<Option<usize>> {
Err(Error::new(EOPNOTSUPP))
}
#[allow(unused_variables)]
fn munmap(&self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result<Option<usize>> {
fn munmap(
&self,
id: usize,
offset: u64,
size: usize,
flags: MunmapFlags,
) -> Result<Option<usize>> {
Err(Error::new(EOPNOTSUPP))
}
}
src/scheme/scheme_block_mut.rs
+107 -53
View File
@@ -1,70 +1,112 @@
use core::{mem, slice};
use crate::CallerCtx;
use crate::OpenResult;
use crate::data::*;
use crate::error::*;
use crate::flag::*;
use crate::number::*;
use crate::scheme::*;
use crate::{data::*, error::*, flag::*, number::*, scheme::*, CallerCtx, OpenResult};
pub trait SchemeBlockMut {
fn handle(&mut self, packet: &Packet) -> Option<usize> {
let res = match packet.a {
SYS_OPEN => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
convert_in_scheme_handle_block(packet, self.xopen(path, packet.d, &CallerCtx::from_packet(&packet)))
SYS_OPEN => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
convert_in_scheme_handle_block(
packet,
self.xopen(path, packet.d, &CallerCtx::from_packet(&packet)),
)
} else {
Err(Error::new(EINVAL))
}
}
SYS_RMDIR => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.rmdir(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
SYS_UNLINK => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.unlink(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
else {
Err(Error::new(EINVAL))
},
SYS_RMDIR => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.rmdir(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_UNLINK => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.unlink(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_DUP => convert_in_scheme_handle_block(packet, self.xdup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, &CallerCtx::from_packet(&packet))),
SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }),
SYS_LSEEK => self.seek(packet.b, packet.c as isize, packet.d).map(|o| o.map(|o| o as usize)),
SYS_DUP => convert_in_scheme_handle_block(
packet,
self.xdup(
packet.b,
unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) },
&CallerCtx::from_packet(&packet),
),
),
SYS_READ => self.read(packet.b, unsafe {
slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
}),
SYS_WRITE => self.write(packet.b, unsafe {
slice::from_raw_parts(packet.c as *const u8, packet.d)
}),
SYS_LSEEK => self
.seek(packet.b, packet.c as isize, packet.d)
.map(|o| o.map(|o| o as usize)),
SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16),
SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32),
SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d),
SYS_FEVENT => self.fevent(packet.b, EventFlags::from_bits_truncate(packet.c)).map(|f| f.map(|f| f.bits())),
SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
SYS_FRENAME => if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } {
self.frename(packet.b, path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_FSTAT => if packet.d >= mem::size_of::<Stat>() {
self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) })
} else {
Err(Error::new(EFAULT))
},
SYS_FSTATVFS => if packet.d >= mem::size_of::<StatVfs>() {
self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) })
} else {
Err(Error::new(EFAULT))
},
SYS_FEVENT => self
.fevent(packet.b, EventFlags::from_bits_truncate(packet.c))
.map(|f| f.map(|f| f.bits())),
SYS_FPATH => self.fpath(packet.b, unsafe {
slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
}),
SYS_FRENAME => {
if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } {
self.frename(packet.b, path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
SYS_FSTAT => {
if packet.d >= mem::size_of::<Stat>() {
self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) })
} else {
Err(Error::new(EFAULT))
}
}
SYS_FSTATVFS => {
if packet.d >= mem::size_of::<StatVfs>() {
self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) })
} else {
Err(Error::new(EFAULT))
}
}
SYS_FSYNC => self.fsync(packet.b),
SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c),
SYS_FUTIMENS => if packet.d >= mem::size_of::<TimeSpec>() {
self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::<TimeSpec>()) })
} else {
Err(Error::new(EFAULT))
},
SYS_FUTIMENS => {
if packet.d >= mem::size_of::<TimeSpec>() {
self.futimens(packet.b, unsafe {
slice::from_raw_parts(
packet.c as *const TimeSpec,
packet.d / mem::size_of::<TimeSpec>(),
)
})
} else {
Err(Error::new(EFAULT))
}
}
SYS_CLOSE => self.close(packet.b),
KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)),
KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MunmapFlags::from_bits_truncate(packet.d)),
KSMSG_MMAP_PREP => self.mmap_prep(
packet.b,
u64::from(packet.uid) | (u64::from(packet.gid) << 32),
packet.c,
MapFlags::from_bits_truncate(packet.d),
),
KSMSG_MUNMAP => self.munmap(
packet.b,
u64::from(packet.uid) | (u64::from(packet.gid) << 32),
packet.c,
MunmapFlags::from_bits_truncate(packet.d),
),
_ => Err(Error::new(ENOSYS))
_ => Err(Error::new(ENOSYS)),
};
res.transpose().map(Error::mux)
@@ -183,12 +225,24 @@ pub trait SchemeBlockMut {
}
#[allow(unused_variables)]
fn mmap_prep(&mut self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result<Option<usize>> {
fn mmap_prep(
&mut self,
id: usize,
offset: u64,
size: usize,
flags: MapFlags,
) -> Result<Option<usize>> {
Err(Error::new(EOPNOTSUPP))
}
#[allow(unused_variables)]
fn munmap(&mut self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result<Option<usize>> {
fn munmap(
&mut self,
id: usize,
offset: u64,
size: usize,
flags: MunmapFlags,
) -> Result<Option<usize>> {
Err(Error::new(EOPNOTSUPP))
}
}
src/scheme/scheme_mut.rs
+93 -51
View File
@@ -1,70 +1,112 @@
use core::{mem, slice};
use crate::CallerCtx;
use crate::OpenResult;
use crate::data::*;
use crate::error::*;
use crate::flag::*;
use crate::number::*;
use crate::scheme::*;
use crate::{data::*, error::*, flag::*, number::*, scheme::*, CallerCtx, OpenResult};
pub trait SchemeMut {
fn handle(&mut self, packet: &mut Packet) {
let res = match packet.a {
SYS_OPEN => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
convert_in_scheme_handle(packet, self.xopen(path, packet.d, &CallerCtx::from_packet(&packet)))
SYS_OPEN => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
convert_in_scheme_handle(
packet,
self.xopen(path, packet.d, &CallerCtx::from_packet(&packet)),
)
} else {
Err(Error::new(EINVAL))
}
}
SYS_RMDIR => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.rmdir(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
SYS_UNLINK => {
if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.unlink(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
else {
Err(Error::new(EINVAL))
},
SYS_RMDIR => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.rmdir(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_UNLINK => if let Some(path) = unsafe { str_from_raw_parts(packet.b as *const u8, packet.c) } {
self.unlink(path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_DUP => convert_in_scheme_handle(packet, self.xdup(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }, &CallerCtx::from_packet(&packet))),
SYS_READ => self.read(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
SYS_WRITE => self.write(packet.b, unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) }),
SYS_LSEEK => self.seek(packet.b, packet.c as isize, packet.d).map(|o| o as usize),
SYS_DUP => convert_in_scheme_handle(
packet,
self.xdup(
packet.b,
unsafe { slice::from_raw_parts(packet.c as *const u8, packet.d) },
&CallerCtx::from_packet(&packet),
),
),
SYS_READ => self.read(packet.b, unsafe {
slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
}),
SYS_WRITE => self.write(packet.b, unsafe {
slice::from_raw_parts(packet.c as *const u8, packet.d)
}),
SYS_LSEEK => self
.seek(packet.b, packet.c as isize, packet.d)
.map(|o| o as usize),
SYS_FCHMOD => self.fchmod(packet.b, packet.c as u16),
SYS_FCHOWN => self.fchown(packet.b, packet.c as u32, packet.d as u32),
SYS_FCNTL => self.fcntl(packet.b, packet.c, packet.d),
SYS_FEVENT => self.fevent(packet.b, EventFlags::from_bits_truncate(packet.c)).map(|f| f.bits()),
SYS_FPATH => self.fpath(packet.b, unsafe { slice::from_raw_parts_mut(packet.c as *mut u8, packet.d) }),
SYS_FRENAME => if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } {
self.frename(packet.b, path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
},
SYS_FSTAT => if packet.d >= mem::size_of::<Stat>() {
self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) })
} else {
Err(Error::new(EFAULT))
},
SYS_FSTATVFS => if packet.d >= mem::size_of::<StatVfs>() {
self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) })
} else {
Err(Error::new(EFAULT))
},
SYS_FEVENT => self
.fevent(packet.b, EventFlags::from_bits_truncate(packet.c))
.map(|f| f.bits()),
SYS_FPATH => self.fpath(packet.b, unsafe {
slice::from_raw_parts_mut(packet.c as *mut u8, packet.d)
}),
SYS_FRENAME => {
if let Some(path) = unsafe { str_from_raw_parts(packet.c as *const u8, packet.d) } {
self.frename(packet.b, path, packet.uid, packet.gid)
} else {
Err(Error::new(EINVAL))
}
}
SYS_FSTAT => {
if packet.d >= mem::size_of::<Stat>() {
self.fstat(packet.b, unsafe { &mut *(packet.c as *mut Stat) })
} else {
Err(Error::new(EFAULT))
}
}
SYS_FSTATVFS => {
if packet.d >= mem::size_of::<StatVfs>() {
self.fstatvfs(packet.b, unsafe { &mut *(packet.c as *mut StatVfs) })
} else {
Err(Error::new(EFAULT))
}
}
SYS_FSYNC => self.fsync(packet.b),
SYS_FTRUNCATE => self.ftruncate(packet.b, packet.c),
SYS_FUTIMENS => if packet.d >= mem::size_of::<TimeSpec>() {
self.futimens(packet.b, unsafe { slice::from_raw_parts(packet.c as *const TimeSpec, packet.d / mem::size_of::<TimeSpec>()) })
} else {
Err(Error::new(EFAULT))
},
SYS_FUTIMENS => {
if packet.d >= mem::size_of::<TimeSpec>() {
self.futimens(packet.b, unsafe {
slice::from_raw_parts(
packet.c as *const TimeSpec,
packet.d / mem::size_of::<TimeSpec>(),
)
})
} else {
Err(Error::new(EFAULT))
}
}
SYS_CLOSE => self.close(packet.b),
KSMSG_MMAP_PREP => self.mmap_prep(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MapFlags::from_bits_truncate(packet.d)),
KSMSG_MUNMAP => self.munmap(packet.b, u64::from(packet.uid) | (u64::from(packet.gid) << 32), packet.c, MunmapFlags::from_bits_truncate(packet.d)),
KSMSG_MMAP_PREP => self.mmap_prep(
packet.b,
u64::from(packet.uid) | (u64::from(packet.gid) << 32),
packet.c,
MapFlags::from_bits_truncate(packet.d),
),
KSMSG_MUNMAP => self.munmap(
packet.b,
u64::from(packet.uid) | (u64::from(packet.gid) << 32),
packet.c,
MunmapFlags::from_bits_truncate(packet.d),
),
_ => Err(Error::new(ENOSYS))
_ => Err(Error::new(ENOSYS)),
};
packet.a = Error::mux(res);
src/scheme/seek.rs
+16 -8
View File
@@ -1,13 +1,16 @@
use core::cmp;
use core::convert::TryFrom;
use crate::error::*;
use crate::flag::*;
use crate::{error::*, flag::*};
use core::{cmp, convert::TryFrom};
/// Helper for seek calls
/// In most cases it's easier to use a usize to track the offset and buffer size internally,
/// but the seek interface uses isize. This wrapper ensures EOVERFLOW errors are returned
/// as appropriate if the value in the usize can't fit in the isize.
pub fn calc_seek_offset_usize(cur_offset: usize, pos: isize, whence: usize, buf_len: usize) -> Result<isize> {
pub fn calc_seek_offset_usize(
cur_offset: usize,
pos: isize,
whence: usize,
buf_len: usize,
) -> Result<isize> {
let cur_offset = isize::try_from(cur_offset).or_else(|_| Err(Error::new(EOVERFLOW)))?;
let buf_len = isize::try_from(buf_len).or_else(|_| Err(Error::new(EOVERFLOW)))?;
calc_seek_offset_isize(cur_offset, pos, whence, buf_len)
@@ -17,7 +20,12 @@ pub fn calc_seek_offset_usize(cur_offset: usize, pos: isize, whence: usize, buf_
/// Result is guaranteed to be positive.
/// EOVERFLOW returned if the arguments would cause an overflow.
/// EINVAL returned if the new offset is out of bounds.
pub fn calc_seek_offset_isize(cur_offset: isize, pos: isize, whence: usize, buf_len: isize) -> Result<isize> {
pub fn calc_seek_offset_isize(
cur_offset: isize,
pos: isize,
whence: usize,
buf_len: isize,
) -> Result<isize> {
let new_offset = match whence {
SEEK_CUR => pos.checked_add(cur_offset),
SEEK_END => pos.checked_add(buf_len),
@@ -28,6 +36,6 @@ pub fn calc_seek_offset_isize(cur_offset: isize, pos: isize, whence: usize, buf_
match new_offset {
Some(new_offset) if new_offset < 0 => Err(Error::new(EINVAL)),
Some(new_offset) => Ok(cmp::min(new_offset, buf_len)),
None => Err(Error::new(EOVERFLOW))
None => Err(Error::new(EOVERFLOW)),
}
}
}