saymrwulf/xous-core
1
0
Fork 0
mirror of https://github.com/saymrwulf/xous-core.git synced 2026-11-14 08:03:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

xous: remove xous::xous_main macro

Browse source 
This macro is now unused, and does not serve a purpose. Remove it to
improve build times.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2022-05-31 13:41:48 +08:00
parent 3ae9d8abf0
commit 4ed3b201d0
3 changed files with 2 additions and 136 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
API.md
View file

@ -275,8 +275,7 @@ use xous_ipc::{String, Buffer};
use api::Opcode;
use xous::{CID, msg_scalar_unpack, msg_blocking_scalar_unpack};
#[xous::xous_main]
fn xmain() -> ! {
fn main() -> ! {
log_server::init_wait().unwrap();
info!("my PID is {}", xous::process::id()); // this is so we can figure out what PID goes to what server

7
xous-rs/Cargo.toml
View file

@ -8,10 +8,7 @@ description = "System call interface for Xous"
repository = "https://github.com/betrusted-io/xous-core/"
homepage = "https://betrusted.io/"
# Dependency policy: fully specify dependencies to the minor version number
[dependencies]
bitflags = {version = "1.2.1", optional = true }
xous-macros = { path = "../macros", version = "0.1.0", optional = true }
core = { version = '1.0.0', optional = true, package = 'rustc-std-workspace-core' }
compiler_builtins = { version = '0.1.0', optional = true }
@ -21,8 +18,6 @@ compiler_builtins = { version = '0.1.0', optional = true }
# will not be implemented. This should only be set by the kernel.
forget-memory-messages = []
# Enable using `bitflags`
# This is being built as part of libstd
rustc-dep-of-std = ['core', 'compiler_builtins/rustc-dep-of-std']
@ -30,7 +25,5 @@ rustc-dep-of-std = ['core', 'compiler_builtins/rustc-dep-of-std']
# testing.
processes-as-threads = []
default = ["xous-macros"]
[target.'cfg(any(windows,unix))'.dependencies]
lazy_static = "1.4.0"

128
xous-rs/src/lib.rs
View file

@ -1,14 +1,5 @@
#![cfg_attr(any(target_os = "none", target_os = "xous"), no_std)]
#[cfg(feature = "bitflags")]
#[macro_use]
extern crate bitflags;
#[cfg(not(feature = "rustc-dep-of-std"))]
extern crate xous_macros as macros;
#[cfg(not(feature = "rustc-dep-of-std"))]
pub use macros::xous_main;
pub mod arch;
pub mod carton;
@ -30,121 +21,4 @@ pub mod locale;
pub use locale::LANG;
#[cfg(feature = "processes-as-threads")]
pub use crate::arch::ProcessArgsAsThread;
pub fn init() {}
#[cfg(not(target_os = "none"))]
#[macro_export]
macro_rules! maybe_main {
() => {
extern "Rust" {
fn xous_entry() -> !;
}
fn main() {
#[cfg(not(target_os = "xous"))]
xous::arch::set_thread_id(1);
unsafe { xous_entry() };
}
};
}
#[cfg(target_os = "none")]
#[macro_export]
macro_rules! maybe_main {
() => {
use core::panic::PanicInfo;
#[panic_handler]
fn handle_panic(arg: &PanicInfo) -> ! {
use core::fmt::Write;
use xous::{
terminate_process, try_connect, try_send_message, wait_event, Message,
ScalarMessage, CID, SID,
};
// Try to connect to the log server. If this fails, we won't be able to print
// anything anyway.
// We use `try_connect()` here because we want this to work even during an interrupt handler.
// If we've already connected to the log server, then the kernel will reuse the
// connection number.
if let Ok(conn) = try_connect(SID::from_bytes(b"xous-log-server ").unwrap()) {
struct PanicWriter {
conn: CID,
}
impl PanicWriter {
// Group `usize` bytes into a `usize` and return it, beginning
// from `offset` * sizeof(usize) bytes from the start. For example,
// `group_or_null([1,2,3,4,5,6,7,8], 1)` on a 32-bit system will
// return a usize with 5678 packed into it.
fn group_or_null(data: &[u8], offset: usize) -> usize {
let start = offset * core::mem::size_of::<usize>();
let mut out_array = [0u8; core::mem::size_of::<usize>()];
for i in 0..core::mem::size_of::<usize>() {
out_array[i] = if i + start < data.len() {
data[start + i]
} else {
0
};
}
usize::from_le_bytes(out_array)
}
}
impl core::fmt::Write for PanicWriter {
fn write_str(&mut self, s: &str) -> core::result::Result<(), core::fmt::Error> {
for c in s.as_bytes().chunks(core::mem::size_of::<usize>() * 4) {
// Text is grouped into 4x `usize` words. The id is 1100 plus
// the number of characters in this message.
let mut panic_msg = ScalarMessage {
id: 1100 + c.len(),
arg1: Self::group_or_null(&c, 0),
arg2: Self::group_or_null(&c, 1),
arg3: Self::group_or_null(&c, 2),
arg4: Self::group_or_null(&c, 3),
};
try_send_message(self.conn, Message::Scalar(panic_msg)).ok();
}
Ok(())
}
}
let mut pw = PanicWriter { conn };
// Send the "We're panicking" message (1000).
let panic_start_msg = ScalarMessage {
id: 1000,
arg1: 0,
arg2: 0,
arg3: 0,
arg4: 0,
};
try_send_message(conn, Message::Scalar(panic_start_msg)).ok();
// Send the contents of the panic.
writeln!(&mut pw, "{}", arg).ok();
// Send the "We're done panicking now it's time to quit" message (1200)
let panic_start_msg = ScalarMessage {
id: 1200,
arg1: 0,
arg2: 0,
arg3: 0,
arg4: 0,
};
try_send_message(conn, Message::Scalar(panic_start_msg)).ok();
}
wait_event();
terminate_process(1);
}
extern "Rust" {
fn xous_entry() -> !;
}
#[export_name = "_start"]
pub extern "C" fn _start(pid: u32) {
xous::process::set_id(pid);
unsafe { xous_entry() };
}
};
}
pub use crate::arch::ProcessArgsAsThread;