From 19653e9c536c5b6e0f6cc695d72b740f8bb5d219 Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Wed, 18 Aug 2021 18:14:24 +0800 Subject: [PATCH] kernel: compatibility with `riscv32imac-unknown-xous-elf` Signed-off-by: Sean Cross --- kernel/assemble.ps1 | 1 + kernel/assemble.sh | 1 + kernel/bin/riscv32i-unknown-none-elf.a | Bin 9078 -> 9062 bytes kernel/bin/riscv32imac-unknown-none-elf.a | Bin 8886 -> 8870 bytes kernel/bin/riscv32imac-unknown-xous-elf.a | Bin 0 -> 8870 bytes kernel/bin/riscv32imc-unknown-none-elf.a | Bin 8886 -> 8870 bytes kernel/bin/riscv64gc-unknown-none-elf.a | Bin 14254 -> 14238 bytes kernel/bin/riscv64imac-unknown-none-elf.a | Bin 14254 -> 14238 bytes kernel/build.rs | 2 +- kernel/link.x | 1 + kernel/src/arch/hosted/mod.rs | 332 ++++++++++++---------- kernel/src/arch/hosted/process.rs | 2 +- kernel/src/debug/mod.rs | 30 +- kernel/src/main.rs | 8 +- kernel/src/services.rs | 7 +- kernel/src/syscall.rs | 5 +- kernel/utralib/src/lib.rs | 2 +- 17 files changed, 219 insertions(+), 172 deletions(-) create mode 100644 kernel/bin/riscv32imac-unknown-xous-elf.a diff --git a/kernel/assemble.ps1 b/kernel/assemble.ps1 index b0295d439..a56afbec4 100644 --- a/kernel/assemble.ps1 +++ b/kernel/assemble.ps1 @@ -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 diff --git a/kernel/assemble.sh b/kernel/assemble.sh index 773c791a9..28c5ccc25 100755 --- a/kernel/assemble.sh +++ b/kernel/assemble.sh @@ -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 diff --git a/kernel/bin/riscv32i-unknown-none-elf.a b/kernel/bin/riscv32i-unknown-none-elf.a index 78f087d64a5d653b8fd10b7d97268a8a8034e97c..bc88a1f90b914febb384ac02b03e013226dc04e9 100644 GIT binary patch delta 188 zcmez7_RMX91ec+ik)@HjsiB3zM5P%j2%dt1fdU9XNJ9eyGcz*<1q%yfqlx!47zH-7 zGah7BakYwZ&QD2=iO4T42C|A$W3p3=@=|jc-2Flo9D@~%^o)%*|6wcQWK`aqFOV<5 zC@}fHfH>`jd;5lo>fDPghcBRGGXVNNP-e4kTSB S^DC<}woEn$k|C4hmBj%Hd^FJj delta 204 zcmaFn_RVdA1ebvV3`|s-p@QHkC_vZ{(#*sJtjxl~#A4z-4Mv5{?2HFlP4qMJb5r$` zO7rqEQ}vVcQ&ROS@=J?#lk##L(GAeIg&z~>A z7%*90!Jl!@C@{HQQJYbJ@@7S4MvKYU71bG2CjSSL5tG%G)EQeQ R`vb`%lgokRl*#jz!~w^fHPHY7 delta 204 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 R`vb`%lgokRl*#jz!~w^fHPHY7 delta 204 zcmZ4Hy3KWh1ebvV3`|s-p@QHkC_vZ{(#*sJtjxm9)NJBC4aS7c?2I2-O!PDIb5r$` zO7rqEQ}vVcQ&ROS@=J?#lkbY9QIOnIN#zf?o76VyDsWI89MR}^U#6GJt{Rc2TS&&V5^C^)va!d?jlPiqt7;jAeZd}j!VRE?%i2QD{pRr-`c2jpo%gO&u&6yUk zPA)JKo7`tAFgealf>C2~xtTrZ16GLfnv?e%$xprq6c?EM-OQe`V6wTnJ!gjjM0Phw F7680FOmhGL diff --git a/kernel/bin/riscv64imac-unknown-none-elf.a b/kernel/bin/riscv64imac-unknown-none-elf.a index dc4ff04e8af6297030309b6c9ba5459d53325422..3e38f01244b5d726bf2538c7506fead82643a4bb 100644 GIT binary patch delta 236 zcmZ3NKQDiR1ec+ik)@HjsiB3zM5P(32%dt1fdU9XNJ9eyGcz*<1w#`91B;3G^%*TT z^D{cK>bY9QIOnIN#zf?o76VyDsWI89MR}^U#6GJt{Rc2TS&&V5^C^)va!d?jlPiqt7;jAeZd}j!VRE?%i2QD{pRr-`c2jpo%gO&u&6yUk zPA)JKo7`tAFgealf>C2~xtTrZ16GLfnv?e%$xprq6c?EM-OQe`V6wTnJ!gjjM0Phw F7680FOmhGL diff --git a/kernel/build.rs b/kernel/build.rs index 7b30e8adf..fa21b2647 100644 --- a/kernel/build.rs +++ b/kernel/build.rs @@ -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 { diff --git a/kernel/link.x b/kernel/link.x index 8848cfb5d..0028887c0 100644 --- a/kernel/link.x +++ b/kernel/link.x @@ -69,6 +69,7 @@ SECTIONS /DISCARD/ : { *(.eh_frame); + *(.eh_frame_hdr); } } diff --git a/kernel/src/arch/hosted/mod.rs b/kernel/src/arch/hosted/mod.rs index 79ca7526e..833070905 100644 --- a/kernel/src/arch/hosted/mod.rs +++ b/kernel/src/arch/hosted/mod.rs @@ -85,22 +85,25 @@ fn handle_connection( chn: Sender, should_exit: std::sync::Arc, ) { - enum ServerMessage { - Exit, - ServerPacket([usize; 9]), - ServerPacketWithData([usize; 9], Vec), - } + // enum ServerMessage { + // Exit, + // ServerPacket(Box), + // ServerPacketWithData([usize; 9], Vec), + // } - fn conn_thread(mut conn: TcpStream, sender: Sender, _pid: PID) { + fn conn_thread(mut conn: TcpStream, sender: Sender, pid: PID) { loop { let mut raw_data = [0u8; 9 * std::mem::size_of::()]; + + // 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 { diff --git a/kernel/src/arch/hosted/process.rs b/kernel/src/arch/hosted/process.rs index 7c0aff16e..f41c66d7c 100644 --- a/kernel/src/arch/hosted/process.rs +++ b/kernel/src/arch/hosted/process.rs @@ -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(()) } diff --git a/kernel/src/debug/mod.rs b/kernel/src/debug/mod.rs index a6eaf3f3c..a63e65bca 100644 --- a/kernel/src/debug/mod.rs +++ b/kernel/src/debug/mod.rs @@ -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() { diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 27cb11d94..226690ba5 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -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| { diff --git a/kernel/src/services.rs b/kernel/src/services.rs index f234f9311..d38d6e120 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -1914,7 +1914,7 @@ impl SystemServices { /// within the current process. pub fn sidx_from_cid(&self, cid: CID) -> Option { // 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; } diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 3a99101e9..0646183a3 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -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?}", diff --git a/kernel/utralib/src/lib.rs b/kernel/utralib/src/lib.rs index 6cf78339f..24d4bdeb5 100644 --- a/kernel/utralib/src/lib.rs +++ b/kernel/utralib/src/lib.rs @@ -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::*;