btrfs: remove the dirty_page local variable

Inside btrfs_buffered_write(), we have a local variable @dirty_pages,
recording the number of pages we dirtied in the current iteration.

However we do not really need that variable, since it can be calculated
from @pos and @copied.

In fact there is already a problem inside the short copy path, where we
use @dirty_pages to calculate the range we need to release.
But that usage assumes sectorsize == PAGE_SIZE, which is no longer true.

Instead of keeping @dirty_pages and cause incorrect usage, just
calculate the number of dirtied pages inside btrfs_dirty_pages().

Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 4fb521d91b061276a1c09a366cbbe0bed6459862..9555a3485670be5b8f18f44e09286917265ac9b8 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -124,12 +124,14 @@ static void btrfs_drop_pages(struct btrfs_fs_info *fs_info,
  * - Update inode size for past EOF write
  */
 int btrfs_dirty_pages(struct btrfs_inode *inode, struct page **pages,
-                     size_t num_pages, loff_t pos, size_t write_bytes,
+                     loff_t pos, size_t write_bytes,
                      struct extent_state **cached, bool noreserve)
 {
        struct btrfs_fs_info *fs_info = inode->root->fs_info;
        int ret = 0;
        int i;
+       const int num_pages = (round_up(pos + write_bytes, PAGE_SIZE) -
+                              round_down(pos, PAGE_SIZE)) >> PAGE_SHIFT;
        u64 num_bytes;
        u64 start_pos;
        u64 end_of_last_block;
@@ -1242,7 +1244,6 @@ ssize_t btrfs_buffered_write(struct kiocb *iocb, struct iov_iter *i)
                                         offset);
                size_t num_pages;
                size_t reserve_bytes;
-               size_t dirty_pages;
                size_t copied;
                size_t dirty_sectors;
                size_t num_sectors;
@@ -1361,11 +1362,8 @@ again:
                if (copied == 0) {
                        force_page_uptodate = true;
                        dirty_sectors = 0;
-                       dirty_pages = 0;
                } else {
                        force_page_uptodate = false;
-                       dirty_pages = DIV_ROUND_UP(copied + offset,
-                                                  PAGE_SIZE);
                }
 
                if (num_sectors > dirty_sectors) {
@@ -1375,13 +1373,10 @@ again:
                                btrfs_delalloc_release_metadata(BTRFS_I(inode),
                                                        release_bytes, true);
                        } else {
-                               u64 __pos;
-
-                               __pos = round_down(pos,
-                                                  fs_info->sectorsize) +
-                                       (dirty_pages << PAGE_SHIFT);
+                               u64 release_start = round_up(pos + copied,
+                                                            fs_info->sectorsize);
                                btrfs_delalloc_release_space(BTRFS_I(inode),
-                                               data_reserved, __pos,
+                                               data_reserved, release_start,
                                                release_bytes, true);
                        }
                }
@@ -1390,7 +1385,7 @@ again:
                                        fs_info->sectorsize);
 
                ret = btrfs_dirty_pages(BTRFS_I(inode), pages,
-                                       dirty_pages, pos, copied,
+                                       pos, copied,
                                        &cached_state, only_release_metadata);
 
                /*

diff --git a/fs/btrfs/file.h b/fs/btrfs/file.h
index 912254e653cf968a7a75a905d7b55a40be11d16b..c23d0bf425989c98b77be758a2bcdaac89c064ff 100644 (file)
--- a/fs/btrfs/file.h
+++ b/fs/btrfs/file.h
@@ -35,7 +35,7 @@ ssize_t btrfs_do_write_iter(struct kiocb *iocb, struct iov_iter *from,
                            const struct btrfs_ioctl_encoded_io_args *encoded);
 int btrfs_release_file(struct inode *inode, struct file *file);
 int btrfs_dirty_pages(struct btrfs_inode *inode, struct page **pages,
-                     size_t num_pages, loff_t pos, size_t write_bytes,
+                     loff_t pos, size_t write_bytes,
                      struct extent_state **cached, bool noreserve);
 int btrfs_fdatawrite_range(struct btrfs_inode *inode, loff_t start, loff_t end);
 int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos,

diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index f4bcb25306606ab6020619797c0f763bb3771a89..0d2db205b9f629b0b2dfa4ad75da300becf2eab1 100644 (file)
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -1457,8 +1457,7 @@ static int __btrfs_write_out_cache(struct inode *inode,
        io_ctl_zero_remaining_pages(io_ctl);
 
        /* Everything is written out, now we dirty the pages in the file. */
-       ret = btrfs_dirty_pages(BTRFS_I(inode), io_ctl->pages,
-                               io_ctl->num_pages, 0, i_size_read(inode),
+       ret = btrfs_dirty_pages(BTRFS_I(inode), io_ctl->pages, 0, i_size_read(inode),
                                &cached_state, false);
        if (ret)
                goto out_nospc;