#include <signal.h>

Include dependency graph for latch.h:

This graph shows which files directly or indirectly include 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)

void	ShutdownLatchSupport (void)

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	InitializeLatchWaitSet (void)

int	GetNumRegisteredWaitEvents (WaitEventSet *set)

Macro Definition Documentation

◆ WL_EXIT_ON_PM_DEATH

#define WL_EXIT_ON_PM_DEATH (1 << 5)

Definition at line 130 of file latch.h.

Referenced by AddWaitEventToSet(), ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), be_tls_open_server(), CheckpointerMain(), ConditionVariableTimedSleep(), copy_read_data(), do_pg_stop_backup(), ExecAppendAsyncEventWait(), gather_readnext(), initialize_worker_spi(), InitializeLatchWaitSet(), lazy_truncate_heap(), libpqrcv_connect(), libpqrcv_PQgetResult(), logicalrep_worker_stop(), LogicalRepApplyLoop(), mq_putmessage(), pg_sleep(), pg_wait_until_termination(), 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(), vacuum_delay_point(), wait_for_relation_state_change(), wait_for_worker_state_change(), wait_for_workers_to_become_ready(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WaitLatch(), WaitLatchOrSocket(), WalRcvWaitForStartPosition(), WalReceiverMain(), and WalWriterMain().

◆ WL_LATCH_SET

#define WL_LATCH_SET (1 << 0)

Definition at line 125 of file latch.h.

Referenced by AddWaitEventToSet(), ApplyLauncherMain(), autoprewarm_main(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), ConditionVariableTimedSleep(), copy_read_data(), do_pg_stop_backup(), FreeWaitEventSet(), gather_readnext(), initialize_worker_spi(), InitializeLatchWaitSet(), lazy_truncate_heap(), libpqrcv_connect(), libpqrcv_PQgetResult(), logicalrep_worker_stop(), LogicalRepApplyLoop(), ModifyWaitEvent(), mq_putmessage(), pg_promote(), pg_sleep(), pg_wait_until_termination(), 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(), vacuum_delay_point(), wait_for_relation_state_change(), wait_for_worker_state_change(), wait_for_workers_to_become_ready(), WaitEventSetWait(), WaitForBackgroundWorkerShutdown(), WaitForBackgroundWorkerStartup(), WaitForParallelWorkersToAttach(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WaitLatch(), WaitLatchOrSocket(), WalRcvWaitForStartPosition(), WalReceiverMain(), and WalWriterMain().

◆ WL_POSTMASTER_DEATH

#define WL_POSTMASTER_DEATH (1 << 4)

Definition at line 129 of file latch.h.

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

◆ WL_SOCKET_CONNECTED

#define WL_SOCKET_CONNECTED WL_SOCKET_WRITEABLE

Definition at line 135 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 138 of file latch.h.

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

◆ WL_SOCKET_READABLE

#define WL_SOCKET_READABLE (1 << 1)

◆ WL_SOCKET_WRITEABLE

#define WL_SOCKET_WRITEABLE (1 << 2)

Definition at line 127 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

Typedef Documentation

◆ Latch

typedef struct Latch Latch

◆ WaitEvent

typedef struct WaitEvent WaitEvent

◆ WaitEventSet

typedef struct WaitEventSet WaitEventSet

Definition at line 154 of file latch.h.

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

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

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ WL_EXIT_ON_PM_DEATH

◆ WL_LATCH_SET

◆ WL_POSTMASTER_DEATH

◆ WL_SOCKET_CONNECTED

◆ WL_SOCKET_MASK

◆ WL_SOCKET_READABLE

◆ WL_SOCKET_WRITEABLE

◆ WL_TIMEOUT

Typedef Documentation

◆ Latch

◆ WaitEvent

◆ WaitEventSet

Function Documentation

◆ AddWaitEventToSet()

◆ CreateWaitEventSet()

◆ DisownLatch()

◆ FreeWaitEventSet()

◆ GetNumRegisteredWaitEvents()

◆ InitializeLatchSupport()

◆ InitializeLatchWaitSet()

◆ InitLatch()

◆ InitSharedLatch()

◆ ModifyWaitEvent()

◆ OwnLatch()

◆ ResetLatch()

◆ SetLatch()

◆ ShutdownLatchSupport()

◆ WaitEventSetWait()

◆ WaitLatch()

◆ WaitLatchOrSocket()