54#ifdef HAVE_SYS_EPOLL_H
57#ifdef HAVE_SYS_EVENT_H
60#ifdef HAVE_SYS_SIGNALFD_H
61#include <sys/signalfd.h>
87#if defined(WAIT_USE_EPOLL) || defined(WAIT_USE_POLL) || \
88 defined(WAIT_USE_KQUEUE) || defined(WAIT_USE_WIN32)
90#elif defined(HAVE_SYS_EPOLL_H)
92#elif defined(HAVE_KQUEUE)
93#define WAIT_USE_KQUEUE
94#elif defined(HAVE_POLL)
99#error "no wait set implementation available"
106#if defined(WAIT_USE_POLL) || defined(WAIT_USE_EPOLL)
107#if defined(WAIT_USE_SELF_PIPE) || defined(WAIT_USE_SIGNALFD)
109#elif defined(WAIT_USE_EPOLL) && defined(HAVE_SYS_SIGNALFD_H)
110#define WAIT_USE_SIGNALFD
112#define WAIT_USE_SELF_PIPE
146#if defined(WAIT_USE_EPOLL)
149 struct epoll_event *epoll_ret_events;
150#elif defined(WAIT_USE_KQUEUE)
153 struct kevent *kqueue_ret_events;
154 bool report_postmaster_not_running;
155#elif defined(WAIT_USE_POLL)
158#elif defined(WAIT_USE_WIN32)
174#ifdef WAIT_USE_SIGNALFD
176static int signal_fd = -1;
179#ifdef WAIT_USE_SELF_PIPE
192#if defined(WAIT_USE_SELF_PIPE) || defined(WAIT_USE_SIGNALFD)
193static void drain(
void);
196#if defined(WAIT_USE_EPOLL)
198#elif defined(WAIT_USE_KQUEUE)
200#elif defined(WAIT_USE_POLL)
202#elif defined(WAIT_USE_WIN32)
207 WaitEvent *occurred_events,
int nevents);
214 .
name =
"WaitEventSet",
243#if defined(WAIT_USE_SELF_PIPE)
295 if (pipe(pipefd) < 0)
297 if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) == -1)
298 elog(
FATAL,
"fcntl(F_SETFL) failed on read-end of self-pipe: %m");
299 if (fcntl(pipefd[1], F_SETFL, O_NONBLOCK) == -1)
300 elog(
FATAL,
"fcntl(F_SETFL) failed on write-end of self-pipe: %m");
301 if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) == -1)
302 elog(
FATAL,
"fcntl(F_SETFD) failed on read-end of self-pipe: %m");
303 if (fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) == -1)
304 elog(
FATAL,
"fcntl(F_SETFD) failed on write-end of self-pipe: %m");
317#ifdef WAIT_USE_SIGNALFD
318 sigset_t signalfd_mask;
330 (void)
close(signal_fd);
340 sigemptyset(&signalfd_mask);
341 sigaddset(&signalfd_mask, SIGURG);
342 signal_fd = signalfd(-1, &signalfd_mask, SFD_NONBLOCK | SFD_CLOEXEC);
348#ifdef WAIT_USE_KQUEUE
379#if defined(WAIT_USE_EPOLL)
380 sz +=
MAXALIGN(
sizeof(
struct epoll_event) * nevents);
381#elif defined(WAIT_USE_KQUEUE)
382 sz +=
MAXALIGN(
sizeof(
struct kevent) * nevents);
383#elif defined(WAIT_USE_POLL)
384 sz +=
MAXALIGN(
sizeof(
struct pollfd) * nevents);
385#elif defined(WAIT_USE_WIN32)
387 sz +=
MAXALIGN(
sizeof(HANDLE) * (nevents + 1));
390 if (resowner != NULL)
401#if defined(WAIT_USE_EPOLL)
402 set->epoll_ret_events = (
struct epoll_event *)
data;
404#elif defined(WAIT_USE_KQUEUE)
405 set->kqueue_ret_events = (
struct kevent *)
data;
407#elif defined(WAIT_USE_POLL)
410#elif defined(WAIT_USE_WIN32)
411 set->handles = (HANDLE)
data;
419 if (resowner != NULL)
422 set->
owner = resowner;
425#if defined(WAIT_USE_EPOLL)
427 elog(
ERROR,
"AcquireExternalFD, for epoll_create1, failed: %m");
428 set->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
429 if (set->epoll_fd < 0)
434#elif defined(WAIT_USE_KQUEUE)
436 elog(
ERROR,
"AcquireExternalFD, for kqueue, failed: %m");
437 set->kqueue_fd = kqueue();
438 if (set->kqueue_fd < 0)
443 if (fcntl(set->kqueue_fd, F_SETFD, FD_CLOEXEC) == -1)
445 int save_errno = errno;
447 close(set->kqueue_fd);
450 elog(
ERROR,
"fcntl(F_SETFD) failed on kqueue descriptor: %m");
452 set->report_postmaster_not_running =
false;
453#elif defined(WAIT_USE_WIN32)
489#if defined(WAIT_USE_EPOLL)
490 close(set->epoll_fd);
492#elif defined(WAIT_USE_KQUEUE)
493 close(set->kqueue_fd);
495#elif defined(WAIT_USE_WIN32)
511 WSAEventSelect(cur_event->fd, NULL, 0);
512 WSACloseEvent(set->handles[cur_event->pos + 1]);
526#if defined(WAIT_USE_EPOLL)
527 close(set->epoll_fd);
529#elif defined(WAIT_USE_KQUEUE)
587 elog(
ERROR,
"cannot wait on a latch owned by another process");
589 elog(
ERROR,
"cannot wait on more than one latch");
591 elog(
ERROR,
"latch events only support being set");
596 elog(
ERROR,
"cannot wait on latch without a specified latch");
601 elog(
ERROR,
"cannot wait on socket event without a socket");
606 event->events = events;
607 event->user_data = user_data;
609 event->reset =
false;
616#if defined(WAIT_USE_SELF_PIPE)
618#elif defined(WAIT_USE_SIGNALFD)
619 event->fd = signal_fd;
635#if defined(WAIT_USE_EPOLL)
636 WaitEventAdjustEpoll(set, event, EPOLL_CTL_ADD);
637#elif defined(WAIT_USE_KQUEUE)
638 WaitEventAdjustKqueue(set, event, 0);
639#elif defined(WAIT_USE_POLL)
641#elif defined(WAIT_USE_WIN32)
642 WaitEventAdjustWin32(set, event);
659#if defined(WAIT_USE_KQUEUE)
663 Assert(pos < set->nevents);
665 event = &set->
events[pos];
666#if defined(WAIT_USE_KQUEUE)
667 old_events =
event->
events;
680 elog(
ERROR,
"cannot remove postmaster death event");
691 if (events == event->
events &&
696 elog(
ERROR,
"cannot modify latch event");
699 event->events = events;
704 elog(
ERROR,
"cannot wait on a latch owned by another process");
714#if defined(WAIT_USE_WIN32)
722#if defined(WAIT_USE_EPOLL)
723 WaitEventAdjustEpoll(set, event, EPOLL_CTL_MOD);
724#elif defined(WAIT_USE_KQUEUE)
725 WaitEventAdjustKqueue(set, event, old_events);
726#elif defined(WAIT_USE_POLL)
728#elif defined(WAIT_USE_WIN32)
729 WaitEventAdjustWin32(set, event);
733#if defined(WAIT_USE_EPOLL)
740 struct epoll_event epoll_ev;
744 epoll_ev.data.ptr = event;
746 epoll_ev.
events = EPOLLERR | EPOLLHUP;
752 epoll_ev.events |= EPOLLIN;
756 epoll_ev.events |= EPOLLIN;
766 epoll_ev.events |= EPOLLIN;
768 epoll_ev.events |= EPOLLOUT;
770 epoll_ev.events |= EPOLLRDHUP;
778 rc = epoll_ctl(set->epoll_fd,
action, event->
fd, &epoll_ev);
788#if defined(WAIT_USE_POLL)
792 struct pollfd *pollfd = &set->
pollfds[
event->pos];
795 pollfd->fd =
event->fd;
801 pollfd->events = POLLIN;
805 pollfd->events = POLLIN;
814 pollfd->events |= POLLIN;
816 pollfd->events |= POLLOUT;
819 pollfd->events |= POLLRDHUP;
827#if defined(WAIT_USE_KQUEUE)
835#define AccessWaitEvent(k_ev) (*((WaitEvent **)(&(k_ev)->udata)))
838WaitEventAdjustKqueueAdd(
struct kevent *k_ev,
int filter,
int action,
841 k_ev->ident =
event->fd;
842 k_ev->filter = filter;
846 AccessWaitEvent(k_ev) = event;
850WaitEventAdjustKqueueAddPostmaster(
struct kevent *k_ev,
WaitEvent *event)
854 k_ev->filter = EVFILT_PROC;
855 k_ev->flags = EV_ADD;
856 k_ev->fflags = NOTE_EXIT;
858 AccessWaitEvent(k_ev) = event;
862WaitEventAdjustKqueueAddLatch(
struct kevent *k_ev,
WaitEvent *event)
865 k_ev->ident = SIGURG;
866 k_ev->filter = EVFILT_SIGNAL;
867 k_ev->flags = EV_ADD;
870 AccessWaitEvent(k_ev) = event;
880 struct kevent k_ev[2];
882 bool new_filt_read =
false;
883 bool old_filt_read =
false;
884 bool new_filt_write =
false;
885 bool old_filt_write =
false;
887 if (old_events == event->
events)
904 WaitEventAdjustKqueueAddPostmaster(&k_ev[count++], event);
909 WaitEventAdjustKqueueAddLatch(&k_ev[count++], event);
919 old_filt_read =
true;
921 new_filt_read =
true;
923 old_filt_write =
true;
925 new_filt_write =
true;
926 if (old_filt_read && !new_filt_read)
927 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_READ, EV_DELETE,
929 else if (!old_filt_read && new_filt_read)
930 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_READ, EV_ADD,
932 if (old_filt_write && !new_filt_write)
933 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_WRITE, EV_DELETE,
935 else if (!old_filt_write && new_filt_write)
936 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_WRITE, EV_ADD,
946 rc = kevent(set->kqueue_fd, &k_ev[0], count, NULL, 0, NULL);
958 (errno == ESRCH || errno == EACCES))
959 set->report_postmaster_not_running =
true;
975 set->report_postmaster_not_running =
true;
981#if defined(WAIT_USE_WIN32)
985 HANDLE *handle = &set->handles[
event->pos + 1];
990 *handle = set->
latch->event;
994 *handle = PostmasterHandle;
998 int flags = FD_CLOSE;
1005 flags |= FD_CONNECT;
1009 if (*handle == WSA_INVALID_EVENT)
1011 *handle = WSACreateEvent();
1012 if (*handle == WSA_INVALID_EVENT)
1013 elog(
ERROR,
"failed to create event for socket: error code %d",
1016 if (WSAEventSelect(event->
fd, *handle, flags) != 0)
1017 elog(
ERROR,
"failed to set up event for socket: error code %d",
1039 WaitEvent *occurred_events,
int nevents,
1042 int returned_events = 0;
1045 long cur_timeout = -1;
1056 Assert(timeout >= 0 && timeout <= INT_MAX);
1057 cur_timeout = timeout;
1070 while (returned_events == 0)
1122 if (returned_events == nevents)
1140 occurred_events, nevents - returned_events);
1149 returned_events += rc;
1152 if (returned_events == 0 && timeout >= 0)
1157 if (cur_timeout <= 0)
1167 return returned_events;
1171#if defined(WAIT_USE_EPOLL)
1183 WaitEvent *occurred_events,
int nevents)
1185 int returned_events = 0;
1188 struct epoll_event *cur_epoll_event;
1191 rc = epoll_wait(set->epoll_fd, set->epoll_ret_events,
1203 errmsg(
"%s() failed: %m",
1219 for (cur_epoll_event = set->epoll_ret_events;
1220 cur_epoll_event < (set->epoll_ret_events + rc) &&
1221 returned_events < nevents;
1225 cur_event = (
WaitEvent *) cur_epoll_event->data.ptr;
1227 occurred_events->
pos = cur_event->
pos;
1229 occurred_events->
events = 0;
1232 cur_epoll_event->events & (EPOLLIN | EPOLLERR | EPOLLHUP))
1246 cur_epoll_event->events & (EPOLLIN | EPOLLERR | EPOLLHUP))
1276 (cur_epoll_event->events & (EPOLLIN | EPOLLERR | EPOLLHUP)))
1283 (cur_epoll_event->events & (EPOLLOUT | EPOLLERR | EPOLLHUP)))
1290 (cur_epoll_event->events & (EPOLLRDHUP | EPOLLERR | EPOLLHUP)))
1296 if (occurred_events->
events != 0)
1298 occurred_events->
fd = cur_event->
fd;
1305 return returned_events;
1308#elif defined(WAIT_USE_KQUEUE)
1319 WaitEvent *occurred_events,
int nevents)
1321 int returned_events = 0;
1324 struct kevent *cur_kqueue_event;
1325 struct timespec timeout;
1326 struct timespec *timeout_p;
1328 if (cur_timeout < 0)
1332 timeout.tv_sec = cur_timeout / 1000;
1333 timeout.tv_nsec = (cur_timeout % 1000) * 1000000;
1334 timeout_p = &timeout;
1341 if (
unlikely(set->report_postmaster_not_running))
1351 rc = kevent(set->kqueue_fd, NULL, 0,
1352 set->kqueue_ret_events,
1365 errmsg(
"%s() failed: %m",
1381 for (cur_kqueue_event = set->kqueue_ret_events;
1382 cur_kqueue_event < (set->kqueue_ret_events + rc) &&
1383 returned_events < nevents;
1387 cur_event = AccessWaitEvent(cur_kqueue_event);
1389 occurred_events->
pos = cur_event->
pos;
1391 occurred_events->
events = 0;
1394 cur_kqueue_event->filter == EVFILT_SIGNAL)
1405 cur_kqueue_event->filter == EVFILT_PROC &&
1406 (cur_kqueue_event->fflags & NOTE_EXIT) != 0)
1413 set->report_postmaster_not_running =
true;
1429 (cur_kqueue_event->filter == EVFILT_READ))
1436 (cur_kqueue_event->filter == EVFILT_READ) &&
1437 (cur_kqueue_event->flags & EV_EOF))
1444 (cur_kqueue_event->filter == EVFILT_WRITE))
1450 if (occurred_events->
events != 0)
1452 occurred_events->
fd = cur_event->
fd;
1459 return returned_events;
1462#elif defined(WAIT_USE_POLL)
1472 WaitEvent *occurred_events,
int nevents)
1474 int returned_events = 0;
1477 struct pollfd *cur_pollfd;
1491 errmsg(
"%s() failed: %m",
1504 returned_events < nevents;
1505 cur_event++, cur_pollfd++)
1508 if (cur_pollfd->revents == 0)
1511 occurred_events->
pos = cur_event->
pos;
1513 occurred_events->
events = 0;
1516 (cur_pollfd->revents & (POLLIN | POLLHUP | POLLERR | POLLNVAL)))
1530 (cur_pollfd->revents & (POLLIN | POLLHUP | POLLERR | POLLNVAL)))
1557 int errflags = POLLHUP | POLLERR | POLLNVAL;
1562 (cur_pollfd->revents & (POLLIN | errflags)))
1569 (cur_pollfd->revents & (POLLOUT | errflags)))
1577 (cur_pollfd->revents & (POLLRDHUP | errflags)))
1584 if (occurred_events->
events != 0)
1586 occurred_events->
fd = cur_event->
fd;
1592 return returned_events;
1595#elif defined(WAIT_USE_WIN32)
1606 WaitEvent *occurred_events,
int nevents)
1608 int returned_events = 0;
1613 for (cur_event = set->
events;
1617 if (cur_event->reset)
1619 WaitEventAdjustWin32(set, cur_event);
1620 cur_event->reset =
false;
1645 if (WSARecv(cur_event->
fd, &
buf, 1, &received, &flags, NULL, NULL) == 0)
1647 occurred_events->
pos = cur_event->
pos;
1650 occurred_events->
fd = cur_event->
fd;
1676 r = WSASend(cur_event->
fd, &
buf, 1, &sent, 0, NULL, NULL);
1677 if (r == 0 || WSAGetLastError() != WSAEWOULDBLOCK)
1679 occurred_events->
pos = cur_event->
pos;
1682 occurred_events->
fd = cur_event->
fd;
1693 rc = WaitForMultipleObjects(set->
nevents + 1, set->handles, FALSE,
1697 if (rc == WAIT_FAILED)
1698 elog(
ERROR,
"WaitForMultipleObjects() failed: error code %lu",
1700 else if (rc == WAIT_TIMEOUT)
1706 if (rc == WAIT_OBJECT_0)
1724 occurred_events->
pos = cur_event->
pos;
1726 occurred_events->
events = 0;
1734 if (!ResetEvent(set->handles[cur_event->
pos + 1]))
1735 elog(
ERROR,
"ResetEvent failed: error code %lu", GetLastError());
1766 WSANETWORKEVENTS resEvents;
1767 HANDLE handle = set->handles[cur_event->
pos + 1];
1771 occurred_events->
fd = cur_event->
fd;
1773 ZeroMemory(&resEvents,
sizeof(resEvents));
1774 if (WSAEnumNetworkEvents(cur_event->
fd, handle, &resEvents) != 0)
1775 elog(
ERROR,
"failed to enumerate network events: error code %d",
1778 (resEvents.lNetworkEvents & FD_READ))
1796 cur_event->reset =
true;
1799 (resEvents.lNetworkEvents & FD_WRITE))
1805 (resEvents.lNetworkEvents & FD_CONNECT))
1811 (resEvents.lNetworkEvents & FD_ACCEPT))
1816 if (resEvents.lNetworkEvents & FD_CLOSE)
1822 if (occurred_events->
events != 0)
1830 if (returned_events == nevents)
1834 next_pos = cur_event->
pos + 1;
1843 count = set->
nevents - next_pos;
1844 rc = WaitForMultipleObjects(count,
1845 set->handles + 1 + next_pos,
1853 if (rc < WAIT_OBJECT_0 || rc >= WAIT_OBJECT_0 + count)
1857 cur_event = &set->
events[next_pos + (rc - WAIT_OBJECT_0)];
1860 return returned_events;
1870#if (defined(WAIT_USE_POLL) && defined(POLLRDHUP)) || \
1871 defined(WAIT_USE_EPOLL) || \
1872 defined(WAIT_USE_KQUEUE)
1888#if defined(WAIT_USE_SELF_PIPE)
1935#if defined(WAIT_USE_SELF_PIPE) || defined(WAIT_USE_SIGNALFD)
1951#ifdef WAIT_USE_SELF_PIPE
1964 else if (errno ==
EINTR)
1969#ifdef WAIT_USE_SELF_PIPE
1970 elog(
ERROR,
"read() on self-pipe failed: %m");
1972 elog(
ERROR,
"read() on signalfd failed: %m");
1979#ifdef WAIT_USE_SELF_PIPE
1980 elog(
ERROR,
"unexpected EOF on self-pipe");
1982 elog(
ERROR,
"unexpected EOF on signalfd");
1985 else if (rc <
sizeof(
buf))
2022#if defined(WAIT_USE_SELF_PIPE)
#define pg_memory_barrier()
#define StaticAssertStmt(condition, errmessage)
int errcode_for_socket_access(void)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
void ReleaseExternalFD(void)
bool AcquireExternalFD(void)
void ReserveExternalFD(void)
Assert(PointerIsAligned(start, uint64))
#define INSTR_TIME_SET_CURRENT(t)
#define INSTR_TIME_SUBTRACT(x, y)
#define INSTR_TIME_GET_MILLISEC(t)
#define INSTR_TIME_SET_ZERO(t)
if(TABLE==NULL||TABLE_index==NULL)
void * MemoryContextAllocZero(MemoryContext context, Size size)
void pfree(void *pointer)
MemoryContext TopMemoryContext
bool PostmasterIsAliveInternal(void)
#define PostmasterIsAlive()
static Datum PointerGetDatum(const void *X)
static Pointer DatumGetPointer(Datum X)
int postmaster_alive_fds[2]
#define POSTMASTER_FD_WATCH
static int fd(const char *x, int i)
void ResourceOwnerForget(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
void ResourceOwnerRemember(ResourceOwner owner, Datum value, const ResourceOwnerDesc *kind)
void ResourceOwnerEnlarge(ResourceOwner owner)
#define RELEASE_PRIO_WAITEVENTSETS
@ RESOURCE_RELEASE_AFTER_LOCKS
void pgwin32_dispatch_queued_signals(void)
HANDLE pgwin32_signal_event
sig_atomic_t maybe_sleeping
bool exit_on_postmaster_death
static void pgstat_report_wait_start(uint32 wait_event_info)
static void pgstat_report_wait_end(void)
static void latch_sigurg_handler(SIGNAL_ARGS)
static void sendSelfPipeByte(void)
static void ResourceOwnerForgetWaitEventSet(ResourceOwner owner, WaitEventSet *set)
static int selfpipe_readfd
static const ResourceOwnerDesc wait_event_set_resowner_desc
void FreeWaitEventSetAfterFork(WaitEventSet *set)
static void WaitEventAdjustPoll(WaitEventSet *set, WaitEvent *event)
static int selfpipe_owner_pid
static int selfpipe_writefd
int GetNumRegisteredWaitEvents(WaitEventSet *set)
void WakeupOtherProc(int pid)
static void ResourceOwnerRememberWaitEventSet(ResourceOwner owner, WaitEventSet *set)
void ModifyWaitEvent(WaitEventSet *set, int pos, uint32 events, Latch *latch)
static int WaitEventSetWaitBlock(WaitEventSet *set, int cur_timeout, WaitEvent *occurred_events, int nevents)
static void ResOwnerReleaseWaitEventSet(Datum res)
void InitializeWaitEventSupport(void)
bool WaitEventSetCanReportClosed(void)
int AddWaitEventToSet(WaitEventSet *set, uint32 events, pgsocket fd, Latch *latch, void *user_data)
int WaitEventSetWait(WaitEventSet *set, long timeout, WaitEvent *occurred_events, int nevents, uint32 wait_event_info)
static volatile sig_atomic_t waiting
void FreeWaitEventSet(WaitEventSet *set)
WaitEventSet * CreateWaitEventSet(ResourceOwner resowner, int nevents)
#define WL_SOCKET_READABLE
#define WL_EXIT_ON_PM_DEATH
#define WL_SOCKET_CONNECTED
#define WL_POSTMASTER_DEATH
#define WL_SOCKET_WRITEABLE