| //@ignore-target: windows # No pthreads on Windows |
| //@ignore-target: android # No pthread_{get,set}_name on Android |
| use std::ffi::{CStr, CString}; |
| use std::thread; |
| |
| const MAX_THREAD_NAME_LEN: usize = { |
| cfg_if::cfg_if! { |
| if #[cfg(any(target_os = "linux"))] { |
| 16 |
| } else if #[cfg(any(target_os = "illumos", target_os = "solaris"))] { |
| 32 |
| } else if #[cfg(target_os = "macos")] { |
| libc::MAXTHREADNAMESIZE // 64, at the time of writing |
| } else if #[cfg(target_os = "freebsd")] { |
| usize::MAX // as far as I can tell |
| } else { |
| panic!() |
| } |
| } |
| }; |
| |
| fn main() { |
| // The short name should be shorter than 16 bytes which POSIX promises |
| // for thread names. The length includes a null terminator. |
| let short_name = "test_named".to_owned(); |
| let long_name = std::iter::once("test_named_thread_truncation") |
| .chain(std::iter::repeat(" yada").take(100)) |
| .collect::<String>(); |
| |
| fn set_thread_name(name: &CStr) -> i32 { |
| cfg_if::cfg_if! { |
| if #[cfg(any( |
| target_os = "linux", |
| target_os = "freebsd", |
| target_os = "illumos", |
| target_os = "solaris" |
| ))] { |
| unsafe { libc::pthread_setname_np(libc::pthread_self(), name.as_ptr().cast()) } |
| } else if #[cfg(target_os = "macos")] { |
| unsafe { libc::pthread_setname_np(name.as_ptr().cast()) } |
| } else { |
| compile_error!("set_thread_name not supported for this OS") |
| } |
| } |
| } |
| |
| fn get_thread_name(name: &mut [u8]) -> i32 { |
| cfg_if::cfg_if! { |
| if #[cfg(any( |
| target_os = "linux", |
| target_os = "freebsd", |
| target_os = "illumos", |
| target_os = "solaris", |
| target_os = "macos" |
| ))] { |
| unsafe { |
| libc::pthread_getname_np(libc::pthread_self(), name.as_mut_ptr().cast(), name.len()) |
| } |
| } else { |
| compile_error!("get_thread_name not supported for this OS") |
| } |
| } |
| } |
| |
| // Set name via Rust API, get it via pthreads. |
| let long_name2 = long_name.clone(); |
| thread::Builder::new() |
| .name(long_name.clone()) |
| .spawn(move || { |
| let mut buf = vec![0u8; long_name2.len() + 1]; |
| assert_eq!(get_thread_name(&mut buf), 0); |
| let cstr = CStr::from_bytes_until_nul(&buf).unwrap(); |
| let truncated_name = &long_name2[..long_name2.len().min(MAX_THREAD_NAME_LEN - 1)]; |
| assert_eq!(cstr.to_bytes(), truncated_name.as_bytes()); |
| }) |
| .unwrap() |
| .join() |
| .unwrap(); |
| |
| // Set name via pthread and get it again (short name). |
| thread::Builder::new() |
| .spawn(move || { |
| // Set short thread name. |
| let cstr = CString::new(short_name.clone()).unwrap(); |
| assert!(cstr.to_bytes_with_nul().len() <= MAX_THREAD_NAME_LEN); // this should fit |
| assert_eq!(set_thread_name(&cstr), 0); |
| |
| // Now get it again, in various ways. |
| |
| // POSIX seems to promise at least 15 chars excluding a null terminator. |
| let mut buf = vec![0u8; short_name.len().max(15) + 1]; |
| assert_eq!(get_thread_name(&mut buf), 0); |
| let cstr = CStr::from_bytes_until_nul(&buf).unwrap(); |
| assert_eq!(cstr.to_bytes(), short_name.as_bytes()); |
| |
| // Test what happens when the buffer is shorter than 16, but still long enough. |
| let res = get_thread_name(&mut buf[..15]); |
| cfg_if::cfg_if! { |
| if #[cfg(target_os = "linux")] { |
| // For glibc used by linux-gnu there should be a failue, |
| // if a shorter than 16 bytes buffer is provided, even if that would be |
| // large enough for the thread name. |
| assert_eq!(res, libc::ERANGE); |
| } else { |
| // Everywhere else, this should work. |
| assert_eq!(res, 0); |
| // POSIX seems to promise at least 15 chars excluding a null terminator. |
| let cstr = CStr::from_bytes_until_nul(&buf).unwrap(); |
| assert_eq!(short_name.as_bytes(), cstr.to_bytes()); |
| } |
| } |
| |
| // Test what happens when the buffer is too short even for the short name. |
| let res = get_thread_name(&mut buf[..4]); |
| cfg_if::cfg_if! { |
| if #[cfg(any(target_os = "freebsd", target_os = "macos"))] { |
| // On macOS and FreeBSD it's not an error for the buffer to be |
| // too short for the thread name -- they truncate instead. |
| assert_eq!(res, 0); |
| let cstr = CStr::from_bytes_until_nul(&buf).unwrap(); |
| assert_eq!(cstr.to_bytes_with_nul().len(), 4); |
| assert!(short_name.as_bytes().starts_with(cstr.to_bytes())); |
| } else { |
| // The rest should give an error. |
| assert_eq!(res, libc::ERANGE); |
| } |
| } |
| |
| // Test zero-sized buffer. |
| let res = get_thread_name(&mut []); |
| cfg_if::cfg_if! { |
| if #[cfg(any(target_os = "freebsd", target_os = "macos"))] { |
| // On macOS and FreeBSD it's not an error for the buffer to be |
| // too short for the thread name -- even with size 0. |
| assert_eq!(res, 0); |
| } else { |
| // The rest should give an error. |
| assert_eq!(res, libc::ERANGE); |
| } |
| } |
| }) |
| .unwrap() |
| .join() |
| .unwrap(); |
| |
| // Set name via pthread and get it again (long name). |
| thread::Builder::new() |
| .spawn(move || { |
| // Set full thread name. |
| let cstr = CString::new(long_name.clone()).unwrap(); |
| let res = set_thread_name(&cstr); |
| cfg_if::cfg_if! { |
| if #[cfg(target_os = "freebsd")] { |
| // Names of all size are supported. |
| assert!(cstr.to_bytes_with_nul().len() <= MAX_THREAD_NAME_LEN); |
| assert_eq!(res, 0); |
| } else if #[cfg(target_os = "macos")] { |
| // Name is too long. |
| assert!(cstr.to_bytes_with_nul().len() > MAX_THREAD_NAME_LEN); |
| assert_eq!(res, libc::ENAMETOOLONG); |
| } else { |
| // Name is too long. |
| assert!(cstr.to_bytes_with_nul().len() > MAX_THREAD_NAME_LEN); |
| assert_eq!(res, libc::ERANGE); |
| } |
| } |
| // Set the longest name we can. |
| let truncated_name = &long_name[..long_name.len().min(MAX_THREAD_NAME_LEN - 1)]; |
| let cstr = CString::new(truncated_name).unwrap(); |
| assert_eq!(set_thread_name(&cstr), 0); |
| |
| // Now get it again, in various ways. |
| |
| // This name should round-trip properly. |
| let mut buf = vec![0u8; long_name.len() + 1]; |
| assert_eq!(get_thread_name(&mut buf), 0); |
| let cstr = CStr::from_bytes_until_nul(&buf).unwrap(); |
| assert_eq!(cstr.to_bytes(), truncated_name.as_bytes()); |
| |
| // Test what happens when our buffer is just one byte too small. |
| let res = get_thread_name(&mut buf[..truncated_name.len()]); |
| cfg_if::cfg_if! { |
| if #[cfg(any(target_os = "freebsd", target_os = "macos"))] { |
| // On macOS and FreeBSD it's not an error for the buffer to be |
| // too short for the thread name -- they truncate instead. |
| assert_eq!(res, 0); |
| let cstr = CStr::from_bytes_until_nul(&buf).unwrap(); |
| assert_eq!(cstr.to_bytes(), &truncated_name.as_bytes()[..(truncated_name.len() - 1)]); |
| } else { |
| // The rest should give an error. |
| assert_eq!(res, libc::ERANGE); |
| } |
| } |
| }) |
| .unwrap() |
| .join() |
| .unwrap(); |
| |
| // Now set the name for a non-existing thread and verify error codes. |
| let invalid_thread = 0xdeadbeef; |
| let error = { |
| cfg_if::cfg_if! { |
| if #[cfg(target_os = "linux")] { |
| libc::ENOENT |
| } else { |
| libc::ESRCH |
| } |
| } |
| }; |
| |
| #[cfg(not(target_os = "macos"))] |
| { |
| // macOS has no `setname` function accepting a thread id as the first argument. |
| let res = unsafe { libc::pthread_setname_np(invalid_thread, [0].as_ptr()) }; |
| assert_eq!(res, error); |
| } |
| |
| let mut buf = [0; 64]; |
| let res = unsafe { libc::pthread_getname_np(invalid_thread, buf.as_mut_ptr(), buf.len()) }; |
| assert_eq!(res, error); |
| } |
