From a4a0e77f90e5e2e69cd7280b65d0e198cf6067e7 Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Mon, 12 Aug 2024 12:43:22 +0300 Subject: [PATCH v4 6/8] Assign a child slot to every postmaster child process Previously, only backends, autovacuum workers, and background workers had an entry in the PMChildFlags array. With this commit, all postmaster child processes, including all the aux processes, have an entry. We now maintain separate free-lists for different kinds of backends. That ensures that there are always slots available for autovacuum and background workers. Previously, pre-authorization backends could prevent autovacuum or background workers from starting up, by using up all the slots. The code to manage the slots in the postmaster process is in a new pmchild.c source file. Because postmaster.c is just so large. Assigning pmsignal slot numbers is now pmchild.c's responsibility. This replaces the PMChildInUse array in pmsignal.c. --- src/backend/postmaster/Makefile | 1 + src/backend/postmaster/launch_backend.c | 1 + src/backend/postmaster/meson.build | 1 + src/backend/postmaster/pmchild.c | 287 ++++++++++ src/backend/postmaster/postmaster.c | 708 ++++++++++-------------- src/backend/storage/ipc/pmsignal.c | 83 +-- src/backend/storage/lmgr/proc.c | 12 +- src/include/postmaster/postmaster.h | 40 ++ src/include/storage/pmsignal.h | 2 +- src/tools/pgindent/typedefs.list | 2 +- 10 files changed, 654 insertions(+), 483 deletions(-) create mode 100644 src/backend/postmaster/pmchild.c diff --git a/src/backend/postmaster/Makefile b/src/backend/postmaster/Makefile index db08543d19..c977d91785 100644 --- a/src/backend/postmaster/Makefile +++ b/src/backend/postmaster/Makefile @@ -23,6 +23,7 @@ OBJS = \ launch_backend.o \ pgarch.o \ postmaster.o \ + pmchild.o \ startup.o \ syslogger.o \ walsummarizer.o \ diff --git a/src/backend/postmaster/launch_backend.c b/src/backend/postmaster/launch_backend.c index 0ae23fdf55..b0b91dc97f 100644 --- a/src/backend/postmaster/launch_backend.c +++ b/src/backend/postmaster/launch_backend.c @@ -182,6 +182,7 @@ static child_process_kind child_process_kinds[] = { [B_INVALID] = {"invalid", NULL, false}, [B_BACKEND] = {"backend", BackendMain, true}, + [B_DEAD_END_BACKEND] = {"dead-end backend", BackendMain, true}, [B_AUTOVAC_LAUNCHER] = {"autovacuum launcher", AutoVacLauncherMain, true}, [B_AUTOVAC_WORKER] = {"autovacuum worker", AutoVacWorkerMain, true}, [B_BG_WORKER] = {"bgworker", BackgroundWorkerMain, true}, diff --git a/src/backend/postmaster/meson.build b/src/backend/postmaster/meson.build index 0ea4bbe084..388848bb52 100644 --- a/src/backend/postmaster/meson.build +++ b/src/backend/postmaster/meson.build @@ -11,6 +11,7 @@ backend_sources += files( 'launch_backend.c', 'pgarch.c', 'postmaster.c', + 'pmchild.c', 'startup.c', 'syslogger.c', 'walsummarizer.c', diff --git a/src/backend/postmaster/pmchild.c b/src/backend/postmaster/pmchild.c new file mode 100644 index 0000000000..735c66f8e7 --- /dev/null +++ b/src/backend/postmaster/pmchild.c @@ -0,0 +1,287 @@ +/*------------------------------------------------------------------------- + * + * pmchild.c + * Functions for keeping track of postmaster child processes. + * + * Keep track of all child processes, so that when a process exits, we know + * kind of a process it was and can clean up accordingly. Every child process + * is allocated a PMChild struct, from a fixed pool of structs. The size of + * the pool is determined by various settings that configure how many worker + * processes and backend connections are allowed, i.e. autovacuum_max_workers, + * max_worker_processes, max_wal_senders, and max_connections. + * + * The structures and functions in this file are private to the postmaster + * process. But note that there is an array in shared memory, managed by + * pmsignal.c, that mirrors this. + * + * + * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * IDENTIFICATION + * src/backend/postmaster/pmchild.c + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "miscadmin.h" +#include "postmaster/autovacuum.h" +#include "postmaster/postmaster.h" +#include "replication/walsender.h" +#include "storage/pmsignal.h" +#include "storage/proc.h" + +/* + * Freelists for different kinds of child processes. We maintain separate + * pools for them, so that launching a lot of backends cannot exchaust all the + * slots, and prevent autovacuum or an aux process from launching. + */ +static dlist_head freeBackendList; +static dlist_head freeAutoVacWorkerList; +static dlist_head freeBgWorkerList; +static dlist_head freeAuxList; + +/* + * List of active child processes. This includes dead-end children. + */ +dlist_head ActiveChildList; + +/* + * MaxLivePostmasterChildren + * + * This reports the number postmaster child processes that can be active. It + * includes all children except for dead_end children. This allows the array + * in shared memory (PMChildFlags) to have a fixed maximum size. + */ +int +MaxLivePostmasterChildren(void) +{ + int n = 0; + + /* We know exactly how mamy worker and aux processes can be active */ + n += autovacuum_max_workers; + n += max_worker_processes; + n += NUM_AUXILIARY_PROCS; + + /* + * We allow more connections here than we can have backends because some + * might still be authenticating; they might fail auth, or some existing + * backend might exit before the auth cycle is completed. The exact + * MaxBackends limit is enforced when a new backend tries to join the + * shared-inval backend array. + */ + n += 2 * (MaxConnections + max_wal_senders); + + return n; +} + +static void +init_slot(PMChild *pmchild, int slotno, dlist_head *freelist) +{ + pmchild->pid = 0; + pmchild->child_slot = slotno + 1; + pmchild->bkend_type = B_INVALID; + pmchild->rw = NULL; + pmchild->bgworker_notify = false; + dlist_push_tail(freelist, &pmchild->elem); +} + +/* + * Initialize at postmaster startup + */ +void +InitPostmasterChildSlots(void) +{ + int num_pmchild_slots; + int slotno; + PMChild *slots; + + dlist_init(&freeBackendList); + dlist_init(&freeAutoVacWorkerList); + dlist_init(&freeBgWorkerList); + dlist_init(&freeAuxList); + dlist_init(&ActiveChildList); + + num_pmchild_slots = MaxLivePostmasterChildren(); + + slots = palloc(num_pmchild_slots * sizeof(PMChild)); + + slotno = 0; + for (int i = 0; i < 2 * (MaxConnections + max_wal_senders); i++) + { + init_slot(&slots[slotno], slotno, &freeBackendList); + slotno++; + } + for (int i = 0; i < autovacuum_max_workers; i++) + { + init_slot(&slots[slotno], slotno, &freeAutoVacWorkerList); + slotno++; + } + for (int i = 0; i < max_worker_processes; i++) + { + init_slot(&slots[slotno], slotno, &freeBgWorkerList); + slotno++; + } + for (int i = 0; i < NUM_AUXILIARY_PROCS; i++) + { + init_slot(&slots[slotno], slotno, &freeAuxList); + slotno++; + } + Assert(slotno == num_pmchild_slots); +} + +/* Return the appropriate free-list for the given backend type */ +static dlist_head * +GetFreeList(BackendType btype) +{ + switch (btype) + { + case B_BACKEND: + case B_BG_WORKER: + case B_WAL_SENDER: + case B_SLOTSYNC_WORKER: + return &freeBackendList; + case B_AUTOVAC_WORKER: + return &freeAutoVacWorkerList; + + /* + * Auxiliary processes. There can be only one of each of these + * running at a time. + */ + case B_AUTOVAC_LAUNCHER: + case B_ARCHIVER: + case B_BG_WRITER: + case B_CHECKPOINTER: + case B_STARTUP: + case B_WAL_RECEIVER: + case B_WAL_SUMMARIZER: + case B_WAL_WRITER: + return &freeAuxList; + + /* + * Logger is not connected to shared memory, and does not have a + * PGPROC entry, but we still allocate a child slot for it. + */ + case B_LOGGER: + return &freeAuxList; + + case B_STANDALONE_BACKEND: + case B_INVALID: + case B_DEAD_END_BACKEND: + break; + } + elog(ERROR, "unexpected BackendType: %d", (int) btype); + return NULL; +} + +/* + * Allocate a PMChild entry for a backend of given type. + * + * The entry is taken from the right pool. + * + * pmchild->child_slot is unique among all active child processes + */ +PMChild * +AssignPostmasterChildSlot(BackendType btype) +{ + dlist_head *freelist; + PMChild *pmchild; + + freelist = GetFreeList(btype); + + if (dlist_is_empty(freelist)) + return NULL; + + pmchild = dlist_container(PMChild, elem, dlist_pop_head_node(freelist)); + pmchild->pid = 0; + pmchild->bkend_type = btype; + pmchild->rw = NULL; + pmchild->bgworker_notify = true; + + /* + * pmchild->child_slot for each entry was initialized when the array of + * slots was allocated. + */ + + dlist_push_head(&ActiveChildList, &pmchild->elem); + + ReservePostmasterChildSlot(pmchild->child_slot); + + /* FIXME: find a more elegant way to pass this */ + MyPMChildSlot = pmchild->child_slot; + + elog(DEBUG2, "assigned pm child slot %d for %s", pmchild->child_slot, PostmasterChildName(btype)); + + return pmchild; +} + +/* + * Release a PMChild slot, after the child process has exited. + * + * Returns true if the child detached cleanly from shared memory, false + * otherwise (see ReleasePostmasterChildSlot). + */ +bool +FreePostmasterChildSlot(PMChild *pmchild) +{ + elog(DEBUG2, "releasing pm child slot %d", pmchild->child_slot); + + dlist_delete(&pmchild->elem); + if (pmchild->bkend_type == B_DEAD_END_BACKEND) + { + pfree(pmchild); + return true; + } + else + { + dlist_head *freelist; + + freelist = GetFreeList(pmchild->bkend_type); + dlist_push_head(freelist, &pmchild->elem); + return ReleasePostmasterChildSlot(pmchild->child_slot); + } +} + +PMChild * +FindPostmasterChildByPid(int pid) +{ + dlist_iter iter; + + dlist_foreach(iter, &ActiveChildList) + { + PMChild *bp = dlist_container(PMChild, elem, iter.cur); + + if (bp->pid == pid) + return bp; + } + return NULL; +} + +/* + * Allocate a PMChild struct for a dead-end backend. Dead-end children are + * not assigned a child_slot number. The struct is palloc'd; returns NULL if + * out of memory. + */ +PMChild * +AllocDeadEndChild(void) +{ + PMChild *pmchild; + + elog(DEBUG2, "allocating dead-end child"); + + pmchild = (PMChild *) palloc_extended(sizeof(PMChild), MCXT_ALLOC_NO_OOM); + if (pmchild) + { + pmchild->pid = 0; + pmchild->child_slot = 0; + pmchild->bkend_type = B_DEAD_END_BACKEND; + pmchild->rw = NULL; + pmchild->bgworker_notify = false; + + dlist_push_head(&ActiveChildList, &pmchild->elem); + } + + return pmchild; +} diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 99c588ee0b..a029e28786 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -135,49 +135,8 @@ #define BACKEND_TYPE_ALL 0xffffffff StaticAssertDecl(BACKEND_NUM_TYPES < 32, "too many backend types for uint32"); -/* - * List of active backends (or child processes anyway; we don't actually - * know whether a given child has become a backend or is still in the - * authorization phase). This is used mainly to keep track of how many - * children we have and send them appropriate signals when necessary. - * - * As shown in the above set of backend types, this list includes not only - * "normal" client sessions, but also autovacuum workers, walsenders, and - * background workers. (Note that at the time of launch, walsenders are - * labeled B_BACKEND; we relabel them to B_WAL_SENDER - * upon noticing they've changed their PMChildFlags entry. Hence that check - * must be done before any operation that needs to distinguish walsenders - * from normal backends.) - * - * Also, "dead_end" children are in it: these are children launched just for - * the purpose of sending a friendly rejection message to a would-be client. - * We must track them because they are attached to shared memory, but we know - * they will never become live backends. dead_end children are not assigned a - * PMChildSlot. dead_end children have bkend_type B_DEAD_END_BACKEND. - * FIXME: a dead-end backend can send query cancel? - * - * "Special" children such as the startup, bgwriter, autovacuum launcher, and - * slot sync worker tasks are not in this list. They are tracked via StartupPID - * and other pid_t variables below. (Thus, there can't be more than one of any - * given "special" child process type. We use BackendList entries for any - * child process there can be more than one of.) - */ -typedef struct bkend -{ - pid_t pid; /* process id of backend */ - int child_slot; /* PMChildSlot for this backend, if any */ - BackendType bkend_type; /* child process flavor, see above */ - RegisteredBgWorker *rw; /* bgworker info, if this is a bgworker */ - bool bgworker_notify; /* gets bgworker start/stop notifications */ - dlist_node elem; /* list link in BackendList */ -} Backend; - -static dlist_head BackendList = DLIST_STATIC_INIT(BackendList); - BackgroundWorker *MyBgworkerEntry = NULL; - - /* The socket number we are listening for connections on */ int PostPortNumber = DEF_PGPORT; @@ -229,17 +188,17 @@ bool remove_temp_files_after_crash = true; bool send_abort_for_crash = false; bool send_abort_for_kill = false; -/* PIDs of special child processes; 0 when not running */ -static pid_t StartupPID = 0, - BgWriterPID = 0, - CheckpointerPID = 0, - WalWriterPID = 0, - WalReceiverPID = 0, - WalSummarizerPID = 0, - AutoVacPID = 0, - PgArchPID = 0, - SysLoggerPID = 0, - SlotSyncWorkerPID = 0; +/* special child processes; NULL when not running */ +static PMChild *StartupPMChild = NULL, + *BgWriterPMChild = NULL, + *CheckpointerPMChild = NULL, + *WalWriterPMChild = NULL, + *WalReceiverPMChild = NULL, + *WalSummarizerPMChild = NULL, + *AutoVacLauncherPMChild = NULL, + *PgArchPMChild = NULL, + *SysLoggerPMChild = NULL, + *SlotSyncWorkerPMChild = NULL; /* Startup process's status */ typedef enum @@ -287,7 +246,7 @@ static bool FatalError = false; /* T if recovering from backend crash */ * PM_HOT_STANDBY state. (connsAllowed can also restrict launching.) * In other states we handle connection requests by launching "dead_end" * child processes, which will simply send the client an error message and - * quit. (We track these in the BackendList so that we can know when they + * quit. (We track these in the ActiveChildList so that we can know when they * are all gone; this is important because they're still connected to shared * memory, and would interfere with an attempt to destroy the shmem segment, * possibly leading to SHMALL failure when we try to make a new one.) @@ -393,7 +352,7 @@ static void process_pm_child_exit(void); static void process_pm_reload_request(void); static void process_pm_shutdown_request(void); static void dummy_handler(SIGNAL_ARGS); -static void CleanupBackend(Backend *bp, int exitstatus); +static void CleanupBackend(PMChild *bp, int exitstatus); static void HandleChildCrash(int pid, int exitstatus, const char *procname); static void LogChildExit(int lev, const char *procname, int pid, int exitstatus); @@ -403,18 +362,18 @@ static void ExitPostmaster(int status) pg_attribute_noreturn(); static int ServerLoop(void); static int BackendStartup(ClientSocket *client_sock); static void report_fork_failure_to_client(ClientSocket *client_sock, int errnum); -static CAC_state canAcceptConnections(int backend_type); -static void signal_child(pid_t pid, int signal); -static void sigquit_child(pid_t pid); +static CAC_state canAcceptConnections(BackendType backend_type); +static void signal_child(PMChild *pmchild, int signal); +static void sigquit_child(PMChild *pmchild); static bool SignalSomeChildren(int signal, uint32 targetMask); static void TerminateChildren(int signal); static int CountChildren(uint32 targetMask); -static Backend *assign_backendlist_entry(void); +static PMChild *assign_backendlist_entry(void); static void LaunchMissingBackgroundProcesses(void); static void maybe_start_bgworkers(void); static bool CreateOptsFile(int argc, char *argv[], char *fullprogname); -static pid_t StartChildProcess(BackendType type); +static PMChild *StartChildProcess(BackendType type); static void StartAutovacuumWorker(void); static void InitPostmasterDeathWatchHandle(void); @@ -893,9 +852,11 @@ PostmasterMain(int argc, char *argv[]) /* * Now that loadable modules have had their chance to alter any GUCs, - * calculate MaxBackends. + * calculate MaxBackends, and initialize the machinery to track child + * processes. */ InitializeMaxBackends(); + InitPostmasterChildSlots(); /* * Give preloaded libraries a chance to request additional shared memory. @@ -1019,7 +980,15 @@ PostmasterMain(int argc, char *argv[]) /* * If enabled, start up syslogger collection subprocess */ - SysLoggerPID = SysLogger_Start(); + SysLoggerPMChild = AssignPostmasterChildSlot(B_LOGGER); + if (!SysLoggerPMChild) + elog(ERROR, "no postmaster child slot available for syslogger"); + SysLoggerPMChild->pid = SysLogger_Start(); + if (SysLoggerPMChild->pid == 0) + { + FreePostmasterChildSlot(SysLoggerPMChild); + SysLoggerPMChild = NULL; + } /* * Reset whereToSendOutput from DestDebug (its starting state) to @@ -1321,16 +1290,16 @@ PostmasterMain(int argc, char *argv[]) AddToDataDirLockFile(LOCK_FILE_LINE_PM_STATUS, PM_STATUS_STARTING); /* Start bgwriter and checkpointer so they can help with recovery */ - if (CheckpointerPID == 0) - CheckpointerPID = StartChildProcess(B_CHECKPOINTER); - if (BgWriterPID == 0) - BgWriterPID = StartChildProcess(B_BG_WRITER); + if (CheckpointerPMChild == NULL) + CheckpointerPMChild = StartChildProcess(B_CHECKPOINTER); + if (BgWriterPMChild == NULL) + BgWriterPMChild = StartChildProcess(B_BG_WRITER); /* * We're ready to rock and roll... */ - StartupPID = StartChildProcess(B_STARTUP); - Assert(StartupPID != 0); + StartupPMChild = StartChildProcess(B_STARTUP); + Assert(StartupPMChild != NULL); StartupStatus = STARTUP_RUNNING; pmState = PM_STARTUP; @@ -1660,8 +1629,8 @@ ServerLoop(void) if (avlauncher_needs_signal) { avlauncher_needs_signal = false; - if (AutoVacPID != 0) - kill(AutoVacPID, SIGUSR2); + if (AutoVacLauncherPMChild != NULL) + kill(AutoVacLauncherPMChild->pid, SIGUSR2); } #ifdef HAVE_PTHREAD_IS_THREADED_NP @@ -1748,7 +1717,7 @@ ServerLoop(void) * know whether a NORMAL connection might turn into a walsender.) */ static CAC_state -canAcceptConnections(int backend_type) +canAcceptConnections(BackendType backend_type) { CAC_state result = CAC_OK; @@ -1779,21 +1748,6 @@ canAcceptConnections(int backend_type) if (!connsAllowed && backend_type == B_BACKEND) return CAC_SHUTDOWN; /* shutdown is pending */ - /* - * Don't start too many children. - * - * We allow more connections here than we can have backends because some - * might still be authenticating; they might fail auth, or some existing - * backend might exit before the auth cycle is completed. The exact - * MaxBackends limit is enforced when a new backend tries to join the - * shared-inval backend array. - * - * The limit here must match the sizes of the per-child-process arrays; - * see comments for MaxLivePostmasterChildren(). - */ - if (CountChildren(BACKEND_TYPE_ALL & ~(1 << B_DEAD_END_BACKEND)) >= MaxLivePostmasterChildren()) - result = CAC_TOOMANY; - return result; } @@ -1961,26 +1915,6 @@ process_pm_reload_request(void) (errmsg("received SIGHUP, reloading configuration files"))); ProcessConfigFile(PGC_SIGHUP); SignalSomeChildren(SIGHUP, BACKEND_TYPE_ALL & ~(1 << B_DEAD_END_BACKEND)); - if (StartupPID != 0) - signal_child(StartupPID, SIGHUP); - if (BgWriterPID != 0) - signal_child(BgWriterPID, SIGHUP); - if (CheckpointerPID != 0) - signal_child(CheckpointerPID, SIGHUP); - if (WalWriterPID != 0) - signal_child(WalWriterPID, SIGHUP); - if (WalReceiverPID != 0) - signal_child(WalReceiverPID, SIGHUP); - if (WalSummarizerPID != 0) - signal_child(WalSummarizerPID, SIGHUP); - if (AutoVacPID != 0) - signal_child(AutoVacPID, SIGHUP); - if (PgArchPID != 0) - signal_child(PgArchPID, SIGHUP); - if (SysLoggerPID != 0) - signal_child(SysLoggerPID, SIGHUP); - if (SlotSyncWorkerPID != 0) - signal_child(SlotSyncWorkerPID, SIGHUP); /* Reload authentication config files too */ if (!load_hba()) @@ -2218,15 +2152,15 @@ process_pm_child_exit(void) while ((pid = waitpid(-1, &exitstatus, WNOHANG)) > 0) { - bool found; - dlist_mutable_iter iter; + PMChild *pmchild; /* * Check if this child was a startup process. */ - if (pid == StartupPID) + if (StartupPMChild && pid == StartupPMChild->pid) { - StartupPID = 0; + FreePostmasterChildSlot(StartupPMChild); + StartupPMChild = NULL; /* * Startup process exited in response to a shutdown request (or it @@ -2337,9 +2271,10 @@ process_pm_child_exit(void) * one at the next iteration of the postmaster's main loop, if * necessary. Any other exit condition is treated as a crash. */ - if (pid == BgWriterPID) + if (BgWriterPMChild && pid == BgWriterPMChild->pid) { - BgWriterPID = 0; + FreePostmasterChildSlot(BgWriterPMChild); + BgWriterPMChild = NULL; if (!EXIT_STATUS_0(exitstatus)) HandleChildCrash(pid, exitstatus, _("background writer process")); @@ -2349,9 +2284,10 @@ process_pm_child_exit(void) /* * Was it the checkpointer? */ - if (pid == CheckpointerPID) + if (CheckpointerPMChild && pid == CheckpointerPMChild->pid) { - CheckpointerPID = 0; + FreePostmasterChildSlot(CheckpointerPMChild); + CheckpointerPMChild = NULL; if (EXIT_STATUS_0(exitstatus) && pmState == PM_SHUTDOWN) { /* @@ -2371,14 +2307,14 @@ process_pm_child_exit(void) Assert(Shutdown > NoShutdown); /* Waken archiver for the last time */ - if (PgArchPID != 0) - signal_child(PgArchPID, SIGUSR2); + if (PgArchPMChild != NULL) + signal_child(PgArchPMChild, SIGUSR2); /* * Waken walsenders for the last time. No regular backends * should be around anymore. */ - SignalSomeChildren(SIGUSR2, BACKEND_TYPE_ALL & (1 << B_DEAD_END_BACKEND)); + SignalSomeChildren(SIGUSR2, (1 << B_WAL_SENDER)); pmState = PM_SHUTDOWN_2; } @@ -2400,9 +2336,10 @@ process_pm_child_exit(void) * new one at the next iteration of the postmaster's main loop, if * necessary. Any other exit condition is treated as a crash. */ - if (pid == WalWriterPID) + if (WalWriterPMChild && pid == WalWriterPMChild->pid) { - WalWriterPID = 0; + FreePostmasterChildSlot(WalWriterPMChild); + WalWriterPMChild = NULL; if (!EXIT_STATUS_0(exitstatus)) HandleChildCrash(pid, exitstatus, _("WAL writer process")); @@ -2415,9 +2352,10 @@ process_pm_child_exit(void) * backends. (If we need a new wal receiver, we'll start one at the * next iteration of the postmaster's main loop.) */ - if (pid == WalReceiverPID) + if (WalReceiverPMChild && pid == WalReceiverPMChild->pid) { - WalReceiverPID = 0; + FreePostmasterChildSlot(WalReceiverPMChild); + WalReceiverPMChild = NULL; if (!EXIT_STATUS_0(exitstatus) && !EXIT_STATUS_1(exitstatus)) HandleChildCrash(pid, exitstatus, _("WAL receiver process")); @@ -2429,9 +2367,10 @@ process_pm_child_exit(void) * a new one at the next iteration of the postmaster's main loop, if * necessary. Any other exit condition is treated as a crash. */ - if (pid == WalSummarizerPID) + if (WalSummarizerPMChild && pid == WalSummarizerPMChild->pid) { - WalSummarizerPID = 0; + FreePostmasterChildSlot(WalSummarizerPMChild); + WalSummarizerPMChild = NULL; if (!EXIT_STATUS_0(exitstatus)) HandleChildCrash(pid, exitstatus, _("WAL summarizer process")); @@ -2444,9 +2383,10 @@ process_pm_child_exit(void) * loop, if necessary. Any other exit condition is treated as a * crash. */ - if (pid == AutoVacPID) + if (AutoVacLauncherPMChild && pid == AutoVacLauncherPMChild->pid) { - AutoVacPID = 0; + FreePostmasterChildSlot(AutoVacLauncherPMChild); + AutoVacLauncherPMChild = NULL; if (!EXIT_STATUS_0(exitstatus)) HandleChildCrash(pid, exitstatus, _("autovacuum launcher process")); @@ -2459,9 +2399,10 @@ process_pm_child_exit(void) * and just try to start a new one on the next cycle of the * postmaster's main loop, to retry archiving remaining files. */ - if (pid == PgArchPID) + if (PgArchPMChild && pid == PgArchPMChild->pid) { - PgArchPID = 0; + FreePostmasterChildSlot(PgArchPMChild); + PgArchPMChild = NULL; if (!EXIT_STATUS_0(exitstatus) && !EXIT_STATUS_1(exitstatus)) HandleChildCrash(pid, exitstatus, _("archiver process")); @@ -2469,11 +2410,15 @@ process_pm_child_exit(void) } /* Was it the system logger? If so, try to start a new one */ - if (pid == SysLoggerPID) + if (SysLoggerPMChild && pid == SysLoggerPMChild->pid) { - SysLoggerPID = 0; /* for safety's sake, launch new logger *first* */ - SysLoggerPID = SysLogger_Start(); + SysLoggerPMChild->pid = SysLogger_Start(); + if (SysLoggerPMChild->pid == 0) + { + FreePostmasterChildSlot(SysLoggerPMChild); + SysLoggerPMChild = NULL; + } if (!EXIT_STATUS_0(exitstatus)) LogChildExit(LOG, _("system logger process"), pid, exitstatus); @@ -2487,9 +2432,10 @@ process_pm_child_exit(void) * start a new one at the next iteration of the postmaster's main * loop, if necessary. Any other exit condition is treated as a crash. */ - if (pid == SlotSyncWorkerPID) + if (SlotSyncWorkerPMChild && pid == SlotSyncWorkerPMChild->pid) { - SlotSyncWorkerPID = 0; + FreePostmasterChildSlot(SlotSyncWorkerPMChild); + SlotSyncWorkerPMChild = NULL; if (!EXIT_STATUS_0(exitstatus) && !EXIT_STATUS_1(exitstatus)) HandleChildCrash(pid, exitstatus, _("slot sync worker process")); @@ -2499,25 +2445,17 @@ process_pm_child_exit(void) /* * Was it a backend or a background worker? */ - found = false; - dlist_foreach_modify(iter, &BackendList) + pmchild = FindPostmasterChildByPid(pid); + if (pmchild) { - Backend *bp = dlist_container(Backend, elem, iter.cur); - - if (bp->pid == pid) - { - dlist_delete(iter.cur); - CleanupBackend(bp, exitstatus); - found = true; - break; - } + CleanupBackend(pmchild, exitstatus); } /* * We don't know anything about this child process. That's highly * unexpected, as we do track all the child processes that we fork. */ - if (!found) + else { if (!EXIT_STATUS_0(exitstatus) && !EXIT_STATUS_1(exitstatus)) HandleChildCrash(pid, exitstatus, _("untracked child process")); @@ -2540,15 +2478,24 @@ process_pm_child_exit(void) * already been unlinked from BackendList, but we will free it here. */ static void -CleanupBackend(Backend *bp, +CleanupBackend(PMChild *bp, int exitstatus) /* child's exit status. */ { char namebuf[MAXPGPATH]; char *procname; bool crashed = false; bool logged = false; + pid_t bp_pid; + bool bp_bgworker_notify; + BackendType bp_bkend_type; + RegisteredBgWorker *rw; /* Construct a process name for log message */ + + /* + * FIXME: use GetBackendTypeDesc here? How does the localization of that + * work? + */ if (bp->bkend_type == B_DEAD_END_BACKEND) { procname = _("dead end backend"); @@ -2589,25 +2536,28 @@ CleanupBackend(Backend *bp, #endif /* - * If the process attached to shared memory, check that it detached - * cleanly. + * Release the PMChild entry. + * + * If the process attached to shared memory, this also checks that it + * detached cleanly. */ - if (bp->bkend_type != B_DEAD_END_BACKEND) + bp_pid = bp->pid; + bp_bgworker_notify = bp->bgworker_notify; + bp_bkend_type = bp->bkend_type; + rw = bp->rw; + if (!FreePostmasterChildSlot(bp)) { - if (!ReleasePostmasterChildSlot(bp->child_slot)) - { - /* - * Uh-oh, the child failed to clean itself up. Treat as a crash - * after all. - */ - crashed = true; - } + /* + * Uh-oh, the child failed to clean itself up. Treat as a crash after + * all. + */ + crashed = true; } + bp = NULL; if (crashed) { - HandleChildCrash(bp->pid, exitstatus, namebuf); - pfree(bp); + HandleChildCrash(bp_pid, exitstatus, namebuf); return; } @@ -2618,16 +2568,14 @@ CleanupBackend(Backend *bp, * gets skipped in the (probably very common) case where the backend has * never requested any such notifications. */ - if (bp->bgworker_notify) - BackgroundWorkerStopNotifications(bp->pid); + if (bp_bgworker_notify) + BackgroundWorkerStopNotifications(bp_pid); /* * If it was a background worker, also update its RegisteredWorker entry. */ - if (bp->bkend_type == B_BG_WORKER) + if (bp_bkend_type == B_BG_WORKER) { - RegisteredBgWorker *rw = bp->rw; - if (!EXIT_STATUS_0(exitstatus)) { /* Record timestamp, so we know when to restart the worker. */ @@ -2646,7 +2594,7 @@ CleanupBackend(Backend *bp, if (!logged) { LogChildExit(EXIT_STATUS_0(exitstatus) ? DEBUG1 : LOG, - procname, bp->pid, exitstatus); + procname, bp_pid, exitstatus); logged = true; } @@ -2655,9 +2603,7 @@ CleanupBackend(Backend *bp, } if (!logged) - LogChildExit(DEBUG2, procname, bp->pid, exitstatus); - - pfree(bp); + LogChildExit(DEBUG2, procname, bp_pid, exitstatus); } /* @@ -2697,9 +2643,16 @@ HandleChildCrash(int pid, int exitstatus, const char *procname) { dlist_iter iter; - dlist_foreach(iter, &BackendList) + dlist_foreach(iter, &ActiveChildList) { - Backend *bp = dlist_container(Backend, elem, iter.cur); + PMChild *bp = dlist_container(PMChild, elem, iter.cur); + + /* We do NOT restart the syslogger */ + if (bp == SysLoggerPMChild) + continue; + + if (bp == StartupPMChild) + StartupStatus = STARTUP_SIGNALED; /* * This backend is still alive. Unless we did so already, tell it @@ -2708,48 +2661,8 @@ HandleChildCrash(int pid, int exitstatus, const char *procname) * We could exclude dead_end children here, but at least when * sending SIGABRT it seems better to include them. */ - sigquit_child(bp->pid); + sigquit_child(bp); } - - if (StartupPID != 0) - { - sigquit_child(StartupPID); - StartupStatus = STARTUP_SIGNALED; - } - - /* Take care of the bgwriter too */ - if (BgWriterPID != 0) - sigquit_child(BgWriterPID); - - /* Take care of the checkpointer too */ - if (CheckpointerPID != 0) - sigquit_child(CheckpointerPID); - - /* Take care of the walwriter too */ - if (WalWriterPID != 0) - sigquit_child(WalWriterPID); - - /* Take care of the walreceiver too */ - if (WalReceiverPID != 0) - sigquit_child(WalReceiverPID); - - /* Take care of the walsummarizer too */ - if (WalSummarizerPID != 0) - sigquit_child(WalSummarizerPID); - - /* Take care of the autovacuum launcher too */ - if (AutoVacPID != 0) - sigquit_child(AutoVacPID); - - /* Take care of the archiver too */ - if (PgArchPID != 0) - sigquit_child(PgArchPID); - - /* Take care of the slot sync worker too */ - if (SlotSyncWorkerPID != 0) - sigquit_child(SlotSyncWorkerPID); - - /* We do NOT restart the syslogger */ } if (Shutdown != ImmediateShutdown) @@ -2864,6 +2777,8 @@ PostmasterStateMachine(void) */ if (pmState == PM_STOP_BACKENDS) { + uint32 targetMask; + /* * Forget any pending requests for background workers, since we're no * longer willing to launch any new workers. (If additional requests @@ -2871,29 +2786,27 @@ PostmasterStateMachine(void) */ ForgetUnstartedBackgroundWorkers(); - /* Signal all backend children except walsenders and dead-end backends */ - SignalSomeChildren(SIGTERM, - BACKEND_TYPE_ALL & ~(1 << B_WAL_SENDER | 1 << B_DEAD_END_BACKEND)); + /* Signal all backend children except walsenders */ + /* dead-end children are not signalled yet */ + targetMask = (1 << B_BACKEND); + targetMask |= (1 << B_BG_WORKER); + /* and the autovac launcher too */ - if (AutoVacPID != 0) - signal_child(AutoVacPID, SIGTERM); + targetMask |= (1 << B_AUTOVAC_LAUNCHER); /* and the bgwriter too */ - if (BgWriterPID != 0) - signal_child(BgWriterPID, SIGTERM); + targetMask |= (1 << B_BG_WRITER); /* and the walwriter too */ - if (WalWriterPID != 0) - signal_child(WalWriterPID, SIGTERM); + targetMask |= (1 << B_WAL_WRITER); /* If we're in recovery, also stop startup and walreceiver procs */ - if (StartupPID != 0) - signal_child(StartupPID, SIGTERM); - if (WalReceiverPID != 0) - signal_child(WalReceiverPID, SIGTERM); - if (WalSummarizerPID != 0) - signal_child(WalSummarizerPID, SIGTERM); - if (SlotSyncWorkerPID != 0) - signal_child(SlotSyncWorkerPID, SIGTERM); + targetMask |= (1 << B_STARTUP); + targetMask |= (1 << B_WAL_RECEIVER); + + targetMask |= (1 << B_WAL_SUMMARIZER); + targetMask |= (1 << B_SLOTSYNC_WORKER); /* checkpointer, archiver, stats, and syslogger may continue for now */ + SignalSomeChildren(SIGTERM, targetMask); + /* Now transition to PM_WAIT_BACKENDS state to wait for them to die */ pmState = PM_WAIT_BACKENDS; } @@ -2915,16 +2828,14 @@ PostmasterStateMachine(void) * here. Walsenders and archiver are also disregarded, they will be * terminated later after writing the checkpoint record. */ - if (CountChildren(BACKEND_TYPE_ALL & ~(1 << B_WAL_SENDER | 1 << B_DEAD_END_BACKEND)) == 0 && - StartupPID == 0 && - WalReceiverPID == 0 && - WalSummarizerPID == 0 && - BgWriterPID == 0 && - (CheckpointerPID == 0 || - (!FatalError && Shutdown < ImmediateShutdown)) && - WalWriterPID == 0 && - AutoVacPID == 0 && - SlotSyncWorkerPID == 0) + uint32 remaining; + + remaining = (1 << B_WAL_SENDER) | (1 << B_ARCHIVER) | (1 << B_LOGGER); + remaining |= (1 << B_DEAD_END_BACKEND); + if (!FatalError && Shutdown < ImmediateShutdown) + remaining |= (1 << B_CHECKPOINTER); + + if (CountChildren(BACKEND_TYPE_ALL & ~remaining) == 0) { if (Shutdown >= ImmediateShutdown || FatalError) { @@ -2950,12 +2861,12 @@ PostmasterStateMachine(void) */ Assert(Shutdown > NoShutdown); /* Start the checkpointer if not running */ - if (CheckpointerPID == 0) - CheckpointerPID = StartChildProcess(B_CHECKPOINTER); + if (CheckpointerPMChild == NULL) + CheckpointerPMChild = StartChildProcess(B_CHECKPOINTER); /* And tell it to shut down */ - if (CheckpointerPID != 0) + if (CheckpointerPMChild != NULL) { - signal_child(CheckpointerPID, SIGUSR2); + signal_child(CheckpointerPMChild, SIGUSR2); pmState = PM_SHUTDOWN; } else @@ -2976,8 +2887,8 @@ PostmasterStateMachine(void) /* Kill the walsenders and archiver, too */ SignalSomeChildren(SIGQUIT, BACKEND_TYPE_ALL); - if (PgArchPID != 0) - signal_child(PgArchPID, SIGQUIT); + if (PgArchPMChild != NULL) + signal_child(PgArchPMChild, SIGQUIT); } } } @@ -2991,7 +2902,10 @@ PostmasterStateMachine(void) * left by now anyway; what we're really waiting for is walsenders and * archiver. */ - if (PgArchPID == 0 && CountChildren(BACKEND_TYPE_ALL & ~(1 << B_DEAD_END_BACKEND)) == 0) + uint32 remaining; + + remaining = (1 << B_LOGGER) | (1 << B_DEAD_END_BACKEND); + if (CountChildren(BACKEND_TYPE_ALL & ~remaining) == 0) { ConfigurePostmasterWaitSet(false); SignalSomeChildren(SIGTERM, 1 << B_DEAD_END_BACKEND); @@ -3013,17 +2927,20 @@ PostmasterStateMachine(void) * normal state transition leading up to PM_WAIT_DEAD_END, or during * FatalError processing. */ - if (dlist_is_empty(&BackendList) && PgArchPID == 0) + if (dlist_is_empty(&ActiveChildList) || + (SysLoggerPMChild != NULL && + dlist_head_node(&ActiveChildList) == &SysLoggerPMChild->elem && + dlist_tail_node(&ActiveChildList) == &SysLoggerPMChild->elem)) { /* These other guys should be dead already */ - Assert(StartupPID == 0); - Assert(WalReceiverPID == 0); - Assert(WalSummarizerPID == 0); - Assert(BgWriterPID == 0); - Assert(CheckpointerPID == 0); - Assert(WalWriterPID == 0); - Assert(AutoVacPID == 0); - Assert(SlotSyncWorkerPID == 0); + Assert(StartupPMChild == NULL); + Assert(WalReceiverPMChild == NULL); + Assert(WalSummarizerPMChild == NULL); + Assert(BgWriterPMChild == NULL); + Assert(CheckpointerPMChild == NULL); + Assert(WalWriterPMChild == NULL); + Assert(AutoVacLauncherPMChild == NULL); + Assert(SlotSyncWorkerPMChild == NULL); /* syslogger is not considered here */ pmState = PM_NO_CHILDREN; } @@ -3106,8 +3023,8 @@ PostmasterStateMachine(void) /* re-create shared memory and semaphores */ CreateSharedMemoryAndSemaphores(); - StartupPID = StartChildProcess(B_STARTUP); - Assert(StartupPID != 0); + StartupPMChild = StartChildProcess(B_STARTUP); + Assert(StartupPMChild != NULL); StartupStatus = STARTUP_RUNNING; pmState = PM_STARTUP; /* crash recovery started, reset SIGKILL flag */ @@ -3130,8 +3047,21 @@ static void LaunchMissingBackgroundProcesses(void) { /* Syslogger is active in all states */ - if (SysLoggerPID == 0 && Logging_collector) - SysLoggerPID = SysLogger_Start(); + if (SysLoggerPMChild == NULL && Logging_collector) + { + SysLoggerPMChild = AssignPostmasterChildSlot(B_LOGGER); + if (!SysLoggerPMChild) + elog(LOG, "no postmaster child slot available for syslogger"); + else + { + SysLoggerPMChild->pid = SysLogger_Start(); + if (SysLoggerPMChild->pid == 0) + { + FreePostmasterChildSlot(SysLoggerPMChild); + SysLoggerPMChild = NULL; + } + } + } /* * The checkpointer and the background writer are active from the start, @@ -3144,30 +3074,30 @@ LaunchMissingBackgroundProcesses(void) if (pmState == PM_RUN || pmState == PM_RECOVERY || pmState == PM_HOT_STANDBY || pmState == PM_STARTUP) { - if (CheckpointerPID == 0) - CheckpointerPID = StartChildProcess(B_CHECKPOINTER); - if (BgWriterPID == 0) - BgWriterPID = StartChildProcess(B_BG_WRITER); + if (CheckpointerPMChild == NULL) + CheckpointerPMChild = StartChildProcess(B_CHECKPOINTER); + if (BgWriterPMChild == NULL) + BgWriterPMChild = StartChildProcess(B_BG_WRITER); } /* * WAL writer is needed only in normal operation (else we cannot be * writing any new WAL). */ - if (WalWriterPID == 0 && pmState == PM_RUN) - WalWriterPID = StartChildProcess(B_WAL_WRITER); + if (WalWriterPMChild == NULL && pmState == PM_RUN) + WalWriterPMChild = StartChildProcess(B_WAL_WRITER); /* * We don't want autovacuum to run in binary upgrade mode because * autovacuum might update relfrozenxid for empty tables before the * physical files are put in place. */ - if (!IsBinaryUpgrade && AutoVacPID == 0 && + if (!IsBinaryUpgrade && AutoVacLauncherPMChild == NULL && (AutoVacuumingActive() || start_autovac_launcher) && pmState == PM_RUN) { - AutoVacPID = StartChildProcess(B_AUTOVAC_LAUNCHER); - if (AutoVacPID != 0) + AutoVacLauncherPMChild = StartChildProcess(B_AUTOVAC_LAUNCHER); + if (AutoVacLauncherPMChild != NULL) start_autovac_launcher = false; /* signal processed */ } @@ -3175,11 +3105,11 @@ LaunchMissingBackgroundProcesses(void) * If WAL archiving is enabled always, we are allowed to start archiver * even during recovery. */ - if (PgArchPID == 0 && + if (PgArchPMChild == NULL && ((XLogArchivingActive() && pmState == PM_RUN) || (XLogArchivingAlways() && (pmState == PM_RECOVERY || pmState == PM_HOT_STANDBY))) && PgArchCanRestart()) - PgArchPID = StartChildProcess(B_ARCHIVER); + PgArchPMChild = StartChildProcess(B_ARCHIVER); /* * If we need to start a slot sync worker, try to do that now @@ -3189,10 +3119,10 @@ LaunchMissingBackgroundProcesses(void) * configured correctly, and it is the first time of worker's launch, or * enough time has passed since the worker was launched last. */ - if (SlotSyncWorkerPID == 0 && pmState == PM_HOT_STANDBY && + if (SlotSyncWorkerPMChild == NULL && pmState == PM_HOT_STANDBY && Shutdown <= SmartShutdown && sync_replication_slots && ValidateSlotSyncParams(LOG) && SlotSyncWorkerCanRestart()) - SlotSyncWorkerPID = StartChildProcess(B_SLOTSYNC_WORKER); + SlotSyncWorkerPMChild = StartChildProcess(B_SLOTSYNC_WORKER); /* * If we need to start a WAL receiver, try to do that now @@ -3208,23 +3138,23 @@ LaunchMissingBackgroundProcesses(void) */ if (WalReceiverRequested) { - if (WalReceiverPID == 0 && + if (WalReceiverPMChild == NULL && (pmState == PM_STARTUP || pmState == PM_RECOVERY || pmState == PM_HOT_STANDBY) && Shutdown <= SmartShutdown) { - WalReceiverPID = StartChildProcess(B_WAL_RECEIVER); - if (WalReceiverPID != 0) + WalReceiverPMChild = StartChildProcess(B_WAL_RECEIVER); + if (WalReceiverPMChild != 0) WalReceiverRequested = false; /* else leave the flag set, so we'll try again later */ } } /* If we need to start a WAL summarizer, try to do that now */ - if (summarize_wal && WalSummarizerPID == 0 && + if (summarize_wal && WalSummarizerPMChild == NULL && (pmState == PM_RUN || pmState == PM_HOT_STANDBY) && Shutdown <= SmartShutdown) - WalSummarizerPID = StartChildProcess(B_WAL_SUMMARIZER); + WalSummarizerPMChild = StartChildProcess(B_WAL_SUMMARIZER); /* Get other worker processes running, if needed */ if (StartWorkerNeeded || HaveCrashedWorker) @@ -3248,8 +3178,14 @@ LaunchMissingBackgroundProcesses(void) * child twice will not cause any problems. */ static void -signal_child(pid_t pid, int signal) +signal_child(PMChild *pmchild, int signal) { + pid_t pid; + + if (pmchild == NULL || pmchild->pid == 0) + return; + pid = pmchild->pid; + if (kill(pid, signal) < 0) elog(DEBUG3, "kill(%ld,%d) failed: %m", (long) pid, signal); #ifdef HAVE_SETSID @@ -3278,13 +3214,13 @@ signal_child(pid_t pid, int signal) * to use SIGABRT to collect per-child core dumps. */ static void -sigquit_child(pid_t pid) +sigquit_child(PMChild *pmchild) { ereport(DEBUG2, (errmsg_internal("sending %s to process %d", (send_abort_for_crash ? "SIGABRT" : "SIGQUIT"), - (int) pid))); - signal_child(pid, (send_abort_for_crash ? SIGABRT : SIGQUIT)); + (int) pmchild->pid))); + signal_child(pmchild, (send_abort_for_crash ? SIGABRT : SIGQUIT)); } /* @@ -3296,13 +3232,13 @@ SignalSomeChildren(int signal, uint32 targetMask) dlist_iter iter; bool signaled = false; - dlist_foreach(iter, &BackendList) + dlist_foreach(iter, &ActiveChildList) { - Backend *bp = dlist_container(Backend, elem, iter.cur); + PMChild *bp = dlist_container(PMChild, elem, iter.cur); /* - * Since target == BACKEND_TYPE_ALL is the most common case, we test - * it first and avoid touching shared memory for every child. + * Since targetMask == BACKEND_TYPE_ALL is the most common case, we + * test it first and avoid touching shared memory for every child. */ if (targetMask != BACKEND_TYPE_ALL) { @@ -3321,7 +3257,7 @@ SignalSomeChildren(int signal, uint32 targetMask) ereport(DEBUG4, (errmsg_internal("sending signal %d to %s process %d", signal, GetBackendTypeDesc(bp->bkend_type), (int) bp->pid))); - signal_child(bp->pid, signal); + signal_child(bp, signal); signaled = true; } return signaled; @@ -3334,29 +3270,12 @@ SignalSomeChildren(int signal, uint32 targetMask) static void TerminateChildren(int signal) { - SignalSomeChildren(signal, BACKEND_TYPE_ALL); - if (StartupPID != 0) + SignalSomeChildren(signal, BACKEND_TYPE_ALL & ~(1 << B_LOGGER)); + if (StartupPMChild != NULL) { - signal_child(StartupPID, signal); if (signal == SIGQUIT || signal == SIGKILL || signal == SIGABRT) StartupStatus = STARTUP_SIGNALED; } - if (BgWriterPID != 0) - signal_child(BgWriterPID, signal); - if (CheckpointerPID != 0) - signal_child(CheckpointerPID, signal); - if (WalWriterPID != 0) - signal_child(WalWriterPID, signal); - if (WalReceiverPID != 0) - signal_child(WalReceiverPID, signal); - if (WalSummarizerPID != 0) - signal_child(WalSummarizerPID, signal); - if (AutoVacPID != 0) - signal_child(AutoVacPID, signal); - if (PgArchPID != 0) - signal_child(PgArchPID, signal); - if (SlotSyncWorkerPID != 0) - signal_child(SlotSyncWorkerPID, signal); } /* @@ -3369,45 +3288,45 @@ TerminateChildren(int signal) static int BackendStartup(ClientSocket *client_sock) { - Backend *bn; /* for backend cleanup */ + PMChild *bn = NULL; pid_t pid; BackendStartupData startup_data; + CAC_state cac; - /* - * Create backend data structure. Better before the fork() so we can - * handle failure cleanly. - */ - bn = (Backend *) palloc_extended(sizeof(Backend), MCXT_ALLOC_NO_OOM); + cac = canAcceptConnections(B_BACKEND); + if (cac == CAC_OK) + { + bn = AssignPostmasterChildSlot(B_BACKEND); + if (!bn) + { + /* + * Too many regular child processes; launch a dead-end child + * process instead. + */ + cac = CAC_TOOMANY; + } + } if (!bn) { - ereport(LOG, - (errcode(ERRCODE_OUT_OF_MEMORY), - errmsg("out of memory"))); - return STATUS_ERROR; + bn = AllocDeadEndChild(); + if (!bn) + { + ereport(LOG, + (errcode(ERRCODE_OUT_OF_MEMORY), + errmsg("out of memory"))); + return STATUS_ERROR; + } } /* Pass down canAcceptConnections state */ - startup_data.canAcceptConnections = canAcceptConnections(B_BACKEND); + startup_data.canAcceptConnections = cac; bn->rw = NULL; - /* - * Unless it's a dead_end child, assign it a child slot number - */ - if (startup_data.canAcceptConnections == CAC_OK) - { - bn->bkend_type = B_BACKEND; /* Can change later to WALSND */ - bn->child_slot = MyPMChildSlot = AssignPostmasterChildSlot(); - } - else - { - bn->bkend_type = B_DEAD_END_BACKEND; - bn->child_slot = 0; - } - /* Hasn't asked to be notified about any bgworkers yet */ bn->bgworker_notify = false; - pid = postmaster_child_launch(B_BACKEND, + MyPMChildSlot = bn->child_slot; + pid = postmaster_child_launch(bn->bkend_type, (char *) &startup_data, sizeof(startup_data), client_sock); if (pid < 0) @@ -3415,9 +3334,7 @@ BackendStartup(ClientSocket *client_sock) /* in parent, fork failed */ int save_errno = errno; - if (bn->child_slot != 0) - (void) ReleasePostmasterChildSlot(bn->child_slot); - pfree(bn); + (void) FreePostmasterChildSlot(bn); errno = save_errno; ereport(LOG, (errmsg("could not fork new process for connection: %m"))); @@ -3435,7 +3352,6 @@ BackendStartup(ClientSocket *client_sock) * of backends. */ bn->pid = pid; - dlist_push_head(&BackendList, &bn->elem); return STATUS_OK; } @@ -3534,9 +3450,9 @@ process_pm_pmsignal(void) * Start the archiver if we're responsible for (re-)archiving received * files. */ - Assert(PgArchPID == 0); + Assert(PgArchPMChild == NULL); if (XLogArchivingAlways()) - PgArchPID = StartChildProcess(B_ARCHIVER); + PgArchPMChild = StartChildProcess(B_ARCHIVER); /* * If we aren't planning to enter hot standby mode later, treat @@ -3582,16 +3498,16 @@ process_pm_pmsignal(void) } /* Tell syslogger to rotate logfile if requested */ - if (SysLoggerPID != 0) + if (SysLoggerPMChild != NULL) { if (CheckLogrotateSignal()) { - signal_child(SysLoggerPID, SIGUSR1); + signal_child(SysLoggerPMChild, SIGUSR1); RemoveLogrotateSignalFiles(); } else if (CheckPostmasterSignal(PMSIGNAL_ROTATE_LOGFILE)) { - signal_child(SysLoggerPID, SIGUSR1); + signal_child(SysLoggerPMChild, SIGUSR1); } } @@ -3638,7 +3554,7 @@ process_pm_pmsignal(void) PostmasterStateMachine(); } - if (StartupPID != 0 && + if (StartupPMChild != NULL && (pmState == PM_STARTUP || pmState == PM_RECOVERY || pmState == PM_HOT_STANDBY) && CheckPromoteSignal()) @@ -3649,7 +3565,7 @@ process_pm_pmsignal(void) * Leave the promote signal file in place and let the Startup process * do the unlink. */ - signal_child(StartupPID, SIGUSR2); + signal_child(StartupPMChild, SIGUSR2); } } @@ -3676,13 +3592,13 @@ CountChildren(uint32 targetMask) dlist_iter iter; int cnt = 0; - dlist_foreach(iter, &BackendList) + dlist_foreach(iter, &ActiveChildList) { - Backend *bp = dlist_container(Backend, elem, iter.cur); + PMChild *bp = dlist_container(PMChild, elem, iter.cur); /* - * Since target == BACKEND_TYPE_ALL is the most common case, we test - * it first and avoid touching shared memory for every child. + * Since targetMask == BACKEND_TYPE_ALL is the most common case, we + * test it first and avoid touching shared memory for every child. */ if (targetMask != BACKEND_TYPE_ALL) { @@ -3713,15 +3629,33 @@ CountChildren(uint32 targetMask) * Return value of StartChildProcess is subprocess' PID, or 0 if failed * to start subprocess. */ -static pid_t +static PMChild * StartChildProcess(BackendType type) { + PMChild *pmchild; pid_t pid; + pmchild = AssignPostmasterChildSlot(type); + if (!pmchild) + { + if (type == B_AUTOVAC_WORKER) + ereport(LOG, + (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED), + errmsg("no slot available for new autovacuum worker process"))); + else + { + /* shouldn't happen because we allocate enough slots */ + elog(LOG, "no postmaster child slot available for aux process"); + } + return NULL; + } + + MyPMChildSlot = pmchild->child_slot; pid = postmaster_child_launch(type, NULL, 0, NULL); if (pid < 0) { /* in parent, fork failed */ + FreePostmasterChildSlot(pmchild); ereport(LOG, (errmsg("could not fork \"%s\" process: %m", PostmasterChildName(type)))); @@ -3731,13 +3665,14 @@ StartChildProcess(BackendType type) */ if (type == B_STARTUP) ExitPostmaster(1); - return 0; + return NULL; } /* * in parent, successful fork */ - return pid; + pmchild->pid = pid; + return pmchild; } /* @@ -3752,7 +3687,7 @@ StartChildProcess(BackendType type) static void StartAutovacuumWorker(void) { - Backend *bn; + PMChild *bn; /* * If not in condition to run a process, don't try, but handle it like a @@ -3763,34 +3698,20 @@ StartAutovacuumWorker(void) */ if (canAcceptConnections(B_AUTOVAC_WORKER) == CAC_OK) { - bn = (Backend *) palloc_extended(sizeof(Backend), MCXT_ALLOC_NO_OOM); + bn = StartChildProcess(B_AUTOVAC_WORKER); if (bn) { - /* Autovac workers need a child slot */ - bn->bkend_type = B_AUTOVAC_WORKER; - bn->child_slot = MyPMChildSlot = AssignPostmasterChildSlot(); bn->bgworker_notify = false; bn->rw = NULL; - - bn->pid = StartChildProcess(B_AUTOVAC_WORKER); - if (bn->pid > 0) - { - dlist_push_head(&BackendList, &bn->elem); - /* all OK */ - return; - } - + return; + } + else + { /* * fork failed, fall through to report -- actual error message was * logged by StartChildProcess */ - (void) ReleasePostmasterChildSlot(bn->child_slot); - pfree(bn); } - else - ereport(LOG, - (errcode(ERRCODE_OUT_OF_MEMORY), - errmsg("out of memory"))); } /* @@ -3802,7 +3723,7 @@ StartAutovacuumWorker(void) * quick succession between the autovac launcher and postmaster in case * things get ugly. */ - if (AutoVacPID != 0) + if (AutoVacLauncherPMChild != NULL) { AutoVacWorkerFailed(); avlauncher_needs_signal = true; @@ -3846,23 +3767,6 @@ CreateOptsFile(int argc, char *argv[], char *fullprogname) } -/* - * MaxLivePostmasterChildren - * - * This reports the number of entries needed in the per-child-process array - * (PMChildFlags). It includes regular backends, autovac workers, walsenders - * and background workers, but not special children nor dead_end children. - * This allows the array to have a fixed maximum size, to wit the same - * too-many-children limit enforced by canAcceptConnections(). The exact value - * isn't too critical as long as it's more than MaxBackends. - */ -int -MaxLivePostmasterChildren(void) -{ - return 2 * (MaxConnections + autovacuum_max_workers + 1 + - max_wal_senders + max_worker_processes); -} - /* * Start a new bgworker. * Starting time conditions must have been checked already. @@ -3875,7 +3779,7 @@ MaxLivePostmasterChildren(void) static bool do_start_bgworker(RegisteredBgWorker *rw) { - Backend *bn; + PMChild *bn; pid_t worker_pid; Assert(rw->rw_pid == 0); @@ -3902,6 +3806,7 @@ do_start_bgworker(RegisteredBgWorker *rw) (errmsg_internal("starting background worker process \"%s\"", rw->rw_worker.bgw_name))); + MyPMChildSlot = bn->child_slot; worker_pid = postmaster_child_launch(B_BG_WORKER, (char *) &rw->rw_worker, sizeof(BackgroundWorker), NULL); if (worker_pid == -1) { @@ -3909,8 +3814,7 @@ do_start_bgworker(RegisteredBgWorker *rw) ereport(LOG, (errmsg("could not fork background worker process: %m"))); /* undo what assign_backendlist_entry did */ - ReleasePostmasterChildSlot(bn->child_slot); - pfree(bn); + FreePostmasterChildSlot(bn); /* mark entry as crashed, so we'll try again later */ rw->rw_crashed_at = GetCurrentTimestamp(); @@ -3921,8 +3825,6 @@ do_start_bgworker(RegisteredBgWorker *rw) rw->rw_pid = worker_pid; bn->pid = rw->rw_pid; ReportBackgroundWorkerPID(rw); - /* add new worker to lists of backends */ - dlist_push_head(&BackendList, &bn->elem); return true; } @@ -3970,17 +3872,13 @@ bgworker_should_start_now(BgWorkerStartTime start_time) * * On failure, return NULL. */ -static Backend * +static PMChild * assign_backendlist_entry(void) { - Backend *bn; + PMChild *bn; - /* - * Check that database state allows another connection. Currently the - * only possible failure is CAC_TOOMANY, so we just log an error message - * based on that rather than checking the error code precisely. - */ - if (canAcceptConnections(B_BG_WORKER) != CAC_OK) + bn = AssignPostmasterChildSlot(B_BG_WORKER); + if (bn == NULL) { ereport(LOG, (errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED), @@ -3988,16 +3886,6 @@ assign_backendlist_entry(void) return NULL; } - bn = palloc_extended(sizeof(Backend), MCXT_ALLOC_NO_OOM); - if (bn == NULL) - { - ereport(LOG, - (errcode(ERRCODE_OUT_OF_MEMORY), - errmsg("out of memory"))); - return NULL; - } - - bn->child_slot = MyPMChildSlot = AssignPostmasterChildSlot(); bn->bkend_type = B_BG_WORKER; bn->bgworker_notify = false; @@ -4138,11 +4026,11 @@ bool PostmasterMarkPIDForWorkerNotify(int pid) { dlist_iter iter; - Backend *bp; + PMChild *bp; - dlist_foreach(iter, &BackendList) + dlist_foreach(iter, &ActiveChildList) { - bp = dlist_container(Backend, elem, iter.cur); + bp = dlist_container(PMChild, elem, iter.cur); if (bp->pid == pid) { bp->bgworker_notify = true; diff --git a/src/backend/storage/ipc/pmsignal.c b/src/backend/storage/ipc/pmsignal.c index cb99e77476..86970bf69b 100644 --- a/src/backend/storage/ipc/pmsignal.c +++ b/src/backend/storage/ipc/pmsignal.c @@ -47,11 +47,11 @@ * 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. A ACTIVE slot means the - * process is actively using shared memory. The slots are assigned to - * child processes at random, and postmaster.c is responsible for tracking - * which one goes with which PID. + * 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 postmaster.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. @@ -83,15 +83,6 @@ struct PMSignalData /* PMSignalState pointer is valid in both postmaster and child processes */ NON_EXEC_STATIC volatile PMSignalData *PMSignalState = NULL; -/* - * These static variables are valid only in the postmaster. We keep a - * duplicative private array so that we can trust its state even if some - * failing child has clobbered the PMSignalData struct in shared memory. - */ -static int num_child_inuse; /* # of entries in PMChildInUse[] */ -static int next_child_inuse; /* next slot to try to assign */ -static bool *PMChildInUse; /* true if i'th flag slot is assigned */ - /* * Signal handler to be notified if postmaster dies. */ @@ -155,25 +146,7 @@ PMSignalShmemInit(void) { /* initialize all flags to zeroes */ MemSet(unvolatize(PMSignalData *, PMSignalState), 0, PMSignalShmemSize()); - num_child_inuse = MaxLivePostmasterChildren(); - PMSignalState->num_child_flags = num_child_inuse; - - /* - * Also allocate postmaster's private PMChildInUse[] array. We - * might've already done that in a previous shared-memory creation - * cycle, in which case free the old array to avoid a leak. (Do it - * like this to support the possibility that MaxLivePostmasterChildren - * changed.) In a standalone backend, we do not need this. - */ - if (PostmasterContext != NULL) - { - if (PMChildInUse) - pfree(PMChildInUse); - PMChildInUse = (bool *) - MemoryContextAllocZero(PostmasterContext, - num_child_inuse * sizeof(bool)); - } - next_child_inuse = 0; + PMSignalState->num_child_flags = MaxLivePostmasterChildren(); } } @@ -239,41 +212,22 @@ GetQuitSignalReason(void) /* - * AssignPostmasterChildSlot - select an unused slot for a new postmaster - * child process, and set its state to ASSIGNED. Returns a slot number - * (one to N). + * ReservePostmasterChildSlot - 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. */ -int -AssignPostmasterChildSlot(void) +void +ReservePostmasterChildSlot(int slot) { - int slot = next_child_inuse; - int n; + Assert(slot > 0 && slot <= PMSignalState->num_child_flags); + slot--; - /* - * Scan for a free slot. Notice that we trust nothing about the contents - * of PMSignalState, but use only postmaster-local data for this decision. - * We track the last slot assigned so as not to waste time repeatedly - * rescanning low-numbered slots. - */ - for (n = num_child_inuse; n > 0; n--) - { - if (--slot < 0) - slot = num_child_inuse - 1; - if (!PMChildInUse[slot]) - { - PMChildInUse[slot] = true; - PMSignalState->PMChildFlags[slot] = PM_CHILD_ASSIGNED; - next_child_inuse = slot; - return slot + 1; - } - } + if (PMSignalState->PMChildFlags[slot] != PM_CHILD_UNUSED) + elog(FATAL, "postmaster child slot is already in use"); - /* Out of slots ... should never happen, else postmaster.c messed up */ - elog(FATAL, "no free slots in PMChildFlags array"); - return 0; /* keep compiler quiet */ + PMSignalState->PMChildFlags[slot] = PM_CHILD_ASSIGNED; } /* @@ -288,17 +242,18 @@ ReleasePostmasterChildSlot(int slot) { bool result; - Assert(slot > 0 && slot <= num_child_inuse); + Assert(slot > 0 && slot <= PMSignalState->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. + * + * FIXME: does that still happen? */ result = (PMSignalState->PMChildFlags[slot] == PM_CHILD_ASSIGNED); PMSignalState->PMChildFlags[slot] = PM_CHILD_UNUSED; - PMChildInUse[slot] = false; return result; } @@ -309,7 +264,7 @@ ReleasePostmasterChildSlot(int slot) bool IsPostmasterChildWalSender(int slot) { - Assert(slot > 0 && slot <= num_child_inuse); + Assert(slot > 0 && slot <= PMSignalState->num_child_flags); slot--; if (PMSignalState->PMChildFlags[slot] == PM_CHILD_WALSENDER) diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c index 9536469e89..2fa709137f 100644 --- a/src/backend/storage/lmgr/proc.c +++ b/src/backend/storage/lmgr/proc.c @@ -311,14 +311,9 @@ InitProcess(void) /* * Before we start accessing the shared memory in a serious way, mark * ourselves as an active postmaster child; this is so that the postmaster - * can detect it if we exit without cleaning up. (XXX autovac launcher - * currently doesn't participate in this; it probably should.) - * - * Slot sync worker also does not participate in it, see comments atop - * 'struct bkend' in postmaster.c. + * can detect it if we exit without cleaning up. */ - if (IsUnderPostmaster && !AmAutoVacuumLauncherProcess() && - !AmLogicalSlotSyncWorkerProcess()) + if (IsUnderPostmaster) MarkPostmasterChildActive(); /* Decide which list should supply our PGPROC. */ @@ -536,6 +531,9 @@ InitAuxiliaryProcess(void) if (MyProc != NULL) elog(ERROR, "you already exist"); + if (IsUnderPostmaster) + MarkPostmasterChildActive(); + /* * We use the ProcStructLock to protect assignment and releasing of * AuxiliaryProcs entries. diff --git a/src/include/postmaster/postmaster.h b/src/include/postmaster/postmaster.h index 63c12917cf..deca2e8370 100644 --- a/src/include/postmaster/postmaster.h +++ b/src/include/postmaster/postmaster.h @@ -13,8 +13,39 @@ #ifndef _POSTMASTER_H #define _POSTMASTER_H +#include "lib/ilist.h" #include "miscadmin.h" +/* + * A struct representing an active postmaster child process. This is used + * mainly to keep track of how many children we have and send them appropriate + * signals when necessary. All postmaster child processes are assigned a + * PMChild entry. That includes "normal" client sessions, but also autovacuum + * workers, walsenders, background workers, and aux processes. (Note that at + * the time of launch, walsenders are labeled B_BACKEND; we relabel them to + * B_WAL_SENDER upon noticing they've changed their PMChildFlags entry. Hence + * that check must be done before any operation that needs to distinguish + * walsenders from normal backends.) + * + * "dead_end" children are also allocated a PMChild entry: these are children + * launched just for the purpose of sending a friendly rejection message to a + * would-be client. We must track them because they are attached to shared + * memory, but we know they will never become live backends. + * + * 'child_slot' is an identifier that is unique across all running child + * processes. It is used as an index into the PMChildFlags array. dead_end + * children are not assigned a child_slot. + */ +typedef struct +{ + pid_t pid; /* process id of backend */ + int child_slot; /* PMChildSlot for this backend, if any */ + BackendType bkend_type; /* child process flavor, see above */ + struct RegisteredBgWorker *rw; /* bgworker info, if this is a bgworker */ + bool bgworker_notify; /* gets bgworker start/stop notifications */ + dlist_node elem; /* list link in BackendList */ +} PMChild; + /* GUC options */ extern PGDLLIMPORT bool EnableSSL; extern PGDLLIMPORT int SuperuserReservedConnections; @@ -80,6 +111,15 @@ const char *PostmasterChildName(BackendType child_type); extern void SubPostmasterMain(int argc, char *argv[]) pg_attribute_noreturn(); #endif +/* prototypes for functions in pmchild.c */ +extern dlist_head ActiveChildList; + +extern void InitPostmasterChildSlots(void); +extern PMChild *AssignPostmasterChildSlot(BackendType btype); +extern bool FreePostmasterChildSlot(PMChild *pmchild); +extern PMChild *FindPostmasterChildByPid(int pid); +extern PMChild *AllocDeadEndChild(void); + /* * Note: MAX_BACKENDS is limited to 2^18-1 because that's the width reserved * for buffer references in buf_internals.h. This limitation could be lifted diff --git a/src/include/storage/pmsignal.h b/src/include/storage/pmsignal.h index 3b9336b83c..2ab198fc31 100644 --- a/src/include/storage/pmsignal.h +++ b/src/include/storage/pmsignal.h @@ -70,7 +70,7 @@ extern void SendPostmasterSignal(PMSignalReason reason); extern bool CheckPostmasterSignal(PMSignalReason reason); extern void SetQuitSignalReason(QuitSignalReason reason); extern QuitSignalReason GetQuitSignalReason(void); -extern int AssignPostmasterChildSlot(void); +extern void ReservePostmasterChildSlot(int slot); extern bool ReleasePostmasterChildSlot(int slot); extern bool IsPostmasterChildWalSender(int slot); extern void MarkPostmasterChildActive(void); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 547d14b3e7..ad39c0741a 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -230,7 +230,6 @@ BTWriteState BUF_MEM BYTE BY_HANDLE_FILE_INFORMATION -Backend BackendParameters BackendStartupData BackendState @@ -1927,6 +1926,7 @@ PLyTransformToOb PLyTupleToOb PLyUnicode_FromStringAndSize_t PLy_elog_impl_t +PMChild PMINIDUMP_CALLBACK_INFORMATION PMINIDUMP_EXCEPTION_INFORMATION PMINIDUMP_USER_STREAM_INFORMATION -- 2.39.2