public inbox for [email protected]
help / color / mirror / Atom feedFrom: Heikki Linnakangas <[email protected]>
To: Thomas Munro <[email protected]>
Cc: [email protected] <[email protected]>
Subject: Re: Refactoring postmaster's code to cleanup after child exit
Date: Mon, 12 Aug 2024 12:55:00 +0300
Message-ID: <[email protected]> (raw)
In-Reply-To: <[email protected]>
References: <[email protected]>
<[email protected]>
<[email protected]>
<CA+hUKGKWqSFoJXzRC9D0owFj1Xby0qvWr-k6p8z9gQzT7+nr7w@mail.gmail.com>
<[email protected]>
On 10/08/2024 00:13, Heikki Linnakangas wrote:
> On 08/08/2024 13:47, Thomas Munro wrote:
>>> * v3-0004-Consolidate-postmaster-code-to-launch-background-.patch
>>
>> Much of the code in process_pm_child_exit() to launch replacement
>> processes when one exits or when progressing to next postmaster
>> state
>> was unnecessary, because the ServerLoop will launch any missing
>> background processes anyway. Remove the redundant code and let
>> ServerLoop handle it.
>
> I'm going to work a little more on the comments on this one before
> committing; I had just moved all the "If we have lost the XXX, try to
> start a new one" comments as is, but they look pretty repetitive now.
Pushed this now, after adjusting the comments a bit. Thanks again for
the review!
Here are the remaining patches, rebased.
> commit a1c43d65907d20a999b203e465db1277ec842a0a
> Author: Heikki Linnakangas <[email protected]>
> Date: Thu Aug 1 17:24:12 2024 +0300
>
> Introduce a separate BackendType for dead-end children
>
> And replace postmaster.c's own "backend type" codes with BackendType
>
> XXX: While working on this, many times I accidentally did something
> like "foo |= B_SOMETHING" instead of "foo |= 1 << B_SOMETHING", when
> constructing arguments to SignalSomeChildren or CountChildren, and
> things broke in very subtle ways taking a long time to debug. The old
> constants that were already bitmasks avoided that. Maybe we need some
> macro magic or something to make this less error-prone.
While rebasing this today, I spotted another instance of that mistake
mentioned in the XXX comment above. I called "CountChildren(B_BACKEND)"
instead of "CountChildren(1 << B_BACKEND)". Some ideas on how to make
that less error-prone:
1. Add a separate typedef for the bitmasks, and macros/functions to work
with it. Something like:
typedef struct {
uint32 mask;
} BackendTypeMask;
static const BackendTypeMask BTMASK_ALL = { 0xffffffff };
static const BackendTypeMask BTMASK_NONE = { 0 };
static inline BackendTypeMask
BTMASK_ADD(BackendTypeMask mask, BackendType t)
{
mask.mask |= 1 << t;
return mask;
}
static inline BackendTypeMask
BTMASK_DEL(BackendTypeMask mask, BackendType t)
{
mask.mask &= ~(1 << t);
return mask;
}
Now the compiler will complain if you try to pass a BackendType for the
mask. We could do this just for BackendType, or we could put this in
src/include/lib/ with a more generic name, like "bitmask_u32".
2. Another idea is to redefine the BackendType values to be separate
bits, like the current BACKEND_TYPE_* values in postmaster.c:
typedef enum BackendType
{
B_INVALID = 0,
/* Backends and other backend-like processes */
B_BACKEND = 1 << 1,
B_DEAD_END_BACKEND = 1 << 2,
B_AUTOVAC_LAUNCHER = 1 << 3,
B_AUTOVAC_WORKER = 1 << 4,
...
} BackendType;
Then you can use | and & on BackendTypes directly. It makes it less
clear which function arguments are a BackendType and which are a
bitmask, however.
Thoughts, other ideas?
--
Heikki Linnakangas
Neon (https://neon.tech)
Attachments:
[text/x-patch] v4-0001-Add-test-for-connection-limits.patch (6.4K, ../[email protected]/2-v4-0001-Add-test-for-connection-limits.patch)
download | inline diff:
From 57216e6203deb99bed7a9cc5ab1b07bbdcf808cc Mon Sep 17 00:00:00 2001
From: Heikki Linnakangas <[email protected]>
Date: Mon, 12 Aug 2024 10:55:05 +0300
Subject: [PATCH v4 1/8] Add test for connection limits
---
src/test/Makefile | 2 +-
src/test/meson.build | 1 +
src/test/postmaster/Makefile | 23 ++++++
src/test/postmaster/README | 27 +++++++
src/test/postmaster/meson.build | 12 +++
.../postmaster/t/001_connection_limits.pl | 79 +++++++++++++++++++
6 files changed, 143 insertions(+), 1 deletion(-)
create mode 100644 src/test/postmaster/Makefile
create mode 100644 src/test/postmaster/README
create mode 100644 src/test/postmaster/meson.build
create mode 100644 src/test/postmaster/t/001_connection_limits.pl
diff --git a/src/test/Makefile b/src/test/Makefile
index dbd3192874..abdd6e5a98 100644
--- a/src/test/Makefile
+++ b/src/test/Makefile
@@ -12,7 +12,7 @@ subdir = src/test
top_builddir = ../..
include $(top_builddir)/src/Makefile.global
-SUBDIRS = perl regress isolation modules authentication recovery subscription
+SUBDIRS = perl postmaster regress isolation modules authentication recovery subscription
ifeq ($(with_icu),yes)
SUBDIRS += icu
diff --git a/src/test/meson.build b/src/test/meson.build
index c3d0dfedf1..67376e4b7f 100644
--- a/src/test/meson.build
+++ b/src/test/meson.build
@@ -4,6 +4,7 @@ subdir('regress')
subdir('isolation')
subdir('authentication')
+subdir('postmaster')
subdir('recovery')
subdir('subscription')
subdir('modules')
diff --git a/src/test/postmaster/Makefile b/src/test/postmaster/Makefile
new file mode 100644
index 0000000000..dfcce9c9ee
--- /dev/null
+++ b/src/test/postmaster/Makefile
@@ -0,0 +1,23 @@
+#-------------------------------------------------------------------------
+#
+# Makefile for src/test/postmaster
+#
+# Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
+#
+# src/test/postmaster/Makefile
+#
+#-------------------------------------------------------------------------
+
+subdir = src/test/postmaster
+top_builddir = ../../..
+include $(top_builddir)/src/Makefile.global
+
+check:
+ $(prove_check)
+
+installcheck:
+ $(prove_installcheck)
+
+clean distclean:
+ rm -rf tmp_check
diff --git a/src/test/postmaster/README b/src/test/postmaster/README
new file mode 100644
index 0000000000..7e47bf5cff
--- /dev/null
+++ b/src/test/postmaster/README
@@ -0,0 +1,27 @@
+src/test/postmaster/README
+
+Regression tests for postmaster
+===============================
+
+This directory contains a test suite for postmaster's handling of
+connections, connection limits, and startup/shutdown sequence.
+
+
+Running the tests
+=================
+
+NOTE: You must have given the --enable-tap-tests argument to configure.
+
+Run
+ make check
+or
+ make installcheck
+You can use "make installcheck" if you previously did "make install".
+In that case, the code in the installation tree is tested. With
+"make check", a temporary installation tree is built from the current
+sources and then tested.
+
+Either way, this test initializes, starts, and stops a test Postgres
+cluster.
+
+See src/test/perl/README for more info about running these tests.
diff --git a/src/test/postmaster/meson.build b/src/test/postmaster/meson.build
new file mode 100644
index 0000000000..c2de2e0eb5
--- /dev/null
+++ b/src/test/postmaster/meson.build
@@ -0,0 +1,12 @@
+# Copyright (c) 2022-2024, PostgreSQL Global Development Group
+
+tests += {
+ 'name': 'postmaster',
+ 'sd': meson.current_source_dir(),
+ 'bd': meson.current_build_dir(),
+ 'tap': {
+ 'tests': [
+ 't/001_connection_limits.pl',
+ ],
+ },
+}
diff --git a/src/test/postmaster/t/001_connection_limits.pl b/src/test/postmaster/t/001_connection_limits.pl
new file mode 100644
index 0000000000..f50aae4949
--- /dev/null
+++ b/src/test/postmaster/t/001_connection_limits.pl
@@ -0,0 +1,79 @@
+
+# Copyright (c) 2021-2024, PostgreSQL Global Development Group
+
+# Test connection limits, i.e. max_connections, reserved_connections
+# and superuser_reserved_connections.
+
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+# Initialize the server with specific low connection limits
+my $node = PostgreSQL::Test::Cluster->new('primary');
+$node->init;
+$node->append_conf('postgresql.conf', "max_connections = 6");
+$node->append_conf('postgresql.conf', "reserved_connections = 2");
+$node->append_conf('postgresql.conf', "superuser_reserved_connections = 1");
+$node->append_conf('postgresql.conf', "log_connections = on");
+$node->start;
+
+$node->safe_psql(
+ 'postgres', qq{
+CREATE USER regress_regular LOGIN;
+CREATE USER regress_reserved LOGIN;
+GRANT pg_use_reserved_connections TO regress_reserved;
+CREATE USER regress_superuser LOGIN SUPERUSER;
+});
+
+# With the limits we set in postgresql.conf, we can establish:
+# - 3 connections for any user with no special privileges
+# - 2 more connections for users belonging to "pg_use_reserved_connections"
+# - 1 more connection for superuser
+
+sub background_psql_as_user
+{
+ my $user = shift;
+
+ return $node->background_psql(
+ 'postgres',
+ on_error_die => 1,
+ extra_params => [ '-U', $user ]);
+}
+
+my @sessions = ();
+
+push(@sessions, background_psql_as_user('regress_regular'));
+push(@sessions, background_psql_as_user('regress_regular'));
+push(@sessions, background_psql_as_user('regress_regular'));
+$node->connect_fails(
+ "dbname=postgres user=regress_regular",
+ "reserved_connections limit",
+ expected_stderr =>
+ qr/FATAL: remaining connection slots are reserved for roles with privileges of the "pg_use_reserved_connections" role/
+);
+
+push(@sessions, background_psql_as_user('regress_reserved'));
+push(@sessions, background_psql_as_user('regress_reserved'));
+$node->connect_fails(
+ "dbname=postgres user=regress_regular",
+ "reserved_connections limit",
+ expected_stderr =>
+ qr/FATAL: remaining connection slots are reserved for roles with the SUPERUSER attribute/
+);
+
+push(@sessions, background_psql_as_user('regress_superuser'));
+$node->connect_fails(
+ "dbname=postgres user=regress_superuser",
+ "superuser_reserved_connections limit",
+ expected_stderr => qr/FATAL: sorry, too many clients already/);
+
+# TODO: test that query cancellation is still possible
+
+foreach my $session (@sessions)
+{
+ $session->quit;
+}
+
+done_testing();
--
2.39.2
[text/x-patch] v4-0002-Add-test-for-dead-end-backends.patch (3.2K, ../[email protected]/3-v4-0002-Add-test-for-dead-end-backends.patch)
download | inline diff:
From 93b9e9b6e072f63af9009e0d66ab6d0d62ea8c15 Mon Sep 17 00:00:00 2001
From: Heikki Linnakangas <[email protected]>
Date: Mon, 12 Aug 2024 10:55:11 +0300
Subject: [PATCH v4 2/8] Add test for dead-end backends
The code path for launching a dead-end backend because we're out of
slots was not covered by any tests, so add one. (Some tests did hit
the case of launching a dead-end backend because the server is still
starting up, though, so the gap in our test coverage wasn't as big as
it sounds.)
---
src/test/perl/PostgreSQL/Test/Cluster.pm | 39 +++++++++++++++++++
.../postmaster/t/001_connection_limits.pl | 17 +++++++-
2 files changed, 55 insertions(+), 1 deletion(-)
diff --git a/src/test/perl/PostgreSQL/Test/Cluster.pm b/src/test/perl/PostgreSQL/Test/Cluster.pm
index 32ee98aebc..6d09f9c5f8 100644
--- a/src/test/perl/PostgreSQL/Test/Cluster.pm
+++ b/src/test/perl/PostgreSQL/Test/Cluster.pm
@@ -104,6 +104,7 @@ use File::Path qw(rmtree mkpath);
use File::Spec;
use File::stat qw(stat);
use File::Temp ();
+use IO::Socket::INET;
use IPC::Run;
use PostgreSQL::Version;
use PostgreSQL::Test::RecursiveCopy;
@@ -284,6 +285,44 @@ sub connstr
return "port=$pgport host=$pghost dbname='$dbname'";
}
+=pod
+
+=item $node->raw_connect()
+
+Open a raw TCP or Unix domain socket connection to the server. This
+used by low-level protocol and connection limit tests.
+
+=cut
+
+sub raw_connect
+{
+ my ($self) = @_;
+ my $pgport = $self->port;
+ my $pghost = $self->host;
+
+ my $socket;
+ if ($PostgreSQL::Test::Utils::use_unix_sockets)
+ {
+ require IO::Socket::UNIX;
+ my $path = "$pghost/.s.PGSQL.$pgport";
+
+ $socket = IO::Socket::UNIX->new(
+ Type => SOCK_STREAM(),
+ Peer => $path,
+ ) or die "Cannot create socket - $IO::Socket::errstr\n";
+ }
+ else
+ {
+ $socket = IO::Socket::INET->new(
+ PeerHost => $pghost,
+ PeerPort => $pgport,
+ Proto => 'tcp'
+ ) or die "Cannot create socket - $IO::Socket::errstr\n";
+ }
+ return $socket;
+}
+
+
=pod
=item $node->group_access()
diff --git a/src/test/postmaster/t/001_connection_limits.pl b/src/test/postmaster/t/001_connection_limits.pl
index f50aae4949..3547b28bdd 100644
--- a/src/test/postmaster/t/001_connection_limits.pl
+++ b/src/test/postmaster/t/001_connection_limits.pl
@@ -43,6 +43,7 @@ sub background_psql_as_user
}
my @sessions = ();
+my @raw_connections = ();
push(@sessions, background_psql_as_user('regress_regular'));
push(@sessions, background_psql_as_user('regress_regular'));
@@ -69,11 +70,25 @@ $node->connect_fails(
"superuser_reserved_connections limit",
expected_stderr => qr/FATAL: sorry, too many clients already/);
-# TODO: test that query cancellation is still possible
+# We can still open TCP (or Unix domain socket) connections, but
+# beyond a certain number (roughly 2x max_connections), they will be
+# "dead-end backends".
+for (my $i = 0; $i <= 20; $i++)
+{
+ push(@raw_connections, $node->raw_connect());
+}
+
+# TODO: test that query cancellation is still possible. A dead-end
+# backend can process a query cancellation packet.
+# Clean up
foreach my $session (@sessions)
{
$session->quit;
}
+foreach my $socket (@raw_connections)
+{
+ $socket->close();
+}
done_testing();
--
2.39.2
[text/x-patch] v4-0003-Use-an-shmem_exit-callback-to-remove-backend-from.patch (4.9K, ../[email protected]/4-v4-0003-Use-an-shmem_exit-callback-to-remove-backend-from.patch)
download | inline diff:
From 88287a2db95e584018f1c7fa9e992feb7d179ce8 Mon Sep 17 00:00:00 2001
From: Heikki Linnakangas <[email protected]>
Date: Mon, 12 Aug 2024 10:58:35 +0300
Subject: [PATCH v4 3/8] Use an shmem_exit callback to remove backend from
PMChildFlags on exit
This seems nicer than having to duplicate the logic between
InitProcess() and ProcKill() for which child processes have a
PMChildFlags slot.
Move the MarkPostmasterChildActive() call earlier in InitProcess(),
out of the section protected by the spinlock.
---
src/backend/storage/ipc/pmsignal.c | 10 ++++++--
src/backend/storage/lmgr/proc.c | 38 ++++++++++--------------------
src/include/storage/pmsignal.h | 1 -
3 files changed, 21 insertions(+), 28 deletions(-)
diff --git a/src/backend/storage/ipc/pmsignal.c b/src/backend/storage/ipc/pmsignal.c
index 27844b46a2..cb99e77476 100644
--- a/src/backend/storage/ipc/pmsignal.c
+++ b/src/backend/storage/ipc/pmsignal.c
@@ -24,6 +24,7 @@
#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"
@@ -121,6 +122,8 @@ postmaster_death_handler(SIGNAL_ARGS)
#endif /* USE_POSTMASTER_DEATH_SIGNAL */
+static void MarkPostmasterChildInactive(int code, Datum arg);
+
/*
* PMSignalShmemSize
* Compute space needed for pmsignal.c's shared memory
@@ -328,6 +331,9 @@ MarkPostmasterChildActive(void)
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);
}
/*
@@ -352,8 +358,8 @@ MarkPostmasterChildWalSender(void)
* MarkPostmasterChildInactive - mark a postmaster child as done using
* shared memory. This is called in the child process.
*/
-void
-MarkPostmasterChildInactive(void)
+static void
+MarkPostmasterChildInactive(int code, Datum arg)
{
int slot = MyPMChildSlot;
diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c
index ac66da8638..9536469e89 100644
--- a/src/backend/storage/lmgr/proc.c
+++ b/src/backend/storage/lmgr/proc.c
@@ -308,6 +308,19 @@ InitProcess(void)
if (MyProc != NULL)
elog(ERROR, "you already exist");
+ /*
+ * 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.
+ */
+ if (IsUnderPostmaster && !AmAutoVacuumLauncherProcess() &&
+ !AmLogicalSlotSyncWorkerProcess())
+ MarkPostmasterChildActive();
+
/* Decide which list should supply our PGPROC. */
if (AmAutoVacuumLauncherProcess() || AmAutoVacuumWorkerProcess())
procgloballist = &ProcGlobal->autovacFreeProcs;
@@ -360,19 +373,6 @@ InitProcess(void)
*/
Assert(MyProc->procgloballist == procgloballist);
- /*
- * Now that we have a PGPROC, 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.
- */
- if (IsUnderPostmaster && !AmAutoVacuumLauncherProcess() &&
- !AmLogicalSlotSyncWorkerProcess())
- MarkPostmasterChildActive();
-
/*
* Initialize all fields of MyProc, except for those previously
* initialized by InitProcGlobal.
@@ -947,18 +947,6 @@ ProcKill(int code, Datum arg)
SpinLockRelease(ProcStructLock);
- /*
- * This process is no longer present in shared memory in any meaningful
- * way, so tell the postmaster we've cleaned up acceptably well. (XXX
- * autovac launcher should be included here someday)
- *
- * Slot sync worker is also not a postmaster child, so skip this shared
- * memory related processing here.
- */
- if (IsUnderPostmaster && !AmAutoVacuumLauncherProcess() &&
- !AmLogicalSlotSyncWorkerProcess())
- MarkPostmasterChildInactive();
-
/* wake autovac launcher if needed -- see comments in FreeWorkerInfo */
if (AutovacuumLauncherPid != 0)
kill(AutovacuumLauncherPid, SIGUSR2);
diff --git a/src/include/storage/pmsignal.h b/src/include/storage/pmsignal.h
index 0c9a7e32a8..3b9336b83c 100644
--- a/src/include/storage/pmsignal.h
+++ b/src/include/storage/pmsignal.h
@@ -74,7 +74,6 @@ extern int AssignPostmasterChildSlot(void);
extern bool ReleasePostmasterChildSlot(int slot);
extern bool IsPostmasterChildWalSender(int slot);
extern void MarkPostmasterChildActive(void);
-extern void MarkPostmasterChildInactive(void);
extern void MarkPostmasterChildWalSender(void);
extern bool PostmasterIsAliveInternal(void);
extern void PostmasterDeathSignalInit(void);
--
2.39.2
[text/x-patch] v4-0004-Introduce-a-separate-BackendType-for-dead-end-chi.patch (14.7K, ../[email protected]/5-v4-0004-Introduce-a-separate-BackendType-for-dead-end-chi.patch)
download | inline diff:
From dc53f89edbeec99f8633def8aa5f47cd98e7a150 Mon Sep 17 00:00:00 2001
From: Heikki Linnakangas <[email protected]>
Date: Mon, 12 Aug 2024 10:59:04 +0300
Subject: [PATCH v4 4/8] Introduce a separate BackendType for dead-end children
And replace postmaster.c's own "backend type" codes with BackendType
XXX: While working on this, many times I accidentally did something
like "foo |= B_SOMETHING" instead of "foo |= 1 << B_SOMETHING", when
constructing arguments to SignalSomeChildren or CountChildren, and
things broke in very subtle ways taking a long time to debug. The old
constants that were already bitmasks avoided that. Maybe we need some
macro magic or something to make this less error-prone.
---
src/backend/postmaster/postmaster.c | 106 ++++++++++++-------------
src/backend/utils/activity/pgstat_io.c | 3 +
src/backend/utils/init/miscinit.c | 3 +
src/include/miscadmin.h | 1 +
4 files changed, 56 insertions(+), 57 deletions(-)
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index 2c8e7fa7d6..9bbbbfe55f 100644
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -129,15 +129,11 @@
/*
- * Possible types of a backend. Beyond being the possible bkend_type values in
- * struct bkend, these are OR-able request flag bits for SignalSomeChildren()
- * and CountChildren().
+ * CountChildren and SignalSomeChildren use a uint32 bitmask argument to
+ * represent BackendTypes to count or signal.
*/
-#define BACKEND_TYPE_NORMAL 0x0001 /* normal backend */
-#define BACKEND_TYPE_AUTOVAC 0x0002 /* autovacuum worker process */
-#define BACKEND_TYPE_WALSND 0x0004 /* walsender process */
-#define BACKEND_TYPE_BGWORKER 0x0008 /* bgworker process */
-#define BACKEND_TYPE_ALL 0x000F /* OR of all the above */
+#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
@@ -148,7 +144,7 @@
* 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 BACKEND_TYPE_NORMAL; we relabel them to BACKEND_TYPE_WALSND
+ * 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.)
@@ -157,7 +153,8 @@
* 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 NORMAL.
+ * 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
@@ -169,8 +166,7 @@ typedef struct bkend
{
pid_t pid; /* process id of backend */
int child_slot; /* PMChildSlot for this backend, if any */
- int bkend_type; /* child process flavor, see above */
- bool dead_end; /* is it going to send an error and quit? */
+ 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 */
@@ -410,12 +406,13 @@ 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 bool SignalSomeChildren(int signal, int target);
+static bool SignalSomeChildren(int signal, uint32 targetMask);
static void TerminateChildren(int signal);
-#define SignalChildren(sig) SignalSomeChildren(sig, BACKEND_TYPE_ALL)
+#define SignalChildren(sig) \
+ SignalSomeChildren(sig, BACKEND_TYPE_ALL & ~(1 << B_DEAD_END_BACKEND))
-static int CountChildren(int target);
+static int CountChildren(uint32 targetMask);
static Backend *assign_backendlist_entry(void);
static void LaunchMissingBackgroundProcesses(void);
static void maybe_start_bgworkers(void);
@@ -1765,7 +1762,7 @@ canAcceptConnections(int backend_type)
* bgworker_should_start_now() decided whether the DB state allows them.
*/
if (pmState != PM_RUN && pmState != PM_HOT_STANDBY &&
- backend_type != BACKEND_TYPE_BGWORKER)
+ backend_type != B_BG_WORKER)
{
if (Shutdown > NoShutdown)
return CAC_SHUTDOWN; /* shutdown is pending */
@@ -1782,7 +1779,7 @@ canAcceptConnections(int backend_type)
* "Smart shutdown" restrictions are applied only to normal connections,
* not to autovac workers or bgworkers.
*/
- if (!connsAllowed && backend_type == BACKEND_TYPE_NORMAL)
+ if (!connsAllowed && backend_type == B_BACKEND)
return CAC_SHUTDOWN; /* shutdown is pending */
/*
@@ -1797,7 +1794,7 @@ canAcceptConnections(int backend_type)
* The limit here must match the sizes of the per-child-process arrays;
* see comments for MaxLivePostmasterChildren().
*/
- if (CountChildren(BACKEND_TYPE_ALL) >= MaxLivePostmasterChildren())
+ if (CountChildren(BACKEND_TYPE_ALL & ~(1 << B_DEAD_END_BACKEND)) >= MaxLivePostmasterChildren())
result = CAC_TOOMANY;
return result;
@@ -2555,11 +2552,11 @@ CleanupBackend(Backend *bp,
bool logged = false;
/* Construct a process name for log message */
- if (bp->dead_end)
+ if (bp->bkend_type == B_DEAD_END_BACKEND)
{
procname = _("dead end backend");
}
- else if (bp->bkend_type == BACKEND_TYPE_BGWORKER)
+ else if (bp->bkend_type == B_BG_WORKER)
{
snprintf(namebuf, MAXPGPATH, _("background worker \"%s\""),
bp->rw->rw_worker.bgw_type);
@@ -2598,7 +2595,7 @@ CleanupBackend(Backend *bp,
* If the process attached to shared memory, check that it detached
* cleanly.
*/
- if (!bp->dead_end)
+ if (bp->bkend_type != B_DEAD_END_BACKEND)
{
if (!ReleasePostmasterChildSlot(bp->child_slot))
{
@@ -2630,7 +2627,7 @@ CleanupBackend(Backend *bp,
/*
* If it was a background worker, also update its RegisteredWorker entry.
*/
- if (bp->bkend_type == BACKEND_TYPE_BGWORKER)
+ if (bp->bkend_type == B_BG_WORKER)
{
RegisteredBgWorker *rw = bp->rw;
@@ -2858,7 +2855,7 @@ PostmasterStateMachine(void)
* This state ends when we have no normal client backends running.
* Then we're ready to stop other children.
*/
- if (CountChildren(BACKEND_TYPE_NORMAL) == 0)
+ if (CountChildren(1 << B_BACKEND) == 0)
pmState = PM_STOP_BACKENDS;
}
}
@@ -2879,7 +2876,7 @@ PostmasterStateMachine(void)
/* Signal all backend children except walsenders */
SignalSomeChildren(SIGTERM,
- BACKEND_TYPE_ALL - BACKEND_TYPE_WALSND);
+ BACKEND_TYPE_ALL & ~(1 << B_WAL_SENDER | 1 << B_DEAD_END_BACKEND));
/* and the autovac launcher too */
if (AutoVacPID != 0)
signal_child(AutoVacPID, SIGTERM);
@@ -2921,7 +2918,7 @@ PostmasterStateMachine(void)
* here. Walsenders and archiver are also disregarded, they will be
* terminated later after writing the checkpoint record.
*/
- if (CountChildren(BACKEND_TYPE_ALL - BACKEND_TYPE_WALSND) == 0 &&
+ if (CountChildren(BACKEND_TYPE_ALL & ~(1 << B_WAL_SENDER | 1 << B_DEAD_END_BACKEND)) == 0 &&
StartupPID == 0 &&
WalReceiverPID == 0 &&
WalSummarizerPID == 0 &&
@@ -2995,7 +2992,7 @@ PostmasterStateMachine(void)
* left by now anyway; what we're really waiting for is walsenders and
* archiver.
*/
- if (PgArchPID == 0 && CountChildren(BACKEND_TYPE_ALL) == 0)
+ if (PgArchPID == 0 && CountChildren(BACKEND_TYPE_ALL & ~(1 << B_DEAD_END_BACKEND)) == 0)
{
pmState = PM_WAIT_DEAD_END;
}
@@ -3294,10 +3291,10 @@ sigquit_child(pid_t pid)
/*
* Send a signal to the targeted children (but NOT special children;
- * dead_end children are never signaled, either).
+ * dead_end children are never signaled, either XXX).
*/
static bool
-SignalSomeChildren(int signal, int target)
+SignalSomeChildren(int signal, uint32 targetMask)
{
dlist_iter iter;
bool signaled = false;
@@ -3306,24 +3303,21 @@ SignalSomeChildren(int signal, int target)
{
Backend *bp = dlist_container(Backend, elem, iter.cur);
- if (bp->dead_end)
- continue;
-
/*
* Since target == BACKEND_TYPE_ALL is the most common case, we test
* it first and avoid touching shared memory for every child.
*/
- if (target != BACKEND_TYPE_ALL)
+ if (targetMask != BACKEND_TYPE_ALL)
{
/*
* Assign bkend_type for any recently announced WAL Sender
* processes.
*/
- if (bp->bkend_type == BACKEND_TYPE_NORMAL &&
+ if (bp->bkend_type == B_BACKEND &&
IsPostmasterChildWalSender(bp->child_slot))
- bp->bkend_type = BACKEND_TYPE_WALSND;
+ bp->bkend_type = B_WAL_SENDER;
- if (!(target & bp->bkend_type))
+ if ((targetMask & (1 << bp->bkend_type)) == 0)
continue;
}
@@ -3396,17 +3390,22 @@ BackendStartup(ClientSocket *client_sock)
}
/* Pass down canAcceptConnections state */
- startup_data.canAcceptConnections = canAcceptConnections(BACKEND_TYPE_NORMAL);
- bn->dead_end = (startup_data.canAcceptConnections != CAC_OK);
+ startup_data.canAcceptConnections = canAcceptConnections(B_BACKEND);
bn->rw = NULL;
/*
* Unless it's a dead_end child, assign it a child slot number
*/
- if (!bn->dead_end)
+ 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;
@@ -3419,7 +3418,7 @@ BackendStartup(ClientSocket *client_sock)
/* in parent, fork failed */
int save_errno = errno;
- if (!bn->dead_end)
+ if (bn->child_slot != 0)
(void) ReleasePostmasterChildSlot(bn->child_slot);
pfree(bn);
errno = save_errno;
@@ -3439,7 +3438,6 @@ BackendStartup(ClientSocket *client_sock)
* of backends.
*/
bn->pid = pid;
- bn->bkend_type = BACKEND_TYPE_NORMAL; /* Can change later to WALSND */
dlist_push_head(&BackendList, &bn->elem);
return STATUS_OK;
@@ -3673,11 +3671,10 @@ dummy_handler(SIGNAL_ARGS)
}
/*
- * Count up number of child processes of specified types (dead_end children
- * are always excluded).
+ * Count up number of child processes of specified types.
*/
static int
-CountChildren(int target)
+CountChildren(uint32 targetMask)
{
dlist_iter iter;
int cnt = 0;
@@ -3686,24 +3683,21 @@ CountChildren(int target)
{
Backend *bp = dlist_container(Backend, elem, iter.cur);
- if (bp->dead_end)
- continue;
-
/*
* Since target == BACKEND_TYPE_ALL is the most common case, we test
* it first and avoid touching shared memory for every child.
*/
- if (target != BACKEND_TYPE_ALL)
+ if (targetMask != BACKEND_TYPE_ALL)
{
/*
* Assign bkend_type for any recently announced WAL Sender
* processes.
*/
- if (bp->bkend_type == BACKEND_TYPE_NORMAL &&
+ if (bp->bkend_type == B_BACKEND &&
IsPostmasterChildWalSender(bp->child_slot))
- bp->bkend_type = BACKEND_TYPE_WALSND;
+ bp->bkend_type = B_WAL_SENDER;
- if (!(target & bp->bkend_type))
+ if ((targetMask & (1 << bp->bkend_type)) == 0)
continue;
}
@@ -3770,13 +3764,13 @@ StartAutovacuumWorker(void)
* we have to check to avoid race-condition problems during DB state
* changes.
*/
- if (canAcceptConnections(BACKEND_TYPE_AUTOVAC) == CAC_OK)
+ if (canAcceptConnections(B_AUTOVAC_WORKER) == CAC_OK)
{
bn = (Backend *) palloc_extended(sizeof(Backend), MCXT_ALLOC_NO_OOM);
if (bn)
{
- /* Autovac workers are not dead_end and need a child slot */
- bn->dead_end = false;
+ /* Autovac workers need a child slot */
+ bn->bkend_type = B_AUTOVAC_WORKER;
bn->child_slot = MyPMChildSlot = AssignPostmasterChildSlot();
bn->bgworker_notify = false;
bn->rw = NULL;
@@ -3784,7 +3778,6 @@ StartAutovacuumWorker(void)
bn->pid = StartChildProcess(B_AUTOVAC_WORKER);
if (bn->pid > 0)
{
- bn->bkend_type = BACKEND_TYPE_AUTOVAC;
dlist_push_head(&BackendList, &bn->elem);
/* all OK */
return;
@@ -3990,7 +3983,7 @@ assign_backendlist_entry(void)
* 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(BACKEND_TYPE_BGWORKER) != CAC_OK)
+ if (canAcceptConnections(B_BG_WORKER) != CAC_OK)
{
ereport(LOG,
(errcode(ERRCODE_CONFIGURATION_LIMIT_EXCEEDED),
@@ -4008,8 +4001,7 @@ assign_backendlist_entry(void)
}
bn->child_slot = MyPMChildSlot = AssignPostmasterChildSlot();
- bn->bkend_type = BACKEND_TYPE_BGWORKER;
- bn->dead_end = false;
+ bn->bkend_type = B_BG_WORKER;
bn->bgworker_notify = false;
return bn;
diff --git a/src/backend/utils/activity/pgstat_io.c b/src/backend/utils/activity/pgstat_io.c
index 8af55989ee..9bad1040d6 100644
--- a/src/backend/utils/activity/pgstat_io.c
+++ b/src/backend/utils/activity/pgstat_io.c
@@ -312,6 +312,8 @@ pgstat_io_snapshot_cb(void)
*
* The following BackendTypes do not participate in the cumulative stats
* subsystem or do not perform IO on which we currently track:
+* - Dead-end backend because it is not connected to shared memory and
+* doesn't do any IO
* - Syslogger because it is not connected to shared memory
* - Archiver because most relevant archiving IO is delegated to a
* specialized command or module
@@ -334,6 +336,7 @@ pgstat_tracks_io_bktype(BackendType bktype)
switch (bktype)
{
case B_INVALID:
+ case B_DEAD_END_BACKEND:
case B_ARCHIVER:
case B_LOGGER:
case B_WAL_RECEIVER:
diff --git a/src/backend/utils/init/miscinit.c b/src/backend/utils/init/miscinit.c
index 537d92c0cf..ae8b1a4331 100644
--- a/src/backend/utils/init/miscinit.c
+++ b/src/backend/utils/init/miscinit.c
@@ -281,6 +281,9 @@ GetBackendTypeDesc(BackendType backendType)
case B_BACKEND:
backendDesc = "client backend";
break;
+ case B_DEAD_END_BACKEND:
+ backendDesc = "dead-end client backend";
+ break;
case B_BG_WORKER:
backendDesc = "background worker";
break;
diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h
index ac16233b71..b21c4d43b9 100644
--- a/src/include/miscadmin.h
+++ b/src/include/miscadmin.h
@@ -337,6 +337,7 @@ typedef enum BackendType
/* Backends and other backend-like processes */
B_BACKEND,
+ B_DEAD_END_BACKEND,
B_AUTOVAC_LAUNCHER,
B_AUTOVAC_WORKER,
B_BG_WORKER,
--
2.39.2
[text/x-patch] v4-0005-Kill-dead-end-children-when-there-s-nothing-else-.patch (7.5K, ../[email protected]/6-v4-0005-Kill-dead-end-children-when-there-s-nothing-else-.patch)
download | inline diff:
From 9c832ce33667abc5aef128a17fa9c27daaad872a Mon Sep 17 00:00:00 2001
From: Heikki Linnakangas <[email protected]>
Date: Mon, 12 Aug 2024 10:59:27 +0300
Subject: [PATCH v4 5/8] Kill dead-end children when there's nothing else left
Previously, the postmaster would never try to kill dead-end child
processes, even if there were no other processes left. A dead-end
backend will eventually exit, when authentication_timeout expires, but
if a dead-end backend is the only thing that's preventing the server
from shutting down, it seems better to kill it immediately. It's
particularly important, if there was a bug in the early startup code
that prevented a dead-end child from timing out and exiting normally.
Includes a test for that case where a dead-end backend previously kept
the server from shutting down.
---
src/backend/postmaster/postmaster.c | 35 +++++++-------
src/test/postmaster/meson.build | 1 +
src/test/postmaster/t/002_start_stop.pl | 64 +++++++++++++++++++++++++
3 files changed, 81 insertions(+), 19 deletions(-)
create mode 100644 src/test/postmaster/t/002_start_stop.pl
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index 9bbbbfe55f..99c588ee0b 100644
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -409,9 +409,6 @@ static void sigquit_child(pid_t pid);
static bool SignalSomeChildren(int signal, uint32 targetMask);
static void TerminateChildren(int signal);
-#define SignalChildren(sig) \
- SignalSomeChildren(sig, BACKEND_TYPE_ALL & ~(1 << B_DEAD_END_BACKEND))
-
static int CountChildren(uint32 targetMask);
static Backend *assign_backendlist_entry(void);
static void LaunchMissingBackgroundProcesses(void);
@@ -1963,7 +1960,7 @@ process_pm_reload_request(void)
ereport(LOG,
(errmsg("received SIGHUP, reloading configuration files")));
ProcessConfigFile(PGC_SIGHUP);
- SignalChildren(SIGHUP);
+ SignalSomeChildren(SIGHUP, BACKEND_TYPE_ALL & ~(1 << B_DEAD_END_BACKEND));
if (StartupPID != 0)
signal_child(StartupPID, SIGHUP);
if (BgWriterPID != 0)
@@ -2381,7 +2378,7 @@ process_pm_child_exit(void)
* Waken walsenders for the last time. No regular backends
* should be around anymore.
*/
- SignalChildren(SIGUSR2);
+ SignalSomeChildren(SIGUSR2, BACKEND_TYPE_ALL & (1 << B_DEAD_END_BACKEND));
pmState = PM_SHUTDOWN_2;
}
@@ -2874,7 +2871,7 @@ PostmasterStateMachine(void)
*/
ForgetUnstartedBackgroundWorkers();
- /* Signal all backend children except walsenders */
+ /* Signal all backend children except walsenders and dead-end backends */
SignalSomeChildren(SIGTERM,
BACKEND_TYPE_ALL & ~(1 << B_WAL_SENDER | 1 << B_DEAD_END_BACKEND));
/* and the autovac launcher too */
@@ -2932,10 +2929,11 @@ PostmasterStateMachine(void)
if (Shutdown >= ImmediateShutdown || FatalError)
{
/*
- * Start waiting for dead_end children to die. This state
- * change causes ServerLoop to stop creating new ones.
+ * Stop any dead_end children and stop creating new ones.
*/
pmState = PM_WAIT_DEAD_END;
+ ConfigurePostmasterWaitSet(false);
+ SignalSomeChildren(SIGQUIT, 1 << B_DEAD_END_BACKEND);
/*
* We already SIGQUIT'd the archiver and stats processes, if
@@ -2974,9 +2972,10 @@ PostmasterStateMachine(void)
*/
FatalError = true;
pmState = PM_WAIT_DEAD_END;
+ ConfigurePostmasterWaitSet(false);
- /* Kill the walsenders and archiver too */
- SignalChildren(SIGQUIT);
+ /* Kill the walsenders and archiver, too */
+ SignalSomeChildren(SIGQUIT, BACKEND_TYPE_ALL);
if (PgArchPID != 0)
signal_child(PgArchPID, SIGQUIT);
}
@@ -2994,15 +2993,14 @@ PostmasterStateMachine(void)
*/
if (PgArchPID == 0 && CountChildren(BACKEND_TYPE_ALL & ~(1 << B_DEAD_END_BACKEND)) == 0)
{
+ ConfigurePostmasterWaitSet(false);
+ SignalSomeChildren(SIGTERM, 1 << B_DEAD_END_BACKEND);
pmState = PM_WAIT_DEAD_END;
}
}
if (pmState == PM_WAIT_DEAD_END)
{
- /* Don't allow any new socket connection events. */
- ConfigurePostmasterWaitSet(false);
-
/*
* PM_WAIT_DEAD_END state ends when the BackendList is entirely empty
* (ie, no dead_end children remain), and the archiver is gone too.
@@ -3290,8 +3288,7 @@ sigquit_child(pid_t pid)
}
/*
- * Send a signal to the targeted children (but NOT special children;
- * dead_end children are never signaled, either XXX).
+ * Send a signal to the targeted children (but NOT special children).
*/
static bool
SignalSomeChildren(int signal, uint32 targetMask)
@@ -3322,8 +3319,8 @@ SignalSomeChildren(int signal, uint32 targetMask)
}
ereport(DEBUG4,
- (errmsg_internal("sending signal %d to process %d",
- signal, (int) bp->pid)));
+ (errmsg_internal("sending signal %d to %s process %d",
+ signal, GetBackendTypeDesc(bp->bkend_type), (int) bp->pid)));
signal_child(bp->pid, signal);
signaled = true;
}
@@ -3332,12 +3329,12 @@ SignalSomeChildren(int signal, uint32 targetMask)
/*
* Send a termination signal to children. This considers all of our children
- * processes, except syslogger and dead_end backends.
+ * processes, except syslogger.
*/
static void
TerminateChildren(int signal)
{
- SignalChildren(signal);
+ SignalSomeChildren(signal, BACKEND_TYPE_ALL);
if (StartupPID != 0)
{
signal_child(StartupPID, signal);
diff --git a/src/test/postmaster/meson.build b/src/test/postmaster/meson.build
index c2de2e0eb5..2d89adf520 100644
--- a/src/test/postmaster/meson.build
+++ b/src/test/postmaster/meson.build
@@ -7,6 +7,7 @@ tests += {
'tap': {
'tests': [
't/001_connection_limits.pl',
+ 't/002_start_stop.pl',
],
},
}
diff --git a/src/test/postmaster/t/002_start_stop.pl b/src/test/postmaster/t/002_start_stop.pl
new file mode 100644
index 0000000000..6f114659fa
--- /dev/null
+++ b/src/test/postmaster/t/002_start_stop.pl
@@ -0,0 +1,64 @@
+
+# Copyright (c) 2021-2024, PostgreSQL Global Development Group
+
+# XXX
+# XXX
+
+use IO::Socket::INET;
+use IO::Socket::UNIX;
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+use Time::HiRes qw(time);
+
+# Initialize the server with low connection limits, to test dead-end backends
+my $node = PostgreSQL::Test::Cluster->new('primary');
+$node->init;
+$node->append_conf('postgresql.conf', "max_connections = 5");
+$node->append_conf('postgresql.conf', "log_connections = on");
+$node->append_conf('postgresql.conf', "log_min_messages = debug2");
+
+# XX
+$node->append_conf('postgresql.conf', "authentication_timeout = '120 s'");
+
+$node->start;
+
+my @sessions = ();
+my @raw_connections = ();
+
+#for (my $i=0; $i <= 5; $i++) {
+# push(@sessions, $node->background_psql('postgres', on_error_die => 1));
+#}
+#$node->connect_fails("dbname=postgres", "max_connections reached",
+# expected_stderr => qr/FATAL: sorry, too many clients already/);
+
+# We can still open TCP (or Unix domain socket) connections, but beyond a
+# certain number (roughly 2x max_connections), they will be "dead-end backends"
+for (my $i = 0; $i <= 20; $i++)
+{
+ push(@raw_connections, $node->raw_connect());
+}
+
+# Test that the dead-end backends don't prevent the server from stopping.
+my $before = time();
+$node->stop();
+my $elapsed = time() - $before;
+ok($elapsed < 60);
+
+$node->start();
+
+$node->connect_ok("dbname=postgres", "works after restart");
+
+# Clean up
+foreach my $session (@sessions)
+{
+ $session->quit;
+}
+foreach my $socket (@raw_connections)
+{
+ $socket->close();
+}
+
+done_testing();
--
2.39.2
[text/x-patch] v4-0006-Assign-a-child-slot-to-every-postmaster-child-pro.patch (64.1K, ../[email protected]/7-v4-0006-Assign-a-child-slot-to-every-postmaster-child-pro.patch)
download | inline diff:
From a4a0e77f90e5e2e69cd7280b65d0e198cf6067e7 Mon Sep 17 00:00:00 2001
From: Heikki Linnakangas <[email protected]>
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
[text/x-patch] v4-0007-Pass-MyPMChildSlot-as-an-explicit-argument-to-chi.patch (10.7K, ../[email protected]/8-v4-0007-Pass-MyPMChildSlot-as-an-explicit-argument-to-chi.patch)
download | inline diff:
From 088f7911d2e300bad23e5afe66370340a96275e4 Mon Sep 17 00:00:00 2001
From: Heikki Linnakangas <[email protected]>
Date: Thu, 1 Aug 2024 22:58:17 +0300
Subject: [PATCH v4 7/8] Pass MyPMChildSlot as an explicit argument to child
process
All the other global variables passed from postmaster to child are
have the same value in all the processes, while MyPMChildSlot is more
like a parameter to each child process.
---
src/backend/postmaster/launch_backend.c | 32 ++++++++++++++++---------
src/backend/postmaster/pmchild.c | 3 ---
src/backend/postmaster/postmaster.c | 16 ++++++-------
src/backend/postmaster/syslogger.c | 8 ++++---
src/include/postmaster/postmaster.h | 1 +
src/include/postmaster/syslogger.h | 2 +-
6 files changed, 35 insertions(+), 27 deletions(-)
diff --git a/src/backend/postmaster/launch_backend.c b/src/backend/postmaster/launch_backend.c
index b0b91dc97f..4e93bd1d94 100644
--- a/src/backend/postmaster/launch_backend.c
+++ b/src/backend/postmaster/launch_backend.c
@@ -96,7 +96,6 @@ typedef int InheritableSocket;
typedef struct
{
char DataDir[MAXPGPATH];
- int MyPMChildSlot;
#ifndef WIN32
unsigned long UsedShmemSegID;
#else
@@ -137,6 +136,8 @@ typedef struct
char my_exec_path[MAXPGPATH];
char pkglib_path[MAXPGPATH];
+ int MyPMChildSlot;
+
/*
* These are only used by backend processes, but are here because passing
* a socket needs some special handling on Windows. 'client_sock' is an
@@ -158,13 +159,16 @@ typedef struct
static void read_backend_variables(char *id, char **startup_data, size_t *startup_data_len);
static void restore_backend_variables(BackendParameters *param);
-static bool save_backend_variables(BackendParameters *param, ClientSocket *client_sock,
+static bool save_backend_variables(BackendParameters *param, int child_slot,
+ ClientSocket *client_sock,
#ifdef WIN32
HANDLE childProcess, pid_t childPid,
#endif
char *startup_data, size_t startup_data_len);
-static pid_t internal_forkexec(const char *child_kind, char *startup_data, size_t startup_data_len, ClientSocket *client_sock);
+static pid_t internal_forkexec(const char *child_kind, int child_slot,
+ char *startup_data, size_t startup_data_len,
+ ClientSocket *client_sock);
#endif /* EXEC_BACKEND */
@@ -226,7 +230,7 @@ PostmasterChildName(BackendType child_type)
* the child process.
*/
pid_t
-postmaster_child_launch(BackendType child_type,
+postmaster_child_launch(BackendType child_type, int child_slot,
char *startup_data, size_t startup_data_len,
ClientSocket *client_sock)
{
@@ -235,7 +239,7 @@ postmaster_child_launch(BackendType child_type,
Assert(IsPostmasterEnvironment && !IsUnderPostmaster);
#ifdef EXEC_BACKEND
- pid = internal_forkexec(child_process_kinds[child_type].name,
+ pid = internal_forkexec(child_process_kinds[child_type].name, child_slot,
startup_data, startup_data_len, client_sock);
/* the child process will arrive in SubPostmasterMain */
#else /* !EXEC_BACKEND */
@@ -263,6 +267,7 @@ postmaster_child_launch(BackendType child_type,
*/
MemoryContextSwitchTo(TopMemoryContext);
+ MyPMChildSlot = child_slot;
if (client_sock)
{
MyClientSocket = palloc(sizeof(ClientSocket));
@@ -289,7 +294,8 @@ postmaster_child_launch(BackendType child_type,
* - fork():s, and then exec():s the child process
*/
static pid_t
-internal_forkexec(const char *child_kind, char *startup_data, size_t startup_data_len, ClientSocket *client_sock)
+internal_forkexec(const char *child_kind, int child_slot,
+ char *startup_data, size_t startup_data_len, ClientSocket *client_sock)
{
static unsigned long tmpBackendFileNum = 0;
pid_t pid;
@@ -309,7 +315,7 @@ internal_forkexec(const char *child_kind, char *startup_data, size_t startup_dat
*/
paramsz = SizeOfBackendParameters(startup_data_len);
param = palloc0(paramsz);
- if (!save_backend_variables(param, client_sock, startup_data, startup_data_len))
+ if (!save_backend_variables(param, child_slot, client_sock, startup_data, startup_data_len))
{
pfree(param);
return -1; /* log made by save_backend_variables */
@@ -398,7 +404,8 @@ internal_forkexec(const char *child_kind, char *startup_data, size_t startup_dat
* file is complete.
*/
static pid_t
-internal_forkexec(const char *child_kind, char *startup_data, size_t startup_data_len, ClientSocket *client_sock)
+internal_forkexec(const char *child_kind, int child_slot,
+ char *startup_data, size_t startup_data_len, ClientSocket *client_sock)
{
int retry_count = 0;
STARTUPINFO si;
@@ -479,7 +486,9 @@ retry:
return -1;
}
- if (!save_backend_variables(param, client_sock, pi.hProcess, pi.dwProcessId, startup_data, startup_data_len))
+ if (!save_backend_variables(param, child_slot, client_sock,
+ pi.hProcess, pi.dwProcessId,
+ startup_data, startup_data_len))
{
/*
* log made by save_backend_variables, but we have to clean up the
@@ -691,7 +700,8 @@ static void read_inheritable_socket(SOCKET *dest, InheritableSocket *src);
/* Save critical backend variables into the BackendParameters struct */
static bool
-save_backend_variables(BackendParameters *param, ClientSocket *client_sock,
+save_backend_variables(BackendParameters *param,
+ int child_slot, ClientSocket *client_sock,
#ifdef WIN32
HANDLE childProcess, pid_t childPid,
#endif
@@ -708,7 +718,7 @@ save_backend_variables(BackendParameters *param, ClientSocket *client_sock,
strlcpy(param->DataDir, DataDir, MAXPGPATH);
- param->MyPMChildSlot = MyPMChildSlot;
+ param->MyPMChildSlot = child_slot;
#ifdef WIN32
param->ShmemProtectiveRegion = ShmemProtectiveRegion;
diff --git a/src/backend/postmaster/pmchild.c b/src/backend/postmaster/pmchild.c
index 735c66f8e7..ac8776bd95 100644
--- a/src/backend/postmaster/pmchild.c
+++ b/src/backend/postmaster/pmchild.c
@@ -209,9 +209,6 @@ AssignPostmasterChildSlot(BackendType btype)
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;
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index a029e28786..798cd330f3 100644
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -983,7 +983,7 @@ PostmasterMain(int argc, char *argv[])
SysLoggerPMChild = AssignPostmasterChildSlot(B_LOGGER);
if (!SysLoggerPMChild)
elog(ERROR, "no postmaster child slot available for syslogger");
- SysLoggerPMChild->pid = SysLogger_Start();
+ SysLoggerPMChild->pid = SysLogger_Start(SysLoggerPMChild->child_slot);
if (SysLoggerPMChild->pid == 0)
{
FreePostmasterChildSlot(SysLoggerPMChild);
@@ -2413,7 +2413,7 @@ process_pm_child_exit(void)
if (SysLoggerPMChild && pid == SysLoggerPMChild->pid)
{
/* for safety's sake, launch new logger *first* */
- SysLoggerPMChild->pid = SysLogger_Start();
+ SysLoggerPMChild->pid = SysLogger_Start(SysLoggerPMChild->child_slot);
if (SysLoggerPMChild->pid == 0)
{
FreePostmasterChildSlot(SysLoggerPMChild);
@@ -3054,7 +3054,7 @@ LaunchMissingBackgroundProcesses(void)
elog(LOG, "no postmaster child slot available for syslogger");
else
{
- SysLoggerPMChild->pid = SysLogger_Start();
+ SysLoggerPMChild->pid = SysLogger_Start(SysLoggerPMChild->child_slot);
if (SysLoggerPMChild->pid == 0)
{
FreePostmasterChildSlot(SysLoggerPMChild);
@@ -3325,8 +3325,7 @@ BackendStartup(ClientSocket *client_sock)
/* Hasn't asked to be notified about any bgworkers yet */
bn->bgworker_notify = false;
- MyPMChildSlot = bn->child_slot;
- pid = postmaster_child_launch(bn->bkend_type,
+ pid = postmaster_child_launch(bn->bkend_type, bn->child_slot,
(char *) &startup_data, sizeof(startup_data),
client_sock);
if (pid < 0)
@@ -3650,8 +3649,7 @@ StartChildProcess(BackendType type)
return NULL;
}
- MyPMChildSlot = pmchild->child_slot;
- pid = postmaster_child_launch(type, NULL, 0, NULL);
+ pid = postmaster_child_launch(type, pmchild->child_slot, NULL, 0, NULL);
if (pid < 0)
{
/* in parent, fork failed */
@@ -3806,8 +3804,8 @@ 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);
+ worker_pid = postmaster_child_launch(B_BG_WORKER, bn->child_slot,
+ (char *) &rw->rw_worker, sizeof(BackgroundWorker), NULL);
if (worker_pid == -1)
{
/* in postmaster, fork failed ... */
diff --git a/src/backend/postmaster/syslogger.c b/src/backend/postmaster/syslogger.c
index 7951599fa8..d68853d429 100644
--- a/src/backend/postmaster/syslogger.c
+++ b/src/backend/postmaster/syslogger.c
@@ -590,7 +590,7 @@ SysLoggerMain(char *startup_data, size_t startup_data_len)
* Postmaster subroutine to start a syslogger subprocess.
*/
int
-SysLogger_Start(void)
+SysLogger_Start(int child_slot)
{
pid_t sysloggerPid;
char *filename;
@@ -699,9 +699,11 @@ SysLogger_Start(void)
startup_data.syslogFile = syslogger_fdget(syslogFile);
startup_data.csvlogFile = syslogger_fdget(csvlogFile);
startup_data.jsonlogFile = syslogger_fdget(jsonlogFile);
- sysloggerPid = postmaster_child_launch(B_LOGGER, (char *) &startup_data, sizeof(startup_data), NULL);
+ sysloggerPid = postmaster_child_launch(B_LOGGER, child_slot,
+ (char *) &startup_data, sizeof(startup_data), NULL);
#else
- sysloggerPid = postmaster_child_launch(B_LOGGER, NULL, 0, NULL);
+ sysloggerPid = postmaster_child_launch(B_LOGGER, child_slot,
+ NULL, 0, NULL);
#endif /* EXEC_BACKEND */
if (sysloggerPid == -1)
diff --git a/src/include/postmaster/postmaster.h b/src/include/postmaster/postmaster.h
index deca2e8370..81a3520021 100644
--- a/src/include/postmaster/postmaster.h
+++ b/src/include/postmaster/postmaster.h
@@ -103,6 +103,7 @@ extern PGDLLIMPORT struct ClientSocket *MyClientSocket;
/* prototypes for functions in launch_backend.c */
extern pid_t postmaster_child_launch(BackendType child_type,
+ int child_slot,
char *startup_data,
size_t startup_data_len,
struct ClientSocket *client_sock);
diff --git a/src/include/postmaster/syslogger.h b/src/include/postmaster/syslogger.h
index b5fc239ba9..d72b978b0a 100644
--- a/src/include/postmaster/syslogger.h
+++ b/src/include/postmaster/syslogger.h
@@ -86,7 +86,7 @@ extern PGDLLIMPORT HANDLE syslogPipe[2];
#endif
-extern int SysLogger_Start(void);
+extern int SysLogger_Start(int child_slot);
extern void write_syslogger_file(const char *buffer, int count, int destination);
--
2.39.2
view thread (39+ messages) latest in thread
reply
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Reply to all the recipients using the --to and --cc options:
reply via email
To: [email protected]
Cc: [email protected], [email protected]
Subject: Re: Refactoring postmaster's code to cleanup after child exit
In-Reply-To: <[email protected]>
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox