Btrfs: mark delayed refs as for cow

Add a for_cow parameter to add_delayed_*_ref and pass the appropriate value
from every call site. The for_cow parameter will later on be used to
determine if a ref will change anything with respect to qgroups.

Delayed refs coming from relocation are always counted as for_cow, as they
don't change subvol quota.

Also pass in the fs_info for later use.

btrfs_find_all_roots() will use this as an optimization, as changes that are
for_cow will not change anything with respect to which root points to a
certain leaf. Thus, we don't need to add the current sequence number to
those delayed refs.

Signed-off-by: Arne Jansen <sensille@gmx.net>
Signed-off-by: Jan Schmidt <list.btrfs@jan-o-sch.net>

1 files changed, 10 insertions, 8 deletions

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index dff29d5e151a..8c1aae2c845d 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1604,12 +1604,12 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
                 ret = btrfs_inc_extent_ref(trans, root, new_bytenr,
                                            num_bytes, parent,
                                            btrfs_header_owner(leaf),
-                                           key.objectid, key.offset);
+                                           key.objectid, key.offset, 1);
                 BUG_ON(ret);
 
                 ret = btrfs_free_extent(trans, root, bytenr, num_bytes,
                                         parent, btrfs_header_owner(leaf),
-                                        key.objectid, key.offset);
+                                        key.objectid, key.offset, 1);
                 BUG_ON(ret);
         }
         if (dirty)
@@ -1778,21 +1778,23 @@ again:
 
                 ret = btrfs_inc_extent_ref(trans, src, old_bytenr, blocksize,
                                         path->nodes[level]->start,
-                                        src->root_key.objectid, level - 1, 0);
+                                        src->root_key.objectid, level - 1, 0,
+                                        1);
                 BUG_ON(ret);
                 ret = btrfs_inc_extent_ref(trans, dest, new_bytenr, blocksize,
                                         0, dest->root_key.objectid, level - 1,
-                                        0);
+                                        0, 1);
                 BUG_ON(ret);
 
                 ret = btrfs_free_extent(trans, src, new_bytenr, blocksize,
                                         path->nodes[level]->start,
-                                        src->root_key.objectid, level - 1, 0);
+                                        src->root_key.objectid, level - 1, 0,
+                                        1);
                 BUG_ON(ret);
 
                 ret = btrfs_free_extent(trans, dest, old_bytenr, blocksize,
                                         0, dest->root_key.objectid, level - 1,
-                                        0);
+                                        0, 1);
                 BUG_ON(ret);
 
                 btrfs_unlock_up_safe(path, 0);
@@ -2244,7 +2246,7 @@ again:
                 } else {
                         list_del_init(&reloc_root->root_list);
                 }
-                btrfs_drop_snapshot(reloc_root, rc->block_rsv, 0);
+                btrfs_drop_snapshot(reloc_root, rc->block_rsv, 0, 1);
         }
 
         if (found) {
@@ -2558,7 +2560,7 @@ static int do_relocation(struct btrfs_trans_handle *trans,
                                                 node->eb->start, blocksize,
                                                 upper->eb->start,
                                                 btrfs_header_owner(upper->eb),
-                                                node->level, 0);
+                                                node->level, 0, 1);
                         BUG_ON(ret);
 
                         ret = btrfs_drop_subtree(trans, root, eb, upper->eb);