posix: clock: move most implementations to clock_common.c

Move most implementations to clock_common.c in preparation for
moving gettimeofday() and clock_nanosleep() to different compilation
units.

We also take this as an opportunity to switch from using k_spinlock
to sys_sem.

Signed-off-by: Chris Friedt <[email protected]>

Author: cfriedt

lib/posix/options/CMakeLists.txt

@@ -115,6 +115,7 @@ endif()
 if (NOT CONFIG_TC_PROVIDES_POSIX_TIMERS)
   zephyr_library_sources_ifdef(CONFIG_POSIX_TIMERS
     clock.c
+    clock_common.c
     timer.c
     timespec_to_timeout.c
   )

lib/posix/options/clock.c

@@ -5,98 +5,18 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "posix_clock.h"
-
-#include <zephyr/kernel.h>
 #include <errno.h>
+#include <time.h>
+
 #include <zephyr/posix/time.h>
 #include <zephyr/posix/sys/time.h>
 #include <zephyr/posix/unistd.h>
-#include <zephyr/internal/syscall_handler.h>
-#include <zephyr/spinlock.h>
-
-/*
- * `k_uptime_get` returns a timestamp based on an always increasing
- * value from the system start.  To support the `CLOCK_REALTIME`
- * clock, this `rt_clock_base` records the time that the system was
- * started.  This can either be set via 'clock_settime', or could be
- * set from a real time clock, if such hardware is present.
- */
-static struct timespec rt_clock_base;
-static struct k_spinlock rt_clock_base_lock;
-
-/**
- * @brief Get clock time specified by clock_id.
- *
- * See IEEE 1003.1
- */
-int z_impl___posix_clock_get_base(clockid_t clock_id, struct timespec *base)
-{
-	switch (clock_id) {
-	case CLOCK_MONOTONIC:
-		base->tv_sec = 0;
-		base->tv_nsec = 0;
-		break;
-
-	case CLOCK_REALTIME:
-		K_SPINLOCK(&rt_clock_base_lock) {
-			*base = rt_clock_base;
-		}
-		break;
-
-	default:
-		errno = EINVAL;
-		return -1;
-	}
 
-	return 0;
-}
-
-#ifdef CONFIG_USERSPACE
-int z_vrfy___posix_clock_get_base(clockid_t clock_id, struct timespec *ts)
-{
-	K_OOPS(K_SYSCALL_MEMORY_WRITE(ts, sizeof(*ts)));
-	return z_impl___posix_clock_get_base(clock_id, ts);
-}
-#include <zephyr/syscalls/__posix_clock_get_base_mrsh.c>
-#endif
+extern int z_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp,
+			     struct timespec *rmtp);
+extern int z_clock_gettime(clockid_t clock_id, struct timespec *ts);
+extern int z_clock_settime(clockid_t clock_id, const struct timespec *tp);
 
-int z_clock_gettime(clockid_t clock_id, struct timespec *ts)
-{
-	struct timespec base;
-
-	switch (clock_id) {
-	case CLOCK_MONOTONIC:
-		base.tv_sec = 0;
-		base.tv_nsec = 0;
-		break;
-
-	case CLOCK_REALTIME:
-		(void)__posix_clock_get_base(clock_id, &base);
-		break;
-
-	default:
-		errno = EINVAL;
-		return -1;
-	}
-
-	uint64_t ticks = k_uptime_ticks();
-	uint64_t elapsed_secs = ticks / CONFIG_SYS_CLOCK_TICKS_PER_SEC;
-	uint64_t nremainder = ticks - elapsed_secs * CONFIG_SYS_CLOCK_TICKS_PER_SEC;
-
-	ts->tv_sec = (time_t) elapsed_secs;
-	/* For ns 32 bit conversion can be used since its smaller than 1sec. */
-	ts->tv_nsec = (int32_t) k_ticks_to_ns_floor32(nremainder);
-
-	ts->tv_sec += base.tv_sec;
-	ts->tv_nsec += base.tv_nsec;
-	if (ts->tv_nsec >= NSEC_PER_SEC) {
-		ts->tv_sec++;
-		ts->tv_nsec -= NSEC_PER_SEC;
-	}
-
-	return 0;
-}
 int clock_gettime(clockid_t clock_id, struct timespec *ts)
 {
 	return z_clock_gettime(clock_id, ts);
@@ -132,34 +52,6 @@ int clock_getres(clockid_t clock_id, struct timespec *res)
  * Note that only the `CLOCK_REALTIME` clock can be set using this
  * call.
  */
-int z_clock_settime(clockid_t clock_id, const struct timespec *tp)
-{
-	struct timespec base;
-	k_spinlock_key_t key;
-
-	if (clock_id != CLOCK_REALTIME) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	if (tp->tv_nsec < 0 || tp->tv_nsec >= NSEC_PER_SEC) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	uint64_t elapsed_nsecs = k_ticks_to_ns_floor64(k_uptime_ticks());
-	int64_t delta = (int64_t)NSEC_PER_SEC * tp->tv_sec + tp->tv_nsec
-		- elapsed_nsecs;
-
-	base.tv_sec = delta / NSEC_PER_SEC;
-	base.tv_nsec = delta % NSEC_PER_SEC;
-
-	key = k_spin_lock(&rt_clock_base_lock);
-	rt_clock_base = base;
-	k_spin_unlock(&rt_clock_base_lock, key);
-
-	return 0;
-}
 int clock_settime(clockid_t clock_id, const struct timespec *tp)
 {
 	return z_clock_settime(clock_id, tp);
@@ -194,105 +86,11 @@ int usleep(useconds_t useconds)
 	return 0;
 }
 
-/**
- * @brief Suspend execution for a nanosecond interval, or
- * until some absolute time relative to the specified clock.
- *
- * See IEEE 1003.1
- */
-int z_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp,
-			       struct timespec *rmtp)
-{
-	uint64_t ns;
-	uint64_t us;
-	uint64_t uptime_ns;
-	k_spinlock_key_t key;
-	const bool update_rmtp = rmtp != NULL;
-
-	if (!((clock_id == CLOCK_REALTIME) || (clock_id == CLOCK_MONOTONIC))) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	if (rqtp == NULL) {
-		errno = EFAULT;
-		return -1;
-	}
-
-	if ((rqtp->tv_sec < 0) || (rqtp->tv_nsec < 0) || (rqtp->tv_nsec >= NSEC_PER_SEC)) {
-		errno = EINVAL;
-		return -1;
-	}
-
-	if ((flags & TIMER_ABSTIME) == 0 && unlikely(rqtp->tv_sec >= ULLONG_MAX / NSEC_PER_SEC)) {
-		ns = rqtp->tv_nsec + NSEC_PER_SEC +
-		     (uint64_t)k_sleep(K_SECONDS(rqtp->tv_sec - 1)) * NSEC_PER_MSEC;
-	} else {
-		ns = (uint64_t)rqtp->tv_sec * NSEC_PER_SEC + rqtp->tv_nsec;
-	}
-
-	uptime_ns = k_ticks_to_ns_ceil64(sys_clock_tick_get());
-
-	if (flags & TIMER_ABSTIME && clock_id == CLOCK_REALTIME) {
-		key = k_spin_lock(&rt_clock_base_lock);
-		ns -= rt_clock_base.tv_sec * NSEC_PER_SEC + rt_clock_base.tv_nsec;
-		k_spin_unlock(&rt_clock_base_lock, key);
-	}
-
-	if ((flags & TIMER_ABSTIME) == 0) {
-		ns += uptime_ns;
-	}
-
-	if (ns <= uptime_ns) {
-		goto do_rmtp_update;
-	}
-
-	us = DIV_ROUND_UP(ns, NSEC_PER_USEC);
-	do {
-		us = k_sleep(K_TIMEOUT_ABS_US(us)) * 1000;
-	} while (us != 0);
-
-do_rmtp_update:
-	if (update_rmtp) {
-		rmtp->tv_sec = 0;
-		rmtp->tv_nsec = 0;
-	}
-
-	return 0;
-}
-
 int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
 {
 	return z_clock_nanosleep(CLOCK_MONOTONIC, 0, rqtp, rmtp);
 }
 
-int clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp,
-		    struct timespec *rmtp)
-{
-	return z_clock_nanosleep(clock_id, flags, rqtp, rmtp);
-}
-
-/**
- * @brief Get current real time.
- *
- * See IEEE 1003.1
- */
-int gettimeofday(struct timeval *tv, void *tz)
-{
-	struct timespec ts;
-	int res;
-
-	/* As per POSIX, "if tzp is not a null pointer, the behavior
-	 * is unspecified."  "tzp" is the "tz" parameter above. */
-	ARG_UNUSED(tz);
-
-	res = clock_gettime(CLOCK_REALTIME, &ts);
-	tv->tv_sec = ts.tv_sec;
-	tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC;
-
-	return res;
-}
-
 int clock_getcpuclockid(pid_t pid, clockid_t *clock_id)
 {
 	/* We don't allow any process ID but our own.  */
@@ -304,23 +102,3 @@ int clock_getcpuclockid(pid_t pid, clockid_t *clock_id)
 
 	return 0;
 }
-
-#ifdef CONFIG_ZTEST
-#include <zephyr/ztest.h>
-static void reset_clock_base(void)
-{
-	K_SPINLOCK(&rt_clock_base_lock) {
-		rt_clock_base = (struct timespec){0};
-	}
-}
-
-static void clock_base_reset_rule_after(const struct ztest_unit_test *test, void *data)
-{
-	ARG_UNUSED(test);
-	ARG_UNUSED(data);
-
-	reset_clock_base();
-}
-
-ZTEST_RULE(clock_base_reset_rule, NULL, clock_base_reset_rule_after);
-#endif /* CONFIG_ZTEST */