1// SPDX-License-Identifier: GPL-2.0-only
  2/* Miscellaneous routines.
  3 *
  4 * Copyright (C) 2023 Red Hat, Inc. All Rights Reserved.
  5 * Written by David Howells (dhowells@redhat.com)
  6 */
  7
  8#include <linux/swap.h>
  9#include "internal.h"
 10
 11/*
 12 * Make sure there's space in the rolling queue.
 13 */
 14struct folio_queue *netfs_buffer_make_space(struct netfs_io_request *rreq)
 15{
 16	struct folio_queue *tail = rreq->buffer_tail, *prev;
 17	unsigned int prev_nr_slots = 0;
 18
 19	if (WARN_ON_ONCE(!rreq->buffer && tail) ||
 20	    WARN_ON_ONCE(rreq->buffer && !tail))
 21		return ERR_PTR(-EIO);
 22
 23	prev = tail;
 24	if (prev) {
 25		if (!folioq_full(tail))
 26			return tail;
 27		prev_nr_slots = folioq_nr_slots(tail);
 28	}
 29
 30	tail = kmalloc(sizeof(*tail), GFP_NOFS);
 31	if (!tail)
 32		return ERR_PTR(-ENOMEM);
 33	netfs_stat(&netfs_n_folioq);
 34	folioq_init(tail);
 35	tail->prev = prev;
 36	if (prev)
 37		/* [!] NOTE: After we set prev->next, the consumer is entirely
 38		 * at liberty to delete prev.
 39		 */
 40		WRITE_ONCE(prev->next, tail);
 41
 42	rreq->buffer_tail = tail;
 43	if (!rreq->buffer) {
 44		rreq->buffer = tail;
 45		iov_iter_folio_queue(&rreq->io_iter, ITER_SOURCE, tail, 0, 0, 0);
 46	} else {
 47		/* Make sure we don't leave the master iterator pointing to a
 48		 * block that might get immediately consumed.
 49		 */
 50		if (rreq->io_iter.folioq == prev &&
 51		    rreq->io_iter.folioq_slot == prev_nr_slots) {
 52			rreq->io_iter.folioq = tail;
 53			rreq->io_iter.folioq_slot = 0;
 54		}
 55	}
 56	rreq->buffer_tail_slot = 0;
 57	return tail;
 58}
 59
 60/*
 61 * Append a folio to the rolling queue.
 62 */
 63int netfs_buffer_append_folio(struct netfs_io_request *rreq, struct folio *folio,
 64			      bool needs_put)
 65{
 66	struct folio_queue *tail;
 67	unsigned int slot, order = folio_order(folio);
 68
 69	tail = netfs_buffer_make_space(rreq);
 70	if (IS_ERR(tail))
 71		return PTR_ERR(tail);
 72
 73	rreq->io_iter.count += PAGE_SIZE << order;
 74
 75	slot = folioq_append(tail, folio);
 76	/* Store the counter after setting the slot. */
 77	smp_store_release(&rreq->buffer_tail_slot, slot);
 78	return 0;
 79}
 80
 81/*
 82 * Delete the head of a rolling queue.
 83 */
 84struct folio_queue *netfs_delete_buffer_head(struct netfs_io_request *wreq)
 85{
 86	struct folio_queue *head = wreq->buffer, *next = head->next;
 87
 88	if (next)
 89		next->prev = NULL;
 90	netfs_stat_d(&netfs_n_folioq);
 91	kfree(head);
 92	wreq->buffer = next;
 93	return next;
 94}
 95
 96/*
 97 * Clear out a rolling queue.
 98 */
 99void netfs_clear_buffer(struct netfs_io_request *rreq)
100{
101	struct folio_queue *p;
102
103	while ((p = rreq->buffer)) {
104		rreq->buffer = p->next;
105		for (int slot = 0; slot < folioq_count(p); slot++) {
106			struct folio *folio = folioq_folio(p, slot);
107			if (!folio)
108				continue;
109			if (folioq_is_marked(p, slot)) {
110				trace_netfs_folio(folio, netfs_folio_trace_put);
111				folio_put(folio);
112			}
113		}
114		netfs_stat_d(&netfs_n_folioq);
115		kfree(p);
116	}
117}
118
119/*
120 * Reset the subrequest iterator to refer just to the region remaining to be
121 * read.  The iterator may or may not have been advanced by socket ops or
122 * extraction ops to an extent that may or may not match the amount actually
123 * read.
124 */
125void netfs_reset_iter(struct netfs_io_subrequest *subreq)
126{
127	struct iov_iter *io_iter = &subreq->io_iter;
128	size_t remain = subreq->len - subreq->transferred;
129
130	if (io_iter->count > remain)
131		iov_iter_advance(io_iter, io_iter->count - remain);
132	else if (io_iter->count < remain)
133		iov_iter_revert(io_iter, remain - io_iter->count);
134	iov_iter_truncate(&subreq->io_iter, remain);
135}
136
137/**
138 * netfs_dirty_folio - Mark folio dirty and pin a cache object for writeback
139 * @mapping: The mapping the folio belongs to.
140 * @folio: The folio being dirtied.
141 *
142 * Set the dirty flag on a folio and pin an in-use cache object in memory so
143 * that writeback can later write to it.  This is intended to be called from
144 * the filesystem's ->dirty_folio() method.
145 *
146 * Return: true if the dirty flag was set on the folio, false otherwise.
147 */
148bool netfs_dirty_folio(struct address_space *mapping, struct folio *folio)
149{
150	struct inode *inode = mapping->host;
151	struct netfs_inode *ictx = netfs_inode(inode);
152	struct fscache_cookie *cookie = netfs_i_cookie(ictx);
153	bool need_use = false;
154
155	_enter("");
156
157	if (!filemap_dirty_folio(mapping, folio))
158		return false;
159	if (!fscache_cookie_valid(cookie))
160		return true;
161
162	if (!(inode->i_state & I_PINNING_NETFS_WB)) {
163		spin_lock(&inode->i_lock);
164		if (!(inode->i_state & I_PINNING_NETFS_WB)) {
165			inode->i_state |= I_PINNING_NETFS_WB;
166			need_use = true;
167		}
168		spin_unlock(&inode->i_lock);
169
170		if (need_use)
171			fscache_use_cookie(cookie, true);
172	}
173	return true;
174}
175EXPORT_SYMBOL(netfs_dirty_folio);
176
177/**
178 * netfs_unpin_writeback - Unpin writeback resources
179 * @inode: The inode on which the cookie resides
180 * @wbc: The writeback control
181 *
182 * Unpin the writeback resources pinned by netfs_dirty_folio().  This is
183 * intended to be called as/by the netfs's ->write_inode() method.
184 */
185int netfs_unpin_writeback(struct inode *inode, struct writeback_control *wbc)
186{
187	struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode));
188
189	if (wbc->unpinned_netfs_wb)
190		fscache_unuse_cookie(cookie, NULL, NULL);
191	return 0;
192}
193EXPORT_SYMBOL(netfs_unpin_writeback);
194
195/**
196 * netfs_clear_inode_writeback - Clear writeback resources pinned by an inode
197 * @inode: The inode to clean up
198 * @aux: Auxiliary data to apply to the inode
199 *
200 * Clear any writeback resources held by an inode when the inode is evicted.
201 * This must be called before clear_inode() is called.
202 */
203void netfs_clear_inode_writeback(struct inode *inode, const void *aux)
204{
205	struct fscache_cookie *cookie = netfs_i_cookie(netfs_inode(inode));
206
207	if (inode->i_state & I_PINNING_NETFS_WB) {
208		loff_t i_size = i_size_read(inode);
209		fscache_unuse_cookie(cookie, aux, &i_size);
210	}
211}
212EXPORT_SYMBOL(netfs_clear_inode_writeback);
213
214/**
215 * netfs_invalidate_folio - Invalidate or partially invalidate a folio
216 * @folio: Folio proposed for release
217 * @offset: Offset of the invalidated region
218 * @length: Length of the invalidated region
219 *
220 * Invalidate part or all of a folio for a network filesystem.  The folio will
221 * be removed afterwards if the invalidated region covers the entire folio.
222 */
223void netfs_invalidate_folio(struct folio *folio, size_t offset, size_t length)
224{
225	struct netfs_folio *finfo;
226	struct netfs_inode *ctx = netfs_inode(folio_inode(folio));
227	size_t flen = folio_size(folio);
228
229	_enter("{%lx},%zx,%zx", folio->index, offset, length);
230
231	if (offset == 0 && length == flen) {
232		unsigned long long i_size = i_size_read(&ctx->inode);
233		unsigned long long fpos = folio_pos(folio), end;
234
235		end = umin(fpos + flen, i_size);
236		if (fpos < i_size && end > ctx->zero_point)
237			ctx->zero_point = end;
238	}
239
240	folio_wait_private_2(folio); /* [DEPRECATED] */
241
242	if (!folio_test_private(folio))
243		return;
244
245	finfo = netfs_folio_info(folio);
246
247	if (offset == 0 && length >= flen)
248		goto erase_completely;
249
250	if (finfo) {
251		/* We have a partially uptodate page from a streaming write. */
252		unsigned int fstart = finfo->dirty_offset;
253		unsigned int fend = fstart + finfo->dirty_len;
254		unsigned int iend = offset + length;
255
256		if (offset >= fend)
257			return;
258		if (iend <= fstart)
259			return;
260
261		/* The invalidation region overlaps the data.  If the region
262		 * covers the start of the data, we either move along the start
263		 * or just erase the data entirely.
264		 */
265		if (offset <= fstart) {
266			if (iend >= fend)
267				goto erase_completely;
268			/* Move the start of the data. */
269			finfo->dirty_len = fend - iend;
270			finfo->dirty_offset = offset;
271			return;
272		}
273
274		/* Reduce the length of the data if the invalidation region
275		 * covers the tail part.
276		 */
277		if (iend >= fend) {
278			finfo->dirty_len = offset - fstart;
279			return;
280		}
281
282		/* A partial write was split.  The caller has already zeroed
283		 * it, so just absorb the hole.
284		 */
285	}
286	return;
287
288erase_completely:
289	netfs_put_group(netfs_folio_group(folio));
290	folio_detach_private(folio);
291	folio_clear_uptodate(folio);
292	kfree(finfo);
293	return;
294}
295EXPORT_SYMBOL(netfs_invalidate_folio);
296
297/**
298 * netfs_release_folio - Try to release a folio
299 * @folio: Folio proposed for release
300 * @gfp: Flags qualifying the release
301 *
302 * Request release of a folio and clean up its private state if it's not busy.
303 * Returns true if the folio can now be released, false if not
304 */
305bool netfs_release_folio(struct folio *folio, gfp_t gfp)
306{
307	struct netfs_inode *ctx = netfs_inode(folio_inode(folio));
308	unsigned long long end;
309
310	if (folio_test_dirty(folio))
311		return false;
312
313	end = umin(folio_pos(folio) + folio_size(folio), i_size_read(&ctx->inode));
314	if (end > ctx->zero_point)
315		ctx->zero_point = end;
316
317	if (folio_test_private(folio))
318		return false;
319	if (unlikely(folio_test_private_2(folio))) { /* [DEPRECATED] */
320		if (current_is_kswapd() || !(gfp & __GFP_FS))
321			return false;
322		folio_wait_private_2(folio);
323	}
324	fscache_note_page_release(netfs_i_cookie(ctx));
325	return true;
326}
327EXPORT_SYMBOL(netfs_release_folio);