u32 *peer_sid);
 
 int security_get_classes(struct selinux_policy *policy,
-                        char ***classes, int *nclasses);
+                        char ***classes, u32 *nclasses);
 int security_get_permissions(struct selinux_policy *policy,
-                            char *class, char ***perms, int *nperms);
+                            const char *class, char ***perms, u32 *nperms);
 int security_get_reject_unknown(void);
 int security_get_allow_unknown(void);
 
 
                        char *objclass, int classvalue,
                        struct dentry *dir)
 {
-       int i, rc, nperms;
+       u32 i, nperms;
+       int rc;
        char **perms;
 
        rc = security_get_permissions(newpolicy, objclass, &perms, &nperms);
                            struct dentry *class_dir,
                            unsigned long *last_class_ino)
 {
-
-       int rc, nclasses, i;
+       u32 i, nclasses;
+       int rc;
        char **classes;
 
        rc = security_get_classes(newpolicy, &classes, &nclasses);
 
        struct sidtab *sidtab;
        struct sidtab_entry *old_entry, *new_entry;
        struct type_datum *type;
-       int index;
+       u32 index;
        int rc;
 
        if (!selinux_initialized())
                return -ENOMEM;
 
        if (!selinux_initialized()) {
-               int i;
+               u32 i;
 
                for (i = 1; i < SECINITSID_NUM; i++) {
                        const char *s = initial_sid_to_string[i];
 {
        struct policydb *policydb = &policy->policydb;
        struct sidtab *sidtab = policy->sidtab;
-       int len;
        u16 sclass;
        struct genfs *genfs;
        struct ocontext *c;
                return -ENOENT;
 
        for (c = genfs->head; c; c = c->next) {
-               len = strlen(c->u.name);
+               size_t len = strlen(c->u.name);
                if ((!c->v.sclass || sclass == c->v.sclass) &&
                    (strncmp(c->u.name, path, len) == 0))
                        break;
 {
        struct class_datum *datum = d;
        char *name = k, **classes = args;
-       int value = datum->value - 1;
+       u32 value = datum->value - 1;
 
        classes[value] = kstrdup(name, GFP_ATOMIC);
        if (!classes[value])
 }
 
 int security_get_classes(struct selinux_policy *policy,
-                        char ***classes, int *nclasses)
+                        char ***classes, u32 *nclasses)
 {
        struct policydb *policydb;
        int rc;
        rc = hashtab_map(&policydb->p_classes.table, get_classes_callback,
                         *classes);
        if (rc) {
-               int i;
+               u32 i;
+
                for (i = 0; i < *nclasses; i++)
                        kfree((*classes)[i]);
                kfree(*classes);
 {
        struct perm_datum *datum = d;
        char *name = k, **perms = args;
-       int value = datum->value - 1;
+       u32 value = datum->value - 1;
 
        perms[value] = kstrdup(name, GFP_ATOMIC);
        if (!perms[value])
 }
 
 int security_get_permissions(struct selinux_policy *policy,
-                            char *class, char ***perms, int *nperms)
+                            const char *class, char ***perms, u32 *nperms)
 {
        struct policydb *policydb;
-       int rc, i;
+       u32 i;
+       int rc;
        struct class_datum *match;
 
        policydb = &policy->policydb;
 /* Check to see if the rule contains any selinux fields */
 int selinux_audit_rule_known(struct audit_krule *rule)
 {
-       int i;
+       u32 i;
 
        for (i = 0; i < rule->field_count; i++) {
                struct audit_field *f = &rule->fields[i];