Andrea Ciliberti
2 years ago
5 changed files with 5 additions and 364 deletions
@ -1,13 +0,0 @@
@@ -1,13 +0,0 @@
|
||||
//! Miscellaneous pthread functions
|
||||
|
||||
// The implementation within `newlib` stubs this out *entirely*. It's not possible to use a "syscall".
|
||||
/* |
||||
#[no_mangle] |
||||
pub unsafe extern "C" fn sched_yield() -> libc::c_int { |
||||
ctru_sys::svcSleepThread(0); |
||||
|
||||
0 |
||||
} |
||||
*/ |
||||
|
||||
// `pthread_sigmask` and `pthread_atfork` are stubbed out by `newlib`
|
||||
@ -1,345 +0,0 @@
@@ -1,345 +0,0 @@
|
||||
//! PThread threads implemented using libctru.
|
||||
|
||||
use spin::rwlock::RwLock; |
||||
use std::collections::BTreeMap; |
||||
use std::ptr; |
||||
use std::sync::atomic::{AtomicUsize, Ordering}; |
||||
|
||||
pub mod attr; |
||||
|
||||
/// The main thread's pthread ID
|
||||
const MAIN_THREAD_ID: libc::pthread_t = 0; |
||||
|
||||
// We initialize to 1 since 0 is reserved for the main thread.
|
||||
static NEXT_ID: AtomicUsize = AtomicUsize::new(1); |
||||
|
||||
// This is a spin-lock RwLock which yields the thread every loop.
|
||||
static THREADS: RwLock<BTreeMap<libc::pthread_t, PThread>, spin::Yield> = |
||||
RwLock::new(BTreeMap::new()); |
||||
|
||||
// Initialize to zero (main thread ID) since the main thread will have the
|
||||
// default value in this thread local.
|
||||
#[thread_local] |
||||
static mut THREAD_ID: libc::pthread_t = MAIN_THREAD_ID; |
||||
|
||||
#[derive(Copy, Clone)] |
||||
struct PThread { |
||||
thread: ShareablePtr<ctru_sys::Thread_tag>, |
||||
os_thread_id: u32, |
||||
is_detached: bool, |
||||
is_finished: bool, |
||||
result: ShareablePtr<libc::c_void>, |
||||
} |
||||
|
||||
/// Pointers are not Send or Sync, though it's really just a lint. This struct
|
||||
/// lets us ignore that "lint".
|
||||
struct ShareablePtr<T>(*mut T); |
||||
unsafe impl<T> Send for ShareablePtr<T> {} |
||||
unsafe impl<T> Sync for ShareablePtr<T> {} |
||||
|
||||
// We can't use the derives because they add an unnecessary T: Copy/Clone bound.
|
||||
impl<T> Copy for ShareablePtr<T> {} |
||||
impl<T> Clone for ShareablePtr<T> { |
||||
fn clone(&self) -> Self { |
||||
*self |
||||
} |
||||
} |
||||
|
||||
#[no_mangle] |
||||
pub unsafe extern "C" fn __syscall_thread_create( |
||||
native: *mut libc::pthread_t, |
||||
entrypoint: extern "C" fn(_: *mut libc::c_void) -> *mut libc::c_void, |
||||
arg: *mut libc::c_void, |
||||
_stackaddr: *const libc::c_void, |
||||
stacksize: libc::size_t, |
||||
) -> libc::c_int { |
||||
let stack_size = stacksize; |
||||
// let priority = (*attr).schedparam.sched_priority;
|
||||
let mut priority = 0; |
||||
let _ = ctru_sys::svcGetThreadPriority(&mut priority, ctru_sys::CUR_THREAD_HANDLE); |
||||
// let processor_id = (*attr).processor_id;
|
||||
|
||||
let thread_id = NEXT_ID.fetch_add(1, Ordering::SeqCst) as libc::pthread_t; |
||||
|
||||
extern "C" fn thread_start(main: *mut libc::c_void) { |
||||
unsafe { |
||||
Box::from_raw(main as *mut Box<dyn FnOnce()>)(); |
||||
} |
||||
} |
||||
|
||||
// The closure needs a fat pointer (64 bits) to work since it captures a variable and is thus a
|
||||
// trait object, but *mut void is only 32 bits. We need double indirection to pass along the
|
||||
// full closure data.
|
||||
// We make this closure in the first place because threadCreate expects a void return type, but
|
||||
// entrypoint returns a pointer so the types are incompatible.
|
||||
let main: *mut Box<dyn FnOnce()> = Box::into_raw(Box::new(Box::new(move || { |
||||
THREAD_ID = thread_id; |
||||
|
||||
let result = entrypoint(arg); |
||||
|
||||
// Update the threads map with the result, and remove this thread if
|
||||
// it's detached.
|
||||
// We hold the lock the whole time so there isn't a race condition.
|
||||
// (ex. we copy out the thread data, pthread_detach is called, we
|
||||
// check is_detached and it's still false, so thread is never
|
||||
// removed from the map)
|
||||
let mut thread_map = THREADS.write(); |
||||
if let Some(mut pthread) = thread_map.get_mut(&thread_id) { |
||||
pthread.is_finished = true; |
||||
pthread.result.0 = result; |
||||
|
||||
if pthread.is_detached { |
||||
// libctru will call threadFree once this thread dies
|
||||
thread_map.remove(&thread_id); |
||||
} |
||||
} |
||||
}))); |
||||
|
||||
let thread = ctru_sys::threadCreate( |
||||
Some(thread_start), |
||||
main as *mut libc::c_void, |
||||
stack_size as usize, |
||||
priority, |
||||
0, // Normal CPU
|
||||
false, |
||||
); |
||||
|
||||
if thread.is_null() { |
||||
// There was some error, but libctru doesn't expose the result.
|
||||
// We assume there was permissions issue (such as too low of a priority).
|
||||
// We also need to clean up the closure at this time.
|
||||
drop(Box::from_raw(main)); |
||||
return libc::EPERM; |
||||
} |
||||
|
||||
// Get the OS thread ID
|
||||
let os_handle = ctru_sys::threadGetHandle(thread); |
||||
let mut os_thread_id = 0; |
||||
let result = ctru_sys::svcGetThreadId(&mut os_thread_id, os_handle); |
||||
if ctru_sys::R_FAILED(result) { |
||||
// TODO: improve error handling? Different codes?
|
||||
return libc::EPERM; |
||||
} |
||||
|
||||
// Insert the thread into our map
|
||||
THREADS.write().insert( |
||||
thread_id, |
||||
PThread { |
||||
thread: ShareablePtr(thread), |
||||
os_thread_id, |
||||
is_detached: false, |
||||
is_finished: false, |
||||
result: ShareablePtr(ptr::null_mut()), |
||||
}, |
||||
); |
||||
|
||||
*native = thread_id; |
||||
|
||||
0 |
||||
} |
||||
|
||||
#[no_mangle] |
||||
pub unsafe extern "C" fn __syscall_thread_join( |
||||
thread_id: libc::pthread_t, |
||||
) -> *const libc::c_void { // The return value is returned as a pointer
|
||||
if thread_id == MAIN_THREAD_ID { |
||||
// This is not a valid thread to join on
|
||||
return std::ptr::null(); |
||||
} |
||||
|
||||
let thread_map = THREADS.read(); |
||||
let Some(&pthread) = thread_map.get(&thread_id) else { |
||||
// This is not a valid thread ID
|
||||
return std::ptr::null(); |
||||
}; |
||||
// We need to drop our read guard so it doesn't stay locked while joining
|
||||
// the thread.
|
||||
drop(thread_map); |
||||
|
||||
if pthread.is_detached { |
||||
// Cannot join on a detached thread
|
||||
return std::ptr::null(); |
||||
} |
||||
|
||||
let result = ctru_sys::threadJoin(pthread.thread.0, u64::MAX); |
||||
if ctru_sys::R_FAILED(result) { |
||||
// TODO: improve the error code by checking the result further?
|
||||
return std::ptr::null(); |
||||
} |
||||
|
||||
ctru_sys::threadFree(pthread.thread.0); |
||||
let thread_data = THREADS.write().remove(&thread_id); |
||||
|
||||
// This should always be Some, but we use an if let just in case.
|
||||
if let Some(thread_data) = thread_data { |
||||
return thread_data.result.0; |
||||
} |
||||
|
||||
std::ptr::null() |
||||
} |
||||
|
||||
#[no_mangle] |
||||
pub unsafe extern "C" fn __syscall_thread_detach(thread_id: libc::pthread_t) -> libc::c_int { |
||||
if thread_id == MAIN_THREAD_ID { |
||||
// This is not a valid thread to detach
|
||||
return libc::EINVAL; |
||||
} |
||||
|
||||
let mut thread_map = THREADS.write(); |
||||
let Some(mut pthread) = thread_map.get_mut(&thread_id) else { |
||||
// This is not a valid thread ID
|
||||
return libc::ESRCH |
||||
}; |
||||
|
||||
if pthread.is_detached { |
||||
// Cannot detach an already detached thread
|
||||
return libc::EINVAL; |
||||
} |
||||
|
||||
pthread.is_detached = true; |
||||
ctru_sys::threadDetach(pthread.thread.0); |
||||
|
||||
if pthread.is_finished { |
||||
// threadFree was already called by threadDetach
|
||||
thread_map.remove(&thread_id); |
||||
} |
||||
|
||||
0 |
||||
} |
||||
|
||||
#[no_mangle] |
||||
pub unsafe extern "C" fn __syscall_thread_self() -> libc::pthread_t { |
||||
let thread_id = THREAD_ID; |
||||
|
||||
if thread_id == MAIN_THREAD_ID { |
||||
// Take this opportunity to populate the main thread's data in the map.
|
||||
// They can only "legally" get the main thread's ID by calling this
|
||||
// function, so this will run before they do anything that needs this.
|
||||
|
||||
// We have to ignore the possible error from svcGetThreadId since
|
||||
// pthread_self cannot fail... But there shouldn't be an error anyways.
|
||||
let mut os_thread_id = 0; |
||||
let _ = ctru_sys::svcGetThreadId(&mut os_thread_id, ctru_sys::CUR_THREAD_HANDLE); |
||||
|
||||
THREADS.write().insert( |
||||
MAIN_THREAD_ID, |
||||
PThread { |
||||
// This null pointer is safe because we return before ever using
|
||||
// it (in pthread_join and pthread_detach).
|
||||
thread: ShareablePtr(ptr::null_mut()), |
||||
os_thread_id, |
||||
is_detached: true, |
||||
is_finished: false, |
||||
result: ShareablePtr(ptr::null_mut()), |
||||
}, |
||||
); |
||||
} |
||||
|
||||
thread_id |
||||
} |
||||
|
||||
/// Closes a kernel handle on drop.
|
||||
struct Handle(ctru_sys::Handle); |
||||
|
||||
impl TryFrom<libc::pthread_t> for Handle { |
||||
type Error = libc::c_int; |
||||
|
||||
fn try_from(thread_id: libc::pthread_t) -> Result<Self, Self::Error> { |
||||
let Some(&pthread) = THREADS.read().get(&thread_id) else { |
||||
// This is not a valid thread ID
|
||||
return Err(libc::ESRCH) |
||||
}; |
||||
|
||||
if pthread.is_finished { |
||||
return Err(libc::ESRCH); |
||||
} |
||||
|
||||
let mut os_handle = 0; |
||||
let ret = unsafe { |
||||
ctru_sys::svcOpenThread( |
||||
&mut os_handle, |
||||
ctru_sys::CUR_PROCESS_HANDLE, |
||||
pthread.os_thread_id, |
||||
) |
||||
}; |
||||
|
||||
if ctru_sys::R_FAILED(ret) || os_handle == u32::MAX { |
||||
// Either there was an error or the thread already finished
|
||||
Err(libc::ESRCH) |
||||
} else { |
||||
Ok(Self(os_handle)) |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl Drop for Handle { |
||||
fn drop(&mut self) { |
||||
unsafe { |
||||
// We ignore the error because we can't return it or panic.
|
||||
let _ = ctru_sys::svcCloseHandle(self.0); |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[no_mangle] |
||||
pub unsafe extern "C" fn pthread_getschedparam( |
||||
thread_id: libc::pthread_t, |
||||
policy: *mut libc::c_int, |
||||
param: *mut libc::sched_param, |
||||
) -> libc::c_int { |
||||
let handle = match Handle::try_from(thread_id) { |
||||
Ok(handle) => handle, |
||||
Err(code) => return code, |
||||
}; |
||||
|
||||
let mut priority = 0; |
||||
let result = ctru_sys::svcGetThreadPriority(&mut priority, handle.0); |
||||
if ctru_sys::R_FAILED(result) { |
||||
// Some error occurred. This is the only error defined for this
|
||||
// function, so return it. Maybe the thread exited while this function
|
||||
// was exiting?
|
||||
return libc::ESRCH; |
||||
} |
||||
|
||||
(*param).sched_priority = priority; |
||||
|
||||
// SCHED_FIFO is closest to how the cooperative app core works, while
|
||||
// SCHED_RR is closest to how the preemptive sys core works.
|
||||
// However, we don't have an API to get the current processor ID of a chosen
|
||||
// thread (only the current), so we just always return SCHED_FIFO.
|
||||
(*policy) = libc::SCHED_FIFO; |
||||
|
||||
0 |
||||
} |
||||
|
||||
#[no_mangle] |
||||
pub unsafe extern "C" fn pthread_setschedparam( |
||||
thread_id: libc::pthread_t, |
||||
policy: libc::c_int, |
||||
param: *const libc::sched_param, |
||||
) -> libc::c_int { |
||||
if policy != libc::SCHED_FIFO { |
||||
// We only accept SCHED_FIFO. See the note in pthread_getschedparam.
|
||||
return libc::EINVAL; |
||||
} |
||||
|
||||
let handle = match Handle::try_from(thread_id) { |
||||
Ok(handle) => handle, |
||||
Err(code) => return code, |
||||
}; |
||||
|
||||
let result = ctru_sys::svcSetThreadPriority(handle.0, (*param).sched_priority); |
||||
if ctru_sys::R_FAILED(result) { |
||||
// Probably the priority is out of the permissible bounds
|
||||
// TODO: improve the error code by checking the result further?
|
||||
return libc::EPERM; |
||||
} |
||||
|
||||
0 |
||||
} |
||||
/* |
||||
#[no_mangle] |
||||
pub unsafe extern "C" fn pthread_getprocessorid_np() -> libc::c_int { |
||||
ctru_sys::svcGetProcessorID() |
||||
} |
||||
*/ |
||||
Loading…
Reference in new issue