kernel: syscall: unify print!() messages

Use `print!()` instead of `println!()` in order to make error messages
easier to read in the debug console.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-10-30 10:19:28 +08:00
parent b3d918358e
commit 49d3ce8a6f

View file

@ -126,10 +126,10 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
.expect("server couldn't be located") .expect("server couldn't be located")
.take_available_thread() .take_available_thread()
{ {
// println!( print!(
// "There are contexts available to handle this message. Marking PID {} as Ready", " [there are contexts available to handle this message -- marking PID {} as Ready]",
// server_pid server_pid
// ); );
let sender_idx = if message.is_blocking() { let sender_idx = if message.is_blocking() {
ss.remember_server_message(sidx, pid, thread, &message, client_address) ss.remember_server_message(sidx, pid, thread, &message, client_address)
.map_err(|e| { .map_err(|e| {
@ -145,10 +145,10 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
sidx, sidx,
idx: sender_idx, idx: sender_idx,
}; };
// println!( print!(
// "KERNEL({}): server connection data: sidx: {}, idx: {}, server pid: {}", " [server connection data: sidx: {}, idx: {}, server pid: {}]",
// pid, sidx, sender_idx, server_pid sidx, sender_idx, server_pid
// ); );
let envelope = MessageEnvelope { let envelope = MessageEnvelope {
sender: sender.into(), sender: sender.into(),
body: message, body: message,
@ -187,7 +187,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
) )
.map(|_| xous_kernel::Result::Ok) .map(|_| xous_kernel::Result::Ok)
} else { } else {
// println!("Setting the return value of the Server and returning to Client"); print!(" [setting the return value of the Server to {:?} and returning to Client]", envelope);
// "Switch to" the server PID when not running on bare metal. This ensures // "Switch to" the server PID when not running on bare metal. This ensures
// that it's "Running". // that it's "Running".
ss.switch_to_thread(server_pid, Some(server_tid))?; ss.switch_to_thread(server_pid, Some(server_tid))?;
@ -199,6 +199,10 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
.map(|_| xous_kernel::Result::Ok) .map(|_| xous_kernel::Result::Ok)
} }
} else { } else {
print!(
" [no threads available in PID {} to handle this message, so blocking]",
server_pid
);
// Add this message to the queue. If the queue is full, this // Add this message to the queue. If the queue is full, this
// returns an error. // returns an error.
ss.queue_server_message(sidx, pid, thread, message, client_address)?; ss.queue_server_message(sidx, pid, thread, message, client_address)?;
@ -237,6 +241,7 @@ fn return_memory(pid: PID, tid: TID, sender: MessageSender, buf: MemoryRange) ->
return Err(xous_kernel::Error::ServerNotFound); return Err(xous_kernel::Error::ServerNotFound);
} }
let result = server.take_waiting_message(sender.idx, Some(&buf))?; let result = server.take_waiting_message(sender.idx, Some(&buf))?;
print!(" [waiting message was: {:?}]", result);
let (client_pid, client_tid, server_addr, client_addr, len) = match result { let (client_pid, client_tid, server_addr, client_addr, len) = match result {
WaitingMessage::BorrowedMemory( WaitingMessage::BorrowedMemory(
client_pid, client_pid,
@ -299,9 +304,13 @@ fn return_memory(pid: PID, tid: TID, sender: MessageSender, buf: MemoryRange) ->
// Unblock the client context to allow it to continue. // Unblock the client context to allow it to continue.
if !cfg!(baremetal) { if !cfg!(baremetal) {
// Send a message to the client, in order to wake it up
print!(" [waking up PID {}:{}]", client_pid, client_tid);
ss.ready_thread(client_pid, client_tid)?; ss.ready_thread(client_pid, client_tid)?;
ss.switch_to_thread(client_pid, Some(client_tid))?; ss.switch_to_thread(client_pid, Some(client_tid))?;
ss.set_thread_result(client_pid, client_tid, xous_kernel::Result::Ok)?; ss.set_thread_result(client_pid, client_tid, xous_kernel::Result::Ok)?;
// Return success to the server
Ok(xous_kernel::Result::Ok) Ok(xous_kernel::Result::Ok)
} else { } else {
// Switch away from the server, but leave it as Runnable // Switch away from the server, but leave it as Runnable
@ -473,6 +482,7 @@ fn receive_message(pid: PID, tid: TID, sid: SID) -> SysCallResult {
// If there is a pending message, return it immediately. // If there is a pending message, return it immediately.
if let Some(msg) = server.take_next_message(sidx) { if let Some(msg) = server.take_next_message(sidx) {
print!(" [waiting messages found -- returning {:?}]", msg);
return Ok(xous_kernel::Result::Message(msg)); return Ok(xous_kernel::Result::Message(msg));
} }
@ -480,10 +490,10 @@ fn receive_message(pid: PID, tid: TID, sid: SID) -> SysCallResult {
// process and mark ourselves as awaiting an event. When a message // process and mark ourselves as awaiting an event. When a message
// arrives, our return value will already be set to the // arrives, our return value will already be set to the
// MessageEnvelope of the incoming message. // MessageEnvelope of the incoming message.
// println!( print!(
// "KERNEL({}): did not have any waiting messages -- parking context {}", " [did not have any waiting messages -- parking thread {}]",
// pid, tid tid
// ); );
server.park_thread(tid); server.park_thread(tid);
// For baremetal targets, switch away from this process. // For baremetal targets, switch away from this process.