From patchwork Wed Jan 15 02:38:41 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Matthew Wilcox X-Patchwork-Id: 11333145 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id A7ACC13A0 for ; Wed, 15 Jan 2020 02:38:51 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 5B21C24679 for ; Wed, 15 Jan 2020 02:38:51 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=infradead.org header.i=@infradead.org header.b="EgrmhkcR" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5B21C24679 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 35E768E0006; Tue, 14 Jan 2020 21:38:49 -0500 (EST) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id 30E6F8E0003; Tue, 14 Jan 2020 21:38:49 -0500 (EST) X-Original-To: int-list-linux-mm@kvack.org X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 1883F8E0006; Tue, 14 Jan 2020 21:38:49 -0500 (EST) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0140.hostedemail.com [216.40.44.140]) by kanga.kvack.org (Postfix) with ESMTP id 0140F8E0003 for ; Tue, 14 Jan 2020 21:38:48 -0500 (EST) Received: from smtpin08.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay04.hostedemail.com (Postfix) with SMTP id A380A40C2 for ; Wed, 15 Jan 2020 02:38:48 +0000 (UTC) X-FDA: 76378310736.08.top32_871049c4f3c3d X-Spam-Summary: 2,0,0,323ee5bb2eeea0c5,d41d8cd98f00b204,willy@infradead.org,:linux-xfs@vger.kernel.org:linux-fsdevel@vger.kernel.org::willy@infradead.org:jlayton@kernel.org:hch@infradead.org:clm@fb.com,RULES_HIT:1:2:41:69:142:355:379:541:800:960:966:973:979:988:989:1260:1311:1314:1345:1359:1437:1515:1605:1730:1747:1777:1792:2194:2196:2198:2199:2200:2201:2393:2559:2562:2693:2731:2901:3138:3139:3140:3141:3142:3865:3866:3867:3868:3870:3871:3872:3874:4051:4250:4321:4383:4385:4395:4605:5007:6119:6261:6653:7576:7903:8784:8957:9010:9108:9592:10004:11026:11232:11473:11658:11914:12043:12296:12297:12438:12555:12683:12895:13894:14096:14110:14394:21080:21450:21451:21627:21987:21990:30054:30056:30070:30091,0,RBL:198.137.202.133:@infradead.org:.lbl8.mailshell.net-62.8.0.100 64.201.201.201,CacheIP:none,Bayesian:0.5,0.5,0.5,Netcheck:none,DomainCache:0,MSF:not bulk,SPF:fn,MSBL:0,DNSBL:neutral,Custom_rules:0:0:0,LFtime:26,LUA_SUMMARY:none X-HE-Tag: top32_871049c4f3c3d X-Filterd-Recvd-Size: 10251 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) by imf01.hostedemail.com (Postfix) with ESMTP for ; Wed, 15 Jan 2020 02:38:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.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:Resent-Date:Resent-From :Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help: List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=R5s7E+fDNMsmJ/ZtIC98sZK+AORG+F7O0ns/rNwbsl0=; b=EgrmhkcR/yjDI7OqkOXZNvgj8i t4lXpRcAlZpgyU/7bgXTxjnCeOOUX+N9qds89jX0ZFKKwdzIOJsX9eDwPUMts4c1tQjhtsZvnVzeQ yKChgvFCVBKDbG0wcvIiYAmKvP0OcdO2Dhzk3qMj1hY4LOsD6yPrgBHYtOATfO91bTL27L3MkrOHN 3t47yBo5GeSPzUIQR61xT2NtFSCrl1rYh8Avo6NaflsIAC03UJ87sXXmFbQRpj45Vi+pz4vrDmYPn hqP29jiEr45cpWuh0U3CK2jsKiHwAzPf0CtG8Oe6K5S+eYZcVROC8Gl/9CUGXLhbCFo9ZL/aE+XzW Z7F646eg==; Received: from willy by bombadil.infradead.org with local (Exim 4.92.3 #3 (Red Hat Linux)) id 1irYZy-0008Az-7T; Wed, 15 Jan 2020 02:38:46 +0000 From: Matthew Wilcox To: linux-xfs@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org Cc: "Matthew Wilcox (Oracle)" , Jeff Layton , Christoph Hellwig , Chris Mason Subject: [PATCH v2 7/9] cifs: Convert from readpages to readahead Date: Tue, 14 Jan 2020 18:38:41 -0800 Message-Id: <20200115023843.31325-8-willy@infradead.org> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20200115023843.31325-1-willy@infradead.org> References: <20200115023843.31325-1-willy@infradead.org> MIME-Version: 1.0 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: From: "Matthew Wilcox (Oracle)" Use the new readahead operation in CIFS Signed-off-by: Matthew Wilcox (Oracle) --- fs/cifs/file.c | 143 +++++++++---------------------------------------- 1 file changed, 25 insertions(+), 118 deletions(-) diff --git a/fs/cifs/file.c b/fs/cifs/file.c index 043288b5c728..c9162380ad22 100644 --- a/fs/cifs/file.c +++ b/fs/cifs/file.c @@ -4280,70 +4280,11 @@ cifs_readpages_copy_into_pages(struct TCP_Server_Info *server, return readpages_fill_pages(server, rdata, iter, iter->count); } -static int -readpages_get_pages(struct address_space *mapping, struct list_head *page_list, - unsigned int rsize, struct list_head *tmplist, - unsigned int *nr_pages, loff_t *offset, unsigned int *bytes) -{ - struct page *page, *tpage; - unsigned int expected_index; - int rc; - gfp_t gfp = readahead_gfp_mask(mapping); - - INIT_LIST_HEAD(tmplist); - - page = lru_to_page(page_list); - - /* - * Lock the page and put it in the cache. Since no one else - * should have access to this page, we're safe to simply set - * PG_locked without checking it first. - */ - __SetPageLocked(page); - rc = add_to_page_cache_locked(page, mapping, - page->index, gfp); - - /* give up if we can't stick it in the cache */ - if (rc) { - __ClearPageLocked(page); - return rc; - } - - /* move first page to the tmplist */ - *offset = (loff_t)page->index << PAGE_SHIFT; - *bytes = PAGE_SIZE; - *nr_pages = 1; - list_move_tail(&page->lru, tmplist); - - /* now try and add more pages onto the request */ - expected_index = page->index + 1; - list_for_each_entry_safe_reverse(page, tpage, page_list, lru) { - /* discontinuity ? */ - if (page->index != expected_index) - break; - - /* would this page push the read over the rsize? */ - if (*bytes + PAGE_SIZE > rsize) - break; - - __SetPageLocked(page); - if (add_to_page_cache_locked(page, mapping, page->index, gfp)) { - __ClearPageLocked(page); - break; - } - list_move_tail(&page->lru, tmplist); - (*bytes) += PAGE_SIZE; - expected_index++; - (*nr_pages)++; - } - return rc; -} - -static int cifs_readpages(struct file *file, struct address_space *mapping, - struct list_head *page_list, unsigned num_pages) +static unsigned cifs_readahead(struct file *file, + struct address_space *mapping, pgoff_t start, + unsigned num_pages) { int rc; - struct list_head tmplist; struct cifsFileInfo *open_file = file->private_data; struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file); struct TCP_Server_Info *server; @@ -4358,11 +4299,10 @@ static int cifs_readpages(struct file *file, struct address_space *mapping, * After this point, every page in the list might have PG_fscache set, * so we will need to clean that up off of every page we don't use. */ - rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list, - &num_pages); + rc = -ENOBUFS; if (rc == 0) { free_xid(xid); - return rc; + return num_pages; } if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD) @@ -4373,24 +4313,11 @@ static int cifs_readpages(struct file *file, struct address_space *mapping, rc = 0; server = tlink_tcon(open_file->tlink)->ses->server; - cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n", - __func__, file, mapping, num_pages); + cifs_dbg(FYI, "%s: file=%p mapping=%p start=%lu num_pages=%u\n", + __func__, file, mapping, start, num_pages); - /* - * Start with the page at end of list and move it to private - * list. Do the same with any following pages until we hit - * the rsize limit, hit an index discontinuity, or run out of - * pages. Issue the async read and then start the loop again - * until the list is empty. - * - * Note that list order is important. The page_list is in - * the order of declining indexes. When we put the pages in - * the rdata->pages, then we want them in increasing order. - */ - while (!list_empty(page_list)) { - unsigned int i, nr_pages, bytes, rsize; - loff_t offset; - struct page *page, *tpage; + while (num_pages) { + unsigned int i, nr_pages, rsize; struct cifs_readdata *rdata; struct cifs_credits credits_on_stack; struct cifs_credits *credits = &credits_on_stack; @@ -4408,21 +4335,14 @@ static int cifs_readpages(struct file *file, struct address_space *mapping, if (rc) break; + nr_pages = min_t(unsigned, rsize / PAGE_SIZE, num_pages); /* * Give up immediately if rsize is too small to read an entire * page. The VFS will fall back to readpage. We should never - * reach this point however since we set ra_pages to 0 when the - * rsize is smaller than a cache page. + * reach this point however since we set ra_pages to 0 when + * the rsize is smaller than a cache page. */ - if (unlikely(rsize < PAGE_SIZE)) { - add_credits_and_wake_if(server, credits, 0); - free_xid(xid); - return 0; - } - - rc = readpages_get_pages(mapping, page_list, rsize, &tmplist, - &nr_pages, &offset, &bytes); - if (rc) { + if (unlikely(nr_pages < 1)) { add_credits_and_wake_if(server, credits, 0); break; } @@ -4430,21 +4350,15 @@ static int cifs_readpages(struct file *file, struct address_space *mapping, rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete); if (!rdata) { /* best to give up if we're out of mem */ - list_for_each_entry_safe(page, tpage, &tmplist, lru) { - list_del(&page->lru); - lru_cache_add_file(page); - unlock_page(page); - put_page(page); - } - rc = -ENOMEM; add_credits_and_wake_if(server, credits, 0); break; } rdata->cfile = cifsFileInfo_get(open_file); rdata->mapping = mapping; - rdata->offset = offset; - rdata->bytes = bytes; + rdata->offset = start; + rdata->nr_pages = nr_pages; + rdata->bytes = nr_pages * PAGE_SIZE; rdata->pid = pid; rdata->pagesz = PAGE_SIZE; rdata->tailsz = PAGE_SIZE; @@ -4452,10 +4366,8 @@ static int cifs_readpages(struct file *file, struct address_space *mapping, rdata->copy_into_pages = cifs_readpages_copy_into_pages; rdata->credits = credits_on_stack; - list_for_each_entry_safe(page, tpage, &tmplist, lru) { - list_del(&page->lru); - rdata->pages[rdata->nr_pages++] = page; - } + for (i = 0; i < nr_pages; i++) + rdata->pages[i] = readahead_page(mapping, start++); rc = adjust_credits(server, &rdata->credits, rdata->bytes); @@ -4468,27 +4380,22 @@ static int cifs_readpages(struct file *file, struct address_space *mapping, if (rc) { add_credits_and_wake_if(server, &rdata->credits, 0); - for (i = 0; i < rdata->nr_pages; i++) { - page = rdata->pages[i]; - lru_cache_add_file(page); - unlock_page(page); - put_page(page); - } - /* Fallback to the readpage in error/reconnect cases */ kref_put(&rdata->refcount, cifs_readdata_release); break; } kref_put(&rdata->refcount, cifs_readdata_release); + num_pages -= nr_pages; } /* Any pages that have been shown to fscache but didn't get added to * the pagecache must be uncached before they get returned to the * allocator. */ - cifs_fscache_readpages_cancel(mapping->host, page_list); +// cifs_fscache_readpages_cancel(mapping->host, page_list); free_xid(xid); - return rc; + + return num_pages; } /* @@ -4806,7 +4713,7 @@ cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter) const struct address_space_operations cifs_addr_ops = { .readpage = cifs_readpage, - .readpages = cifs_readpages, + .readahead = cifs_readahead, .writepage = cifs_writepage, .writepages = cifs_writepages, .write_begin = cifs_write_begin, @@ -4819,9 +4726,9 @@ const struct address_space_operations cifs_addr_ops = { }; /* - * cifs_readpages requires the server to support a buffer large enough to + * cifs_readahead requires the server to support a buffer large enough to * contain the header plus one complete page of data. Otherwise, we need - * to leave cifs_readpages out of the address space operations. + * to leave cifs_readahead out of the address space operations. */ const struct address_space_operations cifs_addr_ops_smallbuf = { .readpage = cifs_readpage,