Smack: allow for significantly longer Smack labels v4

V4 updated to current linux-security#next
Targeted for git://gitorious.org/smack-next/kernel.git

Modern application runtime environments like to use
naming schemes that are structured and generated without
human intervention. Even though the Smack limit of 23
characters for a label name is perfectly rational for
human use there have been complaints that the limit is
a problem in environments where names are composed from
a set or sources, including vendor, author, distribution
channel and application name. Names like

	softwarehouse-pgwodehouse-coolappstore-mellowmuskrats

are becoming harder to avoid. This patch introduces long
label support in Smack. Labels are now limited to 255
characters instead of the old 23.

The primary reason for limiting the labels to 23 characters
was so they could be directly contained in CIPSO category sets.
This is still done were possible, but for labels that are too
large a mapping is required. This is perfectly safe for communication
that stays "on the box" and doesn't require much coordination
between boxes beyond what would have been required to keep label
names consistent.

The bulk of this patch is in smackfs, adding and updating
administrative interfaces. Because existing APIs can't be
changed new ones that do much the same things as old ones
have been introduced.

The Smack specific CIPSO data representation has been removed
and replaced with the data format used by netlabel. The CIPSO
header is now computed when a label is imported rather than
on use. This results in improved IP performance. The smack
label is now allocated separately from the containing structure,
allowing for larger strings.

Four new /smack interfaces have been introduced as four
of the old interfaces strictly required labels be specified
in fixed length arrays.

The access interface is supplemented with the check interface:
	access  "Subject                 Object                  rwxat"
	access2 "Subject Object rwaxt"

The load interface is supplemented with the rules interface:
	load   "Subject                 Object                  rwxat"
	load2  "Subject Object rwaxt"

The load-self interface is supplemented with the self-rules interface:
	load-self   "Subject                 Object                  rwxat"
	load-self2  "Subject Object rwaxt"

The cipso interface is supplemented with the wire interface:
	cipso  "Subject                  lvl cnt  c1  c2 ..."
	cipso2 "Subject lvl cnt  c1  c2 ..."

The old interfaces are maintained for compatibility.

Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>

1 files changed, 761 insertions, 232 deletions

diff --git a/security/smack/smackfs.c b/security/smack/smackfs.c
index 038811cb7e62..1810c9a4ed48 100644
--- a/security/smack/smackfs.c
+++ b/security/smack/smackfs.c
@@ -22,7 +22,6 @@
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <net/net_namespace.h>
-#include <net/netlabel.h>
 #include <net/cipso_ipv4.h>
 #include <linux/seq_file.h>
 #include <linux/ctype.h>
@@ -45,6 +44,11 @@ enum smk_inos {
         SMK_LOGGING     = 10,   /* logging */
         SMK_LOAD_SELF   = 11,   /* task specific rules */
         SMK_ACCESSES    = 12,   /* access policy */
+        SMK_MAPPED      = 13,   /* CIPSO level indicating mapped label */
+        SMK_LOAD2       = 14,   /* load policy with long labels */
+        SMK_LOAD_SELF2  = 15,   /* load task specific rules with long labels */
+        SMK_ACCESS2     = 16,   /* make an access check with long labels */
+        SMK_CIPSO2      = 17,   /* load long label -> CIPSO mapping */
 };
 
 /*
@@ -60,7 +64,7 @@ static DEFINE_MUTEX(smk_netlbladdr_lock);
  * If it isn't somehow marked, use this.
  * It can be reset via smackfs/ambient
  */
-char *smack_net_ambient = smack_known_floor.smk_known;
+char *smack_net_ambient;
 
 /*
  * This is the level in a CIPSO header that indicates a
@@ -70,6 +74,13 @@ char *smack_net_ambient = smack_known_floor.smk_known;
 int smack_cipso_direct = SMACK_CIPSO_DIRECT_DEFAULT;
 
 /*
+ * This is the level in a CIPSO header that indicates a
+ * secid is contained directly in the category set.
+ * It can be reset via smackfs/mapped
+ */
+int smack_cipso_mapped = SMACK_CIPSO_MAPPED_DEFAULT;
+
+/*
  * Unless a process is running with this label even
  * having CAP_MAC_OVERRIDE isn't enough to grant
  * privilege to violate MAC policy. If no label is
@@ -89,7 +100,7 @@ LIST_HEAD(smk_netlbladdr_list);
 
 /*
  * Rule lists are maintained for each label.
- * This master list is just for reading /smack/load.
+ * This master list is just for reading /smack/load and /smack/load2.
  */
 struct smack_master_list {
         struct list_head        list;
@@ -125,6 +136,18 @@ const char *smack_cipso_option = SMACK_CIPSO_OPTION;
 #define SMK_OLOADLEN    (SMK_LABELLEN + SMK_LABELLEN + SMK_OACCESSLEN)
 #define SMK_LOADLEN     (SMK_LABELLEN + SMK_LABELLEN + SMK_ACCESSLEN)
 
+/*
+ * Stricly for CIPSO level manipulation.
+ * Set the category bit number in a smack label sized buffer.
+ */
+static inline void smack_catset_bit(unsigned int cat, char *catsetp)
+{
+        if (cat == 0 || cat > (SMK_CIPSOLEN * 8))
+                return;
+
+        catsetp[(cat - 1) / 8] |= 0x80 >> ((cat - 1) % 8);
+}
+
 /**
  * smk_netlabel_audit_set - fill a netlbl_audit struct
  * @nap: structure to fill
@@ -137,12 +160,10 @@ static void smk_netlabel_audit_set(struct netlbl_audit *nap)
 }
 
 /*
- * Values for parsing single label host rules
+ * Value for parsing single label host rules
  * "1.2.3.4 X"
- * "192.168.138.129/32 abcdefghijklmnopqrstuvw"
  */
 #define SMK_NETLBLADDRMIN       9
-#define SMK_NETLBLADDRMAX       42
 
 /**
  * smk_set_access - add a rule to the rule list
@@ -188,33 +209,47 @@ static int smk_set_access(struct smack_rule *srp, struct list_head *rule_list,
 }
 
 /**
- * smk_parse_rule - parse Smack rule from load string
- * @data: string to be parsed whose size is SMK_LOADLEN
+ * smk_fill_rule - Fill Smack rule from strings
+ * @subject: subject label string
+ * @object: object label string
+ * @access: access string
  * @rule: Smack rule
  * @import: if non-zero, import labels
+ *
+ * Returns 0 on success, -1 on failure
  */
-static int smk_parse_rule(const char *data, struct smack_rule *rule, int import)
+static int smk_fill_rule(const char *subject, const char *object,
+                                const char *access, struct smack_rule *rule,
+                                int import)
 {
-        char smack[SMK_LABELLEN];
+        int rc = -1;
+        int done;
+        const char *cp;
         struct smack_known *skp;
 
         if (import) {
-                rule->smk_subject = smk_import(data, 0);
+                rule->smk_subject = smk_import(subject, 0);
                 if (rule->smk_subject == NULL)
                         return -1;
 
-                rule->smk_object = smk_import(data + SMK_LABELLEN, 0);
+                rule->smk_object = smk_import(object, 0);
                 if (rule->smk_object == NULL)
                         return -1;
         } else {
-                smk_parse_smack(data, 0, smack);
-                skp = smk_find_entry(smack);
+                cp = smk_parse_smack(subject, 0);
+                if (cp == NULL)
+                        return -1;
+                skp = smk_find_entry(cp);
+                kfree(cp);
                 if (skp == NULL)
                         return -1;
                 rule->smk_subject = skp->smk_known;
 
-                smk_parse_smack(data + SMK_LABELLEN, 0, smack);
-                skp = smk_find_entry(smack);
+                cp = smk_parse_smack(object, 0);
+                if (cp == NULL)
+                        return -1;
+                skp = smk_find_entry(cp);
+                kfree(cp);
                 if (skp == NULL)
                         return -1;
                 rule->smk_object = skp->smk_known;
@@ -222,90 +257,127 @@ static int smk_parse_rule(const char *data, struct smack_rule *rule, int import)
 
         rule->smk_access = 0;
 
-        switch (data[SMK_LABELLEN + SMK_LABELLEN]) {
-        case '-':
-                break;
-        case 'r':
-        case 'R':
-                rule->smk_access |= MAY_READ;
-                break;
-        default:
-                return -1;
+        for (cp = access, done = 0; *cp && !done; cp++) {
+                switch (*cp) {
+                case '-':
+                        break;
+                case 'r':
+                case 'R':
+                        rule->smk_access |= MAY_READ;
+                        break;
+                case 'w':
+                case 'W':
+                        rule->smk_access |= MAY_WRITE;
+                        break;
+                case 'x':
+                case 'X':
+                        rule->smk_access |= MAY_EXEC;
+                        break;
+                case 'a':
+                case 'A':
+                        rule->smk_access |= MAY_APPEND;
+                        break;
+                case 't':
+                case 'T':
+                        rule->smk_access |= MAY_TRANSMUTE;
+                        break;
+                default:
+                        done = 1;
+                        break;
+                }
         }
+        rc = 0;
 
-        switch (data[SMK_LABELLEN + SMK_LABELLEN + 1]) {
-        case '-':
-                break;
-        case 'w':
-        case 'W':
-                rule->smk_access |= MAY_WRITE;
-                break;
-        default:
-                return -1;
-        }
+        return rc;
+}
 
-        switch (data[SMK_LABELLEN + SMK_LABELLEN + 2]) {
-        case '-':
-                break;
-        case 'x':
-        case 'X':
-                rule->smk_access |= MAY_EXEC;
-                break;
-        default:
-                return -1;
-        }
+/**
+ * smk_parse_rule - parse Smack rule from load string
+ * @data: string to be parsed whose size is SMK_LOADLEN
+ * @rule: Smack rule
+ * @import: if non-zero, import labels
+ *
+ * Returns 0 on success, -1 on errors.
+ */
+static int smk_parse_rule(const char *data, struct smack_rule *rule, int import)
+{
+        int rc;
 
-        switch (data[SMK_LABELLEN + SMK_LABELLEN + 3]) {
-        case '-':
-                break;
-        case 'a':
-        case 'A':
-                rule->smk_access |= MAY_APPEND;
-                break;
-        default:
-                return -1;
-        }
+        rc = smk_fill_rule(data, data + SMK_LABELLEN,
+                           data + SMK_LABELLEN + SMK_LABELLEN, rule, import);
+        return rc;
+}
 
-        switch (data[SMK_LABELLEN + SMK_LABELLEN + 4]) {
-        case '-':
-                break;
-        case 't':
-        case 'T':
-                rule->smk_access |= MAY_TRANSMUTE;
-                break;
-        default:
-                return -1;
-        }
+/**
+ * smk_parse_long_rule - parse Smack rule from rule string
+ * @data: string to be parsed, null terminated
+ * @rule: Smack rule
+ * @import: if non-zero, import labels
+ *
+ * Returns 0 on success, -1 on failure
+ */
+static int smk_parse_long_rule(const char *data, struct smack_rule *rule,
+                                int import)
+{
+        char *subject;
+        char *object;
+        char *access;
+        int datalen;
+        int rc = -1;
 
-        return 0;
+        /*
+         * This is probably inefficient, but safe.
+         */
+        datalen = strlen(data);
+        subject = kzalloc(datalen, GFP_KERNEL);
+        if (subject == NULL)
+                return -1;
+        object = kzalloc(datalen, GFP_KERNEL);
+        if (object == NULL)
+                goto free_out_s;
+        access = kzalloc(datalen, GFP_KERNEL);
+        if (access == NULL)
+                goto free_out_o;
+
+        if (sscanf(data, "%s %s %s", subject, object, access) == 3)
+                rc = smk_fill_rule(subject, object, access, rule, import);
+
+        kfree(access);
+free_out_o:
+        kfree(object);
+free_out_s:
+        kfree(subject);
+        return rc;
 }
 
+#define SMK_FIXED24_FMT 0       /* Fixed 24byte label format */
+#define SMK_LONG_FMT    1       /* Variable long label format */
 /**
- * smk_write_load_list - write() for any /smack/load
+ * smk_write_rules_list - write() for any /smack rule file
  * @file: file pointer, not actually used
  * @buf: where to get the data from
  * @count: bytes sent
  * @ppos: where to start - must be 0
  * @rule_list: the list of rules to write to
  * @rule_lock: lock for the rule list
+ * @format: /smack/load or /smack/load2 format.
  *
  * Get one smack access rule from above.
- * The format is exactly:
- *     char subject[SMK_LABELLEN]
- *     char object[SMK_LABELLEN]
- *     char access[SMK_ACCESSLEN]
- *
- * writes must be SMK_LABELLEN+SMK_LABELLEN+SMK_ACCESSLEN bytes.
+ * The format for SMK_LONG_FMT is:
+ *      "subject<whitespace>object<whitespace>access[<whitespace>...]"
+ * The format for SMK_FIXED24_FMT is exactly:
+ *      "subject                 object                  rwxat"
  */
-static ssize_t smk_write_load_list(struct file *file, const char __user *buf,
-                                size_t count, loff_t *ppos,
-                                struct list_head *rule_list,
-                                struct mutex *rule_lock)
+static ssize_t smk_write_rules_list(struct file *file, const char __user *buf,
+                                        size_t count, loff_t *ppos,
+                                        struct list_head *rule_list,
+                                        struct mutex *rule_lock, int format)
 {
         struct smack_master_list *smlp;
         struct smack_known *skp;
         struct smack_rule *rule;
         char *data;
+        int datalen;
         int rc = -EINVAL;
         int load = 0;
 
@@ -315,13 +387,18 @@ static ssize_t smk_write_load_list(struct file *file, const char __user *buf,
          */
         if (*ppos != 0)
                 return -EINVAL;
-        /*
-         * Minor hack for backward compatibility
-         */
-        if (count < (SMK_OLOADLEN) || count > SMK_LOADLEN)
-                return -EINVAL;
 
-        data = kzalloc(SMK_LOADLEN, GFP_KERNEL);
+        if (format == SMK_FIXED24_FMT) {
+                /*
+                 * Minor hack for backward compatibility
+                 */
+                if (count != SMK_OLOADLEN && count != SMK_LOADLEN)
+                        return -EINVAL;
+                datalen = SMK_LOADLEN;
+        } else
+                datalen = count + 1;
+
+        data = kzalloc(datalen, GFP_KERNEL);
         if (data == NULL)
                 return -ENOMEM;
 
@@ -330,20 +407,29 @@ static ssize_t smk_write_load_list(struct file *file, const char __user *buf,
                 goto out;
         }
 
-        /*
-         * More on the minor hack for backward compatibility
-         */
-        if (count == (SMK_OLOADLEN))
-                data[SMK_OLOADLEN] = '-';
-
         rule = kzalloc(sizeof(*rule), GFP_KERNEL);
         if (rule == NULL) {
                 rc = -ENOMEM;
                 goto out;
         }
 
-        if (smk_parse_rule(data, rule, 1))
-                goto out_free_rule;
+        if (format == SMK_LONG_FMT) {
+                /*
+                 * Be sure the data string is terminated.
+                 */
+                data[count] = '\0';
+                if (smk_parse_long_rule(data, rule, 1))
+                        goto out_free_rule;
+        } else {
+                /*
+                 * More on the minor hack for backward compatibility
+                 */
+                if (count == (SMK_OLOADLEN))
+                        data[SMK_OLOADLEN] = '-';
+                if (smk_parse_rule(data, rule, 1))
+                        goto out_free_rule;
+        }
+
 
         if (rule_list == NULL) {
                 load = 1;
@@ -354,18 +440,20 @@ static ssize_t smk_write_load_list(struct file *file, const char __user *buf,
 
         rc = count;
         /*
-         * If this is "load" as opposed to "load-self" and a new rule
+         * If this is a global as opposed to self and a new rule
          * it needs to get added for reporting.
          * smk_set_access returns true if there was already a rule
          * for the subject/object pair, and false if it was new.
          */
-        if (load && !smk_set_access(rule, rule_list, rule_lock)) {
-                smlp = kzalloc(sizeof(*smlp), GFP_KERNEL);
-                if (smlp != NULL) {
-                        smlp->smk_rule = rule;
-                        list_add_rcu(&smlp->list, &smack_rule_list);
-                } else
-                        rc = -ENOMEM;
+        if (!smk_set_access(rule, rule_list, rule_lock)) {
+                if (load) {
+                        smlp = kzalloc(sizeof(*smlp), GFP_KERNEL);
+                        if (smlp != NULL) {
+                                smlp->smk_rule = rule;
+                                list_add_rcu(&smlp->list, &smack_rule_list);
+                        } else
+                                rc = -ENOMEM;
+                }
                 goto out;
         }
 
@@ -421,29 +509,18 @@ static void smk_seq_stop(struct seq_file *s, void *v)
         /* No-op */
 }
 
-/*
- * Seq_file read operations for /smack/load
- */
-
-static void *load_seq_start(struct seq_file *s, loff_t *pos)
-{
-        return smk_seq_start(s, pos, &smack_rule_list);
-}
-
-static void *load_seq_next(struct seq_file *s, void *v, loff_t *pos)
+static void smk_rule_show(struct seq_file *s, struct smack_rule *srp, int max)
 {
-        return smk_seq_next(s, v, pos, &smack_rule_list);
-}
-
-static int load_seq_show(struct seq_file *s, void *v)
-{
-        struct list_head *list = v;
-        struct smack_master_list *smlp =
-                 list_entry(list, struct smack_master_list, list);
-        struct smack_rule *srp = smlp->smk_rule;
+        /*
+         * Don't show any rules with label names too long for
+         * interface file (/smack/load or /smack/load2)
+         * because you should expect to be able to write
+         * anything you read back.
+         */
+        if (strlen(srp->smk_subject) >= max || strlen(srp->smk_object) >= max)
+                return;
 
-        seq_printf(s, "%s %s", (char *)srp->smk_subject,
-                   (char *)srp->smk_object);
+        seq_printf(s, "%s %s", srp->smk_subject, srp->smk_object);
 
         seq_putc(s, ' ');
 
@@ -461,13 +538,36 @@ static int load_seq_show(struct seq_file *s, void *v)
                 seq_putc(s, '-');
 
         seq_putc(s, '\n');
+}
+
+/*
+ * Seq_file read operations for /smack/load
+ */
+
+static void *load2_seq_start(struct seq_file *s, loff_t *pos)
+{
+        return smk_seq_start(s, pos, &smack_rule_list);
+}
+
+static void *load2_seq_next(struct seq_file *s, void *v, loff_t *pos)
+{
+        return smk_seq_next(s, v, pos, &smack_rule_list);
+}
+
+static int load_seq_show(struct seq_file *s, void *v)
+{
+        struct list_head *list = v;
+        struct smack_master_list *smlp =
+                 list_entry(list, struct smack_master_list, list);
+
+        smk_rule_show(s, smlp->smk_rule, SMK_LABELLEN);
 
         return 0;
 }
 
 static const struct seq_operations load_seq_ops = {
-        .start = load_seq_start,
-        .next  = load_seq_next,
+        .start = load2_seq_start,
+        .next  = load2_seq_next,
         .show  = load_seq_show,
         .stop  = smk_seq_stop,
 };
@@ -504,7 +604,8 @@ static ssize_t smk_write_load(struct file *file, const char __user *buf,
         if (!capable(CAP_MAC_ADMIN))
                 return -EPERM;
 
-        return smk_write_load_list(file, buf, count, ppos, NULL, NULL);
+        return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
+                                    SMK_FIXED24_FMT);
 }
 
 static const struct file_operations smk_load_ops = {
@@ -574,6 +675,8 @@ static void smk_unlbl_ambient(char *oldambient)
                         printk(KERN_WARNING "%s:%d remove rc = %d\n",
                                __func__, __LINE__, rc);
         }
+        if (smack_net_ambient == NULL)
+                smack_net_ambient = smack_known_floor.smk_known;
 
         rc = netlbl_cfg_unlbl_map_add(smack_net_ambient, PF_INET,
                                       NULL, NULL, &nai);
@@ -605,27 +708,28 @@ static int cipso_seq_show(struct seq_file *s, void *v)
         struct list_head  *list = v;
         struct smack_known *skp =
                  list_entry(list, struct smack_known, list);
-        struct smack_cipso *scp = skp->smk_cipso;
-        char *cbp;
+        struct netlbl_lsm_secattr_catmap *cmp = skp->smk_netlabel.attr.mls.cat;
         char sep = '/';
-        int cat = 1;
         int i;
-        unsigned char m;
 
-        if (scp == NULL)
+        /*
+         * Don't show a label that could not have been set using
+         * /smack/cipso. This is in support of the notion that
+         * anything read from /smack/cipso ought to be writeable
+         * to /smack/cipso.
+         *
+         * /smack/cipso2 should be used instead.
+         */
+        if (strlen(skp->smk_known) >= SMK_LABELLEN)
                 return 0;
 
-        seq_printf(s, "%s %3d", (char *)&skp->smk_known, scp->smk_level);
+        seq_printf(s, "%s %3d", skp->smk_known, skp->smk_netlabel.attr.mls.lvl);
 
-        cbp = scp->smk_catset;
-        for (i = 0; i < SMK_LABELLEN; i++)
-                for (m = 0x80; m != 0; m >>= 1) {
-                        if (m & cbp[i]) {
-                                seq_printf(s, "%c%d", sep, cat);
-                                sep = ',';
-                        }
-                        cat++;
-                }
+        for (i = netlbl_secattr_catmap_walk(cmp, 0); i >= 0;
+             i = netlbl_secattr_catmap_walk(cmp, i + 1)) {
+                seq_printf(s, "%c%d", sep, i);
+                sep = ',';
+        }
 
         seq_putc(s, '\n');
 
@@ -653,23 +757,24 @@ static int smk_open_cipso(struct inode *inode, struct file *file)
 }
 
 /**
- * smk_write_cipso - write() for /smack/cipso
+ * smk_set_cipso - do the work for write() for cipso and cipso2
  * @file: file pointer, not actually used
  * @buf: where to get the data from
  * @count: bytes sent
  * @ppos: where to start
+ * @format: /smack/cipso or /smack/cipso2
  *
  * Accepts only one cipso rule per write call.
  * Returns number of bytes written or error code, as appropriate
  */
-static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
-                               size_t count, loff_t *ppos)
+static ssize_t smk_set_cipso(struct file *file, const char __user *buf,
+                                size_t count, loff_t *ppos, int format)
 {
         struct smack_known *skp;
-        struct smack_cipso *scp = NULL;
-        char mapcatset[SMK_LABELLEN];
+        struct netlbl_lsm_secattr ncats;
+        char mapcatset[SMK_CIPSOLEN];
         int maplevel;
-        int cat;
+        unsigned int cat;
         int catlen;
         ssize_t rc = -EINVAL;
         char *data = NULL;
@@ -686,7 +791,8 @@ static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
                 return -EPERM;
         if (*ppos != 0)
                 return -EINVAL;
-        if (count < SMK_CIPSOMIN || count > SMK_CIPSOMAX)
+        if (format == SMK_FIXED24_FMT &&
+            (count < SMK_CIPSOMIN || count > SMK_CIPSOMAX))
                 return -EINVAL;
 
         data = kzalloc(count + 1, GFP_KERNEL);
@@ -698,11 +804,6 @@ static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
                 goto unlockedout;
         }
 
-        /* labels cannot begin with a '-' */
-        if (data[0] == '-') {
-                rc = -EINVAL;
-                goto unlockedout;
-        }
         data[count] = '\0';
         rule = data;
         /*
@@ -715,7 +816,11 @@ static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
         if (skp == NULL)
                 goto out;
 
-        rule += SMK_LABELLEN;
+        if (format == SMK_FIXED24_FMT)
+                rule += SMK_LABELLEN;
+        else
+                rule += strlen(skp->smk_known);
+
         ret = sscanf(rule, "%d", &maplevel);
         if (ret != 1 || maplevel > SMACK_CIPSO_MAXLEVEL)
                 goto out;
@@ -725,41 +830,29 @@ static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
         if (ret != 1 || catlen > SMACK_CIPSO_MAXCATNUM)
                 goto out;
 
-        if (count != (SMK_CIPSOMIN + catlen * SMK_DIGITLEN))
+        if (format == SMK_FIXED24_FMT &&
+            count != (SMK_CIPSOMIN + catlen * SMK_DIGITLEN))
                 goto out;
 
         memset(mapcatset, 0, sizeof(mapcatset));
 
         for (i = 0; i < catlen; i++) {
                 rule += SMK_DIGITLEN;
-                ret = sscanf(rule, "%d", &cat);
+                ret = sscanf(rule, "%u", &cat);
                 if (ret != 1 || cat > SMACK_CIPSO_MAXCATVAL)
                         goto out;
 
                 smack_catset_bit(cat, mapcatset);
         }
 
-        if (skp->smk_cipso == NULL) {
-                scp = kzalloc(sizeof(struct smack_cipso), GFP_KERNEL);
-                if (scp == NULL) {
-                        rc = -ENOMEM;
-                        goto out;
-                }
+        rc = smk_netlbl_mls(maplevel, mapcatset, &ncats, SMK_CIPSOLEN);
+        if (rc >= 0) {
+                netlbl_secattr_catmap_free(skp->smk_netlabel.attr.mls.cat);
+                skp->smk_netlabel.attr.mls.cat = ncats.attr.mls.cat;
+                skp->smk_netlabel.attr.mls.lvl = ncats.attr.mls.lvl;
+                rc = count;
         }
 
-        spin_lock_bh(&skp->smk_cipsolock);
-
-        if (scp == NULL)
-                scp = skp->smk_cipso;
-        else
-                skp->smk_cipso = scp;
-
-        scp->smk_level = maplevel;
-        memcpy(scp->smk_catset, mapcatset, sizeof(mapcatset));
-
-        spin_unlock_bh(&skp->smk_cipsolock);
-
-        rc = count;
 out:
         mutex_unlock(&smack_cipso_lock);
 unlockedout:
@@ -767,6 +860,22 @@ unlockedout:
         return rc;
 }
 
+/**
+ * smk_write_cipso - write() for /smack/cipso
+ * @file: file pointer, not actually used
+ * @buf: where to get the data from
+ * @count: bytes sent
+ * @ppos: where to start
+ *
+ * Accepts only one cipso rule per write call.
+ * Returns number of bytes written or error code, as appropriate
+ */
+static ssize_t smk_write_cipso(struct file *file, const char __user *buf,
+                               size_t count, loff_t *ppos)
+{
+        return smk_set_cipso(file, buf, count, ppos, SMK_FIXED24_FMT);
+}
+
 static const struct file_operations smk_cipso_ops = {
         .open           = smk_open_cipso,
         .read           = seq_read,
@@ -776,6 +885,80 @@ static const struct file_operations smk_cipso_ops = {
 };
 
 /*
+ * Seq_file read operations for /smack/cipso2
+ */
+
+/*
+ * Print cipso labels in format:
+ * label level[/cat[,cat]]
+ */
+static int cipso2_seq_show(struct seq_file *s, void *v)
+{
+        struct list_head  *list = v;
+        struct smack_known *skp =
+                 list_entry(list, struct smack_known, list);
+        struct netlbl_lsm_secattr_catmap *cmp = skp->smk_netlabel.attr.mls.cat;
+        char sep = '/';
+        int i;
+
+        seq_printf(s, "%s %3d", skp->smk_known, skp->smk_netlabel.attr.mls.lvl);
+
+        for (i = netlbl_secattr_catmap_walk(cmp, 0); i >= 0;
+             i = netlbl_secattr_catmap_walk(cmp, i + 1)) {
+                seq_printf(s, "%c%d", sep, i);
+                sep = ',';
+        }
+
+        seq_putc(s, '\n');
+
+        return 0;
+}
+
+static const struct seq_operations cipso2_seq_ops = {
+        .start = cipso_seq_start,
+        .next  = cipso_seq_next,
+        .show  = cipso2_seq_show,
+        .stop  = smk_seq_stop,
+};
+
+/**
+ * smk_open_cipso2 - open() for /smack/cipso2
+ * @inode: inode structure representing file
+ * @file: "cipso2" file pointer
+ *
+ * Connect our cipso_seq_* operations with /smack/cipso2
+ * file_operations
+ */
+static int smk_open_cipso2(struct inode *inode, struct file *file)
+{
+        return seq_open(file, &cipso2_seq_ops);
+}
+
+/**
+ * smk_write_cipso2 - write() for /smack/cipso2
+ * @file: file pointer, not actually used
+ * @buf: where to get the data from
+ * @count: bytes sent
+ * @ppos: where to start
+ *
+ * Accepts only one cipso rule per write call.
+ * Returns number of bytes written or error code, as appropriate
+ */
+static ssize_t smk_write_cipso2(struct file *file, const char __user *buf,
+                              size_t count, loff_t *ppos)
+{
+        return smk_set_cipso(file, buf, count, ppos, SMK_LONG_FMT);
+}
+
+static const struct file_operations smk_cipso2_ops = {
+        .open           = smk_open_cipso2,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .write          = smk_write_cipso2,
+        .release        = seq_release,
+};
+
+/*
  * Seq_file read operations for /smack/netlabel
  */
 
@@ -887,9 +1070,9 @@ static ssize_t smk_write_netlbladdr(struct file *file, const char __user *buf,
 {
         struct smk_netlbladdr *skp;
         struct sockaddr_in newname;
-        char smack[SMK_LABELLEN];
+        char *smack;
         char *sp;
-        char data[SMK_NETLBLADDRMAX + 1];
+        char *data;
         char *host = (char *)&newname.sin_addr.s_addr;
         int rc;
         struct netlbl_audit audit_info;
@@ -911,10 +1094,23 @@ static ssize_t smk_write_netlbladdr(struct file *file, const char __user *buf,
                 return -EPERM;
         if (*ppos != 0)
                 return -EINVAL;
-        if (count < SMK_NETLBLADDRMIN || count > SMK_NETLBLADDRMAX)
+        if (count < SMK_NETLBLADDRMIN)
                 return -EINVAL;
-        if (copy_from_user(data, buf, count) != 0)
-                return -EFAULT;
+
+        data = kzalloc(count + 1, GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
+
+        if (copy_from_user(data, buf, count) != 0) {
+                rc = -EFAULT;
+                goto free_data_out;
+        }
+
+        smack = kzalloc(count + 1, GFP_KERNEL);
+        if (smack == NULL) {
+                rc = -ENOMEM;
+                goto free_data_out;
+        }
 
         data[count] = '\0';
 
@@ -923,24 +1119,34 @@ static ssize_t smk_write_netlbladdr(struct file *file, const char __user *buf,
         if (rc != 6) {
                 rc = sscanf(data, "%hhd.%hhd.%hhd.%hhd %s",
                         &host[0], &host[1], &host[2], &host[3], smack);
-                if (rc != 5)
-                        return -EINVAL;
+                if (rc != 5) {
+                        rc = -EINVAL;
+                        goto free_out;
+                }
                 m = BEBITS;
         }
-        if (m > BEBITS)
-                return -EINVAL;
+        if (m > BEBITS) {
+                rc = -EINVAL;
+                goto free_out;
+        }
 
-        /* if smack begins with '-', its an option, don't import it */
+        /*
+         * If smack begins with '-', it is an option, don't import it
+         */
         if (smack[0] != '-') {
                 sp = smk_import(smack, 0);
-                if (sp == NULL)
-                        return -EINVAL;
+                if (sp == NULL) {
+                        rc = -EINVAL;
+                        goto free_out;
+                }
         } else {
                 /* check known options */
                 if (strcmp(smack, smack_cipso_option) == 0)
                         sp = (char *)smack_cipso_option;
-                else
-                        return -EINVAL;
+                else {
+                        rc = -EINVAL;
+                        goto free_out;
+                }
         }
 
         for (temp_mask = 0; m > 0; m--) {
@@ -1006,6 +1212,11 @@ static ssize_t smk_write_netlbladdr(struct file *file, const char __user *buf,
 
         mutex_unlock(&smk_netlbladdr_lock);
 
+free_out:
+        kfree(smack);
+free_data_out:
+        kfree(data);
+
         return rc;
 }
 
@@ -1119,6 +1330,7 @@ static ssize_t smk_read_direct(struct file *filp, char __user *buf,
 static ssize_t smk_write_direct(struct file *file, const char __user *buf,
                                 size_t count, loff_t *ppos)
 {
+        struct smack_known *skp;
         char temp[80];
         int i;
 
@@ -1136,7 +1348,20 @@ static ssize_t smk_write_direct(struct file *file, const char __user *buf,
         if (sscanf(temp, "%d", &i) != 1)
                 return -EINVAL;
 
-        smack_cipso_direct = i;
+        /*
+         * Don't do anything if the value hasn't actually changed.
+         * If it is changing reset the level on entries that were
+         * set up to be direct when they were created.
+         */
+        if (smack_cipso_direct != i) {
+                mutex_lock(&smack_known_lock);
+                list_for_each_entry_rcu(skp, &smack_known_list, list)
+                        if (skp->smk_netlabel.attr.mls.lvl ==
+                            smack_cipso_direct)
+                                skp->smk_netlabel.attr.mls.lvl = i;
+                smack_cipso_direct = i;
+                mutex_unlock(&smack_known_lock);
+        }
 
         return count;
 }
@@ -1148,6 +1373,84 @@ static const struct file_operations smk_direct_ops = {
 };
 
 /**
+ * smk_read_mapped - read() for /smack/mapped
+ * @filp: file pointer, not actually used
+ * @buf: where to put the result
+ * @count: maximum to send along
+ * @ppos: where to start
+ *
+ * Returns number of bytes read or error code, as appropriate
+ */
+static ssize_t smk_read_mapped(struct file *filp, char __user *buf,
+                               size_t count, loff_t *ppos)
+{
+        char temp[80];
+        ssize_t rc;
+
+        if (*ppos != 0)
+                return 0;
+
+        sprintf(temp, "%d", smack_cipso_mapped);
+        rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
+
+        return rc;
+}
+
+/**
+ * smk_write_mapped - write() for /smack/mapped
+ * @file: file pointer, not actually used
+ * @buf: where to get the data from
+ * @count: bytes sent
+ * @ppos: where to start
+ *
+ * Returns number of bytes written or error code, as appropriate
+ */
+static ssize_t smk_write_mapped(struct file *file, const char __user *buf,
+                                size_t count, loff_t *ppos)
+{
+        struct smack_known *skp;
+        char temp[80];
+        int i;
+
+        if (!capable(CAP_MAC_ADMIN))
+                return -EPERM;
+
+        if (count >= sizeof(temp) || count == 0)
+                return -EINVAL;
+
+        if (copy_from_user(temp, buf, count) != 0)
+                return -EFAULT;
+
+        temp[count] = '\0';
+
+        if (sscanf(temp, "%d", &i) != 1)
+                return -EINVAL;
+
+        /*
+         * Don't do anything if the value hasn't actually changed.
+         * If it is changing reset the level on entries that were
+         * set up to be mapped when they were created.
+         */
+        if (smack_cipso_mapped != i) {
+                mutex_lock(&smack_known_lock);
+                list_for_each_entry_rcu(skp, &smack_known_list, list)
+                        if (skp->smk_netlabel.attr.mls.lvl ==
+                            smack_cipso_mapped)
+                                skp->smk_netlabel.attr.mls.lvl = i;
+                smack_cipso_mapped = i;
+                mutex_unlock(&smack_known_lock);
+        }
+
+        return count;
+}
+
+static const struct file_operations smk_mapped_ops = {
+        .read           = smk_read_mapped,
+        .write          = smk_write_mapped,
+        .llseek         = default_llseek,
+};
+
+/**
  * smk_read_ambient - read() for /smack/ambient
  * @filp: file pointer, not actually used
  * @buf: where to put the result
@@ -1195,22 +1498,28 @@ static ssize_t smk_read_ambient(struct file *filp, char __user *buf,
 static ssize_t smk_write_ambient(struct file *file, const char __user *buf,
                                  size_t count, loff_t *ppos)
 {
-        char in[SMK_LABELLEN];
         char *oldambient;
-        char *smack;
+        char *smack = NULL;
+        char *data;
+        int rc = count;
 
         if (!capable(CAP_MAC_ADMIN))
                 return -EPERM;
 
-        if (count >= SMK_LABELLEN)
-                return -EINVAL;
+        data = kzalloc(count + 1, GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
 
-        if (copy_from_user(in, buf, count) != 0)
-                return -EFAULT;
+        if (copy_from_user(data, buf, count) != 0) {
+                rc = -EFAULT;
+                goto out;
+        }
 
-        smack = smk_import(in, count);
-        if (smack == NULL)
-                return -EINVAL;
+        smack = smk_import(data, count);
+        if (smack == NULL) {
+                rc = -EINVAL;
+                goto out;
+        }
 
         mutex_lock(&smack_ambient_lock);
 
@@ -1220,7 +1529,9 @@ static ssize_t smk_write_ambient(struct file *file, const char __user *buf,
 
         mutex_unlock(&smack_ambient_lock);
 
-        return count;
+out:
+        kfree(data);
+        return rc;
 }
 
 static const struct file_operations smk_ambient_ops = {
@@ -1271,8 +1582,9 @@ static ssize_t smk_read_onlycap(struct file *filp, char __user *buf,
 static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
                                  size_t count, loff_t *ppos)
 {
-        char in[SMK_LABELLEN];
+        char *data;
         char *sp = smk_of_task(current->cred->security);
+        int rc = count;
 
         if (!capable(CAP_MAC_ADMIN))
                 return -EPERM;
@@ -1285,11 +1597,9 @@ static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
         if (smack_onlycap != NULL && smack_onlycap != sp)
                 return -EPERM;
 
-        if (count >= SMK_LABELLEN)
-                return -EINVAL;
-
-        if (copy_from_user(in, buf, count) != 0)
-                return -EFAULT;
+        data = kzalloc(count, GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
 
         /*
          * Should the null string be passed in unset the onlycap value.
@@ -1297,10 +1607,17 @@ static ssize_t smk_write_onlycap(struct file *file, const char __user *buf,
          * smk_import only expects to return NULL for errors. It
          * is usually the case that a nullstring or "\n" would be
          * bad to pass to smk_import but in fact this is useful here.
+         *
+         * smk_import will also reject a label beginning with '-',
+         * so "-usecapabilities" will also work.
          */
-        smack_onlycap = smk_import(in, count);
+        if (copy_from_user(data, buf, count) != 0)
+                rc = -EFAULT;
+        else
+                smack_onlycap = smk_import(data, count);
 
-        return count;
+        kfree(data);
+        return rc;
 }
 
 static const struct file_operations smk_onlycap_ops = {
@@ -1398,25 +1715,7 @@ static int load_self_seq_show(struct seq_file *s, void *v)
         struct smack_rule *srp =
                  list_entry(list, struct smack_rule, list);
 
-        seq_printf(s, "%s %s", (char *)srp->smk_subject,
-                   (char *)srp->smk_object);
-
-        seq_putc(s, ' ');
-
-        if (srp->smk_access & MAY_READ)
-                seq_putc(s, 'r');
-        if (srp->smk_access & MAY_WRITE)
-                seq_putc(s, 'w');
-        if (srp->smk_access & MAY_EXEC)
-                seq_putc(s, 'x');
-        if (srp->smk_access & MAY_APPEND)
-                seq_putc(s, 'a');
-        if (srp->smk_access & MAY_TRANSMUTE)
-                seq_putc(s, 't');
-        if (srp->smk_access == 0)
-                seq_putc(s, '-');
-
-        seq_putc(s, '\n');
+        smk_rule_show(s, srp, SMK_LABELLEN);
 
         return 0;
 }
@@ -1430,7 +1729,7 @@ static const struct seq_operations load_self_seq_ops = {
 
 
 /**
- * smk_open_load_self - open() for /smack/load-self
+ * smk_open_load_self - open() for /smack/load-self2
  * @inode: inode structure representing file
  * @file: "load" file pointer
  *
@@ -1454,8 +1753,8 @@ static ssize_t smk_write_load_self(struct file *file, const char __user *buf,
 {
         struct task_smack *tsp = current_security();
 
-        return smk_write_load_list(file, buf, count, ppos, &tsp->smk_rules,
-                                        &tsp->smk_rules_lock);
+        return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
+                                    &tsp->smk_rules_lock, SMK_FIXED24_FMT);
 }
 
 static const struct file_operations smk_load_self_ops = {
@@ -1467,24 +1766,42 @@ static const struct file_operations smk_load_self_ops = {
 };
 
 /**
- * smk_write_access - handle access check transaction
+ * smk_user_access - handle access check transaction
  * @file: file pointer
  * @buf: data from user space
  * @count: bytes sent
  * @ppos: where to start - must be 0
  */
-static ssize_t smk_write_access(struct file *file, const char __user *buf,
-                                size_t count, loff_t *ppos)
+static ssize_t smk_user_access(struct file *file, const char __user *buf,
+                                size_t count, loff_t *ppos, int format)
 {
         struct smack_rule rule;
         char *data;
+        char *cod;
         int res;
 
         data = simple_transaction_get(file, buf, count);
         if (IS_ERR(data))
                 return PTR_ERR(data);
 
-        if (count < SMK_LOADLEN || smk_parse_rule(data, &rule, 0))
+        if (format == SMK_FIXED24_FMT) {
+                if (count < SMK_LOADLEN)
+                        return -EINVAL;
+                res = smk_parse_rule(data, &rule, 0);
+        } else {
+                /*
+                 * Copy the data to make sure the string is terminated.
+                 */
+                cod = kzalloc(count + 1, GFP_KERNEL);
+                if (cod == NULL)
+                        return -ENOMEM;
+                memcpy(cod, data, count);
+                cod[count] = '\0';
+                res = smk_parse_long_rule(cod, &rule, 0);
+                kfree(cod);
+        }
+
+        if (res)
                 return -EINVAL;
 
         res = smk_access(rule.smk_subject, rule.smk_object, rule.smk_access,
@@ -1493,7 +1810,23 @@ static ssize_t smk_write_access(struct file *file, const char __user *buf,
         data[1] = '\0';
 
         simple_transaction_set(file, 2);
-        return SMK_LOADLEN;
+
+        if (format == SMK_FIXED24_FMT)
+                return SMK_LOADLEN;
+        return count;
+}
+
+/**
+ * smk_write_access - handle access check transaction
+ * @file: file pointer
+ * @buf: data from user space
+ * @count: bytes sent
+ * @ppos: where to start - must be 0
+ */
+static ssize_t smk_write_access(struct file *file, const char __user *buf,
+                                size_t count, loff_t *ppos)
+{
+        return smk_user_access(file, buf, count, ppos, SMK_FIXED24_FMT);
 }
 
 static const struct file_operations smk_access_ops = {
@@ -1503,6 +1836,163 @@ static const struct file_operations smk_access_ops = {
         .llseek         = generic_file_llseek,
 };
 
+
+/*
+ * Seq_file read operations for /smack/load2
+ */
+
+static int load2_seq_show(struct seq_file *s, void *v)
+{
+        struct list_head *list = v;
+        struct smack_master_list *smlp =
+                 list_entry(list, struct smack_master_list, list);
+
+        smk_rule_show(s, smlp->smk_rule, SMK_LONGLABEL);
+
+        return 0;
+}
+
+static const struct seq_operations load2_seq_ops = {
+        .start = load2_seq_start,
+        .next  = load2_seq_next,
+        .show  = load2_seq_show,
+        .stop  = smk_seq_stop,
+};
+
+/**
+ * smk_open_load2 - open() for /smack/load2
+ * @inode: inode structure representing file
+ * @file: "load2" file pointer
+ *
+ * For reading, use load2_seq_* seq_file reading operations.
+ */
+static int smk_open_load2(struct inode *inode, struct file *file)
+{
+        return seq_open(file, &load2_seq_ops);
+}
+
+/**
+ * smk_write_load2 - write() for /smack/load2
+ * @file: file pointer, not actually used
+ * @buf: where to get the data from
+ * @count: bytes sent
+ * @ppos: where to start - must be 0
+ *
+ */
+static ssize_t smk_write_load2(struct file *file, const char __user *buf,
+                                size_t count, loff_t *ppos)
+{
+        /*
+         * Must have privilege.
+         */
+        if (!capable(CAP_MAC_ADMIN))
+                return -EPERM;
+
+        return smk_write_rules_list(file, buf, count, ppos, NULL, NULL,
+                                    SMK_LONG_FMT);
+}
+
+static const struct file_operations smk_load2_ops = {
+        .open           = smk_open_load2,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .write          = smk_write_load2,
+        .release        = seq_release,
+};
+
+/*
+ * Seq_file read operations for /smack/load-self2
+ */
+
+static void *load_self2_seq_start(struct seq_file *s, loff_t *pos)
+{
+        struct task_smack *tsp = current_security();
+
+        return smk_seq_start(s, pos, &tsp->smk_rules);
+}
+
+static void *load_self2_seq_next(struct seq_file *s, void *v, loff_t *pos)
+{
+        struct task_smack *tsp = current_security();
+
+        return smk_seq_next(s, v, pos, &tsp->smk_rules);
+}
+
+static int load_self2_seq_show(struct seq_file *s, void *v)
+{
+        struct list_head *list = v;
+        struct smack_rule *srp =
+                 list_entry(list, struct smack_rule, list);
+
+        smk_rule_show(s, srp, SMK_LONGLABEL);
+
+        return 0;
+}
+
+static const struct seq_operations load_self2_seq_ops = {
+        .start = load_self2_seq_start,
+        .next  = load_self2_seq_next,
+        .show  = load_self2_seq_show,
+        .stop  = smk_seq_stop,
+};
+
+/**
+ * smk_open_load_self2 - open() for /smack/load-self2
+ * @inode: inode structure representing file
+ * @file: "load" file pointer
+ *
+ * For reading, use load_seq_* seq_file reading operations.
+ */
+static int smk_open_load_self2(struct inode *inode, struct file *file)
+{
+        return seq_open(file, &load_self2_seq_ops);
+}
+
+/**
+ * smk_write_load_self2 - write() for /smack/load-self2
+ * @file: file pointer, not actually used
+ * @buf: where to get the data from
+ * @count: bytes sent
+ * @ppos: where to start - must be 0
+ *
+ */
+static ssize_t smk_write_load_self2(struct file *file, const char __user *buf,
+                              size_t count, loff_t *ppos)
+{
+        struct task_smack *tsp = current_security();
+
+        return smk_write_rules_list(file, buf, count, ppos, &tsp->smk_rules,
+                                    &tsp->smk_rules_lock, SMK_LONG_FMT);
+}
+
+static const struct file_operations smk_load_self2_ops = {
+        .open           = smk_open_load_self2,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .write          = smk_write_load_self2,
+        .release        = seq_release,
+};
+
+/**
+ * smk_write_access2 - handle access check transaction
+ * @file: file pointer
+ * @buf: data from user space
+ * @count: bytes sent
+ * @ppos: where to start - must be 0
+ */
+static ssize_t smk_write_access2(struct file *file, const char __user *buf,
+                                        size_t count, loff_t *ppos)
+{
+        return smk_user_access(file, buf, count, ppos, SMK_LONG_FMT);
+}
+
+static const struct file_operations smk_access2_ops = {
+        .write          = smk_write_access2,
+        .read           = simple_transaction_read,
+        .release        = simple_transaction_release,
+        .llseek         = generic_file_llseek,
+};
+
 /**
  * smk_fill_super - fill the /smackfs superblock
  * @sb: the empty superblock
@@ -1539,6 +2029,16 @@ static int smk_fill_super(struct super_block *sb, void *data, int silent)
                         "load-self", &smk_load_self_ops, S_IRUGO|S_IWUGO},
                 [SMK_ACCESSES] = {
                         "access", &smk_access_ops, S_IRUGO|S_IWUGO},
+                [SMK_MAPPED] = {
+                        "mapped", &smk_mapped_ops, S_IRUGO|S_IWUSR},
+                [SMK_LOAD2] = {
+                        "load2", &smk_load2_ops, S_IRUGO|S_IWUSR},
+                [SMK_LOAD_SELF2] = {
+                        "load-self2", &smk_load_self2_ops, S_IRUGO|S_IWUGO},
+                [SMK_ACCESS2] = {
+                        "access2", &smk_access2_ops, S_IRUGO|S_IWUGO},
+                [SMK_CIPSO2] = {
+                        "cipso2", &smk_cipso2_ops, S_IRUGO|S_IWUSR},
                 /* last one */
                         {""}
         };
@@ -1581,6 +2081,15 @@ static struct file_system_type smk_fs_type = {
 
 static struct vfsmount *smackfs_mount;
 
+static int __init smk_preset_netlabel(struct smack_known *skp)
+{
+        skp->smk_netlabel.domain = skp->smk_known;
+        skp->smk_netlabel.flags =
+                NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
+        return smk_netlbl_mls(smack_cipso_direct, skp->smk_known,
+                                &skp->smk_netlabel, strlen(skp->smk_known));
+}
+
 /**
  * init_smk_fs - get the smackfs superblock
  *
@@ -1597,6 +2106,7 @@ static struct vfsmount *smackfs_mount;
 static int __init init_smk_fs(void)
 {
         int err;
+        int rc;
 
         if (!security_module_enable(&smack_ops))
                 return 0;
@@ -1614,6 +2124,25 @@ static int __init init_smk_fs(void)
         smk_cipso_doi();
         smk_unlbl_ambient(NULL);
 
+        rc = smk_preset_netlabel(&smack_known_floor);
+        if (err == 0 && rc < 0)
+                err = rc;
+        rc = smk_preset_netlabel(&smack_known_hat);
+        if (err == 0 && rc < 0)
+                err = rc;
+        rc = smk_preset_netlabel(&smack_known_huh);
+        if (err == 0 && rc < 0)
+                err = rc;
+        rc = smk_preset_netlabel(&smack_known_invalid);
+        if (err == 0 && rc < 0)
+                err = rc;
+        rc = smk_preset_netlabel(&smack_known_star);
+        if (err == 0 && rc < 0)
+                err = rc;
+        rc = smk_preset_netlabel(&smack_known_web);
+        if (err == 0 && rc < 0)
+                err = rc;
+
         return err;
 }