diff options
Diffstat (limited to 'src/libstd/sys/unix/thread.rs')
| -rw-r--r-- | src/libstd/sys/unix/thread.rs | 143 |
1 files changed, 38 insertions, 105 deletions
diff --git a/src/libstd/sys/unix/thread.rs b/src/libstd/sys/unix/thread.rs index 3eedb76c21b..f111f97be60 100644 --- a/src/libstd/sys/unix/thread.rs +++ b/src/libstd/sys/unix/thread.rs @@ -17,7 +17,7 @@ use cmp; #[cfg(not(target_env = "newlib"))] use ffi::CString; use io; -use libc::consts::os::posix01::PTHREAD_STACK_MIN; +use libc::PTHREAD_STACK_MIN; use libc; use mem; use ptr; @@ -41,10 +41,11 @@ impl Thread { let p = box p; let mut native: libc::pthread_t = mem::zeroed(); let mut attr: libc::pthread_attr_t = mem::zeroed(); - assert_eq!(pthread_attr_init(&mut attr), 0); + assert_eq!(libc::pthread_attr_init(&mut attr), 0); let stack_size = cmp::max(stack, min_stack_size(&attr)); - match pthread_attr_setstacksize(&mut attr, stack_size as libc::size_t) { + match libc::pthread_attr_setstacksize(&mut attr, + stack_size as libc::size_t) { 0 => {} n => { assert_eq!(n, libc::EINVAL); @@ -56,13 +57,14 @@ impl Thread { let stack_size = (stack_size + page_size - 1) & (-(page_size as isize - 1) as usize - 1); let stack_size = stack_size as libc::size_t; - assert_eq!(pthread_attr_setstacksize(&mut attr, stack_size), 0); + assert_eq!(libc::pthread_attr_setstacksize(&mut attr, + stack_size), 0); } }; - let ret = pthread_create(&mut native, &attr, thread_start, - &*p as *const _ as *mut _); - assert_eq!(pthread_attr_destroy(&mut attr), 0); + let ret = libc::pthread_create(&mut native, &attr, thread_start, + &*p as *const _ as *mut _); + assert_eq!(libc::pthread_attr_destroy(&mut attr), 0); return if ret != 0 { Err(io::Error::from_raw_os_error(ret)) @@ -78,25 +80,20 @@ impl Thread { } pub fn yield_now() { - let ret = unsafe { sched_yield() }; + let ret = unsafe { libc::sched_yield() }; debug_assert_eq!(ret, 0); } #[cfg(any(target_os = "linux", target_os = "android"))] pub fn set_name(name: &str) { - // pthread wrapper only appeared in glibc 2.12, so we use syscall - // directly. - extern { - fn prctl(option: libc::c_int, arg2: libc::c_ulong, - arg3: libc::c_ulong, arg4: libc::c_ulong, - arg5: libc::c_ulong) -> libc::c_int; - } const PR_SET_NAME: libc::c_int = 15; let cname = CString::new(name).unwrap_or_else(|_| { panic!("thread name may not contain interior null bytes") }); + // pthread wrapper only appeared in glibc 2.12, so we use syscall + // directly. unsafe { - prctl(PR_SET_NAME, cname.as_ptr() as libc::c_ulong, 0, 0, 0); + libc::prctl(PR_SET_NAME, cname.as_ptr() as libc::c_ulong, 0, 0, 0); } } @@ -105,39 +102,27 @@ impl Thread { target_os = "bitrig", target_os = "openbsd"))] pub fn set_name(name: &str) { - extern { - fn pthread_set_name_np(tid: libc::pthread_t, - name: *const libc::c_char); - } let cname = CString::new(name).unwrap(); unsafe { - pthread_set_name_np(pthread_self(), cname.as_ptr()); + libc::pthread_set_name_np(libc::pthread_self(), cname.as_ptr()); } } #[cfg(any(target_os = "macos", target_os = "ios"))] pub fn set_name(name: &str) { - extern { - fn pthread_setname_np(name: *const libc::c_char) -> libc::c_int; - } let cname = CString::new(name).unwrap(); unsafe { - pthread_setname_np(cname.as_ptr()); + libc::pthread_setname_np(cname.as_ptr()); } } #[cfg(target_os = "netbsd")] pub fn set_name(name: &str) { - extern { - fn pthread_setname_np(thread: libc::pthread_t, - name: *const libc::c_char, - arg: *mut libc::c_void) -> libc::c_int; - } let cname = CString::new(&b"%s"[..]).unwrap(); let carg = CString::new(name).unwrap(); unsafe { - pthread_setname_np(pthread_self(), cname.as_ptr(), - carg.as_ptr() as *mut libc::c_void); + libc::pthread_setname_np(libc::pthread_self(), cname.as_ptr(), + carg.as_ptr() as *mut libc::c_void); } } #[cfg(target_env = "newlib")] @@ -162,7 +147,7 @@ impl Thread { pub fn join(self) { unsafe { - let ret = pthread_join(self.id, ptr::null_mut()); + let ret = libc::pthread_join(self.id, ptr::null_mut()); mem::forget(self); debug_assert_eq!(ret, 0); } @@ -171,7 +156,7 @@ impl Thread { impl Drop for Thread { fn drop(&mut self) { - let ret = unsafe { pthread_detach(self.id) }; + let ret = unsafe { libc::pthread_detach(self.id) }; debug_assert_eq!(ret, 0); } } @@ -197,15 +182,10 @@ pub mod guard { use prelude::v1::*; use libc::{self, pthread_t}; - use libc::funcs::posix88::mman::mmap; - use libc::consts::os::posix88::{PROT_NONE, - MAP_PRIVATE, - MAP_ANON, - MAP_FAILED, - MAP_FIXED}; + use libc::mmap; + use libc::{PROT_NONE, MAP_PRIVATE, MAP_ANON, MAP_FAILED, MAP_FIXED}; use mem; use ptr; - use super::{pthread_self, pthread_attr_destroy}; use sys::os; #[cfg(any(target_os = "macos", @@ -217,19 +197,17 @@ pub mod guard { #[cfg(any(target_os = "linux", target_os = "android", target_os = "netbsd"))] unsafe fn get_stack_start() -> Option<*mut libc::c_void> { - use super::pthread_attr_init; - let mut ret = None; let mut attr: libc::pthread_attr_t = mem::zeroed(); - assert_eq!(pthread_attr_init(&mut attr), 0); - if pthread_getattr_np(pthread_self(), &mut attr) == 0 { + assert_eq!(libc::pthread_attr_init(&mut attr), 0); + if libc::pthread_getattr_np(libc::pthread_self(), &mut attr) == 0 { let mut stackaddr = ptr::null_mut(); let mut stacksize = 0; - assert_eq!(pthread_attr_getstack(&attr, &mut stackaddr, - &mut stacksize), 0); + assert_eq!(libc::pthread_attr_getstack(&attr, &mut stackaddr, + &mut stacksize), 0); ret = Some(stackaddr); } - assert_eq!(pthread_attr_destroy(&mut attr), 0); + assert_eq!(libc::pthread_attr_destroy(&mut attr), 0); ret } @@ -273,33 +251,18 @@ pub mod guard { #[cfg(target_os = "macos")] pub unsafe fn current() -> Option<usize> { - extern { - fn pthread_get_stackaddr_np(thread: pthread_t) -> *mut libc::c_void; - fn pthread_get_stacksize_np(thread: pthread_t) -> libc::size_t; - } - Some((pthread_get_stackaddr_np(pthread_self()) as libc::size_t - - pthread_get_stacksize_np(pthread_self())) as usize) + Some((libc::pthread_get_stackaddr_np(libc::pthread_self()) as libc::size_t - + libc::pthread_get_stacksize_np(libc::pthread_self())) as usize) } #[cfg(any(target_os = "openbsd", target_os = "bitrig"))] pub unsafe fn current() -> Option<usize> { - #[repr(C)] - struct stack_t { - ss_sp: *mut libc::c_void, - ss_size: libc::size_t, - ss_flags: libc::c_int, - } - extern { - fn pthread_main_np() -> libc::c_uint; - fn pthread_stackseg_np(thread: pthread_t, - sinfo: *mut stack_t) -> libc::c_uint; - } - - let mut current_stack: stack_t = mem::zeroed(); - assert_eq!(pthread_stackseg_np(pthread_self(), &mut current_stack), 0); + let mut current_stack: libc::stack_t = mem::zeroed(); + assert_eq!(libc::pthread_stackseg_np(libc::pthread_self(), + &mut current_stack), 0); let extra = if cfg!(target_os = "bitrig") {3} else {1} * os::page_size(); - Some(if pthread_main_np() == 1 { + Some(if libc::pthread_main_np() == 1 { // main thread current_stack.ss_sp as usize - current_stack.ss_size as usize + extra } else { @@ -310,20 +273,19 @@ pub mod guard { #[cfg(any(target_os = "linux", target_os = "android", target_os = "netbsd"))] pub unsafe fn current() -> Option<usize> { - use super::pthread_attr_init; - let mut ret = None; let mut attr: libc::pthread_attr_t = mem::zeroed(); - assert_eq!(pthread_attr_init(&mut attr), 0); - if pthread_getattr_np(pthread_self(), &mut attr) == 0 { + assert_eq!(libc::pthread_attr_init(&mut attr), 0); + if libc::pthread_getattr_np(libc::pthread_self(), &mut attr) == 0 { let mut guardsize = 0; - assert_eq!(pthread_attr_getguardsize(&attr, &mut guardsize), 0); + assert_eq!(libc::pthread_attr_getguardsize(&attr, &mut guardsize), 0); if guardsize == 0 { panic!("there is no guard page"); } let mut stackaddr = ptr::null_mut(); let mut size = 0; - assert_eq!(pthread_attr_getstack(&attr, &mut stackaddr, &mut size), 0); + assert_eq!(libc::pthread_attr_getstack(&attr, &mut stackaddr, + &mut size), 0); ret = if cfg!(target_os = "netbsd") { Some(stackaddr as usize) @@ -331,20 +293,9 @@ pub mod guard { Some(stackaddr as usize + guardsize as usize) }; } - assert_eq!(pthread_attr_destroy(&mut attr), 0); + assert_eq!(libc::pthread_attr_destroy(&mut attr), 0); ret } - - #[cfg(any(target_os = "linux", target_os = "android", target_os = "netbsd"))] - extern { - fn pthread_getattr_np(native: libc::pthread_t, - attr: *mut libc::pthread_attr_t) -> libc::c_int; - fn pthread_attr_getguardsize(attr: *const libc::pthread_attr_t, - guardsize: *mut libc::size_t) -> libc::c_int; - fn pthread_attr_getstack(attr: *const libc::pthread_attr_t, - stackaddr: *mut *mut libc::c_void, - stacksize: *mut libc::size_t) -> libc::c_int; - } } // glibc >= 2.15 has a __pthread_get_minstack() function that returns @@ -394,21 +345,3 @@ fn min_stack_size(attr: *const libc::pthread_attr_t) -> usize { fn min_stack_size(_: *const libc::pthread_attr_t) -> usize { PTHREAD_STACK_MIN as usize } - -extern { - fn pthread_self() -> libc::pthread_t; - fn pthread_create(native: *mut libc::pthread_t, - attr: *const libc::pthread_attr_t, - f: extern fn(*mut libc::c_void) -> *mut libc::c_void, - value: *mut libc::c_void) -> libc::c_int; - fn pthread_join(native: libc::pthread_t, - value: *mut *mut libc::c_void) -> libc::c_int; - fn pthread_attr_init(attr: *mut libc::pthread_attr_t) -> libc::c_int; - fn pthread_attr_destroy(attr: *mut libc::pthread_attr_t) -> libc::c_int; - fn pthread_attr_setstacksize(attr: *mut libc::pthread_attr_t, - stack_size: libc::size_t) -> libc::c_int; - fn pthread_attr_setdetachstate(attr: *mut libc::pthread_attr_t, - state: libc::c_int) -> libc::c_int; - fn pthread_detach(thread: libc::pthread_t) -> libc::c_int; - fn sched_yield() -> libc::c_int; -} |