Skip to content

Commit

Permalink
btrfs: record simple quota deltas in delayed refs
Browse files Browse the repository at this point in the history 
At the moment that we run delayed refs, we make the final ref-count
based decision on creating/removing extent (and metadata) items.
Therefore, it is exactly the spot to hook up simple quotas.

There are a few important subtleties to the fields we must collect to
accurately track simple quotas, particularly when removing an extent.
When removing a data extent, the ref could be in any tree (due to
reflink, for example) and so we need to recover the owning root id from
the owner ref item. When removing a metadata extent, we know the owning
root from the owner field in the header when we create the delayed ref,
so we can recover it from there.

We must also be careful to handle reservations properly to not leaked
reserved space. The happy path is freeing the reservation when the
simple quota delta runs on a data extent. If that doesn't happen, due to
refs canceling out or some error, the ref head already has the
must_insert_reserved machinery to handle this, so we piggy back on that
and use it to clean up the reserved data.

Signed-off-by: Boris Burkov <boris@bur.io>
Signed-off-by: David Sterba <dsterba@suse.com>
  • Loading branch information
Boris Burkov authored and David Sterba committed Oct 12, 2023
1 parent 8d29909 commit cecbb53
Show file tree
Hide file tree
Showing 3 changed files with 82 additions and 8 deletions.
1 change: 1 addition & 0 deletions fs/btrfs/delayed-ref.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -801,6 +801,7 @@ static void init_delayed_ref_head(struct btrfs_delayed_ref_head *head_ref,
head_ref->bytenr = bytenr;
head_ref->num_bytes = num_bytes;
head_ref->ref_mod = count_mod;
head_ref->reserved_bytes = reserved;
head_ref->must_insert_reserved = must_insert_reserved;
head_ref->owning_root = owning_root;
head_ref->is_data = is_data;
Expand Down
6 changes: 6 additions & 0 deletions fs/btrfs/delayed-ref.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -116,6 +116,12 @@ struct btrfs_delayed_ref_head {
*/
u64 owning_root;

/*
* Track reserved bytes when setting must_insert_reserved. On success
* or cleanup, we will need to free the reservation.
*/
u64 reserved_bytes;

/*
* when a new extent is allocated, it is just reserved in memory
* The actual extent isn't inserted into the extent allocation tree
Expand Down
83 changes: 75 additions & 8 deletions fs/btrfs/extent-tree.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -48,6 +48,7 @@


static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
struct btrfs_delayed_ref_head *href,
struct btrfs_delayed_ref_node *node, u64 parent,
u64 root_objectid, u64 owner_objectid,
u64 owner_offset,
Expand Down Expand Up @@ -1541,6 +1542,7 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
}

static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
struct btrfs_delayed_ref_head *href,
struct btrfs_delayed_ref_node *node,
struct btrfs_delayed_extent_op *extent_op,
bool insert_reserved)
Expand All @@ -1558,6 +1560,13 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,

if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
struct btrfs_key key;
struct btrfs_squota_delta delta = {
.root = href->owning_root,
.num_bytes = node->num_bytes,
.rsv_bytes = href->reserved_bytes,
.is_data = true,
.is_inc = true,
};

if (extent_op)
flags |= extent_op->flags_to_set;
Expand All @@ -1570,12 +1579,17 @@ static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
flags, ref->objectid,
ref->offset, &key,
node->ref_mod);
if (!ret)
ret = btrfs_record_squota_delta(trans->fs_info, &delta);
else
btrfs_qgroup_free_refroot(trans->fs_info, delta.root,
delta.rsv_bytes, BTRFS_QGROUP_RSV_DATA);
} else if (node->action == BTRFS_ADD_DELAYED_REF) {
ret = __btrfs_inc_extent_ref(trans, node, parent, ref->root,
ref->objectid, ref->offset,
extent_op);
} else if (node->action == BTRFS_DROP_DELAYED_REF) {
ret = __btrfs_free_extent(trans, node, parent,
ret = __btrfs_free_extent(trans, href, node, parent,
ref->root, ref->objectid,
ref->offset, extent_op);
} else {
Expand Down Expand Up @@ -1692,11 +1706,13 @@ static int run_delayed_extent_op(struct btrfs_trans_handle *trans,
}

static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
struct btrfs_delayed_ref_head *href,
struct btrfs_delayed_ref_node *node,
struct btrfs_delayed_extent_op *extent_op,
bool insert_reserved)
{
int ret = 0;
struct btrfs_fs_info *fs_info = trans->fs_info;
struct btrfs_delayed_tree_ref *ref;
u64 parent = 0;
u64 ref_root = 0;
Expand All @@ -1716,13 +1732,23 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
return -EUCLEAN;
}
if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
struct btrfs_squota_delta delta = {
.root = href->owning_root,
.num_bytes = fs_info->nodesize,
.rsv_bytes = 0,
.is_data = false,
.is_inc = true,
};

BUG_ON(!extent_op || !extent_op->update_flags);
ret = alloc_reserved_tree_block(trans, node, extent_op);
if (!ret)
btrfs_record_squota_delta(fs_info, &delta);
} else if (node->action == BTRFS_ADD_DELAYED_REF) {
ret = __btrfs_inc_extent_ref(trans, node, parent, ref_root,
ref->level, 0, extent_op);
} else if (node->action == BTRFS_DROP_DELAYED_REF) {
ret = __btrfs_free_extent(trans, node, parent, ref_root,
ret = __btrfs_free_extent(trans, href, node, parent, ref_root,
ref->level, 0, extent_op);
} else {
BUG();
Expand All @@ -1732,6 +1758,7 @@ static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,

/* helper function to actually process a single delayed ref entry */
static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
struct btrfs_delayed_ref_head *href,
struct btrfs_delayed_ref_node *node,
struct btrfs_delayed_extent_op *extent_op,
bool insert_reserved)
Expand All @@ -1746,11 +1773,11 @@ static int run_one_delayed_ref(struct btrfs_trans_handle *trans,

if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
node->type == BTRFS_SHARED_BLOCK_REF_KEY)
ret = run_delayed_tree_ref(trans, node, extent_op,
ret = run_delayed_tree_ref(trans, href, node, extent_op,
insert_reserved);
else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
node->type == BTRFS_SHARED_DATA_REF_KEY)
ret = run_delayed_data_ref(trans, node, extent_op,
ret = run_delayed_data_ref(trans, href, node, extent_op,
insert_reserved);
else if (node->type == BTRFS_EXTENT_OWNER_REF_KEY)
ret = 0;
Expand Down Expand Up @@ -1852,6 +1879,10 @@ u64 btrfs_cleanup_ref_head_accounting(struct btrfs_fs_info *fs_info,

return btrfs_calc_delayed_ref_csum_bytes(fs_info, nr_csums);
}
if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE &&
head->must_insert_reserved && head->is_data)
btrfs_qgroup_free_refroot(fs_info, head->owning_root,
head->reserved_bytes, BTRFS_QGROUP_RSV_DATA);

return 0;
}
Expand Down Expand Up @@ -2000,10 +2031,11 @@ static int btrfs_run_delayed_refs_for_head(struct btrfs_trans_handle *trans,
locked_ref->extent_op = NULL;
spin_unlock(&locked_ref->lock);

ret = run_one_delayed_ref(trans, ref, extent_op,
ret = run_one_delayed_ref(trans, locked_ref, ref, extent_op,
must_insert_reserved);
btrfs_delayed_refs_rsv_release(fs_info, 1, 0);
*bytes_released += btrfs_calc_delayed_ref_bytes(fs_info, 1);

btrfs_free_delayed_extent_op(extent_op);
if (ret) {
unselect_delayed_ref_head(delayed_refs, locked_ref);
Expand Down Expand Up @@ -2916,11 +2948,12 @@ u64 btrfs_get_extent_owner_root(struct btrfs_fs_info *fs_info,
}

static int do_free_extent_accounting(struct btrfs_trans_handle *trans,
u64 bytenr, u64 num_bytes, bool is_data)
u64 bytenr, struct btrfs_squota_delta *delta)
{
int ret;
u64 num_bytes = delta->num_bytes;

if (is_data) {
if (delta->is_data) {
struct btrfs_root *csum_root;

csum_root = btrfs_csum_root(trans->fs_info, bytenr);
Expand All @@ -2937,6 +2970,12 @@ static int do_free_extent_accounting(struct btrfs_trans_handle *trans,
}
}

ret = btrfs_record_squota_delta(trans->fs_info, delta);
if (ret) {
btrfs_abort_transaction(trans, ret);
return ret;
}

ret = add_to_free_space_tree(trans, bytenr, num_bytes);
if (ret) {
btrfs_abort_transaction(trans, ret);
Expand Down Expand Up @@ -3017,6 +3056,7 @@ static int do_free_extent_accounting(struct btrfs_trans_handle *trans,
* And that (13631488 EXTENT_DATA_REF <HASH>) gets removed.
*/
static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
struct btrfs_delayed_ref_head *href,
struct btrfs_delayed_ref_node *node, u64 parent,
u64 root_objectid, u64 owner_objectid,
u64 owner_offset,
Expand All @@ -3040,6 +3080,7 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
u64 bytenr = node->bytenr;
u64 num_bytes = node->num_bytes;
bool skinny_metadata = btrfs_fs_incompat(info, SKINNY_METADATA);
u64 delayed_ref_root = href->owning_root;

extent_root = btrfs_extent_root(info, bytenr);
ASSERT(extent_root);
Expand Down Expand Up @@ -3240,6 +3281,14 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
}
}
} else {
struct btrfs_squota_delta delta = {
.root = delayed_ref_root,
.num_bytes = num_bytes,
.rsv_bytes = 0,
.is_data = is_data,
.is_inc = false,
};

/* In this branch refs == 1 */
if (found_extent) {
if (is_data && refs_to_drop !=
Expand Down Expand Up @@ -3278,6 +3327,16 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
num_to_del = 2;
}
}
/*
* We can't infer the data owner from the delayed ref, so we need
* to try to get it from the owning ref item.
*
* If it is not present, then that extent was not written under
* simple quotas mode, so we don't need to account for its deletion.
*/
if (is_data)
delta.root = btrfs_get_extent_owner_root(trans->fs_info,
leaf, extent_slot);

ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
num_to_del);
Expand All @@ -3287,7 +3346,7 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
}
btrfs_release_path(path);

ret = do_free_extent_accounting(trans, bytenr, num_bytes, is_data);
ret = do_free_extent_accounting(trans, bytenr, &delta);
}
btrfs_release_path(path);

Expand Down Expand Up @@ -4862,6 +4921,13 @@ int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
int ret;
struct btrfs_block_group *block_group;
struct btrfs_space_info *space_info;
struct btrfs_squota_delta delta = {
.root = root_objectid,
.num_bytes = ins->offset,
.rsv_bytes = 0,
.is_data = true,
.is_inc = true,
};

/*
* Mixed block groups will exclude before processing the log so we only
Expand Down Expand Up @@ -4890,6 +4956,7 @@ int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
offset, ins, 1);
if (ret)
btrfs_pin_extent(trans, ins->objectid, ins->offset, 1);
ret = btrfs_record_squota_delta(fs_info, &delta);
btrfs_put_block_group(block_group);
return ret;
}
Expand Down

0 comments on commit cecbb53

Please sign in to comment.