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

Include dependency graph for latch.c:

Data Structures
struct	WaitEventSet

Functions
static void	sendSelfPipeByte (void)

static void	drainSelfPipe (void)

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

void	InitializeLatchSupport (void)

void	InitLatch (volatile Latch *latch)

void	InitSharedLatch (volatile Latch *latch)

void	OwnLatch (volatile Latch *latch)

void	DisownLatch (volatile Latch *latch)

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

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

void	SetLatch (volatile Latch *latch)

void	ResetLatch (volatile 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)

void	latch_sigusr1_handler (void)

Variables
static volatile sig_atomic_t	waiting = false

static int	selfpipe_readfd = -1

static int	selfpipe_writefd = -1

static int	selfpipe_owner_pid = 0

Function Documentation

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

Definition at line 666 of file latch.c.

References Assert, elog, ERROR, WaitEventSet::events, fd(), WaitEventSet::latch, WaitEventSet::latch_pos, MyProcPid, WaitEventSet::nevents, WaitEventSet::nevents_space, Latch::owner_pid, PGINVALID_SOCKET, WaitEvent::pos, postmaster_alive_fds, POSTMASTER_FD_WATCH, selfpipe_readfd, WL_LATCH_SET, WL_POSTMASTER_DEATH, and WL_SOCKET_MASK.

Referenced by ConditionVariablePrepareToSleep(), pq_init(), and WaitLatchOrSocket().

 {
     WaitEvent  *event;
 
     /* not enough space */
     Assert(set->nevents < set->nevents_space);
 
     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;
 }

WaitEventSet* CreateWaitEventSet	(	MemoryContext	context,
		int	nevents
	)

Definition at line 520 of file latch.c.

References elog, ERROR, WaitEventSet::events, WaitEventSet::latch, MAXALIGN, MemoryContextAllocZero(), WaitEventSet::nevents_space, NULL, pgwin32_signal_event, and StaticAssertStmt.

Referenced by ConditionVariablePrepareToSleep(), pq_init(), 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;
 
 #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;
 }

void DisownLatch ( volatile Latch * latch )

Definition at line 308 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;
 }

static void drainSelfPipe ( void )

static

Definition at line 1522 of file latch.c.

References EAGAIN, EINTR, elog, ERROR, EWOULDBLOCK, read, selfpipe_readfd, and waiting.

 {
     /*
      * There shouldn't normally be more than one byte in the pipe, or maybe a
      * few bytes if multiple processes run SetLatch at the same instant.
      */
     char        buf[16];
     int         rc;
 
     for (;;)
     {
         rc = read(selfpipe_readfd, buf, sizeof(buf));
         if (rc < 0)
         {
             if (errno == EAGAIN || errno == EWOULDBLOCK)
                 break;          /* the pipe is empty */
             else if (errno == EINTR)
                 continue;       /* retry */
             else
             {
                 waiting = false;
                 elog(ERROR, "read() on self-pipe failed: %m");
             }
         }
         else if (rc == 0)
         {
             waiting = false;
             elog(ERROR, "unexpected EOF on self-pipe");
         }
         else if (rc < sizeof(buf))
         {
             /* we successfully drained the pipe; no need to read() again */
             break;
         }
         /* else buffer wasn't big enough, so read again */
     }
 }

void FreeWaitEventSet ( WaitEventSet * set )

Definition at line 607 of file latch.c.

References close, WaitEventSet::events, WaitEvent::events, WaitEvent::fd, WaitEventSet::nevents, NULL, 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);
 }

void InitializeLatchSupport ( void )

Definition at line 147 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
 }

void InitLatch ( volatile Latch * latch )

Definition at line 220 of file latch.c.

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

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 */
 }

void InitSharedLatch ( volatile Latch * latch )

Definition at line 252 of file latch.c.

References elog, ERROR, FALSE, Latch::is_set, Latch::is_shared, NULL, Latch::owner_pid, and TRUE.

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

void latch_sigusr1_handler ( void )

Definition at line 1473 of file latch.c.

References sendSelfPipeByte(), and waiting.

Referenced by bgworker_sigusr1_handler(), bgwriter_sigusr1_handler(), chkpt_sigusr1_handler(), procsignal_sigusr1_handler(), StartupProcSigUsr1Handler(), WalRcvSigUsr1Handler(), and walwriter_sigusr1_handler().

 {
     if (waiting)
         sendSelfPipeByte();
 }

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

Definition at line 736 of file latch.c.

References Assert, elog, ERROR, WaitEventSet::events, WaitEvent::events, WaitEventSet::latch, WL_LATCH_SET, and WL_POSTMASTER_DEATH.

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
 }

void OwnLatch ( volatile Latch * latch )

Definition at line 288 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;
 }

void ResetLatch ( volatile Latch * latch )

Definition at line 497 of file latch.c.

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

Referenced by ApplyLauncherMain(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), ConditionVariablePrepareToSleep(), ConditionVariableSleep(), copy_read_data(), gather_readnext(), libpqrcv_connect(), libpqrcv_PQexec(), logicalrep_worker_stop(), LogicalRepApplyLoop(), mq_putmessage(), 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(), 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();
 }

static void sendSelfPipeByte ( void )

static

Definition at line 1483 of file latch.c.

References EAGAIN, EINTR, EWOULDBLOCK, selfpipe_writefd, and write.

Referenced by latch_sigusr1_handler(), and SetLatch().

 {
     int         rc;
     char        dummy = 0;
 
 retry:
     rc = write(selfpipe_writefd, &dummy, 1);
     if (rc < 0)
     {
         /* If interrupted by signal, just retry */
         if (errno == EINTR)
             goto retry;
 
         /*
          * If the pipe is full, we don't need to retry, the data that's there
          * already is enough to wake up WaitLatch.
          */
         if (errno == EAGAIN || errno == EWOULDBLOCK)
             return;
 
         /*
          * Oops, the write() failed for some other reason. We might be in a
          * signal handler, so it's not safe to elog(). We have no choice but
          * silently ignore the error.
          */
         return;
     }
 }

void SetLatch ( volatile Latch * latch )

Definition at line 414 of file latch.c.

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

Referenced by ArchSigHupHandler(), ArchSigTermHandler(), av_sighup_handler(), avl_sigterm_handler(), avl_sigusr2_handler(), BgSigHupHandler(), CheckDeadLockAlert(), ChkptSigHupHandler(), ConditionVariableSignal(), die(), ForwardFsyncRequest(), 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(), ProcSendSignal(), procsignal_sigusr1_handler(), ProcWakeup(), RecoveryConflictInterrupt(), ReqCheckpointHandler(), ReqShutdownHandler(), RequestXLogStreaming(), shm_mq_detach(), shm_mq_inc_bytes_read(), shm_mq_notify_receiver(), 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(), 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
 
 }

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

Definition at line 921 of file latch.c.

References Assert, WaitEventSet::events, WaitEvent::events, WaitEvent::fd, INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, Latch::is_set, WaitEventSet::latch, WaitEventSet::latch_pos, PGINVALID_SOCKET, pgstat_report_wait_end(), pgstat_report_wait_start(), pgwin32_dispatch_queued_signals(), WaitEvent::pos, start_time, WaitEvent::user_data, WaitEventSetWaitBlock(), waiting, and WL_LATCH_SET.

Referenced by ConditionVariableSleep(), secure_read(), secure_write(), 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;
 }

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

inlinestatic

Referenced by WaitEventSetWait().

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

Definition at line 336 of file latch.c.

References PGINVALID_SOCKET, and WaitLatchOrSocket().

Referenced by ApplyLauncherMain(), AutoVacLauncherMain(), BackgroundWriterMain(), CheckpointerMain(), gather_readnext(), logicalrep_worker_stop(), mq_putmessage(), pg_sleep(), pgarch_MainLoop(), ProcSleep(), ProcWaitForSignal(), recoveryApplyDelay(), 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(), WaitForParallelWorkersToFinish(), WaitForReplicationWorkerAttach(), WaitForWALToBecomeAvailable(), WalRcvWaitForStartPosition(), and WalWriterMain().

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

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

Definition at line 356 of file latch.c.

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

Referenced by be_tls_open_server(), copy_read_data(), libpqrcv_connect(), libpqrcv_PQexec(), LogicalRepApplyLoop(), pgfdw_get_cleanup_result(), pgfdw_get_result(), PgstatCollectorMain(), SysLoggerMain(), 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 *) latch, NULL);
 
     if (wakeEvents & WL_POSTMASTER_DEATH && IsUnderPostmaster)
         AddWaitEventToSet(set, WL_POSTMASTER_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;
 }