btrfs: refactor __extent_writepage_io() to improve readability

The refactoring involves the following modifications:

- iosize alignment
  In fact we don't really need to manually do alignment at all.
  All extent maps should already be aligned, thus basic ASSERT() check
  would be enough.

- redundant variables
  We have extra variable like blocksize/pg_offset/end.
  They are all unnecessary.

  @blocksize can be replaced by sectorsize size directly, and it's only
  used to verify the em start/size is aligned.

  @pg_offset can be easily calculated using @cur and page_offset(page).

  @end is just assigned from @page_end and never modified, use
  "start + PAGE_SIZE - 1" directly and remove @page_end.

- remove some BUG_ON()s
  The BUG_ON()s are for extent map, which we have tree-checker to check
  on-disk extent data item and runtime check.
  ASSERT() should be enough.

Reviewed-by: Josef Bacik <josef@toxicpanda.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/extent_io.c b/fs/btrfs/extent_io.c
index 6099061..74c0a32 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -3513,23 +3513,20 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
                                 unsigned long nr_written,
                                 int *nr_ret)
 {
+       struct btrfs_fs_info *fs_info = inode->root->fs_info;
        struct extent_io_tree *tree = &inode->io_tree;
        u64 start = page_offset(page);
-       u64 page_end = start + PAGE_SIZE - 1;
-       u64 end;
+       u64 end = start + PAGE_SIZE - 1;
        u64 cur = start;
        u64 extent_offset;
        u64 block_start;
-       u64 iosize;
        struct extent_map *em;
-       size_t pg_offset = 0;
-       size_t blocksize;
        int ret = 0;
        int nr = 0;
        const unsigned int write_flags = wbc_to_write_flags(wbc);
        bool compressed;
 
-       ret = btrfs_writepage_cow_fixup(page, start, page_end);
+       ret = btrfs_writepage_cow_fixup(page, start, end);
        if (ret) {
                /* Fixup worker will requeue */
                redirty_page_for_writepage(wbc, page);
@@ -3544,16 +3541,13 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
         */
        update_nr_written(wbc, nr_written + 1);
 
-       end = page_end;
-       blocksize = inode->vfs_inode.i_sb->s_blocksize;
-
        while (cur <= end) {
                u64 disk_bytenr;
                u64 em_end;
+               u32 iosize;
 
                if (cur >= i_size) {
-                       btrfs_writepage_endio_finish_ordered(page, cur,
-                                                            page_end, 1);
+                       btrfs_writepage_endio_finish_ordered(page, cur, end, 1);
                        break;
                }
                em = btrfs_get_extent(inode, NULL, 0, cur, end - cur + 1);
@@ -3565,13 +3559,16 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
 
                extent_offset = cur - em->start;
                em_end = extent_map_end(em);
-               BUG_ON(em_end <= cur);
-               BUG_ON(end < cur);
-               iosize = min(em_end - cur, end - cur + 1);
-               iosize = ALIGN(iosize, blocksize);
-               disk_bytenr = em->block_start + extent_offset;
+               ASSERT(cur <= em_end);
+               ASSERT(cur < end);
+               ASSERT(IS_ALIGNED(em->start, fs_info->sectorsize));
+               ASSERT(IS_ALIGNED(em->len, fs_info->sectorsize));
                block_start = em->block_start;
                compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
+               disk_bytenr = em->block_start + extent_offset;
+
+               /* Note that em_end from extent_map_end() is exclusive */
+               iosize = min(em_end, end + 1) - cur;
                free_extent_map(em);
                em = NULL;
 
@@ -3587,7 +3584,6 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
                                btrfs_writepage_endio_finish_ordered(page, cur,
                                                        cur + iosize - 1, 1);
                        cur += iosize;
-                       pg_offset += iosize;
                        continue;
                }
 
@@ -3599,8 +3595,8 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
                }
 
                ret = submit_extent_page(REQ_OP_WRITE | write_flags, wbc,
-                                        page, disk_bytenr, iosize, pg_offset,
-                                        &epd->bio,
+                                        page, disk_bytenr, iosize,
+                                        cur - page_offset(page), &epd->bio,
                                         end_bio_extent_writepage,
                                         0, 0, 0, false);
                if (ret) {
@@ -3609,8 +3605,7 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,
                                end_page_writeback(page);
                }
 
-               cur = cur + iosize;
-               pg_offset += iosize;
+               cur += iosize;
                nr++;
        }
        *nr_ret = nr;