Whitespace and code formatting cleanup
authorJustin Sobota <jsobota@ti.com>
Tue, 2 Jun 2015 22:07:33 +0000 (18:07 -0400)
committerJustin Sobota <jsobota@ti.com>
Tue, 2 Jun 2015 22:07:33 +0000 (18:07 -0400)
17 files changed:
include/rm_dtb_utilloc.h
include/rm_internal.h
include/rm_policyloc.h
include/rm_transportloc.h
include/rm_treeloc.h
rm.h
rm_osal.h
rm_services.h
rm_transport.h
rmver.h.xdt
src/rm.c
src/rm_allocator.c
src/rm_dtb_util.c
src/rm_nameserver.c
src/rm_policy.c
src/rm_services.c
src/rm_transport.c

index a4029c035c711ce6d5540bb30b9a8c2f2804178d..f9bfbabf46475f1373ab16ba1cfda20debe6855b 100644 (file)
@@ -4,7 +4,7 @@
  *  Private Resource List and Policy DTB Parsing Utilities
  *
  *  ============================================================================
- *      (C) Copyright 2012-2013, Texas Instruments, Inc.
+ *      (C) Copyright 2012-2015, Texas Instruments, Inc.
  * 
  *  Redistribution and use in source and binary forms, with or without 
  *  modification, are permitted provided that the following conditions 
@@ -178,12 +178,15 @@ typedef struct Rm_LinuxValueRange_s {
  **********************************************************************/
 
 Rm_ResourcePropType rmDtbUtilResGetPropertyType(const char *propertyName);
-Rm_ResourceRange *rmDtbUtilResExtractRange(const void *dtbDataPtr, int32_t dtbDataLen);
+Rm_ResourceRange *rmDtbUtilResExtractRange(const void *dtbDataPtr,
+                                           int32_t dtbDataLen);
 void rmDtbUtilResFreeRange(Rm_ResourceRange *rangeList);
-Rm_LinuxAlias *rmDtbUtilResExtractLinuxAlias(const void *dtbDataPtr, int32_t dtbDataLen,
+Rm_LinuxAlias *rmDtbUtilResExtractLinuxAlias(const void *dtbDataPtr,
+                                             int32_t dtbDataLen,
                                              int32_t *result);
 void rmDtbUtilResFreeLinuxAlias(Rm_LinuxAlias *aliasList);
-Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr, int32_t dtbDataLen, 
+Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr,
+                                                 int32_t dtbDataLen,
                                                  int32_t *result);
 void rmDtbUtilResFreeNsAssignmentList(Rm_NsAssignment *nsAssignmentList);
 
@@ -195,9 +198,11 @@ Rm_PolicyPropType rmDtbUtilPolicyGetPropertyType(const char *propertyName);
 Rm_PolicyAssignment *rmDtbUtilPolicyExtractAssignments(const void *dtbDataPtr,
                                                        int32_t dtbDataLen);
 void rmDtbUtilPolicyFreeAssignments(Rm_PolicyAssignment *assignmentList);
-Rm_ResourceValue *rmDtbUtilPolicyExtractCdAllocationSizes(const void *dtbDataPtr, int32_t dtbDataLen);
+Rm_ResourceValue *rmDtbUtilPolicyExtractCdAllocationSizes(const void *dtbDataPtr,
+                                                          int32_t dtbDataLen);
 void rmDtbUtilPolicyFreeCdAllocationSizes(Rm_ResourceValue *allocationSizeList);
-Rm_ResourceValue *rmDtbUtilPolicyExtractResourceAlignments(const void *dtbDataPtr, int32_t dtbDataLen);
+Rm_ResourceValue *rmDtbUtilPolicyExtractResourceAlignments(const void *dtbDataPtr,
+                                                           int32_t dtbDataLen);
 void rmDtbUtilPolicyFreeResourceAlignments (Rm_ResourceValue *alignmentList);
 Rm_PolicyValidInst *rmDtbUtilPolicyExtractValidInstances(const void *dtbDataPtr,
                                                          int32_t dtbDataLen,
@@ -208,7 +213,8 @@ void rmDtbUtilPolicyFreeValidInstances (Rm_PolicyValidInst *validInstList);
  ********************* Linux DTB Parsing Functions ********************
  **********************************************************************/
 
-Rm_LinuxValueRange *rmDtbUtilLinuxExtractValues(const void *dtbDataPtr, int32_t dtbDataLen);
+Rm_LinuxValueRange *rmDtbUtilLinuxExtractValues(const void *dtbDataPtr,
+                                                int32_t dtbDataLen);
 void rmDtbUtilLinuxFreeValues(Rm_LinuxValueRange *valueList);
 
 #ifdef __cplusplus
index 898ca3b817339f9833c6e076c09146645cd15955..952ab201ab5b042bc27169c1010e41bcb2f5322f 100644 (file)
@@ -4,7 +4,7 @@
  *  Data structures used by more than one internal RM module.
  *
  *  ============================================================================
- *      (C) Copyright 2012-2014, Texas Instruments, Inc.
+ *      (C) Copyright 2012-2015, Texas Instruments, Inc.
  * 
  *  Redistribution and use in source and binary forms, with or without 
  *  modification, are permitted provided that the following conditions 
@@ -81,7 +81,7 @@ extern "C" {
     if (rmInst->instType == Rm_instType_SHARED_SERVER) {      \
         Rm_osalEndMemAccess((void *)rmInst, sizeof(Rm_Inst)); \
         Rm_osalCsExit(csKey);                                 \
-    }  
+    }
 
 /* Shared server invalidate macro */
 #define RM_SS_OBJ_INV(rmInst, obj, objType)                  \
@@ -93,7 +93,7 @@ extern "C" {
 #define RM_SS_OBJ_WB(rmInst, obj, objType)                 \
     if (rmInst->instType == Rm_instType_SHARED_SERVER) {   \
         Rm_osalEndMemAccess((void *)obj, sizeof(objType)); \
-    }    
+    }
 
 /* RM resource information */
 typedef struct {
index 94893782ed8c25130ed7f4af8276abf94cf22175..9608515a4d042a652cff123249586cced52d6b48 100644 (file)
@@ -53,22 +53,25 @@ extern "C" {
 /* Index of global permission bits in policy tree node permission array */
 #define RM_POLICY_GLOBAL_PERM_INDEX        0
 
-/* String stored for resource elements that are reserved by the Linux kernel.  These
- * resources will be in use for the lifetime of the system 
+/* String stored for resource elements that are reserved by the Linux kernel.
+ * These resources will be in use for the lifetime of the system
  *
- * TODO: MOVE TO policy.h LATER SO INTEGRATORS KNOW NOT TO NAME RM INSTANCES THIS NAME */
+ * TODO: MOVE TO policy.h LATER SO INTEGRATORS KNOW NOT TO NAME RM INSTANCES
+ * THIS NAME */
 #define RM_ALLOCATED_TO_LINUX "Linux-Kernel"
 
-/* Policy permission bit storage type
+/* Policy permission bit storage definition for Rm_PolicyPermBits
  * Bit : Description
  *-----------------------------
- *  0  : Init         (i) - RM instance has initialization permission for resource
+ *  0  : Init         (i) - RM instance has initialization permission for
+ *                          resource
  *  1  : Use          (u) - RM instance has usage permission for resource
- *  2  : Exclusive    (x) - RM instance has exclusive allocation privilege for resource
- *                          i.e. No other RM instance can reserve the resource if a RM
- *                          instance with exclusive privilege reserves the resource
- *  3  : Shared Linux (s) - Resource has been reserved by the Linux kernel but can be
- *                          allocated by the specified RM instances
+ *  2  : Exclusive    (x) - RM instance has exclusive allocation privilege for
+ *                          resource i.e. No other RM instance can reserve the
+ *                          resource if a RM instance with exclusive privilege
+ *                          reserves the resource
+ *  3  : Shared Linux (s) - Resource has been reserved by the Linux kernel but
+ *                          can be allocated by the specified RM instances
  *  4 - 31 : UNUSED
  */
 
@@ -106,20 +109,25 @@ extern "C" {
 /* Permissions assignment character */
 #define RM_POLICY_PERM_ASSIGNMENT         '='
 
-/* Policy bit mask */
+/* Full permissions bit mask */
 #define RM_policy_PERM_FULL_MASK          ((1 << RM_POLICY_PERM_MAX_BITS) - 1)
 
+/* Calculates number of instance permission sets per permission word */
 #define RM_policy_PERM_INST_PER_WORD \
     ((sizeof(Rm_PolicyPermBits) * 8) / RM_POLICY_PERM_MAX_BITS)
+/* Calculates the instance's word index into the permission word array */
 #define RM_policy_PERM_INDEX(instIdx) \
     (instIdx / RM_policy_PERM_INST_PER_WORD)
+/* Calculates the instance's bit offset into the permission word */
 #define RM_policy_PERM_OFFSET(instIdx)          \
     ((instIdx % RM_policy_PERM_INST_PER_WORD) * \
      RM_POLICY_PERM_MAX_BITS)
 
+/* Sets a permission for an instance */
 #define RM_policy_PERM_SET(permArray, wordIdx, wordOffset, permOffset, val) \
     permArray[wordIdx] &= ~(0x1 << (wordOffset + permOffset));              \
     permArray[wordIdx] |= (val & 0x1) << (wordOffset + permOffset);
+/* Gets a permission for an instance */
 #define RM_policy_PERM_GET(permArray, wordIdx, wordOffset, permOffset)  \
     ((permArray[wordIdx] >> (wordOffset + permOffset)) & 0x1)
 
index 74e064daa0e63b69dc1b858d98ef17c1a4d4c582..828dae19a7101557cbdad266d3231d93595c9325 100644 (file)
@@ -4,7 +4,7 @@
  *  Private data structures of Resource Manager transport layer.
  *
  *  ============================================================================
- *      (C) Copyright 2012-2013, Texas Instruments, Inc.
+ *      (C) Copyright 2012-2015, Texas Instruments, Inc.
  * 
  *  Redistribution and use in source and binary forms, with or without 
  *  modification, are permitted provided that the following conditions 
@@ -51,7 +51,7 @@ extern "C" {
 /* RM internal includes */
 #include <ti/drv/rm/include/rm_internal.h>
 
-/* This macro generates compilier error if postulate is false, so 
+/* This macro generates compilier error if postulate is false, so
  * allows 0 overhead compile time size check.  This "works" when
  * the expression contains sizeof() which otherwise doesn't work
  * with preprocessor */
@@ -63,12 +63,17 @@ extern "C" {
    }                                                                    \
    while (0)
 
-/* Check assumptions RM request/response packets fit in RM_TRANSPORT_PACKET_MAX_SIZE_BYTES */
+/* Check assumptions RM request/response packets fit in
+ * RM_TRANSPORT_PACKET_MAX_SIZE_BYTES */
 #define RM_PACKET_SIZE_CHECK \
-    RM_COMPILE_TIME_SIZE_CHECK(RM_TRANSPORT_PACKET_MAX_SIZE_BYTES >= sizeof(Rm_ResourceRequestPkt)); \
-    RM_COMPILE_TIME_SIZE_CHECK(RM_TRANSPORT_PACKET_MAX_SIZE_BYTES >= sizeof(Rm_ResourceResponsePkt)); \
-    RM_COMPILE_TIME_SIZE_CHECK(RM_TRANSPORT_PACKET_MAX_SIZE_BYTES >= sizeof(Rm_NsRequestPkt)); \
-    RM_COMPILE_TIME_SIZE_CHECK(RM_TRANSPORT_PACKET_MAX_SIZE_BYTES >= sizeof(Rm_NsResponsePkt)); \
+    RM_COMPILE_TIME_SIZE_CHECK(RM_TRANSPORT_PACKET_MAX_SIZE_BYTES >= \
+                               sizeof(Rm_ResourceRequestPkt));       \
+    RM_COMPILE_TIME_SIZE_CHECK(RM_TRANSPORT_PACKET_MAX_SIZE_BYTES >= \
+                               sizeof(Rm_ResourceResponsePkt));      \
+    RM_COMPILE_TIME_SIZE_CHECK(RM_TRANSPORT_PACKET_MAX_SIZE_BYTES >= \
+                               sizeof(Rm_NsRequestPkt));             \
+    RM_COMPILE_TIME_SIZE_CHECK(RM_TRANSPORT_PACKET_MAX_SIZE_BYTES >= \
+                               sizeof(Rm_NsResponsePkt));            \
 
 /* RM transport list node */
 typedef struct Rm_Transport_s {
@@ -104,30 +109,30 @@ typedef enum {
 } Rm_ResourceReqPktType;
 
 /* Resource Request Packet - Packet sent to CDs and Servers to request
- * a resource service that cannot be handled on the local RM instance due to 
+ * a resource service that cannot be handled on the local RM instance due to
  * permission restrictions. */
 typedef struct {
     /* Transaction ID associated with the request packet */
     uint32_t              requestId;  
     /* Resource request type */
     Rm_ResourceReqPktType resourceReqType;
-    /* RM instance name from which the request packet originated.  Used by 
+    /* RM instance name from which the request packet originated.  Used by
      * receiving instance to route the response */
-    char                  pktSrcInstName[RM_NAME_MAX_CHARS];    
-    /* Name of RM instance that is issuing the service request. The instance 
+    char                  pktSrcInstName[RM_NAME_MAX_CHARS];
+    /* Name of RM instance that is issuing the service request. The instance
      * name will be used to validate the request against the RM policy defined
      * for the instance. */
-    char                  serviceSrcInstName[RM_NAME_MAX_CHARS];      
+    char                  serviceSrcInstName[RM_NAME_MAX_CHARS];
     /* Resource request information */
     Rm_ResourceInfo       resourceInfo;
 } Rm_ResourceRequestPkt;
 
 /* Resource Response Packet - Packet sent to RM instances that requested
- * a resource service.  The packet will contain resource response 
+ * a resource service.  The packet will contain resource response
  * information based on the request */
 typedef struct {
     /* responseID will equal the requestId received in the resource request
-     * packet.  This ID should be associated with a transaction stored in 
+     * packet.  This ID should be associated with a transaction stored in
      * the RM instance that sent the resource request packet */
     uint32_t        responseId;
     /* State of the request.  Resource request denied, or error.  The
@@ -149,10 +154,10 @@ typedef enum {
  * NameServer mapping or unmapping data */
 typedef struct {
     /* Transaction ID associated with the NameServer request packet */
-    uint32_t        requestId;  
+    uint32_t        requestId;
     /* NameServer request type */
     Rm_NsReqPktType nsRequestType;
-    /* RM instance name from which the request packet originated.  Used by 
+    /* RM instance name from which the request packet originated.  Used by
      * receiving instance to route the response */
     char            pktSrcInstName[RM_NAME_MAX_CHARS];
     /* RM instance name making the service request.  Policies may restrict who
@@ -174,7 +179,8 @@ typedef struct {
     int32_t  requestState;
 } Rm_NsResponsePkt;
 
-Rm_Transport *rmTransportFindRemoteInstType(Rm_Transport *transports, Rm_InstType remoteInstType);
+Rm_Transport *rmTransportFindRemoteInstType(Rm_Transport *transports,
+                                            Rm_InstType remoteInstType);
 
 #ifdef __cplusplus
 }
index dc2f8c8930319ec31e87b3e2d9569dd9fdfccb46..e31250a123cf5151a890cab1e83ff89b18746b9d 100644 (file)
@@ -143,17 +143,7 @@ typedef struct _Rm_ResourceNode {
 typedef RB_HEAD(_Rm_AllocatorResourceTree, _Rm_ResourceNode) Rm_ResourceTree;
 
 /* Policy permission bit storage type
- * Bit : Description
- *-----------------------------
- *  0  : Init         (i) - RM instance has initialization permission for resource
- *  1  : Use          (u) - RM instance has usage permission for resource
- *  2  : Exclusive    (x) - RM instance has exclusive allocation privilege for resource
- *                          i.e. No other RM instance can reserve the resource if a RM
- *                          instance with exclusive privilege reserves the resource
- *  3  : Shared Linux (s) - Resource has been reserved by the Linux kernel but can be
- *                          allocated by the specified RM instances
- *  4 - 31 : UNUSED
- */
+ * See rm_policyloc.h for bit by bit usage of this type */
 typedef uint32_t Rm_PolicyPermBits;
 
 /* Policy node */
diff --git a/rm.h b/rm.h
index 8282e18690ddc8610e791d134c088b38c6fc99ba..55d3ef0b9112ef81ec3f7e646a2b2ccb31868a04 100644 (file)
--- a/rm.h
+++ b/rm.h
@@ -53,104 +53,115 @@ extern "C" {
  *
  *   @section intro  Introduction
  *
- *   The Resource Manager (RM) is designed to provide an easy to use, extensible
- *   uinified resource management solution on TI devices.  RM can be integrated by 
- *   a system application to provide resource management services to the system 
- *   temporally (pre-main/post-main) and spatially (system subcomponents, task,
- *   cores).
+ *   The Resource Manager (RM) is designed to provide an easy to use,
+ *   extensible uinified resource management solution on TI devices.  RM can be
+ *   integrated by a system application to provide resource management services
+ *   to the system temporally (pre-main/post-main) and spatially (system
+ *   subcomponents, task, cores).
  *
- *   The RM architecture is instance based.  All RM resource management services 
- *   must originate from a RM instance.  Resource permissions are assigned by a 
- *   system integrator using RM instance names provided during the initialization
- *   of each RM instance in use.  There are three types of RM instances, all of
- *   which can be used by the system to request resource management services:
+ *   The RM architecture is instance based.  All RM resource management
+ *   services must originate from a RM instance.  Resource permissions are
+ *   assigned by a system integrator using RM instance names provided during the
+ *   initialization of each RM instance in use.  There are three types of RM
+ *   instances, all of which can be used by the system to request resource
+ *   management services:
  *    - Server - Manages all resource data structures including the resource
  *               allocators, the permissions policies, and a simple NameServer.
  *               There can only be one Server per RM ecosystem.  If two Servers
  *               are initialized within a system they must manage mutually
- *               exclusive sets of device resources.  There is no limit to the 
+ *               exclusive sets of device resources.  There is no limit to the
  *               number of Client and Client Delegate instances that can connect
  *               to the Server
- *    - Client - Used by system components to request resource services.  There is
- *               no limit to the number of Clients a system can have.  Client
- *               names must be unique since resource permissions are assigned based
- *               on RM instance names.  Clients can connect to at most one Server
- *               or Client Delegate, but not both at the same time.
+ *    - Client - Used by system components to request resource services.  There
+ *               is no limit to the number of Clients a system can have.  Client
+ *               names must be unique since resource permissions are assigned
+ *               based on RM instance names.  Clients can connect to at most
+ *               one Server or Client Delegate, but not both at the same time.
  *    - Client Delegate (CD) - At the moment the CD is not different from the
- *                             Client.  However, in the future the CD will be able
- *                             to act as a proxy for the Server.  The CD will be
- *                             able to satisfy some service requests from Clients,
- *                             offloading some processing from the Server.  This 
- *                             feature will be helpful in situations where a
- *                             slower data path exists between the Server and
- *                             CD/Client instances.  There is no limit to the number
- *                             of Clients that can connect to a CD.  The CD can
- *                             connect to at most one Server.
+ *                             Client.  However, in the future the CD will be
+ *                             able to act as a proxy for the Server.  The CD
+ *                             will be able to satisfy some service requests
+ *                             from Clients, offloading some processing from
+ *                             the Server.  This feature will be helpful in
+ *                             situations where a slower data path exists
+ *                             between the Server and CD/Client instances.
+ *                             There is no limit to the number of Clients that
+ *                             can connect to a CD.  The CD can connect to at
+ *                             most one Server.
  *
- *   RM instances communicate via a generic transport interface.  The RM transport
- *   interface expects the application to configure and manage the transport data paths
- *   between RM instances.  This allows RM to easily extend to different device 
- *   configurations and different devices entirely.
+ *   RM instances communicate via a generic transport interface.  The RM
+ *   transport interface expects the application to configure and manage the
+ *   transport data paths between RM instances.  This allows RM to easily
+ *   extend to different device configurations and different devices entirely.
  *
- *   Shared memory versions of the Server and Client are available for configuration
- *   in cases where the DSP applications cannot tolerate blocking operations or long wait
- *   times for resources.  The Shared Server - Shared Client model assumes all memory
- *   allocated via the OSAL layer is within shared memory.  RM service requests
- *   received from Shared Servers and Shared Clients will be handled via accesses
- *   to the resource management data structures existing in shared memory.
- *   - Shared Server - Essentially a Server instance that expects to be allocated
- *                     from shared memory via the application-supplied OSAL functions.
- *                     Shared Client instances will piggyback on the Shared Server
- *                     instance to allocate/free resources without the need to setup
- *                     transports between the instances.  Access to the resource
- *                     management data structures is managed through OSAL implemented
- *                     cache writeback and invalidate operations.
- *   - Shared Client - Must be provided a Shared Server handle at initialization time.
- *                     The Shared Client will essentially use the resource management
- *                     data structures, created in shared memory when the Shared Server
- *                     was initialized, to handle any server requests.
- *   RM utilizes the BDS-licensed, open source, Flattened Device Tree format to 
- *   specify what resources are managed by RM as well as the RM instance permissions
- *   for managed resources.  The Global Resource List or GRL defines all device 
- *   resources and their ranges that will be tracked by the RM Server.  Addition or 
- *   subtraction of resources from RM requires one modify only the GRL.  RM source code
- *   changes are not required to add or subtract resources from RM's umbrella of 
- *   management.  RM Policies specify resource permissions for the RM instances.  There
- *   are two types of Policies:
- *    - Global Policy - Provided to the Server at initialization and defines the 
- *                      resource permissions for all RM instances in the system.
- *                      All service requests will be validated against the Global
- *                      Policy on the Server.  If the RM instance is found to not
- *                      hold the privileges for the request a denial of the service
- *                      will be issued back to the requesting instance.
+ *   Shared memory versions of the Server and Client are available for
+ *   configuration in cases where the DSP applications cannot tolerate blocking
+ *   operations or long wait times for resources.  The Shared Server - Shared
+ *   Client model assumes all memory allocated via the OSAL layer is within
+ *   shared memory.  RM service requests received from Shared Servers and
+ *   Shared Clients will be handled via accesses to the resource management
+ *   data structures existing in shared memory.
+ *   - Shared Server - Essentially a Server instance that expects to be
+ *                     allocated from shared memory via the application-supplied
+ *                     OSAL functions.  Shared Client instances will piggyback
+ *                     on the Shared Server instance to allocate/free resources
+ *                     without the need to setup transports between the
+ *                     instances.  Access to the resource management data
+ *                     structures is managed through OSAL implemented cache
+ *                     writeback and invalidate operations.
+ *   - Shared Client - Must be provided a Shared Server handle at initialization
+ *                     time.  The Shared Client will essentially use the
+ *                     resource management data structures, created in shared
+ *                     memory when the Shared Server was initialized, to handle
+ *                     any server requests.
+ *
+ *   RM utilizes the BDS-licensed, open source, Flattened Device Tree format to
+ *   specify what resources are managed by RM as well as the RM instance
+ *   permissions for managed resources.  The Global Resource List or GRL defines
+ *   all device resources and their ranges that will be tracked by the
+ *   RM Server.  Addition or subtraction of resources from RM requires one
+ *   modify only the GRL.  RM source code changes are not required to add or
+ *   subtract resources from RM's umbrella of management.  RM Policies specify
+ *   resource permissions for the RM instances.  There are two types of
+ *   Policies:
+ *    - Global Policy - Provided to the Server at initialization and defines
+ *                      the resource permissions for all RM instances in the
+ *                      system.  All service requests will be validated against
+ *                      the Global Policy on the Server.  If the RM instance is
+ *                      found to not hold the privileges for the request a
+ *                      denial of the service will be issued back to the
+ *                      requesting instance.
  *    - Static Policy - Optionally provided to Client and CD instances at
- *                      initialization.  Allows these instances to statically 
+ *                      initialization.  Allows these instances to statically
  *                      allocate resources.  This feature is typically used
  *                      for RM instances that must allocate resources prior
- *                      to the transport connection to the Server being established.
- *                      Resources allocated via any Static Policies will
- *                      be validated against the Global Policy once the transport 
+ *                      to the transport connection to the Server being
+ *                      established.  Resources allocated via any Static
+ *                      Policies will be validated against the Global Policy
+ *                      once the transport 
  *                      to the Server has been fully established.  If a Static
- *                      Policy request fails validation with the Global Policy the
- *                      RM instance that issued the static request will be placed
- *                      into a locked state.  The locked state prevents any further
- *                      service requests from the instance.
+ *                      Policy request fails validation with the Global Policy
+ *                      the RM instance that issued the static request will be
+ *                      placed into a locked state.  The locked state prevents
+ *                      any further service requests from the instance.
  *
- *   Combined, the GRL and Policy Device Tree implementations allow RM to easily extend 
- *   to new resources without the need to recompile the RM source code.
+ *   Combined, the GRL and Policy Device Tree implementations allow RM to easily
+ *   extend to new resources without the need to recompile the RM source code.
  *
  *   RM instances currently provides the following resource services:
  *    - Allocate (initialize) - Allocate a resource for initialization
  *    - Allocate (usage)      - Allocate a resource for use
- *    - Status                - Return the reference count for a specified resource
- *    - Free                  - Free an allocated resource (The free must originate
- *                              from the RM instance that allocated the resource
+ *    - Status                - Return the reference count for a specified
+ *                              resource
+ *    - Free                  - Free an allocated resource (The free must
+ *                              originate from the RM instance that allocated
+ *                              the resource
  *    - Map resource to name  - Map a specified resource to a NameServer name
  *    - Unmap named resource  - Unmap a resource from an existing NameServer name
- *    - Get resource by name  - Returns a resource based on a provided NameServer name
+ *    - Get resource by name  - Returns a resource based on a provided NameServer
+ *                              name
  */
+
 /* Define RM_API as a master group in Doxygen format and add all RM API 
    definitions to this group. */
 /** @defgroup RM_API Resource Manager API
@@ -185,8 +196,8 @@ extern "C" {
 #define RM_SERVICE_PENDING_SERVER_RESPONSE         2
 /** RM has approved requested service */
 #define RM_SERVICE_APPROVED                        3
-/** RM has approved requested service based on static policy.  Request will be validated 
- *  against global policy once all transports have been registered */
+/** RM has approved requested service based on static policy.  Request will be
+ *  validated against global policy once all transports have been registered */
 #define RM_SERVICE_APPROVED_STATIC                 4
 
 /** RM service request denial reasons base */
@@ -199,13 +210,14 @@ extern "C" {
 #define RM_SERVICE_DENIED_RES_NOT_ALLOCD_TO_INST   RM_SERVICE_DENIED_BASE+3
 /** Free request resource range already free */
 #define RM_SERVICE_DENIED_RES_ALREADY_FREE         RM_SERVICE_DENIED_BASE+4
-/** Allocate request resource range partially allocated (Handling of partial allocations
- *  not yet implemented) */
+/** Allocate request resource range partially allocated (Handling of partial
+ *  allocations not yet implemented) */
 #define RM_SERVICE_DENIED_PARTIAL_ALLOCATION       RM_SERVICE_DENIED_BASE+5
-/** Free request resource range partially free (Handling of partial frees not yet implemented) */
+/** Free request resource range partially free (Handling of partial frees not
+ *  yet implemented) */
 #define RM_SERVICE_DENIED_PARTIAL_FREE             RM_SERVICE_DENIED_BASE+6
-/** Requirements of allocate request could not be satisfied (occurs for UNSPECIFIED base 
- *  and/or alignment requests */
+/** Requirements of allocate request could not be satisfied (occurs for
+ *  UNSPECIFIED base and/or alignment requests */
 #define RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET   RM_SERVICE_DENIED_BASE+7
 /** NameServer add request name string already exists in NameServer */
 #define RM_SERVICE_DENIED_NAME_EXISTS_IN_NS        RM_SERVICE_DENIED_BASE+8
@@ -215,27 +227,30 @@ extern "C" {
 #define RM_SERVICE_DENIED_INIT_PERM_NOT_GIVEN      RM_SERVICE_DENIED_BASE+10
 /** Use allocate request resource range not given use privileges in policy */
 #define RM_SERVICE_DENIED_USE_PERM_NOT_GIVEN       RM_SERVICE_DENIED_BASE+11
-/** Allocate request resource range marked as exclusive in policy has already been allocated */
+/** Allocate request resource range marked as exclusive in policy has already
+ *  been allocated */
 #define RM_SERVICE_DENIED_EXCLUSIVE_RES_ALLOCD     RM_SERVICE_DENIED_BASE+12
-/** Allocate request resource range allocated to an instance assigned exclusive privileges in policy */
+/** Allocate request resource range allocated to an instance assigned exclusive
+ *  privileges in policy */
 #define RM_SERVICE_DENIED_ALLOCD_TO_EXCLUSIVE_INST RM_SERVICE_DENIED_BASE+13
 /** Static allocate request was not an allocate-use or allocate-init request */
 #define RM_SERVICE_DENIED_INVALID_STATIC_REQUEST   RM_SERVICE_DENIED_BASE+14
 /** Static allocate request denied by static policy */
 #define RM_SERVICE_DENIED_BY_STATIC_POLICY         RM_SERVICE_DENIED_BASE+15
-/** RM instance locked from further services since a static allocation failed validation against 
- *  global policy.  RM instance cannot be unlocked.  Please make sure static policy and global policy 
- *  are in sync */
+/** RM instance locked from further services since a static allocation failed
+ *  validation against global policy.  RM instance cannot be unlocked.  Please
+ *  make sure static policy and global policy are in sync */
 #define RM_SERVICE_DENIED_RM_INSTANCE_LOCKED       RM_SERVICE_DENIED_BASE+16
-/** Allocate request denied because the resource is already reserved by Linux and "Shared Linux"
- *  privileges are not assigned to the requesting instance */
+/** Allocate request denied because the resource is already reserved by Linux
+ *  and "Shared Linux" privileges are not assigned to the requesting instance */
 #define RM_SERVICE_DENIED_RES_NOT_SHARED_LINUX     RM_SERVICE_DENIED_BASE+17
-/** Status request resource range partially found (Handling of partial status requests not yet implemented) */
+/** Status request resource range partially found (Handling of partial status
+ *  requests not yet implemented) */
 #define RM_SERVICE_DENIED_PARTIAL_STATUS           RM_SERVICE_DENIED_BASE+18
 
-/** RM Client Delegate instance is not stable.  RM system operation cannot be guarateed
- *  if a CD instance is used.  At the time please manage resources using Server and Client
- *  instances - tracked by SDOCM00100797 */
+/** RM Client Delegate instance is not stable.  RM system operation cannot be
+ *  guarateed if a CD instance is used.  At the time please manage resources
+ *  using Server and Client instances - tracked by SDOCM00100797 */
 #define RM_WARNING_CD_INSTANCE_NOT_STABLE          (-1024)
 
 /** Start of libfdt.h error codes */
@@ -249,8 +264,8 @@ extern "C" {
 #define RM_ERROR_INVALID_INST_NAME                 RM_ERROR_BASE-1
 /** List of "valid-instances" not found in global or static policy */
 #define RM_ERROR_NO_VALID_INST_IN_POLICY           RM_ERROR_BASE-2
-/** Instance specified in permissions string does not match any instances specified in the
- *  "valid-instances" list */
+/** Instance specified in permissions string does not match any instances
+ *  specified in the "valid-instances" list */
 #define RM_ERROR_PERM_STR_INST_NOT_VALID           RM_ERROR_BASE-3
 /** Resource specified in global policy does not have an allocator */
 #define RM_ERROR_UNKNOWN_RESOURCE_IN_POLICY        RM_ERROR_BASE-4
@@ -262,20 +277,22 @@ extern "C" {
 #define RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS    RM_ERROR_BASE-6
 /** Permissions string contains invalid character */
 #define RM_ERROR_PERM_STR_INVALID_CHAR             RM_ERROR_BASE-7
-/** Permissions string contains a permission character without the assignment operator
- *  Ex: assignments = <12 1>, "iux (RM_Client_Delegate)"; */
+/** Permissions string contains a permission character without the assignment
+ *  operator Ex: assignments = <12 1>, "iux (RM_Client_Delegate)"; */
 #define RM_ERROR_PERM_CHAR_WITHOUT_ASSIGN_CHAR     RM_ERROR_BASE-8
-/** Permissions string contains a permission character on opposite side of already made assignment
+/** Permissions string contains a permission character on opposite side of
+ *  already made assignment
  *  Ex: assignments = <12 1>, "iux = (RM_Client_Delegate) x"; */
 #define RM_ERROR_INVALID_PERMS_CHAR_ON_RIGHT       RM_ERROR_BASE-9
 /** Policy resource node contains an unknown property */
 #define RM_ERROR_UNKNOWN_POLICY_RESOURCE_PROPERTY  RM_ERROR_BASE-10
-/** Instance name provided in "valid-instances" list is greater than RM_NAME_MAX_CHARS */
+/** Instance name provided in "valid-instances" list is greater than
+ *  RM_NAME_MAX_CHARS */
 #define RM_ERROR_VALID_INST_NAME_TOO_LONG          RM_ERROR_BASE-11
 /** Instance name in permissions assignment is greater than RM_NAME_MAX_CHARS */
 #define RM_ERROR_INST_NAME_IN_ASSIGNMENT_TOO_LONG  RM_ERROR_BASE-12
-/** NameServer name in global resource list nameServer assignment and/or service request
- *  is greater than RM_NAME_MAX_CHARS */
+/** NameServer name in global resource list nameServer assignment and/or
+ *  service request is greater than RM_NAME_MAX_CHARS */
 #define RM_ERROR_NAMESERVER_NAME_TOO_LONG          RM_ERROR_BASE-13
 /** Linux alias assignment in global resource list is invalid */
 #define RM_ERROR_GRL_INVALID_LINUX_ALIAS_FORMAT    RM_ERROR_BASE-14
@@ -293,25 +310,29 @@ extern "C" {
 #define RM_ERROR_RES_SPECIFIED_MORE_THAN_ONCE      RM_ERROR_BASE-19
 /** No data was found at the GRL resource node's specified Linux alias path */
 #define RM_ERROR_DATA_NOT_FOUND_AT_LINUX_ALIAS     RM_ERROR_BASE-20
-/** RM server was not provided a Global Resource List (GRL) and global policy at initialization */
+/** RM server was not provided a Global Resource List (GRL) and global policy
+ *  at initialization */
 #define RM_ERROR_INVALID_SERVER_CONFIGURATION      RM_ERROR_BASE-21
 /** Service request type not recognized */
 #define RM_ERROR_INVALID_SERVICE_TYPE              RM_ERROR_BASE-22
 /** rmAllocPkt transport callout returned NULL for rmPkt */
 #define RM_ERROR_TRANSPORT_ALLOC_PKT_ERROR         RM_ERROR_BASE-23
-/** rmSendPkt transport callout returned error when attempting to send the rmPkt */
+/** rmSendPkt transport callout returned error when attempting to send the
+ *  rmPkt */
 #define RM_ERROR_TRANSPORT_SEND_ERROR              RM_ERROR_BASE-24
 /** A RM service transaction could not be created for the service request */
 #define RM_ERROR_SERVICE_TRANS_NOT_CREATED         RM_ERROR_BASE-25
 /** RM service transaction could not be found in instance's transaction queue */
 #define RM_ERROR_SERVICE_TRANS_DOES_NOT_EXIST      RM_ERROR_BASE-26
-/** NameServer does not exist in instance, cannot satisfy NameServer service request */
+/** NameServer does not exist in instance, cannot satisfy NameServer service
+ *  request */
 #define RM_ERROR_NAMESERVER_DOES_NOT_EXIST         RM_ERROR_BASE-27
 /** Service request to add a name to the NameServer failed */
 #define RM_ERROR_NAMESERVER_NAME_ADD_FAILED        RM_ERROR_BASE-28
 /** Could not find name specified in service request in NameServer */
 #define RM_ERROR_NAMESERVER_NAME_DOES_NOT_EXIST    RM_ERROR_BASE-29
-/** Service request made on Client or CD when no transport established and no static policy registered */
+/** Service request made on Client or CD when no transport established and no
+ *  static policy registered */
 #define RM_ERROR_REQ_FAILED_NO_STATIC_POLICY       RM_ERROR_BASE-30
 /** RM transport handle has not been registered with the RM instance */
 #define RM_ERROR_TRANSPORT_HANDLE_DOES_NOT_EXIST   RM_ERROR_BASE-31
@@ -319,60 +340,64 @@ extern "C" {
 #define RM_ERROR_RECEIVED_INVALID_PACKET_TYPE      RM_ERROR_BASE-32
 /** RM response packet does not match any requests sent from instance */
 #define RM_ERROR_PKT_RESP_DOES_NOT_MATCH_ANY_REQ   RM_ERROR_BASE-33
-/** Server attempted to connect to another server or a CD attempted to connect to another CD or
- *  Client attempted to connect to another client */
+/** Server attempted to connect to another server or a CD attempted to connect
+ *  to another CD or Client attempted to connect to another client */
 #define RM_ERROR_INVALID_REMOTE_INST_TYPE          RM_ERROR_BASE-34
-/** RM client attempted to register with more than one Server or CD or a CD attempted to register 
- *  with more than one Server */
+/** RM client attempted to register with more than one Server or CD or a CD
+ *  attempted to register with more than one Server */
 #define RM_ERROR_ALREADY_REGD_SERVER_OR_CD         RM_ERROR_BASE-35
 /** Instance type not recognized */
 #define RM_ERROR_INVALID_INST_TYPE                 RM_ERROR_BASE-36
-/** RM attempted to allocate a transport packet but the rmAllocPkt callout was not registered */
+/** RM attempted to allocate a transport packet but the rmAllocPkt callout was
+ *  not registered */
 #define RM_ERROR_TRANSPORT_ALLOC_PKT_NOT_REGD      RM_ERROR_BASE-37
-/** RM attempted to send a packet but the rmSendPkt callout was not registered */
+/** RM attempted to send a packet but the rmSendPkt callout was not
+ *  registered */
 #define RM_ERROR_TRANSPORT_SEND_NOT_REGD           RM_ERROR_BASE-38
 /** RM instance cannot be deleted with transports still registered */
 #define RM_ERROR_CANT_DELETE_WITH_REGD_TRANSPORT   RM_ERROR_BASE-39
 /** RM instance cannot be deleted with open service handle */
 #define RM_ERROR_CANT_DELETE_WITH_OPEN_SERV_HNDL   RM_ERROR_BASE-40
-/** RM instance cannot be deleted when there are transactions pending and the 
+/** RM instance cannot be deleted when there are transactions pending and the
  *  ignorePendingServices parameter is set to false */
 #define RM_ERROR_CANT_DELETE_PENDING_TRANSACTIONS  RM_ERROR_BASE-41
 /** Only the Server instance can be used to return resource status via the
  *  Rm_resourceStatus API */
 #define RM_ERROR_INVALID_RES_STATUS_INSTANCE       RM_ERROR_BASE-42
-/** RM Shared Server and Client instances should always return a finished request since 
- *  the instance has access to the resource structures no matter what core the service
- *  is requested from */
+/** RM Shared Server and Client instances should always return a finished
+ *  request since the instance has access to the resource structures no matter
+ *  what core the service is requested from */
 #define RM_ERROR_SHARED_INSTANCE_UNFINISHED_REQ    RM_ERROR_BASE-43
 /** RM Shared Server and Client instances cannot register transports */
 #define RM_ERROR_SHARED_INSTANCE_CANNOT_REG_TRANS  RM_ERROR_BASE-44
-/** RM Shared Client handle was provided an invalid Shared Server handle.  The shared
- *  server handle was either NULL or was not an instance of type Rm_instType_SHARED_SERVER */
+/** RM Shared Client handle was provided an invalid Shared Server handle.
+ *  The shared server handle was either NULL or was not an instance of type
+ *  Rm_instType_SHARED_SERVER */
 #define RM_ERROR_INVALID_SHARED_SERVER_HANDLE      RM_ERROR_BASE-45
-/** A RM Client failed to create a new transaction to request data from the Server in order
- *  to potentially process a transaction on a Client Delegate */
+/** A RM Client failed to create a new transaction to request data from the
+ *  Server in order to potentially process a transaction on a Client Delegate */
 #define RM_ERROR_TRANS_REQ_TO_SERVER_NOT_CREATED   RM_ERROR_BASE-46
-/** Service request required a policy check but instance was not initialized with a policy */
+/** Service request required a policy check but instance was not initialized
+ *  with a policy */
 #define RM_ERROR_INSTANCE_HAS_NO_POLICY            RM_ERROR_BASE-47
 /** RM Client Delegate was not provided a policy at initialization */
 #define RM_ERROR_INVALID_CD_CONFIGURATION          RM_ERROR_BASE-48
-/** RM CD freed local resources which allowed a free request of local request to be sent to
- *  the Server.  The Server free failed so the CD tried to realloc the local resources 
- *  that were originally freed.  The re-allocate operation failed causing a resource loss
- *  on the CD */
+/** RM CD freed local resources which allowed a free request of local request
+ *  to be sent to the Server.  The Server free failed so the CD tried to
+ *  realloc the local resources that were originally freed.  The re-allocate
+ *  operation failed causing a resource loss on the CD */
 #define RM_ERROR_LOST_RESOURCES_ON_CD              RM_ERROR_BASE-49
-/** The service source inst name and RM packet source instance names are not available
- *  for the given type of RM packet */
+/** The service source inst name and RM packet source instance names are not
+ *  available for the given type of RM packet */
 #define RM_ERROR_PKT_AND_SERVICE_SRC_NOT_AVAIL     RM_ERROR_BASE-50
-/** The provided character buffer that will contain the service source inst name or pkt
- *  source inst name is not of size RM_NAME_MAX_CHARS */
+/** The provided character buffer that will contain the service source inst
+ *  name or pkt source inst name is not of size RM_NAME_MAX_CHARS */
 #define RM_ERROR_SRC_NAME_BUF_INVALID_SIZE         RM_ERROR_BASE-51
-/** A resource name specified in the GRL, policy, and/or service request is greater than
- *  RM_NAME_MAX_CHARS */
+/** A resource name specified in the GRL, policy, and/or service request is
+ *  greater than RM_NAME_MAX_CHARS */
 #define RM_ERROR_RESOURCE_NAME_TOO_LONG            RM_ERROR_BASE-52
-/** RM failed to create a new allocator - Occurred because an instance that does not use
- *  allocators tried to create one (RM Client) */
+/** RM failed to create a new allocator - Occurred because an instance that
+ *  does not use allocators tried to create one (RM Client) */
 #define RM_ERROR_COULD_NOT_CREATE_NEW_ALLOCATOR    RM_ERROR_BASE-53
 /** Could not allocate the memory needed to store the root entry of the
  *  allocator tree */
@@ -402,14 +427,14 @@ extern "C" {
  */
 #define RM_NAME_MAX_CHARS (32)
 
-/** 
+/**
  * @brief RM instance handle.  The RM handle is used to register transports
  *        between RM instances and request resource services from the RM
  *        instance.
  */
 typedef void *Rm_Handle;
 
-/** 
+/**
  * @brief RM instance types
  */
 typedef enum {
@@ -455,22 +480,23 @@ typedef struct {
  * @brief RM client delegate (CD) initialization configurations
  */
 typedef struct {
-    /** Pointer to a client delegate policy used by the CD to allocate resources 
+    /** Pointer to a client delegate policy used by the CD to allocate resources
      *  without contacting the server.  The cdPolicy will be used by the CD to
      *  determine whether clients connected to the CD can be allocated resources
      *  provided to the CD by the server. 
      *
      *  The cdPolicy will also act as a static policy until the transport to the
-     *  server has been established.  Static allocations can occur before the 
-     *  instance has been attached to a server instance within the RM system.  
-     *  This is useful for allocating resources prior to main().  Resources allocated
-     *  via the static policy will be verified against the global policy once the 
-     *  CD connects with the server.  The static policy must be in DTB format.  
+     *  server has been established.  Static allocations can occur before the
+     *  instance has been attached to a server instance within the RM system.
+     *  This is useful for allocating resources prior to main().  Resources
+     *  allocated via the static policy will be verified against the global
+     *  policy once the CD connects with the server.  The static policy must be
+     *  in DTB format.
      *
      *  To guarantee proper resource permission synchronization between the CD
      *  and server the cdPolicy must either be an exact copy of the globalPolicy
-     *  or a exact replica of a subset of the globalPolicy provided to the server
-     *  at initialization. */
+     *  or a exact replica of a subset of the globalPolicy provided to the
+     *  server at initialization. */
     void *cdPolicy;
 } Rm_ClientDelegateCfg;
 
@@ -478,12 +504,13 @@ typedef struct {
  * @brief RM client initialization configurations
  */
 typedef struct {
-    /** Pointer to a static policy used by the client to allocate resources statically.
-     *  Static allocations can occur before the instance has been attached to a server
-     *  or CD instance within the RM system.  This is useful for allocating resources
-     *  prior to main().  Resources allocated via the static policy will be verified
-     *  against the global policy once the client connects with the server (directly or
-     *  indirectly through a CD).  The static policy must be in DTB format. */
+    /** Pointer to a static policy used by the client to allocate resources
+     *  statically.  Static allocations can occur before the instance has been
+     *  attached to a server or CD instance within the RM system.  This is
+     *  useful for allocating resources prior to main().  Resources allocated
+     *  via the static policy will be verified against the global policy once
+     *  the client connects with the server (directly or indirectly through a
+     *  CD).  The static policy must be in DTB format. */
     void *staticPolicy;
 } Rm_ClientCfg;
 
@@ -491,35 +518,38 @@ typedef struct {
  * @brief RM shared client initialization configurations
  */
 typedef struct {
-    /** RM Shared Server handle.  Typically, the Shared Server handle is created on
-     *  DSP core designated for system initialization.  The application then
-     *  the Shared Server handle, located in shared memory, to the other DSP cores.
-     *  These DSP cores can then piggyback onto the shared memory data structures in
-     *  the Shared Server via the Shared Client */
+    /** RM Shared Server handle.  Typically, the Shared Server handle is
+     *  created on DSP core designated for system initialization.  The
+     *  application then the Shared Server handle, located in shared memory, to
+     *  the other DSP cores.  These DSP cores can then piggyback onto the
+     *  shared memory data structures in the Shared Server via the Shared
+     *  Client */
      Rm_Handle sharedServerHandle;
 } Rm_SharedClientCfg;
 
-/** 
+/**
  * @brief RM instance initialization structure
  */
 typedef struct {
-    /** Pointer to a character array containing the instance name.  The name of the 
-     *  RM instance can be no greater than #RM_NAME_MAX_CHARS.  The instance name
-     *  must match an instance name defined in the "valid-instances" lists contained
-     *  in the global and static policy DTS files.  Resources and privileges to the
-     *  resources will be based on the name assigned to the RM instance*/
+    /** Pointer to a character array containing the instance name.  The name of
+     *  the RM instance can be no greater than #RM_NAME_MAX_CHARS.  The instance
+     *  name must match an instance name defined in the "valid-instances" lists
+     *  contained in the global and static policy DTS files.  Resources and
+     *  privileges to the resources will be based on the name assigned to the
+     *  RM instance*/
     const char  *instName;
     /** The type of RM instance that will be created. */
     Rm_InstType  instType;
-    /** Instance's multi-threaded semaphore object.  Two or more RM instances can have
-     *  their service transactions to the Server serialized by providing a valid
-     *  multi-threaded semaphore object.  The semaphore object will be used by the 
-     *  Osal_rmMtCsEnter and Osal_rmMtCsExit functions.  The multi-threaded
-     *  semaphore associated with the provided object will be taken when a
-     *  service transaction is requested.  The semaphore will be released when
-     *  the service response is returned.  This will serialize the transactions
-     *  of any RM instance initialized with the same multi-threaded sem object.
-     *  Multi-threaded semaphores will not be used if NULL is provided as the object */
+    /** Instance's multi-threaded semaphore object.  Two or more RM instances
+     *  can have their service transactions to the Server serialized by
+     *  providing a valid multi-threaded semaphore object.  The semaphore
+     *  object will be used by the Osal_rmMtCsEnter and Osal_rmMtCsExit
+     *  functions.  The multi-threaded semaphore associated with the provided
+     *  object will be taken when a service transaction is requested.  The
+     *  semaphore will be released when the service response is returned.  This
+     *  will serialize the transactions of any RM instance initialized with the
+     *  same multi-threaded sem object.  Multi-threaded semaphores will not be
+     *  used if NULL is provided as the object */
     uint32_t    *mtSemObj;
     /** Instance-type specific configurations */
     union {
@@ -536,7 +566,7 @@ typedef struct {
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function prints and returns the status for all resources managed by
  *      the RM instance network.  The allocate/free status as well as ownership
  *      status will be printed for every resource.  Also, the NameServer name
@@ -557,15 +587,15 @@ typedef struct {
  *
  *  @retval
  *      Success - Total number of allocated resource nodes owners.  Effectively
- *                returns the number of resource ranges still allocated. 
+ *                returns the number of resource ranges still allocated.
  *  @retval
- *      Failure - #RM_ERROR_INVALID_RES_STATUS_INSTANCE  
+ *      Failure - #RM_ERROR_INVALID_RES_STATUS_INSTANCE
  */
 int32_t Rm_resourceStatus(Rm_Handle rmHandle, int printResources);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function prints the current status of a RM instance.  The
  *      following instance properties will be printed:
  *      a) instance name & type
@@ -580,7 +610,7 @@ void Rm_instanceStatus(Rm_Handle rmHandle);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function initializes a RM instance.  There are no restrictions
  *      on the amount of times this function can be called.  Each call will
  *      result in a new RM instance.  However, a network of RM instances
@@ -608,7 +638,7 @@ Rm_Handle Rm_init(const Rm_InitCfg *initCfg, int32_t *result);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function deletes the specified RM instance.  All memory
  *      associated with the instance will be freed.
  *
@@ -616,7 +646,7 @@ Rm_Handle Rm_init(const Rm_InitCfg *initCfg, int32_t *result);
  *      Instance handle.
  *
  *  @param[in]  ignorePendingServices
- *      Non-zero - The instance will be deleted despite any services pending <br>
+ *      Non-zero - The instance will be deleted despite any services pending<br>
  *      0        - The instance will not be deleted due to at least one service
  *                 pending.
  *
@@ -633,7 +663,7 @@ int32_t Rm_delete(Rm_Handle rmHandle, int ignorePendingServices);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      The function is used to get the version information of RM.
  *
  *  @retval
@@ -643,7 +673,7 @@ uint32_t Rm_getVersion(void);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      The function is used to get the version string for RM.
  *
  *  @retval
@@ -651,8 +681,8 @@ uint32_t Rm_getVersion(void);
  */
 const char* Rm_getVersionStr(void);
 
-/** 
-@} 
+/**
+@}
 */
 
 #ifdef __cplusplus
index fbee72006466e9838f67bc0803195bfd94d8746a..9038850a390b89920b63def853e53c8afb4eac93 100644 (file)
--- a/rm_osal.h
+++ b/rm_osal.h
@@ -3,12 +3,12 @@
  *
  *   @brief   
  *      This is the sample OS Adaptation layer which is used by the Resource
- *      Manager. The OSAL layer can be ported in either of the following 
+ *      Manager. The OSAL layer can be ported in either of the following
  *      manners to a native OS:
  *
  *      <b> Approach 1: </b>
  *      @n  Use Prebuilt Libraries
- *           - Ensure that the provide an implementation of all 
+ *           - Ensure that the provide an implementation of all
  *             Osal_XXX API for their native OS.
  *           - Link the prebuilt libraries with their application.
  *           - Refer to the "example" directory for an example of this
  *           - Customers can reuse prebuilt TI provided libraries
  *       @n <b> Cons: </b>
  *           - Level of indirection in the API to get to the actual OS call
- *              
+ *
  *      <b> Approach 2: </b>
  *      @n  Rebuilt Library 
  *           - Create a copy of this file and modify it to directly 
  *             inline the native OS calls
- *           - Rebuild the RM low level drivver library; ensure that the Include 
- *             path points to the directory where the copy of this file 
+ *           - Rebuild the RM low level drivver library; ensure that the Include
+ *             path points to the directory where the copy of this file
  *             has been provided.
- *           - Please refer to the "test" directory for an example of this 
+ *           - Please refer to the "test" directory for an example of this
  *       @n <b> Pros: </b>
  *           - Optimizations can be done to remove the level of indirection
  *       @n <b> Cons: </b>
  *
  *  \par
  *  NOTE:
- *      (C) Copyright 2012-2013 Texas Instruments, Inc.
+ *      (C) Copyright 2012-2015 Texas Instruments, Inc.
  * 
- *  Redistribution and use in source and binary forms, with or without 
- *  modification, are permitted provided that the following conditions 
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
  *  are met:
  *
- *    Redistributions of source code must retain the above copyright 
+ *    Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  *    Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the 
- *    documentation and/or other materials provided with the   
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the
  *    distribution.
  *
  *    Neither the name of Texas Instruments Incorporated nor the names of
  *    its contributors may be used to endorse or promote products derived
  *    from this software without specific prior written permission.
  *
- *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
- *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
- *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
- *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
- *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  *  \par
@@ -68,7 +68,7 @@
 #define RM_OSAL_H_
 
 /** @addtogroup RM_OSAL_API
- @{ 
+ @{
  */
 
 /**********************************************************************
@@ -97,9 +97,9 @@ extern void  Osal_rmLog (char *fmt, ... );
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void* Osal_rmMalloc (uint32_t numBytes)
   @endverbatim
- *      
*     void* Osal_rmMalloc (uint32_t numBytes)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Number of bytes to be allocated
  *
@@ -116,9 +116,9 @@ extern void  Osal_rmLog (char *fmt, ... );
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void Osal_rmFree (void *ptr, uint32_t size)
   @endverbatim
- *      
*     void Osal_rmFree (void *ptr, uint32_t size)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Pointer to the block of memory to be cleaned up.
  *  @n  Size of the allocated memory which is being freed.
@@ -131,7 +131,7 @@ extern void  Osal_rmLog (char *fmt, ... );
 /**
  * @brief   The function is used to enter a critical section.
  *          Function protects against 
- *      
+ *
  *          access from multiple cores 
  *          and 
  *          access from multiple threads on single core
@@ -140,9 +140,9 @@ extern void  Osal_rmLog (char *fmt, ... );
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void *Osal_rmCsEnter (void)
   @endverbatim
- *      
*     void *Osal_rmCsEnter (void)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Not applicable.
  *
@@ -152,16 +152,16 @@ extern void  Osal_rmLog (char *fmt, ... );
 #define Rm_osalCsEnter            Osal_rmCsEnter
 
 /**
- * @brief   The function is used to exit a critical section 
+ * @brief   The function is used to exit a critical section
  *          protected using Osal_rmCsEnter() API.
  *
  * <b> Prototype: </b>
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void Osal_rmCsExit (void *CsHandle)
   @endverbatim
- *      
*     void Osal_rmCsExit (void *CsHandle)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Handle for unlocking critical section.
  *
@@ -172,17 +172,17 @@ extern void  Osal_rmLog (char *fmt, ... );
 
 /**
  * @brief   The function is used to enter a multi-threaded critical
- *          section.  Function protects against 
- *      
+ *          section.  Function protects against
+ *
  *          access from multiple threads on single core
  *
  * <b> Prototype: </b>
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void *Osal_rmMtCsEnter (void *mtSemObj)
   @endverbatim
- *      
*     void *Osal_rmMtCsEnter (void *mtSemObj)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Multi-threaded critical section object handle.
  *
@@ -199,8 +199,8 @@ extern void  Osal_rmLog (char *fmt, ... );
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void Osal_rmMtCsExit (void *mtSemObj, void *CsHandle)
   @endverbatim
*     void Osal_rmMtCsExit (void *mtSemObj, void *CsHandle)
*  @endverbatim
  *
  *  <b> Parameter </b>
  *  @n  Multi-threaded critical section object handle.
@@ -223,9 +223,9 @@ extern void  Osal_rmLog (char *fmt, ... );
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void Osal_rmBeginMemAccess (void *ptr, uint32_t size)
   @endverbatim
- *      
*     void Osal_rmBeginMemAccess (void *ptr, uint32_t size)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Address of memory block
  *  @n  Size of memory block
@@ -236,18 +236,18 @@ extern void  Osal_rmLog (char *fmt, ... );
 #define Rm_osalBeginMemAccess     Osal_rmBeginMemAccess
 
 /**
- * @brief   The function is used to indicate that the block of memory has 
- *          finished being accessed. If the memory block is cached then the 
- *          application would need to ensure that the contents of the cache 
- *          are updated immediately to the actual memory. 
+ * @brief   The function is used to indicate that the block of memory has
+ *          finished being accessed. If the memory block is cached then the
+ *          application would need to ensure that the contents of the cache
+ *          are updated immediately to the actual memory.
  *
  * <b> Prototype: </b>
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void Osal_rmEndMemAccess (void *ptr, uint32_t size)
   @endverbatim
- *      
*     void Osal_rmEndMemAccess (void *ptr, uint32_t size)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Address of memory block
  *  @n  Size of memory block
@@ -261,16 +261,16 @@ extern void  Osal_rmLog (char *fmt, ... );
  * @brief   The macro is used by RM to create a task blocking
  *          mechanism allowing a RM instance to block when it
  *          has not been provided a service callback function
- *          and it must send a packet to remote RM instance 
+ *          and it must send a packet to remote RM instance
  *          to complete a service.
  *
  * <b> Prototype: </b>
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void *Osal_rmTaskBlockCreate (void)
   @endverbatim
- *      
*     void *Osal_rmTaskBlockCreate (void)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Not applicable.
  *
@@ -282,7 +282,7 @@ extern void  Osal_rmLog (char *fmt, ... );
 /**
  * @brief   The macro is used by a RM instance to block when it
  *          has not been provided a service callback function
- *          and it must send a packet to remote RM instance 
+ *          and it must send a packet to remote RM instance
  *          to complete a service.  The blocking operation
  *          should block the current RM instance's task/thread
  *          from executing until a task/thread from which the
@@ -292,9 +292,9 @@ extern void  Osal_rmLog (char *fmt, ... );
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void  Osal_rmTaskBlock (void *handle)
   @endverbatim
- *      
*     void  Osal_rmTaskBlock (void *handle)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Task blocking mechanism handle cast as a void pointer
  *
@@ -304,16 +304,16 @@ extern void  Osal_rmLog (char *fmt, ... );
 #define Rm_osalTaskBlock          Osal_rmTaskBlock
 
 /**
- * @brief   The macro is used by a RM instance to unblock from 
+ * @brief   The macro is used by a RM instance to unblock from
  *          a previous block operation.
  *
  * <b> Prototype: </b>
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void  Osal_rmTaskUnblock (void *handle)
   @endverbatim
- *      
*     void  Osal_rmTaskUnblock (void *handle)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Task blocking mechanism handle cast as a void pointer
  *
@@ -330,9 +330,9 @@ extern void  Osal_rmLog (char *fmt, ... );
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
      void  Osal_rmTaskBlockDelete (void *handle)
   @endverbatim
- *      
*     void  Osal_rmTaskBlockDelete (void *handle)
*  @endverbatim
+ *
  *  <b> Parameter </b>
  *  @n  Task blocking mechanism handle cast as a void pointer
  *
@@ -343,14 +343,14 @@ extern void  Osal_rmLog (char *fmt, ... );
 
 /**
  * @brief   The macro is used by RM to log various 
- *          messages. 
+ *          messages.
  *
  * <b> Prototype: </b>
  *  The following is the C prototype for the expected OSAL API.
  *
  *  @verbatim
-       void Osal_rmLog( char *fmt, ... ) 
   @endverbatim
+ *     void Osal_rmLog( char *fmt, ... )
*  @endverbatim
  *
  *  <b> Parameter </b>
  *  @n  printf-style format string 
index ec9c21e79c30b13f8858540658623bd4b1086035..a2f3bba0cf7f0f123b1f27260b1585e051bcfe9a 100644 (file)
@@ -1,13 +1,13 @@
 /**
  *   @file  rm_services.h
  *
- *   @brief   
- *      This is the RM include file for services provided to components that 
+ *   @brief
+ *      This is the RM include file for services provided to components that
  *      register a RM instance
  *
  *  \par
  *  ============================================================================
- *  @n   (C) Copyright 2012-2013, Texas Instruments, Inc.
+ *  @n   (C) Copyright 2012-2015, Texas Instruments, Inc.
  * 
  *  Redistribution and use in source and binary forms, with or without 
  *  modification, are permitted provided that the following conditions 
@@ -78,17 +78,17 @@ typedef enum {
     Rm_service_LAST
 } Rm_ServiceType;
 
-/** 
+/**
  * @brief RM service response information used by RM to provide service
  *        request results back to the application components
  */
 typedef struct {
-    /** RM instance handle from which the service request that spawned this 
+    /** RM instance handle from which the service request that spawned this
      *  result originated.  Used by application to sort responses, received
      *  via callback function, from RM instances located on the same core. */
     Rm_Handle rmHandle;
     /** Service request state.  State values can be found in rm.h starting
-     *  with #RM_SERVICE_PROCESSING, #RM_SERVICE_DENIED_BASE, and 
+     *  with #RM_SERVICE_PROCESSING, #RM_SERVICE_DENIED_BASE, and
      *  #RM_ERROR_LIBFDT_START */
     int32_t   serviceState;
     /** The service ID is returned to the application in order to match service
@@ -99,36 +99,38 @@ typedef struct {
     uint32_t  serviceId;
     /** Affected resource name */
     char      resourceName[RM_NAME_MAX_CHARS];
-    /** The resource base value allocated, freed, or mapped to NameServer name. */
+    /** The resource base value allocated, freed, or mapped to NameServer
+     *  name. */
     int32_t   resourceBase;
     /** The resource length starting at base allocated, freed, or mapped to
      *  NameServer name. */
     uint32_t  resourceLength;
 /** resourceNumOwners is not valid unless >= 0 */
-#define RM_RESOURCE_NUM_OWNERS_INVALID (-1)      
+#define RM_RESOURCE_NUM_OWNERS_INVALID (-1)
     /** Current number of owners for the returned resource.  A value greater
      *  than one means the resource is being shared.  This value is only valid
-     *  if the serviceState is RM_SERVICE_APPROVED or RM_SERVICE_APPROVED_STATIC. */
+     *  if the serviceState is RM_SERVICE_APPROVED or
+     *  RM_SERVICE_APPROVED_STATIC. */
     int32_t   resourceNumOwners;
 /** instAllocCount is not valid unless >= 0 */
-#define RM_INST_ALLOC_COUNT_INVALID (-1) 
-    /** Number of times the requesting instance has allocated the returned resource.
-     *  This value is only valid if the serviceState is RM_SERVICE_APPROVED or
-     *  RM_SERVICE_APPROVED_STATIC */
+#define RM_INST_ALLOC_COUNT_INVALID    (-1)
+    /** Number of times the requesting instance has allocated the returned
+     *  resource.  This value is only valid if the serviceState is
+     *  RM_SERVICE_APPROVED or RM_SERVICE_APPROVED_STATIC */
     int32_t   instAllocCount;
 } Rm_ServiceRespInfo;
 
-/** 
+/**
  * @brief RM service callback function
  */
 typedef struct {
-    /** Component callback function.  RM calls this function when a blocking 
+    /** Component callback function.  RM calls this function when a blocking
      *  resource service request is complete. The callback function supplied
      *  for this parameter must match the function pointer prototype. */
     void (*serviceCallback) (Rm_ServiceRespInfo *serviceResponse);
 } Rm_ServiceCallback;
 
-/** 
+/**
  * @brief RM service request information
  */
 typedef struct {
@@ -156,15 +158,16 @@ typedef struct {
  *     property defined.
  *  b) The default alignment of 1 if no alignment is specified in the policy
  *     for the resource.
- *  This value is only valid if resourceBase is set to #RM_RESOURCE_BASE_UNSPECIFIED */
-#define RM_RESOURCE_ALIGNMENT_UNSPECIFIED (-1)      
+ *  This value is only valid if resourceBase is set to
+ *  #RM_RESOURCE_BASE_UNSPECIFIED */
+#define RM_RESOURCE_ALIGNMENT_UNSPECIFIED (-1)
     /** Alignment of the resource affected by the service request.  Only valid
      *  if resourceBase is set to #RM_RESOURCE_BASE_UNSPECIFIED.
      *  #RM_RESOURCE_ALIGNMENT_UNSPECIFIED can be substituted. */
     int32_t             resourceAlignment;
-    /** The NameServer name associated, or to be associated, with a resource. 
-     *  The NameServer name has precedence over #resourceBase and #resourceLength
-     *  for all resource modification service types as well as
+    /** The NameServer name associated, or to be associated, with a resource.
+     *  The NameServer name has precedence over #resourceBase and
+     *  #resourceLength for all resource modification service types as well as
      *  #Rm_service_RESOURCE_GET_BY_NAME.  If the NameServer name and the base
      *  and length are not NULL the resource information retrieved from the
      *  NameServer entry for the name will replace the values present in
@@ -177,7 +180,7 @@ typedef struct {
     Rm_ServiceCallback  callback;
 } Rm_ServiceReqInfo;
 
-/** 
+/**
  * @brief RM service handle provided to application components for requesting
  *        services
  */
@@ -186,36 +189,38 @@ typedef struct {
     void *rmHandle;
     /**
      *  @b Description
-     *  @n  
+     *  @n
      *      Processes service requests from application components.  Responses
-     *      are returned immediately if the service request could be satisfied 
-     *      without blocking.  If the service request requires a blocking operation,
-     *      such as forwarding the service request to another instance for
-     *      validation, the response will be received via the Rm_ServerCallback
+     *      are returned immediately if the service request could be satisfied
+     *      without blocking.  If the service request requires a blocking
+     *      operation, such as forwarding the service request to another
+     *      instance for validation, the response will be received via the
+     *      Rm_ServerCallback
      *
      *   @param[in] rmHandle
      *      RM instance handle specifies the instance that handles the service
-     *      request.  The request's result, if policy checks are involved, will be
-     *      based on the permissions assigned to the rmHandle's instance name within
-     *      global/static policy.
-     *  
+     *      request.  The request's result, if policy checks are involved, will
+     *      be based on the permissions assigned to the rmHandle's instance
+     *      name within global/static policy.
+     *
      *  @param[in]  serviceRequest
      *      Pointer to the service request structure
      *
      *  @param[out]  serviceResponse
      *      Pointer to a service response structure.
      */
-    void (*Rm_serviceHandler)(void *rmHandle, const Rm_ServiceReqInfo *serviceRequest,
+    void (*Rm_serviceHandler)(void *rmHandle,
+                              const Rm_ServiceReqInfo *serviceRequest,
                               Rm_ServiceRespInfo *serviceResponse);
 } Rm_ServiceHandle;
 
 /**
  *  @b Description
- *  @n  
- *      This function returns a RM service handle to the application to 
- *      provide services to software components (LLDs, BIOS, etc) that want to use RM
- *      for resource management. Only one service handle can be opened from
- *      each RM instance.
+ *  @n
+ *      This function returns a RM service handle to the application to
+ *      provide services to software components (LLDs, BIOS, etc) that want to
+ *      use RM for resource management. Only one service handle can be opened
+ *      from each RM instance.
  *
  *  @param[in]  rmHandle
  *      RM instance handle from which the service handle will be opened
@@ -227,13 +232,14 @@ typedef struct {
  *  @retval
  *      Success - Rm_ServiceHandle and result = #RM_OK
  *  @retval
- *      Failure - NULL Rm_ServiceHandle and result = #RM_ERROR_SERVICE_HANDLE_MEM_ALLOC_FAILED
+ *      Failure - NULL Rm_ServiceHandle and
+ *                result = #RM_ERROR_SERVICE_HANDLE_MEM_ALLOC_FAILED
  */
 Rm_ServiceHandle *Rm_serviceOpenHandle(Rm_Handle rmHandle, int32_t *result);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function closes a RM instance's service handle
  *
  *  @param[in]  rmServiceHandle
@@ -246,8 +252,8 @@ Rm_ServiceHandle *Rm_serviceOpenHandle(Rm_Handle rmHandle, int32_t *result);
  */
 int32_t Rm_serviceCloseHandle(Rm_ServiceHandle *rmServiceHandle);
 
-/** 
-@} 
+/**
+@}
 */
 
 #ifdef __cplusplus
index 426a3cbe7117638bce5985353fd492a14d5f79c8..05c8793733c1bfb1efe57a8b6985c01f2b4857c6 100644 (file)
@@ -7,7 +7,7 @@
  *
  *  \par
  *  ============================================================================
- *  @n   (C) Copyright 2012-2014, Texas Instruments, Inc.
+ *  @n   (C) Copyright 2012-2015, Texas Instruments, Inc.
  * 
  *  Redistribution and use in source and binary forms, with or without 
  *  modification, are permitted provided that the following conditions 
@@ -63,7 +63,7 @@ extern "C" {
  */
 #define RM_TRANSPORT_PACKET_MAX_SIZE_BYTES (256)
 
-/** 
+/**
  * @brief RM transport handle
  */
 typedef void *Rm_TransportHandle;
@@ -76,7 +76,7 @@ typedef void *Rm_TransportHandle;
  *        a Rm_AppTransportHandle to the application any time RM 
  *        wants to alloc or send a packet via the transport callouts
  */
-typedef void *Rm_AppTransportHandle; 
+typedef void *Rm_AppTransportHandle;
 
 /**
  * @brief A void pointer to the start of a registered application transport
@@ -95,7 +95,7 @@ typedef void *Rm_PacketHandle;
 typedef enum {
     /** Allocate/Free request packet */
     Rm_pktType_RESOURCE_REQUEST = 0,
-    /** Allocate/Free response packet */ 
+    /** Allocate/Free response packet */
     Rm_pktType_RESOURCE_RESPONSE,
     /** RM NameServer mapping request */
     Rm_pktType_NAMESERVER_REQUEST,
@@ -103,7 +103,7 @@ typedef enum {
     Rm_pktType_NAMESERVER_RESPONSE
 } Rm_pktType;
 
-/** 
+/**
  * @brief RM transport layer packet
  */
 typedef struct {
@@ -123,19 +123,19 @@ typedef struct {
     /**
      *  @b Description
      *  @n  
-     *      This function pointer describes the RM transport layer packet 
+     *      This function pointer describes the RM transport layer packet
      *      allocation function.  The application must supply an alloc function
-     *      to RM instances at transport registration if the RM instance is 
+     *      to RM instances at transport registration if the RM instance is
      *      intended to communicate with other RM instances.  The function
      *      provided by the application must match this prototype.  The provided
      *      function implements the allocation of packet buffers from the 
-     *      application data path that the RM transport will use to send messages
-     *      between RM instances.  The Rm_Packet pointer will point to start of
-     *      the data buffer containing the RM packet data.  The pktHandle will
-     *      point to the start of the application data path "packet" data
-     *      structure.  The Rm_Packet pointer and pktHandle cannot be NULL.  They
-     *      will either be different or the same value based on the application
-     *      transport.
+     *      application data path that the RM transport will use to send
+     *      messages between RM instances.  The Rm_Packet pointer will point to
+     *      start of the data buffer containing the RM packet data.  The
+     *      pktHandle will point to the start of the application data path
+     *      "packet" data structure.  The Rm_Packet pointer and pktHandle cannot
+     *      be NULL.  They will either be different or the same value based on
+     *      the application transport.
      *
      *  @param[in]  appTransport
      *      Application transport handle to allocate packet from.  This value
@@ -156,14 +156,15 @@ typedef struct {
      *  @retval
      *      Failure - NULL
      */
-    Rm_Packet *(*rmAllocPkt)(Rm_AppTransportHandle appTransport, uint32_t pktSize, 
-                             Rm_PacketHandle *pktHandle);    
+    Rm_Packet *(*rmAllocPkt)(Rm_AppTransportHandle appTransport,
+                             uint32_t pktSize,
+                             Rm_PacketHandle *pktHandle);
     /**
      *  @b Description
-     *  @n  
-     *      This function pointer describes the RM transport layer packet 
+     *  @n
+     *      This function pointer describes the RM transport layer packet
      *      send function.  The application must supply a send function
-     *      to RM instances at transport registration if the RM instance is 
+     *      to RM instances at transport registration if the RM instance is
      *      intended to communicate with other RM instances.  The function
      *      provided by the application must match this prototype.  The provided
      *      function implements the sending of application data path packets,
@@ -189,10 +190,11 @@ typedef struct {
      *  @retval
      *      < 0 - Packet send failed.
      */
-    int32_t (*rmSendPkt)(Rm_AppTransportHandle appTransport, Rm_PacketHandle pktHandle);
+    int32_t (*rmSendPkt)(Rm_AppTransportHandle appTransport,
+                         Rm_PacketHandle pktHandle);
 } Rm_TransportCallouts;
 
-/** 
+/**
  * @brief RM transport registration configuration structure
  */
 typedef struct {
@@ -204,7 +206,7 @@ typedef struct {
      *  should be sent on.  For example, a QMSS queue number, network
      *  port data structure, etc. */
     Rm_AppTransportHandle  appTransportHandle;
-    /** Remote RM instance type at other end of the application transport 
+    /** Remote RM instance type at other end of the application transport
      *  "pipe". */
     Rm_InstType            remoteInstType;
     /** Pointers to application implemented transport APIs.  The APIs for the
@@ -213,12 +215,12 @@ typedef struct {
      *  for each registered transport.  However, based on the application's
      *  implementation of transport code the same function can be provided
      *  for each transport registration.  In these cases, the transport
-     *  must mux/demux the packets it receives from RM based on the 
+     *  must mux/demux the packets it receives from RM based on the
      *  #Rm_TransportHandle. */
-    Rm_TransportCallouts   transportCallouts;   
+    Rm_TransportCallouts   transportCallouts;
 } Rm_TransportCfg;
 
-/** 
+/**
  * @brief RM transport reconfiguration structure
  */
 typedef struct {
@@ -234,14 +236,14 @@ typedef struct {
      *  for each registered transport.  However, based on the application's
      *  implementation of transport code the same function can be provided
      *  for each transport registration.  In these cases, the transport
-     *  must mux/demux the packets it receives from RM based on the 
+     *  must mux/demux the packets it receives from RM based on the
      *  #Rm_TransportHandle. */
-    Rm_TransportCallouts   transportCallouts;   
+    Rm_TransportCallouts   transportCallouts;
 } Rm_TransportReCfg;
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function is used to register transports with RM for sending and
  *      receiving packets between RM instances over application transport
  *      data paths.
@@ -264,19 +266,24 @@ typedef struct {
  *  @retval
  *      Success - RM_TransportHandle and result = #RM_OK
  *  @retval
- *      Failure - NULL RM_TransportHandle and result = #RM_ERROR_INVALID_REMOTE_INST_TYPE
+ *      Failure - NULL RM_TransportHandle and
+ *                result = #RM_ERROR_INVALID_REMOTE_INST_TYPE
  *  @retval
- *      Failure - NULL RM_TransportHandle and result = #RM_ERROR_ALREADY_REGD_SERVER_OR_CD
+ *      Failure - NULL RM_TransportHandle and
+ *                result = #RM_ERROR_ALREADY_REGD_SERVER_OR_CD
  *  @retval
- *      Failure - NULL RM_TransportHandle and result = #RM_ERROR_TRANSPORT_ALLOC_PKT_NOT_REGD
+ *      Failure - NULL RM_TransportHandle and
+ *                result = #RM_ERROR_TRANSPORT_ALLOC_PKT_NOT_REGD
  *  @retval
- *      Failure - NULL RM_TransportHandle and result = #RM_ERROR_TRANSPORT_SEND_NOT_REGD 
+ *      Failure - NULL RM_TransportHandle and
+ *                result = #RM_ERROR_TRANSPORT_SEND_NOT_REGD 
  */
-Rm_TransportHandle Rm_transportRegister(const Rm_TransportCfg *transportCfg, int32_t *result);
+Rm_TransportHandle Rm_transportRegister(const Rm_TransportCfg *transportCfg,
+                                        int32_t *result);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function reconfigures an existing transport handle using the
  *      provided transport configurations
  *
@@ -292,11 +299,12 @@ Rm_TransportHandle Rm_transportRegister(const Rm_TransportCfg *transportCfg, int
  *  @retval
  *      Failure - #RM_ERROR_TRANSPORT_HANDLE_DOES_NOT_EXIST
  */
-int32_t Rm_transportReconfig (Rm_TransportHandle transportHandle, const Rm_TransportReCfg *transportReCfg);
+int32_t Rm_transportReconfig(Rm_TransportHandle transportHandle,
+                             const Rm_TransportReCfg *transportReCfg);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function unregisters the provided transportHandle from the 
  *      RM instance
  *
@@ -309,11 +317,11 @@ int32_t Rm_transportReconfig (Rm_TransportHandle transportHandle, const Rm_Trans
  *  @retval
  *      Failure - #RM_ERROR_TRANSPORT_HANDLE_DOES_NOT_EXIST
  */
-int32_t Rm_transportUnregister (Rm_TransportHandle transportHandle);
+int32_t Rm_transportUnregister(Rm_TransportHandle transportHandle);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function returns the RM instance name from which the service
  *      encapsulated within the RM packet originated
  *
@@ -335,14 +343,15 @@ int32_t Rm_transportUnregister (Rm_TransportHandle transportHandle);
  *      Success - #RM_OK
  *  @retval
  *      Failure - #RM_ERROR_PKT_AND_SERVICE_SRC_NOT_AVAIL
- *      Failure - #RM_ERROR_SRC_NAME_BUF_INVALID_SIZE 
+ *      Failure - #RM_ERROR_SRC_NAME_BUF_INVALID_SIZE
  */
-int32_t Rm_receiveGetPktServiceSrcName(const Rm_Packet *pkt, char *serviceInstName,
+int32_t Rm_receiveGetPktServiceSrcName(const Rm_Packet *pkt,
+                                       char *serviceInstName,
                                        int32_t charBufLen);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function returns the RM instance name from which the RM packet
  *      originated
  *
@@ -366,12 +375,13 @@ int32_t Rm_receiveGetPktServiceSrcName(const Rm_Packet *pkt, char *serviceInstNa
  *      Failure - #RM_ERROR_PKT_AND_SERVICE_SRC_NOT_AVAIL
  *      Failure - #RM_ERROR_SRC_NAME_BUF_INVALID_SIZE
  */
-int32_t Rm_receiveGetPktSrcName(const Rm_Packet *pkt, char *pktInstName,
+int32_t Rm_receiveGetPktSrcName(const Rm_Packet *pkt,
+                                char *pktInstName,
                                 int32_t charBufLen);
 
 /**
  *  @b Description
- *  @n  
+ *  @n
  *      This function is called by the application when it has received a RM
  *      packet for processing.  The application provides the transportHandle
  *      associated with the RM instance that should receive the packet and
@@ -390,12 +400,13 @@ int32_t Rm_receiveGetPktSrcName(const Rm_Packet *pkt, char *pktInstName,
  *  @retval
  *      Success - #RM_OK
  *  @retval
- *      Failure - < #RM_OK 
+ *      Failure - < #RM_OK
  */
-int32_t Rm_receivePacket(Rm_TransportHandle transportHandle, const Rm_Packet *pkt);
+int32_t Rm_receivePacket(Rm_TransportHandle transportHandle,
+                         const Rm_Packet *pkt);
 
-/** 
-@} 
+/**
+@}
 */
 
 #ifdef __cplusplus
index 8730a57d3734672a21e8ce88ac2b7df58cf70c5b..007ade8ab6d039cbce9dda11ccbe3c0f787d4db5 100644 (file)
@@ -46,7 +46,7 @@ extern "C" {
  *   @brief  Resource Manager Version Definitions\r
  *\r
  *  ============================================================\r
- *  Copyright (c) Texas Instruments Incorporated 2012-2014\r
+ *  Copyright (c) Texas Instruments Incorporated 2012-2015\r
  * \r
  *  Redistribution and use in source and binary forms, with or without \r
  *  modification, are permitted provided that the following conditions \r
@@ -79,7 +79,8 @@ extern "C" {
 */\r
 \r
 /**\r
- * @brief   This is the RM Version. Versions numbers are encoded in the following \r
+ * @brief   This is the RM Version. Versions numbers are encoded in the\r
+ *          following\r
  * format:\r
  *  0xAABBCCDD -> Arch (AA); API Changes (BB); Major (CC); Minor (DD)\r
  */\r
@@ -95,6 +96,6 @@ extern "C" {
 #ifdef __cplusplus\r
 }\r
 #endif\r
-  \r
+\r
 \r
 #endif  /* _RMVER_H */\r
index 81d3d27327cc395d740557db4a31fd7430b519a6..792b945ef1551b0b05b4b9ed299467f74274c91d 100644 (file)
--- a/src/rm.c
+++ b/src/rm.c
@@ -97,8 +97,8 @@ static uint32_t transactionGetSequenceNum(Rm_Inst *rmInst)
     rmInst->transactionSeqNum++;
     if (!rmInst->transactionSeqNum) {
         rmInst->transactionSeqNum++;
-    }    
-    return (rmInst->transactionSeqNum);
+    }
+    return(rmInst->transactionSeqNum);
 }
 
 /* FUNCTION PURPOSE: Creates a resource request packet
@@ -109,32 +109,32 @@ static uint32_t transactionGetSequenceNum(Rm_Inst *rmInst)
  *              is allocated via the rmAllocPkt API using the
  *              appTransport handle provided by the application
  */
-void createResourceReqPkt(Rm_Packet *rmPkt, char *localInstName, Rm_Transaction *transaction)
+static void createResourceReqPkt(Rm_Packet *rmPkt, char *localInstName,
+                                 Rm_Transaction *transaction)
 {
     Rm_ResourceRequestPkt *resourceReqPkt = NULL;
-       
+
     rmPkt->pktType = Rm_pktType_RESOURCE_REQUEST;
     resourceReqPkt = (Rm_ResourceRequestPkt *) rmPkt->data;
     resourceReqPkt->requestId = transaction->localId;
     if (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) {
         resourceReqPkt->resourceReqType = Rm_resReqPktType_ALLOCATE_INIT;
-    }
-    else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) {
+    } else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) {
         resourceReqPkt->resourceReqType = Rm_resReqPktType_ALLOCATE_USE;
-    }   
-    else if (transaction->type == Rm_service_RESOURCE_STATUS) {
+    } else if (transaction->type == Rm_service_RESOURCE_STATUS) {
         resourceReqPkt->resourceReqType = Rm_resReqPktType_GET_STATUS;
-    }
-    else if (transaction->type == Rm_service_RESOURCE_FREE) {
+    } else if (transaction->type == Rm_service_RESOURCE_FREE) {
         resourceReqPkt->resourceReqType = Rm_resReqPktType_FREE;
-    }
-    else if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) {
+    } else if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) {
         resourceReqPkt->resourceReqType = Rm_resReqPktType_GET_NAMED;
     }
-    rm_strncpy(resourceReqPkt->pktSrcInstName, localInstName, RM_NAME_MAX_CHARS);
-    rm_strncpy(resourceReqPkt->serviceSrcInstName, transaction->serviceSrcInstName, RM_NAME_MAX_CHARS);
-    memcpy ((void *)&(resourceReqPkt->resourceInfo), (void *)&(transaction->resourceInfo),
-            sizeof(Rm_ResourceInfo));
+    rm_strncpy(resourceReqPkt->pktSrcInstName, localInstName,
+               RM_NAME_MAX_CHARS);
+    rm_strncpy(resourceReqPkt->serviceSrcInstName,
+               transaction->serviceSrcInstName, RM_NAME_MAX_CHARS);
+    memcpy((void *)&(resourceReqPkt->resourceInfo),
+           (void *)&(transaction->resourceInfo),
+           sizeof(Rm_ResourceInfo));
 }
 
 /* FUNCTION PURPOSE: Creates a resource response packet
@@ -145,16 +145,18 @@ void createResourceReqPkt(Rm_Packet *rmPkt, char *localInstName, Rm_Transaction
  *              is allocated via the rmAllocPkt API using the
  *              appTransport handle provided by the application
  */
-void createResourceResponsePkt(Rm_Packet *rmPkt, Rm_Transaction *transaction)
+static void createResourceResponsePkt(Rm_Packet *rmPkt,
+                                      Rm_Transaction *transaction)
 {
     Rm_ResourceResponsePkt *resourceRespPkt = NULL;
-     
-    rmPkt->pktType = Rm_pktType_RESOURCE_RESPONSE;                 
+
+    rmPkt->pktType = Rm_pktType_RESOURCE_RESPONSE;
     resourceRespPkt = (Rm_ResourceResponsePkt *)rmPkt->data;
     resourceRespPkt->responseId = transaction->remoteOriginatingId;
     resourceRespPkt->requestState = transaction->state;
-    memcpy ((void *)&(resourceRespPkt->resourceInfo), (void *)&(transaction->resourceInfo),
-            sizeof(Rm_ResourceInfo));
+    memcpy((void *)&(resourceRespPkt->resourceInfo),
+           (void *)&(transaction->resourceInfo),
+           sizeof(Rm_ResourceInfo));
 }
 
 /* FUNCTION PURPOSE: Creates a NameServer request packet
@@ -165,23 +167,25 @@ void createResourceResponsePkt(Rm_Packet *rmPkt, Rm_Transaction *transaction)
  *              is allocated via the rmAllocPkt API using the
  *              appTransport handle provided by the application
  */
-void createNsRequestPkt(Rm_Packet *rmPkt, char *localInstName, Rm_Transaction *transaction)
+static void createNsRequestPkt(Rm_Packet *rmPkt, char *localInstName,
+                               Rm_Transaction *transaction)
 { 
     Rm_NsRequestPkt *nsReqPkt = NULL;
 
-    rmPkt->pktType = Rm_pktType_NAMESERVER_REQUEST;                   
+    rmPkt->pktType = Rm_pktType_NAMESERVER_REQUEST;
     nsReqPkt = (Rm_NsRequestPkt *)rmPkt->data;
     nsReqPkt->requestId = transaction->localId;
     if (transaction->type == Rm_service_RESOURCE_MAP_TO_NAME) {
         nsReqPkt->nsRequestType = Rm_nsReqPktType_MAP_RESOURCE;
-    }
-    else if (transaction->type == Rm_service_RESOURCE_UNMAP_NAME) {
+    } else if (transaction->type == Rm_service_RESOURCE_UNMAP_NAME) {
         nsReqPkt->nsRequestType = Rm_nsReqPktType_UNMAP_RESOURCE;
     }
     rm_strncpy(nsReqPkt->pktSrcInstName, localInstName, RM_NAME_MAX_CHARS);
-    rm_strncpy(nsReqPkt->serviceSrcInstName, transaction->serviceSrcInstName, RM_NAME_MAX_CHARS);
-    memcpy ((void *)&(nsReqPkt->resourceInfo), (void *)&(transaction->resourceInfo),
-            sizeof(Rm_ResourceInfo));
+    rm_strncpy(nsReqPkt->serviceSrcInstName, transaction->serviceSrcInstName,
+               RM_NAME_MAX_CHARS);
+    memcpy((void *)&(nsReqPkt->resourceInfo),
+           (void *)&(transaction->resourceInfo),
+           sizeof(Rm_ResourceInfo));
 }
 
 /* FUNCTION PURPOSE: Creates a NameServer response packet
@@ -192,11 +196,11 @@ void createNsRequestPkt(Rm_Packet *rmPkt, char *localInstName, Rm_Transaction *t
  *              is allocated via the rmAllocPkt API using the
  *              appTransport handle provided by the application
  */
-void createNsResponsePkt(Rm_Packet *rmPkt, Rm_Transaction *transaction)
+static void createNsResponsePkt(Rm_Packet *rmPkt, Rm_Transaction *transaction)
 {
     Rm_NsResponsePkt *nsRespPkt = NULL;
 
-    rmPkt->pktType = Rm_pktType_NAMESERVER_RESPONSE;                
+    rmPkt->pktType = Rm_pktType_NAMESERVER_RESPONSE;
     nsRespPkt = (Rm_NsResponsePkt *)rmPkt->data;
     nsRespPkt->responseId = transaction->remoteOriginatingId;
     nsRespPkt->requestState = transaction->state;
@@ -219,7 +223,8 @@ static void serviceResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)
     /* Pass back the ID that was provided to the component when it requested
      * the service */
     serviceResponse.serviceId = transaction->localId;
-    /* Owner and instance allocation count will only be set within RM under certain circumstances. */
+    /* Owner and instance allocation count will only be set within RM under
+     * certain circumstances. */
     serviceResponse.resourceNumOwners = transaction->resourceInfo.ownerCount;
     serviceResponse.instAllocCount = transaction->resourceInfo.instAllocCount;
 
@@ -230,23 +235,23 @@ static void serviceResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)
          (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||
          (transaction->type == Rm_service_RESOURCE_FREE) ||
          (transaction->type == Rm_service_RESOURCE_STATUS) ||
-         (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)))
-    {
-        rm_strncpy(serviceResponse.resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
+         (transaction->type == Rm_service_RESOURCE_GET_BY_NAME))) {
+        rm_strncpy(serviceResponse.resourceName, transaction->resourceInfo.name,
+                   RM_NAME_MAX_CHARS);
         serviceResponse.resourceBase = transaction->resourceInfo.base;
         serviceResponse.resourceLength = transaction->resourceInfo.length;
     }
 
     if (transaction->u.callback.serviceCallback) {
-        /* Issue the callback to the requesting component with the response information */
+        /* Issue the callback to the requesting component with the response
+         * information */
         transaction->u.callback.serviceCallback(&serviceResponse);
         /* Delete the transaction from the transaction queue */
         rmTransactionQueueDelete(rmInst, transaction->localId);
-    }
-    else {
+    } else {
         rmServiceInternalCallback((Rm_Handle)rmInst);
     }
-    
+
     return;
 }
 
@@ -263,7 +268,7 @@ static void transactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)
     Rm_Packet       *rmPkt = NULL;
     Rm_PacketHandle  pktHandle = NULL;
 
-    rmPkt = dstTransport->callouts.rmAllocPkt(dstTransport->appTransportHandle, 
+    rmPkt = dstTransport->callouts.rmAllocPkt(dstTransport->appTransportHandle,
                                               sizeof(Rm_Packet), &pktHandle);
     if (!rmPkt || !pktHandle) {
         transaction->state = RM_ERROR_TRANSPORT_ALLOC_PKT_ERROR;
@@ -286,17 +291,18 @@ static void transactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction)
             transaction->state = RM_ERROR_INVALID_SERVICE_TYPE;
             goto errorExit;
     }
-    if (dstTransport->callouts.rmSendPkt(dstTransport->appTransportHandle, pktHandle) < RM_OK) {
+    if (dstTransport->callouts.rmSendPkt(dstTransport->appTransportHandle,
+                                         pktHandle) < RM_OK) {
         transaction->state = RM_ERROR_TRANSPORT_SEND_ERROR;
         goto errorExit;
     }
-    
+
     /* Response packet sent: Delete transaction from queue */
     rmTransactionQueueDelete(rmInst, transaction->localId);
 
 errorExit:
-    /* Do not delete transaction on transport error.  Transport error transactions should be visible
-     * from Rm_printInstanceStatus() */
+    /* Do not delete transaction on transport error.  Transport error
+     * transactions should be visible from Rm_printInstanceStatus() */
     return;
 }
 
@@ -314,20 +320,23 @@ static void transactionForwarder (Rm_Inst *rmInst, Rm_Transaction *transaction)
     Rm_PacketHandle  pktHandle = NULL;
 
     if (rmInst->instType == Rm_instType_CLIENT) {
-        dstTransport = rmTransportFindRemoteInstType(rmInst->transports, Rm_instType_CLIENT_DELEGATE);
+        dstTransport = rmTransportFindRemoteInstType(rmInst->transports,
+                                                   Rm_instType_CLIENT_DELEGATE);
 
         if (!dstTransport) {
-            dstTransport = rmTransportFindRemoteInstType(rmInst->transports, Rm_instType_SERVER);
+            dstTransport = rmTransportFindRemoteInstType(rmInst->transports,
+                                                         Rm_instType_SERVER);
         }
-    } 
-    else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
-        dstTransport = rmTransportFindRemoteInstType(rmInst->transports, Rm_instType_SERVER);
+    } else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
+        dstTransport = rmTransportFindRemoteInstType(rmInst->transports,
+                                                     Rm_instType_SERVER);
     }
 
-    /* Just queue transaction if transport hasn't been registered.  Do not return error */
-    if (dstTransport) {            
-        rmPkt = dstTransport->callouts.rmAllocPkt(dstTransport->appTransportHandle, 
-                                                  sizeof(Rm_Packet), &pktHandle);
+    /* Just queue transaction if transport hasn't been registered.  Do not
+     * return error */
+    if (dstTransport) {
+        rmPkt = dstTransport->callouts.rmAllocPkt(dstTransport->appTransportHandle,
+                                                 sizeof(Rm_Packet), &pktHandle);
         if (!rmPkt || !pktHandle) {
             transaction->state = RM_ERROR_TRANSPORT_ALLOC_PKT_ERROR;
             goto errorExit;
@@ -349,17 +358,18 @@ static void transactionForwarder (Rm_Inst *rmInst, Rm_Transaction *transaction)
                 transaction->state = RM_ERROR_INVALID_SERVICE_TYPE;
                 goto errorExit;
         }
-  
-        if (dstTransport->callouts.rmSendPkt(dstTransport->appTransportHandle, pktHandle) < RM_OK) {
+
+        if (dstTransport->callouts.rmSendPkt(dstTransport->appTransportHandle,
+                                             pktHandle) < RM_OK) {
             transaction->state = RM_ERROR_TRANSPORT_SEND_ERROR;
             goto errorExit;
-        }              
+        }
         transaction->hasBeenForwarded = RM_TRUE;
         /* Transaction not deleted.  Waiting for response from RM CD or Server */
     }
-errorExit: 
-    /* Do not delete transaction on transport error.  Transport error transactions should be visible
-     * from Rm_printInstanceStatus() */               
+errorExit:
+    /* Do not delete transaction on transport error.  Transport error
+     * transactions should be visible from Rm_printInstanceStatus() */
     return;
 }
 
@@ -463,7 +473,7 @@ static int32_t cdRequestServerResources(Rm_Inst *rmInst,
         /* Resource could not be found in policy */
         retVal = RM_SERVICE_DENIED_RES_DOES_NOT_EXIST;
     }
-    return (retVal);
+    return(retVal);
 }
 
 /* FUNCTION PURPOSE: Frees local resources to Server from CD
@@ -472,36 +482,40 @@ static int32_t cdRequestServerResources(Rm_Inst *rmInst,
  *              managed resources that are now localized back to
  *              the Server.
  */
-static int32_t cdFreeResourcesToServer(Rm_Inst *rmInst, Rm_Transaction *transaction)
+static int32_t cdFreeResourcesToServer(Rm_Inst *rmInst,
+                                       Rm_Transaction *transaction)
 {
     int32_t         baseToFree = transaction->resourceInfo.base;
     uint32_t        lenToFree = transaction->resourceInfo.length;
     Rm_Transaction *newTrans = NULL; 
     /* This function should only be called after a free was approved */
     int32_t         retVal = RM_SERVICE_APPROVED;    
-    
-    /* Did free result in a localized free node that can be given back to Server?  If
-     * so create transaction to Server to free localized resource node */
-    if (rmAllocatorGetNodeLocalization((Rm_Handle)rmInst, transaction->resourceInfo.name,
+
+    /* Did free result in a localized free node that can be given back to
+     * Server?  If so create transaction to Server to free localized
+     * resource node */
+    if (rmAllocatorGetNodeLocalization((Rm_Handle)rmInst,
+                                       transaction->resourceInfo.name,
                                        &baseToFree, &lenToFree)) {
         if ((newTrans = rmTransactionQueueAdd(rmInst))) {
             newTrans->type = transaction->type;
-            rm_strncpy(newTrans->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS);
+            rm_strncpy(newTrans->serviceSrcInstName, rmInst->instName,
+                       RM_NAME_MAX_CHARS);
             newTrans->state = RM_SERVICE_PROCESSING;
-            rm_strncpy(newTrans->resourceInfo.name, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
+            rm_strncpy(newTrans->resourceInfo.name,
+                       transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
             newTrans->resourceInfo.base = baseToFree;
             newTrans->resourceInfo.length = lenToFree;
             newTrans->pendingTransactionId = transaction->localId;
             transactionForwarder(rmInst, newTrans);
 
             retVal = RM_SERVICE_PENDING_SERVER_RESPONSE;
-        }
-        else {
+        } else {
             /* Error: Need to re-allocate what was freed */
-            retVal = RM_ERROR_TRANS_REQ_TO_SERVER_NOT_CREATED;    
+            retVal = RM_ERROR_TRANS_REQ_TO_SERVER_NOT_CREATED;
         }
-    }    
-    return (retVal);
+    }
+    return(retVal);
 }
 
 /* FUNCTION PURPOSE: Arbitrates allocation service requests
@@ -531,87 +545,86 @@ static void allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)
 
     if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
         if (transaction->resourceInfo.base != RM_RESOURCE_BASE_UNSPECIFIED) {
-            if (rmAllocatorFind((Rm_Handle)rmInst, transaction->resourceInfo.name)) {
-                /* Attempt to allocate from local resources that were provided by Server */
+            if (rmAllocatorFind((Rm_Handle)rmInst,
+                                transaction->resourceInfo.name)) {
+                /* Attempt to allocate from local resources that were provided
+                 * by Server */
                 if (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) {
                     opInfo.operation = Rm_allocatorOp_ALLOCATE_INIT;
-                }
-                else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) {
+                } else if (transaction->type ==
+                           Rm_service_RESOURCE_ALLOCATE_USE) {
                     opInfo.operation = Rm_allocatorOp_ALLOCATE_USE;
-                }
-                else {
+                } else {
                     retVal = RM_ERROR_INVALID_SERVICE_TYPE;
                     goto errorExit;
                 }
                 retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
 
                 if (retVal == RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST) {
-                    /* Request resource range was not found within local resources
-                     * provided by Server.  Set back to PROCESSING so request is forwarded to
-                     * Server */
+                    /* Request resource range was not found within local
+                     * resources provided by Server.  Set back to PROCESSING so
+                     * request is forwarded to Server */
                     retVal = RM_SERVICE_PROCESSING;
                 }
             }
-        }
-        else {
-            if (rmAllocatorFind((Rm_Handle)rmInst, transaction->resourceInfo.name)) {
+        } else {
+            if (rmAllocatorFind((Rm_Handle)rmInst,
+                                transaction->resourceInfo.name)) {
                 int32_t oldAlign = transaction->resourceInfo.alignment;
-                
-                /* Attempt to allocate from local resources that were provided by Server */
+
+                /* Attempt to allocate from local resources that were provided
+                 * by Server */
                 if (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) {
                     opInfo.operation = Rm_allocatorOp_PRE_ALLOCATE_INIT;
-                }
-                else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) {
+                } else if (transaction->type ==
+                         Rm_service_RESOURCE_ALLOCATE_USE) {
                     opInfo.operation = Rm_allocatorOp_PRE_ALLOCATE_USE;
-                }
-                else {
+                } else {
                     retVal = RM_ERROR_INVALID_SERVICE_TYPE;
                     goto errorExit;
                 }
                 retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
-                
+
                 if (retVal == RM_SERVICE_PROCESSING) {
-                    if (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) {
+                    if (transaction->type ==
+                        Rm_service_RESOURCE_ALLOCATE_INIT) {
                         opInfo.operation = Rm_allocatorOp_ALLOCATE_INIT;
-                    }
-                    else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) {
+                    } else if (transaction->type ==
+                               Rm_service_RESOURCE_ALLOCATE_USE) {
                         opInfo.operation = Rm_allocatorOp_ALLOCATE_USE;
-                    }
-                    else {
+                    } else {
                         retVal = RM_ERROR_INVALID_SERVICE_TYPE;
                         goto errorExit;
                     }
                     retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
 
                     if (retVal == RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST) {
-                        /* Request resource range was not found within local resources
-                         * provided by Server.  Set back to PROCESSING so request is forwarded to
-                         * Server */
+                        /* Request resource range was not found within local
+                         * resources provided by Server.  Set back to
+                         * PROCESSING so request is forwarded to Server */
                         retVal = RM_SERVICE_PROCESSING;
-                    }                    
-                }
-                else if (retVal == RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET) {
+                    }
+                } else if (retVal == RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET) {
                     if (transaction->pendingTransactionId) {
-                        /* Request to Server for resources to complete transaction locally
-                         * performed once already.  Forward transaction to Server for completion */
+                        /* Request to Server for resources to complete
+                         * transaction locally performed once already.  Forward
+                         * transaction to Server for completion */
                         retVal = RM_SERVICE_PROCESSING;
-                    }
-                    else {
-                        /* Restore base and alignment since they were replaced in pre-allocate routine */
+                    } else {
+                        /* Restore base and alignment since they were replaced
+                         * in pre-allocate routine */
                         transaction->resourceInfo.base = RM_RESOURCE_BASE_UNSPECIFIED;
                         transaction->resourceInfo.alignment = oldAlign;
-                        
+
                         retVal = cdRequestServerResources(rmInst, transaction);
                     }
                 }
-            }
-            else {
+            } else {
                 retVal = cdRequestServerResources(rmInst, transaction);
-            }                
+            }
         }
-    }
-    else if ((rmInst->instType == Rm_instType_SERVER)||
-             (rmInst->instType == Rm_instType_SHARED_SERVER)) {
+    } else if ((rmInst->instType == Rm_instType_SERVER)||
+               (rmInst->instType == Rm_instType_SHARED_SERVER)) {
         /* Populated NameServer name has precedence over base */
         if (strlen(transaction->resourceInfo.nameServerName) > 0) {
             if (rmInst->instType == Rm_instType_SHARED_SERVER) {
@@ -620,12 +633,14 @@ static void allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)
             memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
             nameServerObjCfg.nameServerTree = rmInst->u.server.nameServer;
             nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
-            if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) == RM_SERVICE_PROCESSING) {
-                rm_strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);
+            if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) ==
+                RM_SERVICE_PROCESSING) {
+                rm_strncpy(transaction->resourceInfo.name,
+                           nameServerObjCfg.nodeCfg.resourceName,
+                           RM_NAME_MAX_CHARS);
                 transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;
                 transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;
-            }
-            else {
+            } else {
                 goto errorExit;
             }
         }
@@ -633,33 +648,29 @@ static void allocationHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)
         if (transaction->resourceInfo.base == RM_RESOURCE_BASE_UNSPECIFIED) {
             if (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) {
                 opInfo.operation = Rm_allocatorOp_PRE_ALLOCATE_INIT;
-            }
-            else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) {
+            } else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) {
                 opInfo.operation = Rm_allocatorOp_PRE_ALLOCATE_USE;
-            }
-            else {
+            } else {
                 retVal = RM_ERROR_INVALID_SERVICE_TYPE;
                 goto errorExit;
             }
             retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
         }
-    
+
         if (retVal == RM_SERVICE_PROCESSING) {
             if (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) {
                 opInfo.operation = Rm_allocatorOp_ALLOCATE_INIT;
-            }
-            else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) {
+            } else if (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) {
                 opInfo.operation = Rm_allocatorOp_ALLOCATE_USE;
-            }
-            else {
+            } else {
                 retVal = RM_ERROR_INVALID_SERVICE_TYPE;
                 goto errorExit;
             }
             retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
-        }             
+        }
     }
-errorExit:        
-    transaction->state = retVal;      
+errorExit:
+    transaction->state = retVal;
 }
 
 /* FUNCTION PURPOSE: Handles resource status service requests
@@ -682,7 +693,7 @@ static void statusHandler(Rm_Inst *rmInst, Rm_Transaction *transaction)
     if (opInfo.serviceInstNode == NULL) {
         retVal = RM_SERVICE_DENIED_INST_NAME_NOT_VALID;
         goto errorExit;
-    }     
+    }
 
     if ((strlen(transaction->resourceInfo.nameServerName) == 0) &&
         ((transaction->resourceInfo.base == RM_RESOURCE_BASE_UNSPECIFIED) ||
@@ -692,21 +703,23 @@ static void statusHandler(Rm_Inst *rmInst, Rm_Transaction *transaction)
     }
 
     if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
-        if (rmAllocatorFind((Rm_Handle)rmInst, transaction->resourceInfo.name)) {
-            /* Attempt to get status from local resources that were provided by Server */
+        if (rmAllocatorFind((Rm_Handle)rmInst,
+                            transaction->resourceInfo.name)) {
+            /* Attempt to get status from local resources that were provided by
+             * Server */
             retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
 
             if (retVal == RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST) {
-                /* Request resource range was not found within local allocator resources
-                 * provided by Server.  Set back to PROCESSING so request is forwarded to
-                 * Server */
+                /* Request resource range was not found within local allocator
+                 * resources provided by Server.  Set back to PROCESSING so
+                 * request is forwarded to Server */
                 retVal = RM_SERVICE_PROCESSING;
-            }            
+            }
         }
-    }
-    else if ((rmInst->instType == Rm_instType_SERVER)||
-             (rmInst->instType == Rm_instType_SHARED_SERVER)) {
-        /* Populated NameServer name has precedence over base and length values */
+    } else if ((rmInst->instType == Rm_instType_SERVER)||
+               (rmInst->instType == Rm_instType_SHARED_SERVER)) {
+        /* Populated NameServer name has precedence over base and length
+         * values */
         if (strlen(transaction->resourceInfo.nameServerName) > 0) {
             if (rmInst->instType == Rm_instType_SHARED_SERVER) {
                 rmNameServerTreeInv(rmInst->u.server.nameServer);
@@ -714,12 +727,14 @@ static void statusHandler(Rm_Inst *rmInst, Rm_Transaction *transaction)
             memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
             nameServerObjCfg.nameServerTree = rmInst->u.server.nameServer;
             nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
-            if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) == RM_SERVICE_PROCESSING) {
-                rm_strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);
+            if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) ==
+                RM_SERVICE_PROCESSING) {
+                rm_strncpy(transaction->resourceInfo.name,
+                           nameServerObjCfg.nodeCfg.resourceName,
+                           RM_NAME_MAX_CHARS);
                 transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;
                 transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;
-            }
-            else {
+            } else {
                 goto errorExit;
             }
         }
@@ -770,16 +785,14 @@ static void freeHandler(Rm_Inst *rmInst, Rm_Transaction *transaction)
             /* Check if free allows local resources to be freed back to
              * Server */
             retVal = cdFreeResourcesToServer(rmInst, transaction);
-        }
-        else if ((retVal == RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST) ||
+        } else if ((retVal == RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST) ||
                  (retVal == RM_SERVICE_DENIED_RES_DOES_NOT_EXIST)) {
             /* Requested resource or its range were not found within local
              * allocator resources provided by Server.  Set back to PROCESSING
              * so request is forwarded to Server */
             retVal = RM_SERVICE_PROCESSING;
         }
-    }
-    else if ((rmInst->instType == Rm_instType_SERVER) ||
+    } else if ((rmInst->instType == Rm_instType_SERVER) ||
              (rmInst->instType == Rm_instType_SHARED_SERVER)) {
         /* Populated NameServer name has precedence over base */
         if (strlen(transaction->resourceInfo.nameServerName) > 0) {
@@ -789,20 +802,21 @@ static void freeHandler(Rm_Inst *rmInst, Rm_Transaction *transaction)
             memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
             nameServerObjCfg.nameServerTree = rmInst->u.server.nameServer;
             nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
-            if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) == RM_SERVICE_PROCESSING) {
-                rm_strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);
+            if ((retVal = rmNameServerFindObject(&nameServerObjCfg)) ==
+                RM_SERVICE_PROCESSING) {
+                rm_strncpy(transaction->resourceInfo.name,
+                           nameServerObjCfg.nodeCfg.resourceName,
+                           RM_NAME_MAX_CHARS);
                 transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;
                 transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;
-            }
-            else {
+            } else {
                 goto errorExit;
-            }             
+            }
         }
-             
-        retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);     
-    }   
+        retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
+    }
 errorExit:
-    transaction->state = retVal;       
+    transaction->state = retVal;
 }
 
 /* FUNCTION PURPOSE: Client transaction handling process
@@ -815,19 +829,17 @@ errorExit:
  *                  - Forwards all service requests to CD or Server
  *                    once transport has been registered
  */
-static void clientProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
+static void clientProcess(Rm_Inst *rmInst, Rm_Transaction *transaction)
 {
     Rm_Transaction *transQ;
-    
+
     if (!rmInst->registeredWithDelegateOrServer) {
         staticAllocationHandler((Rm_Handle)rmInst, transaction);
-    }
-    else {
+    } else {
         if (transaction->state == RM_SERVICE_PROCESSING) {
             /* Forward all new transactions to CD or Server */
-            transactionForwarder(rmInst, transaction);                
-        }
-        else {
+            transactionForwarder(rmInst, transaction);
+        } else {
             /* Transaction validated.  Return result. */
             serviceResponder(rmInst, transaction);
         }
@@ -840,7 +852,7 @@ static void clientProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
                 transactionForwarder(rmInst, transQ);
             }
             transQ = transQ->nextTransaction;
-        }        
+        }
     }
     /* Let call stack return transaction result app via Rm_serviceHandler */
 }
@@ -857,7 +869,7 @@ static void clientProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
  *                  - Attempts to complete resource service requests
  *                    received from registered Clients
  */
-static void cdProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
+static void cdProcess(Rm_Inst *rmInst, Rm_Transaction *transaction)
 {      
     Rm_Transaction   *newTrans = NULL;
     Rm_AllocatorNode *allocator = NULL;
@@ -865,39 +877,47 @@ static void cdProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
 
     if (!rmInst->registeredWithDelegateOrServer) {
         if ((transaction->state == RM_SERVICE_PROCESSING) &&
-            (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS) == 0)) {
+            (strncmp(transaction->serviceSrcInstName, rmInst->instName,
+             RM_NAME_MAX_CHARS) == 0)) {
             /* Attempt static allocation of requests originating from CD inst */
             staticAllocationHandler((Rm_Handle)rmInst, transaction);
         }
-        /* Everything else left in transaction queue for forwarding once transport to
-         * Server is registered */
-    }
-    else {
+        /* Everything else left in transaction queue for forwarding once
+         * transport to Server is registered */
+    } else {
         if (transaction->pendingTransactionId) {
-            Rm_Transaction *pendingTrans = rmTransactionQueueFind(rmInst, transaction->pendingTransactionId);
+            Rm_Transaction *pendingTrans = rmTransactionQueueFind(rmInst,
+                                             transaction->pendingTransactionId);
             
             /* Transaction is response from Server for transaction sent to get
              * information in order to complete pending transaction */
             if (transaction->state == RM_SERVICE_APPROVED) {
                 if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) {
                     /* Transfer resource data tied to name to pending transaction */
-                    rm_strncpy(pendingTrans->resourceInfo.name, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
+                    rm_strncpy(pendingTrans->resourceInfo.name,
+                               transaction->resourceInfo.name,
+                               RM_NAME_MAX_CHARS);
                     pendingTrans->resourceInfo.base = transaction->resourceInfo.base;
                     pendingTrans->resourceInfo.length = transaction->resourceInfo.length;
-                    /* Delete NS name from pending transaction so Server isn't queried again */
-                    memset(pendingTrans->resourceInfo.nameServerName, 0, RM_NAME_MAX_CHARS);
-                    /* Now that resource values have been retrieved clear pending transaction ID so 
-                     * CD doesn't think a resource request was sent to Server already for more local resources */
+                    /* Delete NS name from pending transaction so Server isn't
+                     * queried again */
+                    memset(pendingTrans->resourceInfo.nameServerName, 0,
+                           RM_NAME_MAX_CHARS);
+                    /* Now that resource values have been retrieved clear
+                     * pending transaction ID so CD doesn't think a resource
+                     * request was sent to Server already for more local
+                     * resources */
                     pendingTrans->pendingTransactionId = 0;
 
-                    /* Return original transaction to processing state to attempt completion. */
+                    /* Return original transaction to processing state to
+                     * attempt completion. */
                     pendingTrans->state = RM_SERVICE_PROCESSING;
-                }
-                else if ((transaction->type ==
-                          Rm_service_RESOURCE_ALLOCATE_INIT) ||
-                         (transaction->type ==
-                          Rm_service_RESOURCE_ALLOCATE_USE)) {
-                    /* Add resources provided by Server to those managed by CD */
+                } else if ((transaction->type ==
+                            Rm_service_RESOURCE_ALLOCATE_INIT) ||
+                           (transaction->type ==
+                            Rm_service_RESOURCE_ALLOCATE_USE)) {
+                    /* Add resources provided by Server to those managed by
+                     * CD */
                     if ((allocator = rmAllocatorFind((Rm_Handle)rmInst,
                                              transaction->resourceInfo.name))) {
                         rmAllocatorAddResNode((Rm_Handle)rmInst,
@@ -906,10 +926,10 @@ static void cdProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
                                               transaction->resourceInfo.length);
                     }
 
-                    /* Return original transaction to processing state to attempt completion */
+                    /* Return original transaction to processing state to
+                     * attempt completion */
                     pendingTrans->state = RM_SERVICE_PROCESSING;
-                }
-                else if (transaction->type == Rm_service_RESOURCE_FREE) {
+                } else if (transaction->type == Rm_service_RESOURCE_FREE) {
                     allocator = rmAllocatorFind((Rm_Handle)rmInst,
                                                 transaction->resourceInfo.name);
 
@@ -923,20 +943,22 @@ static void cdProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
                     /* Allow original free to complete */
                     pendingTrans->state = RM_SERVICE_APPROVED;
                 }
-            }
-            else {
+            } else {
                 if (transaction->type == Rm_service_RESOURCE_FREE) {
-                    /* Error occurred when trying to free local resource on Server.  Reinsert local
-                     * resources freed by original request */
+                    /* Error occurred when trying to free local resource on
+                     * Server.  Reinsert local resources freed by original
+                     * request */
                     Rm_AllocatorOpInfo   opInfo;
 
                     memset((void *)&opInfo, 0, sizeof(Rm_AllocatorOpInfo));
                     opInfo.resourceInfo = &pendingTrans->resourceInfo;
                     opInfo.serviceInstNode = rmPolicyGetValidInstNode((Rm_Handle)rmInst,
-                                                        pendingTrans->serviceSrcInstName);
-                    /* Can't regain the original type of allocate.  Default to init */
+                                              pendingTrans->serviceSrcInstName);
+                    /* Can't regain the original type of allocate.  Default to
+                     * init */
                     opInfo.operation = Rm_allocatorOp_ALLOCATE_INIT;
-                    if (rmAllocatorOperation((Rm_Handle)rmInst, &opInfo) != RM_SERVICE_APPROVED) {
+                    if (rmAllocatorOperation((Rm_Handle)rmInst, &opInfo) !=
+                        RM_SERVICE_APPROVED) {
                         transaction->state = RM_ERROR_LOST_RESOURCES_ON_CD;
                     }
                 }
@@ -947,65 +969,64 @@ static void cdProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
             /* Switch to pending transaction */
             transaction = pendingTrans;
         }
-        
+
         if ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
             (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||
             (transaction->type == Rm_service_RESOURCE_STATUS) ||
             (transaction->type == Rm_service_RESOURCE_FREE)) {
             if ((transaction->state == RM_SERVICE_PROCESSING) &&
-                (strlen(transaction->resourceInfo.nameServerName) > 0)) {   
+                (strlen(transaction->resourceInfo.nameServerName) > 0)) {
                 /* Create and forward new transaction to Server to
                  * retrieve resource data mapped to name */
                 if ((newTrans = rmTransactionQueueAdd(rmInst))) {
                     newTrans->type = Rm_service_RESOURCE_GET_BY_NAME;
-                    rm_strncpy(newTrans->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS);
-                    newTrans->state = RM_SERVICE_PROCESSING;       
-                    rm_strncpy(newTrans->resourceInfo.nameServerName, transaction->resourceInfo.nameServerName, 
-                            RM_NAME_MAX_CHARS);
+                    rm_strncpy(newTrans->serviceSrcInstName, rmInst->instName,
+                               RM_NAME_MAX_CHARS);
+                    newTrans->state = RM_SERVICE_PROCESSING;
+                    rm_strncpy(newTrans->resourceInfo.nameServerName,
+                               transaction->resourceInfo.nameServerName,
+                               RM_NAME_MAX_CHARS);
                     newTrans->pendingTransactionId = transaction->localId;
                     transactionForwarder(rmInst, newTrans);
 
                     transaction->state = RM_SERVICE_PENDING_SERVER_RESPONSE;
+                } else {
+                    transaction->state = RM_ERROR_TRANS_REQ_TO_SERVER_NOT_CREATED;
                 }
-                else {
-                    transaction->state = RM_ERROR_TRANS_REQ_TO_SERVER_NOT_CREATED;    
-                }        
-            }                
+            }
         }
 
         if ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
             (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE)) {
-            if (transaction->state == RM_SERVICE_PROCESSING) {   
+            if (transaction->state == RM_SERVICE_PROCESSING) {
                 allocationHandler(rmInst, transaction);
             }
-        }
-        else if (transaction->type == Rm_service_RESOURCE_STATUS) {
-            if (transaction->state == RM_SERVICE_PROCESSING) {   
+        } else if (transaction->type == Rm_service_RESOURCE_STATUS) {
+            if (transaction->state == RM_SERVICE_PROCESSING) {
                 statusHandler(rmInst, transaction);
-            }               
-        }        
-        else if (transaction->type == Rm_service_RESOURCE_FREE) {     
+            }
+        } else if (transaction->type == Rm_service_RESOURCE_FREE) {
             if (transaction->state == RM_SERVICE_PROCESSING) {
                 freeHandler(rmInst, transaction);
-            }     
+            }
         }
         /* Forward all NameServer-based transactions */
 
         if (transaction->state == RM_SERVICE_PROCESSING) {
             /* CD could not complete transaction.  Forward to Server */
             transactionForwarder(rmInst, transaction);
-        }
-        else if (transaction->state != RM_SERVICE_PENDING_SERVER_RESPONSE) {
-            /* Transaction completed by CD or completed response received from Server.  Return result */
-            if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {
+        } else if (transaction->state != RM_SERVICE_PENDING_SERVER_RESPONSE) {
+            /* Transaction completed by CD or completed response received from
+             * Server.  Return result */
+            if (strncmp(transaction->serviceSrcInstName, rmInst->instName,
+                RM_NAME_MAX_CHARS)) {
                 /* Transaction did not originate on this instance */
                 transactionResponder(rmInst, transaction);
-            }
-            else {
+            } else {
                 /* Transaction originated on this instance */
                 serviceResponder(rmInst, transaction);
-            }                    
-        }           
+            }
+        }
 
         /* Attempt allocation of any queued static requests:
          * RM_SERVICE_APPROVED_STATIC - Originated locally
@@ -1018,7 +1039,7 @@ static void cdProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
                 transactionForwarder(rmInst, transQ);
             }
             transQ = transQ->nextTransaction;
-        }        
+        }
     }
 }
 
@@ -1031,7 +1052,7 @@ static void cdProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
  *                    the service handle and registered CDs and
  *                    Clients
  */
-static void serverProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
+static void serverProcess(Rm_Inst *rmInst, Rm_Transaction *transaction)
 {
     Rm_NameServerObjCfg  nameServerObjCfg;
 
@@ -1053,7 +1074,8 @@ static void serverProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
                 if (rmInst->instType == Rm_instType_SHARED_SERVER) {
                     rmNameServerTreeInv(rmInst->u.server.nameServer);
                 }                
-                memset((void *)&nameServerObjCfg, 0, sizeof(Rm_NameServerObjCfg));
+                memset((void *)&nameServerObjCfg, 0,
+                       sizeof(Rm_NameServerObjCfg));
                 nameServerObjCfg.nameServerTree = rmInst->u.server.nameServer;
                 nameServerObjCfg.nodeCfg.objName = transaction->resourceInfo.nameServerName;
                 if (transaction->type == Rm_service_RESOURCE_MAP_TO_NAME) {
@@ -1061,25 +1083,26 @@ static void serverProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
                     nameServerObjCfg.nodeCfg.resourceBase= transaction->resourceInfo.base;
                     nameServerObjCfg.nodeCfg.resourceLength = transaction->resourceInfo.length;
                     transaction->state = rmNameServerAddObject(&nameServerObjCfg);
-                }
-                else if (transaction->type == Rm_service_RESOURCE_GET_BY_NAME) {
+                } else if (transaction->type ==
+                           Rm_service_RESOURCE_GET_BY_NAME) {
                     if ((transaction->state = rmNameServerFindObject(&nameServerObjCfg)) ==
                         RM_SERVICE_PROCESSING) {
-                        rm_strncpy(transaction->resourceInfo.name, nameServerObjCfg.nodeCfg.resourceName, RM_NAME_MAX_CHARS);
+                        rm_strncpy(transaction->resourceInfo.name,
+                                   nameServerObjCfg.nodeCfg.resourceName,
+                                   RM_NAME_MAX_CHARS);
                         transaction->resourceInfo.base = nameServerObjCfg.nodeCfg.resourceBase;
                         transaction->resourceInfo.length = nameServerObjCfg.nodeCfg.resourceLength;
                         transaction->state = RM_SERVICE_APPROVED;
-                    } 
-                }
-                else if (transaction->type == Rm_service_RESOURCE_UNMAP_NAME) {
+                    }
+                } else if (transaction->type ==
+                           Rm_service_RESOURCE_UNMAP_NAME) {
                     transaction->state = rmNameServerDeleteObject(&nameServerObjCfg);
                 }
-                
+
                 if (rmInst->instType == Rm_instType_SHARED_SERVER) {
                     rmNameServerTreeWb(rmInst->u.server.nameServer);
                 }
-            }
-            else {
+            } else {
                 transaction->state = RM_ERROR_NAMESERVER_DOES_NOT_EXIST;
             }
             break;
@@ -1090,12 +1113,15 @@ static void serverProcess (Rm_Inst *rmInst, Rm_Transaction *transaction)
 
     /* Source of shared server transaction will always be local. */
     if (rmInst->instType != Rm_instType_SHARED_SERVER) {
-        if (strncmp(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS)) {
-            /* Source of transaction was not Server, return transaction via responder */
+        if (strncmp(transaction->serviceSrcInstName, rmInst->instName,
+                    RM_NAME_MAX_CHARS)) {
+            /* Source of transaction was not Server, return transaction via
+             * responder */
             transactionResponder(rmInst, transaction);
         }
     }
-    /* Otherwise let call stack return transaction result app via Rm_serviceHandler */ 
+    /* Otherwise let call stack return transaction result app via
+     * Rm_serviceHandler */ 
 }
 
 /**********************************************************************
@@ -1125,12 +1151,11 @@ Rm_Transaction *rmTransactionQueueAdd(Rm_Inst *rmInst)
                 transactionQueue = transactionQueue->nextTransaction;
             }
             transactionQueue->nextTransaction = newTransaction;
-        }
-        else {
+        } else {
             rmInst->transactionQueue = newTransaction;
         }
     }
-    return (newTransaction);
+    return(newTransaction);
 }
 
 /* FUNCTION PURPOSE: Finds a transaction
@@ -1145,12 +1170,12 @@ Rm_Transaction *rmTransactionQueueFind(Rm_Inst *rmInst, uint32_t transactionId)
 
     while (transaction) {
         if (transaction->localId == transactionId) {
-            break;             
+            break;
         }
         transaction = transaction->nextTransaction;
     }
 
-    return (transaction);
+    return(transaction);
 }
 
 /* FUNCTION PURPOSE: Deletes a transaction
@@ -1160,13 +1185,13 @@ Rm_Transaction *rmTransactionQueueFind(Rm_Inst *rmInst, uint32_t transactionId)
  */
 int32_t rmTransactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId)
 {
-    Rm_Transaction *transaction     = rmInst->transactionQueue;
+    Rm_Transaction *transaction = rmInst->transactionQueue;
     Rm_Transaction *prevTransaction = NULL;
-    int32_t         retVal          = RM_OK;
+    int32_t         retVal = RM_OK;
 
     while (transaction) {
         if (transaction->localId == transactionId) {
-            break;             
+            break;
         }
 
         prevTransaction = transaction;
@@ -1175,20 +1200,18 @@ int32_t rmTransactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId)
 
     if (transaction) {
         if (prevTransaction == NULL) {
-            /* Transaction at start of queue. Map second transaction to start of queue 
-             * as long as more than one transactions. */
+            /* Transaction at start of queue. Map second transaction to start
+             * of queue as long as more than one transactions. */
             rmInst->transactionQueue = transaction->nextTransaction;
-        }
-        else {
+        } else {
             /* Transaction in middle or end of queue. */
             prevTransaction->nextTransaction = transaction->nextTransaction;
         }
         Rm_osalFree((void *)transaction, sizeof(Rm_Transaction));
-    }
-    else {
+    } else {
         retVal = RM_ERROR_SERVICE_TRANS_DOES_NOT_EXIST;
-    }    
-    return (retVal);
+    }
+    return(retVal);
 }
 
 /* FUNCTION PURPOSE: Routes a transaction for processing
@@ -1200,16 +1223,14 @@ void rmProcessRouter (Rm_Inst *rmInst, Rm_Transaction *transaction)
 {
     if (rmInst->instType == Rm_instType_CLIENT) {
         clientProcess(rmInst, transaction);
-    }
-    else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
+    } else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
         cdProcess(rmInst, transaction);
-    }
-    else if ((rmInst->instType == Rm_instType_SERVER) ||
-             (rmInst->instType == Rm_instType_SHARED_SERVER)) {
+    } else if ((rmInst->instType == Rm_instType_SERVER) ||
+               (rmInst->instType == Rm_instType_SHARED_SERVER)) {
         serverProcess(rmInst, transaction);
-    } 
+    }
 }
-     
+
 /**********************************************************************
  ********************** Application visible APIs **********************
  **********************************************************************/
@@ -1243,7 +1264,7 @@ int32_t Rm_resourceStatus(Rm_Handle rmHandle, int printResources)
 
     if (rmInst->instType != Rm_instType_CLIENT) {
         Rm_osalLog("Instance name: %s\n", rmInst->instName);
-        Rm_osalLog("Handle: 0x%08x\n", rmHandle);    
+        Rm_osalLog("Handle: 0x%08x\n", rmHandle);
         if (rmInst->instType == Rm_instType_SERVER) {
             Rm_osalLog("Type:   Server\n");
         } else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
@@ -1361,17 +1382,13 @@ void Rm_instanceStatus(Rm_Handle rmHandle)
     Rm_osalLog("Handle: 0x%08x\n", rmHandle);    
     if (rmInst->instType == Rm_instType_SERVER) {
         Rm_osalLog("Type:   Server\n");
-    }
-    else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
+    } else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
         Rm_osalLog("Type:   Client Delegate\n");
-    }
-    else if (rmInst->instType == Rm_instType_CLIENT) {
+    } else if (rmInst->instType == Rm_instType_CLIENT) {
         Rm_osalLog("Type:   Client\n");
-    }
-    else if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+    } else if (rmInst->instType == Rm_instType_SHARED_SERVER) {
         Rm_osalLog("Type:   Shared Server\n");
-    }
-    else if (rmInst->instType == Rm_instType_SHARED_CLIENT) {
+    } else if (rmInst->instType == Rm_instType_SHARED_CLIENT) {
         Rm_osalLog("Type:   Shared Client\n");
 
         Rm_osalLog("\nShared Server Properties:\n");
@@ -1381,7 +1398,7 @@ void Rm_instanceStatus(Rm_Handle rmHandle)
         Rm_osalLog("Instance name: %s\n", rmInst->instName);
         Rm_osalLog("Handle: 0x%08x\n", rmHandle);
     }
-    
+
     transportList = rmInst->transports;
     if (transportList) {
         Rm_osalLog("\nRegistered Transports:\n");
@@ -1389,14 +1406,14 @@ void Rm_instanceStatus(Rm_Handle rmHandle)
             RM_SS_OBJ_INV(rmInst, transportList, Rm_Transport);
             if (transportList->remoteInstType == Rm_instType_SERVER) {
                 Rm_osalLog("    Remote instType:    Server\n");
-            }
-            else if (transportList->remoteInstType == Rm_instType_CLIENT_DELEGATE) {
+            } else if (transportList->remoteInstType ==
+                       Rm_instType_CLIENT_DELEGATE) {
                 Rm_osalLog("    Remote instType:    Client Delegate\n");
-            }
-            else {
+            } else {
                 Rm_osalLog("    Remote instType:    Client\n");
             }
-            Rm_osalLog("    appTransportHandle: 0x%08x\n", transportList->appTransportHandle);
+            Rm_osalLog("    appTransportHandle: 0x%08x\n",
+                       transportList->appTransportHandle);
             Rm_osalLog("\n");
             transportList = transportList->nextTransport;
         }
@@ -1407,26 +1424,33 @@ void Rm_instanceStatus(Rm_Handle rmHandle)
         Rm_osalLog("\nQueued Service Transactions:\n");
         while (transactionQ) {
             RM_SS_OBJ_INV(rmInst, transactionQ, Rm_Transaction);
-            Rm_osalLog("    Service type:       %d\n", transactionQ->type);
+            Rm_osalLog("    Service type:       %d\n",
+                       transactionQ->type);
             Rm_osalLog("    Service ID:         %d\n", transactionQ->localId);
-            Rm_osalLog("    Service srcInstName %s\n", transactionQ->serviceSrcInstName);
+            Rm_osalLog("    Service srcInstName %s\n",
+                       transactionQ->serviceSrcInstName);
             Rm_osalLog("    Service state:      %d\n", transactionQ->state);
-            Rm_osalLog("    Resource name:      %s\n", transactionQ->resourceInfo.name);
-            Rm_osalLog("    Resource base:      %d\n", transactionQ->resourceInfo.base);
-            Rm_osalLog("    Resource length:    %d\n", transactionQ->resourceInfo.length);
-            Rm_osalLog("    Resource alignment: %d\n", transactionQ->resourceInfo.alignment);
-            Rm_osalLog("    Resource NS name:   %s\n", transactionQ->resourceInfo.nameServerName);
+            Rm_osalLog("    Resource name:      %s\n",
+                       transactionQ->resourceInfo.name);
+            Rm_osalLog("    Resource base:      %d\n",
+                       transactionQ->resourceInfo.base);
+            Rm_osalLog("    Resource length:    %d\n",
+                       transactionQ->resourceInfo.length);
+            Rm_osalLog("    Resource alignment: %d\n",
+                       transactionQ->resourceInfo.alignment);
+            Rm_osalLog("    Resource NS name:   %s\n",
+                       transactionQ->resourceInfo.nameServerName);
             Rm_osalLog("\n");
             transactionQ = transactionQ->nextTransaction;
-        }    
+        }
     }
-    
-    /* Free sem object using originating instance in case the Shared Client to Shared
-     * Server instance switch took place */
+
+    /* Free sem object using originating instance in case the Shared Client
+     * to Shared Server instance switch took place */
     if (((Rm_Inst *)rmHandle)->mtSemObj) {
         Rm_osalMtCsExit(((Rm_Inst *)rmHandle)->mtSemObj, mtKey);
-    }    
-    RM_SS_INST_WB_EXIT_CS(rmInst, key);    
+    }
+    RM_SS_INST_WB_EXIT_CS(rmInst, key);
 }
 
 /* FUNCTION PURPOSE: RM instance creation and initialization
index 420fffd5330a10e3df23f79d4b4cbf3841c0540a..8864f5ed8cfdce19e6bbc616aa728b8de1da95c3 100644 (file)
@@ -166,14 +166,13 @@ static void allocatorResNodeOwnerAdd(Rm_Handle rmHandle, Rm_ResourceNode *node,
 
     if (allocatorResNodeIsOwnedBy(rmHandle, node, serviceInstNode)) {
         allocatorResNodeOwnerRefCntInc(rmHandle, node, serviceInstNode);
-    }
-    else {
+    } else {
         newOwner = Rm_osalMalloc(sizeof(*newOwner));
 
         if (newOwner) {
             newOwner->instNameNode = serviceInstNode;
             newOwner->refCnt = 0;
-            newOwner->nextOwner = NULL;  
+            newOwner->nextOwner = NULL;
 
             /* Add owner entry to end of list */
             if (ownerList) {
@@ -184,8 +183,7 @@ static void allocatorResNodeOwnerAdd(Rm_Handle rmHandle, Rm_ResourceNode *node,
                 }
                 ownerList->nextOwner = newOwner;
                 RM_SS_OBJ_WB(rmInst, ownerList, Rm_Owner);
-            }
-            else {
+            } else {
                 node->ownerList = newOwner;
             }
 
@@ -193,7 +191,8 @@ static void allocatorResNodeOwnerAdd(Rm_Handle rmHandle, Rm_ResourceNode *node,
             newOwner->refCnt++;
             newOwner->instNameNode->allocRefCount++;
             RM_SS_OBJ_WB(rmInst, newOwner, Rm_Owner);
-            RM_SS_OBJ_WB(rmInst, newOwner->instNameNode, Rm_PolicyValidInstNode);
+            RM_SS_OBJ_WB(rmInst, newOwner->instNameNode,
+                         Rm_PolicyValidInstNode);
         }
     }
 }
@@ -217,11 +216,10 @@ static int allocatorResNodeBoundaryCompare(Rm_ResourceNode *node1,
             if (node1End == (node2->base - 1)) {
                 return(RM_TRUE);
             }
-        }
-        else if (node2->base < node1->base) {
+        } else if (node2->base < node1->base) {
             if (node2End == (node1->base - 1)) {
                 return(RM_TRUE);
-            }     
+            }
         }
     }
     return(RM_FALSE);
@@ -265,16 +263,14 @@ static int allocatorResNodeOwnerCompare(Rm_Handle rmHandle,
             if (matchedInst) {
                 node2Owners = node2->ownerList;
                 node1Owners = node1Owners->nextOwner;
-            }
-            else {
+            } else {
                 return(RM_FALSE);
-            }                
+            }
         }
-    }
-    else {
+    } else {
         return(RM_FALSE);
-    }  
-    
+    }
+
     return(RM_TRUE);
 }
 
@@ -295,12 +291,11 @@ static void allocatorResNodeOwnerDelete(Rm_Handle rmHandle,
 
     if (allocatorResNodeIsOwnedBy(rmHandle, node, serviceInstNode) > 1) {
         allocatorResNodeOwnerRefCntDec(rmHandle, node, serviceInstNode);
-    }
-    else {
+    } else {
         while (owner) {
             RM_SS_OBJ_INV(rmInst, owner, Rm_Owner);
             if (owner->instNameNode == serviceInstNode) {
-                break;             
+                break;
             }
             prevOwner = owner;
             owner = owner->nextOwner;
@@ -309,12 +304,11 @@ static void allocatorResNodeOwnerDelete(Rm_Handle rmHandle,
         if (owner) {
             if (prevOwner == NULL) {
                 node->ownerList = owner->nextOwner;
-            }
-            else {
+            } else {
                 prevOwner->nextOwner = owner->nextOwner;
                 RM_SS_OBJ_WB(rmInst, prevOwner, Rm_Owner);
             }
-            
+
             node->allocationCount--;
             owner->instNameNode->allocRefCount--;
             RM_SS_OBJ_WB(rmInst, owner->instNameNode, Rm_PolicyValidInstNode);
@@ -355,8 +349,7 @@ static void allocatorResNodeOwnerCopy(Rm_Handle rmHandle,
 
         if (dstNode->ownerList == NULL) {
             dstNode->ownerList = dstNewOwner;
-        }
-        else {
+        } else {
             dstPrevOwner->nextOwner = dstNewOwner;
             RM_SS_OBJ_WB(rmInst, dstPrevOwner, Rm_Owner);
         }
@@ -417,15 +410,13 @@ static int32_t allocatorStatus(Rm_Handle rmHandle, Rm_AllocatorNode *allocator,
         if ((findNode.base >= matchingNode->base) && (findEnd <= matchingEnd)) {
             opInfo->resourceInfo->ownerCount = matchingNode->allocationCount;
             opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
-                                                                                  matchingNode,
-                                                                                  opInfo->serviceInstNode);
+                                                      matchingNode,
+                                                      opInfo->serviceInstNode);
             retVal = RM_SERVICE_APPROVED;
-        }
-        else {
+        } else {
             retVal = RM_SERVICE_DENIED_PARTIAL_STATUS;
         }
-    }
-    else {
+    } else {
         retVal = RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST;
     }
 
@@ -477,7 +468,7 @@ static int32_t allocatorPreAllocate(Rm_Handle rmHandle,
                                                              opInfo->serviceInstNode,
                                                              policyCheckType);
     }
-    
+
     if (retVal != RM_OK) {
         return (retVal);
     }
@@ -485,11 +476,11 @@ static int32_t allocatorPreAllocate(Rm_Handle rmHandle,
     if (opInfo->resourceInfo->alignment == RM_RESOURCE_ALIGNMENT_UNSPECIFIED) {
         /* Get alignment from policy */
         opInfo->resourceInfo->alignment = rmPolicyGetAllocAlign(allocator->policyRoot);
-    } 
+    }
 
     if (opInfo->resourceInfo->alignment == 0) {
         opInfo->resourceInfo->alignment = 1;
-    } 
+    }
 
     memset((void *)&findNode, 0, sizeof(findNode));
     findNode.base = opInfo->resourceInfo->base;
@@ -500,16 +491,18 @@ static int32_t allocatorPreAllocate(Rm_Handle rmHandle,
     policyCheckCfg.polTree = allocator->policyRoot;
 
     do {
-        matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->resourceRoot, &findNode);
-        
+        matchingNode = RB_FIND(_Rm_AllocatorResourceTree,
+                               allocator->resourceRoot, &findNode);
+
         if (matchingNode) {
             matchingEnd = matchingNode->base + matchingNode->length - 1;
             findEnd = findNode.base + findNode.length - 1;
             nodePassesPolicy = RM_BOOL_UNDEF;
             if ((matchingNode->allocationCount == 0) &&
-                (findNode.base >= matchingNode->base) && (findEnd <= matchingEnd)) {
-                /* Attempt to preallocate from node only if not owned by anyone and sits
-                 * within a matching node. */
+                (findNode.base >= matchingNode->base) &&
+                (findEnd <= matchingEnd)) {
+                /* Attempt to preallocate from node only if not owned by anyone
+                 * and sits within a matching node. */
                 policyCheckCfg.type = policyCheckType;
                 policyCheckCfg.validInstNode = opInfo->serviceInstNode;
                 policyCheckCfg.resourceBase = findNode.base;
@@ -517,23 +510,26 @@ static int32_t allocatorPreAllocate(Rm_Handle rmHandle,
                 nodePassesPolicy = rmPolicyCheckPrivilege(&policyCheckCfg);
 
                 if (nodePassesPolicy && (matchingNode->allocationCount > 0)) {
-                    if (allocatorResNodeIsOwnedBy(rmHandle, matchingNode, rmPolicyGetLinuxInstNode(rmHandle))) {
-                        /* Check if instance requesting resource has privileges to share
-                         * a resource already reserved by Linux */
+                    if (allocatorResNodeIsOwnedBy(rmHandle, matchingNode,
+                                          rmPolicyGetLinuxInstNode(rmHandle))) {
+                        /* Check if instance requesting resource has privileges
+                         * to share a resource already reserved by Linux */
                         policyCheckCfg.type = Rm_policyCheck_SHARED_LINUX;
                         nodePassesPolicy = rmPolicyCheckPrivilege(&policyCheckCfg);
                     }
 
                     if (nodePassesPolicy) {
-                        /* Check exclusive privileges of instance requesting resource.  Requesting
-                         * instance with exclusive privileges can't reserve resource if already owned*/
+                        /* Check exclusive privileges of instance requesting
+                         * resource.  Requesting instance with exclusive
+                         * privileges can't reserve resource if already owned*/
                         policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;
                         nodePassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg);
                     }
                 }
-                
+
                 if (nodePassesPolicy && (matchingNode->allocationCount == 1)) {
-                    /* Check exclusive privileges of instance that currently owns resource */
+                    /* Check exclusive privileges of instance that currently
+                     * owns resource */
                     policyCheckCfg.type = Rm_policyCheck_EXCLUSIVE;
                     policyCheckCfg.validInstNode = matchingNode->ownerList->instNameNode;
                     nodePassesPolicy = !rmPolicyCheckPrivilege(&policyCheckCfg);
@@ -568,32 +564,28 @@ static int32_t allocatorPreAllocate(Rm_Handle rmHandle,
                 /* Check next resource node for available resources */
                 if (findNode.base < matchingNode->base) {
                     findNode.base = matchingNode->base;
-                }
-                else {
+                } else {
                     if (!nodePassesPolicy) {
                         findNode.base += findNode.length;
-                    }
-                    else {
+                    } else {
                         /* Matching node allocated, move to next node */
                         if ((nextNode = RB_NEXT(_Rm_AllocatorResourceTree,
                                                 allocator->resourceRoot,
                                                 matchingNode))) {
                             findNode.base = nextNode->base;
-                        }
-                        else {
+                        } else {
                             retVal = RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET;
                         }
                     }
                 }
             }
-        }
-        else {
+        } else {
             retVal = RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET;
         }
     } while ((!resourceFound) && 
              (retVal != RM_SERVICE_DENIED_RES_ALLOC_REQS_NOT_MET));
 
-    return(retVal); 
+    return(retVal);
 }
 
 /* FUNCTION PURPOSE: Allocates an allocator resource
@@ -666,11 +658,15 @@ static int32_t allocatorAllocate(Rm_Handle rmHandle,
                     }
                 }
 
-                if (!allocatorResNodeIsOwnedBy(rmHandle, matchingNode, opInfo->serviceInstNode)) {
-                    if (allocPassesPolicy && (matchingNode->allocationCount > 0)) {
-                        if (allocatorResNodeIsOwnedBy(rmHandle, matchingNode, rmPolicyGetLinuxInstNode(rmHandle))) {
-                            /* Check if instance requesting resource has privileges to share
-                             * a resource already reserved by Linux */
+                if (!allocatorResNodeIsOwnedBy(rmHandle, matchingNode,
+                                               opInfo->serviceInstNode)) {
+                    if (allocPassesPolicy &&
+                        (matchingNode->allocationCount > 0)) {
+                        if (allocatorResNodeIsOwnedBy(rmHandle, matchingNode,
+                                          rmPolicyGetLinuxInstNode(rmHandle))) {
+                            /* Check if instance requesting resource has
+                             * privileges to share a resource already reserved
+                             * by Linux */
                             checkCfg.type = Rm_policyCheck_SHARED_LINUX;
                             checkCfg.validInstNode = opInfo->serviceInstNode;
                             allocPassesPolicy = rmPolicyCheckPrivilege(&checkCfg);
@@ -679,8 +675,10 @@ static int32_t allocatorAllocate(Rm_Handle rmHandle,
                             }
                         }
                         if (allocPassesPolicy) {
-                            /* Check exclusive privileges of instance requesting resource.  Requesting
-                             * instance with exclusive privileges can't reserve resource if already owned*/
+                            /* Check exclusive privileges of instance
+                             * requesting resource.  Requesting instance with
+                             * exclusive privileges can't reserve resource if
+                             * already owned*/
                             checkCfg.type = Rm_policyCheck_EXCLUSIVE;
                             checkCfg.validInstNode = opInfo->serviceInstNode;
                             allocPassesPolicy = !rmPolicyCheckPrivilege(&checkCfg);
@@ -689,55 +687,73 @@ static int32_t allocatorAllocate(Rm_Handle rmHandle,
                             }
                         }
                     }
-                    if (allocPassesPolicy && (matchingNode->allocationCount == 1)) {
-                        /* Check exclusive privileges of instance that currently owns resource */
+                    if (allocPassesPolicy &&
+                        (matchingNode->allocationCount == 1)) {
+                        /* Check exclusive privileges of instance that
+                         * currently owns resource */
                         checkCfg.type = Rm_policyCheck_EXCLUSIVE;
                         checkCfg.validInstNode = matchingNode->ownerList->instNameNode;
                         allocPassesPolicy = !rmPolicyCheckPrivilege(&checkCfg);
                         if (!allocPassesPolicy) {
                             retVal = RM_SERVICE_DENIED_ALLOCD_TO_EXCLUSIVE_INST;
-                        }                
-                    }  
+                        }
+                    }
                 }
             }
-            
+
             if (allocPassesPolicy) {
-                /* Handle any possible node combinations if requesting instance is
-                 * not already in resource's owner list.  Automatic approval if requesting
-                 * instance is already in owner list. */
-                if ((findNode.base == matchingNode->base) && (findEnd == matchingEnd)) {
+                /* Handle any possible node combinations if requesting instance
+                 * is not already in resource's owner list.  Automatic approval
+                 * if requesting instance is already in owner list. */
+                if ((findNode.base == matchingNode->base) &&
+                    (findEnd == matchingEnd)) {
                     /* findNode range matches matchingNode range
                      *
-                     *   |<--left node-->||<--matched  node-->||<--right node-->| => existing node
-                     *                    |<--alloc request-->|  => requested resources
-                     */                     
-                    leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                    rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                    RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                    allocatorResNodeOwnerAdd(rmHandle, matchingNode, opInfo->serviceInstNode);
-
-                    if (leftNode && allocatorResNodeOwnerCompare(rmHandle, leftNode, matchingNode) &&
-                        allocatorResNodeBoundaryCompare(leftNode, matchingNode)) {
-                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
+                     * |<--left node-->||<--matched  node-->||<--right node-->|
+                     *                  |<--alloc request-->|
+                     */
+                    leftNode = RB_PREV(_Rm_AllocatorResourceTree,
+                                       allocator->resourceRoot, matchingNode);
+                    rightNode = RB_NEXT(_Rm_AllocatorResourceTree,
+                                        allocator->resourceRoot, matchingNode);
+                    RB_REMOVE(_Rm_AllocatorResourceTree,
+                              allocator->resourceRoot, matchingNode);
+                    allocatorResNodeOwnerAdd(rmHandle, matchingNode,
+                                             opInfo->serviceInstNode);
+
+                    if (leftNode &&
+                        allocatorResNodeOwnerCompare(rmHandle,
+                                                     leftNode,
+                                                     matchingNode) &&
+                        allocatorResNodeBoundaryCompare(leftNode,
+                                                        matchingNode)) {
+                        RB_REMOVE(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, leftNode);
                         combineLeft = RM_TRUE;
                     }
-                    if (rightNode && allocatorResNodeOwnerCompare(rmHandle, rightNode, matchingNode) &&
-                        allocatorResNodeBoundaryCompare(rightNode, matchingNode)) {
-                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
+                    if (rightNode &&
+                        allocatorResNodeOwnerCompare(rmHandle,
+                                                     rightNode,
+                                                     matchingNode) &&
+                        allocatorResNodeBoundaryCompare(rightNode,
+                                                        matchingNode)) {
+                        RB_REMOVE(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, rightNode);
                         combineRight = RM_TRUE;
                     }
 
                     if (combineLeft && combineRight) {
                         /* Combine all three nodes into matchingNode */
                         matchingNode->base = leftNode->base;
-                        matchingNode->length = leftNode->length + matchingNode->length + rightNode->length;
+                        matchingNode->length = leftNode->length +
+                                               matchingNode->length +
+                                               rightNode->length;
 
                         allocatorResNodeOwnerClear(rmHandle, leftNode);
                         rmResourceNodeFree(leftNode);
                         allocatorResNodeOwnerClear(rmHandle, rightNode);
-                        rmResourceNodeFree(rightNode);                        
-                    }
-                    else if (combineLeft) {
+                        rmResourceNodeFree(rightNode);
+                    } else if (combineLeft) {
                         /* Combine left and matching nodes.  Reinsert right. */
                         matchingNode->base = leftNode->base;
                         matchingNode->length += leftNode->length;
@@ -745,147 +761,190 @@ static int32_t allocatorAllocate(Rm_Handle rmHandle,
                         allocatorResNodeOwnerClear(rmHandle, leftNode);
                         rmResourceNodeFree(leftNode);
                         if (rightNode) {
-                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);  
+                            RB_INSERT(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, rightNode);  
                         }
-                    }
-                    else if (combineRight) {
+                    } else if (combineRight) {
                         /* Combine right and matching nodes.  Reinsert left. */
                         matchingNode->length += rightNode->length;
 
                         allocatorResNodeOwnerClear(rmHandle, rightNode);
                         rmResourceNodeFree(rightNode);
                         if (leftNode) {
-                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
+                            RB_INSERT(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, leftNode);
                         }
-                    }
-                    else {
+                    } else {
                         /* No combine. */
                         if (leftNode) {
-                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
+                            RB_INSERT(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, leftNode);
                         }
                         if (rightNode) {
-                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
+                            RB_INSERT(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, rightNode);
                         }
                     }
 
-                    /* Always reinsert matchingNode */                
-                    RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                    
-                    /* Matching node contains new reference count after alloc.  Return new owner count
-                     * and originating instance allocation reference count. */
+                    /* Always reinsert matchingNode */
+                    RB_INSERT(_Rm_AllocatorResourceTree,
+                              allocator->resourceRoot, matchingNode);
+
+                    /* Matching node contains new reference count after alloc.
+                     * Return new owner count and originating instance
+                     * allocation reference count. */
                     opInfo->resourceInfo->ownerCount = matchingNode->allocationCount;
-                    opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, matchingNode,
-                                                                                          opInfo->serviceInstNode);
-                }   
-                else if ((findNode.base > matchingNode->base) && (findEnd < matchingEnd)) {
-                    /* findNode range is subset of matchingNode range and neither boundary is
-                     * equivalent.
+                    opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                      matchingNode,
+                                                      opInfo->serviceInstNode);
+                } else if ((findNode.base > matchingNode->base) &&
+                           (findEnd < matchingEnd)) {
+                    /* findNode range is subset of matchingNode range and
+                     * neither boundary is equivalent.
                      *
                      * |<----------matched node---------->|
                      *        |<---alloc request--->|
-                     */ 
-                    RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                    leftNode = rmResourceNodeNew(matchingNode->base, findNode.base - matchingNode->base);
+                     */
+                    RB_REMOVE(_Rm_AllocatorResourceTree,
+                              allocator->resourceRoot, matchingNode);
+                    leftNode = rmResourceNodeNew(matchingNode->base,
+                                                 findNode.base -
+                                                 matchingNode->base);
                     allocatorResNodeOwnerCopy(rmHandle, leftNode, matchingNode);
-                    rightNode = rmResourceNodeNew(findNode.base + findNode.length, matchingEnd - findEnd);
-                    allocatorResNodeOwnerCopy(rmHandle, rightNode, matchingNode);
+                    rightNode = rmResourceNodeNew(findNode.base +
+                                                  findNode.length,
+                                                  matchingEnd - findEnd);
+                    allocatorResNodeOwnerCopy(rmHandle, rightNode,
+                                              matchingNode);
 
-                    matchingNode->base = findNode.base;                                    
+                    matchingNode->base = findNode.base;
                     matchingNode->length = findNode.length;
-                    allocatorResNodeOwnerAdd(rmHandle, matchingNode, opInfo->serviceInstNode);
+                    allocatorResNodeOwnerAdd(rmHandle, matchingNode,
+                                             opInfo->serviceInstNode);
 
                     /* Insert all the nodes */
-                    RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                    RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
-                    RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
-                    
-                    /* Matching node contains new reference count after alloc.  Return new owner count
-                     * and originating instance allocation reference count. */
+                    RB_INSERT(_Rm_AllocatorResourceTree,
+                              allocator->resourceRoot, matchingNode);
+                    RB_INSERT(_Rm_AllocatorResourceTree,
+                              allocator->resourceRoot, leftNode);
+                    RB_INSERT(_Rm_AllocatorResourceTree,
+                              allocator->resourceRoot, rightNode);
+
+                    /* Matching node contains new reference count after alloc.
+                     * Return new owner count and originating instance
+                     * allocation reference count. */
                     opInfo->resourceInfo->ownerCount = matchingNode->allocationCount;
-                    opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, matchingNode, 
-                                                                                          opInfo->serviceInstNode);
-                }  
-                else {    
+                    opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                     matchingNode,
+                                                     opInfo->serviceInstNode);
+                } else {
                     if (findNode.base == matchingNode->base) {
-                        /* findNode base and matchingNode base are equivalent.  May be combine
-                         * possibilities to the left
+                        /* findNode base and matchingNode base are equivalent.
+                         * May be combine possibilities to the left
                          *
-                         * |<---left node (alloc'd)--->||<----------matched node---------->|
-                         *                              |<---findNode (alloc req)--->|
-                         */                         
-                        leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                        /* Add allocating instance to owner list for compare with leftNode */
-                        allocatorResNodeOwnerAdd(rmHandle, matchingNode, opInfo->serviceInstNode);
-                        
-                        if (leftNode && allocatorResNodeOwnerCompare(rmHandle, leftNode, matchingNode) &&
-                            allocatorResNodeBoundaryCompare(leftNode, matchingNode)) {
-                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
+                         * |<-left node (alloc'd)->||<-----matched node------->|
+                         *                          |<-findNode (alloc req)->|
+                         */
+                        leftNode = RB_PREV(_Rm_AllocatorResourceTree,
+                                           allocator->resourceRoot,
+                                           matchingNode);
+                        RB_REMOVE(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, matchingNode);
+                        /* Add allocating instance to owner list for compare
+                         * with leftNode */
+                        allocatorResNodeOwnerAdd(rmHandle, matchingNode,
+                                                 opInfo->serviceInstNode);
+
+                        if (leftNode &&
+                            allocatorResNodeOwnerCompare(rmHandle,
+                                                         leftNode,
+                                                         matchingNode) &&
+                            allocatorResNodeBoundaryCompare(leftNode,
+                                                            matchingNode)) {
+                            RB_REMOVE(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, leftNode);
                             /* Combine leftNode and findNode */
                             leftNode->length += findNode.length;
-                        }
-                        else {
-                            leftNode = rmResourceNodeNew(findNode.base, findNode.length);
-                            allocatorResNodeOwnerCopy(rmHandle, leftNode, matchingNode);
+                        } else {
+                            leftNode = rmResourceNodeNew(findNode.base,
+                                                         findNode.length);
+                            allocatorResNodeOwnerCopy(rmHandle, leftNode,
+                                                      matchingNode);
                         }
 
                         /* Account for leftNode in matchingNode */
                         matchingNode->base = findNode.base + findNode.length;
-                        matchingNode->length = matchingEnd - findEnd;  
+                        matchingNode->length = matchingEnd - findEnd;
 
-                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
-                        /* Left node contains new reference count after alloc.  Return new owner count
-                         * and originating instance allocation reference count. */
+                        RB_INSERT(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, leftNode);
+                        /* Left node contains new reference count after alloc.
+                         * Return new owner count and originating instance
+                         * allocation reference count. */
                         opInfo->resourceInfo->ownerCount = leftNode->allocationCount;
-                        opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, leftNode, 
-                                                                                              opInfo->serviceInstNode);
-                    }
-                    else if (findEnd == matchingEnd) {
-                        /* findNode end and matchingNode end are equivalent.  May be combine
-                         * possibilities to the right
+                        opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                    leftNode,
+                                                    opInfo->serviceInstNode);
+                    else if (findEnd == matchingEnd) {
+                        /* findNode end and matchingNode end are equivalent.
+                         * May be combine possibilities to the right
                          *
-                         * |<----------matched node---------->||<---right node (alloc'd)--->|
-                         *       |<---findNode (alloc req)--->|
-                         */                        
-                        rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                        /* Add allocating instance to owner list for compare with rightNode */
-                        allocatorResNodeOwnerAdd(rmHandle, matchingNode, opInfo->serviceInstNode);
-                        
-                        if (rightNode && allocatorResNodeOwnerCompare(rmHandle, rightNode, matchingNode) &&
-                            allocatorResNodeBoundaryCompare(rightNode, matchingNode)) {
-                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
+                         * |<------matched node----->||<-right node (alloc'd)->|
+                         *  |<-findNode (alloc req)->|
+                         */
+                        rightNode = RB_NEXT(_Rm_AllocatorResourceTree,
+                                            allocator->resourceRoot,
+                                            matchingNode);
+                        RB_REMOVE(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, matchingNode);
+                        /* Add allocating instance to owner list for compare
+                         * with rightNode */
+                        allocatorResNodeOwnerAdd(rmHandle, matchingNode,
+                                                 opInfo->serviceInstNode);
+
+                        if (rightNode &&
+                            allocatorResNodeOwnerCompare(rmHandle,
+                                                         rightNode,
+                                                         matchingNode) &&
+                            allocatorResNodeBoundaryCompare(rightNode,
+                                                            matchingNode)) {
+                            RB_REMOVE(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, rightNode);
                             /* Combine rightNode and findNode */
                             rightNode->base = findNode.base;
                             rightNode->length += findNode.length;
-                        }
-                        else {
-                            rightNode = rmResourceNodeNew(findNode.base, findNode.length);
-                            allocatorResNodeOwnerCopy(rmHandle, rightNode, matchingNode);
+                        } else {
+                            rightNode = rmResourceNodeNew(findNode.base,
+                                                          findNode.length);
+                            allocatorResNodeOwnerCopy(rmHandle, rightNode,
+                                                      matchingNode);
                         }
 
                         /* Account for rightNode in matchingNode */
-                        matchingNode->length -= findNode.length;  
+                        matchingNode->length -= findNode.length;
 
-                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
-                        /* Right node contains new reference count after alloc.  Return new owner count
-                         * and originating instance allocation reference count. */
+                        RB_INSERT(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, rightNode);
+                        /* Right node contains new reference count after alloc.
+                         * Return new owner count and originating instance
+                         * allocation reference count. */
                         opInfo->resourceInfo->ownerCount = rightNode->allocationCount;
-                        opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, rightNode, 
-                                                                                              opInfo->serviceInstNode);
+                        opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                    rightNode,
+                                                    opInfo->serviceInstNode);
                     }
                     /* Remove allocating instance from leftover matchingNode */
-                    allocatorResNodeOwnerDelete(rmHandle, matchingNode, opInfo->serviceInstNode);
-                    RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
+                    allocatorResNodeOwnerDelete(rmHandle, matchingNode,
+                                                opInfo->serviceInstNode);
+                    RB_INSERT(_Rm_AllocatorResourceTree,
+                              allocator->resourceRoot, matchingNode);
                 }
                 retVal = RM_SERVICE_APPROVED;
             }
-        }
-        else {
+        } else {
             retVal = RM_SERVICE_DENIED_PARTIAL_ALLOCATION;
         }
-    }
-    else {
+    } else {
         retVal = RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST;
     }
 
@@ -920,7 +979,8 @@ static int32_t allocatorFree(Rm_Handle rmHandle, Rm_AllocatorNode *allocator,
     memset((void *)&findNode, 0, sizeof(findNode));
     findNode.base = opInfo->resourceInfo->base;
     findNode.length = opInfo->resourceInfo->length;
-    matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->resourceRoot, &findNode);
+    matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->resourceRoot,
+                           &findNode);
 
     if (matchingNode) {
         findEnd = findNode.base + findNode.length - 1;
@@ -928,217 +988,290 @@ static int32_t allocatorFree(Rm_Handle rmHandle, Rm_AllocatorNode *allocator,
         
         if ((findNode.base >= matchingNode->base) && (findEnd <= matchingEnd)) {
             if (matchingNode->allocationCount) {
-                if (allocatorResNodeIsOwnedBy(rmHandle, matchingNode, opInfo->serviceInstNode)) {
-                    if ((findNode.base == matchingNode->base) && (findEnd == matchingEnd)) {
-                        /* Case 1: Free range equals allocated matched node exactly. Attempt to combine 
-                         *         freed node with nodes to left and right.
+                if (allocatorResNodeIsOwnedBy(rmHandle, matchingNode,
+                    opInfo->serviceInstNode)) {
+                    if ((findNode.base == matchingNode->base) &&
+                        (findEnd == matchingEnd)) {
+                        /* Case 1: Free range equals allocated matched node
+                         *         exactly. Attempt to combine freed node with
+                         *         nodes to left and right.
                          *
-                         * |<--left node-->||<---matched node--->||<--right node-->|
-                         *                  |<---free request--->|
-                         */ 
-                        leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                        rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                        allocatorResNodeOwnerDelete(rmHandle, matchingNode, opInfo->serviceInstNode);
-
-                        if (leftNode && allocatorResNodeOwnerCompare(rmHandle, leftNode, matchingNode) &&
-                            allocatorResNodeBoundaryCompare(leftNode, matchingNode)) {
-                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
+                         * |<-left node->||<---matched node--->||<-right node->|
+                         *                |<---free request--->|
+                         */
+                        leftNode = RB_PREV(_Rm_AllocatorResourceTree,
+                                           allocator->resourceRoot,
+                                           matchingNode);
+                        rightNode = RB_NEXT(_Rm_AllocatorResourceTree,
+                                            allocator->resourceRoot,
+                                            matchingNode);
+                        RB_REMOVE(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, matchingNode);
+                        allocatorResNodeOwnerDelete(rmHandle, matchingNode,
+                                                    opInfo->serviceInstNode);
+
+                        if (leftNode &&
+                            allocatorResNodeOwnerCompare(rmHandle,
+                                                         leftNode,
+                                                         matchingNode) &&
+                            allocatorResNodeBoundaryCompare(leftNode,
+                                                            matchingNode)) {
+                            RB_REMOVE(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, leftNode);
                             combineLeft = RM_TRUE;
                         }
-                        if (rightNode && allocatorResNodeOwnerCompare(rmHandle, rightNode, matchingNode) &&
-                            allocatorResNodeBoundaryCompare(rightNode, matchingNode)) {
-                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
+                        if (rightNode &&
+                            allocatorResNodeOwnerCompare(rmHandle,
+                                                         rightNode,
+                                                         matchingNode) &&
+                            allocatorResNodeBoundaryCompare(rightNode,
+                                                            matchingNode)) {
+                            RB_REMOVE(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, rightNode);
                             combineRight = RM_TRUE;
                         }
 
                         if (combineLeft && combineRight) {
                             /* Combine all three nodes into matchingNode */
                             matchingNode->base = leftNode->base;
-                            matchingNode->length = leftNode->length + matchingNode->length + rightNode->length;
+                            matchingNode->length = leftNode->length +
+                                                   matchingNode->length +
+                                                   rightNode->length;
 
                             allocatorResNodeOwnerClear(rmHandle, leftNode);
                             rmResourceNodeFree(leftNode);
                             allocatorResNodeOwnerClear(rmHandle, rightNode);
-                            rmResourceNodeFree(rightNode);                        
-                        }
-                        else if (combineLeft) {
-                            /* Combine left and matching nodes.  Reinsert right. */
+                            rmResourceNodeFree(rightNode);
+                        } else if (combineLeft) {
+                            /* Combine left and matching nodes.
+                             * Reinsert right. */
                             matchingNode->base = leftNode->base;
                             matchingNode->length += leftNode->length;
 
                             allocatorResNodeOwnerClear(rmHandle, leftNode);
                             rmResourceNodeFree(leftNode);
                             if (rightNode) {
-                                RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode); 
+                                RB_INSERT(_Rm_AllocatorResourceTree,
+                                          allocator->resourceRoot, rightNode); 
                             }
-                        }
-                        else if (combineRight) {
-                            /* Combine right and matching nodes.  Reinsert left. */
+                        } else if (combineRight) {
+                            /* Combine right and matching nodes.
+                             * Reinsert left. */
                             matchingNode->length += rightNode->length;
 
                             allocatorResNodeOwnerClear(rmHandle, rightNode);
                             rmResourceNodeFree(rightNode);
                             if (leftNode) {
-                                RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
+                                RB_INSERT(_Rm_AllocatorResourceTree,
+                                          allocator->resourceRoot, leftNode);
                             }
-                        }
-                        else {
+                        } else {
                             /* No combine. */
                             if (leftNode) {
-                                RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
+                                RB_INSERT(_Rm_AllocatorResourceTree,
+                                          allocator->resourceRoot, leftNode);
                             }
                             if (rightNode) {
-                                RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
+                                RB_INSERT(_Rm_AllocatorResourceTree,
+                                          allocator->resourceRoot, rightNode);
                             }
                         }
 
                         /* Always reinsert matchingNode */
-                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
+                        RB_INSERT(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, matchingNode);
                         
-                        /* Matching node is what remains after free.  Return remaining owner count
-                         * and originating instance allocation reference count. */
+                        /* Matching node is what remains after free.  Return
+                         * remaining owner count and originating instance
+                         * allocation reference count. */
                         opInfo->resourceInfo->ownerCount = matchingNode->allocationCount;
-                        opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, matchingNode,
-                                                                                              opInfo->serviceInstNode);
-                    }
-                    else if ((findNode.base > matchingNode->base) && (findEnd < matchingEnd)) {
-                        /* Case 2: Free range is less than range in matched node. Split
-                         *         matched node into three nodes.
+                        opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                    matchingNode,
+                                                    opInfo->serviceInstNode);
+                    } else if ((findNode.base > matchingNode->base) &&
+                               (findEnd < matchingEnd)) {
+                        /* Case 2: Free range is less than range in matched
+                         *         node. Split matched node into three nodes.
                          *
                          * |<----------matched node---------->|
                          *        |<---free request--->|
                          *
-                         * Remove instance from owner list then add it back in for side nodes for
-                         * proper accounting of allocations in validInstance list
-                         */ 
-                        RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                        allocatorResNodeOwnerDelete(rmHandle, matchingNode, opInfo->serviceInstNode);
-                        
-                        leftNode = rmResourceNodeNew(matchingNode->base, findNode.base - matchingNode->base);
-                        allocatorResNodeOwnerCopy(rmHandle, leftNode, matchingNode);
-                        allocatorResNodeOwnerAdd(rmHandle, leftNode, opInfo->serviceInstNode);
-                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
-                        
-                        rightNode = rmResourceNodeNew(findNode.base + findNode.length, matchingEnd - findEnd);
-                        allocatorResNodeOwnerCopy(rmHandle, rightNode, matchingNode);
-                        allocatorResNodeOwnerAdd(rmHandle, rightNode, opInfo->serviceInstNode);
-                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
-
-                        matchingNode->base = findNode.base;                                    
+                         * Remove instance from owner list then add it back in
+                         * for side nodes for proper accounting of allocations
+                         * in validInstance list
+                         */
+                        RB_REMOVE(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, matchingNode);
+                        allocatorResNodeOwnerDelete(rmHandle, matchingNode,
+                                                    opInfo->serviceInstNode);
+
+                        leftNode = rmResourceNodeNew(matchingNode->base,
+                                                     findNode.base -
+                                                     matchingNode->base);
+                        allocatorResNodeOwnerCopy(rmHandle, leftNode,
+                                                  matchingNode);
+                        allocatorResNodeOwnerAdd(rmHandle, leftNode,
+                                                 opInfo->serviceInstNode);
+                        RB_INSERT(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, leftNode);
+
+                        rightNode = rmResourceNodeNew(findNode.base +
+                                                      findNode.length,
+                                                      matchingEnd - findEnd);
+                        allocatorResNodeOwnerCopy(rmHandle, rightNode,
+                                                  matchingNode);
+                        allocatorResNodeOwnerAdd(rmHandle, rightNode,
+                                                 opInfo->serviceInstNode);
+                        RB_INSERT(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, rightNode);
+
+                        matchingNode->base = findNode.base;
                         matchingNode->length = findNode.length;
-                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                        
-                        /* Matching node is what remains after free.  Return remaining owner count
-                         * and originating instance allocation reference count. */
+                        RB_INSERT(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, matchingNode);
+
+                        /* Matching node is what remains after free.  Return
+                         * remaining owner count and originating instance
+                         * allocation reference count. */
                         opInfo->resourceInfo->ownerCount = matchingNode->allocationCount;
-                        opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, matchingNode,
-                                                                                              opInfo->serviceInstNode);
-                    }
-                    else {                        
+                        opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                    matchingNode,
+                                                    opInfo->serviceInstNode);
+                    } else {
                         if (findNode.base == matchingNode->base) {
-                            /* Case 3: Free range is on left boundary of matched node. Try to 
-                             *         combine free range with left node.
+                            /* Case 3: Free range is on left boundary of
+                             *         matched node. Try to combine free range
+                             *         with left node.
                              *
-                             * |<---left node (free)--->||<----------matched node---------->|
-                             *                           |<---findNode (free req)--->|
-                             */ 
-
-                            leftNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                            /* Remove freeing instance from owner list for compare with leftNode */
-                            allocatorResNodeOwnerDelete(rmHandle, matchingNode, opInfo->serviceInstNode);
-                            
-                            if (leftNode && allocatorResNodeOwnerCompare(rmHandle, leftNode, matchingNode) &&
-                                allocatorResNodeBoundaryCompare(leftNode, matchingNode)) {
-                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
+                             * |<-left node (free)->||<-----matched node------>|
+                             *                       |<-findNode (free req)->|
+                             */
+
+                            leftNode = RB_PREV(_Rm_AllocatorResourceTree,
+                                               allocator->resourceRoot,
+                                               matchingNode);
+                            RB_REMOVE(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, matchingNode);
+                            /* Remove freeing instance from owner list for
+                             * compare with leftNode */
+                            allocatorResNodeOwnerDelete(rmHandle, matchingNode,
+                                                       opInfo->serviceInstNode);
+
+                            if (leftNode &&
+                                allocatorResNodeOwnerCompare(rmHandle,
+                                                             leftNode,
+                                                             matchingNode) &&
+                                allocatorResNodeBoundaryCompare(leftNode,
+                                                                matchingNode)) {
+                                RB_REMOVE(_Rm_AllocatorResourceTree,
+                                          allocator->resourceRoot, leftNode);
                                 /* Combine leftNode and findNode */
                                 leftNode->length += findNode.length;
-                            }
-                            else {
-                                leftNode = rmResourceNodeNew(findNode.base, findNode.length);
-                                allocatorResNodeOwnerCopy(rmHandle, leftNode, matchingNode);
+                            } else {
+                                leftNode = rmResourceNodeNew(findNode.base,
+                                                             findNode.length);
+                                allocatorResNodeOwnerCopy(rmHandle, leftNode,
+                                                          matchingNode);
                             }
 
                             /* Remove leftNode range from matchingNode */
-                            matchingNode->base = findNode.base + findNode.length;
-                            matchingNode->length = matchingEnd - findEnd;  
-                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, leftNode);
-                            
-                            /* Left node is what remains after free.  Return remaining owner count
-                             * and originating instance allocation reference count. */
+                            matchingNode->base = findNode.base +
+                                                 findNode.length;
+                            matchingNode->length = matchingEnd - findEnd;
+                            RB_INSERT(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, leftNode);
+
+                            /* Left node is what remains after free.  Return
+                             * remaining owner count and originating instance
+                             * allocation reference count. */
                             opInfo->resourceInfo->ownerCount = leftNode->allocationCount;
-                            opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, leftNode,
-                                                                                                  opInfo->serviceInstNode);
-                        }
-                        else if (findEnd == matchingEnd) {
-                            /* Case 4: Free range is on right boundary of matched node. Try to 
-                             *         combine free range with right node.
+                            opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                    leftNode,
+                                                    opInfo->serviceInstNode);
+                        } else if (findEnd == matchingEnd) {
+                            /* Case 4: Free range is on right boundary of
+                             *         matched node. Try to combine free range
+                             *         with right node.
                              *
-                             * |<----------matched node---------->||<---right node (free)--->|
-                             *        |<---findNode (free req)--->|
-                             */ 
-                            
-                            rightNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-                            RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode); 
-                            /* Remove freeing instance from owner list for compare with rightNode */
-                            allocatorResNodeOwnerDelete(rmHandle, matchingNode, opInfo->serviceInstNode);
+                             * |<-----matched node----->||<-right node (free)->|
+                             *  |<-findNode (free req)->|
+                             */
+
+                            rightNode = RB_NEXT(_Rm_AllocatorResourceTree,
+                                                allocator->resourceRoot,
+                                                matchingNode);
+                            RB_REMOVE(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, matchingNode);
+                            /* Remove freeing instance from owner list for
+                             * compare with rightNode */
+                            allocatorResNodeOwnerDelete(rmHandle, matchingNode,
+                                                       opInfo->serviceInstNode);
                             
-                            if (rightNode && allocatorResNodeOwnerCompare(rmHandle, rightNode, matchingNode) &&
-                                allocatorResNodeBoundaryCompare(rightNode, matchingNode)) {
-                                RB_REMOVE(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
+                            if (rightNode &&
+                                allocatorResNodeOwnerCompare(rmHandle,
+                                                             rightNode,
+                                                             matchingNode) &&
+                                allocatorResNodeBoundaryCompare(rightNode,
+                                                                matchingNode)) {
+                                RB_REMOVE(_Rm_AllocatorResourceTree,
+                                          allocator->resourceRoot, rightNode);
                                 /* Combine rightNode and findNode */
                                 rightNode->base = findNode.base;
                                 rightNode->length += findNode.length;
-                            }
-                            else {
-                                rightNode = rmResourceNodeNew(findNode.base, findNode.length);
-                                allocatorResNodeOwnerCopy(rmHandle, rightNode, matchingNode);
+                            } else {
+                                rightNode = rmResourceNodeNew(findNode.base,
+                                                              findNode.length);
+                                allocatorResNodeOwnerCopy(rmHandle, rightNode,
+                                                          matchingNode);
                             }
 
                             /* Remove rightNode range from matchingNode */
-                            matchingNode->length -= findNode.length;  
-                            RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, rightNode);
-                            
-                            /* Right node is what remains after free.  Return remaining owner count
-                             * and originating instance allocation reference count. */
+                            matchingNode->length -= findNode.length;
+                            RB_INSERT(_Rm_AllocatorResourceTree,
+                                      allocator->resourceRoot, rightNode);
+
+                            /* Right node is what remains after free.  Return
+                             * remaining owner count and originating instance
+                             * allocation reference count. */
                             opInfo->resourceInfo->ownerCount = rightNode->allocationCount;
-                            opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, rightNode,
-                                                                                                  opInfo->serviceInstNode);
+                            opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                    rightNode,
+                                                    opInfo->serviceInstNode);
                         }
 
-                        /* Add freeing instance back into matchingNode allocations */
-                        allocatorResNodeOwnerAdd(rmHandle, matchingNode, opInfo->serviceInstNode);
-                        RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
+                        /* Add freeing instance back into matchingNode
+                         * allocations */
+                        allocatorResNodeOwnerAdd(rmHandle, matchingNode,
+                                                 opInfo->serviceInstNode);
+                        RB_INSERT(_Rm_AllocatorResourceTree,
+                                  allocator->resourceRoot, matchingNode);
                     }
                     retVal = RM_SERVICE_APPROVED;
-                }
-                else {
-                    /* Return owner count and instance alloc count.  In case it's a reference count
-                     * check in application */
+                } else {
+                    /* Return owner count and instance alloc count.  In case
+                     * it's a reference count check in application */
                     opInfo->resourceInfo->ownerCount = matchingNode->allocationCount;
-                    opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, matchingNode,
-                                                                                          opInfo->serviceInstNode);
+                    opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                    matchingNode,
+                                                    opInfo->serviceInstNode);
                     retVal = RM_SERVICE_DENIED_RES_NOT_ALLOCD_TO_INST;
                 }
-            }
-            else {
-                /* Return owner count and instance alloc count.  In case it's a reference count
-                 * check in application */
+            } else {
+                /* Return owner count and instance alloc count.  In case it's
+                 * a reference count check in application */
                 opInfo->resourceInfo->ownerCount = matchingNode->allocationCount;
-                opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle, matchingNode,
-                                                                                      opInfo->serviceInstNode);
+                opInfo->resourceInfo->instAllocCount = allocatorResNodeOwnerGetRefCnt(rmHandle,
+                                                    matchingNode,
+                                                    opInfo->serviceInstNode);
                 retVal = RM_SERVICE_DENIED_RES_ALREADY_FREE;
             }
-        }
-        else {
+        } else {
             retVal = RM_SERVICE_DENIED_PARTIAL_FREE;
         }
-    }
-    else {
+    } else {
         retVal = RM_SERVICE_DENIED_RES_RANGE_DOES_NOT_EXIST;
     }
-    return(retVal);  
+    return(retVal);
 }
 
 /* FUNCTION PURPOSE: Reserves a Linux resource
@@ -1734,13 +1867,15 @@ int rmAllocatorGetNodeLocalization(Rm_Handle rmHandle, char *resourceName,
         memset((void *)&findNode, 0, sizeof(findNode));
         findNode.base = *resBase;
         findNode.length = *resLen;
-        matchingNode = RB_FIND(_Rm_AllocatorResourceTree, allocator->resourceRoot, &findNode);
+        matchingNode = RB_FIND(_Rm_AllocatorResourceTree,
+                               allocator->resourceRoot, &findNode);
 
         if (matchingNode) {
             /* Node can be freed back to Server from CD if:
              * - allocationCount == 0
              * - node's resource range is multiple of policy allocation size
-             * - node's resource range boundaries are not contiguous with surrounding nodes */
+             * - node's resource range boundaries are not contiguous with
+             *   surrounding nodes */
             if (matchingNode->allocationCount) {
                 goto exitLocalization;
             }
@@ -1750,29 +1885,33 @@ int rmAllocatorGetNodeLocalization(Rm_Handle rmHandle, char *resourceName,
             }
 
             /* Check left neighbor */
-            neighborNode = RB_PREV(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-            if (neighborNode && allocatorResNodeBoundaryCompare(neighborNode, matchingNode)) {
+            neighborNode = RB_PREV(_Rm_AllocatorResourceTree,
+                                   allocator->resourceRoot, matchingNode);
+            if (neighborNode &&
+                allocatorResNodeBoundaryCompare(neighborNode, matchingNode)) {
                 goto exitLocalization; 
             }
 
             /* Check right neighbor */
-            neighborNode = RB_NEXT(_Rm_AllocatorResourceTree, allocator->resourceRoot, matchingNode);
-            if (neighborNode && allocatorResNodeBoundaryCompare(neighborNode, matchingNode)) {
+            neighborNode = RB_NEXT(_Rm_AllocatorResourceTree,
+                                   allocator->resourceRoot, matchingNode);
+            if (neighborNode &&
+                allocatorResNodeBoundaryCompare(neighborNode, matchingNode)) {
                 goto exitLocalization; 
             }
 
-            /* All localization checks passed.  Return the base and length of localized node. */
+            /* All localization checks passed.  Return the base and length of
+             * localized node. */
             nodeIsLocalized = RM_TRUE;
             *resBase = matchingNode->base;
             *resLen = matchingNode->length;
-        }
-        else {
+        } else {
             nodeIsLocalized = RM_FALSE;
         }
     }
 
 exitLocalization:
-    return (nodeIsLocalized);
+    return(nodeIsLocalized);
 }
 
 /* FUNCTION PURPOSE: Issues an allocator operation
index 8af1160573d5067089a8d658ba471c0750c0c497..249aeea79a1e6797d6a38e87c15957d7c1fa7049 100644 (file)
@@ -93,7 +93,8 @@ const char dtbUtilPolicyAllocationAlignment[] = "allocation-alignment";
  *                  <200 100>;
  *                  Results in a list of three ranges.
  */
-static Rm_ResourceRange *dtbUtilCommonExtractRange(const void *dtbDataPtr, int32_t dtbDataLen)
+static Rm_ResourceRange *dtbUtilCommonExtractRange(const void *dtbDataPtr,
+                                                   int32_t dtbDataLen)
 {
     uint32_t         *dtbRangeData = (uint32_t *)dtbDataPtr;
     Rm_ResourceRange *startRange = NULL;
@@ -101,11 +102,11 @@ static Rm_ResourceRange *dtbUtilCommonExtractRange(const void *dtbDataPtr, int32
     Rm_ResourceRange *prevRange = NULL;
     uint32_t i;
     
-    /* Ranges are stored in the DTB as a list of 32-bit words.  The number of 32-bit
-     * words in the DTB ranges field should be even since ranges are specified in a 
-     * base, lenth format. The DTB gives properties lengths in bytes so the length
-     * returned from the DTB should be a multiple of the number of bytes in two
-     * uint32_ts. */
+    /* Ranges are stored in the DTB as a list of 32-bit words.  The number of
+     * 32-bit words in the DTB ranges field should be even since ranges are
+     * specified in a base, lenth format. The DTB gives properties lengths in
+     * bytes so the length returned from the DTB should be a multiple of the
+     * number of bytes in two uint32_ts. */
     if (dtbDataLen % (2 * sizeof(uint32_t))) {
         return (NULL);
     }
@@ -118,13 +119,12 @@ static Rm_ResourceRange *dtbUtilCommonExtractRange(const void *dtbDataPtr, int32
         
         if (prevRange == NULL) {
             startRange = newRange;
-        }
-        else {
+        } else {
             prevRange->nextRange = newRange;
         }
         prevRange = newRange;
     }
-    return (startRange);
+    return(startRange);
 }
 
 /* FUNCTION PURPOSE: Deletes a range list
@@ -135,7 +135,7 @@ static Rm_ResourceRange *dtbUtilCommonExtractRange(const void *dtbDataPtr, int32
 static void dtbUtilCommonFreeRangeList(Rm_ResourceRange *rangeList)
 {
     Rm_ResourceRange *nextRange;
-    
+
     while (rangeList) {
         nextRange = rangeList->nextRange;
         Rm_osalFree((void *)rangeList, sizeof(Rm_ResourceRange));
@@ -155,7 +155,8 @@ static void dtbUtilCommonFreeRangeList(Rm_ResourceRange *rangeList)
  *                  <30>;
  *                  Results in a list of three values.
  */
-static Rm_ResourceValue *dtbUtilCommonExtractValueList(const void *dtbDataPtr, int32_t dtbDataLen)
+static Rm_ResourceValue *dtbUtilCommonExtractValueList(const void *dtbDataPtr,
+                                                       int32_t dtbDataLen)
 {
     uint32_t         *dtbRangeData = (uint32_t *)dtbDataPtr;
     Rm_ResourceValue *startValue = NULL;
@@ -174,27 +175,26 @@ static Rm_ResourceValue *dtbUtilCommonExtractValueList(const void *dtbDataPtr, i
         newValue = (Rm_ResourceValue *) Rm_osalMalloc(sizeof(Rm_ResourceValue));
         newValue->value = fdt32_to_cpu(dtbRangeData[i]);
         newValue->nextValue = NULL;
-        
+
         if (prevValue == NULL) {
             startValue = newValue;
-        }
-        else {
+        } else {
             prevValue->nextValue = newValue;
         }
         prevValue = newValue;
     }
-    return (startValue);
+    return(startValue);
 }
 
 /* FUNCTION PURPOSE: Deletes a value list
  ***********************************************************************
- * DESCRIPTION: Frees the memory associated with a list of values 
+ * DESCRIPTION: Frees the memory associated with a list of values
  *              that were extracted from a DTB.
  */
 static void dtbUtilCommonFreeValueList (Rm_ResourceValue *valueList)
 {
     Rm_ResourceValue *nextValue;
-    
+
     while (valueList) {
         nextValue = valueList->nextValue;
         Rm_osalFree((void *)valueList, sizeof(Rm_ResourceValue));
@@ -208,7 +208,7 @@ static void dtbUtilCommonFreeValueList (Rm_ResourceValue *valueList)
 
 /* FUNCTION PURPOSE: Returns the GRL property type
  ***********************************************************************
- * DESCRIPTION: Returns the GRL property type associated with the 
+ * DESCRIPTION: Returns the GRL property type associated with the
  *              property name specified.
  */
 Rm_ResourcePropType rmDtbUtilResGetPropertyType(const char * propertyName)
@@ -217,11 +217,9 @@ Rm_ResourcePropType rmDtbUtilResGetPropertyType(const char * propertyName)
 
     if(strcmp(dtbUtilResRangeProp, propertyName) == 0) {
         propertyType = Rm_resourcePropType_RESOURCE_RANGE;
-    }
-    else if(strcmp(dtbUtilResLinuxAliasProp, propertyName) == 0) {
+    } else if(strcmp(dtbUtilResLinuxAliasProp, propertyName) == 0) {
         propertyType = Rm_resourcePropType_RESOURCE_LINUX_ALIAS;
-    }    
-    else if(strcmp(dtbUtilResNsAssignmentProp, propertyName) == 0) {
+    } else if(strcmp(dtbUtilResNsAssignmentProp, propertyName) == 0) {
         propertyType = Rm_resourcePropType_NSASSIGNMENT;
     }
     return (propertyType);
@@ -240,7 +238,8 @@ Rm_ResourcePropType rmDtbUtilResGetPropertyType(const char * propertyName)
  *                  <20 10>;
  *                  Results in a list of three resource ranges.
  */
-Rm_ResourceRange *rmDtbUtilResExtractRange(const void *dtbDataPtr, int32_t dtbDataLen)
+Rm_ResourceRange *rmDtbUtilResExtractRange(const void *dtbDataPtr,
+                                           int32_t dtbDataLen)
 {
     return(dtbUtilCommonExtractRange(dtbDataPtr, dtbDataLen));
 }
@@ -271,35 +270,38 @@ void rmDtbUtilResFreeRange(Rm_ResourceRange *rangeList)
  *                  "LinuxDtbNode1 LinuxDtbNode2 anotherRes", <2 2 3>,
  *                  Results in a list of two Linux alias paths.
  */
-Rm_LinuxAlias *rmDtbUtilResExtractLinuxAlias(const void *dtbDataPtr, int32_t dtbDataLen, int32_t *result)
+Rm_LinuxAlias *rmDtbUtilResExtractLinuxAlias(const void *dtbDataPtr,
+                                             int32_t dtbDataLen,
+                                             int32_t *result)
 {
     uint8_t       *dtbAliasData = (uint8_t *)dtbDataPtr;
     uint32_t       pathLenBytes;
     uint32_t       extractedValue;
-    uint8_t       *extractedValueBytePtr;        
+    uint8_t       *extractedValueBytePtr;
     Rm_LinuxAlias *startAlias = NULL;
     Rm_LinuxAlias *newAlias = NULL;
     Rm_LinuxAlias *prevAlias = NULL;
     uint32_t       numOffsets;
     int32_t        i = 0;
     uint16_t       j;
-    
-    /* Linux aliases are stored in the DTB as a list space-separated path node names within
-     * null terminated string.  Following the path string 
-     * will be two or three values specifying the fields in the linux DTB property
-     * that contain the relevant data.  The first value specifies the number of offsets
-     * that follow.  If two field offsets are specified the 
-     * Linux DTB contains a base + length. If   one field offset is specified the 
-     * Linux DTB contains a single value for reservation.  There is no padding between
-     * the path string and the 32-bit offsets.  Therefore the 32-bit offsets may not be on
-     * a 4-byte boundary and must be constructed upon extraction */
+
+    /* Linux aliases are stored in the DTB as a list space-separated path node
+     * names within null terminated string.  Following the path string  will be
+     * two or three values specifying the fields in the linux DTB property that
+     * contain the relevant data.  The first value specifies the number of
+     * offsets that follow.  If two field offsets are specified the Linux DTB
+     * contains a base + length. If   one field offset is specified the Linux
+     * DTB contains a single value for reservation.  There is no padding
+     * between the path string and the 32-bit offsets.  Therefore the 32-bit
+     * offsets may not be on a 4-byte boundary and must be constructed upon
+     * extraction */
     while(i < dtbDataLen) {
         newAlias = (Rm_LinuxAlias *) Rm_osalMalloc(sizeof(Rm_LinuxAlias));
-        
+
         pathLenBytes = strlen((char *) &dtbAliasData[i]) + 1;
         newAlias->path = (char *) Rm_osalMalloc(pathLenBytes);
         rm_strncpy(newAlias->path, ((char *) &dtbAliasData[i]), pathLenBytes);
-        
+
         /* Extract 32-bit value specifying number of offsets that follow */
         i += pathLenBytes;
         extractedValueBytePtr = (uint8_t *)&extractedValue;
@@ -313,7 +315,7 @@ Rm_LinuxAlias *rmDtbUtilResExtractLinuxAlias(const void *dtbDataPtr, int32_t dtb
             extractedValueBytePtr = (uint8_t *)&extractedValue;
             for (j = 0; j < sizeof(uint32_t); j++, i++) {
                 extractedValueBytePtr[j] = dtbAliasData[i];
-            }            
+            }
             newAlias->baseOffset = fdt32_to_cpu(extractedValue);
 
             if (numOffsets == 2) {
@@ -321,50 +323,47 @@ Rm_LinuxAlias *rmDtbUtilResExtractLinuxAlias(const void *dtbDataPtr, int32_t dtb
                     extractedValueBytePtr[j] = dtbAliasData[i];
                 }
                 newAlias->lengthOffset = fdt32_to_cpu(extractedValue);
-            }
-            else {
+            } else {
                 newAlias->lengthOffset = RM_DTB_UTIL_LINUX_ALIAS_OFFSET_NOT_SET;
-            }            
-            
+            }
+
             newAlias->nextLinuxAlias = NULL;
             if (prevAlias == NULL) {
                 startAlias = newAlias;
-            }
-            else {
+            } else {
                 prevAlias->nextLinuxAlias = newAlias;
             }
             prevAlias = newAlias;
-        }
-        else {
+        } else {
             Rm_osalFree((void *)newAlias->path, pathLenBytes);
             Rm_osalFree((void *)newAlias, sizeof(Rm_LinuxAlias));
             while (startAlias) {
                 newAlias = startAlias->nextLinuxAlias;
-                pathLenBytes = strlen(startAlias->path);        
+                pathLenBytes = strlen(startAlias->path);
                 Rm_osalFree((void *)startAlias->path, pathLenBytes + 1);
                 Rm_osalFree((void *)startAlias, sizeof(Rm_LinuxAlias));
                 startAlias = newAlias;
-            }   
+            }
             *result = RM_ERROR_GRL_INVALID_LINUX_ALIAS_FORMAT;
             return(NULL);
         }
     }
-    return (startAlias);
+    return(startAlias);
 }
 
 /* FUNCTION PURPOSE: Deletes a Linux Alias list
  ***********************************************************************
- * DESCRIPTION: Frees the memory associated with a list of Linux 
+ * DESCRIPTION: Frees the memory associated with a list of Linux
  *              aliases that were extracted from a GRL DTB.
  */
 void rmDtbUtilResFreeLinuxAlias(Rm_LinuxAlias *aliasList)
 {
     Rm_LinuxAlias *nextAlias;
     int32_t        pathSize;
-       
+
     while (aliasList) {
         nextAlias = aliasList->nextLinuxAlias;
-        pathSize = strlen(aliasList->path);        
+        pathSize = strlen(aliasList->path);
         Rm_osalFree((void *)aliasList->path, pathSize + 1);
         Rm_osalFree((void *)aliasList, sizeof(Rm_LinuxAlias));
         aliasList = nextAlias;
@@ -384,26 +383,28 @@ void rmDtbUtilResFreeLinuxAlias(Rm_LinuxAlias *aliasList)
  *                  "Another Name", <20 10>;
  *                  Results in a list of three NameServer assignments.
  */
-Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr, int32_t dtbDataLen, int32_t *result)
+Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr,
+                                                 int32_t dtbDataLen,
+                                                 int32_t *result)
 {
     uint8_t         *dtbNsAssignmentData = (uint8_t *)dtbDataPtr;
     uint32_t         nameLenBytes;
     uint32_t         extractedValue;
-    uint8_t         *extractedValueBytePtr;        
+    uint8_t         *extractedValueBytePtr;
     Rm_NsAssignment *startAssignment = NULL;
     Rm_NsAssignment *newAssignment = NULL;
     Rm_NsAssignment *prevAssignment = NULL;
     int32_t          i = 0;
     uint16_t         j;
-    
-    /* NameServer assignments are stored in the DTB as a null-terminated character
-     * string followed by a 32-bit word containing the value to be assigned to the
-     * name in the string.  There is no padding between the string and the 32-bit 
-     * word.  Therefore the 32-bit word may not be on a 4-byte boundary and must
-     * be constructed upon extraction */
+
+    /* NameServer assignments are stored in the DTB as a null-terminated
+     * character string followed by a 32-bit word containing the value to be
+     * assigned to the name in the string.  There is no padding between the
+     * string and the 32-bit word.  Therefore the 32-bit word may not be on a
+     * 4-byte boundary and must be constructed upon extraction */
     while(i < dtbDataLen) {
-        newAssignment = (Rm_NsAssignment *) Rm_osalMalloc(sizeof(Rm_NsAssignment));
-        
+        newAssignment = (Rm_NsAssignment *)Rm_osalMalloc(sizeof(Rm_NsAssignment));
+
         nameLenBytes = strlen((char *) &dtbNsAssignmentData[i]) + 1;
         if (nameLenBytes > RM_NAME_MAX_CHARS) {
             Rm_osalFree((void *)newAssignment, sizeof(Rm_NsAssignment));
@@ -414,9 +415,10 @@ Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr, int32_t
             }
             *result = RM_ERROR_NAMESERVER_NAME_TOO_LONG;
             return(NULL);
-        }        
-        rm_strncpy(newAssignment->nsName, ((char *) &dtbNsAssignmentData[i]), RM_NAME_MAX_CHARS);
-        
+        }
+        rm_strncpy(newAssignment->nsName, ((char *) &dtbNsAssignmentData[i]),
+                   RM_NAME_MAX_CHARS);
+
         /* Extract 32-bit base value and flip endian */
         i += nameLenBytes;
         extractedValueBytePtr = (uint8_t *)&extractedValue;
@@ -430,18 +432,17 @@ Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr, int32_t
             extractedValueBytePtr[j] = dtbNsAssignmentData[i];
         }
         newAssignment->resourceLength = fdt32_to_cpu(extractedValue);
-        
+
         newAssignment->nextNsAssignment = NULL;
         if (prevAssignment == NULL) {
             startAssignment = newAssignment;
-        }
-        else {
+        } else {
             prevAssignment->nextNsAssignment = newAssignment;
         }
         prevAssignment = newAssignment;
     }
-    
-    return (startAssignment);
+
+    return(startAssignment);
 }
 
 /* FUNCTION PURPOSE: Deletes a NameServer assignment list
@@ -452,7 +453,7 @@ Rm_NsAssignment *rmDtbUtilResExtractNsAssignment(const void *dtbDataPtr, int32_t
 void rmDtbUtilResFreeNsAssignmentList (Rm_NsAssignment *nsAssignmentList)
 {
     Rm_NsAssignment *nextAssignment;
-    
+
     while (nsAssignmentList) {
         nextAssignment = nsAssignmentList->nextNsAssignment;
         Rm_osalFree((void *)nsAssignmentList, sizeof(Rm_NsAssignment));
@@ -475,17 +476,14 @@ Rm_PolicyPropType rmDtbUtilPolicyGetPropertyType(const char * propertyName)
 
     if(strcmp(dtbUtilPolicyAssignments, propertyName) == 0) {
         propertyType = Rm_policyPropType_ASSIGNMENTS;
-    }
-    else if(strcmp(dtbUtilPolicyCdAllocationSize, propertyName) == 0) {
+    } else if(strcmp(dtbUtilPolicyCdAllocationSize, propertyName) == 0) {
         propertyType = Rm_policyPropType_CD_ALLOCATION_SIZE;
-    }
-    else if(strcmp(dtbUtilPolicyAllocationAlignment, propertyName) == 0) {
+    } else if(strcmp(dtbUtilPolicyAllocationAlignment, propertyName) == 0) {
         propertyType = Rm_policyPropType_ALLOCATION_ALIGNMENT;
-    }    
-    else if(strcmp(dtbUtilPolicyValidInstances, propertyName) == 0) {
+    } else if(strcmp(dtbUtilPolicyValidInstances, propertyName) == 0) {
         propertyType = Rm_policyPropType_VALID_INSTANCES;
-    }       
-    return (propertyType);
+    }
+    return(propertyType);
 }
 
 /* FUNCTION PURPOSE: Extracts a policy assignment list from a Policy DTB
@@ -503,25 +501,26 @@ Rm_PolicyPropType rmDtbUtilPolicyGetPropertyType(const char * propertyName)
  *                  <10 10>, "iu = (*);
  *                  Results in a list of two policy assignments.
  */
-Rm_PolicyAssignment *rmDtbUtilPolicyExtractAssignments(const void *dtbDataPtr, int32_t dtbDataLen)
+Rm_PolicyAssignment *rmDtbUtilPolicyExtractAssignments(const void *dtbDataPtr,
+                                                       int32_t dtbDataLen)
 {
     uint8_t             *dtbAssignmentData = (uint8_t *)dtbDataPtr;
     uint32_t             permissionsLenBytes;
     uint32_t             extractedValue;
-    uint8_t             *extractedValueBytePtr;        
+    uint8_t             *extractedValueBytePtr;
     Rm_PolicyAssignment *startAssignment = NULL;
     Rm_PolicyAssignment *newAssignment = NULL;
     Rm_PolicyAssignment *prevAssignment = NULL;
     int32_t              i = 0;
     uint16_t             j;
-    
-    /* Policy assignments are stored in the DTB as two 32-bit words containing a 
-     * resource base and length to be assigned the permissions in the defined in
-     * the string that follows.  There is no padding between the 32-bit words and the 
-     * string.  Therefore the 32-bit word may not be on a 4-byte boundary and must
-     * be constructed upon extraction */
+
+    /* Policy assignments are stored in the DTB as two 32-bit words containing
+     * a resource base and length to be assigned the permissions in the defined
+     * in the string that follows.  There is no padding between the 32-bit
+     * words and the string.  Therefore the 32-bit word may not be on a 4-byte
+     * boundary and must be constructed upon extraction */
     while(i < dtbDataLen) {
-        newAssignment = (Rm_PolicyAssignment *) Rm_osalMalloc(sizeof(Rm_PolicyAssignment));
+        newAssignment = (Rm_PolicyAssignment *)Rm_osalMalloc(sizeof(Rm_PolicyAssignment));
 
         /* Extract 32-bit resource base value and flip endianness */
         extractedValueBytePtr = (uint8_t *)&extractedValue;
@@ -537,20 +536,20 @@ Rm_PolicyAssignment *rmDtbUtilPolicyExtractAssignments(const void *dtbDataPtr, i
         newAssignment->resourceLength = fdt32_to_cpu(extractedValue);
 
         permissionsLenBytes = strlen((char *) &dtbAssignmentData[i]) + 1;
-        newAssignment->permissionsList = (char *) Rm_osalMalloc(permissionsLenBytes);
-        rm_strncpy(newAssignment->permissionsList, ((char *) &dtbAssignmentData[i]), permissionsLenBytes);
+        newAssignment->permissionsList = (char *)Rm_osalMalloc(permissionsLenBytes);
+        rm_strncpy(newAssignment->permissionsList,
+                   ((char *)&dtbAssignmentData[i]), permissionsLenBytes);
         i += permissionsLenBytes;
 
         newAssignment->nextAssignment = NULL;
         if (prevAssignment == NULL) {
             startAssignment = newAssignment;
-        }
-        else {
+        } else {
             prevAssignment->nextAssignment = newAssignment;
         }
         prevAssignment = newAssignment;
     }
-    return (startAssignment);
+    return(startAssignment);
 }
 
 /* FUNCTION PURPOSE: Deletes a policy assignment list
@@ -562,7 +561,7 @@ void rmDtbUtilPolicyFreeAssignments(Rm_PolicyAssignment *assignmentList)
 {
     Rm_PolicyAssignment *nextAssignment;
     int32_t              permissionsSize;
-    
+
     while (assignmentList) {
         nextAssignment = assignmentList->nextAssignment;
         permissionsSize = strlen(assignmentList->permissionsList);
@@ -584,7 +583,8 @@ void rmDtbUtilPolicyFreeAssignments(Rm_PolicyAssignment *assignmentList)
  *                  <100>;
  *                  Results in a list of two allocation sizes.
  */
-Rm_ResourceValue *rmDtbUtilPolicyExtractCdAllocationSizes(const void *dtbDataPtr, int32_t dtbDataLen)
+Rm_ResourceValue *rmDtbUtilPolicyExtractCdAllocationSizes(const void *dtbDataPtr,
+                                                          int32_t dtbDataLen)
 {
     return(dtbUtilCommonExtractValueList(dtbDataPtr, dtbDataLen));
 }
@@ -611,7 +611,8 @@ void rmDtbUtilPolicyFreeCdAllocationSizes (Rm_ResourceValue *allocationSizeList)
  *                  <100>;
  *                  Results in a list of two resource alignments.
  */
-Rm_ResourceValue *rmDtbUtilPolicyExtractResourceAlignments(const void *dtbDataPtr, int32_t dtbDataLen)
+Rm_ResourceValue *rmDtbUtilPolicyExtractResourceAlignments(const void *dtbDataPtr,
+                                                           int32_t dtbDataLen)
 {
     return(dtbUtilCommonExtractValueList(dtbDataPtr, dtbDataLen));
 }
@@ -621,7 +622,7 @@ Rm_ResourceValue *rmDtbUtilPolicyExtractResourceAlignments(const void *dtbDataPt
  * DESCRIPTION: Frees the memory associated with a list of resource
  *              alignments that were extracted from a Policy DTB.
  */
-void rmDtbUtilPolicyFreeResourceAlignments (Rm_ResourceValue *alignmentList)
+void rmDtbUtilPolicyFreeResourceAlignments(Rm_ResourceValue *alignmentList)
 {
     dtbUtilCommonFreeValueList(alignmentList);
 }
@@ -648,11 +649,11 @@ Rm_PolicyValidInst *rmDtbUtilPolicyExtractValidInstances(const void *dtbDataPtr,
     Rm_PolicyValidInst *newInst = NULL;
     Rm_PolicyValidInst *prevInst = NULL;
     int32_t             i = 0;
-    
-    /* Valid RM instances are stored in the DTB as a list of null-terminated character
-     * strings. */
+
+    /* Valid RM instances are stored in the DTB as a list of null-terminated
+     * character strings. */
     while(i < dtbDataLen) {
-        newInst = (Rm_PolicyValidInst *) Rm_osalMalloc(sizeof(Rm_PolicyValidInst));
+        newInst = (Rm_PolicyValidInst *)Rm_osalMalloc(sizeof(Rm_PolicyValidInst));
 
         instLenBytes = strlen((char *) &dtbValidInstData[i]) + 1;
         if (instLenBytes > RM_NAME_MAX_CHARS) {
@@ -665,21 +666,21 @@ Rm_PolicyValidInst *rmDtbUtilPolicyExtractValidInstances(const void *dtbDataPtr,
             *result = RM_ERROR_VALID_INST_NAME_TOO_LONG;
             return(NULL);
         }
-        rm_strncpy(newInst->instName, ((char *) &dtbValidInstData[i]), instLenBytes);
-        
+        rm_strncpy(newInst->instName, ((char *) &dtbValidInstData[i]),
+                   instLenBytes);
+
         i += instLenBytes;
 
         newInst->nextValidInst = NULL;
 
         if (prevInst == NULL) {
             startInst = newInst;
-        }
-        else {
+        } else {
             prevInst->nextValidInst = newInst;
         }
         prevInst = newInst;
     }
-    return (startInst);
+    return(startInst);
 }
 
 /* FUNCTION PURPOSE: Deletes a valid instnace list
@@ -690,7 +691,7 @@ Rm_PolicyValidInst *rmDtbUtilPolicyExtractValidInstances(const void *dtbDataPtr,
 void rmDtbUtilPolicyFreeValidInstances (Rm_PolicyValidInst *validInstList)
 {
     Rm_PolicyValidInst *nextInst;
-    
+
     while (validInstList) {
         nextInst = validInstList->nextValidInst;
         Rm_osalFree((void *)validInstList, sizeof(Rm_PolicyValidInst));
@@ -712,31 +713,32 @@ void rmDtbUtilPolicyFreeValidInstances (Rm_PolicyValidInst *validInstList)
  *                  <1 5 10 15 20 25>;
  *                  Results in a list of six Linux values.
  */
-Rm_LinuxValueRange *rmDtbUtilLinuxExtractValues(const void *dtbDataPtr, int32_t dtbDataLen)
+Rm_LinuxValueRange *rmDtbUtilLinuxExtractValues(const void *dtbDataPtr,
+                                                int32_t dtbDataLen)
 {
     uint32_t           *dtbValueData = (uint32_t *)dtbDataPtr;
     Rm_LinuxValueRange *startValue = NULL;
     Rm_LinuxValueRange *newValue = NULL;
     Rm_LinuxValueRange *prevValue = NULL;
     uint32_t            i;
-    
-    /* Values are stored in the Linux DTB as a list of 32-bit words.  The number of 32-bit
-     * words in the value field can differ.  depending on the number of values specified. */
+
+    /* Values are stored in the Linux DTB as a list of 32-bit words.  The
+     * number of 32-bit words in the value field can differ.  depending on the
+     * number of values specified. */
     for (i = 0; i < (dtbDataLen / sizeof(uint32_t)); i++) {
-        newValue = (Rm_LinuxValueRange *) Rm_osalMalloc(sizeof(Rm_LinuxValueRange));
+        newValue = (Rm_LinuxValueRange *)Rm_osalMalloc(sizeof(Rm_LinuxValueRange));
         /* Endianness of extracted value must be flipped */
         newValue->value = fdt32_to_cpu(dtbValueData[i]);
         newValue->nextValue = NULL;
-        
+
         if (prevValue == NULL) {
             startValue = newValue;
-        }
-        else {
+        } else {
             prevValue->nextValue = newValue;
         }
         prevValue = newValue;
     }
-    return (startValue);
+    return(startValue);
 }
 
 /* FUNCTION PURPOSE: Deletes a Linux values list
index ee920403359ef857f438e8a94cee71db3e3e7c23..1464d8d978adaacce4d739d5264d758e5a604ee5 100644 (file)
@@ -95,8 +95,7 @@ int32_t rmNameServerAddObject(Rm_NameServerObjCfg *objCfg)
             rmNameServerNodeFree(newNode);
             retVal = RM_SERVICE_DENIED_NAME_EXISTS_IN_NS;
         }
-    }
-    else {
+    } else {
         retVal = RM_ERROR_NAMESERVER_NAME_ADD_FAILED;
     }
 
@@ -126,7 +125,7 @@ int32_t rmNameServerFindObject(Rm_NameServerObjCfg *objCfg)
         objCfg->nodeCfg.resourceLength = matchingNode->resourceLength;
 
         retVal = RM_SERVICE_PROCESSING;
-    }    
+    }
     return(retVal);
 }
 
@@ -137,22 +136,22 @@ int32_t rmNameServerFindObject(Rm_NameServerObjCfg *objCfg)
  *              memory associated with the NameServer node
  */
 int32_t rmNameServerDeleteObject(Rm_NameServerObjCfg *objCfg)
-{   
+{
     Rm_NameServerNode  findNode;
     Rm_NameServerNode *matchingNode;
-    int32_t            retVal = RM_ERROR_NAMESERVER_NAME_DOES_NOT_EXIST;    
+    int32_t            retVal = RM_ERROR_NAMESERVER_NAME_DOES_NOT_EXIST;
 
     memset((void *)&findNode, 0, sizeof(Rm_NameServerNode));
     rm_strncpy(findNode.objName, objCfg->nodeCfg.objName, RM_NAME_MAX_CHARS);
-    
+
     if ((matchingNode = RB_FIND(_Rm_NameServerTree, objCfg->nameServerTree,
                                 &findNode))) {
         /* Remove from NameServer */
         RB_REMOVE(_Rm_NameServerTree, objCfg->nameServerTree, matchingNode);
         rmNameServerNodeFree(matchingNode);
-        
+
         retVal = RM_SERVICE_APPROVED;
-    }    
+    }
     return(retVal);
 }
 
@@ -171,8 +170,9 @@ void rmNameServerPrintObjects(Rm_Handle rmHandle)
         rmNameServerTreeInv(root);
     }
     RB_FOREACH(node, _Rm_NameServerTree, root) {
-        Rm_osalLog("Name: %s resourceName: %s base: %d length: %d\n", node->objName, node->resourceName,
-                                                                      node->resourceBase, node->resourceLength);
+        Rm_osalLog("Name: %s resourceName: %s base: %d length: %d\n",
+                   node->objName, node->resourceName, node->resourceBase,
+                   node->resourceLength);
     }
 }
 
@@ -213,17 +213,19 @@ void rmNameServerDelete(Rm_Handle rmHandle)
         if (rmInst->instType == Rm_instType_SHARED_SERVER) {
             rmNameServerTreeInv(treeRoot);
         }
-        
-        for (node = RB_MIN(_Rm_NameServerTree, treeRoot); node != NULL; node = nextNode) {
+
+        for (node = RB_MIN(_Rm_NameServerTree, treeRoot);
+             node != NULL;
+             node = nextNode) {
             nextNode = RB_NEXT(_Rm_NameServerTree, treeRoot, node);
             objCfg.nameServerTree = treeRoot;
             objCfg.nodeCfg.objName = node->objName;
             rmNameServerDeleteObject(&objCfg);
         }
 
-        /* Don't need to writeback tree node changes since NameServer will be made
-         * NULL in instance */
-         
+        /* Don't need to writeback tree node changes since NameServer will be
+         * made NULL in instance */
+
         if (RB_MIN(_Rm_NameServerTree, treeRoot) == NULL) {
             Rm_osalFree((void *)treeRoot, sizeof(Rm_NameServerTree));
         }
index 82753da8f9a25c091ff0903957baf3da16000549..01421dcb8fe6718239bb9aece9ec63167f75c6b5 100644 (file)
@@ -81,7 +81,8 @@ const char Rm_policyGlobalInst[] = "*";
  *              errors are encountered during the parsing.  The error
  *              is returned via the result pointer parameter.
  */
-static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *permStrEnd, 
+static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart,
+                                                     char *permStrEnd,
                                                      int32_t *result)
 {
     Rm_PolicyPermission *startPerm = NULL;
@@ -111,14 +112,17 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
     subgroupEnd = strchr(permStrStart, RM_POLICY_PERM_SUBGROUP_END);
 
     if ((!subgroupStart) || (!subgroupEnd) || (subgroupStart > subgroupEnd) ||
-        ((subgroupStart != strrchr(permStrStart, RM_POLICY_PERM_SUBGROUP_START)) &&
-         (subgroupEnd != strrchr(permStrStart, RM_POLICY_PERM_SUBGROUP_END)))) {
-        /* Free the memory associated with the temp string and return an error if:
+        ((subgroupStart != strrchr(permStrStart,
+                                   RM_POLICY_PERM_SUBGROUP_START)) &&
+         (subgroupEnd != strrchr(permStrStart,
+                                 RM_POLICY_PERM_SUBGROUP_END)))) {
+        /* Free the memory associated with the temp string and return an
+         * error if:
          * a) Could not find the instance group start
          * b) Could not find the instance group end
          * c) Subgroup start and end are out of order
-         * d) There is more than one instance subgroup specified in the string.  There
-         *    should only be one subgroup per sub-permission string */
+         * d) There is more than one instance subgroup specified in the string.
+         *    There should only be one subgroup per sub-permission string */
         *result = RM_ERROR_PERM_STR_TOO_MANY_INST_GROUPS;
         goto parseError;
     }
@@ -130,15 +134,15 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
     foundInstName = RM_FALSE;
     instNameComplete = RM_FALSE;
     while (permStrPtr <= subgroupEnd) {
-        if ((isspace(*permStrPtr) || (*permStrPtr == RM_POLICY_PERM_SUBGROUP_END))
+        if ((isspace(*permStrPtr) ||
+            (*permStrPtr == RM_POLICY_PERM_SUBGROUP_END))
             && foundInstName) {
             /* First space encountered after copying an instance name.  This
              * terminates the instance name.  All other space characters are
              * ignored. */
             instNameTemp[instNameIndex] = '\0';
             instNameComplete = RM_TRUE; 
-        }
-        else {
+        } else {
             if (!foundInstName) {
                 /* First non-whitespace character encountered is the start of an
                  * instance name */
@@ -150,8 +154,8 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
         }
 
         if (instNameComplete) {
-            newPerm = (Rm_PolicyPermission *) Rm_osalMalloc(sizeof(Rm_PolicyPermission));
-            memset((void *)newPerm, 0, sizeof(Rm_PolicyPermission));
+            newPerm = Rm_osalMalloc(sizeof(*newPerm));
+            memset((void *)newPerm, 0, sizeof(*newPerm));
 
             rm_strncpy(newPerm->instName, instNameTemp, RM_NAME_MAX_CHARS);
             newPerm->nextPermission = NULL;
@@ -159,8 +163,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
             if (prevPerm == NULL) {
                 /* Save the first instance so it can be returned */
                 startPerm = newPerm;
-            }
-            else {
+            } else {
                 prevPerm->nextPermission = newPerm;
             }
             prevPerm = newPerm;
@@ -168,8 +171,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
             instNameComplete = RM_FALSE;
             instNameIndex = 0;
             foundInstName = RM_FALSE;
-        }
-        else if (instNameIndex == RM_NAME_MAX_CHARS) {
+        } else if (instNameIndex == RM_NAME_MAX_CHARS) {
             /* Instance name is longer than max length */
             *result = RM_ERROR_INST_NAME_IN_ASSIGNMENT_TOO_LONG;
             goto parseError;
@@ -187,19 +189,17 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
     {
         if (*permStrPtr == RM_POLICY_PERM_ASSIGNMENT) {
             if (assignmentLeft) {
-                /* Assignment character has been found more than once.  This is a
-                 * syntax error.  Free the permission list and the temporary string
-                 * and return. */
+                /* Assignment character has been found more than once.  This
+                 * is a syntax error.  Free the permission list and the
+                 * temporary string and return. */
                 *result = RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS;
                 goto parseError;
-            }
-            else {
+            } else {
                 assignmentLeft = RM_TRUE;
             }
-        }
-        else if (!isspace(*permStrPtr)) {
+        } else if (!isspace(*permStrPtr)) {
             if (assignmentLeft) {
-                if ((*permStrPtr == RM_POLICY_PERM_INIT_LOWER) || 
+                if ((*permStrPtr == RM_POLICY_PERM_INIT_LOWER) ||
                     (*permStrPtr == RM_POLICY_PERM_INIT_UPPER)) {
                     newPerm = startPerm;
                     while (newPerm) {
@@ -208,8 +208,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
                                            RM_POLICY_PERM_INIT_SHIFT, 1);
                         newPerm = newPerm->nextPermission;
                     }
-                }
-                else if ((*permStrPtr == RM_POLICY_PERM_USE_LOWER) || 
+                } else if ((*permStrPtr == RM_POLICY_PERM_USE_LOWER) ||
                          (*permStrPtr == RM_POLICY_PERM_USE_UPPER)) {
                     newPerm = startPerm;
                     while (newPerm) {
@@ -218,8 +217,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
                                            RM_POLICY_PERM_USE_SHIFT, 1);
                         newPerm = newPerm->nextPermission;
                     }
-                }
-                else if ((*permStrPtr == RM_POLICY_PERM_EXCLUSIVE_LOWER) || 
+                } else if ((*permStrPtr == RM_POLICY_PERM_EXCLUSIVE_LOWER) ||
                          (*permStrPtr == RM_POLICY_PERM_EXCLUSIVE_UPPER)) {
                     newPerm = startPerm;
                     while (newPerm) {
@@ -228,8 +226,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
                                            RM_POLICY_PERM_EXCLUSIVE_SHIFT, 1);
                         newPerm = newPerm->nextPermission;
                     }
-                }
-                else if ((*permStrPtr == RM_POLICY_PERM_SHARED_LINUX_LOWER) || 
+                } else if ((*permStrPtr == RM_POLICY_PERM_SHARED_LINUX_LOWER) ||
                          (*permStrPtr == RM_POLICY_PERM_SHARED_LINUX_UPPER)) {
                     newPerm = startPerm;
                     while (newPerm) {
@@ -239,19 +236,17 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
                                            1);
                         newPerm = newPerm->nextPermission;
                     }
-                }                
-                else {
-                    /* Invalid permission character.  This is a
-                     * syntax error.  Free the permission list and the temporary string
+                } else {
+                    /* Invalid permission character.  This is a syntax error.
+                     * Free the permission list and the temporary string
                      * and return. */
                     *result = RM_ERROR_PERM_STR_INVALID_CHAR;
                     goto parseError;
                 }
-            }
-            else {
-                /* Character found without the assignment character being found.  This is a
-                 * syntax error.  Free the permission list and the temporary string
-                 * and return. */
+            } else {
+                /* Character found without the assignment character being found.
+                 * This is a syntax error.  Free the permission list and the
+                 * temporary string and return. */
                 *result = RM_ERROR_PERM_CHAR_WITHOUT_ASSIGN_CHAR;
                 goto parseError;
             }
@@ -264,26 +259,25 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
     assignmentRight = RM_FALSE;
     while (permStrPtr < permStrEnd) {
         if (assignmentLeft && (!isspace(*permStrPtr))) {
-            /* There should be nothing but spaces on right if assignment was already found on left */
+            /* There should be nothing but spaces on right if assignment was
+             * already found on left */
             *result = RM_ERROR_INVALID_PERMS_CHAR_ON_RIGHT;
-            goto parseError;             
+            goto parseError;
         }
-        
+
         if (*permStrPtr == RM_POLICY_PERM_ASSIGNMENT) {
             if (assignmentRight) {
-                /* Assignment character has been found more than once.  This is a
-                 * syntax error.  Free the permission list and the temporary string
-                 * and return. */
+                /* Assignment character has been found more than once.  This is
+                 * a syntax error.  Free the permission list and the temporary
+                 * string and return. */
                 *result = RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS;
-                goto parseError;               
-            }
-            else {
+                goto parseError;
+            } else {
                 assignmentRight = RM_TRUE;
             }
-        }
-        else if (!isspace(*permStrPtr)) {
+        } else if (!isspace(*permStrPtr)) {
             if (assignmentRight) {
-                if ((*permStrPtr == RM_POLICY_PERM_INIT_LOWER) || 
+                if ((*permStrPtr == RM_POLICY_PERM_INIT_LOWER) ||
                     (*permStrPtr == RM_POLICY_PERM_INIT_UPPER)) {
                     newPerm = startPerm;
                     while (newPerm) {
@@ -292,8 +286,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
                                            RM_POLICY_PERM_INIT_SHIFT, 1);
                         newPerm = newPerm->nextPermission;
                     }
-                }
-                else if ((*permStrPtr == RM_POLICY_PERM_USE_LOWER) || 
+                } else if ((*permStrPtr == RM_POLICY_PERM_USE_LOWER) ||
                          (*permStrPtr == RM_POLICY_PERM_USE_UPPER)) {
                     newPerm = startPerm;
                     while (newPerm) {
@@ -302,8 +295,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
                                            RM_POLICY_PERM_USE_SHIFT, 1);
                         newPerm = newPerm->nextPermission;
                     }
-                }
-                else if ((*permStrPtr == RM_POLICY_PERM_EXCLUSIVE_LOWER) || 
+                } else if ((*permStrPtr == RM_POLICY_PERM_EXCLUSIVE_LOWER) ||
                          (*permStrPtr == RM_POLICY_PERM_EXCLUSIVE_UPPER)) {
                     newPerm = startPerm;
                     while (newPerm) {
@@ -312,8 +304,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
                                            RM_POLICY_PERM_EXCLUSIVE_SHIFT, 1);
                         newPerm = newPerm->nextPermission;
                     }
-                }
-                else if ((*permStrPtr == RM_POLICY_PERM_SHARED_LINUX_LOWER) || 
+                } else if ((*permStrPtr == RM_POLICY_PERM_SHARED_LINUX_LOWER) ||
                          (*permStrPtr == RM_POLICY_PERM_SHARED_LINUX_UPPER)) {
                     newPerm = startPerm;
                     while (newPerm) {
@@ -323,19 +314,17 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
                                            1);
                         newPerm = newPerm->nextPermission;
                     }
-                }                  
-                else {
-                    /* Invalid permission character.  This is a
-                     * syntax error.  Free the permission list and the temporary string
+                } else {
+                    /* Invalid permission character.  This is a syntax error.
+                     * Free the permission list and the temporary string
                      * and return. */
                     *result = RM_ERROR_PERM_STR_INVALID_CHAR;
-                    goto parseError;                   
+                    goto parseError;
                 }
-            }
-            else {
-                /* Character found without the assignment character being found.  This is a
-                 * syntax error.  Free the permission list and the temporary string
-                 * and return. */
+            } else {
+                /* Character found without the assignment character being found.
+                 * This is a syntax error.  Free the permission list and the
+                 * temporary string and return. */
                 *result = RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS;
                 goto parseError;
             }
@@ -352,9 +341,9 @@ parseError:
         nextPerm = startPerm->nextPermission;
         Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
         startPerm = nextPerm;
-    }    
+    }
     Rm_osalFree((void *)permStrStart, permStrLen);
-    return(NULL);     
+    return(NULL);
 }
 
 /* FUNCTION PURPOSE: Frees a linked list of assignment permissions
@@ -366,7 +355,7 @@ parseError:
 static void policyFreeAssignmentPermissions(Rm_PolicyPermission *permissionList)
 {
     Rm_PolicyPermission *nextPerm;
-    
+
     while (permissionList) {
         nextPerm = permissionList->nextPermission;
         Rm_osalFree((void *)permissionList, sizeof(Rm_PolicyPermission));
@@ -381,7 +370,7 @@ static void policyFreeAssignmentPermissions(Rm_PolicyPermission *permissionList)
  *              Each node in the linked list will contain a valid instance
  *              name along with the permissions assigned to the instance
  */
-static Rm_PolicyPermission *policyGetAssignmentPermissions(Rm_PolicyAssignment *assignment, 
+static Rm_PolicyPermission *policyGetAssignmentPermissions(Rm_PolicyAssignment *assignment,
                                                            int32_t *result)
 {
     Rm_PolicyPermission *startPerm = NULL;
@@ -393,13 +382,14 @@ static Rm_PolicyPermission *policyGetAssignmentPermissions(Rm_PolicyAssignment *
     uint32_t             i = 0;
 
     *result = RM_OK;
-    
+
     while(i < permStrLen) {
-        /* Find the first sub-permission specification and parse it.  A sub-permission
-         * can be terminated by the termination character or the end of the string. */
-        if (!(permStrEnd = strchr(permStrStart, RM_POLICY_PERM_TERMINATOR))) {           
-            /* Sub-permission termination character not found.  The permission string
-             * end is the end of the entire permission string */
+        /* Find the first sub-permission specification and parse it.  A
+         * sub-permission can be terminated by the termination character or the
+         * end of the string. */
+        if (!(permStrEnd = strchr(permStrStart, RM_POLICY_PERM_TERMINATOR))) {
+            /* Sub-permission termination character not found.  The permission
+             * string end is the end of the entire permission string */
             permStrEnd = permStrStart + strlen(permStrStart);
         }
 
@@ -414,19 +404,19 @@ static Rm_PolicyPermission *policyGetAssignmentPermissions(Rm_PolicyAssignment *
 
         if (prevPerm == NULL) {
             startPerm = newPerm;
-        }
-        else {
+        } else {
             prevPerm->nextPermission = newPerm;
         }
 
-        /* Set prevPerm to the last sub-permission returned by the sub-permission parser */
+        /* Set prevPerm to the last sub-permission returned by the
+         * sub-permission parser */
         prevPerm = newPerm;
         while(prevPerm->nextPermission != NULL) {
             prevPerm = prevPerm->nextPermission;
         }
-        
-        /* Update the number of characters parsed from the permission list and point to 
-         * the start of the next sub-permission */
+
+        /* Update the number of characters parsed from the permission list and
+         * point to the start of the next sub-permission */
         i += ((uint32_t)(permStrEnd - permStrStart + 1));
         permStrStart = permStrEnd + 1;
     }
@@ -633,7 +623,7 @@ Rm_PolicyValidInstNode *rmPolicyGetLinuxInstNode(Rm_Handle rmHandle)
 {
     const char linuxName[] = RM_ALLOCATED_TO_LINUX;
 
-    return (rmPolicyGetValidInstNode(rmHandle, linuxName));
+    return(rmPolicyGetValidInstNode(rmHandle, linuxName));
 }
 
 /* FUNCTION PURPOSE: Validates resource permissions against a Policy DTB
@@ -712,7 +702,7 @@ int32_t rmPolicyCheckPrivilege(Rm_PolicyCheckCfg *privilegeCfg)
 
         matchEnd = matchNode->base + matchNode->len - 1;
         findEnd  = findNode.base + findNode.len - 1;
-        
+
         /* Check node to right if request range spans matching node to right */
         if (findEnd > matchEnd) {
             matchNode = RB_NEXT(_Rm_AllocatorPolicyTree, privilegeCfg->polTree,
index 6bedf7b861c3da8f331526604d81ad896f2760c5..ed3d758adedc46f57dd7aa6adc3539ba1b8b56a6 100644 (file)
@@ -161,11 +161,12 @@ void Rm_serviceHandler (void *rmHandle, const Rm_ServiceReqInfo *serviceRequest,
 
         if ((rmInst->instType == Rm_instType_SHARED_SERVER) && 
             (transaction->state == RM_SERVICE_PROCESSING)) {
-            /* Shared Server should always return a fully processed transaction */
+            /* Shared Server should always return a fully processed
+             * transaction */
             serviceResponse->serviceState = RM_ERROR_SHARED_INSTANCE_UNFINISHED_REQ;
             rmTransactionQueueDelete(rmInst, transaction->localId);
         } else {
-            if ((transaction->state == RM_SERVICE_PROCESSING) && 
+            if ((transaction->state == RM_SERVICE_PROCESSING) &&
                 (transaction->u.callback.serviceCallback == NULL)) {
                 /* Block until response is received.  Response will be
                  * received in transaction. */
@@ -251,15 +252,14 @@ Rm_ServiceHandle *Rm_serviceOpenHandle(Rm_Handle rmHandle, int32_t *result)
             serviceHandle->Rm_serviceHandler = Rm_serviceHandler;
             RM_SS_OBJ_WB(rmInst, serviceHandle, Rm_ServiceHandle);
             rmInst->serviceHandle = serviceHandle;
-        }
-        else {
+        } else {
             *result = RM_ERROR_SERVICE_HANDLE_MEM_ALLOC_FAILED;
         }
     }
-    
+
     if (rmInst->mtSemObj) {
         Rm_osalMtCsExit(rmInst->mtSemObj, mtKey);
-    }    
+    }
     RM_SS_INST_WB_EXIT_CS(rmInst, key);
     return (serviceHandle);
 }
@@ -283,14 +283,13 @@ int32_t Rm_serviceCloseHandle(Rm_ServiceHandle *rmServiceHandle)
     if (rmInst->serviceHandle) {
         Rm_osalFree((void *)rmServiceHandle, sizeof(*rmServiceHandle));
         rmInst->serviceHandle = NULL;
-    }
-    else {
+    } else {
         retVal = RM_ERROR_SERVICE_HANDLE_ALREADY_CLOSED;
     }
-    
+
     if (rmInst->mtSemObj) {
         Rm_osalMtCsExit(rmInst->mtSemObj, mtKey);
-    }    
+    }
     RM_SS_INST_WB_EXIT_CS(rmInst, key);
     return(retVal);
 }
index c105a143a989ab87a19c39e05c8fdfc1cb641785..db14c8853bd65a04cbf2b1be6a23aebb9c3f6a54 100644 (file)
@@ -82,12 +82,11 @@ static Rm_Transport *transportAdd(const Rm_TransportCfg *transportCfg)
                 transports = transports->nextTransport;\r
             }\r
             transports->nextTransport = newTransport;\r
-        }\r
-        else {\r
+        } else {\r
             rmInst->transports = newTransport;\r
         }\r
     }\r
-    return (newTransport);\r
+    return(newTransport);\r
 }\r
 \r
 /* FUNCTION PURPOSE: Tests if a transport is registered to an instance\r
@@ -99,14 +98,14 @@ static int transportIsRegistered(Rm_Handle rmHandle, Rm_Transport *transport)
 {\r
     Rm_Inst      *rmInst = (Rm_Inst *)rmHandle;\r
     Rm_Transport *transportList = (Rm_Transport *)rmInst->transports;\r
-    \r
+\r
     while (transportList) {\r
         if (transportList == transport) {\r
-            return(RM_TRUE);             \r
+            return(RM_TRUE);\r
         }\r
         transportList = transportList->nextTransport;\r
     }\r
-    return (RM_FALSE);\r
+    return(RM_FALSE);\r
 }\r
 \r
 /* FUNCTION PURPOSE: Deletes a transport\r
@@ -124,7 +123,7 @@ static void transportDelete(Rm_Transport *transport)
     /* Get previous transport in list */\r
     while (transportList) {\r
         if (transportList == transport) {\r
-            break;             \r
+            break;\r
         }\r
         prevTransport = transportList;\r
         transportList = transportList->nextTransport;\r
@@ -132,35 +131,12 @@ static void transportDelete(Rm_Transport *transport)
 \r
     if (prevTransport == NULL) {\r
          rmInst->transports = transport->nextTransport;\r
-    }\r
-    else {\r
+    } else {\r
          prevTransport->nextTransport = transport->nextTransport;\r
     }\r
     Rm_osalFree((void *)transport, sizeof(Rm_Transport));\r
 }\r
 \r
-/**********************************************************************\r
- ********************** Internal Functions ****************************\r
- **********************************************************************/\r
-\r
-/* FUNCTION PURPOSE: Finds a transport based on remote inst type\r
- ***********************************************************************\r
- * DESCRIPTION: Returns a pointer to the transport within an instance's\r
- *              transport list that matches the provided remote\r
- *              instance type.  NULL is returned if no transports in \r
- *              the list match the remote instance type.\r
- */\r
-Rm_Transport *rmTransportFindRemoteInstType(Rm_Transport *transports, Rm_InstType remoteInstType)\r
-{\r
-    while (transports) {\r
-        if (transports->remoteInstType == remoteInstType) {\r
-            break;             \r
-        }\r
-        transports = transports->nextTransport;\r
-    }\r
-    return (transports);\r
-}\r
-\r
 /* FUNCTION PURPOSE: Returns RM packet source instance\r
  ***********************************************************************\r
  * DESCRIPTION: Can return the RM instance name for one of two things:\r
@@ -168,27 +144,28 @@ Rm_Transport *rmTransportFindRemoteInstType(Rm_Transport *transports, Rm_InstTyp
  *                  - RM instance from which the service request contained\r
  *                    in the provided RM packet originated\r
  */\r
-int32_t getPktSrcNames(const Rm_Packet *pkt, char *pktSrc, char *serviceSrc, int32_t bufLen)\r
+static int32_t getPktSrcNames(const Rm_Packet *pkt, char *pktSrc,\r
+                              char *serviceSrc, int32_t bufLen)\r
 {\r
     int32_t retVal = RM_OK;\r
 \r
     if (bufLen != RM_NAME_MAX_CHARS) {\r
         retVal = RM_ERROR_SRC_NAME_BUF_INVALID_SIZE;\r
-    }\r
-    else {\r
+    } else {\r
         switch (pkt->pktType) {\r
             case Rm_pktType_RESOURCE_REQUEST:\r
             {\r
                 Rm_ResourceRequestPkt *resourceReqPkt = (Rm_ResourceRequestPkt *)pkt->data;\r
 \r
                 if (pktSrc){\r
-                    rm_strncpy(pktSrc, resourceReqPkt->pktSrcInstName, RM_NAME_MAX_CHARS);\r
+                    rm_strncpy(pktSrc, resourceReqPkt->pktSrcInstName,\r
+                               RM_NAME_MAX_CHARS);\r
                 }\r
 \r
                 if (serviceSrc) {\r
-                    rm_strncpy(serviceSrc, resourceReqPkt->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
+                    rm_strncpy(serviceSrc, resourceReqPkt->serviceSrcInstName,\r
+                               RM_NAME_MAX_CHARS);\r
                 }\r
-\r
                 break;\r
             }\r
             case Rm_pktType_NAMESERVER_REQUEST:\r
@@ -196,26 +173,48 @@ int32_t getPktSrcNames(const Rm_Packet *pkt, char *pktSrc, char *serviceSrc, int
                 Rm_NsRequestPkt *nsRequestPkt = (Rm_NsRequestPkt *)pkt->data;\r
 \r
                 if (pktSrc){\r
-                    rm_strncpy(pktSrc, nsRequestPkt->pktSrcInstName, RM_NAME_MAX_CHARS);\r
+                    rm_strncpy(pktSrc, nsRequestPkt->pktSrcInstName,\r
+                               RM_NAME_MAX_CHARS);\r
                 }\r
 \r
                 if (serviceSrc) {\r
-                    rm_strncpy(serviceSrc, nsRequestPkt->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
+                    rm_strncpy(serviceSrc, nsRequestPkt->serviceSrcInstName,\r
+                               RM_NAME_MAX_CHARS);\r
                 }\r
-\r
                 break;\r
             }\r
             case Rm_pktType_RESOURCE_RESPONSE:\r
             case Rm_pktType_NAMESERVER_RESPONSE:\r
             default:\r
-            {\r
                 retVal = RM_ERROR_PKT_AND_SERVICE_SRC_NOT_AVAIL;\r
                 break;\r
-            }\r
         }\r
     }\r
 \r
-    return (retVal);\r
+    return(retVal);\r
+}\r
+\r
+/**********************************************************************\r
+ ********************** Internal Functions ****************************\r
+ **********************************************************************/\r
+\r
+/* FUNCTION PURPOSE: Finds a transport based on remote inst type\r
+ ***********************************************************************\r
+ * DESCRIPTION: Returns a pointer to the transport within an instance's\r
+ *              transport list that matches the provided remote\r
+ *              instance type.  NULL is returned if no transports in \r
+ *              the list match the remote instance type.\r
+ */\r
+Rm_Transport *rmTransportFindRemoteInstType(Rm_Transport *transports,\r
+                                            Rm_InstType remoteInstType)\r
+{\r
+    while (transports) {\r
+        if (transports->remoteInstType == remoteInstType) {\r
+            break;\r
+        }\r
+        transports = transports->nextTransport;\r
+    }\r
+    return(transports);\r
 }\r
 \r
 /**********************************************************************\r
@@ -234,7 +233,8 @@ int32_t getPktSrcNames(const Rm_Packet *pkt, char *pktSrc, char *serviceSrc, int
  *              is returned for the transport handle if any errors\r
  *              are encountered.\r
  */\r
-Rm_TransportHandle Rm_transportRegister (const Rm_TransportCfg *transportCfg, int32_t *result)\r
+Rm_TransportHandle Rm_transportRegister(const Rm_TransportCfg *transportCfg,\r
+                                        int32_t *result)\r
 {\r
     Rm_Inst      *rmInst = (Rm_Inst *) transportCfg->rmHandle;\r
     Rm_Transport *transport = NULL;\r
@@ -270,22 +270,22 @@ Rm_TransportHandle Rm_transportRegister (const Rm_TransportCfg *transportCfg, in
         goto errorExit;\r
     }\r
 \r
-    /* Verify Clients are not registering with more than one Client Delegate or Server. And\r
-     * that Client Delegate is not registering with more than one Server. */\r
+    /* Verify Clients are not registering with more than one Client Delegate or\r
+     * Server. And that Client Delegate is not registering with more than one\r
+     * Server. */\r
     if (rmInst->registeredWithDelegateOrServer &&\r
         (((rmInst->instType == Rm_instType_CLIENT) &&\r
-          (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)) || \r
+          (transportCfg->remoteInstType == Rm_instType_CLIENT_DELEGATE)) ||\r
          ((rmInst->instType == Rm_instType_CLIENT_DELEGATE) &&\r
           (transportCfg->remoteInstType == Rm_instType_SERVER)))) {\r
         *result = RM_ERROR_ALREADY_REGD_SERVER_OR_CD;\r
         goto errorExit;\r
-    }         \r
-    \r
+    }\r
+\r
     if (!transportCfg->transportCallouts.rmAllocPkt) {\r
         *result = RM_ERROR_TRANSPORT_ALLOC_PKT_NOT_REGD;\r
         goto errorExit;\r
-    }\r
-    else if (!transportCfg->transportCallouts.rmSendPkt) {\r
+    } else if (!transportCfg->transportCallouts.rmSendPkt) {\r
         *result = RM_ERROR_TRANSPORT_SEND_NOT_REGD;\r
         goto errorExit;\r
     }\r
@@ -299,8 +299,8 @@ Rm_TransportHandle Rm_transportRegister (const Rm_TransportCfg *transportCfg, in
 errorExit:\r
     if (rmInst->mtSemObj) {\r
         Rm_osalMtCsExit(rmInst->mtSemObj, mtKey);\r
-    }    \r
-    RM_SS_INST_WB_EXIT_CS(rmInst, key);    \r
+    }\r
+    RM_SS_INST_WB_EXIT_CS(rmInst, key);\r
     return ((Rm_TransportHandle) transport);\r
 }\r
 \r
@@ -310,7 +310,8 @@ errorExit:
  *              configuration parameters if it exists within the \r
  *              instance.\r
  */\r
-int32_t Rm_transportReconfig (Rm_TransportHandle transportHandle, const Rm_TransportReCfg *reCfg)\r
+int32_t Rm_transportReconfig(Rm_TransportHandle transportHandle,\r
+                             const Rm_TransportReCfg *reCfg)\r
 {\r
     Rm_Transport *transport = (Rm_Transport *)transportHandle;\r
     Rm_Inst      *rmInst = (Rm_Inst *)transport->rmHandle;\r
@@ -324,8 +325,8 @@ int32_t Rm_transportReconfig (Rm_TransportHandle transportHandle, const Rm_Trans
     }\r
 \r
     if (transportIsRegistered(transport->rmHandle, transport)) {\r
-        /* Reconfigure existing transport's appTransportHandle.  Used in cases where instances\r
-         * running on same core connected by function call. */\r
+        /* Reconfigure existing transport's appTransportHandle.  Used in cases\r
+         * where instances running on same core connected by function call. */\r
         transport->appTransportHandle = reCfg->appTransportHandle;\r
 \r
         if (reCfg->transportCallouts.rmAllocPkt) {\r
@@ -334,16 +335,15 @@ int32_t Rm_transportReconfig (Rm_TransportHandle transportHandle, const Rm_Trans
         if (reCfg->transportCallouts.rmSendPkt) {\r
             transport->callouts.rmSendPkt = reCfg->transportCallouts.rmSendPkt;\r
         }\r
-    }\r
-    else {\r
+    } else {\r
         retVal = RM_ERROR_TRANSPORT_HANDLE_DOES_NOT_EXIST;\r
-    }        \r
+    }\r
 \r
     if (rmInst->mtSemObj) {\r
         Rm_osalMtCsExit(rmInst->mtSemObj, mtKey);\r
     }\r
-    RM_SS_INST_WB_EXIT_CS(rmInst, key);    \r
-    return (retVal);\r
+    RM_SS_INST_WB_EXIT_CS(rmInst, key);\r
+    return(retVal);\r
 }\r
 \r
 /* FUNCTION PURPOSE: Unregisters an app transport from a RM instance\r
@@ -364,11 +364,10 @@ int32_t Rm_transportUnregister(Rm_TransportHandle transportHandle)
             rmInst->registeredWithDelegateOrServer = RM_FALSE;\r
         }\r
         transportDelete(transport);\r
-    }\r
-    else {\r
+    } else {\r
         retVal = RM_ERROR_TRANSPORT_HANDLE_DOES_NOT_EXIST;\r
     }\r
-    return (retVal);\r
+    return(retVal);\r
 }\r
 \r
 /* FUNCTION PURPOSE: Returns a RM packet's service source instance name\r
@@ -376,8 +375,9 @@ int32_t Rm_transportUnregister(Rm_TransportHandle transportHandle)
  * DESCRIPTION: Returns the RM instance name from which the service\r
  *              encapsulated in the RM packet originated.\r
  */\r
-int32_t Rm_receiveGetPktServiceSrcName(const Rm_Packet *pkt, char *serviceInstName, \r
-                                         int32_t charBufLen)\r
+int32_t Rm_receiveGetPktServiceSrcName(const Rm_Packet *pkt,\r
+                                       char *serviceInstName,\r
+                                       int32_t charBufLen)\r
 {\r
     return(getPktSrcNames(pkt, NULL, serviceInstName, charBufLen));\r
 }\r
@@ -387,8 +387,8 @@ int32_t Rm_receiveGetPktServiceSrcName(const Rm_Packet *pkt, char *serviceInstNa
  * DESCRIPTION: Returns the RM instance name from which the RM packet\r
  *              originated.\r
  */\r
-int32_t Rm_receiveGetPktSrcName(const Rm_Packet *pkt, char *pktInstName, \r
-                                  int32_t charBufLen)\r
+int32_t Rm_receiveGetPktSrcName(const Rm_Packet *pkt, char *pktInstName,\r
+                                int32_t charBufLen)\r
 {\r
     return(getPktSrcNames(pkt, pktInstName, NULL, charBufLen));\r
 }\r
@@ -401,7 +401,8 @@ int32_t Rm_receiveGetPktSrcName(const Rm_Packet *pkt, char *pktInstName,
  *              invoking application will free packet after this\r
  *              function returns.\r
  */\r
-int32_t Rm_receivePacket(Rm_TransportHandle transportHandle, const Rm_Packet *pkt)\r
+int32_t Rm_receivePacket(Rm_TransportHandle transportHandle,\r
+                         const Rm_Packet *pkt)\r
 {\r\r\r
     Rm_Transport   *transport = (Rm_Transport *)transportHandle;\r
     Rm_Inst        *rmInst = (Rm_Inst *)transport->rmHandle;\r
@@ -421,36 +422,40 @@ int32_t Rm_receivePacket(Rm_TransportHandle transportHandle, const Rm_Packet *pk
             transaction = rmTransactionQueueAdd(rmInst);\r
             transaction->remoteOriginatingId = resourceReqPkt->requestId;\r
             transaction->u.respTrans = transport;\r
-            if (resourceReqPkt->resourceReqType == Rm_resReqPktType_ALLOCATE_INIT) {\r
+            if (resourceReqPkt->resourceReqType ==\r
+                Rm_resReqPktType_ALLOCATE_INIT) {\r
                 transaction->type = Rm_service_RESOURCE_ALLOCATE_INIT;\r
-            }\r
-            else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_ALLOCATE_USE) {\r
+            } else if (resourceReqPkt->resourceReqType ==\r
+                       Rm_resReqPktType_ALLOCATE_USE) {\r
                 transaction->type = Rm_service_RESOURCE_ALLOCATE_USE;\r
-            }\r
-            else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_GET_STATUS) {\r
+            } else if (resourceReqPkt->resourceReqType ==\r
+                       Rm_resReqPktType_GET_STATUS) {\r
                 transaction->type = Rm_service_RESOURCE_STATUS;\r
-            }\r
-            else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_FREE) {\r
+            } else if (resourceReqPkt->resourceReqType ==\r
+                       Rm_resReqPktType_FREE) {\r
                 transaction->type = Rm_service_RESOURCE_FREE;\r
-            }\r
-            else if (resourceReqPkt->resourceReqType == Rm_resReqPktType_GET_NAMED) {\r
+            } else if (resourceReqPkt->resourceReqType ==\r
+                       Rm_resReqPktType_GET_NAMED) {\r
                 transaction->type = Rm_service_RESOURCE_GET_BY_NAME;\r
-            }            \r
-            rm_strncpy(transaction->serviceSrcInstName, resourceReqPkt->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
+            }\r
+            rm_strncpy(transaction->serviceSrcInstName,\r
+                       resourceReqPkt->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
             transaction->state = RM_SERVICE_PROCESSING;\r
-            memcpy ((void *)&(transaction->resourceInfo), (void *)&(resourceReqPkt->resourceInfo),\r
-                    sizeof(Rm_ResourceInfo));\r
+            memcpy((void *)&(transaction->resourceInfo),\r
+                   (void *)&(resourceReqPkt->resourceInfo),\r
+                   sizeof(Rm_ResourceInfo));\r
             break;\r
         }\r
         case Rm_pktType_RESOURCE_RESPONSE:\r
         {\r
             Rm_ResourceResponsePkt *resourceRespPkt = (Rm_ResourceResponsePkt *)pkt->data;\r
 \r
-            if ((transaction = rmTransactionQueueFind(rmInst,resourceRespPkt->responseId))) {\r
+            if ((transaction = rmTransactionQueueFind(rmInst,\r
+                                                resourceRespPkt->responseId))) {\r
                 if ((transaction->state == RM_SERVICE_APPROVED_STATIC) &&\r
                     (resourceRespPkt->requestState != RM_SERVICE_APPROVED)) {\r
-                    /* Lock the RM instance since service validated against static policy failed against \r
-                     * Server's global policy */\r
+                    /* Lock the RM instance since service validated against\r
+                     * static policy failed against Server's global policy */\r
                     rmInst->isLocked = RM_TRUE;\r
                 }\r
                 transaction->state = resourceRespPkt->requestState;\r
@@ -460,16 +465,15 @@ int32_t Rm_receivePacket(Rm_TransportHandle transportHandle, const Rm_Packet *pk
                      (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||\r
                      (transaction->type == Rm_service_RESOURCE_STATUS) ||\r
                      (transaction->type == Rm_service_RESOURCE_GET_BY_NAME))) {\r
-                    memcpy ((void *)&(transaction->resourceInfo), (void *)&(resourceRespPkt->resourceInfo),\r
-                            sizeof(Rm_ResourceInfo));\r
-                }\r
-                else {\r
+                    memcpy((void *)&(transaction->resourceInfo),\r
+                           (void *)&(resourceRespPkt->resourceInfo),\r
+                           sizeof(Rm_ResourceInfo));\r
+                else {\r
                     /* Always copy owner count and instance allocation count */\r
                     transaction->resourceInfo.ownerCount = resourceRespPkt->resourceInfo.ownerCount;\r
                     transaction->resourceInfo.instAllocCount = resourceRespPkt->resourceInfo.instAllocCount;\r
                 }\r
-            }\r
-            else {\r
+            } else {\r
                 retVal = RM_ERROR_PKT_RESP_DOES_NOT_MATCH_ANY_REQ;\r
                 goto errorExit;\r
             }\r
@@ -485,31 +489,33 @@ int32_t Rm_receivePacket(Rm_TransportHandle transportHandle, const Rm_Packet *pk
 \r
             if (nsRequestPkt->nsRequestType == Rm_nsReqPktType_MAP_RESOURCE) {\r
                 transaction->type = Rm_service_RESOURCE_MAP_TO_NAME;\r
-            }\r
-            else if (nsRequestPkt->nsRequestType == Rm_nsReqPktType_UNMAP_RESOURCE) {\r
+            } else if (nsRequestPkt->nsRequestType ==\r
+                       Rm_nsReqPktType_UNMAP_RESOURCE) {\r
                 transaction->type = Rm_service_RESOURCE_UNMAP_NAME;\r
             }\r
 \r
-            rm_strncpy(transaction->serviceSrcInstName, nsRequestPkt->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
+            rm_strncpy(transaction->serviceSrcInstName,\r
+                       nsRequestPkt->serviceSrcInstName, RM_NAME_MAX_CHARS);\r
             transaction->state = RM_SERVICE_PROCESSING;\r
-            memcpy ((void *)&(transaction->resourceInfo), (void *)&(nsRequestPkt->resourceInfo),\r
-                    sizeof(Rm_ResourceInfo));           \r
+            memcpy((void *)&(transaction->resourceInfo),\r
+                   (void *)&(nsRequestPkt->resourceInfo),\r
+                    sizeof(Rm_ResourceInfo));\r
             break;\r
         }\r
         case Rm_pktType_NAMESERVER_RESPONSE:\r
         {\r
             Rm_NsResponsePkt *nsResponsePkt = (Rm_NsResponsePkt *)pkt->data;\r
 \r
-            if ((transaction = rmTransactionQueueFind(rmInst, nsResponsePkt->responseId))) {\r
+            if ((transaction = rmTransactionQueueFind(rmInst,\r
+                                                  nsResponsePkt->responseId))) {\r
                 if ((transaction->state == RM_SERVICE_APPROVED_STATIC) &&\r
                     (nsResponsePkt->requestState != RM_SERVICE_APPROVED)) {\r
-                    /* Lock the RM instance since service validated against static policy failed against \r
-                     * Server's global policy */\r
+                    /* Lock the RM instance since service validated against\r
+                     * static policy failed against Server's global policy */\r
                     rmInst->isLocked = RM_TRUE;\r
                 }\r
                 transaction->state = nsResponsePkt->requestState;\r
-            }\r
-            else {\r
+            } else {\r
                 retVal = RM_ERROR_PKT_RESP_DOES_NOT_MATCH_ANY_REQ;\r
                 goto errorExit;\r
             }\r
@@ -521,7 +527,7 @@ int32_t Rm_receivePacket(Rm_TransportHandle transportHandle, const Rm_Packet *pk
     }\r
 \r
     /* Process received transaction */\r
-    rmProcessRouter(rmInst, transaction);   \r
+    rmProcessRouter(rmInst, transaction);\r
 errorExit:\r
     return(retVal);\r
 }\r