void deferred_event_init(struct deferred_event *event)
{
assert(event != NULL);
waitset_chanstate_init(&event->waitset_state, CHANTYPE_DEFERRED);
event->next = event->prev = NULL;
event->time = 0;
}
/**
* \brief Initialize the domain library
*
* Registers a iref with the monitor to offer the interdisp service on this core
* Does not block for completion.
*/
errval_t domain_init(void)
{
errval_t err;
struct domain_state *domain_state = malloc(sizeof(struct domain_state));
if (!domain_state) {
return LIB_ERR_MALLOC_FAIL;
}
set_domain_state(domain_state);
domain_state->iref = 0;
domain_state->default_waitset_handler = NULL;
domain_state->remote_wakeup_queue = NULL;
waitset_chanstate_init(&domain_state->remote_wakeup_event,
CHANTYPE_EVENT_QUEUE);
for (int i = 0; i < MAX_CPUS; i++) {
domain_state->b[i] = NULL;
}
waitset_init(&domain_state->interdisp_ws);
domain_state->conditional = false;
err = interdisp_export(NULL, server_listening, server_connected,
&domain_state->interdisp_ws, IDC_EXPORT_FLAGS_DEFAULT);
if (err_is_fail(err)) {
return err;
}
// XXX: Wait for the export to finish before returning
while(!domain_state->conditional) {
messages_wait_and_handle_next();
}
return SYS_ERR_OK;
}
/**
* \brief Initialise a new event queue
*
* \param q Storage for event queue
* \param waitset Waitset that will service the queue
* \param mode Operating mode for the queue
*/
void event_queue_init(struct event_queue *q, struct waitset *waitset,
enum event_queue_mode mode)
{
waitset_chanstate_init(&q->waitset_state, CHANTYPE_EVENT_QUEUE);
thread_mutex_init(&q->mutex);
q->head = q->tail = NULL;
q->waitset = waitset;
q->mode = mode;
}
/**
* \brief Initialise a new LMP channel
*
* \param lc Storage for channel state
*/
void lmp_chan_init(struct lmp_chan *lc)
{
assert(lc != NULL);
lc->connstate = LMP_DISCONNECTED;
waitset_chanstate_init(&lc->send_waitset, CHANTYPE_LMP_OUT);
lc->endpoint = NULL;
#ifndef NDEBUG
lc->prev = lc->next = NULL;
#endif
}
static void span_slave_done_request(struct interdisp_binding *b)
{
USER_PANIC("shouldn't be called");
struct waitset_chanstate *cs = malloc(sizeof(struct waitset_chanstate));
// Signal the default waitset of this event
struct event_closure closure = {
.handler = span_slave_done_handler,
.arg = cs,
};
waitset_chanstate_init(cs, CHANTYPE_EVENT_QUEUE);
errval_t err = waitset_chan_trigger_closure(get_default_waitset(), cs,
closure);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "Triggering default waitset");
}
}
/**
* \brief Handled for dispatcher_initialized msg type
*
* Called when a recently spanned dispatcher has initialized.
* Store it's connection object, and upcall into the registered callback
*/
static void dispatcher_initialized(struct interdisp_binding *st, genvaddr_t id)
{
struct span_domain_state *span_domain_state = (struct span_domain_state*)(uintptr_t)id;
// Signal the default waitset of this event
struct event_closure closure = {
.handler = dispatcher_initialized_handler,
.arg = span_domain_state,
};
waitset_chanstate_init(&span_domain_state->initev, CHANTYPE_EVENT_QUEUE);
errval_t err = waitset_chan_trigger_closure(get_default_waitset(),
&span_domain_state->initev,
closure);
if(err_is_fail(err)) {
USER_PANIC_ERR(err, "Triggering default waitset");
}
}
void flounder_support_waitset_chanstate_init(struct waitset_chanstate *wc)
{
waitset_chanstate_init(wc, CHANTYPE_FLOUNDER);
}
