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

// SPDX-License-Identifier: GPL-2.0-or-later
/* Daemon interface
 *
 * Copyright (C) 2007, 2021 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/completion.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/namei.h>
#include <linux/poll.h>
#include <linux/mount.h>
#include <linux/statfs.h>
#include <linux/ctype.h>
#include <linux/string.h>
#include <linux/fs_struct.h>
#include "internal.h"

static int cachefiles_daemon_open(struct inode *, struct file *);
static int cachefiles_daemon_release(struct inode *, struct file *);
static ssize_t cachefiles_daemon_read(struct file *, char __user *, size_t,
				      loff_t *);
static ssize_t cachefiles_daemon_write(struct file *, const char __user *,
				       size_t, loff_t *);
static __poll_t cachefiles_daemon_poll(struct file *,
					   struct poll_table_struct *);
static int cachefiles_daemon_frun(struct cachefiles_cache *, char *);
static int cachefiles_daemon_fcull(struct cachefiles_cache *, char *);
static int cachefiles_daemon_fstop(struct cachefiles_cache *, char *);
static int cachefiles_daemon_brun(struct cachefiles_cache *, char *);
static int cachefiles_daemon_bcull(struct cachefiles_cache *, char *);
static int cachefiles_daemon_bstop(struct cachefiles_cache *, char *);
static int cachefiles_daemon_cull(struct cachefiles_cache *, char *);
static int cachefiles_daemon_debug(struct cachefiles_cache *, char *);
static int cachefiles_daemon_dir(struct cachefiles_cache *, char *);
static int cachefiles_daemon_inuse(struct cachefiles_cache *, char *);
static int cachefiles_daemon_secctx(struct cachefiles_cache *, char *);
static int cachefiles_daemon_tag(struct cachefiles_cache *, char *);
static int cachefiles_daemon_bind(struct cachefiles_cache *, char *);
static void cachefiles_daemon_unbind(struct cachefiles_cache *);

static unsigned long cachefiles_open;

const struct file_operations cachefiles_daemon_fops = {
	.owner		= THIS_MODULE,
	.open		= cachefiles_daemon_open,
	.release	= cachefiles_daemon_release,
	.read		= cachefiles_daemon_read,
	.write		= cachefiles_daemon_write,
	.poll		= cachefiles_daemon_poll,
	.llseek		= noop_llseek,
};

struct cachefiles_daemon_cmd {
	char name[8];
	int (*handler)(struct cachefiles_cache *cache, char *args);
};

static const struct cachefiles_daemon_cmd cachefiles_daemon_cmds[] = {
	{ "bind",	cachefiles_daemon_bind		},
	{ "brun",	cachefiles_daemon_brun		},
	{ "bcull",	cachefiles_daemon_bcull		},
	{ "bstop",	cachefiles_daemon_bstop		},
	{ "cull",	cachefiles_daemon_cull		},
	{ "debug",	cachefiles_daemon_debug		},
	{ "dir",	cachefiles_daemon_dir		},
	{ "frun",	cachefiles_daemon_frun		},
	{ "fcull",	cachefiles_daemon_fcull		},
	{ "fstop",	cachefiles_daemon_fstop		},
	{ "inuse",	cachefiles_daemon_inuse		},
	{ "secctx",	cachefiles_daemon_secctx	},
	{ "tag",	cachefiles_daemon_tag		},
#ifdef CONFIG_CACHEFILES_ONDEMAND
	{ "copen",	cachefiles_ondemand_copen	},
#endif
	{ "",		NULL				}
};


/*
 * Prepare a cache for caching.
 */
static int cachefiles_daemon_open(struct inode *inode, struct file *file)
{
	struct cachefiles_cache *cache;

	_enter("");

	/* only the superuser may do this */
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	/* the cachefiles device may only be open once at a time */
	if (xchg(&cachefiles_open, 1) == 1)
		return -EBUSY;

	/* allocate a cache record */
	cache = kzalloc(sizeof(struct cachefiles_cache), GFP_KERNEL);
	if (!cache) {
		cachefiles_open = 0;
		return -ENOMEM;
	}

	mutex_init(&cache->daemon_mutex);
	init_waitqueue_head(&cache->daemon_pollwq);
	INIT_LIST_HEAD(&cache->volumes);
	INIT_LIST_HEAD(&cache->object_list);
	spin_lock_init(&cache->object_list_lock);
	refcount_set(&cache->unbind_pincount, 1);
	xa_init_flags(&cache->reqs, XA_FLAGS_ALLOC);
	xa_init_flags(&cache->ondemand_ids, XA_FLAGS_ALLOC1);

	/* set default caching limits
	 * - limit at 1% free space and/or free files
	 * - cull below 5% free space and/or free files
	 * - cease culling above 7% free space and/or free files
	 */
	cache->frun_percent = 7;
	cache->fcull_percent = 5;
	cache->fstop_percent = 1;
	cache->brun_percent = 7;
	cache->bcull_percent = 5;
	cache->bstop_percent = 1;

	file->private_data = cache;
	cache->cachefilesd = file;
	return 0;
}

static void cachefiles_flush_reqs(struct cachefiles_cache *cache)
{
	struct xarray *xa = &cache->reqs;
	struct cachefiles_req *req;
	unsigned long index;

	/*
	 * Make sure the following two operations won't be reordered.
	 *   1) set CACHEFILES_DEAD bit
	 *   2) flush requests in the xarray
	 * Otherwise the request may be enqueued after xarray has been
	 * flushed, leaving the orphan request never being completed.
	 *
	 * CPU 1			CPU 2
	 * =====			=====
	 * flush requests in the xarray
	 *				test CACHEFILES_DEAD bit
	 *				enqueue the request
	 * set CACHEFILES_DEAD bit
	 */
	smp_mb();

	xa_lock(xa);
	xa_for_each(xa, index, req) {
		req->error = -EIO;
		complete(&req->done);
	}
	xa_unlock(xa);

	xa_destroy(&cache->reqs);
	xa_destroy(&cache->ondemand_ids);
}

void cachefiles_put_unbind_pincount(struct cachefiles_cache *cache)
{
	if (refcount_dec_and_test(&cache->unbind_pincount)) {
		cachefiles_daemon_unbind(cache);
		cachefiles_open = 0;
		kfree(cache);
	}
}

void cachefiles_get_unbind_pincount(struct cachefiles_cache *cache)
{
	refcount_inc(&cache->unbind_pincount);
}

/*
 * Release a cache.
 */
static int cachefiles_daemon_release(struct inode *inode, struct file *file)
{
	struct cachefiles_cache *cache = file->private_data;

	_enter("");

	ASSERT(cache);

	set_bit(CACHEFILES_DEAD, &cache->flags);

	if (cachefiles_in_ondemand_mode(cache))
		cachefiles_flush_reqs(cache);

	/* clean up the control file interface */
	cache->cachefilesd = NULL;
	file->private_data = NULL;

	cachefiles_put_unbind_pincount(cache);

	_leave("");
	return 0;
}

static ssize_t cachefiles_do_daemon_read(struct cachefiles_cache *cache,
					 char __user *_buffer, size_t buflen)
{
	unsigned long long b_released;
	unsigned f_released;
	char buffer[256];
	int n;

	/* check how much space the cache has */
	cachefiles_has_space(cache, 0, 0, cachefiles_has_space_check);

	/* summarise */
	f_released = atomic_xchg(&cache->f_released, 0);
	b_released = atomic_long_xchg(&cache->b_released, 0);
	clear_bit(CACHEFILES_STATE_CHANGED, &cache->flags);

	n = snprintf(buffer, sizeof(buffer),
		     "cull=%c"
		     " frun=%llx"
		     " fcull=%llx"
		     " fstop=%llx"
		     " brun=%llx"
		     " bcull=%llx"
		     " bstop=%llx"
		     " freleased=%x"
		     " breleased=%llx",
		     test_bit(CACHEFILES_CULLING, &cache->flags) ? '1' : '0',
		     (unsigned long long) cache->frun,
		     (unsigned long long) cache->fcull,
		     (unsigned long long) cache->fstop,
		     (unsigned long long) cache->brun,
		     (unsigned long long) cache->bcull,
		     (unsigned long long) cache->bstop,
		     f_released,
		     b_released);

	if (n > buflen)
		return -EMSGSIZE;

	if (copy_to_user(_buffer, buffer, n) != 0)
		return -EFAULT;

	return n;
}

/*
 * Read the cache state.
 */
static ssize_t cachefiles_daemon_read(struct file *file, char __user *_buffer,
				      size_t buflen, loff_t *pos)
{
	struct cachefiles_cache *cache = file->private_data;

	//_enter(",,%zu,", buflen);

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

	if (cachefiles_in_ondemand_mode(cache))
		return cachefiles_ondemand_daemon_read(cache, _buffer, buflen);
	else
		return cachefiles_do_daemon_read(cache, _buffer, buflen);
}

/*
 * Take a command from cachefilesd, parse it and act on it.
 */
static ssize_t cachefiles_daemon_write(struct file *file,
				       const char __user *_data,
				       size_t datalen,
				       loff_t *pos)
{
	const struct cachefiles_daemon_cmd *cmd;
	struct cachefiles_cache *cache = file->private_data;
	ssize_t ret;
	char *data, *args, *cp;

	//_enter(",,%zu,", datalen);

	ASSERT(cache);

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

	if (datalen > PAGE_SIZE - 1)
		return -EOPNOTSUPP;

	/* drag the command string into the kernel so we can parse it */
	data = memdup_user_nul(_data, datalen);
	if (IS_ERR(data))
		return PTR_ERR(data);

	ret = -EINVAL;
	if (memchr(data, '\0', datalen))
		goto error;

	/* strip any newline */
	cp = memchr(data, '\n', datalen);
	if (cp) {
		if (cp == data)
			goto error;

		*cp = '\0';
	}

	/* parse the command */
	ret = -EOPNOTSUPP;

	for (args = data; *args; args++)
		if (isspace(*args))
			break;
	if (*args) {
		if (args == data)
			goto error;
		*args = '\0';
		args = skip_spaces(++args);
	}

	/* run the appropriate command handler */
	for (cmd = cachefiles_daemon_cmds; cmd->name[0]; cmd++)
		if (strcmp(cmd->name, data) == 0)
			goto found_command;

error:
	kfree(data);
	//_leave(" = %zd", ret);
	return ret;

found_command:
	mutex_lock(&cache->daemon_mutex);

	ret = -EIO;
	if (!test_bit(CACHEFILES_DEAD, &cache->flags))
		ret = cmd->handler(cache, args);

	mutex_unlock(&cache->daemon_mutex);

	if (ret == 0)
		ret = datalen;
	goto error;
}

/*
 * Poll for culling state
 * - use EPOLLOUT to indicate culling state
 */
static __poll_t cachefiles_daemon_poll(struct file *file,
					   struct poll_table_struct *poll)
{
	struct cachefiles_cache *cache = file->private_data;
	__poll_t mask;

	poll_wait(file, &cache->daemon_pollwq, poll);
	mask = 0;

	if (cachefiles_in_ondemand_mode(cache)) {
		if (!xa_empty(&cache->reqs))
			mask |= EPOLLIN;
	} else {
		if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags))
			mask |= EPOLLIN;
	}

	if (test_bit(CACHEFILES_CULLING, &cache->flags))
		mask |= EPOLLOUT;

	return mask;
}

/*
 * Give a range error for cache space constraints
 * - can be tail-called
 */
static int cachefiles_daemon_range_error(struct cachefiles_cache *cache,
					 char *args)
{
	pr_err("Free space limits must be in range 0%%<=stop<cull<run<100%%\n");

	return -EINVAL;
}

/*
 * Set the percentage of files at which to stop culling
 * - command: "frun <N>%"
 */
static int cachefiles_daemon_frun(struct cachefiles_cache *cache, char *args)
{
	unsigned long frun;

	_enter(",%s", args);

	if (!*args)
		return -EINVAL;

	frun = simple_strtoul(args, &args, 10);
	if (args[0] != '%' || args[1] != '\0')
		return -EINVAL;

	if (frun <= cache->fcull_percent || frun >= 100)
		return cachefiles_daemon_range_error(cache, args);

	cache->frun_percent = frun;
	return 0;
}

/*
 * Set the percentage of files at which to start culling
 * - command: "fcull <N>%"
 */
static int cachefiles_daemon_fcull(struct cachefiles_cache *cache, char *args)
{
	unsigned long fcull;

	_enter(",%s", args);

	if (!*args)
		return -EINVAL;

	fcull = simple_strtoul(args, &args, 10);
	if (args[0] != '%' || args[1] != '\0')
		return -EINVAL;

	if (fcull <= cache->fstop_percent || fcull >= cache->frun_percent)
		return cachefiles_daemon_range_error(cache, args);

	cache->fcull_percent = fcull;
	return 0;
}

/*
 * Set the percentage of files at which to stop allocating
 * - command: "fstop <N>%"
 */
static int cachefiles_daemon_fstop(struct cachefiles_cache *cache, char *args)
{
	unsigned long fstop;

	_enter(",%s", args);

	if (!*args)
		return -EINVAL;

	fstop = simple_strtoul(args, &args, 10);
	if (args[0] != '%' || args[1] != '\0')
		return -EINVAL;

	if (fstop >= cache->fcull_percent)
		return cachefiles_daemon_range_error(cache, args);

	cache->fstop_percent = fstop;
	return 0;
}

/*
 * Set the percentage of blocks at which to stop culling
 * - command: "brun <N>%"
 */
static int cachefiles_daemon_brun(struct cachefiles_cache *cache, char *args)
{
	unsigned long brun;

	_enter(",%s", args);

	if (!*args)
		return -EINVAL;

	brun = simple_strtoul(args, &args, 10);
	if (args[0] != '%' || args[1] != '\0')
		return -EINVAL;

	if (brun <= cache->bcull_percent || brun >= 100)
		return cachefiles_daemon_range_error(cache, args);

	cache->brun_percent = brun;
	return 0;
}

/*
 * Set the percentage of blocks at which to start culling
 * - command: "bcull <N>%"
 */
static int cachefiles_daemon_bcull(struct cachefiles_cache *cache, char *args)
{
	unsigned long bcull;

	_enter(",%s", args);

	if (!*args)
		return -EINVAL;

	bcull = simple_strtoul(args, &args, 10);
	if (args[0] != '%' || args[1] != '\0')
		return -EINVAL;

	if (bcull <= cache->bstop_percent || bcull >= cache->brun_percent)
		return cachefiles_daemon_range_error(cache, args);

	cache->bcull_percent = bcull;
	return 0;
}

/*
 * Set the percentage of blocks at which to stop allocating
 * - command: "bstop <N>%"
 */
static int cachefiles_daemon_bstop(struct cachefiles_cache *cache, char *args)
{
	unsigned long bstop;

	_enter(",%s", args);

	if (!*args)
		return -EINVAL;

	bstop = simple_strtoul(args, &args, 10);
	if (args[0] != '%' || args[1] != '\0')
		return -EINVAL;

	if (bstop >= cache->bcull_percent)
		return cachefiles_daemon_range_error(cache, args);

	cache->bstop_percent = bstop;
	return 0;
}

/*
 * Set the cache directory
 * - command: "dir <name>"
 */
static int cachefiles_daemon_dir(struct cachefiles_cache *cache, char *args)
{
	char *dir;

	_enter(",%s", args);

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

	if (cache->rootdirname) {
		pr_err("Second cache directory specified\n");
		return -EEXIST;
	}

	dir = kstrdup(args, GFP_KERNEL);
	if (!dir)
		return -ENOMEM;

	cache->rootdirname = dir;
	return 0;
}

/*
 * Set the cache security context
 * - command: "secctx <ctx>"
 */
static int cachefiles_daemon_secctx(struct cachefiles_cache *cache, char *args)
{
	char *secctx;

	_enter(",%s", args);

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

	if (cache->secctx) {
		pr_err("Second security context specified\n");
		return -EINVAL;
	}

	secctx = kstrdup(args, GFP_KERNEL);
	if (!secctx)
		return -ENOMEM;

	cache->secctx = secctx;
	return 0;
}

/*
 * Set the cache tag
 * - command: "tag <name>"
 */
static int cachefiles_daemon_tag(struct cachefiles_cache *cache, char *args)
{
	char *tag;

	_enter(",%s", args);

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

	if (cache->tag)
		return -EEXIST;

	tag = kstrdup(args, GFP_KERNEL);
	if (!tag)
		return -ENOMEM;

	cache->tag = tag;
	return 0;
}

/*
 * Request a node in the cache be culled from the current working directory
 * - command: "cull <name>"
 */
static int cachefiles_daemon_cull(struct cachefiles_cache *cache, char *args)
{
	struct path path;
	const struct cred *saved_cred;
	int ret;

	_enter(",%s", args);

	if (strchr(args, '/'))
		goto inval;

	if (!test_bit(CACHEFILES_READY, &cache->flags)) {
		pr_err("cull applied to unready cache\n");
		return -EIO;
	}

	if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
		pr_err("cull applied to dead cache\n");
		return -EIO;
	}

	get_fs_pwd(current->fs, &path);

	if (!d_can_lookup(path.dentry))
		goto notdir;

	cachefiles_begin_secure(cache, &saved_cred);
	ret = cachefiles_cull(cache, path.dentry, args);
	cachefiles_end_secure(cache, saved_cred);

	path_put(&path);
	_leave(" = %d", ret);
	return ret;

notdir:
	path_put(&path);
	pr_err("cull command requires dirfd to be a directory\n");
	return -ENOTDIR;

inval:
	pr_err("cull command requires dirfd and filename\n");
	return -EINVAL;
}

/*
 * Set debugging mode
 * - command: "debug <mask>"
 */
static int cachefiles_daemon_debug(struct cachefiles_cache *cache, char *args)
{
	unsigned long mask;

	_enter(",%s", args);

	mask = simple_strtoul(args, &args, 0);
	if (args[0] != '\0')
		goto inval;

	cachefiles_debug = mask;
	_leave(" = 0");
	return 0;

inval:
	pr_err("debug command requires mask\n");
	return -EINVAL;
}

/*
 * Find out whether an object in the current working directory is in use or not
 * - command: "inuse <name>"
 */
static int cachefiles_daemon_inuse(struct cachefiles_cache *cache, char *args)
{
	struct path path;
	const struct cred *saved_cred;
	int ret;

	//_enter(",%s", args);

	if (strchr(args, '/'))
		goto inval;

	if (!test_bit(CACHEFILES_READY, &cache->flags)) {
		pr_err("inuse applied to unready cache\n");
		return -EIO;
	}

	if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
		pr_err("inuse applied to dead cache\n");
		return -EIO;
	}

	get_fs_pwd(current->fs, &path);

	if (!d_can_lookup(path.dentry))
		goto notdir;

	cachefiles_begin_secure(cache, &saved_cred);
	ret = cachefiles_check_in_use(cache, path.dentry, args);
	cachefiles_end_secure(cache, saved_cred);

	path_put(&path);
	//_leave(" = %d", ret);
	return ret;

notdir:
	path_put(&path);
	pr_err("inuse command requires dirfd to be a directory\n");
	return -ENOTDIR;

inval:
	pr_err("inuse command requires dirfd and filename\n");
	return -EINVAL;
}

/*
 * Bind a directory as a cache
 */
static int cachefiles_daemon_bind(struct cachefiles_cache *cache, char *args)
{
	_enter("{%u,%u,%u,%u,%u,%u},%s",
	       cache->frun_percent,
	       cache->fcull_percent,
	       cache->fstop_percent,
	       cache->brun_percent,
	       cache->bcull_percent,
	       cache->bstop_percent,
	       args);

	if (cache->fstop_percent >= cache->fcull_percent ||
	    cache->fcull_percent >= cache->frun_percent ||
	    cache->frun_percent  >= 100)
		return -ERANGE;

	if (cache->bstop_percent >= cache->bcull_percent ||
	    cache->bcull_percent >= cache->brun_percent ||
	    cache->brun_percent  >= 100)
		return -ERANGE;

	if (!cache->rootdirname) {
		pr_err("No cache directory specified\n");
		return -EINVAL;
	}

	/* Don't permit already bound caches to be re-bound */
	if (test_bit(CACHEFILES_READY, &cache->flags)) {
		pr_err("Cache already bound\n");
		return -EBUSY;
	}

	if (IS_ENABLED(CONFIG_CACHEFILES_ONDEMAND)) {
		if (!strcmp(args, "ondemand")) {
			set_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags);
		} else if (*args) {
			pr_err("Invalid argument to the 'bind' command\n");
			return -EINVAL;
		}
	} else if (*args) {
		pr_err("'bind' command doesn't take an argument\n");
		return -EINVAL;
	}

	/* Make sure we have copies of the tag string */
	if (!cache->tag) {
		/*
		 * The tag string is released by the fops->release()
		 * function, so we don't release it on error here
		 */
		cache->tag = kstrdup("CacheFiles", GFP_KERNEL);
		if (!cache->tag)
			return -ENOMEM;
	}

	return cachefiles_add_cache(cache);
}

/*
 * Unbind a cache.
 */
static void cachefiles_daemon_unbind(struct cachefiles_cache *cache)
{
	_enter("");

	if (test_bit(CACHEFILES_READY, &cache->flags))
		cachefiles_withdraw_cache(cache);

	cachefiles_put_directory(cache->graveyard);
	cachefiles_put_directory(cache->store);
	mntput(cache->mnt);

	kfree(cache->rootdirname);
	kfree(cache->secctx);
	kfree(cache->tag);

	_leave("");
}
Commit	Line	Data
8667d434 DH	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/* Daemon interface
	3	*
	4	* Copyright (C) 2007, 2021 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells (dhowells@redhat.com)
	6	*/
	7
	8	#include <linux/module.h>
	9	#include <linux/init.h>
	10	#include <linux/sched.h>
	11	#include <linux/completion.h>
	12	#include <linux/slab.h>
	13	#include <linux/fs.h>
	14	#include <linux/file.h>
	15	#include <linux/namei.h>
	16	#include <linux/poll.h>
	17	#include <linux/mount.h>
	18	#include <linux/statfs.h>
	19	#include <linux/ctype.h>
	20	#include <linux/string.h>
	21	#include <linux/fs_struct.h>
	22	#include "internal.h"
	23
	24	static int cachefiles_daemon_open(struct inode , struct file );
	25	static int cachefiles_daemon_release(struct inode , struct file );
	26	static ssize_t cachefiles_daemon_read(struct file , char __user , size_t,
	27	loff_t *);
	28	static ssize_t cachefiles_daemon_write(struct file , const char __user ,
	29	size_t, loff_t *);
	30	static __poll_t cachefiles_daemon_poll(struct file *,
	31	struct poll_table_struct *);
	32	static int cachefiles_daemon_frun(struct cachefiles_cache , char );
	33	static int cachefiles_daemon_fcull(struct cachefiles_cache , char );
	34	static int cachefiles_daemon_fstop(struct cachefiles_cache , char );
	35	static int cachefiles_daemon_brun(struct cachefiles_cache , char );
	36	static int cachefiles_daemon_bcull(struct cachefiles_cache , char );
	37	static int cachefiles_daemon_bstop(struct cachefiles_cache , char );
	38	static int cachefiles_daemon_cull(struct cachefiles_cache , char );
	39	static int cachefiles_daemon_debug(struct cachefiles_cache , char );
	40	static int cachefiles_daemon_dir(struct cachefiles_cache , char );
	41	static int cachefiles_daemon_inuse(struct cachefiles_cache , char );
	42	static int cachefiles_daemon_secctx(struct cachefiles_cache , char );
	43	static int cachefiles_daemon_tag(struct cachefiles_cache , char );
	44	static int cachefiles_daemon_bind(struct cachefiles_cache , char );
	45	static void cachefiles_daemon_unbind(struct cachefiles_cache *);
	46
	47	static unsigned long cachefiles_open;
	48
	49	const struct file_operations cachefiles_daemon_fops = {
	50	.owner = THIS_MODULE,
	51	.open = cachefiles_daemon_open,
	52	.release = cachefiles_daemon_release,
	53	.read = cachefiles_daemon_read,
	54	.write = cachefiles_daemon_write,
	55	.poll = cachefiles_daemon_poll,
	56	.llseek = noop_llseek,
	57	};
	58
	59	struct cachefiles_daemon_cmd {
	60	char name[8];
	61	int (handler)(struct cachefiles_cache cache, char *args);
	62	};
	63
	64	static const struct cachefiles_daemon_cmd cachefiles_daemon_cmds[] = {
65	{ "bind", cachefiles_daemon_bind },
66	{ "brun", cachefiles_daemon_brun },
67	{ "bcull", cachefiles_daemon_bcull },
68	{ "bstop", cachefiles_daemon_bstop },
69	{ "cull", cachefiles_daemon_cull },
70	{ "debug", cachefiles_daemon_debug },
71	{ "dir", cachefiles_daemon_dir },
72	{ "frun", cachefiles_daemon_frun },
73	{ "fcull", cachefiles_daemon_fcull },
74	{ "fstop", cachefiles_daemon_fstop },
75	{ "inuse", cachefiles_daemon_inuse },
76	{ "secctx", cachefiles_daemon_secctx },
77	{ "tag", cachefiles_daemon_tag },
c8383054 JX	78	#ifdef CONFIG_CACHEFILES_ONDEMAND
	79	{ "copen", cachefiles_ondemand_copen },
	80	#endif
8667d434 DH	81	{ "", NULL }
	82	};
	83
	84
	85	/*
	86	* Prepare a cache for caching.
	87	*/
	88	static int cachefiles_daemon_open(struct inode inode, struct file file)
	89	{
	90	struct cachefiles_cache *cache;
	91
	92	_enter("");
	93
	94	/* only the superuser may do this */
	95	if (!capable(CAP_SYS_ADMIN))
	96	return -EPERM;
	97
	98	/* the cachefiles device may only be open once at a time */
	99	if (xchg(&cachefiles_open, 1) == 1)
	100	return -EBUSY;
	101
	102	/* allocate a cache record */
	103	cache = kzalloc(sizeof(struct cachefiles_cache), GFP_KERNEL);
	104	if (!cache) {
	105	cachefiles_open = 0;
	106	return -ENOMEM;
	107	}
	108
	109	mutex_init(&cache->daemon_mutex);
	110	init_waitqueue_head(&cache->daemon_pollwq);
fe2140e2	111	INIT_LIST_HEAD(&cache->volumes);
1f08c925	112	INIT_LIST_HEAD(&cache->object_list);
fe2140e2	113	spin_lock_init(&cache->object_list_lock);
d11b0b04	114	refcount_set(&cache->unbind_pincount, 1);
c8383054 JX	115	xa_init_flags(&cache->reqs, XA_FLAGS_ALLOC);
c8383054 JX	116	xa_init_flags(&cache->ondemand_ids, XA_FLAGS_ALLOC1);
8667d434 DH	117
	118	/* set default caching limits
	119	* - limit at 1% free space and/or free files
	120	* - cull below 5% free space and/or free files
	121	* - cease culling above 7% free space and/or free files
	122	*/
	123	cache->frun_percent = 7;
	124	cache->fcull_percent = 5;
	125	cache->fstop_percent = 1;
	126	cache->brun_percent = 7;
	127	cache->bcull_percent = 5;
	128	cache->bstop_percent = 1;
	129
	130	file->private_data = cache;
	131	cache->cachefilesd = file;
	132	return 0;
	133	}
	134
c8383054 JX	135	static void cachefiles_flush_reqs(struct cachefiles_cache *cache)
	136	{
	137	struct xarray *xa = &cache->reqs;
	138	struct cachefiles_req *req;
	139	unsigned long index;
	140
	141	/*
	142	* Make sure the following two operations won't be reordered.
	143	* 1) set CACHEFILES_DEAD bit
	144	* 2) flush requests in the xarray
	145	* Otherwise the request may be enqueued after xarray has been
	146	* flushed, leaving the orphan request never being completed.
	147	*
	148	* CPU 1 CPU 2
	149	* ===== =====
	150	* flush requests in the xarray
	151	* test CACHEFILES_DEAD bit
	152	* enqueue the request
	153	* set CACHEFILES_DEAD bit
	154	*/
	155	smp_mb();
	156
	157	xa_lock(xa);
	158	xa_for_each(xa, index, req) {
	159	req->error = -EIO;
	160	complete(&req->done);
	161	}
	162	xa_unlock(xa);
	163
	164	xa_destroy(&cache->reqs);
	165	xa_destroy(&cache->ondemand_ids);
	166	}
	167
d11b0b04 JX	168	void cachefiles_put_unbind_pincount(struct cachefiles_cache *cache)
	169	{
	170	if (refcount_dec_and_test(&cache->unbind_pincount)) {
	171	cachefiles_daemon_unbind(cache);
	172	cachefiles_open = 0;
	173	kfree(cache);
	174	}
	175	}
	176
	177	void cachefiles_get_unbind_pincount(struct cachefiles_cache *cache)
	178	{
	179	refcount_inc(&cache->unbind_pincount);
	180	}
	181
8667d434 DH	182	/*
	183	* Release a cache.
	184	*/
	185	static int cachefiles_daemon_release(struct inode inode, struct file file)
	186	{
	187	struct cachefiles_cache *cache = file->private_data;
	188
	189	_enter("");
	190
	191	ASSERT(cache);
	192
	193	set_bit(CACHEFILES_DEAD, &cache->flags);
	194
c8383054 JX	195	if (cachefiles_in_ondemand_mode(cache))
c8383054 JX	196	cachefiles_flush_reqs(cache);
8667d434 DH	197
	198	/* clean up the control file interface */
	199	cache->cachefilesd = NULL;
	200	file->private_data = NULL;
8667d434	201
d11b0b04	202	cachefiles_put_unbind_pincount(cache);
8667d434 DH	203
	204	_leave("");
	205	return 0;
	206	}
	207
c8383054 JX	208	static ssize_t cachefiles_do_daemon_read(struct cachefiles_cache *cache,
c8383054 JX	209	char __user *_buffer, size_t buflen)
8667d434	210	{
8667d434 DH	211	unsigned long long b_released;
	212	unsigned f_released;
	213	char buffer[256];
	214	int n;
	215
8667d434	216	/* check how much space the cache has */
3929eca7	217	cachefiles_has_space(cache, 0, 0, cachefiles_has_space_check);
8667d434 DH	218
	219	/* summarise */
	220	f_released = atomic_xchg(&cache->f_released, 0);
	221	b_released = atomic_long_xchg(&cache->b_released, 0);
	222	clear_bit(CACHEFILES_STATE_CHANGED, &cache->flags);
	223
	224	n = snprintf(buffer, sizeof(buffer),
	225	"cull=%c"
	226	" frun=%llx"
	227	" fcull=%llx"
	228	" fstop=%llx"
	229	" brun=%llx"
	230	" bcull=%llx"
	231	" bstop=%llx"
	232	" freleased=%x"
	233	" breleased=%llx",
	234	test_bit(CACHEFILES_CULLING, &cache->flags) ? '1' : '0',
	235	(unsigned long long) cache->frun,
	236	(unsigned long long) cache->fcull,
	237	(unsigned long long) cache->fstop,
	238	(unsigned long long) cache->brun,
	239	(unsigned long long) cache->bcull,
	240	(unsigned long long) cache->bstop,
	241	f_released,
	242	b_released);
	243
	244	if (n > buflen)
	245	return -EMSGSIZE;
	246
	247	if (copy_to_user(_buffer, buffer, n) != 0)
	248	return -EFAULT;
	249
	250	return n;
	251	}
	252
c8383054 JX	253	/*
	254	* Read the cache state.
	255	*/
	256	static ssize_t cachefiles_daemon_read(struct file file, char __user _buffer,
	257	size_t buflen, loff_t *pos)
	258	{
	259	struct cachefiles_cache *cache = file->private_data;
	260
	261	//_enter(",,%zu,", buflen);
	262
	263	if (!test_bit(CACHEFILES_READY, &cache->flags))
	264	return 0;
	265
	266	if (cachefiles_in_ondemand_mode(cache))
	267	return cachefiles_ondemand_daemon_read(cache, _buffer, buflen);
	268	else
	269	return cachefiles_do_daemon_read(cache, _buffer, buflen);
	270	}
	271
8667d434 DH	272	/*
	273	* Take a command from cachefilesd, parse it and act on it.
	274	*/
	275	static ssize_t cachefiles_daemon_write(struct file *file,
	276	const char __user *_data,
	277	size_t datalen,
	278	loff_t *pos)
	279	{
	280	const struct cachefiles_daemon_cmd *cmd;
	281	struct cachefiles_cache *cache = file->private_data;
	282	ssize_t ret;
	283	char data, args, *cp;
	284
	285	//_enter(",,%zu,", datalen);
	286
	287	ASSERT(cache);
	288
	289	if (test_bit(CACHEFILES_DEAD, &cache->flags))
	290	return -EIO;
	291
	292	if (datalen > PAGE_SIZE - 1)
	293	return -EOPNOTSUPP;
	294
	295	/* drag the command string into the kernel so we can parse it */
	296	data = memdup_user_nul(_data, datalen);
	297	if (IS_ERR(data))
	298	return PTR_ERR(data);
	299
	300	ret = -EINVAL;
	301	if (memchr(data, '\0', datalen))
	302	goto error;
	303
	304	/* strip any newline */
	305	cp = memchr(data, '\n', datalen);
	306	if (cp) {
	307	if (cp == data)
	308	goto error;
	309
	310	*cp = '\0';
	311	}
	312
	313	/* parse the command */
	314	ret = -EOPNOTSUPP;
	315
	316	for (args = data; *args; args++)
	317	if (isspace(*args))
	318	break;
	319	if (*args) {
	320	if (args == data)
	321	goto error;
	322	*args = '\0';
	323	args = skip_spaces(++args);
	324	}
	325
	326	/* run the appropriate command handler */
	327	for (cmd = cachefiles_daemon_cmds; cmd->name[0]; cmd++)
	328	if (strcmp(cmd->name, data) == 0)
	329	goto found_command;
	330
	331	error:
	332	kfree(data);
	333	//_leave(" = %zd", ret);
	334	return ret;
	335
336	found_command:
337	mutex_lock(&cache->daemon_mutex);
338
339	ret = -EIO;
340	if (!test_bit(CACHEFILES_DEAD, &cache->flags))
341	ret = cmd->handler(cache, args);
342
343	mutex_unlock(&cache->daemon_mutex);
344
345	if (ret == 0)
346	ret = datalen;
347	goto error;
348	}
349
350	/*
351	* Poll for culling state
352	* - use EPOLLOUT to indicate culling state
353	*/
354	static __poll_t cachefiles_daemon_poll(struct file *file,
355	struct poll_table_struct *poll)
356	{
357	struct cachefiles_cache *cache = file->private_data;
358	__poll_t mask;
359
360	poll_wait(file, &cache->daemon_pollwq, poll);
361	mask = 0;
362
c8383054 JX	363	if (cachefiles_in_ondemand_mode(cache)) {
	364	if (!xa_empty(&cache->reqs))
	365	mask \|= EPOLLIN;
	366	} else {
	367	if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags))
	368	mask \|= EPOLLIN;
	369	}
8667d434 DH	370
	371	if (test_bit(CACHEFILES_CULLING, &cache->flags))
	372	mask \|= EPOLLOUT;
	373
	374	return mask;
	375	}
	376
	377	/*
	378	* Give a range error for cache space constraints
	379	* - can be tail-called
	380	*/
	381	static int cachefiles_daemon_range_error(struct cachefiles_cache *cache,
	382	char *args)
	383	{
	384	pr_err("Free space limits must be in range 0%%<=stop<cull<run<100%%\n");
	385
	386	return -EINVAL;
	387	}
	388
	389	/*
	390	* Set the percentage of files at which to stop culling
	391	* - command: "frun <N>%"
	392	*/
	393	static int cachefiles_daemon_frun(struct cachefiles_cache cache, char args)
	394	{
	395	unsigned long frun;
	396
	397	_enter(",%s", args);
	398
	399	if (!*args)
	400	return -EINVAL;
	401
	402	frun = simple_strtoul(args, &args, 10);
	403	if (args[0] != '%' \|\| args[1] != '\0')
	404	return -EINVAL;
	405
	406	if (frun <= cache->fcull_percent \|\| frun >= 100)
	407	return cachefiles_daemon_range_error(cache, args);
	408
	409	cache->frun_percent = frun;
	410	return 0;
	411	}
	412
	413	/*
	414	* Set the percentage of files at which to start culling
	415	* - command: "fcull <N>%"
	416	*/
	417	static int cachefiles_daemon_fcull(struct cachefiles_cache cache, char args)
	418	{
	419	unsigned long fcull;
	420
	421	_enter(",%s", args);
	422
	423	if (!*args)
	424	return -EINVAL;
	425
	426	fcull = simple_strtoul(args, &args, 10);
	427	if (args[0] != '%' \|\| args[1] != '\0')
	428	return -EINVAL;
	429
	430	if (fcull <= cache->fstop_percent \|\| fcull >= cache->frun_percent)
	431	return cachefiles_daemon_range_error(cache, args);
	432
	433	cache->fcull_percent = fcull;
434	return 0;
435	}
436
437	/*
438	* Set the percentage of files at which to stop allocating
439	* - command: "fstop <N>%"
440	*/
441	static int cachefiles_daemon_fstop(struct cachefiles_cache cache, char args)
442	{
443	unsigned long fstop;
444
445	_enter(",%s", args);
446
447	if (!*args)
448	return -EINVAL;
449
450	fstop = simple_strtoul(args, &args, 10);
451	if (args[0] != '%' \|\| args[1] != '\0')
452	return -EINVAL;
453
454	if (fstop >= cache->fcull_percent)
455	return cachefiles_daemon_range_error(cache, args);
456
457	cache->fstop_percent = fstop;
458	return 0;
459	}
460
461	/*
462	* Set the percentage of blocks at which to stop culling
463	* - command: "brun <N>%"
464	*/
465	static int cachefiles_daemon_brun(struct cachefiles_cache cache, char args)
466	{
467	unsigned long brun;
468
469	_enter(",%s", args);
470
471	if (!*args)
472	return -EINVAL;
473
474	brun = simple_strtoul(args, &args, 10);
475	if (args[0] != '%' \|\| args[1] != '\0')
476	return -EINVAL;
477
478	if (brun <= cache->bcull_percent \|\| brun >= 100)
479	return cachefiles_daemon_range_error(cache, args);
480
481	cache->brun_percent = brun;
482	return 0;
483	}
484
485	/*
486	* Set the percentage of blocks at which to start culling
487	* - command: "bcull <N>%"
488	*/
489	static int cachefiles_daemon_bcull(struct cachefiles_cache cache, char args)
490	{
491	unsigned long bcull;
492
493	_enter(",%s", args);
494
495	if (!*args)
496	return -EINVAL;
497
498	bcull = simple_strtoul(args, &args, 10);
499	if (args[0] != '%' \|\| args[1] != '\0')
500	return -EINVAL;
501
502	if (bcull <= cache->bstop_percent \|\| bcull >= cache->brun_percent)
503	return cachefiles_daemon_range_error(cache, args);
504
505	cache->bcull_percent = bcull;
506	return 0;
507	}
508
509	/*
510	* Set the percentage of blocks at which to stop allocating
511	* - command: "bstop <N>%"
512	*/
513	static int cachefiles_daemon_bstop(struct cachefiles_cache cache, char args)
514	{
515	unsigned long bstop;
516
517	_enter(",%s", args);
518
519	if (!*args)
520	return -EINVAL;
521
522	bstop = simple_strtoul(args, &args, 10);
523	if (args[0] != '%' \|\| args[1] != '\0')
524	return -EINVAL;
525
526	if (bstop >= cache->bcull_percent)
527	return cachefiles_daemon_range_error(cache, args);
528
529	cache->bstop_percent = bstop;
530	return 0;
531	}
532
533	/*
534	* Set the cache directory
535	* - command: "dir <name>"
536	*/
537	static int cachefiles_daemon_dir(struct cachefiles_cache cache, char args)
538	{
539	char *dir;
540
541	_enter(",%s", args);
542
543	if (!*args) {
544	pr_err("Empty directory specified\n");
545	return -EINVAL;
546	}
547
548	if (cache->rootdirname) {
549	pr_err("Second cache directory specified\n");
550	return -EEXIST;
551	}
552
553	dir = kstrdup(args, GFP_KERNEL);
554	if (!dir)
555	return -ENOMEM;
556
557	cache->rootdirname = dir;
558	return 0;
559	}
560
561	/*
562	* Set the cache security context
563	* - command: "secctx <ctx>"
564	*/
565	static int cachefiles_daemon_secctx(struct cachefiles_cache cache, char args)
566	{
567	char *secctx;
568
569	_enter(",%s", args);
570
571	if (!*args) {
572	pr_err("Empty security context specified\n");
573	return -EINVAL;
574	}
575
576	if (cache->secctx) {
577	pr_err("Second security context specified\n");
578	return -EINVAL;
579	}
580
581	secctx = kstrdup(args, GFP_KERNEL);
582	if (!secctx)
583	return -ENOMEM;
584
585	cache->secctx = secctx;
586	return 0;
587	}
588
589	/*
590	* Set the cache tag
591	* - command: "tag <name>"
592	*/
593	static int cachefiles_daemon_tag(struct cachefiles_cache cache, char args)
594	{
595	char *tag;
596
597	_enter(",%s", args);
598
599	if (!*args) {
600	pr_err("Empty tag specified\n");
601	return -EINVAL;
602	}
603
604	if (cache->tag)
605	return -EEXIST;
606
607	tag = kstrdup(args, GFP_KERNEL);
608	if (!tag)
609	return -ENOMEM;
610
611	cache->tag = tag;
612	return 0;
613	}
614
615	/*
616	* Request a node in the cache be culled from the current working directory
617	* - command: "cull <name>"
618	*/
619	static int cachefiles_daemon_cull(struct cachefiles_cache cache, char args)
620	{
621	struct path path;
622	const struct cred *saved_cred;
623	int ret;
624
625	_enter(",%s", args);
626
627	if (strchr(args, '/'))
628	goto inval;
629
630	if (!test_bit(CACHEFILES_READY, &cache->flags)) {
631	pr_err("cull applied to unready cache\n");
632	return -EIO;
633	}
634
635	if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
636	pr_err("cull applied to dead cache\n");
637	return -EIO;
638	}
639
640	get_fs_pwd(current->fs, &path);
641
642	if (!d_can_lookup(path.dentry))
643	goto notdir;
644
645	cachefiles_begin_secure(cache, &saved_cred);
07a90e97	646	ret = cachefiles_cull(cache, path.dentry, args);
8667d434 DH	647	cachefiles_end_secure(cache, saved_cred);
	648
	649	path_put(&path);
	650	_leave(" = %d", ret);
	651	return ret;
	652
	653	notdir:
	654	path_put(&path);
	655	pr_err("cull command requires dirfd to be a directory\n");
	656	return -ENOTDIR;
	657
	658	inval:
	659	pr_err("cull command requires dirfd and filename\n");
	660	return -EINVAL;
	661	}
	662
	663	/*
	664	* Set debugging mode
	665	* - command: "debug <mask>"
	666	*/
	667	static int cachefiles_daemon_debug(struct cachefiles_cache cache, char args)
	668	{
	669	unsigned long mask;
	670
	671	_enter(",%s", args);
	672
	673	mask = simple_strtoul(args, &args, 0);
	674	if (args[0] != '\0')
	675	goto inval;
	676
	677	cachefiles_debug = mask;
	678	_leave(" = 0");
	679	return 0;
	680
	681	inval:
	682	pr_err("debug command requires mask\n");
	683	return -EINVAL;
	684	}
	685
	686	/*
	687	* Find out whether an object in the current working directory is in use or not
	688	* - command: "inuse <name>"
	689	*/
	690	static int cachefiles_daemon_inuse(struct cachefiles_cache cache, char args)
	691	{
	692	struct path path;
	693	const struct cred *saved_cred;
	694	int ret;
	695
	696	//_enter(",%s", args);
	697
	698	if (strchr(args, '/'))
	699	goto inval;
	700
	701	if (!test_bit(CACHEFILES_READY, &cache->flags)) {
	702	pr_err("inuse applied to unready cache\n");
	703	return -EIO;
	704	}
	705
	706	if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
	707	pr_err("inuse applied to dead cache\n");
	708	return -EIO;
	709	}
	710
711	get_fs_pwd(current->fs, &path);
712
713	if (!d_can_lookup(path.dentry))
714	goto notdir;
715
716	cachefiles_begin_secure(cache, &saved_cred);
07a90e97	717	ret = cachefiles_check_in_use(cache, path.dentry, args);
8667d434 DH	718	cachefiles_end_secure(cache, saved_cred);
	719
	720	path_put(&path);
	721	//_leave(" = %d", ret);
	722	return ret;
	723
	724	notdir:
	725	path_put(&path);
	726	pr_err("inuse command requires dirfd to be a directory\n");
	727	return -ENOTDIR;
	728
	729	inval:
	730	pr_err("inuse command requires dirfd and filename\n");
	731	return -EINVAL;
	732	}
	733
	734	/*
	735	* Bind a directory as a cache
	736	*/
	737	static int cachefiles_daemon_bind(struct cachefiles_cache cache, char args)
	738	{
	739	_enter("{%u,%u,%u,%u,%u,%u},%s",
	740	cache->frun_percent,
	741	cache->fcull_percent,
	742	cache->fstop_percent,
	743	cache->brun_percent,
	744	cache->bcull_percent,
	745	cache->bstop_percent,
	746	args);
	747
	748	if (cache->fstop_percent >= cache->fcull_percent \|\|
	749	cache->fcull_percent >= cache->frun_percent \|\|
	750	cache->frun_percent >= 100)
	751	return -ERANGE;
	752
	753	if (cache->bstop_percent >= cache->bcull_percent \|\|
	754	cache->bcull_percent >= cache->brun_percent \|\|
	755	cache->brun_percent >= 100)
	756	return -ERANGE;
	757
8667d434 DH	758	if (!cache->rootdirname) {
	759	pr_err("No cache directory specified\n");
	760	return -EINVAL;
	761	}
	762
	763	/* Don't permit already bound caches to be re-bound */
	764	if (test_bit(CACHEFILES_READY, &cache->flags)) {
	765	pr_err("Cache already bound\n");
	766	return -EBUSY;
	767	}
	768
4e4f1788 JX	769	if (IS_ENABLED(CONFIG_CACHEFILES_ONDEMAND)) {
	770	if (!strcmp(args, "ondemand")) {
	771	set_bit(CACHEFILES_ONDEMAND_MODE, &cache->flags);
	772	} else if (*args) {
	773	pr_err("Invalid argument to the 'bind' command\n");
	774	return -EINVAL;
	775	}
	776	} else if (*args) {
	777	pr_err("'bind' command doesn't take an argument\n");
	778	return -EINVAL;
	779	}
	780
c7ca7315 JX	781	/* Make sure we have copies of the tag string */
	782	if (!cache->tag) {
	783	/*
	784	* The tag string is released by the fops->release()
	785	* function, so we don't release it on error here
	786	*/
	787	cache->tag = kstrdup("CacheFiles", GFP_KERNEL);
	788	if (!cache->tag)
	789	return -ENOMEM;
	790	}
	791
ecd1a5f6	792	return cachefiles_add_cache(cache);
8667d434 DH	793	}
	794
	795	/*
	796	* Unbind a cache.
	797	*/
	798	static void cachefiles_daemon_unbind(struct cachefiles_cache *cache)
	799	{
	800	_enter("");
	801
d1065b0a DH	802	if (test_bit(CACHEFILES_READY, &cache->flags))
d1065b0a DH	803	cachefiles_withdraw_cache(cache);
8667d434	804
d1065b0a DH	805	cachefiles_put_directory(cache->graveyard);
d1065b0a DH	806	cachefiles_put_directory(cache->store);
8667d434 DH	807	mntput(cache->mnt);
	808
	809	kfree(cache->rootdirname);
	810	kfree(cache->secctx);
	811	kfree(cache->tag);
	812
	813	_leave("");
	814	}