more fine-grained feature-detection for pidfd spawning

we now distinguish between pidfd_spawn support, pidfd-via-fork/exec and not-supported

Author: the8472

library/std/src/sys/pal/unix/process/process_unix.rs

@@ -476,35 +476,47 @@ impl Command {
 
  weak! {fn pidfd_getpid(libc::c_int) -> libc::c_int }
 
-staticPIDFD_SPAWN_SUPPORTED:AtomicU8 = AtomicU8::new(0);
+staticPIDFD_SUPPORTED:AtomicU8 = AtomicU8::new(0);
 constUNKNOWN:u8 = 0;
-constYES:u8 = 1;
-// NO currently forces a fallback to fork/exec. We could be more nuanced here and keep using spawn
-// if we know pidfd's aren't supported at all and the fallback would be futile.
-constNO:u8 = 2;
+constSPAWN:u8 = 1;
+// Obtaining a pidfd via the fork+exec path might work
+constFORK_EXEC:u8 = 2;
+// Neither pidfd_spawn nor fork/exec will get us a pidfd.
+// Instead we'll just posix_spawn if the other preconditions are met.
+constNO:u8 = 3;
 
 ifself.get_create_pidfd(){
-letflag = PIDFD_SPAWN_SUPPORTED.load(Ordering::Relaxed);
-ifflag == NO || pidfd_spawnp.get().is_none() || pidfd_getpid.get().is_none(){
+letmut support = PIDFD_SUPPORTED.load(Ordering::Relaxed);
+ifsupport == FORK_EXEC{
 returnOk(None);
 }
-ifflag == UNKNOWN{
-letmutsupport = NO;
+ifsupport == UNKNOWN{
+ support = NO;
 let our_pid = crate::process::id();
-let pidfd =
-unsafe{ libc::syscall(libc::SYS_pidfd_open, our_pid,0)}as libc::c_int;
-if pidfd >= 0{
-let pid = unsafe{ pidfd_getpid.get().unwrap()(pidfd)}asu32;
-unsafe{ libc::close(pidfd)};
-if pid == our_pid {
- support = YES
-};
+let pidfd = cvt(unsafe{ libc::syscall(libc::SYS_pidfd_open, our_pid,0)}as c_int);
+match pidfd {
+Ok(pidfd) => {
+ support = FORK_EXEC;
+ifletSome(Ok(pid)) = pidfd_getpid.get().map(|f| cvt(unsafe{ f(pidfd)}asi32)){
+if pidfd_spawnp.get().is_some() && pid asu32 == our_pid {
+ support = SPAWN
+}
+}
+unsafe{ libc::close(pidfd)};
+}
+Err(e)if e.raw_os_error() == Some(libc::EMFILE) => {
+// We're temporarily(?) out of file descriptors. In this case obtaining a pidfd would also fail
+// Don't update the support flag so we can probe again later.
+returnErr(e)
+}
+ _ => {}
 }
-PIDFD_SPAWN_SUPPORTED.store(support,Ordering::Relaxed);
-if support != YES{
+PIDFD_SUPPORTED.store(support,Ordering::Relaxed);
+if support == FORK_EXEC{
 returnOk(None);
 }
 }
+ core::assert_matches::debug_assert_matches!(support,SPAWN | NO);
 }
 } else {
 ifself.get_create_pidfd(){
@@ -691,7 +703,7 @@ impl Command {
 let spawn_fn = retrying_libc_posix_spawnp;
 
 #[cfg(target_os = "linux")]
-ifself.get_create_pidfd(){
+ifself.get_create_pidfd()&& PIDFD_SUPPORTED.load(Ordering::Relaxed) == SPAWN{
 letmut pidfd: libc::c_int = -1;
 let spawn_res = pidfd_spawnp.get().unwrap()(
 &mut pidfd,
@@ -706,7 +718,7 @@ impl Command {
 ifletErr(ref e) = spawn_res
  && e.raw_os_error() == Some(libc::ENOSYS)
 {
-PIDFD_SPAWN_SUPPORTED.store(NO,Ordering::Relaxed);
+PIDFD_SUPPORTED.store(FORK_EXEC,Ordering::Relaxed);
 returnOk(None);
 }
  spawn_res?;