mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-17 08:40:52 +00:00
Merge branch 'hardware' of github.com:betrusted-io/xous-core into hardware
This commit is contained in:
commit
e84845553e
13 changed files with 206 additions and 129 deletions
2
Cargo.lock
generated
2
Cargo.lock
generated
|
|
@ -1536,7 +1536,7 @@ checksum = "b07db065a5cf61a7e4ba64f29e67db906fb1787316516c4e6e5ff0fea1efcd8a"
|
|||
|
||||
[[package]]
|
||||
name = "xous"
|
||||
version = "0.1.0"
|
||||
version = "0.1.2"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"hex",
|
||||
|
|
|
|||
2
kernel/Cargo.lock
generated
2
kernel/Cargo.lock
generated
|
|
@ -574,7 +574,7 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
|
|||
|
||||
[[package]]
|
||||
name = "xous"
|
||||
version = "0.1.0"
|
||||
version = "0.1.2"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"hex",
|
||||
|
|
|
|||
|
|
@ -792,6 +792,12 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
|
|||
SysCall::Shutdown => {
|
||||
SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok))
|
||||
}
|
||||
SysCall::GetProcessId => {
|
||||
Ok(xous_kernel::Result::ProcessID(pid))
|
||||
}
|
||||
SysCall::GetThreadId => {
|
||||
Ok(xous_kernel::Result::ThreadID(tid))
|
||||
}
|
||||
|
||||
SysCall::Connect(sid) => {
|
||||
let result = SystemServices::with_mut(|ss| {
|
||||
|
|
|
|||
|
|
@ -4,37 +4,47 @@ The GAM provides abstract UI primitives to other modules.
|
|||
|
||||
The goal is to have this module work in close conjunction with the
|
||||
`graphics-server`, and all other modules would route abstract UI
|
||||
requests through this module.
|
||||
requests through this module.
|
||||
|
||||
## Structure
|
||||
At a high level, you can think of the GAM as a firewall around the `graphics-server`.
|
||||
The `graphics-server` has no concept of what pixel belongs where; it's happy
|
||||
to mutate a pixel that is anywhere within the physical hardware framebuffer.
|
||||
|
||||
Giving processes direct access to `graphics-server` means that a less trusted
|
||||
program could draw into an OS-reserved area, thus presenting false information
|
||||
to a user. The GAM solves this problem by dividing the screen into `Canvas` objects.
|
||||
|
||||
### Canvas
|
||||
|
||||
A `Canvas` is a minimal data structure that defines a physical region of the
|
||||
screen that will display a set of primitives. `Canvas` structures are domiciled
|
||||
in the UI server, and are considered trusted by default, although there is
|
||||
in the GAM server, and are considered trusted by default, although there is
|
||||
a flag that can be cleared to make everything within it untrusted.
|
||||
|
||||
Each `Canvas` has a 128-bit GUID. Application processes that wish to draw
|
||||
something to the screen must refer to a `Canvas` by its 128-bit GUID; it is up
|
||||
to the GAM to not share secure GUIDs with insecure processes.
|
||||
to the GAM to not share secure GUIDs with insecure processes. Thus the security
|
||||
of a `Canvas` rests in the difficulty of guessing the 128-bit GUID, and also
|
||||
in the system not leaking GUIDs.
|
||||
|
||||
The `Canvas` selection is modal on a per-connection basis. In other words,
|
||||
an application can request several `Canvas` objects to draw on, but it
|
||||
must first send a `SelectCanvas` command first to pick the right `Canvas`.
|
||||
By default, the last requested `Canvas` is the default `Canvas` for a
|
||||
given connection to the GAM.
|
||||
Every GAM drawing object includes the GUID of the `Canvas` to which it should be drawn.
|
||||
Upon receiving a draw request, it validates that the GUID exists, and applies
|
||||
any other relevant rules (for example, a higher security process can use the
|
||||
GAM to prohibit all drawing of lower security processes by marking their
|
||||
`Canvas` as not drawable).
|
||||
|
||||
The region of the physical screen that can be drawn on by a `Canvas` is
|
||||
defined by a `clip_rect`. The coordinate space of the `clip_rect` is fixed
|
||||
All GAM drawing objects specify pixel offsets from a `(0,0)` top-left coordinate
|
||||
system. The GAM then handles translating these offsets from a virtual `(0,0)`
|
||||
Canvas offset to a physical region of a screen through the `clip_rect`
|
||||
record within the `Canvas`. The coordinate space of the `clip_rect` is fixed
|
||||
to the screen's coordinates, that is, `(0,0)` in the top left, X increasing
|
||||
to the right, Y increasing down.
|
||||
|
||||
A `Canvas` stores a `pan_offset`. If the pan offset is `(0,0)`, then the top left
|
||||
corner of the `clip_rect` corresponds to data drawn at location `(0,0)` inside
|
||||
the `Canvas`. The `pan_offset` is added to every coordinate inside the objects that
|
||||
refer to a `Canvas` at render time; this allows for easy implementation
|
||||
of panning and scrolling.
|
||||
A `Canvas` also stores a `pan_offset`. The `pan_offset` is added to every
|
||||
coordinate inside the objects that refer to a `Canvas` and then the result
|
||||
is clipped with `clip_rect`; this allows for easy implementation
|
||||
of panning and scrolling. (Note: this feature is largely untested as of March 2021)
|
||||
|
||||
A `Canvas` has a `trust_level` associated with it. Higher numbers are more
|
||||
trusted; 255 is the highest level of trust. Rules for drawing are as follows:
|
||||
|
|
@ -81,13 +91,23 @@ control over customizing their interfaces, and also helps introduce a layer
|
|||
of protection against phishing; however it also means that UX designers will not
|
||||
be able to have exquisite control over the "look and feel" of their applications.
|
||||
|
||||
`TextView` objects are domiciled on the application process. Process-local API
|
||||
calls can "simulate" certain properties (such as figuring out the dynamic
|
||||
width or height of a text box based on the size of the string within) to assist
|
||||
with laying out `TextViews`. Once the layout is finalized, the `TextView` objects
|
||||
are then immutably lent to the GAM using an `rkyv` lend wrapper;
|
||||
`TextView` objects are domiciled on the application process. The application
|
||||
process is responsible for guiding the rough layout of where `TextView`s go
|
||||
in a canvas. Once the object is finalized, the `TextView` objects
|
||||
are then mutably lent to the GAM using an `rkyv` lend wrapper;
|
||||
the calling thread then blocks until the GAM completes the rendering operation.
|
||||
|
||||
For layouts that need to adjust in height based on variable-length text strings,
|
||||
the calling application can use the `bounds_hint`/`TextBounds` to help manage this.
|
||||
The bounds of a `TextView` can either be a fixed-sized rectangle, or a box that
|
||||
grows up and out from a point plus a width. So, for example, a `TextView` could have
|
||||
an anchor in the lower-right hand corner, plus a maximum width, and the height of the
|
||||
box will be computed based as the text is rendered. The height of text can't be
|
||||
known a-priori, because for example, emoji glyphs and hanzi characters will
|
||||
have a different height than latin characters. A `dry_run` option is also
|
||||
available for a `TextView` so one can simulate the rendering to determine the height
|
||||
without paying the compuational price.
|
||||
|
||||
One can think of a `TextView` as a text bubble, that can have rounded or square
|
||||
corners, and its content string can be rendered with a selection of options
|
||||
that specify the glyph style (*not* a font -- it's more of a hint than a specifier),
|
||||
|
|
@ -95,40 +115,11 @@ aligment, and the size of the text bubble. The text bubble can either be of a
|
|||
fixed size (such that the string will show ellipses `...` if it overruns the
|
||||
bubble), or of a dynamically growable size based on its content.
|
||||
|
||||
Thus, a typical "chat-style" app where text bubbles show a history of the chat
|
||||
going from the most recent at the bottom of the screen to the oldest at the top,
|
||||
would start by rendering variable-height text bubbles on the bottom, getting the
|
||||
returned value of the rendered height, and setting the height of the next bubble
|
||||
on top for rendering, and then rendering that.
|
||||
|
||||
`TextView` can both be directly rendered to a `Canvas`, or managed by secondary
|
||||
object such as a `Menu` or `List` to compose other UI elements.
|
||||
|
||||
`TextView` supports a `draw_order` attribute, which allows multiple `TextViews`
|
||||
within a single application to be stacked on top of each other.
|
||||
Note that `draw_order` can only be respected within the context of a single application;
|
||||
if two applications are drawing to the same `Canvas`, then who gets the last
|
||||
draw depend on who sends the last update request. This might be fixable later
|
||||
on with a bit to "mutex" the drawing of other applications to enforce an order,
|
||||
but for MVP we simply avoid having multiple applications contend for access to
|
||||
the same `Canvas`.
|
||||
|
||||
|
||||
|
||||
--------------------
|
||||
|
||||
|
||||
|
||||
The problem is:
|
||||
1. you don't have access to the drawing objects; they are domiciled in the apps
|
||||
2. you don't want to just clear large regions of the FB; that will slow things down.
|
||||
You want to take advantage of dirty bits as much as possible for good performance.
|
||||
3. It would be nice to be able to have a more trusted "pop-up" on top of a less
|
||||
trusted app, and have it obscure the lower app.
|
||||
|
||||
Options include:
|
||||
|
||||
1. A bitmap that stores the drawable mask based on a trust level. This would have
|
||||
to be recalculated from the priority queue for each Canvas every time the queue
|
||||
is updated. This structure consumes 24kiB per canvas in this case...
|
||||
2. Coming up with an arbitrary polygonal region (that can also support holes) and
|
||||
then doing maths to figure out if a point may or may not be updated. This would
|
||||
be memory efficient but rather time and CPU-inefficient to compute.
|
||||
3. Disallowing overlapping Canvas features??
|
||||
4. Maintaining each Canvas with a bitmap that has the latest drawing on it,
|
||||
updating only that bitmap, and then doing compositing and dirty bit computation
|
||||
before sending off to the graphics engine?
|
||||
|
|
|
|||
|
|
@ -1,27 +1,39 @@
|
|||
[package]
|
||||
name = "xous"
|
||||
version = "0.1.0"
|
||||
version = "0.1.2"
|
||||
authors = ["Sean Cross <sean@xobs.io>"]
|
||||
edition = "2018"
|
||||
license = "MIT OR Apache-2.0"
|
||||
description = "System call interface for Xous"
|
||||
|
||||
[dependencies]
|
||||
bitflags = "1"
|
||||
bitflags = {version = "1", optional = true }
|
||||
xous-macros = { path = "../macros", version = "0.1.0" }
|
||||
log = { version = "0.4", optional = true }
|
||||
rkyv = { version = "0.3.1", default_features = false }
|
||||
rkyv = { version = "0.3.1", default_features = false, optional = true }
|
||||
core = { version = '1.0.0', optional = true, package = 'rustc-std-workspace-core' }
|
||||
compiler_builtins = { version = '0.1.0', optional = true }
|
||||
|
||||
[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 = []
|
||||
|
||||
# Enable using `bitflags`
|
||||
bit-flags = ["bitflags"]
|
||||
|
||||
# Enable sending commands using `rkyv`
|
||||
archive = ["rkyv"]
|
||||
|
||||
# `logging` causes this program to connect to a log server on startup
|
||||
# so you can run log commands such as `info!()`.
|
||||
logging = ["log"]
|
||||
|
||||
default = []
|
||||
# This is being built as part of libstd
|
||||
rustc-dep-of-std = ['core', 'compiler_builtins/rustc-dep-of-std']
|
||||
|
||||
default = ["bit-flags", "archive"]
|
||||
|
||||
[target.'cfg(any(windows,unix))'.dependencies]
|
||||
lazy_static = "1.4"
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#[cfg(target_os = "none")]
|
||||
#[cfg(any(target_os = "none", target_os = "xous"))]
|
||||
pub mod native;
|
||||
#[cfg(target_os = "none")]
|
||||
#[cfg(any(target_os = "none", target_os = "xous"))]
|
||||
pub use native::*;
|
||||
|
||||
#[cfg(not(target_os = "none"))]
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
pub mod hosted;
|
||||
#[cfg(not(target_os = "none"))]
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
pub use hosted::*;
|
||||
|
|
|
|||
|
|
@ -174,12 +174,12 @@ where
|
|||
T: Send + 'static,
|
||||
U: Send + 'static,
|
||||
{
|
||||
let stack = crate::map_memory(
|
||||
None,
|
||||
None,
|
||||
131_072,
|
||||
crate::MemoryFlags::R | crate::MemoryFlags::W | crate::MemoryFlags::RESERVE,
|
||||
)?;
|
||||
#[cfg(feature = "bit-flags")]
|
||||
let flags = crate::MemoryFlags::R | crate::MemoryFlags::W | crate::MemoryFlags::RESERVE;
|
||||
#[cfg(not(feature = "bit-flags"))]
|
||||
let flags = 0b0000_0010 | 0b0000_0100 | 0b0000_0001;
|
||||
|
||||
let stack = crate::map_memory(None, None, 131_072, flags)?;
|
||||
let start = unsafe { core::mem::transmute(*f) };
|
||||
let arg = unsafe { core::mem::transmute(arg) };
|
||||
Ok(ThreadInit::new(start, stack, Some(arg), [0; 12]))
|
||||
|
|
|
|||
|
|
@ -1,4 +1,7 @@
|
|||
use crate::{Result, Error, MemoryMessage, MemoryRange, MemoryFlags, MemorySize, Message, CID, map_memory, send_message};
|
||||
use crate::{
|
||||
map_memory, send_message, Error, MemoryMessage, MemoryRange, MemorySize, Message,
|
||||
Result, CID,
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct XousBuffer<'a> {
|
||||
|
|
@ -11,16 +14,23 @@ pub struct XousBuffer<'a> {
|
|||
impl<'a> XousBuffer<'a> {
|
||||
#[allow(dead_code)]
|
||||
pub fn new(len: usize) -> Self {
|
||||
let remainder =
|
||||
if ((len & 0xFFF) == 0) && (len > 0) { 0 }
|
||||
else { 0x1000 - (len & 0xFFF) };
|
||||
let remainder = if ((len & 0xFFF) == 0) && (len > 0) {
|
||||
0
|
||||
} else {
|
||||
0x1000 - (len & 0xFFF)
|
||||
};
|
||||
|
||||
#[cfg(feature = "bit-flags")]
|
||||
let flags = crate::MemoryFlags::R | crate::MemoryFlags::W;
|
||||
#[cfg(not(feature = "bit-flags"))]
|
||||
let flags = 0b0000_0010 | 0b0000_0100;
|
||||
|
||||
let new_mem = map_memory(
|
||||
None,
|
||||
None,
|
||||
// Ensure our byte size is a multiple of 4096
|
||||
len + remainder,
|
||||
MemoryFlags::R | MemoryFlags::W,
|
||||
flags,
|
||||
)
|
||||
.expect("XousBuffer: error in new()/map_memory");
|
||||
|
||||
|
|
@ -28,7 +38,9 @@ impl<'a> XousBuffer<'a> {
|
|||
valid.size = MemorySize::new(len + remainder).unwrap();
|
||||
XousBuffer {
|
||||
range: new_mem,
|
||||
slice: unsafe { core::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), len + remainder) },
|
||||
slice: unsafe {
|
||||
core::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), len + remainder)
|
||||
},
|
||||
valid,
|
||||
should_drop: true,
|
||||
}
|
||||
|
|
@ -46,11 +58,7 @@ impl<'a> XousBuffer<'a> {
|
|||
|
||||
/// Perform a mutable lend of this Carton to the server.
|
||||
#[allow(dead_code)]
|
||||
pub fn lend_mut(
|
||||
&mut self,
|
||||
connection: CID,
|
||||
id: u32,
|
||||
) -> core::result::Result<Result, Error> {
|
||||
pub fn lend_mut(&mut self, connection: CID, id: u32) -> core::result::Result<Result, Error> {
|
||||
let msg = MemoryMessage {
|
||||
id: id as usize,
|
||||
buf: self.valid,
|
||||
|
|
@ -61,11 +69,7 @@ impl<'a> XousBuffer<'a> {
|
|||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn lend(
|
||||
&self,
|
||||
connection: CID,
|
||||
id: u32
|
||||
) -> core::result::Result<Result, Error> {
|
||||
pub fn lend(&self, connection: CID, id: u32) -> core::result::Result<Result, Error> {
|
||||
let msg = MemoryMessage {
|
||||
id: id as usize,
|
||||
buf: self.valid,
|
||||
|
|
@ -76,11 +80,7 @@ impl<'a> XousBuffer<'a> {
|
|||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn send(
|
||||
mut self,
|
||||
connection: CID,
|
||||
id: u32,
|
||||
) -> core::result::Result<Result, Error> {
|
||||
pub fn send(mut self, connection: CID, id: u32) -> core::result::Result<Result, Error> {
|
||||
let msg = crate::MemoryMessage {
|
||||
id: id as usize,
|
||||
buf: self.valid,
|
||||
|
|
|
|||
|
|
@ -19,13 +19,12 @@ impl<'a> Carton<'a> {
|
|||
let remainder = bytes.len() & 4095;
|
||||
let size = bytes.len() + (4096 - remainder);
|
||||
|
||||
let new_mem = crate::map_memory(
|
||||
None,
|
||||
None,
|
||||
size,
|
||||
crate::MemoryFlags::R | crate::MemoryFlags::W,
|
||||
)
|
||||
.unwrap();
|
||||
#[cfg(feature = "bit-flags")]
|
||||
let flags = crate::MemoryFlags::R | crate::MemoryFlags::W;
|
||||
#[cfg(not(feature = "bit-flags"))]
|
||||
let flags = 0b0000_0010 | 0b0000_0100;
|
||||
|
||||
let new_mem = crate::map_memory(None, None, size, flags).unwrap();
|
||||
|
||||
// NOTE: Remaining bytes are not zeroed. We assume the kernel has done this for us.
|
||||
unsafe {
|
||||
|
|
|
|||
|
|
@ -115,6 +115,7 @@ pub struct MemoryRange {
|
|||
pub size: MemorySize,
|
||||
}
|
||||
|
||||
#[cfg(feature = "bitflags")]
|
||||
bitflags! {
|
||||
/// Flags to be passed to the MapMemory struct.
|
||||
/// Note that it is an error to have memory be
|
||||
|
|
@ -138,6 +139,25 @@ bitflags! {
|
|||
const X = 0b0000_1000;
|
||||
}
|
||||
}
|
||||
#[cfg(feature = "bitflags")]
|
||||
pub(crate) fn get_bits(bf: &MemoryFlags) -> usize {
|
||||
bf.bits()
|
||||
}
|
||||
#[cfg(feature = "bitflags")]
|
||||
pub(crate) fn from_bits(raw: usize) -> Option<MemoryFlags> {
|
||||
MemoryFlags::from_bits(raw)
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "bitflags"))]
|
||||
pub type MemoryFlags = usize;
|
||||
#[cfg(not(feature = "bitflags"))]
|
||||
pub(crate) fn get_bits(bf: &MemoryFlags) -> usize {
|
||||
*bf
|
||||
}
|
||||
#[cfg(not(feature = "bitflags"))]
|
||||
pub(crate) fn from_bits(raw: usize) -> Option<MemoryFlags> {
|
||||
Some(raw)
|
||||
}
|
||||
|
||||
pub fn pid_from_usize(src: usize) -> core::result::Result<PID, Error> {
|
||||
if src > u8::MAX as _ {
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
#![cfg_attr(target_os = "none", no_std)]
|
||||
#![cfg_attr(any(target_os = "none", target_os = "xous"), no_std)]
|
||||
|
||||
#[cfg(feature = "bitflags")]
|
||||
#[macro_use]
|
||||
extern crate bitflags;
|
||||
|
||||
|
|
@ -12,27 +13,30 @@ pub mod arch;
|
|||
pub mod carton;
|
||||
pub mod definitions;
|
||||
mod messages;
|
||||
pub mod string;
|
||||
|
||||
pub mod buffer;
|
||||
pub mod syscall;
|
||||
pub mod process;
|
||||
#[cfg(feature = "archive")]
|
||||
pub mod string;
|
||||
pub mod syscall;
|
||||
|
||||
pub mod names;
|
||||
|
||||
pub use arch::{ProcessArgs, ProcessInit, ProcessKey, ThreadInit};
|
||||
pub use buffer::XousBuffer;
|
||||
pub use definitions::*;
|
||||
pub use messages::*;
|
||||
#[cfg(feature = "archive")]
|
||||
pub use string::*;
|
||||
pub use syscall::*;
|
||||
pub use buffer::XousBuffer;
|
||||
|
||||
#[cfg(not(target_os = "none"))]
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
pub use arch::ProcessArgsAsThread;
|
||||
|
||||
#[cfg(target_os = "none")]
|
||||
#[cfg(any(target_os = "none", target_os = "xous"))]
|
||||
pub fn init() {}
|
||||
|
||||
#[cfg(not(target_os = "none"))]
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
pub fn init() {
|
||||
use std::panic;
|
||||
panic::set_hook(Box::new(|arg| {
|
||||
|
|
@ -61,6 +65,7 @@ macro_rules! maybe_main {
|
|||
}
|
||||
|
||||
fn main() {
|
||||
#[cfg(not(target_os = "xous"))]
|
||||
xous::arch::ensure_connection().unwrap();
|
||||
unsafe { xous_entry() };
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,17 +1,9 @@
|
|||
#[cfg(not(target_os = "none"))]
|
||||
pub fn id() -> u32 {
|
||||
std::process::id()
|
||||
if let Ok(crate::Result::ProcessID(pid)) = crate::syscall::current_pid() {
|
||||
pid.get() as u32
|
||||
} else {
|
||||
0
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_os = "none")]
|
||||
static PID_KEEPER: core::sync::atomic::AtomicU32 = core::sync::atomic::AtomicU32::new(0);
|
||||
|
||||
#[cfg(target_os = "none")]
|
||||
pub fn id() -> u32 {
|
||||
PID_KEEPER.load(core::sync::atomic::Ordering::Relaxed)
|
||||
}
|
||||
|
||||
#[cfg(target_os = "none")]
|
||||
pub fn set_id(id: u32) {
|
||||
PID_KEEPER.store(id, core::sync::atomic::Ordering::Relaxed)
|
||||
}
|
||||
pub fn set_id(_id: u32) {}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ use core::convert::TryInto;
|
|||
// use num_derive::FromPrimitive;
|
||||
// use num_traits::FromPrimitive;
|
||||
|
||||
#[cfg(not(target_os = "none"))]
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
use crate::ProcessArgsAsThread;
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
|
|
@ -299,6 +299,12 @@ pub enum SysCall {
|
|||
/// disclosing SIDs.
|
||||
ConnectForProcess(PID, SID),
|
||||
|
||||
/// Get the current Thread ID
|
||||
GetThreadId,
|
||||
|
||||
/// Get the current Process ID
|
||||
GetProcessId,
|
||||
|
||||
/// This syscall does not exist. It captures all possible
|
||||
/// arguments so detailed analysis can be performed.
|
||||
Invalid(usize, usize, usize, usize, usize, usize, usize),
|
||||
|
|
@ -336,6 +342,8 @@ pub enum SysCallNumber {
|
|||
CreateServer = 29,
|
||||
ConnectForProcess = 30,
|
||||
CreateServerId = 31,
|
||||
GetThreadId = 32,
|
||||
GetProcessId = 33,
|
||||
Invalid,
|
||||
}
|
||||
|
||||
|
|
@ -373,6 +381,8 @@ impl SysCallNumber {
|
|||
29 => CreateServer,
|
||||
30 => ConnectForProcess,
|
||||
31 => CreateServerId,
|
||||
32 => GetThreadId,
|
||||
33 => GetProcessId,
|
||||
_ => Invalid,
|
||||
}
|
||||
}
|
||||
|
|
@ -395,7 +405,7 @@ impl SysCall {
|
|||
a1.map(|x| x.get()).unwrap_or_default(),
|
||||
a2.map(|x| x.get()).unwrap_or_default(),
|
||||
a3.get(),
|
||||
a4.bits(),
|
||||
crate::get_bits(a4),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
|
|
@ -499,7 +509,7 @@ impl SysCall {
|
|||
SysCall::IncreaseHeap(a1, a2) => [
|
||||
SysCallNumber::IncreaseHeap as usize,
|
||||
*a1 as usize,
|
||||
a2.bits(),
|
||||
crate::get_bits(a2),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
|
|
@ -520,7 +530,7 @@ impl SysCall {
|
|||
SysCallNumber::UpdateMemoryFlags as usize,
|
||||
a1.get(),
|
||||
*a2 as usize,
|
||||
a3.bits(),
|
||||
crate::get_bits(a3),
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
|
|
@ -668,6 +678,24 @@ impl SysCall {
|
|||
0,
|
||||
0,
|
||||
],
|
||||
SysCall::GetThreadId => [SysCallNumber::GetThreadId as usize,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
],
|
||||
SysCall::GetProcessId => [SysCallNumber::GetProcessId as usize,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
],
|
||||
SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7) => [
|
||||
SysCallNumber::Invalid as usize,
|
||||
*a1,
|
||||
|
|
@ -697,7 +725,7 @@ impl SysCall {
|
|||
MemoryAddress::new(a1),
|
||||
MemoryAddress::new(a2),
|
||||
MemoryAddress::new(a3).ok_or(Error::InvalidSyscall)?,
|
||||
MemoryFlags::from_bits(a4).ok_or(Error::InvalidSyscall)?,
|
||||
crate::from_bits(a4).ok_or(Error::InvalidSyscall)?,
|
||||
),
|
||||
SysCallNumber::UnmapMemory => {
|
||||
SysCall::UnmapMemory(MemoryRange::new(a1, a2).or(Err(Error::InvalidSyscall))?)
|
||||
|
|
@ -721,13 +749,13 @@ impl SysCall {
|
|||
SysCallNumber::ReadyThreads => SysCall::ReadyThreads(pid_from_usize(a1)?),
|
||||
SysCallNumber::IncreaseHeap => SysCall::IncreaseHeap(
|
||||
a1 as usize,
|
||||
MemoryFlags::from_bits(a2).ok_or(Error::InvalidSyscall)?,
|
||||
crate::from_bits(a2).ok_or(Error::InvalidSyscall)?,
|
||||
),
|
||||
SysCallNumber::DecreaseHeap => SysCall::DecreaseHeap(a1 as usize),
|
||||
SysCallNumber::UpdateMemoryFlags => SysCall::UpdateMemoryFlags(
|
||||
MemoryAddress::new(a1).ok_or(Error::InvalidSyscall)?,
|
||||
a2 as usize,
|
||||
MemoryFlags::from_bits(a3).ok_or(Error::InvalidSyscall)?,
|
||||
crate::from_bits(a3).ok_or(Error::InvalidSyscall)?,
|
||||
),
|
||||
SysCallNumber::SetMemRegion => SysCall::SetMemRegion(
|
||||
pid_from_usize(a1)?,
|
||||
|
|
@ -867,6 +895,8 @@ impl SysCall {
|
|||
SID::from_u32(a2 as _, a3 as _, a4 as _, a5 as _),
|
||||
),
|
||||
SysCallNumber::CreateServerId => SysCall::CreateServerId,
|
||||
SysCallNumber::GetThreadId => SysCall::GetThreadId,
|
||||
SysCallNumber::GetProcessId => SysCall::GetProcessId,
|
||||
SysCallNumber::Invalid => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
|
||||
})
|
||||
}
|
||||
|
|
@ -1334,7 +1364,7 @@ pub fn wait_thread<T>(joiner: crate::arch::WaitHandle<T>) -> SysCallResult {
|
|||
}
|
||||
|
||||
/// Create a new process by running it in its own thread
|
||||
#[cfg(not(target_os = "none"))]
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
pub fn create_process_as_thread<F>(
|
||||
args: ProcessArgsAsThread<F>,
|
||||
) -> core::result::Result<crate::arch::ProcessHandleAsThread, Error>
|
||||
|
|
@ -1352,7 +1382,7 @@ where
|
|||
}
|
||||
|
||||
/// Wait for a thread to finish
|
||||
#[cfg(not(target_os = "none"))]
|
||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||
pub fn wait_process_as_thread(joiner: crate::arch::ProcessHandleAsThread) -> SysCallResult {
|
||||
crate::arch::wait_process_as_thread(joiner)
|
||||
}
|
||||
|
|
@ -1375,6 +1405,28 @@ pub fn wait_process(joiner: crate::arch::ProcessHandle) -> SysCallResult {
|
|||
crate::arch::wait_process(joiner)
|
||||
}
|
||||
|
||||
/// Get the current process ID
|
||||
pub fn current_pid() -> SysCallResult {
|
||||
rsyscall(SysCall::GetProcessId).and_then(|result| {
|
||||
if let Result::ProcessID(pid) = result {
|
||||
Ok(Result::ProcessID(pid))
|
||||
} else {
|
||||
Err(Error::InternalError)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Get the current thread ID
|
||||
pub fn current_tid() -> SysCallResult {
|
||||
rsyscall(SysCall::GetProcessId).and_then(|result| {
|
||||
if let Result::ThreadID(tid) = result {
|
||||
Ok(Result::ThreadID(tid))
|
||||
} else {
|
||||
Err(Error::InternalError)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
pub fn rsyscall(call: SysCall) -> SysCallResult {
|
||||
let mut ret = Result::Ok;
|
||||
let args = call.as_args();
|
||||
|
|
|
|||
Loading…
Reference in a new issue