diff -cr cvs/src/backend/access/transam/xact.c cvs.build/src/backend/access/transam/xact.c *** cvs/src/backend/access/transam/xact.c 2009-12-24 13:55:12.000000000 +0100 --- cvs.build/src/backend/access/transam/xact.c 2010-01-05 11:25:17.000000000 +0100 *************** *** 313,320 **** /* * IsAbortedTransactionBlockState * ! * This returns true if we are currently running a query ! * within an aborted transaction block. */ bool IsAbortedTransactionBlockState(void) --- 313,319 ---- /* * IsAbortedTransactionBlockState * ! * This returns true if we are within an aborted transaction block. */ bool IsAbortedTransactionBlockState(void) *************** *** 2692,2697 **** --- 2691,2738 ---- } /* + * AbortTransactionAndAnySubtransactions + * + * Similar to AbortCurrentTransaction but if any subtransactions + * in progress we abort them and all of their parents. So this is + * used when the caller wishes to make the abort untrappable by the user. + */ + void + AbortTransactionAndAnySubtransactions(void) + { + TransactionState s = CurrentTransactionState; + + switch (s->blockState) + { + case TBLOCK_DEFAULT: + case TBLOCK_STARTED: + case TBLOCK_BEGIN: + case TBLOCK_INPROGRESS: + case TBLOCK_END: + case TBLOCK_ABORT: + case TBLOCK_SUBABORT: + case TBLOCK_ABORT_END: + case TBLOCK_ABORT_PENDING: + case TBLOCK_PREPARE: + case TBLOCK_SUBABORT_END: + case TBLOCK_SUBABORT_RESTART: + AbortCurrentTransaction(); + break; + + case TBLOCK_SUBINPROGRESS: + case TBLOCK_SUBBEGIN: + case TBLOCK_SUBEND: + case TBLOCK_SUBABORT_PENDING: + case TBLOCK_SUBRESTART: + AbortSubTransaction(); + CleanupSubTransaction(); + AbortTransactionAndAnySubtransactions(); + break; + } + } + + + /* * PreventTransactionChain * * This routine is to be called by statements that must not run inside diff -cr cvs/src/backend/commands/vacuum.c cvs.build/src/backend/commands/vacuum.c *** cvs/src/backend/commands/vacuum.c 2009-12-24 13:55:13.000000000 +0100 --- cvs.build/src/backend/commands/vacuum.c 2010-01-03 20:24:26.000000000 +0100 *************** *** 3936,3942 **** CHECK_FOR_INTERRUPTS(); /* Nap if appropriate */ ! if (VacuumCostActive && !InterruptPending && VacuumCostBalance >= VacuumCostLimit) { int msec; --- 3936,3942 ---- CHECK_FOR_INTERRUPTS(); /* Nap if appropriate */ ! if (VacuumCostActive && !IsInterruptEventPending && VacuumCostBalance >= VacuumCostLimit) { int msec; diff -cr cvs/src/backend/postmaster/autovacuum.c cvs.build/src/backend/postmaster/autovacuum.c *** cvs/src/backend/postmaster/autovacuum.c 2009-12-09 11:24:41.000000000 +0100 --- cvs.build/src/backend/postmaster/autovacuum.c 2010-01-07 00:22:21.000000000 +0100 *************** *** 479,488 **** /* Prevents interrupts while cleaning up */ HOLD_INTERRUPTS(); ! /* Forget any pending QueryCancel request */ ! QueryCancelPending = false; disable_sig_alarm(true); ! QueryCancelPending = false; /* again in case timeout occurred */ /* Report the error to the server log */ EmitErrorReport(); --- 479,489 ---- /* Prevents interrupts while cleaning up */ HOLD_INTERRUPTS(); ! /* Forget any pending CancelQuery request */ ! ClearInterruptEventPending(CancelQueryPending); disable_sig_alarm(true); ! /* again in case timeout occurred */ ! ClearInterruptEventPending(CancelQueryPending); /* Report the error to the server log */ EmitErrorReport(); *************** *** 2233,2244 **** autovacuum_do_vac_analyze(tab, bstrategy); /* ! * Clear a possible query-cancel signal, to avoid a late reaction * to an automatically-sent signal because of vacuuming the * current table (we're done with it, so it would make no sense to * cancel at this point.) */ ! QueryCancelPending = false; } PG_CATCH(); { --- 2234,2245 ---- autovacuum_do_vac_analyze(tab, bstrategy); /* ! * Clear a possible cancel-query signal, to avoid a late reaction * to an automatically-sent signal because of vacuuming the * current table (we're done with it, so it would make no sense to * cancel at this point.) */ ! ClearInterruptEventPending(CancelQueryPending); } PG_CATCH(); { diff -cr cvs/src/backend/storage/ipc/ipc.c cvs.build/src/backend/storage/ipc/ipc.c *** cvs/src/backend/storage/ipc/ipc.c 2009-12-09 11:24:52.000000000 +0100 --- cvs.build/src/backend/storage/ipc/ipc.c 2010-01-03 20:33:49.000000000 +0100 *************** *** 155,163 **** * close up shop already. Note that the signal handlers will not set * these flags again, now that proc_exit_inprogress is set. */ ! InterruptPending = false; ! ProcDiePending = false; ! QueryCancelPending = false; /* And let's just make *sure* we're not interrupted ... */ ImmediateInterruptOK = false; InterruptHoldoffCount = 1; --- 155,161 ---- * close up shop already. Note that the signal handlers will not set * these flags again, now that proc_exit_inprogress is set. */ ! ZeroInterruptEventPending(); /* And let's just make *sure* we're not interrupted ... */ ImmediateInterruptOK = false; InterruptHoldoffCount = 1; diff -cr cvs/src/backend/storage/ipc/procarray.c cvs.build/src/backend/storage/ipc/procarray.c *** cvs/src/backend/storage/ipc/procarray.c 2009-12-24 13:55:18.000000000 +0100 --- cvs.build/src/backend/storage/ipc/procarray.c 2010-01-06 20:02:31.000000000 +0100 *************** *** 52,57 **** --- 52,58 ---- #include "access/twophase.h" #include "miscadmin.h" #include "storage/procarray.h" + #include "storage/procsignal.h" #include "storage/standby.h" #include "utils/builtins.h" #include "utils/snapmgr.h" *************** *** 1704,1710 **** * Returns pid of the process signaled, or 0 if not found. */ pid_t ! CancelVirtualTransaction(VirtualTransactionId vxid, int cancel_mode) { ProcArrayStruct *arrayP = procArray; int index; --- 1705,1711 ---- * Returns pid of the process signaled, or 0 if not found. */ pid_t ! CancelVirtualTransaction(VirtualTransactionId vxid, ProcSignalReason sigmode) { ProcArrayStruct *arrayP = procArray; int index; *************** *** 1722,1733 **** if (procvxid.backendId == vxid.backendId && procvxid.localTransactionId == vxid.localTransactionId) { - /* - * Issue orders for the proc to read next time it receives SIGINT - */ - if (proc->recoveryConflictMode < cancel_mode) - proc->recoveryConflictMode = cancel_mode; - pid = proc->pid; break; } --- 1723,1728 ---- *************** *** 1741,1747 **** * Kill the pid if it's still here. If not, that's what we wanted * so ignore any errors. */ ! kill(pid, SIGINT); } return pid; --- 1736,1742 ---- * Kill the pid if it's still here. If not, that's what we wanted * so ignore any errors. */ ! (void) SendProcSignal(pid, sigmode, vxid.backendId); } return pid; diff -cr cvs/src/backend/storage/ipc/procsignal.c cvs.build/src/backend/storage/ipc/procsignal.c *** cvs/src/backend/storage/ipc/procsignal.c 2009-12-09 11:24:52.000000000 +0100 --- cvs.build/src/backend/storage/ipc/procsignal.c 2010-01-07 12:00:33.000000000 +0100 *************** *** 24,29 **** --- 24,31 ---- #include "storage/procsignal.h" #include "storage/shmem.h" #include "storage/sinval.h" + #include "storage/standby.h" + #include "tcop/tcopprot.h" /* *************** *** 170,195 **** SendProcSignal(pid_t pid, ProcSignalReason reason, BackendId backendId) { volatile ProcSignalSlot *slot; if (backendId != InvalidBackendId) { ! slot = &ProcSignalSlots[backendId - 1]; ! /* ! * Note: Since there's no locking, it's possible that the target * process detaches from shared memory and exits right after this ! * test, before we set the flag and send signal. And the signal slot ! * might even be recycled by a new process, so it's remotely possible ! * that we set a flag for a wrong process. That's OK, all the signals ! * are such that no harm is done if they're mistakenly fired. */ if (slot->pss_pid == pid) { /* Atomically set the proper flag */ slot->pss_signalFlags[reason] = true; /* Send signal */ ! return kill(pid, SIGUSR1); } } else { --- 172,210 ---- SendProcSignal(pid_t pid, ProcSignalReason reason, BackendId backendId) { volatile ProcSignalSlot *slot; + int ret; if (backendId != InvalidBackendId) { ! Assert(backendId <= MaxBackends); /* ! * If we did not get a lock, it would be possible that the target * process detaches from shared memory and exits right after this ! * test, before we set the flag and send the signal. And the signal ! * slot might even be recycled by a new process, so it's remotely ! * possible that we set a flag for a wrong process. That's OK for ! * harmless signal reasons. As soon as we get a cancel-something signal ! * reason (which really should not happen all that often), we take the ! * time to grab a shared lock on ProcArray before we start to search ! * that backend and hold it until we have sent the signal. */ + if (!IsHarmlessSignal(reason)) + LWLockAcquire(ProcArrayLock, LW_SHARED); + + slot = &ProcSignalSlots[backendId - 1]; + if (slot->pss_pid == pid) { /* Atomically set the proper flag */ slot->pss_signalFlags[reason] = true; /* Send signal */ ! ret = kill(pid, SIGUSR1); } + + if (!IsHarmlessSignal(reason)) + LWLockRelease(ProcArrayLock); + + return ret; } else { *************** *** 200,205 **** --- 215,228 ---- * process, which will have a slot near the end of the array. */ int i; + bool found = false; + + /* + * If the signal is not a harmless one, grab a lock to be sure we + * send it to the correct backend. + */ + if (!IsHarmlessSignal(reason)) + LWLockAcquire(ProcArrayLock, LW_SHARED); for (i = NumProcSignalSlots - 1; i >= 0; i--) { *************** *** 207,220 **** if (slot->pss_pid == pid) { ! /* the above note about race conditions applies here too */ /* Atomically set the proper flag */ slot->pss_signalFlags[reason] = true; /* Send signal */ ! return kill(pid, SIGUSR1); } } } errno = ESRCH; --- 230,250 ---- if (slot->pss_pid == pid) { ! found = true; /* Atomically set the proper flag */ slot->pss_signalFlags[reason] = true; /* Send signal */ ! ret = kill(pid, SIGUSR1); ! break; } } + + if (!IsHarmlessSignal(reason)) + LWLockRelease(ProcArrayLock); + + if (found) + return ret; } errno = ESRCH; *************** *** 252,262 **** --- 282,314 ---- { int save_errno = errno; + /* signal reasons that notify a backend of an event */ if (CheckProcSignal(PROCSIG_CATCHUP_INTERRUPT)) HandleCatchupInterrupt(); if (CheckProcSignal(PROCSIG_NOTIFY_INTERRUPT)) HandleNotifyInterrupt(); + /* signal reasons that request the backend to cancel some action */ + + /* pg_cancel_idle_transaction() */ + if (CheckProcSignal(PROCSIG_CANCEL_IDLE_TRANSACTION)) + HandleCancelAction(false, true, false); + + /* Hot standby */ + if (CheckProcSignal(PROCSIG_CONFLICT_ERROR_INTERRUPT)) + { + SetInterruptEventPending(ConflictErrorPending); + HandleCancelAction(true, true, false); + } + + /* Hot standby */ + if (CheckProcSignal(PROCSIG_CONFLICT_FATAL_INTERRUPT)) + { + SetInterruptEventPending(ConflictFatalPending); + HandleCancelAction(false, false, true); + } + errno = save_errno; } + diff -cr cvs/src/backend/storage/ipc/standby.c cvs.build/src/backend/storage/ipc/standby.c *** cvs/src/backend/storage/ipc/standby.c 2009-12-19 02:32:35.000000000 +0100 --- cvs.build/src/backend/storage/ipc/standby.c 2010-01-06 19:35:02.000000000 +0100 *************** *** 219,229 **** { pid_t pid; /* * Now find out who to throw out of the balloon. */ Assert(VirtualTransactionIdIsValid(*waitlist)); ! pid = CancelVirtualTransaction(*waitlist, cancel_mode); if (pid != 0) { --- 219,236 ---- { pid_t pid; + ProcSignalReason sigmode; + + if (cancel_mode == CONFLICT_MODE_ERROR) + sigmode = PROCSIG_CONFLICT_ERROR_INTERRUPT; + else + sigmode = PROCSIG_CONFLICT_FATAL_INTERRUPT; + /* * Now find out who to throw out of the balloon. */ Assert(VirtualTransactionIdIsValid(*waitlist)); ! pid = CancelVirtualTransaction(*waitlist, sigmode); if (pid != 0) { diff -cr cvs/src/backend/tcop/postgres.c cvs.build/src/backend/tcop/postgres.c *** cvs/src/backend/tcop/postgres.c 2009-12-24 13:55:18.000000000 +0100 --- cvs.build/src/backend/tcop/postgres.c 2010-01-07 12:46:26.000000000 +0100 *************** *** 479,486 **** /* Allow "die" interrupt to be processed while waiting */ ImmediateInterruptOK = true; ! /* And don't forget to detect one that already arrived */ ! QueryCancelPending = false; CHECK_FOR_INTERRUPTS(); } } --- 479,486 ---- /* Allow "die" interrupt to be processed while waiting */ ImmediateInterruptOK = true; ! /* And don't forget to detect those that already arrived */ ! ZeroInterruptEventPending(); CHECK_FOR_INTERRUPTS(); } } *************** *** 494,500 **** if (DoingCommandRead) { ImmediateInterruptOK = false; ! QueryCancelPending = false; /* forget any CANCEL signal */ DisableNotifyInterrupt(); DisableCatchupInterrupt(); --- 494,501 ---- if (DoingCommandRead) { ImmediateInterruptOK = false; ! /* forget any CANCEL signal */ ! ZeroInterruptEventPending(); DisableNotifyInterrupt(); DisableCatchupInterrupt(); *************** *** 2593,2661 **** void die(SIGNAL_ARGS) { ! int save_errno = errno; ! ! /* Don't joggle the elbow of proc_exit */ ! if (!proc_exit_inprogress) ! { ! InterruptPending = true; ! ProcDiePending = true; ! ! /* ! * If it's safe to interrupt, and we're waiting for input or a lock, ! * service the interrupt immediately ! */ ! if (ImmediateInterruptOK && InterruptHoldoffCount == 0 && ! CritSectionCount == 0) ! { ! /* bump holdoff count to make ProcessInterrupts() a no-op */ ! /* until we are done getting ready for it */ ! InterruptHoldoffCount++; ! LockWaitCancel(); /* prevent CheckDeadLock from running */ ! DisableNotifyInterrupt(); ! DisableCatchupInterrupt(); ! InterruptHoldoffCount--; ! ProcessInterrupts(); ! } ! } ! ! errno = save_errno; } /* ! * Query-cancel signal from postmaster: abort current transaction ! * at soonest convenient time */ void StatementCancelHandler(SIGNAL_ARGS) { int save_errno = errno; /* ! * Don't joggle the elbow of proc_exit */ ! if (!proc_exit_inprogress) ! { ! InterruptPending = true; ! QueryCancelPending = true; ! /* ! * If it's safe to interrupt, and we're waiting for a lock, service ! * the interrupt immediately. No point in interrupting if we're ! * waiting for input, however. ! */ ! if (InterruptHoldoffCount == 0 && CritSectionCount == 0 && ! (DoingCommandRead || ImmediateInterruptOK)) ! { ! /* bump holdoff count to make ProcessInterrupts() a no-op */ ! /* until we are done getting ready for it */ ! InterruptHoldoffCount++; ! LockWaitCancel(); /* prevent CheckDeadLock from running */ ! DisableNotifyInterrupt(); ! DisableCatchupInterrupt(); ! InterruptHoldoffCount--; ! ProcessInterrupts(); ! } } errno = save_errno; --- 2594,2668 ---- void die(SIGNAL_ARGS) { ! HandleCancelAction(false, false, true); } /* ! * Query-cancel signal from postmaster: abort current query at soonest ! * convenient time, do not abort an idle transaction however. */ void StatementCancelHandler(SIGNAL_ARGS) { + HandleCancelAction(true, false, false); + } + + void + HandleCancelAction(bool cancelQuery, + bool cancelIdleTransaction, + bool cancelSession) + { int save_errno = errno; + /* Don't joggle the elbow of proc_exit */ + if (proc_exit_inprogress) + return; + /* ! * Check cancel requests against internal states, we might want to ! * ignore a request. */ ! if (cancelQuery && DoingCommandRead) ! cancelQuery = false; ! if (cancelIdleTransaction) ! { ! if (!DoingCommandRead) ! cancelIdleTransaction = false; ! else if (!IsTransactionOrTransactionBlock()) ! cancelIdleTransaction = false; ! else if (IsAbortedTransactionBlockState()) ! cancelIdleTransaction = false; ! } ! if (!cancelQuery && !cancelIdleTransaction && !cancelSession) ! return; ! ! /* ! * Set the global variable InterruptPendingEvent to whatever is left set ! * to true after the previous checks. ! */ ! if (cancelQuery) ! SetInterruptEventPending(CancelQueryPending); ! if (cancelIdleTransaction) ! SetInterruptEventPending(CancelIdleTransactionPending); ! if (cancelSession) ! SetInterruptEventPending(CancelSessionPending); ! ! /* ! * If it's safe to interrupt, and we're waiting for a lock, service ! * the interrupt immediately. ! */ ! if (InterruptHoldoffCount == 0 && CritSectionCount == 0 && ! ImmediateInterruptOK) ! { ! /* bump holdoff count to make ProcessInterrupts() a no-op */ ! /* until we are done getting ready for it */ ! InterruptHoldoffCount++; ! LockWaitCancel(); /* prevent CheckDeadLock from running */ ! DisableNotifyInterrupt(); ! DisableCatchupInterrupt(); ! InterruptHoldoffCount--; ! ProcessInterrupts(); } errno = save_errno; *************** *** 2685,2704 **** * ProcessInterrupts: out-of-line portion of CHECK_FOR_INTERRUPTS() macro * * If an interrupt condition is pending, and it's safe to service it, ! * then clear the flag and accept the interrupt. Called only when ! * InterruptPending is true. */ void ProcessInterrupts(void) { /* OK to accept interrupt now? */ if (InterruptHoldoffCount != 0 || CritSectionCount != 0) return; ! InterruptPending = false; ! if (ProcDiePending) { - ProcDiePending = false; - QueryCancelPending = false; /* ProcDie trumps QueryCancel */ ImmediateInterruptOK = false; /* not idle anymore */ DisableNotifyInterrupt(); DisableCatchupInterrupt(); --- 2692,2712 ---- * ProcessInterrupts: out-of-line portion of CHECK_FOR_INTERRUPTS() macro * * If an interrupt condition is pending, and it's safe to service it, ! * then clear the flag and accept the interrupt. Called only when ! * InterruptPendingEvent != NothingPending. */ void ProcessInterrupts(void) { + const char *msg; + int code; + /* OK to accept interrupt now? */ if (InterruptHoldoffCount != 0 || CritSectionCount != 0) return; ! ! if (InterruptPendingEvent & CancelSessionPending) { ImmediateInterruptOK = false; /* not idle anymore */ DisableNotifyInterrupt(); DisableCatchupInterrupt(); *************** *** 2706,2722 **** if (ClientAuthInProgress && whereToSendOutput == DestRemote) whereToSendOutput = DestNone; if (IsAutoVacuumWorkerProcess()) ! ereport(FATAL, ! (errcode(ERRCODE_ADMIN_SHUTDOWN), ! errmsg("terminating autovacuum process due to administrator command"))); else ! ereport(FATAL, ! (errcode(ERRCODE_ADMIN_SHUTDOWN), ! errmsg("terminating connection due to administrator command"))); } ! if (QueryCancelPending) { - QueryCancelPending = false; ImmediateInterruptOK = false; /* not idle anymore */ DisableNotifyInterrupt(); DisableCatchupInterrupt(); --- 2714,2742 ---- if (ClientAuthInProgress && whereToSendOutput == DestRemote) whereToSendOutput = DestNone; if (IsAutoVacuumWorkerProcess()) ! { ! code = ERRCODE_ADMIN_SHUTDOWN; ! msg = "terminating autovacuum process due to administrator command"; ! } ! else if (InterruptPendingEvent & ConflictFatalPending) ! { ! Assert(RecoveryInProgress()); ! code = ERRCODE_QUERY_CANCELED; ! msg = "canceling session due to conflict with recovery"; ! } else ! { ! code = ERRCODE_ADMIN_SHUTDOWN; ! msg = "terminating connection due to administrator command"; ! } ! ! ZeroInterruptEventPending(); ! ! ereport(FATAL, (errcode(code), ! errmsg(msg))); } ! if (InterruptPendingEvent & CancelQueryPending) { ImmediateInterruptOK = false; /* not idle anymore */ DisableNotifyInterrupt(); DisableCatchupInterrupt(); *************** *** 2724,2795 **** if (ClientAuthInProgress && whereToSendOutput == DestRemote) whereToSendOutput = DestNone; if (ClientAuthInProgress) ! ereport(ERROR, ! (errcode(ERRCODE_QUERY_CANCELED), ! errmsg("canceling authentication due to timeout"))); else if (cancel_from_timeout) ! ereport(ERROR, ! (errcode(ERRCODE_QUERY_CANCELED), ! errmsg("canceling statement due to statement timeout"))); else if (IsAutoVacuumWorkerProcess()) ! ereport(ERROR, ! (errcode(ERRCODE_QUERY_CANCELED), ! errmsg("canceling autovacuum task"))); ! else { ! int cancelMode = MyProc->recoveryConflictMode; ! /* ! * XXXHS: We don't yet have a clean way to cancel an ! * idle-in-transaction session, so make it FATAL instead. ! * This isn't as bad as it looks because we don't issue a ! * CONFLICT_MODE_ERROR for a session with proc->xmin == 0 ! * on cleanup conflicts. There's a possibility that we ! * marked somebody as a conflict and then they go idle. ! */ ! if (DoingCommandRead && IsTransactionBlock() && ! cancelMode == CONFLICT_MODE_ERROR) ! { ! cancelMode = CONFLICT_MODE_FATAL; ! } ! switch (cancelMode) ! { ! case CONFLICT_MODE_FATAL: ! Assert(RecoveryInProgress()); ! ereport(FATAL, ! (errcode(ERRCODE_QUERY_CANCELED), ! errmsg("canceling session due to conflict with recovery"))); ! ! case CONFLICT_MODE_ERROR: ! /* ! * We are aborting because we need to release ! * locks. So we need to abort out of all ! * subtransactions to make sure we release ! * all locks at whatever their level. ! * ! * XXX Should we try to examine the ! * transaction tree and cancel just enough ! * subxacts to remove locks? Doubt it. ! */ ! Assert(RecoveryInProgress()); ! AbortOutOfAnyTransaction(); ! ereport(ERROR, ! (errcode(ERRCODE_QUERY_CANCELED), ! errmsg("canceling statement due to conflict with recovery"))); ! return; ! ! default: ! /* No conflict pending, so fall through */ ! break; ! } ! ereport(ERROR, ! (errcode(ERRCODE_QUERY_CANCELED), ! errmsg("canceling statement due to user request"))); } } ! /* If we get here, do nothing (probably, QueryCancelPending was reset) */ } --- 2744,2794 ---- if (ClientAuthInProgress && whereToSendOutput == DestRemote) whereToSendOutput = DestNone; if (ClientAuthInProgress) ! msg = "canceling authentication due to timeout"; else if (cancel_from_timeout) ! msg = "canceling statement due to statement timeout"; else if (IsAutoVacuumWorkerProcess()) ! msg = "canceling autovacuum task"; ! else if (InterruptPendingEvent & ConflictErrorPending) { ! Assert(RecoveryInProgress()); ! msg = "canceling statement due to conflict with recovery"; ! } ! else ! msg = "canceling statement due to user request"; ! ZeroInterruptEventPending(); ! ereport(ERROR, ! (errcode(ERRCODE_QUERY_CANCELED), ! errmsg(msg))); ! } ! if (InterruptPendingEvent & CancelIdleTransactionPending) ! { ! ImmediateInterruptOK = false; /* not idle anymore */ ! DisableNotifyInterrupt(); ! DisableCatchupInterrupt(); ! if (InterruptPendingEvent & ConflictErrorPending) ! { ! Assert(RecoveryInProgress()); ! msg = "canceling statement due to conflict with recovery"; } + else + msg = "canceling idle transaction due to administrator request"; + + ZeroInterruptEventPending(); + + ereport(NOTICE, + (errcode(ERRCODE_QUERY_CANCELED), + errmsg(msg))); + + AbortTransactionAndAnySubtransactions(); + + set_ps_display("idle in transaction (aborted)", false); + pgstat_report_activity(" in transaction (aborted)"); } ! /* If we get here, do nothing (probably, CancelQueryPending was reset) */ } *************** *** 3507,3518 **** HOLD_INTERRUPTS(); /* ! * Forget any pending QueryCancel request, since we're returning to * the idle loop anyway, and cancel the statement timer if running. */ ! QueryCancelPending = false; disable_sig_alarm(true); ! QueryCancelPending = false; /* again in case timeout occurred */ /* * Turn off these interrupts too. This is only needed here and not in --- 3506,3518 ---- HOLD_INTERRUPTS(); /* ! * Forget any pending CancelQuery request, since we're returning to * the idle loop anyway, and cancel the statement timer if running. */ ! ZeroInterruptEventPending(); disable_sig_alarm(true); ! /* again in case timeout occurred */ ! ZeroInterruptEventPending(); /* * Turn off these interrupts too. This is only needed here and not in *************** *** 3603,3609 **** */ if (send_ready_for_query) { ! if (IsTransactionOrTransactionBlock()) { set_ps_display("idle in transaction", false); pgstat_report_activity(" in transaction"); --- 3603,3614 ---- */ if (send_ready_for_query) { ! if (IsAbortedTransactionBlockState()) ! { ! set_ps_display("idle in transaction (aborted)", false); ! pgstat_report_activity(" in transaction (aborted)"); ! } ! else if (IsTransactionOrTransactionBlock()) { set_ps_display("idle in transaction", false); pgstat_report_activity(" in transaction"); *************** *** 3626,3632 **** * conditional since we don't want, say, reads on behalf of COPY FROM * STDIN doing the same thing.) */ ! QueryCancelPending = false; /* forget any earlier CANCEL signal */ DoingCommandRead = true; /* --- 3631,3638 ---- * conditional since we don't want, say, reads on behalf of COPY FROM * STDIN doing the same thing.) */ ! /* forget any earlier cancel signals */ ! ZeroInterruptEventPending(); DoingCommandRead = true; /* diff -cr cvs/src/backend/utils/adt/misc.c cvs.build/src/backend/utils/adt/misc.c *** cvs/src/backend/utils/adt/misc.c 2009-12-09 11:24:45.000000000 +0100 --- cvs.build/src/backend/utils/adt/misc.c 2010-01-07 12:38:52.000000000 +0100 *************** *** 30,35 **** --- 30,36 ---- #include "storage/fd.h" #include "storage/pmsignal.h" #include "storage/procarray.h" + #include "storage/procsignal.h" #include "utils/builtins.h" #include "tcop/tcopprot.h" *************** *** 117,122 **** --- 118,132 ---- } Datum + pg_cancel_idle_transaction(PG_FUNCTION_ARGS) + { + int ret; + pid_t pid = PG_GETARG_INT32(0); + ret = SendProcSignal(pid, PROCSIG_CANCEL_IDLE_TRANSACTION, InvalidBackendId); + PG_RETURN_BOOL(ret == 0); + } + + Datum pg_reload_conf(PG_FUNCTION_ARGS) { if (!superuser()) diff -cr cvs/src/backend/utils/init/globals.c cvs.build/src/backend/utils/init/globals.c *** cvs/src/backend/utils/init/globals.c 2009-12-09 11:24:42.000000000 +0100 --- cvs.build/src/backend/utils/init/globals.c 2010-01-03 20:58:09.000000000 +0100 *************** *** 25,33 **** ProtocolVersion FrontendProtocol; ! volatile bool InterruptPending = false; ! volatile bool QueryCancelPending = false; ! volatile bool ProcDiePending = false; volatile bool ImmediateInterruptOK = false; volatile uint32 InterruptHoldoffCount = 0; volatile uint32 CritSectionCount = 0; --- 25,31 ---- ProtocolVersion FrontendProtocol; ! volatile int InterruptPendingEvent = NothingPending; volatile bool ImmediateInterruptOK = false; volatile uint32 InterruptHoldoffCount = 0; volatile uint32 CritSectionCount = 0; diff -cr cvs/src/include/access/xact.h cvs.build/src/include/access/xact.h *** cvs/src/include/access/xact.h 2009-12-24 13:55:28.000000000 +0100 --- cvs.build/src/include/access/xact.h 2010-01-04 08:01:52.000000000 +0100 *************** *** 189,194 **** --- 189,195 ---- extern void StartTransactionCommand(void); extern void CommitTransactionCommand(void); extern void AbortCurrentTransaction(void); + extern void AbortTransactionAndAnySubtransactions(void); extern void BeginTransactionBlock(void); extern bool EndTransactionBlock(void); extern bool PrepareTransactionBlock(char *gid); diff -cr cvs/src/include/catalog/pg_proc.h cvs.build/src/include/catalog/pg_proc.h *** cvs/src/include/catalog/pg_proc.h 2009-12-24 13:55:29.000000000 +0100 --- cvs.build/src/include/catalog/pg_proc.h 2010-01-04 07:45:01.000000000 +0100 *************** *** 3268,3273 **** --- 3268,3275 ---- DATA(insert OID = 2171 ( pg_cancel_backend PGNSP PGUID 12 1 0 0 f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ pg_cancel_backend _null_ _null_ _null_ )); DESCR("cancel a server process' current query"); + DATA(insert OID = 2179 ( pg_cancel_idle_transaction PGNSP PGUID 12 1 0 0 f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ pg_cancel_idle_transaction _null_ _null_ _null_ )); + DESCR("cancel a server process' idle transaction"); DATA(insert OID = 2096 ( pg_terminate_backend PGNSP PGUID 12 1 0 0 f f f t f v 1 0 16 "23" _null_ _null_ _null_ _null_ pg_terminate_backend _null_ _null_ _null_ )); DESCR("terminate a server process"); DATA(insert OID = 2172 ( pg_start_backup PGNSP PGUID 12 1 0 0 f f f t f v 2 0 25 "25 16" _null_ _null_ _null_ _null_ pg_start_backup _null_ _null_ _null_ )); diff -cr cvs/src/include/miscadmin.h cvs.build/src/include/miscadmin.h *** cvs/src/include/miscadmin.h 2009-12-24 13:55:28.000000000 +0100 --- cvs.build/src/include/miscadmin.h 2010-01-06 21:13:35.000000000 +0100 *************** *** 64,74 **** * *****************************************************************************/ /* in globals.c */ ! /* these are marked volatile because they are set by signal handlers: */ ! extern PGDLLIMPORT volatile bool InterruptPending; ! extern volatile bool QueryCancelPending; ! extern volatile bool ProcDiePending; /* these are marked volatile because they are examined by signal handlers: */ extern volatile bool ImmediateInterruptOK; --- 64,85 ---- * *****************************************************************************/ + #define NothingPending 0 + #define CancelQueryPending 1 + #define CancelIdleTransactionPending 2 + #define CancelQueryOrTransactionPending 4 + #define CancelSessionPending 8 + #define ConflictErrorPending 16 + #define ConflictFatalPending 32 + + #define IsInterruptEventPending (InterruptPendingEvent != NothingPending) + #define SetInterruptEventPending(ev) (InterruptPendingEvent |= ev) + #define ClearInterruptEventPending(ev) (InterruptPendingEvent &= ~ev) + #define ZeroInterruptEventPending() (InterruptPendingEvent = NothingPending) + /* in globals.c */ ! /* this is marked volatile because it is set by signal handlers: */ ! extern PGDLLIMPORT volatile int InterruptPendingEvent; /* these are marked volatile because they are examined by signal handlers: */ extern volatile bool ImmediateInterruptOK; *************** *** 82,88 **** #define CHECK_FOR_INTERRUPTS() \ do { \ ! if (InterruptPending) \ ProcessInterrupts(); \ } while(0) #else /* WIN32 */ --- 93,99 ---- #define CHECK_FOR_INTERRUPTS() \ do { \ ! if (IsInterruptEventPending) \ ProcessInterrupts(); \ } while(0) #else /* WIN32 */ *************** *** 91,97 **** do { \ if (UNBLOCKED_SIGNAL_QUEUE()) \ pgwin32_dispatch_queued_signals(); \ ! if (InterruptPending) \ ProcessInterrupts(); \ } while(0) #endif /* WIN32 */ --- 102,108 ---- do { \ if (UNBLOCKED_SIGNAL_QUEUE()) \ pgwin32_dispatch_queued_signals(); \ ! if (IsInterruptEventPending) \ ProcessInterrupts(); \ } while(0) #endif /* WIN32 */ diff -cr cvs/src/include/storage/procarray.h cvs.build/src/include/storage/procarray.h *** cvs/src/include/storage/procarray.h 2009-12-24 13:55:33.000000000 +0100 --- cvs.build/src/include/storage/procarray.h 2010-01-06 19:36:15.000000000 +0100 *************** *** 15,20 **** --- 15,21 ---- #define PROCARRAY_H #include "storage/lock.h" + #include "storage/procsignal.h" #include "storage/standby.h" #include "utils/snapshot.h" *************** *** 59,65 **** extern VirtualTransactionId *GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid, bool skipExistingConflicts); extern pid_t CancelVirtualTransaction(VirtualTransactionId vxid, ! int cancel_mode); extern int CountActiveBackends(void); extern int CountDBBackends(Oid databaseid); --- 60,66 ---- extern VirtualTransactionId *GetConflictingVirtualXIDs(TransactionId limitXmin, Oid dbOid, bool skipExistingConflicts); extern pid_t CancelVirtualTransaction(VirtualTransactionId vxid, ! ProcSignalReason sigmode); extern int CountActiveBackends(void); extern int CountDBBackends(Oid databaseid); diff -cr cvs/src/include/storage/procsignal.h cvs.build/src/include/storage/procsignal.h *** cvs/src/include/storage/procsignal.h 2009-12-09 11:24:53.000000000 +0100 --- cvs.build/src/include/storage/procsignal.h 2010-01-07 00:34:26.000000000 +0100 *************** *** 32,40 **** --- 32,51 ---- PROCSIG_CATCHUP_INTERRUPT, /* sinval catchup interrupt */ PROCSIG_NOTIFY_INTERRUPT, /* listen/notify interrupt */ + IDX_PROCSIG_HARMLESS, /* not a real identifier but an index. + * we treat harmless signals different than + * harmful ones. */ + + PROCSIG_CANCEL_IDLE_TRANSACTION, /* pg_backend_cancel_idle_transaction() */ + + PROCSIG_CONFLICT_ERROR_INTERRUPT, /* used by HotStandby for conflict */ + PROCSIG_CONFLICT_FATAL_INTERRUPT, /* resolution. */ + NUM_PROCSIGNALS /* Must be last! */ } ProcSignalReason; + #define IsHarmlessSignal(reason) (reason < IDX_PROCSIG_HARMLESS) + /* * prototypes for functions in procsignal.c */ diff -cr cvs/src/include/tcop/tcopprot.h cvs.build/src/include/tcop/tcopprot.h *** cvs/src/include/tcop/tcopprot.h 2009-12-09 11:24:53.000000000 +0100 --- cvs.build/src/include/tcop/tcopprot.h 2010-01-07 00:22:38.000000000 +0100 *************** *** 64,69 **** --- 64,74 ---- extern void quickdie(SIGNAL_ARGS); extern void StatementCancelHandler(SIGNAL_ARGS); extern void FloatExceptionHandler(SIGNAL_ARGS); + + extern void HandleCancelAction(bool cancelQuery, + bool cancelIdleTransaction, + bool cancelSession); + extern void prepare_for_client_read(void); extern void client_read_ended(void); extern const char *process_postgres_switches(int argc, char *argv[], diff -cr cvs/src/include/utils/builtins.h cvs.build/src/include/utils/builtins.h *** cvs/src/include/utils/builtins.h 2009-12-24 13:55:33.000000000 +0100 --- cvs.build/src/include/utils/builtins.h 2010-01-06 21:52:12.000000000 +0100 *************** *** 443,448 **** --- 443,449 ---- extern Datum current_database(PG_FUNCTION_ARGS); extern Datum current_query(PG_FUNCTION_ARGS); extern Datum pg_cancel_backend(PG_FUNCTION_ARGS); + extern Datum pg_cancel_idle_transaction(PG_FUNCTION_ARGS); extern Datum pg_terminate_backend(PG_FUNCTION_ARGS); extern Datum pg_reload_conf(PG_FUNCTION_ARGS); extern Datum pg_tablespace_databases(PG_FUNCTION_ARGS);