Security: add get, set, and cloning of superblock security information

Adds security_get_sb_mnt_opts, security_set_sb_mnt_opts, and
security_clont_sb_mnt_opts to the LSM and to SELinux.  This will allow
filesystems to directly own and control all of their mount options if they
so choose.  This interface deals only with option identifiers and strings so
it should generic enough for any LSM which may come in the future.

Filesystems which pass text mount data around in the kernel (almost all of
them) need not currently make use of this interface when dealing with
SELinux since it will still parse those strings as it always has.  I assume
future LSM's would do the same.  NFS is the primary FS which does not use
text mount data and thus must make use of this interface.

An LSM would need to implement these functions only if they had mount time
options, such as selinux has context= or fscontext=.  If the LSM has no
mount time options they could simply not implement and let the dummy ops
take care of things.

An LSM other than SELinux would need to define new option numbers in
security.h and any FS which decides to own there own security options would
need to be patched to use this new interface for every possible LSM.  This
is because it was stated to me very clearly that LSM's should not attempt to
understand FS mount data and the burdon to understand security should be in
the FS which owns the options.

Signed-off-by: Eric Paris <eparis@redhat.com>
Acked-by: Stephen D. Smalley <sds@tycho.nsa.gov>
Signed-off-by: James Morris <jmorris@namei.org>

4 files changed, 541 insertions, 254 deletions

diff --git a/security/dummy.c b/security/dummy.c
index 3ccfbbe973b6..a3b29d0d00e5 100644
--- a/security/dummy.c
+++ b/security/dummy.c
@@ -245,6 +245,29 @@ static void dummy_sb_post_pivotroot (struct nameidata *old_nd, struct nameidata
         return;
 }
 
+static int dummy_sb_get_mnt_opts(const struct super_block *sb, char ***mount_options,
+                                 int **flags, int *num_opts)
+{
+        *mount_options = NULL;
+        *flags = NULL;
+        *num_opts = 0;
+        return 0;
+}
+
+static int dummy_sb_set_mnt_opts(struct super_block *sb, char **mount_options,
+                                 int *flags, int num_opts)
+{
+        if (unlikely(num_opts))
+                return -EOPNOTSUPP;
+        return 0;
+}
+
+static void dummy_sb_clone_mnt_opts(const struct super_block *oldsb,
+                                    struct super_block *newsb)
+{
+        return;
+}
+
 static int dummy_inode_alloc_security (struct inode *inode)
 {
         return 0;
@@ -998,6 +1021,9 @@ void security_fixup_ops (struct security_operations *ops)
         set_to_dummy_if_null(ops, sb_post_addmount);
         set_to_dummy_if_null(ops, sb_pivotroot);
         set_to_dummy_if_null(ops, sb_post_pivotroot);
+        set_to_dummy_if_null(ops, sb_get_mnt_opts);
+        set_to_dummy_if_null(ops, sb_set_mnt_opts);
+        set_to_dummy_if_null(ops, sb_clone_mnt_opts);
         set_to_dummy_if_null(ops, inode_alloc_security);
         set_to_dummy_if_null(ops, inode_free_security);
         set_to_dummy_if_null(ops, inode_init_security);
diff --git a/security/security.c b/security/security.c
index 0e1f1f124368..b13b54f0af85 100644
--- a/security/security.c
+++ b/security/security.c
@@ -308,6 +308,26 @@ void security_sb_post_pivotroot(struct nameidata *old_nd, struct nameidata *new_
         security_ops->sb_post_pivotroot(old_nd, new_nd);
 }
 
+int security_sb_get_mnt_opts(const struct super_block *sb,
+                              char ***mount_options,
+                              int **flags, int *num_opts)
+{
+        return security_ops->sb_get_mnt_opts(sb, mount_options, flags, num_opts);
+}
+
+int security_sb_set_mnt_opts(struct super_block *sb,
+                              char **mount_options,
+                              int *flags, int num_opts)
+{
+        return security_ops->sb_set_mnt_opts(sb, mount_options, flags, num_opts);
+}
+
+void security_sb_clone_mnt_opts(const struct super_block *oldsb,
+                                struct super_block *newsb)
+{
+        security_ops->sb_clone_mnt_opts(oldsb, newsb);
+}
+
 int security_inode_alloc(struct inode *inode)
 {
         inode->i_security = NULL;
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 9f3124b08867..233c8b97462f 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -82,6 +82,8 @@
 #define XATTR_SELINUX_SUFFIX "selinux"
 #define XATTR_NAME_SELINUX XATTR_SECURITY_PREFIX XATTR_SELINUX_SUFFIX
 
+#define NUM_SEL_MNT_OPTS 4
+
 extern unsigned int policydb_loaded_version;
 extern int selinux_nlmsg_lookup(u16 sclass, u16 nlmsg_type, u32 *perm);
 extern int selinux_compat_net;
@@ -321,8 +323,8 @@ enum {
         Opt_error = -1,
         Opt_context = 1,
         Opt_fscontext = 2,
-        Opt_defcontext = 4,
-        Opt_rootcontext = 8,
+        Opt_defcontext = 3,
+        Opt_rootcontext = 4,
 };
 
 static match_table_t tokens = {
@@ -366,150 +368,317 @@ static int may_context_mount_inode_relabel(u32 sid,
         return rc;
 }
 
-static int try_context_mount(struct super_block *sb, void *data)
+static int sb_finish_set_opts(struct super_block *sb)
 {
-        char *context = NULL, *defcontext = NULL;
-        char *fscontext = NULL, *rootcontext = NULL;
-        const char *name;
-        u32 sid;
-        int alloc = 0, rc = 0, seen = 0;
-        struct task_security_struct *tsec = current->security;
         struct superblock_security_struct *sbsec = sb->s_security;
+        struct dentry *root = sb->s_root;
+        struct inode *root_inode = root->d_inode;
+        int rc = 0;
 
-        if (!data)
-                goto out;
+        if (sbsec->behavior == SECURITY_FS_USE_XATTR) {
+                /* Make sure that the xattr handler exists and that no
+                   error other than -ENODATA is returned by getxattr on
+                   the root directory.  -ENODATA is ok, as this may be
+                   the first boot of the SELinux kernel before we have
+                   assigned xattr values to the filesystem. */
+                if (!root_inode->i_op->getxattr) {
+                        printk(KERN_WARNING "SELinux: (dev %s, type %s) has no "
+                               "xattr support\n", sb->s_id, sb->s_type->name);
+                        rc = -EOPNOTSUPP;
+                        goto out;
+                }
+                rc = root_inode->i_op->getxattr(root, XATTR_NAME_SELINUX, NULL, 0);
+                if (rc < 0 && rc != -ENODATA) {
+                        if (rc == -EOPNOTSUPP)
+                                printk(KERN_WARNING "SELinux: (dev %s, type "
+                                       "%s) has no security xattr handler\n",
+                                       sb->s_id, sb->s_type->name);
+                        else
+                                printk(KERN_WARNING "SELinux: (dev %s, type "
+                                       "%s) getxattr errno %d\n", sb->s_id,
+                                       sb->s_type->name, -rc);
+                        goto out;
+                }
+        }
 
-        name = sb->s_type->name;
+        sbsec->initialized = 1;
 
-        if (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA) {
+        if (sbsec->behavior > ARRAY_SIZE(labeling_behaviors))
+                printk(KERN_ERR "SELinux: initialized (dev %s, type %s), unknown behavior\n",
+                       sb->s_id, sb->s_type->name);
+        else
+                printk(KERN_DEBUG "SELinux: initialized (dev %s, type %s), %s\n",
+                       sb->s_id, sb->s_type->name,
+                       labeling_behaviors[sbsec->behavior-1]);
 
-                /* NFS we understand. */
-                if (!strcmp(name, "nfs")) {
-                        struct nfs_mount_data *d = data;
+        /* Initialize the root inode. */
+        rc = inode_doinit_with_dentry(root_inode, root);
 
-                        if (d->version <  NFS_MOUNT_VERSION)
-                                goto out;
+        /* Initialize any other inodes associated with the superblock, e.g.
+           inodes created prior to initial policy load or inodes created
+           during get_sb by a pseudo filesystem that directly
+           populates itself. */
+        spin_lock(&sbsec->isec_lock);
+next_inode:
+        if (!list_empty(&sbsec->isec_head)) {
+                struct inode_security_struct *isec =
+                                list_entry(sbsec->isec_head.next,
+                                           struct inode_security_struct, list);
+                struct inode *inode = isec->inode;
+                spin_unlock(&sbsec->isec_lock);
+                inode = igrab(inode);
+                if (inode) {
+                        if (!IS_PRIVATE(inode))
+                                inode_doinit(inode);
+                        iput(inode);
+                }
+                spin_lock(&sbsec->isec_lock);
+                list_del_init(&isec->list);
+                goto next_inode;
+        }
+        spin_unlock(&sbsec->isec_lock);
+out:
+        return rc;
+}
 
-                        if (d->context[0]) {
-                                context = d->context;
-                                seen |= Opt_context;
-                        }
-                } else
-                        goto out;
+/*
+ * This function should allow an FS to ask what it's mount security
+ * options were so it can use those later for submounts, displaying
+ * mount options, or whatever.
+ */
+static int selinux_get_mnt_opts(const struct super_block *sb,
+                                char ***mount_options, int **mnt_opts_flags,
+                                int *num_opts)
+{
+        int rc = 0, i;
+        struct superblock_security_struct *sbsec = sb->s_security;
+        char *context = NULL;
+        u32 len;
+        char tmp;
 
-        } else {
-                /* Standard string-based options. */
-                char *p, *options = data;
+        *num_opts = 0;
+        *mount_options = NULL;
+        *mnt_opts_flags = NULL;
 
-                while ((p = strsep(&options, "|")) != NULL) {
-                        int token;
-                        substring_t args[MAX_OPT_ARGS];
+        if (!sbsec->initialized)
+                return -EINVAL;
 
-                        if (!*p)
-                                continue;
+        if (!ss_initialized)
+                return -EINVAL;
 
-                        token = match_token(p, tokens, args);
+        /*
+         * if we ever use sbsec flags for anything other than tracking mount
+         * settings this is going to need a mask
+         */
+        tmp = sbsec->flags;
+        /* count the number of mount options for this sb */
+        for (i = 0; i < 8; i++) {
+                if (tmp & 0x01)
+                        (*num_opts)++;
+                tmp >>= 1;
+        }
 
-                        switch (token) {
-                        case Opt_context:
-                                if (seen & (Opt_context|Opt_defcontext)) {
-                                        rc = -EINVAL;
-                                        printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
-                                        goto out_free;
-                                }
-                                context = match_strdup(&args[0]);
-                                if (!context) {
-                                        rc = -ENOMEM;
-                                        goto out_free;
-                                }
-                                if (!alloc)
-                                        alloc = 1;
-                                seen |= Opt_context;
-                                break;
+        *mount_options = kcalloc(*num_opts, sizeof(char *), GFP_ATOMIC);
+        if (!*mount_options) {
+                rc = -ENOMEM;
+                goto out_free;
+        }
 
-                        case Opt_fscontext:
-                                if (seen & Opt_fscontext) {
-                                        rc = -EINVAL;
-                                        printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
-                                        goto out_free;
-                                }
-                                fscontext = match_strdup(&args[0]);
-                                if (!fscontext) {
-                                        rc = -ENOMEM;
-                                        goto out_free;
-                                }
-                                if (!alloc)
-                                        alloc = 1;
-                                seen |= Opt_fscontext;
-                                break;
+        *mnt_opts_flags = kcalloc(*num_opts, sizeof(int), GFP_ATOMIC);
+        if (!*mnt_opts_flags) {
+                rc = -ENOMEM;
+                goto out_free;
+        }
 
-                        case Opt_rootcontext:
-                                if (seen & Opt_rootcontext) {
-                                        rc = -EINVAL;
-                                        printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
-                                        goto out_free;
-                                }
-                                rootcontext = match_strdup(&args[0]);
-                                if (!rootcontext) {
-                                        rc = -ENOMEM;
-                                        goto out_free;
-                                }
-                                if (!alloc)
-                                        alloc = 1;
-                                seen |= Opt_rootcontext;
-                                break;
+        i = 0;
+        if (sbsec->flags & FSCONTEXT_MNT) {
+                rc = security_sid_to_context(sbsec->sid, &context, &len);
+                if (rc)
+                        goto out_free;
+                (*mount_options)[i] = context;
+                (*mnt_opts_flags)[i++] = FSCONTEXT_MNT;
+        }
+        if (sbsec->flags & CONTEXT_MNT) {
+                rc = security_sid_to_context(sbsec->mntpoint_sid, &context, &len);
+                if (rc)
+                        goto out_free;
+                (*mount_options)[i] = context;
+                (*mnt_opts_flags)[i++] = CONTEXT_MNT;
+        }
+        if (sbsec->flags & DEFCONTEXT_MNT) {
+                rc = security_sid_to_context(sbsec->def_sid, &context, &len);
+                if (rc)
+                        goto out_free;
+                (*mount_options)[i] = context;
+                (*mnt_opts_flags)[i++] = DEFCONTEXT_MNT;
+        }
+        if (sbsec->flags & ROOTCONTEXT_MNT) {
+                struct inode *root = sbsec->sb->s_root->d_inode;
+                struct inode_security_struct *isec = root->i_security;
 
-                        case Opt_defcontext:
-                                if (sbsec->behavior != SECURITY_FS_USE_XATTR) {
-                                        rc = -EINVAL;
-                                        printk(KERN_WARNING "SELinux:  "
-                                               "defcontext option is invalid "
-                                               "for this filesystem type\n");
-                                        goto out_free;
-                                }
-                                if (seen & (Opt_context|Opt_defcontext)) {
-                                        rc = -EINVAL;
-                                        printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
-                                        goto out_free;
-                                }
-                                defcontext = match_strdup(&args[0]);
-                                if (!defcontext) {
-                                        rc = -ENOMEM;
-                                        goto out_free;
-                                }
-                                if (!alloc)
-                                        alloc = 1;
-                                seen |= Opt_defcontext;
-                                break;
+                rc = security_sid_to_context(isec->sid, &context, &len);
+                if (rc)
+                        goto out_free;
+                (*mount_options)[i] = context;
+                (*mnt_opts_flags)[i++] = ROOTCONTEXT_MNT;
+        }
 
-                        default:
-                                rc = -EINVAL;
-                                printk(KERN_WARNING "SELinux:  unknown mount "
-                                       "option\n");
-                                goto out_free;
+        BUG_ON(i != *num_opts);
 
-                        }
-                }
-        }
+        return 0;
+
+out_free:
+        /* don't leak context string if security_sid_to_context had an error */
+        if (*mount_options && i)
+                for (; i > 0; i--)
+                        kfree((*mount_options)[i-1]);
+        kfree(*mount_options);
+        *mount_options = NULL;
+        kfree(*mnt_opts_flags);
+        *mnt_opts_flags = NULL;
+        *num_opts = 0;
+        return rc;
+}
+
+static int bad_option(struct superblock_security_struct *sbsec, char flag,
+                      u32 old_sid, u32 new_sid)
+{
+        /* check if the old mount command had the same options */
+        if (sbsec->initialized)
+                if (!(sbsec->flags & flag) ||
+                    (old_sid != new_sid))
+                        return 1;
+
+        /* check if we were passed the same options twice,
+         * aka someone passed context=a,context=b
+         */
+        if (!sbsec->initialized)
+                if (sbsec->flags & flag)
+                        return 1;
+        return 0;
+}
+/*
+ * Allow filesystems with binary mount data to explicitly set mount point
+ * labeling information.
+ */
+int selinux_set_mnt_opts(struct super_block *sb, char **mount_options,
+                                 int *flags, int num_opts)
+{
+        int rc = 0, i;
+        struct task_security_struct *tsec = current->security;
+        struct superblock_security_struct *sbsec = sb->s_security;
+        const char *name = sb->s_type->name;
+        struct inode *inode = sbsec->sb->s_root->d_inode;
+        struct inode_security_struct *root_isec = inode->i_security;
+        u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0;
+        u32 defcontext_sid = 0;
 
-        if (!seen)
+        mutex_lock(&sbsec->lock);
+
+        if (!ss_initialized) {
+                if (!num_opts) {
+                        /* Defer initialization until selinux_complete_init,
+                           after the initial policy is loaded and the security
+                           server is ready to handle calls. */
+                        spin_lock(&sb_security_lock);
+                        if (list_empty(&sbsec->list))
+                                list_add(&sbsec->list, &superblock_security_head);
+                        spin_unlock(&sb_security_lock);
+                        goto out;
+                }
+                rc = -EINVAL;
+                printk(KERN_WARNING "Unable to set superblock options before "
+                       "the security server is initialized\n");
                 goto out;
+        }
 
-        /* sets the context of the superblock for the fs being mounted. */
-        if (fscontext) {
-                rc = security_context_to_sid(fscontext, strlen(fscontext), &sid);
+        /*
+         * parse the mount options, check if they are valid sids.
+         * also check if someone is trying to mount the same sb more
+         * than once with different security options.
+         */
+        for (i = 0; i < num_opts; i++) {
+                u32 sid;
+                rc = security_context_to_sid(mount_options[i],
+                                             strlen(mount_options[i]), &sid);
                 if (rc) {
                         printk(KERN_WARNING "SELinux: security_context_to_sid"
                                "(%s) failed for (dev %s, type %s) errno=%d\n",
-                               fscontext, sb->s_id, name, rc);
-                        goto out_free;
+                               mount_options[i], sb->s_id, name, rc);
+                        goto out;
+                }
+                switch (flags[i]) {
+                case FSCONTEXT_MNT:
+                        fscontext_sid = sid;
+
+                        if (bad_option(sbsec, FSCONTEXT_MNT, sbsec->sid,
+                                        fscontext_sid))
+                                goto out_double_mount;
+
+                        sbsec->flags |= FSCONTEXT_MNT;
+                        break;
+                case CONTEXT_MNT:
+                        context_sid = sid;
+
+                        if (bad_option(sbsec, CONTEXT_MNT, sbsec->mntpoint_sid,
+                                        context_sid))
+                                goto out_double_mount;
+
+                        sbsec->flags |= CONTEXT_MNT;
+                        break;
+                case ROOTCONTEXT_MNT:
+                        rootcontext_sid = sid;
+
+                        if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid,
+                                        rootcontext_sid))
+                                goto out_double_mount;
+
+                        sbsec->flags |= ROOTCONTEXT_MNT;
+
+                        break;
+                case DEFCONTEXT_MNT:
+                        defcontext_sid = sid;
+
+                        if (bad_option(sbsec, DEFCONTEXT_MNT, sbsec->def_sid,
+                                        defcontext_sid))
+                                goto out_double_mount;
+
+                        sbsec->flags |= DEFCONTEXT_MNT;
+
+                        break;
+                default:
+                        rc = -EINVAL;
+                        goto out;
                 }
+        }
+
+        if (sbsec->initialized) {
+                /* previously mounted with options, but not on this attempt? */
+                if (sbsec->flags && !num_opts)
+                        goto out_double_mount;
+                rc = 0;
+                goto out;
+        }
 
-                rc = may_context_mount_sb_relabel(sid, sbsec, tsec);
+        if (strcmp(sb->s_type->name, "proc") == 0)
+                sbsec->proc = 1;
+
+        /* Determine the labeling behavior to use for this filesystem type. */
+        rc = security_fs_use(sb->s_type->name, &sbsec->behavior, &sbsec->sid);
+        if (rc) {
+                printk(KERN_WARNING "%s: security_fs_use(%s) returned %d\n",
+                       __FUNCTION__, sb->s_type->name, rc);
+                goto out;
+        }
+
+        /* sets the context of the superblock for the fs being mounted. */
+        if (fscontext_sid) {
+
+                rc = may_context_mount_sb_relabel(fscontext_sid, sbsec, tsec);
                 if (rc)
-                        goto out_free;
+                        goto out;
 
-                sbsec->sid = sid;
+                sbsec->sid = fscontext_sid;
         }
 
         /*
@@ -517,182 +686,250 @@ static int try_context_mount(struct super_block *sb, void *data)
          * sets the label used on all file below the mountpoint, and will set
          * the superblock context if not already set.
          */
-        if (context) {
-                rc = security_context_to_sid(context, strlen(context), &sid);
-                if (rc) {
-                        printk(KERN_WARNING "SELinux: security_context_to_sid"
-                               "(%s) failed for (dev %s, type %s) errno=%d\n",
-                               context, sb->s_id, name, rc);
-                        goto out_free;
-                }
-
-                if (!fscontext) {
-                        rc = may_context_mount_sb_relabel(sid, sbsec, tsec);
+        if (context_sid) {
+                if (!fscontext_sid) {
+                        rc = may_context_mount_sb_relabel(context_sid, sbsec, tsec);
                         if (rc)
-                                goto out_free;
-                        sbsec->sid = sid;
+                                goto out;
+                        sbsec->sid = context_sid;
                 } else {
-                        rc = may_context_mount_inode_relabel(sid, sbsec, tsec);
+                        rc = may_context_mount_inode_relabel(context_sid, sbsec, tsec);
                         if (rc)
-                                goto out_free;
+                                goto out;
                 }
-                sbsec->mntpoint_sid = sid;
+                if (!rootcontext_sid)
+                        rootcontext_sid = context_sid;
 
+                sbsec->mntpoint_sid = context_sid;
                 sbsec->behavior = SECURITY_FS_USE_MNTPOINT;
         }
 
-        if (rootcontext) {
-                struct inode *inode = sb->s_root->d_inode;
-                struct inode_security_struct *isec = inode->i_security;
-                rc = security_context_to_sid(rootcontext, strlen(rootcontext), &sid);
-                if (rc) {
-                        printk(KERN_WARNING "SELinux: security_context_to_sid"
-                               "(%s) failed for (dev %s, type %s) errno=%d\n",
-                               rootcontext, sb->s_id, name, rc);
-                        goto out_free;
-                }
-
-                rc = may_context_mount_inode_relabel(sid, sbsec, tsec);
+        if (rootcontext_sid) {
+                rc = may_context_mount_inode_relabel(rootcontext_sid, sbsec, tsec);
                 if (rc)
-                        goto out_free;
+                        goto out;
 
-                isec->sid = sid;
-                isec->initialized = 1;
+                root_isec->sid = rootcontext_sid;
+                root_isec->initialized = 1;
         }
 
-        if (defcontext) {
-                rc = security_context_to_sid(defcontext, strlen(defcontext), &sid);
-                if (rc) {
-                        printk(KERN_WARNING "SELinux: security_context_to_sid"
-                               "(%s) failed for (dev %s, type %s) errno=%d\n",
-                               defcontext, sb->s_id, name, rc);
-                        goto out_free;
+        if (defcontext_sid) {
+                if (sbsec->behavior != SECURITY_FS_USE_XATTR) {
+                        rc = -EINVAL;
+                        printk(KERN_WARNING "SELinux: defcontext option is "
+                               "invalid for this filesystem type\n");
+                        goto out;
                 }
 
-                if (sid == sbsec->def_sid)
-                        goto out_free;
-
-                rc = may_context_mount_inode_relabel(sid, sbsec, tsec);
-                if (rc)
-                        goto out_free;
+                if (defcontext_sid != sbsec->def_sid) {
+                        rc = may_context_mount_inode_relabel(defcontext_sid,
+                                                             sbsec, tsec);
+                        if (rc)
+                                goto out;
+                }
 
-                sbsec->def_sid = sid;
+                sbsec->def_sid = defcontext_sid;
         }
 
-out_free:
-        if (alloc) {
-                kfree(context);
-                kfree(defcontext);
-                kfree(fscontext);
-                kfree(rootcontext);
-        }
+        rc = sb_finish_set_opts(sb);
 out:
+        mutex_unlock(&sbsec->lock);
         return rc;
+out_double_mount:
+        rc = -EINVAL;
+        printk(KERN_WARNING "SELinux: mount invalid.  Same superblock, different "
+               "security settings for (dev %s, type %s)\n", sb->s_id, name);
+        goto out;
 }
 
-static int superblock_doinit(struct super_block *sb, void *data)
+static void selinux_sb_clone_mnt_opts(const struct super_block *oldsb,
+                                        struct super_block *newsb)
 {
-        struct superblock_security_struct *sbsec = sb->s_security;
-        struct dentry *root = sb->s_root;
-        struct inode *inode = root->d_inode;
-        int rc = 0;
+        const struct superblock_security_struct *oldsbsec = oldsb->s_security;
+        struct superblock_security_struct *newsbsec = newsb->s_security;
 
-        mutex_lock(&sbsec->lock);
-        if (sbsec->initialized)
-                goto out;
+        int set_fscontext =     (oldsbsec->flags & FSCONTEXT_MNT);
+        int set_context =       (oldsbsec->flags & CONTEXT_MNT);
+        int set_rootcontext =   (oldsbsec->flags & ROOTCONTEXT_MNT);
 
-        if (!ss_initialized) {
-                /* Defer initialization until selinux_complete_init,
-                   after the initial policy is loaded and the security
-                   server is ready to handle calls. */
-                spin_lock(&sb_security_lock);
-                if (list_empty(&sbsec->list))
-                        list_add(&sbsec->list, &superblock_security_head);
-                spin_unlock(&sb_security_lock);
-                goto out;
+        /* we can't error, we can't save the info, this shouldn't get called
+         * this early in the boot process. */
+        BUG_ON(!ss_initialized);
+
+        /* this might go away sometime down the line if there is a new user
+         * of clone, but for now, nfs better not get here... */
+        BUG_ON(newsbsec->initialized);
+
+        /* how can we clone if the old one wasn't set up?? */
+        BUG_ON(!oldsbsec->initialized);
+
+        mutex_lock(&newsbsec->lock);
+
+        newsbsec->flags = oldsbsec->flags;
+
+        newsbsec->sid = oldsbsec->sid;
+        newsbsec->def_sid = oldsbsec->def_sid;
+        newsbsec->behavior = oldsbsec->behavior;
+
+        if (set_context) {
+                u32 sid = oldsbsec->mntpoint_sid;
+
+                if (!set_fscontext)
+                        newsbsec->sid = sid;
+                if (!set_rootcontext) {
+                        struct inode *newinode = newsb->s_root->d_inode;
+                        struct inode_security_struct *newisec = newinode->i_security;
+                        newisec->sid = sid;
+                }
+                newsbsec->mntpoint_sid = sid;
         }
+        if (set_rootcontext) {
+                const struct inode *oldinode = oldsb->s_root->d_inode;
+                const struct inode_security_struct *oldisec = oldinode->i_security;
+                struct inode *newinode = newsb->s_root->d_inode;
+                struct inode_security_struct *newisec = newinode->i_security;
 
-        /* Determine the labeling behavior to use for this filesystem type. */
-        rc = security_fs_use(sb->s_type->name, &sbsec->behavior, &sbsec->sid);
-        if (rc) {
-                printk(KERN_WARNING "%s:  security_fs_use(%s) returned %d\n",
-                       __FUNCTION__, sb->s_type->name, rc);
-                goto out;
+                newisec->sid = oldisec->sid;
         }
 
-        rc = try_context_mount(sb, data);
-        if (rc)
+        sb_finish_set_opts(newsb);
+        mutex_unlock(&newsbsec->lock);
+}
+
+/*
+ * string mount options parsing and call set the sbsec
+ */
+static int superblock_doinit(struct super_block *sb, void *data)
+{
+        char *context = NULL, *defcontext = NULL;
+        char *fscontext = NULL, *rootcontext = NULL;
+        int rc = 0;
+        char *p, *options = data;
+        /* selinux only know about a fixed number of mount options */
+        char *mnt_opts[NUM_SEL_MNT_OPTS];
+        int mnt_opts_flags[NUM_SEL_MNT_OPTS], num_mnt_opts = 0;
+
+        if (!data)
                 goto out;
 
-        if (sbsec->behavior == SECURITY_FS_USE_XATTR) {
-                /* Make sure that the xattr handler exists and that no
-                   error other than -ENODATA is returned by getxattr on
-                   the root directory.  -ENODATA is ok, as this may be
-                   the first boot of the SELinux kernel before we have
-                   assigned xattr values to the filesystem. */
-                if (!inode->i_op->getxattr) {
-                        printk(KERN_WARNING "SELinux: (dev %s, type %s) has no "
-                               "xattr support\n", sb->s_id, sb->s_type->name);
-                        rc = -EOPNOTSUPP;
-                        goto out;
-                }
-                rc = inode->i_op->getxattr(root, XATTR_NAME_SELINUX, NULL, 0);
-                if (rc < 0 && rc != -ENODATA) {
-                        if (rc == -EOPNOTSUPP)
-                                printk(KERN_WARNING "SELinux: (dev %s, type "
-                                       "%s) has no security xattr handler\n",
-                                       sb->s_id, sb->s_type->name);
-                        else
-                                printk(KERN_WARNING "SELinux: (dev %s, type "
-                                       "%s) getxattr errno %d\n", sb->s_id,
-                                       sb->s_type->name, -rc);
+        /* with the nfs patch this will become a goto out; */
+        if (sb->s_type->fs_flags & FS_BINARY_MOUNTDATA) {
+                const char *name = sb->s_type->name;
+                /* NFS we understand. */
+                if (!strcmp(name, "nfs")) {
+                        struct nfs_mount_data *d = data;
+
+                        if (d->version !=  NFS_MOUNT_VERSION)
+                                goto out;
+
+                        if (d->context[0]) {
+                                context = kstrdup(d->context, GFP_KERNEL);
+                                if (!context) {
+                                        rc = -ENOMEM;
+                                        goto out;
+                                }
+                        }
+                        goto build_flags;
+                } else
                         goto out;
-                }
         }
 
-        if (strcmp(sb->s_type->name, "proc") == 0)
-                sbsec->proc = 1;
+        /* Standard string-based options. */
+        while ((p = strsep(&options, "|")) != NULL) {
+                int token;
+                substring_t args[MAX_OPT_ARGS];
 
-        sbsec->initialized = 1;
+                if (!*p)
+                        continue;
 
-        if (sbsec->behavior > ARRAY_SIZE(labeling_behaviors)) {
-                printk(KERN_ERR "SELinux: initialized (dev %s, type %s), unknown behavior\n",
-                       sb->s_id, sb->s_type->name);
-        }
-        else {
-                printk(KERN_DEBUG "SELinux: initialized (dev %s, type %s), %s\n",
-                       sb->s_id, sb->s_type->name,
-                       labeling_behaviors[sbsec->behavior-1]);
-        }
+                token = match_token(p, tokens, args);
 
-        /* Initialize the root inode. */
-        rc = inode_doinit_with_dentry(sb->s_root->d_inode, sb->s_root);
+                switch (token) {
+                case Opt_context:
+                        if (context || defcontext) {
+                                rc = -EINVAL;
+                                printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
+                                goto out_err;
+                        }
+                        context = match_strdup(&args[0]);
+                        if (!context) {
+                                rc = -ENOMEM;
+                                goto out_err;
+                        }
+                        break;
+
+                case Opt_fscontext:
+                        if (fscontext) {
+                                rc = -EINVAL;
+                                printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
+                                goto out_err;
+                        }
+                        fscontext = match_strdup(&args[0]);
+                        if (!fscontext) {
+                                rc = -ENOMEM;
+                                goto out_err;
+                        }
+                        break;
+
+                case Opt_rootcontext:
+                        if (rootcontext) {
+                                rc = -EINVAL;
+                                printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
+                                goto out_err;
+                        }
+                        rootcontext = match_strdup(&args[0]);
+                        if (!rootcontext) {
+                                rc = -ENOMEM;
+                                goto out_err;
+                        }
+                        break;
+
+                case Opt_defcontext:
+                        if (context || defcontext) {
+                                rc = -EINVAL;
+                                printk(KERN_WARNING SEL_MOUNT_FAIL_MSG);
+                                goto out_err;
+                        }
+                        defcontext = match_strdup(&args[0]);
+                        if (!defcontext) {
+                                rc = -ENOMEM;
+                                goto out_err;
+                        }
+                        break;
+
+                default:
+                        rc = -EINVAL;
+                        printk(KERN_WARNING "SELinux:  unknown mount option\n");
+                        goto out_err;
 
-        /* Initialize any other inodes associated with the superblock, e.g.
-           inodes created prior to initial policy load or inodes created
-           during get_sb by a pseudo filesystem that directly
-           populates itself. */
-        spin_lock(&sbsec->isec_lock);
-next_inode:
-        if (!list_empty(&sbsec->isec_head)) {
-                struct inode_security_struct *isec =
-                                list_entry(sbsec->isec_head.next,
-                                           struct inode_security_struct, list);
-                struct inode *inode = isec->inode;
-                spin_unlock(&sbsec->isec_lock);
-                inode = igrab(inode);
-                if (inode) {
-                        if (!IS_PRIVATE (inode))
-                                inode_doinit(inode);
-                        iput(inode);
                 }
-                spin_lock(&sbsec->isec_lock);
-                list_del_init(&isec->list);
-                goto next_inode;
         }
-        spin_unlock(&sbsec->isec_lock);
+
+build_flags:
+        if (fscontext) {
+                mnt_opts[num_mnt_opts] = fscontext;
+                mnt_opts_flags[num_mnt_opts++] = FSCONTEXT_MNT;
+        }
+        if (context) {
+                mnt_opts[num_mnt_opts] = context;
+                mnt_opts_flags[num_mnt_opts++] = CONTEXT_MNT;
+        }
+        if (rootcontext) {
+                mnt_opts[num_mnt_opts] = rootcontext;
+                mnt_opts_flags[num_mnt_opts++] = ROOTCONTEXT_MNT;
+        }
+        if (defcontext) {
+                mnt_opts[num_mnt_opts] = defcontext;
+                mnt_opts_flags[num_mnt_opts++] = DEFCONTEXT_MNT;
+        }
+
 out:
-        mutex_unlock(&sbsec->lock);
+        rc = selinux_set_mnt_opts(sb, mnt_opts, mnt_opts_flags, num_mnt_opts);
+out_err:
+        kfree(context);
+        kfree(defcontext);
+        kfree(fscontext);
+        kfree(rootcontext);
         return rc;
 }
 
@@ -4800,6 +5037,9 @@ static struct security_operations selinux_ops = {
         .sb_statfs =                    selinux_sb_statfs,
         .sb_mount =                     selinux_mount,
         .sb_umount =                    selinux_umount,
+        .sb_get_mnt_opts =              selinux_get_mnt_opts,
+        .sb_set_mnt_opts =              selinux_set_mnt_opts,
+        .sb_clone_mnt_opts =            selinux_sb_clone_mnt_opts,
 
         .inode_alloc_security =         selinux_inode_alloc_security,
         .inode_free_security =          selinux_inode_free_security,
diff --git a/security/selinux/include/objsec.h b/security/selinux/include/objsec.h
index 642a9fd319ad..4138a80f8e27 100644
--- a/security/selinux/include/objsec.h
+++ b/security/selinux/include/objsec.h
@@ -65,6 +65,7 @@ struct superblock_security_struct {
         u32 mntpoint_sid;               /* SECURITY_FS_USE_MNTPOINT context for files */
         unsigned int behavior;          /* labeling behavior */
         unsigned char initialized;      /* initialization flag */
+        unsigned char flags;            /* which mount options were specified */
         unsigned char proc;             /* proc fs */
         struct mutex lock;
         struct list_head isec_head;