From 84e7107b32f9babdab7c74a7b2a3f96df1f5172b Mon Sep 17 00:00:00 2001 From: Alberto Escolar Piedras Date: Tue, 23 Apr 2024 16:06:38 +0200 Subject: [PATCH] Revert "posix: use sys_sem instead of k_spinlock for pool synch" This reverts commit 6e66aa1f7c15792a4f173355d05f6feb907811e5. And fixes an indentation issue in the original code, which triggers checkpatch. This PR: https://github.com/zephyrproject-rtos/zephyr/pull/71718 introduced a regression breaking CI: https://github.com/zephyrproject-rtos/zephyr/issues/71814 Let's just revert it until a better fix is done. Signed-off-by: Alberto Escolar Piedras --- lib/posix/options/key.c | 145 +++++++++++++++++++----------------- lib/posix/options/mutex.c | 47 +++++------- lib/posix/options/pthread.c | 122 +++++++++++++++--------------- lib/posix/options/rwlock.c | 7 +- 4 files changed, 161 insertions(+), 160 deletions(-) diff --git a/lib/posix/options/key.c b/lib/posix/options/key.c index aa87e930e2..5e68381c53 100644 --- a/lib/posix/options/key.c +++ b/lib/posix/options/key.c @@ -11,7 +11,6 @@ #include #include #include -#include struct pthread_key_data { sys_snode_t node; @@ -20,7 +19,7 @@ struct pthread_key_data { LOG_MODULE_REGISTER(pthread_key, CONFIG_PTHREAD_KEY_LOG_LEVEL); -static SYS_SEM_DEFINE(pthread_key_lock, 1, 1); +static struct k_spinlock pthread_key_lock; /* This is non-standard (i.e. an implementation detail) */ #define PTHREAD_KEY_INITIALIZER (-1) @@ -129,40 +128,42 @@ int pthread_key_create(pthread_key_t *key, int pthread_key_delete(pthread_key_t key) { size_t bit; - int ret = 0; - pthread_key_obj *key_obj = NULL; + __unused int ret; + pthread_key_obj *key_obj; struct pthread_key_data *key_data; sys_snode_t *node_l, *next_node_l; + k_spinlock_key_t key_key; - SYS_SEM_LOCK(&pthread_key_lock) { - key_obj = get_posix_key(key); - if (key_obj == NULL) { - ret = EINVAL; - SYS_SEM_LOCK_BREAK; - } + key_key = k_spin_lock(&pthread_key_lock); - /* Delete thread-specific elements associated with the key */ - SYS_SLIST_FOR_EACH_NODE_SAFE(&(key_obj->key_data_l), node_l, next_node_l) { - - /* Remove the object from the list key_data_l */ - key_data = (struct pthread_key_data *)sys_slist_get(&(key_obj->key_data_l)); - - /* Deallocate the object's memory */ - k_free((void *)key_data); - LOG_DBG("Freed key data %p for key %x in thread %x", key_data, key, - pthread_self()); - } - - bit = posix_key_to_offset(key_obj); - ret = sys_bitarray_free(&posix_key_bitarray, 1, bit); - __ASSERT_NO_MSG(ret == 0); + key_obj = get_posix_key(key); + if (key_obj == NULL) { + k_spin_unlock(&pthread_key_lock, key_key); + return EINVAL; } - if (ret == 0) { - LOG_DBG("Deleted key %p (%x)", key_obj, key); + /* Delete thread-specific elements associated with the key */ + SYS_SLIST_FOR_EACH_NODE_SAFE(&(key_obj->key_data_l), + node_l, next_node_l) { + + /* Remove the object from the list key_data_l */ + key_data = (struct pthread_key_data *) + sys_slist_get(&(key_obj->key_data_l)); + + /* Deallocate the object's memory */ + k_free((void *)key_data); + LOG_DBG("Freed key data %p for key %x in thread %x", key_data, key, pthread_self()); } - return ret; + bit = posix_key_to_offset(key_obj); + ret = sys_bitarray_free(&posix_key_bitarray, 1, bit); + __ASSERT_NO_MSG(ret == 0); + + k_spin_unlock(&pthread_key_lock, key_key); + + LOG_DBG("Deleted key %p (%x)", key_obj, key); + + return 0; } /** @@ -172,10 +173,12 @@ int pthread_key_delete(pthread_key_t key) */ int pthread_setspecific(pthread_key_t key, const void *value) { - pthread_key_obj *key_obj = NULL; + pthread_key_obj *key_obj; struct posix_thread *thread; struct pthread_key_data *key_data; - sys_snode_t *node_l = NULL; + pthread_thread_data *thread_spec_data; + k_spinlock_key_t key_key; + sys_snode_t *node_l; int retval = 0; thread = to_posix_thread(pthread_self()); @@ -187,37 +190,37 @@ int pthread_setspecific(pthread_key_t key, const void *value) * If the key is already in the list, re-assign its value. * Else add the key to the thread's list. */ - SYS_SEM_LOCK(&pthread_key_lock) { - key_obj = get_posix_key(key); - if (key_obj == NULL) { - retval = EINVAL; - SYS_SEM_LOCK_BREAK; + key_key = k_spin_lock(&pthread_key_lock); + + key_obj = get_posix_key(key); + if (key_obj == NULL) { + k_spin_unlock(&pthread_key_lock, key_key); + return EINVAL; + } + + SYS_SLIST_FOR_EACH_NODE(&(thread->key_list), node_l) { + + thread_spec_data = (pthread_thread_data *)node_l; + + if (thread_spec_data->key == key_obj) { + + /* Key is already present so + * associate thread specific data + */ + thread_spec_data->spec_data = (void *)value; + LOG_DBG("Paired key %x to value %p for thread %x", key, value, + pthread_self()); + goto out; } + } - SYS_SLIST_FOR_EACH_NODE(&(thread->key_list), node_l) { - pthread_thread_data *thread_spec_data = (pthread_thread_data *)node_l; - - if (thread_spec_data->key == key_obj) { - /* Key is already present so associate thread specific data */ - thread_spec_data->spec_data = (void *)value; - LOG_DBG("Paired key %x to value %p for thread %x", key, value, - pthread_self()); - break; - } - } - - if (node_l != NULL) { - /* Key is already present, so we are done */ - SYS_SEM_LOCK_BREAK; - } - - /* Key and data need to be added */ + if (node_l == NULL) { key_data = k_malloc(sizeof(struct pthread_key_data)); if (key_data == NULL) { LOG_DBG("Failed to allocate key data for key %x", key); retval = ENOMEM; - SYS_SEM_LOCK_BREAK; + goto out; } LOG_DBG("Allocated key data %p for key %x in thread %x", key_data, key, @@ -236,6 +239,9 @@ int pthread_setspecific(pthread_key_t key, const void *value) LOG_DBG("Paired key %x to value %p for thread %x", key, value, pthread_self()); } +out: + k_spin_unlock(&pthread_key_lock, key_key); + return retval; } @@ -251,30 +257,33 @@ void *pthread_getspecific(pthread_key_t key) pthread_thread_data *thread_spec_data; void *value = NULL; sys_snode_t *node_l; + k_spinlock_key_t key_key; thread = to_posix_thread(pthread_self()); if (thread == NULL) { return NULL; } - SYS_SEM_LOCK(&pthread_key_lock) { - key_obj = get_posix_key(key); - if (key_obj == NULL) { - value = NULL; - SYS_SEM_LOCK_BREAK; - } + key_key = k_spin_lock(&pthread_key_lock); - /* Traverse the list of keys set by the thread, looking for key */ + key_obj = get_posix_key(key); + if (key_obj == NULL) { + k_spin_unlock(&pthread_key_lock, key_key); + return NULL; + } - SYS_SLIST_FOR_EACH_NODE(&(thread->key_list), node_l) { - thread_spec_data = (pthread_thread_data *)node_l; - if (thread_spec_data->key == key_obj) { - /* Key is present, so get the set thread data */ - value = thread_spec_data->spec_data; - break; - } + /* Traverse the list of keys set by the thread, looking for key */ + + SYS_SLIST_FOR_EACH_NODE(&(thread->key_list), node_l) { + thread_spec_data = (pthread_thread_data *)node_l; + if (thread_spec_data->key == key_obj) { + /* Key is present, so get the set thread data */ + value = thread_spec_data->spec_data; + break; } } + k_spin_unlock(&pthread_key_lock, key_key); + return value; } diff --git a/lib/posix/options/mutex.c b/lib/posix/options/mutex.c index 46760830cf..62953e2d38 100644 --- a/lib/posix/options/mutex.c +++ b/lib/posix/options/mutex.c @@ -12,11 +12,10 @@ #include #include #include -#include LOG_MODULE_REGISTER(pthread_mutex, CONFIG_PTHREAD_MUTEX_LOG_LEVEL); -static SYS_SEM_DEFINE(lock, 1, 1); +static struct k_spinlock pthread_mutex_spinlock; int64_t timespec_to_timeoutms(const struct timespec *abstime); @@ -107,41 +106,35 @@ struct k_mutex *to_posix_mutex(pthread_mutex_t *mu) static int acquire_mutex(pthread_mutex_t *mu, k_timeout_t timeout) { + int type; + size_t bit; int ret = 0; - int type = -1; - size_t bit = -1; - size_t lock_count = -1; - struct k_mutex *m = NULL; - struct k_thread *owner = NULL; + struct k_mutex *m; + k_spinlock_key_t key; - SYS_SEM_LOCK(&lock) { - m = to_posix_mutex(mu); - if (m == NULL) { - ret = EINVAL; - SYS_SEM_LOCK_BREAK; - } + key = k_spin_lock(&pthread_mutex_spinlock); - LOG_DBG("Locking mutex %p with timeout %llx", m, timeout.ticks); - - bit = posix_mutex_to_offset(m); - type = posix_mutex_type[bit]; - owner = m->owner; - lock_count = m->lock_count; + m = to_posix_mutex(mu); + if (m == NULL) { + k_spin_unlock(&pthread_mutex_spinlock, key); + return EINVAL; } - if (ret != 0) { - goto handle_error; - } + LOG_DBG("Locking mutex %p with timeout %llx", m, timeout.ticks); - if (owner == k_current_get()) { + bit = posix_mutex_to_offset(m); + type = posix_mutex_type[bit]; + + if (m->owner == k_current_get()) { switch (type) { case PTHREAD_MUTEX_NORMAL: if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) { + k_spin_unlock(&pthread_mutex_spinlock, key); LOG_DBG("Timeout locking mutex %p", m); - ret = EBUSY; - break; + return EBUSY; } /* On most POSIX systems, this usually results in an infinite loop */ + k_spin_unlock(&pthread_mutex_spinlock, key); LOG_DBG("Attempt to relock non-recursive mutex %p", m); do { (void)k_sleep(K_FOREVER); @@ -149,7 +142,7 @@ static int acquire_mutex(pthread_mutex_t *mu, k_timeout_t timeout) CODE_UNREACHABLE; break; case PTHREAD_MUTEX_RECURSIVE: - if (lock_count >= MUTEX_MAX_REC_LOCK) { + if (m->lock_count >= MUTEX_MAX_REC_LOCK) { LOG_DBG("Mutex %p locked recursively too many times", m); ret = EAGAIN; } @@ -164,6 +157,7 @@ static int acquire_mutex(pthread_mutex_t *mu, k_timeout_t timeout) break; } } + k_spin_unlock(&pthread_mutex_spinlock, key); if (ret == 0) { ret = k_mutex_lock(m, timeout); @@ -177,7 +171,6 @@ static int acquire_mutex(pthread_mutex_t *mu, k_timeout_t timeout) } } -handle_error: if (ret < 0) { LOG_DBG("k_mutex_unlock() failed: %d", ret); ret = -ret; diff --git a/lib/posix/options/pthread.c b/lib/posix/options/pthread.c index bd9c85eecc..a46cde7614 100644 --- a/lib/posix/options/pthread.c +++ b/lib/posix/options/pthread.c @@ -16,7 +16,6 @@ #include #include #include -#include #include #include @@ -88,7 +87,7 @@ static sys_dlist_t posix_thread_q[] = { SYS_DLIST_STATIC_INIT(&posix_thread_q[POSIX_THREAD_DONE_Q]), }; static struct posix_thread posix_thread_pool[CONFIG_MAX_PTHREAD_COUNT]; -static SYS_SEM_DEFINE(pthread_pool_lock, 1, 1); +static struct k_spinlock pthread_pool_lock; static int pthread_concurrency; static inline void posix_thread_q_set(struct posix_thread *t, enum posix_thread_qid qid) @@ -220,7 +219,7 @@ void __z_pthread_cleanup_push(void *cleanup[3], void (*routine)(void *arg), void struct posix_thread *t = NULL; struct __pthread_cleanup *const c = (struct __pthread_cleanup *)cleanup; - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread_self()); BUILD_ASSERT(3 * sizeof(void *) == sizeof(*c)); __ASSERT_NO_MSG(t != NULL); @@ -237,7 +236,7 @@ void __z_pthread_cleanup_pop(int execute) struct __pthread_cleanup *c = NULL; struct posix_thread *t = NULL; - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread_self()); __ASSERT_NO_MSG(t != NULL); node = sys_slist_get(&t->cleanup_list); @@ -477,6 +476,7 @@ static K_WORK_DELAYABLE_DEFINE(posix_thread_recycle_work, posix_thread_recycle_w static void posix_thread_finalize(struct posix_thread *t, void *retval) { sys_snode_t *node_l; + k_spinlock_key_t key; pthread_key_obj *key_obj; pthread_thread_data *thread_spec_data; @@ -491,11 +491,11 @@ static void posix_thread_finalize(struct posix_thread *t, void *retval) } /* move thread from run_q to done_q */ - SYS_SEM_LOCK(&pthread_pool_lock) { - sys_dlist_remove(&t->q_node); - posix_thread_q_set(t, POSIX_THREAD_DONE_Q); - t->retval = retval; - } + key = k_spin_lock(&pthread_pool_lock); + sys_dlist_remove(&t->q_node); + posix_thread_q_set(t, POSIX_THREAD_DONE_Q); + t->retval = retval; + k_spin_unlock(&pthread_pool_lock, key); /* trigger recycle work */ (void)k_work_schedule(&posix_thread_recycle_work, K_MSEC(CONFIG_PTHREAD_RECYCLER_DELAY_MS)); @@ -526,22 +526,22 @@ static void zephyr_thread_wrapper(void *arg1, void *arg2, void *arg3) static void posix_thread_recycle(void) { + k_spinlock_key_t key; struct posix_thread *t; struct posix_thread *safe_t; sys_dlist_t recyclables = SYS_DLIST_STATIC_INIT(&recyclables); - SYS_SEM_LOCK(&pthread_pool_lock) { - SYS_DLIST_FOR_EACH_CONTAINER_SAFE(&posix_thread_q[POSIX_THREAD_DONE_Q], t, safe_t, - q_node) { - if (t->attr.detachstate == PTHREAD_CREATE_JOINABLE) { - /* thread has not been joined yet */ - continue; - } - - sys_dlist_remove(&t->q_node); - sys_dlist_append(&recyclables, &t->q_node); + key = k_spin_lock(&pthread_pool_lock); + SYS_DLIST_FOR_EACH_CONTAINER_SAFE(&posix_thread_q[POSIX_THREAD_DONE_Q], t, safe_t, q_node) { + if (t->attr.detachstate == PTHREAD_CREATE_JOINABLE) { + /* thread has not been joined yet */ + continue; } + + sys_dlist_remove(&t->q_node); + sys_dlist_append(&recyclables, &t->q_node); } + k_spin_unlock(&pthread_pool_lock, key); if (sys_dlist_is_empty(&recyclables)) { return; @@ -557,12 +557,12 @@ static void posix_thread_recycle(void) } } - SYS_SEM_LOCK(&pthread_pool_lock) { - while (!sys_dlist_is_empty(&recyclables)) { - t = CONTAINER_OF(sys_dlist_get(&recyclables), struct posix_thread, q_node); - posix_thread_q_set(t, POSIX_THREAD_READY_Q); - } + key = k_spin_lock(&pthread_pool_lock); + while (!sys_dlist_is_empty(&recyclables)) { + t = CONTAINER_OF(sys_dlist_get(&recyclables), struct posix_thread, q_node); + posix_thread_q_set(t, POSIX_THREAD_READY_Q); } + k_spin_unlock(&pthread_pool_lock, key); } /** @@ -587,7 +587,7 @@ int pthread_create(pthread_t *th, const pthread_attr_t *_attr, void *(*threadrou /* reclaim resources greedily */ posix_thread_recycle(); - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { if (!sys_dlist_is_empty(&posix_thread_q[POSIX_THREAD_READY_Q])) { t = CONTAINER_OF(sys_dlist_get(&posix_thread_q[POSIX_THREAD_READY_Q]), struct posix_thread, q_node); @@ -603,7 +603,7 @@ int pthread_create(pthread_t *th, const pthread_attr_t *_attr, void *(*threadrou err = pthread_barrier_init(&barrier, NULL, 2); if (err != 0) { /* cannot allocate barrier. move thread back to ready_q */ - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { sys_dlist_remove(&t->q_node); posix_thread_q_set(t, POSIX_THREAD_READY_Q); } @@ -625,7 +625,7 @@ int pthread_create(pthread_t *th, const pthread_attr_t *_attr, void *(*threadrou } if (err != 0) { /* cannot allocate pthread attributes (e.g. stack) */ - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { sys_dlist_remove(&t->q_node); posix_thread_q_set(t, POSIX_THREAD_READY_Q); } @@ -673,7 +673,7 @@ int pthread_getconcurrency(void) { int ret = 0; - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { ret = pthread_concurrency; } @@ -690,7 +690,7 @@ int pthread_setconcurrency(int new_level) return EAGAIN; } - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { pthread_concurrency = new_level; } @@ -705,8 +705,8 @@ int pthread_setconcurrency(int new_level) int pthread_setcancelstate(int state, int *oldstate) { int ret = 0; + struct posix_thread *t; bool cancel_pending = false; - struct posix_thread *t = NULL; bool cancel_type = PTHREAD_CANCEL_ENABLE; if (state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE) { @@ -714,11 +714,11 @@ int pthread_setcancelstate(int state, int *oldstate) return EINVAL; } - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread_self()); if (t == NULL) { ret = EINVAL; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } if (oldstate != NULL) { @@ -753,11 +753,11 @@ int pthread_setcanceltype(int type, int *oldtype) return EINVAL; } - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread_self()); if (t == NULL) { ret = EINVAL; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } if (oldtype != NULL) { @@ -776,16 +776,16 @@ int pthread_setcanceltype(int type, int *oldtype) */ void pthread_testcancel(void) { + struct posix_thread *t; bool cancel_pended = false; - struct posix_thread *t = NULL; - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread_self()); if (t == NULL) { - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } if (t->attr.cancelstate != PTHREAD_CANCEL_ENABLE) { - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } if (t->attr.cancelpending) { cancel_pended = true; @@ -810,17 +810,17 @@ int pthread_cancel(pthread_t pthread) bool cancel_type = PTHREAD_CANCEL_DEFERRED; struct posix_thread *t = NULL; - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread); if (t == NULL) { ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } if (!__attr_is_initialized(&t->attr)) { /* thread has already terminated */ ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } t->attr.cancelpending = true; @@ -852,11 +852,11 @@ int pthread_setschedparam(pthread_t pthread, int policy, const struct sched_para return EINVAL; } - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread); if (t == NULL) { ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } new_prio = posix_to_zephyr_priority(param->sched_priority, policy); @@ -892,11 +892,11 @@ int pthread_setschedprio(pthread_t thread, int prio) return EINVAL; } - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(thread); if (t == NULL) { ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } new_prio = posix_to_zephyr_priority(prio, policy); @@ -965,16 +965,16 @@ int pthread_getschedparam(pthread_t pthread, int *policy, struct sched_param *pa return EINVAL; } - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread); if (t == NULL) { ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } if (!__attr_is_initialized(&t->attr)) { ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } param->sched_priority = @@ -999,7 +999,7 @@ int pthread_once(pthread_once_t *once, void (*init_func)(void)) return EINVAL; } - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { if (!_once->flag) { run_init_func = true; _once->flag = true; @@ -1023,10 +1023,10 @@ void pthread_exit(void *retval) { struct posix_thread *self = NULL; - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { self = to_posix_thread(pthread_self()); if (self == NULL) { - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } /* Mark a thread as cancellable before exiting */ @@ -1060,11 +1060,11 @@ int pthread_join(pthread_t pthread, void **status) return EDEADLK; } - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread); if (t == NULL) { ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } LOG_DBG("Pthread %p joining..", &t->thread); @@ -1072,12 +1072,12 @@ int pthread_join(pthread_t pthread, void **status) if (t->attr.detachstate != PTHREAD_CREATE_JOINABLE) { /* undefined behaviour */ ret = EINVAL; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } if (posix_thread_q_get(t) == POSIX_THREAD_READY_Q) { ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } /* @@ -1124,18 +1124,18 @@ int pthread_detach(pthread_t pthread) int ret = 0; struct posix_thread *t; - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread); if (t == NULL) { ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } if (posix_thread_q_get(t) == POSIX_THREAD_READY_Q || t->attr.detachstate != PTHREAD_CREATE_JOINABLE) { LOG_DBG("Pthread %p cannot be detached", &t->thread); ret = EINVAL; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } t->attr.detachstate = PTHREAD_CREATE_DETACHED; @@ -1437,11 +1437,11 @@ int pthread_sigmask(int how, const sigset_t *ZRESTRICT set, sigset_t *ZRESTRICT return EINVAL; } - SYS_SEM_LOCK(&pthread_pool_lock) { + K_SPINLOCK(&pthread_pool_lock) { t = to_posix_thread(pthread_self()); if (t == NULL) { ret = ESRCH; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } if (oset != NULL) { @@ -1449,7 +1449,7 @@ int pthread_sigmask(int how, const sigset_t *ZRESTRICT set, sigset_t *ZRESTRICT } if (set == NULL) { - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } switch (how) { diff --git a/lib/posix/options/rwlock.c b/lib/posix/options/rwlock.c index 3d6752a3fa..b8a91a0323 100644 --- a/lib/posix/options/rwlock.c +++ b/lib/posix/options/rwlock.c @@ -11,7 +11,6 @@ #include #include #include -#include #define CONCURRENT_READER_LIMIT (CONFIG_MAX_PTHREAD_COUNT + 1) @@ -33,7 +32,7 @@ static uint32_t write_lock_acquire(struct posix_rwlock *rwl, int32_t timeout); LOG_MODULE_REGISTER(pthread_rwlock, CONFIG_PTHREAD_RWLOCK_LOG_LEVEL); -static SYS_SEM_DEFINE(posix_rwlock_lock, 1, 1); +static struct k_spinlock posix_rwlock_spinlock; static struct posix_rwlock posix_rwlock_pool[CONFIG_MAX_PTHREAD_RWLOCK_COUNT]; SYS_BITARRAY_DEFINE_STATIC(posix_rwlock_bitarray, CONFIG_MAX_PTHREAD_RWLOCK_COUNT); @@ -151,10 +150,10 @@ int pthread_rwlock_destroy(pthread_rwlock_t *rwlock) return EINVAL; } - SYS_SEM_LOCK(&posix_rwlock_lock) { + K_SPINLOCK(&posix_rwlock_spinlock) { if (rwl->wr_owner != NULL) { ret = EBUSY; - SYS_SEM_LOCK_BREAK; + K_SPINLOCK_BREAK; } bit = posix_rwlock_to_offset(rwl);