Added function hook for the MessageQ_put method
authorRamsey Harris <ramsey@ti.com>
Sat, 6 Dec 2014 00:58:52 +0000 (16:58 -0800)
committerRobert Tivy <rtivy@ti.com>
Tue, 9 Dec 2014 18:14:33 +0000 (10:14 -0800)
New feature where you can register a function hook to be called
near the beginning of the MessageQ_put method. New type definition
for the hook function. Runtime API to register the hook function.
Also added a configuration parameter so you can register your hook
function in the application configuration script.

linux/src/api/MessageQ.c
packages/ti/ipc/MessageQ.h
packages/ti/sdo/ipc/MessageQ.c
packages/ti/sdo/ipc/MessageQ.xdc
packages/ti/sdo/ipc/MessageQ.xs
qnx/src/api/MessageQ.c

index 7a20a7821aa629b0af73ccc8283ad38e6a3744a7..2fc61e32a10808d1d848d85e94eb52eb008f6928 100644 (file)
@@ -112,6 +112,7 @@ typedef struct MessageQ_ModuleObject {
     int                       seqNum;
     IMessageQTransport_Handle transports[MultiProc_MAXPROCESSORS][2];
     INetworkTransport_Handle  transInst[MessageQ_MAXTRANSPORTS];
+    MessageQ_PutHookFxn       putHookFxn;
 } MessageQ_ModuleObject;
 
 typedef struct MessageQ_CIRCLEQ_ENTRY {
@@ -142,6 +143,7 @@ static MessageQ_ModuleObject MessageQ_state =
 {
     .refCount   = 0,
     .nameServer = NULL,
+    .putHookFxn = NULL
 };
 
 /*!
@@ -670,6 +672,11 @@ Int MessageQ_put(MessageQ_QueueId queueId, MessageQ_Msg msg)
     msg->dstId     = queueIndex;
     msg->dstProc   = dstProcId;
 
+    /* invoke put hook function after addressing the message */
+    if (MessageQ_module->putHookFxn != NULL) {
+        MessageQ_module->putHookFxn(queueId, msg);
+    }
+
     if (dstProcId != MultiProc_self()) {
         tid = MessageQ_getTransportId(msg);
         if (tid == 0) {
index 0453f4134af1b9f254ecf6a7d482c3dd382ed266..c3a42b3e05733bcd451c83ae419fd87f280333f9 100644 (file)
@@ -535,6 +535,18 @@ typedef enum {
  */
 typedef Void (*MessageQ_FreeHookFxn)(Bits16 heapId, Bits16 msgId);
 
+/*!
+ *  @brief      Put hook function definition
+ *
+ *  This function is invoked near the beginning of the MessageQ_put()
+ *  function. It allows client code to augment the addressing of the
+ *  given message before it is delivered.
+ *
+ *  @param[in]  queueId     destination message queue
+ *  @param[in]  msg         message to be sent
+ */
+typedef Void (*MessageQ_PutHookFxn)(MessageQ_QueueId queueId, MessageQ_Msg msg);
+
 #ifdef STD_H
 #include <ITransport.h>
 #include <IMessageQTransport.h>
@@ -826,6 +838,20 @@ Void MessageQ_staticMsgInit(MessageQ_Msg msg, UInt32 size);
  */
 Void MessageQ_setFreeHookFxn(MessageQ_FreeHookFxn freeHookFxn);
 
+/*!
+ *  @brief      Set the function hook for the MessageQ_put() method
+ *
+ *  Register a hook function which is called from the beginning of the
+ *  MessageQ_put() function. Only one hook may be registered at a time.
+ *  Subsequent calls to register a put function will overwrite the
+ *  previously registered function.
+ *
+ *  To disable the hook function, call MessageQ_setPutHookFxn() with NULL.
+ *
+ *  @param[in]  putHookFxn  function to be called within MessageQ_put()
+ */
+Void MessageQ_setPutHookFxn(MessageQ_PutHookFxn putHookFxn);
+
 /* =============================================================================
  *  MessageQ Per-instance Functions
  * =============================================================================
index 2e9422e43025730fb771ffd054d8303f0159ff9c..111ce9278f258b999d597e16072cdab8ac5a2e1a 100644 (file)
@@ -81,6 +81,7 @@
     #pragma FUNC_EXT_CALLED(MessageQ_put);
     #pragma FUNC_EXT_CALLED(MessageQ_registerHeap);
     #pragma FUNC_EXT_CALLED(MessageQ_setFreeHookFxn);
+    #pragma FUNC_EXT_CALLED(MessageQ_setPutHookFxn);
     #pragma FUNC_EXT_CALLED(MessageQ_setReplyQueue);
     #pragma FUNC_EXT_CALLED(MessageQ_setMsgTrace);
     #pragma FUNC_EXT_CALLED(MessageQ_staticMsgInit);
@@ -444,6 +445,11 @@ Int MessageQ_put(MessageQ_QueueId queueId, MessageQ_Msg msg)
     msg->dstId   = (UInt16)(queueId);
     msg->dstProc = (UInt16)(queueId >> 16);
 
+    /* invoke put hook function after addressing the message */
+    if (MessageQ_module->putHookFxn != NULL) {
+        MessageQ_module->putHookFxn(queueId, (Ptr)msg);
+    }
+
     /* extract the transport ID from the message header */
     tid = MessageQ_getTransportId(msg);
 
@@ -607,6 +613,14 @@ Void MessageQ_setFreeHookFxn(MessageQ_FreeHookFxn freeHookFxn)
     MessageQ_module->freeHookFxn = freeHookFxn;
 }
 
+/*
+ *  ======== MessageQ_setPutHookFxn ========
+ */
+Void MessageQ_setPutHookFxn(MessageQ_PutHookFxn putHookFxn)
+{
+    MessageQ_module->putHookFxn = (ti_sdo_ipc_MessageQ_PutHookFxn)putHookFxn;
+}
+
 /*
  *  ======== MessageQ_setMsgTrace ========
  */
index 4b420a2788b6e447ca928bac51dc633190c64320..6b597bc69814a6a70d691dc0d5b6f2f98a28899a 100644 (file)
@@ -345,6 +345,15 @@ module MessageQ
      */
     typedef Void (*FreeHookFxn)(Bits16, Bits16);
 
+    /*!
+     *  ======== PutHookFxn ========
+     *  Function prototype for the MessageQ_put callback
+     *
+     *  @param(Bits32)  queueId of the destination message queue
+     *  @param(Ptr)     pointer to a message header structure
+     */
+    typedef Void (*PutHookFxn)(Bits32, Ptr);
+
     /*! MessageQ ID */
     typedef UInt32 QueueId;
 
@@ -549,6 +558,12 @@ module MessageQ
      */
     config FreeHookFxn freeHookFxn = null;
 
+    /*!
+     *  ======== putHookFxn ========
+     *  Put function hook
+     */
+    config PutHookFxn putHookFxn = null;
+
     /*!
      *  ======== registerHeapMeta ========
      *  Statically register a heap with MessageQ
@@ -775,6 +790,7 @@ internal:
         UInt16               numHeaps;
         NameServer.Handle    nameServer;
         FreeHookFxn          freeHookFxn;
+        PutHookFxn           putHookFxn;
         Bool                 canFreeQueues;
         UInt16               seqNum;
         RegisteredTransport  regTrans[8];
index b91222e0553ed7e7827e7032f38362c5ab8f2bf8..8fd693c948e3c91c948e4a396f677cf962b94e45 100644 (file)
@@ -127,7 +127,8 @@ function module$static$init(state, mod)
 
     state.queues.length = state.numQueues;
     state.canFreeQueues = false;
-    state.freeHookFxn   = mod.freeHookFxn;
+    state.freeHookFxn = mod.freeHookFxn;
+    state.putHookFxn = mod.putHookFxn;
 
     if (mod.nameTableGate == null) {
          state.gate = null;
index 397ec49b8f0f1ab29bdae9f41b597fbc33eb1f8b..189e652b1b4cbd3fc0f7320f5add37043ed899cd 100644 (file)
@@ -196,6 +196,8 @@ typedef struct MessageQ_ModuleObject {
     /*!< File Descriptors for sending to each remote processor */
     int                 seqNum;
     /*!< Process-specific sequence number */
+    MessageQ_PutHookFxn putHookFxn;
+    /*!< hook function for MessageQ_put method */
 } MessageQ_ModuleObject;
 
 /*!
@@ -223,8 +225,9 @@ static Bool verbose = FALSE;
  */
 static MessageQ_ModuleObject MessageQ_state =
 {
-    .refCount               = 0,
-    .nameServer             = NULL,
+    .refCount   = 0,
+    .nameServer = NULL,
+    .putHookFxn = NULL
 };
 
 /*!
@@ -523,6 +526,11 @@ Int MessageQ_put (MessageQ_QueueId queueId, MessageQ_Msg msg)
     msg->dstId     = queueIndex;
     msg->dstProc   = dstProcId;
 
+    /* invoke put hook function after addressing the message */
+    if (MessageQ_module->putHookFxn != NULL) {
+        MessageQ_module->putHookFxn(queueId, msg);
+    }
+
     status = transportPut(msg, queueIndex, dstProcId);
 
     return (status);