btrfs: support different disk extent size for delalloc

Currently, we always reserve the same extent size in the file and extent
size on disk for delalloc because the former is the worst case for the
latter. For BTRFS_IOC_ENCODED_WRITE writes, we know the exact size of
the extent on disk, which may be less than or greater than (for
bookends) the size in the file. Add a disk_num_bytes parameter to
btrfs_delalloc_reserve_metadata() so that we can reserve the correct
amount of csum bytes. No functional change.

Reviewed-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Signed-off-by: Omar Sandoval <osandov@fb.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index aa88dd70ac48b227a2ca15c68362c229be1fa55a..91b27d5eb8cfc395612febfa3d2b0061337eb029 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2887,7 +2887,8 @@ void btrfs_subvolume_release_metadata(struct btrfs_root *root,
                                      struct btrfs_block_rsv *rsv);
 void btrfs_delalloc_release_extents(struct btrfs_inode *inode, u64 num_bytes);
 
-int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes);
+int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes,
+                                   u64 disk_num_bytes);
 u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo);
 int btrfs_error_unpin_extent_range(struct btrfs_fs_info *fs_info,
                                   u64 start, u64 end);

diff --git a/fs/btrfs/delalloc-space.c b/fs/btrfs/delalloc-space.c
index fb46a28f50659f431d2b325d6548b411795ff30c..bd8267c4687d93d34ba786924a467c337d93aee1 100644 (file)
--- a/fs/btrfs/delalloc-space.c
+++ b/fs/btrfs/delalloc-space.c
@@ -270,11 +270,11 @@ static void btrfs_calculate_inode_block_rsv_size(struct btrfs_fs_info *fs_info,
 }
 
 static void calc_inode_reservations(struct btrfs_fs_info *fs_info,
-                                   u64 num_bytes, u64 *meta_reserve,
-                                   u64 *qgroup_reserve)
+                                   u64 num_bytes, u64 disk_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);
+       u64 csum_leaves = btrfs_csum_bytes_to_leaves(fs_info, disk_num_bytes);
        u64 inode_update = btrfs_calc_metadata_size(fs_info, 1);
 
        *meta_reserve = btrfs_calc_insert_metadata_size(fs_info,
@@ -288,7 +288,8 @@ static void calc_inode_reservations(struct btrfs_fs_info *fs_info,
        *qgroup_reserve = nr_extents * fs_info->nodesize;
 }
 
-int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes)
+int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes,
+                                   u64 disk_num_bytes)
 {
        struct btrfs_root *root = inode->root;
        struct btrfs_fs_info *fs_info = root->fs_info;
@@ -318,6 +319,7 @@ int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes)
        }
 
        num_bytes = ALIGN(num_bytes, fs_info->sectorsize);
+       disk_num_bytes = ALIGN(disk_num_bytes, fs_info->sectorsize);
 
        /*
         * We always want to do it this way, every other way is wrong and ends
@@ -329,8 +331,8 @@ int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes)
         * 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);
+       calc_inode_reservations(fs_info, num_bytes, disk_num_bytes,
+                               &meta_reserve, &qgroup_reserve);
        ret = btrfs_qgroup_reserve_meta_prealloc(root, qgroup_reserve, true);
        if (ret)
                return ret;
@@ -349,7 +351,7 @@ int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes)
        spin_lock(&inode->lock);
        nr_extents = count_max_extents(num_bytes);
        btrfs_mod_outstanding_extents(inode, nr_extents);
-       inode->csum_bytes += num_bytes;
+       inode->csum_bytes += disk_num_bytes;
        btrfs_calculate_inode_block_rsv_size(fs_info, inode);
        spin_unlock(&inode->lock);
 
@@ -454,7 +456,7 @@ int btrfs_delalloc_reserve_space(struct btrfs_inode *inode,
        ret = btrfs_check_data_free_space(inode, reserved, start, len);
        if (ret < 0)
                return ret;
-       ret = btrfs_delalloc_reserve_metadata(inode, len);
+       ret = btrfs_delalloc_reserve_metadata(inode, len, len);
        if (ret < 0) {
                btrfs_free_reserved_data_space(inode, *reserved, start, len);
                extent_changeset_free(*reserved);

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 391b05019dbdfa008bb40796e7530207685f702f..7b4a5458ca9b683922cbe224375241659ba8f801 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1719,7 +1719,8 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,
                                         fs_info->sectorsize);
                WARN_ON(reserve_bytes == 0);
                ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode),
-                               reserve_bytes);
+                                                     reserve_bytes,
+                                                     reserve_bytes);
                if (ret) {
                        if (!only_release_metadata)
                                btrfs_free_reserved_data_space(BTRFS_I(inode),

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 5f77554686db4cf96e456660cc691f3aa8ce27ce..38ea51d645534f58a0fa04c0f865ead1a99e4557 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4697,7 +4697,7 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len,
                        goto out;
                }
        }
-       ret = btrfs_delalloc_reserve_metadata(inode, blocksize);
+       ret = btrfs_delalloc_reserve_metadata(inode, blocksize, blocksize);
        if (ret < 0) {
                if (!only_release_metadata)
                        btrfs_free_reserved_data_space(inode, data_reserved,
@@ -7467,7 +7467,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map,
                struct extent_map *em2;
 
                /* We can NOCOW, so only need to reserve metadata space. */
-               ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), len);
+               ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode), len, len);
                if (ret < 0) {
                        /* Our caller expects us to free the input extent map. */
                        free_extent_map(em);

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 9d8054839782e2c62da3c9f9123b099d7786caf2..50130f943d99900a675de1a9123d93ee35d6996c 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -2997,7 +2997,7 @@ static int relocate_one_page(struct inode *inode, struct file_ra_state *ra,
 
                /* Reserve metadata for this range */
                ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode),
-                                                     clamped_len);
+                                                     clamped_len, clamped_len);
                if (ret)
                        goto release_page;