btrfs: use folio_end() where appropriate

Simplify folio_pos() + folio_size() and use the new helper.

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/compression.h b/fs/btrfs/compression.h
index d34c4341eaf485dc949633ba99104613db7849de..1df3c8dec40a91ca39a4b1c4b72ae414ba2fac2a 100644 (file)
--- a/fs/btrfs/compression.h
+++ b/fs/btrfs/compression.h
@@ -13,6 +13,7 @@
 #include <linux/wait.h>
 #include <linux/pagemap.h>
 #include "bio.h"
+#include "fs.h"
 #include "messages.h"
 
 struct address_space;
@@ -77,12 +78,10 @@ struct compressed_bio {
 /* @range_end must be exclusive. */
 static inline u32 btrfs_calc_input_length(struct folio *folio, u64 range_end, u64 cur)
 {
-       const u64 folio_end = folio_pos(folio) + folio_size(folio);
-
        /* @cur must be inside the folio. */
        ASSERT(folio_pos(folio) <= cur);
-       ASSERT(cur < folio_end);
-       return min(range_end, folio_end) - cur;
+       ASSERT(cur < folio_end(folio));
+       return min(range_end, folio_end(folio)) - cur;
 }
 
 int __init btrfs_init_compress(void);

diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
index faa563ee300049845101aa0733d86498cf933cd0..701b6b51ea8577b347097b91435b61ae3b3e85b9 100644 (file)
--- a/fs/btrfs/defrag.c
+++ b/fs/btrfs/defrag.c
@@ -886,7 +886,7 @@ again:
        }
 
        lock_start = folio_pos(folio);
-       lock_end = folio_pos(folio) + folio_size(folio) - 1;
+       lock_end = folio_end(folio) - 1;
        /* Wait for any existing ordered extent in the range */
        while (1) {
                struct btrfs_ordered_extent *ordered;
@@ -1178,8 +1178,7 @@ static int defrag_one_locked_target(struct btrfs_inode *inode,
 
                if (!folio)
                        break;
-               if (start >= folio_pos(folio) + folio_size(folio) ||
-                   start + len <= folio_pos(folio))
+               if (start >= folio_end(folio) || start + len <= folio_pos(folio))
                        continue;
                btrfs_folio_clamp_clear_checked(fs_info, folio, start, len);
                btrfs_folio_clamp_set_dirty(fs_info, folio, start, len);
@@ -1220,7 +1219,7 @@ static int defrag_one_range(struct btrfs_inode *inode, u64 start, u32 len,
                        folios[i] = NULL;
                        goto free_folios;
                }
-               cur = folio_pos(folios[i]) + folio_size(folios[i]);
+               cur = folio_end(folios[i]);
        }
        for (int i = 0; i < nr_pages; i++) {
                if (!folios[i])

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index f869309c8aa1aca72e5168adc0e1fba119062417..3628bd504e37357bd04fbb882b4ebc4f35f77574 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -266,8 +266,7 @@ static noinline int lock_delalloc_folios(struct inode *inode,
                                goto out;
                        }
                        range_start = max_t(u64, folio_pos(folio), start);
-                       range_len = min_t(u64, folio_pos(folio) + folio_size(folio),
-                                         end + 1) - range_start;
+                       range_len = min_t(u64, folio_end(folio), end + 1) - range_start;
                        btrfs_folio_set_lock(fs_info, folio, range_start, range_len);
 
                        processed_end = range_start + range_len - 1;
@@ -321,7 +320,7 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode,
        ASSERT(orig_end > orig_start);
 
        /* The range should at least cover part of the folio */
-       ASSERT(!(orig_start >= folio_pos(locked_folio) + folio_size(locked_folio) ||
+       ASSERT(!(orig_start >= folio_end(locked_folio) ||
                 orig_end <= folio_pos(locked_folio)));
 again:
        /* step one, find a bunch of delalloc bytes starting at start */
@@ -419,7 +418,7 @@ static void end_folio_read(struct folio *folio, bool uptodate, u64 start, u32 le
        struct btrfs_fs_info *fs_info = folio_to_fs_info(folio);
 
        ASSERT(folio_pos(folio) <= start &&
-              start + len <= folio_pos(folio) + folio_size(folio));
+              start + len <= folio_end(folio));
 
        if (uptodate && btrfs_verify_folio(folio, start, len))
                btrfs_folio_set_uptodate(fs_info, folio, start, len);
@@ -1086,7 +1085,7 @@ static bool can_skip_one_ordered_range(struct btrfs_inode *inode,
         * finished our folio read and unlocked the folio.
         */
        if (btrfs_folio_test_dirty(fs_info, folio, cur, blocksize)) {
-               u64 range_len = min(folio_pos(folio) + folio_size(folio),
+               u64 range_len = min(folio_end(folio),
                                    ordered->file_offset + ordered->num_bytes) - cur;
 
                ret = true;
@@ -1108,7 +1107,7 @@ static bool can_skip_one_ordered_range(struct btrfs_inode *inode,
         * So we return true and update @next_ret to the OE/folio boundary.
         */
        if (btrfs_folio_test_uptodate(fs_info, folio, cur, blocksize)) {
-               u64 range_len = min(folio_pos(folio) + folio_size(folio),
+               u64 range_len = min(folio_end(folio),
                                    ordered->file_offset + ordered->num_bytes) - cur;
 
                /*
@@ -2085,7 +2084,7 @@ static noinline_for_stack void write_one_eb(struct extent_buffer *eb,
        for (int i = 0; i < num_extent_folios(eb); i++) {
                struct folio *folio = eb->folios[i];
                u64 range_start = max_t(u64, eb->start, folio_pos(folio));
-               u32 range_len = min_t(u64, folio_pos(folio) + folio_size(folio),
+               u32 range_len = min_t(u64, folio_end(folio),
                                      eb->start + eb->len) - range_start;
 
                folio_lock(folio);
@@ -2489,7 +2488,7 @@ void extent_write_locked_range(struct inode *inode, const struct folio *locked_f
                        continue;
                }
 
-               cur_end = min_t(u64, folio_pos(folio) + folio_size(folio) - 1, end);
+               cur_end = min_t(u64, folio_end(folio) - 1, end);
                cur_len = cur_end + 1 - cur;
 
                ASSERT(folio_test_locked(folio));
@@ -3728,7 +3727,7 @@ int read_extent_buffer_pages_nowait(struct extent_buffer *eb, int mirror_num,
        for (int i = 0; i < num_extent_folios(eb); i++) {
                struct folio *folio = eb->folios[i];
                u64 range_start = max_t(u64, eb->start, folio_pos(folio));
-               u32 range_len = min_t(u64, folio_pos(folio) + folio_size(folio),
+               u32 range_len = min_t(u64, folio_end(folio),
                                      eb->start + eb->len) - range_start;
 
                bio_add_folio_nofail(&bbio->bio, folio, range_len,

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 2902de88dd1b2891068d7641dcbb0537c5ecf171..0826305628387adbca8292b666419b29cd93fafa 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -89,8 +89,7 @@ int btrfs_dirty_folio(struct btrfs_inode *inode, struct folio *folio, loff_t pos
        num_bytes = round_up(write_bytes + pos - start_pos,
                             fs_info->sectorsize);
        ASSERT(num_bytes <= U32_MAX);
-       ASSERT(folio_pos(folio) <= pos &&
-              folio_pos(folio) + folio_size(folio) >= pos + write_bytes);
+       ASSERT(folio_pos(folio) <= pos && folio_end(folio) >= pos + write_bytes);
 
        end_of_last_block = start_pos + num_bytes - 1;
 
@@ -801,7 +800,7 @@ static int prepare_uptodate_folio(struct inode *inode, struct folio *folio, u64
                                  u64 len)
 {
        u64 clamp_start = max_t(u64, pos, folio_pos(folio));
-       u64 clamp_end = min_t(u64, pos + len, folio_pos(folio) + folio_size(folio));
+       u64 clamp_end = min_t(u64, pos + len, folio_end(folio));
        const u32 blocksize = inode_to_fs_info(inode)->sectorsize;
        int ret = 0;
 
@@ -1233,8 +1232,8 @@ again:
         * The reserved range goes beyond the current folio, shrink the reserved
         * space to the folio boundary.
         */
-       if (reserved_start + reserved_len > folio_pos(folio) + folio_size(folio)) {
-               const u64 last_block = folio_pos(folio) + folio_size(folio);
+       if (reserved_start + reserved_len > folio_end(folio)) {
+               const u64 last_block = folio_end(folio);
 
                shrink_reserved_space(inode, *data_reserved, reserved_start,
                                      reserved_len, last_block - reserved_start,

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 391a1f71d7b2ed3a6657de73c698a581686df79d..12141348236d5b58fe181a4b261c7185d917184c 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -2328,8 +2328,7 @@ int btrfs_run_delalloc_range(struct btrfs_inode *inode, struct folio *locked_fol
         * The range must cover part of the @locked_folio, or a return of 1
         * can confuse the caller.
         */
-       ASSERT(!(end <= folio_pos(locked_folio) ||
-                start >= folio_pos(locked_folio) + folio_size(locked_folio)));
+       ASSERT(!(end <= folio_pos(locked_folio) || start >= folio_end(locked_folio)));
 
        if (should_nocow(inode, start, end)) {
                ret = run_delalloc_nocow(inode, locked_folio, start, end);
@@ -2737,7 +2736,7 @@ static void btrfs_writepage_fixup_worker(struct btrfs_work *work)
        struct btrfs_inode *inode = fixup->inode;
        struct btrfs_fs_info *fs_info = inode->root->fs_info;
        u64 page_start = folio_pos(folio);
-       u64 page_end = folio_pos(folio) + folio_size(folio) - 1;
+       u64 page_end = folio_end(folio) - 1;
        int ret = 0;
        bool free_delalloc_space = true;
 
@@ -4819,7 +4818,7 @@ again:
         */
 
        zero_start = max_t(u64, folio_pos(folio), start);
-       zero_end = folio_pos(folio) + folio_size(folio);
+       zero_end = folio_end(folio);
        folio_zero_range(folio, zero_start - folio_pos(folio),
                         zero_end - zero_start);
 
@@ -4999,8 +4998,7 @@ again:
                 * not reach disk, it still affects our page caches.
                 */
                zero_start = max_t(u64, folio_pos(folio), start);
-               zero_end = min_t(u64, folio_pos(folio) + folio_size(folio) - 1,
-                                end);
+               zero_end = min_t(u64, folio_end(folio) - 1, end);
        } else {
                zero_start = max_t(u64, block_start, start);
                zero_end = min_t(u64, block_end, end);

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 9212ce110cdeef2b2135939a5eaae2ceb55c3587..2829f20d7bb59de71d2ecb19b5c966b7e1f08c2e 100644 (file)
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -359,7 +359,7 @@ static bool can_finish_ordered_extent(struct btrfs_ordered_extent *ordered,
        if (folio) {
                ASSERT(folio->mapping);
                ASSERT(folio_pos(folio) <= file_offset);
-               ASSERT(file_offset + len <= folio_pos(folio) + folio_size(folio));
+               ASSERT(file_offset + len <= folio_end(folio));
 
                /*
                 * Ordered flag indicates whether we still have

diff --git a/fs/btrfs/subpage.c b/fs/btrfs/subpage.c
index 9b63a4d1c98906bef0064bff9f9aa5e9f26f157a..2c5c9262b1a83f136bfc84327c82d09f9cec5b70 100644 (file)
--- a/fs/btrfs/subpage.c
+++ b/fs/btrfs/subpage.c
@@ -187,7 +187,7 @@ static void btrfs_subpage_assert(const struct btrfs_fs_info *fs_info,
         */
        if (folio->mapping)
                ASSERT(folio_pos(folio) <= start &&
-                      start + len <= folio_pos(folio) + folio_size(folio));
+                      start + len <= folio_end(folio));
 }
 
 #define subpage_calc_start_bit(fs_info, folio, name, start, len)       \
@@ -216,8 +216,7 @@ static void btrfs_subpage_clamp_range(struct folio *folio, u64 *start, u32 *len)
        if (folio_pos(folio) >= orig_start + orig_len)
                *len = 0;
        else
-               *len = min_t(u64, folio_pos(folio) + folio_size(folio),
-                            orig_start + orig_len) - *start;
+               *len = min_t(u64, folio_end(folio), orig_start + orig_len) - *start;
 }
 
 static bool btrfs_subpage_end_and_test_lock(const struct btrfs_fs_info *fs_info,