8357641: [CRaC] Support PID change during checkpoint-restore

Co-authored-by: Radim Vansa <rvansa@openjdk.org>
Reviewed-by: rvansa

Author: TimPushkin

src/hotspot/os/aix/os_aix.cpp

@@ -916,6 +916,9 @@ int os::current_process_id() {
   return getpid();
 }
 
+void os::reset_cached_process_id() {
+}
+
 // DLL functions
 
 // This must be hard coded because it's the system's temporary

src/hotspot/os/bsd/os_bsd.cpp

@@ -869,6 +869,9 @@ int os::current_process_id() {
   return (int)(getpid());
 }
 
+void os::reset_cached_process_id() {
+}
+
 // DLL functions
 static int local_dladdr(const void* addr, Dl_info* info) {
 #ifdef __APPLE__

src/hotspot/os/linux/os_linux.cpp

@@ -220,6 +220,8 @@ typedef int (*malloc_info_func_t)(int options, FILE *stream);
 static malloc_info_func_t g_malloc_info = nullptr;
 #endif // __GLIBC__
 
+static int cached_pid = 0;
+
 static int clock_tics_per_sec = 100;
 
 // If the VM might have been created on the primordial thread, we need to resolve the
@@ -1516,8 +1518,16 @@ void os::Linux::fast_thread_clock_init() {
 
 // thread_id is kernel thread id (similar to Solaris LWP id)
 intx os::current_thread_id() { return os::Linux::gettid(); }
+
 int os::current_process_id() {
-  return ::getpid();
+  // GLIBC < 2.25 caches pid in ::getpid(); we need to be able to reset this
+  // on CRaC restore, therefore we will use our own caching.
+  return cached_pid ? cached_pid : syscall(SYS_getpid);
+}
+
+void os::reset_cached_process_id() {
+  cached_pid = 0;
+  cached_pid = current_process_id();
 }
 
 // DLL functions
@@ -4415,6 +4425,7 @@ static void check_pax(void) {
 // this is called _before_ most of the global arguments have been parsed
 void os::init(void) {
   char dummy;   // used to get a guess on initial stack address
+  cached_pid = current_process_id();
 
   clock_tics_per_sec = checked_cast<int>(sysconf(_SC_CLK_TCK));
   int sys_pg_size = checked_cast<int>(sysconf(_SC_PAGESIZE));

src/hotspot/os/posix/signals_posix.cpp

@@ -1169,7 +1169,7 @@ void os::print_siginfo(outputStream* os, const void* si0) {
     const pid_t pid = si->si_pid;
     os->print(", si_pid: %ld", (long) pid);
     if (IS_VALID_PID(pid)) {
-      const pid_t me = getpid();
+      const pid_t me = os::current_process_id();
       if (me == pid) {
         os->print(" (current process)");
       }

src/hotspot/os/windows/os_windows.cpp

@@ -3951,6 +3951,9 @@ int os::current_process_id() {
   return (_initial_pid ? _initial_pid : _getpid());
 }
 
+void os::reset_cached_process_id() {
+}
+
 int    os::win32::_processor_type            = 0;
 // Processor level is not available on non-NT systems, use vm_version instead
 int    os::win32::_processor_level           = 0;

src/hotspot/share/runtime/crac.cpp

@@ -280,6 +280,7 @@ void VM_Crac::doit() {
   }
 
   Arguments::reset_for_crac_restore();
+  os::reset_cached_process_id();
 
   if (shmid == 0) { // E.g. engine does not support restore data
     log_debug(crac)("Restore parameters (JVM flags, env vars, system properties, arguments...) not provided");

src/hotspot/share/runtime/os.hpp

@@ -608,6 +608,7 @@ class os: AllStatic {
   // thread id on Linux/64bit is 64bit, on Windows it's 32bit
   static intx current_thread_id();
   static int current_process_id();
+  static void reset_cached_process_id();
 
   // Short standalone OS sleep routines suitable for slow path spin loop.
   // Ignores safepoints/suspension/Thread.interrupt() (so keep it short).

src/java.base/share/classes/java/lang/ProcessHandleImpl.java

@@ -24,6 +24,10 @@
  */
 package java.lang;
 
+import jdk.internal.crac.Core;
+import jdk.internal.crac.JDKResource;
+import jdk.internal.crac.mirror.Context;
+import jdk.internal.crac.mirror.Resource;
 import jdk.internal.misc.InnocuousThread;
 
 import java.lang.annotation.Native;
@@ -73,10 +77,22 @@ final class ProcessHandleImpl implements ProcessHandle {
     private static final ConcurrentMap<Long, ExitCompletion>
             completions = new ConcurrentHashMap<>();
 
+    private static JDKResource cracResource = new JDKResource() {
+        @Override
+        public void beforeCheckpoint(Context<? extends Resource> context) {
+        }
+
+        @Override
+        public void afterRestore(Context<? extends Resource> context) {
+            current.pid = getCurrentPid0();
+        }
+    };
+
     static {
         initNative();
         long pid = getCurrentPid0();
         current = new ProcessHandleImpl(pid, isAlive0(pid));
+        Core.Priority.NORMAL.getContext().register(cracResource);
     }
 
     private static native void initNative();
@@ -206,7 +222,7 @@ public CompletableFuture<ProcessHandle> onExit() {
     /**
      * The pid of this ProcessHandle.
      */
-    private final long pid;
+    private long pid;
 
     /**
      * The start time of this process.

src/java.base/unix/native/libjava/ProcessHandleImpl_unix.c

@@ -44,6 +44,10 @@
 #include <sys/stat.h>
 #include <sys/wait.h>
 
+#ifdef LINUX
+  #include <sys/syscall.h>
+#endif
+
 #include <pwd.h>
 
 #if defined(_AIX)
@@ -274,7 +278,11 @@ Java_java_lang_ProcessHandleImpl_waitForProcessExit0(JNIEnv* env,
  */
 JNIEXPORT jlong JNICALL
 Java_java_lang_ProcessHandleImpl_getCurrentPid0(JNIEnv *env, jclass clazz) {
+#ifdef LINUX
+    pid_t pid = syscall(SYS_getpid);
+#else
     pid_t pid = getpid();
+#endif
     return (jlong) pid;
 }
 
@@ -383,7 +391,12 @@ Java_java_lang_ProcessHandleImpl_parent0(JNIEnv *env,
     pid_t pid = (pid_t) jpid;
     pid_t ppid;
 
-    if (pid == getpid()) {
+#ifdef LINUX
+    pid_t mypid = syscall(SYS_getpid);
+#else
+    pid_t mypid = getpid();
+#endif
+    if (pid == mypid) {
         ppid = getppid();
     } else {
         jlong start = 0L;

src/java.base/unix/native/libnet/Inet4AddressImpl.c

@@ -31,6 +31,9 @@
 #include <netinet/ip_icmp.h>
 #include <stdlib.h>
 #include <string.h>
+#ifdef LINUX
+#include <sys/syscall.h>
+#endif
 #include <sys/time.h>
 
 #include "net_util.h"
@@ -379,7 +382,11 @@ ping4(JNIEnv *env, jint fd, SOCKETADDRESS *sa, SOCKETADDRESS *netif,
     }
 
     // icmp_id is a 16 bit data type, therefore down cast the pid
+#ifdef LINUX
+    pid = (jchar)syscall(SYS_getpid);
+#else
     pid = (jchar)getpid();
+#endif // !LINUX
 
     // Make the socket non blocking so we can use select
     SET_NONBLOCKING(fd);