Added support for prctl handling thread names

YohDeadfall · YohDeadfall · commit 4f34ee1d6eb1 · 2024-10-17T23:37:51.000+03:00
diff --git a/ci/ci.sh b/ci/ci.sh
@@ -154,7 +154,7 @@ case $HOST_TARGET in
     TEST_TARGET=i686-unknown-freebsd   run_tests_minimal $BASIC $UNIX time hashmap random threadname pthread fs libc-pipe
     TEST_TARGET=x86_64-unknown-illumos run_tests_minimal $BASIC $UNIX time hashmap random thread sync available-parallelism tls libc-pipe
     TEST_TARGET=x86_64-pc-solaris      run_tests_minimal $BASIC $UNIX time hashmap random thread sync available-parallelism tls libc-pipe
-    TEST_TARGET=aarch64-linux-android  run_tests_minimal $BASIC $UNIX time hashmap pthread --skip threadname
+    TEST_TARGET=aarch64-linux-android  run_tests_minimal $BASIC $UNIX time hashmap threadname pthread
     TEST_TARGET=wasm32-wasip2          run_tests_minimal $BASIC wasm
     TEST_TARGET=wasm32-unknown-unknown run_tests_minimal no_std empty_main wasm # this target doesn't really have std
     TEST_TARGET=thumbv7em-none-eabihf  run_tests_minimal no_std
diff --git a/src/shims/unix/android/foreign_items.rs b/src/shims/unix/android/foreign_items.rs
@@ -1,6 +1,7 @@
 use rustc_span::Symbol;
 use rustc_target::spec::abi::Abi;
 
+use crate::shims::unix::android::thread::prctl;
 use crate::*;
 
 pub fn is_dyn_sym(_name: &str) -> bool {
@@ -25,6 +26,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(errno_place.to_ref(this).to_scalar(), dest)?;
             }
 
+            // Threading
+            "prctl" => prctl(this, link_name, abi, args, dest)?,
+
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
         interp_ok(EmulateItemResult::NeedsReturn)
diff --git a/src/shims/unix/android/mod.rs b/src/shims/unix/android/mod.rs
@@ -1 +1,2 @@
 pub mod foreign_items;
+pub mod thread;
diff --git a/src/shims/unix/android/thread.rs b/src/shims/unix/android/thread.rs
@@ -0,0 +1,54 @@
+use rustc_span::Symbol;
+use rustc_target::spec::abi::Abi;
+
+use crate::helpers::check_min_arg_count;
+use crate::shims::unix::thread::EvalContextExt as _;
+use crate::*;
+
+const TASK_COMM_LEN: usize = 16;
+
+pub fn prctl<'tcx>(
+    this: &mut MiriInterpCx<'tcx>,
+    link_name: Symbol,
+    abi: Abi,
+    args: &[OpTy<'tcx>],
+    dest: &MPlaceTy<'tcx>,
+) -> InterpResult<'tcx> {
+    // We do not use `check_shim` here because `prctl` is variadic. The argument
+    // count is checked bellow.
+    this.check_abi_and_shim_symbol_clash(abi, Abi::C { unwind: false }, link_name)?;
+
+    // FIXME: Use PR_SET/GET_NAME constant when https://github.com/rust-lang/libc/pull/3941 lands.
+    let pr_set_name = 15;
+    let pr_get_name = 16;
+
+    let [op] = check_min_arg_count("prctl", args)?;
+    let res = match this.read_scalar(op)?.to_i32()? {
+        op if op == pr_set_name => {
+            let [_, name] = check_min_arg_count("prctl(PR_SET_NAME, ...)", args)?;
+            let name = this.read_scalar(name)?;
+            let thread = this.pthread_self()?;
+            let res =
+                this.pthread_setname_np(thread, name, TASK_COMM_LEN, /* truncate */ true)?;
+            assert!(res);
+            Scalar::from_u32(0)
+        }
+        op if op == pr_get_name => {
+            let [_, name] = check_min_arg_count("prctl(PR_GET_NAME, ...)", args)?;
+            let name = this.read_scalar(name)?;
+            let thread = this.pthread_self()?;
+            let len = Scalar::from_target_usize(TASK_COMM_LEN as u64, this);
+            let res = if this.pthread_getname_np(thread, name, len, /* truncate*/ false)? {
+                Scalar::from_u32(0)
+            } else {
+                throw_ub_format!(
+                    "`prctl(PR_GET_NAME, name)` requires the `name` argument to be at least {TASK_COMM_LEN} bytes long"
+                );
+            };
+            res
+        }
+        op => throw_unsup_format!("Miri does not support `prctl` syscall with op={}", op),
+    };
+    this.write_scalar(res, dest)?;
+    interp_ok(())
+}
diff --git a/src/shims/unix/freebsd/foreign_items.rs b/src/shims/unix/freebsd/foreign_items.rs
@@ -29,6 +29,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this.read_scalar(thread)?,
                     this.read_scalar(name)?,
                     max_len,
+                    /* truncate */ false,
                 )?;
             }
             "pthread_get_name_np" => {
diff --git a/src/shims/unix/linux/foreign_items.rs b/src/shims/unix/linux/foreign_items.rs
@@ -84,6 +84,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this.read_scalar(thread)?,
                     this.read_scalar(name)?,
                     TASK_COMM_LEN,
+                    /* truncate */ false,
                 )?;
                 let res = if res { Scalar::from_u32(0) } else { this.eval_libc("ERANGE") };
                 this.write_scalar(res, dest)?;
diff --git a/src/shims/unix/macos/foreign_items.rs b/src/shims/unix/macos/foreign_items.rs
@@ -181,6 +181,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     thread,
                     this.read_scalar(name)?,
                     this.eval_libc("MAXTHREADNAMESIZE").to_target_usize(this)?.try_into().unwrap(),
+                    /* truncate */ false,
                 )? {
                     Scalar::from_u32(0)
                 } else {
diff --git a/src/shims/unix/solarish/foreign_items.rs b/src/shims/unix/solarish/foreign_items.rs
@@ -30,6 +30,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this.read_scalar(thread)?,
                     this.read_scalar(name)?,
                     max_len,
+                    /* truncate */ false,
                 )?;
                 let res = if res { Scalar::from_u32(0) } else { this.eval_libc("ERANGE") };
                 this.write_scalar(res, dest)?;
diff --git a/src/shims/unix/thread.rs b/src/shims/unix/thread.rs
@@ -64,23 +64,29 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 
     /// Set the name of the specified thread. If the name including the null terminator
-    /// is longer than `name_max_len`, then `false` is returned.
+    /// is longer or equals to `name_max_len`, then if `truncate` is set the truncated name
+    /// is used as the thread name, otherwise `false` is returned.
     fn pthread_setname_np(
         &mut self,
         thread: Scalar,
         name: Scalar,
         name_max_len: usize,
+        truncate: bool,
     ) -> InterpResult<'tcx, bool> {
         let this = self.eval_context_mut();
 
         let thread = thread.to_int(this.libc_ty_layout("pthread_t").size)?;
         let thread = ThreadId::try_from(thread).unwrap();
         let name = name.to_pointer(this)?;
-        let name = this.read_c_str(name)?.to_owned();
+        let mut name = this.read_c_str(name)?.to_owned();
 
         // Comparing with `>=` to account for null terminator.
         if name.len() >= name_max_len {
-            return interp_ok(false);
+            if truncate {
+                name.drain(name_max_len - 1..);
+            } else {
+                return interp_ok(false);
+            }
         }
 
         this.set_thread_name(thread, name);
diff --git a/tests/pass-dep/libc/threadname.rs b/tests/pass-dep/libc/threadname.rs
@@ -1,10 +1,10 @@
-//@ignore-target: windows # No pthreads on Windows
+//@ignore-target: windows # No pthreads or prctl on Windows
 use std::ffi::{CStr, CString};
 use std::thread;
 
 const MAX_THREAD_NAME_LEN: usize = {
     cfg_if::cfg_if! {
-        if #[cfg(any(target_os = "linux"))] {
+        if #[cfg(any(target_os = "linux", target_os = "android"))] {
             16
         } else if #[cfg(any(target_os = "illumos", target_os = "solaris"))] {
             32
@@ -36,6 +36,10 @@ fn main() {
                 0
             } else if #[cfg(target_os = "macos")] {
                 unsafe { libc::pthread_setname_np(name.as_ptr().cast()) }
+            } else if #[cfg(target_os = "android")] {
+                // FIXME: Use PR_SET_NAME constant when https://github.com/rust-lang/libc/pull/3941 lands.
+                const PR_SET_NAME: i32 = 15;
+                unsafe { libc::prctl(PR_SET_NAME, name.as_ptr().cast::<libc::c_char>()) }
             } else {
                 compile_error!("set_thread_name not supported for this OS")
             }
@@ -59,6 +63,10 @@ fn main() {
                     libc::pthread_get_name_np(libc::pthread_self(), name.as_mut_ptr().cast(), name.len())
                 };
                 0
+            } else if #[cfg(target_os = "android")] {
+                // FIXME: Use PR_GET_NAME constant when https://github.com/rust-lang/libc/pull/3941 lands.
+                const PR_GET_NAME: i32 = 16;
+                unsafe { libc::prctl(PR_GET_NAME, name.as_mut_ptr().cast::<libc::c_char>()) }
             } else {
                 compile_error!("get_thread_name not supported for this OS")
             }
@@ -98,30 +106,32 @@ fn main() {
             }
 
             // 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.
+                    let res = get_thread_name(&mut buf[..4]);
                     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 {
+                } else if #[cfg(not(target_os = "android"))] {
                     // The rest should give an error.
+                    let res = get_thread_name(&mut buf[..4]);
                     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.
+                    let res = get_thread_name(&mut []);
                     assert_eq!(res, 0);
-                } else {
+                } else if #[cfg(not(target_os = "android"))] {
                     // The rest should give an error.
+                    let res = get_thread_name(&mut []);
                     assert_eq!(res, libc::ERANGE);
                 }
             }
@@ -140,10 +150,15 @@ fn main() {
                     // 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.
+                } else if #[cfg(target_os = "android")] {
+                    // Names are truncated by the Linux kernel.
                     assert!(cstr.to_bytes_with_nul().len() > MAX_THREAD_NAME_LEN);
-                    assert_eq!(res, libc::ENAMETOOLONG);
+                    assert_eq!(res, 0);
+
+                    let mut buf = vec![0u8; MAX_THREAD_NAME_LEN];
+                    assert_eq!(get_thread_name(&mut buf), 0);
+                    let cstr = CStr::from_bytes_until_nul(&buf).unwrap();
+                    assert_eq!(cstr.to_bytes(), &long_name.as_bytes()[..(MAX_THREAD_NAME_LEN - 1)]);
                 } else {
                     // Name is too long.
                     assert!(cstr.to_bytes_with_nul().len() > MAX_THREAD_NAME_LEN);
@@ -164,16 +179,17 @@ fn main() {
             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.
+                    let res = get_thread_name(&mut buf[..truncated_name.len()]);
                     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 {
+                } else if #[cfg(not(target_os = "android"))] {
                     // The rest should give an error.
+                    let res = get_thread_name(&mut buf[..truncated_name.len()]);
                     assert_eq!(res, libc::ERANGE);
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`use rustc_span::Symbol;`
`2`	`2`	`use rustc_target::spec::abi::Abi;`
`3`	`3`
	`4`	`+use crate::shims::unix::android::thread::prctl;`
`4`	`5`	`use crate::*;`
`5`	`6`
`6`	`7`	`pub fn is_dyn_sym(_name: &str) -> bool {`
`@@ -25,6 +26,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {`
`25`	`26`	`this.write_scalar(errno_place.to_ref(this).to_scalar(), dest)?;`
`26`	`27`	`}`
`27`	`28`
	`29`	`+ // Threading`
	`30`	`+ "prctl" => prctl(this, link_name, abi, args, dest)?,`
	`31`	`+`
`28`	`32`	`_ => return interp_ok(EmulateItemResult::NotSupported),`
`29`	`33`	`}`
`30`	`34`	`interp_ok(EmulateItemResult::NeedsReturn)`
Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`	`1`	`pub mod foreign_items;`
	`2`	`+pub mod thread;`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {`
`29`	`29`	`this.read_scalar(thread)?,`
`30`	`30`	`this.read_scalar(name)?,`
`31`	`31`	`max_len,`
	`32`	`+ /* truncate */ false,`
`32`	`33`	`)?;`
`33`	`34`	`}`
`34`	`35`	`"pthread_get_name_np" => {`