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 unbindMaybeNotification(notification_t *ntfnPtr)
{
tcb_t *boundTCB;
boundTCB = (tcb_t *)notification_ptr_get_ntfnBoundTCB(ntfnPtr);
if (boundTCB) {
doUnbindNotification(ntfnPtr, boundTCB);
}
}
static void
handleRecv(bool_t isBlocking)
{
word_t epCPtr;
lookupCap_ret_t lu_ret;
epCPtr = getRegister(ksCurThread, capRegister);
lu_ret = lookupCap(ksCurThread, epCPtr);
#if defined(DEBUG) || defined(CONFIG_BENCHMARK_TRACK_KERNEL_ENTRIES)
ksKernelEntry.cap_type = cap_get_capType(lu_ret.cap);
#endif
if (unlikely(lu_ret.status != EXCEPTION_NONE)) {
/* current_lookup_fault has been set by lookupCap */
current_fault = fault_cap_fault_new(epCPtr, true);
handleFault(ksCurThread);
return;
}
switch (cap_get_capType(lu_ret.cap)) {
case cap_endpoint_cap:
if (unlikely(!cap_endpoint_cap_get_capCanReceive(lu_ret.cap))) {
current_lookup_fault = lookup_fault_missing_capability_new(0);
current_fault = fault_cap_fault_new(epCPtr, true);
handleFault(ksCurThread);
break;
}
deleteCallerCap(ksCurThread);
receiveIPC(ksCurThread, lu_ret.cap, isBlocking);
break;
case cap_notification_cap: {
notification_t *ntfnPtr;
tcb_t *boundTCB;
ntfnPtr = NTFN_PTR(cap_notification_cap_get_capNtfnPtr(lu_ret.cap));
boundTCB = (tcb_t*)notification_ptr_get_ntfnBoundTCB(ntfnPtr);
if (unlikely(!cap_notification_cap_get_capNtfnCanReceive(lu_ret.cap)
|| (boundTCB && boundTCB != ksCurThread))) {
current_lookup_fault = lookup_fault_missing_capability_new(0);
current_fault = fault_cap_fault_new(epCPtr, true);
handleFault(ksCurThread);
break;
}
receiveSignal(ksCurThread, lu_ret.cap, isBlocking);
break;
}
default:
current_lookup_fault = lookup_fault_missing_capability_new(0);
current_fault = fault_cap_fault_new(epCPtr, true);
handleFault(ksCurThread);
break;
}
}
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;
}
}
}
