Initial conversion of NFS basic I/O to use folios
Subsystems (2)
[email protected]
maintainerv2 cover Initial conversion of NFS basic I/O to use folios
From: Trond Myklebust <[email protected]>
This set of patches represents an initial effort to convert the page cache I/O in the NFS client to use native folio functionality. It should allow the nfs_page structs and their helpers to carry folios (including folios of order > 0) and to pass their data contents through to the RPC layer.
Note that because O_DIRECT uses pages, we still need to support the traditional page based I/O, and so the new struct nfs_page will carry both types.
I did not touch the fscache code, but I expect that to be able to continue to work with order 0 folios.
The plan is to merge this functionality with order 0 folios first, in order to catch any regressions in existing functionality. Then we can enable order n > 0 once we're happy about the stability (at least for the non-fscache case).
At this point, the xfstests are all passing without any regressions on my setup, so I'm throwing the patches over the fence to allow for wider testing.
Please make sure, in particular to test pNFS if your server supports it. I didn't have to make any changes to the pNFS code, and I don't expect any trouble, but it would be good to have validation of that assumption.
---
v2:
- Fix a bisectability issue reported by Anna
- Remove an unnecessary NULL pointer check in nfs_read_folio()
Trond Myklebust (18):
NFS: Fix for xfstests generic/208
NFS: Add basic functionality for tracking folios in struct nfs_page
NFS: Support folios in nfs_generic_pgio()
NFS: Fix nfs_coalesce_size() to work with folios
NFS: Add a helper to convert a struct nfs_page into an inode
NFS: Convert the remaining pagelist helper functions to support folios
NFS: Add a helper nfs_wb_folio()
NFS: Convert buffered reads to use folios
NFS: Convert the function nfs_wb_page() to use folios
NFS: Convert buffered writes to use folios
NFS: Remove unused function nfs_wb_page()
NFS: Convert nfs_write_begin/end to use folios
NFS: Fix up nfs_vm_page_mkwrite() for folios
NFS: Clean up O_DIRECT request allocation
NFS: fix up nfs_release_folio() to try to release the page
NFS: Enable tracing of nfs_invalidate_folio() and nfs_launder_folio()
NFS: Improve tracing of nfs_wb_folio()
NFS: Remove unnecessary check in nfs_read_folio()
fs/nfs/direct.c | 12 +- fs/nfs/file.c | 124 +++++++------ fs/nfs/internal.h | 38 ++-- fs/nfs/nfstrace.h | 58 ++++-- fs/nfs/pagelist.c | 217 +++++++++++++++++----- fs/nfs/pnfs.h | 10 +- fs/nfs/pnfs_nfs.c | 18 +- fs/nfs/read.c | 94 +++++----- fs/nfs/write.c | 380 ++++++++++++++++++++------------------- include/linux/nfs_fs.h | 7 +- include/linux/nfs_page.h | 79 +++++++- 11 files changed, 646 insertions(+), 391 deletions(-)
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 1/18 NFS: Fix for xfstests generic/208
From: Trond Myklebust <[email protected]>
If the same page and data is being used for multiple requests, then ignore that when the request indicates we're reading from the start of the page.
--- fs/nfs/pagelist.c | 3 +++ 1 file changed, 3 insertions(+)
fs/nfs/pagelist.c +3 -0
@@ -920,6 +920,9 @@ int nfs_generic_pgio(struct nfs_pageio_descriptor *desc, req =nfs_list_entry (head->next);nfs_list_move_request (req, &hdr->pages); +if (req->wb_pgbase ==0 ) + last_page =NULL ; +if (!last_page || last_page != req->wb_page) { pageused++;if (pageused > pagecount)
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 2/18 NFS: Add basic functionality for tracking folios in struct nfs_page
From: Trond Myklebust <[email protected]>
--- fs/nfs/pagelist.c | 5 +++-- include/linux/nfs_page.h | 38 +++++++++++++++++++++++++++++++++++++- 2 files changed, 40 insertions(+), 3 deletions(-)
fs/nfs/pagelist.c +3 -2
@@ -500,9 +500,10 @@ nfs_create_subreq(struct nfs_page *req, {struct nfs_page *last;struct nfs_page *ret; +struct page *page =nfs_page_to_page (req, pgbase); - ret =__nfs_create_request (req->wb_lock_context, req->wb_page, - pgbase, offset, count); + ret =__nfs_create_request (req->wb_lock_context, page, pgbase, offset, + count);if (!IS_ERR (ret)) {/* find the last request */ for (last = req->wb_head;
include/linux/nfs_page.h +37 -1
@@ -25,6 +25,7 @@enum {PG_BUSY =0 ,/* nfs_{un}lock_request */ PG_MAPPED ,/* page private set for buffered io */ +PG_FOLIO ,/* Tracking a folio (unset for O_DIRECT) */ PG_CLEAN ,/* write succeeded */ PG_COMMIT_TO_DS ,/* used by pnfs layouts */ PG_INODE_REF ,/* extra ref held by inode when in writeback */
@@ -41,7 +42,10 @@ enum {struct nfs_inode ;struct nfs_page {struct list_head wb_list;/* Defines state of page: */ -struct page *wb_page;/* page to read in/write out */ +union { +struct page *wb_page;/* page to read in/write out */ +struct folio *wb_folio; + };struct nfs_lock_context *wb_lock_context;/* lock context info */ pgoff_t wb_index;/* Offset >> PAGE_SHIFT */ unsigned int wb_offset, /* Offset & ~PAGE_MASK */
@@ -153,6 +157,38 @@ extern int nfs_page_set_headlock(struct nfs_page *req);extern void nfs_page_clear_headlock (struct nfs_page *req);extern bool nfs_async_iocounter_wait (struct rpc_task *,struct nfs_lock_context *); +/** +* nfs_page_to_folio - Retrieve a struct folio for the request +* @req: pointer to a struct nfs_page +* +* If a folio was assigned to @req, then return it, otherwise return NULL. +*/ +static inline struct folio *nfs_page_to_folio (const struct nfs_page *req) +{ +if (test_bit (PG_FOLIO , &req->wb_flags)) +return req->wb_folio; +return NULL ; +} + +/** +* nfs_page_to_page - Retrieve a struct page for the request +* @req: pointer to a struct nfs_page +* @pgbase: folio byte offset +* +* Return the page containing the byte that is at offset @pgbase relative +* to the start of the folio. +* Note: The request starts at offset @req->wb_pgbase. +*/ +static inline struct page *nfs_page_to_page (const struct nfs_page *req, +size_t pgbase) +{ +struct folio *folio =nfs_page_to_folio (req); + +if (folio ==NULL ) +return req->wb_page; +return folio_page (folio, pgbase >>PAGE_SHIFT ); +} +/* * Lock the page of an asynchronous request */
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 3/18 NFS: Support folios in nfs_generic_pgio()
From: Trond Myklebust <[email protected]>
Add support for multi-page folios in the generic NFS i/o engine.
--- fs/nfs/internal.h | 7 +++-- fs/nfs/pagelist.c | 68 +++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 60 insertions(+), 15 deletions(-)
fs/nfs/internal.h +3 -4
@@ -807,11 +807,10 @@ unsigned char nfs_umode_to_dtype(umode_t mode)* Determine the number of pages in an array of length 'len' and * with a base offset of 'base' */ -static inline -unsigned int nfs_page_array_len (unsigned int base,size_t len) +static inline unsigned int nfs_page_array_len (unsigned int base,size_t len) { -return ((unsigned long )len + (unsigned long )base + -PAGE_SIZE -1 ) >>PAGE_SHIFT ; +return ((unsigned long )len + (unsigned long )base +PAGE_SIZE -1 ) >> +PAGE_SHIFT ; }/*
fs/nfs/pagelist.c +57 -11
118 lines not on this page · raw message
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 4/18 NFS: Fix nfs_coalesce_size() to work with folios
From: Trond Myklebust <[email protected]>
Use the helper folio_size() where appropriate.
--- fs/nfs/pagelist.c | 28 +++++++++++++++++++--------- include/linux/nfs_page.h | 15 +++++++++++++++ 2 files changed, 34 insertions(+), 9 deletions(-)
fs/nfs/pagelist.c +19 -9
@@ -1084,6 +1084,24 @@ static bool nfs_match_lock_context(const struct nfs_lock_context *l1,return l1->lockowner == l2->lockowner; } +static bool nfs_page_is_contiguous (const struct nfs_page *prev, +const struct nfs_page *req) +{ +size_t prev_end = prev->wb_pgbase + prev->wb_bytes; + +if (req_offset (req) !=req_offset (prev) + prev->wb_bytes) +return false; +if (req->wb_pgbase ==0 ) +return prev_end ==nfs_page_max_length (prev); +if (req->wb_pgbase == prev_end) { +struct folio *folio =nfs_page_to_folio (req); +if (folio) +return folio ==nfs_page_to_folio (prev); +return req->wb_page == prev->wb_page; + } +return false; +} +/** * nfs_coalesce_size - test two requests for compatibility * @prev: pointer to nfs_page
@@ -1112,16 +1130,8 @@ static unsigned int nfs_coalesce_size(struct nfs_page *prev, !nfs_match_lock_context(req->wb_lock_context, prev->wb_lock_context))return 0 ; -if (req_offset (req) !=req_offset (prev) + prev->wb_bytes) +if (!nfs_page_is_contiguous (prev, req))return 0 ; -if (req->wb_page == prev->wb_page) { -if (req->wb_pgbase != prev->wb_pgbase + prev->wb_bytes) -return 0 ; - }else { -if (req->wb_pgbase !=0 || - prev->wb_pgbase + prev->wb_bytes !=PAGE_SIZE ) -return 0 ; - } }return pgio->pg_ops->pg_test (pgio, prev, req); }
include/linux/nfs_page.h +15 -0
@@ -189,6 +189,21 @@ static inline struct page *nfs_page_to_page(const struct nfs_page *req,return folio_page (folio, pgbase >>PAGE_SHIFT ); } +/** +* nfs_page_max_length - Retrieve the maximum possible length for a request +* @req: pointer to a struct nfs_page +* +* Returns the maximum possible length of a request +*/ +static inline size_t nfs_page_max_length (const struct nfs_page *req) +{ +struct folio *folio =nfs_page_to_folio (req); + +if (folio ==NULL ) +return PAGE_SIZE ; +return folio_size (folio); +} +/* * Lock the page of an asynchronous request */
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 5/18 NFS: Add a helper to convert a struct nfs_page into an inode
From: Trond Myklebust <[email protected]>
Replace all the open coded calls to page_file_mapping(req->wb_page)->host.
--- fs/nfs/pagelist.c | 2 +- fs/nfs/write.c | 7 +++---- include/linux/nfs_page.h | 13 +++++++++++++ 3 files changed, 17 insertions(+), 5 deletions(-)
fs/nfs/pagelist.c +1 -1
@@ -426,7 +426,7 @@ nfs_page_group_init(struct nfs_page *req, struct nfs_page *prev)* has extra ref from the write/commit path to handle handoff * between write and commit lists. */ if (test_bit (PG_INODE_REF , &prev->wb_head->wb_flags)) { - inode =page_file_mapping (req->wb_page)->host; + inode =nfs_page_to_inode (req);set_bit (PG_INODE_REF , &req->wb_flags);kref_get (&req->wb_kref);atomic_long_inc (&NFS_I (inode)->nrequests);
fs/nfs/write.c +3 -4
@@ -421,7 +421,7 @@ static void nfs_set_page_writeback(struct page *page)static void nfs_end_page_writeback (struct nfs_page *req) { -struct inode *inode =page_file_mapping (req->wb_page)->host; +struct inode *inode =nfs_page_to_inode (req);struct nfs_server *nfss =NFS_SERVER (inode);bool is_done;
@@ -592,8 +592,7 @@ nfs_lock_and_join_requests(struct page *page)static void nfs_write_error (struct nfs_page *req,int error) { -trace_nfs_write_error (page_file_mapping (req->wb_page)->host, req, - error); +trace_nfs_write_error (nfs_page_to_inode (req), req, error);nfs_mapping_set_error (req->wb_page, error);nfs_inode_remove_request (req);nfs_end_page_writeback (req);
@@ -1420,7 +1419,7 @@ static void nfs_initiate_write(struct nfs_pgio_header *hdr,*/ static void nfs_redirty_request (struct nfs_page *req) { -struct nfs_inode *nfsi =NFS_I (page_file_mapping (req->wb_page)->host); +struct nfs_inode *nfsi =NFS_I (nfs_page_to_inode (req));/* Bump the transmission count */ req->wb_nio++;
include/linux/nfs_page.h +13 -0
@@ -189,6 +189,19 @@ static inline struct page *nfs_page_to_page(const struct nfs_page *req,return folio_page (folio, pgbase >>PAGE_SHIFT ); } +/** +* nfs_page_to_inode - Retrieve an inode for the request +* @req: pointer to a struct nfs_page +*/ +static inline struct inode *nfs_page_to_inode (const struct nfs_page *req) +{ +struct folio *folio =nfs_page_to_folio (req); + +if (folio ==NULL ) +return page_file_mapping (req->wb_page)->host; +return folio_file_mapping (folio)->host; +} +/** * nfs_page_max_length - Retrieve the maximum possible length for a request * @req: pointer to a struct nfs_page
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 6/18 NFS: Convert the remaining pagelist helper functions to support folios
From: Trond Myklebust <[email protected]>
Allow creation of subrequests from a request that is carrying a folio. Add helpers to set up and tear down requests carrying folios.
--- fs/nfs/pagelist.c | 72 ++++++++++++++++++++++++++++++++--------------- 1 file changed, 50 insertions(+), 22 deletions(-)
fs/nfs/pagelist.c +50 -22
@@ -466,10 +466,9 @@ nfs_page_group_destroy(struct kref *kref)nfs_release_request (head); } -static struct nfs_page * -__nfs_create_request (struct nfs_lock_context *l_ctx,struct page *page, -unsigned int pgbase,unsigned int offset, -unsigned int count) +static struct nfs_page *nfs_page_create (struct nfs_lock_context *l_ctx, +unsigned int pgbase,pgoff_t index, +unsigned int offset,unsigned int count) {struct nfs_page *req;struct nfs_open_context *ctx = l_ctx->open_context;
@@ -488,19 +487,32 @@ __nfs_create_request(struct nfs_lock_context *l_ctx, struct page *page,/* Initialize the request struct. Initially, we assume a * long write-back delay. This will be adjusted in * update_nfs_request below if the region is not locked. */ - req->wb_page = page; -if (page) { - req->wb_index =page_index (page); -get_page (page); - } - req->wb_offset = offset; - req->wb_pgbase = pgbase; - req->wb_bytes = count; + req->wb_pgbase = pgbase; + req->wb_index = index; + req->wb_offset = offset; + req->wb_bytes = count;kref_init (&req->wb_kref); req->wb_nio =0 ;return req; } +static void nfs_page_assign_folio (struct nfs_page *req,struct folio *folio) +{ +if (folio !=NULL ) { + req->wb_folio = folio; +folio_get (folio); +set_bit (PG_FOLIO , &req->wb_flags); + } +} + +static void nfs_page_assign_page (struct nfs_page *req,struct page *page) +{ +if (page !=NULL ) { + req->wb_page = page; +get_page (page); + } +} +/** * nfs_create_request - Create an NFS read/write request. * @ctx: open context to use
@@ -521,9 +533,11 @@ nfs_create_request(struct nfs_open_context *ctx, struct page *page,if (IS_ERR (l_ctx))return ERR_CAST (l_ctx); - ret =__nfs_create_request (l_ctx, page, offset, offset, count); -if (!IS_ERR (ret)) + ret =nfs_page_create (l_ctx, offset,page_index (page), offset, count); +if (!IS_ERR (ret)) { +nfs_page_assign_page (ret, page);nfs_page_group_init (ret,NULL ); + }nfs_put_lock_context (l_ctx);return ret; }
@@ -536,11 +550,16 @@ nfs_create_subreq(struct nfs_page *req, {struct nfs_page *last;struct nfs_page *ret; +struct folio *folio =nfs_page_to_folio (req);struct page *page =nfs_page_to_page (req, pgbase); - ret =__nfs_create_request (req->wb_lock_context, page, pgbase, offset, - count); + ret =nfs_page_create (req->wb_lock_context, pgbase, req->wb_index, + offset, count);if (!IS_ERR (ret)) { +if (folio) +nfs_page_assign_folio (ret, folio); +else +nfs_page_assign_page (ret, page);/* find the last request */ for (last = req->wb_head; last->wb_this_page != req->wb_head;
@@ -548,7 +567,6 @@ nfs_create_subreq(struct nfs_page *req, ;nfs_lock_request (ret); - ret->wb_index = req->wb_index;nfs_page_group_init (ret, last); ret->wb_nio = req->wb_nio; }
@@ -587,11 +605,16 @@ void nfs_unlock_and_release_request(struct nfs_page *req)*/ static void nfs_clear_request (struct nfs_page *req) { +struct folio *folio =nfs_page_to_folio (req);struct page *page = req->wb_page;struct nfs_lock_context *l_ctx = req->wb_lock_context;struct nfs_open_context *ctx; -if (page !=NULL ) { +if (folio !=NULL ) { +folio_put (folio); + req->wb_folio =NULL ; +clear_bit (PG_FOLIO , &req->wb_flags); + }else if (page !=NULL ) {put_page (page); req->wb_page =NULL ; }
@@ -1471,16 +1494,21 @@ void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *desc, pgoff_t index) {struct nfs_pgio_mirror *mirror;struct nfs_page *prev; +struct folio *folio;u32 midx;for (midx =0 ; midx < desc->pg_mirror_count; midx++) { mirror =nfs_pgio_get_mirror (desc, midx);if (!list_empty (&mirror->pg_list)) { prev =nfs_list_entry (mirror->pg_list.prev); -if (index != prev->wb_index +1 ) { -nfs_pageio_complete (desc); -break ; - } + folio =nfs_page_to_folio (prev); +if (folio) { +if (index ==folio_next_index (folio)) +continue ; + }else if (index == prev->wb_index +1 ) +continue ; +nfs_pageio_complete (desc); +break ; } } }
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 7/18 NFS: Add a helper nfs_wb_folio()
From: Trond Myklebust <[email protected]>
...and use it in nfs_launder_folio().
--- fs/nfs/file.c | 2 +- fs/nfs/write.c | 13 +++++++++++++ include/linux/nfs_fs.h | 1 + 3 files changed, 15 insertions(+), 1 deletion(-)
fs/nfs/file.c +1 -1
@@ -469,7 +469,7 @@ static int nfs_launder_folio(struct folio *folio) inode->i_ino, folio_pos(folio));folio_wait_fscache (folio); -return nfs_wb_page (inode, &folio->page); +return nfs_wb_folio (inode, folio); } static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
fs/nfs/write.c +13 -0
@@ -2106,6 +2106,19 @@ int nfs_wb_page(struct inode *inode, struct page *page)return ret; } +/** +* nfs_wb_folio - Write back all requests on one page +* @inode: pointer to page +* @folio: pointer to folio +* +* Assumes that the folio has been locked by the caller, and will +* not unlock it. +*/ +int nfs_wb_folio (struct inode *inode,struct folio *folio) +{ +return nfs_wb_page (inode, &folio->page); +} +#ifdef CONFIG_MIGRATION int nfs_migrate_folio (struct address_space *mapping,struct folio *dst,struct folio *src,enum migrate_mode mode)
include/linux/nfs_fs.h +1 -0
@@ -578,6 +578,7 @@ extern int nfs_updatepage(struct file *, struct page *, unsigned int, unsigned*/ extern int nfs_sync_inode (struct inode *inode);extern int nfs_wb_all (struct inode *inode); +extern int nfs_wb_folio (struct inode *inode,struct folio *folio);extern int nfs_wb_page (struct inode *inode,struct page *page);int nfs_wb_folio_cancel (struct inode *inode,struct folio *folio);extern int nfs_commit_inode (struct inode *,int );
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 8/18 NFS: Convert buffered reads to use folios
From: Trond Myklebust <[email protected]>
Perform a largely mechanical conversion of references to struct page and page-specific functions to use the folio equivalents.
Note that the fscache functionality remains untouched. Instead we just pass in the folio page. This should be OK, as long as we use order 0 folios together with fscache.
--- fs/nfs/internal.h | 18 +++++++++ fs/nfs/nfstrace.h | 12 +++--- fs/nfs/pagelist.c | 30 ++++++++++++++ fs/nfs/read.c | 86 ++++++++++++++++++++-------------------- include/linux/nfs_page.h | 4 ++ 5 files changed, 100 insertions(+), 50 deletions(-)
fs/nfs/internal.h +18 -0
@@ -794,6 +794,24 @@ unsigned int nfs_page_length(struct page *page)return 0 ; } +/* +* Determine the number of bytes of data the page contains +*/ +static inline size_t nfs_folio_length (struct folio *folio) +{ +loff_t i_size =i_size_read (folio_file_mapping (folio)->host); + +if (i_size >0 ) { +pgoff_t index =folio_index (folio) >>folio_order (folio); +pgoff_t end_index = (i_size -1 ) >>folio_shift (folio); +if (index < end_index) +return folio_size (folio); +if (index == end_index) +return offset_in_folio (folio, i_size -1 ) +1 ; + } +return 0 ; +} +/* * Convert a umode to a dirent->d_type */
fs/nfs/nfstrace.h +6 -6
@@ -936,10 +936,10 @@ TRACE_EVENT(nfs_sillyrename_unlink, TRACE_EVENT(nfs_aop_readpage, TP_PROTO( const struct inode *inode, - struct page *page + struct folio *folio ), - TP_ARGS(inode, page), + TP_ARGS(inode, folio), TP_STRUCT__entry( __field(dev_t, dev)
@@ -956,7 +956,7 @@ TRACE_EVENT(nfs_aop_readpage, __entry->fileid = nfsi->fileid; __entry->fhandle =nfs_fhandle_hash (&nfsi->fh); __entry->version =inode_peek_iversion_raw (inode); - __entry->offset =page_index (page) <<PAGE_SHIFT ; + __entry->offset =folio_file_pos (folio); ), TP_printk(
@@ -971,11 +971,11 @@ TRACE_EVENT(nfs_aop_readpage, TRACE_EVENT(nfs_aop_readpage_done, TP_PROTO( const struct inode *inode, - struct page *page, + struct folio *folio, int ret ), - TP_ARGS(inode, page, ret), + TP_ARGS(inode, folio, ret), TP_STRUCT__entry( __field(dev_t, dev)
@@ -993,7 +993,7 @@ TRACE_EVENT(nfs_aop_readpage_done, __entry->fileid = nfsi->fileid; __entry->fhandle =nfs_fhandle_hash (&nfsi->fh); __entry->version =inode_peek_iversion_raw (inode); - __entry->offset =page_index (page) <<PAGE_SHIFT ; + __entry->offset =folio_file_pos (folio); __entry->ret = ret; ),
fs/nfs/pagelist.c +30 -0
@@ -542,6 +542,36 @@ nfs_create_request(struct nfs_open_context *ctx, struct page *page,return ret; } +/** +* nfs_page_create_from_folio - Create an NFS read/write request. +* @ctx: open context to use +* @folio: folio to write +* @offset: starting offset within the folio for the write +* @count: number of bytes to read/write +* +* The page must be locked by the caller. This makes sure we never +* create two different requests for the same page. +* User should ensure it is safe to sleep in this function. +*/ +struct nfs_page *nfs_page_create_from_folio (struct nfs_open_context *ctx, +struct folio *folio, +unsigned int offset, +unsigned int count) +{ +struct nfs_lock_context *l_ctx =nfs_get_lock_context (ctx); +struct nfs_page *ret; + +if (IS_ERR (l_ctx)) +return ERR_CAST (l_ctx); + ret =nfs_page_create (l_ctx, offset,folio_index (folio), offset, count); +if (!IS_ERR (ret)) { +nfs_page_assign_folio (ret, folio); +nfs_page_group_init (ret,NULL ); + } +nfs_put_lock_context (l_ctx); +return ret; +} +static struct nfs_page * nfs_create_subreq(struct nfs_page *req, unsigned int pgbase,
fs/nfs/read.c +42 -44
205 lines not on this page · raw message
include/linux/nfs_page.h +4 -0
@@ -125,6 +125,10 @@ extern struct nfs_page *nfs_create_request(struct nfs_open_context *ctx,struct page *page, unsigned int offset, unsigned int count); +extern struct nfs_page *nfs_page_create_from_folio (struct nfs_open_context *ctx, +struct folio *folio, +unsigned int offset, +unsigned int count);extern void nfs_release_request (struct nfs_page *);
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 9/18 NFS: Convert the function nfs_wb_page() to use folios
From: Trond Myklebust <[email protected]>
Convert to use the folio functions, but pass the struct page to nfs_writepage_locked() for now.
--- fs/nfs/write.c | 35 ++++++++++++++++------------------- 1 file changed, 16 insertions(+), 19 deletions(-)
fs/nfs/write.c +16 -19
@@ -2069,13 +2069,18 @@ int nfs_wb_folio_cancel(struct inode *inode, struct folio *folio)return ret; } -/* -* Write back all requests on one page - we do this before reading it. +/** +* nfs_wb_folio - Write back all requests on one page +* @inode: pointer to page +* @folio: pointer to folio +* +* Assumes that the folio has been locked by the caller, and will +* not unlock it. */ -int nfs_wb_page (struct inode *inode,struct page *page) +int nfs_wb_folio (struct inode *inode,struct folio *folio) { -loff_t range_start =page_file_offset (page); -loff_t range_end = range_start + (loff_t)(PAGE_SIZE -1 ); +loff_t range_start =folio_file_pos (folio); +loff_t range_end = range_start + (loff_t )folio_size (folio) -1 ;struct writeback_control wbc = { .sync_mode =WB_SYNC_ALL , .nr_to_write =0 ,
@@ -2087,15 +2092,15 @@ int nfs_wb_page(struct inode *inode, struct page *page)trace_nfs_writeback_page_enter (inode);for (;;) { -wait_on_page_writeback (page); -if (clear_page_dirty_for_io (page)) { - ret =nfs_writepage_locked (page, &wbc); +folio_wait_writeback (folio); +if (folio_clear_dirty_for_io (folio)) { + ret =nfs_writepage_locked (&folio->page, &wbc);if (ret <0 ) goto out_error;continue ; } ret =0 ; -if (!PagePrivate (page)) +if (!folio_test_private (folio))break ; ret =nfs_commit_inode (inode,FLUSH_SYNC );if (ret <0 )
@@ -2106,17 +2111,9 @@ int nfs_wb_page(struct inode *inode, struct page *page)return ret; } -/** -* nfs_wb_folio - Write back all requests on one page -* @inode: pointer to page -* @folio: pointer to folio -* -* Assumes that the folio has been locked by the caller, and will -* not unlock it. -*/ -int nfs_wb_folio (struct inode *inode,struct folio *folio) +int nfs_wb_page (struct inode *inode,struct page *page) { -return nfs_wb_page (inode, &folio->page); +return nfs_wb_folio (inode,page_folio (page)); }#ifdef CONFIG_MIGRATION
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 10/18 NFS: Convert buffered writes to use folios
From: Trond Myklebust <[email protected]>
Mostly mechanical conversion of struct page and functions into struct folio equivalents.
The lack of support for folios in write_cache_pages(), means we still only support order 0 folio allocations. However the rest of the writeback code should now be ready for order n > 0.
--- fs/nfs/file.c | 14 +- fs/nfs/internal.h | 13 +- fs/nfs/pnfs.h | 10 +- fs/nfs/pnfs_nfs.c | 18 +-- fs/nfs/write.c | 350 +++++++++++++++++++++-------------------- include/linux/nfs_fs.h | 5 +- 6 files changed, 210 insertions(+), 200 deletions(-)
fs/nfs/file.c +9 -5
@@ -319,6 +319,7 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping,int ret;pgoff_t index = pos >>PAGE_SHIFT ;struct page *page; +struct folio *folio;int once_thru =0 ; dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
@@ -329,15 +330,16 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping,if (!page)return -ENOMEM ; *pagep = page; + folio =page_folio (page); - ret =nfs_flush_incompatible (file, page); + ret =nfs_flush_incompatible (file, folio);if (ret) {unlock_page (page);put_page (page); }else if (!once_thru &&nfs_want_read_modify_write (file, page, pos, len)) { once_thru =1 ; - ret =nfs_read_folio (file,page_folio (page)); + ret =nfs_read_folio (file, folio);put_page (page);if (!ret) goto start;
@@ -351,6 +353,7 @@ static int nfs_write_end(struct file *file, struct address_space *mapping, {unsigned offset = pos & (PAGE_SIZE -1 );struct nfs_open_context *ctx =nfs_file_open_context (file); +struct folio *folio =page_folio (page);int status; dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
@@ -376,7 +379,7 @@ static int nfs_write_end(struct file *file, struct address_space *mapping,zero_user_segment (page, pglen,PAGE_SIZE ); } - status =nfs_updatepage (file, page, offset, copied); + status =nfs_update_folio (file, folio, offset, copied);unlock_page (page);put_page (page);
@@ -552,6 +555,7 @@ static vm_fault_t nfs_vm_page_mkwrite(struct vm_fault *vmf)unsigned pagelen;vm_fault_t ret =VM_FAULT_NOPAGE ;struct address_space *mapping; +struct folio *folio =page_folio (page); dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n", filp, filp->f_mapping->host->i_ino,
@@ -582,8 +586,8 @@ static vm_fault_t nfs_vm_page_mkwrite(struct vm_fault *vmf) goto out_unlock; ret =VM_FAULT_LOCKED ; -if (nfs_flush_incompatible (filp, page) ==0 && -nfs_updatepage (filp, page,0 , pagelen) ==0 ) +if (nfs_flush_incompatible (filp, folio) ==0 && +nfs_update_folio (filp, folio,0 , pagelen) ==0 ) goto out; ret =VM_FAULT_SIGBUS ;
fs/nfs/internal.h +7 -6
@@ -760,17 +760,18 @@ void nfs_super_set_maxbytes(struct super_block *sb, __u64 maxfilesize)* Record the page as unstable (an extra writeback period) and mark its * inode as dirty. */ -static inline -void nfs_mark_page_unstable (struct page *page,struct nfs_commit_info *cinfo) +static inline void nfs_folio_mark_unstable (struct folio *folio, +struct nfs_commit_info *cinfo) { -if (!cinfo->dreq) { -struct inode *inode =page_file_mapping (page)->host; +if (folio && !cinfo->dreq) { +struct inode *inode =folio_file_mapping (folio)->host; +long nr =folio_nr_pages (folio);/* This page is really still in write-back - just that the * writeback is happening on the server now. */ -inc_node_page_state (page,NR_WRITEBACK ); -inc_wb_stat (&inode_to_bdi (inode)->wb,WB_WRITEBACK ); +node_stat_mod_folio (folio,NR_WRITEBACK , nr); +wb_stat_mod (&inode_to_bdi (inode)->wb,WB_WRITEBACK , nr);__mark_inode_dirty (inode,I_DIRTY_DATASYNC ); } }
fs/nfs/pnfs.h +5 -5
@@ -193,7 +193,7 @@ struct pnfs_commit_ops {void (*recover_commit_reqs) (struct list_head *list,struct nfs_commit_info *cinfo);struct nfs_page * (*search_commit_reqs)(struct nfs_commit_info *cinfo, -struct page *page); +struct folio *folio); };struct pnfs_layout_hdr {
@@ -395,7 +395,7 @@ void pnfs_generic_rw_release(void *data);void pnfs_generic_recover_commit_reqs (struct list_head *dst,struct nfs_commit_info *cinfo);struct nfs_page *pnfs_generic_search_commit_reqs (struct nfs_commit_info *cinfo, -struct page *page); +struct folio *folio); int pnfs_generic_commit_pagelist(struct inode *inode, struct list_head *mds_pages, int how,
@@ -557,13 +557,13 @@ pnfs_recover_commit_reqs(struct list_head *head, struct nfs_commit_info *cinfo)static inline struct nfs_page *pnfs_search_commit_reqs (struct inode *inode,struct nfs_commit_info *cinfo, -struct page *page) +struct folio *folio) {struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;if (!fl_cinfo->ops || !fl_cinfo->ops->search_commit_reqs)return NULL ; -return fl_cinfo->ops->search_commit_reqs (cinfo, page); +return fl_cinfo->ops->search_commit_reqs (cinfo, folio); }/* Should the pNFS client commit and return the layout upon a setattr */
@@ -864,7 +864,7 @@ pnfs_recover_commit_reqs(struct list_head *head, struct nfs_commit_info *cinfo)static inline struct nfs_page *pnfs_search_commit_reqs (struct inode *inode,struct nfs_commit_info *cinfo, -struct page *page) +struct folio *folio) {return NULL ; }
fs/nfs/pnfs_nfs.c +9 -9
@@ -353,7 +353,7 @@ EXPORT_SYMBOL_GPL(pnfs_generic_recover_commit_reqs);static struct nfs_page *pnfs_bucket_search_commit_reqs (struct pnfs_commit_bucket *buckets, -unsigned int nbuckets,struct page *page) +unsigned int nbuckets,struct folio *folio) {struct nfs_page *req;struct pnfs_commit_bucket *b;
@@ -363,11 +363,11 @@ pnfs_bucket_search_commit_reqs(struct pnfs_commit_bucket *buckets,* request is found */ for (i =0 , b = buckets; i < nbuckets; i++, b++) {list_for_each_entry (req, &b->written, wb_list) { -if (req->wb_page == page) +if (nfs_page_to_folio (req) == folio)return req->wb_head; }list_for_each_entry (req, &b->committing, wb_list) { -if (req->wb_page == page) +if (nfs_page_to_folio (req) == folio)return req->wb_head; } }
@@ -375,14 +375,14 @@ pnfs_bucket_search_commit_reqs(struct pnfs_commit_bucket *buckets, }/* pnfs_generic_search_commit_reqs - Search lists in @cinfo for the head request -* for @page +* for @folio * @cinfo - commit info for current inode -* @page - page to search for matching head request +* @folio - page to search for matching head request * * Return: the head request if one is found, otherwise %NULL. */ -struct nfs_page * -pnfs_generic_search_commit_reqs (struct nfs_commit_info *cinfo,struct page *page) +struct nfs_page *pnfs_generic_search_commit_reqs (struct nfs_commit_info *cinfo, +struct folio *folio) {struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;struct pnfs_commit_array *array;
@@ -390,7 +390,7 @@ pnfs_generic_search_commit_reqs(struct nfs_commit_info *cinfo, struct page *pagelist_for_each_entry (array, &fl_cinfo->commits, cinfo_list) { req =pnfs_bucket_search_commit_reqs (array->buckets, - array->nbuckets, page); + array->nbuckets, folio);if (req)return req; }
@@ -1180,7 +1180,7 @@ pnfs_layout_mark_request_commit(struct nfs_page *req,nfs_request_add_commit_list_locked (req, list, cinfo);mutex_unlock (&NFS_I (cinfo->inode)->commit_mutex); -nfs_mark_page_unstable (req->wb_page, cinfo); +nfs_folio_mark_unstable (nfs_page_to_folio (req), cinfo);return ; out_resched:mutex_unlock (&NFS_I (cinfo->inode)->commit_mutex);
fs/nfs/write.c +177 -173
810 lines not on this page · raw message
include/linux/nfs_fs.h +3 -2
@@ -569,8 +569,9 @@ extern void nfs_complete_unlink(struct dentry *dentry, struct inode *);extern int nfs_congestion_kb;extern int nfs_writepage (struct page *page,struct writeback_control *wbc);extern int nfs_writepages (struct address_space *,struct writeback_control *); -extern int nfs_flush_incompatible (struct file *file,struct page *page); -extern int nfs_updatepage (struct file *,struct page *,unsigned int ,unsigned int ); +extern int nfs_flush_incompatible (struct file *file,struct folio *folio); +extern int nfs_update_folio (struct file *file,struct folio *folio, +unsigned int offset,unsigned int count);/* * Try to write back everything synchronously (but check the
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 11/18 NFS: Remove unused function nfs_wb_page()
From: Trond Myklebust <[email protected]>
--- fs/nfs/write.c | 5 ----- include/linux/nfs_fs.h | 1 - 2 files changed, 6 deletions(-)
fs/nfs/write.c +0 -5
@@ -2115,11 +2115,6 @@ int nfs_wb_folio(struct inode *inode, struct folio *folio)return ret; } -int nfs_wb_page (struct inode *inode,struct page *page) -{ -return nfs_wb_folio (inode,page_folio (page)); -} -#ifdef CONFIG_MIGRATION int nfs_migrate_folio (struct address_space *mapping,struct folio *dst,struct folio *src,enum migrate_mode mode)
include/linux/nfs_fs.h +0 -1
@@ -580,7 +580,6 @@ extern int nfs_update_folio(struct file *file, struct folio *folio,extern int nfs_sync_inode (struct inode *inode);extern int nfs_wb_all (struct inode *inode);extern int nfs_wb_folio (struct inode *inode,struct folio *folio); -extern int nfs_wb_page (struct inode *inode,struct page *page);int nfs_wb_folio_cancel (struct inode *inode,struct folio *folio);extern int nfs_commit_inode (struct inode *,int );extern struct nfs_commit_data *nfs_commitdata_alloc (void );
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 12/18 NFS: Convert nfs_write_begin/end to use folios
From: Trond Myklebust <[email protected]>
Add a helper nfs_folio_grab_cache_write_begin() that can call __filemap_get_folio() directly with the appropriate parameters.
Since write_begin()/write_end() take struct page arguments, just pass the folio->page back for now.
--- fs/nfs/file.c | 75 ++++++++++++++++++++++++++++----------------------- 1 file changed, 41 insertions(+), 34 deletions(-)
fs/nfs/file.c +41 -34
@@ -276,27 +276,28 @@ EXPORT_SYMBOL_GPL(nfs_file_fsync);* and that the new data won't completely replace the old data in * that range of the file. */ -static bool nfs_full_page_write (struct page *page,loff_t pos,unsigned int len) +static bool nfs_folio_is_full_write (struct folio *folio,loff_t pos, +unsigned int len) { -unsigned int pglen =nfs_page_length (page); -unsigned int offset = pos & (PAGE_SIZE -1 ); +unsigned int pglen =nfs_folio_length (folio); +unsigned int offset =offset_in_folio (folio, pos);unsigned int end = offset + len;return !pglen || (end >= pglen && !offset); } -static bool nfs_want_read_modify_write (struct file *file,struct page *page, -loff_t pos,unsigned int len) +static bool nfs_want_read_modify_write (struct file *file,struct folio *folio, +loff_t pos,unsigned int len) {/* * Up-to-date pages, those with ongoing or full-page write * don't need read/modify/write */ -if (PageUptodate (page) ||PagePrivate (page) || -nfs_full_page_write (page, pos, len)) +if (folio_test_uptodate (folio) ||folio_test_private (folio) || +nfs_folio_is_full_write (folio, pos, len))return false; -if (pnfs_ld_read_whole_page (file->f_mapping->host)) +if (pnfs_ld_read_whole_page (file_inode (file)))return true;/* Open for reading too? */ if (file->f_mode &FMODE_READ )
@@ -304,6 +305,15 @@ static bool nfs_want_read_modify_write(struct file *file, struct page *page,return false; } +static struct folio * +nfs_folio_grab_cache_write_begin (struct address_space *mapping,pgoff_t index) +{ +unsigned fgp_flags =FGP_LOCK |FGP_WRITE |FGP_CREAT |FGP_STABLE ; + +return __filemap_get_folio (mapping, index, fgp_flags, +mapping_gfp_mask (mapping)); +} +/* * This does the "real" work of the write. We must allocate and lock the * page to be sent back to the generic routine, which then copies the
@@ -313,34 +323,31 @@ static bool nfs_want_read_modify_write(struct file *file, struct page *page,* increment the page use counts until he is done with the page. */ static int nfs_write_begin (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len, -struct page **pagep,void **fsdata) +loff_t pos,unsigned len,struct page **pagep, +void **fsdata) { -int ret; -pgoff_t index = pos >>PAGE_SHIFT ; -struct page *page;struct folio *folio;int once_thru =0 ; +int ret;dfprintk (PAGECACHE ,"NFS: write_begin(%pD2(%lu), %u@%lld)\n" , file, mapping->host->i_ino, len, (long long ) pos); start: - page =grab_cache_page_write_begin (mapping, index); -if (!page) + folio =nfs_folio_grab_cache_write_begin (mapping, pos >>PAGE_SHIFT ); +if (!folio)return -ENOMEM ; - *pagep = page; - folio =page_folio (page); + *pagep = &folio->page; ret =nfs_flush_incompatible (file, folio);if (ret) { -unlock_page (page); -put_page (page); +folio_unlock (folio); +folio_put (folio); }else if (!once_thru && -nfs_want_read_modify_write (file, page, pos, len)) { +nfs_want_read_modify_write (file, folio, pos, len)) { once_thru =1 ; ret =nfs_read_folio (file, folio); -put_page (page); +folio_put (folio);if (!ret) goto start; }
@@ -348,12 +355,12 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping, }static int nfs_write_end (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) +loff_t pos,unsigned len,unsigned copied, +struct page *page,void *fsdata) { -unsigned offset = pos & (PAGE_SIZE -1 );struct nfs_open_context *ctx =nfs_file_open_context (file);struct folio *folio =page_folio (page); +unsigned offset =offset_in_folio (folio, pos);int status; dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
@@ -363,26 +370,26 @@ static int nfs_write_end(struct file *file, struct address_space *mapping,* Zero any uninitialised parts of the page, and then mark the page * as up to date if it turns out that we're extending the file. */ -if (!PageUptodate (page)) { -unsigned pglen =nfs_page_length (page); +if (!folio_test_uptodate (folio)) { +size_t fsize =folio_size (folio); +unsigned pglen =nfs_folio_length (folio);unsigned end = offset + copied;if (pglen ==0 ) { -zero_user_segments (page,0 , offset, - end,PAGE_SIZE ); -SetPageUptodate (page); +folio_zero_segments (folio,0 , offset, end, fsize); +folio_mark_uptodate (folio); }else if (end >= pglen) { -zero_user_segment (page, end,PAGE_SIZE ); +folio_zero_segment (folio, end, fsize);if (offset ==0 ) -SetPageUptodate (page); +folio_mark_uptodate (folio); }else -zero_user_segment (page, pglen,PAGE_SIZE ); +folio_zero_segment (folio, pglen, fsize); } status =nfs_update_folio (file, folio, offset, copied); -unlock_page (page); -put_page (page); +folio_unlock (folio); +folio_put (folio);if (status <0 )return status;
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 13/18 NFS: Fix up nfs_vm_page_mkwrite() for folios
From: Trond Myklebust <[email protected]>
Mechanical conversion of struct page and functions into the folio equivalents.
--- fs/nfs/file.c | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-)
fs/nfs/file.c +10 -11
@@ -556,23 +556,22 @@ const struct address_space_operations nfs_file_aops = {*/ static vm_fault_t nfs_vm_page_mkwrite (struct vm_fault *vmf) { -struct page *page = vmf->page;struct file *filp = vmf->vma->vm_file;struct inode *inode =file_inode (filp);unsigned pagelen;vm_fault_t ret =VM_FAULT_NOPAGE ;struct address_space *mapping; -struct folio *folio =page_folio (page); +struct folio *folio =page_folio (vmf->page);dfprintk (PAGECACHE ,"NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n" , - filp, filp->f_mapping->host->i_ino, - (long long )page_offset (page)); + filp, filp->f_mapping->host->i_ino, + (long long )folio_file_pos (folio));sb_start_pagefault (inode->i_sb);/* make sure the cache has finished storing the page */ -if (PageFsCache (page) && -wait_on_page_fscache_killable (vmf->page) <0 ) { +if (folio_test_fscache (folio) && +folio_wait_fscache_killable (folio) <0 ) { ret =VM_FAULT_RETRY ; goto out; }
@@ -581,14 +580,14 @@ static vm_fault_t nfs_vm_page_mkwrite(struct vm_fault *vmf) nfs_wait_bit_killable, TASK_KILLABLE|TASK_FREEZABLE_UNSAFE); -lock_page (page); - mapping =page_file_mapping (page); +folio_lock (folio); + mapping =folio_file_mapping (folio);if (mapping != inode->i_mapping) goto out_unlock; -wait_on_page_writeback (page); +folio_wait_writeback (folio); - pagelen =nfs_page_length (page); + pagelen =nfs_folio_length (folio);if (pagelen ==0 ) goto out_unlock;
@@ -599,7 +598,7 @@ static vm_fault_t nfs_vm_page_mkwrite(struct vm_fault *vmf) ret =VM_FAULT_SIGBUS ; out_unlock: -unlock_page (page); +folio_unlock (folio); out:sb_end_pagefault (inode->i_sb);return ret;
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 14/18 NFS: Clean up O_DIRECT request allocation
From: Trond Myklebust <[email protected]>
Rather than adjusting the index+offset after the call to nfs_create_request(), add a function nfs_page_create_from_page() that takes an offset.
--- fs/nfs/direct.c | 12 ++++-------- fs/nfs/pagelist.c | 15 +++++++++------ include/linux/nfs_page.h | 9 +++++---- 3 files changed, 18 insertions(+), 18 deletions(-)
fs/nfs/direct.c +4 -8
@@ -343,14 +343,12 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq,struct nfs_page *req;unsigned int req_len =min_t (size_t, bytes,PAGE_SIZE - pgbase);/* XXX do we need to do the eof zeroing found in async_filler? */ - req =nfs_create_request (dreq->ctx, pagevec[i], - pgbase, req_len); + req =nfs_page_create_from_page (dreq->ctx, pagevec[i], + pgbase, pos, req_len);if (IS_ERR (req)) { result =PTR_ERR (req);break ; } - req->wb_index = pos >>PAGE_SHIFT ; - req->wb_offset = pos & ~PAGE_MASK ;if (!nfs_pageio_add_request (&desc, req)) { result = desc.pg_error;nfs_release_request (req);
@@ -802,8 +800,8 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq,struct nfs_page *req;unsigned int req_len =min_t (size_t, bytes,PAGE_SIZE - pgbase); - req =nfs_create_request (dreq->ctx, pagevec[i], - pgbase, req_len); + req =nfs_page_create_from_page (dreq->ctx, pagevec[i], + pgbase, pos, req_len);if (IS_ERR (req)) { result =PTR_ERR (req);break ;
@@ -816,8 +814,6 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq, }nfs_lock_request (req); - req->wb_index = pos >>PAGE_SHIFT ; - req->wb_offset = pos & ~PAGE_MASK ;if (!nfs_pageio_add_request (&desc, req)) { result = desc.pg_error;nfs_unlock_and_release_request (req);
fs/nfs/pagelist.c +9 -6
@@ -514,26 +514,29 @@ static void nfs_page_assign_page(struct nfs_page *req, struct page *page) }/** -* nfs_create_request - Create an NFS read/write request. +* nfs_page_create_from_page - Create an NFS read/write request. * @ctx: open context to use * @page: page to write -* @offset: starting offset within the page for the write +* @pgbase: starting offset within the page for the write +* @offset: file offset for the write * @count: number of bytes to read/write * * The page must be locked by the caller. This makes sure we never * create two different requests for the same page. * User should ensure it is safe to sleep in this function. */ -struct nfs_page * -nfs_create_request (struct nfs_open_context *ctx,struct page *page, -unsigned int offset,unsigned int count) +struct nfs_page *nfs_page_create_from_page (struct nfs_open_context *ctx, +struct page *page, +unsigned int pgbase,loff_t offset, +unsigned int count) {struct nfs_lock_context *l_ctx =nfs_get_lock_context (ctx);struct nfs_page *ret;if (IS_ERR (l_ctx))return ERR_CAST (l_ctx); - ret =nfs_page_create (l_ctx, offset,page_index (page), offset, count); + ret =nfs_page_create (l_ctx, pgbase, offset >>PAGE_SHIFT , +offset_in_page (offset), count);if (!IS_ERR (ret)) {nfs_page_assign_page (ret, page);nfs_page_group_init (ret,NULL );
include/linux/nfs_page.h +5 -4
@@ -121,10 +121,11 @@ struct nfs_pageio_descriptor {#define NFS_WBACK_BUSY (req) (test_bit(PG_BUSY,&(req)->wb_flags)) -extern struct nfs_page *nfs_create_request (struct nfs_open_context *ctx, -struct page *page, -unsigned int offset, -unsigned int count); +extern struct nfs_page *nfs_page_create_from_page (struct nfs_open_context *ctx, +struct page *page, +unsigned int pgbase, +loff_t offset, +unsigned int count); extern struct nfs_page *nfs_page_create_from_folio(struct nfs_open_context *ctx, struct folio *folio, unsigned int offset,
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 15/18 NFS: fix up nfs_release_folio() to try to release the page
From: Trond Myklebust <[email protected]>
If the gfp context allows it, and we're not kswapd, then try to write out the folio that has private data.
--- fs/nfs/file.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
fs/nfs/file.c +7 -2
@@ -432,8 +432,13 @@ static bool nfs_release_folio(struct folio *folio, gfp_t gfp)dfprintk (PAGECACHE ,"NFS: release_folio(%p)\n" , folio);/* If the private flag is set, then the folio is not freeable */ -if (folio_test_private (folio)) -return false; +if (folio_test_private (folio)) { +if ((current_gfp_context (gfp) &GFP_KERNEL ) !=GFP_KERNEL || +current_is_kswapd ()) +return false; +if (nfs_wb_folio (folio_file_mapping (folio)->host, folio) <0 ) +return false; + }return nfs_fscache_release_folio (folio, gfp); }
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 16/18 NFS: Enable tracing of nfs_invalidate_folio() and nfs_launder_folio()
From: Trond Myklebust <[email protected]>
--- fs/nfs/file.c | 9 +++++++-- fs/nfs/nfstrace.h | 41 +++++++++++++++++++++++++++++++++++------ 2 files changed, 42 insertions(+), 8 deletions(-)
fs/nfs/file.c +7 -2
@@ -411,14 +411,16 @@ static int nfs_write_end(struct file *file, struct address_space *mapping,static void nfs_invalidate_folio (struct folio *folio,size_t offset,size_t length) { +struct inode *inode =folio_file_mapping (folio)->host;dfprintk (PAGECACHE ,"NFS: invalidate_folio(%lu, %zu, %zu)\n" , folio->index, offset, length);if (offset !=0 || length <folio_size (folio))return ;/* Cancel any unstarted writes on this page */ -nfs_wb_folio_cancel (folio->mapping->host, folio); +nfs_wb_folio_cancel (inode, folio);folio_wait_fscache (folio); +trace_nfs_invalidate_folio (inode, folio); }/*
@@ -479,12 +481,15 @@ static void nfs_check_dirty_writeback(struct folio *folio,static int nfs_launder_folio (struct folio *folio) {struct inode *inode = folio->mapping->host; +int ret;dfprintk (PAGECACHE ,"NFS: launder_folio(%ld, %llu)\n" , inode->i_ino,folio_pos (folio));folio_wait_fscache (folio); -return nfs_wb_folio (inode, folio); + ret =nfs_wb_folio (inode, folio); +trace_nfs_launder_folio_done (inode, folio, ret); +return ret; } static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
fs/nfs/nfstrace.h +35 -6
90 lines not on this page · raw message
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 17/18 NFS: Improve tracing of nfs_wb_folio()
From: Trond Myklebust <[email protected]>
Include info about which folio is being traced.
--- fs/nfs/nfstrace.h | 5 +++-- fs/nfs/write.c | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-)
fs/nfs/nfstrace.h +3 -2
@@ -152,8 +152,6 @@ DEFINE_NFS_INODE_EVENT(nfs_getattr_enter);DEFINE_NFS_INODE_EVENT_DONE (nfs_getattr_exit);DEFINE_NFS_INODE_EVENT (nfs_setattr_enter);DEFINE_NFS_INODE_EVENT_DONE (nfs_setattr_exit); -DEFINE_NFS_INODE_EVENT (nfs_writeback_page_enter); -DEFINE_NFS_INODE_EVENT_DONE (nfs_writeback_page_exit);DEFINE_NFS_INODE_EVENT (nfs_writeback_inode_enter);DEFINE_NFS_INODE_EVENT_DONE (nfs_writeback_inode_exit);DEFINE_NFS_INODE_EVENT (nfs_fsync_enter);
@@ -1032,6 +1030,9 @@ DECLARE_EVENT_CLASS(nfs_folio_event_done,DEFINE_NFS_FOLIO_EVENT (nfs_aop_readpage);DEFINE_NFS_FOLIO_EVENT_DONE (nfs_aop_readpage_done); +DEFINE_NFS_FOLIO_EVENT (nfs_writeback_folio); +DEFINE_NFS_FOLIO_EVENT_DONE (nfs_writeback_folio_done); +DEFINE_NFS_FOLIO_EVENT (nfs_invalidate_folio);DEFINE_NFS_FOLIO_EVENT_DONE (nfs_launder_folio_done);
fs/nfs/write.c +2 -2
@@ -2093,7 +2093,7 @@ int nfs_wb_folio(struct inode *inode, struct folio *folio) };int ret; -trace_nfs_writeback_page_enter (inode); +trace_nfs_writeback_folio (inode, folio);for (;;) {folio_wait_writeback (folio);
@@ -2111,7 +2111,7 @@ int nfs_wb_folio(struct inode *inode, struct folio *folio) goto out_error; } out_error: -trace_nfs_writeback_page_exit (inode, ret); +trace_nfs_writeback_folio_done (inode, folio, ret);return ret; }
Signature · 1 line
2.39.0
[email protected]
maintainerPATCH v2 18/18 NFS: Remove unnecessary check in nfs_read_folio()
From: Trond Myklebust <[email protected]>
All the callers are expected to supply a valid struct file argument, so there is no need for the NULL check.
--- fs/nfs/read.c | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-)
fs/nfs/read.c +1 -7
@@ -355,13 +355,7 @@ int nfs_read_folio(struct file *file, struct folio *folio)if (NFS_STALE (inode)) goto out_unlock; -if (file ==NULL ) { - ret = -EBADF ; - desc.ctx =nfs_find_open_context (inode,NULL ,FMODE_READ ); -if (desc.ctx ==NULL ) - goto out_unlock; - }else - desc.ctx =get_nfs_open_context (nfs_file_open_context (file)); + desc.ctx =get_nfs_open_context (nfs_file_open_context (file));xchg (&desc.ctx->error,0 ); nfs_pageio_init_read(&desc.pgio, inode, false,
Signature · 1 line
2.39.0
Re: [PATCH v2 18/18] NFS: Remove unnecessary check in nfs_read_folio()
Quoted 4 lines · On Thu, Jan 19, 2023 at 04:33:51PM -0500, [email protected] wrote:
From: Trond Myklebust <[email protected]>
All the callers are expected to supply a valid struct file argument, so there is no need for the NULL check.
Ummm. Not sure that's true. Look at this path:
mapping_read_folio_gfp(mapping, index, gfp) do_read_cache_folio(mapping, index, NULL, NULL, gfp) filemap_read_folio(NULL, mapping->a_ops->read_folio, folio)
It could well be that nobody does this to an NFS file! The places where I see this called tend to be filesystems doing it to block devices, or filesystems doing it to their own files (eg reading a journal file or quota file)
But I'm suspicious of static match tools claiming it can't ever happen, and I'd like more details please. I can't find the original report. Also, it would have been nice to be cc'd on the folio conversion patches.
Quoted 29 lines
Reported-by kernel test robot <[email protected]>Reported-by Dan Carpenter <[email protected]>Signed-off-by Trond Myklebust <[email protected]>--- fs/nfs/read.c | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-)fs/nfs/read.c +1
-7@@ -355,13 +355,7 @@ int nfs_read_folio(struct file *file, struct folio *folio)if (NFS_STALE (inode)) goto out_unlock; -if (file ==NULL ) { - ret = -EBADF ; - desc.ctx =nfs_find_open_context (inode,NULL ,FMODE_READ ); -if (desc.ctx ==NULL ) - goto out_unlock; - }else - desc.ctx =get_nfs_open_context (nfs_file_open_context (file)); + desc.ctx =get_nfs_open_context (nfs_file_open_context (file));xchg (&desc.ctx->error,0 ); nfs_pageio_init_read(&desc.pgio, inode, false,Signature · 1 line
2.39.0
Re: [PATCH v2 18/18] NFS: Remove unnecessary check in nfs_read_folio()
Quoted 2 lines · Matthew Wilcox
But I'm suspicious of static match tools claiming it can't ever happen, and I'd like more details please. I can't find the original report.
I would never write a warning like that... However at the time when I reported the bug then Smatch did say that all the callers passed a non-NULL file pointer. I've reviewed my logs and that was true when I said it but it's not true now. :( Now Smatch says there are three callers and nfs_write_begin() passes a valid pointer, read_pages() passes either a valid pointer or a NULL and filemap_read_folio() passes an unknown pointer.
https://lore.kernel.org/all/Y77+n9MyHgx%2FalA4@kadam/
The issue here is that the pointer was already derefernced on the lines before the check for NULL.
struct inode *inode = file_inode(file);
So either the dereference or the check was wrong.
regards,
dan carpenter
Quoted 19 lines · On Fri, Jan 20, 2023 at 12:10 AM <[email protected]> wrote:
From: Trond Myklebust <[email protected]>
This set of patches represents an initial effort to convert the page cache I/O in the NFS client to use native folio functionality. It should allow the
nfs_pagestructs and their helpers to carry folios (including folios of order > 0) and to pass their data contents through to the RPC layer.
Note that becauseO_DIRECTuses pages, we still need to support the traditional page based I/O, and so the new structnfs_pagewill carry both types.
I did not touch the fscache code, but I expect that to be able to continue to work with order 0 folios.The plan is to merge this functionality with order 0 folios first, in order to catch any regressions in existing functionality. Then we can enable order n > 0 once we're happy about the stability (at least for the non-fscache case).
Quoted 6 lines
At this point, the xfstests are all passing without any regressions on my setup, so I'm throwing the patches over the fence to allow for wider testing.
Please make sure, in particular to test pNFS if your server supports it. I didn't have to make any changes to the pNFS code, and I don't expect any trouble, but it would be good to have validation of that assumption.
Here's my experience with running with these patches running thru xfstest's quick group:
Against a linux server: takes about a couple of minutes longer to run with folio patches (48m with folio, 45 without) but that's just from 1 run with and and without.
Against an ontap server (so pnfs case): total time is higher with
patches: I have a difference of 47m with folio and 38m without.
While I don't believe this is related to folio patches but I need to increase my vm's size to 4g to have a successful run of xfstest. Tests generic/531 and generic/460 are problematic with 2G. generic/531 leads to oom-killer and generic/460 hangs.
Quoted 42 lines
---
v2:
- Fix a bisectability issue reported by Anna
- Remove an unnecessary NULL pointer check innfs_read_folio()Trond Myklebust (18):
NFS: Fix for xfstests generic/208
NFS: Add basic functionality for tracking folios in structnfs_page
NFS: Support folios innfs_generic_pgio()
NFS: Fixnfs_coalesce_size()to work with folios
NFS: Add a helper to convert a structnfs_pageinto an inode
NFS: Convert the remaining pagelist helper functions to support folios
NFS: Add a helpernfs_wb_folio()
NFS: Convert buffered reads to use folios
NFS: Convert the functionnfs_wb_page()to use folios
NFS: Convert buffered writes to use folios
NFS: Remove unused functionnfs_wb_page()
NFS: Convert nfs_write_begin/end to use folios
NFS: Fix upnfs_vm_page_mkwrite()for folios
NFS: Clean upO_DIRECTrequest allocation
NFS: fix upnfs_release_folio()to try to release the page
NFS: Enable tracing ofnfs_invalidate_folio()andnfs_launder_folio()
NFS: Improve tracing ofnfs_wb_folio()
NFS: Remove unnecessary check innfs_read_folio()fs/nfs/direct.c | 12 +- fs/nfs/file.c | 124 +++++++------ fs/nfs/internal.h | 38 ++-- fs/nfs/nfstrace.h | 58 ++++-- fs/nfs/pagelist.c | 217 +++++++++++++++++----- fs/nfs/pnfs.h | 10 +- fs/nfs/pnfs_nfs.c | 18 +- fs/nfs/read.c | 94 +++++----- fs/nfs/write.c | 380 ++++++++++++++++++++------------------- include/linux/nfs_fs.h | 7 +- include/linux/nfs_page.h | 79 +++++++- 11 files changed, 646 insertions(+), 391 deletions(-)--
2.39.0
Quoted 37 lines · Olga Kornievskaia
Quoted 19 lines · On Fri, Jan 20, 2023 at 12:10 AM <[email protected]> wrote:
From: Trond Myklebust <[email protected]>
This set of patches represents an initial effort to convert the page cache I/O in the NFS client to use native folio functionality. It should allow the
nfs_pagestructs and their helpers to carry folios (including folios of order > 0) and to pass their data contents through to the RPC layer.
Note that becauseO_DIRECTuses pages, we still need to support the traditional page based I/O, and so the new structnfs_pagewill carry both types.
I did not touch the fscache code, but I expect that to be able to continue to work with order 0 folios.The plan is to merge this functionality with order 0 folios first, in order to catch any regressions in existing functionality. Then we can enable order n > 0 once we're happy about the stability (at least for the non-fscache case).
Quoted 6 lines
At this point, the xfstests are all passing without any regressions on my setup, so I'm throwing the patches over the fence to allow for wider testing.
Please make sure, in particular to test pNFS if your server supports it. I didn't have to make any changes to the pNFS code, and I don't expect any trouble, but it would be good to have validation of that assumption.Here's my experience with running with these patches running thru xfstest's quick group:
Against a linux server: takes about a couple of minutes longer to run with folio patches (48m with folio, 45 without) but that's just from 1 run with and and without.
Quoted 7 lines
Against an ontap server (so pnfs case): total time is higher with
patches: I have a difference of 47m with folio and 38m without.While I don't believe this is related to folio patches but I need to increase my vm's size to 4g to have a successful run of xfstest. Tests generic/531 and generic/460 are problematic with 2G. generic/531 leads to oom-killer and generic/460 hangs.
Hmm… Does the performance climb back to normal if you revert the patch 21f5ae90169b ("NFS: fix up nfs_release_folio() to try to release the page”)? That’s the only one I can think of that does more than just convert from struct page -> struct folio.
_________________________________
Trond Myklebust
Linux NFS client maintainer, Hammerspace
[email protected]