void
sendSignal(notification_t *ntfnPtr, word_t badge)
{
switch (notification_ptr_get_state(ntfnPtr)) {
case NtfnState_Idle: {
tcb_t *tcb = (tcb_t*)notification_ptr_get_ntfnBoundTCB(ntfnPtr);
/* Check if we are bound and that thread is waiting for a message */
if (tcb) {
if (thread_state_ptr_get_tsType(&tcb->tcbState) == ThreadState_BlockedOnReceive) {
/* Send and start thread running */
cancelIPC(tcb);
setThreadState(tcb, ThreadState_Running);
setRegister(tcb, badgeRegister, badge);
switchIfRequiredTo(tcb);
} else {
ntfn_set_active(ntfnPtr, badge);
}
} else {
ntfn_set_active(ntfnPtr, badge);
}
break;
}
case NtfnState_Waiting: {
tcb_queue_t ntfn_queue;
tcb_t *dest;
ntfn_queue = ntfn_ptr_get_queue(ntfnPtr);
dest = ntfn_queue.head;
/* Haskell error "WaitingNtfn Notification must have non-empty queue" */
assert(dest);
/* Dequeue TCB */
ntfn_queue = tcbEPDequeue(dest, ntfn_queue);
ntfn_ptr_set_queue(ntfnPtr, ntfn_queue);
/* set the thread state to idle if the queue is empty */
if (!ntfn_queue.head) {
notification_ptr_set_state(ntfnPtr, NtfnState_Idle);
}
setThreadState(dest, ThreadState_Running);
setRegister(dest, badgeRegister, badge);
switchIfRequiredTo(dest);
break;
}
case NtfnState_Active: {
word_t badge2;
badge2 = notification_ptr_get_ntfnMsgIdentifier(ntfnPtr);
badge2 |= badge;
notification_ptr_set_ntfnMsgIdentifier(ntfnPtr, badge2);
break;
}
}
}
void
receiveSignal(tcb_t *thread, cap_t cap, bool_t isBlocking)
{
notification_t *ntfnPtr;
ntfnPtr = NTFN_PTR(cap_notification_cap_get_capNtfnPtr(cap));
switch (notification_ptr_get_state(ntfnPtr)) {
case NtfnState_Idle:
case NtfnState_Waiting: {
tcb_queue_t ntfn_queue;
if (isBlocking) {
/* Block thread on notification object */
thread_state_ptr_set_tsType(&thread->tcbState,
ThreadState_BlockedOnNotification);
thread_state_ptr_set_blockingObject(&thread->tcbState,
NTFN_REF(ntfnPtr));
scheduleTCB(thread);
/* Enqueue TCB */
ntfn_queue = ntfn_ptr_get_queue(ntfnPtr);
ntfn_queue = tcbEPAppend(thread, ntfn_queue);
notification_ptr_set_state(ntfnPtr, NtfnState_Waiting);
ntfn_ptr_set_queue(ntfnPtr, ntfn_queue);
} else {
doNBRecvFailedTransfer(thread);
}
break;
}
case NtfnState_Active:
setRegister(
thread, badgeRegister,
notification_ptr_get_ntfnMsgIdentifier(ntfnPtr));
notification_ptr_set_state(ntfnPtr, NtfnState_Idle);
break;
}
}
void completeSignal(notification_t *ntfnPtr, tcb_t *tcb)
{
word_t badge;
if (likely(tcb && notification_ptr_get_state(ntfnPtr) == NtfnState_Active)) {
badge = notification_ptr_get_ntfnMsgIdentifier(ntfnPtr);
setRegister(tcb, badgeRegister, badge);
notification_ptr_set_state(ntfnPtr, NtfnState_Idle);
} else {
fail("tried to complete signal with inactive notification object");
}
}
void cancelAllSignals(notification_t *ntfnPtr)
{
if (notification_ptr_get_state(ntfnPtr) == NtfnState_Waiting) {
tcb_t *thread = TCB_PTR(notification_ptr_get_ntfnQueue_head(ntfnPtr));
notification_ptr_set_state(ntfnPtr, NtfnState_Idle);
notification_ptr_set_ntfnQueue_head(ntfnPtr, 0);
notification_ptr_set_ntfnQueue_tail(ntfnPtr, 0);
/* Set all waiting threads to Restart */
for (; thread; thread = thread->tcbEPNext) {
setThreadState(thread, ThreadState_Restart);
SCHED_ENQUEUE(thread);
}
rescheduleRequired();
}
}
void cancelSignal(tcb_t *threadPtr, notification_t *ntfnPtr)
{
tcb_queue_t ntfn_queue;
/* Haskell error "cancelSignal: notification object must be in a waiting" state */
assert(notification_ptr_get_state(ntfnPtr) == NtfnState_Waiting);
/* Dequeue TCB */
ntfn_queue = ntfn_ptr_get_queue(ntfnPtr);
ntfn_queue = tcbEPDequeue(threadPtr, ntfn_queue);
ntfn_ptr_set_queue(ntfnPtr, ntfn_queue);
/* Make notification object idle */
if (!ntfn_queue.head) {
notification_ptr_set_state(ntfnPtr, NtfnState_Idle);
}
/* Make thread inactive */
setThreadState(threadPtr, ThreadState_Inactive);
}
void sendSignal(notification_t *ntfnPtr, word_t badge)
{
switch (notification_ptr_get_state(ntfnPtr)) {
case NtfnState_Idle: {
tcb_t *tcb = (tcb_t *)notification_ptr_get_ntfnBoundTCB(ntfnPtr);
/* Check if we are bound and that thread is waiting for a message */
if (tcb) {
if (thread_state_ptr_get_tsType(&tcb->tcbState) == ThreadState_BlockedOnReceive) {
/* Send and start thread running */
cancelIPC(tcb);
setThreadState(tcb, ThreadState_Running);
setRegister(tcb, badgeRegister, badge);
possibleSwitchTo(tcb);
#ifdef CONFIG_VTX
} else if (thread_state_ptr_get_tsType(&tcb->tcbState) == ThreadState_RunningVM) {
#ifdef ENABLE_SMP_SUPPORT
if (tcb->tcbAffinity != getCurrentCPUIndex()) {
ntfn_set_active(ntfnPtr, badge);
doRemoteVMCheckBoundNotification(tcb->tcbAffinity, tcb);
} else
#endif /* ENABLE_SMP_SUPPORT */
{
setThreadState(tcb, ThreadState_Running);
setRegister(tcb, badgeRegister, badge);
Arch_leaveVMAsyncTransfer(tcb);
possibleSwitchTo(tcb);
}
#endif /* CONFIG_VTX */
} else {
/* In particular, this path is taken when a thread
* is waiting on a reply cap since BlockedOnReply
* would also trigger this path. I.e, a thread
* with a bound notification will not be awakened
* by signals on that bound notification if it is
* in the middle of an seL4_Call.
*/
ntfn_set_active(ntfnPtr, badge);
}
} else {
ntfn_set_active(ntfnPtr, badge);
}
break;
}
case NtfnState_Waiting: {
tcb_queue_t ntfn_queue;
tcb_t *dest;
ntfn_queue = ntfn_ptr_get_queue(ntfnPtr);
dest = ntfn_queue.head;
/* Haskell error "WaitingNtfn Notification must have non-empty queue" */
assert(dest);
/* Dequeue TCB */
ntfn_queue = tcbEPDequeue(dest, ntfn_queue);
ntfn_ptr_set_queue(ntfnPtr, ntfn_queue);
/* set the thread state to idle if the queue is empty */
if (!ntfn_queue.head) {
notification_ptr_set_state(ntfnPtr, NtfnState_Idle);
}
setThreadState(dest, ThreadState_Running);
setRegister(dest, badgeRegister, badge);
possibleSwitchTo(dest);
break;
}
case NtfnState_Active: {
word_t badge2;
badge2 = notification_ptr_get_ntfnMsgIdentifier(ntfnPtr);
badge2 |= badge;
notification_ptr_set_ntfnMsgIdentifier(ntfnPtr, badge2);
break;
}
}
}
static inline void ntfn_set_active(notification_t *ntfnPtr, word_t badge)
{
notification_ptr_set_state(ntfnPtr, NtfnState_Active);
notification_ptr_set_ntfnMsgIdentifier(ntfnPtr, badge);
}
