Eric Lee / smarc-fsl-linux-kernel

Commit b0c1e928c85023c73780b5d9873406ccf1cd8019

Authored by Allan Stephens 14 years ago

Committed by David S. Miller 14 years ago

Exists in master and in 39 other branches

tipc: Remove user registry subsystem

Eliminates routines, data structures, and files that make up TIPC's
user registry. The user registry is no longer needed since the native
API routines that utilized it no longer exist and there are no longer
any internal TIPC services that use it.

Signed-off-by: Allan Stephens <Allan.Stephens@windriver.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 8 changed files with 7 additions and 292 deletions Inline Diff

net/tipc/Makefile
net/tipc/config.c
net/tipc/core.c
net/tipc/port.c
net/tipc/port.h
net/tipc/subscr.c
net/tipc/user_reg.c
net/tipc/user_reg.h

net/tipc/Makefile

Diff comments View file @ b0c1e92

1	#	1	#
2	# Makefile for the Linux TIPC layer	2	# Makefile for the Linux TIPC layer
3	#	3	#
4		4
5	obj-$(CONFIG_TIPC) := tipc.o	5	obj-$(CONFIG_TIPC) := tipc.o
6		6
7	tipc-y += addr.o bcast.o bearer.o config.o \	7	tipc-y += addr.o bcast.o bearer.o config.o \
8	core.o handler.o link.o discover.o msg.o \	8	core.o handler.o link.o discover.o msg.o \
9	name_distr.o subscr.o name_table.o net.o \	9	name_distr.o subscr.o name_table.o net.o \
10	netlink.o node.o node_subscr.o port.o ref.o \	10	netlink.o node.o node_subscr.o port.o ref.o \
11	socket.o user_reg.o dbg.o eth_media.o	11	socket.o dbg.o eth_media.o
12		12
13	# End of file	13	# End of file
14		14

net/tipc/config.c

Diff comments View file @ b0c1e92

1	/*	1	/*
2	* net/tipc/config.c: TIPC configuration management code	2	* net/tipc/config.c: TIPC configuration management code
3	*	3	*
4	* Copyright (c) 2002-2006, Ericsson AB	4	* Copyright (c) 2002-2006, Ericsson AB
5	* Copyright (c) 2004-2007, Wind River Systems	5	* Copyright (c) 2004-2007, Wind River Systems
6	* All rights reserved.	6	* All rights reserved.
7	*	7	*
8	* Redistribution and use in source and binary forms, with or without	8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions are met:	9	* modification, are permitted provided that the following conditions are met:
10	*	10	*
11	* 1. Redistributions of source code must retain the above copyright	11	* 1. Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.	12	* notice, this list of conditions and the following disclaimer.
13	* 2. Redistributions in binary form must reproduce the above copyright	13	* 2. Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in the	14	* notice, this list of conditions and the following disclaimer in the
15	* documentation and/or other materials provided with the distribution.	15	* documentation and/or other materials provided with the distribution.
16	* 3. Neither the names of the copyright holders nor the names of its	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	17	* contributors may be used to endorse or promote products derived from
18	* this software without specific prior written permission.	18	* this software without specific prior written permission.
19	*	19	*
20	* Alternatively, this software may be distributed under the terms of the	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	21	* GNU General Public License ("GPL") version 2 as published by the Free
22	* Software Foundation.	22	* Software Foundation.
23	*	23	*
24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"	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	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE	27	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR	28	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF	29	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	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	31	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	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	33	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34	* POSSIBILITY OF SUCH DAMAGE.	34	* POSSIBILITY OF SUCH DAMAGE.
35	*/	35	*/
36		36
37	#include "core.h"	37	#include "core.h"
38	#include "port.h"	38	#include "port.h"
39	#include "link.h"	39	#include "link.h"
40	#include "name_table.h"	40	#include "name_table.h"
41	#include "config.h"	41	#include "config.h"
42		42
43	static u32 config_port_ref;	43	static u32 config_port_ref;
44		44
45	static DEFINE_SPINLOCK(config_lock);	45	static DEFINE_SPINLOCK(config_lock);
46		46
47	static const void req_tlv_area; / request message TLV area */	47	static const void req_tlv_area; / request message TLV area */
48	static int req_tlv_space; /* request message TLV area size */	48	static int req_tlv_space; /* request message TLV area size */
49	static int rep_headroom; /* reply message headroom to use */	49	static int rep_headroom; /* reply message headroom to use */
50		50
51		51
52	struct sk_buff *tipc_cfg_reply_alloc(int payload_size)	52	struct sk_buff *tipc_cfg_reply_alloc(int payload_size)
53	{	53	{
54	struct sk_buff *buf;	54	struct sk_buff *buf;
55		55
56	buf = alloc_skb(rep_headroom + payload_size, GFP_ATOMIC);	56	buf = alloc_skb(rep_headroom + payload_size, GFP_ATOMIC);
57	if (buf)	57	if (buf)
58	skb_reserve(buf, rep_headroom);	58	skb_reserve(buf, rep_headroom);
59	return buf;	59	return buf;
60	}	60	}
61		61
62	int tipc_cfg_append_tlv(struct sk_buff *buf, int tlv_type,	62	int tipc_cfg_append_tlv(struct sk_buff *buf, int tlv_type,
63	void *tlv_data, int tlv_data_size)	63	void *tlv_data, int tlv_data_size)
64	{	64	{
65	struct tlv_desc tlv = (struct tlv_desc )skb_tail_pointer(buf);	65	struct tlv_desc tlv = (struct tlv_desc )skb_tail_pointer(buf);
66	int new_tlv_space = TLV_SPACE(tlv_data_size);	66	int new_tlv_space = TLV_SPACE(tlv_data_size);
67		67
68	if (skb_tailroom(buf) < new_tlv_space) {	68	if (skb_tailroom(buf) < new_tlv_space) {
69	dbg("tipc_cfg_append_tlv unable to append TLV\n");	69	dbg("tipc_cfg_append_tlv unable to append TLV\n");
70	return 0;	70	return 0;
71	}	71	}
72	skb_put(buf, new_tlv_space);	72	skb_put(buf, new_tlv_space);
73	tlv->tlv_type = htons(tlv_type);	73	tlv->tlv_type = htons(tlv_type);
74	tlv->tlv_len = htons(TLV_LENGTH(tlv_data_size));	74	tlv->tlv_len = htons(TLV_LENGTH(tlv_data_size));
75	if (tlv_data_size && tlv_data)	75	if (tlv_data_size && tlv_data)
76	memcpy(TLV_DATA(tlv), tlv_data, tlv_data_size);	76	memcpy(TLV_DATA(tlv), tlv_data, tlv_data_size);
77	return 1;	77	return 1;
78	}	78	}
79		79
80	static struct sk_buff *tipc_cfg_reply_unsigned_type(u16 tlv_type, u32 value)	80	static struct sk_buff *tipc_cfg_reply_unsigned_type(u16 tlv_type, u32 value)
81	{	81	{
82	struct sk_buff *buf;	82	struct sk_buff *buf;
83	__be32 value_net;	83	__be32 value_net;
84		84
85	buf = tipc_cfg_reply_alloc(TLV_SPACE(sizeof(value)));	85	buf = tipc_cfg_reply_alloc(TLV_SPACE(sizeof(value)));
86	if (buf) {	86	if (buf) {
87	value_net = htonl(value);	87	value_net = htonl(value);
88	tipc_cfg_append_tlv(buf, tlv_type, &value_net,	88	tipc_cfg_append_tlv(buf, tlv_type, &value_net,
89	sizeof(value_net));	89	sizeof(value_net));
90	}	90	}
91	return buf;	91	return buf;
92	}	92	}
93		93
94	static struct sk_buff *tipc_cfg_reply_unsigned(u32 value)	94	static struct sk_buff *tipc_cfg_reply_unsigned(u32 value)
95	{	95	{
96	return tipc_cfg_reply_unsigned_type(TIPC_TLV_UNSIGNED, value);	96	return tipc_cfg_reply_unsigned_type(TIPC_TLV_UNSIGNED, value);
97	}	97	}
98		98
99	struct sk_buff tipc_cfg_reply_string_type(u16 tlv_type, char string)	99	struct sk_buff tipc_cfg_reply_string_type(u16 tlv_type, char string)
100	{	100	{
101	struct sk_buff *buf;	101	struct sk_buff *buf;
102	int string_len = strlen(string) + 1;	102	int string_len = strlen(string) + 1;
103		103
104	buf = tipc_cfg_reply_alloc(TLV_SPACE(string_len));	104	buf = tipc_cfg_reply_alloc(TLV_SPACE(string_len));
105	if (buf)	105	if (buf)
106	tipc_cfg_append_tlv(buf, tlv_type, string, string_len);	106	tipc_cfg_append_tlv(buf, tlv_type, string, string_len);
107	return buf;	107	return buf;
108	}	108	}
109		109
110	#define MAX_STATS_INFO 2000	110	#define MAX_STATS_INFO 2000
111		111
112	static struct sk_buff *tipc_show_stats(void)	112	static struct sk_buff *tipc_show_stats(void)
113	{	113	{
114	struct sk_buff *buf;	114	struct sk_buff *buf;
115	struct tlv_desc *rep_tlv;	115	struct tlv_desc *rep_tlv;
116	struct print_buf pb;	116	struct print_buf pb;
117	int str_len;	117	int str_len;
118	u32 value;	118	u32 value;
119		119
120	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))	120	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
121	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	121	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
122		122
123	value = ntohl((u32 )TLV_DATA(req_tlv_area));	123	value = ntohl((u32 )TLV_DATA(req_tlv_area));
124	if (value != 0)	124	if (value != 0)
125	return tipc_cfg_reply_error_string("unsupported argument");	125	return tipc_cfg_reply_error_string("unsupported argument");
126		126
127	buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_STATS_INFO));	127	buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_STATS_INFO));
128	if (buf == NULL)	128	if (buf == NULL)
129	return NULL;	129	return NULL;
130		130
131	rep_tlv = (struct tlv_desc *)buf->data;	131	rep_tlv = (struct tlv_desc *)buf->data;
132	tipc_printbuf_init(&pb, (char *)TLV_DATA(rep_tlv), MAX_STATS_INFO);	132	tipc_printbuf_init(&pb, (char *)TLV_DATA(rep_tlv), MAX_STATS_INFO);
133		133
134	tipc_printf(&pb, "TIPC version " TIPC_MOD_VER "\n");	134	tipc_printf(&pb, "TIPC version " TIPC_MOD_VER "\n");
135		135
136	/* Use additional tipc_printf()'s to return more info ... */	136	/* Use additional tipc_printf()'s to return more info ... */
137		137
138	str_len = tipc_printbuf_validate(&pb);	138	str_len = tipc_printbuf_validate(&pb);
139	skb_put(buf, TLV_SPACE(str_len));	139	skb_put(buf, TLV_SPACE(str_len));
140	TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);	140	TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
141		141
142	return buf;	142	return buf;
143	}	143	}
144		144
145	static struct sk_buff *cfg_enable_bearer(void)	145	static struct sk_buff *cfg_enable_bearer(void)
146	{	146	{
147	struct tipc_bearer_config *args;	147	struct tipc_bearer_config *args;
148		148
149	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_CONFIG))	149	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_CONFIG))
150	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	150	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
151		151
152	args = (struct tipc_bearer_config *)TLV_DATA(req_tlv_area);	152	args = (struct tipc_bearer_config *)TLV_DATA(req_tlv_area);
153	if (tipc_enable_bearer(args->name,	153	if (tipc_enable_bearer(args->name,
154	ntohl(args->detect_scope),	154	ntohl(args->detect_scope),
155	ntohl(args->priority)))	155	ntohl(args->priority)))
156	return tipc_cfg_reply_error_string("unable to enable bearer");	156	return tipc_cfg_reply_error_string("unable to enable bearer");
157		157
158	return tipc_cfg_reply_none();	158	return tipc_cfg_reply_none();
159	}	159	}
160		160
161	static struct sk_buff *cfg_disable_bearer(void)	161	static struct sk_buff *cfg_disable_bearer(void)
162	{	162	{
163	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_NAME))	163	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_BEARER_NAME))
164	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	164	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
165		165
166	if (tipc_disable_bearer((char *)TLV_DATA(req_tlv_area)))	166	if (tipc_disable_bearer((char *)TLV_DATA(req_tlv_area)))
167	return tipc_cfg_reply_error_string("unable to disable bearer");	167	return tipc_cfg_reply_error_string("unable to disable bearer");
168		168
169	return tipc_cfg_reply_none();	169	return tipc_cfg_reply_none();
170	}	170	}
171		171
172	static struct sk_buff *cfg_set_own_addr(void)	172	static struct sk_buff *cfg_set_own_addr(void)
173	{	173	{
174	u32 addr;	174	u32 addr;
175		175
176	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))	176	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_NET_ADDR))
177	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	177	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
178		178
179	addr = ntohl((__be32 )TLV_DATA(req_tlv_area));	179	addr = ntohl((__be32 )TLV_DATA(req_tlv_area));
180	if (addr == tipc_own_addr)	180	if (addr == tipc_own_addr)
181	return tipc_cfg_reply_none();	181	return tipc_cfg_reply_none();
182	if (!tipc_addr_node_valid(addr))	182	if (!tipc_addr_node_valid(addr))
183	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE	183	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
184	" (node address)");	184	" (node address)");
185	if (tipc_mode == TIPC_NET_MODE)	185	if (tipc_mode == TIPC_NET_MODE)
186	return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED	186	return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
187	" (cannot change node address once assigned)");	187	" (cannot change node address once assigned)");
188		188
189	/*	189	/*
190	* Must release all spinlocks before calling start_net() because	190	* Must release all spinlocks before calling start_net() because
191	* Linux version of TIPC calls eth_media_start() which calls	191	* Linux version of TIPC calls eth_media_start() which calls
192	* register_netdevice_notifier() which may block!	192	* register_netdevice_notifier() which may block!
193	*	193	*
194	* Temporarily releasing the lock should be harmless for non-Linux TIPC,	194	* Temporarily releasing the lock should be harmless for non-Linux TIPC,
195	* but Linux version of eth_media_start() should really be reworked	195	* but Linux version of eth_media_start() should really be reworked
196	* so that it can be called with spinlocks held.	196	* so that it can be called with spinlocks held.
197	*/	197	*/
198		198
199	spin_unlock_bh(&config_lock);	199	spin_unlock_bh(&config_lock);
200	tipc_core_start_net(addr);	200	tipc_core_start_net(addr);
201	spin_lock_bh(&config_lock);	201	spin_lock_bh(&config_lock);
202	return tipc_cfg_reply_none();	202	return tipc_cfg_reply_none();
203	}	203	}
204		204
205	static struct sk_buff *cfg_set_remote_mng(void)	205	static struct sk_buff *cfg_set_remote_mng(void)
206	{	206	{
207	u32 value;	207	u32 value;
208		208
209	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))	209	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
210	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	210	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
211		211
212	value = ntohl((__be32 )TLV_DATA(req_tlv_area));	212	value = ntohl((__be32 )TLV_DATA(req_tlv_area));
213	tipc_remote_management = (value != 0);	213	tipc_remote_management = (value != 0);
214	return tipc_cfg_reply_none();	214	return tipc_cfg_reply_none();
215	}	215	}
216		216
217	static struct sk_buff *cfg_set_max_publications(void)	217	static struct sk_buff *cfg_set_max_publications(void)
218	{	218	{
219	u32 value;	219	u32 value;
220		220
221	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))	221	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
222	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	222	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
223		223
224	value = ntohl((__be32 )TLV_DATA(req_tlv_area));	224	value = ntohl((__be32 )TLV_DATA(req_tlv_area));
225	if (value != delimit(value, 1, 65535))	225	if (value != delimit(value, 1, 65535))
226	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE	226	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
227	" (max publications must be 1-65535)");	227	" (max publications must be 1-65535)");
228	tipc_max_publications = value;	228	tipc_max_publications = value;
229	return tipc_cfg_reply_none();	229	return tipc_cfg_reply_none();
230	}	230	}
231		231
232	static struct sk_buff *cfg_set_max_subscriptions(void)	232	static struct sk_buff *cfg_set_max_subscriptions(void)
233	{	233	{
234	u32 value;	234	u32 value;
235		235
236	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))	236	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
237	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	237	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
238		238
239	value = ntohl((__be32 )TLV_DATA(req_tlv_area));	239	value = ntohl((__be32 )TLV_DATA(req_tlv_area));
240	if (value != delimit(value, 1, 65535))	240	if (value != delimit(value, 1, 65535))
241	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE	241	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
242	" (max subscriptions must be 1-65535");	242	" (max subscriptions must be 1-65535");
243	tipc_max_subscriptions = value;	243	tipc_max_subscriptions = value;
244	return tipc_cfg_reply_none();	244	return tipc_cfg_reply_none();
245	}	245	}
246		246
247	static struct sk_buff *cfg_set_max_ports(void)	247	static struct sk_buff *cfg_set_max_ports(void)
248	{	248	{
249	u32 value;	249	u32 value;
250		250
251	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))	251	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
252	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	252	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
253	value = ntohl((__be32 )TLV_DATA(req_tlv_area));	253	value = ntohl((__be32 )TLV_DATA(req_tlv_area));
254	if (value == tipc_max_ports)	254	if (value == tipc_max_ports)
255	return tipc_cfg_reply_none();	255	return tipc_cfg_reply_none();
256	if (value != delimit(value, 127, 65535))	256	if (value != delimit(value, 127, 65535))
257	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE	257	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
258	" (max ports must be 127-65535)");	258	" (max ports must be 127-65535)");
259	if (tipc_mode != TIPC_NOT_RUNNING)	259	if (tipc_mode != TIPC_NOT_RUNNING)
260	return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED	260	return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
261	" (cannot change max ports while TIPC is active)");	261	" (cannot change max ports while TIPC is active)");
262	tipc_max_ports = value;	262	tipc_max_ports = value;
263	return tipc_cfg_reply_none();	263	return tipc_cfg_reply_none();
264	}	264	}
265		265
266	static struct sk_buff *cfg_set_max_nodes(void)	266	static struct sk_buff *cfg_set_max_nodes(void)
267	{	267	{
268	u32 value;	268	u32 value;
269		269
270	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))	270	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
271	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	271	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
272	value = ntohl((__be32 )TLV_DATA(req_tlv_area));	272	value = ntohl((__be32 )TLV_DATA(req_tlv_area));
273	if (value == tipc_max_nodes)	273	if (value == tipc_max_nodes)
274	return tipc_cfg_reply_none();	274	return tipc_cfg_reply_none();
275	if (value != delimit(value, 8, 2047))	275	if (value != delimit(value, 8, 2047))
276	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE	276	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
277	" (max nodes must be 8-2047)");	277	" (max nodes must be 8-2047)");
278	if (tipc_mode == TIPC_NET_MODE)	278	if (tipc_mode == TIPC_NET_MODE)
279	return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED	279	return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
280	" (cannot change max nodes once TIPC has joined a network)");	280	" (cannot change max nodes once TIPC has joined a network)");
281	tipc_max_nodes = value;	281	tipc_max_nodes = value;
282	return tipc_cfg_reply_none();	282	return tipc_cfg_reply_none();
283	}	283	}
284		284
285	static struct sk_buff *cfg_set_netid(void)	285	static struct sk_buff *cfg_set_netid(void)
286	{	286	{
287	u32 value;	287	u32 value;
288		288
289	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))	289	if (!TLV_CHECK(req_tlv_area, req_tlv_space, TIPC_TLV_UNSIGNED))
290	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);	290	return tipc_cfg_reply_error_string(TIPC_CFG_TLV_ERROR);
291	value = ntohl((__be32 )TLV_DATA(req_tlv_area));	291	value = ntohl((__be32 )TLV_DATA(req_tlv_area));
292	if (value == tipc_net_id)	292	if (value == tipc_net_id)
293	return tipc_cfg_reply_none();	293	return tipc_cfg_reply_none();
294	if (value != delimit(value, 1, 9999))	294	if (value != delimit(value, 1, 9999))
295	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE	295	return tipc_cfg_reply_error_string(TIPC_CFG_INVALID_VALUE
296	" (network id must be 1-9999)");	296	" (network id must be 1-9999)");
297	if (tipc_mode == TIPC_NET_MODE)	297	if (tipc_mode == TIPC_NET_MODE)
298	return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED	298	return tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
299	" (cannot change network id once TIPC has joined a network)");	299	" (cannot change network id once TIPC has joined a network)");
300	tipc_net_id = value;	300	tipc_net_id = value;
301	return tipc_cfg_reply_none();	301	return tipc_cfg_reply_none();
302	}	302	}
303		303
304	struct sk_buff tipc_cfg_do_cmd(u32 orig_node, u16 cmd, const void request_area,	304	struct sk_buff tipc_cfg_do_cmd(u32 orig_node, u16 cmd, const void request_area,
305	int request_space, int reply_headroom)	305	int request_space, int reply_headroom)
306	{	306	{
307	struct sk_buff *rep_tlv_buf;	307	struct sk_buff *rep_tlv_buf;
308		308
309	spin_lock_bh(&config_lock);	309	spin_lock_bh(&config_lock);
310		310
311	/* Save request and reply details in a well-known location */	311	/* Save request and reply details in a well-known location */
312		312
313	req_tlv_area = request_area;	313	req_tlv_area = request_area;
314	req_tlv_space = request_space;	314	req_tlv_space = request_space;
315	rep_headroom = reply_headroom;	315	rep_headroom = reply_headroom;
316		316
317	/* Check command authorization */	317	/* Check command authorization */
318		318
319	if (likely(orig_node == tipc_own_addr)) {	319	if (likely(orig_node == tipc_own_addr)) {
320	/* command is permitted */	320	/* command is permitted */
321	} else if (cmd >= 0x8000) {	321	} else if (cmd >= 0x8000) {
322	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED	322	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
323	" (cannot be done remotely)");	323	" (cannot be done remotely)");
324	goto exit;	324	goto exit;
325	} else if (!tipc_remote_management) {	325	} else if (!tipc_remote_management) {
326	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NO_REMOTE);	326	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NO_REMOTE);
327	goto exit;	327	goto exit;
328	}	328	}
329	else if (cmd >= 0x4000) {	329	else if (cmd >= 0x4000) {
330	u32 domain = 0;	330	u32 domain = 0;
331		331
332	if ((tipc_nametbl_translate(TIPC_ZM_SRV, 0, &domain) == 0) \|\|	332	if ((tipc_nametbl_translate(TIPC_ZM_SRV, 0, &domain) == 0) \|\|
333	(domain != orig_node)) {	333	(domain != orig_node)) {
334	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_ZONE_MSTR);	334	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_ZONE_MSTR);
335	goto exit;	335	goto exit;
336	}	336	}
337	}	337	}
338		338
339	/* Call appropriate processing routine */	339	/* Call appropriate processing routine */
340		340
341	switch (cmd) {	341	switch (cmd) {
342	case TIPC_CMD_NOOP:	342	case TIPC_CMD_NOOP:
343	rep_tlv_buf = tipc_cfg_reply_none();	343	rep_tlv_buf = tipc_cfg_reply_none();
344	break;	344	break;
345	case TIPC_CMD_GET_NODES:	345	case TIPC_CMD_GET_NODES:
346	rep_tlv_buf = tipc_node_get_nodes(req_tlv_area, req_tlv_space);	346	rep_tlv_buf = tipc_node_get_nodes(req_tlv_area, req_tlv_space);
347	break;	347	break;
348	case TIPC_CMD_GET_LINKS:	348	case TIPC_CMD_GET_LINKS:
349	rep_tlv_buf = tipc_node_get_links(req_tlv_area, req_tlv_space);	349	rep_tlv_buf = tipc_node_get_links(req_tlv_area, req_tlv_space);
350	break;	350	break;
351	case TIPC_CMD_SHOW_LINK_STATS:	351	case TIPC_CMD_SHOW_LINK_STATS:
352	rep_tlv_buf = tipc_link_cmd_show_stats(req_tlv_area, req_tlv_space);	352	rep_tlv_buf = tipc_link_cmd_show_stats(req_tlv_area, req_tlv_space);
353	break;	353	break;
354	case TIPC_CMD_RESET_LINK_STATS:	354	case TIPC_CMD_RESET_LINK_STATS:
355	rep_tlv_buf = tipc_link_cmd_reset_stats(req_tlv_area, req_tlv_space);	355	rep_tlv_buf = tipc_link_cmd_reset_stats(req_tlv_area, req_tlv_space);
356	break;	356	break;
357	case TIPC_CMD_SHOW_NAME_TABLE:	357	case TIPC_CMD_SHOW_NAME_TABLE:
358	rep_tlv_buf = tipc_nametbl_get(req_tlv_area, req_tlv_space);	358	rep_tlv_buf = tipc_nametbl_get(req_tlv_area, req_tlv_space);
359	break;	359	break;
360	case TIPC_CMD_GET_BEARER_NAMES:	360	case TIPC_CMD_GET_BEARER_NAMES:
361	rep_tlv_buf = tipc_bearer_get_names();	361	rep_tlv_buf = tipc_bearer_get_names();
362	break;	362	break;
363	case TIPC_CMD_GET_MEDIA_NAMES:	363	case TIPC_CMD_GET_MEDIA_NAMES:
364	rep_tlv_buf = tipc_media_get_names();	364	rep_tlv_buf = tipc_media_get_names();
365	break;	365	break;
366	case TIPC_CMD_SHOW_PORTS:	366	case TIPC_CMD_SHOW_PORTS:
367	rep_tlv_buf = tipc_port_get_ports();	367	rep_tlv_buf = tipc_port_get_ports();
368	break;	368	break;
369	case TIPC_CMD_SET_LOG_SIZE:	369	case TIPC_CMD_SET_LOG_SIZE:
370	rep_tlv_buf = tipc_log_resize_cmd(req_tlv_area, req_tlv_space);	370	rep_tlv_buf = tipc_log_resize_cmd(req_tlv_area, req_tlv_space);
371	break;	371	break;
372	case TIPC_CMD_DUMP_LOG:	372	case TIPC_CMD_DUMP_LOG:
373	rep_tlv_buf = tipc_log_dump();	373	rep_tlv_buf = tipc_log_dump();
374	break;	374	break;
375	case TIPC_CMD_SHOW_STATS:	375	case TIPC_CMD_SHOW_STATS:
376	rep_tlv_buf = tipc_show_stats();	376	rep_tlv_buf = tipc_show_stats();
377	break;	377	break;
378	case TIPC_CMD_SET_LINK_TOL:	378	case TIPC_CMD_SET_LINK_TOL:
379	case TIPC_CMD_SET_LINK_PRI:	379	case TIPC_CMD_SET_LINK_PRI:
380	case TIPC_CMD_SET_LINK_WINDOW:	380	case TIPC_CMD_SET_LINK_WINDOW:
381	rep_tlv_buf = tipc_link_cmd_config(req_tlv_area, req_tlv_space, cmd);	381	rep_tlv_buf = tipc_link_cmd_config(req_tlv_area, req_tlv_space, cmd);
382	break;	382	break;
383	case TIPC_CMD_ENABLE_BEARER:	383	case TIPC_CMD_ENABLE_BEARER:
384	rep_tlv_buf = cfg_enable_bearer();	384	rep_tlv_buf = cfg_enable_bearer();
385	break;	385	break;
386	case TIPC_CMD_DISABLE_BEARER:	386	case TIPC_CMD_DISABLE_BEARER:
387	rep_tlv_buf = cfg_disable_bearer();	387	rep_tlv_buf = cfg_disable_bearer();
388	break;	388	break;
389	case TIPC_CMD_SET_NODE_ADDR:	389	case TIPC_CMD_SET_NODE_ADDR:
390	rep_tlv_buf = cfg_set_own_addr();	390	rep_tlv_buf = cfg_set_own_addr();
391	break;	391	break;
392	case TIPC_CMD_SET_REMOTE_MNG:	392	case TIPC_CMD_SET_REMOTE_MNG:
393	rep_tlv_buf = cfg_set_remote_mng();	393	rep_tlv_buf = cfg_set_remote_mng();
394	break;	394	break;
395	case TIPC_CMD_SET_MAX_PORTS:	395	case TIPC_CMD_SET_MAX_PORTS:
396	rep_tlv_buf = cfg_set_max_ports();	396	rep_tlv_buf = cfg_set_max_ports();
397	break;	397	break;
398	case TIPC_CMD_SET_MAX_PUBL:	398	case TIPC_CMD_SET_MAX_PUBL:
399	rep_tlv_buf = cfg_set_max_publications();	399	rep_tlv_buf = cfg_set_max_publications();
400	break;	400	break;
401	case TIPC_CMD_SET_MAX_SUBSCR:	401	case TIPC_CMD_SET_MAX_SUBSCR:
402	rep_tlv_buf = cfg_set_max_subscriptions();	402	rep_tlv_buf = cfg_set_max_subscriptions();
403	break;	403	break;
404	case TIPC_CMD_SET_MAX_NODES:	404	case TIPC_CMD_SET_MAX_NODES:
405	rep_tlv_buf = cfg_set_max_nodes();	405	rep_tlv_buf = cfg_set_max_nodes();
406	break;	406	break;
407	case TIPC_CMD_SET_NETID:	407	case TIPC_CMD_SET_NETID:
408	rep_tlv_buf = cfg_set_netid();	408	rep_tlv_buf = cfg_set_netid();
409	break;	409	break;
410	case TIPC_CMD_GET_REMOTE_MNG:	410	case TIPC_CMD_GET_REMOTE_MNG:
411	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_remote_management);	411	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_remote_management);
412	break;	412	break;
413	case TIPC_CMD_GET_MAX_PORTS:	413	case TIPC_CMD_GET_MAX_PORTS:
414	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_ports);	414	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_ports);
415	break;	415	break;
416	case TIPC_CMD_GET_MAX_PUBL:	416	case TIPC_CMD_GET_MAX_PUBL:
417	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_publications);	417	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_publications);
418	break;	418	break;
419	case TIPC_CMD_GET_MAX_SUBSCR:	419	case TIPC_CMD_GET_MAX_SUBSCR:
420	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_subscriptions);	420	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_subscriptions);
421	break;	421	break;
422	case TIPC_CMD_GET_MAX_NODES:	422	case TIPC_CMD_GET_MAX_NODES:
423	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_nodes);	423	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_max_nodes);
424	break;	424	break;
425	case TIPC_CMD_GET_NETID:	425	case TIPC_CMD_GET_NETID:
426	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_net_id);	426	rep_tlv_buf = tipc_cfg_reply_unsigned(tipc_net_id);
427	break;	427	break;
428	case TIPC_CMD_NOT_NET_ADMIN:	428	case TIPC_CMD_NOT_NET_ADMIN:
429	rep_tlv_buf =	429	rep_tlv_buf =
430	tipc_cfg_reply_error_string(TIPC_CFG_NOT_NET_ADMIN);	430	tipc_cfg_reply_error_string(TIPC_CFG_NOT_NET_ADMIN);
431	break;	431	break;
432	case TIPC_CMD_SET_MAX_ZONES:	432	case TIPC_CMD_SET_MAX_ZONES:
433	case TIPC_CMD_GET_MAX_ZONES:	433	case TIPC_CMD_GET_MAX_ZONES:
434	case TIPC_CMD_SET_MAX_SLAVES:	434	case TIPC_CMD_SET_MAX_SLAVES:
435	case TIPC_CMD_GET_MAX_SLAVES:	435	case TIPC_CMD_GET_MAX_SLAVES:
436	case TIPC_CMD_SET_MAX_CLUSTERS:	436	case TIPC_CMD_SET_MAX_CLUSTERS:
437	case TIPC_CMD_GET_MAX_CLUSTERS:	437	case TIPC_CMD_GET_MAX_CLUSTERS:
438	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED	438	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
439	" (obsolete command)");	439	" (obsolete command)");
440	break;	440	break;
441	default:	441	default:
442	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED	442	rep_tlv_buf = tipc_cfg_reply_error_string(TIPC_CFG_NOT_SUPPORTED
443	" (unknown command)");	443	" (unknown command)");
444	break;	444	break;
445	}	445	}
446		446
447	/* Return reply buffer */	447	/* Return reply buffer */
448	exit:	448	exit:
449	spin_unlock_bh(&config_lock);	449	spin_unlock_bh(&config_lock);
450	return rep_tlv_buf;	450	return rep_tlv_buf;
451	}	451	}
452		452
453	static void cfg_named_msg_event(void *userdata,	453	static void cfg_named_msg_event(void *userdata,
454	u32 port_ref,	454	u32 port_ref,
455	struct sk_buff **buf,	455	struct sk_buff **buf,
456	const unchar *msg,	456	const unchar *msg,
457	u32 size,	457	u32 size,
458	u32 importance,	458	u32 importance,
459	struct tipc_portid const *orig,	459	struct tipc_portid const *orig,
460	struct tipc_name_seq const *dest)	460	struct tipc_name_seq const *dest)
461	{	461	{
462	struct tipc_cfg_msg_hdr *req_hdr;	462	struct tipc_cfg_msg_hdr *req_hdr;
463	struct tipc_cfg_msg_hdr *rep_hdr;	463	struct tipc_cfg_msg_hdr *rep_hdr;
464	struct sk_buff *rep_buf;	464	struct sk_buff *rep_buf;
465		465
466	/* Validate configuration message header (ignore invalid message) */	466	/* Validate configuration message header (ignore invalid message) */
467		467
468	req_hdr = (struct tipc_cfg_msg_hdr *)msg;	468	req_hdr = (struct tipc_cfg_msg_hdr *)msg;
469	if ((size < sizeof(*req_hdr)) \|\|	469	if ((size < sizeof(*req_hdr)) \|\|
470	(size != TCM_ALIGN(ntohl(req_hdr->tcm_len))) \|\|	470	(size != TCM_ALIGN(ntohl(req_hdr->tcm_len))) \|\|
471	(ntohs(req_hdr->tcm_flags) != TCM_F_REQUEST)) {	471	(ntohs(req_hdr->tcm_flags) != TCM_F_REQUEST)) {
472	warn("Invalid configuration message discarded\n");	472	warn("Invalid configuration message discarded\n");
473	return;	473	return;
474	}	474	}
475		475
476	/* Generate reply for request (if can't, return request) */	476	/* Generate reply for request (if can't, return request) */
477		477
478	rep_buf = tipc_cfg_do_cmd(orig->node,	478	rep_buf = tipc_cfg_do_cmd(orig->node,
479	ntohs(req_hdr->tcm_type),	479	ntohs(req_hdr->tcm_type),
480	msg + sizeof(*req_hdr),	480	msg + sizeof(*req_hdr),
481	size - sizeof(*req_hdr),	481	size - sizeof(*req_hdr),
482	BUF_HEADROOM + MAX_H_SIZE + sizeof(*rep_hdr));	482	BUF_HEADROOM + MAX_H_SIZE + sizeof(*rep_hdr));
483	if (rep_buf) {	483	if (rep_buf) {
484	skb_push(rep_buf, sizeof(*rep_hdr));	484	skb_push(rep_buf, sizeof(*rep_hdr));
485	rep_hdr = (struct tipc_cfg_msg_hdr *)rep_buf->data;	485	rep_hdr = (struct tipc_cfg_msg_hdr *)rep_buf->data;
486	memcpy(rep_hdr, req_hdr, sizeof(*rep_hdr));	486	memcpy(rep_hdr, req_hdr, sizeof(*rep_hdr));
487	rep_hdr->tcm_len = htonl(rep_buf->len);	487	rep_hdr->tcm_len = htonl(rep_buf->len);
488	rep_hdr->tcm_flags &= htons(~TCM_F_REQUEST);	488	rep_hdr->tcm_flags &= htons(~TCM_F_REQUEST);
489	} else {	489	} else {
490	rep_buf = *buf;	490	rep_buf = *buf;
491	*buf = NULL;	491	*buf = NULL;
492	}	492	}
493		493
494	/* NEED TO ADD CODE TO HANDLE FAILED SEND (SUCH AS CONGESTION) */	494	/* NEED TO ADD CODE TO HANDLE FAILED SEND (SUCH AS CONGESTION) */
495	tipc_send_buf2port(port_ref, orig, rep_buf, rep_buf->len);	495	tipc_send_buf2port(port_ref, orig, rep_buf, rep_buf->len);
496	}	496	}
497		497
498	int tipc_cfg_init(void)	498	int tipc_cfg_init(void)
499	{	499	{
500	struct tipc_name_seq seq;	500	struct tipc_name_seq seq;
501	int res;	501	int res;
502		502
503	res = tipc_createport(0, NULL, TIPC_CRITICAL_IMPORTANCE,	503	res = tipc_createport(NULL, TIPC_CRITICAL_IMPORTANCE,
504	NULL, NULL, NULL,	504	NULL, NULL, NULL,
505	NULL, cfg_named_msg_event, NULL,	505	NULL, cfg_named_msg_event, NULL,
506	NULL, &config_port_ref);	506	NULL, &config_port_ref);
507	if (res)	507	if (res)
508	goto failed;	508	goto failed;
509		509
510	seq.type = TIPC_CFG_SRV;	510	seq.type = TIPC_CFG_SRV;
511	seq.lower = seq.upper = tipc_own_addr;	511	seq.lower = seq.upper = tipc_own_addr;
512	res = tipc_nametbl_publish_rsv(config_port_ref, TIPC_ZONE_SCOPE, &seq);	512	res = tipc_nametbl_publish_rsv(config_port_ref, TIPC_ZONE_SCOPE, &seq);
513	if (res)	513	if (res)
514	goto failed;	514	goto failed;
515		515
516	return 0;	516	return 0;
517		517
518	failed:	518	failed:
519	err("Unable to create configuration service\n");	519	err("Unable to create configuration service\n");
520	return res;	520	return res;
521	}	521	}
522		522
523	void tipc_cfg_stop(void)	523	void tipc_cfg_stop(void)
524	{	524	{
525	if (config_port_ref) {	525	if (config_port_ref) {
526	tipc_deleteport(config_port_ref);	526	tipc_deleteport(config_port_ref);
527	config_port_ref = 0;	527	config_port_ref = 0;
528	}	528	}
529	}	529	}
530		530

net/tipc/core.c

Diff comments View file @ b0c1e92

 /*
  * net/tipc/core.c: TIPC module code
  *
  * Copyright (c) 2003-2006, Ericsson AB
  * Copyright (c) 2005-2006, 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 <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/random.h>
 #include "core.h"
 #include "ref.h"
 #include "net.h"
-#include "user_reg.h"
 #include "name_table.h"
 #include "subscr.h"
 #include "config.h"
 #ifndef CONFIG_TIPC_NODES
 #define CONFIG_TIPC_NODES 255
 #endif
 #ifndef CONFIG_TIPC_PORTS
 #define CONFIG_TIPC_PORTS 8191
 #endif
 #ifndef CONFIG_TIPC_LOG
 #define CONFIG_TIPC_LOG 0
 #endif
 /* global variables used by multiple sub-systems within TIPC */
 int tipc_mode = TIPC_NOT_RUNNING;
 int tipc_random;
 atomic_t tipc_user_count = ATOMIC_INIT(0);
 const char tipc_alphabet[] =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.";
 /* configurable TIPC parameters */
 u32 tipc_own_addr;
 int tipc_max_nodes;
 int tipc_max_ports;
 int tipc_max_subscriptions;
 int tipc_max_publications;
 int tipc_net_id;
 int tipc_remote_management;
 /**
  * tipc_buf_acquire - creates a TIPC message buffer
  * @size: message size (including TIPC header)
  *
  * Returns a new buffer with data pointers set to the specified size.
  *
  * NOTE: Headroom is reserved to allow prepending of a data link header.
  *       There may also be unrequested tailroom present at the buffer's end.
  */
 struct sk_buff *tipc_buf_acquire(u32 size)
 {
 	struct sk_buff *skb;
 	unsigned int buf_size = (BUF_HEADROOM + size + 3) & ~3u;
 	skb = alloc_skb_fclone(buf_size, GFP_ATOMIC);
 	if (skb) {
 		skb_reserve(skb, BUF_HEADROOM);
 		skb_put(skb, size);
 		skb->next = NULL;
 	}
 	return skb;
 }
 /**
  * tipc_core_stop_net - shut down TIPC networking sub-systems
  */
 static void tipc_core_stop_net(void)
 {
 	tipc_eth_media_stop();
 	tipc_net_stop();
 }
 /**
  * start_net - start TIPC networking sub-systems
  */
 int tipc_core_start_net(unsigned long addr)
 {
 	int res;
 	if ((res = tipc_net_start(addr)) ||
 	    (res = tipc_eth_media_start())) {
 		tipc_core_stop_net();
 	}
 	return res;
 }
 /**
  * tipc_core_stop - switch TIPC from SINGLE NODE to NOT RUNNING mode
  */
 static void tipc_core_stop(void)
 {
 	if (tipc_mode != TIPC_NODE_MODE)
 		return;
 	tipc_mode = TIPC_NOT_RUNNING;
 	tipc_netlink_stop();
 	tipc_handler_stop();
 	tipc_cfg_stop();
 	tipc_subscr_stop();
-	tipc_reg_stop();
 	tipc_nametbl_stop();
 	tipc_ref_table_stop();
 	tipc_socket_stop();
 	tipc_log_resize(0);
 }
 /**
  * tipc_core_start - switch TIPC from NOT RUNNING to SINGLE NODE mode
  */
 static int tipc_core_start(void)
 {
 	int res;
 	if (tipc_mode != TIPC_NOT_RUNNING)
 		return -ENOPROTOOPT;
 	get_random_bytes(&tipc_random, sizeof(tipc_random));
 	tipc_mode = TIPC_NODE_MODE;
 	if ((res = tipc_handler_start()) ||
 	    (res = tipc_ref_table_init(tipc_max_ports, tipc_random)) ||
-	    (res = tipc_reg_start()) ||
 	    (res = tipc_nametbl_init()) ||
 	    (res = tipc_k_signal((Handler)tipc_subscr_start, 0)) ||
 	    (res = tipc_k_signal((Handler)tipc_cfg_init, 0)) ||
 	    (res = tipc_netlink_start()) ||
 	    (res = tipc_socket_init())) {
 		tipc_core_stop();
 	}
 	return res;
 }
 static int __init tipc_init(void)
 {
 	int res;
 	if (tipc_log_resize(CONFIG_TIPC_LOG) != 0)
 		warn("Unable to create log buffer\n");
 	info("Activated (version " TIPC_MOD_VER
 	     " compiled " __DATE__ " " __TIME__ ")\n");
 	tipc_own_addr = 0;
 	tipc_remote_management = 1;
 	tipc_max_publications = 10000;
 	tipc_max_subscriptions = 2000;
 	tipc_max_ports = CONFIG_TIPC_PORTS;
 	tipc_max_nodes = CONFIG_TIPC_NODES;
 	tipc_net_id = 4711;
 	if ((res = tipc_core_start()))
 		err("Unable to start in single node mode\n");
 	else
 		info("Started in single node mode\n");
 	return res;
 }
 static void __exit tipc_exit(void)
 {
 	tipc_core_stop_net();
 	tipc_core_stop();
 	info("Deactivated\n");
 }
 module_init(tipc_init);
 module_exit(tipc_exit);
 MODULE_DESCRIPTION("TIPC: Transparent Inter Process Communication");
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_VERSION(TIPC_MOD_VER);

net/tipc/port.c

Diff comments View file @ b0c1e92

 /*
  * net/tipc/port.c: TIPC port code
  *
  * Copyright (c) 1992-2007, Ericsson AB
  * Copyright (c) 2004-2008, 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 "config.h"
 #include "port.h"
 #include "name_table.h"
-#include "user_reg.h"
 /* Connection management: */
 #define PROBING_INTERVAL 3600000	/* [ms] => 1 h */
 #define CONFIRMED 0
 #define PROBING 1
 #define MAX_REJECT_SIZE 1024
 static struct sk_buff *msg_queue_head = NULL;
 static struct sk_buff *msg_queue_tail = NULL;
 DEFINE_SPINLOCK(tipc_port_list_lock);
 static DEFINE_SPINLOCK(queue_lock);
 static LIST_HEAD(ports);
 static void port_handle_node_down(unsigned long ref);
 static struct sk_buff* port_build_self_abort_msg(struct port *,u32 err);
 static struct sk_buff* port_build_peer_abort_msg(struct port *,u32 err);
 static void port_timeout(unsigned long ref);
 static u32 port_peernode(struct port *p_ptr)
 {
 	return msg_destnode(&p_ptr->publ.phdr);
 }
 static u32 port_peerport(struct port *p_ptr)
 {
 	return msg_destport(&p_ptr->publ.phdr);
 }
 static u32 port_out_seqno(struct port *p_ptr)
 {
 	return msg_transp_seqno(&p_ptr->publ.phdr);
 }
 static void port_incr_out_seqno(struct port *p_ptr)
 {
 	struct tipc_msg *m = &p_ptr->publ.phdr;
 	if (likely(!msg_routed(m)))
 		return;
 	msg_set_transp_seqno(m, (msg_transp_seqno(m) + 1));
 }
 /**
  * tipc_multicast - send a multicast message to local and remote destinations
  */
 int tipc_multicast(u32 ref, struct tipc_name_seq const *seq,
 		   u32 num_sect, struct iovec const *msg_sect)
 {
 	struct tipc_msg *hdr;
 	struct sk_buff *buf;
 	struct sk_buff *ibuf = NULL;
 	struct port_list dports = {0, NULL, };
 	struct port *oport = tipc_port_deref(ref);
 	int ext_targets;
 	int res;
 	if (unlikely(!oport))
 		return -EINVAL;
 	/* Create multicast message */
 	hdr = &oport->publ.phdr;
 	msg_set_type(hdr, TIPC_MCAST_MSG);
 	msg_set_nametype(hdr, seq->type);
 	msg_set_namelower(hdr, seq->lower);
 	msg_set_nameupper(hdr, seq->upper);
 	msg_set_hdr_sz(hdr, MCAST_H_SIZE);
 	res = tipc_msg_build(hdr, msg_sect, num_sect, MAX_MSG_SIZE,
 			!oport->user_port, &buf);
 	if (unlikely(!buf))
 		return res;
 	/* Figure out where to send multicast message */
 	ext_targets = tipc_nametbl_mc_translate(seq->type, seq->lower, seq->upper,
 						TIPC_NODE_SCOPE, &dports);
 	/* Send message to destinations (duplicate it only if necessary) */
 	if (ext_targets) {
 		if (dports.count != 0) {
 			ibuf = skb_copy(buf, GFP_ATOMIC);
 			if (ibuf == NULL) {
 				tipc_port_list_free(&dports);
 				buf_discard(buf);
 				return -ENOMEM;
 			}
 		}
 		res = tipc_bclink_send_msg(buf);
 		if ((res < 0) && (dports.count != 0)) {
 			buf_discard(ibuf);
 		}
 	} else {
 		ibuf = buf;
 	}
 	if (res >= 0) {
 		if (ibuf)
 			tipc_port_recv_mcast(ibuf, &dports);
 	} else {
 		tipc_port_list_free(&dports);
 	}
 	return res;
 }
 /**
  * tipc_port_recv_mcast - deliver multicast message to all destination ports
  *
  * If there is no port list, perform a lookup to create one
  */
 void tipc_port_recv_mcast(struct sk_buff *buf, struct port_list *dp)
 {
 	struct tipc_msg* msg;
 	struct port_list dports = {0, NULL, };
 	struct port_list *item = dp;
 	int cnt = 0;
 	msg = buf_msg(buf);
 	/* Create destination port list, if one wasn't supplied */
 	if (dp == NULL) {
 		tipc_nametbl_mc_translate(msg_nametype(msg),
 				     msg_namelower(msg),
 				     msg_nameupper(msg),
 				     TIPC_CLUSTER_SCOPE,
 				     &dports);
 		item = dp = &dports;
 	}
 	/* Deliver a copy of message to each destination port */
 	if (dp->count != 0) {
 		if (dp->count == 1) {
 			msg_set_destport(msg, dp->ports[0]);
 			tipc_port_recv_msg(buf);
 			tipc_port_list_free(dp);
 			return;
 		}
 		for (; cnt < dp->count; cnt++) {
 			int index = cnt % PLSIZE;
 			struct sk_buff *b = skb_clone(buf, GFP_ATOMIC);
 			if (b == NULL) {
 				warn("Unable to deliver multicast message(s)\n");
 				msg_dbg(msg, "LOST:");
 				goto exit;
 			}
 			if ((index == 0) && (cnt != 0)) {
 				item = item->next;
 			}
 			msg_set_destport(buf_msg(b),item->ports[index]);
 			tipc_port_recv_msg(b);
 		}
 	}
 exit:
 	buf_discard(buf);
 	tipc_port_list_free(dp);
 }
 /**
  * tipc_createport_raw - create a generic TIPC port
  *
  * Returns pointer to (locked) TIPC port, or NULL if unable to create it
  */
 struct tipc_port *tipc_createport_raw(void *usr_handle,
 			u32 (*dispatcher)(struct tipc_port *, struct sk_buff *),
 			void (*wakeup)(struct tipc_port *),
 			const u32 importance)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	u32 ref;
 	p_ptr = kzalloc(sizeof(*p_ptr), GFP_ATOMIC);
 	if (!p_ptr) {
 		warn("Port creation failed, no memory\n");
 		return NULL;
 	}
 	ref = tipc_ref_acquire(p_ptr, &p_ptr->publ.lock);
 	if (!ref) {
 		warn("Port creation failed, reference table exhausted\n");
 		kfree(p_ptr);
 		return NULL;
 	}
 	p_ptr->publ.usr_handle = usr_handle;
 	p_ptr->publ.max_pkt = MAX_PKT_DEFAULT;
 	p_ptr->publ.ref = ref;
 	msg = &p_ptr->publ.phdr;
 	tipc_msg_init(msg, importance, TIPC_NAMED_MSG, LONG_H_SIZE, 0);
 	msg_set_origport(msg, ref);
 	p_ptr->last_in_seqno = 41;
 	p_ptr->sent = 1;
 	INIT_LIST_HEAD(&p_ptr->wait_list);
 	INIT_LIST_HEAD(&p_ptr->subscription.nodesub_list);
 	p_ptr->dispatcher = dispatcher;
 	p_ptr->wakeup = wakeup;
 	p_ptr->user_port = NULL;
 	k_init_timer(&p_ptr->timer, (Handler)port_timeout, ref);
 	spin_lock_bh(&tipc_port_list_lock);
 	INIT_LIST_HEAD(&p_ptr->publications);
 	INIT_LIST_HEAD(&p_ptr->port_list);
 	list_add_tail(&p_ptr->port_list, &ports);
 	spin_unlock_bh(&tipc_port_list_lock);
 	return &(p_ptr->publ);
 }
 int tipc_deleteport(u32 ref)
 {
 	struct port *p_ptr;
 	struct sk_buff *buf = NULL;
 	tipc_withdraw(ref, 0, NULL);
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	tipc_ref_discard(ref);
 	tipc_port_unlock(p_ptr);
 	k_cancel_timer(&p_ptr->timer);
 	if (p_ptr->publ.connected) {
 		buf = port_build_peer_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
 		tipc_nodesub_unsubscribe(&p_ptr->subscription);
 	}
 	if (p_ptr->user_port) {
-		tipc_reg_remove_port(p_ptr->user_port);
 		kfree(p_ptr->user_port);
 	}
 	spin_lock_bh(&tipc_port_list_lock);
 	list_del(&p_ptr->port_list);
 	list_del(&p_ptr->wait_list);
 	spin_unlock_bh(&tipc_port_list_lock);
 	k_term_timer(&p_ptr->timer);
 	kfree(p_ptr);
 	dbg("Deleted port %u\n", ref);
 	tipc_net_route_msg(buf);
 	return 0;
 }
 static int port_unreliable(struct port *p_ptr)
 {
 	return msg_src_droppable(&p_ptr->publ.phdr);
 }
 int tipc_portunreliable(u32 ref, unsigned int *isunreliable)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	*isunreliable = port_unreliable(p_ptr);
 	tipc_port_unlock(p_ptr);
 	return 0;
 }
 int tipc_set_portunreliable(u32 ref, unsigned int isunreliable)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	msg_set_src_droppable(&p_ptr->publ.phdr, (isunreliable != 0));
 	tipc_port_unlock(p_ptr);
 	return 0;
 }
 static int port_unreturnable(struct port *p_ptr)
 {
 	return msg_dest_droppable(&p_ptr->publ.phdr);
 }
 int tipc_portunreturnable(u32 ref, unsigned int *isunrejectable)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	*isunrejectable = port_unreturnable(p_ptr);
 	tipc_port_unlock(p_ptr);
 	return 0;
 }
 int tipc_set_portunreturnable(u32 ref, unsigned int isunrejectable)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	msg_set_dest_droppable(&p_ptr->publ.phdr, (isunrejectable != 0));
 	tipc_port_unlock(p_ptr);
 	return 0;
 }
 /*
  * port_build_proto_msg(): build a port level protocol
  * or a connection abortion message. Called with
  * tipc_port lock on.
  */
 static struct sk_buff *port_build_proto_msg(u32 destport, u32 destnode,
 					    u32 origport, u32 orignode,
 					    u32 usr, u32 type, u32 err,
 					    u32 seqno, u32 ack)
 {
 	struct sk_buff *buf;
 	struct tipc_msg *msg;
 	buf = tipc_buf_acquire(LONG_H_SIZE);
 	if (buf) {
 		msg = buf_msg(buf);
 		tipc_msg_init(msg, usr, type, LONG_H_SIZE, destnode);
 		msg_set_errcode(msg, err);
 		msg_set_destport(msg, destport);
 		msg_set_origport(msg, origport);
 		msg_set_orignode(msg, orignode);
 		msg_set_transp_seqno(msg, seqno);
 		msg_set_msgcnt(msg, ack);
 		msg_dbg(msg, "PORT>SEND>:");
 	}
 	return buf;
 }
 int tipc_reject_msg(struct sk_buff *buf, u32 err)
 {
 	struct tipc_msg *msg = buf_msg(buf);
 	struct sk_buff *rbuf;
 	struct tipc_msg *rmsg;
 	int hdr_sz;
 	u32 imp = msg_importance(msg);
 	u32 data_sz = msg_data_sz(msg);
 	if (data_sz > MAX_REJECT_SIZE)
 		data_sz = MAX_REJECT_SIZE;
 	if (msg_connected(msg) && (imp < TIPC_CRITICAL_IMPORTANCE))
 		imp++;
 	msg_dbg(msg, "port->rej: ");
 	/* discard rejected message if it shouldn't be returned to sender */
 	if (msg_errcode(msg) || msg_dest_droppable(msg)) {
 		buf_discard(buf);
 		return data_sz;
 	}
 	/* construct rejected message */
 	if (msg_mcast(msg))
 		hdr_sz = MCAST_H_SIZE;
 	else
 		hdr_sz = LONG_H_SIZE;
 	rbuf = tipc_buf_acquire(data_sz + hdr_sz);
 	if (rbuf == NULL) {
 		buf_discard(buf);
 		return data_sz;
 	}
 	rmsg = buf_msg(rbuf);
 	tipc_msg_init(rmsg, imp, msg_type(msg), hdr_sz, msg_orignode(msg));
 	msg_set_errcode(rmsg, err);
 	msg_set_destport(rmsg, msg_origport(msg));
 	msg_set_origport(rmsg, msg_destport(msg));
 	if (msg_short(msg)) {
 		msg_set_orignode(rmsg, tipc_own_addr);
 		/* leave name type & instance as zeroes */
 	} else {
 		msg_set_orignode(rmsg, msg_destnode(msg));
 		msg_set_nametype(rmsg, msg_nametype(msg));
 		msg_set_nameinst(rmsg, msg_nameinst(msg));
 	}
 	msg_set_size(rmsg, data_sz + hdr_sz);
 	skb_copy_to_linear_data_offset(rbuf, hdr_sz, msg_data(msg), data_sz);
 	/* send self-abort message when rejecting on a connected port */
 	if (msg_connected(msg)) {
 		struct sk_buff *abuf = NULL;
 		struct port *p_ptr = tipc_port_lock(msg_destport(msg));
 		if (p_ptr) {
 			if (p_ptr->publ.connected)
 				abuf = port_build_self_abort_msg(p_ptr, err);
 			tipc_port_unlock(p_ptr);
 		}
 		tipc_net_route_msg(abuf);
 	}
 	/* send rejected message */
 	buf_discard(buf);
 	tipc_net_route_msg(rbuf);
 	return data_sz;
 }
 int tipc_port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr,
 			      struct iovec const *msg_sect, u32 num_sect,
 			      int err)
 {
 	struct sk_buff *buf;
 	int res;
 	res = tipc_msg_build(hdr, msg_sect, num_sect, MAX_MSG_SIZE,
 			!p_ptr->user_port, &buf);
 	if (!buf)
 		return res;
 	return tipc_reject_msg(buf, err);
 }
 static void port_timeout(unsigned long ref)
 {
 	struct port *p_ptr = tipc_port_lock(ref);
 	struct sk_buff *buf = NULL;
 	if (!p_ptr)
 		return;
 	if (!p_ptr->publ.connected) {
 		tipc_port_unlock(p_ptr);
 		return;
 	}
 	/* Last probe answered ? */
 	if (p_ptr->probing_state == PROBING) {
 		buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_PORT);
 	} else {
 		buf = port_build_proto_msg(port_peerport(p_ptr),
 					   port_peernode(p_ptr),
 					   p_ptr->publ.ref,
 					   tipc_own_addr,
 					   CONN_MANAGER,
 					   CONN_PROBE,
 					   TIPC_OK,
 					   port_out_seqno(p_ptr),
 					   0);
 		port_incr_out_seqno(p_ptr);
 		p_ptr->probing_state = PROBING;
 		k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
 	}
 	tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(buf);
 }
 static void port_handle_node_down(unsigned long ref)
 {
 	struct port *p_ptr = tipc_port_lock(ref);
 	struct sk_buff* buf = NULL;
 	if (!p_ptr)
 		return;
 	buf = port_build_self_abort_msg(p_ptr, TIPC_ERR_NO_NODE);
 	tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(buf);
 }
 static struct sk_buff *port_build_self_abort_msg(struct port *p_ptr, u32 err)
 {
 	u32 imp = msg_importance(&p_ptr->publ.phdr);
 	if (!p_ptr->publ.connected)
 		return NULL;
 	if (imp < TIPC_CRITICAL_IMPORTANCE)
 		imp++;
 	return port_build_proto_msg(p_ptr->publ.ref,
 				    tipc_own_addr,
 				    port_peerport(p_ptr),
 				    port_peernode(p_ptr),
 				    imp,
 				    TIPC_CONN_MSG,
 				    err,
 				    p_ptr->last_in_seqno + 1,
 				    0);
 }
 static struct sk_buff *port_build_peer_abort_msg(struct port *p_ptr, u32 err)
 {
 	u32 imp = msg_importance(&p_ptr->publ.phdr);
 	if (!p_ptr->publ.connected)
 		return NULL;
 	if (imp < TIPC_CRITICAL_IMPORTANCE)
 		imp++;
 	return port_build_proto_msg(port_peerport(p_ptr),
 				    port_peernode(p_ptr),
 				    p_ptr->publ.ref,
 				    tipc_own_addr,
 				    imp,
 				    TIPC_CONN_MSG,
 				    err,
 				    port_out_seqno(p_ptr),
 				    0);
 }
 void tipc_port_recv_proto_msg(struct sk_buff *buf)
 {
 	struct tipc_msg *msg = buf_msg(buf);
 	struct port *p_ptr = tipc_port_lock(msg_destport(msg));
 	u32 err = TIPC_OK;
 	struct sk_buff *r_buf = NULL;
 	struct sk_buff *abort_buf = NULL;
 	msg_dbg(msg, "PORT<RECV<:");
 	if (!p_ptr) {
 		err = TIPC_ERR_NO_PORT;
 	} else if (p_ptr->publ.connected) {
 		if ((port_peernode(p_ptr) != msg_orignode(msg)) ||
 		    (port_peerport(p_ptr) != msg_origport(msg))) {
 			err = TIPC_ERR_NO_PORT;
 		} else if (msg_type(msg) == CONN_ACK) {
 			int wakeup = tipc_port_congested(p_ptr) &&
 				     p_ptr->publ.congested &&
 				     p_ptr->wakeup;
 			p_ptr->acked += msg_msgcnt(msg);
 			if (tipc_port_congested(p_ptr))
 				goto exit;
 			p_ptr->publ.congested = 0;
 			if (!wakeup)
 				goto exit;
 			p_ptr->wakeup(&p_ptr->publ);
 			goto exit;
 		}
 	} else if (p_ptr->publ.published) {
 		err = TIPC_ERR_NO_PORT;
 	}
 	if (err) {
 		r_buf = port_build_proto_msg(msg_origport(msg),
 					     msg_orignode(msg),
 					     msg_destport(msg),
 					     tipc_own_addr,
 					     TIPC_HIGH_IMPORTANCE,
 					     TIPC_CONN_MSG,
 					     err,
 					     0,
 					     0);
 		goto exit;
 	}
 	/* All is fine */
 	if (msg_type(msg) == CONN_PROBE) {
 		r_buf = port_build_proto_msg(msg_origport(msg),
 					     msg_orignode(msg),
 					     msg_destport(msg),
 					     tipc_own_addr,
 					     CONN_MANAGER,
 					     CONN_PROBE_REPLY,
 					     TIPC_OK,
 					     port_out_seqno(p_ptr),
 					     0);
 	}
 	p_ptr->probing_state = CONFIRMED;
 	port_incr_out_seqno(p_ptr);
 exit:
 	if (p_ptr)
 		tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(r_buf);
 	tipc_net_route_msg(abort_buf);
 	buf_discard(buf);
 }
 static void port_print(struct port *p_ptr, struct print_buf *buf, int full_id)
 {
 	struct publication *publ;
 	if (full_id)
 		tipc_printf(buf, "<%u.%u.%u:%u>:",
 			    tipc_zone(tipc_own_addr), tipc_cluster(tipc_own_addr),
 			    tipc_node(tipc_own_addr), p_ptr->publ.ref);
 	else
 		tipc_printf(buf, "%-10u:", p_ptr->publ.ref);
 	if (p_ptr->publ.connected) {
 		u32 dport = port_peerport(p_ptr);
 		u32 destnode = port_peernode(p_ptr);
 		tipc_printf(buf, " connected to <%u.%u.%u:%u>",
 			    tipc_zone(destnode), tipc_cluster(destnode),
 			    tipc_node(destnode), dport);
 		if (p_ptr->publ.conn_type != 0)
 			tipc_printf(buf, " via {%u,%u}",
 				    p_ptr->publ.conn_type,
 				    p_ptr->publ.conn_instance);
 	}
 	else if (p_ptr->publ.published) {
 		tipc_printf(buf, " bound to");
 		list_for_each_entry(publ, &p_ptr->publications, pport_list) {
 			if (publ->lower == publ->upper)
 				tipc_printf(buf, " {%u,%u}", publ->type,
 					    publ->lower);
 			else
 				tipc_printf(buf, " {%u,%u,%u}", publ->type,
 					    publ->lower, publ->upper);
 		}
 	}
 	tipc_printf(buf, "\n");
 }
 #define MAX_PORT_QUERY 32768
 struct sk_buff *tipc_port_get_ports(void)
 {
 	struct sk_buff *buf;
 	struct tlv_desc *rep_tlv;
 	struct print_buf pb;
 	struct port *p_ptr;
 	int str_len;
 	buf = tipc_cfg_reply_alloc(TLV_SPACE(MAX_PORT_QUERY));
 	if (!buf)
 		return NULL;
 	rep_tlv = (struct tlv_desc *)buf->data;
 	tipc_printbuf_init(&pb, TLV_DATA(rep_tlv), MAX_PORT_QUERY);
 	spin_lock_bh(&tipc_port_list_lock);
 	list_for_each_entry(p_ptr, &ports, port_list) {
 		spin_lock_bh(p_ptr->publ.lock);
 		port_print(p_ptr, &pb, 0);
 		spin_unlock_bh(p_ptr->publ.lock);
 	}
 	spin_unlock_bh(&tipc_port_list_lock);
 	str_len = tipc_printbuf_validate(&pb);
 	skb_put(buf, TLV_SPACE(str_len));
 	TLV_SET(rep_tlv, TIPC_TLV_ULTRA_STRING, NULL, str_len);
 	return buf;
 }
 void tipc_port_reinit(void)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	spin_lock_bh(&tipc_port_list_lock);
 	list_for_each_entry(p_ptr, &ports, port_list) {
 		msg = &p_ptr->publ.phdr;
 		if (msg_orignode(msg) == tipc_own_addr)
 			break;
 		msg_set_prevnode(msg, tipc_own_addr);
 		msg_set_orignode(msg, tipc_own_addr);
 	}
 	spin_unlock_bh(&tipc_port_list_lock);
 }
 /*
  *  port_dispatcher_sigh(): Signal handler for messages destinated
  *                          to the tipc_port interface.
  */
 static void port_dispatcher_sigh(void *dummy)
 {
 	struct sk_buff *buf;
 	spin_lock_bh(&queue_lock);
 	buf = msg_queue_head;
 	msg_queue_head = NULL;
 	spin_unlock_bh(&queue_lock);
 	while (buf) {
 		struct port *p_ptr;
 		struct user_port *up_ptr;
 		struct tipc_portid orig;
 		struct tipc_name_seq dseq;
 		void *usr_handle;
 		int connected;
 		int published;
 		u32 message_type;
 		struct sk_buff *next = buf->next;
 		struct tipc_msg *msg = buf_msg(buf);
 		u32 dref = msg_destport(msg);
 		message_type = msg_type(msg);
 		if (message_type > TIPC_DIRECT_MSG)
 			goto reject;	/* Unsupported message type */
 		p_ptr = tipc_port_lock(dref);
 		if (!p_ptr)
 			goto reject;	/* Port deleted while msg in queue */
 		orig.ref = msg_origport(msg);
 		orig.node = msg_orignode(msg);
 		up_ptr = p_ptr->user_port;
 		usr_handle = up_ptr->usr_handle;
 		connected = p_ptr->publ.connected;
 		published = p_ptr->publ.published;
 		if (unlikely(msg_errcode(msg)))
 			goto err;
 		switch (message_type) {
 		case TIPC_CONN_MSG:{
 				tipc_conn_msg_event cb = up_ptr->conn_msg_cb;
 				u32 peer_port = port_peerport(p_ptr);
 				u32 peer_node = port_peernode(p_ptr);
 				tipc_port_unlock(p_ptr);
 				if (unlikely(!cb))
 					goto reject;
 				if (unlikely(!connected)) {
 					if (tipc_connect2port(dref, &orig))
 						goto reject;
 				} else if ((msg_origport(msg) != peer_port) ||
 					   (msg_orignode(msg) != peer_node))
 					goto reject;
 				if (unlikely(++p_ptr->publ.conn_unacked >=
 					     TIPC_FLOW_CONTROL_WIN))
 					tipc_acknowledge(dref,
 							 p_ptr->publ.conn_unacked);
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg));
 				break;
 			}
 		case TIPC_DIRECT_MSG:{
 				tipc_msg_event cb = up_ptr->msg_cb;
 				tipc_port_unlock(p_ptr);
 				if (unlikely(!cb || connected))
 					goto reject;
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_importance(msg),
 				   &orig);
 				break;
 			}
 		case TIPC_MCAST_MSG:
 		case TIPC_NAMED_MSG:{
 				tipc_named_msg_event cb = up_ptr->named_msg_cb;
 				tipc_port_unlock(p_ptr);
 				if (unlikely(!cb || connected || !published))
 					goto reject;
 				dseq.type =  msg_nametype(msg);
 				dseq.lower = msg_nameinst(msg);
 				dseq.upper = (message_type == TIPC_NAMED_MSG)
 					? dseq.lower : msg_nameupper(msg);
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_importance(msg),
 				   &orig, &dseq);
 				break;
 			}
 		}
 		if (buf)
 			buf_discard(buf);
 		buf = next;
 		continue;
 err:
 		switch (message_type) {
 		case TIPC_CONN_MSG:{
 				tipc_conn_shutdown_event cb =
 					up_ptr->conn_err_cb;
 				u32 peer_port = port_peerport(p_ptr);
 				u32 peer_node = port_peernode(p_ptr);
 				tipc_port_unlock(p_ptr);
 				if (!cb || !connected)
 					break;
 				if ((msg_origport(msg) != peer_port) ||
 				    (msg_orignode(msg) != peer_node))
 					break;
 				tipc_disconnect(dref);
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_errcode(msg));
 				break;
 			}
 		case TIPC_DIRECT_MSG:{
 				tipc_msg_err_event cb = up_ptr->err_cb;
 				tipc_port_unlock(p_ptr);
 				if (!cb || connected)
 					break;
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_errcode(msg), &orig);
 				break;
 			}
 		case TIPC_MCAST_MSG:
 		case TIPC_NAMED_MSG:{
 				tipc_named_msg_err_event cb =
 					up_ptr->named_err_cb;
 				tipc_port_unlock(p_ptr);
 				if (!cb || connected)
 					break;
 				dseq.type =  msg_nametype(msg);
 				dseq.lower = msg_nameinst(msg);
 				dseq.upper = (message_type == TIPC_NAMED_MSG)
 					? dseq.lower : msg_nameupper(msg);
 				skb_pull(buf, msg_hdr_sz(msg));
 				cb(usr_handle, dref, &buf, msg_data(msg),
 				   msg_data_sz(msg), msg_errcode(msg), &dseq);
 				break;
 			}
 		}
 		if (buf)
 			buf_discard(buf);
 		buf = next;
 		continue;
 reject:
 		tipc_reject_msg(buf, TIPC_ERR_NO_PORT);
 		buf = next;
 	}
 }
 /*
  *  port_dispatcher(): Dispatcher for messages destinated
  *  to the tipc_port interface. Called with port locked.
  */
 static u32 port_dispatcher(struct tipc_port *dummy, struct sk_buff *buf)
 {
 	buf->next = NULL;
 	spin_lock_bh(&queue_lock);
 	if (msg_queue_head) {
 		msg_queue_tail->next = buf;
 		msg_queue_tail = buf;
 	} else {
 		msg_queue_tail = msg_queue_head = buf;
 		tipc_k_signal((Handler)port_dispatcher_sigh, 0);
 	}
 	spin_unlock_bh(&queue_lock);
 	return 0;
 }
 /*
  * Wake up port after congestion: Called with port locked,
  *
  */
 static void port_wakeup_sh(unsigned long ref)
 {
 	struct port *p_ptr;
 	struct user_port *up_ptr;
 	tipc_continue_event cb = NULL;
 	void *uh = NULL;
 	p_ptr = tipc_port_lock(ref);
 	if (p_ptr) {
 		up_ptr = p_ptr->user_port;
 		if (up_ptr) {
 			cb = up_ptr->continue_event_cb;
 			uh = up_ptr->usr_handle;
 		}
 		tipc_port_unlock(p_ptr);
 	}
 	if (cb)
 		cb(uh, ref);
 }
 static void port_wakeup(struct tipc_port *p_ptr)
 {
 	tipc_k_signal((Handler)port_wakeup_sh, p_ptr->ref);
 }
 void tipc_acknowledge(u32 ref, u32 ack)
 {
 	struct port *p_ptr;
 	struct sk_buff *buf = NULL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return;
 	if (p_ptr->publ.connected) {
 		p_ptr->publ.conn_unacked -= ack;
 		buf = port_build_proto_msg(port_peerport(p_ptr),
 					   port_peernode(p_ptr),
 					   ref,
 					   tipc_own_addr,
 					   CONN_MANAGER,
 					   CONN_ACK,
 					   TIPC_OK,
 					   port_out_seqno(p_ptr),
 					   ack);
 	}
 	tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(buf);
 }
 /*
- * tipc_createport(): user level call. Will add port to
+ * tipc_createport(): user level call.
- *                    registry if non-zero user_ref.
  */
-int tipc_createport(u32 user_ref,
+int tipc_createport(void *usr_handle,
-		    void *usr_handle,
 		    unsigned int importance,
 		    tipc_msg_err_event error_cb,
 		    tipc_named_msg_err_event named_error_cb,
 		    tipc_conn_shutdown_event conn_error_cb,
 		    tipc_msg_event msg_cb,
 		    tipc_named_msg_event named_msg_cb,
 		    tipc_conn_msg_event conn_msg_cb,
 		    tipc_continue_event continue_event_cb,/* May be zero */
 		    u32 *portref)
 {
 	struct user_port *up_ptr;
 	struct port *p_ptr;
 	up_ptr = kmalloc(sizeof(*up_ptr), GFP_ATOMIC);
 	if (!up_ptr) {
 		warn("Port creation failed, no memory\n");
 		return -ENOMEM;
 	}
 	p_ptr = (struct port *)tipc_createport_raw(NULL, port_dispatcher,
 						   port_wakeup, importance);
 	if (!p_ptr) {
 		kfree(up_ptr);
 		return -ENOMEM;
 	}
 	p_ptr->user_port = up_ptr;
-	up_ptr->user_ref = user_ref;
 	up_ptr->usr_handle = usr_handle;
 	up_ptr->ref = p_ptr->publ.ref;
 	up_ptr->err_cb = error_cb;
 	up_ptr->named_err_cb = named_error_cb;
 	up_ptr->conn_err_cb = conn_error_cb;
 	up_ptr->msg_cb = msg_cb;
 	up_ptr->named_msg_cb = named_msg_cb;
 	up_ptr->conn_msg_cb = conn_msg_cb;
 	up_ptr->continue_event_cb = continue_event_cb;
-	INIT_LIST_HEAD(&up_ptr->uport_list);
-	tipc_reg_add_port(up_ptr);
 	*portref = p_ptr->publ.ref;
 	tipc_port_unlock(p_ptr);
 	return 0;
 }
 int tipc_portimportance(u32 ref, unsigned int *importance)
 {
 	struct port *p_ptr;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	*importance = (unsigned int)msg_importance(&p_ptr->publ.phdr);
 	tipc_port_unlock(p_ptr);
 	return 0;
 }
 int tipc_set_portimportance(u32 ref, unsigned int imp)
 {
 	struct port *p_ptr;
 	if (imp > TIPC_CRITICAL_IMPORTANCE)
 		return -EINVAL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	msg_set_importance(&p_ptr->publ.phdr, (u32)imp);
 	tipc_port_unlock(p_ptr);
 	return 0;
 }
 int tipc_publish(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
 {
 	struct port *p_ptr;
 	struct publication *publ;
 	u32 key;
 	int res = -EINVAL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	dbg("tipc_publ %u, p_ptr = %x, conn = %x, scope = %x, "
 	    "lower = %u, upper = %u\n",
 	    ref, p_ptr, p_ptr->publ.connected, scope, seq->lower, seq->upper);
 	if (p_ptr->publ.connected)
 		goto exit;
 	if (seq->lower > seq->upper)
 		goto exit;
 	if ((scope < TIPC_ZONE_SCOPE) || (scope > TIPC_NODE_SCOPE))
 		goto exit;
 	key = ref + p_ptr->pub_count + 1;
 	if (key == ref) {
 		res = -EADDRINUSE;
 		goto exit;
 	}
 	publ = tipc_nametbl_publish(seq->type, seq->lower, seq->upper,
 				    scope, p_ptr->publ.ref, key);
 	if (publ) {
 		list_add(&publ->pport_list, &p_ptr->publications);
 		p_ptr->pub_count++;
 		p_ptr->publ.published = 1;
 		res = 0;
 	}
 exit:
 	tipc_port_unlock(p_ptr);
 	return res;
 }
 int tipc_withdraw(u32 ref, unsigned int scope, struct tipc_name_seq const *seq)
 {
 	struct port *p_ptr;
 	struct publication *publ;
 	struct publication *tpubl;
 	int res = -EINVAL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	if (!seq) {
 		list_for_each_entry_safe(publ, tpubl,
 					 &p_ptr->publications, pport_list) {
 			tipc_nametbl_withdraw(publ->type, publ->lower,
 					      publ->ref, publ->key);
 		}
 		res = 0;
 	} else {
 		list_for_each_entry_safe(publ, tpubl,
 					 &p_ptr->publications, pport_list) {
 			if (publ->scope != scope)
 				continue;
 			if (publ->type != seq->type)
 				continue;
 			if (publ->lower != seq->lower)
 				continue;
 			if (publ->upper != seq->upper)
 				break;
 			tipc_nametbl_withdraw(publ->type, publ->lower,
 					      publ->ref, publ->key);
 			res = 0;
 			break;
 		}
 	}
 	if (list_empty(&p_ptr->publications))
 		p_ptr->publ.published = 0;
 	tipc_port_unlock(p_ptr);
 	return res;
 }
 int tipc_connect2port(u32 ref, struct tipc_portid const *peer)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	int res = -EINVAL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	if (p_ptr->publ.published || p_ptr->publ.connected)
 		goto exit;
 	if (!peer->ref)
 		goto exit;
 	msg = &p_ptr->publ.phdr;
 	msg_set_destnode(msg, peer->node);
 	msg_set_destport(msg, peer->ref);
 	msg_set_orignode(msg, tipc_own_addr);
 	msg_set_origport(msg, p_ptr->publ.ref);
 	msg_set_transp_seqno(msg, 42);
 	msg_set_type(msg, TIPC_CONN_MSG);
 	msg_set_hdr_sz(msg, SHORT_H_SIZE);
 	p_ptr->probing_interval = PROBING_INTERVAL;
 	p_ptr->probing_state = CONFIRMED;
 	p_ptr->publ.connected = 1;
 	k_start_timer(&p_ptr->timer, p_ptr->probing_interval);
 	tipc_nodesub_subscribe(&p_ptr->subscription,peer->node,
 			  (void *)(unsigned long)ref,
 			  (net_ev_handler)port_handle_node_down);
 	res = 0;
 exit:
 	tipc_port_unlock(p_ptr);
 	p_ptr->publ.max_pkt = tipc_link_get_max_pkt(peer->node, ref);
 	return res;
 }
 /**
  * tipc_disconnect_port - disconnect port from peer
  *
  * Port must be locked.
  */
 int tipc_disconnect_port(struct tipc_port *tp_ptr)
 {
 	int res;
 	if (tp_ptr->connected) {
 		tp_ptr->connected = 0;
 		/* let timer expire on it's own to avoid deadlock! */
 		tipc_nodesub_unsubscribe(
 			&((struct port *)tp_ptr)->subscription);
 		res = 0;
 	} else {
 		res = -ENOTCONN;
 	}
 	return res;
 }
 /*
  * tipc_disconnect(): Disconnect port form peer.
  *                    This is a node local operation.
  */
 int tipc_disconnect(u32 ref)
 {
 	struct port *p_ptr;
 	int res;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	res = tipc_disconnect_port((struct tipc_port *)p_ptr);
 	tipc_port_unlock(p_ptr);
 	return res;
 }
 /*
  * tipc_shutdown(): Send a SHUTDOWN msg to peer and disconnect
  */
 int tipc_shutdown(u32 ref)
 {
 	struct port *p_ptr;
 	struct sk_buff *buf = NULL;
 	p_ptr = tipc_port_lock(ref);
 	if (!p_ptr)
 		return -EINVAL;
 	if (p_ptr->publ.connected) {
 		u32 imp = msg_importance(&p_ptr->publ.phdr);
 		if (imp < TIPC_CRITICAL_IMPORTANCE)
 			imp++;
 		buf = port_build_proto_msg(port_peerport(p_ptr),
 					   port_peernode(p_ptr),
 					   ref,
 					   tipc_own_addr,
 					   imp,
 					   TIPC_CONN_MSG,
 					   TIPC_CONN_SHUTDOWN,
 					   port_out_seqno(p_ptr),
 					   0);
 	}
 	tipc_port_unlock(p_ptr);
 	tipc_net_route_msg(buf);
 	return tipc_disconnect(ref);
 }
 /*
  *  tipc_port_recv_sections(): Concatenate and deliver sectioned
  *                        message for this node.
  */
 static int tipc_port_recv_sections(struct port *sender, unsigned int num_sect,
 				   struct iovec const *msg_sect)
 {
 	struct sk_buff *buf;
 	int res;
 	res = tipc_msg_build(&sender->publ.phdr, msg_sect, num_sect,
 			MAX_MSG_SIZE, !sender->user_port, &buf);
 	if (likely(buf))
 		tipc_port_recv_msg(buf);
 	return res;
 }
 /**
  * tipc_send - send message sections on connection
  */
 int tipc_send(u32 ref, unsigned int num_sect, struct iovec const *msg_sect)
 {
 	struct port *p_ptr;
 	u32 destnode;
 	int res;
 	p_ptr = tipc_port_deref(ref);
 	if (!p_ptr || !p_ptr->publ.connected)
 		return -EINVAL;
 	p_ptr->publ.congested = 1;
 	if (!tipc_port_congested(p_ptr)) {
 		destnode = port_peernode(p_ptr);
 		if (likely(destnode != tipc_own_addr))
 			res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect,
 							   destnode);
 		else
 			res = tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
 		if (likely(res != -ELINKCONG)) {
 			port_incr_out_seqno(p_ptr);
 			p_ptr->publ.congested = 0;
 			p_ptr->sent++;
 			return res;
 		}
 	}
 	if (port_unreliable(p_ptr)) {
 		p_ptr->publ.congested = 0;
 		/* Just calculate msg length and return */
 		return tipc_msg_calc_data_size(msg_sect, num_sect);
 	}
 	return -ELINKCONG;
 }
 /**
  * tipc_send2name - send message sections to port name
  */
 int tipc_send2name(u32 ref, struct tipc_name const *name, unsigned int domain,
 	   unsigned int num_sect, struct iovec const *msg_sect)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	u32 destnode = domain;
 	u32 destport;
 	int res;
 	p_ptr = tipc_port_deref(ref);
 	if (!p_ptr || p_ptr->publ.connected)
 		return -EINVAL;
 	msg = &p_ptr->publ.phdr;
 	msg_set_type(msg, TIPC_NAMED_MSG);
 	msg_set_orignode(msg, tipc_own_addr);
 	msg_set_origport(msg, ref);
 	msg_set_hdr_sz(msg, LONG_H_SIZE);
 	msg_set_nametype(msg, name->type);
 	msg_set_nameinst(msg, name->instance);
 	msg_set_lookup_scope(msg, tipc_addr_scope(domain));
 	destport = tipc_nametbl_translate(name->type, name->instance, &destnode);
 	msg_set_destnode(msg, destnode);
 	msg_set_destport(msg, destport);
 	if (likely(destport)) {
 		p_ptr->sent++;
 		if (likely(destnode == tipc_own_addr))
 			return tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
 		res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect,
 						   destnode);
 		if (likely(res != -ELINKCONG))
 			return res;
 		if (port_unreliable(p_ptr)) {
 			/* Just calculate msg length and return */
 			return tipc_msg_calc_data_size(msg_sect, num_sect);
 		}
 		return -ELINKCONG;
 	}
 	return tipc_port_reject_sections(p_ptr, msg, msg_sect, num_sect,
 					 TIPC_ERR_NO_NAME);
 }
 /**
  * tipc_send2port - send message sections to port identity
  */
 int tipc_send2port(u32 ref, struct tipc_portid const *dest,
 	   unsigned int num_sect, struct iovec const *msg_sect)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	int res;
 	p_ptr = tipc_port_deref(ref);
 	if (!p_ptr || p_ptr->publ.connected)
 		return -EINVAL;
 	msg = &p_ptr->publ.phdr;
 	msg_set_type(msg, TIPC_DIRECT_MSG);
 	msg_set_orignode(msg, tipc_own_addr);
 	msg_set_origport(msg, ref);
 	msg_set_destnode(msg, dest->node);
 	msg_set_destport(msg, dest->ref);
 	msg_set_hdr_sz(msg, DIR_MSG_H_SIZE);
 	p_ptr->sent++;
 	if (dest->node == tipc_own_addr)
 		return tipc_port_recv_sections(p_ptr, num_sect, msg_sect);
 	res = tipc_link_send_sections_fast(p_ptr, msg_sect, num_sect, dest->node);
 	if (likely(res != -ELINKCONG))
 		return res;
 	if (port_unreliable(p_ptr)) {
 		/* Just calculate msg length and return */
 		return tipc_msg_calc_data_size(msg_sect, num_sect);
 	}
 	return -ELINKCONG;
 }
 /**
  * tipc_send_buf2port - send message buffer to port identity
  */
 int tipc_send_buf2port(u32 ref, struct tipc_portid const *dest,
 	       struct sk_buff *buf, unsigned int dsz)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg;
 	int res;
 	p_ptr = (struct port *)tipc_ref_deref(ref);
 	if (!p_ptr || p_ptr->publ.connected)
 		return -EINVAL;
 	msg = &p_ptr->publ.phdr;
 	msg_set_type(msg, TIPC_DIRECT_MSG);
 	msg_set_orignode(msg, tipc_own_addr);
 	msg_set_origport(msg, ref);
 	msg_set_destnode(msg, dest->node);
 	msg_set_destport(msg, dest->ref);
 	msg_set_hdr_sz(msg, DIR_MSG_H_SIZE);
 	msg_set_size(msg, DIR_MSG_H_SIZE + dsz);
 	if (skb_cow(buf, DIR_MSG_H_SIZE))
 		return -ENOMEM;
 	skb_push(buf, DIR_MSG_H_SIZE);
 	skb_copy_to_linear_data(buf, msg, DIR_MSG_H_SIZE);
 	msg_dbg(msg, "buf2port: ");
 	p_ptr->sent++;
 	if (dest->node == tipc_own_addr)
 		return tipc_port_recv_msg(buf);
 	res = tipc_send_buf_fast(buf, dest->node);
 	if (likely(res != -ELINKCONG))
 		return res;
 	if (port_unreliable(p_ptr))
 		return dsz;
 	return -ELINKCONG;
 }

net/tipc/port.h

Diff comments View file @ b0c1e92

 /*
  * net/tipc/port.h: Include file for TIPC port code
  *
  * Copyright (c) 1994-2007, Ericsson AB
  * Copyright (c) 2004-2007, 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.
  */
 #ifndef _TIPC_PORT_H
 #define _TIPC_PORT_H
 #include "ref.h"
 #include "net.h"
 #include "msg.h"
 #include "node_subscr.h"
 #define TIPC_FLOW_CONTROL_WIN 512
 typedef void (*tipc_msg_err_event) (void *usr_handle, u32 portref,
 		struct sk_buff **buf, unsigned char const *data,
 		unsigned int size, int reason,
 		struct tipc_portid const *attmpt_destid);
 typedef void (*tipc_named_msg_err_event) (void *usr_handle, u32 portref,
 		struct sk_buff **buf, unsigned char const *data,
 		unsigned int size, int reason,
 		struct tipc_name_seq const *attmpt_dest);
 typedef void (*tipc_conn_shutdown_event) (void *usr_handle, u32 portref,
 		struct sk_buff **buf, unsigned char const *data,
 		unsigned int size, int reason);
 typedef void (*tipc_msg_event) (void *usr_handle, u32 portref,
 		struct sk_buff **buf, unsigned char const *data,
 		unsigned int size, unsigned int importance,
 		struct tipc_portid const *origin);
 typedef void (*tipc_named_msg_event) (void *usr_handle, u32 portref,
 		struct sk_buff **buf, unsigned char const *data,
 		unsigned int size, unsigned int importance,
 		struct tipc_portid const *orig,
 		struct tipc_name_seq const *dest);
 typedef void (*tipc_conn_msg_event) (void *usr_handle, u32 portref,
 		struct sk_buff **buf, unsigned char const *data,
 		unsigned int size);
 typedef void (*tipc_continue_event) (void *usr_handle, u32 portref);
 /**
  * struct user_port - TIPC user port (used with native API)
- * @user_ref: id of user who created user port
  * @usr_handle: user-specified field
  * @ref: object reference to associated TIPC port
  * <various callback routines>
- * @uport_list: adjacent user ports in list of ports held by user
  */
 struct user_port {
-	u32 user_ref;
 	void *usr_handle;
 	u32 ref;
 	tipc_msg_err_event err_cb;
 	tipc_named_msg_err_event named_err_cb;
 	tipc_conn_shutdown_event conn_err_cb;
 	tipc_msg_event msg_cb;
 	tipc_named_msg_event named_msg_cb;
 	tipc_conn_msg_event conn_msg_cb;
 	tipc_continue_event continue_event_cb;
-	struct list_head uport_list;
 };
 /**
  * struct tipc_port - TIPC port info available to socket API
  * @usr_handle: pointer to additional user-defined information about port
  * @lock: pointer to spinlock for controlling access to port
  * @connected: non-zero if port is currently connected to a peer port
  * @conn_type: TIPC type used when connection was established
  * @conn_instance: TIPC instance used when connection was established
  * @conn_unacked: number of unacknowledged messages received from peer port
  * @published: non-zero if port has one or more associated names
  * @congested: non-zero if cannot send because of link or port congestion
  * @max_pkt: maximum packet size "hint" used when building messages sent by port
  * @ref: unique reference to port in TIPC object registry
  * @phdr: preformatted message header used when sending messages
  */
 struct tipc_port {
 	void *usr_handle;
 	spinlock_t *lock;
 	int connected;
 	u32 conn_type;
 	u32 conn_instance;
 	u32 conn_unacked;
 	int published;
 	u32 congested;
 	u32 max_pkt;
 	u32 ref;
 	struct tipc_msg phdr;
 };
 /**
  * struct port - TIPC port structure
  * @publ: TIPC port info available to privileged users
  * @port_list: adjacent ports in TIPC's global list of ports
  * @dispatcher: ptr to routine which handles received messages
  * @wakeup: ptr to routine to call when port is no longer congested
  * @user_port: ptr to user port associated with port (if any)
  * @wait_list: adjacent ports in list of ports waiting on link congestion
  * @waiting_pkts:
  * @sent:
  * @acked:
  * @publications: list of publications for port
  * @pub_count: total # of publications port has made during its lifetime
  * @probing_state:
  * @probing_interval:
  * @last_in_seqno:
  * @timer_ref:
  * @subscription: "node down" subscription used to terminate failed connections
  */
 struct port {
 	struct tipc_port publ;
 	struct list_head port_list;
 	u32 (*dispatcher)(struct tipc_port *, struct sk_buff *);
 	void (*wakeup)(struct tipc_port *);
 	struct user_port *user_port;
 	struct list_head wait_list;
 	u32 waiting_pkts;
 	u32 sent;
 	u32 acked;
 	struct list_head publications;
 	u32 pub_count;
 	u32 probing_state;
 	u32 probing_interval;
 	u32 last_in_seqno;
 	struct timer_list timer;
 	struct tipc_node_subscr subscription;
 };
 extern spinlock_t tipc_port_list_lock;
 struct port_list;
 /*
  * TIPC port manipulation routines
  */
 struct tipc_port *tipc_createport_raw(void *usr_handle,
 		u32 (*dispatcher)(struct tipc_port *, struct sk_buff *),
 		void (*wakeup)(struct tipc_port *), const u32 importance);
 int tipc_reject_msg(struct sk_buff *buf, u32 err);
 int tipc_send_buf_fast(struct sk_buff *buf, u32 destnode);
 void tipc_acknowledge(u32 port_ref, u32 ack);
-int tipc_createport(unsigned int tipc_user, void *usr_handle,
+int tipc_createport(void *usr_handle,
 		unsigned int importance, tipc_msg_err_event error_cb,
 		tipc_named_msg_err_event named_error_cb,
 		tipc_conn_shutdown_event conn_error_cb, tipc_msg_event msg_cb,
 		tipc_named_msg_event named_msg_cb,
 		tipc_conn_msg_event conn_msg_cb,
 		tipc_continue_event continue_event_cb, u32 *portref);
 int tipc_deleteport(u32 portref);
 int tipc_portimportance(u32 portref, unsigned int *importance);
 int tipc_set_portimportance(u32 portref, unsigned int importance);
 int tipc_portunreliable(u32 portref, unsigned int *isunreliable);
 int tipc_set_portunreliable(u32 portref, unsigned int isunreliable);
 int tipc_portunreturnable(u32 portref, unsigned int *isunreturnable);
 int tipc_set_portunreturnable(u32 portref, unsigned int isunreturnable);
 int tipc_publish(u32 portref, unsigned int scope,
 		struct tipc_name_seq const *name_seq);
 int tipc_withdraw(u32 portref, unsigned int scope,
 		struct tipc_name_seq const *name_seq);
 int tipc_connect2port(u32 portref, struct tipc_portid const *port);
 int tipc_disconnect(u32 portref);
 int tipc_shutdown(u32 ref);
 /*
  * The following routines require that the port be locked on entry
  */
 int tipc_disconnect_port(struct tipc_port *tp_ptr);
 /*
  * TIPC messaging routines
  */
 int tipc_send(u32 portref, unsigned int num_sect, struct iovec const *msg_sect);
 int tipc_send2name(u32 portref, struct tipc_name const *name, u32 domain,
 		unsigned int num_sect, struct iovec const *msg_sect);
 int tipc_send2port(u32 portref, struct tipc_portid const *dest,
 		unsigned int num_sect, struct iovec const *msg_sect);
 int tipc_send_buf2port(u32 portref, struct tipc_portid const *dest,
 		struct sk_buff *buf, unsigned int dsz);
 int tipc_multicast(u32 portref, struct tipc_name_seq const *seq,
 		unsigned int section_count, struct iovec const *msg);
 int tipc_port_reject_sections(struct port *p_ptr, struct tipc_msg *hdr,
 			      struct iovec const *msg_sect, u32 num_sect,
 			      int err);
 struct sk_buff *tipc_port_get_ports(void);
 void tipc_port_recv_proto_msg(struct sk_buff *buf);
 void tipc_port_recv_mcast(struct sk_buff *buf, struct port_list *dp);
 void tipc_port_reinit(void);
 /**
  * tipc_port_lock - lock port instance referred to and return its pointer
  */
 static inline struct port *tipc_port_lock(u32 ref)
 {
 	return (struct port *)tipc_ref_lock(ref);
 }
 /**
  * tipc_port_unlock - unlock a port instance
  *
  * Can use pointer instead of tipc_ref_unlock() since port is already locked.
  */
 static inline void tipc_port_unlock(struct port *p_ptr)
 {
 	spin_unlock_bh(p_ptr->publ.lock);
 }
 static inline struct port* tipc_port_deref(u32 ref)
 {
 	return (struct port *)tipc_ref_deref(ref);
 }
 static inline u32 tipc_peer_port(struct port *p_ptr)
 {
 	return msg_destport(&p_ptr->publ.phdr);
 }
 static inline u32 tipc_peer_node(struct port *p_ptr)
 {
 	return msg_destnode(&p_ptr->publ.phdr);
 }
 static inline int tipc_port_congested(struct port *p_ptr)
 {
 	return (p_ptr->sent - p_ptr->acked) >= (TIPC_FLOW_CONTROL_WIN * 2);
 }
 /**
  * tipc_port_recv_msg - receive message from lower layer and deliver to port user
  */
 static inline int tipc_port_recv_msg(struct sk_buff *buf)
 {
 	struct port *p_ptr;
 	struct tipc_msg *msg = buf_msg(buf);
 	u32 destport = msg_destport(msg);
 	u32 dsz = msg_data_sz(msg);
 	u32 err;
 	/* forward unresolved named message */
 	if (unlikely(!destport)) {
 		tipc_net_route_msg(buf);
 		return dsz;
 	}
 	/* validate destination & pass to port, otherwise reject message */
 	p_ptr = tipc_port_lock(destport);
 	if (likely(p_ptr)) {
 		if (likely(p_ptr->publ.connected)) {
 			if ((unlikely(msg_origport(msg) != tipc_peer_port(p_ptr))) ||
 			    (unlikely(msg_orignode(msg) != tipc_peer_node(p_ptr))) ||
 			    (unlikely(!msg_connected(msg)))) {
 				err = TIPC_ERR_NO_PORT;
 				tipc_port_unlock(p_ptr);
 				goto reject;
 			}
 		}
 		err = p_ptr->dispatcher(&p_ptr->publ, buf);
 		tipc_port_unlock(p_ptr);
 		if (likely(!err))
 			return dsz;
 	} else {
 		err = TIPC_ERR_NO_PORT;
 	}
 reject:
 	dbg("port->rejecting, err = %x..\n",err);
 	return tipc_reject_msg(buf, err);
 }
 #endif

net/tipc/subscr.c

Diff comments View file @ b0c1e92

 /*
  * net/tipc/subscr.c: TIPC network topology service
  *
  * Copyright (c) 2000-2006, Ericsson AB
  * Copyright (c) 2005-2007, 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 "name_table.h"
 #include "port.h"
 #include "subscr.h"
 /**
  * struct subscriber - TIPC network topology subscriber
  * @port_ref: object reference to server port connecting to subscriber
  * @lock: pointer to spinlock controlling access to subscriber's server port
  * @subscriber_list: adjacent subscribers in top. server's list of subscribers
  * @subscription_list: list of subscription objects for this subscriber
  */
 struct subscriber {
 	u32 port_ref;
 	spinlock_t *lock;
 	struct list_head subscriber_list;
 	struct list_head subscription_list;
 };
 /**
  * struct top_srv - TIPC network topology subscription service
  * @user_ref: TIPC userid of subscription service
  * @setup_port: reference to TIPC port that handles subscription requests
  * @subscription_count: number of active subscriptions (not subscribers!)
  * @subscriber_list: list of ports subscribing to service
  * @lock: spinlock govering access to subscriber list
  */
 struct top_srv {
 	u32 setup_port;
 	atomic_t subscription_count;
 	struct list_head subscriber_list;
 	spinlock_t lock;
 };
 static struct top_srv topsrv = { 0 };
 /**
  * htohl - convert value to endianness used by destination
  * @in: value to convert
  * @swap: non-zero if endianness must be reversed
  *
  * Returns converted value
  */
 static u32 htohl(u32 in, int swap)
 {
 	return swap ? swab32(in) : in;
 }
 /**
  * subscr_send_event - send a message containing a tipc_event to the subscriber
  *
  * Note: Must not hold subscriber's server port lock, since tipc_send() will
  *       try to take the lock if the message is rejected and returned!
  */
 static void subscr_send_event(struct subscription *sub,
 			      u32 found_lower,
 			      u32 found_upper,
 			      u32 event,
 			      u32 port_ref,
 			      u32 node)
 {
 	struct iovec msg_sect;
 	msg_sect.iov_base = (void *)&sub->evt;
 	msg_sect.iov_len = sizeof(struct tipc_event);
 	sub->evt.event = htohl(event, sub->swap);
 	sub->evt.found_lower = htohl(found_lower, sub->swap);
 	sub->evt.found_upper = htohl(found_upper, sub->swap);
 	sub->evt.port.ref = htohl(port_ref, sub->swap);
 	sub->evt.port.node = htohl(node, sub->swap);
 	tipc_send(sub->server_ref, 1, &msg_sect);
 }
 /**
  * tipc_subscr_overlap - test for subscription overlap with the given values
  *
  * Returns 1 if there is overlap, otherwise 0.
  */
 int tipc_subscr_overlap(struct subscription *sub,
 			u32 found_lower,
 			u32 found_upper)
 {
 	if (found_lower < sub->seq.lower)
 		found_lower = sub->seq.lower;
 	if (found_upper > sub->seq.upper)
 		found_upper = sub->seq.upper;
 	if (found_lower > found_upper)
 		return 0;
 	return 1;
 }
 /**
  * tipc_subscr_report_overlap - issue event if there is subscription overlap
  *
  * Protected by nameseq.lock in name_table.c
  */
 void tipc_subscr_report_overlap(struct subscription *sub,
 				u32 found_lower,
 				u32 found_upper,
 				u32 event,
 				u32 port_ref,
 				u32 node,
 				int must)
 {
 	if (!tipc_subscr_overlap(sub, found_lower, found_upper))
 		return;
 	if (!must && !(sub->filter & TIPC_SUB_PORTS))
 		return;
 	sub->event_cb(sub, found_lower, found_upper, event, port_ref, node);
 }
 /**
  * subscr_timeout - subscription timeout has occurred
  */
 static void subscr_timeout(struct subscription *sub)
 {
 	struct port *server_port;
 	/* Validate server port reference (in case subscriber is terminating) */
 	server_port = tipc_port_lock(sub->server_ref);
 	if (server_port == NULL)
 		return;
 	/* Validate timeout (in case subscription is being cancelled) */
 	if (sub->timeout == TIPC_WAIT_FOREVER) {
 		tipc_port_unlock(server_port);
 		return;
 	}
 	/* Unlink subscription from name table */
 	tipc_nametbl_unsubscribe(sub);
 	/* Unlink subscription from subscriber */
 	list_del(&sub->subscription_list);
 	/* Release subscriber's server port */
 	tipc_port_unlock(server_port);
 	/* Notify subscriber of timeout */
 	subscr_send_event(sub, sub->evt.s.seq.lower, sub->evt.s.seq.upper,
 			  TIPC_SUBSCR_TIMEOUT, 0, 0);
 	/* Now destroy subscription */
 	k_term_timer(&sub->timer);
 	kfree(sub);
 	atomic_dec(&topsrv.subscription_count);
 }
 /**
  * subscr_del - delete a subscription within a subscription list
  *
  * Called with subscriber port locked.
  */
 static void subscr_del(struct subscription *sub)
 {
 	tipc_nametbl_unsubscribe(sub);
 	list_del(&sub->subscription_list);
 	kfree(sub);
 	atomic_dec(&topsrv.subscription_count);
 }
 /**
  * subscr_terminate - terminate communication with a subscriber
  *
  * Called with subscriber port locked.  Routine must temporarily release lock
  * to enable subscription timeout routine(s) to finish without deadlocking;
  * the lock is then reclaimed to allow caller to release it upon return.
  * (This should work even in the unlikely event some other thread creates
  * a new object reference in the interim that uses this lock; this routine will
  * simply wait for it to be released, then claim it.)
  */
 static void subscr_terminate(struct subscriber *subscriber)
 {
 	u32 port_ref;
 	struct subscription *sub;
 	struct subscription *sub_temp;
 	/* Invalidate subscriber reference */
 	port_ref = subscriber->port_ref;
 	subscriber->port_ref = 0;
 	spin_unlock_bh(subscriber->lock);
 	/* Sever connection to subscriber */
 	tipc_shutdown(port_ref);
 	tipc_deleteport(port_ref);
 	/* Destroy any existing subscriptions for subscriber */
 	list_for_each_entry_safe(sub, sub_temp, &subscriber->subscription_list,
 				 subscription_list) {
 		if (sub->timeout != TIPC_WAIT_FOREVER) {
 			k_cancel_timer(&sub->timer);
 			k_term_timer(&sub->timer);
 		}
 		dbg("Term: Removing sub %u,%u,%u from subscriber %x list\n",
 		    sub->seq.type, sub->seq.lower, sub->seq.upper, subscriber);
 		subscr_del(sub);
 	}
 	/* Remove subscriber from topology server's subscriber list */
 	spin_lock_bh(&topsrv.lock);
 	list_del(&subscriber->subscriber_list);
 	spin_unlock_bh(&topsrv.lock);
 	/* Reclaim subscriber lock */
 	spin_lock_bh(subscriber->lock);
 	/* Now destroy subscriber */
 	kfree(subscriber);
 }
 /**
  * subscr_cancel - handle subscription cancellation request
  *
  * Called with subscriber port locked.  Routine must temporarily release lock
  * to enable the subscription timeout routine to finish without deadlocking;
  * the lock is then reclaimed to allow caller to release it upon return.
  *
  * Note that fields of 's' use subscriber's endianness!
  */
 static void subscr_cancel(struct tipc_subscr *s,
 			  struct subscriber *subscriber)
 {
 	struct subscription *sub;
 	struct subscription *sub_temp;
 	int found = 0;
 	/* Find first matching subscription, exit if not found */
 	list_for_each_entry_safe(sub, sub_temp, &subscriber->subscription_list,
 				 subscription_list) {
 		if (!memcmp(s, &sub->evt.s, sizeof(struct tipc_subscr))) {
 			found = 1;
 			break;
 		}
 	}
 	if (!found)
 		return;
 	/* Cancel subscription timer (if used), then delete subscription */
 	if (sub->timeout != TIPC_WAIT_FOREVER) {
 		sub->timeout = TIPC_WAIT_FOREVER;
 		spin_unlock_bh(subscriber->lock);
 		k_cancel_timer(&sub->timer);
 		k_term_timer(&sub->timer);
 		spin_lock_bh(subscriber->lock);
 	}
 	dbg("Cancel: removing sub %u,%u,%u from subscriber %x list\n",
 	    sub->seq.type, sub->seq.lower, sub->seq.upper, subscriber);
 	subscr_del(sub);
 }
 /**
  * subscr_subscribe - create subscription for subscriber
  *
  * Called with subscriber port locked.
  */
 static struct subscription *subscr_subscribe(struct tipc_subscr *s,
 					     struct subscriber *subscriber)
 {
 	struct subscription *sub;
 	int swap;
 	/* Determine subscriber's endianness */
 	swap = !(s->filter & (TIPC_SUB_PORTS | TIPC_SUB_SERVICE));
 	/* Detect & process a subscription cancellation request */
 	if (s->filter & htohl(TIPC_SUB_CANCEL, swap)) {
 		s->filter &= ~htohl(TIPC_SUB_CANCEL, swap);
 		subscr_cancel(s, subscriber);
 		return NULL;
 	}
 	/* Refuse subscription if global limit exceeded */
 	if (atomic_read(&topsrv.subscription_count) >= tipc_max_subscriptions) {
 		warn("Subscription rejected, subscription limit reached (%u)\n",
 		     tipc_max_subscriptions);
 		subscr_terminate(subscriber);
 		return NULL;
 	}
 	/* Allocate subscription object */
 	sub = kmalloc(sizeof(*sub), GFP_ATOMIC);
 	if (!sub) {
 		warn("Subscription rejected, no memory\n");
 		subscr_terminate(subscriber);
 		return NULL;
 	}
 	/* Initialize subscription object */
 	sub->seq.type = htohl(s->seq.type, swap);
 	sub->seq.lower = htohl(s->seq.lower, swap);
 	sub->seq.upper = htohl(s->seq.upper, swap);
 	sub->timeout = htohl(s->timeout, swap);
 	sub->filter = htohl(s->filter, swap);
 	if ((!(sub->filter & TIPC_SUB_PORTS) ==
 	     !(sub->filter & TIPC_SUB_SERVICE)) ||
 	    (sub->seq.lower > sub->seq.upper)) {
 		warn("Subscription rejected, illegal request\n");
 		kfree(sub);
 		subscr_terminate(subscriber);
 		return NULL;
 	}
 	sub->event_cb = subscr_send_event;
 	INIT_LIST_HEAD(&sub->nameseq_list);
 	list_add(&sub->subscription_list, &subscriber->subscription_list);
 	sub->server_ref = subscriber->port_ref;
 	sub->swap = swap;
 	memcpy(&sub->evt.s, s, sizeof(struct tipc_subscr));
 	atomic_inc(&topsrv.subscription_count);
 	if (sub->timeout != TIPC_WAIT_FOREVER) {
 		k_init_timer(&sub->timer,
 			     (Handler)subscr_timeout, (unsigned long)sub);
 		k_start_timer(&sub->timer, sub->timeout);
 	}
 	return sub;
 }
 /**
  * subscr_conn_shutdown_event - handle termination request from subscriber
  *
  * Called with subscriber's server port unlocked.
  */
 static void subscr_conn_shutdown_event(void *usr_handle,
 				       u32 port_ref,
 				       struct sk_buff **buf,
 				       unsigned char const *data,
 				       unsigned int size,
 				       int reason)
 {
 	struct subscriber *subscriber = usr_handle;
 	spinlock_t *subscriber_lock;
 	if (tipc_port_lock(port_ref) == NULL)
 		return;
 	subscriber_lock = subscriber->lock;
 	subscr_terminate(subscriber);
 	spin_unlock_bh(subscriber_lock);
 }
 /**
  * subscr_conn_msg_event - handle new subscription request from subscriber
  *
  * Called with subscriber's server port unlocked.
  */
 static void subscr_conn_msg_event(void *usr_handle,
 				  u32 port_ref,
 				  struct sk_buff **buf,
 				  const unchar *data,
 				  u32 size)
 {
 	struct subscriber *subscriber = usr_handle;
 	spinlock_t *subscriber_lock;
 	struct subscription *sub;
 	/*
 	 * Lock subscriber's server port (& make a local copy of lock pointer,
 	 * in case subscriber is deleted while processing subscription request)
 	 */
 	if (tipc_port_lock(port_ref) == NULL)
 		return;
 	subscriber_lock = subscriber->lock;
 	if (size != sizeof(struct tipc_subscr)) {
 		subscr_terminate(subscriber);
 		spin_unlock_bh(subscriber_lock);
 	} else {
 		sub = subscr_subscribe((struct tipc_subscr *)data, subscriber);
 		spin_unlock_bh(subscriber_lock);
 		if (sub != NULL) {
 			/*
 			 * We must release the server port lock before adding a
 			 * subscription to the name table since TIPC needs to be
 			 * able to (re)acquire the port lock if an event message
 			 * issued by the subscription process is rejected and
 			 * returned.  The subscription cannot be deleted while
 			 * it is being added to the name table because:
 			 * a) the single-threading of the native API port code
 			 *    ensures the subscription cannot be cancelled and
 			 *    the subscriber connection cannot be broken, and
 			 * b) the name table lock ensures the subscription
 			 *    timeout code cannot delete the subscription,
 			 * so the subscription object is still protected.
 			 */
 			tipc_nametbl_subscribe(sub);
 		}
 	}
 }
 /**
  * subscr_named_msg_event - handle request to establish a new subscriber
  */
 static void subscr_named_msg_event(void *usr_handle,
 				   u32 port_ref,
 				   struct sk_buff **buf,
 				   const unchar *data,
 				   u32 size,
 				   u32 importance,
 				   struct tipc_portid const *orig,
 				   struct tipc_name_seq const *dest)
 {
 	static struct iovec msg_sect = {NULL, 0};
 	struct subscriber *subscriber;
 	u32 server_port_ref;
 	/* Create subscriber object */
 	subscriber = kzalloc(sizeof(struct subscriber), GFP_ATOMIC);
 	if (subscriber == NULL) {
 		warn("Subscriber rejected, no memory\n");
 		return;
 	}
 	INIT_LIST_HEAD(&subscriber->subscription_list);
 	INIT_LIST_HEAD(&subscriber->subscriber_list);
 	/* Create server port & establish connection to subscriber */
-	tipc_createport(0,
+	tipc_createport(subscriber,
-			subscriber,
 			importance,
 			NULL,
 			NULL,
 			subscr_conn_shutdown_event,
 			NULL,
 			NULL,
 			subscr_conn_msg_event,
 			NULL,
 			&subscriber->port_ref);
 	if (subscriber->port_ref == 0) {
 		warn("Subscriber rejected, unable to create port\n");
 		kfree(subscriber);
 		return;
 	}
 	tipc_connect2port(subscriber->port_ref, orig);
 	/* Lock server port (& save lock address for future use) */
 	subscriber->lock = tipc_port_lock(subscriber->port_ref)->publ.lock;
 	/* Add subscriber to topology server's subscriber list */
 	spin_lock_bh(&topsrv.lock);
 	list_add(&subscriber->subscriber_list, &topsrv.subscriber_list);
 	spin_unlock_bh(&topsrv.lock);
 	/* Unlock server port */
 	server_port_ref = subscriber->port_ref;
 	spin_unlock_bh(subscriber->lock);
 	/* Send an ACK- to complete connection handshaking */
 	tipc_send(server_port_ref, 1, &msg_sect);
 	/* Handle optional subscription request */
 	if (size != 0) {
 		subscr_conn_msg_event(subscriber, server_port_ref,
 				      buf, data, size);
 	}
 }
 int tipc_subscr_start(void)
 {
 	struct tipc_name_seq seq = {TIPC_TOP_SRV, TIPC_TOP_SRV, TIPC_TOP_SRV};
 	int res;
 	memset(&topsrv, 0, sizeof (topsrv));
 	spin_lock_init(&topsrv.lock);
 	INIT_LIST_HEAD(&topsrv.subscriber_list);
 	spin_lock_bh(&topsrv.lock);
-	res = tipc_createport(0,
+	res = tipc_createport(NULL,
-			      NULL,
 			      TIPC_CRITICAL_IMPORTANCE,
 			      NULL,
 			      NULL,
 			      NULL,
 			      NULL,
 			      subscr_named_msg_event,
 			      NULL,
 			      NULL,
 			      &topsrv.setup_port);
 	if (res)
 		goto failed;
 	res = tipc_nametbl_publish_rsv(topsrv.setup_port, TIPC_NODE_SCOPE, &seq);
 	if (res) {
 		tipc_deleteport(topsrv.setup_port);
 		topsrv.setup_port = 0;
 		goto failed;
 	}
 	spin_unlock_bh(&topsrv.lock);
 	return 0;
 failed:
 	err("Failed to create subscription service\n");
 	spin_unlock_bh(&topsrv.lock);
 	return res;
 }
 void tipc_subscr_stop(void)
 {
 	struct subscriber *subscriber;
 	struct subscriber *subscriber_temp;
 	spinlock_t *subscriber_lock;
 	if (topsrv.setup_port) {
 		tipc_deleteport(topsrv.setup_port);
 		topsrv.setup_port = 0;
 		list_for_each_entry_safe(subscriber, subscriber_temp,
 					 &topsrv.subscriber_list,
 					 subscriber_list) {
 			subscriber_lock = subscriber->lock;
 			spin_lock_bh(subscriber_lock);
 			subscr_terminate(subscriber);
 			spin_unlock_bh(subscriber_lock);
 		}
 	}
 }

net/tipc/user_reg.c

View file @ b0c1e92

1	/*		File was deleted
2	* net/tipc/user_reg.c: TIPC user registry code
3	*
4	* Copyright (c) 2000-2006, Ericsson AB
5	* Copyright (c) 2004-2005, Wind River Systems
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:
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.
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	*
43	* The registry utilizes an array of "TIPC user" entries;
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	* @ports: list of user ports owned by the user
54	*/
55
56	struct tipc_user {
57	int next;
58	struct list_head ports;
59	};
60
61	#define MAX_USERID 64
62	#define USER_LIST_SIZE ((MAX_USERID + 1) * sizeof(struct tipc_user))
63
64	static struct tipc_user *users = NULL;
65	static u32 next_free_user = MAX_USERID + 1;
66	static DEFINE_SPINLOCK(reg_lock);
67
68	/**
69	* reg_init - create TIPC user registry (but don't activate it)
70	*
71	* If registry has been pre-initialized it is left "as is".
72	* NOTE: This routine may be called when TIPC is inactive.
73	*/
74
75	static int reg_init(void)
76	{
77	u32 i;
78
79	spin_lock_bh(&reg_lock);
80	if (!users) {
81	users = kzalloc(USER_LIST_SIZE, GFP_ATOMIC);
82	if (users) {
83	for (i = 1; i <= MAX_USERID; i++) {
84	users[i].next = i - 1;
85	}
86	next_free_user = MAX_USERID;
87	}
88	}
89	spin_unlock_bh(&reg_lock);
90	return users ? 0 : -ENOMEM;
91	}
92
93	/**
94	* tipc_reg_start - activate TIPC user registry
95	*/
96
97	int tipc_reg_start(void)
98	{
99	return reg_init();
100	}
101
102	/**
103	* tipc_reg_stop - shut down & delete TIPC user registry
104	*/
105
106	void tipc_reg_stop(void)
107	{
108	if (!users)
109	return;
110
111	kfree(users);
112	users = NULL;
113	}
114
115	/**
116	* tipc_attach - register a TIPC user
117	*
118	* NOTE: This routine may be called when TIPC is inactive.
119	*/
120
121	int tipc_attach(u32 *userid)
122	{
123	struct tipc_user *user_ptr;
124
125	if (!users)
126	reg_init();
127
128	spin_lock_bh(&reg_lock);
129	if (!next_free_user) {
130	spin_unlock_bh(&reg_lock);
131	return -EBUSY;
132	}
133	user_ptr = &users[next_free_user];
134	*userid = next_free_user;
135	next_free_user = user_ptr->next;
136	user_ptr->next = -1;
137	spin_unlock_bh(&reg_lock);
138
139	INIT_LIST_HEAD(&user_ptr->ports);
140	atomic_inc(&tipc_user_count);
141
142	return 0;
143	}
144
145	/**
146	* tipc_detach - deregister a TIPC user
147	*/
148
149	void tipc_detach(u32 userid)
150	{
151	struct tipc_user *user_ptr;
152	struct list_head ports_temp;
153	struct user_port up_ptr, temp_up_ptr;
154
155	if ((userid == 0) \|\| (userid > MAX_USERID))
156	return;
157
158	spin_lock_bh(&reg_lock);
159	if ((!users) \|\| (users[userid].next >= 0)) {
160	spin_unlock_bh(&reg_lock);
161	return;
162	}
163
164	user_ptr = &users[userid];
165	INIT_LIST_HEAD(&ports_temp);
166	list_splice(&user_ptr->ports, &ports_temp);
167	user_ptr->next = next_free_user;
168	next_free_user = userid;
169	spin_unlock_bh(&reg_lock);
170
171	atomic_dec(&tipc_user_count);
172
173	list_for_each_entry_safe(up_ptr, temp_up_ptr, &ports_temp, uport_list) {
174	tipc_deleteport(up_ptr->ref);
175	}
176	}
177
178	/**
179	* tipc_reg_add_port - register a user's driver port
180	*/
181
182	int tipc_reg_add_port(struct user_port *up_ptr)
183	{
184	struct tipc_user *user_ptr;
185
186	if (up_ptr->user_ref == 0)
187	return 0;
188	if (up_ptr->user_ref > MAX_USERID)
189	return -EINVAL;
190	if ((tipc_mode == TIPC_NOT_RUNNING) \|\| !users )
191	return -ENOPROTOOPT;
192
193	spin_lock_bh(&reg_lock);
194	user_ptr = &users[up_ptr->user_ref];
195	list_add(&up_ptr->uport_list, &user_ptr->ports);
196	spin_unlock_bh(&reg_lock);
197	return 0;
198	}
199
200	/**
201	* tipc_reg_remove_port - deregister a user's driver port
202	*/
203
204	int tipc_reg_remove_port(struct user_port *up_ptr)
205	{
206	if (up_ptr->user_ref == 0)
207	return 0;
208	if (up_ptr->user_ref > MAX_USERID)
209	return -EINVAL;
210	if (!users )
211	return -ENOPROTOOPT;
212
213	spin_lock_bh(&reg_lock);
214	list_del_init(&up_ptr->uport_list);
215	spin_unlock_bh(&reg_lock);
216	return 0;
217	}
218		1	/*
219		2	* net/tipc/user_reg.c: TIPC user registry code

net/tipc/user_reg.h

View file @ b0c1e92

1	/*		File was deleted
2	* net/tipc/user_reg.h: Include file for TIPC user registry code
3	*
4	* Copyright (c) 2000-2006, Ericsson AB
5	* Copyright (c) 2005, Wind River Systems
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:
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.
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	#ifndef _TIPC_USER_REG_H
38	#define _TIPC_USER_REG_H
39
40	#include "port.h"
41
42	int tipc_reg_start(void);
43	void tipc_reg_stop(void);
44
45	int tipc_attach(unsigned int *userref);
46	void tipc_detach(unsigned int userref);
47
48	int tipc_reg_add_port(struct user_port *up_ptr);
49	int tipc_reg_remove_port(struct user_port *up_ptr);
50
51	#endif
52		1	/*