This parameter can only be set in the <filename>postgresql.conf</filename>
file or on the server command line.
If this parameter is changed while the WAL receiver process is
- running, that process is signalled to shut down and expected to
+ running, that process is signaled to shut down and expected to
restart with the new setting (except if <varname>primary_conninfo</varname>
is an empty string).
This setting has no effect if the server is not in standby mode.
This parameter can only be set in the <filename>postgresql.conf</filename>
file or on the server command line.
If this parameter is changed while the WAL receiver process is running,
- that process is signalled to shut down and expected to restart with the
+ that process is signaled to shut down and expected to restart with the
new setting.
This setting has no effect if <varname>primary_conninfo</varname> is not
set or the server is not in standby mode.
The default is off. This parameter can only be set in the
<filename>postgresql.conf</filename> file or on the server command line.
If this parameter is changed while the WAL receiver process is running,
- that process is signalled to shut down and expected to restart with
+ that process is signaled to shut down and expected to restart with
the new setting.
</para>
</listitem>
treated the timeout as applying to the whole query string.)
In extended query protocol, the timeout starts running when any
query-related message (Parse, Bind, Execute, Describe) arrives, and
- it is cancelled by completion of an Execute or Sync message.
+ it is canceled by completion of an Execute or Sync message.
</para>
<para>
* behind. Waken them anyway if they're far enough behind, so that they'll
* advance their queue position pointers, allowing the global tail to advance.
*
- * Since we know the BackendId and the Pid the signalling is quite cheap.
+ * Since we know the BackendId and the Pid the signaling is quite cheap.
*/
static void
SignalBackends(void)
* Update the wrap limit for GetNewTransactionId and creation of new
* MultiXactIds. Note: these functions will also signal the postmaster
* for an(other) autovac cycle if needed. XXX should we avoid possibly
- * signalling twice?
+ * signaling twice?
*/
SetTransactionIdLimit(frozenXID, oldestxid_datoid);
SetMultiXactIdLimit(minMulti, minmulti_datoid, false);
*v_fcinfo_isnull = LLVMBuildLoad(b, v_fcinfo_isnullp, "");
/*
- * Add lifetime-end annotation, signalling that writes to memory don't
+ * Add lifetime-end annotation, signaling that writes to memory don't
* have to be retained (important for inlining potential).
*/
{
if (r != WAIT_TIMEOUT && r != WAIT_IO_COMPLETION && r != (WAIT_OBJECT_0 + numevents))
{
/*
- * We scan all events, even those not signalled, in case more than one
+ * We scan all events, even those not signaled, in case more than one
* event has been tagged but Wait.. can only return one.
*/
WSANETWORKEVENTS resEvents;
r = WaitForSingleObjectEx(timerCommArea.event, waittime, FALSE);
if (r == WAIT_OBJECT_0)
{
- /* Event signalled from main thread, change the timer */
+ /* Event signaled from main thread, change the timer */
EnterCriticalSection(&timerCommArea.crit_sec);
if (timerCommArea.value.it_value.tv_sec == 0 &&
timerCommArea.value.it_value.tv_usec == 0)
HandleAutoVacLauncherInterrupts();
/*
- * a worker finished, or postmaster signalled failure to start a
+ * a worker finished, or postmaster signaled failure to start a
* worker
*/
if (got_SIGUSR2)
int save_errno = errno;
/*
- * The signalling process should have set ckpt_flags nonzero, so all we
+ * The signaling process should have set ckpt_flags nonzero, so all we
* need do is ensure that our main loop gets kicked out of any wait.
*/
SetLatch(MyLatch);
/* ----------
* pgstat_recv_autovac() -
*
- * Process an autovacuum signalling message.
+ * Process an autovacuum signaling message.
* ----------
*/
static void
/* received START_AUTOVAC_LAUNCHER signal */
static volatile sig_atomic_t start_autovac_launcher = false;
-/* the launcher needs to be signalled to communicate some condition */
+/* the launcher needs to be signaled to communicate some condition */
static volatile bool avlauncher_needs_signal = false;
/* received START_WALRECEIVER signal */
* We only log messages and send signals if this is the first process
* crash and we're not doing an immediate shutdown; otherwise, we're only
* here to update postmaster's idea of live processes. If we have already
- * signalled children, nonzero exit status is to be expected, so don't
+ * signaled children, nonzero exit status is to be expected, so don't
* clutter log.
*/
take_action = !FatalError && Shutdown != ImmediateShutdown;
* might not even be connected to shared memory, so don't try to call
* AutoVacWorkerFailed.) Note that we also need to signal it so that it
* responds to the condition, but we don't do that here, instead waiting
- * for ServerLoop to do it. This way we avoid a ping-pong signalling in
+ * for ServerLoop to do it. This way we avoid a ping-pong signaling in
* quick succession between the autovac launcher and postmaster in case
* things get ugly.
*/
int acquired_by;
/*
- * Condition variable that's signalled when acquired_by changes.
+ * Condition variable that's signaled when acquired_by changes.
*/
ConditionVariable origin_cv;
* This module gets handed individual pieces of transactions in the order
* they are written to the WAL and is responsible to reassemble them into
* toplevel transaction sized pieces. When a transaction is completely
- * reassembled - signalled by reading the transaction commit record - it
+ * reassembled - signaled by reading the transaction commit record - it
* will then call the output plugin (cf. ReorderBufferCommit()) with the
* individual changes. The output plugins rely on snapshots built by
* snapbuild.c which hands them to us.
* because we don't expect the pipe to become readable or to have
* any errors either, treat those cases as postmaster death, too.
*
- * Be paranoid about a spurious event signalling the postmaster as
+ * Be paranoid about a spurious event signaling the postmaster as
* being dead. There have been reports about that happening with
* older primitives (select(2) to be specific), and a spurious
* WL_POSTMASTER_DEATH event would be painful. Re-checking doesn't
* we don't expect the pipe to become readable or to have any
* errors either, treat those cases as postmaster death, too.
*
- * Be paranoid about a spurious event signalling the postmaster as
+ * Be paranoid about a spurious event signaling the postmaster as
* being dead. There have been reports about that happening with
* older primitives (select(2) to be specific), and a spurious
* WL_POSTMASTER_DEATH event would be painful. Re-checking doesn't
/*-------------------------------------------------------------------------
*
* procsignal.c
- * Routines for interprocess signalling
+ * Routines for interprocess signaling
*
*
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
#include "tcop/tcopprot.h"
/*
- * The SIGUSR1 signal is multiplexed to support signalling multiple event
+ * The SIGUSR1 signal is multiplexed to support signaling multiple event
* types. The specific reason is communicated via flags in shared memory.
* We keep a boolean flag for each possible "reason", so that different
* reasons can be signaled to a process concurrently. (However, if the same
* Each process that wants to receive signals registers its process ID
* in the ProcSignalSlots array. The array is indexed by backend ID to make
* slot allocation simple, and to avoid having to search the array when you
- * know the backend ID of the process you're signalling. (We do support
- * signalling without backend ID, but it's a bit less efficient.)
+ * know the backend ID of the process you're signaling. (We do support
+ * signaling without backend ID, but it's a bit less efficient.)
*
* The flags are actually declared as "volatile sig_atomic_t" for maximum
* portability. This should ensure that loads and stores of the flag
/*
* Perform global barrier related interrupt checking.
*
- * Any backend that participates in ProcSignal signalling must arrange to
+ * Any backend that participates in ProcSignal signaling must arrange to
* call this function periodically. It is called from CHECK_FOR_INTERRUPTS(),
* which is enough for normal backends, but not necessarily for all types of
* background processes.
}
}
- /* Wait to be signalled. */
+ /* Wait to be signaled. */
(void) WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, 0,
WAIT_EVENT_MQ_INTERNAL);
/*-------------------------------------------------------------------------
*
* signalfuncs.c
- * Functions for signalling backends
+ * Functions for signaling backends
*
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
/*
* Initialize shared invalidation management for Startup process, being
* careful to register ourselves as a sendOnly process so we don't need to
- * read messages, nor will we get signalled when the queue starts filling
+ * read messages, nor will we get signaled when the queue starts filling
* up.
*/
SharedInvalBackendInit(true);
* reportMemoryError specifies whether a lock request that fills the lock
* table should generate an ERROR or not. Passing "false" allows the caller
* to attempt to recover from lock-table-full situations, perhaps by forcibly
- * cancelling other lock holders and then retrying. Note, however, that the
+ * canceling other lock holders and then retrying. Note, however, that the
* return code for that is LOCKACQUIRE_NOT_AVAIL, so that it's unsafe to use
* in combination with dontWait = true, as the cause of failure couldn't be
* distinguished.
*/
/*
- * quickdie() occurs when signalled SIGQUIT by the postmaster.
+ * quickdie() occurs when signaled SIGQUIT by the postmaster.
*
* Some backend has bought the farm,
* so we need to stop what we're doing and exit.
while ((entry = (RelfilenodeMapEntry *) hash_seq_search(&status)) != NULL)
{
/*
- * If relid is InvalidOid, signalling a complete reset, we must remove
+ * If relid is InvalidOid, signaling a complete reset, we must remove
* all entries, otherwise just remove the specific relation's entry.
* Always remove negative cache entries.
*/
*
* *call_again is false on the first call to index_fetch_tuple for a tid.
* If there potentially is another tuple matching the tid, *call_again
- * needs be set to true by index_fetch_tuple, signalling to the caller
+ * needs be set to true by index_fetch_tuple, signaling to the caller
* that index_fetch_tuple should be called again for the same tid.
*
* *all_dead, if all_dead is not NULL, should be set to true by
*
* *call_again needs to be false on the first call to table_index_fetch_tuple() for
* a tid. If there potentially is another tuple matching the tid, *call_again
- * will be set to true, signalling that table_index_fetch_tuple() should be called
+ * will be set to true, signaling that table_index_fetch_tuple() should be called
* again for the same tid.
*
* *all_dead, if all_dead is not NULL, will be set to true by
/*
* As table_index_build_scan(), except that instead of scanning the complete
* table, only the given number of blocks are scanned. Scan to end-of-rel can
- * be signalled by passing InvalidBlockNumber as numblocks. Note that
+ * be signaled by passing InvalidBlockNumber as numblocks. Note that
* restricting the range to scan cannot be done when requesting syncscan.
*
* When "anyvisible" mode is requested, all tuples visible to any transaction
*
* A minimal commit/abort record only consists of a xl_xact_commit/abort
* struct. The presence of additional information is indicated by bits set in
- * 'xl_xact_xinfo->xinfo'. The presence of the xinfo field itself is signalled
+ * 'xl_xact_xinfo->xinfo'. The presence of the xinfo field itself is signaled
* by a set XLOG_XACT_HAS_INFO bit in the xl_info field.
*
* NB: All the individual data chunks should be sized to multiples of
/* is somebody performing io on this slot? */
LWLock io_in_progress_lock;
- /* Condition variable signalled when active_pid changes */
+ /* Condition variable signaled when active_pid changes */
ConditionVariable active_cv;
/* all the remaining data is only used for logical slots */
* on the condition variable; and (3) broadcast, which wakes up every
* process sleeping on the condition variable. In our implementation,
* condition variables put a process into an interruptible sleep (so it
- * can be cancelled prior to the fulfillment of the condition) and do not
+ * can be canceled prior to the fulfillment of the condition) and do not
* use pointers internally (so that they are safe to use within DSMs).
*
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
/*-------------------------------------------------------------------------
*
* procsignal.h
- * Routines for interprocess signalling
+ * Routines for interprocess signaling
*
*
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
/*
- * Reasons for signalling a Postgres child process (a backend or an auxiliary
+ * Reasons for signaling a Postgres child process (a backend or an auxiliary
* process, like checkpointer). We can cope with concurrent signals for different
* reasons. However, if the same reason is signaled multiple times in quick
* succession, the process is likely to observe only one notification of it.
break;
}
- /* Wait to be signalled. */
+ /* Wait to be signaled. */
(void) WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, 0,
PG_WAIT_EXTENSION);
projects / postgresql.git / commitdiff