void
doReplyTransfer(tcb_t *sender, tcb_t *receiver, cte_t *slot)
{
assert(thread_state_get_tsType(receiver->tcbState) ==
ThreadState_BlockedOnReply);
if (likely(fault_get_faultType(receiver->tcbFault) == fault_null_fault)) {
doIPCTransfer(sender, NULL, 0, true, receiver, false);
/** GHOSTUPD: "(True, gs_set_assn cteDeleteOne_'proc (ucast cap_reply_cap))" */
cteDeleteOne(slot);
setThreadState(receiver, ThreadState_Running);
attemptSwitchTo(receiver);
} else {
bool_t restart;
/** GHOSTUPD: "(True, gs_set_assn cteDeleteOne_'proc (ucast cap_reply_cap))" */
cteDeleteOne(slot);
restart = handleFaultReply(receiver, sender);
fault_null_fault_ptr_new(&receiver->tcbFault);
if (restart) {
setThreadState(receiver, ThreadState_Restart);
attemptSwitchTo(receiver);
} else {
setThreadState(receiver, ThreadState_Inactive);
}
}
}
void
deleteCallerCap(tcb_t *receiver)
{
cte_t *callerSlot;
callerSlot = TCB_PTR_CTE_PTR(receiver, tcbCaller);
cteDeleteOne(callerSlot);
}
void
deletingIRQHandler(irq_t irq)
{
cte_t *slot;
slot = intStateIRQNode + irq;
/** GHOSTUPD: "(True, gs_set_assn cteDeleteOne_'proc (ucast cap_notification_cap))" */
cteDeleteOne(slot);
}
void
invokeIRQHandler_ClearIRQHandler(irq_t irq)
{
cte_t *irqSlot;
irqSlot = intStateIRQNode + irq;
/** GHOSTUPD: "(True, gs_set_assn cteDeleteOne_'proc (-1))" */
cteDeleteOne(irqSlot);
}
void
invokeIRQHandler_SetIRQHandler(irq_t irq, cap_t cap, cte_t *slot)
{
cte_t *irqSlot;
irqSlot = intStateIRQNode + irq;
/** GHOSTUPD: "(True, gs_set_assn cteDeleteOne_'proc (-1))" */
cteDeleteOne(irqSlot);
cteInsert(cap, slot, irqSlot);
}
void
cancelIPC(tcb_t *tptr)
{
thread_state_t *state = &tptr->tcbState;
switch (thread_state_ptr_get_tsType(state)) {
case ThreadState_BlockedOnSend:
case ThreadState_BlockedOnReceive: {
/* blockedIPCCancel state */
endpoint_t *epptr;
tcb_queue_t queue;
epptr = EP_PTR(thread_state_ptr_get_blockingObject(state));
/* Haskell error "blockedIPCCancel: endpoint must not be idle" */
assert(endpoint_ptr_get_state(epptr) != EPState_Idle);
/* Dequeue TCB */
queue = ep_ptr_get_queue(epptr);
queue = tcbEPDequeue(tptr, queue);
ep_ptr_set_queue(epptr, queue);
if (!queue.head) {
endpoint_ptr_set_state(epptr, EPState_Idle);
}
setThreadState(tptr, ThreadState_Inactive);
break;
}
case ThreadState_BlockedOnNotification:
cancelSignal(tptr,
NTFN_PTR(thread_state_ptr_get_blockingObject(state)));
break;
case ThreadState_BlockedOnReply: {
cte_t *slot, *callerCap;
tptr->tcbFault = seL4_Fault_NullFault_new();
/* Get the reply cap slot */
slot = TCB_PTR_CTE_PTR(tptr, tcbReply);
callerCap = CTE_PTR(mdb_node_get_mdbNext(slot->cteMDBNode));
if (callerCap) {
/** GHOSTUPD: "(True,
gs_set_assn cteDeleteOne_'proc (ucast cap_reply_cap))" */
cteDeleteOne(callerCap);
}
break;
}
}
}
