gvisor/test/syscalls/linux/clock_nanosleep.cc

// 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 <time.h>

#include <atomic>
#include <utility>

#include "gtest/gtest.h"
#include "absl/time/time.h"
#include "test/util/cleanup.h"
#include "test/util/posix_error.h"
#include "test/util/signal_util.h"
#include "test/util/test_util.h"
#include "test/util/thread_util.h"
#include "test/util/timer_util.h"

namespace gvisor {
namespace testing {

namespace {

// sys_clock_nanosleep is defined because the glibc clock_nanosleep returns
// error numbers directly and does not set errno. This makes our Syscall
// matchers look a little weird when expecting failure:
// "SyscallSucceedsWithValue(ERRNO)".
int sys_clock_nanosleep(clockid_t clkid, int flags,
                        const struct timespec* request,
                        struct timespec* remain) {
  return syscall(SYS_clock_nanosleep, clkid, flags, request, remain);
}

PosixErrorOr<absl::Time> GetTime(clockid_t clk) {
  struct timespec ts = {};
  int rc = clock_gettime(clk, &ts);
  MaybeSave();
  if (rc < 0) {
    return PosixError(errno, "clock_gettime");
  }
  return absl::TimeFromTimespec(ts);
}

class WallClockNanosleepTest : public ::testing::TestWithParam<clockid_t> {};

TEST_P(WallClockNanosleepTest, InvalidValues) {
  const struct timespec invalid[] = {
      {.tv_sec = -1, .tv_nsec = -1},       {.tv_sec = 0, .tv_nsec = INT32_MIN},
      {.tv_sec = 0, .tv_nsec = INT32_MAX}, {.tv_sec = 0, .tv_nsec = -1},
      {.tv_sec = -1, .tv_nsec = 0},
  };

  for (auto const ts : invalid) {
    EXPECT_THAT(sys_clock_nanosleep(GetParam(), 0, &ts, nullptr),
                SyscallFailsWithErrno(EINVAL));
  }
}

TEST_P(WallClockNanosleepTest, SleepOneSecond) {
  absl::Duration const duration = absl::Seconds(1);
  struct timespec dur = absl::ToTimespec(duration);

  absl::Time const before = ASSERT_NO_ERRNO_AND_VALUE(GetTime(GetParam()));
  EXPECT_THAT(RetryEINTR(sys_clock_nanosleep)(GetParam(), 0, &dur, &dur),
              SyscallSucceeds());
  absl::Time const after = ASSERT_NO_ERRNO_AND_VALUE(GetTime(GetParam()));

  EXPECT_GE(after - before, duration);
}

TEST_P(WallClockNanosleepTest, InterruptedNanosleep) {
  absl::Duration const duration = absl::Seconds(60);
  struct timespec dur = absl::ToTimespec(duration);

  // Install no-op signal handler for SIGALRM.
  struct sigaction sa = {};
  sigfillset(&sa.sa_mask);
  sa.sa_handler = +[](int signo) {};
  auto const cleanup_sa =
      ASSERT_NO_ERRNO_AND_VALUE(ScopedSigaction(SIGALRM, sa));

  // Measure time since setting the alarm, since the alarm will interrupt the
  // sleep and hence determine how long we sleep.
  absl::Time const before = ASSERT_NO_ERRNO_AND_VALUE(GetTime(GetParam()));

  // Set an alarm to go off while sleeping.
  struct itimerval timer = {};
  timer.it_value.tv_sec = 1;
  timer.it_value.tv_usec = 0;
  timer.it_interval.tv_sec = 1;
  timer.it_interval.tv_usec = 0;
  auto const cleanup =
      ASSERT_NO_ERRNO_AND_VALUE(ScopedItimer(ITIMER_REAL, timer));

  EXPECT_THAT(sys_clock_nanosleep(GetParam(), 0, &dur, &dur),
              SyscallFailsWithErrno(EINTR));
  absl::Time const after = ASSERT_NO_ERRNO_AND_VALUE(GetTime(GetParam()));

  absl::Duration const remaining = absl::DurationFromTimespec(dur);
  EXPECT_GE(after - before + remaining, duration);
}

TEST_P(WallClockNanosleepTest, SleepUntil) {
  absl::Time const now = ASSERT_NO_ERRNO_AND_VALUE(GetTime(GetParam()));
  absl::Time const until = now + absl::Seconds(2);
  struct timespec ts = absl::ToTimespec(until);

  EXPECT_THAT(
      RetryEINTR(sys_clock_nanosleep)(GetParam(), TIMER_ABSTIME, &ts, nullptr),
      SyscallSucceeds());
  absl::Time const after = ASSERT_NO_ERRNO_AND_VALUE(GetTime(GetParam()));

  EXPECT_GE(after, until);
}

INSTANTIATE_TEST_CASE_P(Sleepers, WallClockNanosleepTest,
                        ::testing::Values(CLOCK_REALTIME, CLOCK_MONOTONIC));

TEST(ClockNanosleepProcessTest, SleepFiveSeconds) {
  absl::Duration const kDuration = absl::Seconds(5);
  struct timespec dur = absl::ToTimespec(kDuration);

  // Ensure that CLOCK_PROCESS_CPUTIME_ID advances.
  std::atomic<bool> done(false);
  ScopedThread t([&] {
    while (!done.load()) {
    }
  });
  auto const cleanup_done = Cleanup([&] { done.store(true); });

  absl::Time const before =
      ASSERT_NO_ERRNO_AND_VALUE(GetTime(CLOCK_PROCESS_CPUTIME_ID));
  EXPECT_THAT(
      RetryEINTR(sys_clock_nanosleep)(CLOCK_PROCESS_CPUTIME_ID, 0, &dur, &dur),
      SyscallSucceeds());
  absl::Time const after =
      ASSERT_NO_ERRNO_AND_VALUE(GetTime(CLOCK_PROCESS_CPUTIME_ID));
  EXPECT_GE(after - before, kDuration);
}
}  // namespace

}  // namespace testing
}  // namespace gvisor