40#ifdef HAVE_SYS_EPOLL_H
43#ifdef HAVE_SYS_EVENT_H
46#ifdef HAVE_SYS_SIGNALFD_H
47#include <sys/signalfd.h>
72#if defined(WAIT_USE_EPOLL) || defined(WAIT_USE_POLL) || \
73 defined(WAIT_USE_KQUEUE) || defined(WAIT_USE_WIN32)
75#elif defined(HAVE_SYS_EPOLL_H)
77#elif defined(HAVE_KQUEUE)
78#define WAIT_USE_KQUEUE
79#elif defined(HAVE_POLL)
84#error "no wait set implementation available"
91#if defined(WAIT_USE_POLL) || defined(WAIT_USE_EPOLL)
92#if defined(WAIT_USE_SELF_PIPE) || defined(WAIT_USE_SIGNALFD)
94#elif defined(WAIT_USE_EPOLL) && defined(HAVE_SYS_SIGNALFD_H)
95#define WAIT_USE_SIGNALFD
97#define WAIT_USE_SELF_PIPE
131#if defined(WAIT_USE_EPOLL)
134 struct epoll_event *epoll_ret_events;
135#elif defined(WAIT_USE_KQUEUE)
138 struct kevent *kqueue_ret_events;
139 bool report_postmaster_not_running;
140#elif defined(WAIT_USE_POLL)
143#elif defined(WAIT_USE_WIN32)
158#define LatchWaitSetLatchPos 0
165#ifdef WAIT_USE_SIGNALFD
167static int signal_fd = -1;
170#ifdef WAIT_USE_SELF_PIPE
183#if defined(WAIT_USE_SELF_PIPE) || defined(WAIT_USE_SIGNALFD)
184static void drain(
void);
187#if defined(WAIT_USE_EPOLL)
189#elif defined(WAIT_USE_KQUEUE)
191#elif defined(WAIT_USE_POLL)
193#elif defined(WAIT_USE_WIN32)
198 WaitEvent *occurred_events,
int nevents);
205 .
name =
"WaitEventSet",
234#if defined(WAIT_USE_SELF_PIPE)
286 if (pipe(pipefd) < 0)
288 if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) == -1)
289 elog(
FATAL,
"fcntl(F_SETFL) failed on read-end of self-pipe: %m");
290 if (fcntl(pipefd[1], F_SETFL, O_NONBLOCK) == -1)
291 elog(
FATAL,
"fcntl(F_SETFL) failed on write-end of self-pipe: %m");
292 if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) == -1)
293 elog(
FATAL,
"fcntl(F_SETFD) failed on read-end of self-pipe: %m");
294 if (fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) == -1)
295 elog(
FATAL,
"fcntl(F_SETFD) failed on write-end of self-pipe: %m");
308#ifdef WAIT_USE_SIGNALFD
309 sigset_t signalfd_mask;
321 (void)
close(signal_fd);
331 sigemptyset(&signalfd_mask);
332 sigaddset(&signalfd_mask, SIGURG);
333 signal_fd = signalfd(-1, &signalfd_mask, SFD_NONBLOCK | SFD_CLOEXEC);
339#ifdef WAIT_USE_KQUEUE
366#if defined(WAIT_USE_POLL)
376#if defined(WAIT_USE_SELF_PIPE)
384#if defined(WAIT_USE_SIGNALFD)
401#if defined(WAIT_USE_SELF_PIPE)
404#elif defined(WAIT_USE_SIGNALFD)
407#elif defined(WAIT_USE_WIN32)
408 latch->event = CreateEvent(NULL, TRUE, FALSE, NULL);
409 if (latch->event == NULL)
410 elog(
ERROR,
"CreateEvent failed: error code %lu", GetLastError());
433 SECURITY_ATTRIBUTES
sa;
438 ZeroMemory(&
sa,
sizeof(
sa));
439 sa.nLength =
sizeof(
sa);
440 sa.bInheritHandle = TRUE;
442 latch->event = CreateEvent(&
sa, TRUE, FALSE, NULL);
443 if (latch->event == NULL)
444 elog(
ERROR,
"CreateEvent failed: error code %lu", GetLastError());
470#if defined(WAIT_USE_SELF_PIPE)
473#elif defined(WAIT_USE_SIGNALFD)
480 elog(
PANIC,
"latch already owned by PID %d", owner_pid);
541 wait_event_info) == 0)
566 long timeout,
uint32 wait_event_info)
686#if defined(WAIT_USE_SELF_PIPE)
695 kill(owner_pid, SIGURG);
706 handle = latch->event;
766#if defined(WAIT_USE_EPOLL)
767 sz +=
MAXALIGN(
sizeof(
struct epoll_event) * nevents);
768#elif defined(WAIT_USE_KQUEUE)
769 sz +=
MAXALIGN(
sizeof(
struct kevent) * nevents);
770#elif defined(WAIT_USE_POLL)
771 sz +=
MAXALIGN(
sizeof(
struct pollfd) * nevents);
772#elif defined(WAIT_USE_WIN32)
774 sz +=
MAXALIGN(
sizeof(HANDLE) * (nevents + 1));
777 if (resowner != NULL)
788#if defined(WAIT_USE_EPOLL)
789 set->epoll_ret_events = (
struct epoll_event *)
data;
791#elif defined(WAIT_USE_KQUEUE)
792 set->kqueue_ret_events = (
struct kevent *)
data;
794#elif defined(WAIT_USE_POLL)
797#elif defined(WAIT_USE_WIN32)
798 set->handles = (HANDLE)
data;
806 if (resowner != NULL)
809 set->
owner = resowner;
812#if defined(WAIT_USE_EPOLL)
814 elog(
ERROR,
"AcquireExternalFD, for epoll_create1, failed: %m");
815 set->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
816 if (set->epoll_fd < 0)
821#elif defined(WAIT_USE_KQUEUE)
823 elog(
ERROR,
"AcquireExternalFD, for kqueue, failed: %m");
824 set->kqueue_fd = kqueue();
825 if (set->kqueue_fd < 0)
830 if (fcntl(set->kqueue_fd, F_SETFD, FD_CLOEXEC) == -1)
832 int save_errno = errno;
834 close(set->kqueue_fd);
837 elog(
ERROR,
"fcntl(F_SETFD) failed on kqueue descriptor: %m");
839 set->report_postmaster_not_running =
false;
840#elif defined(WAIT_USE_WIN32)
876#if defined(WAIT_USE_EPOLL)
877 close(set->epoll_fd);
879#elif defined(WAIT_USE_KQUEUE)
880 close(set->kqueue_fd);
882#elif defined(WAIT_USE_WIN32)
898 WSAEventSelect(cur_event->fd, NULL, 0);
899 WSACloseEvent(set->handles[cur_event->pos + 1]);
913#if defined(WAIT_USE_EPOLL)
914 close(set->epoll_fd);
916#elif defined(WAIT_USE_KQUEUE)
974 elog(
ERROR,
"cannot wait on a latch owned by another process");
976 elog(
ERROR,
"cannot wait on more than one latch");
978 elog(
ERROR,
"latch events only support being set");
983 elog(
ERROR,
"cannot wait on latch without a specified latch");
988 elog(
ERROR,
"cannot wait on socket event without a socket");
993 event->events = events;
994 event->user_data = user_data;
996 event->reset =
false;
1003#if defined(WAIT_USE_SELF_PIPE)
1005#elif defined(WAIT_USE_SIGNALFD)
1006 event->fd = signal_fd;
1009#ifdef WAIT_USE_EPOLL
1022#if defined(WAIT_USE_EPOLL)
1023 WaitEventAdjustEpoll(set, event, EPOLL_CTL_ADD);
1024#elif defined(WAIT_USE_KQUEUE)
1025 WaitEventAdjustKqueue(set, event, 0);
1026#elif defined(WAIT_USE_POLL)
1028#elif defined(WAIT_USE_WIN32)
1029 WaitEventAdjustWin32(set, event);
1046#if defined(WAIT_USE_KQUEUE)
1050 Assert(pos < set->nevents);
1052 event = &set->
events[pos];
1053#if defined(WAIT_USE_KQUEUE)
1054 old_events =
event->
events;
1063 if (events == event->
events &&
1070 elog(
ERROR,
"cannot modify latch event");
1075 elog(
ERROR,
"cannot modify postmaster death event");
1079 event->events = events;
1084 elog(
ERROR,
"cannot wait on a latch owned by another process");
1094#if defined(WAIT_USE_WIN32)
1102#if defined(WAIT_USE_EPOLL)
1103 WaitEventAdjustEpoll(set, event, EPOLL_CTL_MOD);
1104#elif defined(WAIT_USE_KQUEUE)
1105 WaitEventAdjustKqueue(set, event, old_events);
1106#elif defined(WAIT_USE_POLL)
1108#elif defined(WAIT_USE_WIN32)
1109 WaitEventAdjustWin32(set, event);
1113#if defined(WAIT_USE_EPOLL)
1120 struct epoll_event epoll_ev;
1124 epoll_ev.data.ptr = event;
1126 epoll_ev.
events = EPOLLERR | EPOLLHUP;
1132 epoll_ev.events |= EPOLLIN;
1136 epoll_ev.events |= EPOLLIN;
1146 epoll_ev.events |= EPOLLIN;
1148 epoll_ev.events |= EPOLLOUT;
1150 epoll_ev.events |= EPOLLRDHUP;
1158 rc = epoll_ctl(set->epoll_fd,
action, event->
fd, &epoll_ev);
1163 errmsg(
"%s() failed: %m",
1168#if defined(WAIT_USE_POLL)
1172 struct pollfd *pollfd = &set->
pollfds[
event->pos];
1174 pollfd->revents = 0;
1175 pollfd->fd =
event->fd;
1181 pollfd->events = POLLIN;
1185 pollfd->events = POLLIN;
1194 pollfd->events |= POLLIN;
1196 pollfd->events |= POLLOUT;
1199 pollfd->events |= POLLRDHUP;
1207#if defined(WAIT_USE_KQUEUE)
1215#define AccessWaitEvent(k_ev) (*((WaitEvent **)(&(k_ev)->udata)))
1218WaitEventAdjustKqueueAdd(
struct kevent *k_ev,
int filter,
int action,
1221 k_ev->ident =
event->fd;
1222 k_ev->filter = filter;
1226 AccessWaitEvent(k_ev) = event;
1230WaitEventAdjustKqueueAddPostmaster(
struct kevent *k_ev,
WaitEvent *event)
1234 k_ev->filter = EVFILT_PROC;
1235 k_ev->flags = EV_ADD;
1236 k_ev->fflags = NOTE_EXIT;
1238 AccessWaitEvent(k_ev) = event;
1242WaitEventAdjustKqueueAddLatch(
struct kevent *k_ev,
WaitEvent *event)
1245 k_ev->ident = SIGURG;
1246 k_ev->filter = EVFILT_SIGNAL;
1247 k_ev->flags = EV_ADD;
1250 AccessWaitEvent(k_ev) = event;
1260 struct kevent k_ev[2];
1262 bool new_filt_read =
false;
1263 bool old_filt_read =
false;
1264 bool new_filt_write =
false;
1265 bool old_filt_write =
false;
1267 if (old_events == event->
events)
1284 WaitEventAdjustKqueueAddPostmaster(&k_ev[count++], event);
1289 WaitEventAdjustKqueueAddLatch(&k_ev[count++], event);
1299 old_filt_read =
true;
1301 new_filt_read =
true;
1303 old_filt_write =
true;
1305 new_filt_write =
true;
1306 if (old_filt_read && !new_filt_read)
1307 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_READ, EV_DELETE,
1309 else if (!old_filt_read && new_filt_read)
1310 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_READ, EV_ADD,
1312 if (old_filt_write && !new_filt_write)
1313 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_WRITE, EV_DELETE,
1315 else if (!old_filt_write && new_filt_write)
1316 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_WRITE, EV_ADD,
1326 rc = kevent(set->kqueue_fd, &k_ev[0], count, NULL, 0, NULL);
1338 (errno == ESRCH || errno == EACCES))
1339 set->report_postmaster_not_running =
true;
1343 errmsg(
"%s() failed: %m",
1355 set->report_postmaster_not_running =
true;
1361#if defined(WAIT_USE_WIN32)
1365 HANDLE *handle = &set->handles[
event->pos + 1];
1370 *handle = set->
latch->event;
1374 *handle = PostmasterHandle;
1378 int flags = FD_CLOSE;
1385 flags |= FD_CONNECT;
1389 if (*handle == WSA_INVALID_EVENT)
1391 *handle = WSACreateEvent();
1392 if (*handle == WSA_INVALID_EVENT)
1393 elog(
ERROR,
"failed to create event for socket: error code %d",
1396 if (WSAEventSelect(event->
fd, *handle, flags) != 0)
1397 elog(
ERROR,
"failed to set up event for socket: error code %d",
1419 WaitEvent *occurred_events,
int nevents,
1422 int returned_events = 0;
1425 long cur_timeout = -1;
1436 Assert(timeout >= 0 && timeout <= INT_MAX);
1437 cur_timeout = timeout;
1450 while (returned_events == 0)
1502 if (returned_events == nevents)
1520 occurred_events, nevents - returned_events);
1529 returned_events += rc;
1532 if (returned_events == 0 && timeout >= 0)
1537 if (cur_timeout <= 0)
1547 return returned_events;
1551#if defined(WAIT_USE_EPOLL)
1563 WaitEvent *occurred_events,
int nevents)
1565 int returned_events = 0;
1568 struct epoll_event *cur_epoll_event;
1571 rc = epoll_wait(set->epoll_fd, set->epoll_ret_events,
1583 errmsg(
"%s() failed: %m",
1599 for (cur_epoll_event = set->epoll_ret_events;
1600 cur_epoll_event < (set->epoll_ret_events + rc) &&
1601 returned_events < nevents;
1605 cur_event = (
WaitEvent *) cur_epoll_event->data.ptr;
1607 occurred_events->
pos = cur_event->
pos;
1609 occurred_events->
events = 0;
1612 cur_epoll_event->events & (EPOLLIN | EPOLLERR | EPOLLHUP))
1626 cur_epoll_event->events & (EPOLLIN | EPOLLERR | EPOLLHUP))
1656 (cur_epoll_event->events & (EPOLLIN | EPOLLERR | EPOLLHUP)))
1663 (cur_epoll_event->events & (EPOLLOUT | EPOLLERR | EPOLLHUP)))
1670 (cur_epoll_event->events & (EPOLLRDHUP | EPOLLERR | EPOLLHUP)))
1676 if (occurred_events->
events != 0)
1678 occurred_events->
fd = cur_event->
fd;
1685 return returned_events;
1688#elif defined(WAIT_USE_KQUEUE)
1699 WaitEvent *occurred_events,
int nevents)
1701 int returned_events = 0;
1704 struct kevent *cur_kqueue_event;
1705 struct timespec timeout;
1706 struct timespec *timeout_p;
1708 if (cur_timeout < 0)
1712 timeout.tv_sec = cur_timeout / 1000;
1713 timeout.tv_nsec = (cur_timeout % 1000) * 1000000;
1714 timeout_p = &timeout;
1721 if (
unlikely(set->report_postmaster_not_running))
1731 rc = kevent(set->kqueue_fd, NULL, 0,
1732 set->kqueue_ret_events,
1745 errmsg(
"%s() failed: %m",
1761 for (cur_kqueue_event = set->kqueue_ret_events;
1762 cur_kqueue_event < (set->kqueue_ret_events + rc) &&
1763 returned_events < nevents;
1767 cur_event = AccessWaitEvent(cur_kqueue_event);
1769 occurred_events->
pos = cur_event->
pos;
1771 occurred_events->
events = 0;
1774 cur_kqueue_event->filter == EVFILT_SIGNAL)
1785 cur_kqueue_event->filter == EVFILT_PROC &&
1786 (cur_kqueue_event->fflags & NOTE_EXIT) != 0)
1793 set->report_postmaster_not_running =
true;
1809 (cur_kqueue_event->filter == EVFILT_READ))
1816 (cur_kqueue_event->filter == EVFILT_READ) &&
1817 (cur_kqueue_event->flags & EV_EOF))
1824 (cur_kqueue_event->filter == EVFILT_WRITE))
1830 if (occurred_events->
events != 0)
1832 occurred_events->
fd = cur_event->
fd;
1839 return returned_events;
1842#elif defined(WAIT_USE_POLL)
1852 WaitEvent *occurred_events,
int nevents)
1854 int returned_events = 0;
1857 struct pollfd *cur_pollfd;
1871 errmsg(
"%s() failed: %m",
1884 returned_events < nevents;
1885 cur_event++, cur_pollfd++)
1888 if (cur_pollfd->revents == 0)
1891 occurred_events->
pos = cur_event->
pos;
1893 occurred_events->
events = 0;
1896 (cur_pollfd->revents & (POLLIN | POLLHUP | POLLERR | POLLNVAL)))
1910 (cur_pollfd->revents & (POLLIN | POLLHUP | POLLERR | POLLNVAL)))
1937 int errflags = POLLHUP | POLLERR | POLLNVAL;
1942 (cur_pollfd->revents & (POLLIN | errflags)))
1949 (cur_pollfd->revents & (POLLOUT | errflags)))
1957 (cur_pollfd->revents & (POLLRDHUP | errflags)))
1964 if (occurred_events->
events != 0)
1966 occurred_events->
fd = cur_event->
fd;
1972 return returned_events;
1975#elif defined(WAIT_USE_WIN32)
1986 WaitEvent *occurred_events,
int nevents)
1988 int returned_events = 0;
1993 for (cur_event = set->
events;
1997 if (cur_event->reset)
1999 WaitEventAdjustWin32(set, cur_event);
2000 cur_event->reset =
false;
2025 if (WSARecv(cur_event->
fd, &
buf, 1, &received, &flags, NULL, NULL) == 0)
2027 occurred_events->
pos = cur_event->
pos;
2030 occurred_events->
fd = cur_event->
fd;
2056 r = WSASend(cur_event->
fd, &
buf, 1, &sent, 0, NULL, NULL);
2057 if (r == 0 || WSAGetLastError() != WSAEWOULDBLOCK)
2059 occurred_events->
pos = cur_event->
pos;
2062 occurred_events->
fd = cur_event->
fd;
2073 rc = WaitForMultipleObjects(set->
nevents + 1, set->handles, FALSE,
2077 if (rc == WAIT_FAILED)
2078 elog(
ERROR,
"WaitForMultipleObjects() failed: error code %lu",
2080 else if (rc == WAIT_TIMEOUT)
2086 if (rc == WAIT_OBJECT_0)
2104 occurred_events->
pos = cur_event->
pos;
2106 occurred_events->
events = 0;
2114 if (!ResetEvent(set->handles[cur_event->
pos + 1]))
2115 elog(
ERROR,
"ResetEvent failed: error code %lu", GetLastError());
2146 WSANETWORKEVENTS resEvents;
2147 HANDLE handle = set->handles[cur_event->
pos + 1];
2151 occurred_events->
fd = cur_event->
fd;
2153 ZeroMemory(&resEvents,
sizeof(resEvents));
2154 if (WSAEnumNetworkEvents(cur_event->
fd, handle, &resEvents) != 0)
2155 elog(
ERROR,
"failed to enumerate network events: error code %d",
2158 (resEvents.lNetworkEvents & FD_READ))
2176 cur_event->reset =
true;
2179 (resEvents.lNetworkEvents & FD_WRITE))
2185 (resEvents.lNetworkEvents & FD_CONNECT))
2191 (resEvents.lNetworkEvents & FD_ACCEPT))
2196 if (resEvents.lNetworkEvents & FD_CLOSE)
2202 if (occurred_events->
events != 0)
2210 if (returned_events == nevents)
2214 next_pos = cur_event->
pos + 1;
2223 count = set->
nevents - next_pos;
2224 rc = WaitForMultipleObjects(count,
2225 set->handles + 1 + next_pos,
2233 if (rc < WAIT_OBJECT_0 || rc >= WAIT_OBJECT_0 + count)
2237 cur_event = &set->
events[next_pos + (rc - WAIT_OBJECT_0)];
2240 return returned_events;
2250#if (defined(WAIT_USE_POLL) && defined(POLLRDHUP)) || \
2251 defined(WAIT_USE_EPOLL) || \
2252 defined(WAIT_USE_KQUEUE)
2268#if defined(WAIT_USE_SELF_PIPE)
2315#if defined(WAIT_USE_SELF_PIPE) || defined(WAIT_USE_SIGNALFD)
2331#ifdef WAIT_USE_SELF_PIPE
2344 else if (errno ==
EINTR)
2349#ifdef WAIT_USE_SELF_PIPE
2350 elog(
ERROR,
"read() on self-pipe failed: %m");
2352 elog(
ERROR,
"read() on signalfd failed: %m");
2359#ifdef WAIT_USE_SELF_PIPE
2360 elog(
ERROR,
"unexpected EOF on self-pipe");
2362 elog(
ERROR,
"unexpected EOF on signalfd");
2365 else if (rc <
sizeof(
buf))
#define pg_memory_barrier()
#define PG_USED_FOR_ASSERTS_ONLY
#define Assert(condition)
#define StaticAssertStmt(condition, errmessage)
static void PGresult * res
int errcode_for_socket_access(void)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
void ReleaseExternalFD(void)
bool AcquireExternalFD(void)
void ReserveExternalFD(void)
#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)
static void latch_sigurg_handler(SIGNAL_ARGS)
static void sendSelfPipeByte(void)
static void ResourceOwnerForgetWaitEventSet(ResourceOwner owner, WaitEventSet *set)
void InitializeLatchWaitSet(void)
int WaitLatchOrSocket(Latch *latch, int wakeEvents, pgsocket sock, long timeout, uint32 wait_event_info)
#define LatchWaitSetLatchPos
static int selfpipe_readfd
void OwnLatch(Latch *latch)
void DisownLatch(Latch *latch)
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 InitSharedLatch(Latch *latch)
void InitializeLatchSupport(void)
static WaitEventSet * LatchWaitSet
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 SetLatch(Latch *latch)
void ShutdownLatchSupport(void)
bool WaitEventSetCanReportClosed(void)
void InitLatch(Latch *latch)
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)
void ResetLatch(Latch *latch)
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
#define WL_SOCKET_READABLE
#define WL_EXIT_ON_PM_DEATH
#define WL_SOCKET_CONNECTED
#define WL_POSTMASTER_DEATH
#define WL_SOCKET_WRITEABLE
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)
ResourceOwner CurrentResourceOwner
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)