btrfs: Make extent-io callbacks that never fail return void

The set/clear bit and the extent split/merge hooks only ever return 0.

 Changing them to return void simplifies the error handling cases later.

 This patch changes the hook prototypes, the single implementation of each,
 and the functions that call them to return void instead.

 Since all four of these hooks execute under a spinlock, they're necessarily
 simple.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
Signed-off-by: Chris Mason <chris.mason@oracle.com>

1 files changed, 14 insertions, 38 deletions

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 5bbdb243bb6f..789d0b23048f 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -254,14 +254,14 @@ static void merge_cb(struct extent_io_tree *tree, struct extent_state *new,
  *
  * This should be called with the tree lock held.
  */
-static int merge_state(struct extent_io_tree *tree,
-                       struct extent_state *state)
+static void merge_state(struct extent_io_tree *tree,
+                        struct extent_state *state)
 {
         struct extent_state *other;
         struct rb_node *other_node;
 
         if (state->state & (EXTENT_IOBITS | EXTENT_BOUNDARY))
-                return 0;
+                return;
 
         other_node = rb_prev(&state->rb_node);
         if (other_node) {
@@ -287,19 +287,13 @@ static int merge_state(struct extent_io_tree *tree,
                         free_extent_state(other);
                 }
         }
-
-        return 0;
 }
 
-static int set_state_cb(struct extent_io_tree *tree,
+static void set_state_cb(struct extent_io_tree *tree,
                          struct extent_state *state, int *bits)
 {
-        if (tree->ops && tree->ops->set_bit_hook) {
-                return tree->ops->set_bit_hook(tree->mapping->host,
-                                               state, bits);
-        }
-
-        return 0;
+        if (tree->ops && tree->ops->set_bit_hook)
+                tree->ops->set_bit_hook(tree->mapping->host, state, bits);
 }
 
 static void clear_state_cb(struct extent_io_tree *tree,
@@ -325,7 +319,6 @@ static int insert_state(struct extent_io_tree *tree,
 {
         struct rb_node *node;
         int bits_to_set = *bits & ~EXTENT_CTLBITS;
-        int ret;
 
         if (end < start) {
                 printk(KERN_ERR "btrfs end < start %llu %llu\n",
@@ -335,9 +328,7 @@ static int insert_state(struct extent_io_tree *tree,
         }
         state->start = start;
         state->end = end;
-        ret = set_state_cb(tree, state, bits);
-        if (ret)
-                return ret;
+        set_state_cb(tree, state, bits);
 
         if (bits_to_set & EXTENT_DIRTY)
                 tree->dirty_bytes += end - start + 1;
@@ -357,13 +348,11 @@ static int insert_state(struct extent_io_tree *tree,
         return 0;
 }
 
-static int split_cb(struct extent_io_tree *tree, struct extent_state *orig,
+static void split_cb(struct extent_io_tree *tree, struct extent_state *orig,
                      u64 split)
 {
         if (tree->ops && tree->ops->split_extent_hook)
-                return tree->ops->split_extent_hook(tree->mapping->host,
-                                                    orig, split);
-        return 0;
+                tree->ops->split_extent_hook(tree->mapping->host, orig, split);
 }
 
 /*
@@ -670,23 +659,18 @@ out:
         return 0;
 }
 
-static int set_state_bits(struct extent_io_tree *tree,
+static void set_state_bits(struct extent_io_tree *tree,
                            struct extent_state *state,
                            int *bits)
 {
-        int ret;
         int bits_to_set = *bits & ~EXTENT_CTLBITS;
 
-        ret = set_state_cb(tree, state, bits);
-        if (ret)
-                return ret;
+        set_state_cb(tree, state, bits);
         if ((bits_to_set & EXTENT_DIRTY) && !(state->state & EXTENT_DIRTY)) {
                 u64 range = state->end - state->start + 1;
                 tree->dirty_bytes += range;
         }
         state->state |= bits_to_set;
-
-        return 0;
 }
 
 static void cache_state(struct extent_state *state,
@@ -779,9 +763,7 @@ hit_next:
                         goto out;
                 }
 
-                err = set_state_bits(tree, state, &bits);
-                if (err)
-                        goto out;
+                set_state_bits(tree, state, &bits);
 
                 cache_state(state, cached_state);
                 merge_state(tree, state);
@@ -830,9 +812,7 @@ hit_next:
                 if (err)
                         goto out;
                 if (state->end <= end) {
-                        err = set_state_bits(tree, state, &bits);
-                        if (err)
-                                goto out;
+                        set_state_bits(tree, state, &bits);
                         cache_state(state, cached_state);
                         merge_state(tree, state);
                         if (last_end == (u64)-1)
@@ -893,11 +873,7 @@ hit_next:
                 err = split_state(tree, state, prealloc, end + 1);
                 BUG_ON(err == -EEXIST);
 
-                err = set_state_bits(tree, prealloc, &bits);
-                if (err) {
-                        prealloc = NULL;
-                        goto out;
-                }
+                set_state_bits(tree, prealloc, &bits);
                 cache_state(prealloc, cached_state);
                 merge_state(tree, prealloc);
                 prealloc = NULL;