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 * @kref: reference counter to tipc_subscription object
44 * @conid: connection identifier to server connecting to subscriber
45 * @lock: control access to subscriber
46 * @subscrp_list: list of subscription objects for this subscriber
48 struct tipc_subscriber {
52 struct list_head subscrp_list;
55 static void tipc_subscrp_delete(struct tipc_subscription *sub);
56 static void tipc_subscrb_put(struct tipc_subscriber *subscriber);
57 static void tipc_subscrp_put(struct tipc_subscription *subscription);
58 static void tipc_subscrp_get(struct tipc_subscription *subscription);
61 * htohl - convert value to endianness used by destination
62 * @in: value to convert
63 * @swap: non-zero if endianness must be reversed
65 * Returns converted value
67 static u32 htohl(u32 in, int swap)
69 return swap ? swab32(in) : in;
72 static void tipc_subscrp_send_event(struct tipc_subscription *sub,
73 u32 found_lower, u32 found_upper,
74 u32 event, u32 port_ref, u32 node)
76 struct tipc_net *tn = net_generic(sub->net, tipc_net_id);
77 struct tipc_subscriber *subscriber = sub->subscriber;
80 msg_sect.iov_base = (void *)&sub->evt;
81 msg_sect.iov_len = sizeof(struct tipc_event);
82 sub->evt.event = htohl(event, sub->swap);
83 sub->evt.found_lower = htohl(found_lower, sub->swap);
84 sub->evt.found_upper = htohl(found_upper, sub->swap);
85 sub->evt.port.ref = htohl(port_ref, sub->swap);
86 sub->evt.port.node = htohl(node, sub->swap);
87 tipc_conn_sendmsg(tn->topsrv, subscriber->conid, NULL,
88 msg_sect.iov_base, msg_sect.iov_len);
92 * tipc_subscrp_check_overlap - test for subscription overlap with the
95 * Returns 1 if there is overlap, otherwise 0.
97 int tipc_subscrp_check_overlap(struct tipc_name_seq *seq, u32 found_lower,
100 if (found_lower < seq->lower)
101 found_lower = seq->lower;
102 if (found_upper > seq->upper)
103 found_upper = seq->upper;
104 if (found_lower > found_upper)
109 u32 tipc_subscrp_convert_seq_type(u32 type, int swap)
111 return htohl(type, swap);
114 void tipc_subscrp_convert_seq(struct tipc_name_seq *in, int swap,
115 struct tipc_name_seq *out)
117 out->type = htohl(in->type, swap);
118 out->lower = htohl(in->lower, swap);
119 out->upper = htohl(in->upper, swap);
122 void tipc_subscrp_report_overlap(struct tipc_subscription *sub, u32 found_lower,
123 u32 found_upper, u32 event, u32 port_ref,
126 struct tipc_name_seq seq;
128 tipc_subscrp_get(sub);
129 tipc_subscrp_convert_seq(&sub->evt.s.seq, sub->swap, &seq);
130 if (!tipc_subscrp_check_overlap(&seq, found_lower, found_upper))
133 !(htohl(sub->evt.s.filter, sub->swap) & TIPC_SUB_PORTS))
136 tipc_subscrp_send_event(sub, found_lower, found_upper, event, port_ref,
138 tipc_subscrp_put(sub);
141 static void tipc_subscrp_timeout(unsigned long data)
143 struct tipc_subscription *sub = (struct tipc_subscription *)data;
144 struct tipc_subscriber *subscriber = sub->subscriber;
146 spin_lock_bh(&subscriber->lock);
147 tipc_nametbl_unsubscribe(sub);
148 spin_unlock_bh(&subscriber->lock);
150 /* Notify subscriber of timeout */
151 tipc_subscrp_send_event(sub, sub->evt.s.seq.lower, sub->evt.s.seq.upper,
152 TIPC_SUBSCR_TIMEOUT, 0, 0);
154 tipc_subscrp_put(sub);
157 static void tipc_subscrb_kref_release(struct kref *kref)
159 kfree(container_of(kref,struct tipc_subscriber, kref));
162 static void tipc_subscrb_put(struct tipc_subscriber *subscriber)
164 kref_put(&subscriber->kref, tipc_subscrb_kref_release);
167 static void tipc_subscrb_get(struct tipc_subscriber *subscriber)
169 kref_get(&subscriber->kref);
172 static void tipc_subscrp_kref_release(struct kref *kref)
174 struct tipc_subscription *sub = container_of(kref,
175 struct tipc_subscription,
177 struct tipc_net *tn = net_generic(sub->net, tipc_net_id);
178 struct tipc_subscriber *subscriber = sub->subscriber;
180 spin_lock_bh(&subscriber->lock);
181 list_del(&sub->subscrp_list);
182 atomic_dec(&tn->subscription_count);
183 spin_unlock_bh(&subscriber->lock);
185 tipc_subscrb_put(subscriber);
188 static void tipc_subscrp_put(struct tipc_subscription *subscription)
190 kref_put(&subscription->kref, tipc_subscrp_kref_release);
193 static void tipc_subscrp_get(struct tipc_subscription *subscription)
195 kref_get(&subscription->kref);
198 /* tipc_subscrb_subscrp_delete - delete a specific subscription or all
199 * subscriptions for a given subscriber.
201 static void tipc_subscrb_subscrp_delete(struct tipc_subscriber *subscriber,
202 struct tipc_subscr *s)
204 struct list_head *subscription_list = &subscriber->subscrp_list;
205 struct tipc_subscription *sub, *temp;
207 spin_lock_bh(&subscriber->lock);
208 list_for_each_entry_safe(sub, temp, subscription_list, subscrp_list) {
209 if (s && memcmp(s, &sub->evt.s, sizeof(struct tipc_subscr)))
212 tipc_nametbl_unsubscribe(sub);
213 tipc_subscrp_get(sub);
214 spin_unlock_bh(&subscriber->lock);
215 tipc_subscrp_delete(sub);
216 tipc_subscrp_put(sub);
217 spin_lock_bh(&subscriber->lock);
222 spin_unlock_bh(&subscriber->lock);
225 static struct tipc_subscriber *tipc_subscrb_create(int conid)
227 struct tipc_subscriber *subscriber;
229 subscriber = kzalloc(sizeof(*subscriber), GFP_ATOMIC);
231 pr_warn("Subscriber rejected, no memory\n");
234 INIT_LIST_HEAD(&subscriber->subscrp_list);
235 kref_init(&subscriber->kref);
236 subscriber->conid = conid;
237 spin_lock_init(&subscriber->lock);
242 static void tipc_subscrb_delete(struct tipc_subscriber *subscriber)
244 tipc_subscrb_subscrp_delete(subscriber, NULL);
245 tipc_subscrb_put(subscriber);
248 static void tipc_subscrp_delete(struct tipc_subscription *sub)
250 u32 timeout = htohl(sub->evt.s.timeout, sub->swap);
252 if (timeout == TIPC_WAIT_FOREVER || del_timer(&sub->timer))
253 tipc_subscrp_put(sub);
256 static void tipc_subscrp_cancel(struct tipc_subscr *s,
257 struct tipc_subscriber *subscriber)
259 tipc_subscrb_get(subscriber);
260 tipc_subscrb_subscrp_delete(subscriber, s);
261 tipc_subscrb_put(subscriber);
264 static struct tipc_subscription *tipc_subscrp_create(struct net *net,
265 struct tipc_subscr *s,
268 struct tipc_net *tn = net_generic(net, tipc_net_id);
269 struct tipc_subscription *sub;
270 u32 filter = htohl(s->filter, swap);
272 /* Refuse subscription if global limit exceeded */
273 if (atomic_read(&tn->subscription_count) >= TIPC_MAX_SUBSCRIPTIONS) {
274 pr_warn("Subscription rejected, limit reached (%u)\n",
275 TIPC_MAX_SUBSCRIPTIONS);
279 /* Allocate subscription object */
280 sub = kmalloc(sizeof(*sub), GFP_ATOMIC);
282 pr_warn("Subscription rejected, no memory\n");
286 /* Initialize subscription object */
288 if (((filter & TIPC_SUB_PORTS) && (filter & TIPC_SUB_SERVICE)) ||
289 (htohl(s->seq.lower, swap) > htohl(s->seq.upper, swap))) {
290 pr_warn("Subscription rejected, illegal request\n");
296 memcpy(&sub->evt.s, s, sizeof(*s));
297 atomic_inc(&tn->subscription_count);
298 kref_init(&sub->kref);
302 static void tipc_subscrp_subscribe(struct net *net, struct tipc_subscr *s,
303 struct tipc_subscriber *subscriber, int swap)
305 struct tipc_net *tn = net_generic(net, tipc_net_id);
306 struct tipc_subscription *sub = NULL;
309 sub = tipc_subscrp_create(net, s, swap);
311 return tipc_conn_terminate(tn->topsrv, subscriber->conid);
313 spin_lock_bh(&subscriber->lock);
314 list_add(&sub->subscrp_list, &subscriber->subscrp_list);
315 sub->subscriber = subscriber;
316 tipc_nametbl_subscribe(sub);
317 tipc_subscrb_get(subscriber);
318 spin_unlock_bh(&subscriber->lock);
320 setup_timer(&sub->timer, tipc_subscrp_timeout, (unsigned long)sub);
321 timeout = htohl(sub->evt.s.timeout, swap);
323 if (timeout != TIPC_WAIT_FOREVER)
324 mod_timer(&sub->timer, jiffies + msecs_to_jiffies(timeout));
327 /* Handle one termination request for the subscriber */
328 static void tipc_subscrb_release_cb(int conid, void *usr_data)
330 tipc_subscrb_delete((struct tipc_subscriber *)usr_data);
333 /* Handle one request to create a new subscription for the subscriber */
334 static void tipc_subscrb_rcv_cb(struct net *net, int conid,
335 struct sockaddr_tipc *addr, void *usr_data,
336 void *buf, size_t len)
338 struct tipc_subscriber *subscriber = usr_data;
339 struct tipc_subscr *s = (struct tipc_subscr *)buf;
342 /* Determine subscriber's endianness */
343 swap = !(s->filter & (TIPC_SUB_PORTS | TIPC_SUB_SERVICE |
346 /* Detect & process a subscription cancellation request */
347 if (s->filter & htohl(TIPC_SUB_CANCEL, swap)) {
348 s->filter &= ~htohl(TIPC_SUB_CANCEL, swap);
349 return tipc_subscrp_cancel(s, subscriber);
352 tipc_subscrp_subscribe(net, s, subscriber, swap);
355 /* Handle one request to establish a new subscriber */
356 static void *tipc_subscrb_connect_cb(int conid)
358 return (void *)tipc_subscrb_create(conid);
361 static int tipc_topsrv_start(struct net *net)
363 struct tipc_net *tn = net_generic(net, tipc_net_id);
364 const char name[] = "topology_server";
365 struct tipc_server *topsrv;
366 struct sockaddr_tipc *saddr;
368 saddr = kzalloc(sizeof(*saddr), GFP_ATOMIC);
371 saddr->family = AF_TIPC;
372 saddr->addrtype = TIPC_ADDR_NAMESEQ;
373 saddr->addr.nameseq.type = TIPC_TOP_SRV;
374 saddr->addr.nameseq.lower = TIPC_TOP_SRV;
375 saddr->addr.nameseq.upper = TIPC_TOP_SRV;
376 saddr->scope = TIPC_NODE_SCOPE;
378 topsrv = kzalloc(sizeof(*topsrv), GFP_ATOMIC);
384 topsrv->saddr = saddr;
385 topsrv->imp = TIPC_CRITICAL_IMPORTANCE;
386 topsrv->type = SOCK_SEQPACKET;
387 topsrv->max_rcvbuf_size = sizeof(struct tipc_subscr);
388 topsrv->tipc_conn_recvmsg = tipc_subscrb_rcv_cb;
389 topsrv->tipc_conn_new = tipc_subscrb_connect_cb;
390 topsrv->tipc_conn_release = tipc_subscrb_release_cb;
392 strscpy(topsrv->name, name, sizeof(topsrv->name));
394 atomic_set(&tn->subscription_count, 0);
396 return tipc_server_start(topsrv);
399 static void tipc_topsrv_stop(struct net *net)
401 struct tipc_net *tn = net_generic(net, tipc_net_id);
402 struct tipc_server *topsrv = tn->topsrv;
404 tipc_server_stop(topsrv);
405 kfree(topsrv->saddr);
409 int __net_init tipc_topsrv_init_net(struct net *net)
411 return tipc_topsrv_start(net);
414 void __net_exit tipc_topsrv_exit_net(struct net *net)
416 tipc_topsrv_stop(net);