posix + tests: correct timing functions to use CLOCK_REALTIME

Use `CLOCK_REALTIME` by default as per the POSIX specification for the
following functions:

* `mq_timedreceive()`
* `mq_timedsend()`
* `pthread_cond_timedwait()`
* `pthread_mutex_timedlock()`
* `pthread_rwlock_timedrdlock()`
* `pthread_rwlock_timedwrlock()`
* `sem_timedwait()`

and additionally for the following non-portable functions:

* `pthread_timedjoin_np()`

Signed-off-by: Chris Friedt <cfriedt@tenstorrent.com>

Author: cfriedt

include/zephyr/posix/time.h

@@ -85,11 +85,6 @@ extern "C" {
 #define TIMER_ABSTIME 4
 #endif
 
-static inline int32_t _ts_to_ms(const struct timespec *to)
-{
-	return (int32_t)(to->tv_sec * MSEC_PER_SEC) + (int32_t)(to->tv_nsec / NSEC_PER_MSEC);
-}
-
 int clock_gettime(clockid_t clock_id, struct timespec *ts);
 int clock_getres(clockid_t clock_id, struct timespec *ts);
 int clock_settime(clockid_t clock_id, const struct timespec *ts);

lib/posix/options/cond.c

@@ -7,6 +7,8 @@
 
 #include "posix_internal.h"
 
+#include <stdbool.h>
+
 #include <zephyr/init.h>
 #include <zephyr/kernel.h>
 #include <zephyr/logging/log.h>
@@ -15,10 +17,7 @@
 
 LOG_MODULE_REGISTER(pthread_cond, CONFIG_PTHREAD_COND_LOG_LEVEL);
 
-int64_t timespec_to_timeoutms(const struct timespec *abstime);
-
-__pinned_bss
-static struct k_condvar posix_cond_pool[CONFIG_MAX_PTHREAD_COND_COUNT];
+__pinned_bss static struct posix_cond posix_cond_pool[CONFIG_MAX_PTHREAD_COND_COUNT];
 
 SYS_BITARRAY_DEFINE_STATIC(posix_cond_bitarray, CONFIG_MAX_PTHREAD_COND_COUNT);
 
@@ -30,7 +29,7 @@ SYS_BITARRAY_DEFINE_STATIC(posix_cond_bitarray, CONFIG_MAX_PTHREAD_COND_COUNT);
 BUILD_ASSERT(CONFIG_MAX_PTHREAD_COND_COUNT < PTHREAD_OBJ_MASK_INIT,
 	     "CONFIG_MAX_PTHREAD_COND_COUNT is too high");
 
-static inline size_t posix_cond_to_offset(struct k_condvar *cv)
+static inline size_t posix_cond_to_offset(struct posix_cond *cv)
 {
 	return cv - posix_cond_pool;
 }
@@ -40,7 +39,7 @@ static inline size_t to_posix_cond_idx(pthread_cond_t cond)
 	return mark_pthread_obj_uninitialized(cond);
 }
 
-static struct k_condvar *get_posix_cond(pthread_cond_t cond)
+static struct posix_cond *get_posix_cond(pthread_cond_t cond)
 {
 	int actually_initialized;
 	size_t bit = to_posix_cond_idx(cond);
@@ -66,10 +65,30 @@ static struct k_condvar *get_posix_cond(pthread_cond_t cond)
 	return &posix_cond_pool[bit];
 }
 
-static struct k_condvar *to_posix_cond(pthread_cond_t *cvar)
+static inline bool is_posix_condattr_valid(struct posix_condattr *attr)
+{
+	if (attr == NULL) {
+		return false;
+	}
+
+	if (!attr->initialized) {
+		LOG_DBG("condattr is not initialized");
+		return false;
+	}
+
+	/* revisit when POSIX_CLOCK_SELECTION is reworked */
+	if (!((attr->clock == CLOCK_REALTIME) || (attr->clock == CLOCK_MONOTONIC))) {
+		LOG_DBG("condattr clock %u is invalid", attr->clock);
+		return false;
+	}
+
+	return true;
+}
+
+static struct posix_cond *to_posix_cond(pthread_cond_t *cvar)
 {
 	size_t bit;
-	struct k_condvar *cv;
+	struct posix_cond *cv;
 
 	if (*cvar != PTHREAD_COND_INITIALIZER) {
 		return get_posix_cond(*cvar);
@@ -85,24 +104,35 @@ static struct k_condvar *to_posix_cond(pthread_cond_t *cvar)
 	/* Record the associated posix_cond in mu and mark as initialized */
 	*cvar = mark_pthread_obj_initialized(bit);
 	cv = &posix_cond_pool[bit];
+	(void)pthread_condattr_init((pthread_condattr_t *)&cv->attr);
 
 	return cv;
 }
 
-static int cond_wait(pthread_cond_t *cond, pthread_mutex_t *mu, k_timeout_t timeout)
+static int cond_wait(pthread_cond_t *cond, pthread_mutex_t *mu, const struct timespec *abstime)
 {
 	int ret;
 	struct k_mutex *m;
-	struct k_condvar *cv;
+	struct posix_cond *cv;
+	k_timeout_t timeout = K_FOREVER;
 
 	m = to_posix_mutex(mu);
 	cv = to_posix_cond(cond);
 	if (cv == NULL || m == NULL) {
 		return EINVAL;
 	}
 
+	if (abstime != NULL) {
+		if (!is_timespec_valid(abstime)) {
+			LOG_DBG("%s is invalid", "abstime");
+			return EINVAL;
+		}
+
+		timeout = K_MSEC((int32_t)timespec_to_timeoutms(cv->attr.clock, abstime));
+	}
+
 	LOG_DBG("Waiting on cond %p with timeout %llx", cv, timeout.ticks);
-	ret = k_condvar_wait(cv, m, timeout);
+	ret = k_condvar_wait(&cv->condvar, m, timeout);
 	if (ret == -EAGAIN) {
 		LOG_DBG("Timeout waiting on cond %p", cv);
 		ret = ETIMEDOUT;
@@ -120,15 +150,15 @@ static int cond_wait(pthread_cond_t *cond, pthread_mutex_t *mu, k_timeout_t time
 int pthread_cond_signal(pthread_cond_t *cvar)
 {
 	int ret;
-	struct k_condvar *cv;
+	struct posix_cond *cv;
 
 	cv = to_posix_cond(cvar);
 	if (cv == NULL) {
 		return EINVAL;
 	}
 
 	LOG_DBG("Signaling cond %p", cv);
-	ret = k_condvar_signal(cv);
+	ret = k_condvar_signal(&cv->condvar);
 	if (ret < 0) {
 		LOG_DBG("k_condvar_signal() failed: %d", ret);
 		return -ret;
@@ -142,15 +172,15 @@ int pthread_cond_signal(pthread_cond_t *cvar)
 int pthread_cond_broadcast(pthread_cond_t *cvar)
 {
 	int ret;
-	struct k_condvar *cv;
+	struct posix_cond *cv;
 
 	cv = get_posix_cond(*cvar);
 	if (cv == NULL) {
 		return EINVAL;
 	}
 
 	LOG_DBG("Broadcasting on cond %p", cv);
-	ret = k_condvar_broadcast(cv);
+	ret = k_condvar_broadcast(&cv->condvar);
 	if (ret < 0) {
 		LOG_DBG("k_condvar_broadcast() failed: %d", ret);
 		return -ret;
@@ -163,27 +193,33 @@ int pthread_cond_broadcast(pthread_cond_t *cvar)
 
 int pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mut)
 {
-	return cond_wait(cv, mut, K_FOREVER);
+	return cond_wait(cv, mut, NULL);
 }
 
 int pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *mut, const struct timespec *abstime)
 {
-	return cond_wait(cv, mut, K_MSEC((int32_t)timespec_to_timeoutms(abstime)));
+	return cond_wait(cv, mut, abstime);
 }
 
 int pthread_cond_init(pthread_cond_t *cvar, const pthread_condattr_t *att)
 {
-	struct k_condvar *cv;
+	struct posix_cond *cv;
 
-	ARG_UNUSED(att);
 	*cvar = PTHREAD_COND_INITIALIZER;
-
-	/* calls k_condvar_init() */
 	cv = to_posix_cond(cvar);
 	if (cv == NULL) {
 		return ENOMEM;
 	}
 
+	if (att != NULL) {
+		if (!is_posix_condattr_valid((struct posix_condattr *)att)) {
+			LOG_ERR("%s invalid", "pthread_condattr_t");
+			return EINVAL;
+		}
+
+		cv->attr = *((const struct posix_condattr *)att);
+	}
+
 	LOG_DBG("Initialized cond %p", cv);
 
 	return 0;
@@ -193,7 +229,7 @@ int pthread_cond_destroy(pthread_cond_t *cvar)
 {
 	int err;
 	size_t bit;
-	struct k_condvar *cv;
+	struct posix_cond *cv;
 
 	cv = get_posix_cond(*cvar);
 	if (cv == NULL) {
@@ -218,7 +254,7 @@ static int pthread_cond_pool_init(void)
 	size_t i;
 
 	for (i = 0; i < CONFIG_MAX_PTHREAD_COND_COUNT; ++i) {
-		err = k_condvar_init(&posix_cond_pool[i]);
+		err = k_condvar_init(&posix_cond_pool[i].condvar);
 		__ASSERT_NO_MSG(err == 0);
 	}
 
@@ -229,33 +265,56 @@ int pthread_condattr_init(pthread_condattr_t *att)
 {
 	__ASSERT_NO_MSG(att != NULL);
 
-	att->clock = CLOCK_MONOTONIC;
+	struct posix_condattr *const attr = (struct posix_condattr *)att;
+
+	attr->clock = CLOCK_REALTIME;
+	attr->initialized = true;
 
 	return 0;
 }
 
 int pthread_condattr_destroy(pthread_condattr_t *att)
 {
-	ARG_UNUSED(att);
+	struct posix_condattr *const attr = (struct posix_condattr *)att;
+
+	if (attr == NULL) {
+		return EINVAL;
+	}
+
+	*attr = (struct posix_condattr){0};
 
 	return 0;
 }
 
 int pthread_condattr_getclock(const pthread_condattr_t *ZRESTRICT att,
 		clockid_t *ZRESTRICT clock_id)
 {
-	*clock_id = att->clock;
+	struct posix_condattr *const attr = (struct posix_condattr *)att;
+
+	if ((attr == NULL) || !attr->initialized) {
+		LOG_DBG("condattr is not initialized");
+		return EINVAL;
+	}
+
+	*clock_id = attr->clock;
 
 	return 0;
 }
 
 int pthread_condattr_setclock(pthread_condattr_t *att, clockid_t clock_id)
 {
+	struct posix_condattr *const attr = (struct posix_condattr *)att;
+
 	if (clock_id != CLOCK_REALTIME && clock_id != CLOCK_MONOTONIC) {
 		return -EINVAL;
 	}
 
-	att->clock = clock_id;
+	if ((attr == NULL) || !attr->initialized) {
+		LOG_DBG("condattr is not initialized");
+		return EINVAL;
+	}
+
+	attr->clock = clock_id;
 
 	return 0;
 }

lib/posix/options/mqueue.c

@@ -4,6 +4,9 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
+
+#include "posix_internal.h"
+
 #include <zephyr/kernel.h>
 #include <errno.h>
 #include <string.h>
@@ -34,7 +37,6 @@ K_SEM_DEFINE(mq_sem, 1, 1);
 /* Initialize the list */
 sys_slist_t mq_list = SYS_SLIST_STATIC_INIT(&mq_list);
 
-int64_t timespec_to_timeoutms(const struct timespec *abstime);
 static mqueue_object *find_in_list(const char *name);
 static int32_t send_message(mqueue_desc *mqd, const char *msg_ptr, size_t msg_len,
 			  k_timeout_t timeout);
@@ -254,10 +256,15 @@ int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len,
 int mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len,
 		 unsigned int msg_prio, const struct timespec *abstime)
 {
-	mqueue_desc *mqd = (mqueue_desc *)mqdes;
-	int32_t timeout = (int32_t) timespec_to_timeoutms(abstime);
+	mqueue_desc *const mqd = (mqueue_desc *)mqdes;
+
+	if (!is_timespec_valid(abstime)) {
+		errno = EINVAL;
+		return -1;
+	}
 
-	return send_message(mqd, msg_ptr, msg_len, K_MSEC(timeout));
+	return send_message(mqd, msg_ptr, msg_len,
+			    K_MSEC(timespec_to_timeoutms(CLOCK_REALTIME, abstime)));
 }
 
 /**
@@ -285,10 +292,15 @@ int mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len,
 int mq_timedreceive(mqd_t mqdes, char *msg_ptr, size_t msg_len,
 			unsigned int *msg_prio, const struct timespec *abstime)
 {
-	mqueue_desc *mqd = (mqueue_desc *)mqdes;
-	int32_t timeout = (int32_t) timespec_to_timeoutms(abstime);
+	mqueue_desc *const mqd = (mqueue_desc *)mqdes;
+
+	if (!is_timespec_valid(abstime)) {
+		errno = EINVAL;
+		return -1;
+	}
 
-	return receive_message(mqd, msg_ptr, msg_len, K_MSEC(timeout));
+	return receive_message(mqd, msg_ptr, msg_len,
+			       K_MSEC((int32_t)timespec_to_timeoutms(CLOCK_REALTIME, abstime)));
 }
 
 /**

lib/posix/options/mutex.c

@@ -18,8 +18,6 @@ LOG_MODULE_REGISTER(pthread_mutex, CONFIG_PTHREAD_MUTEX_LOG_LEVEL);
 
 static SYS_SEM_DEFINE(lock, 1, 1);
 
-int64_t timespec_to_timeoutms(const struct timespec *abstime);
-
 #define MUTEX_MAX_REC_LOCK 32767
 
 /*
@@ -141,7 +139,7 @@ static int acquire_mutex(pthread_mutex_t *mu, k_timeout_t timeout)
 		case PTHREAD_MUTEX_NORMAL:
 			if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
 				LOG_DBG("Timeout locking mutex %p", m);
-				ret = EBUSY;
+				ret = ETIMEDOUT;
 				break;
 			}
 			/* On most POSIX systems, this usually results in an infinite loop */
@@ -212,8 +210,15 @@ int pthread_mutex_trylock(pthread_mutex_t *m)
 int pthread_mutex_timedlock(pthread_mutex_t *m,
 			    const struct timespec *abstime)
 {
-	int32_t timeout = (int32_t)timespec_to_timeoutms(abstime);
-	return acquire_mutex(m, K_MSEC(timeout));
+	__ASSERT(m != NULL, "%s is NULL", "mutex");
+	__ASSERT(abstime != NULL, "%s is NULL", "abstime");
+
+	if (!is_timespec_valid(abstime)) {
+		LOG_DBG("%s is invalid", "abstime");
+		return EINVAL;
+	}
+
+	return acquire_mutex(m, K_MSEC(timespec_to_timeoutms(CLOCK_REALTIME, abstime)));
 }
 
 /**