btrfs: cleanup duplicated parameters related to btrfs_alloc_ordered_extent

All parameters after @filepos of btrfs_alloc_ordered_extent() can be
replaced with btrfs_file_extent structure.

This patch does the cleanup, meanwhile some points to note:

- Move btrfs_file_extent structure to ordered-data.h
  The structure is needed by both btrfs_alloc_ordered_extent() and
  can_nocow_extent(), but since btrfs_inode.h includes
  ordered-data.h, so we need to move the structure to ordered-data.h.

- Move the special handling of NOCOW/PREALLOC into
  btrfs_alloc_ordered_extent()
  This is to allow btrfs_split_ordered_extent() to properly split them
  for DIO.
  For now just move the handling into btrfs_alloc_ordered_extent() to
  simplify the callers.

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 be2f66f29b0c6a2659f1618f3682b1349175ff48..db193b3be8eb89abc989142ccf569e1ba6f999b8 100644 (file)
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -514,19 +514,6 @@ 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,
                              struct btrfs_file_extent *file_extent,
                              bool nowait, bool strict);

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index a7c1c90bb57389eee9052074745ee4f8d5d49e64..6ec3dc78ef73a49758b639510ddfaa785badbc96 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1221,14 +1221,8 @@ static void submit_one_async_extent(struct async_chunk *async_chunk,
        }
        free_extent_map(em);
 
-       ordered = btrfs_alloc_ordered_extent(inode, start,      /* file_offset */
-                                      async_extent->ram_size,  /* num_bytes */
-                                      async_extent->ram_size,  /* ram_bytes */
-                                      ins.objectid,            /* disk_bytenr */
-                                      ins.offset,              /* disk_num_bytes */
-                                      0,                       /* offset */
-                                      1 << BTRFS_ORDERED_COMPRESSED,
-                                      async_extent->compress_type);
+       ordered = btrfs_alloc_ordered_extent(inode, start, &file_extent,
+                                            1 << BTRFS_ORDERED_COMPRESSED);
        if (IS_ERR(ordered)) {
                btrfs_drop_extent_map_range(inode, start, end, false);
                ret = PTR_ERR(ordered);
@@ -1464,10 +1458,8 @@ static noinline int cow_file_range(struct btrfs_inode *inode,
                }
                free_extent_map(em);
 
-               ordered = btrfs_alloc_ordered_extent(inode, start, ram_size,
-                                       ram_size, ins.objectid, cur_alloc_size,
-                                       0, 1 << BTRFS_ORDERED_REGULAR,
-                                       BTRFS_COMPRESS_NONE);
+               ordered = btrfs_alloc_ordered_extent(inode, start, &file_extent,
+                                                    1 << BTRFS_ORDERED_REGULAR);
                if (IS_ERR(ordered)) {
                        unlock_extent(&inode->io_tree, start,
                                      start + ram_size - 1, &cached);
@@ -2192,15 +2184,10 @@ must_cow:
                }
 
                ordered = btrfs_alloc_ordered_extent(inode, cur_offset,
-                               nocow_args.file_extent.num_bytes,
-                               nocow_args.file_extent.num_bytes,
-                               nocow_args.file_extent.disk_bytenr +
-                               nocow_args.file_extent.offset,
-                               nocow_args.file_extent.num_bytes, 0,
+                               &nocow_args.file_extent,
                                is_prealloc
                                ? (1 << BTRFS_ORDERED_PREALLOC)
-                               : (1 << BTRFS_ORDERED_NOCOW),
-                               BTRFS_COMPRESS_NONE);
+                               : (1 << BTRFS_ORDERED_NOCOW));
                btrfs_dec_nocow_writers(nocow_bg);
                if (IS_ERR(ordered)) {
                        if (is_prealloc) {
@@ -7055,27 +7042,9 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode,
                        goto out;
        }
 
-       /*
-        * For regular writes, file_extent->offset is always 0, thus we really
-        * only need file_extent->disk_bytenr, every other length
-        * (disk_num_bytes/ram_bytes) should match @len and file_extent->num_bytes.
-        *
-        * For NOCOW, we don't really care about the numbers except @start and
-        * @len, as we won't insert a file extent item at all.
-        *
-        * For PREALLOC, we do not use ordered extent members, but
-        * btrfs_mark_extent_written() handles everything.
-        *
-        * So here we always pass 0 as offset for the ordered extent,
-        * otherwise btrfs_split_ordered_extent() cannot handle it correctly.
-        */
-       ordered = btrfs_alloc_ordered_extent(inode, start, len, len,
-                                            file_extent->disk_bytenr +
-                                            file_extent->offset,
-                                            len, 0,
+       ordered = btrfs_alloc_ordered_extent(inode, start, file_extent,
                                             (1 << type) |
-                                            (1 << BTRFS_ORDERED_DIRECT),
-                                            BTRFS_COMPRESS_NONE);
+                                            (1 << BTRFS_ORDERED_DIRECT));
        if (IS_ERR(ordered)) {
                if (em) {
                        free_extent_map(em);
@@ -10346,12 +10315,9 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from,
        }
        free_extent_map(em);
 
-       ordered = btrfs_alloc_ordered_extent(inode, start, num_bytes, ram_bytes,
-                                      ins.objectid, ins.offset,
-                                      encoded->unencoded_offset,
+       ordered = btrfs_alloc_ordered_extent(inode, start, &file_extent,
                                       (1 << BTRFS_ORDERED_ENCODED) |
-                                      (1 << BTRFS_ORDERED_COMPRESSED),
-                                      compression);
+                                      (1 << BTRFS_ORDERED_COMPRESSED));
        if (IS_ERR(ordered)) {
                btrfs_drop_extent_map_range(inode, start, end, false);
                ret = PTR_ERR(ordered);

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index d446d89c2c3466fc4f82581b0514b2d517590f1e..30a9d4a2e2b6a983bf91367876f46481370dfe29 100644 (file)
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -264,17 +264,39 @@ static void insert_ordered_extent(struct btrfs_ordered_extent *entry)
  */
 struct btrfs_ordered_extent *btrfs_alloc_ordered_extent(
                        struct btrfs_inode *inode, u64 file_offset,
-                       u64 num_bytes, u64 ram_bytes, u64 disk_bytenr,
-                       u64 disk_num_bytes, u64 offset, unsigned long flags,
-                       int compress_type)
+                       struct btrfs_file_extent *file_extent, unsigned long flags)
 {
        struct btrfs_ordered_extent *entry;
 
        ASSERT((flags & ~BTRFS_ORDERED_TYPE_FLAGS) == 0);
 
-       entry = alloc_ordered_extent(inode, file_offset, num_bytes, ram_bytes,
-                                    disk_bytenr, disk_num_bytes, offset, flags,
-                                    compress_type);
+       /*
+        * For regular writes, we just use the members in @file_extent.
+        *
+        * For NOCOW, we don't really care about the numbers except @start and
+        * file_extent->num_bytes, as we won't insert a file extent item at all.
+        *
+        * For PREALLOC, we do not use ordered extent members, but
+        * btrfs_mark_extent_written() handles everything.
+        *
+        * So here we always pass 0 as offset for NOCOW/PREALLOC ordered extents,
+        * or btrfs_split_ordered_extent() cannot handle it correctly.
+        */
+       if (flags & ((1U << BTRFS_ORDERED_NOCOW) | (1U << BTRFS_ORDERED_PREALLOC)))
+               entry = alloc_ordered_extent(inode, file_offset,
+                                            file_extent->num_bytes,
+                                            file_extent->num_bytes,
+                                            file_extent->disk_bytenr + file_extent->offset,
+                                            file_extent->num_bytes, 0, flags,
+                                            file_extent->compression);
+       else
+               entry = alloc_ordered_extent(inode, file_offset,
+                                            file_extent->num_bytes,
+                                            file_extent->ram_bytes,
+                                            file_extent->disk_bytenr,
+                                            file_extent->disk_num_bytes,
+                                            file_extent->offset, flags,
+                                            file_extent->compression);
        if (!IS_ERR(entry))
                insert_ordered_extent(entry);
        return entry;

diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h
index 2ec329e2f0f3659834a527b7285eb18fbb689b67..580982be1b6e8eba5ef0388fb0e8a5a2497fae7e 100644 (file)
--- a/fs/btrfs/ordered-data.h
+++ b/fs/btrfs/ordered-data.h
@@ -171,11 +171,22 @@ void btrfs_mark_ordered_io_finished(struct btrfs_inode *inode,
 bool btrfs_dec_test_ordered_pending(struct btrfs_inode *inode,
                                    struct btrfs_ordered_extent **cached,
                                    u64 file_offset, u64 io_size);
+
+/*
+ * 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;
+};
+
 struct btrfs_ordered_extent *btrfs_alloc_ordered_extent(
                        struct btrfs_inode *inode, u64 file_offset,
-                       u64 num_bytes, u64 ram_bytes, u64 disk_bytenr,
-                       u64 disk_num_bytes, u64 offset, unsigned long flags,
-                       int compress_type);
+                       struct btrfs_file_extent *file_extent, unsigned long flags);
 void btrfs_add_ordered_sum(struct btrfs_ordered_extent *entry,
                           struct btrfs_ordered_sum *sum);
 struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct btrfs_inode *inode,