2019-06-19 22:12:00 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
|
|
|
|
#include "ctree.h"
|
|
|
|
#include "delalloc-space.h"
|
|
|
|
#include "block-rsv.h"
|
|
|
|
#include "btrfs_inode.h"
|
|
|
|
#include "space-info.h"
|
|
|
|
#include "transaction.h"
|
|
|
|
#include "qgroup.h"
|
2019-06-20 22:38:04 +03:00
|
|
|
#include "block-group.h"
|
2019-06-19 22:12:00 +03:00
|
|
|
|
2020-02-04 21:18:55 +03:00
|
|
|
/*
|
|
|
|
* HOW DOES THIS WORK
|
|
|
|
*
|
|
|
|
* There are two stages to data reservations, one for data and one for metadata
|
|
|
|
* to handle the new extents and checksums generated by writing data.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* DATA RESERVATION
|
|
|
|
* The general flow of the data reservation is as follows
|
|
|
|
*
|
|
|
|
* -> Reserve
|
|
|
|
* We call into btrfs_reserve_data_bytes() for the user request bytes that
|
|
|
|
* they wish to write. We make this reservation and add it to
|
|
|
|
* space_info->bytes_may_use. We set EXTENT_DELALLOC on the inode io_tree
|
|
|
|
* for the range and carry on if this is buffered, or follow up trying to
|
|
|
|
* make a real allocation if we are pre-allocating or doing O_DIRECT.
|
|
|
|
*
|
|
|
|
* -> Use
|
|
|
|
* At writepages()/prealloc/O_DIRECT time we will call into
|
|
|
|
* btrfs_reserve_extent() for some part or all of this range of bytes. We
|
|
|
|
* will make the allocation and subtract space_info->bytes_may_use by the
|
|
|
|
* original requested length and increase the space_info->bytes_reserved by
|
|
|
|
* the allocated length. This distinction is important because compression
|
|
|
|
* may allocate a smaller on disk extent than we previously reserved.
|
|
|
|
*
|
|
|
|
* -> Allocation
|
|
|
|
* finish_ordered_io() will insert the new file extent item for this range,
|
|
|
|
* and then add a delayed ref update for the extent tree. Once that delayed
|
|
|
|
* ref is written the extent size is subtracted from
|
|
|
|
* space_info->bytes_reserved and added to space_info->bytes_used.
|
|
|
|
*
|
|
|
|
* Error handling
|
|
|
|
*
|
|
|
|
* -> By the reservation maker
|
|
|
|
* This is the simplest case, we haven't completed our operation and we know
|
|
|
|
* how much we reserved, we can simply call
|
|
|
|
* btrfs_free_reserved_data_space*() and it will be removed from
|
|
|
|
* space_info->bytes_may_use.
|
|
|
|
*
|
|
|
|
* -> After the reservation has been made, but before cow_file_range()
|
|
|
|
* This is specifically for the delalloc case. You must clear
|
|
|
|
* EXTENT_DELALLOC with the EXTENT_CLEAR_DATA_RESV bit, and the range will
|
|
|
|
* be subtracted from space_info->bytes_may_use.
|
|
|
|
*
|
|
|
|
* METADATA RESERVATION
|
|
|
|
* The general metadata reservation lifetimes are discussed elsewhere, this
|
|
|
|
* will just focus on how it is used for delalloc space.
|
|
|
|
*
|
|
|
|
* We keep track of two things on a per inode bases
|
|
|
|
*
|
|
|
|
* ->outstanding_extents
|
|
|
|
* This is the number of file extent items we'll need to handle all of the
|
|
|
|
* outstanding DELALLOC space we have in this inode. We limit the maximum
|
|
|
|
* size of an extent, so a large contiguous dirty area may require more than
|
|
|
|
* one outstanding_extent, which is why count_max_extents() is used to
|
|
|
|
* determine how many outstanding_extents get added.
|
|
|
|
*
|
|
|
|
* ->csum_bytes
|
|
|
|
* This is essentially how many dirty bytes we have for this inode, so we
|
|
|
|
* can calculate the number of checksum items we would have to add in order
|
|
|
|
* to checksum our outstanding data.
|
|
|
|
*
|
|
|
|
* We keep a per-inode block_rsv in order to make it easier to keep track of
|
|
|
|
* our reservation. We use btrfs_calculate_inode_block_rsv_size() to
|
|
|
|
* calculate the current theoretical maximum reservation we would need for the
|
|
|
|
* metadata for this inode. We call this and then adjust our reservation as
|
|
|
|
* necessary, either by attempting to reserve more space, or freeing up excess
|
|
|
|
* space.
|
|
|
|
*
|
|
|
|
* OUTSTANDING_EXTENTS HANDLING
|
|
|
|
*
|
|
|
|
* ->outstanding_extents is used for keeping track of how many extents we will
|
|
|
|
* need to use for this inode, and it will fluctuate depending on where you are
|
|
|
|
* in the life cycle of the dirty data. Consider the following normal case for
|
|
|
|
* a completely clean inode, with a num_bytes < our maximum allowed extent size
|
|
|
|
*
|
|
|
|
* -> reserve
|
|
|
|
* ->outstanding_extents += 1 (current value is 1)
|
|
|
|
*
|
|
|
|
* -> set_delalloc
|
|
|
|
* ->outstanding_extents += 1 (currrent value is 2)
|
|
|
|
*
|
|
|
|
* -> btrfs_delalloc_release_extents()
|
|
|
|
* ->outstanding_extents -= 1 (current value is 1)
|
|
|
|
*
|
|
|
|
* We must call this once we are done, as we hold our reservation for the
|
|
|
|
* duration of our operation, and then assume set_delalloc will update the
|
|
|
|
* counter appropriately.
|
|
|
|
*
|
|
|
|
* -> add ordered extent
|
|
|
|
* ->outstanding_extents += 1 (current value is 2)
|
|
|
|
*
|
|
|
|
* -> btrfs_clear_delalloc_extent
|
|
|
|
* ->outstanding_extents -= 1 (current value is 1)
|
|
|
|
*
|
|
|
|
* -> finish_ordered_io/btrfs_remove_ordered_extent
|
|
|
|
* ->outstanding_extents -= 1 (current value is 0)
|
|
|
|
*
|
|
|
|
* Each stage is responsible for their own accounting of the extent, thus
|
|
|
|
* making error handling and cleanup easier.
|
|
|
|
*/
|
|
|
|
|
2019-06-19 22:12:00 +03:00
|
|
|
int btrfs_alloc_data_chunk_ondemand(struct btrfs_inode *inode, u64 bytes)
|
|
|
|
{
|
|
|
|
struct btrfs_root *root = inode->root;
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
2020-07-21 17:22:25 +03:00
|
|
|
enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_DATA;
|
2019-06-19 22:12:00 +03:00
|
|
|
|
|
|
|
/* Make sure bytes are sectorsize aligned */
|
|
|
|
bytes = ALIGN(bytes, fs_info->sectorsize);
|
|
|
|
|
2020-07-21 17:22:25 +03:00
|
|
|
if (btrfs_is_free_space_inode(inode))
|
|
|
|
flush = BTRFS_RESERVE_FLUSH_FREE_SPACE_INODE;
|
2019-06-19 22:12:00 +03:00
|
|
|
|
2020-07-21 17:22:25 +03:00
|
|
|
return btrfs_reserve_data_bytes(fs_info, bytes, flush);
|
2019-06-19 22:12:00 +03:00
|
|
|
}
|
|
|
|
|
2020-06-03 08:55:41 +03:00
|
|
|
int btrfs_check_data_free_space(struct btrfs_inode *inode,
|
2019-06-19 22:12:00 +03:00
|
|
|
struct extent_changeset **reserved, u64 start, u64 len)
|
|
|
|
{
|
2020-06-03 08:55:41 +03:00
|
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
2019-06-19 22:12:00 +03:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* align the range */
|
|
|
|
len = round_up(start + len, fs_info->sectorsize) -
|
|
|
|
round_down(start, fs_info->sectorsize);
|
|
|
|
start = round_down(start, fs_info->sectorsize);
|
|
|
|
|
2020-06-03 08:55:41 +03:00
|
|
|
ret = btrfs_alloc_data_chunk_ondemand(inode, len);
|
2019-06-19 22:12:00 +03:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Use new btrfs_qgroup_reserve_data to reserve precious data space. */
|
2020-06-03 08:55:41 +03:00
|
|
|
ret = btrfs_qgroup_reserve_data(inode, reserved, start, len);
|
2019-06-19 22:12:00 +03:00
|
|
|
if (ret < 0)
|
2020-06-03 08:55:38 +03:00
|
|
|
btrfs_free_reserved_data_space_noquota(fs_info, len);
|
2019-06-19 22:12:00 +03:00
|
|
|
else
|
|
|
|
ret = 0;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called if we need to clear a data reservation for this inode
|
|
|
|
* Normally in a error case.
|
|
|
|
*
|
|
|
|
* This one will *NOT* use accurate qgroup reserved space API, just for case
|
|
|
|
* which we can't sleep and is sure it won't affect qgroup reserved space.
|
|
|
|
* Like clear_bit_hook().
|
|
|
|
*/
|
2020-06-03 08:55:38 +03:00
|
|
|
void btrfs_free_reserved_data_space_noquota(struct btrfs_fs_info *fs_info,
|
2019-06-19 22:12:00 +03:00
|
|
|
u64 len)
|
|
|
|
{
|
|
|
|
struct btrfs_space_info *data_sinfo;
|
|
|
|
|
2020-06-09 13:19:33 +03:00
|
|
|
ASSERT(IS_ALIGNED(len, fs_info->sectorsize));
|
2019-06-19 22:12:00 +03:00
|
|
|
|
|
|
|
data_sinfo = fs_info->data_sinfo;
|
2020-07-21 17:22:20 +03:00
|
|
|
btrfs_space_info_free_bytes_may_use(fs_info, data_sinfo, len);
|
2019-06-19 22:12:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called if we need to clear a data reservation for this inode
|
|
|
|
* Normally in a error case.
|
|
|
|
*
|
|
|
|
* This one will handle the per-inode data rsv map for accurate reserved
|
|
|
|
* space framework.
|
|
|
|
*/
|
2020-06-03 08:55:39 +03:00
|
|
|
void btrfs_free_reserved_data_space(struct btrfs_inode *inode,
|
2019-06-19 22:12:00 +03:00
|
|
|
struct extent_changeset *reserved, u64 start, u64 len)
|
|
|
|
{
|
2020-06-03 08:55:39 +03:00
|
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
2019-06-19 22:12:00 +03:00
|
|
|
|
|
|
|
/* Make sure the range is aligned to sectorsize */
|
2020-06-03 08:55:39 +03:00
|
|
|
len = round_up(start + len, fs_info->sectorsize) -
|
|
|
|
round_down(start, fs_info->sectorsize);
|
|
|
|
start = round_down(start, fs_info->sectorsize);
|
2019-06-19 22:12:00 +03:00
|
|
|
|
2020-06-03 08:55:39 +03:00
|
|
|
btrfs_free_reserved_data_space_noquota(fs_info, len);
|
|
|
|
btrfs_qgroup_free_data(inode, reserved, start, len);
|
2019-06-19 22:12:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* btrfs_inode_rsv_release - release any excessive reservation.
|
|
|
|
* @inode - the inode we need to release from.
|
|
|
|
* @qgroup_free - free or convert qgroup meta.
|
|
|
|
* Unlike normal operation, qgroup meta reservation needs to know if we are
|
|
|
|
* freeing qgroup reservation or just converting it into per-trans. Normally
|
|
|
|
* @qgroup_free is true for error handling, and false for normal release.
|
|
|
|
*
|
|
|
|
* This is the same as btrfs_block_rsv_release, except that it handles the
|
|
|
|
* tracepoint for the reservation.
|
|
|
|
*/
|
|
|
|
static void btrfs_inode_rsv_release(struct btrfs_inode *inode, bool qgroup_free)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
|
|
struct btrfs_block_rsv *block_rsv = &inode->block_rsv;
|
|
|
|
u64 released = 0;
|
|
|
|
u64 qgroup_to_release = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we statically set the block_rsv->size we just want to say we
|
|
|
|
* are releasing 0 bytes, and then we'll just get the reservation over
|
|
|
|
* the size free'd.
|
|
|
|
*/
|
2020-03-10 11:59:31 +03:00
|
|
|
released = btrfs_block_rsv_release(fs_info, block_rsv, 0,
|
|
|
|
&qgroup_to_release);
|
2019-06-19 22:12:00 +03:00
|
|
|
if (released > 0)
|
|
|
|
trace_btrfs_space_reservation(fs_info, "delalloc",
|
|
|
|
btrfs_ino(inode), released, 0);
|
|
|
|
if (qgroup_free)
|
|
|
|
btrfs_qgroup_free_meta_prealloc(inode->root, qgroup_to_release);
|
|
|
|
else
|
|
|
|
btrfs_qgroup_convert_reserved_meta(inode->root,
|
|
|
|
qgroup_to_release);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info *fs_info,
|
|
|
|
struct btrfs_inode *inode)
|
|
|
|
{
|
|
|
|
struct btrfs_block_rsv *block_rsv = &inode->block_rsv;
|
|
|
|
u64 reserve_size = 0;
|
|
|
|
u64 qgroup_rsv_size = 0;
|
|
|
|
u64 csum_leaves;
|
|
|
|
unsigned outstanding_extents;
|
|
|
|
|
|
|
|
lockdep_assert_held(&inode->lock);
|
|
|
|
outstanding_extents = inode->outstanding_extents;
|
2019-08-22 22:14:34 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Insert size for the number of outstanding extents, 1 normal size for
|
|
|
|
* updating the inode.
|
|
|
|
*/
|
|
|
|
if (outstanding_extents) {
|
2019-08-22 22:14:33 +03:00
|
|
|
reserve_size = btrfs_calc_insert_metadata_size(fs_info,
|
2019-08-22 22:14:34 +03:00
|
|
|
outstanding_extents);
|
|
|
|
reserve_size += btrfs_calc_metadata_size(fs_info, 1);
|
|
|
|
}
|
2019-06-19 22:12:00 +03:00
|
|
|
csum_leaves = btrfs_csum_bytes_to_leaves(fs_info,
|
|
|
|
inode->csum_bytes);
|
2019-08-22 22:14:33 +03:00
|
|
|
reserve_size += btrfs_calc_insert_metadata_size(fs_info,
|
|
|
|
csum_leaves);
|
2019-06-19 22:12:00 +03:00
|
|
|
/*
|
|
|
|
* For qgroup rsv, the calculation is very simple:
|
|
|
|
* account one nodesize for each outstanding extent
|
|
|
|
*
|
|
|
|
* This is overestimating in most cases.
|
|
|
|
*/
|
|
|
|
qgroup_rsv_size = (u64)outstanding_extents * fs_info->nodesize;
|
|
|
|
|
|
|
|
spin_lock(&block_rsv->lock);
|
|
|
|
block_rsv->size = reserve_size;
|
|
|
|
block_rsv->qgroup_rsv_size = qgroup_rsv_size;
|
|
|
|
spin_unlock(&block_rsv->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void calc_inode_reservations(struct btrfs_fs_info *fs_info,
|
|
|
|
u64 num_bytes, u64 *meta_reserve,
|
|
|
|
u64 *qgroup_reserve)
|
|
|
|
{
|
|
|
|
u64 nr_extents = count_max_extents(num_bytes);
|
|
|
|
u64 csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, num_bytes);
|
2019-08-22 22:14:34 +03:00
|
|
|
u64 inode_update = btrfs_calc_metadata_size(fs_info, 1);
|
2019-06-19 22:12:00 +03:00
|
|
|
|
2019-08-22 22:14:33 +03:00
|
|
|
*meta_reserve = btrfs_calc_insert_metadata_size(fs_info,
|
2019-08-22 22:14:34 +03:00
|
|
|
nr_extents + csum_leaves);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* finish_ordered_io has to update the inode, so add the space required
|
|
|
|
* for an inode update.
|
|
|
|
*/
|
|
|
|
*meta_reserve += inode_update;
|
2019-06-19 22:12:00 +03:00
|
|
|
*qgroup_reserve = nr_extents * fs_info->nodesize;
|
|
|
|
}
|
|
|
|
|
|
|
|
int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes)
|
|
|
|
{
|
|
|
|
struct btrfs_root *root = inode->root;
|
|
|
|
struct btrfs_fs_info *fs_info = root->fs_info;
|
|
|
|
struct btrfs_block_rsv *block_rsv = &inode->block_rsv;
|
|
|
|
u64 meta_reserve, qgroup_reserve;
|
|
|
|
unsigned nr_extents;
|
|
|
|
enum btrfs_reserve_flush_enum flush = BTRFS_RESERVE_FLUSH_ALL;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we are a free space inode we need to not flush since we will be in
|
|
|
|
* the middle of a transaction commit. We also don't need the delalloc
|
|
|
|
* mutex since we won't race with anybody. We need this mostly to make
|
|
|
|
* lockdep shut its filthy mouth.
|
|
|
|
*
|
|
|
|
* If we have a transaction open (can happen if we call truncate_block
|
|
|
|
* from truncate), then we need FLUSH_LIMIT so we don't deadlock.
|
|
|
|
*/
|
|
|
|
if (btrfs_is_free_space_inode(inode)) {
|
|
|
|
flush = BTRFS_RESERVE_NO_FLUSH;
|
|
|
|
} else {
|
|
|
|
if (current->journal_info)
|
|
|
|
flush = BTRFS_RESERVE_FLUSH_LIMIT;
|
|
|
|
|
|
|
|
if (btrfs_transaction_in_commit(fs_info))
|
|
|
|
schedule_timeout(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
num_bytes = ALIGN(num_bytes, fs_info->sectorsize);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We always want to do it this way, every other way is wrong and ends
|
|
|
|
* in tears. Pre-reserving the amount we are going to add will always
|
|
|
|
* be the right way, because otherwise if we have enough parallelism we
|
|
|
|
* could end up with thousands of inodes all holding little bits of
|
|
|
|
* reservations they were able to make previously and the only way to
|
|
|
|
* reclaim that space is to ENOSPC out the operations and clear
|
|
|
|
* everything out and try again, which is bad. This way we just
|
|
|
|
* over-reserve slightly, and clean up the mess when we are done.
|
|
|
|
*/
|
|
|
|
calc_inode_reservations(fs_info, num_bytes, &meta_reserve,
|
|
|
|
&qgroup_reserve);
|
|
|
|
ret = btrfs_qgroup_reserve_meta_prealloc(root, qgroup_reserve, true);
|
|
|
|
if (ret)
|
Btrfs: remove unnecessary delalloc mutex for inodes
The inode delalloc mutex was added a long time ago by commit f248679e86fea
("Btrfs: add a delalloc mutex to inodes for delalloc reservations"), and
the reason for its introduction is not very clear from the change log. It
claims it solves bogus warnings from lockdep, however it lacks an example
report/warning from lockdep, or any explanation.
Since we have enough concurrentcy protection from the locks of the space
info and block reserve objects, and such lockdep warnings don't seem to
exist anymore (at least on a 5.3 kernel I couldn't get them with fstests,
ltp, fs_mark, etc), remove it, simplifying things a bit and decreasing
the size of the btrfs_inode structure. With some quick fio tests doing
direct IO and mmap writes I couldn't observe any significant performance
increase either (direct IO writes that don't increase the file's size
don't hold the inode's lock for their entire duration and mmap writes
don't hold the inode's lock at all), which are the only type of writes
that could see any performance gain due to less serialization.
Review feedback from Josef:
The problem was taking the i_mutex in mmap, which is how I was
protecting delalloc reservations originally. The delalloc mutex didn't
come with all of the other dependencies. That's what the lockdep
messages were about, removing the lock isn't going to make them appear
again.
We _had_ to lock around this because we used to do tricks to keep from
over-reserving, and if we didn't serialize delalloc reservations we'd
end up with ugly accounting problems when we tried to clean things up.
However with my recentish changes this isn't the case anymore. Every
operation is responsible for reserving its space, and then adding it to
the inode. Then cleaning up is straightforward and can't be mucked up
by other users. So we no longer need the delalloc mutex to safe us from
ourselves.
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-10-25 12:52:42 +03:00
|
|
|
return ret;
|
2019-06-19 22:12:00 +03:00
|
|
|
ret = btrfs_reserve_metadata_bytes(root, block_rsv, meta_reserve, flush);
|
Btrfs: remove unnecessary delalloc mutex for inodes
The inode delalloc mutex was added a long time ago by commit f248679e86fea
("Btrfs: add a delalloc mutex to inodes for delalloc reservations"), and
the reason for its introduction is not very clear from the change log. It
claims it solves bogus warnings from lockdep, however it lacks an example
report/warning from lockdep, or any explanation.
Since we have enough concurrentcy protection from the locks of the space
info and block reserve objects, and such lockdep warnings don't seem to
exist anymore (at least on a 5.3 kernel I couldn't get them with fstests,
ltp, fs_mark, etc), remove it, simplifying things a bit and decreasing
the size of the btrfs_inode structure. With some quick fio tests doing
direct IO and mmap writes I couldn't observe any significant performance
increase either (direct IO writes that don't increase the file's size
don't hold the inode's lock for their entire duration and mmap writes
don't hold the inode's lock at all), which are the only type of writes
that could see any performance gain due to less serialization.
Review feedback from Josef:
The problem was taking the i_mutex in mmap, which is how I was
protecting delalloc reservations originally. The delalloc mutex didn't
come with all of the other dependencies. That's what the lockdep
messages were about, removing the lock isn't going to make them appear
again.
We _had_ to lock around this because we used to do tricks to keep from
over-reserving, and if we didn't serialize delalloc reservations we'd
end up with ugly accounting problems when we tried to clean things up.
However with my recentish changes this isn't the case anymore. Every
operation is responsible for reserving its space, and then adding it to
the inode. Then cleaning up is straightforward and can't be mucked up
by other users. So we no longer need the delalloc mutex to safe us from
ourselves.
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-10-25 12:52:42 +03:00
|
|
|
if (ret) {
|
|
|
|
btrfs_qgroup_free_meta_prealloc(root, qgroup_reserve);
|
|
|
|
return ret;
|
|
|
|
}
|
2019-06-19 22:12:00 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now we need to update our outstanding extents and csum bytes _first_
|
|
|
|
* and then add the reservation to the block_rsv. This keeps us from
|
|
|
|
* racing with an ordered completion or some such that would think it
|
|
|
|
* needs to free the reservation we just made.
|
|
|
|
*/
|
|
|
|
spin_lock(&inode->lock);
|
|
|
|
nr_extents = count_max_extents(num_bytes);
|
|
|
|
btrfs_mod_outstanding_extents(inode, nr_extents);
|
|
|
|
inode->csum_bytes += num_bytes;
|
|
|
|
btrfs_calculate_inode_block_rsv_size(fs_info, inode);
|
|
|
|
spin_unlock(&inode->lock);
|
|
|
|
|
|
|
|
/* Now we can safely add our space to our block rsv */
|
|
|
|
btrfs_block_rsv_add_bytes(block_rsv, meta_reserve, false);
|
|
|
|
trace_btrfs_space_reservation(root->fs_info, "delalloc",
|
|
|
|
btrfs_ino(inode), meta_reserve, 1);
|
|
|
|
|
|
|
|
spin_lock(&block_rsv->lock);
|
|
|
|
block_rsv->qgroup_rsv_reserved += qgroup_reserve;
|
|
|
|
spin_unlock(&block_rsv->lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* btrfs_delalloc_release_metadata - release a metadata reservation for an inode
|
|
|
|
* @inode: the inode to release the reservation for.
|
|
|
|
* @num_bytes: the number of bytes we are releasing.
|
|
|
|
* @qgroup_free: free qgroup reservation or convert it to per-trans reservation
|
|
|
|
*
|
|
|
|
* This will release the metadata reservation for an inode. This can be called
|
|
|
|
* once we complete IO for a given set of bytes to release their metadata
|
|
|
|
* reservations, or on error for the same reason.
|
|
|
|
*/
|
|
|
|
void btrfs_delalloc_release_metadata(struct btrfs_inode *inode, u64 num_bytes,
|
|
|
|
bool qgroup_free)
|
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
|
|
|
|
|
|
num_bytes = ALIGN(num_bytes, fs_info->sectorsize);
|
|
|
|
spin_lock(&inode->lock);
|
|
|
|
inode->csum_bytes -= num_bytes;
|
|
|
|
btrfs_calculate_inode_block_rsv_size(fs_info, inode);
|
|
|
|
spin_unlock(&inode->lock);
|
|
|
|
|
|
|
|
if (btrfs_is_testing(fs_info))
|
|
|
|
return;
|
|
|
|
|
|
|
|
btrfs_inode_rsv_release(inode, qgroup_free);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* btrfs_delalloc_release_extents - release our outstanding_extents
|
|
|
|
* @inode: the inode to balance the reservation for.
|
|
|
|
* @num_bytes: the number of bytes we originally reserved with
|
|
|
|
*
|
|
|
|
* When we reserve space we increase outstanding_extents for the extents we may
|
|
|
|
* add. Once we've set the range as delalloc or created our ordered extents we
|
|
|
|
* have outstanding_extents to track the real usage, so we use this to free our
|
|
|
|
* temporarily tracked outstanding_extents. This _must_ be used in conjunction
|
|
|
|
* with btrfs_delalloc_reserve_metadata.
|
|
|
|
*/
|
btrfs: qgroup: Always free PREALLOC META reserve in btrfs_delalloc_release_extents()
[Background]
Btrfs qgroup uses two types of reserved space for METADATA space,
PERTRANS and PREALLOC.
PERTRANS is metadata space reserved for each transaction started by
btrfs_start_transaction().
While PREALLOC is for delalloc, where we reserve space before joining a
transaction, and finally it will be converted to PERTRANS after the
writeback is done.
[Inconsistency]
However there is inconsistency in how we handle PREALLOC metadata space.
The most obvious one is:
In btrfs_buffered_write():
btrfs_delalloc_release_extents(BTRFS_I(inode), reserve_bytes, true);
We always free qgroup PREALLOC meta space.
While in btrfs_truncate_block():
btrfs_delalloc_release_extents(BTRFS_I(inode), blocksize, (ret != 0));
We only free qgroup PREALLOC meta space when something went wrong.
[The Correct Behavior]
The correct behavior should be the one in btrfs_buffered_write(), we
should always free PREALLOC metadata space.
The reason is, the btrfs_delalloc_* mechanism works by:
- Reserve metadata first, even it's not necessary
In btrfs_delalloc_reserve_metadata()
- Free the unused metadata space
Normally in:
btrfs_delalloc_release_extents()
|- btrfs_inode_rsv_release()
Here we do calculation on whether we should release or not.
E.g. for 64K buffered write, the metadata rsv works like:
/* The first page */
reserve_meta: num_bytes=calc_inode_reservations()
free_meta: num_bytes=0
total: num_bytes=calc_inode_reservations()
/* The first page caused one outstanding extent, thus needs metadata
rsv */
/* The 2nd page */
reserve_meta: num_bytes=calc_inode_reservations()
free_meta: num_bytes=calc_inode_reservations()
total: not changed
/* The 2nd page doesn't cause new outstanding extent, needs no new meta
rsv, so we free what we have reserved */
/* The 3rd~16th pages */
reserve_meta: num_bytes=calc_inode_reservations()
free_meta: num_bytes=calc_inode_reservations()
total: not changed (still space for one outstanding extent)
This means, if btrfs_delalloc_release_extents() determines to free some
space, then those space should be freed NOW.
So for qgroup, we should call btrfs_qgroup_free_meta_prealloc() other
than btrfs_qgroup_convert_reserved_meta().
The good news is:
- The callers are not that hot
The hottest caller is in btrfs_buffered_write(), which is already
fixed by commit 336a8bb8e36a ("btrfs: Fix wrong
btrfs_delalloc_release_extents parameter"). Thus it's not that
easy to cause false EDQUOT.
- The trans commit in advance for qgroup would hide the bug
Since commit f5fef4593653 ("btrfs: qgroup: Make qgroup async transaction
commit more aggressive"), when btrfs qgroup metadata free space is slow,
it will try to commit transaction and free the wrongly converted
PERTRANS space, so it's not that easy to hit such bug.
[FIX]
So to fix the problem, remove the @qgroup_free parameter for
btrfs_delalloc_release_extents(), and always pass true to
btrfs_inode_rsv_release().
Reported-by: Filipe Manana <fdmanana@suse.com>
Fixes: 43b18595d660 ("btrfs: qgroup: Use separate meta reservation type for delalloc")
CC: stable@vger.kernel.org # 4.19+
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-10-14 09:34:51 +03:00
|
|
|
void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes)
|
2019-06-19 22:12:00 +03:00
|
|
|
{
|
|
|
|
struct btrfs_fs_info *fs_info = inode->root->fs_info;
|
|
|
|
unsigned num_extents;
|
|
|
|
|
|
|
|
spin_lock(&inode->lock);
|
|
|
|
num_extents = count_max_extents(num_bytes);
|
|
|
|
btrfs_mod_outstanding_extents(inode, -num_extents);
|
|
|
|
btrfs_calculate_inode_block_rsv_size(fs_info, inode);
|
|
|
|
spin_unlock(&inode->lock);
|
|
|
|
|
|
|
|
if (btrfs_is_testing(fs_info))
|
|
|
|
return;
|
|
|
|
|
btrfs: qgroup: Always free PREALLOC META reserve in btrfs_delalloc_release_extents()
[Background]
Btrfs qgroup uses two types of reserved space for METADATA space,
PERTRANS and PREALLOC.
PERTRANS is metadata space reserved for each transaction started by
btrfs_start_transaction().
While PREALLOC is for delalloc, where we reserve space before joining a
transaction, and finally it will be converted to PERTRANS after the
writeback is done.
[Inconsistency]
However there is inconsistency in how we handle PREALLOC metadata space.
The most obvious one is:
In btrfs_buffered_write():
btrfs_delalloc_release_extents(BTRFS_I(inode), reserve_bytes, true);
We always free qgroup PREALLOC meta space.
While in btrfs_truncate_block():
btrfs_delalloc_release_extents(BTRFS_I(inode), blocksize, (ret != 0));
We only free qgroup PREALLOC meta space when something went wrong.
[The Correct Behavior]
The correct behavior should be the one in btrfs_buffered_write(), we
should always free PREALLOC metadata space.
The reason is, the btrfs_delalloc_* mechanism works by:
- Reserve metadata first, even it's not necessary
In btrfs_delalloc_reserve_metadata()
- Free the unused metadata space
Normally in:
btrfs_delalloc_release_extents()
|- btrfs_inode_rsv_release()
Here we do calculation on whether we should release or not.
E.g. for 64K buffered write, the metadata rsv works like:
/* The first page */
reserve_meta: num_bytes=calc_inode_reservations()
free_meta: num_bytes=0
total: num_bytes=calc_inode_reservations()
/* The first page caused one outstanding extent, thus needs metadata
rsv */
/* The 2nd page */
reserve_meta: num_bytes=calc_inode_reservations()
free_meta: num_bytes=calc_inode_reservations()
total: not changed
/* The 2nd page doesn't cause new outstanding extent, needs no new meta
rsv, so we free what we have reserved */
/* The 3rd~16th pages */
reserve_meta: num_bytes=calc_inode_reservations()
free_meta: num_bytes=calc_inode_reservations()
total: not changed (still space for one outstanding extent)
This means, if btrfs_delalloc_release_extents() determines to free some
space, then those space should be freed NOW.
So for qgroup, we should call btrfs_qgroup_free_meta_prealloc() other
than btrfs_qgroup_convert_reserved_meta().
The good news is:
- The callers are not that hot
The hottest caller is in btrfs_buffered_write(), which is already
fixed by commit 336a8bb8e36a ("btrfs: Fix wrong
btrfs_delalloc_release_extents parameter"). Thus it's not that
easy to cause false EDQUOT.
- The trans commit in advance for qgroup would hide the bug
Since commit f5fef4593653 ("btrfs: qgroup: Make qgroup async transaction
commit more aggressive"), when btrfs qgroup metadata free space is slow,
it will try to commit transaction and free the wrongly converted
PERTRANS space, so it's not that easy to hit such bug.
[FIX]
So to fix the problem, remove the @qgroup_free parameter for
btrfs_delalloc_release_extents(), and always pass true to
btrfs_inode_rsv_release().
Reported-by: Filipe Manana <fdmanana@suse.com>
Fixes: 43b18595d660 ("btrfs: qgroup: Use separate meta reservation type for delalloc")
CC: stable@vger.kernel.org # 4.19+
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
2019-10-14 09:34:51 +03:00
|
|
|
btrfs_inode_rsv_release(inode, true);
|
2019-06-19 22:12:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* btrfs_delalloc_reserve_space - reserve data and metadata space for
|
|
|
|
* delalloc
|
|
|
|
* @inode: inode we're writing to
|
|
|
|
* @start: start range we are writing to
|
|
|
|
* @len: how long the range we are writing to
|
|
|
|
* @reserved: mandatory parameter, record actually reserved qgroup ranges of
|
|
|
|
* current reservation.
|
|
|
|
*
|
|
|
|
* This will do the following things
|
|
|
|
*
|
|
|
|
* - reserve space in data space info for num bytes
|
|
|
|
* and reserve precious corresponding qgroup space
|
|
|
|
* (Done in check_data_free_space)
|
|
|
|
*
|
|
|
|
* - reserve space for metadata space, based on the number of outstanding
|
|
|
|
* extents and how much csums will be needed
|
|
|
|
* also reserve metadata space in a per root over-reserve method.
|
|
|
|
* - add to the inodes->delalloc_bytes
|
|
|
|
* - add it to the fs_info's delalloc inodes list.
|
|
|
|
* (Above 3 all done in delalloc_reserve_metadata)
|
|
|
|
*
|
|
|
|
* Return 0 for success
|
|
|
|
* Return <0 for error(-ENOSPC or -EQUOT)
|
|
|
|
*/
|
2020-06-03 08:55:42 +03:00
|
|
|
int btrfs_delalloc_reserve_space(struct btrfs_inode *inode,
|
2019-06-19 22:12:00 +03:00
|
|
|
struct extent_changeset **reserved, u64 start, u64 len)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2020-06-03 08:55:42 +03:00
|
|
|
ret = btrfs_check_data_free_space(inode, reserved, start, len);
|
2019-06-19 22:12:00 +03:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2020-06-03 08:55:42 +03:00
|
|
|
ret = btrfs_delalloc_reserve_metadata(inode, len);
|
2019-06-19 22:12:00 +03:00
|
|
|
if (ret < 0)
|
2020-06-03 08:55:42 +03:00
|
|
|
btrfs_free_reserved_data_space(inode, *reserved, start, len);
|
2019-06-19 22:12:00 +03:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* btrfs_delalloc_release_space - release data and metadata space for delalloc
|
|
|
|
* @inode: inode we're releasing space for
|
|
|
|
* @start: start position of the space already reserved
|
|
|
|
* @len: the len of the space already reserved
|
|
|
|
* @release_bytes: the len of the space we consumed or didn't use
|
|
|
|
*
|
|
|
|
* This function will release the metadata space that was not used and will
|
|
|
|
* decrement ->delalloc_bytes and remove it from the fs_info delalloc_inodes
|
|
|
|
* list if there are no delalloc bytes left.
|
|
|
|
* Also it will handle the qgroup reserved space.
|
|
|
|
*/
|
2020-06-03 08:55:40 +03:00
|
|
|
void btrfs_delalloc_release_space(struct btrfs_inode *inode,
|
2019-06-19 22:12:00 +03:00
|
|
|
struct extent_changeset *reserved,
|
|
|
|
u64 start, u64 len, bool qgroup_free)
|
|
|
|
{
|
2020-06-03 08:55:40 +03:00
|
|
|
btrfs_delalloc_release_metadata(inode, len, qgroup_free);
|
|
|
|
btrfs_free_reserved_data_space(inode, reserved, start, len);
|
2019-06-19 22:12:00 +03:00
|
|
|
}
|