Newer
Older
#include <ipc.h>
#include <kernel.h>
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
extern Buffer*** TotalSendQ;
int doSend(KernelStruct* Colonel, int TaskID, void* Msg, int MsgLen, void* ReplyMsg, int ReplyLen) {
Colonel->Active->RetVal = SRR_FAILED;
Buffer** AllSendQ = *(TotalSendQ);
// check the TD availability
int TIDIndex = GetMemoryIndexINT(TaskID);
TD* SenderTask = Colonel->Active;
if(TIDIndex >= MAX_NUM_TD){
bwprintf(COM2,"doSend: TID Index:%d out of MaxNumTD\n\r", TIDIndex);
SenderTask->RetVal = TASK_DNE;
return FAILURE;
}
TD* ReceiverTask = &(Colonel->Tasks[TIDIndex]);
if(GetAvailability(ReceiverTask)){
bwprintf(COM2,"doSend: Task %d Availability %d\n\r",TaskID, GetAvailability(ReceiverTask));
SenderTask->RetVal = TASK_DNE;
return FAILURE;
}
bwprintf(COM2,"doSend: Task %d SendMsgLen:%d\n\r",SenderTask->TaskID,MsgLen);
int Result;
bwprintf(COM2,"doSend: Guess1\n\r");
AP* Args = ReceiverTask->Args;
bwprintf(COM2,"doSend: Guess2 %d\n\r",Args->arg1);
int *ReceiverSlot = (int *)Args->arg1;
bwprintf(COM2,"doSend: Guess3\n\r");
int ReceiverLen = (int)(Args->arg2);
if (ReceiverTask->TaskState == SendBlocked) {
bwprintf(COM2,"doSend: Receiver %d SendBlocked\n\r", TaskID);
Result = byteCopy(ReceiverSlot, Msg, ReceiverLen, MsgLen);
if (Result == FAILURE){
bwprintf(COM2,"doSend: byteCopy Failed\n\r");
ReceiverTask->RetVal = MSG_TRUNCATED;
return Result;
SenderTask->TaskState = ReplyBlocked;
ReceiverTask->TaskState = Ready;
pushToScheduler(Colonel, ReceiverTask);
BufferPopHead(AllSendQ[TIDIndex]);
}
else {
bwprintf(COM2,"doSend: Receiver %d not Received, Task %d RBLocked\n\r",TaskID,SenderTask->TaskID);
SenderTask->TaskState = ReceiveBlocked;
FeedBuffer(AllSendQ[TIDIndex],(void *)(SenderTask->TaskID));
}
Colonel->Active = NULL;
return SUCCESS;
}
int doReceive(KernelStruct* Colonel, int TaskID, void* Msg, int MsgLen) {
int TIDIndex = GetMemoryIndexINT(TaskID);
TD* SenderTask = &(Colonel->Tasks[TIDIndex]);
Buffer** AllSendQ = *TotalSendQ;
int Result;
AP* Args = SenderTask->Args;
void* SendMsg = Args->arg1;
int SendMsgLen = (int)Args->arg2;
if (SenderTask->TaskState!= ReceiveBlocked) {
bwprintf(COM2,"doReceive: Sender %d not send yet\n\r",SenderTask->TaskID);
ReceiverTask->TaskState = SendBlocked;
Colonel->Active = NULL;
}else{
bwprintf(COM2,"doReceive,MsgLen:%d,SendMsgLen:%d\n\r",MsgLen,SendMsgLen);
Result = byteCopy(Msg, SendMsg, MsgLen, SendMsgLen);
bwprintf(COM2,"doReceive: Receive Message from %d, result: %d\n\r",SenderTask->TaskID, Result);
if (Result == FAILURE){
ReceiverTask->RetVal = MSG_TRUNCATED;
return Result;
}
SenderTask->TaskState = ReplyBlocked;
bwprintf(COM2,"doReceive: Sender%d Reply Blocked\n\r",TaskID);
Result = BufferPopHead(AllSendQ[GetMemoryIndexINT(ReceiverTask->TaskID)]);
bwprintf(COM2,"doReceive: BufferPopHead %d\n\r");
Colonel->Active->RetVal = MsgLen;
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
int doReply(KernelStruct* Colonel, int TaskID, void* ReplyMsg, int ReplyLen) {
TD* ReplyTask = Colonel->Active; // me
int TIDIndex = GetMemoryIndexINT(TaskID);
TD* SenderTask = &(Colonel->Tasks[TIDIndex]);
if(TIDIndex >= MAX_NUM_TD){
SenderTask->RetVal = TASK_DNE;
return FAILURE;
}
if(GetAvailability(SenderTask)){
SenderTask->RetVal = TASK_DNE;
return FAILURE;
}
AP* Args = SenderTask->Args;
int Result;
void* SenderReply = Args->arg3;
int SenderLen = (int)Args->arg4;
if(SenderTask->TaskState != ReplyBlocked){
Colonel->Active->RetVal = SRR_FAILED;
return FAILURE;
}
Result = byteCopy(SenderReply, ReplyMsg, SenderLen, ReplyLen);
if(Result != SUCCESS){
SenderTask->RetVal = MSG_TRUNCATED;
return Result;
}
SenderTask->TaskState = Ready;
SenderTask->RetVal = ReplyLen;
Colonel->Active->RetVal = 0;
pushToScheduler(Colonel, SenderTask);
return SUCCESS;