security: new security_inode_init_security API adds function callback

This patch changes the security_inode_init_security API by adding a
filesystem specific callback to write security extended attributes.
This change is in preparation for supporting the initialization of
multiple LSM xattrs and the EVM xattr.  Initially the callback function
walks an array of xattrs, writing each xattr separately, but could be
optimized to write multiple xattrs at once.

For existing security_inode_init_security() calls, which have not yet
been converted to use the new callback function, such as those in
reiserfs and ocfs2, this patch defines security_old_inode_init_security().

Signed-off-by: Mimi Zohar <zohar@us.ibm.com>

10 files changed, 194 insertions, 173 deletions

diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index 5366fe452ab0..a039e6ed4ce0 100644
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -360,36 +360,36 @@ int btrfs_removexattr(struct dentry *dentry, const char *name)
                                 XATTR_REPLACE);
 }
 
-int btrfs_xattr_security_init(struct btrfs_trans_handle *trans,
-                              struct inode *inode, struct inode *dir,
-                              const struct qstr *qstr)
+int btrfs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
+                     void *fs_info)
 {
-        int err;
-        size_t len;
-        void *value;
-        char *suffix;
+        const struct xattr *xattr;
+        struct btrfs_trans_handle *trans = fs_info;
         char *name;
+        int err = 0;
 
-        err = security_inode_init_security(inode, dir, qstr, &suffix, &value,
-                                           &len);
-        if (err) {
-                if (err == -EOPNOTSUPP)
-                        return 0;
-                return err;
-        }
-
-        name = kmalloc(XATTR_SECURITY_PREFIX_LEN + strlen(suffix) + 1,
-                       GFP_NOFS);
-        if (!name) {
-                err = -ENOMEM;
-        } else {
+        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
+                name = kmalloc(XATTR_SECURITY_PREFIX_LEN +
+                               strlen(xattr->name) + 1, GFP_NOFS);
+                if (!name) {
+                        err = -ENOMEM;
+                        break;
+                }
                 strcpy(name, XATTR_SECURITY_PREFIX);
-                strcpy(name + XATTR_SECURITY_PREFIX_LEN, suffix);
-                err = __btrfs_setxattr(trans, inode, name, value, len, 0);
+                strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
+                err = __btrfs_setxattr(trans, inode, name,
+                                       xattr->value, xattr->value_len, 0);
                 kfree(name);
+                if (err < 0)
+                        break;
         }
-
-        kfree(suffix);
-        kfree(value);
         return err;
 }
+
+int btrfs_xattr_security_init(struct btrfs_trans_handle *trans,
+                              struct inode *inode, struct inode *dir,
+                              const struct qstr *qstr)
+{
+        return security_inode_init_security(inode, dir, qstr,
+                                            &btrfs_initxattrs, trans);
+}
diff --git a/fs/ext2/xattr_security.c b/fs/ext2/xattr_security.c
index 5d979b4347b0..c922adc8ef41 100644
--- a/fs/ext2/xattr_security.c
+++ b/fs/ext2/xattr_security.c
@@ -46,28 +46,30 @@ ext2_xattr_security_set(struct dentry *dentry, const char *name,
                               value, size, flags);
 }
 
-int
-ext2_init_security(struct inode *inode, struct inode *dir,
-                   const struct qstr *qstr)
+int ext2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
+                    void *fs_info)
 {
-        int err;
-        size_t len;
-        void *value;
-        char *name;
+        const struct xattr *xattr;
+        int err = 0;
 
-        err = security_inode_init_security(inode, dir, qstr, &name, &value, &len);
-        if (err) {
-                if (err == -EOPNOTSUPP)
-                        return 0;
-                return err;
+        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
+                err = ext2_xattr_set(inode, EXT2_XATTR_INDEX_SECURITY,
+                                     xattr->name, xattr->value,
+                                     xattr->value_len, 0);
+                if (err < 0)
+                        break;
         }
-        err = ext2_xattr_set(inode, EXT2_XATTR_INDEX_SECURITY,
-                             name, value, len, 0);
-        kfree(name);
-        kfree(value);
         return err;
 }
 
+int
+ext2_init_security(struct inode *inode, struct inode *dir,
+                   const struct qstr *qstr)
+{
+        return security_inode_init_security(inode, dir, qstr,
+                                            &ext2_initxattrs, NULL);
+}
+
 const struct xattr_handler ext2_xattr_security_handler = {
         .prefix = XATTR_SECURITY_PREFIX,
         .list   = ext2_xattr_security_list,
diff --git a/fs/ext3/xattr_security.c b/fs/ext3/xattr_security.c
index b8d9f83aa5c5..3c218b8a51d4 100644
--- a/fs/ext3/xattr_security.c
+++ b/fs/ext3/xattr_security.c
@@ -48,28 +48,32 @@ ext3_xattr_security_set(struct dentry *dentry, const char *name,
                               name, value, size, flags);
 }
 
-int
-ext3_init_security(handle_t *handle, struct inode *inode, struct inode *dir,
-                   const struct qstr *qstr)
+int ext3_initxattrs(struct inode *inode, const struct xattr *xattr_array,
+                    void *fs_info)
 {
-        int err;
-        size_t len;
-        void *value;
-        char *name;
+        const struct xattr *xattr;
+        handle_t *handle = fs_info;
+        int err = 0;
 
-        err = security_inode_init_security(inode, dir, qstr, &name, &value, &len);
-        if (err) {
-                if (err == -EOPNOTSUPP)
-                        return 0;
-                return err;
+        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
+                err = ext3_xattr_set_handle(handle, inode,
+                                            EXT3_XATTR_INDEX_SECURITY,
+                                            xattr->name, xattr->value,
+                                            xattr->value_len, 0);
+                if (err < 0)
+                        break;
         }
-        err = ext3_xattr_set_handle(handle, inode, EXT3_XATTR_INDEX_SECURITY,
-                                    name, value, len, 0);
-        kfree(name);
-        kfree(value);
         return err;
 }
 
+int
+ext3_init_security(handle_t *handle, struct inode *inode, struct inode *dir,
+                   const struct qstr *qstr)
+{
+        return security_inode_init_security(inode, dir, qstr,
+                                            &ext3_initxattrs, handle);
+}
+
 const struct xattr_handler ext3_xattr_security_handler = {
         .prefix = XATTR_SECURITY_PREFIX,
         .list   = ext3_xattr_security_list,
diff --git a/fs/ext4/xattr_security.c b/fs/ext4/xattr_security.c
index 007c3bfbf094..34e4350dd4d9 100644
--- a/fs/ext4/xattr_security.c
+++ b/fs/ext4/xattr_security.c
@@ -48,28 +48,32 @@ ext4_xattr_security_set(struct dentry *dentry, const char *name,
                               name, value, size, flags);
 }
 
-int
-ext4_init_security(handle_t *handle, struct inode *inode, struct inode *dir,
-                   const struct qstr *qstr)
+int ext4_initxattrs(struct inode *inode, const struct xattr *xattr_array,
+                    void *fs_info)
 {
-        int err;
-        size_t len;
-        void *value;
-        char *name;
+        const struct xattr *xattr;
+        handle_t *handle = fs_info;
+        int err = 0;
 
-        err = security_inode_init_security(inode, dir, qstr, &name, &value, &len);
-        if (err) {
-                if (err == -EOPNOTSUPP)
-                        return 0;
-                return err;
+        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
+                err = ext4_xattr_set_handle(handle, inode,
+                                            EXT4_XATTR_INDEX_SECURITY,
+                                            xattr->name, xattr->value,
+                                            xattr->value_len, 0);
+                if (err < 0)
+                        break;
         }
-        err = ext4_xattr_set_handle(handle, inode, EXT4_XATTR_INDEX_SECURITY,
-                                    name, value, len, 0);
-        kfree(name);
-        kfree(value);
         return err;
 }
 
+int
+ext4_init_security(handle_t *handle, struct inode *inode, struct inode *dir,
+                   const struct qstr *qstr)
+{
+        return security_inode_init_security(inode, dir, qstr,
+                                            &ext4_initxattrs, handle);
+}
+
 const struct xattr_handler ext4_xattr_security_handler = {
         .prefix = XATTR_SECURITY_PREFIX,
         .list   = ext4_xattr_security_list,
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 03e0c529063e..1d3a1a651721 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -624,31 +624,29 @@ fail:
         return error;
 }
 
-static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
-                              const struct qstr *qstr)
+int gfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
+                    void *fs_info)
 {
-        int err;
-        size_t len;
-        void *value;
-        char *name;
-
-        err = security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,
-                                           &name, &value, &len);
-
-        if (err) {
-                if (err == -EOPNOTSUPP)
-                        return 0;
-                return err;
+        const struct xattr *xattr;
+        int err = 0;
+
+        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
+                err = __gfs2_xattr_set(inode, xattr->name, xattr->value,
+                                       xattr->value_len, 0,
+                                       GFS2_EATYPE_SECURITY);
+                if (err < 0)
+                        break;
         }
-
-        err = __gfs2_xattr_set(&ip->i_inode, name, value, len, 0,
-                               GFS2_EATYPE_SECURITY);
-        kfree(value);
-        kfree(name);
-
         return err;
 }
 
+static int gfs2_security_init(struct gfs2_inode *dip, struct gfs2_inode *ip,
+                              const struct qstr *qstr)
+{
+        return security_inode_init_security(&ip->i_inode, &dip->i_inode, qstr,
+                                            &gfs2_initxattrs, NULL);
+}
+
 /**
  * gfs2_create_inode - Create a new inode
  * @dir: The parent directory
diff --git a/fs/jffs2/security.c b/fs/jffs2/security.c
index cfeb7164b085..0f20208df602 100644
--- a/fs/jffs2/security.c
+++ b/fs/jffs2/security.c
@@ -22,26 +22,29 @@
 #include <linux/security.h>
 #include "nodelist.h"
 
-/* ---- Initial Security Label Attachment -------------- */
-int jffs2_init_security(struct inode *inode, struct inode *dir,
-                        const struct qstr *qstr)
+/* ---- Initial Security Label(s) Attachment callback --- */
+int jffs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
+                     void *fs_info)
 {
-        int rc;
-        size_t len;
-        void *value;
-        char *name;
+        const struct xattr *xattr;
+        int err = 0;
 
-        rc = security_inode_init_security(inode, dir, qstr, &name, &value, &len);
-        if (rc) {
-                if (rc == -EOPNOTSUPP)
-                        return 0;
-                return rc;
+        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
+                err = do_jffs2_setxattr(inode, JFFS2_XPREFIX_SECURITY,
+                                        xattr->name, xattr->value,
+                                        xattr->value_len, 0);
+                if (err < 0)
+                        break;
         }
-        rc = do_jffs2_setxattr(inode, JFFS2_XPREFIX_SECURITY, name, value, len, 0);
+        return err;
+}
 
-        kfree(name);
-        kfree(value);
-        return rc;
+/* ---- Initial Security Label(s) Attachment ----------- */
+int jffs2_init_security(struct inode *inode, struct inode *dir,
+                        const struct qstr *qstr)
+{
+        return security_inode_init_security(inode, dir, qstr,
+                                            &jffs2_initxattrs, NULL);
 }
 
 /* ---- XATTR Handler for "security.*" ----------------- */
diff --git a/fs/jfs/xattr.c b/fs/jfs/xattr.c
index 24838f1eeee5..e982509292f8 100644
--- a/fs/jfs/xattr.c
+++ b/fs/jfs/xattr.c
@@ -1091,38 +1091,37 @@ int jfs_removexattr(struct dentry *dentry, const char *name)
 }
 
 #ifdef CONFIG_JFS_SECURITY
-int jfs_init_security(tid_t tid, struct inode *inode, struct inode *dir,
-                      const struct qstr *qstr)
+int jfs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
+                   void *fs_info)
 {
-        int rc;
-        size_t len;
-        void *value;
-        char *suffix;
+        const struct xattr *xattr;
+        tid_t *tid = fs_info;
         char *name;
-
-        rc = security_inode_init_security(inode, dir, qstr, &suffix, &value,
-                                          &len);
-        if (rc) {
-                if (rc == -EOPNOTSUPP)
-                        return 0;
-                return rc;
-        }
-        name = kmalloc(XATTR_SECURITY_PREFIX_LEN + 1 + strlen(suffix),
-                       GFP_NOFS);
-        if (!name) {
-                rc = -ENOMEM;
-                goto kmalloc_failed;
+        int err = 0;
+
+        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
+                name = kmalloc(XATTR_SECURITY_PREFIX_LEN +
+                               strlen(xattr->name) + 1, GFP_NOFS);
+                if (!name) {
+                        err = -ENOMEM;
+                        break;
+                }
+                strcpy(name, XATTR_SECURITY_PREFIX);
+                strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
+
+                err = __jfs_setxattr(*tid, inode, name,
+                                     xattr->value, xattr->value_len, 0);
+                kfree(name);
+                if (err < 0)
+                        break;
         }
-        strcpy(name, XATTR_SECURITY_PREFIX);
-        strcpy(name + XATTR_SECURITY_PREFIX_LEN, suffix);
-
-        rc = __jfs_setxattr(tid, inode, name, value, len, 0);
-
-        kfree(name);
-kmalloc_failed:
-        kfree(suffix);
-        kfree(value);
+        return err;
+}
 
-        return rc;
+int jfs_init_security(tid_t tid, struct inode *inode, struct inode *dir,
+                      const struct qstr *qstr)
+{
+        return security_inode_init_security(inode, dir, qstr,
+                                            &jfs_initxattrs, &tid);
 }
 #endif
diff --git a/fs/ocfs2/xattr.c b/fs/ocfs2/xattr.c
index 81ecf9c0bf0a..194fb22ef79d 100644
--- a/fs/ocfs2/xattr.c
+++ b/fs/ocfs2/xattr.c
@@ -7185,20 +7185,9 @@ int ocfs2_init_security_and_acl(struct inode *dir,
 {
         int ret = 0;
         struct buffer_head *dir_bh = NULL;
-        struct ocfs2_security_xattr_info si = {
-                .enable = 1,
-        };
 
-        ret = ocfs2_init_security_get(inode, dir, qstr, &si);
+        ret = ocfs2_init_security_get(inode, dir, qstr, NULL);
         if (!ret) {
-                ret = ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY,
-                                      si.name, si.value, si.value_len,
-                                      XATTR_CREATE);
-                if (ret) {
-                        mlog_errno(ret);
-                        goto leave;
-                }
-        } else if (ret != -EOPNOTSUPP) {
                 mlog_errno(ret);
                 goto leave;
         }
@@ -7255,6 +7244,22 @@ static int ocfs2_xattr_security_set(struct dentry *dentry, const char *name,
                                name, value, size, flags);
 }
 
+int ocfs2_initxattrs(struct inode *inode, const struct xattr *xattr_array,
+                     void *fs_info)
+{
+        const struct xattr *xattr;
+        int err = 0;
+
+        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
+                err = ocfs2_xattr_set(inode, OCFS2_XATTR_INDEX_SECURITY,
+                                      xattr->name, xattr->value,
+                                      xattr->value_len, XATTR_CREATE);
+                if (err)
+                        break;
+        }
+        return err;
+}
+
 int ocfs2_init_security_get(struct inode *inode,
                             struct inode *dir,
                             const struct qstr *qstr,
@@ -7263,8 +7268,13 @@ int ocfs2_init_security_get(struct inode *inode,
         /* check whether ocfs2 support feature xattr */
         if (!ocfs2_supports_xattr(OCFS2_SB(dir->i_sb)))
                 return -EOPNOTSUPP;
-        return security_inode_init_security(inode, dir, qstr, &si->name,
-                                            &si->value, &si->value_len);
+        if (si)
+                return security_old_inode_init_security(inode, dir, qstr,
+                                                        &si->name, &si->value,
+                                                        &si->value_len);
+
+        return security_inode_init_security(inode, dir, qstr,
+                                            &ocfs2_initxattrs, NULL);
 }
 
 int ocfs2_init_security_set(handle_t *handle,
diff --git a/fs/reiserfs/xattr_security.c b/fs/reiserfs/xattr_security.c
index ef66c18a9332..534668fa41be 100644
--- a/fs/reiserfs/xattr_security.c
+++ b/fs/reiserfs/xattr_security.c
@@ -66,8 +66,8 @@ int reiserfs_security_init(struct inode *dir, struct inode *inode,
         if (IS_PRIVATE(dir))
                 return 0;
 
-        error = security_inode_init_security(inode, dir, qstr, &sec->name,
-                                             &sec->value, &sec->length);
+        error = security_old_inode_init_security(inode, dir, qstr, &sec->name,
+                                                 &sec->value, &sec->length);
         if (error) {
                 if (error == -EOPNOTSUPP)
                         error = 0;
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index d44d92cd12b1..27a3658b830f 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -93,37 +93,38 @@ xfs_mark_inode_dirty(
                 mark_inode_dirty(inode);
 }
 
+
+int xfs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
+                   void *fs_info)
+{
+        const struct xattr *xattr;
+        struct xfs_inode *ip = XFS_I(inode);
+        int error = 0;
+
+        for (xattr = xattr_array; xattr->name != NULL; xattr++) {
+                error = xfs_attr_set(ip, xattr->name, xattr->value,
+                                     xattr->value_len, ATTR_SECURE);
+                if (error < 0)
+                        break;
+        }
+        return error;
+}
+
 /*
  * Hook in SELinux.  This is not quite correct yet, what we really need
  * here (as we do for default ACLs) is a mechanism by which creation of
  * these attrs can be journalled at inode creation time (along with the
  * inode, of course, such that log replay can't cause these to be lost).
  */
+
 STATIC int
 xfs_init_security(
         struct inode    *inode,
         struct inode    *dir,
         const struct qstr *qstr)
 {
-        struct xfs_inode *ip = XFS_I(inode);
-        size_t          length;
-        void            *value;
-        unsigned char   *name;
-        int             error;
-
-        error = security_inode_init_security(inode, dir, qstr, (char **)&name,
-                                             &value, &length);
-        if (error) {
-                if (error == -EOPNOTSUPP)
-                        return 0;
-                return -error;
-        }
-
-        error = xfs_attr_set(ip, name, value, length, ATTR_SECURE);
-
-        kfree(name);
-        kfree(value);
-        return error;
+        return security_inode_init_security(inode, dir, qstr,
+                                            &xfs_initxattrs, NULL);
 }
 
 static void