lib: posix: clock: Refactor to use sys_realtime for realtime clock

The posix clock implementation uses k_uptime as its only source of
truth for time, tying clock monotonic 1-1 to k_uptime, and clock
realtime to (k_uptime + a reference/offset).

sys_realtime provides the zephyr version of a realtime clock, which
is managed by the kernel.

This commit refactors the posix clock implementation to offload the
realtime clock to sys_realtime, converting between a unix timestamp
in ms (sys_realtime) to a unix timestamp in struct timespec (posix
time).

A small adjustment to the posix common clock test suite to set the
realtime clock to the same time as clock monotonic was required
since the test suite can not support a clock which is not tied
1-1 to k_uptime.

Signed-off-by: Bjarki Arge Andreasen <[email protected]>

Author: bjarki-andreasen

lib/posix/options/CMakeLists.txt

@@ -2,10 +2,6 @@
 
 set(GEN_DIR ${ZEPHYR_BINARY_DIR}/include/generated)
 
-zephyr_syscall_header(
-  posix_clock.h
-)
-
 if(CONFIG_POSIX_API)
   zephyr_include_directories(${ZEPHYR_BASE}/include/zephyr/posix)
 endif()

lib/posix/options/Kconfig.timer

@@ -5,6 +5,7 @@
 
 menuconfig POSIX_TIMERS
 	bool "POSIX timers, clocks, and sleep functions"
+	select SYS_REALTIME
 	help
 	  Select 'y' here and Zephyr will provide implementations of clock_getres(), clock_gettime(),
 	  clock_settime(), nanosleep(), timer_create(), timer_delete(), timer_getoverrun(),

lib/posix/options/clock.c

@@ -5,97 +5,157 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include "posix_clock.h"
-
 #include <zephyr/kernel.h>
 #include <errno.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>
+#include <zephyr/sys/realtime.h>
+
+static bool __posix_clock_validate_timespec(const struct timespec *ts)
+{
+	return ts->tv_sec >= 0 && ts->tv_nsec >= 0 && ts->tv_nsec < NSEC_PER_SEC;
+}
+
+static void __posix_clock_k_ticks_to_timespec(struct timespec *ts, int64_t 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);
+}
+
+static void __posix_clock_get_monotonic(struct timespec *ts)
+{
+	__posix_clock_k_ticks_to_timespec(ts, k_uptime_ticks());
+}
+
+static void __posix_clock_msec_to_timespec(struct timespec *ts, const int64_t *ms)
+{
+	ts->tv_sec = *ms / MSEC_PER_SEC;
+	ts->tv_nsec = (*ms % MSEC_PER_SEC) * NSEC_PER_MSEC;
+}
+
+static uint64_t __posix_clock_timespec_to_usec(const struct timespec *ts)
+{
+	uint64_t usec;
+
+	usec = ts->tv_sec;
+	usec *= USEC_PER_SEC;
+	usec += DIV_ROUND_UP(ts->tv_nsec, NSEC_PER_USEC);
+	return usec;
+}
+
+static uint64_t __posix_clock_timespec_to_msec(const struct timespec *ts)
+{
+	uint64_t msec;
+
+	msec = ts->tv_sec;
+	msec *= MSEC_PER_SEC;
+	msec += DIV_ROUND_UP(ts->tv_nsec, NSEC_PER_MSEC);
+	return msec;
+}
+
+/* Check if a_ts is less than b_ts (a_ts < b_ts) */
+static bool __posix_clock_timespec_less_than(const struct timespec *a_ts,
+					     const struct timespec *b_ts)
+{
+	return (a_ts->tv_sec < b_ts->tv_sec) ||
+	       (a_ts->tv_sec == b_ts->tv_sec && a_ts->tv_nsec < b_ts->tv_nsec);
+}
 
 /*
- * `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.
+ * Subtract b_ts from a_ts placing result in res_ts (ret_ts = a_ts - b_ts)
+ * Presumes a_ts >= b_ts
  */
-static struct timespec rt_clock_base;
-static struct k_spinlock rt_clock_base_lock;
+static void __posix_clock_timespec_subtract(struct timespec *res_ts,
+					    const struct timespec *a_ts,
+					    const struct timespec *b_ts)
+{
+	res_ts->tv_sec = a_ts->tv_sec - b_ts->tv_sec;
 
-/**
- * @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)
+	if (b_ts->tv_nsec <= a_ts->tv_nsec) {
+		res_ts->tv_nsec = a_ts->tv_nsec - b_ts->tv_nsec;
+	} else {
+		res_ts->tv_sec--;
+		res_ts->tv_nsec = a_ts->tv_nsec + NSEC_PER_SEC - b_ts->tv_nsec;
+	}
+}
+
+/* Add b_ts to a_ts placing result in res_ts (ret_ts = a_ts + b_ts) */
+static void __posix_clock_timespec_add(struct timespec *res_ts,
+				       const struct timespec *a_ts,
+				       const struct timespec *b_ts)
 {
-	switch (clock_id) {
-	case CLOCK_MONOTONIC:
-		base->tv_sec = 0;
-		base->tv_nsec = 0;
-		break;
+	res_ts->tv_sec = a_ts->tv_sec + b_ts->tv_sec;
+	res_ts->tv_nsec = a_ts->tv_nsec + b_ts->tv_nsec;
 
-	case CLOCK_REALTIME:
-		K_SPINLOCK(&rt_clock_base_lock) {
-			*base = rt_clock_base;
-		}
-		break;
+	if (res_ts->tv_nsec >= NSEC_PER_SEC) {
+		res_ts->tv_sec++;
+		res_ts->tv_nsec -= NSEC_PER_SEC;
+	}
+}
 
-	default:
-		errno = EINVAL;
-		return -1;
+static void __posix_clock_timespec_copy(struct timespec *des_ts, const struct timespec *src_ts)
+{
+	des_ts->tv_sec = src_ts->tv_sec;
+	des_ts->tv_nsec = src_ts->tv_nsec;
+}
+
+static void __posix_clock_get_realtime(struct timespec *ts)
+{
+	int res;
+	int64_t timestamp_ms;
+
+	res = sys_realtime_get_timestamp(&timestamp_ms);
+	if (timestamp_ms < 0) {
+		/* timespec can't be negative */
+		ts->tv_sec = 0;
+		ts->tv_nsec = 0;
 	}
 
-	return 0;
+	__posix_clock_msec_to_timespec(ts, &timestamp_ms);
 }
 
-#ifdef CONFIG_USERSPACE
-int z_vrfy___posix_clock_get_base(clockid_t clock_id, struct timespec *ts)
+static int __posix_clock_set_realtime(const struct timespec *ts)
 {
-	K_OOPS(K_SYSCALL_MEMORY_WRITE(ts, sizeof(*ts)));
-	return z_impl___posix_clock_get_base(clock_id, ts);
+	int64_t timestamp_ms;
+	int res;
+
+	timestamp_ms = (int64_t)__posix_clock_timespec_to_msec(ts);
+
+	res = sys_realtime_set_timestamp(&timestamp_ms);
+	if (res < 0) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	return 0;
 }
-#include <zephyr/syscalls/__posix_clock_get_base_mrsh.c>
-#endif
 
 int clock_gettime(clockid_t clock_id, struct timespec *ts)
 {
-	struct timespec base;
+	int res;
 
 	switch (clock_id) {
 	case CLOCK_MONOTONIC:
-		base.tv_sec = 0;
-		base.tv_nsec = 0;
+		__posix_clock_get_monotonic(ts);
+		res = 0;
 		break;
 
 	case CLOCK_REALTIME:
-		(void)__posix_clock_get_base(clock_id, &base);
+		__posix_clock_get_realtime(ts);
+		res = 0;
 		break;
 
 	default:
 		errno = EINVAL;
-		return -1;
+		res = -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;
+	return res;
 }
 
 int clock_getres(clockid_t clock_id, struct timespec *res)
@@ -130,31 +190,12 @@ int clock_getres(clockid_t clock_id, struct timespec *res)
  */
 int clock_settime(clockid_t clock_id, const struct timespec *tp)
 {
-	struct timespec base;
-	k_spinlock_key_t key;
-
-	if (clock_id != CLOCK_REALTIME) {
+	if (clock_id != CLOCK_REALTIME || !__posix_clock_validate_timespec(tp)) {
 		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;
+	return __posix_clock_set_realtime(tp);
 }
 
 /*
@@ -195,10 +236,10 @@ int usleep(useconds_t useconds)
 static 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;
+	volatile uint64_t usec;
+	struct timespec clock_ts;
+	struct timespec rel_ts;
+	struct timespec abs_ts;
 	const bool update_rmtp = rmtp != NULL;
 
 	if (!(clock_id == CLOCK_REALTIME || clock_id == CLOCK_MONOTONIC)) {
@@ -211,42 +252,35 @@ static int __z_clock_nanosleep(clockid_t clock_id, int flags, const struct times
 		return -1;
 	}
 
-	if (rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 || rqtp->tv_nsec >= NSEC_PER_SEC) {
+	if (!__posix_clock_validate_timespec(rqtp)) {
 		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
-			+ k_sleep(K_SECONDS(rqtp->tv_sec - 1)) * NSEC_PER_MSEC;
-	} else {
-		ns = rqtp->tv_sec * NSEC_PER_SEC + rqtp->tv_nsec;
-	}
-
-	uptime_ns = k_cyc_to_ns_ceil64(k_cycle_get_32());
+	if ((flags & TIMER_ABSTIME) && clock_id == CLOCK_REALTIME) {
+		__posix_clock_get_realtime(&clock_ts);
 
-	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 (__posix_clock_timespec_less_than(rqtp, &clock_ts)) {
+			goto post_sleep;
+		}
 
-	if ((flags & TIMER_ABSTIME) == 0) {
-		ns += uptime_ns;
+		__posix_clock_timespec_subtract(&rel_ts, rqtp, &clock_ts);
+		__posix_clock_get_monotonic(&clock_ts);
+		__posix_clock_timespec_add(&abs_ts, &rel_ts, &clock_ts);
+	} else if (flags & TIMER_ABSTIME) {
+		__posix_clock_timespec_copy(&abs_ts, rqtp);
+	} else {
+		__posix_clock_get_monotonic(&clock_ts);
+		__posix_clock_timespec_add(&abs_ts, rqtp, &clock_ts);
 	}
 
-	if (ns <= uptime_ns) {
-		goto do_rmtp_update;
-	}
+	usec = __posix_clock_timespec_to_usec(&abs_ts);
 
-	us = DIV_ROUND_UP(ns, NSEC_PER_USEC);
 	do {
-		us = k_sleep(K_TIMEOUT_ABS_US(us)) * 1000;
-	} while (us != 0);
+		usec = k_sleep(K_TIMEOUT_ABS_US(usec)) * USEC_PER_MSEC;
+	} while (usec != 0);
 
-do_rmtp_update:
+post_sleep:
 	if (update_rmtp) {
 		rmtp->tv_sec = 0;
 		rmtp->tv_nsec = 0;
@@ -298,23 +332,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 */