Merge tag 'for-linus-20170713' of git://git.infradead.org/linux-mtd

[karo-tx-linux.git] / fs / ext2 / xattr.c

diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index fbdb8f17189366ede18ba20754d4db30c7e867b9..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,8 +495,8 @@ 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_block(EXT2_SB(sb)->s_mb_cache,
-                                                   hash, bh->b_blocknr);
+                       mb_cache_entry_delete(EA_BLOCK_CACHE(inode), hash,
+                                             bh->b_blocknr);
 
                        /* keep the buffer locked while modifying it. */
                } else {
@@ -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,8 +723,8 @@ 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_block(ext2_mb_cache,
-                                                   hash, old_bh->b_blocknr);
+                       mb_cache_entry_delete(ea_block_cache, hash,
+                                             old_bh->b_blocknr);
                        /* Free the old block. */
                        ea_bdebug(old_bh, "freeing");
                        ext2_free_blocks(inode, old_bh->b_blocknr, 1);
@@ -795,8 +797,8 @@ 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_block(EXT2_SB(inode->i_sb)->s_mb_cache,
-                                           hash, bh->b_blocknr);
+               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);
                bforget(bh);
@@ -897,21 +899,21 @@ 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;
 
-               bh = sb_bread(inode->i_sb, ce->e_block);
+               bh = sb_bread(inode->i_sb, ce->e_value);
                if (!bh) {
                        ext2_error(inode->i_sb, "ext2_xattr_cache_find",
                                "inode %ld: block %ld read error",
-                               inode->i_ino, (unsigned long) ce->e_block);
+                               inode->i_ino, (unsigned long) ce->e_value);
                } else {
                        lock_buffer(bh);
                        /*
@@ -924,27 +926,27 @@ 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;
                        } else if (le32_to_cpu(HDR(bh)->h_refcount) >
                                   EXT2_XATTR_REFCOUNT_MAX) {
                                ea_idebug(inode, "block %ld refcount %d>%d",
-                                         (unsigned long) ce->e_block,
+                                         (unsigned long) ce->e_value,
                                          le32_to_cpu(HDR(bh)->h_refcount),
                                          EXT2_XATTR_REFCOUNT_MAX);
                        } 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;
 }