From ff47c0c41af0d9b7c70733ade3c4af94ac506171 Mon Sep 17 00:00:00 2001 From: Thomas Munro Date: Wed, 11 Apr 2018 11:30:36 +1200 Subject: [PATCH] Exit by default if postmaster dies. Users of the WaitEventSet and WaitLatch() APIs can now choose between asking for W_POSTMASTER_DEATH explicitly and then handling it, or not asking for it and getting the new default behavior. Update call sites to use the new simplified interface. In all cases where the behavior was to exit(1) or proc_exit(1), remove that code and rely on the default behavior. In some cases where WL_POSTMASTER_DEATH was requested but apparently ignored, also use the new default behavior because that was probably a bug. The remaining cases of explicit WL_POSTMASTER_DEATH events are retained because they do something special when the postmaster dies. Author: Thomas Munro Discussion: https://postgr.es/m/CAEepm%3D1TCviRykkUb69ppWLr_V697rzd1j3eZsRMmbXvETfqbQ%40mail.gmail.com, https://postgr.es/m/CAEepm=2LqHzizbe7muD7-2yHUbTOoF7Q+qkSD5Q41kuhttRTwA@mail.gmail.com --- contrib/pg_prewarm/autoprewarm.c | 6 ++-- src/backend/access/transam/parallel.c | 6 +--- src/backend/access/transam/xlog.c | 6 ++-- src/backend/libpq/be-secure.c | 4 +-- src/backend/libpq/pqcomm.c | 9 +++-- src/backend/postmaster/autovacuum.c | 16 +++------ src/backend/postmaster/bgwriter.c | 11 ++---- src/backend/postmaster/checkpointer.c | 16 +++------ src/backend/postmaster/pgarch.c | 4 ++- src/backend/postmaster/walwriter.c | 16 +++------ src/backend/replication/basebackup.c | 2 +- .../libpqwalreceiver/libpqwalreceiver.c | 12 +------ src/backend/replication/logical/launcher.c | 24 +++---------- src/backend/replication/logical/tablesync.c | 29 ++++----------- src/backend/replication/logical/worker.c | 7 +--- src/backend/replication/syncrep.c | 18 +++++----- src/backend/replication/walreceiver.c | 20 ++--------- src/backend/replication/walsender.c | 29 ++------------- src/backend/storage/ipc/latch.c | 42 +++++++++++++++++++++- src/backend/storage/lmgr/condition_variable.c | 11 ------ src/backend/utils/init/miscinit.c | 6 ++-- src/include/libpq/libpq.h | 2 ++ src/test/modules/worker_spi/worker_spi.c | 6 +--- 23 files changed, 108 insertions(+), 194 deletions(-) diff --git a/contrib/pg_prewarm/autoprewarm.c b/contrib/pg_prewarm/autoprewarm.c index bb28e237d17..ee96ff032c9 100644 --- a/contrib/pg_prewarm/autoprewarm.c +++ b/contrib/pg_prewarm/autoprewarm.c @@ -219,7 +219,7 @@ autoprewarm_main(Datum main_arg) { /* We're only dumping at shutdown, so just wait forever. */ rc = WaitLatch(&MyProc->procLatch, - WL_LATCH_SET | WL_POSTMASTER_DEATH, + WL_LATCH_SET, -1L, PG_WAIT_EXTENSION); } @@ -248,15 +248,13 @@ autoprewarm_main(Datum main_arg) /* Sleep until the next dump time. */ rc = WaitLatch(&MyProc->procLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, delay_in_ms, PG_WAIT_EXTENSION); } /* Reset the latch, bail out if postmaster died, otherwise loop. */ ResetLatch(&MyProc->procLatch); - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); } /* diff --git a/src/backend/access/transam/parallel.c b/src/backend/access/transam/parallel.c index 1d631b72755..a238ec65104 100644 --- a/src/backend/access/transam/parallel.c +++ b/src/backend/access/transam/parallel.c @@ -672,13 +672,9 @@ WaitForParallelWorkersToAttach(ParallelContext *pcxt) * just end up waiting for the same worker again. */ rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_POSTMASTER_DEATH, + WL_LATCH_SET, -1, WAIT_EVENT_BGWORKER_STARTUP); - /* emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); - if (rc & WL_LATCH_SET) ResetLatch(MyLatch); } diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index 08dc9ba031b..1ce15f09b2d 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -6120,7 +6120,7 @@ recoveryApplyDelay(XLogReaderState *record) secs, microsecs / 1000); WaitLatch(&XLogCtl->recoveryWakeupLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, secs * 1000L + microsecs / 1000, WAIT_EVENT_RECOVERY_APPLY_DELAY); } @@ -11908,7 +11908,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, (secs * 1000 + usecs / 1000); WaitLatch(&XLogCtl->recoveryWakeupLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, wait_time, WAIT_EVENT_RECOVERY_WAL_STREAM); ResetLatch(&XLogCtl->recoveryWakeupLatch); now = GetCurrentTimestamp(); @@ -12084,7 +12084,7 @@ WaitForWALToBecomeAvailable(XLogRecPtr RecPtr, bool randAccess, * to react to a trigger file promptly. */ WaitLatch(&XLogCtl->recoveryWakeupLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, 5000L, WAIT_EVENT_RECOVERY_WAL_ALL); ResetLatch(&XLogCtl->recoveryWakeupLatch); break; diff --git a/src/backend/libpq/be-secure.c b/src/backend/libpq/be-secure.c index edfe2c0751c..206bf7d60b8 100644 --- a/src/backend/libpq/be-secure.c +++ b/src/backend/libpq/be-secure.c @@ -165,7 +165,7 @@ retry: Assert(waitfor); - ModifyWaitEvent(FeBeWaitSet, 0, waitfor, NULL); + ModifyWaitEvent(FeBeWaitSet, FeBeWaitSetSocketPos, waitfor, NULL); WaitEventSetWait(FeBeWaitSet, -1 /* no timeout */ , &event, 1, WAIT_EVENT_CLIENT_READ); @@ -267,7 +267,7 @@ retry: Assert(waitfor); - ModifyWaitEvent(FeBeWaitSet, 0, waitfor, NULL); + ModifyWaitEvent(FeBeWaitSet, FeBeWaitSetSocketPos, waitfor, NULL); WaitEventSetWait(FeBeWaitSet, -1 /* no timeout */ , &event, 1, WAIT_EVENT_CLIENT_WRITE); diff --git a/src/backend/libpq/pqcomm.c b/src/backend/libpq/pqcomm.c index a4f6d4deeb4..4f5ce20cb22 100644 --- a/src/backend/libpq/pqcomm.c +++ b/src/backend/libpq/pqcomm.c @@ -184,6 +184,8 @@ static PQcommMethods PqCommSocketMethods = { PQcommMethods *PqCommMethods = &PqCommSocketMethods; WaitEventSet *FeBeWaitSet; +int FeBeWaitSetSocketPos; +int FeBeWaitSetLatchPos; /* -------------------------------- @@ -221,9 +223,10 @@ pq_init(void) #endif FeBeWaitSet = CreateWaitEventSet(TopMemoryContext, 3); - AddWaitEventToSet(FeBeWaitSet, WL_SOCKET_WRITEABLE, MyProcPort->sock, - NULL, NULL); - AddWaitEventToSet(FeBeWaitSet, WL_LATCH_SET, -1, MyLatch, NULL); + FeBeWaitSetSocketPos = AddWaitEventToSet(FeBeWaitSet, WL_SOCKET_WRITEABLE, + MyProcPort->sock, NULL, NULL); + FeBeWaitSetLatchPos = AddWaitEventToSet(FeBeWaitSet, WL_LATCH_SET, -1, + MyLatch, NULL); AddWaitEventToSet(FeBeWaitSet, WL_POSTMASTER_DEATH, -1, NULL, NULL); } diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 3b90b16daec..a566a01feeb 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -632,7 +632,6 @@ AutoVacLauncherMain(int argc, char *argv[]) struct timeval nap; TimestampTz current_time = 0; bool can_launch; - int rc; /* * This loop is a bit different from the normal use of WaitLatch, @@ -648,23 +647,16 @@ AutoVacLauncherMain(int argc, char *argv[]) * Wait until naptime expires or we get some type of signal (all the * signal handlers will wake us by calling SetLatch). */ - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, - (nap.tv_sec * 1000L) + (nap.tv_usec / 1000L), - WAIT_EVENT_AUTOVACUUM_MAIN); + WaitLatch(MyLatch, + WL_LATCH_SET | WL_TIMEOUT, + (nap.tv_sec * 1000L) + (nap.tv_usec / 1000L), + WAIT_EVENT_AUTOVACUUM_MAIN); ResetLatch(MyLatch); /* Process sinval catchup interrupts that happened while sleeping */ ProcessCatchupInterrupt(); - /* - * Emergency bailout if postmaster has died. This is to avoid the - * necessity for manual cleanup of all postmaster children. - */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); - /* the normal shutdown case */ if (got_SIGTERM) break; diff --git a/src/backend/postmaster/bgwriter.c b/src/backend/postmaster/bgwriter.c index b7813d7a4fb..f1461197562 100644 --- a/src/backend/postmaster/bgwriter.c +++ b/src/backend/postmaster/bgwriter.c @@ -349,7 +349,7 @@ BackgroundWriterMain(void) * normal operation. */ rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, BgWriterDelay /* ms */ , WAIT_EVENT_BGWRITER_MAIN); /* @@ -376,20 +376,13 @@ BackgroundWriterMain(void) StrategyNotifyBgWriter(MyProc->pgprocno); /* Sleep ... */ rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, BgWriterDelay * HIBERNATE_FACTOR, WAIT_EVENT_BGWRITER_HIBERNATE); /* Reset the notification request in case we timed out */ StrategyNotifyBgWriter(-1); } - /* - * Emergency bailout if postmaster has died. This is to avoid the - * necessity for manual cleanup of all postmaster children. - */ - if (rc & WL_POSTMASTER_DEATH) - exit(1); - prev_hibernate = can_hibernate; } } diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c index 4b452e7cee6..5072d23e8c4 100644 --- a/src/backend/postmaster/checkpointer.c +++ b/src/backend/postmaster/checkpointer.c @@ -354,7 +354,6 @@ CheckpointerMain(void) pg_time_t now; int elapsed_secs; int cur_timeout; - int rc; /* Clear any already-pending wakeups */ ResetLatch(MyLatch); @@ -555,17 +554,10 @@ CheckpointerMain(void) cur_timeout = Min(cur_timeout, XLogArchiveTimeout - elapsed_secs); } - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, - cur_timeout * 1000L /* convert to ms */ , - WAIT_EVENT_CHECKPOINTER_MAIN); - - /* - * Emergency bailout if postmaster has died. This is to avoid the - * necessity for manual cleanup of all postmaster children. - */ - if (rc & WL_POSTMASTER_DEATH) - exit(1); + WaitLatch(MyLatch, + WL_LATCH_SET | WL_TIMEOUT, + cur_timeout * 1000L /* convert to ms */ , + WAIT_EVENT_CHECKPOINTER_MAIN); } } diff --git a/src/backend/postmaster/pgarch.c b/src/backend/postmaster/pgarch.c index 885e85ad8af..e43ac4d4f47 100644 --- a/src/backend/postmaster/pgarch.c +++ b/src/backend/postmaster/pgarch.c @@ -393,6 +393,8 @@ pgarch_MainLoop(void) WAIT_EVENT_ARCHIVER_MAIN); if (rc & WL_TIMEOUT) wakened = true; + if (rc & WL_POSTMASTER_DEATH) + time_to_stop = true; } else wakened = true; @@ -403,7 +405,7 @@ pgarch_MainLoop(void) * or after completing one more archiving cycle after receiving * SIGUSR2. */ - } while (PostmasterIsAlive() && !time_to_stop); + } while (!time_to_stop); } /* diff --git a/src/backend/postmaster/walwriter.c b/src/backend/postmaster/walwriter.c index 4fa3a3b0aaf..d36ff1b0d54 100644 --- a/src/backend/postmaster/walwriter.c +++ b/src/backend/postmaster/walwriter.c @@ -237,7 +237,6 @@ WalWriterMain(void) for (;;) { long cur_timeout; - int rc; /* * Advertise whether we might hibernate in this cycle. We do this @@ -290,17 +289,10 @@ WalWriterMain(void) else cur_timeout = WalWriterDelay * HIBERNATE_FACTOR; - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, - cur_timeout, - WAIT_EVENT_WAL_WRITER_MAIN); - - /* - * Emergency bailout if postmaster has died. This is to avoid the - * necessity for manual cleanup of all postmaster children. - */ - if (rc & WL_POSTMASTER_DEATH) - exit(1); + WaitLatch(MyLatch, + WL_LATCH_SET | WL_TIMEOUT, + cur_timeout, + WAIT_EVENT_WAL_WRITER_MAIN); } } diff --git a/src/backend/replication/basebackup.c b/src/backend/replication/basebackup.c index a79048d233d..8087352dc79 100644 --- a/src/backend/replication/basebackup.c +++ b/src/backend/replication/basebackup.c @@ -1684,7 +1684,7 @@ throttle(size_t increment) * the maximum time to sleep. Thus the cast to long is safe. */ wait_result = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, (long) (sleep / 1000), WAIT_EVENT_BASE_BACKUP_THROTTLE); diff --git a/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c b/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c index e4d261bd793..16dbd34d819 100644 --- a/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c +++ b/src/backend/replication/libpqwalreceiver/libpqwalreceiver.c @@ -186,16 +186,11 @@ libpqrcv_connect(const char *conninfo, bool logical, const char *appname, io_flag = WL_SOCKET_WRITEABLE; rc = WaitLatchOrSocket(MyLatch, - WL_POSTMASTER_DEATH | WL_LATCH_SET | io_flag, PQsocket(conn->streamConn), 0, WAIT_EVENT_LIBPQWALRECEIVER_CONNECT); - /* Emergency bailout? */ - if (rc & WL_POSTMASTER_DEATH) - exit(1); - /* Interrupted? */ if (rc & WL_LATCH_SET) { @@ -610,16 +605,11 @@ libpqrcv_PQexec(PGconn *streamConn, const char *query) * replication connection. */ rc = WaitLatchOrSocket(MyLatch, - WL_POSTMASTER_DEATH | WL_SOCKET_READABLE | - WL_LATCH_SET, + WL_SOCKET_READABLE | WL_LATCH_SET, PQsocket(streamConn), 0, WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE); - /* Emergency bailout? */ - if (rc & WL_POSTMASTER_DEATH) - exit(1); - /* Interrupted? */ if (rc & WL_LATCH_SET) { diff --git a/src/backend/replication/logical/launcher.c b/src/backend/replication/logical/launcher.c index 6ef333b7257..0848539a83e 100644 --- a/src/backend/replication/logical/launcher.c +++ b/src/backend/replication/logical/launcher.c @@ -209,13 +209,9 @@ WaitForReplicationWorkerAttach(LogicalRepWorker *worker, * about the worker attach. But we don't expect to have to wait long. */ rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, 10L, WAIT_EVENT_BGWORKER_STARTUP); - /* emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); - if (rc & WL_LATCH_SET) { ResetLatch(MyLatch); @@ -486,13 +482,9 @@ logicalrep_worker_stop(Oid subid, Oid relid) /* Wait a bit --- we don't expect to have to wait long. */ rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, 10L, WAIT_EVENT_BGWORKER_STARTUP); - /* emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); - if (rc & WL_LATCH_SET) { ResetLatch(MyLatch); @@ -534,13 +526,9 @@ logicalrep_worker_stop(Oid subid, Oid relid) /* Wait a bit --- we don't expect to have to wait long. */ rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, 10L, WAIT_EVENT_BGWORKER_SHUTDOWN); - /* emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); - if (rc & WL_LATCH_SET) { ResetLatch(MyLatch); @@ -972,14 +960,10 @@ ApplyLauncherMain(Datum main_arg) /* Wait for more work. */ rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, wait_time, WAIT_EVENT_LOGICAL_LAUNCHER_MAIN); - /* emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); - if (rc & WL_LATCH_SET) { ResetLatch(MyLatch); diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index acc6498567d..e995c5383f9 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -159,7 +159,6 @@ finish_sync_worker(void) static bool wait_for_relation_state_change(Oid relid, char expected_state) { - int rc; char state; for (;;) @@ -192,13 +191,9 @@ wait_for_relation_state_change(Oid relid, char expected_state) if (!worker) return false; - rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, - 1000L, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE); - - /* emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); + WaitLatch(MyLatch, + WL_LATCH_SET | WL_TIMEOUT, + 1000L, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE); ResetLatch(MyLatch); } @@ -250,13 +245,9 @@ wait_for_worker_state_change(char expected_state) * but use a timeout in case it dies without sending one. */ rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, 1000L, WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE); - /* emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); - if (rc & WL_LATCH_SET) ResetLatch(MyLatch); } @@ -593,7 +584,6 @@ copy_read_data(void *outbuf, int minread, int maxread) while (maxread > 0 && bytesread < minread) { pgsocket fd = PGINVALID_SOCKET; - int rc; int len; char *buf = NULL; @@ -632,14 +622,9 @@ copy_read_data(void *outbuf, int minread, int maxread) /* * Wait for more data or latch. */ - rc = WaitLatchOrSocket(MyLatch, - WL_SOCKET_READABLE | WL_LATCH_SET | - WL_TIMEOUT | WL_POSTMASTER_DEATH, - fd, 1000L, WAIT_EVENT_LOGICAL_SYNC_DATA); - - /* Emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); + WaitLatchOrSocket(MyLatch, + WL_SOCKET_READABLE | WL_LATCH_SET | WL_TIMEOUT, + fd, 1000L, WAIT_EVENT_LOGICAL_SYNC_DATA); ResetLatch(MyLatch); } diff --git a/src/backend/replication/logical/worker.c b/src/backend/replication/logical/worker.c index aa7e27179e8..d28cdd538ea 100644 --- a/src/backend/replication/logical/worker.c +++ b/src/backend/replication/logical/worker.c @@ -1254,15 +1254,10 @@ LogicalRepApplyLoop(XLogRecPtr last_received) wait_time = NAPTIME_PER_CYCLE; rc = WaitLatchOrSocket(MyLatch, - WL_SOCKET_READABLE | WL_LATCH_SET | - WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_SOCKET_READABLE | WL_LATCH_SET | WL_TIMEOUT, fd, wait_time, WAIT_EVENT_LOGICAL_APPLY_MAIN); - /* Emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); - if (rc & WL_LATCH_SET) { ResetLatch(MyLatch); diff --git a/src/backend/replication/syncrep.c b/src/backend/replication/syncrep.c index 75d26817192..7fc784f5916 100644 --- a/src/backend/replication/syncrep.c +++ b/src/backend/replication/syncrep.c @@ -214,6 +214,8 @@ SyncRepWaitForLSN(XLogRecPtr lsn, bool commit) */ for (;;) { + int rc; + /* Must reset the latch before testing state. */ ResetLatch(MyLatch); @@ -266,25 +268,25 @@ SyncRepWaitForLSN(XLogRecPtr lsn, bool commit) break; } + /* + * Wait on latch. Any condition that should wake us up will set the + * latch, so no need for timeout. + */ + rc = WaitLatch(MyLatch, WL_LATCH_SET | WL_POSTMASTER_DEATH, -1, + WAIT_EVENT_SYNC_REP); + /* * If the postmaster dies, we'll probably never get an * acknowledgement, because all the wal sender processes will exit. So * just bail out. */ - if (!PostmasterIsAlive()) + if (rc & WL_POSTMASTER_DEATH) { ProcDiePending = true; whereToSendOutput = DestNone; SyncRepCancelWait(); break; } - - /* - * Wait on latch. Any condition that should wake us up will set the - * latch, so no need for timeout. - */ - WaitLatch(MyLatch, WL_LATCH_SET | WL_POSTMASTER_DEATH, -1, - WAIT_EVENT_SYNC_REP); } /* diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c index b9dab322d6b..b561bf94017 100644 --- a/src/backend/replication/walreceiver.c +++ b/src/backend/replication/walreceiver.c @@ -513,7 +513,7 @@ WalReceiverMain(void) */ Assert(wait_fd != PGINVALID_SOCKET); rc = WaitLatchOrSocket(walrcv->latch, - WL_POSTMASTER_DEATH | WL_SOCKET_READABLE | + WL_SOCKET_READABLE | WL_TIMEOUT | WL_LATCH_SET, wait_fd, NAPTIME_PER_CYCLE, @@ -534,15 +534,6 @@ WalReceiverMain(void) XLogWalRcvSendReply(true, false); } } - if (rc & WL_POSTMASTER_DEATH) - { - /* - * Emergency bailout if postmaster has died. This is to - * avoid the necessity for manual cleanup of all - * postmaster children. - */ - exit(1); - } if (rc & WL_TIMEOUT) { /* @@ -683,13 +674,6 @@ WalRcvWaitForStartPosition(XLogRecPtr *startpoint, TimeLineID *startpointTLI) { ResetLatch(walrcv->latch); - /* - * Emergency bailout if postmaster has died. This is to avoid the - * necessity for manual cleanup of all postmaster children. - */ - if (!PostmasterIsAlive()) - exit(1); - ProcessWalRcvInterrupts(); SpinLockAcquire(&walrcv->mutex); @@ -716,7 +700,7 @@ WalRcvWaitForStartPosition(XLogRecPtr *startpoint, TimeLineID *startpointTLI) } SpinLockRelease(&walrcv->mutex); - WaitLatch(walrcv->latch, WL_LATCH_SET | WL_POSTMASTER_DEATH, 0, + WaitLatch(walrcv->latch, WL_LATCH_SET, 0, WAIT_EVENT_WAL_RECEIVER_WAIT_START); } diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index 642e859439f..9a8792a7f94 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -1205,7 +1205,7 @@ WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, sleeptime = WalSndComputeSleeptime(now); - wakeEvents = WL_LATCH_SET | WL_POSTMASTER_DEATH | + wakeEvents = WL_LATCH_SET | WL_SOCKET_WRITEABLE | WL_SOCKET_READABLE | WL_TIMEOUT; /* Sleep until something happens or we time out */ @@ -1213,13 +1213,6 @@ WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid, MyProcPort->sock, sleeptime, WAIT_EVENT_WAL_SENDER_WRITE_DATA); - /* - * Emergency bailout if postmaster has died. This is to avoid the - * necessity for manual cleanup of all postmaster children. - */ - if (!PostmasterIsAlive()) - exit(1); - /* Clear any already-pending wakeups */ ResetLatch(MyLatch); @@ -1300,13 +1293,6 @@ WalSndWaitForWal(XLogRecPtr loc) long sleeptime; TimestampTz now; - /* - * Emergency bailout if postmaster has died. This is to avoid the - * necessity for manual cleanup of all postmaster children. - */ - if (!PostmasterIsAlive()) - exit(1); - /* Clear any already-pending wakeups */ ResetLatch(MyLatch); @@ -1400,8 +1386,7 @@ WalSndWaitForWal(XLogRecPtr loc) */ sleeptime = WalSndComputeSleeptime(now); - wakeEvents = WL_LATCH_SET | WL_POSTMASTER_DEATH | - WL_SOCKET_READABLE | WL_TIMEOUT; + wakeEvents = WL_LATCH_SET | WL_SOCKET_READABLE | WL_TIMEOUT; if (pq_is_send_pending()) wakeEvents |= WL_SOCKET_WRITEABLE; @@ -2108,13 +2093,6 @@ WalSndLoop(WalSndSendDataCallback send_data) { TimestampTz now; - /* - * Emergency bailout if postmaster has died. This is to avoid the - * necessity for manual cleanup of all postmaster children. - */ - if (!PostmasterIsAlive()) - exit(1); - /* Clear any already-pending wakeups */ ResetLatch(MyLatch); @@ -2206,8 +2184,7 @@ WalSndLoop(WalSndSendDataCallback send_data) long sleeptime; int wakeEvents; - wakeEvents = WL_LATCH_SET | WL_POSTMASTER_DEATH | WL_TIMEOUT | - WL_SOCKET_READABLE; + wakeEvents = WL_LATCH_SET | WL_TIMEOUT | WL_SOCKET_READABLE; sleeptime = WalSndComputeSleeptime(now); diff --git a/src/backend/storage/ipc/latch.c b/src/backend/storage/ipc/latch.c index e6706f7fb80..84530d9f6b9 100644 --- a/src/backend/storage/ipc/latch.c +++ b/src/backend/storage/ipc/latch.c @@ -92,6 +92,12 @@ struct WaitEventSet Latch *latch; int latch_pos; + /* + * If the client explicitly asks for WL_POSTMASTER_DEATH, then we'll + * return it. If otherwise we'll exit automatically. + */ + bool exit_on_postmaster_death; + #if defined(WAIT_USE_EPOLL) int epoll_fd; /* epoll_wait returns events in a user provided arrays, allocate once */ @@ -523,6 +529,9 @@ CreateWaitEventSet(MemoryContext context, int nevents) char *data; Size sz = 0; + /* Allow for the implicit WL_POSTMASTER_DEATH event. */ + ++nevents; + /* * Use MAXALIGN size/alignment to guarantee that later uses of memory are * aligned correctly. E.g. epoll_event might need 8 byte alignment on some @@ -591,6 +600,13 @@ CreateWaitEventSet(MemoryContext context, int nevents) StaticAssertStmt(WSA_INVALID_EVENT == NULL, ""); #endif + /* + * Set up the default behavior for postmaster death. The caller can + * override this by explicitly adding a WL_POSTMASTER_DEATH event. + */ + AddWaitEventToSet(set, WL_POSTMASTER_DEATH, -1, NULL, NULL); + set->exit_on_postmaster_death = true; + return set; } @@ -671,6 +687,17 @@ AddWaitEventToSet(WaitEventSet *set, uint32 events, pgsocket fd, Latch *latch, /* not enough space */ Assert(set->nevents < set->nevents_space); + /* + * If the caller explicitly asks for notification of postmaster death, + * then we don't need to do anything because we already installed one. + * We just need to disable the immediate exit behavior. + */ + if (events == WL_POSTMASTER_DEATH && set->nevents > 0) + { + set->exit_on_postmaster_death = false; + return 0; + } + if (latch) { if (latch->owner_pid != MyProcPid) @@ -926,6 +953,7 @@ WaitEventSetWait(WaitEventSet *set, long timeout, instr_time start_time; instr_time cur_time; long cur_timeout = -1; + int i; Assert(nevents > 0); @@ -986,7 +1014,6 @@ WaitEventSetWait(WaitEventSet *set, long timeout, occurred_events->user_data = set->events[set->latch_pos].user_data; occurred_events->events = WL_LATCH_SET; - occurred_events++; returned_events++; break; @@ -1021,6 +1048,19 @@ WaitEventSetWait(WaitEventSet *set, long timeout, pgstat_report_wait_end(); + /* + * Exit immediately if the postmaster died and the caller did not ask to + * handle that event. + */ + if (set->exit_on_postmaster_death) + { + for (i = 0; i < returned_events; ++i) + { + if (occurred_events[i].events == WL_POSTMASTER_DEATH) + exit(1); + } + } + return returned_events; } diff --git a/src/backend/storage/lmgr/condition_variable.c b/src/backend/storage/lmgr/condition_variable.c index ef1d5baf016..7ace6a897f7 100644 --- a/src/backend/storage/lmgr/condition_variable.c +++ b/src/backend/storage/lmgr/condition_variable.c @@ -72,8 +72,6 @@ ConditionVariablePrepareToSleep(ConditionVariable *cv) new_event_set = CreateWaitEventSet(TopMemoryContext, 2); AddWaitEventToSet(new_event_set, WL_LATCH_SET, PGINVALID_SOCKET, MyLatch, NULL); - AddWaitEventToSet(new_event_set, WL_POSTMASTER_DEATH, PGINVALID_SOCKET, - NULL, NULL); /* Don't set cv_wait_event_set until we have a correct WES. */ cv_wait_event_set = new_event_set; } @@ -156,15 +154,6 @@ ConditionVariableSleep(ConditionVariable *cv, uint32 wait_event_info) */ WaitEventSetWait(cv_wait_event_set, -1, &event, 1, wait_event_info); - if (event.events & WL_POSTMASTER_DEATH) - { - /* - * Emergency bailout if postmaster has died. This is to avoid the - * necessity for manual cleanup of all postmaster children. - */ - exit(1); - } - /* Reset latch before examining the state of the wait list. */ ResetLatch(MyLatch); diff --git a/src/backend/utils/init/miscinit.c b/src/backend/utils/init/miscinit.c index 03b28c3604a..a42e10f12ae 100644 --- a/src/backend/utils/init/miscinit.c +++ b/src/backend/utils/init/miscinit.c @@ -346,7 +346,8 @@ SwitchToSharedLatch(void) MyLatch = &MyProc->procLatch; if (FeBeWaitSet) - ModifyWaitEvent(FeBeWaitSet, 1, WL_LATCH_SET, MyLatch); + ModifyWaitEvent(FeBeWaitSet, FeBeWaitSetLatchPos, WL_LATCH_SET, + MyLatch); /* * Set the shared latch as the local one might have been set. This @@ -365,7 +366,8 @@ SwitchBackToLocalLatch(void) MyLatch = &LocalLatchData; if (FeBeWaitSet) - ModifyWaitEvent(FeBeWaitSet, 1, WL_LATCH_SET, MyLatch); + ModifyWaitEvent(FeBeWaitSet, FeBeWaitSetLatchPos, WL_LATCH_SET, + MyLatch); SetLatch(MyLatch); } diff --git a/src/include/libpq/libpq.h b/src/include/libpq/libpq.h index a74ad521b5a..5611db97735 100644 --- a/src/include/libpq/libpq.h +++ b/src/include/libpq/libpq.h @@ -96,6 +96,8 @@ extern ssize_t secure_raw_write(Port *port, const void *ptr, size_t len); extern bool ssl_loaded_verify_locations; extern WaitEventSet *FeBeWaitSet; +extern int FeBeWaitSetSocketPos; +extern int FeBeWaitSetLatchPos; /* GUCs */ extern char *SSLCipherSuites; diff --git a/src/test/modules/worker_spi/worker_spi.c b/src/test/modules/worker_spi/worker_spi.c index 0d705a3f2ed..c991bf28f53 100644 --- a/src/test/modules/worker_spi/worker_spi.c +++ b/src/test/modules/worker_spi/worker_spi.c @@ -226,15 +226,11 @@ worker_spi_main(Datum main_arg) * background process goes away immediately in an emergency. */ rc = WaitLatch(MyLatch, - WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH, + WL_LATCH_SET | WL_TIMEOUT, worker_spi_naptime * 1000L, PG_WAIT_EXTENSION); ResetLatch(MyLatch); - /* emergency bailout if postmaster has died */ - if (rc & WL_POSTMASTER_DEATH) - proc_exit(1); - CHECK_FOR_INTERRUPTS(); /* -- 2.16.2