[net-next-2.6.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 struct ccid_operations *ccids[] = {
	&ccid2_ops,
#ifdef CONFIG_IP_DCCP_CCID3
	&ccid3_ops,
#endif
};

static struct ccid_operations *ccid_by_number(const u8 id)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(ccids); i++)
		if (ccids[i]->ccid_id == id)
			return ccids[i];
	return NULL;
}

/* check that up to @array_len members in @ccid_array are supported */
bool ccid_support_check(u8 const *ccid_array, u8 array_len)
{
	while (array_len > 0)
		if (ccid_by_number(ccid_array[--array_len]) == NULL)
			return false;
	return true;
}

/**
 * ccid_get_builtin_ccids  -  Populate a list of built-in CCIDs
 * @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 = kmalloc(ARRAY_SIZE(ccids), gfp_any());
	if (*ccid_array == NULL)
		return -ENOBUFS;

	for (*array_len = 0; *array_len < ARRAY_SIZE(ccids); *array_len += 1)
		(*ccid_array)[*array_len] = ccids[*array_len]->ccid_id;
	return 0;
}

int ccid_getsockopt_builtin_ccids(struct sock *sk, int len,
				  char __user *optval, int __user *optlen)
{
	u8 *ccid_array, array_len;
	int err = 0;

	if (len < ARRAY_SIZE(ccids))
		return -EINVAL;

	if (ccid_get_builtin_ccids(&ccid_array, &array_len))
		return -ENOBUFS;

	if (put_user(array_len, optlen) ||
	    copy_to_user(optval, ccid_array, array_len))
		err = -EFAULT;

	kfree(ccid_array);
	return err;
}

#ifdef ___OLD_INTERFACE_TO_BE_REMOVED___
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
#endif /* ___OLD_INTERFACE_TO_BE_REMOVED___ */

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);
	}
}

#ifdef ___OLD_INTERFACE_TO_BE_REMOVED___
/* 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;
}
#endif /* ___OLD_INTERFACE_TO_BE_REMOVED___ */

static int ccid_activate(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;

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

static void ccid_deactivate(struct ccid_operations *ccid_ops)
{
	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: Deactivated CCID %d (%s)\n",
		ccid_ops->ccid_id, ccid_ops->ccid_name);
}

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

	if (ccid_ops == NULL)
		goto out;

	ccid = kmem_cache_alloc(rx ? ccid_ops->ccid_hc_rx_slab :
				     ccid_ops->ccid_hc_tx_slab, gfp);
	if (ccid == NULL)
		goto out;
	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_free_ccid:
	kmem_cache_free(rx ? ccid_ops->ccid_hc_rx_slab :
			ccid_ops->ccid_hc_tx_slab, ccid);
	ccid = NULL;
	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);
	}
}

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

int __init ccid_initialize_builtins(void)
{
	int i, err;

	for (i = 0; i < ARRAY_SIZE(ccids); i++) {
		err = ccid_activate(ccids[i]);
		if (err)
			goto unwind_registrations;
	}
	return 0;

unwind_registrations:
	while(--i >= 0)
		ccid_deactivate(ccids[i]);
	return err;
}

void ccid_cleanup_builtins(void)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(ccids); i++)
		ccid_deactivate(ccids[i]);
}
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
ddebc973 GR	16	static struct ccid_operations *ccids[] = {
	17	&ccid2_ops,
	18	#ifdef CONFIG_IP_DCCP_CCID3
	19	&ccid3_ops,
	20	#endif
	21	};
	22
	23	static struct ccid_operations *ccid_by_number(const u8 id)
	24	{
	25	int i;
	26
	27	for (i = 0; i < ARRAY_SIZE(ccids); i++)
	28	if (ccids[i]->ccid_id == id)
	29	return ccids[i];
	30	return NULL;
	31	}
	32
	33	/* check that up to @array_len members in @ccid_array are supported */
	34	bool ccid_support_check(u8 const *ccid_array, u8 array_len)
	35	{
	36	while (array_len > 0)
	37	if (ccid_by_number(ccid_array[--array_len]) == NULL)
	38	return false;
	39	return true;
	40	}
	41
	42	/**
	43	* ccid_get_builtin_ccids - Populate a list of built-in CCIDs
	44	* @ccid_array: pointer to copy into
	45	* @array_len: value to return length into
	46	* This function allocates memory - caller must see that it is freed after use.
	47	*/
	48	int ccid_get_builtin_ccids(u8 *ccid_array, u8 array_len)
	49	{
	50	*ccid_array = kmalloc(ARRAY_SIZE(ccids), gfp_any());
	51	if (*ccid_array == NULL)
	52	return -ENOBUFS;
	53
	54	for (array_len = 0; array_len < ARRAY_SIZE(ccids); *array_len += 1)
	55	(ccid_array)[array_len] = ccids[*array_len]->ccid_id;
	56	return 0;
	57	}
	58
	59	int ccid_getsockopt_builtin_ccids(struct sock *sk, int len,
	60	char __user optval, int __user optlen)
	61	{
	62	u8 *ccid_array, array_len;
	63	int err = 0;
	64
	65	if (len < ARRAY_SIZE(ccids))
	66	return -EINVAL;
	67
	68	if (ccid_get_builtin_ccids(&ccid_array, &array_len))
	69	return -ENOBUFS;
	70
	71	if (put_user(array_len, optlen) \|\|
	72	copy_to_user(optval, ccid_array, array_len))
	73	err = -EFAULT;
	74
	75	kfree(ccid_array);
	76	return err;
	77	}
	78
	79	#ifdef ___OLD_INTERFACE_TO_BE_REMOVED___
d90ebcbf GR	80	static u8 builtin_ccids[] = {
	81	DCCPC_CCID2, /* CCID2 is supported by default */
	82	#if defined(CONFIG_IP_DCCP_CCID3) \|\| defined(CONFIG_IP_DCCP_CCID3_MODULE)
	83	DCCPC_CCID3,
	84	#endif
	85	};
	86
91f0ebf7	87	static struct ccid_operations *ccids[CCID_MAX];
7c657876 ACM	88	#if defined(CONFIG_SMP) \|\| defined(CONFIG_PREEMPT)
	89	static atomic_t ccids_lockct = ATOMIC_INIT(0);
	90	static DEFINE_SPINLOCK(ccids_lock);
	91
	92	/*
	93	* The strategy is: modifications ccids vector are short, do not sleep and
	94	* veeery rare, but read access should be free of any exclusive locks.
	95	*/
	96	static void ccids_write_lock(void)
	97	{
	98	spin_lock(&ccids_lock);
	99	while (atomic_read(&ccids_lockct) != 0) {
	100	spin_unlock(&ccids_lock);
	101	yield();
	102	spin_lock(&ccids_lock);
	103	}
	104	}
	105
	106	static inline void ccids_write_unlock(void)
	107	{
	108	spin_unlock(&ccids_lock);
	109	}
	110
	111	static inline void ccids_read_lock(void)
	112	{
	113	atomic_inc(&ccids_lockct);
d725fdc8	114	smp_mb__after_atomic_inc();
7c657876 ACM	115	spin_unlock_wait(&ccids_lock);
	116	}
	117
	118	static inline void ccids_read_unlock(void)
	119	{
	120	atomic_dec(&ccids_lockct);
	121	}
	122
	123	#else
	124	#define ccids_write_lock() do { } while(0)
	125	#define ccids_write_unlock() do { } while(0)
	126	#define ccids_read_lock() do { } while(0)
	127	#define ccids_read_unlock() do { } while(0)
	128	#endif
ddebc973	129	#endif /* ___OLD_INTERFACE_TO_BE_REMOVED___ */
7c657876	130
e18b890b	131	static struct kmem_cache ccid_kmem_cache_create(int obj_size, const char fmt,...)
7c657876	132	{
e18b890b	133	struct kmem_cache *slab;
91f0ebf7 ACM	134	char slab_name_fmt[32], *slab_name;
	135	va_list args;
	136
	137	va_start(args, fmt);
	138	vsnprintf(slab_name_fmt, sizeof(slab_name_fmt), fmt, args);
	139	va_end(args);
	140
	141	slab_name = kstrdup(slab_name_fmt, GFP_KERNEL);
	142	if (slab_name == NULL)
	143	return NULL;
	144	slab = kmem_cache_create(slab_name, sizeof(struct ccid) + obj_size, 0,
20c2df83	145	SLAB_HWCACHE_ALIGN, NULL);
91f0ebf7 ACM	146	if (slab == NULL)
	147	kfree(slab_name);
	148	return slab;
	149	}
	150
e18b890b	151	static void ccid_kmem_cache_destroy(struct kmem_cache *slab)
91f0ebf7 ACM	152	{
	153	if (slab != NULL) {
	154	const char *name = kmem_cache_name(slab);
	155
	156	kmem_cache_destroy(slab);
	157	kfree(name);
	158	}
	159	}
	160
ddebc973	161	#ifdef ___OLD_INTERFACE_TO_BE_REMOVED___
d90ebcbf GR	162	/* check that up to @array_len members in @ccid_array are supported */
	163	bool ccid_support_check(u8 const *ccid_array, u8 array_len)
	164	{
	165	u8 i, j, found;
	166
	167	for (i = 0, found = 0; i < array_len; i++, found = 0) {
	168	for (j = 0; !found && j < ARRAY_SIZE(builtin_ccids); j++)
	169	found = (ccid_array[i] == builtin_ccids[j]);
	170	if (!found)
	171	return false;
	172	}
	173	return true;
	174	}
	175
	176	/**
	177	* ccid_get_builtin_ccids - Provide copy of `builtin' CCID array
	178	* @ccid_array: pointer to copy into
	179	* @array_len: value to return length into
	180	* This function allocates memory - caller must see that it is freed after use.
	181	*/
	182	int ccid_get_builtin_ccids(u8 *ccid_array, u8 array_len)
	183	{
	184	*ccid_array = kmemdup(builtin_ccids, sizeof(builtin_ccids), gfp_any());
	185	if (*ccid_array == NULL)
	186	return -ENOBUFS;
	187	*array_len = ARRAY_SIZE(builtin_ccids);
	188	return 0;
	189	}
	190
	191	int ccid_getsockopt_builtin_ccids(struct sock *sk, int len,
	192	char __user optval, int __user optlen)
	193	{
	194	if (len < sizeof(builtin_ccids))
	195	return -EINVAL;
	196
	197	if (put_user(sizeof(builtin_ccids), optlen) \|\|
	198	copy_to_user(optval, builtin_ccids, sizeof(builtin_ccids)))
	199	return -EFAULT;
	200	return 0;
	201	}
ddebc973	202	#endif /* ___OLD_INTERFACE_TO_BE_REMOVED___ */
d90ebcbf	203
ddebc973	204	static int ccid_activate(struct ccid_operations *ccid_ops)
91f0ebf7 ACM	205	{
	206	int err = -ENOBUFS;
	207
	208	ccid_ops->ccid_hc_rx_slab =
	209	ccid_kmem_cache_create(ccid_ops->ccid_hc_rx_obj_size,
84a97b0a GR	210	"ccid%u_hc_rx_sock",
84a97b0a GR	211	ccid_ops->ccid_id);
91f0ebf7 ACM	212	if (ccid_ops->ccid_hc_rx_slab == NULL)
	213	goto out;
	214
	215	ccid_ops->ccid_hc_tx_slab =
	216	ccid_kmem_cache_create(ccid_ops->ccid_hc_tx_obj_size,
84a97b0a GR	217	"ccid%u_hc_tx_sock",
84a97b0a GR	218	ccid_ops->ccid_id);
91f0ebf7 ACM	219	if (ccid_ops->ccid_hc_tx_slab == NULL)
91f0ebf7 ACM	220	goto out_free_rx_slab;
7c657876	221
ddebc973	222	pr_info("CCID: Activated CCID %d (%s)\n",
91f0ebf7	223	ccid_ops->ccid_id, ccid_ops->ccid_name);
ddebc973	224	err = 0;
91f0ebf7	225	out:
7c657876	226	return err;
91f0ebf7 ACM	227	out_free_rx_slab:
	228	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
	229	ccid_ops->ccid_hc_rx_slab = NULL;
	230	goto out;
7c657876 ACM	231	}
7c657876 ACM	232
ddebc973	233	static void ccid_deactivate(struct ccid_operations *ccid_ops)
7c657876	234	{
91f0ebf7 ACM	235	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab);
	236	ccid_ops->ccid_hc_tx_slab = NULL;
	237	ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
	238	ccid_ops->ccid_hc_rx_slab = NULL;
	239
ddebc973	240	pr_info("CCID: Deactivated CCID %d (%s)\n",
91f0ebf7	241	ccid_ops->ccid_id, ccid_ops->ccid_name);
7c657876 ACM	242	}
7c657876 ACM	243
91f0ebf7	244	struct ccid ccid_new(unsigned char id, struct sock sk, int rx, gfp_t gfp)
7c657876	245	{
ddebc973	246	struct ccid_operations *ccid_ops = ccid_by_number(id);
91f0ebf7	247	struct ccid *ccid = NULL;
7c657876	248
91f0ebf7	249	if (ccid_ops == NULL)
ddebc973	250	goto out;
7c657876	251
91f0ebf7 ACM	252	ccid = kmem_cache_alloc(rx ? ccid_ops->ccid_hc_rx_slab :
	253	ccid_ops->ccid_hc_tx_slab, gfp);
	254	if (ccid == NULL)
ddebc973	255	goto out;
91f0ebf7 ACM	256	ccid->ccid_ops = ccid_ops;
	257	if (rx) {
	258	memset(ccid + 1, 0, ccid_ops->ccid_hc_rx_obj_size);
	259	if (ccid->ccid_ops->ccid_hc_rx_init != NULL &&
	260	ccid->ccid_ops->ccid_hc_rx_init(ccid, sk) != 0)
	261	goto out_free_ccid;
	262	} else {
	263	memset(ccid + 1, 0, ccid_ops->ccid_hc_tx_obj_size);
	264	if (ccid->ccid_ops->ccid_hc_tx_init != NULL &&
	265	ccid->ccid_ops->ccid_hc_tx_init(ccid, sk) != 0)
	266	goto out_free_ccid;
	267	}
7c657876	268	out:
7c657876	269	return ccid;
91f0ebf7 ACM	270	out_free_ccid:
	271	kmem_cache_free(rx ? ccid_ops->ccid_hc_rx_slab :
	272	ccid_ops->ccid_hc_tx_slab, ccid);
7c657876 ACM	273	ccid = NULL;
	274	goto out;
	275	}
	276
91f0ebf7	277	EXPORT_SYMBOL_GPL(ccid_new);
7c657876	278
91f0ebf7 ACM	279	static void ccid_delete(struct ccid ccid, struct sock sk, int rx)
	280	{
	281	struct ccid_operations *ccid_ops;
	282
7c657876 ACM	283	if (ccid == NULL)
	284	return;
	285
91f0ebf7 ACM	286	ccid_ops = ccid->ccid_ops;
	287	if (rx) {
	288	if (ccid_ops->ccid_hc_rx_exit != NULL)
	289	ccid_ops->ccid_hc_rx_exit(sk);
	290	kmem_cache_free(ccid_ops->ccid_hc_rx_slab, ccid);
	291	} else {
	292	if (ccid_ops->ccid_hc_tx_exit != NULL)
	293	ccid_ops->ccid_hc_tx_exit(sk);
	294	kmem_cache_free(ccid_ops->ccid_hc_tx_slab, ccid);
	295	}
91f0ebf7	296	}
7c657876	297
91f0ebf7 ACM	298	void ccid_hc_rx_delete(struct ccid ccid, struct sock sk)
	299	{
	300	ccid_delete(ccid, sk, 1);
	301	}
7c657876	302
91f0ebf7 ACM	303	EXPORT_SYMBOL_GPL(ccid_hc_rx_delete);
	304
	305	void ccid_hc_tx_delete(struct ccid ccid, struct sock sk)
	306	{
	307	ccid_delete(ccid, sk, 0);
7c657876 ACM	308	}
7c657876 ACM	309
91f0ebf7	310	EXPORT_SYMBOL_GPL(ccid_hc_tx_delete);
ddebc973 GR	311
	312	int __init ccid_initialize_builtins(void)
	313	{
	314	int i, err;
	315
	316	for (i = 0; i < ARRAY_SIZE(ccids); i++) {
	317	err = ccid_activate(ccids[i]);
	318	if (err)
	319	goto unwind_registrations;
	320	}
	321	return 0;
	322
	323	unwind_registrations:
	324	while(--i >= 0)
	325	ccid_deactivate(ccids[i]);
	326	return err;
	327	}
	328
	329	void ccid_cleanup_builtins(void)
	330	{
	331	int i;
	332
	333	for (i = 0; i < ARRAY_SIZE(ccids); i++)
	334	ccid_deactivate(ccids[i]);
	335	}