From 6ce0cb44ae8d70beff50945775074d75b944fedb Mon Sep 17 00:00:00 2001 From: Thomas Munro Date: Thu, 19 Nov 2020 12:38:29 +1300 Subject: [PATCH v3 2/4] Use SIGURG rather than SIGUSR1 for latches. Traditionally, SIGUSR1 has been overloaded for ad-hoc signals, procsignal.c signals and latch.c wakeups. Move that last use over to a new dedicated signal. SIGURG reports out-of-band socket data, but PostgreSQL doesn't use that. The signal handler is now installed in all postmaster children by InitializeLatchSupport(). Those wishing to disconnect from it should call ShutdownLatchSupport() which will set it back to SIG_IGN. Future patches will use this separation to avoid the need for a signal handler on some operating systems. Discussion: https://postgr.es/m/CA+hUKGJjxPDpzBE0a3hyUywBvaZuC89yx3jK9RFZgfv_KHU7gg@mail.gmail.com --- src/backend/postmaster/bgworker.c | 19 ++--------- src/backend/postmaster/postmaster.c | 1 + src/backend/storage/ipc/latch.c | 50 ++++++++++++++++++---------- src/backend/storage/ipc/procsignal.c | 2 -- src/include/storage/latch.h | 11 +----- 5 files changed, 37 insertions(+), 46 deletions(-) diff --git a/src/backend/postmaster/bgworker.c b/src/backend/postmaster/bgworker.c index 5a9a0e3435..9241b4edf4 100644 --- a/src/backend/postmaster/bgworker.c +++ b/src/backend/postmaster/bgworker.c @@ -654,22 +654,6 @@ bgworker_die(SIGNAL_ARGS) MyBgworkerEntry->bgw_type))); } -/* - * Standard SIGUSR1 handler for unconnected workers - * - * Here, we want to make sure an unconnected worker will at least heed - * latch activity. - */ -static void -bgworker_sigusr1_handler(SIGNAL_ARGS) -{ - int save_errno = errno; - - latch_sigusr1_handler(); - - errno = save_errno; -} - /* * Start a new background worker * @@ -700,6 +684,7 @@ StartBackgroundWorker(void) */ if ((worker->bgw_flags & BGWORKER_SHMEM_ACCESS) == 0) { + ShutdownLatchSupport(); dsm_detach_all(); PGSharedMemoryDetach(); } @@ -727,7 +712,7 @@ StartBackgroundWorker(void) else { pqsignal(SIGINT, SIG_IGN); - pqsignal(SIGUSR1, bgworker_sigusr1_handler); + pqsignal(SIGUSR1, SIG_IGN); pqsignal(SIGFPE, SIG_IGN); } pqsignal(SIGTERM, bgworker_die); diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index b7799ed1d2..2632d56ed4 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -654,6 +654,7 @@ PostmasterMain(int argc, char *argv[]) pqsignal_pm(SIGUSR1, sigusr1_handler); /* message from child process */ pqsignal_pm(SIGUSR2, dummy_handler); /* unused, reserve for children */ pqsignal_pm(SIGCHLD, reaper); /* handle child termination */ + pqsignal_pm(SIGURG, SIG_IGN); /* ignored */ /* * No other place in Postgres should touch SIGTTIN/SIGTTOU handling. We diff --git a/src/backend/storage/ipc/latch.c b/src/backend/storage/ipc/latch.c index f4768b79c2..ca6196df14 100644 --- a/src/backend/storage/ipc/latch.c +++ b/src/backend/storage/ipc/latch.c @@ -16,7 +16,7 @@ * * When SetLatch is called from the same process that owns the latch, * SetLatch writes the byte directly to the pipe. If it's owned by another - * process, SIGUSR1 is sent and the signal handler in the waiting process + * process, SIGURG is sent and the signal handler in the waiting process * writes the byte to the pipe on behalf of the signaling process. * * The Windows implementation uses Windows events that are inherited by all @@ -148,6 +148,7 @@ static int selfpipe_writefd = -1; static int selfpipe_owner_pid = 0; /* Private function prototypes */ +static void latch_sigurg_handler(SIGNAL_ARGS); static void sendSelfPipeByte(void); static void drainSelfPipe(void); #endif /* WIN32 */ @@ -244,6 +245,8 @@ InitializeLatchSupport(void) /* Tell fd.c about these two long-lived FDs */ ReserveExternalFD(); ReserveExternalFD(); + + pqsignal(SIGURG, latch_sigurg_handler); #else /* currently, nothing to do here for Windows */ #endif @@ -267,6 +270,24 @@ InitializeLatchWaitSet(void) Assert(latch_pos == LatchWaitSetLatchPos); } +void +ShutdownLatchSupport(void) +{ + pqsignal(SIGURG, SIG_IGN); + + if (LatchWaitSet) + { + FreeWaitEventSet(LatchWaitSet); + LatchWaitSet = NULL; + } + + close(selfpipe_readfd); + close(selfpipe_writefd); + selfpipe_readfd = -1; + selfpipe_writefd = -1; + selfpipe_owner_pid = InvalidPid; +} + /* * Initialize a process-local latch. */ @@ -335,10 +356,6 @@ InitSharedLatch(Latch *latch) * any sort of locking here, meaning that we could fail to detect the error * if two processes try to own the same latch at about the same time. If * there is any risk of that, caller must provide an interlock to prevent it. - * - * In any process that calls OwnLatch(), make sure that - * latch_sigusr1_handler() is called from the SIGUSR1 signal handler, - * as shared latches use SIGUSR1 for inter-process communication. */ void OwnLatch(Latch *latch) @@ -562,7 +579,7 @@ SetLatch(Latch *latch) sendSelfPipeByte(); } else - kill(owner_pid, SIGUSR1); + kill(owner_pid, SIGURG); #else /* @@ -1285,7 +1302,7 @@ WaitEventSetWait(WaitEventSet *set, long timeout, * the pipe-buffer fill up we're still ok, because the pipe is in * nonblocking mode. It's unlikely for that to happen, because the * self pipe isn't filled unless we're blocking (waiting = true), or - * from inside a signal handler in latch_sigusr1_handler(). + * from inside a signal handler in latch_sigurg_handler(). * * On windows, we'll also notice if there's a pending event for the * latch when blocking, but there's no danger of anything filling up, @@ -1951,22 +1968,21 @@ WaitEventSetWaitBlock(WaitEventSet *set, int cur_timeout, } #endif +#ifndef WIN32 /* - * SetLatch uses SIGUSR1 to wake up the process waiting on the latch. - * - * Wake up WaitLatch, if we're waiting. (We might not be, since SIGUSR1 is - * overloaded for multiple purposes; or we might not have reached WaitLatch - * yet, in which case we don't need to fill the pipe either.) + * SetLatch uses SIGURG to wake up the process waiting on the latch. * - * NB: when calling this in a signal handler, be sure to save and restore - * errno around it. + * Wake up WaitLatch, if we're waiting. */ -#ifndef WIN32 -void -latch_sigusr1_handler(void) +static void +latch_sigurg_handler(SIGNAL_ARGS) { + int save_errno = errno; + if (waiting) sendSelfPipeByte(); + + errno = save_errno; } #endif /* !WIN32 */ diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c index ffe67acea1..a6b60ca15b 100644 --- a/src/backend/storage/ipc/procsignal.c +++ b/src/backend/storage/ipc/procsignal.c @@ -587,7 +587,5 @@ procsignal_sigusr1_handler(SIGNAL_ARGS) SetLatch(MyLatch); - latch_sigusr1_handler(); - errno = save_errno; } diff --git a/src/include/storage/latch.h b/src/include/storage/latch.h index d0da7e5d31..382311ab4a 100644 --- a/src/include/storage/latch.h +++ b/src/include/storage/latch.h @@ -163,6 +163,7 @@ extern void OwnLatch(Latch *latch); extern void DisownLatch(Latch *latch); extern void SetLatch(Latch *latch); extern void ResetLatch(Latch *latch); +extern void ShutdownLatchSupport(void); extern WaitEventSet *CreateWaitEventSet(MemoryContext context, int nevents); extern void FreeWaitEventSet(WaitEventSet *set); @@ -179,14 +180,4 @@ extern int WaitLatchOrSocket(Latch *latch, int wakeEvents, pgsocket sock, long timeout, uint32 wait_event_info); extern void InitializeLatchWaitSet(void); -/* - * Unix implementation uses SIGUSR1 for inter-process signaling. - * Win32 doesn't need this. - */ -#ifndef WIN32 -extern void latch_sigusr1_handler(void); -#else -#define latch_sigusr1_handler() ((void) 0) -#endif - #endif /* LATCH_H */ -- 2.20.1