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

mm/filemap: Add __folio_lock_or_retry() 



Convert __lock_page_or_retry() to __folio_lock_or_retry().  This actually
saves 4 bytes in the only caller of lock_page_or_retry() (due to better
register allocation) and saves the 14 byte cost of calling page_folio()
in __folio_lock_or_retry() for a total saving of 18 bytes.  Also use
a bool for the return type.

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>
Reviewed-by: default avatarWilliam Kucharski <william.kucharski@oracle.com>
Acked-by: default avatarMike Rapoport <rppt@linux.ibm.com>
Reviewed-by: default avatarDavid Howells <dhowells@redhat.com>
Acked-by: default avatarVlastimil Babka <vbabka@suse.cz>
parent 6baa8d60

include/linux/pagemap.h

+7 −4
Original line number Diff line number Diff line
@@ -654,7 +654,7 @@ 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_or_retry(struct page *page, struct mm_struct *mm,

bool __folio_lock_or_retry(struct folio *folio, struct mm_struct *mm,

				unsigned int flags);

void unlock_page(struct page *page);

void folio_unlock(struct folio *folio);
@@ -715,13 +715,16 @@ static inline int lock_page_killable(struct page *page) 
 * caller indicated that it can handle a retry.

 *

 * Return value and mmap_lock implications depend on flags; see

 * __lock_page_or_retry().

 * __folio_lock_or_retry().

 */

static inline int lock_page_or_retry(struct page *page, struct mm_struct *mm,

static inline bool lock_page_or_retry(struct page *page, struct mm_struct *mm,

				     unsigned int flags)

{

	struct folio *folio;

	might_sleep();

	return trylock_page(page) || __lock_page_or_retry(page, mm, flags);



	folio = page_folio(page);

	return folio_trylock(folio) || __folio_lock_or_retry(folio, mm, flags);

}



/*

mm/filemap.c

+10 −12
Original line number Diff line number Diff line
@@ -1680,48 +1680,46 @@ static int __folio_lock_async(struct folio *folio, struct wait_page_queue *wait) 


/*

 * Return values:

 * 1 - page is locked; mmap_lock is still held.

 * 0 - page is not locked.

 * true - folio is locked; mmap_lock is still held.

 * false - folio is not locked.

 *     mmap_lock has been released (mmap_read_unlock(), unless flags had both

 *     FAULT_FLAG_ALLOW_RETRY and FAULT_FLAG_RETRY_NOWAIT set, in

 *     which case mmap_lock is still held.

 *

 * If neither ALLOW_RETRY nor KILLABLE are set, will always return 1

 * with the page locked and the mmap_lock unperturbed.

 * If neither ALLOW_RETRY nor KILLABLE are set, will always return true

 * with the folio locked and the mmap_lock unperturbed.

 */

int __lock_page_or_retry(struct page *page, struct mm_struct *mm,

bool __folio_lock_or_retry(struct folio *folio, struct mm_struct *mm,

			 unsigned int flags)

{

	struct folio *folio = page_folio(page);



	if (fault_flag_allow_retry_first(flags)) {

		/*

		 * CAUTION! In this case, mmap_lock is not released

		 * even though return 0.

		 */

		if (flags & FAULT_FLAG_RETRY_NOWAIT)

			return 0;

			return false;



		mmap_read_unlock(mm);

		if (flags & FAULT_FLAG_KILLABLE)

			folio_wait_locked_killable(folio);

		else

			folio_wait_locked(folio);

		return 0;

		return false;

	}

	if (flags & FAULT_FLAG_KILLABLE) {

		int ret;

		bool ret;



		ret = __folio_lock_killable(folio);

		if (ret) {

			mmap_read_unlock(mm);

			return 0;

			return false;

		}

	} else {

		__folio_lock(folio);

	}



	return 1;

	return true;

}



/**

mm/memory.c

+4 −4
Original line number Diff line number Diff line
@@ -4258,7 +4258,7 @@ static vm_fault_t do_shared_fault(struct vm_fault *vmf) 
 * We enter with non-exclusive mmap_lock (to exclude vma changes,

 * but allow concurrent faults).

 * The mmap_lock may have been released depending on flags and our

 * return value.  See filemap_fault() and __lock_page_or_retry().

 * return value.  See filemap_fault() and __folio_lock_or_retry().

 * If mmap_lock is released, vma may become invalid (for example

 * by other thread calling munmap()).

 */
@@ -4499,7 +4499,7 @@ static vm_fault_t wp_huge_pud(struct vm_fault *vmf, pud_t orig_pud) 
 * concurrent faults).

 *

 * The mmap_lock may have been released depending on flags and our return value.

 * See filemap_fault() and __lock_page_or_retry().

 * See filemap_fault() and __folio_lock_or_retry().

 */

static vm_fault_t handle_pte_fault(struct vm_fault *vmf)

{
@@ -4603,7 +4603,7 @@ static vm_fault_t handle_pte_fault(struct vm_fault *vmf) 
 * By the time we get here, we already hold the mm semaphore

 *

 * The mmap_lock may have been released depending on flags and our

 * return value.  See filemap_fault() and __lock_page_or_retry().

 * return value.  See filemap_fault() and __folio_lock_or_retry().

 */

static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,

		unsigned long address, unsigned int flags)
@@ -4759,7 +4759,7 @@ static inline void mm_account_fault(struct pt_regs *regs, 
 * By the time we get here, we already hold the mm semaphore

 *

 * The mmap_lock may have been released depending on flags and our

 * return value.  See filemap_fault() and __lock_page_or_retry().

 * return value.  See filemap_fault() and __folio_lock_or_retry().

 */

vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,

			   unsigned int flags, struct pt_regs *regs)