exception_t decodeBindAEP(cap_t cap, extra_caps_t extraCaps)
{
async_endpoint_t *aepptr;
tcb_t *tcb;
if (extraCaps.excaprefs[0] == NULL) {
userError("TCB BindAEP: Truncated message.");
current_syscall_error.type = seL4_TruncatedMessage;
return EXCEPTION_SYSCALL_ERROR;
}
if (cap_get_capType(extraCaps.excaprefs[0]->cap) != cap_async_endpoint_cap) {
userError("TCB BindAEP: Async endpoint is invalid.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
tcb = TCB_PTR(cap_thread_cap_get_capTCBPtr(cap));
if (tcb->boundAsyncEndpoint) {
userError("TCB BindAEP: TCB already has AEP.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
aepptr = AEP_PTR(cap_async_endpoint_cap_get_capAEPPtr(extraCaps.excaprefs[0]->cap));
if ((tcb_t*)async_endpoint_ptr_get_aepQueue_head(aepptr)) {
userError("TCB BindAEP: AEP cannot be bound.");
current_syscall_error.type = seL4_IllegalOperation;
return EXCEPTION_SYSCALL_ERROR;
}
setThreadState(ksCurThread, ThreadState_Restart);
return invokeTCB_AEPControl(tcb, aepptr);
}
void
ipcCancel(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_blockingIPCEndpoint(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_BlockedOnAsyncEvent:
asyncIPCCancel(tptr,
AEP_PTR(thread_state_ptr_get_blockingIPCEndpoint(state)));
break;
case ThreadState_BlockedOnReply: {
cte_t *slot, *callerCap;
fault_null_fault_ptr_new(&tptr->tcbFault);
/* Get the reply cap slot */
slot = TCB_PTR_CTE_PTR(tptr, tcbReply);
callerCap = CTE_PTR(cap_reply_cap_get_capCallerSlot(slot->cap));
if (callerCap) {
finaliseCap(callerCap->cap, true, true);
callerCap->cap = cap_null_cap_new();
}
cap_reply_cap_ptr_set_capCallerSlot(&slot->cap, CTE_REF(NULL));
break;
}
}
}
static void
handleWait(bool_t isBlocking)
{
word_t epCPtr;
lookupCap_ret_t lu_ret;
epCPtr = getRegister(ksCurThread, capRegister);
lu_ret = lookupCap(ksCurThread, epCPtr);
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) || !isBlocking)) {
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);
break;
case cap_async_endpoint_cap: {
async_endpoint_t *aepptr;
tcb_t *boundTCB;
aepptr = AEP_PTR(cap_async_endpoint_cap_get_capAEPPtr(lu_ret.cap));
boundTCB = (tcb_t*)async_endpoint_ptr_get_aepBoundTCB(aepptr);
if (unlikely(!cap_async_endpoint_cap_get_capAEPCanReceive(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;
}
receiveAsyncIPC(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;
}
}
