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"
43 * struct tipc_subscriber - TIPC network topology subscriber
44 * @conid: connection identifier to server connecting to subscriber
45 * @lock: control access to subscriber
46 * @subscription_list: list of subscription objects for this subscriber
48 struct tipc_subscriber
{
51 struct list_head subscription_list
;
54 static void subscr_conn_msg_event(int conid
, struct sockaddr_tipc
*addr
,
55 void *usr_data
, void *buf
, size_t len
);
56 static void *subscr_named_msg_event(int conid
);
57 static void subscr_conn_shutdown_event(int conid
, void *usr_data
);
59 static atomic_t subscription_count
= ATOMIC_INIT(0);
61 static struct sockaddr_tipc topsrv_addr __read_mostly
= {
63 .addrtype
= TIPC_ADDR_NAMESEQ
,
64 .addr
.nameseq
.type
= TIPC_TOP_SRV
,
65 .addr
.nameseq
.lower
= TIPC_TOP_SRV
,
66 .addr
.nameseq
.upper
= TIPC_TOP_SRV
,
67 .scope
= TIPC_NODE_SCOPE
70 static struct tipc_server topsrv __read_mostly
= {
71 .saddr
= &topsrv_addr
,
72 .imp
= TIPC_CRITICAL_IMPORTANCE
,
73 .type
= SOCK_SEQPACKET
,
74 .max_rcvbuf_size
= sizeof(struct tipc_subscr
),
75 .name
= "topology_server",
76 .tipc_conn_recvmsg
= subscr_conn_msg_event
,
77 .tipc_conn_new
= subscr_named_msg_event
,
78 .tipc_conn_shutdown
= subscr_conn_shutdown_event
,
82 * htohl - convert value to endianness used by destination
83 * @in: value to convert
84 * @swap: non-zero if endianness must be reversed
86 * Returns converted value
88 static u32
htohl(u32 in
, int swap
)
90 return swap
? swab32(in
) : in
;
93 static void subscr_send_event(struct tipc_subscription
*sub
, u32 found_lower
,
94 u32 found_upper
, u32 event
, u32 port_ref
,
97 struct tipc_subscriber
*subscriber
= sub
->subscriber
;
100 msg_sect
.iov_base
= (void *)&sub
->evt
;
101 msg_sect
.iov_len
= sizeof(struct tipc_event
);
102 sub
->evt
.event
= htohl(event
, sub
->swap
);
103 sub
->evt
.found_lower
= htohl(found_lower
, sub
->swap
);
104 sub
->evt
.found_upper
= htohl(found_upper
, sub
->swap
);
105 sub
->evt
.port
.ref
= htohl(port_ref
, sub
->swap
);
106 sub
->evt
.port
.node
= htohl(node
, sub
->swap
);
107 tipc_conn_sendmsg(&topsrv
, subscriber
->conid
, NULL
, msg_sect
.iov_base
,
112 * tipc_subscr_overlap - test for subscription overlap with the given values
114 * Returns 1 if there is overlap, otherwise 0.
116 int tipc_subscr_overlap(struct tipc_subscription
*sub
, u32 found_lower
,
119 if (found_lower
< sub
->seq
.lower
)
120 found_lower
= sub
->seq
.lower
;
121 if (found_upper
> sub
->seq
.upper
)
122 found_upper
= sub
->seq
.upper
;
123 if (found_lower
> found_upper
)
129 * tipc_subscr_report_overlap - issue event if there is subscription overlap
131 * Protected by nameseq.lock in name_table.c
133 void tipc_subscr_report_overlap(struct tipc_subscription
*sub
, u32 found_lower
,
134 u32 found_upper
, u32 event
, u32 port_ref
,
137 if (!tipc_subscr_overlap(sub
, found_lower
, found_upper
))
139 if (!must
&& !(sub
->filter
& TIPC_SUB_PORTS
))
142 subscr_send_event(sub
, found_lower
, found_upper
, event
, port_ref
, node
);
145 static void subscr_timeout(struct tipc_subscription
*sub
)
147 struct tipc_subscriber
*subscriber
= sub
->subscriber
;
149 /* The spin lock per subscriber is used to protect its members */
150 spin_lock_bh(&subscriber
->lock
);
152 /* Validate if the connection related to the subscriber is
153 * closed (in case subscriber is terminating)
155 if (subscriber
->conid
== 0) {
156 spin_unlock_bh(&subscriber
->lock
);
160 /* Validate timeout (in case subscription is being cancelled) */
161 if (sub
->timeout
== TIPC_WAIT_FOREVER
) {
162 spin_unlock_bh(&subscriber
->lock
);
166 /* Unlink subscription from name table */
167 tipc_nametbl_unsubscribe(sub
);
169 /* Unlink subscription from subscriber */
170 list_del(&sub
->subscription_list
);
172 spin_unlock_bh(&subscriber
->lock
);
174 /* Notify subscriber of timeout */
175 subscr_send_event(sub
, sub
->evt
.s
.seq
.lower
, sub
->evt
.s
.seq
.upper
,
176 TIPC_SUBSCR_TIMEOUT
, 0, 0);
178 /* Now destroy subscription */
179 k_term_timer(&sub
->timer
);
181 atomic_dec(&subscription_count
);
185 * subscr_del - delete a subscription within a subscription list
187 * Called with subscriber lock held.
189 static void subscr_del(struct tipc_subscription
*sub
)
191 tipc_nametbl_unsubscribe(sub
);
192 list_del(&sub
->subscription_list
);
194 atomic_dec(&subscription_count
);
198 * subscr_terminate - terminate communication with a subscriber
200 * Note: Must call it in process context since it might sleep.
202 static void subscr_terminate(struct tipc_subscriber
*subscriber
)
204 tipc_conn_terminate(&topsrv
, subscriber
->conid
);
207 static void subscr_release(struct tipc_subscriber
*subscriber
)
209 struct tipc_subscription
*sub
;
210 struct tipc_subscription
*sub_temp
;
212 spin_lock_bh(&subscriber
->lock
);
214 /* Invalidate subscriber reference */
215 subscriber
->conid
= 0;
217 /* Destroy any existing subscriptions for subscriber */
218 list_for_each_entry_safe(sub
, sub_temp
, &subscriber
->subscription_list
,
220 if (sub
->timeout
!= TIPC_WAIT_FOREVER
) {
221 spin_unlock_bh(&subscriber
->lock
);
222 k_cancel_timer(&sub
->timer
);
223 k_term_timer(&sub
->timer
);
224 spin_lock_bh(&subscriber
->lock
);
228 spin_unlock_bh(&subscriber
->lock
);
230 /* Now destroy subscriber */
235 * subscr_cancel - handle subscription cancellation request
237 * Called with subscriber lock held. Routine must temporarily release lock
238 * to enable the subscription timeout routine to finish without deadlocking;
239 * the lock is then reclaimed to allow caller to release it upon return.
241 * Note that fields of 's' use subscriber's endianness!
243 static void subscr_cancel(struct tipc_subscr
*s
,
244 struct tipc_subscriber
*subscriber
)
246 struct tipc_subscription
*sub
;
247 struct tipc_subscription
*sub_temp
;
250 /* Find first matching subscription, exit if not found */
251 list_for_each_entry_safe(sub
, sub_temp
, &subscriber
->subscription_list
,
253 if (!memcmp(s
, &sub
->evt
.s
, sizeof(struct tipc_subscr
))) {
261 /* Cancel subscription timer (if used), then delete subscription */
262 if (sub
->timeout
!= TIPC_WAIT_FOREVER
) {
263 sub
->timeout
= TIPC_WAIT_FOREVER
;
264 spin_unlock_bh(&subscriber
->lock
);
265 k_cancel_timer(&sub
->timer
);
266 k_term_timer(&sub
->timer
);
267 spin_lock_bh(&subscriber
->lock
);
273 * subscr_subscribe - create subscription for subscriber
275 * Called with subscriber lock held.
277 static struct tipc_subscription
*subscr_subscribe(struct tipc_subscr
*s
,
278 struct tipc_subscriber
*subscriber
)
280 struct tipc_subscription
*sub
;
283 /* Determine subscriber's endianness */
284 swap
= !(s
->filter
& (TIPC_SUB_PORTS
| TIPC_SUB_SERVICE
));
286 /* Detect & process a subscription cancellation request */
287 if (s
->filter
& htohl(TIPC_SUB_CANCEL
, swap
)) {
288 s
->filter
&= ~htohl(TIPC_SUB_CANCEL
, swap
);
289 subscr_cancel(s
, subscriber
);
293 /* Refuse subscription if global limit exceeded */
294 if (atomic_read(&subscription_count
) >= TIPC_MAX_SUBSCRIPTIONS
) {
295 pr_warn("Subscription rejected, limit reached (%u)\n",
296 TIPC_MAX_SUBSCRIPTIONS
);
297 subscr_terminate(subscriber
);
301 /* Allocate subscription object */
302 sub
= kmalloc(sizeof(*sub
), GFP_ATOMIC
);
304 pr_warn("Subscription rejected, no memory\n");
305 subscr_terminate(subscriber
);
309 /* Initialize subscription object */
310 sub
->seq
.type
= htohl(s
->seq
.type
, swap
);
311 sub
->seq
.lower
= htohl(s
->seq
.lower
, swap
);
312 sub
->seq
.upper
= htohl(s
->seq
.upper
, swap
);
313 sub
->timeout
= htohl(s
->timeout
, swap
);
314 sub
->filter
= htohl(s
->filter
, swap
);
315 if ((!(sub
->filter
& TIPC_SUB_PORTS
) ==
316 !(sub
->filter
& TIPC_SUB_SERVICE
)) ||
317 (sub
->seq
.lower
> sub
->seq
.upper
)) {
318 pr_warn("Subscription rejected, illegal request\n");
320 subscr_terminate(subscriber
);
323 INIT_LIST_HEAD(&sub
->nameseq_list
);
324 list_add(&sub
->subscription_list
, &subscriber
->subscription_list
);
325 sub
->subscriber
= subscriber
;
327 memcpy(&sub
->evt
.s
, s
, sizeof(struct tipc_subscr
));
328 atomic_inc(&subscription_count
);
329 if (sub
->timeout
!= TIPC_WAIT_FOREVER
) {
330 k_init_timer(&sub
->timer
,
331 (Handler
)subscr_timeout
, (unsigned long)sub
);
332 k_start_timer(&sub
->timer
, sub
->timeout
);
338 /* Handle one termination request for the subscriber */
339 static void subscr_conn_shutdown_event(int conid
, void *usr_data
)
341 subscr_release((struct tipc_subscriber
*)usr_data
);
344 /* Handle one request to create a new subscription for the subscriber */
345 static void subscr_conn_msg_event(int conid
, struct sockaddr_tipc
*addr
,
346 void *usr_data
, void *buf
, size_t len
)
348 struct tipc_subscriber
*subscriber
= usr_data
;
349 struct tipc_subscription
*sub
;
351 spin_lock_bh(&subscriber
->lock
);
352 sub
= subscr_subscribe((struct tipc_subscr
*)buf
, subscriber
);
354 tipc_nametbl_subscribe(sub
);
355 spin_unlock_bh(&subscriber
->lock
);
359 /* Handle one request to establish a new subscriber */
360 static void *subscr_named_msg_event(int conid
)
362 struct tipc_subscriber
*subscriber
;
364 /* Create subscriber object */
365 subscriber
= kzalloc(sizeof(struct tipc_subscriber
), GFP_ATOMIC
);
366 if (subscriber
== NULL
) {
367 pr_warn("Subscriber rejected, no memory\n");
370 INIT_LIST_HEAD(&subscriber
->subscription_list
);
371 subscriber
->conid
= conid
;
372 spin_lock_init(&subscriber
->lock
);
374 return (void *)subscriber
;
377 int tipc_subscr_start(void)
379 return tipc_server_start(&topsrv
);
382 void tipc_subscr_stop(void)
384 tipc_server_stop(&topsrv
);