Do not call getpid wrapper after fork in tests

The test calls libc::getpid() in the pre_exec hook and asserts that the returned value is different from the PID of the parent.
However, libc::getpid() returns the wrong value.
Before version 2.25, glibc caches the PID of the current process with the goal of avoiding additional syscalls.
The cached value is only updated when the wrapper functions for fork or clone are called.
In PR rust-lang#81825 we switch to directly using the clone3 syscall.
Thus, the cache is not updated and getpid returns the PID of the parent.
source: https://man7.org/linux/man-pages/man2/getpid.2.html#NOTES

src/test/ui/command/command-pre-exec.rs

@@ -8,15 +8,30 @@
 // ignore-sgx no processes
 #![feature(process_exec, rustc_private)]
 
-extern crate libc;
-
 use std::env;
 use std::io::Error;
 use std::os::unix::process::CommandExt;
 use std::process::Command;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
+#[cfg(not(target_os = "linux"))]
+fn getpid() -> u32 {
+    use std::process;
+    process::id()
+}
+
+/// We need to directly use the getpid syscall instead of using `process::id()`
+/// because the libc wrapper might return incorrect values after a process was
+/// forked.
+#[cfg(target_os = "linux")]
+fn getpid() -> u32 {
+    extern crate libc;
+    unsafe {
+        libc::syscall(libc::SYS_getpid) as _
+    }
+}
+
 fn main() {
     if let Some(arg) = env::args().nth(1) {
         match &arg[..] {
@@ -68,14 +83,12 @@ fn main() {
     };
     assert_eq!(output.raw_os_error(), Some(102));
 
-    let pid = unsafe { libc::getpid() };
-    assert!(pid >= 0);
+    let pid = getpid();
     let output = unsafe {
         Command::new(&me)
             .arg("empty")
             .pre_exec(move || {
-                let child = libc::getpid();
-                assert!(child >= 0);
+                let child = getpid();
                 assert!(pid != child);
                 Ok(())
             })

src/test/ui/process/process-panic-after-fork.rs

@@ -23,6 +23,21 @@ use std::sync::atomic::{AtomicU32, Ordering};
 
 use libc::c_int;
 
+#[cfg(not(target_os = "linux"))]
+fn getpid() -> u32 {
+    process::id()
+}
+
+/// We need to directly use the getpid syscall instead of using `process::id()`
+/// because the libc wrapper might return incorrect values after a process was
+/// forked.
+#[cfg(target_os = "linux")]
+fn getpid() -> u32 {
+    unsafe {
+        libc::syscall(libc::SYS_getpid) as _
+    }
+}
+
 /// This stunt allocator allows us to spot heap allocations in the child.
 struct PidChecking<A> {
     parent: A,
@@ -44,7 +59,7 @@ impl<A> PidChecking<A> {
     fn check(&self) {
         let require_pid = self.require_pid.load(Ordering::Acquire);
         if require_pid != 0 {
-            let actual_pid = process::id();
+            let actual_pid = getpid();
             if require_pid != actual_pid {
                 unsafe {
                     libc::raise(libc::SIGUSR1);