40 #ifdef HAVE_SYS_EPOLL_H
41 #include <sys/epoll.h>
43 #ifdef HAVE_SYS_EVENT_H
44 #include <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)
76 #define WAIT_USE_EPOLL
77 #elif defined(HAVE_KQUEUE)
78 #define WAIT_USE_KQUEUE
79 #elif defined(HAVE_POLL)
82 #define WAIT_USE_WIN32
84 #error "no wait set implementation available"
92 #if defined(WAIT_USE_POLL) || defined(WAIT_USE_EPOLL)
93 #if defined(WAIT_USE_SELF_PIPE) || defined(WAIT_USE_SIGNALFD)
95 #elif defined(WAIT_USE_EPOLL) && defined(HAVE_SYS_SIGNALFD_H) && \
97 #define WAIT_USE_SIGNALFD
99 #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)
142 struct pollfd *pollfds;
143 #elif defined(WAIT_USE_WIN32)
158 #define LatchWaitSetLatchPos 0
165 #ifdef WAIT_USE_SIGNALFD
167 static int signal_fd = -1;
170 #ifdef WAIT_USE_SELF_PIPE
172 static int selfpipe_readfd = -1;
173 static int selfpipe_writefd = -1;
176 static int selfpipe_owner_pid = 0;
180 static void sendSelfPipeByte(
void);
183 #if defined(WAIT_USE_SELF_PIPE) || defined(WAIT_USE_SIGNALFD)
184 static 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);
209 #if defined(WAIT_USE_SELF_PIPE)
220 if (selfpipe_owner_pid != 0)
225 (void)
close(selfpipe_readfd);
226 (void)
close(selfpipe_writefd);
228 selfpipe_readfd = selfpipe_writefd = -1;
229 selfpipe_owner_pid = 0;
242 Assert(selfpipe_readfd == -1);
248 Assert(selfpipe_readfd == -1);
249 Assert(selfpipe_owner_pid == 0);
261 if (pipe(pipefd) < 0)
263 if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) == -1)
264 elog(
FATAL,
"fcntl(F_SETFL) failed on read-end of self-pipe: %m");
265 if (fcntl(pipefd[1], F_SETFL, O_NONBLOCK) == -1)
266 elog(
FATAL,
"fcntl(F_SETFL) failed on write-end of self-pipe: %m");
267 if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) == -1)
268 elog(
FATAL,
"fcntl(F_SETFD) failed on read-end of self-pipe: %m");
269 if (fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) == -1)
270 elog(
FATAL,
"fcntl(F_SETFD) failed on write-end of self-pipe: %m");
272 selfpipe_readfd = pipefd[0];
273 selfpipe_writefd = pipefd[1];
280 pqsignal(SIGURG, latch_sigurg_handler);
283 #ifdef WAIT_USE_SIGNALFD
284 sigset_t signalfd_mask;
290 sigemptyset(&signalfd_mask);
291 sigaddset(&signalfd_mask, SIGURG);
292 signal_fd = signalfd(-1, &signalfd_mask, SFD_NONBLOCK | SFD_CLOEXEC);
298 #ifdef WAIT_USE_KQUEUE
325 #if defined(WAIT_USE_POLL)
335 #if defined(WAIT_USE_SELF_PIPE)
336 close(selfpipe_readfd);
337 close(selfpipe_writefd);
338 selfpipe_readfd = -1;
339 selfpipe_writefd = -1;
343 #if defined(WAIT_USE_SIGNALFD)
360 #if defined(WAIT_USE_SELF_PIPE)
363 #elif defined(WAIT_USE_SIGNALFD)
366 #elif defined(WAIT_USE_WIN32)
367 latch->event = CreateEvent(NULL, TRUE, FALSE, NULL);
368 if (latch->event == NULL)
369 elog(
ERROR,
"CreateEvent failed: error code %lu", GetLastError());
392 SECURITY_ATTRIBUTES
sa;
397 ZeroMemory(&
sa,
sizeof(
sa));
398 sa.nLength =
sizeof(
sa);
399 sa.bInheritHandle = TRUE;
401 latch->event = CreateEvent(&
sa, TRUE, FALSE, NULL);
402 if (latch->event == NULL)
403 elog(
ERROR,
"CreateEvent failed: error code %lu", GetLastError());
429 #if defined(WAIT_USE_SELF_PIPE)
432 #elif defined(WAIT_USE_SIGNALFD)
439 elog(
PANIC,
"latch already owned by PID %d", owner_pid);
500 wait_event_info) == 0)
525 long timeout,
uint32 wait_event_info)
645 #if defined(WAIT_USE_SELF_PIPE)
654 kill(owner_pid, SIGURG);
665 handle = latch->event;
722 #if defined(WAIT_USE_EPOLL)
723 sz +=
MAXALIGN(
sizeof(
struct epoll_event) * nevents);
724 #elif defined(WAIT_USE_KQUEUE)
725 sz +=
MAXALIGN(
sizeof(
struct kevent) * nevents);
726 #elif defined(WAIT_USE_POLL)
727 sz +=
MAXALIGN(
sizeof(
struct pollfd) * nevents);
728 #elif defined(WAIT_USE_WIN32)
730 sz +=
MAXALIGN(
sizeof(HANDLE) * (nevents + 1));
741 #if defined(WAIT_USE_EPOLL)
742 set->epoll_ret_events = (
struct epoll_event *)
data;
744 #elif defined(WAIT_USE_KQUEUE)
745 set->kqueue_ret_events = (
struct kevent *)
data;
747 #elif defined(WAIT_USE_POLL)
748 set->pollfds = (
struct pollfd *)
data;
750 #elif defined(WAIT_USE_WIN32)
751 set->handles = (HANDLE)
data;
759 #if defined(WAIT_USE_EPOLL)
765 set->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
766 if (set->epoll_fd < 0)
771 #elif defined(WAIT_USE_KQUEUE)
777 set->kqueue_fd = kqueue();
778 if (set->kqueue_fd < 0)
783 if (fcntl(set->kqueue_fd, F_SETFD, FD_CLOEXEC) == -1)
785 int save_errno = errno;
787 close(set->kqueue_fd);
790 elog(
ERROR,
"fcntl(F_SETFD) failed on kqueue descriptor: %m");
792 set->report_postmaster_not_running =
false;
793 #elif defined(WAIT_USE_WIN32)
823 #if defined(WAIT_USE_EPOLL)
824 close(set->epoll_fd);
826 #elif defined(WAIT_USE_KQUEUE)
827 close(set->kqueue_fd);
829 #elif defined(WAIT_USE_WIN32)
832 for (cur_event = set->
events;
847 WSAEventSelect(cur_event->
fd, NULL, 0);
848 WSACloseEvent(set->handles[cur_event->
pos + 1]);
903 elog(
ERROR,
"cannot wait on a latch owned by another process");
905 elog(
ERROR,
"cannot wait on more than one latch");
907 elog(
ERROR,
"latch events only support being set");
912 elog(
ERROR,
"cannot wait on latch without a specified latch");
917 elog(
ERROR,
"cannot wait on socket event without a socket");
922 event->events = events;
923 event->user_data = user_data;
925 event->reset =
false;
932 #if defined(WAIT_USE_SELF_PIPE)
933 event->fd = selfpipe_readfd;
934 #elif defined(WAIT_USE_SIGNALFD)
935 event->fd = signal_fd;
938 #ifdef WAIT_USE_EPOLL
951 #if defined(WAIT_USE_EPOLL)
952 WaitEventAdjustEpoll(set, event, EPOLL_CTL_ADD);
953 #elif defined(WAIT_USE_KQUEUE)
954 WaitEventAdjustKqueue(set, event, 0);
955 #elif defined(WAIT_USE_POLL)
956 WaitEventAdjustPoll(set, event);
957 #elif defined(WAIT_USE_WIN32)
958 WaitEventAdjustWin32(set, event);
975 #if defined(WAIT_USE_KQUEUE)
979 Assert(pos < set->nevents);
981 event = &set->
events[pos];
982 #if defined(WAIT_USE_KQUEUE)
983 old_events =
event->
events;
992 if (events == event->
events &&
999 elog(
ERROR,
"cannot modify latch event");
1004 elog(
ERROR,
"cannot modify postmaster death event");
1008 event->events = events;
1013 elog(
ERROR,
"cannot wait on a latch owned by another process");
1023 #if defined(WAIT_USE_WIN32)
1031 #if defined(WAIT_USE_EPOLL)
1032 WaitEventAdjustEpoll(set, event, EPOLL_CTL_MOD);
1033 #elif defined(WAIT_USE_KQUEUE)
1034 WaitEventAdjustKqueue(set, event, old_events);
1035 #elif defined(WAIT_USE_POLL)
1036 WaitEventAdjustPoll(set, event);
1037 #elif defined(WAIT_USE_WIN32)
1038 WaitEventAdjustWin32(set, event);
1042 #if defined(WAIT_USE_EPOLL)
1049 struct epoll_event epoll_ev;
1053 epoll_ev.data.ptr = event;
1055 epoll_ev.
events = EPOLLERR | EPOLLHUP;
1061 epoll_ev.events |= EPOLLIN;
1065 epoll_ev.events |= EPOLLIN;
1075 epoll_ev.events |= EPOLLIN;
1077 epoll_ev.events |= EPOLLOUT;
1079 epoll_ev.events |= EPOLLRDHUP;
1087 rc = epoll_ctl(set->epoll_fd,
action, event->
fd, &epoll_ev);
1092 errmsg(
"%s() failed: %m",
1097 #if defined(WAIT_USE_POLL)
1101 struct pollfd *pollfd = &set->pollfds[
event->pos];
1103 pollfd->revents = 0;
1104 pollfd->fd =
event->fd;
1110 pollfd->events = POLLIN;
1114 pollfd->events = POLLIN;
1123 pollfd->events |= POLLIN;
1125 pollfd->events |= POLLOUT;
1128 pollfd->events |= POLLRDHUP;
1136 #if defined(WAIT_USE_KQUEUE)
1144 #define AccessWaitEvent(k_ev) (*((WaitEvent **)(&(k_ev)->udata)))
1147 WaitEventAdjustKqueueAdd(
struct kevent *k_ev,
int filter,
int action,
1150 k_ev->ident =
event->fd;
1151 k_ev->filter = filter;
1155 AccessWaitEvent(k_ev) = event;
1159 WaitEventAdjustKqueueAddPostmaster(
struct kevent *k_ev,
WaitEvent *event)
1163 k_ev->filter = EVFILT_PROC;
1164 k_ev->flags = EV_ADD;
1165 k_ev->fflags = NOTE_EXIT;
1167 AccessWaitEvent(k_ev) = event;
1171 WaitEventAdjustKqueueAddLatch(
struct kevent *k_ev,
WaitEvent *event)
1174 k_ev->ident = SIGURG;
1175 k_ev->filter = EVFILT_SIGNAL;
1176 k_ev->flags = EV_ADD;
1179 AccessWaitEvent(k_ev) = event;
1189 struct kevent k_ev[2];
1191 bool new_filt_read =
false;
1192 bool old_filt_read =
false;
1193 bool new_filt_write =
false;
1194 bool old_filt_write =
false;
1196 if (old_events == event->
events)
1213 WaitEventAdjustKqueueAddPostmaster(&k_ev[count++], event);
1218 WaitEventAdjustKqueueAddLatch(&k_ev[count++], event);
1228 old_filt_read =
true;
1230 new_filt_read =
true;
1232 old_filt_write =
true;
1234 new_filt_write =
true;
1235 if (old_filt_read && !new_filt_read)
1236 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_READ, EV_DELETE,
1238 else if (!old_filt_read && new_filt_read)
1239 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_READ, EV_ADD,
1241 if (old_filt_write && !new_filt_write)
1242 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_WRITE, EV_DELETE,
1244 else if (!old_filt_write && new_filt_write)
1245 WaitEventAdjustKqueueAdd(&k_ev[count++], EVFILT_WRITE, EV_ADD,
1255 rc = kevent(set->kqueue_fd, &k_ev[0], count, NULL, 0, NULL);
1267 (errno == ESRCH || errno == EACCES))
1268 set->report_postmaster_not_running =
true;
1272 errmsg(
"%s() failed: %m",
1284 set->report_postmaster_not_running =
true;
1290 #if defined(WAIT_USE_WIN32)
1294 HANDLE *handle = &set->handles[
event->pos + 1];
1299 *handle = set->
latch->event;
1303 *handle = PostmasterHandle;
1307 int flags = FD_CLOSE;
1314 flags |= FD_CONNECT;
1316 if (*handle == WSA_INVALID_EVENT)
1318 *handle = WSACreateEvent();
1319 if (*handle == WSA_INVALID_EVENT)
1320 elog(
ERROR,
"failed to create event for socket: error code %d",
1323 if (WSAEventSelect(event->
fd, *handle, flags) != 0)
1324 elog(
ERROR,
"failed to set up event for socket: error code %d",
1346 WaitEvent *occurred_events,
int nevents,
1349 int returned_events = 0;
1352 long cur_timeout = -1;
1363 Assert(timeout >= 0 && timeout <= INT_MAX);
1364 cur_timeout = timeout;
1375 while (returned_events == 0)
1436 occurred_events, nevents);
1447 returned_events = rc;
1450 if (returned_events == 0 && timeout >= 0)
1455 if (cur_timeout <= 0)
1465 return returned_events;
1469 #if defined(WAIT_USE_EPOLL)
1481 WaitEvent *occurred_events,
int nevents)
1483 int returned_events = 0;
1486 struct epoll_event *cur_epoll_event;
1489 rc = epoll_wait(set->epoll_fd, set->epoll_ret_events,
1490 nevents, cur_timeout);
1501 errmsg(
"%s() failed: %m",
1517 for (cur_epoll_event = set->epoll_ret_events;
1518 cur_epoll_event < (set->epoll_ret_events + rc) &&
1519 returned_events < nevents;
1523 cur_event = (
WaitEvent *) cur_epoll_event->data.ptr;
1525 occurred_events->
pos = cur_event->
pos;
1527 occurred_events->
events = 0;
1530 cur_epoll_event->events & (EPOLLIN | EPOLLERR | EPOLLHUP))
1544 cur_epoll_event->events & (EPOLLIN | EPOLLERR | EPOLLHUP))
1574 (cur_epoll_event->events & (EPOLLIN | EPOLLERR | EPOLLHUP)))
1581 (cur_epoll_event->events & (EPOLLOUT | EPOLLERR | EPOLLHUP)))
1588 (cur_epoll_event->events & (EPOLLRDHUP | EPOLLERR | EPOLLHUP)))
1594 if (occurred_events->
events != 0)
1596 occurred_events->
fd = cur_event->
fd;
1603 return returned_events;
1606 #elif defined(WAIT_USE_KQUEUE)
1617 WaitEvent *occurred_events,
int nevents)
1619 int returned_events = 0;
1622 struct kevent *cur_kqueue_event;
1623 struct timespec timeout;
1624 struct timespec *timeout_p;
1626 if (cur_timeout < 0)
1630 timeout.tv_sec = cur_timeout / 1000;
1631 timeout.tv_nsec = (cur_timeout % 1000) * 1000000;
1632 timeout_p = &timeout;
1639 if (
unlikely(set->report_postmaster_not_running))
1649 rc = kevent(set->kqueue_fd, NULL, 0,
1650 set->kqueue_ret_events, nevents,
1662 errmsg(
"%s() failed: %m",
1678 for (cur_kqueue_event = set->kqueue_ret_events;
1679 cur_kqueue_event < (set->kqueue_ret_events + rc) &&
1680 returned_events < nevents;
1684 cur_event = AccessWaitEvent(cur_kqueue_event);
1686 occurred_events->
pos = cur_event->
pos;
1688 occurred_events->
events = 0;
1691 cur_kqueue_event->filter == EVFILT_SIGNAL)
1702 cur_kqueue_event->filter == EVFILT_PROC &&
1703 (cur_kqueue_event->fflags & NOTE_EXIT) != 0)
1710 set->report_postmaster_not_running =
true;
1726 (cur_kqueue_event->filter == EVFILT_READ))
1733 (cur_kqueue_event->filter == EVFILT_READ) &&
1734 (cur_kqueue_event->flags & EV_EOF))
1741 (cur_kqueue_event->filter == EVFILT_WRITE))
1747 if (occurred_events->
events != 0)
1749 occurred_events->
fd = cur_event->
fd;
1756 return returned_events;
1759 #elif defined(WAIT_USE_POLL)
1769 WaitEvent *occurred_events,
int nevents)
1771 int returned_events = 0;
1774 struct pollfd *cur_pollfd;
1777 rc = poll(set->pollfds, set->
nevents, (
int) cur_timeout);
1788 errmsg(
"%s() failed: %m",
1799 for (cur_event = set->
events, cur_pollfd = set->pollfds;
1801 returned_events < nevents;
1802 cur_event++, cur_pollfd++)
1805 if (cur_pollfd->revents == 0)
1808 occurred_events->
pos = cur_event->
pos;
1810 occurred_events->
events = 0;
1813 (cur_pollfd->revents & (POLLIN | POLLHUP | POLLERR | POLLNVAL)))
1827 (cur_pollfd->revents & (POLLIN | POLLHUP | POLLERR | POLLNVAL)))
1854 int errflags = POLLHUP | POLLERR | POLLNVAL;
1859 (cur_pollfd->revents & (POLLIN | errflags)))
1866 (cur_pollfd->revents & (POLLOUT | errflags)))
1874 (cur_pollfd->revents & (POLLRDHUP | errflags)))
1881 if (occurred_events->
events != 0)
1883 occurred_events->
fd = cur_event->
fd;
1889 return returned_events;
1892 #elif defined(WAIT_USE_WIN32)
1906 WaitEvent *occurred_events,
int nevents)
1908 int returned_events = 0;
1913 for (cur_event = set->
events;
1917 if (cur_event->reset)
1919 WaitEventAdjustWin32(set, cur_event);
1920 cur_event->reset =
false;
1944 r = WSASend(cur_event->
fd, &
buf, 1, &sent, 0, NULL, NULL);
1945 if (r == 0 || WSAGetLastError() != WSAEWOULDBLOCK)
1947 occurred_events->
pos = cur_event->
pos;
1950 occurred_events->
fd = cur_event->
fd;
1961 rc = WaitForMultipleObjects(set->
nevents + 1, set->handles, FALSE,
1965 if (rc == WAIT_FAILED)
1966 elog(
ERROR,
"WaitForMultipleObjects() failed: error code %lu",
1968 else if (rc == WAIT_TIMEOUT)
1974 if (rc == WAIT_OBJECT_0)
1987 occurred_events->
pos = cur_event->
pos;
1989 occurred_events->
events = 0;
1997 if (!ResetEvent(set->handles[cur_event->
pos + 1]))
1998 elog(
ERROR,
"ResetEvent failed: error code %lu", GetLastError());
2029 WSANETWORKEVENTS resEvents;
2030 HANDLE handle = set->handles[cur_event->
pos + 1];
2034 occurred_events->
fd = cur_event->
fd;
2036 ZeroMemory(&resEvents,
sizeof(resEvents));
2037 if (WSAEnumNetworkEvents(cur_event->
fd, handle, &resEvents) != 0)
2038 elog(
ERROR,
"failed to enumerate network events: error code %d",
2041 (resEvents.lNetworkEvents & FD_READ))
2056 cur_event->reset =
true;
2059 (resEvents.lNetworkEvents & FD_WRITE))
2065 (resEvents.lNetworkEvents & FD_CONNECT))
2070 if (resEvents.lNetworkEvents & FD_CLOSE)
2076 if (occurred_events->
events != 0)
2083 return returned_events;
2093 #if (defined(WAIT_USE_POLL) && defined(POLLRDHUP)) || \
2094 defined(WAIT_USE_EPOLL) || \
2095 defined(WAIT_USE_KQUEUE)
2111 #if defined(WAIT_USE_SELF_PIPE)
2121 int save_errno = errno;
2131 sendSelfPipeByte(
void)
2137 rc =
write(selfpipe_writefd, &dummy, 1);
2162 #if defined(WAIT_USE_SELF_PIPE) || defined(WAIT_USE_SIGNALFD)
2178 #ifdef WAIT_USE_SELF_PIPE
2179 fd = selfpipe_readfd;
2191 else if (errno ==
EINTR)
2196 #ifdef WAIT_USE_SELF_PIPE
2197 elog(
ERROR,
"read() on self-pipe failed: %m");
2199 elog(
ERROR,
"read() on signalfd failed: %m");
2206 #ifdef WAIT_USE_SELF_PIPE
2207 elog(
ERROR,
"unexpected EOF on self-pipe");
2209 elog(
ERROR,
"unexpected EOF on signalfd");
2212 else if (rc <
sizeof(
buf))
#define pg_memory_barrier()
#define StaticAssertStmt(condition, errmessage)
#define PG_USED_FOR_ASSERTS_ONLY
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)
struct timeval instr_time
#define INSTR_TIME_GET_MILLISEC(t)
void InitializeLatchWaitSet(void)
int WaitLatchOrSocket(Latch *latch, int wakeEvents, pgsocket sock, long timeout, uint32 wait_event_info)
#define LatchWaitSetLatchPos
void OwnLatch(Latch *latch)
void DisownLatch(Latch *latch)
int GetNumRegisteredWaitEvents(WaitEventSet *set)
WaitEventSet * CreateWaitEventSet(MemoryContext context, int nevents)
void InitSharedLatch(Latch *latch)
void InitializeLatchSupport(void)
static WaitEventSet * LatchWaitSet
void ModifyWaitEvent(WaitEventSet *set, int pos, uint32 events, Latch *latch)
static int WaitEventSetWaitBlock(WaitEventSet *set, int cur_timeout, WaitEvent *occurred_events, int nevents)
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)
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
Assert(fmt[strlen(fmt) - 1] !='\n')
void pfree(void *pointer)
MemoryContext TopMemoryContext
void * MemoryContextAllocZero(MemoryContext context, Size size)
MemoryContext CurrentMemoryContext
bool PostmasterIsAliveInternal(void)
#define PostmasterIsAlive()
int postmaster_alive_fds[2]
#define POSTMASTER_FD_WATCH
static int fd(const char *x, int i)
void pgwin32_dispatch_queued_signals(void)
HANDLE pgwin32_signal_event
pqsigfunc pqsignal(int signum, pqsigfunc handler)
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)