latch.h File Reference

#include <signal.h>

Include dependency graph for latch.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Latch
struct	WaitEvent

Macros
#define	WL_LATCH_SET   (1 << 0)
#define	WL_SOCKET_READABLE   (1 << 1)
#define	WL_SOCKET_WRITEABLE   (1 << 2)
#define	WL_TIMEOUT   (1 << 3) /* not for WaitEventSetWait() */
#define	WL_POSTMASTER_DEATH   (1 << 4)
#define	WL_EXIT_ON_PM_DEATH   (1 << 5)
#define	WL_SOCKET_CONNECTED   WL_SOCKET_WRITEABLE
#define	WL_SOCKET_MASK

Typedefs
typedef struct Latch	Latch
typedef struct WaitEvent	WaitEvent
typedef struct WaitEventSet	WaitEventSet

Functions
void	InitializeLatchSupport (void)
void	InitLatch (Latch *latch)
void	InitSharedLatch (Latch *latch)
void	OwnLatch (Latch *latch)
void	DisownLatch (Latch *latch)
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	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	latch_sigusr1_handler (void)

Macro Definition Documentation

WL_EXIT_ON_PM_DEATH

#define WL_EXIT_ON_PM_DEATH   (1 << 5)

Definition at line 129 of file latch.h.

Referenced by AddWaitEventToSet(), ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), be_tls_open_server(), CheckpointerMain(), ConditionVariablePrepareToSleep(), copy_read_data(), gather_readnext(), initialize_worker_spi(), libpqrcv_connect(), libpqrcv_PQgetResult(), logicalrep_worker_stop(), LogicalRepApplyLoop(), mq_putmessage(), pg_sleep(), pgfdw_get_cleanup_result(), pgfdw_get_result(), ProcSleep(), ProcWaitForSignal(), read_or_wait(), recoveryApplyDelay(), secure_open_gssapi(), shm_mq_receive_bytes(), shm_mq_send_bytes(), shm_mq_wait_internal(), test_shm_mq_pipelined(), throttle(), wait_for_relation_state_change(), wait_for_worker_state_change(), wait_for_workers_to_become_ready(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WaitLatchOrSocket(), WalRcvWaitForStartPosition(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), WalSndWriteData(), and WalWriterMain().

WL_LATCH_SET

#define WL_LATCH_SET   (1 << 0)

Definition at line 124 of file latch.h.

Referenced by AddWaitEventToSet(), ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), ConditionVariablePrepareToSleep(), copy_read_data(), FreeWaitEventSet(), gather_readnext(), initialize_worker_spi(), libpqrcv_connect(), libpqrcv_PQgetResult(), logicalrep_worker_stop(), LogicalRepApplyLoop(), ModifyWaitEvent(), mq_putmessage(), pg_promote(), pg_sleep(), pgarch_MainLoop(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PgstatCollectorMain(), pq_init(), ProcSleep(), ProcWaitForSignal(), recoveryApplyDelay(), secure_read(), secure_write(), shm_mq_receive_bytes(), shm_mq_send_bytes(), shm_mq_wait_internal(), SwitchBackToLocalLatch(), SwitchToSharedLatch(), SyncRepWaitForLSN(), SysLoggerMain(), test_shm_mq_pipelined(), throttle(), wait_for_relation_state_change(), wait_for_worker_state_change(), wait_for_workers_to_become_ready(), WaitEventSetWait(), WaitForBackgroundWorkerShutdown(), WaitForBackgroundWorkerStartup(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WaitLatchOrSocket(), WalRcvWaitForStartPosition(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), WalSndWriteData(), and WalWriterMain().

WL_POSTMASTER_DEATH

#define WL_POSTMASTER_DEATH   (1 << 4)

Definition at line 128 of file latch.h.

Referenced by AddWaitEventToSet(), FreeWaitEventSet(), ModifyWaitEvent(), pg_promote(), pgarch_MainLoop(), PgstatCollectorMain(), pq_init(), secure_read(), secure_write(), SyncRepWaitForLSN(), WaitEventSetWait(), WaitForBackgroundWorkerShutdown(), WaitForBackgroundWorkerStartup(), and WaitLatchOrSocket().

WL_SOCKET_CONNECTED

#define WL_SOCKET_CONNECTED   WL_SOCKET_WRITEABLE

Definition at line 134 of file latch.h.

Referenced by libpqrcv_connect(), ModifyWaitEvent(), and WaitEventSetWait().

WL_SOCKET_MASK

#define WL_SOCKET_MASK

Value:

(WL_SOCKET_READABLE | \
                             WL_SOCKET_WRITEABLE | \
                             WL_SOCKET_CONNECTED)

Definition at line 137 of file latch.h.

Referenced by AddWaitEventToSet(), WaitEventSetWait(), and WaitLatchOrSocket().

WL_SOCKET_READABLE

#define WL_SOCKET_READABLE   (1 << 1)

Definition at line 125 of file latch.h.

Referenced by be_tls_open_server(), be_tls_read(), be_tls_write(), copy_read_data(), libpqrcv_connect(), libpqrcv_PQgetResult(), LogicalRepApplyLoop(), ModifyWaitEvent(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PgstatCollectorMain(), read_or_wait(), secure_read(), SysLoggerMain(), WaitEventSetWait(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), and WalSndWriteData().

WL_SOCKET_WRITEABLE

#define WL_SOCKET_WRITEABLE   (1 << 2)

Definition at line 126 of file latch.h.

Referenced by be_tls_open_server(), be_tls_read(), be_tls_write(), libpqrcv_connect(), ModifyWaitEvent(), pq_init(), secure_open_gssapi(), secure_write(), WaitEventSetWait(), WalSndLoop(), WalSndWaitForWal(), and WalSndWriteData().

WL_TIMEOUT

#define WL_TIMEOUT   (1 << 3) /* not for WaitEventSetWait() */

Definition at line 127 of file latch.h.

Referenced by ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), copy_read_data(), initialize_worker_spi(), logicalrep_worker_stop(), LogicalRepApplyLoop(), pg_promote(), pg_sleep(), pgarch_MainLoop(), pgfdw_get_cleanup_result(), PgstatCollectorMain(), recoveryApplyDelay(), throttle(), wait_for_relation_state_change(), wait_for_worker_state_change(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WaitLatchOrSocket(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), WalSndWriteData(), and WalWriterMain().

Typedef Documentation

Latch

typedef struct Latch Latch

WaitEvent

typedef struct WaitEvent WaitEvent

WaitEventSet

typedef struct WaitEventSet WaitEventSet

Definition at line 153 of file latch.h.

Function Documentation

AddWaitEventToSet()

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

Definition at line 690 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, selfpipe_readfd, WaitEvent::user_data, WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, WL_POSTMASTER_DEATH, and WL_SOCKET_MASK.

Referenced by ConditionVariablePrepareToSleep(), 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;
#ifndef WIN32
        event->fd = selfpipe_readfd;
#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_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 542 of file latch.c.

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

Referenced by ConditionVariablePrepareToSleep(), 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_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_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)
#ifdef EPOLL_CLOEXEC
    set->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
    if (set->epoll_fd < 0)
        elog(ERROR, "epoll_create1 failed: %m");
#else
    /* cope with ancient glibc lacking epoll_create1 (e.g., RHEL5) */
    set->epoll_fd = epoll_create(nevents);
    if (set->epoll_fd < 0)
        elog(ERROR, "epoll_create failed: %m");
    if (fcntl(set->epoll_fd, F_SETFD, FD_CLOEXEC) == -1)
        elog(ERROR, "fcntl(F_SETFD) failed on epoll descriptor: %m");
#endif                          /* EPOLL_CLOEXEC */
#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 316 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 630 of file latch.c.

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

Referenced by WaitLatchOrSocket().

{
#if defined(WAIT_USE_EPOLL)
    close(set->epoll_fd);
#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);
}

InitializeLatchSupport()

void InitializeLatchSupport

(

void

)

Definition at line 155 of file latch.c.

References Assert, close, elog, FATAL, IsUnderPostmaster, MyProcPid, selfpipe_owner_pid, selfpipe_readfd, and selfpipe_writefd.

Referenced by InitPostmasterChild(), and InitStandaloneProcess().

{
#ifndef WIN32
    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;
        }
        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.
             */
            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;
#else
    /* currently, nothing to do here for Windows */
#endif
}

InitLatch()

void InitLatch

(

Latch *

latch

)

Definition at line 228 of file latch.c.

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

Referenced by InitPostmasterChild(), and InitStandaloneProcess().

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

#ifndef WIN32
    /* Assert InitializeLatchSupport has been called in this process */
    Assert(selfpipe_readfd >= 0 && selfpipe_owner_pid == MyProcPid);
#else
    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 260 of file latch.c.

References elog, ERROR, Latch::is_set, Latch::is_shared, 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->owner_pid = 0;
    latch->is_shared = true;
}

latch_sigusr1_handler()

void latch_sigusr1_handler

(

void

)

Definition at line 1515 of file latch.c.

References sendSelfPipeByte(), and waiting.

Referenced by bgworker_sigusr1_handler(), and procsignal_sigusr1_handler().

{
    if (waiting)
        sendSelfPipeByte();
}

ModifyWaitEvent()

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

Definition at line 766 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, WaitEventSet::nevents, PGINVALID_SOCKET, WL_LATCH_SET, WL_POSTMASTER_DEATH, WL_SOCKET_CONNECTED, WL_SOCKET_READABLE, and WL_SOCKET_WRITEABLE.

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

{
    WaitEvent  *event;

    Assert(pos < set->nevents);

    event = &set->events[pos];

    /*
     * 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)
    {
        /* we could allow to disable latch events for a while */
        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)
    {
        set->latch = latch;
    }

#if defined(WAIT_USE_EPOLL)
    WaitEventAdjustEpoll(set, event, EPOLL_CTL_MOD);
#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 296 of file latch.c.

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

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

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

#ifndef WIN32
    /* 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 519 of file latch.c.

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

Referenced by ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), ConditionVariablePrepareToSleep(), ConditionVariableTimedSleep(), copy_read_data(), gather_readnext(), initialize_worker_spi(), libpqrcv_connect(), libpqrcv_PQgetResult(), logicalrep_worker_stop(), LogicalRepApplyLoop(), mq_putmessage(), pg_promote(), pg_sleep(), 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(), 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);

    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 436 of file latch.c.

References Latch::is_set, kill, MyProcPid, Latch::owner_pid, pg_memory_barrier, sendSelfPipeByte(), SIGUSR1, and waiting.

Referenced by apw_sighup_handler(), apw_sigterm_handler(), ArchSigHupHandler(), ArchSigTermHandler(), av_sighup_handler(), avl_sigterm_handler(), avl_sigusr2_handler(), BgSigHupHandler(), CheckDeadLockAlert(), ChkptSigHupHandler(), ConditionVariableBroadcast(), ConditionVariableSignal(), die(), ForwardSyncRequest(), handle_sig_alarm(), handle_sigterm(), HandleCatchupInterrupt(), HandleNotifyInterrupt(), HandleParallelMessageInterrupt(), IdleInTransactionSessionTimeoutHandler(), logicalrep_launcher_sighup(), logicalrep_worker_sighup(), logicalrep_worker_wakeup_ptr(), pgarch_waken(), pgarch_waken_stop(), pgstat_exit(), pgstat_sighup_handler(), PostgresSigHupHandler(), ProcessClientReadInterrupt(), ProcessClientWriteInterrupt(), ProcSendSignal(), procsignal_sigusr1_handler(), ProcWakeup(), RecoveryConflictInterrupt(), ReqCheckpointHandler(), ReqShutdownHandler(), 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(), sigHupHandler(), sigUsr1Handler(), StatementCancelHandler(), StrategyGetBuffer(), SwitchBackToLocalLatch(), SwitchToSharedLatch(), SyncRepWakeQueue(), test_shm_mq_main(), WakeupRecovery(), WalRcvForceReply(), WalRcvShutdownHandler(), WalShutdownHandler(), WalSigHupHandler(), WalSndLastCycleHandler(), WalSndWaitForWal(), WalSndWakeup(), WalSndWriteData(), worker_spi_sighup(), worker_spi_sigterm(), 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;

#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 to wake up the
     * poll()/epoll_wait() 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 (waiting)
            sendSelfPipeByte();
    }
    else
        kill(owner_pid, SIGUSR1);
#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

}

WaitEventSetWait()

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

Definition at line 953 of file latch.c.

References Assert, buf, drainSelfPipe(), 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, PGINVALID_SOCKET, pgstat_report_wait_end(), pgstat_report_wait_start(), pgwin32_dispatch_queued_signals(), WaitEvent::pos, PostmasterIsAliveInternal(), proc_exit(), start_time, 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 ConditionVariableTimedSleep(), secure_read(), secure_write(), SysLoggerMain(), and WaitLatchOrSocket().

{
    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_sigusr1_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)
        {
            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++;

            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 (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;
}

WaitLatch()

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

Definition at line 344 of file latch.c.

References PGINVALID_SOCKET, and WaitLatchOrSocket().

Referenced by ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), gather_readnext(), initialize_worker_spi(), logicalrep_worker_stop(), mq_putmessage(), pg_promote(), pg_sleep(), pgarch_MainLoop(), ProcSleep(), ProcWaitForSignal(), recoveryApplyDelay(), shm_mq_receive_bytes(), shm_mq_send_bytes(), shm_mq_wait_internal(), SyncRepWaitForLSN(), test_shm_mq_pipelined(), throttle(), 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().

{
    return WaitLatchOrSocket(latch, wakeEvents, PGINVALID_SOCKET, timeout,
                             wait_event_info);
}

WaitLatchOrSocket()

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

Definition at line 369 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(), PgstatCollectorMain(), read_or_wait(), secure_open_gssapi(), WaitLatch(), WalReceiverMain(), WalSndLoop(), WalSndWaitForWal(), and WalSndWriteData().

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