latch.c File Reference

#include "postgres.h"
#include "miscadmin.h"
#include "port/atomics.h"
#include "storage/latch.h"
#include "storage/waiteventset.h"
#include "utils/resowner.h"

Include dependency graph for latch.c:

Go to the source code of this file.

Macros
#define	LatchWaitSetLatchPos   0
#define	LatchWaitSetPostmasterDeathPos   1

Functions
void	InitializeLatchWaitSet (void)
void	InitLatch (Latch *latch)
void	InitSharedLatch (Latch *latch)
void	OwnLatch (Latch *latch)
void	DisownLatch (Latch *latch)
int	WaitLatch (Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
int	WaitLatchOrSocket (Latch *latch, int wakeEvents, pgsocket sock, long timeout, uint32 wait_event_info)
void	SetLatch (Latch *latch)
void	ResetLatch (Latch *latch)

Variables
static WaitEventSet *	LatchWaitSet

Macro Definition Documentation

LatchWaitSetLatchPos

#define LatchWaitSetLatchPos   0

Definition at line 31 of file latch.c.

LatchWaitSetPostmasterDeathPos

#define LatchWaitSetPostmasterDeathPos   1

Definition at line 32 of file latch.c.

Function Documentation

DisownLatch()

void DisownLatch

(

Latch *

latch

)

Definition at line 144 of file latch.c.

{
    Assert(latch->is_shared);
    Assert(latch->owner_pid == MyProcPid);
 
    latch->owner_pid = 0;
}

References Assert(), Latch::is_shared, MyProcPid, and Latch::owner_pid.

Referenced by AuxiliaryProcKill(), ProcKill(), and ShutdownWalRecovery().

InitializeLatchWaitSet()

void InitializeLatchWaitSet

(

void

)

Definition at line 35 of file latch.c.

{
    int         latch_pos PG_USED_FOR_ASSERTS_ONLY;
 
    Assert(LatchWaitSet == NULL);
 
    /* Set up the WaitEventSet used by WaitLatch(). */
    LatchWaitSet = CreateWaitEventSet(NULL, 2);
    latch_pos = AddWaitEventToSet(LatchWaitSet, WL_LATCH_SET, PGINVALID_SOCKET,
                                  MyLatch, NULL);
    Assert(latch_pos == LatchWaitSetLatchPos);
 
    /*
     * WaitLatch will modify this to WL_EXIT_ON_PM_DEATH or
     * WL_POSTMASTER_DEATH on each call.
     */
    if (IsUnderPostmaster)
    {
        latch_pos = AddWaitEventToSet(LatchWaitSet, WL_EXIT_ON_PM_DEATH,
                                      PGINVALID_SOCKET, NULL, NULL);
        Assert(latch_pos == LatchWaitSetPostmasterDeathPos);
    }
}

References AddWaitEventToSet(), Assert(), CreateWaitEventSet(), IsUnderPostmaster, LatchWaitSet, LatchWaitSetLatchPos, LatchWaitSetPostmasterDeathPos, MyLatch, PG_USED_FOR_ASSERTS_ONLY, PGINVALID_SOCKET, WL_EXIT_ON_PM_DEATH, and WL_LATCH_SET.

Referenced by InitPostmasterChild(), and InitStandaloneProcess().

InitLatch()

void InitLatch

(

Latch *

latch

)

Definition at line 63 of file latch.c.

{
    latch->is_set = false;
    latch->maybe_sleeping = false;
    latch->owner_pid = MyProcPid;
    latch->is_shared = false;
 
#ifdef WIN32
    latch->event = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (latch->event == NULL)
        elog(ERROR, "CreateEvent failed: error code %lu", GetLastError());
#endif                          /* WIN32 */
}

References elog, ERROR, Latch::is_set, Latch::is_shared, Latch::maybe_sleeping, MyProcPid, and Latch::owner_pid.

Referenced by InitProcessLocalLatch().

InitSharedLatch()

void InitSharedLatch

(

Latch *

latch

)

Definition at line 93 of file latch.c.

{
#ifdef WIN32
    SECURITY_ATTRIBUTES sa;
 
    /*
     * Set up security attributes to specify that the events are inherited.
     */
    ZeroMemory(&sa, sizeof(sa));
    sa.nLength = sizeof(sa);
    sa.bInheritHandle = TRUE;
 
    latch->event = CreateEvent(&sa, TRUE, FALSE, NULL);
    if (latch->event == NULL)
        elog(ERROR, "CreateEvent failed: error code %lu", GetLastError());
#endif
 
    latch->is_set = false;
    latch->maybe_sleeping = false;
    latch->owner_pid = 0;
    latch->is_shared = true;
}

References elog, ERROR, Latch::is_set, Latch::is_shared, Latch::maybe_sleeping, and Latch::owner_pid.

Referenced by InitProcGlobal(), and XLogRecoveryShmemInit().

OwnLatch()

void OwnLatch

(

Latch *

latch

)

Definition at line 126 of file latch.c.

{
    int         owner_pid;
 
    /* Sanity checks */
    Assert(latch->is_shared);
 
    owner_pid = latch->owner_pid;
    if (owner_pid != 0)
        elog(PANIC, "latch already owned by PID %d", owner_pid);
 
    latch->owner_pid = MyProcPid;
}

References Assert(), elog, Latch::is_shared, MyProcPid, Latch::owner_pid, and PANIC.

Referenced by InitAuxiliaryProcess(), InitProcess(), and InitWalRecovery().

ResetLatch()

void ResetLatch

(

Latch *

latch

)

Definition at line 372 of file latch.c.

{
    /* Only the owner should reset the latch */
    Assert(latch->owner_pid == MyProcPid);
    Assert(latch->maybe_sleeping == false);
 
    latch->is_set = false;
 
    /*
     * Ensure that the write to is_set gets flushed to main memory before we
     * examine any flag variables.  Otherwise a concurrent SetLatch might
     * falsely conclude that it needn't signal us, even though we have missed
     * seeing some flag updates that SetLatch was supposed to inform us of.
     */
    pg_memory_barrier();
}

References Assert(), Latch::is_set, Latch::maybe_sleeping, MyProcPid, Latch::owner_pid, and pg_memory_barrier.

Referenced by ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), CheckpointWriteDelay(), ConditionVariableTimedSleep(), copy_read_data(), do_pg_backup_stop(), ExecAppendAsyncEventWait(), gather_readnext(), IoWorkerMain(), lazy_truncate_heap(), libpqsrv_cancel(), libpqsrv_connect_internal(), libpqsrv_get_result(), LogicalParallelApplyLoop(), logicalrep_worker_stop_internal(), LogicalRepApplyLoop(), mq_putmessage(), pa_send_data(), pa_wait_for_xact_state(), pg_promote(), pg_sleep(), pg_wait_until_termination(), pgarch_MainLoop(), pgfdw_get_cleanup_result(), pq_check_connection(), ProcessPendingWrites(), ProcSleep(), ProcWaitForSignal(), recoveryApplyDelay(), secure_read(), secure_write(), ServerLoop(), shm_mq_receive_bytes(), shm_mq_send_bytes(), shm_mq_wait_internal(), ShutDownSlotSync(), summarizer_wait_for_wal(), SyncRepWaitForLSN(), SysLoggerMain(), test_shm_mq_pipelined(), throttle(), wait_for_relation_state_change(), wait_for_slot_activity(), wait_for_worker_state_change(), wait_for_workers_to_become_ready(), WaitForBackgroundWorkerShutdown(), WaitForBackgroundWorkerStartup(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WalRcvWaitForStartPosition(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), WalWriterMain(), and worker_spi_main().

SetLatch()

void SetLatch

(

Latch *

latch

)

Definition at line 288 of file latch.c.

{
#ifndef WIN32
    pid_t       owner_pid;
#else
    HANDLE      handle;
#endif
 
    /*
     * The memory barrier has to be placed here to ensure that any flag
     * variables possibly changed by this process have been flushed to main
     * memory, before we check/set is_set.
     */
    pg_memory_barrier();
 
    /* Quick exit if already set */
    if (latch->is_set)
        return;
 
    latch->is_set = true;
 
    pg_memory_barrier();
    if (!latch->maybe_sleeping)
        return;
 
#ifndef WIN32
 
    /*
     * See if anyone's waiting for the latch. It can be the current process if
     * we're in a signal handler. We use the self-pipe or SIGURG to ourselves
     * to wake up WaitEventSetWaitBlock() without races in that case. If it's
     * another process, send a signal.
     *
     * Fetch owner_pid only once, in case the latch is concurrently getting
     * owned or disowned. XXX: This assumes that pid_t is atomic, which isn't
     * guaranteed to be true! In practice, the effective range of pid_t fits
     * in a 32 bit integer, and so should be atomic. In the worst case, we
     * might end up signaling the wrong process. Even then, you're very
     * unlucky if a process with that bogus pid exists and belongs to
     * Postgres; and PG database processes should handle excess SIGUSR1
     * interrupts without a problem anyhow.
     *
     * Another sort of race condition that's possible here is for a new
     * process to own the latch immediately after we look, so we don't signal
     * it. This is okay so long as all callers of ResetLatch/WaitLatch follow
     * the standard coding convention of waiting at the bottom of their loops,
     * not the top, so that they'll correctly process latch-setting events
     * that happen before they enter the loop.
     */
    owner_pid = latch->owner_pid;
    if (owner_pid == 0)
        return;
    else if (owner_pid == MyProcPid)
        WakeupMyProc();
    else
        WakeupOtherProc(owner_pid);
 
#else
 
    /*
     * See if anyone's waiting for the latch. It can be the current process if
     * we're in a signal handler.
     *
     * Use a local variable here just in case somebody changes the event field
     * concurrently (which really should not happen).
     */
    handle = latch->event;
    if (handle)
    {
        SetEvent(handle);
 
        /*
         * Note that we silently ignore any errors. We might be in a signal
         * handler or other critical path where it's not safe to call elog().
         */
    }
#endif
}

References Latch::is_set, Latch::maybe_sleeping, MyProcPid, Latch::owner_pid, pg_memory_barrier, WakeupMyProc(), and WakeupOtherProc().

Referenced by avl_sigusr2_handler(), CheckDeadLockAlert(), ClientCheckTimeoutHandler(), ConditionVariableBroadcast(), ConditionVariableSignal(), die(), ForwardSyncRequest(), handle_pm_child_exit_signal(), handle_pm_pmsignal_signal(), handle_pm_reload_request_signal(), handle_pm_shutdown_request_signal(), handle_sig_alarm(), HandleCatchupInterrupt(), HandleNotifyInterrupt(), HandleParallelApplyMessageInterrupt(), HandleParallelMessageInterrupt(), IdleInTransactionSessionTimeoutHandler(), IdleSessionTimeoutHandler(), IdleStatsUpdateTimeoutHandler(), IoWorkerMain(), logicalrep_worker_wakeup_ptr(), pgaio_worker_submit_internal(), pgarch_waken_stop(), PgArchWakeup(), ProcessClientReadInterrupt(), ProcessClientWriteInterrupt(), ProcessPendingWrites(), ProcSendSignal(), procsignal_sigusr1_handler(), ProcWakeup(), ReqShutdownXLOG(), RequestCheckpoint(), RequestXLogStreaming(), shm_mq_detach_internal(), shm_mq_inc_bytes_read(), shm_mq_send_bytes(), shm_mq_sendv(), shm_mq_set_receiver(), shm_mq_set_sender(), SignalHandlerForConfigReload(), SignalHandlerForShutdownRequest(), sigUsr1Handler(), StatementCancelHandler(), StrategyGetBuffer(), SwitchBackToLocalLatch(), SwitchToSharedLatch(), SyncRepWakeQueue(), test_shm_mq_main(), TransactionTimeoutHandler(), WakeupRecovery(), WakeupWalSummarizer(), WalRcvForceReply(), WalSndLastCycleHandler(), WalSndWaitForWal(), and XLogSetAsyncXactLSN().

WaitLatch()

int WaitLatch	(	Latch *	latch,
		int	wakeEvents,
		long	timeout,
		uint32	wait_event_info
	)

Definition at line 172 of file latch.c.

{
    WaitEvent   event;
 
    /* Postmaster-managed callers must handle postmaster death somehow. */
    Assert(!IsUnderPostmaster ||
           (wakeEvents & WL_EXIT_ON_PM_DEATH) ||
           (wakeEvents & WL_POSTMASTER_DEATH));
 
    /*
     * Some callers may have a latch other than MyLatch, or no latch at all,
     * or want to handle postmaster death differently.  It's cheap to assign
     * those, so just do it every time.
     */
    if (!(wakeEvents & WL_LATCH_SET))
        latch = NULL;
    ModifyWaitEvent(LatchWaitSet, LatchWaitSetLatchPos, WL_LATCH_SET, latch);
    ModifyWaitEvent(LatchWaitSet, LatchWaitSetPostmasterDeathPos,
                    (wakeEvents & (WL_EXIT_ON_PM_DEATH | WL_POSTMASTER_DEATH)),
                    NULL);
 
    if (WaitEventSetWait(LatchWaitSet,
                         (wakeEvents & WL_TIMEOUT) ? timeout : -1,
                         &event, 1,
                         wait_event_info) == 0)
        return WL_TIMEOUT;
    else
        return event.events;
}

References Assert(), IsUnderPostmaster, LatchWaitSet, LatchWaitSetLatchPos, LatchWaitSetPostmasterDeathPos, ModifyWaitEvent(), WaitEventSetWait(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_POSTMASTER_DEATH, and WL_TIMEOUT.

Referenced by ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), CheckpointWriteDelay(), ConditionVariableTimedSleep(), do_pg_backup_stop(), gather_readnext(), IoWorkerMain(), lazy_truncate_heap(), LogicalParallelApplyLoop(), logicalrep_worker_stop_internal(), mq_putmessage(), pa_send_data(), pa_wait_for_xact_state(), pg_promote(), pg_sleep(), pg_wait_until_termination(), pgarch_MainLoop(), ProcSleep(), ProcWaitForSignal(), recoveryApplyDelay(), RegisterSyncRequest(), shm_mq_receive_bytes(), shm_mq_send_bytes(), shm_mq_wait_internal(), ShutDownSlotSync(), summarizer_wait_for_wal(), SyncRepWaitForLSN(), test_shm_mq_pipelined(), throttle(), wait_for_relation_state_change(), wait_for_slot_activity(), wait_for_worker_state_change(), wait_for_workers_to_become_ready(), WaitForBackgroundWorkerShutdown(), WaitForBackgroundWorkerStartup(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WalRcvWaitForStartPosition(), WalSummarizerMain(), WalWriterMain(), and worker_spi_main().

WaitLatchOrSocket()

int WaitLatchOrSocket	(	Latch *	latch,
		int	wakeEvents,
		pgsocket	sock,
		long	timeout,
		uint32	wait_event_info
	)

Definition at line 221 of file latch.c.

{
    int         ret = 0;
    int         rc;
    WaitEvent   event;
    WaitEventSet *set = CreateWaitEventSet(CurrentResourceOwner, 3);
 
    if (wakeEvents & WL_TIMEOUT)
        Assert(timeout >= 0);
    else
        timeout = -1;
 
    if (wakeEvents & WL_LATCH_SET)
        AddWaitEventToSet(set, WL_LATCH_SET, PGINVALID_SOCKET,
                          latch, NULL);
 
    /* Postmaster-managed callers must handle postmaster death somehow. */
    Assert(!IsUnderPostmaster ||
           (wakeEvents & WL_EXIT_ON_PM_DEATH) ||
           (wakeEvents & WL_POSTMASTER_DEATH));
 
    if ((wakeEvents & WL_POSTMASTER_DEATH) && IsUnderPostmaster)
        AddWaitEventToSet(set, WL_POSTMASTER_DEATH, PGINVALID_SOCKET,
                          NULL, NULL);
 
    if ((wakeEvents & WL_EXIT_ON_PM_DEATH) && IsUnderPostmaster)
        AddWaitEventToSet(set, WL_EXIT_ON_PM_DEATH, PGINVALID_SOCKET,
                          NULL, NULL);
 
    if (wakeEvents & WL_SOCKET_MASK)
    {
        int         ev;
 
        ev = wakeEvents & WL_SOCKET_MASK;
        AddWaitEventToSet(set, ev, sock, NULL, NULL);
    }
 
    rc = WaitEventSetWait(set, timeout, &event, 1, wait_event_info);
 
    if (rc == 0)
        ret |= WL_TIMEOUT;
    else
    {
        ret |= event.events & (WL_LATCH_SET |
                               WL_POSTMASTER_DEATH |
                               WL_SOCKET_MASK);
    }
 
    FreeWaitEventSet(set);
 
    return ret;
}

References AddWaitEventToSet(), Assert(), CreateWaitEventSet(), CurrentResourceOwner, FreeWaitEventSet(), IsUnderPostmaster, PGINVALID_SOCKET, WaitEventSetWait(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_POSTMASTER_DEATH, WL_SOCKET_MASK, and WL_TIMEOUT.

Referenced by be_tls_open_server(), copy_read_data(), libpqsrv_cancel(), libpqsrv_connect_internal(), libpqsrv_get_result(), LogicalRepApplyLoop(), pgfdw_get_cleanup_result(), read_or_wait(), secure_open_gssapi(), and WalReceiverMain().

Variable Documentation

LatchWaitSet

WaitEventSet* LatchWaitSet

static

Definition at line 28 of file latch.c.

Referenced by InitializeLatchWaitSet(), and WaitLatch().