Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-rc-fixes-2.6

[~andy/linux] / fs / btrfs / inode.c

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 2fdb2995be64520828a6d1b0cd678ca814d7f8b1..1c8b0190d0317104d9d5e3a412f4c469d0ed5038 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -70,7 +70,6 @@ static struct extent_io_ops btrfs_extent_io_ops;
 static struct kmem_cache *btrfs_inode_cachep;
 struct kmem_cache *btrfs_trans_handle_cachep;
 struct kmem_cache *btrfs_transaction_cachep;
-struct kmem_cache *btrfs_bit_radix_cachep;
 struct kmem_cache *btrfs_path_cachep;
 
 #define S_SHIFT 12
@@ -1823,10 +1822,12 @@ good:
        return 0;
 
 zeroit:
-       printk(KERN_INFO "btrfs csum failed ino %lu off %llu csum %u "
-              "private %llu\n", page->mapping->host->i_ino,
-              (unsigned long long)start, csum,
-              (unsigned long long)private);
+       if (printk_ratelimit()) {
+               printk(KERN_INFO "btrfs csum failed ino %lu off %llu csum %u "
+                      "private %llu\n", page->mapping->host->i_ino,
+                      (unsigned long long)start, csum,
+                      (unsigned long long)private);
+       }
        memset(kaddr + offset, 1, end - start + 1);
        flush_dcache_page(page);
        kunmap_atomic(kaddr, KM_USER0);
@@ -2014,6 +2015,57 @@ void btrfs_orphan_cleanup(struct btrfs_root *root)
        btrfs_free_path(path);
 }
 
+/*
+ * very simple check to peek ahead in the leaf looking for xattrs.  If we
+ * don't find any xattrs, we know there can't be any acls.
+ *
+ * slot is the slot the inode is in, objectid is the objectid of the inode
+ */
+static noinline int acls_after_inode_item(struct extent_buffer *leaf,
+                                         int slot, u64 objectid)
+{
+       u32 nritems = btrfs_header_nritems(leaf);
+       struct btrfs_key found_key;
+       int scanned = 0;
+
+       slot++;
+       while (slot < nritems) {
+               btrfs_item_key_to_cpu(leaf, &found_key, slot);
+
+               /* we found a different objectid, there must not be acls */
+               if (found_key.objectid != objectid)
+                       return 0;
+
+               /* we found an xattr, assume we've got an acl */
+               if (found_key.type == BTRFS_XATTR_ITEM_KEY)
+                       return 1;
+
+               /*
+                * we found a key greater than an xattr key, there can't
+                * be any acls later on
+                */
+               if (found_key.type > BTRFS_XATTR_ITEM_KEY)
+                       return 0;
+
+               slot++;
+               scanned++;
+
+               /*
+                * it goes inode, inode backrefs, xattrs, extents,
+                * so if there are a ton of hard links to an inode there can
+                * be a lot of backrefs.  Don't waste time searching too hard,
+                * this is just an optimization
+                */
+               if (scanned >= 8)
+                       break;
+       }
+       /* we hit the end of the leaf before we found an xattr or
+        * something larger than an xattr.  We have to assume the inode
+        * has acls
+        */
+       return 1;
+}
+
 /*
  * read an inode from the btree into the in-memory inode
  */
@@ -2025,6 +2077,7 @@ void btrfs_read_locked_inode(struct inode *inode)
        struct btrfs_timespec *tspec;
        struct btrfs_root *root = BTRFS_I(inode)->root;
        struct btrfs_key location;
+       int maybe_acls;
        u64 alloc_group_block;
        u32 rdev;
        int ret;
@@ -2071,6 +2124,16 @@ void btrfs_read_locked_inode(struct inode *inode)
 
        alloc_group_block = btrfs_inode_block_group(leaf, inode_item);
 
+       /*
+        * try to precache a NULL acl entry for files that don't have
+        * any xattrs or acls
+        */
+       maybe_acls = acls_after_inode_item(leaf, path->slots[0], inode->i_ino);
+       if (!maybe_acls) {
+               BTRFS_I(inode)->i_acl = NULL;
+               BTRFS_I(inode)->i_default_acl = NULL;
+       }
+
        BTRFS_I(inode)->block_group = btrfs_find_block_group(root, 0,
                                                alloc_group_block, 0);
        btrfs_free_path(path);
@@ -3046,8 +3109,8 @@ static noinline void init_btrfs_i(struct inode *inode)
 {
        struct btrfs_inode *bi = BTRFS_I(inode);
 
-       bi->i_acl = NULL;
-       bi->i_default_acl = NULL;
+       bi->i_acl = BTRFS_ACL_NOT_CACHED;
+       bi->i_default_acl = BTRFS_ACL_NOT_CACHED;
 
        bi->generation = 0;
        bi->sequence = 0;
@@ -3059,6 +3122,7 @@ static noinline void init_btrfs_i(struct inode *inode)
        bi->flags = 0;
        bi->index_cnt = (u64)-1;
        bi->last_unlink_trans = 0;
+       bi->ordered_data_close = 0;
        extent_map_tree_init(&BTRFS_I(inode)->extent_tree, GFP_NOFS);
        extent_io_tree_init(&BTRFS_I(inode)->io_tree,
                             inode->i_mapping, GFP_NOFS);
@@ -4232,7 +4296,6 @@ out:
        }
        if (err) {
                free_extent_map(em);
-               WARN_ON(1);
                return ERR_PTR(err);
        }
        return em;
@@ -4639,8 +4702,6 @@ void btrfs_destroy_cachep(void)
                kmem_cache_destroy(btrfs_trans_handle_cachep);
        if (btrfs_transaction_cachep)
                kmem_cache_destroy(btrfs_transaction_cachep);
-       if (btrfs_bit_radix_cachep)
-               kmem_cache_destroy(btrfs_bit_radix_cachep);
        if (btrfs_path_cachep)
                kmem_cache_destroy(btrfs_path_cachep);
 }
@@ -4671,11 +4732,6 @@ int btrfs_init_cachep(void)
        if (!btrfs_path_cachep)
                goto fail;
 
-       btrfs_bit_radix_cachep = kmem_cache_create("btrfs_radix", 256, 0,
-                       SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD |
-                       SLAB_DESTROY_BY_RCU, NULL);
-       if (!btrfs_bit_radix_cachep)
-               goto fail;
        return 0;
 fail:
        btrfs_destroy_cachep();