kernel: fix thread termination and waiting

Signed-off-by: Sean Cross <sean@xobs.io>
This commit is contained in:
Sean Cross 2021-05-21 17:23:13 +08:00
parent 18a86a9a19
commit be6e0a9895
4 changed files with 42 additions and 17 deletions

View file

@ -154,7 +154,9 @@ pub extern "C" fn trap_handler(
// This address indicates a thread has exited. Destroy the thread. // This address indicates a thread has exited. Destroy the thread.
// This activates another thread within this process. // This activates another thread within this process.
SystemServices::with_mut(|ss| ss.destroy_thread(pid, tid)).unwrap(); if SystemServices::with_mut(|ss| ss.destroy_thread(pid, tid)).unwrap() {
crate::syscall::reset_switchto_caller();
}
// Resume the new thread within the same process. // Resume the new thread within the same process.
ArchProcess::with_current_mut(|p| { ArchProcess::with_current_mut(|p| {

View file

@ -58,9 +58,12 @@ struct ProcessImpl {
/// Global parameters used by the operating system /// Global parameters used by the operating system
pub inner: ProcessInner, pub inner: ProcessInner,
/// The last thread ID that was allocated
last_tid_allocated: u8,
/// Pad everything to 128 bytes, so the Thread slice starts at /// Pad everything to 128 bytes, so the Thread slice starts at
/// offset 128. /// offset 128.
_padding: [u32; 14], _padding: [u32; 13],
/// This enables the kernel to keep track of threads in the /// This enables the kernel to keep track of threads in the
/// target process, and know which threads are ready to /// target process, and know which threads are ready to
@ -224,9 +227,18 @@ impl Process {
pub fn find_free_thread(&self) -> Option<TID> { pub fn find_free_thread(&self) -> Option<TID> {
let process = unsafe { &mut *PROCESS }; let process = unsafe { &mut *PROCESS };
for (index, thread) in process.threads.iter().enumerate() { let start_tid = process.last_tid_allocated as usize;
if index != IRQ_TID && thread.sepc == 0 { let a = &process.threads[start_tid..process.threads.len()];
return Some(index as TID); let b = &process.threads[0..start_tid];
for (index, thread) in a.iter().chain(b.iter()).enumerate() {
let mut tid = index + start_tid;
if tid >= process.threads.len() {
tid -= process.threads.len()
}
if tid != IRQ_TID && thread.sepc == 0 {
process.last_tid_allocated = tid as _;
return Some(tid as TID);
} }
} }
None None
@ -508,7 +520,6 @@ impl Thread {
pub fn a1(&self) -> usize { pub fn a1(&self) -> usize {
self.registers[10] self.registers[10]
} }
} }
pub fn set_current_pid(pid: PID) { pub fn set_current_pid(pid: PID) {

View file

@ -1409,13 +1409,12 @@ impl SystemServices {
Ok(new_tid) Ok(new_tid)
} }
/// Destroy the given thread. /// Destroy the given thread. Returns `true` if the PID has been updated.
/// NOTE: You MUST immediately switch away from this process.
/// # Errors /// # Errors
/// ///
/// * **ThreadNotAvailable**: The thread does not exist in this process /// * **ThreadNotAvailable**: The thread does not exist in this process
#[cfg(baremetal)] #[cfg(baremetal)]
pub fn destroy_thread(&mut self, pid: PID, tid: TID) -> Result<usize, xous_kernel::Error> { pub fn destroy_thread(&mut self, pid: PID, tid: TID) -> Result<bool, xous_kernel::Error> {
let current_pid = self.current_pid(); let current_pid = self.current_pid();
assert_eq!(pid, current_pid); assert_eq!(pid, current_pid);
@ -1426,7 +1425,7 @@ impl SystemServices {
// Destroy the thread at a hardware level // Destroy the thread at a hardware level
let mut arch_process = crate::arch::process::Process::current(); let mut arch_process = crate::arch::process::Process::current();
let return_value = arch_process.destroy_thread(tid).unwrap(); let return_value = arch_process.destroy_thread(tid).unwrap_or_default();
// If there's another thread waiting on the return value of this thread, // If there's another thread waiting on the return value of this thread,
// wake it up and set its return value. // wake it up and set its return value.
@ -1440,15 +1439,23 @@ impl SystemServices {
waiting_threads |= 1 << waiting_tid; waiting_threads |= 1 << waiting_tid;
} }
// Mark this process as `Ready`. // Mark this process as `Ready` if there are waiting threads, or `Sleeping` if
// We can do this because the current thread has just exited. Note that if there // there are no waiting threads.
// are no threads available, this is an error. let mut new_pid = pid;
self.get_process_mut(pid)?.state = ProcessState::Ready(waiting_threads); {
let process = self.get_process_mut(pid)?;
process.state = if waiting_threads == 0 {
new_pid = process.ppid;
ProcessState::Sleeping
} else {
ProcessState::Ready(waiting_threads)
};
}
// Switch to the next available TID. This moves the process back to a `Running` state. // Switch to the next available TID. This moves the process back to a `Running` state.
self.switch_to_thread(pid, None)?; self.switch_to_thread(new_pid, None)?;
Ok(return_value) Ok(new_pid != pid)
} }
/// Park this thread if the target thread is currently running. Otherwise, /// Park this thread if the target thread is currently running. Otherwise,
@ -1477,7 +1484,8 @@ impl SystemServices {
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) .unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
} else { } else {
// The thread does not exist -- continue execution // The thread does not exist -- continue execution
Err(xous_kernel::Error::ThreadNotAvailable) // Err(xous_kernel::Error::ThreadNotAvailable)
Ok(xous_kernel::Result::Scalar1(0))
} }
} }

View file

@ -30,6 +30,10 @@ enum ExecutionType {
NonBlocking, NonBlocking,
} }
pub fn reset_switchto_caller() {
unsafe { SWITCHTO_CALLER = None };
}
fn retry_syscall(pid: PID, tid: TID) -> SysCallResult { fn retry_syscall(pid: PID, tid: TID) -> SysCallResult {
if cfg!(baremetal) { if cfg!(baremetal) {
arch::process::Process::with_current_mut(|p| p.retry_instruction(tid))?; arch::process::Process::with_current_mut(|p| p.retry_instruction(tid))?;