[linux-block.git] / net / 9p / util.c

/*
 *  net/9p/util.c
 *
 *  This file contains some helper functions
 *
 *  Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
 *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
 *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2
 *  as published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to:
 *  Free Software Foundation
 *  51 Franklin Street, Fifth Floor
 *  Boston, MA  02111-1301  USA
 *
 */

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/parser.h>
#include <linux/idr.h>
#include <net/9p/9p.h>

struct p9_idpool {
	spinlock_t lock;
	struct idr pool;
};

struct p9_idpool *p9_idpool_create(void)
{
	struct p9_idpool *p;

	p = kmalloc(sizeof(struct p9_idpool), GFP_KERNEL);
	if (!p)
		return ERR_PTR(-ENOMEM);

	spin_lock_init(&p->lock);
	idr_init(&p->pool);

	return p;
}
EXPORT_SYMBOL(p9_idpool_create);

void p9_idpool_destroy(struct p9_idpool *p)
{
	idr_destroy(&p->pool);
	kfree(p);
}
EXPORT_SYMBOL(p9_idpool_destroy);

/**
 * p9_idpool_get - allocate numeric id from pool
 * @p - pool to allocate from
 *
 * XXX - This seems to be an awful generic function, should it be in idr.c with
 *            the lock included in struct idr?
 */

int p9_idpool_get(struct p9_idpool *p)
{
	int i = 0;
	int error;
	unsigned int flags;

retry:
	if (idr_pre_get(&p->pool, GFP_KERNEL) == 0)
		return 0;

	spin_lock_irqsave(&p->lock, flags);

	/* no need to store exactly p, we just need something non-null */
	error = idr_get_new(&p->pool, p, &i);
	spin_unlock_irqrestore(&p->lock, flags);

	if (error == -EAGAIN)
		goto retry;
	else if (error)
		return -1;

	return i;
}
EXPORT_SYMBOL(p9_idpool_get);

/**
 * p9_idpool_put - release numeric id from pool
 * @p - pool to allocate from
 *
 * XXX - This seems to be an awful generic function, should it be in idr.c with
 *            the lock included in struct idr?
 */

void p9_idpool_put(int id, struct p9_idpool *p)
{
	unsigned int flags;
	spin_lock_irqsave(&p->lock, flags);
	idr_remove(&p->pool, id);
	spin_unlock_irqrestore(&p->lock, flags);
}
EXPORT_SYMBOL(p9_idpool_put);

/**
 * p9_idpool_check - check if the specified id is available
 * @id - id to check
 * @p - pool
 */
int p9_idpool_check(int id, struct p9_idpool *p)
{
	return idr_find(&p->pool, id) != NULL;
}
EXPORT_SYMBOL(p9_idpool_check);
Commit	Line	Data
bd238fb4 LI	1	/*
	2	* net/9p/util.c
	3	*
	4	* This file contains some helper functions
	5	*
	6	* Copyright (C) 2007 by Latchesar Ionkov <lucho@ionkov.net>
	7	* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
	8	* Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2
	12	* as published by the Free Software Foundation.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to:
	21	* Free Software Foundation
	22	* 51 Franklin Street, Fifth Floor
	23	* Boston, MA 02111-1301 USA
	24	*
	25	*/
	26
	27	#include <linux/module.h>
	28	#include <linux/errno.h>
	29	#include <linux/fs.h>
	30	#include <linux/sched.h>
	31	#include <linux/parser.h>
	32	#include <linux/idr.h>
	33	#include <net/9p/9p.h>
	34
	35	struct p9_idpool {
dea7bbb6	36	spinlock_t lock;
bd238fb4 LI	37	struct idr pool;
	38	};
	39
	40	struct p9_idpool *p9_idpool_create(void)
	41	{
	42	struct p9_idpool *p;
	43
	44	p = kmalloc(sizeof(struct p9_idpool), GFP_KERNEL);
	45	if (!p)
	46	return ERR_PTR(-ENOMEM);
	47
dea7bbb6	48	spin_lock_init(&p->lock);
bd238fb4 LI	49	idr_init(&p->pool);
	50
	51	return p;
	52	}
	53	EXPORT_SYMBOL(p9_idpool_create);
	54
	55	void p9_idpool_destroy(struct p9_idpool *p)
	56	{
	57	idr_destroy(&p->pool);
	58	kfree(p);
	59	}
	60	EXPORT_SYMBOL(p9_idpool_destroy);
	61
	62	/**
	63	* p9_idpool_get - allocate numeric id from pool
	64	* @p - pool to allocate from
	65	*
	66	* XXX - This seems to be an awful generic function, should it be in idr.c with
	67	* the lock included in struct idr?
	68	*/
	69
	70	int p9_idpool_get(struct p9_idpool *p)
	71	{
	72	int i = 0;
	73	int error;
dea7bbb6	74	unsigned int flags;
bd238fb4 LI	75
	76	retry:
	77	if (idr_pre_get(&p->pool, GFP_KERNEL) == 0)
	78	return 0;
	79
dea7bbb6	80	spin_lock_irqsave(&p->lock, flags);
bd238fb4 LI	81
	82	/* no need to store exactly p, we just need something non-null */
	83	error = idr_get_new(&p->pool, p, &i);
dea7bbb6	84	spin_unlock_irqrestore(&p->lock, flags);
bd238fb4 LI	85
	86	if (error == -EAGAIN)
	87	goto retry;
	88	else if (error)
	89	return -1;
	90
	91	return i;
	92	}
	93	EXPORT_SYMBOL(p9_idpool_get);
	94
	95	/**
	96	* p9_idpool_put - release numeric id from pool
	97	* @p - pool to allocate from
	98	*
	99	* XXX - This seems to be an awful generic function, should it be in idr.c with
	100	* the lock included in struct idr?
	101	*/
	102
	103	void p9_idpool_put(int id, struct p9_idpool *p)
	104	{
dea7bbb6 AL	105	unsigned int flags;
dea7bbb6 AL	106	spin_lock_irqsave(&p->lock, flags);
bd238fb4	107	idr_remove(&p->pool, id);
dea7bbb6	108	spin_unlock_irqrestore(&p->lock, flags);
bd238fb4 LI	109	}
	110	EXPORT_SYMBOL(p9_idpool_put);
	111
	112	/**
	113	* p9_idpool_check - check if the specified id is available
	114	* @id - id to check
	115	* @p - pool
	116	*/
	117	int p9_idpool_check(int id, struct p9_idpool *p)
	118	{
	119	return idr_find(&p->pool, id) != NULL;
	120	}
	121	EXPORT_SYMBOL(p9_idpool_check);