/*
|
* Copyright (C) 2011 Philippe Gerum <rpm@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 "clock.h"
|
#include "monitor.h"
|
#include <trace/events/cobalt-posix.h>
|
#include <cobalt/kernel/time.h>
|
|
/*
|
* The Cobalt monitor is a double-wait condition object, serializing
|
* accesses through a gate. It behaves like a mutex + two condition
|
* variables combo with extended signaling logic. Folding several
|
* conditions and the serialization support into a single object
|
* performs better on low end hw caches and allows for specific
|
* optimizations, compared to using separate general-purpose mutex and
|
* condvars. This object is used by the Copperplate interface
|
* internally when it runs over the Cobalt core.
|
*
|
* Threads can wait for some resource(s) to be granted (consumer
|
* side), or wait for the available resource(s) to drain (producer
|
* side). Therefore, signals are thread-directed for the grant side,
|
* and monitor-directed for the drain side.
|
*
|
* Typically, a consumer would wait for the GRANT condition to be
|
* satisfied, signaling the DRAINED condition when more resources
|
* could be made available if the protocol implements output
|
* contention (e.g. the write side of a message queue waiting for the
|
* consumer to release message slots). Conversely, a producer would
|
* wait for the DRAINED condition to be satisfied, issuing GRANT
|
* signals once more resources have been made available to the
|
* consumer.
|
*
|
* Implementation-wise, the monitor logic is shared with the Cobalt
|
* thread object.
|
*/
|
COBALT_SYSCALL(monitor_init, current,
|
(struct cobalt_monitor_shadow __user *u_mon,
|
clockid_t clk_id, int flags))
|
{
|
struct cobalt_monitor_shadow shadow;
|
struct cobalt_monitor_state *state;
|
struct cobalt_monitor *mon;
|
int pshared, tmode, ret;
|
struct cobalt_umm *umm;
|
unsigned long stateoff;
|
spl_t s;
|
|
tmode = clock_flag(TIMER_ABSTIME, clk_id);
|
if (tmode < 0)
|
return -EINVAL;
|
|
mon = xnmalloc(sizeof(*mon));
|
if (mon == NULL)
|
return -ENOMEM;
|
|
pshared = (flags & COBALT_MONITOR_SHARED) != 0;
|
umm = &cobalt_ppd_get(pshared)->umm;
|
state = cobalt_umm_alloc(umm, sizeof(*state));
|
if (state == NULL) {
|
xnfree(mon);
|
return -EAGAIN;
|
}
|
|
ret = xnregistry_enter_anon(mon, &mon->resnode.handle);
|
if (ret) {
|
cobalt_umm_free(umm, state);
|
xnfree(mon);
|
return ret;
|
}
|
|
mon->state = state;
|
xnsynch_init(&mon->gate, XNSYNCH_PI, &state->owner);
|
xnsynch_init(&mon->drain, XNSYNCH_PRIO, NULL);
|
mon->flags = flags;
|
mon->tmode = tmode;
|
INIT_LIST_HEAD(&mon->waiters);
|
|
xnlock_get_irqsave(&nklock, s);
|
cobalt_add_resource(&mon->resnode, monitor, pshared);
|
mon->magic = COBALT_MONITOR_MAGIC;
|
xnlock_put_irqrestore(&nklock, s);
|
|
state->flags = 0;
|
stateoff = cobalt_umm_offset(umm, state);
|
XENO_BUG_ON(COBALT, stateoff != (__u32)stateoff);
|
shadow.flags = flags;
|
shadow.handle = mon->resnode.handle;
|
shadow.state_offset = (__u32)stateoff;
|
|
return cobalt_copy_to_user(u_mon, &shadow, sizeof(*u_mon));
|
}
|
|
/* nklock held, irqs off */
|
static int monitor_enter(xnhandle_t handle, struct xnthread *curr)
|
{
|
struct cobalt_monitor *mon;
|
int info;
|
|
mon = xnregistry_lookup(handle, NULL); /* (Re)validate. */
|
if (mon == NULL || mon->magic != COBALT_MONITOR_MAGIC)
|
return -EINVAL;
|
|
info = xnsynch_acquire(&mon->gate, XN_INFINITE, XN_RELATIVE);
|
if (info)
|
/* Break or error, no timeout possible. */
|
return info & XNBREAK ? -EINTR : -EINVAL;
|
|
mon->state->flags &= ~(COBALT_MONITOR_SIGNALED|COBALT_MONITOR_BROADCAST);
|
|
return 0;
|
}
|
|
COBALT_SYSCALL(monitor_enter, primary,
|
(struct cobalt_monitor_shadow __user *u_mon))
|
{
|
struct xnthread *curr = xnthread_current();
|
xnhandle_t handle;
|
int ret;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_mon->handle);
|
|
xnlock_get_irqsave(&nklock, s);
|
ret = monitor_enter(handle, curr);
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
/* nklock held, irqs off */
|
static void monitor_wakeup(struct cobalt_monitor *mon)
|
{
|
struct cobalt_monitor_state *state = mon->state;
|
struct cobalt_thread *thread, *tmp;
|
struct xnthread *p;
|
int bcast;
|
|
/*
|
* Having the GRANT signal pending does not necessarily mean
|
* that somebody is actually waiting for it, so we have to
|
* check both conditions below.
|
*/
|
bcast = (state->flags & COBALT_MONITOR_BROADCAST) != 0;
|
if ((state->flags & COBALT_MONITOR_GRANTED) == 0 ||
|
list_empty(&mon->waiters))
|
goto drain;
|
|
/*
|
* Unblock waiters requesting a grant, either those who
|
* received it only or all of them, depending on the broadcast
|
* bit.
|
*
|
* We update the PENDED flag to inform userland about the
|
* presence of waiters, so that it may decide not to issue any
|
* syscall for exiting the monitor if nobody else is waiting
|
* at the gate.
|
*/
|
list_for_each_entry_safe(thread, tmp, &mon->waiters, monitor_link) {
|
p = &thread->threadbase;
|
/*
|
* A thread might receive a grant signal albeit it
|
* does not wait on a monitor, or it might have timed
|
* out before we got there, so we really have to check
|
* that ->wchan does match our sleep queue.
|
*/
|
if (bcast ||
|
(p->u_window->grant_value && p->wchan == &thread->monitor_synch)) {
|
xnsynch_wakeup_this_sleeper(&thread->monitor_synch, p);
|
list_del_init(&thread->monitor_link);
|
}
|
}
|
drain:
|
/*
|
* Unblock threads waiting for a drain event if that signal is
|
* pending, either one or all, depending on the broadcast
|
* flag.
|
*/
|
if ((state->flags & COBALT_MONITOR_DRAINED) != 0 &&
|
xnsynch_pended_p(&mon->drain)) {
|
if (bcast)
|
xnsynch_flush(&mon->drain, 0);
|
else
|
xnsynch_wakeup_one_sleeper(&mon->drain);
|
}
|
|
if (list_empty(&mon->waiters) && !xnsynch_pended_p(&mon->drain))
|
state->flags &= ~COBALT_MONITOR_PENDED;
|
}
|
|
int __cobalt_monitor_wait(struct cobalt_monitor_shadow __user *u_mon,
|
int event, const struct timespec64 *ts,
|
int __user *u_ret)
|
{
|
struct cobalt_thread *curr = cobalt_current_thread();
|
struct cobalt_monitor_state *state;
|
xnticks_t timeout = XN_INFINITE;
|
int ret = 0, opret = 0, info;
|
struct cobalt_monitor *mon;
|
struct xnsynch *synch;
|
xnhandle_t handle;
|
xntmode_t tmode;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_mon->handle);
|
|
if (ts) {
|
if (!timespec64_valid(ts))
|
return -EINVAL;
|
|
timeout = ts2ns(ts) + 1;
|
}
|
|
xnlock_get_irqsave(&nklock, s);
|
|
mon = xnregistry_lookup(handle, NULL);
|
if (mon == NULL || mon->magic != COBALT_MONITOR_MAGIC) {
|
ret = -EINVAL;
|
goto out;
|
}
|
|
/*
|
* The current thread might have sent signals to the monitor
|
* it wants to sleep on: wake up satisfied waiters before
|
* going to sleep.
|
*/
|
state = mon->state;
|
if (state->flags & COBALT_MONITOR_SIGNALED)
|
monitor_wakeup(mon);
|
|
synch = &curr->monitor_synch;
|
if (event & COBALT_MONITOR_WAITDRAIN)
|
synch = &mon->drain;
|
else {
|
curr->threadbase.u_window->grant_value = 0;
|
list_add_tail(&curr->monitor_link, &mon->waiters);
|
}
|
|
/*
|
* Tell userland that somebody is now waiting for a signal, so
|
* that later exiting the monitor on the producer side will
|
* trigger a wakeup syscall.
|
*
|
* CAUTION: we must raise the PENDED flag while holding the
|
* gate mutex, to prevent a signal from sneaking in from a
|
* remote CPU without the producer issuing the corresponding
|
* wakeup call when dropping the gate lock.
|
*/
|
state->flags |= COBALT_MONITOR_PENDED;
|
|
tmode = ts ? mon->tmode : XN_RELATIVE;
|
|
/* Release the gate prior to waiting, all atomically. */
|
xnsynch_release(&mon->gate, &curr->threadbase);
|
|
info = xnsynch_sleep_on(synch, timeout, tmode);
|
if (info) {
|
if ((event & COBALT_MONITOR_WAITDRAIN) == 0 &&
|
!list_empty(&curr->monitor_link))
|
list_del_init(&curr->monitor_link);
|
|
if (list_empty(&mon->waiters) && !xnsynch_pended_p(&mon->drain))
|
state->flags &= ~COBALT_MONITOR_PENDED;
|
|
if (info & XNBREAK) {
|
opret = -EINTR;
|
goto out;
|
}
|
if (info & XNTIMEO)
|
opret = -ETIMEDOUT;
|
}
|
|
ret = monitor_enter(handle, &curr->threadbase);
|
out:
|
xnlock_put_irqrestore(&nklock, s);
|
|
__xn_put_user(opret, u_ret);
|
|
return ret;
|
}
|
|
int __cobalt_monitor_wait64(struct cobalt_monitor_shadow __user *u_mon,
|
int event,
|
const struct __kernel_timespec __user *u_ts,
|
int __user *u_ret)
|
{
|
struct timespec64 ts, *tsp = NULL;
|
int ret;
|
|
if (u_ts) {
|
tsp = &ts;
|
ret = cobalt_get_timespec64(&ts, u_ts);
|
if (ret)
|
return ret;
|
}
|
|
return __cobalt_monitor_wait(u_mon, event, tsp, u_ret);
|
}
|
|
COBALT_SYSCALL(monitor_wait, nonrestartable,
|
(struct cobalt_monitor_shadow __user *u_mon,
|
int event, const struct __user_old_timespec __user *u_ts,
|
int __user *u_ret))
|
{
|
struct timespec64 ts, *tsp = NULL;
|
int ret;
|
|
if (u_ts) {
|
tsp = &ts;
|
ret = cobalt_get_u_timespec(&ts, u_ts);
|
if (ret)
|
return ret;
|
}
|
|
return __cobalt_monitor_wait(u_mon, event, tsp, u_ret);
|
}
|
|
COBALT_SYSCALL(monitor_wait64, nonrestartable,
|
(struct cobalt_monitor_shadow __user *u_mon, int event,
|
const struct __kernel_timespec __user *u_ts, int __user *u_ret))
|
{
|
return __cobalt_monitor_wait64(u_mon, event, u_ts, u_ret);
|
}
|
|
COBALT_SYSCALL(monitor_sync, nonrestartable,
|
(struct cobalt_monitor_shadow __user *u_mon))
|
{
|
struct cobalt_monitor *mon;
|
struct xnthread *curr;
|
xnhandle_t handle;
|
int ret = 0;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_mon->handle);
|
curr = xnthread_current();
|
|
xnlock_get_irqsave(&nklock, s);
|
|
mon = xnregistry_lookup(handle, NULL);
|
if (mon == NULL || mon->magic != COBALT_MONITOR_MAGIC)
|
ret = -EINVAL;
|
else if (mon->state->flags & COBALT_MONITOR_SIGNALED) {
|
monitor_wakeup(mon);
|
xnsynch_release(&mon->gate, curr);
|
xnsched_run();
|
ret = monitor_enter(handle, curr);
|
}
|
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
COBALT_SYSCALL(monitor_exit, primary,
|
(struct cobalt_monitor_shadow __user *u_mon))
|
{
|
struct cobalt_monitor *mon;
|
struct xnthread *curr;
|
xnhandle_t handle;
|
int ret = 0;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_mon->handle);
|
curr = xnthread_current();
|
|
xnlock_get_irqsave(&nklock, s);
|
|
mon = xnregistry_lookup(handle, NULL);
|
if (mon == NULL || mon->magic != COBALT_MONITOR_MAGIC)
|
ret = -EINVAL;
|
else {
|
if (mon->state->flags & COBALT_MONITOR_SIGNALED)
|
monitor_wakeup(mon);
|
|
xnsynch_release(&mon->gate, curr);
|
xnsched_run();
|
}
|
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
COBALT_SYSCALL(monitor_destroy, primary,
|
(struct cobalt_monitor_shadow __user *u_mon))
|
{
|
struct cobalt_monitor_state *state;
|
struct cobalt_monitor *mon;
|
struct xnthread *curr;
|
xnhandle_t handle;
|
int ret = 0;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_mon->handle);
|
curr = xnthread_current();
|
|
xnlock_get_irqsave(&nklock, s);
|
|
mon = xnregistry_lookup(handle, NULL);
|
if (mon == NULL || mon->magic != COBALT_MONITOR_MAGIC) {
|
ret = -EINVAL;
|
goto fail;
|
}
|
|
state = mon->state;
|
if ((state->flags & COBALT_MONITOR_PENDED) != 0 ||
|
xnsynch_pended_p(&mon->drain) || !list_empty(&mon->waiters)) {
|
ret = -EBUSY;
|
goto fail;
|
}
|
|
/*
|
* A monitor must be destroyed by the thread currently holding
|
* its gate lock.
|
*/
|
if (xnsynch_owner_check(&mon->gate, curr)) {
|
ret = -EPERM;
|
goto fail;
|
}
|
|
xnsynch_release(&mon->gate, curr);
|
cobalt_monitor_reclaim(&mon->resnode, s); /* drops lock */
|
|
xnsched_run();
|
|
return 0;
|
fail:
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
void cobalt_monitor_reclaim(struct cobalt_resnode *node, spl_t s)
|
{
|
struct cobalt_monitor *mon;
|
struct cobalt_umm *umm;
|
int pshared;
|
|
mon = container_of(node, struct cobalt_monitor, resnode);
|
pshared = (mon->flags & COBALT_MONITOR_SHARED) != 0;
|
xnsynch_destroy(&mon->gate);
|
xnsynch_destroy(&mon->drain);
|
xnregistry_remove(node->handle);
|
cobalt_del_resource(node);
|
cobalt_mark_deleted(mon);
|
xnlock_put_irqrestore(&nklock, s);
|
|
umm = &cobalt_ppd_get(pshared)->umm;
|
cobalt_umm_free(umm, mon->state);
|
xnfree(mon);
|
}
|
