lkml.org 
[lkml]   [2022]   [Mar]   [9]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
SubjectRe: [PATCH v2 16/19] netfs: Split fs/netfs/read_helper.c
From
Date
On Tue, 2022-03-08 at 23:29 +0000, David Howells wrote:
> Split fs/netfs/read_helper.c into two pieces, one to deal with buffered
> writes and one to deal with the I/O mechanism.
>

I think you mean buffered reads here?

> Changes
> =======
> ver #2)
> - Add kdoc reference to new file.
>
> Signed-off-by: David Howells <dhowells@redhat.com>
> cc: linux-cachefs@redhat.com
>
> Link: https://lore.kernel.org/r/164623005586.3564931.6149556072728481767.stgit@warthog.procyon.org.uk/ # v1
> ---
>
> fs/netfs/Makefile | 1
> fs/netfs/buffered_read.c | 428 ++++++++++++++++++++++++++++++++++++++++++++++
> fs/netfs/io.c | 418 ---------------------------------------------
> 3 files changed, 429 insertions(+), 418 deletions(-)
> create mode 100644 fs/netfs/buffered_read.c
>
> diff --git a/fs/netfs/Makefile b/fs/netfs/Makefile
> index 51ece4f7bc77..88b904532bc7 100644
> --- a/fs/netfs/Makefile
> +++ b/fs/netfs/Makefile
> @@ -1,6 +1,7 @@
> # SPDX-License-Identifier: GPL-2.0
>
> netfs-y := \
> + buffered_read.o \
> io.o \
> objects.o
>
> diff --git a/fs/netfs/buffered_read.c b/fs/netfs/buffered_read.c
> new file mode 100644
> index 000000000000..09ba7097a970
> --- /dev/null
> +++ b/fs/netfs/buffered_read.c
> @@ -0,0 +1,428 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/* Network filesystem high-level buffered read support.
> + *
> + * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
> + * Written by David Howells (dhowells@redhat.com)
> + */
> +
> +#include <linux/export.h>
> +#include <linux/task_io_accounting_ops.h>
> +#include "internal.h"
> +
> +/*
> + * Unlock the folios in a read operation. We need to set PG_fscache on any
> + * folios we're going to write back before we unlock them.
> + */
> +void netfs_rreq_unlock_folios(struct netfs_io_request *rreq)
> +{
> + struct netfs_io_subrequest *subreq;
> + struct folio *folio;
> + unsigned int iopos, account = 0;
> + pgoff_t start_page = rreq->start / PAGE_SIZE;
> + pgoff_t last_page = ((rreq->start + rreq->len) / PAGE_SIZE) - 1;
> + bool subreq_failed = false;
> +
> + XA_STATE(xas, &rreq->mapping->i_pages, start_page);
> +
> + if (test_bit(NETFS_RREQ_FAILED, &rreq->flags)) {
> + __clear_bit(NETFS_RREQ_COPY_TO_CACHE, &rreq->flags);
> + list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
> + __clear_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
> + }
> + }
> +
> + /* Walk through the pagecache and the I/O request lists simultaneously.
> + * We may have a mixture of cached and uncached sections and we only
> + * really want to write out the uncached sections. This is slightly
> + * complicated by the possibility that we might have huge pages with a
> + * mixture inside.
> + */
> + subreq = list_first_entry(&rreq->subrequests,
> + struct netfs_io_subrequest, rreq_link);
> + iopos = 0;
> + subreq_failed = (subreq->error < 0);
> +
> + trace_netfs_rreq(rreq, netfs_rreq_trace_unlock);
> +
> + rcu_read_lock();
> + xas_for_each(&xas, folio, last_page) {
> + unsigned int pgpos = (folio_index(folio) - start_page) * PAGE_SIZE;
> + unsigned int pgend = pgpos + folio_size(folio);
> + bool pg_failed = false;
> +
> + for (;;) {
> + if (!subreq) {
> + pg_failed = true;
> + break;
> + }
> + if (test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags))
> + folio_start_fscache(folio);
> + pg_failed |= subreq_failed;
> + if (pgend < iopos + subreq->len)
> + break;
> +
> + account += subreq->transferred;
> + iopos += subreq->len;
> + if (!list_is_last(&subreq->rreq_link, &rreq->subrequests)) {
> + subreq = list_next_entry(subreq, rreq_link);
> + subreq_failed = (subreq->error < 0);
> + } else {
> + subreq = NULL;
> + subreq_failed = false;
> + }
> + if (pgend == iopos)
> + break;
> + }
> +
> + if (!pg_failed) {
> + flush_dcache_folio(folio);
> + folio_mark_uptodate(folio);
> + }
> +
> + if (!test_bit(NETFS_RREQ_DONT_UNLOCK_FOLIOS, &rreq->flags)) {
> + if (folio_index(folio) == rreq->no_unlock_folio &&
> + test_bit(NETFS_RREQ_NO_UNLOCK_FOLIO, &rreq->flags))
> + _debug("no unlock");
> + else
> + folio_unlock(folio);
> + }
> + }
> + rcu_read_unlock();
> +
> + task_io_account_read(account);
> + if (rreq->netfs_ops->done)
> + rreq->netfs_ops->done(rreq);
> +}
> +
> +static void netfs_cache_expand_readahead(struct netfs_io_request *rreq,
> + loff_t *_start, size_t *_len, loff_t i_size)
> +{
> + struct netfs_cache_resources *cres = &rreq->cache_resources;
> +
> + if (cres->ops && cres->ops->expand_readahead)
> + cres->ops->expand_readahead(cres, _start, _len, i_size);
> +}
> +
> +static void netfs_rreq_expand(struct netfs_io_request *rreq,
> + struct readahead_control *ractl)
> +{
> + /* Give the cache a chance to change the request parameters. The
> + * resultant request must contain the original region.
> + */
> + netfs_cache_expand_readahead(rreq, &rreq->start, &rreq->len, rreq->i_size);
> +
> + /* Give the netfs a chance to change the request parameters. The
> + * resultant request must contain the original region.
> + */
> + if (rreq->netfs_ops->expand_readahead)
> + rreq->netfs_ops->expand_readahead(rreq);
> +
> + /* Expand the request if the cache wants it to start earlier. Note
> + * that the expansion may get further extended if the VM wishes to
> + * insert THPs and the preferred start and/or end wind up in the middle
> + * of THPs.
> + *
> + * If this is the case, however, the THP size should be an integer
> + * multiple of the cache granule size, so we get a whole number of
> + * granules to deal with.
> + */
> + if (rreq->start != readahead_pos(ractl) ||
> + rreq->len != readahead_length(ractl)) {
> + readahead_expand(ractl, rreq->start, rreq->len);
> + rreq->start = readahead_pos(ractl);
> + rreq->len = readahead_length(ractl);
> +
> + trace_netfs_read(rreq, readahead_pos(ractl), readahead_length(ractl),
> + netfs_read_trace_expanded);
> + }
> +}
> +
> +/**
> + * netfs_readahead - Helper to manage a read request
> + * @ractl: The description of the readahead request
> + *
> + * Fulfil a readahead request by drawing data from the cache if possible, or
> + * the netfs if not. Space beyond the EOF is zero-filled. Multiple I/O
> + * requests from different sources will get munged together. If necessary, the
> + * readahead window can be expanded in either direction to a more convenient
> + * alighment for RPC efficiency or to make storage in the cache feasible.
> + *
> + * The calling netfs must initialise a netfs context contiguous to the vfs
> + * inode before calling this.
> + *
> + * This is usable whether or not caching is enabled.
> + */
> +void netfs_readahead(struct readahead_control *ractl)
> +{
> + struct netfs_io_request *rreq;
> + struct netfs_i_context *ctx = netfs_i_context(ractl->mapping->host);
> + int ret;
> +
> + _enter("%lx,%x", readahead_index(ractl), readahead_count(ractl));
> +
> + if (readahead_count(ractl) == 0)
> + return;
> +
> + rreq = netfs_alloc_request(ractl->mapping, ractl->file,
> + readahead_pos(ractl),
> + readahead_length(ractl),
> + NETFS_READAHEAD);
> + if (IS_ERR(rreq))
> + return;
> +
> + if (ctx->ops->begin_cache_operation) {
> + ret = ctx->ops->begin_cache_operation(rreq);
> + if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS)
> + goto cleanup_free;
> + }
> +
> + netfs_stat(&netfs_n_rh_readahead);
> + trace_netfs_read(rreq, readahead_pos(ractl), readahead_length(ractl),
> + netfs_read_trace_readahead);
> +
> + netfs_rreq_expand(rreq, ractl);
> +
> + /* Drop the refs on the folios here rather than in the cache or
> + * filesystem. The locks will be dropped in netfs_rreq_unlock().
> + */
> + while (readahead_folio(ractl))
> + ;
> +
> + netfs_begin_read(rreq, false);
> + return;
> +
> +cleanup_free:
> + netfs_put_request(rreq, false, netfs_rreq_trace_put_failed);
> + return;
> +}
> +EXPORT_SYMBOL(netfs_readahead);
> +
> +/**
> + * netfs_readpage - Helper to manage a readpage request
> + * @file: The file to read from
> + * @subpage: A subpage of the folio to read
> + *
> + * Fulfil a readpage request by drawing data from the cache if possible, or the
> + * netfs if not. Space beyond the EOF is zero-filled. Multiple I/O requests
> + * from different sources will get munged together.
> + *
> + * The calling netfs must initialise a netfs context contiguous to the vfs
> + * inode before calling this.
> + *
> + * This is usable whether or not caching is enabled.
> + */
> +int netfs_readpage(struct file *file, struct page *subpage)
> +{
> + struct folio *folio = page_folio(subpage);
> + struct address_space *mapping = folio_file_mapping(folio);
> + struct netfs_io_request *rreq;
> + struct netfs_i_context *ctx = netfs_i_context(mapping->host);
> + int ret;
> +
> + _enter("%lx", folio_index(folio));
> +
> + rreq = netfs_alloc_request(mapping, file,
> + folio_file_pos(folio), folio_size(folio),
> + NETFS_READPAGE);
> + if (IS_ERR(rreq)) {
> + ret = PTR_ERR(rreq);
> + goto alloc_error;
> + }
> +
> + if (ctx->ops->begin_cache_operation) {
> + ret = ctx->ops->begin_cache_operation(rreq);
> + if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS)
> + goto discard;
> + }
> +
> + netfs_stat(&netfs_n_rh_readpage);
> + trace_netfs_read(rreq, rreq->start, rreq->len, netfs_read_trace_readpage);
> + return netfs_begin_read(rreq, true);
> +
> +discard:
> + netfs_put_request(rreq, false, netfs_rreq_trace_put_discard);
> +alloc_error:
> + folio_unlock(folio);
> + return ret;
> +}
> +EXPORT_SYMBOL(netfs_readpage);
> +
> +/*
> + * Prepare a folio for writing without reading first
> + * @folio: The folio being prepared
> + * @pos: starting position for the write
> + * @len: length of write
> + * @always_fill: T if the folio should always be completely filled/cleared
> + *
> + * In some cases, write_begin doesn't need to read at all:
> + * - full folio write
> + * - write that lies in a folio that is completely beyond EOF
> + * - write that covers the folio from start to EOF or beyond it
> + *
> + * If any of these criteria are met, then zero out the unwritten parts
> + * of the folio and return true. Otherwise, return false.
> + */
> +static bool netfs_skip_folio_read(struct folio *folio, loff_t pos, size_t len,
> + bool always_fill)
> +{
> + struct inode *inode = folio_inode(folio);
> + loff_t i_size = i_size_read(inode);
> + size_t offset = offset_in_folio(folio, pos);
> + size_t plen = folio_size(folio);
> +
> + if (unlikely(always_fill)) {
> + if (pos - offset + len <= i_size)
> + return false; /* Page entirely before EOF */
> + zero_user_segment(&folio->page, 0, plen);
> + folio_mark_uptodate(folio);
> + return true;
> + }
> +
> + /* Full folio write */
> + if (offset == 0 && len >= plen)
> + return true;
> +
> + /* Page entirely beyond the end of the file */
> + if (pos - offset >= i_size)
> + goto zero_out;
> +
> + /* Write that covers from the start of the folio to EOF or beyond */
> + if (offset == 0 && (pos + len) >= i_size)
> + goto zero_out;
> +
> + return false;
> +zero_out:
> + zero_user_segments(&folio->page, 0, offset, offset + len, len);
> + return true;
> +}
> +
> +/**
> + * netfs_write_begin - Helper to prepare for writing
> + * @file: The file to read from
> + * @mapping: The mapping to read from
> + * @pos: File position at which the write will begin
> + * @len: The length of the write (may extend beyond the end of the folio chosen)
> + * @aop_flags: AOP_* flags
> + * @_folio: Where to put the resultant folio
> + * @_fsdata: Place for the netfs to store a cookie
> + *
> + * Pre-read data for a write-begin request by drawing data from the cache if
> + * possible, or the netfs if not. Space beyond the EOF is zero-filled.
> + * Multiple I/O requests from different sources will get munged together. If
> + * necessary, the readahead window can be expanded in either direction to a
> + * more convenient alighment for RPC efficiency or to make storage in the cache
> + * feasible.
> + *
> + * The calling netfs must provide a table of operations, only one of which,
> + * issue_op, is mandatory.
> + *
> + * The check_write_begin() operation can be provided to check for and flush
> + * conflicting writes once the folio is grabbed and locked. It is passed a
> + * pointer to the fsdata cookie that gets returned to the VM to be passed to
> + * write_end. It is permitted to sleep. It should return 0 if the request
> + * should go ahead; unlock the folio and return -EAGAIN to cause the folio to
> + * be regot; or return an error.
> + *
> + * The calling netfs must initialise a netfs context contiguous to the vfs
> + * inode before calling this.
> + *
> + * This is usable whether or not caching is enabled.
> + */
> +int netfs_write_begin(struct file *file, struct address_space *mapping,
> + loff_t pos, unsigned int len, unsigned int aop_flags,
> + struct folio **_folio, void **_fsdata)
> +{
> + struct netfs_io_request *rreq;
> + struct netfs_i_context *ctx = netfs_i_context(file_inode(file ));
> + struct folio *folio;
> + unsigned int fgp_flags;
> + pgoff_t index = pos >> PAGE_SHIFT;
> + int ret;
> +
> + DEFINE_READAHEAD(ractl, file, NULL, mapping, index);
> +
> +retry:
> + fgp_flags = FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE;
> + if (aop_flags & AOP_FLAG_NOFS)
> + fgp_flags |= FGP_NOFS;
> + folio = __filemap_get_folio(mapping, index, fgp_flags,
> + mapping_gfp_mask(mapping));
> + if (!folio)
> + return -ENOMEM;
> +
> + if (ctx->ops->check_write_begin) {
> + /* Allow the netfs (eg. ceph) to flush conflicts. */
> + ret = ctx->ops->check_write_begin(file, pos, len, folio, _fsdata);
> + if (ret < 0) {
> + trace_netfs_failure(NULL, NULL, ret, netfs_fail_check_write_begin);
> + if (ret == -EAGAIN)
> + goto retry;
> + goto error;
> + }
> + }
> +
> + if (folio_test_uptodate(folio))
> + goto have_folio;
> +
> + /* If the page is beyond the EOF, we want to clear it - unless it's
> + * within the cache granule containing the EOF, in which case we need
> + * to preload the granule.
> + */
> + if (!netfs_is_cache_enabled(ctx) &&
> + netfs_skip_folio_read(folio, pos, len, false)) {
> + netfs_stat(&netfs_n_rh_write_zskip);
> + goto have_folio_no_wait;
> + }
> +
> + rreq = netfs_alloc_request(mapping, file,
> + folio_file_pos(folio), folio_size(folio),
> + NETFS_READ_FOR_WRITE);
> + if (IS_ERR(rreq)) {
> + ret = PTR_ERR(rreq);
> + goto error;
> + }
> + rreq->no_unlock_folio = folio_index(folio);
> + __set_bit(NETFS_RREQ_NO_UNLOCK_FOLIO, &rreq->flags);
> +
> + if (ctx->ops->begin_cache_operation) {
> + ret = ctx->ops->begin_cache_operation(rreq);
> + if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS)
> + goto error_put;
> + }
> +
> + netfs_stat(&netfs_n_rh_write_begin);
> + trace_netfs_read(rreq, pos, len, netfs_read_trace_write_begin);
> +
> + /* Expand the request to meet caching requirements and download
> + * preferences.
> + */
> + ractl._nr_pages = folio_nr_pages(folio);
> + netfs_rreq_expand(rreq, &ractl);
> +
> + /* We hold the folio locks, so we can drop the references */
> + folio_get(folio);
> + while (readahead_folio(&ractl))
> + ;
> +
> + ret = netfs_begin_read(rreq, true);
> + if (ret < 0)
> + goto error;
> +
> +have_folio:
> + ret = folio_wait_fscache_killable(folio);
> + if (ret < 0)
> + goto error;
> +have_folio_no_wait:
> + *_folio = folio;
> + _leave(" = 0");
> + return 0;
> +
> +error_put:
> + netfs_put_request(rreq, false, netfs_rreq_trace_put_failed);
> +error:
> + folio_unlock(folio);
> + folio_put(folio);
> + _leave(" = %d", ret);
> + return ret;
> +}
> +EXPORT_SYMBOL(netfs_write_begin);
> diff --git a/fs/netfs/io.c b/fs/netfs/io.c
> index 058a534ba917..1fe9706c58a5 100644
> --- a/fs/netfs/io.c
> +++ b/fs/netfs/io.c
> @@ -246,91 +246,6 @@ static void netfs_rreq_write_to_cache(struct netfs_io_request *rreq)
> BUG();
> }
>
> -/*
> - * Unlock the folios in a read operation. We need to set PG_fscache on any
> - * folios we're going to write back before we unlock them.
> - */
> -void netfs_rreq_unlock_folios(struct netfs_io_request *rreq)
> -{
> - struct netfs_io_subrequest *subreq;
> - struct folio *folio;
> - unsigned int iopos, account = 0;
> - pgoff_t start_page = rreq->start / PAGE_SIZE;
> - pgoff_t last_page = ((rreq->start + rreq->len) / PAGE_SIZE) - 1;
> - bool subreq_failed = false;
> -
> - XA_STATE(xas, &rreq->mapping->i_pages, start_page);
> -
> - if (test_bit(NETFS_RREQ_FAILED, &rreq->flags)) {
> - __clear_bit(NETFS_RREQ_COPY_TO_CACHE, &rreq->flags);
> - list_for_each_entry(subreq, &rreq->subrequests, rreq_link) {
> - __clear_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
> - }
> - }
> -
> - /* Walk through the pagecache and the I/O request lists simultaneously.
> - * We may have a mixture of cached and uncached sections and we only
> - * really want to write out the uncached sections. This is slightly
> - * complicated by the possibility that we might have huge pages with a
> - * mixture inside.
> - */
> - subreq = list_first_entry(&rreq->subrequests,
> - struct netfs_io_subrequest, rreq_link);
> - iopos = 0;
> - subreq_failed = (subreq->error < 0);
> -
> - trace_netfs_rreq(rreq, netfs_rreq_trace_unlock);
> -
> - rcu_read_lock();
> - xas_for_each(&xas, folio, last_page) {
> - unsigned int pgpos = (folio_index(folio) - start_page) * PAGE_SIZE;
> - unsigned int pgend = pgpos + folio_size(folio);
> - bool pg_failed = false;
> -
> - for (;;) {
> - if (!subreq) {
> - pg_failed = true;
> - break;
> - }
> - if (test_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags))
> - folio_start_fscache(folio);
> - pg_failed |= subreq_failed;
> - if (pgend < iopos + subreq->len)
> - break;
> -
> - account += subreq->transferred;
> - iopos += subreq->len;
> - if (!list_is_last(&subreq->rreq_link, &rreq->subrequests)) {
> - subreq = list_next_entry(subreq, rreq_link);
> - subreq_failed = (subreq->error < 0);
> - } else {
> - subreq = NULL;
> - subreq_failed = false;
> - }
> - if (pgend == iopos)
> - break;
> - }
> -
> - if (!pg_failed) {
> - flush_dcache_folio(folio);
> - folio_mark_uptodate(folio);
> - }
> -
> - if (!test_bit(NETFS_RREQ_DONT_UNLOCK_FOLIOS, &rreq->flags)) {
> - if (folio_index(folio) == rreq->no_unlock_folio &&
> - test_bit(NETFS_RREQ_NO_UNLOCK_FOLIO, &rreq->flags))
> - _debug("no unlock");
> - else
> - folio_unlock(folio);
> - }
> - }
> - rcu_read_unlock();
> -
> - task_io_account_read(account);
> - if (rreq->netfs_ops->done)
> - rreq->netfs_ops->done(rreq);
> -}
> -
> /*
> * Handle a short read.
> */
> @@ -750,336 +665,3 @@ int netfs_begin_read(struct netfs_io_request *rreq, bool sync)
> }
> return ret;
> }
> -
> -static void netfs_cache_expand_readahead(struct netfs_io_request *rreq,
> - loff_t *_start, size_t *_len, loff_t i_size)
> -{
> - struct netfs_cache_resources *cres = &rreq->cache_resources;
> -
> - if (cres->ops && cres->ops->expand_readahead)
> - cres->ops->expand_readahead(cres, _start, _len, i_size);
> -}
> -
> -static void netfs_rreq_expand(struct netfs_io_request *rreq,
> - struct readahead_control *ractl)
> -{
> - /* Give the cache a chance to change the request parameters. The
> - * resultant request must contain the original region.
> - */
> - netfs_cache_expand_readahead(rreq, &rreq->start, &rreq->len, rreq->i_size);
> -
> - /* Give the netfs a chance to change the request parameters. The
> - * resultant request must contain the original region.
> - */
> - if (rreq->netfs_ops->expand_readahead)
> - rreq->netfs_ops->expand_readahead(rreq);
> -
> - /* Expand the request if the cache wants it to start earlier. Note
> - * that the expansion may get further extended if the VM wishes to
> - * insert THPs and the preferred start and/or end wind up in the middle
> - * of THPs.
> - *
> - * If this is the case, however, the THP size should be an integer
> - * multiple of the cache granule size, so we get a whole number of
> - * granules to deal with.
> - */
> - if (rreq->start != readahead_pos(ractl) ||
> - rreq->len != readahead_length(ractl)) {
> - readahead_expand(ractl, rreq->start, rreq->len);
> - rreq->start = readahead_pos(ractl);
> - rreq->len = readahead_length(ractl);
> -
> - trace_netfs_read(rreq, readahead_pos(ractl), readahead_length(ractl),
> - netfs_read_trace_expanded);
> - }
> -}
> -
> -/**
> - * netfs_readahead - Helper to manage a read request
> - * @ractl: The description of the readahead request
> - *
> - * Fulfil a readahead request by drawing data from the cache if possible, or
> - * the netfs if not. Space beyond the EOF is zero-filled. Multiple I/O
> - * requests from different sources will get munged together. If necessary, the
> - * readahead window can be expanded in either direction to a more convenient
> - * alighment for RPC efficiency or to make storage in the cache feasible.
> - *
> - * The calling netfs must initialise a netfs context contiguous to the vfs
> - * inode before calling this.
> - *
> - * This is usable whether or not caching is enabled.
> - */
> -void netfs_readahead(struct readahead_control *ractl)
> -{
> - struct netfs_io_request *rreq;
> - struct netfs_i_context *ctx = netfs_i_context(ractl->mapping->host);
> - int ret;
> -
> - _enter("%lx,%x", readahead_index(ractl), readahead_count(ractl));
> -
> - if (readahead_count(ractl) == 0)
> - return;
> -
> - rreq = netfs_alloc_request(ractl->mapping, ractl->file,
> - readahead_pos(ractl),
> - readahead_length(ractl),
> - NETFS_READAHEAD);
> - if (IS_ERR(rreq))
> - return;
> -
> - if (ctx->ops->begin_cache_operation) {
> - ret = ctx->ops->begin_cache_operation(rreq);
> - if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS)
> - goto cleanup_free;
> - }
> -
> - netfs_stat(&netfs_n_rh_readahead);
> - trace_netfs_read(rreq, readahead_pos(ractl), readahead_length(ractl),
> - netfs_read_trace_readahead);
> -
> - netfs_rreq_expand(rreq, ractl);
> -
> - /* Drop the refs on the folios here rather than in the cache or
> - * filesystem. The locks will be dropped in netfs_rreq_unlock().
> - */
> - while (readahead_folio(ractl))
> - ;
> -
> - netfs_begin_read(rreq, false);
> - return;
> -
> -cleanup_free:
> - netfs_put_request(rreq, false, netfs_rreq_trace_put_failed);
> - return;
> -}
> -EXPORT_SYMBOL(netfs_readahead);
> -
> -/**
> - * netfs_readpage - Helper to manage a readpage request
> - * @file: The file to read from
> - * @subpage: A subpage of the folio to read
> - *
> - * Fulfil a readpage request by drawing data from the cache if possible, or the
> - * netfs if not. Space beyond the EOF is zero-filled. Multiple I/O requests
> - * from different sources will get munged together.
> - *
> - * The calling netfs must initialise a netfs context contiguous to the vfs
> - * inode before calling this.
> - *
> - * This is usable whether or not caching is enabled.
> - */
> -int netfs_readpage(struct file *file, struct page *subpage)
> -{
> - struct folio *folio = page_folio(subpage);
> - struct address_space *mapping = folio->mapping;
> - struct netfs_io_request *rreq;
> - struct netfs_i_context *ctx = netfs_i_context(mapping->host);
> - int ret;
> -
> - _enter("%lx", folio_index(folio));
> -
> - rreq = netfs_alloc_request(mapping, file,
> - folio_file_pos(folio), folio_size(folio),
> - NETFS_READPAGE);
> - if (IS_ERR(rreq)) {
> - ret = PTR_ERR(rreq);
> - goto alloc_error;
> - }
> -
> - if (ctx->ops->begin_cache_operation) {
> - ret = ctx->ops->begin_cache_operation(rreq);
> - if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS)
> - goto discard;
> - }
> -
> - netfs_stat(&netfs_n_rh_readpage);
> - trace_netfs_read(rreq, rreq->start, rreq->len, netfs_read_trace_readpage);
> - return netfs_begin_read(rreq, true);
> -
> -discard:
> - netfs_put_request(rreq, false, netfs_rreq_trace_put_discard);
> -alloc_error:
> - folio_unlock(folio);
> - return ret;
> -}
> -EXPORT_SYMBOL(netfs_readpage);
> -
> -/*
> - * Prepare a folio for writing without reading first
> - * @folio: The folio being prepared
> - * @pos: starting position for the write
> - * @len: length of write
> - * @always_fill: T if the folio should always be completely filled/cleared
> - *
> - * In some cases, write_begin doesn't need to read at all:
> - * - full folio write
> - * - write that lies in a folio that is completely beyond EOF
> - * - write that covers the folio from start to EOF or beyond it
> - *
> - * If any of these criteria are met, then zero out the unwritten parts
> - * of the folio and return true. Otherwise, return false.
> - */
> -static bool netfs_skip_folio_read(struct folio *folio, loff_t pos, size_t len,
> - bool always_fill)
> -{
> - struct inode *inode = folio_inode(folio);
> - loff_t i_size = i_size_read(inode);
> - size_t offset = offset_in_folio(folio, pos);
> - size_t plen = folio_size(folio);
> -
> - if (unlikely(always_fill)) {
> - if (pos - offset + len <= i_size)
> - return false; /* Page entirely before EOF */
> - zero_user_segment(&folio->page, 0, plen);
> - folio_mark_uptodate(folio);
> - return true;
> - }
> -
> - /* Full folio write */
> - if (offset == 0 && len >= plen)
> - return true;
> -
> - /* Page entirely beyond the end of the file */
> - if (pos - offset >= i_size)
> - goto zero_out;
> -
> - /* Write that covers from the start of the folio to EOF or beyond */
> - if (offset == 0 && (pos + len) >= i_size)
> - goto zero_out;
> -
> - return false;
> -zero_out:
> - zero_user_segments(&folio->page, 0, offset, offset + len, len);
> - return true;
> -}
> -
> -/**
> - * netfs_write_begin - Helper to prepare for writing
> - * @file: The file to read from
> - * @mapping: The mapping to read from
> - * @pos: File position at which the write will begin
> - * @len: The length of the write (may extend beyond the end of the folio chosen)
> - * @aop_flags: AOP_* flags
> - * @_folio: Where to put the resultant folio
> - * @_fsdata: Place for the netfs to store a cookie
> - *
> - * Pre-read data for a write-begin request by drawing data from the cache if
> - * possible, or the netfs if not. Space beyond the EOF is zero-filled.
> - * Multiple I/O requests from different sources will get munged together. If
> - * necessary, the readahead window can be expanded in either direction to a
> - * more convenient alighment for RPC efficiency or to make storage in the cache
> - * feasible.
> - *
> - * The calling netfs must provide a table of operations, only one of which,
> - * issue_op, is mandatory.
> - *
> - * The check_write_begin() operation can be provided to check for and flush
> - * conflicting writes once the folio is grabbed and locked. It is passed a
> - * pointer to the fsdata cookie that gets returned to the VM to be passed to
> - * write_end. It is permitted to sleep. It should return 0 if the request
> - * should go ahead; unlock the folio and return -EAGAIN to cause the folio to
> - * be regot; or return an error.
> - *
> - * The calling netfs must initialise a netfs context contiguous to the vfs
> - * inode before calling this.
> - *
> - * This is usable whether or not caching is enabled.
> - */
> -int netfs_write_begin(struct file *file, struct address_space *mapping,
> - loff_t pos, unsigned int len, unsigned int aop_flags,
> - struct folio **_folio, void **_fsdata)
> -{
> - struct netfs_io_request *rreq;
> - struct netfs_i_context *ctx = netfs_i_context(file_inode(file ));
> - struct folio *folio;
> - unsigned int fgp_flags;
> - pgoff_t index = pos >> PAGE_SHIFT;
> - int ret;
> -
> - DEFINE_READAHEAD(ractl, file, NULL, mapping, index);
> -
> -retry:
> - fgp_flags = FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE;
> - if (aop_flags & AOP_FLAG_NOFS)
> - fgp_flags |= FGP_NOFS;
> - folio = __filemap_get_folio(mapping, index, fgp_flags,
> - mapping_gfp_mask(mapping));
> - if (!folio)
> - return -ENOMEM;
> -
> - if (ctx->ops->check_write_begin) {
> - /* Allow the netfs (eg. ceph) to flush conflicts. */
> - ret = ctx->ops->check_write_begin(file, pos, len, folio, _fsdata);
> - if (ret < 0) {
> - trace_netfs_failure(NULL, NULL, ret, netfs_fail_check_write_begin);
> - if (ret == -EAGAIN)
> - goto retry;
> - goto error;
> - }
> - }
> -
> - if (folio_test_uptodate(folio))
> - goto have_folio;
> -
> - /* If the page is beyond the EOF, we want to clear it - unless it's
> - * within the cache granule containing the EOF, in which case we need
> - * to preload the granule.
> - */
> - if (!netfs_is_cache_enabled(ctx) &&
> - netfs_skip_folio_read(folio, pos, len, false)) {
> - netfs_stat(&netfs_n_rh_write_zskip);
> - goto have_folio_no_wait;
> - }
> -
> - rreq = netfs_alloc_request(mapping, file,
> - folio_file_pos(folio), folio_size(folio),
> - NETFS_READ_FOR_WRITE);
> - if (IS_ERR(rreq)) {
> - ret = PTR_ERR(rreq);
> - goto error;
> - }
> - rreq->no_unlock_folio = folio_index(folio);
> - __set_bit(NETFS_RREQ_NO_UNLOCK_FOLIO, &rreq->flags);
> -
> - if (ctx->ops->begin_cache_operation) {
> - ret = ctx->ops->begin_cache_operation(rreq);
> - if (ret == -ENOMEM || ret == -EINTR || ret == -ERESTARTSYS)
> - goto error_put;
> - }
> -
> - netfs_stat(&netfs_n_rh_write_begin);
> - trace_netfs_read(rreq, pos, len, netfs_read_trace_write_begin);
> -
> - /* Expand the request to meet caching requirements and download
> - * preferences.
> - */
> - ractl._nr_pages = folio_nr_pages(folio);
> - netfs_rreq_expand(rreq, &ractl);
> -
> - /* We hold the folio locks, so we can drop the references */
> - folio_get(folio);
> - while (readahead_folio(&ractl))
> - ;
> -
> - ret = netfs_begin_read(rreq, true);
> - if (ret < 0)
> - goto error;
> -
> -have_folio:
> - ret = folio_wait_fscache_killable(folio);
> - if (ret < 0)
> - goto error;
> -have_folio_no_wait:
> - *_folio = folio;
> - _leave(" = 0");
> - return 0;
> -
> -error_put:
> - netfs_put_request(rreq, false, netfs_rreq_trace_put_failed);
> -error:
> - folio_unlock(folio);
> - folio_put(folio);
> - _leave(" = %d", ret);
> - return ret;
> -}
> -EXPORT_SYMBOL(netfs_write_begin);
>
>

Patch itself is fine though.

Reviewed-by: Jeff Layton <jlayton@kernel.org>

\
 
 \ /
  Last update: 2022-03-09 21:30    [W:0.438 / U:0.176 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site