1// SPDX-License-Identifier: GPL-2.0-or-later
  2/* Cache data I/O routines
  3 *
  4 * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
  5 * Written by David Howells (dhowells@redhat.com)
  6 */
  7#define FSCACHE_DEBUG_LEVEL OPERATION
  8#include <linux/fscache-cache.h>
  9#include <linux/uio.h>
 10#include <linux/bvec.h>
 11#include <linux/slab.h>
 12#include "internal.h"
 13
 14/**
 15 * fscache_wait_for_operation - Wait for an object become accessible
 16 * @cres: The cache resources for the operation being performed
 17 * @want_state: The minimum state the object must be at
 18 *
 19 * See if the target cache object is at the specified minimum state of
 20 * accessibility yet, and if not, wait for it.
 21 */
 22bool fscache_wait_for_operation(struct netfs_cache_resources *cres,
 23				enum fscache_want_state want_state)
 24{
 25	struct fscache_cookie *cookie = fscache_cres_cookie(cres);
 26	enum fscache_cookie_state state;
 27
 28again:
 29	if (!fscache_cache_is_live(cookie->volume->cache)) {
 30		_leave(" [broken]");
 31		return false;
 32	}
 33
 34	state = fscache_cookie_state(cookie);
 35	_enter("c=%08x{%u},%x", cookie->debug_id, state, want_state);
 36
 37	switch (state) {
 38	case FSCACHE_COOKIE_STATE_CREATING:
 39	case FSCACHE_COOKIE_STATE_INVALIDATING:
 40		if (want_state == FSCACHE_WANT_PARAMS)
 41			goto ready; /* There can be no content */
 42		fallthrough;
 43	case FSCACHE_COOKIE_STATE_LOOKING_UP:
 44	case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
 45		wait_var_event(&cookie->state,
 46			       fscache_cookie_state(cookie) != state);
 47		goto again;
 48
 49	case FSCACHE_COOKIE_STATE_ACTIVE:
 50		goto ready;
 51	case FSCACHE_COOKIE_STATE_DROPPED:
 52	case FSCACHE_COOKIE_STATE_RELINQUISHING:
 53	default:
 54		_leave(" [not live]");
 55		return false;
 56	}
 57
 58ready:
 59	if (!cres->cache_priv2)
 60		return cookie->volume->cache->ops->begin_operation(cres, want_state);
 61	return true;
 62}
 63EXPORT_SYMBOL(fscache_wait_for_operation);
 64
 65/*
 66 * Begin an I/O operation on the cache, waiting till we reach the right state.
 67 *
 68 * Attaches the resources required to the operation resources record.
 69 */
 70static int fscache_begin_operation(struct netfs_cache_resources *cres,
 71				   struct fscache_cookie *cookie,
 72				   enum fscache_want_state want_state,
 73				   enum fscache_access_trace why)
 74{
 75	enum fscache_cookie_state state;
 76	long timeo;
 77	bool once_only = false;
 78
 79	cres->ops		= NULL;
 80	cres->cache_priv	= cookie;
 81	cres->cache_priv2	= NULL;
 82	cres->debug_id		= cookie->debug_id;
 83	cres->inval_counter	= cookie->inval_counter;
 84
 85	if (!fscache_begin_cookie_access(cookie, why)) {
 86		cres->cache_priv = NULL;
 87		return -ENOBUFS;
 88	}
 89
 90again:
 91	spin_lock(&cookie->lock);
 92
 93	state = fscache_cookie_state(cookie);
 94	_enter("c=%08x{%u},%x", cookie->debug_id, state, want_state);
 95
 96	switch (state) {
 97	case FSCACHE_COOKIE_STATE_LOOKING_UP:
 98	case FSCACHE_COOKIE_STATE_LRU_DISCARDING:
 99	case FSCACHE_COOKIE_STATE_INVALIDATING:
100		goto wait_for_file_wrangling;
101	case FSCACHE_COOKIE_STATE_CREATING:
102		if (want_state == FSCACHE_WANT_PARAMS)
103			goto ready; /* There can be no content */
104		goto wait_for_file_wrangling;
105	case FSCACHE_COOKIE_STATE_ACTIVE:
106		goto ready;
107	case FSCACHE_COOKIE_STATE_DROPPED:
108	case FSCACHE_COOKIE_STATE_RELINQUISHING:
109		WARN(1, "Can't use cookie in state %u\n", cookie->state);
110		goto not_live;
111	default:
112		goto not_live;
113	}
114
115ready:
116	spin_unlock(&cookie->lock);
117	if (!cookie->volume->cache->ops->begin_operation(cres, want_state))
118		goto failed;
119	return 0;
120
121wait_for_file_wrangling:
122	spin_unlock(&cookie->lock);
123	trace_fscache_access(cookie->debug_id, refcount_read(&cookie->ref),
124			     atomic_read(&cookie->n_accesses),
125			     fscache_access_io_wait);
126	timeo = wait_var_event_timeout(&cookie->state,
127				       fscache_cookie_state(cookie) != state, 20 * HZ);
128	if (timeo <= 1 && !once_only) {
129		pr_warn("%s: cookie state change wait timed out: cookie->state=%u state=%u",
130			__func__, fscache_cookie_state(cookie), state);
131		fscache_print_cookie(cookie, 'O');
132		once_only = true;
133	}
134	goto again;
135
136not_live:
137	spin_unlock(&cookie->lock);
138failed:
139	cres->cache_priv = NULL;
140	cres->ops = NULL;
141	fscache_end_cookie_access(cookie, fscache_access_io_not_live);
142	_leave(" = -ENOBUFS");
143	return -ENOBUFS;
144}
145
146int __fscache_begin_read_operation(struct netfs_cache_resources *cres,
147				   struct fscache_cookie *cookie)
148{
149	return fscache_begin_operation(cres, cookie, FSCACHE_WANT_PARAMS,
150				       fscache_access_io_read);
151}
152EXPORT_SYMBOL(__fscache_begin_read_operation);
153
154int __fscache_begin_write_operation(struct netfs_cache_resources *cres,
155				    struct fscache_cookie *cookie)
156{
157	return fscache_begin_operation(cres, cookie, FSCACHE_WANT_PARAMS,
158				       fscache_access_io_write);
159}
160EXPORT_SYMBOL(__fscache_begin_write_operation);
161
162struct fscache_write_request {
163	struct netfs_cache_resources cache_resources;
164	struct address_space	*mapping;
165	loff_t			start;
166	size_t			len;
167	bool			set_bits;
168	bool			using_pgpriv2;
169	netfs_io_terminated_t	term_func;
170	void			*term_func_priv;
171};
172
173void __fscache_clear_page_bits(struct address_space *mapping,
174			       loff_t start, size_t len)
175{
176	pgoff_t first = start / PAGE_SIZE;
177	pgoff_t last = (start + len - 1) / PAGE_SIZE;
178	struct page *page;
179
180	if (len) {
181		XA_STATE(xas, &mapping->i_pages, first);
182
183		rcu_read_lock();
184		xas_for_each(&xas, page, last) {
185			folio_end_private_2(page_folio(page));
186		}
187		rcu_read_unlock();
188	}
189}
190EXPORT_SYMBOL(__fscache_clear_page_bits);
191
192/*
193 * Deal with the completion of writing the data to the cache.
194 */
195static void fscache_wreq_done(void *priv, ssize_t transferred_or_error,
196			      bool was_async)
197{
198	struct fscache_write_request *wreq = priv;
199
200	if (wreq->using_pgpriv2)
201		fscache_clear_page_bits(wreq->mapping, wreq->start, wreq->len,
202					wreq->set_bits);
203
204	if (wreq->term_func)
205		wreq->term_func(wreq->term_func_priv, transferred_or_error,
206				was_async);
207	fscache_end_operation(&wreq->cache_resources);
208	kfree(wreq);
209}
210
211void __fscache_write_to_cache(struct fscache_cookie *cookie,
212			      struct address_space *mapping,
213			      loff_t start, size_t len, loff_t i_size,
214			      netfs_io_terminated_t term_func,
215			      void *term_func_priv,
216			      bool using_pgpriv2, bool cond)
217{
218	struct fscache_write_request *wreq;
219	struct netfs_cache_resources *cres;
220	struct iov_iter iter;
221	int ret = -ENOBUFS;
222
223	if (len == 0)
224		goto abandon;
225
226	_enter("%llx,%zx", start, len);
227
228	wreq = kzalloc(sizeof(struct fscache_write_request), GFP_NOFS);
229	if (!wreq)
230		goto abandon;
231	wreq->mapping		= mapping;
232	wreq->start		= start;
233	wreq->len		= len;
234	wreq->using_pgpriv2	= using_pgpriv2;
235	wreq->set_bits		= cond;
236	wreq->term_func		= term_func;
237	wreq->term_func_priv	= term_func_priv;
238
239	cres = &wreq->cache_resources;
240	if (fscache_begin_operation(cres, cookie, FSCACHE_WANT_WRITE,
241				    fscache_access_io_write) < 0)
242		goto abandon_free;
243
244	ret = cres->ops->prepare_write(cres, &start, &len, len, i_size, false);
245	if (ret < 0)
246		goto abandon_end;
247
248	/* TODO: Consider clearing page bits now for space the write isn't
249	 * covering.  This is more complicated than it appears when THPs are
250	 * taken into account.
251	 */
252
253	iov_iter_xarray(&iter, ITER_SOURCE, &mapping->i_pages, start, len);
254	fscache_write(cres, start, &iter, fscache_wreq_done, wreq);
255	return;
256
257abandon_end:
258	return fscache_wreq_done(wreq, ret, false);
259abandon_free:
260	kfree(wreq);
261abandon:
262	if (using_pgpriv2)
263		fscache_clear_page_bits(mapping, start, len, cond);
264	if (term_func)
265		term_func(term_func_priv, ret, false);
266}
267EXPORT_SYMBOL(__fscache_write_to_cache);
268
269/*
270 * Change the size of a backing object.
271 */
272void __fscache_resize_cookie(struct fscache_cookie *cookie, loff_t new_size)
273{
274	struct netfs_cache_resources cres;
275
276	trace_fscache_resize(cookie, new_size);
277	if (fscache_begin_operation(&cres, cookie, FSCACHE_WANT_WRITE,
278				    fscache_access_io_resize) == 0) {
279		fscache_stat(&fscache_n_resizes);
280		set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &cookie->flags);
281
282		/* We cannot defer a resize as we need to do it inside the
283		 * netfs's inode lock so that we're serialised with respect to
284		 * writes.
285		 */
286		cookie->volume->cache->ops->resize_cookie(&cres, new_size);
287		fscache_end_operation(&cres);
288	} else {
289		fscache_stat(&fscache_n_resizes_null);
290	}
291}
292EXPORT_SYMBOL(__fscache_resize_cookie);