michaelh/zephyr
1
0
Fork 0
Code Releases Activity

lib: posix: Update to new timeout API

Browse source 
Mostly trivial search-and-replace, except for pthread_rwlock.c, where
we need spread timeout over 2 semaphore operations.

Signed-off-by: Paul Sokolovsky <paul.sokolovsky@linaro.org>
This commit is contained in:
Paul Sokolovsky 2020-05-05 11:23:55 +03:00 • committed by Carles Cufí
commit 0b634793cc
7 changed files with 37 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

1
lib/posix/Kconfig
View file

@ -12,7 +12,6 @@ config POSIX_MAX_FDS
config POSIX_API
depends on !ARCH_POSIX
bool "POSIX APIs"
select LEGACY_TIMEOUT_API
help
Enable mostly-standards-compliant implementations of
various POSIX (IEEE 1003.1) APIs.

29
lib/posix/mqueue.c
View file

@ -33,9 +33,9 @@ sys_slist_t mq_list = SYS_SLIST_STATIC_INIT(&mq_list);
s64_t timespec_to_timeoutms(const struct timespec *abstime);
static mqueue_object *find_in_list(const char *name);
static s32_t send_message(mqueue_desc *mqd, const char *msg_ptr, size_t msg_len,
s32_t timeout);
k_timeout_t timeout);
static int receive_message(mqueue_desc *mqd, char *msg_ptr, size_t msg_len,
s32_t timeout);
k_timeout_t timeout);
static void remove_mq(mqueue_object *msg_queue);
/**
@ -233,9 +233,8 @@ int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len,
unsigned int msg_prio)
{
mqueue_desc *mqd = (mqueue_desc *)mqdes;
s32_t timeout = K_FOREVER;
return send_message(mqd, msg_ptr, msg_len, timeout);
return send_message(mqd, msg_ptr, msg_len, K_FOREVER);
}
/**
@ -249,10 +248,9 @@ 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;
s32_t timeout;
s32_t timeout = (s32_t) timespec_to_timeoutms(abstime);
timeout = (s32_t) timespec_to_timeoutms(abstime);
return send_message(mqd, msg_ptr, msg_len, timeout);
return send_message(mqd, msg_ptr, msg_len, K_MSEC(timeout));
}
/**
@ -266,10 +264,8 @@ int mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len,
unsigned int *msg_prio)
{
mqueue_desc *mqd = (mqueue_desc *)mqdes;
s32_t timeout = K_FOREVER;
return receive_message(mqd, msg_ptr, msg_len, timeout);
return receive_message(mqd, msg_ptr, msg_len, K_FOREVER);
}
/**
@ -283,10 +279,9 @@ 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;
s32_t timeout = K_NO_WAIT;
s32_t timeout = (s32_t) timespec_to_timeoutms(abstime);
timeout = (s32_t) timespec_to_timeoutms(abstime);
return receive_message(mqd, msg_ptr, msg_len, timeout);
return receive_message(mqd, msg_ptr, msg_len, K_MSEC(timeout));
}
/**
@ -366,7 +361,7 @@ static mqueue_object *find_in_list(const char *name)
}
static s32_t send_message(mqueue_desc *mqd, const char *msg_ptr, size_t msg_len,
s32_t timeout)
k_timeout_t timeout)
{
s32_t ret = -1;
@ -385,7 +380,7 @@ static s32_t send_message(mqueue_desc *mqd, const char *msg_ptr, size_t msg_len,
}
if (k_msgq_put(&mqd->mqueue->queue, (void *)msg_ptr, timeout) != 0) {
errno = (timeout == K_NO_WAIT) ? EAGAIN : ETIMEDOUT;
errno = K_TIMEOUT_EQ(timeout, K_NO_WAIT) ? EAGAIN : ETIMEDOUT;
return ret;
}
@ -393,7 +388,7 @@ static s32_t send_message(mqueue_desc *mqd, const char *msg_ptr, size_t msg_len,
}
static s32_t receive_message(mqueue_desc *mqd, char *msg_ptr, size_t msg_len,
s32_t timeout)
k_timeout_t timeout)
{
int ret = -1;
@ -412,7 +407,7 @@ static s32_t receive_message(mqueue_desc *mqd, char *msg_ptr, size_t msg_len,
}
if (k_msgq_get(&mqd->mqueue->queue, (void *)msg_ptr, timeout) != 0) {
errno = (timeout != K_NO_WAIT) ? ETIMEDOUT : EAGAIN;
errno = K_TIMEOUT_EQ(timeout, K_NO_WAIT) ? EAGAIN : ETIMEDOUT;
} else {
ret = mqd->mqueue->queue.msg_size;
}

4
lib/posix/pthread.c
View file

@ -24,7 +24,7 @@ static const pthread_attr_t init_pthread_attrs = {
.stack = NULL,
.stacksize = 0,
.flags = PTHREAD_INIT_FLAGS,
.delayedstart = K_NO_WAIT,
.delayedstart = 0,
#if defined(CONFIG_PREEMPT_ENABLED)
.schedpolicy = SCHED_RR,
#else
@ -190,7 +190,7 @@ int pthread_create(pthread_t *newthread, const pthread_attr_t *attr,
(void *)arg, NULL,
threadroutine, prio,
(~K_ESSENTIAL & attr->flags),
attr->delayedstart);
K_MSEC(attr->delayedstart));
return 0;
}

5
lib/posix/pthread_cond.c
View file

@ -11,7 +11,8 @@
s64_t timespec_to_timeoutms(const struct timespec *abstime);
static int cond_wait(pthread_cond_t *cv, pthread_mutex_t *mut, int timeout)
static int cond_wait(pthread_cond_t *cv, pthread_mutex_t *mut,
k_timeout_t timeout)
{
__ASSERT(mut->lock_count == 1U, "");
@ -78,5 +79,5 @@ int pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *mut,
const struct timespec *abstime)
{
s32_t timeout = (s32_t)timespec_to_timeoutms(abstime);
return cond_wait(cv, mut, timeout);
return cond_wait(cv, mut, K_MSEC(timeout));
}

6
lib/posix/pthread_mutex.c
View file

@ -20,7 +20,7 @@ static const pthread_mutexattr_t def_attr = {
.type = PTHREAD_MUTEX_DEFAULT,
};
static int acquire_mutex(pthread_mutex_t *m, int timeout)
static int acquire_mutex(pthread_mutex_t *m, k_timeout_t timeout)
{
int rc = 0, key = irq_lock();
@ -45,7 +45,7 @@ static int acquire_mutex(pthread_mutex_t *m, int timeout)
return rc;
}
if (timeout == K_NO_WAIT) {
if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
irq_unlock(key);
return EINVAL;
}
@ -78,7 +78,7 @@ int pthread_mutex_timedlock(pthread_mutex_t *m,
const struct timespec *abstime)
{
s32_t timeout = (s32_t)timespec_to_timeoutms(abstime);
return acquire_mutex(m, timeout);
return acquire_mutex(m, K_MSEC(timeout));
}
/**

24
lib/posix/pthread_rwlock.c
View file

@ -71,7 +71,7 @@ int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock)
return EINVAL;
}
return read_lock_acquire(rwlock, K_FOREVER);
return read_lock_acquire(rwlock, SYS_FOREVER_MS);
}
/**
@ -116,7 +116,7 @@ int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock)
return EINVAL;
}
return read_lock_acquire(rwlock, K_NO_WAIT);
return read_lock_acquire(rwlock, 0);
}
/**
@ -133,7 +133,7 @@ int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock)
return EINVAL;
}
return write_lock_acquire(rwlock, K_FOREVER);
return write_lock_acquire(rwlock, SYS_FOREVER_MS);
}
/**
@ -178,7 +178,7 @@ int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock)
return EINVAL;
}
return write_lock_acquire(rwlock, K_NO_WAIT);
return write_lock_acquire(rwlock, 0);
}
/**
@ -216,7 +216,7 @@ static u32_t read_lock_acquire(pthread_rwlock_t *rwlock, s32_t timeout)
{
u32_t ret = 0U;
if (k_sem_take(&rwlock->wr_sem, timeout) == 0) {
if (k_sem_take(&rwlock->wr_sem, SYS_TIMEOUT_MS(timeout)) == 0) {
k_sem_take(&rwlock->reader_active, K_NO_WAIT);
k_sem_take(&rwlock->rd_sem, K_NO_WAIT);
k_sem_give(&rwlock->wr_sem);
@ -231,17 +231,23 @@ static u32_t write_lock_acquire(pthread_rwlock_t *rwlock, s32_t timeout)
{
u32_t ret = 0U;
s64_t elapsed_time, st_time = k_uptime_get();
k_timeout_t k_timeout;
k_timeout = SYS_TIMEOUT_MS(timeout);
/* waiting for release of write lock */
if (k_sem_take(&rwlock->wr_sem, timeout) == 0) {
if (timeout > K_NO_WAIT) {
if (k_sem_take(&rwlock->wr_sem, k_timeout) == 0) {
/* update remaining timeout time for 2nd sem */
if (timeout != SYS_FOREVER_MS) {
elapsed_time = k_uptime_get() - st_time;
timeout = timeout <= elapsed_time ? K_NO_WAIT :
timeout = timeout <= elapsed_time ? 0 :
timeout - elapsed_time;
}
k_timeout = SYS_TIMEOUT_MS(timeout);
/* waiting for reader to complete operation */
if (k_sem_take(&rwlock->reader_active, timeout) == 0) {
if (k_sem_take(&rwlock->reader_active, k_timeout) == 0) {
rwlock->wr_owner = k_current_get();
} else {
k_sem_give(&rwlock->wr_sem);

4
lib/posix/semaphore.c
View file

@ -104,12 +104,12 @@ int sem_timedwait(sem_t *semaphore, struct timespec *abstime)
abstime_ms = (s64_t)_ts_to_ms(abstime);
if (abstime_ms <= current_ms) {
timeout = K_NO_WAIT;
timeout = 0;
} else {
timeout = (s32_t)(abstime_ms - current_ms);
}
if (k_sem_take(semaphore, timeout)) {
if (k_sem_take(semaphore, K_MSEC(timeout))) {
errno = ETIMEDOUT;
return -1;
}