lkml.org 
[lkml]   [2021]   [Jul]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v14 024/138] mm/filemap: Add folio_end_writeback()
    Date
    Add an end_page_writeback() wrapper function for users that are not yet
    converted to folios.

    folio_end_writeback() is less than half the size of end_page_writeback()
    at just 105 bytes compared to 228 bytes, due to removing all the
    compound_head() calls. The 30 byte wrapper function makes this a net
    saving of 93 bytes.

    Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
    Reviewed-by: Christoph Hellwig <hch@lst.de>
    Acked-by: Jeff Layton <jlayton@kernel.org>
    Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
    Acked-by: Vlastimil Babka <vbabka@suse.cz>
    Reviewed-by: William Kucharski <william.kucharski@oracle.com>
    Reviewed-by: David Howells <dhowells@redhat.com>
    ---
    include/linux/pagemap.h | 3 ++-
    mm/filemap.c | 43 ++++++++++++++++++++---------------------
    mm/folio-compat.c | 6 ++++++
    3 files changed, 29 insertions(+), 23 deletions(-)

    diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
    index 626dbccbfb90..66a019178550 100644
    --- a/include/linux/pagemap.h
    +++ b/include/linux/pagemap.h
    @@ -768,7 +768,8 @@ static inline int wait_on_page_locked_killable(struct page *page)
    int put_and_wait_on_page_locked(struct page *page, int state);
    void wait_on_page_writeback(struct page *page);
    int wait_on_page_writeback_killable(struct page *page);
    -extern void end_page_writeback(struct page *page);
    +void end_page_writeback(struct page *page);
    +void folio_end_writeback(struct folio *folio);
    void wait_for_stable_page(struct page *page);

    void __set_page_dirty(struct page *, struct address_space *, int warn);
    diff --git a/mm/filemap.c b/mm/filemap.c
    index 4ce2b22b64f8..b5a0d546e436 100644
    --- a/mm/filemap.c
    +++ b/mm/filemap.c
    @@ -1175,11 +1175,11 @@ static void wake_up_page_bit(struct page *page, int bit_nr)
    spin_unlock_irqrestore(&q->lock, flags);
    }

    -static void wake_up_page(struct page *page, int bit)
    +static void folio_wake(struct folio *folio, int bit)
    {
    - if (!PageWaiters(page))
    + if (!folio_test_waiters(folio))
    return;
    - wake_up_page_bit(page, bit);
    + wake_up_page_bit(&folio->page, bit);
    }

    /*
    @@ -1516,39 +1516,38 @@ int wait_on_page_private_2_killable(struct page *page)
    EXPORT_SYMBOL(wait_on_page_private_2_killable);

    /**
    - * end_page_writeback - end writeback against a page
    - * @page: the page
    + * folio_end_writeback - End writeback against a folio.
    + * @folio: The folio.
    */
    -void end_page_writeback(struct page *page)
    +void folio_end_writeback(struct folio *folio)
    {
    /*
    - * TestClearPageReclaim could be used here but it is an atomic
    - * operation and overkill in this particular case. Failing to
    - * shuffle a page marked for immediate reclaim is too mild to
    - * justify taking an atomic operation penalty at the end of
    - * ever page writeback.
    + * folio_test_clear_reclaim() could be used here but it is an
    + * atomic operation and overkill in this particular case. Failing
    + * to shuffle a folio marked for immediate reclaim is too mild
    + * a gain to justify taking an atomic operation penalty at the
    + * end of every folio writeback.
    */
    - if (PageReclaim(page)) {
    - struct folio *folio = page_folio(page);
    - ClearPageReclaim(page);
    + if (folio_test_reclaim(folio)) {
    + folio_clear_reclaim(folio);
    folio_rotate_reclaimable(folio);
    }

    /*
    - * Writeback does not hold a page reference of its own, relying
    + * Writeback does not hold a folio reference of its own, relying
    * on truncation to wait for the clearing of PG_writeback.
    - * But here we must make sure that the page is not freed and
    - * reused before the wake_up_page().
    + * But here we must make sure that the folio is not freed and
    + * reused before the folio_wake().
    */
    - get_page(page);
    - if (!test_clear_page_writeback(page))
    + folio_get(folio);
    + if (!test_clear_page_writeback(&folio->page))
    BUG();

    smp_mb__after_atomic();
    - wake_up_page(page, PG_writeback);
    - put_page(page);
    + folio_wake(folio, PG_writeback);
    + folio_put(folio);
    }
    -EXPORT_SYMBOL(end_page_writeback);
    +EXPORT_SYMBOL(folio_end_writeback);

    /*
    * After completing I/O on a page, call this routine to update the page
    diff --git a/mm/folio-compat.c b/mm/folio-compat.c
    index 91b3d00a92f7..526843d03d58 100644
    --- a/mm/folio-compat.c
    +++ b/mm/folio-compat.c
    @@ -17,3 +17,9 @@ void unlock_page(struct page *page)
    return folio_unlock(page_folio(page));
    }
    EXPORT_SYMBOL(unlock_page);
    +
    +void end_page_writeback(struct page *page)
    +{
    + return folio_end_writeback(page_folio(page));
    +}
    +EXPORT_SYMBOL(end_page_writeback);
    --
    2.30.2
    \
     
     \ /
      Last update: 2021-07-15 06:00    [W:6.517 / U:1.232 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site