Merge pull request #49 from betrusted-io/hardware

Merge documentation
This commit is contained in:
bunnie 2021-03-11 22:58:16 +08:00 committed by GitHub
commit 8de49d8966
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
25 changed files with 384 additions and 271 deletions

19
Cargo.lock generated
View file

@ -261,6 +261,15 @@ dependencies = [
"com_rs", "com_rs",
] ]
[[package]]
name = "compiler_builtins"
version = "0.1.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3748f82c7d366a0b4950257d19db685d4958d2fa27c6d164a3f069fec42b748b"
dependencies = [
"rustc-std-workspace-core",
]
[[package]] [[package]]
name = "content-plugin-api" name = "content-plugin-api"
version = "0.1.0" version = "0.1.0"
@ -1028,6 +1037,12 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
[[package]]
name = "rustc-std-workspace-core"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1956f5517128a2b6f23ab2dadf1a976f4f5b27962e7724c2bf3d45e539ec098c"
[[package]] [[package]]
name = "ryu" name = "ryu"
version = "1.0.5" version = "1.0.5"
@ -1536,13 +1551,15 @@ checksum = "b07db065a5cf61a7e4ba64f29e67db906fb1787316516c4e6e5ff0fea1efcd8a"
[[package]] [[package]]
name = "xous" name = "xous"
version = "0.1.0" version = "0.1.2"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"compiler_builtins",
"hex", "hex",
"lazy_static", "lazy_static",
"log", "log",
"rkyv", "rkyv",
"rustc-std-workspace-core",
"xous-macros", "xous-macros",
] ]

2
kernel/Cargo.lock generated
View file

@ -574,7 +574,7 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]] [[package]]
name = "xous" name = "xous"
version = "0.1.0" version = "0.1.2"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"hex", "hex",

View file

@ -792,6 +792,12 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
SysCall::Shutdown => { SysCall::Shutdown => {
SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok)) 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) => { SysCall::Connect(sid) => {
let result = SystemServices::with_mut(|ss| { let result = SystemServices::with_mut(|ss| {

View file

@ -7,34 +7,44 @@ The goal is to have this module work in close conjunction with the
requests through this module. requests through this module.
## Structure ## 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 ### Canvas
A `Canvas` is a minimal data structure that defines a physical region of the 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 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. 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 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 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, Every GAM drawing object includes the GUID of the `Canvas` to which it should be drawn.
an application can request several `Canvas` objects to draw on, but it Upon receiving a draw request, it validates that the GUID exists, and applies
must first send a `SelectCanvas` command first to pick the right `Canvas`. any other relevant rules (for example, a higher security process can use the
By default, the last requested `Canvas` is the default `Canvas` for a GAM to prohibit all drawing of lower security processes by marking their
given connection to the GAM. `Canvas` as not drawable).
The region of the physical screen that can be drawn on by a `Canvas` is All GAM drawing objects specify pixel offsets from a `(0,0)` top-left coordinate
defined by a `clip_rect`. The coordinate space of the `clip_rect` is fixed 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 screen's coordinates, that is, `(0,0)` in the top left, X increasing
to the right, Y increasing down. to the right, Y increasing down.
A `Canvas` stores a `pan_offset`. If the pan offset is `(0,0)`, then the top left A `Canvas` also stores a `pan_offset`. The `pan_offset` is added to every
corner of the `clip_rect` corresponds to data drawn at location `(0,0)` inside coordinate inside the objects that refer to a `Canvas` and then the result
the `Canvas`. The `pan_offset` is added to every coordinate inside the objects that is clipped with `clip_rect`; this allows for easy implementation
refer to a `Canvas` at render time; this allows for easy implementation of panning and scrolling. (Note: this feature is largely untested as of March 2021)
of panning and scrolling.
A `Canvas` has a `trust_level` associated with it. Higher numbers are more 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: 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 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. 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 `TextView` objects are domiciled on the application process. The application
calls can "simulate" certain properties (such as figuring out the dynamic process is responsible for guiding the rough layout of where `TextView`s go
width or height of a text box based on the size of the string within) to assist in a canvas. Once the object is finalized, the `TextView` objects
with laying out `TextViews`. Once the layout is finalized, the `TextView` objects are then mutably lent to the GAM using an `rkyv` lend wrapper;
are then immutably lent to the GAM using an `rkyv` lend wrapper;
the calling thread then blocks until the GAM completes the rendering operation. 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 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 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), 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 fixed size (such that the string will show ellipses `...` if it overruns the
bubble), or of a dynamically growable size based on its content. 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 `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. 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?

View file

@ -22,21 +22,21 @@ pub enum CanvasState {
/// A rectangular region that defines a top-left zero relative offset for graphical items /// A rectangular region that defines a top-left zero relative offset for graphical items
/// and a bottom-right point that defines a clipping area for things drawn inside. /// and a bottom-right point that defines a clipping area for things drawn inside.
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
#[repr(C)]
pub struct Canvas { pub struct Canvas {
// unique, random identifier for the Canvas
gid: Gid,
// screen coordinates of the clipping region // screen coordinates of the clipping region
clip_rect: Rectangle, clip_rect: Rectangle,
// trust level, 255 is most trusted // trust level, 255 is most trusted
trust_level: u8, trust_level: u8,
state: CanvasState,
// unique, random identifier for the Canvas
gid: Gid,
// enables scroll/pan of objects within a region // enables scroll/pan of objects within a region
pan_offset: Point, pan_offset: Point,
// track the drawing state of the canvas
state: CanvasState,
} }
#[allow(dead_code)] #[allow(dead_code)]

View file

@ -25,6 +25,7 @@ use heapless::consts::*;
use rkyv::{Unarchive, archived_value, archived_value_mut}; use rkyv::{Unarchive, archived_value, archived_value_mut};
use core::pin::Pin; use core::pin::Pin;
#[derive(Debug)]
// GIDs of canvases that are used the "Chat" layout. // GIDs of canvases that are used the "Chat" layout.
struct ChatLayout { struct ChatLayout {
// a set of GIDs to track the elements of the chat layout // a set of GIDs to track the elements of the chat layout
@ -178,6 +179,7 @@ impl ModalCanvases {
#[xous::xous_main] #[xous::xous_main]
fn xmain() -> ! { fn xmain() -> ! {
let debug1 = false; // debug level 1 - most general level let debug1 = false; // debug level 1 - most general level
let debugc = false;
log_server::init_wait().unwrap(); log_server::init_wait().unwrap();
info!("GAM: my PID is {}", xous::process::id()); info!("GAM: my PID is {}", xous::process::id());
@ -194,7 +196,7 @@ fn xmain() -> ! {
// a map of canvases accessable by Gid // a map of canvases accessable by Gid
let mut canvases: FnvIndexMap<Gid, Canvas, U32> = FnvIndexMap::new(); let mut canvases: FnvIndexMap<Gid, Canvas, U32> = FnvIndexMap::new();
let modallayout = ModalCanvases::init(trng_conn, &mut canvases).expect("GAM: can't add modal layouts"); // let modallayout = ModalCanvases::init(trng_conn, &mut canvases).expect("GAM: can't add modal layouts");
let mut chatlayout = ChatLayout::init(gfx_conn, trng_conn, &mut canvases).expect("GAM: couldn't create chat layout"); let mut chatlayout = ChatLayout::init(gfx_conn, trng_conn, &mut canvases).expect("GAM: couldn't create chat layout");
chatlayout.clear(&mut canvases).expect("GAM: couldn't clear initial chatlayout"); chatlayout.clear(&mut canvases).expect("GAM: couldn't clear initial chatlayout");
@ -217,6 +219,7 @@ fn xmain() -> ! {
// no content canvas initially, but keep a placeholder for one // no content canvas initially, but keep a placeholder for one
let mut ccc: ContentCanvasConnection = ContentCanvasConnection{connection: None}; let mut ccc: ContentCanvasConnection = ContentCanvasConnection{connection: None};
if debugc{info!("GAM: chatlayout made st {:?} co {:?} pr {:?} in {:?}", chatlayout.status, chatlayout.content, chatlayout.predictive, chatlayout.input);}
// make a thread to manage the status bar -- this needs to start after the IMEF is initialized // make a thread to manage the status bar -- this needs to start after the IMEF is initialized
// the status bar is a trusted element managed by the OS, and we are chosing to domicile this in the GAM process for now // the status bar is a trusted element managed by the OS, and we are chosing to domicile this in the GAM process for now
xous::create_thread_simple(status_thread, chatlayout.status.gid()).expect("GAM: couldn't create status thread"); xous::create_thread_simple(status_thread, chatlayout.status.gid()).expect("GAM: couldn't create status thread");
@ -327,7 +330,7 @@ fn xmain() -> ! {
info!("GAM: attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored."); info!("GAM: attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored.");
} }
} else { } else {
info!("GAM: bogus GID in TextView, not doing anything in response to draw request."); info!("GAM: bogus GID {:?} in TextView {}, not doing anything in response to draw request.", tv.get_canvas_gid(), tv.text);
// silently fail if a bogus Gid is given??? // silently fail if a bogus Gid is given???
} }
}, },

View file

@ -15,9 +15,9 @@ pub fn status_thread(canvas_gid: [u32; 4]) {
if debug1{info!("GAM|status: registering GAM|status thread");} if debug1{info!("GAM|status: registering GAM|status thread");}
let status_sid = xous_names::register_name(xous::names::SERVER_NAME_STATUS).expect("GAM|status: can't register server"); let status_sid = xous_names::register_name(xous::names::SERVER_NAME_STATUS).expect("GAM|status: can't register server");
let gam_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_GAM).expect("GAM|status: can't connect to GAM");
let ticktimer_conn = xous::connect(xous::SID::from_bytes(b"ticktimer-server").unwrap()).unwrap(); let ticktimer_conn = xous::connect(xous::SID::from_bytes(b"ticktimer-server").unwrap()).unwrap();
let com_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_COM).expect("GAM|status: can't connect to COM"); let com_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_COM).expect("GAM|status: can't connect to COM");
let gam_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_GAM).expect("GAM|status: can't connect to GAM");
if debug1{info!("GAM|status: getting screen size");} if debug1{info!("GAM|status: getting screen size");}
let screensize = gam::get_canvas_bounds(gam_conn, status_gid).expect("GAM|status: Couldn't get canvas size"); let screensize = gam::get_canvas_bounds(gam_conn, status_gid).expect("GAM|status: Couldn't get canvas size");
@ -25,7 +25,7 @@ pub fn status_thread(canvas_gid: [u32; 4]) {
if debug1{info!("GAM|status: building textview objects");} if debug1{info!("GAM|status: building textview objects");}
// build uptime text view: left half of status bar // build uptime text view: left half of status bar
let mut uptime_tv = TextView::new(status_gid, 0, let mut uptime_tv = TextView::new(status_gid,
TextBounds::BoundingBox(Rectangle::new(Point::new(0,0), TextBounds::BoundingBox(Rectangle::new(Point::new(0,0),
Point::new(screensize.x / 2, screensize.y - 1)))); Point::new(screensize.x / 2, screensize.y - 1))));
uptime_tv.untrusted = false; uptime_tv.untrusted = false;
@ -37,7 +37,7 @@ pub fn status_thread(canvas_gid: [u32; 4]) {
if debug1{info!("GAM|status: uptime initialized to '{:?}'", uptime_tv);} if debug1{info!("GAM|status: uptime initialized to '{:?}'", uptime_tv);}
// build battstats text view: right half of status bar // build battstats text view: right half of status bar
let mut battstats_tv = TextView::new(status_gid, 0, let mut battstats_tv = TextView::new(status_gid,
TextBounds::BoundingBox(Rectangle::new(Point::new(screensize.x / 2, 0), TextBounds::BoundingBox(Rectangle::new(Point::new(screensize.x / 2, 0),
Point::new(screensize.x, screensize.y - 1)))); Point::new(screensize.x, screensize.y - 1))));
battstats_tv.style = blitstr::GlyphStyle::Small; battstats_tv.style = blitstr::GlyphStyle::Small;

View file

@ -54,9 +54,6 @@ pub struct TextView {
pub token: Option<[u32; 4]>, // optional 128-bit token which is presented to prove a field's trustability pub token: Option<[u32; 4]>, // optional 128-bit token which is presented to prove a field's trustability
pub invert: bool, // only trusted, token-validated TextViews will have the invert bit respected pub invert: bool, // only trusted, token-validated TextViews will have the invert bit respected
// lower numbers are drawn last
pub draw_order: u32,
// offsets for text drawing -- exactly one of the following options should be specified // offsets for text drawing -- exactly one of the following options should be specified
// note that the TextBounds coordinate system is local to the canvas, not the screen // note that the TextBounds coordinate system is local to the canvas, not the screen
pub bounds_hint: TextBounds, pub bounds_hint: TextBounds,
@ -65,7 +62,6 @@ pub struct TextView {
pub dry_run: bool, // set to true if no drawing is desired and we just want to compute the bounds pub dry_run: bool, // set to true if no drawing is desired and we just want to compute the bounds
pub style: GlyphStyle, pub style: GlyphStyle,
pub text: xous::String::<3072>,
pub cursor: Cursor, pub cursor: Cursor,
pub insertion: Option<i32>, // this is the insertion point offset, if it's to be drawn, on the string pub insertion: Option<i32>, // this is the insertion point offset, if it's to be drawn, on the string
pub ellipsis: bool, pub ellipsis: bool,
@ -81,15 +77,17 @@ pub struct TextView {
canvas: Gid, // GID of the canvas to draw on canvas: Gid, // GID of the canvas to draw on
pub clip_rect: Option<Rectangle>, // this is set by the GAM to the canvas' clip_rect; needed by gfx for drawing. Note this is in screen coordinates. pub clip_rect: Option<Rectangle>, // this is set by the GAM to the canvas' clip_rect; needed by gfx for drawing. Note this is in screen coordinates.
pub text: xous::String::<3072>,
} }
impl TextView { impl TextView {
pub fn new(canvas: Gid, draw_order: u32, bounds_hint: TextBounds) -> Self { pub fn new(canvas: Gid, bounds_hint: TextBounds) -> Self {
TextView { TextView {
canvas,
operation: TextOp::Nop, operation: TextOp::Nop,
untrusted: true, untrusted: true,
token: None, token: None,
invert: false, invert: false,
draw_order,
clip_rect: None, clip_rect: None,
bounds_hint, bounds_hint,
bounds_computed: None, bounds_computed: None,
@ -103,7 +101,6 @@ impl TextView {
rounded_border: None, rounded_border: None,
margin: Point { x: 4, y: 4 }, margin: Point { x: 4, y: 4 },
selected: None, selected: None,
canvas,
clear_area: true, clear_area: true,
overflow: None, overflow: None,
dry_run: false, dry_run: false,
@ -120,11 +117,11 @@ impl TextView {
pub fn clear_str(&mut self) { self.text.clear() } pub fn clear_str(&mut self) { self.text.clear() }
pub fn populate_from(&mut self, t: &TextView) { pub fn populate_from(&mut self, t: &TextView) {
self.canvas = t.canvas;
self.operation = t.operation; self.operation = t.operation;
self.untrusted = t.untrusted; self.untrusted = t.untrusted;
self.token = t.token; self.token = t.token;
self.invert = t.invert; self.invert = t.invert;
self.draw_order = t.draw_order;
self.bounds_hint = t.bounds_hint; self.bounds_hint = t.bounds_hint;
self.bounds_computed = t.bounds_computed; self.bounds_computed = t.bounds_computed;
self.style = t.style; self.style = t.style;
@ -136,7 +133,6 @@ impl TextView {
self.rounded_border = t.rounded_border; self.rounded_border = t.rounded_border;
self.margin = t.margin; self.margin = t.margin;
self.selected = t.selected; self.selected = t.selected;
self.canvas = t.canvas;
self.overflow = t.overflow; self.overflow = t.overflow;
self.clip_rect = t.clip_rect; self.clip_rect = t.clip_rect;
self.dry_run = t.dry_run; self.dry_run = t.dry_run;

View file

@ -219,7 +219,7 @@ impl InputTracker {
if let Some(ic) = self.input_canvas { if let Some(ic) = self.input_canvas {
if debug1{info!("IMEF: updating input area");} if debug1{info!("IMEF: updating input area");}
let ic_bounds: Point = gam::get_canvas_bounds(self.gam_conn, ic).expect("IMEF: Couldn't get input canvas bounds"); let ic_bounds: Point = gam::get_canvas_bounds(self.gam_conn, ic).expect("IMEF: Couldn't get input canvas bounds");
let mut input_tv = TextView::new(ic, 255, let mut input_tv = TextView::new(ic,
TextBounds::BoundingBox(Rectangle::new(Point::new(0,1), ic_bounds))); TextBounds::BoundingBox(Rectangle::new(Point::new(0,1), ic_bounds)));
input_tv.draw_border = false; input_tv.draw_border = false;
input_tv.border_width = 1; input_tv.border_width = 1;
@ -523,13 +523,15 @@ impl InputTracker {
} }
} }
let debug_canvas = false;
if valid_predictions == 0 { if valid_predictions == 0 {
let mut empty_tv = TextView::new(pc, 255, let mut empty_tv = TextView::new(pc,
TextBounds::BoundingBox(Rectangle::new(Point::new(0, 1), pc_bounds))); TextBounds::BoundingBox(Rectangle::new(Point::new(0, 1), pc_bounds)));
empty_tv.draw_border = false; empty_tv.draw_border = false;
empty_tv.border_width = 1; empty_tv.border_width = 1;
empty_tv.clear_area = true; empty_tv.clear_area = true;
write!(empty_tv.text, "Ready for input...").expect("IMEF: couldn't set up empty TextView"); write!(empty_tv.text, "Ready for input...").expect("IMEF: couldn't set up empty TextView");
if debug_canvas { info!("IMEF: pc canvas {:?}", pc) }
gam::post_textview(self.gam_conn, &mut empty_tv).expect("IMEF: can't draw prediction TextView"); gam::post_textview(self.gam_conn, &mut empty_tv).expect("IMEF: can't draw prediction TextView");
} else if update_predictor { } else if update_predictor {
// alright, first, let's clear the area // alright, first, let's clear the area
@ -554,7 +556,7 @@ impl InputTracker {
DrawStyle { fill_color: None, stroke_color: Some(PixelColor::Dark), stroke_width: 1 } DrawStyle { fill_color: None, stroke_color: Some(PixelColor::Dark), stroke_width: 1 }
)).expect("IMEF: couldn't draw dividing lines in prediction area"); )).expect("IMEF: couldn't draw dividing lines in prediction area");
} }
let mut p_tv = TextView::new(pc, 255, let mut p_tv = TextView::new(pc,
TextBounds::BoundingBox(p_clip)); TextBounds::BoundingBox(p_clip));
p_tv.draw_border = false; p_tv.draw_border = false;
p_tv.border_width = 1; p_tv.border_width = 1;
@ -578,7 +580,8 @@ impl InputTracker {
#[xous::xous_main] #[xous::xous_main]
fn xmain() -> ! { fn xmain() -> ! {
let debug1 = false; let debug1 = false;
let dbglistener = true; let dbglistener = false;
let dbgcanvas = false;
log_server::init_wait().unwrap(); log_server::init_wait().unwrap();
info!("IMEF: my PID is {}", xous::process::id()); info!("IMEF: my PID is {}", xous::process::id());
@ -601,11 +604,11 @@ fn xmain() -> ! {
if let Ok(opcode) = ImefOpcode::try_from(&envelope.body) { if let Ok(opcode) = ImefOpcode::try_from(&envelope.body) {
match opcode { match opcode {
ImefOpcode::SetInputCanvas(g) => { ImefOpcode::SetInputCanvas(g) => {
if debug1{info!("IMEF: got input canvas {:?}", g);} if debug1 || dbgcanvas {info!("IMEF: got input canvas {:?}", g);}
tracker.set_input_canvas(g); tracker.set_input_canvas(g);
}, },
ImefOpcode::SetPredictionCanvas(g) => { ImefOpcode::SetPredictionCanvas(g) => {
if debug1{info!("IMEF: got prediction canvas {:?}", g);} if debug1 || dbgcanvas {info!("IMEF: got prediction canvas {:?}", g);}
tracker.set_pred_canvas(g); tracker.set_pred_canvas(g);
}, },
_ => info!("IMEF: expected canvas Gid, but got {:?}", opcode) _ => info!("IMEF: expected canvas Gid, but got {:?}", opcode)

View file

@ -0,0 +1,44 @@
# Shell Chat
`shellchat` is a baseline demo application for Xous. It uses a chat-client
style interface (stacking bubbles of text, with user input right-aligned
and shell feedback left-aligned) to facilitate interactions with the hardware.
It implements the basic envisioned structure of a Xous application, namely:
- Text input comes via the `ime-frontend`
- Graphical output is rendered via the `gam`
Other facilities for handling system-level messages, such as menu configurations
and network events, have yet to be implemented. However, they will likely end up
with a demo in this application first.
To make your own command, copy the `echo.rs` template or snag the one below, and put
it in the services/shellchat/src/cmds/ directory:
```Rust
use crate::{ShellCmdApi, CommonEnv};
use xous::String;
#[derive(Debug)]
pub struct Echo {
}
impl<'a> ShellCmdApi<'a> for Echo {
cmd_api!(echo); // inserts boilerplate for command API
fn process(&mut self, args: String::<1024>, _env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
Ok(Some(rest))
}
}
```
The "verb" is the name of your command, and it is the argument to the `cmd_api!()` macro.
`process()` is your "main" function, and `args` is a string which contains the
rest of the line that was typed into the chat, minus the verb used to identify
your command (the arguments, as they may be, but not tokenized or parsed in
any way). `env` contains some items in a common environment, for example, connections
to the GAM, LLIO server or other resources required by your implementation.
Once you've added your command to the directory, go to the `cmds.rs` file, and follow
the four-step instructions embedded within the file, starting around line 40.

View file

@ -1,49 +1,34 @@
use xous::String; use xous::String;
use core::fmt::Write; use core::fmt::Write;
/////////////////////////// Common items to all commands
pub trait ShellCmdApi<'a> { pub trait ShellCmdApi<'a> {
// user implemented:
// called to process the command with the remainder of the string attached
fn process(&mut self, args: String::<1024>, env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error>;
// created with cmd_api! macro
// checks if the command matches the current verb in question // checks if the command matches the current verb in question
fn matches(&self, verb: &str) -> bool; fn matches(&self, verb: &str) -> bool;
// called to process the command with the remainder of the string attached
fn process(&mut self, rest: String::<1024>, env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error>;
// returns my verb // returns my verb
fn verb(&self) -> &'static str; fn verb(&self) -> &'static str;
} }
// the argument to this macro is the command verb
/// extract the first token, as delimited by spaces macro_rules! cmd_api {
/// modifies the incoming line by removing the token and returning the remainder ($verb:expr) => {
/// returns the found token fn verb(&self) -> &'static str {
/// note: we don't have split() because of nostd stringify!($verb)
pub fn tokenize(line: &mut String::<1024>) -> Option<String::<1024>> {
let mut token = String::<1024>::new();
let mut retline = String::<1024>::new();
let lineiter = line.as_str().unwrap().chars();
let mut foundspace = false;
let mut foundrest = false;
for ch in lineiter {
if ch != ' ' && !foundspace {
token.push(ch).unwrap();
} else if foundspace && foundrest {
retline.push(ch).unwrap();
} else if foundspace && ch != ' ' {
// handle case of multiple spaces in a row
foundrest = true;
retline.push(ch).unwrap();
} else {
foundspace = true;
// consume the space
} }
} fn matches(&self, verb: &str) -> bool {
line.clear(); if verb == stringify!($verb) {
write!(line, "{}", retline.as_str().unwrap()).unwrap(); true
if token.len() > 0 { } else {
Some(token) false
} else { }
None }
} };
} }
/////////////////////////// Command shell integration
#[derive(Debug)] #[derive(Debug)]
pub struct CommonEnv { pub struct CommonEnv {
llio: xous::CID, llio: xous::CID,
@ -52,18 +37,29 @@ pub struct CommonEnv {
gam: xous::CID, gam: xous::CID,
} }
mod echo; /*
use echo::*; To add a new command:
mod test; 0. ensure that the command implements the ShellCmdApi (above)
use test::*; 1. mod/use the new command
mod sleep; 2. create an entry for the command's storage in the CmdEnv structure
use sleep::*; 3. initialize the persistant storage here
mod sensors; 4. add it to the "commands" array in the dispatch() routine below
use sensors::*;
Side note: if your command doesn't require persistent storage, you could,
technically, generate the command dynamically every time it's called. Echo
demonstrates this.
*/
///// 1. add your module here, and pull its namespace into the local crate
mod echo; use echo::*;
mod test; use test::*;
mod sleep; use sleep::*;
mod sensors; use sensors::*;
#[derive(Debug)] #[derive(Debug)]
pub struct CmdEnv { pub struct CmdEnv {
common_env: CommonEnv, common_env: CommonEnv,
///// 2. declare storage for your command here.
test_cmd: Test, test_cmd: Test,
sleep_cmd: Sleep, sleep_cmd: Sleep,
sensors_cmd: Sensors, sensors_cmd: Sensors,
@ -71,18 +67,6 @@ pub struct CmdEnv {
impl CmdEnv { impl CmdEnv {
pub fn new(gam: xous::CID) -> CmdEnv { pub fn new(gam: xous::CID) -> CmdEnv {
let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap(); let ticktimer_server_id = xous::SID::from_bytes(b"ticktimer-server").unwrap();
/*
To add a new command:
- ensure that the command implements the ShellCmdApi
- mod/use the new command (above)
- create an entry for the command's storage in the CmdEnv structure
- initialize the persistant storage here
- add it to the "commands" array in the dispatch() routine below
Side note: if your command doesn't require persistent storage, you could,
technically, generate the command dynamically every time it's called. Echo
demonstrates this.
*/
CmdEnv { CmdEnv {
common_env: CommonEnv { common_env: CommonEnv {
llio: xous_names::request_connection_blocking(xous::names::SERVER_NAME_LLIO).expect("CMD: can't connect to LLIO"), llio: xous_names::request_connection_blocking(xous::names::SERVER_NAME_LLIO).expect("CMD: can't connect to LLIO"),
@ -90,6 +74,7 @@ impl CmdEnv {
ticktimer: xous::connect(ticktimer_server_id).unwrap(), ticktimer: xous::connect(ticktimer_server_id).unwrap(),
gam, gam,
}, },
///// 3. initialize your storage, by calling new()
test_cmd: Test::new(), test_cmd: Test::new(),
sleep_cmd: Sleep::new(), sleep_cmd: Sleep::new(),
sensors_cmd: Sensors::new(), sensors_cmd: Sensors::new(),
@ -101,6 +86,7 @@ impl CmdEnv {
let mut echo_cmd = Echo {}; // this command has no persistent storage, so we can "create" it every time we call dispatch (but it's a zero-cost absraction so this doesn't actually create any instructions) let mut echo_cmd = Echo {}; // this command has no persistent storage, so we can "create" it every time we call dispatch (but it's a zero-cost absraction so this doesn't actually create any instructions)
let commands: &mut [& mut dyn ShellCmdApi] = &mut [ let commands: &mut [& mut dyn ShellCmdApi] = &mut [
///// 4. add your command to this array, so that it can be looked up and dispatched
&mut echo_cmd, &mut echo_cmd,
&mut self.test_cmd, &mut self.test_cmd,
&mut self.sleep_cmd, &mut self.sleep_cmd,
@ -143,3 +129,37 @@ impl CmdEnv {
} }
} }
} }
/// extract the first token, as delimited by spaces
/// modifies the incoming line by removing the token and returning the remainder
/// returns the found token
/// note: we don't have split() because of nostd
pub fn tokenize(line: &mut String::<1024>) -> Option<String::<1024>> {
let mut token = String::<1024>::new();
let mut retline = String::<1024>::new();
let lineiter = line.as_str().unwrap().chars();
let mut foundspace = false;
let mut foundrest = false;
for ch in lineiter {
if ch != ' ' && !foundspace {
token.push(ch).unwrap();
} else if foundspace && foundrest {
retline.push(ch).unwrap();
} else if foundspace && ch != ' ' {
// handle case of multiple spaces in a row
foundrest = true;
retline.push(ch).unwrap();
} else {
foundspace = true;
// consume the space
}
}
line.clear();
write!(line, "{}", retline.as_str().unwrap()).unwrap();
if token.len() > 0 {
Some(token)
} else {
None
}
}

View file

@ -5,22 +5,10 @@ use xous::String;
pub struct Echo { pub struct Echo {
} }
const VERB: &str = "echo";
impl<'a> ShellCmdApi<'a> for Echo { impl<'a> ShellCmdApi<'a> for Echo {
fn matches(&self, verb: &str) -> bool { cmd_api!(echo); // inserts boilerplate for command API
if verb == VERB {
true
} else {
false
}
}
fn process(&mut self, rest: String::<1024>, _env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> { fn process(&mut self, args: String::<1024>, _env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
Ok(Some(rest)) Ok(Some(args))
}
fn verb(&self) -> &'static str {
VERB
} }
} }

View file

@ -10,10 +10,11 @@ impl Sensors {
} }
} }
const VERB: &str = "sensors";
impl<'a> ShellCmdApi<'a> for Sensors { impl<'a> ShellCmdApi<'a> for Sensors {
fn process(&mut self, _rest: String::<1024>, env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> { cmd_api!(sensors);
fn process(&mut self, _args: String::<1024>, env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
use core::fmt::Write; use core::fmt::Write;
let mut ret = String::<1024>::new(); let mut ret = String::<1024>::new();
@ -29,16 +30,4 @@ impl<'a> ShellCmdApi<'a> for Sensors {
Ok(Some(ret)) Ok(Some(ret))
} }
fn verb(&self) -> &'static str {
VERB
}
fn matches(&self, verb: &str) -> bool {
if verb == VERB {
true
} else {
false
}
}
} }

View file

@ -10,10 +10,10 @@ impl Sleep {
} }
} }
const VERB: &str = "sleep";
impl<'a> ShellCmdApi<'a> for Sleep { impl<'a> ShellCmdApi<'a> for Sleep {
fn process(&mut self, _rest: String::<1024>, env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> { cmd_api!(sleep); // inserts boilerplate for command API
fn process(&mut self, _args: String::<1024>, env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
use core::fmt::Write; use core::fmt::Write;
let mut ret = String::<1024>::new(); let mut ret = String::<1024>::new();
@ -41,16 +41,4 @@ impl<'a> ShellCmdApi<'a> for Sleep {
Ok(Some(ret)) Ok(Some(ret))
} }
} }
fn verb(&self) -> &'static str {
VERB
}
fn matches(&self, verb: &str) -> bool {
if verb == VERB {
true
} else {
false
}
}
} }

View file

@ -13,18 +13,10 @@ impl Test {
} }
} }
const VERB: &str = "test";
impl<'a> ShellCmdApi<'a> for Test { impl<'a> ShellCmdApi<'a> for Test {
fn matches(&self, verb: &str) -> bool { cmd_api!(test);
if verb == VERB {
true
} else {
false
}
}
fn process(&mut self, _rest: String::<1024>, _env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> { fn process(&mut self, _args: String::<1024>, _env: &mut CommonEnv) -> Result<Option<String::<1024>>, xous::Error> {
use core::fmt::Write; use core::fmt::Write;
self.state += 1; self.state += 1;
@ -32,8 +24,4 @@ impl<'a> ShellCmdApi<'a> for Test {
write!(ret, "Test has run {} times.", self.state).unwrap(); write!(ret, "Test has run {} times.", self.state).unwrap();
Ok(Some(ret)) Ok(Some(ret))
} }
fn verb(&self) -> &'static str {
VERB
}
} }

View file

@ -153,12 +153,12 @@ impl Repl{
for h in self.history.iter().rev() { for h in self.history.iter().rev() {
let mut bubble_tv = let mut bubble_tv =
if h.is_input { if h.is_input {
TextView::new(self.content, 255, TextView::new(self.content,
TextBounds::GrowableFromBr( TextBounds::GrowableFromBr(
Point::new(self.screensize.x - self.margin.x, bubble_baseline), Point::new(self.screensize.x - self.margin.x, bubble_baseline),
self.bubble_width)) self.bubble_width))
} else { } else {
TextView::new(self.content, 255, TextView::new(self.content,
TextBounds::GrowableFromBl( TextBounds::GrowableFromBl(
Point::new(self.margin.x, bubble_baseline), Point::new(self.margin.x, bubble_baseline),
self.bubble_width)) self.bubble_width))

View file

@ -1,27 +1,39 @@
[package] [package]
name = "xous" name = "xous"
version = "0.1.0" version = "0.1.2"
authors = ["Sean Cross <sean@xobs.io>"] authors = ["Sean Cross <sean@xobs.io>"]
edition = "2018" edition = "2018"
license = "MIT OR Apache-2.0" license = "MIT OR Apache-2.0"
description = "System call interface for Xous" description = "System call interface for Xous"
[dependencies] [dependencies]
bitflags = "1" bitflags = {version = "1", optional = true }
xous-macros = { path = "../macros", version = "0.1.0" } xous-macros = { path = "../macros", version = "0.1.0" }
log = { version = "0.4", optional = true } 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] [features]
# If this is set, then the "Drop" feature of MemoryMessage structs # If this is set, then the "Drop" feature of MemoryMessage structs
# will not be implemented. This should only be set by the kernel. # will not be implemented. This should only be set by the kernel.
forget-memory-messages = [] 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 # `logging` causes this program to connect to a log server on startup
# so you can run log commands such as `info!()`. # so you can run log commands such as `info!()`.
logging = ["log"] 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] [target.'cfg(any(windows,unix))'.dependencies]
lazy_static = "1.4" lazy_static = "1.4"

View file

@ -1,9 +1,9 @@
#[cfg(target_os = "none")] #[cfg(any(target_os = "none", target_os = "xous"))]
pub mod native; pub mod native;
#[cfg(target_os = "none")] #[cfg(any(target_os = "none", target_os = "xous"))]
pub use native::*; pub use native::*;
#[cfg(not(target_os = "none"))] #[cfg(not(any(target_os = "none", target_os = "xous")))]
pub mod hosted; pub mod hosted;
#[cfg(not(target_os = "none"))] #[cfg(not(any(target_os = "none", target_os = "xous")))]
pub use hosted::*; pub use hosted::*;

View file

@ -174,12 +174,12 @@ where
T: Send + 'static, T: Send + 'static,
U: Send + 'static, U: Send + 'static,
{ {
let stack = crate::map_memory( #[cfg(feature = "bit-flags")]
None, let flags = crate::MemoryFlags::R | crate::MemoryFlags::W | crate::MemoryFlags::RESERVE;
None, #[cfg(not(feature = "bit-flags"))]
131_072, let flags = 0b0000_0010 | 0b0000_0100 | 0b0000_0001;
crate::MemoryFlags::R | crate::MemoryFlags::W | crate::MemoryFlags::RESERVE,
)?; let stack = crate::map_memory(None, None, 131_072, flags)?;
let start = unsafe { core::mem::transmute(*f) }; let start = unsafe { core::mem::transmute(*f) };
let arg = unsafe { core::mem::transmute(arg) }; let arg = unsafe { core::mem::transmute(arg) };
Ok(ThreadInit::new(start, stack, Some(arg), [0; 12])) Ok(ThreadInit::new(start, stack, Some(arg), [0; 12]))

View file

@ -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)] #[derive(Debug)]
pub struct XousBuffer<'a> { pub struct XousBuffer<'a> {
@ -11,16 +14,23 @@ pub struct XousBuffer<'a> {
impl<'a> XousBuffer<'a> { impl<'a> XousBuffer<'a> {
#[allow(dead_code)] #[allow(dead_code)]
pub fn new(len: usize) -> Self { pub fn new(len: usize) -> Self {
let remainder = let remainder = if ((len & 0xFFF) == 0) && (len > 0) {
if ((len & 0xFFF) == 0) && (len > 0) { 0 } 0
else { 0x1000 - (len & 0xFFF) }; } 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( let new_mem = map_memory(
None, None,
None, None,
// Ensure our byte size is a multiple of 4096 // Ensure our byte size is a multiple of 4096
len + remainder, len + remainder,
MemoryFlags::R | MemoryFlags::W, flags,
) )
.expect("XousBuffer: error in new()/map_memory"); .expect("XousBuffer: error in new()/map_memory");
@ -28,7 +38,9 @@ impl<'a> XousBuffer<'a> {
valid.size = MemorySize::new(len + remainder).unwrap(); valid.size = MemorySize::new(len + remainder).unwrap();
XousBuffer { XousBuffer {
range: new_mem, 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, valid,
should_drop: true, should_drop: true,
} }
@ -46,11 +58,7 @@ impl<'a> XousBuffer<'a> {
/// Perform a mutable lend of this Carton to the server. /// Perform a mutable lend of this Carton to the server.
#[allow(dead_code)] #[allow(dead_code)]
pub fn lend_mut( pub fn lend_mut(&mut self, connection: CID, id: u32) -> core::result::Result<Result, Error> {
&mut self,
connection: CID,
id: u32,
) -> core::result::Result<Result, Error> {
let msg = MemoryMessage { let msg = MemoryMessage {
id: id as usize, id: id as usize,
buf: self.valid, buf: self.valid,
@ -61,11 +69,7 @@ impl<'a> XousBuffer<'a> {
} }
#[allow(dead_code)] #[allow(dead_code)]
pub fn lend( pub fn lend(&self, connection: CID, id: u32) -> core::result::Result<Result, Error> {
&self,
connection: CID,
id: u32
) -> core::result::Result<Result, Error> {
let msg = MemoryMessage { let msg = MemoryMessage {
id: id as usize, id: id as usize,
buf: self.valid, buf: self.valid,
@ -76,11 +80,7 @@ impl<'a> XousBuffer<'a> {
} }
#[allow(dead_code)] #[allow(dead_code)]
pub fn send( pub fn send(mut self, connection: CID, id: u32) -> core::result::Result<Result, Error> {
mut self,
connection: CID,
id: u32,
) -> core::result::Result<Result, Error> {
let msg = crate::MemoryMessage { let msg = crate::MemoryMessage {
id: id as usize, id: id as usize,
buf: self.valid, buf: self.valid,

View file

@ -19,13 +19,12 @@ impl<'a> Carton<'a> {
let remainder = bytes.len() & 4095; let remainder = bytes.len() & 4095;
let size = bytes.len() + (4096 - remainder); let size = bytes.len() + (4096 - remainder);
let new_mem = crate::map_memory( #[cfg(feature = "bit-flags")]
None, let flags = crate::MemoryFlags::R | crate::MemoryFlags::W;
None, #[cfg(not(feature = "bit-flags"))]
size, let flags = 0b0000_0010 | 0b0000_0100;
crate::MemoryFlags::R | crate::MemoryFlags::W,
) let new_mem = crate::map_memory(None, None, size, flags).unwrap();
.unwrap();
// NOTE: Remaining bytes are not zeroed. We assume the kernel has done this for us. // NOTE: Remaining bytes are not zeroed. We assume the kernel has done this for us.
unsafe { unsafe {

View file

@ -115,6 +115,7 @@ pub struct MemoryRange {
pub size: MemorySize, pub size: MemorySize,
} }
#[cfg(feature = "bitflags")]
bitflags! { bitflags! {
/// Flags to be passed to the MapMemory struct. /// Flags to be passed to the MapMemory struct.
/// Note that it is an error to have memory be /// Note that it is an error to have memory be
@ -138,6 +139,25 @@ bitflags! {
const X = 0b0000_1000; 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> { pub fn pid_from_usize(src: usize) -> core::result::Result<PID, Error> {
if src > u8::MAX as _ { if src > u8::MAX as _ {

View file

@ -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] #[macro_use]
extern crate bitflags; extern crate bitflags;
@ -12,27 +13,30 @@ pub mod arch;
pub mod carton; pub mod carton;
pub mod definitions; pub mod definitions;
mod messages; mod messages;
pub mod string;
pub mod buffer; pub mod buffer;
pub mod syscall;
pub mod process; pub mod process;
#[cfg(feature = "archive")]
pub mod string;
pub mod syscall;
pub mod names; pub mod names;
pub use arch::{ProcessArgs, ProcessInit, ProcessKey, ThreadInit}; pub use arch::{ProcessArgs, ProcessInit, ProcessKey, ThreadInit};
pub use buffer::XousBuffer;
pub use definitions::*; pub use definitions::*;
pub use messages::*; pub use messages::*;
#[cfg(feature = "archive")]
pub use string::*; pub use string::*;
pub use syscall::*; 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; pub use arch::ProcessArgsAsThread;
#[cfg(target_os = "none")] #[cfg(any(target_os = "none", target_os = "xous"))]
pub fn init() {} pub fn init() {}
#[cfg(not(target_os = "none"))] #[cfg(not(any(target_os = "none", target_os = "xous")))]
pub fn init() { pub fn init() {
use std::panic; use std::panic;
panic::set_hook(Box::new(|arg| { panic::set_hook(Box::new(|arg| {
@ -61,6 +65,7 @@ macro_rules! maybe_main {
} }
fn main() { fn main() {
#[cfg(not(target_os = "xous"))]
xous::arch::ensure_connection().unwrap(); xous::arch::ensure_connection().unwrap();
unsafe { xous_entry() }; unsafe { xous_entry() };
} }

View file

@ -1,17 +1,9 @@
#[cfg(not(target_os = "none"))]
pub fn id() -> u32 { 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")] pub fn set_id(_id: u32) {}
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)
}

View file

@ -8,7 +8,7 @@ use core::convert::TryInto;
// use num_derive::FromPrimitive; // use num_derive::FromPrimitive;
// use num_traits::FromPrimitive; // use num_traits::FromPrimitive;
#[cfg(not(target_os = "none"))] #[cfg(not(any(target_os = "none", target_os = "xous")))]
use crate::ProcessArgsAsThread; use crate::ProcessArgsAsThread;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
@ -299,6 +299,12 @@ pub enum SysCall {
/// disclosing SIDs. /// disclosing SIDs.
ConnectForProcess(PID, SID), ConnectForProcess(PID, SID),
/// Get the current Thread ID
GetThreadId,
/// Get the current Process ID
GetProcessId,
/// This syscall does not exist. It captures all possible /// This syscall does not exist. It captures all possible
/// arguments so detailed analysis can be performed. /// arguments so detailed analysis can be performed.
Invalid(usize, usize, usize, usize, usize, usize, usize), Invalid(usize, usize, usize, usize, usize, usize, usize),
@ -336,6 +342,8 @@ pub enum SysCallNumber {
CreateServer = 29, CreateServer = 29,
ConnectForProcess = 30, ConnectForProcess = 30,
CreateServerId = 31, CreateServerId = 31,
GetThreadId = 32,
GetProcessId = 33,
Invalid, Invalid,
} }
@ -373,6 +381,8 @@ impl SysCallNumber {
29 => CreateServer, 29 => CreateServer,
30 => ConnectForProcess, 30 => ConnectForProcess,
31 => CreateServerId, 31 => CreateServerId,
32 => GetThreadId,
33 => GetProcessId,
_ => Invalid, _ => Invalid,
} }
} }
@ -395,7 +405,7 @@ impl SysCall {
a1.map(|x| x.get()).unwrap_or_default(), a1.map(|x| x.get()).unwrap_or_default(),
a2.map(|x| x.get()).unwrap_or_default(), a2.map(|x| x.get()).unwrap_or_default(),
a3.get(), a3.get(),
a4.bits(), crate::get_bits(a4),
0, 0,
0, 0,
0, 0,
@ -499,7 +509,7 @@ impl SysCall {
SysCall::IncreaseHeap(a1, a2) => [ SysCall::IncreaseHeap(a1, a2) => [
SysCallNumber::IncreaseHeap as usize, SysCallNumber::IncreaseHeap as usize,
*a1 as usize, *a1 as usize,
a2.bits(), crate::get_bits(a2),
0, 0,
0, 0,
0, 0,
@ -520,7 +530,7 @@ impl SysCall {
SysCallNumber::UpdateMemoryFlags as usize, SysCallNumber::UpdateMemoryFlags as usize,
a1.get(), a1.get(),
*a2 as usize, *a2 as usize,
a3.bits(), crate::get_bits(a3),
0, 0,
0, 0,
0, 0,
@ -668,6 +678,24 @@ impl SysCall {
0, 0,
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) => [ SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7) => [
SysCallNumber::Invalid as usize, SysCallNumber::Invalid as usize,
*a1, *a1,
@ -697,7 +725,7 @@ impl SysCall {
MemoryAddress::new(a1), MemoryAddress::new(a1),
MemoryAddress::new(a2), MemoryAddress::new(a2),
MemoryAddress::new(a3).ok_or(Error::InvalidSyscall)?, 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 => { SysCallNumber::UnmapMemory => {
SysCall::UnmapMemory(MemoryRange::new(a1, a2).or(Err(Error::InvalidSyscall))?) 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::ReadyThreads => SysCall::ReadyThreads(pid_from_usize(a1)?),
SysCallNumber::IncreaseHeap => SysCall::IncreaseHeap( SysCallNumber::IncreaseHeap => SysCall::IncreaseHeap(
a1 as usize, 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::DecreaseHeap => SysCall::DecreaseHeap(a1 as usize),
SysCallNumber::UpdateMemoryFlags => SysCall::UpdateMemoryFlags( SysCallNumber::UpdateMemoryFlags => SysCall::UpdateMemoryFlags(
MemoryAddress::new(a1).ok_or(Error::InvalidSyscall)?, MemoryAddress::new(a1).ok_or(Error::InvalidSyscall)?,
a2 as usize, a2 as usize,
MemoryFlags::from_bits(a3).ok_or(Error::InvalidSyscall)?, crate::from_bits(a3).ok_or(Error::InvalidSyscall)?,
), ),
SysCallNumber::SetMemRegion => SysCall::SetMemRegion( SysCallNumber::SetMemRegion => SysCall::SetMemRegion(
pid_from_usize(a1)?, pid_from_usize(a1)?,
@ -867,6 +895,8 @@ impl SysCall {
SID::from_u32(a2 as _, a3 as _, a4 as _, a5 as _), SID::from_u32(a2 as _, a3 as _, a4 as _, a5 as _),
), ),
SysCallNumber::CreateServerId => SysCall::CreateServerId, SysCallNumber::CreateServerId => SysCall::CreateServerId,
SysCallNumber::GetThreadId => SysCall::GetThreadId,
SysCallNumber::GetProcessId => SysCall::GetProcessId,
SysCallNumber::Invalid => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7), 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 /// 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>( pub fn create_process_as_thread<F>(
args: ProcessArgsAsThread<F>, args: ProcessArgsAsThread<F>,
) -> core::result::Result<crate::arch::ProcessHandleAsThread, Error> ) -> core::result::Result<crate::arch::ProcessHandleAsThread, Error>
@ -1352,7 +1382,7 @@ where
} }
/// Wait for a thread to finish /// 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 { pub fn wait_process_as_thread(joiner: crate::arch::ProcessHandleAsThread) -> SysCallResult {
crate::arch::wait_process_as_thread(joiner) 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) 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 { pub fn rsyscall(call: SysCall) -> SysCallResult {
let mut ret = Result::Ok; let mut ret = Result::Ok;
let args = call.as_args(); let args = call.as_args();