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