diff --git a/src/rm_policy.c b/src/rm_policy.c
index 9432c3dea0c90f053064b0b9661b7ad2c06df2b0..8e2a7c74e9a9d54dbc5ed15755aac831cf1cf14b 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_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>
*********************** Policy Globals *******************************
**********************************************************************/
+/* Character used in Policies to specify all RM instances receive
+ * the defined permissions for a resource node */
const char Rm_policyAllInstances[] = "*";
/**********************************************************************
******************** Local Policy Functions **************************
**********************************************************************/
+/* FUNCTION PURPOSE: Validates the instance names in a permissions string
+ ***********************************************************************
+ * DESCRIPTION: Returns RM_OK if all the instance names in a permissions
+ * string match instance names defined in the valid instance
+ * 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)
{
while (permissionsList) {
- if (strcmp(permissionsList->instName, Rm_policyAllInstances) &&
+ if (strncmp(permissionsList->instName, Rm_policyAllInstances, RM_NAME_MAX_CHARS) &&
(!rmPolicyGetValidInstNode(validInstTree, permissionsList->instName))) {
- return(RM_INIT_ERROR_POLICY_UNKNOWN_INSTANCE);
+ return(RM_ERROR_PERM_STR_INST_NOT_VALID);
}
permissionsList = permissionsList->nextPermission;
}
- return(RM_INIT_OK);
+ return(RM_OK);
}
+/* FUNCTION PURPOSE: Parses a permissions subgroup
+ ***********************************************************************
+ * DESCRIPTION: Returns a linked list of policy permissions defining
+ * which RM instance referenced in the permissions subgroup
+ * get which permissions. Returns NULL if any syntax
+ * errors are encountered during the parsing. The error
+ * is returned via the result pointer parameter.
+ */
static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *permStrEnd,
int32_t *result)
{
@@ -123,7 +141,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
* 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_INIT_ERROR_POLICY_SYNTAX_ERROR_MORE_THAN_ONE_INSTANCE_GROUP;
+ *result = RM_ERROR_PERM_STR_TOO_MANY_INST_GROUPS;
return(NULL);
}
@@ -131,8 +149,8 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
* Instances names are separated by one or more spaces. */
permStrPtr = subgroupStart + 1;
instNameIndex = 0;
- foundInstName = FALSE;
- instNameComplete = FALSE;
+ foundInstName = false;
+ instNameComplete = false;
while (permStrPtr <= subgroupEnd) {
if ((isspace(*permStrPtr) || (*permStrPtr == RM_POLICY_PERM_SUBGROUP_END))
&& foundInstName) {
@@ -140,13 +158,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 = true;
}
else {
if (!foundInstName) {
/* First non-whitespace character encountered is the start of an
* instance name */
- foundInstName = TRUE;
+ foundInstName = true;
}
/* Copy the character into the temporary instance name string */
@@ -165,13 +183,13 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
startPerm = newPerm;
}
else {
- prevPerm->nextPermission = (void *) newPerm;
+ prevPerm->nextPermission = newPerm;
}
prevPerm = newPerm;
- instNameComplete = FALSE;
+ instNameComplete = false;
instNameIndex = 0;
- foundInstName = FALSE;
+ foundInstName = false;
}
else if (instNameIndex == RM_NAME_MAX_CHARS) {
/* Instance name is longer than max length */
@@ -181,7 +199,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
startPerm = nextPerm;
}
Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
- *result = RM_INIT_ERROR_POLICY_SYNTAX_ERROR_INSTANCE_NAME_IN_ASSIGNMENT_TOO_LONG;
+ *result = RM_ERROR_INST_NAME_IN_ASSIGNMENT_TOO_LONG;
return(NULL);
}
@@ -192,7 +210,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
/* Look on left of instance group for permission assignments. */
permStrPtr = subgroupStart - 1;
- assignmentLeft = FALSE;
+ assignmentLeft = false;
while (permStrPtr >= permStrStart)
{
if (*permStrPtr == RM_POLICY_PERM_ASSIGNMENT) {
@@ -206,11 +224,11 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
startPerm = nextPerm;
}
Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
- *result = RM_INIT_ERROR_POLICY_SYNTAX_ERROR_MORE_THAN_ONE_ASSIGNMENT_CHAR;
+ *result = RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS;
return(NULL);
}
else {
- assignmentLeft = TRUE;
+ assignmentLeft = true;
}
}
else if (!isspace(*permStrPtr)) {
@@ -257,7 +275,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
startPerm = nextPerm;
}
Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
- *result = RM_INIT_ERROR_POLICY_SYNTAX_ERROR_INVALID_PERM_CHAR;
+ *result = RM_ERROR_PERM_STR_INVALID_CHAR;
return(NULL);
}
}
@@ -271,7 +289,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
startPerm = nextPerm;
}
Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
- *result = RM_INIT_ERROR_POLICY_SYNTAX_ERROR_PERM_CHAR_WITHOUT_ASSIGN_CHAR;
+ *result = RM_ERROR_PERM_CHAR_WITHOUT_ASSIGN_CHAR;
return(NULL);
}
}
@@ -280,7 +298,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
/* Look on right of instance group for permission assignments. */
permStrPtr = subgroupEnd + 1;
- assignmentRight = FALSE;
+ assignmentRight = false;
while (permStrPtr < permStrEnd) {
if (assignmentLeft && (!isspace(*permStrPtr))) {
/* There should be nothing but spaces on right if assignment was already found on left */
@@ -290,7 +308,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
startPerm = nextPerm;
}
Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
- *result = RM_INIT_ERROR_POLICY_SYNTAX_ERROR_INVALID_CHAR_ON_RIGHT_WITH_ASSINMENT_ON_LEFT;
+ *result = RM_ERROR_INVALID_PERMS_CHAR_ON_RIGHT;
return(NULL);
}
@@ -305,11 +323,11 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
startPerm = nextPerm;
}
Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
- *result = RM_INIT_ERROR_POLICY_SYNTAX_ERROR_MORE_THAN_ONE_ASSIGNMENT_CHAR;
+ *result = RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS;
return(NULL);
}
else {
- assignmentRight = TRUE;
+ assignmentRight = true;
}
}
else if (!isspace(*permStrPtr)) {
@@ -356,7 +374,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
startPerm = nextPerm;
}
Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
- *result = RM_INIT_ERROR_POLICY_SYNTAX_ERROR_INVALID_PERM_CHAR;
+ *result = RM_ERROR_PERM_STR_INVALID_CHAR;
return(NULL);
}
}
@@ -370,7 +388,7 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
startPerm = nextPerm;
}
Rm_osalFree((void *)permStrStart, sizeof(permStrLen));
- *result = RM_INIT_ERROR_POLICY_SYNTAX_ERROR_MORE_THAN_ONE_ASSIGNMENT_CHAR;
+ *result = RM_ERROR_PERM_STR_TOO_MANY_ASSIGN_CHARS;
return(NULL);
}
}
@@ -381,6 +399,12 @@ static Rm_PolicyPermission *policyParseSubPermission(char *permStrStart, char *p
return (startPerm);
}
+/* FUNCTION PURPOSE: Frees a linked list of assignment permissions
+ ***********************************************************************
+ * DESCRIPTION: Frees the memory associated with a linked list of
+ * assignment permissions extracted from a permissions
+ * assignment subgroup in a policy DTB.
+ */
static void policyFreeAssignmentPermissions(Rm_PolicyPermission *permissionList)
{
Rm_PolicyPermission *nextPerm;
@@ -392,6 +416,13 @@ static void policyFreeAssignmentPermissions(Rm_PolicyPermission *permissionList)
}
}
+/* FUNCTION PURPOSE: Extracts permissions from a Policy "assignment"
+ ***********************************************************************
+ * DESCRIPTION: Returns a linked list of permissions for a resource node
+ * containing an "assignment" property in the Policy DTB.
+ * 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,
int32_t *result)
{
@@ -443,21 +474,28 @@ static Rm_PolicyPermission *policyGetAssignmentPermissions(Rm_PolicyAssignment *
return(startPerm);
}
+/* FUNCTION PURPOSE: Validates a policy "assignment" string list
+ ***********************************************************************
+ * DESCRIPTION: Returns RM_OK if the specified Policy DTB "assignment"
+ * property specification parses okay and all the RM
+ * instances in the assignment match RM instances in the
+ * valid instances list
+ */
static int32_t policyValidateAssignmentPermissions(Rm_PolicyValidInstTree *root,
Rm_PolicyAssignment *assignmentList)
{
Rm_PolicyAssignment *assignment = assignmentList;
Rm_PolicyPermission *permissionList;
- int32_t result;
+ int32_t result = RM_OK;
while (assignment) {
/* Make sure assignment's permissions parse okay */
permissionList = policyGetAssignmentPermissions(assignment, &result);
- if (result != RM_INIT_OK) {
+ if (result != RM_OK) {
return(result);
}
- if (result = policyCheckInstances(root, permissionList) != RM_INIT_OK) {
+ if (result = policyCheckInstances(root, permissionList) != RM_OK) {
policyFreeAssignmentPermissions(permissionList);
return(result);
}
@@ -466,13 +504,18 @@ static int32_t policyValidateAssignmentPermissions(Rm_PolicyValidInstTree *root,
assignment = assignment->nextAssignment;
}
- return (RM_INIT_OK);
+ return (RM_OK);
}
/**********************************************************************
************************ Internal Policy APIs ************************
**********************************************************************/
+/* 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 findNode;
@@ -483,6 +526,12 @@ Rm_PolicyValidInstNode *rmPolicyGetValidInstNode(Rm_PolicyValidInstTree *validIn
return (RB_FIND(_Rm_PolicyValidInstTree, validInstTree, &findNode));
}
+/* FUNCTION PURPOSE: Gets the Linux Valid instance node
+ ***********************************************************************
+ * DESCRIPTION: Returns a pointer to the valid instance node in the
+ * valid instance tree that matches the instance name
+ * reserved for resource assigned to the Linux kernel.
+ */
Rm_PolicyValidInstNode *rmPolicyGetLinuxInstNode(Rm_PolicyValidInstTree *validInstTree)
{
char linuxName[] = RM_ALLOCATED_TO_LINUX;
@@ -490,12 +539,18 @@ Rm_PolicyValidInstNode *rmPolicyGetLinuxInstNode(Rm_PolicyValidInstTree *validIn
return (rmPolicyGetValidInstNode(validInstTree, linuxName));
}
+/* FUNCTION PURPOSE: Validates resource permissions against a Policy DTB
+ ***********************************************************************
+ * DESCRIPTION: Returns TRUE if the instance name has the specified
+ * permissions for the specified resource in the Policy
+ * DTB. Otherwise, returns FALSE.
+ */
bool rmPolicyCheckPrivilege(Rm_PolicyCheckCfg *privilegeCfg, int32_t *result)
{
int32_t propertyOffset;
const char *propertyName;
- int32_t propertyLen;
- const void *propertyData;
+ int32_t propertyLen;
+ const void *propertyData;
Rm_PolicyAssignment *assignment = NULL;
Rm_PolicyAssignment *assignmentStart = NULL;
Rm_PolicyPermission *permission = NULL;
if (assignment) {
while (assignment) {
assignmentEnd = assignment->resourceBase + assignment->resourceLength - 1;
- foundInstance = FALSE;
+ foundInstance = 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 = 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(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(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(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(false);
+ }
+ }
break;
}
permission = permission->nextPermission;
policyFreeAssignmentPermissions(permissionStart);
if (!foundInstance) {
rmDtbUtilPolicyFreeAssignments(assignmentStart);
- return(FALSE);
+ return(false);
}
}
assignment = assignment->nextAssignment;
rmDtbUtilPolicyFreeAssignments(assignmentStart);
}
else {
- return(FALSE);
+ return(false);
}
- return(TRUE);
+ return(true);
}
+/* FUNCTION PURPOSE: Returns resource base value according to the Policy
+ ***********************************************************************
+ * DESCRIPTION: Returns a resource base value based on the resource
+ * ranges assigned to the specified valid instance by the
+ * Policy DTB.
+ */
uint32_t rmPolicyGetResourceBase(void *policyDtb, Rm_PolicyValidInstNode *validInstNode,
int32_t resourceOffset, uint32_t allocType,
int32_t *result)
@@ -585,8 +653,8 @@ uint32_t rmPolicyGetResourceBase(void *policyDtb, Rm_PolicyValidInstNode *validI
{
int32_t propertyOffset;
const char *propertyName;
- int32_t propertyLen;
- const void *propertyData;
+ int32_t propertyLen;
+ const void *propertyData;
Rm_PolicyAssignment *assignment = NULL;
Rm_PolicyAssignment *assignmentStart = NULL;
Rm_PolicyPermission *permission = NULL;
@@ -605,51 +673,55 @@ uint32_t rmPolicyGetResourceBase(void *policyDtb, Rm_PolicyValidInstNode *validI
}
}
- /* Search policy permissions for a valid resource base */
- if (assignment) {
- while (assignment) {
- permission = permissionStart = policyGetAssignmentPermissions(assignment, result);
- while (permission) {
- if ((strcmp(permission->instName, validInstNode->name) == 0) ||
- (strcmp(permission->instName, Rm_policyAllInstances) == 0)) {
- /* Check instance's permissions */
- if (RM_policy_GET_PERM(allocType, RM_POLICY_PERM_INIT_SHIFT) &&
- 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) &&
- RM_policy_GET_PERM(permission->permissionBits, RM_POLICY_PERM_USE_SHIFT)) {
- resourceBase = assignment->resourceBase;
- break;
- }
+ /* Search policy permissions for valid resource base */
+ while (assignment) {
+ permission = permissionStart = policyGetAssignmentPermissions(assignment, result);
+ while (permission) {
+ 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) &&
+ 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) &&
+ RM_policy_GET_PERM(permission->permissionBits, RM_POLICY_PERM_USE_SHIFT)) {
+ resourceBase = assignment->resourceBase;
+ break;
}
- permission = permission->nextPermission;
}
- policyFreeAssignmentPermissions(permissionStart);
+ permission = permission->nextPermission;
+ }
+ policyFreeAssignmentPermissions(permissionStart);
- if (resourceBase) {
- break;
- }
- else {
- assignment = assignment->nextAssignment;
- }
+ if (resourceBase) {
+ break;
+ }
+ else {
+ assignment = assignment->nextAssignment;
}
- rmDtbUtilPolicyFreeAssignments(assignmentStart);
}
- else {
- *result = RM_SERVICE_DENIED_NO_RANGE_ASSIGNMENTS_FOR_POLICY;
+
+ if (assignmentStart) {
+ rmDtbUtilPolicyFreeAssignments(assignmentStart);
}
return(resourceBase);
}
+/* FUNCTION PURPOSE: Returns resource alignment value according to the Policy
+ ***********************************************************************
+ * DESCRIPTION: Returns a resource alignment value based on the resource
+ * alignment assigned to the specified valid instance by the
+ * Policy DTB.
+ */
uint32_t rmPolicyGetResourceAlignment(void *policyDtb, int32_t resourceOffset)
{
int32_t propertyOffset;
const char *propertyName;
- int32_t propertyLen;
- const void *propertyData;
+ int32_t propertyLen;
+ const void *propertyData;
Rm_ResourceValue *alignmentList;
uint32_t resourceAlignment = 0;
return(resourceAlignment);
}
+/* FUNCTION PURPOSE: Get a resource's offset into a Policy
+ ***********************************************************************
+ * DESCRIPTION: Returns the location of the specified resource node
+ * within the specified Policy in the form of an offset
+ * into the DTB. The resourceName and the Policy
+ * node name must match.
+ */
int32_t rmPolicyGetResourceOffset(void *policyDtb, char *resourceName)
{
int32_t nodeOffset;
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);
}
+/* FUNCTION PURPOSE: Validates a Policy's resource node names
+ ***********************************************************************
+ * DESCRIPTION: Returns RM_OK if all of a Policy's resource node names
+ * match a node name specified in the "valid-instances"
+ * list specified at the top of the Policy. Otherwise,
+ * returns error
+ */
int32_t rmPolicyValidatePolicyResourceNames(void *policyDtb, void *allocatorList)
{
Rm_Allocator *allocator = (Rm_Allocator *)allocatorList;
@@ -711,22 +802,31 @@ int32_t rmPolicyValidatePolicyResourceNames(void *policyDtb, void *allocatorList
if (fdt_first_property_offset(policyDtb, nodeOffset) > RM_DTB_UTIL_STARTING_NODE_OFFSET) {
if (rmAllocatorFind(allocator, (char *)nodeName) == NULL) {
/* No allocator tied to resource name */
- return(RM_INIT_ERROR_POLICY_UNKNOWN_RESOURCE);
+ return(RM_ERROR_UNKNOWN_RESOURCE_IN_POLICY);
}
}
}
- return(RM_INIT_OK);
+ return(RM_OK);
}
-/* TODO: ADD ABILITY TO RETURN THE SYNTAX ERROR LOCATION */
+/* FUNCTION PURPOSE: Validates a Policy DTB
+ ***********************************************************************
+ * DESCRIPTION: Returns RM_OK if the input Policy satisfies the
+ * following conditions:
+ * a) All "assignment" permission string parse okay
+ * b) All RM instance names specified in the permission
+ * strings match an instance name in the valid instance
+ * list
+ * c) All resource node names match a resource allocator
+ */
int32_t rmPolicyValidatePolicy(void *policyDtb, Rm_PolicyValidInstTree *validInstTree)
{
int32_t nodeOffset;
int32_t propertyOffset;
int32_t depth;
const char *propertyName;
- int32_t propertyLen;
- const void *propertyData;
+ int32_t propertyLen;
+ const void *propertyData;
Rm_PolicyPropType propertyType;
Rm_PolicyAssignment *assignmentList;
int32_t result;
@@ -747,27 +847,35 @@ int32_t rmPolicyValidatePolicy(void *policyDtb, Rm_PolicyValidInstTree *validIns
if (propertyType == Rm_policyPropType_ASSIGNMENTS) {
assignmentList = rmDtbUtilPolicyExtractAssignments(propertyData, propertyLen);
- if ((result = policyValidateAssignmentPermissions(validInstTree, assignmentList)) != RM_INIT_OK) {
+ if ((result = policyValidateAssignmentPermissions(validInstTree, assignmentList)) != RM_OK) {
rmDtbUtilPolicyFreeAssignments(assignmentList);
return(result);
}
rmDtbUtilPolicyFreeAssignments(assignmentList);
}
else if (propertyType == Rm_policyPropType_UNKNOWN) {
- return(RM_INIT_ERROR_POLICY_UNKNOWN_RESOURCE_PROPERTY);
+ return(RM_ERROR_UNKNOWN_POLICY_RESOURCE_PROPERTY);
}
propertyOffset = fdt_next_property_offset(policyDtb, propertyOffset);
}
}
- return(RM_INIT_OK);
+ return(RM_OK);
}
-Rm_PolicyValidInstTree *rmPolicyCreateValidInstTree(void *policyDtb, int32_t *result)
+/* FUNCTION PURPOSE: Creates the valid instance tree for a RM instance
+ ***********************************************************************
+ * DESCRIPTION: Creates the valid instance tree for a RM instance
+ * that has been provided a global or static policy
+ * The valid instance tree is created from the
+ * "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)
{
int32_t validInstOffset;
const char *validInstName = NULL;
- int32_t validInstLen;
- const void *validInstData = NULL;
+ int32_t validInstLen;
+ const void *validInstData = NULL;
Rm_PolicyPropType propertyType;
Rm_PolicyValidInst *validInstList = NULL;
Rm_PolicyValidInstTree *rootEntry = NULL;
@@ -782,13 +890,13 @@ Rm_PolicyValidInstTree *rmPolicyCreateValidInstTree(void *policyDtb, int32_t *re
return (NULL);
}
else if (validInstOffset == -FDT_ERR_NOTFOUND) {
- *result = RM_INIT_ERROR_POLICY_NO_VALID_INSTANCES_DEFINED;
+ *result = RM_ERROR_NO_VALID_INST_IN_POLICY;
return (NULL);
}
validInstData = fdt_getprop_by_offset(policyDtb, validInstOffset, &validInstName, &validInstLen);
propertyType = rmDtbUtilPolicyGetPropertyType(validInstName);
if (propertyType != Rm_policyPropType_VALID_INSTANCES) {
- *result = RM_INIT_ERROR_POLICY_NO_VALID_INSTANCES_DEFINED;
+ *result = RM_ERROR_NO_VALID_INST_IN_POLICY;
return (NULL);
}
@@ -808,21 +916,33 @@ Rm_PolicyValidInstTree *rmPolicyCreateValidInstTree(void *policyDtb, int32_t *re
}
/* Add the Linux kernel node */
- newNode = rmPolicyValidInstNodeNew(linuxName);
- RB_INSERT(_Rm_PolicyValidInstTree, rootEntry, newNode);
+ if (addLinux) {
+ newNode = rmPolicyValidInstNodeNew(linuxName);
+ RB_INSERT(_Rm_PolicyValidInstTree, rootEntry, newNode);
+ }
- *result = RM_INIT_OK;
+ *result = RM_OK;
return (rootEntry);
}
+/* FUNCTION PURPOSE: Deletes a valid instance tree
+ ***********************************************************************
+ * DESCRIPTION: Frees all memory associated with a Policy valid
+ * instance tree.
+ */
void rmPolicyFreeValidInstTree(Rm_PolicyValidInstTree *validInstTree)
{
Rm_PolicyValidInstNode *node;
-
- RB_FOREACH(node, _Rm_PolicyValidInstTree, validInstTree) {
+ Rm_PolicyValidInstNode *nextNode;
+
+ for (node = RB_MIN(_Rm_PolicyValidInstTree, validInstTree); node != NULL; node = nextNode) {
+ nextNode = RB_NEXT(_Rm_PolicyValidInstTree, validInstTree, node);
RB_REMOVE(_Rm_PolicyValidInstTree, validInstTree, node);
rmPolicyValidInstNodeFree(node);
- }
- Rm_osalFree((void *)validInstTree, sizeof(Rm_PolicyValidInstTree));
+ }
+ if (RB_MIN(_Rm_PolicyValidInstTree, validInstTree) == NULL) {
+ /* No more valid instance nodes in tree */
+ Rm_osalFree((void *)validInstTree, sizeof(Rm_PolicyValidInstTree));
+ }
}