btrfs: cleanup for extent_write_locked_range()

There are several cleanups for extent_write_locked_range(), most of them
are pure cleanups, but with some preparation for future subpage support.

- Add a proper comment for which call sites are suitable
  Unlike regular synchronized extent write back, if async COW or zoned
  COW happens, we have all pages in the range still locked.

  Thus for those (only) two call sites, we need this function to submit
  page content into bios and submit them.

- Remove @mode parameter
  All the existing two call sites pass WB_SYNC_ALL. No need for @mode
  parameter.

- Better error handling
  Currently if we hit an error during the page iteration loop, we
  overwrite @ret, causing only the last error can be recorded.

  Here we add @found_error and @first_error variable to record if we hit
  any error, and the first error we hit.
  So the first error won't get lost.

- Don't reuse @start as the cursor
  We reuse the parameter @start as the cursor to iterate the range, not
  a big problem, but since we're here, introduce a proper @cur as the
  cursor.

- Remove impossible branch
  Since all pages are still locked after the ordered extent is inserted,
  there is no way that pages can get its dirty bit cleared.
  Remove the branch where page is not dirty and replace it with an
  ASSERT().

Signed-off-by: Qu Wenruo <wqu@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 e9d68b8ee9e6b627e4fdfd4bdfcd7959d3d83fcc..a010a405820775015e504910b166710772a9f45e 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -5073,23 +5073,29 @@ int extent_write_full_page(struct page *page, struct writeback_control *wbc)
        return ret;
 }
 
-int extent_write_locked_range(struct inode *inode, u64 start, u64 end,
-                             int mode)
+/*
+ * Submit the pages in the range to bio for call sites which delalloc range has
+ * already been ran (aka, ordered extent inserted) and all pages are still
+ * locked.
+ */
+int extent_write_locked_range(struct inode *inode, u64 start, u64 end)
 {
+       bool found_error = false;
+       int first_error = 0;
        int ret = 0;
        struct address_space *mapping = inode->i_mapping;
        struct page *page;
+       u64 cur = start;
        unsigned long nr_pages = (end - start + PAGE_SIZE) >>
                PAGE_SHIFT;
-
        struct extent_page_data epd = {
                .bio_ctrl = { 0 },
                .extent_locked = 1,
-               .sync_io = mode == WB_SYNC_ALL,
+               .sync_io = 1,
        };
        struct writeback_control wbc_writepages = {
-               .sync_mode      = mode,
                .nr_to_write    = nr_pages * 2,
+               .sync_mode      = WB_SYNC_ALL,
                .range_start    = start,
                .range_end      = end + 1,
                /* We're called from an async helper function */
@@ -5098,26 +5104,33 @@ int extent_write_locked_range(struct inode *inode, u64 start, u64 end,
        };
 
        wbc_attach_fdatawrite_inode(&wbc_writepages, inode);
-       while (start <= end) {
-               page = find_get_page(mapping, start >> PAGE_SHIFT);
-               if (clear_page_dirty_for_io(page))
-                       ret = __extent_writepage(page, &wbc_writepages, &epd);
-               else {
-                       btrfs_writepage_endio_finish_ordered(BTRFS_I(inode),
-                                       page, start, start + PAGE_SIZE - 1, true);
-                       unlock_page(page);
+       while (cur <= end) {
+               page = find_get_page(mapping, cur >> PAGE_SHIFT);
+               /*
+                * All pages in the range are locked since
+                * btrfs_run_delalloc_range(), thus there is no way to clear
+                * the page dirty flag.
+                */
+               ASSERT(PageDirty(page));
+               clear_page_dirty_for_io(page);
+               ret = __extent_writepage(page, &wbc_writepages, &epd);
+               ASSERT(ret <= 0);
+               if (ret < 0) {
+                       found_error = true;
+                       first_error = ret;
                }
                put_page(page);
-               start += PAGE_SIZE;
+               cur += PAGE_SIZE;
        }
 
-       ASSERT(ret <= 0);
-       if (ret == 0)
+       if (!found_error)
                ret = flush_write_bio(&epd);
        else
                end_write_bio(&epd, ret);
 
        wbc_detach_inode(&wbc_writepages);
+       if (found_error)
+               return first_error;
        return ret;
 }
 

diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index a3ecfd4f37ac2fc9364fb86328ac19cb2c8a57e8..0399cf8e3c32c5c3a5e5141bd07cea93e2abcaa6 100644 (file)
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -184,8 +184,7 @@ int btrfs_do_readpage(struct page *page, struct extent_map **em_cached,
                      struct btrfs_bio_ctrl *bio_ctrl,
                      unsigned int read_flags, u64 *prev_em_start);
 int extent_write_full_page(struct page *page, struct writeback_control *wbc);
-int extent_write_locked_range(struct inode *inode, u64 start, u64 end,
-                             int mode);
+int extent_write_locked_range(struct inode *inode, u64 start, u64 end);
 int extent_writepages(struct address_space *mapping,
                      struct writeback_control *wbc);
 int btree_write_cache_pages(struct address_space *mapping,

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index bb47b0b04a0ae6c3ba47cae2ca772d2bc9a51cfa..aaeb2192b24d38d8ee8f708af01b01a44e17c851 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -873,8 +873,7 @@ static int submit_one_async_extent(struct btrfs_inode *inode,
                 * drive.
                 */
                if (!page_started && !ret)
-                       extent_write_locked_range(&inode->vfs_inode, start,
-                                                 end, WB_SYNC_ALL);
+                       extent_write_locked_range(&inode->vfs_inode, start, end);
                else if (ret && async_chunk->locked_page)
                        unlock_page(async_chunk->locked_page);
                kfree(async_extent);
@@ -1454,7 +1453,7 @@ static noinline int run_delalloc_zoned(struct btrfs_inode *inode,
 
        __set_page_dirty_nobuffers(locked_page);
        account_page_redirty(locked_page);
-       extent_write_locked_range(&inode->vfs_inode, start, end, WB_SYNC_ALL);
+       extent_write_locked_range(&inode->vfs_inode, start, end);
        *page_started = 1;
 
        return 0;