1 /* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * Routing netlink socket interface: protocol independent part. 7 * 8 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * as published by the Free Software Foundation; either version 13 * 2 of the License, or (at your option) any later version. 14 * 15 * Fixes: 16 * Vitaly E. Lavrov RTA_OK arithmetics was wrong. 17 */ 18 19 #include <linux/bitops.h> 20 #include <linux/errno.h> 21 #include <linux/module.h> 22 #include <linux/types.h> 23 #include <linux/socket.h> 24 #include <linux/kernel.h> 25 #include <linux/timer.h> 26 #include <linux/string.h> 27 #include <linux/sockios.h> 28 #include <linux/net.h> 29 #include <linux/fcntl.h> 30 #include <linux/mm.h> 31 #include <linux/slab.h> 32 #include <linux/interrupt.h> 33 #include <linux/capability.h> 34 #include <linux/skbuff.h> 35 #include <linux/init.h> 36 #include <linux/security.h> 37 #include <linux/mutex.h> 38 #include <linux/if_addr.h> 39 #include <linux/if_bridge.h> 40 #include <linux/if_vlan.h> 41 #include <linux/pci.h> 42 #include <linux/etherdevice.h> 43 #include <linux/bpf.h> 44 45 #include <linux/uaccess.h> 46 47 #include <linux/inet.h> 48 #include <linux/netdevice.h> 49 #include <net/switchdev.h> 50 #include <net/ip.h> 51 #include <net/protocol.h> 52 #include <net/arp.h> 53 #include <net/route.h> 54 #include <net/udp.h> 55 #include <net/tcp.h> 56 #include <net/sock.h> 57 #include <net/pkt_sched.h> 58 #include <net/fib_rules.h> 59 #include <net/rtnetlink.h> 60 #include <net/net_namespace.h> 61 62 struct rtnl_link { 63 rtnl_doit_func doit; 64 rtnl_dumpit_func dumpit; 65 struct module *owner; 66 unsigned int flags; 67 struct rcu_head rcu; 68 }; 69 70 static DEFINE_MUTEX(rtnl_mutex); 71 72 void rtnl_lock(void) 73 { 74 mutex_lock(&rtnl_mutex); 75 } 76 EXPORT_SYMBOL(rtnl_lock); 77 78 static struct sk_buff *defer_kfree_skb_list; 79 void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail) 80 { 81 if (head && tail) { 82 tail->next = defer_kfree_skb_list; 83 defer_kfree_skb_list = head; 84 } 85 } 86 EXPORT_SYMBOL(rtnl_kfree_skbs); 87 88 void __rtnl_unlock(void) 89 { 90 struct sk_buff *head = defer_kfree_skb_list; 91 92 defer_kfree_skb_list = NULL; 93 94 mutex_unlock(&rtnl_mutex); 95 96 while (head) { 97 struct sk_buff *next = head->next; 98 99 kfree_skb(head); 100 cond_resched(); 101 head = next; 102 } 103 } 104 105 void rtnl_unlock(void) 106 { 107 /* This fellow will unlock it for us. */ 108 netdev_run_todo(); 109 } 110 EXPORT_SYMBOL(rtnl_unlock); 111 112 int rtnl_trylock(void) 113 { 114 return mutex_trylock(&rtnl_mutex); 115 } 116 EXPORT_SYMBOL(rtnl_trylock); 117 118 int rtnl_is_locked(void) 119 { 120 return mutex_is_locked(&rtnl_mutex); 121 } 122 EXPORT_SYMBOL(rtnl_is_locked); 123 124 #ifdef CONFIG_PROVE_LOCKING 125 bool lockdep_rtnl_is_held(void) 126 { 127 return lockdep_is_held(&rtnl_mutex); 128 } 129 EXPORT_SYMBOL(lockdep_rtnl_is_held); 130 #endif /* #ifdef CONFIG_PROVE_LOCKING */ 131 132 static struct rtnl_link *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1]; 133 134 static inline int rtm_msgindex(int msgtype) 135 { 136 int msgindex = msgtype - RTM_BASE; 137 138 /* 139 * msgindex < 0 implies someone tried to register a netlink 140 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that 141 * the message type has not been added to linux/rtnetlink.h 142 */ 143 BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES); 144 145 return msgindex; 146 } 147 148 static struct rtnl_link *rtnl_get_link(int protocol, int msgtype) 149 { 150 struct rtnl_link **tab; 151 152 if (protocol >= ARRAY_SIZE(rtnl_msg_handlers)) 153 protocol = PF_UNSPEC; 154 155 tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]); 156 if (!tab) 157 tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]); 158 159 return tab[msgtype]; 160 } 161 162 static int rtnl_register_internal(struct module *owner, 163 int protocol, int msgtype, 164 rtnl_doit_func doit, rtnl_dumpit_func dumpit, 165 unsigned int flags) 166 { 167 struct rtnl_link *link, *old; 168 struct rtnl_link __rcu **tab; 169 int msgindex; 170 int ret = -ENOBUFS; 171 172 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX); 173 msgindex = rtm_msgindex(msgtype); 174 175 rtnl_lock(); 176 tab = rtnl_msg_handlers[protocol]; 177 if (tab == NULL) { 178 tab = kcalloc(RTM_NR_MSGTYPES, sizeof(void *), GFP_KERNEL); 179 if (!tab) 180 goto unlock; 181 182 /* ensures we see the 0 stores */ 183 rcu_assign_pointer(rtnl_msg_handlers[protocol], tab); 184 } 185 186 old = rtnl_dereference(tab[msgindex]); 187 if (old) { 188 link = kmemdup(old, sizeof(*old), GFP_KERNEL); 189 if (!link) 190 goto unlock; 191 } else { 192 link = kzalloc(sizeof(*link), GFP_KERNEL); 193 if (!link) 194 goto unlock; 195 } 196 197 WARN_ON(link->owner && link->owner != owner); 198 link->owner = owner; 199 200 WARN_ON(doit && link->doit && link->doit != doit); 201 if (doit) 202 link->doit = doit; 203 WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit); 204 if (dumpit) 205 link->dumpit = dumpit; 206 207 link->flags |= flags; 208 209 /* publish protocol:msgtype */ 210 rcu_assign_pointer(tab[msgindex], link); 211 ret = 0; 212 if (old) 213 kfree_rcu(old, rcu); 214 unlock: 215 rtnl_unlock(); 216 return ret; 217 } 218 219 /** 220 * rtnl_register_module - Register a rtnetlink message type 221 * 222 * @owner: module registering the hook (THIS_MODULE) 223 * @protocol: Protocol family or PF_UNSPEC 224 * @msgtype: rtnetlink message type 225 * @doit: Function pointer called for each request message 226 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message 227 * @flags: rtnl_link_flags to modifiy behaviour of doit/dumpit functions 228 * 229 * Like rtnl_register, but for use by removable modules. 230 */ 231 int rtnl_register_module(struct module *owner, 232 int protocol, int msgtype, 233 rtnl_doit_func doit, rtnl_dumpit_func dumpit, 234 unsigned int flags) 235 { 236 return rtnl_register_internal(owner, protocol, msgtype, 237 doit, dumpit, flags); 238 } 239 EXPORT_SYMBOL_GPL(rtnl_register_module); 240 241 /** 242 * rtnl_register - Register a rtnetlink message type 243 * @protocol: Protocol family or PF_UNSPEC 244 * @msgtype: rtnetlink message type 245 * @doit: Function pointer called for each request message 246 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message 247 * @flags: rtnl_link_flags to modifiy behaviour of doit/dumpit functions 248 * 249 * Registers the specified function pointers (at least one of them has 250 * to be non-NULL) to be called whenever a request message for the 251 * specified protocol family and message type is received. 252 * 253 * The special protocol family PF_UNSPEC may be used to define fallback 254 * function pointers for the case when no entry for the specific protocol 255 * family exists. 256 */ 257 void rtnl_register(int protocol, int msgtype, 258 rtnl_doit_func doit, rtnl_dumpit_func dumpit, 259 unsigned int flags) 260 { 261 int err; 262 263 err = rtnl_register_internal(NULL, protocol, msgtype, doit, dumpit, 264 flags); 265 if (err) 266 pr_err("Unable to register rtnetlink message handler, " 267 "protocol = %d, message type = %d\n", protocol, msgtype); 268 } 269 270 /** 271 * rtnl_unregister - Unregister a rtnetlink message type 272 * @protocol: Protocol family or PF_UNSPEC 273 * @msgtype: rtnetlink message type 274 * 275 * Returns 0 on success or a negative error code. 276 */ 277 int rtnl_unregister(int protocol, int msgtype) 278 { 279 struct rtnl_link **tab, *link; 280 int msgindex; 281 282 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX); 283 msgindex = rtm_msgindex(msgtype); 284 285 rtnl_lock(); 286 tab = rtnl_dereference(rtnl_msg_handlers[protocol]); 287 if (!tab) { 288 rtnl_unlock(); 289 return -ENOENT; 290 } 291 292 link = tab[msgindex]; 293 rcu_assign_pointer(tab[msgindex], NULL); 294 rtnl_unlock(); 295 296 kfree_rcu(link, rcu); 297 298 return 0; 299 } 300 EXPORT_SYMBOL_GPL(rtnl_unregister); 301 302 /** 303 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol 304 * @protocol : Protocol family or PF_UNSPEC 305 * 306 * Identical to calling rtnl_unregster() for all registered message types 307 * of a certain protocol family. 308 */ 309 void rtnl_unregister_all(int protocol) 310 { 311 struct rtnl_link **tab, *link; 312 int msgindex; 313 314 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX); 315 316 rtnl_lock(); 317 tab = rtnl_msg_handlers[protocol]; 318 RCU_INIT_POINTER(rtnl_msg_handlers[protocol], NULL); 319 for (msgindex = 0; msgindex < RTM_NR_MSGTYPES; msgindex++) { 320 link = tab[msgindex]; 321 if (!link) 322 continue; 323 324 rcu_assign_pointer(tab[msgindex], NULL); 325 kfree_rcu(link, rcu); 326 } 327 rtnl_unlock(); 328 329 synchronize_net(); 330 331 kfree(tab); 332 } 333 EXPORT_SYMBOL_GPL(rtnl_unregister_all); 334 335 static LIST_HEAD(link_ops); 336 337 static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind) 338 { 339 const struct rtnl_link_ops *ops; 340 341 list_for_each_entry(ops, &link_ops, list) { 342 if (!strcmp(ops->kind, kind)) 343 return ops; 344 } 345 return NULL; 346 } 347 348 /** 349 * __rtnl_link_register - Register rtnl_link_ops with rtnetlink. 350 * @ops: struct rtnl_link_ops * to register 351 * 352 * The caller must hold the rtnl_mutex. This function should be used 353 * by drivers that create devices during module initialization. It 354 * must be called before registering the devices. 355 * 356 * Returns 0 on success or a negative error code. 357 */ 358 int __rtnl_link_register(struct rtnl_link_ops *ops) 359 { 360 if (rtnl_link_ops_get(ops->kind)) 361 return -EEXIST; 362 363 /* The check for setup is here because if ops 364 * does not have that filled up, it is not possible 365 * to use the ops for creating device. So do not 366 * fill up dellink as well. That disables rtnl_dellink. 367 */ 368 if (ops->setup && !ops->dellink) 369 ops->dellink = unregister_netdevice_queue; 370 371 list_add_tail(&ops->list, &link_ops); 372 return 0; 373 } 374 EXPORT_SYMBOL_GPL(__rtnl_link_register); 375 376 /** 377 * rtnl_link_register - Register rtnl_link_ops with rtnetlink. 378 * @ops: struct rtnl_link_ops * to register 379 * 380 * Returns 0 on success or a negative error code. 381 */ 382 int rtnl_link_register(struct rtnl_link_ops *ops) 383 { 384 int err; 385 386 rtnl_lock(); 387 err = __rtnl_link_register(ops); 388 rtnl_unlock(); 389 return err; 390 } 391 EXPORT_SYMBOL_GPL(rtnl_link_register); 392 393 static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops) 394 { 395 struct net_device *dev; 396 LIST_HEAD(list_kill); 397 398 for_each_netdev(net, dev) { 399 if (dev->rtnl_link_ops == ops) 400 ops->dellink(dev, &list_kill); 401 } 402 unregister_netdevice_many(&list_kill); 403 } 404 405 /** 406 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink. 407 * @ops: struct rtnl_link_ops * to unregister 408 * 409 * The caller must hold the rtnl_mutex. 410 */ 411 void __rtnl_link_unregister(struct rtnl_link_ops *ops) 412 { 413 struct net *net; 414 415 for_each_net(net) { 416 __rtnl_kill_links(net, ops); 417 } 418 list_del(&ops->list); 419 } 420 EXPORT_SYMBOL_GPL(__rtnl_link_unregister); 421 422 /* Return with the rtnl_lock held when there are no network 423 * devices unregistering in any network namespace. 424 */ 425 static void rtnl_lock_unregistering_all(void) 426 { 427 struct net *net; 428 bool unregistering; 429 DEFINE_WAIT_FUNC(wait, woken_wake_function); 430 431 add_wait_queue(&netdev_unregistering_wq, &wait); 432 for (;;) { 433 unregistering = false; 434 rtnl_lock(); 435 for_each_net(net) { 436 if (net->dev_unreg_count > 0) { 437 unregistering = true; 438 break; 439 } 440 } 441 if (!unregistering) 442 break; 443 __rtnl_unlock(); 444 445 wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT); 446 } 447 remove_wait_queue(&netdev_unregistering_wq, &wait); 448 } 449 450 /** 451 * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink. 452 * @ops: struct rtnl_link_ops * to unregister 453 */ 454 void rtnl_link_unregister(struct rtnl_link_ops *ops) 455 { 456 /* Close the race with cleanup_net() */ 457 mutex_lock(&net_mutex); 458 rtnl_lock_unregistering_all(); 459 __rtnl_link_unregister(ops); 460 rtnl_unlock(); 461 mutex_unlock(&net_mutex); 462 } 463 EXPORT_SYMBOL_GPL(rtnl_link_unregister); 464 465 static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev) 466 { 467 struct net_device *master_dev; 468 const struct rtnl_link_ops *ops; 469 size_t size = 0; 470 471 rcu_read_lock(); 472 473 master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev); 474 if (!master_dev) 475 goto out; 476 477 ops = master_dev->rtnl_link_ops; 478 if (!ops || !ops->get_slave_size) 479 goto out; 480 /* IFLA_INFO_SLAVE_DATA + nested data */ 481 size = nla_total_size(sizeof(struct nlattr)) + 482 ops->get_slave_size(master_dev, dev); 483 484 out: 485 rcu_read_unlock(); 486 return size; 487 } 488 489 static size_t rtnl_link_get_size(const struct net_device *dev) 490 { 491 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 492 size_t size; 493 494 if (!ops) 495 return 0; 496 497 size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */ 498 nla_total_size(strlen(ops->kind) + 1); /* IFLA_INFO_KIND */ 499 500 if (ops->get_size) 501 /* IFLA_INFO_DATA + nested data */ 502 size += nla_total_size(sizeof(struct nlattr)) + 503 ops->get_size(dev); 504 505 if (ops->get_xstats_size) 506 /* IFLA_INFO_XSTATS */ 507 size += nla_total_size(ops->get_xstats_size(dev)); 508 509 size += rtnl_link_get_slave_info_data_size(dev); 510 511 return size; 512 } 513 514 static LIST_HEAD(rtnl_af_ops); 515 516 static const struct rtnl_af_ops *rtnl_af_lookup(const int family) 517 { 518 const struct rtnl_af_ops *ops; 519 520 list_for_each_entry_rcu(ops, &rtnl_af_ops, list) { 521 if (ops->family == family) 522 return ops; 523 } 524 525 return NULL; 526 } 527 528 /** 529 * rtnl_af_register - Register rtnl_af_ops with rtnetlink. 530 * @ops: struct rtnl_af_ops * to register 531 * 532 * Returns 0 on success or a negative error code. 533 */ 534 void rtnl_af_register(struct rtnl_af_ops *ops) 535 { 536 rtnl_lock(); 537 list_add_tail_rcu(&ops->list, &rtnl_af_ops); 538 rtnl_unlock(); 539 } 540 EXPORT_SYMBOL_GPL(rtnl_af_register); 541 542 /** 543 * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink. 544 * @ops: struct rtnl_af_ops * to unregister 545 */ 546 void rtnl_af_unregister(struct rtnl_af_ops *ops) 547 { 548 rtnl_lock(); 549 list_del_rcu(&ops->list); 550 rtnl_unlock(); 551 552 synchronize_rcu(); 553 } 554 EXPORT_SYMBOL_GPL(rtnl_af_unregister); 555 556 static size_t rtnl_link_get_af_size(const struct net_device *dev, 557 u32 ext_filter_mask) 558 { 559 struct rtnl_af_ops *af_ops; 560 size_t size; 561 562 /* IFLA_AF_SPEC */ 563 size = nla_total_size(sizeof(struct nlattr)); 564 565 rcu_read_lock(); 566 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { 567 if (af_ops->get_link_af_size) { 568 /* AF_* + nested data */ 569 size += nla_total_size(sizeof(struct nlattr)) + 570 af_ops->get_link_af_size(dev, ext_filter_mask); 571 } 572 } 573 rcu_read_unlock(); 574 575 return size; 576 } 577 578 static bool rtnl_have_link_slave_info(const struct net_device *dev) 579 { 580 struct net_device *master_dev; 581 bool ret = false; 582 583 rcu_read_lock(); 584 585 master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev); 586 if (master_dev && master_dev->rtnl_link_ops) 587 ret = true; 588 rcu_read_unlock(); 589 return ret; 590 } 591 592 static int rtnl_link_slave_info_fill(struct sk_buff *skb, 593 const struct net_device *dev) 594 { 595 struct net_device *master_dev; 596 const struct rtnl_link_ops *ops; 597 struct nlattr *slave_data; 598 int err; 599 600 master_dev = netdev_master_upper_dev_get((struct net_device *) dev); 601 if (!master_dev) 602 return 0; 603 ops = master_dev->rtnl_link_ops; 604 if (!ops) 605 return 0; 606 if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0) 607 return -EMSGSIZE; 608 if (ops->fill_slave_info) { 609 slave_data = nla_nest_start(skb, IFLA_INFO_SLAVE_DATA); 610 if (!slave_data) 611 return -EMSGSIZE; 612 err = ops->fill_slave_info(skb, master_dev, dev); 613 if (err < 0) 614 goto err_cancel_slave_data; 615 nla_nest_end(skb, slave_data); 616 } 617 return 0; 618 619 err_cancel_slave_data: 620 nla_nest_cancel(skb, slave_data); 621 return err; 622 } 623 624 static int rtnl_link_info_fill(struct sk_buff *skb, 625 const struct net_device *dev) 626 { 627 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 628 struct nlattr *data; 629 int err; 630 631 if (!ops) 632 return 0; 633 if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0) 634 return -EMSGSIZE; 635 if (ops->fill_xstats) { 636 err = ops->fill_xstats(skb, dev); 637 if (err < 0) 638 return err; 639 } 640 if (ops->fill_info) { 641 data = nla_nest_start(skb, IFLA_INFO_DATA); 642 if (data == NULL) 643 return -EMSGSIZE; 644 err = ops->fill_info(skb, dev); 645 if (err < 0) 646 goto err_cancel_data; 647 nla_nest_end(skb, data); 648 } 649 return 0; 650 651 err_cancel_data: 652 nla_nest_cancel(skb, data); 653 return err; 654 } 655 656 static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev) 657 { 658 struct nlattr *linkinfo; 659 int err = -EMSGSIZE; 660 661 linkinfo = nla_nest_start(skb, IFLA_LINKINFO); 662 if (linkinfo == NULL) 663 goto out; 664 665 err = rtnl_link_info_fill(skb, dev); 666 if (err < 0) 667 goto err_cancel_link; 668 669 err = rtnl_link_slave_info_fill(skb, dev); 670 if (err < 0) 671 goto err_cancel_link; 672 673 nla_nest_end(skb, linkinfo); 674 return 0; 675 676 err_cancel_link: 677 nla_nest_cancel(skb, linkinfo); 678 out: 679 return err; 680 } 681 682 int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo) 683 { 684 struct sock *rtnl = net->rtnl; 685 int err = 0; 686 687 NETLINK_CB(skb).dst_group = group; 688 if (echo) 689 refcount_inc(&skb->users); 690 netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL); 691 if (echo) 692 err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT); 693 return err; 694 } 695 696 int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid) 697 { 698 struct sock *rtnl = net->rtnl; 699 700 return nlmsg_unicast(rtnl, skb, pid); 701 } 702 EXPORT_SYMBOL(rtnl_unicast); 703 704 void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group, 705 struct nlmsghdr *nlh, gfp_t flags) 706 { 707 struct sock *rtnl = net->rtnl; 708 int report = 0; 709 710 if (nlh) 711 report = nlmsg_report(nlh); 712 713 nlmsg_notify(rtnl, skb, pid, group, report, flags); 714 } 715 EXPORT_SYMBOL(rtnl_notify); 716 717 void rtnl_set_sk_err(struct net *net, u32 group, int error) 718 { 719 struct sock *rtnl = net->rtnl; 720 721 netlink_set_err(rtnl, 0, group, error); 722 } 723 EXPORT_SYMBOL(rtnl_set_sk_err); 724 725 int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics) 726 { 727 struct nlattr *mx; 728 int i, valid = 0; 729 730 mx = nla_nest_start(skb, RTA_METRICS); 731 if (mx == NULL) 732 return -ENOBUFS; 733 734 for (i = 0; i < RTAX_MAX; i++) { 735 if (metrics[i]) { 736 if (i == RTAX_CC_ALGO - 1) { 737 char tmp[TCP_CA_NAME_MAX], *name; 738 739 name = tcp_ca_get_name_by_key(metrics[i], tmp); 740 if (!name) 741 continue; 742 if (nla_put_string(skb, i + 1, name)) 743 goto nla_put_failure; 744 } else if (i == RTAX_FEATURES - 1) { 745 u32 user_features = metrics[i] & RTAX_FEATURE_MASK; 746 747 if (!user_features) 748 continue; 749 BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK); 750 if (nla_put_u32(skb, i + 1, user_features)) 751 goto nla_put_failure; 752 } else { 753 if (nla_put_u32(skb, i + 1, metrics[i])) 754 goto nla_put_failure; 755 } 756 valid++; 757 } 758 } 759 760 if (!valid) { 761 nla_nest_cancel(skb, mx); 762 return 0; 763 } 764 765 return nla_nest_end(skb, mx); 766 767 nla_put_failure: 768 nla_nest_cancel(skb, mx); 769 return -EMSGSIZE; 770 } 771 EXPORT_SYMBOL(rtnetlink_put_metrics); 772 773 int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id, 774 long expires, u32 error) 775 { 776 struct rta_cacheinfo ci = { 777 .rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse), 778 .rta_used = dst->__use, 779 .rta_clntref = atomic_read(&(dst->__refcnt)), 780 .rta_error = error, 781 .rta_id = id, 782 }; 783 784 if (expires) { 785 unsigned long clock; 786 787 clock = jiffies_to_clock_t(abs(expires)); 788 clock = min_t(unsigned long, clock, INT_MAX); 789 ci.rta_expires = (expires > 0) ? clock : -clock; 790 } 791 return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci); 792 } 793 EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo); 794 795 static void set_operstate(struct net_device *dev, unsigned char transition) 796 { 797 unsigned char operstate = dev->operstate; 798 799 switch (transition) { 800 case IF_OPER_UP: 801 if ((operstate == IF_OPER_DORMANT || 802 operstate == IF_OPER_UNKNOWN) && 803 !netif_dormant(dev)) 804 operstate = IF_OPER_UP; 805 break; 806 807 case IF_OPER_DORMANT: 808 if (operstate == IF_OPER_UP || 809 operstate == IF_OPER_UNKNOWN) 810 operstate = IF_OPER_DORMANT; 811 break; 812 } 813 814 if (dev->operstate != operstate) { 815 write_lock_bh(&dev_base_lock); 816 dev->operstate = operstate; 817 write_unlock_bh(&dev_base_lock); 818 netdev_state_change(dev); 819 } 820 } 821 822 static unsigned int rtnl_dev_get_flags(const struct net_device *dev) 823 { 824 return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) | 825 (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI)); 826 } 827 828 static unsigned int rtnl_dev_combine_flags(const struct net_device *dev, 829 const struct ifinfomsg *ifm) 830 { 831 unsigned int flags = ifm->ifi_flags; 832 833 /* bugwards compatibility: ifi_change == 0 is treated as ~0 */ 834 if (ifm->ifi_change) 835 flags = (flags & ifm->ifi_change) | 836 (rtnl_dev_get_flags(dev) & ~ifm->ifi_change); 837 838 return flags; 839 } 840 841 static void copy_rtnl_link_stats(struct rtnl_link_stats *a, 842 const struct rtnl_link_stats64 *b) 843 { 844 a->rx_packets = b->rx_packets; 845 a->tx_packets = b->tx_packets; 846 a->rx_bytes = b->rx_bytes; 847 a->tx_bytes = b->tx_bytes; 848 a->rx_errors = b->rx_errors; 849 a->tx_errors = b->tx_errors; 850 a->rx_dropped = b->rx_dropped; 851 a->tx_dropped = b->tx_dropped; 852 853 a->multicast = b->multicast; 854 a->collisions = b->collisions; 855 856 a->rx_length_errors = b->rx_length_errors; 857 a->rx_over_errors = b->rx_over_errors; 858 a->rx_crc_errors = b->rx_crc_errors; 859 a->rx_frame_errors = b->rx_frame_errors; 860 a->rx_fifo_errors = b->rx_fifo_errors; 861 a->rx_missed_errors = b->rx_missed_errors; 862 863 a->tx_aborted_errors = b->tx_aborted_errors; 864 a->tx_carrier_errors = b->tx_carrier_errors; 865 a->tx_fifo_errors = b->tx_fifo_errors; 866 a->tx_heartbeat_errors = b->tx_heartbeat_errors; 867 a->tx_window_errors = b->tx_window_errors; 868 869 a->rx_compressed = b->rx_compressed; 870 a->tx_compressed = b->tx_compressed; 871 872 a->rx_nohandler = b->rx_nohandler; 873 } 874 875 /* All VF info */ 876 static inline int rtnl_vfinfo_size(const struct net_device *dev, 877 u32 ext_filter_mask) 878 { 879 if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) { 880 int num_vfs = dev_num_vf(dev->dev.parent); 881 size_t size = nla_total_size(0); 882 size += num_vfs * 883 (nla_total_size(0) + 884 nla_total_size(sizeof(struct ifla_vf_mac)) + 885 nla_total_size(sizeof(struct ifla_vf_vlan)) + 886 nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */ 887 nla_total_size(MAX_VLAN_LIST_LEN * 888 sizeof(struct ifla_vf_vlan_info)) + 889 nla_total_size(sizeof(struct ifla_vf_spoofchk)) + 890 nla_total_size(sizeof(struct ifla_vf_tx_rate)) + 891 nla_total_size(sizeof(struct ifla_vf_rate)) + 892 nla_total_size(sizeof(struct ifla_vf_link_state)) + 893 nla_total_size(sizeof(struct ifla_vf_rss_query_en)) + 894 nla_total_size(0) + /* nest IFLA_VF_STATS */ 895 /* IFLA_VF_STATS_RX_PACKETS */ 896 nla_total_size_64bit(sizeof(__u64)) + 897 /* IFLA_VF_STATS_TX_PACKETS */ 898 nla_total_size_64bit(sizeof(__u64)) + 899 /* IFLA_VF_STATS_RX_BYTES */ 900 nla_total_size_64bit(sizeof(__u64)) + 901 /* IFLA_VF_STATS_TX_BYTES */ 902 nla_total_size_64bit(sizeof(__u64)) + 903 /* IFLA_VF_STATS_BROADCAST */ 904 nla_total_size_64bit(sizeof(__u64)) + 905 /* IFLA_VF_STATS_MULTICAST */ 906 nla_total_size_64bit(sizeof(__u64)) + 907 /* IFLA_VF_STATS_RX_DROPPED */ 908 nla_total_size_64bit(sizeof(__u64)) + 909 /* IFLA_VF_STATS_TX_DROPPED */ 910 nla_total_size_64bit(sizeof(__u64)) + 911 nla_total_size(sizeof(struct ifla_vf_trust))); 912 return size; 913 } else 914 return 0; 915 } 916 917 static size_t rtnl_port_size(const struct net_device *dev, 918 u32 ext_filter_mask) 919 { 920 size_t port_size = nla_total_size(4) /* PORT_VF */ 921 + nla_total_size(PORT_PROFILE_MAX) /* PORT_PROFILE */ 922 + nla_total_size(PORT_UUID_MAX) /* PORT_INSTANCE_UUID */ 923 + nla_total_size(PORT_UUID_MAX) /* PORT_HOST_UUID */ 924 + nla_total_size(1) /* PROT_VDP_REQUEST */ 925 + nla_total_size(2); /* PORT_VDP_RESPONSE */ 926 size_t vf_ports_size = nla_total_size(sizeof(struct nlattr)); 927 size_t vf_port_size = nla_total_size(sizeof(struct nlattr)) 928 + port_size; 929 size_t port_self_size = nla_total_size(sizeof(struct nlattr)) 930 + port_size; 931 932 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent || 933 !(ext_filter_mask & RTEXT_FILTER_VF)) 934 return 0; 935 if (dev_num_vf(dev->dev.parent)) 936 return port_self_size + vf_ports_size + 937 vf_port_size * dev_num_vf(dev->dev.parent); 938 else 939 return port_self_size; 940 } 941 942 static size_t rtnl_xdp_size(void) 943 { 944 size_t xdp_size = nla_total_size(0) + /* nest IFLA_XDP */ 945 nla_total_size(1) + /* XDP_ATTACHED */ 946 nla_total_size(4); /* XDP_PROG_ID */ 947 948 return xdp_size; 949 } 950 951 static noinline size_t if_nlmsg_size(const struct net_device *dev, 952 u32 ext_filter_mask) 953 { 954 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 955 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 956 + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */ 957 + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */ 958 + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap)) 959 + nla_total_size(sizeof(struct rtnl_link_stats)) 960 + nla_total_size_64bit(sizeof(struct rtnl_link_stats64)) 961 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 962 + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */ 963 + nla_total_size(4) /* IFLA_TXQLEN */ 964 + nla_total_size(4) /* IFLA_WEIGHT */ 965 + nla_total_size(4) /* IFLA_MTU */ 966 + nla_total_size(4) /* IFLA_LINK */ 967 + nla_total_size(4) /* IFLA_MASTER */ 968 + nla_total_size(1) /* IFLA_CARRIER */ 969 + nla_total_size(4) /* IFLA_PROMISCUITY */ 970 + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */ 971 + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */ 972 + nla_total_size(4) /* IFLA_GSO_MAX_SEGS */ 973 + nla_total_size(4) /* IFLA_GSO_MAX_SIZE */ 974 + nla_total_size(1) /* IFLA_OPERSTATE */ 975 + nla_total_size(1) /* IFLA_LINKMODE */ 976 + nla_total_size(4) /* IFLA_CARRIER_CHANGES */ 977 + nla_total_size(4) /* IFLA_LINK_NETNSID */ 978 + nla_total_size(4) /* IFLA_GROUP */ 979 + nla_total_size(ext_filter_mask 980 & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */ 981 + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */ 982 + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */ 983 + rtnl_link_get_size(dev) /* IFLA_LINKINFO */ 984 + rtnl_link_get_af_size(dev, ext_filter_mask) /* IFLA_AF_SPEC */ 985 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */ 986 + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */ 987 + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */ 988 + rtnl_xdp_size() /* IFLA_XDP */ 989 + nla_total_size(4) /* IFLA_EVENT */ 990 + nla_total_size(4) /* IFLA_NEW_NETNSID */ 991 + nla_total_size(4) /* IFLA_NEW_IFINDEX */ 992 + nla_total_size(1) /* IFLA_PROTO_DOWN */ 993 + nla_total_size(4) /* IFLA_IF_NETNSID */ 994 + nla_total_size(4) /* IFLA_CARRIER_UP_COUNT */ 995 + nla_total_size(4) /* IFLA_CARRIER_DOWN_COUNT */ 996 + 0; 997 } 998 999 static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev) 1000 { 1001 struct nlattr *vf_ports; 1002 struct nlattr *vf_port; 1003 int vf; 1004 int err; 1005 1006 vf_ports = nla_nest_start(skb, IFLA_VF_PORTS); 1007 if (!vf_ports) 1008 return -EMSGSIZE; 1009 1010 for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) { 1011 vf_port = nla_nest_start(skb, IFLA_VF_PORT); 1012 if (!vf_port) 1013 goto nla_put_failure; 1014 if (nla_put_u32(skb, IFLA_PORT_VF, vf)) 1015 goto nla_put_failure; 1016 err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb); 1017 if (err == -EMSGSIZE) 1018 goto nla_put_failure; 1019 if (err) { 1020 nla_nest_cancel(skb, vf_port); 1021 continue; 1022 } 1023 nla_nest_end(skb, vf_port); 1024 } 1025 1026 nla_nest_end(skb, vf_ports); 1027 1028 return 0; 1029 1030 nla_put_failure: 1031 nla_nest_cancel(skb, vf_ports); 1032 return -EMSGSIZE; 1033 } 1034 1035 static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev) 1036 { 1037 struct nlattr *port_self; 1038 int err; 1039 1040 port_self = nla_nest_start(skb, IFLA_PORT_SELF); 1041 if (!port_self) 1042 return -EMSGSIZE; 1043 1044 err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb); 1045 if (err) { 1046 nla_nest_cancel(skb, port_self); 1047 return (err == -EMSGSIZE) ? err : 0; 1048 } 1049 1050 nla_nest_end(skb, port_self); 1051 1052 return 0; 1053 } 1054 1055 static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev, 1056 u32 ext_filter_mask) 1057 { 1058 int err; 1059 1060 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent || 1061 !(ext_filter_mask & RTEXT_FILTER_VF)) 1062 return 0; 1063 1064 err = rtnl_port_self_fill(skb, dev); 1065 if (err) 1066 return err; 1067 1068 if (dev_num_vf(dev->dev.parent)) { 1069 err = rtnl_vf_ports_fill(skb, dev); 1070 if (err) 1071 return err; 1072 } 1073 1074 return 0; 1075 } 1076 1077 static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev) 1078 { 1079 int err; 1080 struct netdev_phys_item_id ppid; 1081 1082 err = dev_get_phys_port_id(dev, &ppid); 1083 if (err) { 1084 if (err == -EOPNOTSUPP) 1085 return 0; 1086 return err; 1087 } 1088 1089 if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id)) 1090 return -EMSGSIZE; 1091 1092 return 0; 1093 } 1094 1095 static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev) 1096 { 1097 char name[IFNAMSIZ]; 1098 int err; 1099 1100 err = dev_get_phys_port_name(dev, name, sizeof(name)); 1101 if (err) { 1102 if (err == -EOPNOTSUPP) 1103 return 0; 1104 return err; 1105 } 1106 1107 if (nla_put_string(skb, IFLA_PHYS_PORT_NAME, name)) 1108 return -EMSGSIZE; 1109 1110 return 0; 1111 } 1112 1113 static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev) 1114 { 1115 int err; 1116 struct switchdev_attr attr = { 1117 .orig_dev = dev, 1118 .id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID, 1119 .flags = SWITCHDEV_F_NO_RECURSE, 1120 }; 1121 1122 err = switchdev_port_attr_get(dev, &attr); 1123 if (err) { 1124 if (err == -EOPNOTSUPP) 1125 return 0; 1126 return err; 1127 } 1128 1129 if (nla_put(skb, IFLA_PHYS_SWITCH_ID, attr.u.ppid.id_len, 1130 attr.u.ppid.id)) 1131 return -EMSGSIZE; 1132 1133 return 0; 1134 } 1135 1136 static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb, 1137 struct net_device *dev) 1138 { 1139 struct rtnl_link_stats64 *sp; 1140 struct nlattr *attr; 1141 1142 attr = nla_reserve_64bit(skb, IFLA_STATS64, 1143 sizeof(struct rtnl_link_stats64), IFLA_PAD); 1144 if (!attr) 1145 return -EMSGSIZE; 1146 1147 sp = nla_data(attr); 1148 dev_get_stats(dev, sp); 1149 1150 attr = nla_reserve(skb, IFLA_STATS, 1151 sizeof(struct rtnl_link_stats)); 1152 if (!attr) 1153 return -EMSGSIZE; 1154 1155 copy_rtnl_link_stats(nla_data(attr), sp); 1156 1157 return 0; 1158 } 1159 1160 static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb, 1161 struct net_device *dev, 1162 int vfs_num, 1163 struct nlattr *vfinfo) 1164 { 1165 struct ifla_vf_rss_query_en vf_rss_query_en; 1166 struct nlattr *vf, *vfstats, *vfvlanlist; 1167 struct ifla_vf_link_state vf_linkstate; 1168 struct ifla_vf_vlan_info vf_vlan_info; 1169 struct ifla_vf_spoofchk vf_spoofchk; 1170 struct ifla_vf_tx_rate vf_tx_rate; 1171 struct ifla_vf_stats vf_stats; 1172 struct ifla_vf_trust vf_trust; 1173 struct ifla_vf_vlan vf_vlan; 1174 struct ifla_vf_rate vf_rate; 1175 struct ifla_vf_mac vf_mac; 1176 struct ifla_vf_info ivi; 1177 1178 memset(&ivi, 0, sizeof(ivi)); 1179 1180 /* Not all SR-IOV capable drivers support the 1181 * spoofcheck and "RSS query enable" query. Preset to 1182 * -1 so the user space tool can detect that the driver 1183 * didn't report anything. 1184 */ 1185 ivi.spoofchk = -1; 1186 ivi.rss_query_en = -1; 1187 ivi.trusted = -1; 1188 /* The default value for VF link state is "auto" 1189 * IFLA_VF_LINK_STATE_AUTO which equals zero 1190 */ 1191 ivi.linkstate = 0; 1192 /* VLAN Protocol by default is 802.1Q */ 1193 ivi.vlan_proto = htons(ETH_P_8021Q); 1194 if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi)) 1195 return 0; 1196 1197 memset(&vf_vlan_info, 0, sizeof(vf_vlan_info)); 1198 1199 vf_mac.vf = 1200 vf_vlan.vf = 1201 vf_vlan_info.vf = 1202 vf_rate.vf = 1203 vf_tx_rate.vf = 1204 vf_spoofchk.vf = 1205 vf_linkstate.vf = 1206 vf_rss_query_en.vf = 1207 vf_trust.vf = ivi.vf; 1208 1209 memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac)); 1210 vf_vlan.vlan = ivi.vlan; 1211 vf_vlan.qos = ivi.qos; 1212 vf_vlan_info.vlan = ivi.vlan; 1213 vf_vlan_info.qos = ivi.qos; 1214 vf_vlan_info.vlan_proto = ivi.vlan_proto; 1215 vf_tx_rate.rate = ivi.max_tx_rate; 1216 vf_rate.min_tx_rate = ivi.min_tx_rate; 1217 vf_rate.max_tx_rate = ivi.max_tx_rate; 1218 vf_spoofchk.setting = ivi.spoofchk; 1219 vf_linkstate.link_state = ivi.linkstate; 1220 vf_rss_query_en.setting = ivi.rss_query_en; 1221 vf_trust.setting = ivi.trusted; 1222 vf = nla_nest_start(skb, IFLA_VF_INFO); 1223 if (!vf) 1224 goto nla_put_vfinfo_failure; 1225 if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) || 1226 nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) || 1227 nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate), 1228 &vf_rate) || 1229 nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate), 1230 &vf_tx_rate) || 1231 nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk), 1232 &vf_spoofchk) || 1233 nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate), 1234 &vf_linkstate) || 1235 nla_put(skb, IFLA_VF_RSS_QUERY_EN, 1236 sizeof(vf_rss_query_en), 1237 &vf_rss_query_en) || 1238 nla_put(skb, IFLA_VF_TRUST, 1239 sizeof(vf_trust), &vf_trust)) 1240 goto nla_put_vf_failure; 1241 vfvlanlist = nla_nest_start(skb, IFLA_VF_VLAN_LIST); 1242 if (!vfvlanlist) 1243 goto nla_put_vf_failure; 1244 if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info), 1245 &vf_vlan_info)) { 1246 nla_nest_cancel(skb, vfvlanlist); 1247 goto nla_put_vf_failure; 1248 } 1249 nla_nest_end(skb, vfvlanlist); 1250 memset(&vf_stats, 0, sizeof(vf_stats)); 1251 if (dev->netdev_ops->ndo_get_vf_stats) 1252 dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num, 1253 &vf_stats); 1254 vfstats = nla_nest_start(skb, IFLA_VF_STATS); 1255 if (!vfstats) 1256 goto nla_put_vf_failure; 1257 if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, 1258 vf_stats.rx_packets, IFLA_VF_STATS_PAD) || 1259 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, 1260 vf_stats.tx_packets, IFLA_VF_STATS_PAD) || 1261 nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, 1262 vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || 1263 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, 1264 vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || 1265 nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, 1266 vf_stats.broadcast, IFLA_VF_STATS_PAD) || 1267 nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, 1268 vf_stats.multicast, IFLA_VF_STATS_PAD) || 1269 nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, 1270 vf_stats.rx_dropped, IFLA_VF_STATS_PAD) || 1271 nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED, 1272 vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) { 1273 nla_nest_cancel(skb, vfstats); 1274 goto nla_put_vf_failure; 1275 } 1276 nla_nest_end(skb, vfstats); 1277 nla_nest_end(skb, vf); 1278 return 0; 1279 1280 nla_put_vf_failure: 1281 nla_nest_cancel(skb, vf); 1282 nla_put_vfinfo_failure: 1283 nla_nest_cancel(skb, vfinfo); 1284 return -EMSGSIZE; 1285 } 1286 1287 static noinline_for_stack int rtnl_fill_vf(struct sk_buff *skb, 1288 struct net_device *dev, 1289 u32 ext_filter_mask) 1290 { 1291 struct nlattr *vfinfo; 1292 int i, num_vfs; 1293 1294 if (!dev->dev.parent || ((ext_filter_mask & RTEXT_FILTER_VF) == 0)) 1295 return 0; 1296 1297 num_vfs = dev_num_vf(dev->dev.parent); 1298 if (nla_put_u32(skb, IFLA_NUM_VF, num_vfs)) 1299 return -EMSGSIZE; 1300 1301 if (!dev->netdev_ops->ndo_get_vf_config) 1302 return 0; 1303 1304 vfinfo = nla_nest_start(skb, IFLA_VFINFO_LIST); 1305 if (!vfinfo) 1306 return -EMSGSIZE; 1307 1308 for (i = 0; i < num_vfs; i++) { 1309 if (rtnl_fill_vfinfo(skb, dev, i, vfinfo)) 1310 return -EMSGSIZE; 1311 } 1312 1313 nla_nest_end(skb, vfinfo); 1314 return 0; 1315 } 1316 1317 static int rtnl_fill_link_ifmap(struct sk_buff *skb, struct net_device *dev) 1318 { 1319 struct rtnl_link_ifmap map; 1320 1321 memset(&map, 0, sizeof(map)); 1322 map.mem_start = dev->mem_start; 1323 map.mem_end = dev->mem_end; 1324 map.base_addr = dev->base_addr; 1325 map.irq = dev->irq; 1326 map.dma = dev->dma; 1327 map.port = dev->if_port; 1328 1329 if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD)) 1330 return -EMSGSIZE; 1331 1332 return 0; 1333 } 1334 1335 static u8 rtnl_xdp_attached_mode(struct net_device *dev, u32 *prog_id) 1336 { 1337 const struct net_device_ops *ops = dev->netdev_ops; 1338 const struct bpf_prog *generic_xdp_prog; 1339 struct netdev_bpf xdp; 1340 1341 ASSERT_RTNL(); 1342 1343 *prog_id = 0; 1344 generic_xdp_prog = rtnl_dereference(dev->xdp_prog); 1345 if (generic_xdp_prog) { 1346 *prog_id = generic_xdp_prog->aux->id; 1347 return XDP_ATTACHED_SKB; 1348 } 1349 if (!ops->ndo_bpf) 1350 return XDP_ATTACHED_NONE; 1351 1352 __dev_xdp_query(dev, ops->ndo_bpf, &xdp); 1353 *prog_id = xdp.prog_id; 1354 1355 return xdp.prog_attached; 1356 } 1357 1358 static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev) 1359 { 1360 struct nlattr *xdp; 1361 u32 prog_id; 1362 int err; 1363 1364 xdp = nla_nest_start(skb, IFLA_XDP); 1365 if (!xdp) 1366 return -EMSGSIZE; 1367 1368 err = nla_put_u8(skb, IFLA_XDP_ATTACHED, 1369 rtnl_xdp_attached_mode(dev, &prog_id)); 1370 if (err) 1371 goto err_cancel; 1372 1373 if (prog_id) { 1374 err = nla_put_u32(skb, IFLA_XDP_PROG_ID, prog_id); 1375 if (err) 1376 goto err_cancel; 1377 } 1378 1379 nla_nest_end(skb, xdp); 1380 return 0; 1381 1382 err_cancel: 1383 nla_nest_cancel(skb, xdp); 1384 return err; 1385 } 1386 1387 static u32 rtnl_get_event(unsigned long event) 1388 { 1389 u32 rtnl_event_type = IFLA_EVENT_NONE; 1390 1391 switch (event) { 1392 case NETDEV_REBOOT: 1393 rtnl_event_type = IFLA_EVENT_REBOOT; 1394 break; 1395 case NETDEV_FEAT_CHANGE: 1396 rtnl_event_type = IFLA_EVENT_FEATURES; 1397 break; 1398 case NETDEV_BONDING_FAILOVER: 1399 rtnl_event_type = IFLA_EVENT_BONDING_FAILOVER; 1400 break; 1401 case NETDEV_NOTIFY_PEERS: 1402 rtnl_event_type = IFLA_EVENT_NOTIFY_PEERS; 1403 break; 1404 case NETDEV_RESEND_IGMP: 1405 rtnl_event_type = IFLA_EVENT_IGMP_RESEND; 1406 break; 1407 case NETDEV_CHANGEINFODATA: 1408 rtnl_event_type = IFLA_EVENT_BONDING_OPTIONS; 1409 break; 1410 default: 1411 break; 1412 } 1413 1414 return rtnl_event_type; 1415 } 1416 1417 static int put_master_ifindex(struct sk_buff *skb, struct net_device *dev) 1418 { 1419 const struct net_device *upper_dev; 1420 int ret = 0; 1421 1422 rcu_read_lock(); 1423 1424 upper_dev = netdev_master_upper_dev_get_rcu(dev); 1425 if (upper_dev) 1426 ret = nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex); 1427 1428 rcu_read_unlock(); 1429 return ret; 1430 } 1431 1432 static int nla_put_iflink(struct sk_buff *skb, const struct net_device *dev) 1433 { 1434 int ifindex = dev_get_iflink(dev); 1435 1436 if (dev->ifindex == ifindex) 1437 return 0; 1438 1439 return nla_put_u32(skb, IFLA_LINK, ifindex); 1440 } 1441 1442 static noinline_for_stack int nla_put_ifalias(struct sk_buff *skb, 1443 struct net_device *dev) 1444 { 1445 char buf[IFALIASZ]; 1446 int ret; 1447 1448 ret = dev_get_alias(dev, buf, sizeof(buf)); 1449 return ret > 0 ? nla_put_string(skb, IFLA_IFALIAS, buf) : 0; 1450 } 1451 1452 static int rtnl_fill_link_netnsid(struct sk_buff *skb, 1453 const struct net_device *dev, 1454 struct net *src_net) 1455 { 1456 if (dev->rtnl_link_ops && dev->rtnl_link_ops->get_link_net) { 1457 struct net *link_net = dev->rtnl_link_ops->get_link_net(dev); 1458 1459 if (!net_eq(dev_net(dev), link_net)) { 1460 int id = peernet2id_alloc(src_net, link_net); 1461 1462 if (nla_put_s32(skb, IFLA_LINK_NETNSID, id)) 1463 return -EMSGSIZE; 1464 } 1465 } 1466 1467 return 0; 1468 } 1469 1470 static int rtnl_fill_link_af(struct sk_buff *skb, 1471 const struct net_device *dev, 1472 u32 ext_filter_mask) 1473 { 1474 const struct rtnl_af_ops *af_ops; 1475 struct nlattr *af_spec; 1476 1477 af_spec = nla_nest_start(skb, IFLA_AF_SPEC); 1478 if (!af_spec) 1479 return -EMSGSIZE; 1480 1481 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { 1482 struct nlattr *af; 1483 int err; 1484 1485 if (!af_ops->fill_link_af) 1486 continue; 1487 1488 af = nla_nest_start(skb, af_ops->family); 1489 if (!af) 1490 return -EMSGSIZE; 1491 1492 err = af_ops->fill_link_af(skb, dev, ext_filter_mask); 1493 /* 1494 * Caller may return ENODATA to indicate that there 1495 * was no data to be dumped. This is not an error, it 1496 * means we should trim the attribute header and 1497 * continue. 1498 */ 1499 if (err == -ENODATA) 1500 nla_nest_cancel(skb, af); 1501 else if (err < 0) 1502 return -EMSGSIZE; 1503 1504 nla_nest_end(skb, af); 1505 } 1506 1507 nla_nest_end(skb, af_spec); 1508 return 0; 1509 } 1510 1511 static int rtnl_fill_ifinfo(struct sk_buff *skb, 1512 struct net_device *dev, struct net *src_net, 1513 int type, u32 pid, u32 seq, u32 change, 1514 unsigned int flags, u32 ext_filter_mask, 1515 u32 event, int *new_nsid, int new_ifindex, 1516 int tgt_netnsid) 1517 { 1518 struct ifinfomsg *ifm; 1519 struct nlmsghdr *nlh; 1520 1521 ASSERT_RTNL(); 1522 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags); 1523 if (nlh == NULL) 1524 return -EMSGSIZE; 1525 1526 ifm = nlmsg_data(nlh); 1527 ifm->ifi_family = AF_UNSPEC; 1528 ifm->__ifi_pad = 0; 1529 ifm->ifi_type = dev->type; 1530 ifm->ifi_index = dev->ifindex; 1531 ifm->ifi_flags = dev_get_flags(dev); 1532 ifm->ifi_change = change; 1533 1534 if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_IF_NETNSID, tgt_netnsid)) 1535 goto nla_put_failure; 1536 1537 if (nla_put_string(skb, IFLA_IFNAME, dev->name) || 1538 nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) || 1539 nla_put_u8(skb, IFLA_OPERSTATE, 1540 netif_running(dev) ? dev->operstate : IF_OPER_DOWN) || 1541 nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) || 1542 nla_put_u32(skb, IFLA_MTU, dev->mtu) || 1543 nla_put_u32(skb, IFLA_GROUP, dev->group) || 1544 nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) || 1545 nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) || 1546 nla_put_u32(skb, IFLA_GSO_MAX_SEGS, dev->gso_max_segs) || 1547 nla_put_u32(skb, IFLA_GSO_MAX_SIZE, dev->gso_max_size) || 1548 #ifdef CONFIG_RPS 1549 nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) || 1550 #endif 1551 nla_put_iflink(skb, dev) || 1552 put_master_ifindex(skb, dev) || 1553 nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) || 1554 (dev->qdisc && 1555 nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) || 1556 nla_put_ifalias(skb, dev) || 1557 nla_put_u32(skb, IFLA_CARRIER_CHANGES, 1558 atomic_read(&dev->carrier_up_count) + 1559 atomic_read(&dev->carrier_down_count)) || 1560 nla_put_u8(skb, IFLA_PROTO_DOWN, dev->proto_down) || 1561 nla_put_u32(skb, IFLA_CARRIER_UP_COUNT, 1562 atomic_read(&dev->carrier_up_count)) || 1563 nla_put_u32(skb, IFLA_CARRIER_DOWN_COUNT, 1564 atomic_read(&dev->carrier_down_count))) 1565 goto nla_put_failure; 1566 1567 if (event != IFLA_EVENT_NONE) { 1568 if (nla_put_u32(skb, IFLA_EVENT, event)) 1569 goto nla_put_failure; 1570 } 1571 1572 if (rtnl_fill_link_ifmap(skb, dev)) 1573 goto nla_put_failure; 1574 1575 if (dev->addr_len) { 1576 if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) || 1577 nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast)) 1578 goto nla_put_failure; 1579 } 1580 1581 if (rtnl_phys_port_id_fill(skb, dev)) 1582 goto nla_put_failure; 1583 1584 if (rtnl_phys_port_name_fill(skb, dev)) 1585 goto nla_put_failure; 1586 1587 if (rtnl_phys_switch_id_fill(skb, dev)) 1588 goto nla_put_failure; 1589 1590 if (rtnl_fill_stats(skb, dev)) 1591 goto nla_put_failure; 1592 1593 if (rtnl_fill_vf(skb, dev, ext_filter_mask)) 1594 goto nla_put_failure; 1595 1596 if (rtnl_port_fill(skb, dev, ext_filter_mask)) 1597 goto nla_put_failure; 1598 1599 if (rtnl_xdp_fill(skb, dev)) 1600 goto nla_put_failure; 1601 1602 if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) { 1603 if (rtnl_link_fill(skb, dev) < 0) 1604 goto nla_put_failure; 1605 } 1606 1607 if (rtnl_fill_link_netnsid(skb, dev, src_net)) 1608 goto nla_put_failure; 1609 1610 if (new_nsid && 1611 nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0) 1612 goto nla_put_failure; 1613 if (new_ifindex && 1614 nla_put_s32(skb, IFLA_NEW_IFINDEX, new_ifindex) < 0) 1615 goto nla_put_failure; 1616 1617 1618 rcu_read_lock(); 1619 if (rtnl_fill_link_af(skb, dev, ext_filter_mask)) 1620 goto nla_put_failure_rcu; 1621 rcu_read_unlock(); 1622 1623 nlmsg_end(skb, nlh); 1624 return 0; 1625 1626 nla_put_failure_rcu: 1627 rcu_read_unlock(); 1628 nla_put_failure: 1629 nlmsg_cancel(skb, nlh); 1630 return -EMSGSIZE; 1631 } 1632 1633 static const struct nla_policy ifla_policy[IFLA_MAX+1] = { 1634 [IFLA_IFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ-1 }, 1635 [IFLA_ADDRESS] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, 1636 [IFLA_BROADCAST] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, 1637 [IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) }, 1638 [IFLA_MTU] = { .type = NLA_U32 }, 1639 [IFLA_LINK] = { .type = NLA_U32 }, 1640 [IFLA_MASTER] = { .type = NLA_U32 }, 1641 [IFLA_CARRIER] = { .type = NLA_U8 }, 1642 [IFLA_TXQLEN] = { .type = NLA_U32 }, 1643 [IFLA_WEIGHT] = { .type = NLA_U32 }, 1644 [IFLA_OPERSTATE] = { .type = NLA_U8 }, 1645 [IFLA_LINKMODE] = { .type = NLA_U8 }, 1646 [IFLA_LINKINFO] = { .type = NLA_NESTED }, 1647 [IFLA_NET_NS_PID] = { .type = NLA_U32 }, 1648 [IFLA_NET_NS_FD] = { .type = NLA_U32 }, 1649 /* IFLA_IFALIAS is a string, but policy is set to NLA_BINARY to 1650 * allow 0-length string (needed to remove an alias). 1651 */ 1652 [IFLA_IFALIAS] = { .type = NLA_BINARY, .len = IFALIASZ - 1 }, 1653 [IFLA_VFINFO_LIST] = {. type = NLA_NESTED }, 1654 [IFLA_VF_PORTS] = { .type = NLA_NESTED }, 1655 [IFLA_PORT_SELF] = { .type = NLA_NESTED }, 1656 [IFLA_AF_SPEC] = { .type = NLA_NESTED }, 1657 [IFLA_EXT_MASK] = { .type = NLA_U32 }, 1658 [IFLA_PROMISCUITY] = { .type = NLA_U32 }, 1659 [IFLA_NUM_TX_QUEUES] = { .type = NLA_U32 }, 1660 [IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 }, 1661 [IFLA_GSO_MAX_SEGS] = { .type = NLA_U32 }, 1662 [IFLA_GSO_MAX_SIZE] = { .type = NLA_U32 }, 1663 [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN }, 1664 [IFLA_CARRIER_CHANGES] = { .type = NLA_U32 }, /* ignored */ 1665 [IFLA_PHYS_SWITCH_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN }, 1666 [IFLA_LINK_NETNSID] = { .type = NLA_S32 }, 1667 [IFLA_PROTO_DOWN] = { .type = NLA_U8 }, 1668 [IFLA_XDP] = { .type = NLA_NESTED }, 1669 [IFLA_EVENT] = { .type = NLA_U32 }, 1670 [IFLA_GROUP] = { .type = NLA_U32 }, 1671 [IFLA_IF_NETNSID] = { .type = NLA_S32 }, 1672 [IFLA_CARRIER_UP_COUNT] = { .type = NLA_U32 }, 1673 [IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 }, 1674 }; 1675 1676 static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = { 1677 [IFLA_INFO_KIND] = { .type = NLA_STRING }, 1678 [IFLA_INFO_DATA] = { .type = NLA_NESTED }, 1679 [IFLA_INFO_SLAVE_KIND] = { .type = NLA_STRING }, 1680 [IFLA_INFO_SLAVE_DATA] = { .type = NLA_NESTED }, 1681 }; 1682 1683 static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = { 1684 [IFLA_VF_MAC] = { .len = sizeof(struct ifla_vf_mac) }, 1685 [IFLA_VF_VLAN] = { .len = sizeof(struct ifla_vf_vlan) }, 1686 [IFLA_VF_VLAN_LIST] = { .type = NLA_NESTED }, 1687 [IFLA_VF_TX_RATE] = { .len = sizeof(struct ifla_vf_tx_rate) }, 1688 [IFLA_VF_SPOOFCHK] = { .len = sizeof(struct ifla_vf_spoofchk) }, 1689 [IFLA_VF_RATE] = { .len = sizeof(struct ifla_vf_rate) }, 1690 [IFLA_VF_LINK_STATE] = { .len = sizeof(struct ifla_vf_link_state) }, 1691 [IFLA_VF_RSS_QUERY_EN] = { .len = sizeof(struct ifla_vf_rss_query_en) }, 1692 [IFLA_VF_STATS] = { .type = NLA_NESTED }, 1693 [IFLA_VF_TRUST] = { .len = sizeof(struct ifla_vf_trust) }, 1694 [IFLA_VF_IB_NODE_GUID] = { .len = sizeof(struct ifla_vf_guid) }, 1695 [IFLA_VF_IB_PORT_GUID] = { .len = sizeof(struct ifla_vf_guid) }, 1696 }; 1697 1698 static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = { 1699 [IFLA_PORT_VF] = { .type = NLA_U32 }, 1700 [IFLA_PORT_PROFILE] = { .type = NLA_STRING, 1701 .len = PORT_PROFILE_MAX }, 1702 [IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY, 1703 .len = PORT_UUID_MAX }, 1704 [IFLA_PORT_HOST_UUID] = { .type = NLA_STRING, 1705 .len = PORT_UUID_MAX }, 1706 [IFLA_PORT_REQUEST] = { .type = NLA_U8, }, 1707 [IFLA_PORT_RESPONSE] = { .type = NLA_U16, }, 1708 1709 /* Unused, but we need to keep it here since user space could 1710 * fill it. It's also broken with regard to NLA_BINARY use in 1711 * combination with structs. 1712 */ 1713 [IFLA_PORT_VSI_TYPE] = { .type = NLA_BINARY, 1714 .len = sizeof(struct ifla_port_vsi) }, 1715 }; 1716 1717 static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = { 1718 [IFLA_XDP_FD] = { .type = NLA_S32 }, 1719 [IFLA_XDP_ATTACHED] = { .type = NLA_U8 }, 1720 [IFLA_XDP_FLAGS] = { .type = NLA_U32 }, 1721 [IFLA_XDP_PROG_ID] = { .type = NLA_U32 }, 1722 }; 1723 1724 static const struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla) 1725 { 1726 const struct rtnl_link_ops *ops = NULL; 1727 struct nlattr *linfo[IFLA_INFO_MAX + 1]; 1728 1729 if (nla_parse_nested(linfo, IFLA_INFO_MAX, nla, 1730 ifla_info_policy, NULL) < 0) 1731 return NULL; 1732 1733 if (linfo[IFLA_INFO_KIND]) { 1734 char kind[MODULE_NAME_LEN]; 1735 1736 nla_strlcpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind)); 1737 ops = rtnl_link_ops_get(kind); 1738 } 1739 1740 return ops; 1741 } 1742 1743 static bool link_master_filtered(struct net_device *dev, int master_idx) 1744 { 1745 struct net_device *master; 1746 1747 if (!master_idx) 1748 return false; 1749 1750 master = netdev_master_upper_dev_get(dev); 1751 if (!master || master->ifindex != master_idx) 1752 return true; 1753 1754 return false; 1755 } 1756 1757 static bool link_kind_filtered(const struct net_device *dev, 1758 const struct rtnl_link_ops *kind_ops) 1759 { 1760 if (kind_ops && dev->rtnl_link_ops != kind_ops) 1761 return true; 1762 1763 return false; 1764 } 1765 1766 static bool link_dump_filtered(struct net_device *dev, 1767 int master_idx, 1768 const struct rtnl_link_ops *kind_ops) 1769 { 1770 if (link_master_filtered(dev, master_idx) || 1771 link_kind_filtered(dev, kind_ops)) 1772 return true; 1773 1774 return false; 1775 } 1776 1777 static struct net *get_target_net(struct sock *sk, int netnsid) 1778 { 1779 struct net *net; 1780 1781 net = get_net_ns_by_id(sock_net(sk), netnsid); 1782 if (!net) 1783 return ERR_PTR(-EINVAL); 1784 1785 /* For now, the caller is required to have CAP_NET_ADMIN in 1786 * the user namespace owning the target net ns. 1787 */ 1788 if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) { 1789 put_net(net); 1790 return ERR_PTR(-EACCES); 1791 } 1792 return net; 1793 } 1794 1795 static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) 1796 { 1797 struct net *net = sock_net(skb->sk); 1798 struct net *tgt_net = net; 1799 int h, s_h; 1800 int idx = 0, s_idx; 1801 struct net_device *dev; 1802 struct hlist_head *head; 1803 struct nlattr *tb[IFLA_MAX+1]; 1804 u32 ext_filter_mask = 0; 1805 const struct rtnl_link_ops *kind_ops = NULL; 1806 unsigned int flags = NLM_F_MULTI; 1807 int master_idx = 0; 1808 int netnsid = -1; 1809 int err; 1810 int hdrlen; 1811 1812 s_h = cb->args[0]; 1813 s_idx = cb->args[1]; 1814 1815 /* A hack to preserve kernel<->userspace interface. 1816 * The correct header is ifinfomsg. It is consistent with rtnl_getlink. 1817 * However, before Linux v3.9 the code here assumed rtgenmsg and that's 1818 * what iproute2 < v3.9.0 used. 1819 * We can detect the old iproute2. Even including the IFLA_EXT_MASK 1820 * attribute, its netlink message is shorter than struct ifinfomsg. 1821 */ 1822 hdrlen = nlmsg_len(cb->nlh) < sizeof(struct ifinfomsg) ? 1823 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg); 1824 1825 if (nlmsg_parse(cb->nlh, hdrlen, tb, IFLA_MAX, 1826 ifla_policy, NULL) >= 0) { 1827 if (tb[IFLA_IF_NETNSID]) { 1828 netnsid = nla_get_s32(tb[IFLA_IF_NETNSID]); 1829 tgt_net = get_target_net(skb->sk, netnsid); 1830 if (IS_ERR(tgt_net)) { 1831 tgt_net = net; 1832 netnsid = -1; 1833 } 1834 } 1835 1836 if (tb[IFLA_EXT_MASK]) 1837 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]); 1838 1839 if (tb[IFLA_MASTER]) 1840 master_idx = nla_get_u32(tb[IFLA_MASTER]); 1841 1842 if (tb[IFLA_LINKINFO]) 1843 kind_ops = linkinfo_to_kind_ops(tb[IFLA_LINKINFO]); 1844 1845 if (master_idx || kind_ops) 1846 flags |= NLM_F_DUMP_FILTERED; 1847 } 1848 1849 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 1850 idx = 0; 1851 head = &tgt_net->dev_index_head[h]; 1852 hlist_for_each_entry(dev, head, index_hlist) { 1853 if (link_dump_filtered(dev, master_idx, kind_ops)) 1854 goto cont; 1855 if (idx < s_idx) 1856 goto cont; 1857 err = rtnl_fill_ifinfo(skb, dev, net, 1858 RTM_NEWLINK, 1859 NETLINK_CB(cb->skb).portid, 1860 cb->nlh->nlmsg_seq, 0, 1861 flags, 1862 ext_filter_mask, 0, NULL, 0, 1863 netnsid); 1864 1865 if (err < 0) { 1866 if (likely(skb->len)) 1867 goto out; 1868 1869 goto out_err; 1870 } 1871 cont: 1872 idx++; 1873 } 1874 } 1875 out: 1876 err = skb->len; 1877 out_err: 1878 cb->args[1] = idx; 1879 cb->args[0] = h; 1880 cb->seq = net->dev_base_seq; 1881 nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 1882 if (netnsid >= 0) 1883 put_net(tgt_net); 1884 1885 return err; 1886 } 1887 1888 int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len, 1889 struct netlink_ext_ack *exterr) 1890 { 1891 return nla_parse(tb, IFLA_MAX, head, len, ifla_policy, exterr); 1892 } 1893 EXPORT_SYMBOL(rtnl_nla_parse_ifla); 1894 1895 struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[]) 1896 { 1897 struct net *net; 1898 /* Examine the link attributes and figure out which 1899 * network namespace we are talking about. 1900 */ 1901 if (tb[IFLA_NET_NS_PID]) 1902 net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID])); 1903 else if (tb[IFLA_NET_NS_FD]) 1904 net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD])); 1905 else 1906 net = get_net(src_net); 1907 return net; 1908 } 1909 EXPORT_SYMBOL(rtnl_link_get_net); 1910 1911 /* Figure out which network namespace we are talking about by 1912 * examining the link attributes in the following order: 1913 * 1914 * 1. IFLA_NET_NS_PID 1915 * 2. IFLA_NET_NS_FD 1916 * 3. IFLA_IF_NETNSID 1917 */ 1918 static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net, 1919 struct nlattr *tb[]) 1920 { 1921 struct net *net; 1922 1923 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]) 1924 return rtnl_link_get_net(src_net, tb); 1925 1926 if (!tb[IFLA_IF_NETNSID]) 1927 return get_net(src_net); 1928 1929 net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_IF_NETNSID])); 1930 if (!net) 1931 return ERR_PTR(-EINVAL); 1932 1933 return net; 1934 } 1935 1936 static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb, 1937 struct net *src_net, 1938 struct nlattr *tb[], int cap) 1939 { 1940 struct net *net; 1941 1942 net = rtnl_link_get_net_by_nlattr(src_net, tb); 1943 if (IS_ERR(net)) 1944 return net; 1945 1946 if (!netlink_ns_capable(skb, net->user_ns, cap)) { 1947 put_net(net); 1948 return ERR_PTR(-EPERM); 1949 } 1950 1951 return net; 1952 } 1953 1954 static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[]) 1955 { 1956 if (dev) { 1957 if (tb[IFLA_ADDRESS] && 1958 nla_len(tb[IFLA_ADDRESS]) < dev->addr_len) 1959 return -EINVAL; 1960 1961 if (tb[IFLA_BROADCAST] && 1962 nla_len(tb[IFLA_BROADCAST]) < dev->addr_len) 1963 return -EINVAL; 1964 } 1965 1966 if (tb[IFLA_AF_SPEC]) { 1967 struct nlattr *af; 1968 int rem, err; 1969 1970 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) { 1971 const struct rtnl_af_ops *af_ops; 1972 1973 rcu_read_lock(); 1974 af_ops = rtnl_af_lookup(nla_type(af)); 1975 if (!af_ops) { 1976 rcu_read_unlock(); 1977 return -EAFNOSUPPORT; 1978 } 1979 1980 if (!af_ops->set_link_af) { 1981 rcu_read_unlock(); 1982 return -EOPNOTSUPP; 1983 } 1984 1985 if (af_ops->validate_link_af) { 1986 err = af_ops->validate_link_af(dev, af); 1987 if (err < 0) { 1988 rcu_read_unlock(); 1989 return err; 1990 } 1991 } 1992 1993 rcu_read_unlock(); 1994 } 1995 } 1996 1997 return 0; 1998 } 1999 2000 static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt, 2001 int guid_type) 2002 { 2003 const struct net_device_ops *ops = dev->netdev_ops; 2004 2005 return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type); 2006 } 2007 2008 static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type) 2009 { 2010 if (dev->type != ARPHRD_INFINIBAND) 2011 return -EOPNOTSUPP; 2012 2013 return handle_infiniband_guid(dev, ivt, guid_type); 2014 } 2015 2016 static int do_setvfinfo(struct net_device *dev, struct nlattr **tb) 2017 { 2018 const struct net_device_ops *ops = dev->netdev_ops; 2019 int err = -EINVAL; 2020 2021 if (tb[IFLA_VF_MAC]) { 2022 struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]); 2023 2024 err = -EOPNOTSUPP; 2025 if (ops->ndo_set_vf_mac) 2026 err = ops->ndo_set_vf_mac(dev, ivm->vf, 2027 ivm->mac); 2028 if (err < 0) 2029 return err; 2030 } 2031 2032 if (tb[IFLA_VF_VLAN]) { 2033 struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]); 2034 2035 err = -EOPNOTSUPP; 2036 if (ops->ndo_set_vf_vlan) 2037 err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan, 2038 ivv->qos, 2039 htons(ETH_P_8021Q)); 2040 if (err < 0) 2041 return err; 2042 } 2043 2044 if (tb[IFLA_VF_VLAN_LIST]) { 2045 struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN]; 2046 struct nlattr *attr; 2047 int rem, len = 0; 2048 2049 err = -EOPNOTSUPP; 2050 if (!ops->ndo_set_vf_vlan) 2051 return err; 2052 2053 nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) { 2054 if (nla_type(attr) != IFLA_VF_VLAN_INFO || 2055 nla_len(attr) < NLA_HDRLEN) { 2056 return -EINVAL; 2057 } 2058 if (len >= MAX_VLAN_LIST_LEN) 2059 return -EOPNOTSUPP; 2060 ivvl[len] = nla_data(attr); 2061 2062 len++; 2063 } 2064 if (len == 0) 2065 return -EINVAL; 2066 2067 err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan, 2068 ivvl[0]->qos, ivvl[0]->vlan_proto); 2069 if (err < 0) 2070 return err; 2071 } 2072 2073 if (tb[IFLA_VF_TX_RATE]) { 2074 struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]); 2075 struct ifla_vf_info ivf; 2076 2077 err = -EOPNOTSUPP; 2078 if (ops->ndo_get_vf_config) 2079 err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf); 2080 if (err < 0) 2081 return err; 2082 2083 err = -EOPNOTSUPP; 2084 if (ops->ndo_set_vf_rate) 2085 err = ops->ndo_set_vf_rate(dev, ivt->vf, 2086 ivf.min_tx_rate, 2087 ivt->rate); 2088 if (err < 0) 2089 return err; 2090 } 2091 2092 if (tb[IFLA_VF_RATE]) { 2093 struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]); 2094 2095 err = -EOPNOTSUPP; 2096 if (ops->ndo_set_vf_rate) 2097 err = ops->ndo_set_vf_rate(dev, ivt->vf, 2098 ivt->min_tx_rate, 2099 ivt->max_tx_rate); 2100 if (err < 0) 2101 return err; 2102 } 2103 2104 if (tb[IFLA_VF_SPOOFCHK]) { 2105 struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]); 2106 2107 err = -EOPNOTSUPP; 2108 if (ops->ndo_set_vf_spoofchk) 2109 err = ops->ndo_set_vf_spoofchk(dev, ivs->vf, 2110 ivs->setting); 2111 if (err < 0) 2112 return err; 2113 } 2114 2115 if (tb[IFLA_VF_LINK_STATE]) { 2116 struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]); 2117 2118 err = -EOPNOTSUPP; 2119 if (ops->ndo_set_vf_link_state) 2120 err = ops->ndo_set_vf_link_state(dev, ivl->vf, 2121 ivl->link_state); 2122 if (err < 0) 2123 return err; 2124 } 2125 2126 if (tb[IFLA_VF_RSS_QUERY_EN]) { 2127 struct ifla_vf_rss_query_en *ivrssq_en; 2128 2129 err = -EOPNOTSUPP; 2130 ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]); 2131 if (ops->ndo_set_vf_rss_query_en) 2132 err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf, 2133 ivrssq_en->setting); 2134 if (err < 0) 2135 return err; 2136 } 2137 2138 if (tb[IFLA_VF_TRUST]) { 2139 struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]); 2140 2141 err = -EOPNOTSUPP; 2142 if (ops->ndo_set_vf_trust) 2143 err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting); 2144 if (err < 0) 2145 return err; 2146 } 2147 2148 if (tb[IFLA_VF_IB_NODE_GUID]) { 2149 struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]); 2150 2151 if (!ops->ndo_set_vf_guid) 2152 return -EOPNOTSUPP; 2153 2154 return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID); 2155 } 2156 2157 if (tb[IFLA_VF_IB_PORT_GUID]) { 2158 struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]); 2159 2160 if (!ops->ndo_set_vf_guid) 2161 return -EOPNOTSUPP; 2162 2163 return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID); 2164 } 2165 2166 return err; 2167 } 2168 2169 static int do_set_master(struct net_device *dev, int ifindex, 2170 struct netlink_ext_ack *extack) 2171 { 2172 struct net_device *upper_dev = netdev_master_upper_dev_get(dev); 2173 const struct net_device_ops *ops; 2174 int err; 2175 2176 if (upper_dev) { 2177 if (upper_dev->ifindex == ifindex) 2178 return 0; 2179 ops = upper_dev->netdev_ops; 2180 if (ops->ndo_del_slave) { 2181 err = ops->ndo_del_slave(upper_dev, dev); 2182 if (err) 2183 return err; 2184 } else { 2185 return -EOPNOTSUPP; 2186 } 2187 } 2188 2189 if (ifindex) { 2190 upper_dev = __dev_get_by_index(dev_net(dev), ifindex); 2191 if (!upper_dev) 2192 return -EINVAL; 2193 ops = upper_dev->netdev_ops; 2194 if (ops->ndo_add_slave) { 2195 err = ops->ndo_add_slave(upper_dev, dev, extack); 2196 if (err) 2197 return err; 2198 } else { 2199 return -EOPNOTSUPP; 2200 } 2201 } 2202 return 0; 2203 } 2204 2205 #define DO_SETLINK_MODIFIED 0x01 2206 /* notify flag means notify + modified. */ 2207 #define DO_SETLINK_NOTIFY 0x03 2208 static int do_setlink(const struct sk_buff *skb, 2209 struct net_device *dev, struct ifinfomsg *ifm, 2210 struct netlink_ext_ack *extack, 2211 struct nlattr **tb, char *ifname, int status) 2212 { 2213 const struct net_device_ops *ops = dev->netdev_ops; 2214 int err; 2215 2216 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_IF_NETNSID]) { 2217 struct net *net = rtnl_link_get_net_capable(skb, dev_net(dev), 2218 tb, CAP_NET_ADMIN); 2219 if (IS_ERR(net)) { 2220 err = PTR_ERR(net); 2221 goto errout; 2222 } 2223 2224 err = dev_change_net_namespace(dev, net, ifname); 2225 put_net(net); 2226 if (err) 2227 goto errout; 2228 status |= DO_SETLINK_MODIFIED; 2229 } 2230 2231 if (tb[IFLA_MAP]) { 2232 struct rtnl_link_ifmap *u_map; 2233 struct ifmap k_map; 2234 2235 if (!ops->ndo_set_config) { 2236 err = -EOPNOTSUPP; 2237 goto errout; 2238 } 2239 2240 if (!netif_device_present(dev)) { 2241 err = -ENODEV; 2242 goto errout; 2243 } 2244 2245 u_map = nla_data(tb[IFLA_MAP]); 2246 k_map.mem_start = (unsigned long) u_map->mem_start; 2247 k_map.mem_end = (unsigned long) u_map->mem_end; 2248 k_map.base_addr = (unsigned short) u_map->base_addr; 2249 k_map.irq = (unsigned char) u_map->irq; 2250 k_map.dma = (unsigned char) u_map->dma; 2251 k_map.port = (unsigned char) u_map->port; 2252 2253 err = ops->ndo_set_config(dev, &k_map); 2254 if (err < 0) 2255 goto errout; 2256 2257 status |= DO_SETLINK_NOTIFY; 2258 } 2259 2260 if (tb[IFLA_ADDRESS]) { 2261 struct sockaddr *sa; 2262 int len; 2263 2264 len = sizeof(sa_family_t) + max_t(size_t, dev->addr_len, 2265 sizeof(*sa)); 2266 sa = kmalloc(len, GFP_KERNEL); 2267 if (!sa) { 2268 err = -ENOMEM; 2269 goto errout; 2270 } 2271 sa->sa_family = dev->type; 2272 memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]), 2273 dev->addr_len); 2274 err = dev_set_mac_address(dev, sa); 2275 kfree(sa); 2276 if (err) 2277 goto errout; 2278 status |= DO_SETLINK_MODIFIED; 2279 } 2280 2281 if (tb[IFLA_MTU]) { 2282 err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU])); 2283 if (err < 0) 2284 goto errout; 2285 status |= DO_SETLINK_MODIFIED; 2286 } 2287 2288 if (tb[IFLA_GROUP]) { 2289 dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP])); 2290 status |= DO_SETLINK_NOTIFY; 2291 } 2292 2293 /* 2294 * Interface selected by interface index but interface 2295 * name provided implies that a name change has been 2296 * requested. 2297 */ 2298 if (ifm->ifi_index > 0 && ifname[0]) { 2299 err = dev_change_name(dev, ifname); 2300 if (err < 0) 2301 goto errout; 2302 status |= DO_SETLINK_MODIFIED; 2303 } 2304 2305 if (tb[IFLA_IFALIAS]) { 2306 err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]), 2307 nla_len(tb[IFLA_IFALIAS])); 2308 if (err < 0) 2309 goto errout; 2310 status |= DO_SETLINK_NOTIFY; 2311 } 2312 2313 if (tb[IFLA_BROADCAST]) { 2314 nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len); 2315 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); 2316 } 2317 2318 if (ifm->ifi_flags || ifm->ifi_change) { 2319 err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm)); 2320 if (err < 0) 2321 goto errout; 2322 } 2323 2324 if (tb[IFLA_MASTER]) { 2325 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack); 2326 if (err) 2327 goto errout; 2328 status |= DO_SETLINK_MODIFIED; 2329 } 2330 2331 if (tb[IFLA_CARRIER]) { 2332 err = dev_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER])); 2333 if (err) 2334 goto errout; 2335 status |= DO_SETLINK_MODIFIED; 2336 } 2337 2338 if (tb[IFLA_TXQLEN]) { 2339 unsigned int value = nla_get_u32(tb[IFLA_TXQLEN]); 2340 2341 err = dev_change_tx_queue_len(dev, value); 2342 if (err) 2343 goto errout; 2344 status |= DO_SETLINK_MODIFIED; 2345 } 2346 2347 if (tb[IFLA_GSO_MAX_SIZE]) { 2348 u32 max_size = nla_get_u32(tb[IFLA_GSO_MAX_SIZE]); 2349 2350 if (max_size > GSO_MAX_SIZE) { 2351 err = -EINVAL; 2352 goto errout; 2353 } 2354 2355 if (dev->gso_max_size ^ max_size) { 2356 netif_set_gso_max_size(dev, max_size); 2357 status |= DO_SETLINK_MODIFIED; 2358 } 2359 } 2360 2361 if (tb[IFLA_GSO_MAX_SEGS]) { 2362 u32 max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]); 2363 2364 if (max_segs > GSO_MAX_SEGS) { 2365 err = -EINVAL; 2366 goto errout; 2367 } 2368 2369 if (dev->gso_max_segs ^ max_segs) { 2370 dev->gso_max_segs = max_segs; 2371 status |= DO_SETLINK_MODIFIED; 2372 } 2373 } 2374 2375 if (tb[IFLA_OPERSTATE]) 2376 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE])); 2377 2378 if (tb[IFLA_LINKMODE]) { 2379 unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]); 2380 2381 write_lock_bh(&dev_base_lock); 2382 if (dev->link_mode ^ value) 2383 status |= DO_SETLINK_NOTIFY; 2384 dev->link_mode = value; 2385 write_unlock_bh(&dev_base_lock); 2386 } 2387 2388 if (tb[IFLA_VFINFO_LIST]) { 2389 struct nlattr *vfinfo[IFLA_VF_MAX + 1]; 2390 struct nlattr *attr; 2391 int rem; 2392 2393 nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) { 2394 if (nla_type(attr) != IFLA_VF_INFO || 2395 nla_len(attr) < NLA_HDRLEN) { 2396 err = -EINVAL; 2397 goto errout; 2398 } 2399 err = nla_parse_nested(vfinfo, IFLA_VF_MAX, attr, 2400 ifla_vf_policy, NULL); 2401 if (err < 0) 2402 goto errout; 2403 err = do_setvfinfo(dev, vfinfo); 2404 if (err < 0) 2405 goto errout; 2406 status |= DO_SETLINK_NOTIFY; 2407 } 2408 } 2409 err = 0; 2410 2411 if (tb[IFLA_VF_PORTS]) { 2412 struct nlattr *port[IFLA_PORT_MAX+1]; 2413 struct nlattr *attr; 2414 int vf; 2415 int rem; 2416 2417 err = -EOPNOTSUPP; 2418 if (!ops->ndo_set_vf_port) 2419 goto errout; 2420 2421 nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) { 2422 if (nla_type(attr) != IFLA_VF_PORT || 2423 nla_len(attr) < NLA_HDRLEN) { 2424 err = -EINVAL; 2425 goto errout; 2426 } 2427 err = nla_parse_nested(port, IFLA_PORT_MAX, attr, 2428 ifla_port_policy, NULL); 2429 if (err < 0) 2430 goto errout; 2431 if (!port[IFLA_PORT_VF]) { 2432 err = -EOPNOTSUPP; 2433 goto errout; 2434 } 2435 vf = nla_get_u32(port[IFLA_PORT_VF]); 2436 err = ops->ndo_set_vf_port(dev, vf, port); 2437 if (err < 0) 2438 goto errout; 2439 status |= DO_SETLINK_NOTIFY; 2440 } 2441 } 2442 err = 0; 2443 2444 if (tb[IFLA_PORT_SELF]) { 2445 struct nlattr *port[IFLA_PORT_MAX+1]; 2446 2447 err = nla_parse_nested(port, IFLA_PORT_MAX, 2448 tb[IFLA_PORT_SELF], ifla_port_policy, 2449 NULL); 2450 if (err < 0) 2451 goto errout; 2452 2453 err = -EOPNOTSUPP; 2454 if (ops->ndo_set_vf_port) 2455 err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port); 2456 if (err < 0) 2457 goto errout; 2458 status |= DO_SETLINK_NOTIFY; 2459 } 2460 2461 if (tb[IFLA_AF_SPEC]) { 2462 struct nlattr *af; 2463 int rem; 2464 2465 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) { 2466 const struct rtnl_af_ops *af_ops; 2467 2468 rcu_read_lock(); 2469 2470 BUG_ON(!(af_ops = rtnl_af_lookup(nla_type(af)))); 2471 2472 err = af_ops->set_link_af(dev, af); 2473 if (err < 0) { 2474 rcu_read_unlock(); 2475 goto errout; 2476 } 2477 2478 rcu_read_unlock(); 2479 status |= DO_SETLINK_NOTIFY; 2480 } 2481 } 2482 err = 0; 2483 2484 if (tb[IFLA_PROTO_DOWN]) { 2485 err = dev_change_proto_down(dev, 2486 nla_get_u8(tb[IFLA_PROTO_DOWN])); 2487 if (err) 2488 goto errout; 2489 status |= DO_SETLINK_NOTIFY; 2490 } 2491 2492 if (tb[IFLA_XDP]) { 2493 struct nlattr *xdp[IFLA_XDP_MAX + 1]; 2494 u32 xdp_flags = 0; 2495 2496 err = nla_parse_nested(xdp, IFLA_XDP_MAX, tb[IFLA_XDP], 2497 ifla_xdp_policy, NULL); 2498 if (err < 0) 2499 goto errout; 2500 2501 if (xdp[IFLA_XDP_ATTACHED] || xdp[IFLA_XDP_PROG_ID]) { 2502 err = -EINVAL; 2503 goto errout; 2504 } 2505 2506 if (xdp[IFLA_XDP_FLAGS]) { 2507 xdp_flags = nla_get_u32(xdp[IFLA_XDP_FLAGS]); 2508 if (xdp_flags & ~XDP_FLAGS_MASK) { 2509 err = -EINVAL; 2510 goto errout; 2511 } 2512 if (hweight32(xdp_flags & XDP_FLAGS_MODES) > 1) { 2513 err = -EINVAL; 2514 goto errout; 2515 } 2516 } 2517 2518 if (xdp[IFLA_XDP_FD]) { 2519 err = dev_change_xdp_fd(dev, extack, 2520 nla_get_s32(xdp[IFLA_XDP_FD]), 2521 xdp_flags); 2522 if (err) 2523 goto errout; 2524 status |= DO_SETLINK_NOTIFY; 2525 } 2526 } 2527 2528 errout: 2529 if (status & DO_SETLINK_MODIFIED) { 2530 if ((status & DO_SETLINK_NOTIFY) == DO_SETLINK_NOTIFY) 2531 netdev_state_change(dev); 2532 2533 if (err < 0) 2534 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", 2535 dev->name); 2536 } 2537 2538 return err; 2539 } 2540 2541 static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, 2542 struct netlink_ext_ack *extack) 2543 { 2544 struct net *net = sock_net(skb->sk); 2545 struct ifinfomsg *ifm; 2546 struct net_device *dev; 2547 int err; 2548 struct nlattr *tb[IFLA_MAX+1]; 2549 char ifname[IFNAMSIZ]; 2550 2551 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, 2552 extack); 2553 if (err < 0) 2554 goto errout; 2555 2556 if (tb[IFLA_IFNAME]) 2557 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 2558 else 2559 ifname[0] = '\0'; 2560 2561 err = -EINVAL; 2562 ifm = nlmsg_data(nlh); 2563 if (ifm->ifi_index > 0) 2564 dev = __dev_get_by_index(net, ifm->ifi_index); 2565 else if (tb[IFLA_IFNAME]) 2566 dev = __dev_get_by_name(net, ifname); 2567 else 2568 goto errout; 2569 2570 if (dev == NULL) { 2571 err = -ENODEV; 2572 goto errout; 2573 } 2574 2575 err = validate_linkmsg(dev, tb); 2576 if (err < 0) 2577 goto errout; 2578 2579 err = do_setlink(skb, dev, ifm, extack, tb, ifname, 0); 2580 errout: 2581 return err; 2582 } 2583 2584 static int rtnl_group_dellink(const struct net *net, int group) 2585 { 2586 struct net_device *dev, *aux; 2587 LIST_HEAD(list_kill); 2588 bool found = false; 2589 2590 if (!group) 2591 return -EPERM; 2592 2593 for_each_netdev(net, dev) { 2594 if (dev->group == group) { 2595 const struct rtnl_link_ops *ops; 2596 2597 found = true; 2598 ops = dev->rtnl_link_ops; 2599 if (!ops || !ops->dellink) 2600 return -EOPNOTSUPP; 2601 } 2602 } 2603 2604 if (!found) 2605 return -ENODEV; 2606 2607 for_each_netdev_safe(net, dev, aux) { 2608 if (dev->group == group) { 2609 const struct rtnl_link_ops *ops; 2610 2611 ops = dev->rtnl_link_ops; 2612 ops->dellink(dev, &list_kill); 2613 } 2614 } 2615 unregister_netdevice_many(&list_kill); 2616 2617 return 0; 2618 } 2619 2620 int rtnl_delete_link(struct net_device *dev) 2621 { 2622 const struct rtnl_link_ops *ops; 2623 LIST_HEAD(list_kill); 2624 2625 ops = dev->rtnl_link_ops; 2626 if (!ops || !ops->dellink) 2627 return -EOPNOTSUPP; 2628 2629 ops->dellink(dev, &list_kill); 2630 unregister_netdevice_many(&list_kill); 2631 2632 return 0; 2633 } 2634 EXPORT_SYMBOL_GPL(rtnl_delete_link); 2635 2636 static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, 2637 struct netlink_ext_ack *extack) 2638 { 2639 struct net *net = sock_net(skb->sk); 2640 struct net *tgt_net = net; 2641 struct net_device *dev = NULL; 2642 struct ifinfomsg *ifm; 2643 char ifname[IFNAMSIZ]; 2644 struct nlattr *tb[IFLA_MAX+1]; 2645 int err; 2646 int netnsid = -1; 2647 2648 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack); 2649 if (err < 0) 2650 return err; 2651 2652 if (tb[IFLA_IFNAME]) 2653 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 2654 2655 if (tb[IFLA_IF_NETNSID]) { 2656 netnsid = nla_get_s32(tb[IFLA_IF_NETNSID]); 2657 tgt_net = get_target_net(NETLINK_CB(skb).sk, netnsid); 2658 if (IS_ERR(tgt_net)) 2659 return PTR_ERR(tgt_net); 2660 } 2661 2662 err = -EINVAL; 2663 ifm = nlmsg_data(nlh); 2664 if (ifm->ifi_index > 0) 2665 dev = __dev_get_by_index(tgt_net, ifm->ifi_index); 2666 else if (tb[IFLA_IFNAME]) 2667 dev = __dev_get_by_name(tgt_net, ifname); 2668 else if (tb[IFLA_GROUP]) 2669 err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP])); 2670 else 2671 goto out; 2672 2673 if (!dev) { 2674 if (tb[IFLA_IFNAME] || ifm->ifi_index > 0) 2675 err = -ENODEV; 2676 2677 goto out; 2678 } 2679 2680 err = rtnl_delete_link(dev); 2681 2682 out: 2683 if (netnsid >= 0) 2684 put_net(tgt_net); 2685 2686 return err; 2687 } 2688 2689 int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm) 2690 { 2691 unsigned int old_flags; 2692 int err; 2693 2694 old_flags = dev->flags; 2695 if (ifm && (ifm->ifi_flags || ifm->ifi_change)) { 2696 err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm)); 2697 if (err < 0) 2698 return err; 2699 } 2700 2701 dev->rtnl_link_state = RTNL_LINK_INITIALIZED; 2702 2703 __dev_notify_flags(dev, old_flags, ~0U); 2704 return 0; 2705 } 2706 EXPORT_SYMBOL(rtnl_configure_link); 2707 2708 struct net_device *rtnl_create_link(struct net *net, 2709 const char *ifname, unsigned char name_assign_type, 2710 const struct rtnl_link_ops *ops, struct nlattr *tb[]) 2711 { 2712 struct net_device *dev; 2713 unsigned int num_tx_queues = 1; 2714 unsigned int num_rx_queues = 1; 2715 2716 if (tb[IFLA_NUM_TX_QUEUES]) 2717 num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]); 2718 else if (ops->get_num_tx_queues) 2719 num_tx_queues = ops->get_num_tx_queues(); 2720 2721 if (tb[IFLA_NUM_RX_QUEUES]) 2722 num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]); 2723 else if (ops->get_num_rx_queues) 2724 num_rx_queues = ops->get_num_rx_queues(); 2725 2726 dev = alloc_netdev_mqs(ops->priv_size, ifname, name_assign_type, 2727 ops->setup, num_tx_queues, num_rx_queues); 2728 if (!dev) 2729 return ERR_PTR(-ENOMEM); 2730 2731 dev_net_set(dev, net); 2732 dev->rtnl_link_ops = ops; 2733 dev->rtnl_link_state = RTNL_LINK_INITIALIZING; 2734 2735 if (tb[IFLA_MTU]) 2736 dev->mtu = nla_get_u32(tb[IFLA_MTU]); 2737 if (tb[IFLA_ADDRESS]) { 2738 memcpy(dev->dev_addr, nla_data(tb[IFLA_ADDRESS]), 2739 nla_len(tb[IFLA_ADDRESS])); 2740 dev->addr_assign_type = NET_ADDR_SET; 2741 } 2742 if (tb[IFLA_BROADCAST]) 2743 memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]), 2744 nla_len(tb[IFLA_BROADCAST])); 2745 if (tb[IFLA_TXQLEN]) 2746 dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]); 2747 if (tb[IFLA_OPERSTATE]) 2748 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE])); 2749 if (tb[IFLA_LINKMODE]) 2750 dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]); 2751 if (tb[IFLA_GROUP]) 2752 dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP])); 2753 if (tb[IFLA_GSO_MAX_SIZE]) 2754 netif_set_gso_max_size(dev, nla_get_u32(tb[IFLA_GSO_MAX_SIZE])); 2755 if (tb[IFLA_GSO_MAX_SEGS]) 2756 dev->gso_max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]); 2757 2758 return dev; 2759 } 2760 EXPORT_SYMBOL(rtnl_create_link); 2761 2762 static int rtnl_group_changelink(const struct sk_buff *skb, 2763 struct net *net, int group, 2764 struct ifinfomsg *ifm, 2765 struct netlink_ext_ack *extack, 2766 struct nlattr **tb) 2767 { 2768 struct net_device *dev, *aux; 2769 int err; 2770 2771 for_each_netdev_safe(net, dev, aux) { 2772 if (dev->group == group) { 2773 err = do_setlink(skb, dev, ifm, extack, tb, NULL, 0); 2774 if (err < 0) 2775 return err; 2776 } 2777 } 2778 2779 return 0; 2780 } 2781 2782 static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, 2783 struct netlink_ext_ack *extack) 2784 { 2785 struct net *net = sock_net(skb->sk); 2786 const struct rtnl_link_ops *ops; 2787 const struct rtnl_link_ops *m_ops = NULL; 2788 struct net_device *dev; 2789 struct net_device *master_dev = NULL; 2790 struct ifinfomsg *ifm; 2791 char kind[MODULE_NAME_LEN]; 2792 char ifname[IFNAMSIZ]; 2793 struct nlattr *tb[IFLA_MAX+1]; 2794 struct nlattr *linkinfo[IFLA_INFO_MAX+1]; 2795 unsigned char name_assign_type = NET_NAME_USER; 2796 int err; 2797 2798 #ifdef CONFIG_MODULES 2799 replay: 2800 #endif 2801 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack); 2802 if (err < 0) 2803 return err; 2804 2805 if (tb[IFLA_IF_NETNSID]) 2806 return -EOPNOTSUPP; 2807 2808 if (tb[IFLA_IFNAME]) 2809 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 2810 else 2811 ifname[0] = '\0'; 2812 2813 ifm = nlmsg_data(nlh); 2814 if (ifm->ifi_index > 0) 2815 dev = __dev_get_by_index(net, ifm->ifi_index); 2816 else { 2817 if (ifname[0]) 2818 dev = __dev_get_by_name(net, ifname); 2819 else 2820 dev = NULL; 2821 } 2822 2823 if (dev) { 2824 master_dev = netdev_master_upper_dev_get(dev); 2825 if (master_dev) 2826 m_ops = master_dev->rtnl_link_ops; 2827 } 2828 2829 err = validate_linkmsg(dev, tb); 2830 if (err < 0) 2831 return err; 2832 2833 if (tb[IFLA_LINKINFO]) { 2834 err = nla_parse_nested(linkinfo, IFLA_INFO_MAX, 2835 tb[IFLA_LINKINFO], ifla_info_policy, 2836 NULL); 2837 if (err < 0) 2838 return err; 2839 } else 2840 memset(linkinfo, 0, sizeof(linkinfo)); 2841 2842 if (linkinfo[IFLA_INFO_KIND]) { 2843 nla_strlcpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind)); 2844 ops = rtnl_link_ops_get(kind); 2845 } else { 2846 kind[0] = '\0'; 2847 ops = NULL; 2848 } 2849 2850 if (1) { 2851 struct nlattr *attr[ops ? ops->maxtype + 1 : 1]; 2852 struct nlattr *slave_attr[m_ops ? m_ops->slave_maxtype + 1 : 1]; 2853 struct nlattr **data = NULL; 2854 struct nlattr **slave_data = NULL; 2855 struct net *dest_net, *link_net = NULL; 2856 2857 if (ops) { 2858 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) { 2859 err = nla_parse_nested(attr, ops->maxtype, 2860 linkinfo[IFLA_INFO_DATA], 2861 ops->policy, NULL); 2862 if (err < 0) 2863 return err; 2864 data = attr; 2865 } 2866 if (ops->validate) { 2867 err = ops->validate(tb, data, extack); 2868 if (err < 0) 2869 return err; 2870 } 2871 } 2872 2873 if (m_ops) { 2874 if (m_ops->slave_maxtype && 2875 linkinfo[IFLA_INFO_SLAVE_DATA]) { 2876 err = nla_parse_nested(slave_attr, 2877 m_ops->slave_maxtype, 2878 linkinfo[IFLA_INFO_SLAVE_DATA], 2879 m_ops->slave_policy, 2880 NULL); 2881 if (err < 0) 2882 return err; 2883 slave_data = slave_attr; 2884 } 2885 } 2886 2887 if (dev) { 2888 int status = 0; 2889 2890 if (nlh->nlmsg_flags & NLM_F_EXCL) 2891 return -EEXIST; 2892 if (nlh->nlmsg_flags & NLM_F_REPLACE) 2893 return -EOPNOTSUPP; 2894 2895 if (linkinfo[IFLA_INFO_DATA]) { 2896 if (!ops || ops != dev->rtnl_link_ops || 2897 !ops->changelink) 2898 return -EOPNOTSUPP; 2899 2900 err = ops->changelink(dev, tb, data, extack); 2901 if (err < 0) 2902 return err; 2903 status |= DO_SETLINK_NOTIFY; 2904 } 2905 2906 if (linkinfo[IFLA_INFO_SLAVE_DATA]) { 2907 if (!m_ops || !m_ops->slave_changelink) 2908 return -EOPNOTSUPP; 2909 2910 err = m_ops->slave_changelink(master_dev, dev, 2911 tb, slave_data, 2912 extack); 2913 if (err < 0) 2914 return err; 2915 status |= DO_SETLINK_NOTIFY; 2916 } 2917 2918 return do_setlink(skb, dev, ifm, extack, tb, ifname, 2919 status); 2920 } 2921 2922 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 2923 if (ifm->ifi_index == 0 && tb[IFLA_GROUP]) 2924 return rtnl_group_changelink(skb, net, 2925 nla_get_u32(tb[IFLA_GROUP]), 2926 ifm, extack, tb); 2927 return -ENODEV; 2928 } 2929 2930 if (tb[IFLA_MAP] || tb[IFLA_PROTINFO]) 2931 return -EOPNOTSUPP; 2932 2933 if (!ops) { 2934 #ifdef CONFIG_MODULES 2935 if (kind[0]) { 2936 __rtnl_unlock(); 2937 request_module("rtnl-link-%s", kind); 2938 rtnl_lock(); 2939 ops = rtnl_link_ops_get(kind); 2940 if (ops) 2941 goto replay; 2942 } 2943 #endif 2944 return -EOPNOTSUPP; 2945 } 2946 2947 if (!ops->setup) 2948 return -EOPNOTSUPP; 2949 2950 if (!ifname[0]) { 2951 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind); 2952 name_assign_type = NET_NAME_ENUM; 2953 } 2954 2955 dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN); 2956 if (IS_ERR(dest_net)) 2957 return PTR_ERR(dest_net); 2958 2959 if (tb[IFLA_LINK_NETNSID]) { 2960 int id = nla_get_s32(tb[IFLA_LINK_NETNSID]); 2961 2962 link_net = get_net_ns_by_id(dest_net, id); 2963 if (!link_net) { 2964 err = -EINVAL; 2965 goto out; 2966 } 2967 err = -EPERM; 2968 if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN)) 2969 goto out; 2970 } 2971 2972 dev = rtnl_create_link(link_net ? : dest_net, ifname, 2973 name_assign_type, ops, tb); 2974 if (IS_ERR(dev)) { 2975 err = PTR_ERR(dev); 2976 goto out; 2977 } 2978 2979 dev->ifindex = ifm->ifi_index; 2980 2981 if (ops->newlink) { 2982 err = ops->newlink(link_net ? : net, dev, tb, data, 2983 extack); 2984 /* Drivers should call free_netdev() in ->destructor 2985 * and unregister it on failure after registration 2986 * so that device could be finally freed in rtnl_unlock. 2987 */ 2988 if (err < 0) { 2989 /* If device is not registered at all, free it now */ 2990 if (dev->reg_state == NETREG_UNINITIALIZED) 2991 free_netdev(dev); 2992 goto out; 2993 } 2994 } else { 2995 err = register_netdevice(dev); 2996 if (err < 0) { 2997 free_netdev(dev); 2998 goto out; 2999 } 3000 } 3001 err = rtnl_configure_link(dev, ifm); 3002 if (err < 0) 3003 goto out_unregister; 3004 if (link_net) { 3005 err = dev_change_net_namespace(dev, dest_net, ifname); 3006 if (err < 0) 3007 goto out_unregister; 3008 } 3009 if (tb[IFLA_MASTER]) { 3010 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), 3011 extack); 3012 if (err) 3013 goto out_unregister; 3014 } 3015 out: 3016 if (link_net) 3017 put_net(link_net); 3018 put_net(dest_net); 3019 return err; 3020 out_unregister: 3021 if (ops->newlink) { 3022 LIST_HEAD(list_kill); 3023 3024 ops->dellink(dev, &list_kill); 3025 unregister_netdevice_many(&list_kill); 3026 } else { 3027 unregister_netdevice(dev); 3028 } 3029 goto out; 3030 } 3031 } 3032 3033 static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh, 3034 struct netlink_ext_ack *extack) 3035 { 3036 struct net *net = sock_net(skb->sk); 3037 struct net *tgt_net = net; 3038 struct ifinfomsg *ifm; 3039 char ifname[IFNAMSIZ]; 3040 struct nlattr *tb[IFLA_MAX+1]; 3041 struct net_device *dev = NULL; 3042 struct sk_buff *nskb; 3043 int netnsid = -1; 3044 int err; 3045 u32 ext_filter_mask = 0; 3046 3047 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack); 3048 if (err < 0) 3049 return err; 3050 3051 if (tb[IFLA_IF_NETNSID]) { 3052 netnsid = nla_get_s32(tb[IFLA_IF_NETNSID]); 3053 tgt_net = get_target_net(NETLINK_CB(skb).sk, netnsid); 3054 if (IS_ERR(tgt_net)) 3055 return PTR_ERR(tgt_net); 3056 } 3057 3058 if (tb[IFLA_IFNAME]) 3059 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 3060 3061 if (tb[IFLA_EXT_MASK]) 3062 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]); 3063 3064 err = -EINVAL; 3065 ifm = nlmsg_data(nlh); 3066 if (ifm->ifi_index > 0) 3067 dev = __dev_get_by_index(tgt_net, ifm->ifi_index); 3068 else if (tb[IFLA_IFNAME]) 3069 dev = __dev_get_by_name(tgt_net, ifname); 3070 else 3071 goto out; 3072 3073 err = -ENODEV; 3074 if (dev == NULL) 3075 goto out; 3076 3077 err = -ENOBUFS; 3078 nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL); 3079 if (nskb == NULL) 3080 goto out; 3081 3082 err = rtnl_fill_ifinfo(nskb, dev, net, 3083 RTM_NEWLINK, NETLINK_CB(skb).portid, 3084 nlh->nlmsg_seq, 0, 0, ext_filter_mask, 3085 0, NULL, 0, netnsid); 3086 if (err < 0) { 3087 /* -EMSGSIZE implies BUG in if_nlmsg_size */ 3088 WARN_ON(err == -EMSGSIZE); 3089 kfree_skb(nskb); 3090 } else 3091 err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid); 3092 out: 3093 if (netnsid >= 0) 3094 put_net(tgt_net); 3095 3096 return err; 3097 } 3098 3099 static u16 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh) 3100 { 3101 struct net *net = sock_net(skb->sk); 3102 struct net_device *dev; 3103 struct nlattr *tb[IFLA_MAX+1]; 3104 u32 ext_filter_mask = 0; 3105 u16 min_ifinfo_dump_size = 0; 3106 int hdrlen; 3107 3108 /* Same kernel<->userspace interface hack as in rtnl_dump_ifinfo. */ 3109 hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ? 3110 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg); 3111 3112 if (nlmsg_parse(nlh, hdrlen, tb, IFLA_MAX, ifla_policy, NULL) >= 0) { 3113 if (tb[IFLA_EXT_MASK]) 3114 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]); 3115 } 3116 3117 if (!ext_filter_mask) 3118 return NLMSG_GOODSIZE; 3119 /* 3120 * traverse the list of net devices and compute the minimum 3121 * buffer size based upon the filter mask. 3122 */ 3123 rcu_read_lock(); 3124 for_each_netdev_rcu(net, dev) { 3125 min_ifinfo_dump_size = max_t(u16, min_ifinfo_dump_size, 3126 if_nlmsg_size(dev, 3127 ext_filter_mask)); 3128 } 3129 rcu_read_unlock(); 3130 3131 return nlmsg_total_size(min_ifinfo_dump_size); 3132 } 3133 3134 static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb) 3135 { 3136 int idx; 3137 int s_idx = cb->family; 3138 3139 if (s_idx == 0) 3140 s_idx = 1; 3141 3142 for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) { 3143 struct rtnl_link **tab; 3144 int type = cb->nlh->nlmsg_type-RTM_BASE; 3145 struct rtnl_link *link; 3146 rtnl_dumpit_func dumpit; 3147 3148 if (idx < s_idx || idx == PF_PACKET) 3149 continue; 3150 3151 if (type < 0 || type >= RTM_NR_MSGTYPES) 3152 continue; 3153 3154 tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]); 3155 if (!tab) 3156 continue; 3157 3158 link = tab[type]; 3159 if (!link) 3160 continue; 3161 3162 dumpit = link->dumpit; 3163 if (!dumpit) 3164 continue; 3165 3166 if (idx > s_idx) { 3167 memset(&cb->args[0], 0, sizeof(cb->args)); 3168 cb->prev_seq = 0; 3169 cb->seq = 0; 3170 } 3171 if (dumpit(skb, cb)) 3172 break; 3173 } 3174 cb->family = idx; 3175 3176 return skb->len; 3177 } 3178 3179 struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev, 3180 unsigned int change, 3181 u32 event, gfp_t flags, int *new_nsid, 3182 int new_ifindex) 3183 { 3184 struct net *net = dev_net(dev); 3185 struct sk_buff *skb; 3186 int err = -ENOBUFS; 3187 size_t if_info_size; 3188 3189 skb = nlmsg_new((if_info_size = if_nlmsg_size(dev, 0)), flags); 3190 if (skb == NULL) 3191 goto errout; 3192 3193 err = rtnl_fill_ifinfo(skb, dev, dev_net(dev), 3194 type, 0, 0, change, 0, 0, event, 3195 new_nsid, new_ifindex, -1); 3196 if (err < 0) { 3197 /* -EMSGSIZE implies BUG in if_nlmsg_size() */ 3198 WARN_ON(err == -EMSGSIZE); 3199 kfree_skb(skb); 3200 goto errout; 3201 } 3202 return skb; 3203 errout: 3204 if (err < 0) 3205 rtnl_set_sk_err(net, RTNLGRP_LINK, err); 3206 return NULL; 3207 } 3208 3209 void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags) 3210 { 3211 struct net *net = dev_net(dev); 3212 3213 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, flags); 3214 } 3215 3216 static void rtmsg_ifinfo_event(int type, struct net_device *dev, 3217 unsigned int change, u32 event, 3218 gfp_t flags, int *new_nsid, int new_ifindex) 3219 { 3220 struct sk_buff *skb; 3221 3222 if (dev->reg_state != NETREG_REGISTERED) 3223 return; 3224 3225 skb = rtmsg_ifinfo_build_skb(type, dev, change, event, flags, new_nsid, 3226 new_ifindex); 3227 if (skb) 3228 rtmsg_ifinfo_send(skb, dev, flags); 3229 } 3230 3231 void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change, 3232 gfp_t flags) 3233 { 3234 rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags, 3235 NULL, 0); 3236 } 3237 3238 void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change, 3239 gfp_t flags, int *new_nsid, int new_ifindex) 3240 { 3241 rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags, 3242 new_nsid, new_ifindex); 3243 } 3244 3245 static int nlmsg_populate_fdb_fill(struct sk_buff *skb, 3246 struct net_device *dev, 3247 u8 *addr, u16 vid, u32 pid, u32 seq, 3248 int type, unsigned int flags, 3249 int nlflags, u16 ndm_state) 3250 { 3251 struct nlmsghdr *nlh; 3252 struct ndmsg *ndm; 3253 3254 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags); 3255 if (!nlh) 3256 return -EMSGSIZE; 3257 3258 ndm = nlmsg_data(nlh); 3259 ndm->ndm_family = AF_BRIDGE; 3260 ndm->ndm_pad1 = 0; 3261 ndm->ndm_pad2 = 0; 3262 ndm->ndm_flags = flags; 3263 ndm->ndm_type = 0; 3264 ndm->ndm_ifindex = dev->ifindex; 3265 ndm->ndm_state = ndm_state; 3266 3267 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, addr)) 3268 goto nla_put_failure; 3269 if (vid) 3270 if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid)) 3271 goto nla_put_failure; 3272 3273 nlmsg_end(skb, nlh); 3274 return 0; 3275 3276 nla_put_failure: 3277 nlmsg_cancel(skb, nlh); 3278 return -EMSGSIZE; 3279 } 3280 3281 static inline size_t rtnl_fdb_nlmsg_size(void) 3282 { 3283 return NLMSG_ALIGN(sizeof(struct ndmsg)) + 3284 nla_total_size(ETH_ALEN) + /* NDA_LLADDR */ 3285 nla_total_size(sizeof(u16)) + /* NDA_VLAN */ 3286 0; 3287 } 3288 3289 static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type, 3290 u16 ndm_state) 3291 { 3292 struct net *net = dev_net(dev); 3293 struct sk_buff *skb; 3294 int err = -ENOBUFS; 3295 3296 skb = nlmsg_new(rtnl_fdb_nlmsg_size(), GFP_ATOMIC); 3297 if (!skb) 3298 goto errout; 3299 3300 err = nlmsg_populate_fdb_fill(skb, dev, addr, vid, 3301 0, 0, type, NTF_SELF, 0, ndm_state); 3302 if (err < 0) { 3303 kfree_skb(skb); 3304 goto errout; 3305 } 3306 3307 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 3308 return; 3309 errout: 3310 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err); 3311 } 3312 3313 /** 3314 * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry 3315 */ 3316 int ndo_dflt_fdb_add(struct ndmsg *ndm, 3317 struct nlattr *tb[], 3318 struct net_device *dev, 3319 const unsigned char *addr, u16 vid, 3320 u16 flags) 3321 { 3322 int err = -EINVAL; 3323 3324 /* If aging addresses are supported device will need to 3325 * implement its own handler for this. 3326 */ 3327 if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) { 3328 pr_info("%s: FDB only supports static addresses\n", dev->name); 3329 return err; 3330 } 3331 3332 if (vid) { 3333 pr_info("%s: vlans aren't supported yet for dev_uc|mc_add()\n", dev->name); 3334 return err; 3335 } 3336 3337 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) 3338 err = dev_uc_add_excl(dev, addr); 3339 else if (is_multicast_ether_addr(addr)) 3340 err = dev_mc_add_excl(dev, addr); 3341 3342 /* Only return duplicate errors if NLM_F_EXCL is set */ 3343 if (err == -EEXIST && !(flags & NLM_F_EXCL)) 3344 err = 0; 3345 3346 return err; 3347 } 3348 EXPORT_SYMBOL(ndo_dflt_fdb_add); 3349 3350 static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid, 3351 struct netlink_ext_ack *extack) 3352 { 3353 u16 vid = 0; 3354 3355 if (vlan_attr) { 3356 if (nla_len(vlan_attr) != sizeof(u16)) { 3357 NL_SET_ERR_MSG(extack, "invalid vlan attribute size"); 3358 return -EINVAL; 3359 } 3360 3361 vid = nla_get_u16(vlan_attr); 3362 3363 if (!vid || vid >= VLAN_VID_MASK) { 3364 NL_SET_ERR_MSG(extack, "invalid vlan id"); 3365 return -EINVAL; 3366 } 3367 } 3368 *p_vid = vid; 3369 return 0; 3370 } 3371 3372 static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, 3373 struct netlink_ext_ack *extack) 3374 { 3375 struct net *net = sock_net(skb->sk); 3376 struct ndmsg *ndm; 3377 struct nlattr *tb[NDA_MAX+1]; 3378 struct net_device *dev; 3379 u8 *addr; 3380 u16 vid; 3381 int err; 3382 3383 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, extack); 3384 if (err < 0) 3385 return err; 3386 3387 ndm = nlmsg_data(nlh); 3388 if (ndm->ndm_ifindex == 0) { 3389 NL_SET_ERR_MSG(extack, "invalid ifindex"); 3390 return -EINVAL; 3391 } 3392 3393 dev = __dev_get_by_index(net, ndm->ndm_ifindex); 3394 if (dev == NULL) { 3395 NL_SET_ERR_MSG(extack, "unknown ifindex"); 3396 return -ENODEV; 3397 } 3398 3399 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) { 3400 NL_SET_ERR_MSG(extack, "invalid address"); 3401 return -EINVAL; 3402 } 3403 3404 addr = nla_data(tb[NDA_LLADDR]); 3405 3406 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack); 3407 if (err) 3408 return err; 3409 3410 err = -EOPNOTSUPP; 3411 3412 /* Support fdb on master device the net/bridge default case */ 3413 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) && 3414 (dev->priv_flags & IFF_BRIDGE_PORT)) { 3415 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 3416 const struct net_device_ops *ops = br_dev->netdev_ops; 3417 3418 err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid, 3419 nlh->nlmsg_flags); 3420 if (err) 3421 goto out; 3422 else 3423 ndm->ndm_flags &= ~NTF_MASTER; 3424 } 3425 3426 /* Embedded bridge, macvlan, and any other device support */ 3427 if ((ndm->ndm_flags & NTF_SELF)) { 3428 if (dev->netdev_ops->ndo_fdb_add) 3429 err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr, 3430 vid, 3431 nlh->nlmsg_flags); 3432 else 3433 err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid, 3434 nlh->nlmsg_flags); 3435 3436 if (!err) { 3437 rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH, 3438 ndm->ndm_state); 3439 ndm->ndm_flags &= ~NTF_SELF; 3440 } 3441 } 3442 out: 3443 return err; 3444 } 3445 3446 /** 3447 * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry 3448 */ 3449 int ndo_dflt_fdb_del(struct ndmsg *ndm, 3450 struct nlattr *tb[], 3451 struct net_device *dev, 3452 const unsigned char *addr, u16 vid) 3453 { 3454 int err = -EINVAL; 3455 3456 /* If aging addresses are supported device will need to 3457 * implement its own handler for this. 3458 */ 3459 if (!(ndm->ndm_state & NUD_PERMANENT)) { 3460 pr_info("%s: FDB only supports static addresses\n", dev->name); 3461 return err; 3462 } 3463 3464 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) 3465 err = dev_uc_del(dev, addr); 3466 else if (is_multicast_ether_addr(addr)) 3467 err = dev_mc_del(dev, addr); 3468 3469 return err; 3470 } 3471 EXPORT_SYMBOL(ndo_dflt_fdb_del); 3472 3473 static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh, 3474 struct netlink_ext_ack *extack) 3475 { 3476 struct net *net = sock_net(skb->sk); 3477 struct ndmsg *ndm; 3478 struct nlattr *tb[NDA_MAX+1]; 3479 struct net_device *dev; 3480 int err = -EINVAL; 3481 __u8 *addr; 3482 u16 vid; 3483 3484 if (!netlink_capable(skb, CAP_NET_ADMIN)) 3485 return -EPERM; 3486 3487 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL, extack); 3488 if (err < 0) 3489 return err; 3490 3491 ndm = nlmsg_data(nlh); 3492 if (ndm->ndm_ifindex == 0) { 3493 NL_SET_ERR_MSG(extack, "invalid ifindex"); 3494 return -EINVAL; 3495 } 3496 3497 dev = __dev_get_by_index(net, ndm->ndm_ifindex); 3498 if (dev == NULL) { 3499 NL_SET_ERR_MSG(extack, "unknown ifindex"); 3500 return -ENODEV; 3501 } 3502 3503 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) { 3504 NL_SET_ERR_MSG(extack, "invalid address"); 3505 return -EINVAL; 3506 } 3507 3508 addr = nla_data(tb[NDA_LLADDR]); 3509 3510 err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack); 3511 if (err) 3512 return err; 3513 3514 err = -EOPNOTSUPP; 3515 3516 /* Support fdb on master device the net/bridge default case */ 3517 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) && 3518 (dev->priv_flags & IFF_BRIDGE_PORT)) { 3519 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 3520 const struct net_device_ops *ops = br_dev->netdev_ops; 3521 3522 if (ops->ndo_fdb_del) 3523 err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid); 3524 3525 if (err) 3526 goto out; 3527 else 3528 ndm->ndm_flags &= ~NTF_MASTER; 3529 } 3530 3531 /* Embedded bridge, macvlan, and any other device support */ 3532 if (ndm->ndm_flags & NTF_SELF) { 3533 if (dev->netdev_ops->ndo_fdb_del) 3534 err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr, 3535 vid); 3536 else 3537 err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid); 3538 3539 if (!err) { 3540 rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH, 3541 ndm->ndm_state); 3542 ndm->ndm_flags &= ~NTF_SELF; 3543 } 3544 } 3545 out: 3546 return err; 3547 } 3548 3549 static int nlmsg_populate_fdb(struct sk_buff *skb, 3550 struct netlink_callback *cb, 3551 struct net_device *dev, 3552 int *idx, 3553 struct netdev_hw_addr_list *list) 3554 { 3555 struct netdev_hw_addr *ha; 3556 int err; 3557 u32 portid, seq; 3558 3559 portid = NETLINK_CB(cb->skb).portid; 3560 seq = cb->nlh->nlmsg_seq; 3561 3562 list_for_each_entry(ha, &list->list, list) { 3563 if (*idx < cb->args[2]) 3564 goto skip; 3565 3566 err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0, 3567 portid, seq, 3568 RTM_NEWNEIGH, NTF_SELF, 3569 NLM_F_MULTI, NUD_PERMANENT); 3570 if (err < 0) 3571 return err; 3572 skip: 3573 *idx += 1; 3574 } 3575 return 0; 3576 } 3577 3578 /** 3579 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table. 3580 * @nlh: netlink message header 3581 * @dev: netdevice 3582 * 3583 * Default netdevice operation to dump the existing unicast address list. 3584 * Returns number of addresses from list put in skb. 3585 */ 3586 int ndo_dflt_fdb_dump(struct sk_buff *skb, 3587 struct netlink_callback *cb, 3588 struct net_device *dev, 3589 struct net_device *filter_dev, 3590 int *idx) 3591 { 3592 int err; 3593 3594 netif_addr_lock_bh(dev); 3595 err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->uc); 3596 if (err) 3597 goto out; 3598 err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->mc); 3599 out: 3600 netif_addr_unlock_bh(dev); 3601 return err; 3602 } 3603 EXPORT_SYMBOL(ndo_dflt_fdb_dump); 3604 3605 static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb) 3606 { 3607 struct net_device *dev; 3608 struct nlattr *tb[IFLA_MAX+1]; 3609 struct net_device *br_dev = NULL; 3610 const struct net_device_ops *ops = NULL; 3611 const struct net_device_ops *cops = NULL; 3612 struct ifinfomsg *ifm = nlmsg_data(cb->nlh); 3613 struct net *net = sock_net(skb->sk); 3614 struct hlist_head *head; 3615 int brport_idx = 0; 3616 int br_idx = 0; 3617 int h, s_h; 3618 int idx = 0, s_idx; 3619 int err = 0; 3620 int fidx = 0; 3621 3622 err = nlmsg_parse(cb->nlh, sizeof(struct ifinfomsg), tb, 3623 IFLA_MAX, ifla_policy, NULL); 3624 if (err < 0) { 3625 return -EINVAL; 3626 } else if (err == 0) { 3627 if (tb[IFLA_MASTER]) 3628 br_idx = nla_get_u32(tb[IFLA_MASTER]); 3629 } 3630 3631 brport_idx = ifm->ifi_index; 3632 3633 if (br_idx) { 3634 br_dev = __dev_get_by_index(net, br_idx); 3635 if (!br_dev) 3636 return -ENODEV; 3637 3638 ops = br_dev->netdev_ops; 3639 } 3640 3641 s_h = cb->args[0]; 3642 s_idx = cb->args[1]; 3643 3644 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 3645 idx = 0; 3646 head = &net->dev_index_head[h]; 3647 hlist_for_each_entry(dev, head, index_hlist) { 3648 3649 if (brport_idx && (dev->ifindex != brport_idx)) 3650 continue; 3651 3652 if (!br_idx) { /* user did not specify a specific bridge */ 3653 if (dev->priv_flags & IFF_BRIDGE_PORT) { 3654 br_dev = netdev_master_upper_dev_get(dev); 3655 cops = br_dev->netdev_ops; 3656 } 3657 } else { 3658 if (dev != br_dev && 3659 !(dev->priv_flags & IFF_BRIDGE_PORT)) 3660 continue; 3661 3662 if (br_dev != netdev_master_upper_dev_get(dev) && 3663 !(dev->priv_flags & IFF_EBRIDGE)) 3664 continue; 3665 cops = ops; 3666 } 3667 3668 if (idx < s_idx) 3669 goto cont; 3670 3671 if (dev->priv_flags & IFF_BRIDGE_PORT) { 3672 if (cops && cops->ndo_fdb_dump) { 3673 err = cops->ndo_fdb_dump(skb, cb, 3674 br_dev, dev, 3675 &fidx); 3676 if (err == -EMSGSIZE) 3677 goto out; 3678 } 3679 } 3680 3681 if (dev->netdev_ops->ndo_fdb_dump) 3682 err = dev->netdev_ops->ndo_fdb_dump(skb, cb, 3683 dev, NULL, 3684 &fidx); 3685 else 3686 err = ndo_dflt_fdb_dump(skb, cb, dev, NULL, 3687 &fidx); 3688 if (err == -EMSGSIZE) 3689 goto out; 3690 3691 cops = NULL; 3692 3693 /* reset fdb offset to 0 for rest of the interfaces */ 3694 cb->args[2] = 0; 3695 fidx = 0; 3696 cont: 3697 idx++; 3698 } 3699 } 3700 3701 out: 3702 cb->args[0] = h; 3703 cb->args[1] = idx; 3704 cb->args[2] = fidx; 3705 3706 return skb->len; 3707 } 3708 3709 static int brport_nla_put_flag(struct sk_buff *skb, u32 flags, u32 mask, 3710 unsigned int attrnum, unsigned int flag) 3711 { 3712 if (mask & flag) 3713 return nla_put_u8(skb, attrnum, !!(flags & flag)); 3714 return 0; 3715 } 3716 3717 int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, 3718 struct net_device *dev, u16 mode, 3719 u32 flags, u32 mask, int nlflags, 3720 u32 filter_mask, 3721 int (*vlan_fill)(struct sk_buff *skb, 3722 struct net_device *dev, 3723 u32 filter_mask)) 3724 { 3725 struct nlmsghdr *nlh; 3726 struct ifinfomsg *ifm; 3727 struct nlattr *br_afspec; 3728 struct nlattr *protinfo; 3729 u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN; 3730 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 3731 int err = 0; 3732 3733 nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), nlflags); 3734 if (nlh == NULL) 3735 return -EMSGSIZE; 3736 3737 ifm = nlmsg_data(nlh); 3738 ifm->ifi_family = AF_BRIDGE; 3739 ifm->__ifi_pad = 0; 3740 ifm->ifi_type = dev->type; 3741 ifm->ifi_index = dev->ifindex; 3742 ifm->ifi_flags = dev_get_flags(dev); 3743 ifm->ifi_change = 0; 3744 3745 3746 if (nla_put_string(skb, IFLA_IFNAME, dev->name) || 3747 nla_put_u32(skb, IFLA_MTU, dev->mtu) || 3748 nla_put_u8(skb, IFLA_OPERSTATE, operstate) || 3749 (br_dev && 3750 nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) || 3751 (dev->addr_len && 3752 nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) || 3753 (dev->ifindex != dev_get_iflink(dev) && 3754 nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev)))) 3755 goto nla_put_failure; 3756 3757 br_afspec = nla_nest_start(skb, IFLA_AF_SPEC); 3758 if (!br_afspec) 3759 goto nla_put_failure; 3760 3761 if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF)) { 3762 nla_nest_cancel(skb, br_afspec); 3763 goto nla_put_failure; 3764 } 3765 3766 if (mode != BRIDGE_MODE_UNDEF) { 3767 if (nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) { 3768 nla_nest_cancel(skb, br_afspec); 3769 goto nla_put_failure; 3770 } 3771 } 3772 if (vlan_fill) { 3773 err = vlan_fill(skb, dev, filter_mask); 3774 if (err) { 3775 nla_nest_cancel(skb, br_afspec); 3776 goto nla_put_failure; 3777 } 3778 } 3779 nla_nest_end(skb, br_afspec); 3780 3781 protinfo = nla_nest_start(skb, IFLA_PROTINFO | NLA_F_NESTED); 3782 if (!protinfo) 3783 goto nla_put_failure; 3784 3785 if (brport_nla_put_flag(skb, flags, mask, 3786 IFLA_BRPORT_MODE, BR_HAIRPIN_MODE) || 3787 brport_nla_put_flag(skb, flags, mask, 3788 IFLA_BRPORT_GUARD, BR_BPDU_GUARD) || 3789 brport_nla_put_flag(skb, flags, mask, 3790 IFLA_BRPORT_FAST_LEAVE, 3791 BR_MULTICAST_FAST_LEAVE) || 3792 brport_nla_put_flag(skb, flags, mask, 3793 IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK) || 3794 brport_nla_put_flag(skb, flags, mask, 3795 IFLA_BRPORT_LEARNING, BR_LEARNING) || 3796 brport_nla_put_flag(skb, flags, mask, 3797 IFLA_BRPORT_LEARNING_SYNC, BR_LEARNING_SYNC) || 3798 brport_nla_put_flag(skb, flags, mask, 3799 IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD) || 3800 brport_nla_put_flag(skb, flags, mask, 3801 IFLA_BRPORT_PROXYARP, BR_PROXYARP)) { 3802 nla_nest_cancel(skb, protinfo); 3803 goto nla_put_failure; 3804 } 3805 3806 nla_nest_end(skb, protinfo); 3807 3808 nlmsg_end(skb, nlh); 3809 return 0; 3810 nla_put_failure: 3811 nlmsg_cancel(skb, nlh); 3812 return err ? err : -EMSGSIZE; 3813 } 3814 EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink); 3815 3816 static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb) 3817 { 3818 struct net *net = sock_net(skb->sk); 3819 struct net_device *dev; 3820 int idx = 0; 3821 u32 portid = NETLINK_CB(cb->skb).portid; 3822 u32 seq = cb->nlh->nlmsg_seq; 3823 u32 filter_mask = 0; 3824 int err; 3825 3826 if (nlmsg_len(cb->nlh) > sizeof(struct ifinfomsg)) { 3827 struct nlattr *extfilt; 3828 3829 extfilt = nlmsg_find_attr(cb->nlh, sizeof(struct ifinfomsg), 3830 IFLA_EXT_MASK); 3831 if (extfilt) { 3832 if (nla_len(extfilt) < sizeof(filter_mask)) 3833 return -EINVAL; 3834 3835 filter_mask = nla_get_u32(extfilt); 3836 } 3837 } 3838 3839 rcu_read_lock(); 3840 for_each_netdev_rcu(net, dev) { 3841 const struct net_device_ops *ops = dev->netdev_ops; 3842 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 3843 3844 if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) { 3845 if (idx >= cb->args[0]) { 3846 err = br_dev->netdev_ops->ndo_bridge_getlink( 3847 skb, portid, seq, dev, 3848 filter_mask, NLM_F_MULTI); 3849 if (err < 0 && err != -EOPNOTSUPP) { 3850 if (likely(skb->len)) 3851 break; 3852 3853 goto out_err; 3854 } 3855 } 3856 idx++; 3857 } 3858 3859 if (ops->ndo_bridge_getlink) { 3860 if (idx >= cb->args[0]) { 3861 err = ops->ndo_bridge_getlink(skb, portid, 3862 seq, dev, 3863 filter_mask, 3864 NLM_F_MULTI); 3865 if (err < 0 && err != -EOPNOTSUPP) { 3866 if (likely(skb->len)) 3867 break; 3868 3869 goto out_err; 3870 } 3871 } 3872 idx++; 3873 } 3874 } 3875 err = skb->len; 3876 out_err: 3877 rcu_read_unlock(); 3878 cb->args[0] = idx; 3879 3880 return err; 3881 } 3882 3883 static inline size_t bridge_nlmsg_size(void) 3884 { 3885 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 3886 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 3887 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 3888 + nla_total_size(sizeof(u32)) /* IFLA_MASTER */ 3889 + nla_total_size(sizeof(u32)) /* IFLA_MTU */ 3890 + nla_total_size(sizeof(u32)) /* IFLA_LINK */ 3891 + nla_total_size(sizeof(u32)) /* IFLA_OPERSTATE */ 3892 + nla_total_size(sizeof(u8)) /* IFLA_PROTINFO */ 3893 + nla_total_size(sizeof(struct nlattr)) /* IFLA_AF_SPEC */ 3894 + nla_total_size(sizeof(u16)) /* IFLA_BRIDGE_FLAGS */ 3895 + nla_total_size(sizeof(u16)); /* IFLA_BRIDGE_MODE */ 3896 } 3897 3898 static int rtnl_bridge_notify(struct net_device *dev) 3899 { 3900 struct net *net = dev_net(dev); 3901 struct sk_buff *skb; 3902 int err = -EOPNOTSUPP; 3903 3904 if (!dev->netdev_ops->ndo_bridge_getlink) 3905 return 0; 3906 3907 skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC); 3908 if (!skb) { 3909 err = -ENOMEM; 3910 goto errout; 3911 } 3912 3913 err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0, 0); 3914 if (err < 0) 3915 goto errout; 3916 3917 if (!skb->len) 3918 goto errout; 3919 3920 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC); 3921 return 0; 3922 errout: 3923 WARN_ON(err == -EMSGSIZE); 3924 kfree_skb(skb); 3925 if (err) 3926 rtnl_set_sk_err(net, RTNLGRP_LINK, err); 3927 return err; 3928 } 3929 3930 static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, 3931 struct netlink_ext_ack *extack) 3932 { 3933 struct net *net = sock_net(skb->sk); 3934 struct ifinfomsg *ifm; 3935 struct net_device *dev; 3936 struct nlattr *br_spec, *attr = NULL; 3937 int rem, err = -EOPNOTSUPP; 3938 u16 flags = 0; 3939 bool have_flags = false; 3940 3941 if (nlmsg_len(nlh) < sizeof(*ifm)) 3942 return -EINVAL; 3943 3944 ifm = nlmsg_data(nlh); 3945 if (ifm->ifi_family != AF_BRIDGE) 3946 return -EPFNOSUPPORT; 3947 3948 dev = __dev_get_by_index(net, ifm->ifi_index); 3949 if (!dev) { 3950 NL_SET_ERR_MSG(extack, "unknown ifindex"); 3951 return -ENODEV; 3952 } 3953 3954 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 3955 if (br_spec) { 3956 nla_for_each_nested(attr, br_spec, rem) { 3957 if (nla_type(attr) == IFLA_BRIDGE_FLAGS) { 3958 if (nla_len(attr) < sizeof(flags)) 3959 return -EINVAL; 3960 3961 have_flags = true; 3962 flags = nla_get_u16(attr); 3963 break; 3964 } 3965 } 3966 } 3967 3968 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) { 3969 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 3970 3971 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) { 3972 err = -EOPNOTSUPP; 3973 goto out; 3974 } 3975 3976 err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh, flags); 3977 if (err) 3978 goto out; 3979 3980 flags &= ~BRIDGE_FLAGS_MASTER; 3981 } 3982 3983 if ((flags & BRIDGE_FLAGS_SELF)) { 3984 if (!dev->netdev_ops->ndo_bridge_setlink) 3985 err = -EOPNOTSUPP; 3986 else 3987 err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh, 3988 flags); 3989 if (!err) { 3990 flags &= ~BRIDGE_FLAGS_SELF; 3991 3992 /* Generate event to notify upper layer of bridge 3993 * change 3994 */ 3995 err = rtnl_bridge_notify(dev); 3996 } 3997 } 3998 3999 if (have_flags) 4000 memcpy(nla_data(attr), &flags, sizeof(flags)); 4001 out: 4002 return err; 4003 } 4004 4005 static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, 4006 struct netlink_ext_ack *extack) 4007 { 4008 struct net *net = sock_net(skb->sk); 4009 struct ifinfomsg *ifm; 4010 struct net_device *dev; 4011 struct nlattr *br_spec, *attr = NULL; 4012 int rem, err = -EOPNOTSUPP; 4013 u16 flags = 0; 4014 bool have_flags = false; 4015 4016 if (nlmsg_len(nlh) < sizeof(*ifm)) 4017 return -EINVAL; 4018 4019 ifm = nlmsg_data(nlh); 4020 if (ifm->ifi_family != AF_BRIDGE) 4021 return -EPFNOSUPPORT; 4022 4023 dev = __dev_get_by_index(net, ifm->ifi_index); 4024 if (!dev) { 4025 NL_SET_ERR_MSG(extack, "unknown ifindex"); 4026 return -ENODEV; 4027 } 4028 4029 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 4030 if (br_spec) { 4031 nla_for_each_nested(attr, br_spec, rem) { 4032 if (nla_type(attr) == IFLA_BRIDGE_FLAGS) { 4033 if (nla_len(attr) < sizeof(flags)) 4034 return -EINVAL; 4035 4036 have_flags = true; 4037 flags = nla_get_u16(attr); 4038 break; 4039 } 4040 } 4041 } 4042 4043 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) { 4044 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 4045 4046 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_dellink) { 4047 err = -EOPNOTSUPP; 4048 goto out; 4049 } 4050 4051 err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh, flags); 4052 if (err) 4053 goto out; 4054 4055 flags &= ~BRIDGE_FLAGS_MASTER; 4056 } 4057 4058 if ((flags & BRIDGE_FLAGS_SELF)) { 4059 if (!dev->netdev_ops->ndo_bridge_dellink) 4060 err = -EOPNOTSUPP; 4061 else 4062 err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh, 4063 flags); 4064 4065 if (!err) { 4066 flags &= ~BRIDGE_FLAGS_SELF; 4067 4068 /* Generate event to notify upper layer of bridge 4069 * change 4070 */ 4071 err = rtnl_bridge_notify(dev); 4072 } 4073 } 4074 4075 if (have_flags) 4076 memcpy(nla_data(attr), &flags, sizeof(flags)); 4077 out: 4078 return err; 4079 } 4080 4081 static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr) 4082 { 4083 return (mask & IFLA_STATS_FILTER_BIT(attrid)) && 4084 (!idxattr || idxattr == attrid); 4085 } 4086 4087 #define IFLA_OFFLOAD_XSTATS_FIRST (IFLA_OFFLOAD_XSTATS_UNSPEC + 1) 4088 static int rtnl_get_offload_stats_attr_size(int attr_id) 4089 { 4090 switch (attr_id) { 4091 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 4092 return sizeof(struct rtnl_link_stats64); 4093 } 4094 4095 return 0; 4096 } 4097 4098 static int rtnl_get_offload_stats(struct sk_buff *skb, struct net_device *dev, 4099 int *prividx) 4100 { 4101 struct nlattr *attr = NULL; 4102 int attr_id, size; 4103 void *attr_data; 4104 int err; 4105 4106 if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats && 4107 dev->netdev_ops->ndo_get_offload_stats)) 4108 return -ENODATA; 4109 4110 for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST; 4111 attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) { 4112 if (attr_id < *prividx) 4113 continue; 4114 4115 size = rtnl_get_offload_stats_attr_size(attr_id); 4116 if (!size) 4117 continue; 4118 4119 if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id)) 4120 continue; 4121 4122 attr = nla_reserve_64bit(skb, attr_id, size, 4123 IFLA_OFFLOAD_XSTATS_UNSPEC); 4124 if (!attr) 4125 goto nla_put_failure; 4126 4127 attr_data = nla_data(attr); 4128 memset(attr_data, 0, size); 4129 err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev, 4130 attr_data); 4131 if (err) 4132 goto get_offload_stats_failure; 4133 } 4134 4135 if (!attr) 4136 return -ENODATA; 4137 4138 *prividx = 0; 4139 return 0; 4140 4141 nla_put_failure: 4142 err = -EMSGSIZE; 4143 get_offload_stats_failure: 4144 *prividx = attr_id; 4145 return err; 4146 } 4147 4148 static int rtnl_get_offload_stats_size(const struct net_device *dev) 4149 { 4150 int nla_size = 0; 4151 int attr_id; 4152 int size; 4153 4154 if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats && 4155 dev->netdev_ops->ndo_get_offload_stats)) 4156 return 0; 4157 4158 for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST; 4159 attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) { 4160 if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id)) 4161 continue; 4162 size = rtnl_get_offload_stats_attr_size(attr_id); 4163 nla_size += nla_total_size_64bit(size); 4164 } 4165 4166 if (nla_size != 0) 4167 nla_size += nla_total_size(0); 4168 4169 return nla_size; 4170 } 4171 4172 static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev, 4173 int type, u32 pid, u32 seq, u32 change, 4174 unsigned int flags, unsigned int filter_mask, 4175 int *idxattr, int *prividx) 4176 { 4177 struct if_stats_msg *ifsm; 4178 struct nlmsghdr *nlh; 4179 struct nlattr *attr; 4180 int s_prividx = *prividx; 4181 int err; 4182 4183 ASSERT_RTNL(); 4184 4185 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifsm), flags); 4186 if (!nlh) 4187 return -EMSGSIZE; 4188 4189 ifsm = nlmsg_data(nlh); 4190 ifsm->family = PF_UNSPEC; 4191 ifsm->pad1 = 0; 4192 ifsm->pad2 = 0; 4193 ifsm->ifindex = dev->ifindex; 4194 ifsm->filter_mask = filter_mask; 4195 4196 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, *idxattr)) { 4197 struct rtnl_link_stats64 *sp; 4198 4199 attr = nla_reserve_64bit(skb, IFLA_STATS_LINK_64, 4200 sizeof(struct rtnl_link_stats64), 4201 IFLA_STATS_UNSPEC); 4202 if (!attr) 4203 goto nla_put_failure; 4204 4205 sp = nla_data(attr); 4206 dev_get_stats(dev, sp); 4207 } 4208 4209 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, *idxattr)) { 4210 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 4211 4212 if (ops && ops->fill_linkxstats) { 4213 *idxattr = IFLA_STATS_LINK_XSTATS; 4214 attr = nla_nest_start(skb, 4215 IFLA_STATS_LINK_XSTATS); 4216 if (!attr) 4217 goto nla_put_failure; 4218 4219 err = ops->fill_linkxstats(skb, dev, prividx, *idxattr); 4220 nla_nest_end(skb, attr); 4221 if (err) 4222 goto nla_put_failure; 4223 *idxattr = 0; 4224 } 4225 } 4226 4227 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 4228 *idxattr)) { 4229 const struct rtnl_link_ops *ops = NULL; 4230 const struct net_device *master; 4231 4232 master = netdev_master_upper_dev_get(dev); 4233 if (master) 4234 ops = master->rtnl_link_ops; 4235 if (ops && ops->fill_linkxstats) { 4236 *idxattr = IFLA_STATS_LINK_XSTATS_SLAVE; 4237 attr = nla_nest_start(skb, 4238 IFLA_STATS_LINK_XSTATS_SLAVE); 4239 if (!attr) 4240 goto nla_put_failure; 4241 4242 err = ops->fill_linkxstats(skb, dev, prividx, *idxattr); 4243 nla_nest_end(skb, attr); 4244 if (err) 4245 goto nla_put_failure; 4246 *idxattr = 0; 4247 } 4248 } 4249 4250 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 4251 *idxattr)) { 4252 *idxattr = IFLA_STATS_LINK_OFFLOAD_XSTATS; 4253 attr = nla_nest_start(skb, IFLA_STATS_LINK_OFFLOAD_XSTATS); 4254 if (!attr) 4255 goto nla_put_failure; 4256 4257 err = rtnl_get_offload_stats(skb, dev, prividx); 4258 if (err == -ENODATA) 4259 nla_nest_cancel(skb, attr); 4260 else 4261 nla_nest_end(skb, attr); 4262 4263 if (err && err != -ENODATA) 4264 goto nla_put_failure; 4265 *idxattr = 0; 4266 } 4267 4268 if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, *idxattr)) { 4269 struct rtnl_af_ops *af_ops; 4270 4271 *idxattr = IFLA_STATS_AF_SPEC; 4272 attr = nla_nest_start(skb, IFLA_STATS_AF_SPEC); 4273 if (!attr) 4274 goto nla_put_failure; 4275 4276 rcu_read_lock(); 4277 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { 4278 if (af_ops->fill_stats_af) { 4279 struct nlattr *af; 4280 int err; 4281 4282 af = nla_nest_start(skb, af_ops->family); 4283 if (!af) { 4284 rcu_read_unlock(); 4285 goto nla_put_failure; 4286 } 4287 err = af_ops->fill_stats_af(skb, dev); 4288 4289 if (err == -ENODATA) { 4290 nla_nest_cancel(skb, af); 4291 } else if (err < 0) { 4292 rcu_read_unlock(); 4293 goto nla_put_failure; 4294 } 4295 4296 nla_nest_end(skb, af); 4297 } 4298 } 4299 rcu_read_unlock(); 4300 4301 nla_nest_end(skb, attr); 4302 4303 *idxattr = 0; 4304 } 4305 4306 nlmsg_end(skb, nlh); 4307 4308 return 0; 4309 4310 nla_put_failure: 4311 /* not a multi message or no progress mean a real error */ 4312 if (!(flags & NLM_F_MULTI) || s_prividx == *prividx) 4313 nlmsg_cancel(skb, nlh); 4314 else 4315 nlmsg_end(skb, nlh); 4316 4317 return -EMSGSIZE; 4318 } 4319 4320 static size_t if_nlmsg_stats_size(const struct net_device *dev, 4321 u32 filter_mask) 4322 { 4323 size_t size = 0; 4324 4325 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, 0)) 4326 size += nla_total_size_64bit(sizeof(struct rtnl_link_stats64)); 4327 4328 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, 0)) { 4329 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 4330 int attr = IFLA_STATS_LINK_XSTATS; 4331 4332 if (ops && ops->get_linkxstats_size) { 4333 size += nla_total_size(ops->get_linkxstats_size(dev, 4334 attr)); 4335 /* for IFLA_STATS_LINK_XSTATS */ 4336 size += nla_total_size(0); 4337 } 4338 } 4339 4340 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 0)) { 4341 struct net_device *_dev = (struct net_device *)dev; 4342 const struct rtnl_link_ops *ops = NULL; 4343 const struct net_device *master; 4344 4345 /* netdev_master_upper_dev_get can't take const */ 4346 master = netdev_master_upper_dev_get(_dev); 4347 if (master) 4348 ops = master->rtnl_link_ops; 4349 if (ops && ops->get_linkxstats_size) { 4350 int attr = IFLA_STATS_LINK_XSTATS_SLAVE; 4351 4352 size += nla_total_size(ops->get_linkxstats_size(dev, 4353 attr)); 4354 /* for IFLA_STATS_LINK_XSTATS_SLAVE */ 4355 size += nla_total_size(0); 4356 } 4357 } 4358 4359 if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 0)) 4360 size += rtnl_get_offload_stats_size(dev); 4361 4362 if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, 0)) { 4363 struct rtnl_af_ops *af_ops; 4364 4365 /* for IFLA_STATS_AF_SPEC */ 4366 size += nla_total_size(0); 4367 4368 rcu_read_lock(); 4369 list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { 4370 if (af_ops->get_stats_af_size) { 4371 size += nla_total_size( 4372 af_ops->get_stats_af_size(dev)); 4373 4374 /* for AF_* */ 4375 size += nla_total_size(0); 4376 } 4377 } 4378 rcu_read_unlock(); 4379 } 4380 4381 return size; 4382 } 4383 4384 static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh, 4385 struct netlink_ext_ack *extack) 4386 { 4387 struct net *net = sock_net(skb->sk); 4388 struct net_device *dev = NULL; 4389 int idxattr = 0, prividx = 0; 4390 struct if_stats_msg *ifsm; 4391 struct sk_buff *nskb; 4392 u32 filter_mask; 4393 int err; 4394 4395 if (nlmsg_len(nlh) < sizeof(*ifsm)) 4396 return -EINVAL; 4397 4398 ifsm = nlmsg_data(nlh); 4399 if (ifsm->ifindex > 0) 4400 dev = __dev_get_by_index(net, ifsm->ifindex); 4401 else 4402 return -EINVAL; 4403 4404 if (!dev) 4405 return -ENODEV; 4406 4407 filter_mask = ifsm->filter_mask; 4408 if (!filter_mask) 4409 return -EINVAL; 4410 4411 nskb = nlmsg_new(if_nlmsg_stats_size(dev, filter_mask), GFP_KERNEL); 4412 if (!nskb) 4413 return -ENOBUFS; 4414 4415 err = rtnl_fill_statsinfo(nskb, dev, RTM_NEWSTATS, 4416 NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0, 4417 0, filter_mask, &idxattr, &prividx); 4418 if (err < 0) { 4419 /* -EMSGSIZE implies BUG in if_nlmsg_stats_size */ 4420 WARN_ON(err == -EMSGSIZE); 4421 kfree_skb(nskb); 4422 } else { 4423 err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid); 4424 } 4425 4426 return err; 4427 } 4428 4429 static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb) 4430 { 4431 int h, s_h, err, s_idx, s_idxattr, s_prividx; 4432 struct net *net = sock_net(skb->sk); 4433 unsigned int flags = NLM_F_MULTI; 4434 struct if_stats_msg *ifsm; 4435 struct hlist_head *head; 4436 struct net_device *dev; 4437 u32 filter_mask = 0; 4438 int idx = 0; 4439 4440 s_h = cb->args[0]; 4441 s_idx = cb->args[1]; 4442 s_idxattr = cb->args[2]; 4443 s_prividx = cb->args[3]; 4444 4445 cb->seq = net->dev_base_seq; 4446 4447 if (nlmsg_len(cb->nlh) < sizeof(*ifsm)) 4448 return -EINVAL; 4449 4450 ifsm = nlmsg_data(cb->nlh); 4451 filter_mask = ifsm->filter_mask; 4452 if (!filter_mask) 4453 return -EINVAL; 4454 4455 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 4456 idx = 0; 4457 head = &net->dev_index_head[h]; 4458 hlist_for_each_entry(dev, head, index_hlist) { 4459 if (idx < s_idx) 4460 goto cont; 4461 err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS, 4462 NETLINK_CB(cb->skb).portid, 4463 cb->nlh->nlmsg_seq, 0, 4464 flags, filter_mask, 4465 &s_idxattr, &s_prividx); 4466 /* If we ran out of room on the first message, 4467 * we're in trouble 4468 */ 4469 WARN_ON((err == -EMSGSIZE) && (skb->len == 0)); 4470 4471 if (err < 0) 4472 goto out; 4473 s_prividx = 0; 4474 s_idxattr = 0; 4475 nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 4476 cont: 4477 idx++; 4478 } 4479 } 4480 out: 4481 cb->args[3] = s_prividx; 4482 cb->args[2] = s_idxattr; 4483 cb->args[1] = idx; 4484 cb->args[0] = h; 4485 4486 return skb->len; 4487 } 4488 4489 /* Process one rtnetlink message. */ 4490 4491 static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, 4492 struct netlink_ext_ack *extack) 4493 { 4494 struct net *net = sock_net(skb->sk); 4495 struct rtnl_link *link; 4496 struct module *owner; 4497 int err = -EOPNOTSUPP; 4498 rtnl_doit_func doit; 4499 unsigned int flags; 4500 int kind; 4501 int family; 4502 int type; 4503 4504 type = nlh->nlmsg_type; 4505 if (type > RTM_MAX) 4506 return -EOPNOTSUPP; 4507 4508 type -= RTM_BASE; 4509 4510 /* All the messages must have at least 1 byte length */ 4511 if (nlmsg_len(nlh) < sizeof(struct rtgenmsg)) 4512 return 0; 4513 4514 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family; 4515 kind = type&3; 4516 4517 if (kind != 2 && !netlink_net_capable(skb, CAP_NET_ADMIN)) 4518 return -EPERM; 4519 4520 rcu_read_lock(); 4521 if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) { 4522 struct sock *rtnl; 4523 rtnl_dumpit_func dumpit; 4524 u16 min_dump_alloc = 0; 4525 4526 link = rtnl_get_link(family, type); 4527 if (!link || !link->dumpit) { 4528 family = PF_UNSPEC; 4529 link = rtnl_get_link(family, type); 4530 if (!link || !link->dumpit) 4531 goto err_unlock; 4532 } 4533 owner = link->owner; 4534 dumpit = link->dumpit; 4535 4536 if (type == RTM_GETLINK - RTM_BASE) 4537 min_dump_alloc = rtnl_calcit(skb, nlh); 4538 4539 err = 0; 4540 /* need to do this before rcu_read_unlock() */ 4541 if (!try_module_get(owner)) 4542 err = -EPROTONOSUPPORT; 4543 4544 rcu_read_unlock(); 4545 4546 rtnl = net->rtnl; 4547 if (err == 0) { 4548 struct netlink_dump_control c = { 4549 .dump = dumpit, 4550 .min_dump_alloc = min_dump_alloc, 4551 .module = owner, 4552 }; 4553 err = netlink_dump_start(rtnl, skb, nlh, &c); 4554 /* netlink_dump_start() will keep a reference on 4555 * module if dump is still in progress. 4556 */ 4557 module_put(owner); 4558 } 4559 return err; 4560 } 4561 4562 link = rtnl_get_link(family, type); 4563 if (!link || !link->doit) { 4564 family = PF_UNSPEC; 4565 link = rtnl_get_link(PF_UNSPEC, type); 4566 if (!link || !link->doit) 4567 goto out_unlock; 4568 } 4569 4570 owner = link->owner; 4571 if (!try_module_get(owner)) { 4572 err = -EPROTONOSUPPORT; 4573 goto out_unlock; 4574 } 4575 4576 flags = link->flags; 4577 if (flags & RTNL_FLAG_DOIT_UNLOCKED) { 4578 doit = link->doit; 4579 rcu_read_unlock(); 4580 if (doit) 4581 err = doit(skb, nlh, extack); 4582 module_put(owner); 4583 return err; 4584 } 4585 rcu_read_unlock(); 4586 4587 rtnl_lock(); 4588 link = rtnl_get_link(family, type); 4589 if (link && link->doit) 4590 err = link->doit(skb, nlh, extack); 4591 rtnl_unlock(); 4592 4593 module_put(owner); 4594 4595 return err; 4596 4597 out_unlock: 4598 rcu_read_unlock(); 4599 return err; 4600 4601 err_unlock: 4602 rcu_read_unlock(); 4603 return -EOPNOTSUPP; 4604 } 4605 4606 static void rtnetlink_rcv(struct sk_buff *skb) 4607 { 4608 netlink_rcv_skb(skb, &rtnetlink_rcv_msg); 4609 } 4610 4611 static int rtnetlink_bind(struct net *net, int group) 4612 { 4613 switch (group) { 4614 case RTNLGRP_IPV4_MROUTE_R: 4615 case RTNLGRP_IPV6_MROUTE_R: 4616 if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) 4617 return -EPERM; 4618 break; 4619 } 4620 return 0; 4621 } 4622 4623 static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr) 4624 { 4625 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 4626 4627 switch (event) { 4628 case NETDEV_REBOOT: 4629 case NETDEV_CHANGEMTU: 4630 case NETDEV_CHANGEADDR: 4631 case NETDEV_CHANGENAME: 4632 case NETDEV_FEAT_CHANGE: 4633 case NETDEV_BONDING_FAILOVER: 4634 case NETDEV_POST_TYPE_CHANGE: 4635 case NETDEV_NOTIFY_PEERS: 4636 case NETDEV_CHANGEUPPER: 4637 case NETDEV_RESEND_IGMP: 4638 case NETDEV_CHANGEINFODATA: 4639 case NETDEV_CHANGELOWERSTATE: 4640 case NETDEV_CHANGE_TX_QUEUE_LEN: 4641 rtmsg_ifinfo_event(RTM_NEWLINK, dev, 0, rtnl_get_event(event), 4642 GFP_KERNEL, NULL, 0); 4643 break; 4644 default: 4645 break; 4646 } 4647 return NOTIFY_DONE; 4648 } 4649 4650 static struct notifier_block rtnetlink_dev_notifier = { 4651 .notifier_call = rtnetlink_event, 4652 }; 4653 4654 4655 static int __net_init rtnetlink_net_init(struct net *net) 4656 { 4657 struct sock *sk; 4658 struct netlink_kernel_cfg cfg = { 4659 .groups = RTNLGRP_MAX, 4660 .input = rtnetlink_rcv, 4661 .cb_mutex = &rtnl_mutex, 4662 .flags = NL_CFG_F_NONROOT_RECV, 4663 .bind = rtnetlink_bind, 4664 }; 4665 4666 sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg); 4667 if (!sk) 4668 return -ENOMEM; 4669 net->rtnl = sk; 4670 return 0; 4671 } 4672 4673 static void __net_exit rtnetlink_net_exit(struct net *net) 4674 { 4675 netlink_kernel_release(net->rtnl); 4676 net->rtnl = NULL; 4677 } 4678 4679 static struct pernet_operations rtnetlink_net_ops = { 4680 .init = rtnetlink_net_init, 4681 .exit = rtnetlink_net_exit, 4682 }; 4683 4684 void __init rtnetlink_init(void) 4685 { 4686 if (register_pernet_subsys(&rtnetlink_net_ops)) 4687 panic("rtnetlink_init: cannot initialize rtnetlink\n"); 4688 4689 register_netdevice_notifier(&rtnetlink_dev_notifier); 4690 4691 rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink, 4692 rtnl_dump_ifinfo, 0); 4693 rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL, 0); 4694 rtnl_register(PF_UNSPEC, RTM_NEWLINK, rtnl_newlink, NULL, 0); 4695 rtnl_register(PF_UNSPEC, RTM_DELLINK, rtnl_dellink, NULL, 0); 4696 4697 rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, 0); 4698 rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, 0); 4699 rtnl_register(PF_UNSPEC, RTM_GETNETCONF, NULL, rtnl_dump_all, 0); 4700 4701 rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, 0); 4702 rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL, 0); 4703 rtnl_register(PF_BRIDGE, RTM_GETNEIGH, NULL, rtnl_fdb_dump, 0); 4704 4705 rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, 0); 4706 rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, 0); 4707 rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, 0); 4708 4709 rtnl_register(PF_UNSPEC, RTM_GETSTATS, rtnl_stats_get, rtnl_stats_dump, 4710 0); 4711 } 4712