kernel: compatibility with riscv32imac-unknown-xous-elf

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2021-08-18 18:14:24 +08:00
parent 3c10127ed4
commit 19653e9c53
17 changed files with 219 additions and 172 deletions

View file

@ -5,6 +5,7 @@ $crate = "xous-kernel"
riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32imac src/asm.S -o bin/$crate.o
riscv64-unknown-elf-ar crs bin/riscv32imac-unknown-none-elf.a bin/$crate.o
riscv64-unknown-elf-ar crs bin/riscv32imac-unknown-xous-elf.a bin/$crate.o
riscv64-unknown-elf-ar crs bin/riscv32imc-unknown-none-elf.a bin/$crate.o
riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32i src/asm.S -DSKIP_MULTICORE -o bin/$crate.o

View file

@ -14,6 +14,7 @@ rm -f bin/*.a
riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32imac src/asm.S -o bin/$crate.o
ar crs bin/riscv32imac-unknown-none-elf.a bin/$crate.o
ar crs bin/riscv32imac-unknown-xous-elf.a bin/$crate.o
ar crs bin/riscv32imc-unknown-none-elf.a bin/$crate.o
riscv64-unknown-elf-gcc -ggdb3 -c -mabi=ilp32 -march=rv32i src/asm.S -DSKIP_MULTICORE -o bin/$crate.o

Binary file not shown.

View file

@ -17,7 +17,7 @@ fn main() {
// If we're not running on a desktop-class operating system, emit the "baremetal"
// config setting. This will enable software to do tasks such as
// managing memory.
if target_os == "none" {
if target_os == "none" || target_os == "xous" {
println!("Target {} is bare metal", target);
println!("cargo:rustc-cfg=baremetal");
} else {

View file

@ -69,6 +69,7 @@ SECTIONS
/DISCARD/ :
{
*(.eh_frame);
*(.eh_frame_hdr);
}
}

View file

@ -85,22 +85,25 @@ fn handle_connection(
chn: Sender<ThreadMessage>,
should_exit: std::sync::Arc<core::sync::atomic::AtomicBool>,
) {
enum ServerMessage {
Exit,
ServerPacket([usize; 9]),
ServerPacketWithData([usize; 9], Vec<u8>),
}
// enum ServerMessage {
// Exit,
// ServerPacket(Box<SysCall>),
// ServerPacketWithData([usize; 9], Vec<u8>),
// }
fn conn_thread(mut conn: TcpStream, sender: Sender<ServerMessage>, _pid: PID) {
fn conn_thread(mut conn: TcpStream, sender: Sender<ThreadMessage>, pid: PID) {
loop {
let mut raw_data = [0u8; 9 * std::mem::size_of::<usize>()];
// Read bytes from the connection. This will fail when the connection closes,
// so send a `Termination` message across the channel.
if let Err(_e) = conn.read_exact(&mut raw_data) {
#[cfg(not(test))]
eprintln!(
"KERNEL({}): client disconnected: {} -- shutting down virtual process",
_pid, _e
pid, _e
);
sender.send(ServerMessage::Exit).ok();
// sender.send(ServerMessage::Exit).ok();
return;
}
@ -111,40 +114,68 @@ fn handle_connection(
{
*word = usize::from_le_bytes(bytes.try_into().unwrap());
}
let thread_id = packet_data[0] as TID;
let mut call = match crate::SysCall::from_args(
packet_data[1],
packet_data[2],
packet_data[3],
packet_data[4],
packet_data[5],
packet_data[6],
packet_data[7],
packet_data[8],
) {
Ok(call) => call,
Err(e) => {
eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e);
eprintln!(
"Raw packet: {:08x} {} {} {} {} {} {} {}",
packet_data[0],
packet_data[1],
packet_data[2],
packet_data[3],
packet_data[4],
packet_data[5],
packet_data[6],
packet_data[7]
);
continue;
}
};
if let Some(mem) = unsafe { call.memory_mut() } {
let mut data = vec![0u8; mem.len()];
if conn.read_exact(&mut data).is_err() {
return;
}
let sliced_data = data.into_boxed_slice();
assert_eq!(
sliced_data.len(),
mem.len(),
"deconstructed data {} != message buf length {}",
sliced_data.len(),
mem.len()
);
*mem = unsafe {
xous_kernel::MemoryRange::new(
Box::into_raw(sliced_data) as *mut u8 as usize,
mem.len(),
)
.unwrap()
};
}
sender
.send(
if (packet_data[1] == xous_kernel::syscall::SysCallNumber::SendMessage as _
|| packet_data[1]
== xous_kernel::syscall::SysCallNumber::TrySendMessage as _)
&& (packet_data[3] == 1 || packet_data[3] == 2 || packet_data[3] == 3)
{
let mut v = vec![0; packet_data[6]];
if conn.read_exact(&mut v).is_err() {
sender.send(ServerMessage::Exit).ok();
return;
}
ServerMessage::ServerPacketWithData(packet_data, v)
} else if packet_data[1]
== xous_kernel::syscall::SysCallNumber::ReturnMemory as _
{
let mut v = vec![0; packet_data[4]];
if conn.read_exact(&mut v).is_err() {
sender.send(ServerMessage::Exit).ok();
return;
}
ServerMessage::ServerPacketWithData(packet_data, v)
} else {
ServerMessage::ServerPacket(packet_data)
},
)
.send(ThreadMessage::SysCall(pid, thread_id, call))
.unwrap();
}
}
let (sender, receiver) = unbounded();
let conn_sender = sender.clone();
std::thread::Builder::new()
// let (sender, receiver) = unbounded();
// let conn_sender = sender.clone();
let conn_sender = chn.clone();
let conn_thread = std::thread::Builder::new()
.name(format!("PID {}: client connection thread", pid))
.spawn(move || {
conn_thread(conn, conn_sender, pid);
@ -155,122 +186,124 @@ fn handle_connection(
.name(format!("PID {}: client should_exit thread", pid))
.spawn(move || loop {
if should_exit.load(core::sync::atomic::Ordering::Relaxed) {
// eprintln!("KERNEL: should_exit == 1");
sender.send(ServerMessage::Exit).ok();
eprintln!("KERNEL: should_exit == 1");
// sender.send(ServerMessage::Exit).ok();
// WARNING: This functionality is unimplemented right now
return;
}
std::thread::park_timeout(std::time::Duration::from_secs(1));
})
.unwrap();
for msg in receiver {
match msg {
ServerMessage::Exit => {
#[cfg(not(test))]
eprintln!("KERNEL({}): Received ServerMessage::Exit", pid);
break;
}
ServerMessage::ServerPacket(pkt) => {
let thread_id = pkt[0];
let call = xous_kernel::SysCall::from_args(
pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8],
);
match call {
Err(e) => {
eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e);
eprintln!(
"Raw packet: {:08x} {} {} {} {} {} {} {}",
pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7]
);
}
Ok(call) => chn
.send(ThreadMessage::SysCall(pid, thread_id, call))
.expect("couldn't make syscall"),
}
}
ServerMessage::ServerPacketWithData(pkt, data) => {
let thread_id = pkt[0];
let call = xous_kernel::SysCall::from_args(
pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8],
);
match call {
Err(e) => {
eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e);
eprintln!(
"Raw packet: {:08x} {} {} {} {} {} {} {}",
pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7]
);
}
Ok(mut call) => {
// eprintln!(
// "Received packet: {:08x} {} {} {} {} {} {} {}: {:?}",
// pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], call
// );
match call {
SysCall::SendMessage(ref _cid, ref mut envelope)
| SysCall::TrySendMessage(ref _cid, ref mut envelope) => {
match envelope {
xous_kernel::Message::MutableBorrow(msg)
| xous_kernel::Message::Borrow(msg)
| xous_kernel::Message::Move(msg) => {
// Update the address pointer. This will get turned back into a
// usable pointer by casting it back into a &[T] on the other
// side. This is just a pointer to the start of data
// as well as the index into the data it points at. The lengths
// should still be equal once we reconstitute the data in the
// other process.
// ::debug_here::debug_here!();
let sliced_data = data.into_boxed_slice();
assert_eq!(
sliced_data.len(),
msg.buf.len(),
"deconstructed data {} != message buf length {}",
sliced_data.len(),
msg.buf.len()
);
msg.buf = unsafe {
xous_kernel::MemoryRange::new(
Box::into_raw(sliced_data) as *mut u8 as usize,
msg.buf.len(),
)
.unwrap()
};
}
xous_kernel::Message::Scalar(_)
| xous_kernel::Message::BlockingScalar(_) => (),
}
}
SysCall::ReturnMemory(
ref _sender,
ref mut buf,
ref _offset,
ref _valid,
) => {
let sliced_data = data.into_boxed_slice();
assert_eq!(
sliced_data.len(),
buf.len(),
"deconstructed data {} != message buf length {}",
sliced_data.len(),
buf.len()
);
*buf = unsafe {
xous_kernel::MemoryRange::new(
Box::into_raw(sliced_data) as *mut u8 as usize,
buf.len(),
)
.unwrap()
};
}
_ => panic!("unsupported message type"),
}
chn.send(ThreadMessage::SysCall(pid, thread_id, call))
.expect("couldn't make syscall");
}
}
}
}
}
// for msg in receiver {
// match msg {
// ServerMessage::Exit => {
// #[cfg(not(test))]
// eprintln!("KERNEL({}): Received ServerMessage::Exit", pid);
// break;
// }
// ServerMessage::ServerPacket(pkt) => {
// let thread_id = pkt[0];
// let call = xous_kernel::SysCall::from_args(
// pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8],
// );
// match call {
// Err(e) => {
// eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e);
// eprintln!(
// "Raw packet: {:08x} {} {} {} {} {} {} {}",
// pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7]
// );
// }
// Ok(call) => chn
// .send(ThreadMessage::SysCall(pid, thread_id, call))
// .expect("couldn't make syscall"),
// }
// }
// ServerMessage::ServerPacketWithData(pkt, data) => {
// let thread_id = pkt[0];
// let call = xous_kernel::SysCall::from_args(
// pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8],
// );
// match call {
// Err(e) => {
// eprintln!("KERNEL({}): Received invalid syscall: {:?}", pid, e);
// eprintln!(
// "Raw packet: {:08x} {} {} {} {} {} {} {}",
// pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7]
// );
// }
// Ok(mut call) => {
// // eprintln!(
// // "Received packet: {:08x} {} {} {} {} {} {} {}: {:?}",
// // pkt[0], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], call
// // );
// match call {
// SysCall::SendMessage(ref _cid, ref mut envelope)
// | SysCall::TrySendMessage(ref _cid, ref mut envelope) => {
// match envelope {
// xous_kernel::Message::MutableBorrow(msg)
// | xous_kernel::Message::Borrow(msg)
// | xous_kernel::Message::Move(msg) => {
// // Update the address pointer. This will get turned back into a
// // usable pointer by casting it back into a &[T] on the other
// // side. This is just a pointer to the start of data
// // as well as the index into the data it points at. The lengths
// // should still be equal once we reconstitute the data in the
// // other process.
// // ::debug_here::debug_here!();
// let sliced_data = data.into_boxed_slice();
// assert_eq!(
// sliced_data.len(),
// msg.buf.len(),
// "deconstructed data {} != message buf length {}",
// sliced_data.len(),
// msg.buf.len()
// );
// msg.buf = unsafe {
// xous_kernel::MemoryRange::new(
// Box::into_raw(sliced_data) as *mut u8 as usize,
// msg.buf.len(),
// )
// .unwrap()
// };
// }
// xous_kernel::Message::Scalar(_)
// | xous_kernel::Message::BlockingScalar(_) => (),
// }
// }
// SysCall::ReturnMemory(
// ref _sender,
// ref mut buf,
// ref _offset,
// ref _valid,
// ) => {
// let sliced_data = data.into_boxed_slice();
// assert_eq!(
// sliced_data.len(),
// buf.len(),
// "deconstructed data {} != message buf length {}",
// sliced_data.len(),
// buf.len()
// );
// *buf = unsafe {
// xous_kernel::MemoryRange::new(
// Box::into_raw(sliced_data) as *mut u8 as usize,
// buf.len(),
// )
// .unwrap()
// };
// }
// _ => panic!("unsupported message type"),
// }
// chn.send(ThreadMessage::SysCall(pid, thread_id, call))
// .expect("couldn't make syscall");
// }
// }
// }
// }
// }
conn_thread.join().unwrap();
#[cfg(not(test))]
eprintln!(
"KERNEL({}): Finished the thread so sending TerminateProcess",
@ -535,6 +568,7 @@ pub fn idle() -> bool {
}
}
ThreadMessage::SysCall(pid, thread_id, call) => {
// let measurement_start = std::time::Instant::now();
// println!("KERNEL({}): Received syscall {:?}", pid, call);
crate::arch::process::set_current_pid(pid);
// println!("KERNEL({}): Now running as the new process", pid);
@ -607,6 +641,12 @@ pub fn idle() -> bool {
.ok();
});
crate::arch::process::set_current_pid(existing_pid);
// println!(
// "KERNEL [{:2}:{:2}] Syscall took {:7} usec",
// pid,
// thread_id,
// measurement_start.elapsed().as_micros()
// );
}
if is_shutdown {

View file

@ -391,7 +391,7 @@ impl Process {
let process = &mut process_table.table[current_pid_idx].as_mut().unwrap();
let conn = process.conn.as_mut().unwrap();
conn.write_all(bytes).unwrap();
conn.flush().unwrap();
// conn.flush().unwrap();
});
Ok(())
}

View file

@ -3,7 +3,7 @@
#[cfg(baremetal)]
use core::fmt::{Error, Write};
#[cfg(target_os = "none")]
#[cfg(baremetal)]
use utralib::generated::*;
#[cfg(baremetal)]
@ -12,7 +12,7 @@ pub static mut DEBUG_OUTPUT: Option<&'static mut dyn Write> = None;
#[macro_use]
#[cfg(all(
not(test),
target_os = "none",
baremetal,
any(feature = "debug-print", feature = "print-panics")
))]
pub mod debug_print_hardware {
@ -21,12 +21,12 @@ pub mod debug_print_hardware {
}
#[cfg(all(
not(test),
target_os = "none",
baremetal,
any(feature = "debug-print", feature = "print-panics")
))]
pub use crate::debug::debug_print_hardware::SUPERVISOR_UART_ADDR;
#[cfg(all(target_os = "none"))]
#[cfg(baremetal)]
#[macro_export]
macro_rules! print {
($($args:tt)+) => {{
@ -39,7 +39,7 @@ macro_rules! print {
}};
}
#[cfg(target_os = "none")]
#[cfg(baremetal)]
#[macro_export]
macro_rules! println
{
@ -54,15 +54,15 @@ macro_rules! println
});
}
#[cfg(target_os = "none")]
#[cfg(baremetal)]
pub struct Uart {}
#[cfg(target_os = "none")]
#[cfg(baremetal)]
pub static mut UART: Uart = Uart {};
#[cfg(all(target_os = "none", feature = "wrap-print"))]
static mut CHAR_COUNT: usize = 0;
#[cfg(target_os = "none")]
#[cfg(baremetal)]
impl Uart {
#[allow(dead_code)]
pub fn init(self) {
@ -117,10 +117,10 @@ impl Uart {
}
}
#[cfg(all(feature = "gdbserver", target_os = "none"))]
#[cfg(all(feature = "gdbserver", baremetal))]
mod gdb_server;
#[cfg(all(feature = "gdbserver", target_os = "none"))]
#[cfg(all(feature = "gdbserver", baremetal))]
impl gdbstub::Connection for Uart {
type Error = ();
@ -144,7 +144,7 @@ impl gdbstub::Connection for Uart {
#[cfg(all(
not(test),
target_os = "none",
baremetal,
any(feature = "debug-print", feature = "print-panics")
))]
pub fn irq(_irq_number: usize, _arg: *mut usize) {
@ -157,11 +157,11 @@ pub fn irq(_irq_number: usize, _arg: *mut usize) {
#[cfg(all(
not(test),
target_os = "none",
baremetal,
any(feature = "debug-print", feature = "print-panics")
))]
fn process_irq_character(b: u8) {
#[cfg(all(feature = "gdbserver", target_os = "none"))]
#[cfg(all(feature = "gdbserver", baremetal))]
if gdb_server::handle(b) {
return;
}
@ -257,7 +257,7 @@ fn process_irq_character(b: u8) {
});
println!("{} k total", total_bytes / 1024);
}
#[cfg(all(feature = "gdbserver", target_os = "none"))]
#[cfg(all(feature = "gdbserver", baremetal))]
b'g' => {
println!("Starting GDB server -- attach your debugger now");
gdb_server::setup();
@ -277,7 +277,7 @@ fn process_irq_character(b: u8) {
}
}
#[cfg(target_os = "none")]
#[cfg(baremetal)]
impl Write for Uart {
fn write_str(&mut self, s: &str) -> Result<(), Error> {
for c in s.bytes() {

View file

@ -4,7 +4,7 @@
#![cfg_attr(baremetal, no_main)]
#![cfg_attr(baremetal, no_std)]
#[cfg(target_os = "none")]
#[cfg(baremetal)]
#[macro_use]
extern crate bitflags;
@ -28,9 +28,9 @@ mod syscall;
use services::SystemServices;
use xous_kernel::*;
#[cfg(target_os = "none")]
#[cfg(baremetal)]
use core::panic::PanicInfo;
#[cfg(target_os = "none")]
#[cfg(baremetal)]
#[panic_handler]
fn handle_panic(_arg: &PanicInfo) -> ! {
println!("PANIC in PID {}: {}", crate::arch::current_pid(), _arg);
@ -150,7 +150,7 @@ pub extern "C" fn kmain() {
// Note that at this point, no new direct children of INIT may be created.
let mut pid = None;
#[cfg(not(any(target_os = "none", all(ci, test))))]
#[cfg(not(any(target_os = "none", target_os = "xous", all(ci, test))))]
{
use std::panic;
panic::set_hook(Box::new(|arg| {

View file

@ -1914,7 +1914,7 @@ impl SystemServices {
/// within the current process.
pub fn sidx_from_cid(&self, cid: CID) -> Option<usize> {
// println!("KERNEL({}): Attempting to get SIDX from CID {}", crate::arch::process::current_pid(), cid);
if cid == 0 || cid == 1 {
if cid < 2 {
return None;
}
@ -1930,8 +1930,9 @@ impl SystemServices {
// println!("KERNEL({}): CID {} doesn't exist in the connection map", crate::arch::process::current_pid(), cid + 2);
// println!("KERNEL({}): Process inner is: {:?}", crate::arch::process::current_pid(), process_inner);
// }
let mut server_idx = process_inner.connection_map[cid as usize]?.get() as usize;
if server_idx == 1 {
let connection_value = *process_inner.connection_map.get(cid as usize)?;
let mut server_idx = connection_value?.get() as usize;
if server_idx < 2 {
// println!("KERNEL({}): CID {} is no longer valid", crate::arch::process::current_pid(), cid + 2);
return None;
}

View file

@ -600,7 +600,8 @@ fn receive_message(pid: PID, tid: TID, sid: SID, blocking: ExecutionType) -> Sys
pub fn handle(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallResult {
#[cfg(feature = "debug-print")]
print!("KERNEL({}:{}): Syscall {:x?}", pid, tid, call);
// let call_string = format!("{:x?}", call);
// let start_time = std::time::Instant::now();
#[allow(clippy::let_and_return)]
let result = if in_irq && !call.can_call_from_interrupt() {
Err(xous_kernel::Error::InvalidSyscall)
@ -608,6 +609,8 @@ pub fn handle(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallResult
handle_inner(pid, tid, in_irq, call)
};
// println!("KERNEL [{:2}:{:2}] Syscall took {:7} usec: {}", pid, tid, start_time.elapsed().as_micros(), call_string);
#[cfg(feature = "debug-print")]
println!(
" -> ({}:{}) {:x?}",

View file

@ -1,3 +1,3 @@
#![cfg_attr(target_os = "none", no_std)]
#![cfg_attr(any(target_os = "none", target_os = "xous"), no_std)]
pub mod generated;
pub use generated::*;