btrfs: export the expected file extent through can_nocow_extent()

Currently function can_nocow_extent() only returns members needed for
extent_map.

However since we will soon change the extent_map structure to be more
like btrfs_file_extent_item, we want to expose the expected file extent
caused by the NOCOW write for future usage.

This introduces a new structure, btrfs_file_extent, to be a more
memory access friendly representation of btrfs_file_extent_item.
And use that structure to expose the expected file extent caused by the
NOCOW write.

For now there is no user of the new structure yet.

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Signed-off-by: Qu Wenruo <wqu@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index 21bd17d84f59356498ea549733a68422114e61e5..38de2fe23f43608049f9da7b1c378a3fa16ccd35 100644 (file)
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -514,9 +514,23 @@ int btrfs_check_sector_csum(struct btrfs_fs_info *fs_info, struct page *page,
                            u32 pgoff, u8 *csum, const u8 * const csum_expected);
 bool btrfs_data_csum_ok(struct btrfs_bio *bbio, struct btrfs_device *dev,
                        u32 bio_offset, struct bio_vec *bv);
+
+/*
+ * This represents details about the target file extent item of a write operation.
+ */
+struct btrfs_file_extent {
+       u64 disk_bytenr;
+       u64 disk_num_bytes;
+       u64 num_bytes;
+       u64 ram_bytes;
+       u64 offset;
+       u8 compression;
+};
+
 noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
                              u64 *orig_start, u64 *orig_block_len,
-                             u64 *ram_bytes, bool nowait, bool strict);
+                             u64 *ram_bytes, struct btrfs_file_extent *file_extent,
+                             bool nowait, bool strict);
 
 void btrfs_del_delalloc_inode(struct btrfs_inode *inode);
 struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry);

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index ebb769777da4f3207d76367cfc17842c9cff25ac..e3ef1659b6aef0eaedb6e87d874bc90e88c052e8 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1104,7 +1104,7 @@ int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos,
                                                   &cached_state);
        }
        ret = can_nocow_extent(&inode->vfs_inode, lockstart, &num_bytes,
-                       NULL, NULL, NULL, nowait, false);
+                              NULL, NULL, NULL, NULL, nowait, false);
        if (ret <= 0)
                btrfs_drew_write_unlock(&root->snapshot_lock);
        else

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 0ab5f8237d0842646adbbf1ba871dfd97ea0b332..5696babaa9870355a6b9af2a0bdf12b66ba641a4 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1856,6 +1856,9 @@ struct can_nocow_file_extent_args {
        u64 extent_offset;
        /* Number of bytes that can be written to in NOCOW mode. */
        u64 num_bytes;
+
+       /* The expected file extent for the NOCOW write. */
+       struct btrfs_file_extent file_extent;
 };
 
 /*
@@ -1920,6 +1923,12 @@ static int can_nocow_file_extent(struct btrfs_path *path,
 
        extent_end = btrfs_file_extent_end(path);
 
+       args->file_extent.disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
+       args->file_extent.disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
+       args->file_extent.ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
+       args->file_extent.offset = btrfs_file_extent_offset(leaf, fi);
+       args->file_extent.compression = btrfs_file_extent_compression(leaf, fi);
+
        /*
         * The following checks can be expensive, as they need to take other
         * locks and do btree or rbtree searches, so release the path to avoid
@@ -1954,6 +1963,9 @@ static int can_nocow_file_extent(struct btrfs_path *path,
        args->disk_bytenr += args->start - key->offset;
        args->num_bytes = min(args->end + 1, extent_end) - args->start;
 
+       args->file_extent.num_bytes = args->num_bytes;
+       args->file_extent.offset += args->start - key->offset;
+
        /*
         * Force COW if csums exist in the range. This ensures that csums for a
         * given extent are either valid or do not exist.
@@ -7138,7 +7150,8 @@ static bool btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr)
  */
 noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
                              u64 *orig_start, u64 *orig_block_len,
-                             u64 *ram_bytes, bool nowait, bool strict)
+                             u64 *ram_bytes, struct btrfs_file_extent *file_extent,
+                             bool nowait, bool strict)
 {
        struct btrfs_fs_info *fs_info = inode_to_fs_info(inode);
        struct can_nocow_file_extent_args nocow_args = { 0 };
@@ -7227,6 +7240,8 @@ noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
                *orig_start = key.offset - nocow_args.extent_offset;
        if (orig_block_len)
                *orig_block_len = nocow_args.disk_num_bytes;
+       if (file_extent)
+               memcpy(file_extent, &nocow_args.file_extent, sizeof(*file_extent));
 
        *len = nocow_args.num_bytes;
        ret = 1;
@@ -7446,7 +7461,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map,
                block_start = em->block_start + (start - em->start);
 
                if (can_nocow_extent(inode, start, &len, &orig_start,
-                                    &orig_block_len, &ram_bytes, false, false) == 1) {
+                                    &orig_block_len, &ram_bytes, NULL, false, false) == 1) {
                        bg = btrfs_inc_nocow_writers(fs_info, block_start);
                        if (bg)
                                can_nocow = true;
@@ -10640,7 +10655,7 @@ static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file,
                free_extent_map(em);
                em = NULL;
 
-               ret = can_nocow_extent(inode, start, &len, NULL, NULL, NULL, false, true);
+               ret = can_nocow_extent(inode, start, &len, NULL, NULL, NULL, NULL, false, true);
                if (ret < 0) {
                        goto out;
                } else if (ret) {