1 files changed, 27 insertions, 33 deletions

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index a1c940425307..bbf6d0d9aebe 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -59,6 +59,14 @@ static struct rb_node *tree_insert(struct rb_root *root, u64 file_offset,
         return NULL;
 }
 
+static void ordered_data_tree_panic(struct inode *inode, int errno,
+                                               u64 offset)
+{
+        struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
+        btrfs_panic(fs_info, errno, "Inconsistency in ordered tree at offset "
+                    "%llu\n", (unsigned long long)offset);
+}
+
 /*
  * look for a given offset in the tree, and if it can't be found return the
  * first lesser offset
@@ -207,7 +215,8 @@ static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
         spin_lock(&tree->lock);
         node = tree_insert(&tree->tree, file_offset,
                            &entry->rb_node);
-        BUG_ON(node);
+        if (node)
+                ordered_data_tree_panic(inode, -EEXIST, file_offset);
         spin_unlock(&tree->lock);
 
         spin_lock(&BTRFS_I(inode)->root->fs_info->ordered_extent_lock);
@@ -215,7 +224,6 @@ static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
                       &BTRFS_I(inode)->root->fs_info->ordered_extents);
         spin_unlock(&BTRFS_I(inode)->root->fs_info->ordered_extent_lock);
 
-        BUG_ON(node);
         return 0;
 }
 
@@ -249,9 +257,9 @@ int btrfs_add_ordered_extent_compress(struct inode *inode, u64 file_offset,
  * when an ordered extent is finished.  If the list covers more than one
  * ordered extent, it is split across multiples.
  */
-int btrfs_add_ordered_sum(struct inode *inode,
-                          struct btrfs_ordered_extent *entry,
-                          struct btrfs_ordered_sum *sum)
+void btrfs_add_ordered_sum(struct inode *inode,
+                           struct btrfs_ordered_extent *entry,
+                           struct btrfs_ordered_sum *sum)
 {
         struct btrfs_ordered_inode_tree *tree;
 
@@ -259,7 +267,6 @@ int btrfs_add_ordered_sum(struct inode *inode,
         spin_lock(&tree->lock);
         list_add_tail(&sum->list, &entry->list);
         spin_unlock(&tree->lock);
-        return 0;
 }
 
 /*
@@ -384,7 +391,7 @@ out:
  * used to drop a reference on an ordered extent.  This will free
  * the extent if the last reference is dropped
  */
-int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
+void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
 {
         struct list_head *cur;
         struct btrfs_ordered_sum *sum;
@@ -400,7 +407,6 @@ int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
                 }
                 kfree(entry);
         }
-        return 0;
 }
 
 /*
@@ -408,8 +414,8 @@ int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
  * and you must wake_up entry->wait.  You must hold the tree lock
  * while you call this function.
  */
-static int __btrfs_remove_ordered_extent(struct inode *inode,
-                                struct btrfs_ordered_extent *entry)
+static void __btrfs_remove_ordered_extent(struct inode *inode,
+                                          struct btrfs_ordered_extent *entry)
 {
         struct btrfs_ordered_inode_tree *tree;
         struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -436,35 +442,30 @@ static int __btrfs_remove_ordered_extent(struct inode *inode,
                 list_del_init(&BTRFS_I(inode)->ordered_operations);
         }
         spin_unlock(&root->fs_info->ordered_extent_lock);
-
-        return 0;
 }
 
 /*
  * remove an ordered extent from the tree.  No references are dropped
  * but any waiters are woken.
  */
-int btrfs_remove_ordered_extent(struct inode *inode,
-                                struct btrfs_ordered_extent *entry)
+void btrfs_remove_ordered_extent(struct inode *inode,
+                                 struct btrfs_ordered_extent *entry)
 {
         struct btrfs_ordered_inode_tree *tree;
-        int ret;
 
         tree = &BTRFS_I(inode)->ordered_tree;
         spin_lock(&tree->lock);
-        ret = __btrfs_remove_ordered_extent(inode, entry);
+        __btrfs_remove_ordered_extent(inode, entry);
         spin_unlock(&tree->lock);
         wake_up(&entry->wait);
-
-        return ret;
 }
 
 /*
  * wait for all the ordered extents in a root.  This is done when balancing
  * space between drives.
  */
-int btrfs_wait_ordered_extents(struct btrfs_root *root,
-                               int nocow_only, int delay_iput)
+void btrfs_wait_ordered_extents(struct btrfs_root *root,
+                                int nocow_only, int delay_iput)
 {
         struct list_head splice;
         struct list_head *cur;
@@ -512,7 +513,6 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root,
                 spin_lock(&root->fs_info->ordered_extent_lock);
         }
         spin_unlock(&root->fs_info->ordered_extent_lock);
-        return 0;
 }
 
 /*
@@ -525,7 +525,7 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root,
  * extra check to make sure the ordered operation list really is empty
  * before we return
  */
-int btrfs_run_ordered_operations(struct btrfs_root *root, int wait)
+void btrfs_run_ordered_operations(struct btrfs_root *root, int wait)
 {
         struct btrfs_inode *btrfs_inode;
         struct inode *inode;
@@ -573,8 +573,6 @@ again:
 
         spin_unlock(&root->fs_info->ordered_extent_lock);
         mutex_unlock(&root->fs_info->ordered_operations_mutex);
-
-        return 0;
 }
 
 /*
@@ -609,7 +607,7 @@ void btrfs_start_ordered_extent(struct inode *inode,
 /*
  * Used to wait on ordered extents across a large range of bytes.
  */
-int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
+void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
 {
         u64 end;
         u64 orig_end;
@@ -664,7 +662,6 @@ again:
                 schedule_timeout(1);
                 goto again;
         }
-        return 0;
 }
 
 /*
@@ -948,9 +945,8 @@ out:
  * If trans is not null, we'll do a friendly check for a transaction that
  * is already flushing things and force the IO down ourselves.
  */
-int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
-                                struct btrfs_root *root,
-                                struct inode *inode)
+void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
+                                 struct btrfs_root *root, struct inode *inode)
 {
         u64 last_mod;
 
@@ -961,7 +957,7 @@ int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
          * commit, we can safely return without doing anything
          */
         if (last_mod < root->fs_info->last_trans_committed)
-                return 0;
+                return;
 
         /*
          * the transaction is already committing.  Just start the IO and
@@ -969,7 +965,7 @@ int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
          */
         if (trans && root->fs_info->running_transaction->blocked) {
                 btrfs_wait_ordered_range(inode, 0, (u64)-1);
-                return 0;
+                return;
         }
 
         spin_lock(&root->fs_info->ordered_extent_lock);
@@ -978,6 +974,4 @@ int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans,
                               &root->fs_info->ordered_operations);
         }
         spin_unlock(&root->fs_info->ordered_extent_lock);
-
-        return 0;
 }