From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.5 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id C5CB9C433E0 for ; Thu, 28 Jan 2021 07:04:58 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 48D8964D9D for ; Thu, 28 Jan 2021 07:04:58 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 48D8964D9D Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=infradead.org Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 3DE496B0088; Thu, 28 Jan 2021 02:04:49 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 33B006B0089; Thu, 28 Jan 2021 02:04:49 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 1B4C66B008A; Thu, 28 Jan 2021 02:04:49 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0099.hostedemail.com [216.40.44.99]) by kanga.kvack.org (Postfix) with ESMTP id EE44B6B0088 for ; Thu, 28 Jan 2021 02:04:48 -0500 (EST) Received: from smtpin20.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay02.hostedemail.com (Postfix) with ESMTP id B8E07363C for ; Thu, 28 Jan 2021 07:04:48 +0000 (UTC) X-FDA: 77754296256.20.game73_1e15ba42759d Received: from filter.hostedemail.com (10.5.16.251.rfc1918.com [10.5.16.251]) by smtpin20.hostedemail.com (Postfix) with ESMTP id 92897180C07A3 for ; Thu, 28 Jan 2021 07:04:48 +0000 (UTC) X-HE-Tag: game73_1e15ba42759d X-Filterd-Recvd-Size: 12853 Received: from casper.infradead.org (casper.infradead.org [90.155.50.34]) by imf22.hostedemail.com (Postfix) with ESMTP for ; Thu, 28 Jan 2021 07:04:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:MIME-Version: References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-Type:Content-ID:Content-Description; bh=eDn22njYgy16brcOrkAAMp8iBYtor2K3+ZpZIPkgrZo=; b=fFObk1dsvRE/nkV3tkLDzPLGJt 2QZPYILedC5Vyltemv09YoWyRPxqlVmcO6gG6ZYac15mdiV1fTayaXuhToaeU8WmF9CQuqIFTSR5X 4K+/GXIFCL4Z9CZG+GGIspRGQ0dA36nTuzSy5NCJhz7glbzRAnx73Clnd+RkW5ghlp7haGt3b7jIk dGs2iq/+Dv4oyDiv73QcU64SRxhoauapKFY9iHNzTFXL9HT6xJeShgJ9PjLRjghvSg2/thDlgmkr7 dJ/LFNJDmKcDGToDUbePSgiYSzqCgJchJAijUyFXDl8xY0u0DESB7oKafQUwpvPayT8KJrLE6udF6 jGvLn7Hw==; Received: from willy by casper.infradead.org with local (Exim 4.94 #2 (Red Hat Linux)) id 1l51MB-00848M-OQ; Thu, 28 Jan 2021 07:04:44 +0000 From: "Matthew Wilcox (Oracle)" To: linux-fsdevel@vger.kernel.org, linux-mm@kvack.org Cc: "Matthew Wilcox (Oracle)" , linux-kernel@vger.kernel.org Subject: [PATCH v3 18/25] mm: Convert wait_on_page_bit to wait_on_folio_bit Date: Thu, 28 Jan 2021 07:03:57 +0000 Message-Id: <20210128070404.1922318-19-willy@infradead.org> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20210128070404.1922318-1-willy@infradead.org> References: <20210128070404.1922318-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: We must deal with folios here otherwise we'll get the wrong waitqueue and fail to receive wakeups. Signed-off-by: Matthew Wilcox (Oracle) --- fs/afs/write.c | 31 ++++++++++++----------- include/linux/pagemap.h | 19 +++++++++------ mm/filemap.c | 54 ++++++++++++++++++----------------------- mm/page-writeback.c | 7 +++--- 4 files changed, 56 insertions(+), 55 deletions(-) diff --git a/fs/afs/write.c b/fs/afs/write.c index e672833c99bc..b3dac7afd123 100644 --- a/fs/afs/write.c +++ b/fs/afs/write.c @@ -915,13 +915,14 @@ int afs_fsync(struct file *file, loff_t start, loff= _t end, int datasync) */ vm_fault_t afs_page_mkwrite(struct vm_fault *vmf) { - struct page *page =3D thp_head(vmf->page); + struct folio *folio =3D page_folio(vmf->page); struct file *file =3D vmf->vma->vm_file; struct inode *inode =3D file_inode(file); struct afs_vnode *vnode =3D AFS_FS_I(inode); unsigned long priv; =20 - _enter("{{%llx:%llu}},{%lx}", vnode->fid.vid, vnode->fid.vnode, page->i= ndex); + _enter("{{%llx:%llu}},{%lx}", vnode->fid.vid, vnode->fid.vnode, + folio->page.index); =20 sb_start_pagefault(inode->i_sb); =20 @@ -929,32 +930,34 @@ vm_fault_t afs_page_mkwrite(struct vm_fault *vmf) * be modified. We then assume the entire page will need writing back. */ #ifdef CONFIG_AFS_FSCACHE - if (PageFsCache(page) && - wait_on_page_bit_killable(page, PG_fscache) < 0) + if (FolioFsCache(folio) && + wait_on_folio_bit_killable(folio, PG_fscache) < 0) return VM_FAULT_RETRY; #endif =20 - if (PageWriteback(page) && - wait_on_page_bit_killable(page, PG_writeback) < 0) + if (FolioWriteback(folio) && + wait_on_folio_bit_killable(folio, PG_writeback) < 0) return VM_FAULT_RETRY; =20 - if (lock_page_killable(page) < 0) + if (lock_folio_killable(folio) < 0) return VM_FAULT_RETRY; =20 /* We mustn't change page->private until writeback is complete as that * details the portion of the page we need to write back and we might * need to redirty the page if there's a problem. */ - wait_on_page_writeback(page); + wait_on_page_writeback(&folio->page); =20 - priv =3D afs_page_dirty(page, 0, thp_size(page)); + priv =3D afs_page_dirty(&folio->page, 0, folio_size(folio)); priv =3D afs_page_dirty_mmapped(priv); - if (PagePrivate(page)) { - set_page_private(page, priv); - trace_afs_page_dirty(vnode, tracepoint_string("mkwrite+"), page); + if (FolioPrivate(folio)) { + set_folio_private(folio, priv); + trace_afs_page_dirty(vnode, tracepoint_string("mkwrite+"), + &folio->page); } else { - attach_page_private(page, (void *)priv); - trace_afs_page_dirty(vnode, tracepoint_string("mkwrite"), page); + attach_folio_private(folio, (void *)priv); + trace_afs_page_dirty(vnode, tracepoint_string("mkwrite"), + &folio->page); } file_update_time(file); =20 diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h index 67d3badc9fe0..55f3c1a8be3c 100644 --- a/include/linux/pagemap.h +++ b/include/linux/pagemap.h @@ -720,8 +720,8 @@ static inline int lock_page_or_retry(struct page *pag= e, struct mm_struct *mm, * This is exported only for wait_on_page_locked/wait_on_page_writeback,= etc., * and should not be used directly. */ -extern void wait_on_page_bit(struct page *page, int bit_nr); -extern int wait_on_page_bit_killable(struct page *page, int bit_nr); +extern void wait_on_folio_bit(struct folio *folio, int bit_nr); +extern int wait_on_folio_bit_killable(struct folio *folio, int bit_nr); =20 /*=20 * Wait for a page to be unlocked. @@ -732,15 +732,17 @@ extern int wait_on_page_bit_killable(struct page *p= age, int bit_nr); */ static inline void wait_on_page_locked(struct page *page) { - if (PageLocked(page)) - wait_on_page_bit(compound_head(page), PG_locked); + struct folio *folio =3D page_folio(page); + if (FolioLocked(folio)) + wait_on_folio_bit(folio, PG_locked); } =20 static inline int wait_on_page_locked_killable(struct page *page) { - if (!PageLocked(page)) + struct folio *folio =3D page_folio(page); + if (!FolioLocked(folio)) return 0; - return wait_on_page_bit_killable(compound_head(page), PG_locked); + return wait_on_folio_bit_killable(folio, PG_locked); } =20 /** @@ -752,8 +754,9 @@ static inline int wait_on_page_locked_killable(struct= page *page) */ static inline void wait_on_page_fscache(struct page *page) { - if (PagePrivate2(page)) - wait_on_page_bit(compound_head(page), PG_fscache); + struct folio *folio =3D page_folio(page); + if (FolioPrivate2(folio)) + wait_on_folio_bit(folio, PG_fscache); } =20 int put_and_wait_on_page_locked(struct page *page, int state); diff --git a/mm/filemap.c b/mm/filemap.c index 65008c42e47d..f68bf0129458 100644 --- a/mm/filemap.c +++ b/mm/filemap.c @@ -1074,7 +1074,7 @@ static int wake_page_function(wait_queue_entry_t *w= ait, unsigned mode, int sync, * * So update the flags atomically, and wake up the waiter * afterwards to avoid any races. This store-release pairs - * with the load-acquire in wait_on_page_bit_common(). + * with the load-acquire in wait_on_folio_bit_common(). */ smp_store_release(&wait->flags, flags | WQ_FLAG_WOKEN); wake_up_state(wait->private, mode); @@ -1155,7 +1155,7 @@ static void wake_up_folio(struct folio *folio, int = bit) } =20 /* - * A choice of three behaviors for wait_on_page_bit_common(): + * A choice of three behaviors for wait_on_folio_bit_common(): */ enum behavior { EXCLUSIVE, /* Hold ref to page and take the bit when woken, like @@ -1189,9 +1189,10 @@ static inline bool trylock_page_bit_common(struct = page *page, int bit_nr, /* How many times do we accept lock stealing from under a waiter? */ int sysctl_page_lock_unfairness =3D 5; =20 -static inline int wait_on_page_bit_common(wait_queue_head_t *q, - struct page *page, int bit_nr, int state, enum behavior behavior) +static inline int wait_on_folio_bit_common(struct folio *folio, int bit_= nr, + int state, enum behavior behavior) { + wait_queue_head_t *q =3D page_waitqueue(&folio->page); int unfairness =3D sysctl_page_lock_unfairness; struct wait_page_queue wait_page; wait_queue_entry_t *wait =3D &wait_page.wait; @@ -1200,8 +1201,8 @@ static inline int wait_on_page_bit_common(wait_queu= e_head_t *q, unsigned long pflags; =20 if (bit_nr =3D=3D PG_locked && - !PageUptodate(page) && PageWorkingset(page)) { - if (!PageSwapBacked(page)) { + !FolioUptodate(folio) && FolioWorkingset(folio)) { + if (!FolioSwapBacked(folio)) { delayacct_thrashing_start(); delayacct =3D true; } @@ -1211,7 +1212,7 @@ static inline int wait_on_page_bit_common(wait_queu= e_head_t *q, =20 init_wait(wait); wait->func =3D wake_page_function; - wait_page.page =3D page; + wait_page.page =3D &folio->page; wait_page.bit_nr =3D bit_nr; =20 repeat: @@ -1226,7 +1227,7 @@ static inline int wait_on_page_bit_common(wait_queu= e_head_t *q, * Do one last check whether we can get the * page bit synchronously. * - * Do the SetPageWaiters() marking before that + * Do the SetFolioWaiters() marking before that * to let any waker we _just_ missed know they * need to wake us up (otherwise they'll never * even go to the slow case that looks at the @@ -1237,8 +1238,8 @@ static inline int wait_on_page_bit_common(wait_queu= e_head_t *q, * lock to avoid races. */ spin_lock_irq(&q->lock); - SetPageWaiters(page); - if (!trylock_page_bit_common(page, bit_nr, wait)) + SetFolioWaiters(folio); + if (!trylock_page_bit_common(&folio->page, bit_nr, wait)) __add_wait_queue_entry_tail(q, wait); spin_unlock_irq(&q->lock); =20 @@ -1248,10 +1249,10 @@ static inline int wait_on_page_bit_common(wait_qu= eue_head_t *q, * see whether the page bit testing has already * been done by the wake function. * - * We can drop our reference to the page. + * We can drop our reference to the folio. */ if (behavior =3D=3D DROP) - put_page(page); + put_folio(folio); =20 /* * Note that until the "finish_wait()", or until @@ -1288,7 +1289,7 @@ static inline int wait_on_page_bit_common(wait_queu= e_head_t *q, * * And if that fails, we'll have to retry this all. */ - if (unlikely(test_and_set_bit(bit_nr, &page->flags))) + if (unlikely(test_and_set_bit(bit_nr, folio_flags(folio)))) goto repeat; =20 wait->flags |=3D WQ_FLAG_DONE; @@ -1328,19 +1329,17 @@ static inline int wait_on_page_bit_common(wait_qu= eue_head_t *q, return wait->flags & WQ_FLAG_WOKEN ? 0 : -EINTR; } =20 -void wait_on_page_bit(struct page *page, int bit_nr) +void wait_on_folio_bit(struct folio *folio, int bit_nr) { - wait_queue_head_t *q =3D page_waitqueue(page); - wait_on_page_bit_common(q, page, bit_nr, TASK_UNINTERRUPTIBLE, SHARED); + wait_on_folio_bit_common(folio, bit_nr, TASK_UNINTERRUPTIBLE, SHARED); } -EXPORT_SYMBOL(wait_on_page_bit); +EXPORT_SYMBOL(wait_on_folio_bit); =20 -int wait_on_page_bit_killable(struct page *page, int bit_nr) +int wait_on_folio_bit_killable(struct folio *folio, int bit_nr) { - wait_queue_head_t *q =3D page_waitqueue(page); - return wait_on_page_bit_common(q, page, bit_nr, TASK_KILLABLE, SHARED); + return wait_on_folio_bit_common(folio, bit_nr, TASK_KILLABLE, SHARED); } -EXPORT_SYMBOL(wait_on_page_bit_killable); +EXPORT_SYMBOL(wait_on_folio_bit_killable); =20 /** * put_and_wait_on_page_locked - Drop a reference and wait for it to be = unlocked @@ -1357,11 +1356,8 @@ EXPORT_SYMBOL(wait_on_page_bit_killable); */ int put_and_wait_on_page_locked(struct page *page, int state) { - wait_queue_head_t *q; - - page =3D compound_head(page); - q =3D page_waitqueue(page); - return wait_on_page_bit_common(q, page, PG_locked, state, DROP); + wait_on_folio_bit_common(page_folio(page), PG_locked, + state, DROP); } =20 /** @@ -1510,16 +1506,14 @@ EXPORT_SYMBOL_GPL(page_endio); */ void __lock_folio(struct folio *folio) { - wait_queue_head_t *q =3D page_waitqueue(&folio->page); - wait_on_page_bit_common(q, &folio->page, PG_locked, TASK_UNINTERRUPTIBL= E, + wait_on_folio_bit_common(folio, PG_locked, TASK_UNINTERRUPTIBLE, EXCLUSIVE); } EXPORT_SYMBOL(__lock_folio); =20 int __lock_folio_killable(struct folio *folio) { - wait_queue_head_t *q =3D page_waitqueue(&folio->page); - return wait_on_page_bit_common(q, &folio->page, PG_locked, TASK_KILLABL= E, + return wait_on_folio_bit_common(folio, PG_locked, TASK_KILLABLE, EXCLUSIVE); } EXPORT_SYMBOL_GPL(__lock_folio_killable); diff --git a/mm/page-writeback.c b/mm/page-writeback.c index eb34d204d4ee..51b4326f0aaa 100644 --- a/mm/page-writeback.c +++ b/mm/page-writeback.c @@ -2826,9 +2826,10 @@ EXPORT_SYMBOL(__test_set_page_writeback); */ void wait_on_page_writeback(struct page *page) { - while (PageWriteback(page)) { - trace_wait_on_page_writeback(page, page_mapping(page)); - wait_on_page_bit(page, PG_writeback); + struct folio *folio =3D page_folio(page); + while (FolioWriteback(folio)) { + trace_wait_on_page_writeback(page, folio_mapping(folio)); + wait_on_folio_bit(folio, PG_writeback); } } EXPORT_SYMBOL_GPL(wait_on_page_writeback); --=20 2.29.2