/**
* \brief Wakeup a thread on a foreign dispatcher while disabled.
*
* \param core_id Core ID to wakeup on
* \param thread Pointer to thread to wakeup
* \param mydisp Dispatcher this function is running on
*
* \return SYS_ERR_OK on success.
*/
static errval_t domain_wakeup_on_coreid_disabled(coreid_t core_id,
struct thread *thread,
dispatcher_handle_t mydisp)
{
struct domain_state *ds = get_domain_state();
// XXX: Ugly hack to allow waking up on a core id we don't have a
// dispatcher handler for
thread->coreid = core_id;
// Catch this early
assert_disabled(ds != NULL);
if (ds->b[core_id] == NULL) {
return LIB_ERR_NO_SPANNED_DISP;
}
thread_enqueue(thread, &ds->remote_wakeup_queue);
// Signal the inter-disp waitset of this event
struct event_closure closure = {
.handler = handle_wakeup_on
};
errval_t err =
waitset_chan_trigger_closure_disabled(&ds->interdisp_ws,
&ds->remote_wakeup_event,
closure,
mydisp);
assert_disabled(err_is_ok(err) ||
err_no(err) == LIB_ERR_CHAN_ALREADY_REGISTERED);
return SYS_ERR_OK;
}
/**
* \brief Trigger a specific event callback on an unregistered channel
*
* This function is equivalent to waitset_chan_register()
* followed by waitset_chan_trigger(), but avoids unneccessary queue
* manipulation. This function must only be called when enabled.
*
* \param ws Waitset
* \param chan Waitset's per-channel state
* \param closure Event handler
*/
errval_t waitset_chan_trigger_closure(struct waitset *ws,
struct waitset_chanstate *chan,
struct event_closure closure)
{
dispatcher_handle_t disp = disp_disable();
errval_t err = waitset_chan_trigger_closure_disabled(ws, chan, closure, disp);
disp_enable(disp);
return err;
}
