ext2, ext4: make mb block cache names more explicit

There will be a second mb_cache instance that tracks ea_inodes. Make
existing names more explicit so that it is clear that they refer to
xattr block cache.

Signed-off-by: Tahsin Erdogan <tahsin@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 03f5ce1d3dbe1c334958c1de072ff88ce1cdeb8a..23ebb92484c602ba075d4725694e3380827397cc 100644 (file)
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -113,7 +113,7 @@ struct ext2_sb_info {
         * of the mount options.
         */
        spinlock_t s_lock;
-       struct mb_cache *s_mb_cache;
+       struct mb_cache *s_ea_block_cache;
 };
 
 static inline spinlock_t *

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 9c2028b50e5c389ed6f86a89d9bf94960fcfc8cb..7b1bc9059863b37c2ff508bd331a736cef403bb6 100644 (file)
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -147,9 +147,9 @@ static void ext2_put_super (struct super_block * sb)
 
        ext2_quota_off_umount(sb);
 
-       if (sbi->s_mb_cache) {
-               ext2_xattr_destroy_cache(sbi->s_mb_cache);
-               sbi->s_mb_cache = NULL;
+       if (sbi->s_ea_block_cache) {
+               ext2_xattr_destroy_cache(sbi->s_ea_block_cache);
+               sbi->s_ea_block_cache = NULL;
        }
        if (!(sb->s_flags & MS_RDONLY)) {
                struct ext2_super_block *es = sbi->s_es;
@@ -1131,9 +1131,9 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
        }
 
 #ifdef CONFIG_EXT2_FS_XATTR
-       sbi->s_mb_cache = ext2_xattr_create_cache();
-       if (!sbi->s_mb_cache) {
-               ext2_msg(sb, KERN_ERR, "Failed to create an mb_cache");
+       sbi->s_ea_block_cache = ext2_xattr_create_cache();
+       if (!sbi->s_ea_block_cache) {
+               ext2_msg(sb, KERN_ERR, "Failed to create ea_block_cache");
                goto failed_mount3;
        }
 #endif
@@ -1182,8 +1182,8 @@ cantfind_ext2:
                        sb->s_id);
        goto failed_mount;
 failed_mount3:
-       if (sbi->s_mb_cache)
-               ext2_xattr_destroy_cache(sbi->s_mb_cache);
+       if (sbi->s_ea_block_cache)
+               ext2_xattr_destroy_cache(sbi->s_ea_block_cache);
        percpu_counter_destroy(&sbi->s_freeblocks_counter);
        percpu_counter_destroy(&sbi->s_freeinodes_counter);
        percpu_counter_destroy(&sbi->s_dirs_counter);

diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index 1e5f76070580e64568a35afbadb61470fd473a2e..1b9b1268d418049b6978dee5bfbe0be098c65f34 100644 (file)
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -121,6 +121,8 @@ const struct xattr_handler *ext2_xattr_handlers[] = {
        NULL
 };
 
+#define EA_BLOCK_CACHE(inode)  (EXT2_SB(inode->i_sb)->s_ea_block_cache)
+
 static inline const struct xattr_handler *
 ext2_xattr_handler(int name_index)
 {
@@ -150,7 +152,7 @@ ext2_xattr_get(struct inode *inode, int name_index, const char *name,
        size_t name_len, size;
        char *end;
        int error;
-       struct mb_cache *ext2_mb_cache = EXT2_SB(inode->i_sb)->s_mb_cache;
+       struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
 
        ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
                  name_index, name, buffer, (long)buffer_size);
@@ -195,7 +197,7 @@ bad_block:  ext2_error(inode->i_sb, "ext2_xattr_get",
                        goto found;
                entry = next;
        }
-       if (ext2_xattr_cache_insert(ext2_mb_cache, bh))
+       if (ext2_xattr_cache_insert(ea_block_cache, bh))
                ea_idebug(inode, "cache insert failed");
        error = -ENODATA;
        goto cleanup;
@@ -208,7 +210,7 @@ found:
            le16_to_cpu(entry->e_value_offs) + size > inode->i_sb->s_blocksize)
                goto bad_block;
 
-       if (ext2_xattr_cache_insert(ext2_mb_cache, bh))
+       if (ext2_xattr_cache_insert(ea_block_cache, bh))
                ea_idebug(inode, "cache insert failed");
        if (buffer) {
                error = -ERANGE;
@@ -246,7 +248,7 @@ ext2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size)
        char *end;
        size_t rest = buffer_size;
        int error;
-       struct mb_cache *ext2_mb_cache = EXT2_SB(inode->i_sb)->s_mb_cache;
+       struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
 
        ea_idebug(inode, "buffer=%p, buffer_size=%ld",
                  buffer, (long)buffer_size);
@@ -281,7 +283,7 @@ bad_block:  ext2_error(inode->i_sb, "ext2_xattr_list",
                        goto bad_block;
                entry = next;
        }
-       if (ext2_xattr_cache_insert(ext2_mb_cache, bh))
+       if (ext2_xattr_cache_insert(ea_block_cache, bh))
                ea_idebug(inode, "cache insert failed");
 
        /* list the attribute names */
@@ -493,7 +495,7 @@ bad_block:          ext2_error(sb, "ext2_xattr_set",
                         * This must happen under buffer lock for
                         * ext2_xattr_set2() to reliably detect modified block
                         */
-                       mb_cache_entry_delete(EXT2_SB(sb)->s_mb_cache, hash,
+                       mb_cache_entry_delete(EA_BLOCK_CACHE(inode), hash,
                                              bh->b_blocknr);
 
                        /* keep the buffer locked while modifying it. */
@@ -627,7 +629,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
        struct super_block *sb = inode->i_sb;
        struct buffer_head *new_bh = NULL;
        int error;
-       struct mb_cache *ext2_mb_cache = EXT2_SB(sb)->s_mb_cache;
+       struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
 
        if (header) {
                new_bh = ext2_xattr_cache_find(inode, header);
@@ -655,7 +657,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                           don't need to change the reference count. */
                        new_bh = old_bh;
                        get_bh(new_bh);
-                       ext2_xattr_cache_insert(ext2_mb_cache, new_bh);
+                       ext2_xattr_cache_insert(ea_block_cache, new_bh);
                } else {
                        /* We need to allocate a new block */
                        ext2_fsblk_t goal = ext2_group_first_block_no(sb,
@@ -676,7 +678,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                        memcpy(new_bh->b_data, header, new_bh->b_size);
                        set_buffer_uptodate(new_bh);
                        unlock_buffer(new_bh);
-                       ext2_xattr_cache_insert(ext2_mb_cache, new_bh);
+                       ext2_xattr_cache_insert(ea_block_cache, new_bh);
                        
                        ext2_xattr_update_super_block(sb);
                }
@@ -721,7 +723,7 @@ ext2_xattr_set2(struct inode *inode, struct buffer_head *old_bh,
                         * This must happen under buffer lock for
                         * ext2_xattr_set2() to reliably detect freed block
                         */
-                       mb_cache_entry_delete(ext2_mb_cache, hash,
+                       mb_cache_entry_delete(ea_block_cache, hash,
                                              old_bh->b_blocknr);
                        /* Free the old block. */
                        ea_bdebug(old_bh, "freeing");
@@ -795,7 +797,7 @@ ext2_xattr_delete_inode(struct inode *inode)
                 * This must happen under buffer lock for ext2_xattr_set2() to
                 * reliably detect freed block
                 */
-               mb_cache_entry_delete(EXT2_SB(inode->i_sb)->s_mb_cache, hash,
+               mb_cache_entry_delete(EA_BLOCK_CACHE(inode), hash,
                                      bh->b_blocknr);
                ext2_free_blocks(inode, EXT2_I(inode)->i_file_acl, 1);
                get_bh(bh);
@@ -897,13 +899,13 @@ ext2_xattr_cache_find(struct inode *inode, struct ext2_xattr_header *header)
 {
        __u32 hash = le32_to_cpu(header->h_hash);
        struct mb_cache_entry *ce;
-       struct mb_cache *ext2_mb_cache = EXT2_SB(inode->i_sb)->s_mb_cache;
+       struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
 
        if (!header->h_hash)
                return NULL;  /* never share */
        ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
 again:
-       ce = mb_cache_entry_find_first(ext2_mb_cache, hash);
+       ce = mb_cache_entry_find_first(ea_block_cache, hash);
        while (ce) {
                struct buffer_head *bh;
 
@@ -924,7 +926,7 @@ again:
                         * entry is still hashed is reliable.
                         */
                        if (hlist_bl_unhashed(&ce->e_hash_list)) {
-                               mb_cache_entry_put(ext2_mb_cache, ce);
+                               mb_cache_entry_put(ea_block_cache, ce);
                                unlock_buffer(bh);
                                brelse(bh);
                                goto again;
@@ -937,14 +939,14 @@ again:
                        } else if (!ext2_xattr_cmp(header, HDR(bh))) {
                                ea_bdebug(bh, "b_count=%d",
                                          atomic_read(&(bh->b_count)));
-                               mb_cache_entry_touch(ext2_mb_cache, ce);
-                               mb_cache_entry_put(ext2_mb_cache, ce);
+                               mb_cache_entry_touch(ea_block_cache, ce);
+                               mb_cache_entry_put(ea_block_cache, ce);
                                return bh;
                        }
                        unlock_buffer(bh);
                        brelse(bh);
                }
-               ce = mb_cache_entry_find_next(ext2_mb_cache, ce);
+               ce = mb_cache_entry_find_next(ea_block_cache, ce);
        }
        return NULL;
 }

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 6b7c517498c9e03f1c379b89cafbf103a7a858c8..caf004d0d1b3c8d4cadb92985c24c43251b6c18f 100644 (file)
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1516,7 +1516,7 @@ struct ext4_sb_info {
        struct list_head s_es_list;     /* List of inodes with reclaimable extents */
        long s_es_nr_inode;
        struct ext4_es_stats s_es_stats;
-       struct mb_cache *s_mb_cache;
+       struct mb_cache *s_ea_block_cache;
        spinlock_t s_es_lock ____cacheline_aligned_in_smp;
 
        /* Ratelimit ext4 messages. */

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index b02a23ec92ca058ce5cefb72c7ce30e832fe4b2a..380389740575154ce987a82fd2c8843065cb290b 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -927,9 +927,9 @@ static void ext4_put_super(struct super_block *sb)
                invalidate_bdev(sbi->journal_bdev);
                ext4_blkdev_remove(sbi);
        }
-       if (sbi->s_mb_cache) {
-               ext4_xattr_destroy_cache(sbi->s_mb_cache);
-               sbi->s_mb_cache = NULL;
+       if (sbi->s_ea_block_cache) {
+               ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
+               sbi->s_ea_block_cache = NULL;
        }
        if (sbi->s_mmp_tsk)
                kthread_stop(sbi->s_mmp_tsk);
@@ -4061,9 +4061,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
        sbi->s_journal->j_commit_callback = ext4_journal_commit_callback;
 
 no_journal:
-       sbi->s_mb_cache = ext4_xattr_create_cache();
-       if (!sbi->s_mb_cache) {
-               ext4_msg(sb, KERN_ERR, "Failed to create an mb_cache");
+       sbi->s_ea_block_cache = ext4_xattr_create_cache();
+       if (!sbi->s_ea_block_cache) {
+               ext4_msg(sb, KERN_ERR, "Failed to create ea_block_cache");
                goto failed_mount_wq;
        }
 
@@ -4296,9 +4296,9 @@ failed_mount4:
        if (EXT4_SB(sb)->rsv_conversion_wq)
                destroy_workqueue(EXT4_SB(sb)->rsv_conversion_wq);
 failed_mount_wq:
-       if (sbi->s_mb_cache) {
-               ext4_xattr_destroy_cache(sbi->s_mb_cache);
-               sbi->s_mb_cache = NULL;
+       if (sbi->s_ea_block_cache) {
+               ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
+               sbi->s_ea_block_cache = NULL;
        }
        if (sbi->s_journal) {
                jbd2_journal_destroy(sbi->s_journal);

diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index 85da7792afd00b3a2c16852c1210bcd03dc8c01c..53980ee164edb52cbbfe9085f49164e5728737a4 100644 (file)
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -72,10 +72,11 @@
 # define ea_bdebug(bh, fmt, ...)       no_printk(fmt, ##__VA_ARGS__)
 #endif
 
-static void ext4_xattr_cache_insert(struct mb_cache *, struct buffer_head *);
-static struct buffer_head *ext4_xattr_cache_find(struct inode *,
-                                                struct ext4_xattr_header *,
-                                                struct mb_cache_entry **);
+static void ext4_xattr_block_cache_insert(struct mb_cache *,
+                                         struct buffer_head *);
+static struct buffer_head *
+ext4_xattr_block_cache_find(struct inode *, struct ext4_xattr_header *,
+                           struct mb_cache_entry **);
 static void ext4_xattr_rehash(struct ext4_xattr_header *,
                              struct ext4_xattr_entry *);
 
@@ -104,8 +105,8 @@ const struct xattr_handler *ext4_xattr_handlers[] = {
        NULL
 };
 
-#define EXT4_GET_MB_CACHE(inode)       (((struct ext4_sb_info *) \
-                               inode->i_sb->s_fs_info)->s_mb_cache)
+#define EA_BLOCK_CACHE(inode)  (((struct ext4_sb_info *) \
+                               inode->i_sb->s_fs_info)->s_ea_block_cache)
 
 #ifdef CONFIG_LOCKDEP
 void ext4_xattr_inode_set_class(struct inode *ea_inode)
@@ -374,7 +375,7 @@ ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
        struct ext4_xattr_entry *entry;
        size_t size;
        int error;
-       struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
+       struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
 
        ea_idebug(inode, "name=%d.%s, buffer=%p, buffer_size=%ld",
                  name_index, name, buffer, (long)buffer_size);
@@ -395,7 +396,7 @@ ext4_xattr_block_get(struct inode *inode, int name_index, const char *name,
                error = -EFSCORRUPTED;
                goto cleanup;
        }
-       ext4_xattr_cache_insert(ext4_mb_cache, bh);
+       ext4_xattr_block_cache_insert(ea_block_cache, bh);
        entry = BFIRST(bh);
        error = ext4_xattr_find_entry(&entry, name_index, name, 1);
        if (error)
@@ -541,7 +542,6 @@ ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
        struct inode *inode = d_inode(dentry);
        struct buffer_head *bh = NULL;
        int error;
-       struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
 
        ea_idebug(inode, "buffer=%p, buffer_size=%ld",
                  buffer, (long)buffer_size);
@@ -563,7 +563,7 @@ ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size)
                error = -EFSCORRUPTED;
                goto cleanup;
        }
-       ext4_xattr_cache_insert(ext4_mb_cache, bh);
+       ext4_xattr_block_cache_insert(EA_BLOCK_CACHE(inode), bh);
        error = ext4_xattr_list_entries(dentry, BFIRST(bh), buffer, buffer_size);
 
 cleanup:
@@ -660,7 +660,7 @@ static void
 ext4_xattr_release_block(handle_t *handle, struct inode *inode,
                         struct buffer_head *bh)
 {
-       struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
+       struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
        u32 hash, ref;
        int error = 0;
 
@@ -678,7 +678,7 @@ ext4_xattr_release_block(handle_t *handle, struct inode *inode,
                 * This must happen under buffer lock for
                 * ext4_xattr_block_set() to reliably detect freed block
                 */
-               mb_cache_entry_delete(ext4_mb_cache, hash, bh->b_blocknr);
+               mb_cache_entry_delete(ea_block_cache, hash, bh->b_blocknr);
                get_bh(bh);
                unlock_buffer(bh);
                ext4_free_blocks(handle, inode, bh, 0, 1,
@@ -690,11 +690,11 @@ ext4_xattr_release_block(handle_t *handle, struct inode *inode,
                if (ref == EXT4_XATTR_REFCOUNT_MAX - 1) {
                        struct mb_cache_entry *ce;
 
-                       ce = mb_cache_entry_get(ext4_mb_cache, hash,
+                       ce = mb_cache_entry_get(ea_block_cache, hash,
                                                bh->b_blocknr);
                        if (ce) {
                                ce->e_reusable = 1;
-                               mb_cache_entry_put(ext4_mb_cache, ce);
+                               mb_cache_entry_put(ea_block_cache, ce);
                        }
                }
 
@@ -1094,7 +1094,7 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode,
        struct ext4_xattr_search *s = &s_copy;
        struct mb_cache_entry *ce = NULL;
        int error = 0;
-       struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
+       struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
 
 #define header(x) ((struct ext4_xattr_header *)(x))
 
@@ -1113,7 +1113,7 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode,
                         * ext4_xattr_block_set() to reliably detect modified
                         * block
                         */
-                       mb_cache_entry_delete(ext4_mb_cache, hash,
+                       mb_cache_entry_delete(ea_block_cache, hash,
                                              bs->bh->b_blocknr);
                        ea_bdebug(bs->bh, "modifying in-place");
                        error = ext4_xattr_set_entry(i, s, handle, inode);
@@ -1121,8 +1121,8 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode,
                                if (!IS_LAST_ENTRY(s->first))
                                        ext4_xattr_rehash(header(s->base),
                                                          s->here);
-                               ext4_xattr_cache_insert(ext4_mb_cache,
-                                       bs->bh);
+                               ext4_xattr_block_cache_insert(ea_block_cache,
+                                                             bs->bh);
                        }
                        ext4_xattr_block_csum_set(inode, bs->bh);
                        unlock_buffer(bs->bh);
@@ -1175,7 +1175,8 @@ ext4_xattr_block_set(handle_t *handle, struct inode *inode,
 
 inserted:
        if (!IS_LAST_ENTRY(s->first)) {
-               new_bh = ext4_xattr_cache_find(inode, header(s->base), &ce);
+               new_bh = ext4_xattr_block_cache_find(inode, header(s->base),
+                                                    &ce);
                if (new_bh) {
                        /* We found an identical block in the cache. */
                        if (new_bh == bs->bh)
@@ -1220,7 +1221,7 @@ inserted:
                                                         EXT4_C2B(EXT4_SB(sb),
                                                                  1));
                                        brelse(new_bh);
-                                       mb_cache_entry_put(ext4_mb_cache, ce);
+                                       mb_cache_entry_put(ea_block_cache, ce);
                                        ce = NULL;
                                        new_bh = NULL;
                                        goto inserted;
@@ -1239,8 +1240,8 @@ inserted:
                                if (error)
                                        goto cleanup_dquot;
                        }
-                       mb_cache_entry_touch(ext4_mb_cache, ce);
-                       mb_cache_entry_put(ext4_mb_cache, ce);
+                       mb_cache_entry_touch(ea_block_cache, ce);
+                       mb_cache_entry_put(ea_block_cache, ce);
                        ce = NULL;
                } else if (bs->bh && s->base == bs->bh->b_data) {
                        /* We were modifying this block in-place. */
@@ -1290,7 +1291,7 @@ getblk_failed:
                        ext4_xattr_block_csum_set(inode, new_bh);
                        set_buffer_uptodate(new_bh);
                        unlock_buffer(new_bh);
-                       ext4_xattr_cache_insert(ext4_mb_cache, new_bh);
+                       ext4_xattr_block_cache_insert(ea_block_cache, new_bh);
                        error = ext4_handle_dirty_metadata(handle, inode,
                                                           new_bh);
                        if (error)
@@ -1308,7 +1309,7 @@ getblk_failed:
 
 cleanup:
        if (ce)
-               mb_cache_entry_put(ext4_mb_cache, ce);
+               mb_cache_entry_put(ea_block_cache, ce);
        brelse(new_bh);
        if (!(bs->bh && s->base == bs->bh->b_data))
                kfree(s->base);
@@ -2148,15 +2149,16 @@ void ext4_xattr_inode_array_free(struct ext4_xattr_inode_array *ea_inode_array)
 }
 
 /*
- * ext4_xattr_cache_insert()
+ * ext4_xattr_block_cache_insert()
  *
- * Create a new entry in the extended attribute cache, and insert
+ * Create a new entry in the extended attribute block cache, and insert
  * it unless such an entry is already in the cache.
  *
  * Returns 0, or a negative error number on failure.
  */
 static void
-ext4_xattr_cache_insert(struct mb_cache *ext4_mb_cache, struct buffer_head *bh)
+ext4_xattr_block_cache_insert(struct mb_cache *ea_block_cache,
+                             struct buffer_head *bh)
 {
        struct ext4_xattr_header *header = BHDR(bh);
        __u32 hash = le32_to_cpu(header->h_hash);
@@ -2164,7 +2166,7 @@ ext4_xattr_cache_insert(struct mb_cache *ext4_mb_cache, struct buffer_head *bh)
                       EXT4_XATTR_REFCOUNT_MAX;
        int error;
 
-       error = mb_cache_entry_create(ext4_mb_cache, GFP_NOFS, hash,
+       error = mb_cache_entry_create(ea_block_cache, GFP_NOFS, hash,
                                      bh->b_blocknr, reusable);
        if (error) {
                if (error == -EBUSY)
@@ -2214,7 +2216,7 @@ ext4_xattr_cmp(struct ext4_xattr_header *header1,
 }
 
 /*
- * ext4_xattr_cache_find()
+ * ext4_xattr_block_cache_find()
  *
  * Find an identical extended attribute block.
  *
@@ -2222,17 +2224,18 @@ ext4_xattr_cmp(struct ext4_xattr_header *header1,
  * not found or an error occurred.
  */
 static struct buffer_head *
-ext4_xattr_cache_find(struct inode *inode, struct ext4_xattr_header *header,
-                     struct mb_cache_entry **pce)
+ext4_xattr_block_cache_find(struct inode *inode,
+                           struct ext4_xattr_header *header,
+                           struct mb_cache_entry **pce)
 {
        __u32 hash = le32_to_cpu(header->h_hash);
        struct mb_cache_entry *ce;
-       struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode);
+       struct mb_cache *ea_block_cache = EA_BLOCK_CACHE(inode);
 
        if (!header->h_hash)
                return NULL;  /* never share */
        ea_idebug(inode, "looking for cached blocks [%x]", (int)hash);
-       ce = mb_cache_entry_find_first(ext4_mb_cache, hash);
+       ce = mb_cache_entry_find_first(ea_block_cache, hash);
        while (ce) {
                struct buffer_head *bh;
 
@@ -2245,7 +2248,7 @@ ext4_xattr_cache_find(struct inode *inode, struct ext4_xattr_header *header,
                        return bh;
                }
                brelse(bh);
-               ce = mb_cache_entry_find_next(ext4_mb_cache, ce);
+               ce = mb_cache_entry_find_next(ea_block_cache, ce);
        }
        return NULL;
 }