btrfs: rename PagePrivate2 to PageOrdered inside btrfs

Inside btrfs we use Private2 page status to indicate we have an ordered
extent with pending IO for the sector.

But the page status name, Private2, tells us nothing about the bit
itself, so this patch will rename it to Ordered.
And with extra comment about the bit added, so reader who is still
uncertain about the page Ordered status, will find the comment pretty
easily.

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/ctree.h b/fs/btrfs/ctree.h
index 70952c1a39d1c80d4ab0b54a2997e931f42bd46a..c63980977fa4d919b0a346709a0ebba9bc22b362 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -3799,4 +3799,14 @@ static inline bool btrfs_is_zoned(const struct btrfs_fs_info *fs_info)
        return fs_info->zoned != 0;
 }
 
+/*
+ * We use page status Private2 to indicate there is an ordered extent with
+ * unfinished IO.
+ *
+ * Rename the Private2 accessors to Ordered, to improve readability.
+ */
+#define PageOrdered(page)              PagePrivate2(page)
+#define SetPageOrdered(page)           SetPagePrivate2(page)
+#define ClearPageOrdered(page)         ClearPagePrivate2(page)
+
 #endif

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index c0600dec62f8baba194e471ef8129e002c43ddb7..13c5e880404da35b1f99bcd2cb829ea4a0a602b4 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -1975,8 +1975,8 @@ static int __process_pages_contig(struct address_space *mapping,
                }
 
                for (i = 0; i < ret; i++) {
-                       if (page_ops & PAGE_SET_PRIVATE2)
-                               SetPagePrivate2(pages[i]);
+                       if (page_ops & PAGE_SET_ORDERED)
+                               SetPageOrdered(pages[i]);
 
                        if (locked_page && pages[i] == locked_page) {
                                put_page(pages[i]);

diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 946d09caa5925485baeddcf84cf7483148774894..62027f551b4456caa394b288f69cf846b3b65861 100644 (file)
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -39,7 +39,7 @@ enum {
 /* Page starts writeback, clear dirty bit and set writeback bit */
 #define PAGE_START_WRITEBACK   (1 << 1)
 #define PAGE_END_WRITEBACK     (1 << 2)
-#define PAGE_SET_PRIVATE2      (1 << 3)
+#define PAGE_SET_ORDERED       (1 << 3)
 #define PAGE_SET_ERROR         (1 << 4)
 #define PAGE_LOCK              (1 << 5)
 

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index f036b6e992dfefca8a0bb27c5a9a286e262fabd1..412abf923136502ae507efffd989c306bf110230 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -170,7 +170,7 @@ static inline void btrfs_cleanup_ordered_extents(struct btrfs_inode *inode,
                index++;
                if (!page)
                        continue;
-               ClearPagePrivate2(page);
+               ClearPageOrdered(page);
                put_page(page);
        }
 
@@ -1151,15 +1151,16 @@ static noinline int cow_file_range(struct btrfs_inode *inode,
 
                btrfs_dec_block_group_reservations(fs_info, ins.objectid);
 
-               /* we're not doing compressed IO, don't unlock the first
-                * page (which the caller expects to stay locked), don't
-                * clear any dirty bits and don't set any writeback bits
+               /*
+                * We're not doing compressed IO, don't unlock the first page
+                * (which the caller expects to stay locked), don't clear any
+                * dirty bits and don't set any writeback bits
                 *
-                * Do set the Private2 bit so we know this page was properly
-                * setup for writepage
+                * Do set the Ordered (Private2) bit so we know this page was
+                * properly setup for writepage.
                 */
                page_ops = unlock ? PAGE_UNLOCK : 0;
-               page_ops |= PAGE_SET_PRIVATE2;
+               page_ops |= PAGE_SET_ORDERED;
 
                extent_clear_unlock_delalloc(inode, start, start + ram_size - 1,
                                             locked_page,
@@ -1823,7 +1824,7 @@ out_check:
                                             locked_page, EXTENT_LOCKED |
                                             EXTENT_DELALLOC |
                                             EXTENT_CLEAR_DATA_RESV,
-                                            PAGE_UNLOCK | PAGE_SET_PRIVATE2);
+                                            PAGE_UNLOCK | PAGE_SET_ORDERED);
 
                cur_offset = extent_end;
 
@@ -2571,7 +2572,7 @@ again:
        lock_extent_bits(&inode->io_tree, page_start, page_end, &cached_state);
 
        /* already ordered? We're done */
-       if (PagePrivate2(page))
+       if (PageOrdered(page))
                goto out_reserved;
 
        ordered = btrfs_lookup_ordered_range(inode, page_start, PAGE_SIZE);
@@ -2646,8 +2647,8 @@ int btrfs_writepage_cow_fixup(struct page *page, u64 start, u64 end)
        struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
        struct btrfs_writepage_fixup *fixup;
 
-       /* this page is properly in the ordered list */
-       if (PagePrivate2(page))
+       /* This page has ordered extent covering it already */
+       if (PageOrdered(page))
                return 0;
 
        /*
@@ -8300,9 +8301,9 @@ static int btrfs_migratepage(struct address_space *mapping,
        if (page_has_private(page))
                attach_page_private(newpage, detach_page_private(page));
 
-       if (PagePrivate2(page)) {
-               ClearPagePrivate2(page);
-               SetPagePrivate2(newpage);
+       if (PageOrdered(page)) {
+               ClearPageOrdered(page);
+               SetPageOrdered(newpage);
        }
 
        if (mode != MIGRATE_SYNC_NO_COPY)
@@ -8329,9 +8330,10 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,
         * page, nor bio can be submitted for this page.
         *
         * But already submitted bio can still be finished on this page.
-        * Furthermore, endio function won't skip page which has Private2
-        * already cleared, so it's possible for endio and invalidatepage to do
-        * the same ordered extent accounting twice on one page.
+        * Furthermore, endio function won't skip page which has Ordered
+        * (Private2) already cleared, so it's possible for endio and
+        * invalidatepage to do the same ordered extent accounting twice
+        * on one page.
         *
         * So here we wait for any submitted bios to finish, so that we won't
         * do double ordered extent accounting on the same page.
@@ -8377,17 +8379,17 @@ static void btrfs_invalidatepage(struct page *page, unsigned int offset,
 
                range_end = min(ordered->file_offset + ordered->num_bytes - 1,
                                page_end);
-               if (!PagePrivate2(page)) {
+               if (!PageOrdered(page)) {
                        /*
-                        * If Private2 is cleared, it means endio has already
-                        * been executed for the range.
+                        * If Ordered (Private2) is cleared, it means endio has
+                        * already been executed for the range.
                         * We can't delete the extent states as
                         * btrfs_finish_ordered_io() may still use some of them.
                         */
                        delete_states = false;
                        goto next;
                }
-               ClearPagePrivate2(page);
+               ClearPageOrdered(page);
 
                /*
                 * IO on this page will never be started, so we need to account
@@ -8454,10 +8456,10 @@ next:
        }
        /*
         * We have iterated through all ordered extents of the page, the page
-        * should not have Private2 anymore, or the above iteration does
-        * something wrong.
+        * should not have Ordered (Private2) anymore, or the above iteration
+        * did something wrong.
         */
-       ASSERT(!PagePrivate2(page));
+       ASSERT(!PageOrdered(page));
        if (!inode_evicting)
                __btrfs_releasepage(page, GFP_NOFS);
        ClearPageChecked(page);

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index f3270396e547b122d3193f06b697ecee26e1e6d2..b1b377ad99a048e7207b4e0636e5acf23d2f9894 100644 (file)
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -390,16 +390,16 @@ void btrfs_mark_ordered_io_finished(struct btrfs_inode *inode,
 
                if (page) {
                        /*
-                        * Private2 bit indicates whether we still have pending
-                        * io unfinished for the ordered extent.
+                        * Ordered (Private2) bit indicates whether we still
+                        * have pending io unfinished for the ordered extent.
                         *
                         * If there's no such bit, we need to skip to next range.
                         */
-                       if (!PagePrivate2(page)) {
+                       if (!PageOrdered(page)) {
                                cur += len;
                                continue;
                        }
-                       ClearPagePrivate2(page);
+                       ClearPageOrdered(page);
                }
 
                /* Now we're fine to update the accounting */