cosmopolitan/libc/calls/clock_nanosleep.c

/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8                                :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
│                                                                              │
│ Permission to use, copy, modify, and/or distribute this software for         │
│ any purpose with or without fee is hereby granted, provided that the         │
│ above copyright notice and this permission notice appear in all copies.      │
│                                                                              │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
│ PERFORMANCE OF THIS SOFTWARE.                                                │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/assert.h"
#include "libc/calls/cp.internal.h"
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timespec.internal.h"
#include "libc/dce.h"
#include "libc/errno.h"
#include "libc/intrin/describeflags.internal.h"
#include "libc/intrin/kprintf.h"
#include "libc/intrin/strace.internal.h"
#include "libc/intrin/weaken.h"
#include "libc/runtime/clktck.h"
#include "libc/sysv/consts/clock.h"
#include "libc/sysv/consts/timer.h"
#include "libc/sysv/errfuns.h"
#include "libc/thread/thread.h"

static int sys_clock_nanosleep(int clock, int flags,  //
                               const struct timespec *req,
                               struct timespec *rem) {
  int rc;
  BEGIN_CANCELATION_POINT;
  if (IsLinux() || IsFreebsd() || IsNetbsd()) {
    rc = __sys_clock_nanosleep(clock, flags, req, rem);
  } else if (IsXnu()) {
    rc = sys_clock_nanosleep_xnu(clock, flags, req, rem);
  } else if (IsOpenbsd()) {
    rc = sys_clock_nanosleep_openbsd(clock, flags, req, rem);
  } else if (IsWindows()) {
    rc = sys_clock_nanosleep_nt(clock, flags, req, rem);
  } else {
    rc = enosys();
  }
  if (rc > 0) {
    errno = rc;
    rc = -1;
  }
  // system call support might not detect cancelation on bsds
  if (rc == -1 && errno == EINTR &&      //
      _weaken(pthread_testcancel_np) &&  //
      _weaken(pthread_testcancel_np)()) {
    rc = ecanceled();
  }
  END_CANCELATION_POINT;
  STRACE("sys_clock_nanosleep(%s, %s, %s, [%s]) → %d% m",
         DescribeClockName(clock), DescribeSleepFlags(flags),
         DescribeTimespec(0, req), DescribeTimespec(rc, rem), rc);
  return rc;
}

static int cosmo_clock_nanosleep(int clock, int flags,
                                 const struct timespec *req,
                                 struct timespec *rem) {

  // pick clocks
  int time_clock;
  int sleep_clock;
  if (clock == CLOCK_REALTIME ||  //
      clock == CLOCK_REALTIME_PRECISE) {
    time_clock = clock;
    sleep_clock = CLOCK_REALTIME;
  } else if (clock == CLOCK_MONOTONIC ||  //
             clock == CLOCK_MONOTONIC_PRECISE) {
    time_clock = clock;
    sleep_clock = CLOCK_MONOTONIC;
  } else if (clock == CLOCK_REALTIME_COARSE ||  //
             clock == CLOCK_REALTIME_FAST) {
    return sys_clock_nanosleep(CLOCK_REALTIME, flags, req, rem);
  } else if (clock == CLOCK_MONOTONIC_COARSE ||  //
             clock == CLOCK_MONOTONIC_FAST) {
    return sys_clock_nanosleep(CLOCK_MONOTONIC, flags, req, rem);
  } else {
    return sys_clock_nanosleep(clock, flags, req, rem);
  }

  // sleep bulk of time in kernel
  struct timespec start, deadline, remain, waitfor, now;
  struct timespec quantum = timespec_fromnanos(1000000000 / CLK_TCK);
  unassert(!clock_gettime(time_clock, &start));
  deadline = flags & TIMER_ABSTIME ? *req : timespec_add(start, *req);
  if (timespec_cmp(start, deadline) >= 0) return 0;
  remain = timespec_sub(deadline, start);
  if (timespec_cmp(remain, quantum) > 0) {
    waitfor = timespec_sub(remain, quantum);
    if (sys_clock_nanosleep(sleep_clock, 0, &waitfor, rem) == -1) {
      if (!flags && rem && errno == EINTR) {
        *rem = timespec_add(*rem, quantum);
      }
      return -1;
    }
  }

  // spin through final scheduling quantum
  do unassert(!clock_gettime(time_clock, &now));
  while (timespec_cmp(now, deadline) < 0);
  return 0;
}

/**
 * Sleeps for particular amount of time.
 *
 * Here's how you could sleep for one second:
 *
 *     clock_nanosleep(0, 0, &(struct timespec){1}, 0);
 *
 * Your sleep will be interrupted automatically if you do something like
 * press ctrl-c during the wait. That's an `EINTR` error and it lets you
 * immediately react to status changes. This is always the case, even if
 * you're using `SA_RESTART` since this is a `@norestart` system call.
 *
 *     void OnCtrlC(int sig) {} // EINTR only happens after delivery
 *     signal(SIGINT, OnCtrlC); // do delivery rather than kill proc
 *     printf("save me from sleeping forever by pressing ctrl-c\n");
 *     clock_nanosleep(0, 0, &(struct timespec){INT_MAX}, 0);
 *     printf("you're my hero\n");
 *
 * If you want to perform an uninterruptible sleep without having to use
 * sigprocmask() to block all signals then this function provides a good
 * solution to that problem. For example:
 *
 *     struct timespec rel, now, abs;
 *     clock_gettime(CLOCK_REALTIME, &now);
 *     rel = timespec_frommillis(100);
 *     abs = timespec_add(now, rel);
 *     while (clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &abs, 0));
 *
 * will accurately spin on `EINTR` errors. That way you're not impeding
 * signal delivery and you're not loosing precision on the wait timeout.
 * This function has first-class support on Linux, FreeBSD, and NetBSD;
 * on OpenBSD it's good; on XNU it's bad; and on Windows it's ugly.
 *
 * @param clock may be
 *     - `CLOCK_REALTIME` to have nanosecond-accurate wall time sleeps
 *     - `CLOCK_REALTIME_COARSE` to not spin through scheduler quantum
 *     - `CLOCK_MONOTONIC` to base the sleep off the monotinic clock
 *     - `CLOCK_MONOTONIC_COARSE` to once again not do userspace spin
 * @param flags can be 0 for relative and `TIMER_ABSTIME` for absolute
 * @param req can be a relative or absolute time, depending on `flags`
 * @param rem shall be updated with the remainder of unslept time when
 *     (1) it's non-null; (2) `flags` is 0; and (3) -1 w/ `EINTR` is
 *     returned; if this function returns 0 then `rem` is undefined;
 *     if flags is `TIMER_ABSTIME` then `rem` is ignored
 * @return 0 on success, or errno on error
 * @raise EINTR when a signal got delivered while we were waiting
 * @raise ECANCELED if thread was cancelled in masked mode
 * @raise ENOTSUP if `clock` is known but we can't use it here
 * @raise EFAULT if `req` or null or bad memory was passed
 * @raise EINVAL if `clock` is unknown to current platform
 * @raise EINVAL if `flags` has an unrecognized value
 * @raise EINVAL if `req->tv_nsec ∉ [0,1000000000)`
 * @raise ENOSYS on bare metal
 * @cancelationpoint
 * @returnserrno
 * @norestart
 */
errno_t clock_nanosleep(int clock, int flags,        //
                        const struct timespec *req,  //
                        struct timespec *rem) {
  if (IsMetal()) {
    return ENOSYS;
  }
  if (clock == 127 ||              //
      (flags & ~TIMER_ABSTIME) ||  //
      req->tv_sec < 0 ||           //
      !(0 <= req->tv_nsec && req->tv_nsec <= 999999999)) {
    return EINVAL;
  }
  errno_t old = errno;
  int rc = cosmo_clock_nanosleep(clock, flags, req, rem);
  errno_t err = !rc ? 0 : errno;
  errno = old;
  return err;
}