mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
MemoryRange: move to using this struct for memory ranges
This is a combination of MemoryAddress and MemorySize. This is guaranteed to be not null. Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
parent
94459c8d43
commit
bdb8eac9ad
12 changed files with 107 additions and 108 deletions
|
|
@ -3,26 +3,19 @@ use core::slice;
|
|||
use xous;
|
||||
|
||||
pub struct LogString<'a> {
|
||||
backing: &'a [u8],
|
||||
s: &'a str,
|
||||
}
|
||||
|
||||
impl<'a> LogString<'a> {
|
||||
pub fn from_message(message: xous::MemoryMessage) -> LogString<'a> {
|
||||
pub fn from_message(message: &xous::MemoryMessage) -> LogString<'a> {
|
||||
println!(
|
||||
"Message address is at {:08x}",
|
||||
message.buf.expect("no buffer").get()
|
||||
message.buf.addr.get()
|
||||
);
|
||||
LogString {
|
||||
backing: unsafe {
|
||||
slice::from_raw_parts(
|
||||
message.buf.expect("no buffer present").get() as *mut u8,
|
||||
message.buf_size.expect("no buffer length present").get(),
|
||||
)
|
||||
},
|
||||
s: unsafe {
|
||||
core::str::from_utf8(slice::from_raw_parts(
|
||||
message.buf.expect("no buffer present").get() as *mut u8,
|
||||
message.buf.addr.get() as *mut u8,
|
||||
message.valid.expect("no buffer length present").get(),
|
||||
))
|
||||
.expect("message didn't have valid utf8")
|
||||
|
|
@ -36,10 +29,3 @@ impl<'a> fmt::Display for LogString<'a> {
|
|||
write!(f, "{}", self.s)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Drop for LogString<'a> {
|
||||
fn drop(&mut self) {
|
||||
xous::syscall::unmap_memory(xous::MemoryAddress::new(self.backing.as_ptr() as usize).unwrap(), self.backing.len())
|
||||
.expect("couldn't free string");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,8 +34,8 @@ fn main() {
|
|||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.expect("couldn't map serial port");
|
||||
unsafe { debug::DEFAULT_UART_ADDR = uart.base as *mut usize };
|
||||
println!("Mapped UART @ {:08x}", uart.base as usize);
|
||||
unsafe { debug::DEFAULT_UART_ADDR = uart.as_mut_ptr() };
|
||||
println!("Mapped UART @ {:08x}", uart.addr.get());
|
||||
|
||||
println!("Process: map success!");
|
||||
debug::DEFAULT.enable_rx();
|
||||
|
|
@ -81,7 +81,7 @@ fn main() {
|
|||
// println!("Waiting for an event...");
|
||||
let envelope = xous::syscall::receive_message(server_addr).expect("couldn't get address");
|
||||
// println!("Got message envelope: {:?}", envelope);
|
||||
match envelope.message {
|
||||
match &envelope.message {
|
||||
xous::Message::Scalar(msg) => {
|
||||
println!("Scalar message from {}: {:?}", envelope.sender, msg)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,13 +18,13 @@ impl<'a> LogStr<'a> {
|
|||
)
|
||||
.expect("couldn't allocate memory");
|
||||
|
||||
let raw_slice = unsafe { slice::from_raw_parts_mut(mem.base, 4096) };
|
||||
let raw_slice = unsafe { slice::from_raw_parts_mut(mem.as_ptr() as *mut u8, 4096) };
|
||||
|
||||
LogStr {
|
||||
raw_slice,
|
||||
len: 0,
|
||||
string: unsafe {
|
||||
core::str::from_utf8_unchecked(slice::from_raw_parts(mem.base, 0))
|
||||
core::str::from_utf8_unchecked(slice::from_raw_parts(mem.as_ptr() as *mut u8, 0))
|
||||
},
|
||||
}
|
||||
}
|
||||
|
|
@ -32,8 +32,7 @@ impl<'a> LogStr<'a> {
|
|||
pub fn into_memory_message(self, id: xous::MessageId) -> Result<xous::MemoryMessage, xous::Error> {
|
||||
Ok(xous::MemoryMessage {
|
||||
id: id,
|
||||
buf: xous::MemoryAddress::new(self.raw_slice.as_ptr() as usize),
|
||||
buf_size: xous::MemorySize::new(self.raw_slice.len()),
|
||||
buf: xous::MemoryRange::new(self.raw_slice.as_ptr() as usize, self.raw_slice.len()),
|
||||
offset: None,
|
||||
valid: xous::MemorySize::new(self.len),
|
||||
})
|
||||
|
|
|
|||
|
|
@ -45,8 +45,8 @@ fn main() {
|
|||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||
)
|
||||
.expect("couldn't map uart");
|
||||
unsafe { debug::DEFAULT_UART_ADDR = uart.base as *mut usize };
|
||||
println!("Mapped UART @ {:08x}", uart.base as usize);
|
||||
unsafe { debug::DEFAULT_UART_ADDR = uart.as_mut_ptr() };
|
||||
println!("Mapped UART @ {:08x}", uart.addr.get() );
|
||||
|
||||
xous::syscall::map_memory(
|
||||
xous::MemoryAddress::new(0xf0002000),
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ description = "Core kernel for Xous, including task switching and memory managem
|
|||
[dependencies]
|
||||
bitflags = "1.2.1"
|
||||
riscv = "0.5.6"
|
||||
xous = { path = "../xous-rs" }
|
||||
xous = { path = "../xous-rs", features = ["forget-memory-messages"] }
|
||||
|
||||
[dependencies.sha3]
|
||||
default-features = false
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ use core::str;
|
|||
|
||||
pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE};
|
||||
use crate::arch::process::ProcessHandle;
|
||||
use xous::{MemoryFlags, PID};
|
||||
use xous::{MemoryFlags, MemoryRange, PID};
|
||||
|
||||
#[derive(Debug)]
|
||||
enum ClaimOrRelease {
|
||||
|
|
@ -339,10 +339,7 @@ impl MemoryManager {
|
|||
// FIXME: Un-reserve addresses if we encounter an error here
|
||||
mm.reserve_address(self, virt, flags)?;
|
||||
}
|
||||
Ok(xous::MemoryRange {
|
||||
base: virt_ptr as *mut u8,
|
||||
size,
|
||||
})
|
||||
Ok(xous::MemoryRange::new(virt_ptr as usize, size))
|
||||
}
|
||||
|
||||
/// Attempt to allocate a single page from the default section.
|
||||
|
|
@ -433,10 +430,7 @@ impl MemoryManager {
|
|||
}
|
||||
}
|
||||
|
||||
Ok(xous::MemoryRange {
|
||||
base: virt as *mut u8,
|
||||
size,
|
||||
})
|
||||
Ok(MemoryRange::new(virt, size))
|
||||
}
|
||||
|
||||
/// Attempt to map the given physical address into the virtual address space
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
pub use crate::arch::ProcessContext;
|
||||
use core::{mem, slice};
|
||||
use xous::{CtxID, MemoryAddress, MemorySize, PID, SID};
|
||||
use xous::{CtxID, MemoryRange, MemorySize, PID, SID};
|
||||
|
||||
/// Internal representation of a queued message for a server. This should be
|
||||
/// exactly 8 words / 32 bytes, yielding 128 queued messages per server
|
||||
|
|
@ -116,8 +116,7 @@ impl Server {
|
|||
sender: sender,
|
||||
message: xous::Message::ImmutableBorrow(xous::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryAddress::new(buf),
|
||||
buf_size: MemorySize::new(buf_size),
|
||||
buf: MemoryRange::new(buf, buf_size),
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
|
|
@ -137,8 +136,7 @@ impl Server {
|
|||
sender: sender,
|
||||
message: xous::Message::MutableBorrow(xous::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryAddress::new(buf),
|
||||
buf_size: MemorySize::new(buf_size),
|
||||
buf: MemoryRange::new(buf, buf_size),
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
|
|
@ -151,8 +149,7 @@ impl Server {
|
|||
sender: sender,
|
||||
message: xous::Message::Move(xous::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryAddress::new(buf),
|
||||
buf_size: MemorySize::new(buf_size),
|
||||
buf: MemoryRange::new(buf, buf_size),
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
|
|
@ -206,8 +203,8 @@ impl Server {
|
|||
envelope.sender,
|
||||
context,
|
||||
msg.id,
|
||||
msg.buf.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
msg.buf_size.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
msg.buf.addr.get(),
|
||||
msg.buf.size.get(),
|
||||
msg.offset.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
msg.valid.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
),
|
||||
|
|
|
|||
|
|
@ -712,7 +712,7 @@ impl SystemServices {
|
|||
);
|
||||
if let Ok(ref range) = result {
|
||||
for offset in
|
||||
((range.base as usize)..(range.base as usize + range.size)).step_by(PAGE_SIZE)
|
||||
(range.addr.get()..(range.addr.get() + range.size.get())).step_by(PAGE_SIZE)
|
||||
{
|
||||
println!("Handing page to user");
|
||||
crate::arch::mem::hand_page_to_user(offset as *mut usize)
|
||||
|
|
@ -729,9 +729,9 @@ impl SystemServices {
|
|||
"send_memory: Sent phys {:08x} from {:08x} to {:08x}",
|
||||
phys,
|
||||
src_virt as usize,
|
||||
result.as_ref().unwrap().base as usize
|
||||
result.as_ref().unwrap().addr.get()
|
||||
);
|
||||
result.map(|virt| virt.base as usize)
|
||||
result.map(|virt| virt.addr.get())
|
||||
}
|
||||
|
||||
pub fn spawn_thread(
|
||||
|
|
|
|||
|
|
@ -162,17 +162,18 @@ pub fn handle(call: SysCall) -> core::result::Result<xous::Result, xous::Error>
|
|||
if mm.is_main_memory(phys) {
|
||||
println!(
|
||||
"Going to zero out {} bytes @ {:08x}",
|
||||
range.size, range.base as usize
|
||||
range.size.get(),
|
||||
range.addr.get()
|
||||
);
|
||||
unsafe {
|
||||
range
|
||||
.base
|
||||
.write_bytes(0, range.size / mem::size_of::<usize>())
|
||||
.as_mut_ptr()
|
||||
.write_bytes(0, range.size.get() / mem::size_of::<usize>())
|
||||
};
|
||||
println!("Done zeroing out");
|
||||
}
|
||||
for offset in
|
||||
((range.base as usize)..(range.base as usize + range.size)).step_by(PAGE_SIZE)
|
||||
(range.addr.get()..(range.addr.get() + range.size.get())).step_by(PAGE_SIZE)
|
||||
{
|
||||
println!("Handing page to user");
|
||||
crate::arch::mem::hand_page_to_user(offset as *mut usize)
|
||||
|
|
@ -189,7 +190,7 @@ pub fn handle(call: SysCall) -> core::result::Result<xous::Result, xous::Error>
|
|||
if virt & 0xfff != 0 {
|
||||
return Err(xous::Error::BadAlignment);
|
||||
}
|
||||
for addr in (virt..(virt+size)).step_by(PAGE_SIZE) {
|
||||
for addr in (virt..(virt + size)).step_by(PAGE_SIZE) {
|
||||
if let Err(e) = mm.unmap_page(addr as *mut usize) {
|
||||
if result.is_ok() {
|
||||
result = Err(e);
|
||||
|
|
@ -323,26 +324,17 @@ pub fn handle(call: SysCall) -> core::result::Result<xous::Result, xous::Error>
|
|||
let (message, blocking) = match message {
|
||||
Message::Scalar(_) => (message, false),
|
||||
Message::Move(msg) => {
|
||||
let new_virt = if let Some(virt) = msg.buf {
|
||||
if msg.buf_size.is_none() {
|
||||
return Err(xous::Error::BadAddress);
|
||||
}
|
||||
let len = msg.buf_size.unwrap().get();
|
||||
MemoryAddress::new(ss.send_memory(
|
||||
virt.get() as *mut usize,
|
||||
let new_virt = ss.send_memory(
|
||||
msg.buf.as_mut_ptr(),
|
||||
server_pid,
|
||||
len,
|
||||
msg.buf.len(),
|
||||
true,
|
||||
false,
|
||||
)?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
)?;
|
||||
(
|
||||
Message::Move(MemoryMessage {
|
||||
id: msg.id,
|
||||
buf: new_virt,
|
||||
buf_size: msg.buf_size,
|
||||
buf: MemoryRange::new(new_virt, msg.buf.len()),
|
||||
offset: msg.offset,
|
||||
valid: msg.valid,
|
||||
}),
|
||||
|
|
|
|||
|
|
@ -12,3 +12,8 @@ num-derive = "0.3.0"
|
|||
[dependencies.num-traits]
|
||||
version = "0.2"
|
||||
default-features = false
|
||||
|
||||
[features]
|
||||
# If this is set, then the "Drop" feature of MemoryMessage structs
|
||||
# will not be implemented. This should only be set by the kernel.
|
||||
forget-memory-messages = []
|
||||
|
|
|
|||
|
|
@ -21,6 +21,12 @@ pub type CtxID = usize;
|
|||
/// Equivalent to a RISC-V Hart ID
|
||||
pub type CpuID = usize;
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct MemoryRange {
|
||||
pub addr: MemoryAddress,
|
||||
pub size: MemorySize,
|
||||
}
|
||||
|
||||
#[repr(usize)]
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum Error {
|
||||
|
|
@ -42,6 +48,7 @@ pub enum Error {
|
|||
ServerQueueFull = 15,
|
||||
ContextNotAvailable = 16,
|
||||
UnhandledSyscall = 17,
|
||||
InvalidSyscall = 18,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
|
|
@ -55,27 +62,33 @@ pub struct Context {
|
|||
/// A struct describing memory that is passed between processes.
|
||||
/// The `buf` value will get translated as necessary.
|
||||
pub struct MemoryMessage {
|
||||
|
||||
/// A user-assignable message ID.
|
||||
pub id: MessageId,
|
||||
|
||||
/// The offset of the buffer. This address will get
|
||||
/// transformed when the message is moved between
|
||||
/// processes.
|
||||
pub buf: Option<MemoryAddress>,
|
||||
/// The offset of the buffer. This address will get transformed when the
|
||||
/// message is moved between processes.
|
||||
pub buf: MemoryRange,
|
||||
|
||||
/// The overall size of the buffer. Must be a multiple
|
||||
/// of PAGE_SIZE.
|
||||
pub buf_size: Option<MemorySize>,
|
||||
|
||||
/// The offset within the buffer where the interesting
|
||||
/// stuff starts.
|
||||
/// The offset within the buffer where the interesting stuff starts.
|
||||
pub offset: Option<MemorySize>,
|
||||
|
||||
/// How many bytes in the buffer are valid
|
||||
pub valid: Option<MemorySize>,
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "forget-memory-messages"))]
|
||||
impl Drop for MessageEnvelope {
|
||||
fn drop(&mut self) {
|
||||
match &self.message {
|
||||
Message::MutableBorrow(msg) | Message::ImmutableBorrow(msg) | Message::Move(msg) => {
|
||||
crate::syscall::unmap_memory(msg.buf.addr, msg.buf.size)
|
||||
.expect("couldn't free memory message");
|
||||
}
|
||||
Message::Scalar(_) => (),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug, PartialEq)]
|
||||
/// A simple scalar message. This is similar to a `move` message.
|
||||
|
|
@ -102,3 +115,28 @@ pub struct MessageEnvelope {
|
|||
pub sender: MessageSender,
|
||||
pub message: Message,
|
||||
}
|
||||
|
||||
impl MemoryRange {
|
||||
pub fn new(addr: usize, size: usize) -> MemoryRange {
|
||||
assert!(
|
||||
addr != 0,
|
||||
"tried to construct a memory range with a null pointer"
|
||||
);
|
||||
MemoryRange {
|
||||
addr: MemoryAddress::new(addr).unwrap(),
|
||||
size: MemorySize::new(size).unwrap(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn len(&self) -> usize {
|
||||
self.size.get()
|
||||
}
|
||||
|
||||
pub fn as_ptr(&self) -> *const usize {
|
||||
self.addr.get() as *const usize
|
||||
}
|
||||
|
||||
pub fn as_mut_ptr(&self) -> *mut usize {
|
||||
self.addr.get() as *mut usize
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
use crate::{
|
||||
CpuID, CtxID, Error, MemoryAddress, MemoryMessage, MemorySize, Message, MessageEnvelope,
|
||||
ScalarMessage, CID, PID, SID,
|
||||
CpuID, CtxID, Error, MemoryAddress, MemoryMessage, MemoryRange, MemorySize, Message,
|
||||
MessageEnvelope, ScalarMessage, CID, PID, SID,
|
||||
};
|
||||
use num_derive::FromPrimitive;
|
||||
use num_traits::FromPrimitive;
|
||||
|
|
@ -316,9 +316,6 @@ enum SysCallNumber {
|
|||
Invalid,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct InvalidSyscall {}
|
||||
|
||||
impl SysCall {
|
||||
pub fn as_args(&self) -> [usize; 8] {
|
||||
use core::mem;
|
||||
|
|
@ -462,8 +459,8 @@ impl SysCall {
|
|||
a1,
|
||||
1,
|
||||
mm.id as usize,
|
||||
mm.buf.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
mm.buf_size.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
mm.buf.as_ptr() as usize,
|
||||
mm.buf.len(),
|
||||
mm.offset.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
mm.valid.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
],
|
||||
|
|
@ -472,8 +469,8 @@ impl SysCall {
|
|||
a1,
|
||||
2,
|
||||
mm.id as usize,
|
||||
mm.buf.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
mm.buf_size.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
mm.buf.as_ptr() as usize,
|
||||
mm.buf.len(),
|
||||
mm.offset.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
mm.valid.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
],
|
||||
|
|
@ -482,8 +479,8 @@ impl SysCall {
|
|||
a1,
|
||||
3,
|
||||
mm.id as usize,
|
||||
mm.buf.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
mm.buf_size.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
mm.buf.as_ptr() as usize,
|
||||
mm.buf.len(),
|
||||
mm.offset.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
mm.valid.map(|x| x.get()).unwrap_or(0) as usize,
|
||||
],
|
||||
|
|
@ -522,13 +519,13 @@ impl SysCall {
|
|||
a5: usize,
|
||||
a6: usize,
|
||||
a7: usize,
|
||||
) -> core::result::Result<Self, InvalidSyscall> {
|
||||
) -> core::result::Result<Self, Error> {
|
||||
Ok(match FromPrimitive::from_usize(a0) {
|
||||
Some(SysCallNumber::MapMemory) => SysCall::MapMemory(
|
||||
a1 as *mut usize,
|
||||
a2 as *mut usize,
|
||||
a3,
|
||||
MemoryFlags::from_bits(a4).ok_or(InvalidSyscall {})?,
|
||||
MemoryFlags::from_bits(a4).ok_or(Error::InvalidSyscall)?,
|
||||
),
|
||||
Some(SysCallNumber::UnmapMemory) => SysCall::UnmapMemory(a1 as *mut usize, a2),
|
||||
Some(SysCallNumber::Yield) => SysCall::Yield,
|
||||
|
|
@ -543,13 +540,13 @@ impl SysCall {
|
|||
Some(SysCallNumber::ReadyContexts) => SysCall::ReadyContexts(a1 as u8),
|
||||
Some(SysCallNumber::IncreaseHeap) => SysCall::IncreaseHeap(
|
||||
a1 as usize,
|
||||
MemoryFlags::from_bits(a2).ok_or(InvalidSyscall {})?,
|
||||
MemoryFlags::from_bits(a2).ok_or(Error::InvalidSyscall)?,
|
||||
),
|
||||
Some(SysCallNumber::DecreaseHeap) => SysCall::DecreaseHeap(a1 as usize),
|
||||
Some(SysCallNumber::UpdateMemoryFlags) => SysCall::UpdateMemoryFlags(
|
||||
a1 as *mut usize,
|
||||
a2 as usize,
|
||||
MemoryFlags::from_bits(a3).ok_or(InvalidSyscall {})?,
|
||||
MemoryFlags::from_bits(a3).ok_or(Error::InvalidSyscall)?,
|
||||
),
|
||||
Some(SysCallNumber::SetMemRegion) => {
|
||||
SysCall::SetMemRegion(a1 as PID, MemoryType::from(a2), a3 as *mut usize, a4)
|
||||
|
|
@ -561,8 +558,7 @@ impl SysCall {
|
|||
a1,
|
||||
Message::MutableBorrow(MemoryMessage {
|
||||
id: a3,
|
||||
buf: MemoryAddress::new(a4),
|
||||
buf_size: MemorySize::new(a5),
|
||||
buf: MemoryRange::new(a4, a5),
|
||||
offset: MemoryAddress::new(a6),
|
||||
valid: MemorySize::new(a7),
|
||||
}),
|
||||
|
|
@ -571,8 +567,7 @@ impl SysCall {
|
|||
a1,
|
||||
Message::ImmutableBorrow(MemoryMessage {
|
||||
id: a3,
|
||||
buf: MemoryAddress::new(a4),
|
||||
buf_size: MemorySize::new(a5),
|
||||
buf: MemoryRange::new(a4, a5),
|
||||
offset: MemoryAddress::new(a6),
|
||||
valid: MemorySize::new(a7),
|
||||
}),
|
||||
|
|
@ -581,8 +576,7 @@ impl SysCall {
|
|||
a1,
|
||||
Message::Move(MemoryMessage {
|
||||
id: a3,
|
||||
buf: MemoryAddress::new(a4),
|
||||
buf_size: MemorySize::new(a5),
|
||||
buf: MemoryRange::new(a4, a5),
|
||||
offset: MemoryAddress::new(a6),
|
||||
valid: MemorySize::new(a7),
|
||||
}),
|
||||
|
|
@ -603,17 +597,11 @@ impl SysCall {
|
|||
SysCall::SpawnThread(a1 as *mut usize, a2 as *mut usize, a3 as *mut usize)
|
||||
}
|
||||
Some(SysCallNumber::Invalid) => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
|
||||
None => return Err(InvalidSyscall {}),
|
||||
None => return Err(Error::InvalidSyscall),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct MemoryRange {
|
||||
pub base: *mut u8,
|
||||
pub size: usize,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum Result {
|
||||
|
|
@ -696,8 +684,8 @@ pub fn map_memory(
|
|||
|
||||
/// Map the given physical address to the given virtual address.
|
||||
/// The `size` field must be page-aligned.
|
||||
pub fn unmap_memory(virt: MemoryAddress, size: usize) -> core::result::Result<(), Error> {
|
||||
let result = rsyscall(SysCall::UnmapMemory(virt.get() as *mut usize, size))?;
|
||||
pub fn unmap_memory(virt: MemoryAddress, size: MemorySize) -> core::result::Result<(), Error> {
|
||||
let result = rsyscall(SysCall::UnmapMemory(virt.get() as *mut usize, size.get()))?;
|
||||
if let Result::Ok = result {
|
||||
Ok(())
|
||||
} else if let Result::Error(e) = result {
|
||||
|
|
|
|||
Loading…
Reference in a new issue