diff --git a/src/rm.c b/src/rm.c
index b96e4dd0abbe2be3658ef808d6dcfdafaeb93f60..81d3d27327cc395d740557db4a31fd7430b519a6 100644 (file)
--- a/src/rm.c
+++ b/src/rm.c
* with a Server. The allocation request is validated
* against a static policy.
*/
-static void staticAllocationHandler (Rm_Handle rmHandle, Rm_Transaction *transaction)
+static void staticAllocationHandler(Rm_Handle rmHandle,
+ Rm_Transaction *transaction)
{
Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
- void *staticPolicy = rmPolicyGetPolicy(rmHandle);
+ Rm_AllocatorNode *allocNode = NULL;
Rm_PolicyCheckCfg privCheckCfg;
- int32_t result;
-
- if (staticPolicy) {
- if ((transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
+
+ if (rmInst->allocatorTree) {
+ allocNode = rmAllocatorFind(rmHandle, transaction->resourceInfo.name);
+
+ if (allocNode &&
+ (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) ||
(transaction->type == Rm_service_RESOURCE_ALLOCATE_USE)) {
/* Check request against static policy */
memset((void *)&privCheckCfg, 0, sizeof(Rm_PolicyCheckCfg));
-
+
if (transaction->type == Rm_service_RESOURCE_ALLOCATE_INIT) {
privCheckCfg.type = Rm_policyCheck_INIT;
- }
- else {
+ } else {
privCheckCfg.type = Rm_policyCheck_USE;
}
- privCheckCfg.policyDtb = staticPolicy;
- privCheckCfg.validInstNode = rmPolicyGetValidInstNode(rmHandle, rmInst->instName);
- privCheckCfg.resourceOffset = rmPolicyGetResourceOffset(staticPolicy,
- transaction->resourceInfo.name);
- privCheckCfg.resourceBase = transaction->resourceInfo.base;
+ privCheckCfg.validInstNode = rmPolicyGetValidInstNode(rmHandle,
+ rmInst->instName);
+ privCheckCfg.polTree = allocNode->policyRoot;
+ privCheckCfg.resourceBase = transaction->resourceInfo.base;
privCheckCfg.resourceLength = transaction->resourceInfo.length;
-
- if (rmPolicyCheckPrivilege(&privCheckCfg, &result)) {
+
+ if (rmPolicyCheckPrivilege(&privCheckCfg)) {
transaction->state = RM_SERVICE_APPROVED_STATIC;
- }
- else if (result == RM_OK) {
- /* Privilege check returned false without error */
+ } else {
transaction->state = RM_SERVICE_DENIED_BY_STATIC_POLICY;
}
- else {
- /* Privilege check returned false with error */
- transaction->state = result;
- }
- }
- else {
+ } else {
transaction->state = RM_SERVICE_DENIED_INVALID_STATIC_REQUEST;
}
- }
- else {
+ } else {
transaction->state = RM_ERROR_REQ_FAILED_NO_STATIC_POLICY;
- }
+ }
}
/* FUNCTION PURPOSE: Requests resources from Server for CD
@@ -425,26 +418,32 @@ static void staticAllocationHandler (Rm_Handle rmHandle, Rm_Transaction *transac
* pending state in order to wait for the response from the
* Server
*/
-static int32_t cdRequestServerResources(Rm_Inst *rmInst, Rm_Transaction *transaction)
+static int32_t cdRequestServerResources(Rm_Inst *rmInst,
+ Rm_Transaction *transaction)
{
- Rm_Transaction *newTrans = NULL;
- void * policy = rmPolicyGetPolicy((Rm_Handle)rmInst);
- int32_t resourceOffsetInPolicy;
- uint32_t allocSize = 0;
- int32_t retVal;
-
- resourceOffsetInPolicy = rmPolicyGetResourceOffset(policy, transaction->resourceInfo.name);
- if (resourceOffsetInPolicy > 0) {
- if ((allocSize = rmPolicyGetResourceCdAllocSize(policy, resourceOffsetInPolicy))) {
- if ((newTrans = rmTransactionQueueAdd(rmInst))) {
+ Rm_AllocatorNode *allocNode = NULL;
+ Rm_Transaction *newTrans = NULL;
+ uint32_t allocSize = 0;
+ int32_t retVal;
+
+ allocNode = rmAllocatorFind((Rm_Handle)rmInst,
+ transaction->resourceInfo.name);
+
+ if (allocNode) {
+ if (allocSize = rmPolicyGetCdAllocSize(allocNode->policyRoot)) {
+ if (newTrans = rmTransactionQueueAdd(rmInst)) {
newTrans->type = transaction->type;
- 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->serviceSrcInstName, rmInst->instName,
+ RM_NAME_MAX_CHARS);
+ newTrans->state = RM_SERVICE_PROCESSING;
+ rm_strncpy(newTrans->resourceInfo.name,
+ transaction->resourceInfo.name,
+ RM_NAME_MAX_CHARS);
newTrans->resourceInfo.base = RM_RESOURCE_BASE_UNSPECIFIED;
/* Make sure request length will satisfy transaction length */
newTrans->resourceInfo.length = allocSize;
- while (newTrans->resourceInfo.length < transaction->resourceInfo.length) {
+ while (newTrans->resourceInfo.length <
+ transaction->resourceInfo.length) {
newTrans->resourceInfo.length += allocSize;
}
newTrans->resourceInfo.alignment = transaction->resourceInfo.alignment;
@@ -452,18 +451,15 @@ static int32_t cdRequestServerResources(Rm_Inst *rmInst, Rm_Transaction *transac
transactionForwarder(rmInst, newTrans);
retVal = RM_SERVICE_PENDING_SERVER_RESPONSE;
- }
- else {
+ } else {
retVal = RM_ERROR_TRANS_REQ_TO_SERVER_NOT_CREATED;
}
- }
- else {
+ } else {
/* Forward request to Server for completion if policy has
* no allocation size for resource */
retVal = RM_SERVICE_PROCESSING;
}
- }
- else {
+ } else {
/* Resource could not be found in policy */
retVal = RM_SERVICE_DENIED_RES_DOES_NOT_EXIST;
}
int32_t retVal = transaction->state;
memset((void *)&opInfo, 0, sizeof(Rm_AllocatorOpInfo));
- opInfo.policy = rmPolicyGetPolicy((Rm_Handle)rmInst);
opInfo.resourceInfo = &transaction->resourceInfo;
- opInfo.serviceSrcInstNode = rmPolicyGetValidInstNode((Rm_Handle)rmInst, transaction->serviceSrcInstName);
- if (opInfo.serviceSrcInstNode == NULL) {
+ opInfo.serviceInstNode = rmPolicyGetValidInstNode((Rm_Handle)rmInst,
+ transaction->serviceSrcInstName);
+ if (opInfo.serviceInstNode == NULL) {
retVal = RM_SERVICE_DENIED_INST_NAME_NOT_VALID;
goto errorExit;
- }
-
+ }
+
if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
if (transaction->resourceInfo.base != RM_RESOURCE_BASE_UNSPECIFIED) {
if (rmAllocatorFind((Rm_Handle)rmInst, transaction->resourceInfo.name)) {
* current status (currently just owner reference count)
* for the resource specified in the transaction
*/
-static void statusHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)
+static void statusHandler(Rm_Inst *rmInst, Rm_Transaction *transaction)
{
Rm_AllocatorOpInfo opInfo;
Rm_NameServerObjCfg nameServerObjCfg;
memset((void *)&opInfo, 0, sizeof(Rm_AllocatorOpInfo));
opInfo.operation = Rm_allocatorOp_GET_STATUS;
- opInfo.policy = rmPolicyGetPolicy((Rm_Handle)rmInst);
opInfo.resourceInfo = &transaction->resourceInfo;
- opInfo.serviceSrcInstNode = rmPolicyGetValidInstNode((Rm_Handle)rmInst, transaction->serviceSrcInstName);
- if (opInfo.serviceSrcInstNode == NULL) {
+ opInfo.serviceInstNode = rmPolicyGetValidInstNode((Rm_Handle)rmInst,
+ transaction->serviceSrcInstName);
+ if (opInfo.serviceInstNode == NULL) {
retVal = RM_SERVICE_DENIED_INST_NAME_NOT_VALID;
goto errorExit;
}
goto errorExit;
}
}
- retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
+ retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
}
-errorExit:
- transaction->state = retVal;
+errorExit:
+ transaction->state = retVal;
}
/* FUNCTION PURPOSE: Arbitrates free service requests
* retrieved from the NameServer prior to the free
* attempt.
*/
-static void freeHandler (Rm_Inst *rmInst, Rm_Transaction *transaction)
+static void freeHandler(Rm_Inst *rmInst, Rm_Transaction *transaction)
{
Rm_AllocatorOpInfo opInfo;
- Rm_NameServerObjCfg nameServerObjCfg;
+ Rm_NameServerObjCfg nameServerObjCfg;
int32_t retVal = transaction->state;
memset((void *)&opInfo, 0, sizeof(Rm_AllocatorOpInfo));
opInfo.operation = Rm_allocatorOp_FREE;
- opInfo.policy = rmPolicyGetPolicy((Rm_Handle)rmInst);
opInfo.resourceInfo = &transaction->resourceInfo;
- opInfo.serviceSrcInstNode = rmPolicyGetValidInstNode((Rm_Handle)rmInst, transaction->serviceSrcInstName);
- if (opInfo.serviceSrcInstNode == NULL) {
+ opInfo.serviceInstNode = rmPolicyGetValidInstNode((Rm_Handle)rmInst,
+ transaction->serviceSrcInstName);
+ if (opInfo.serviceInstNode == NULL) {
retVal = RM_SERVICE_DENIED_INST_NAME_NOT_VALID;
goto errorExit;
}
}
if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
- if (rmAllocatorFind((Rm_Handle)rmInst, transaction->resourceInfo.name)) {
- /* Attempt to free from local resources that were provided by Server */
- retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
+ /* Attempt to free from local resources that were provided by Server */
+ retVal = rmAllocatorOperation((Rm_Handle)rmInst, &opInfo);
- if (retVal == RM_SERVICE_APPROVED) {
- /* 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) {
- /* 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;
- }
- }
+ if (retVal == RM_SERVICE_APPROVED) {
+ /* 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) ||
+ (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) ||
(rmInst->instType == Rm_instType_SHARED_SERVER)) {
/* 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)) {
+ 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))) {
- Rm_ResourceNode *treeNode = NULL;
-
- treeNode = rmResourceNodeNew(transaction->resourceInfo.base, transaction->resourceInfo.length);
- RB_INSERT(_Rm_AllocatorResourceTree, allocator->resourceRoot, treeNode);
- }
- else {
- Rm_ResourceRange resRange;
-
- memset((void *)&resRange, 0, sizeof(resRange));
- resRange.base = transaction->resourceInfo.base;
- resRange.length = transaction->resourceInfo.length;
-
- rmAllocatorCreate((Rm_Handle)rmInst, transaction->resourceInfo.name, &resRange);
+ if ((allocator = rmAllocatorFind((Rm_Handle)rmInst,
+ transaction->resourceInfo.name))) {
+ rmAllocatorAddResNode((Rm_Handle)rmInst,
+ allocator,
+ transaction->resourceInfo.base,
+ transaction->resourceInfo.length);
}
/* Return original transaction to processing state to attempt completion */
allocator = rmAllocatorFind((Rm_Handle)rmInst,
transaction->resourceInfo.name);
- /* Local resource freed on Server. Need to remove from
+ /* Local resource freed on Server. Remove node in
* local allocator's resource tree as well */
rmAllocatorDeleteResNode((Rm_Handle)rmInst,
allocator,
transaction->resourceInfo.base,
transaction->resourceInfo.length);
- /* Delete the allocator's resource tree if there are no
- * nodes left in the resource tree */
- if (RB_MIN(_Rm_AllocatorResourceTree,
- allocator->resourceRoot) == NULL) {
- rmAllocatorDelete((Rm_Handle)rmInst,
- transaction->resourceInfo.name);
- }
-
/* Allow original free to complete */
pendingTrans->state = RM_SERVICE_APPROVED;
}
Rm_AllocatorOpInfo opInfo;
memset((void *)&opInfo, 0, sizeof(Rm_AllocatorOpInfo));
- opInfo.policy = rmPolicyGetPolicy((Rm_Handle)rmInst);
opInfo.resourceInfo = &pendingTrans->resourceInfo;
- opInfo.serviceSrcInstNode = rmPolicyGetValidInstNode((Rm_Handle)rmInst, pendingTrans->serviceSrcInstName);
+ opInfo.serviceInstNode = rmPolicyGetValidInstNode((Rm_Handle)rmInst,
+ 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) {
transaction->state = RM_ERROR_LOST_RESOURCES_ON_CD;
- }
+ }
}
/* Transfer error or denial to pending transaction */
pendingTrans->state = transaction->state;
if ((rmInst->instType == Rm_instType_SERVER) ||
(rmInst->instType == Rm_instType_SHARED_SERVER) ||
(rmInst->instType == Rm_instType_CLIENT_DELEGATE)) {
-
- allocTree = rmAllocatorGetTree((Rm_Handle)rmInst);
+
+ allocTree = rmInst->allocatorTree;
if (rmInst->instType == Rm_instType_SHARED_SERVER) {
rmAllocatorTreeInv(allocTree);
}
Rm_Handle Rm_init(const Rm_InitCfg *initCfg, int32_t *result)
{
Rm_Inst *rmInst = NULL;
- Rm_Inst *sharedServerInst = NULL;
- uint32_t policySize;
- void *globalResourceDtb = NULL;
- void *linuxResourceDtb = NULL;
+ void *grlDtb = NULL;
+ void *policyDtb = NULL;
+ void *linuxDtb = NULL;
int addLinux = RM_FALSE;
void *key;
goto errorExit;
}
- if (rmInst->instType == Rm_instType_SHARED_SERVER) {
- /* Shared Server makes copy of policy in shared memory for Shared
- * Clients on other cores */
- policySize = fdt_totalsize(initCfg->instCfg.serverCfg.globalPolicy);
- /* Align policy size to cache boundary */
- if (policySize % RM_MAX_CACHE_ALIGN) {
- policySize += (RM_MAX_CACHE_ALIGN - (policySize % RM_MAX_CACHE_ALIGN));
- }
- rmInst->u.server.policySize = policySize;
- rmInst->u.server.globalPolicy = Rm_osalMalloc(rmInst->u.server.policySize);
- memcpy(rmInst->u.server.globalPolicy, initCfg->instCfg.serverCfg.globalPolicy, rmInst->u.server.policySize);
- } else {
- rmInst->u.server.globalPolicy = initCfg->instCfg.serverCfg.globalPolicy;
- }
-
if (initCfg->instCfg.serverCfg.linuxDtb) {
- linuxResourceDtb = initCfg->instCfg.serverCfg.linuxDtb;
+ linuxDtb = initCfg->instCfg.serverCfg.linuxDtb;
addLinux = RM_TRUE;
}
- /* Create valid instance list from policy. Must be done prior to parsing
- * GRL so that Linux resources can be reserved correctly */
- rmInst->u.server.validInstTree = rmPolicyCreateValidInstTree((Rm_Handle)rmInst, addLinux, result);
- if (*result == RM_OK) {
- *result = rmPolicyValidatePolicy((Rm_Handle)rmInst);
- }
-
+ /* Create valid instance list from policy. Must be done prior to
+ * parsing GRL so that Linux resources can be reserved correctly */
+ policyDtb = initCfg->instCfg.serverCfg.globalPolicy;
+ rmInst->validInstTree = rmPolicyVInstTreeInit(rmInst, policyDtb,
+ addLinux, result);
if (*result != RM_OK) {
- if (rmInst->u.server.validInstTree) {
- rmPolicyFreeValidInstTree((Rm_Handle)rmInst);
- }
goto errorExit;
- } else {
- rmNameServerInit((Rm_Handle)rmInst);
-
- globalResourceDtb = initCfg->instCfg.serverCfg.globalResourceList;
-
- if ((*result = rmAllocatorInitTree((Rm_Handle) rmInst)) == RM_OK) {
- if ((*result = rmAllocatorPopulateTree((Rm_Handle)rmInst,
- globalResourceDtb,
- linuxResourceDtb)) ==
- RM_OK) {
- *result = rmPolicyValidateResNames((Rm_Handle)rmInst);
- }
- }
+ }
- if (*result != RM_OK) {
- rmAllocatorDeleteTree((Rm_Handle)rmInst);
- rmNameServerDelete((Rm_Handle)rmInst);
- if (rmInst->u.server.validInstTree) {
- rmPolicyFreeValidInstTree((Rm_Handle)rmInst);
- }
- goto errorExit;
- }
+ rmNameServerInit((Rm_Handle)rmInst);
+ grlDtb = initCfg->instCfg.serverCfg.globalResourceList;
+ if ((*result = rmAllocatorTreeInit(rmInst, grlDtb,
+ policyDtb, linuxDtb)) != RM_OK) {
+ goto errorExit;
}
} else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
if (!initCfg->instCfg.cdCfg.cdPolicy) {
goto errorExit;
}
- rmInst->u.cd.cdPolicy = initCfg->instCfg.cdCfg.cdPolicy;
- rmInst->u.cd.validInstTree = rmPolicyCreateValidInstTree((Rm_Handle)rmInst, addLinux, result);
- if (*result == RM_OK) {
- *result = rmPolicyValidatePolicy((Rm_Handle)rmInst);
- }
-
+ policyDtb = initCfg->instCfg.cdCfg.cdPolicy;
+ rmInst->validInstTree = rmPolicyVInstTreeInit(rmInst, policyDtb,
+ addLinux, result);
if (*result != RM_OK) {
- if (rmInst->u.cd.validInstTree) {
- rmPolicyFreeValidInstTree((Rm_Handle)rmInst);
- }
goto errorExit;
}
- if ((*result = rmAllocatorInitTree((Rm_Handle) rmInst)) != RM_OK) {
- if (rmInst->u.cd.validInstTree) {
- rmPolicyFreeValidInstTree((Rm_Handle)rmInst);
- }
+ if ((*result = rmAllocatorTreeInit(rmInst, NULL,
+ policyDtb, NULL)) != RM_OK) {
goto errorExit;
}
/* Remove once CD instance is stable - tracked by SDOCM00100797 */
*result = RM_WARNING_CD_INSTANCE_NOT_STABLE;
+
} else if (rmInst->instType == Rm_instType_CLIENT) {
if (initCfg->instCfg.clientCfg.staticPolicy) {
- rmInst->u.client.staticPolicy = initCfg->instCfg.clientCfg.staticPolicy;
- rmInst->u.client.staticValidInstTree = rmPolicyCreateValidInstTree((Rm_Handle)rmInst, addLinux, result);
- if (*result == RM_OK) {
- *result = rmPolicyValidatePolicy((Rm_Handle)rmInst);
- }
-
+ policyDtb = initCfg->instCfg.clientCfg.staticPolicy;
+ rmInst->validInstTree = rmPolicyVInstTreeInit(rmInst, policyDtb,
+ addLinux, result);
if (*result != RM_OK) {
- if (rmInst->u.client.staticValidInstTree) {
- rmPolicyFreeValidInstTree((Rm_Handle)rmInst);
- }
+ goto errorExit;
+ }
+
+ if ((*result = rmAllocatorTreeInit(rmInst, NULL,
+ policyDtb, NULL)) != RM_OK) {
goto errorExit;
}
}
+
} else if (rmInst->instType == Rm_instType_SHARED_CLIENT) {
- if (initCfg->instCfg.sharedClientCfg.sharedServerHandle) {
- rmInst->u.sharedClient.sharedServerHandle = initCfg->instCfg.sharedClientCfg.sharedServerHandle;
- /* Invalidate the Shared server instance structure on this core to get the latest
- * instance data. */
+ Rm_Handle sHdl = initCfg->instCfg.sharedClientCfg.sharedServerHandle;
+ Rm_Inst *ssInst = NULL;
+
+ if (sHdl) {
+ rmInst->u.sharedClient.sharedServerHandle = sHdl;
+ /* Invalidate the Shared server instance structure on this core to
+ * get the latest instance data. */
key = Rm_osalCsEnter();
- Rm_osalBeginMemAccess((void *)rmInst->u.sharedClient.sharedServerHandle, sizeof(Rm_Inst));
- sharedServerInst = rmInst->u.sharedClient.sharedServerHandle;
- if (sharedServerInst->instType != Rm_instType_SHARED_SERVER) {
+ Rm_osalBeginMemAccess((void *)sHdl, sizeof(Rm_Inst));
+ ssInst = rmInst->u.sharedClient.sharedServerHandle;
+ if (ssInst->instType != Rm_instType_SHARED_SERVER) {
*result = RM_ERROR_INVALID_SHARED_SERVER_HANDLE;
Rm_osalCsExit(key);
goto errorExit;
} else {
- /* Invalidate the policy */
- Rm_osalBeginMemAccess((void *)sharedServerInst->u.server.globalPolicy,
- sharedServerInst->u.server.policySize);
+ /* Invalidate all the trees */
+ rmPolicyValidInstTreeInv(ssInst->validInstTree);
+ rmAllocatorTreeInv(ssInst->allocatorTree);
+ rmNameServerTreeInv(ssInst->u.server.nameServer);
}
Rm_osalCsExit(key);
} else {
}
if (initCfg->instType == Rm_instType_SHARED_SERVER) {
- /* Writeback the instance and policy for other cores */
- Rm_osalEndMemAccess ((void *)rmInst, sizeof(Rm_Inst));
- Rm_osalEndMemAccess ((void *)rmInst->u.server.globalPolicy, rmInst->u.server.policySize);
+ /* Writeback instance and trees for other cores */
+ rmPolicyValidInstTreeWb(rmInst->validInstTree);
+ rmAllocatorTreeWb(rmInst->allocatorTree);
+ rmNameServerTreeWb(rmInst->u.server.nameServer);
+ Rm_osalEndMemAccess((void *)rmInst, sizeof(*rmInst));
} else if (rmInst->instType != Rm_instType_SHARED_CLIENT) {
/* Create the instance's task blocking mechanism */
rmInst->blockHandle = Rm_osalTaskBlockCreate();
}
- return ((Rm_Handle) rmInst);
+ return((Rm_Handle)rmInst);
+
errorExit:
if (rmInst) {
- Rm_osalFree((void *)rmInst, sizeof(Rm_Inst));
+ rmAllocatorTreeDelete((Rm_Handle)rmInst);
+ rmNameServerDelete((Rm_Handle)rmInst);
+ rmPolicyVInstTreeDelete((Rm_Handle)rmInst);
+ Rm_osalFree((void *)rmInst, sizeof(*rmInst));
}
- return (NULL);
+ return(NULL);
}
/* FUNCTION PURPOSE: Deletes an RM instance
key = Rm_osalCsEnter();
if (rmInst->instType == Rm_instType_SHARED_SERVER) {
- Rm_osalBeginMemAccess((void *)rmInst, sizeof(Rm_Inst));
+ Rm_osalBeginMemAccess((void *)rmInst, sizeof(*rmInst));
}
if (rmInst->serviceHandle) {
- return (RM_ERROR_CANT_DELETE_WITH_OPEN_SERV_HNDL);
- }
- else if (rmInst->transports) {
- return (RM_ERROR_CANT_DELETE_WITH_REGD_TRANSPORT);
- }
- else if (rmInst->transactionQueue && !ignorePendingServices) {
- return (RM_ERROR_CANT_DELETE_PENDING_TRANSACTIONS);
- }
-
- if ((rmInst->instType == Rm_instType_SERVER) ||
- (rmInst->instType == Rm_instType_SHARED_SERVER)) {
- rmAllocatorDeleteTree(rmHandle);
- rmNameServerDelete(rmHandle);
- rmInst->u.server.allocatorTree = NULL;
-
- if (rmInst->instType == Rm_instType_SHARED_SERVER) {
- Rm_osalFree((void *)rmInst->u.server.globalPolicy,
- rmInst->u.server.policySize);
- }
- }
- else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
- rmAllocatorDeleteTree(rmHandle);
- rmInst->u.cd.allocatorTree = NULL;
+ return(RM_ERROR_CANT_DELETE_WITH_OPEN_SERV_HNDL);
+ } else if (rmInst->transports) {
+ return(RM_ERROR_CANT_DELETE_WITH_REGD_TRANSPORT);
+ } else if (rmInst->transactionQueue && !ignorePendingServices) {
+ return(RM_ERROR_CANT_DELETE_PENDING_TRANSACTIONS);
}
if (rmInst->instType != Rm_instType_SHARED_CLIENT) {
- /* Delete valid instance tree */
- rmPolicyFreeValidInstTree(rmHandle);
+ rmNameServerDelete(rmHandle);
+ rmAllocatorTreeDelete(rmHandle);
+ rmPolicyVInstTreeDelete(rmHandle);
/* Delete any transactions */
while(rmInst->transactionQueue) {
if (rmInst->instType != Rm_instType_SHARED_SERVER) {
/* Delete the instance's task blocking mechanism */
Rm_osalTaskBlockDelete(rmInst->blockHandle);
- }
- else {
- Rm_osalEndMemAccess((void *)rmInst, sizeof(Rm_Inst));
+ } else {
+ rmInst->allocatorTree = NULL;
+ rmInst->validInstTree = NULL;
+ rmInst->u.server.nameServer = NULL;
+ Rm_osalEndMemAccess((void *)rmInst, sizeof(*rmInst));
}
}
- Rm_osalFree((void *)rmInst, sizeof(Rm_Inst));
-
+ Rm_osalFree((void *)rmInst, sizeof(*rmInst));
Rm_osalCsExit(key);
- return (RM_OK);
+ return(RM_OK);
}
/* FUNCTION PURPOSE: Returns RM version information
*/
uint32_t Rm_getVersion(void)
{
- return RM_VERSION_ID;
+ return(RM_VERSION_ID);
}
/* FUNCTION PURPOSE: Returns RM version string
*/
const char* Rm_getVersionStr(void)
{
- return rmVersionStr;
+ return(rmVersionStr);
}