Removed receipts started basic testing on infrastructure code
authorJustin Sobota <jsobota@ti.com>
Tue, 20 Nov 2012 23:20:35 +0000 (18:20 -0500)
committerJustin Sobota <jsobota@ti.com>
Tue, 20 Nov 2012 23:20:35 +0000 (18:20 -0500)
config.bld
rm_services.h
rm_transport.h
src/rm.c
src/rm_nameserver.c
src/rm_services.c
src/rm_transport.c
test/rm_osal.c
test/rm_test.c
test/rm_test.cfg

index f929e70569113c43ade8f1cc5887eeb65d6f35ce..587bf55b6be77f539b537d981c2010bb37d5f058 100644 (file)
@@ -35,12 +35,12 @@ var lldCoverityAnalysis = java.lang.System.getenv("LLDCOV");
 /* C66 ELF compiler configuration for Little Endian Mode. */\r
 var C66LE          = xdc.useModule('ti.targets.elf.C66');\r
 C66LE.rootDir       = toolsBaseDir;\r
-C66LE.ccOpts.prefix  = "-mo -o3 -q -k -eo.o";\r
+C66LE.ccOpts.prefix  = "-mo -g -q -k -eo.o";\r
 \r
 /* C66 ELF compiler configuration for Big Endian Mode. */\r
 var C66BE          = xdc.useModule('ti.targets.elf.C66_big_endian');\r
 C66BE.rootDir       = toolsBaseDir;\r
-C66BE.ccOpts.prefix  = "-mo -o3 -q -k -eo.o -DBIGENDIAN";\r
+C66BE.ccOpts.prefix  = "-mo -g -q -k -eo.o -DBIGENDIAN";\r
 \r
 /* Check if we need to run the STATIC Analysis or not? */\r
 var coverityAnalysis = java.lang.System.getenv("STATIC_ANALYZE");\r
index f4b5e2493fdadeda15f3cb2e8d27d5ecd0cd0189..15904bc60d13ba09832321fddb7bd031ebfd86c1 100644 (file)
@@ -55,22 +55,22 @@ extern "C" {
 @{
 */
 
-/** RM Service Request (serviceResult) Action Codes and Errors */
-/** RM Service Request Action Code Base */
-#define RM_SERVICE_ACTION_BASE (0)
-/** RM internal action okay - This value is for internal use by RM.  It should never be
+/** RM Service Request State Codes and Errors */
+/** RM Service Request State Code Base */
+#define RM_SERVICE_STATE_BASE (0)
+/** RM internal state okay - This value is for internal use by RM.  It should never be
  *  seen as a return value during normal operation */
-#define RM_SERVICE_ACTION_OKAY (RM_SERVICE_ACTION_BASE)
+#define RM_SERVICE_STATE_OKAY (RM_SERVICE_STATE_BASE)
+/** RM service is being processed.  Typically this means the service is
+ *  being sent to a higher level RM agent for processing */
+#define RM_SERVICE_PROCESSING (RM_SERVICE_STATE_BASE+1)
 /** RM service was approved.  The resource data in the response is valid if
  *  the service has been approved. */
-#define RM_SERVICE_APPROVED (RM_SERVICE_ACTION_BASE+1)
+#define RM_SERVICE_APPROVED (RM_SERVICE_STATE_BASE+2)
 /** Beginning of resource denied reasons */
-#define RM_SERVICE_DENIED_BEGIN (RM_SERVICE_ACTION_BASE+2)
+#define RM_SERVICE_DENIED_BEGIN (RM_SERVICE_STATE_BASE+3)
 /** End of resource denied reasons */
-#define RM_SERVICE_DENIED_END (RM_SERVICE_ACTION_BASE+2)
-/** RM service is being processed.  Typically this means the service is
- *  being sent to a higher level RM agent for processing */
-#define RM_SERVICE_PROCESSING (RM_SERVICE_ACTION_BASE+3)
+#define RM_SERVICE_DENIED_END (RM_SERVICE_STATE_BASE+3)
 
 /** RM Service Request Error Code Base */
 #define RM_SERVICE_ERROR_BASE (-64)
@@ -103,23 +103,12 @@ extern "C" {
 #define RM_SERVICE_ERROR_TRANSACTION_DOES_NOT_EXST_FOR_THIS_RM_INSTANCE (RM_SERVICE_ERROR_BASE-8)
 /** RM failed to allocate memory for new service transaction */
 #define RM_SERVICE_ERROR_TRANSACTION_FAILED_TO_ALLOCATE (RM_SERVICE_ERROR_BASE-9)
-/** RM found no service transactions queued when trying to delete a received service
- *  transaction */
-#define RM_SERVICE_ERROR_NO_TRANSACTIONS_IN_QUEUE (RM_SERVICE_ERROR_BASE-10)
 /** RM could not find the service transaction in the RM instance's transaction queue */
-#define RM_SERVICE_ERROR_SERVICE_TRANSACTION_DOES_NOT_EXIST (RM_SERVICE_ERROR_BASE-11)
-/** RM received a response transaction and found a request transaction awaiting a response.
- *  However, the request transaction was not in the "awaiting response" state */
-#define RM_SERVICE_ERROR_INVALID_REQUEST_TRANSACTION_STATE_UPON_RESPONSE (RM_SERVICE_ERROR_BASE-12)
-/** RM Client instance received a service transaction response that did not have a
- *  matching service request that originated on the Client instance */
-#define RM_SERVICE_ERROR_INVALID_TRANSACTION_RECEIVED_ON_CLIENT (RM_SERVICE_ERROR_BASE-13)
+#define RM_SERVICE_ERROR_SERVICE_TRANSACTION_DOES_NOT_EXIST (RM_SERVICE_ERROR_BASE-10)
 /** A failure occurred within a registered transport's packet free API */
-#define RM_SERVICE_ERROR_TRANSPORT_FREE_PKT_ERROR (RM_SERVICE_ERROR_BASE-14)
-/** Invalid NameServer object create on non-Server instance */
-#define RM_SERVICE_ERROR_NAMESERVER_OBJECT_CREATE_ON_INVALID_INSTANCE (RM_SERVICE_ERROR_BASE-15)
-/** Invalid NameServer object delete on non-Server instance */
-#define RM_SERVICE_ERROR_NAMESERVER_OBJECT_DELETE_ON_INVALID_INSTANCE (RM_SERVICE_ERROR_BASE-16)
+#define RM_SERVICE_ERROR_TRANSPORT_FREE_PKT_ERROR (RM_SERVICE_ERROR_BASE-11)
+/** Invalid NameServer object modification on non-Server instance */
+#define RM_SERVICE_ERROR_NAMESERVER_OBJECT_MOD_ON_INVALID_INSTANCE (RM_SERVICE_ERROR_BASE-12)
 
 /**
  * @brief Maximum number of characters in the resource names
@@ -174,15 +163,15 @@ typedef struct {
  *        requesting component
  */
 typedef struct {
-    /** Result of the service request
+    /** State of the service request.
      *  Non-negative result: RM has taken an action based on the request
      *  Negative result: RM has encountered an error handling the request */
-    int32_t serviceResult;
-    /** A request ID will be returned to the component if the requested service cannot
-     *  be completed immediately.  The request ID can be used by the component to identify
-     *  service responses received via the component callback function.  A request ID will not
+    int32_t serviceState;
+    /** A service ID will be returned to the component if the requested service cannot
+     *  be completed immediately.  The service ID can be used by the component to identify
+     *  service responses received via the component callback function.  A service ID will not
      *  be returned if the service request is satisfied immediately */
-    uint32_t requestId;
+    uint32_t serviceId;
     /** The base value of the returned resource.  In the case of a block resource allocation 
      *  response this field will contain the base value of the block. */
     int32_t resourceBase;
@@ -190,6 +179,9 @@ typedef struct {
     uint32_t resourceRange;
 } Rm_ServiceRespInfo;
 
+/** 
+ * @brief RM service callback function structure
+ */
 typedef struct {
     /** Component callback function.  RM will call this function when the 
      *  resource service request is completed. The callback function supplied
index d2906c6e9501d5b14ee22332fbfdd8fd588b2f4e..039fb12ebbb4aac8f50b453a0bb4f16b779f6b18 100644 (file)
@@ -71,7 +71,10 @@ extern "C" {
 #define RM_TRANSPORT_ERROR_PACKET_RECEPTION_ERROR (RM_TRANSPORT_ERROR_BASE-3)
 /** RM received a packet with an unknown RM packet type */
 #define RM_TRANSPORT_ERROR_INVALID_PACKET_TYPE (RM_TRANSPORT_ERROR_BASE-4)
-
+/** RM resource request transaction could not be found matching the response received */
+#define RM_TRANSPORT_ERROR_MATCHING_RESOURCE_REQUEST_NOT_FOUND (RM_TRANSPORT_ERROR_BASE-5)
+/** RM NameServer request transaction could not be found matching the response received */
+#define RM_TRANSPORT_ERROR_MATCHING_NAME_SERVER_REQUEST_NOT_FOUND (RM_TRANSPORT_ERROR_BASE-6)
 
 /** 
  * @brief Result of RM transport layer operations
index 9484c8cb0e7ed73eca826f81dbb068160e25c91d..2ef6cc90c98a878a140a8efb485fe89a007f3808 100644 (file)
--- a/src/rm.c
+++ b/src/rm.c
@@ -82,7 +82,7 @@ Rm_Transaction *Rm_transactionQueueAdd(Rm_Inst *rmInst)
     void *key;\r
 \r
     /* Lock access to the RM instance's transaction queue */\r
-    key = Rm_osalCsEnter();\r
+    key = Rm_osalMtCsEnter();\r
 \r
     /* Get memory for a new transaction from local memory */\r
     newTransaction = Rm_osalMalloc(sizeof(Rm_Transaction), false);\r
@@ -90,7 +90,7 @@ Rm_Transaction *Rm_transactionQueueAdd(Rm_Inst *rmInst)
     /* Return if the memory allocated for the transaction entry is NULL */\r
     if (newTransaction == NULL)\r
     {\r
-        Rm_osalCsExit(key);\r
+        Rm_osalMtCsExit(key);\r
         return(newTransaction);\r
     }\r
 \r
@@ -126,7 +126,7 @@ Rm_Transaction *Rm_transactionQueueAdd(Rm_Inst *rmInst)
         rmInst->transactionQueue = newTransaction;\r
     }\r
 \r
-    Rm_osalCsExit(key);\r
+    Rm_osalMtCsExit(key);\r
     return (newTransaction);\r
 }\r
 \r
@@ -158,17 +158,11 @@ int32_t Rm_transactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId)
 {\r
     Rm_Transaction *transaction = (Rm_Transaction *) rmInst->transactionQueue;\r
     Rm_Transaction *prevTransaction = NULL;\r
+    int32_t retVal = RM_SERVICE_STATE_OKAY;\r
     void *key;\r
 \r
     /* Lock access to the RM instance's transaction queue */\r
-    key = Rm_osalCsEnter();\r
-\r
-    /* Make sure there is at least one entry in the transaction queue */\r
-    if (transaction == NULL)\r
-    {\r
-        Rm_osalCsExit(key);\r
-        return (RM_SERVICE_ERROR_NO_TRANSACTIONS_IN_QUEUE);\r
-    }\r
+    key = Rm_osalMtCsEnter();\r
 \r
     /* Find the transaction ID within the specified RM instance's transaction queue. */\r
     while (transaction != NULL)\r
@@ -186,17 +180,16 @@ int32_t Rm_transactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId)
     /* Traversed entire queue but did not find transaction */\r
     if (transaction == NULL)\r
     {\r
-        Rm_osalCsExit(key);\r
-        return (RM_SERVICE_ERROR_SERVICE_TRANSACTION_DOES_NOT_EXIST);\r
+        retVal = RM_SERVICE_ERROR_SERVICE_TRANSACTION_DOES_NOT_EXIST;\r
     }\r
     else\r
     {\r
         /* Delete the transaction */\r
-        if ((prevTransaction == NULL) && transaction->nextTransaction)\r
+        if (prevTransaction == NULL)\r
         {\r
             /* Transaction to be deleted exists at start of transaction queue.  Map second\r
-             * transaction to be start of transaction queue as long as there are more than\r
-             * one transactions */\r
+             * transaction to be start of transaction queue.  This covers case where there is\r
+             * only one transaction in the queue since the nextTransaction will be NULL */\r
             rmInst->transactionQueue = transaction->nextTransaction;\r
         }\r
         else\r
@@ -211,24 +204,20 @@ int32_t Rm_transactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId)
         Rm_osalFree((void *)transaction, sizeof(Rm_Transaction), false);\r
     }\r
 \r
-    Rm_osalCsExit(key);\r
-    return (RM_SERVICE_ACTION_OKAY);\r
+    Rm_osalMtCsExit(key);\r
+    return (retVal);\r
 }\r
 \r
 uint32_t Rm_transactionInitSequenceNum(void)\r
 {\r
-    /* Sequence number can never have a value of 0 so that there are no conflicts\r
-     * when searching for transactions that received a response of a higher level RM agent */\r
+    /* Sequence number can never have a value of zero so that there are no conflicts\r
+     * with transactions that have a remoteOriginatingId of zero */\r
     return (1);\r
 }\r
 \r
 uint32_t Rm_transactionGetSequenceNum(Rm_Inst *rmInst)\r
 {\r
     uint32_t sequenceNum = 0;\r
-    void *key;\r
-\r
-    /* Lock access to the RM instance */\r
-    key = Rm_osalCsEnter();\r
 \r
     /* Get the next sequence number and then increment.  If there's an overflow\r
      * assign the initial value instead of incrementing. */\r
@@ -243,13 +232,11 @@ uint32_t Rm_transactionGetSequenceNum(Rm_Inst *rmInst)
         sequenceNum = rmInst->transactionSeqNum++;\r
     }    \r
 \r
-    Rm_osalCsExit(key);\r
     return (sequenceNum);\r
 }\r
 \r
 /* Function used to send RM response transactions to lower level agents */\r
-void Rm_transactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction,\r
-                              Rm_TransactionReceipt *receipt)\r
+void Rm_transactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 {\r
     Rm_TransportNode *dstTransportNode = NULL;\r
     Rm_Packet *rmPkt = NULL;\r
@@ -267,24 +254,24 @@ void Rm_transactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction,
         case Rm_service_RESOURCE_BLOCK_FREE:\r
         case Rm_service_RESOURCE_FREE_BY_NAME:\r
             rmPkt = Rm_transportCreateResourceResponsePkt(rmInst, dstTransportNode, \r
-                                                          transaction, receipt);\r
+                                                          transaction);\r
             break;\r
         case Rm_service_RESOURCE_MAP_TO_NAME:\r
         case Rm_service_RESOURCE_UNMAP_NAME:\r
             rmPkt = Rm_transportCreateNsResponsePkt(rmInst, dstTransportNode,\r
-                                                    transaction, receipt);\r
+                                                    transaction);\r
             break;\r
         default:\r
             /* Invalid service type.  Flag the error and return */\r
-            receipt->serviceResult = RM_SERVICE_ERROR_INVALID_SERVICE_TYPE;\r
+            transaction->state = RM_SERVICE_ERROR_INVALID_SERVICE_TYPE;\r
             break;\r
     }\r
 \r
-    if (receipt->serviceResult <= RM_SERVICE_ERROR_BASE)\r
+    if (transaction->state <= RM_SERVICE_ERROR_BASE)\r
     {\r
         /* Delete the transaction and return immediately because an error occurred \r
          * allocating the packet */\r
-        Rm_transactionQueueDelete(rmInst, transaction->id);\r
+        Rm_transactionQueueDelete(rmInst, transaction->localId);\r
         return;\r
     }\r
 \r
@@ -293,40 +280,41 @@ void Rm_transactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction,
     {\r
         /* Negative value returned by transport send.  An error occurred\r
          * in the transport while attempting to send the packet.*/\r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANPSPORT_SEND_ERROR;\r
+        transaction->state = RM_SERVICE_ERROR_TRANPSPORT_SEND_ERROR;\r
         /* Clean up the packet */\r
         if (rmInst->transport.rmFreePkt((Rm_TransportHandle) dstTransportNode, rmPkt))\r
         {\r
             /* Non-NULL value returned by transport packet free. Flag the\r
              * error */\r
-             receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_FREE_PKT_ERROR;\r
+            transaction->state = RM_SERVICE_ERROR_TRANSPORT_FREE_PKT_ERROR;\r
         }\r
         return;\r
     }\r
 \r
-    /* Fill out the receipt information and delete the transaction */\r
-    receipt->serviceResult = transaction->details;\r
-    Rm_transactionQueueDelete(rmInst, transaction->id);\r
+    /* NEED TO DO SOMETHING IF GET AN ERROR IN THE transaction->state FIELD.  CREATE\r
+     * NEW TRANSACTION WITH DATA FROM ORIGINAL?  THEN TRY TO SEND FAILED REQUEST BACK\r
+     * TO REQUESTER???  KEEP RETRYING SEND OF RESPONSE??? */\r
+\r
+    /* Delete the transaction */\r
+    Rm_transactionQueueDelete(rmInst, transaction->localId);\r
 }\r
 \r
-void Rm_allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction,\r
-                           Rm_TransactionReceipt *receipt)\r
+void Rm_allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 {\r
     if (rmInst->instType == Rm_instType_CLIENT_DELEGATE)\r
     {\r
 #if 0        \r
         /* Check local policy to see if the request can be satisfied with the\r
          * resources stored locally */\r
-         Rm_policy...API()\r
+        Rm_policy...API()\r
 \r
         if (policy check approves the resource)\r
         {\r
             /* call the allocator to allocate the resource */\r
             if (allocator returns resource)\r
             {\r
-                /* Populate the receipt with the allocated resources and the result */\r
-                receipt->serviceResult = approve reason;\r
-                receipt->serviceId = transaction->id;\r
+                /* Populate the transaction with the allocated resources and the result */\r
+                transaction->state = approve reason;\r
                 return ...\r
             }\r
             else\r
@@ -339,14 +327,13 @@ void Rm_allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction,
         else if (policy check denies resource)\r
         {\r
             /* Policy check denied resource. */\r
-            receipt->serviceResult = deny reason;\r
-            receipt->serviceId = transaction->id;\r
+            transaction->state= deny reason;\r
             return ...\r
         }\r
         else if (policy check says forward to Server for validation)\r
         {\r
             /* Forward the transaction to the Server */\r
-            Rm_transactionForwarder(rmInst, transaction, receipt);\r
+            Rm_transactionForwarder(rmInst, transaction);\r
         }\r
 #endif         \r
     }\r
@@ -362,45 +349,36 @@ void Rm_allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction,
             /* call allocator to allocate resource */\r
         }\r
 \r
-        receipt->serviceResult = approve or deny reason;\r
-        receipt->serviceId = transaction->id;\r
-        receipt->resourceBase = ...;\r
-        receipt->resourceRange = ...;\r
+        transaction->state = approve or deny reason;\r
+        transaction->resourceInfo.base = ...;\r
+        transaction->resourceInfo.range = ...;\r
 \r
         /* If source instance name does not match the current instance\r
-         * name the allocation request came from a client.  The result\r
+         * name the allocation request came from a Client.  The result\r
          * must be sent back to the Client */\r
         if (strcmp(transaction->sourceInstName, rmInst->name))\r
         {\r
-            /* Names don't match.  Copy the allocation response resource data \r
-             * into the original transaction and send it back to the Client */\r
-            transaction->details = transaction->details;\r
-            transaction->resourceInfo.base = receipt->resourceBase;\r
-            transaction->resourceInfo.range = receipt->resourceRange;\r
-            Rm_transactionResponder(rmInst, transaction, receipt);\r
+            /* Names don't match.  Send the transaction back to the Client */\r
+            Rm_transactionResponder(rmInst, transaction);\r
         }\r
         else\r
         {\r
             /* Resource allocation request originated locally on the active\r
-             * instance. Send the response via the service responder. */\r
-            transaction->details = transaction->details;\r
-            transaction->resourceInfo.base = receipt->resourceBase;\r
-            transaction->resourceInfo.range = receipt->resourceRange;             \r
-            Rm_serviceResponder(rmInst, transaction, NULL, receipt);                            \r
+             * instance. Send the response via the service responder. */          \r
+            Rm_serviceResponder(rmInst, transaction);                            \r
         }\r
 #endif        \r
     }   \r
 }\r
 \r
-void Rm_freeHandler (Rm_Inst *rmInst, Rm_Transaction *transaction,\r
-                     Rm_TransactionReceipt *receipt)\r
+void Rm_freeHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 {\r
     if (rmInst->instType == Rm_instType_CLIENT_DELEGATE)\r
     {\r
 #if 0        \r
         /* Check local policy to see if the request can be satisfied with the\r
          * resources stored locally */\r
-         Rm_policy...API()\r
+        Rm_policy...API()\r
 \r
         if (policy check approves the free)\r
         {\r
@@ -416,22 +394,20 @@ void Rm_freeHandler (Rm_Inst *rmInst, Rm_Transaction *transaction,
             else\r
             {\r
                 /* Populate the receipt with the freed resources and the result */\r
-                receipt->serviceResult = approve reason;\r
-                receipt->serviceId = transaction->id;\r
+                transaction->state = approve reason;\r
                 return ...\r
             }\r
         }\r
         else if (policy check denies resource free)\r
         {\r
             /* Policy check denied resource. */\r
-            receipt->serviceResult = deny reason;\r
-            receipt->serviceId = transaction->id;\r
+            transaction->state = deny reason;\r
             return ...\r
         }\r
         else if (policy check says forward to Server for validation)\r
         {\r
             /* Forward the transaction to the Server */\r
-            Rm_transactionForwarder(rmInst, transaction, receipt);\r
+            Rm_transactionForwarder(rmInst, transaction);\r
         }\r
 #endif         \r
     }\r
@@ -446,39 +422,30 @@ void Rm_freeHandler (Rm_Inst *rmInst, Rm_Transaction *transaction,
             /* call allocator to free resources */\r
         }\r
             \r
-        receipt->serviceResult = approve or deny reason;\r
-        receipt->serviceId = transaction->id;\r
-        receipt->resourceBase = ...;\r
-        receipt->resourceRange = ...;\r
+        transaction->state = approve or deny reason;\r
+        transaction->resourceInfo.base = ...;\r
+        transaction->resourceInfo.range = ...;\r
 \r
         /* If source instance name does not match the current instance\r
          * name the allocation request came from a client.  The result\r
          * must be sent back to the Client */\r
         if (strcmp(transaction->sourceInstName, rmInst->name))\r
         {\r
-            /* Names don't match.  Copy the free response resource data \r
-             * into the original transaction and send it back to the Client Delegate or Client */\r
-            transaction->details = transaction->details;\r
-            transaction->resourceInfo.base = receipt->resourceBase;\r
-            transaction->resourceInfo.range = receipt->resourceRange;\r
-            Rm_transactionResponder(rmInst, transaction, receipt);\r
+            /* Names don't match.  Send the transaction back to the Client Delegate or Client */\r
+            Rm_transactionResponder(rmInst, transaction);\r
         }\r
         else\r
         {\r
             /* Resource allocation request originated locally on the active\r
              * instance. Send the response via the service responder. */\r
-            transaction->details = transaction->details;\r
-            transaction->resourceInfo.base = receipt->resourceBase;\r
-            transaction->resourceInfo.range = receipt->resourceRange;\r
-            Rm_serviceResponder(rmInst, transaction, NULL, receipt);                            \r
+            Rm_serviceResponder(rmInst, transaction);                            \r
         }\r
 #endif        \r
     }   \r
 }\r
 \r
 /* Function used to forward RM transactions to higher level agents */\r
-void Rm_transactionForwarder (Rm_Inst *rmInst, Rm_Transaction *transaction,\r
-                              Rm_TransactionReceipt *receipt)\r
+void Rm_transactionForwarder (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 {\r
     Rm_TransportNode *dstTransportNode = NULL;\r
     Rm_Packet *rmPkt = NULL;\r
@@ -486,7 +453,7 @@ void Rm_transactionForwarder (Rm_Inst *rmInst, Rm_Transaction *transaction,
     /* Make sure the RM instance has a transport registered with a higher level agent */\r
     if (rmInst->registeredWithDelegateOrServer == false)\r
     {\r
-        receipt->serviceResult = RM_SERVICE_ERROR_NOT_REGISTERED_WITH_DEL_OR_SERVER;\r
+        transaction->state = RM_SERVICE_ERROR_NOT_REGISTERED_WITH_DEL_OR_SERVER;\r
         return;\r
     }\r
 \r
@@ -512,55 +479,47 @@ void Rm_transactionForwarder (Rm_Inst *rmInst, Rm_Transaction *transaction,
         case Rm_service_RESOURCE_BLOCK_FREE:\r
         case Rm_service_RESOURCE_FREE_BY_NAME:\r
             rmPkt = Rm_transportCreateResourceReqPkt(rmInst, dstTransportNode, \r
-                                                     transaction, receipt);\r
+                                                     transaction);\r
             break;\r
         case Rm_service_RESOURCE_MAP_TO_NAME:\r
         case Rm_service_RESOURCE_UNMAP_NAME:\r
             rmPkt = Rm_transportCreateNsRequestPkt(rmInst, dstTransportNode,\r
-                                                   transaction, receipt);\r
+                                                   transaction);\r
             break;\r
         default:\r
             /* Invalid service type.  Flag the error and return */\r
-            receipt->serviceResult = RM_SERVICE_ERROR_INVALID_SERVICE_TYPE;\r
+            transaction->state = RM_SERVICE_ERROR_INVALID_SERVICE_TYPE;\r
             break;\r
     }\r
 \r
-    if (receipt->serviceResult <= RM_SERVICE_ERROR_BASE)\r
+    if (transaction->state <= RM_SERVICE_ERROR_BASE)\r
     {\r
         /* Return immediately because an error occurred allocating the packet */\r
         return;\r
     }\r
 \r
-    /* Switch the queued transaction to the awaiting response state */\r
-    transaction->state = Rm_transactionState_AWAITING_RESPONSE;\r
-\r
     /* Send the RM packet to the application transport */\r
     if (rmInst->transport.rmSend((Rm_TransportHandle) dstTransportNode, rmPkt) < RM_TRANSPORT_SUCCESSFUL)\r
     {\r
         /* Negative value returned by transport send.  An error occurred\r
          * in the transport while attempting to send the packet.*/\r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANPSPORT_SEND_ERROR;\r
+        transaction->state = RM_SERVICE_ERROR_TRANPSPORT_SEND_ERROR;\r
         /* Clean up the packet */\r
         if (rmInst->transport.rmFreePkt((Rm_TransportHandle) dstTransportNode, rmPkt))\r
         {\r
             /* Non-NULL value returned by transport packet free. Flag the\r
              * error */\r
-             receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_FREE_PKT_ERROR;\r
+            transaction->state = RM_SERVICE_ERROR_TRANSPORT_FREE_PKT_ERROR;\r
         }\r
         return;\r
     }\r
 \r
-    /* Inform requesting component that the service is being forwarded to a higher lever\r
-     * RM agent for processing.  The result of the service will be provided to the \r
-     * component via the specified callback function */\r
-    receipt->serviceResult = RM_SERVICE_PROCESSING;\r
-    receipt->serviceId = transaction->id;\r
+    /* Transaction is not deleted because it is awaiting a response from the higher level\r
+     * RM instance */\r
 }\r
 \r
 void Rm_transactionProcessor (Rm_Inst *rmInst, Rm_Transaction *transaction)\r
 {\r
-    Rm_Transaction *queuedTransaction = NULL;\r
-\r
     /* Handle auto-forwarded transactions.  These transactions include:\r
      * - All request transactions received on Clients are forwarded to the Client Delegate\r
      * - NameServer requests received on the Client Delegate are forwarded to the Server */\r
@@ -569,68 +528,31 @@ void Rm_transactionProcessor (Rm_Inst *rmInst, Rm_Transaction *transaction)
          (transaction->type == Rm_service_RESOURCE_MAP_TO_NAME) ||\r
          (transaction->type == Rm_service_RESOURCE_UNMAP_NAME)))\r
     {\r
-        /* Check if the new transaction's ID matches any transactions waiting for\r
-         * responses.  A transaction received as a response will have an ID that \r
-         * matches the transaction that originated the request packet */\r
-        if (queuedTransaction = Rm_transactionQueueFind(rmInst, transaction->id))\r
+        /* Check if the transaction is a transaction that received a response to its\r
+         * request. */\r
+        if (transaction->state != RM_SERVICE_PROCESSING)\r
         {\r
-            if (queuedTransaction->state == Rm_transactionState_AWAITING_RESPONSE)\r
+\r
+            /* A transaction has received a response. Send the response to either the \r
+             * transaction or service responder based on the source instance */\r
+            if (strcmp(transaction->sourceInstName, rmInst->name))\r
             {\r
-                if (rmInst->instType == Rm_instType_CLIENT)\r
-                {\r
-                    /* Client found a transaction awaiting a response.  Pass both transactions\r
-                     * to the service responder for response processing */\r
-                    Rm_serviceResponder(rmInst, transaction, queuedTransaction, receipt);\r
-                }\r
-                else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE)\r
-                {\r
-                    /* Client Delegate found a NameServer transaction awaiting a response. Send the \r
-                     * response to either the transaction or service responder based on the \r
-                     * source instance */\r
-                    if (strcmp(queuedTransaction->sourceInstName, rmInst->name))\r
-                    {\r
-                        /* NameServer transaction originated from another instance.  Use the \r
-                         * transaction responder to send the NameServer result to the source instance.\r
-                         * Need to transfer the NameServer result details to the request transaction \r
-                         * which will be reused for the response. */\r
-                        queuedTransaction->details = transaction->details;\r
-                        Rm_transactionResponder(rmInst, queuedTransaction, receipt);\r
-                        /* Delete the response transaction */\r
-                        Rm_transactionQueueDelete(rmInst, transaction->id);                        \r
-                    }\r
-                    else\r
-                    {\r
-                        /* NameServer request originated on the Client Delegate instance.  Send to the\r
-                         * service responder */\r
-                        Rm_serviceResponder(rmInst, transaction, queuedTransaction,\r
-                                            receipt);\r
-                    }\r
-                }\r
+                /* Transaction originated from another instance.  Use the \r
+                 * transaction responder to send the result to the source instance.  This\r
+                 * is not possible on RM Clients since they can't forward RM services */\r
+                Rm_transactionResponder(rmInst, transaction);\r
             }\r
             else\r
             {\r
-                /* Request transaction was not in the awaiting response state.  Flag the\r
-                 * error in the receipt and return */\r
-                receipt->serviceResult = RM_SERVICE_ERROR_INVALID_REQUEST_TRANSACTION_STATE_UPON_RESPONSE;\r
+                /* Transaction originated on this instance.  Send to the\r
+                 * service responder */\r
+                Rm_serviceResponder(rmInst, transaction);\r
             }\r
         }\r
         else\r
         {\r
-            /* This is a new transaction.  Make sure the transaction is not a \r
-             * response transaction sent to the wrong RM instance */\r
-            if ((transaction->state == Rm_transactionState_RESOURCE_APPROVED) ||\r
-                (transaction->state == Rm_transactionState_RESOURCE_DENIED))\r
-            {\r
-                /* No matching request transaction.  This transaction result was sent to the\r
-                 * wrong RM instance.  Flag the error in the receipt and return */\r
-                receipt->serviceResult = RM_SERVICE_ERROR_INVALID_TRANSACTION_RECEIVED_ON_CLIENT;\r
-            }\r
-            else\r
-            {\r
-                /* All service requests on Clients are forwarded to the higher level RM Client \r
-                 * Delegate.  NameServer requests on Client Delegates are forwarded to the Server. */\r
-                Rm_transactionForwarder(rmInst, transaction, receipt);\r
-            }\r
+            /* This is a new transaction that must be forwarded to a higher level RM instance. */\r
+            Rm_transactionForwarder(rmInst, transaction);\r
         }\r
     }\r
     else\r
@@ -641,162 +563,78 @@ void Rm_transactionProcessor (Rm_Inst *rmInst, Rm_Transaction *transaction)
             case Rm_service_RESOURCE_ALLOCATE:\r
             case Rm_service_RESOURCE_BLOCK_ALLOCATE:\r
             case Rm_service_RESOURCE_ALLOCATE_BY_NAME:\r
-                /* Run the transaction through the response handler to take care of any\r
-                 * transactions that are responses to sent allocation requests. */\r
-                if (queuedTransaction = Rm_transactionQueueFind(rmInst, transaction->id))\r
+            case Rm_service_RESOURCE_FREE:\r
+            case Rm_service_RESOURCE_BLOCK_FREE:\r
+            case Rm_service_RESOURCE_FREE_BY_NAME:                \r
+                /* Check if the transaction is fulfilled request */\r
+                if (transaction->state != RM_SERVICE_PROCESSING)\r
                 {\r
-                    if (queuedTransaction->state == Rm_transactionState_AWAITING_RESPONSE)\r
+                    /* If source instance name does not match the current instance\r
+                     * name the allocation request came from a client.  The result\r
+                     * must be sent back to the Client */\r
+                    if (strcmp(transaction->sourceInstName, rmInst->name))\r
                     {\r
-                        /* If source instance name does not match the current instance\r
-                         * name the allocation request came from a client.  The result\r
-                         * must be sent back to the Client */\r
-                        if (strcmp(queuedTransaction->sourceInstName, rmInst->name))\r
-                        {\r
-                            /* Names don't match.  Copy the allocation response resource data \r
-                             * into the original transaction and send it back to the Client */\r
-                            queuedTransaction->details = transaction->details;\r
-                            memcpy ((void *)&(queuedTransaction->resourceInfo), \r
-                                    (void *)&(transaction->resourceInfo), sizeof(Rm_ResourceInfo));\r
-                            Rm_transactionResponder(rmInst, queuedTransaction, receipt);\r
-                            /* Delete the response transaction */\r
-                            Rm_transactionQueueDelete(rmInst, transaction->id);\r
-                        }\r
-                        else\r
-                        {\r
-                            /* Resource allocation request originated locally on Client Delegate\r
-                             * instance. Send the response via the service responder. */\r
-                            Rm_serviceResponder(rmInst, transaction, queuedTransaction,\r
-                                                receipt);                            \r
-                        }\r
+                        Rm_transactionResponder(rmInst, transaction);\r
                     }\r
                     else\r
                     {\r
-                        /* Request transaction was not in the awaiting response state.  Flag the\r
-                         * error in the receipt and return */\r
-                        receipt->serviceResult = RM_SERVICE_ERROR_INVALID_REQUEST_TRANSACTION_STATE_UPON_RESPONSE;\r
-                    }\r
+                        /* Resource allocation request originated locally.  Send the response\r
+                         * via the service responder. */\r
+                        Rm_serviceResponder(rmInst, transaction);      \r
+\r
 \r
+                        /* WHAT IF TRANSACITON CAME FROM CD AND WAS SOLVED IMMEDIATELY. NEED TO RETURN\r
+                         * THE TRANSACTION RATHER THAN GO THROUGH THE SERVICERESPONDER */\r
+                    }\r
                 }\r
                 else\r
                 {\r
                     /* This is a new transaction request originating from an RM instance with fewer\r
-                     * allocate/free privileges.  Run the allocation handler to see if the resource\r
+                     * allocate/free privileges.  Run the allocation or free handler to see if the resource\r
                      * request can be handled locally or if it needs to be forwarded to a higher level\r
                      * agent */\r
-                     Rm_allocationHandler(rmInst, transaction, receipt);\r
-                }\r
-                break;\r
-            case Rm_service_RESOURCE_FREE:\r
-            case Rm_service_RESOURCE_BLOCK_FREE:\r
-            case Rm_service_RESOURCE_FREE_BY_NAME:\r
-                /* Run the transaction through the response handler to take care of any\r
-                 * transactions that are responses to sent free requests. */\r
-                if (queuedTransaction = Rm_transactionQueueFind(rmInst, transaction->id))\r
-                {\r
-                    if (queuedTransaction->state == Rm_transactionState_AWAITING_RESPONSE)\r
+                    if ((transaction->type == Rm_service_RESOURCE_ALLOCATE) ||\r
+                        (transaction->type == Rm_service_RESOURCE_BLOCK_ALLOCATE) ||\r
+                        (transaction->type == Rm_service_RESOURCE_ALLOCATE_BY_NAME))\r
                     {\r
-                        /* If source instance name does not match the current instance\r
-                         * name the allocation request came from a client.  The result\r
-                         * must be sent back to the Client */\r
-                        if (strcmp(queuedTransaction->sourceInstName, rmInst->name))\r
-                        {\r
-                            /* Names don't match.  Copy the free response resource data \r
-                             * into the original transaction and send it back to the Client */\r
-                            queuedTransaction->details = transaction->details;\r
-                            memcpy ((void *)&(queuedTransaction->resourceInfo), \r
-                                    (void *)&(transaction->resourceInfo), sizeof(Rm_ResourceInfo));\r
-                            Rm_transactionResponder(rmInst, queuedTransaction, receipt);\r
-                            /* Delete the response transaction */\r
-                            Rm_transactionQueueDelete(rmInst, transaction->id);\r
-                        }\r
-                        else\r
-                        {\r
-                            /* Resource free request originated locally on Client Delegate\r
-                             * instance. Send the response via the service responder. */\r
-                            Rm_serviceResponder(rmInst, transaction, queuedTransaction,\r
-                                                receipt);                            \r
-                        }\r
+                        Rm_allocationHandler(rmInst, transaction);\r
                     }\r
                     else\r
                     {\r
-                        /* Request transaction was not in the awaiting response state.  Flag the\r
-                         * error in the receipt and return */\r
-                        receipt->serviceResult = RM_SERVICE_ERROR_INVALID_REQUEST_TRANSACTION_STATE_UPON_RESPONSE;\r
+                        Rm_freeHandler(rmInst, transaction);\r
                     }\r
-\r
-                }\r
-                else\r
-                {\r
-                    /* This is a new transaction request originating from an RM instance with fewer\r
-                     * allocate/free privileges.  Run the free handler to see if the resource\r
-                     * request can be handled locally or if it needs to be forwarded to a higher level\r
-                     * agent */\r
-                     Rm_freeHandler(rmInst, transaction, receipt);\r
                 }\r
-\r
                 break;\r
             case Rm_service_RESOURCE_MAP_TO_NAME:\r
+            case Rm_service_RESOURCE_UNMAP_NAME:                \r
                 /* Server is the only RM instance capable of adding NameServer objects */\r
                 if (rmInst->instType == Rm_instType_SERVER)\r
                 {\r
-                    /* Create a new NameServer object with the request transaction information */\r
-                    Rm_nsAddObject(rmInst, transaction, receipt);\r
-\r
-                    /* Return the result of the NameServer addition to the RM instance\r
-                     * that requested it */\r
-                    transaction->details = receipt->serviceResult;\r
-\r
-                    /* If source instance name does not match the current instance\r
-                     * name the NameServer request came from a Client or Client Delegate.  The \r
-                     * result must be sent back to the Client or Client Delegate */\r
-                    if (strcmp(transaction->sourceInstName, rmInst->name))\r
+                    if (transaction->type == Rm_service_RESOURCE_MAP_TO_NAME)\r
                     {\r
-                        Rm_transactionResponder(rmInst, queuedTransaction, receipt);\r
+                        /* Create a new NameServer object with the request transaction information.\r
+                         * Transaction will contain the state result of the NameServer addition. */\r
+                        Rm_nsAddObject(rmInst, transaction);\r
                     }\r
                     else\r
                     {\r
-                        /* NameServer addition request originated locally on Server\r
-                         * instance. Send the response via the service responder.  In this case\r
-                         * the request transaction will be passed as NULL since the request\r
-                         * is being reused as the response */\r
-                        Rm_serviceResponder(rmInst, transaction, NULL, receipt);                            \r
+                        /* Delete an existing NameServer object with the request transaction information\r
+                         * Transaction will contain the state result of the NameServer addition. */\r
+                        Rm_nsDeleteObject(rmInst, transaction);\r
                     }\r
-                }\r
-                else\r
-                {\r
-                    receipt->serviceResult = RM_SERVICE_ERROR_NAMESERVER_OBJECT_CREATE_ON_INVALID_INSTANCE;\r
-                }\r
-                break;\r
-            case Rm_service_RESOURCE_UNMAP_NAME:\r
-                /* Server is the only RM instance capable of deleting NameServer objects */\r
-                if (rmInst->instType == Rm_instType_SERVER)\r
-                {\r
-                    /* Delete an existing NameServer object with the request transaction information */\r
-                    Rm_nsDeleteObject(rmInst, transaction, receipt);\r
 \r
-                    /* Return the result of the NameServer deletion to the RM instance\r
-                     * that requested it */\r
-                    transaction->details = receipt->serviceResult;\r
-\r
-                    /* If source instance name does not match the current instance\r
+                    /* If source instance name does not match the local instance\r
                      * name the NameServer request came from a Client or Client Delegate.  The \r
-                     * result must be sent back to the Client or Client Delegate */\r
+                     * result must be sent back to the Client or Client Delegate.  Just return if it does\r
+                     * match since the NameServer transaction result can be returned immediately. */\r
                     if (strcmp(transaction->sourceInstName, rmInst->name))\r
                     {\r
-                        Rm_transactionResponder(rmInst, queuedTransaction, receipt);\r
+                        Rm_transactionResponder(rmInst, transaction);\r
                     }\r
-                    else\r
-                    {\r
-                        /* NameServer delete request originated locally on Server\r
-                         * instance. Send the response via the service responder.  In this case\r
-                         * the request transaction will be passed as NULL since the request\r
-                         * is being reused as the response */\r
-                        Rm_serviceResponder(rmInst, transaction, NULL, receipt);                            \r
-                    }                    \r
                 }\r
                 else\r
                 {\r
-                    receipt->serviceResult = RM_SERVICE_ERROR_NAMESERVER_OBJECT_DELETE_ON_INVALID_INSTANCE;\r
+                    transaction->state = RM_SERVICE_ERROR_NAMESERVER_OBJECT_MOD_ON_INVALID_INSTANCE;\r
                 }\r
                 break;\r
         }\r
index 935951323f892ad314d7a1d6e705c102efffc23a..a4ac48618336690bcaa2fd80b076e2c2a6864130 100644 (file)
  ********************** Internal Functions ****************************
  **********************************************************************/
 
-void Rm_nsAddObject(Rm_Inst *rmInst, Rm_Transaction *transaction, 
-                    Rm_TransactionReceipt *receipt)
+void Rm_nsAddObject(Rm_Inst *rmInst, Rm_Transaction *transaction)
 {
     /* STUB APPROVED FOR NOW */
-    receipt->serviceResult = RM_SERVICE_APPROVED;
+    transaction->state = RM_SERVICE_APPROVED;
 
 }
 
-void Rm_nsDeleteObject(Rm_Inst *rmInst, Rm_Transaction *transaction, 
-                    Rm_TransactionReceipt *receipt)
+void Rm_nsDeleteObject(Rm_Inst *rmInst, Rm_Transaction *transaction)
 {
     /* STUB APPROVED FOR NOW */
-    receipt->serviceResult = RM_SERVICE_APPROVED;
+    transaction->state = RM_SERVICE_APPROVED;
 }
 
index edfdd5a8e7b686bf479c44184fa0980dbfbe63f2..b334f096da247041f6155fb26244f41919705fc8 100644 (file)
@@ -60,18 +60,12 @@ void Rm_serviceHandler (void *rmHandle, Rm_ServiceReqInfo *serviceRequest,
 {
     Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
     Rm_Transaction *transaction;
-    void *key;
-
-    /* Prevent another component using the same instance from wiping out the current
-     * service request */
-    key = Rm_osalCsEnter();
 
     /* Make sure serviceType is valid and that a callback function has been provided */
     if ((serviceRequest->type < Rm_service_FIRST) || 
         (serviceRequest->type > Rm_service_LAST))
     {
         serviceResponse->serviceState = RM_SERVICE_ERROR_INVALID_SERVICE_TYPE;
-        Rm_osalCsExit(key);
         return;
     }
     else if (serviceRequest->callback.serviceCallback == NULL)
@@ -82,7 +76,6 @@ void Rm_serviceHandler (void *rmHandle, Rm_ServiceReqInfo *serviceRequest,
          * through the callback function provided by the component.  Return an error 
          * if the component does not provide a callback function. */
         serviceResponse->serviceState = RM_SERVICE_ERROR_CALLBACK_NOT_PROVIDED;
-        Rm_osalCsExit(key);
         return;
     }
     
@@ -132,7 +125,7 @@ void Rm_serviceHandler (void *rmHandle, Rm_ServiceReqInfo *serviceRequest,
             }
 
             /* Delete the transaction since a response was received immediately */
-            Rm_transactionQueueDelete(rmInst, transaction->id);
+            Rm_transactionQueueDelete(rmInst, transaction->localId);
         }
         else if ((serviceResponse->serviceState >= RM_SERVICE_DENIED_BEGIN) &&
                  (serviceResponse->serviceState <= RM_SERVICE_DENIED_END))
@@ -140,11 +133,10 @@ void Rm_serviceHandler (void *rmHandle, Rm_ServiceReqInfo *serviceRequest,
             /* The serviceState field will contain information regarding why the 
              * service was denied.  Just delete the transaction since a response was
              * received immediately */
-            Rm_transactionQueueDelete(rmInst, transaction->id);
+            Rm_transactionQueueDelete(rmInst, transaction->localId);
         }
     }
 
-    Rm_osalCsExit(key); 
     return;
 }
 
index 4a2b5cb243e6d0b8d51977301b59b5576d6d6c7c..c209034c4d17058bd596851e983f8c284cf3dc91 100644 (file)
@@ -61,10 +61,6 @@ Rm_TransportNode *Rm_transportNodeAdd(Rm_Inst *rmInst, Rm_TransportCfg *transpor
 {\r
     Rm_TransportNode *routeMap = (Rm_TransportNode *)rmInst->routeMap;\r
     Rm_TransportNode *newTransportNode = NULL;\r
-    void *key;\r
-\r
-    /* Lock access to the RM instance's route map */\r
-    key = Rm_osalCsEnter();\r
 \r
     /* Get memory for a new transport node from local memory */\r
     newTransportNode = Rm_osalMalloc (sizeof(Rm_TransportNode), false);\r
@@ -98,8 +94,6 @@ Rm_TransportNode *Rm_transportNodeAdd(Rm_Inst *rmInst, Rm_TransportCfg *transpor
             rmInst->routeMap = (void *)newTransportNode;\r
         }\r
     }\r
-   \r
-    Rm_osalCsExit(key);\r
 \r
     return (newTransportNode);\r
 }\r
@@ -184,15 +178,10 @@ Rm_TransportResult Rm_transportNodeDelete(Rm_Inst *rmInst, Rm_TransportHandle tr
 {\r
     Rm_TransportNode *transportNode = (Rm_TransportNode *)rmInst->routeMap;\r
     Rm_TransportNode *prevNode = NULL;\r
-    void *key;\r
-\r
-    /* Lock access to the RM instance's route map */\r
-    key = Rm_osalCsEnter();\r
 \r
     /* Make sure there is at least one entry in the transaction queue */\r
     if (transportNode == NULL)\r
     {\r
-        Rm_osalCsExit(key);\r
         return (RM_TRANSPORT_ERROR_NO_TRANSPORTS_REGISTERED);\r
     }\r
 \r
@@ -212,7 +201,6 @@ Rm_TransportResult Rm_transportNodeDelete(Rm_Inst *rmInst, Rm_TransportHandle tr
     /* Traversed entire queue but did not find transaction */\r
     if (transportNode == NULL)\r
     {\r
-        Rm_osalCsExit(key);\r
         return (RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED);\r
     }\r
     else\r
@@ -237,12 +225,11 @@ Rm_TransportResult Rm_transportNodeDelete(Rm_Inst *rmInst, Rm_TransportHandle tr
         Rm_osalFree((void *) transportNode, sizeof(Rm_TransportNode), false);\r
     }\r
 \r
-    Rm_osalCsExit(key);\r
     return (RM_TRANSPORT_SUCCESSFUL);\r
 }\r
 \r
 Rm_Packet *Rm_transportCreateResourceReqPkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
-                                            Rm_Transaction *transaction, Rm_TransactionReceipt *receipt)\r
+                                            Rm_Transaction *transaction)\r
 {\r
     Rm_Packet *rmPkt = NULL;\r
     Rm_ResourceRequestPkt *resourceReqPkt = NULL;\r
@@ -251,7 +238,7 @@ Rm_Packet *Rm_transportCreateResourceReqPkt(Rm_Inst *rmInst, Rm_TransportNode *d
     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
         NULL)\r
     {\r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
+        transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
         return (NULL);\r
     }\r
 \r
@@ -259,7 +246,7 @@ Rm_Packet *Rm_transportCreateResourceReqPkt(Rm_Inst *rmInst, Rm_TransportNode *d
      * rmPktLen and Rm_PktType fields */\r
     if (rmPkt->pktLenBytes < (sizeof(Rm_ResourceRequestPkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
     {   \r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
+        transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
         return (NULL);\r
     }\r
 \r
@@ -269,7 +256,7 @@ Rm_Packet *Rm_transportCreateResourceReqPkt(Rm_Inst *rmInst, Rm_TransportNode *d
     /* Assign the packet's data field to be the start of the resource request packet */\r
     resourceReqPkt = (Rm_ResourceRequestPkt *) rmPkt->data;\r
     /* Populate the resource request packet using the transaction information */\r
-    resourceReqPkt->requestId = transaction->id;\r
+    resourceReqPkt->requestId = transaction->localId;\r
     if (transaction->type == Rm_service_RESOURCE_ALLOCATE)\r
     {\r
         resourceReqPkt->resourceReqType = Rm_resReqPktType_ALLOCATE;\r
@@ -303,7 +290,7 @@ Rm_Packet *Rm_transportCreateResourceReqPkt(Rm_Inst *rmInst, Rm_TransportNode *d
 }\r
 \r
 Rm_Packet *Rm_transportCreateResourceResponsePkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
-                                                 Rm_Transaction *transaction, Rm_TransactionReceipt *receipt)\r
+                                                 Rm_Transaction *transaction)\r
 {\r
     Rm_Packet *rmPkt = NULL;\r
     Rm_ResourceResponsePkt *resourceRespPkt = NULL;\r
@@ -312,7 +299,7 @@ Rm_Packet *Rm_transportCreateResourceResponsePkt(Rm_Inst *rmInst, Rm_TransportNo
     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
         NULL)\r
     {\r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
+        transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
         return (NULL);\r
     }\r
 \r
@@ -320,7 +307,7 @@ Rm_Packet *Rm_transportCreateResourceResponsePkt(Rm_Inst *rmInst, Rm_TransportNo
      * rmPktLen and Rm_PktType fields */\r
     if (rmPkt->pktLenBytes < (sizeof(Rm_ResourceResponsePkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
     {   \r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
+        transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
         return (NULL);\r
     }\r
 \r
@@ -329,9 +316,11 @@ Rm_Packet *Rm_transportCreateResourceResponsePkt(Rm_Inst *rmInst, Rm_TransportNo
                           \r
     /* Assign the packet's data field to be the start of the resource response packet */\r
     resourceRespPkt = (Rm_ResourceResponsePkt *)rmPkt->data;\r
-    /* Populate the resource response packet using the transaction information */\r
-    resourceRespPkt->responseId = transaction->id;\r
-    resourceRespPkt->requestResult = transaction->details;\r
+    /* Populate the resource response packet using the transaction information.  The\r
+     * responseId is the remoteOriginatingId.  The responseId must match the local ID \r
+     * of the transaction that originated the request */\r
+    resourceRespPkt->responseId = transaction->remoteOriginatingId;\r
+    resourceRespPkt->requestState = transaction->state;\r
     /* Copy the resource data */\r
     memcpy ((void *)&(resourceRespPkt->resourceInfo), (void *)&(transaction->resourceInfo),\r
             sizeof(Rm_ResourceInfo));\r
@@ -340,7 +329,7 @@ Rm_Packet *Rm_transportCreateResourceResponsePkt(Rm_Inst *rmInst, Rm_TransportNo
 }\r
 \r
 Rm_Packet *Rm_transportCreateNsRequestPkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
-                                          Rm_Transaction *transaction, Rm_TransactionReceipt *receipt)\r
+                                          Rm_Transaction *transaction)\r
 {\r
     Rm_Packet *rmPkt = NULL;\r
     Rm_NsRequestPkt *nsReqPkt = NULL;\r
@@ -349,7 +338,7 @@ Rm_Packet *Rm_transportCreateNsRequestPkt(Rm_Inst *rmInst, Rm_TransportNode *dst
     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
         NULL)\r
     {\r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
+        transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
         return (NULL);\r
     }\r
 \r
@@ -357,7 +346,7 @@ Rm_Packet *Rm_transportCreateNsRequestPkt(Rm_Inst *rmInst, Rm_TransportNode *dst
      * rmPktLen and Rm_PktType fields */\r
     if (rmPkt->pktLenBytes < (sizeof(Rm_NsRequestPkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
     {   \r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
+        transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
         return (NULL);\r
     }\r
 \r
@@ -367,7 +356,7 @@ Rm_Packet *Rm_transportCreateNsRequestPkt(Rm_Inst *rmInst, Rm_TransportNode *dst
     /* Assign the packet's data field to be the start of the NameServer request packet */\r
     nsReqPkt = (Rm_NsRequestPkt *)rmPkt->data;\r
     /* Populate the NameServer request packet using the transaction information */\r
-    nsReqPkt->requestId = transaction->id;\r
+    nsReqPkt->requestId = transaction->localId;\r
     if (transaction->type == Rm_service_RESOURCE_MAP_TO_NAME)\r
     {\r
         nsReqPkt->nsRequestType = Rm_nsReqPktType_MAP_RESOURCE;\r
@@ -385,7 +374,7 @@ Rm_Packet *Rm_transportCreateNsRequestPkt(Rm_Inst *rmInst, Rm_TransportNode *dst
 }\r
 \r
 Rm_Packet *Rm_transportCreateNsResponsePkt(Rm_Inst *rmInst, Rm_TransportNode *dstTransportNode,\r
-                                           Rm_Transaction *transaction, Rm_TransactionReceipt *receipt)\r
+                                           Rm_Transaction *transaction)\r
 {\r
     Rm_Packet *rmPkt = NULL;\r
     Rm_NsResponsePkt *nsRespPkt = NULL;\r
@@ -394,7 +383,7 @@ Rm_Packet *Rm_transportCreateNsResponsePkt(Rm_Inst *rmInst, Rm_TransportNode *ds
     if ((rmPkt = rmInst->transport.rmAllocPkt((Rm_TransportHandle)dstTransportNode, sizeof(Rm_Packet))) ==\r
         NULL)\r
     {\r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
+        transaction->state = RM_SERVICE_ERROR_TRANSPORT_ALLOC_PKT_ERROR;\r
         return (NULL);\r
     }\r
 \r
@@ -402,7 +391,7 @@ Rm_Packet *Rm_transportCreateNsResponsePkt(Rm_Inst *rmInst, Rm_TransportNode *ds
      * rmPktLen and Rm_PktType fields */\r
     if (rmPkt->pktLenBytes < (sizeof(Rm_NsResponsePkt) + sizeof(uint32_t) + sizeof(Rm_pktType)))\r
     {   \r
-        receipt->serviceResult = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
+        transaction->state = RM_SERVICE_ERROR_TRANSPORT_PKT_BUF_TOO_SMALL;\r
         return (NULL);\r
     }\r
 \r
@@ -411,9 +400,11 @@ Rm_Packet *Rm_transportCreateNsResponsePkt(Rm_Inst *rmInst, Rm_TransportNode *ds
                           \r
     /* Assign the packet's data field to be the start of the NameServer response packet */\r
     nsRespPkt = (Rm_NsResponsePkt *)rmPkt->data;\r
-    /* Populate the NameServer response packet using the transaction information */\r
-    nsRespPkt->responseId = transaction->id;\r
-    nsRespPkt->requestResult = transaction->details;\r
+    /* Populate the NameServer response packet using the transaction information. The\r
+     * responseId is the remoteOriginatingId.  The responseId must match the local ID \r
+     * of the transaction that originated the request */\r
+    nsRespPkt->responseId = transaction->remoteOriginatingId;\r
+    nsRespPkt->requestState = transaction->state;\r
 \r
     return (rmPkt);\r
 }\r
@@ -429,7 +420,7 @@ Rm_TransportHandle Rm_transportRegister (Rm_Handle rmHandle, Rm_TransportCfg *tr
     void *key;\r
 \r
     /* Lock access to the RM instance */\r
-    key = Rm_osalCsEnter();\r
+    key = Rm_osalMtCsEnter();\r
 \r
     /* RM Servers cannot connect to other Servers.  RM Client Delegates cannot\r
      * connect to other Client Delegates. */\r
@@ -438,21 +429,18 @@ Rm_TransportHandle Rm_transportRegister (Rm_Handle rmHandle, Rm_TransportCfg *tr
         ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
          (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)))\r
     {\r
-        Rm_osalCsExit(key);\r
-        return (NULL); /* Error - return null */\r
+        goto exitCs; /* Error - return null */\r
     }\r
 \r
-    /* Verify Clients and Client Delegates are not registering with more than one \r
-     * Client Delegate or Server. Assuming a Client Delegate can register with another \r
-     * Client Delegate that can "act" as a server */\r
-    if (((rmInst->instType == Rm_instType_CLIENT) &&\r
-         (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)) || \r
-        ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
-         (transportCfg->remoteInstType == Rm_instType_SERVER)) &&\r
-        rmInst->registeredWithDelegateOrServer)\r
+    /* Verify Clients are not registering with more than one Client Delegate or Server. And\r
+     * that Client Delegate are not registering with more than one Server. */\r
+    if (rmInst->registeredWithDelegateOrServer &&\r
+        (((rmInst->instType == Rm_instType_CLIENT) &&\r
+          (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)) || \r
+         ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
+          (transportCfg->remoteInstType == Rm_instType_SERVER))))\r
     {\r
-        Rm_osalCsExit(key);\r
-        return (NULL); /* Error - return null */\r
+        goto exitCs; /* Error - return null */\r
     }         \r
 \r
     /* Copy the transport callout function pointers into the RM instance as long as they're\r
@@ -466,8 +454,7 @@ Rm_TransportHandle Rm_transportRegister (Rm_Handle rmHandle, Rm_TransportCfg *tr
             (transportCfg->transportCallouts.rmReceive == NULL) ||\r
             (transportCfg->transportCallouts.rmNumPktsReceived == NULL))\r
         {\r
-            Rm_osalCsExit(key);\r
-            return (NULL); /* Error - return null */\r
+            goto exitCs; /* Error - return null */\r
         }\r
             \r
         /* Populate the instance transport callouts */\r
@@ -489,7 +476,9 @@ Rm_TransportHandle Rm_transportRegister (Rm_Handle rmHandle, Rm_TransportCfg *tr
         rmInst->registeredWithDelegateOrServer = true;\r
     }\r
 \r
-    Rm_osalCsExit(key);\r
+exitCs:\r
+    \r
+    Rm_osalMtCsExit(key);\r
     return ((Rm_TransportHandle) transportNode);\r
 }\r
 \r
@@ -501,7 +490,7 @@ Rm_TransportResult Rm_transportUnregister (Rm_Handle rmHandle, Rm_TransportHandl
     void *key;\r
 \r
     /* Lock access to the RM instance */\r
-    key = Rm_osalCsEnter();    \r
+    key = Rm_osalMtCsEnter();    \r
 \r
     /* Check if the transportHandle exists in the RM instance's route map */\r
     transportNode = Rm_transportNodeFindTransportHandle(rmInst, transportHandle);\r
@@ -509,23 +498,24 @@ Rm_TransportResult Rm_transportUnregister (Rm_Handle rmHandle, Rm_TransportHandl
     if (transportNode == NULL)\r
     {\r
         /* Error - transport node does not exist in RM instance route map */\r
-        Rm_osalCsExit(key);\r
-        return (RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED);\r
+        retVal = RM_TRANSPORT_ERROR_HANDLE_HAS_NOT_BEEN_REGISTERED;\r
     }\r
-\r
-    /* Remove specification that RM instance has been connected to an upper level agent\r
-     * if the node to be deleted has a remote instance type of Client Delegate or Server */\r
-    if ((transportNode->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||\r
-        (transportNode->remoteInstType == Rm_instType_SERVER))\r
+    else\r
     {\r
-        rmInst->registeredWithDelegateOrServer = false;\r
-    }\r
 \r
-    /* Delete the transport node */\r
-    retVal = Rm_transportNodeDelete(rmInst, transportHandle);\r
+        /* Remove specification that RM instance has been connected to an upper level agent\r
+         * if the node to be deleted has a remote instance type of Client Delegate or Server */\r
+        if ((transportNode->remoteInstType == Rm_instType_CLIENT_DELEGATE) ||\r
+            (transportNode->remoteInstType == Rm_instType_SERVER))\r
+        {\r
+            rmInst->registeredWithDelegateOrServer = false;\r
+        }\r
 \r
-    Rm_osalCsExit(key);\r
+        /* Delete the transport node */\r
+        retVal = Rm_transportNodeDelete(rmInst, transportHandle);\r
+    }\r
 \r
+    Rm_osalMtCsExit(key);\r
     return (retVal);\r
 }\r
 \r
@@ -598,24 +588,31 @@ int32_t Rm_receivePktIsr(Rm_TransportHandle transportHandle, Rm_Packet *pkt)
             Rm_ResourceResponsePkt *resourceRespPkt = (Rm_ResourceResponsePkt *)pkt->data;\r
 \r
             /* Find the transaction that is awaiting the response */\r
-            transaction = Rm_transactionQueueFind(rmInst,resourceRespPkt->responseId);\r
-            /* Transfer the result of the request to the transaction */\r
-            transaction->state = resourceRespPkt->requestState;\r
-\r
-            if ((transaction->state == RM_SERVICE_APPROVED) &&\r
-                ((transaction->type == Rm_service_RESOURCE_ALLOCATE) ||\r
-                 (transaction->type == Rm_service_RESOURCE_BLOCK_ALLOCATE) ||\r
-                 (transaction->type == Rm_service_RESOURCE_ALLOCATE_BY_NAME)))\r
+            if (transaction = Rm_transactionQueueFind(rmInst,resourceRespPkt->responseId))\r
             {\r
-                /* Copy resources from request for allocations since an allocation\r
-                 * can be specified as unknown.  Meaning the RM instance will specify the\r
-                 * resource value obtained */\r
-                memcpy ((void *)&(transaction->resourceInfo), (void *)&(resourceRespPkt->resourceInfo),\r
-                        sizeof(Rm_ResourceInfo));\r
+                /* Transfer the result of the request to the transaction */\r
+                transaction->state = resourceRespPkt->requestState;\r
+\r
+                if ((transaction->state == RM_SERVICE_APPROVED) &&\r
+                    ((transaction->type == Rm_service_RESOURCE_ALLOCATE) ||\r
+                     (transaction->type == Rm_service_RESOURCE_BLOCK_ALLOCATE) ||\r
+                     (transaction->type == Rm_service_RESOURCE_ALLOCATE_BY_NAME)))\r
+                {\r
+                    /* Copy resources from request for allocations since an allocation\r
+                     * can be specified as unknown.  If the request resources were unspecified\r
+                     * the RM instance will specify the resources obtained */\r
+                    memcpy ((void *)&(transaction->resourceInfo), (void *)&(resourceRespPkt->resourceInfo),\r
+                            sizeof(Rm_ResourceInfo));\r
+                }\r
+                \r
+                /* Process the transaction */\r
+                Rm_transactionProcessor(rmInst, transaction);\r
+            }\r
+            else\r
+            {\r
+                rmInst->transport.rmFreePkt(transportHandle, pkt);\r
+                return (RM_TRANSPORT_ERROR_MATCHING_RESOURCE_REQUEST_NOT_FOUND);\r
             }\r
-            \r
-            /* Process the transaction */\r
-            Rm_transactionProcessor(rmInst, transaction);\r
             break;\r
         }\r
         case Rm_pktType_NAMESERVER_REQUEST:\r
@@ -648,12 +645,19 @@ int32_t Rm_receivePktIsr(Rm_TransportHandle transportHandle, Rm_Packet *pkt)
             Rm_NsResponsePkt *nsResponsePkt = (Rm_NsResponsePkt *)pkt->data;\r
 \r
             /* Find the transaction that is awaiting the response */\r
-            transaction = Rm_transactionQueueFind(rmInst, nsResponsePkt->responseId);\r
-            /* Transfer the state of the request to the transaction */\r
-            transaction->state = nsResponsePkt->requestState;            \r
+            if (transaction = Rm_transactionQueueFind(rmInst, nsResponsePkt->responseId))\r
+            {\r
+                /* Transfer the state of the request to the transaction */\r
+                transaction->state = nsResponsePkt->requestState;            \r
 \r
-            /* Process the transaction */\r
-            Rm_transactionProcessor(rmInst, transaction);\r
+                /* Process the transaction */\r
+                Rm_transactionProcessor(rmInst, transaction);\r
+            }\r
+            else\r
+            {\r
+                rmInst->transport.rmFreePkt(transportHandle, pkt);\r
+                return (RM_TRANSPORT_ERROR_MATCHING_NAME_SERVER_REQUEST_NOT_FOUND);\r
+            }\r
             break;\r
         }\r
         case Rm_pktType_POLICY_REQUEST:\r
index a67d0d441c5aa5a2def26034ef61357db092dc4a..e8c1856fd349a3cfe705ccd3f4636b292a74d332 100644 (file)
@@ -63,6 +63,8 @@
 uint32_t rmMallocCounter = 0;
 uint32_t rmFreeCounter   = 0;
 
+uint32_t rmMtSem = 0;
+
 /**********************************************************************
  *************************** OSAL Functions **************************
  **********************************************************************/
@@ -170,7 +172,14 @@ void* Osal_rmMtCsEnter (void)
     /* Create Semaphore for protection against access from multiple threads
      * Not created here becasue application is not multithreaded
      * */
-    return NULL;
+
+    /* Block while semaphore is taken */
+    while (rmMtSem){};
+    
+    /* Take the semaphore if it's available */
+    rmMtSem = 1;
+    
+    return ((void *)&rmMtSem);
 }
 
 /**
@@ -187,7 +196,10 @@ void* Osal_rmMtCsEnter (void)
  */
 void Osal_rmMtCsExit (void *CsHandle)
 {
+    uint32_t *mtSem = (uint32_t *)CsHandle;
+    
     /* Release Semaphore using handle */
+    *mtSem = 0;   
 
     return;
 }
index a57dbfc06f3344a6033382686fb746e5a285149a..ceb440db3115ef7f6be9c9c8f3dbdf34f665291f 100644 (file)
@@ -348,8 +348,8 @@ Void testRmTsk(UArg arg0, UArg arg1)
         /* TEMP: Try mapping a resource in Name Server */
         requestInfo.type = Rm_service_RESOURCE_MAP_TO_NAME;
         requestInfo.resourceName = &resourceName[0];
-        requestInfo.resourceBase = 0;
-        requestInfo.resourceRange = 1;
+        requestInfo.resourceBase = 1;
+        requestInfo.resourceRange = 2;
         requestInfo.resourceNsName = &resourceNsName[0];
         requestInfo.callback.serviceCallback = testServiceCallback;
         
index 13ad0bb15da92111fb1bdd712980bc77c83d6c5c..0af281fbf9a2cf185c061c87932596e135e0ae21 100644 (file)
@@ -36,7 +36,8 @@ var MultiProc = xdc.useModule('ti.sdo.utils.MultiProc');
  *  Get the list of names that the build device supports.
  *  I.e. ["CORE0", "CORE1", "CORE2" ... ]
  */
-var nameList = MultiProc.getDeviceProcNames();
+// var nameList = MultiProc.getDeviceProcNames();
+var nameList = ["CORE0", "CORE1"];
 
 /* 
  *  Since this is a single-image example, we don't (at build-time) which