Open source system call tests.

PiperOrigin-RevId: 224886231
Change-Id: I0fccb4d994601739d8b16b1d4e6b31f40297fb22

1 files changed, 155 insertions, 0 deletions

diff --git a/test/syscalls/linux/ppoll.cc b/test/syscalls/linux/ppoll.cc
new file mode 100644
index 000000000..f8c388c00
--- /dev/null
+++ b/test/syscalls/linux/ppoll.cc
@@ -0,0 +1,155 @@
+// Copyright 2018 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <poll.h>
+#include <signal.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+#include "gtest/gtest.h"
+#include "absl/time/time.h"
+#include "test/syscalls/linux/base_poll_test.h"
+#include "test/util/signal_util.h"
+#include "test/util/test_util.h"
+
+namespace gvisor {
+namespace testing {
+namespace {
+
+// Linux and glibc have a different idea of the sizeof sigset_t. When calling
+// the syscall directly, use what the kernel expects.
+unsigned kSigsetSize = SIGRTMAX / 8;
+
+// Linux ppoll(2) differs from the glibc wrapper function in that Linux updates
+// the timeout with the amount of time remaining. In order to test this behavior
+// we need to use the syscall directly.
+int syscallPpoll(struct pollfd* fds, nfds_t nfds, struct timespec* timeout_ts,
+                 const sigset_t* sigmask, unsigned mask_size) {
+  return syscall(SYS_ppoll, fds, nfds, timeout_ts, sigmask, mask_size);
+}
+
+class PpollTest : public BasePollTest {
+ protected:
+  void SetUp() override { BasePollTest::SetUp(); }
+  void TearDown() override { BasePollTest::TearDown(); }
+};
+
+TEST_F(PpollTest, InvalidFds) {
+  // fds is invalid because it's null, but we tell ppoll the length is non-zero.
+  struct timespec timeout = {};
+  sigset_t sigmask;
+  TEST_PCHECK(sigemptyset(&sigmask) == 0);
+  EXPECT_THAT(syscallPpoll(nullptr, 1, &timeout, &sigmask, kSigsetSize),
+              SyscallFailsWithErrno(EFAULT));
+  EXPECT_THAT(syscallPpoll(nullptr, -1, &timeout, &sigmask, kSigsetSize),
+              SyscallFailsWithErrno(EINVAL));
+}
+
+// See that when fds is null, ppoll behaves like sleep.
+TEST_F(PpollTest, NullFds) {
+  struct timespec timeout = absl::ToTimespec(absl::Milliseconds(10));
+  ASSERT_THAT(syscallPpoll(nullptr, 0, &timeout, nullptr, 0),
+              SyscallSucceeds());
+  EXPECT_EQ(timeout.tv_sec, 0);
+  EXPECT_EQ(timeout.tv_nsec, 0);
+}
+
+TEST_F(PpollTest, ZeroTimeout) {
+  struct timespec timeout = {};
+  ASSERT_THAT(syscallPpoll(nullptr, 0, &timeout, nullptr, 0),
+              SyscallSucceeds());
+  EXPECT_EQ(timeout.tv_sec, 0);
+  EXPECT_EQ(timeout.tv_nsec, 0);
+}
+
+// If random S/R interrupts the ppoll, SIGALRM may be delivered before ppoll
+// restarts, causing the ppoll to hang forever.
+TEST_F(PpollTest, NoTimeout_NoRandomSave) {
+  // When there's no timeout, ppoll may never return so set a timer.
+  SetTimer(absl::Milliseconds(100));
+  // See that we get interrupted by the timer.
+  ASSERT_THAT(syscallPpoll(nullptr, 0, nullptr, nullptr, 0),
+              SyscallFailsWithErrno(EINTR));
+  EXPECT_TRUE(TimerFired());
+}
+
+TEST_F(PpollTest, InvalidTimeoutNegative) {
+  struct timespec timeout = absl::ToTimespec(absl::Nanoseconds(-1));
+  EXPECT_THAT(syscallPpoll(nullptr, 0, &timeout, nullptr, 0),
+              SyscallFailsWithErrno(EINVAL));
+}
+
+TEST_F(PpollTest, InvalidTimeoutNotNormalized) {
+  struct timespec timeout = {0, 1000000001};
+  EXPECT_THAT(syscallPpoll(nullptr, 0, &timeout, nullptr, 0),
+              SyscallFailsWithErrno(EINVAL));
+}
+
+TEST_F(PpollTest, InvalidMaskSize) {
+  struct timespec timeout = {};
+  sigset_t sigmask;
+  TEST_PCHECK(sigemptyset(&sigmask) == 0);
+  EXPECT_THAT(syscallPpoll(nullptr, 0, &timeout, &sigmask, 128),
+              SyscallFailsWithErrno(EINVAL));
+}
+
+// Verify that signals blocked by the ppoll mask (that would otherwise be
+// allowed) do not interrupt ppoll.
+TEST_F(PpollTest, SignalMaskBlocksSignal) {
+  absl::Duration duration(absl::Seconds(30));
+  struct timespec timeout = absl::ToTimespec(duration);
+  absl::Duration timer_duration(absl::Seconds(10));
+
+  // Call with a mask that blocks SIGALRM. See that ppoll is not interrupted
+  // (i.e. returns 0) and that upon completion, the timer has fired.
+  sigset_t mask;
+  ASSERT_THAT(sigprocmask(0, nullptr, &mask), SyscallSucceeds());
+  TEST_PCHECK(sigaddset(&mask, SIGALRM) == 0);
+  SetTimer(timer_duration);
+  MaybeSave();
+  ASSERT_FALSE(TimerFired());
+  ASSERT_THAT(syscallPpoll(nullptr, 0, &timeout, &mask, kSigsetSize),
+              SyscallSucceeds());
+  EXPECT_TRUE(TimerFired());
+  EXPECT_EQ(absl::DurationFromTimespec(timeout), absl::Duration());
+}
+
+// Verify that signals allowed by the ppoll mask (that would otherwise be
+// blocked) interrupt ppoll.
+TEST_F(PpollTest, SignalMaskAllowsSignal) {
+  absl::Duration duration(absl::Seconds(30));
+  struct timespec timeout = absl::ToTimespec(duration);
+  absl::Duration timer_duration(absl::Seconds(10));
+
+  sigset_t mask;
+  ASSERT_THAT(sigprocmask(0, nullptr, &mask), SyscallSucceeds());
+
+  // Block SIGALRM.
+  auto cleanup =
+      ASSERT_NO_ERRNO_AND_VALUE(ScopedSignalMask(SIG_BLOCK, SIGALRM));
+
+  // Call with a mask that unblocks SIGALRM. See that ppoll is interrupted.
+  SetTimer(timer_duration);
+  MaybeSave();
+  ASSERT_FALSE(TimerFired());
+  ASSERT_THAT(syscallPpoll(nullptr, 0, &timeout, &mask, kSigsetSize),
+              SyscallFailsWithErrno(EINTR));
+  EXPECT_TRUE(TimerFired());
+  EXPECT_GT(absl::DurationFromTimespec(timeout), absl::Duration());
+}
+
+}  // namespace
+}  // namespace testing
+}  // namespace gvisor