Patched in Tegra support.

1 files changed, 27 insertions, 50 deletions

diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index 446a6848c55..69565e5fc6a 100644
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -122,32 +122,11 @@ static int do_setxattr(struct btrfs_trans_handle *trans,
                  */
                 if (!value)
                         goto out;
-        } else {
-                di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(inode),
-                                        name, name_len, 0);
-                if (IS_ERR(di)) {
-                        ret = PTR_ERR(di);
-                        goto out;
-                }
-                if (!di && !value)
-                        goto out;
-                btrfs_release_path(path);
         }
 
 again:
         ret = btrfs_insert_xattr_item(trans, root, path, btrfs_ino(inode),
                                       name, name_len, value, size);
-        /*
-         * If we're setting an xattr to a new value but the new value is say
-         * exactly BTRFS_MAX_XATTR_SIZE, we could end up with EOVERFLOW getting
-         * back from split_leaf.  This is because it thinks we'll be extending
-         * the existing item size, but we're asking for enough space to add the
-         * item itself.  So if we get EOVERFLOW just set ret to EEXIST and let
-         * the rest of the function figure it out.
-         */
-        if (ret == -EOVERFLOW)
-                ret = -EEXIST;
-
         if (ret == -EEXIST) {
                 if (flags & XATTR_CREATE)
                         goto out;
@@ -206,13 +185,11 @@ int __btrfs_setxattr(struct btrfs_trans_handle *trans,
         if (ret)
                 goto out;
 
-        inode_inc_iversion(inode);
         inode->i_ctime = CURRENT_TIME;
-        set_bit(BTRFS_INODE_COPY_EVERYTHING, &BTRFS_I(inode)->runtime_flags);
         ret = btrfs_update_inode(trans, root, inode);
         BUG_ON(ret);
 out:
-        btrfs_end_transaction(trans, root);
+        btrfs_end_transaction_throttle(trans, root);
         return ret;
 }
 
@@ -276,7 +253,7 @@ ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 
                 di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
                 if (verify_dir_item(root, leaf, di))
-                        goto next;
+                        continue;
 
                 name_len = btrfs_dir_name_len(leaf, di);
                 total_size += name_len + 1;
@@ -406,36 +383,36 @@ int btrfs_removexattr(struct dentry *dentry, const char *name)
                                 XATTR_REPLACE);
 }
 
-int btrfs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
-                     void *fs_info)
+int btrfs_xattr_security_init(struct btrfs_trans_handle *trans,
+                              struct inode *inode, struct inode *dir,
+                              const struct qstr *qstr)
 {
-        const struct xattr *xattr;
-        struct btrfs_trans_handle *trans = fs_info;
+        int err;
+        size_t len;
+        void *value;
+        char *suffix;
         char *name;
-        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;
-                }
+        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 {
                 strcpy(name, XATTR_SECURITY_PREFIX);
-                strcpy(name + XATTR_SECURITY_PREFIX_LEN, xattr->name);
-                err = __btrfs_setxattr(trans, inode, name,
-                                       xattr->value, xattr->value_len, 0);
+                strcpy(name + XATTR_SECURITY_PREFIX_LEN, suffix);
+                err = __btrfs_setxattr(trans, inode, name, value, len, 0);
                 kfree(name);
-                if (err < 0)
-                        break;
         }
-        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);
+        kfree(suffix);
+        kfree(value);
+        return err;
 }