1// SPDX-License-Identifier: GPL-2.0-or-later
2#include <linux/fdtable.h>
3#include <linux/anon_inodes.h>
4#include <linux/uio.h>
5#include "internal.h"
6
7static int cachefiles_ondemand_fd_release(struct inode *inode,
8					  struct file *file)
9{
10	struct cachefiles_object *object = file->private_data;
11	struct cachefiles_cache *cache = object->volume->cache;
12	int object_id = object->ondemand_id;
13	struct cachefiles_req *req;
14	XA_STATE(xas, &cache->reqs, 0);
15
16	xa_lock(&cache->reqs);
17	object->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED;
18
19	/*
20	 * Flush all pending READ requests since their completion depends on
21	 * anon_fd.
22	 */
23	xas_for_each(&xas, req, ULONG_MAX) {
24		if (req->msg.object_id == object_id &&
25		    req->msg.opcode == CACHEFILES_OP_READ) {
26			req->error = -EIO;
27			complete(&req->done);
28			xas_store(&xas, NULL);
29		}
30	}
31	xa_unlock(&cache->reqs);
32
33	xa_erase(&cache->ondemand_ids, object_id);
34	trace_cachefiles_ondemand_fd_release(object, object_id);
35	cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
36	cachefiles_put_unbind_pincount(cache);
37	return 0;
38}
39
40static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb,
41						 struct iov_iter *iter)
42{
43	struct cachefiles_object *object = kiocb->ki_filp->private_data;
44	struct cachefiles_cache *cache = object->volume->cache;
45	struct file *file = object->file;
46	size_t len = iter->count;
47	loff_t pos = kiocb->ki_pos;
48	const struct cred *saved_cred;
49	int ret;
50
51	if (!file)
52		return -ENOBUFS;
53
54	cachefiles_begin_secure(cache, &saved_cred);
55	ret = __cachefiles_prepare_write(object, file, &pos, &len, true);
56	cachefiles_end_secure(cache, saved_cred);
57	if (ret < 0)
58		return ret;
59
60	trace_cachefiles_ondemand_fd_write(object, file_inode(file), pos, len);
61	ret = __cachefiles_write(object, file, pos, iter, NULL, NULL);
62	if (!ret)
63		ret = len;
64
65	return ret;
66}
67
68static loff_t cachefiles_ondemand_fd_llseek(struct file *filp, loff_t pos,
69					    int whence)
70{
71	struct cachefiles_object *object = filp->private_data;
72	struct file *file = object->file;
73
74	if (!file)
75		return -ENOBUFS;
76
77	return vfs_llseek(file, pos, whence);
78}
79
80static long cachefiles_ondemand_fd_ioctl(struct file *filp, unsigned int ioctl,
81					 unsigned long arg)
82{
83	struct cachefiles_object *object = filp->private_data;
84	struct cachefiles_cache *cache = object->volume->cache;
85	struct cachefiles_req *req;
86	unsigned long id;
87
88	if (ioctl != CACHEFILES_IOC_READ_COMPLETE)
89		return -EINVAL;
90
91	if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
92		return -EOPNOTSUPP;
93
94	id = arg;
95	req = xa_erase(&cache->reqs, id);
96	if (!req)
97		return -EINVAL;
98
99	trace_cachefiles_ondemand_cread(object, id);
100	complete(&req->done);
101	return 0;
102}
103
104static const struct file_operations cachefiles_ondemand_fd_fops = {
105	.owner		= THIS_MODULE,
106	.release	= cachefiles_ondemand_fd_release,
107	.write_iter	= cachefiles_ondemand_fd_write_iter,
108	.llseek		= cachefiles_ondemand_fd_llseek,
109	.unlocked_ioctl	= cachefiles_ondemand_fd_ioctl,
110};
111
112/*
113 * OPEN request Completion (copen)
114 * - command: "copen <id>,<cache_size>"
115 *   <cache_size> indicates the object size if >=0, error code if negative
116 */
117int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args)
118{
119	struct cachefiles_req *req;
120	struct fscache_cookie *cookie;
121	char *pid, *psize;
122	unsigned long id;
123	long size;
124	int ret;
125
126	if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
127		return -EOPNOTSUPP;
128
129	if (!*args) {
130		pr_err("Empty id specified\n");
131		return -EINVAL;
132	}
133
134	pid = args;
135	psize = strchr(args, ',');
136	if (!psize) {
137		pr_err("Cache size is not specified\n");
138		return -EINVAL;
139	}
140
141	*psize = 0;
142	psize++;
143
144	ret = kstrtoul(pid, 0, &id);
145	if (ret)
146		return ret;
147
148	req = xa_erase(&cache->reqs, id);
149	if (!req)
150		return -EINVAL;
151
152	/* fail OPEN request if copen format is invalid */
153	ret = kstrtol(psize, 0, &size);
154	if (ret) {
155		req->error = ret;
156		goto out;
157	}
158
159	/* fail OPEN request if daemon reports an error */
160	if (size < 0) {
161		if (!IS_ERR_VALUE(size)) {
162			req->error = -EINVAL;
163			ret = -EINVAL;
164		} else {
165			req->error = size;
166			ret = 0;
167		}
168		goto out;
169	}
170
171	cookie = req->object->cookie;
172	cookie->object_size = size;
173	if (size)
174		clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
175	else
176		set_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
177	trace_cachefiles_ondemand_copen(req->object, id, size);
178
179out:
180	complete(&req->done);
181	return ret;
182}
183
184static int cachefiles_ondemand_get_fd(struct cachefiles_req *req)
185{
186	struct cachefiles_object *object;
187	struct cachefiles_cache *cache;
188	struct cachefiles_open *load;
189	struct file *file;
190	u32 object_id;
191	int ret, fd;
192
193	object = cachefiles_grab_object(req->object,
194			cachefiles_obj_get_ondemand_fd);
195	cache = object->volume->cache;
196
197	ret = xa_alloc_cyclic(&cache->ondemand_ids, &object_id, NULL,
198			      XA_LIMIT(1, INT_MAX),
199			      &cache->ondemand_id_next, GFP_KERNEL);
200	if (ret < 0)
201		goto err;
202
203	fd = get_unused_fd_flags(O_WRONLY);
204	if (fd < 0) {
205		ret = fd;
206		goto err_free_id;
207	}
208
209	file = anon_inode_getfile("[cachefiles]", &cachefiles_ondemand_fd_fops,
210				  object, O_WRONLY);
211	if (IS_ERR(file)) {
212		ret = PTR_ERR(file);
213		goto err_put_fd;
214	}
215
216	file->f_mode |= FMODE_PWRITE | FMODE_LSEEK;
217	fd_install(fd, file);
218
219	load = (void *)req->msg.data;
220	load->fd = fd;
221	req->msg.object_id = object_id;
222	object->ondemand_id = object_id;
223
224	cachefiles_get_unbind_pincount(cache);
225	trace_cachefiles_ondemand_open(object, &req->msg, load);
226	return 0;
227
228err_put_fd:
229	put_unused_fd(fd);
230err_free_id:
231	xa_erase(&cache->ondemand_ids, object_id);
232err:
233	cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
234	return ret;
235}
236
237ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache,
238					char __user *_buffer, size_t buflen)
239{
240	struct cachefiles_req *req;
241	struct cachefiles_msg *msg;
242	unsigned long id = 0;
243	size_t n;
244	int ret = 0;
245	XA_STATE(xas, &cache->reqs, cache->req_id_next);
246
247	/*
248	 * Cyclically search for a request that has not ever been processed,
249	 * to prevent requests from being processed repeatedly, and make
250	 * request distribution fair.
251	 */
252	xa_lock(&cache->reqs);
253	req = xas_find_marked(&xas, UINT_MAX, CACHEFILES_REQ_NEW);
254	if (!req && cache->req_id_next > 0) {
255		xas_set(&xas, 0);
256		req = xas_find_marked(&xas, cache->req_id_next - 1, CACHEFILES_REQ_NEW);
257	}
258	if (!req) {
259		xa_unlock(&cache->reqs);
260		return 0;
261	}
262
263	msg = &req->msg;
264	n = msg->len;
265
266	if (n > buflen) {
267		xa_unlock(&cache->reqs);
268		return -EMSGSIZE;
269	}
270
271	xas_clear_mark(&xas, CACHEFILES_REQ_NEW);
272	cache->req_id_next = xas.xa_index + 1;
273	xa_unlock(&cache->reqs);
274
275	id = xas.xa_index;
276	msg->msg_id = id;
277
278	if (msg->opcode == CACHEFILES_OP_OPEN) {
279		ret = cachefiles_ondemand_get_fd(req);
280		if (ret)
281			goto error;
282	}
283
284	if (copy_to_user(_buffer, msg, n) != 0) {
285		ret = -EFAULT;
286		goto err_put_fd;
287	}
288
289	/* CLOSE request has no reply */
290	if (msg->opcode == CACHEFILES_OP_CLOSE) {
291		xa_erase(&cache->reqs, id);
292		complete(&req->done);
293	}
294
295	return n;
296
297err_put_fd:
298	if (msg->opcode == CACHEFILES_OP_OPEN)
299		close_fd(((struct cachefiles_open *)msg->data)->fd);
300error:
301	xa_erase(&cache->reqs, id);
302	req->error = ret;
303	complete(&req->done);
304	return ret;
305}
306
307typedef int (*init_req_fn)(struct cachefiles_req *req, void *private);
308
309static int cachefiles_ondemand_send_req(struct cachefiles_object *object,
310					enum cachefiles_opcode opcode,
311					size_t data_len,
312					init_req_fn init_req,
313					void *private)
314{
315	struct cachefiles_cache *cache = object->volume->cache;
316	struct cachefiles_req *req;
317	XA_STATE(xas, &cache->reqs, 0);
318	int ret;
319
320	if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
321		return 0;
322
323	if (test_bit(CACHEFILES_DEAD, &cache->flags))
324		return -EIO;
325
326	req = kzalloc(sizeof(*req) + data_len, GFP_KERNEL);
327	if (!req)
328		return -ENOMEM;
329
330	req->object = object;
331	init_completion(&req->done);
332	req->msg.opcode = opcode;
333	req->msg.len = sizeof(struct cachefiles_msg) + data_len;
334
335	ret = init_req(req, private);
336	if (ret)
337		goto out;
338
339	do {
340		/*
341		 * Stop enqueuing the request when daemon is dying. The
342		 * following two operations need to be atomic as a whole.
343		 *   1) check cache state, and
344		 *   2) enqueue request if cache is alive.
345		 * Otherwise the request may be enqueued after xarray has been
346		 * flushed, leaving the orphan request never being completed.
347		 *
348		 * CPU 1			CPU 2
349		 * =====			=====
350		 *				test CACHEFILES_DEAD bit
351		 * set CACHEFILES_DEAD bit
352		 * flush requests in the xarray
353		 *				enqueue the request
354		 */
355		xas_lock(&xas);
356
357		if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
358			xas_unlock(&xas);
359			ret = -EIO;
360			goto out;
361		}
362
363		/* coupled with the barrier in cachefiles_flush_reqs() */
364		smp_mb();
365
366		if (opcode != CACHEFILES_OP_OPEN && object->ondemand_id <= 0) {
367			WARN_ON_ONCE(object->ondemand_id == 0);
368			xas_unlock(&xas);
369			ret = -EIO;
370			goto out;
371		}
372
373		xas.xa_index = 0;
374		xas_find_marked(&xas, UINT_MAX, XA_FREE_MARK);
375		if (xas.xa_node == XAS_RESTART)
376			xas_set_err(&xas, -EBUSY);
377		xas_store(&xas, req);
378		xas_clear_mark(&xas, XA_FREE_MARK);
379		xas_set_mark(&xas, CACHEFILES_REQ_NEW);
380		xas_unlock(&xas);
381	} while (xas_nomem(&xas, GFP_KERNEL));
382
383	ret = xas_error(&xas);
384	if (ret)
385		goto out;
386
387	wake_up_all(&cache->daemon_pollwq);
388	wait_for_completion(&req->done);
389	ret = req->error;
390out:
391	kfree(req);
392	return ret;
393}
394
395static int cachefiles_ondemand_init_open_req(struct cachefiles_req *req,
396					     void *private)
397{
398	struct cachefiles_object *object = req->object;
399	struct fscache_cookie *cookie = object->cookie;
400	struct fscache_volume *volume = object->volume->vcookie;
401	struct cachefiles_open *load = (void *)req->msg.data;
402	size_t volume_key_size, cookie_key_size;
403	void *volume_key, *cookie_key;
404
405	/*
406	 * Volume key is a NUL-terminated string. key[0] stores strlen() of the
407	 * string, followed by the content of the string (excluding '\0').
408	 */
409	volume_key_size = volume->key[0] + 1;
410	volume_key = volume->key + 1;
411
412	/* Cookie key is binary data, which is netfs specific. */
413	cookie_key_size = cookie->key_len;
414	cookie_key = fscache_get_key(cookie);
415
416	if (!(object->cookie->advice & FSCACHE_ADV_WANT_CACHE_SIZE)) {
417		pr_err("WANT_CACHE_SIZE is needed for on-demand mode\n");
418		return -EINVAL;
419	}
420
421	load->volume_key_size = volume_key_size;
422	load->cookie_key_size = cookie_key_size;
423	memcpy(load->data, volume_key, volume_key_size);
424	memcpy(load->data + volume_key_size, cookie_key, cookie_key_size);
425
426	return 0;
427}
428
429static int cachefiles_ondemand_init_close_req(struct cachefiles_req *req,
430					      void *private)
431{
432	struct cachefiles_object *object = req->object;
433	int object_id = object->ondemand_id;
434
435	/*
436	 * It's possible that object id is still 0 if the cookie looking up
437	 * phase failed before OPEN request has ever been sent. Also avoid
438	 * sending CLOSE request for CACHEFILES_ONDEMAND_ID_CLOSED, which means
439	 * anon_fd has already been closed.
440	 */
441	if (object_id <= 0)
442		return -ENOENT;
443
444	req->msg.object_id = object_id;
445	trace_cachefiles_ondemand_close(object, &req->msg);
446	return 0;
447}
448
449struct cachefiles_read_ctx {
450	loff_t off;
451	size_t len;
452};
453
454static int cachefiles_ondemand_init_read_req(struct cachefiles_req *req,
455					     void *private)
456{
457	struct cachefiles_object *object = req->object;
458	struct cachefiles_read *load = (void *)req->msg.data;
459	struct cachefiles_read_ctx *read_ctx = private;
460	int object_id = object->ondemand_id;
461
462	/* Stop enqueuing requests when daemon has closed anon_fd. */
463	if (object_id <= 0) {
464		WARN_ON_ONCE(object_id == 0);
465		pr_info_once("READ: anonymous fd closed prematurely.\n");
466		return -EIO;
467	}
468
469	req->msg.object_id = object_id;
470	load->off = read_ctx->off;
471	load->len = read_ctx->len;
472	trace_cachefiles_ondemand_read(object, &req->msg, load);
473	return 0;
474}
475
476int cachefiles_ondemand_init_object(struct cachefiles_object *object)
477{
478	struct fscache_cookie *cookie = object->cookie;
479	struct fscache_volume *volume = object->volume->vcookie;
480	size_t volume_key_size, cookie_key_size, data_len;
481
482	/*
483	 * CacheFiles will firstly check the cache file under the root cache
484	 * directory. If the coherency check failed, it will fallback to
485	 * creating a new tmpfile as the cache file. Reuse the previously
486	 * allocated object ID if any.
487	 */
488	if (object->ondemand_id > 0)
489		return 0;
490
491	volume_key_size = volume->key[0] + 1;
492	cookie_key_size = cookie->key_len;
493	data_len = sizeof(struct cachefiles_open) +
494		   volume_key_size + cookie_key_size;
495
496	return cachefiles_ondemand_send_req(object, CACHEFILES_OP_OPEN,
497			data_len, cachefiles_ondemand_init_open_req, NULL);
498}
499
500void cachefiles_ondemand_clean_object(struct cachefiles_object *object)
501{
502	cachefiles_ondemand_send_req(object, CACHEFILES_OP_CLOSE, 0,
503			cachefiles_ondemand_init_close_req, NULL);
504}
505
506int cachefiles_ondemand_read(struct cachefiles_object *object,
507			     loff_t pos, size_t len)
508{
509	struct cachefiles_read_ctx read_ctx = {pos, len};
510
511	return cachefiles_ondemand_send_req(object, CACHEFILES_OP_READ,
512			sizeof(struct cachefiles_read),
513			cachefiles_ondemand_init_read_req, &read_ctx);
514}
515