blob: 1af9de71f84b839012bc6331ba2ad5f5f72d1a05 [file] [log] [blame]
/*
* Copyright 2017, Data61
* Commonwealth Scientific and Industrial Research Organisation (CSIRO)
* ABN 41 687 119 230.
*
* This software may be distributed and modified according to the terms of
* the BSD 2-Clause license. Note that NO WARRANTY is provided.
* See "LICENSE_BSD2.txt" for details.
*
* @TAG(DATA61_BSD)
*/
#pragma once
#include <autoconf.h>
#include <sel4/sel4.h>
#include <vka/vka.h>
#include <vka/object.h>
#include <platsupport/sync/atomic.h>
#include <stdbool.h>
typedef struct {
vka_object_t notification;
volatile int waiters;
volatile bool broadcasting;
} sync_cv_t;
/* Initialise an unmanaged condition variable
* @param cv A condition variable object to be initialised.
* @param notification A notification object to use for wake up.
* @return 0 on success, an error code on failure. */
static inline int sync_cv_init(sync_cv_t *cv, seL4_CPtr notification)
{
if (cv == NULL) {
ZF_LOGE("Condition variable passed to sync_cv_init is NULL");
return -1;
}
#ifdef CONFIG_DEBUG_BUILD
/* Check the cap actually is a notification. */
assert(seL4_DebugCapIdentify(notification) == 6);
#endif
cv->notification.cptr = notification;
cv->waiters = 0;
cv->broadcasting = false;
return 0;
}
/* Wait on a condition variable.
* This assumes that you already hold the lock and will block until notified
* by sync_cv_signal or sync_cv_broadcast. It returns once you hold the lock
* again. Note that a spurious wake up is possible and the condition should
* always be checked again after sync_cv_wait returns.
* @param lock The lock on the monitor.
* @param cv The condition variable to wait on.
* @return 0 on success, an error code on failure. */
static inline int sync_cv_wait(sync_bin_sem_t *lock, sync_cv_t *cv)
{
if (cv == NULL) {
ZF_LOGE("Condition variable passed to sync_cv_wait is NULL");
return -1;
}
/* Increment waiters count and release the lock */
cv->waiters++;
cv->broadcasting = false;
int error = sync_bin_sem_post(lock);
if (error != 0) {
return error;
}
/* Wait to be notified */
seL4_Wait(cv->notification.cptr, NULL);
/* Reacquire the lock */
error = sync_bin_sem_wait(lock);
if (error != 0) {
return error;
}
/* Wake up and decrement waiters count */
cv->waiters--;
/* Handle the case where a broadcast is ongoing */
if (cv->broadcasting) {
if (cv->waiters > 0) {
/* Signal the next thread and continue */
seL4_Signal(cv->notification.cptr);
} else {
/* This is the last thread, so stop broadcasting */
cv->broadcasting = false;
}
}
return 0;
}
/* Signal a condition variable.
* This assumes that you hold the lock and notifies one waiter
* @param cv The condition variable to signal.
* @return 0 on success, an error code on failure. */
static inline int sync_cv_signal(sync_cv_t *cv)
{
if (cv == NULL) {
ZF_LOGE("Condition variable passed to sync_cv_signal is NULL");
return -1;
}
if (cv->waiters > 0) {
seL4_Signal(cv->notification.cptr);
}
return 0;
}
/* Broadcast to a condition variable.
* This assumes that you hold the lock and notifies all waiters
* @param cv The condition variable to broadcast to.
* @return 0 on success, an error code on failure. */
static inline int sync_cv_broadcast(sync_cv_t *cv)
{
if (cv == NULL) {
ZF_LOGE("Condition variable passed to sync_cv_broadcast is NULL");
return -1;
}
if (cv->waiters > 0) {
cv->broadcasting = true;
seL4_Signal(cv->notification.cptr);
}
return 0;
}
/* Broadcast to a condition variable and release the lock.
* This function is useful in situations where the scheduler might wake up a
* waiter immediately after a signal (i.e. if the broadcaster is lower priority).
* For performance reasons it is useful to release the lock prior to signalling
* the condition variable in this case.
* @param cv The condition variable to broadcast to.
* @return 0 on success, an error code on failure. */
static inline int sync_cv_broadcast_release(sync_bin_sem_t *lock, sync_cv_t *cv)
{
if (cv == NULL) {
ZF_LOGE("Condition variable passed to sync_cv_broadcast_release is NULL");
return -1;
}
if (cv->waiters > 0) {
cv->broadcasting = true;
int error = sync_bin_sem_post(lock);
if (error != 0) {
return error;
}
seL4_Signal(cv->notification.cptr);
return 0;
} else {
return sync_bin_sem_post(lock);
}
}
/* Initialise a managed condition variable.
* @param vka A VKA instance used to allocate the notification object.
* @param cv A condition variable object to initialise.
* @return 0 on success, an error code on failure. */
static inline int sync_cv_new(vka_t *vka, sync_cv_t *cv)
{
if (cv == NULL) {
ZF_LOGE("Condition variable passed to sync_cv_new is NULL");
return -1;
}
int error = vka_alloc_notification(vka, &(cv->notification));
if (error != 0) {
return error;
} else {
return sync_cv_init(cv, cv->notification.cptr);
}
}
/* Destroy a managed condition variable.
* Uses the passed vka instance to deallocate the notification object.
* This function is not to be used on unmanaged condition variables.
* @param vka A VKA instance used to deallocate the notification object.
* @param cv A condition variable object initialised by sync_cv_new.
* @return 0 on success, an error code on failure. */
static inline int sync_cv_destroy(vka_t *vka, sync_cv_t *cv)
{
if (cv == NULL) {
ZF_LOGE("Condition variable passed to sync_cv_destroy is NULL");
return -1;
}
vka_free_object(vka, &(cv->notification));
return 0;
}