mm/filemap: Add __folio_lock_async()

There aren't any actual callers of lock_page_async(), so remove it.
Convert filemap_update_page() to call __folio_lock_async().

__folio_lock_async() is 21 bytes smaller than __lock_page_async(),
but the real savings come from using a folio in filemap_update_page(),
shrinking it from 515 bytes to 404 bytes, saving 110 bytes.  The text
shrinks by 132 bytes in total.

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>
Acked-by: Mike Rapoport <rppt@linux.ibm.com>

diff --git a/fs/io_uring.c b/fs/io_uring.c
index 82f867983bb3279a323a2245220e109e9df01928..2c913698e428093c2473a572e0404d47cef6027b 100644 (file)
--- a/fs/io_uring.c
+++ b/fs/io_uring.c
@@ -3364,7 +3364,7 @@ static int io_read_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
 }
 
 /*
- * This is our waitqueue callback handler, registered through lock_page_async()
+ * This is our waitqueue callback handler, registered through __folio_lock_async()
  * when we initially tried to do the IO with the iocb armed our waitqueue.
  * This gets called when the page is unlocked, and we generally expect that to
  * happen when the page IO is completed and the page is now uptodate. This will

diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index cf0ebd8c9e86f54aff9c9f06ebf8297d804c0c3b..5b5e8bd0b3fbf7339bcc159b52bb97675cb81ab3 100644 (file)
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -654,7 +654,6 @@ static inline bool wake_page_match(struct wait_page_queue *wait_page,
 
 void __folio_lock(struct folio *folio);
 int __folio_lock_killable(struct folio *folio);
-extern int __lock_page_async(struct page *page, struct wait_page_queue *wait);
 extern int __lock_page_or_retry(struct page *page, struct mm_struct *mm,
                                unsigned int flags);
 void unlock_page(struct page *page);
@@ -711,22 +710,6 @@ static inline int lock_page_killable(struct page *page)
        return folio_lock_killable(page_folio(page));
 }
 
-/*
- * lock_page_async - Lock the page, unless this would block. If the page
- * is already locked, then queue a callback when the page becomes unlocked.
- * This callback can then retry the operation.
- *
- * Returns 0 if the page is locked successfully, or -EIOCBQUEUED if the page
- * was already locked and the callback defined in 'wait' was queued.
- */
-static inline int lock_page_async(struct page *page,
-                                 struct wait_page_queue *wait)
-{
-       if (!trylock_page(page))
-               return __lock_page_async(page, wait);
-       return 0;
-}
-
 /*
  * lock_page_or_retry - Lock the page, unless this would block and the
  * caller indicated that it can handle a retry.

diff --git a/mm/filemap.c b/mm/filemap.c
index 17803f785a34def45b5039a2b7462f13a72e81ac..655145d27fffee9985667279c027489c57e62de9 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -1652,18 +1652,18 @@ int __folio_lock_killable(struct folio *folio)
 }
 EXPORT_SYMBOL_GPL(__folio_lock_killable);
 
-int __lock_page_async(struct page *page, struct wait_page_queue *wait)
+static int __folio_lock_async(struct folio *folio, struct wait_page_queue *wait)
 {
-       struct wait_queue_head *q = page_waitqueue(page);
+       struct wait_queue_head *q = page_waitqueue(&folio->page);
        int ret = 0;
 
-       wait->page = page;
+       wait->page = &folio->page;
        wait->bit_nr = PG_locked;
 
        spin_lock_irq(&q->lock);
        __add_wait_queue_entry_tail(q, &wait->wait);
-       SetPageWaiters(page);
-       ret = !trylock_page(page);
+       folio_set_waiters(folio);
+       ret = !folio_trylock(folio);
        /*
         * If we were successful now, we know we're still on the
         * waitqueue as we're still under the lock. This means it's
@@ -2436,6 +2436,7 @@ static int filemap_update_page(struct kiocb *iocb,
                struct address_space *mapping, struct iov_iter *iter,
                struct page *page)
 {
+       struct folio *folio = page_folio(page);
        int error;
 
        if (iocb->ki_flags & IOCB_NOWAIT) {
@@ -2445,40 +2446,40 @@ static int filemap_update_page(struct kiocb *iocb,
                filemap_invalidate_lock_shared(mapping);
        }
 
-       if (!trylock_page(page)) {
+       if (!folio_trylock(folio)) {
                error = -EAGAIN;
                if (iocb->ki_flags & (IOCB_NOWAIT | IOCB_NOIO))
                        goto unlock_mapping;
                if (!(iocb->ki_flags & IOCB_WAITQ)) {
                        filemap_invalidate_unlock_shared(mapping);
-                       put_and_wait_on_page_locked(page, TASK_KILLABLE);
+                       put_and_wait_on_page_locked(&folio->page, TASK_KILLABLE);
                        return AOP_TRUNCATED_PAGE;
                }
-               error = __lock_page_async(page, iocb->ki_waitq);
+               error = __folio_lock_async(folio, iocb->ki_waitq);
                if (error)
                        goto unlock_mapping;
        }
 
        error = AOP_TRUNCATED_PAGE;
-       if (!page->mapping)
+       if (!folio->mapping)
                goto unlock;
 
        error = 0;
-       if (filemap_range_uptodate(mapping, iocb->ki_pos, iter, page))
+       if (filemap_range_uptodate(mapping, iocb->ki_pos, iter, &folio->page))
                goto unlock;
 
        error = -EAGAIN;
        if (iocb->ki_flags & (IOCB_NOIO | IOCB_NOWAIT | IOCB_WAITQ))
                goto unlock;
 
-       error = filemap_read_page(iocb->ki_filp, mapping, page);
+       error = filemap_read_page(iocb->ki_filp, mapping, &folio->page);
        goto unlock_mapping;
 unlock:
-       unlock_page(page);
+       folio_unlock(folio);
 unlock_mapping:
        filemap_invalidate_unlock_shared(mapping);
        if (error == AOP_TRUNCATED_PAGE)
-               put_page(page);
+               folio_put(folio);
        return error;
 }