mbox_base.c

/*
 * Copyright (C) 2016 Kaspar Schleiser <kaspar@schleiser.de>
 *               2018 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */

/**
 * @ingroup     core_mbox_base
 * @{
 *
 * @file
 * @brief   basic mailbox implementation
 *
 * @author  Kaspar Schleiser <kaspar@schleiser.de>
 * @author  Martine Lenders <m.lenders@fu-berlin.de>
 */

#include <string.h>

#include "mbox_base.h"
#include "irq.h"
#include "sched.h"
#include "thread.h"

#define ENABLE_DEBUG (0)
#include "debug.h"

void _mbox_base_notify(thread_t *thread, unsigned irqstate)
{
    sched_set_status(thread, STATUS_PENDING);

    DEBUG("mbox_base: Thread %" PRIkernel_pid ": _notify(): waking up "
          "%" PRIkernel_pid ".\n", sched_active_pid, thread->pid);

    uint16_t process_priority = thread->priority;
    irq_restore(irqstate);
    sched_switch(process_priority);
}

void _mbox_base_wait(list_node_t *wait_queue, unsigned irqstate)
{
    DEBUG("mbox_base: Thread %" PRIkernel_pid " _wait(): going blocked.\n",
          sched_active_pid);

    thread_t *me = (thread_t*) sched_active_thread;
    sched_set_status(me, STATUS_MBOX_BLOCKED);
    thread_add_to_list(wait_queue, me);
    irq_restore(irqstate);
    thread_yield();

    DEBUG("mbox_base: Thread %" PRIkernel_pid " _wait(): woke up.\n",
          sched_active_pid);
}

int _mbox_base_put(mbox_base_t *mbox, msg_t *msg, int blocking)
{
    unsigned irqstate = irq_disable();

    if (cib_full(&mbox->cib)) {
        if (blocking) {
            _mbox_base_wait(&mbox->writers, irqstate);
            irqstate = irq_disable();
        }
        else {
            irq_restore(irqstate);
            return 0;
        }
    }

    DEBUG("mbox_base: Thread %" PRIkernel_pid " mbox 0x%p: _tryput(): "
          "queued message.\n", sched_active_pid, (void *)mbox);
    msg->sender_pid = sched_active_pid;
    /* copy msg into queue */
    mbox->msg_array[cib_put_unsafe(&mbox->cib)] = *msg;
    irq_restore(irqstate);
    return 1;
}

int _mbox_base_get(mbox_base_t *mbox, msg_t *msg, int blocking)
{
    unsigned irqstate = irq_disable();

    if (cib_avail(&mbox->cib)) {
        DEBUG("mbox_base: Thread %" PRIkernel_pid " mbox 0x%p: _tryget(): "
              "got queued message.\n", sched_active_pid, (void *)mbox);
        /* copy msg from queue */
        *msg = mbox->msg_array[cib_get_unsafe(&mbox->cib)];
        list_node_t *next = (list_node_t*) list_remove_head(&mbox->writers);
        if (next) {
            thread_t *thread = container_of((clist_node_t*)next, thread_t,
                                            rq_entry);
            _mbox_base_notify(thread, irqstate);
        }
        else {
            irq_restore(irqstate);
        }
        return 1;
    }
    else if (blocking) {
        sched_active_thread->wait_data = (void *)msg;
        /* sender has copied message */
        return 1;
    }
    else {
        irq_restore(irqstate);
        return 0;
    }
}

/** @} */