btrfs: fix memory leaks after failure to lookup checksums during inode logging

[linux-2.6-microblaze.git] / fs / btrfs / free-space-cache.c

diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 55955bd..ef0fd7a 100644 (file)
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -1334,8 +1334,9 @@ static int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
        io_ctl_zero_remaining_pages(io_ctl);
 
        /* Everything is written out, now we dirty the pages in the file. */
-       ret = btrfs_dirty_pages(inode, io_ctl->pages, io_ctl->num_pages, 0,
-                               i_size_read(inode), &cached_state);
+       ret = btrfs_dirty_pages(BTRFS_I(inode), io_ctl->pages,
+                               io_ctl->num_pages, 0, i_size_read(inode),
+                               &cached_state);
        if (ret)
                goto out_nospc;
 
@@ -2281,7 +2282,7 @@ out:
 static bool try_merge_free_space(struct btrfs_free_space_ctl *ctl,
                          struct btrfs_free_space *info, bool update_stat)
 {
-       struct btrfs_free_space *left_info;
+       struct btrfs_free_space *left_info = NULL;
        struct btrfs_free_space *right_info;
        bool merged = false;
        u64 offset = info->offset;
@@ -2297,7 +2298,7 @@ static bool try_merge_free_space(struct btrfs_free_space_ctl *ctl,
        if (right_info && rb_prev(&right_info->offset_index))
                left_info = rb_entry(rb_prev(&right_info->offset_index),
                                     struct btrfs_free_space, offset_index);
-       else
+       else if (!right_info)
                left_info = tree_search_offset(ctl, offset - 1, 0, 0);
 
        /* See try_merge_free_space() comment. */
@@ -2703,8 +2704,7 @@ void btrfs_init_free_space_ctl(struct btrfs_block_group *block_group)
  * pointed to by the cluster, someone else raced in and freed the
  * cluster already.  In that case, we just return without changing anything
  */
-static int
-__btrfs_return_cluster_to_free_space(
+static void __btrfs_return_cluster_to_free_space(
                             struct btrfs_block_group *block_group,
                             struct btrfs_free_cluster *cluster)
 {
@@ -2756,7 +2756,6 @@ __btrfs_return_cluster_to_free_space(
 out:
        spin_unlock(&cluster->lock);
        btrfs_put_block_group(block_group);
-       return 0;
 }
 
 static void __btrfs_remove_free_space_cache_locked(
@@ -2907,12 +2906,11 @@ out:
  * Otherwise, it'll get a reference on the block group pointed to by the
  * cluster and remove the cluster from it.
  */
-int btrfs_return_cluster_to_free_space(
+void btrfs_return_cluster_to_free_space(
                               struct btrfs_block_group *block_group,
                               struct btrfs_free_cluster *cluster)
 {
        struct btrfs_free_space_ctl *ctl;
-       int ret;
 
        /* first, get a safe pointer to the block group */
        spin_lock(&cluster->lock);
@@ -2920,28 +2918,27 @@ int btrfs_return_cluster_to_free_space(
                block_group = cluster->block_group;
                if (!block_group) {
                        spin_unlock(&cluster->lock);
-                       return 0;
+                       return;
                }
        } else if (cluster->block_group != block_group) {
                /* someone else has already freed it don't redo their work */
                spin_unlock(&cluster->lock);
-               return 0;
+               return;
        }
-       atomic_inc(&block_group->count);
+       btrfs_get_block_group(block_group);
        spin_unlock(&cluster->lock);
 
        ctl = block_group->free_space_ctl;
 
        /* now return any extents the cluster had on it */
        spin_lock(&ctl->tree_lock);
-       ret = __btrfs_return_cluster_to_free_space(block_group, cluster);
+       __btrfs_return_cluster_to_free_space(block_group, cluster);
        spin_unlock(&ctl->tree_lock);
 
        btrfs_discard_queue_work(&block_group->fs_info->discard_ctl, block_group);
 
        /* finally drop our ref */
        btrfs_put_block_group(block_group);
-       return ret;
 }
 
 static u64 btrfs_alloc_from_bitmap(struct btrfs_block_group *block_group,
@@ -3358,7 +3355,7 @@ int btrfs_find_space_cluster(struct btrfs_block_group *block_group,
                list_del_init(&entry->list);
 
        if (!ret) {
-               atomic_inc(&block_group->count);
+               btrfs_get_block_group(block_group);
                list_add_tail(&cluster->block_group_list,
                              &block_group->cluster_list);
                cluster->block_group = block_group;