[linux.git] / fs / dcookies.c

/*
 * dcookies.c
 *
 * Copyright 2002 John Levon <[email protected]>
 *
 * Persistent cookie-path mappings. These are used by
 * profilers to convert a per-task EIP value into something
 * non-transitory that can be processed at a later date.
 * This is done by locking the dentry/vfsmnt pair in the
 * kernel until released by the tasks needing the persistent
 * objects. The tag is simply an unsigned long that refers
 * to the pair and can be looked up from userspace.
 */

#include <linux/syscalls.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/list.h>
#include <linux/mount.h>
#include <linux/capability.h>
#include <linux/dcache.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/dcookies.h>
#include <linux/mutex.h>
#include <asm/uaccess.h>

/* The dcookies are allocated from a kmem_cache and
 * hashed onto a small number of lists. None of the
 * code here is particularly performance critical
 */
struct dcookie_struct {
	struct dentry * dentry;
	struct vfsmount * vfsmnt;
	struct list_head hash_list;
};

static LIST_HEAD(dcookie_users);
static DEFINE_MUTEX(dcookie_mutex);
static kmem_cache_t *dcookie_cache __read_mostly;
static struct list_head *dcookie_hashtable __read_mostly;
static size_t hash_size __read_mostly;

static inline int is_live(void)
{
	return !(list_empty(&dcookie_users));
}


/* The dentry is locked, its address will do for the cookie */
static inline unsigned long dcookie_value(struct dcookie_struct * dcs)
{
	return (unsigned long)dcs->dentry;
}


static size_t dcookie_hash(unsigned long dcookie)
{
	return (dcookie >> L1_CACHE_SHIFT) & (hash_size - 1);
}


static struct dcookie_struct * find_dcookie(unsigned long dcookie)
{
	struct dcookie_struct *found = NULL;
	struct dcookie_struct * dcs;
	struct list_head * pos;
	struct list_head * list;

	list = dcookie_hashtable + dcookie_hash(dcookie);

	list_for_each(pos, list) {
		dcs = list_entry(pos, struct dcookie_struct, hash_list);
		if (dcookie_value(dcs) == dcookie) {
			found = dcs;
			break;
		}
	}

	return found;
}


static void hash_dcookie(struct dcookie_struct * dcs)
{
	struct list_head * list = dcookie_hashtable + dcookie_hash(dcookie_value(dcs));
	list_add(&dcs->hash_list, list);
}


static struct dcookie_struct * alloc_dcookie(struct dentry * dentry,
	struct vfsmount * vfsmnt)
{
	struct dcookie_struct * dcs = kmem_cache_alloc(dcookie_cache, GFP_KERNEL);
	if (!dcs)
		return NULL;

	dentry->d_cookie = dcs;

	dcs->dentry = dget(dentry);
	dcs->vfsmnt = mntget(vfsmnt);
	hash_dcookie(dcs);

	return dcs;
}


/* This is the main kernel-side routine that retrieves the cookie
 * value for a dentry/vfsmnt pair.
 */
int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
	unsigned long * cookie)
{
	int err = 0;
	struct dcookie_struct * dcs;

	mutex_lock(&dcookie_mutex);

	if (!is_live()) {
		err = -EINVAL;
		goto out;
	}

	dcs = dentry->d_cookie;

	if (!dcs)
		dcs = alloc_dcookie(dentry, vfsmnt);

	if (!dcs) {
		err = -ENOMEM;
		goto out;
	}

	*cookie = dcookie_value(dcs);

out:
	mutex_unlock(&dcookie_mutex);
	return err;
}


/* And here is where the userspace process can look up the cookie value
 * to retrieve the path.
 */
asmlinkage long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len)
{
	unsigned long cookie = (unsigned long)cookie64;
	int err = -EINVAL;
	char * kbuf;
	char * path;
	size_t pathlen;
	struct dcookie_struct * dcs;

	/* we could leak path information to users
	 * without dir read permission without this
	 */
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	mutex_lock(&dcookie_mutex);

	if (!is_live()) {
		err = -EINVAL;
		goto out;
	}

	if (!(dcs = find_dcookie(cookie)))
		goto out;

	err = -ENOMEM;
	kbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
	if (!kbuf)
		goto out;

	/* FIXME: (deleted) ? */
	path = d_path(dcs->dentry, dcs->vfsmnt, kbuf, PAGE_SIZE);

	if (IS_ERR(path)) {
		err = PTR_ERR(path);
		goto out_free;
	}

	err = -ERANGE;
 
	pathlen = kbuf + PAGE_SIZE - path;
	if (pathlen <= len) {
		err = pathlen;
		if (copy_to_user(buf, path, pathlen))
			err = -EFAULT;
	}

out_free:
	kfree(kbuf);
out:
	mutex_unlock(&dcookie_mutex);
	return err;
}


static int dcookie_init(void)
{
	struct list_head * d;
	unsigned int i, hash_bits;
	int err = -ENOMEM;

	dcookie_cache = kmem_cache_create("dcookie_cache",
		sizeof(struct dcookie_struct),
		0, 0, NULL, NULL);

	if (!dcookie_cache)
		goto out;

	dcookie_hashtable = kmalloc(PAGE_SIZE, GFP_KERNEL);
	if (!dcookie_hashtable)
		goto out_kmem;

	err = 0;

	/*
	 * Find the power-of-two list-heads that can fit into the allocation..
	 * We don't guarantee that "sizeof(struct list_head)" is necessarily
	 * a power-of-two.
	 */
	hash_size = PAGE_SIZE / sizeof(struct list_head);
	hash_bits = 0;
	do {
		hash_bits++;
	} while ((hash_size >> hash_bits) != 0);
	hash_bits--;

	/*
	 * Re-calculate the actual number of entries and the mask
	 * from the number of bits we can fit.
	 */
	hash_size = 1UL << hash_bits;

	/* And initialize the newly allocated array */
	d = dcookie_hashtable;
	i = hash_size;
	do {
		INIT_LIST_HEAD(d);
		d++;
		i--;
	} while (i);

out:
	return err;
out_kmem:
	kmem_cache_destroy(dcookie_cache);
	goto out;
}


static void free_dcookie(struct dcookie_struct * dcs)
{
	dcs->dentry->d_cookie = NULL;
	dput(dcs->dentry);
	mntput(dcs->vfsmnt);
	kmem_cache_free(dcookie_cache, dcs);
}


static void dcookie_exit(void)
{
	struct list_head * list;
	struct list_head * pos;
	struct list_head * pos2;
	struct dcookie_struct * dcs;
	size_t i;

	for (i = 0; i < hash_size; ++i) {
		list = dcookie_hashtable + i;
		list_for_each_safe(pos, pos2, list) {
			dcs = list_entry(pos, struct dcookie_struct, hash_list);
			list_del(&dcs->hash_list);
			free_dcookie(dcs);
		}
	}

	kfree(dcookie_hashtable);
	kmem_cache_destroy(dcookie_cache);
}


struct dcookie_user {
	struct list_head next;
};
 
struct dcookie_user * dcookie_register(void)
{
	struct dcookie_user * user;

	mutex_lock(&dcookie_mutex);

	user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL);
	if (!user)
		goto out;

	if (!is_live() && dcookie_init())
		goto out_free;

	list_add(&user->next, &dcookie_users);

out:
	mutex_unlock(&dcookie_mutex);
	return user;
out_free:
	kfree(user);
	user = NULL;
	goto out;
}


void dcookie_unregister(struct dcookie_user * user)
{
	mutex_lock(&dcookie_mutex);

	list_del(&user->next);
	kfree(user);

	if (!is_live())
		dcookie_exit();

	mutex_unlock(&dcookie_mutex);
}

EXPORT_SYMBOL_GPL(dcookie_register);
EXPORT_SYMBOL_GPL(dcookie_unregister);
EXPORT_SYMBOL_GPL(get_dcookie);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* dcookies.c
	3	*
	4	* Copyright 2002 John Levon <[email protected]>
	5	*
	6	* Persistent cookie-path mappings. These are used by
	7	* profilers to convert a per-task EIP value into something
	8	* non-transitory that can be processed at a later date.
	9	* This is done by locking the dentry/vfsmnt pair in the
	10	* kernel until released by the tasks needing the persistent
	11	* objects. The tag is simply an unsigned long that refers
	12	* to the pair and can be looked up from userspace.
	13	*/
	14
1da177e4 LT	15	#include <linux/syscalls.h>
	16	#include <linux/module.h>
	17	#include <linux/slab.h>
	18	#include <linux/list.h>
	19	#include <linux/mount.h>
16f7e0fe	20	#include <linux/capability.h>
1da177e4 LT	21	#include <linux/dcache.h>
	22	#include <linux/mm.h>
	23	#include <linux/errno.h>
	24	#include <linux/dcookies.h>
353ab6e9	25	#include <linux/mutex.h>
1da177e4 LT	26	#include <asm/uaccess.h>
	27
	28	/* The dcookies are allocated from a kmem_cache and
	29	* hashed onto a small number of lists. None of the
	30	* code here is particularly performance critical
	31	*/
	32	struct dcookie_struct {
	33	struct dentry * dentry;
	34	struct vfsmount * vfsmnt;
	35	struct list_head hash_list;
	36	};
	37
	38	static LIST_HEAD(dcookie_users);
353ab6e9	39	static DEFINE_MUTEX(dcookie_mutex);
fa3536cc ED	40	static kmem_cache_t *dcookie_cache __read_mostly;
	41	static struct list_head *dcookie_hashtable __read_mostly;
	42	static size_t hash_size __read_mostly;
1da177e4 LT	43
	44	static inline int is_live(void)
	45	{
	46	return !(list_empty(&dcookie_users));
	47	}
	48
	49
	50	/* The dentry is locked, its address will do for the cookie */
	51	static inline unsigned long dcookie_value(struct dcookie_struct * dcs)
	52	{
	53	return (unsigned long)dcs->dentry;
	54	}
	55
	56
	57	static size_t dcookie_hash(unsigned long dcookie)
	58	{
	59	return (dcookie >> L1_CACHE_SHIFT) & (hash_size - 1);
	60	}
	61
	62
	63	static struct dcookie_struct * find_dcookie(unsigned long dcookie)
	64	{
	65	struct dcookie_struct *found = NULL;
	66	struct dcookie_struct * dcs;
	67	struct list_head * pos;
	68	struct list_head * list;
	69
	70	list = dcookie_hashtable + dcookie_hash(dcookie);
	71
	72	list_for_each(pos, list) {
	73	dcs = list_entry(pos, struct dcookie_struct, hash_list);
	74	if (dcookie_value(dcs) == dcookie) {
	75	found = dcs;
	76	break;
	77	}
	78	}
	79
	80	return found;
	81	}
	82
	83
	84	static void hash_dcookie(struct dcookie_struct * dcs)
	85	{
	86	struct list_head * list = dcookie_hashtable + dcookie_hash(dcookie_value(dcs));
	87	list_add(&dcs->hash_list, list);
	88	}
	89
	90
	91	static struct dcookie_struct * alloc_dcookie(struct dentry * dentry,
	92	struct vfsmount * vfsmnt)
	93	{
	94	struct dcookie_struct * dcs = kmem_cache_alloc(dcookie_cache, GFP_KERNEL);
	95	if (!dcs)
	96	return NULL;
	97
1da177e4 LT	98	dentry->d_cookie = dcs;
1da177e4 LT	99
732dbef6 MS	100	dcs->dentry = dget(dentry);
732dbef6 MS	101	dcs->vfsmnt = mntget(vfsmnt);
1da177e4 LT	102	hash_dcookie(dcs);
	103
	104	return dcs;
	105	}
	106
	107
	108	/* This is the main kernel-side routine that retrieves the cookie
	109	* value for a dentry/vfsmnt pair.
	110	*/
	111	int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
	112	unsigned long * cookie)
	113	{
	114	int err = 0;
	115	struct dcookie_struct * dcs;
	116
353ab6e9	117	mutex_lock(&dcookie_mutex);
1da177e4 LT	118
	119	if (!is_live()) {
	120	err = -EINVAL;
	121	goto out;
	122	}
	123
	124	dcs = dentry->d_cookie;
	125
	126	if (!dcs)
	127	dcs = alloc_dcookie(dentry, vfsmnt);
	128
	129	if (!dcs) {
	130	err = -ENOMEM;
	131	goto out;
	132	}
	133
	134	*cookie = dcookie_value(dcs);
	135
	136	out:
353ab6e9	137	mutex_unlock(&dcookie_mutex);
1da177e4 LT	138	return err;
	139	}
	140
	141
	142	/* And here is where the userspace process can look up the cookie value
	143	* to retrieve the path.
	144	*/
	145	asmlinkage long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len)
	146	{
	147	unsigned long cookie = (unsigned long)cookie64;
	148	int err = -EINVAL;
	149	char * kbuf;
	150	char * path;
	151	size_t pathlen;
	152	struct dcookie_struct * dcs;
	153
	154	/* we could leak path information to users
	155	* without dir read permission without this
	156	*/
	157	if (!capable(CAP_SYS_ADMIN))
	158	return -EPERM;
	159
353ab6e9	160	mutex_lock(&dcookie_mutex);
1da177e4 LT	161
	162	if (!is_live()) {
	163	err = -EINVAL;
	164	goto out;
	165	}
	166
	167	if (!(dcs = find_dcookie(cookie)))
	168	goto out;
	169
	170	err = -ENOMEM;
	171	kbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
	172	if (!kbuf)
	173	goto out;
	174
	175	/* FIXME: (deleted) ? */
	176	path = d_path(dcs->dentry, dcs->vfsmnt, kbuf, PAGE_SIZE);
	177
	178	if (IS_ERR(path)) {
	179	err = PTR_ERR(path);
	180	goto out_free;
	181	}
	182
	183	err = -ERANGE;
	184
	185	pathlen = kbuf + PAGE_SIZE - path;
	186	if (pathlen <= len) {
	187	err = pathlen;
	188	if (copy_to_user(buf, path, pathlen))
	189	err = -EFAULT;
	190	}
	191
	192	out_free:
	193	kfree(kbuf);
	194	out:
353ab6e9	195	mutex_unlock(&dcookie_mutex);
1da177e4 LT	196	return err;
	197	}
	198
	199
	200	static int dcookie_init(void)
	201	{
	202	struct list_head * d;
	203	unsigned int i, hash_bits;
	204	int err = -ENOMEM;
	205
	206	dcookie_cache = kmem_cache_create("dcookie_cache",
	207	sizeof(struct dcookie_struct),
	208	0, 0, NULL, NULL);
	209
	210	if (!dcookie_cache)
	211	goto out;
	212
	213	dcookie_hashtable = kmalloc(PAGE_SIZE, GFP_KERNEL);
	214	if (!dcookie_hashtable)
	215	goto out_kmem;
	216
	217	err = 0;
	218
	219	/*
	220	* Find the power-of-two list-heads that can fit into the allocation..
	221	* We don't guarantee that "sizeof(struct list_head)" is necessarily
	222	* a power-of-two.
	223	*/
	224	hash_size = PAGE_SIZE / sizeof(struct list_head);
	225	hash_bits = 0;
	226	do {
	227	hash_bits++;
	228	} while ((hash_size >> hash_bits) != 0);
	229	hash_bits--;
	230
	231	/*
	232	* Re-calculate the actual number of entries and the mask
	233	* from the number of bits we can fit.
	234	*/
	235	hash_size = 1UL << hash_bits;
	236
	237	/* And initialize the newly allocated array */
	238	d = dcookie_hashtable;
	239	i = hash_size;
	240	do {
	241	INIT_LIST_HEAD(d);
	242	d++;
	243	i--;
	244	} while (i);
	245
	246	out:
	247	return err;
	248	out_kmem:
	249	kmem_cache_destroy(dcookie_cache);
	250	goto out;
	251	}
	252
	253
	254	static void free_dcookie(struct dcookie_struct * dcs)
	255	{
	256	dcs->dentry->d_cookie = NULL;
	257	dput(dcs->dentry);
	258	mntput(dcs->vfsmnt);
	259	kmem_cache_free(dcookie_cache, dcs);
260	}
261
262
263	static void dcookie_exit(void)
264	{
265	struct list_head * list;
266	struct list_head * pos;
267	struct list_head * pos2;
268	struct dcookie_struct * dcs;
269	size_t i;
270
271	for (i = 0; i < hash_size; ++i) {
272	list = dcookie_hashtable + i;
273	list_for_each_safe(pos, pos2, list) {
274	dcs = list_entry(pos, struct dcookie_struct, hash_list);
275	list_del(&dcs->hash_list);
276	free_dcookie(dcs);
277	}
278	}
279
280	kfree(dcookie_hashtable);
281	kmem_cache_destroy(dcookie_cache);
282	}
283
284
285	struct dcookie_user {
286	struct list_head next;
287	};
288
289	struct dcookie_user * dcookie_register(void)
290	{
291	struct dcookie_user * user;
292
353ab6e9	293	mutex_lock(&dcookie_mutex);
1da177e4 LT	294
	295	user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL);
	296	if (!user)
	297	goto out;
	298
	299	if (!is_live() && dcookie_init())
	300	goto out_free;
	301
	302	list_add(&user->next, &dcookie_users);
	303
	304	out:
353ab6e9	305	mutex_unlock(&dcookie_mutex);
1da177e4 LT	306	return user;
	307	out_free:
	308	kfree(user);
	309	user = NULL;
	310	goto out;
	311	}
	312
	313
	314	void dcookie_unregister(struct dcookie_user * user)
	315	{
353ab6e9	316	mutex_lock(&dcookie_mutex);
1da177e4 LT	317
	318	list_del(&user->next);
	319	kfree(user);
	320
	321	if (!is_live())
	322	dcookie_exit();
	323
353ab6e9	324	mutex_unlock(&dcookie_mutex);
1da177e4 LT	325	}
	326
	327	EXPORT_SYMBOL_GPL(dcookie_register);
	328	EXPORT_SYMBOL_GPL(dcookie_unregister);
	329	EXPORT_SYMBOL_GPL(get_dcookie);