btrfs: open code now trivial btrfs_set_lock_blocking

btrfs_set_lock_blocking is now only a simple wrapper around
btrfs_set_lock_blocking_write. The name does not bring any semantic
value that could not be inferred from the new function so there's no
point keeping it.

Reviewed-by: Johannes Thumshirn <jthumshirn@suse.de>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 75e0f737d7d2bf2b03aa82efaa09b20f1c5b0297..3940d707fcf3de825302358c48696cd605cfa1c4 100644 (file)
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -1487,8 +1487,8 @@ noinline int btrfs_cow_block(struct btrfs_trans_handle *trans,
        search_start = buf->start & ~((u64)SZ_1G - 1);
 
        if (parent)
-               btrfs_set_lock_blocking(parent);
-       btrfs_set_lock_blocking(buf);
+               btrfs_set_lock_blocking_write(parent);
+       btrfs_set_lock_blocking_write(buf);
 
        /*
         * Before CoWing this block for later modification, check if it's
@@ -1590,7 +1590,7 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
        if (parent_nritems <= 1)
                return 0;
 
-       btrfs_set_lock_blocking(parent);
+       btrfs_set_lock_blocking_write(parent);
 
        for (i = start_slot; i <= end_slot; i++) {
                struct btrfs_key first_key;
@@ -1649,7 +1649,7 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
                        search_start = last_block;
 
                btrfs_tree_lock(cur);
-               btrfs_set_lock_blocking(cur);
+               btrfs_set_lock_blocking_write(cur);
                err = __btrfs_cow_block(trans, root, cur, parent, i,
                                        &cur, search_start,
                                        min(16 * blocksize,
@@ -1864,7 +1864,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
                }
 
                btrfs_tree_lock(child);
-               btrfs_set_lock_blocking(child);
+               btrfs_set_lock_blocking_write(child);
                ret = btrfs_cow_block(trans, root, child, mid, 0, &child);
                if (ret) {
                        btrfs_tree_unlock(child);
@@ -1902,7 +1902,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
 
        if (left) {
                btrfs_tree_lock(left);
-               btrfs_set_lock_blocking(left);
+               btrfs_set_lock_blocking_write(left);
                wret = btrfs_cow_block(trans, root, left,
                                       parent, pslot - 1, &left);
                if (wret) {
@@ -1917,7 +1917,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans,
 
        if (right) {
                btrfs_tree_lock(right);
-               btrfs_set_lock_blocking(right);
+               btrfs_set_lock_blocking_write(right);
                wret = btrfs_cow_block(trans, root, right,
                                       parent, pslot + 1, &right);
                if (wret) {
@@ -2080,7 +2080,7 @@ static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans,
                u32 left_nr;
 
                btrfs_tree_lock(left);
-               btrfs_set_lock_blocking(left);
+               btrfs_set_lock_blocking_write(left);
 
                left_nr = btrfs_header_nritems(left);
                if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 1) {
@@ -2135,7 +2135,7 @@ static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans,
                u32 right_nr;
 
                btrfs_tree_lock(right);
-               btrfs_set_lock_blocking(right);
+               btrfs_set_lock_blocking_write(right);
 
                right_nr = btrfs_header_nritems(right);
                if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 1) {
@@ -3779,7 +3779,7 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root
                return 1;
 
        btrfs_tree_lock(right);
-       btrfs_set_lock_blocking(right);
+       btrfs_set_lock_blocking_write(right);
 
        free_space = btrfs_leaf_free_space(fs_info, right);
        if (free_space < data_size)
@@ -4013,7 +4013,7 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root
                return 1;
 
        btrfs_tree_lock(left);
-       btrfs_set_lock_blocking(left);
+       btrfs_set_lock_blocking_write(left);
 
        free_space = btrfs_leaf_free_space(fs_info, left);
        if (free_space < data_size) {

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 74a696d9cd683fd47ca77fb5176a000e19e223e4..4047867473e16ead5445ed2589525687b229aec2 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1121,7 +1121,7 @@ void clean_tree_block(struct btrfs_fs_info *fs_info,
                                                 -buf->len,
                                                 fs_info->dirty_metadata_batch);
                        /* ugh, clear_extent_buffer_dirty needs to lock the page */
-                       btrfs_set_lock_blocking(buf);
+                       btrfs_set_lock_blocking_write(buf);
                        clear_extent_buffer_dirty(buf);
                }
        }

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 1b35a235bf1029f91f60510865d46092938d9927..2f683dad3c665c03d981e5078cdead582965931e 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -8502,7 +8502,7 @@ btrfs_init_new_buffer(struct btrfs_trans_handle *trans, struct btrfs_root *root,
        clean_tree_block(fs_info, buf);
        clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);
 
-       btrfs_set_lock_blocking(buf);
+       btrfs_set_lock_blocking_write(buf);
        set_extent_buffer_uptodate(buf);
 
        memzero_extent_buffer(buf, 0, sizeof(struct btrfs_header));
@@ -8927,7 +8927,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
                reada = 1;
        }
        btrfs_tree_lock(next);
-       btrfs_set_lock_blocking(next);
+       btrfs_set_lock_blocking_write(next);
 
        ret = btrfs_lookup_extent_info(trans, fs_info, bytenr, level - 1, 1,
                                       &wc->refs[level - 1],
@@ -8987,7 +8987,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
                        return -EIO;
                }
                btrfs_tree_lock(next);
-               btrfs_set_lock_blocking(next);
+               btrfs_set_lock_blocking_write(next);
        }
 
        level--;
@@ -9099,7 +9099,7 @@ static noinline int walk_up_proc(struct btrfs_trans_handle *trans,
                if (!path->locks[level]) {
                        BUG_ON(level == 0);
                        btrfs_tree_lock(eb);
-                       btrfs_set_lock_blocking(eb);
+                       btrfs_set_lock_blocking_write(eb);
                        path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
 
                        ret = btrfs_lookup_extent_info(trans, fs_info,
@@ -9141,7 +9141,7 @@ static noinline int walk_up_proc(struct btrfs_trans_handle *trans,
                if (!path->locks[level] &&
                    btrfs_header_generation(eb) == trans->transid) {
                        btrfs_tree_lock(eb);
-                       btrfs_set_lock_blocking(eb);
+                       btrfs_set_lock_blocking_write(eb);
                        path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
                }
                clean_tree_block(fs_info, eb);
@@ -9308,7 +9308,7 @@ int btrfs_drop_snapshot(struct btrfs_root *root,
        if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
                level = btrfs_header_level(root->node);
                path->nodes[level] = btrfs_lock_root_node(root);
-               btrfs_set_lock_blocking(path->nodes[level]);
+               btrfs_set_lock_blocking_write(path->nodes[level]);
                path->slots[level] = 0;
                path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
                memset(&wc->update_progress, 0,
@@ -9338,7 +9338,7 @@ int btrfs_drop_snapshot(struct btrfs_root *root,
                level = btrfs_header_level(root->node);
                while (1) {
                        btrfs_tree_lock(path->nodes[level]);
-                       btrfs_set_lock_blocking(path->nodes[level]);
+                       btrfs_set_lock_blocking_write(path->nodes[level]);
                        path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;
 
                        ret = btrfs_lookup_extent_info(trans, fs_info,

diff --git a/fs/btrfs/locking.h b/fs/btrfs/locking.h
index 9d9f649e35ccf75714b0b1c83fa9e44ee86a3197..84ea6ed60047b10b0d01f6b1922887e041d6b844 100644 (file)
--- a/fs/btrfs/locking.h
+++ b/fs/btrfs/locking.h
@@ -51,9 +51,4 @@ static inline void btrfs_set_lock_blocking_rw(struct extent_buffer *eb, int rw)
                btrfs_set_lock_blocking_read(eb);
 }
 
-static inline void btrfs_set_lock_blocking(struct extent_buffer *eb)
-{
-       btrfs_set_lock_blocking_write(eb);
-}
-
 #endif

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index e04cf11059b51819aa31ad9e5e9186849b95d232..70b85a593b7b11570b0457a900d1cad31b13f9c6 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1777,7 +1777,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc,
        btrfs_node_key_to_cpu(path->nodes[lowest_level], &key, slot);
 
        eb = btrfs_lock_root_node(dest);
-       btrfs_set_lock_blocking(eb);
+       btrfs_set_lock_blocking_write(eb);
        level = btrfs_header_level(eb);
 
        if (level < lowest_level) {
@@ -1790,7 +1790,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc,
                ret = btrfs_cow_block(trans, dest, eb, NULL, 0, &eb);
                BUG_ON(ret);
        }
-       btrfs_set_lock_blocking(eb);
+       btrfs_set_lock_blocking_write(eb);
 
        if (next_key) {
                next_key->objectid = (u64)-1;
@@ -1856,7 +1856,7 @@ int replace_path(struct btrfs_trans_handle *trans, struct reloc_control *rc,
                                                      slot, &eb);
                                BUG_ON(ret);
                        }
-                       btrfs_set_lock_blocking(eb);
+                       btrfs_set_lock_blocking_write(eb);
 
                        btrfs_tree_unlock(parent);
                        free_extent_buffer(parent);
@@ -2797,7 +2797,7 @@ static int do_relocation(struct btrfs_trans_handle *trans,
                        goto next;
                }
                btrfs_tree_lock(eb);
-               btrfs_set_lock_blocking(eb);
+               btrfs_set_lock_blocking_write(eb);
 
                if (!node->eb) {
                        ret = btrfs_cow_block(trans, root, eb, upper->eb,

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 0cc6d8b5819136da66434b04555657fe592a0c82..acdad6d658f54bda7cf9c379867d212a41d1c24b 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -1532,7 +1532,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
                goto fail;
        }
 
-       btrfs_set_lock_blocking(old);
+       btrfs_set_lock_blocking_write(old);
 
        ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
        /* clean up in any case */

diff --git a/fs/btrfs/tree-defrag.c b/fs/btrfs/tree-defrag.c
index 3c0987ab587d5ec33f799b156fe30692f53c42a8..5f9e2dd413af9fbf77bf06f2d579e3cd930c29a7 100644 (file)
--- a/fs/btrfs/tree-defrag.c
+++ b/fs/btrfs/tree-defrag.c
@@ -52,7 +52,7 @@ int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
                u32 nritems;
 
                root_node = btrfs_lock_root_node(root);
-               btrfs_set_lock_blocking(root_node);
+               btrfs_set_lock_blocking_write(root_node);
                nritems = btrfs_header_nritems(root_node);
                root->defrag_max.objectid = 0;
                /* from above we know this is not a leaf */

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index ac232b3d6d7e2f3ba34d991ef8b2a17f96588f13..1a69a45ae926703bcd6484540f3d3559aff1f8aa 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -2663,7 +2663,7 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans,
 
                                if (trans) {
                                        btrfs_tree_lock(next);
-                                       btrfs_set_lock_blocking(next);
+                                       btrfs_set_lock_blocking_write(next);
                                        clean_tree_block(fs_info, next);
                                        btrfs_wait_tree_block_writeback(next);
                                        btrfs_tree_unlock(next);
@@ -2747,7 +2747,7 @@ static noinline int walk_up_log_tree(struct btrfs_trans_handle *trans,
 
                                if (trans) {
                                        btrfs_tree_lock(next);
-                                       btrfs_set_lock_blocking(next);
+                                       btrfs_set_lock_blocking_write(next);
                                        clean_tree_block(fs_info, next);
                                        btrfs_wait_tree_block_writeback(next);
                                        btrfs_tree_unlock(next);
@@ -2829,7 +2829,7 @@ static int walk_log_tree(struct btrfs_trans_handle *trans,
 
                        if (trans) {
                                btrfs_tree_lock(next);
-                               btrfs_set_lock_blocking(next);
+                               btrfs_set_lock_blocking_write(next);
                                clean_tree_block(fs_info, next);
                                btrfs_wait_tree_block_writeback(next);
                                btrfs_tree_unlock(next);