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