1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * INET An implementation of the TCP/IP protocol suite for the LINUX 4 * operating system. INET is implemented using the BSD Socket 5 * interface as the means of communication with the user level. 6 * 7 * Routing netlink socket interface: protocol independent part. 8 * 9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 10 * 11 * Fixes: 12 * Vitaly E. Lavrov RTA_OK arithmetic was wrong. 13 */ 14 15 #include <linux/bitops.h> 16 #include <linux/errno.h> 17 #include <linux/module.h> 18 #include <linux/types.h> 19 #include <linux/socket.h> 20 #include <linux/kernel.h> 21 #include <linux/timer.h> 22 #include <linux/string.h> 23 #include <linux/sockios.h> 24 #include <linux/net.h> 25 #include <linux/fcntl.h> 26 #include <linux/mm.h> 27 #include <linux/slab.h> 28 #include <linux/interrupt.h> 29 #include <linux/capability.h> 30 #include <linux/skbuff.h> 31 #include <linux/init.h> 32 #include <linux/security.h> 33 #include <linux/mutex.h> 34 #include <linux/if_addr.h> 35 #include <linux/if_bridge.h> 36 #include <linux/if_vlan.h> 37 #include <linux/pci.h> 38 #include <linux/etherdevice.h> 39 #include <linux/bpf.h> 40 41 #include <linux/uaccess.h> 42 43 #include <linux/inet.h> 44 #include <linux/netdevice.h> 45 #include <net/ip.h> 46 #include <net/protocol.h> 47 #include <net/arp.h> 48 #include <net/route.h> 49 #include <net/udp.h> 50 #include <net/tcp.h> 51 #include <net/sock.h> 52 #include <net/pkt_sched.h> 53 #include <net/fib_rules.h> 54 #include <net/rtnetlink.h> 55 #include <net/net_namespace.h> 56 #include <net/netdev_lock.h> 57 #include <net/devlink.h> 58 #if IS_ENABLED(CONFIG_IPV6) 59 #include <net/addrconf.h> 60 #endif 61 #include <linux/dpll.h> 62 63 #include "dev.h" 64 65 #define RTNL_MAX_TYPE 50 66 #define RTNL_SLAVE_MAX_TYPE 44 67 68 struct rtnl_link { 69 rtnl_doit_func doit; 70 rtnl_dumpit_func dumpit; 71 struct module *owner; 72 unsigned int flags; 73 struct rcu_head rcu; 74 }; 75 76 static DEFINE_MUTEX(rtnl_mutex); 77 78 void rtnl_lock(void) 79 { 80 mutex_lock(&rtnl_mutex); 81 } 82 EXPORT_SYMBOL(rtnl_lock); 83 84 int rtnl_lock_interruptible(void) 85 { 86 return mutex_lock_interruptible(&rtnl_mutex); 87 } 88 89 int rtnl_lock_killable(void) 90 { 91 return mutex_lock_killable(&rtnl_mutex); 92 } 93 94 static struct sk_buff *defer_kfree_skb_list; 95 void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail) 96 { 97 if (head && tail) { 98 tail->next = defer_kfree_skb_list; 99 defer_kfree_skb_list = head; 100 } 101 } 102 EXPORT_SYMBOL(rtnl_kfree_skbs); 103 104 void __rtnl_unlock(void) 105 { 106 struct sk_buff *head = defer_kfree_skb_list; 107 108 defer_kfree_skb_list = NULL; 109 110 /* Ensure that we didn't actually add any TODO item when __rtnl_unlock() 111 * is used. In some places, e.g. in cfg80211, we have code that will do 112 * something like 113 * rtnl_lock() 114 * wiphy_lock() 115 * ... 116 * rtnl_unlock() 117 * 118 * and because netdev_run_todo() acquires the RTNL for items on the list 119 * we could cause a situation such as this: 120 * Thread 1 Thread 2 121 * rtnl_lock() 122 * unregister_netdevice() 123 * __rtnl_unlock() 124 * rtnl_lock() 125 * wiphy_lock() 126 * rtnl_unlock() 127 * netdev_run_todo() 128 * __rtnl_unlock() 129 * 130 * // list not empty now 131 * // because of thread 2 132 * rtnl_lock() 133 * while (!list_empty(...)) 134 * rtnl_lock() 135 * wiphy_lock() 136 * **** DEADLOCK **** 137 * 138 * However, usage of __rtnl_unlock() is rare, and so we can ensure that 139 * it's not used in cases where something is added to do the list. 140 */ 141 WARN_ON(!list_empty(&net_todo_list)); 142 143 mutex_unlock(&rtnl_mutex); 144 145 while (head) { 146 struct sk_buff *next = head->next; 147 148 kfree_skb(head); 149 cond_resched(); 150 head = next; 151 } 152 } 153 154 void rtnl_unlock(void) 155 { 156 /* This fellow will unlock it for us. */ 157 netdev_run_todo(); 158 } 159 EXPORT_SYMBOL(rtnl_unlock); 160 161 int rtnl_trylock(void) 162 { 163 return mutex_trylock(&rtnl_mutex); 164 } 165 EXPORT_SYMBOL(rtnl_trylock); 166 167 int rtnl_is_locked(void) 168 { 169 return mutex_is_locked(&rtnl_mutex); 170 } 171 EXPORT_SYMBOL(rtnl_is_locked); 172 173 bool refcount_dec_and_rtnl_lock(refcount_t *r) 174 { 175 return refcount_dec_and_mutex_lock(r, &rtnl_mutex); 176 } 177 EXPORT_SYMBOL(refcount_dec_and_rtnl_lock); 178 179 #ifdef CONFIG_PROVE_LOCKING 180 bool lockdep_rtnl_is_held(void) 181 { 182 return lockdep_is_held(&rtnl_mutex); 183 } 184 EXPORT_SYMBOL(lockdep_rtnl_is_held); 185 #endif /* #ifdef CONFIG_PROVE_LOCKING */ 186 187 #ifdef CONFIG_DEBUG_NET_SMALL_RTNL 188 void __rtnl_net_lock(struct net *net) 189 { 190 ASSERT_RTNL(); 191 192 mutex_lock(&net->rtnl_mutex); 193 } 194 EXPORT_SYMBOL(__rtnl_net_lock); 195 196 void __rtnl_net_unlock(struct net *net) 197 { 198 ASSERT_RTNL(); 199 200 mutex_unlock(&net->rtnl_mutex); 201 } 202 EXPORT_SYMBOL(__rtnl_net_unlock); 203 204 void rtnl_net_lock(struct net *net) 205 { 206 rtnl_lock(); 207 __rtnl_net_lock(net); 208 } 209 EXPORT_SYMBOL(rtnl_net_lock); 210 211 void rtnl_net_unlock(struct net *net) 212 { 213 __rtnl_net_unlock(net); 214 rtnl_unlock(); 215 } 216 EXPORT_SYMBOL(rtnl_net_unlock); 217 218 int rtnl_net_trylock(struct net *net) 219 { 220 int ret = rtnl_trylock(); 221 222 if (ret) 223 __rtnl_net_lock(net); 224 225 return ret; 226 } 227 EXPORT_SYMBOL(rtnl_net_trylock); 228 229 int rtnl_net_lock_killable(struct net *net) 230 { 231 int ret = rtnl_lock_killable(); 232 233 if (!ret) 234 __rtnl_net_lock(net); 235 236 return ret; 237 } 238 239 static int rtnl_net_cmp_locks(const struct net *net_a, const struct net *net_b) 240 { 241 if (net_eq(net_a, net_b)) 242 return 0; 243 244 /* always init_net first */ 245 if (net_eq(net_a, &init_net)) 246 return -1; 247 248 if (net_eq(net_b, &init_net)) 249 return 1; 250 251 /* otherwise lock in ascending order */ 252 return net_a < net_b ? -1 : 1; 253 } 254 255 int rtnl_net_lock_cmp_fn(const struct lockdep_map *a, const struct lockdep_map *b) 256 { 257 const struct net *net_a, *net_b; 258 259 net_a = container_of(a, struct net, rtnl_mutex.dep_map); 260 net_b = container_of(b, struct net, rtnl_mutex.dep_map); 261 262 return rtnl_net_cmp_locks(net_a, net_b); 263 } 264 265 bool rtnl_net_is_locked(struct net *net) 266 { 267 return rtnl_is_locked() && mutex_is_locked(&net->rtnl_mutex); 268 } 269 EXPORT_SYMBOL(rtnl_net_is_locked); 270 271 bool lockdep_rtnl_net_is_held(struct net *net) 272 { 273 return lockdep_rtnl_is_held() && lockdep_is_held(&net->rtnl_mutex); 274 } 275 EXPORT_SYMBOL(lockdep_rtnl_net_is_held); 276 #else 277 static int rtnl_net_cmp_locks(const struct net *net_a, const struct net *net_b) 278 { 279 /* No need to swap */ 280 return -1; 281 } 282 #endif 283 284 struct rtnl_nets { 285 /* ->newlink() needs to freeze 3 netns at most; 286 * 2 for the new device, 1 for its peer. 287 */ 288 struct net *net[3]; 289 unsigned char len; 290 }; 291 292 static void rtnl_nets_init(struct rtnl_nets *rtnl_nets) 293 { 294 memset(rtnl_nets, 0, sizeof(*rtnl_nets)); 295 } 296 297 static void rtnl_nets_destroy(struct rtnl_nets *rtnl_nets) 298 { 299 int i; 300 301 for (i = 0; i < rtnl_nets->len; i++) { 302 put_net(rtnl_nets->net[i]); 303 rtnl_nets->net[i] = NULL; 304 } 305 306 rtnl_nets->len = 0; 307 } 308 309 /** 310 * rtnl_nets_add - Add netns to be locked before ->newlink(). 311 * 312 * @rtnl_nets: rtnl_nets pointer passed to ->get_peer_net(). 313 * @net: netns pointer with an extra refcnt held. 314 * 315 * The extra refcnt is released in rtnl_nets_destroy(). 316 */ 317 static void rtnl_nets_add(struct rtnl_nets *rtnl_nets, struct net *net) 318 { 319 int i; 320 321 DEBUG_NET_WARN_ON_ONCE(rtnl_nets->len == ARRAY_SIZE(rtnl_nets->net)); 322 323 for (i = 0; i < rtnl_nets->len; i++) { 324 switch (rtnl_net_cmp_locks(rtnl_nets->net[i], net)) { 325 case 0: 326 put_net(net); 327 return; 328 case 1: 329 swap(rtnl_nets->net[i], net); 330 } 331 } 332 333 rtnl_nets->net[i] = net; 334 rtnl_nets->len++; 335 } 336 337 static void rtnl_nets_lock(struct rtnl_nets *rtnl_nets) 338 { 339 int i; 340 341 rtnl_lock(); 342 343 for (i = 0; i < rtnl_nets->len; i++) 344 __rtnl_net_lock(rtnl_nets->net[i]); 345 } 346 347 static void rtnl_nets_unlock(struct rtnl_nets *rtnl_nets) 348 { 349 int i; 350 351 for (i = 0; i < rtnl_nets->len; i++) 352 __rtnl_net_unlock(rtnl_nets->net[i]); 353 354 rtnl_unlock(); 355 } 356 357 static struct rtnl_link __rcu *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1]; 358 359 static inline int rtm_msgindex(int msgtype) 360 { 361 int msgindex = msgtype - RTM_BASE; 362 363 /* 364 * msgindex < 0 implies someone tried to register a netlink 365 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that 366 * the message type has not been added to linux/rtnetlink.h 367 */ 368 BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES); 369 370 return msgindex; 371 } 372 373 static struct rtnl_link *rtnl_get_link(int protocol, int msgtype) 374 { 375 struct rtnl_link __rcu **tab; 376 377 if (protocol >= ARRAY_SIZE(rtnl_msg_handlers)) 378 protocol = PF_UNSPEC; 379 380 tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]); 381 if (!tab) 382 tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]); 383 384 return rcu_dereference_rtnl(tab[msgtype]); 385 } 386 387 static int rtnl_register_internal(struct module *owner, 388 int protocol, int msgtype, 389 rtnl_doit_func doit, rtnl_dumpit_func dumpit, 390 unsigned int flags) 391 { 392 struct rtnl_link *link, *old; 393 struct rtnl_link __rcu **tab; 394 int msgindex; 395 int ret = -ENOBUFS; 396 397 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX); 398 msgindex = rtm_msgindex(msgtype); 399 400 rtnl_lock(); 401 tab = rtnl_dereference(rtnl_msg_handlers[protocol]); 402 if (tab == NULL) { 403 tab = kcalloc(RTM_NR_MSGTYPES, sizeof(void *), GFP_KERNEL); 404 if (!tab) 405 goto unlock; 406 407 /* ensures we see the 0 stores */ 408 rcu_assign_pointer(rtnl_msg_handlers[protocol], tab); 409 } 410 411 old = rtnl_dereference(tab[msgindex]); 412 if (old) { 413 link = kmemdup(old, sizeof(*old), GFP_KERNEL); 414 if (!link) 415 goto unlock; 416 } else { 417 link = kzalloc(sizeof(*link), GFP_KERNEL); 418 if (!link) 419 goto unlock; 420 } 421 422 WARN_ON(link->owner && link->owner != owner); 423 link->owner = owner; 424 425 WARN_ON(doit && link->doit && link->doit != doit); 426 if (doit) 427 link->doit = doit; 428 WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit); 429 if (dumpit) 430 link->dumpit = dumpit; 431 432 WARN_ON(rtnl_msgtype_kind(msgtype) != RTNL_KIND_DEL && 433 (flags & RTNL_FLAG_BULK_DEL_SUPPORTED)); 434 link->flags |= flags; 435 436 /* publish protocol:msgtype */ 437 rcu_assign_pointer(tab[msgindex], link); 438 ret = 0; 439 if (old) 440 kfree_rcu(old, rcu); 441 unlock: 442 rtnl_unlock(); 443 return ret; 444 } 445 446 /** 447 * rtnl_unregister - Unregister a rtnetlink message type 448 * @protocol: Protocol family or PF_UNSPEC 449 * @msgtype: rtnetlink message type 450 * 451 * Returns 0 on success or a negative error code. 452 */ 453 static int rtnl_unregister(int protocol, int msgtype) 454 { 455 struct rtnl_link __rcu **tab; 456 struct rtnl_link *link; 457 int msgindex; 458 459 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX); 460 msgindex = rtm_msgindex(msgtype); 461 462 rtnl_lock(); 463 tab = rtnl_dereference(rtnl_msg_handlers[protocol]); 464 if (!tab) { 465 rtnl_unlock(); 466 return -ENOENT; 467 } 468 469 link = rcu_replace_pointer_rtnl(tab[msgindex], NULL); 470 rtnl_unlock(); 471 472 kfree_rcu(link, rcu); 473 474 return 0; 475 } 476 477 /** 478 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol 479 * @protocol : Protocol family or PF_UNSPEC 480 * 481 * Identical to calling rtnl_unregster() for all registered message types 482 * of a certain protocol family. 483 */ 484 void rtnl_unregister_all(int protocol) 485 { 486 struct rtnl_link __rcu **tab; 487 struct rtnl_link *link; 488 int msgindex; 489 490 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX); 491 492 rtnl_lock(); 493 tab = rcu_replace_pointer_rtnl(rtnl_msg_handlers[protocol], NULL); 494 if (!tab) { 495 rtnl_unlock(); 496 return; 497 } 498 for (msgindex = 0; msgindex < RTM_NR_MSGTYPES; msgindex++) { 499 link = rcu_replace_pointer_rtnl(tab[msgindex], NULL); 500 kfree_rcu(link, rcu); 501 } 502 rtnl_unlock(); 503 504 synchronize_net(); 505 506 kfree(tab); 507 } 508 EXPORT_SYMBOL_GPL(rtnl_unregister_all); 509 510 /** 511 * __rtnl_register_many - Register rtnetlink message types 512 * @handlers: Array of struct rtnl_msg_handlers 513 * @n: The length of @handlers 514 * 515 * Registers the specified function pointers (at least one of them has 516 * to be non-NULL) to be called whenever a request message for the 517 * specified protocol family and message type is received. 518 * 519 * The special protocol family PF_UNSPEC may be used to define fallback 520 * function pointers for the case when no entry for the specific protocol 521 * family exists. 522 * 523 * When one element of @handlers fails to register, 524 * 1) built-in: panics. 525 * 2) modules : the previous successful registrations are unwinded 526 * and an error is returned. 527 * 528 * Use rtnl_register_many(). 529 */ 530 int __rtnl_register_many(const struct rtnl_msg_handler *handlers, int n) 531 { 532 const struct rtnl_msg_handler *handler; 533 int i, err; 534 535 for (i = 0, handler = handlers; i < n; i++, handler++) { 536 err = rtnl_register_internal(handler->owner, handler->protocol, 537 handler->msgtype, handler->doit, 538 handler->dumpit, handler->flags); 539 if (err) { 540 if (!handler->owner) 541 panic("Unable to register rtnetlink message " 542 "handlers, %pS\n", handlers); 543 544 __rtnl_unregister_many(handlers, i); 545 break; 546 } 547 } 548 549 return err; 550 } 551 EXPORT_SYMBOL_GPL(__rtnl_register_many); 552 553 void __rtnl_unregister_many(const struct rtnl_msg_handler *handlers, int n) 554 { 555 const struct rtnl_msg_handler *handler; 556 int i; 557 558 for (i = n - 1, handler = handlers + n - 1; i >= 0; i--, handler--) 559 rtnl_unregister(handler->protocol, handler->msgtype); 560 } 561 EXPORT_SYMBOL_GPL(__rtnl_unregister_many); 562 563 static DEFINE_MUTEX(link_ops_mutex); 564 static LIST_HEAD(link_ops); 565 566 static struct rtnl_link_ops *rtnl_link_ops_get(const char *kind, int *srcu_index) 567 { 568 struct rtnl_link_ops *ops; 569 570 rcu_read_lock(); 571 572 list_for_each_entry_rcu(ops, &link_ops, list) { 573 if (!strcmp(ops->kind, kind)) { 574 *srcu_index = srcu_read_lock(&ops->srcu); 575 goto unlock; 576 } 577 } 578 579 ops = NULL; 580 unlock: 581 rcu_read_unlock(); 582 583 return ops; 584 } 585 586 static void rtnl_link_ops_put(struct rtnl_link_ops *ops, int srcu_index) 587 { 588 srcu_read_unlock(&ops->srcu, srcu_index); 589 } 590 591 /** 592 * rtnl_link_register - Register rtnl_link_ops with rtnetlink. 593 * @ops: struct rtnl_link_ops * to register 594 * 595 * Returns 0 on success or a negative error code. 596 */ 597 int rtnl_link_register(struct rtnl_link_ops *ops) 598 { 599 struct rtnl_link_ops *tmp; 600 int err; 601 602 /* Sanity-check max sizes to avoid stack buffer overflow. */ 603 if (WARN_ON(ops->maxtype > RTNL_MAX_TYPE || 604 ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE)) 605 return -EINVAL; 606 607 /* The check for alloc/setup is here because if ops 608 * does not have that filled up, it is not possible 609 * to use the ops for creating device. So do not 610 * fill up dellink as well. That disables rtnl_dellink. 611 */ 612 if ((ops->alloc || ops->setup) && !ops->dellink) 613 ops->dellink = unregister_netdevice_queue; 614 615 err = init_srcu_struct(&ops->srcu); 616 if (err) 617 return err; 618 619 mutex_lock(&link_ops_mutex); 620 621 list_for_each_entry(tmp, &link_ops, list) { 622 if (!strcmp(ops->kind, tmp->kind)) { 623 err = -EEXIST; 624 goto unlock; 625 } 626 } 627 628 list_add_tail_rcu(&ops->list, &link_ops); 629 unlock: 630 mutex_unlock(&link_ops_mutex); 631 632 return err; 633 } 634 EXPORT_SYMBOL_GPL(rtnl_link_register); 635 636 static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops) 637 { 638 struct net_device *dev; 639 LIST_HEAD(list_kill); 640 641 for_each_netdev(net, dev) { 642 if (dev->rtnl_link_ops == ops) 643 ops->dellink(dev, &list_kill); 644 } 645 unregister_netdevice_many(&list_kill); 646 } 647 648 /* Return with the rtnl_lock held when there are no network 649 * devices unregistering in any network namespace. 650 */ 651 static void rtnl_lock_unregistering_all(void) 652 { 653 DEFINE_WAIT_FUNC(wait, woken_wake_function); 654 655 add_wait_queue(&netdev_unregistering_wq, &wait); 656 for (;;) { 657 rtnl_lock(); 658 /* We held write locked pernet_ops_rwsem, and parallel 659 * setup_net() and cleanup_net() are not possible. 660 */ 661 if (!atomic_read(&dev_unreg_count)) 662 break; 663 __rtnl_unlock(); 664 665 wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT); 666 } 667 remove_wait_queue(&netdev_unregistering_wq, &wait); 668 } 669 670 /** 671 * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink. 672 * @ops: struct rtnl_link_ops * to unregister 673 */ 674 void rtnl_link_unregister(struct rtnl_link_ops *ops) 675 { 676 struct net *net; 677 678 mutex_lock(&link_ops_mutex); 679 list_del_rcu(&ops->list); 680 mutex_unlock(&link_ops_mutex); 681 682 synchronize_srcu(&ops->srcu); 683 cleanup_srcu_struct(&ops->srcu); 684 685 /* Close the race with setup_net() and cleanup_net() */ 686 down_write(&pernet_ops_rwsem); 687 rtnl_lock_unregistering_all(); 688 689 for_each_net(net) 690 __rtnl_kill_links(net, ops); 691 692 rtnl_unlock(); 693 up_write(&pernet_ops_rwsem); 694 } 695 EXPORT_SYMBOL_GPL(rtnl_link_unregister); 696 697 static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev) 698 { 699 struct net_device *master_dev; 700 const struct rtnl_link_ops *ops; 701 size_t size = 0; 702 703 rcu_read_lock(); 704 705 master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev); 706 if (!master_dev) 707 goto out; 708 709 ops = master_dev->rtnl_link_ops; 710 if (!ops || !ops->get_slave_size) 711 goto out; 712 /* IFLA_INFO_SLAVE_DATA + nested data */ 713 size = nla_total_size(sizeof(struct nlattr)) + 714 ops->get_slave_size(master_dev, dev); 715 716 out: 717 rcu_read_unlock(); 718 return size; 719 } 720 721 static size_t rtnl_link_get_size(const struct net_device *dev) 722 { 723 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 724 size_t size; 725 726 if (!ops) 727 return 0; 728 729 size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */ 730 nla_total_size(strlen(ops->kind) + 1); /* IFLA_INFO_KIND */ 731 732 if (ops->get_size) 733 /* IFLA_INFO_DATA + nested data */ 734 size += nla_total_size(sizeof(struct nlattr)) + 735 ops->get_size(dev); 736 737 if (ops->get_xstats_size) 738 /* IFLA_INFO_XSTATS */ 739 size += nla_total_size(ops->get_xstats_size(dev)); 740 741 size += rtnl_link_get_slave_info_data_size(dev); 742 743 return size; 744 } 745 746 static LIST_HEAD(rtnl_af_ops); 747 748 static struct rtnl_af_ops *rtnl_af_lookup(const int family, int *srcu_index) 749 { 750 struct rtnl_af_ops *ops; 751 752 ASSERT_RTNL(); 753 754 rcu_read_lock(); 755 756 list_for_each_entry_rcu(ops, &rtnl_af_ops, list) { 757 if (ops->family == family) { 758 *srcu_index = srcu_read_lock(&ops->srcu); 759 goto unlock; 760 } 761 } 762 763 ops = NULL; 764 unlock: 765 rcu_read_unlock(); 766 767 return ops; 768 } 769 770 static void rtnl_af_put(struct rtnl_af_ops *ops, int srcu_index) 771 { 772 srcu_read_unlock(&ops->srcu, srcu_index); 773 } 774 775 /** 776 * rtnl_af_register - Register rtnl_af_ops with rtnetlink. 777 * @ops: struct rtnl_af_ops * to register 778 * 779 * Return: 0 on success or a negative error code. 780 */ 781 int rtnl_af_register(struct rtnl_af_ops *ops) 782 { 783 int err = init_srcu_struct(&ops->srcu); 784 785 if (err) 786 return err; 787 788 rtnl_lock(); 789 list_add_tail_rcu(&ops->list, &rtnl_af_ops); 790 rtnl_unlock(); 791 792 return 0; 793 } 794 EXPORT_SYMBOL_GPL(rtnl_af_register); 795 796 /** 797 * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink. 798 * @ops: struct rtnl_af_ops * to unregister 799 */ 800 void rtnl_af_unregister(struct rtnl_af_ops *ops) 801 { 802 rtnl_lock(); 803 list_del_rcu(&ops->list); 804 rtnl_unlock(); 805 806 synchronize_rcu(); 807 synchronize_srcu(&ops->srcu); 808 cleanup_srcu_struct(&ops->srcu); 809 } 810 EXPORT_SYMBOL_GPL(rtnl_af_unregister); 811 812 static size_t rtnl_link_get_af_size(const struct net_device *dev, 813 u32 ext_filter_mask) 814 { 815 struct rtnl_af_ops *af_ops; 816 size_t size; 817 818 /* IFLA_AF_SPEC */ 819 size = nla_total_size(sizeof(struct nlattr)); 820 821 rcu_read_lock(); 822 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { 823 if (af_ops->get_link_af_size) { 824 /* AF_* + nested data */ 825 size += nla_total_size(sizeof(struct nlattr)) + 826 af_ops->get_link_af_size(dev, ext_filter_mask); 827 } 828 } 829 rcu_read_unlock(); 830 831 return size; 832 } 833 834 static bool rtnl_have_link_slave_info(const struct net_device *dev) 835 { 836 struct net_device *master_dev; 837 bool ret = false; 838 839 rcu_read_lock(); 840 841 master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev); 842 if (master_dev && master_dev->rtnl_link_ops) 843 ret = true; 844 rcu_read_unlock(); 845 return ret; 846 } 847 848 static int rtnl_link_slave_info_fill(struct sk_buff *skb, 849 const struct net_device *dev) 850 { 851 struct net_device *master_dev; 852 const struct rtnl_link_ops *ops; 853 struct nlattr *slave_data; 854 int err; 855 856 master_dev = netdev_master_upper_dev_get((struct net_device *) dev); 857 if (!master_dev) 858 return 0; 859 ops = master_dev->rtnl_link_ops; 860 if (!ops) 861 return 0; 862 if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0) 863 return -EMSGSIZE; 864 if (ops->fill_slave_info) { 865 slave_data = nla_nest_start_noflag(skb, IFLA_INFO_SLAVE_DATA); 866 if (!slave_data) 867 return -EMSGSIZE; 868 err = ops->fill_slave_info(skb, master_dev, dev); 869 if (err < 0) 870 goto err_cancel_slave_data; 871 nla_nest_end(skb, slave_data); 872 } 873 return 0; 874 875 err_cancel_slave_data: 876 nla_nest_cancel(skb, slave_data); 877 return err; 878 } 879 880 static int rtnl_link_info_fill(struct sk_buff *skb, 881 const struct net_device *dev) 882 { 883 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 884 struct nlattr *data; 885 int err; 886 887 if (!ops) 888 return 0; 889 if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0) 890 return -EMSGSIZE; 891 if (ops->fill_xstats) { 892 err = ops->fill_xstats(skb, dev); 893 if (err < 0) 894 return err; 895 } 896 if (ops->fill_info) { 897 data = nla_nest_start_noflag(skb, IFLA_INFO_DATA); 898 if (data == NULL) 899 return -EMSGSIZE; 900 err = ops->fill_info(skb, dev); 901 if (err < 0) 902 goto err_cancel_data; 903 nla_nest_end(skb, data); 904 } 905 return 0; 906 907 err_cancel_data: 908 nla_nest_cancel(skb, data); 909 return err; 910 } 911 912 static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev) 913 { 914 struct nlattr *linkinfo; 915 int err = -EMSGSIZE; 916 917 linkinfo = nla_nest_start_noflag(skb, IFLA_LINKINFO); 918 if (linkinfo == NULL) 919 goto out; 920 921 err = rtnl_link_info_fill(skb, dev); 922 if (err < 0) 923 goto err_cancel_link; 924 925 err = rtnl_link_slave_info_fill(skb, dev); 926 if (err < 0) 927 goto err_cancel_link; 928 929 nla_nest_end(skb, linkinfo); 930 return 0; 931 932 err_cancel_link: 933 nla_nest_cancel(skb, linkinfo); 934 out: 935 return err; 936 } 937 938 int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo) 939 { 940 struct sock *rtnl = net->rtnl; 941 942 return nlmsg_notify(rtnl, skb, pid, group, echo, GFP_KERNEL); 943 } 944 945 int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid) 946 { 947 struct sock *rtnl = net->rtnl; 948 949 return nlmsg_unicast(rtnl, skb, pid); 950 } 951 EXPORT_SYMBOL(rtnl_unicast); 952 953 void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group, 954 const struct nlmsghdr *nlh, gfp_t flags) 955 { 956 struct sock *rtnl = net->rtnl; 957 958 nlmsg_notify(rtnl, skb, pid, group, nlmsg_report(nlh), flags); 959 } 960 EXPORT_SYMBOL(rtnl_notify); 961 962 void rtnl_set_sk_err(struct net *net, u32 group, int error) 963 { 964 struct sock *rtnl = net->rtnl; 965 966 netlink_set_err(rtnl, 0, group, error); 967 } 968 EXPORT_SYMBOL(rtnl_set_sk_err); 969 970 int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics) 971 { 972 struct nlattr *mx; 973 int i, valid = 0; 974 975 /* nothing is dumped for dst_default_metrics, so just skip the loop */ 976 if (metrics == dst_default_metrics.metrics) 977 return 0; 978 979 mx = nla_nest_start_noflag(skb, RTA_METRICS); 980 if (mx == NULL) 981 return -ENOBUFS; 982 983 for (i = 0; i < RTAX_MAX; i++) { 984 if (metrics[i]) { 985 if (i == RTAX_CC_ALGO - 1) { 986 char tmp[TCP_CA_NAME_MAX], *name; 987 988 name = tcp_ca_get_name_by_key(metrics[i], tmp); 989 if (!name) 990 continue; 991 if (nla_put_string(skb, i + 1, name)) 992 goto nla_put_failure; 993 } else if (i == RTAX_FEATURES - 1) { 994 u32 user_features = metrics[i] & RTAX_FEATURE_MASK; 995 996 if (!user_features) 997 continue; 998 BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK); 999 if (nla_put_u32(skb, i + 1, user_features)) 1000 goto nla_put_failure; 1001 } else { 1002 if (nla_put_u32(skb, i + 1, metrics[i])) 1003 goto nla_put_failure; 1004 } 1005 valid++; 1006 } 1007 } 1008 1009 if (!valid) { 1010 nla_nest_cancel(skb, mx); 1011 return 0; 1012 } 1013 1014 return nla_nest_end(skb, mx); 1015 1016 nla_put_failure: 1017 nla_nest_cancel(skb, mx); 1018 return -EMSGSIZE; 1019 } 1020 EXPORT_SYMBOL(rtnetlink_put_metrics); 1021 1022 int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id, 1023 long expires, u32 error) 1024 { 1025 struct rta_cacheinfo ci = { 1026 .rta_error = error, 1027 .rta_id = id, 1028 }; 1029 1030 if (dst) { 1031 ci.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse); 1032 ci.rta_used = dst->__use; 1033 ci.rta_clntref = rcuref_read(&dst->__rcuref); 1034 } 1035 if (expires) { 1036 unsigned long clock; 1037 1038 clock = jiffies_to_clock_t(abs(expires)); 1039 clock = min_t(unsigned long, clock, INT_MAX); 1040 ci.rta_expires = (expires > 0) ? clock : -clock; 1041 } 1042 return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci); 1043 } 1044 EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo); 1045 1046 void netif_set_operstate(struct net_device *dev, int newstate) 1047 { 1048 unsigned int old = READ_ONCE(dev->operstate); 1049 1050 do { 1051 if (old == newstate) 1052 return; 1053 } while (!try_cmpxchg(&dev->operstate, &old, newstate)); 1054 1055 netif_state_change(dev); 1056 } 1057 EXPORT_SYMBOL(netif_set_operstate); 1058 1059 static void set_operstate(struct net_device *dev, unsigned char transition) 1060 { 1061 unsigned char operstate = READ_ONCE(dev->operstate); 1062 1063 switch (transition) { 1064 case IF_OPER_UP: 1065 if ((operstate == IF_OPER_DORMANT || 1066 operstate == IF_OPER_TESTING || 1067 operstate == IF_OPER_UNKNOWN) && 1068 !netif_dormant(dev) && !netif_testing(dev)) 1069 operstate = IF_OPER_UP; 1070 break; 1071 1072 case IF_OPER_TESTING: 1073 if (netif_oper_up(dev)) 1074 operstate = IF_OPER_TESTING; 1075 break; 1076 1077 case IF_OPER_DORMANT: 1078 if (netif_oper_up(dev)) 1079 operstate = IF_OPER_DORMANT; 1080 break; 1081 } 1082 1083 netif_set_operstate(dev, operstate); 1084 } 1085 1086 static unsigned int rtnl_dev_get_flags(const struct net_device *dev) 1087 { 1088 return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) | 1089 (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI)); 1090 } 1091 1092 static unsigned int rtnl_dev_combine_flags(const struct net_device *dev, 1093 const struct ifinfomsg *ifm) 1094 { 1095 unsigned int flags = ifm->ifi_flags; 1096 1097 /* bugwards compatibility: ifi_change == 0 is treated as ~0 */ 1098 if (ifm->ifi_change) 1099 flags = (flags & ifm->ifi_change) | 1100 (rtnl_dev_get_flags(dev) & ~ifm->ifi_change); 1101 1102 return flags; 1103 } 1104 1105 static void copy_rtnl_link_stats(struct rtnl_link_stats *a, 1106 const struct rtnl_link_stats64 *b) 1107 { 1108 a->rx_packets = b->rx_packets; 1109 a->tx_packets = b->tx_packets; 1110 a->rx_bytes = b->rx_bytes; 1111 a->tx_bytes = b->tx_bytes; 1112 a->rx_errors = b->rx_errors; 1113 a->tx_errors = b->tx_errors; 1114 a->rx_dropped = b->rx_dropped; 1115 a->tx_dropped = b->tx_dropped; 1116 1117 a->multicast = b->multicast; 1118 a->collisions = b->collisions; 1119 1120 a->rx_length_errors = b->rx_length_errors; 1121 a->rx_over_errors = b->rx_over_errors; 1122 a->rx_crc_errors = b->rx_crc_errors; 1123 a->rx_frame_errors = b->rx_frame_errors; 1124 a->rx_fifo_errors = b->rx_fifo_errors; 1125 a->rx_missed_errors = b->rx_missed_errors; 1126 1127 a->tx_aborted_errors = b->tx_aborted_errors; 1128 a->tx_carrier_errors = b->tx_carrier_errors; 1129 a->tx_fifo_errors = b->tx_fifo_errors; 1130 a->tx_heartbeat_errors = b->tx_heartbeat_errors; 1131 a->tx_window_errors = b->tx_window_errors; 1132 1133 a->rx_compressed = b->rx_compressed; 1134 a->tx_compressed = b->tx_compressed; 1135 1136 a->rx_nohandler = b->rx_nohandler; 1137 } 1138 1139 /* All VF info */ 1140 static inline int rtnl_vfinfo_size(const struct net_device *dev, 1141 u32 ext_filter_mask) 1142 { 1143 if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) { 1144 int num_vfs = dev_num_vf(dev->dev.parent); 1145 size_t size = nla_total_size(0); 1146 size += num_vfs * 1147 (nla_total_size(0) + 1148 nla_total_size(sizeof(struct ifla_vf_mac)) + 1149 nla_total_size(sizeof(struct ifla_vf_broadcast)) + 1150 nla_total_size(sizeof(struct ifla_vf_vlan)) + 1151 nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */ 1152 nla_total_size(MAX_VLAN_LIST_LEN * 1153 sizeof(struct ifla_vf_vlan_info)) + 1154 nla_total_size(sizeof(struct ifla_vf_spoofchk)) + 1155 nla_total_size(sizeof(struct ifla_vf_tx_rate)) + 1156 nla_total_size(sizeof(struct ifla_vf_rate)) + 1157 nla_total_size(sizeof(struct ifla_vf_link_state)) + 1158 nla_total_size(sizeof(struct ifla_vf_rss_query_en)) + 1159 nla_total_size(sizeof(struct ifla_vf_trust))); 1160 if (~ext_filter_mask & RTEXT_FILTER_SKIP_STATS) { 1161 size += num_vfs * 1162 (nla_total_size(0) + /* nest IFLA_VF_STATS */ 1163 /* IFLA_VF_STATS_RX_PACKETS */ 1164 nla_total_size_64bit(sizeof(__u64)) + 1165 /* IFLA_VF_STATS_TX_PACKETS */ 1166 nla_total_size_64bit(sizeof(__u64)) + 1167 /* IFLA_VF_STATS_RX_BYTES */ 1168 nla_total_size_64bit(sizeof(__u64)) + 1169 /* IFLA_VF_STATS_TX_BYTES */ 1170 nla_total_size_64bit(sizeof(__u64)) + 1171 /* IFLA_VF_STATS_BROADCAST */ 1172 nla_total_size_64bit(sizeof(__u64)) + 1173 /* IFLA_VF_STATS_MULTICAST */ 1174 nla_total_size_64bit(sizeof(__u64)) + 1175 /* IFLA_VF_STATS_RX_DROPPED */ 1176 nla_total_size_64bit(sizeof(__u64)) + 1177 /* IFLA_VF_STATS_TX_DROPPED */ 1178 nla_total_size_64bit(sizeof(__u64))); 1179 } 1180 if (dev->netdev_ops->ndo_get_vf_guid) 1181 size += num_vfs * 2 * 1182 nla_total_size(sizeof(struct ifla_vf_guid)); 1183 return size; 1184 } else 1185 return 0; 1186 } 1187 1188 static size_t rtnl_port_size(const struct net_device *dev, 1189 u32 ext_filter_mask) 1190 { 1191 size_t port_size = nla_total_size(4) /* PORT_VF */ 1192 + nla_total_size(PORT_PROFILE_MAX) /* PORT_PROFILE */ 1193 + nla_total_size(PORT_UUID_MAX) /* PORT_INSTANCE_UUID */ 1194 + nla_total_size(PORT_UUID_MAX) /* PORT_HOST_UUID */ 1195 + nla_total_size(1) /* PROT_VDP_REQUEST */ 1196 + nla_total_size(2); /* PORT_VDP_RESPONSE */ 1197 size_t vf_ports_size = nla_total_size(sizeof(struct nlattr)); 1198 size_t vf_port_size = nla_total_size(sizeof(struct nlattr)) 1199 + port_size; 1200 size_t port_self_size = nla_total_size(sizeof(struct nlattr)) 1201 + port_size; 1202 1203 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent || 1204 !(ext_filter_mask & RTEXT_FILTER_VF)) 1205 return 0; 1206 if (dev_num_vf(dev->dev.parent)) 1207 return port_self_size + vf_ports_size + 1208 vf_port_size * dev_num_vf(dev->dev.parent); 1209 else 1210 return port_self_size; 1211 } 1212 1213 static size_t rtnl_xdp_size(void) 1214 { 1215 size_t xdp_size = nla_total_size(0) + /* nest IFLA_XDP */ 1216 nla_total_size(1) + /* XDP_ATTACHED */ 1217 nla_total_size(4) + /* XDP_PROG_ID (or 1st mode) */ 1218 nla_total_size(4); /* XDP_<mode>_PROG_ID */ 1219 1220 return xdp_size; 1221 } 1222 1223 static size_t rtnl_prop_list_size(const struct net_device *dev) 1224 { 1225 struct netdev_name_node *name_node; 1226 unsigned int cnt = 0; 1227 1228 rcu_read_lock(); 1229 list_for_each_entry_rcu(name_node, &dev->name_node->list, list) 1230 cnt++; 1231 rcu_read_unlock(); 1232 1233 if (!cnt) 1234 return 0; 1235 1236 return nla_total_size(0) + cnt * nla_total_size(ALTIFNAMSIZ); 1237 } 1238 1239 static size_t rtnl_proto_down_size(const struct net_device *dev) 1240 { 1241 size_t size = nla_total_size(1); 1242 1243 /* Assume dev->proto_down_reason is not zero. */ 1244 size += nla_total_size(0) + nla_total_size(4); 1245 1246 return size; 1247 } 1248 1249 static size_t rtnl_devlink_port_size(const struct net_device *dev) 1250 { 1251 size_t size = nla_total_size(0); /* nest IFLA_DEVLINK_PORT */ 1252 1253 if (dev->devlink_port) 1254 size += devlink_nl_port_handle_size(dev->devlink_port); 1255 1256 return size; 1257 } 1258 1259 static size_t rtnl_dpll_pin_size(const struct net_device *dev) 1260 { 1261 size_t size = nla_total_size(0); /* nest IFLA_DPLL_PIN */ 1262 1263 size += dpll_netdev_pin_handle_size(dev); 1264 1265 return size; 1266 } 1267 1268 static noinline size_t if_nlmsg_size(const struct net_device *dev, 1269 u32 ext_filter_mask) 1270 { 1271 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 1272 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 1273 + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */ 1274 + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */ 1275 + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap)) 1276 + nla_total_size(sizeof(struct rtnl_link_stats)) 1277 + nla_total_size_64bit(sizeof(struct rtnl_link_stats64)) 1278 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 1279 + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */ 1280 + nla_total_size(4) /* IFLA_TXQLEN */ 1281 + nla_total_size(4) /* IFLA_WEIGHT */ 1282 + nla_total_size(4) /* IFLA_MTU */ 1283 + nla_total_size(4) /* IFLA_LINK */ 1284 + nla_total_size(4) /* IFLA_MASTER */ 1285 + nla_total_size(1) /* IFLA_CARRIER */ 1286 + nla_total_size(4) /* IFLA_PROMISCUITY */ 1287 + nla_total_size(4) /* IFLA_ALLMULTI */ 1288 + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */ 1289 + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */ 1290 + nla_total_size(4) /* IFLA_GSO_MAX_SEGS */ 1291 + nla_total_size(4) /* IFLA_GSO_MAX_SIZE */ 1292 + nla_total_size(4) /* IFLA_GRO_MAX_SIZE */ 1293 + nla_total_size(4) /* IFLA_GSO_IPV4_MAX_SIZE */ 1294 + nla_total_size(4) /* IFLA_GRO_IPV4_MAX_SIZE */ 1295 + nla_total_size(4) /* IFLA_TSO_MAX_SIZE */ 1296 + nla_total_size(4) /* IFLA_TSO_MAX_SEGS */ 1297 + nla_total_size(1) /* IFLA_OPERSTATE */ 1298 + nla_total_size(1) /* IFLA_LINKMODE */ 1299 + nla_total_size(1) /* IFLA_NETNS_IMMUTABLE */ 1300 + nla_total_size(4) /* IFLA_CARRIER_CHANGES */ 1301 + nla_total_size(4) /* IFLA_LINK_NETNSID */ 1302 + nla_total_size(4) /* IFLA_GROUP */ 1303 + nla_total_size(ext_filter_mask 1304 & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */ 1305 + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */ 1306 + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */ 1307 + rtnl_link_get_size(dev) /* IFLA_LINKINFO */ 1308 + rtnl_link_get_af_size(dev, ext_filter_mask) /* IFLA_AF_SPEC */ 1309 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */ 1310 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */ 1311 + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */ 1312 + rtnl_xdp_size() /* IFLA_XDP */ 1313 + nla_total_size(4) /* IFLA_EVENT */ 1314 + nla_total_size(4) /* IFLA_NEW_NETNSID */ 1315 + nla_total_size(4) /* IFLA_NEW_IFINDEX */ 1316 + rtnl_proto_down_size(dev) /* proto down */ 1317 + nla_total_size(4) /* IFLA_TARGET_NETNSID */ 1318 + nla_total_size(4) /* IFLA_CARRIER_UP_COUNT */ 1319 + nla_total_size(4) /* IFLA_CARRIER_DOWN_COUNT */ 1320 + nla_total_size(4) /* IFLA_MIN_MTU */ 1321 + nla_total_size(4) /* IFLA_MAX_MTU */ 1322 + rtnl_prop_list_size(dev) 1323 + nla_total_size(MAX_ADDR_LEN) /* IFLA_PERM_ADDRESS */ 1324 + rtnl_devlink_port_size(dev) 1325 + rtnl_dpll_pin_size(dev) 1326 + nla_total_size(8) /* IFLA_MAX_PACING_OFFLOAD_HORIZON */ 1327 + 0; 1328 } 1329 1330 static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev) 1331 { 1332 struct nlattr *vf_ports; 1333 struct nlattr *vf_port; 1334 int vf; 1335 int err; 1336 1337 vf_ports = nla_nest_start_noflag(skb, IFLA_VF_PORTS); 1338 if (!vf_ports) 1339 return -EMSGSIZE; 1340 1341 for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) { 1342 vf_port = nla_nest_start_noflag(skb, IFLA_VF_PORT); 1343 if (!vf_port) 1344 goto nla_put_failure; 1345 if (nla_put_u32(skb, IFLA_PORT_VF, vf)) 1346 goto nla_put_failure; 1347 err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb); 1348 if (err == -EMSGSIZE) 1349 goto nla_put_failure; 1350 if (err) { 1351 nla_nest_cancel(skb, vf_port); 1352 continue; 1353 } 1354 nla_nest_end(skb, vf_port); 1355 } 1356 1357 nla_nest_end(skb, vf_ports); 1358 1359 return 0; 1360 1361 nla_put_failure: 1362 nla_nest_cancel(skb, vf_ports); 1363 return -EMSGSIZE; 1364 } 1365 1366 static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev) 1367 { 1368 struct nlattr *port_self; 1369 int err; 1370 1371 port_self = nla_nest_start_noflag(skb, IFLA_PORT_SELF); 1372 if (!port_self) 1373 return -EMSGSIZE; 1374 1375 err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb); 1376 if (err) { 1377 nla_nest_cancel(skb, port_self); 1378 return (err == -EMSGSIZE) ? err : 0; 1379 } 1380 1381 nla_nest_end(skb, port_self); 1382 1383 return 0; 1384 } 1385 1386 static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev, 1387 u32 ext_filter_mask) 1388 { 1389 int err; 1390 1391 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent || 1392 !(ext_filter_mask & RTEXT_FILTER_VF)) 1393 return 0; 1394 1395 err = rtnl_port_self_fill(skb, dev); 1396 if (err) 1397 return err; 1398 1399 if (dev_num_vf(dev->dev.parent)) { 1400 err = rtnl_vf_ports_fill(skb, dev); 1401 if (err) 1402 return err; 1403 } 1404 1405 return 0; 1406 } 1407 1408 static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev) 1409 { 1410 int err; 1411 struct netdev_phys_item_id ppid; 1412 1413 err = dev_get_phys_port_id(dev, &ppid); 1414 if (err) { 1415 if (err == -EOPNOTSUPP) 1416 return 0; 1417 return err; 1418 } 1419 1420 if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id)) 1421 return -EMSGSIZE; 1422 1423 return 0; 1424 } 1425 1426 static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev) 1427 { 1428 char name[IFNAMSIZ]; 1429 int err; 1430 1431 err = dev_get_phys_port_name(dev, name, sizeof(name)); 1432 if (err) { 1433 if (err == -EOPNOTSUPP) 1434 return 0; 1435 return err; 1436 } 1437 1438 if (nla_put_string(skb, IFLA_PHYS_PORT_NAME, name)) 1439 return -EMSGSIZE; 1440 1441 return 0; 1442 } 1443 1444 static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev) 1445 { 1446 struct netdev_phys_item_id ppid = { }; 1447 int err; 1448 1449 err = dev_get_port_parent_id(dev, &ppid, false); 1450 if (err) { 1451 if (err == -EOPNOTSUPP) 1452 return 0; 1453 return err; 1454 } 1455 1456 if (nla_put(skb, IFLA_PHYS_SWITCH_ID, ppid.id_len, ppid.id)) 1457 return -EMSGSIZE; 1458 1459 return 0; 1460 } 1461 1462 static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb, 1463 struct net_device *dev) 1464 { 1465 struct rtnl_link_stats64 *sp; 1466 struct nlattr *attr; 1467 1468 attr = nla_reserve_64bit(skb, IFLA_STATS64, 1469 sizeof(struct rtnl_link_stats64), IFLA_PAD); 1470 if (!attr) 1471 return -EMSGSIZE; 1472 1473 sp = nla_data(attr); 1474 dev_get_stats(dev, sp); 1475 1476 attr = nla_reserve(skb, IFLA_STATS, 1477 sizeof(struct rtnl_link_stats)); 1478 if (!attr) 1479 return -EMSGSIZE; 1480 1481 copy_rtnl_link_stats(nla_data(attr), sp); 1482 1483 return 0; 1484 } 1485 1486 static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb, 1487 struct net_device *dev, 1488 int vfs_num, 1489 u32 ext_filter_mask) 1490 { 1491 struct ifla_vf_rss_query_en vf_rss_query_en; 1492 struct nlattr *vf, *vfstats, *vfvlanlist; 1493 struct ifla_vf_link_state vf_linkstate; 1494 struct ifla_vf_vlan_info vf_vlan_info; 1495 struct ifla_vf_spoofchk vf_spoofchk; 1496 struct ifla_vf_tx_rate vf_tx_rate; 1497 struct ifla_vf_stats vf_stats; 1498 struct ifla_vf_trust vf_trust; 1499 struct ifla_vf_vlan vf_vlan; 1500 struct ifla_vf_rate vf_rate; 1501 struct ifla_vf_mac vf_mac; 1502 struct ifla_vf_broadcast vf_broadcast; 1503 struct ifla_vf_info ivi; 1504 struct ifla_vf_guid node_guid; 1505 struct ifla_vf_guid port_guid; 1506 1507 memset(&ivi, 0, sizeof(ivi)); 1508 1509 /* Not all SR-IOV capable drivers support the 1510 * spoofcheck and "RSS query enable" query. Preset to 1511 * -1 so the user space tool can detect that the driver 1512 * didn't report anything. 1513 */ 1514 ivi.spoofchk = -1; 1515 ivi.rss_query_en = -1; 1516 ivi.trusted = -1; 1517 /* The default value for VF link state is "auto" 1518 * IFLA_VF_LINK_STATE_AUTO which equals zero 1519 */ 1520 ivi.linkstate = 0; 1521 /* VLAN Protocol by default is 802.1Q */ 1522 ivi.vlan_proto = htons(ETH_P_8021Q); 1523 if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi)) 1524 return 0; 1525 1526 memset(&vf_vlan_info, 0, sizeof(vf_vlan_info)); 1527 memset(&node_guid, 0, sizeof(node_guid)); 1528 memset(&port_guid, 0, sizeof(port_guid)); 1529 1530 vf_mac.vf = 1531 vf_vlan.vf = 1532 vf_vlan_info.vf = 1533 vf_rate.vf = 1534 vf_tx_rate.vf = 1535 vf_spoofchk.vf = 1536 vf_linkstate.vf = 1537 vf_rss_query_en.vf = 1538 vf_trust.vf = 1539 node_guid.vf = 1540 port_guid.vf = ivi.vf; 1541 1542 memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac)); 1543 memcpy(vf_broadcast.broadcast, dev->broadcast, dev->addr_len); 1544 vf_vlan.vlan = ivi.vlan; 1545 vf_vlan.qos = ivi.qos; 1546 vf_vlan_info.vlan = ivi.vlan; 1547 vf_vlan_info.qos = ivi.qos; 1548 vf_vlan_info.vlan_proto = ivi.vlan_proto; 1549 vf_tx_rate.rate = ivi.max_tx_rate; 1550 vf_rate.min_tx_rate = ivi.min_tx_rate; 1551 vf_rate.max_tx_rate = ivi.max_tx_rate; 1552 vf_spoofchk.setting = ivi.spoofchk; 1553 vf_linkstate.link_state = ivi.linkstate; 1554 vf_rss_query_en.setting = ivi.rss_query_en; 1555 vf_trust.setting = ivi.trusted; 1556 vf = nla_nest_start_noflag(skb, IFLA_VF_INFO); 1557 if (!vf) 1558 return -EMSGSIZE; 1559 if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) || 1560 nla_put(skb, IFLA_VF_BROADCAST, sizeof(vf_broadcast), &vf_broadcast) || 1561 nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) || 1562 nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate), 1563 &vf_rate) || 1564 nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate), 1565 &vf_tx_rate) || 1566 nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk), 1567 &vf_spoofchk) || 1568 nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate), 1569 &vf_linkstate) || 1570 nla_put(skb, IFLA_VF_RSS_QUERY_EN, 1571 sizeof(vf_rss_query_en), 1572 &vf_rss_query_en) || 1573 nla_put(skb, IFLA_VF_TRUST, 1574 sizeof(vf_trust), &vf_trust)) 1575 goto nla_put_vf_failure; 1576 1577 if (dev->netdev_ops->ndo_get_vf_guid && 1578 !dev->netdev_ops->ndo_get_vf_guid(dev, vfs_num, &node_guid, 1579 &port_guid)) { 1580 if (nla_put(skb, IFLA_VF_IB_NODE_GUID, sizeof(node_guid), 1581 &node_guid) || 1582 nla_put(skb, IFLA_VF_IB_PORT_GUID, sizeof(port_guid), 1583 &port_guid)) 1584 goto nla_put_vf_failure; 1585 } 1586 vfvlanlist = nla_nest_start_noflag(skb, IFLA_VF_VLAN_LIST); 1587 if (!vfvlanlist) 1588 goto nla_put_vf_failure; 1589 if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info), 1590 &vf_vlan_info)) { 1591 nla_nest_cancel(skb, vfvlanlist); 1592 goto nla_put_vf_failure; 1593 } 1594 nla_nest_end(skb, vfvlanlist); 1595 if (~ext_filter_mask & RTEXT_FILTER_SKIP_STATS) { 1596 memset(&vf_stats, 0, sizeof(vf_stats)); 1597 if (dev->netdev_ops->ndo_get_vf_stats) 1598 dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num, 1599 &vf_stats); 1600 vfstats = nla_nest_start_noflag(skb, IFLA_VF_STATS); 1601 if (!vfstats) 1602 goto nla_put_vf_failure; 1603 if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, 1604 vf_stats.rx_packets, IFLA_VF_STATS_PAD) || 1605 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, 1606 vf_stats.tx_packets, IFLA_VF_STATS_PAD) || 1607 nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, 1608 vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || 1609 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, 1610 vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || 1611 nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, 1612 vf_stats.broadcast, IFLA_VF_STATS_PAD) || 1613 nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, 1614 vf_stats.multicast, IFLA_VF_STATS_PAD) || 1615 nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, 1616 vf_stats.rx_dropped, IFLA_VF_STATS_PAD) || 1617 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED, 1618 vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) { 1619 nla_nest_cancel(skb, vfstats); 1620 goto nla_put_vf_failure; 1621 } 1622 nla_nest_end(skb, vfstats); 1623 } 1624 nla_nest_end(skb, vf); 1625 return 0; 1626 1627 nla_put_vf_failure: 1628 nla_nest_cancel(skb, vf); 1629 return -EMSGSIZE; 1630 } 1631 1632 static noinline_for_stack int rtnl_fill_vf(struct sk_buff *skb, 1633 struct net_device *dev, 1634 u32 ext_filter_mask) 1635 { 1636 struct nlattr *vfinfo; 1637 int i, num_vfs; 1638 1639 if (!dev->dev.parent || ((ext_filter_mask & RTEXT_FILTER_VF) == 0)) 1640 return 0; 1641 1642 num_vfs = dev_num_vf(dev->dev.parent); 1643 if (nla_put_u32(skb, IFLA_NUM_VF, num_vfs)) 1644 return -EMSGSIZE; 1645 1646 if (!dev->netdev_ops->ndo_get_vf_config) 1647 return 0; 1648 1649 vfinfo = nla_nest_start_noflag(skb, IFLA_VFINFO_LIST); 1650 if (!vfinfo) 1651 return -EMSGSIZE; 1652 1653 for (i = 0; i < num_vfs; i++) { 1654 if (rtnl_fill_vfinfo(skb, dev, i, ext_filter_mask)) { 1655 nla_nest_cancel(skb, vfinfo); 1656 return -EMSGSIZE; 1657 } 1658 } 1659 1660 nla_nest_end(skb, vfinfo); 1661 return 0; 1662 } 1663 1664 static int rtnl_fill_link_ifmap(struct sk_buff *skb, 1665 const struct net_device *dev) 1666 { 1667 struct rtnl_link_ifmap map; 1668 1669 memset(&map, 0, sizeof(map)); 1670 map.mem_start = READ_ONCE(dev->mem_start); 1671 map.mem_end = READ_ONCE(dev->mem_end); 1672 map.base_addr = READ_ONCE(dev->base_addr); 1673 map.irq = READ_ONCE(dev->irq); 1674 map.dma = READ_ONCE(dev->dma); 1675 map.port = READ_ONCE(dev->if_port); 1676 1677 if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD)) 1678 return -EMSGSIZE; 1679 1680 return 0; 1681 } 1682 1683 static u32 rtnl_xdp_prog_skb(struct net_device *dev) 1684 { 1685 const struct bpf_prog *generic_xdp_prog; 1686 u32 res = 0; 1687 1688 rcu_read_lock(); 1689 generic_xdp_prog = rcu_dereference(dev->xdp_prog); 1690 if (generic_xdp_prog) 1691 res = generic_xdp_prog->aux->id; 1692 rcu_read_unlock(); 1693 1694 return res; 1695 } 1696 1697 static u32 rtnl_xdp_prog_drv(struct net_device *dev) 1698 { 1699 return dev_xdp_prog_id(dev, XDP_MODE_DRV); 1700 } 1701 1702 static u32 rtnl_xdp_prog_hw(struct net_device *dev) 1703 { 1704 return dev_xdp_prog_id(dev, XDP_MODE_HW); 1705 } 1706 1707 static int rtnl_xdp_report_one(struct sk_buff *skb, struct net_device *dev, 1708 u32 *prog_id, u8 *mode, u8 tgt_mode, u32 attr, 1709 u32 (*get_prog_id)(struct net_device *dev)) 1710 { 1711 u32 curr_id; 1712 int err; 1713 1714 curr_id = get_prog_id(dev); 1715 if (!curr_id) 1716 return 0; 1717 1718 *prog_id = curr_id; 1719 err = nla_put_u32(skb, attr, curr_id); 1720 if (err) 1721 return err; 1722 1723 if (*mode != XDP_ATTACHED_NONE) 1724 *mode = XDP_ATTACHED_MULTI; 1725 else 1726 *mode = tgt_mode; 1727 1728 return 0; 1729 } 1730 1731 static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev) 1732 { 1733 struct nlattr *xdp; 1734 u32 prog_id; 1735 int err; 1736 u8 mode; 1737 1738 xdp = nla_nest_start_noflag(skb, IFLA_XDP); 1739 if (!xdp) 1740 return -EMSGSIZE; 1741 1742 prog_id = 0; 1743 mode = XDP_ATTACHED_NONE; 1744 err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_SKB, 1745 IFLA_XDP_SKB_PROG_ID, rtnl_xdp_prog_skb); 1746 if (err) 1747 goto err_cancel; 1748 err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_DRV, 1749 IFLA_XDP_DRV_PROG_ID, rtnl_xdp_prog_drv); 1750 if (err) 1751 goto err_cancel; 1752 err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_HW, 1753 IFLA_XDP_HW_PROG_ID, rtnl_xdp_prog_hw); 1754 if (err) 1755 goto err_cancel; 1756 1757 err = nla_put_u8(skb, IFLA_XDP_ATTACHED, mode); 1758 if (err) 1759 goto err_cancel; 1760 1761 if (prog_id && mode != XDP_ATTACHED_MULTI) { 1762 err = nla_put_u32(skb, IFLA_XDP_PROG_ID, prog_id); 1763 if (err) 1764 goto err_cancel; 1765 } 1766 1767 nla_nest_end(skb, xdp); 1768 return 0; 1769 1770 err_cancel: 1771 nla_nest_cancel(skb, xdp); 1772 return err; 1773 } 1774 1775 static u32 rtnl_get_event(unsigned long event) 1776 { 1777 u32 rtnl_event_type = IFLA_EVENT_NONE; 1778 1779 switch (event) { 1780 case NETDEV_REBOOT: 1781 rtnl_event_type = IFLA_EVENT_REBOOT; 1782 break; 1783 case NETDEV_FEAT_CHANGE: 1784 rtnl_event_type = IFLA_EVENT_FEATURES; 1785 break; 1786 case NETDEV_BONDING_FAILOVER: 1787 rtnl_event_type = IFLA_EVENT_BONDING_FAILOVER; 1788 break; 1789 case NETDEV_NOTIFY_PEERS: 1790 rtnl_event_type = IFLA_EVENT_NOTIFY_PEERS; 1791 break; 1792 case NETDEV_RESEND_IGMP: 1793 rtnl_event_type = IFLA_EVENT_IGMP_RESEND; 1794 break; 1795 case NETDEV_CHANGEINFODATA: 1796 rtnl_event_type = IFLA_EVENT_BONDING_OPTIONS; 1797 break; 1798 default: 1799 break; 1800 } 1801 1802 return rtnl_event_type; 1803 } 1804 1805 static int put_master_ifindex(struct sk_buff *skb, struct net_device *dev) 1806 { 1807 const struct net_device *upper_dev; 1808 int ret = 0; 1809 1810 rcu_read_lock(); 1811 1812 upper_dev = netdev_master_upper_dev_get_rcu(dev); 1813 if (upper_dev) 1814 ret = nla_put_u32(skb, IFLA_MASTER, 1815 READ_ONCE(upper_dev->ifindex)); 1816 1817 rcu_read_unlock(); 1818 return ret; 1819 } 1820 1821 static int nla_put_iflink(struct sk_buff *skb, const struct net_device *dev, 1822 bool force) 1823 { 1824 int iflink = dev_get_iflink(dev); 1825 1826 if (force || READ_ONCE(dev->ifindex) != iflink) 1827 return nla_put_u32(skb, IFLA_LINK, iflink); 1828 1829 return 0; 1830 } 1831 1832 static noinline_for_stack int nla_put_ifalias(struct sk_buff *skb, 1833 struct net_device *dev) 1834 { 1835 char buf[IFALIASZ]; 1836 int ret; 1837 1838 ret = dev_get_alias(dev, buf, sizeof(buf)); 1839 return ret > 0 ? nla_put_string(skb, IFLA_IFALIAS, buf) : 0; 1840 } 1841 1842 static int rtnl_fill_link_netnsid(struct sk_buff *skb, 1843 const struct net_device *dev, 1844 struct net *src_net, gfp_t gfp) 1845 { 1846 bool put_iflink = false; 1847 1848 if (dev->rtnl_link_ops && dev->rtnl_link_ops->get_link_net) { 1849 struct net *link_net = dev->rtnl_link_ops->get_link_net(dev); 1850 1851 if (!net_eq(dev_net(dev), link_net)) { 1852 int id = peernet2id_alloc(src_net, link_net, gfp); 1853 1854 if (nla_put_s32(skb, IFLA_LINK_NETNSID, id)) 1855 return -EMSGSIZE; 1856 1857 put_iflink = true; 1858 } 1859 } 1860 1861 return nla_put_iflink(skb, dev, put_iflink); 1862 } 1863 1864 static int rtnl_fill_link_af(struct sk_buff *skb, 1865 const struct net_device *dev, 1866 u32 ext_filter_mask) 1867 { 1868 const struct rtnl_af_ops *af_ops; 1869 struct nlattr *af_spec; 1870 1871 af_spec = nla_nest_start_noflag(skb, IFLA_AF_SPEC); 1872 if (!af_spec) 1873 return -EMSGSIZE; 1874 1875 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { 1876 struct nlattr *af; 1877 int err; 1878 1879 if (!af_ops->fill_link_af) 1880 continue; 1881 1882 af = nla_nest_start_noflag(skb, af_ops->family); 1883 if (!af) 1884 return -EMSGSIZE; 1885 1886 err = af_ops->fill_link_af(skb, dev, ext_filter_mask); 1887 /* 1888 * Caller may return ENODATA to indicate that there 1889 * was no data to be dumped. This is not an error, it 1890 * means we should trim the attribute header and 1891 * continue. 1892 */ 1893 if (err == -ENODATA) 1894 nla_nest_cancel(skb, af); 1895 else if (err < 0) 1896 return -EMSGSIZE; 1897 1898 nla_nest_end(skb, af); 1899 } 1900 1901 nla_nest_end(skb, af_spec); 1902 return 0; 1903 } 1904 1905 static int rtnl_fill_alt_ifnames(struct sk_buff *skb, 1906 const struct net_device *dev) 1907 { 1908 struct netdev_name_node *name_node; 1909 int count = 0; 1910 1911 list_for_each_entry_rcu(name_node, &dev->name_node->list, list) { 1912 if (nla_put_string(skb, IFLA_ALT_IFNAME, name_node->name)) 1913 return -EMSGSIZE; 1914 count++; 1915 } 1916 return count; 1917 } 1918 1919 /* RCU protected. */ 1920 static int rtnl_fill_prop_list(struct sk_buff *skb, 1921 const struct net_device *dev) 1922 { 1923 struct nlattr *prop_list; 1924 int ret; 1925 1926 prop_list = nla_nest_start(skb, IFLA_PROP_LIST); 1927 if (!prop_list) 1928 return -EMSGSIZE; 1929 1930 ret = rtnl_fill_alt_ifnames(skb, dev); 1931 if (ret <= 0) 1932 goto nest_cancel; 1933 1934 nla_nest_end(skb, prop_list); 1935 return 0; 1936 1937 nest_cancel: 1938 nla_nest_cancel(skb, prop_list); 1939 return ret; 1940 } 1941 1942 static int rtnl_fill_proto_down(struct sk_buff *skb, 1943 const struct net_device *dev) 1944 { 1945 struct nlattr *pr; 1946 u32 preason; 1947 1948 if (nla_put_u8(skb, IFLA_PROTO_DOWN, READ_ONCE(dev->proto_down))) 1949 goto nla_put_failure; 1950 1951 preason = READ_ONCE(dev->proto_down_reason); 1952 if (!preason) 1953 return 0; 1954 1955 pr = nla_nest_start(skb, IFLA_PROTO_DOWN_REASON); 1956 if (!pr) 1957 return -EMSGSIZE; 1958 1959 if (nla_put_u32(skb, IFLA_PROTO_DOWN_REASON_VALUE, preason)) { 1960 nla_nest_cancel(skb, pr); 1961 goto nla_put_failure; 1962 } 1963 1964 nla_nest_end(skb, pr); 1965 return 0; 1966 1967 nla_put_failure: 1968 return -EMSGSIZE; 1969 } 1970 1971 static int rtnl_fill_devlink_port(struct sk_buff *skb, 1972 const struct net_device *dev) 1973 { 1974 struct nlattr *devlink_port_nest; 1975 int ret; 1976 1977 devlink_port_nest = nla_nest_start(skb, IFLA_DEVLINK_PORT); 1978 if (!devlink_port_nest) 1979 return -EMSGSIZE; 1980 1981 if (dev->devlink_port) { 1982 ret = devlink_nl_port_handle_fill(skb, dev->devlink_port); 1983 if (ret < 0) 1984 goto nest_cancel; 1985 } 1986 1987 nla_nest_end(skb, devlink_port_nest); 1988 return 0; 1989 1990 nest_cancel: 1991 nla_nest_cancel(skb, devlink_port_nest); 1992 return ret; 1993 } 1994 1995 static int rtnl_fill_dpll_pin(struct sk_buff *skb, 1996 const struct net_device *dev) 1997 { 1998 struct nlattr *dpll_pin_nest; 1999 int ret; 2000 2001 dpll_pin_nest = nla_nest_start(skb, IFLA_DPLL_PIN); 2002 if (!dpll_pin_nest) 2003 return -EMSGSIZE; 2004 2005 ret = dpll_netdev_add_pin_handle(skb, dev); 2006 if (ret < 0) 2007 goto nest_cancel; 2008 2009 nla_nest_end(skb, dpll_pin_nest); 2010 return 0; 2011 2012 nest_cancel: 2013 nla_nest_cancel(skb, dpll_pin_nest); 2014 return ret; 2015 } 2016 2017 static int rtnl_fill_ifinfo(struct sk_buff *skb, 2018 struct net_device *dev, struct net *src_net, 2019 int type, u32 pid, u32 seq, u32 change, 2020 unsigned int flags, u32 ext_filter_mask, 2021 u32 event, int *new_nsid, int new_ifindex, 2022 int tgt_netnsid, gfp_t gfp) 2023 { 2024 char devname[IFNAMSIZ]; 2025 struct ifinfomsg *ifm; 2026 struct nlmsghdr *nlh; 2027 struct Qdisc *qdisc; 2028 2029 ASSERT_RTNL(); 2030 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags); 2031 if (nlh == NULL) 2032 return -EMSGSIZE; 2033 2034 ifm = nlmsg_data(nlh); 2035 ifm->ifi_family = AF_UNSPEC; 2036 ifm->__ifi_pad = 0; 2037 ifm->ifi_type = READ_ONCE(dev->type); 2038 ifm->ifi_index = READ_ONCE(dev->ifindex); 2039 ifm->ifi_flags = dev_get_flags(dev); 2040 ifm->ifi_change = change; 2041 2042 if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_TARGET_NETNSID, tgt_netnsid)) 2043 goto nla_put_failure; 2044 2045 netdev_copy_name(dev, devname); 2046 if (nla_put_string(skb, IFLA_IFNAME, devname)) 2047 goto nla_put_failure; 2048 2049 if (nla_put_u32(skb, IFLA_TXQLEN, READ_ONCE(dev->tx_queue_len)) || 2050 nla_put_u8(skb, IFLA_OPERSTATE, 2051 netif_running(dev) ? READ_ONCE(dev->operstate) : 2052 IF_OPER_DOWN) || 2053 nla_put_u8(skb, IFLA_LINKMODE, READ_ONCE(dev->link_mode)) || 2054 nla_put_u8(skb, IFLA_NETNS_IMMUTABLE, dev->netns_immutable) || 2055 nla_put_u32(skb, IFLA_MTU, READ_ONCE(dev->mtu)) || 2056 nla_put_u32(skb, IFLA_MIN_MTU, READ_ONCE(dev->min_mtu)) || 2057 nla_put_u32(skb, IFLA_MAX_MTU, READ_ONCE(dev->max_mtu)) || 2058 nla_put_u32(skb, IFLA_GROUP, READ_ONCE(dev->group)) || 2059 nla_put_u32(skb, IFLA_PROMISCUITY, READ_ONCE(dev->promiscuity)) || 2060 nla_put_u32(skb, IFLA_ALLMULTI, READ_ONCE(dev->allmulti)) || 2061 nla_put_u32(skb, IFLA_NUM_TX_QUEUES, 2062 READ_ONCE(dev->num_tx_queues)) || 2063 nla_put_u32(skb, IFLA_GSO_MAX_SEGS, 2064 READ_ONCE(dev->gso_max_segs)) || 2065 nla_put_u32(skb, IFLA_GSO_MAX_SIZE, 2066 READ_ONCE(dev->gso_max_size)) || 2067 nla_put_u32(skb, IFLA_GRO_MAX_SIZE, 2068 READ_ONCE(dev->gro_max_size)) || 2069 nla_put_u32(skb, IFLA_GSO_IPV4_MAX_SIZE, 2070 READ_ONCE(dev->gso_ipv4_max_size)) || 2071 nla_put_u32(skb, IFLA_GRO_IPV4_MAX_SIZE, 2072 READ_ONCE(dev->gro_ipv4_max_size)) || 2073 nla_put_u32(skb, IFLA_TSO_MAX_SIZE, 2074 READ_ONCE(dev->tso_max_size)) || 2075 nla_put_u32(skb, IFLA_TSO_MAX_SEGS, 2076 READ_ONCE(dev->tso_max_segs)) || 2077 nla_put_uint(skb, IFLA_MAX_PACING_OFFLOAD_HORIZON, 2078 READ_ONCE(dev->max_pacing_offload_horizon)) || 2079 #ifdef CONFIG_RPS 2080 nla_put_u32(skb, IFLA_NUM_RX_QUEUES, 2081 READ_ONCE(dev->num_rx_queues)) || 2082 #endif 2083 put_master_ifindex(skb, dev) || 2084 nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) || 2085 nla_put_ifalias(skb, dev) || 2086 nla_put_u32(skb, IFLA_CARRIER_CHANGES, 2087 atomic_read(&dev->carrier_up_count) + 2088 atomic_read(&dev->carrier_down_count)) || 2089 nla_put_u32(skb, IFLA_CARRIER_UP_COUNT, 2090 atomic_read(&dev->carrier_up_count)) || 2091 nla_put_u32(skb, IFLA_CARRIER_DOWN_COUNT, 2092 atomic_read(&dev->carrier_down_count))) 2093 goto nla_put_failure; 2094 2095 if (rtnl_fill_proto_down(skb, dev)) 2096 goto nla_put_failure; 2097 2098 if (event != IFLA_EVENT_NONE) { 2099 if (nla_put_u32(skb, IFLA_EVENT, event)) 2100 goto nla_put_failure; 2101 } 2102 2103 if (dev->addr_len) { 2104 if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) || 2105 nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast)) 2106 goto nla_put_failure; 2107 } 2108 2109 if (rtnl_phys_port_id_fill(skb, dev)) 2110 goto nla_put_failure; 2111 2112 if (rtnl_phys_port_name_fill(skb, dev)) 2113 goto nla_put_failure; 2114 2115 if (rtnl_phys_switch_id_fill(skb, dev)) 2116 goto nla_put_failure; 2117 2118 if (rtnl_fill_stats(skb, dev)) 2119 goto nla_put_failure; 2120 2121 if (rtnl_fill_vf(skb, dev, ext_filter_mask)) 2122 goto nla_put_failure; 2123 2124 if (rtnl_port_fill(skb, dev, ext_filter_mask)) 2125 goto nla_put_failure; 2126 2127 if (rtnl_xdp_fill(skb, dev)) 2128 goto nla_put_failure; 2129 2130 if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) { 2131 if (rtnl_link_fill(skb, dev) < 0) 2132 goto nla_put_failure; 2133 } 2134 2135 if (new_nsid && 2136 nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0) 2137 goto nla_put_failure; 2138 if (new_ifindex && 2139 nla_put_s32(skb, IFLA_NEW_IFINDEX, new_ifindex) < 0) 2140 goto nla_put_failure; 2141 2142 if (memchr_inv(dev->perm_addr, '\0', dev->addr_len) && 2143 nla_put(skb, IFLA_PERM_ADDRESS, dev->addr_len, dev->perm_addr)) 2144 goto nla_put_failure; 2145 2146 rcu_read_lock(); 2147 if (rtnl_fill_link_netnsid(skb, dev, src_net, GFP_ATOMIC)) 2148 goto nla_put_failure_rcu; 2149 qdisc = rcu_dereference(dev->qdisc); 2150 if (qdisc && nla_put_string(skb, IFLA_QDISC, qdisc->ops->id)) 2151 goto nla_put_failure_rcu; 2152 if (rtnl_fill_link_af(skb, dev, ext_filter_mask)) 2153 goto nla_put_failure_rcu; 2154 if (rtnl_fill_link_ifmap(skb, dev)) 2155 goto nla_put_failure_rcu; 2156 if (rtnl_fill_prop_list(skb, dev)) 2157 goto nla_put_failure_rcu; 2158 rcu_read_unlock(); 2159 2160 if (dev->dev.parent && 2161 nla_put_string(skb, IFLA_PARENT_DEV_NAME, 2162 dev_name(dev->dev.parent))) 2163 goto nla_put_failure; 2164 2165 if (dev->dev.parent && dev->dev.parent->bus && 2166 nla_put_string(skb, IFLA_PARENT_DEV_BUS_NAME, 2167 dev->dev.parent->bus->name)) 2168 goto nla_put_failure; 2169 2170 if (rtnl_fill_devlink_port(skb, dev)) 2171 goto nla_put_failure; 2172 2173 if (rtnl_fill_dpll_pin(skb, dev)) 2174 goto nla_put_failure; 2175 2176 nlmsg_end(skb, nlh); 2177 return 0; 2178 2179 nla_put_failure_rcu: 2180 rcu_read_unlock(); 2181 nla_put_failure: 2182 nlmsg_cancel(skb, nlh); 2183 return -EMSGSIZE; 2184 } 2185 2186 static const struct nla_policy ifla_policy[IFLA_MAX+1] = { 2187 [IFLA_UNSPEC] = { .strict_start_type = IFLA_DPLL_PIN }, 2188 [IFLA_IFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ-1 }, 2189 [IFLA_ADDRESS] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, 2190 [IFLA_BROADCAST] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, 2191 [IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) }, 2192 [IFLA_MTU] = { .type = NLA_U32 }, 2193 [IFLA_LINK] = { .type = NLA_U32 }, 2194 [IFLA_MASTER] = { .type = NLA_U32 }, 2195 [IFLA_CARRIER] = { .type = NLA_U8 }, 2196 [IFLA_TXQLEN] = { .type = NLA_U32 }, 2197 [IFLA_WEIGHT] = { .type = NLA_U32 }, 2198 [IFLA_OPERSTATE] = { .type = NLA_U8 }, 2199 [IFLA_LINKMODE] = { .type = NLA_U8 }, 2200 [IFLA_LINKINFO] = { .type = NLA_NESTED }, 2201 [IFLA_NET_NS_PID] = { .type = NLA_U32 }, 2202 [IFLA_NET_NS_FD] = { .type = NLA_U32 }, 2203 /* IFLA_IFALIAS is a string, but policy is set to NLA_BINARY to 2204 * allow 0-length string (needed to remove an alias). 2205 */ 2206 [IFLA_IFALIAS] = { .type = NLA_BINARY, .len = IFALIASZ - 1 }, 2207 [IFLA_VFINFO_LIST] = {. type = NLA_NESTED }, 2208 [IFLA_VF_PORTS] = { .type = NLA_NESTED }, 2209 [IFLA_PORT_SELF] = { .type = NLA_NESTED }, 2210 [IFLA_AF_SPEC] = { .type = NLA_NESTED }, 2211 [IFLA_EXT_MASK] = { .type = NLA_U32 }, 2212 [IFLA_PROMISCUITY] = { .type = NLA_U32 }, 2213 [IFLA_NUM_TX_QUEUES] = { .type = NLA_U32 }, 2214 [IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 }, 2215 [IFLA_GSO_MAX_SEGS] = { .type = NLA_U32 }, 2216 [IFLA_GSO_MAX_SIZE] = NLA_POLICY_MIN(NLA_U32, MAX_TCP_HEADER + 1), 2217 [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN }, 2218 [IFLA_CARRIER_CHANGES] = { .type = NLA_U32 }, /* ignored */ 2219 [IFLA_PHYS_SWITCH_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN }, 2220 [IFLA_LINK_NETNSID] = { .type = NLA_S32 }, 2221 [IFLA_PROTO_DOWN] = { .type = NLA_U8 }, 2222 [IFLA_XDP] = { .type = NLA_NESTED }, 2223 [IFLA_EVENT] = { .type = NLA_U32 }, 2224 [IFLA_GROUP] = { .type = NLA_U32 }, 2225 [IFLA_TARGET_NETNSID] = { .type = NLA_S32 }, 2226 [IFLA_CARRIER_UP_COUNT] = { .type = NLA_U32 }, 2227 [IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 }, 2228 [IFLA_MIN_MTU] = { .type = NLA_U32 }, 2229 [IFLA_MAX_MTU] = { .type = NLA_U32 }, 2230 [IFLA_PROP_LIST] = { .type = NLA_NESTED }, 2231 [IFLA_ALT_IFNAME] = { .type = NLA_STRING, 2232 .len = ALTIFNAMSIZ - 1 }, 2233 [IFLA_PERM_ADDRESS] = { .type = NLA_REJECT }, 2234 [IFLA_PROTO_DOWN_REASON] = { .type = NLA_NESTED }, 2235 [IFLA_NEW_IFINDEX] = NLA_POLICY_MIN(NLA_S32, 1), 2236 [IFLA_PARENT_DEV_NAME] = { .type = NLA_NUL_STRING }, 2237 [IFLA_GRO_MAX_SIZE] = { .type = NLA_U32 }, 2238 [IFLA_TSO_MAX_SIZE] = { .type = NLA_REJECT }, 2239 [IFLA_TSO_MAX_SEGS] = { .type = NLA_REJECT }, 2240 [IFLA_ALLMULTI] = { .type = NLA_REJECT }, 2241 [IFLA_GSO_IPV4_MAX_SIZE] = NLA_POLICY_MIN(NLA_U32, MAX_TCP_HEADER + 1), 2242 [IFLA_GRO_IPV4_MAX_SIZE] = { .type = NLA_U32 }, 2243 [IFLA_NETNS_IMMUTABLE] = { .type = NLA_REJECT }, 2244 }; 2245 2246 static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = { 2247 [IFLA_INFO_KIND] = { .type = NLA_STRING }, 2248 [IFLA_INFO_DATA] = { .type = NLA_NESTED }, 2249 [IFLA_INFO_SLAVE_KIND] = { .type = NLA_STRING }, 2250 [IFLA_INFO_SLAVE_DATA] = { .type = NLA_NESTED }, 2251 }; 2252 2253 static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = { 2254 [IFLA_VF_MAC] = { .len = sizeof(struct ifla_vf_mac) }, 2255 [IFLA_VF_BROADCAST] = { .type = NLA_REJECT }, 2256 [IFLA_VF_VLAN] = { .len = sizeof(struct ifla_vf_vlan) }, 2257 [IFLA_VF_VLAN_LIST] = { .type = NLA_NESTED }, 2258 [IFLA_VF_TX_RATE] = { .len = sizeof(struct ifla_vf_tx_rate) }, 2259 [IFLA_VF_SPOOFCHK] = { .len = sizeof(struct ifla_vf_spoofchk) }, 2260 [IFLA_VF_RATE] = { .len = sizeof(struct ifla_vf_rate) }, 2261 [IFLA_VF_LINK_STATE] = { .len = sizeof(struct ifla_vf_link_state) }, 2262 [IFLA_VF_RSS_QUERY_EN] = { .len = sizeof(struct ifla_vf_rss_query_en) }, 2263 [IFLA_VF_STATS] = { .type = NLA_NESTED }, 2264 [IFLA_VF_TRUST] = { .len = sizeof(struct ifla_vf_trust) }, 2265 [IFLA_VF_IB_NODE_GUID] = { .len = sizeof(struct ifla_vf_guid) }, 2266 [IFLA_VF_IB_PORT_GUID] = { .len = sizeof(struct ifla_vf_guid) }, 2267 }; 2268 2269 static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = { 2270 [IFLA_PORT_VF] = { .type = NLA_U32 }, 2271 [IFLA_PORT_PROFILE] = { .type = NLA_STRING, 2272 .len = PORT_PROFILE_MAX }, 2273 [IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY, 2274 .len = PORT_UUID_MAX }, 2275 [IFLA_PORT_HOST_UUID] = { .type = NLA_STRING, 2276 .len = PORT_UUID_MAX }, 2277 [IFLA_PORT_REQUEST] = { .type = NLA_U8, }, 2278 [IFLA_PORT_RESPONSE] = { .type = NLA_U16, }, 2279 2280 /* Unused, but we need to keep it here since user space could 2281 * fill it. It's also broken with regard to NLA_BINARY use in 2282 * combination with structs. 2283 */ 2284 [IFLA_PORT_VSI_TYPE] = { .type = NLA_BINARY, 2285 .len = sizeof(struct ifla_port_vsi) }, 2286 }; 2287 2288 static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = { 2289 [IFLA_XDP_UNSPEC] = { .strict_start_type = IFLA_XDP_EXPECTED_FD }, 2290 [IFLA_XDP_FD] = { .type = NLA_S32 }, 2291 [IFLA_XDP_EXPECTED_FD] = { .type = NLA_S32 }, 2292 [IFLA_XDP_ATTACHED] = { .type = NLA_U8 }, 2293 [IFLA_XDP_FLAGS] = { .type = NLA_U32 }, 2294 [IFLA_XDP_PROG_ID] = { .type = NLA_U32 }, 2295 }; 2296 2297 static struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla, 2298 int *ops_srcu_index) 2299 { 2300 struct nlattr *linfo[IFLA_INFO_MAX + 1]; 2301 struct rtnl_link_ops *ops = NULL; 2302 2303 if (nla_parse_nested_deprecated(linfo, IFLA_INFO_MAX, nla, ifla_info_policy, NULL) < 0) 2304 return NULL; 2305 2306 if (linfo[IFLA_INFO_KIND]) { 2307 char kind[MODULE_NAME_LEN]; 2308 2309 nla_strscpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind)); 2310 ops = rtnl_link_ops_get(kind, ops_srcu_index); 2311 } 2312 2313 return ops; 2314 } 2315 2316 static bool link_master_filtered(struct net_device *dev, int master_idx) 2317 { 2318 struct net_device *master; 2319 2320 if (!master_idx) 2321 return false; 2322 2323 master = netdev_master_upper_dev_get(dev); 2324 2325 /* 0 is already used to denote IFLA_MASTER wasn't passed, therefore need 2326 * another invalid value for ifindex to denote "no master". 2327 */ 2328 if (master_idx == -1) 2329 return !!master; 2330 2331 if (!master || master->ifindex != master_idx) 2332 return true; 2333 2334 return false; 2335 } 2336 2337 static bool link_kind_filtered(const struct net_device *dev, 2338 const struct rtnl_link_ops *kind_ops) 2339 { 2340 if (kind_ops && dev->rtnl_link_ops != kind_ops) 2341 return true; 2342 2343 return false; 2344 } 2345 2346 static bool link_dump_filtered(struct net_device *dev, 2347 int master_idx, 2348 const struct rtnl_link_ops *kind_ops) 2349 { 2350 if (link_master_filtered(dev, master_idx) || 2351 link_kind_filtered(dev, kind_ops)) 2352 return true; 2353 2354 return false; 2355 } 2356 2357 /** 2358 * rtnl_get_net_ns_capable - Get netns if sufficiently privileged. 2359 * @sk: netlink socket 2360 * @netnsid: network namespace identifier 2361 * 2362 * Returns the network namespace identified by netnsid on success or an error 2363 * pointer on failure. 2364 */ 2365 struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid) 2366 { 2367 struct net *net; 2368 2369 net = get_net_ns_by_id(sock_net(sk), netnsid); 2370 if (!net) 2371 return ERR_PTR(-EINVAL); 2372 2373 /* For now, the caller is required to have CAP_NET_ADMIN in 2374 * the user namespace owning the target net ns. 2375 */ 2376 if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) { 2377 put_net(net); 2378 return ERR_PTR(-EACCES); 2379 } 2380 return net; 2381 } 2382 EXPORT_SYMBOL_GPL(rtnl_get_net_ns_capable); 2383 2384 static int rtnl_valid_dump_ifinfo_req(const struct nlmsghdr *nlh, 2385 bool strict_check, struct nlattr **tb, 2386 struct netlink_ext_ack *extack) 2387 { 2388 int hdrlen; 2389 2390 if (strict_check) { 2391 struct ifinfomsg *ifm; 2392 2393 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) { 2394 NL_SET_ERR_MSG(extack, "Invalid header for link dump"); 2395 return -EINVAL; 2396 } 2397 2398 ifm = nlmsg_data(nlh); 2399 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags || 2400 ifm->ifi_change) { 2401 NL_SET_ERR_MSG(extack, "Invalid values in header for link dump request"); 2402 return -EINVAL; 2403 } 2404 if (ifm->ifi_index) { 2405 NL_SET_ERR_MSG(extack, "Filter by device index not supported for link dumps"); 2406 return -EINVAL; 2407 } 2408 2409 return nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, 2410 IFLA_MAX, ifla_policy, 2411 extack); 2412 } 2413 2414 /* A hack to preserve kernel<->userspace interface. 2415 * The correct header is ifinfomsg. It is consistent with rtnl_getlink. 2416 * However, before Linux v3.9 the code here assumed rtgenmsg and that's 2417 * what iproute2 < v3.9.0 used. 2418 * We can detect the old iproute2. Even including the IFLA_EXT_MASK 2419 * attribute, its netlink message is shorter than struct ifinfomsg. 2420 */ 2421 hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ? 2422 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg); 2423 2424 return nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy, 2425 extack); 2426 } 2427 2428 static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) 2429 { 2430 struct netlink_ext_ack *extack = cb->extack; 2431 struct rtnl_link_ops *kind_ops = NULL; 2432 const struct nlmsghdr *nlh = cb->nlh; 2433 struct net *net = sock_net(skb->sk); 2434 unsigned int flags = NLM_F_MULTI; 2435 struct nlattr *tb[IFLA_MAX+1]; 2436 struct { 2437 unsigned long ifindex; 2438 } *ctx = (void *)cb->ctx; 2439 struct net *tgt_net = net; 2440 u32 ext_filter_mask = 0; 2441 struct net_device *dev; 2442 int ops_srcu_index; 2443 int master_idx = 0; 2444 int netnsid = -1; 2445 int err, i; 2446 2447 err = rtnl_valid_dump_ifinfo_req(nlh, cb->strict_check, tb, extack); 2448 if (err < 0) { 2449 if (cb->strict_check) 2450 return err; 2451 2452 goto walk_entries; 2453 } 2454 2455 for (i = 0; i <= IFLA_MAX; ++i) { 2456 if (!tb[i]) 2457 continue; 2458 2459 /* new attributes should only be added with strict checking */ 2460 switch (i) { 2461 case IFLA_TARGET_NETNSID: 2462 netnsid = nla_get_s32(tb[i]); 2463 tgt_net = rtnl_get_net_ns_capable(skb->sk, netnsid); 2464 if (IS_ERR(tgt_net)) { 2465 NL_SET_ERR_MSG(extack, "Invalid target network namespace id"); 2466 err = PTR_ERR(tgt_net); 2467 netnsid = -1; 2468 goto out; 2469 } 2470 break; 2471 case IFLA_EXT_MASK: 2472 ext_filter_mask = nla_get_u32(tb[i]); 2473 break; 2474 case IFLA_MASTER: 2475 master_idx = nla_get_u32(tb[i]); 2476 break; 2477 case IFLA_LINKINFO: 2478 kind_ops = linkinfo_to_kind_ops(tb[i], &ops_srcu_index); 2479 break; 2480 default: 2481 if (cb->strict_check) { 2482 NL_SET_ERR_MSG(extack, "Unsupported attribute in link dump request"); 2483 err = -EINVAL; 2484 goto out; 2485 } 2486 } 2487 } 2488 2489 if (master_idx || kind_ops) 2490 flags |= NLM_F_DUMP_FILTERED; 2491 2492 walk_entries: 2493 err = 0; 2494 for_each_netdev_dump(tgt_net, dev, ctx->ifindex) { 2495 if (link_dump_filtered(dev, master_idx, kind_ops)) 2496 continue; 2497 err = rtnl_fill_ifinfo(skb, dev, net, RTM_NEWLINK, 2498 NETLINK_CB(cb->skb).portid, 2499 nlh->nlmsg_seq, 0, flags, 2500 ext_filter_mask, 0, NULL, 0, 2501 netnsid, GFP_KERNEL); 2502 if (err < 0) 2503 break; 2504 } 2505 2506 2507 cb->seq = tgt_net->dev_base_seq; 2508 nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 2509 2510 out: 2511 2512 if (kind_ops) 2513 rtnl_link_ops_put(kind_ops, ops_srcu_index); 2514 if (netnsid >= 0) 2515 put_net(tgt_net); 2516 2517 return err; 2518 } 2519 2520 int rtnl_nla_parse_ifinfomsg(struct nlattr **tb, const struct nlattr *nla_peer, 2521 struct netlink_ext_ack *exterr) 2522 { 2523 const struct ifinfomsg *ifmp; 2524 const struct nlattr *attrs; 2525 size_t len; 2526 2527 ifmp = nla_data(nla_peer); 2528 attrs = nla_data(nla_peer) + sizeof(struct ifinfomsg); 2529 len = nla_len(nla_peer) - sizeof(struct ifinfomsg); 2530 2531 if (ifmp->ifi_index < 0) { 2532 NL_SET_ERR_MSG_ATTR(exterr, nla_peer, 2533 "ifindex can't be negative"); 2534 return -EINVAL; 2535 } 2536 2537 return nla_parse_deprecated(tb, IFLA_MAX, attrs, len, ifla_policy, 2538 exterr); 2539 } 2540 EXPORT_SYMBOL(rtnl_nla_parse_ifinfomsg); 2541 2542 static struct net *rtnl_link_get_net_ifla(struct nlattr *tb[]) 2543 { 2544 struct net *net = NULL; 2545 2546 /* Examine the link attributes and figure out which 2547 * network namespace we are talking about. 2548 */ 2549 if (tb[IFLA_NET_NS_PID]) 2550 net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID])); 2551 else if (tb[IFLA_NET_NS_FD]) 2552 net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD])); 2553 2554 return net; 2555 } 2556 2557 struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[]) 2558 { 2559 struct net *net = rtnl_link_get_net_ifla(tb); 2560 2561 if (!net) 2562 net = get_net(src_net); 2563 2564 return net; 2565 } 2566 EXPORT_SYMBOL(rtnl_link_get_net); 2567 2568 /* Figure out which network namespace we are talking about by 2569 * examining the link attributes in the following order: 2570 * 2571 * 1. IFLA_NET_NS_PID 2572 * 2. IFLA_NET_NS_FD 2573 * 3. IFLA_TARGET_NETNSID 2574 */ 2575 static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net, 2576 struct nlattr *tb[]) 2577 { 2578 struct net *net; 2579 2580 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]) 2581 return rtnl_link_get_net(src_net, tb); 2582 2583 if (!tb[IFLA_TARGET_NETNSID]) 2584 return get_net(src_net); 2585 2586 net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_TARGET_NETNSID])); 2587 if (!net) 2588 return ERR_PTR(-EINVAL); 2589 2590 return net; 2591 } 2592 2593 static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb, 2594 struct net *src_net, 2595 struct nlattr *tb[], int cap) 2596 { 2597 struct net *net; 2598 2599 net = rtnl_link_get_net_by_nlattr(src_net, tb); 2600 if (IS_ERR(net)) 2601 return net; 2602 2603 if (!netlink_ns_capable(skb, net->user_ns, cap)) { 2604 put_net(net); 2605 return ERR_PTR(-EPERM); 2606 } 2607 2608 return net; 2609 } 2610 2611 /* Verify that rtnetlink requests do not pass additional properties 2612 * potentially referring to different network namespaces. 2613 */ 2614 static int rtnl_ensure_unique_netns(struct nlattr *tb[], 2615 struct netlink_ext_ack *extack, 2616 bool netns_id_only) 2617 { 2618 2619 if (netns_id_only) { 2620 if (!tb[IFLA_NET_NS_PID] && !tb[IFLA_NET_NS_FD]) 2621 return 0; 2622 2623 NL_SET_ERR_MSG(extack, "specified netns attribute not supported"); 2624 return -EOPNOTSUPP; 2625 } 2626 2627 if (tb[IFLA_TARGET_NETNSID] && (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD])) 2628 goto invalid_attr; 2629 2630 if (tb[IFLA_NET_NS_PID] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_FD])) 2631 goto invalid_attr; 2632 2633 if (tb[IFLA_NET_NS_FD] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_PID])) 2634 goto invalid_attr; 2635 2636 return 0; 2637 2638 invalid_attr: 2639 NL_SET_ERR_MSG(extack, "multiple netns identifying attributes specified"); 2640 return -EINVAL; 2641 } 2642 2643 static int rtnl_set_vf_rate(struct net_device *dev, int vf, int min_tx_rate, 2644 int max_tx_rate) 2645 { 2646 const struct net_device_ops *ops = dev->netdev_ops; 2647 2648 if (!ops->ndo_set_vf_rate) 2649 return -EOPNOTSUPP; 2650 if (max_tx_rate && max_tx_rate < min_tx_rate) 2651 return -EINVAL; 2652 2653 return ops->ndo_set_vf_rate(dev, vf, min_tx_rate, max_tx_rate); 2654 } 2655 2656 static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[], 2657 struct netlink_ext_ack *extack) 2658 { 2659 if (tb[IFLA_ADDRESS] && 2660 nla_len(tb[IFLA_ADDRESS]) < dev->addr_len) 2661 return -EINVAL; 2662 2663 if (tb[IFLA_BROADCAST] && 2664 nla_len(tb[IFLA_BROADCAST]) < dev->addr_len) 2665 return -EINVAL; 2666 2667 if (tb[IFLA_GSO_MAX_SIZE] && 2668 nla_get_u32(tb[IFLA_GSO_MAX_SIZE]) > dev->tso_max_size) { 2669 NL_SET_ERR_MSG(extack, "too big gso_max_size"); 2670 return -EINVAL; 2671 } 2672 2673 if (tb[IFLA_GSO_MAX_SEGS] && 2674 (nla_get_u32(tb[IFLA_GSO_MAX_SEGS]) > GSO_MAX_SEGS || 2675 nla_get_u32(tb[IFLA_GSO_MAX_SEGS]) > dev->tso_max_segs)) { 2676 NL_SET_ERR_MSG(extack, "too big gso_max_segs"); 2677 return -EINVAL; 2678 } 2679 2680 if (tb[IFLA_GRO_MAX_SIZE] && 2681 nla_get_u32(tb[IFLA_GRO_MAX_SIZE]) > GRO_MAX_SIZE) { 2682 NL_SET_ERR_MSG(extack, "too big gro_max_size"); 2683 return -EINVAL; 2684 } 2685 2686 if (tb[IFLA_GSO_IPV4_MAX_SIZE] && 2687 nla_get_u32(tb[IFLA_GSO_IPV4_MAX_SIZE]) > dev->tso_max_size) { 2688 NL_SET_ERR_MSG(extack, "too big gso_ipv4_max_size"); 2689 return -EINVAL; 2690 } 2691 2692 if (tb[IFLA_GRO_IPV4_MAX_SIZE] && 2693 nla_get_u32(tb[IFLA_GRO_IPV4_MAX_SIZE]) > GRO_MAX_SIZE) { 2694 NL_SET_ERR_MSG(extack, "too big gro_ipv4_max_size"); 2695 return -EINVAL; 2696 } 2697 2698 if (tb[IFLA_AF_SPEC]) { 2699 struct nlattr *af; 2700 int rem, err; 2701 2702 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) { 2703 struct rtnl_af_ops *af_ops; 2704 int af_ops_srcu_index; 2705 2706 af_ops = rtnl_af_lookup(nla_type(af), &af_ops_srcu_index); 2707 if (!af_ops) 2708 return -EAFNOSUPPORT; 2709 2710 if (!af_ops->set_link_af) 2711 err = -EOPNOTSUPP; 2712 else if (af_ops->validate_link_af) 2713 err = af_ops->validate_link_af(dev, af, extack); 2714 else 2715 err = 0; 2716 2717 rtnl_af_put(af_ops, af_ops_srcu_index); 2718 2719 if (err < 0) 2720 return err; 2721 } 2722 } 2723 2724 return 0; 2725 } 2726 2727 static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt, 2728 int guid_type) 2729 { 2730 const struct net_device_ops *ops = dev->netdev_ops; 2731 2732 return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type); 2733 } 2734 2735 static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type) 2736 { 2737 if (dev->type != ARPHRD_INFINIBAND) 2738 return -EOPNOTSUPP; 2739 2740 return handle_infiniband_guid(dev, ivt, guid_type); 2741 } 2742 2743 static int do_setvfinfo(struct net_device *dev, struct nlattr **tb) 2744 { 2745 const struct net_device_ops *ops = dev->netdev_ops; 2746 int err = -EINVAL; 2747 2748 if (tb[IFLA_VF_MAC]) { 2749 struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]); 2750 2751 if (ivm->vf >= INT_MAX) 2752 return -EINVAL; 2753 err = -EOPNOTSUPP; 2754 if (ops->ndo_set_vf_mac) 2755 err = ops->ndo_set_vf_mac(dev, ivm->vf, 2756 ivm->mac); 2757 if (err < 0) 2758 return err; 2759 } 2760 2761 if (tb[IFLA_VF_VLAN]) { 2762 struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]); 2763 2764 if (ivv->vf >= INT_MAX) 2765 return -EINVAL; 2766 err = -EOPNOTSUPP; 2767 if (ops->ndo_set_vf_vlan) 2768 err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan, 2769 ivv->qos, 2770 htons(ETH_P_8021Q)); 2771 if (err < 0) 2772 return err; 2773 } 2774 2775 if (tb[IFLA_VF_VLAN_LIST]) { 2776 struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN]; 2777 struct nlattr *attr; 2778 int rem, len = 0; 2779 2780 err = -EOPNOTSUPP; 2781 if (!ops->ndo_set_vf_vlan) 2782 return err; 2783 2784 nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) { 2785 if (nla_type(attr) != IFLA_VF_VLAN_INFO || 2786 nla_len(attr) < sizeof(struct ifla_vf_vlan_info)) { 2787 return -EINVAL; 2788 } 2789 if (len >= MAX_VLAN_LIST_LEN) 2790 return -EOPNOTSUPP; 2791 ivvl[len] = nla_data(attr); 2792 2793 len++; 2794 } 2795 if (len == 0) 2796 return -EINVAL; 2797 2798 if (ivvl[0]->vf >= INT_MAX) 2799 return -EINVAL; 2800 err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan, 2801 ivvl[0]->qos, ivvl[0]->vlan_proto); 2802 if (err < 0) 2803 return err; 2804 } 2805 2806 if (tb[IFLA_VF_TX_RATE]) { 2807 struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]); 2808 struct ifla_vf_info ivf; 2809 2810 if (ivt->vf >= INT_MAX) 2811 return -EINVAL; 2812 err = -EOPNOTSUPP; 2813 if (ops->ndo_get_vf_config) 2814 err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf); 2815 if (err < 0) 2816 return err; 2817 2818 err = rtnl_set_vf_rate(dev, ivt->vf, 2819 ivf.min_tx_rate, ivt->rate); 2820 if (err < 0) 2821 return err; 2822 } 2823 2824 if (tb[IFLA_VF_RATE]) { 2825 struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]); 2826 2827 if (ivt->vf >= INT_MAX) 2828 return -EINVAL; 2829 2830 err = rtnl_set_vf_rate(dev, ivt->vf, 2831 ivt->min_tx_rate, ivt->max_tx_rate); 2832 if (err < 0) 2833 return err; 2834 } 2835 2836 if (tb[IFLA_VF_SPOOFCHK]) { 2837 struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]); 2838 2839 if (ivs->vf >= INT_MAX) 2840 return -EINVAL; 2841 err = -EOPNOTSUPP; 2842 if (ops->ndo_set_vf_spoofchk) 2843 err = ops->ndo_set_vf_spoofchk(dev, ivs->vf, 2844 ivs->setting); 2845 if (err < 0) 2846 return err; 2847 } 2848 2849 if (tb[IFLA_VF_LINK_STATE]) { 2850 struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]); 2851 2852 if (ivl->vf >= INT_MAX) 2853 return -EINVAL; 2854 err = -EOPNOTSUPP; 2855 if (ops->ndo_set_vf_link_state) 2856 err = ops->ndo_set_vf_link_state(dev, ivl->vf, 2857 ivl->link_state); 2858 if (err < 0) 2859 return err; 2860 } 2861 2862 if (tb[IFLA_VF_RSS_QUERY_EN]) { 2863 struct ifla_vf_rss_query_en *ivrssq_en; 2864 2865 err = -EOPNOTSUPP; 2866 ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]); 2867 if (ivrssq_en->vf >= INT_MAX) 2868 return -EINVAL; 2869 if (ops->ndo_set_vf_rss_query_en) 2870 err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf, 2871 ivrssq_en->setting); 2872 if (err < 0) 2873 return err; 2874 } 2875 2876 if (tb[IFLA_VF_TRUST]) { 2877 struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]); 2878 2879 if (ivt->vf >= INT_MAX) 2880 return -EINVAL; 2881 err = -EOPNOTSUPP; 2882 if (ops->ndo_set_vf_trust) 2883 err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting); 2884 if (err < 0) 2885 return err; 2886 } 2887 2888 if (tb[IFLA_VF_IB_NODE_GUID]) { 2889 struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]); 2890 2891 if (ivt->vf >= INT_MAX) 2892 return -EINVAL; 2893 if (!ops->ndo_set_vf_guid) 2894 return -EOPNOTSUPP; 2895 return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID); 2896 } 2897 2898 if (tb[IFLA_VF_IB_PORT_GUID]) { 2899 struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]); 2900 2901 if (ivt->vf >= INT_MAX) 2902 return -EINVAL; 2903 if (!ops->ndo_set_vf_guid) 2904 return -EOPNOTSUPP; 2905 2906 return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID); 2907 } 2908 2909 return err; 2910 } 2911 2912 static int do_set_master(struct net_device *dev, int ifindex, 2913 struct netlink_ext_ack *extack) 2914 { 2915 struct net_device *upper_dev = netdev_master_upper_dev_get(dev); 2916 const struct net_device_ops *ops; 2917 int err; 2918 2919 /* Release the lower lock, the upper is responsible for locking 2920 * the lower if needed. None of the existing upper devices 2921 * use netdev instance lock, so don't grab it. 2922 */ 2923 2924 if (upper_dev) { 2925 if (upper_dev->ifindex == ifindex) 2926 return 0; 2927 ops = upper_dev->netdev_ops; 2928 if (ops->ndo_del_slave) { 2929 netdev_unlock_ops(dev); 2930 err = ops->ndo_del_slave(upper_dev, dev); 2931 netdev_lock_ops(dev); 2932 if (err) 2933 return err; 2934 } else { 2935 return -EOPNOTSUPP; 2936 } 2937 } 2938 2939 if (ifindex) { 2940 upper_dev = __dev_get_by_index(dev_net(dev), ifindex); 2941 if (!upper_dev) 2942 return -EINVAL; 2943 ops = upper_dev->netdev_ops; 2944 if (ops->ndo_add_slave) { 2945 netdev_unlock_ops(dev); 2946 err = ops->ndo_add_slave(upper_dev, dev, extack); 2947 netdev_lock_ops(dev); 2948 if (err) 2949 return err; 2950 } else { 2951 return -EOPNOTSUPP; 2952 } 2953 } 2954 return 0; 2955 } 2956 2957 static const struct nla_policy ifla_proto_down_reason_policy[IFLA_PROTO_DOWN_REASON_VALUE + 1] = { 2958 [IFLA_PROTO_DOWN_REASON_MASK] = { .type = NLA_U32 }, 2959 [IFLA_PROTO_DOWN_REASON_VALUE] = { .type = NLA_U32 }, 2960 }; 2961 2962 static int do_set_proto_down(struct net_device *dev, 2963 struct nlattr *nl_proto_down, 2964 struct nlattr *nl_proto_down_reason, 2965 struct netlink_ext_ack *extack) 2966 { 2967 struct nlattr *pdreason[IFLA_PROTO_DOWN_REASON_MAX + 1]; 2968 unsigned long mask = 0; 2969 u32 value; 2970 bool proto_down; 2971 int err; 2972 2973 if (!dev->change_proto_down) { 2974 NL_SET_ERR_MSG(extack, "Protodown not supported by device"); 2975 return -EOPNOTSUPP; 2976 } 2977 2978 if (nl_proto_down_reason) { 2979 err = nla_parse_nested_deprecated(pdreason, 2980 IFLA_PROTO_DOWN_REASON_MAX, 2981 nl_proto_down_reason, 2982 ifla_proto_down_reason_policy, 2983 NULL); 2984 if (err < 0) 2985 return err; 2986 2987 if (!pdreason[IFLA_PROTO_DOWN_REASON_VALUE]) { 2988 NL_SET_ERR_MSG(extack, "Invalid protodown reason value"); 2989 return -EINVAL; 2990 } 2991 2992 value = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_VALUE]); 2993 2994 if (pdreason[IFLA_PROTO_DOWN_REASON_MASK]) 2995 mask = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_MASK]); 2996 2997 netdev_change_proto_down_reason_locked(dev, mask, value); 2998 } 2999 3000 if (nl_proto_down) { 3001 proto_down = nla_get_u8(nl_proto_down); 3002 3003 /* Don't turn off protodown if there are active reasons */ 3004 if (!proto_down && dev->proto_down_reason) { 3005 NL_SET_ERR_MSG(extack, "Cannot clear protodown, active reasons"); 3006 return -EBUSY; 3007 } 3008 err = netif_change_proto_down(dev, proto_down); 3009 if (err) 3010 return err; 3011 } 3012 3013 return 0; 3014 } 3015 3016 #define DO_SETLINK_MODIFIED 0x01 3017 /* notify flag means notify + modified. */ 3018 #define DO_SETLINK_NOTIFY 0x03 3019 static int do_setlink(const struct sk_buff *skb, struct net_device *dev, 3020 struct net *tgt_net, struct ifinfomsg *ifm, 3021 struct netlink_ext_ack *extack, 3022 struct nlattr **tb, int status) 3023 { 3024 const struct net_device_ops *ops = dev->netdev_ops; 3025 char ifname[IFNAMSIZ]; 3026 int err; 3027 3028 err = validate_linkmsg(dev, tb, extack); 3029 if (err < 0) 3030 return err; 3031 3032 if (tb[IFLA_IFNAME]) 3033 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 3034 else 3035 ifname[0] = '\0'; 3036 3037 if (!net_eq(tgt_net, dev_net(dev))) { 3038 const char *pat = ifname[0] ? ifname : NULL; 3039 int new_ifindex; 3040 3041 new_ifindex = nla_get_s32_default(tb[IFLA_NEW_IFINDEX], 0); 3042 3043 err = __dev_change_net_namespace(dev, tgt_net, pat, 3044 new_ifindex, extack); 3045 if (err) 3046 return err; 3047 3048 status |= DO_SETLINK_MODIFIED; 3049 } 3050 3051 netdev_lock_ops(dev); 3052 3053 if (tb[IFLA_MAP]) { 3054 struct rtnl_link_ifmap *u_map; 3055 struct ifmap k_map; 3056 3057 if (!ops->ndo_set_config) { 3058 err = -EOPNOTSUPP; 3059 goto errout; 3060 } 3061 3062 if (!netif_device_present(dev)) { 3063 err = -ENODEV; 3064 goto errout; 3065 } 3066 3067 u_map = nla_data(tb[IFLA_MAP]); 3068 k_map.mem_start = (unsigned long) u_map->mem_start; 3069 k_map.mem_end = (unsigned long) u_map->mem_end; 3070 k_map.base_addr = (unsigned short) u_map->base_addr; 3071 k_map.irq = (unsigned char) u_map->irq; 3072 k_map.dma = (unsigned char) u_map->dma; 3073 k_map.port = (unsigned char) u_map->port; 3074 3075 err = ops->ndo_set_config(dev, &k_map); 3076 if (err < 0) 3077 goto errout; 3078 3079 status |= DO_SETLINK_NOTIFY; 3080 } 3081 3082 if (tb[IFLA_ADDRESS]) { 3083 struct sockaddr *sa; 3084 int len; 3085 3086 len = sizeof(sa_family_t) + max_t(size_t, dev->addr_len, 3087 sizeof(*sa)); 3088 sa = kmalloc(len, GFP_KERNEL); 3089 if (!sa) { 3090 err = -ENOMEM; 3091 goto errout; 3092 } 3093 sa->sa_family = dev->type; 3094 3095 netdev_unlock_ops(dev); 3096 3097 /* dev_addr_sem is an outer lock, enforce proper ordering */ 3098 down_write(&dev_addr_sem); 3099 netdev_lock_ops(dev); 3100 3101 memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]), 3102 dev->addr_len); 3103 err = netif_set_mac_address(dev, sa, extack); 3104 kfree(sa); 3105 if (err) { 3106 up_write(&dev_addr_sem); 3107 goto errout; 3108 } 3109 status |= DO_SETLINK_MODIFIED; 3110 3111 up_write(&dev_addr_sem); 3112 } 3113 3114 if (tb[IFLA_MTU]) { 3115 err = netif_set_mtu_ext(dev, nla_get_u32(tb[IFLA_MTU]), extack); 3116 if (err < 0) 3117 goto errout; 3118 status |= DO_SETLINK_MODIFIED; 3119 } 3120 3121 if (tb[IFLA_GROUP]) { 3122 netif_set_group(dev, nla_get_u32(tb[IFLA_GROUP])); 3123 status |= DO_SETLINK_NOTIFY; 3124 } 3125 3126 /* 3127 * Interface selected by interface index but interface 3128 * name provided implies that a name change has been 3129 * requested. 3130 */ 3131 if (ifm->ifi_index > 0 && ifname[0]) { 3132 err = netif_change_name(dev, ifname); 3133 if (err < 0) 3134 goto errout; 3135 status |= DO_SETLINK_MODIFIED; 3136 } 3137 3138 if (tb[IFLA_IFALIAS]) { 3139 err = netif_set_alias(dev, nla_data(tb[IFLA_IFALIAS]), 3140 nla_len(tb[IFLA_IFALIAS])); 3141 if (err < 0) 3142 goto errout; 3143 status |= DO_SETLINK_NOTIFY; 3144 } 3145 3146 if (tb[IFLA_BROADCAST]) { 3147 nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len); 3148 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); 3149 } 3150 3151 if (ifm->ifi_flags || ifm->ifi_change) { 3152 err = netif_change_flags(dev, rtnl_dev_combine_flags(dev, ifm), 3153 extack); 3154 if (err < 0) 3155 goto errout; 3156 } 3157 3158 if (tb[IFLA_MASTER]) { 3159 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack); 3160 if (err) 3161 goto errout; 3162 status |= DO_SETLINK_MODIFIED; 3163 } 3164 3165 if (tb[IFLA_CARRIER]) { 3166 err = netif_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER])); 3167 if (err) 3168 goto errout; 3169 status |= DO_SETLINK_MODIFIED; 3170 } 3171 3172 if (tb[IFLA_TXQLEN]) { 3173 unsigned int value = nla_get_u32(tb[IFLA_TXQLEN]); 3174 3175 err = netif_change_tx_queue_len(dev, value); 3176 if (err) 3177 goto errout; 3178 status |= DO_SETLINK_MODIFIED; 3179 } 3180 3181 if (tb[IFLA_GSO_MAX_SIZE]) { 3182 u32 max_size = nla_get_u32(tb[IFLA_GSO_MAX_SIZE]); 3183 3184 if (dev->gso_max_size ^ max_size) { 3185 netif_set_gso_max_size(dev, max_size); 3186 status |= DO_SETLINK_MODIFIED; 3187 } 3188 } 3189 3190 if (tb[IFLA_GSO_MAX_SEGS]) { 3191 u32 max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]); 3192 3193 if (dev->gso_max_segs ^ max_segs) { 3194 netif_set_gso_max_segs(dev, max_segs); 3195 status |= DO_SETLINK_MODIFIED; 3196 } 3197 } 3198 3199 if (tb[IFLA_GRO_MAX_SIZE]) { 3200 u32 gro_max_size = nla_get_u32(tb[IFLA_GRO_MAX_SIZE]); 3201 3202 if (dev->gro_max_size ^ gro_max_size) { 3203 netif_set_gro_max_size(dev, gro_max_size); 3204 status |= DO_SETLINK_MODIFIED; 3205 } 3206 } 3207 3208 if (tb[IFLA_GSO_IPV4_MAX_SIZE]) { 3209 u32 max_size = nla_get_u32(tb[IFLA_GSO_IPV4_MAX_SIZE]); 3210 3211 if (dev->gso_ipv4_max_size ^ max_size) { 3212 netif_set_gso_ipv4_max_size(dev, max_size); 3213 status |= DO_SETLINK_MODIFIED; 3214 } 3215 } 3216 3217 if (tb[IFLA_GRO_IPV4_MAX_SIZE]) { 3218 u32 gro_max_size = nla_get_u32(tb[IFLA_GRO_IPV4_MAX_SIZE]); 3219 3220 if (dev->gro_ipv4_max_size ^ gro_max_size) { 3221 netif_set_gro_ipv4_max_size(dev, gro_max_size); 3222 status |= DO_SETLINK_MODIFIED; 3223 } 3224 } 3225 3226 if (tb[IFLA_OPERSTATE]) 3227 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE])); 3228 3229 if (tb[IFLA_LINKMODE]) { 3230 unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]); 3231 3232 if (dev->link_mode ^ value) 3233 status |= DO_SETLINK_NOTIFY; 3234 WRITE_ONCE(dev->link_mode, value); 3235 } 3236 3237 if (tb[IFLA_VFINFO_LIST]) { 3238 struct nlattr *vfinfo[IFLA_VF_MAX + 1]; 3239 struct nlattr *attr; 3240 int rem; 3241 3242 nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) { 3243 if (nla_type(attr) != IFLA_VF_INFO || 3244 nla_len(attr) < NLA_HDRLEN) { 3245 err = -EINVAL; 3246 goto errout; 3247 } 3248 err = nla_parse_nested_deprecated(vfinfo, IFLA_VF_MAX, 3249 attr, 3250 ifla_vf_policy, 3251 NULL); 3252 if (err < 0) 3253 goto errout; 3254 err = do_setvfinfo(dev, vfinfo); 3255 if (err < 0) 3256 goto errout; 3257 status |= DO_SETLINK_NOTIFY; 3258 } 3259 } 3260 err = 0; 3261 3262 if (tb[IFLA_VF_PORTS]) { 3263 struct nlattr *port[IFLA_PORT_MAX+1]; 3264 struct nlattr *attr; 3265 int vf; 3266 int rem; 3267 3268 err = -EOPNOTSUPP; 3269 if (!ops->ndo_set_vf_port) 3270 goto errout; 3271 3272 nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) { 3273 if (nla_type(attr) != IFLA_VF_PORT || 3274 nla_len(attr) < NLA_HDRLEN) { 3275 err = -EINVAL; 3276 goto errout; 3277 } 3278 err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX, 3279 attr, 3280 ifla_port_policy, 3281 NULL); 3282 if (err < 0) 3283 goto errout; 3284 if (!port[IFLA_PORT_VF]) { 3285 err = -EOPNOTSUPP; 3286 goto errout; 3287 } 3288 vf = nla_get_u32(port[IFLA_PORT_VF]); 3289 err = ops->ndo_set_vf_port(dev, vf, port); 3290 if (err < 0) 3291 goto errout; 3292 status |= DO_SETLINK_NOTIFY; 3293 } 3294 } 3295 err = 0; 3296 3297 if (tb[IFLA_PORT_SELF]) { 3298 struct nlattr *port[IFLA_PORT_MAX+1]; 3299 3300 err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX, 3301 tb[IFLA_PORT_SELF], 3302 ifla_port_policy, NULL); 3303 if (err < 0) 3304 goto errout; 3305 3306 err = -EOPNOTSUPP; 3307 if (ops->ndo_set_vf_port) 3308 err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port); 3309 if (err < 0) 3310 goto errout; 3311 status |= DO_SETLINK_NOTIFY; 3312 } 3313 3314 if (tb[IFLA_AF_SPEC]) { 3315 struct nlattr *af; 3316 int rem; 3317 3318 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) { 3319 struct rtnl_af_ops *af_ops; 3320 int af_ops_srcu_index; 3321 3322 af_ops = rtnl_af_lookup(nla_type(af), &af_ops_srcu_index); 3323 if (!af_ops) { 3324 err = -EAFNOSUPPORT; 3325 goto errout; 3326 } 3327 3328 err = af_ops->set_link_af(dev, af, extack); 3329 rtnl_af_put(af_ops, af_ops_srcu_index); 3330 3331 if (err < 0) 3332 goto errout; 3333 3334 status |= DO_SETLINK_NOTIFY; 3335 } 3336 } 3337 err = 0; 3338 3339 if (tb[IFLA_PROTO_DOWN] || tb[IFLA_PROTO_DOWN_REASON]) { 3340 err = do_set_proto_down(dev, tb[IFLA_PROTO_DOWN], 3341 tb[IFLA_PROTO_DOWN_REASON], extack); 3342 if (err) 3343 goto errout; 3344 status |= DO_SETLINK_NOTIFY; 3345 } 3346 3347 if (tb[IFLA_XDP]) { 3348 struct nlattr *xdp[IFLA_XDP_MAX + 1]; 3349 u32 xdp_flags = 0; 3350 3351 err = nla_parse_nested_deprecated(xdp, IFLA_XDP_MAX, 3352 tb[IFLA_XDP], 3353 ifla_xdp_policy, NULL); 3354 if (err < 0) 3355 goto errout; 3356 3357 if (xdp[IFLA_XDP_ATTACHED] || xdp[IFLA_XDP_PROG_ID]) { 3358 err = -EINVAL; 3359 goto errout; 3360 } 3361 3362 if (xdp[IFLA_XDP_FLAGS]) { 3363 xdp_flags = nla_get_u32(xdp[IFLA_XDP_FLAGS]); 3364 if (xdp_flags & ~XDP_FLAGS_MASK) { 3365 err = -EINVAL; 3366 goto errout; 3367 } 3368 if (hweight32(xdp_flags & XDP_FLAGS_MODES) > 1) { 3369 err = -EINVAL; 3370 goto errout; 3371 } 3372 } 3373 3374 if (xdp[IFLA_XDP_FD]) { 3375 int expected_fd = -1; 3376 3377 if (xdp_flags & XDP_FLAGS_REPLACE) { 3378 if (!xdp[IFLA_XDP_EXPECTED_FD]) { 3379 err = -EINVAL; 3380 goto errout; 3381 } 3382 expected_fd = 3383 nla_get_s32(xdp[IFLA_XDP_EXPECTED_FD]); 3384 } 3385 3386 err = dev_change_xdp_fd(dev, extack, 3387 nla_get_s32(xdp[IFLA_XDP_FD]), 3388 expected_fd, 3389 xdp_flags); 3390 if (err) 3391 goto errout; 3392 status |= DO_SETLINK_NOTIFY; 3393 } 3394 } 3395 3396 errout: 3397 if (status & DO_SETLINK_MODIFIED) { 3398 if ((status & DO_SETLINK_NOTIFY) == DO_SETLINK_NOTIFY) 3399 netif_state_change(dev); 3400 3401 if (err < 0) 3402 net_warn_ratelimited("A link change request failed with some changes committed already. Interface %s may have been left with an inconsistent configuration, please check.\n", 3403 dev->name); 3404 } 3405 3406 netdev_unlock_ops(dev); 3407 3408 return err; 3409 } 3410 3411 static struct net_device *rtnl_dev_get(struct net *net, 3412 struct nlattr *tb[]) 3413 { 3414 char ifname[ALTIFNAMSIZ]; 3415 3416 if (tb[IFLA_IFNAME]) 3417 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 3418 else if (tb[IFLA_ALT_IFNAME]) 3419 nla_strscpy(ifname, tb[IFLA_ALT_IFNAME], ALTIFNAMSIZ); 3420 else 3421 return NULL; 3422 3423 return __dev_get_by_name(net, ifname); 3424 } 3425 3426 static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, 3427 struct netlink_ext_ack *extack) 3428 { 3429 struct ifinfomsg *ifm = nlmsg_data(nlh); 3430 struct net *net = sock_net(skb->sk); 3431 struct nlattr *tb[IFLA_MAX+1]; 3432 struct net_device *dev = NULL; 3433 struct rtnl_nets rtnl_nets; 3434 struct net *tgt_net; 3435 int err; 3436 3437 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX, 3438 ifla_policy, extack); 3439 if (err < 0) 3440 goto errout; 3441 3442 err = rtnl_ensure_unique_netns(tb, extack, false); 3443 if (err < 0) 3444 goto errout; 3445 3446 tgt_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN); 3447 if (IS_ERR(tgt_net)) { 3448 err = PTR_ERR(tgt_net); 3449 goto errout; 3450 } 3451 3452 rtnl_nets_init(&rtnl_nets); 3453 rtnl_nets_add(&rtnl_nets, get_net(net)); 3454 rtnl_nets_add(&rtnl_nets, tgt_net); 3455 3456 rtnl_nets_lock(&rtnl_nets); 3457 3458 if (ifm->ifi_index > 0) 3459 dev = __dev_get_by_index(net, ifm->ifi_index); 3460 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) 3461 dev = rtnl_dev_get(net, tb); 3462 else 3463 err = -EINVAL; 3464 3465 if (dev) 3466 err = do_setlink(skb, dev, tgt_net, ifm, extack, tb, 0); 3467 else if (!err) 3468 err = -ENODEV; 3469 3470 rtnl_nets_unlock(&rtnl_nets); 3471 rtnl_nets_destroy(&rtnl_nets); 3472 errout: 3473 return err; 3474 } 3475 3476 static int rtnl_group_dellink(const struct net *net, int group) 3477 { 3478 struct net_device *dev, *aux; 3479 LIST_HEAD(list_kill); 3480 bool found = false; 3481 3482 if (!group) 3483 return -EPERM; 3484 3485 for_each_netdev(net, dev) { 3486 if (dev->group == group) { 3487 const struct rtnl_link_ops *ops; 3488 3489 found = true; 3490 ops = dev->rtnl_link_ops; 3491 if (!ops || !ops->dellink) 3492 return -EOPNOTSUPP; 3493 } 3494 } 3495 3496 if (!found) 3497 return -ENODEV; 3498 3499 for_each_netdev_safe(net, dev, aux) { 3500 if (dev->group == group) { 3501 const struct rtnl_link_ops *ops; 3502 3503 ops = dev->rtnl_link_ops; 3504 ops->dellink(dev, &list_kill); 3505 } 3506 } 3507 unregister_netdevice_many(&list_kill); 3508 3509 return 0; 3510 } 3511 3512 int rtnl_delete_link(struct net_device *dev, u32 portid, const struct nlmsghdr *nlh) 3513 { 3514 const struct rtnl_link_ops *ops; 3515 LIST_HEAD(list_kill); 3516 3517 ops = dev->rtnl_link_ops; 3518 if (!ops || !ops->dellink) 3519 return -EOPNOTSUPP; 3520 3521 ops->dellink(dev, &list_kill); 3522 unregister_netdevice_many_notify(&list_kill, portid, nlh); 3523 3524 return 0; 3525 } 3526 EXPORT_SYMBOL_GPL(rtnl_delete_link); 3527 3528 static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, 3529 struct netlink_ext_ack *extack) 3530 { 3531 struct ifinfomsg *ifm = nlmsg_data(nlh); 3532 struct net *net = sock_net(skb->sk); 3533 u32 portid = NETLINK_CB(skb).portid; 3534 struct nlattr *tb[IFLA_MAX+1]; 3535 struct net_device *dev = NULL; 3536 struct net *tgt_net = net; 3537 int netnsid = -1; 3538 int err; 3539 3540 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX, 3541 ifla_policy, extack); 3542 if (err < 0) 3543 return err; 3544 3545 err = rtnl_ensure_unique_netns(tb, extack, true); 3546 if (err < 0) 3547 return err; 3548 3549 if (tb[IFLA_TARGET_NETNSID]) { 3550 netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]); 3551 tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid); 3552 if (IS_ERR(tgt_net)) 3553 return PTR_ERR(tgt_net); 3554 } 3555 3556 rtnl_net_lock(tgt_net); 3557 3558 if (ifm->ifi_index > 0) 3559 dev = __dev_get_by_index(tgt_net, ifm->ifi_index); 3560 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) 3561 dev = rtnl_dev_get(tgt_net, tb); 3562 3563 if (dev) 3564 err = rtnl_delete_link(dev, portid, nlh); 3565 else if (ifm->ifi_index > 0 || tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) 3566 err = -ENODEV; 3567 else if (tb[IFLA_GROUP]) 3568 err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP])); 3569 else 3570 err = -EINVAL; 3571 3572 rtnl_net_unlock(tgt_net); 3573 3574 if (netnsid >= 0) 3575 put_net(tgt_net); 3576 3577 return err; 3578 } 3579 3580 int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm, 3581 u32 portid, const struct nlmsghdr *nlh) 3582 { 3583 unsigned int old_flags; 3584 int err; 3585 3586 old_flags = dev->flags; 3587 if (ifm && (ifm->ifi_flags || ifm->ifi_change)) { 3588 err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm), 3589 NULL); 3590 if (err < 0) 3591 return err; 3592 } 3593 3594 if (dev->rtnl_link_state == RTNL_LINK_INITIALIZED) { 3595 __dev_notify_flags(dev, old_flags, (old_flags ^ dev->flags), portid, nlh); 3596 } else { 3597 dev->rtnl_link_state = RTNL_LINK_INITIALIZED; 3598 __dev_notify_flags(dev, old_flags, ~0U, portid, nlh); 3599 } 3600 return 0; 3601 } 3602 EXPORT_SYMBOL(rtnl_configure_link); 3603 3604 struct net_device *rtnl_create_link(struct net *net, const char *ifname, 3605 unsigned char name_assign_type, 3606 const struct rtnl_link_ops *ops, 3607 struct nlattr *tb[], 3608 struct netlink_ext_ack *extack) 3609 { 3610 struct net_device *dev; 3611 unsigned int num_tx_queues = 1; 3612 unsigned int num_rx_queues = 1; 3613 int err; 3614 3615 if (tb[IFLA_NUM_TX_QUEUES]) 3616 num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]); 3617 else if (ops->get_num_tx_queues) 3618 num_tx_queues = ops->get_num_tx_queues(); 3619 3620 if (tb[IFLA_NUM_RX_QUEUES]) 3621 num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]); 3622 else if (ops->get_num_rx_queues) 3623 num_rx_queues = ops->get_num_rx_queues(); 3624 3625 if (num_tx_queues < 1 || num_tx_queues > 4096) { 3626 NL_SET_ERR_MSG(extack, "Invalid number of transmit queues"); 3627 return ERR_PTR(-EINVAL); 3628 } 3629 3630 if (num_rx_queues < 1 || num_rx_queues > 4096) { 3631 NL_SET_ERR_MSG(extack, "Invalid number of receive queues"); 3632 return ERR_PTR(-EINVAL); 3633 } 3634 3635 if (ops->alloc) { 3636 dev = ops->alloc(tb, ifname, name_assign_type, 3637 num_tx_queues, num_rx_queues); 3638 if (IS_ERR(dev)) 3639 return dev; 3640 } else { 3641 dev = alloc_netdev_mqs(ops->priv_size, ifname, 3642 name_assign_type, ops->setup, 3643 num_tx_queues, num_rx_queues); 3644 } 3645 3646 if (!dev) 3647 return ERR_PTR(-ENOMEM); 3648 3649 err = validate_linkmsg(dev, tb, extack); 3650 if (err < 0) { 3651 free_netdev(dev); 3652 return ERR_PTR(err); 3653 } 3654 3655 dev_net_set(dev, net); 3656 dev->rtnl_link_ops = ops; 3657 dev->rtnl_link_state = RTNL_LINK_INITIALIZING; 3658 3659 if (tb[IFLA_MTU]) { 3660 u32 mtu = nla_get_u32(tb[IFLA_MTU]); 3661 3662 err = dev_validate_mtu(dev, mtu, extack); 3663 if (err) { 3664 free_netdev(dev); 3665 return ERR_PTR(err); 3666 } 3667 dev->mtu = mtu; 3668 } 3669 if (tb[IFLA_ADDRESS]) { 3670 __dev_addr_set(dev, nla_data(tb[IFLA_ADDRESS]), 3671 nla_len(tb[IFLA_ADDRESS])); 3672 dev->addr_assign_type = NET_ADDR_SET; 3673 } 3674 if (tb[IFLA_BROADCAST]) 3675 memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]), 3676 nla_len(tb[IFLA_BROADCAST])); 3677 if (tb[IFLA_TXQLEN]) 3678 dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]); 3679 if (tb[IFLA_OPERSTATE]) { 3680 netdev_lock_ops(dev); 3681 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE])); 3682 netdev_unlock_ops(dev); 3683 } 3684 if (tb[IFLA_LINKMODE]) 3685 dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]); 3686 if (tb[IFLA_GROUP]) 3687 dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP])); 3688 if (tb[IFLA_GSO_MAX_SIZE]) 3689 netif_set_gso_max_size(dev, nla_get_u32(tb[IFLA_GSO_MAX_SIZE])); 3690 if (tb[IFLA_GSO_MAX_SEGS]) 3691 netif_set_gso_max_segs(dev, nla_get_u32(tb[IFLA_GSO_MAX_SEGS])); 3692 if (tb[IFLA_GRO_MAX_SIZE]) 3693 netif_set_gro_max_size(dev, nla_get_u32(tb[IFLA_GRO_MAX_SIZE])); 3694 if (tb[IFLA_GSO_IPV4_MAX_SIZE]) 3695 netif_set_gso_ipv4_max_size(dev, nla_get_u32(tb[IFLA_GSO_IPV4_MAX_SIZE])); 3696 if (tb[IFLA_GRO_IPV4_MAX_SIZE]) 3697 netif_set_gro_ipv4_max_size(dev, nla_get_u32(tb[IFLA_GRO_IPV4_MAX_SIZE])); 3698 3699 return dev; 3700 } 3701 EXPORT_SYMBOL(rtnl_create_link); 3702 3703 struct rtnl_newlink_tbs { 3704 struct nlattr *tb[IFLA_MAX + 1]; 3705 struct nlattr *linkinfo[IFLA_INFO_MAX + 1]; 3706 struct nlattr *attr[RTNL_MAX_TYPE + 1]; 3707 struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1]; 3708 }; 3709 3710 static int rtnl_changelink(const struct sk_buff *skb, struct nlmsghdr *nlh, 3711 const struct rtnl_link_ops *ops, 3712 struct net_device *dev, struct net *tgt_net, 3713 struct rtnl_newlink_tbs *tbs, 3714 struct nlattr **data, 3715 struct netlink_ext_ack *extack) 3716 { 3717 struct nlattr ** const linkinfo = tbs->linkinfo; 3718 struct nlattr ** const tb = tbs->tb; 3719 int status = 0; 3720 int err; 3721 3722 if (nlh->nlmsg_flags & NLM_F_EXCL) 3723 return -EEXIST; 3724 3725 if (nlh->nlmsg_flags & NLM_F_REPLACE) 3726 return -EOPNOTSUPP; 3727 3728 if (linkinfo[IFLA_INFO_DATA]) { 3729 if (!ops || ops != dev->rtnl_link_ops || !ops->changelink) 3730 return -EOPNOTSUPP; 3731 3732 err = ops->changelink(dev, tb, data, extack); 3733 if (err < 0) 3734 return err; 3735 3736 status |= DO_SETLINK_NOTIFY; 3737 } 3738 3739 if (linkinfo[IFLA_INFO_SLAVE_DATA]) { 3740 const struct rtnl_link_ops *m_ops = NULL; 3741 struct nlattr **slave_data = NULL; 3742 struct net_device *master_dev; 3743 3744 master_dev = netdev_master_upper_dev_get(dev); 3745 if (master_dev) 3746 m_ops = master_dev->rtnl_link_ops; 3747 3748 if (!m_ops || !m_ops->slave_changelink) 3749 return -EOPNOTSUPP; 3750 3751 if (m_ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE) 3752 return -EINVAL; 3753 3754 if (m_ops->slave_maxtype) { 3755 err = nla_parse_nested_deprecated(tbs->slave_attr, 3756 m_ops->slave_maxtype, 3757 linkinfo[IFLA_INFO_SLAVE_DATA], 3758 m_ops->slave_policy, extack); 3759 if (err < 0) 3760 return err; 3761 3762 slave_data = tbs->slave_attr; 3763 } 3764 3765 err = m_ops->slave_changelink(master_dev, dev, tb, slave_data, extack); 3766 if (err < 0) 3767 return err; 3768 3769 status |= DO_SETLINK_NOTIFY; 3770 } 3771 3772 return do_setlink(skb, dev, tgt_net, nlmsg_data(nlh), extack, tb, status); 3773 } 3774 3775 static int rtnl_group_changelink(const struct sk_buff *skb, 3776 struct net *net, struct net *tgt_net, 3777 int group, struct ifinfomsg *ifm, 3778 struct netlink_ext_ack *extack, 3779 struct nlattr **tb) 3780 { 3781 struct net_device *dev, *aux; 3782 int err; 3783 3784 for_each_netdev_safe(net, dev, aux) { 3785 if (dev->group == group) { 3786 err = do_setlink(skb, dev, tgt_net, ifm, extack, tb, 0); 3787 if (err < 0) 3788 return err; 3789 } 3790 } 3791 3792 return 0; 3793 } 3794 3795 static int rtnl_newlink_create(struct sk_buff *skb, struct ifinfomsg *ifm, 3796 const struct rtnl_link_ops *ops, 3797 struct net *tgt_net, struct net *link_net, 3798 struct net *peer_net, 3799 const struct nlmsghdr *nlh, 3800 struct nlattr **tb, struct nlattr **data, 3801 struct netlink_ext_ack *extack) 3802 { 3803 unsigned char name_assign_type = NET_NAME_USER; 3804 struct rtnl_newlink_params params = { 3805 .src_net = sock_net(skb->sk), 3806 .link_net = link_net, 3807 .peer_net = peer_net, 3808 .tb = tb, 3809 .data = data, 3810 }; 3811 u32 portid = NETLINK_CB(skb).portid; 3812 struct net_device *dev; 3813 char ifname[IFNAMSIZ]; 3814 int err; 3815 3816 if (!ops->alloc && !ops->setup) 3817 return -EOPNOTSUPP; 3818 3819 if (tb[IFLA_IFNAME]) { 3820 nla_strscpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 3821 } else { 3822 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind); 3823 name_assign_type = NET_NAME_ENUM; 3824 } 3825 3826 dev = rtnl_create_link(tgt_net, ifname, name_assign_type, ops, tb, 3827 extack); 3828 if (IS_ERR(dev)) { 3829 err = PTR_ERR(dev); 3830 goto out; 3831 } 3832 3833 dev->ifindex = ifm->ifi_index; 3834 3835 if (ops->newlink) 3836 err = ops->newlink(dev, ¶ms, extack); 3837 else 3838 err = register_netdevice(dev); 3839 if (err < 0) { 3840 free_netdev(dev); 3841 goto out; 3842 } 3843 3844 netdev_lock_ops(dev); 3845 3846 err = rtnl_configure_link(dev, ifm, portid, nlh); 3847 if (err < 0) 3848 goto out_unregister; 3849 if (tb[IFLA_MASTER]) { 3850 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack); 3851 if (err) 3852 goto out_unregister; 3853 } 3854 3855 netdev_unlock_ops(dev); 3856 out: 3857 return err; 3858 out_unregister: 3859 netdev_unlock_ops(dev); 3860 if (ops->newlink) { 3861 LIST_HEAD(list_kill); 3862 3863 ops->dellink(dev, &list_kill); 3864 unregister_netdevice_many(&list_kill); 3865 } else { 3866 unregister_netdevice(dev); 3867 } 3868 goto out; 3869 } 3870 3871 static struct net *rtnl_get_peer_net(const struct rtnl_link_ops *ops, 3872 struct nlattr *tbp[], 3873 struct nlattr *data[], 3874 struct netlink_ext_ack *extack) 3875 { 3876 struct nlattr *tb[IFLA_MAX + 1]; 3877 int err; 3878 3879 if (!data || !data[ops->peer_type]) 3880 return rtnl_link_get_net_ifla(tbp); 3881 3882 err = rtnl_nla_parse_ifinfomsg(tb, data[ops->peer_type], extack); 3883 if (err < 0) 3884 return ERR_PTR(err); 3885 3886 if (ops->validate) { 3887 err = ops->validate(tb, NULL, extack); 3888 if (err < 0) 3889 return ERR_PTR(err); 3890 } 3891 3892 return rtnl_link_get_net_ifla(tb); 3893 } 3894 3895 static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, 3896 const struct rtnl_link_ops *ops, 3897 struct net *tgt_net, struct net *link_net, 3898 struct net *peer_net, 3899 struct rtnl_newlink_tbs *tbs, 3900 struct nlattr **data, 3901 struct netlink_ext_ack *extack) 3902 { 3903 struct nlattr ** const tb = tbs->tb; 3904 struct net *net = sock_net(skb->sk); 3905 struct net *device_net; 3906 struct net_device *dev; 3907 struct ifinfomsg *ifm; 3908 bool link_specified; 3909 3910 /* When creating, lookup for existing device in target net namespace */ 3911 device_net = (nlh->nlmsg_flags & NLM_F_CREATE) && 3912 (nlh->nlmsg_flags & NLM_F_EXCL) ? 3913 tgt_net : net; 3914 3915 ifm = nlmsg_data(nlh); 3916 if (ifm->ifi_index > 0) { 3917 link_specified = true; 3918 dev = __dev_get_by_index(device_net, ifm->ifi_index); 3919 } else if (ifm->ifi_index < 0) { 3920 NL_SET_ERR_MSG(extack, "ifindex can't be negative"); 3921 return -EINVAL; 3922 } else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) { 3923 link_specified = true; 3924 dev = rtnl_dev_get(device_net, tb); 3925 } else { 3926 link_specified = false; 3927 dev = NULL; 3928 } 3929 3930 if (dev) 3931 return rtnl_changelink(skb, nlh, ops, dev, tgt_net, tbs, data, extack); 3932 3933 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 3934 /* No dev found and NLM_F_CREATE not set. Requested dev does not exist, 3935 * or it's for a group 3936 */ 3937 if (link_specified || !tb[IFLA_GROUP]) 3938 return -ENODEV; 3939 3940 return rtnl_group_changelink(skb, net, tgt_net, 3941 nla_get_u32(tb[IFLA_GROUP]), 3942 ifm, extack, tb); 3943 } 3944 3945 if (tb[IFLA_MAP] || tb[IFLA_PROTINFO]) 3946 return -EOPNOTSUPP; 3947 3948 if (!ops) { 3949 NL_SET_ERR_MSG(extack, "Unknown device type"); 3950 return -EOPNOTSUPP; 3951 } 3952 3953 return rtnl_newlink_create(skb, ifm, ops, tgt_net, link_net, peer_net, nlh, 3954 tb, data, extack); 3955 } 3956 3957 static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, 3958 struct netlink_ext_ack *extack) 3959 { 3960 struct net *tgt_net, *link_net = NULL, *peer_net = NULL; 3961 struct nlattr **tb, **linkinfo, **data = NULL; 3962 struct rtnl_link_ops *ops = NULL; 3963 struct rtnl_newlink_tbs *tbs; 3964 struct rtnl_nets rtnl_nets; 3965 int ops_srcu_index; 3966 int ret; 3967 3968 tbs = kmalloc(sizeof(*tbs), GFP_KERNEL); 3969 if (!tbs) 3970 return -ENOMEM; 3971 3972 tb = tbs->tb; 3973 ret = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg), tb, 3974 IFLA_MAX, ifla_policy, extack); 3975 if (ret < 0) 3976 goto free; 3977 3978 ret = rtnl_ensure_unique_netns(tb, extack, false); 3979 if (ret < 0) 3980 goto free; 3981 3982 linkinfo = tbs->linkinfo; 3983 if (tb[IFLA_LINKINFO]) { 3984 ret = nla_parse_nested_deprecated(linkinfo, IFLA_INFO_MAX, 3985 tb[IFLA_LINKINFO], 3986 ifla_info_policy, NULL); 3987 if (ret < 0) 3988 goto free; 3989 } else { 3990 memset(linkinfo, 0, sizeof(tbs->linkinfo)); 3991 } 3992 3993 if (linkinfo[IFLA_INFO_KIND]) { 3994 char kind[MODULE_NAME_LEN]; 3995 3996 nla_strscpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind)); 3997 ops = rtnl_link_ops_get(kind, &ops_srcu_index); 3998 #ifdef CONFIG_MODULES 3999 if (!ops) { 4000 request_module("rtnl-link-%s", kind); 4001 ops = rtnl_link_ops_get(kind, &ops_srcu_index); 4002 } 4003 #endif 4004 } 4005 4006 rtnl_nets_init(&rtnl_nets); 4007 4008 if (ops) { 4009 if (ops->maxtype > RTNL_MAX_TYPE) { 4010 ret = -EINVAL; 4011 goto put_ops; 4012 } 4013 4014 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) { 4015 ret = nla_parse_nested_deprecated(tbs->attr, ops->maxtype, 4016 linkinfo[IFLA_INFO_DATA], 4017 ops->policy, extack); 4018 if (ret < 0) 4019 goto put_ops; 4020 4021 data = tbs->attr; 4022 } 4023 4024 if (ops->validate) { 4025 ret = ops->validate(tb, data, extack); 4026 if (ret < 0) 4027 goto put_ops; 4028 } 4029 4030 if (ops->peer_type) { 4031 peer_net = rtnl_get_peer_net(ops, tb, data, extack); 4032 if (IS_ERR(peer_net)) { 4033 ret = PTR_ERR(peer_net); 4034 goto put_ops; 4035 } 4036 if (peer_net) 4037 rtnl_nets_add(&rtnl_nets, peer_net); 4038 } 4039 } 4040 4041 tgt_net = rtnl_link_get_net_capable(skb, sock_net(skb->sk), tb, CAP_NET_ADMIN); 4042 if (IS_ERR(tgt_net)) { 4043 ret = PTR_ERR(tgt_net); 4044 goto put_net; 4045 } 4046 4047 rtnl_nets_add(&rtnl_nets, tgt_net); 4048 4049 if (tb[IFLA_LINK_NETNSID]) { 4050 int id = nla_get_s32(tb[IFLA_LINK_NETNSID]); 4051 4052 link_net = get_net_ns_by_id(tgt_net, id); 4053 if (!link_net) { 4054 NL_SET_ERR_MSG(extack, "Unknown network namespace id"); 4055 ret = -EINVAL; 4056 goto put_net; 4057 } 4058 4059 rtnl_nets_add(&rtnl_nets, link_net); 4060 4061 if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN)) { 4062 ret = -EPERM; 4063 goto put_net; 4064 } 4065 } 4066 4067 rtnl_nets_lock(&rtnl_nets); 4068 ret = __rtnl_newlink(skb, nlh, ops, tgt_net, link_net, peer_net, tbs, data, extack); 4069 rtnl_nets_unlock(&rtnl_nets); 4070 4071 put_net: 4072 rtnl_nets_destroy(&rtnl_nets); 4073 put_ops: 4074 if (ops) 4075 rtnl_link_ops_put(ops, ops_srcu_index); 4076 free: 4077 kfree(tbs); 4078 return ret; 4079 } 4080 4081 static int rtnl_valid_getlink_req(struct sk_buff *skb, 4082 const struct nlmsghdr *nlh, 4083 struct nlattr **tb, 4084 struct netlink_ext_ack *extack) 4085 { 4086 struct ifinfomsg *ifm; 4087 int i, err; 4088 4089 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) { 4090 NL_SET_ERR_MSG(extack, "Invalid header for get link"); 4091 return -EINVAL; 4092 } 4093 4094 if (!netlink_strict_get_check(skb)) 4095 return nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX, 4096 ifla_policy, extack); 4097 4098 ifm = nlmsg_data(nlh); 4099 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags || 4100 ifm->ifi_change) { 4101 NL_SET_ERR_MSG(extack, "Invalid values in header for get link request"); 4102 return -EINVAL; 4103 } 4104 4105 err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFLA_MAX, 4106 ifla_policy, extack); 4107 if (err) 4108 return err; 4109 4110 for (i = 0; i <= IFLA_MAX; i++) { 4111 if (!tb[i]) 4112 continue; 4113 4114 switch (i) { 4115 case IFLA_IFNAME: 4116 case IFLA_ALT_IFNAME: 4117 case IFLA_EXT_MASK: 4118 case IFLA_TARGET_NETNSID: 4119 break; 4120 default: 4121 NL_SET_ERR_MSG(extack, "Unsupported attribute in get link request"); 4122 return -EINVAL; 4123 } 4124 } 4125 4126 return 0; 4127 } 4128 4129 static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh, 4130 struct netlink_ext_ack *extack) 4131 { 4132 struct net *net = sock_net(skb->sk); 4133 struct net *tgt_net = net; 4134 struct ifinfomsg *ifm; 4135 struct nlattr *tb[IFLA_MAX+1]; 4136 struct net_device *dev = NULL; 4137 struct sk_buff *nskb; 4138 int netnsid = -1; 4139 int err; 4140 u32 ext_filter_mask = 0; 4141 4142 err = rtnl_valid_getlink_req(skb, nlh, tb, extack); 4143 if (err < 0) 4144 return err; 4145 4146 err = rtnl_ensure_unique_netns(tb, extack, true); 4147 if (err < 0) 4148 return err; 4149 4150 if (tb[IFLA_TARGET_NETNSID]) { 4151 netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]); 4152 tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid); 4153 if (IS_ERR(tgt_net)) 4154 return PTR_ERR(tgt_net); 4155 } 4156 4157 if (tb[IFLA_EXT_MASK]) 4158 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]); 4159 4160 err = -EINVAL; 4161 ifm = nlmsg_data(nlh); 4162 if (ifm->ifi_index > 0) 4163 dev = __dev_get_by_index(tgt_net, ifm->ifi_index); 4164 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) 4165 dev = rtnl_dev_get(tgt_net, tb); 4166 else 4167 goto out; 4168 4169 err = -ENODEV; 4170 if (dev == NULL) 4171 goto out; 4172 4173 err = -ENOBUFS; 4174 nskb = nlmsg_new_large(if_nlmsg_size(dev, ext_filter_mask)); 4175 if (nskb == NULL) 4176 goto out; 4177 4178 /* Synchronize the carrier state so we don't report a state 4179 * that we're not actually going to honour immediately; if 4180 * the driver just did a carrier off->on transition, we can 4181 * only TX if link watch work has run, but without this we'd 4182 * already report carrier on, even if it doesn't work yet. 4183 */ 4184 linkwatch_sync_dev(dev); 4185 4186 err = rtnl_fill_ifinfo(nskb, dev, net, 4187 RTM_NEWLINK, NETLINK_CB(skb).portid, 4188 nlh->nlmsg_seq, 0, 0, ext_filter_mask, 4189 0, NULL, 0, netnsid, GFP_KERNEL); 4190 if (err < 0) { 4191 /* -EMSGSIZE implies BUG in if_nlmsg_size */ 4192 WARN_ON(err == -EMSGSIZE); 4193 kfree_skb(nskb); 4194 } else 4195 err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid); 4196 out: 4197 if (netnsid >= 0) 4198 put_net(tgt_net); 4199 4200 return err; 4201 } 4202 4203 static int rtnl_alt_ifname(int cmd, struct net_device *dev, struct nlattr *attr, 4204 bool *changed, struct netlink_ext_ack *extack) 4205 { 4206 char *alt_ifname; 4207 size_t size; 4208 int err; 4209 4210 err = nla_validate(attr, attr->nla_len, IFLA_MAX, ifla_policy, extack); 4211 if (err) 4212 return err; 4213 4214 if (cmd == RTM_NEWLINKPROP) { 4215 size = rtnl_prop_list_size(dev); 4216 size += nla_total_size(ALTIFNAMSIZ); 4217 if (size >= U16_MAX) { 4218 NL_SET_ERR_MSG(extack, 4219 "effective property list too long"); 4220 return -EINVAL; 4221 } 4222 } 4223 4224 alt_ifname = nla_strdup(attr, GFP_KERNEL_ACCOUNT); 4225 if (!alt_ifname) 4226 return -ENOMEM; 4227 4228 if (cmd == RTM_NEWLINKPROP) { 4229 err = netdev_name_node_alt_create(dev, alt_ifname); 4230 if (!err) 4231 alt_ifname = NULL; 4232 } else if (cmd == RTM_DELLINKPROP) { 4233 err = netdev_name_node_alt_destroy(dev, alt_ifname); 4234 } else { 4235 WARN_ON_ONCE(1); 4236 err = -EINVAL; 4237 } 4238 4239 kfree(alt_ifname); 4240 if (!err) 4241 *changed = true; 4242 return err; 4243 } 4244 4245 static int rtnl_linkprop(int cmd, struct sk_buff *skb, struct nlmsghdr *nlh, 4246 struct netlink_ext_ack *extack) 4247 { 4248 struct net *net = sock_net(skb->sk); 4249 struct nlattr *tb[IFLA_MAX + 1]; 4250 struct net_device *dev; 4251 struct ifinfomsg *ifm; 4252 bool changed = false; 4253 struct nlattr *attr; 4254 int err, rem; 4255 4256 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack); 4257 if (err) 4258 return err; 4259 4260 err = rtnl_ensure_unique_netns(tb, extack, true); 4261 if (err) 4262 return err; 4263 4264 ifm = nlmsg_data(nlh); 4265 if (ifm->ifi_index > 0) 4266 dev = __dev_get_by_index(net, ifm->ifi_index); 4267 else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME]) 4268 dev = rtnl_dev_get(net, tb); 4269 else 4270 return -EINVAL; 4271 4272 if (!dev) 4273 return -ENODEV; 4274 4275 if (!tb[IFLA_PROP_LIST]) 4276 return 0; 4277 4278 nla_for_each_nested(attr, tb[IFLA_PROP_LIST], rem) { 4279 switch (nla_type(attr)) { 4280 case IFLA_ALT_IFNAME: 4281 err = rtnl_alt_ifname(cmd, dev, attr, &changed, extack); 4282 if (err) 4283 return err; 4284 break; 4285 } 4286 } 4287 4288 if (changed) 4289 netdev_state_change(dev); 4290 return 0; 4291 } 4292 4293 static int rtnl_newlinkprop(struct sk_buff *skb, struct nlmsghdr *nlh, 4294 struct netlink_ext_ack *extack) 4295 { 4296 return rtnl_linkprop(RTM_NEWLINKPROP, skb, nlh, extack); 4297 } 4298 4299 static int rtnl_dellinkprop(struct sk_buff *skb, struct nlmsghdr *nlh, 4300 struct netlink_ext_ack *extack) 4301 { 4302 return rtnl_linkprop(RTM_DELLINKPROP, skb, nlh, extack); 4303 } 4304 4305 static noinline_for_stack u32 rtnl_calcit(struct sk_buff *skb, 4306 struct nlmsghdr *nlh) 4307 { 4308 struct net *net = sock_net(skb->sk); 4309 size_t min_ifinfo_dump_size = 0; 4310 u32 ext_filter_mask = 0; 4311 struct net_device *dev; 4312 struct nlattr *nla; 4313 int hdrlen, rem; 4314 4315 /* Same kernel<->userspace interface hack as in rtnl_dump_ifinfo. */ 4316 hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ? 4317 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg); 4318 4319 if (nlh->nlmsg_len < nlmsg_msg_size(hdrlen)) 4320 return NLMSG_GOODSIZE; 4321 4322 nla_for_each_attr_type(nla, IFLA_EXT_MASK, 4323 nlmsg_attrdata(nlh, hdrlen), 4324 nlmsg_attrlen(nlh, hdrlen), rem) { 4325 if (nla_len(nla) == sizeof(u32)) 4326 ext_filter_mask = nla_get_u32(nla); 4327 } 4328 4329 if (!ext_filter_mask) 4330 return NLMSG_GOODSIZE; 4331 /* 4332 * traverse the list of net devices and compute the minimum 4333 * buffer size based upon the filter mask. 4334 */ 4335 rcu_read_lock(); 4336 for_each_netdev_rcu(net, dev) { 4337 min_ifinfo_dump_size = max(min_ifinfo_dump_size, 4338 if_nlmsg_size(dev, ext_filter_mask)); 4339 } 4340 rcu_read_unlock(); 4341 4342 return nlmsg_total_size(min_ifinfo_dump_size); 4343 } 4344 4345 static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb) 4346 { 4347 int idx; 4348 int s_idx = cb->family; 4349 int type = cb->nlh->nlmsg_type - RTM_BASE; 4350 int ret = 0; 4351 4352 if (s_idx == 0) 4353 s_idx = 1; 4354 4355 for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) { 4356 struct rtnl_link __rcu **tab; 4357 struct rtnl_link *link; 4358 rtnl_dumpit_func dumpit; 4359 4360 if (idx < s_idx || idx == PF_PACKET) 4361 continue; 4362 4363 if (type < 0 || type >= RTM_NR_MSGTYPES) 4364 continue; 4365 4366 tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]); 4367 if (!tab) 4368 continue; 4369 4370 link = rcu_dereference_rtnl(tab[type]); 4371 if (!link) 4372 continue; 4373 4374 dumpit = link->dumpit; 4375 if (!dumpit) 4376 continue; 4377 4378 if (idx > s_idx) { 4379 memset(&cb->args[0], 0, sizeof(cb->args)); 4380 cb->prev_seq = 0; 4381 cb->seq = 0; 4382 } 4383 ret = dumpit(skb, cb); 4384 if (ret) 4385 break; 4386 } 4387 cb->family = idx; 4388 4389 return skb->len ? : ret; 4390 } 4391 4392 struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev, 4393 unsigned int change, 4394 u32 event, gfp_t flags, int *new_nsid, 4395 int new_ifindex, u32 portid, 4396 const struct nlmsghdr *nlh) 4397 { 4398 struct net *net = dev_net(dev); 4399 struct sk_buff *skb; 4400 int err = -ENOBUFS; 4401 u32 seq = 0; 4402 4403 skb = nlmsg_new(if_nlmsg_size(dev, 0), flags); 4404 if (skb == NULL) 4405 goto errout; 4406 4407 if (nlmsg_report(nlh)) 4408 seq = nlmsg_seq(nlh); 4409 else 4410 portid = 0; 4411 4412 err = rtnl_fill_ifinfo(skb, dev, dev_net(dev), 4413 type, portid, seq, change, 0, 0, event, 4414 new_nsid, new_ifindex, -1, flags); 4415 if (err < 0) { 4416 /* -EMSGSIZE implies BUG in if_nlmsg_size() */ 4417 WARN_ON(err == -EMSGSIZE); 4418 kfree_skb(skb); 4419 goto errout; 4420 } 4421 return skb; 4422 errout: 4423 rtnl_set_sk_err(net, RTNLGRP_LINK, err); 4424 return NULL; 4425 } 4426 4427 void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags, 4428 u32 portid, const struct nlmsghdr *nlh) 4429 { 4430 struct net *net = dev_net(dev); 4431 4432 rtnl_notify(skb, net, portid, RTNLGRP_LINK, nlh, flags); 4433 } 4434 4435 static void rtmsg_ifinfo_event(int type, struct net_device *dev, 4436 unsigned int change, u32 event, 4437 gfp_t flags, int *new_nsid, int new_ifindex, 4438 u32 portid, const struct nlmsghdr *nlh) 4439 { 4440 struct sk_buff *skb; 4441 4442 if (dev->reg_state != NETREG_REGISTERED) 4443 return; 4444 4445 skb = rtmsg_ifinfo_build_skb(type, dev, change, event, flags, new_nsid, 4446 new_ifindex, portid, nlh); 4447 if (skb) 4448 rtmsg_ifinfo_send(skb, dev, flags, portid, nlh); 4449 } 4450 4451 void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change, 4452 gfp_t flags, u32 portid, const struct nlmsghdr *nlh) 4453 { 4454 rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags, 4455 NULL, 0, portid, nlh); 4456 } 4457 4458 void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change, 4459 gfp_t flags, int *new_nsid, int new_ifindex) 4460 { 4461 rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags, 4462 new_nsid, new_ifindex, 0, NULL); 4463 } 4464 4465 static int nlmsg_populate_fdb_fill(struct sk_buff *skb, 4466 struct net_device *dev, 4467 u8 *addr, u16 vid, u32 pid, u32 seq, 4468 int type, unsigned int flags, 4469 int nlflags, u16 ndm_state) 4470 { 4471 struct nlmsghdr *nlh; 4472 struct ndmsg *ndm; 4473 4474 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags); 4475 if (!nlh) 4476 return -EMSGSIZE; 4477 4478 ndm = nlmsg_data(nlh); 4479 ndm->ndm_family = AF_BRIDGE; 4480 ndm->ndm_pad1 = 0; 4481 ndm->ndm_pad2 = 0; 4482 ndm->ndm_flags = flags; 4483 ndm->ndm_type = 0; 4484 ndm->ndm_ifindex = dev->ifindex; 4485 ndm->ndm_state = ndm_state; 4486 4487 if (nla_put(skb, NDA_LLADDR, dev->addr_len, addr)) 4488 goto nla_put_failure; 4489 if (vid) 4490 if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid)) 4491 goto nla_put_failure; 4492 4493 nlmsg_end(skb, nlh); 4494 return 0; 4495 4496 nla_put_failure: 4497 nlmsg_cancel(skb, nlh); 4498 return -EMSGSIZE; 4499 } 4500 4501 static inline size_t rtnl_fdb_nlmsg_size(const struct net_device *dev) 4502 { 4503 return NLMSG_ALIGN(sizeof(struct ndmsg)) + 4504 nla_total_size(dev->addr_len) + /* NDA_LLADDR */ 4505 nla_total_size(sizeof(u16)) + /* NDA_VLAN */ 4506 0; 4507 } 4508 4509 static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type, 4510 u16 ndm_state) 4511 { 4512 struct net *net = dev_net(dev); 4513 struct sk_buff *skb; 4514 int err = -ENOBUFS; 4515 4516 skb = nlmsg_new(rtnl_fdb_nlmsg_size(dev), GFP_ATOMIC); 4517 if (!skb) 4518 goto errout; 4519 4520 err = nlmsg_populate_fdb_fill(skb, dev, addr, vid, 4521 0, 0, type, NTF_SELF, 0, ndm_state); 4522 if (err < 0) { 4523 kfree_skb(skb); 4524 goto errout; 4525 } 4526 4527 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 4528 return; 4529 errout: 4530 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err); 4531 } 4532 4533 /* 4534 * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry 4535 */ 4536 int ndo_dflt_fdb_add(struct ndmsg *ndm, 4537 struct nlattr *tb[], 4538 struct net_device *dev, 4539 const unsigned char *addr, u16 vid, 4540 u16 flags) 4541 { 4542 int err = -EINVAL; 4543 4544 /* If aging addresses are supported device will need to 4545 * implement its own handler for this. 4546 */ 4547 if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) { 4548 netdev_info(dev, "default FDB implementation only supports local addresses\n"); 4549 return err; 4550 } 4551 4552 if (tb[NDA_FLAGS_EXT]) { 4553 netdev_info(dev, "invalid flags given to default FDB implementation\n"); 4554 return err; 4555 } 4556 4557 if (vid) { 4558 netdev_info(dev, "vlans aren't supported yet for dev_uc|mc_add()\n"); 4559 return err; 4560 } 4561 4562 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) 4563 err = dev_uc_add_excl(dev, addr); 4564 else if (is_multicast_ether_addr(addr)) 4565 err = dev_mc_add_excl(dev, addr); 4566 4567 /* Only return duplicate errors if NLM_F_EXCL is set */ 4568 if (err == -EEXIST && !(flags & NLM_F_EXCL)) 4569 err = 0; 4570 4571 return err; 4572 } 4573 EXPORT_SYMBOL(ndo_dflt_fdb_add); 4574 4575 static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid, 4576 struct netlink_ext_ack *extack) 4577 { 4578 u16 vid = 0; 4579 4580 if (vlan_attr) { 4581 if (nla_len(vlan_attr) != sizeof(u16)) { 4582 NL_SET_ERR_MSG(extack, "invalid vlan attribute size"); 4583 return -EINVAL; 4584 } 4585 4586 vid = nla_get_u16(vlan_attr); 4587 4588 if (!vid || vid >= VLAN_VID_MASK) { 4589 NL_SET_ERR_MSG(extack, "invalid vlan id"); 4590 return -EINVAL; 4591 } 4592 } 4593 *p_vid = vid; 4594 return 0; 4595 } 4596 4597 static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, 4598 struct netlink_ext_ack *extack) 4599 { 4600 struct net *net = sock_net(skb->sk); 4601 struct ndmsg *ndm; 4602 struct nlattr *tb[NDA_MAX+1]; 4603 struct net_device *dev; 4604 u8 *addr; 4605 u16 vid; 4606 int err; 4607 4608 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, 4609 extack); 4610 if (err < 0) 4611 return err; 4612 4613 ndm = nlmsg_data(nlh); 4614 if (ndm->ndm_ifindex == 0) { 4615 NL_SET_ERR_MSG(extack, "invalid ifindex"); 4616 return -EINVAL; 4617 } 4618 4619 dev = __dev_get_by_index(net, ndm->ndm_ifindex); 4620 if (dev == NULL) { 4621 NL_SET_ERR_MSG(extack, "unknown ifindex"); 4622 return -ENODEV; 4623 } 4624 4625 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) { 4626 NL_SET_ERR_MSG(extack, "invalid address"); 4627 return -EINVAL; 4628 } 4629 4630 if (dev->type != ARPHRD_ETHER) { 4631 NL_SET_ERR_MSG(extack, "FDB add only supported for Ethernet devices"); 4632 return -EINVAL; 4633 } 4634 4635 addr = nla_data(tb[NDA_LLADDR]); 4636 4637 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack); 4638 if (err) 4639 return err; 4640 4641 err = -EOPNOTSUPP; 4642 4643 /* Support fdb on master device the net/bridge default case */ 4644 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) && 4645 netif_is_bridge_port(dev)) { 4646 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 4647 const struct net_device_ops *ops = br_dev->netdev_ops; 4648 bool notified = false; 4649 4650 err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid, 4651 nlh->nlmsg_flags, ¬ified, extack); 4652 if (err) 4653 goto out; 4654 else 4655 ndm->ndm_flags &= ~NTF_MASTER; 4656 } 4657 4658 /* Embedded bridge, macvlan, and any other device support */ 4659 if ((ndm->ndm_flags & NTF_SELF)) { 4660 bool notified = false; 4661 4662 if (dev->netdev_ops->ndo_fdb_add) 4663 err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr, 4664 vid, 4665 nlh->nlmsg_flags, 4666 ¬ified, extack); 4667 else 4668 err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid, 4669 nlh->nlmsg_flags); 4670 4671 if (!err && !notified) { 4672 rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH, 4673 ndm->ndm_state); 4674 ndm->ndm_flags &= ~NTF_SELF; 4675 } 4676 } 4677 out: 4678 return err; 4679 } 4680 4681 /* 4682 * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry 4683 */ 4684 int ndo_dflt_fdb_del(struct ndmsg *ndm, 4685 struct nlattr *tb[], 4686 struct net_device *dev, 4687 const unsigned char *addr, u16 vid) 4688 { 4689 int err = -EINVAL; 4690 4691 /* If aging addresses are supported device will need to 4692 * implement its own handler for this. 4693 */ 4694 if (!(ndm->ndm_state & NUD_PERMANENT)) { 4695 netdev_info(dev, "default FDB implementation only supports local addresses\n"); 4696 return err; 4697 } 4698 4699 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) 4700 err = dev_uc_del(dev, addr); 4701 else if (is_multicast_ether_addr(addr)) 4702 err = dev_mc_del(dev, addr); 4703 4704 return err; 4705 } 4706 EXPORT_SYMBOL(ndo_dflt_fdb_del); 4707 4708 static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh, 4709 struct netlink_ext_ack *extack) 4710 { 4711 bool del_bulk = !!(nlh->nlmsg_flags & NLM_F_BULK); 4712 struct net *net = sock_net(skb->sk); 4713 const struct net_device_ops *ops; 4714 struct ndmsg *ndm; 4715 struct nlattr *tb[NDA_MAX+1]; 4716 struct net_device *dev; 4717 __u8 *addr = NULL; 4718 int err; 4719 u16 vid; 4720 4721 if (!netlink_capable(skb, CAP_NET_ADMIN)) 4722 return -EPERM; 4723 4724 if (!del_bulk) { 4725 err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, 4726 NULL, extack); 4727 } else { 4728 /* For bulk delete, the drivers will parse the message with 4729 * policy. 4730 */ 4731 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, extack); 4732 } 4733 if (err < 0) 4734 return err; 4735 4736 ndm = nlmsg_data(nlh); 4737 if (ndm->ndm_ifindex == 0) { 4738 NL_SET_ERR_MSG(extack, "invalid ifindex"); 4739 return -EINVAL; 4740 } 4741 4742 dev = __dev_get_by_index(net, ndm->ndm_ifindex); 4743 if (dev == NULL) { 4744 NL_SET_ERR_MSG(extack, "unknown ifindex"); 4745 return -ENODEV; 4746 } 4747 4748 if (!del_bulk) { 4749 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) { 4750 NL_SET_ERR_MSG(extack, "invalid address"); 4751 return -EINVAL; 4752 } 4753 addr = nla_data(tb[NDA_LLADDR]); 4754 4755 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack); 4756 if (err) 4757 return err; 4758 } 4759 4760 if (dev->type != ARPHRD_ETHER) { 4761 NL_SET_ERR_MSG(extack, "FDB delete only supported for Ethernet devices"); 4762 return -EINVAL; 4763 } 4764 4765 err = -EOPNOTSUPP; 4766 4767 /* Support fdb on master device the net/bridge default case */ 4768 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) && 4769 netif_is_bridge_port(dev)) { 4770 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 4771 bool notified = false; 4772 4773 ops = br_dev->netdev_ops; 4774 if (!del_bulk) { 4775 if (ops->ndo_fdb_del) 4776 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid, 4777 ¬ified, extack); 4778 } else { 4779 if (ops->ndo_fdb_del_bulk) 4780 err = ops->ndo_fdb_del_bulk(nlh, dev, extack); 4781 } 4782 4783 if (err) 4784 goto out; 4785 else 4786 ndm->ndm_flags &= ~NTF_MASTER; 4787 } 4788 4789 /* Embedded bridge, macvlan, and any other device support */ 4790 if (ndm->ndm_flags & NTF_SELF) { 4791 bool notified = false; 4792 4793 ops = dev->netdev_ops; 4794 if (!del_bulk) { 4795 if (ops->ndo_fdb_del) 4796 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid, 4797 ¬ified, extack); 4798 else 4799 err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid); 4800 } else { 4801 /* in case err was cleared by NTF_MASTER call */ 4802 err = -EOPNOTSUPP; 4803 if (ops->ndo_fdb_del_bulk) 4804 err = ops->ndo_fdb_del_bulk(nlh, dev, extack); 4805 } 4806 4807 if (!err) { 4808 if (!del_bulk && !notified) 4809 rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH, 4810 ndm->ndm_state); 4811 ndm->ndm_flags &= ~NTF_SELF; 4812 } 4813 } 4814 out: 4815 return err; 4816 } 4817 4818 static int nlmsg_populate_fdb(struct sk_buff *skb, 4819 struct netlink_callback *cb, 4820 struct net_device *dev, 4821 int *idx, 4822 struct netdev_hw_addr_list *list) 4823 { 4824 struct ndo_fdb_dump_context *ctx = (void *)cb->ctx; 4825 struct netdev_hw_addr *ha; 4826 u32 portid, seq; 4827 int err; 4828 4829 portid = NETLINK_CB(cb->skb).portid; 4830 seq = cb->nlh->nlmsg_seq; 4831 4832 list_for_each_entry(ha, &list->list, list) { 4833 if (*idx < ctx->fdb_idx) 4834 goto skip; 4835 4836 err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0, 4837 portid, seq, 4838 RTM_NEWNEIGH, NTF_SELF, 4839 NLM_F_MULTI, NUD_PERMANENT); 4840 if (err < 0) 4841 return err; 4842 skip: 4843 *idx += 1; 4844 } 4845 return 0; 4846 } 4847 4848 /** 4849 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table. 4850 * @skb: socket buffer to store message in 4851 * @cb: netlink callback 4852 * @dev: netdevice 4853 * @filter_dev: ignored 4854 * @idx: the number of FDB table entries dumped is added to *@idx 4855 * 4856 * Default netdevice operation to dump the existing unicast address list. 4857 * Returns number of addresses from list put in skb. 4858 */ 4859 int ndo_dflt_fdb_dump(struct sk_buff *skb, 4860 struct netlink_callback *cb, 4861 struct net_device *dev, 4862 struct net_device *filter_dev, 4863 int *idx) 4864 { 4865 int err; 4866 4867 if (dev->type != ARPHRD_ETHER) 4868 return -EINVAL; 4869 4870 netif_addr_lock_bh(dev); 4871 err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->uc); 4872 if (err) 4873 goto out; 4874 err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->mc); 4875 out: 4876 netif_addr_unlock_bh(dev); 4877 return err; 4878 } 4879 EXPORT_SYMBOL(ndo_dflt_fdb_dump); 4880 4881 static int valid_fdb_dump_strict(const struct nlmsghdr *nlh, 4882 int *br_idx, int *brport_idx, 4883 struct netlink_ext_ack *extack) 4884 { 4885 struct nlattr *tb[NDA_MAX + 1]; 4886 struct ndmsg *ndm; 4887 int err, i; 4888 4889 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) { 4890 NL_SET_ERR_MSG(extack, "Invalid header for fdb dump request"); 4891 return -EINVAL; 4892 } 4893 4894 ndm = nlmsg_data(nlh); 4895 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state || 4896 ndm->ndm_flags || ndm->ndm_type) { 4897 NL_SET_ERR_MSG(extack, "Invalid values in header for fdb dump request"); 4898 return -EINVAL; 4899 } 4900 4901 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb, 4902 NDA_MAX, NULL, extack); 4903 if (err < 0) 4904 return err; 4905 4906 *brport_idx = ndm->ndm_ifindex; 4907 for (i = 0; i <= NDA_MAX; ++i) { 4908 if (!tb[i]) 4909 continue; 4910 4911 switch (i) { 4912 case NDA_IFINDEX: 4913 if (nla_len(tb[i]) != sizeof(u32)) { 4914 NL_SET_ERR_MSG(extack, "Invalid IFINDEX attribute in fdb dump request"); 4915 return -EINVAL; 4916 } 4917 *brport_idx = nla_get_u32(tb[NDA_IFINDEX]); 4918 break; 4919 case NDA_MASTER: 4920 if (nla_len(tb[i]) != sizeof(u32)) { 4921 NL_SET_ERR_MSG(extack, "Invalid MASTER attribute in fdb dump request"); 4922 return -EINVAL; 4923 } 4924 *br_idx = nla_get_u32(tb[NDA_MASTER]); 4925 break; 4926 default: 4927 NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb dump request"); 4928 return -EINVAL; 4929 } 4930 } 4931 4932 return 0; 4933 } 4934 4935 static int valid_fdb_dump_legacy(const struct nlmsghdr *nlh, 4936 int *br_idx, int *brport_idx, 4937 struct netlink_ext_ack *extack) 4938 { 4939 struct nlattr *tb[IFLA_MAX+1]; 4940 int err; 4941 4942 /* A hack to preserve kernel<->userspace interface. 4943 * Before Linux v4.12 this code accepted ndmsg since iproute2 v3.3.0. 4944 * However, ndmsg is shorter than ifinfomsg thus nlmsg_parse() bails. 4945 * So, check for ndmsg with an optional u32 attribute (not used here). 4946 * Fortunately these sizes don't conflict with the size of ifinfomsg 4947 * with an optional attribute. 4948 */ 4949 if (nlmsg_len(nlh) != sizeof(struct ndmsg) && 4950 (nlmsg_len(nlh) != sizeof(struct ndmsg) + 4951 nla_attr_size(sizeof(u32)))) { 4952 struct ifinfomsg *ifm; 4953 4954 err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg), 4955 tb, IFLA_MAX, ifla_policy, 4956 extack); 4957 if (err < 0) { 4958 return -EINVAL; 4959 } else if (err == 0) { 4960 if (tb[IFLA_MASTER]) 4961 *br_idx = nla_get_u32(tb[IFLA_MASTER]); 4962 } 4963 4964 ifm = nlmsg_data(nlh); 4965 *brport_idx = ifm->ifi_index; 4966 } 4967 return 0; 4968 } 4969 4970 static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb) 4971 { 4972 const struct net_device_ops *ops = NULL, *cops = NULL; 4973 struct ndo_fdb_dump_context *ctx = (void *)cb->ctx; 4974 struct net_device *dev, *br_dev = NULL; 4975 struct net *net = sock_net(skb->sk); 4976 int brport_idx = 0; 4977 int br_idx = 0; 4978 int fidx = 0; 4979 int err; 4980 4981 NL_ASSERT_CTX_FITS(struct ndo_fdb_dump_context); 4982 4983 if (cb->strict_check) 4984 err = valid_fdb_dump_strict(cb->nlh, &br_idx, &brport_idx, 4985 cb->extack); 4986 else 4987 err = valid_fdb_dump_legacy(cb->nlh, &br_idx, &brport_idx, 4988 cb->extack); 4989 if (err < 0) 4990 return err; 4991 4992 if (br_idx) { 4993 br_dev = __dev_get_by_index(net, br_idx); 4994 if (!br_dev) 4995 return -ENODEV; 4996 4997 ops = br_dev->netdev_ops; 4998 } 4999 5000 for_each_netdev_dump(net, dev, ctx->ifindex) { 5001 if (brport_idx && (dev->ifindex != brport_idx)) 5002 continue; 5003 5004 if (!br_idx) { /* user did not specify a specific bridge */ 5005 if (netif_is_bridge_port(dev)) { 5006 br_dev = netdev_master_upper_dev_get(dev); 5007 cops = br_dev->netdev_ops; 5008 } 5009 } else { 5010 if (dev != br_dev && 5011 !netif_is_bridge_port(dev)) 5012 continue; 5013 5014 if (br_dev != netdev_master_upper_dev_get(dev) && 5015 !netif_is_bridge_master(dev)) 5016 continue; 5017 cops = ops; 5018 } 5019 5020 if (netif_is_bridge_port(dev)) { 5021 if (cops && cops->ndo_fdb_dump) { 5022 err = cops->ndo_fdb_dump(skb, cb, br_dev, dev, 5023 &fidx); 5024 if (err == -EMSGSIZE) 5025 break; 5026 } 5027 } 5028 5029 if (dev->netdev_ops->ndo_fdb_dump) 5030 err = dev->netdev_ops->ndo_fdb_dump(skb, cb, dev, NULL, 5031 &fidx); 5032 else 5033 err = ndo_dflt_fdb_dump(skb, cb, dev, NULL, &fidx); 5034 if (err == -EMSGSIZE) 5035 break; 5036 5037 cops = NULL; 5038 5039 /* reset fdb offset to 0 for rest of the interfaces */ 5040 ctx->fdb_idx = 0; 5041 fidx = 0; 5042 } 5043 5044 ctx->fdb_idx = fidx; 5045 5046 return skb->len; 5047 } 5048 5049 static int valid_fdb_get_strict(const struct nlmsghdr *nlh, 5050 struct nlattr **tb, u8 *ndm_flags, 5051 int *br_idx, int *brport_idx, u8 **addr, 5052 u16 *vid, struct netlink_ext_ack *extack) 5053 { 5054 struct ndmsg *ndm; 5055 int err, i; 5056 5057 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) { 5058 NL_SET_ERR_MSG(extack, "Invalid header for fdb get request"); 5059 return -EINVAL; 5060 } 5061 5062 ndm = nlmsg_data(nlh); 5063 if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state || 5064 ndm->ndm_type) { 5065 NL_SET_ERR_MSG(extack, "Invalid values in header for fdb get request"); 5066 return -EINVAL; 5067 } 5068 5069 if (ndm->ndm_flags & ~(NTF_MASTER | NTF_SELF)) { 5070 NL_SET_ERR_MSG(extack, "Invalid flags in header for fdb get request"); 5071 return -EINVAL; 5072 } 5073 5074 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb, 5075 NDA_MAX, nda_policy, extack); 5076 if (err < 0) 5077 return err; 5078 5079 *ndm_flags = ndm->ndm_flags; 5080 *brport_idx = ndm->ndm_ifindex; 5081 for (i = 0; i <= NDA_MAX; ++i) { 5082 if (!tb[i]) 5083 continue; 5084 5085 switch (i) { 5086 case NDA_MASTER: 5087 *br_idx = nla_get_u32(tb[i]); 5088 break; 5089 case NDA_LLADDR: 5090 if (nla_len(tb[i]) != ETH_ALEN) { 5091 NL_SET_ERR_MSG(extack, "Invalid address in fdb get request"); 5092 return -EINVAL; 5093 } 5094 *addr = nla_data(tb[i]); 5095 break; 5096 case NDA_VLAN: 5097 err = fdb_vid_parse(tb[i], vid, extack); 5098 if (err) 5099 return err; 5100 break; 5101 case NDA_VNI: 5102 break; 5103 default: 5104 NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb get request"); 5105 return -EINVAL; 5106 } 5107 } 5108 5109 return 0; 5110 } 5111 5112 static int rtnl_fdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh, 5113 struct netlink_ext_ack *extack) 5114 { 5115 struct net_device *dev = NULL, *br_dev = NULL; 5116 const struct net_device_ops *ops = NULL; 5117 struct net *net = sock_net(in_skb->sk); 5118 struct nlattr *tb[NDA_MAX + 1]; 5119 struct sk_buff *skb; 5120 int brport_idx = 0; 5121 u8 ndm_flags = 0; 5122 int br_idx = 0; 5123 u8 *addr = NULL; 5124 u16 vid = 0; 5125 int err; 5126 5127 err = valid_fdb_get_strict(nlh, tb, &ndm_flags, &br_idx, 5128 &brport_idx, &addr, &vid, extack); 5129 if (err < 0) 5130 return err; 5131 5132 if (!addr) { 5133 NL_SET_ERR_MSG(extack, "Missing lookup address for fdb get request"); 5134 return -EINVAL; 5135 } 5136 5137 if (brport_idx) { 5138 dev = __dev_get_by_index(net, brport_idx); 5139 if (!dev) { 5140 NL_SET_ERR_MSG(extack, "Unknown device ifindex"); 5141 return -ENODEV; 5142 } 5143 } 5144 5145 if (br_idx) { 5146 if (dev) { 5147 NL_SET_ERR_MSG(extack, "Master and device are mutually exclusive"); 5148 return -EINVAL; 5149 } 5150 5151 br_dev = __dev_get_by_index(net, br_idx); 5152 if (!br_dev) { 5153 NL_SET_ERR_MSG(extack, "Invalid master ifindex"); 5154 return -EINVAL; 5155 } 5156 ops = br_dev->netdev_ops; 5157 } 5158 5159 if (dev) { 5160 if (!ndm_flags || (ndm_flags & NTF_MASTER)) { 5161 if (!netif_is_bridge_port(dev)) { 5162 NL_SET_ERR_MSG(extack, "Device is not a bridge port"); 5163 return -EINVAL; 5164 } 5165 br_dev = netdev_master_upper_dev_get(dev); 5166 if (!br_dev) { 5167 NL_SET_ERR_MSG(extack, "Master of device not found"); 5168 return -EINVAL; 5169 } 5170 ops = br_dev->netdev_ops; 5171 } else { 5172 if (!(ndm_flags & NTF_SELF)) { 5173 NL_SET_ERR_MSG(extack, "Missing NTF_SELF"); 5174 return -EINVAL; 5175 } 5176 ops = dev->netdev_ops; 5177 } 5178 } 5179 5180 if (!br_dev && !dev) { 5181 NL_SET_ERR_MSG(extack, "No device specified"); 5182 return -ENODEV; 5183 } 5184 5185 if (!ops || !ops->ndo_fdb_get) { 5186 NL_SET_ERR_MSG(extack, "Fdb get operation not supported by device"); 5187 return -EOPNOTSUPP; 5188 } 5189 5190 skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL); 5191 if (!skb) 5192 return -ENOBUFS; 5193 5194 if (br_dev) 5195 dev = br_dev; 5196 err = ops->ndo_fdb_get(skb, tb, dev, addr, vid, 5197 NETLINK_CB(in_skb).portid, 5198 nlh->nlmsg_seq, extack); 5199 if (err) 5200 goto out; 5201 5202 return rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid); 5203 out: 5204 kfree_skb(skb); 5205 return err; 5206 } 5207 5208 static int brport_nla_put_flag(struct sk_buff *skb, u32 flags, u32 mask, 5209 unsigned int attrnum, unsigned int flag) 5210 { 5211 if (mask & flag) 5212 return nla_put_u8(skb, attrnum, !!(flags & flag)); 5213 return 0; 5214 } 5215 5216 int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, 5217 struct net_device *dev, u16 mode, 5218 u32 flags, u32 mask, int nlflags, 5219 u32 filter_mask, 5220 int (*vlan_fill)(struct sk_buff *skb, 5221 struct net_device *dev, 5222 u32 filter_mask)) 5223 { 5224 struct nlmsghdr *nlh; 5225 struct ifinfomsg *ifm; 5226 struct nlattr *br_afspec; 5227 struct nlattr *protinfo; 5228 u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN; 5229 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 5230 int err = 0; 5231 5232 nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), nlflags); 5233 if (nlh == NULL) 5234 return -EMSGSIZE; 5235 5236 ifm = nlmsg_data(nlh); 5237 ifm->ifi_family = AF_BRIDGE; 5238 ifm->__ifi_pad = 0; 5239 ifm->ifi_type = dev->type; 5240 ifm->ifi_index = dev->ifindex; 5241 ifm->ifi_flags = dev_get_flags(dev); 5242 ifm->ifi_change = 0; 5243 5244 5245 if (nla_put_string(skb, IFLA_IFNAME, dev->name) || 5246 nla_put_u32(skb, IFLA_MTU, dev->mtu) || 5247 nla_put_u8(skb, IFLA_OPERSTATE, operstate) || 5248 (br_dev && 5249 nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) || 5250 (dev->addr_len && 5251 nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) || 5252 (dev->ifindex != dev_get_iflink(dev) && 5253 nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev)))) 5254 goto nla_put_failure; 5255 5256 br_afspec = nla_nest_start_noflag(skb, IFLA_AF_SPEC); 5257 if (!br_afspec) 5258 goto nla_put_failure; 5259 5260 if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF)) { 5261 nla_nest_cancel(skb, br_afspec); 5262 goto nla_put_failure; 5263 } 5264 5265 if (mode != BRIDGE_MODE_UNDEF) { 5266 if (nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) { 5267 nla_nest_cancel(skb, br_afspec); 5268 goto nla_put_failure; 5269 } 5270 } 5271 if (vlan_fill) { 5272 err = vlan_fill(skb, dev, filter_mask); 5273 if (err) { 5274 nla_nest_cancel(skb, br_afspec); 5275 goto nla_put_failure; 5276 } 5277 } 5278 nla_nest_end(skb, br_afspec); 5279 5280 protinfo = nla_nest_start(skb, IFLA_PROTINFO); 5281 if (!protinfo) 5282 goto nla_put_failure; 5283 5284 if (brport_nla_put_flag(skb, flags, mask, 5285 IFLA_BRPORT_MODE, BR_HAIRPIN_MODE) || 5286 brport_nla_put_flag(skb, flags, mask, 5287 IFLA_BRPORT_GUARD, BR_BPDU_GUARD) || 5288 brport_nla_put_flag(skb, flags, mask, 5289 IFLA_BRPORT_FAST_LEAVE, 5290 BR_MULTICAST_FAST_LEAVE) || 5291 brport_nla_put_flag(skb, flags, mask, 5292 IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK) || 5293 brport_nla_put_flag(skb, flags, mask, 5294 IFLA_BRPORT_LEARNING, BR_LEARNING) || 5295 brport_nla_put_flag(skb, flags, mask, 5296 IFLA_BRPORT_LEARNING_SYNC, BR_LEARNING_SYNC) || 5297 brport_nla_put_flag(skb, flags, mask, 5298 IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD) || 5299 brport_nla_put_flag(skb, flags, mask, 5300 IFLA_BRPORT_PROXYARP, BR_PROXYARP) || 5301 brport_nla_put_flag(skb, flags, mask, 5302 IFLA_BRPORT_MCAST_FLOOD, BR_MCAST_FLOOD) || 5303 brport_nla_put_flag(skb, flags, mask, 5304 IFLA_BRPORT_BCAST_FLOOD, BR_BCAST_FLOOD)) { 5305 nla_nest_cancel(skb, protinfo); 5306 goto nla_put_failure; 5307 } 5308 5309 nla_nest_end(skb, protinfo); 5310 5311 nlmsg_end(skb, nlh); 5312 return 0; 5313 nla_put_failure: 5314 nlmsg_cancel(skb, nlh); 5315 return err ? err : -EMSGSIZE; 5316 } 5317 EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink); 5318 5319 static int valid_bridge_getlink_req(const struct nlmsghdr *nlh, 5320 bool strict_check, u32 *filter_mask, 5321 struct netlink_ext_ack *extack) 5322 { 5323 struct nlattr *tb[IFLA_MAX+1]; 5324 int err, i; 5325 5326 if (strict_check) { 5327 struct ifinfomsg *ifm; 5328 5329 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) { 5330 NL_SET_ERR_MSG(extack, "Invalid header for bridge link dump"); 5331 return -EINVAL; 5332 } 5333 5334 ifm = nlmsg_data(nlh); 5335 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags || 5336 ifm->ifi_change || ifm->ifi_index) { 5337 NL_SET_ERR_MSG(extack, "Invalid values in header for bridge link dump request"); 5338 return -EINVAL; 5339 } 5340 5341 err = nlmsg_parse_deprecated_strict(nlh, 5342 sizeof(struct ifinfomsg), 5343 tb, IFLA_MAX, ifla_policy, 5344 extack); 5345 } else { 5346 err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg), 5347 tb, IFLA_MAX, ifla_policy, 5348 extack); 5349 } 5350 if (err < 0) 5351 return err; 5352 5353 /* new attributes should only be added with strict checking */ 5354 for (i = 0; i <= IFLA_MAX; ++i) { 5355 if (!tb[i]) 5356 continue; 5357 5358 switch (i) { 5359 case IFLA_EXT_MASK: 5360 *filter_mask = nla_get_u32(tb[i]); 5361 break; 5362 default: 5363 if (strict_check) { 5364 NL_SET_ERR_MSG(extack, "Unsupported attribute in bridge link dump request"); 5365 return -EINVAL; 5366 } 5367 } 5368 } 5369 5370 return 0; 5371 } 5372 5373 static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb) 5374 { 5375 const struct nlmsghdr *nlh = cb->nlh; 5376 struct net *net = sock_net(skb->sk); 5377 struct net_device *dev; 5378 int idx = 0; 5379 u32 portid = NETLINK_CB(cb->skb).portid; 5380 u32 seq = nlh->nlmsg_seq; 5381 u32 filter_mask = 0; 5382 int err; 5383 5384 err = valid_bridge_getlink_req(nlh, cb->strict_check, &filter_mask, 5385 cb->extack); 5386 if (err < 0 && cb->strict_check) 5387 return err; 5388 5389 rcu_read_lock(); 5390 for_each_netdev_rcu(net, dev) { 5391 const struct net_device_ops *ops = dev->netdev_ops; 5392 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 5393 5394 if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) { 5395 if (idx >= cb->args[0]) { 5396 err = br_dev->netdev_ops->ndo_bridge_getlink( 5397 skb, portid, seq, dev, 5398 filter_mask, NLM_F_MULTI); 5399 if (err < 0 && err != -EOPNOTSUPP) { 5400 if (likely(skb->len)) 5401 break; 5402 5403 goto out_err; 5404 } 5405 } 5406 idx++; 5407 } 5408 5409 if (ops->ndo_bridge_getlink) { 5410 if (idx >= cb->args[0]) { 5411 err = ops->ndo_bridge_getlink(skb, portid, 5412 seq, dev, 5413 filter_mask, 5414 NLM_F_MULTI); 5415 if (err < 0 && err != -EOPNOTSUPP) { 5416 if (likely(skb->len)) 5417 break; 5418 5419 goto out_err; 5420 } 5421 } 5422 idx++; 5423 } 5424 } 5425 err = skb->len; 5426 out_err: 5427 rcu_read_unlock(); 5428 cb->args[0] = idx; 5429 5430 return err; 5431 } 5432 5433 static inline size_t bridge_nlmsg_size(void) 5434 { 5435 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 5436 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 5437 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 5438 + nla_total_size(sizeof(u32)) /* IFLA_MASTER */ 5439 + nla_total_size(sizeof(u32)) /* IFLA_MTU */ 5440 + nla_total_size(sizeof(u32)) /* IFLA_LINK */ 5441 + nla_total_size(sizeof(u32)) /* IFLA_OPERSTATE */ 5442 + nla_total_size(sizeof(u8)) /* IFLA_PROTINFO */ 5443 + nla_total_size(sizeof(struct nlattr)) /* IFLA_AF_SPEC */ 5444 + nla_total_size(sizeof(u16)) /* IFLA_BRIDGE_FLAGS */ 5445 + nla_total_size(sizeof(u16)); /* IFLA_BRIDGE_MODE */ 5446 } 5447 5448 static int rtnl_bridge_notify(struct net_device *dev) 5449 { 5450 struct net *net = dev_net(dev); 5451 struct sk_buff *skb; 5452 int err = -EOPNOTSUPP; 5453 5454 if (!dev->netdev_ops->ndo_bridge_getlink) 5455 return 0; 5456 5457 skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC); 5458 if (!skb) { 5459 err = -ENOMEM; 5460 goto errout; 5461 } 5462 5463 err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0, 0); 5464 if (err < 0) 5465 goto errout; 5466 5467 /* Notification info is only filled for bridge ports, not the bridge 5468 * device itself. Therefore, a zero notification length is valid and 5469 * should not result in an error. 5470 */ 5471 if (!skb->len) 5472 goto errout; 5473 5474 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC); 5475 return 0; 5476 errout: 5477 WARN_ON(err == -EMSGSIZE); 5478 kfree_skb(skb); 5479 if (err) 5480 rtnl_set_sk_err(net, RTNLGRP_LINK, err); 5481 return err; 5482 } 5483 5484 static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, 5485 struct netlink_ext_ack *extack) 5486 { 5487 struct net *net = sock_net(skb->sk); 5488 struct ifinfomsg *ifm; 5489 struct net_device *dev; 5490 struct nlattr *br_spec, *attr, *br_flags_attr = NULL; 5491 int rem, err = -EOPNOTSUPP; 5492 u16 flags = 0; 5493 5494 if (nlmsg_len(nlh) < sizeof(*ifm)) 5495 return -EINVAL; 5496 5497 ifm = nlmsg_data(nlh); 5498 if (ifm->ifi_family != AF_BRIDGE) 5499 return -EPFNOSUPPORT; 5500 5501 dev = __dev_get_by_index(net, ifm->ifi_index); 5502 if (!dev) { 5503 NL_SET_ERR_MSG(extack, "unknown ifindex"); 5504 return -ENODEV; 5505 } 5506 5507 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 5508 if (br_spec) { 5509 nla_for_each_nested(attr, br_spec, rem) { 5510 if (nla_type(attr) == IFLA_BRIDGE_FLAGS && !br_flags_attr) { 5511 if (nla_len(attr) < sizeof(flags)) 5512 return -EINVAL; 5513 5514 br_flags_attr = attr; 5515 flags = nla_get_u16(attr); 5516 } 5517 5518 if (nla_type(attr) == IFLA_BRIDGE_MODE) { 5519 if (nla_len(attr) < sizeof(u16)) 5520 return -EINVAL; 5521 } 5522 } 5523 } 5524 5525 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) { 5526 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 5527 5528 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) { 5529 err = -EOPNOTSUPP; 5530 goto out; 5531 } 5532 5533 err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh, flags, 5534 extack); 5535 if (err) 5536 goto out; 5537 5538 flags &= ~BRIDGE_FLAGS_MASTER; 5539 } 5540 5541 if ((flags & BRIDGE_FLAGS_SELF)) { 5542 if (!dev->netdev_ops->ndo_bridge_setlink) 5543 err = -EOPNOTSUPP; 5544 else 5545 err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh, 5546 flags, 5547 extack); 5548 if (!err) { 5549 flags &= ~BRIDGE_FLAGS_SELF; 5550 5551 /* Generate event to notify upper layer of bridge 5552 * change 5553 */ 5554 err = rtnl_bridge_notify(dev); 5555 } 5556 } 5557 5558 if (br_flags_attr) 5559 memcpy(nla_data(br_flags_attr), &flags, sizeof(flags)); 5560 out: 5561 return err; 5562 } 5563 5564 static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, 5565 struct netlink_ext_ack *extack) 5566 { 5567 struct net *net = sock_net(skb->sk); 5568 struct ifinfomsg *ifm; 5569 struct net_device *dev; 5570 struct nlattr *br_spec, *attr = NULL; 5571 int rem, err = -EOPNOTSUPP; 5572 u16 flags = 0; 5573 bool have_flags = false; 5574 5575 if (nlmsg_len(nlh) < sizeof(*ifm)) 5576 return -EINVAL; 5577 5578 ifm = nlmsg_data(nlh); 5579 if (ifm->ifi_family != AF_BRIDGE) 5580 return -EPFNOSUPPORT; 5581 5582 dev = __dev_get_by_index(net, ifm->ifi_index); 5583 if (!dev) { 5584 NL_SET_ERR_MSG(extack, "unknown ifindex"); 5585 return -ENODEV; 5586 } 5587 5588 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 5589 if (br_spec) { 5590 nla_for_each_nested_type(attr, IFLA_BRIDGE_FLAGS, br_spec, 5591 rem) { 5592 if (nla_len(attr) < sizeof(flags)) 5593 return -EINVAL; 5594 5595 have_flags = true; 5596 flags = nla_get_u16(attr); 5597 break; 5598 } 5599 } 5600 5601 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) { 5602 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 5603 5604 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_dellink) { 5605 err = -EOPNOTSUPP; 5606 goto out; 5607 } 5608 5609 err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh, flags); 5610 if (err) 5611 goto out; 5612 5613 flags &= ~BRIDGE_FLAGS_MASTER; 5614 } 5615 5616 if ((flags & BRIDGE_FLAGS_SELF)) { 5617 if (!dev->netdev_ops->ndo_bridge_dellink) 5618 err = -EOPNOTSUPP; 5619 else 5620 err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh, 5621 flags); 5622 5623 if (!err) { 5624 flags &= ~BRIDGE_FLAGS_SELF; 5625 5626 /* Generate event to notify upper layer of bridge 5627 * change 5628 */ 5629 err = rtnl_bridge_notify(dev); 5630 } 5631 } 5632 5633 if (have_flags) 5634 memcpy(nla_data(attr), &flags, sizeof(flags)); 5635 out: 5636 return err; 5637 } 5638 5639 static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr) 5640 { 5641 return (mask & IFLA_STATS_FILTER_BIT(attrid)) && 5642 (!idxattr || idxattr == attrid); 5643 } 5644 5645 static bool 5646 rtnl_offload_xstats_have_ndo(const struct net_device *dev, int attr_id) 5647 { 5648 return dev->netdev_ops && 5649 dev->netdev_ops->ndo_has_offload_stats && 5650 dev->netdev_ops->ndo_get_offload_stats && 5651 dev->netdev_ops->ndo_has_offload_stats(dev, attr_id); 5652 } 5653 5654 static unsigned int 5655 rtnl_offload_xstats_get_size_ndo(const struct net_device *dev, int attr_id) 5656 { 5657 return rtnl_offload_xstats_have_ndo(dev, attr_id) ? 5658 sizeof(struct rtnl_link_stats64) : 0; 5659 } 5660 5661 static int 5662 rtnl_offload_xstats_fill_ndo(struct net_device *dev, int attr_id, 5663 struct sk_buff *skb) 5664 { 5665 unsigned int size = rtnl_offload_xstats_get_size_ndo(dev, attr_id); 5666 struct nlattr *attr = NULL; 5667 void *attr_data; 5668 int err; 5669 5670 if (!size) 5671 return -ENODATA; 5672 5673 attr = nla_reserve_64bit(skb, attr_id, size, 5674 IFLA_OFFLOAD_XSTATS_UNSPEC); 5675 if (!attr) 5676 return -EMSGSIZE; 5677 5678 attr_data = nla_data(attr); 5679 memset(attr_data, 0, size); 5680 5681 err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev, attr_data); 5682 if (err) 5683 return err; 5684 5685 return 0; 5686 } 5687 5688 static unsigned int 5689 rtnl_offload_xstats_get_size_stats(const struct net_device *dev, 5690 enum netdev_offload_xstats_type type) 5691 { 5692 bool enabled = netdev_offload_xstats_enabled(dev, type); 5693 5694 return enabled ? sizeof(struct rtnl_hw_stats64) : 0; 5695 } 5696 5697 struct rtnl_offload_xstats_request_used { 5698 bool request; 5699 bool used; 5700 }; 5701 5702 static int 5703 rtnl_offload_xstats_get_stats(struct net_device *dev, 5704 enum netdev_offload_xstats_type type, 5705 struct rtnl_offload_xstats_request_used *ru, 5706 struct rtnl_hw_stats64 *stats, 5707 struct netlink_ext_ack *extack) 5708 { 5709 bool request; 5710 bool used; 5711 int err; 5712 5713 request = netdev_offload_xstats_enabled(dev, type); 5714 if (!request) { 5715 used = false; 5716 goto out; 5717 } 5718 5719 err = netdev_offload_xstats_get(dev, type, stats, &used, extack); 5720 if (err) 5721 return err; 5722 5723 out: 5724 if (ru) { 5725 ru->request = request; 5726 ru->used = used; 5727 } 5728 return 0; 5729 } 5730 5731 static int 5732 rtnl_offload_xstats_fill_hw_s_info_one(struct sk_buff *skb, int attr_id, 5733 struct rtnl_offload_xstats_request_used *ru) 5734 { 5735 struct nlattr *nest; 5736 5737 nest = nla_nest_start(skb, attr_id); 5738 if (!nest) 5739 return -EMSGSIZE; 5740 5741 if (nla_put_u8(skb, IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST, ru->request)) 5742 goto nla_put_failure; 5743 5744 if (nla_put_u8(skb, IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED, ru->used)) 5745 goto nla_put_failure; 5746 5747 nla_nest_end(skb, nest); 5748 return 0; 5749 5750 nla_put_failure: 5751 nla_nest_cancel(skb, nest); 5752 return -EMSGSIZE; 5753 } 5754 5755 static int 5756 rtnl_offload_xstats_fill_hw_s_info(struct sk_buff *skb, struct net_device *dev, 5757 struct netlink_ext_ack *extack) 5758 { 5759 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3; 5760 struct rtnl_offload_xstats_request_used ru_l3; 5761 struct nlattr *nest; 5762 int err; 5763 5764 err = rtnl_offload_xstats_get_stats(dev, t_l3, &ru_l3, NULL, extack); 5765 if (err) 5766 return err; 5767 5768 nest = nla_nest_start(skb, IFLA_OFFLOAD_XSTATS_HW_S_INFO); 5769 if (!nest) 5770 return -EMSGSIZE; 5771 5772 if (rtnl_offload_xstats_fill_hw_s_info_one(skb, 5773 IFLA_OFFLOAD_XSTATS_L3_STATS, 5774 &ru_l3)) 5775 goto nla_put_failure; 5776 5777 nla_nest_end(skb, nest); 5778 return 0; 5779 5780 nla_put_failure: 5781 nla_nest_cancel(skb, nest); 5782 return -EMSGSIZE; 5783 } 5784 5785 static int rtnl_offload_xstats_fill(struct sk_buff *skb, struct net_device *dev, 5786 int *prividx, u32 off_filter_mask, 5787 struct netlink_ext_ack *extack) 5788 { 5789 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3; 5790 int attr_id_hw_s_info = IFLA_OFFLOAD_XSTATS_HW_S_INFO; 5791 int attr_id_l3_stats = IFLA_OFFLOAD_XSTATS_L3_STATS; 5792 int attr_id_cpu_hit = IFLA_OFFLOAD_XSTATS_CPU_HIT; 5793 bool have_data = false; 5794 int err; 5795 5796 if (*prividx <= attr_id_cpu_hit && 5797 (off_filter_mask & 5798 IFLA_STATS_FILTER_BIT(attr_id_cpu_hit))) { 5799 err = rtnl_offload_xstats_fill_ndo(dev, attr_id_cpu_hit, skb); 5800 if (!err) { 5801 have_data = true; 5802 } else if (err != -ENODATA) { 5803 *prividx = attr_id_cpu_hit; 5804 return err; 5805 } 5806 } 5807 5808 if (*prividx <= attr_id_hw_s_info && 5809 (off_filter_mask & IFLA_STATS_FILTER_BIT(attr_id_hw_s_info))) { 5810 *prividx = attr_id_hw_s_info; 5811 5812 err = rtnl_offload_xstats_fill_hw_s_info(skb, dev, extack); 5813 if (err) 5814 return err; 5815 5816 have_data = true; 5817 *prividx = 0; 5818 } 5819 5820 if (*prividx <= attr_id_l3_stats && 5821 (off_filter_mask & IFLA_STATS_FILTER_BIT(attr_id_l3_stats))) { 5822 unsigned int size_l3; 5823 struct nlattr *attr; 5824 5825 *prividx = attr_id_l3_stats; 5826 5827 size_l3 = rtnl_offload_xstats_get_size_stats(dev, t_l3); 5828 if (!size_l3) 5829 goto skip_l3_stats; 5830 attr = nla_reserve_64bit(skb, attr_id_l3_stats, size_l3, 5831 IFLA_OFFLOAD_XSTATS_UNSPEC); 5832 if (!attr) 5833 return -EMSGSIZE; 5834 5835 err = rtnl_offload_xstats_get_stats(dev, t_l3, NULL, 5836 nla_data(attr), extack); 5837 if (err) 5838 return err; 5839 5840 have_data = true; 5841 skip_l3_stats: 5842 *prividx = 0; 5843 } 5844 5845 if (!have_data) 5846 return -ENODATA; 5847 5848 *prividx = 0; 5849 return 0; 5850 } 5851 5852 static unsigned int 5853 rtnl_offload_xstats_get_size_hw_s_info_one(const struct net_device *dev, 5854 enum netdev_offload_xstats_type type) 5855 { 5856 return nla_total_size(0) + 5857 /* IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST */ 5858 nla_total_size(sizeof(u8)) + 5859 /* IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED */ 5860 nla_total_size(sizeof(u8)) + 5861 0; 5862 } 5863 5864 static unsigned int 5865 rtnl_offload_xstats_get_size_hw_s_info(const struct net_device *dev) 5866 { 5867 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3; 5868 5869 return nla_total_size(0) + 5870 /* IFLA_OFFLOAD_XSTATS_L3_STATS */ 5871 rtnl_offload_xstats_get_size_hw_s_info_one(dev, t_l3) + 5872 0; 5873 } 5874 5875 static int rtnl_offload_xstats_get_size(const struct net_device *dev, 5876 u32 off_filter_mask) 5877 { 5878 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3; 5879 int attr_id_cpu_hit = IFLA_OFFLOAD_XSTATS_CPU_HIT; 5880 int nla_size = 0; 5881 int size; 5882 5883 if (off_filter_mask & 5884 IFLA_STATS_FILTER_BIT(attr_id_cpu_hit)) { 5885 size = rtnl_offload_xstats_get_size_ndo(dev, attr_id_cpu_hit); 5886 nla_size += nla_total_size_64bit(size); 5887 } 5888 5889 if (off_filter_mask & 5890 IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_HW_S_INFO)) 5891 nla_size += rtnl_offload_xstats_get_size_hw_s_info(dev); 5892 5893 if (off_filter_mask & 5894 IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_L3_STATS)) { 5895 size = rtnl_offload_xstats_get_size_stats(dev, t_l3); 5896 nla_size += nla_total_size_64bit(size); 5897 } 5898 5899 if (nla_size != 0) 5900 nla_size += nla_total_size(0); 5901 5902 return nla_size; 5903 } 5904 5905 struct rtnl_stats_dump_filters { 5906 /* mask[0] filters outer attributes. Then individual nests have their 5907 * filtering mask at the index of the nested attribute. 5908 */ 5909 u32 mask[IFLA_STATS_MAX + 1]; 5910 }; 5911 5912 static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev, 5913 int type, u32 pid, u32 seq, u32 change, 5914 unsigned int flags, 5915 const struct rtnl_stats_dump_filters *filters, 5916 int *idxattr, int *prividx, 5917 struct netlink_ext_ack *extack) 5918 { 5919 unsigned int filter_mask = filters->mask[0]; 5920 struct if_stats_msg *ifsm; 5921 struct nlmsghdr *nlh; 5922 struct nlattr *attr; 5923 int s_prividx = *prividx; 5924 int err; 5925 5926 ASSERT_RTNL(); 5927 5928 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifsm), flags); 5929 if (!nlh) 5930 return -EMSGSIZE; 5931 5932 ifsm = nlmsg_data(nlh); 5933 ifsm->family = PF_UNSPEC; 5934 ifsm->pad1 = 0; 5935 ifsm->pad2 = 0; 5936 ifsm->ifindex = dev->ifindex; 5937 ifsm->filter_mask = filter_mask; 5938 5939 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, *idxattr)) { 5940 struct rtnl_link_stats64 *sp; 5941 5942 attr = nla_reserve_64bit(skb, IFLA_STATS_LINK_64, 5943 sizeof(struct rtnl_link_stats64), 5944 IFLA_STATS_UNSPEC); 5945 if (!attr) { 5946 err = -EMSGSIZE; 5947 goto nla_put_failure; 5948 } 5949 5950 sp = nla_data(attr); 5951 dev_get_stats(dev, sp); 5952 } 5953 5954 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, *idxattr)) { 5955 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 5956 5957 if (ops && ops->fill_linkxstats) { 5958 *idxattr = IFLA_STATS_LINK_XSTATS; 5959 attr = nla_nest_start_noflag(skb, 5960 IFLA_STATS_LINK_XSTATS); 5961 if (!attr) { 5962 err = -EMSGSIZE; 5963 goto nla_put_failure; 5964 } 5965 5966 err = ops->fill_linkxstats(skb, dev, prividx, *idxattr); 5967 nla_nest_end(skb, attr); 5968 if (err) 5969 goto nla_put_failure; 5970 *idxattr = 0; 5971 } 5972 } 5973 5974 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 5975 *idxattr)) { 5976 const struct rtnl_link_ops *ops = NULL; 5977 const struct net_device *master; 5978 5979 master = netdev_master_upper_dev_get(dev); 5980 if (master) 5981 ops = master->rtnl_link_ops; 5982 if (ops && ops->fill_linkxstats) { 5983 *idxattr = IFLA_STATS_LINK_XSTATS_SLAVE; 5984 attr = nla_nest_start_noflag(skb, 5985 IFLA_STATS_LINK_XSTATS_SLAVE); 5986 if (!attr) { 5987 err = -EMSGSIZE; 5988 goto nla_put_failure; 5989 } 5990 5991 err = ops->fill_linkxstats(skb, dev, prividx, *idxattr); 5992 nla_nest_end(skb, attr); 5993 if (err) 5994 goto nla_put_failure; 5995 *idxattr = 0; 5996 } 5997 } 5998 5999 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 6000 *idxattr)) { 6001 u32 off_filter_mask; 6002 6003 off_filter_mask = filters->mask[IFLA_STATS_LINK_OFFLOAD_XSTATS]; 6004 *idxattr = IFLA_STATS_LINK_OFFLOAD_XSTATS; 6005 attr = nla_nest_start_noflag(skb, 6006 IFLA_STATS_LINK_OFFLOAD_XSTATS); 6007 if (!attr) { 6008 err = -EMSGSIZE; 6009 goto nla_put_failure; 6010 } 6011 6012 err = rtnl_offload_xstats_fill(skb, dev, prividx, 6013 off_filter_mask, extack); 6014 if (err == -ENODATA) 6015 nla_nest_cancel(skb, attr); 6016 else 6017 nla_nest_end(skb, attr); 6018 6019 if (err && err != -ENODATA) 6020 goto nla_put_failure; 6021 *idxattr = 0; 6022 } 6023 6024 if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, *idxattr)) { 6025 struct rtnl_af_ops *af_ops; 6026 6027 *idxattr = IFLA_STATS_AF_SPEC; 6028 attr = nla_nest_start_noflag(skb, IFLA_STATS_AF_SPEC); 6029 if (!attr) { 6030 err = -EMSGSIZE; 6031 goto nla_put_failure; 6032 } 6033 6034 rcu_read_lock(); 6035 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { 6036 if (af_ops->fill_stats_af) { 6037 struct nlattr *af; 6038 6039 af = nla_nest_start_noflag(skb, 6040 af_ops->family); 6041 if (!af) { 6042 rcu_read_unlock(); 6043 err = -EMSGSIZE; 6044 goto nla_put_failure; 6045 } 6046 err = af_ops->fill_stats_af(skb, dev); 6047 6048 if (err == -ENODATA) { 6049 nla_nest_cancel(skb, af); 6050 } else if (err < 0) { 6051 rcu_read_unlock(); 6052 goto nla_put_failure; 6053 } 6054 6055 nla_nest_end(skb, af); 6056 } 6057 } 6058 rcu_read_unlock(); 6059 6060 nla_nest_end(skb, attr); 6061 6062 *idxattr = 0; 6063 } 6064 6065 nlmsg_end(skb, nlh); 6066 6067 return 0; 6068 6069 nla_put_failure: 6070 /* not a multi message or no progress mean a real error */ 6071 if (!(flags & NLM_F_MULTI) || s_prividx == *prividx) 6072 nlmsg_cancel(skb, nlh); 6073 else 6074 nlmsg_end(skb, nlh); 6075 6076 return err; 6077 } 6078 6079 static size_t if_nlmsg_stats_size(const struct net_device *dev, 6080 const struct rtnl_stats_dump_filters *filters) 6081 { 6082 size_t size = NLMSG_ALIGN(sizeof(struct if_stats_msg)); 6083 unsigned int filter_mask = filters->mask[0]; 6084 6085 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, 0)) 6086 size += nla_total_size_64bit(sizeof(struct rtnl_link_stats64)); 6087 6088 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, 0)) { 6089 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 6090 int attr = IFLA_STATS_LINK_XSTATS; 6091 6092 if (ops && ops->get_linkxstats_size) { 6093 size += nla_total_size(ops->get_linkxstats_size(dev, 6094 attr)); 6095 /* for IFLA_STATS_LINK_XSTATS */ 6096 size += nla_total_size(0); 6097 } 6098 } 6099 6100 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 0)) { 6101 struct net_device *_dev = (struct net_device *)dev; 6102 const struct rtnl_link_ops *ops = NULL; 6103 const struct net_device *master; 6104 6105 /* netdev_master_upper_dev_get can't take const */ 6106 master = netdev_master_upper_dev_get(_dev); 6107 if (master) 6108 ops = master->rtnl_link_ops; 6109 if (ops && ops->get_linkxstats_size) { 6110 int attr = IFLA_STATS_LINK_XSTATS_SLAVE; 6111 6112 size += nla_total_size(ops->get_linkxstats_size(dev, 6113 attr)); 6114 /* for IFLA_STATS_LINK_XSTATS_SLAVE */ 6115 size += nla_total_size(0); 6116 } 6117 } 6118 6119 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 0)) { 6120 u32 off_filter_mask; 6121 6122 off_filter_mask = filters->mask[IFLA_STATS_LINK_OFFLOAD_XSTATS]; 6123 size += rtnl_offload_xstats_get_size(dev, off_filter_mask); 6124 } 6125 6126 if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, 0)) { 6127 struct rtnl_af_ops *af_ops; 6128 6129 /* for IFLA_STATS_AF_SPEC */ 6130 size += nla_total_size(0); 6131 6132 rcu_read_lock(); 6133 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { 6134 if (af_ops->get_stats_af_size) { 6135 size += nla_total_size( 6136 af_ops->get_stats_af_size(dev)); 6137 6138 /* for AF_* */ 6139 size += nla_total_size(0); 6140 } 6141 } 6142 rcu_read_unlock(); 6143 } 6144 6145 return size; 6146 } 6147 6148 #define RTNL_STATS_OFFLOAD_XSTATS_VALID ((1 << __IFLA_OFFLOAD_XSTATS_MAX) - 1) 6149 6150 static const struct nla_policy 6151 rtnl_stats_get_policy_filters[IFLA_STATS_MAX + 1] = { 6152 [IFLA_STATS_LINK_OFFLOAD_XSTATS] = 6153 NLA_POLICY_MASK(NLA_U32, RTNL_STATS_OFFLOAD_XSTATS_VALID), 6154 }; 6155 6156 static const struct nla_policy 6157 rtnl_stats_get_policy[IFLA_STATS_GETSET_MAX + 1] = { 6158 [IFLA_STATS_GET_FILTERS] = 6159 NLA_POLICY_NESTED(rtnl_stats_get_policy_filters), 6160 }; 6161 6162 static const struct nla_policy 6163 ifla_stats_set_policy[IFLA_STATS_GETSET_MAX + 1] = { 6164 [IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS] = NLA_POLICY_MAX(NLA_U8, 1), 6165 }; 6166 6167 static int rtnl_stats_get_parse_filters(struct nlattr *ifla_filters, 6168 struct rtnl_stats_dump_filters *filters, 6169 struct netlink_ext_ack *extack) 6170 { 6171 struct nlattr *tb[IFLA_STATS_MAX + 1]; 6172 int err; 6173 int at; 6174 6175 err = nla_parse_nested(tb, IFLA_STATS_MAX, ifla_filters, 6176 rtnl_stats_get_policy_filters, extack); 6177 if (err < 0) 6178 return err; 6179 6180 for (at = 1; at <= IFLA_STATS_MAX; at++) { 6181 if (tb[at]) { 6182 if (!(filters->mask[0] & IFLA_STATS_FILTER_BIT(at))) { 6183 NL_SET_ERR_MSG(extack, "Filtered attribute not enabled in filter_mask"); 6184 return -EINVAL; 6185 } 6186 filters->mask[at] = nla_get_u32(tb[at]); 6187 } 6188 } 6189 6190 return 0; 6191 } 6192 6193 static int rtnl_stats_get_parse(const struct nlmsghdr *nlh, 6194 u32 filter_mask, 6195 struct rtnl_stats_dump_filters *filters, 6196 struct netlink_ext_ack *extack) 6197 { 6198 struct nlattr *tb[IFLA_STATS_GETSET_MAX + 1]; 6199 int err; 6200 int i; 6201 6202 filters->mask[0] = filter_mask; 6203 for (i = 1; i < ARRAY_SIZE(filters->mask); i++) 6204 filters->mask[i] = -1U; 6205 6206 err = nlmsg_parse(nlh, sizeof(struct if_stats_msg), tb, 6207 IFLA_STATS_GETSET_MAX, rtnl_stats_get_policy, extack); 6208 if (err < 0) 6209 return err; 6210 6211 if (tb[IFLA_STATS_GET_FILTERS]) { 6212 err = rtnl_stats_get_parse_filters(tb[IFLA_STATS_GET_FILTERS], 6213 filters, extack); 6214 if (err) 6215 return err; 6216 } 6217 6218 return 0; 6219 } 6220 6221 static int rtnl_valid_stats_req(const struct nlmsghdr *nlh, bool strict_check, 6222 bool is_dump, struct netlink_ext_ack *extack) 6223 { 6224 struct if_stats_msg *ifsm; 6225 6226 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifsm))) { 6227 NL_SET_ERR_MSG(extack, "Invalid header for stats dump"); 6228 return -EINVAL; 6229 } 6230 6231 if (!strict_check) 6232 return 0; 6233 6234 ifsm = nlmsg_data(nlh); 6235 6236 /* only requests using strict checks can pass data to influence 6237 * the dump. The legacy exception is filter_mask. 6238 */ 6239 if (ifsm->pad1 || ifsm->pad2 || (is_dump && ifsm->ifindex)) { 6240 NL_SET_ERR_MSG(extack, "Invalid values in header for stats dump request"); 6241 return -EINVAL; 6242 } 6243 if (ifsm->filter_mask >= IFLA_STATS_FILTER_BIT(IFLA_STATS_MAX + 1)) { 6244 NL_SET_ERR_MSG(extack, "Invalid stats requested through filter mask"); 6245 return -EINVAL; 6246 } 6247 6248 return 0; 6249 } 6250 6251 static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh, 6252 struct netlink_ext_ack *extack) 6253 { 6254 struct rtnl_stats_dump_filters filters; 6255 struct net *net = sock_net(skb->sk); 6256 struct net_device *dev = NULL; 6257 int idxattr = 0, prividx = 0; 6258 struct if_stats_msg *ifsm; 6259 struct sk_buff *nskb; 6260 int err; 6261 6262 err = rtnl_valid_stats_req(nlh, netlink_strict_get_check(skb), 6263 false, extack); 6264 if (err) 6265 return err; 6266 6267 ifsm = nlmsg_data(nlh); 6268 if (ifsm->ifindex > 0) 6269 dev = __dev_get_by_index(net, ifsm->ifindex); 6270 else 6271 return -EINVAL; 6272 6273 if (!dev) 6274 return -ENODEV; 6275 6276 if (!ifsm->filter_mask) { 6277 NL_SET_ERR_MSG(extack, "Filter mask must be set for stats get"); 6278 return -EINVAL; 6279 } 6280 6281 err = rtnl_stats_get_parse(nlh, ifsm->filter_mask, &filters, extack); 6282 if (err) 6283 return err; 6284 6285 nskb = nlmsg_new(if_nlmsg_stats_size(dev, &filters), GFP_KERNEL); 6286 if (!nskb) 6287 return -ENOBUFS; 6288 6289 err = rtnl_fill_statsinfo(nskb, dev, RTM_NEWSTATS, 6290 NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0, 6291 0, &filters, &idxattr, &prividx, extack); 6292 if (err < 0) { 6293 /* -EMSGSIZE implies BUG in if_nlmsg_stats_size */ 6294 WARN_ON(err == -EMSGSIZE); 6295 kfree_skb(nskb); 6296 } else { 6297 err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid); 6298 } 6299 6300 return err; 6301 } 6302 6303 static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb) 6304 { 6305 struct netlink_ext_ack *extack = cb->extack; 6306 struct rtnl_stats_dump_filters filters; 6307 struct net *net = sock_net(skb->sk); 6308 unsigned int flags = NLM_F_MULTI; 6309 struct if_stats_msg *ifsm; 6310 struct { 6311 unsigned long ifindex; 6312 int idxattr; 6313 int prividx; 6314 } *ctx = (void *)cb->ctx; 6315 struct net_device *dev; 6316 int err; 6317 6318 cb->seq = net->dev_base_seq; 6319 6320 err = rtnl_valid_stats_req(cb->nlh, cb->strict_check, true, extack); 6321 if (err) 6322 return err; 6323 6324 ifsm = nlmsg_data(cb->nlh); 6325 if (!ifsm->filter_mask) { 6326 NL_SET_ERR_MSG(extack, "Filter mask must be set for stats dump"); 6327 return -EINVAL; 6328 } 6329 6330 err = rtnl_stats_get_parse(cb->nlh, ifsm->filter_mask, &filters, 6331 extack); 6332 if (err) 6333 return err; 6334 6335 for_each_netdev_dump(net, dev, ctx->ifindex) { 6336 err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS, 6337 NETLINK_CB(cb->skb).portid, 6338 cb->nlh->nlmsg_seq, 0, 6339 flags, &filters, 6340 &ctx->idxattr, &ctx->prividx, 6341 extack); 6342 /* If we ran out of room on the first message, 6343 * we're in trouble. 6344 */ 6345 WARN_ON((err == -EMSGSIZE) && (skb->len == 0)); 6346 6347 if (err < 0) 6348 break; 6349 ctx->prividx = 0; 6350 ctx->idxattr = 0; 6351 nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 6352 } 6353 6354 return err; 6355 } 6356 6357 void rtnl_offload_xstats_notify(struct net_device *dev) 6358 { 6359 struct rtnl_stats_dump_filters response_filters = {}; 6360 struct net *net = dev_net(dev); 6361 int idxattr = 0, prividx = 0; 6362 struct sk_buff *skb; 6363 int err = -ENOBUFS; 6364 6365 ASSERT_RTNL(); 6366 6367 response_filters.mask[0] |= 6368 IFLA_STATS_FILTER_BIT(IFLA_STATS_LINK_OFFLOAD_XSTATS); 6369 response_filters.mask[IFLA_STATS_LINK_OFFLOAD_XSTATS] |= 6370 IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_HW_S_INFO); 6371 6372 skb = nlmsg_new(if_nlmsg_stats_size(dev, &response_filters), 6373 GFP_KERNEL); 6374 if (!skb) 6375 goto errout; 6376 6377 err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS, 0, 0, 0, 0, 6378 &response_filters, &idxattr, &prividx, NULL); 6379 if (err < 0) { 6380 kfree_skb(skb); 6381 goto errout; 6382 } 6383 6384 rtnl_notify(skb, net, 0, RTNLGRP_STATS, NULL, GFP_KERNEL); 6385 return; 6386 6387 errout: 6388 rtnl_set_sk_err(net, RTNLGRP_STATS, err); 6389 } 6390 EXPORT_SYMBOL(rtnl_offload_xstats_notify); 6391 6392 static int rtnl_stats_set(struct sk_buff *skb, struct nlmsghdr *nlh, 6393 struct netlink_ext_ack *extack) 6394 { 6395 enum netdev_offload_xstats_type t_l3 = NETDEV_OFFLOAD_XSTATS_TYPE_L3; 6396 struct rtnl_stats_dump_filters response_filters = {}; 6397 struct nlattr *tb[IFLA_STATS_GETSET_MAX + 1]; 6398 struct net *net = sock_net(skb->sk); 6399 struct net_device *dev = NULL; 6400 struct if_stats_msg *ifsm; 6401 bool notify = false; 6402 int err; 6403 6404 err = rtnl_valid_stats_req(nlh, netlink_strict_get_check(skb), 6405 false, extack); 6406 if (err) 6407 return err; 6408 6409 ifsm = nlmsg_data(nlh); 6410 if (ifsm->family != AF_UNSPEC) { 6411 NL_SET_ERR_MSG(extack, "Address family should be AF_UNSPEC"); 6412 return -EINVAL; 6413 } 6414 6415 if (ifsm->ifindex > 0) 6416 dev = __dev_get_by_index(net, ifsm->ifindex); 6417 else 6418 return -EINVAL; 6419 6420 if (!dev) 6421 return -ENODEV; 6422 6423 if (ifsm->filter_mask) { 6424 NL_SET_ERR_MSG(extack, "Filter mask must be 0 for stats set"); 6425 return -EINVAL; 6426 } 6427 6428 err = nlmsg_parse(nlh, sizeof(*ifsm), tb, IFLA_STATS_GETSET_MAX, 6429 ifla_stats_set_policy, extack); 6430 if (err < 0) 6431 return err; 6432 6433 if (tb[IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS]) { 6434 u8 req = nla_get_u8(tb[IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS]); 6435 6436 if (req) 6437 err = netdev_offload_xstats_enable(dev, t_l3, extack); 6438 else 6439 err = netdev_offload_xstats_disable(dev, t_l3); 6440 6441 if (!err) 6442 notify = true; 6443 else if (err != -EALREADY) 6444 return err; 6445 6446 response_filters.mask[0] |= 6447 IFLA_STATS_FILTER_BIT(IFLA_STATS_LINK_OFFLOAD_XSTATS); 6448 response_filters.mask[IFLA_STATS_LINK_OFFLOAD_XSTATS] |= 6449 IFLA_STATS_FILTER_BIT(IFLA_OFFLOAD_XSTATS_HW_S_INFO); 6450 } 6451 6452 if (notify) 6453 rtnl_offload_xstats_notify(dev); 6454 6455 return 0; 6456 } 6457 6458 static int rtnl_mdb_valid_dump_req(const struct nlmsghdr *nlh, 6459 struct netlink_ext_ack *extack) 6460 { 6461 struct br_port_msg *bpm; 6462 6463 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*bpm))) { 6464 NL_SET_ERR_MSG(extack, "Invalid header for mdb dump request"); 6465 return -EINVAL; 6466 } 6467 6468 bpm = nlmsg_data(nlh); 6469 if (bpm->ifindex) { 6470 NL_SET_ERR_MSG(extack, "Filtering by device index is not supported for mdb dump request"); 6471 return -EINVAL; 6472 } 6473 if (nlmsg_attrlen(nlh, sizeof(*bpm))) { 6474 NL_SET_ERR_MSG(extack, "Invalid data after header in mdb dump request"); 6475 return -EINVAL; 6476 } 6477 6478 return 0; 6479 } 6480 6481 struct rtnl_mdb_dump_ctx { 6482 long idx; 6483 }; 6484 6485 static int rtnl_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb) 6486 { 6487 struct rtnl_mdb_dump_ctx *ctx = (void *)cb->ctx; 6488 struct net *net = sock_net(skb->sk); 6489 struct net_device *dev; 6490 int idx, s_idx; 6491 int err; 6492 6493 NL_ASSERT_CTX_FITS(struct rtnl_mdb_dump_ctx); 6494 6495 if (cb->strict_check) { 6496 err = rtnl_mdb_valid_dump_req(cb->nlh, cb->extack); 6497 if (err) 6498 return err; 6499 } 6500 6501 s_idx = ctx->idx; 6502 idx = 0; 6503 6504 for_each_netdev(net, dev) { 6505 if (idx < s_idx) 6506 goto skip; 6507 if (!dev->netdev_ops->ndo_mdb_dump) 6508 goto skip; 6509 6510 err = dev->netdev_ops->ndo_mdb_dump(dev, skb, cb); 6511 if (err == -EMSGSIZE) 6512 goto out; 6513 /* Moving on to next device, reset markers and sequence 6514 * counters since they are all maintained per-device. 6515 */ 6516 memset(cb->ctx, 0, sizeof(cb->ctx)); 6517 cb->prev_seq = 0; 6518 cb->seq = 0; 6519 skip: 6520 idx++; 6521 } 6522 6523 out: 6524 ctx->idx = idx; 6525 return skb->len; 6526 } 6527 6528 static int rtnl_validate_mdb_entry_get(const struct nlattr *attr, 6529 struct netlink_ext_ack *extack) 6530 { 6531 struct br_mdb_entry *entry = nla_data(attr); 6532 6533 if (nla_len(attr) != sizeof(struct br_mdb_entry)) { 6534 NL_SET_ERR_MSG_ATTR(extack, attr, "Invalid attribute length"); 6535 return -EINVAL; 6536 } 6537 6538 if (entry->ifindex) { 6539 NL_SET_ERR_MSG(extack, "Entry ifindex cannot be specified"); 6540 return -EINVAL; 6541 } 6542 6543 if (entry->state) { 6544 NL_SET_ERR_MSG(extack, "Entry state cannot be specified"); 6545 return -EINVAL; 6546 } 6547 6548 if (entry->flags) { 6549 NL_SET_ERR_MSG(extack, "Entry flags cannot be specified"); 6550 return -EINVAL; 6551 } 6552 6553 if (entry->vid >= VLAN_VID_MASK) { 6554 NL_SET_ERR_MSG(extack, "Invalid entry VLAN id"); 6555 return -EINVAL; 6556 } 6557 6558 if (entry->addr.proto != htons(ETH_P_IP) && 6559 entry->addr.proto != htons(ETH_P_IPV6) && 6560 entry->addr.proto != 0) { 6561 NL_SET_ERR_MSG(extack, "Unknown entry protocol"); 6562 return -EINVAL; 6563 } 6564 6565 return 0; 6566 } 6567 6568 static const struct nla_policy mdba_get_policy[MDBA_GET_ENTRY_MAX + 1] = { 6569 [MDBA_GET_ENTRY] = NLA_POLICY_VALIDATE_FN(NLA_BINARY, 6570 rtnl_validate_mdb_entry_get, 6571 sizeof(struct br_mdb_entry)), 6572 [MDBA_GET_ENTRY_ATTRS] = { .type = NLA_NESTED }, 6573 }; 6574 6575 static int rtnl_mdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh, 6576 struct netlink_ext_ack *extack) 6577 { 6578 struct nlattr *tb[MDBA_GET_ENTRY_MAX + 1]; 6579 struct net *net = sock_net(in_skb->sk); 6580 struct br_port_msg *bpm; 6581 struct net_device *dev; 6582 int err; 6583 6584 err = nlmsg_parse(nlh, sizeof(struct br_port_msg), tb, 6585 MDBA_GET_ENTRY_MAX, mdba_get_policy, extack); 6586 if (err) 6587 return err; 6588 6589 bpm = nlmsg_data(nlh); 6590 if (!bpm->ifindex) { 6591 NL_SET_ERR_MSG(extack, "Invalid ifindex"); 6592 return -EINVAL; 6593 } 6594 6595 dev = __dev_get_by_index(net, bpm->ifindex); 6596 if (!dev) { 6597 NL_SET_ERR_MSG(extack, "Device doesn't exist"); 6598 return -ENODEV; 6599 } 6600 6601 if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_GET_ENTRY)) { 6602 NL_SET_ERR_MSG(extack, "Missing MDBA_GET_ENTRY attribute"); 6603 return -EINVAL; 6604 } 6605 6606 if (!dev->netdev_ops->ndo_mdb_get) { 6607 NL_SET_ERR_MSG(extack, "Device does not support MDB operations"); 6608 return -EOPNOTSUPP; 6609 } 6610 6611 return dev->netdev_ops->ndo_mdb_get(dev, tb, NETLINK_CB(in_skb).portid, 6612 nlh->nlmsg_seq, extack); 6613 } 6614 6615 static int rtnl_validate_mdb_entry(const struct nlattr *attr, 6616 struct netlink_ext_ack *extack) 6617 { 6618 struct br_mdb_entry *entry = nla_data(attr); 6619 6620 if (nla_len(attr) != sizeof(struct br_mdb_entry)) { 6621 NL_SET_ERR_MSG_ATTR(extack, attr, "Invalid attribute length"); 6622 return -EINVAL; 6623 } 6624 6625 if (entry->ifindex == 0) { 6626 NL_SET_ERR_MSG(extack, "Zero entry ifindex is not allowed"); 6627 return -EINVAL; 6628 } 6629 6630 if (entry->addr.proto == htons(ETH_P_IP)) { 6631 if (!ipv4_is_multicast(entry->addr.u.ip4) && 6632 !ipv4_is_zeronet(entry->addr.u.ip4)) { 6633 NL_SET_ERR_MSG(extack, "IPv4 entry group address is not multicast or 0.0.0.0"); 6634 return -EINVAL; 6635 } 6636 if (ipv4_is_local_multicast(entry->addr.u.ip4)) { 6637 NL_SET_ERR_MSG(extack, "IPv4 entry group address is local multicast"); 6638 return -EINVAL; 6639 } 6640 #if IS_ENABLED(CONFIG_IPV6) 6641 } else if (entry->addr.proto == htons(ETH_P_IPV6)) { 6642 if (ipv6_addr_is_ll_all_nodes(&entry->addr.u.ip6)) { 6643 NL_SET_ERR_MSG(extack, "IPv6 entry group address is link-local all nodes"); 6644 return -EINVAL; 6645 } 6646 #endif 6647 } else if (entry->addr.proto == 0) { 6648 /* L2 mdb */ 6649 if (!is_multicast_ether_addr(entry->addr.u.mac_addr)) { 6650 NL_SET_ERR_MSG(extack, "L2 entry group is not multicast"); 6651 return -EINVAL; 6652 } 6653 } else { 6654 NL_SET_ERR_MSG(extack, "Unknown entry protocol"); 6655 return -EINVAL; 6656 } 6657 6658 if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY) { 6659 NL_SET_ERR_MSG(extack, "Unknown entry state"); 6660 return -EINVAL; 6661 } 6662 if (entry->vid >= VLAN_VID_MASK) { 6663 NL_SET_ERR_MSG(extack, "Invalid entry VLAN id"); 6664 return -EINVAL; 6665 } 6666 6667 return 0; 6668 } 6669 6670 static const struct nla_policy mdba_policy[MDBA_SET_ENTRY_MAX + 1] = { 6671 [MDBA_SET_ENTRY_UNSPEC] = { .strict_start_type = MDBA_SET_ENTRY_ATTRS + 1 }, 6672 [MDBA_SET_ENTRY] = NLA_POLICY_VALIDATE_FN(NLA_BINARY, 6673 rtnl_validate_mdb_entry, 6674 sizeof(struct br_mdb_entry)), 6675 [MDBA_SET_ENTRY_ATTRS] = { .type = NLA_NESTED }, 6676 }; 6677 6678 static int rtnl_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, 6679 struct netlink_ext_ack *extack) 6680 { 6681 struct nlattr *tb[MDBA_SET_ENTRY_MAX + 1]; 6682 struct net *net = sock_net(skb->sk); 6683 struct br_port_msg *bpm; 6684 struct net_device *dev; 6685 int err; 6686 6687 err = nlmsg_parse_deprecated(nlh, sizeof(*bpm), tb, 6688 MDBA_SET_ENTRY_MAX, mdba_policy, extack); 6689 if (err) 6690 return err; 6691 6692 bpm = nlmsg_data(nlh); 6693 if (!bpm->ifindex) { 6694 NL_SET_ERR_MSG(extack, "Invalid ifindex"); 6695 return -EINVAL; 6696 } 6697 6698 dev = __dev_get_by_index(net, bpm->ifindex); 6699 if (!dev) { 6700 NL_SET_ERR_MSG(extack, "Device doesn't exist"); 6701 return -ENODEV; 6702 } 6703 6704 if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_SET_ENTRY)) { 6705 NL_SET_ERR_MSG(extack, "Missing MDBA_SET_ENTRY attribute"); 6706 return -EINVAL; 6707 } 6708 6709 if (!dev->netdev_ops->ndo_mdb_add) { 6710 NL_SET_ERR_MSG(extack, "Device does not support MDB operations"); 6711 return -EOPNOTSUPP; 6712 } 6713 6714 return dev->netdev_ops->ndo_mdb_add(dev, tb, nlh->nlmsg_flags, extack); 6715 } 6716 6717 static int rtnl_validate_mdb_entry_del_bulk(const struct nlattr *attr, 6718 struct netlink_ext_ack *extack) 6719 { 6720 struct br_mdb_entry *entry = nla_data(attr); 6721 struct br_mdb_entry zero_entry = {}; 6722 6723 if (nla_len(attr) != sizeof(struct br_mdb_entry)) { 6724 NL_SET_ERR_MSG_ATTR(extack, attr, "Invalid attribute length"); 6725 return -EINVAL; 6726 } 6727 6728 if (entry->state != MDB_PERMANENT && entry->state != MDB_TEMPORARY) { 6729 NL_SET_ERR_MSG(extack, "Unknown entry state"); 6730 return -EINVAL; 6731 } 6732 6733 if (entry->flags) { 6734 NL_SET_ERR_MSG(extack, "Entry flags cannot be set"); 6735 return -EINVAL; 6736 } 6737 6738 if (entry->vid >= VLAN_N_VID - 1) { 6739 NL_SET_ERR_MSG(extack, "Invalid entry VLAN id"); 6740 return -EINVAL; 6741 } 6742 6743 if (memcmp(&entry->addr, &zero_entry.addr, sizeof(entry->addr))) { 6744 NL_SET_ERR_MSG(extack, "Entry address cannot be set"); 6745 return -EINVAL; 6746 } 6747 6748 return 0; 6749 } 6750 6751 static const struct nla_policy mdba_del_bulk_policy[MDBA_SET_ENTRY_MAX + 1] = { 6752 [MDBA_SET_ENTRY] = NLA_POLICY_VALIDATE_FN(NLA_BINARY, 6753 rtnl_validate_mdb_entry_del_bulk, 6754 sizeof(struct br_mdb_entry)), 6755 [MDBA_SET_ENTRY_ATTRS] = { .type = NLA_NESTED }, 6756 }; 6757 6758 static int rtnl_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh, 6759 struct netlink_ext_ack *extack) 6760 { 6761 bool del_bulk = !!(nlh->nlmsg_flags & NLM_F_BULK); 6762 struct nlattr *tb[MDBA_SET_ENTRY_MAX + 1]; 6763 struct net *net = sock_net(skb->sk); 6764 struct br_port_msg *bpm; 6765 struct net_device *dev; 6766 int err; 6767 6768 if (!del_bulk) 6769 err = nlmsg_parse_deprecated(nlh, sizeof(*bpm), tb, 6770 MDBA_SET_ENTRY_MAX, mdba_policy, 6771 extack); 6772 else 6773 err = nlmsg_parse(nlh, sizeof(*bpm), tb, MDBA_SET_ENTRY_MAX, 6774 mdba_del_bulk_policy, extack); 6775 if (err) 6776 return err; 6777 6778 bpm = nlmsg_data(nlh); 6779 if (!bpm->ifindex) { 6780 NL_SET_ERR_MSG(extack, "Invalid ifindex"); 6781 return -EINVAL; 6782 } 6783 6784 dev = __dev_get_by_index(net, bpm->ifindex); 6785 if (!dev) { 6786 NL_SET_ERR_MSG(extack, "Device doesn't exist"); 6787 return -ENODEV; 6788 } 6789 6790 if (NL_REQ_ATTR_CHECK(extack, NULL, tb, MDBA_SET_ENTRY)) { 6791 NL_SET_ERR_MSG(extack, "Missing MDBA_SET_ENTRY attribute"); 6792 return -EINVAL; 6793 } 6794 6795 if (del_bulk) { 6796 if (!dev->netdev_ops->ndo_mdb_del_bulk) { 6797 NL_SET_ERR_MSG(extack, "Device does not support MDB bulk deletion"); 6798 return -EOPNOTSUPP; 6799 } 6800 return dev->netdev_ops->ndo_mdb_del_bulk(dev, tb, extack); 6801 } 6802 6803 if (!dev->netdev_ops->ndo_mdb_del) { 6804 NL_SET_ERR_MSG(extack, "Device does not support MDB operations"); 6805 return -EOPNOTSUPP; 6806 } 6807 6808 return dev->netdev_ops->ndo_mdb_del(dev, tb, extack); 6809 } 6810 6811 /* Process one rtnetlink message. */ 6812 6813 static int rtnl_dumpit(struct sk_buff *skb, struct netlink_callback *cb) 6814 { 6815 const bool needs_lock = !(cb->flags & RTNL_FLAG_DUMP_UNLOCKED); 6816 rtnl_dumpit_func dumpit = cb->data; 6817 int err; 6818 6819 /* Previous iteration have already finished, avoid calling->dumpit() 6820 * again, it may not expect to be called after it reached the end. 6821 */ 6822 if (!dumpit) 6823 return 0; 6824 6825 if (needs_lock) 6826 rtnl_lock(); 6827 err = dumpit(skb, cb); 6828 if (needs_lock) 6829 rtnl_unlock(); 6830 6831 /* Old dump handlers used to send NLM_DONE as in a separate recvmsg(). 6832 * Some applications which parse netlink manually depend on this. 6833 */ 6834 if (cb->flags & RTNL_FLAG_DUMP_SPLIT_NLM_DONE) { 6835 if (err < 0 && err != -EMSGSIZE) 6836 return err; 6837 if (!err) 6838 cb->data = NULL; 6839 6840 return skb->len; 6841 } 6842 return err; 6843 } 6844 6845 static int rtnetlink_dump_start(struct sock *ssk, struct sk_buff *skb, 6846 const struct nlmsghdr *nlh, 6847 struct netlink_dump_control *control) 6848 { 6849 if (control->flags & RTNL_FLAG_DUMP_SPLIT_NLM_DONE || 6850 !(control->flags & RTNL_FLAG_DUMP_UNLOCKED)) { 6851 WARN_ON(control->data); 6852 control->data = control->dump; 6853 control->dump = rtnl_dumpit; 6854 } 6855 6856 return netlink_dump_start(ssk, skb, nlh, control); 6857 } 6858 6859 static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, 6860 struct netlink_ext_ack *extack) 6861 { 6862 struct net *net = sock_net(skb->sk); 6863 struct rtnl_link *link; 6864 enum rtnl_kinds kind; 6865 struct module *owner; 6866 int err = -EOPNOTSUPP; 6867 rtnl_doit_func doit; 6868 unsigned int flags; 6869 int family; 6870 int type; 6871 6872 type = nlh->nlmsg_type; 6873 if (type > RTM_MAX) 6874 return -EOPNOTSUPP; 6875 6876 type -= RTM_BASE; 6877 6878 /* All the messages must have at least 1 byte length */ 6879 if (nlmsg_len(nlh) < sizeof(struct rtgenmsg)) 6880 return 0; 6881 6882 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family; 6883 kind = rtnl_msgtype_kind(type); 6884 6885 if (kind != RTNL_KIND_GET && !netlink_net_capable(skb, CAP_NET_ADMIN)) 6886 return -EPERM; 6887 6888 rcu_read_lock(); 6889 if (kind == RTNL_KIND_GET && (nlh->nlmsg_flags & NLM_F_DUMP)) { 6890 struct sock *rtnl; 6891 rtnl_dumpit_func dumpit; 6892 u32 min_dump_alloc = 0; 6893 6894 link = rtnl_get_link(family, type); 6895 if (!link || !link->dumpit) { 6896 family = PF_UNSPEC; 6897 link = rtnl_get_link(family, type); 6898 if (!link || !link->dumpit) 6899 goto err_unlock; 6900 } 6901 owner = link->owner; 6902 dumpit = link->dumpit; 6903 flags = link->flags; 6904 6905 if (type == RTM_GETLINK - RTM_BASE) 6906 min_dump_alloc = rtnl_calcit(skb, nlh); 6907 6908 err = 0; 6909 /* need to do this before rcu_read_unlock() */ 6910 if (!try_module_get(owner)) 6911 err = -EPROTONOSUPPORT; 6912 6913 rcu_read_unlock(); 6914 6915 rtnl = net->rtnl; 6916 if (err == 0) { 6917 struct netlink_dump_control c = { 6918 .dump = dumpit, 6919 .min_dump_alloc = min_dump_alloc, 6920 .module = owner, 6921 .flags = flags, 6922 }; 6923 err = rtnetlink_dump_start(rtnl, skb, nlh, &c); 6924 /* netlink_dump_start() will keep a reference on 6925 * module if dump is still in progress. 6926 */ 6927 module_put(owner); 6928 } 6929 return err; 6930 } 6931 6932 link = rtnl_get_link(family, type); 6933 if (!link || !link->doit) { 6934 family = PF_UNSPEC; 6935 link = rtnl_get_link(PF_UNSPEC, type); 6936 if (!link || !link->doit) 6937 goto out_unlock; 6938 } 6939 6940 owner = link->owner; 6941 if (!try_module_get(owner)) { 6942 err = -EPROTONOSUPPORT; 6943 goto out_unlock; 6944 } 6945 6946 flags = link->flags; 6947 if (kind == RTNL_KIND_DEL && (nlh->nlmsg_flags & NLM_F_BULK) && 6948 !(flags & RTNL_FLAG_BULK_DEL_SUPPORTED)) { 6949 NL_SET_ERR_MSG(extack, "Bulk delete is not supported"); 6950 module_put(owner); 6951 goto err_unlock; 6952 } 6953 6954 if (flags & RTNL_FLAG_DOIT_UNLOCKED) { 6955 doit = link->doit; 6956 rcu_read_unlock(); 6957 if (doit) 6958 err = doit(skb, nlh, extack); 6959 module_put(owner); 6960 return err; 6961 } 6962 rcu_read_unlock(); 6963 6964 rtnl_lock(); 6965 link = rtnl_get_link(family, type); 6966 if (link && link->doit) 6967 err = link->doit(skb, nlh, extack); 6968 rtnl_unlock(); 6969 6970 module_put(owner); 6971 6972 return err; 6973 6974 out_unlock: 6975 rcu_read_unlock(); 6976 return err; 6977 6978 err_unlock: 6979 rcu_read_unlock(); 6980 return -EOPNOTSUPP; 6981 } 6982 6983 static void rtnetlink_rcv(struct sk_buff *skb) 6984 { 6985 netlink_rcv_skb(skb, &rtnetlink_rcv_msg); 6986 } 6987 6988 static int rtnetlink_bind(struct net *net, int group) 6989 { 6990 switch (group) { 6991 case RTNLGRP_IPV4_MROUTE_R: 6992 case RTNLGRP_IPV6_MROUTE_R: 6993 if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 6994 return -EPERM; 6995 break; 6996 } 6997 return 0; 6998 } 6999 7000 static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr) 7001 { 7002 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 7003 7004 switch (event) { 7005 case NETDEV_REBOOT: 7006 case NETDEV_CHANGEMTU: 7007 case NETDEV_CHANGEADDR: 7008 case NETDEV_CHANGENAME: 7009 case NETDEV_FEAT_CHANGE: 7010 case NETDEV_BONDING_FAILOVER: 7011 case NETDEV_POST_TYPE_CHANGE: 7012 case NETDEV_NOTIFY_PEERS: 7013 case NETDEV_CHANGEUPPER: 7014 case NETDEV_RESEND_IGMP: 7015 case NETDEV_CHANGEINFODATA: 7016 case NETDEV_CHANGELOWERSTATE: 7017 case NETDEV_CHANGE_TX_QUEUE_LEN: 7018 rtmsg_ifinfo_event(RTM_NEWLINK, dev, 0, rtnl_get_event(event), 7019 GFP_KERNEL, NULL, 0, 0, NULL); 7020 break; 7021 default: 7022 break; 7023 } 7024 return NOTIFY_DONE; 7025 } 7026 7027 static struct notifier_block rtnetlink_dev_notifier = { 7028 .notifier_call = rtnetlink_event, 7029 }; 7030 7031 7032 static int __net_init rtnetlink_net_init(struct net *net) 7033 { 7034 struct sock *sk; 7035 struct netlink_kernel_cfg cfg = { 7036 .groups = RTNLGRP_MAX, 7037 .input = rtnetlink_rcv, 7038 .flags = NL_CFG_F_NONROOT_RECV, 7039 .bind = rtnetlink_bind, 7040 }; 7041 7042 sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg); 7043 if (!sk) 7044 return -ENOMEM; 7045 net->rtnl = sk; 7046 return 0; 7047 } 7048 7049 static void __net_exit rtnetlink_net_exit(struct net *net) 7050 { 7051 netlink_kernel_release(net->rtnl); 7052 net->rtnl = NULL; 7053 } 7054 7055 static struct pernet_operations rtnetlink_net_ops = { 7056 .init = rtnetlink_net_init, 7057 .exit = rtnetlink_net_exit, 7058 }; 7059 7060 static const struct rtnl_msg_handler rtnetlink_rtnl_msg_handlers[] __initconst = { 7061 {.msgtype = RTM_NEWLINK, .doit = rtnl_newlink, 7062 .flags = RTNL_FLAG_DOIT_PERNET}, 7063 {.msgtype = RTM_DELLINK, .doit = rtnl_dellink, 7064 .flags = RTNL_FLAG_DOIT_PERNET_WIP}, 7065 {.msgtype = RTM_GETLINK, .doit = rtnl_getlink, 7066 .dumpit = rtnl_dump_ifinfo, .flags = RTNL_FLAG_DUMP_SPLIT_NLM_DONE}, 7067 {.msgtype = RTM_SETLINK, .doit = rtnl_setlink, 7068 .flags = RTNL_FLAG_DOIT_PERNET_WIP}, 7069 {.msgtype = RTM_GETADDR, .dumpit = rtnl_dump_all}, 7070 {.msgtype = RTM_GETROUTE, .dumpit = rtnl_dump_all}, 7071 {.msgtype = RTM_GETNETCONF, .dumpit = rtnl_dump_all}, 7072 {.msgtype = RTM_GETSTATS, .doit = rtnl_stats_get, 7073 .dumpit = rtnl_stats_dump}, 7074 {.msgtype = RTM_SETSTATS, .doit = rtnl_stats_set}, 7075 {.msgtype = RTM_NEWLINKPROP, .doit = rtnl_newlinkprop}, 7076 {.msgtype = RTM_DELLINKPROP, .doit = rtnl_dellinkprop}, 7077 {.protocol = PF_BRIDGE, .msgtype = RTM_GETLINK, 7078 .dumpit = rtnl_bridge_getlink}, 7079 {.protocol = PF_BRIDGE, .msgtype = RTM_DELLINK, 7080 .doit = rtnl_bridge_dellink}, 7081 {.protocol = PF_BRIDGE, .msgtype = RTM_SETLINK, 7082 .doit = rtnl_bridge_setlink}, 7083 {.protocol = PF_BRIDGE, .msgtype = RTM_NEWNEIGH, .doit = rtnl_fdb_add}, 7084 {.protocol = PF_BRIDGE, .msgtype = RTM_DELNEIGH, .doit = rtnl_fdb_del, 7085 .flags = RTNL_FLAG_BULK_DEL_SUPPORTED}, 7086 {.protocol = PF_BRIDGE, .msgtype = RTM_GETNEIGH, .doit = rtnl_fdb_get, 7087 .dumpit = rtnl_fdb_dump}, 7088 {.protocol = PF_BRIDGE, .msgtype = RTM_NEWMDB, .doit = rtnl_mdb_add}, 7089 {.protocol = PF_BRIDGE, .msgtype = RTM_DELMDB, .doit = rtnl_mdb_del, 7090 .flags = RTNL_FLAG_BULK_DEL_SUPPORTED}, 7091 {.protocol = PF_BRIDGE, .msgtype = RTM_GETMDB, .doit = rtnl_mdb_get, 7092 .dumpit = rtnl_mdb_dump}, 7093 }; 7094 7095 void __init rtnetlink_init(void) 7096 { 7097 if (register_pernet_subsys(&rtnetlink_net_ops)) 7098 panic("rtnetlink_init: cannot initialize rtnetlink\n"); 7099 7100 register_netdevice_notifier(&rtnetlink_dev_notifier); 7101 7102 rtnl_register_many(rtnetlink_rtnl_msg_handlers); 7103 } 7104