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/errno.h> 20 #include <linux/module.h> 21 #include <linux/types.h> 22 #include <linux/socket.h> 23 #include <linux/kernel.h> 24 #include <linux/timer.h> 25 #include <linux/string.h> 26 #include <linux/sockios.h> 27 #include <linux/net.h> 28 #include <linux/fcntl.h> 29 #include <linux/mm.h> 30 #include <linux/slab.h> 31 #include <linux/interrupt.h> 32 #include <linux/capability.h> 33 #include <linux/skbuff.h> 34 #include <linux/init.h> 35 #include <linux/security.h> 36 #include <linux/mutex.h> 37 #include <linux/if_addr.h> 38 #include <linux/if_bridge.h> 39 #include <linux/pci.h> 40 #include <linux/etherdevice.h> 41 42 #include <asm/uaccess.h> 43 44 #include <linux/inet.h> 45 #include <linux/netdevice.h> 46 #include <net/ip.h> 47 #include <net/protocol.h> 48 #include <net/arp.h> 49 #include <net/route.h> 50 #include <net/udp.h> 51 #include <net/sock.h> 52 #include <net/pkt_sched.h> 53 #include <net/fib_rules.h> 54 #include <net/rtnetlink.h> 55 #include <net/net_namespace.h> 56 57 struct rtnl_link { 58 rtnl_doit_func doit; 59 rtnl_dumpit_func dumpit; 60 rtnl_calcit_func calcit; 61 }; 62 63 static DEFINE_MUTEX(rtnl_mutex); 64 65 void rtnl_lock(void) 66 { 67 mutex_lock(&rtnl_mutex); 68 } 69 EXPORT_SYMBOL(rtnl_lock); 70 71 void __rtnl_unlock(void) 72 { 73 mutex_unlock(&rtnl_mutex); 74 } 75 76 void rtnl_unlock(void) 77 { 78 /* This fellow will unlock it for us. */ 79 netdev_run_todo(); 80 } 81 EXPORT_SYMBOL(rtnl_unlock); 82 83 int rtnl_trylock(void) 84 { 85 return mutex_trylock(&rtnl_mutex); 86 } 87 EXPORT_SYMBOL(rtnl_trylock); 88 89 int rtnl_is_locked(void) 90 { 91 return mutex_is_locked(&rtnl_mutex); 92 } 93 EXPORT_SYMBOL(rtnl_is_locked); 94 95 #ifdef CONFIG_PROVE_LOCKING 96 int lockdep_rtnl_is_held(void) 97 { 98 return lockdep_is_held(&rtnl_mutex); 99 } 100 EXPORT_SYMBOL(lockdep_rtnl_is_held); 101 #endif /* #ifdef CONFIG_PROVE_LOCKING */ 102 103 static struct rtnl_link *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1]; 104 105 static inline int rtm_msgindex(int msgtype) 106 { 107 int msgindex = msgtype - RTM_BASE; 108 109 /* 110 * msgindex < 0 implies someone tried to register a netlink 111 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that 112 * the message type has not been added to linux/rtnetlink.h 113 */ 114 BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES); 115 116 return msgindex; 117 } 118 119 static rtnl_doit_func rtnl_get_doit(int protocol, int msgindex) 120 { 121 struct rtnl_link *tab; 122 123 if (protocol <= RTNL_FAMILY_MAX) 124 tab = rtnl_msg_handlers[protocol]; 125 else 126 tab = NULL; 127 128 if (tab == NULL || tab[msgindex].doit == NULL) 129 tab = rtnl_msg_handlers[PF_UNSPEC]; 130 131 return tab[msgindex].doit; 132 } 133 134 static rtnl_dumpit_func rtnl_get_dumpit(int protocol, int msgindex) 135 { 136 struct rtnl_link *tab; 137 138 if (protocol <= RTNL_FAMILY_MAX) 139 tab = rtnl_msg_handlers[protocol]; 140 else 141 tab = NULL; 142 143 if (tab == NULL || tab[msgindex].dumpit == NULL) 144 tab = rtnl_msg_handlers[PF_UNSPEC]; 145 146 return tab[msgindex].dumpit; 147 } 148 149 static rtnl_calcit_func rtnl_get_calcit(int protocol, int msgindex) 150 { 151 struct rtnl_link *tab; 152 153 if (protocol <= RTNL_FAMILY_MAX) 154 tab = rtnl_msg_handlers[protocol]; 155 else 156 tab = NULL; 157 158 if (tab == NULL || tab[msgindex].calcit == NULL) 159 tab = rtnl_msg_handlers[PF_UNSPEC]; 160 161 return tab[msgindex].calcit; 162 } 163 164 /** 165 * __rtnl_register - Register a rtnetlink message type 166 * @protocol: Protocol family or PF_UNSPEC 167 * @msgtype: rtnetlink message type 168 * @doit: Function pointer called for each request message 169 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message 170 * @calcit: Function pointer to calc size of dump message 171 * 172 * Registers the specified function pointers (at least one of them has 173 * to be non-NULL) to be called whenever a request message for the 174 * specified protocol family and message type is received. 175 * 176 * The special protocol family PF_UNSPEC may be used to define fallback 177 * function pointers for the case when no entry for the specific protocol 178 * family exists. 179 * 180 * Returns 0 on success or a negative error code. 181 */ 182 int __rtnl_register(int protocol, int msgtype, 183 rtnl_doit_func doit, rtnl_dumpit_func dumpit, 184 rtnl_calcit_func calcit) 185 { 186 struct rtnl_link *tab; 187 int msgindex; 188 189 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX); 190 msgindex = rtm_msgindex(msgtype); 191 192 tab = rtnl_msg_handlers[protocol]; 193 if (tab == NULL) { 194 tab = kcalloc(RTM_NR_MSGTYPES, sizeof(*tab), GFP_KERNEL); 195 if (tab == NULL) 196 return -ENOBUFS; 197 198 rtnl_msg_handlers[protocol] = tab; 199 } 200 201 if (doit) 202 tab[msgindex].doit = doit; 203 204 if (dumpit) 205 tab[msgindex].dumpit = dumpit; 206 207 if (calcit) 208 tab[msgindex].calcit = calcit; 209 210 return 0; 211 } 212 EXPORT_SYMBOL_GPL(__rtnl_register); 213 214 /** 215 * rtnl_register - Register a rtnetlink message type 216 * 217 * Identical to __rtnl_register() but panics on failure. This is useful 218 * as failure of this function is very unlikely, it can only happen due 219 * to lack of memory when allocating the chain to store all message 220 * handlers for a protocol. Meant for use in init functions where lack 221 * of memory implies no sense in continuing. 222 */ 223 void rtnl_register(int protocol, int msgtype, 224 rtnl_doit_func doit, rtnl_dumpit_func dumpit, 225 rtnl_calcit_func calcit) 226 { 227 if (__rtnl_register(protocol, msgtype, doit, dumpit, calcit) < 0) 228 panic("Unable to register rtnetlink message handler, " 229 "protocol = %d, message type = %d\n", 230 protocol, msgtype); 231 } 232 EXPORT_SYMBOL_GPL(rtnl_register); 233 234 /** 235 * rtnl_unregister - Unregister a rtnetlink message type 236 * @protocol: Protocol family or PF_UNSPEC 237 * @msgtype: rtnetlink message type 238 * 239 * Returns 0 on success or a negative error code. 240 */ 241 int rtnl_unregister(int protocol, int msgtype) 242 { 243 int msgindex; 244 245 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX); 246 msgindex = rtm_msgindex(msgtype); 247 248 if (rtnl_msg_handlers[protocol] == NULL) 249 return -ENOENT; 250 251 rtnl_msg_handlers[protocol][msgindex].doit = NULL; 252 rtnl_msg_handlers[protocol][msgindex].dumpit = NULL; 253 254 return 0; 255 } 256 EXPORT_SYMBOL_GPL(rtnl_unregister); 257 258 /** 259 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol 260 * @protocol : Protocol family or PF_UNSPEC 261 * 262 * Identical to calling rtnl_unregster() for all registered message types 263 * of a certain protocol family. 264 */ 265 void rtnl_unregister_all(int protocol) 266 { 267 BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX); 268 269 kfree(rtnl_msg_handlers[protocol]); 270 rtnl_msg_handlers[protocol] = NULL; 271 } 272 EXPORT_SYMBOL_GPL(rtnl_unregister_all); 273 274 static LIST_HEAD(link_ops); 275 276 static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind) 277 { 278 const struct rtnl_link_ops *ops; 279 280 list_for_each_entry(ops, &link_ops, list) { 281 if (!strcmp(ops->kind, kind)) 282 return ops; 283 } 284 return NULL; 285 } 286 287 /** 288 * __rtnl_link_register - Register rtnl_link_ops with rtnetlink. 289 * @ops: struct rtnl_link_ops * to register 290 * 291 * The caller must hold the rtnl_mutex. This function should be used 292 * by drivers that create devices during module initialization. It 293 * must be called before registering the devices. 294 * 295 * Returns 0 on success or a negative error code. 296 */ 297 int __rtnl_link_register(struct rtnl_link_ops *ops) 298 { 299 if (rtnl_link_ops_get(ops->kind)) 300 return -EEXIST; 301 302 if (!ops->dellink) 303 ops->dellink = unregister_netdevice_queue; 304 305 list_add_tail(&ops->list, &link_ops); 306 return 0; 307 } 308 EXPORT_SYMBOL_GPL(__rtnl_link_register); 309 310 /** 311 * rtnl_link_register - Register rtnl_link_ops with rtnetlink. 312 * @ops: struct rtnl_link_ops * to register 313 * 314 * Returns 0 on success or a negative error code. 315 */ 316 int rtnl_link_register(struct rtnl_link_ops *ops) 317 { 318 int err; 319 320 rtnl_lock(); 321 err = __rtnl_link_register(ops); 322 rtnl_unlock(); 323 return err; 324 } 325 EXPORT_SYMBOL_GPL(rtnl_link_register); 326 327 static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops) 328 { 329 struct net_device *dev; 330 LIST_HEAD(list_kill); 331 332 for_each_netdev(net, dev) { 333 if (dev->rtnl_link_ops == ops) 334 ops->dellink(dev, &list_kill); 335 } 336 unregister_netdevice_many(&list_kill); 337 } 338 339 /** 340 * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink. 341 * @ops: struct rtnl_link_ops * to unregister 342 * 343 * The caller must hold the rtnl_mutex. 344 */ 345 void __rtnl_link_unregister(struct rtnl_link_ops *ops) 346 { 347 struct net *net; 348 349 for_each_net(net) { 350 __rtnl_kill_links(net, ops); 351 } 352 list_del(&ops->list); 353 } 354 EXPORT_SYMBOL_GPL(__rtnl_link_unregister); 355 356 /* Return with the rtnl_lock held when there are no network 357 * devices unregistering in any network namespace. 358 */ 359 static void rtnl_lock_unregistering_all(void) 360 { 361 struct net *net; 362 bool unregistering; 363 DEFINE_WAIT(wait); 364 365 for (;;) { 366 prepare_to_wait(&netdev_unregistering_wq, &wait, 367 TASK_UNINTERRUPTIBLE); 368 unregistering = false; 369 rtnl_lock(); 370 for_each_net(net) { 371 if (net->dev_unreg_count > 0) { 372 unregistering = true; 373 break; 374 } 375 } 376 if (!unregistering) 377 break; 378 __rtnl_unlock(); 379 schedule(); 380 } 381 finish_wait(&netdev_unregistering_wq, &wait); 382 } 383 384 /** 385 * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink. 386 * @ops: struct rtnl_link_ops * to unregister 387 */ 388 void rtnl_link_unregister(struct rtnl_link_ops *ops) 389 { 390 /* Close the race with cleanup_net() */ 391 mutex_lock(&net_mutex); 392 rtnl_lock_unregistering_all(); 393 __rtnl_link_unregister(ops); 394 rtnl_unlock(); 395 mutex_unlock(&net_mutex); 396 } 397 EXPORT_SYMBOL_GPL(rtnl_link_unregister); 398 399 static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev) 400 { 401 struct net_device *master_dev; 402 const struct rtnl_link_ops *ops; 403 404 master_dev = netdev_master_upper_dev_get((struct net_device *) dev); 405 if (!master_dev) 406 return 0; 407 ops = master_dev->rtnl_link_ops; 408 if (!ops || !ops->get_slave_size) 409 return 0; 410 /* IFLA_INFO_SLAVE_DATA + nested data */ 411 return nla_total_size(sizeof(struct nlattr)) + 412 ops->get_slave_size(master_dev, dev); 413 } 414 415 static size_t rtnl_link_get_size(const struct net_device *dev) 416 { 417 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 418 size_t size; 419 420 if (!ops) 421 return 0; 422 423 size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */ 424 nla_total_size(strlen(ops->kind) + 1); /* IFLA_INFO_KIND */ 425 426 if (ops->get_size) 427 /* IFLA_INFO_DATA + nested data */ 428 size += nla_total_size(sizeof(struct nlattr)) + 429 ops->get_size(dev); 430 431 if (ops->get_xstats_size) 432 /* IFLA_INFO_XSTATS */ 433 size += nla_total_size(ops->get_xstats_size(dev)); 434 435 size += rtnl_link_get_slave_info_data_size(dev); 436 437 return size; 438 } 439 440 static LIST_HEAD(rtnl_af_ops); 441 442 static const struct rtnl_af_ops *rtnl_af_lookup(const int family) 443 { 444 const struct rtnl_af_ops *ops; 445 446 list_for_each_entry(ops, &rtnl_af_ops, list) { 447 if (ops->family == family) 448 return ops; 449 } 450 451 return NULL; 452 } 453 454 /** 455 * rtnl_af_register - Register rtnl_af_ops with rtnetlink. 456 * @ops: struct rtnl_af_ops * to register 457 * 458 * Returns 0 on success or a negative error code. 459 */ 460 void rtnl_af_register(struct rtnl_af_ops *ops) 461 { 462 rtnl_lock(); 463 list_add_tail(&ops->list, &rtnl_af_ops); 464 rtnl_unlock(); 465 } 466 EXPORT_SYMBOL_GPL(rtnl_af_register); 467 468 /** 469 * __rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink. 470 * @ops: struct rtnl_af_ops * to unregister 471 * 472 * The caller must hold the rtnl_mutex. 473 */ 474 void __rtnl_af_unregister(struct rtnl_af_ops *ops) 475 { 476 list_del(&ops->list); 477 } 478 EXPORT_SYMBOL_GPL(__rtnl_af_unregister); 479 480 /** 481 * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink. 482 * @ops: struct rtnl_af_ops * to unregister 483 */ 484 void rtnl_af_unregister(struct rtnl_af_ops *ops) 485 { 486 rtnl_lock(); 487 __rtnl_af_unregister(ops); 488 rtnl_unlock(); 489 } 490 EXPORT_SYMBOL_GPL(rtnl_af_unregister); 491 492 static size_t rtnl_link_get_af_size(const struct net_device *dev) 493 { 494 struct rtnl_af_ops *af_ops; 495 size_t size; 496 497 /* IFLA_AF_SPEC */ 498 size = nla_total_size(sizeof(struct nlattr)); 499 500 list_for_each_entry(af_ops, &rtnl_af_ops, list) { 501 if (af_ops->get_link_af_size) { 502 /* AF_* + nested data */ 503 size += nla_total_size(sizeof(struct nlattr)) + 504 af_ops->get_link_af_size(dev); 505 } 506 } 507 508 return size; 509 } 510 511 static bool rtnl_have_link_slave_info(const struct net_device *dev) 512 { 513 struct net_device *master_dev; 514 515 master_dev = netdev_master_upper_dev_get((struct net_device *) dev); 516 if (master_dev && master_dev->rtnl_link_ops) 517 return true; 518 return false; 519 } 520 521 static int rtnl_link_slave_info_fill(struct sk_buff *skb, 522 const struct net_device *dev) 523 { 524 struct net_device *master_dev; 525 const struct rtnl_link_ops *ops; 526 struct nlattr *slave_data; 527 int err; 528 529 master_dev = netdev_master_upper_dev_get((struct net_device *) dev); 530 if (!master_dev) 531 return 0; 532 ops = master_dev->rtnl_link_ops; 533 if (!ops) 534 return 0; 535 if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0) 536 return -EMSGSIZE; 537 if (ops->fill_slave_info) { 538 slave_data = nla_nest_start(skb, IFLA_INFO_SLAVE_DATA); 539 if (!slave_data) 540 return -EMSGSIZE; 541 err = ops->fill_slave_info(skb, master_dev, dev); 542 if (err < 0) 543 goto err_cancel_slave_data; 544 nla_nest_end(skb, slave_data); 545 } 546 return 0; 547 548 err_cancel_slave_data: 549 nla_nest_cancel(skb, slave_data); 550 return err; 551 } 552 553 static int rtnl_link_info_fill(struct sk_buff *skb, 554 const struct net_device *dev) 555 { 556 const struct rtnl_link_ops *ops = dev->rtnl_link_ops; 557 struct nlattr *data; 558 int err; 559 560 if (!ops) 561 return 0; 562 if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0) 563 return -EMSGSIZE; 564 if (ops->fill_xstats) { 565 err = ops->fill_xstats(skb, dev); 566 if (err < 0) 567 return err; 568 } 569 if (ops->fill_info) { 570 data = nla_nest_start(skb, IFLA_INFO_DATA); 571 if (data == NULL) 572 return -EMSGSIZE; 573 err = ops->fill_info(skb, dev); 574 if (err < 0) 575 goto err_cancel_data; 576 nla_nest_end(skb, data); 577 } 578 return 0; 579 580 err_cancel_data: 581 nla_nest_cancel(skb, data); 582 return err; 583 } 584 585 static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev) 586 { 587 struct nlattr *linkinfo; 588 int err = -EMSGSIZE; 589 590 linkinfo = nla_nest_start(skb, IFLA_LINKINFO); 591 if (linkinfo == NULL) 592 goto out; 593 594 err = rtnl_link_info_fill(skb, dev); 595 if (err < 0) 596 goto err_cancel_link; 597 598 err = rtnl_link_slave_info_fill(skb, dev); 599 if (err < 0) 600 goto err_cancel_link; 601 602 nla_nest_end(skb, linkinfo); 603 return 0; 604 605 err_cancel_link: 606 nla_nest_cancel(skb, linkinfo); 607 out: 608 return err; 609 } 610 611 int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo) 612 { 613 struct sock *rtnl = net->rtnl; 614 int err = 0; 615 616 NETLINK_CB(skb).dst_group = group; 617 if (echo) 618 atomic_inc(&skb->users); 619 netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL); 620 if (echo) 621 err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT); 622 return err; 623 } 624 625 int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid) 626 { 627 struct sock *rtnl = net->rtnl; 628 629 return nlmsg_unicast(rtnl, skb, pid); 630 } 631 EXPORT_SYMBOL(rtnl_unicast); 632 633 void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group, 634 struct nlmsghdr *nlh, gfp_t flags) 635 { 636 struct sock *rtnl = net->rtnl; 637 int report = 0; 638 639 if (nlh) 640 report = nlmsg_report(nlh); 641 642 nlmsg_notify(rtnl, skb, pid, group, report, flags); 643 } 644 EXPORT_SYMBOL(rtnl_notify); 645 646 void rtnl_set_sk_err(struct net *net, u32 group, int error) 647 { 648 struct sock *rtnl = net->rtnl; 649 650 netlink_set_err(rtnl, 0, group, error); 651 } 652 EXPORT_SYMBOL(rtnl_set_sk_err); 653 654 int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics) 655 { 656 struct nlattr *mx; 657 int i, valid = 0; 658 659 mx = nla_nest_start(skb, RTA_METRICS); 660 if (mx == NULL) 661 return -ENOBUFS; 662 663 for (i = 0; i < RTAX_MAX; i++) { 664 if (metrics[i]) { 665 valid++; 666 if (nla_put_u32(skb, i+1, metrics[i])) 667 goto nla_put_failure; 668 } 669 } 670 671 if (!valid) { 672 nla_nest_cancel(skb, mx); 673 return 0; 674 } 675 676 return nla_nest_end(skb, mx); 677 678 nla_put_failure: 679 nla_nest_cancel(skb, mx); 680 return -EMSGSIZE; 681 } 682 EXPORT_SYMBOL(rtnetlink_put_metrics); 683 684 int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id, 685 long expires, u32 error) 686 { 687 struct rta_cacheinfo ci = { 688 .rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse), 689 .rta_used = dst->__use, 690 .rta_clntref = atomic_read(&(dst->__refcnt)), 691 .rta_error = error, 692 .rta_id = id, 693 }; 694 695 if (expires) { 696 unsigned long clock; 697 698 clock = jiffies_to_clock_t(abs(expires)); 699 clock = min_t(unsigned long, clock, INT_MAX); 700 ci.rta_expires = (expires > 0) ? clock : -clock; 701 } 702 return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci); 703 } 704 EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo); 705 706 static void set_operstate(struct net_device *dev, unsigned char transition) 707 { 708 unsigned char operstate = dev->operstate; 709 710 switch (transition) { 711 case IF_OPER_UP: 712 if ((operstate == IF_OPER_DORMANT || 713 operstate == IF_OPER_UNKNOWN) && 714 !netif_dormant(dev)) 715 operstate = IF_OPER_UP; 716 break; 717 718 case IF_OPER_DORMANT: 719 if (operstate == IF_OPER_UP || 720 operstate == IF_OPER_UNKNOWN) 721 operstate = IF_OPER_DORMANT; 722 break; 723 } 724 725 if (dev->operstate != operstate) { 726 write_lock_bh(&dev_base_lock); 727 dev->operstate = operstate; 728 write_unlock_bh(&dev_base_lock); 729 netdev_state_change(dev); 730 } 731 } 732 733 static unsigned int rtnl_dev_get_flags(const struct net_device *dev) 734 { 735 return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) | 736 (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI)); 737 } 738 739 static unsigned int rtnl_dev_combine_flags(const struct net_device *dev, 740 const struct ifinfomsg *ifm) 741 { 742 unsigned int flags = ifm->ifi_flags; 743 744 /* bugwards compatibility: ifi_change == 0 is treated as ~0 */ 745 if (ifm->ifi_change) 746 flags = (flags & ifm->ifi_change) | 747 (rtnl_dev_get_flags(dev) & ~ifm->ifi_change); 748 749 return flags; 750 } 751 752 static void copy_rtnl_link_stats(struct rtnl_link_stats *a, 753 const struct rtnl_link_stats64 *b) 754 { 755 a->rx_packets = b->rx_packets; 756 a->tx_packets = b->tx_packets; 757 a->rx_bytes = b->rx_bytes; 758 a->tx_bytes = b->tx_bytes; 759 a->rx_errors = b->rx_errors; 760 a->tx_errors = b->tx_errors; 761 a->rx_dropped = b->rx_dropped; 762 a->tx_dropped = b->tx_dropped; 763 764 a->multicast = b->multicast; 765 a->collisions = b->collisions; 766 767 a->rx_length_errors = b->rx_length_errors; 768 a->rx_over_errors = b->rx_over_errors; 769 a->rx_crc_errors = b->rx_crc_errors; 770 a->rx_frame_errors = b->rx_frame_errors; 771 a->rx_fifo_errors = b->rx_fifo_errors; 772 a->rx_missed_errors = b->rx_missed_errors; 773 774 a->tx_aborted_errors = b->tx_aborted_errors; 775 a->tx_carrier_errors = b->tx_carrier_errors; 776 a->tx_fifo_errors = b->tx_fifo_errors; 777 a->tx_heartbeat_errors = b->tx_heartbeat_errors; 778 a->tx_window_errors = b->tx_window_errors; 779 780 a->rx_compressed = b->rx_compressed; 781 a->tx_compressed = b->tx_compressed; 782 } 783 784 static void copy_rtnl_link_stats64(void *v, const struct rtnl_link_stats64 *b) 785 { 786 memcpy(v, b, sizeof(*b)); 787 } 788 789 /* All VF info */ 790 static inline int rtnl_vfinfo_size(const struct net_device *dev, 791 u32 ext_filter_mask) 792 { 793 if (dev->dev.parent && dev_is_pci(dev->dev.parent) && 794 (ext_filter_mask & RTEXT_FILTER_VF)) { 795 int num_vfs = dev_num_vf(dev->dev.parent); 796 size_t size = nla_total_size(sizeof(struct nlattr)); 797 size += nla_total_size(num_vfs * sizeof(struct nlattr)); 798 size += num_vfs * 799 (nla_total_size(sizeof(struct ifla_vf_mac)) + 800 nla_total_size(sizeof(struct ifla_vf_vlan)) + 801 nla_total_size(sizeof(struct ifla_vf_tx_rate)) + 802 nla_total_size(sizeof(struct ifla_vf_spoofchk))); 803 return size; 804 } else 805 return 0; 806 } 807 808 static size_t rtnl_port_size(const struct net_device *dev, 809 u32 ext_filter_mask) 810 { 811 size_t port_size = nla_total_size(4) /* PORT_VF */ 812 + nla_total_size(PORT_PROFILE_MAX) /* PORT_PROFILE */ 813 + nla_total_size(sizeof(struct ifla_port_vsi)) 814 /* PORT_VSI_TYPE */ 815 + nla_total_size(PORT_UUID_MAX) /* PORT_INSTANCE_UUID */ 816 + nla_total_size(PORT_UUID_MAX) /* PORT_HOST_UUID */ 817 + nla_total_size(1) /* PROT_VDP_REQUEST */ 818 + nla_total_size(2); /* PORT_VDP_RESPONSE */ 819 size_t vf_ports_size = nla_total_size(sizeof(struct nlattr)); 820 size_t vf_port_size = nla_total_size(sizeof(struct nlattr)) 821 + port_size; 822 size_t port_self_size = nla_total_size(sizeof(struct nlattr)) 823 + port_size; 824 825 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent || 826 !(ext_filter_mask & RTEXT_FILTER_VF)) 827 return 0; 828 if (dev_num_vf(dev->dev.parent)) 829 return port_self_size + vf_ports_size + 830 vf_port_size * dev_num_vf(dev->dev.parent); 831 else 832 return port_self_size; 833 } 834 835 static noinline size_t if_nlmsg_size(const struct net_device *dev, 836 u32 ext_filter_mask) 837 { 838 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 839 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 840 + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */ 841 + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */ 842 + nla_total_size(sizeof(struct rtnl_link_ifmap)) 843 + nla_total_size(sizeof(struct rtnl_link_stats)) 844 + nla_total_size(sizeof(struct rtnl_link_stats64)) 845 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 846 + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */ 847 + nla_total_size(4) /* IFLA_TXQLEN */ 848 + nla_total_size(4) /* IFLA_WEIGHT */ 849 + nla_total_size(4) /* IFLA_MTU */ 850 + nla_total_size(4) /* IFLA_LINK */ 851 + nla_total_size(4) /* IFLA_MASTER */ 852 + nla_total_size(1) /* IFLA_CARRIER */ 853 + nla_total_size(4) /* IFLA_PROMISCUITY */ 854 + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */ 855 + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */ 856 + nla_total_size(1) /* IFLA_OPERSTATE */ 857 + nla_total_size(1) /* IFLA_LINKMODE */ 858 + nla_total_size(4) /* IFLA_CARRIER_CHANGES */ 859 + nla_total_size(ext_filter_mask 860 & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */ 861 + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */ 862 + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */ 863 + rtnl_link_get_size(dev) /* IFLA_LINKINFO */ 864 + rtnl_link_get_af_size(dev) /* IFLA_AF_SPEC */ 865 + nla_total_size(MAX_PHYS_PORT_ID_LEN); /* IFLA_PHYS_PORT_ID */ 866 } 867 868 static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev) 869 { 870 struct nlattr *vf_ports; 871 struct nlattr *vf_port; 872 int vf; 873 int err; 874 875 vf_ports = nla_nest_start(skb, IFLA_VF_PORTS); 876 if (!vf_ports) 877 return -EMSGSIZE; 878 879 for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) { 880 vf_port = nla_nest_start(skb, IFLA_VF_PORT); 881 if (!vf_port) 882 goto nla_put_failure; 883 if (nla_put_u32(skb, IFLA_PORT_VF, vf)) 884 goto nla_put_failure; 885 err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb); 886 if (err == -EMSGSIZE) 887 goto nla_put_failure; 888 if (err) { 889 nla_nest_cancel(skb, vf_port); 890 continue; 891 } 892 nla_nest_end(skb, vf_port); 893 } 894 895 nla_nest_end(skb, vf_ports); 896 897 return 0; 898 899 nla_put_failure: 900 nla_nest_cancel(skb, vf_ports); 901 return -EMSGSIZE; 902 } 903 904 static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev) 905 { 906 struct nlattr *port_self; 907 int err; 908 909 port_self = nla_nest_start(skb, IFLA_PORT_SELF); 910 if (!port_self) 911 return -EMSGSIZE; 912 913 err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb); 914 if (err) { 915 nla_nest_cancel(skb, port_self); 916 return (err == -EMSGSIZE) ? err : 0; 917 } 918 919 nla_nest_end(skb, port_self); 920 921 return 0; 922 } 923 924 static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev, 925 u32 ext_filter_mask) 926 { 927 int err; 928 929 if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent || 930 !(ext_filter_mask & RTEXT_FILTER_VF)) 931 return 0; 932 933 err = rtnl_port_self_fill(skb, dev); 934 if (err) 935 return err; 936 937 if (dev_num_vf(dev->dev.parent)) { 938 err = rtnl_vf_ports_fill(skb, dev); 939 if (err) 940 return err; 941 } 942 943 return 0; 944 } 945 946 static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev) 947 { 948 int err; 949 struct netdev_phys_port_id ppid; 950 951 err = dev_get_phys_port_id(dev, &ppid); 952 if (err) { 953 if (err == -EOPNOTSUPP) 954 return 0; 955 return err; 956 } 957 958 if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id)) 959 return -EMSGSIZE; 960 961 return 0; 962 } 963 964 static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, 965 int type, u32 pid, u32 seq, u32 change, 966 unsigned int flags, u32 ext_filter_mask) 967 { 968 struct ifinfomsg *ifm; 969 struct nlmsghdr *nlh; 970 struct rtnl_link_stats64 temp; 971 const struct rtnl_link_stats64 *stats; 972 struct nlattr *attr, *af_spec; 973 struct rtnl_af_ops *af_ops; 974 struct net_device *upper_dev = netdev_master_upper_dev_get(dev); 975 976 ASSERT_RTNL(); 977 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags); 978 if (nlh == NULL) 979 return -EMSGSIZE; 980 981 ifm = nlmsg_data(nlh); 982 ifm->ifi_family = AF_UNSPEC; 983 ifm->__ifi_pad = 0; 984 ifm->ifi_type = dev->type; 985 ifm->ifi_index = dev->ifindex; 986 ifm->ifi_flags = dev_get_flags(dev); 987 ifm->ifi_change = change; 988 989 if (nla_put_string(skb, IFLA_IFNAME, dev->name) || 990 nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) || 991 nla_put_u8(skb, IFLA_OPERSTATE, 992 netif_running(dev) ? dev->operstate : IF_OPER_DOWN) || 993 nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) || 994 nla_put_u32(skb, IFLA_MTU, dev->mtu) || 995 nla_put_u32(skb, IFLA_GROUP, dev->group) || 996 nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) || 997 nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) || 998 #ifdef CONFIG_RPS 999 nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) || 1000 #endif 1001 (dev->ifindex != dev->iflink && 1002 nla_put_u32(skb, IFLA_LINK, dev->iflink)) || 1003 (upper_dev && 1004 nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex)) || 1005 nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) || 1006 (dev->qdisc && 1007 nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) || 1008 (dev->ifalias && 1009 nla_put_string(skb, IFLA_IFALIAS, dev->ifalias)) || 1010 nla_put_u32(skb, IFLA_CARRIER_CHANGES, 1011 atomic_read(&dev->carrier_changes))) 1012 goto nla_put_failure; 1013 1014 if (1) { 1015 struct rtnl_link_ifmap map = { 1016 .mem_start = dev->mem_start, 1017 .mem_end = dev->mem_end, 1018 .base_addr = dev->base_addr, 1019 .irq = dev->irq, 1020 .dma = dev->dma, 1021 .port = dev->if_port, 1022 }; 1023 if (nla_put(skb, IFLA_MAP, sizeof(map), &map)) 1024 goto nla_put_failure; 1025 } 1026 1027 if (dev->addr_len) { 1028 if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) || 1029 nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast)) 1030 goto nla_put_failure; 1031 } 1032 1033 if (rtnl_phys_port_id_fill(skb, dev)) 1034 goto nla_put_failure; 1035 1036 attr = nla_reserve(skb, IFLA_STATS, 1037 sizeof(struct rtnl_link_stats)); 1038 if (attr == NULL) 1039 goto nla_put_failure; 1040 1041 stats = dev_get_stats(dev, &temp); 1042 copy_rtnl_link_stats(nla_data(attr), stats); 1043 1044 attr = nla_reserve(skb, IFLA_STATS64, 1045 sizeof(struct rtnl_link_stats64)); 1046 if (attr == NULL) 1047 goto nla_put_failure; 1048 copy_rtnl_link_stats64(nla_data(attr), stats); 1049 1050 if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF) && 1051 nla_put_u32(skb, IFLA_NUM_VF, dev_num_vf(dev->dev.parent))) 1052 goto nla_put_failure; 1053 1054 if (dev->netdev_ops->ndo_get_vf_config && dev->dev.parent 1055 && (ext_filter_mask & RTEXT_FILTER_VF)) { 1056 int i; 1057 1058 struct nlattr *vfinfo, *vf; 1059 int num_vfs = dev_num_vf(dev->dev.parent); 1060 1061 vfinfo = nla_nest_start(skb, IFLA_VFINFO_LIST); 1062 if (!vfinfo) 1063 goto nla_put_failure; 1064 for (i = 0; i < num_vfs; i++) { 1065 struct ifla_vf_info ivi; 1066 struct ifla_vf_mac vf_mac; 1067 struct ifla_vf_vlan vf_vlan; 1068 struct ifla_vf_tx_rate vf_tx_rate; 1069 struct ifla_vf_spoofchk vf_spoofchk; 1070 struct ifla_vf_link_state vf_linkstate; 1071 1072 /* 1073 * Not all SR-IOV capable drivers support the 1074 * spoofcheck query. Preset to -1 so the user 1075 * space tool can detect that the driver didn't 1076 * report anything. 1077 */ 1078 ivi.spoofchk = -1; 1079 memset(ivi.mac, 0, sizeof(ivi.mac)); 1080 /* The default value for VF link state is "auto" 1081 * IFLA_VF_LINK_STATE_AUTO which equals zero 1082 */ 1083 ivi.linkstate = 0; 1084 if (dev->netdev_ops->ndo_get_vf_config(dev, i, &ivi)) 1085 break; 1086 vf_mac.vf = 1087 vf_vlan.vf = 1088 vf_tx_rate.vf = 1089 vf_spoofchk.vf = 1090 vf_linkstate.vf = ivi.vf; 1091 1092 memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac)); 1093 vf_vlan.vlan = ivi.vlan; 1094 vf_vlan.qos = ivi.qos; 1095 vf_tx_rate.rate = ivi.tx_rate; 1096 vf_spoofchk.setting = ivi.spoofchk; 1097 vf_linkstate.link_state = ivi.linkstate; 1098 vf = nla_nest_start(skb, IFLA_VF_INFO); 1099 if (!vf) { 1100 nla_nest_cancel(skb, vfinfo); 1101 goto nla_put_failure; 1102 } 1103 if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) || 1104 nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) || 1105 nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate), 1106 &vf_tx_rate) || 1107 nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk), 1108 &vf_spoofchk) || 1109 nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate), 1110 &vf_linkstate)) 1111 goto nla_put_failure; 1112 nla_nest_end(skb, vf); 1113 } 1114 nla_nest_end(skb, vfinfo); 1115 } 1116 1117 if (rtnl_port_fill(skb, dev, ext_filter_mask)) 1118 goto nla_put_failure; 1119 1120 if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) { 1121 if (rtnl_link_fill(skb, dev) < 0) 1122 goto nla_put_failure; 1123 } 1124 1125 if (!(af_spec = nla_nest_start(skb, IFLA_AF_SPEC))) 1126 goto nla_put_failure; 1127 1128 list_for_each_entry(af_ops, &rtnl_af_ops, list) { 1129 if (af_ops->fill_link_af) { 1130 struct nlattr *af; 1131 int err; 1132 1133 if (!(af = nla_nest_start(skb, af_ops->family))) 1134 goto nla_put_failure; 1135 1136 err = af_ops->fill_link_af(skb, dev); 1137 1138 /* 1139 * Caller may return ENODATA to indicate that there 1140 * was no data to be dumped. This is not an error, it 1141 * means we should trim the attribute header and 1142 * continue. 1143 */ 1144 if (err == -ENODATA) 1145 nla_nest_cancel(skb, af); 1146 else if (err < 0) 1147 goto nla_put_failure; 1148 1149 nla_nest_end(skb, af); 1150 } 1151 } 1152 1153 nla_nest_end(skb, af_spec); 1154 1155 return nlmsg_end(skb, nlh); 1156 1157 nla_put_failure: 1158 nlmsg_cancel(skb, nlh); 1159 return -EMSGSIZE; 1160 } 1161 1162 static const struct nla_policy ifla_policy[IFLA_MAX+1] = { 1163 [IFLA_IFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ-1 }, 1164 [IFLA_ADDRESS] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, 1165 [IFLA_BROADCAST] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, 1166 [IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) }, 1167 [IFLA_MTU] = { .type = NLA_U32 }, 1168 [IFLA_LINK] = { .type = NLA_U32 }, 1169 [IFLA_MASTER] = { .type = NLA_U32 }, 1170 [IFLA_CARRIER] = { .type = NLA_U8 }, 1171 [IFLA_TXQLEN] = { .type = NLA_U32 }, 1172 [IFLA_WEIGHT] = { .type = NLA_U32 }, 1173 [IFLA_OPERSTATE] = { .type = NLA_U8 }, 1174 [IFLA_LINKMODE] = { .type = NLA_U8 }, 1175 [IFLA_LINKINFO] = { .type = NLA_NESTED }, 1176 [IFLA_NET_NS_PID] = { .type = NLA_U32 }, 1177 [IFLA_NET_NS_FD] = { .type = NLA_U32 }, 1178 [IFLA_IFALIAS] = { .type = NLA_STRING, .len = IFALIASZ-1 }, 1179 [IFLA_VFINFO_LIST] = {. type = NLA_NESTED }, 1180 [IFLA_VF_PORTS] = { .type = NLA_NESTED }, 1181 [IFLA_PORT_SELF] = { .type = NLA_NESTED }, 1182 [IFLA_AF_SPEC] = { .type = NLA_NESTED }, 1183 [IFLA_EXT_MASK] = { .type = NLA_U32 }, 1184 [IFLA_PROMISCUITY] = { .type = NLA_U32 }, 1185 [IFLA_NUM_TX_QUEUES] = { .type = NLA_U32 }, 1186 [IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 }, 1187 [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_PORT_ID_LEN }, 1188 [IFLA_CARRIER_CHANGES] = { .type = NLA_U32 }, /* ignored */ 1189 }; 1190 1191 static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = { 1192 [IFLA_INFO_KIND] = { .type = NLA_STRING }, 1193 [IFLA_INFO_DATA] = { .type = NLA_NESTED }, 1194 [IFLA_INFO_SLAVE_KIND] = { .type = NLA_STRING }, 1195 [IFLA_INFO_SLAVE_DATA] = { .type = NLA_NESTED }, 1196 }; 1197 1198 static const struct nla_policy ifla_vfinfo_policy[IFLA_VF_INFO_MAX+1] = { 1199 [IFLA_VF_INFO] = { .type = NLA_NESTED }, 1200 }; 1201 1202 static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = { 1203 [IFLA_VF_MAC] = { .type = NLA_BINARY, 1204 .len = sizeof(struct ifla_vf_mac) }, 1205 [IFLA_VF_VLAN] = { .type = NLA_BINARY, 1206 .len = sizeof(struct ifla_vf_vlan) }, 1207 [IFLA_VF_TX_RATE] = { .type = NLA_BINARY, 1208 .len = sizeof(struct ifla_vf_tx_rate) }, 1209 [IFLA_VF_SPOOFCHK] = { .type = NLA_BINARY, 1210 .len = sizeof(struct ifla_vf_spoofchk) }, 1211 }; 1212 1213 static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = { 1214 [IFLA_PORT_VF] = { .type = NLA_U32 }, 1215 [IFLA_PORT_PROFILE] = { .type = NLA_STRING, 1216 .len = PORT_PROFILE_MAX }, 1217 [IFLA_PORT_VSI_TYPE] = { .type = NLA_BINARY, 1218 .len = sizeof(struct ifla_port_vsi)}, 1219 [IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY, 1220 .len = PORT_UUID_MAX }, 1221 [IFLA_PORT_HOST_UUID] = { .type = NLA_STRING, 1222 .len = PORT_UUID_MAX }, 1223 [IFLA_PORT_REQUEST] = { .type = NLA_U8, }, 1224 [IFLA_PORT_RESPONSE] = { .type = NLA_U16, }, 1225 }; 1226 1227 static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) 1228 { 1229 struct net *net = sock_net(skb->sk); 1230 int h, s_h; 1231 int idx = 0, s_idx; 1232 struct net_device *dev; 1233 struct hlist_head *head; 1234 struct nlattr *tb[IFLA_MAX+1]; 1235 u32 ext_filter_mask = 0; 1236 int err; 1237 1238 s_h = cb->args[0]; 1239 s_idx = cb->args[1]; 1240 1241 rcu_read_lock(); 1242 cb->seq = net->dev_base_seq; 1243 1244 if (nlmsg_parse(cb->nlh, sizeof(struct ifinfomsg), tb, IFLA_MAX, 1245 ifla_policy) >= 0) { 1246 1247 if (tb[IFLA_EXT_MASK]) 1248 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]); 1249 } 1250 1251 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) { 1252 idx = 0; 1253 head = &net->dev_index_head[h]; 1254 hlist_for_each_entry_rcu(dev, head, index_hlist) { 1255 if (idx < s_idx) 1256 goto cont; 1257 err = rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK, 1258 NETLINK_CB(cb->skb).portid, 1259 cb->nlh->nlmsg_seq, 0, 1260 NLM_F_MULTI, 1261 ext_filter_mask); 1262 /* If we ran out of room on the first message, 1263 * we're in trouble 1264 */ 1265 WARN_ON((err == -EMSGSIZE) && (skb->len == 0)); 1266 1267 if (err <= 0) 1268 goto out; 1269 1270 nl_dump_check_consistent(cb, nlmsg_hdr(skb)); 1271 cont: 1272 idx++; 1273 } 1274 } 1275 out: 1276 rcu_read_unlock(); 1277 cb->args[1] = idx; 1278 cb->args[0] = h; 1279 1280 return skb->len; 1281 } 1282 1283 int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len) 1284 { 1285 return nla_parse(tb, IFLA_MAX, head, len, ifla_policy); 1286 } 1287 EXPORT_SYMBOL(rtnl_nla_parse_ifla); 1288 1289 struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[]) 1290 { 1291 struct net *net; 1292 /* Examine the link attributes and figure out which 1293 * network namespace we are talking about. 1294 */ 1295 if (tb[IFLA_NET_NS_PID]) 1296 net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID])); 1297 else if (tb[IFLA_NET_NS_FD]) 1298 net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD])); 1299 else 1300 net = get_net(src_net); 1301 return net; 1302 } 1303 EXPORT_SYMBOL(rtnl_link_get_net); 1304 1305 static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[]) 1306 { 1307 if (dev) { 1308 if (tb[IFLA_ADDRESS] && 1309 nla_len(tb[IFLA_ADDRESS]) < dev->addr_len) 1310 return -EINVAL; 1311 1312 if (tb[IFLA_BROADCAST] && 1313 nla_len(tb[IFLA_BROADCAST]) < dev->addr_len) 1314 return -EINVAL; 1315 } 1316 1317 if (tb[IFLA_AF_SPEC]) { 1318 struct nlattr *af; 1319 int rem, err; 1320 1321 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) { 1322 const struct rtnl_af_ops *af_ops; 1323 1324 if (!(af_ops = rtnl_af_lookup(nla_type(af)))) 1325 return -EAFNOSUPPORT; 1326 1327 if (!af_ops->set_link_af) 1328 return -EOPNOTSUPP; 1329 1330 if (af_ops->validate_link_af) { 1331 err = af_ops->validate_link_af(dev, af); 1332 if (err < 0) 1333 return err; 1334 } 1335 } 1336 } 1337 1338 return 0; 1339 } 1340 1341 static int do_setvfinfo(struct net_device *dev, struct nlattr *attr) 1342 { 1343 int rem, err = -EINVAL; 1344 struct nlattr *vf; 1345 const struct net_device_ops *ops = dev->netdev_ops; 1346 1347 nla_for_each_nested(vf, attr, rem) { 1348 switch (nla_type(vf)) { 1349 case IFLA_VF_MAC: { 1350 struct ifla_vf_mac *ivm; 1351 ivm = nla_data(vf); 1352 err = -EOPNOTSUPP; 1353 if (ops->ndo_set_vf_mac) 1354 err = ops->ndo_set_vf_mac(dev, ivm->vf, 1355 ivm->mac); 1356 break; 1357 } 1358 case IFLA_VF_VLAN: { 1359 struct ifla_vf_vlan *ivv; 1360 ivv = nla_data(vf); 1361 err = -EOPNOTSUPP; 1362 if (ops->ndo_set_vf_vlan) 1363 err = ops->ndo_set_vf_vlan(dev, ivv->vf, 1364 ivv->vlan, 1365 ivv->qos); 1366 break; 1367 } 1368 case IFLA_VF_TX_RATE: { 1369 struct ifla_vf_tx_rate *ivt; 1370 ivt = nla_data(vf); 1371 err = -EOPNOTSUPP; 1372 if (ops->ndo_set_vf_tx_rate) 1373 err = ops->ndo_set_vf_tx_rate(dev, ivt->vf, 1374 ivt->rate); 1375 break; 1376 } 1377 case IFLA_VF_SPOOFCHK: { 1378 struct ifla_vf_spoofchk *ivs; 1379 ivs = nla_data(vf); 1380 err = -EOPNOTSUPP; 1381 if (ops->ndo_set_vf_spoofchk) 1382 err = ops->ndo_set_vf_spoofchk(dev, ivs->vf, 1383 ivs->setting); 1384 break; 1385 } 1386 case IFLA_VF_LINK_STATE: { 1387 struct ifla_vf_link_state *ivl; 1388 ivl = nla_data(vf); 1389 err = -EOPNOTSUPP; 1390 if (ops->ndo_set_vf_link_state) 1391 err = ops->ndo_set_vf_link_state(dev, ivl->vf, 1392 ivl->link_state); 1393 break; 1394 } 1395 default: 1396 err = -EINVAL; 1397 break; 1398 } 1399 if (err) 1400 break; 1401 } 1402 return err; 1403 } 1404 1405 static int do_set_master(struct net_device *dev, int ifindex) 1406 { 1407 struct net_device *upper_dev = netdev_master_upper_dev_get(dev); 1408 const struct net_device_ops *ops; 1409 int err; 1410 1411 if (upper_dev) { 1412 if (upper_dev->ifindex == ifindex) 1413 return 0; 1414 ops = upper_dev->netdev_ops; 1415 if (ops->ndo_del_slave) { 1416 err = ops->ndo_del_slave(upper_dev, dev); 1417 if (err) 1418 return err; 1419 } else { 1420 return -EOPNOTSUPP; 1421 } 1422 } 1423 1424 if (ifindex) { 1425 upper_dev = __dev_get_by_index(dev_net(dev), ifindex); 1426 if (!upper_dev) 1427 return -EINVAL; 1428 ops = upper_dev->netdev_ops; 1429 if (ops->ndo_add_slave) { 1430 err = ops->ndo_add_slave(upper_dev, dev); 1431 if (err) 1432 return err; 1433 } else { 1434 return -EOPNOTSUPP; 1435 } 1436 } 1437 return 0; 1438 } 1439 1440 static int do_setlink(const struct sk_buff *skb, 1441 struct net_device *dev, struct ifinfomsg *ifm, 1442 struct nlattr **tb, char *ifname, int modified) 1443 { 1444 const struct net_device_ops *ops = dev->netdev_ops; 1445 int err; 1446 1447 if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]) { 1448 struct net *net = rtnl_link_get_net(dev_net(dev), tb); 1449 if (IS_ERR(net)) { 1450 err = PTR_ERR(net); 1451 goto errout; 1452 } 1453 if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) { 1454 err = -EPERM; 1455 goto errout; 1456 } 1457 err = dev_change_net_namespace(dev, net, ifname); 1458 put_net(net); 1459 if (err) 1460 goto errout; 1461 modified = 1; 1462 } 1463 1464 if (tb[IFLA_MAP]) { 1465 struct rtnl_link_ifmap *u_map; 1466 struct ifmap k_map; 1467 1468 if (!ops->ndo_set_config) { 1469 err = -EOPNOTSUPP; 1470 goto errout; 1471 } 1472 1473 if (!netif_device_present(dev)) { 1474 err = -ENODEV; 1475 goto errout; 1476 } 1477 1478 u_map = nla_data(tb[IFLA_MAP]); 1479 k_map.mem_start = (unsigned long) u_map->mem_start; 1480 k_map.mem_end = (unsigned long) u_map->mem_end; 1481 k_map.base_addr = (unsigned short) u_map->base_addr; 1482 k_map.irq = (unsigned char) u_map->irq; 1483 k_map.dma = (unsigned char) u_map->dma; 1484 k_map.port = (unsigned char) u_map->port; 1485 1486 err = ops->ndo_set_config(dev, &k_map); 1487 if (err < 0) 1488 goto errout; 1489 1490 modified = 1; 1491 } 1492 1493 if (tb[IFLA_ADDRESS]) { 1494 struct sockaddr *sa; 1495 int len; 1496 1497 len = sizeof(sa_family_t) + dev->addr_len; 1498 sa = kmalloc(len, GFP_KERNEL); 1499 if (!sa) { 1500 err = -ENOMEM; 1501 goto errout; 1502 } 1503 sa->sa_family = dev->type; 1504 memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]), 1505 dev->addr_len); 1506 err = dev_set_mac_address(dev, sa); 1507 kfree(sa); 1508 if (err) 1509 goto errout; 1510 modified = 1; 1511 } 1512 1513 if (tb[IFLA_MTU]) { 1514 err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU])); 1515 if (err < 0) 1516 goto errout; 1517 modified = 1; 1518 } 1519 1520 if (tb[IFLA_GROUP]) { 1521 dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP])); 1522 modified = 1; 1523 } 1524 1525 /* 1526 * Interface selected by interface index but interface 1527 * name provided implies that a name change has been 1528 * requested. 1529 */ 1530 if (ifm->ifi_index > 0 && ifname[0]) { 1531 err = dev_change_name(dev, ifname); 1532 if (err < 0) 1533 goto errout; 1534 modified = 1; 1535 } 1536 1537 if (tb[IFLA_IFALIAS]) { 1538 err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]), 1539 nla_len(tb[IFLA_IFALIAS])); 1540 if (err < 0) 1541 goto errout; 1542 modified = 1; 1543 } 1544 1545 if (tb[IFLA_BROADCAST]) { 1546 nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len); 1547 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); 1548 } 1549 1550 if (ifm->ifi_flags || ifm->ifi_change) { 1551 err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm)); 1552 if (err < 0) 1553 goto errout; 1554 } 1555 1556 if (tb[IFLA_MASTER]) { 1557 err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER])); 1558 if (err) 1559 goto errout; 1560 modified = 1; 1561 } 1562 1563 if (tb[IFLA_CARRIER]) { 1564 err = dev_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER])); 1565 if (err) 1566 goto errout; 1567 modified = 1; 1568 } 1569 1570 if (tb[IFLA_TXQLEN]) 1571 dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]); 1572 1573 if (tb[IFLA_OPERSTATE]) 1574 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE])); 1575 1576 if (tb[IFLA_LINKMODE]) { 1577 write_lock_bh(&dev_base_lock); 1578 dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]); 1579 write_unlock_bh(&dev_base_lock); 1580 } 1581 1582 if (tb[IFLA_VFINFO_LIST]) { 1583 struct nlattr *attr; 1584 int rem; 1585 nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) { 1586 if (nla_type(attr) != IFLA_VF_INFO) { 1587 err = -EINVAL; 1588 goto errout; 1589 } 1590 err = do_setvfinfo(dev, attr); 1591 if (err < 0) 1592 goto errout; 1593 modified = 1; 1594 } 1595 } 1596 err = 0; 1597 1598 if (tb[IFLA_VF_PORTS]) { 1599 struct nlattr *port[IFLA_PORT_MAX+1]; 1600 struct nlattr *attr; 1601 int vf; 1602 int rem; 1603 1604 err = -EOPNOTSUPP; 1605 if (!ops->ndo_set_vf_port) 1606 goto errout; 1607 1608 nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) { 1609 if (nla_type(attr) != IFLA_VF_PORT) 1610 continue; 1611 err = nla_parse_nested(port, IFLA_PORT_MAX, 1612 attr, ifla_port_policy); 1613 if (err < 0) 1614 goto errout; 1615 if (!port[IFLA_PORT_VF]) { 1616 err = -EOPNOTSUPP; 1617 goto errout; 1618 } 1619 vf = nla_get_u32(port[IFLA_PORT_VF]); 1620 err = ops->ndo_set_vf_port(dev, vf, port); 1621 if (err < 0) 1622 goto errout; 1623 modified = 1; 1624 } 1625 } 1626 err = 0; 1627 1628 if (tb[IFLA_PORT_SELF]) { 1629 struct nlattr *port[IFLA_PORT_MAX+1]; 1630 1631 err = nla_parse_nested(port, IFLA_PORT_MAX, 1632 tb[IFLA_PORT_SELF], ifla_port_policy); 1633 if (err < 0) 1634 goto errout; 1635 1636 err = -EOPNOTSUPP; 1637 if (ops->ndo_set_vf_port) 1638 err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port); 1639 if (err < 0) 1640 goto errout; 1641 modified = 1; 1642 } 1643 1644 if (tb[IFLA_AF_SPEC]) { 1645 struct nlattr *af; 1646 int rem; 1647 1648 nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) { 1649 const struct rtnl_af_ops *af_ops; 1650 1651 if (!(af_ops = rtnl_af_lookup(nla_type(af)))) 1652 BUG(); 1653 1654 err = af_ops->set_link_af(dev, af); 1655 if (err < 0) 1656 goto errout; 1657 1658 modified = 1; 1659 } 1660 } 1661 err = 0; 1662 1663 errout: 1664 if (err < 0 && modified) 1665 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", 1666 dev->name); 1667 1668 return err; 1669 } 1670 1671 static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh) 1672 { 1673 struct net *net = sock_net(skb->sk); 1674 struct ifinfomsg *ifm; 1675 struct net_device *dev; 1676 int err; 1677 struct nlattr *tb[IFLA_MAX+1]; 1678 char ifname[IFNAMSIZ]; 1679 1680 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy); 1681 if (err < 0) 1682 goto errout; 1683 1684 if (tb[IFLA_IFNAME]) 1685 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 1686 else 1687 ifname[0] = '\0'; 1688 1689 err = -EINVAL; 1690 ifm = nlmsg_data(nlh); 1691 if (ifm->ifi_index > 0) 1692 dev = __dev_get_by_index(net, ifm->ifi_index); 1693 else if (tb[IFLA_IFNAME]) 1694 dev = __dev_get_by_name(net, ifname); 1695 else 1696 goto errout; 1697 1698 if (dev == NULL) { 1699 err = -ENODEV; 1700 goto errout; 1701 } 1702 1703 err = validate_linkmsg(dev, tb); 1704 if (err < 0) 1705 goto errout; 1706 1707 err = do_setlink(skb, dev, ifm, tb, ifname, 0); 1708 errout: 1709 return err; 1710 } 1711 1712 static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh) 1713 { 1714 struct net *net = sock_net(skb->sk); 1715 const struct rtnl_link_ops *ops; 1716 struct net_device *dev; 1717 struct ifinfomsg *ifm; 1718 char ifname[IFNAMSIZ]; 1719 struct nlattr *tb[IFLA_MAX+1]; 1720 int err; 1721 LIST_HEAD(list_kill); 1722 1723 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy); 1724 if (err < 0) 1725 return err; 1726 1727 if (tb[IFLA_IFNAME]) 1728 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 1729 1730 ifm = nlmsg_data(nlh); 1731 if (ifm->ifi_index > 0) 1732 dev = __dev_get_by_index(net, ifm->ifi_index); 1733 else if (tb[IFLA_IFNAME]) 1734 dev = __dev_get_by_name(net, ifname); 1735 else 1736 return -EINVAL; 1737 1738 if (!dev) 1739 return -ENODEV; 1740 1741 ops = dev->rtnl_link_ops; 1742 if (!ops) 1743 return -EOPNOTSUPP; 1744 1745 ops->dellink(dev, &list_kill); 1746 unregister_netdevice_many(&list_kill); 1747 list_del(&list_kill); 1748 return 0; 1749 } 1750 1751 int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm) 1752 { 1753 unsigned int old_flags; 1754 int err; 1755 1756 old_flags = dev->flags; 1757 if (ifm && (ifm->ifi_flags || ifm->ifi_change)) { 1758 err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm)); 1759 if (err < 0) 1760 return err; 1761 } 1762 1763 dev->rtnl_link_state = RTNL_LINK_INITIALIZED; 1764 1765 __dev_notify_flags(dev, old_flags, ~0U); 1766 return 0; 1767 } 1768 EXPORT_SYMBOL(rtnl_configure_link); 1769 1770 struct net_device *rtnl_create_link(struct net *net, 1771 char *ifname, const struct rtnl_link_ops *ops, struct nlattr *tb[]) 1772 { 1773 int err; 1774 struct net_device *dev; 1775 unsigned int num_tx_queues = 1; 1776 unsigned int num_rx_queues = 1; 1777 1778 if (tb[IFLA_NUM_TX_QUEUES]) 1779 num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]); 1780 else if (ops->get_num_tx_queues) 1781 num_tx_queues = ops->get_num_tx_queues(); 1782 1783 if (tb[IFLA_NUM_RX_QUEUES]) 1784 num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]); 1785 else if (ops->get_num_rx_queues) 1786 num_rx_queues = ops->get_num_rx_queues(); 1787 1788 err = -ENOMEM; 1789 dev = alloc_netdev_mqs(ops->priv_size, ifname, ops->setup, 1790 num_tx_queues, num_rx_queues); 1791 if (!dev) 1792 goto err; 1793 1794 dev_net_set(dev, net); 1795 dev->rtnl_link_ops = ops; 1796 dev->rtnl_link_state = RTNL_LINK_INITIALIZING; 1797 1798 if (tb[IFLA_MTU]) 1799 dev->mtu = nla_get_u32(tb[IFLA_MTU]); 1800 if (tb[IFLA_ADDRESS]) { 1801 memcpy(dev->dev_addr, nla_data(tb[IFLA_ADDRESS]), 1802 nla_len(tb[IFLA_ADDRESS])); 1803 dev->addr_assign_type = NET_ADDR_SET; 1804 } 1805 if (tb[IFLA_BROADCAST]) 1806 memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]), 1807 nla_len(tb[IFLA_BROADCAST])); 1808 if (tb[IFLA_TXQLEN]) 1809 dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]); 1810 if (tb[IFLA_OPERSTATE]) 1811 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE])); 1812 if (tb[IFLA_LINKMODE]) 1813 dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]); 1814 if (tb[IFLA_GROUP]) 1815 dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP])); 1816 1817 return dev; 1818 1819 err: 1820 return ERR_PTR(err); 1821 } 1822 EXPORT_SYMBOL(rtnl_create_link); 1823 1824 static int rtnl_group_changelink(const struct sk_buff *skb, 1825 struct net *net, int group, 1826 struct ifinfomsg *ifm, 1827 struct nlattr **tb) 1828 { 1829 struct net_device *dev; 1830 int err; 1831 1832 for_each_netdev(net, dev) { 1833 if (dev->group == group) { 1834 err = do_setlink(skb, dev, ifm, tb, NULL, 0); 1835 if (err < 0) 1836 return err; 1837 } 1838 } 1839 1840 return 0; 1841 } 1842 1843 static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh) 1844 { 1845 struct net *net = sock_net(skb->sk); 1846 const struct rtnl_link_ops *ops; 1847 const struct rtnl_link_ops *m_ops = NULL; 1848 struct net_device *dev; 1849 struct net_device *master_dev = NULL; 1850 struct ifinfomsg *ifm; 1851 char kind[MODULE_NAME_LEN]; 1852 char ifname[IFNAMSIZ]; 1853 struct nlattr *tb[IFLA_MAX+1]; 1854 struct nlattr *linkinfo[IFLA_INFO_MAX+1]; 1855 int err; 1856 1857 #ifdef CONFIG_MODULES 1858 replay: 1859 #endif 1860 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy); 1861 if (err < 0) 1862 return err; 1863 1864 if (tb[IFLA_IFNAME]) 1865 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 1866 else 1867 ifname[0] = '\0'; 1868 1869 ifm = nlmsg_data(nlh); 1870 if (ifm->ifi_index > 0) 1871 dev = __dev_get_by_index(net, ifm->ifi_index); 1872 else { 1873 if (ifname[0]) 1874 dev = __dev_get_by_name(net, ifname); 1875 else 1876 dev = NULL; 1877 } 1878 1879 if (dev) { 1880 master_dev = netdev_master_upper_dev_get(dev); 1881 if (master_dev) 1882 m_ops = master_dev->rtnl_link_ops; 1883 } 1884 1885 err = validate_linkmsg(dev, tb); 1886 if (err < 0) 1887 return err; 1888 1889 if (tb[IFLA_LINKINFO]) { 1890 err = nla_parse_nested(linkinfo, IFLA_INFO_MAX, 1891 tb[IFLA_LINKINFO], ifla_info_policy); 1892 if (err < 0) 1893 return err; 1894 } else 1895 memset(linkinfo, 0, sizeof(linkinfo)); 1896 1897 if (linkinfo[IFLA_INFO_KIND]) { 1898 nla_strlcpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind)); 1899 ops = rtnl_link_ops_get(kind); 1900 } else { 1901 kind[0] = '\0'; 1902 ops = NULL; 1903 } 1904 1905 if (1) { 1906 struct nlattr *attr[ops ? ops->maxtype + 1 : 0]; 1907 struct nlattr *slave_attr[m_ops ? m_ops->slave_maxtype + 1 : 0]; 1908 struct nlattr **data = NULL; 1909 struct nlattr **slave_data = NULL; 1910 struct net *dest_net; 1911 1912 if (ops) { 1913 if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) { 1914 err = nla_parse_nested(attr, ops->maxtype, 1915 linkinfo[IFLA_INFO_DATA], 1916 ops->policy); 1917 if (err < 0) 1918 return err; 1919 data = attr; 1920 } 1921 if (ops->validate) { 1922 err = ops->validate(tb, data); 1923 if (err < 0) 1924 return err; 1925 } 1926 } 1927 1928 if (m_ops) { 1929 if (m_ops->slave_maxtype && 1930 linkinfo[IFLA_INFO_SLAVE_DATA]) { 1931 err = nla_parse_nested(slave_attr, 1932 m_ops->slave_maxtype, 1933 linkinfo[IFLA_INFO_SLAVE_DATA], 1934 m_ops->slave_policy); 1935 if (err < 0) 1936 return err; 1937 slave_data = slave_attr; 1938 } 1939 if (m_ops->slave_validate) { 1940 err = m_ops->slave_validate(tb, slave_data); 1941 if (err < 0) 1942 return err; 1943 } 1944 } 1945 1946 if (dev) { 1947 int modified = 0; 1948 1949 if (nlh->nlmsg_flags & NLM_F_EXCL) 1950 return -EEXIST; 1951 if (nlh->nlmsg_flags & NLM_F_REPLACE) 1952 return -EOPNOTSUPP; 1953 1954 if (linkinfo[IFLA_INFO_DATA]) { 1955 if (!ops || ops != dev->rtnl_link_ops || 1956 !ops->changelink) 1957 return -EOPNOTSUPP; 1958 1959 err = ops->changelink(dev, tb, data); 1960 if (err < 0) 1961 return err; 1962 modified = 1; 1963 } 1964 1965 if (linkinfo[IFLA_INFO_SLAVE_DATA]) { 1966 if (!m_ops || !m_ops->slave_changelink) 1967 return -EOPNOTSUPP; 1968 1969 err = m_ops->slave_changelink(master_dev, dev, 1970 tb, slave_data); 1971 if (err < 0) 1972 return err; 1973 modified = 1; 1974 } 1975 1976 return do_setlink(skb, dev, ifm, tb, ifname, modified); 1977 } 1978 1979 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 1980 if (ifm->ifi_index == 0 && tb[IFLA_GROUP]) 1981 return rtnl_group_changelink(skb, net, 1982 nla_get_u32(tb[IFLA_GROUP]), 1983 ifm, tb); 1984 return -ENODEV; 1985 } 1986 1987 if (tb[IFLA_MAP] || tb[IFLA_MASTER] || tb[IFLA_PROTINFO]) 1988 return -EOPNOTSUPP; 1989 1990 if (!ops) { 1991 #ifdef CONFIG_MODULES 1992 if (kind[0]) { 1993 __rtnl_unlock(); 1994 request_module("rtnl-link-%s", kind); 1995 rtnl_lock(); 1996 ops = rtnl_link_ops_get(kind); 1997 if (ops) 1998 goto replay; 1999 } 2000 #endif 2001 return -EOPNOTSUPP; 2002 } 2003 2004 if (!ifname[0]) 2005 snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind); 2006 2007 dest_net = rtnl_link_get_net(net, tb); 2008 if (IS_ERR(dest_net)) 2009 return PTR_ERR(dest_net); 2010 2011 dev = rtnl_create_link(dest_net, ifname, ops, tb); 2012 if (IS_ERR(dev)) { 2013 err = PTR_ERR(dev); 2014 goto out; 2015 } 2016 2017 dev->ifindex = ifm->ifi_index; 2018 2019 if (ops->newlink) { 2020 err = ops->newlink(net, dev, tb, data); 2021 /* Drivers should call free_netdev() in ->destructor 2022 * and unregister it on failure so that device could be 2023 * finally freed in rtnl_unlock. 2024 */ 2025 if (err < 0) 2026 goto out; 2027 } else { 2028 err = register_netdevice(dev); 2029 if (err < 0) { 2030 free_netdev(dev); 2031 goto out; 2032 } 2033 } 2034 err = rtnl_configure_link(dev, ifm); 2035 if (err < 0) 2036 unregister_netdevice(dev); 2037 out: 2038 put_net(dest_net); 2039 return err; 2040 } 2041 } 2042 2043 static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh) 2044 { 2045 struct net *net = sock_net(skb->sk); 2046 struct ifinfomsg *ifm; 2047 char ifname[IFNAMSIZ]; 2048 struct nlattr *tb[IFLA_MAX+1]; 2049 struct net_device *dev = NULL; 2050 struct sk_buff *nskb; 2051 int err; 2052 u32 ext_filter_mask = 0; 2053 2054 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy); 2055 if (err < 0) 2056 return err; 2057 2058 if (tb[IFLA_IFNAME]) 2059 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 2060 2061 if (tb[IFLA_EXT_MASK]) 2062 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]); 2063 2064 ifm = nlmsg_data(nlh); 2065 if (ifm->ifi_index > 0) 2066 dev = __dev_get_by_index(net, ifm->ifi_index); 2067 else if (tb[IFLA_IFNAME]) 2068 dev = __dev_get_by_name(net, ifname); 2069 else 2070 return -EINVAL; 2071 2072 if (dev == NULL) 2073 return -ENODEV; 2074 2075 nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL); 2076 if (nskb == NULL) 2077 return -ENOBUFS; 2078 2079 err = rtnl_fill_ifinfo(nskb, dev, RTM_NEWLINK, NETLINK_CB(skb).portid, 2080 nlh->nlmsg_seq, 0, 0, ext_filter_mask); 2081 if (err < 0) { 2082 /* -EMSGSIZE implies BUG in if_nlmsg_size */ 2083 WARN_ON(err == -EMSGSIZE); 2084 kfree_skb(nskb); 2085 } else 2086 err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid); 2087 2088 return err; 2089 } 2090 2091 static u16 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh) 2092 { 2093 struct net *net = sock_net(skb->sk); 2094 struct net_device *dev; 2095 struct nlattr *tb[IFLA_MAX+1]; 2096 u32 ext_filter_mask = 0; 2097 u16 min_ifinfo_dump_size = 0; 2098 2099 if (nlmsg_parse(nlh, sizeof(struct ifinfomsg), tb, IFLA_MAX, 2100 ifla_policy) >= 0) { 2101 if (tb[IFLA_EXT_MASK]) 2102 ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]); 2103 } 2104 2105 if (!ext_filter_mask) 2106 return NLMSG_GOODSIZE; 2107 /* 2108 * traverse the list of net devices and compute the minimum 2109 * buffer size based upon the filter mask. 2110 */ 2111 list_for_each_entry(dev, &net->dev_base_head, dev_list) { 2112 min_ifinfo_dump_size = max_t(u16, min_ifinfo_dump_size, 2113 if_nlmsg_size(dev, 2114 ext_filter_mask)); 2115 } 2116 2117 return min_ifinfo_dump_size; 2118 } 2119 2120 static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb) 2121 { 2122 int idx; 2123 int s_idx = cb->family; 2124 2125 if (s_idx == 0) 2126 s_idx = 1; 2127 for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) { 2128 int type = cb->nlh->nlmsg_type-RTM_BASE; 2129 if (idx < s_idx || idx == PF_PACKET) 2130 continue; 2131 if (rtnl_msg_handlers[idx] == NULL || 2132 rtnl_msg_handlers[idx][type].dumpit == NULL) 2133 continue; 2134 if (idx > s_idx) { 2135 memset(&cb->args[0], 0, sizeof(cb->args)); 2136 cb->prev_seq = 0; 2137 cb->seq = 0; 2138 } 2139 if (rtnl_msg_handlers[idx][type].dumpit(skb, cb)) 2140 break; 2141 } 2142 cb->family = idx; 2143 2144 return skb->len; 2145 } 2146 2147 void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change, 2148 gfp_t flags) 2149 { 2150 struct net *net = dev_net(dev); 2151 struct sk_buff *skb; 2152 int err = -ENOBUFS; 2153 size_t if_info_size; 2154 2155 skb = nlmsg_new((if_info_size = if_nlmsg_size(dev, 0)), flags); 2156 if (skb == NULL) 2157 goto errout; 2158 2159 err = rtnl_fill_ifinfo(skb, dev, type, 0, 0, change, 0, 0); 2160 if (err < 0) { 2161 /* -EMSGSIZE implies BUG in if_nlmsg_size() */ 2162 WARN_ON(err == -EMSGSIZE); 2163 kfree_skb(skb); 2164 goto errout; 2165 } 2166 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, flags); 2167 return; 2168 errout: 2169 if (err < 0) 2170 rtnl_set_sk_err(net, RTNLGRP_LINK, err); 2171 } 2172 EXPORT_SYMBOL(rtmsg_ifinfo); 2173 2174 static int nlmsg_populate_fdb_fill(struct sk_buff *skb, 2175 struct net_device *dev, 2176 u8 *addr, u32 pid, u32 seq, 2177 int type, unsigned int flags, 2178 int nlflags) 2179 { 2180 struct nlmsghdr *nlh; 2181 struct ndmsg *ndm; 2182 2183 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags); 2184 if (!nlh) 2185 return -EMSGSIZE; 2186 2187 ndm = nlmsg_data(nlh); 2188 ndm->ndm_family = AF_BRIDGE; 2189 ndm->ndm_pad1 = 0; 2190 ndm->ndm_pad2 = 0; 2191 ndm->ndm_flags = flags; 2192 ndm->ndm_type = 0; 2193 ndm->ndm_ifindex = dev->ifindex; 2194 ndm->ndm_state = NUD_PERMANENT; 2195 2196 if (nla_put(skb, NDA_LLADDR, ETH_ALEN, addr)) 2197 goto nla_put_failure; 2198 2199 return nlmsg_end(skb, nlh); 2200 2201 nla_put_failure: 2202 nlmsg_cancel(skb, nlh); 2203 return -EMSGSIZE; 2204 } 2205 2206 static inline size_t rtnl_fdb_nlmsg_size(void) 2207 { 2208 return NLMSG_ALIGN(sizeof(struct ndmsg)) + nla_total_size(ETH_ALEN); 2209 } 2210 2211 static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, int type) 2212 { 2213 struct net *net = dev_net(dev); 2214 struct sk_buff *skb; 2215 int err = -ENOBUFS; 2216 2217 skb = nlmsg_new(rtnl_fdb_nlmsg_size(), GFP_ATOMIC); 2218 if (!skb) 2219 goto errout; 2220 2221 err = nlmsg_populate_fdb_fill(skb, dev, addr, 0, 0, type, NTF_SELF, 0); 2222 if (err < 0) { 2223 kfree_skb(skb); 2224 goto errout; 2225 } 2226 2227 rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 2228 return; 2229 errout: 2230 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err); 2231 } 2232 2233 /** 2234 * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry 2235 */ 2236 int ndo_dflt_fdb_add(struct ndmsg *ndm, 2237 struct nlattr *tb[], 2238 struct net_device *dev, 2239 const unsigned char *addr, 2240 u16 flags) 2241 { 2242 int err = -EINVAL; 2243 2244 /* If aging addresses are supported device will need to 2245 * implement its own handler for this. 2246 */ 2247 if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) { 2248 pr_info("%s: FDB only supports static addresses\n", dev->name); 2249 return err; 2250 } 2251 2252 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) 2253 err = dev_uc_add_excl(dev, addr); 2254 else if (is_multicast_ether_addr(addr)) 2255 err = dev_mc_add_excl(dev, addr); 2256 2257 /* Only return duplicate errors if NLM_F_EXCL is set */ 2258 if (err == -EEXIST && !(flags & NLM_F_EXCL)) 2259 err = 0; 2260 2261 return err; 2262 } 2263 EXPORT_SYMBOL(ndo_dflt_fdb_add); 2264 2265 static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh) 2266 { 2267 struct net *net = sock_net(skb->sk); 2268 struct ndmsg *ndm; 2269 struct nlattr *tb[NDA_MAX+1]; 2270 struct net_device *dev; 2271 u8 *addr; 2272 int err; 2273 2274 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL); 2275 if (err < 0) 2276 return err; 2277 2278 ndm = nlmsg_data(nlh); 2279 if (ndm->ndm_ifindex == 0) { 2280 pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid ifindex\n"); 2281 return -EINVAL; 2282 } 2283 2284 dev = __dev_get_by_index(net, ndm->ndm_ifindex); 2285 if (dev == NULL) { 2286 pr_info("PF_BRIDGE: RTM_NEWNEIGH with unknown ifindex\n"); 2287 return -ENODEV; 2288 } 2289 2290 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) { 2291 pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid address\n"); 2292 return -EINVAL; 2293 } 2294 2295 addr = nla_data(tb[NDA_LLADDR]); 2296 2297 err = -EOPNOTSUPP; 2298 2299 /* Support fdb on master device the net/bridge default case */ 2300 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) && 2301 (dev->priv_flags & IFF_BRIDGE_PORT)) { 2302 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 2303 const struct net_device_ops *ops = br_dev->netdev_ops; 2304 2305 err = ops->ndo_fdb_add(ndm, tb, dev, addr, nlh->nlmsg_flags); 2306 if (err) 2307 goto out; 2308 else 2309 ndm->ndm_flags &= ~NTF_MASTER; 2310 } 2311 2312 /* Embedded bridge, macvlan, and any other device support */ 2313 if ((ndm->ndm_flags & NTF_SELF)) { 2314 if (dev->netdev_ops->ndo_fdb_add) 2315 err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr, 2316 nlh->nlmsg_flags); 2317 else 2318 err = ndo_dflt_fdb_add(ndm, tb, dev, addr, 2319 nlh->nlmsg_flags); 2320 2321 if (!err) { 2322 rtnl_fdb_notify(dev, addr, RTM_NEWNEIGH); 2323 ndm->ndm_flags &= ~NTF_SELF; 2324 } 2325 } 2326 out: 2327 return err; 2328 } 2329 2330 /** 2331 * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry 2332 */ 2333 int ndo_dflt_fdb_del(struct ndmsg *ndm, 2334 struct nlattr *tb[], 2335 struct net_device *dev, 2336 const unsigned char *addr) 2337 { 2338 int err = -EOPNOTSUPP; 2339 2340 /* If aging addresses are supported device will need to 2341 * implement its own handler for this. 2342 */ 2343 if (!(ndm->ndm_state & NUD_PERMANENT)) { 2344 pr_info("%s: FDB only supports static addresses\n", dev->name); 2345 return -EINVAL; 2346 } 2347 2348 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr)) 2349 err = dev_uc_del(dev, addr); 2350 else if (is_multicast_ether_addr(addr)) 2351 err = dev_mc_del(dev, addr); 2352 else 2353 err = -EINVAL; 2354 2355 return err; 2356 } 2357 EXPORT_SYMBOL(ndo_dflt_fdb_del); 2358 2359 static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh) 2360 { 2361 struct net *net = sock_net(skb->sk); 2362 struct ndmsg *ndm; 2363 struct nlattr *tb[NDA_MAX+1]; 2364 struct net_device *dev; 2365 int err = -EINVAL; 2366 __u8 *addr; 2367 2368 if (!netlink_capable(skb, CAP_NET_ADMIN)) 2369 return -EPERM; 2370 2371 err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL); 2372 if (err < 0) 2373 return err; 2374 2375 ndm = nlmsg_data(nlh); 2376 if (ndm->ndm_ifindex == 0) { 2377 pr_info("PF_BRIDGE: RTM_DELNEIGH with invalid ifindex\n"); 2378 return -EINVAL; 2379 } 2380 2381 dev = __dev_get_by_index(net, ndm->ndm_ifindex); 2382 if (dev == NULL) { 2383 pr_info("PF_BRIDGE: RTM_DELNEIGH with unknown ifindex\n"); 2384 return -ENODEV; 2385 } 2386 2387 if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) { 2388 pr_info("PF_BRIDGE: RTM_DELNEIGH with invalid address\n"); 2389 return -EINVAL; 2390 } 2391 2392 addr = nla_data(tb[NDA_LLADDR]); 2393 2394 err = -EOPNOTSUPP; 2395 2396 /* Support fdb on master device the net/bridge default case */ 2397 if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) && 2398 (dev->priv_flags & IFF_BRIDGE_PORT)) { 2399 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 2400 const struct net_device_ops *ops = br_dev->netdev_ops; 2401 2402 if (ops->ndo_fdb_del) 2403 err = ops->ndo_fdb_del(ndm, tb, dev, addr); 2404 2405 if (err) 2406 goto out; 2407 else 2408 ndm->ndm_flags &= ~NTF_MASTER; 2409 } 2410 2411 /* Embedded bridge, macvlan, and any other device support */ 2412 if (ndm->ndm_flags & NTF_SELF) { 2413 if (dev->netdev_ops->ndo_fdb_del) 2414 err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr); 2415 else 2416 err = ndo_dflt_fdb_del(ndm, tb, dev, addr); 2417 2418 if (!err) { 2419 rtnl_fdb_notify(dev, addr, RTM_DELNEIGH); 2420 ndm->ndm_flags &= ~NTF_SELF; 2421 } 2422 } 2423 out: 2424 return err; 2425 } 2426 2427 static int nlmsg_populate_fdb(struct sk_buff *skb, 2428 struct netlink_callback *cb, 2429 struct net_device *dev, 2430 int *idx, 2431 struct netdev_hw_addr_list *list) 2432 { 2433 struct netdev_hw_addr *ha; 2434 int err; 2435 u32 portid, seq; 2436 2437 portid = NETLINK_CB(cb->skb).portid; 2438 seq = cb->nlh->nlmsg_seq; 2439 2440 list_for_each_entry(ha, &list->list, list) { 2441 if (*idx < cb->args[0]) 2442 goto skip; 2443 2444 err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 2445 portid, seq, 2446 RTM_NEWNEIGH, NTF_SELF, 2447 NLM_F_MULTI); 2448 if (err < 0) 2449 return err; 2450 skip: 2451 *idx += 1; 2452 } 2453 return 0; 2454 } 2455 2456 /** 2457 * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table. 2458 * @nlh: netlink message header 2459 * @dev: netdevice 2460 * 2461 * Default netdevice operation to dump the existing unicast address list. 2462 * Returns number of addresses from list put in skb. 2463 */ 2464 int ndo_dflt_fdb_dump(struct sk_buff *skb, 2465 struct netlink_callback *cb, 2466 struct net_device *dev, 2467 int idx) 2468 { 2469 int err; 2470 2471 netif_addr_lock_bh(dev); 2472 err = nlmsg_populate_fdb(skb, cb, dev, &idx, &dev->uc); 2473 if (err) 2474 goto out; 2475 nlmsg_populate_fdb(skb, cb, dev, &idx, &dev->mc); 2476 out: 2477 netif_addr_unlock_bh(dev); 2478 return idx; 2479 } 2480 EXPORT_SYMBOL(ndo_dflt_fdb_dump); 2481 2482 static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb) 2483 { 2484 int idx = 0; 2485 struct net *net = sock_net(skb->sk); 2486 struct net_device *dev; 2487 2488 rcu_read_lock(); 2489 for_each_netdev_rcu(net, dev) { 2490 if (dev->priv_flags & IFF_BRIDGE_PORT) { 2491 struct net_device *br_dev; 2492 const struct net_device_ops *ops; 2493 2494 br_dev = netdev_master_upper_dev_get(dev); 2495 ops = br_dev->netdev_ops; 2496 if (ops->ndo_fdb_dump) 2497 idx = ops->ndo_fdb_dump(skb, cb, dev, idx); 2498 } 2499 2500 if (dev->netdev_ops->ndo_fdb_dump) 2501 idx = dev->netdev_ops->ndo_fdb_dump(skb, cb, dev, idx); 2502 else 2503 idx = ndo_dflt_fdb_dump(skb, cb, dev, idx); 2504 } 2505 rcu_read_unlock(); 2506 2507 cb->args[0] = idx; 2508 return skb->len; 2509 } 2510 2511 int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, 2512 struct net_device *dev, u16 mode) 2513 { 2514 struct nlmsghdr *nlh; 2515 struct ifinfomsg *ifm; 2516 struct nlattr *br_afspec; 2517 u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN; 2518 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 2519 2520 nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), NLM_F_MULTI); 2521 if (nlh == NULL) 2522 return -EMSGSIZE; 2523 2524 ifm = nlmsg_data(nlh); 2525 ifm->ifi_family = AF_BRIDGE; 2526 ifm->__ifi_pad = 0; 2527 ifm->ifi_type = dev->type; 2528 ifm->ifi_index = dev->ifindex; 2529 ifm->ifi_flags = dev_get_flags(dev); 2530 ifm->ifi_change = 0; 2531 2532 2533 if (nla_put_string(skb, IFLA_IFNAME, dev->name) || 2534 nla_put_u32(skb, IFLA_MTU, dev->mtu) || 2535 nla_put_u8(skb, IFLA_OPERSTATE, operstate) || 2536 (br_dev && 2537 nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) || 2538 (dev->addr_len && 2539 nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) || 2540 (dev->ifindex != dev->iflink && 2541 nla_put_u32(skb, IFLA_LINK, dev->iflink))) 2542 goto nla_put_failure; 2543 2544 br_afspec = nla_nest_start(skb, IFLA_AF_SPEC); 2545 if (!br_afspec) 2546 goto nla_put_failure; 2547 2548 if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF) || 2549 nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) { 2550 nla_nest_cancel(skb, br_afspec); 2551 goto nla_put_failure; 2552 } 2553 nla_nest_end(skb, br_afspec); 2554 2555 return nlmsg_end(skb, nlh); 2556 nla_put_failure: 2557 nlmsg_cancel(skb, nlh); 2558 return -EMSGSIZE; 2559 } 2560 EXPORT_SYMBOL(ndo_dflt_bridge_getlink); 2561 2562 static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb) 2563 { 2564 struct net *net = sock_net(skb->sk); 2565 struct net_device *dev; 2566 int idx = 0; 2567 u32 portid = NETLINK_CB(cb->skb).portid; 2568 u32 seq = cb->nlh->nlmsg_seq; 2569 struct nlattr *extfilt; 2570 u32 filter_mask = 0; 2571 2572 extfilt = nlmsg_find_attr(cb->nlh, sizeof(struct ifinfomsg), 2573 IFLA_EXT_MASK); 2574 if (extfilt) 2575 filter_mask = nla_get_u32(extfilt); 2576 2577 rcu_read_lock(); 2578 for_each_netdev_rcu(net, dev) { 2579 const struct net_device_ops *ops = dev->netdev_ops; 2580 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 2581 2582 if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) { 2583 if (idx >= cb->args[0] && 2584 br_dev->netdev_ops->ndo_bridge_getlink( 2585 skb, portid, seq, dev, filter_mask) < 0) 2586 break; 2587 idx++; 2588 } 2589 2590 if (ops->ndo_bridge_getlink) { 2591 if (idx >= cb->args[0] && 2592 ops->ndo_bridge_getlink(skb, portid, seq, dev, 2593 filter_mask) < 0) 2594 break; 2595 idx++; 2596 } 2597 } 2598 rcu_read_unlock(); 2599 cb->args[0] = idx; 2600 2601 return skb->len; 2602 } 2603 2604 static inline size_t bridge_nlmsg_size(void) 2605 { 2606 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 2607 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 2608 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 2609 + nla_total_size(sizeof(u32)) /* IFLA_MASTER */ 2610 + nla_total_size(sizeof(u32)) /* IFLA_MTU */ 2611 + nla_total_size(sizeof(u32)) /* IFLA_LINK */ 2612 + nla_total_size(sizeof(u32)) /* IFLA_OPERSTATE */ 2613 + nla_total_size(sizeof(u8)) /* IFLA_PROTINFO */ 2614 + nla_total_size(sizeof(struct nlattr)) /* IFLA_AF_SPEC */ 2615 + nla_total_size(sizeof(u16)) /* IFLA_BRIDGE_FLAGS */ 2616 + nla_total_size(sizeof(u16)); /* IFLA_BRIDGE_MODE */ 2617 } 2618 2619 static int rtnl_bridge_notify(struct net_device *dev, u16 flags) 2620 { 2621 struct net *net = dev_net(dev); 2622 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 2623 struct sk_buff *skb; 2624 int err = -EOPNOTSUPP; 2625 2626 skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC); 2627 if (!skb) { 2628 err = -ENOMEM; 2629 goto errout; 2630 } 2631 2632 if ((!flags || (flags & BRIDGE_FLAGS_MASTER)) && 2633 br_dev && br_dev->netdev_ops->ndo_bridge_getlink) { 2634 err = br_dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0); 2635 if (err < 0) 2636 goto errout; 2637 } 2638 2639 if ((flags & BRIDGE_FLAGS_SELF) && 2640 dev->netdev_ops->ndo_bridge_getlink) { 2641 err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0); 2642 if (err < 0) 2643 goto errout; 2644 } 2645 2646 rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC); 2647 return 0; 2648 errout: 2649 WARN_ON(err == -EMSGSIZE); 2650 kfree_skb(skb); 2651 rtnl_set_sk_err(net, RTNLGRP_LINK, err); 2652 return err; 2653 } 2654 2655 static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh) 2656 { 2657 struct net *net = sock_net(skb->sk); 2658 struct ifinfomsg *ifm; 2659 struct net_device *dev; 2660 struct nlattr *br_spec, *attr = NULL; 2661 int rem, err = -EOPNOTSUPP; 2662 u16 oflags, flags = 0; 2663 bool have_flags = false; 2664 2665 if (nlmsg_len(nlh) < sizeof(*ifm)) 2666 return -EINVAL; 2667 2668 ifm = nlmsg_data(nlh); 2669 if (ifm->ifi_family != AF_BRIDGE) 2670 return -EPFNOSUPPORT; 2671 2672 dev = __dev_get_by_index(net, ifm->ifi_index); 2673 if (!dev) { 2674 pr_info("PF_BRIDGE: RTM_SETLINK with unknown ifindex\n"); 2675 return -ENODEV; 2676 } 2677 2678 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 2679 if (br_spec) { 2680 nla_for_each_nested(attr, br_spec, rem) { 2681 if (nla_type(attr) == IFLA_BRIDGE_FLAGS) { 2682 have_flags = true; 2683 flags = nla_get_u16(attr); 2684 break; 2685 } 2686 } 2687 } 2688 2689 oflags = flags; 2690 2691 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) { 2692 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 2693 2694 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) { 2695 err = -EOPNOTSUPP; 2696 goto out; 2697 } 2698 2699 err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh); 2700 if (err) 2701 goto out; 2702 2703 flags &= ~BRIDGE_FLAGS_MASTER; 2704 } 2705 2706 if ((flags & BRIDGE_FLAGS_SELF)) { 2707 if (!dev->netdev_ops->ndo_bridge_setlink) 2708 err = -EOPNOTSUPP; 2709 else 2710 err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh); 2711 2712 if (!err) 2713 flags &= ~BRIDGE_FLAGS_SELF; 2714 } 2715 2716 if (have_flags) 2717 memcpy(nla_data(attr), &flags, sizeof(flags)); 2718 /* Generate event to notify upper layer of bridge change */ 2719 if (!err) 2720 err = rtnl_bridge_notify(dev, oflags); 2721 out: 2722 return err; 2723 } 2724 2725 static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh) 2726 { 2727 struct net *net = sock_net(skb->sk); 2728 struct ifinfomsg *ifm; 2729 struct net_device *dev; 2730 struct nlattr *br_spec, *attr = NULL; 2731 int rem, err = -EOPNOTSUPP; 2732 u16 oflags, flags = 0; 2733 bool have_flags = false; 2734 2735 if (nlmsg_len(nlh) < sizeof(*ifm)) 2736 return -EINVAL; 2737 2738 ifm = nlmsg_data(nlh); 2739 if (ifm->ifi_family != AF_BRIDGE) 2740 return -EPFNOSUPPORT; 2741 2742 dev = __dev_get_by_index(net, ifm->ifi_index); 2743 if (!dev) { 2744 pr_info("PF_BRIDGE: RTM_SETLINK with unknown ifindex\n"); 2745 return -ENODEV; 2746 } 2747 2748 br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC); 2749 if (br_spec) { 2750 nla_for_each_nested(attr, br_spec, rem) { 2751 if (nla_type(attr) == IFLA_BRIDGE_FLAGS) { 2752 have_flags = true; 2753 flags = nla_get_u16(attr); 2754 break; 2755 } 2756 } 2757 } 2758 2759 oflags = flags; 2760 2761 if (!flags || (flags & BRIDGE_FLAGS_MASTER)) { 2762 struct net_device *br_dev = netdev_master_upper_dev_get(dev); 2763 2764 if (!br_dev || !br_dev->netdev_ops->ndo_bridge_dellink) { 2765 err = -EOPNOTSUPP; 2766 goto out; 2767 } 2768 2769 err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh); 2770 if (err) 2771 goto out; 2772 2773 flags &= ~BRIDGE_FLAGS_MASTER; 2774 } 2775 2776 if ((flags & BRIDGE_FLAGS_SELF)) { 2777 if (!dev->netdev_ops->ndo_bridge_dellink) 2778 err = -EOPNOTSUPP; 2779 else 2780 err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh); 2781 2782 if (!err) 2783 flags &= ~BRIDGE_FLAGS_SELF; 2784 } 2785 2786 if (have_flags) 2787 memcpy(nla_data(attr), &flags, sizeof(flags)); 2788 /* Generate event to notify upper layer of bridge change */ 2789 if (!err) 2790 err = rtnl_bridge_notify(dev, oflags); 2791 out: 2792 return err; 2793 } 2794 2795 /* Process one rtnetlink message. */ 2796 2797 static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) 2798 { 2799 struct net *net = sock_net(skb->sk); 2800 rtnl_doit_func doit; 2801 int sz_idx, kind; 2802 int family; 2803 int type; 2804 int err; 2805 2806 type = nlh->nlmsg_type; 2807 if (type > RTM_MAX) 2808 return -EOPNOTSUPP; 2809 2810 type -= RTM_BASE; 2811 2812 /* All the messages must have at least 1 byte length */ 2813 if (nlmsg_len(nlh) < sizeof(struct rtgenmsg)) 2814 return 0; 2815 2816 family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family; 2817 sz_idx = type>>2; 2818 kind = type&3; 2819 2820 if (kind != 2 && !netlink_net_capable(skb, CAP_NET_ADMIN)) 2821 return -EPERM; 2822 2823 if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) { 2824 struct sock *rtnl; 2825 rtnl_dumpit_func dumpit; 2826 rtnl_calcit_func calcit; 2827 u16 min_dump_alloc = 0; 2828 2829 dumpit = rtnl_get_dumpit(family, type); 2830 if (dumpit == NULL) 2831 return -EOPNOTSUPP; 2832 calcit = rtnl_get_calcit(family, type); 2833 if (calcit) 2834 min_dump_alloc = calcit(skb, nlh); 2835 2836 __rtnl_unlock(); 2837 rtnl = net->rtnl; 2838 { 2839 struct netlink_dump_control c = { 2840 .dump = dumpit, 2841 .min_dump_alloc = min_dump_alloc, 2842 }; 2843 err = netlink_dump_start(rtnl, skb, nlh, &c); 2844 } 2845 rtnl_lock(); 2846 return err; 2847 } 2848 2849 doit = rtnl_get_doit(family, type); 2850 if (doit == NULL) 2851 return -EOPNOTSUPP; 2852 2853 return doit(skb, nlh); 2854 } 2855 2856 static void rtnetlink_rcv(struct sk_buff *skb) 2857 { 2858 rtnl_lock(); 2859 netlink_rcv_skb(skb, &rtnetlink_rcv_msg); 2860 rtnl_unlock(); 2861 } 2862 2863 static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr) 2864 { 2865 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 2866 2867 switch (event) { 2868 case NETDEV_UP: 2869 case NETDEV_DOWN: 2870 case NETDEV_PRE_UP: 2871 case NETDEV_POST_INIT: 2872 case NETDEV_REGISTER: 2873 case NETDEV_CHANGE: 2874 case NETDEV_PRE_TYPE_CHANGE: 2875 case NETDEV_GOING_DOWN: 2876 case NETDEV_UNREGISTER: 2877 case NETDEV_UNREGISTER_FINAL: 2878 case NETDEV_RELEASE: 2879 case NETDEV_JOIN: 2880 break; 2881 default: 2882 rtmsg_ifinfo(RTM_NEWLINK, dev, 0, GFP_KERNEL); 2883 break; 2884 } 2885 return NOTIFY_DONE; 2886 } 2887 2888 static struct notifier_block rtnetlink_dev_notifier = { 2889 .notifier_call = rtnetlink_event, 2890 }; 2891 2892 2893 static int __net_init rtnetlink_net_init(struct net *net) 2894 { 2895 struct sock *sk; 2896 struct netlink_kernel_cfg cfg = { 2897 .groups = RTNLGRP_MAX, 2898 .input = rtnetlink_rcv, 2899 .cb_mutex = &rtnl_mutex, 2900 .flags = NL_CFG_F_NONROOT_RECV, 2901 }; 2902 2903 sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg); 2904 if (!sk) 2905 return -ENOMEM; 2906 net->rtnl = sk; 2907 return 0; 2908 } 2909 2910 static void __net_exit rtnetlink_net_exit(struct net *net) 2911 { 2912 netlink_kernel_release(net->rtnl); 2913 net->rtnl = NULL; 2914 } 2915 2916 static struct pernet_operations rtnetlink_net_ops = { 2917 .init = rtnetlink_net_init, 2918 .exit = rtnetlink_net_exit, 2919 }; 2920 2921 void __init rtnetlink_init(void) 2922 { 2923 if (register_pernet_subsys(&rtnetlink_net_ops)) 2924 panic("rtnetlink_init: cannot initialize rtnetlink\n"); 2925 2926 register_netdevice_notifier(&rtnetlink_dev_notifier); 2927 2928 rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink, 2929 rtnl_dump_ifinfo, rtnl_calcit); 2930 rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL, NULL); 2931 rtnl_register(PF_UNSPEC, RTM_NEWLINK, rtnl_newlink, NULL, NULL); 2932 rtnl_register(PF_UNSPEC, RTM_DELLINK, rtnl_dellink, NULL, NULL); 2933 2934 rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, NULL); 2935 rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, NULL); 2936 2937 rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, NULL); 2938 rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL, NULL); 2939 rtnl_register(PF_BRIDGE, RTM_GETNEIGH, NULL, rtnl_fdb_dump, NULL); 2940 2941 rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, NULL); 2942 rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, NULL); 2943 rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, NULL); 2944 } 2945 2946