/*------------------------------------------------------------------------- * * pmsignal.c * routines for signaling between the postmaster and its child processes * * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * IDENTIFICATION * src/backend/storage/ipc/pmsignal.c * *------------------------------------------------------------------------- */ #include "postgres.h" #include #include #ifdef HAVE_SYS_PRCTL_H #include #endif #include "miscadmin.h" #include "postmaster/postmaster.h" #include "replication/walsender.h" #include "storage/ipc.h" #include "storage/pmsignal.h" #include "storage/shmem.h" #include "utils/memutils.h" /* * The postmaster is signaled by its children by sending SIGUSR1. The * specific reason is communicated via flags in shared memory. We keep * a boolean flag for each possible "reason", so that different reasons * can be signaled by different backends at the same time. (However, * if the same reason is signaled more than once simultaneously, the * postmaster will observe it only once.) * * The flags are actually declared as "volatile sig_atomic_t" for maximum * portability. This should ensure that loads and stores of the flag * values are atomic, allowing us to dispense with any explicit locking. * * In addition to the per-reason flags, we store a set of per-child-process * flags that are currently used only for detecting whether a backend has * exited without performing proper shutdown. The per-child-process flags * have three possible states: UNUSED, ASSIGNED, ACTIVE. An UNUSED slot is * available for assignment. An ASSIGNED slot is associated with a postmaster * child process, but either the process has not touched shared memory yet, or * it has successfully cleaned up after itself. An ACTIVE slot means the * process is actively using shared memory. The slots are assigned to child * processes by postmaster, and pmchild.c is responsible for tracking which * one goes with which PID. * * Actually there is a fourth state, WALSENDER. This is just like ACTIVE, * but carries the extra information that the child is a WAL sender. * WAL senders too start in ACTIVE state, but switch to WALSENDER once they * start streaming the WAL (and they never go back to ACTIVE after that). * * We also have a shared-memory field that is used for communication in * the opposite direction, from postmaster to children: it tells why the * postmaster has broadcasted SIGQUIT signals, if indeed it has done so. */ #define PM_CHILD_UNUSED 0 /* these values must fit in sig_atomic_t */ #define PM_CHILD_ASSIGNED 1 #define PM_CHILD_ACTIVE 2 #define PM_CHILD_WALSENDER 3 /* "typedef struct PMSignalData PMSignalData" appears in pmsignal.h */ struct PMSignalData { /* per-reason flags for signaling the postmaster */ sig_atomic_t PMSignalFlags[NUM_PMSIGNALS]; /* global flags for signals from postmaster to children */ QuitSignalReason sigquit_reason; /* why SIGQUIT was sent */ /* per-child-process flags */ int num_child_flags; /* # of entries in PMChildFlags[] */ sig_atomic_t PMChildFlags[FLEXIBLE_ARRAY_MEMBER]; }; /* PMSignalState pointer is valid in both postmaster and child processes */ NON_EXEC_STATIC volatile PMSignalData *PMSignalState = NULL; /* * Local copy of PMSignalState->num_child_flags, only valid in the * postmaster. Postmaster keeps a local copy so that it doesn't need to * trust the value in shared memory. */ static int num_child_flags; /* * Signal handler to be notified if postmaster dies. */ #ifdef USE_POSTMASTER_DEATH_SIGNAL volatile sig_atomic_t postmaster_possibly_dead = false; static void postmaster_death_handler(SIGNAL_ARGS) { postmaster_possibly_dead = true; } /* * The available signals depend on the OS. SIGUSR1 and SIGUSR2 are already * used for other things, so choose another one. * * Currently, we assume that we can always find a signal to use. That * seems like a reasonable assumption for all platforms that are modern * enough to have a parent-death signaling mechanism. */ #if defined(SIGINFO) #define POSTMASTER_DEATH_SIGNAL SIGINFO #elif defined(SIGPWR) #define POSTMASTER_DEATH_SIGNAL SIGPWR #else #error "cannot find a signal to use for postmaster death" #endif #endif /* USE_POSTMASTER_DEATH_SIGNAL */ static void MarkPostmasterChildInactive(int code, Datum arg); /* * PMSignalShmemSize * Compute space needed for pmsignal.c's shared memory */ Size PMSignalShmemSize(void) { Size size; size = offsetof(PMSignalData, PMChildFlags); size = add_size(size, mul_size(MaxLivePostmasterChildren(), sizeof(sig_atomic_t))); return size; } /* * PMSignalShmemInit - initialize during shared-memory creation */ void PMSignalShmemInit(void) { bool found; PMSignalState = (PMSignalData *) ShmemInitStruct("PMSignalState", PMSignalShmemSize(), &found); if (!found) { /* initialize all flags to zeroes */ MemSet(unvolatize(PMSignalData *, PMSignalState), 0, PMSignalShmemSize()); num_child_flags = MaxLivePostmasterChildren(); PMSignalState->num_child_flags = num_child_flags; } } /* * SendPostmasterSignal - signal the postmaster from a child process */ void SendPostmasterSignal(PMSignalReason reason) { /* If called in a standalone backend, do nothing */ if (!IsUnderPostmaster) return; /* Atomically set the proper flag */ PMSignalState->PMSignalFlags[reason] = true; /* Send signal to postmaster */ kill(PostmasterPid, SIGUSR1); } /* * CheckPostmasterSignal - check to see if a particular reason has been * signaled, and clear the signal flag. Should be called by postmaster * after receiving SIGUSR1. */ bool CheckPostmasterSignal(PMSignalReason reason) { /* Careful here --- don't clear flag if we haven't seen it set */ if (PMSignalState->PMSignalFlags[reason]) { PMSignalState->PMSignalFlags[reason] = false; return true; } return false; } /* * SetQuitSignalReason - broadcast the reason for a system shutdown. * Should be called by postmaster before sending SIGQUIT to children. * * Note: in a crash-and-restart scenario, the "reason" field gets cleared * as a part of rebuilding shared memory; the postmaster need not do it * explicitly. */ void SetQuitSignalReason(QuitSignalReason reason) { PMSignalState->sigquit_reason = reason; } /* * GetQuitSignalReason - obtain the reason for a system shutdown. * Called by child processes when they receive SIGQUIT. * If the postmaster hasn't actually sent SIGQUIT, will return PMQUIT_NOT_SENT. */ QuitSignalReason GetQuitSignalReason(void) { /* This is called in signal handlers, so be extra paranoid. */ if (!IsUnderPostmaster || PMSignalState == NULL) return PMQUIT_NOT_SENT; return PMSignalState->sigquit_reason; } /* * MarkPostmasterChildSlotAssigned - mark the given slot as ASSIGNED for a * new postmaster child process. * * Only the postmaster is allowed to execute this routine, so we need no * special locking. */ void MarkPostmasterChildSlotAssigned(int slot) { Assert(slot > 0 && slot <= num_child_flags); slot--; if (PMSignalState->PMChildFlags[slot] != PM_CHILD_UNUSED) elog(FATAL, "postmaster child slot is already in use"); PMSignalState->PMChildFlags[slot] = PM_CHILD_ASSIGNED; } /* * MarkPostmasterChildSlotUnassigned - release a slot after death of a * postmaster child process. This must be called in the postmaster process. * * Returns true if the slot had been in ASSIGNED state (the expected case), * false otherwise (implying that the child failed to clean itself up). */ bool MarkPostmasterChildSlotUnassigned(int slot) { bool result; Assert(slot > 0 && slot <= num_child_flags); slot--; /* * Note: the slot state might already be unused, because the logic in * postmaster.c is such that this might get called twice when a child * crashes. So we don't try to Assert anything about the state. */ result = (PMSignalState->PMChildFlags[slot] == PM_CHILD_ASSIGNED); PMSignalState->PMChildFlags[slot] = PM_CHILD_UNUSED; return result; } /* * IsPostmasterChildWalSender - check if given slot is in use by a * walsender process. This is called only by the postmaster. */ bool IsPostmasterChildWalSender(int slot) { Assert(slot > 0 && slot <= num_child_flags); slot--; if (PMSignalState->PMChildFlags[slot] == PM_CHILD_WALSENDER) return true; else return false; } /* * RegisterPostmasterChildActive - mark a postmaster child as about to begin * actively using shared memory. This is called in the child process. * * This register an shmem exit hook to mark us as inactive again when the * process exits normally. */ void RegisterPostmasterChildActive(void) { int slot = MyPMChildSlot; Assert(slot > 0 && slot <= PMSignalState->num_child_flags); slot--; Assert(PMSignalState->PMChildFlags[slot] == PM_CHILD_ASSIGNED); PMSignalState->PMChildFlags[slot] = PM_CHILD_ACTIVE; /* Arrange to clean up at exit. */ on_shmem_exit(MarkPostmasterChildInactive, 0); } /* * MarkPostmasterChildWalSender - mark a postmaster child as a WAL sender * process. This is called in the child process, sometime after marking the * child as active. */ void MarkPostmasterChildWalSender(void) { int slot = MyPMChildSlot; Assert(am_walsender); Assert(slot > 0 && slot <= PMSignalState->num_child_flags); slot--; Assert(PMSignalState->PMChildFlags[slot] == PM_CHILD_ACTIVE); PMSignalState->PMChildFlags[slot] = PM_CHILD_WALSENDER; } /* * MarkPostmasterChildInactive - mark a postmaster child as done using * shared memory. This is called in the child process. */ static void MarkPostmasterChildInactive(int code, Datum arg) { int slot = MyPMChildSlot; Assert(slot > 0 && slot <= PMSignalState->num_child_flags); slot--; Assert(PMSignalState->PMChildFlags[slot] == PM_CHILD_ACTIVE || PMSignalState->PMChildFlags[slot] == PM_CHILD_WALSENDER); PMSignalState->PMChildFlags[slot] = PM_CHILD_ASSIGNED; } /* * PostmasterIsAliveInternal - check whether postmaster process is still alive * * This is the slow path of PostmasterIsAlive(), where the caller has already * checked 'postmaster_possibly_dead'. (On platforms that don't support * a signal for parent death, PostmasterIsAlive() is just an alias for this.) */ bool PostmasterIsAliveInternal(void) { #ifdef USE_POSTMASTER_DEATH_SIGNAL /* * Reset the flag before checking, so that we don't miss a signal if * postmaster dies right after the check. If postmaster was indeed dead, * we'll re-arm it before returning to caller. */ postmaster_possibly_dead = false; #endif #ifndef WIN32 { char c; ssize_t rc; rc = read(postmaster_alive_fds[POSTMASTER_FD_WATCH], &c, 1); /* * In the usual case, the postmaster is still alive, and there is no * data in the pipe. */ if (rc < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) return true; else { /* * Postmaster is dead, or something went wrong with the read() * call. */ #ifdef USE_POSTMASTER_DEATH_SIGNAL postmaster_possibly_dead = true; #endif if (rc < 0) elog(FATAL, "read on postmaster death monitoring pipe failed: %m"); else if (rc > 0) elog(FATAL, "unexpected data in postmaster death monitoring pipe"); return false; } } #else /* WIN32 */ if (WaitForSingleObject(PostmasterHandle, 0) == WAIT_TIMEOUT) return true; else { #ifdef USE_POSTMASTER_DEATH_SIGNAL postmaster_possibly_dead = true; #endif return false; } #endif /* WIN32 */ } /* * PostmasterDeathSignalInit - request signal on postmaster death if possible */ void PostmasterDeathSignalInit(void) { #ifdef USE_POSTMASTER_DEATH_SIGNAL int signum = POSTMASTER_DEATH_SIGNAL; /* Register our signal handler. */ pqsignal(signum, postmaster_death_handler); /* Request a signal on parent exit. */ #if defined(PR_SET_PDEATHSIG) if (prctl(PR_SET_PDEATHSIG, signum) < 0) elog(ERROR, "could not request parent death signal: %m"); #elif defined(PROC_PDEATHSIG_CTL) if (procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum) < 0) elog(ERROR, "could not request parent death signal: %m"); #else #error "USE_POSTMASTER_DEATH_SIGNAL set, but there is no mechanism to request the signal" #endif /* * Just in case the parent was gone already and we missed it, we'd better * check the slow way on the first call. */ postmaster_possibly_dead = true; #endif /* USE_POSTMASTER_DEATH_SIGNAL */ }