[linux.git] / net / tipc / user_reg.c

/*
 * net/tipc/user_reg.c: TIPC user registry code
 *
 * Copyright (c) 2000-2006, Ericsson AB
 * Copyright (c) 2004-2005, Wind River Systems
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "core.h"
#include "user_reg.h"

/*
 * TIPC user registry keeps track of users of the tipc_port interface.
 *
 * The registry utilizes an array of "TIPC user" entries;
 * a user's ID is the index of their associated array entry.
 * Array entry 0 is not used, so userid 0 is not valid;
 * TIPC sometimes uses this value to denote an anonymous user.
 * The list of free entries is initially chained from last entry to entry 1.
 */

/**
 * struct tipc_user - registered TIPC user info
 * @next: index of next free registry entry (or -1 for an allocated entry)
 * @callback: ptr to routine to call when TIPC mode changes (NULL if none)
 * @usr_handle: user-defined value passed to callback routine
 * @ports: list of user ports owned by the user
 */

struct tipc_user {
	int next;
	tipc_mode_event callback;
	void *usr_handle;
	struct list_head ports;
};

#define MAX_USERID 64
#define USER_LIST_SIZE ((MAX_USERID + 1) * sizeof(struct tipc_user))

static struct tipc_user *users = NULL;
static u32 next_free_user = MAX_USERID + 1;
static DEFINE_SPINLOCK(reg_lock);

/**
 * reg_init - create TIPC user registry (but don't activate it)
 *
 * If registry has been pre-initialized it is left "as is".
 * NOTE: This routine may be called when TIPC is inactive.
 */

static int reg_init(void)
{
	u32 i;

	spin_lock_bh(&reg_lock);
	if (!users) {
		users = kzalloc(USER_LIST_SIZE, GFP_ATOMIC);
		if (users) {
			for (i = 1; i <= MAX_USERID; i++) {
				users[i].next = i - 1;
			}
			next_free_user = MAX_USERID;
		}
	}
	spin_unlock_bh(&reg_lock);
	return users ? 0 : -ENOMEM;
}

/**
 * reg_callback - inform TIPC user about current operating mode
 */

static void reg_callback(struct tipc_user *user_ptr)
{
	tipc_mode_event cb;
	void *arg;

	spin_lock_bh(&reg_lock);
	cb = user_ptr->callback;
	arg = user_ptr->usr_handle;
	spin_unlock_bh(&reg_lock);

	if (cb)
		cb(arg, tipc_mode, tipc_own_addr);
}

/**
 * tipc_reg_start - activate TIPC user registry
 */

int tipc_reg_start(void)
{
	u32 u;
	int res;

	if ((res = reg_init()))
		return res;

	for (u = 1; u <= MAX_USERID; u++) {
		if (users[u].callback)
			tipc_k_signal((Handler)reg_callback,
				      (unsigned long)&users[u]);
	}
	return 0;
}

/**
 * tipc_reg_stop - shut down & delete TIPC user registry
 */

void tipc_reg_stop(void)
{
	int id;

	if (!users)
		return;

	for (id = 1; id <= MAX_USERID; id++) {
		if (users[id].callback)
			reg_callback(&users[id]);
	}
	kfree(users);
	users = NULL;
}

/**
 * tipc_attach - register a TIPC user
 *
 * NOTE: This routine may be called when TIPC is inactive.
 */

int tipc_attach(u32 *userid, tipc_mode_event cb, void *usr_handle)
{
	struct tipc_user *user_ptr;

	if ((tipc_mode == TIPC_NOT_RUNNING) && !cb)
		return -ENOPROTOOPT;
	if (!users)
		reg_init();

	spin_lock_bh(&reg_lock);
	if (!next_free_user) {
		spin_unlock_bh(&reg_lock);
		return -EBUSY;
	}
	user_ptr = &users[next_free_user];
	*userid = next_free_user;
	next_free_user = user_ptr->next;
	user_ptr->next = -1;
	spin_unlock_bh(&reg_lock);

	user_ptr->callback = cb;
	user_ptr->usr_handle = usr_handle;
	INIT_LIST_HEAD(&user_ptr->ports);
	atomic_inc(&tipc_user_count);

	if (cb && (tipc_mode != TIPC_NOT_RUNNING))
		tipc_k_signal((Handler)reg_callback, (unsigned long)user_ptr);
	return 0;
}

/**
 * tipc_detach - deregister a TIPC user
 */

void tipc_detach(u32 userid)
{
	struct tipc_user *user_ptr;
	struct list_head ports_temp;
	struct user_port *up_ptr, *temp_up_ptr;

	if ((userid == 0) || (userid > MAX_USERID))
		return;

	spin_lock_bh(&reg_lock);
	if ((!users) || (users[userid].next >= 0)) {
		spin_unlock_bh(&reg_lock);
		return;
	}

	user_ptr = &users[userid];
	user_ptr->callback = NULL;
	INIT_LIST_HEAD(&ports_temp);
	list_splice(&user_ptr->ports, &ports_temp);
	user_ptr->next = next_free_user;
	next_free_user = userid;
	spin_unlock_bh(&reg_lock);

	atomic_dec(&tipc_user_count);

	list_for_each_entry_safe(up_ptr, temp_up_ptr, &ports_temp, uport_list) {
		tipc_deleteport(up_ptr->ref);
	}
}

/**
 * tipc_reg_add_port - register a user's driver port
 */

int tipc_reg_add_port(struct user_port *up_ptr)
{
	struct tipc_user *user_ptr;

	if (up_ptr->user_ref == 0)
		return 0;
	if (up_ptr->user_ref > MAX_USERID)
		return -EINVAL;
	if ((tipc_mode == TIPC_NOT_RUNNING) || !users )
		return -ENOPROTOOPT;

	spin_lock_bh(&reg_lock);
	user_ptr = &users[up_ptr->user_ref];
	list_add(&up_ptr->uport_list, &user_ptr->ports);
	spin_unlock_bh(&reg_lock);
	return 0;
}

/**
 * tipc_reg_remove_port - deregister a user's driver port
 */

int tipc_reg_remove_port(struct user_port *up_ptr)
{
	if (up_ptr->user_ref == 0)
		return 0;
	if (up_ptr->user_ref > MAX_USERID)
		return -EINVAL;
	if (!users )
		return -ENOPROTOOPT;

	spin_lock_bh(&reg_lock);
	list_del_init(&up_ptr->uport_list);
	spin_unlock_bh(&reg_lock);
	return 0;
}
Commit	Line	Data
b97bf3fd PL	1	/*
b97bf3fd PL	2	* net/tipc/user_reg.c: TIPC user registry code
c4307285	3	*
593a5f22	4	* Copyright (c) 2000-2006, Ericsson AB
b97bf3fd	5	* Copyright (c) 2004-2005, Wind River Systems
b97bf3fd PL	6	* All rights reserved.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted provided that the following conditions are met:
9ea1fd3c PL	10	*
	11	* 1. Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* 2. Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in the
	15	* documentation and/or other materials provided with the distribution.
	16	* 3. Neither the names of the copyright holders nor the names of its
	17	* contributors may be used to endorse or promote products derived from
	18	* this software without specific prior written permission.
	19	*
	20	* Alternatively, this software may be distributed under the terms of the
	21	* GNU General Public License ("GPL") version 2 as published by the Free
	22	* Software Foundation.
b97bf3fd PL	23	*
	24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	28	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	30	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	31	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	32	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	33	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	34	* POSSIBILITY OF SUCH DAMAGE.
	35	*/
	36
	37	#include "core.h"
	38	#include "user_reg.h"
	39
	40	/*
	41	* TIPC user registry keeps track of users of the tipc_port interface.
	42	*
c4307285	43	* The registry utilizes an array of "TIPC user" entries;
b97bf3fd PL	44	* a user's ID is the index of their associated array entry.
	45	* Array entry 0 is not used, so userid 0 is not valid;
	46	* TIPC sometimes uses this value to denote an anonymous user.
	47	* The list of free entries is initially chained from last entry to entry 1.
	48	*/
	49
	50	/**
	51	* struct tipc_user - registered TIPC user info
	52	* @next: index of next free registry entry (or -1 for an allocated entry)
	53	* @callback: ptr to routine to call when TIPC mode changes (NULL if none)
c4307285	54	* @usr_handle: user-defined value passed to callback routine
b97bf3fd PL	55	* @ports: list of user ports owned by the user
	56	*/
	57
	58	struct tipc_user {
	59	int next;
	60	tipc_mode_event callback;
	61	void *usr_handle;
	62	struct list_head ports;
	63	};
	64
	65	#define MAX_USERID 64
	66	#define USER_LIST_SIZE ((MAX_USERID + 1) * sizeof(struct tipc_user))
	67
1fc54d8f	68	static struct tipc_user *users = NULL;
b97bf3fd	69	static u32 next_free_user = MAX_USERID + 1;
34af946a	70	static DEFINE_SPINLOCK(reg_lock);
b97bf3fd PL	71
	72	/**
	73	* reg_init - create TIPC user registry (but don't activate it)
c4307285	74	*
b97bf3fd PL	75	* If registry has been pre-initialized it is left "as is".
	76	* NOTE: This routine may be called when TIPC is inactive.
	77	*/
	78
	79	static int reg_init(void)
	80	{
	81	u32 i;
c4307285	82
b97bf3fd PL	83	spin_lock_bh(&reg_lock);
b97bf3fd PL	84	if (!users) {
0da974f4	85	users = kzalloc(USER_LIST_SIZE, GFP_ATOMIC);
b97bf3fd	86	if (users) {
b97bf3fd PL	87	for (i = 1; i <= MAX_USERID; i++) {
	88	users[i].next = i - 1;
	89	}
	90	next_free_user = MAX_USERID;
	91	}
	92	}
	93	spin_unlock_bh(&reg_lock);
0e35fd5e	94	return users ? 0 : -ENOMEM;
b97bf3fd PL	95	}
	96
	97	/**
	98	* reg_callback - inform TIPC user about current operating mode
	99	*/
	100
	101	static void reg_callback(struct tipc_user *user_ptr)
	102	{
	103	tipc_mode_event cb;
	104	void *arg;
	105
	106	spin_lock_bh(&reg_lock);
	107	cb = user_ptr->callback;
	108	arg = user_ptr->usr_handle;
	109	spin_unlock_bh(&reg_lock);
	110
	111	if (cb)
	112	cb(arg, tipc_mode, tipc_own_addr);
	113	}
	114
	115	/**
4323add6	116	* tipc_reg_start - activate TIPC user registry
b97bf3fd PL	117	*/
b97bf3fd PL	118
4323add6	119	int tipc_reg_start(void)
b97bf3fd PL	120	{
	121	u32 u;
	122	int res;
	123
	124	if ((res = reg_init()))
	125	return res;
	126
	127	for (u = 1; u <= MAX_USERID; u++) {
	128	if (users[u].callback)
4323add6 PL	129	tipc_k_signal((Handler)reg_callback,
4323add6 PL	130	(unsigned long)&users[u]);
b97bf3fd	131	}
0e35fd5e	132	return 0;
b97bf3fd PL	133	}
	134
	135	/**
4323add6	136	* tipc_reg_stop - shut down & delete TIPC user registry
b97bf3fd PL	137	*/
b97bf3fd PL	138
4323add6	139	void tipc_reg_stop(void)
c4307285	140	{
b97bf3fd PL	141	int id;
	142
	143	if (!users)
	144	return;
	145
	146	for (id = 1; id <= MAX_USERID; id++) {
	147	if (users[id].callback)
	148	reg_callback(&users[id]);
	149	}
	150	kfree(users);
1fc54d8f	151	users = NULL;
b97bf3fd PL	152	}
	153
	154	/**
	155	* tipc_attach - register a TIPC user
	156	*
	157	* NOTE: This routine may be called when TIPC is inactive.
	158	*/
	159
	160	int tipc_attach(u32 userid, tipc_mode_event cb, void usr_handle)
	161	{
	162	struct tipc_user *user_ptr;
	163
	164	if ((tipc_mode == TIPC_NOT_RUNNING) && !cb)
	165	return -ENOPROTOOPT;
	166	if (!users)
	167	reg_init();
	168
	169	spin_lock_bh(&reg_lock);
	170	if (!next_free_user) {
	171	spin_unlock_bh(&reg_lock);
	172	return -EBUSY;
	173	}
	174	user_ptr = &users[next_free_user];
	175	*userid = next_free_user;
	176	next_free_user = user_ptr->next;
c4307285	177	user_ptr->next = -1;
b97bf3fd PL	178	spin_unlock_bh(&reg_lock);
	179
	180	user_ptr->callback = cb;
	181	user_ptr->usr_handle = usr_handle;
	182	INIT_LIST_HEAD(&user_ptr->ports);
	183	atomic_inc(&tipc_user_count);
c4307285	184
b97bf3fd	185	if (cb && (tipc_mode != TIPC_NOT_RUNNING))
4323add6	186	tipc_k_signal((Handler)reg_callback, (unsigned long)user_ptr);
0e35fd5e	187	return 0;
b97bf3fd PL	188	}
	189
	190	/**
	191	* tipc_detach - deregister a TIPC user
	192	*/
	193
	194	void tipc_detach(u32 userid)
	195	{
	196	struct tipc_user *user_ptr;
	197	struct list_head ports_temp;
	198	struct user_port up_ptr, temp_up_ptr;
	199
	200	if ((userid == 0) \|\| (userid > MAX_USERID))
	201	return;
	202
	203	spin_lock_bh(&reg_lock);
	204	if ((!users) \|\| (users[userid].next >= 0)) {
	205	spin_unlock_bh(&reg_lock);
	206	return;
	207	}
	208
	209	user_ptr = &users[userid];
c4307285	210	user_ptr->callback = NULL;
b97bf3fd	211	INIT_LIST_HEAD(&ports_temp);
c4307285	212	list_splice(&user_ptr->ports, &ports_temp);
b97bf3fd PL	213	user_ptr->next = next_free_user;
	214	next_free_user = userid;
	215	spin_unlock_bh(&reg_lock);
	216
	217	atomic_dec(&tipc_user_count);
	218
c4307285	219	list_for_each_entry_safe(up_ptr, temp_up_ptr, &ports_temp, uport_list) {
b97bf3fd PL	220	tipc_deleteport(up_ptr->ref);
	221	}
	222	}
	223
	224	/**
4323add6	225	* tipc_reg_add_port - register a user's driver port
b97bf3fd PL	226	*/
b97bf3fd PL	227
4323add6	228	int tipc_reg_add_port(struct user_port *up_ptr)
b97bf3fd PL	229	{
	230	struct tipc_user *user_ptr;
	231
	232	if (up_ptr->user_ref == 0)
0e35fd5e	233	return 0;
b97bf3fd PL	234	if (up_ptr->user_ref > MAX_USERID)
	235	return -EINVAL;
	236	if ((tipc_mode == TIPC_NOT_RUNNING) \|\| !users )
	237	return -ENOPROTOOPT;
	238
	239	spin_lock_bh(&reg_lock);
	240	user_ptr = &users[up_ptr->user_ref];
	241	list_add(&up_ptr->uport_list, &user_ptr->ports);
	242	spin_unlock_bh(&reg_lock);
0e35fd5e	243	return 0;
b97bf3fd PL	244	}
	245
	246	/**
4323add6	247	* tipc_reg_remove_port - deregister a user's driver port
b97bf3fd PL	248	*/
b97bf3fd PL	249
4323add6	250	int tipc_reg_remove_port(struct user_port *up_ptr)
b97bf3fd PL	251	{
b97bf3fd PL	252	if (up_ptr->user_ref == 0)
0e35fd5e	253	return 0;
b97bf3fd PL	254	if (up_ptr->user_ref > MAX_USERID)
	255	return -EINVAL;
	256	if (!users )
	257	return -ENOPROTOOPT;
	258
	259	spin_lock_bh(&reg_lock);
	260	list_del_init(&up_ptr->uport_list);
	261	spin_unlock_bh(&reg_lock);
0e35fd5e	262	return 0;
b97bf3fd PL	263	}
b97bf3fd PL	264