[mirror_ubuntu-focal-kernel.git] / fs / cachefiles / daemon.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* Daemon interface
 *
 * Copyright (C) 2007 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 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		},
	{ "",		NULL				}
};


/*
 * do various checks
 */
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);
	cache->active_nodes = RB_ROOT;
	rwlock_init(&cache->active_lock);
	init_waitqueue_head(&cache->daemon_pollwq);

	/* 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;
}

/*
 * 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);

	cachefiles_daemon_unbind(cache);

	ASSERT(!cache->active_nodes.rb_node);

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

	kfree(cache);

	_leave("");
	return 0;
}

/*
 * 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;
	unsigned long long b_released;
	unsigned f_released;
	char buffer[256];
	int n;

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

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

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

	/* 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;
}

/*
 * command the cache
 */
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 < 0 || 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 (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 < 0 || 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 < 0 || 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;
	}

	/* extract the directory dentry from the cwd */
	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;
	}

	/* extract the directory dentry from the cwd */
	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;
}

/*
 * see if we have space for a number of pages and/or a number of files in the
 * cache
 */
int cachefiles_has_space(struct cachefiles_cache *cache,
			 unsigned fnr, unsigned bnr)
{
	struct kstatfs stats;
	struct path path = {
		.mnt	= cache->mnt,
		.dentry	= cache->mnt->mnt_root,
	};
	int ret;

	//_enter("{%llu,%llu,%llu,%llu,%llu,%llu},%u,%u",
	//       (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,
	//       fnr, bnr);

	/* find out how many pages of blockdev are available */
	memset(&stats, 0, sizeof(stats));

	ret = vfs_statfs(&path, &stats);
	if (ret < 0) {
		if (ret == -EIO)
			cachefiles_io_error(cache, "statfs failed");
		_leave(" = %d", ret);
		return ret;
	}

	stats.f_bavail >>= cache->bshift;

	//_debug("avail %llu,%llu",
	//       (unsigned long long) stats.f_ffree,
	//       (unsigned long long) stats.f_bavail);

	/* see if there is sufficient space */
	if (stats.f_ffree > fnr)
		stats.f_ffree -= fnr;
	else
		stats.f_ffree = 0;

	if (stats.f_bavail > bnr)
		stats.f_bavail -= bnr;
	else
		stats.f_bavail = 0;

	ret = -ENOBUFS;
	if (stats.f_ffree < cache->fstop ||
	    stats.f_bavail < cache->bstop)
		goto begin_cull;

	ret = 0;
	if (stats.f_ffree < cache->fcull ||
	    stats.f_bavail < cache->bcull)
		goto begin_cull;

	if (test_bit(CACHEFILES_CULLING, &cache->flags) &&
	    stats.f_ffree >= cache->frun &&
	    stats.f_bavail >= cache->brun &&
	    test_and_clear_bit(CACHEFILES_CULLING, &cache->flags)
	    ) {
		_debug("cease culling");
		cachefiles_state_changed(cache);
	}

	//_leave(" = 0");
	return 0;

begin_cull:
	if (!test_and_set_bit(CACHEFILES_CULLING, &cache->flags)) {
		_debug("### CULL CACHE ###");
		cachefiles_state_changed(cache);
	}

	_leave(" = %d", ret);
	return ret;
}
Commit	Line	Data
b4d0d230	1	// SPDX-License-Identifier: GPL-2.0-or-later
9ae326a6 DH	2	/* Daemon interface
	3	*
	4	* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells (dhowells@redhat.com)
9ae326a6 DH	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>
e7d2860b	20	#include <linux/string.h>
9ae326a6 DH	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 *);
076ccb76	30	static __poll_t cachefiles_daemon_poll(struct file *,
9ae326a6 DH	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
	45	static unsigned long cachefiles_open;
	46
	47	const struct file_operations cachefiles_daemon_fops = {
	48	.owner = THIS_MODULE,
	49	.open = cachefiles_daemon_open,
	50	.release = cachefiles_daemon_release,
	51	.read = cachefiles_daemon_read,
	52	.write = cachefiles_daemon_write,
	53	.poll = cachefiles_daemon_poll,
6038f373	54	.llseek = noop_llseek,
9ae326a6 DH	55	};
	56
	57	struct cachefiles_daemon_cmd {
	58	char name[8];
	59	int (handler)(struct cachefiles_cache cache, char *args);
	60	};
	61
	62	static const struct cachefiles_daemon_cmd cachefiles_daemon_cmds[] = {
	63	{ "bind", cachefiles_daemon_bind },
	64	{ "brun", cachefiles_daemon_brun },
	65	{ "bcull", cachefiles_daemon_bcull },
	66	{ "bstop", cachefiles_daemon_bstop },
	67	{ "cull", cachefiles_daemon_cull },
	68	{ "debug", cachefiles_daemon_debug },
	69	{ "dir", cachefiles_daemon_dir },
	70	{ "frun", cachefiles_daemon_frun },
	71	{ "fcull", cachefiles_daemon_fcull },
	72	{ "fstop", cachefiles_daemon_fstop },
	73	{ "inuse", cachefiles_daemon_inuse },
	74	{ "secctx", cachefiles_daemon_secctx },
	75	{ "tag", cachefiles_daemon_tag },
	76	{ "", NULL }
	77	};
	78
	79
	80	/*
	81	* do various checks
	82	*/
	83	static int cachefiles_daemon_open(struct inode inode, struct file file)
	84	{
	85	struct cachefiles_cache *cache;
	86
	87	_enter("");
	88
	89	/* only the superuser may do this */
	90	if (!capable(CAP_SYS_ADMIN))
	91	return -EPERM;
	92
	93	/* the cachefiles device may only be open once at a time */
	94	if (xchg(&cachefiles_open, 1) == 1)
	95	return -EBUSY;
	96
	97	/* allocate a cache record */
	98	cache = kzalloc(sizeof(struct cachefiles_cache), GFP_KERNEL);
	99	if (!cache) {
	100	cachefiles_open = 0;
	101	return -ENOMEM;
	102	}
	103
	104	mutex_init(&cache->daemon_mutex);
	105	cache->active_nodes = RB_ROOT;
	106	rwlock_init(&cache->active_lock);
	107	init_waitqueue_head(&cache->daemon_pollwq);
	108
	109	/* set default caching limits
	110	* - limit at 1% free space and/or free files
	111	* - cull below 5% free space and/or free files
	112	* - cease culling above 7% free space and/or free files
	113	*/
	114	cache->frun_percent = 7;
	115	cache->fcull_percent = 5;
	116	cache->fstop_percent = 1;
	117	cache->brun_percent = 7;
	118	cache->bcull_percent = 5;
119	cache->bstop_percent = 1;
120
121	file->private_data = cache;
122	cache->cachefilesd = file;
123	return 0;
124	}
125
126	/*
127	* release a cache
128	*/
129	static int cachefiles_daemon_release(struct inode inode, struct file file)
130	{
131	struct cachefiles_cache *cache = file->private_data;
132
133	_enter("");
134
135	ASSERT(cache);
136
137	set_bit(CACHEFILES_DEAD, &cache->flags);
138
139	cachefiles_daemon_unbind(cache);
140
141	ASSERT(!cache->active_nodes.rb_node);
142
143	/* clean up the control file interface */
144	cache->cachefilesd = NULL;
145	file->private_data = NULL;
146	cachefiles_open = 0;
147
148	kfree(cache);
149
150	_leave("");
151	return 0;
152	}
153
154	/*
155	* read the cache state
156	*/
157	static ssize_t cachefiles_daemon_read(struct file file, char __user _buffer,
158	size_t buflen, loff_t *pos)
159	{
160	struct cachefiles_cache *cache = file->private_data;
a5b3a80b DH	161	unsigned long long b_released;
a5b3a80b DH	162	unsigned f_released;
9ae326a6 DH	163	char buffer[256];
	164	int n;
	165
	166	//_enter(",,%zu,", buflen);
	167
	168	if (!test_bit(CACHEFILES_READY, &cache->flags))
	169	return 0;
	170
	171	/* check how much space the cache has */
	172	cachefiles_has_space(cache, 0, 0);
	173
	174	/* summarise */
a5b3a80b DH	175	f_released = atomic_xchg(&cache->f_released, 0);
a5b3a80b DH	176	b_released = atomic_long_xchg(&cache->b_released, 0);
9ae326a6 DH	177	clear_bit(CACHEFILES_STATE_CHANGED, &cache->flags);
	178
	179	n = snprintf(buffer, sizeof(buffer),
	180	"cull=%c"
	181	" frun=%llx"
	182	" fcull=%llx"
	183	" fstop=%llx"
	184	" brun=%llx"
	185	" bcull=%llx"
a5b3a80b DH	186	" bstop=%llx"
	187	" freleased=%x"
	188	" breleased=%llx",
9ae326a6 DH	189	test_bit(CACHEFILES_CULLING, &cache->flags) ? '1' : '0',
	190	(unsigned long long) cache->frun,
	191	(unsigned long long) cache->fcull,
	192	(unsigned long long) cache->fstop,
	193	(unsigned long long) cache->brun,
	194	(unsigned long long) cache->bcull,
a5b3a80b DH	195	(unsigned long long) cache->bstop,
	196	f_released,
	197	b_released);
9ae326a6 DH	198
	199	if (n > buflen)
	200	return -EMSGSIZE;
	201
	202	if (copy_to_user(_buffer, buffer, n) != 0)
	203	return -EFAULT;
	204
	205	return n;
	206	}
	207
	208	/*
	209	* command the cache
	210	*/
	211	static ssize_t cachefiles_daemon_write(struct file *file,
	212	const char __user *_data,
	213	size_t datalen,
	214	loff_t *pos)
	215	{
	216	const struct cachefiles_daemon_cmd *cmd;
	217	struct cachefiles_cache *cache = file->private_data;
	218	ssize_t ret;
	219	char data, args, *cp;
	220
	221	//_enter(",,%zu,", datalen);
	222
	223	ASSERT(cache);
	224
	225	if (test_bit(CACHEFILES_DEAD, &cache->flags))
	226	return -EIO;
	227
	228	if (datalen < 0 \|\| datalen > PAGE_SIZE - 1)
	229	return -EOPNOTSUPP;
	230
	231	/* drag the command string into the kernel so we can parse it */
16e5c1fc AV	232	data = memdup_user_nul(_data, datalen);
	233	if (IS_ERR(data))
	234	return PTR_ERR(data);
9ae326a6 DH	235
	236	ret = -EINVAL;
	237	if (memchr(data, '\0', datalen))
	238	goto error;
	239
	240	/* strip any newline */
	241	cp = memchr(data, '\n', datalen);
	242	if (cp) {
	243	if (cp == data)
	244	goto error;
	245
	246	*cp = '\0';
	247	}
	248
	249	/* parse the command */
	250	ret = -EOPNOTSUPP;
	251
	252	for (args = data; *args; args++)
	253	if (isspace(*args))
	254	break;
	255	if (*args) {
	256	if (args == data)
	257	goto error;
	258	*args = '\0';
e7d2860b	259	args = skip_spaces(++args);
9ae326a6 DH	260	}
	261
	262	/* run the appropriate command handler */
	263	for (cmd = cachefiles_daemon_cmds; cmd->name[0]; cmd++)
	264	if (strcmp(cmd->name, data) == 0)
	265	goto found_command;
	266
	267	error:
	268	kfree(data);
	269	//_leave(" = %zd", ret);
	270	return ret;
	271
	272	found_command:
	273	mutex_lock(&cache->daemon_mutex);
	274
	275	ret = -EIO;
	276	if (!test_bit(CACHEFILES_DEAD, &cache->flags))
	277	ret = cmd->handler(cache, args);
	278
	279	mutex_unlock(&cache->daemon_mutex);
	280
	281	if (ret == 0)
	282	ret = datalen;
	283	goto error;
	284	}
	285
	286	/*
	287	* poll for culling state
a9a08845	288	* - use EPOLLOUT to indicate culling state
9ae326a6	289	*/
076ccb76	290	static __poll_t cachefiles_daemon_poll(struct file *file,
9ae326a6 DH	291	struct poll_table_struct *poll)
	292	{
	293	struct cachefiles_cache *cache = file->private_data;
076ccb76	294	__poll_t mask;
9ae326a6 DH	295
	296	poll_wait(file, &cache->daemon_pollwq, poll);
	297	mask = 0;
	298
	299	if (test_bit(CACHEFILES_STATE_CHANGED, &cache->flags))
a9a08845	300	mask \|= EPOLLIN;
9ae326a6 DH	301
9ae326a6 DH	302	if (test_bit(CACHEFILES_CULLING, &cache->flags))
a9a08845	303	mask \|= EPOLLOUT;
9ae326a6 DH	304
	305	return mask;
	306	}
	307
	308	/*
	309	* give a range error for cache space constraints
	310	* - can be tail-called
	311	*/
	312	static int cachefiles_daemon_range_error(struct cachefiles_cache *cache,
	313	char *args)
	314	{
6ff66ac7	315	pr_err("Free space limits must be in range 0%%<=stop<cull<run<100%%\n");
9ae326a6 DH	316
	317	return -EINVAL;
	318	}
	319
	320	/*
	321	* set the percentage of files at which to stop culling
	322	* - command: "frun <N>%"
	323	*/
	324	static int cachefiles_daemon_frun(struct cachefiles_cache cache, char args)
	325	{
	326	unsigned long frun;
	327
	328	_enter(",%s", args);
	329
	330	if (!*args)
	331	return -EINVAL;
	332
	333	frun = simple_strtoul(args, &args, 10);
	334	if (args[0] != '%' \|\| args[1] != '\0')
	335	return -EINVAL;
	336
	337	if (frun <= cache->fcull_percent \|\| frun >= 100)
	338	return cachefiles_daemon_range_error(cache, args);
	339
	340	cache->frun_percent = frun;
	341	return 0;
	342	}
	343
	344	/*
	345	* set the percentage of files at which to start culling
	346	* - command: "fcull <N>%"
	347	*/
	348	static int cachefiles_daemon_fcull(struct cachefiles_cache cache, char args)
	349	{
	350	unsigned long fcull;
	351
	352	_enter(",%s", args);
	353
	354	if (!*args)
	355	return -EINVAL;
	356
	357	fcull = simple_strtoul(args, &args, 10);
	358	if (args[0] != '%' \|\| args[1] != '\0')
	359	return -EINVAL;
	360
	361	if (fcull <= cache->fstop_percent \|\| fcull >= cache->frun_percent)
	362	return cachefiles_daemon_range_error(cache, args);
	363
	364	cache->fcull_percent = fcull;
	365	return 0;
	366	}
	367
	368	/*
	369	* set the percentage of files at which to stop allocating
	370	* - command: "fstop <N>%"
	371	*/
	372	static int cachefiles_daemon_fstop(struct cachefiles_cache cache, char args)
	373	{
	374	unsigned long fstop;
	375
	376	_enter(",%s", args);
	377
	378	if (!*args)
	379	return -EINVAL;
380
381	fstop = simple_strtoul(args, &args, 10);
382	if (args[0] != '%' \|\| args[1] != '\0')
383	return -EINVAL;
384
385	if (fstop < 0 \|\| fstop >= cache->fcull_percent)
386	return cachefiles_daemon_range_error(cache, args);
387
388	cache->fstop_percent = fstop;
389	return 0;
390	}
391
392	/*
393	* set the percentage of blocks at which to stop culling
394	* - command: "brun <N>%"
395	*/
396	static int cachefiles_daemon_brun(struct cachefiles_cache cache, char args)
397	{
398	unsigned long brun;
399
400	_enter(",%s", args);
401
402	if (!*args)
403	return -EINVAL;
404
405	brun = simple_strtoul(args, &args, 10);
406	if (args[0] != '%' \|\| args[1] != '\0')
407	return -EINVAL;
408
409	if (brun <= cache->bcull_percent \|\| brun >= 100)
410	return cachefiles_daemon_range_error(cache, args);
411
412	cache->brun_percent = brun;
413	return 0;
414	}
415
416	/*
417	* set the percentage of blocks at which to start culling
418	* - command: "bcull <N>%"
419	*/
420	static int cachefiles_daemon_bcull(struct cachefiles_cache cache, char args)
421	{
422	unsigned long bcull;
423
424	_enter(",%s", args);
425
426	if (!*args)
427	return -EINVAL;
428
429	bcull = simple_strtoul(args, &args, 10);
430	if (args[0] != '%' \|\| args[1] != '\0')
431	return -EINVAL;
432
433	if (bcull <= cache->bstop_percent \|\| bcull >= cache->brun_percent)
434	return cachefiles_daemon_range_error(cache, args);
435
436	cache->bcull_percent = bcull;
437	return 0;
438	}
439
440	/*
441	* set the percentage of blocks at which to stop allocating
442	* - command: "bstop <N>%"
443	*/
444	static int cachefiles_daemon_bstop(struct cachefiles_cache cache, char args)
445	{
446	unsigned long bstop;
447
448	_enter(",%s", args);
449
450	if (!*args)
451	return -EINVAL;
452
453	bstop = simple_strtoul(args, &args, 10);
454	if (args[0] != '%' \|\| args[1] != '\0')
455	return -EINVAL;
456
457	if (bstop < 0 \|\| bstop >= cache->bcull_percent)
458	return cachefiles_daemon_range_error(cache, args);
459
460	cache->bstop_percent = bstop;
461	return 0;
462	}
463
464	/*
465	* set the cache directory
466	* - command: "dir <name>"
467	*/
468	static int cachefiles_daemon_dir(struct cachefiles_cache cache, char args)
469	{
470	char *dir;
471
472	_enter(",%s", args);
473
474	if (!*args) {
6ff66ac7	475	pr_err("Empty directory specified\n");
9ae326a6 DH	476	return -EINVAL;
	477	}
	478
	479	if (cache->rootdirname) {
6ff66ac7	480	pr_err("Second cache directory specified\n");
9ae326a6 DH	481	return -EEXIST;
	482	}
	483
	484	dir = kstrdup(args, GFP_KERNEL);
	485	if (!dir)
	486	return -ENOMEM;
	487
	488	cache->rootdirname = dir;
	489	return 0;
	490	}
	491
	492	/*
	493	* set the cache security context
	494	* - command: "secctx <ctx>"
	495	*/
	496	static int cachefiles_daemon_secctx(struct cachefiles_cache cache, char args)
	497	{
	498	char *secctx;
	499
	500	_enter(",%s", args);
	501
	502	if (!*args) {
6ff66ac7	503	pr_err("Empty security context specified\n");
9ae326a6 DH	504	return -EINVAL;
	505	}
	506
	507	if (cache->secctx) {
6ff66ac7	508	pr_err("Second security context specified\n");
9ae326a6 DH	509	return -EINVAL;
	510	}
	511
	512	secctx = kstrdup(args, GFP_KERNEL);
	513	if (!secctx)
	514	return -ENOMEM;
	515
	516	cache->secctx = secctx;
	517	return 0;
	518	}
	519
	520	/*
	521	* set the cache tag
	522	* - command: "tag <name>"
	523	*/
	524	static int cachefiles_daemon_tag(struct cachefiles_cache cache, char args)
	525	{
	526	char *tag;
	527
	528	_enter(",%s", args);
	529
	530	if (!*args) {
6ff66ac7	531	pr_err("Empty tag specified\n");
9ae326a6 DH	532	return -EINVAL;
	533	}
	534
	535	if (cache->tag)
	536	return -EEXIST;
	537
	538	tag = kstrdup(args, GFP_KERNEL);
	539	if (!tag)
	540	return -ENOMEM;
	541
	542	cache->tag = tag;
	543	return 0;
	544	}
	545
	546	/*
	547	* request a node in the cache be culled from the current working directory
	548	* - command: "cull <name>"
	549	*/
	550	static int cachefiles_daemon_cull(struct cachefiles_cache cache, char args)
	551	{
542ce7a9	552	struct path path;
9ae326a6 DH	553	const struct cred *saved_cred;
	554	int ret;
	555
	556	_enter(",%s", args);
	557
	558	if (strchr(args, '/'))
	559	goto inval;
	560
	561	if (!test_bit(CACHEFILES_READY, &cache->flags)) {
6ff66ac7	562	pr_err("cull applied to unready cache\n");
9ae326a6 DH	563	return -EIO;
	564	}
	565
	566	if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
6ff66ac7	567	pr_err("cull applied to dead cache\n");
9ae326a6 DH	568	return -EIO;
	569	}
	570
	571	/* extract the directory dentry from the cwd */
f7ad3c6b	572	get_fs_pwd(current->fs, &path);
9ae326a6	573
ce40fa78	574	if (!d_can_lookup(path.dentry))
9ae326a6 DH	575	goto notdir;
	576
	577	cachefiles_begin_secure(cache, &saved_cred);
542ce7a9	578	ret = cachefiles_cull(cache, path.dentry, args);
9ae326a6 DH	579	cachefiles_end_secure(cache, saved_cred);
9ae326a6 DH	580
542ce7a9	581	path_put(&path);
9ae326a6 DH	582	_leave(" = %d", ret);
	583	return ret;
	584
	585	notdir:
542ce7a9	586	path_put(&path);
6ff66ac7	587	pr_err("cull command requires dirfd to be a directory\n");
9ae326a6 DH	588	return -ENOTDIR;
	589
	590	inval:
6ff66ac7	591	pr_err("cull command requires dirfd and filename\n");
9ae326a6 DH	592	return -EINVAL;
	593	}
	594
	595	/*
	596	* set debugging mode
	597	* - command: "debug <mask>"
	598	*/
	599	static int cachefiles_daemon_debug(struct cachefiles_cache cache, char args)
	600	{
	601	unsigned long mask;
	602
	603	_enter(",%s", args);
	604
	605	mask = simple_strtoul(args, &args, 0);
	606	if (args[0] != '\0')
	607	goto inval;
	608
	609	cachefiles_debug = mask;
	610	_leave(" = 0");
	611	return 0;
	612
	613	inval:
6ff66ac7	614	pr_err("debug command requires mask\n");
9ae326a6 DH	615	return -EINVAL;
	616	}
	617
	618	/*
	619	* find out whether an object in the current working directory is in use or not
	620	* - command: "inuse <name>"
	621	*/
	622	static int cachefiles_daemon_inuse(struct cachefiles_cache cache, char args)
	623	{
542ce7a9	624	struct path path;
9ae326a6 DH	625	const struct cred *saved_cred;
	626	int ret;
	627
	628	//_enter(",%s", args);
	629
	630	if (strchr(args, '/'))
	631	goto inval;
	632
	633	if (!test_bit(CACHEFILES_READY, &cache->flags)) {
6ff66ac7	634	pr_err("inuse applied to unready cache\n");
9ae326a6 DH	635	return -EIO;
	636	}
	637
	638	if (test_bit(CACHEFILES_DEAD, &cache->flags)) {
6ff66ac7	639	pr_err("inuse applied to dead cache\n");
9ae326a6 DH	640	return -EIO;
	641	}
	642
	643	/* extract the directory dentry from the cwd */
f7ad3c6b	644	get_fs_pwd(current->fs, &path);
9ae326a6	645
ce40fa78	646	if (!d_can_lookup(path.dentry))
9ae326a6 DH	647	goto notdir;
	648
	649	cachefiles_begin_secure(cache, &saved_cred);
542ce7a9	650	ret = cachefiles_check_in_use(cache, path.dentry, args);
9ae326a6 DH	651	cachefiles_end_secure(cache, saved_cred);
9ae326a6 DH	652
542ce7a9	653	path_put(&path);
9ae326a6 DH	654	//_leave(" = %d", ret);
	655	return ret;
	656
	657	notdir:
542ce7a9	658	path_put(&path);
6ff66ac7	659	pr_err("inuse command requires dirfd to be a directory\n");
9ae326a6 DH	660	return -ENOTDIR;
	661
	662	inval:
6ff66ac7	663	pr_err("inuse command requires dirfd and filename\n");
9ae326a6 DH	664	return -EINVAL;
	665	}
	666
	667	/*
	668	* see if we have space for a number of pages and/or a number of files in the
	669	* cache
	670	*/
	671	int cachefiles_has_space(struct cachefiles_cache *cache,
	672	unsigned fnr, unsigned bnr)
	673	{
	674	struct kstatfs stats;
ebabe9a9 CH	675	struct path path = {
	676	.mnt = cache->mnt,
	677	.dentry = cache->mnt->mnt_root,
	678	};
9ae326a6 DH	679	int ret;
	680
	681	//_enter("{%llu,%llu,%llu,%llu,%llu,%llu},%u,%u",
	682	// (unsigned long long) cache->frun,
	683	// (unsigned long long) cache->fcull,
	684	// (unsigned long long) cache->fstop,
	685	// (unsigned long long) cache->brun,
	686	// (unsigned long long) cache->bcull,
	687	// (unsigned long long) cache->bstop,
	688	// fnr, bnr);
	689
	690	/* find out how many pages of blockdev are available */
	691	memset(&stats, 0, sizeof(stats));
	692
ebabe9a9	693	ret = vfs_statfs(&path, &stats);
9ae326a6 DH	694	if (ret < 0) {
	695	if (ret == -EIO)
	696	cachefiles_io_error(cache, "statfs failed");
	697	_leave(" = %d", ret);
	698	return ret;
	699	}
	700
	701	stats.f_bavail >>= cache->bshift;
	702
	703	//_debug("avail %llu,%llu",
	704	// (unsigned long long) stats.f_ffree,
	705	// (unsigned long long) stats.f_bavail);
	706
	707	/* see if there is sufficient space */
	708	if (stats.f_ffree > fnr)
	709	stats.f_ffree -= fnr;
	710	else
	711	stats.f_ffree = 0;
	712
	713	if (stats.f_bavail > bnr)
	714	stats.f_bavail -= bnr;
	715	else
	716	stats.f_bavail = 0;
	717
	718	ret = -ENOBUFS;
	719	if (stats.f_ffree < cache->fstop \|\|
	720	stats.f_bavail < cache->bstop)
	721	goto begin_cull;
	722
	723	ret = 0;
	724	if (stats.f_ffree < cache->fcull \|\|
	725	stats.f_bavail < cache->bcull)
	726	goto begin_cull;
	727
	728	if (test_bit(CACHEFILES_CULLING, &cache->flags) &&
	729	stats.f_ffree >= cache->frun &&
	730	stats.f_bavail >= cache->brun &&
	731	test_and_clear_bit(CACHEFILES_CULLING, &cache->flags)
	732	) {
	733	_debug("cease culling");
	734	cachefiles_state_changed(cache);
	735	}
	736
	737	//_leave(" = 0");
	738	return 0;
	739
	740	begin_cull:
	741	if (!test_and_set_bit(CACHEFILES_CULLING, &cache->flags)) {
	742	_debug("### CULL CACHE ###");
	743	cachefiles_state_changed(cache);
	744	}
	745
	746	_leave(" = %d", ret);
	747	return ret;
	748	}