Commit ffdc8dab authored by Matthew Wilcox (Oracle)'s avatar Matthew Wilcox (Oracle)
Browse files

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: default avatarMatthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Acked-by: default avatarJeff Layton <jlayton@kernel.org>
Acked-by: default avatarKirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: default avatarVlastimil Babka <vbabka@suse.cz>
Reviewed-by: default avatarWilliam Kucharski <william.kucharski@oracle.com>
Reviewed-by: default avatarDavid Howells <dhowells@redhat.com>
Acked-by: default avatarMike Rapoport <rppt@linux.ibm.com>
parent af7f29d9

fs/io_uring.c

+1 −1
Original line number Diff line number Diff line
@@ -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

include/linux/pagemap.h

+0 −17
Original line number Diff line number Diff line
@@ -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.

mm/filemap.c

+14 −13
Original line number Diff line number Diff line
@@ -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;

}