Commit c2458685 authored by David Howells's avatar David Howells
Browse files

netfs: Remove the old writeback code 



Remove the old writeback code.

Signed-off-by: default avatarDavid 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
parent 2df86547

fs/9p/vfs_addr.c

+0 −34
Original line number Diff line number Diff line
@@ -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

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

fs/afs/write.c

+0 −40
Original line number Diff line number Diff line
@@ -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.

fs/netfs/buffered_write.c

+0 −629
Original line number Diff line number Diff line
@@ -573,632 +573,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

fs/netfs/output.c

deleted100644 → 0
+0 −477

File deleted.

Preview size limit exceeded, changes collapsed.