/*
|
* Written by Gilles Chanteperdrix <gilles.chanteperdrix@xenomai.org>.
|
*
|
* This program is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU General Public License as
|
* published by the Free Software Foundation; either version 2 of the
|
* License, or (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
*/
|
|
#include "internal.h"
|
#include "thread.h"
|
#include "mutex.h"
|
#include "cond.h"
|
#include "clock.h"
|
#include <cobalt/kernel/time.h>
|
|
static int cobalt_mutex_init_inner(struct cobalt_mutex_shadow *shadow,
|
struct cobalt_mutex *mutex,
|
struct cobalt_mutex_state *state,
|
const struct cobalt_mutexattr *attr)
|
{
|
int synch_flags = XNSYNCH_PRIO | XNSYNCH_OWNER;
|
struct cobalt_umm *umm;
|
spl_t s;
|
int ret;
|
|
ret = xnregistry_enter_anon(mutex, &mutex->resnode.handle);
|
if (ret < 0)
|
return ret;
|
|
umm = &cobalt_ppd_get(attr->pshared)->umm;
|
shadow->handle = mutex->resnode.handle;
|
shadow->magic = COBALT_MUTEX_MAGIC;
|
shadow->lockcnt = 0;
|
shadow->attr = *attr;
|
shadow->state_offset = cobalt_umm_offset(umm, state);
|
|
mutex->magic = COBALT_MUTEX_MAGIC;
|
|
if (attr->protocol == PTHREAD_PRIO_PROTECT) {
|
state->ceiling = attr->ceiling + 1;
|
xnsynch_init_protect(&mutex->synchbase, synch_flags,
|
&state->owner, &state->ceiling);
|
} else {
|
state->ceiling = 0;
|
if (attr->protocol == PTHREAD_PRIO_INHERIT)
|
synch_flags |= XNSYNCH_PI;
|
xnsynch_init(&mutex->synchbase, synch_flags, &state->owner);
|
}
|
|
state->flags = (attr->type == PTHREAD_MUTEX_ERRORCHECK
|
? COBALT_MUTEX_ERRORCHECK : 0);
|
mutex->attr = *attr;
|
INIT_LIST_HEAD(&mutex->conds);
|
|
xnlock_get_irqsave(&nklock, s);
|
cobalt_add_resource(&mutex->resnode, mutex, attr->pshared);
|
xnlock_put_irqrestore(&nklock, s);
|
|
return 0;
|
}
|
|
/* must be called with nklock locked, interrupts off. */
|
int __cobalt_mutex_acquire_unchecked(struct xnthread *cur,
|
struct cobalt_mutex *mutex,
|
const struct timespec64 *ts)
|
{
|
int ret;
|
|
if (ts) {
|
if (!timespec64_valid(ts))
|
return -EINVAL;
|
ret = xnsynch_acquire(&mutex->synchbase, ts2ns(ts) + 1, XN_REALTIME);
|
} else
|
ret = xnsynch_acquire(&mutex->synchbase, XN_INFINITE, XN_RELATIVE);
|
|
if (ret) {
|
if (ret & XNBREAK)
|
return -EINTR;
|
if (ret & XNTIMEO)
|
return -ETIMEDOUT;
|
return -EINVAL;
|
}
|
|
return 0;
|
}
|
|
int cobalt_mutex_release(struct xnthread *curr,
|
struct cobalt_mutex *mutex)
|
{ /* nklock held, irqs off */
|
struct cobalt_mutex_state *state;
|
struct cobalt_cond *cond;
|
unsigned long flags;
|
int need_resched;
|
|
if (!cobalt_obj_active(mutex, COBALT_MUTEX_MAGIC, struct cobalt_mutex))
|
return -EINVAL;
|
|
if (mutex->resnode.scope !=
|
cobalt_current_resources(mutex->attr.pshared))
|
return -EPERM;
|
|
/*
|
* We are about to release a mutex which is still pending PP
|
* (i.e. we never got scheduled out while holding it). Clear
|
* the lazy handle.
|
*/
|
if (mutex->resnode.handle == curr->u_window->pp_pending)
|
curr->u_window->pp_pending = XN_NO_HANDLE;
|
|
state = container_of(mutex->synchbase.fastlock, struct cobalt_mutex_state, owner);
|
flags = state->flags;
|
need_resched = 0;
|
if ((flags & COBALT_MUTEX_COND_SIGNAL)) {
|
state->flags = flags & ~COBALT_MUTEX_COND_SIGNAL;
|
if (!list_empty(&mutex->conds)) {
|
list_for_each_entry(cond, &mutex->conds, mutex_link)
|
need_resched |=
|
cobalt_cond_deferred_signals(cond);
|
}
|
}
|
need_resched |= xnsynch_release(&mutex->synchbase, curr);
|
|
return need_resched;
|
}
|
|
int __cobalt_mutex_timedlock_break(struct cobalt_mutex_shadow __user *u_mx,
|
const void __user *u_ts,
|
int (*fetch_timeout)(struct timespec64 *ts,
|
const void __user *u_ts))
|
{
|
struct xnthread *curr = xnthread_current();
|
struct timespec64 ts, *tsp = NULL;
|
struct cobalt_mutex *mutex;
|
xnhandle_t handle;
|
spl_t s;
|
int ret;
|
|
/* We need a valid thread handle for the fast lock. */
|
if (curr->handle == XN_NO_HANDLE)
|
return -EPERM;
|
|
handle = cobalt_get_handle_from_user(&u_mx->handle);
|
redo:
|
xnlock_get_irqsave(&nklock, s);
|
|
mutex = xnregistry_lookup(handle, NULL);
|
if (!cobalt_obj_active(mutex, COBALT_MUTEX_MAGIC, struct cobalt_mutex)) {
|
ret = -EINVAL;
|
goto out;
|
}
|
|
if (mutex->resnode.scope !=
|
cobalt_current_resources(mutex->attr.pshared)) {
|
ret = -EPERM;
|
goto out;
|
}
|
|
xnthread_commit_ceiling(curr);
|
|
if (xnsynch_owner_check(&mutex->synchbase, curr)) {
|
/* Check if we can take the mutex immediately */
|
ret = xnsynch_try_acquire(&mutex->synchbase);
|
if (ret != -EBUSY)
|
goto out;
|
|
if (fetch_timeout) {
|
xnlock_put_irqrestore(&nklock, s);
|
ret = fetch_timeout(&ts, u_ts);
|
if (ret)
|
return ret;
|
|
fetch_timeout = NULL;
|
tsp = &ts;
|
goto redo; /* Revalidate handle. */
|
}
|
ret = __cobalt_mutex_acquire_unchecked(curr, mutex, tsp);
|
xnlock_put_irqrestore(&nklock, s);
|
return ret;
|
}
|
|
/* We already own the mutex, something looks wrong. */
|
|
ret = -EBUSY;
|
switch(mutex->attr.type) {
|
case PTHREAD_MUTEX_NORMAL:
|
/* Attempting to relock a normal mutex, deadlock. */
|
if (IS_ENABLED(XENO_OPT_DEBUG_USER))
|
printk(XENO_WARNING
|
"thread %s deadlocks on non-recursive mutex\n",
|
curr->name);
|
/* Make the caller hang. */
|
__cobalt_mutex_acquire_unchecked(curr, mutex, NULL);
|
break;
|
|
case PTHREAD_MUTEX_ERRORCHECK:
|
case PTHREAD_MUTEX_RECURSIVE:
|
/*
|
* Recursive mutexes are handled in user-space, so
|
* these cases should never happen.
|
*/
|
ret = -EINVAL;
|
break;
|
}
|
out:
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
COBALT_SYSCALL(mutex_check_init, current,
|
(struct cobalt_mutex_shadow __user *u_mx))
|
{
|
struct cobalt_mutex *mutex;
|
xnhandle_t handle;
|
int err;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_mx->handle);
|
|
xnlock_get_irqsave(&nklock, s);
|
mutex = xnregistry_lookup(handle, NULL);
|
if (cobalt_obj_active(mutex, COBALT_MUTEX_MAGIC, typeof(*mutex)))
|
/* mutex is already in a queue. */
|
err = -EBUSY;
|
else
|
err = 0;
|
|
xnlock_put_irqrestore(&nklock, s);
|
return err;
|
}
|
|
COBALT_SYSCALL(mutex_init, current,
|
(struct cobalt_mutex_shadow __user *u_mx,
|
const struct cobalt_mutexattr __user *u_attr))
|
{
|
struct cobalt_mutex_state *state;
|
struct cobalt_mutex_shadow mx;
|
struct cobalt_mutexattr attr;
|
struct cobalt_mutex *mutex;
|
int ret;
|
|
if (cobalt_copy_from_user(&mx, u_mx, sizeof(mx)))
|
return -EFAULT;
|
|
if (cobalt_copy_from_user(&attr, u_attr, sizeof(attr)))
|
return -EFAULT;
|
|
mutex = xnmalloc(sizeof(*mutex));
|
if (mutex == NULL)
|
return -ENOMEM;
|
|
state = cobalt_umm_alloc(&cobalt_ppd_get(attr.pshared)->umm,
|
sizeof(*state));
|
if (state == NULL) {
|
xnfree(mutex);
|
return -EAGAIN;
|
}
|
|
ret = cobalt_mutex_init_inner(&mx, mutex, state, &attr);
|
if (ret) {
|
xnfree(mutex);
|
cobalt_umm_free(&cobalt_ppd_get(attr.pshared)->umm, state);
|
return ret;
|
}
|
|
return cobalt_copy_to_user(u_mx, &mx, sizeof(*u_mx));
|
}
|
|
COBALT_SYSCALL(mutex_destroy, current,
|
(struct cobalt_mutex_shadow __user *u_mx))
|
{
|
struct cobalt_mutex_shadow mx;
|
struct cobalt_mutex *mutex;
|
spl_t s;
|
int ret;
|
|
if (cobalt_copy_from_user(&mx, u_mx, sizeof(mx)))
|
return -EFAULT;
|
|
xnlock_get_irqsave(&nklock, s);
|
|
mutex = xnregistry_lookup(mx.handle, NULL);
|
if (!cobalt_obj_active(mutex, COBALT_MUTEX_MAGIC, typeof(*mutex))) {
|
ret = -EINVAL;
|
goto fail;
|
}
|
if (cobalt_current_resources(mutex->attr.pshared) !=
|
mutex->resnode.scope) {
|
ret = -EPERM;
|
goto fail;
|
}
|
if (xnsynch_fast_owner_check(mutex->synchbase.fastlock,
|
XN_NO_HANDLE) != 0 ||
|
!list_empty(&mutex->conds)) {
|
ret = -EBUSY;
|
goto fail;
|
}
|
|
cobalt_mutex_reclaim(&mutex->resnode, s); /* drops lock */
|
|
cobalt_mark_deleted(&mx);
|
|
return cobalt_copy_to_user(u_mx, &mx, sizeof(*u_mx));
|
fail:
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
COBALT_SYSCALL(mutex_trylock, primary,
|
(struct cobalt_mutex_shadow __user *u_mx))
|
{
|
struct xnthread *curr = xnthread_current();
|
struct cobalt_mutex *mutex;
|
xnhandle_t handle;
|
spl_t s;
|
int ret;
|
|
handle = cobalt_get_handle_from_user(&u_mx->handle);
|
|
xnlock_get_irqsave(&nklock, s);
|
|
mutex = xnregistry_lookup(handle, NULL);
|
if (!cobalt_obj_active(mutex, COBALT_MUTEX_MAGIC, typeof(*mutex))) {
|
ret = -EINVAL;
|
goto out;
|
}
|
|
xnthread_commit_ceiling(curr);
|
|
ret = xnsynch_try_acquire(&mutex->synchbase);
|
|
out:
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
COBALT_SYSCALL(mutex_lock, primary,
|
(struct cobalt_mutex_shadow __user *u_mx))
|
{
|
return __cobalt_mutex_timedlock_break(u_mx, NULL, NULL);
|
}
|
|
static inline int mutex_fetch_timeout(struct timespec64 *ts,
|
const void __user *u_ts)
|
{
|
return u_ts == NULL ? -EFAULT : cobalt_get_u_timespec(ts, u_ts);
|
}
|
|
static inline int mutex_fetch_timeout64(struct timespec64 *ts,
|
const void __user *u_ts)
|
{
|
return u_ts == NULL ? -EFAULT : cobalt_get_timespec64(ts, u_ts);
|
}
|
|
int __cobalt_mutex_timedlock64(struct cobalt_mutex_shadow __user *u_mx,
|
const void __user *u_ts)
|
{
|
return __cobalt_mutex_timedlock_break(u_mx, u_ts,
|
mutex_fetch_timeout64);
|
}
|
|
COBALT_SYSCALL(mutex_timedlock, primary,
|
(struct cobalt_mutex_shadow __user *u_mx,
|
const struct __user_old_timespec __user *u_ts))
|
{
|
return __cobalt_mutex_timedlock_break(u_mx, u_ts, mutex_fetch_timeout);
|
}
|
|
COBALT_SYSCALL(mutex_timedlock64, primary,
|
(struct cobalt_mutex_shadow __user *u_mx,
|
const struct __kernel_timespec __user *u_ts))
|
{
|
return __cobalt_mutex_timedlock64(u_mx, u_ts);
|
}
|
|
COBALT_SYSCALL(mutex_unlock, nonrestartable,
|
(struct cobalt_mutex_shadow __user *u_mx))
|
{
|
struct cobalt_mutex *mutex;
|
struct xnthread *curr;
|
xnhandle_t handle;
|
int ret;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_mx->handle);
|
curr = xnthread_current();
|
|
xnlock_get_irqsave(&nklock, s);
|
|
mutex = xnregistry_lookup(handle, NULL);
|
ret = cobalt_mutex_release(curr, mutex);
|
if (ret > 0) {
|
xnsched_run();
|
ret = 0;
|
}
|
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
void cobalt_mutex_reclaim(struct cobalt_resnode *node, spl_t s)
|
{
|
struct cobalt_mutex_state *state;
|
struct cobalt_mutex *mutex;
|
int pshared;
|
|
mutex = container_of(node, struct cobalt_mutex, resnode);
|
state = container_of(mutex->synchbase.fastlock, struct cobalt_mutex_state, owner);
|
pshared = mutex->attr.pshared;
|
xnregistry_remove(node->handle);
|
cobalt_del_resource(node);
|
xnsynch_destroy(&mutex->synchbase);
|
cobalt_mark_deleted(mutex);
|
xnlock_put_irqrestore(&nklock, s);
|
|
cobalt_umm_free(&cobalt_ppd_get(pshared)->umm, state);
|
xnfree(mutex);
|
}
|
|
struct xnsynch *lookup_lazy_pp(xnhandle_t handle)
|
{ /* nklock held, irqs off */
|
struct cobalt_mutex *mutex;
|
|
/* Only mutexes may be PP-enabled. */
|
|
mutex = xnregistry_lookup(handle, NULL);
|
if (mutex == NULL ||
|
!cobalt_obj_active(mutex, COBALT_MUTEX_MAGIC, struct cobalt_mutex) ||
|
mutex->attr.protocol != PTHREAD_PRIO_PROTECT)
|
return NULL;
|
|
return &mutex->synchbase;
|
}
|
