hosted: fix hosted builds

We can now run `cargo xtask run` and it will do the right thing.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-08-18 13:52:43 +08:00
parent 0ca7fe6f12
commit dfd11f846d
8 changed files with 108 additions and 272 deletions

44
Cargo.lock generated
View file

@ -274,7 +274,6 @@ dependencies = [
name = "log-server" name = "log-server"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"pancurses",
"xous", "xous",
] ]
@ -310,17 +309,6 @@ dependencies = [
"xkbcommon-sys", "xkbcommon-sys",
] ]
[[package]]
name = "ncurses"
version = "5.99.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "15699bee2f37e9f8828c7b35b2bc70d13846db453f2d507713b758fabe536b82"
dependencies = [
"cc",
"libc",
"pkg-config",
]
[[package]] [[package]]
name = "nix" name = "nix"
version = "0.17.0" version = "0.17.0"
@ -391,29 +379,6 @@ dependencies = [
"sdl2", "sdl2",
] ]
[[package]]
name = "pancurses"
version = "0.16.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3058bc37c433096b2ac7afef1c5cdfae49ede0a4ffec3dfc1df1df0959d0ff0"
dependencies = [
"libc",
"log",
"ncurses",
"pdcurses-sys",
"winreg",
]
[[package]]
name = "pdcurses-sys"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "084dd22796ff60f1225d4eb6329f33afaf4c85419d51d440ab6b8c6f4529166b"
dependencies = [
"cc",
"libc",
]
[[package]] [[package]]
name = "pkg-config" name = "pkg-config"
version = "0.3.18" version = "0.3.18"
@ -949,15 +914,6 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "winreg"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a27a759395c1195c4cc5cda607ef6f8f6498f64e78f7900f5de0a127a424704a"
dependencies = [
"winapi",
]
[[package]] [[package]]
name = "x11-dl" name = "x11-dl"
version = "2.18.5" version = "2.18.5"

View file

@ -8,6 +8,5 @@ description = "Log output program"
[dependencies] [dependencies]
xous = { path = "../../xous-rs" } xous = { path = "../../xous-rs" }
[target.'cfg(any(windows, unix))'.dependencies] #[target.'cfg(any(windows, unix))'.dependencies]
#bracket-terminal = "0.8.1" #pancurses = "*"
pancurses = "*"

View file

@ -1,85 +1,19 @@
#![cfg_attr(baremetal, no_std)] #![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(baremetal, no_main)] #![cfg_attr(target_os = "none", no_main)]
#[cfg(baremetal)] #[cfg(baremetal)]
#[macro_use] #[macro_use]
mod debug; mod debug;
mod log_string; mod log_string;
mod start;
use core::fmt::Write; use core::fmt::Write;
use log_string::LogString; use log_string::LogString;
#[cfg(bracket_terminal)] #[cfg(not(target_os = "none"))]
mod implementation {
use bracket_terminal::prelude::*;
use core::fmt::{Error, Write};
use std::sync::mpsc::{channel, Sender};
use std::thread::{spawn, JoinHandle};
struct State {}
impl GameState for State {
fn tick(&mut self, ctx: &mut BTerm) {
ctx.print(1, 1, "Hello Bracket World");
}
}
enum ControlMessage {
Text(String),
Exit,
}
pub struct Output {
stream: Sender<ControlMessage>,
context: Option<BTerm>,
gs: Option<State>,
}
pub fn init() -> Output {
let (tx, rx) = channel();
let context = BTermBuilder::simple80x50()
.with_title("Hello Minimal Bracket World")
.build()
.unwrap();
let gs: State = State {};
Output {
stream: tx,
context: Some(context),
gs: Some(gs),
}
}
impl Output {
pub fn run(&mut self) {
main_loop(self.context.take().unwrap(), self.gs.take().unwrap());
}
}
impl Drop for Output {
fn drop(&mut self) {
self.stream.send(ControlMessage::Exit).unwrap();
// self.finish.take().unwrap().join().unwrap();
}
}
impl Write for Output {
fn write_str(&mut self, s: &str) -> Result<(), Error> {
// It would be nice if this worked with &str
self.stream
.send(ControlMessage::Text(s.to_owned()))
.unwrap();
Ok(())
}
}
}
#[cfg(not(baremetal))]
mod implementation { mod implementation {
use core::fmt::{Error, Write}; use core::fmt::{Error, Write};
use pancurses::{endwin, initscr, Window}; // use pancurses::{endwin, initscr, Window};
use std::sync::mpsc::{channel, Receiver, Sender}; use std::sync::mpsc::{channel, Receiver, Sender};
enum ControlMessage { enum ControlMessage {
@ -88,20 +22,20 @@ mod implementation {
} }
pub struct Output { pub struct Output {
window: Option<Window>, // window: Option<Window>,
tx: Sender<ControlMessage>, tx: Sender<ControlMessage>,
rx: Receiver<ControlMessage>, rx: Receiver<ControlMessage>,
} }
pub fn init() -> Output { pub fn init() -> Output {
let (tx, rx) = channel(); let (tx, rx) = channel();
let window = initscr(); // let window = initscr();
window.nodelay(true); // window.nodelay(true);
Output { Output {
tx, tx,
rx, rx,
window: Some(window), // window: Some(window),
} }
} }
@ -112,13 +46,14 @@ mod implementation {
Ok(msg) => match msg { Ok(msg) => match msg {
ControlMessage::Exit => break, ControlMessage::Exit => break,
ControlMessage::Text(s) => { ControlMessage::Text(s) => {
self.window.as_ref().unwrap().printw(s); print!("{}", s);
self.window.as_ref().unwrap().refresh(); // self.window.as_ref().unwrap().printw(s);
// self.window.as_ref().unwrap().refresh();
} }
}, },
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => { Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
// Calling `getch` refreshes the screen // Calling `getch` refreshes the screen
self.window.as_ref().unwrap().getch(); // self.window.as_ref().unwrap().getch();
} }
Err(e) => panic!("Error: {}", e), Err(e) => panic!("Error: {}", e),
} }
@ -135,7 +70,7 @@ mod implementation {
impl Drop for Output { impl Drop for Output {
fn drop(&mut self) { fn drop(&mut self) {
self.tx.send(ControlMessage::Exit).unwrap(); self.tx.send(ControlMessage::Exit).unwrap();
endwin(); // endwin();
} }
} }
@ -160,7 +95,7 @@ mod implementation {
} }
} }
#[cfg(baremetal)] #[cfg(target_os = "none")]
mod implementation { mod implementation {
use core::fmt::{Error, Write}; use core::fmt::{Error, Write};
@ -217,15 +152,15 @@ mod implementation {
} }
} }
use core::panic::PanicInfo; // use core::panic::PanicInfo;
#[panic_handler] // #[panic_handler]
fn handle_panic(arg: &PanicInfo) -> ! { // fn handle_panic(arg: &PanicInfo) -> ! {
println!("PANIC!"); // println!("PANIC!");
println!("Details: {:?}", arg); // println!("Details: {:?}", arg);
xous::syscall::wait_event(); // xous::syscall::wait_event();
loop {} // loop {}
} // }
fn handle_irq(irq_no: usize, arg: *mut usize) { fn handle_irq(irq_no: usize, arg: *mut usize) {
print!("Handling IRQ {} (arg: {:08x}): ", irq_no, arg as usize); print!("Handling IRQ {} (arg: {:08x}): ", irq_no, arg as usize);
@ -314,8 +249,8 @@ fn reader_thread(mut output: implementation::OutputWriter) {
} }
} }
#[cfg_attr(baremetal, no_mangle)] #[xous::xous_main]
fn main() { fn some_main() -> ! {
let mut output = implementation::init(); let mut output = implementation::init();
let writer = output.get_writer(); let writer = output.get_writer();
// xous::arch::ensure_connection().unwrap(); // xous::arch::ensure_connection().unwrap();
@ -323,4 +258,5 @@ fn main() {
xous::create_thread_simple(reader_thread, writer).unwrap(); xous::create_thread_simple(reader_thread, writer).unwrap();
println!("Running the output"); println!("Running the output");
output.run(); output.run();
panic!("exited");
} }

View file

@ -1,20 +0,0 @@
/// Rust entry point (_start_rust)
///
/// Zeros bss section, initializes data section and calls main. This function
/// never returns.
#[link_section = ".init.rust"]
#[export_name = "_start"]
pub unsafe extern "C" fn start_rust() -> ! {
extern "Rust" {
// This symbol will be provided by the kernel
fn main();
}
main();
panic!("exited main");
}
#[export_name = "abort"]
pub extern "C" fn abort() -> ! {
panic!("aborted");
}

View file

@ -19,5 +19,5 @@ rustflags = [
"-C", "force-frame-pointers=no", "-C", "force-frame-pointers=no",
] ]
[build] #[build]
target = "riscv32imac-unknown-none-elf" #target = "riscv32imac-unknown-none-elf"

View file

@ -55,22 +55,6 @@ use proc_macro::TokenStream;
pub fn xous_main(args: TokenStream, input: TokenStream) -> TokenStream { pub fn xous_main(args: TokenStream, input: TokenStream) -> TokenStream {
let f = parse_macro_input!(input as ItemFn); let f = parse_macro_input!(input as ItemFn);
// let hosted =
// cfg!(target_os = "linux") || cfg!(target_os = "windows") || cfg!(target_os = "macos");
// let is_none = cfg!(target_os = "");
// return parse::Error::new(
// f.span(),
// format!(
// "Target OS is none? {} - hosted? {} Unknown OS? {}",
// is_none,
// hosted,
// cfg!(target_os = "unknown")
// ),
// )
// .to_compile_error()
// .into();
// check the function signature // check the function signature
let valid_signature = f.sig.constness.is_none() let valid_signature = f.sig.constness.is_none()
&& f.sig.asyncness.is_none() && f.sig.asyncness.is_none()
@ -109,95 +93,17 @@ pub fn xous_main(args: TokenStream, input: TokenStream) -> TokenStream {
let hash = random_ident(); let hash = random_ident();
let stmts = f.block.stmts; let stmts = f.block.stmts;
quote!( let r = quote!(
xous::maybe_main!();
#[export_name = "xous_entry"] #[export_name = "xous_entry"]
#(#attrs)* #(#attrs)*
pub #unsafety fn #hash() -> ! { pub #unsafety fn #hash() -> ! {
#(#stmts)* #(#stmts)*
} }
xous::maybe_main!();
) );
.into() r.into()
// pub fn main() {
// #hash()
// }
} }
// /// Attribute to mark which function will be called at the beginning of the reset handler.
// ///
// /// **IMPORTANT**: This attribute can appear at most *once* in the dependency graph. Also, if you
// /// are using Rust 1.30 the attribute must be used on a reachable item (i.e. there must be no
// /// private modules between the item and the root of the crate); if the item is in the root of the
// /// crate you'll be fine. This reachability restriction doesn't apply to Rust 1.31 and newer
// /// releases.
// ///
// /// The function must have the signature of `unsafe fn()`.
// ///
// /// The function passed will be called before static variables are initialized. Any access of static
// /// variables will result in undefined behavior.
// ///
// /// # Examples
// ///
// /// ```
// /// # use riscv_rt_macros::pre_init;
// /// #[pre_init]
// /// unsafe fn before_main() {
// /// // do something here
// /// }
// ///
// /// # fn main() {}
// /// ```
// #[proc_macro_attribute]
// pub fn pre_init(args: TokenStream, input: TokenStream) -> TokenStream {
// let f = parse_macro_input!(input as ItemFn);
// // check the function signature
// let valid_signature = f.sig.constness.is_none()
// && f.sig.asyncness.is_none()
// && f.vis == Visibility::Inherited
// && f.sig.unsafety.is_some()
// && f.sig.abi.is_none()
// && f.sig.inputs.is_empty()
// && f.sig.generics.params.is_empty()
// && f.sig.generics.where_clause.is_none()
// && f.sig.variadic.is_none()
// && match f.sig.output {
// ReturnType::Default => true,
// ReturnType::Type(_, ref ty) => match **ty {
// Type::Tuple(ref tuple) => tuple.elems.is_empty(),
// _ => false,
// },
// };
// if !valid_signature {
// return parse::Error::new(
// f.span(),
// "`#[pre_init]` function must have signature `unsafe fn()`",
// )
// .to_compile_error()
// .into();
// }
// if !args.is_empty() {
// return parse::Error::new(Span::call_site(), "This attribute accepts no arguments")
// .to_compile_error()
// .into();
// }
// // XXX should we blacklist other attributes?
// let attrs = f.attrs;
// let ident = f.sig.ident;
// let block = f.block;
// quote!(
// #[export_name = "__pre_init"]
// #(#attrs)*
// pub unsafe fn #ident() #block
// )
// .into()
// }
// Creates a random identifier // Creates a random identifier
fn random_ident() -> Ident { fn random_ident() -> Ident {
let secs = SystemTime::now() let secs = SystemTime::now()
@ -221,9 +127,9 @@ fn random_ident() -> Ident {
&(0..16) &(0..16)
.map(|i| { .map(|i| {
if i == 0 || rng.gen() { if i == 0 || rng.gen() {
('a' as u8 + rng.gen::<u8>() % 25) as char (b'a' + rng.gen::<u8>() % 25) as char
} else { } else {
('0' as u8 + rng.gen::<u8>() % 10) as char (b'0' + rng.gen::<u8>() % 10) as char
} }
}) })
.collect::<String>(), .collect::<String>(),

View file

@ -40,6 +40,7 @@ macro_rules! maybe_main {
fn xous_entry() -> !; fn xous_entry() -> !;
} }
fn main() { fn main() {
xous::arch::ensure_connection().unwrap();
unsafe { xous_entry() }; unsafe { xous_entry() };
} }
}; };

View file

@ -1,6 +1,6 @@
use std::{ use std::{
env, fs, env,
path::{Path, PathBuf}, path::{Path, PathBuf, MAIN_SEPARATOR},
process::Command, process::Command,
}; };
@ -34,6 +34,7 @@ fn try_main() -> Result<(), DynError> {
let task = env::args().nth(1); let task = env::args().nth(1);
match task.as_deref() { match task.as_deref() {
Some("renode-image") => image()?, Some("renode-image") => image()?,
Some("run") => run()?,
_ => print_help(), _ => print_help(),
} }
Ok(()) Ok(())
@ -49,29 +50,86 @@ renode-image builds a test image for renode
fn image() -> Result<(), DynError> { fn image() -> Result<(), DynError> {
let debug = false; let debug = false;
// let _ = fs::remove_dir_all(&dist_dir());
// fs::create_dir_all(&dist_dir())?;
let kernel = build_kernel(debug)?; let kernel = build_kernel(debug)?;
let mut init = vec![]; let mut init = vec![];
for pkg in &["log-server", "graphics-server"] { for pkg in &["log-server", "graphics-server"] {
init.push(build(pkg, debug, None)?); init.push(build(pkg, debug, Some(TARGET), None)?);
} }
build("loader", false, Some("loader".into()))?; build("loader", false, Some(TARGET), Some("loader".into()))?;
create_image(&kernel, &init, debug)?; create_image(&kernel, &init, debug)?;
Ok(()) Ok(())
} }
fn build_kernel(debug: bool) -> Result<PathBuf, DynError> { fn run() -> Result<(), DynError> {
build("kernel", debug, Some("kernel".into())) let debug = false;
let stream = if debug { "debug" } else { "release" };
let init = ["shell", "log-server", "graphics-server"];
// let mut init_paths = vec![];
for pkg in &init {
build(pkg, debug, None, None)?;
}
// println!("Built packages: {:?}", init_paths);
// Build and run the kernel
let mut args = vec!["run"];
if !debug {
args.push("--release");
}
args.push("--");
let mut paths = vec![];
for i in &init {
let tmp: PathBuf = Path::new(&format!(
"..{}target{}{}{}{}",
MAIN_SEPARATOR, MAIN_SEPARATOR, stream, MAIN_SEPARATOR, i
))
.to_owned();
// .canonicalize()
// .or(Err(BuildError::PathConversionError))?;
paths.push(tmp);
}
for t in &paths {
args.push(t.to_str().ok_or(BuildError::PathConversionError)?);
}
let mut dir = project_root();
dir.push("kernel");
let status = Command::new(cargo())
.current_dir(dir)
.args(&args)
.status()?;
if !status.success() {
return Err("cargo build failed".into());
}
Ok(())
} }
fn build(project: &str, debug: bool, directory: Option<PathBuf>) -> Result<PathBuf, DynError> { fn build_kernel(debug: bool) -> Result<PathBuf, DynError> {
build("kernel", debug, Some(TARGET), Some("kernel".into()))
}
fn build(
project: &str,
debug: bool,
target: Option<&str>,
directory: Option<PathBuf>,
) -> Result<PathBuf, DynError> {
println!("Building {}...", project); println!("Building {}...", project);
let stream = if debug { "debug" } else { "release" }; let stream = if debug { "debug" } else { "release" };
let mut args = vec!["build", "--target", TARGET, "--package", project]; let mut args = vec!["build", "--package", project];
let mut target_path = "".to_owned();
if let Some(t) = target {
args.push("--target");
args.push(t);
target_path = format!("{}/", t);
}
if !debug { if !debug {
args.push("--release"); args.push("--release");
} }
@ -92,14 +150,14 @@ fn build(project: &str, debug: bool, directory: Option<PathBuf>) -> Result<PathB
if let Some(base_dir) = &directory { if let Some(base_dir) = &directory {
Ok(project_root().join(&format!( Ok(project_root().join(&format!(
"{}/target/{}/{}/{}", "{}/target/{}{}/{}",
base_dir.to_str().ok_or(BuildError::PathConversionError)?, base_dir.to_str().ok_or(BuildError::PathConversionError)?,
TARGET, target_path,
stream, stream,
project project
))) )))
} else { } else {
Ok(project_root().join(&format!("target/{}/{}/{}", TARGET, stream, project))) Ok(project_root().join(&format!("target/{}{}/{}", target_path, stream, project)))
} }
} }