Re: [PATCH 24/26] netfs: Remove the old writeback code

Jeff Layton
2024-04-15T12:20:46Z

On Thu, 2024-03-28 at 16:34 +0000, David Howells wrote:
> Remove the old writeback code.
>
> Signed-off-by: David Howells <dhowells@redhat.com>
> cc: Jeff Layton <jlayton@kernel.org>
> cc: Eric Van Hensbergen <ericvh@kernel.org>
> cc: Latchesar Ionkov <lucho@ionkov.net>
> cc: Dominique Martinet <asmadeus@codewreck.org>
> cc: Christian Schoenebeck <linux_oss@crudebyte.com>
> cc: Marc Dionne <marc.dionne@auristor.com>
> cc: v9fs@lists.linux.dev
> cc: linux-afs@lists.infradead.org
> cc: netfs@lists.linux.dev
> cc: linux-fsdevel@vger.kernel.org
> ---
> fs/9p/vfs_addr.c | 34 ---
> fs/afs/write.c | 40 ---
> fs/netfs/buffered_write.c | 629 --------------------------------------
> fs/netfs/direct_write.c | 2 +-
> fs/netfs/output.c | 477 -----------------------------
> 5 files changed, 1 insertion(+), 1181 deletions(-)
> delete mode 100644 fs/netfs/output.c
>
> diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
> index 4845e655bc39..a97ceb105cd8 100644
> --- a/fs/9p/vfs_addr.c
> +++ b/fs/9p/vfs_addr.c
> @@ -60,40 +60,6 @@ static void v9fs_issue_write(struct netfs_io_subrequest *subreq)
> netfs_write_subrequest_terminated(subreq, len ?: err, false);
> }
>
> -#if 0 // TODO: Remove

#23 and #24 should probably be merged. I don't see any reason to do the
two-step of ifdef'ing out the code and then removing it. Just go for it
at this point in the series.

> -static void v9fs_upload_to_server(struct netfs_io_subrequest *subreq)
> -{
> - struct p9_fid *fid = subreq->rreq->netfs_priv;
> - int err, len;
> -
> - trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
> - len = p9_client_write(fid, subreq->start, &subreq->io_iter, &err);
> - netfs_write_subrequest_terminated(subreq, len ?: err, false);
> -}
> -
> -static void v9fs_upload_to_server_worker(struct work_struct *work)
> -{
> - struct netfs_io_subrequest *subreq =
> - container_of(work, struct netfs_io_subrequest, work);
> -
> - v9fs_upload_to_server(subreq);
> -}
> -
> -/*
> - * Set up write requests for a writeback slice. We need to add a write request
> - * for each write we want to make.
> - */
> -static void v9fs_create_write_requests(struct netfs_io_request *wreq, loff_t start, size_t len)
> -{
> - struct netfs_io_subrequest *subreq;
> -
> - subreq = netfs_create_write_request(wreq, NETFS_UPLOAD_TO_SERVER,
> - start, len, v9fs_upload_to_server_worker);
> - if (subreq)
> - netfs_queue_write_request(subreq);
> -}
> -#endif
> -
> /**
> * v9fs_issue_read - Issue a read from 9P
> * @subreq: The read to make
> diff --git a/fs/afs/write.c b/fs/afs/write.c
> index 0ead204c84cb..6ef7d4cbc008 100644
> --- a/fs/afs/write.c
> +++ b/fs/afs/write.c
> @@ -156,46 +156,6 @@ static int afs_store_data(struct afs_vnode *vnode, struct iov_iter *iter, loff_t
> return afs_put_operation(op);
> }
>
> -#if 0 // TODO: Remove
> -static void afs_upload_to_server(struct netfs_io_subrequest *subreq)
> -{
> - struct afs_vnode *vnode = AFS_FS_I(subreq->rreq->inode);
> - ssize_t ret;
> -
> - _enter("%x[%x],%zx",
> - subreq->rreq->debug_id, subreq->debug_index, subreq->io_iter.count);
> -
> - trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
> - ret = afs_store_data(vnode, &subreq->io_iter, subreq->start);
> - netfs_write_subrequest_terminated(subreq, ret < 0 ? ret : subreq->len,
> - false);
> -}
> -
> -static void afs_upload_to_server_worker(struct work_struct *work)
> -{
> - struct netfs_io_subrequest *subreq =
> - container_of(work, struct netfs_io_subrequest, work);
> -
> - afs_upload_to_server(subreq);
> -}
> -
> -/*
> - * Set up write requests for a writeback slice. We need to add a write request
> - * for each write we want to make.
> - */
> -void afs_create_write_requests(struct netfs_io_request *wreq, loff_t start, size_t len)
> -{
> - struct netfs_io_subrequest *subreq;
> -
> - _enter("%x,%llx-%llx", wreq->debug_id, start, start + len);
> -
> - subreq = netfs_create_write_request(wreq, NETFS_UPLOAD_TO_SERVER,
> - start, len, afs_upload_to_server_worker);
> - if (subreq)
> - netfs_queue_write_request(subreq);
> -}
> -#endif
> -
> /*
> * Writeback calls this when it finds a folio that needs uploading. This isn't
> * called if writeback only has copy-to-cache to deal with.
> diff --git a/fs/netfs/buffered_write.c b/fs/netfs/buffered_write.c
> index 945e646cd2db..2da9905abec9 100644
> --- a/fs/netfs/buffered_write.c
> +++ b/fs/netfs/buffered_write.c
> @@ -575,632 +575,3 @@ vm_fault_t netfs_page_mkwrite(struct vm_fault *vmf, struct netfs_group *netfs_gr
> return ret;
> }
> EXPORT_SYMBOL(netfs_page_mkwrite);
> -
> -#if 0 // TODO: Remove
> -/*
> - * Kill all the pages in the given range
> - */
> -static void netfs_kill_pages(struct address_space *mapping,
> - loff_t start, loff_t len)
> -{
> - struct folio *folio;
> - pgoff_t index = start / PAGE_SIZE;
> - pgoff_t last = (start + len - 1) / PAGE_SIZE, next;
> -
> - _enter("%llx-%llx", start, start + len - 1);
> -
> - do {
> - _debug("kill %lx (to %lx)", index, last);
> -
> - folio = filemap_get_folio(mapping, index);
> - if (IS_ERR(folio)) {
> - next = index + 1;
> - continue;
> - }
> -
> - next = folio_next_index(folio);
> -
> - trace_netfs_folio(folio, netfs_folio_trace_kill);
> - folio_clear_uptodate(folio);
> - folio_end_writeback(folio);
> - folio_lock(folio);
> - generic_error_remove_folio(mapping, folio);
> - folio_unlock(folio);
> - folio_put(folio);
> -
> - } while (index = next, index <= last);
> -
> - _leave("");
> -}
> -
> -/*
> - * Redirty all the pages in a given range.
> - */
> -static void netfs_redirty_pages(struct address_space *mapping,
> - loff_t start, loff_t len)
> -{
> - struct folio *folio;
> - pgoff_t index = start / PAGE_SIZE;
> - pgoff_t last = (start + len - 1) / PAGE_SIZE, next;
> -
> - _enter("%llx-%llx", start, start + len - 1);
> -
> - do {
> - _debug("redirty %llx @%llx", len, start);
> -
> - folio = filemap_get_folio(mapping, index);
> - if (IS_ERR(folio)) {
> - next = index + 1;
> - continue;
> - }
> -
> - next = folio_next_index(folio);
> - trace_netfs_folio(folio, netfs_folio_trace_redirty);
> - filemap_dirty_folio(mapping, folio);
> - folio_end_writeback(folio);
> - folio_put(folio);
> - } while (index = next, index <= last);
> -
> - balance_dirty_pages_ratelimited(mapping);
> -
> - _leave("");
> -}
> -
> -/*
> - * Completion of write to server
> - */
> -static void netfs_pages_written_back(struct netfs_io_request *wreq)
> -{
> - struct address_space *mapping = wreq->mapping;
> - struct netfs_folio *finfo;
> - struct netfs_group *group = NULL;
> - struct folio *folio;
> - pgoff_t last;
> - int gcount = 0;
> -
> - XA_STATE(xas, &mapping->i_pages, wreq->start / PAGE_SIZE);
> -
> - _enter("%llx-%llx", wreq->start, wreq->start + wreq->len);
> -
> - rcu_read_lock();
> -
> - last = (wreq->start + wreq->len - 1) / PAGE_SIZE;
> - xas_for_each(&xas, folio, last) {
> - WARN(!folio_test_writeback(folio),
> - "bad %llx @%llx page %lx %lx\n",
> - wreq->len, wreq->start, folio->index, last);
> -
> - if ((finfo = netfs_folio_info(folio))) {
> - /* Streaming writes cannot be redirtied whilst under
> - * writeback, so discard the streaming record.
> - */
> - folio_detach_private(folio);
> - group = finfo->netfs_group;
> - gcount++;
> - trace_netfs_folio(folio, netfs_folio_trace_clear_s);
> - kfree(finfo);
> - } else if ((group = netfs_folio_group(folio))) {
> - /* Need to detach the group pointer if the page didn't
> - * get redirtied. If it has been redirtied, then it
> - * must be within the same group.
> - */
> - if (folio_test_dirty(folio)) {
> - trace_netfs_folio(folio, netfs_folio_trace_redirtied);
> - goto end_wb;
> - }
> - if (folio_trylock(folio)) {
> - if (!folio_test_dirty(folio)) {
> - folio_detach_private(folio);
> - gcount++;
> - if (group == NETFS_FOLIO_COPY_TO_CACHE)
> - trace_netfs_folio(folio,
> - netfs_folio_trace_end_copy);
> - else
> - trace_netfs_folio(folio, netfs_folio_trace_clear_g);
> - } else {
> - trace_netfs_folio(folio, netfs_folio_trace_redirtied);
> - }
> - folio_unlock(folio);
> - goto end_wb;
> - }
> -
> - xas_pause(&xas);
> - rcu_read_unlock();
> - folio_lock(folio);
> - if (!folio_test_dirty(folio)) {
> - folio_detach_private(folio);
> - gcount++;
> - trace_netfs_folio(folio, netfs_folio_trace_clear_g);
> - } else {
> - trace_netfs_folio(folio, netfs_folio_trace_redirtied);
> - }
> - folio_unlock(folio);
> - rcu_read_lock();
> - } else {
> - trace_netfs_folio(folio, netfs_folio_trace_clear);
> - }
> - end_wb:
> - xas_advance(&xas, folio_next_index(folio) - 1);
> - folio_end_writeback(folio);
> - }
> -
> - rcu_read_unlock();
> - netfs_put_group_many(group, gcount);
> - _leave("");
> -}
> -
> -/*
> - * Deal with the disposition of the folios that are under writeback to close
> - * out the operation.
> - */
> -static void netfs_cleanup_buffered_write(struct netfs_io_request *wreq)
> -{
> - struct address_space *mapping = wreq->mapping;
> -
> - _enter("");
> -
> - switch (wreq->error) {
> - case 0:
> - netfs_pages_written_back(wreq);
> - break;
> -
> - default:
> - pr_notice("R=%08x Unexpected error %d\n", wreq->debug_id, wreq->error);
> - fallthrough;
> - case -EACCES:
> - case -EPERM:
> - case -ENOKEY:
> - case -EKEYEXPIRED:
> - case -EKEYREJECTED:
> - case -EKEYREVOKED:
> - case -ENETRESET:
> - case -EDQUOT:
> - case -ENOSPC:
> - netfs_redirty_pages(mapping, wreq->start, wreq->len);
> - break;
> -
> - case -EROFS:
> - case -EIO:
> - case -EREMOTEIO:
> - case -EFBIG:
> - case -ENOENT:
> - case -ENOMEDIUM:
> - case -ENXIO:
> - netfs_kill_pages(mapping, wreq->start, wreq->len);
> - break;
> - }
> -
> - if (wreq->error)
> - mapping_set_error(mapping, wreq->error);
> - if (wreq->netfs_ops->done)
> - wreq->netfs_ops->done(wreq);
> -}
> -
> -/*
> - * Extend the region to be written back to include subsequent contiguously
> - * dirty pages if possible, but don't sleep while doing so.
> - *
> - * If this page holds new content, then we can include filler zeros in the
> - * writeback.
> - */
> -static void netfs_extend_writeback(struct address_space *mapping,
> - struct netfs_group *group,
> - struct xa_state *xas,
> - long *_count,
> - loff_t start,
> - loff_t max_len,
> - size_t *_len,
> - size_t *_top)
> -{
> - struct netfs_folio *finfo;
> - struct folio_batch fbatch;
> - struct folio *folio;
> - unsigned int i;
> - pgoff_t index = (start + *_len) / PAGE_SIZE;
> - size_t len;
> - void *priv;
> - bool stop = true;
> -
> - folio_batch_init(&fbatch);
> -
> - do {
> - /* Firstly, we gather up a batch of contiguous dirty pages
> - * under the RCU read lock - but we can't clear the dirty flags
> - * there if any of those pages are mapped.
> - */
> - rcu_read_lock();
> -
> - xas_for_each(xas, folio, ULONG_MAX) {
> - stop = true;
> - if (xas_retry(xas, folio))
> - continue;
> - if (xa_is_value(folio))
> - break;
> - if (folio->index != index) {
> - xas_reset(xas);
> - break;
> - }
> -
> - if (!folio_try_get_rcu(folio)) {
> - xas_reset(xas);
> - continue;
> - }
> -
> - /* Has the folio moved or been split? */
> - if (unlikely(folio != xas_reload(xas))) {
> - folio_put(folio);
> - xas_reset(xas);
> - break;
> - }
> -
> - if (!folio_trylock(folio)) {
> - folio_put(folio);
> - xas_reset(xas);
> - break;
> - }
> - if (!folio_test_dirty(folio) ||
> - folio_test_writeback(folio)) {
> - folio_unlock(folio);
> - folio_put(folio);
> - xas_reset(xas);
> - break;
> - }
> -
> - stop = false;
> - len = folio_size(folio);
> - priv = folio_get_private(folio);
> - if ((const struct netfs_group *)priv != group) {
> - stop = true;
> - finfo = netfs_folio_info(folio);
> - if (!finfo ||
> - finfo->netfs_group != group ||
> - finfo->dirty_offset > 0) {
> - folio_unlock(folio);
> - folio_put(folio);
> - xas_reset(xas);
> - break;
> - }
> - len = finfo->dirty_len;
> - }
> -
> - *_top += folio_size(folio);
> - index += folio_nr_pages(folio);
> - *_count -= folio_nr_pages(folio);
> - *_len += len;
> - if (*_len >= max_len || *_count <= 0)
> - stop = true;
> -
> - if (!folio_batch_add(&fbatch, folio))
> - break;
> - if (stop)
> - break;
> - }
> -
> - xas_pause(xas);
> - rcu_read_unlock();
> -
> - /* Now, if we obtained any folios, we can shift them to being
> - * writable and mark them for caching.
> - */
> - if (!folio_batch_count(&fbatch))
> - break;
> -
> - for (i = 0; i < folio_batch_count(&fbatch); i++) {
> - folio = fbatch.folios[i];
> - if (group == NETFS_FOLIO_COPY_TO_CACHE)
> - trace_netfs_folio(folio, netfs_folio_trace_copy_plus);
> - else
> - trace_netfs_folio(folio, netfs_folio_trace_store_plus);
> -
> - if (!folio_clear_dirty_for_io(folio))
> - BUG();
> - folio_start_writeback(folio);
> - folio_unlock(folio);
> - }
> -
> - folio_batch_release(&fbatch);
> - cond_resched();
> - } while (!stop);
> -}
> -
> -/*
> - * Synchronously write back the locked page and any subsequent non-locked dirty
> - * pages.
> - */
> -static ssize_t netfs_write_back_from_locked_folio(struct address_space *mapping,
> - struct writeback_control *wbc,
> - struct netfs_group *group,
> - struct xa_state *xas,
> - struct folio *folio,
> - unsigned long long start,
> - unsigned long long end)
> -{
> - struct netfs_io_request *wreq;
> - struct netfs_folio *finfo;
> - struct netfs_inode *ctx = netfs_inode(mapping->host);
> - unsigned long long i_size = i_size_read(&ctx->inode);
> - size_t len, max_len;
> - long count = wbc->nr_to_write;
> - int ret;
> -
> - _enter(",%lx,%llx-%llx", folio->index, start, end);
> -
> - wreq = netfs_alloc_request(mapping, NULL, start, folio_size(folio),
> - group == NETFS_FOLIO_COPY_TO_CACHE ?
> - NETFS_COPY_TO_CACHE : NETFS_WRITEBACK);
> - if (IS_ERR(wreq)) {
> - folio_unlock(folio);
> - return PTR_ERR(wreq);
> - }
> -
> - if (!folio_clear_dirty_for_io(folio))
> - BUG();
> - folio_start_writeback(folio);
> -
> - count -= folio_nr_pages(folio);
> -
> - /* Find all consecutive lockable dirty pages that have contiguous
> - * written regions, stopping when we find a page that is not
> - * immediately lockable, is not dirty or is missing, or we reach the
> - * end of the range.
> - */
> - if (group == NETFS_FOLIO_COPY_TO_CACHE)
> - trace_netfs_folio(folio, netfs_folio_trace_copy);
> - else
> - trace_netfs_folio(folio, netfs_folio_trace_store);
> -
> - len = wreq->len;
> - finfo = netfs_folio_info(folio);
> - if (finfo) {
> - start += finfo->dirty_offset;
> - if (finfo->dirty_offset + finfo->dirty_len != len) {
> - len = finfo->dirty_len;
> - goto cant_expand;
> - }
> - len = finfo->dirty_len;
> - }
> -
> - if (start < i_size) {
> - /* Trim the write to the EOF; the extra data is ignored. Also
> - * put an upper limit on the size of a single storedata op.
> - */
> - max_len = 65536 * 4096;
> - max_len = min_t(unsigned long long, max_len, end - start + 1);
> - max_len = min_t(unsigned long long, max_len, i_size - start);
> -
> - if (len < max_len)
> - netfs_extend_writeback(mapping, group, xas, &count, start,
> - max_len, &len, &wreq->upper_len);
> - }
> -
> -cant_expand:
> - len = min_t(unsigned long long, len, i_size - start);
> -
> - /* We now have a contiguous set of dirty pages, each with writeback
> - * set; the first page is still locked at this point, but all the rest
> - * have been unlocked.
> - */
> - folio_unlock(folio);
> - wreq->start = start;
> - wreq->len = len;
> -
> - if (start < i_size) {
> - _debug("write back %zx @%llx [%llx]", len, start, i_size);
> -
> - /* Speculatively write to the cache. We have to fix this up
> - * later if the store fails.
> - */
> - wreq->cleanup = netfs_cleanup_buffered_write;
> -
> - iov_iter_xarray(&wreq->iter, ITER_SOURCE, &mapping->i_pages, start,
> - wreq->upper_len);
> - if (group != NETFS_FOLIO_COPY_TO_CACHE) {
> - __set_bit(NETFS_RREQ_UPLOAD_TO_SERVER, &wreq->flags);
> - ret = netfs_begin_write(wreq, true, netfs_write_trace_writeback);
> - } else {
> - ret = netfs_begin_write(wreq, true, netfs_write_trace_copy_to_cache);
> - }
> - if (ret == 0 || ret == -EIOCBQUEUED)
> - wbc->nr_to_write -= len / PAGE_SIZE;
> - } else {
> - _debug("write discard %zx @%llx [%llx]", len, start, i_size);
> -
> - /* The dirty region was entirely beyond the EOF. */
> - netfs_pages_written_back(wreq);
> - ret = 0;
> - }
> -
> - netfs_put_request(wreq, false, netfs_rreq_trace_put_return);
> - _leave(" = 1");
> - return 1;
> -}
> -
> -/*
> - * Write a region of pages back to the server
> - */
> -static ssize_t netfs_writepages_begin(struct address_space *mapping,
> - struct writeback_control *wbc,
> - struct netfs_group *group,
> - struct xa_state *xas,
> - unsigned long long *_start,
> - unsigned long long end)
> -{
> - const struct netfs_folio *finfo;
> - struct folio *folio;
> - unsigned long long start = *_start;
> - ssize_t ret;
> - void *priv;
> - int skips = 0;
> -
> - _enter("%llx,%llx,", start, end);
> -
> -search_again:
> - /* Find the first dirty page in the group. */
> - rcu_read_lock();
> -
> - for (;;) {
> - folio = xas_find_marked(xas, end / PAGE_SIZE, PAGECACHE_TAG_DIRTY);
> - if (xas_retry(xas, folio) || xa_is_value(folio))
> - continue;
> - if (!folio)
> - break;
> -
> - if (!folio_try_get_rcu(folio)) {
> - xas_reset(xas);
> - continue;
> - }
> -
> - if (unlikely(folio != xas_reload(xas))) {
> - folio_put(folio);
> - xas_reset(xas);
> - continue;
> - }
> -
> - /* Skip any dirty folio that's not in the group of interest. */
> - priv = folio_get_private(folio);
> - if ((const struct netfs_group *)priv == NETFS_FOLIO_COPY_TO_CACHE) {
> - group = NETFS_FOLIO_COPY_TO_CACHE;
> - } else if ((const struct netfs_group *)priv != group) {
> - finfo = __netfs_folio_info(priv);
> - if (!finfo || finfo->netfs_group != group) {
> - folio_put(folio);
> - continue;
> - }
> - }
> -
> - xas_pause(xas);
> - break;
> - }
> - rcu_read_unlock();
> - if (!folio)
> - return 0;
> -
> - start = folio_pos(folio); /* May regress with THPs */
> -
> - _debug("wback %lx", folio->index);
> -
> - /* At this point we hold neither the i_pages lock nor the page lock:
> - * the page may be truncated or invalidated (changing page->mapping to
> - * NULL), or even swizzled back from swapper_space to tmpfs file
> - * mapping
> - */
> -lock_again:
> - if (wbc->sync_mode != WB_SYNC_NONE) {
> - ret = folio_lock_killable(folio);
> - if (ret < 0)
> - return ret;
> - } else {
> - if (!folio_trylock(folio))
> - goto search_again;
> - }
> -
> - if (folio->mapping != mapping ||
> - !folio_test_dirty(folio)) {
> - start += folio_size(folio);
> - folio_unlock(folio);
> - goto search_again;
> - }
> -
> - if (folio_test_writeback(folio)) {
> - folio_unlock(folio);
> - if (wbc->sync_mode != WB_SYNC_NONE) {
> - folio_wait_writeback(folio);
> - goto lock_again;
> - }
> -
> - start += folio_size(folio);
> - if (wbc->sync_mode == WB_SYNC_NONE) {
> - if (skips >= 5 || need_resched()) {
> - ret = 0;
> - goto out;
> - }
> - skips++;
> - }
> - goto search_again;
> - }
> -
> - ret = netfs_write_back_from_locked_folio(mapping, wbc, group, xas,
> - folio, start, end);
> -out:
> - if (ret > 0)
> - *_start = start + ret;
> - _leave(" = %zd [%llx]", ret, *_start);
> - return ret;
> -}
> -
> -/*
> - * Write a region of pages back to the server
> - */
> -static int netfs_writepages_region(struct address_space *mapping,
> - struct writeback_control *wbc,
> - struct netfs_group *group,
> - unsigned long long *_start,
> - unsigned long long end)
> -{
> - ssize_t ret;
> -
> - XA_STATE(xas, &mapping->i_pages, *_start / PAGE_SIZE);
> -
> - do {
> - ret = netfs_writepages_begin(mapping, wbc, group, &xas,
> - _start, end);
> - if (ret > 0 && wbc->nr_to_write > 0)
> - cond_resched();
> - } while (ret > 0 && wbc->nr_to_write > 0);
> -
> - return ret > 0 ? 0 : ret;
> -}
> -
> -/*
> - * write some of the pending data back to the server
> - */
> -int netfs_writepages(struct address_space *mapping,
> - struct writeback_control *wbc)
> -{
> - struct netfs_group *group = NULL;
> - loff_t start, end;
> - int ret;
> -
> - _enter("");
> -
> - /* We have to be careful as we can end up racing with setattr()
> - * truncating the pagecache since the caller doesn't take a lock here
> - * to prevent it.
> - */
> -
> - if (wbc->range_cyclic && mapping->writeback_index) {
> - start = mapping->writeback_index * PAGE_SIZE;
> - ret = netfs_writepages_region(mapping, wbc, group,
> - &start, LLONG_MAX);
> - if (ret < 0)
> - goto out;
> -
> - if (wbc->nr_to_write <= 0) {
> - mapping->writeback_index = start / PAGE_SIZE;
> - goto out;
> - }
> -
> - start = 0;
> - end = mapping->writeback_index * PAGE_SIZE;
> - mapping->writeback_index = 0;
> - ret = netfs_writepages_region(mapping, wbc, group, &start, end);
> - if (ret == 0)
> - mapping->writeback_index = start / PAGE_SIZE;
> - } else if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) {
> - start = 0;
> - ret = netfs_writepages_region(mapping, wbc, group,
> - &start, LLONG_MAX);
> - if (wbc->nr_to_write > 0 && ret == 0)
> - mapping->writeback_index = start / PAGE_SIZE;
> - } else {
> - start = wbc->range_start;
> - ret = netfs_writepages_region(mapping, wbc, group,
> - &start, wbc->range_end);
> - }
> -
> -out:
> - _leave(" = %d", ret);
> - return ret;
> -}
> -EXPORT_SYMBOL(netfs_writepages);
> -#endif
> diff --git a/fs/netfs/direct_write.c b/fs/netfs/direct_write.c
> index 330ba7cb3f10..e4a9cf7cd234 100644
> --- a/fs/netfs/direct_write.c
> +++ b/fs/netfs/direct_write.c
> @@ -37,7 +37,7 @@ static ssize_t netfs_unbuffered_write_iter_locked(struct kiocb *iocb, struct iov
> size_t len = iov_iter_count(iter);
> bool async = !is_sync_kiocb(iocb);
>
> - _enter("");
> + _enter("%lx", iov_iter_count(iter));
>
> /* We're going to need a bounce buffer if what we transmit is going to
> * be different in some way to the source buffer, e.g. because it gets
> diff --git a/fs/netfs/output.c b/fs/netfs/output.c
> deleted file mode 100644
> index 85374322f10f..000000000000
> --- a/fs/netfs/output.c
> +++ /dev/null
> @@ -1,477 +0,0 @@
> -// SPDX-License-Identifier: GPL-2.0-only
> -/* Network filesystem high-level write support.
> - *
> - * Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
> - * Written by David Howells (dhowells@redhat.com)
> - */
> -
> -#include <linux/fs.h>
> -#include <linux/mm.h>
> -#include <linux/pagemap.h>
> -#include <linux/slab.h>
> -#include <linux/writeback.h>
> -#include <linux/pagevec.h>
> -#include "internal.h"
> -
> -/**
> - * netfs_create_write_request - Create a write operation.
> - * @wreq: The write request this is storing from.
> - * @dest: The destination type
> - * @start: Start of the region this write will modify
> - * @len: Length of the modification
> - * @worker: The worker function to handle the write(s)
> - *
> - * Allocate a write operation, set it up and add it to the list on a write
> - * request.
> - */
> -struct netfs_io_subrequest *netfs_create_write_request(struct netfs_io_request *wreq,
> - enum netfs_io_source dest,
> - loff_t start, size_t len,
> - work_func_t worker)
> -{
> - struct netfs_io_subrequest *subreq;
> -
> - subreq = netfs_alloc_subrequest(wreq);
> - if (subreq) {
> - INIT_WORK(&subreq->work, worker);
> - subreq->source = dest;
> - subreq->start = start;
> - subreq->len = len;
> -
> - switch (subreq->source) {
> - case NETFS_UPLOAD_TO_SERVER:
> - netfs_stat(&netfs_n_wh_upload);
> - break;
> - case NETFS_WRITE_TO_CACHE:
> - netfs_stat(&netfs_n_wh_write);
> - break;
> - default:
> - BUG();
> - }
> -
> - subreq->io_iter = wreq->io_iter;
> - iov_iter_advance(&subreq->io_iter, subreq->start - wreq->start);
> - iov_iter_truncate(&subreq->io_iter, subreq->len);
> -
> - trace_netfs_sreq_ref(wreq->debug_id, subreq->debug_index,
> - refcount_read(&subreq->ref),
> - netfs_sreq_trace_new);
> - atomic_inc(&wreq->nr_outstanding);
> - list_add_tail(&subreq->rreq_link, &wreq->subrequests);
> - trace_netfs_sreq(subreq, netfs_sreq_trace_prepare);
> - }
> -
> - return subreq;
> -}
> -EXPORT_SYMBOL(netfs_create_write_request);
> -
> -/*
> - * Process a completed write request once all the component operations have
> - * been completed.
> - */
> -static void netfs_write_terminated(struct netfs_io_request *wreq, bool was_async)
> -{
> - struct netfs_io_subrequest *subreq;
> - struct netfs_inode *ctx = netfs_inode(wreq->inode);
> - size_t transferred = 0;
> -
> - _enter("R=%x[]", wreq->debug_id);
> -
> - trace_netfs_rreq(wreq, netfs_rreq_trace_write_done);
> -
> - list_for_each_entry(subreq, &wreq->subrequests, rreq_link) {
> - if (subreq->error || subreq->transferred == 0)
> - break;
> - transferred += subreq->transferred;
> - if (subreq->transferred < subreq->len)
> - break;
> - }
> - wreq->transferred = transferred;
> -
> - list_for_each_entry(subreq, &wreq->subrequests, rreq_link) {
> - if (!subreq->error)
> - continue;
> - switch (subreq->source) {
> - case NETFS_UPLOAD_TO_SERVER:
> - /* Depending on the type of failure, this may prevent
> - * writeback completion unless we're in disconnected
> - * mode.
> - */
> - if (!wreq->error)
> - wreq->error = subreq->error;
> - break;
> -
> - case NETFS_WRITE_TO_CACHE:
> - /* Failure doesn't prevent writeback completion unless
> - * we're in disconnected mode.
> - */
> - if (subreq->error != -ENOBUFS)
> - ctx->ops->invalidate_cache(wreq);
> - break;
> -
> - default:
> - WARN_ON_ONCE(1);
> - if (!wreq->error)
> - wreq->error = -EIO;
> - return;
> - }
> - }
> -
> - wreq->cleanup(wreq);
> -
> - if (wreq->origin == NETFS_DIO_WRITE &&
> - wreq->mapping->nrpages) {
> - pgoff_t first = wreq->start >> PAGE_SHIFT;
> - pgoff_t last = (wreq->start + wreq->transferred - 1) >> PAGE_SHIFT;
> - invalidate_inode_pages2_range(wreq->mapping, first, last);
> - }
> -
> - if (wreq->origin == NETFS_DIO_WRITE)
> - inode_dio_end(wreq->inode);
> -
> - _debug("finished");
> - trace_netfs_rreq(wreq, netfs_rreq_trace_wake_ip);
> - clear_bit_unlock(NETFS_RREQ_IN_PROGRESS, &wreq->flags);
> - wake_up_bit(&wreq->flags, NETFS_RREQ_IN_PROGRESS);
> -
> - if (wreq->iocb) {
> - wreq->iocb->ki_pos += transferred;
> - if (wreq->iocb->ki_complete)
> - wreq->iocb->ki_complete(
> - wreq->iocb, wreq->error ? wreq->error : transferred);
> - }
> -
> - netfs_clear_subrequests(wreq, was_async);
> - netfs_put_request(wreq, was_async, netfs_rreq_trace_put_complete);
> -}
> -
> -/*
> - * Deal with the completion of writing the data to the cache.
> - */
> -void netfs_write_subrequest_terminated(void *_op, ssize_t transferred_or_error,
> - bool was_async)
> -{
> - struct netfs_io_subrequest *subreq = _op;
> - struct netfs_io_request *wreq = subreq->rreq;
> - unsigned int u;
> -
> - _enter("%x[%x] %zd", wreq->debug_id, subreq->debug_index, transferred_or_error);
> -
> - switch (subreq->source) {
> - case NETFS_UPLOAD_TO_SERVER:
> - netfs_stat(&netfs_n_wh_upload_done);
> - break;
> - case NETFS_WRITE_TO_CACHE:
> - netfs_stat(&netfs_n_wh_write_done);
> - break;
> - case NETFS_INVALID_WRITE:
> - break;
> - default:
> - BUG();
> - }
> -
> - if (IS_ERR_VALUE(transferred_or_error)) {
> - subreq->error = transferred_or_error;
> - trace_netfs_failure(wreq, subreq, transferred_or_error,
> - netfs_fail_write);
> - goto failed;
> - }
> -
> - if (WARN(transferred_or_error > subreq->len - subreq->transferred,
> - "Subreq excess write: R%x[%x] %zd > %zu - %zu",
> - wreq->debug_id, subreq->debug_index,
> - transferred_or_error, subreq->len, subreq->transferred))
> - transferred_or_error = subreq->len - subreq->transferred;
> -
> - subreq->error = 0;
> - subreq->transferred += transferred_or_error;
> -
> - if (iov_iter_count(&subreq->io_iter) != subreq->len - subreq->transferred)
> - pr_warn("R=%08x[%u] ITER POST-MISMATCH %zx != %zx-%zx %x\n",
> - wreq->debug_id, subreq->debug_index,
> - iov_iter_count(&subreq->io_iter), subreq->len,
> - subreq->transferred, subreq->io_iter.iter_type);
> -
> - if (subreq->transferred < subreq->len)
> - goto incomplete;
> -
> - __clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags);
> -out:
> - trace_netfs_sreq(subreq, netfs_sreq_trace_terminated);
> -
> - /* If we decrement nr_outstanding to 0, the ref belongs to us. */
> - u = atomic_dec_return(&wreq->nr_outstanding);
> - if (u == 0)
> - netfs_write_terminated(wreq, was_async);
> - else if (u == 1)
> - wake_up_var(&wreq->nr_outstanding);
> -
> - netfs_put_subrequest(subreq, was_async, netfs_sreq_trace_put_terminated);
> - return;
> -
> -incomplete:
> - if (transferred_or_error == 0) {
> - if (__test_and_set_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags)) {
> - subreq->error = -ENODATA;
> - goto failed;
> - }
> - } else {
> - __clear_bit(NETFS_SREQ_NO_PROGRESS, &subreq->flags);
> - }
> -
> - __set_bit(NETFS_SREQ_SHORT_IO, &subreq->flags);
> - set_bit(NETFS_RREQ_INCOMPLETE_IO, &wreq->flags);
> - goto out;
> -
> -failed:
> - switch (subreq->source) {
> - case NETFS_WRITE_TO_CACHE:
> - netfs_stat(&netfs_n_wh_write_failed);
> - set_bit(NETFS_RREQ_INCOMPLETE_IO, &wreq->flags);
> - break;
> - case NETFS_UPLOAD_TO_SERVER:
> - netfs_stat(&netfs_n_wh_upload_failed);
> - set_bit(NETFS_RREQ_FAILED, &wreq->flags);
> - wreq->error = subreq->error;
> - break;
> - default:
> - break;
> - }
> - goto out;
> -}
> -EXPORT_SYMBOL(netfs_write_subrequest_terminated);
> -
> -static void netfs_write_to_cache_op(struct netfs_io_subrequest *subreq)
> -{
> - struct netfs_io_request *wreq = subreq->rreq;
> - struct netfs_cache_resources *cres = &wreq->cache_resources;
> -
> - trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
> -
> - cres->ops->write(cres, subreq->start, &subreq->io_iter,
> - netfs_write_subrequest_terminated, subreq);
> -}
> -
> -static void netfs_write_to_cache_op_worker(struct work_struct *work)
> -{
> - struct netfs_io_subrequest *subreq =
> - container_of(work, struct netfs_io_subrequest, work);
> -
> - netfs_write_to_cache_op(subreq);
> -}
> -
> -/**
> - * netfs_queue_write_request - Queue a write request for attention
> - * @subreq: The write request to be queued
> - *
> - * Queue the specified write request for processing by a worker thread. We
> - * pass the caller's ref on the request to the worker thread.
> - */
> -void netfs_queue_write_request(struct netfs_io_subrequest *subreq)
> -{
> - if (!queue_work(system_unbound_wq, &subreq->work))
> - netfs_put_subrequest(subreq, false, netfs_sreq_trace_put_wip);
> -}
> -EXPORT_SYMBOL(netfs_queue_write_request);
> -
> -/*
> - * Set up a op for writing to the cache.
> - */
> -static void netfs_set_up_write_to_cache(struct netfs_io_request *wreq)
> -{
> - struct netfs_cache_resources *cres = &wreq->cache_resources;
> - struct netfs_io_subrequest *subreq;
> - struct netfs_inode *ctx = netfs_inode(wreq->inode);
> - struct fscache_cookie *cookie = netfs_i_cookie(ctx);
> - loff_t start = wreq->start;
> - size_t len = wreq->len;
> - int ret;
> -
> - if (!fscache_cookie_enabled(cookie)) {
> - clear_bit(NETFS_RREQ_WRITE_TO_CACHE, &wreq->flags);
> - return;
> - }
> -
> - _debug("write to cache");
> - ret = fscache_begin_write_operation(cres, cookie);
> - if (ret < 0)
> - return;
> -
> - ret = cres->ops->prepare_write(cres, &start, &len, wreq->upper_len,
> - i_size_read(wreq->inode), true);
> - if (ret < 0)
> - return;
> -
> - subreq = netfs_create_write_request(wreq, NETFS_WRITE_TO_CACHE, start, len,
> - netfs_write_to_cache_op_worker);
> - if (!subreq)
> - return;
> -
> - netfs_write_to_cache_op(subreq);
> -}
> -
> -/*
> - * Begin the process of writing out a chunk of data.
> - *
> - * We are given a write request that holds a series of dirty regions and
> - * (partially) covers a sequence of folios, all of which are present. The
> - * pages must have been marked as writeback as appropriate.
> - *
> - * We need to perform the following steps:
> - *
> - * (1) If encrypting, create an output buffer and encrypt each block of the
> - * data into it, otherwise the output buffer will point to the original
> - * folios.
> - *
> - * (2) If the data is to be cached, set up a write op for the entire output
> - * buffer to the cache, if the cache wants to accept it.
> - *
> - * (3) If the data is to be uploaded (ie. not merely cached):
> - *
> - * (a) If the data is to be compressed, create a compression buffer and
> - * compress the data into it.
> - *
> - * (b) For each destination we want to upload to, set up write ops to write
> - * to that destination. We may need multiple writes if the data is not
> - * contiguous or the span exceeds wsize for a server.
> - */
> -int netfs_begin_write(struct netfs_io_request *wreq, bool may_wait,
> - enum netfs_write_trace what)
> -{
> - struct netfs_inode *ctx = netfs_inode(wreq->inode);
> -
> - _enter("R=%x %llx-%llx f=%lx",
> - wreq->debug_id, wreq->start, wreq->start + wreq->len - 1,
> - wreq->flags);
> -
> - trace_netfs_write(wreq, what);
> - if (wreq->len == 0 || wreq->iter.count == 0) {
> - pr_err("Zero-sized write [R=%x]\n", wreq->debug_id);
> - return -EIO;
> - }
> -
> - if (wreq->origin == NETFS_DIO_WRITE)
> - inode_dio_begin(wreq->inode);
> -
> - wreq->io_iter = wreq->iter;
> -
> - /* ->outstanding > 0 carries a ref */
> - netfs_get_request(wreq, netfs_rreq_trace_get_for_outstanding);
> - atomic_set(&wreq->nr_outstanding, 1);
> -
> - /* Start the encryption/compression going. We can do that in the
> - * background whilst we generate a list of write ops that we want to
> - * perform.
> - */
> - // TODO: Encrypt or compress the region as appropriate
> -
> - /* We need to write all of the region to the cache */
> - if (test_bit(NETFS_RREQ_WRITE_TO_CACHE, &wreq->flags))
> - netfs_set_up_write_to_cache(wreq);
> -
> - /* However, we don't necessarily write all of the region to the server.
> - * Caching of reads is being managed this way also.
> - */
> - if (test_bit(NETFS_RREQ_UPLOAD_TO_SERVER, &wreq->flags))
> - ctx->ops->create_write_requests(wreq, wreq->start, wreq->len);
> -
> - if (atomic_dec_and_test(&wreq->nr_outstanding))
> - netfs_write_terminated(wreq, false);
> -
> - if (!may_wait)
> - return -EIOCBQUEUED;
> -
> - wait_on_bit(&wreq->flags, NETFS_RREQ_IN_PROGRESS,
> - TASK_UNINTERRUPTIBLE);
> - return wreq->error;
> -}
> -
> -/*
> - * Begin a write operation for writing through the pagecache.
> - */
> -struct netfs_io_request *netfs_begin_writethrough(struct kiocb *iocb, size_t len)
> -{
> - struct netfs_io_request *wreq;
> - struct file *file = iocb->ki_filp;
> -
> - wreq = netfs_alloc_request(file->f_mapping, file, iocb->ki_pos, len,
> - NETFS_WRITETHROUGH);
> - if (IS_ERR(wreq))
> - return wreq;
> -
> - trace_netfs_write(wreq, netfs_write_trace_writethrough);
> -
> - __set_bit(NETFS_RREQ_UPLOAD_TO_SERVER, &wreq->flags);
> - iov_iter_xarray(&wreq->iter, ITER_SOURCE, &wreq->mapping->i_pages, wreq->start, 0);
> - wreq->io_iter = wreq->iter;
> -
> - /* ->outstanding > 0 carries a ref */
> - netfs_get_request(wreq, netfs_rreq_trace_get_for_outstanding);
> - atomic_set(&wreq->nr_outstanding, 1);
> - return wreq;
> -}
> -
> -static void netfs_submit_writethrough(struct netfs_io_request *wreq, bool final)
> -{
> - struct netfs_inode *ictx = netfs_inode(wreq->inode);
> - unsigned long long start;
> - size_t len;
> -
> - if (!test_bit(NETFS_RREQ_UPLOAD_TO_SERVER, &wreq->flags))
> - return;
> -
> - start = wreq->start + wreq->submitted;
> - len = wreq->iter.count - wreq->submitted;
> - if (!final) {
> - len /= wreq->wsize; /* Round to number of maximum packets */
> - len *= wreq->wsize;
> - }
> -
> - ictx->ops->create_write_requests(wreq, start, len);
> - wreq->submitted += len;
> -}
> -
> -/*
> - * Advance the state of the write operation used when writing through the
> - * pagecache. Data has been copied into the pagecache that we need to append
> - * to the request. If we've added more than wsize then we need to create a new
> - * subrequest.
> - */
> -int netfs_advance_writethrough(struct netfs_io_request *wreq, size_t copied, bool to_page_end)
> -{
> - _enter("ic=%zu sb=%llu ws=%u cp=%zu tp=%u",
> - wreq->iter.count, wreq->submitted, wreq->wsize, copied, to_page_end);
> -
> - wreq->iter.count += copied;
> - wreq->io_iter.count += copied;
> - if (to_page_end && wreq->io_iter.count - wreq->submitted >= wreq->wsize)
> - netfs_submit_writethrough(wreq, false);
> -
> - return wreq->error;
> -}
> -
> -/*
> - * End a write operation used when writing through the pagecache.
> - */
> -int netfs_end_writethrough(struct netfs_io_request *wreq, struct kiocb *iocb)
> -{
> - int ret = -EIOCBQUEUED;
> -
> - _enter("ic=%zu sb=%llu ws=%u",
> - wreq->iter.count, wreq->submitted, wreq->wsize);
> -
> - if (wreq->submitted < wreq->io_iter.count)
> - netfs_submit_writethrough(wreq, true);
> -
> - if (atomic_dec_and_test(&wreq->nr_outstanding))
> - netfs_write_terminated(wreq, false);
> -
> - if (is_sync_kiocb(iocb)) {
> - wait_on_bit(&wreq->flags, NETFS_RREQ_IN_PROGRESS,
> - TASK_UNINTERRUPTIBLE);
> - ret = wreq->error;
> - }
> -
> - netfs_put_request(wreq, false, netfs_rreq_trace_put_return);
> - return ret;
> -}
>

--
Jeff Layton <jlayton@kernel.org>