[linux-block.git] / fs / cachefiles / ondemand.c

// SPDX-License-Identifier: GPL-2.0-or-later
#include <linux/fdtable.h>
#include <linux/anon_inodes.h>
#include <linux/uio.h>
#include "internal.h"

static int cachefiles_ondemand_fd_release(struct inode *inode,
					  struct file *file)
{
	struct cachefiles_object *object = file->private_data;
	struct cachefiles_cache *cache = object->volume->cache;
	int object_id = object->ondemand_id;
	struct cachefiles_req *req;
	XA_STATE(xas, &cache->reqs, 0);

	xa_lock(&cache->reqs);
	object->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED;

	/*
	 * Flush all pending READ requests since their completion depends on
	 * anon_fd.
	 */
	xas_for_each(&xas, req, ULONG_MAX) {
		if (req->msg.object_id == object_id &&
		    req->msg.opcode == CACHEFILES_OP_READ) {
			req->error = -EIO;
			complete(&req->done);
			xas_store(&xas, NULL);
		}
	}
	xa_unlock(&cache->reqs);

	xa_erase(&cache->ondemand_ids, object_id);
	trace_cachefiles_ondemand_fd_release(object, object_id);
	cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
	cachefiles_put_unbind_pincount(cache);
	return 0;
}

static ssize_t cachefiles_ondemand_fd_write_iter(struct kiocb *kiocb,
						 struct iov_iter *iter)
{
	struct cachefiles_object *object = kiocb->ki_filp->private_data;
	struct cachefiles_cache *cache = object->volume->cache;
	struct file *file = object->file;
	size_t len = iter->count;
	loff_t pos = kiocb->ki_pos;
	const struct cred *saved_cred;
	int ret;

	if (!file)
		return -ENOBUFS;

	cachefiles_begin_secure(cache, &saved_cred);
	ret = __cachefiles_prepare_write(object, file, &pos, &len, true);
	cachefiles_end_secure(cache, saved_cred);
	if (ret < 0)
		return ret;

	trace_cachefiles_ondemand_fd_write(object, file_inode(file), pos, len);
	ret = __cachefiles_write(object, file, pos, iter, NULL, NULL);
	if (!ret)
		ret = len;

	return ret;
}

static loff_t cachefiles_ondemand_fd_llseek(struct file *filp, loff_t pos,
					    int whence)
{
	struct cachefiles_object *object = filp->private_data;
	struct file *file = object->file;

	if (!file)
		return -ENOBUFS;

	return vfs_llseek(file, pos, whence);
}

static long cachefiles_ondemand_fd_ioctl(struct file *filp, unsigned int ioctl,
					 unsigned long arg)
{
	struct cachefiles_object *object = filp->private_data;
	struct cachefiles_cache *cache = object->volume->cache;
	struct cachefiles_req *req;
	unsigned long id;

	if (ioctl != CACHEFILES_IOC_READ_COMPLETE)
		return -EINVAL;

	if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
		return -EOPNOTSUPP;

	id = arg;
	req = xa_erase(&cache->reqs, id);
	if (!req)
		return -EINVAL;

	trace_cachefiles_ondemand_cread(object, id);
	complete(&req->done);
	return 0;
}

static const struct file_operations cachefiles_ondemand_fd_fops = {
	.owner		= THIS_MODULE,
	.release	= cachefiles_ondemand_fd_release,
	.write_iter	= cachefiles_ondemand_fd_write_iter,
	.llseek		= cachefiles_ondemand_fd_llseek,
	.unlocked_ioctl	= cachefiles_ondemand_fd_ioctl,
};

/*
 * OPEN request Completion (copen)
 * - command: "copen <id>,<cache_size>"
 *   <cache_size> indicates the object size if >=0, error code if negative
 */
int cachefiles_ondemand_copen(struct cachefiles_cache *cache, char *args)
{
	struct cachefiles_req *req;
	struct fscache_cookie *cookie;
	char *pid, *psize;
	unsigned long id;
	long size;
	int ret;

	if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
		return -EOPNOTSUPP;

	if (!*args) {
		pr_err("Empty id specified\n");
		return -EINVAL;
	}

	pid = args;
	psize = strchr(args, ',');
	if (!psize) {
		pr_err("Cache size is not specified\n");
		return -EINVAL;
	}

	*psize = 0;
	psize++;

	ret = kstrtoul(pid, 0, &id);
	if (ret)
		return ret;

	req = xa_erase(&cache->reqs, id);
	if (!req)
		return -EINVAL;

	/* fail OPEN request if copen format is invalid */
	ret = kstrtol(psize, 0, &size);
	if (ret) {
		req->error = ret;
		goto out;
	}

	/* fail OPEN request if daemon reports an error */
	if (size < 0) {
		if (!IS_ERR_VALUE(size)) {
			req->error = -EINVAL;
			ret = -EINVAL;
		} else {
			req->error = size;
			ret = 0;
		}
		goto out;
	}

	cookie = req->object->cookie;
	cookie->object_size = size;
	if (size)
		clear_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
	else
		set_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags);
	trace_cachefiles_ondemand_copen(req->object, id, size);

out:
	complete(&req->done);
	return ret;
}

static int cachefiles_ondemand_get_fd(struct cachefiles_req *req)
{
	struct cachefiles_object *object;
	struct cachefiles_cache *cache;
	struct cachefiles_open *load;
	struct file *file;
	u32 object_id;
	int ret, fd;

	object = cachefiles_grab_object(req->object,
			cachefiles_obj_get_ondemand_fd);
	cache = object->volume->cache;

	ret = xa_alloc_cyclic(&cache->ondemand_ids, &object_id, NULL,
			      XA_LIMIT(1, INT_MAX),
			      &cache->ondemand_id_next, GFP_KERNEL);
	if (ret < 0)
		goto err;

	fd = get_unused_fd_flags(O_WRONLY);
	if (fd < 0) {
		ret = fd;
		goto err_free_id;
	}

	file = anon_inode_getfile("[cachefiles]", &cachefiles_ondemand_fd_fops,
				  object, O_WRONLY);
	if (IS_ERR(file)) {
		ret = PTR_ERR(file);
		goto err_put_fd;
	}

	file->f_mode |= FMODE_PWRITE | FMODE_LSEEK;
	fd_install(fd, file);

	load = (void *)req->msg.data;
	load->fd = fd;
	req->msg.object_id = object_id;
	object->ondemand_id = object_id;

	cachefiles_get_unbind_pincount(cache);
	trace_cachefiles_ondemand_open(object, &req->msg, load);
	return 0;

err_put_fd:
	put_unused_fd(fd);
err_free_id:
	xa_erase(&cache->ondemand_ids, object_id);
err:
	cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
	return ret;
}

ssize_t cachefiles_ondemand_daemon_read(struct cachefiles_cache *cache,
					char __user *_buffer, size_t buflen)
{
	struct cachefiles_req *req;
	struct cachefiles_msg *msg;
	unsigned long id = 0;
	size_t n;
	int ret = 0;
	XA_STATE(xas, &cache->reqs, cache->req_id_next);

	/*
	 * Cyclically search for a request that has not ever been processed,
	 * to prevent requests from being processed repeatedly, and make
	 * request distribution fair.
	 */
	xa_lock(&cache->reqs);
	req = xas_find_marked(&xas, UINT_MAX, CACHEFILES_REQ_NEW);
	if (!req && cache->req_id_next > 0) {
		xas_set(&xas, 0);
		req = xas_find_marked(&xas, cache->req_id_next - 1, CACHEFILES_REQ_NEW);
	}
	if (!req) {
		xa_unlock(&cache->reqs);
		return 0;
	}

	msg = &req->msg;
	n = msg->len;

	if (n > buflen) {
		xa_unlock(&cache->reqs);
		return -EMSGSIZE;
	}

	xas_clear_mark(&xas, CACHEFILES_REQ_NEW);
	cache->req_id_next = xas.xa_index + 1;
	xa_unlock(&cache->reqs);

	id = xas.xa_index;
	msg->msg_id = id;

	if (msg->opcode == CACHEFILES_OP_OPEN) {
		ret = cachefiles_ondemand_get_fd(req);
		if (ret)
			goto error;
	}

	if (copy_to_user(_buffer, msg, n) != 0) {
		ret = -EFAULT;
		goto err_put_fd;
	}

	/* CLOSE request has no reply */
	if (msg->opcode == CACHEFILES_OP_CLOSE) {
		xa_erase(&cache->reqs, id);
		complete(&req->done);
	}

	return n;

err_put_fd:
	if (msg->opcode == CACHEFILES_OP_OPEN)
		close_fd(((struct cachefiles_open *)msg->data)->fd);
error:
	xa_erase(&cache->reqs, id);
	req->error = ret;
	complete(&req->done);
	return ret;
}

typedef int (*init_req_fn)(struct cachefiles_req *req, void *private);

static int cachefiles_ondemand_send_req(struct cachefiles_object *object,
					enum cachefiles_opcode opcode,
					size_t data_len,
					init_req_fn init_req,
					void *private)
{
	struct cachefiles_cache *cache = object->volume->cache;
	struct cachefiles_req *req;
	XA_STATE(xas, &cache->reqs, 0);
	int ret;

	if (!test_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags))
		return 0;

	if (test_bit(CACHEFILES_DEAD, &cache->flags))
		return -EIO;

	req = kzalloc(sizeof(*req) + data_len, GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	req->object = object;
	init_completion(&req->done);
	req->msg.opcode = opcode;
	req->msg.len = sizeof(struct cachefiles_msg) + data_len;

	ret = init_req(req, private);
	if (ret)
		goto out;

	do {
		/*
		 * Stop enqueuing the request when daemon is dying. The
		 * following two operations need to be atomic as a whole.
		 *   1) check cache state, and
		 *   2) enqueue request if cache is alive.
		 * Otherwise the request may be enqueued after xarray has been
		 * flushed, leaving the orphan request never being completed.
		 *
		 * CPU 1			CPU 2
		 * =====			=====
		 *				test CACHEFILES_DEAD bit
		 * set CACHEFILES_DEAD bit
		 * flush requests in the xarray
		 *				enqueue the request
		 */
		xas_lock(&xas);

		if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
			xas_unlock(&xas);
			ret = -EIO;
			goto out;
		}

		/* coupled with the barrier in cachefiles_flush_reqs() */
		smp_mb();

		if (opcode != CACHEFILES_OP_OPEN && object->ondemand_id <= 0) {
			WARN_ON_ONCE(object->ondemand_id == 0);
			xas_unlock(&xas);
			ret = -EIO;
			goto out;
		}

		xas.xa_index = 0;
		xas_find_marked(&xas, UINT_MAX, XA_FREE_MARK);
		if (xas.xa_node == XAS_RESTART)
			xas_set_err(&xas, -EBUSY);
		xas_store(&xas, req);
		xas_clear_mark(&xas, XA_FREE_MARK);
		xas_set_mark(&xas, CACHEFILES_REQ_NEW);
		xas_unlock(&xas);
	} while (xas_nomem(&xas, GFP_KERNEL));

	ret = xas_error(&xas);
	if (ret)
		goto out;

	wake_up_all(&cache->daemon_pollwq);
	wait_for_completion(&req->done);
	ret = req->error;
out:
	kfree(req);
	return ret;
}

static int cachefiles_ondemand_init_open_req(struct cachefiles_req *req,
					     void *private)
{
	struct cachefiles_object *object = req->object;
	struct fscache_cookie *cookie = object->cookie;
	struct fscache_volume *volume = object->volume->vcookie;
	struct cachefiles_open *load = (void *)req->msg.data;
	size_t volume_key_size, cookie_key_size;
	void *volume_key, *cookie_key;

	/*
	 * Volume key is a NUL-terminated string. key[0] stores strlen() of the
	 * string, followed by the content of the string (excluding '\0').
	 */
	volume_key_size = volume->key[0] + 1;
	volume_key = volume->key + 1;

	/* Cookie key is binary data, which is netfs specific. */
	cookie_key_size = cookie->key_len;
	cookie_key = fscache_get_key(cookie);

	if (!(object->cookie->advice & FSCACHE_ADV_WANT_CACHE_SIZE)) {
		pr_err("WANT_CACHE_SIZE is needed for on-demand mode\n");
		return -EINVAL;
	}

	load->volume_key_size = volume_key_size;
	load->cookie_key_size = cookie_key_size;
	memcpy(load->data, volume_key, volume_key_size);
	memcpy(load->data + volume_key_size, cookie_key, cookie_key_size);

	return 0;
}

static int cachefiles_ondemand_init_close_req(struct cachefiles_req *req,
					      void *private)
{
	struct cachefiles_object *object = req->object;
	int object_id = object->ondemand_id;

	/*
	 * It's possible that object id is still 0 if the cookie looking up
	 * phase failed before OPEN request has ever been sent. Also avoid
	 * sending CLOSE request for CACHEFILES_ONDEMAND_ID_CLOSED, which means
	 * anon_fd has already been closed.
	 */
	if (object_id <= 0)
		return -ENOENT;

	req->msg.object_id = object_id;
	trace_cachefiles_ondemand_close(object, &req->msg);
	return 0;
}

struct cachefiles_read_ctx {
	loff_t off;
	size_t len;
};

static int cachefiles_ondemand_init_read_req(struct cachefiles_req *req,
					     void *private)
{
	struct cachefiles_object *object = req->object;
	struct cachefiles_read *load = (void *)req->msg.data;
	struct cachefiles_read_ctx *read_ctx = private;
	int object_id = object->ondemand_id;

	/* Stop enqueuing requests when daemon has closed anon_fd. */
	if (object_id <= 0) {
		WARN_ON_ONCE(object_id == 0);
		pr_info_once("READ: anonymous fd closed prematurely.\n");
		return -EIO;
	}

	req->msg.object_id = object_id;
	load->off = read_ctx->off;
	load->len = read_ctx->len;
	trace_cachefiles_ondemand_read(object, &req->msg, load);
	return 0;
}

int cachefiles_ondemand_init_object(struct cachefiles_object *object)
{
	struct fscache_cookie *cookie = object->cookie;
	struct fscache_volume *volume = object->volume->vcookie;
	size_t volume_key_size, cookie_key_size, data_len;

	/*
	 * CacheFiles will firstly check the cache file under the root cache
	 * directory. If the coherency check failed, it will fallback to
	 * creating a new tmpfile as the cache file. Reuse the previously
	 * allocated object ID if any.
	 */
	if (object->ondemand_id > 0)
		return 0;

	volume_key_size = volume->key[0] + 1;
	cookie_key_size = cookie->key_len;
	data_len = sizeof(struct cachefiles_open) +
		   volume_key_size + cookie_key_size;

	return cachefiles_ondemand_send_req(object, CACHEFILES_OP_OPEN,
			data_len, cachefiles_ondemand_init_open_req, NULL);
}

void cachefiles_ondemand_clean_object(struct cachefiles_object *object)
{
	cachefiles_ondemand_send_req(object, CACHEFILES_OP_CLOSE, 0,
			cachefiles_ondemand_init_close_req, NULL);
}

int cachefiles_ondemand_read(struct cachefiles_object *object,
			     loff_t pos, size_t len)
{
	struct cachefiles_read_ctx read_ctx = {pos, len};

	return cachefiles_ondemand_send_req(object, CACHEFILES_OP_READ,
			sizeof(struct cachefiles_read),
			cachefiles_ondemand_init_read_req, &read_ctx);
}
Commit	Line	Data
c8383054 JX	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
	7	static 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;
9032b6e8 JX	13	struct cachefiles_req *req;
9032b6e8 JX	14	XA_STATE(xas, &cache->reqs, 0);
c8383054	15
9032b6e8	16	xa_lock(&cache->reqs);
c8383054	17	object->ondemand_id = CACHEFILES_ONDEMAND_ID_CLOSED;
9032b6e8 JX	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) {
65aa5f6f JZ	24	if (req->msg.object_id == object_id &&
65aa5f6f JZ	25	req->msg.opcode == CACHEFILES_OP_READ) {
9032b6e8 JX	26	req->error = -EIO;
	27	complete(&req->done);
	28	xas_store(&xas, NULL);
	29	}
	30	}
	31	xa_unlock(&cache->reqs);
	32
c8383054	33	xa_erase(&cache->ondemand_ids, object_id);
1519670e	34	trace_cachefiles_ondemand_fd_release(object, object_id);
c8383054	35	cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
d11b0b04	36	cachefiles_put_unbind_pincount(cache);
c8383054 JX	37	return 0;
	38	}
	39
	40	static 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
1519670e	60	trace_cachefiles_ondemand_fd_write(object, file_inode(file), pos, len);
c8383054 JX	61	ret = __cachefiles_write(object, file, pos, iter, NULL, NULL);
	62	if (!ret)
	63	ret = len;
	64
	65	return ret;
	66	}
	67
	68	static 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
9032b6e8 JX	80	static 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
1519670e	99	trace_cachefiles_ondemand_cread(object, id);
9032b6e8 JX	100	complete(&req->done);
	101	return 0;
	102	}
	103
c8383054 JX	104	static 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,
9032b6e8	109	.unlocked_ioctl = cachefiles_ondemand_fd_ioctl,
c8383054 JX	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	*/
	117	int 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) {
c93ccd63 SK	161	if (!IS_ERR_VALUE(size)) {
	162	req->error = -EINVAL;
	163	ret = -EINVAL;
	164	} else {
	165	req->error = size;
	166	ret = 0;
	167	}
c8383054 JX	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);
1519670e	177	trace_cachefiles_ondemand_copen(req->object, id, size);
c8383054 JX	178
	179	out:
	180	complete(&req->done);
	181	return ret;
	182	}
	183
	184	static 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;
d11b0b04 JX	223
d11b0b04 JX	224	cachefiles_get_unbind_pincount(cache);
1519670e	225	trace_cachefiles_ondemand_open(object, &req->msg, load);
c8383054 JX	226	return 0;
	227
	228	err_put_fd:
	229	put_unused_fd(fd);
	230	err_free_id:
	231	xa_erase(&cache->ondemand_ids, object_id);
	232	err:
	233	cachefiles_put_object(object, cachefiles_obj_put_ondemand_fd);
	234	return ret;
	235	}
	236
	237	ssize_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;
1122f400	245	XA_STATE(xas, &cache->reqs, cache->req_id_next);
c8383054 JX	246
c8383054 JX	247	/*
1122f400 XY	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.
c8383054 JX	251	*/
	252	xa_lock(&cache->reqs);
	253	req = xas_find_marked(&xas, UINT_MAX, CACHEFILES_REQ_NEW);
1122f400 XY	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	}
c8383054 JX	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);
1122f400	272	cache->req_id_next = xas.xa_index + 1;
c8383054 JX	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
324b954a JX	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
c8383054 JX	295	return n;
	296
	297	err_put_fd:
	298	if (msg->opcode == CACHEFILES_OP_OPEN)
	299	close_fd(((struct cachefiles_open *)msg->data)->fd);
	300	error:
	301	xa_erase(&cache->reqs, id);
	302	req->error = ret;
	303	complete(&req->done);
	304	return ret;
	305	}
	306
	307	typedef int (init_req_fn)(struct cachefiles_req req, void *private);
	308
	309	static 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
324b954a JX	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
c8383054 JX	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;
	390	out:
	391	kfree(req);
	392	return ret;
	393	}
	394
	395	static 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
324b954a JX	429	static 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;
1519670e	445	trace_cachefiles_ondemand_close(object, &req->msg);
324b954a JX	446	return 0;
	447	}
	448
9032b6e8 JX	449	struct cachefiles_read_ctx {
	450	loff_t off;
	451	size_t len;
	452	};
	453
	454	static 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;
1519670e	472	trace_cachefiles_ondemand_read(object, &req->msg, load);
9032b6e8 JX	473	return 0;
	474	}
	475
c8383054 JX	476	int 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	}
324b954a JX	499
	500	void 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	}
9032b6e8 JX	505
	506	int 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	}