Fix waitpid() emulation on Windows.

Our waitpid() emulation didn't prevent a PID from being recycled by the
OS before the call to waitpid().  The postmaster could finish up
tracking more than one child process with the same PID, and confuse
them.

Fix, by moving the guts of pgwin32_deadchild_callback() into waitpid(),
so that resources are released synchronously.  The process and PID
continue to exist until we close the process handle, which only happens
once we're ready to adjust our book-keeping of running children.

This seems to explain a couple of failures on CI.  It had never been
reported before, despite the code being as old as the Windows port.
Perhaps Windows started recycling PIDs more rapidly, or perhaps timing
changes due to commit 7389aad6 made it more likely to break.

Thanks to Alexander Lakhin for analysis and Andres Freund for tracking
down the root cause.

Back-patch to all supported branches.

Reported-by: Andres Freund <[email protected]>
Discussion: https://postgr.es/m/20230208012852.bvkn2am4h4iqjogq%40awork3.anarazel.de

diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index 2552327d9043257a417b8f78b1ddd3fcb31cba0b..71198b72c832a6c13781a5275e141b989bdfb2cf 100644 (file)
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -4811,7 +4811,7 @@ retry:
                                (errmsg_internal("could not register process for wait: error code %lu",
                                                                 GetLastError())));
 
-       /* Don't close pi.hProcess here - the wait thread needs access to it */
+       /* Don't close pi.hProcess here - waitpid() needs access to it */
 
        CloseHandle(pi.hThread);
 
@@ -6421,36 +6421,21 @@ ShmemBackendArrayRemove(Backend *bn)
 static pid_t
 waitpid(pid_t pid, int *exitstatus, int options)
 {
+       win32_deadchild_waitinfo *childinfo;
+       DWORD           exitcode;
        DWORD           dwd;
        ULONG_PTR       key;
        OVERLAPPED *ovl;
 
-       /*
-        * Check if there are any dead children. If there are, return the pid of
-        * the first one that died.
-        */
-       if (GetQueuedCompletionStatus(win32ChildQueue, &dwd, &key, &ovl, 0))
+       /* Try to consume one win32_deadchild_waitinfo from the queue. */
+       if (!GetQueuedCompletionStatus(win32ChildQueue, &dwd, &key, &ovl, 0))
        {
-               *exitstatus = (int) key;
-               return dwd;
+               errno = EAGAIN;
+               return -1;
        }
 
-       return -1;
-}
-
-/*
- * Note! Code below executes on a thread pool! All operations must
- * be thread safe! Note that elog() and friends must *not* be used.
- */
-static void WINAPI
-pgwin32_deadchild_callback(PVOID lpParameter, BOOLEAN TimerOrWaitFired)
-{
-       win32_deadchild_waitinfo *childinfo = (win32_deadchild_waitinfo *) lpParameter;
-       DWORD           exitcode;
-
-       if (TimerOrWaitFired)
-               return;                                 /* timeout. Should never happen, since we use
-                                                                * INFINITE as timeout value. */
+       childinfo = (win32_deadchild_waitinfo *) key;
+       pid = childinfo->procId;
 
        /*
         * Remove handle from wait - required even though it's set to wait only
@@ -6466,13 +6451,11 @@ pgwin32_deadchild_callback(PVOID lpParameter, BOOLEAN TimerOrWaitFired)
                write_stderr("could not read exit code for process\n");
                exitcode = 255;
        }
-
-       if (!PostQueuedCompletionStatus(win32ChildQueue, childinfo->procId, (ULONG_PTR) exitcode, NULL))
-               write_stderr("could not post child completion status\n");
+       *exitstatus = exitcode;
 
        /*
-        * Handle is per-process, so we close it here instead of in the
-        * originating thread
+        * Close the process handle.  Only after this point can the PID can be
+        * recycled by the kernel.
         */
        CloseHandle(childinfo->procHandle);
 
@@ -6482,7 +6465,34 @@ pgwin32_deadchild_callback(PVOID lpParameter, BOOLEAN TimerOrWaitFired)
         */
        free(childinfo);
 
-       /* Queue SIGCHLD signal */
+       return pid;
+}
+
+/*
+ * Note! Code below executes on a thread pool! All operations must
+ * be thread safe! Note that elog() and friends must *not* be used.
+ */
+static void WINAPI
+pgwin32_deadchild_callback(PVOID lpParameter, BOOLEAN TimerOrWaitFired)
+{
+       /* Should never happen, since we use INFINITE as timeout value. */
+       if (TimerOrWaitFired)
+               return;
+
+       /*
+        * Post the win32_deadchild_waitinfo object for waitpid() to deal with. If
+        * that fails, we leak the object, but we also leak a whole process and
+        * get into an unrecoverable state, so there's not much point in worrying
+        * about that.  We'd like to panic, but we can't use that infrastructure
+        * from this thread.
+        */
+       if (!PostQueuedCompletionStatus(win32ChildQueue,
+                                                                       0,
+                                                                       (ULONG_PTR) lpParameter,
+                                                                       NULL))
+               write_stderr("could not post child completion status\n");
+
+       /* Queue SIGCHLD signal. */
        pg_queue_signal(SIGCHLD);
 }
 #endif                                                 /* WIN32 */