diff --git a/src/rm_policy.c b/src/rm_policy.c
index 356ea165986a90e69aa0fa6bb9200f937e7bd29d..63f1dc0e1cd136aa9639a7aafd1aa8fe894a6a8f 100644 (file)
--- a/src/rm_policy.c
+++ b/src/rm_policy.c
/* Standard includes */
#include <ctype.h>
-#include <stdbool.h>
/* RM external API includes */
#include <ti/drv/rm/rm.h>
/* RM internal API includes */
+#include <ti/drv/rm/include/rm_internal.h>
#include <ti/drv/rm/include/rm_loc.h>
+#include <ti/drv/rm/include/rm_allocatorloc.h>
#include <ti/drv/rm/include/rm_policyloc.h>
#include <ti/drv/rm/include/rm_dtb_utilloc.h>
******************** Local Policy Functions **************************
**********************************************************************/
+/* FUNCTION PURPOSE: Returns a pointer to the valid instance tree
+ ***********************************************************************
+ * DESCRIPTION: Returns a pointer to the instance's valid instance
+ * tree based on the instance type
+ */
+static Rm_PolicyValidInstTree *policyGetValidInstTree(Rm_Handle rmHandle)
+{
+ Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
+ Rm_PolicyValidInstTree *tree = NULL;
+
+ if ((rmInst->instType == Rm_instType_SERVER) ||
+ (rmInst->instType == Rm_instType_SHARED_SERVER)) {
+ tree = rmInst->u.server.globalValidInstTree;
+ }
+ else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
+ tree = rmInst->u.cd.cdValidInstTree;
+ }
+ else if (rmInst->instType == Rm_instType_CLIENT) {
+ tree = rmInst->u.client.staticValidInstTree;
+ }
+ return(tree);
+}
+
/* FUNCTION PURPOSE: Validates the instance names in a permissions string
***********************************************************************
* DESCRIPTION: Returns RM_OK if all the instance names in a permissions
* list. RM_ERROR_PERM_STR_INST_NOT_VALID is returned if
* there are any mismatches
*/
-static int32_t policyCheckInstances(Rm_PolicyValidInstTree *validInstTree,
- Rm_PolicyPermission *permissionsList)
+static int32_t policyCheckInstances(Rm_Handle rmHandle, Rm_PolicyPermission *permissionsList)
{
while (permissionsList) {
- if (strcmp(permissionsList->instName, Rm_policyAllInstances) &&
- (!rmPolicyGetValidInstNode(validInstTree, permissionsList->instName))) {
+ if (strncmp(permissionsList->instName, Rm_policyAllInstances, RM_NAME_MAX_CHARS) &&
+ (!rmPolicyGetValidInstNode(rmHandle, permissionsList->instName))) {
return(RM_ERROR_PERM_STR_INST_NOT_VALID);
}
permissionsList = permissionsList->nextPermission;
@@ -113,10 +136,10 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
uint32_t permStrLen = (uint32_t)(permStrEnd - permStrStart + 1);
char instNameTemp[RM_NAME_MAX_CHARS];
uint32_t instNameIndex;
- bool foundInstName;
- bool instNameComplete;
- bool assignmentLeft;
- bool assignmentRight;
+ int foundInstName;
+ int instNameComplete;
+ int assignmentLeft;
+ int assignmentRight;
/* Create a local copy of the sub-permission string */
permStrPtr = Rm_osalMalloc(permStrLen);
@@ -140,17 +163,16 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
* 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 */
- Rm_osalFree((void *)permStrStart, permStrLen);
*result = RM_ERROR_PERM_STR_TOO_MANY_INST_GROUPS;
- return(NULL);
+ goto parseError;
}
/* Create a permission entry for each instance specified in the instance group.
* Instances names are separated by one or more spaces. */
permStrPtr = subgroupStart + 1;
instNameIndex = 0;
- foundInstName = false;
- instNameComplete = false;
+ foundInstName = RM_FALSE;
+ instNameComplete = RM_FALSE;
while (permStrPtr <= subgroupEnd) {
if ((isspace(*permStrPtr) || (*permStrPtr == RM_POLICY_PERM_SUBGROUP_END))
&& foundInstName) {
@@ -158,13 +180,13 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
* terminates the instance name. All other space characters are
* ignored. */
instNameTemp[instNameIndex] = '\0';
- instNameComplete = true;
+ instNameComplete = RM_TRUE;
}
else {
if (!foundInstName) {
/* First non-whitespace character encountered is the start of an
* instance name */
- foundInstName = true;
+ foundInstName = RM_TRUE;
}
/* Copy the character into the temporary instance name string */
@@ -187,20 +209,14 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
}
prevPerm = newPerm;
- instNameComplete = false;
+ instNameComplete = RM_FALSE;
instNameIndex = 0;
- foundInstName = false;
+ foundInstName = RM_FALSE;
}
else if (instNameIndex == RM_NAME_MAX_CHARS) {
/* Instance name is longer than max length */
- while (startPerm) {
- nextPerm = startPerm->nextPermission;
- Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
- startPerm = nextPerm;
- }
- Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
*result = RM_ERROR_INST_NAME_IN_ASSIGNMENT_TOO_LONG;
- return(NULL);
+ goto parseError;
}
permStrPtr++;
@@ -210,7 +226,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
/* Look on left of instance group for permission assignments. */
permStrPtr = subgroupStart - 1;
- assignmentLeft = false;
+ assignmentLeft = RM_FALSE;
while (permStrPtr >= permStrStart)
{
if (*permStrPtr == RM_POLICY_PERM_ASSIGNMENT) {
@@ -218,17 +234,11 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
/* Assignment character has been found more than once. This is a
* syntax error. Free the permission list and the temporary string
* and return. */
- while (startPerm) {
- nextPerm = startPerm->nextPermission;
- Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
- startPerm = nextPerm;
- }
- Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
*result = RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS;
- return(NULL);
+ goto parseError;
}
else {
- assignmentLeft = true;
+ assignmentLeft = RM_TRUE;
}
}
else if (!isspace(*permStrPtr)) {
@@ -269,28 +279,16 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
/* Invalid permission character. This is a
* syntax error. Free the permission list and the temporary string
* and return. */
- while (startPerm) {
- nextPerm = startPerm->nextPermission;
- Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
- startPerm = nextPerm;
- }
- Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
*result = RM_ERROR_PERM_STR_INVALID_CHAR;
- return(NULL);
+ 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. */
- while (startPerm) {
- nextPerm = startPerm->nextPermission;
- Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
- startPerm = nextPerm;
- }
- Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
*result = RM_ERROR_PERM_CHAR_WITHOUT_ASSIGN_CHAR;
- return(NULL);
+ goto parseError;
}
}
permStrPtr--;
@@ -298,18 +296,12 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
/* Look on right of instance group for permission assignments. */
permStrPtr = subgroupEnd + 1;
- assignmentRight = false;
+ 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 */
- while (startPerm) {
- nextPerm = startPerm->nextPermission;
- Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
- startPerm = nextPerm;
- }
- Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
*result = RM_ERROR_INVALID_PERMS_CHAR_ON_RIGHT;
- return(NULL);
+ goto parseError;
}
if (*permStrPtr == RM_POLICY_PERM_ASSIGNMENT) {
@@ -317,17 +309,11 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
/* Assignment character has been found more than once. This is a
* syntax error. Free the permission list and the temporary string
* and return. */
- while (startPerm) {
- nextPerm = startPerm->nextPermission;
- Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
- startPerm = nextPerm;
- }
- Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
*result = RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS;
- return(NULL);
+ goto parseError;
}
else {
- assignmentRight = true;
+ assignmentRight = RM_TRUE;
}
}
else if (!isspace(*permStrPtr)) {
@@ -368,35 +354,33 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
/* Invalid permission character. This is a
* syntax error. Free the permission list and the temporary string
* and return. */
- while (startPerm) {
- nextPerm = startPerm->nextPermission;
- Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
- startPerm = nextPerm;
- }
- Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
*result = RM_ERROR_PERM_STR_INVALID_CHAR;
- return(NULL);
+ 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. */
- while (startPerm) {
- nextPerm = startPerm->nextPermission;
- Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
- startPerm = nextPerm;
- }
- Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
*result = RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS;
- return(NULL);
+ goto parseError;
}
}
permStrPtr++;
}
Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
+ *result = RM_OK;
return (startPerm);
+
+parseError:
+ while (startPerm) {
+ nextPerm = startPerm->nextPermission;
+ Rm_osalFree((void *)startPerm, sizeof(Rm_PolicyPermission));
+ startPerm = nextPerm;
+ }
+ Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
+ return(NULL);
}
/* FUNCTION PURPOSE: Frees a linked list of assignment permissions
@@ -433,6 +417,8 @@ static Rm_PolicyPermission *policyGetAssignmentPermissions(Rm_PolicyAssignment *
char *permStrEnd;
uint32_t permStrLen = strlen(assignment->permissionsList) + 1;
uint32_t i = 0;
+
+ *result = RM_OK;
while(i < permStrLen) {
/* Find the first sub-permission specification and parse it. A sub-permission
@@ -445,7 +431,7 @@ static Rm_PolicyPermission *policyGetAssignmentPermissions(Rm_PolicyAssignment *
newPerm = policyParseSubPermission(permStrStart, permStrEnd, result);
- if (*result != RM_SERVICE_PROCESSING) {
+ if (*result != RM_OK) {
/* Delete the permission list that's been created thus far, return
* the error and NULL for the permission list */
policyFreeAssignmentPermissions(startPerm);
@@ -481,12 +467,12 @@ static Rm_PolicyPermission *policyGetAssignmentPermissions(Rm_PolicyAssignment *
* instances in the assignment match RM instances in the
* valid instances list
*/
-static int32_t policyValidateAssignmentPermissions(Rm_PolicyValidInstTree *root,
+static int32_t policyValidateAssignmentPermissions(Rm_Handle rmHandle,
Rm_PolicyAssignment *assignmentList)
{
Rm_PolicyAssignment *assignment = assignmentList;
Rm_PolicyPermission *permissionList;
- int32_t result = RM_OK;
+ int32_t result;
while (assignment) {
/* Make sure assignment's permissions parse okay */
@@ -495,7 +481,7 @@ static int32_t policyValidateAssignmentPermissions(Rm_PolicyValidInstTree *root,
return(result);
}
- if (result = policyCheckInstances(root, permissionList) != RM_OK) {
+ if (result = policyCheckInstances(rmHandle, permissionList) != RM_OK) {
policyFreeAssignmentPermissions(permissionList);
return(result);
}
@@ -511,19 +497,48 @@ static int32_t policyValidateAssignmentPermissions(Rm_PolicyValidInstTree *root,
************************ Internal Policy APIs ************************
**********************************************************************/
+/* FUNCTION PURPOSE: Returns a pointer to the instance policy
+ ***********************************************************************
+ * DESCRIPTION: Returns a pointer to the instance's policy based on
+ * the instance type
+ */
+void *rmPolicyGetPolicy(Rm_Handle rmHandle)
+{
+ Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
+ void *policy = NULL;
+
+ if ((rmInst->instType == Rm_instType_SERVER) ||
+ (rmInst->instType == Rm_instType_SHARED_SERVER)) {
+ policy = rmInst->u.server.globalPolicy;
+ }
+ else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
+ policy = rmInst->u.cd.cdPolicy;
+ }
+ else if (rmInst->instType == Rm_instType_CLIENT) {
+ policy = rmInst->u.client.staticPolicy;
+ }
+ return(policy);
+}
+
/* FUNCTION PURPOSE: Get a valid instace node from the valid inst tree
***********************************************************************
* DESCRIPTION: Returns a valid instance node from the valid instance
* tree that matches the specified instName
*/
-Rm_PolicyValidInstNode *rmPolicyGetValidInstNode(Rm_PolicyValidInstTree *validInstTree, char *instName)
+Rm_PolicyValidInstNode *rmPolicyGetValidInstNode(Rm_Handle rmHandle, char *instName)
{
+ Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
+ Rm_PolicyValidInstTree *treeRoot = policyGetValidInstTree(rmHandle);
Rm_PolicyValidInstNode findNode;
+ if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+ rmPolicyValidInstTreeInv(treeRoot);
+ }
+
memset((void *)&findNode, 0, sizeof(Rm_PolicyValidInstNode));
strncpy(findNode.name, instName, RM_NAME_MAX_CHARS);
- return (RB_FIND(_Rm_PolicyValidInstTree, validInstTree, &findNode));
+ return (RB_FIND(_Rm_PolicyValidInstTree, treeRoot, &findNode));
}
/* FUNCTION PURPOSE: Gets the Linux Valid instance node
@@ -532,11 +547,11 @@ Rm_PolicyValidInstNode *rmPolicyGetValidInstNode(Rm_PolicyValidInstTree *validIn
* valid instance tree that matches the instance name
* reserved for resource assigned to the Linux kernel.
*/
-Rm_PolicyValidInstNode *rmPolicyGetLinuxInstNode(Rm_PolicyValidInstTree *validInstTree)
+Rm_PolicyValidInstNode *rmPolicyGetLinuxInstNode(Rm_Handle rmHandle)
{
char linuxName[] = RM_ALLOCATED_TO_LINUX;
- return (rmPolicyGetValidInstNode(validInstTree, linuxName));
+ return (rmPolicyGetValidInstNode(rmHandle, linuxName));
}
/* FUNCTION PURPOSE: Validates resource permissions against a Policy DTB
@@ -545,7 +560,7 @@ Rm_PolicyValidInstNode *rmPolicyGetLinuxInstNode(Rm_PolicyValidInstTree *validIn
* permissions for the specified resource in the Policy
* DTB. Otherwise, returns FALSE.
*/
-bool rmPolicyCheckPrivilege(Rm_PolicyCheckCfg *privilegeCfg, int32_t *result)
+int rmPolicyCheckPrivilege(Rm_PolicyCheckCfg *privilegeCfg, int32_t *result)
{
int32_t propertyOffset;
const char *propertyName;
Rm_PolicyPermission *permissionStart = NULL;
uint32_t assignmentEnd;
uint32_t resourceEnd = privilegeCfg->resourceBase + privilegeCfg->resourceLength - 1;
- bool foundInstance;
+ int foundInstance;
+
+ *result = RM_OK;
/* Get the resource's assignments */
propertyOffset = fdt_first_property_offset(privilegeCfg->policyDtb, privilegeCfg->resourceOffset);
if (assignment) {
while (assignment) {
assignmentEnd = assignment->resourceBase + assignment->resourceLength - 1;
- foundInstance = false;
+ foundInstance = RM_FALSE;
if (((privilegeCfg->resourceBase >= assignment->resourceBase) &&
(privilegeCfg->resourceBase <= assignmentEnd)) ||
((privilegeCfg->resourceBase < assignment->resourceBase) &&
permission = permissionStart = policyGetAssignmentPermissions(assignment, result);
while (permission) {
- if ((strcmp(permission->instName, privilegeCfg->validInstNode->name) == 0) ||
- (strcmp(permission->instName, Rm_policyAllInstances) == 0)) {
- foundInstance = true;
+ if ((strncmp(permission->instName, privilegeCfg->validInstNode->name, RM_NAME_MAX_CHARS) == 0) ||
+ (strncmp(permission->instName, Rm_policyAllInstances, RM_NAME_MAX_CHARS) == 0)) {
+ foundInstance = RM_TRUE;
/* Check instance's permissions */
if (privilegeCfg->type == Rm_policyCheck_INIT) {
if (!RM_policy_GET_PERM(permission->permissionBits, RM_POLICY_PERM_INIT_SHIFT)) {
policyFreeAssignmentPermissions(permissionStart);
rmDtbUtilPolicyFreeAssignments(assignmentStart);
- return(false);
+ return(RM_FALSE);
}
}
else if (privilegeCfg->type == Rm_policyCheck_USE) {
if (!RM_policy_GET_PERM(permission->permissionBits, RM_POLICY_PERM_USE_SHIFT)) {
policyFreeAssignmentPermissions(permissionStart);
rmDtbUtilPolicyFreeAssignments(assignmentStart);
- return(false);
+ return(RM_FALSE);
}
}
else if (privilegeCfg->type == Rm_policyCheck_EXCLUSIVE) {
if (!RM_policy_GET_PERM(permission->permissionBits, RM_POLICY_PERM_EXCLUSIVE_SHIFT)) {
policyFreeAssignmentPermissions(permissionStart);
rmDtbUtilPolicyFreeAssignments(assignmentStart);
- return(false);
+ return(RM_FALSE);
}
}
+ else if (privilegeCfg->type == Rm_policyCheck_SHARED_LINUX) {
+ if (!RM_policy_GET_PERM(permission->permissionBits, RM_POLICY_PERM_SHARED_LINUX_SHIFT)) {
+ policyFreeAssignmentPermissions(permissionStart);
+ rmDtbUtilPolicyFreeAssignments(assignmentStart);
+ return(RM_FALSE);
+ }
+ }
break;
}
permission = permission->nextPermission;
policyFreeAssignmentPermissions(permissionStart);
if (!foundInstance) {
rmDtbUtilPolicyFreeAssignments(assignmentStart);
- return(false);
+ return(RM_FALSE);
}
}
assignment = assignment->nextAssignment;
rmDtbUtilPolicyFreeAssignments(assignmentStart);
}
else {
- return(false);
+ return(RM_FALSE);
}
- return(true);
+ return(RM_TRUE);
}
/* FUNCTION PURPOSE: Returns resource base value according to the Policy
* Policy DTB.
*/
uint32_t rmPolicyGetResourceBase(void *policyDtb, Rm_PolicyValidInstNode *validInstNode,
- int32_t resourceOffset, uint32_t allocType,
+ int32_t resourceOffset, Rm_PolicyCheckType policyCheckType,
int32_t *result)
{
@@ -654,6 +678,8 @@ uint32_t rmPolicyGetResourceBase(void *policyDtb, Rm_PolicyValidInstNode *validI
Rm_PolicyPermission *permissionStart = NULL;
uint32_t resourceBase = 0;
+ *result = RM_OK;
+
propertyOffset = fdt_first_property_offset(policyDtb, resourceOffset);
if (propertyOffset > RM_DTB_UTIL_STARTING_NODE_OFFSET) {
while (propertyOffset > RM_DTB_UTIL_STARTING_NODE_OFFSET) {
@@ -670,15 +696,15 @@ uint32_t rmPolicyGetResourceBase(void *policyDtb, Rm_PolicyValidInstNode *validI
while (assignment) {
permission = permissionStart = policyGetAssignmentPermissions(assignment, result);
while (permission) {
- if ((strcmp(permission->instName, validInstNode->name) == 0) ||
- (strcmp(permission->instName, Rm_policyAllInstances) == 0)) {
+ if ((strncmp(permission->instName, validInstNode->name, RM_NAME_MAX_CHARS) == 0) ||
+ (strncmp(permission->instName, Rm_policyAllInstances, RM_NAME_MAX_CHARS) == 0)) {
/* Check instance's permissions */
- if (RM_policy_GET_PERM(allocType, RM_POLICY_PERM_INIT_SHIFT) &&
+ if ((policyCheckType == Rm_policyCheck_INIT) &&
RM_policy_GET_PERM(permission->permissionBits, RM_POLICY_PERM_INIT_SHIFT)) {
resourceBase = assignment->resourceBase;
break;
}
- else if (RM_policy_GET_PERM(allocType, RM_POLICY_PERM_USE_SHIFT) &&
+ else if ((policyCheckType == Rm_policyCheck_USE) &&
RM_policy_GET_PERM(permission->permissionBits, RM_POLICY_PERM_USE_SHIFT)) {
resourceBase = assignment->resourceBase;
break;
nodeOffset = fdt_next_node(policyDtb, nodeOffset, &depth);
nodeName = fdt_get_name(policyDtb, nodeOffset, NULL);
- if (strcmp(nodeName, resourceName) == 0)
+ if (strncmp(nodeName, resourceName, RM_NAME_MAX_CHARS) == 0)
{
break;
}
}
+
+ if (depth < RM_DTB_UTIL_STARTING_DEPTH) {
+ /* Resource name not found */
+ nodeOffset = RM_SERVICE_DENIED_RES_DOES_NOT_EXIST;
+ }
return(nodeOffset);
}
* list specified at the top of the Policy. Otherwise,
* returns error
*/
-int32_t rmPolicyValidatePolicyResourceNames(void *policyDtb, void *allocatorList)
+int32_t rmPolicyValidatePolicyResourceNames(Rm_Handle rmHandle)
{
- Rm_Allocator *allocator = (Rm_Allocator *)allocatorList;
- int32_t nodeOffset;
- int32_t depth;
- const char *nodeName;
+ void *policyDtb = rmPolicyGetPolicy(rmHandle);
+ int32_t nodeOffset;
+ int32_t depth;
+ const char *nodeName;
depth = RM_DTB_UTIL_STARTING_DEPTH;
nodeOffset = RM_DTB_UTIL_STARTING_NODE_OFFSET;
@@ -788,7 +819,7 @@ int32_t rmPolicyValidatePolicyResourceNames(void *policyDtb, void *allocatorList
nodeOffset = fdt_next_node(policyDtb, nodeOffset, &depth);
nodeName = fdt_get_name(policyDtb, nodeOffset, NULL);
if (fdt_first_property_offset(policyDtb, nodeOffset) > RM_DTB_UTIL_STARTING_NODE_OFFSET) {
- if (rmAllocatorFind(allocator, (char *)nodeName) == NULL) {
+ if (rmAllocatorFind(rmHandle, nodeName) == NULL) {
/* No allocator tied to resource name */
return(RM_ERROR_UNKNOWN_RESOURCE_IN_POLICY);
}
@@ -807,8 +838,9 @@ int32_t rmPolicyValidatePolicyResourceNames(void *policyDtb, void *allocatorList
* list
* c) All resource node names match a resource allocator
*/
-int32_t rmPolicyValidatePolicy(void *policyDtb, Rm_PolicyValidInstTree *validInstTree)
+int32_t rmPolicyValidatePolicy(Rm_Handle rmHandle)
{
+ void *policyDtb = rmPolicyGetPolicy(rmHandle);
int32_t nodeOffset;
int32_t propertyOffset;
int32_t depth;
@@ -835,7 +867,7 @@ int32_t rmPolicyValidatePolicy(void *policyDtb, Rm_PolicyValidInstTree *validIns
if (propertyType == Rm_policyPropType_ASSIGNMENTS) {
assignmentList = rmDtbUtilPolicyExtractAssignments(propertyData, propertyLen);
- if ((result = policyValidateAssignmentPermissions(validInstTree, assignmentList)) != RM_OK) {
+ if ((result = policyValidateAssignmentPermissions(rmHandle, assignmentList)) != RM_OK) {
rmDtbUtilPolicyFreeAssignments(assignmentList);
return(result);
}
@@ -858,13 +890,16 @@ int32_t rmPolicyValidatePolicy(void *policyDtb, Rm_PolicyValidInstTree *validIns
* "valid-instances" property at the top of the Policy.
* The root entry of the valid instance tree is returned.
*/
-Rm_PolicyValidInstTree *rmPolicyCreateValidInstTree(void *policyDtb, bool addLinux, int32_t *result)
+Rm_PolicyValidInstTree *rmPolicyCreateValidInstTree(Rm_Handle rmHandle, int addLinux, int32_t *result)
{
+ Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
+ void *policyDtb = rmPolicyGetPolicy(rmHandle);
int32_t validInstOffset;
const char *validInstName = NULL;
int32_t validInstLen;
const void *validInstData = NULL;
Rm_PolicyPropType propertyType;
+ Rm_PolicyValidInst *vInstListStart = NULL;
Rm_PolicyValidInst *validInstList = NULL;
Rm_PolicyValidInstTree *rootEntry = NULL;
Rm_PolicyValidInstNode *newNode = NULL;
@@ -896,12 +931,14 @@ Rm_PolicyValidInstTree *rmPolicyCreateValidInstTree(void *policyDtb, bool addLin
rootEntry = Rm_osalMalloc(sizeof(Rm_PolicyValidInstTree));
RB_INIT(rootEntry);
+ vInstListStart = validInstList;
while (validInstList) {
newNode = rmPolicyValidInstNodeNew(validInstList->instName);
RB_INSERT(_Rm_PolicyValidInstTree, rootEntry, newNode);
validInstList = validInstList->nextValidInst;
}
+ rmDtbUtilPolicyFreeValidInstances(vInstListStart);
/* Add the Linux kernel node */
if (addLinux) {
@@ -909,6 +946,11 @@ Rm_PolicyValidInstTree *rmPolicyCreateValidInstTree(void *policyDtb, bool addLin
RB_INSERT(_Rm_PolicyValidInstTree, rootEntry, newNode);
}
+ if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+ /* Writeback the valid instance tree */
+ rmPolicyValidInstTreeWb(rootEntry);
+ }
+
*result = RM_OK;
return (rootEntry);
}
@@ -918,17 +960,42 @@ Rm_PolicyValidInstTree *rmPolicyCreateValidInstTree(void *policyDtb, bool addLin
* DESCRIPTION: Frees all memory associated with a Policy valid
* instance tree.
*/
-void rmPolicyFreeValidInstTree(Rm_PolicyValidInstTree *validInstTree)
+void rmPolicyFreeValidInstTree(Rm_Handle rmHandle)
{
+ Rm_Inst *rmInst = (Rm_Inst *)rmHandle;
+ Rm_PolicyValidInstTree *treeRoot = policyGetValidInstTree(rmHandle);
Rm_PolicyValidInstNode *node;
-
- RB_FOREACH(node, _Rm_PolicyValidInstTree, validInstTree) {
- RB_REMOVE(_Rm_PolicyValidInstTree, validInstTree, node);
- rmPolicyValidInstNodeFree(node);
- }
- if (RB_MIN(_Rm_PolicyValidInstTree, validInstTree) == NULL) {
- /* No more valid instance nodes in tree */
- Rm_osalFree((void *)validInstTree, sizeof(Rm_PolicyValidInstTree));
+ Rm_PolicyValidInstNode *nextNode;
+
+ if (treeRoot) {
+ if (rmInst->instType == Rm_instType_SHARED_SERVER) {
+ rmPolicyValidInstTreeInv(treeRoot);
+ }
+
+ for (node = RB_MIN(_Rm_PolicyValidInstTree, treeRoot); node != NULL; node = nextNode) {
+ nextNode = RB_NEXT(_Rm_PolicyValidInstTree, treeRoot, node);
+ RB_REMOVE(_Rm_PolicyValidInstTree, treeRoot, node);
+ rmPolicyValidInstNodeFree(node);
+ }
+
+ /* Don't need to writeback tree node changes since valid instance will be made
+ * NULL in instance */
+
+ if (RB_MIN(_Rm_PolicyValidInstTree, treeRoot) == NULL) {
+ /* No more valid instance nodes in tree */
+ Rm_osalFree((void *)treeRoot, sizeof(Rm_PolicyValidInstTree));
+ }
+
+ if ((rmInst->instType == Rm_instType_SERVER) ||
+ (rmInst->instType == Rm_instType_SHARED_SERVER)) {
+ rmInst->u.server.globalValidInstTree = NULL;
+ }
+ else if (rmInst->instType == Rm_instType_CLIENT_DELEGATE) {
+ rmInst->u.cd.cdValidInstTree = NULL;
+ }
+ else if (rmInst->instType == Rm_instType_CLIENT) {
+ rmInst->u.client.staticValidInstTree = NULL;
+ }
}
}