/**
* Handler for messageq params init API.
*
* \param ctp Thread's associated context information.
* \param msg The actual devctl() message.
* \param ocb OCB associated with client's session.
*
* \return POSIX errno value.
*
* \retval EOK Success.
* \retval ENOTSUP Unsupported devctl().
*/
int syslink_messageq_params_init(resmgr_context_t *ctp, io_devctl_t *msg, syslink_ocb_t *ocb)
{
MessageQDrv_CmdArgs * cargs = (MessageQDrv_CmdArgs *) (_DEVCTL_DATA (msg->i));
MessageQ_Params *local_params = (MessageQ_Params *)(cargs+1);
MessageQ_Params_init (local_params);
cargs->apiStatus = MessageQ_S_SUCCESS;
SETIOV(&ctp->iov[0], &msg->o, sizeof(msg->o) + sizeof(MessageQDrv_CmdArgs));
SETIOV(&ctp->iov[1], local_params, sizeof(*local_params));
return _RESMGR_NPARTS(2);
}
/*
* ======== Server_create ========
*/
Int Server_create()
{
Int status = 0;
MessageQ_Params msgqParams;
GateMP_Params gateParams;
/* enable some log events */
Diags_setMask(MODULE_NAME"+EXF");
/* create GateMP */
GateMP_Params_init(&gateParams);
gateParams.name = GATEMP_SLAVE_NAME;
gateParams.localProtect = GateMP_LocalProtect_PROCESS;
gateParams.remoteProtect = GateMP_RemoteProtect_SYSTEM;
Module.slaveGateMPHandle = GateMP_create (&gateParams);
if (Module.slaveGateMPHandle == NULL) {
status = GATEMPAPP_E_FAILURE;
Log_print0(Diags_INFO, "Server_create: Failed to create GateMP");
goto leave;
}
/* create local message queue (inbound messages) */
MessageQ_Params_init(&msgqParams);
Module.slaveQue = MessageQ_create(GateMPApp_SlaveMsgQueName, &msgqParams);
if (Module.slaveQue == NULL) {
status = -1;
Log_print0(Diags_INFO, "Server_create: Failed to create MessageQ");
GateMP_delete(&Module.slaveGateMPHandle);
goto leave;
}
Log_print0(Diags_INFO,"Server_create: Slave is ready");
leave:
Log_print1(Diags_EXIT, "<-- Server_create: %d", (IArg)status);
return (status);
}
Int MessageQApp_execute(UInt32 numLoops, UInt16 procId)
{
Int32 status = 0;
MessageQ_Msg msg = NULL;
MessageQ_Params msgParams;
UInt32 i;
MessageQ_QueueId queueId = MessageQ_INVALIDMESSAGEQ;
MessageQ_Handle msgqHandle;
char remoteQueueName[64];
UInt32 msgId;
printf("Entered MessageQApp_execute\n");
/* Create the local Message Queue for receiving. */
MessageQ_Params_init(&msgParams);
msgqHandle = MessageQ_create(MPU_MESSAGEQNAME, &msgParams);
if (msgqHandle == NULL) {
printf("Error in MessageQ_create\n");
goto exit;
}
else {
printf("Local MessageQId: 0x%x\n", MessageQ_getQueueId(msgqHandle));
}
sprintf(remoteQueueName, "%s_%s", SLAVE_MESSAGEQNAME,
MultiProc_getName(procId));
/* Poll until remote side has it's messageQ created before we send: */
do {
status = MessageQ_open(remoteQueueName, &queueId);
sleep (1);
} while (status == MessageQ_E_NOTFOUND);
if (status < 0) {
printf("Error in MessageQ_open [%d]\n", status);
goto cleanup;
}
else {
printf("Remote queueId [0x%x]\n", queueId);
}
msg = MessageQ_alloc(HEAPID, sizeof(SyncMsg));
if (msg == NULL) {
printf("Error in MessageQ_alloc\n");
MessageQ_close(&queueId);
goto cleanup;
}
/* handshake with remote to set the number of loops */
MessageQ_setReplyQueue(msgqHandle, msg);
((SyncMsg *)msg)->numLoops = numLoops;
((SyncMsg *)msg)->print = FALSE;
MessageQ_put(queueId, msg);
MessageQ_get(msgqHandle, &msg, MessageQ_FOREVER);
printf("Exchanging %d messages with remote processor %s...\n",
numLoops, MultiProc_getName(procId));
for (i = 1 ; i <= numLoops; i++) {
((SyncMsg *)msg)->numLoops = i;
/* Have the remote proc reply to this message queue */
MessageQ_setReplyQueue(msgqHandle, msg);
status = MessageQ_put(queueId, msg);
if (status < 0) {
printf("Error in MessageQ_put [%d]\n", status);
MessageQ_free(msg);
break;
}
status = MessageQ_get(msgqHandle, &msg, MessageQ_FOREVER);
if (status < 0) {
printf("Error in MessageQ_get [%d]\n", status);
break;
}
else {
/* validate the returned message */
msgId = ((SyncMsg *)msg)->numLoops;
if ((msg != NULL) && (msgId != i)) {
printf("Data integrity failure!\n"
" Expected %d\n"
" Received %d\n",
i, msgId);
break;
}
}
if (numLoops <= 200) {
printf("MessageQ_get #%d Msg = 0x%x\n", i, (UInt)msg);
}
else if ((i % 1000) == 0) {
printf("MessageQ_get #%d Msg = 0x%x\n", i, (UInt)msg);
}
}
printf("Exchanged %d messages with remote processor %s\n",
(i-1), MultiProc_getName(procId));
if (status >= 0) {
printf("Sample application successfully completed!\n");
MessageQ_free(msg);
}
MessageQ_close(&queueId);
cleanup:
/* Clean-up */
status = MessageQ_delete(&msgqHandle);
if (status < 0) {
printf("Error in MessageQ_delete [%d]\n", status);
}
exit:
printf("Leaving MessageQApp_execute\n\n");
return (status);
}
Int App_create(UInt16 remoteProcId)
{
Int status =0;
int retStatus =0;
UInt32 event =0;
HeapBufMP_Params heapParams;
MessageQ_Params msgqParams;
printf("--> App_create:\n");
/* setting default values */
Module.remoteProcId = remoteProcId;
Module.lineId = SystemCfg_LineId;
Module.eventId = SystemCfg_AppEventId;
Module.head = 0;
Module.tail = 0;
Module.error = 0;
Module.msgHeap = NULL;
Module.hostQue = NULL;
Module.videoQue = MessageQ_INVALIDMESSAGEQ;
Module.heapId = App_MsgHeapId;
Module.msgSize = sizeof(App_Msg);
/* 1. create sync object */
retStatus = sem_init(&Module.semH, 0, 0);
if (retStatus == -1) {
printf("App_create: Failed to create a semaphore\n");
goto leave;
}
/* 2. register notify callback */
status = Notify_registerEventSingle(Module.remoteProcId, Module.lineId,
Module.eventId, App_notifyCB, (UArg)&Module);
if (status < 0) {
printf("App_create: Host failed to register an event\n");
goto leave;
}
/* 3. wait until remote core has also registered notify callback */
do {
status = Notify_sendEvent(Module.remoteProcId, Module.lineId,
Module.eventId, App_CMD_NOP, TRUE);
if (status == Notify_E_EVTNOTREGISTERED) {
sleep(1);
}
} while (status == Notify_E_EVTNOTREGISTERED);
if (status < 0) {
printf("App_create: Failed to send event\n");
goto leave;
}
/* 4. create local & shared resources (to be opened by remote processor) */
/* create heap for messages */
HeapBufMP_Params_init(&heapParams);
heapParams.name = App_MsgHeapName;
heapParams.regionId = App_MsgHeapSrId;
heapParams.blockSize = 64;
heapParams.numBlocks = 10;
Module.msgHeap = HeapBufMP_create(&heapParams);
if (Module.msgHeap == NULL) {
printf("App_create: Failed to create a HeapBufMP\n");
status = -1;
goto leave;
}
/* register heap with MessageQ */
status = MessageQ_registerHeap((Ptr)(Module.msgHeap), App_MsgHeapId);
if (status < 0) {
printf("App_create: Failed to register HeapBufMP with MessageQ\n");
goto leave;
}
/* create local message queue (inbound messages) */
MessageQ_Params_init(&msgqParams);
Module.hostQue = MessageQ_create(App_HostMsgQueName, &msgqParams);
if (Module.hostQue == NULL) {
printf("App_create: Failed creating MessageQ\n");
status = -1;
goto leave;
}
/* 5. send resource ready event */
status = Notify_sendEvent(Module.remoteProcId, Module.lineId,
Module.eventId, App_CMD_RESRDY, TRUE);
if (status < 0) {
printf("App_create: Failed to send event\n");
goto leave;
}
/* 6. wait for remote resource ready event */
do {
event = App_waitForEvent();
if (event >= App_E_FAILURE) {
status = -1;
printf("App_create: Failed waiting for event\n");
goto leave;
}
} while (event != App_CMD_RESRDY);
/* 7. open remote resources */
/* open the video message queue */
status = MessageQ_open(App_VideoMsgQueName, &Module.videoQue);
if (status < 0) {
printf("App_create: Failed opening MessageQ\n");
goto leave;
}
/* 8. send application ready event */
status = Notify_sendEvent(Module.remoteProcId, Module.lineId,
Module.eventId, App_CMD_READY, TRUE);
if (status < 0) {
printf("App_create: Failed to send event\n");
goto leave;
}
/* 9. wait for remote server ready event */
do {
event = App_waitForEvent();
if (event >= App_E_FAILURE) {
status = -1;
printf("App_create: Failed waiting for event\n");
goto leave;
}
} while (event != App_CMD_READY);
printf("App_create: Host is ready\n");
leave:
printf("<-- App_create:\n");
return(status);
}
Int MessageQApp_execute(UInt32 numLoops, UInt32 payloadSize, UInt16 procId)
{
Int32 status = 0;
MessageQ_Msg msg = NULL;
MessageQ_Params msgParams;
UInt32 i;
MessageQ_QueueId queueId = MessageQ_INVALIDMESSAGEQ;
MessageQ_Handle msgqHandle;
char remoteQueueName[64];
struct timespec start, end;
long elapsed;
UInt32 msgId;
printf("Entered MessageQApp_execute\n");
/* Create the local Message Queue for receiving. */
MessageQ_Params_init(&msgParams);
msgqHandle = MessageQ_create(MPU_MESSAGEQNAME, &msgParams);
if (msgqHandle == NULL) {
printf("Error in MessageQ_create\n");
goto exit;
}
else {
printf("Local MessageQId: 0x%x\n", MessageQ_getQueueId(msgqHandle));
}
sprintf(remoteQueueName, "%s_%s", SLAVE_MESSAGEQNAME,
MultiProc_getName(procId));
/* Poll until remote side has its messageQ created before we send: */
do {
status = MessageQ_open(remoteQueueName, &queueId);
sleep (1);
} while (status == MessageQ_E_NOTFOUND);
if (status < 0) {
printf("Error in MessageQ_open [%d]\n", status);
goto cleanup;
}
else {
printf("Remote queueId [0x%x]\n", queueId);
}
msg = MessageQ_alloc(HEAPID, sizeof(SyncMsg) + payloadSize);
if (msg == NULL) {
printf("Error in MessageQ_alloc\n");
MessageQ_close(&queueId);
goto cleanup;
}
/* handshake with remote to set the number of loops */
MessageQ_setReplyQueue(msgqHandle, msg);
((SyncMsg *)msg)->numLoops = numLoops;
((SyncMsg *)msg)->print = FALSE;
MessageQ_put(queueId, msg);
MessageQ_get(msgqHandle, &msg, MessageQ_FOREVER);
printf("Exchanging %d messages with remote processor %s...\n",
numLoops, MultiProc_getName(procId));
clock_gettime(CLOCK_REALTIME, &start);
for (i = 1 ; i <= numLoops; i++) {
((SyncMsg *)msg)->numLoops = i;
/* Have the remote proc reply to this message queue */
MessageQ_setReplyQueue(msgqHandle, msg);
status = MessageQ_put(queueId, msg);
if (status < 0) {
printf("Error in MessageQ_put [%d]\n", status);
break;
}
status = MessageQ_get(msgqHandle, &msg, MessageQ_FOREVER);
if (status < 0) {
printf("Error in MessageQ_get [%d]\n", status);
break;
}
else {
/* Validate the returned message */
msgId = ((SyncMsg *)msg)->numLoops;
if ((msg != NULL) && (msgId != i)) {
printf("Data integrity failure!\n"
" Expected %d\n"
" Received %d\n",
i, msgId);
break;
}
}
}
clock_gettime(CLOCK_REALTIME, &end);
elapsed = diff(start, end);
if (numLoops > 0) {
printf("%s: Avg round trip time: %ld usecs\n",
MultiProc_getName(procId), elapsed / numLoops);
}
MessageQ_free(msg);
MessageQ_close(&queueId);
cleanup:
status = MessageQ_delete(&msgqHandle);
if (status < 0) {
printf ("Error in MessageQ_delete [%d]\n", status);
}
exit:
printf("Leaving MessageQApp_execute\n\n");
return (status);
}
Int RcmClient_Instance_init(RcmClient_Object *obj, String server,
const RcmClient_Params *params)
{
Error_Block eb;
MessageQ_Params mqParams;
SyncSemThread_Params syncParams;
SemThread_Params semParams;
SemThread_Handle semHndl;
List_Params listP;
Int rval;
Int status = RcmClient_S_SUCCESS;
Log_print2(Diags_ENTRY, "--> %s: (obj=0x%x)", (IArg)FXNN, (IArg)obj);
/* must initialize error block */
Error_init(&eb);
/* initialize instance data */
obj->msgId = 0xFFFF;
obj->sync = NULL;
obj->serverMsgQ = MessageQ_INVALIDMESSAGEQ;
obj->msgQue = NULL;
obj->errorMsgQue = NULL;
obj->mbxLock = NULL;
obj->queueLock = NULL;
obj->recipients = NULL;
obj->newMail = NULL;
/* create the instance gate */
GateThread_construct(&obj->gate, NULL, &eb);
if (Error_check(&eb)) {
Log_error0(FXNN": could not create gate object");
status = RcmClient_E_FAIL;
goto leave;
}
/* create a synchronizer for the message queue */
SyncSemThread_Params_init(&syncParams);
obj->sync = SyncSemThread_create(&syncParams, &eb);
if (Error_check(&eb)) {
status = RcmClient_E_FAIL;
goto leave;
}
/* create the message queue for return messages */
MessageQ_Params_init(&mqParams);
obj->msgQue = MessageQ_create(NULL, &mqParams);
if (obj->msgQue == NULL) {
Log_error0(FXNN": could not create return message queue");
status = RcmClient_E_MSGQCREATEFAILED;
goto leave;
}
/* create the message queue for error messages */
MessageQ_Params_init(&mqParams);
obj->errorMsgQue = MessageQ_create(NULL, &mqParams);
if (NULL == obj->errorMsgQue) {
Log_error0(FXNN": could not create error message queue");
status = RcmClient_E_MSGQCREATEFAILED;
goto leave;
}
/* locate server message queue */
rval = MessageQ_open(server, (MessageQ_QueueId *)(&obj->serverMsgQ));
if (MessageQ_E_NOTFOUND == rval) {
Log_error1(FXNN": given server not found, server=0x%x", (IArg)server);
status = RcmClient_E_SERVERNOTFOUND;
goto leave;
}
else if (status < 0) {
Log_error1(FXNN": could not open server message queue, server=0x%x",
(IArg)server);
status = RcmClient_E_MSGQOPENFAILED;
goto leave;
}
/* create callback server */
if ((obj->cbNotify = params->callbackNotification)) {
/* TODO create callback server thread */
/* make sure to free resources acquired by thread */
Error_raise(&eb, Error_E_generic, "Not Implemented", 0);
goto leave;
}
/* register the heapId used for message allocation */
if ((obj->heapId = params->heapId) == RcmClient_INVALIDHEAPID) {
Log_error0(FXNN": must specify a heap id in create params");
status = RcmClient_E_INVALIDHEAPID;
goto leave;
}
/* create the mailbox lock */
SemThread_Params_init(&semParams);
semHndl = SemThread_create(1, &semParams, &eb);
if (Error_check(&eb)) {
status = RcmClient_E_FAIL;
goto leave;
}
obj->mbxLock = SemThread_Handle_upCast(semHndl);
/* create the message queue lock */
SemThread_Params_init(&semParams);
semHndl = SemThread_create(1, &semParams, &eb);
if (Error_check(&eb)) {
status = RcmClient_E_FAIL;
goto leave;
}
obj->queueLock = SemThread_Handle_upCast(semHndl);
/* create the return message recipient list */
#if defined(RCM_ti_ipc)
List_Params_init(&listP);
obj->recipients = List_create(&listP, &eb);
if (Error_check(&eb)) {
Log_error0(FXNN": could not create list object");
status = RcmClient_E_LISTCREATEFAILED;
goto leave;
}
#elif defined(RCM_ti_syslink)
List_Params_init(&listP);
obj->recipients = List_create(&listP, NULL);
if (NULL == obj->recipients) {
Log_error0(FXNN": could not create list object");
status = RcmClient_E_LISTCREATEFAILED;
goto leave;
}
#endif
/* create list of undelivered messages (new mail) */
#if defined(RCM_ti_ipc)
List_Params_init(&listP);
obj->newMail = List_create(&listP, &eb);
if (Error_check(&eb)) {
Log_error0(FXNN": could not create list object");
status = RcmClient_E_LISTCREATEFAILED;
goto leave;
}
#elif defined(RCM_ti_syslink)
List_Params_init(&listP);
obj->newMail = List_create(&listP, NULL);
if (NULL == obj->newMail) {
Log_error0(FXNN": could not create list object");
status = RcmClient_E_LISTCREATEFAILED;
goto leave;
}
#endif
leave:
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
Int32 System_ipcMsgQCreate()
{
UInt32 i;
UInt32 procId;
Int32 status;
Int32 retryCount;
MessageQ_Params msgQParams;
char msgQName[64];
char ackMsgQName[64];
i=0;
while(gSystem_ipcMsgQEnableProcId[i]!=SYSTEM_PROC_MAX)
{
procId = gSystem_ipcMsgQEnableProcId[i];
if (procId != SYSTEM_PROC_INVALID)
{
System_ipcGetMsgQName(procId, msgQName, ackMsgQName);
if(procId==System_getSelfProcId())
{
/* create MsgQ */
MessageQ_Params_init(&msgQParams);
/* printf(" %u: SYSTEM: Creating MsgQ [%s] ...\n",
OSA_getCurTimeInMsec(),
msgQName
);
*/
gSystem_ipcObj.selfMsgQ = MessageQ_create(msgQName, &msgQParams);
UTILS_assert(gSystem_ipcObj.selfMsgQ!=NULL);
MessageQ_Params_init(&msgQParams);
/* printf(" %u: SYSTEM: Creating MsgQ [%s] ...\n",
OSA_getCurTimeInMsec(),
ackMsgQName
);
*/
gSystem_ipcObj.selfAckMsgQ = MessageQ_create(ackMsgQName, &msgQParams);
UTILS_assert(gSystem_ipcObj.selfMsgQ!=NULL);
}
else
{
/* open MsgQ */
retryCount=10;
while(retryCount)
{
// printf(" %u: SYSTEM: Opening MsgQ [%s] ...\n",
// OSA_getCurTimeInMsec(),
// msgQName
// );
status = MessageQ_open(msgQName, &gSystem_ipcObj.remoteProcMsgQ[procId]);
if(status==MessageQ_E_NOTFOUND)
OSA_waitMsecs(1000);
else
if(status==MessageQ_S_SUCCESS)
break;
retryCount--;
if(retryCount<=0)
UTILS_assert(0);
}
/* no need to open ack msgq,
since ack msgq id is embeeded in the received message
*/
}
}
i++;
}
return OSA_SOK;
}
static Void * pingThreadFxn(void *arg)
{
Int threadNum = *(int *)arg;
Int32 status = 0;
MessageQ_Msg msg = NULL;
MessageQ_Params msgParams;
UInt16 i;
MessageQ_Handle handle;
MessageQ_QueueId queueId = MessageQ_INVALIDMESSAGEQ;
char remoteQueueName[64];
char hostQueueName[64];
printf ("Entered pingThreadFxn: %d\n", threadNum);
sprintf(remoteQueueName, "%s_%d%d", SLAVE_MESSAGEQNAME, threadNum, (threadNum % (MultiProc_getNumProcessors() - 1)) + 1);
sprintf(hostQueueName, "%s_%d", HOST_MESSAGEQNAME, threadNum );
/* Create the local Message Queue for receiving. */
MessageQ_Params_init (&msgParams);
handle = MessageQ_create (hostQueueName, &msgParams);
if (handle == NULL) {
printf ("Error in MessageQ_create\n");
goto exit;
}
else {
printf ("thread: %d, Local Message: %s, QId: 0x%x\n",
threadNum, hostQueueName, MessageQ_getQueueId(handle));
}
/* Poll until remote side has it's messageQ created before we send: */
do {
status = MessageQ_open (remoteQueueName, &queueId);
sleep (1);
} while (status == MessageQ_E_NOTFOUND);
if (status < 0) {
printf ("Error in MessageQ_open [0x%x]\n", status);
goto cleanup;
}
else {
printf ("thread: %d, Remote queue: %s, QId: 0x%x\n",
threadNum, remoteQueueName, queueId);
}
printf ("\nthread: %d: Exchanging messages with remote processor...\n",
threadNum);
for (i = 0 ; i < numLoops ; i++) {
/* Allocate message. */
msg = MessageQ_alloc (HEAPID, MSGSIZE);
if (msg == NULL) {
printf ("Error in MessageQ_alloc\n");
break;
}
MessageQ_setMsgId (msg, i);
/* Have the remote proc reply to this message queue */
MessageQ_setReplyQueue (handle, msg);
status = MessageQ_put (queueId, msg);
if (status < 0) {
printf ("Error in MessageQ_put [0x%x]\n", status);
break;
}
status = MessageQ_get(handle, &msg, MessageQ_FOREVER);
if (status < 0) {
printf ("Error in MessageQ_get [0x%x]\n", status);
break;
}
else {
/* Validate the returned message. */
if ((msg != NULL) && (MessageQ_getMsgId (msg) != i)) {
printf ("Data integrity failure!\n"
" Expected %d\n"
" Received %d\n",
i, MessageQ_getMsgId (msg));
break;
}
status = MessageQ_free (msg);
}
printf ("thread: %d: Exchanged %d msgs\n", threadNum, (i+1));
}
printf ("thread: %d: pingThreadFxn successfully completed!\n", threadNum);
MessageQ_close (&queueId);
cleanup:
/* Clean-up */
status = MessageQ_delete (&handle);
if (status < 0) {
printf ("Error in MessageQ_delete [0x%x]\n", status);
}
exit:
return ((void *)status);
}
