Received: by 2002:a05:6a10:9848:0:0:0:0 with SMTP id x8csp1587685pxf; Fri, 9 Apr 2021 12:09:45 -0700 (PDT) X-Google-Smtp-Source: ABdhPJwwYJpM6M0N+/JCae09zwvPWfhE2lTQPo55nsresWfK+fQfvDNOeofLt29FbyClRKClzVrl X-Received: by 2002:a17:906:af13:: with SMTP id lx19mr7967445ejb.508.1617995385441; Fri, 09 Apr 2021 12:09:45 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1617995385; cv=none; d=google.com; s=arc-20160816; b=goBTk9pa9P2t2MvhZo5Q+cIA/lvjQ+Ye5Qh52TtJ/RSlM04EkVL8JGmQINc1YZe9J9 uPl/+AclmUKIp5k7D4m9Ta2f6SH1OdWAfZ8puiFwmZwuEDIUP76FhNO0ow8q8LCZW41V lRtPULO7QpRRpXdedzehEOI5PLiRU2O4Ii6HM6PCN37Mdbc9lswtAUb42hKsSwjxvDe4 uq5kbUcFJWr3KE0HUTDBMM9ektkwGSDu6cmVdcVS+UCXRmLo4IQI5pGy+zFSQOXXUc2Y wHeXRbjTt9tk4sVnm9aU0zdYZ1Jw0oIlQOdV5BjTuzdx7k19UaBOntb5Q6t/u4ZrTeu1 pMOA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=9FeJvzZQJ3NWya1x19zV190GdZrLXiWMA/J8CElycPA=; b=l58E9C4pefz9CHl1HNQhbLPby+xOdyrq1sLHJ/qNXEbmEQ/SbnEJ+ZeWpGS3QWl5rU C4sm3rLL58j8GwyowTVB1dvE/0rK1W1XWmcTYLibZWB3BpG00JgpOJq0ofRlWEFVm19v Za64kWGMJNfPkKj9F7kJBOab69OUhye0q1LsdWxPhXDFKPuhOyEC4kRjsoXlxe4MWbSO 9R64ztnPjhHmpf+EdlkfqhT85eH44OjkOptUwtWGRlguj9ucrB0k0ep+Hgj+z6Zfjvn7 z8kYSP/RZsHlJmzZOFJXNz+9yjKWjXnjLv1UvI2I+PS4SsNTyn+ZglmLcHSzVFPjLS40 FDPw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@infradead.org header.s=casper.20170209 header.b=hLTxHakv; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id d11si2685630ejm.20.2021.04.09.12.09.21; Fri, 09 Apr 2021 12:09:45 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@infradead.org header.s=casper.20170209 header.b=hLTxHakv; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234869AbhDITIP (ORCPT + 99 others); Fri, 9 Apr 2021 15:08:15 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:33670 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234441AbhDITIO (ORCPT ); Fri, 9 Apr 2021 15:08:14 -0400 Received: from casper.infradead.org (casper.infradead.org [IPv6:2001:8b0:10b:1236::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 70792C061762; Fri, 9 Apr 2021 12:08:01 -0700 (PDT) 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=9FeJvzZQJ3NWya1x19zV190GdZrLXiWMA/J8CElycPA=; b=hLTxHakvYR1H9wR9EjV7bCx9fM vqB/Vk8eD4HTxc3VthQjQBSeE60UJjA48LCXK95SpiHaVHCsgeRTrxcAxgjdecVIj4AsrtgIOca82 ToeVq7dpmUGMiGKRFcyZEjdeaQHH7Oka+a4CZZ/oR5hl4mEW42ciqXUWhdUMBmyJr/U+vJyyyxxEy IEwv1WgaAk4TSCDhoV219tk8pRF/wSnlCbH70rkmPMCCNDIp/DqiP3cFxf34xCdl2U8dcvY3mGn4l B28tgSlqVysJ+m3rjSqIU6a0PKwA4NR947dUGVTHhfl7VMdbatg+g2IutzdrDCEFGvg7VCt9Pj+j2 e/Sx4ezg==; Received: from willy by casper.infradead.org with local (Exim 4.94 #2 (Red Hat Linux)) id 1lUwSI-000oOP-4v; Fri, 09 Apr 2021 19:06:29 +0000 From: "Matthew Wilcox (Oracle)" To: linux-mm@kvack.org Cc: "Matthew Wilcox (Oracle)" , linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-cachefs@redhat.com, linux-afs@lists.infradead.org, Christoph Hellwig , Jeff Layton Subject: [PATCH v7 20/28] mm/filemap: Add __lock_folio_async Date: Fri, 9 Apr 2021 19:50:57 +0100 Message-Id: <20210409185105.188284-21-willy@infradead.org> X-Mailer: git-send-email 2.29.2 In-Reply-To: <20210409185105.188284-1-willy@infradead.org> References: <20210409185105.188284-1-willy@infradead.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org There aren't any actual callers of lock_page_async(), so remove it. Convert filemap_update_page() to call __lock_folio_async(). __lock_folio_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 514 bytes to 403 bytes, saving 111 bytes. The text shrinks by 132 bytes in total. Signed-off-by: Matthew Wilcox (Oracle) Reviewed-by: Christoph Hellwig Acked-by: Jeff Layton --- fs/io_uring.c | 2 +- include/linux/pagemap.h | 17 ----------------- mm/filemap.c | 31 ++++++++++++++++--------------- 3 files changed, 17 insertions(+), 33 deletions(-) diff --git a/fs/io_uring.c b/fs/io_uring.c index 81e5d156af1c..154fd92ab8a8 100644 --- a/fs/io_uring.c +++ b/fs/io_uring.c @@ -3142,7 +3142,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 lock_folio_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 b23b95f771f7..c63f59d4ae60 100644 --- a/include/linux/pagemap.h +++ b/include/linux/pagemap.h @@ -716,7 +716,6 @@ static inline bool wake_page_match(struct wait_page_queue *wait_page, void __lock_folio(struct folio *folio); int __lock_folio_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); @@ -773,22 +772,6 @@ static inline int lock_page_killable(struct page *page) return lock_folio_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 2a4fa0b5fa88..9485ce2a4820 100644 --- a/mm/filemap.c +++ b/mm/filemap.c @@ -1593,18 +1593,18 @@ int __lock_folio_killable(struct folio *folio) } EXPORT_SYMBOL_GPL(__lock_folio_killable); -int __lock_page_async(struct page *page, struct wait_page_queue *wait) +static int __lock_folio_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); + SetFolioWaiters(folio); + ret = !trylock_folio(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 @@ -2351,41 +2351,42 @@ 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 (!trylock_page(page)) { + if (!trylock_folio(folio)) { if (iocb->ki_flags & (IOCB_NOWAIT | IOCB_NOIO)) return -EAGAIN; if (!(iocb->ki_flags & IOCB_WAITQ)) { - 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 = __lock_folio_async(folio, iocb->ki_waitq); if (error) return error; } - if (!page->mapping) + if (!folio->mapping) goto truncated; 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); if (error == AOP_TRUNCATED_PAGE) - put_page(page); + put_folio(folio); return error; truncated: - unlock_page(page); - put_page(page); + unlock_folio(folio); + put_folio(folio); return AOP_TRUNCATED_PAGE; unlock: - unlock_page(page); + unlock_folio(folio); return error; } -- 2.30.2