[linux-2.6-block.git] / net / dccp / ccid.c

/*
 *  net/dccp/ccid.c
 *
 *  An implementation of the DCCP protocol
 *  Arnaldo Carvalho de Melo <acme@conectiva.com.br>
 *
 *  CCID infrastructure
 *
 *	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.
 */

#include "ccid.h"

static u8 builtin_ccids[] = {
	DCCPC_CCID2,		/* CCID2 is supported by default */
#if defined(CONFIG_IP_DCCP_CCID3) || defined(CONFIG_IP_DCCP_CCID3_MODULE)
	DCCPC_CCID3,
#endif
};

static struct ccid_operations *ccids[CCID_MAX];
#if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
static atomic_t ccids_lockct = ATOMIC_INIT(0);
static DEFINE_SPINLOCK(ccids_lock);

/*
 * The strategy is: modifications ccids vector are short, do not sleep and
 * veeery rare, but read access should be free of any exclusive locks.
 */
static void ccids_write_lock(void)
{
	spin_lock(&ccids_lock);
	while (atomic_read(&ccids_lockct) != 0) {
		spin_unlock(&ccids_lock);
		yield();
		spin_lock(&ccids_lock);
	}
}

static inline void ccids_write_unlock(void)
{
	spin_unlock(&ccids_lock);
}

static inline void ccids_read_lock(void)
{
	atomic_inc(&ccids_lockct);
	smp_mb__after_atomic_inc();
	spin_unlock_wait(&ccids_lock);
}

static inline void ccids_read_unlock(void)
{
	atomic_dec(&ccids_lockct);
}

#else
#define ccids_write_lock() do { } while(0)
#define ccids_write_unlock() do { } while(0)
#define ccids_read_lock() do { } while(0)
#define ccids_read_unlock() do { } while(0)
#endif

static struct kmem_cache *ccid_kmem_cache_create(int obj_size, const char *fmt,...)
{
	struct kmem_cache *slab;
	char slab_name_fmt[32], *slab_name;
	va_list args;

	va_start(args, fmt);
	vsnprintf(slab_name_fmt, sizeof(slab_name_fmt), fmt, args);
	va_end(args);

	slab_name = kstrdup(slab_name_fmt, GFP_KERNEL);
	if (slab_name == NULL)
		return NULL;
	slab = kmem_cache_create(slab_name, sizeof(struct ccid) + obj_size, 0,
				 SLAB_HWCACHE_ALIGN, NULL);
	if (slab == NULL)
		kfree(slab_name);
	return slab;
}

static void ccid_kmem_cache_destroy(struct kmem_cache *slab)
{
	if (slab != NULL) {
		const char *name = kmem_cache_name(slab);

		kmem_cache_destroy(slab);
		kfree(name);
	}
}

/* check that up to @array_len members in @ccid_array are supported */
bool ccid_support_check(u8 const *ccid_array, u8 array_len)
{
	u8 i, j, found;

	for (i = 0, found = 0; i < array_len; i++, found = 0) {
		for (j = 0; !found && j < ARRAY_SIZE(builtin_ccids); j++)
			found = (ccid_array[i] == builtin_ccids[j]);
		if (!found)
			return false;
	}
	return true;
}

/**
 * ccid_get_builtin_ccids  -  Provide copy of `builtin' CCID array
 * @ccid_array: pointer to copy into
 * @array_len: value to return length into
 * This function allocates memory - caller must see that it is freed after use.
 */
int ccid_get_builtin_ccids(u8 **ccid_array, u8 *array_len)
{
	*ccid_array = kmemdup(builtin_ccids, sizeof(builtin_ccids), gfp_any());
	if (*ccid_array == NULL)
		return -ENOBUFS;
	*array_len = ARRAY_SIZE(builtin_ccids);
	return 0;
}

int ccid_getsockopt_builtin_ccids(struct sock *sk, int len,
				    char __user *optval, int __user *optlen)
{
	if (len < sizeof(builtin_ccids))
		return -EINVAL;

	if (put_user(sizeof(builtin_ccids), optlen) ||
	    copy_to_user(optval, builtin_ccids, sizeof(builtin_ccids)))
		return -EFAULT;
	return 0;
}

int ccid_register(struct ccid_operations *ccid_ops)
{
	int err = -ENOBUFS;

	ccid_ops->ccid_hc_rx_slab =
			ccid_kmem_cache_create(ccid_ops->ccid_hc_rx_obj_size,
					       "ccid%u_hc_rx_sock",
					       ccid_ops->ccid_id);
	if (ccid_ops->ccid_hc_rx_slab == NULL)
		goto out;

	ccid_ops->ccid_hc_tx_slab =
			ccid_kmem_cache_create(ccid_ops->ccid_hc_tx_obj_size,
					       "ccid%u_hc_tx_sock",
					       ccid_ops->ccid_id);
	if (ccid_ops->ccid_hc_tx_slab == NULL)
		goto out_free_rx_slab;

	ccids_write_lock();
	err = -EEXIST;
	if (ccids[ccid_ops->ccid_id] == NULL) {
		ccids[ccid_ops->ccid_id] = ccid_ops;
		err = 0;
	}
	ccids_write_unlock();
	if (err != 0)
		goto out_free_tx_slab;

	pr_info("CCID: Registered CCID %d (%s)\n",
		ccid_ops->ccid_id, ccid_ops->ccid_name);
out:
	return err;
out_free_tx_slab:
	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab);
	ccid_ops->ccid_hc_tx_slab = NULL;
	goto out;
out_free_rx_slab:
	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
	ccid_ops->ccid_hc_rx_slab = NULL;
	goto out;
}

EXPORT_SYMBOL_GPL(ccid_register);

int ccid_unregister(struct ccid_operations *ccid_ops)
{
	ccids_write_lock();
	ccids[ccid_ops->ccid_id] = NULL;
	ccids_write_unlock();

	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab);
	ccid_ops->ccid_hc_tx_slab = NULL;
	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
	ccid_ops->ccid_hc_rx_slab = NULL;

	pr_info("CCID: Unregistered CCID %d (%s)\n",
		ccid_ops->ccid_id, ccid_ops->ccid_name);
	return 0;
}

EXPORT_SYMBOL_GPL(ccid_unregister);

struct ccid *ccid_new(unsigned char id, struct sock *sk, int rx, gfp_t gfp)
{
	struct ccid_operations *ccid_ops;
	struct ccid *ccid = NULL;

	ccids_read_lock();
#ifdef CONFIG_MODULES
	if (ccids[id] == NULL) {
		/* We only try to load if in process context */
		ccids_read_unlock();
		if (gfp & GFP_ATOMIC)
			goto out;
		request_module("net-dccp-ccid-%d", id);
		ccids_read_lock();
	}
#endif
	ccid_ops = ccids[id];
	if (ccid_ops == NULL)
		goto out_unlock;

	if (!try_module_get(ccid_ops->ccid_owner))
		goto out_unlock;

	ccids_read_unlock();

	ccid = kmem_cache_alloc(rx ? ccid_ops->ccid_hc_rx_slab :
				     ccid_ops->ccid_hc_tx_slab, gfp);
	if (ccid == NULL)
		goto out_module_put;
	ccid->ccid_ops = ccid_ops;
	if (rx) {
		memset(ccid + 1, 0, ccid_ops->ccid_hc_rx_obj_size);
		if (ccid->ccid_ops->ccid_hc_rx_init != NULL &&
		    ccid->ccid_ops->ccid_hc_rx_init(ccid, sk) != 0)
			goto out_free_ccid;
	} else {
		memset(ccid + 1, 0, ccid_ops->ccid_hc_tx_obj_size);
		if (ccid->ccid_ops->ccid_hc_tx_init != NULL &&
		    ccid->ccid_ops->ccid_hc_tx_init(ccid, sk) != 0)
			goto out_free_ccid;
	}
out:
	return ccid;
out_unlock:
	ccids_read_unlock();
	goto out;
out_free_ccid:
	kmem_cache_free(rx ? ccid_ops->ccid_hc_rx_slab :
			ccid_ops->ccid_hc_tx_slab, ccid);
	ccid = NULL;
out_module_put:
	module_put(ccid_ops->ccid_owner);
	goto out;
}

EXPORT_SYMBOL_GPL(ccid_new);

static void ccid_delete(struct ccid *ccid, struct sock *sk, int rx)
{
	struct ccid_operations *ccid_ops;

	if (ccid == NULL)
		return;

	ccid_ops = ccid->ccid_ops;
	if (rx) {
		if (ccid_ops->ccid_hc_rx_exit != NULL)
			ccid_ops->ccid_hc_rx_exit(sk);
		kmem_cache_free(ccid_ops->ccid_hc_rx_slab,  ccid);
	} else {
		if (ccid_ops->ccid_hc_tx_exit != NULL)
			ccid_ops->ccid_hc_tx_exit(sk);
		kmem_cache_free(ccid_ops->ccid_hc_tx_slab,  ccid);
	}
	ccids_read_lock();
	if (ccids[ccid_ops->ccid_id] != NULL)
		module_put(ccid_ops->ccid_owner);
	ccids_read_unlock();
}

void ccid_hc_rx_delete(struct ccid *ccid, struct sock *sk)
{
	ccid_delete(ccid, sk, 1);
}

EXPORT_SYMBOL_GPL(ccid_hc_rx_delete);

void ccid_hc_tx_delete(struct ccid *ccid, struct sock *sk)
{
	ccid_delete(ccid, sk, 0);
}

EXPORT_SYMBOL_GPL(ccid_hc_tx_delete);
Commit	Line	Data
7c657876 ACM	1	/*
	2	* net/dccp/ccid.c
	3	*
	4	* An implementation of the DCCP protocol
	5	* Arnaldo Carvalho de Melo <acme@conectiva.com.br>
	6	*
	7	* CCID infrastructure
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*/
	13
	14	#include "ccid.h"
	15
d90ebcbf GR	16	static u8 builtin_ccids[] = {
	17	DCCPC_CCID2, /* CCID2 is supported by default */
	18	#if defined(CONFIG_IP_DCCP_CCID3) \|\| defined(CONFIG_IP_DCCP_CCID3_MODULE)
	19	DCCPC_CCID3,
	20	#endif
	21	};
	22
91f0ebf7	23	static struct ccid_operations *ccids[CCID_MAX];
7c657876 ACM	24	#if defined(CONFIG_SMP) \|\| defined(CONFIG_PREEMPT)
	25	static atomic_t ccids_lockct = ATOMIC_INIT(0);
	26	static DEFINE_SPINLOCK(ccids_lock);
	27
	28	/*
	29	* The strategy is: modifications ccids vector are short, do not sleep and
	30	* veeery rare, but read access should be free of any exclusive locks.
	31	*/
	32	static void ccids_write_lock(void)
	33	{
	34	spin_lock(&ccids_lock);
	35	while (atomic_read(&ccids_lockct) != 0) {
	36	spin_unlock(&ccids_lock);
	37	yield();
	38	spin_lock(&ccids_lock);
	39	}
	40	}
	41
	42	static inline void ccids_write_unlock(void)
	43	{
	44	spin_unlock(&ccids_lock);
	45	}
	46
	47	static inline void ccids_read_lock(void)
	48	{
	49	atomic_inc(&ccids_lockct);
d725fdc8	50	smp_mb__after_atomic_inc();
7c657876 ACM	51	spin_unlock_wait(&ccids_lock);
	52	}
	53
	54	static inline void ccids_read_unlock(void)
	55	{
	56	atomic_dec(&ccids_lockct);
	57	}
	58
	59	#else
	60	#define ccids_write_lock() do { } while(0)
	61	#define ccids_write_unlock() do { } while(0)
	62	#define ccids_read_lock() do { } while(0)
	63	#define ccids_read_unlock() do { } while(0)
	64	#endif
	65
e18b890b	66	static struct kmem_cache ccid_kmem_cache_create(int obj_size, const char fmt,...)
7c657876	67	{
e18b890b	68	struct kmem_cache *slab;
91f0ebf7 ACM	69	char slab_name_fmt[32], *slab_name;
	70	va_list args;
	71
	72	va_start(args, fmt);
	73	vsnprintf(slab_name_fmt, sizeof(slab_name_fmt), fmt, args);
	74	va_end(args);
	75
	76	slab_name = kstrdup(slab_name_fmt, GFP_KERNEL);
	77	if (slab_name == NULL)
	78	return NULL;
	79	slab = kmem_cache_create(slab_name, sizeof(struct ccid) + obj_size, 0,
20c2df83	80	SLAB_HWCACHE_ALIGN, NULL);
91f0ebf7 ACM	81	if (slab == NULL)
	82	kfree(slab_name);
	83	return slab;
	84	}
	85
e18b890b	86	static void ccid_kmem_cache_destroy(struct kmem_cache *slab)
91f0ebf7 ACM	87	{
	88	if (slab != NULL) {
	89	const char *name = kmem_cache_name(slab);
	90
	91	kmem_cache_destroy(slab);
	92	kfree(name);
	93	}
	94	}
	95
d90ebcbf GR	96	/* check that up to @array_len members in @ccid_array are supported */
	97	bool ccid_support_check(u8 const *ccid_array, u8 array_len)
	98	{
	99	u8 i, j, found;
	100
	101	for (i = 0, found = 0; i < array_len; i++, found = 0) {
	102	for (j = 0; !found && j < ARRAY_SIZE(builtin_ccids); j++)
	103	found = (ccid_array[i] == builtin_ccids[j]);
	104	if (!found)
	105	return false;
	106	}
	107	return true;
	108	}
	109
	110	/**
	111	* ccid_get_builtin_ccids - Provide copy of `builtin' CCID array
	112	* @ccid_array: pointer to copy into
	113	* @array_len: value to return length into
	114	* This function allocates memory - caller must see that it is freed after use.
	115	*/
	116	int ccid_get_builtin_ccids(u8 *ccid_array, u8 array_len)
	117	{
	118	*ccid_array = kmemdup(builtin_ccids, sizeof(builtin_ccids), gfp_any());
	119	if (*ccid_array == NULL)
	120	return -ENOBUFS;
	121	*array_len = ARRAY_SIZE(builtin_ccids);
	122	return 0;
	123	}
	124
	125	int ccid_getsockopt_builtin_ccids(struct sock *sk, int len,
	126	char __user optval, int __user optlen)
	127	{
	128	if (len < sizeof(builtin_ccids))
	129	return -EINVAL;
	130
	131	if (put_user(sizeof(builtin_ccids), optlen) \|\|
	132	copy_to_user(optval, builtin_ccids, sizeof(builtin_ccids)))
	133	return -EFAULT;
	134	return 0;
	135	}
	136
91f0ebf7 ACM	137	int ccid_register(struct ccid_operations *ccid_ops)
	138	{
	139	int err = -ENOBUFS;
	140
	141	ccid_ops->ccid_hc_rx_slab =
	142	ccid_kmem_cache_create(ccid_ops->ccid_hc_rx_obj_size,
84a97b0a GR	143	"ccid%u_hc_rx_sock",
84a97b0a GR	144	ccid_ops->ccid_id);
91f0ebf7 ACM	145	if (ccid_ops->ccid_hc_rx_slab == NULL)
	146	goto out;
	147
	148	ccid_ops->ccid_hc_tx_slab =
	149	ccid_kmem_cache_create(ccid_ops->ccid_hc_tx_obj_size,
84a97b0a GR	150	"ccid%u_hc_tx_sock",
84a97b0a GR	151	ccid_ops->ccid_id);
91f0ebf7 ACM	152	if (ccid_ops->ccid_hc_tx_slab == NULL)
91f0ebf7 ACM	153	goto out_free_rx_slab;
7c657876	154
7c657876 ACM	155	ccids_write_lock();
7c657876 ACM	156	err = -EEXIST;
91f0ebf7 ACM	157	if (ccids[ccid_ops->ccid_id] == NULL) {
91f0ebf7 ACM	158	ccids[ccid_ops->ccid_id] = ccid_ops;
7c657876 ACM	159	err = 0;
	160	}
	161	ccids_write_unlock();
91f0ebf7 ACM	162	if (err != 0)
	163	goto out_free_tx_slab;
	164
	165	pr_info("CCID: Registered CCID %d (%s)\n",
	166	ccid_ops->ccid_id, ccid_ops->ccid_name);
	167	out:
7c657876	168	return err;
91f0ebf7 ACM	169	out_free_tx_slab:
	170	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab);
	171	ccid_ops->ccid_hc_tx_slab = NULL;
	172	goto out;
	173	out_free_rx_slab:
	174	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
	175	ccid_ops->ccid_hc_rx_slab = NULL;
	176	goto out;
7c657876 ACM	177	}
	178
	179	EXPORT_SYMBOL_GPL(ccid_register);
	180
91f0ebf7	181	int ccid_unregister(struct ccid_operations *ccid_ops)
7c657876 ACM	182	{
7c657876 ACM	183	ccids_write_lock();
91f0ebf7	184	ccids[ccid_ops->ccid_id] = NULL;
7c657876	185	ccids_write_unlock();
91f0ebf7 ACM	186
	187	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab);
	188	ccid_ops->ccid_hc_tx_slab = NULL;
	189	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
	190	ccid_ops->ccid_hc_rx_slab = NULL;
	191
7c657876	192	pr_info("CCID: Unregistered CCID %d (%s)\n",
91f0ebf7	193	ccid_ops->ccid_id, ccid_ops->ccid_name);
7c657876 ACM	194	return 0;
	195	}
	196
	197	EXPORT_SYMBOL_GPL(ccid_unregister);
	198
91f0ebf7	199	struct ccid ccid_new(unsigned char id, struct sock sk, int rx, gfp_t gfp)
7c657876	200	{
91f0ebf7 ACM	201	struct ccid_operations *ccid_ops;
91f0ebf7 ACM	202	struct ccid *ccid = NULL;
7c657876	203
91f0ebf7	204	ccids_read_lock();
95a5afca	205	#ifdef CONFIG_MODULES
91f0ebf7 ACM	206	if (ccids[id] == NULL) {
	207	/* We only try to load if in process context */
	208	ccids_read_unlock();
	209	if (gfp & GFP_ATOMIC)
	210	goto out;
7c657876	211	request_module("net-dccp-ccid-%d", id);
91f0ebf7 ACM	212	ccids_read_lock();
91f0ebf7 ACM	213	}
7c657876	214	#endif
91f0ebf7 ACM	215	ccid_ops = ccids[id];
	216	if (ccid_ops == NULL)
	217	goto out_unlock;
7c657876	218
91f0ebf7 ACM	219	if (!try_module_get(ccid_ops->ccid_owner))
91f0ebf7 ACM	220	goto out_unlock;
7c657876	221
91f0ebf7	222	ccids_read_unlock();
7c657876	223
91f0ebf7 ACM	224	ccid = kmem_cache_alloc(rx ? ccid_ops->ccid_hc_rx_slab :
	225	ccid_ops->ccid_hc_tx_slab, gfp);
	226	if (ccid == NULL)
7c657876	227	goto out_module_put;
91f0ebf7 ACM	228	ccid->ccid_ops = ccid_ops;
	229	if (rx) {
	230	memset(ccid + 1, 0, ccid_ops->ccid_hc_rx_obj_size);
	231	if (ccid->ccid_ops->ccid_hc_rx_init != NULL &&
	232	ccid->ccid_ops->ccid_hc_rx_init(ccid, sk) != 0)
	233	goto out_free_ccid;
	234	} else {
	235	memset(ccid + 1, 0, ccid_ops->ccid_hc_tx_obj_size);
	236	if (ccid->ccid_ops->ccid_hc_tx_init != NULL &&
	237	ccid->ccid_ops->ccid_hc_tx_init(ccid, sk) != 0)
	238	goto out_free_ccid;
	239	}
7c657876	240	out:
7c657876	241	return ccid;
91f0ebf7 ACM	242	out_unlock:
	243	ccids_read_unlock();
	244	goto out;
	245	out_free_ccid:
	246	kmem_cache_free(rx ? ccid_ops->ccid_hc_rx_slab :
	247	ccid_ops->ccid_hc_tx_slab, ccid);
7c657876	248	ccid = NULL;
91f0ebf7 ACM	249	out_module_put:
91f0ebf7 ACM	250	module_put(ccid_ops->ccid_owner);
7c657876 ACM	251	goto out;
	252	}
	253
91f0ebf7	254	EXPORT_SYMBOL_GPL(ccid_new);
7c657876	255
91f0ebf7 ACM	256	static void ccid_delete(struct ccid ccid, struct sock sk, int rx)
	257	{
	258	struct ccid_operations *ccid_ops;
	259
7c657876 ACM	260	if (ccid == NULL)
	261	return;
	262
91f0ebf7 ACM	263	ccid_ops = ccid->ccid_ops;
	264	if (rx) {
	265	if (ccid_ops->ccid_hc_rx_exit != NULL)
	266	ccid_ops->ccid_hc_rx_exit(sk);
	267	kmem_cache_free(ccid_ops->ccid_hc_rx_slab, ccid);
	268	} else {
	269	if (ccid_ops->ccid_hc_tx_exit != NULL)
	270	ccid_ops->ccid_hc_tx_exit(sk);
	271	kmem_cache_free(ccid_ops->ccid_hc_tx_slab, ccid);
	272	}
7c657876	273	ccids_read_lock();
91f0ebf7 ACM	274	if (ccids[ccid_ops->ccid_id] != NULL)
	275	module_put(ccid_ops->ccid_owner);
	276	ccids_read_unlock();
	277	}
7c657876	278
91f0ebf7 ACM	279	void ccid_hc_rx_delete(struct ccid ccid, struct sock sk)
	280	{
	281	ccid_delete(ccid, sk, 1);
	282	}
7c657876	283
91f0ebf7 ACM	284	EXPORT_SYMBOL_GPL(ccid_hc_rx_delete);
	285
	286	void ccid_hc_tx_delete(struct ccid ccid, struct sock sk)
	287	{
	288	ccid_delete(ccid, sk, 0);
7c657876 ACM	289	}
7c657876 ACM	290
91f0ebf7	291	EXPORT_SYMBOL_GPL(ccid_hc_tx_delete);