btrfs: avoid tree mod log ENOMEM failures when we don't need to log

When logging tree mod log operations we start by checking, in a lockless
manner, if we need to log - if we don't, we just return and do nothing,
otherwise we will allocate one or more tree mod log operations and then
check again if we need to log. This second check will take the tree mod
log lock in write mode if we need to log, otherwise it will do nothing
and we just free the allocated memory and return success.

We can improve on this by not returning an error in case the memory
allocations fail, unless the second check tells us that we actually need
to log. That is, if we fail to allocate memory and the second check tells
use that we don't need to log, we can just return success and avoid
returning -ENOMEM to the caller. Currently tree mod log failures are
dealt with either a BUG_ON() or a transaction abort, as tree mod log
operations are logged in code paths that modify a b+tree.

So just avoid failing with -ENOMEM if we fail to allocate a tree mod log
operation unless we actually need to log the operations, that is, if
tree_mod_dont_log() returns true.

Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/tree-mod-log.c b/fs/btrfs/tree-mod-log.c
index 07c086f9e35e94be8e8fcad28ffaf7a141925313..3df6153d5d5a8015399dee164edb9bb7797e114f 100644 (file)
--- a/fs/btrfs/tree-mod-log.c
+++ b/fs/btrfs/tree-mod-log.c
@@ -226,21 +226,32 @@ int btrfs_tree_mod_log_insert_key(struct extent_buffer *eb, int slot,
                                  enum btrfs_mod_log_op op)
 {
        struct tree_mod_elem *tm;
-       int ret;
+       int ret = 0;
 
        if (!tree_mod_need_log(eb->fs_info, eb))
                return 0;
 
        tm = alloc_tree_mod_elem(eb, slot, op);
        if (!tm)
-               return -ENOMEM;
+               ret = -ENOMEM;
 
        if (tree_mod_dont_log(eb->fs_info, eb)) {
                kfree(tm);
+               /*
+                * Don't error if we failed to allocate memory because we don't
+                * need to log.
+                */
                return 0;
+       } else if (ret != 0) {
+               /*
+                * We previously failed to allocate memory and we need to log,
+                * so we have to fail.
+                */
+               goto out_unlock;
        }
 
        ret = tree_mod_log_insert(eb->fs_info, tm);
+out_unlock:
        write_unlock(&eb->fs_info->tree_mod_log_lock);
        if (ret)
                kfree(tm);
@@ -282,14 +293,16 @@ int btrfs_tree_mod_log_insert_move(struct extent_buffer *eb,
                return 0;
 
        tm_list = kcalloc(nr_items, sizeof(struct tree_mod_elem *), GFP_NOFS);
-       if (!tm_list)
-               return -ENOMEM;
+       if (!tm_list) {
+               ret = -ENOMEM;
+               goto lock;
+       }
 
        tm = tree_mod_log_alloc_move(eb, dst_slot, src_slot, nr_items);
        if (IS_ERR(tm)) {
                ret = PTR_ERR(tm);
                tm = NULL;
-               goto free_tms;
+               goto lock;
        }
 
        for (i = 0; i + dst_slot < src_slot && i < nr_items; i++) {
@@ -297,14 +310,28 @@ int btrfs_tree_mod_log_insert_move(struct extent_buffer *eb,
                                BTRFS_MOD_LOG_KEY_REMOVE_WHILE_MOVING);
                if (!tm_list[i]) {
                        ret = -ENOMEM;
-                       goto free_tms;
+                       goto lock;
                }
        }
 
-       if (tree_mod_dont_log(eb->fs_info, eb))
+lock:
+       if (tree_mod_dont_log(eb->fs_info, eb)) {
+               /*
+                * Don't error if we failed to allocate memory because we don't
+                * need to log.
+                */
+               ret = 0;
                goto free_tms;
+       }
        locked = true;
 
+       /*
+        * We previously failed to allocate memory and we need to log, so we
+        * have to fail.
+        */
+       if (ret != 0)
+               goto free_tms;
+
        /*
         * When we override something during the move, we log these removals.
         * This can only happen when we move towards the beginning of the
@@ -325,10 +352,12 @@ int btrfs_tree_mod_log_insert_move(struct extent_buffer *eb,
        return 0;
 
 free_tms:
-       for (i = 0; i < nr_items; i++) {
-               if (tm_list[i] && !RB_EMPTY_NODE(&tm_list[i]->node))
-                       rb_erase(&tm_list[i]->node, &eb->fs_info->tree_mod_log);
-               kfree(tm_list[i]);
+       if (tm_list) {
+               for (i = 0; i < nr_items; i++) {
+                       if (tm_list[i] && !RB_EMPTY_NODE(&tm_list[i]->node))
+                               rb_erase(&tm_list[i]->node, &eb->fs_info->tree_mod_log);
+                       kfree(tm_list[i]);
+               }
        }
        if (locked)
                write_unlock(&eb->fs_info->tree_mod_log_lock);
@@ -378,14 +407,14 @@ int btrfs_tree_mod_log_insert_root(struct extent_buffer *old_root,
                                  GFP_NOFS);
                if (!tm_list) {
                        ret = -ENOMEM;
-                       goto free_tms;
+                       goto lock;
                }
                for (i = 0; i < nritems; i++) {
                        tm_list[i] = alloc_tree_mod_elem(old_root, i,
                            BTRFS_MOD_LOG_KEY_REMOVE_WHILE_FREEING);
                        if (!tm_list[i]) {
                                ret = -ENOMEM;
-                               goto free_tms;
+                               goto lock;
                        }
                }
        }
@@ -393,7 +422,7 @@ int btrfs_tree_mod_log_insert_root(struct extent_buffer *old_root,
        tm = kzalloc(sizeof(*tm), GFP_NOFS);
        if (!tm) {
                ret = -ENOMEM;
-               goto free_tms;
+               goto lock;
        }
 
        tm->logical = new_root->start;
@@ -402,14 +431,28 @@ int btrfs_tree_mod_log_insert_root(struct extent_buffer *old_root,
        tm->generation = btrfs_header_generation(old_root);
        tm->op = BTRFS_MOD_LOG_ROOT_REPLACE;
 
-       if (tree_mod_dont_log(fs_info, NULL))
+lock:
+       if (tree_mod_dont_log(fs_info, NULL)) {
+               /*
+                * Don't error if we failed to allocate memory because we don't
+                * need to log.
+                */
+               ret = 0;
                goto free_tms;
+       } else if (ret != 0) {
+               /*
+                * We previously failed to allocate memory and we need to log,
+                * so we have to fail.
+                */
+               goto out_unlock;
+       }
 
        if (tm_list)
                ret = tree_mod_log_free_eb(fs_info, tm_list, nritems);
        if (!ret)
                ret = tree_mod_log_insert(fs_info, tm);
 
+out_unlock:
        write_unlock(&fs_info->tree_mod_log_lock);
        if (ret)
                goto free_tms;
@@ -501,7 +544,8 @@ int btrfs_tree_mod_log_eb_copy(struct extent_buffer *dst,
        struct btrfs_fs_info *fs_info = dst->fs_info;
        int ret = 0;
        struct tree_mod_elem **tm_list = NULL;
-       struct tree_mod_elem **tm_list_add, **tm_list_rem;
+       struct tree_mod_elem **tm_list_add = NULL;
+       struct tree_mod_elem **tm_list_rem = NULL;
        int i;
        bool locked = false;
        struct tree_mod_elem *dst_move_tm = NULL;
@@ -517,8 +561,10 @@ int btrfs_tree_mod_log_eb_copy(struct extent_buffer *dst,
 
        tm_list = kcalloc(nr_items * 2, sizeof(struct tree_mod_elem *),
                          GFP_NOFS);
-       if (!tm_list)
-               return -ENOMEM;
+       if (!tm_list) {
+               ret = -ENOMEM;
+               goto lock;
+       }
 
        if (dst_move_nr_items) {
                dst_move_tm = tree_mod_log_alloc_move(dst, dst_offset + nr_items,
@@ -526,7 +572,7 @@ int btrfs_tree_mod_log_eb_copy(struct extent_buffer *dst,
                if (IS_ERR(dst_move_tm)) {
                        ret = PTR_ERR(dst_move_tm);
                        dst_move_tm = NULL;
-                       goto free_tms;
+                       goto lock;
                }
        }
        if (src_move_nr_items) {
@@ -536,7 +582,7 @@ int btrfs_tree_mod_log_eb_copy(struct extent_buffer *dst,
                if (IS_ERR(src_move_tm)) {
                        ret = PTR_ERR(src_move_tm);
                        src_move_tm = NULL;
-                       goto free_tms;
+                       goto lock;
                }
        }
 
@@ -547,21 +593,35 @@ int btrfs_tree_mod_log_eb_copy(struct extent_buffer *dst,
                                                     BTRFS_MOD_LOG_KEY_REMOVE);
                if (!tm_list_rem[i]) {
                        ret = -ENOMEM;
-                       goto free_tms;
+                       goto lock;
                }
 
                tm_list_add[i] = alloc_tree_mod_elem(dst, i + dst_offset,
                                                     BTRFS_MOD_LOG_KEY_ADD);
                if (!tm_list_add[i]) {
                        ret = -ENOMEM;
-                       goto free_tms;
+                       goto lock;
                }
        }
 
-       if (tree_mod_dont_log(fs_info, NULL))
+lock:
+       if (tree_mod_dont_log(fs_info, NULL)) {
+               /*
+                * Don't error if we failed to allocate memory because we don't
+                * need to log.
+                */
+               ret = 0;
                goto free_tms;
+       }
        locked = true;
 
+       /*
+        * We previously failed to allocate memory and we need to log, so we
+        * have to fail.
+        */
+       if (ret != 0)
+               goto free_tms;
+
        if (dst_move_tm) {
                ret = tree_mod_log_insert(fs_info, dst_move_tm);
                if (ret)
@@ -593,10 +653,12 @@ free_tms:
        if (src_move_tm && !RB_EMPTY_NODE(&src_move_tm->node))
                rb_erase(&src_move_tm->node, &fs_info->tree_mod_log);
        kfree(src_move_tm);
-       for (i = 0; i < nr_items * 2; i++) {
-               if (tm_list[i] && !RB_EMPTY_NODE(&tm_list[i]->node))
-                       rb_erase(&tm_list[i]->node, &fs_info->tree_mod_log);
-               kfree(tm_list[i]);
+       if (tm_list) {
+               for (i = 0; i < nr_items * 2; i++) {
+                       if (tm_list[i] && !RB_EMPTY_NODE(&tm_list[i]->node))
+                               rb_erase(&tm_list[i]->node, &fs_info->tree_mod_log);
+                       kfree(tm_list[i]);
+               }
        }
        if (locked)
                write_unlock(&fs_info->tree_mod_log_lock);
@@ -617,22 +679,38 @@ int btrfs_tree_mod_log_free_eb(struct extent_buffer *eb)
 
        nritems = btrfs_header_nritems(eb);
        tm_list = kcalloc(nritems, sizeof(struct tree_mod_elem *), GFP_NOFS);
-       if (!tm_list)
-               return -ENOMEM;
+       if (!tm_list) {
+               ret = -ENOMEM;
+               goto lock;
+       }
 
        for (i = 0; i < nritems; i++) {
                tm_list[i] = alloc_tree_mod_elem(eb, i,
                                    BTRFS_MOD_LOG_KEY_REMOVE_WHILE_FREEING);
                if (!tm_list[i]) {
                        ret = -ENOMEM;
-                       goto free_tms;
+                       goto lock;
                }
        }
 
-       if (tree_mod_dont_log(eb->fs_info, eb))
+lock:
+       if (tree_mod_dont_log(eb->fs_info, eb)) {
+               /*
+                * Don't error if we failed to allocate memory because we don't
+                * need to log.
+                */
+               ret = 0;
                goto free_tms;
+       } else if (ret != 0) {
+               /*
+                * We previously failed to allocate memory and we need to log,
+                * so we have to fail.
+                */
+               goto out_unlock;
+       }
 
        ret = tree_mod_log_free_eb(eb->fs_info, tm_list, nritems);
+out_unlock:
        write_unlock(&eb->fs_info->tree_mod_log_lock);
        if (ret)
                goto free_tms;
@@ -641,9 +719,11 @@ int btrfs_tree_mod_log_free_eb(struct extent_buffer *eb)
        return 0;
 
 free_tms:
-       for (i = 0; i < nritems; i++)
-               kfree(tm_list[i]);
-       kfree(tm_list);
+       if (tm_list) {
+               for (i = 0; i < nritems; i++)
+                       kfree(tm_list[i]);
+               kfree(tm_list);
+       }
 
        return ret;
 }