event.c

Go to the documentation of this file.

/*
 * Copyright (c) 2014, Michael Müller
 * Copyright (c) 2014, Sebastian Lackner
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <process/event.h>
#include <process/object.h>
#include <memory/allocator.h>
#include <process/object.h>
#include <util/list.h>
#include <util/util.h>


static void __eventDestroy(struct object *obj);
static void __eventShutdown(struct object *obj, UNUSED uint32_t mode);
static int32_t __eventGetStatus(struct object *obj, UNUSED uint32_t mode);
static struct linkedList *__eventWait(struct object *obj, UNUSED uint32_t mode, uint32_t *result);
static void __eventSignal(struct object *obj, uint32_t result);
static bool __eventAttachObj(struct object *obj, struct object *subObj, uint32_t mode, uint32_t ident);
static bool __eventDetachObj(struct object *obj, uint32_t ident);

static const struct objectFunctions eventFunctions =
{
    __eventDestroy,
    NULL, /* getMinHandle */
    __eventShutdown,
    __eventGetStatus,
    __eventWait,
    __eventSignal,
    NULL, /* write */
    NULL, /* read */
    __eventAttachObj,
    __eventDetachObj,
};

static void __subEventSignal(struct object *obj, uint32_t result);

static const struct objectFunctions subEventFunctions =
{
    NULL, /* destroy */
    NULL, /* getMinHandle */
    NULL, /* shutdown */
    NULL, /* getStatus */
    NULL, /* wait */
    __subEventSignal,
    NULL, /* write */
    NULL, /* read */
    NULL, /* insert */
    NULL, /* remove */
};

struct event *eventCreate(bool wakeupAll)
{
    struct event *e;

    /* allocate some new memory */
    if (!(e = heapAlloc(sizeof(*e))))
        return NULL;

    /* initialize general object info */
    __objectInit(&e->obj, &eventFunctions);
    ll_init(&e->waiters);
    ll_init(&e->subEvents);
    e->status = 0;
    e->wakeupAll = wakeupAll;

    return e;
}

static void __eventDestroy(struct object *obj)
{
    struct event *e = objectContainer(obj, struct event, &eventFunctions);
    struct subEvent *sub, *__sub;

    /* release other threads if the user destroys the object before they return */
    queueWakeup(&e->waiters, true, -1);
    assert(ll_empty(&e->waiters));

    LL_FOR_EACH_SAFE(sub, __sub, &e->subEvents, struct subEvent, entry_event)
    {
        if (sub->blocked)
            ll_remove(&sub->obj.entry);
        ll_remove(&sub->entry_event); /* not really necessary, as the memory is deallocated afterwards */
        __objectRelease(sub->wait);

        sub->obj.functions = NULL;
        heapFree(sub);
    }

    /* release event memory */
    e->obj.functions = NULL;
    heapFree(e);
}

static void __eventShutdown(struct object *obj, UNUSED uint32_t mode)
{
    struct event *e = objectContainer(obj, struct event, &eventFunctions);
    queueWakeup(&e->waiters, true, -1);
}

static int32_t __eventGetStatus(struct object *obj, UNUSED uint32_t mode)
{
    struct event *e = objectContainer(obj, struct event, &eventFunctions);
    return e->status;
}

static struct linkedList *__eventWait(struct object *obj, UNUSED uint32_t mode, uint32_t *result)
{
    struct event *e = objectContainer(obj, struct event, &eventFunctions);
    struct subEvent *sub;
    struct linkedList *queue;

    LL_FOR_EACH(sub, &e->subEvents, struct subEvent, entry_event)
    {
        if (sub->blocked) continue;
        assert(sub->event == e);

        e->status = 0;
        queue = __objectWait(sub->wait, sub->waitMode, &e->status);
        if (queue)
        {
            sub->blocked = true;
            ll_add_after(queue, &sub->obj.entry);
        }
        else
        {
            *result = sub->identifier;
            return NULL;
        }
    }

    return &e->waiters;
}

static void __eventSignal(struct object *obj, uint32_t result)
{
    struct event *e = objectContainer(obj, struct event, &eventFunctions);
    e->status = 0;
    queueWakeup(&e->waiters, e->wakeupAll, result);
}

static bool __eventAttachObj(struct object *obj, struct object *subObj, uint32_t mode, uint32_t ident)
{
    struct subEvent *sub;
    struct event *e = objectContainer(obj, struct event, &eventFunctions);

    if (!(sub = heapAlloc(sizeof(*sub))))
        return false;

    /* initialize general object info */
    __objectInit(&sub->obj, &subEventFunctions);
    sub->blocked    = false;
    sub->event      = e;
    ll_add_tail(&e->subEvents, &sub->entry_event);
    sub->wait       = __objectAddRef(subObj);
    sub->waitMode   = mode;
    sub->identifier = ident;

    return true;
}

static bool __eventDetachObj(struct object *obj, uint32_t ident)
{
    struct event *e = objectContainer(obj, struct event, &eventFunctions);
    struct subEvent *sub, *__sub;
    bool success = false;

    LL_FOR_EACH_SAFE(sub, __sub, &e->subEvents, struct subEvent, entry_event)
    {
        if (sub->identifier == ident)
        {
            if (sub->blocked)
                ll_remove(&sub->obj.entry);
            ll_remove(&sub->entry_event);
            __objectRelease(sub->wait);

            sub->obj.functions = NULL;
            heapFree(sub);

            success = true;
        }
    }

    return success;
}

static void __subEventSignal(struct object *obj, uint32_t result)
{
    struct subEvent *s = objectContainer(obj, struct subEvent, &subEventFunctions);
    struct event *e = s->event;
    if (!s->blocked) return;

    s->blocked = false;
    ll_remove(&s->obj.entry);

    /* wakeup objects waiting for the main event */
    e->status = result;
    queueWakeup(&e->waiters, e->wakeupAll, s->identifier);
}