github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-07 06:17:02 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

nfs: introduce nfs_direct_extract_pages helper

Browse Source 
Introduce nfs_direct_extract_pages() in direct.c to centralize page
extraction and request creation for the Direct I/O path. The helper
manages extraction from the iters and builds a list of nfs_page requests

Refactor nfs_direct_read_schedule_iovec() and
nfs_direct_write_schedule_iovec() to utilize the new helper, unifying
the extraction logic on both paths.

Signed-off-by: Pranjal Shrivastava <praan@google.com>
Reviewed-by: Shivaji Kant <shivajikant@google.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Anna Schumaker <anna.schumaker@hammerspace.com>
This commit is contained in:
Pranjal Shrivastava 2026-08-14 14:32:55 +00:00 committed by Anna Schumaker
parent a2bb86ade0
commit 7851fd653c
1 changed files with 64 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
fs/nfs/direct.c
View File

@ -152,6 +152,50 @@ static void nfs_direct_release_pages(struct page **pages, unsigned int npages,
unpin_user_pages(pages, npages);
}
static ssize_t nfs_direct_extract_pages(struct nfs_direct_req *dreq,
struct iov_iter *iter,
size_t size, loff_t *pos,
struct list_head *list)
{
bool pinned = iov_iter_extract_will_pin(iter);
struct page **pagevec = NULL;
ssize_t result, bytes = 0;
int err = 0;
unsigned int npages, i;
size_t pgbase;
result = iov_iter_extract_pages(iter, &pagevec, size, ~0U, 0, &pgbase);
if (result <= 0)
return result;
npages = (result + pgbase + PAGE_SIZE - 1) >> PAGE_SHIFT;
for (i = 0; i < npages; i++) {
struct nfs_page *req;
unsigned int req_len = min_t(size_t, result - bytes, PAGE_SIZE - pgbase);
req = nfs_page_create_from_page(dreq->ctx, pagevec[i],
pinned, pgbase, *pos,
req_len);
if (IS_ERR(req)) {
err = PTR_ERR(req);
break;
}
list_add_tail(&req->wb_list, list);
pgbase = 0;
bytes += req_len;
*pos += req_len;
}
if (i < npages) {
iov_iter_revert(iter, result - bytes);
nfs_direct_release_pages(pagevec + i, npages - i, pinned);
}
kvfree(pagevec);
return bytes ? bytes : err;
}
void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo,
struct nfs_direct_req *dreq)
{
@ -320,6 +364,7 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq,
ssize_t result = -EINVAL;
size_t requested_bytes = 0;
size_t rsize = max_t(size_t, NFS_SERVER(inode)->rsize, PAGE_SIZE);
LIST_HEAD(nfs_page_list);
nfs_pageio_init_read(&desc, dreq->inode, false,
&nfs_direct_read_completion_ops);
@ -328,44 +373,23 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq,
inode_dio_begin(inode);
while (iov_iter_count(iter)) {
struct page **pagevec = NULL;
size_t bytes;
size_t pgbase;
unsigned npages, i;
bool pinned = iov_iter_extract_will_pin(iter);
result = iov_iter_extract_pages(iter, &pagevec,
rsize, ~0U, 0, &pgbase);
result = nfs_direct_extract_pages(dreq, iter, rsize, &pos, &nfs_page_list);
if (result < 0)
break;
bytes = result;
npages = (result + pgbase + PAGE_SIZE - 1) / PAGE_SIZE;
for (i = 0; i < npages; i++) {
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_page_create_from_page(dreq->ctx, pagevec[i],
pinned, pgbase, pos,
req_len);
if (IS_ERR(req)) {
result = PTR_ERR(req);
break;
}
while (!list_empty(&nfs_page_list)) {
struct nfs_page *req = nfs_list_entry(nfs_page_list.next);
size_t req_len = req->wb_bytes;
nfs_list_remove_request(req);
if (!nfs_pageio_add_request(&desc, req)) {
result = desc.pg_error;
nfs_release_request(req);
i++;
nfs_release_request_list(&nfs_page_list);
break;
}
pgbase = 0;
bytes -= req_len;
requested_bytes += req_len;
pos += req_len;
}
if (i < npages)
nfs_direct_release_pages(pagevec + i, npages - i, pinned);
kvfree(pagevec);
if (result < 0)
break;
}
@ -856,6 +880,7 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq,
ssize_t result = 0;
size_t requested_bytes = 0;
size_t wsize = max_t(size_t, NFS_SERVER(inode)->wsize, PAGE_SIZE);
LIST_HEAD(nfs_page_list);
bool defer = false;
trace_nfs_direct_write_schedule_iovec(dreq);
@ -868,57 +893,32 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq,
NFS_I(inode)->write_io += iov_iter_count(iter);
while (iov_iter_count(iter)) {
struct page **pagevec = NULL;
size_t bytes;
size_t pgbase;
unsigned npages, i;
bool pinned = iov_iter_extract_will_pin(iter);
result = iov_iter_extract_pages(iter, &pagevec,
wsize, ~0U, 0, &pgbase);
result = nfs_direct_extract_pages(dreq, iter, wsize, &pos, &nfs_page_list);
if (result < 0)
break;
bytes = result;
npages = (result + pgbase + PAGE_SIZE - 1) / PAGE_SIZE;
for (i = 0; i < npages; i++) {
struct nfs_page *req;
unsigned int req_len = min_t(size_t, bytes, PAGE_SIZE - pgbase);
req = nfs_page_create_from_page(dreq->ctx, pagevec[i],
pinned, pgbase, pos,
req_len);
if (IS_ERR(req)) {
result = PTR_ERR(req);
break;
}
if (desc.pg_error < 0) {
nfs_free_request(req);
result = desc.pg_error;
i++;
break;
}
pgbase = 0;
bytes -= req_len;
requested_bytes += req_len;
pos += req_len;
while (!list_empty(&nfs_page_list)) {
struct nfs_page *req = nfs_list_entry(nfs_page_list.next);
size_t req_len = req->wb_bytes;
nfs_list_remove_request(req);
if (defer) {
nfs_mark_request_commit(req, NULL, &cinfo, 0);
requested_bytes += req_len;
continue;
}
nfs_lock_request(req);
if (nfs_pageio_add_request(&desc, req))
if (nfs_pageio_add_request(&desc, req)) {
requested_bytes += req_len;
continue;
}
/* Exit on hard errors */
if (desc.pg_error < 0 && desc.pg_error != -EAGAIN) {
result = desc.pg_error;
nfs_unlock_and_release_request(req);
i++;
nfs_release_request_list(&nfs_page_list);
break;
}
@ -929,12 +929,10 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq,
spin_unlock(&dreq->lock);
nfs_unlock_request(req);
nfs_mark_request_commit(req, NULL, &cinfo, 0);
requested_bytes += req_len;
desc.pg_error = 0;
defer = true;
}
if (i < npages)
nfs_direct_release_pages(pagevec + i, npages - i, pinned);
kvfree(pagevec);
if (result < 0)
break;
}