* postmaster ever unblocks signals.
*
* pqinitmask() must have been invoked previously.
- *
- * On Windows, this function is just an alias for pqsignal()
- * (and note that it's calling the code in src/backend/port/win32/signal.c,
- * not src/port/pqsignal.c). On that platform, the postmaster's signal
- * handlers still have to block signals for themselves.
*/
pqsigfunc
pqsignal_pm(int signo, pqsigfunc func)
{
-#ifndef WIN32
struct sigaction act,
oact;
if (sigaction(signo, &act, &oact) < 0)
return SIG_ERR;
return oact.sa_handler;
-#else /* WIN32 */
- return pqsignal(signo, func);
-#endif
}
static CRITICAL_SECTION pg_signal_crit_sec;
/* Note that array elements 0 are unused since they correspond to signal 0 */
-static pqsigfunc pg_signal_array[PG_SIGNAL_COUNT];
+static struct sigaction pg_signal_array[PG_SIGNAL_COUNT];
static pqsigfunc pg_signal_defaults[PG_SIGNAL_COUNT];
for (i = 0; i < PG_SIGNAL_COUNT; i++)
{
- pg_signal_array[i] = SIG_DFL;
+ pg_signal_array[i].sa_handler = SIG_DFL;
+ pg_signal_array[i].sa_mask = 0;
+ pg_signal_array[i].sa_flags = 0;
pg_signal_defaults[i] = SIG_IGN;
}
pg_signal_mask = 0;
if (exec_mask & sigmask(i))
{
/* Execute this signal */
- pqsigfunc sig = pg_signal_array[i];
+ struct sigaction *act = &pg_signal_array[i];
+ pqsigfunc sig = act->sa_handler;
if (sig == SIG_DFL)
sig = pg_signal_defaults[i];
pg_signal_queue &= ~sigmask(i);
if (sig != SIG_ERR && sig != SIG_IGN && sig != SIG_DFL)
{
+ sigset_t block_mask;
+ sigset_t save_mask;
+
LeaveCriticalSection(&pg_signal_crit_sec);
+
+ block_mask = act->sa_mask;
+ if ((act->sa_flags & SA_NODEFER) == 0)
+ block_mask |= sigmask(i);
+
+ sigprocmask(SIG_BLOCK, &block_mask, &save_mask);
sig(i);
+ sigprocmask(SIG_SETMASK, &save_mask, NULL);
+
EnterCriticalSection(&pg_signal_crit_sec);
break; /* Restart outer loop, in case signal mask or
* queue has been modified inside signal
return 0;
}
-
/*
* Unix-like signal handler installation
*
* Only called on main thread, no sync required
*/
-pqsigfunc
-pqsignal(int signum, pqsigfunc handler)
+int
+pqsigaction(int signum, const struct sigaction *act,
+ struct sigaction *oldact)
{
- pqsigfunc prevfunc;
-
if (signum >= PG_SIGNAL_COUNT || signum < 0)
- return SIG_ERR;
- prevfunc = pg_signal_array[signum];
- pg_signal_array[signum] = handler;
- return prevfunc;
+ {
+ errno = EINVAL;
+ return -1;
+ }
+ if (oldact)
+ *oldact = pg_signal_array[signum];
+ if (act)
+ pg_signal_array[signum] = *act;
+ return 0;
}
/* Create the signal listener pipe for specified PID */
* is used by all child processes and client processes). That has a
* couple of special behaviors:
*
- * 1. Except on Windows, we tell sigaction() to block all signals for the
- * duration of the signal handler. This is faster than our old approach
- * of blocking/unblocking explicitly in the signal handler, and it should
- * also prevent excessive stack consumption if signals arrive quickly.
+ * 1. We tell sigaction() to block all signals for the duration of the
+ * signal handler. This is faster than our old approach of
+ * blocking/unblocking explicitly in the signal handler, and it should also
+ * prevent excessive stack consumption if signals arrive quickly.
*
* 2. We do not set the SA_RESTART flag. This is because signals will be
* blocked at all times except when ServerLoop is waiting for something to
{
int save_errno = errno;
- /*
- * We rely on the signal mechanism to have blocked all signals ... except
- * on Windows, which lacks sigaction(), so we have to do it manually.
- */
-#ifdef WIN32
- PG_SETMASK(&BlockSig);
-#endif
-
if (Shutdown <= SmartShutdown)
{
ereport(LOG,
#endif
}
-#ifdef WIN32
- PG_SETMASK(&UnBlockSig);
-#endif
-
errno = save_errno;
}
{
int save_errno = errno;
- /*
- * We rely on the signal mechanism to have blocked all signals ... except
- * on Windows, which lacks sigaction(), so we have to do it manually.
- */
-#ifdef WIN32
- PG_SETMASK(&BlockSig);
-#endif
-
ereport(DEBUG2,
(errmsg_internal("postmaster received signal %d",
postgres_signal_arg)));
break;
}
-#ifdef WIN32
- PG_SETMASK(&UnBlockSig);
-#endif
-
errno = save_errno;
}
int pid; /* process id of dead child process */
int exitstatus; /* its exit status */
- /*
- * We rely on the signal mechanism to have blocked all signals ... except
- * on Windows, which lacks sigaction(), so we have to do it manually.
- */
-#ifdef WIN32
- PG_SETMASK(&BlockSig);
-#endif
-
ereport(DEBUG4,
(errmsg_internal("reaping dead processes")));
*/
PostmasterStateMachine();
- /* Done with signal handler */
-#ifdef WIN32
- PG_SETMASK(&UnBlockSig);
-#endif
-
errno = save_errno;
}
{
int save_errno = errno;
- /*
- * We rely on the signal mechanism to have blocked all signals ... except
- * on Windows, which lacks sigaction(), so we have to do it manually.
- */
-#ifdef WIN32
- PG_SETMASK(&BlockSig);
-#endif
-
/*
* RECOVERY_STARTED and BEGIN_HOT_STANDBY signals are ignored in
* unexpected states. If the startup process quickly starts up, completes
signal_child(StartupPID, SIGUSR2);
}
-#ifdef WIN32
- PG_SETMASK(&UnBlockSig);
-#endif
-
errno = save_errno;
}
/* Emulate POSIX sigset_t APIs on Windows */
typedef int sigset_t;
+#define SA_RESTART 1
+#define SA_NODEFER 2
+
+struct sigaction
+{
+ void (*sa_handler) (int);
+ /* sa_sigaction not yet implemented */
+ sigset_t sa_mask;
+ int sa_flags;
+};
+
extern int pqsigprocmask(int how, const sigset_t *set, sigset_t *oset);
+extern int pqsigaction(int signum, const struct sigaction *act,
+ struct sigaction *oldact);
#define SIG_BLOCK 1
#define SIG_UNBLOCK 2
#define SIG_SETMASK 3
#define sigprocmask(how, set, oset) pqsigprocmask((how), (set), (oset))
+#define sigaction(signum, act, oldact) pqsigaction((signum), (act), (oldact))
#define sigemptyset(set) (*(set) = 0)
#define sigfillset(set) (*(set) = ~0)
#define sigaddset(set, signum) (*(set) |= (sigmask(signum)))
#include <signal.h>
-#if !defined(WIN32) || defined(FRONTEND)
+#ifndef FRONTEND
+#include "libpq/pqsignal.h"
+#endif
/*
* Set up a signal handler, with SA_RESTART, for signal "signo"
pqsigfunc
pqsignal(int signo, pqsigfunc func)
{
-#ifndef WIN32
+#if !(defined(WIN32) && defined(FRONTEND))
struct sigaction act,
oact;
if (sigaction(signo, &act, &oact) < 0)
return SIG_ERR;
return oact.sa_handler;
-#else /* WIN32 */
+#else
+ /* Forward to Windows native signal system. */
return signal(signo, func);
#endif
}
-
-#endif /* !defined(WIN32) || defined(FRONTEND) */
projects / postgresql.git / commitdiff