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
restart(tcb_t *target)
{
if (isBlocked(target)) {
ipcCancel(target);
setupReplyMaster(target);
setThreadState(target, ThreadState_Restart);
tcbSchedEnqueue(target);
switchIfRequiredTo(target);
}
}
void
receiveIPC(tcb_t *thread, cap_t cap)
{
endpoint_t *epptr;
bool_t diminish;
async_endpoint_t *aepptr;
/* Haskell error "receiveIPC: invalid cap" */
assert(cap_get_capType(cap) == cap_endpoint_cap);
//printf("\n;;;;;;;;;In function receiveIPC;;;;;;;\n");
epptr = EP_PTR(cap_endpoint_cap_get_capEPPtr(cap));
diminish = !cap_endpoint_cap_get_capCanSend(cap);
/* Check for anything waiting in the async endpoint*/
aepptr = thread->boundAsyncEndpoint;
if (aepptr && async_endpoint_ptr_get_state(aepptr) == AEPState_Active)
{
completeAsyncIPC(aepptr, thread);
}
else
{
switch (endpoint_ptr_get_state(epptr)) {
case EPState_Idle:
//printf("in case idle\n");
case EPState_Recv: {
tcb_queue_t queue;
//printf("in case recv\n");
/* Set thread state to BlockedOnReceive */
thread_state_ptr_set_tsType(&thread->tcbState,
ThreadState_BlockedOnReceive);
thread_state_ptr_set_blockingIPCEndpoint(
&thread->tcbState, EP_REF(epptr));
thread_state_ptr_set_blockingIPCDiminishCaps(
&thread->tcbState, diminish);
scheduleTCB(thread);
/* Place calling thread in endpoint queue */
queue = ep_ptr_get_queue(epptr);
queue = tcbEPAppend(thread, queue);
endpoint_ptr_set_state(epptr, EPState_Recv);
ep_ptr_set_queue(epptr, queue);
break;
}
case EPState_Send: {
tcb_queue_t queue;
tcb_t *sender;
word_t badge;
bool_t canGrant;
bool_t do_call;
//printf("in case send\n");
/* Get the head of the endpoint queue. */
queue = ep_ptr_get_queue(epptr);
sender = queue.head;
/* Haskell error "Send endpoint queue must not be empty" */
assert(sender);
/* Dequeue the first TCB */
queue = tcbEPDequeue(sender, queue);
ep_ptr_set_queue(epptr, queue);
if (!queue.head) {
endpoint_ptr_set_state(epptr, EPState_Idle);
}
/* Get sender IPC details */
badge = thread_state_ptr_get_blockingIPCBadge(&sender->tcbState);
canGrant =
thread_state_ptr_get_blockingIPCCanGrant(&sender->tcbState);
/* Do the transfer */
doIPCTransfer(sender, epptr, badge,
canGrant, thread, diminish);
do_call = thread_state_ptr_get_blockingIPCIsCall(&sender->tcbState);
if (do_call ||
fault_get_faultType(sender->tcbFault) != fault_null_fault) {
if (canGrant && !diminish) {
setupCallerCap(sender, thread);
} else {
setThreadState(sender, ThreadState_Inactive);
}
} else {
setThreadState(sender, ThreadState_Running);
switchIfRequiredTo(sender);
}
break;
}
}
}
}
void
receiveIPC(tcb_t *thread, cap_t cap, bool_t isBlocking)
{
endpoint_t *epptr;
notification_t *ntfnPtr;
/* Haskell error "receiveIPC: invalid cap" */
assert(cap_get_capType(cap) == cap_endpoint_cap);
epptr = EP_PTR(cap_endpoint_cap_get_capEPPtr(cap));
/* Check for anything waiting in the notification */
ntfnPtr = thread->tcbBoundNotification;
if (ntfnPtr && notification_ptr_get_state(ntfnPtr) == NtfnState_Active) {
completeSignal(ntfnPtr, thread);
} else {
switch (endpoint_ptr_get_state(epptr)) {
case EPState_Idle:
case EPState_Recv: {
tcb_queue_t queue;
if (isBlocking) {
/* Set thread state to BlockedOnReceive */
thread_state_ptr_set_tsType(&thread->tcbState,
ThreadState_BlockedOnReceive);
thread_state_ptr_set_blockingObject(
&thread->tcbState, EP_REF(epptr));
scheduleTCB(thread);
/* Place calling thread in endpoint queue */
queue = ep_ptr_get_queue(epptr);
queue = tcbEPAppend(thread, queue);
endpoint_ptr_set_state(epptr, EPState_Recv);
ep_ptr_set_queue(epptr, queue);
} else {
doNBRecvFailedTransfer(thread);
}
break;
}
case EPState_Send: {
tcb_queue_t queue;
tcb_t *sender;
word_t badge;
bool_t canGrant;
bool_t do_call;
/* Get the head of the endpoint queue. */
queue = ep_ptr_get_queue(epptr);
sender = queue.head;
/* Haskell error "Send endpoint queue must not be empty" */
assert(sender);
/* Dequeue the first TCB */
queue = tcbEPDequeue(sender, queue);
ep_ptr_set_queue(epptr, queue);
if (!queue.head) {
endpoint_ptr_set_state(epptr, EPState_Idle);
}
/* Get sender IPC details */
badge = thread_state_ptr_get_blockingIPCBadge(&sender->tcbState);
canGrant =
thread_state_ptr_get_blockingIPCCanGrant(&sender->tcbState);
/* Do the transfer */
doIPCTransfer(sender, epptr, badge,
canGrant, thread);
do_call = thread_state_ptr_get_blockingIPCIsCall(&sender->tcbState);
if (do_call ||
seL4_Fault_get_seL4_FaultType(sender->tcbFault) != seL4_Fault_NullFault) {
if (canGrant) {
setupCallerCap(sender, thread);
} else {
setThreadState(sender, ThreadState_Inactive);
}
} else {
setThreadState(sender, ThreadState_Running);
switchIfRequiredTo(sender);
}
break;
}
}
}
}
