summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 7fd8dba)
raw | patch | inline | side by side (parent: 7fd8dba)
| author | Justin Sobota <jsobota@ti.com> | |
| Thu, 31 Jan 2013 20:45:10 +0000 (15:45 -0500) | ||
| committer | Justin Sobota <jsobota@ti.com> | |
| Thu, 31 Jan 2013 20:45:10 +0000 (15:45 -0500) |
| include/rm_dtb_utilloc.h | patch | blob | history | |
| include/rm_loc.h | patch | blob | history | |
| include/rm_servicesloc.h | patch | blob | history | |
| rm.h | patch | blob | history | |
| rm_services.h | patch | blob | history | |
| src/rm.c | patch | blob | history | |
| src/rm_dtb_util.c | patch | blob | history | |
| src/rm_services.c | patch | blob | history |
index c7273c105b8b4c303a9e60dfcdeeca37f4d75ee1..21d0395fd9f8fd5260cdf75eb45c02943a25343d 100644 (file)
--- a/include/rm_dtb_utilloc.h
+++ b/include/rm_dtb_utilloc.h
/* RM external includes */
#include <ti/drv/rm/rm.h>
-/**
-* @brief LIBFDT's return codes start at 1. Map a return value of 0 to an okay result
-* from the LIBFDT APIs
-*/
-#define RM_DTB_UTIL_RESULT_OKAY 0
/**
* @brief DTB starting node offset for parsing
*/
diff --git a/include/rm_loc.h b/include/rm_loc.h
index c4e3641eedcf05d517b56803a874b19fb352cca2..df6fb1113e8ab516b208e9de075d1977a1e7b663 100644 (file)
--- a/include/rm_loc.h
+++ b/include/rm_loc.h
} Rm_Allocator;
typedef struct {
- char instName[RM_NAME_MAX_CHARS];
- void *startupDtb;
- Rm_PolicyValidInstTree *validInstTree;
- uint32_t requestCount;
- Rm_ServicePreMainReq *preMainReqList;
-} Rm_PreMainInst;
+ void *staticPolicy;
+ Rm_PolicyValidInstTree *staticValidInstTree;
+ Rm_ServiceStaticReq *staticReqList;
+} Rm_StaticInfo;
typedef struct {
char instName[RM_NAME_MAX_CHARS];
Rm_ServiceHandle *serviceHandle;
bool registeredWithDelegateOrServer;
void *policy;
- void *staticPolicy;
Rm_PolicyValidInstTree *validInstances;
Rm_Allocator *allocators;
Rm_NameServerTree *nameServer;
uint32_t transactionSeqNum;
Rm_Transaction *transactionQueue;
Rm_TransportCallouts transportCallouts;
+ Rm_StaticInfo staticInfo;
} Rm_Inst;
Rm_Transaction *rmTransactionQueueAdd(Rm_Inst *rmInst);
Rm_Transaction *rmTransactionQueueFind(Rm_Inst *rmInst, uint32_t transactionId);
int32_t rmTransactionQueueDelete(Rm_Inst *rmInst, uint32_t transactionId);
uint32_t rmTransactionGetSequenceNum(Rm_Inst *rmInst);
-
Rm_Allocator *rmAllocatorFind(Rm_Allocator *allocatorList, char *resourceName);
-
void rmTransactionResponder (Rm_Inst *rmInst, Rm_Transaction *transaction);
void rmTransactionForwarder (Rm_Inst *rmInst, Rm_Transaction *transaction);
void rmTransactionProcessor (Rm_Inst *rmInst, Rm_Transaction *transaction);
index e8003a5521daa18450c4fa60c2d121af6d6419b6..9eab463ce0a2f6dec05db37f2dcb787a07709f8c 100644 (file)
--- a/include/rm_servicesloc.h
+++ b/include/rm_servicesloc.h
/*
- * file rmservicesloc.h
+ * file rm_servicesloc.h
*
* Private data structures of Resource Manager services layer.
*
/* RM external includes */
#include <ti/drv/rm/rm_services.h>
-typedef struct Rm_ServicePreMainReq_s {
- Rm_ServiceReqInfo *preMainReq;
- struct Rm_ServicePreMainReq_s *nextPreMainReq;
-} Rm_ServicePreMainReq;
+typedef struct Rm_ServiceStaticReq_s {
+ Rm_ServiceReqInfo *staticReq;
+ struct Rm_ServiceStaticReq_s *nextStaticReq;
+} Rm_ServiceStaticReq;
#ifdef __cplusplus
}
index e5e0ebed3ae1cf803c5d8a927b0ef28de783c7ff..ca6f1d2811a586fd4702a4f21beb6cc86dcbb2cd 100644 (file)
--- a/rm.h
+++ b/rm.h
#define RM_INIT_ERROR_POLICY_SYNTAX_ERROR_INVALID_PERM_CHAR -263
#define RM_INIT_ERROR_POLICY_SYNTAX_ERROR_PERM_CHAR_WITHOUT_ASSIGN_CHAR -264
#define RM_INIT_ERROR_POLICY_SYNTAX_ERROR_INVALID_CHAR_ON_RIGHT_WITH_ASSINMENT_ON_LEFT -265
-#define RM_INIT_ERROR_PREMAIN_INST_AND_POSTMAIN_INST_NAMES_DONT_MATCH -266
#define RM_INIT_ERROR_POLICY_UNKNOWN_RESOURCE_PROPERTY -267
#define RM_INIT_ERROR_POLICY_VALID_INSTANCE_NAME_TOO_LONG -268
#define RM_INIT_ERROR_POLICY_SYNTAX_ERROR_INSTANCE_NAME_IN_ASSIGNMENT_TOO_LONG -269
#define RM_INIT_ERROR_SERVICE_HANDLE_MEMORY_ALLOC_FAILED -272
#define RM_INIT_ERROR_SERVICE_HANDLE_ALREADY_ALLOCATED -273
#define RM_INIT_ERROR_SERVICE_HANDLE_ALREADY_CLOSED_FOR_INSTANCE -274
+#define RM_INIT_ERROR_UNKNOWN_RESOURCE_LIST_PROPERTY_TYPE -275
+#define RM_INIT_ERROR_ALLOCATOR_DOES_NOT_EXIST -276
+#define RM_INIT_ERROR_RESOURCE_OVERLAP_WHEN_CREATING_ALLOCATOR -277
+#define RM_INIT_ERROR_COULD_NOT_LOCATE_RESOURCE_IN_LINUX_DTB -278
/** RM Service Request State Codes and Errors */
/** RM Service Request State Code Base */
/** The resource couldn't be allocated because it was already allocated to an instance with exclusive
* privileges for the resource */
#define RM_SERVICE_DENIED_RESOURCE_ALLOCATED_TO_INSTANCE_WITH_EXCLUSIVE_PRIV (RM_SERVICE_DENIED_BEGIN+21)
-/** Pre main request was not an allocate use or allocate init request */
-#define RM_SERVICE_DENIED_INVALID_PREMAIN_REQUEST (RM_SERVICE_DENIED_BEGIN+22)
-/** Startup policy denied pre-main allocation request */
-#define RM_SERVICE_DENIED_POLICY_DENIED_PREMAIN_ALLOCATION (RM_SERVICE_DENIED_BEGIN+23)
+/** Static request was not an allocate use or allocate init request */
+#define RM_SERVICE_DENIED_INVALID_STATIC_REQUEST (RM_SERVICE_DENIED_BEGIN+22)
+/** Startup policy denied static allocation request */
+#define RM_SERVICE_DENIED_POLICY_DENIED_STATIC_ALLOCATION (RM_SERVICE_DENIED_BEGIN+23)
/** End of resource denied reasons */
#define RM_SERVICE_DENIED_END (RM_SERVICE_DENIED_BEGIN+23)
Rm_instType_CLIENT = 2
} Rm_InstType;
-typedef struct {
- char *instName;
- Rm_InstType instType;
- void *startupPolicyDtb;
-} Rm_PreMainInitCfg;
-
/**
* @brief RM instance initialization structure
*/
* Note: This parameter will be ignored when the instance type is a
* Client
*/
- void *policy;
+ void *dynamicPolicy;
+ /** static policy used for pre-main allocation of resources. Resources given
+ * in the static will be verified against the global policy once the RM
+ * system is fully initialized */
+ void *staticPolicy;
} Rm_InitCfg;
/* TESTING PURPOSES: SERVER ONLY */
void Rm_printResourceStatus(Rm_Handle *rmHandle);
Rm_PreMainHandle Rm_preMainInit(Rm_PreMainInitCfg *preMainInitCfg, int32_t *result);
-/** [Server/Client Delegate Parameter] Pre-main allocation handle used to
- * by application to request resources prior to main via the startup policy
- * The preMainHandle will be used to validate the resources allocated prior
- * to main
- */
-int32_t Rm_preMainHandleValidateAndDelete(Rm_Handle rmHandle, Rm_PreMainHandle rmPreMainHandle);
+
+
+int32_t Rm_validateStaticRequests(Rm_Handle rmHandle);
/**
* @b Description
diff --git a/rm_services.h b/rm_services.h
index 188ca45cdd783c27f46cc25a691d991c7c5e0a6a..4969f7445e9d4e363d854fc151e7c01eae0e664b 100644 (file)
--- a/rm_services.h
+++ b/rm_services.h
Rm_ServiceRespInfo *serviceResponse);
} Rm_ServiceHandle;
-/**
- * @brief RM pre-main allocation request information provided by the pre-main
- * startup function requesting the resource */
-typedef struct {
- Rm_PreMainHandle rmPreMainHandle;
- Rm_ServiceReqInfo *request;
-} Rm_PreMainReqCfg;
-
-/**
- * @b Description
- * @n
- * Non-blocking function used by RTSC pre-main startup functions to
- * allocate RM resources for usage. Pre-main allocated resources will be
- * validated by RM against a memory-mapped startup resource policy.
- * Pre-main allocation of unauthorized resources will result in a system
- * exception.
- *
- * Note: Resource pre-main allocations can only occur on a core that is
- * running a RM Server or Client Delegate that has a startup policy
- * allowing the allocation of pre-main resources
- *
- * @param[in] preMainRequest
- * Resource pre-main allocation structure that provides details of the
- * resource requested from RM for preallocation
- *
- * @param[out] preMainResponse
- * Contains the result information regarding the pre-main allocation request
- *
- * @retval
- * Success - 0 - Resource pre-main allocation request okay.
- * @retval
- * Failure - non-zero - Resource pre-main allocation request error.
- */
-void Rm_servicePreMainRequest(Rm_PreMainReqCfg *reqCfg, Rm_ServiceRespInfo *preMainResp);
-
/**
* @b Description
* @n
diff --git a/src/rm.c b/src/rm.c
index 1baa97ff2d0d1e17b0858751ed4f80e9dfbc0421..3dfb2bb8b288439ef4019f47962ebb3c57110f0c 100644 (file)
--- a/src/rm.c
+++ b/src/rm.c
/**********************************************************************\r
************************** Globals ***********************************\r
**********************************************************************/\r
-extern const char rmDtbStartingNode[];\r
\r
/** @brief Global Variable which describes the RM Version Information */\r
const char rmVersionStr[] = RM_VERSION_STR ":" __DATE__ ":" __TIME__;\r
\r
if (allocator) {\r
if (prevAllocator == NULL) {\r
- /* Allocator at start of list. Map second allocator to start of list \r
- * as long as more than one allocators. */\r
rmInst->allocators = allocator->nextAllocator;\r
}\r
else {\r
- /* Allocator in middle or end of list. */\r
prevAllocator->nextAllocator = allocator->nextAllocator;\r
}\r
Rm_osalFree((void *)allocator, sizeof(Rm_Allocator));\r
}\r
else {\r
- retVal = -22; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
+ retVal = RM_INIT_ERROR_ALLOCATOR_DOES_NOT_EXIST;\r
}\r
return (retVal);\r
}\r
@@ -404,13 +400,13 @@ int32_t rmCreateTreeAllocator(Rm_Inst *rmInst, const char *resourceName, Rm_Reso
}\r
Rm_osalFree((void *)treeRootEntry, sizeof(Rm_ResourceTree));\r
rmAllocatorDelete(rmInst, allocator->resourceName);\r
- return (-24); /* TODO FIX RETURN */\r
+ return (RM_INIT_ERROR_RESOURCE_OVERLAP_WHEN_CREATING_ALLOCATOR);\r
}\r
range = range->nextRange;\r
}\r
\r
allocator->allocatorRootEntry = treeRootEntry;\r
- return(0); /* TODO: FIX THIS RETURN */\r
+ return(RM_INIT_OK);\r
}\r
\r
/* Called when an allocate request is made but the base is unspecified. RM must preallocate\r
int32_t rmReserveLinuxResource(Rm_Inst *rmInst, Rm_LinuxAlias *linuxAlias, \r
Rm_LinuxValueRange *linuxValues, Rm_AllocatorOpInfo *opInfo)\r
{\r
- int32_t retVal = RM_DTB_UTIL_RESULT_OKAY;\r
+ int32_t retVal = RM_INIT_OK;\r
bool baseFound = FALSE;\r
bool lengthFound = FALSE;\r
uint32_t valueIndex = 0;\r
\r
- while ((linuxValues != NULL) && (!baseFound || !lengthFound)) {\r
+ while ((linuxValues) && (!baseFound || !lengthFound)) {\r
if (linuxAlias->baseOffset == valueIndex) {\r
opInfo->resourceInfo->base = linuxValues->value;\r
baseFound = TRUE;\r
}\r
\r
if (!baseFound || !lengthFound) {\r
- retVal = -33; /* TODO: ERROR BASE OR LENGTH OFFSET IN LINUX DTB WAS INCORRECT */\r
+ retVal = RM_INIT_ERROR_COULD_NOT_LOCATE_RESOURCE_IN_LINUX_DTB;\r
}\r
else {\r
/* Allocate resource to Linux */\r
@@ -1354,7 +1350,7 @@ int32_t rmFindAndReserveLinuxResource(Rm_Inst *rmInst, const char *resourceName,
const char *propertyName;\r
const void *propertyData; \r
Rm_LinuxValueRange *linuxValueRange;\r
- int32_t retVal = RM_DTB_UTIL_RESULT_OKAY; \r
+ int32_t retVal = RM_INIT_OK; \r
\r
memset((void *) &opInfo, 0, sizeof(Rm_AllocatorOpInfo));\r
memset((void *) &resourceInfo, 0, sizeof(Rm_ResourceInfo));\r
@@ -1364,7 +1360,7 @@ int32_t rmFindAndReserveLinuxResource(Rm_Inst *rmInst, const char *resourceName,
opInfo.operation = Rm_allocatorOp_ALLOCATE;\r
opInfo.resourceInfo = &resourceInfo; \r
\r
- while(linuxAlias != NULL) {\r
+ while(linuxAlias) {\r
/* Reset parsing variables */\r
pathOffset = 0;\r
pathSize = strlen(linuxAlias->path) + 1;\r
@@ -1386,7 +1382,7 @@ int32_t rmFindAndReserveLinuxResource(Rm_Inst *rmInst, const char *resourceName,
if ((depth < prevDepth) || (nodeOffset == -FDT_ERR_NOTFOUND)) {\r
/* Returning from subnode that matched part of alias path without finding\r
* resource values */\r
- retVal = (-31); /* TODO: COULD NOT FIND RESOURCE AT ALIAS PATH */\r
+ retVal = (RM_INIT_ERROR_COULD_NOT_LOCATE_RESOURCE_IN_LINUX_DTB);\r
break;\r
}\r
}\r
@@ -1423,7 +1419,7 @@ int32_t rmFindAndReserveLinuxResource(Rm_Inst *rmInst, const char *resourceName,
}\r
}\r
\r
- if (retVal < RM_DTB_UTIL_RESULT_OKAY) {\r
+ if (retVal < RM_INIT_OK) {\r
break;\r
}\r
linuxAlias = (Rm_LinuxAlias *) linuxAlias->nextLinuxAlias;\r
Rm_NsAssignment *nsAssignmentBasePtr = NULL;\r
Rm_LinuxAlias *linuxAlias = NULL;\r
Rm_NameServerObjCfg nameServerObjCfg; \r
- int32_t retVal = RM_DTB_UTIL_RESULT_OKAY;\r
+ int32_t retVal = RM_INIT_OK;\r
\r
if (resourceProperties->rangeData && (resourceProperties->rangeLen > 0)) {\r
range = rangeBasePtr = rmDtbUtilResExtractRange(resourceProperties->rangeData, \r
resourceProperties->rangeLen);\r
\r
- if ((retVal = rmCreateTreeAllocator(rmInst, resourceName, range)) >= RM_DTB_UTIL_RESULT_OKAY) {\r
+ if ((retVal = rmCreateTreeAllocator(rmInst, resourceName, range)) >= RM_INIT_OK) {\r
if (resourceProperties->linuxAliasData && resourceProperties->linuxAliasLen) {\r
linuxAlias = rmDtbUtilResExtractLinuxAlias(resourceProperties->linuxAliasData,\r
resourceProperties->linuxAliasLen, &retVal);\r
}\r
}\r
\r
- if (retVal >= RM_DTB_UTIL_RESULT_OKAY) {\r
+ if (retVal >= RM_INIT_OK) {\r
if (resourceProperties->nsAssignData && resourceProperties->nsAssignLen) {\r
nsAssignments = rmDtbUtilResExtractNsAssignment(resourceProperties->nsAssignData, \r
resourceProperties->nsAssignLen, &retVal);\r
nameServerObjCfg.nodeCfg.resourceName = (char *)resourceName;\r
nameServerObjCfg.nodeCfg.resourceBase= nsAssignments->resourceBase;\r
nameServerObjCfg.nodeCfg.resourceLength = nsAssignments->resourceLength; \r
- \r
- /* TODO: RETURN IF ANY OF THE ADDS FAIL??? */\r
rmNameServerAddObject(&nameServerObjCfg);\r
nsAssignments = nsAssignments->nextNsAssignment;\r
}\r
@@ -1489,153 +1483,85 @@ int32_t rmCreateAndInitAllocator(Rm_Inst *rmInst, const char *resourceName,
\r
int32_t rmParseResourceProperty(void *globalResourceDtb, int32_t offset, Rm_ResourceProperties *propertyInfo)\r
{\r
- int32_t propertyLen;\r
- const char *propertyName;\r
- const void *propertyData;\r
- Rm_ResourcePropType propertyType;\r
- int32_t retVal = RM_DTB_UTIL_RESULT_OKAY;\r
+ int32_t propertyLen;\r
+ const char *propertyName;\r
+ const void *propertyData;\r
+ Rm_ResourcePropType propertyType;\r
+ int32_t retVal = RM_INIT_OK;\r
\r
- /* Get the property data and store it in the corresponding propertyInfo field */\r
propertyData = fdt_getprop_by_offset(globalResourceDtb, offset, &propertyName, &propertyLen);\r
- if (propertyData)\r
- {\r
- propertyType = rmDtbUtilResGetPropertyType(propertyName);\r
- if (propertyType == Rm_resourcePropType_RESOURCE_RANGE)\r
- {\r
- if (propertyInfo->rangeData || propertyInfo->rangeLen)\r
- {\r
- /* The range fields have already been populated. Return an error.\r
- * The resource list has specified a property field more than once\r
- * for a resource node */\r
- retVal = -18; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
- }\r
- else\r
- {\r
- propertyInfo->rangeData = propertyData;\r
- propertyInfo->rangeLen = propertyLen;\r
- }\r
- }\r
- else if (propertyType == Rm_resourcePropType_NSASSIGNMENT)\r
- {\r
- if (propertyInfo->nsAssignData || propertyInfo->nsAssignLen)\r
- {\r
- /* The nsAssign fields have already been populated. Return an error.\r
- * The resource list has specified a property field more than once\r
- * for a resource node */\r
- retVal = -19; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
- }\r
- else\r
- {\r
- propertyInfo->nsAssignData = propertyData;\r
- propertyInfo->nsAssignLen = propertyLen;\r
- }\r
- }\r
- else if (propertyType == Rm_resourcePropType_RESOURCE_LINUX_ALIAS)\r
- {\r
- if (propertyInfo->linuxAliasData || propertyInfo->linuxAliasLen)\r
- {\r
- /* The linuxAlias fields have already been populated. Return an error.\r
- * The resource list has specified a property field more than once\r
- * for a resource node */\r
- retVal = -28; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
- }\r
- else\r
- {\r
- propertyInfo->linuxAliasData = propertyData;\r
- propertyInfo->linuxAliasLen = propertyLen;\r
- }\r
- } \r
- else\r
- {\r
- retVal = -20; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
- }\r
- }\r
- else\r
- {\r
- retVal = -16; /* TEMP ERROR: Can't conflict with LIBFDT errors */\r
+ propertyType = rmDtbUtilResGetPropertyType(propertyName);\r
+ if (propertyType == Rm_resourcePropType_RESOURCE_RANGE) {\r
+ propertyInfo->rangeData = propertyData;\r
+ propertyInfo->rangeLen = propertyLen;\r
+ }\r
+ else if (propertyType == Rm_resourcePropType_NSASSIGNMENT) {\r
+ propertyInfo->nsAssignData = propertyData;\r
+ propertyInfo->nsAssignLen = propertyLen;\r
+ }\r
+ else if (propertyType == Rm_resourcePropType_RESOURCE_LINUX_ALIAS) {\r
+ propertyInfo->linuxAliasData = propertyData;\r
+ propertyInfo->linuxAliasLen = propertyLen;\r
+ } \r
+ else {\r
+ retVal = RM_INIT_ERROR_UNKNOWN_RESOURCE_LIST_PROPERTY_TYPE;\r
}\r
\r
- /* Don't get anymore properties if error occurred */\r
- if (retVal == RM_DTB_UTIL_RESULT_OKAY)\r
- {\r
+ if (retVal == RM_INIT_OK) {\r
offset = fdt_next_property_offset(globalResourceDtb, offset);\r
- if (offset >= 0)\r
- {\r
+ if (offset >= 0) {\r
retVal = rmParseResourceProperty(globalResourceDtb, offset, propertyInfo);\r
}\r
- else if (offset != -FDT_ERR_NOTFOUND)\r
- {\r
- /* Error was returned by LIBFDT when parsing the properties */\r
+ else if (offset != -FDT_ERR_NOTFOUND) {\r
+ /* Error returned by LIBFDT */\r
retVal = offset;\r
}\r
}\r
- \r
return (retVal);\r
}\r
\r
int32_t rmParseResourceNode(Rm_Inst *rmInst, void *globalResourceDtb, int32_t nodeOffset, int32_t depth,\r
void *linuxDtb)\r
{\r
- const char *resourceName = fdt_get_name(globalResourceDtb, nodeOffset, NULL);\r
- Rm_ResourceProperties resourceProperties;\r
- int32_t error = RM_DTB_UTIL_RESULT_OKAY;\r
- int32_t offset;\r
+ const char *resourceName = fdt_get_name(globalResourceDtb, nodeOffset, NULL);\r
+ Rm_ResourceProperties resourceProperties;\r
+ int32_t retVal = RM_INIT_OK;\r
+ int32_t offset;\r
\r
- /* Initialize the resource properties structure */\r
memset((void *)&resourceProperties, 0, sizeof(Rm_ResourceProperties));\r
-\r
- /* Ignore properties of the base node */\r
- if (strcmp(resourceName, rmDtbStartingNode))\r
- {\r
- /* Get the properties for the resource node if any exist */\r
- offset = fdt_first_property_offset(globalResourceDtb, nodeOffset);\r
- if (offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET)\r
- {\r
- /* Since at least one property exists attempt to parse the property nodes and \r
- * use them to create and initialize a resource allocator */\r
- error = rmParseResourceProperty(globalResourceDtb, offset, &resourceProperties);\r
- if (error < -FDT_ERR_NOTFOUND)\r
- {\r
- return (error);\r
- }\r
- \r
- /* Initialize an allocator with the resource properties if no error was returned */\r
- rmCreateAndInitAllocator(rmInst, resourceName, &resourceProperties, linuxDtb);\r
- }\r
- else if (offset != -FDT_ERR_NOTFOUND)\r
- {\r
- /* Error was returned by LIBFDT when parsing the properties */\r
- return (offset);\r
+ /* Get properties of resource node */\r
+ offset = fdt_first_property_offset(globalResourceDtb, nodeOffset);\r
+ if (offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) {\r
+ retVal = rmParseResourceProperty(globalResourceDtb, offset, &resourceProperties);\r
+ if (retVal < -FDT_ERR_NOTFOUND) {\r
+ return (retVal);\r
}\r
+ rmCreateAndInitAllocator(rmInst, resourceName, &resourceProperties, linuxDtb);\r
+ }\r
+ else if (offset != -FDT_ERR_NOTFOUND) {\r
+ /* Error returned by LIBFDT */\r
+ return (offset);\r
}\r
\r
- /* Get the next resource node */\r
offset = fdt_next_node(globalResourceDtb, nodeOffset, &depth);\r
- /* Check the offset and depth of the next node to make sure the current node\r
- * wasn't the last node in the Resource List. A depth less than the depth set\r
- * at the start of the recursion will signal the end of the resource list */\r
- if ((offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) && (depth >= RM_DTB_UTIL_STARTING_DEPTH))\r
- {\r
- error = rmParseResourceNode(rmInst, globalResourceDtb, offset, depth, linuxDtb);\r
- if (error < -FDT_ERR_NOTFOUND)\r
- {\r
- return (error);\r
+ if ((offset >= RM_DTB_UTIL_STARTING_NODE_OFFSET) && (depth >= RM_DTB_UTIL_STARTING_DEPTH)) {\r
+ retVal = rmParseResourceNode(rmInst, globalResourceDtb, offset, depth, linuxDtb);\r
+ if (retVal < -FDT_ERR_NOTFOUND) {\r
+ return (retVal);\r
}\r
}\r
- else if (offset != -FDT_ERR_NOTFOUND)\r
- {\r
- /* Error was returned by LIBFDT when parsing the nodes */\r
+ else if (offset != -FDT_ERR_NOTFOUND) {\r
+ /* Error returned by LIBFDT */\r
return (offset);\r
}\r
-\r
- return (RM_DTB_UTIL_RESULT_OKAY);\r
+ return (retVal);\r
}\r
\r
int32_t rmInitializeAllocators(Rm_Inst *rmInst, void *globalResourceDtb, void *linuxDtb)\r
{\r
int32_t nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;\r
int32_t startDepth = RM_DTB_UTIL_STARTING_DEPTH;\r
- int32_t result = RM_DTB_UTIL_RESULT_OKAY;\r
+ int32_t result = RM_INIT_OK;\r
\r
/* Recursively parse the Global Resource List, creating an allocator for\r
* each resource as specified in the node */\r
Rm_ResourceTree *treeRoot;\r
Rm_ResourceNode *treeNode;\r
\r
- while (allocator != NULL) {\r
- Rm_osalLog("Resource: %s\n", allocator->resourceName);\r
+ if (rmInst->instType == Rm_instType_SERVER) {\r
+ while (allocator != NULL) {\r
+ Rm_osalLog("Resource: %s\n", allocator->resourceName);\r
\r
- treeRoot = allocator->allocatorRootEntry;\r
+ treeRoot = allocator->allocatorRootEntry;\r
\r
- RB_FOREACH(treeNode, _Rm_AllocatorResourceTree, treeRoot) { \r
- Rm_osalLog(" %10d - %10d ", treeNode->base, \r
- treeNode->base + treeNode->length -1);\r
- \r
- if (treeNode->allocationCount == 0) {\r
- Rm_osalLog("NOT ALLOCATED\n");\r
- }\r
- else {\r
- owners = treeNode->ownerList;\r
- Rm_osalLog("allocated to ");\r
- while (owners) {\r
- Rm_osalLog(" %s", owners->instNameNode->name);\r
- owners = owners->nextOwner;\r
+ RB_FOREACH(treeNode, _Rm_AllocatorResourceTree, treeRoot) { \r
+ Rm_osalLog(" %10d - %10d ", treeNode->base, \r
+ treeNode->base + treeNode->length -1);\r
+ \r
+ if (treeNode->allocationCount == 0) {\r
+ Rm_osalLog("NOT ALLOCATED\n");\r
}\r
- Rm_osalLog("\n");\r
- }\r
- } \r
- allocator = allocator->nextAllocator;\r
+ else {\r
+ owners = treeNode->ownerList;\r
+ Rm_osalLog("allocated to ");\r
+ while (owners) {\r
+ Rm_osalLog(" %s", owners->instNameNode->name);\r
+ owners = owners->nextOwner;\r
+ }\r
+ Rm_osalLog("\n");\r
+ }\r
+ } \r
+ allocator = allocator->nextAllocator;\r
+ }\r
+ rmNameServerPrintObjects(rmInst->nameServer);\r
}\r
-\r
- rmNameServerPrintObjects(rmInst->nameServer);\r
}\r
\r
Rm_PreMainHandle Rm_preMainInit(Rm_PreMainInitCfg *preMainInitCfg, int32_t *result)\r
{\r
Rm_PreMainInst *preMainInst;\r
\r
- if ((strlen(preMainInitCfg->instName) + 1) > RM_NAME_MAX_CHARS) {\r
- *result = RM_INIT_ERROR_INSTANCE_NAME_TOO_BIG;\r
- return (NULL);\r
- }\r
\r
preMainInst = (Rm_PreMainInst *) Rm_osalMalloc (sizeof(Rm_PreMainInst));\r
fdt_open_into(preMainInitCfg->startupPolicyDtb, preMainInitCfg->startupPolicyDtb,\r
@@ -1721,33 +1644,6 @@ Rm_PreMainHandle Rm_preMainInit(Rm_PreMainInitCfg *preMainInitCfg, int32_t *resu
return((Rm_PreMainHandle)preMainInst);\r
}\r
\r
-int32_t Rm_preMainHandleValidateAndDelete(Rm_Handle rmHandle, Rm_PreMainHandle rmPreMainHandle)\r
-{\r
- Rm_Inst *rmInst = (Rm_Inst *)rmHandle;\r
- Rm_PreMainInst *preMainInst = (Rm_PreMainInst *)rmPreMainHandle;\r
- Rm_ServicePreMainReq *serviceReq = preMainInst->preMainReqList;\r
- Rm_ServicePreMainReq *nextServiceReq;\r
- int32_t retVal = RM_INIT_OK;\r
-\r
- if (strcmp(rmInst->instName, preMainInst->instName) == 0) {\r
- /* TODO: Validate the requests against the global policyDtb */\r
-\r
- /* Free all memory associated with the pre-main instance */\r
- rmPolicyFreeValidInstTree(preMainInst->validInstTree);\r
- while(serviceReq) {\r
- nextServiceReq = serviceReq->nextPreMainReq;\r
- Rm_osalFree((void *)serviceReq->preMainReq, sizeof(Rm_ServiceReqInfo));\r
- Rm_osalFree((void *)serviceReq, sizeof(Rm_ServicePreMainReq));\r
- serviceReq = nextServiceReq;\r
- }\r
- Rm_osalFree((void *)preMainInst, sizeof(Rm_PreMainInst));\r
- }\r
- else {\r
- retVal = RM_INIT_ERROR_PREMAIN_INST_AND_POSTMAIN_INST_NAMES_DONT_MATCH;\r
- }\r
- return(retVal);\r
-}\r
-\r
Rm_Handle Rm_init(Rm_InitCfg *initCfg, int32_t *result)\r
{\r
Rm_Inst *rmInst;\r
rmInst->transactionSeqNum = rmTransactionInitSequenceNum();\r
rmInst->transactionQueue= NULL;\r
\r
- if ((rmInst->instType != Rm_instType_CLIENT) && initCfg->policy) {\r
- rmInst->policy = initCfg->policy;\r
+ if ((rmInst->instType != Rm_instType_CLIENT) && initCfg->dynamicPolicy) {\r
+ rmInst->policy = initCfg->dynamicPolicy;\r
fdt_open_into(rmInst->policy, rmInst->policy, fdt_totalsize(rmInst->policy)); \r
\r
/* Create valid instance list from policy. Must be done prior to parsing\r
}\r
}\r
\r
- if ((rmInst->instType != Rm_instType_CLIENT) && initCfg->policy) {\r
+ if ((rmInst->instType != Rm_instType_CLIENT) && initCfg->dynamicPolicy) {\r
*result = rmPolicyValidatePolicyResourceNames(rmInst->policy, (void *)rmInst->allocators);\r
} \r
\r
diff --git a/src/rm_dtb_util.c b/src/rm_dtb_util.c
index aaf2c896cd236e06e991ccaf7f2808b8e87c7c46..eddbf769dbed93b5d18b1c57c6a569e47e148147 100644 (file)
--- a/src/rm_dtb_util.c
+++ b/src/rm_dtb_util.c
******************** Common DTB Parsing Globals **********************
**********************************************************************/
-const char rmDtbStartingNode[] = "\0";
-
/**********************************************************************
*************** Global Resource List Parsing Globals *****************
**********************************************************************/
diff --git a/src/rm_services.c b/src/rm_services.c
index 5120cd6754cc0423d6d99698b44fe6c996ca5731..885fd96380b8999b5d1a07159633cd4758afae73 100644 (file)
--- a/src/rm_services.c
+++ b/src/rm_services.c
void Rm_serviceHandler (void *rmHandle, Rm_ServiceReqInfo *serviceRequest,
Rm_ServiceRespInfo *serviceResponse)
{
- Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
- Rm_Transaction *transaction;
+ Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
+ Rm_Transaction *transaction;
+ Rm_PolicyCheckCfg privCheckCfg;
+ Rm_ServiceStaticReq *lastStaticReq;
- if (serviceRequest->callback.serviceCallback == NULL) {
- serviceResponse->serviceState = RM_SERVICE_ERROR_CALLBACK_NOT_PROVIDED;
- return;
- }
+ if (serviceRequest->reqType == Rm_reqType_STATIC) {
+ serviceResponse->serviceState = RM_SERVICE_PROCESSING;
- if (serviceRequest->type >= Rm_service_LAST) {
- serviceResponse->serviceState = RM_SERVICE_ERROR_INVALID_SERVICE_TYPE;
- return;
- }
-
- transaction = rmTransactionQueueAdd(rmInst);
- if (transaction) {
- transaction->type = serviceRequest->type;
- strncpy(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS);
- transaction->callback.serviceCallback = serviceRequest->callback.serviceCallback;
- transaction->state = RM_SERVICE_PROCESSING;
- if (serviceRequest->resourceName) {
- strncpy(transaction->resourceInfo.name, serviceRequest->resourceName, RM_NAME_MAX_CHARS);
+ if ((serviceRequest->serviceType == Rm_service_RESOURCE_ALLOCATE_INIT) ||
+ (serviceRequest->serviceType == Rm_service_RESOURCE_ALLOCATE_USE) ||
+ (serviceRequest->resourceBase != RM_RESOURCE_BASE_UNSPECIFIED)) {
+ /* Check request against startup policy */
+ memset((void *)&privCheckCfg, 0, sizeof(Rm_PolicyCheckCfg));
+
+ if (serviceRequest->serviceType == Rm_service_RESOURCE_ALLOCATE_INIT) {
+ privCheckCfg.type = Rm_policyCheck_INIT;
+ }
+ else {
+ privCheckCfg.type = Rm_policyCheck_USE;
+ }
+ privCheckCfg.policyDtb = rmInst->staticInfo.staticPolicy;
+ privCheckCfg.validInstNode = rmPolicyGetValidInstNode(rmInst->staticInfo.staticValidInstTree,
+ rmInst->instName);
+ privCheckCfg.resourceOffset = rmPolicyGetResourceOffset(rmInst->staticInfo.staticPolicy,
+ serviceRequest->resourceName);
+ privCheckCfg.resourceBase = serviceRequest->resourceBase;
+ privCheckCfg.resourceLength = serviceRequest->resourceLength;
+
+ if (rmPolicyCheckPrivilege(&privCheckCfg, &serviceResponse->serviceState)) {
+ serviceResponse->serviceState = RM_SERVICE_APPROVED_AND_COMPLETED;
+ }
+ else if (serviceResponse->serviceState == RM_SERVICE_PROCESSING) {
+ /* Privilege check returned FALSE without error */
+ serviceResponse->serviceState = RM_SERVICE_DENIED_POLICY_DENIED_STATIC_ALLOCATION;
+ }
}
- transaction->resourceInfo.base = serviceRequest->resourceBase;
- transaction->resourceInfo.length = serviceRequest->resourceLength;
- transaction->resourceInfo.alignment = serviceRequest->resourceAlignment;
- if (serviceRequest->resourceNsName) {
- strncpy(transaction->resourceInfo.nameServerName, serviceRequest->resourceNsName, RM_NAME_MAX_CHARS);
+ else {
+ serviceResponse->serviceState = RM_SERVICE_DENIED_INVALID_STATIC_REQUEST;
+ }
+
+ /* Store request for validation after instance transports have been established */
+ if (serviceResponse->serviceState == RM_SERVICE_APPROVED_AND_COMPLETED) {
+ lastStaticReq = rmInst->staticInfo.staticReqList;
+ while(lastStaticReq) {
+ lastStaticReq = lastStaticReq->nextStaticReq;
+ }
+ lastStaticReq = (Rm_ServiceStaticReq *) Rm_osalMalloc (sizeof(Rm_ServiceStaticReq));
+ lastStaticReq->nextStaticReq = NULL;
+ lastStaticReq->staticReq = (Rm_ServiceReqInfo *) Rm_osalMalloc(sizeof(Rm_ServiceReqInfo));
+ memcpy((void *)lastStaticReq->staticReq, (void *)serviceRequest, sizeof(Rm_ServiceReqInfo));
+
+ /* Fill out response */
+ serviceResponse->resourceBase = serviceRequest->resourceBase;
+ serviceResponse->resourceLength = serviceRequest->resourceLength;
+ strncpy(serviceResponse->resourceName, serviceRequest->resourceName, RM_NAME_MAX_CHARS);
+ serviceResponse->serviceId = rmTransactionGetSequenceNum(rmInst);
+ }
+ }
+ else if (serviceRequest->reqType == Rm_reqType_DYNAMIC) {
+ if (serviceRequest->callback.serviceCallback == NULL) {
+ serviceResponse->serviceState = RM_SERVICE_ERROR_CALLBACK_NOT_PROVIDED;
+ return;
}
- rmTransactionProcessor (rmInst, transaction);
- serviceResponse->serviceState = transaction->state;
- if (serviceResponse->serviceState == RM_SERVICE_PROCESSING) {
- /* Service still being processed. Provide transaction ID
- * back to component so it can sort service responses received
- * via callback function */
- serviceResponse->serviceId = transaction->localId;
+ if (serviceRequest->serviceType >= Rm_service_LAST) {
+ serviceResponse->serviceState = RM_SERVICE_ERROR_INVALID_SERVICE_TYPE;
+ return;
}
- else if (serviceResponse->serviceState == RM_SERVICE_APPROVED_AND_COMPLETED) {
- if ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
- (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||
- (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)) {
- strncpy(serviceResponse->resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
- serviceResponse->resourceBase = transaction->resourceInfo.base;
- serviceResponse->resourceLength = transaction->resourceInfo.length;
+
+ transaction = rmTransactionQueueAdd(rmInst);
+ if (transaction) {
+ transaction->type = serviceRequest->serviceType;
+ strncpy(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS);
+ transaction->callback.serviceCallback = serviceRequest->callback.serviceCallback;
+ transaction->state = RM_SERVICE_PROCESSING;
+ if (serviceRequest->resourceName) {
+ strncpy(transaction->resourceInfo.name, serviceRequest->resourceName, RM_NAME_MAX_CHARS);
+ }
+ transaction->resourceInfo.base = serviceRequest->resourceBase;
+ transaction->resourceInfo.length = serviceRequest->resourceLength;
+ transaction->resourceInfo.alignment = serviceRequest->resourceAlignment;
+ if (serviceRequest->resourceNsName) {
+ strncpy(transaction->resourceInfo.nameServerName, serviceRequest->resourceNsName, RM_NAME_MAX_CHARS);
+ }
+
+ rmTransactionProcessor (rmInst, transaction);
+ serviceResponse->serviceState = transaction->state;
+ if (serviceResponse->serviceState == RM_SERVICE_PROCESSING) {
+ /* Service still being processed. Provide transaction ID
+ * back to component so it can sort service responses received
+ * via callback function */
+ serviceResponse->serviceId = transaction->localId;
+ }
+ else if (serviceResponse->serviceState == RM_SERVICE_APPROVED_AND_COMPLETED) {
+ if ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
+ (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||
+ (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)) {
+ strncpy(serviceResponse->resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
+ serviceResponse->resourceBase = transaction->resourceInfo.base;
+ serviceResponse->resourceLength = transaction->resourceInfo.length;
+ }
+ rmTransactionQueueDelete(rmInst, transaction->localId);
+ }
+ else {
+ rmTransactionQueueDelete(rmInst, transaction->localId);
}
- rmTransactionQueueDelete(rmInst, transaction->localId);
}
else {
- rmTransactionQueueDelete(rmInst, transaction->localId);
+ serviceResponse->serviceState = RM_SERVICE_ERROR_TRANSACTION_FAILED_TO_ALLOCATE;
}
}
- else {
- serviceResponse->serviceState = RM_SERVICE_ERROR_TRANSACTION_FAILED_TO_ALLOCATE;
- }
return;
}
-void Rm_servicePreMainRequest(Rm_PreMainReqCfg *reqCfg, Rm_ServiceRespInfo *preMainResp)
+void Rm_serviceValidateStaticRequests(Rm_Handle rmHandle, Rm_ServiceCallback validateCallback)
{
- Rm_PreMainInst *preMainInst = (Rm_PreMainInst *)reqCfg->rmPreMainHandle;
- Rm_PolicyCheckCfg privCheckCfg;
- Rm_ServicePreMainReq *lastServiceReq;
-
- preMainResp->serviceState = RM_SERVICE_PROCESSING;
- preMainResp->serviceId = 0;
+ Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
+ Rm_ServiceReqInfo *staticRequest;
+ Rm_ServiceStaticReq *nextServiceReq;
+ Rm_Transaction *transaction;
+ Rm_ServiceRespInfo serviceResponse;
- if ((reqCfg->request->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
- (reqCfg->request->type == Rm_service_RESOURCE_ALLOCATE_USE) ||
- (reqCfg->request->resourceBase == RM_RESOURCE_BASE_UNSPECIFIED)) {
- /* Check request against startup policy */
- memset((void *)&privCheckCfg, 0, sizeof(Rm_PolicyCheckCfg));
+ if (validateCallback.serviceCallback == NULL) {
+ serviceResponse->serviceState = RM_SERVICE_ERROR_CALLBACK_NOT_PROVIDED;
+ return;
+ }
- if (reqCfg->request->type == Rm_service_RESOURCE_ALLOCATE_INIT) {
- privCheckCfg.type = Rm_policyCheck_INIT;
+ /* Validate static requests against the global policyDtb */
+ while(rmInst->staticInfo.staticReqList) {
+ transaction = rmTransactionQueueAdd(rmInst);
+ if (transaction) {
+ staticRequest = rmInst->staticInfo.staticReqList->staticReq;
+ transaction->type = staticRequest->serviceType;
+ strncpy(transaction->serviceSrcInstName, rmInst->instName, RM_NAME_MAX_CHARS);
+ transaction->callback.serviceCallback = validateCallback.serviceCallback;
+ transaction->state = RM_SERVICE_PROCESSING;
+ if (staticRequest->resourceName) {
+ strncpy(transaction->resourceInfo.name, staticRequest->resourceName, RM_NAME_MAX_CHARS);
+ }
+ transaction->resourceInfo.base = staticRequest->resourceBase;
+ transaction->resourceInfo.length = staticRequest->resourceLength;
+ transaction->resourceInfo.alignment = staticRequest->resourceAlignment;
+ if (staticRequest->resourceNsName) {
+ strncpy(transaction->resourceInfo.nameServerName, staticRequest->resourceNsName, RM_NAME_MAX_CHARS);
+ }
+
+ rmTransactionProcessor (rmInst, transaction);
+ memset((void *)&serviceResponse, 0, sizeof(Rm_ServiceRespInfo));
+ serviceResponse->serviceState = transaction->state;
+ if (serviceResponse->serviceState == RM_SERVICE_PROCESSING) {
+ /* Service still being processed. Provide transaction ID
+ * back to component so it can sort service responses received
+ * via callback function */
+ serviceResponse->serviceId = transaction->localId;
+ }
+ else if (serviceResponse->serviceState == RM_SERVICE_APPROVED_AND_COMPLETED) {
+ if ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
+ (transaction->type == Rm_service_RESOURCE_ALLOCATE_USE) ||
+ (transaction->type == Rm_service_RESOURCE_GET_BY_NAME)) {
+ strncpy(serviceResponse->resourceName, transaction->resourceInfo.name, RM_NAME_MAX_CHARS);
+ serviceResponse->resourceBase = transaction->resourceInfo.base;
+ serviceResponse->resourceLength = transaction->resourceInfo.length;
+ }
+ rmTransactionQueueDelete(rmInst, transaction->localId);
+ }
+ else {
+ rmTransactionQueueDelete(rmInst, transaction->localId);
+ }
+ /* Issue response via callback since function won't return until all static requests have
+ * been handled */
+ validateCallback->serviceCallback(&serviceResponse);
}
else {
- privCheckCfg.type = Rm_policyCheck_USE;
- }
- privCheckCfg.policyDtb = preMainInst->startupDtb;
- privCheckCfg.validInstNode = rmPolicyGetValidInstNode(preMainInst->validInstTree,
- preMainInst->instName);
- privCheckCfg.resourceOffset = rmPolicyGetResourceOffset(preMainInst->startupDtb,
- reqCfg->request->resourceName);
- privCheckCfg.resourceBase = reqCfg->request->resourceBase;
- privCheckCfg.resourceLength = reqCfg->request->resourceLength;
-
- if (rmPolicyCheckPrivilege(&privCheckCfg, &preMainResp->serviceState)) {
- preMainResp->serviceState = RM_SERVICE_APPROVED_AND_COMPLETED;
- }
- else if (preMainResp->serviceState == RM_SERVICE_PROCESSING) {
- /* Privilege check returned FALSE without error */
- preMainResp->serviceState = RM_SERVICE_DENIED_POLICY_DENIED_PREMAIN_ALLOCATION;
- }
- }
- else {
- preMainResp->serviceState = RM_SERVICE_DENIED_INVALID_PREMAIN_REQUEST;
- }
-
- /* Store the request for validation after post-main instance
- * transports have been established */
- if (preMainResp->serviceState == RM_SERVICE_APPROVED_AND_COMPLETED) {
- /* Store the request for validation after all instances have been setup post-main */
- lastServiceReq = preMainInst->preMainReqList;
- while(lastServiceReq) {
- lastServiceReq = lastServiceReq->nextPreMainReq;
+ serviceResponse->serviceState = RM_SERVICE_ERROR_TRANSACTION_FAILED_TO_ALLOCATE;
+ return;
}
- lastServiceReq = (Rm_ServicePreMainReq *) Rm_osalMalloc (sizeof(Rm_ServicePreMainReq));
- lastServiceReq->nextPreMainReq = NULL;
- lastServiceReq->preMainReq = (Rm_ServiceReqInfo *) Rm_osalMalloc(sizeof(Rm_ServiceReqInfo));
- memcpy((void *)lastServiceReq->preMainReq, (void *)reqCfg->request, sizeof(Rm_ServiceReqInfo));
-
- /* Fill out response */
- preMainResp->resourceBase = reqCfg->request->resourceBase;
- preMainResp->resourceLength = reqCfg->request->resourceLength;
- strncpy(preMainResp->resourceName, reqCfg->request->resourceName, RM_NAME_MAX_CHARS);
- preMainResp->serviceId = ++preMainInst->requestCount;
+ /* Free memory associated with static requests sent for validation */
+ nextServiceReq = rmInst->staticInfo.staticReqList->nextStaticReq;
+ Rm_osalFree((void *)rmInst->staticInfo.staticReqList->staticReq, sizeof(Rm_ServiceReqInfo));
+ Rm_osalFree((void *)rmInst->staticInfo.staticReqList, sizeof(Rm_ServiceStaticReq));
+ rmInst->staticInfo.staticReqList = nextServiceReq;
}
}