2 * net/tipc/subscr.c: TIPC network topology service
4 * Copyright (c) 2000-2006, Ericsson AB
5 * Copyright (c) 2005-2007, 2010-2013, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
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.
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.
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.
38 #include "name_table.h"
42 * struct tipc_subscriber - TIPC network topology subscriber
43 * @conid: connection identifier to server connecting to subscriber
44 * @lock: control access to subscriber
45 * @subscription_list: list of subscription objects for this subscriber
47 struct tipc_subscriber
{
50 struct list_head subscription_list
;
54 * htohl - convert value to endianness used by destination
55 * @in: value to convert
56 * @swap: non-zero if endianness must be reversed
58 * Returns converted value
60 static u32
htohl(u32 in
, int swap
)
62 return swap
? swab32(in
) : in
;
65 static void subscr_send_event(struct tipc_subscription
*sub
, u32 found_lower
,
66 u32 found_upper
, u32 event
, u32 port_ref
,
69 struct tipc_net
*tn
= net_generic(sub
->net
, tipc_net_id
);
70 struct tipc_subscriber
*subscriber
= sub
->subscriber
;
73 msg_sect
.iov_base
= (void *)&sub
->evt
;
74 msg_sect
.iov_len
= sizeof(struct tipc_event
);
75 sub
->evt
.event
= htohl(event
, sub
->swap
);
76 sub
->evt
.found_lower
= htohl(found_lower
, sub
->swap
);
77 sub
->evt
.found_upper
= htohl(found_upper
, sub
->swap
);
78 sub
->evt
.port
.ref
= htohl(port_ref
, sub
->swap
);
79 sub
->evt
.port
.node
= htohl(node
, sub
->swap
);
80 tipc_conn_sendmsg(tn
->topsrv
, subscriber
->conid
, NULL
,
81 msg_sect
.iov_base
, msg_sect
.iov_len
);
85 * tipc_subscr_overlap - test for subscription overlap with the given values
87 * Returns 1 if there is overlap, otherwise 0.
89 int tipc_subscr_overlap(struct tipc_subscription
*sub
, u32 found_lower
,
92 if (found_lower
< sub
->seq
.lower
)
93 found_lower
= sub
->seq
.lower
;
94 if (found_upper
> sub
->seq
.upper
)
95 found_upper
= sub
->seq
.upper
;
96 if (found_lower
> found_upper
)
102 * tipc_subscr_report_overlap - issue event if there is subscription overlap
104 * Protected by nameseq.lock in name_table.c
106 void tipc_subscr_report_overlap(struct tipc_subscription
*sub
, u32 found_lower
,
107 u32 found_upper
, u32 event
, u32 port_ref
,
110 if (!tipc_subscr_overlap(sub
, found_lower
, found_upper
))
112 if (!must
&& !(sub
->filter
& TIPC_SUB_PORTS
))
115 subscr_send_event(sub
, found_lower
, found_upper
, event
, port_ref
, node
);
118 static void subscr_timeout(unsigned long data
)
120 struct tipc_subscription
*sub
= (struct tipc_subscription
*)data
;
121 struct tipc_subscriber
*subscriber
= sub
->subscriber
;
122 struct tipc_net
*tn
= net_generic(sub
->net
, tipc_net_id
);
124 /* The spin lock per subscriber is used to protect its members */
125 spin_lock_bh(&subscriber
->lock
);
127 /* Validate timeout (in case subscription is being cancelled) */
128 if (sub
->timeout
== TIPC_WAIT_FOREVER
) {
129 spin_unlock_bh(&subscriber
->lock
);
133 /* Unlink subscription from name table */
134 tipc_nametbl_unsubscribe(sub
);
136 /* Unlink subscription from subscriber */
137 list_del(&sub
->subscription_list
);
139 spin_unlock_bh(&subscriber
->lock
);
141 /* Notify subscriber of timeout */
142 subscr_send_event(sub
, sub
->evt
.s
.seq
.lower
, sub
->evt
.s
.seq
.upper
,
143 TIPC_SUBSCR_TIMEOUT
, 0, 0);
145 /* Now destroy subscription */
147 atomic_dec(&tn
->subscription_count
);
151 * subscr_del - delete a subscription within a subscription list
153 * Called with subscriber lock held.
155 static void subscr_del(struct tipc_subscription
*sub
)
157 struct tipc_net
*tn
= net_generic(sub
->net
, tipc_net_id
);
159 tipc_nametbl_unsubscribe(sub
);
160 list_del(&sub
->subscription_list
);
162 atomic_dec(&tn
->subscription_count
);
166 * subscr_terminate - terminate communication with a subscriber
168 * Note: Must call it in process context since it might sleep.
170 static void subscr_terminate(struct tipc_subscription
*sub
)
172 struct tipc_subscriber
*subscriber
= sub
->subscriber
;
173 struct tipc_net
*tn
= net_generic(sub
->net
, tipc_net_id
);
175 tipc_conn_terminate(tn
->topsrv
, subscriber
->conid
);
178 static void subscr_release(struct tipc_subscriber
*subscriber
)
180 struct tipc_subscription
*sub
;
181 struct tipc_subscription
*sub_temp
;
183 spin_lock_bh(&subscriber
->lock
);
185 /* Destroy any existing subscriptions for subscriber */
186 list_for_each_entry_safe(sub
, sub_temp
, &subscriber
->subscription_list
,
188 if (sub
->timeout
!= TIPC_WAIT_FOREVER
) {
189 spin_unlock_bh(&subscriber
->lock
);
190 del_timer_sync(&sub
->timer
);
191 spin_lock_bh(&subscriber
->lock
);
195 spin_unlock_bh(&subscriber
->lock
);
197 /* Now destroy subscriber */
202 * subscr_cancel - handle subscription cancellation request
204 * Called with subscriber lock held. Routine must temporarily release lock
205 * to enable the subscription timeout routine to finish without deadlocking;
206 * the lock is then reclaimed to allow caller to release it upon return.
208 * Note that fields of 's' use subscriber's endianness!
210 static void subscr_cancel(struct tipc_subscr
*s
,
211 struct tipc_subscriber
*subscriber
)
213 struct tipc_subscription
*sub
;
214 struct tipc_subscription
*sub_temp
;
217 /* Find first matching subscription, exit if not found */
218 list_for_each_entry_safe(sub
, sub_temp
, &subscriber
->subscription_list
,
220 if (!memcmp(s
, &sub
->evt
.s
, sizeof(struct tipc_subscr
))) {
228 /* Cancel subscription timer (if used), then delete subscription */
229 if (sub
->timeout
!= TIPC_WAIT_FOREVER
) {
230 sub
->timeout
= TIPC_WAIT_FOREVER
;
231 spin_unlock_bh(&subscriber
->lock
);
232 del_timer_sync(&sub
->timer
);
233 spin_lock_bh(&subscriber
->lock
);
239 * subscr_subscribe - create subscription for subscriber
241 * Called with subscriber lock held.
243 static int subscr_subscribe(struct net
*net
, struct tipc_subscr
*s
,
244 struct tipc_subscriber
*subscriber
,
245 struct tipc_subscription
**sub_p
)
247 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
248 struct tipc_subscription
*sub
;
251 /* Determine subscriber's endianness */
252 swap
= !(s
->filter
& (TIPC_SUB_PORTS
| TIPC_SUB_SERVICE
));
254 /* Detect & process a subscription cancellation request */
255 if (s
->filter
& htohl(TIPC_SUB_CANCEL
, swap
)) {
256 s
->filter
&= ~htohl(TIPC_SUB_CANCEL
, swap
);
257 subscr_cancel(s
, subscriber
);
261 /* Refuse subscription if global limit exceeded */
262 if (atomic_read(&tn
->subscription_count
) >= TIPC_MAX_SUBSCRIPTIONS
) {
263 pr_warn("Subscription rejected, limit reached (%u)\n",
264 TIPC_MAX_SUBSCRIPTIONS
);
268 /* Allocate subscription object */
269 sub
= kmalloc(sizeof(*sub
), GFP_ATOMIC
);
271 pr_warn("Subscription rejected, no memory\n");
275 /* Initialize subscription object */
277 sub
->seq
.type
= htohl(s
->seq
.type
, swap
);
278 sub
->seq
.lower
= htohl(s
->seq
.lower
, swap
);
279 sub
->seq
.upper
= htohl(s
->seq
.upper
, swap
);
280 sub
->timeout
= msecs_to_jiffies(htohl(s
->timeout
, swap
));
281 sub
->filter
= htohl(s
->filter
, swap
);
282 if ((!(sub
->filter
& TIPC_SUB_PORTS
) ==
283 !(sub
->filter
& TIPC_SUB_SERVICE
)) ||
284 (sub
->seq
.lower
> sub
->seq
.upper
)) {
285 pr_warn("Subscription rejected, illegal request\n");
289 list_add(&sub
->subscription_list
, &subscriber
->subscription_list
);
290 sub
->subscriber
= subscriber
;
292 memcpy(&sub
->evt
.s
, s
, sizeof(struct tipc_subscr
));
293 atomic_inc(&tn
->subscription_count
);
294 if (sub
->timeout
!= TIPC_WAIT_FOREVER
) {
295 setup_timer(&sub
->timer
, subscr_timeout
, (unsigned long)sub
);
296 mod_timer(&sub
->timer
, jiffies
+ sub
->timeout
);
302 /* Handle one termination request for the subscriber */
303 static void subscr_conn_shutdown_event(int conid
, void *usr_data
)
305 subscr_release((struct tipc_subscriber
*)usr_data
);
308 /* Handle one request to create a new subscription for the subscriber */
309 static void subscr_conn_msg_event(struct net
*net
, int conid
,
310 struct sockaddr_tipc
*addr
, void *usr_data
,
311 void *buf
, size_t len
)
313 struct tipc_subscriber
*subscriber
= usr_data
;
314 struct tipc_subscription
*sub
= NULL
;
316 spin_lock_bh(&subscriber
->lock
);
317 if (subscr_subscribe(net
, (struct tipc_subscr
*)buf
, subscriber
,
319 spin_unlock_bh(&subscriber
->lock
);
320 subscr_terminate(sub
);
324 tipc_nametbl_subscribe(sub
);
325 spin_unlock_bh(&subscriber
->lock
);
328 /* Handle one request to establish a new subscriber */
329 static void *subscr_named_msg_event(int conid
)
331 struct tipc_subscriber
*subscriber
;
333 /* Create subscriber object */
334 subscriber
= kzalloc(sizeof(struct tipc_subscriber
), GFP_ATOMIC
);
335 if (subscriber
== NULL
) {
336 pr_warn("Subscriber rejected, no memory\n");
339 INIT_LIST_HEAD(&subscriber
->subscription_list
);
340 subscriber
->conid
= conid
;
341 spin_lock_init(&subscriber
->lock
);
343 return (void *)subscriber
;
346 int tipc_subscr_start(struct net
*net
)
348 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
349 const char name
[] = "topology_server";
350 struct tipc_server
*topsrv
;
351 struct sockaddr_tipc
*saddr
;
353 saddr
= kzalloc(sizeof(*saddr
), GFP_ATOMIC
);
356 saddr
->family
= AF_TIPC
;
357 saddr
->addrtype
= TIPC_ADDR_NAMESEQ
;
358 saddr
->addr
.nameseq
.type
= TIPC_TOP_SRV
;
359 saddr
->addr
.nameseq
.lower
= TIPC_TOP_SRV
;
360 saddr
->addr
.nameseq
.upper
= TIPC_TOP_SRV
;
361 saddr
->scope
= TIPC_NODE_SCOPE
;
363 topsrv
= kzalloc(sizeof(*topsrv
), GFP_ATOMIC
);
369 topsrv
->saddr
= saddr
;
370 topsrv
->imp
= TIPC_CRITICAL_IMPORTANCE
;
371 topsrv
->type
= SOCK_SEQPACKET
;
372 topsrv
->max_rcvbuf_size
= sizeof(struct tipc_subscr
);
373 topsrv
->tipc_conn_recvmsg
= subscr_conn_msg_event
;
374 topsrv
->tipc_conn_new
= subscr_named_msg_event
;
375 topsrv
->tipc_conn_shutdown
= subscr_conn_shutdown_event
;
377 strncpy(topsrv
->name
, name
, strlen(name
) + 1);
379 atomic_set(&tn
->subscription_count
, 0);
381 return tipc_server_start(topsrv
);
384 void tipc_subscr_stop(struct net
*net
)
386 struct tipc_net
*tn
= net_generic(net
, tipc_net_id
);
387 struct tipc_server
*topsrv
= tn
->topsrv
;
389 tipc_server_stop(topsrv
);
390 kfree(topsrv
->saddr
);