/*
|
* Copyright (C) 2012 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 "event.h"
|
#include <trace/events/cobalt-posix.h>
|
#include <cobalt/kernel/time.h>
|
|
/*
|
* Cobalt event notification services
|
*
|
* An event flag group is a synchronization object represented by a
|
* regular native integer; every available bit in such word can be
|
* used to map a user-defined event flag. When a flag is set, the
|
* associated event is said to have occurred.
|
*
|
* Xenomai threads and interrupt handlers can use event flags to
|
* signal the occurrence of events to other threads; those threads can
|
* either wait for the events to occur in a conjunctive manner (all
|
* awaited events must have occurred to wake up), or in a disjunctive
|
* way (at least one of the awaited events must have occurred to wake
|
* up).
|
*
|
* We expose this non-POSIX feature through the internal API, as a
|
* fast IPC mechanism available to the Copperplate interface.
|
*/
|
|
struct event_wait_context {
|
struct xnthread_wait_context wc;
|
unsigned int value;
|
int mode;
|
};
|
|
COBALT_SYSCALL(event_init, current,
|
(struct cobalt_event_shadow __user *u_event,
|
unsigned int value, int flags))
|
{
|
struct cobalt_event_shadow shadow;
|
struct cobalt_event_state *state;
|
int pshared, synflags, ret;
|
struct cobalt_event *event;
|
struct cobalt_umm *umm;
|
unsigned long stateoff;
|
spl_t s;
|
|
trace_cobalt_event_init(u_event, value, flags);
|
|
event = xnmalloc(sizeof(*event));
|
if (event == NULL)
|
return -ENOMEM;
|
|
pshared = (flags & COBALT_EVENT_SHARED) != 0;
|
umm = &cobalt_ppd_get(pshared)->umm;
|
state = cobalt_umm_alloc(umm, sizeof(*state));
|
if (state == NULL) {
|
xnfree(event);
|
return -EAGAIN;
|
}
|
|
ret = xnregistry_enter_anon(event, &event->resnode.handle);
|
if (ret) {
|
cobalt_umm_free(umm, state);
|
xnfree(event);
|
return ret;
|
}
|
|
event->state = state;
|
event->flags = flags;
|
synflags = (flags & COBALT_EVENT_PRIO) ? XNSYNCH_PRIO : XNSYNCH_FIFO;
|
xnsynch_init(&event->synch, synflags, NULL);
|
state->value = value;
|
state->flags = 0;
|
state->nwaiters = 0;
|
stateoff = cobalt_umm_offset(umm, state);
|
XENO_BUG_ON(COBALT, stateoff != (__u32)stateoff);
|
|
xnlock_get_irqsave(&nklock, s);
|
cobalt_add_resource(&event->resnode, event, pshared);
|
event->magic = COBALT_EVENT_MAGIC;
|
xnlock_put_irqrestore(&nklock, s);
|
|
shadow.flags = flags;
|
shadow.handle = event->resnode.handle;
|
shadow.state_offset = (__u32)stateoff;
|
|
return cobalt_copy_to_user(u_event, &shadow, sizeof(*u_event));
|
}
|
|
int __cobalt_event_wait(struct cobalt_event_shadow __user *u_event,
|
unsigned int bits,
|
unsigned int __user *u_bits_r,
|
int mode, const struct timespec64 *ts)
|
{
|
unsigned int rbits = 0, testval;
|
xnticks_t timeout = XN_INFINITE;
|
struct cobalt_event_state *state;
|
xntmode_t tmode = XN_RELATIVE;
|
struct event_wait_context ewc;
|
struct cobalt_event *event;
|
xnhandle_t handle;
|
int ret = 0, info;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_event->handle);
|
|
if (ts) {
|
if (!timespec64_valid(ts))
|
return -EINVAL;
|
|
timeout = ts2ns(ts);
|
if (timeout) {
|
timeout++;
|
tmode = XN_ABSOLUTE;
|
} else
|
timeout = XN_NONBLOCK;
|
trace_cobalt_event_timedwait(u_event, bits, mode, ts);
|
} else
|
trace_cobalt_event_wait(u_event, bits, mode);
|
|
xnlock_get_irqsave(&nklock, s);
|
|
event = xnregistry_lookup(handle, NULL);
|
if (event == NULL || event->magic != COBALT_EVENT_MAGIC) {
|
ret = -EINVAL;
|
goto out;
|
}
|
|
state = event->state;
|
|
if (bits == 0) {
|
/*
|
* Special case: we don't wait for any event, we only
|
* return the current flag group value.
|
*/
|
rbits = state->value;
|
goto out;
|
}
|
|
state->flags |= COBALT_EVENT_PENDED;
|
rbits = state->value & bits;
|
testval = mode & COBALT_EVENT_ANY ? rbits : bits;
|
if (rbits && rbits == testval)
|
goto done;
|
|
if (timeout == XN_NONBLOCK) {
|
ret = -EWOULDBLOCK;
|
goto done;
|
}
|
|
ewc.value = bits;
|
ewc.mode = mode;
|
xnthread_prepare_wait(&ewc.wc);
|
state->nwaiters++;
|
info = xnsynch_sleep_on(&event->synch, timeout, tmode);
|
if (info & XNRMID) {
|
ret = -EIDRM;
|
goto out;
|
}
|
if (info & (XNBREAK|XNTIMEO)) {
|
state->nwaiters--;
|
ret = (info & XNBREAK) ? -EINTR : -ETIMEDOUT;
|
} else
|
rbits = ewc.value;
|
done:
|
if (!xnsynch_pended_p(&event->synch))
|
state->flags &= ~COBALT_EVENT_PENDED;
|
out:
|
xnlock_put_irqrestore(&nklock, s);
|
|
if (ret == 0 &&
|
cobalt_copy_to_user(u_bits_r, &rbits, sizeof(rbits)))
|
return -EFAULT;
|
|
return ret;
|
}
|
|
int __cobalt_event_wait64(struct cobalt_event_shadow __user *u_event,
|
unsigned int bits,
|
unsigned int __user *u_bits_r,
|
int mode, const struct __kernel_timespec __user *u_ts)
|
{
|
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_event_wait(u_event, bits, u_bits_r, mode, tsp);
|
}
|
|
COBALT_SYSCALL(event_wait, primary,
|
(struct cobalt_event_shadow __user *u_event,
|
unsigned int bits,
|
unsigned int __user *u_bits_r,
|
int mode, const struct __user_old_timespec __user *u_ts))
|
{
|
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_event_wait(u_event, bits, u_bits_r, mode, tsp);
|
}
|
|
COBALT_SYSCALL(event_wait64, primary,
|
(struct cobalt_event_shadow __user *u_event,
|
unsigned int bits,
|
unsigned int __user *u_bits_r,
|
int mode, const struct __kernel_timespec __user *u_ts))
|
{
|
return __cobalt_event_wait64(u_event, bits, u_bits_r, mode, u_ts);
|
}
|
|
COBALT_SYSCALL(event_sync, current,
|
(struct cobalt_event_shadow __user *u_event))
|
{
|
unsigned int bits, waitval, testval;
|
struct xnthread_wait_context *wc;
|
struct cobalt_event_state *state;
|
struct event_wait_context *ewc;
|
struct cobalt_event *event;
|
struct xnthread *p, *tmp;
|
xnhandle_t handle;
|
int ret = 0;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_event->handle);
|
|
xnlock_get_irqsave(&nklock, s);
|
|
event = xnregistry_lookup(handle, NULL);
|
if (event == NULL || event->magic != COBALT_EVENT_MAGIC) {
|
ret = -EINVAL;
|
goto out;
|
}
|
|
/*
|
* Userland has already updated the bitmask, our job is to
|
* wake up any thread which could be satisfied by its current
|
* value.
|
*/
|
state = event->state;
|
bits = state->value;
|
|
xnsynch_for_each_sleeper_safe(p, tmp, &event->synch) {
|
wc = xnthread_get_wait_context(p);
|
ewc = container_of(wc, struct event_wait_context, wc);
|
waitval = ewc->value & bits;
|
testval = ewc->mode & COBALT_EVENT_ANY ? waitval : ewc->value;
|
if (waitval && waitval == testval) {
|
state->nwaiters--;
|
ewc->value = waitval;
|
xnsynch_wakeup_this_sleeper(&event->synch, p);
|
}
|
}
|
|
xnsched_run();
|
out:
|
xnlock_put_irqrestore(&nklock, s);
|
|
return ret;
|
}
|
|
COBALT_SYSCALL(event_destroy, current,
|
(struct cobalt_event_shadow __user *u_event))
|
{
|
struct cobalt_event *event;
|
xnhandle_t handle;
|
spl_t s;
|
|
trace_cobalt_event_destroy(u_event);
|
|
handle = cobalt_get_handle_from_user(&u_event->handle);
|
|
xnlock_get_irqsave(&nklock, s);
|
|
event = xnregistry_lookup(handle, NULL);
|
if (event == NULL || event->magic != COBALT_EVENT_MAGIC) {
|
xnlock_put_irqrestore(&nklock, s);
|
return -EINVAL;
|
}
|
|
cobalt_event_reclaim(&event->resnode, s); /* drops lock */
|
|
return 0;
|
}
|
|
COBALT_SYSCALL(event_inquire, current,
|
(struct cobalt_event_shadow __user *u_event,
|
struct cobalt_event_info __user *u_info,
|
pid_t __user *u_waitlist,
|
size_t waitsz))
|
{
|
int nrpend = 0, nrwait = 0, nrpids, ret = 0;
|
unsigned long pstamp, nstamp = 0;
|
struct cobalt_event_info info;
|
struct cobalt_event *event;
|
pid_t *t = NULL, fbuf[16];
|
struct xnthread *thread;
|
xnhandle_t handle;
|
spl_t s;
|
|
handle = cobalt_get_handle_from_user(&u_event->handle);
|
|
nrpids = waitsz / sizeof(pid_t);
|
|
xnlock_get_irqsave(&nklock, s);
|
|
for (;;) {
|
pstamp = nstamp;
|
event = xnregistry_lookup(handle, &nstamp);
|
if (event == NULL || event->magic != COBALT_EVENT_MAGIC) {
|
xnlock_put_irqrestore(&nklock, s);
|
return -EINVAL;
|
}
|
/*
|
* Allocate memory to return the wait list without
|
* holding any lock, then revalidate the handle.
|
*/
|
if (t == NULL) {
|
nrpend = 0;
|
if (!xnsynch_pended_p(&event->synch))
|
break;
|
xnsynch_for_each_sleeper(thread, &event->synch)
|
nrpend++;
|
if (u_waitlist == NULL)
|
break;
|
xnlock_put_irqrestore(&nklock, s);
|
if (nrpids > nrpend)
|
nrpids = nrpend;
|
if (nrpend <= ARRAY_SIZE(fbuf))
|
t = fbuf; /* Use fast buffer. */
|
else {
|
t = xnmalloc(nrpend * sizeof(pid_t));
|
if (t == NULL)
|
return -ENOMEM;
|
}
|
xnlock_get_irqsave(&nklock, s);
|
} else if (pstamp == nstamp)
|
break;
|
else {
|
xnlock_put_irqrestore(&nklock, s);
|
if (t != fbuf)
|
xnfree(t);
|
t = NULL;
|
xnlock_get_irqsave(&nklock, s);
|
}
|
}
|
|
info.flags = event->flags;
|
info.value = event->value;
|
info.nrwait = nrpend;
|
|
if (xnsynch_pended_p(&event->synch) && u_waitlist != NULL) {
|
xnsynch_for_each_sleeper(thread, &event->synch) {
|
if (nrwait >= nrpids)
|
break;
|
t[nrwait++] = xnthread_host_pid(thread);
|
}
|
}
|
|
xnlock_put_irqrestore(&nklock, s);
|
|
ret = cobalt_copy_to_user(u_info, &info, sizeof(info));
|
if (ret == 0 && nrwait > 0)
|
ret = cobalt_copy_to_user(u_waitlist, t, nrwait * sizeof(pid_t));
|
|
if (t && t != fbuf)
|
xnfree(t);
|
|
return ret ?: nrwait;
|
}
|
|
void cobalt_event_reclaim(struct cobalt_resnode *node, spl_t s)
|
{
|
struct cobalt_event *event;
|
struct cobalt_umm *umm;
|
int pshared;
|
|
event = container_of(node, struct cobalt_event, resnode);
|
xnregistry_remove(node->handle);
|
cobalt_del_resource(node);
|
xnsynch_destroy(&event->synch);
|
pshared = (event->flags & COBALT_EVENT_SHARED) != 0;
|
xnlock_put_irqrestore(&nklock, s);
|
|
umm = &cobalt_ppd_get(pshared)->umm;
|
cobalt_umm_free(umm, event->state);
|
xnfree(event);
|
}
|
