/*
|
* Copyright (C) 2012 Philippe Gerum <rpm@xenomai.org>.
|
*
|
* This library is free software; you can redistribute it and/or
|
* modify it under the terms of the GNU Lesser General Public
|
* License as published by the Free Software Foundation; either
|
* version 2 of the License, or (at your option) any later version.
|
*
|
* This library 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
|
* Lesser General Public License for more details.
|
|
* You should have received a copy of the GNU Lesser General Public
|
* License along with this library; if not, write to the Free Software
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
|
*/
|
|
#include <assert.h>
|
#include <errno.h>
|
#include "copperplate/threadobj.h"
|
#include "copperplate/eventobj.h"
|
#include "copperplate/heapobj.h"
|
#include "copperplate/debug.h"
|
|
#ifdef CONFIG_XENO_COBALT
|
|
#include "cobalt/internal.h"
|
|
int eventobj_init(struct eventobj *evobj, unsigned int value, int flags,
|
fnref_type(void (*)(struct eventobj *evobj)) finalizer)
|
{
|
int ret, event_flags = event_scope_attribute;
|
|
if (flags & EVOBJ_PRIO)
|
event_flags |= COBALT_EVENT_PRIO;
|
|
ret = cobalt_event_init(&evobj->core.event, value, event_flags);
|
if (ret)
|
return __bt(ret);
|
|
evobj->finalizer = finalizer;
|
|
return 0;
|
}
|
|
int eventobj_destroy(struct eventobj *evobj)
|
{
|
void (*finalizer)(struct eventobj *evobj);
|
int ret;
|
|
ret = cobalt_event_destroy(&evobj->core.event);
|
if (ret)
|
return ret;
|
|
fnref_get(finalizer, evobj->finalizer);
|
finalizer(evobj);
|
|
return 0;
|
}
|
|
void eventobj_uninit(struct eventobj *evobj)
|
{
|
int ret = cobalt_event_destroy(&evobj->core.event);
|
assert(ret == 0);
|
(void)ret;
|
}
|
|
int eventobj_wait(struct eventobj *evobj,
|
unsigned int bits, unsigned int *bits_r,
|
int mode, const struct timespec *timeout)
|
{
|
int ret;
|
|
ret = cobalt_event_wait(&evobj->core.event,
|
bits, bits_r, mode, timeout);
|
if (ret)
|
return ret;
|
|
return 0;
|
}
|
|
int eventobj_post(struct eventobj *evobj, unsigned int bits)
|
{
|
int ret;
|
|
ret = cobalt_event_post(&evobj->core.event, bits);
|
if (ret)
|
return ret;
|
|
return 0;
|
}
|
|
int eventobj_clear(struct eventobj *evobj, unsigned int bits,
|
unsigned int *bits_r)
|
{
|
unsigned int oldval;
|
|
oldval = cobalt_event_clear(&evobj->core.event, bits);
|
if (bits_r)
|
*bits_r = oldval;
|
|
return 0;
|
}
|
|
int eventobj_inquire(struct eventobj *evobj, size_t waitsz,
|
struct eventobj_waitentry *waitlist,
|
unsigned int *bits_r)
|
{
|
struct cobalt_threadstat stat;
|
struct cobalt_event_info info;
|
int nrwait, pidsz, n, ret;
|
pid_t *pidlist = NULL;
|
|
pidsz = sizeof(pid_t) * (waitsz / sizeof(*waitlist));
|
if (pidsz > 0) {
|
pidlist = pvmalloc(pidsz);
|
if (pidlist == NULL)
|
return -ENOMEM;
|
}
|
|
nrwait = cobalt_event_inquire(&evobj->core.event, &info, pidlist, pidsz);
|
if (nrwait < 0)
|
goto out;
|
|
*bits_r = info.value;
|
|
if (pidlist == NULL)
|
return nrwait;
|
|
for (n = 0; n < nrwait; n++, waitlist++) {
|
ret = cobalt_thread_stat(pidlist[n], &stat);
|
/* If waiter disappeared, fill in a dummy entry. */
|
if (ret) {
|
waitlist->pid = -1;
|
strcpy(waitlist->name, "???");
|
} else {
|
waitlist->pid = pidlist[n];
|
strcpy(waitlist->name, stat.name);
|
}
|
}
|
out:
|
if (pidlist)
|
pvfree(pidlist);
|
|
return nrwait;
|
}
|
|
#else /* CONFIG_XENO_MERCURY */
|
|
static void eventobj_finalize(struct syncobj *sobj)
|
{
|
struct eventobj *evobj = container_of(sobj, struct eventobj, core.sobj);
|
void (*finalizer)(struct eventobj *evobj);
|
|
fnref_get(finalizer, evobj->finalizer);
|
finalizer(evobj);
|
}
|
fnref_register(libcopperplate, eventobj_finalize);
|
|
int eventobj_init(struct eventobj *evobj, unsigned int value, int flags,
|
fnref_type(void (*)(struct eventobj *evobj)) finalizer)
|
{
|
int sobj_flags = 0, ret;
|
|
if (flags & EVOBJ_PRIO)
|
sobj_flags = SYNCOBJ_PRIO;
|
|
ret = syncobj_init(&evobj->core.sobj, CLOCK_COPPERPLATE, sobj_flags,
|
fnref_put(libcopperplate, eventobj_finalize));
|
if (ret)
|
return __bt(ret);
|
|
evobj->core.flags = flags;
|
evobj->core.value = value;
|
evobj->finalizer = finalizer;
|
|
return 0;
|
}
|
|
int eventobj_destroy(struct eventobj *evobj)
|
{
|
struct syncstate syns;
|
int ret;
|
|
if (syncobj_lock(&evobj->core.sobj, &syns))
|
return -EINVAL;
|
|
ret = syncobj_destroy(&evobj->core.sobj, &syns);
|
if (ret < 0)
|
return ret;
|
|
return 0;
|
}
|
|
void eventobj_uninit(struct eventobj *evobj)
|
{
|
syncobj_uninit(&evobj->core.sobj);
|
}
|
|
int eventobj_wait(struct eventobj *evobj,
|
unsigned int bits, unsigned int *bits_r,
|
int mode, const struct timespec *timeout)
|
{
|
struct eventobj_wait_struct *wait;
|
unsigned int waitval, testval;
|
struct syncstate syns;
|
int ret = 0;
|
|
ret = syncobj_lock(&evobj->core.sobj, &syns);
|
if (ret)
|
return ret;
|
|
if (bits == 0) {
|
*bits_r = evobj->core.value;
|
goto done;
|
}
|
|
waitval = evobj->core.value & bits;
|
testval = mode & EVOBJ_ANY ? waitval : bits;
|
|
if (waitval && waitval == testval) {
|
*bits_r = waitval;
|
goto done;
|
}
|
|
/* Have to wait. */
|
|
if (timeout && timeout->tv_sec == 0 && timeout->tv_nsec == 0) {
|
ret = -EWOULDBLOCK;
|
goto done;
|
}
|
|
wait = threadobj_prepare_wait(struct eventobj_wait_struct);
|
wait->value = bits;
|
wait->mode = mode;
|
|
ret = syncobj_wait_grant(&evobj->core.sobj, timeout, &syns);
|
if (ret == -EIDRM) {
|
threadobj_finish_wait();
|
return ret;
|
}
|
|
if (ret == 0)
|
*bits_r = wait->value;
|
|
threadobj_finish_wait();
|
done:
|
syncobj_unlock(&evobj->core.sobj, &syns);
|
|
return ret;
|
}
|
|
int eventobj_post(struct eventobj *evobj, unsigned int bits)
|
{
|
struct eventobj_wait_struct *wait;
|
unsigned int waitval, testval;
|
struct threadobj *thobj, *tmp;
|
struct syncstate syns;
|
int ret;
|
|
ret = syncobj_lock(&evobj->core.sobj, &syns);
|
if (ret)
|
return ret;
|
|
evobj->core.value |= bits;
|
|
if (!syncobj_grant_wait_p(&evobj->core.sobj))
|
goto done;
|
|
syncobj_for_each_grant_waiter_safe(&evobj->core.sobj, thobj, tmp) {
|
wait = threadobj_get_wait(thobj);
|
waitval = wait->value & bits;
|
testval = wait->mode & EVOBJ_ANY ? waitval : wait->value;
|
if (waitval && waitval == testval) {
|
wait->value = waitval;
|
syncobj_grant_to(&evobj->core.sobj, thobj);
|
}
|
}
|
done:
|
syncobj_unlock(&evobj->core.sobj, &syns);
|
|
return 0;
|
}
|
|
int eventobj_clear(struct eventobj *evobj,
|
unsigned int bits,
|
unsigned int *bits_r)
|
{
|
struct syncstate syns;
|
unsigned int oldval;
|
int ret;
|
|
ret = syncobj_lock(&evobj->core.sobj, &syns);
|
if (ret)
|
return ret;
|
|
oldval = evobj->core.value;
|
evobj->core.value &= ~bits;
|
|
syncobj_unlock(&evobj->core.sobj, &syns);
|
|
if (bits_r)
|
*bits_r = oldval;
|
|
return 0;
|
}
|
|
int eventobj_inquire(struct eventobj *evobj, size_t waitsz,
|
struct eventobj_waitentry *waitlist,
|
unsigned int *bits_r)
|
{
|
struct threadobj *thobj;
|
struct syncstate syns;
|
int ret, nrwait;
|
|
ret = syncobj_lock(&evobj->core.sobj, &syns);
|
if (ret)
|
return ret;
|
|
nrwait = syncobj_count_grant(&evobj->core.sobj);
|
if (nrwait > 0) {
|
syncobj_for_each_grant_waiter(&evobj->core.sobj, thobj) {
|
waitlist->pid = threadobj_get_pid(thobj);
|
strcpy(waitlist->name, threadobj_get_name(thobj));
|
waitlist++;
|
}
|
}
|
|
*bits_r = evobj->core.value;
|
|
syncobj_unlock(&evobj->core.sobj, &syns);
|
|
return nrwait;
|
}
|
|
#endif /* CONFIG_XENO_MERCURY */
|
