Implement epoll_pwait2.

PiperOrigin-RevId: 371216407

2 files changed, 60 insertions, 2 deletions

diff --git a/test/syscalls/linux/epoll.cc b/test/syscalls/linux/epoll.cc
index b180f633c..af3d27894 100644
--- a/test/syscalls/linux/epoll.cc
+++ b/test/syscalls/linux/epoll.cc
@@ -39,6 +39,15 @@ namespace {
 constexpr int kFDsPerEpoll = 3;
 constexpr uint64_t kMagicConstant = 0x0102030405060708;
 
+#ifndef SYS_epoll_pwait2
+#define SYS_epoll_pwait2 441
+#endif
+
+int epoll_pwait2(int fd, struct epoll_event* events, int maxevents,
+                 const struct timespec* timeout, const sigset_t* sigset) {
+  return syscall(SYS_epoll_pwait2, fd, events, maxevents, timeout, sigset);
+}
+
 TEST(EpollTest, AllWritable) {
   auto epollfd = ASSERT_NO_ERRNO_AND_VALUE(NewEpollFD());
   std::vector<FileDescriptor> eventfds;
@@ -144,6 +153,50 @@ TEST(EpollTest, Timeout) {
   EXPECT_GT(ms_elapsed(begin, end), kTimeoutMs - 1);
 }
 
+TEST(EpollTest, EpollPwait2Timeout) {
+  auto epollfd = ASSERT_NO_ERRNO_AND_VALUE(NewEpollFD());
+  // 200 milliseconds.
+  constexpr int kTimeoutNs = 200000000;
+  struct timespec timeout;
+  timeout.tv_sec = 0;
+  timeout.tv_nsec = 0;
+  struct timespec begin;
+  struct timespec end;
+  struct epoll_event result[kFDsPerEpoll];
+
+  std::vector<FileDescriptor> eventfds;
+  for (int i = 0; i < kFDsPerEpoll; i++) {
+    eventfds.push_back(ASSERT_NO_ERRNO_AND_VALUE(NewEventFD()));
+    ASSERT_NO_ERRNO(RegisterEpollFD(epollfd.get(), eventfds[i].get(), EPOLLIN,
+                                    kMagicConstant + i));
+  }
+
+  // Pass valid arguments so that the syscall won't be blocked indefinitely
+  // nor return errno EINVAL.
+  //
+  // The syscall returns immediately when timeout is zero,
+  // even if no events are available.
+  SKIP_IF(!IsRunningOnGvisor() &&
+          epoll_pwait2(epollfd.get(), result, kFDsPerEpoll, &timeout, nullptr) <
+              0 &&
+          errno == ENOSYS);
+
+  {
+    const DisableSave ds;  // Timing-related.
+    EXPECT_THAT(clock_gettime(CLOCK_MONOTONIC, &begin), SyscallSucceeds());
+
+    timeout.tv_nsec = kTimeoutNs;
+    ASSERT_THAT(RetryEINTR(epoll_pwait2)(epollfd.get(), result, kFDsPerEpoll,
+                                         &timeout, nullptr),
+                SyscallSucceedsWithValue(0));
+    EXPECT_THAT(clock_gettime(CLOCK_MONOTONIC, &end), SyscallSucceeds());
+  }
+
+  // Check the lower bound on the timeout.  Checking for an upper bound is
+  // fragile because Linux can overrun the timeout due to scheduling delays.
+  EXPECT_GT(ns_elapsed(begin, end), kTimeoutNs - 1);
+}
+
 void* writer(void* arg) {
   int fd = *reinterpret_cast<int*>(arg);
   uint64_t tmp = 1;
diff --git a/test/util/test_util.h b/test/util/test_util.h
index 876ff58db..bcbb388ed 100644
--- a/test/util/test_util.h
+++ b/test/util/test_util.h
@@ -272,10 +272,15 @@ PosixErrorOr<std::vector<OpenFd>> GetOpenFDs();
 // Returns the number of hard links to a path.
 PosixErrorOr<uint64_t> Links(const std::string& path);
 
+inline uint64_t ns_elapsed(const struct timespec& begin,
+                           const struct timespec& end) {
+  return (end.tv_sec - begin.tv_sec) * 1000000000 +
+         (end.tv_nsec - begin.tv_nsec);
+}
+
 inline uint64_t ms_elapsed(const struct timespec& begin,
                            const struct timespec& end) {
-  return (end.tv_sec - begin.tv_sec) * 1000 +
-         (end.tv_nsec - begin.tv_nsec) / 1000000;
+  return ns_elapsed(begin, end) / 1000000;
 }
 
 namespace internal {