kernel: server: allow taking multiple messages from queue

Previously, we would only look at the top item on the server queue. If
it was not a known message, we would return an error.

This patch changes this behavior to look through the entire queue for
something we can take, and then clean it up as we go along.

This allow for having outstanding requests in the queue an forms the
backbone of the sleep server.

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2021-03-23 19:45:32 +08:00
parent ccc7264b79
commit 9ab5b4880f

View file

@ -387,17 +387,26 @@ impl Server {
} }
} }
*current_val = QueuedMessage::Empty; *current_val = QueuedMessage::Empty;
self.queue_tail += 1; if idx == self.queue_tail {
if self.queue_tail >= self.queue.len() { self.queue_tail += 1;
self.queue_tail = 0; if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
// Advance the pointer in case we have a long string of Empty messages.
while self.queue_tail != self.queue_head && self.queue[self.queue_tail] == QueuedMessage::Empty {
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
}
} }
// Destructure the PID and context ID from the `pid_tid` field // Destructure the PID and context ID from the `pid_tid` field
klog!( // klog!(
"taking waiting message and returning to pid: {} tid: {}", // "taking waiting message and returning to pid: {} tid: {}",
pid, // pid,
tid // tid
); // );
if !is_memory { if !is_memory {
return Ok(WaitingMessage::ScalarMessage( return Ok(WaitingMessage::ScalarMessage(
@ -442,219 +451,259 @@ impl Server {
/// * **None**: There are no waiting messages /// * **None**: There are no waiting messages
/// ***Some(MessageEnvelope): This message is queued. /// ***Some(MessageEnvelope): This message is queued.
pub fn take_next_message(&mut self, sidx: usize) -> Option<xous_kernel::MessageEnvelope> { pub fn take_next_message(&mut self, sidx: usize) -> Option<xous_kernel::MessageEnvelope> {
// println!( // klog!(
// "queue_head: ((({}))) queue_tail: ((({}))): {:?} CID: ((({})))", // "queue_head: ((({}))) queue_tail: ((({}))): {:?} CID: ((({})))",
// self.queue_head, self.queue_tail, self.queue[self.queue_tail], sidx // self.queue_head,
// self.queue_tail,
// self.queue[self.queue_tail],
// sidx
// ); // );
use core::convert::TryInto; use core::convert::TryInto;
let mut sender = SenderID::new(sidx, self.queue_tail, None); let mut queue_idx = self.queue_tail;
let (result, response) = match self.queue[self.queue_tail] { while queue_idx != self.queue_head {
QueuedMessage::Empty => return None, let mut sender = SenderID::new(sidx, queue_idx, None);
QueuedMessage::WaitingReturnMemory(_, _, _, _, _) => return None, // klog!("Message @ server.queue[{}]: {:?}", queue_idx, self.queue[queue_idx]);
QueuedMessage::WaitingForget(_, _, _, _, _) => return None, let (result, response) = match self.queue[queue_idx] {
QueuedMessage::WaitingReturnScalar(_, _, _) => return None, QueuedMessage::Empty => {
QueuedMessage::MemoryMessageROLend( queue_idx += 1;
pid, if queue_idx >= self.queue.len() {
tid, queue_idx = 0;
client_addr, }
id, continue;
buf, }
buf_size, QueuedMessage::WaitingReturnMemory(_, _, _, _, _) => {
offset, queue_idx += 1;
valid, if queue_idx >= self.queue.len() {
) => { queue_idx = 0;
sender.pid = PID::new(pid.try_into().unwrap()); }
( continue;
xous_kernel::MessageEnvelope { }
sender: sender.into(), QueuedMessage::WaitingForget(_, _, _, _, _) => {
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { queue_idx += 1;
id, if queue_idx >= self.queue.len() {
buf: MemoryRange::new(buf, buf_size).ok()?, queue_idx = 0;
offset: MemorySize::new(offset), }
valid: MemorySize::new(valid), continue;
}), }
}, QueuedMessage::WaitingReturnScalar(_, _, _) => {
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size), queue_idx += 1;
) if queue_idx >= self.queue.len() {
} queue_idx = 0;
QueuedMessage::MemoryMessageRWLend( }
pid, continue;
tid, }
client_addr, QueuedMessage::MemoryMessageROLend(
id, pid,
buf, tid,
buf_size, client_addr,
offset, id,
valid, buf,
) => { buf_size,
sender.pid = PID::new(pid.try_into().unwrap()); offset,
( valid,
xous_kernel::MessageEnvelope { ) => {
sender: sender.into(), sender.pid = PID::new(pid.try_into().unwrap());
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { (
id, xous_kernel::MessageEnvelope {
buf: MemoryRange::new(buf, buf_size).ok()?, sender: sender.into(),
offset: MemorySize::new(offset), body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
valid: MemorySize::new(valid), id,
}), buf: MemoryRange::new(buf, buf_size).ok()?,
}, offset: MemorySize::new(offset),
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size), valid: MemorySize::new(valid),
) }),
} },
QueuedMessage::MemoryMessageROLendTerminated( QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
pid, )
tid, }
client_addr, QueuedMessage::MemoryMessageRWLend(
id, pid,
buf, tid,
buf_size, client_addr,
offset, id,
valid, buf,
) => { buf_size,
sender.pid = PID::new(pid.try_into().unwrap()); offset,
( valid,
xous_kernel::MessageEnvelope { ) => {
sender: sender.into(), sender.pid = PID::new(pid.try_into().unwrap());
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { (
id, xous_kernel::MessageEnvelope {
buf: MemoryRange::new(buf, buf_size).ok()?, sender: sender.into(),
offset: MemorySize::new(offset), body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
valid: MemorySize::new(valid), id,
}), buf: MemoryRange::new(buf, buf_size).ok()?,
}, offset: MemorySize::new(offset),
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size), valid: MemorySize::new(valid),
) }),
} },
QueuedMessage::MemoryMessageRWLendTerminated( QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
pid, )
tid, }
client_addr, QueuedMessage::MemoryMessageROLendTerminated(
id, pid,
buf, tid,
buf_size, client_addr,
offset, id,
valid, buf,
) => { buf_size,
sender.pid = PID::new(pid.try_into().unwrap()); offset,
( valid,
xous_kernel::MessageEnvelope { ) => {
sender: sender.into(), sender.pid = PID::new(pid.try_into().unwrap());
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { (
id, xous_kernel::MessageEnvelope {
buf: MemoryRange::new(buf, buf_size).ok()?, sender: sender.into(),
offset: MemorySize::new(offset), body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
valid: MemorySize::new(valid), id,
}), buf: MemoryRange::new(buf, buf_size).ok()?,
}, offset: MemorySize::new(offset),
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size), valid: MemorySize::new(valid),
) }),
} },
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
QueuedMessage::MemoryMessageRWLendTerminated(
pid,
tid,
client_addr,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
(
xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
},
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
)
}
QueuedMessage::BlockingScalarMessage( QueuedMessage::BlockingScalarMessage(
pid, pid,
tid, tid,
client_addr, client_addr,
id, id,
arg1, arg1,
arg2, arg2,
arg3, arg3,
arg4, arg4,
) => { ) => {
sender.pid = PID::new(pid.try_into().unwrap()); sender.pid = PID::new(pid.try_into().unwrap());
( (
xous_kernel::MessageEnvelope { xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::BlockingScalar(
xous_kernel::ScalarMessage {
id,
arg1,
arg2,
arg3,
arg4,
},
),
},
QueuedMessage::WaitingReturnScalar(pid, tid, client_addr),
)
}
QueuedMessage::MemoryMessageSend(
pid,
_tid,
_reserved,
id,
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(), sender: sender.into(),
body: xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage { body: xous_kernel::Message::Move(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
};
self.queue[queue_idx] = QueuedMessage::Empty;
if queue_idx == self.queue_tail {
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
}
return Some(msg);
}
// Scalar messages have nothing to return, so they can go straight to the `Free` state
QueuedMessage::ScalarMessage(pid, _tid, _reserved, id, arg1, arg2, arg3, arg4) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id, id,
arg1, arg1,
arg2, arg2,
arg3, arg3,
arg4, arg4,
}), }),
}, };
QueuedMessage::WaitingReturnScalar(pid, tid, client_addr), self.queue[queue_idx] = QueuedMessage::Empty;
) if queue_idx == self.queue_tail {
} self.queue_tail += 1;
QueuedMessage::MemoryMessageSend( if self.queue_tail >= self.queue.len() {
pid, self.queue_tail = 0;
_tid, }
_reserved, }
id, return Some(msg);
buf,
buf_size,
offset,
valid,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Move(xous_kernel::MemoryMessage {
id,
buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset),
valid: MemorySize::new(valid),
}),
};
self.queue[self.queue_tail] = QueuedMessage::Empty;
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
} }
return Some(msg); QueuedMessage::BlockingScalarTerminated(
} pid,
_tid,
_reserved,
id,
arg1,
arg2,
arg3,
arg4,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id,
arg1,
arg2,
arg3,
arg4,
}),
};
self.queue[queue_idx] = QueuedMessage::Empty;
if queue_idx == self.queue_tail {
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
}
return Some(msg);
}
};
// Scalar messages have nothing to return, so they can go straight to the `Free` state self.queue[queue_idx] = response;
QueuedMessage::ScalarMessage(pid, _tid, _reserved, id, arg1, arg2, arg3, arg4) => { return Some(result);
sender.pid = PID::new(pid.try_into().unwrap()); }
let msg = xous_kernel::MessageEnvelope { None
sender: sender.into(),
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id,
arg1,
arg2,
arg3,
arg4,
}),
};
self.queue[self.queue_tail] = QueuedMessage::Empty;
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
return Some(msg);
}
QueuedMessage::BlockingScalarTerminated(
pid,
_tid,
_reserved,
id,
arg1,
arg2,
arg3,
arg4,
) => {
sender.pid = PID::new(pid.try_into().unwrap());
let msg = xous_kernel::MessageEnvelope {
sender: sender.into(),
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id,
arg1,
arg2,
arg3,
arg4,
}),
};
self.queue[self.queue_tail] = QueuedMessage::Empty;
self.queue_tail += 1;
if self.queue_tail >= self.queue.len() {
self.queue_tail = 0;
}
return Some(msg);
}
};
self.queue[self.queue_tail] = response;
Some(result)
} }
/// Add the given message to this server's queue. /// Add the given message to this server's queue.
@ -669,7 +718,12 @@ impl Server {
message: xous_kernel::Message, message: xous_kernel::Message,
original_address: Option<MemoryAddress>, original_address: Option<MemoryAddress>,
) -> core::result::Result<usize, xous_kernel::Error> { ) -> core::result::Result<usize, xous_kernel::Error> {
// println!("Queueing message: {:?} for pid: {} tid: {}", message, pid.get(), context); // klog!(
// "Queueing message: {:?} for pid: {} tid: {}",
// message,
// pid.get(),
// context
// );
if self.queue[self.queue_head] != QueuedMessage::Empty { if self.queue[self.queue_head] != QueuedMessage::Empty {
return Err(xous_kernel::Error::ServerQueueFull); return Err(xous_kernel::Error::ServerQueueFull);
} }
@ -732,6 +786,11 @@ impl Server {
if self.queue_head >= self.queue.len() { if self.queue_head >= self.queue.len() {
self.queue_head = 0; self.queue_head = 0;
} }
// klog!(
// "queue head: {} queue_tail: {}",
// self.queue_head,
// self.queue_tail
// );
Ok(idx) Ok(idx)
} }