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