]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - net/tipc/bearer.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
tipc: some cleanups in the file discover.c
[mirror_ubuntu-jammy-kernel.git] / net / tipc / bearer.c
1 /*
2 * net/tipc/bearer.c: TIPC bearer code
3 *
4 * Copyright (c) 1996-2006, 2013-2016, Ericsson AB
5 * Copyright (c) 2004-2006, 2010-2013, 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 <net/sock.h>
38 #include "core.h"
39 #include "bearer.h"
40 #include "link.h"
41 #include "discover.h"
42 #include "monitor.h"
43 #include "bcast.h"
44 #include "netlink.h"
45 #include "udp_media.h"
46
47 #define MAX_ADDR_STR 60
48
49 static struct tipc_media * const media_info_array[] = {
50 &eth_media_info,
51 #ifdef CONFIG_TIPC_MEDIA_IB
52 &ib_media_info,
53 #endif
54 #ifdef CONFIG_TIPC_MEDIA_UDP
55 &udp_media_info,
56 #endif
57 NULL
58 };
59
60 static struct tipc_bearer *bearer_get(struct net *net, int bearer_id)
61 {
62 struct tipc_net *tn = tipc_net(net);
63
64 return rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
65 }
66
67 static void bearer_disable(struct net *net, struct tipc_bearer *b);
68 static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
69 struct packet_type *pt, struct net_device *orig_dev);
70
71 /**
72 * tipc_media_find - locates specified media object by name
73 */
74 struct tipc_media *tipc_media_find(const char *name)
75 {
76 u32 i;
77
78 for (i = 0; media_info_array[i] != NULL; i++) {
79 if (!strcmp(media_info_array[i]->name, name))
80 break;
81 }
82 return media_info_array[i];
83 }
84
85 /**
86 * media_find_id - locates specified media object by type identifier
87 */
88 static struct tipc_media *media_find_id(u8 type)
89 {
90 u32 i;
91
92 for (i = 0; media_info_array[i] != NULL; i++) {
93 if (media_info_array[i]->type_id == type)
94 break;
95 }
96 return media_info_array[i];
97 }
98
99 /**
100 * tipc_media_addr_printf - record media address in print buffer
101 */
102 void tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a)
103 {
104 char addr_str[MAX_ADDR_STR];
105 struct tipc_media *m;
106 int ret;
107
108 m = media_find_id(a->media_id);
109
110 if (m && !m->addr2str(a, addr_str, sizeof(addr_str)))
111 ret = scnprintf(buf, len, "%s(%s)", m->name, addr_str);
112 else {
113 u32 i;
114
115 ret = scnprintf(buf, len, "UNKNOWN(%u)", a->media_id);
116 for (i = 0; i < sizeof(a->value); i++)
117 ret += scnprintf(buf - ret, len + ret,
118 "-%02x", a->value[i]);
119 }
120 }
121
122 /**
123 * bearer_name_validate - validate & (optionally) deconstruct bearer name
124 * @name: ptr to bearer name string
125 * @name_parts: ptr to area for bearer name components (or NULL if not needed)
126 *
127 * Returns 1 if bearer name is valid, otherwise 0.
128 */
129 static int bearer_name_validate(const char *name,
130 struct tipc_bearer_names *name_parts)
131 {
132 char name_copy[TIPC_MAX_BEARER_NAME];
133 char *media_name;
134 char *if_name;
135 u32 media_len;
136 u32 if_len;
137
138 /* copy bearer name & ensure length is OK */
139 name_copy[TIPC_MAX_BEARER_NAME - 1] = 0;
140 /* need above in case non-Posix strncpy() doesn't pad with nulls */
141 strncpy(name_copy, name, TIPC_MAX_BEARER_NAME);
142 if (name_copy[TIPC_MAX_BEARER_NAME - 1] != 0)
143 return 0;
144
145 /* ensure all component parts of bearer name are present */
146 media_name = name_copy;
147 if_name = strchr(media_name, ':');
148 if (if_name == NULL)
149 return 0;
150 *(if_name++) = 0;
151 media_len = if_name - media_name;
152 if_len = strlen(if_name) + 1;
153
154 /* validate component parts of bearer name */
155 if ((media_len <= 1) || (media_len > TIPC_MAX_MEDIA_NAME) ||
156 (if_len <= 1) || (if_len > TIPC_MAX_IF_NAME))
157 return 0;
158
159 /* return bearer name components, if necessary */
160 if (name_parts) {
161 strcpy(name_parts->media_name, media_name);
162 strcpy(name_parts->if_name, if_name);
163 }
164 return 1;
165 }
166
167 /**
168 * tipc_bearer_find - locates bearer object with matching bearer name
169 */
170 struct tipc_bearer *tipc_bearer_find(struct net *net, const char *name)
171 {
172 struct tipc_net *tn = net_generic(net, tipc_net_id);
173 struct tipc_bearer *b;
174 u32 i;
175
176 for (i = 0; i < MAX_BEARERS; i++) {
177 b = rtnl_dereference(tn->bearer_list[i]);
178 if (b && (!strcmp(b->name, name)))
179 return b;
180 }
181 return NULL;
182 }
183
184 /* tipc_bearer_get_name - get the bearer name from its id.
185 * @net: network namespace
186 * @name: a pointer to the buffer where the name will be stored.
187 * @bearer_id: the id to get the name from.
188 */
189 int tipc_bearer_get_name(struct net *net, char *name, u32 bearer_id)
190 {
191 struct tipc_net *tn = tipc_net(net);
192 struct tipc_bearer *b;
193
194 if (bearer_id >= MAX_BEARERS)
195 return -EINVAL;
196
197 b = rtnl_dereference(tn->bearer_list[bearer_id]);
198 if (!b)
199 return -EINVAL;
200
201 strcpy(name, b->name);
202 return 0;
203 }
204
205 void tipc_bearer_add_dest(struct net *net, u32 bearer_id, u32 dest)
206 {
207 struct tipc_net *tn = net_generic(net, tipc_net_id);
208 struct tipc_bearer *b;
209
210 rcu_read_lock();
211 b = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
212 if (b)
213 tipc_disc_add_dest(b->disc);
214 rcu_read_unlock();
215 }
216
217 void tipc_bearer_remove_dest(struct net *net, u32 bearer_id, u32 dest)
218 {
219 struct tipc_net *tn = net_generic(net, tipc_net_id);
220 struct tipc_bearer *b;
221
222 rcu_read_lock();
223 b = rcu_dereference_rtnl(tn->bearer_list[bearer_id]);
224 if (b)
225 tipc_disc_remove_dest(b->disc);
226 rcu_read_unlock();
227 }
228
229 /**
230 * tipc_enable_bearer - enable bearer with the given name
231 */
232 static int tipc_enable_bearer(struct net *net, const char *name,
233 u32 disc_domain, u32 prio,
234 struct nlattr *attr[])
235 {
236 struct tipc_net *tn = tipc_net(net);
237 struct tipc_bearer_names b_names;
238 u32 self = tipc_own_addr(net);
239 int with_this_prio = 1;
240 struct tipc_bearer *b;
241 struct tipc_media *m;
242 struct sk_buff *skb;
243 char addr_string[16];
244 int bearer_id = 0;
245 int res = -EINVAL;
246 char *errstr = "";
247
248 if (!self) {
249 errstr = "not supported in standalone mode";
250 res = -ENOPROTOOPT;
251 goto rejected;
252 }
253
254 if (!bearer_name_validate(name, &b_names)) {
255 errstr = "illegal name";
256 goto rejected;
257 }
258
259 if (tipc_addr_domain_valid(disc_domain) && disc_domain != self) {
260 if (tipc_in_scope(disc_domain, self)) {
261 /* Accept any node in own cluster */
262 disc_domain = self & TIPC_ZONE_CLUSTER_MASK;
263 res = 0;
264 } else if (in_own_cluster_exact(net, disc_domain)) {
265 /* Accept specified node in own cluster */
266 res = 0;
267 }
268 }
269 if (res) {
270 errstr = "illegal discovery domain";
271 goto rejected;
272 }
273
274 if (prio > TIPC_MAX_LINK_PRI && prio != TIPC_MEDIA_LINK_PRI) {
275 errstr = "illegal priority";
276 goto rejected;
277 }
278
279 m = tipc_media_find(b_names.media_name);
280 if (!m) {
281 errstr = "media not registered";
282 goto rejected;
283 }
284
285 if (prio == TIPC_MEDIA_LINK_PRI)
286 prio = m->priority;
287
288 /* Check new bearer vs existing ones and find free bearer id if any */
289 while (bearer_id < MAX_BEARERS) {
290 b = rtnl_dereference(tn->bearer_list[bearer_id]);
291 if (!b)
292 break;
293 if (!strcmp(name, b->name)) {
294 errstr = "already enabled";
295 goto rejected;
296 }
297 bearer_id++;
298 if (b->priority != prio)
299 continue;
300 if (++with_this_prio <= 2)
301 continue;
302 pr_warn("Bearer <%s>: already 2 bearers with priority %u\n",
303 name, prio);
304 if (prio == TIPC_MIN_LINK_PRI) {
305 errstr = "cannot adjust to lower";
306 goto rejected;
307 }
308 pr_warn("Bearer <%s>: trying with adjusted priority\n", name);
309 prio--;
310 bearer_id = 0;
311 with_this_prio = 1;
312 }
313
314 if (bearer_id >= MAX_BEARERS) {
315 errstr = "max 3 bearers permitted";
316 goto rejected;
317 }
318
319 b = kzalloc(sizeof(*b), GFP_ATOMIC);
320 if (!b)
321 return -ENOMEM;
322
323 strcpy(b->name, name);
324 b->media = m;
325 res = m->enable_media(net, b, attr);
326 if (res) {
327 kfree(b);
328 errstr = "failed to enable media";
329 goto rejected;
330 }
331
332 b->identity = bearer_id;
333 b->tolerance = m->tolerance;
334 b->window = m->window;
335 b->domain = disc_domain;
336 b->net_plane = bearer_id + 'A';
337 b->priority = prio;
338 test_and_set_bit_lock(0, &b->up);
339
340 res = tipc_disc_create(net, b, &b->bcast_addr, &skb);
341 if (res) {
342 bearer_disable(net, b);
343 kfree(b);
344 errstr = "failed to create discoverer";
345 goto rejected;
346 }
347
348 rcu_assign_pointer(tn->bearer_list[bearer_id], b);
349 if (skb)
350 tipc_bearer_xmit_skb(net, bearer_id, skb, &b->bcast_addr);
351
352 if (tipc_mon_create(net, bearer_id)) {
353 bearer_disable(net, b);
354 return -ENOMEM;
355 }
356
357 tipc_addr_string_fill(addr_string, disc_domain);
358 pr_info("Enabled bearer <%s>, discovery scope %s, priority %u\n",
359 name, addr_string, prio);
360 return res;
361 rejected:
362 pr_warn("Bearer <%s> rejected, %s\n", name, errstr);
363 return res;
364 }
365
366 /**
367 * tipc_reset_bearer - Reset all links established over this bearer
368 */
369 static int tipc_reset_bearer(struct net *net, struct tipc_bearer *b)
370 {
371 pr_info("Resetting bearer <%s>\n", b->name);
372 tipc_node_delete_links(net, b->identity);
373 tipc_disc_reset(net, b);
374 return 0;
375 }
376
377 /**
378 * bearer_disable
379 *
380 * Note: This routine assumes caller holds RTNL lock.
381 */
382 static void bearer_disable(struct net *net, struct tipc_bearer *b)
383 {
384 struct tipc_net *tn = tipc_net(net);
385 int bearer_id = b->identity;
386
387 pr_info("Disabling bearer <%s>\n", b->name);
388 clear_bit_unlock(0, &b->up);
389 tipc_node_delete_links(net, bearer_id);
390 b->media->disable_media(b);
391 RCU_INIT_POINTER(b->media_ptr, NULL);
392 if (b->disc)
393 tipc_disc_delete(b->disc);
394 RCU_INIT_POINTER(tn->bearer_list[bearer_id], NULL);
395 kfree_rcu(b, rcu);
396 tipc_mon_delete(net, bearer_id);
397 }
398
399 int tipc_enable_l2_media(struct net *net, struct tipc_bearer *b,
400 struct nlattr *attr[])
401 {
402 struct net_device *dev;
403 char *driver_name = strchr((const char *)b->name, ':') + 1;
404
405 /* Find device with specified name */
406 dev = dev_get_by_name(net, driver_name);
407 if (!dev)
408 return -ENODEV;
409 if (tipc_mtu_bad(dev, 0)) {
410 dev_put(dev);
411 return -EINVAL;
412 }
413
414 /* Associate TIPC bearer with L2 bearer */
415 rcu_assign_pointer(b->media_ptr, dev);
416 b->pt.dev = dev;
417 b->pt.type = htons(ETH_P_TIPC);
418 b->pt.func = tipc_l2_rcv_msg;
419 dev_add_pack(&b->pt);
420 memset(&b->bcast_addr, 0, sizeof(b->bcast_addr));
421 memcpy(b->bcast_addr.value, dev->broadcast, b->media->hwaddr_len);
422 b->bcast_addr.media_id = b->media->type_id;
423 b->bcast_addr.broadcast = TIPC_BROADCAST_SUPPORT;
424 b->mtu = dev->mtu;
425 b->media->raw2addr(b, &b->addr, (char *)dev->dev_addr);
426 rcu_assign_pointer(dev->tipc_ptr, b);
427 return 0;
428 }
429
430 /* tipc_disable_l2_media - detach TIPC bearer from an L2 interface
431 *
432 * Mark L2 bearer as inactive so that incoming buffers are thrown away
433 */
434 void tipc_disable_l2_media(struct tipc_bearer *b)
435 {
436 struct net_device *dev;
437
438 dev = (struct net_device *)rtnl_dereference(b->media_ptr);
439 dev_remove_pack(&b->pt);
440 RCU_INIT_POINTER(dev->tipc_ptr, NULL);
441 synchronize_net();
442 dev_put(dev);
443 }
444
445 /**
446 * tipc_l2_send_msg - send a TIPC packet out over an L2 interface
447 * @skb: the packet to be sent
448 * @b: the bearer through which the packet is to be sent
449 * @dest: peer destination address
450 */
451 int tipc_l2_send_msg(struct net *net, struct sk_buff *skb,
452 struct tipc_bearer *b, struct tipc_media_addr *dest)
453 {
454 struct net_device *dev;
455 int delta;
456
457 dev = (struct net_device *)rcu_dereference_rtnl(b->media_ptr);
458 if (!dev)
459 return 0;
460
461 delta = SKB_DATA_ALIGN(dev->hard_header_len - skb_headroom(skb));
462 if ((delta > 0) && pskb_expand_head(skb, delta, 0, GFP_ATOMIC)) {
463 kfree_skb(skb);
464 return 0;
465 }
466 skb_reset_network_header(skb);
467 skb->dev = dev;
468 skb->protocol = htons(ETH_P_TIPC);
469 dev_hard_header(skb, dev, ETH_P_TIPC, dest->value,
470 dev->dev_addr, skb->len);
471 dev_queue_xmit(skb);
472 return 0;
473 }
474
475 bool tipc_bearer_bcast_support(struct net *net, u32 bearer_id)
476 {
477 bool supp = false;
478 struct tipc_bearer *b;
479
480 rcu_read_lock();
481 b = bearer_get(net, bearer_id);
482 if (b)
483 supp = (b->bcast_addr.broadcast == TIPC_BROADCAST_SUPPORT);
484 rcu_read_unlock();
485 return supp;
486 }
487
488 int tipc_bearer_mtu(struct net *net, u32 bearer_id)
489 {
490 int mtu = 0;
491 struct tipc_bearer *b;
492
493 rcu_read_lock();
494 b = rcu_dereference_rtnl(tipc_net(net)->bearer_list[bearer_id]);
495 if (b)
496 mtu = b->mtu;
497 rcu_read_unlock();
498 return mtu;
499 }
500
501 /* tipc_bearer_xmit_skb - sends buffer to destination over bearer
502 */
503 void tipc_bearer_xmit_skb(struct net *net, u32 bearer_id,
504 struct sk_buff *skb,
505 struct tipc_media_addr *dest)
506 {
507 struct tipc_msg *hdr = buf_msg(skb);
508 struct tipc_bearer *b;
509
510 rcu_read_lock();
511 b = bearer_get(net, bearer_id);
512 if (likely(b && (test_bit(0, &b->up) || msg_is_reset(hdr))))
513 b->media->send_msg(net, skb, b, dest);
514 else
515 kfree_skb(skb);
516 rcu_read_unlock();
517 }
518
519 /* tipc_bearer_xmit() -send buffer to destination over bearer
520 */
521 void tipc_bearer_xmit(struct net *net, u32 bearer_id,
522 struct sk_buff_head *xmitq,
523 struct tipc_media_addr *dst)
524 {
525 struct tipc_bearer *b;
526 struct sk_buff *skb, *tmp;
527
528 if (skb_queue_empty(xmitq))
529 return;
530
531 rcu_read_lock();
532 b = bearer_get(net, bearer_id);
533 if (unlikely(!b))
534 __skb_queue_purge(xmitq);
535 skb_queue_walk_safe(xmitq, skb, tmp) {
536 __skb_dequeue(xmitq);
537 if (likely(test_bit(0, &b->up) || msg_is_reset(buf_msg(skb))))
538 b->media->send_msg(net, skb, b, dst);
539 else
540 kfree_skb(skb);
541 }
542 rcu_read_unlock();
543 }
544
545 /* tipc_bearer_bc_xmit() - broadcast buffers to all destinations
546 */
547 void tipc_bearer_bc_xmit(struct net *net, u32 bearer_id,
548 struct sk_buff_head *xmitq)
549 {
550 struct tipc_net *tn = tipc_net(net);
551 int net_id = tn->net_id;
552 struct tipc_bearer *b;
553 struct sk_buff *skb, *tmp;
554 struct tipc_msg *hdr;
555
556 rcu_read_lock();
557 b = bearer_get(net, bearer_id);
558 if (unlikely(!b || !test_bit(0, &b->up)))
559 __skb_queue_purge(xmitq);
560 skb_queue_walk_safe(xmitq, skb, tmp) {
561 hdr = buf_msg(skb);
562 msg_set_non_seq(hdr, 1);
563 msg_set_mc_netid(hdr, net_id);
564 __skb_dequeue(xmitq);
565 b->media->send_msg(net, skb, b, &b->bcast_addr);
566 }
567 rcu_read_unlock();
568 }
569
570 /**
571 * tipc_l2_rcv_msg - handle incoming TIPC message from an interface
572 * @buf: the received packet
573 * @dev: the net device that the packet was received on
574 * @pt: the packet_type structure which was used to register this handler
575 * @orig_dev: the original receive net device in case the device is a bond
576 *
577 * Accept only packets explicitly sent to this node, or broadcast packets;
578 * ignores packets sent using interface multicast, and traffic sent to other
579 * nodes (which can happen if interface is running in promiscuous mode).
580 */
581 static int tipc_l2_rcv_msg(struct sk_buff *skb, struct net_device *dev,
582 struct packet_type *pt, struct net_device *orig_dev)
583 {
584 struct tipc_bearer *b;
585
586 rcu_read_lock();
587 b = rcu_dereference_rtnl(dev->tipc_ptr) ?:
588 rcu_dereference_rtnl(orig_dev->tipc_ptr);
589 if (likely(b && test_bit(0, &b->up) &&
590 (skb->pkt_type <= PACKET_MULTICAST))) {
591 skb->next = NULL;
592 tipc_rcv(dev_net(b->pt.dev), skb, b);
593 rcu_read_unlock();
594 return NET_RX_SUCCESS;
595 }
596 rcu_read_unlock();
597 kfree_skb(skb);
598 return NET_RX_DROP;
599 }
600
601 /**
602 * tipc_l2_device_event - handle device events from network device
603 * @nb: the context of the notification
604 * @evt: the type of event
605 * @ptr: the net device that the event was on
606 *
607 * This function is called by the Ethernet driver in case of link
608 * change event.
609 */
610 static int tipc_l2_device_event(struct notifier_block *nb, unsigned long evt,
611 void *ptr)
612 {
613 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
614 struct net *net = dev_net(dev);
615 struct tipc_bearer *b;
616
617 b = rtnl_dereference(dev->tipc_ptr);
618 if (!b)
619 return NOTIFY_DONE;
620
621 switch (evt) {
622 case NETDEV_CHANGE:
623 if (netif_carrier_ok(dev))
624 break;
625 case NETDEV_UP:
626 test_and_set_bit_lock(0, &b->up);
627 break;
628 case NETDEV_GOING_DOWN:
629 clear_bit_unlock(0, &b->up);
630 tipc_reset_bearer(net, b);
631 break;
632 case NETDEV_CHANGEMTU:
633 if (tipc_mtu_bad(dev, 0)) {
634 bearer_disable(net, b);
635 break;
636 }
637 b->mtu = dev->mtu;
638 tipc_reset_bearer(net, b);
639 break;
640 case NETDEV_CHANGEADDR:
641 b->media->raw2addr(b, &b->addr,
642 (char *)dev->dev_addr);
643 tipc_reset_bearer(net, b);
644 break;
645 case NETDEV_UNREGISTER:
646 case NETDEV_CHANGENAME:
647 bearer_disable(net, b);
648 break;
649 }
650 return NOTIFY_OK;
651 }
652
653 static struct notifier_block notifier = {
654 .notifier_call = tipc_l2_device_event,
655 .priority = 0,
656 };
657
658 int tipc_bearer_setup(void)
659 {
660 return register_netdevice_notifier(&notifier);
661 }
662
663 void tipc_bearer_cleanup(void)
664 {
665 unregister_netdevice_notifier(&notifier);
666 }
667
668 void tipc_bearer_stop(struct net *net)
669 {
670 struct tipc_net *tn = net_generic(net, tipc_net_id);
671 struct tipc_bearer *b;
672 u32 i;
673
674 for (i = 0; i < MAX_BEARERS; i++) {
675 b = rtnl_dereference(tn->bearer_list[i]);
676 if (b) {
677 bearer_disable(net, b);
678 tn->bearer_list[i] = NULL;
679 }
680 }
681 }
682
683 /* Caller should hold rtnl_lock to protect the bearer */
684 static int __tipc_nl_add_bearer(struct tipc_nl_msg *msg,
685 struct tipc_bearer *bearer, int nlflags)
686 {
687 void *hdr;
688 struct nlattr *attrs;
689 struct nlattr *prop;
690
691 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
692 nlflags, TIPC_NL_BEARER_GET);
693 if (!hdr)
694 return -EMSGSIZE;
695
696 attrs = nla_nest_start(msg->skb, TIPC_NLA_BEARER);
697 if (!attrs)
698 goto msg_full;
699
700 if (nla_put_string(msg->skb, TIPC_NLA_BEARER_NAME, bearer->name))
701 goto attr_msg_full;
702
703 prop = nla_nest_start(msg->skb, TIPC_NLA_BEARER_PROP);
704 if (!prop)
705 goto prop_msg_full;
706 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, bearer->priority))
707 goto prop_msg_full;
708 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, bearer->tolerance))
709 goto prop_msg_full;
710 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, bearer->window))
711 goto prop_msg_full;
712
713 nla_nest_end(msg->skb, prop);
714
715 #ifdef CONFIG_TIPC_MEDIA_UDP
716 if (bearer->media->type_id == TIPC_MEDIA_TYPE_UDP) {
717 if (tipc_udp_nl_add_bearer_data(msg, bearer))
718 goto attr_msg_full;
719 }
720 #endif
721
722 nla_nest_end(msg->skb, attrs);
723 genlmsg_end(msg->skb, hdr);
724
725 return 0;
726
727 prop_msg_full:
728 nla_nest_cancel(msg->skb, prop);
729 attr_msg_full:
730 nla_nest_cancel(msg->skb, attrs);
731 msg_full:
732 genlmsg_cancel(msg->skb, hdr);
733
734 return -EMSGSIZE;
735 }
736
737 int tipc_nl_bearer_dump(struct sk_buff *skb, struct netlink_callback *cb)
738 {
739 int err;
740 int i = cb->args[0];
741 struct tipc_bearer *bearer;
742 struct tipc_nl_msg msg;
743 struct net *net = sock_net(skb->sk);
744 struct tipc_net *tn = net_generic(net, tipc_net_id);
745
746 if (i == MAX_BEARERS)
747 return 0;
748
749 msg.skb = skb;
750 msg.portid = NETLINK_CB(cb->skb).portid;
751 msg.seq = cb->nlh->nlmsg_seq;
752
753 rtnl_lock();
754 for (i = 0; i < MAX_BEARERS; i++) {
755 bearer = rtnl_dereference(tn->bearer_list[i]);
756 if (!bearer)
757 continue;
758
759 err = __tipc_nl_add_bearer(&msg, bearer, NLM_F_MULTI);
760 if (err)
761 break;
762 }
763 rtnl_unlock();
764
765 cb->args[0] = i;
766 return skb->len;
767 }
768
769 int tipc_nl_bearer_get(struct sk_buff *skb, struct genl_info *info)
770 {
771 int err;
772 char *name;
773 struct sk_buff *rep;
774 struct tipc_bearer *bearer;
775 struct tipc_nl_msg msg;
776 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
777 struct net *net = genl_info_net(info);
778
779 if (!info->attrs[TIPC_NLA_BEARER])
780 return -EINVAL;
781
782 err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
783 info->attrs[TIPC_NLA_BEARER],
784 tipc_nl_bearer_policy, info->extack);
785 if (err)
786 return err;
787
788 if (!attrs[TIPC_NLA_BEARER_NAME])
789 return -EINVAL;
790 name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
791
792 rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
793 if (!rep)
794 return -ENOMEM;
795
796 msg.skb = rep;
797 msg.portid = info->snd_portid;
798 msg.seq = info->snd_seq;
799
800 rtnl_lock();
801 bearer = tipc_bearer_find(net, name);
802 if (!bearer) {
803 err = -EINVAL;
804 goto err_out;
805 }
806
807 err = __tipc_nl_add_bearer(&msg, bearer, 0);
808 if (err)
809 goto err_out;
810 rtnl_unlock();
811
812 return genlmsg_reply(rep, info);
813 err_out:
814 rtnl_unlock();
815 nlmsg_free(rep);
816
817 return err;
818 }
819
820 int __tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
821 {
822 int err;
823 char *name;
824 struct tipc_bearer *bearer;
825 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
826 struct net *net = sock_net(skb->sk);
827
828 if (!info->attrs[TIPC_NLA_BEARER])
829 return -EINVAL;
830
831 err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
832 info->attrs[TIPC_NLA_BEARER],
833 tipc_nl_bearer_policy, info->extack);
834 if (err)
835 return err;
836
837 if (!attrs[TIPC_NLA_BEARER_NAME])
838 return -EINVAL;
839
840 name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
841
842 bearer = tipc_bearer_find(net, name);
843 if (!bearer)
844 return -EINVAL;
845
846 bearer_disable(net, bearer);
847
848 return 0;
849 }
850
851 int tipc_nl_bearer_disable(struct sk_buff *skb, struct genl_info *info)
852 {
853 int err;
854
855 rtnl_lock();
856 err = __tipc_nl_bearer_disable(skb, info);
857 rtnl_unlock();
858
859 return err;
860 }
861
862 int __tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
863 {
864 int err;
865 char *bearer;
866 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
867 struct net *net = sock_net(skb->sk);
868 struct tipc_net *tn = net_generic(net, tipc_net_id);
869 u32 domain;
870 u32 prio;
871
872 prio = TIPC_MEDIA_LINK_PRI;
873 domain = tn->own_addr & TIPC_ZONE_CLUSTER_MASK;
874
875 if (!info->attrs[TIPC_NLA_BEARER])
876 return -EINVAL;
877
878 err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
879 info->attrs[TIPC_NLA_BEARER],
880 tipc_nl_bearer_policy, info->extack);
881 if (err)
882 return err;
883
884 if (!attrs[TIPC_NLA_BEARER_NAME])
885 return -EINVAL;
886
887 bearer = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
888
889 if (attrs[TIPC_NLA_BEARER_DOMAIN])
890 domain = nla_get_u32(attrs[TIPC_NLA_BEARER_DOMAIN]);
891
892 if (attrs[TIPC_NLA_BEARER_PROP]) {
893 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
894
895 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
896 props);
897 if (err)
898 return err;
899
900 if (props[TIPC_NLA_PROP_PRIO])
901 prio = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
902 }
903
904 return tipc_enable_bearer(net, bearer, domain, prio, attrs);
905 }
906
907 int tipc_nl_bearer_enable(struct sk_buff *skb, struct genl_info *info)
908 {
909 int err;
910
911 rtnl_lock();
912 err = __tipc_nl_bearer_enable(skb, info);
913 rtnl_unlock();
914
915 return err;
916 }
917
918 int tipc_nl_bearer_add(struct sk_buff *skb, struct genl_info *info)
919 {
920 int err;
921 char *name;
922 struct tipc_bearer *b;
923 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
924 struct net *net = sock_net(skb->sk);
925
926 if (!info->attrs[TIPC_NLA_BEARER])
927 return -EINVAL;
928
929 err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
930 info->attrs[TIPC_NLA_BEARER],
931 tipc_nl_bearer_policy, info->extack);
932 if (err)
933 return err;
934
935 if (!attrs[TIPC_NLA_BEARER_NAME])
936 return -EINVAL;
937 name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
938
939 rtnl_lock();
940 b = tipc_bearer_find(net, name);
941 if (!b) {
942 rtnl_unlock();
943 return -EINVAL;
944 }
945
946 #ifdef CONFIG_TIPC_MEDIA_UDP
947 if (attrs[TIPC_NLA_BEARER_UDP_OPTS]) {
948 err = tipc_udp_nl_bearer_add(b,
949 attrs[TIPC_NLA_BEARER_UDP_OPTS]);
950 if (err) {
951 rtnl_unlock();
952 return err;
953 }
954 }
955 #endif
956 rtnl_unlock();
957
958 return 0;
959 }
960
961 int __tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
962 {
963 struct tipc_bearer *b;
964 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
965 struct net *net = sock_net(skb->sk);
966 char *name;
967 int err;
968
969 if (!info->attrs[TIPC_NLA_BEARER])
970 return -EINVAL;
971
972 err = nla_parse_nested(attrs, TIPC_NLA_BEARER_MAX,
973 info->attrs[TIPC_NLA_BEARER],
974 tipc_nl_bearer_policy, info->extack);
975 if (err)
976 return err;
977
978 if (!attrs[TIPC_NLA_BEARER_NAME])
979 return -EINVAL;
980 name = nla_data(attrs[TIPC_NLA_BEARER_NAME]);
981
982 b = tipc_bearer_find(net, name);
983 if (!b)
984 return -EINVAL;
985
986 if (attrs[TIPC_NLA_BEARER_PROP]) {
987 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
988
989 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_BEARER_PROP],
990 props);
991 if (err)
992 return err;
993
994 if (props[TIPC_NLA_PROP_TOL]) {
995 b->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
996 tipc_node_apply_tolerance(net, b);
997 }
998 if (props[TIPC_NLA_PROP_PRIO])
999 b->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1000 if (props[TIPC_NLA_PROP_WIN])
1001 b->window = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1002 }
1003
1004 return 0;
1005 }
1006
1007 int tipc_nl_bearer_set(struct sk_buff *skb, struct genl_info *info)
1008 {
1009 int err;
1010
1011 rtnl_lock();
1012 err = __tipc_nl_bearer_set(skb, info);
1013 rtnl_unlock();
1014
1015 return err;
1016 }
1017
1018 static int __tipc_nl_add_media(struct tipc_nl_msg *msg,
1019 struct tipc_media *media, int nlflags)
1020 {
1021 void *hdr;
1022 struct nlattr *attrs;
1023 struct nlattr *prop;
1024
1025 hdr = genlmsg_put(msg->skb, msg->portid, msg->seq, &tipc_genl_family,
1026 nlflags, TIPC_NL_MEDIA_GET);
1027 if (!hdr)
1028 return -EMSGSIZE;
1029
1030 attrs = nla_nest_start(msg->skb, TIPC_NLA_MEDIA);
1031 if (!attrs)
1032 goto msg_full;
1033
1034 if (nla_put_string(msg->skb, TIPC_NLA_MEDIA_NAME, media->name))
1035 goto attr_msg_full;
1036
1037 prop = nla_nest_start(msg->skb, TIPC_NLA_MEDIA_PROP);
1038 if (!prop)
1039 goto prop_msg_full;
1040 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_PRIO, media->priority))
1041 goto prop_msg_full;
1042 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_TOL, media->tolerance))
1043 goto prop_msg_full;
1044 if (nla_put_u32(msg->skb, TIPC_NLA_PROP_WIN, media->window))
1045 goto prop_msg_full;
1046
1047 nla_nest_end(msg->skb, prop);
1048 nla_nest_end(msg->skb, attrs);
1049 genlmsg_end(msg->skb, hdr);
1050
1051 return 0;
1052
1053 prop_msg_full:
1054 nla_nest_cancel(msg->skb, prop);
1055 attr_msg_full:
1056 nla_nest_cancel(msg->skb, attrs);
1057 msg_full:
1058 genlmsg_cancel(msg->skb, hdr);
1059
1060 return -EMSGSIZE;
1061 }
1062
1063 int tipc_nl_media_dump(struct sk_buff *skb, struct netlink_callback *cb)
1064 {
1065 int err;
1066 int i = cb->args[0];
1067 struct tipc_nl_msg msg;
1068
1069 if (i == MAX_MEDIA)
1070 return 0;
1071
1072 msg.skb = skb;
1073 msg.portid = NETLINK_CB(cb->skb).portid;
1074 msg.seq = cb->nlh->nlmsg_seq;
1075
1076 rtnl_lock();
1077 for (; media_info_array[i] != NULL; i++) {
1078 err = __tipc_nl_add_media(&msg, media_info_array[i],
1079 NLM_F_MULTI);
1080 if (err)
1081 break;
1082 }
1083 rtnl_unlock();
1084
1085 cb->args[0] = i;
1086 return skb->len;
1087 }
1088
1089 int tipc_nl_media_get(struct sk_buff *skb, struct genl_info *info)
1090 {
1091 int err;
1092 char *name;
1093 struct tipc_nl_msg msg;
1094 struct tipc_media *media;
1095 struct sk_buff *rep;
1096 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1097
1098 if (!info->attrs[TIPC_NLA_MEDIA])
1099 return -EINVAL;
1100
1101 err = nla_parse_nested(attrs, TIPC_NLA_MEDIA_MAX,
1102 info->attrs[TIPC_NLA_MEDIA],
1103 tipc_nl_media_policy, info->extack);
1104 if (err)
1105 return err;
1106
1107 if (!attrs[TIPC_NLA_MEDIA_NAME])
1108 return -EINVAL;
1109 name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);
1110
1111 rep = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1112 if (!rep)
1113 return -ENOMEM;
1114
1115 msg.skb = rep;
1116 msg.portid = info->snd_portid;
1117 msg.seq = info->snd_seq;
1118
1119 rtnl_lock();
1120 media = tipc_media_find(name);
1121 if (!media) {
1122 err = -EINVAL;
1123 goto err_out;
1124 }
1125
1126 err = __tipc_nl_add_media(&msg, media, 0);
1127 if (err)
1128 goto err_out;
1129 rtnl_unlock();
1130
1131 return genlmsg_reply(rep, info);
1132 err_out:
1133 rtnl_unlock();
1134 nlmsg_free(rep);
1135
1136 return err;
1137 }
1138
1139 int __tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1140 {
1141 int err;
1142 char *name;
1143 struct tipc_media *m;
1144 struct nlattr *attrs[TIPC_NLA_BEARER_MAX + 1];
1145
1146 if (!info->attrs[TIPC_NLA_MEDIA])
1147 return -EINVAL;
1148
1149 err = nla_parse_nested(attrs, TIPC_NLA_MEDIA_MAX,
1150 info->attrs[TIPC_NLA_MEDIA],
1151 tipc_nl_media_policy, info->extack);
1152
1153 if (!attrs[TIPC_NLA_MEDIA_NAME])
1154 return -EINVAL;
1155 name = nla_data(attrs[TIPC_NLA_MEDIA_NAME]);
1156
1157 m = tipc_media_find(name);
1158 if (!m)
1159 return -EINVAL;
1160
1161 if (attrs[TIPC_NLA_MEDIA_PROP]) {
1162 struct nlattr *props[TIPC_NLA_PROP_MAX + 1];
1163
1164 err = tipc_nl_parse_link_prop(attrs[TIPC_NLA_MEDIA_PROP],
1165 props);
1166 if (err)
1167 return err;
1168
1169 if (props[TIPC_NLA_PROP_TOL])
1170 m->tolerance = nla_get_u32(props[TIPC_NLA_PROP_TOL]);
1171 if (props[TIPC_NLA_PROP_PRIO])
1172 m->priority = nla_get_u32(props[TIPC_NLA_PROP_PRIO]);
1173 if (props[TIPC_NLA_PROP_WIN])
1174 m->window = nla_get_u32(props[TIPC_NLA_PROP_WIN]);
1175 }
1176
1177 return 0;
1178 }
1179
1180 int tipc_nl_media_set(struct sk_buff *skb, struct genl_info *info)
1181 {
1182 int err;
1183
1184 rtnl_lock();
1185 err = __tipc_nl_media_set(skb, info);
1186 rtnl_unlock();
1187
1188 return err;
1189 }
Ubuntu Jammy Linux kernel mirror