kernel: start using tls

This allows us to run multiple kernels in parallel.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-06-24 17:51:31 +08:00
parent abcba48a2a
commit 54a0db50b3
7 changed files with 116 additions and 113 deletions

View file

@ -3,12 +3,14 @@ pub mod mem;
pub mod process; pub mod process;
pub mod syscall; pub mod syscall;
use std::cell::RefCell;
use std::env; use std::env;
use std::io::Read; use std::io::Read;
use std::mem::size_of; use std::mem::size_of;
use std::net::{TcpListener, TcpStream}; use std::net::{TcpListener, TcpStream};
use std::sync::mpsc::{channel, Receiver, Sender}; use std::sync::mpsc::{channel, Receiver, Sender};
use std::thread::spawn; use std::thread::spawn;
use std::thread_local;
use std::time::Duration; use std::time::Duration;
use xous::{Result, SysCall, PID}; use xous::{Result, SysCall, PID};
@ -16,16 +18,24 @@ use xous::{Result, SysCall, PID};
use crate::arch::process::ProcessHandle; use crate::arch::process::ProcessHandle;
use crate::services::SystemServicesHandle; use crate::services::SystemServicesHandle;
pub type KernelArguments = Option<String>;
const DEFAULT_LISTEN_ADDRESS: &str = "localhost:9687"; const DEFAULT_LISTEN_ADDRESS: &str = "localhost:9687";
thread_local!(static NETWORK_LISTEN_ADDRESS: RefCell<String> = RefCell::new(DEFAULT_LISTEN_ADDRESS.to_owned()));
/// Set the network address for this particular thread.
pub fn set_listen_address(new_address: &str) {
NETWORK_LISTEN_ADDRESS.with(|nla| {
let mut address = nla.borrow_mut();
*address = new_address.to_owned();
});
}
/// Each client gets its own connection and its own thread, which is handled here. /// Each client gets its own connection and its own thread, which is handled here.
fn handle_connection(mut conn: TcpStream, pid: PID, chn: Sender<(PID, SysCall)>) { fn handle_connection(mut conn: TcpStream, pid: PID, chn: Sender<(PID, SysCall)>) {
loop { loop {
let mut pkt = [0usize; 8]; let mut pkt = [0usize; 8];
let mut incoming_word = [0u8; size_of::<usize>()]; let mut incoming_word = [0u8; size_of::<usize>()];
conn.set_nonblocking(true).expect("couldn't enable nonblocking mode"); conn.set_nonblocking(true)
.expect("couldn't enable nonblocking mode");
for word in pkt.iter_mut() { for word in pkt.iter_mut() {
loop { loop {
if let Err(e) = conn.read_exact(&mut incoming_word) { if let Err(e) = conn.read_exact(&mut incoming_word) {
@ -60,10 +70,7 @@ fn handle_connection(mut conn: TcpStream, pid: PID, chn: Sender<(PID, SysCall)>)
} }
} }
fn listen_thread(address: Option<String>, chn: Sender<(PID, SysCall)>, quit: Receiver<()>) { fn listen_thread(listen_addr: String, chn: Sender<(PID, SysCall)>, quit: Receiver<()>) {
let listen_addr = address.unwrap_or_else(|| {
env::var("XOUS_LISTEN_ADDR").unwrap_or_else(|_| DEFAULT_LISTEN_ADDRESS.to_owned())
});
println!("Starting Xous server on {}...", listen_addr); println!("Starting Xous server on {}...", listen_addr);
let listener = TcpListener::bind(listen_addr).unwrap_or_else(|e| { let listener = TcpListener::bind(listen_addr).unwrap_or_else(|e| {
panic!("Unable to create server: {}", e); panic!("Unable to create server: {}", e);
@ -85,7 +92,10 @@ fn listen_thread(address: Option<String>, chn: Sender<(PID, SysCall)>, quit: Rec
ss.spawn_process(process::ProcessInit::new(conn.try_clone().unwrap()), ()) ss.spawn_process(process::ProcessInit::new(conn.try_clone().unwrap()), ())
.unwrap() .unwrap()
}; };
println!("New client connected from {} and assigned PID {}", addr, new_pid); println!(
"New client connected from {} and assigned PID {}",
addr, new_pid
);
let conn_copy = conn.try_clone().expect("couldn't duplicate connection"); let conn_copy = conn.try_clone().expect("couldn't duplicate connection");
let jh = spawn(move || handle_connection(conn, new_pid, thr_chn)); let jh = spawn(move || handle_connection(conn, new_pid, thr_chn));
clients.push((jh, conn_copy)); clients.push((jh, conn_copy));
@ -95,10 +105,14 @@ fn listen_thread(address: Option<String>, chn: Sender<(PID, SysCall)>, quit: Rec
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => { Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
continue; continue;
} }
x => { _x => {
if let Err(e) = _x {
println!("Got error receiving quit timeout: {:?}", e);
}
for (jh, conn) in clients { for (jh, conn) in clients {
use std::net::Shutdown; use std::net::Shutdown;
conn.shutdown(Shutdown::Both).expect("couldn't shutdown client"); conn.shutdown(Shutdown::Both)
.expect("couldn't shutdown client");
jh.join().expect("couldn't join client thread"); jh.join().expect("couldn't join client thread");
} }
return; return;
@ -116,15 +130,18 @@ fn listen_thread(address: Option<String>, chn: Sender<(PID, SysCall)>, quit: Rec
/// The idle function is run when there are no directly-runnable processes /// The idle function is run when there are no directly-runnable processes
/// that kmain can activate. In a hosted environment,this is the primary /// that kmain can activate. In a hosted environment,this is the primary
/// thread that handles network communications, and this function never returns. /// thread that handles network communications, and this function never returns.
pub fn idle(args: &KernelArguments) -> bool { pub fn idle() -> bool {
// Start listening. // Start listening.
let (sender, receiver) = channel(); let (sender, receiver) = channel();
let (term_sender, term_receiver) = channel(); let (term_sender, term_receiver) = channel();
let server_addr = args.clone(); let listen_addr = env::var("XOUS_LISTEN_ADDR")
let listen_thread_handle = spawn(move || listen_thread(server_addr, sender, term_receiver)); .unwrap_or_else(|_| NETWORK_LISTEN_ADDRESS.with(|nla| nla.borrow().clone()));
let listen_thread_handle = spawn(move || listen_thread(listen_addr, sender, term_receiver));
while let Ok((pid, call)) = receiver.recv() { while let Ok((pid, call)) = receiver.recv() {
println!("Received message from PID {}: {:?}", pid, call);
{ {
let mut ss = SystemServicesHandle::get(); let mut ss = SystemServicesHandle::get();
ss.switch_to(pid, Some(1)).unwrap(); ss.switch_to(pid, Some(1)).unwrap();
@ -138,9 +155,10 @@ pub fn idle(args: &KernelArguments) -> bool {
// Handle the syscall within the Xous kernel // Handle the syscall within the Xous kernel
let response = crate::syscall::handle(pid, call).unwrap_or_else(Result::Error); let response = crate::syscall::handle(pid, call).unwrap_or_else(Result::Error);
println!("KERNEL: Response to PID {}: {:?}", pid, response);
// There's a response if it wasn't a blocked process and we're not terminating. // There's a response if it wasn't a blocked process and we're not terminating.
// Send the response back to the target. // Send the response back to the target.
if response != Result::BlockedProcess && !is_terminate && !is_shutdown{ if response != Result::BlockedProcess && !is_terminate && !is_shutdown {
{ {
let mut processes = ProcessHandle::get(); let mut processes = ProcessHandle::get();
let mut response_vec = Vec::new(); let mut response_vec = Vec::new();

View file

@ -126,7 +126,7 @@ fn next_pid_to_run(last_pid: Option<PID>) -> Option<PID> {
/// Common main function for baremetal and hosted environments. /// Common main function for baremetal and hosted environments.
#[no_mangle] #[no_mangle]
pub extern "C" fn kmain(args: crate::arch::KernelArguments) { pub extern "C" fn kmain() {
// Start performing round-robin on all child processes. // Start performing round-robin on all child processes.
// Note that at this point, no new direct children of INIT may be created. // Note that at this point, no new direct children of INIT may be created.
@ -144,7 +144,7 @@ pub extern "C" fn kmain(args: crate::arch::KernelArguments) {
None => { None => {
println!("No runnable tasks found. Entering idle state..."); println!("No runnable tasks found. Entering idle state...");
// Special case for testing: idle can return `false` to indicate exit // Special case for testing: idle can return `false` to indicate exit
if ! arch::idle(&args) { if ! arch::idle() {
return; return;
} }
} }
@ -156,5 +156,5 @@ pub extern "C" fn kmain(args: crate::arch::KernelArguments) {
/// this function does not exist. /// this function does not exist.
#[cfg(not(baremetal))] #[cfg(not(baremetal))]
fn main() { fn main() {
kmain(None); kmain();
} }

View file

@ -120,7 +120,7 @@ enum QueuedMessage {
} }
/// A pointer to resolve a server ID to a particular process /// A pointer to resolve a server ID to a particular process
#[derive(PartialEq)] #[derive(PartialEq, Debug)]
pub struct Server { pub struct Server {
/// A randomly-generated ID /// A randomly-generated ID
pub sid: SID, pub sid: SID,

View file

@ -1150,6 +1150,9 @@ impl SystemServices {
let mut slot_idx = None; let mut slot_idx = None;
let mut process = ProcessHandle::get(); let mut process = ProcessHandle::get();
println!("KERNEL: Connecting to server -- map: {:?}", process.inner.connection_map);
println!("KERNEL: All servers: {:?}", self.servers);
// Look through the connection map for (1) a free slot, and (2) an // Look through the connection map for (1) a free slot, and (2) an
// existing connection // existing connection
for (idx, server_idx) in process.inner.connection_map.iter().enumerate() { for (idx, server_idx) in process.inner.connection_map.iter().enumerate() {
@ -1171,6 +1174,7 @@ impl SystemServices {
if let Some(allocated_server) = server { if let Some(allocated_server) = server {
if allocated_server.sid == sid { if allocated_server.sid == sid {
process.inner.connection_map[slot_idx] = idx as u8 + 2; process.inner.connection_map[slot_idx] = idx as u8 + 2;
println!("KERNEL: After connection, server map is: {:?}", process.inner.connection_map);
return Ok(idx + 1); return Ok(idx + 1);
} }
} }

View file

@ -3,7 +3,8 @@ use std::thread::spawn;
use std::net::{TcpStream, ToSocketAddrs}; use std::net::{TcpStream, ToSocketAddrs};
use std::time::Duration; use std::time::Duration;
use xous::{rsyscall_to, SysCall, Result}; use xous::{SysCall, rsyscall};
use std::sync::mpsc::channel;
mod shutdown; mod shutdown;
@ -15,17 +16,23 @@ fn shutdown() {
.expect("invalid server address") .expect("invalid server address")
.next() .next()
.expect("unable to resolve server address"); .expect("unable to resolve server address");
let server_spec = server_spec.to_owned();
// Launch the main thread // Launch the main thread
let main_thread = spawn(|| kmain(Some(server_spec))); let server_spec_server = server_spec.clone();
let main_thread = spawn(move || {
crate::arch::set_listen_address(&server_spec_server);
kmain()
});
// This is now the client.
xous::hosted::set_xous_address(&server_spec);
// Connect to server // Connect to server
for i in 1..11 { for i in 1..11 {
println!("Retrying connection {}/10", i); println!("Retrying connection {}/10", i);
let res = TcpStream::connect_timeout(&server_addr, Duration::from_millis(200)); let res = TcpStream::connect_timeout(&server_addr, Duration::from_millis(200));
if let Ok(mut stream) = res { if res.is_ok() {
let call_result = rsyscall_to(SysCall::Shutdown, &mut stream); let call_result = rsyscall(SysCall::Shutdown);
println!("Call result: {:?}", call_result); println!("Call result: {:?}", call_result);
break; break;
} }
@ -42,63 +49,59 @@ fn send_scalar_message() {
.expect("invalid server address") .expect("invalid server address")
.next() .next()
.expect("unable to resolve server address"); .expect("unable to resolve server address");
let server_spec = server_spec.to_owned();
// Launch the main thread // Launch the main thread
let main_thread = spawn(|| kmain(Some(server_spec))); let server_spec_server = server_spec.clone();
let main_thread = spawn(move || {
crate::arch::set_listen_address(&server_spec_server);
kmain()
});
// Connect to server. This first instance needs to make sure the kernel is listening. // Connect to server. This first instance needs to make sure the kernel is listening.
let mut server_conn = None; // let mut server_conn = None;
let mut connected = false;
for i in 1..11 { for i in 1..11 {
println!("Retrying connection {}/10", i); println!("Retrying connection {}/10", i);
let res = TcpStream::connect_timeout(&server_addr, Duration::from_millis(200)); let res = TcpStream::connect_timeout(&server_addr, Duration::from_millis(200));
if let Ok(stream) = res { if res.is_ok() {
server_conn = Some(stream); connected = true;
break; break;
} }
} }
// Convert the Option<conn> into conn // Convert the Option<conn> into conn
let mut server_conn = server_conn.expect("unable to connect to server"); assert!(connected, "unable to connect to server");
// The client instance should connect instantly. let xous_client_spec = server_spec.to_owned();
let mut client_conn = TcpStream::connect_timeout(&server_addr, Duration::from_millis(200)).expect("client couldn't connect"); let xous_server_spec = server_spec.to_owned();
xous::hosted::set_xous_address(server_spec);
let server_xous_addr = match rsyscall_to(SysCall::CreateServer(5), &mut server_conn).expect("couldn't create xous server") { let (server_addr_send, server_addr_recv) = channel();
Result::ServerID(sid) => sid,
x => panic!("unexpected syscall result: {:?}", x),
};
eprintln!("CLIENT: Connecting to server {:?}", server_xous_addr); let xous_server = spawn(move || {
let client_xous_conn = match rsyscall_to(SysCall::Connect(server_xous_addr), &mut client_conn) { xous::hosted::set_xous_address(&xous_client_spec);
Err(e) => panic!("unable to connect to xous server: {:?}", e), println!("SERVER: Creating server");
Ok(Result::ConnectionID(i)) => i, let sid = xous::create_server(0x7884_3123).expect("couldn't create test server");
Ok(o) => panic!("unexpected return value: {:?}", o), println!("SERVER: Now listening on {:?}", sid);
}; server_addr_send.send(sid).unwrap();
println!("SERVER: Listening for message...");
let msg = xous::receive_message(sid).expect("couldn't receive messages");
println!("SERVER: Received message: {:?}", msg);
});
eprintln!("CLIENT: Calling SendMessage..."); let xous_client = spawn(move || {
match rsyscall_to( xous::hosted::set_xous_address(&xous_server_spec);
SysCall::SendMessage(client_xous_conn, xous::Message::Scalar(xous::ScalarMessage { id: 1, arg1: 2, arg2: 3, arg3: 4, arg4: 5} )), println!("CLIENT: Waiting for server address...");
&mut client_conn).expect("couldn't send message") { let sid = server_addr_recv.recv().unwrap();
Result::Ok => (), println!("CLIENT: Connecting to server {:?}", sid);
x => panic!("Unexpected message result: {:?}", x), let conn = xous::connect(sid).expect("couldn't connect to server");
} xous::send_message(conn, xous::Message::Scalar(xous::ScalarMessage { id: 1, arg1: 2, arg2: 3, arg3: 4, arg4: 5} )).expect("couldn't send message");
});
std::thread::sleep(Duration::from_secs(1)); xous_server.join().expect("couldn't join server process");
eprintln!("SERVER: Calling ReceiveMessage..."); xous_client.join().expect("couldn't join client process");
let incoming_message = match rsyscall_to(
SysCall::ReceiveMessage(server_xous_addr),
&mut server_conn
) {
Err(e) => panic!("couldn't receive message: {:?}", e),
Ok(Result::Message(m)) => m,
Ok(o) => panic!("received invalid message: {:?}", o),
};
eprintln!("SERVER: Received message: {:?}", incoming_message);
// Any process ought to be able to shut down the system currently. // Any process ought to be able to shut down the system currently.
rsyscall_to(SysCall::Shutdown, &mut client_conn).expect("unable to shutdown server"); rsyscall(SysCall::Shutdown).expect("unable to shutdown server");
eprintln!("Joining main thread, waiting for it to quit"); main_thread.join().expect("couldn't join kernel process");
main_thread.join().expect("couldn't join main thread");
} }

View file

@ -1,14 +1,20 @@
use lazy_static::lazy_static;
use std::io::{Read, Write}; use std::io::{Read, Write};
use std::mem::size_of; use std::mem::size_of;
use std::net::TcpStream; use std::net::TcpStream;
use std::sync::Mutex; use std::thread_local;
use std::cell::RefCell;
use crate::Result; use crate::Result;
lazy_static! { thread_local!(static NETWORK_CONNECT_ADDRESS: RefCell<String> = RefCell::new("localhost:9687".to_owned()));
pub static ref XOUS_SERVER_CONNECTION: Mutex<Option<TcpStream>> = Mutex::new(None); thread_local!(static XOUS_SERVER_CONNECTION: RefCell<Option<TcpStream>> = RefCell::new(None));
/// Set the network address for this particular thread.
pub fn set_xous_address(new_address: &str) {
NETWORK_CONNECT_ADDRESS.with(|nca| {
let mut address = nca.borrow_mut();
*address = new_address.to_owned();
});
} }
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
@ -24,19 +30,22 @@ pub fn _xous_syscall(
a7: usize, a7: usize,
ret: &mut Result, ret: &mut Result,
) { ) {
let xous_server_connection = &mut *XOUS_SERVER_CONNECTION.lock().unwrap(); XOUS_SERVER_CONNECTION.with(|xsc| {
if xous_server_connection.is_none() { if xsc.borrow().is_none() {
println!("Opening connection to Xous server..."); NETWORK_CONNECT_ADDRESS.with(|nca| {
let conn = TcpStream::connect("localhost:9687").unwrap(); println!("Opening connection to Xous server @ {}...", nca.borrow());
*xous_server_connection = Some(conn); let conn = TcpStream::connect(nca.borrow().as_str()).unwrap();
} *xsc.borrow_mut() = Some(conn);
let xsc: &mut TcpStream = (*xous_server_connection).as_mut().unwrap(); });
_xous_syscall_to(nr, a1, a2, a3, a4, a5, a6, a7, ret, xsc) }
// let xsc: &mut TcpStream = (*xous_server_connection).as_mut().unwrap();
_xous_syscall_to(nr, a1, a2, a3, a4, a5, a6, a7, ret, xsc.borrow_mut().as_mut().unwrap())
})
} }
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
#[no_mangle] #[no_mangle]
pub fn _xous_syscall_to( fn _xous_syscall_to(
nr: usize, nr: usize,
a1: usize, a1: usize,
a2: usize, a2: usize,
@ -48,10 +57,10 @@ pub fn _xous_syscall_to(
ret: &mut Result, ret: &mut Result,
xsc: &mut TcpStream, xsc: &mut TcpStream,
) { ) {
// print!( println!(
// "Making Syscall: {:?}", "Making Syscall: {:?}",
// SysCall::from_args(nr, a1, a2, a3, a4, a5, a6, a7).unwrap() crate::SysCall::from_args(nr, a1, a2, a3, a4, a5, a6, a7).unwrap()
// ); );
// Send the packet to the server // Send the packet to the server
for word in &[nr, a1, a2, a3, a4, a5, a6, a7] { for word in &[nr, a1, a2, a3, a4, a5, a6, a7] {
@ -68,7 +77,7 @@ pub fn _xous_syscall_to(
} }
*ret = Result::from_args(pkt); *ret = Result::from_args(pkt);
// println!(" Response: {:?}", *ret); println!(" Response: {:?}", *ret);
if Result::BlockedProcess == *ret { if Result::BlockedProcess == *ret {
// println!(" Waiting again"); // println!(" Waiting again");
} else { } else {

View file

@ -5,9 +5,6 @@ use crate::{
use num_derive::FromPrimitive; use num_derive::FromPrimitive;
use num_traits::FromPrimitive; use num_traits::FromPrimitive;
#[cfg(not(baremetal))]
use std::net::TcpStream;
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
pub enum SysCall { pub enum SysCall {
/// Allocates pages of memory, equal to a total of `size` bytes. A physical /// Allocates pages of memory, equal to a total of `size` bytes. A physical
@ -636,19 +633,6 @@ extern "Rust" {
a7: usize, a7: usize,
ret: &mut Result, ret: &mut Result,
); );
#[cfg(not(baremetal))]
pub fn _xous_syscall_to(
nr: usize,
a1: usize,
a2: usize,
a3: usize,
a4: usize,
a5: usize,
a6: usize,
a7: usize,
ret: &mut Result,
xsc: &mut TcpStream,
);
} }
/// Map the given physical address to the given virtual address. /// Map the given physical address to the given virtual address.
@ -820,21 +804,6 @@ pub fn rsyscall(call: SysCall) -> SysCallResult {
} }
} }
/// Perform a remote syscall to a given address
#[cfg(not(baremetal))]
pub fn rsyscall_to(call: SysCall, stream: &mut TcpStream) -> SysCallResult {
let mut ret = Result::Ok;
let args = call.as_args();
unsafe {
_xous_syscall_to(
args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], &mut ret, stream,
)
};
match ret {
Result::Error(e) => Err(e),
other => Ok(other),
}
}
// /// This is dangerous, but fast. // /// This is dangerous, but fast.
// pub unsafe fn dangerous_syscall(call: SysCall) -> SyscallResult { // pub unsafe fn dangerous_syscall(call: SysCall) -> SyscallResult {
// use core::mem::{transmute, MaybeUninit}; // use core::mem::{transmute, MaybeUninit};