latch.c File Reference

#include "postgres.h"
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <unistd.h>
#include "libpq/pqsignal.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "port/atomics.h"
#include "portability/instr_time.h"
#include "postmaster/postmaster.h"
#include "storage/fd.h"
#include "storage/ipc.h"
#include "storage/latch.h"
#include "storage/pmsignal.h"
#include "storage/shmem.h"
#include "utils/memutils.h"

Include dependency graph for latch.c:

Go to the source code of this file.

Data Structures
struct	WaitEventSet

Macros
#define	LatchWaitSetLatchPos   0

Functions
static int	WaitEventSetWaitBlock (WaitEventSet *set, int cur_timeout, WaitEvent *occurred_events, int nevents)
void	InitializeLatchSupport (void)
void	InitializeLatchWaitSet (void)
void	ShutdownLatchSupport (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)
WaitEventSet *	CreateWaitEventSet (MemoryContext context, int nevents)
void	FreeWaitEventSet (WaitEventSet *set)
int	AddWaitEventToSet (WaitEventSet *set, uint32 events, pgsocket fd, Latch *latch, void *user_data)
void	ModifyWaitEvent (WaitEventSet *set, int pos, uint32 events, Latch *latch)
int	WaitEventSetWait (WaitEventSet *set, long timeout, WaitEvent *occurred_events, int nevents, uint32 wait_event_info)
int	GetNumRegisteredWaitEvents (WaitEventSet *set)

Variables
static WaitEventSet *	LatchWaitSet
static volatile sig_atomic_t	waiting = false

Macro Definition Documentation

LatchWaitSetLatchPos

#define LatchWaitSetLatchPos   0

Definition at line 143 of file latch.c.

Referenced by InitializeLatchWaitSet(), and WaitLatch().

Function Documentation

AddWaitEventToSet()

int AddWaitEventToSet	(	WaitEventSet *	set,
		uint32	events,
		pgsocket	fd,
		Latch *	latch,
		void *	user_data
	)

Definition at line 862 of file latch.c.

References Assert, elog, ERROR, WaitEventSet::events, fd(), WaitEventSet::latch, MyProcPid, Latch::owner_pid, PGINVALID_SOCKET, postmaster_alive_fds, POSTMASTER_FD_WATCH, WaitEvent::user_data, WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_POSTMASTER_DEATH, and WL_SOCKET_MASK.

Referenced by ExecAppendAsyncEventWait(), InitializeLatchWaitSet(), PgstatCollectorMain(), postgresForeignAsyncConfigureWait(), pq_init(), SysLoggerMain(), and WaitLatchOrSocket().

{
    WaitEvent  *event;

    /* not enough space */
    Assert(set->nevents < set->nevents_space);

    if (events == WL_EXIT_ON_PM_DEATH)
    {
        events = WL_POSTMASTER_DEATH;
        set->exit_on_postmaster_death = true;
    }

    if (latch)
    {
        if (latch->owner_pid != MyProcPid)
            elog(ERROR, "cannot wait on a latch owned by another process");
        if (set->latch)
            elog(ERROR, "cannot wait on more than one latch");
        if ((events & WL_LATCH_SET) != WL_LATCH_SET)
            elog(ERROR, "latch events only support being set");
    }
    else
    {
        if (events & WL_LATCH_SET)
            elog(ERROR, "cannot wait on latch without a specified latch");
    }

    /* waiting for socket readiness without a socket indicates a bug */
    if (fd == PGINVALID_SOCKET && (events & WL_SOCKET_MASK))
        elog(ERROR, "cannot wait on socket event without a socket");

    event = &set->events[set->nevents];
    event->pos = set->nevents++;
    event->fd = fd;
    event->events = events;
    event->user_data = user_data;
#ifdef WIN32
    event->reset = false;
#endif

    if (events == WL_LATCH_SET)
    {
        set->latch = latch;
        set->latch_pos = event->pos;
#if defined(WAIT_USE_POLL)
        event->fd = selfpipe_readfd;
#elif defined(WAIT_USE_EPOLL)
        event->fd = signal_fd;
#else
        event->fd = PGINVALID_SOCKET;
#ifdef WAIT_USE_EPOLL
        return event->pos;
#endif
#endif
    }
    else if (events == WL_POSTMASTER_DEATH)
    {
#ifndef WIN32
        event->fd = postmaster_alive_fds[POSTMASTER_FD_WATCH];
#endif
    }

    /* perform wait primitive specific initialization, if needed */
#if defined(WAIT_USE_EPOLL)
    WaitEventAdjustEpoll(set, event, EPOLL_CTL_ADD);
#elif defined(WAIT_USE_KQUEUE)
    WaitEventAdjustKqueue(set, event, 0);
#elif defined(WAIT_USE_POLL)
    WaitEventAdjustPoll(set, event);
#elif defined(WAIT_USE_WIN32)
    WaitEventAdjustWin32(set, event);
#endif

    return event->pos;
}

CreateWaitEventSet()

WaitEventSet* CreateWaitEventSet	(	MemoryContext	context,
		int	nevents
	)

Definition at line 684 of file latch.c.

References AcquireExternalFD(), close, elog, ERROR, MAXALIGN, MemoryContextAllocZero(), WaitEventSet::nevents, pgwin32_signal_event, ReleaseExternalFD(), and StaticAssertStmt.

Referenced by ExecAppendAsyncEventWait(), InitializeLatchWaitSet(), PgstatCollectorMain(), pq_init(), SysLoggerMain(), and WaitLatchOrSocket().

{
    WaitEventSet *set;
    char       *data;
    Size        sz = 0;

    /*
     * Use MAXALIGN size/alignment to guarantee that later uses of memory are
     * aligned correctly. E.g. epoll_event might need 8 byte alignment on some
     * platforms, but earlier allocations like WaitEventSet and WaitEvent
     * might not sized to guarantee that when purely using sizeof().
     */
    sz += MAXALIGN(sizeof(WaitEventSet));
    sz += MAXALIGN(sizeof(WaitEvent) * nevents);

#if defined(WAIT_USE_EPOLL)
    sz += MAXALIGN(sizeof(struct epoll_event) * nevents);
#elif defined(WAIT_USE_KQUEUE)
    sz += MAXALIGN(sizeof(struct kevent) * nevents);
#elif defined(WAIT_USE_POLL)
    sz += MAXALIGN(sizeof(struct pollfd) * nevents);
#elif defined(WAIT_USE_WIN32)
    /* need space for the pgwin32_signal_event */
    sz += MAXALIGN(sizeof(HANDLE) * (nevents + 1));
#endif

    data = (char *) MemoryContextAllocZero(context, sz);

    set = (WaitEventSet *) data;
    data += MAXALIGN(sizeof(WaitEventSet));

    set->events = (WaitEvent *) data;
    data += MAXALIGN(sizeof(WaitEvent) * nevents);

#if defined(WAIT_USE_EPOLL)
    set->epoll_ret_events = (struct epoll_event *) data;
    data += MAXALIGN(sizeof(struct epoll_event) * nevents);
#elif defined(WAIT_USE_KQUEUE)
    set->kqueue_ret_events = (struct kevent *) data;
    data += MAXALIGN(sizeof(struct kevent) * nevents);
#elif defined(WAIT_USE_POLL)
    set->pollfds = (struct pollfd *) data;
    data += MAXALIGN(sizeof(struct pollfd) * nevents);
#elif defined(WAIT_USE_WIN32)
    set->handles = (HANDLE) data;
    data += MAXALIGN(sizeof(HANDLE) * nevents);
#endif

    set->latch = NULL;
    set->nevents_space = nevents;
    set->exit_on_postmaster_death = false;

#if defined(WAIT_USE_EPOLL)
    if (!AcquireExternalFD())
    {
        /* treat this as though epoll_create1 itself returned EMFILE */
        elog(ERROR, "epoll_create1 failed: %m");
    }
    set->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
    if (set->epoll_fd < 0)
    {
        ReleaseExternalFD();
        elog(ERROR, "epoll_create1 failed: %m");
    }
#elif defined(WAIT_USE_KQUEUE)
    if (!AcquireExternalFD())
    {
        /* treat this as though kqueue itself returned EMFILE */
        elog(ERROR, "kqueue failed: %m");
    }
    set->kqueue_fd = kqueue();
    if (set->kqueue_fd < 0)
    {
        ReleaseExternalFD();
        elog(ERROR, "kqueue failed: %m");
    }
    if (fcntl(set->kqueue_fd, F_SETFD, FD_CLOEXEC) == -1)
    {
        int         save_errno = errno;

        close(set->kqueue_fd);
        ReleaseExternalFD();
        errno = save_errno;
        elog(ERROR, "fcntl(F_SETFD) failed on kqueue descriptor: %m");
    }
    set->report_postmaster_not_running = false;
#elif defined(WAIT_USE_WIN32)

    /*
     * To handle signals while waiting, we need to add a win32 specific event.
     * We accounted for the additional event at the top of this routine. See
     * port/win32/signal.c for more details.
     *
     * Note: pgwin32_signal_event should be first to ensure that it will be
     * reported when multiple events are set.  We want to guarantee that
     * pending signals are serviced.
     */
    set->handles[0] = pgwin32_signal_event;
    StaticAssertStmt(WSA_INVALID_EVENT == NULL, "");
#endif

    return set;
}

DisownLatch()

void DisownLatch

(

Latch *

latch

)

Definition at line 424 of file latch.c.

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

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

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

    latch->owner_pid = 0;
}

FreeWaitEventSet()

void FreeWaitEventSet

(

WaitEventSet *

set

)

Definition at line 798 of file latch.c.

References close, WaitEvent::events, WaitEvent::fd, pfree(), WaitEvent::pos, ReleaseExternalFD(), WL_LATCH_SET, and WL_POSTMASTER_DEATH.

Referenced by ExecAppendAsyncEventWait(), PgstatCollectorMain(), ShutdownLatchSupport(), and WaitLatchOrSocket().

{
#if defined(WAIT_USE_EPOLL)
    close(set->epoll_fd);
    ReleaseExternalFD();
#elif defined(WAIT_USE_KQUEUE)
    close(set->kqueue_fd);
    ReleaseExternalFD();
#elif defined(WAIT_USE_WIN32)
    WaitEvent  *cur_event;

    for (cur_event = set->events;
         cur_event < (set->events + set->nevents);
         cur_event++)
    {
        if (cur_event->events & WL_LATCH_SET)
        {
            /* uses the latch's HANDLE */
        }
        else if (cur_event->events & WL_POSTMASTER_DEATH)
        {
            /* uses PostmasterHandle */
        }
        else
        {
            /* Clean up the event object we created for the socket */
            WSAEventSelect(cur_event->fd, NULL, 0);
            WSACloseEvent(set->handles[cur_event->pos + 1]);
        }
    }
#endif

    pfree(set);
}

GetNumRegisteredWaitEvents()

int GetNumRegisteredWaitEvents

(

WaitEventSet *

set

)

Definition at line 2022 of file latch.c.

References buf, EAGAIN, EINTR, elog, ERROR, EWOULDBLOCK, fd(), read, SIGNAL_ARGS, waiting, and write.

Referenced by ExecAppendAsyncEventWait(), and postgresForeignAsyncConfigureWait().

{
    return set->nevents;
}

InitializeLatchSupport()

void InitializeLatchSupport

(

void

)

Definition at line 192 of file latch.c.

References Assert, close, elog, FATAL, IsUnderPostmaster, MyProcPid, pqsignal(), ReleaseExternalFD(), ReserveExternalFD(), SIG_IGN, and UnBlockSig.

Referenced by InitPostmasterChild(), and InitStandaloneProcess().

{
#if defined(WAIT_USE_POLL)
    int         pipefd[2];

    if (IsUnderPostmaster)
    {
        /*
         * We might have inherited connections to a self-pipe created by the
         * postmaster.  It's critical that child processes create their own
         * self-pipes, of course, and we really want them to close the
         * inherited FDs for safety's sake.
         */
        if (selfpipe_owner_pid != 0)
        {
            /* Assert we go through here but once in a child process */
            Assert(selfpipe_owner_pid != MyProcPid);
            /* Release postmaster's pipe FDs; ignore any error */
            (void) close(selfpipe_readfd);
            (void) close(selfpipe_writefd);
            /* Clean up, just for safety's sake; we'll set these below */
            selfpipe_readfd = selfpipe_writefd = -1;
            selfpipe_owner_pid = 0;
            /* Keep fd.c's accounting straight */
            ReleaseExternalFD();
            ReleaseExternalFD();
        }
        else
        {
            /*
             * Postmaster didn't create a self-pipe ... or else we're in an
             * EXEC_BACKEND build, in which case it doesn't matter since the
             * postmaster's pipe FDs were closed by the action of FD_CLOEXEC.
             * fd.c won't have state to clean up, either.
             */
            Assert(selfpipe_readfd == -1);
        }
    }
    else
    {
        /* In postmaster or standalone backend, assert we do this but once */
        Assert(selfpipe_readfd == -1);
        Assert(selfpipe_owner_pid == 0);
    }

    /*
     * Set up the self-pipe that allows a signal handler to wake up the
     * poll()/epoll_wait() in WaitLatch. Make the write-end non-blocking, so
     * that SetLatch won't block if the event has already been set many times
     * filling the kernel buffer. Make the read-end non-blocking too, so that
     * we can easily clear the pipe by reading until EAGAIN or EWOULDBLOCK.
     * Also, make both FDs close-on-exec, since we surely do not want any
     * child processes messing with them.
     */
    if (pipe(pipefd) < 0)
        elog(FATAL, "pipe() failed: %m");
    if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) == -1)
        elog(FATAL, "fcntl(F_SETFL) failed on read-end of self-pipe: %m");
    if (fcntl(pipefd[1], F_SETFL, O_NONBLOCK) == -1)
        elog(FATAL, "fcntl(F_SETFL) failed on write-end of self-pipe: %m");
    if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) == -1)
        elog(FATAL, "fcntl(F_SETFD) failed on read-end of self-pipe: %m");
    if (fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) == -1)
        elog(FATAL, "fcntl(F_SETFD) failed on write-end of self-pipe: %m");

    selfpipe_readfd = pipefd[0];
    selfpipe_writefd = pipefd[1];
    selfpipe_owner_pid = MyProcPid;

    /* Tell fd.c about these two long-lived FDs */
    ReserveExternalFD();
    ReserveExternalFD();

    pqsignal(SIGURG, latch_sigurg_handler);
#endif

#ifdef WAIT_USE_EPOLL
    sigset_t    signalfd_mask;

    /* Block SIGURG, because we'll receive it through a signalfd. */
    sigaddset(&UnBlockSig, SIGURG);

    /* Set up the signalfd to receive SIGURG notifications. */
    sigemptyset(&signalfd_mask);
    sigaddset(&signalfd_mask, SIGURG);
    signal_fd = signalfd(-1, &signalfd_mask, SFD_NONBLOCK | SFD_CLOEXEC);
    if (signal_fd < 0)
        elog(FATAL, "signalfd() failed");
    ReserveExternalFD();
#endif

#ifdef WAIT_USE_KQUEUE
    /* Ignore SIGURG, because we'll receive it via kqueue. */
    pqsignal(SIGURG, SIG_IGN);
#endif
}

InitializeLatchWaitSet()

void InitializeLatchWaitSet

(

void

)

Definition at line 290 of file latch.c.

References AddWaitEventToSet(), Assert, CreateWaitEventSet(), IsUnderPostmaster, WaitEventSet::latch_pos, LatchWaitSetLatchPos, MyLatch, PG_USED_FOR_ASSERTS_ONLY, PGINVALID_SOCKET, TopMemoryContext, WL_EXIT_ON_PM_DEATH, and WL_LATCH_SET.

Referenced by InitPostmasterChild(), and InitStandaloneProcess().

{
    int         latch_pos PG_USED_FOR_ASSERTS_ONLY;

    Assert(LatchWaitSet == NULL);

    /* Set up the WaitEventSet used by WaitLatch(). */
    LatchWaitSet = CreateWaitEventSet(TopMemoryContext, 2);
    latch_pos = AddWaitEventToSet(LatchWaitSet, WL_LATCH_SET, PGINVALID_SOCKET,
                                  MyLatch, NULL);
    if (IsUnderPostmaster)
        AddWaitEventToSet(LatchWaitSet, WL_EXIT_ON_PM_DEATH,
                          PGINVALID_SOCKET, NULL, NULL);

    Assert(latch_pos == LatchWaitSetLatchPos);
}

InitLatch()

void InitLatch

(

Latch *

latch

)

Definition at line 338 of file latch.c.

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

Referenced by InitPostmasterChild(), and InitStandaloneProcess().

{
    latch->is_set = false;
    latch->maybe_sleeping = false;
    latch->owner_pid = MyProcPid;
    latch->is_shared = false;

#if defined(WAIT_USE_POLL)
    /* Assert InitializeLatchSupport has been called in this process */
    Assert(selfpipe_readfd >= 0 && selfpipe_owner_pid == MyProcPid);
#elif defined(WAIT_USE_WIN32)
    latch->event = CreateEvent(NULL, TRUE, FALSE, NULL);
    if (latch->event == NULL)
        elog(ERROR, "CreateEvent failed: error code %lu", GetLastError());
#endif                          /* WIN32 */
}

InitSharedLatch()

void InitSharedLatch

(

Latch *

latch

)

Definition at line 371 of file latch.c.

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

Referenced by InitProcGlobal(), and XLOGShmemInit().

{
#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;
}

ModifyWaitEvent()

void ModifyWaitEvent	(	WaitEventSet *	set,
		int	pos,
		uint32	events,
		Latch *	latch
	)

Definition at line 948 of file latch.c.

References generate_unaccent_rules::action, Assert, elog, ereport, errcode_for_socket_access(), errmsg(), ERROR, WaitEventSet::events, WaitEvent::events, WaitEvent::fd, WaitEventSet::latch, MyProcPid, WaitEventSet::nevents, Latch::owner_pid, PGINVALID_SOCKET, PostmasterIsAlive, PostmasterPid, WL_LATCH_SET, WL_POSTMASTER_DEATH, WL_SOCKET_CONNECTED, WL_SOCKET_READABLE, and WL_SOCKET_WRITEABLE.

Referenced by secure_read(), secure_write(), SwitchBackToLocalLatch(), SwitchToSharedLatch(), WaitLatch(), and WalSndWait().

{
    WaitEvent  *event;
#if defined(WAIT_USE_KQUEUE)
    int         old_events;
#endif

    Assert(pos < set->nevents);

    event = &set->events[pos];
#if defined(WAIT_USE_KQUEUE)
    old_events = event->events;
#endif

    /*
     * If neither the event mask nor the associated latch changes, return
     * early. That's an important optimization for some sockets, where
     * ModifyWaitEvent is frequently used to switch from waiting for reads to
     * waiting on writes.
     */
    if (events == event->events &&
        (!(event->events & WL_LATCH_SET) || set->latch == latch))
        return;

    if (event->events & WL_LATCH_SET &&
        events != event->events)
    {
        elog(ERROR, "cannot modify latch event");
    }

    if (event->events & WL_POSTMASTER_DEATH)
    {
        elog(ERROR, "cannot modify postmaster death event");
    }

    /* FIXME: validate event mask */
    event->events = events;

    if (events == WL_LATCH_SET)
    {
        if (latch && latch->owner_pid != MyProcPid)
            elog(ERROR, "cannot wait on a latch owned by another process");
        set->latch = latch;

        /*
         * On Unix, we don't need to modify the kernel object because the
         * underlying pipe (if there is one) is the same for all latches so we
         * can return immediately.  On Windows, we need to update our array of
         * handles, but we leave the old one in place and tolerate spurious
         * wakeups if the latch is disabled.
         */
#if defined(WAIT_USE_WIN32)
        if (!latch)
            return;
#else
        return;
#endif
    }

#if defined(WAIT_USE_EPOLL)
    WaitEventAdjustEpoll(set, event, EPOLL_CTL_MOD);
#elif defined(WAIT_USE_KQUEUE)
    WaitEventAdjustKqueue(set, event, old_events);
#elif defined(WAIT_USE_POLL)
    WaitEventAdjustPoll(set, event);
#elif defined(WAIT_USE_WIN32)
    WaitEventAdjustWin32(set, event);
#endif
}

OwnLatch()

void OwnLatch

(

Latch *

latch

)

Definition at line 404 of file latch.c.

References Assert, elog, ERROR, Latch::is_shared, MyProcPid, and Latch::owner_pid.

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

{
    /* Sanity checks */
    Assert(latch->is_shared);

#if defined(WAIT_USE_POLL)
    /* Assert InitializeLatchSupport has been called in this process */
    Assert(selfpipe_readfd >= 0 && selfpipe_owner_pid == MyProcPid);
#endif

    if (latch->owner_pid != 0)
        elog(ERROR, "latch already owned");

    latch->owner_pid = MyProcPid;
}

ResetLatch()

void ResetLatch

(

Latch *

latch

)

Definition at line 660 of file latch.c.

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

Referenced by ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), ConditionVariableTimedSleep(), copy_read_data(), do_pg_stop_backup(), gather_readnext(), initialize_worker_spi(), lazy_truncate_heap(), libpqrcv_connect(), libpqrcv_PQgetResult(), logicalrep_worker_stop(), LogicalRepApplyLoop(), mq_putmessage(), pg_promote(), pg_sleep(), pg_wait_until_termination(), pgarch_MainLoop(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PgstatCollectorMain(), ProcSleep(), ProcWaitForSignal(), recoveryApplyDelay(), secure_read(), secure_write(), shm_mq_receive_bytes(), shm_mq_send_bytes(), shm_mq_wait_internal(), SyncRepWaitForLSN(), SysLoggerMain(), test_shm_mq_pipelined(), throttle(), vacuum_delay_point(), wait_for_relation_state_change(), wait_for_worker_state_change(), wait_for_workers_to_become_ready(), WaitForBackgroundWorkerShutdown(), WaitForBackgroundWorkerStartup(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WalRcvWaitForStartPosition(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), WalSndWriteData(), and WalWriterMain().

{
    /* 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();
}

SetLatch()

void SetLatch

(

Latch *

latch

)

Definition at line 567 of file latch.c.

References Latch::is_set, kill, Latch::maybe_sleeping, MyProcPid, Latch::owner_pid, pg_memory_barrier, and waiting.

Referenced by avl_sigusr2_handler(), CheckDeadLockAlert(), ClientCheckTimeoutHandler(), ConditionVariableBroadcast(), ConditionVariableSignal(), die(), ForwardSyncRequest(), handle_sig_alarm(), HandleCatchupInterrupt(), HandleNotifyInterrupt(), HandleParallelMessageInterrupt(), IdleInTransactionSessionTimeoutHandler(), IdleSessionTimeoutHandler(), logicalrep_worker_wakeup_ptr(), pgarch_waken_stop(), PgArchWakeup(), ProcessClientReadInterrupt(), ProcessClientWriteInterrupt(), ProcSendSignal(), procsignal_sigusr1_handler(), ProcWakeup(), RecoveryConflictInterrupt(), ReqCheckpointHandler(), 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(), WakeupRecovery(), WalRcvForceReply(), WalSndLastCycleHandler(), WalSndWaitForWal(), WalSndWakeup(), WalSndWriteData(), write_syslogger_file(), and XLogSetAsyncXactLSN().

{
#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)
    {
#if defined(WAIT_USE_POLL)
        if (waiting)
            sendSelfPipeByte();
#else
        if (waiting)
            kill(MyProcPid, SIGURG);
#endif
    }
    else
        kill(owner_pid, SIGURG);

#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

}

ShutdownLatchSupport()

void ShutdownLatchSupport

(

void

)

Definition at line 308 of file latch.c.

References close, FreeWaitEventSet(), InvalidPid, pqsignal(), and SIG_IGN.

{
#if defined(WAIT_USE_POLL)
    pqsignal(SIGURG, SIG_IGN);
#endif

    if (LatchWaitSet)
    {
        FreeWaitEventSet(LatchWaitSet);
        LatchWaitSet = NULL;
    }

#if defined(WAIT_USE_POLL)
    close(selfpipe_readfd);
    close(selfpipe_writefd);
    selfpipe_readfd = -1;
    selfpipe_writefd = -1;
    selfpipe_owner_pid = InvalidPid;
#endif

#if defined(WAIT_USE_EPOLL)
    close(signal_fd);
    signal_fd = -1;
#endif
}

WaitEventSetWait()

int WaitEventSetWait	(	WaitEventSet *	set,
		long	timeout,
		WaitEvent *	occurred_events,
		int	nevents,
		uint32	wait_event_info
	)

Definition at line 1306 of file latch.c.

References Assert, buf, EINTR, elog, ereport, errcode_for_socket_access(), errmsg(), ERROR, WaitEvent::events, WaitEvent::fd, INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, WaitEventSet::nevents, pg_memory_barrier, PGINVALID_SOCKET, pgstat_report_wait_end(), pgstat_report_wait_start(), pgwin32_dispatch_queued_signals(), WaitEvent::pos, PostmasterIsAliveInternal(), proc_exit(), start_time, unlikely, WaitEvent::user_data, WaitEventSetWaitBlock(), waiting, WL_LATCH_SET, WL_POSTMASTER_DEATH, WL_SOCKET_CONNECTED, WL_SOCKET_MASK, WL_SOCKET_READABLE, and WL_SOCKET_WRITEABLE.

Referenced by ExecAppendAsyncEventWait(), PgstatCollectorMain(), secure_read(), secure_write(), SysLoggerMain(), WaitLatch(), WaitLatchOrSocket(), and WalSndWait().

{
    int         returned_events = 0;
    instr_time  start_time;
    instr_time  cur_time;
    long        cur_timeout = -1;

    Assert(nevents > 0);

    /*
     * Initialize timeout if requested.  We must record the current time so
     * that we can determine the remaining timeout if interrupted.
     */
    if (timeout >= 0)
    {
        INSTR_TIME_SET_CURRENT(start_time);
        Assert(timeout >= 0 && timeout <= INT_MAX);
        cur_timeout = timeout;
    }

    pgstat_report_wait_start(wait_event_info);

#ifndef WIN32
    waiting = true;
#else
    /* Ensure that signals are serviced even if latch is already set */
    pgwin32_dispatch_queued_signals();
#endif
    while (returned_events == 0)
    {
        int         rc;

        /*
         * Check if the latch is set already. If so, leave the loop
         * immediately, avoid blocking again. We don't attempt to report any
         * other events that might also be satisfied.
         *
         * If someone sets the latch between this and the
         * WaitEventSetWaitBlock() below, the setter will write a byte to the
         * pipe (or signal us and the signal handler will do that), and the
         * readiness routine will return immediately.
         *
         * On unix, If there's a pending byte in the self pipe, we'll notice
         * whenever blocking. Only clearing the pipe in that case avoids
         * having to drain it every time WaitLatchOrSocket() is used. Should
         * the pipe-buffer fill up we're still ok, because the pipe is in
         * nonblocking mode. It's unlikely for that to happen, because the
         * self pipe isn't filled unless we're blocking (waiting = true), or
         * from inside a signal handler in latch_sigurg_handler().
         *
         * On windows, we'll also notice if there's a pending event for the
         * latch when blocking, but there's no danger of anything filling up,
         * as "Setting an event that is already set has no effect.".
         *
         * Note: we assume that the kernel calls involved in latch management
         * will provide adequate synchronization on machines with weak memory
         * ordering, so that we cannot miss seeing is_set if a notification
         * has already been queued.
         */
        if (set->latch && !set->latch->is_set)
        {
            /* about to sleep on a latch */
            set->latch->maybe_sleeping = true;
            pg_memory_barrier();
            /* and recheck */
        }

        if (set->latch && set->latch->is_set)
        {
            occurred_events->fd = PGINVALID_SOCKET;
            occurred_events->pos = set->latch_pos;
            occurred_events->user_data =
                set->events[set->latch_pos].user_data;
            occurred_events->events = WL_LATCH_SET;
            occurred_events++;
            returned_events++;

            /* could have been set above */
            set->latch->maybe_sleeping = false;

            break;
        }

        /*
         * Wait for events using the readiness primitive chosen at the top of
         * this file. If -1 is returned, a timeout has occurred, if 0 we have
         * to retry, everything >= 1 is the number of returned events.
         */
        rc = WaitEventSetWaitBlock(set, cur_timeout,
                                   occurred_events, nevents);

        if (set->latch)
        {
            Assert(set->latch->maybe_sleeping);
            set->latch->maybe_sleeping = false;
        }

        if (rc == -1)
            break;              /* timeout occurred */
        else
            returned_events = rc;

        /* If we're not done, update cur_timeout for next iteration */
        if (returned_events == 0 && timeout >= 0)
        {
            INSTR_TIME_SET_CURRENT(cur_time);
            INSTR_TIME_SUBTRACT(cur_time, start_time);
            cur_timeout = timeout - (long) INSTR_TIME_GET_MILLISEC(cur_time);
            if (cur_timeout <= 0)
                break;
        }
    }
#ifndef WIN32
    waiting = false;
#endif

    pgstat_report_wait_end();

    return returned_events;
}

WaitEventSetWaitBlock()

static int WaitEventSetWaitBlock ( WaitEventSet *  set, int  cur_timeout, WaitEvent *  occurred_events, int  nevents  )

inlinestatic

Referenced by WaitEventSetWait().

WaitLatch()

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

Definition at line 452 of file latch.c.

References Assert, WaitEventSet::exit_on_postmaster_death, IsUnderPostmaster, LatchWaitSetLatchPos, ModifyWaitEvent(), WaitEventSetWait(), WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_POSTMASTER_DEATH, and WL_TIMEOUT.

Referenced by ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), ConditionVariableTimedSleep(), do_pg_stop_backup(), gather_readnext(), initialize_worker_spi(), lazy_truncate_heap(), logicalrep_worker_stop(), mq_putmessage(), pg_promote(), pg_sleep(), pg_wait_until_termination(), pgarch_MainLoop(), ProcSleep(), ProcWaitForSignal(), recoveryApplyDelay(), shm_mq_receive_bytes(), shm_mq_send_bytes(), shm_mq_wait_internal(), SyncRepWaitForLSN(), test_shm_mq_pipelined(), throttle(), vacuum_delay_point(), wait_for_relation_state_change(), wait_for_worker_state_change(), wait_for_workers_to_become_ready(), WaitForBackgroundWorkerShutdown(), WaitForBackgroundWorkerStartup(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WalRcvWaitForStartPosition(), and WalWriterMain().

{
    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);
    LatchWaitSet->exit_on_postmaster_death =
        ((wakeEvents & WL_EXIT_ON_PM_DEATH) != 0);

    if (WaitEventSetWait(LatchWaitSet,
                         (wakeEvents & WL_TIMEOUT) ? timeout : -1,
                         &event, 1,
                         wait_event_info) == 0)
        return WL_TIMEOUT;
    else
        return event.events;
}

WaitLatchOrSocket()

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

Definition at line 500 of file latch.c.

References AddWaitEventToSet(), Assert, CreateWaitEventSet(), CurrentMemoryContext, 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(), libpqrcv_connect(), libpqrcv_PQgetResult(), LogicalRepApplyLoop(), pgfdw_get_cleanup_result(), pgfdw_get_result(), read_or_wait(), secure_open_gssapi(), and WalReceiverMain().

{
    int         ret = 0;
    int         rc;
    WaitEvent   event;
    WaitEventSet *set = CreateWaitEventSet(CurrentMemoryContext, 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;
}

Variable Documentation

LatchWaitSet

WaitEventSet* LatchWaitSet

static

Definition at line 140 of file latch.c.

waiting

volatile sig_atomic_t waiting = false

static

Definition at line 147 of file latch.c.

Referenced by GetNumRegisteredWaitEvents(), run_permutation(), SetLatch(), try_complete_step(), and WaitEventSetWait().