InterruptPending = false;
ProcDiePending = false;
QueryCancelPending = false;
- /* And let's just make *sure* we're not interrupted ... */
- ImmediateInterruptOK = false;
InterruptHoldoffCount = 1;
CritSectionCount = 0;
{
InterruptPending = true;
ProcDiePending = true;
-
- /*
- * If we're waiting for input or a lock so that it's safe to
- * interrupt, service the interrupt immediately
- */
- if (ImmediateInterruptOK)
- ProcessInterrupts();
}
/* If we're still here, waken anything waiting on the process latch */
{
InterruptPending = true;
QueryCancelPending = true;
-
- /*
- * If we're waiting for input or a lock so that it's safe to
- * interrupt, service the interrupt immediately
- */
- if (ImmediateInterruptOK)
- ProcessInterrupts();
}
/* If we're still here, waken anything waiting on the process latch */
*/
if (reason == PROCSIG_RECOVERY_CONFLICT_DATABASE)
RecoveryConflictRetryable = false;
-
- /*
- * If we're waiting for input or a lock so that it's safe to
- * interrupt, service the interrupt immediately.
- */
- if (ImmediateInterruptOK)
- ProcessInterrupts();
}
/*
{
ProcDiePending = false;
QueryCancelPending = false; /* ProcDie trumps QueryCancel */
- ImmediateInterruptOK = false; /* not idle anymore */
LockErrorCleanup();
/* As in quickdie, don't risk sending to client during auth */
if (ClientAuthInProgress && whereToSendOutput == DestRemote)
if (ClientConnectionLost)
{
QueryCancelPending = false; /* lost connection trumps QueryCancel */
- ImmediateInterruptOK = false; /* not idle anymore */
LockErrorCleanup();
/* don't send to client, we already know the connection to be dead. */
whereToSendOutput = DestNone;
if (RecoveryConflictPending && DoingCommandRead)
{
QueryCancelPending = false; /* this trumps QueryCancel */
- ImmediateInterruptOK = false; /* not idle anymore */
RecoveryConflictPending = false;
LockErrorCleanup();
pgstat_report_recovery_conflict(RecoveryConflictReason);
*/
if (get_timeout_indicator(LOCK_TIMEOUT, true))
{
- ImmediateInterruptOK = false; /* not idle anymore */
(void) get_timeout_indicator(STATEMENT_TIMEOUT, true);
LockErrorCleanup();
ereport(ERROR,
}
if (get_timeout_indicator(STATEMENT_TIMEOUT, true))
{
- ImmediateInterruptOK = false; /* not idle anymore */
LockErrorCleanup();
ereport(ERROR,
(errcode(ERRCODE_QUERY_CANCELED),
}
if (IsAutoVacuumWorkerProcess())
{
- ImmediateInterruptOK = false; /* not idle anymore */
LockErrorCleanup();
ereport(ERROR,
(errcode(ERRCODE_QUERY_CANCELED),
}
if (RecoveryConflictPending)
{
- ImmediateInterruptOK = false; /* not idle anymore */
RecoveryConflictPending = false;
LockErrorCleanup();
pgstat_report_recovery_conflict(RecoveryConflictReason);
*/
if (!DoingCommandRead)
{
- ImmediateInterruptOK = false; /* not idle anymore */
LockErrorCleanup();
ereport(ERROR,
(errcode(ERRCODE_QUERY_CANCELED),
{
ErrorData *edata = &errordata[errordata_stack_depth];
int elevel;
- bool save_ImmediateInterruptOK;
MemoryContext oldcontext;
ErrorContextCallback *econtext;
CHECK_STACK_DEPTH();
elevel = edata->elevel;
- /*
- * Ensure we can't get interrupted while performing error reporting. This
- * is needed to prevent recursive entry to functions like syslog(), which
- * may not be re-entrant.
- *
- * Note: other places that save-and-clear ImmediateInterruptOK also do
- * HOLD_INTERRUPTS(), but that should not be necessary here since we don't
- * call anything that could turn on ImmediateInterruptOK.
- */
- save_ImmediateInterruptOK = ImmediateInterruptOK;
- ImmediateInterruptOK = false;
-
/*
* Do processing in ErrorContext, which we hope has enough reserved space
* to report an error.
* itself be inside a holdoff section. If necessary, such a handler
* could save and restore InterruptHoldoffCount for itself, but this
* should make life easier for most.)
- *
- * Note that we intentionally don't restore ImmediateInterruptOK here,
- * even if it was set at entry. We definitely don't want that on
- * while doing error cleanup.
*/
InterruptHoldoffCount = 0;
QueryCancelHoldoffCount = 0;
}
/*
- * We reach here if elevel <= WARNING. OK to return to caller, so restore
- * caller's setting of ImmediateInterruptOK.
- */
- ImmediateInterruptOK = save_ImmediateInterruptOK;
-
- /*
- * But check for cancel/die interrupt first --- this is so that the user
- * can stop a query emitting tons of notice or warning messages, even if
- * it's in a loop that otherwise fails to check for interrupts.
+ * Check for cancel/die interrupt first --- this is so that the user can
+ * stop a query emitting tons of notice or warning messages, even if it's
+ * in a loop that otherwise fails to check for interrupts.
*/
CHECK_FOR_INTERRUPTS();
}
volatile bool QueryCancelPending = false;
volatile bool ProcDiePending = false;
volatile bool ClientConnectionLost = false;
-volatile bool ImmediateInterruptOK = false;
volatile uint32 InterruptHoldoffCount = 0;
volatile uint32 QueryCancelHoldoffCount = 0;
volatile uint32 CritSectionCount = 0;
handle_sig_alarm(SIGNAL_ARGS)
{
int save_errno = errno;
- bool save_ImmediateInterruptOK = ImmediateInterruptOK;
/*
- * We may be executing while ImmediateInterruptOK is true (e.g., when
- * mainline is waiting for a lock). If SIGINT or similar arrives while
- * this code is running, we'd lose control and perhaps leave our data
- * structures in an inconsistent state. Disable immediate interrupts, and
- * just to be real sure, bump the holdoff counter as well. (The reason
- * for this belt-and-suspenders-too approach is to make sure that nothing
- * bad happens if a timeout handler calls code that manipulates
- * ImmediateInterruptOK.)
- *
- * Note: it's possible for a SIGINT to interrupt handle_sig_alarm before
- * we manage to do this; the net effect would be as if the SIGALRM event
- * had been silently lost. Therefore error recovery must include some
- * action that will allow any lost interrupt to be rescheduled. Disabling
- * some or all timeouts is sufficient, or if that's not appropriate,
- * reschedule_timeouts() can be called. Also, the signal blocking hazard
- * described below applies here too.
+ * Bump the holdoff counter, to make sure nothing we call will process
+ * interrupts directly. No timeout handler should do that, but these
+ * failures are hard to debug, so better be sure.
*/
- ImmediateInterruptOK = false;
HOLD_INTERRUPTS();
/*
}
}
- /*
- * Re-allow query cancel, and then try to service any cancel request that
- * arrived meanwhile (this might in particular include a cancel request
- * fired by one of the timeout handlers). Since we are in a signal
- * handler, we mustn't call ProcessInterrupts unless ImmediateInterruptOK
- * is set; if it isn't, the cancel will happen at the next mainline
- * CHECK_FOR_INTERRUPTS.
- *
- * Note: a longjmp from here is safe so far as our own data structures are
- * concerned; but on platforms that block a signal before calling the
- * handler and then un-block it on return, longjmping out of the signal
- * handler leaves SIGALRM still blocked. Error cleanup is responsible for
- * unblocking any blocked signals.
- */
RESUME_INTERRUPTS();
- ImmediateInterruptOK = save_ImmediateInterruptOK;
- if (save_ImmediateInterruptOK)
- CHECK_FOR_INTERRUPTS();
errno = save_errno;
}
extern volatile bool ClientConnectionLost;
/* these are marked volatile because they are examined by signal handlers: */
-extern PGDLLIMPORT volatile bool ImmediateInterruptOK;
extern PGDLLIMPORT volatile uint32 InterruptHoldoffCount;
extern PGDLLIMPORT volatile uint32 QueryCancelHoldoffCount;
extern PGDLLIMPORT volatile uint32 CritSectionCount;
*
* We want CHECK_FOR_INTERRUPTS() to kill off this worker process just as
* it would a normal user backend. To make that happen, we establish a
- * signal handler that is a stripped-down version of die(). We don't have
- * any equivalent of the backend's command-read loop, where interrupts can
- * be processed immediately, so make sure ImmediateInterruptOK is turned
- * off.
+ * signal handler that is a stripped-down version of die().
*/
pqsignal(SIGTERM, handle_sigterm);
- ImmediateInterruptOK = false;
BackgroundWorkerUnblockSignals();
/*
projects / postgresql.git / commitdiff