diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 325fbbce1eaa..b3ba102af60b 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -59,1890 +59,70 @@
  * accounting is preserved.
  */
 
-#define CONGESTION_ON_THRESH(congestion_kb) (congestion_kb >> (PAGE_SHIFT-10))
-#define CONGESTION_OFF_THRESH(congestion_kb)				\
-	(CONGESTION_ON_THRESH(congestion_kb) -				\
-	 (CONGESTION_ON_THRESH(congestion_kb) >> 2))
-
-#if 0 // TODO: Remove after netfs conversion
-static int ceph_netfs_check_write_begin(struct file *file, loff_t pos, unsigned int len,
-					struct folio **foliop, void **_fsdata);
-
-static struct ceph_snap_context *page_snap_context(struct page *page)
-{
-	if (PagePrivate(page))
-		return (void *)page->private;
-	return NULL;
-}
-#endif // TODO: Remove after netfs conversion
-
-/*
- * Dirty a page.  Optimistically adjust accounting, on the assumption
- * that we won't race with invalidate.  If we do, readjust.
- */
-bool ceph_dirty_folio(struct address_space *mapping, struct folio *folio)
-{
-	struct inode *inode = mapping->host;
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
-	struct ceph_inode_info *ci;
-	struct ceph_snap_context *snapc;
-	struct netfs_group *group;
-
-	if (folio_test_dirty(folio)) {
-		doutc(cl, "%llx.%llx %p idx %lu -- already dirty\n",
-		      ceph_vinop(inode), folio, folio->index);
-		VM_BUG_ON_FOLIO(!folio_test_private(folio), folio);
-		return false;
-	}
-
-	atomic64_inc(&mdsc->dirty_folios);
-
-	ci = ceph_inode(inode);
-
-	/* dirty the head */
-	spin_lock(&ci->i_ceph_lock);
-	if (__ceph_have_pending_cap_snap(ci)) {
-		struct ceph_cap_snap *capsnap =
-			list_last_entry(&ci->i_cap_snaps,
-					struct ceph_cap_snap,
-					ci_item);
-		snapc = capsnap->context;
-		capsnap->dirty_pages++;
-	} else {
-		snapc = ci->i_head_snapc;
-		BUG_ON(!snapc);
-		++ci->i_wrbuffer_ref_head;
-	}
-
-	/* Attach a reference to the snap/group to the folio. */
-	group = netfs_folio_group(folio);
-	if (group != &snapc->group) {
-		netfs_set_group(folio, &snapc->group);
-		if (group) {
-			doutc(cl, "Different group %px != %px\n",
-			      group, &snapc->group);
-			netfs_put_group(group);
-		}
-	}
-
-	if (ci->i_wrbuffer_ref == 0)
-		ihold(inode);
-	++ci->i_wrbuffer_ref;
-	doutc(cl, "%llx.%llx %p idx %lu head %d/%d -> %d/%d "
-	      "snapc %p seq %lld (%d snaps)\n",
-	      ceph_vinop(inode), folio, folio->index,
-	      ci->i_wrbuffer_ref-1, ci->i_wrbuffer_ref_head-1,
-	      ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head,
-	      snapc, snapc->seq, snapc->num_snaps);
-	spin_unlock(&ci->i_ceph_lock);
-
-	return netfs_dirty_folio(mapping, folio);
-}
-
-#if 0 // TODO: Remove after netfs conversion
-/*
- * If we are truncating the full folio (i.e. offset == 0), adjust the
- * dirty folio counters appropriately.  Only called if there is private
- * data on the folio.
- */
-static void ceph_invalidate_folio(struct folio *folio, size_t offset,
-				size_t length)
-{
-	struct inode *inode = folio->mapping->host;
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_snap_context *snapc;
-
-
-	if (offset != 0 || length != folio_size(folio)) {
-		doutc(cl, "%llx.%llx idx %lu partial dirty page %zu~%zu\n",
-		      ceph_vinop(inode), folio->index, offset, length);
-		return;
-	}
-
-	WARN_ON(!folio_test_locked(folio));
-	if (folio_test_private(folio)) {
-		doutc(cl, "%llx.%llx idx %lu full dirty page\n",
-		      ceph_vinop(inode), folio->index);
-
-		snapc = folio_detach_private(folio);
-		ceph_put_wrbuffer_cap_refs(ci, 1, snapc);
-		ceph_put_snap_context(snapc);
-	}
-
-	netfs_invalidate_folio(folio, offset, length);
-}
-
-static void ceph_netfs_expand_readahead(struct netfs_io_request *rreq)
-{
-	struct inode *inode = rreq->inode;
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_file_layout *lo = &ci->i_layout;
-	unsigned long max_pages = inode->i_sb->s_bdi->ra_pages;
-	loff_t end = rreq->start + rreq->len, new_end;
-	struct ceph_netfs_request_data *priv = rreq->netfs_priv;
-	unsigned long max_len;
-	u32 blockoff;
-
-	if (priv) {
-		/* Readahead is disabled by posix_fadvise POSIX_FADV_RANDOM */
-		if (priv->file_ra_disabled)
-			max_pages = 0;
-		else
-			max_pages = priv->file_ra_pages;
-
-	}
-
-	/* Readahead is disabled */
-	if (!max_pages)
-		return;
-
-	max_len = max_pages << PAGE_SHIFT;
-
-	/*
-	 * Try to expand the length forward by rounding up it to the next
-	 * block, but do not exceed the file size, unless the original
-	 * request already exceeds it.
-	 */
-	new_end = umin(round_up(end, lo->stripe_unit), rreq->i_size);
-	if (new_end > end && new_end <= rreq->start + max_len)
-		rreq->len = new_end - rreq->start;
-
-	/* Try to expand the start downward */
-	div_u64_rem(rreq->start, lo->stripe_unit, &blockoff);
-	if (rreq->len + blockoff <= max_len) {
-		rreq->start -= blockoff;
-		rreq->len += blockoff;
-	}
-}
-
-static void finish_netfs_read(struct ceph_osd_request *req)
-{
-	struct inode *inode = req->r_inode;
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_osd_data *osd_data = osd_req_op_extent_osd_data(req, 0);
-	struct netfs_io_subrequest *subreq = req->r_priv;
-	struct ceph_osd_req_op *op = &req->r_ops[0];
-	int err = req->r_result;
-	bool sparse = (op->op == CEPH_OSD_OP_SPARSE_READ);
-
-	ceph_update_read_metrics(&fsc->mdsc->metric, req->r_start_latency,
-				 req->r_end_latency, osd_data->length, err);
-
-	doutc(cl, "result %d subreq->len=%zu i_size=%lld\n", req->r_result,
-	      subreq->len, i_size_read(req->r_inode));
-
-	/* no object means success but no data */
-	if (err == -ENOENT) {
-		__set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
-		__set_bit(NETFS_SREQ_MADE_PROGRESS, &subreq->flags);
-		err = 0;
-	} else if (err == -EBLOCKLISTED) {
-		fsc->blocklisted = true;
-	}
-
-	if (err >= 0) {
-		if (sparse && err > 0)
-			err = ceph_sparse_ext_map_end(op);
-		if (err < subreq->len &&
-		    subreq->rreq->origin != NETFS_DIO_READ)
-			__set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
-		if (IS_ENCRYPTED(inode) && err > 0) {
-			err = ceph_fscrypt_decrypt_extents(inode,
-					osd_data->pages, subreq->start,
-					op->extent.sparse_ext,
-					op->extent.sparse_ext_cnt);
-			if (err > subreq->len)
-				err = subreq->len;
-		}
-		if (err > 0)
-			__set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
-	}
-
-	if (osd_data->type == CEPH_OSD_DATA_TYPE_PAGES) {
-		ceph_put_page_vector(osd_data->pages,
-				     calc_pages_for(osd_data->offset,
-					osd_data->length), false);
-	}
-	if (err > 0) {
-		subreq->transferred = err;
-		err = 0;
-	}
-	subreq->error = err;
-	trace_netfs_sreq(subreq, netfs_sreq_trace_io_progress);
-	netfs_read_subreq_terminated(subreq);
-	iput(req->r_inode);
-	ceph_dec_osd_stopping_blocker(fsc->mdsc);
-}
-
-static bool ceph_netfs_issue_op_inline(struct netfs_io_subrequest *subreq)
-{
-	struct netfs_io_request *rreq = subreq->rreq;
-	struct inode *inode = rreq->inode;
-	struct ceph_mds_reply_info_parsed *rinfo;
-	struct ceph_mds_reply_info_in *iinfo;
-	struct ceph_mds_request *req;
-	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	ssize_t err = 0;
-	size_t len;
-	int mode;
-
-	if (rreq->origin != NETFS_DIO_READ)
-		__set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
-	__clear_bit(NETFS_SREQ_COPY_TO_CACHE, &subreq->flags);
-
-	if (subreq->start >= inode->i_size)
-		goto out;
-
-	/* We need to fetch the inline data. */
-	mode = ceph_try_to_choose_auth_mds(inode, CEPH_STAT_CAP_INLINE_DATA);
-	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, mode);
-	if (IS_ERR(req)) {
-		err = PTR_ERR(req);
-		goto out;
-	}
-	req->r_ino1 = ci->i_vino;
-	req->r_args.getattr.mask = cpu_to_le32(CEPH_STAT_CAP_INLINE_DATA);
-	req->r_num_caps = 2;
-
-	trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
-	err = ceph_mdsc_do_request(mdsc, NULL, req);
-	if (err < 0)
-		goto out;
-
-	rinfo = &req->r_reply_info;
-	iinfo = &rinfo->targeti;
-	if (iinfo->inline_version == CEPH_INLINE_NONE) {
-		/* The data got uninlined */
-		ceph_mdsc_put_request(req);
-		return false;
-	}
-
-	len = min_t(size_t, iinfo->inline_len - subreq->start, subreq->len);
-	err = copy_to_iter(iinfo->inline_data + subreq->start, len, &subreq->io_iter);
-	if (err == 0) {
-		err = -EFAULT;
-	} else {
-		subreq->transferred += err;
-		err = 0;
-	}
-
-	ceph_mdsc_put_request(req);
-out:
-	subreq->error = err;
-	trace_netfs_sreq(subreq, netfs_sreq_trace_io_progress);
-	netfs_read_subreq_terminated(subreq);
-	return true;
-}
-
-static int ceph_netfs_prepare_read(struct netfs_io_subrequest *subreq)
-{
-	struct netfs_io_request *rreq = subreq->rreq;
-	struct inode *inode = rreq->inode;
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	size_t xlen;
-	u64 objno, objoff;
-
-	/* Truncate the extent at the end of the current block */
-	ceph_calc_file_object_mapping(&ci->i_layout, subreq->start, subreq->len,
-				      &objno, &objoff, &xlen);
-	rreq->io_streams[0].sreq_max_len = umin(xlen, fsc->mount_options->rsize);
-	return 0;
-}
-
-static void ceph_netfs_issue_read(struct netfs_io_subrequest *subreq)
-{
-	struct netfs_io_request *rreq = subreq->rreq;
-	struct inode *inode = rreq->inode;
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_osd_request *req = NULL;
-	struct ceph_vino vino = ceph_vino(inode);
-	int err;
-	u64 len;
-	bool sparse = IS_ENCRYPTED(inode) || ceph_test_mount_opt(fsc, SPARSEREAD);
-	u64 off = subreq->start;
-	int extent_cnt;
-
-	if (ceph_inode_is_shutdown(inode)) {
-		err = -EIO;
-		goto out;
-	}
-
-	if (ceph_has_inline_data(ci) && ceph_netfs_issue_op_inline(subreq))
-		return;
-
-	// TODO: This rounding here is slightly dodgy.  It *should* work, for
-	// now, as the cache only deals in blocks that are a multiple of
-	// PAGE_SIZE and fscrypt blocks are at most PAGE_SIZE.  What needs to
-	// happen is for the fscrypt driving to be moved into netfslib and the
-	// data in the cache also to be stored encrypted.
-	len = subreq->len;
-	ceph_fscrypt_adjust_off_and_len(inode, &off, &len);
-
-	req = ceph_osdc_new_request(&fsc->client->osdc, &ci->i_layout, vino,
-			off, &len, 0, 1, sparse ? CEPH_OSD_OP_SPARSE_READ : CEPH_OSD_OP_READ,
-			CEPH_OSD_FLAG_READ, NULL, ci->i_truncate_seq,
-			ci->i_truncate_size, false);
-	if (IS_ERR(req)) {
-		err = PTR_ERR(req);
-		req = NULL;
-		goto out;
-	}
-
-	if (sparse) {
-		extent_cnt = __ceph_sparse_read_ext_count(inode, len);
-		err = ceph_alloc_sparse_ext_map(&req->r_ops[0], extent_cnt);
-		if (err)
-			goto out;
-	}
-
-	doutc(cl, "%llx.%llx pos=%llu orig_len=%zu len=%llu\n",
-	      ceph_vinop(inode), subreq->start, subreq->len, len);
-
-	/*
-	 * FIXME: For now, use CEPH_OSD_DATA_TYPE_PAGES instead of _ITER for
-	 * encrypted inodes. We'd need infrastructure that handles an iov_iter
-	 * instead of page arrays, and we don't have that as of yet. Once the
-	 * dust settles on the write helpers and encrypt/decrypt routines for
-	 * netfs, we should be able to rework this.
-	 */
-	if (IS_ENCRYPTED(inode)) {
-		struct page **pages;
-		size_t page_off;
-
-		/*
-		 * The io_iter.count needs to be corrected to aligned length.
-		 * Otherwise, iov_iter_get_pages_alloc2() operates with
-		 * the initial unaligned length value. As a result,
-		 * ceph_msg_data_cursor_init() triggers BUG_ON() in the case
-		 * if msg->sparse_read_total > msg->data_length.
-		 */
-		subreq->io_iter.count = len;
-
-		err = iov_iter_get_pages_alloc2(&subreq->io_iter, &pages, len, &page_off);
-		if (err < 0) {
-			doutc(cl, "%llx.%llx failed to allocate pages, %d\n",
-			      ceph_vinop(inode), err);
-			goto out;
-		}
-
-		/* should always give us a page-aligned read */
-		WARN_ON_ONCE(page_off);
-
-		len = err;
-		err = 0;
-
-		osd_req_op_extent_osd_data_pages(req, 0, pages, len, 0, false,
-						 false);
-	} else {
-		osd_req_op_extent_osd_iter(req, 0, &subreq->io_iter);
-	}
-	if (!ceph_inc_osd_stopping_blocker(fsc->mdsc)) {
-		err = -EIO;
-		goto out;
-	}
-	req->r_callback = finish_netfs_read;
-	req->r_priv = subreq;
-	req->r_inode = inode;
-	ihold(inode);
-
-	trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
-	ceph_osdc_start_request(req->r_osdc, req);
-out:
-	ceph_osdc_put_request(req);
-	if (err) {
-		subreq->error = err;
-		netfs_read_subreq_terminated(subreq);
-	}
-	doutc(cl, "%llx.%llx result %d\n", ceph_vinop(inode), err);
-}
-
-static int ceph_init_request(struct netfs_io_request *rreq, struct file *file)
-{
-	struct inode *inode = rreq->inode;
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-	int got = 0, want = CEPH_CAP_FILE_CACHE;
-	struct ceph_netfs_request_data *priv;
-	int ret = 0;
-
-	/* [DEPRECATED] Use PG_private_2 to mark folio being written to the cache. */
-	__set_bit(NETFS_RREQ_USE_PGPRIV2, &rreq->flags);
-
-	if (rreq->origin != NETFS_READAHEAD)
-		return 0;
-
-	priv = kzalloc(sizeof(*priv), GFP_NOFS);
-	if (!priv)
-		return -ENOMEM;
-
-	/*
-	 * If we are doing readahead triggered by a read, fault-in or
-	 * MADV/FADV_WILLNEED, someone higher up the stack must be holding the
-	 * FILE_CACHE and/or LAZYIO caps.
-	 */
-	if (file) {
-		priv->file_ra_pages = file->f_ra.ra_pages;
-		priv->file_ra_disabled = file->f_mode & FMODE_RANDOM;
-		rreq->netfs_priv = priv;
-		return 0;
-	}
-
-	/*
-	 * readahead callers do not necessarily hold Fcb caps
-	 * (e.g. fadvise, madvise).
-	 */
-	ret = ceph_try_get_caps(inode, CEPH_CAP_FILE_RD, want, true, &got);
-	if (ret < 0) {
-		doutc(cl, "%llx.%llx, error getting cap\n", ceph_vinop(inode));
-		goto out;
-	}
-
-	if (!(got & want)) {
-		doutc(cl, "%llx.%llx, no cache cap\n", ceph_vinop(inode));
-		ret = -EACCES;
-		goto out;
-	}
-	if (ret == 0) {
-		ret = -EACCES;
-		goto out;
-	}
-
-	priv->caps = got;
-	rreq->netfs_priv = priv;
-	rreq->io_streams[0].sreq_max_len = fsc->mount_options->rsize;
-
-out:
-	if (ret < 0) {
-		if (got)
-			ceph_put_cap_refs(ceph_inode(inode), got);
-		kfree(priv);
-	}
-
-	return ret;
-}
-
-static void ceph_netfs_free_request(struct netfs_io_request *rreq)
-{
-	struct ceph_netfs_request_data *priv = rreq->netfs_priv;
-
-	if (!priv)
-		return;
-
-	if (priv->caps)
-		ceph_put_cap_refs(ceph_inode(rreq->inode), priv->caps);
-	kfree(priv);
-	rreq->netfs_priv = NULL;
-}
-
-const struct netfs_request_ops ceph_netfs_ops = {
-	.init_request		= ceph_init_request,
-	.free_request		= ceph_netfs_free_request,
-	.prepare_read		= ceph_netfs_prepare_read,
-	.issue_read		= ceph_netfs_issue_read,
-	.expand_readahead	= ceph_netfs_expand_readahead,
-	.check_write_begin	= ceph_netfs_check_write_begin,
-};
-
-#ifdef CONFIG_CEPH_FSCACHE
-static void ceph_set_page_fscache(struct page *page)
-{
-	folio_start_private_2(page_folio(page)); /* [DEPRECATED] */
-}
-
-static void ceph_fscache_write_terminated(void *priv, ssize_t error, bool was_async)
-{
-	struct inode *inode = priv;
-
-	if (IS_ERR_VALUE(error) && error != -ENOBUFS)
-		ceph_fscache_invalidate(inode, false);
-}
-
-static void ceph_fscache_write_to_cache(struct inode *inode, u64 off, u64 len, bool caching)
-{
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct fscache_cookie *cookie = ceph_fscache_cookie(ci);
-
-	fscache_write_to_cache(cookie, inode->i_mapping, off, len, i_size_read(inode),
-			       ceph_fscache_write_terminated, inode, true, caching);
-}
-#else
-static inline void ceph_set_page_fscache(struct page *page)
-{
-}
-
-static inline void ceph_fscache_write_to_cache(struct inode *inode, u64 off, u64 len, bool caching)
-{
-}
-#endif /* CONFIG_CEPH_FSCACHE */
-
-struct ceph_writeback_ctl
-{
-	loff_t i_size;
-	u64 truncate_size;
-	u32 truncate_seq;
-	bool size_stable;
-
-	bool head_snapc;
-	struct ceph_snap_context *snapc;
-	struct ceph_snap_context *last_snapc;
-
-	bool done;
-	bool should_loop;
-	bool range_whole;
-	pgoff_t start_index;
-	pgoff_t index;
-	pgoff_t end;
-	xa_mark_t tag;
-
-	pgoff_t strip_unit_end;
-	unsigned int wsize;
-	unsigned int nr_folios;
-	unsigned int max_pages;
-	unsigned int locked_pages;
-
-	int op_idx;
-	int num_ops;
-	u64 offset;
-	u64 len;
-
-	struct folio_batch fbatch;
-	unsigned int processed_in_fbatch;
-
-	bool from_pool;
-	struct page **pages;
-	struct page **data_pages;
-};
-
-/*
- * Get ref for the oldest snapc for an inode with dirty data... that is, the
- * only snap context we are allowed to write back.
- */
-static struct ceph_snap_context *
-get_oldest_context(struct inode *inode, struct ceph_writeback_ctl *ctl,
-		   struct ceph_snap_context *page_snapc)
-{
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-	struct ceph_snap_context *snapc = NULL;
-	struct ceph_cap_snap *capsnap = NULL;
-
-	spin_lock(&ci->i_ceph_lock);
-	list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
-		doutc(cl, " capsnap %p snapc %p has %d dirty pages\n",
-		      capsnap, capsnap->context, capsnap->dirty_pages);
-		if (!capsnap->dirty_pages)
-			continue;
-
-		/* get i_size, truncate_{seq,size} for page_snapc? */
-		if (snapc && capsnap->context != page_snapc)
-			continue;
-
-		if (ctl) {
-			if (capsnap->writing) {
-				ctl->i_size = i_size_read(inode);
-				ctl->size_stable = false;
-			} else {
-				ctl->i_size = capsnap->size;
-				ctl->size_stable = true;
-			}
-			ctl->truncate_size = capsnap->truncate_size;
-			ctl->truncate_seq = capsnap->truncate_seq;
-			ctl->head_snapc = false;
-		}
-
-		if (snapc)
-			break;
-
-		snapc = ceph_get_snap_context(capsnap->context);
-		if (!page_snapc ||
-		    page_snapc == snapc ||
-		    page_snapc->seq > snapc->seq)
-			break;
-	}
-	if (!snapc && ci->i_wrbuffer_ref_head) {
-		snapc = ceph_get_snap_context(ci->i_head_snapc);
-		doutc(cl, " head snapc %p has %d dirty pages\n", snapc,
-		      ci->i_wrbuffer_ref_head);
-		if (ctl) {
-			ctl->i_size = i_size_read(inode);
-			ctl->truncate_size = ci->i_truncate_size;
-			ctl->truncate_seq = ci->i_truncate_seq;
-			ctl->size_stable = false;
-			ctl->head_snapc = true;
-		}
-	}
-	spin_unlock(&ci->i_ceph_lock);
-	return snapc;
-}
-
-static u64 get_writepages_data_length(struct inode *inode,
-				      struct page *page, u64 start)
-{
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_snap_context *snapc;
-	struct ceph_cap_snap *capsnap = NULL;
-	u64 end = i_size_read(inode);
-	u64 ret;
-
-	snapc = page_snap_context(ceph_fscrypt_pagecache_page(page));
-	if (snapc != ci->i_head_snapc) {
-		bool found = false;
-		spin_lock(&ci->i_ceph_lock);
-		list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
-			if (capsnap->context == snapc) {
-				if (!capsnap->writing)
-					end = capsnap->size;
-				found = true;
-				break;
-			}
-		}
-		spin_unlock(&ci->i_ceph_lock);
-		WARN_ON(!found);
-	}
-	if (end > ceph_fscrypt_page_offset(page) + thp_size(page))
-		end = ceph_fscrypt_page_offset(page) + thp_size(page);
-	ret = end > start ? end - start : 0;
-	if (ret && fscrypt_is_bounce_page(page))
-		ret = round_up(ret, CEPH_FSCRYPT_BLOCK_SIZE);
-	return ret;
-}
-
-/*
- * Write a folio, but leave it locked.
- *
- * If we get a write error, mark the mapping for error, but still adjust the
- * dirty page accounting (i.e., folio is no longer dirty).
- */
-static int write_folio_nounlock(struct folio *folio,
-		struct writeback_control *wbc)
-{
-	struct page *page = &folio->page;
-	struct inode *inode = folio->mapping->host;
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_snap_context *snapc, *oldest;
-	loff_t page_off = folio_pos(folio);
-	int err;
-	loff_t len = folio_size(folio);
-	loff_t wlen;
-	struct ceph_writeback_ctl ceph_wbc;
-	struct ceph_osd_client *osdc = &fsc->client->osdc;
-	struct ceph_osd_request *req;
-	bool caching = ceph_is_cache_enabled(inode);
-	struct page *bounce_page = NULL;
-
-	doutc(cl, "%llx.%llx folio %p idx %lu\n", ceph_vinop(inode), folio,
-	      folio->index);
-
-	if (ceph_inode_is_shutdown(inode))
-		return -EIO;
-
-	/* verify this is a writeable snap context */
-	snapc = page_snap_context(&folio->page);
-	if (!snapc) {
-		doutc(cl, "%llx.%llx folio %p not dirty?\n", ceph_vinop(inode),
-		      folio);
-		return 0;
-	}
-	oldest = get_oldest_context(inode, &ceph_wbc, snapc);
-	if (snapc->seq > oldest->seq) {
-		doutc(cl, "%llx.%llx folio %p snapc %p not writeable - noop\n",
-		      ceph_vinop(inode), folio, snapc);
-		/* we should only noop if called by kswapd */
-		WARN_ON(!(current->flags & PF_MEMALLOC));
-		ceph_put_snap_context(oldest);
-		folio_redirty_for_writepage(wbc, folio);
-		return 0;
-	}
-	ceph_put_snap_context(oldest);
-
-	/* is this a partial page at end of file? */
-	if (page_off >= ceph_wbc.i_size) {
-		doutc(cl, "%llx.%llx folio at %lu beyond eof %llu\n",
-		      ceph_vinop(inode), folio->index, ceph_wbc.i_size);
-		folio_invalidate(folio, 0, folio_size(folio));
-		return 0;
-	}
-
-	if (ceph_wbc.i_size < page_off + len)
-		len = ceph_wbc.i_size - page_off;
-
-	wlen = IS_ENCRYPTED(inode) ? round_up(len, CEPH_FSCRYPT_BLOCK_SIZE) : len;
-	doutc(cl, "%llx.%llx folio %p index %lu on %llu~%llu snapc %p seq %lld\n",
-	      ceph_vinop(inode), folio, folio->index, page_off, wlen, snapc,
-	      snapc->seq);
-
-	if (atomic_long_inc_return(&fsc->writeback_count) >
-	    CONGESTION_ON_THRESH(fsc->mount_options->congestion_kb))
-		fsc->write_congested = true;
-
-	req = ceph_osdc_new_request(osdc, &ci->i_layout, ceph_vino(inode),
-				    page_off, &wlen, 0, 1, CEPH_OSD_OP_WRITE,
-				    CEPH_OSD_FLAG_WRITE, snapc,
-				    ceph_wbc.truncate_seq,
-				    ceph_wbc.truncate_size, true);
-	if (IS_ERR(req)) {
-		folio_redirty_for_writepage(wbc, folio);
-		return PTR_ERR(req);
-	}
-
-	if (wlen < len)
-		len = wlen;
-
-	folio_start_writeback(folio);
-	if (caching)
-		ceph_set_page_fscache(&folio->page);
-	ceph_fscache_write_to_cache(inode, page_off, len, caching);
-
-	if (IS_ENCRYPTED(inode)) {
-		bounce_page = fscrypt_encrypt_pagecache_blocks(&folio->page,
-						    CEPH_FSCRYPT_BLOCK_SIZE, 0,
-						    GFP_NOFS);
-		if (IS_ERR(bounce_page)) {
-			folio_redirty_for_writepage(wbc, folio);
-			folio_end_writeback(folio);
-			ceph_osdc_put_request(req);
-			return PTR_ERR(bounce_page);
-		}
-	}
-
-	/* it may be a short write due to an object boundary */
-	WARN_ON_ONCE(len > folio_size(folio));
-	osd_req_op_extent_osd_data_pages(req, 0,
-			bounce_page ? &bounce_page : &page, wlen, 0,
-			false, false);
-	doutc(cl, "%llx.%llx %llu~%llu (%llu bytes, %sencrypted)\n",
-	      ceph_vinop(inode), page_off, len, wlen,
-	      IS_ENCRYPTED(inode) ? "" : "not ");
-
-	req->r_mtime = inode_get_mtime(inode);
-	ceph_osdc_start_request(osdc, req);
-	err = ceph_osdc_wait_request(osdc, req);
-
-	ceph_update_write_metrics(&fsc->mdsc->metric, req->r_start_latency,
-				  req->r_end_latency, len, err);
-	fscrypt_free_bounce_page(bounce_page);
-	ceph_osdc_put_request(req);
-	if (err == 0)
-		err = len;
-
-	if (err < 0) {
-		struct writeback_control tmp_wbc;
-		if (!wbc)
-			wbc = &tmp_wbc;
-		if (err == -ERESTARTSYS) {
-			/* killed by SIGKILL */
-			doutc(cl, "%llx.%llx interrupted page %p\n",
-			      ceph_vinop(inode), folio);
-			folio_redirty_for_writepage(wbc, folio);
-			folio_end_writeback(folio);
-			return err;
-		}
-		if (err == -EBLOCKLISTED)
-			fsc->blocklisted = true;
-		doutc(cl, "%llx.%llx setting mapping error %d %p\n",
-		      ceph_vinop(inode), err, folio);
-		mapping_set_error(&inode->i_data, err);
-		wbc->pages_skipped++;
-	} else {
-		doutc(cl, "%llx.%llx cleaned page %p\n",
-		      ceph_vinop(inode), folio);
-		err = 0;  /* vfs expects us to return 0 */
-	}
-	oldest = folio_detach_private(folio);
-	WARN_ON_ONCE(oldest != snapc);
-	folio_end_writeback(folio);
-	ceph_put_wrbuffer_cap_refs(ci, 1, snapc);
-	ceph_put_snap_context(snapc);  /* page's reference */
-
-	if (atomic_long_dec_return(&fsc->writeback_count) <
-	    CONGESTION_OFF_THRESH(fsc->mount_options->congestion_kb))
-		fsc->write_congested = false;
-
-	return err;
-}
-
-/*
- * async writeback completion handler.
- *
- * If we get an error, set the mapping error bit, but not the individual
- * page error bits.
- */
-static void writepages_finish(struct ceph_osd_request *req)
-{
-	struct inode *inode = req->r_inode;
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-	struct ceph_osd_data *osd_data;
-	struct page *page;
-	int num_pages, total_pages = 0;
-	int i, j;
-	int rc = req->r_result;
-	struct ceph_snap_context *snapc = req->r_snapc;
-	struct address_space *mapping = inode->i_mapping;
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
-	unsigned int len = 0;
-	bool remove_page;
-
-	doutc(cl, "%llx.%llx rc %d\n", ceph_vinop(inode), rc);
-	if (rc < 0) {
-		mapping_set_error(mapping, rc);
-		ceph_set_error_write(ci);
-		if (rc == -EBLOCKLISTED)
-			fsc->blocklisted = true;
-	} else {
-		ceph_clear_error_write(ci);
-	}
-
-	/*
-	 * We lost the cache cap, need to truncate the page before
-	 * it is unlocked, otherwise we'd truncate it later in the
-	 * page truncation thread, possibly losing some data that
-	 * raced its way in
-	 */
-	remove_page = !(ceph_caps_issued(ci) &
-			(CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO));
-
-	/* clean all pages */
-	for (i = 0; i < req->r_num_ops; i++) {
-		if (req->r_ops[i].op != CEPH_OSD_OP_WRITE) {
-			pr_warn_client(cl,
-				"%llx.%llx incorrect op %d req %p index %d tid %llu\n",
-				ceph_vinop(inode), req->r_ops[i].op, req, i,
-				req->r_tid);
-			break;
-		}
-
-		osd_data = osd_req_op_extent_osd_data(req, i);
-		BUG_ON(osd_data->type != CEPH_OSD_DATA_TYPE_PAGES);
-		len += osd_data->length;
-		num_pages = calc_pages_for((u64)osd_data->offset,
-					   (u64)osd_data->length);
-		total_pages += num_pages;
-		for (j = 0; j < num_pages; j++) {
-			page = osd_data->pages[j];
-			if (fscrypt_is_bounce_page(page)) {
-				page = fscrypt_pagecache_page(page);
-				fscrypt_free_bounce_page(osd_data->pages[j]);
-				osd_data->pages[j] = page;
-			}
-			BUG_ON(!page);
-			WARN_ON(!PageUptodate(page));
-
-			if (atomic_long_dec_return(&fsc->writeback_count) <
-			     CONGESTION_OFF_THRESH(
-					fsc->mount_options->congestion_kb))
-				fsc->write_congested = false;
-
-			ceph_put_snap_context(detach_page_private(page));
-			end_page_writeback(page);
-
-			if (atomic64_dec_return(&mdsc->dirty_folios) <= 0) {
-				wake_up_all(&mdsc->flush_end_wq);
-				WARN_ON(atomic64_read(&mdsc->dirty_folios) < 0);
-			}
-
-			doutc(cl, "unlocking %p\n", page);
-
-			if (remove_page)
-				generic_error_remove_folio(inode->i_mapping,
-							  page_folio(page));
-
-			unlock_page(page);
-		}
-		doutc(cl, "%llx.%llx wrote %llu bytes cleaned %d pages\n",
-		      ceph_vinop(inode), osd_data->length,
-		      rc >= 0 ? num_pages : 0);
-
-		release_pages(osd_data->pages, num_pages);
-	}
-
-	ceph_update_write_metrics(&fsc->mdsc->metric, req->r_start_latency,
-				  req->r_end_latency, len, rc);
-
-	ceph_put_wrbuffer_cap_refs(ci, total_pages, snapc);
-
-	osd_data = osd_req_op_extent_osd_data(req, 0);
-	if (osd_data->pages_from_pool)
-		mempool_free(osd_data->pages, ceph_wb_pagevec_pool);
-	else
-		kfree(osd_data->pages);
-	ceph_osdc_put_request(req);
-	ceph_dec_osd_stopping_blocker(fsc->mdsc);
-}
-
-static inline
-bool is_forced_umount(struct address_space *mapping)
-{
-	struct inode *inode = mapping->host;
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-
-	if (ceph_inode_is_shutdown(inode)) {
-		if (ci->i_wrbuffer_ref > 0) {
-			pr_warn_ratelimited_client(cl,
-				"%llx.%llx %lld forced umount\n",
-				ceph_vinop(inode), ceph_ino(inode));
-		}
-		mapping_set_error(mapping, -EIO);
-		return true;
-	}
-
-	return false;
-}
-
-static inline
-unsigned int ceph_define_write_size(struct address_space *mapping)
-{
-	struct inode *inode = mapping->host;
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	unsigned int wsize = i_blocksize(inode);
-
-	if (fsc->mount_options->wsize < wsize)
-		wsize = fsc->mount_options->wsize;
-
-	return wsize;
-}
-
-static inline
-void ceph_folio_batch_init(struct ceph_writeback_ctl *ceph_wbc)
-{
-	folio_batch_init(&ceph_wbc->fbatch);
-	ceph_wbc->processed_in_fbatch = 0;
-}
-
-static inline
-void ceph_folio_batch_reinit(struct ceph_writeback_ctl *ceph_wbc)
-{
-	folio_batch_release(&ceph_wbc->fbatch);
-	ceph_folio_batch_init(ceph_wbc);
-}
-
-static inline
-void ceph_init_writeback_ctl(struct address_space *mapping,
-			     struct writeback_control *wbc,
-			     struct ceph_writeback_ctl *ceph_wbc)
-{
-	ceph_wbc->snapc = NULL;
-	ceph_wbc->last_snapc = NULL;
-
-	ceph_wbc->strip_unit_end = 0;
-	ceph_wbc->wsize = ceph_define_write_size(mapping);
-
-	ceph_wbc->nr_folios = 0;
-	ceph_wbc->max_pages = 0;
-	ceph_wbc->locked_pages = 0;
-
-	ceph_wbc->done = false;
-	ceph_wbc->should_loop = false;
-	ceph_wbc->range_whole = false;
-
-	ceph_wbc->start_index = wbc->range_cyclic ? mapping->writeback_index : 0;
-	ceph_wbc->index = ceph_wbc->start_index;
-	ceph_wbc->end = -1;
-
-	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages) {
-		ceph_wbc->tag = PAGECACHE_TAG_TOWRITE;
-	} else {
-		ceph_wbc->tag = PAGECACHE_TAG_DIRTY;
-	}
-
-	ceph_wbc->op_idx = -1;
-	ceph_wbc->num_ops = 0;
-	ceph_wbc->offset = 0;
-	ceph_wbc->len = 0;
-	ceph_wbc->from_pool = false;
-
-	ceph_folio_batch_init(ceph_wbc);
-
-	ceph_wbc->pages = NULL;
-	ceph_wbc->data_pages = NULL;
-}
-
-static inline
-int ceph_define_writeback_range(struct address_space *mapping,
-				struct writeback_control *wbc,
-				struct ceph_writeback_ctl *ceph_wbc)
-{
-	struct inode *inode = mapping->host;
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-
-	/* find oldest snap context with dirty data */
-	ceph_wbc->snapc = get_oldest_context(inode, ceph_wbc, NULL);
-	if (!ceph_wbc->snapc) {
-		/* hmm, why does writepages get called when there
-		   is no dirty data? */
-		doutc(cl, " no snap context with dirty data?\n");
-		return -ENODATA;
-	}
-
-	doutc(cl, " oldest snapc is %p seq %lld (%d snaps)\n",
-	      ceph_wbc->snapc, ceph_wbc->snapc->seq,
-	      ceph_wbc->snapc->num_snaps);
-
-	ceph_wbc->should_loop = false;
-
-	if (ceph_wbc->head_snapc && ceph_wbc->snapc != ceph_wbc->last_snapc) {
-		/* where to start/end? */
-		if (wbc->range_cyclic) {
-			ceph_wbc->index = ceph_wbc->start_index;
-			ceph_wbc->end = -1;
-			if (ceph_wbc->index > 0)
-				ceph_wbc->should_loop = true;
-			doutc(cl, " cyclic, start at %lu\n", ceph_wbc->index);
-		} else {
-			ceph_wbc->index = wbc->range_start >> PAGE_SHIFT;
-			ceph_wbc->end = wbc->range_end >> PAGE_SHIFT;
-			if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
-				ceph_wbc->range_whole = true;
-			doutc(cl, " not cyclic, %lu to %lu\n",
-				ceph_wbc->index, ceph_wbc->end);
-		}
-	} else if (!ceph_wbc->head_snapc) {
-		/* Do not respect wbc->range_{start,end}. Dirty pages
-		 * in that range can be associated with newer snapc.
-		 * They are not writeable until we write all dirty pages
-		 * associated with 'snapc' get written */
-		if (ceph_wbc->index > 0)
-			ceph_wbc->should_loop = true;
-		doutc(cl, " non-head snapc, range whole\n");
-	}
-
-	ceph_put_snap_context(ceph_wbc->last_snapc);
-	ceph_wbc->last_snapc = ceph_wbc->snapc;
-
-	return 0;
-}
-
-static inline
-bool has_writeback_done(struct ceph_writeback_ctl *ceph_wbc)
-{
-	return ceph_wbc->done && ceph_wbc->index > ceph_wbc->end;
-}
-
-static inline
-bool can_next_page_be_processed(struct ceph_writeback_ctl *ceph_wbc,
-				unsigned index)
-{
-	return index < ceph_wbc->nr_folios &&
-		ceph_wbc->locked_pages < ceph_wbc->max_pages;
-}
-
-static
-int ceph_check_page_before_write(struct address_space *mapping,
-				 struct writeback_control *wbc,
-				 struct ceph_writeback_ctl *ceph_wbc,
-				 struct folio *folio)
-{
-	struct inode *inode = mapping->host;
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_snap_context *pgsnapc;
-
-	/* only dirty folios, or our accounting breaks */
-	if (unlikely(!folio_test_dirty(folio) || folio->mapping != mapping)) {
-		doutc(cl, "!dirty or !mapping %p\n", folio);
-		return -ENODATA;
-	}
-
-	/* only if matching snap context */
-	pgsnapc = page_snap_context(&folio->page);
-	if (pgsnapc != ceph_wbc->snapc) {
-		doutc(cl, "folio snapc %p %lld != oldest %p %lld\n",
-		      pgsnapc, pgsnapc->seq,
-		      ceph_wbc->snapc, ceph_wbc->snapc->seq);
-
-		if (!ceph_wbc->should_loop && !ceph_wbc->head_snapc &&
-		    wbc->sync_mode != WB_SYNC_NONE)
-			ceph_wbc->should_loop = true;
-
-		return -ENODATA;
-	}
-
-	if (folio_pos(folio) >= ceph_wbc->i_size) {
-		doutc(cl, "folio at %lu beyond eof %llu\n",
-		      folio->index, ceph_wbc->i_size);
-
-		if ((ceph_wbc->size_stable ||
-		    folio_pos(folio) >= i_size_read(inode)) &&
-		    folio_clear_dirty_for_io(folio))
-			folio_invalidate(folio, 0, folio_size(folio));
-
-		return -ENODATA;
-	}
-
-	if (ceph_wbc->strip_unit_end &&
-	    (folio->index > ceph_wbc->strip_unit_end)) {
-		doutc(cl, "end of strip unit %p\n", folio);
-		return -E2BIG;
-	}
-
-	return 0;
-}
-
-static inline
-void __ceph_allocate_page_array(struct ceph_writeback_ctl *ceph_wbc,
-				unsigned int max_pages)
-{
-	ceph_wbc->pages = kmalloc_array(max_pages,
-					sizeof(*ceph_wbc->pages),
-					GFP_NOFS);
-	if (!ceph_wbc->pages) {
-		ceph_wbc->from_pool = true;
-		ceph_wbc->pages = mempool_alloc(ceph_wb_pagevec_pool, GFP_NOFS);
-		BUG_ON(!ceph_wbc->pages);
-	}
-}
-
-static inline
-void ceph_allocate_page_array(struct address_space *mapping,
-			      struct ceph_writeback_ctl *ceph_wbc,
-			      struct folio *folio)
-{
-	struct inode *inode = mapping->host;
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	size_t xlen;
-	u64 objnum;
-	u64 objoff;
-
-	/* prepare async write request */
-	ceph_wbc->offset = (u64)folio_pos(folio);
-	ceph_calc_file_object_mapping(&ci->i_layout,
-					ceph_wbc->offset, ceph_wbc->wsize,
-					&objnum, &objoff, &xlen);
-
-	ceph_wbc->num_ops = 1;
-	ceph_wbc->strip_unit_end = folio->index + ((xlen - 1) >> PAGE_SHIFT);
-
-	BUG_ON(ceph_wbc->pages);
-	ceph_wbc->max_pages = calc_pages_for(0, (u64)xlen);
-	__ceph_allocate_page_array(ceph_wbc, ceph_wbc->max_pages);
-
-	ceph_wbc->len = 0;
-}
-
-static inline
-bool is_folio_index_contiguous(const struct ceph_writeback_ctl *ceph_wbc,
-			      const struct folio *folio)
-{
-	return folio->index == (ceph_wbc->offset + ceph_wbc->len) >> PAGE_SHIFT;
-}
-
-static inline
-bool is_num_ops_too_big(struct ceph_writeback_ctl *ceph_wbc)
-{
-	return ceph_wbc->num_ops >=
-		(ceph_wbc->from_pool ?  CEPH_OSD_SLAB_OPS : CEPH_OSD_MAX_OPS);
-}
-#endif // TODO: Remove after netfs conversion
-
-static inline
-bool is_write_congestion_happened(struct ceph_fs_client *fsc)
-{
-	return atomic_long_inc_return(&fsc->writeback_count) >
-		CONGESTION_ON_THRESH(fsc->mount_options->congestion_kb);
-}
-
-#if 0 // TODO: Remove after netfs conversion
-static inline int move_dirty_folio_in_page_array(struct address_space *mapping,
-		struct writeback_control *wbc,
-		struct ceph_writeback_ctl *ceph_wbc, struct folio *folio)
-{
-	struct inode *inode = mapping->host;
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct page **pages = ceph_wbc->pages;
-	unsigned int index = ceph_wbc->locked_pages;
-	gfp_t gfp_flags = ceph_wbc->locked_pages ? GFP_NOWAIT : GFP_NOFS;
-
-	if (IS_ENCRYPTED(inode)) {
-		pages[index] = fscrypt_encrypt_pagecache_blocks(&folio->page,
-								PAGE_SIZE,
-								0,
-								gfp_flags);
-		if (IS_ERR(pages[index])) {
-			if (PTR_ERR(pages[index]) == -EINVAL) {
-				pr_err_client(cl, "inode->i_blkbits=%hhu\n",
-						inode->i_blkbits);
-			}
-
-			/* better not fail on first page! */
-			BUG_ON(ceph_wbc->locked_pages == 0);
-
-			pages[index] = NULL;
-			return PTR_ERR(pages[index]);
-		}
-	} else {
-		pages[index] = &folio->page;
-	}
-
-	ceph_wbc->locked_pages++;
-
-	return 0;
-}
-
-static
-int ceph_process_folio_batch(struct address_space *mapping,
-			     struct writeback_control *wbc,
-			     struct ceph_writeback_ctl *ceph_wbc)
-{
-	struct inode *inode = mapping->host;
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct folio *folio = NULL;
-	unsigned i;
-	int rc = 0;
-
-	for (i = 0; can_next_page_be_processed(ceph_wbc, i); i++) {
-		folio = ceph_wbc->fbatch.folios[i];
-
-		if (!folio)
-			continue;
-
-		doutc(cl, "? %p idx %lu, folio_test_writeback %#x, "
-			"folio_test_dirty %#x, folio_test_locked %#x\n",
-			folio, folio->index, folio_test_writeback(folio),
-			folio_test_dirty(folio),
-			folio_test_locked(folio));
-
-		if (folio_test_writeback(folio) ||
-		    folio_test_private_2(folio) /* [DEPRECATED] */) {
-			doutc(cl, "waiting on writeback %p\n", folio);
-			folio_wait_writeback(folio);
-			folio_wait_private_2(folio); /* [DEPRECATED] */
-			continue;
-		}
-
-		if (ceph_wbc->locked_pages == 0)
-			folio_lock(folio);
-		else if (!folio_trylock(folio))
-			break;
-
-		rc = ceph_check_page_before_write(mapping, wbc,
-						  ceph_wbc, folio);
-		if (rc == -ENODATA) {
-			rc = 0;
-			folio_unlock(folio);
-			ceph_wbc->fbatch.folios[i] = NULL;
-			continue;
-		} else if (rc == -E2BIG) {
-			rc = 0;
-			folio_unlock(folio);
-			ceph_wbc->fbatch.folios[i] = NULL;
-			break;
-		}
-
-		if (!folio_clear_dirty_for_io(folio)) {
-			doutc(cl, "%p !folio_clear_dirty_for_io\n", folio);
-			folio_unlock(folio);
-			ceph_wbc->fbatch.folios[i] = NULL;
-			continue;
-		}
-
-		/*
-		 * We have something to write.  If this is
-		 * the first locked page this time through,
-		 * calculate max possible write size and
-		 * allocate a page array
-		 */
-		if (ceph_wbc->locked_pages == 0) {
-			ceph_allocate_page_array(mapping, ceph_wbc, folio);
-		} else if (!is_folio_index_contiguous(ceph_wbc, folio)) {
-			if (is_num_ops_too_big(ceph_wbc)) {
-				folio_redirty_for_writepage(wbc, folio);
-				folio_unlock(folio);
-				break;
-			}
-
-			ceph_wbc->num_ops++;
-			ceph_wbc->offset = (u64)folio_pos(folio);
-			ceph_wbc->len = 0;
-		}
-
-		/* note position of first page in fbatch */
-		doutc(cl, "%llx.%llx will write folio %p idx %lu\n",
-		      ceph_vinop(inode), folio, folio->index);
-
-		fsc->write_congested = is_write_congestion_happened(fsc);
-
-		rc = move_dirty_folio_in_page_array(mapping, wbc, ceph_wbc,
-				folio);
-		if (rc) {
-			folio_redirty_for_writepage(wbc, folio);
-			folio_unlock(folio);
-			break;
-		}
-
-		ceph_wbc->fbatch.folios[i] = NULL;
-		ceph_wbc->len += folio_size(folio);
-	}
-
-	ceph_wbc->processed_in_fbatch = i;
-
-	return rc;
-}
-
-static inline
-void ceph_shift_unused_folios_left(struct folio_batch *fbatch)
-{
-	unsigned j, n = 0;
-
-	/* shift unused page to beginning of fbatch */
-	for (j = 0; j < folio_batch_count(fbatch); j++) {
-		if (!fbatch->folios[j])
-			continue;
-
-		if (n < j) {
-			fbatch->folios[n] = fbatch->folios[j];
-		}
-
-		n++;
-	}
-
-	fbatch->nr = n;
-}
-
-static
-int ceph_submit_write(struct address_space *mapping,
-			struct writeback_control *wbc,
-			struct ceph_writeback_ctl *ceph_wbc)
-{
-	struct inode *inode = mapping->host;
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_vino vino = ceph_vino(inode);
-	struct ceph_osd_request *req = NULL;
-	struct page *page = NULL;
-	bool caching = ceph_is_cache_enabled(inode);
-	u64 offset;
-	u64 len;
-	unsigned i;
-
-new_request:
-	offset = ceph_fscrypt_page_offset(ceph_wbc->pages[0]);
-	len = ceph_wbc->wsize;
-
-	req = ceph_osdc_new_request(&fsc->client->osdc,
-				    &ci->i_layout, vino,
-				    offset, &len, 0, ceph_wbc->num_ops,
-				    CEPH_OSD_OP_WRITE, CEPH_OSD_FLAG_WRITE,
-				    ceph_wbc->snapc, ceph_wbc->truncate_seq,
-				    ceph_wbc->truncate_size, false);
-	if (IS_ERR(req)) {
-		req = ceph_osdc_new_request(&fsc->client->osdc,
-					    &ci->i_layout, vino,
-					    offset, &len, 0,
-					    min(ceph_wbc->num_ops,
-						CEPH_OSD_SLAB_OPS),
-					    CEPH_OSD_OP_WRITE,
-					    CEPH_OSD_FLAG_WRITE,
-					    ceph_wbc->snapc,
-					    ceph_wbc->truncate_seq,
-					    ceph_wbc->truncate_size,
-					    true);
-		BUG_ON(IS_ERR(req));
-	}
-
-	page = ceph_wbc->pages[ceph_wbc->locked_pages - 1];
-	BUG_ON(len < ceph_fscrypt_page_offset(page) + thp_size(page) - offset);
-
-	if (!ceph_inc_osd_stopping_blocker(fsc->mdsc)) {
-		for (i = 0; i < folio_batch_count(&ceph_wbc->fbatch); i++) {
-			struct folio *folio = ceph_wbc->fbatch.folios[i];
-
-			if (!folio)
-				continue;
-
-			page = &folio->page;
-			redirty_page_for_writepage(wbc, page);
-			unlock_page(page);
-		}
-
-		for (i = 0; i < ceph_wbc->locked_pages; i++) {
-			page = ceph_fscrypt_pagecache_page(ceph_wbc->pages[i]);
-
-			if (!page)
-				continue;
-
-			redirty_page_for_writepage(wbc, page);
-			unlock_page(page);
-		}
-
-		ceph_osdc_put_request(req);
-		return -EIO;
-	}
-
-	req->r_callback = writepages_finish;
-	req->r_inode = inode;
-
-	/* Format the osd request message and submit the write */
-	len = 0;
-	ceph_wbc->data_pages = ceph_wbc->pages;
-	ceph_wbc->op_idx = 0;
-	for (i = 0; i < ceph_wbc->locked_pages; i++) {
-		u64 cur_offset;
-
-		page = ceph_fscrypt_pagecache_page(ceph_wbc->pages[i]);
-		cur_offset = page_offset(page);
-
-		/*
-		 * Discontinuity in page range? Ceph can handle that by just passing
-		 * multiple extents in the write op.
-		 */
-		if (offset + len != cur_offset) {
-			/* If it's full, stop here */
-			if (ceph_wbc->op_idx + 1 == req->r_num_ops)
-				break;
-
-			/* Kick off an fscache write with what we have so far. */
-			ceph_fscache_write_to_cache(inode, offset, len, caching);
-
-			/* Start a new extent */
-			osd_req_op_extent_dup_last(req, ceph_wbc->op_idx,
-						   cur_offset - offset);
-
-			doutc(cl, "got pages at %llu~%llu\n", offset, len);
-
-			osd_req_op_extent_osd_data_pages(req, ceph_wbc->op_idx,
-							 ceph_wbc->data_pages,
-							 len, 0,
-							 ceph_wbc->from_pool,
-							 false);
-			osd_req_op_extent_update(req, ceph_wbc->op_idx, len);
-
-			len = 0;
-			offset = cur_offset;
-			ceph_wbc->data_pages = ceph_wbc->pages + i;
-			ceph_wbc->op_idx++;
-		}
-
-		set_page_writeback(page);
-
-		if (caching)
-			ceph_set_page_fscache(page);
-
-		len += thp_size(page);
-	}
-
-	ceph_fscache_write_to_cache(inode, offset, len, caching);
-
-	if (ceph_wbc->size_stable) {
-		len = min(len, ceph_wbc->i_size - offset);
-	} else if (i == ceph_wbc->locked_pages) {
-		/* writepages_finish() clears writeback pages
-		 * according to the data length, so make sure
-		 * data length covers all locked pages */
-		u64 min_len = len + 1 - thp_size(page);
-		len = get_writepages_data_length(inode,
-						 ceph_wbc->pages[i - 1],
-						 offset);
-		len = max(len, min_len);
-	}
-
-	if (IS_ENCRYPTED(inode))
-		len = round_up(len, CEPH_FSCRYPT_BLOCK_SIZE);
-
-	doutc(cl, "got pages at %llu~%llu\n", offset, len);
-
-	if (IS_ENCRYPTED(inode) &&
-	    ((offset | len) & ~CEPH_FSCRYPT_BLOCK_MASK)) {
-		pr_warn_client(cl,
-			"bad encrypted write offset=%lld len=%llu\n",
-			offset, len);
-	}
-
-	osd_req_op_extent_osd_data_pages(req, ceph_wbc->op_idx,
-					 ceph_wbc->data_pages, len,
-					 0, ceph_wbc->from_pool, false);
-	osd_req_op_extent_update(req, ceph_wbc->op_idx, len);
-
-	BUG_ON(ceph_wbc->op_idx + 1 != req->r_num_ops);
-
-	ceph_wbc->from_pool = false;
-	if (i < ceph_wbc->locked_pages) {
-		BUG_ON(ceph_wbc->num_ops <= req->r_num_ops);
-		ceph_wbc->num_ops -= req->r_num_ops;
-		ceph_wbc->locked_pages -= i;
-
-		/* allocate new pages array for next request */
-		ceph_wbc->data_pages = ceph_wbc->pages;
-		__ceph_allocate_page_array(ceph_wbc, ceph_wbc->locked_pages);
-		memcpy(ceph_wbc->pages, ceph_wbc->data_pages + i,
-			ceph_wbc->locked_pages * sizeof(*ceph_wbc->pages));
-		memset(ceph_wbc->data_pages + i, 0,
-			ceph_wbc->locked_pages * sizeof(*ceph_wbc->pages));
-	} else {
-		BUG_ON(ceph_wbc->num_ops != req->r_num_ops);
-		/* request message now owns the pages array */
-		ceph_wbc->pages = NULL;
-	}
-
-	req->r_mtime = inode_get_mtime(inode);
-	ceph_osdc_start_request(&fsc->client->osdc, req);
-	req = NULL;
-
-	wbc->nr_to_write -= i;
-	if (ceph_wbc->pages)
-		goto new_request;
-
-	return 0;
-}
-
-static
-void ceph_wait_until_current_writes_complete(struct address_space *mapping,
-					     struct writeback_control *wbc,
-					     struct ceph_writeback_ctl *ceph_wbc)
-{
-	struct page *page;
-	unsigned i, nr;
-
-	if (wbc->sync_mode != WB_SYNC_NONE &&
-	    ceph_wbc->start_index == 0 && /* all dirty pages were checked */
-	    !ceph_wbc->head_snapc) {
-		ceph_wbc->index = 0;
-
-		while ((ceph_wbc->index <= ceph_wbc->end) &&
-			(nr = filemap_get_folios_tag(mapping,
-						     &ceph_wbc->index,
-						     (pgoff_t)-1,
-						     PAGECACHE_TAG_WRITEBACK,
-						     &ceph_wbc->fbatch))) {
-			for (i = 0; i < nr; i++) {
-				page = &ceph_wbc->fbatch.folios[i]->page;
-				if (page_snap_context(page) != ceph_wbc->snapc)
-					continue;
-				wait_on_page_writeback(page);
-			}
-
-			folio_batch_release(&ceph_wbc->fbatch);
-			cond_resched();
-		}
-	}
-}
-
 /*
- * initiate async writeback
+ * Dirty a page.  Optimistically adjust accounting, on the assumption
+ * that we won't race with invalidate.  If we do, readjust.
  */
-static int ceph_writepages_start(struct address_space *mapping,
-				 struct writeback_control *wbc)
+bool ceph_dirty_folio(struct address_space *mapping, struct folio *folio)
 {
 	struct inode *inode = mapping->host;
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_writeback_ctl ceph_wbc;
-	int rc = 0;
-
-	if (wbc->sync_mode == WB_SYNC_NONE && fsc->write_congested)
-		return 0;
-
-	doutc(cl, "%llx.%llx (mode=%s)\n", ceph_vinop(inode),
-	      wbc->sync_mode == WB_SYNC_NONE ? "NONE" :
-	      (wbc->sync_mode == WB_SYNC_ALL ? "ALL" : "HOLD"));
-
-	if (is_forced_umount(mapping)) {
-		/* we're in a forced umount, don't write! */
-		return -EIO;
-	}
-
-	ceph_init_writeback_ctl(mapping, wbc, &ceph_wbc);
-
-	if (!ceph_inc_osd_stopping_blocker(fsc->mdsc)) {
-		rc = -EIO;
-		goto out;
-	}
-
-retry:
-	rc = ceph_define_writeback_range(mapping, wbc, &ceph_wbc);
-	if (rc == -ENODATA) {
-		/* hmm, why does writepages get called when there
-		   is no dirty data? */
-		rc = 0;
-		goto dec_osd_stopping_blocker;
-	}
-
-	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
-		tag_pages_for_writeback(mapping, ceph_wbc.index, ceph_wbc.end);
-
-	while (!has_writeback_done(&ceph_wbc)) {
-		ceph_wbc.locked_pages = 0;
-		ceph_wbc.max_pages = ceph_wbc.wsize >> PAGE_SHIFT;
-
-get_more_pages:
-		ceph_folio_batch_reinit(&ceph_wbc);
-
-		ceph_wbc.nr_folios = filemap_get_folios_tag(mapping,
-							    &ceph_wbc.index,
-							    ceph_wbc.end,
-							    ceph_wbc.tag,
-							    &ceph_wbc.fbatch);
-		doutc(cl, "pagevec_lookup_range_tag for tag %#x got %d\n",
-			ceph_wbc.tag, ceph_wbc.nr_folios);
-
-		if (!ceph_wbc.nr_folios && !ceph_wbc.locked_pages)
-			break;
-
-process_folio_batch:
-		rc = ceph_process_folio_batch(mapping, wbc, &ceph_wbc);
-		if (rc)
-			goto release_folios;
-
-		/* did we get anything? */
-		if (!ceph_wbc.locked_pages)
-			goto release_folios;
-
-		if (ceph_wbc.processed_in_fbatch) {
-			ceph_shift_unused_folios_left(&ceph_wbc.fbatch);
-
-			if (folio_batch_count(&ceph_wbc.fbatch) == 0 &&
-			    ceph_wbc.locked_pages < ceph_wbc.max_pages) {
-				doutc(cl, "reached end fbatch, trying for more\n");
-				goto get_more_pages;
-			}
-		}
-
-		rc = ceph_submit_write(mapping, wbc, &ceph_wbc);
-		if (rc)
-			goto release_folios;
-
-		ceph_wbc.locked_pages = 0;
-		ceph_wbc.strip_unit_end = 0;
-
-		if (folio_batch_count(&ceph_wbc.fbatch) > 0) {
-			ceph_wbc.nr_folios =
-				folio_batch_count(&ceph_wbc.fbatch);
-			goto process_folio_batch;
-		}
-
-		/*
-		 * We stop writing back only if we are not doing
-		 * integrity sync. In case of integrity sync we have to
-		 * keep going until we have written all the pages
-		 * we tagged for writeback prior to entering this loop.
-		 */
-		if (wbc->nr_to_write <= 0 && wbc->sync_mode == WB_SYNC_NONE)
-			ceph_wbc.done = true;
-
-release_folios:
-		doutc(cl, "folio_batch release on %d folios (%p)\n",
-		      (int)ceph_wbc.fbatch.nr,
-		      ceph_wbc.fbatch.nr ? ceph_wbc.fbatch.folios[0] : NULL);
-		folio_batch_release(&ceph_wbc.fbatch);
-	}
-
-	if (ceph_wbc.should_loop && !ceph_wbc.done) {
-		/* more to do; loop back to beginning of file */
-		doutc(cl, "looping back to beginning of file\n");
-		/* OK even when start_index == 0 */
-		ceph_wbc.end = ceph_wbc.start_index - 1;
-
-		/* to write dirty pages associated with next snapc,
-		 * we need to wait until current writes complete */
-		ceph_wait_until_current_writes_complete(mapping, wbc, &ceph_wbc);
-
-		ceph_wbc.start_index = 0;
-		ceph_wbc.index = 0;
-		goto retry;
-	}
-
-	if (wbc->range_cyclic || (ceph_wbc.range_whole && wbc->nr_to_write > 0))
-		mapping->writeback_index = ceph_wbc.index;
-
-dec_osd_stopping_blocker:
-	ceph_dec_osd_stopping_blocker(fsc->mdsc);
-
-out:
-	ceph_put_snap_context(ceph_wbc.last_snapc);
-	doutc(cl, "%llx.%llx dend - startone, rc = %d\n", ceph_vinop(inode),
-	      rc);
-
-	return rc;
-}
-
-/*
- * See if a given @snapc is either writeable, or already written.
- */
-static int context_is_writeable_or_written(struct inode *inode,
-					   struct ceph_snap_context *snapc)
-{
-	struct ceph_snap_context *oldest = get_oldest_context(inode, NULL, NULL);
-	int ret = !oldest || snapc->seq <= oldest->seq;
-
-	ceph_put_snap_context(oldest);
-	return ret;
-}
-
-/**
- * ceph_find_incompatible - find an incompatible context and return it
- * @folio: folio being dirtied
- *
- * We are only allowed to write into/dirty a folio if the folio is
- * clean, or already dirty within the same snap context. Returns a
- * conflicting context if there is one, NULL if there isn't, or a
- * negative error code on other errors.
- *
- * Must be called with folio lock held.
- */
-static struct ceph_snap_context *
-ceph_find_incompatible(struct folio *folio)
-{
-	struct inode *inode = folio->mapping->host;
 	struct ceph_client *cl = ceph_inode_to_client(inode);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-
-	if (ceph_inode_is_shutdown(inode)) {
-		doutc(cl, " %llx.%llx folio %p is shutdown\n",
-		      ceph_vinop(inode), folio);
-		return ERR_PTR(-ESTALE);
-	}
-
-	for (;;) {
-		struct ceph_snap_context *snapc, *oldest;
-
-		folio_wait_writeback(folio);
-
-		snapc = page_snap_context(&folio->page);
-		if (!snapc || snapc == ci->i_head_snapc)
-			break;
-
-		/*
-		 * this folio is already dirty in another (older) snap
-		 * context!  is it writeable now?
-		 */
-		oldest = get_oldest_context(inode, NULL, NULL);
-		if (snapc->seq > oldest->seq) {
-			/* not writeable -- return it for the caller to deal with */
-			ceph_put_snap_context(oldest);
-			doutc(cl, " %llx.%llx folio %p snapc %p not current or oldest\n",
-			      ceph_vinop(inode), folio, snapc);
-			return ceph_get_snap_context(snapc);
-		}
-		ceph_put_snap_context(oldest);
-
-		/* yay, writeable, do it now (without dropping folio lock) */
-		doutc(cl, " %llx.%llx folio %p snapc %p not current, but oldest\n",
-		      ceph_vinop(inode), folio, snapc);
-		if (folio_clear_dirty_for_io(folio)) {
-			int r = write_folio_nounlock(folio, NULL);
-			if (r < 0)
-				return ERR_PTR(r);
-		}
-	}
-	return NULL;
-}
-
-static int ceph_netfs_check_write_begin(struct file *file, loff_t pos, unsigned int len,
-					struct folio **foliop, void **_fsdata)
-{
-	struct inode *inode = file_inode(file);
-	struct ceph_inode_info *ci = ceph_inode(inode);
+	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
+	struct ceph_inode_info *ci;
 	struct ceph_snap_context *snapc;
+	struct netfs_group *group;
 
-	snapc = ceph_find_incompatible(*foliop);
-	if (snapc) {
-		int r;
-
-		folio_unlock(*foliop);
-		folio_put(*foliop);
-		*foliop = NULL;
-		if (IS_ERR(snapc))
-			return PTR_ERR(snapc);
-
-		ceph_queue_writeback(inode);
-		r = wait_event_killable(ci->i_cap_wq,
-					context_is_writeable_or_written(inode, snapc));
-		ceph_put_snap_context(snapc);
-		return r == 0 ? -EAGAIN : r;
+	if (folio_test_dirty(folio)) {
+		doutc(cl, "%llx.%llx %p idx %lu -- already dirty\n",
+		      ceph_vinop(inode), folio, folio->index);
+		VM_BUG_ON_FOLIO(!folio_test_private(folio), folio);
+		return false;
 	}
-	return 0;
-}
-
-/*
- * We are only allowed to write into/dirty the page if the page is
- * clean, or already dirty within the same snap context.
- */
-static int ceph_write_begin(struct file *file, struct address_space *mapping,
-			    loff_t pos, unsigned len,
-			    struct folio **foliop, void **fsdata)
-{
-	struct inode *inode = file_inode(file);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	int r;
-
-	r = netfs_write_begin(&ci->netfs, file, inode->i_mapping, pos, len, foliop, NULL);
-	if (r < 0)
-		return r;
 
-	folio_wait_private_2(*foliop); /* [DEPRECATED] */
-	WARN_ON_ONCE(!folio_test_locked(*foliop));
-	return 0;
-}
+	atomic64_inc(&mdsc->dirty_folios);
 
-/*
- * we don't do anything in here that simple_write_end doesn't do
- * except adjust dirty page accounting
- */
-static int ceph_write_end(struct file *file, struct address_space *mapping,
-			  loff_t pos, unsigned len, unsigned copied,
-			  struct folio *folio, void *fsdata)
-{
-	struct inode *inode = file_inode(file);
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-	bool check_cap = false;
+	ci = ceph_inode(inode);
 
-	doutc(cl, "%llx.%llx file %p folio %p %d~%d (%d)\n", ceph_vinop(inode),
-	      file, folio, (int)pos, (int)copied, (int)len);
+	/* dirty the head */
+	spin_lock(&ci->i_ceph_lock);
+	if (__ceph_have_pending_cap_snap(ci)) {
+		struct ceph_cap_snap *capsnap =
+			list_last_entry(&ci->i_cap_snaps,
+					struct ceph_cap_snap,
+					ci_item);
+		snapc = capsnap->context;
+		capsnap->dirty_pages++;
+	} else {
+		snapc = ci->i_head_snapc;
+		BUG_ON(!snapc);
+		++ci->i_wrbuffer_ref_head;
+	}
 
-	if (!folio_test_uptodate(folio)) {
-		/* just return that nothing was copied on a short copy */
-		if (copied < len) {
-			copied = 0;
-			goto out;
+	/* Attach a reference to the snap/group to the folio. */
+	group = netfs_folio_group(folio);
+	if (group != &snapc->group) {
+		netfs_set_group(folio, &snapc->group);
+		if (group) {
+			doutc(cl, "Different group %px != %px\n",
+			      group, &snapc->group);
+			netfs_put_group(group);
 		}
-		folio_mark_uptodate(folio);
 	}
 
-	/* did file size increase? */
-	if (pos+copied > i_size_read(inode))
-		check_cap = ceph_inode_set_size(inode, pos+copied);
-
-	folio_mark_dirty(folio);
-
-out:
-	folio_unlock(folio);
-	folio_put(folio);
-
-	if (check_cap)
-		ceph_check_caps(ceph_inode(inode), CHECK_CAPS_AUTHONLY);
+	if (ci->i_wrbuffer_ref == 0)
+		ihold(inode);
+	++ci->i_wrbuffer_ref;
+	doutc(cl, "%llx.%llx %p idx %lu head %d/%d -> %d/%d "
+	      "snapc %p seq %lld (%d snaps)\n",
+	      ceph_vinop(inode), folio, folio->index,
+	      ci->i_wrbuffer_ref-1, ci->i_wrbuffer_ref_head-1,
+	      ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head,
+	      snapc, snapc->seq, snapc->num_snaps);
+	spin_unlock(&ci->i_ceph_lock);
 
-	return copied;
+	return netfs_dirty_folio(mapping, folio);
 }
 
-const struct address_space_operations ceph_aops = {
-	.read_folio = netfs_read_folio,
-	.readahead = netfs_readahead,
-	.writepages = ceph_writepages_start,
-	.write_begin = ceph_write_begin,
-	.write_end = ceph_write_end,
-	.dirty_folio = ceph_dirty_folio,
-	.invalidate_folio = ceph_invalidate_folio,
-	.release_folio = netfs_release_folio,
-	.direct_IO = noop_direct_IO,
-	.migrate_folio = filemap_migrate_folio,
-};
-#endif // TODO: Remove after netfs conversion
-
 static void ceph_block_sigs(sigset_t *oldset)
 {
 	sigset_t mask;
@@ -2046,112 +226,6 @@ static vm_fault_t ceph_filemap_fault(struct vm_fault *vmf)
 	return ret;
 }
 
-#if 0 // TODO: Remove after netfs conversion
-static vm_fault_t ceph_page_mkwrite(struct vm_fault *vmf)
-{
-	struct vm_area_struct *vma = vmf->vma;
-	struct inode *inode = file_inode(vma->vm_file);
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_file_info *fi = vma->vm_file->private_data;
-	struct ceph_cap_flush *prealloc_cf;
-	struct folio *folio = page_folio(vmf->page);
-	loff_t off = folio_pos(folio);
-	loff_t size = i_size_read(inode);
-	size_t len;
-	int want, got, err;
-	sigset_t oldset;
-	vm_fault_t ret = VM_FAULT_SIGBUS;
-
-	if (ceph_inode_is_shutdown(inode))
-		return ret;
-
-	prealloc_cf = ceph_alloc_cap_flush();
-	if (!prealloc_cf)
-		return VM_FAULT_OOM;
-
-	sb_start_pagefault(inode->i_sb);
-	ceph_block_sigs(&oldset);
-
-	if (off + folio_size(folio) <= size)
-		len = folio_size(folio);
-	else
-		len = offset_in_folio(folio, size);
-
-	doutc(cl, "%llx.%llx %llu~%zd getting caps i_size %llu\n",
-	      ceph_vinop(inode), off, len, size);
-	if (fi->fmode & CEPH_FILE_MODE_LAZY)
-		want = CEPH_CAP_FILE_BUFFER | CEPH_CAP_FILE_LAZYIO;
-	else
-		want = CEPH_CAP_FILE_BUFFER;
-
-	got = 0;
-	err = ceph_get_caps(vma->vm_file, CEPH_CAP_FILE_WR, want, off + len, &got);
-	if (err < 0)
-		goto out_free;
-
-	doutc(cl, "%llx.%llx %llu~%zd got cap refs on %s\n", ceph_vinop(inode),
-	      off, len, ceph_cap_string(got));
-
-	/* Update time before taking folio lock */
-	file_update_time(vma->vm_file);
-	inode_inc_iversion_raw(inode);
-
-	do {
-		struct ceph_snap_context *snapc;
-
-		folio_lock(folio);
-
-		if (folio_mkwrite_check_truncate(folio, inode) < 0) {
-			folio_unlock(folio);
-			ret = VM_FAULT_NOPAGE;
-			break;
-		}
-
-		snapc = ceph_find_incompatible(folio);
-		if (!snapc) {
-			/* success.  we'll keep the folio locked. */
-			folio_mark_dirty(folio);
-			ret = VM_FAULT_LOCKED;
-			break;
-		}
-
-		folio_unlock(folio);
-
-		if (IS_ERR(snapc)) {
-			ret = VM_FAULT_SIGBUS;
-			break;
-		}
-
-		ceph_queue_writeback(inode);
-		err = wait_event_killable(ci->i_cap_wq,
-				context_is_writeable_or_written(inode, snapc));
-		ceph_put_snap_context(snapc);
-	} while (err == 0);
-
-	if (ret == VM_FAULT_LOCKED) {
-		int dirty;
-		spin_lock(&ci->i_ceph_lock);
-		dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR,
-					       &prealloc_cf);
-		spin_unlock(&ci->i_ceph_lock);
-		if (dirty)
-			__mark_inode_dirty(inode, dirty);
-	}
-
-	doutc(cl, "%llx.%llx %llu~%zd dropping cap refs on %s ret %x\n",
-	      ceph_vinop(inode), off, len, ceph_cap_string(got), ret);
-	ceph_put_cap_refs_async(ci, got);
-out_free:
-	ceph_restore_sigs(&oldset);
-	sb_end_pagefault(inode->i_sb);
-	ceph_free_cap_flush(prealloc_cf);
-	if (err < 0)
-		ret = vmf_error(err);
-	return ret;
-}
-#endif // TODO: Remove after netfs conversion
-
 void ceph_fill_inline_data(struct inode *inode, struct page *locked_page,
 			   char	*data, size_t len)
 {
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 94b91b5bc843..d7684f4b2e10 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -77,97 +77,6 @@ static __le32 ceph_flags_sys2wire(struct ceph_mds_client *mdsc, u32 flags)
  * need to wait for MDS acknowledgement.
  */
 
-#if 0 // TODO: Remove after netfs conversion
-/*
- * How many pages to get in one call to iov_iter_get_pages().  This
- * determines the size of the on-stack array used as a buffer.
- */
-#define ITER_GET_BVECS_PAGES	64
-
-static int __iter_get_bvecs(struct iov_iter *iter, size_t maxsize,
-			    struct ceph_databuf *dbuf)
-{
-	size_t size = 0;
-
-	if (maxsize > iov_iter_count(iter))
-		maxsize = iov_iter_count(iter);
-
-	while (size < maxsize) {
-		struct page *pages[ITER_GET_BVECS_PAGES];
-		ssize_t bytes;
-		size_t start;
-		int idx = 0;
-
-		bytes = iov_iter_get_pages2(iter, pages, maxsize - size,
-					    ITER_GET_BVECS_PAGES, &start);
-		if (bytes < 0) {
-			if (size == 0)
-				return bytes;
-			break;
-		}
-
-		while (bytes) {
-			int len = min_t(int, bytes, PAGE_SIZE - start);
-
-			ceph_databuf_append_page(dbuf, pages[idx++], start, len);
-			bytes -= len;
-			size += len;
-			start = 0;
-		}
-	}
-
-	return 0;
-}
-
-/*
- * iov_iter_get_pages() only considers one iov_iter segment, no matter
- * what maxsize or maxpages are given.  For ITER_BVEC that is a single
- * page.
- *
- * Attempt to get up to @maxsize bytes worth of pages from @iter.
- * Return the number of bytes in the created bio_vec array, or an error.
- */
-static struct ceph_databuf *iter_get_bvecs_alloc(struct iov_iter *iter,
-						 size_t maxsize, bool write)
-{
-	struct ceph_databuf *dbuf;
-	size_t orig_count = iov_iter_count(iter);
-	int npages, ret;
-
-	iov_iter_truncate(iter, maxsize);
-	npages = iov_iter_npages(iter, INT_MAX);
-	iov_iter_reexpand(iter, orig_count);
-
-	if (write)
-		dbuf = ceph_databuf_req_alloc(npages, 0, GFP_KERNEL);
-	else
-		dbuf = ceph_databuf_reply_alloc(npages, 0, GFP_KERNEL);
-	if (!dbuf)
-		return ERR_PTR(-ENOMEM);
-
-	ret = __iter_get_bvecs(iter, maxsize, dbuf);
-	if (ret < 0) {
-		/*
-		 * No pages were pinned -- just free the array.
-		 */
-		ceph_databuf_release(dbuf);
-		return ERR_PTR(ret);
-	}
-
-	return dbuf;
-}
-
-static void ceph_dirty_pages(struct ceph_databuf *dbuf)
-{
-	struct bio_vec *bvec = dbuf->bvec;
-	int i;
-
-	for (i = 0; i < dbuf->nr_bvec; i++)
-		if (bvec[i].bv_page)
-			set_page_dirty_lock(bvec[i].bv_page);
-}
-#endif // TODO: Remove after netfs conversion
-
 /*
  * Prepare an open request.  Preallocate ceph_cap to avoid an
  * inopportune ENOMEM later.
@@ -1023,1222 +932,6 @@ int ceph_release(struct inode *inode, struct file *file)
 	return 0;
 }
 
-#if 0 // TODO: Remove after netfs conversion
-enum {
-	HAVE_RETRIED = 1,
-	CHECK_EOF =    2,
-	READ_INLINE =  3,
-};
-
-/*
- * Completely synchronous read and write methods.  Direct from __user
- * buffer to osd, or directly to user pages (if O_DIRECT).
- *
- * If the read spans object boundary, just do multiple reads.  (That's not
- * atomic, but good enough for now.)
- *
- * If we get a short result from the OSD, check against i_size; we need to
- * only return a short read to the caller if we hit EOF.
- */
-ssize_t __ceph_sync_read(struct inode *inode, loff_t *ki_pos,
-			 struct iov_iter *to, int *retry_op,
-			 u64 *last_objver)
-{
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_osd_client *osdc = &fsc->client->osdc;
-	ssize_t ret;
-	u64 off = *ki_pos;
-	u64 len = iov_iter_count(to);
-	u64 i_size = i_size_read(inode);
-	bool sparse = IS_ENCRYPTED(inode) || ceph_test_mount_opt(fsc, SPARSEREAD);
-	u64 objver = 0;
-
-	doutc(cl, "on inode %p %llx.%llx %llx~%llx\n", inode,
-	      ceph_vinop(inode), *ki_pos, len);
-
-	if (ceph_inode_is_shutdown(inode))
-		return -EIO;
-
-	if (!len || !i_size)
-		return 0;
-	/*
-	 * flush any page cache pages in this range.  this
-	 * will make concurrent normal and sync io slow,
-	 * but it will at least behave sensibly when they are
-	 * in sequence.
-	 */
-	ret = filemap_write_and_wait_range(inode->i_mapping,
-					   off, off + len - 1);
-	if (ret < 0)
-		return ret;
-
-	ret = 0;
-	while ((len = iov_iter_count(to)) > 0) {
-		struct ceph_osd_request *req;
-		struct page **pages;
-		int num_pages;
-		size_t page_off;
-		bool more;
-		int idx = 0;
-		size_t left;
-		struct ceph_osd_req_op *op;
-		u64 read_off = off;
-		u64 read_len = len;
-		int extent_cnt;
-
-		/* determine new offset/length if encrypted */
-		ceph_fscrypt_adjust_off_and_len(inode, &read_off, &read_len);
-
-		doutc(cl, "orig %llu~%llu reading %llu~%llu", off, len,
-		      read_off, read_len);
-
-		req = ceph_osdc_new_request(osdc, &ci->i_layout,
-					ci->i_vino, read_off, &read_len, 0, 1,
-					sparse ? CEPH_OSD_OP_SPARSE_READ :
-						 CEPH_OSD_OP_READ,
-					CEPH_OSD_FLAG_READ,
-					NULL, ci->i_truncate_seq,
-					ci->i_truncate_size, false);
-		if (IS_ERR(req)) {
-			ret = PTR_ERR(req);
-			break;
-		}
-
-		/* adjust len downward if the request truncated the len */
-		if (off + len > read_off + read_len)
-			len = read_off + read_len - off;
-		more = len < iov_iter_count(to);
-
-		op = &req->r_ops[0];
-		if (sparse) {
-			extent_cnt = __ceph_sparse_read_ext_count(inode, read_len);
-			ret = ceph_alloc_sparse_ext_map(op, extent_cnt);
-			if (ret) {
-				ceph_osdc_put_request(req);
-				break;
-			}
-		}
-
-		num_pages = calc_pages_for(read_off, read_len);
-		page_off = offset_in_page(off);
-		pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
-		if (IS_ERR(pages)) {
-			ceph_osdc_put_request(req);
-			ret = PTR_ERR(pages);
-			break;
-		}
-
-		osd_req_op_extent_osd_data_pages(req, 0, pages, read_len,
-						 offset_in_page(read_off),
-						 false, true);
-
-		ceph_osdc_start_request(osdc, req);
-		ret = ceph_osdc_wait_request(osdc, req);
-
-		ceph_update_read_metrics(&fsc->mdsc->metric,
-					 req->r_start_latency,
-					 req->r_end_latency,
-					 read_len, ret);
-
-		if (ret > 0)
-			objver = req->r_version;
-
-		i_size = i_size_read(inode);
-		doutc(cl, "%llu~%llu got %zd i_size %llu%s\n", off, len,
-		      ret, i_size, (more ? " MORE" : ""));
-
-		/* Fix it to go to end of extent map */
-		if (sparse && ret >= 0)
-			ret = ceph_sparse_ext_map_end(op);
-		else if (ret == -ENOENT)
-			ret = 0;
-
-		if (ret < 0) {
-			ceph_osdc_put_request(req);
-			if (ret == -EBLOCKLISTED)
-				fsc->blocklisted = true;
-			break;
-		}
-
-		if (IS_ENCRYPTED(inode)) {
-			int fret;
-
-			fret = ceph_fscrypt_decrypt_extents(inode, pages,
-					read_off, op->extent.sparse_ext,
-					op->extent.sparse_ext_cnt);
-			if (fret < 0) {
-				ret = fret;
-				ceph_osdc_put_request(req);
-				break;
-			}
-
-			/* account for any partial block at the beginning */
-			fret -= (off - read_off);
-
-			/*
-			 * Short read after big offset adjustment?
-			 * Nothing is usable, just call it a zero
-			 * len read.
-			 */
-			fret = max(fret, 0);
-
-			/* account for partial block at the end */
-			ret = min_t(ssize_t, fret, len);
-		}
-
-		/* Short read but not EOF? Zero out the remainder. */
-		if (ret < len && (off + ret < i_size)) {
-			int zlen = min(len - ret, i_size - off - ret);
-			int zoff = page_off + ret;
-
-			doutc(cl, "zero gap %llu~%llu\n", off + ret,
-			      off + ret + zlen);
-			ceph_zero_page_vector_range(zoff, zlen, pages);
-			ret += zlen;
-		}
-
-		if (off + ret > i_size)
-			left = (i_size > off) ? i_size - off : 0;
-		else
-			left = ret;
-
-		while (left > 0) {
-			size_t plen, copied;
-
-			plen = min_t(size_t, left, PAGE_SIZE - page_off);
-			SetPageUptodate(pages[idx]);
-			copied = copy_page_to_iter(pages[idx++],
-						   page_off, plen, to);
-			off += copied;
-			left -= copied;
-			page_off = 0;
-			if (copied < plen) {
-				ret = -EFAULT;
-				break;
-			}
-		}
-
-		ceph_osdc_put_request(req);
-
-		if (off >= i_size || !more)
-			break;
-	}
-
-	if (ret > 0) {
-		if (off >= i_size) {
-			*retry_op = CHECK_EOF;
-			ret = i_size - *ki_pos;
-			*ki_pos = i_size;
-		} else {
-			ret = off - *ki_pos;
-			*ki_pos = off;
-		}
-
-		if (last_objver)
-			*last_objver = objver;
-	}
-	doutc(cl, "result %zd retry_op %d\n", ret, *retry_op);
-	return ret;
-}
-
-static ssize_t ceph_sync_read(struct kiocb *iocb, struct iov_iter *to,
-			      int *retry_op)
-{
-	struct file *file = iocb->ki_filp;
-	struct inode *inode = file_inode(file);
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-
-	doutc(cl, "on file %p %llx~%zx %s\n", file, iocb->ki_pos,
-	      iov_iter_count(to),
-	      (file->f_flags & O_DIRECT) ? "O_DIRECT" : "");
-
-	return __ceph_sync_read(inode, &iocb->ki_pos, to, retry_op, NULL);
-}
-
-struct ceph_aio_request {
-	struct kiocb *iocb;
-	size_t total_len;
-	bool write;
-	bool should_dirty;
-	int error;
-	struct list_head osd_reqs;
-	unsigned num_reqs;
-	atomic_t pending_reqs;
-	struct timespec64 mtime;
-	struct ceph_cap_flush *prealloc_cf;
-};
-
-struct ceph_aio_work {
-	struct work_struct work;
-	struct ceph_osd_request *req;
-};
-
-static void ceph_aio_retry_work(struct work_struct *work);
-
-static void ceph_aio_complete(struct inode *inode,
-			      struct ceph_aio_request *aio_req)
-{
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	int ret;
-
-	if (!atomic_dec_and_test(&aio_req->pending_reqs))
-		return;
-
-	if (aio_req->iocb->ki_flags & IOCB_DIRECT)
-		inode_dio_end(inode);
-
-	ret = aio_req->error;
-	if (!ret)
-		ret = aio_req->total_len;
-
-	doutc(cl, "%p %llx.%llx rc %d\n", inode, ceph_vinop(inode), ret);
-
-	if (ret >= 0 && aio_req->write) {
-		int dirty;
-
-		loff_t endoff = aio_req->iocb->ki_pos + aio_req->total_len;
-		if (endoff > i_size_read(inode)) {
-			if (ceph_inode_set_size(inode, endoff))
-				ceph_check_caps(ci, CHECK_CAPS_AUTHONLY);
-		}
-
-		spin_lock(&ci->i_ceph_lock);
-		dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR,
-					       &aio_req->prealloc_cf);
-		spin_unlock(&ci->i_ceph_lock);
-		if (dirty)
-			__mark_inode_dirty(inode, dirty);
-
-	}
-
-	ceph_put_cap_refs(ci, (aio_req->write ? CEPH_CAP_FILE_WR :
-						CEPH_CAP_FILE_RD));
-
-	aio_req->iocb->ki_complete(aio_req->iocb, ret);
-
-	ceph_free_cap_flush(aio_req->prealloc_cf);
-	kfree(aio_req);
-}
-
-static void ceph_aio_complete_req(struct ceph_osd_request *req)
-{
-	int rc = req->r_result;
-	struct inode *inode = req->r_inode;
-	struct ceph_aio_request *aio_req = req->r_priv;
-	struct ceph_osd_data *osd_data = osd_req_op_extent_osd_data(req, 0);
-	struct ceph_osd_req_op *op = &req->r_ops[0];
-	struct ceph_client_metric *metric = &ceph_sb_to_mdsc(inode->i_sb)->metric;
-	size_t len = osd_data->iter.count;
-	bool sparse = (op->op == CEPH_OSD_OP_SPARSE_READ);
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-
-	doutc(cl, "req %p inode %p %llx.%llx, rc %d bytes %zu\n", req,
-	      inode, ceph_vinop(inode), rc, len);
-
-	if (rc == -EOLDSNAPC) {
-		struct ceph_aio_work *aio_work;
-		BUG_ON(!aio_req->write);
-
-		aio_work = kmalloc(sizeof(*aio_work), GFP_NOFS);
-		if (aio_work) {
-			INIT_WORK(&aio_work->work, ceph_aio_retry_work);
-			aio_work->req = req;
-			queue_work(ceph_inode_to_fs_client(inode)->inode_wq,
-				   &aio_work->work);
-			return;
-		}
-		rc = -ENOMEM;
-	} else if (!aio_req->write) {
-		if (sparse && rc >= 0)
-			rc = ceph_sparse_ext_map_end(op);
-		if (rc == -ENOENT)
-			rc = 0;
-		if (rc >= 0 && len > rc) {
-			int zlen = len - rc;
-
-			/*
-			 * If read is satisfied by single OSD request,
-			 * it can pass EOF. Otherwise read is within
-			 * i_size.
-			 */
-			if (aio_req->num_reqs == 1) {
-				loff_t i_size = i_size_read(inode);
-				loff_t endoff = aio_req->iocb->ki_pos + rc;
-				if (endoff < i_size)
-					zlen = min_t(size_t, zlen,
-						     i_size - endoff);
-				aio_req->total_len = rc + zlen;
-			}
-
-			iov_iter_advance(&osd_data->iter, rc);
-			iov_iter_zero(zlen, &osd_data->iter);
-		}
-	}
-
-	/* r_start_latency == 0 means the request was not submitted */
-	if (req->r_start_latency) {
-		if (aio_req->write)
-			ceph_update_write_metrics(metric, req->r_start_latency,
-						  req->r_end_latency, len, rc);
-		else
-			ceph_update_read_metrics(metric, req->r_start_latency,
-						 req->r_end_latency, len, rc);
-	}
-
-	if (aio_req->should_dirty)
-		ceph_dirty_pages(osd_data->dbuf);
-	ceph_osdc_put_request(req);
-
-	if (rc < 0)
-		cmpxchg(&aio_req->error, 0, rc);
-
-	ceph_aio_complete(inode, aio_req);
-	return;
-}
-
-static void ceph_aio_retry_work(struct work_struct *work)
-{
-	struct ceph_aio_work *aio_work =
-		container_of(work, struct ceph_aio_work, work);
-	struct ceph_osd_request *orig_req = aio_work->req;
-	struct ceph_aio_request *aio_req = orig_req->r_priv;
-	struct inode *inode = orig_req->r_inode;
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_snap_context *snapc;
-	struct ceph_osd_request *req;
-	int ret;
-
-	spin_lock(&ci->i_ceph_lock);
-	if (__ceph_have_pending_cap_snap(ci)) {
-		struct ceph_cap_snap *capsnap =
-			list_last_entry(&ci->i_cap_snaps,
-					struct ceph_cap_snap,
-					ci_item);
-		snapc = ceph_get_snap_context(capsnap->context);
-	} else {
-		BUG_ON(!ci->i_head_snapc);
-		snapc = ceph_get_snap_context(ci->i_head_snapc);
-	}
-	spin_unlock(&ci->i_ceph_lock);
-
-	req = ceph_osdc_alloc_request(orig_req->r_osdc, snapc, 1,
-			false, GFP_NOFS);
-	if (!req) {
-		ret = -ENOMEM;
-		req = orig_req;
-		goto out;
-	}
-
-	req->r_flags = /* CEPH_OSD_FLAG_ORDERSNAP | */ CEPH_OSD_FLAG_WRITE;
-	ceph_oloc_copy(&req->r_base_oloc, &orig_req->r_base_oloc);
-	ceph_oid_copy(&req->r_base_oid, &orig_req->r_base_oid);
-
-	req->r_ops[0] = orig_req->r_ops[0];
-
-	req->r_mtime = aio_req->mtime;
-	req->r_data_offset = req->r_ops[0].extent.offset;
-
-	ret = ceph_osdc_alloc_messages(req, GFP_NOFS);
-	if (ret) {
-		ceph_osdc_put_request(req);
-		req = orig_req;
-		goto out;
-	}
-
-	ceph_osdc_put_request(orig_req);
-
-	req->r_callback = ceph_aio_complete_req;
-	req->r_inode = inode;
-	req->r_priv = aio_req;
-
-	ceph_osdc_start_request(req->r_osdc, req);
-out:
-	if (ret < 0) {
-		req->r_result = ret;
-		ceph_aio_complete_req(req);
-	}
-
-	ceph_put_snap_context(snapc);
-	kfree(aio_work);
-}
-
-static ssize_t
-ceph_direct_read_write(struct kiocb *iocb, struct iov_iter *iter,
-		       struct ceph_snap_context *snapc,
-		       struct ceph_cap_flush **pcf)
-{
-	struct file *file = iocb->ki_filp;
-	struct inode *inode = file_inode(file);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_client_metric *metric = &fsc->mdsc->metric;
-	struct ceph_vino vino;
-	struct ceph_osd_request *req;
-	struct ceph_aio_request *aio_req = NULL;
-	struct ceph_databuf *dbuf = NULL;
-	int flags;
-	int ret = 0;
-	struct timespec64 mtime = current_time(inode);
-	size_t count = iov_iter_count(iter);
-	loff_t pos = iocb->ki_pos;
-	bool write = iov_iter_rw(iter) == WRITE;
-	bool should_dirty = !write && user_backed_iter(iter);
-	bool sparse = ceph_test_mount_opt(fsc, SPARSEREAD);
-
-	if (write && ceph_snap(file_inode(file)) != CEPH_NOSNAP)
-		return -EROFS;
-
-	doutc(cl, "sync_direct_%s on file %p %lld~%u snapc %p seq %lld\n",
-	      (write ? "write" : "read"), file, pos, (unsigned)count,
-	      snapc, snapc ? snapc->seq : 0);
-
-	if (write) {
-		int ret2;
-
-		ceph_fscache_invalidate(inode, true);
-
-		ret2 = invalidate_inode_pages2_range(inode->i_mapping,
-					pos >> PAGE_SHIFT,
-					(pos + count - 1) >> PAGE_SHIFT);
-		if (ret2 < 0)
-			doutc(cl, "invalidate_inode_pages2_range returned %d\n",
-			      ret2);
-
-		flags = /* CEPH_OSD_FLAG_ORDERSNAP | */ CEPH_OSD_FLAG_WRITE;
-	} else {
-		flags = CEPH_OSD_FLAG_READ;
-	}
-
-	while (iov_iter_count(iter) > 0) {
-		u64 size = iov_iter_count(iter);
-		struct ceph_osd_req_op *op;
-		size_t len;
-		int readop = sparse ? CEPH_OSD_OP_SPARSE_READ : CEPH_OSD_OP_READ;
-		int extent_cnt;
-
-		if (write)
-			size = min_t(u64, size, fsc->mount_options->wsize);
-		else
-			size = min_t(u64, size, fsc->mount_options->rsize);
-
-		vino = ceph_vino(inode);
-		req = ceph_osdc_new_request(&fsc->client->osdc, &ci->i_layout,
-					    vino, pos, &size, 0,
-					    1,
-					    write ? CEPH_OSD_OP_WRITE : readop,
-					    flags, snapc,
-					    ci->i_truncate_seq,
-					    ci->i_truncate_size,
-					    false);
-		if (IS_ERR(req)) {
-			ret = PTR_ERR(req);
-			break;
-		}
-
-		op = &req->r_ops[0];
-		if (!write && sparse) {
-			extent_cnt = __ceph_sparse_read_ext_count(inode, size);
-			ret = ceph_alloc_sparse_ext_map(op, extent_cnt);
-			if (ret) {
-				ceph_osdc_put_request(req);
-				break;
-			}
-		}
-
-		dbuf = iter_get_bvecs_alloc(iter, size, write);
-		if (IS_ERR(dbuf)) {
-			ceph_osdc_put_request(req);
-			ret = PTR_ERR(dbuf);
-			break;
-		}
-		len = ceph_databuf_len(dbuf);
-		if (len != size)
-			osd_req_op_extent_update(req, 0, len);
-
-		osd_req_op_extent_osd_databuf(req, 0, dbuf);
-
-		/*
-		 * To simplify error handling, allow AIO when IO within i_size
-		 * or IO can be satisfied by single OSD request.
-		 */
-		if (pos == iocb->ki_pos && !is_sync_kiocb(iocb) &&
-		    (len == count || pos + count <= i_size_read(inode))) {
-			aio_req = kzalloc(sizeof(*aio_req), GFP_KERNEL);
-			if (aio_req) {
-				aio_req->iocb = iocb;
-				aio_req->write = write;
-				aio_req->should_dirty = should_dirty;
-				INIT_LIST_HEAD(&aio_req->osd_reqs);
-				if (write) {
-					aio_req->mtime = mtime;
-					swap(aio_req->prealloc_cf, *pcf);
-				}
-			}
-			/* ignore error */
-		}
-
-		if (write) {
-			/*
-			 * throw out any page cache pages in this range. this
-			 * may block.
-			 */
-			truncate_inode_pages_range(inode->i_mapping, pos,
-						   PAGE_ALIGN(pos + len) - 1);
-
-			req->r_mtime = mtime;
-		}
-
-		if (aio_req) {
-			aio_req->total_len += len;
-			aio_req->num_reqs++;
-			atomic_inc(&aio_req->pending_reqs);
-
-			req->r_callback = ceph_aio_complete_req;
-			req->r_inode = inode;
-			req->r_priv = aio_req;
-			list_add_tail(&req->r_private_item, &aio_req->osd_reqs);
-
-			pos += len;
-			continue;
-		}
-
-		ceph_osdc_start_request(req->r_osdc, req);
-		ret = ceph_osdc_wait_request(&fsc->client->osdc, req);
-
-		if (write)
-			ceph_update_write_metrics(metric, req->r_start_latency,
-						  req->r_end_latency, len, ret);
-		else
-			ceph_update_read_metrics(metric, req->r_start_latency,
-						 req->r_end_latency, len, ret);
-
-		size = i_size_read(inode);
-		if (!write) {
-			if (sparse && ret >= 0)
-				ret = ceph_sparse_ext_map_end(op);
-			else if (ret == -ENOENT)
-				ret = 0;
-
-			if (ret >= 0 && ret < len && pos + ret < size) {
-				int zlen = min_t(size_t, len - ret,
-						 size - pos - ret);
-
-				iov_iter_advance(&dbuf->iter, ret);
-				iov_iter_zero(zlen, &dbuf->iter);
-				ret += zlen;
-			}
-			if (ret >= 0)
-				len = ret;
-		}
-
-		ceph_osdc_put_request(req);
-		if (ret < 0)
-			break;
-
-		pos += len;
-		if (!write && pos >= size)
-			break;
-
-		if (write && pos > size) {
-			if (ceph_inode_set_size(inode, pos))
-				ceph_check_caps(ceph_inode(inode),
-						CHECK_CAPS_AUTHONLY);
-		}
-	}
-
-	if (aio_req) {
-		LIST_HEAD(osd_reqs);
-
-		if (aio_req->num_reqs == 0) {
-			kfree(aio_req);
-			return ret;
-		}
-
-		ceph_get_cap_refs(ci, write ? CEPH_CAP_FILE_WR :
-					      CEPH_CAP_FILE_RD);
-
-		list_splice(&aio_req->osd_reqs, &osd_reqs);
-		inode_dio_begin(inode);
-		while (!list_empty(&osd_reqs)) {
-			req = list_first_entry(&osd_reqs,
-					       struct ceph_osd_request,
-					       r_private_item);
-			list_del_init(&req->r_private_item);
-			if (ret >= 0)
-				ceph_osdc_start_request(req->r_osdc, req);
-			if (ret < 0) {
-				req->r_result = ret;
-				ceph_aio_complete_req(req);
-			}
-		}
-		return -EIOCBQUEUED;
-	}
-
-	if (ret != -EOLDSNAPC && pos > iocb->ki_pos) {
-		ret = pos - iocb->ki_pos;
-		iocb->ki_pos = pos;
-	}
-	return ret;
-}
-
-/*
- * Synchronous write, straight from __user pointer or user pages.
- *
- * If write spans object boundary, just do multiple writes.  (For a
- * correct atomic write, we should e.g. take write locks on all
- * objects, rollback on failure, etc.)
- */
-static ssize_t
-ceph_sync_write(struct kiocb *iocb, struct iov_iter *from, loff_t pos,
-		struct ceph_snap_context *snapc)
-{
-	struct file *file = iocb->ki_filp;
-	struct inode *inode = file_inode(file);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_osd_client *osdc = &fsc->client->osdc;
-	struct ceph_osd_request *req;
-	struct page **pages;
-	u64 len;
-	int num_pages;
-	int written = 0;
-	int ret;
-	bool check_caps = false;
-	struct timespec64 mtime = current_time(inode);
-	size_t count = iov_iter_count(from);
-
-	if (ceph_snap(file_inode(file)) != CEPH_NOSNAP)
-		return -EROFS;
-
-	doutc(cl, "on file %p %lld~%u snapc %p seq %lld\n", file, pos,
-	      (unsigned)count, snapc, snapc->seq);
-
-	ret = filemap_write_and_wait_range(inode->i_mapping,
-					   pos, pos + count - 1);
-	if (ret < 0)
-		return ret;
-
-	ceph_fscache_invalidate(inode, false);
-
-	while ((len = iov_iter_count(from)) > 0) {
-		size_t left;
-		int n;
-		u64 write_pos = pos;
-		u64 write_len = len;
-		u64 objnum, objoff;
-		u64 assert_ver = 0;
-		bool rmw;
-		bool first, last;
-		struct iov_iter saved_iter = *from;
-		size_t off, xlen;
-
-		ceph_fscrypt_adjust_off_and_len(inode, &write_pos, &write_len);
-
-		/* clamp the length to the end of first object */
-		ceph_calc_file_object_mapping(&ci->i_layout, write_pos,
-					      write_len, &objnum, &objoff,
-					      &xlen);
-		write_len = xlen;
-
-		/* adjust len downward if it goes beyond current object */
-		if (pos + len > write_pos + write_len)
-			len = write_pos + write_len - pos;
-
-		/*
-		 * If we had to adjust the length or position to align with a
-		 * crypto block, then we must do a read/modify/write cycle. We
-		 * use a version assertion to redrive the thing if something
-		 * changes in between.
-		 */
-		first = pos != write_pos;
-		last = (pos + len) != (write_pos + write_len);
-		rmw = first || last;
-
-		doutc(cl, "ino %llx %lld~%llu adjusted %lld~%llu -- %srmw\n",
-		      ci->i_vino.ino, pos, len, write_pos, write_len,
-		      rmw ? "" : "no ");
-
-		/*
-		 * The data is emplaced into the page as it would be if it were
-		 * in an array of pagecache pages.
-		 */
-		num_pages = calc_pages_for(write_pos, write_len);
-		pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
-		if (IS_ERR(pages)) {
-			ret = PTR_ERR(pages);
-			break;
-		}
-
-		/* Do we need to preload the pages? */
-		if (rmw) {
-			u64 first_pos = write_pos;
-			u64 last_pos = (write_pos + write_len) - CEPH_FSCRYPT_BLOCK_SIZE;
-			u64 read_len = CEPH_FSCRYPT_BLOCK_SIZE;
-			struct ceph_osd_req_op *op;
-
-			/* We should only need to do this for encrypted inodes */
-			WARN_ON_ONCE(!IS_ENCRYPTED(inode));
-
-			/* No need to do two reads if first and last blocks are same */
-			if (first && last_pos == first_pos)
-				last = false;
-
-			/*
-			 * Allocate a read request for one or two extents,
-			 * depending on how the request was aligned.
-			 */
-			req = ceph_osdc_new_request(osdc, &ci->i_layout,
-					ci->i_vino, first ? first_pos : last_pos,
-					&read_len, 0, (first && last) ? 2 : 1,
-					CEPH_OSD_OP_SPARSE_READ, CEPH_OSD_FLAG_READ,
-					NULL, ci->i_truncate_seq,
-					ci->i_truncate_size, false);
-			if (IS_ERR(req)) {
-				ceph_release_page_vector(pages, num_pages);
-				ret = PTR_ERR(req);
-				break;
-			}
-
-			/* Something is misaligned! */
-			if (read_len != CEPH_FSCRYPT_BLOCK_SIZE) {
-				ceph_osdc_put_request(req);
-				ceph_release_page_vector(pages, num_pages);
-				ret = -EIO;
-				break;
-			}
-
-			/* Add extent for first block? */
-			op = &req->r_ops[0];
-
-			if (first) {
-				osd_req_op_extent_osd_data_pages(req, 0, pages,
-							 CEPH_FSCRYPT_BLOCK_SIZE,
-							 offset_in_page(first_pos),
-							 false, false);
-				/* We only expect a single extent here */
-				ret = __ceph_alloc_sparse_ext_map(op, 1);
-				if (ret) {
-					ceph_osdc_put_request(req);
-					ceph_release_page_vector(pages, num_pages);
-					break;
-				}
-			}
-
-			/* Add extent for last block */
-			if (last) {
-				/* Init the other extent if first extent has been used */
-				if (first) {
-					op = &req->r_ops[1];
-					osd_req_op_extent_init(req, 1,
-							CEPH_OSD_OP_SPARSE_READ,
-							last_pos, CEPH_FSCRYPT_BLOCK_SIZE,
-							ci->i_truncate_size,
-							ci->i_truncate_seq);
-				}
-
-				ret = __ceph_alloc_sparse_ext_map(op, 1);
-				if (ret) {
-					ceph_osdc_put_request(req);
-					ceph_release_page_vector(pages, num_pages);
-					break;
-				}
-
-				osd_req_op_extent_osd_data_pages(req, first ? 1 : 0,
-							&pages[num_pages - 1],
-							CEPH_FSCRYPT_BLOCK_SIZE,
-							offset_in_page(last_pos),
-							false, false);
-			}
-
-			ceph_osdc_start_request(osdc, req);
-			ret = ceph_osdc_wait_request(osdc, req);
-
-			/* FIXME: length field is wrong if there are 2 extents */
-			ceph_update_read_metrics(&fsc->mdsc->metric,
-						 req->r_start_latency,
-						 req->r_end_latency,
-						 read_len, ret);
-
-			/* Ok if object is not already present */
-			if (ret == -ENOENT) {
-				/*
-				 * If there is no object, then we can't assert
-				 * on its version. Set it to 0, and we'll use an
-				 * exclusive create instead.
-				 */
-				ceph_osdc_put_request(req);
-				ret = 0;
-
-				/*
-				 * zero out the soon-to-be uncopied parts of the
-				 * first and last pages.
-				 */
-				if (first)
-					zero_user_segment(pages[0], 0,
-							  offset_in_page(first_pos));
-				if (last)
-					zero_user_segment(pages[num_pages - 1],
-							  offset_in_page(last_pos),
-							  PAGE_SIZE);
-			} else {
-				if (ret < 0) {
-					ceph_osdc_put_request(req);
-					ceph_release_page_vector(pages, num_pages);
-					break;
-				}
-
-				op = &req->r_ops[0];
-				if (op->extent.sparse_ext_cnt == 0) {
-					if (first)
-						zero_user_segment(pages[0], 0,
-								  offset_in_page(first_pos));
-					else
-						zero_user_segment(pages[num_pages - 1],
-								  offset_in_page(last_pos),
-								  PAGE_SIZE);
-				} else if (op->extent.sparse_ext_cnt != 1 ||
-					   ceph_sparse_ext_map_end(op) !=
-						CEPH_FSCRYPT_BLOCK_SIZE) {
-					ret = -EIO;
-					ceph_osdc_put_request(req);
-					ceph_release_page_vector(pages, num_pages);
-					break;
-				}
-
-				if (first && last) {
-					op = &req->r_ops[1];
-					if (op->extent.sparse_ext_cnt == 0) {
-						zero_user_segment(pages[num_pages - 1],
-								  offset_in_page(last_pos),
-								  PAGE_SIZE);
-					} else if (op->extent.sparse_ext_cnt != 1 ||
-						   ceph_sparse_ext_map_end(op) !=
-							CEPH_FSCRYPT_BLOCK_SIZE) {
-						ret = -EIO;
-						ceph_osdc_put_request(req);
-						ceph_release_page_vector(pages, num_pages);
-						break;
-					}
-				}
-
-				/* Grab assert version. It must be non-zero. */
-				assert_ver = req->r_version;
-				WARN_ON_ONCE(ret > 0 && assert_ver == 0);
-
-				ceph_osdc_put_request(req);
-				if (first) {
-					ret = ceph_fscrypt_decrypt_block_inplace(inode,
-							pages[0], CEPH_FSCRYPT_BLOCK_SIZE,
-							offset_in_page(first_pos),
-							first_pos >> CEPH_FSCRYPT_BLOCK_SHIFT);
-					if (ret < 0) {
-						ceph_release_page_vector(pages, num_pages);
-						break;
-					}
-				}
-				if (last) {
-					ret = ceph_fscrypt_decrypt_block_inplace(inode,
-							pages[num_pages - 1],
-							CEPH_FSCRYPT_BLOCK_SIZE,
-							offset_in_page(last_pos),
-							last_pos >> CEPH_FSCRYPT_BLOCK_SHIFT);
-					if (ret < 0) {
-						ceph_release_page_vector(pages, num_pages);
-						break;
-					}
-				}
-			}
-		}
-
-		left = len;
-		off = offset_in_page(pos);
-		for (n = 0; n < num_pages; n++) {
-			size_t plen = min_t(size_t, left, PAGE_SIZE - off);
-
-			/* copy the data */
-			ret = copy_page_from_iter(pages[n], off, plen, from);
-			if (ret != plen) {
-				ret = -EFAULT;
-				break;
-			}
-			off = 0;
-			left -= ret;
-		}
-		if (ret < 0) {
-			doutc(cl, "write failed with %d\n", ret);
-			ceph_release_page_vector(pages, num_pages);
-			break;
-		}
-
-		if (IS_ENCRYPTED(inode)) {
-			ret = ceph_fscrypt_encrypt_pages(inode, pages,
-							 write_pos, write_len,
-							 GFP_KERNEL);
-			if (ret < 0) {
-				doutc(cl, "encryption failed with %d\n", ret);
-				ceph_release_page_vector(pages, num_pages);
-				break;
-			}
-		}
-
-		req = ceph_osdc_new_request(osdc, &ci->i_layout,
-					    ci->i_vino, write_pos, &write_len,
-					    rmw ? 1 : 0, rmw ? 2 : 1,
-					    CEPH_OSD_OP_WRITE,
-					    CEPH_OSD_FLAG_WRITE,
-					    snapc, ci->i_truncate_seq,
-					    ci->i_truncate_size, false);
-		if (IS_ERR(req)) {
-			ret = PTR_ERR(req);
-			ceph_release_page_vector(pages, num_pages);
-			break;
-		}
-
-		doutc(cl, "write op %lld~%llu\n", write_pos, write_len);
-		osd_req_op_extent_osd_data_pages(req, rmw ? 1 : 0, pages, write_len,
-						 offset_in_page(write_pos), false,
-						 true);
-		req->r_inode = inode;
-		req->r_mtime = mtime;
-
-		/* Set up the assertion */
-		if (rmw) {
-			/*
-			 * Set up the assertion. If we don't have a version
-			 * number, then the object doesn't exist yet. Use an
-			 * exclusive create instead of a version assertion in
-			 * that case.
-			 */
-			if (assert_ver) {
-				osd_req_op_init(req, 0, CEPH_OSD_OP_ASSERT_VER, 0);
-				req->r_ops[0].assert_ver.ver = assert_ver;
-			} else {
-				osd_req_op_init(req, 0, CEPH_OSD_OP_CREATE,
-						CEPH_OSD_OP_FLAG_EXCL);
-			}
-		}
-
-		ceph_osdc_start_request(osdc, req);
-		ret = ceph_osdc_wait_request(osdc, req);
-
-		ceph_update_write_metrics(&fsc->mdsc->metric, req->r_start_latency,
-					  req->r_end_latency, len, ret);
-		ceph_osdc_put_request(req);
-		if (ret != 0) {
-			doutc(cl, "osd write returned %d\n", ret);
-			/* Version changed! Must re-do the rmw cycle */
-			if ((assert_ver && (ret == -ERANGE || ret == -EOVERFLOW)) ||
-			    (!assert_ver && ret == -EEXIST)) {
-				/* We should only ever see this on a rmw */
-				WARN_ON_ONCE(!rmw);
-
-				/* The version should never go backward */
-				WARN_ON_ONCE(ret == -EOVERFLOW);
-
-				*from = saved_iter;
-
-				/* FIXME: limit number of times we loop? */
-				continue;
-			}
-			ceph_set_error_write(ci);
-			break;
-		}
-
-		ceph_clear_error_write(ci);
-
-		/*
-		 * We successfully wrote to a range of the file. Declare
-		 * that region of the pagecache invalid.
-		 */
-		ret = invalidate_inode_pages2_range(
-				inode->i_mapping,
-				pos >> PAGE_SHIFT,
-				(pos + len - 1) >> PAGE_SHIFT);
-		if (ret < 0) {
-			doutc(cl, "invalidate_inode_pages2_range returned %d\n",
-			      ret);
-			ret = 0;
-		}
-		pos += len;
-		written += len;
-		doutc(cl, "written %d\n", written);
-		if (pos > i_size_read(inode)) {
-			check_caps = ceph_inode_set_size(inode, pos);
-			if (check_caps)
-				ceph_check_caps(ceph_inode(inode),
-						CHECK_CAPS_AUTHONLY);
-		}
-
-	}
-
-	if (ret != -EOLDSNAPC && written > 0) {
-		ret = written;
-		iocb->ki_pos = pos;
-	}
-	doutc(cl, "returning %d\n", ret);
-	return ret;
-}
-
-/*
- * Wrap generic_file_aio_read with checks for cap bits on the inode.
- * Atomically grab references, so that those bits are not released
- * back to the MDS mid-read.
- *
- * Hmm, the sync read case isn't actually async... should it be?
- */
-static ssize_t ceph_read_iter(struct kiocb *iocb, struct iov_iter *to)
-{
-	struct file *filp = iocb->ki_filp;
-	struct ceph_file_info *fi = filp->private_data;
-	size_t len = iov_iter_count(to);
-	struct inode *inode = file_inode(filp);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	bool direct_lock = iocb->ki_flags & IOCB_DIRECT;
-	struct ceph_client *cl = ceph_inode_to_client(inode);
-	ssize_t ret;
-	int want = 0, got = 0;
-	int retry_op = 0, read = 0;
-
-again:
-	doutc(cl, "%llu~%u trying to get caps on %p %llx.%llx\n",
-	      iocb->ki_pos, (unsigned)len, inode, ceph_vinop(inode));
-
-	if (ceph_inode_is_shutdown(inode))
-		return -ESTALE;
-
-	if (direct_lock)
-		ceph_start_io_direct(inode);
-	else
-		ceph_start_io_read(inode);
-
-	if (!(fi->flags & CEPH_F_SYNC) && !direct_lock)
-		want |= CEPH_CAP_FILE_CACHE;
-	if (fi->fmode & CEPH_FILE_MODE_LAZY)
-		want |= CEPH_CAP_FILE_LAZYIO;
-
-	ret = ceph_get_caps(filp, CEPH_CAP_FILE_RD, want, -1, &got);
-	if (ret < 0) {
-		if (direct_lock)
-			ceph_end_io_direct(inode);
-		else
-			ceph_end_io_read(inode);
-		return ret;
-	}
-
-	if ((got & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) == 0 ||
-	    (iocb->ki_flags & IOCB_DIRECT) ||
-	    (fi->flags & CEPH_F_SYNC)) {
-
-		doutc(cl, "sync %p %llx.%llx %llu~%u got cap refs on %s\n",
-		      inode, ceph_vinop(inode), iocb->ki_pos, (unsigned)len,
-		      ceph_cap_string(got));
-
-		if (!ceph_has_inline_data(ci)) {
-			if (!retry_op &&
-			    (iocb->ki_flags & IOCB_DIRECT) &&
-			    !IS_ENCRYPTED(inode)) {
-				ret = ceph_direct_read_write(iocb, to,
-							     NULL, NULL);
-				if (ret >= 0 && ret < len)
-					retry_op = CHECK_EOF;
-			} else {
-				ret = ceph_sync_read(iocb, to, &retry_op);
-			}
-		} else {
-			retry_op = READ_INLINE;
-		}
-	} else {
-		doutc(cl, "async %p %llx.%llx %llu~%u got cap refs on %s\n",
-		      inode, ceph_vinop(inode), iocb->ki_pos, (unsigned)len,
-		      ceph_cap_string(got));
-		ret = generic_file_read_iter(iocb, to);
-	}
-
-	doutc(cl, "%p %llx.%llx dropping cap refs on %s = %d\n",
-	      inode, ceph_vinop(inode), ceph_cap_string(got), (int)ret);
-	ceph_put_cap_refs(ci, got);
-
-	if (direct_lock)
-		ceph_end_io_direct(inode);
-	else
-		ceph_end_io_read(inode);
-
-	if (retry_op > HAVE_RETRIED && ret >= 0) {
-		int statret;
-		struct page *page = NULL;
-		loff_t i_size;
-		int mask = CEPH_STAT_CAP_SIZE;
-		if (retry_op == READ_INLINE) {
-			page = __page_cache_alloc(GFP_KERNEL);
-			if (!page)
-				return -ENOMEM;
-
-			mask = CEPH_STAT_CAP_INLINE_DATA;
-		}
-
-		statret = __ceph_do_getattr(inode, page, mask, !!page);
-		if (statret < 0) {
-			if (page)
-				__free_page(page);
-			if (statret == -ENODATA) {
-				BUG_ON(retry_op != READ_INLINE);
-				goto again;
-			}
-			return statret;
-		}
-
-		i_size = i_size_read(inode);
-		if (retry_op == READ_INLINE) {
-			BUG_ON(ret > 0 || read > 0);
-			if (iocb->ki_pos < i_size &&
-			    iocb->ki_pos < PAGE_SIZE) {
-				loff_t end = min_t(loff_t, i_size,
-						   iocb->ki_pos + len);
-				end = min_t(loff_t, end, PAGE_SIZE);
-				if (statret < end)
-					zero_user_segment(page, statret, end);
-				ret = copy_page_to_iter(page,
-						iocb->ki_pos & ~PAGE_MASK,
-						end - iocb->ki_pos, to);
-				iocb->ki_pos += ret;
-				read += ret;
-			}
-			if (iocb->ki_pos < i_size && read < len) {
-				size_t zlen = min_t(size_t, len - read,
-						    i_size - iocb->ki_pos);
-				ret = iov_iter_zero(zlen, to);
-				iocb->ki_pos += ret;
-				read += ret;
-			}
-			__free_pages(page, 0);
-			return read;
-		}
-
-		/* hit EOF or hole? */
-		if (retry_op == CHECK_EOF && iocb->ki_pos < i_size &&
-		    ret < len) {
-			doutc(cl, "may hit hole, ppos %lld < size %lld, reading more\n",
-			      iocb->ki_pos, i_size);
-
-			read += ret;
-			len -= ret;
-			retry_op = HAVE_RETRIED;
-			goto again;
-		}
-	}
-
-	if (ret >= 0)
-		ret += read;
-
-	return ret;
-}
-#endif // TODO: Remove after netfs conversion
-
 /*
  * Wrap filemap_splice_read with checks for cap bits on the inode.
  * Atomically grab references, so that those bits are not released
@@ -2298,203 +991,6 @@ static ssize_t ceph_splice_read(struct file *in, loff_t *ppos,
 	return ret;
 }
 
-#if 0 // TODO: Remove after netfs conversion
-/*
- * Take cap references to avoid releasing caps to MDS mid-write.
- *
- * If we are synchronous, and write with an old snap context, the OSD
- * may return EOLDSNAPC.  In that case, retry the write.. _after_
- * dropping our cap refs and allowing the pending snap to logically
- * complete _before_ this write occurs.
- *
- * If we are near ENOSPC, write synchronously.
- */
-static ssize_t ceph_write_iter(struct kiocb *iocb, struct iov_iter *from)
-{
-	struct file *file = iocb->ki_filp;
-	struct ceph_file_info *fi = file->private_data;
-	struct inode *inode = file_inode(file);
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_fs_client *fsc = ceph_inode_to_fs_client(inode);
-	struct ceph_client *cl = fsc->client;
-	struct ceph_osd_client *osdc = &fsc->client->osdc;
-	struct ceph_cap_flush *prealloc_cf;
-	ssize_t count, written = 0;
-	int err, want = 0, got;
-	bool direct_lock = false;
-	u32 map_flags;
-	u64 pool_flags;
-	loff_t pos;
-	loff_t limit = max(i_size_read(inode), fsc->max_file_size);
-
-	if (ceph_inode_is_shutdown(inode))
-		return -ESTALE;
-
-	if (ceph_snap(inode) != CEPH_NOSNAP)
-		return -EROFS;
-
-	prealloc_cf = ceph_alloc_cap_flush();
-	if (!prealloc_cf)
-		return -ENOMEM;
-
-	if ((iocb->ki_flags & (IOCB_DIRECT | IOCB_APPEND)) == IOCB_DIRECT)
-		direct_lock = true;
-
-retry_snap:
-	if (direct_lock)
-		ceph_start_io_direct(inode);
-	else
-		ceph_start_io_write(inode);
-
-	if (iocb->ki_flags & IOCB_APPEND) {
-		err = ceph_do_getattr(inode, CEPH_STAT_CAP_SIZE, false);
-		if (err < 0)
-			goto out;
-	}
-
-	err = generic_write_checks(iocb, from);
-	if (err <= 0)
-		goto out;
-
-	pos = iocb->ki_pos;
-	if (unlikely(pos >= limit)) {
-		err = -EFBIG;
-		goto out;
-	} else {
-		iov_iter_truncate(from, limit - pos);
-	}
-
-	count = iov_iter_count(from);
-	if (ceph_quota_is_max_bytes_exceeded(inode, pos + count)) {
-		err = -EDQUOT;
-		goto out;
-	}
-
-	down_read(&osdc->lock);
-	map_flags = osdc->osdmap->flags;
-	pool_flags = ceph_pg_pool_flags(osdc->osdmap, ci->i_layout.pool_id);
-	up_read(&osdc->lock);
-	if ((map_flags & CEPH_OSDMAP_FULL) ||
-	    (pool_flags & CEPH_POOL_FLAG_FULL)) {
-		err = -ENOSPC;
-		goto out;
-	}
-
-	err = file_remove_privs(file);
-	if (err)
-		goto out;
-
-	doutc(cl, "%p %llx.%llx %llu~%zd getting caps. i_size %llu\n",
-	      inode, ceph_vinop(inode), pos, count,
-	      i_size_read(inode));
-	if (!(fi->flags & CEPH_F_SYNC) && !direct_lock)
-		want |= CEPH_CAP_FILE_BUFFER;
-	if (fi->fmode & CEPH_FILE_MODE_LAZY)
-		want |= CEPH_CAP_FILE_LAZYIO;
-	got = 0;
-	err = ceph_get_caps(file, CEPH_CAP_FILE_WR, want, pos + count, &got);
-	if (err < 0)
-		goto out;
-
-	err = file_update_time(file);
-	if (err)
-		goto out_caps;
-
-	inode_inc_iversion_raw(inode);
-
-	doutc(cl, "%p %llx.%llx %llu~%zd got cap refs on %s\n",
-	      inode, ceph_vinop(inode), pos, count, ceph_cap_string(got));
-
-	if ((got & (CEPH_CAP_FILE_BUFFER|CEPH_CAP_FILE_LAZYIO)) == 0 ||
-	    (iocb->ki_flags & IOCB_DIRECT) || (fi->flags & CEPH_F_SYNC) ||
-	    (ci->i_ceph_flags & CEPH_I_ERROR_WRITE)) {
-		struct ceph_snap_context *snapc;
-		struct iov_iter data;
-
-		spin_lock(&ci->i_ceph_lock);
-		if (__ceph_have_pending_cap_snap(ci)) {
-			struct ceph_cap_snap *capsnap =
-					list_last_entry(&ci->i_cap_snaps,
-							struct ceph_cap_snap,
-							ci_item);
-			snapc = ceph_get_snap_context(capsnap->context);
-		} else {
-			BUG_ON(!ci->i_head_snapc);
-			snapc = ceph_get_snap_context(ci->i_head_snapc);
-		}
-		spin_unlock(&ci->i_ceph_lock);
-
-		/* we might need to revert back to that point */
-		data = *from;
-		if ((iocb->ki_flags & IOCB_DIRECT) && !IS_ENCRYPTED(inode))
-			written = ceph_direct_read_write(iocb, &data, snapc,
-							 &prealloc_cf);
-		else
-			written = ceph_sync_write(iocb, &data, pos, snapc);
-		if (direct_lock)
-			ceph_end_io_direct(inode);
-		else
-			ceph_end_io_write(inode);
-		if (written > 0)
-			iov_iter_advance(from, written);
-		ceph_put_snap_context(snapc);
-	} else {
-		/*
-		 * No need to acquire the i_truncate_mutex. Because
-		 * the MDS revokes Fwb caps before sending truncate
-		 * message to us. We can't get Fwb cap while there
-		 * are pending vmtruncate. So write and vmtruncate
-		 * can not run at the same time
-		 */
-		written = generic_perform_write(iocb, from);
-		ceph_end_io_write(inode);
-	}
-
-	if (written >= 0) {
-		int dirty;
-
-		spin_lock(&ci->i_ceph_lock);
-		dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR,
-					       &prealloc_cf);
-		spin_unlock(&ci->i_ceph_lock);
-		if (dirty)
-			__mark_inode_dirty(inode, dirty);
-		if (ceph_quota_is_max_bytes_approaching(inode, iocb->ki_pos))
-			ceph_check_caps(ci, CHECK_CAPS_FLUSH);
-	}
-
-	doutc(cl, "%p %llx.%llx %llu~%u  dropping cap refs on %s\n",
-	      inode, ceph_vinop(inode), pos, (unsigned)count,
-	      ceph_cap_string(got));
-	ceph_put_cap_refs(ci, got);
-
-	if (written == -EOLDSNAPC) {
-		doutc(cl, "%p %llx.%llx %llu~%u" "got EOLDSNAPC, retrying\n",
-		      inode, ceph_vinop(inode), pos, (unsigned)count);
-		goto retry_snap;
-	}
-
-	if (written >= 0) {
-		if ((map_flags & CEPH_OSDMAP_NEARFULL) ||
-		    (pool_flags & CEPH_POOL_FLAG_NEARFULL))
-			iocb->ki_flags |= IOCB_DSYNC;
-		written = generic_write_sync(iocb, written);
-	}
-
-	goto out_unlocked;
-out_caps:
-	ceph_put_cap_refs(ci, got);
-out:
-	if (direct_lock)
-		ceph_end_io_direct(inode);
-	else
-		ceph_end_io_write(inode);
-out_unlocked:
-	ceph_free_cap_flush(prealloc_cf);
-	return written ? written : err;
-}
-#endif // TODO: Remove after netfs conversion
-
 /*
  * llseek.  be sure to verify file size on SEEK_END.
  */
diff --git a/fs/ceph/super.h b/fs/ceph/super.h
index acd5c4821ded..97eddbf9dae9 100644
--- a/fs/ceph/super.h
+++ b/fs/ceph/super.h
@@ -470,19 +470,6 @@ struct ceph_inode_info {
 #endif
 };
 
-struct ceph_netfs_request_data { // TODO: Remove
-	int caps;
-
-	/*
-	 * Maximum size of a file readahead request.
-	 * The fadvise could update the bdi's default ra_pages.
-	 */
-	unsigned int file_ra_pages;
-
-	/* Set it if fadvise disables file readahead entirely */
-	bool file_ra_disabled;
-};
-
 struct ceph_io_request {
 	struct netfs_io_request rreq;
 	u64 rmw_assert_version;
@@ -1260,9 +1247,6 @@ extern void __ceph_touch_fmode(struct ceph_inode_info *ci,
 			       struct ceph_mds_client *mdsc, int fmode);
 
 /* addr.c */
-#if 0 // TODO: Remove after netfs conversion
-extern const struct netfs_request_ops ceph_netfs_ops;
-#endif // TODO: Remove after netfs conversion
 bool ceph_dirty_folio(struct address_space *mapping, struct folio *folio);
 extern int ceph_mmap(struct file *file, struct vm_area_struct *vma);
 extern int ceph_uninline_data(struct file *file);
@@ -1293,11 +1277,6 @@ extern int ceph_renew_caps(struct inode *inode, int fmode);
 extern int ceph_open(struct inode *inode, struct file *file);
 extern int ceph_atomic_open(struct inode *dir, struct dentry *dentry,
 			    struct file *file, unsigned flags, umode_t mode);
-#if 0 // TODO: Remove after netfs conversion
-extern ssize_t __ceph_sync_read(struct inode *inode, loff_t *ki_pos,
-				struct iov_iter *to, int *retry_op,
-				u64 *last_objver);
-#endif
 extern int ceph_release(struct inode *inode, struct file *filp);
 extern void ceph_fill_inline_data(struct inode *inode, struct page *locked_page,
 				  char *data, size_t len);
