1 /* 2 * drivers/net/team/team.c - Network team device driver 3 * Copyright (c) 2011 Jiri Pirko <jpirko@redhat.com> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/types.h> 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/slab.h> 16 #include <linux/rcupdate.h> 17 #include <linux/errno.h> 18 #include <linux/ctype.h> 19 #include <linux/notifier.h> 20 #include <linux/netdevice.h> 21 #include <linux/netpoll.h> 22 #include <linux/if_vlan.h> 23 #include <linux/if_arp.h> 24 #include <linux/socket.h> 25 #include <linux/etherdevice.h> 26 #include <linux/rtnetlink.h> 27 #include <net/rtnetlink.h> 28 #include <net/genetlink.h> 29 #include <net/netlink.h> 30 #include <net/sch_generic.h> 31 #include <net/switchdev.h> 32 #include <generated/utsrelease.h> 33 #include <linux/if_team.h> 34 35 #define DRV_NAME "team" 36 37 38 /********** 39 * Helpers 40 **********/ 41 42 #define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT) 43 44 static struct team_port *team_port_get_rcu(const struct net_device *dev) 45 { 46 return rcu_dereference(dev->rx_handler_data); 47 } 48 49 static struct team_port *team_port_get_rtnl(const struct net_device *dev) 50 { 51 struct team_port *port = rtnl_dereference(dev->rx_handler_data); 52 53 return team_port_exists(dev) ? port : NULL; 54 } 55 56 /* 57 * Since the ability to change device address for open port device is tested in 58 * team_port_add, this function can be called without control of return value 59 */ 60 static int __set_port_dev_addr(struct net_device *port_dev, 61 const unsigned char *dev_addr) 62 { 63 struct sockaddr_storage addr; 64 65 memcpy(addr.__data, dev_addr, port_dev->addr_len); 66 addr.ss_family = port_dev->type; 67 return dev_set_mac_address(port_dev, (struct sockaddr *)&addr); 68 } 69 70 static int team_port_set_orig_dev_addr(struct team_port *port) 71 { 72 return __set_port_dev_addr(port->dev, port->orig.dev_addr); 73 } 74 75 static int team_port_set_team_dev_addr(struct team *team, 76 struct team_port *port) 77 { 78 return __set_port_dev_addr(port->dev, team->dev->dev_addr); 79 } 80 81 int team_modeop_port_enter(struct team *team, struct team_port *port) 82 { 83 return team_port_set_team_dev_addr(team, port); 84 } 85 EXPORT_SYMBOL(team_modeop_port_enter); 86 87 void team_modeop_port_change_dev_addr(struct team *team, 88 struct team_port *port) 89 { 90 team_port_set_team_dev_addr(team, port); 91 } 92 EXPORT_SYMBOL(team_modeop_port_change_dev_addr); 93 94 static void team_lower_state_changed(struct team_port *port) 95 { 96 struct netdev_lag_lower_state_info info; 97 98 info.link_up = port->linkup; 99 info.tx_enabled = team_port_enabled(port); 100 netdev_lower_state_changed(port->dev, &info); 101 } 102 103 static void team_refresh_port_linkup(struct team_port *port) 104 { 105 bool new_linkup = port->user.linkup_enabled ? port->user.linkup : 106 port->state.linkup; 107 108 if (port->linkup != new_linkup) { 109 port->linkup = new_linkup; 110 team_lower_state_changed(port); 111 } 112 } 113 114 115 /******************* 116 * Options handling 117 *******************/ 118 119 struct team_option_inst { /* One for each option instance */ 120 struct list_head list; 121 struct list_head tmp_list; 122 struct team_option *option; 123 struct team_option_inst_info info; 124 bool changed; 125 bool removed; 126 }; 127 128 static struct team_option *__team_find_option(struct team *team, 129 const char *opt_name) 130 { 131 struct team_option *option; 132 133 list_for_each_entry(option, &team->option_list, list) { 134 if (strcmp(option->name, opt_name) == 0) 135 return option; 136 } 137 return NULL; 138 } 139 140 static void __team_option_inst_del(struct team_option_inst *opt_inst) 141 { 142 list_del(&opt_inst->list); 143 kfree(opt_inst); 144 } 145 146 static void __team_option_inst_del_option(struct team *team, 147 struct team_option *option) 148 { 149 struct team_option_inst *opt_inst, *tmp; 150 151 list_for_each_entry_safe(opt_inst, tmp, &team->option_inst_list, list) { 152 if (opt_inst->option == option) 153 __team_option_inst_del(opt_inst); 154 } 155 } 156 157 static int __team_option_inst_add(struct team *team, struct team_option *option, 158 struct team_port *port) 159 { 160 struct team_option_inst *opt_inst; 161 unsigned int array_size; 162 unsigned int i; 163 int err; 164 165 array_size = option->array_size; 166 if (!array_size) 167 array_size = 1; /* No array but still need one instance */ 168 169 for (i = 0; i < array_size; i++) { 170 opt_inst = kmalloc(sizeof(*opt_inst), GFP_KERNEL); 171 if (!opt_inst) 172 return -ENOMEM; 173 opt_inst->option = option; 174 opt_inst->info.port = port; 175 opt_inst->info.array_index = i; 176 opt_inst->changed = true; 177 opt_inst->removed = false; 178 list_add_tail(&opt_inst->list, &team->option_inst_list); 179 if (option->init) { 180 err = option->init(team, &opt_inst->info); 181 if (err) 182 return err; 183 } 184 185 } 186 return 0; 187 } 188 189 static int __team_option_inst_add_option(struct team *team, 190 struct team_option *option) 191 { 192 int err; 193 194 if (!option->per_port) { 195 err = __team_option_inst_add(team, option, NULL); 196 if (err) 197 goto inst_del_option; 198 } 199 return 0; 200 201 inst_del_option: 202 __team_option_inst_del_option(team, option); 203 return err; 204 } 205 206 static void __team_option_inst_mark_removed_option(struct team *team, 207 struct team_option *option) 208 { 209 struct team_option_inst *opt_inst; 210 211 list_for_each_entry(opt_inst, &team->option_inst_list, list) { 212 if (opt_inst->option == option) { 213 opt_inst->changed = true; 214 opt_inst->removed = true; 215 } 216 } 217 } 218 219 static void __team_option_inst_del_port(struct team *team, 220 struct team_port *port) 221 { 222 struct team_option_inst *opt_inst, *tmp; 223 224 list_for_each_entry_safe(opt_inst, tmp, &team->option_inst_list, list) { 225 if (opt_inst->option->per_port && 226 opt_inst->info.port == port) 227 __team_option_inst_del(opt_inst); 228 } 229 } 230 231 static int __team_option_inst_add_port(struct team *team, 232 struct team_port *port) 233 { 234 struct team_option *option; 235 int err; 236 237 list_for_each_entry(option, &team->option_list, list) { 238 if (!option->per_port) 239 continue; 240 err = __team_option_inst_add(team, option, port); 241 if (err) 242 goto inst_del_port; 243 } 244 return 0; 245 246 inst_del_port: 247 __team_option_inst_del_port(team, port); 248 return err; 249 } 250 251 static void __team_option_inst_mark_removed_port(struct team *team, 252 struct team_port *port) 253 { 254 struct team_option_inst *opt_inst; 255 256 list_for_each_entry(opt_inst, &team->option_inst_list, list) { 257 if (opt_inst->info.port == port) { 258 opt_inst->changed = true; 259 opt_inst->removed = true; 260 } 261 } 262 } 263 264 static bool __team_option_inst_tmp_find(const struct list_head *opts, 265 const struct team_option_inst *needle) 266 { 267 struct team_option_inst *opt_inst; 268 269 list_for_each_entry(opt_inst, opts, tmp_list) 270 if (opt_inst == needle) 271 return true; 272 return false; 273 } 274 275 static int __team_options_register(struct team *team, 276 const struct team_option *option, 277 size_t option_count) 278 { 279 int i; 280 struct team_option **dst_opts; 281 int err; 282 283 dst_opts = kzalloc(sizeof(struct team_option *) * option_count, 284 GFP_KERNEL); 285 if (!dst_opts) 286 return -ENOMEM; 287 for (i = 0; i < option_count; i++, option++) { 288 if (__team_find_option(team, option->name)) { 289 err = -EEXIST; 290 goto alloc_rollback; 291 } 292 dst_opts[i] = kmemdup(option, sizeof(*option), GFP_KERNEL); 293 if (!dst_opts[i]) { 294 err = -ENOMEM; 295 goto alloc_rollback; 296 } 297 } 298 299 for (i = 0; i < option_count; i++) { 300 err = __team_option_inst_add_option(team, dst_opts[i]); 301 if (err) 302 goto inst_rollback; 303 list_add_tail(&dst_opts[i]->list, &team->option_list); 304 } 305 306 kfree(dst_opts); 307 return 0; 308 309 inst_rollback: 310 for (i--; i >= 0; i--) 311 __team_option_inst_del_option(team, dst_opts[i]); 312 313 i = option_count - 1; 314 alloc_rollback: 315 for (i--; i >= 0; i--) 316 kfree(dst_opts[i]); 317 318 kfree(dst_opts); 319 return err; 320 } 321 322 static void __team_options_mark_removed(struct team *team, 323 const struct team_option *option, 324 size_t option_count) 325 { 326 int i; 327 328 for (i = 0; i < option_count; i++, option++) { 329 struct team_option *del_opt; 330 331 del_opt = __team_find_option(team, option->name); 332 if (del_opt) 333 __team_option_inst_mark_removed_option(team, del_opt); 334 } 335 } 336 337 static void __team_options_unregister(struct team *team, 338 const struct team_option *option, 339 size_t option_count) 340 { 341 int i; 342 343 for (i = 0; i < option_count; i++, option++) { 344 struct team_option *del_opt; 345 346 del_opt = __team_find_option(team, option->name); 347 if (del_opt) { 348 __team_option_inst_del_option(team, del_opt); 349 list_del(&del_opt->list); 350 kfree(del_opt); 351 } 352 } 353 } 354 355 static void __team_options_change_check(struct team *team); 356 357 int team_options_register(struct team *team, 358 const struct team_option *option, 359 size_t option_count) 360 { 361 int err; 362 363 err = __team_options_register(team, option, option_count); 364 if (err) 365 return err; 366 __team_options_change_check(team); 367 return 0; 368 } 369 EXPORT_SYMBOL(team_options_register); 370 371 void team_options_unregister(struct team *team, 372 const struct team_option *option, 373 size_t option_count) 374 { 375 __team_options_mark_removed(team, option, option_count); 376 __team_options_change_check(team); 377 __team_options_unregister(team, option, option_count); 378 } 379 EXPORT_SYMBOL(team_options_unregister); 380 381 static int team_option_get(struct team *team, 382 struct team_option_inst *opt_inst, 383 struct team_gsetter_ctx *ctx) 384 { 385 if (!opt_inst->option->getter) 386 return -EOPNOTSUPP; 387 return opt_inst->option->getter(team, ctx); 388 } 389 390 static int team_option_set(struct team *team, 391 struct team_option_inst *opt_inst, 392 struct team_gsetter_ctx *ctx) 393 { 394 if (!opt_inst->option->setter) 395 return -EOPNOTSUPP; 396 return opt_inst->option->setter(team, ctx); 397 } 398 399 void team_option_inst_set_change(struct team_option_inst_info *opt_inst_info) 400 { 401 struct team_option_inst *opt_inst; 402 403 opt_inst = container_of(opt_inst_info, struct team_option_inst, info); 404 opt_inst->changed = true; 405 } 406 EXPORT_SYMBOL(team_option_inst_set_change); 407 408 void team_options_change_check(struct team *team) 409 { 410 __team_options_change_check(team); 411 } 412 EXPORT_SYMBOL(team_options_change_check); 413 414 415 /**************** 416 * Mode handling 417 ****************/ 418 419 static LIST_HEAD(mode_list); 420 static DEFINE_SPINLOCK(mode_list_lock); 421 422 struct team_mode_item { 423 struct list_head list; 424 const struct team_mode *mode; 425 }; 426 427 static struct team_mode_item *__find_mode(const char *kind) 428 { 429 struct team_mode_item *mitem; 430 431 list_for_each_entry(mitem, &mode_list, list) { 432 if (strcmp(mitem->mode->kind, kind) == 0) 433 return mitem; 434 } 435 return NULL; 436 } 437 438 static bool is_good_mode_name(const char *name) 439 { 440 while (*name != '\0') { 441 if (!isalpha(*name) && !isdigit(*name) && *name != '_') 442 return false; 443 name++; 444 } 445 return true; 446 } 447 448 int team_mode_register(const struct team_mode *mode) 449 { 450 int err = 0; 451 struct team_mode_item *mitem; 452 453 if (!is_good_mode_name(mode->kind) || 454 mode->priv_size > TEAM_MODE_PRIV_SIZE) 455 return -EINVAL; 456 457 mitem = kmalloc(sizeof(*mitem), GFP_KERNEL); 458 if (!mitem) 459 return -ENOMEM; 460 461 spin_lock(&mode_list_lock); 462 if (__find_mode(mode->kind)) { 463 err = -EEXIST; 464 kfree(mitem); 465 goto unlock; 466 } 467 mitem->mode = mode; 468 list_add_tail(&mitem->list, &mode_list); 469 unlock: 470 spin_unlock(&mode_list_lock); 471 return err; 472 } 473 EXPORT_SYMBOL(team_mode_register); 474 475 void team_mode_unregister(const struct team_mode *mode) 476 { 477 struct team_mode_item *mitem; 478 479 spin_lock(&mode_list_lock); 480 mitem = __find_mode(mode->kind); 481 if (mitem) { 482 list_del_init(&mitem->list); 483 kfree(mitem); 484 } 485 spin_unlock(&mode_list_lock); 486 } 487 EXPORT_SYMBOL(team_mode_unregister); 488 489 static const struct team_mode *team_mode_get(const char *kind) 490 { 491 struct team_mode_item *mitem; 492 const struct team_mode *mode = NULL; 493 494 spin_lock(&mode_list_lock); 495 mitem = __find_mode(kind); 496 if (!mitem) { 497 spin_unlock(&mode_list_lock); 498 request_module("team-mode-%s", kind); 499 spin_lock(&mode_list_lock); 500 mitem = __find_mode(kind); 501 } 502 if (mitem) { 503 mode = mitem->mode; 504 if (!try_module_get(mode->owner)) 505 mode = NULL; 506 } 507 508 spin_unlock(&mode_list_lock); 509 return mode; 510 } 511 512 static void team_mode_put(const struct team_mode *mode) 513 { 514 module_put(mode->owner); 515 } 516 517 static bool team_dummy_transmit(struct team *team, struct sk_buff *skb) 518 { 519 dev_kfree_skb_any(skb); 520 return false; 521 } 522 523 static rx_handler_result_t team_dummy_receive(struct team *team, 524 struct team_port *port, 525 struct sk_buff *skb) 526 { 527 return RX_HANDLER_ANOTHER; 528 } 529 530 static const struct team_mode __team_no_mode = { 531 .kind = "*NOMODE*", 532 }; 533 534 static bool team_is_mode_set(struct team *team) 535 { 536 return team->mode != &__team_no_mode; 537 } 538 539 static void team_set_no_mode(struct team *team) 540 { 541 team->user_carrier_enabled = false; 542 team->mode = &__team_no_mode; 543 } 544 545 static void team_adjust_ops(struct team *team) 546 { 547 /* 548 * To avoid checks in rx/tx skb paths, ensure here that non-null and 549 * correct ops are always set. 550 */ 551 552 if (!team->en_port_count || !team_is_mode_set(team) || 553 !team->mode->ops->transmit) 554 team->ops.transmit = team_dummy_transmit; 555 else 556 team->ops.transmit = team->mode->ops->transmit; 557 558 if (!team->en_port_count || !team_is_mode_set(team) || 559 !team->mode->ops->receive) 560 team->ops.receive = team_dummy_receive; 561 else 562 team->ops.receive = team->mode->ops->receive; 563 } 564 565 /* 566 * We can benefit from the fact that it's ensured no port is present 567 * at the time of mode change. Therefore no packets are in fly so there's no 568 * need to set mode operations in any special way. 569 */ 570 static int __team_change_mode(struct team *team, 571 const struct team_mode *new_mode) 572 { 573 /* Check if mode was previously set and do cleanup if so */ 574 if (team_is_mode_set(team)) { 575 void (*exit_op)(struct team *team) = team->ops.exit; 576 577 /* Clear ops area so no callback is called any longer */ 578 memset(&team->ops, 0, sizeof(struct team_mode_ops)); 579 team_adjust_ops(team); 580 581 if (exit_op) 582 exit_op(team); 583 team_mode_put(team->mode); 584 team_set_no_mode(team); 585 /* zero private data area */ 586 memset(&team->mode_priv, 0, 587 sizeof(struct team) - offsetof(struct team, mode_priv)); 588 } 589 590 if (!new_mode) 591 return 0; 592 593 if (new_mode->ops->init) { 594 int err; 595 596 err = new_mode->ops->init(team); 597 if (err) 598 return err; 599 } 600 601 team->mode = new_mode; 602 memcpy(&team->ops, new_mode->ops, sizeof(struct team_mode_ops)); 603 team_adjust_ops(team); 604 605 return 0; 606 } 607 608 static int team_change_mode(struct team *team, const char *kind) 609 { 610 const struct team_mode *new_mode; 611 struct net_device *dev = team->dev; 612 int err; 613 614 if (!list_empty(&team->port_list)) { 615 netdev_err(dev, "No ports can be present during mode change\n"); 616 return -EBUSY; 617 } 618 619 if (team_is_mode_set(team) && strcmp(team->mode->kind, kind) == 0) { 620 netdev_err(dev, "Unable to change to the same mode the team is in\n"); 621 return -EINVAL; 622 } 623 624 new_mode = team_mode_get(kind); 625 if (!new_mode) { 626 netdev_err(dev, "Mode \"%s\" not found\n", kind); 627 return -EINVAL; 628 } 629 630 err = __team_change_mode(team, new_mode); 631 if (err) { 632 netdev_err(dev, "Failed to change to mode \"%s\"\n", kind); 633 team_mode_put(new_mode); 634 return err; 635 } 636 637 netdev_info(dev, "Mode changed to \"%s\"\n", kind); 638 return 0; 639 } 640 641 642 /********************* 643 * Peers notification 644 *********************/ 645 646 static void team_notify_peers_work(struct work_struct *work) 647 { 648 struct team *team; 649 int val; 650 651 team = container_of(work, struct team, notify_peers.dw.work); 652 653 if (!rtnl_trylock()) { 654 schedule_delayed_work(&team->notify_peers.dw, 0); 655 return; 656 } 657 val = atomic_dec_if_positive(&team->notify_peers.count_pending); 658 if (val < 0) { 659 rtnl_unlock(); 660 return; 661 } 662 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, team->dev); 663 rtnl_unlock(); 664 if (val) 665 schedule_delayed_work(&team->notify_peers.dw, 666 msecs_to_jiffies(team->notify_peers.interval)); 667 } 668 669 static void team_notify_peers(struct team *team) 670 { 671 if (!team->notify_peers.count || !netif_running(team->dev)) 672 return; 673 atomic_add(team->notify_peers.count, &team->notify_peers.count_pending); 674 schedule_delayed_work(&team->notify_peers.dw, 0); 675 } 676 677 static void team_notify_peers_init(struct team *team) 678 { 679 INIT_DELAYED_WORK(&team->notify_peers.dw, team_notify_peers_work); 680 } 681 682 static void team_notify_peers_fini(struct team *team) 683 { 684 cancel_delayed_work_sync(&team->notify_peers.dw); 685 } 686 687 688 /******************************* 689 * Send multicast group rejoins 690 *******************************/ 691 692 static void team_mcast_rejoin_work(struct work_struct *work) 693 { 694 struct team *team; 695 int val; 696 697 team = container_of(work, struct team, mcast_rejoin.dw.work); 698 699 if (!rtnl_trylock()) { 700 schedule_delayed_work(&team->mcast_rejoin.dw, 0); 701 return; 702 } 703 val = atomic_dec_if_positive(&team->mcast_rejoin.count_pending); 704 if (val < 0) { 705 rtnl_unlock(); 706 return; 707 } 708 call_netdevice_notifiers(NETDEV_RESEND_IGMP, team->dev); 709 rtnl_unlock(); 710 if (val) 711 schedule_delayed_work(&team->mcast_rejoin.dw, 712 msecs_to_jiffies(team->mcast_rejoin.interval)); 713 } 714 715 static void team_mcast_rejoin(struct team *team) 716 { 717 if (!team->mcast_rejoin.count || !netif_running(team->dev)) 718 return; 719 atomic_add(team->mcast_rejoin.count, &team->mcast_rejoin.count_pending); 720 schedule_delayed_work(&team->mcast_rejoin.dw, 0); 721 } 722 723 static void team_mcast_rejoin_init(struct team *team) 724 { 725 INIT_DELAYED_WORK(&team->mcast_rejoin.dw, team_mcast_rejoin_work); 726 } 727 728 static void team_mcast_rejoin_fini(struct team *team) 729 { 730 cancel_delayed_work_sync(&team->mcast_rejoin.dw); 731 } 732 733 734 /************************ 735 * Rx path frame handler 736 ************************/ 737 738 /* note: already called with rcu_read_lock */ 739 static rx_handler_result_t team_handle_frame(struct sk_buff **pskb) 740 { 741 struct sk_buff *skb = *pskb; 742 struct team_port *port; 743 struct team *team; 744 rx_handler_result_t res; 745 746 skb = skb_share_check(skb, GFP_ATOMIC); 747 if (!skb) 748 return RX_HANDLER_CONSUMED; 749 750 *pskb = skb; 751 752 port = team_port_get_rcu(skb->dev); 753 team = port->team; 754 if (!team_port_enabled(port)) { 755 /* allow exact match delivery for disabled ports */ 756 res = RX_HANDLER_EXACT; 757 } else { 758 res = team->ops.receive(team, port, skb); 759 } 760 if (res == RX_HANDLER_ANOTHER) { 761 struct team_pcpu_stats *pcpu_stats; 762 763 pcpu_stats = this_cpu_ptr(team->pcpu_stats); 764 u64_stats_update_begin(&pcpu_stats->syncp); 765 pcpu_stats->rx_packets++; 766 pcpu_stats->rx_bytes += skb->len; 767 if (skb->pkt_type == PACKET_MULTICAST) 768 pcpu_stats->rx_multicast++; 769 u64_stats_update_end(&pcpu_stats->syncp); 770 771 skb->dev = team->dev; 772 } else if (res == RX_HANDLER_EXACT) { 773 this_cpu_inc(team->pcpu_stats->rx_nohandler); 774 } else { 775 this_cpu_inc(team->pcpu_stats->rx_dropped); 776 } 777 778 return res; 779 } 780 781 782 /************************************* 783 * Multiqueue Tx port select override 784 *************************************/ 785 786 static int team_queue_override_init(struct team *team) 787 { 788 struct list_head *listarr; 789 unsigned int queue_cnt = team->dev->num_tx_queues - 1; 790 unsigned int i; 791 792 if (!queue_cnt) 793 return 0; 794 listarr = kmalloc(sizeof(struct list_head) * queue_cnt, GFP_KERNEL); 795 if (!listarr) 796 return -ENOMEM; 797 team->qom_lists = listarr; 798 for (i = 0; i < queue_cnt; i++) 799 INIT_LIST_HEAD(listarr++); 800 return 0; 801 } 802 803 static void team_queue_override_fini(struct team *team) 804 { 805 kfree(team->qom_lists); 806 } 807 808 static struct list_head *__team_get_qom_list(struct team *team, u16 queue_id) 809 { 810 return &team->qom_lists[queue_id - 1]; 811 } 812 813 /* 814 * note: already called with rcu_read_lock 815 */ 816 static bool team_queue_override_transmit(struct team *team, struct sk_buff *skb) 817 { 818 struct list_head *qom_list; 819 struct team_port *port; 820 821 if (!team->queue_override_enabled || !skb->queue_mapping) 822 return false; 823 qom_list = __team_get_qom_list(team, skb->queue_mapping); 824 list_for_each_entry_rcu(port, qom_list, qom_list) { 825 if (!team_dev_queue_xmit(team, port, skb)) 826 return true; 827 } 828 return false; 829 } 830 831 static void __team_queue_override_port_del(struct team *team, 832 struct team_port *port) 833 { 834 if (!port->queue_id) 835 return; 836 list_del_rcu(&port->qom_list); 837 } 838 839 static bool team_queue_override_port_has_gt_prio_than(struct team_port *port, 840 struct team_port *cur) 841 { 842 if (port->priority < cur->priority) 843 return true; 844 if (port->priority > cur->priority) 845 return false; 846 if (port->index < cur->index) 847 return true; 848 return false; 849 } 850 851 static void __team_queue_override_port_add(struct team *team, 852 struct team_port *port) 853 { 854 struct team_port *cur; 855 struct list_head *qom_list; 856 struct list_head *node; 857 858 if (!port->queue_id) 859 return; 860 qom_list = __team_get_qom_list(team, port->queue_id); 861 node = qom_list; 862 list_for_each_entry(cur, qom_list, qom_list) { 863 if (team_queue_override_port_has_gt_prio_than(port, cur)) 864 break; 865 node = &cur->qom_list; 866 } 867 list_add_tail_rcu(&port->qom_list, node); 868 } 869 870 static void __team_queue_override_enabled_check(struct team *team) 871 { 872 struct team_port *port; 873 bool enabled = false; 874 875 list_for_each_entry(port, &team->port_list, list) { 876 if (port->queue_id) { 877 enabled = true; 878 break; 879 } 880 } 881 if (enabled == team->queue_override_enabled) 882 return; 883 netdev_dbg(team->dev, "%s queue override\n", 884 enabled ? "Enabling" : "Disabling"); 885 team->queue_override_enabled = enabled; 886 } 887 888 static void team_queue_override_port_prio_changed(struct team *team, 889 struct team_port *port) 890 { 891 if (!port->queue_id || team_port_enabled(port)) 892 return; 893 __team_queue_override_port_del(team, port); 894 __team_queue_override_port_add(team, port); 895 __team_queue_override_enabled_check(team); 896 } 897 898 static void team_queue_override_port_change_queue_id(struct team *team, 899 struct team_port *port, 900 u16 new_queue_id) 901 { 902 if (team_port_enabled(port)) { 903 __team_queue_override_port_del(team, port); 904 port->queue_id = new_queue_id; 905 __team_queue_override_port_add(team, port); 906 __team_queue_override_enabled_check(team); 907 } else { 908 port->queue_id = new_queue_id; 909 } 910 } 911 912 static void team_queue_override_port_add(struct team *team, 913 struct team_port *port) 914 { 915 __team_queue_override_port_add(team, port); 916 __team_queue_override_enabled_check(team); 917 } 918 919 static void team_queue_override_port_del(struct team *team, 920 struct team_port *port) 921 { 922 __team_queue_override_port_del(team, port); 923 __team_queue_override_enabled_check(team); 924 } 925 926 927 /**************** 928 * Port handling 929 ****************/ 930 931 static bool team_port_find(const struct team *team, 932 const struct team_port *port) 933 { 934 struct team_port *cur; 935 936 list_for_each_entry(cur, &team->port_list, list) 937 if (cur == port) 938 return true; 939 return false; 940 } 941 942 /* 943 * Enable/disable port by adding to enabled port hashlist and setting 944 * port->index (Might be racy so reader could see incorrect ifindex when 945 * processing a flying packet, but that is not a problem). Write guarded 946 * by team->lock. 947 */ 948 static void team_port_enable(struct team *team, 949 struct team_port *port) 950 { 951 if (team_port_enabled(port)) 952 return; 953 port->index = team->en_port_count++; 954 hlist_add_head_rcu(&port->hlist, 955 team_port_index_hash(team, port->index)); 956 team_adjust_ops(team); 957 team_queue_override_port_add(team, port); 958 if (team->ops.port_enabled) 959 team->ops.port_enabled(team, port); 960 team_notify_peers(team); 961 team_mcast_rejoin(team); 962 team_lower_state_changed(port); 963 } 964 965 static void __reconstruct_port_hlist(struct team *team, int rm_index) 966 { 967 int i; 968 struct team_port *port; 969 970 for (i = rm_index + 1; i < team->en_port_count; i++) { 971 port = team_get_port_by_index(team, i); 972 hlist_del_rcu(&port->hlist); 973 port->index--; 974 hlist_add_head_rcu(&port->hlist, 975 team_port_index_hash(team, port->index)); 976 } 977 } 978 979 static void team_port_disable(struct team *team, 980 struct team_port *port) 981 { 982 if (!team_port_enabled(port)) 983 return; 984 if (team->ops.port_disabled) 985 team->ops.port_disabled(team, port); 986 hlist_del_rcu(&port->hlist); 987 __reconstruct_port_hlist(team, port->index); 988 port->index = -1; 989 team->en_port_count--; 990 team_queue_override_port_del(team, port); 991 team_adjust_ops(team); 992 team_notify_peers(team); 993 team_mcast_rejoin(team); 994 team_lower_state_changed(port); 995 } 996 997 #define TEAM_VLAN_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \ 998 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \ 999 NETIF_F_HIGHDMA | NETIF_F_LRO) 1000 1001 #define TEAM_ENC_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \ 1002 NETIF_F_RXCSUM | NETIF_F_ALL_TSO) 1003 1004 static void __team_compute_features(struct team *team) 1005 { 1006 struct team_port *port; 1007 u32 vlan_features = TEAM_VLAN_FEATURES & NETIF_F_ALL_FOR_ALL; 1008 netdev_features_t enc_features = TEAM_ENC_FEATURES; 1009 unsigned short max_hard_header_len = ETH_HLEN; 1010 unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE | 1011 IFF_XMIT_DST_RELEASE_PERM; 1012 1013 list_for_each_entry(port, &team->port_list, list) { 1014 vlan_features = netdev_increment_features(vlan_features, 1015 port->dev->vlan_features, 1016 TEAM_VLAN_FEATURES); 1017 enc_features = 1018 netdev_increment_features(enc_features, 1019 port->dev->hw_enc_features, 1020 TEAM_ENC_FEATURES); 1021 1022 1023 dst_release_flag &= port->dev->priv_flags; 1024 if (port->dev->hard_header_len > max_hard_header_len) 1025 max_hard_header_len = port->dev->hard_header_len; 1026 } 1027 1028 team->dev->vlan_features = vlan_features; 1029 team->dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL; 1030 team->dev->hard_header_len = max_hard_header_len; 1031 1032 team->dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; 1033 if (dst_release_flag == (IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM)) 1034 team->dev->priv_flags |= IFF_XMIT_DST_RELEASE; 1035 } 1036 1037 static void team_compute_features(struct team *team) 1038 { 1039 mutex_lock(&team->lock); 1040 __team_compute_features(team); 1041 mutex_unlock(&team->lock); 1042 netdev_change_features(team->dev); 1043 } 1044 1045 static int team_port_enter(struct team *team, struct team_port *port) 1046 { 1047 int err = 0; 1048 1049 dev_hold(team->dev); 1050 if (team->ops.port_enter) { 1051 err = team->ops.port_enter(team, port); 1052 if (err) { 1053 netdev_err(team->dev, "Device %s failed to enter team mode\n", 1054 port->dev->name); 1055 goto err_port_enter; 1056 } 1057 } 1058 1059 return 0; 1060 1061 err_port_enter: 1062 dev_put(team->dev); 1063 1064 return err; 1065 } 1066 1067 static void team_port_leave(struct team *team, struct team_port *port) 1068 { 1069 if (team->ops.port_leave) 1070 team->ops.port_leave(team, port); 1071 dev_put(team->dev); 1072 } 1073 1074 #ifdef CONFIG_NET_POLL_CONTROLLER 1075 static int __team_port_enable_netpoll(struct team_port *port) 1076 { 1077 struct netpoll *np; 1078 int err; 1079 1080 np = kzalloc(sizeof(*np), GFP_KERNEL); 1081 if (!np) 1082 return -ENOMEM; 1083 1084 err = __netpoll_setup(np, port->dev); 1085 if (err) { 1086 kfree(np); 1087 return err; 1088 } 1089 port->np = np; 1090 return err; 1091 } 1092 1093 static int team_port_enable_netpoll(struct team_port *port) 1094 { 1095 if (!port->team->dev->npinfo) 1096 return 0; 1097 1098 return __team_port_enable_netpoll(port); 1099 } 1100 1101 static void team_port_disable_netpoll(struct team_port *port) 1102 { 1103 struct netpoll *np = port->np; 1104 1105 if (!np) 1106 return; 1107 port->np = NULL; 1108 1109 /* Wait for transmitting packets to finish before freeing. */ 1110 synchronize_rcu_bh(); 1111 __netpoll_cleanup(np); 1112 kfree(np); 1113 } 1114 #else 1115 static int team_port_enable_netpoll(struct team_port *port) 1116 { 1117 return 0; 1118 } 1119 static void team_port_disable_netpoll(struct team_port *port) 1120 { 1121 } 1122 #endif 1123 1124 static int team_upper_dev_link(struct team *team, struct team_port *port, 1125 struct netlink_ext_ack *extack) 1126 { 1127 struct netdev_lag_upper_info lag_upper_info; 1128 int err; 1129 1130 lag_upper_info.tx_type = team->mode->lag_tx_type; 1131 err = netdev_master_upper_dev_link(port->dev, team->dev, NULL, 1132 &lag_upper_info, extack); 1133 if (err) 1134 return err; 1135 port->dev->priv_flags |= IFF_TEAM_PORT; 1136 return 0; 1137 } 1138 1139 static void team_upper_dev_unlink(struct team *team, struct team_port *port) 1140 { 1141 netdev_upper_dev_unlink(port->dev, team->dev); 1142 port->dev->priv_flags &= ~IFF_TEAM_PORT; 1143 } 1144 1145 static void __team_port_change_port_added(struct team_port *port, bool linkup); 1146 static int team_dev_type_check_change(struct net_device *dev, 1147 struct net_device *port_dev); 1148 1149 static int team_port_add(struct team *team, struct net_device *port_dev, 1150 struct netlink_ext_ack *extack) 1151 { 1152 struct net_device *dev = team->dev; 1153 struct team_port *port; 1154 char *portname = port_dev->name; 1155 int err; 1156 1157 if (port_dev->flags & IFF_LOOPBACK) { 1158 NL_SET_ERR_MSG(extack, "Loopback device can't be added as a team port"); 1159 netdev_err(dev, "Device %s is loopback device. Loopback devices can't be added as a team port\n", 1160 portname); 1161 return -EINVAL; 1162 } 1163 1164 if (team_port_exists(port_dev)) { 1165 NL_SET_ERR_MSG(extack, "Device is already a port of a team device"); 1166 netdev_err(dev, "Device %s is already a port " 1167 "of a team device\n", portname); 1168 return -EBUSY; 1169 } 1170 1171 if (port_dev->features & NETIF_F_VLAN_CHALLENGED && 1172 vlan_uses_dev(dev)) { 1173 NL_SET_ERR_MSG(extack, "Device is VLAN challenged and team device has VLAN set up"); 1174 netdev_err(dev, "Device %s is VLAN challenged and team device has VLAN set up\n", 1175 portname); 1176 return -EPERM; 1177 } 1178 1179 err = team_dev_type_check_change(dev, port_dev); 1180 if (err) 1181 return err; 1182 1183 if (port_dev->flags & IFF_UP) { 1184 NL_SET_ERR_MSG(extack, "Device is up. Set it down before adding it as a team port"); 1185 netdev_err(dev, "Device %s is up. Set it down before adding it as a team port\n", 1186 portname); 1187 return -EBUSY; 1188 } 1189 1190 port = kzalloc(sizeof(struct team_port) + team->mode->port_priv_size, 1191 GFP_KERNEL); 1192 if (!port) 1193 return -ENOMEM; 1194 1195 port->dev = port_dev; 1196 port->team = team; 1197 INIT_LIST_HEAD(&port->qom_list); 1198 1199 port->orig.mtu = port_dev->mtu; 1200 err = dev_set_mtu(port_dev, dev->mtu); 1201 if (err) { 1202 netdev_dbg(dev, "Error %d calling dev_set_mtu\n", err); 1203 goto err_set_mtu; 1204 } 1205 1206 memcpy(port->orig.dev_addr, port_dev->dev_addr, port_dev->addr_len); 1207 1208 err = team_port_enter(team, port); 1209 if (err) { 1210 netdev_err(dev, "Device %s failed to enter team mode\n", 1211 portname); 1212 goto err_port_enter; 1213 } 1214 1215 err = dev_open(port_dev); 1216 if (err) { 1217 netdev_dbg(dev, "Device %s opening failed\n", 1218 portname); 1219 goto err_dev_open; 1220 } 1221 1222 err = vlan_vids_add_by_dev(port_dev, dev); 1223 if (err) { 1224 netdev_err(dev, "Failed to add vlan ids to device %s\n", 1225 portname); 1226 goto err_vids_add; 1227 } 1228 1229 err = team_port_enable_netpoll(port); 1230 if (err) { 1231 netdev_err(dev, "Failed to enable netpoll on device %s\n", 1232 portname); 1233 goto err_enable_netpoll; 1234 } 1235 1236 if (!(dev->features & NETIF_F_LRO)) 1237 dev_disable_lro(port_dev); 1238 1239 err = netdev_rx_handler_register(port_dev, team_handle_frame, 1240 port); 1241 if (err) { 1242 netdev_err(dev, "Device %s failed to register rx_handler\n", 1243 portname); 1244 goto err_handler_register; 1245 } 1246 1247 err = team_upper_dev_link(team, port, extack); 1248 if (err) { 1249 netdev_err(dev, "Device %s failed to set upper link\n", 1250 portname); 1251 goto err_set_upper_link; 1252 } 1253 1254 err = __team_option_inst_add_port(team, port); 1255 if (err) { 1256 netdev_err(dev, "Device %s failed to add per-port options\n", 1257 portname); 1258 goto err_option_port_add; 1259 } 1260 1261 netif_addr_lock_bh(dev); 1262 dev_uc_sync_multiple(port_dev, dev); 1263 dev_mc_sync_multiple(port_dev, dev); 1264 netif_addr_unlock_bh(dev); 1265 1266 port->index = -1; 1267 list_add_tail_rcu(&port->list, &team->port_list); 1268 team_port_enable(team, port); 1269 __team_compute_features(team); 1270 __team_port_change_port_added(port, !!netif_carrier_ok(port_dev)); 1271 __team_options_change_check(team); 1272 1273 netdev_info(dev, "Port device %s added\n", portname); 1274 1275 return 0; 1276 1277 err_option_port_add: 1278 team_upper_dev_unlink(team, port); 1279 1280 err_set_upper_link: 1281 netdev_rx_handler_unregister(port_dev); 1282 1283 err_handler_register: 1284 team_port_disable_netpoll(port); 1285 1286 err_enable_netpoll: 1287 vlan_vids_del_by_dev(port_dev, dev); 1288 1289 err_vids_add: 1290 dev_close(port_dev); 1291 1292 err_dev_open: 1293 team_port_leave(team, port); 1294 team_port_set_orig_dev_addr(port); 1295 1296 err_port_enter: 1297 dev_set_mtu(port_dev, port->orig.mtu); 1298 1299 err_set_mtu: 1300 kfree(port); 1301 1302 return err; 1303 } 1304 1305 static void __team_port_change_port_removed(struct team_port *port); 1306 1307 static int team_port_del(struct team *team, struct net_device *port_dev) 1308 { 1309 struct net_device *dev = team->dev; 1310 struct team_port *port; 1311 char *portname = port_dev->name; 1312 1313 port = team_port_get_rtnl(port_dev); 1314 if (!port || !team_port_find(team, port)) { 1315 netdev_err(dev, "Device %s does not act as a port of this team\n", 1316 portname); 1317 return -ENOENT; 1318 } 1319 1320 team_port_disable(team, port); 1321 list_del_rcu(&port->list); 1322 team_upper_dev_unlink(team, port); 1323 netdev_rx_handler_unregister(port_dev); 1324 team_port_disable_netpoll(port); 1325 vlan_vids_del_by_dev(port_dev, dev); 1326 dev_uc_unsync(port_dev, dev); 1327 dev_mc_unsync(port_dev, dev); 1328 dev_close(port_dev); 1329 team_port_leave(team, port); 1330 1331 __team_option_inst_mark_removed_port(team, port); 1332 __team_options_change_check(team); 1333 __team_option_inst_del_port(team, port); 1334 __team_port_change_port_removed(port); 1335 1336 team_port_set_orig_dev_addr(port); 1337 dev_set_mtu(port_dev, port->orig.mtu); 1338 kfree_rcu(port, rcu); 1339 netdev_info(dev, "Port device %s removed\n", portname); 1340 __team_compute_features(team); 1341 1342 return 0; 1343 } 1344 1345 1346 /***************** 1347 * Net device ops 1348 *****************/ 1349 1350 static int team_mode_option_get(struct team *team, struct team_gsetter_ctx *ctx) 1351 { 1352 ctx->data.str_val = team->mode->kind; 1353 return 0; 1354 } 1355 1356 static int team_mode_option_set(struct team *team, struct team_gsetter_ctx *ctx) 1357 { 1358 return team_change_mode(team, ctx->data.str_val); 1359 } 1360 1361 static int team_notify_peers_count_get(struct team *team, 1362 struct team_gsetter_ctx *ctx) 1363 { 1364 ctx->data.u32_val = team->notify_peers.count; 1365 return 0; 1366 } 1367 1368 static int team_notify_peers_count_set(struct team *team, 1369 struct team_gsetter_ctx *ctx) 1370 { 1371 team->notify_peers.count = ctx->data.u32_val; 1372 return 0; 1373 } 1374 1375 static int team_notify_peers_interval_get(struct team *team, 1376 struct team_gsetter_ctx *ctx) 1377 { 1378 ctx->data.u32_val = team->notify_peers.interval; 1379 return 0; 1380 } 1381 1382 static int team_notify_peers_interval_set(struct team *team, 1383 struct team_gsetter_ctx *ctx) 1384 { 1385 team->notify_peers.interval = ctx->data.u32_val; 1386 return 0; 1387 } 1388 1389 static int team_mcast_rejoin_count_get(struct team *team, 1390 struct team_gsetter_ctx *ctx) 1391 { 1392 ctx->data.u32_val = team->mcast_rejoin.count; 1393 return 0; 1394 } 1395 1396 static int team_mcast_rejoin_count_set(struct team *team, 1397 struct team_gsetter_ctx *ctx) 1398 { 1399 team->mcast_rejoin.count = ctx->data.u32_val; 1400 return 0; 1401 } 1402 1403 static int team_mcast_rejoin_interval_get(struct team *team, 1404 struct team_gsetter_ctx *ctx) 1405 { 1406 ctx->data.u32_val = team->mcast_rejoin.interval; 1407 return 0; 1408 } 1409 1410 static int team_mcast_rejoin_interval_set(struct team *team, 1411 struct team_gsetter_ctx *ctx) 1412 { 1413 team->mcast_rejoin.interval = ctx->data.u32_val; 1414 return 0; 1415 } 1416 1417 static int team_port_en_option_get(struct team *team, 1418 struct team_gsetter_ctx *ctx) 1419 { 1420 struct team_port *port = ctx->info->port; 1421 1422 ctx->data.bool_val = team_port_enabled(port); 1423 return 0; 1424 } 1425 1426 static int team_port_en_option_set(struct team *team, 1427 struct team_gsetter_ctx *ctx) 1428 { 1429 struct team_port *port = ctx->info->port; 1430 1431 if (ctx->data.bool_val) 1432 team_port_enable(team, port); 1433 else 1434 team_port_disable(team, port); 1435 return 0; 1436 } 1437 1438 static int team_user_linkup_option_get(struct team *team, 1439 struct team_gsetter_ctx *ctx) 1440 { 1441 struct team_port *port = ctx->info->port; 1442 1443 ctx->data.bool_val = port->user.linkup; 1444 return 0; 1445 } 1446 1447 static void __team_carrier_check(struct team *team); 1448 1449 static int team_user_linkup_option_set(struct team *team, 1450 struct team_gsetter_ctx *ctx) 1451 { 1452 struct team_port *port = ctx->info->port; 1453 1454 port->user.linkup = ctx->data.bool_val; 1455 team_refresh_port_linkup(port); 1456 __team_carrier_check(port->team); 1457 return 0; 1458 } 1459 1460 static int team_user_linkup_en_option_get(struct team *team, 1461 struct team_gsetter_ctx *ctx) 1462 { 1463 struct team_port *port = ctx->info->port; 1464 1465 ctx->data.bool_val = port->user.linkup_enabled; 1466 return 0; 1467 } 1468 1469 static int team_user_linkup_en_option_set(struct team *team, 1470 struct team_gsetter_ctx *ctx) 1471 { 1472 struct team_port *port = ctx->info->port; 1473 1474 port->user.linkup_enabled = ctx->data.bool_val; 1475 team_refresh_port_linkup(port); 1476 __team_carrier_check(port->team); 1477 return 0; 1478 } 1479 1480 static int team_priority_option_get(struct team *team, 1481 struct team_gsetter_ctx *ctx) 1482 { 1483 struct team_port *port = ctx->info->port; 1484 1485 ctx->data.s32_val = port->priority; 1486 return 0; 1487 } 1488 1489 static int team_priority_option_set(struct team *team, 1490 struct team_gsetter_ctx *ctx) 1491 { 1492 struct team_port *port = ctx->info->port; 1493 s32 priority = ctx->data.s32_val; 1494 1495 if (port->priority == priority) 1496 return 0; 1497 port->priority = priority; 1498 team_queue_override_port_prio_changed(team, port); 1499 return 0; 1500 } 1501 1502 static int team_queue_id_option_get(struct team *team, 1503 struct team_gsetter_ctx *ctx) 1504 { 1505 struct team_port *port = ctx->info->port; 1506 1507 ctx->data.u32_val = port->queue_id; 1508 return 0; 1509 } 1510 1511 static int team_queue_id_option_set(struct team *team, 1512 struct team_gsetter_ctx *ctx) 1513 { 1514 struct team_port *port = ctx->info->port; 1515 u16 new_queue_id = ctx->data.u32_val; 1516 1517 if (port->queue_id == new_queue_id) 1518 return 0; 1519 if (new_queue_id >= team->dev->real_num_tx_queues) 1520 return -EINVAL; 1521 team_queue_override_port_change_queue_id(team, port, new_queue_id); 1522 return 0; 1523 } 1524 1525 static const struct team_option team_options[] = { 1526 { 1527 .name = "mode", 1528 .type = TEAM_OPTION_TYPE_STRING, 1529 .getter = team_mode_option_get, 1530 .setter = team_mode_option_set, 1531 }, 1532 { 1533 .name = "notify_peers_count", 1534 .type = TEAM_OPTION_TYPE_U32, 1535 .getter = team_notify_peers_count_get, 1536 .setter = team_notify_peers_count_set, 1537 }, 1538 { 1539 .name = "notify_peers_interval", 1540 .type = TEAM_OPTION_TYPE_U32, 1541 .getter = team_notify_peers_interval_get, 1542 .setter = team_notify_peers_interval_set, 1543 }, 1544 { 1545 .name = "mcast_rejoin_count", 1546 .type = TEAM_OPTION_TYPE_U32, 1547 .getter = team_mcast_rejoin_count_get, 1548 .setter = team_mcast_rejoin_count_set, 1549 }, 1550 { 1551 .name = "mcast_rejoin_interval", 1552 .type = TEAM_OPTION_TYPE_U32, 1553 .getter = team_mcast_rejoin_interval_get, 1554 .setter = team_mcast_rejoin_interval_set, 1555 }, 1556 { 1557 .name = "enabled", 1558 .type = TEAM_OPTION_TYPE_BOOL, 1559 .per_port = true, 1560 .getter = team_port_en_option_get, 1561 .setter = team_port_en_option_set, 1562 }, 1563 { 1564 .name = "user_linkup", 1565 .type = TEAM_OPTION_TYPE_BOOL, 1566 .per_port = true, 1567 .getter = team_user_linkup_option_get, 1568 .setter = team_user_linkup_option_set, 1569 }, 1570 { 1571 .name = "user_linkup_enabled", 1572 .type = TEAM_OPTION_TYPE_BOOL, 1573 .per_port = true, 1574 .getter = team_user_linkup_en_option_get, 1575 .setter = team_user_linkup_en_option_set, 1576 }, 1577 { 1578 .name = "priority", 1579 .type = TEAM_OPTION_TYPE_S32, 1580 .per_port = true, 1581 .getter = team_priority_option_get, 1582 .setter = team_priority_option_set, 1583 }, 1584 { 1585 .name = "queue_id", 1586 .type = TEAM_OPTION_TYPE_U32, 1587 .per_port = true, 1588 .getter = team_queue_id_option_get, 1589 .setter = team_queue_id_option_set, 1590 }, 1591 }; 1592 1593 1594 static int team_init(struct net_device *dev) 1595 { 1596 struct team *team = netdev_priv(dev); 1597 int i; 1598 int err; 1599 1600 team->dev = dev; 1601 mutex_init(&team->lock); 1602 team_set_no_mode(team); 1603 1604 team->pcpu_stats = netdev_alloc_pcpu_stats(struct team_pcpu_stats); 1605 if (!team->pcpu_stats) 1606 return -ENOMEM; 1607 1608 for (i = 0; i < TEAM_PORT_HASHENTRIES; i++) 1609 INIT_HLIST_HEAD(&team->en_port_hlist[i]); 1610 INIT_LIST_HEAD(&team->port_list); 1611 err = team_queue_override_init(team); 1612 if (err) 1613 goto err_team_queue_override_init; 1614 1615 team_adjust_ops(team); 1616 1617 INIT_LIST_HEAD(&team->option_list); 1618 INIT_LIST_HEAD(&team->option_inst_list); 1619 1620 team_notify_peers_init(team); 1621 team_mcast_rejoin_init(team); 1622 1623 err = team_options_register(team, team_options, ARRAY_SIZE(team_options)); 1624 if (err) 1625 goto err_options_register; 1626 netif_carrier_off(dev); 1627 1628 netdev_lockdep_set_classes(dev); 1629 1630 return 0; 1631 1632 err_options_register: 1633 team_mcast_rejoin_fini(team); 1634 team_notify_peers_fini(team); 1635 team_queue_override_fini(team); 1636 err_team_queue_override_init: 1637 free_percpu(team->pcpu_stats); 1638 1639 return err; 1640 } 1641 1642 static void team_uninit(struct net_device *dev) 1643 { 1644 struct team *team = netdev_priv(dev); 1645 struct team_port *port; 1646 struct team_port *tmp; 1647 1648 mutex_lock(&team->lock); 1649 list_for_each_entry_safe(port, tmp, &team->port_list, list) 1650 team_port_del(team, port->dev); 1651 1652 __team_change_mode(team, NULL); /* cleanup */ 1653 __team_options_unregister(team, team_options, ARRAY_SIZE(team_options)); 1654 team_mcast_rejoin_fini(team); 1655 team_notify_peers_fini(team); 1656 team_queue_override_fini(team); 1657 mutex_unlock(&team->lock); 1658 netdev_change_features(dev); 1659 } 1660 1661 static void team_destructor(struct net_device *dev) 1662 { 1663 struct team *team = netdev_priv(dev); 1664 1665 free_percpu(team->pcpu_stats); 1666 } 1667 1668 static int team_open(struct net_device *dev) 1669 { 1670 return 0; 1671 } 1672 1673 static int team_close(struct net_device *dev) 1674 { 1675 return 0; 1676 } 1677 1678 /* 1679 * note: already called with rcu_read_lock 1680 */ 1681 static netdev_tx_t team_xmit(struct sk_buff *skb, struct net_device *dev) 1682 { 1683 struct team *team = netdev_priv(dev); 1684 bool tx_success; 1685 unsigned int len = skb->len; 1686 1687 tx_success = team_queue_override_transmit(team, skb); 1688 if (!tx_success) 1689 tx_success = team->ops.transmit(team, skb); 1690 if (tx_success) { 1691 struct team_pcpu_stats *pcpu_stats; 1692 1693 pcpu_stats = this_cpu_ptr(team->pcpu_stats); 1694 u64_stats_update_begin(&pcpu_stats->syncp); 1695 pcpu_stats->tx_packets++; 1696 pcpu_stats->tx_bytes += len; 1697 u64_stats_update_end(&pcpu_stats->syncp); 1698 } else { 1699 this_cpu_inc(team->pcpu_stats->tx_dropped); 1700 } 1701 1702 return NETDEV_TX_OK; 1703 } 1704 1705 static u16 team_select_queue(struct net_device *dev, struct sk_buff *skb, 1706 void *accel_priv, select_queue_fallback_t fallback) 1707 { 1708 /* 1709 * This helper function exists to help dev_pick_tx get the correct 1710 * destination queue. Using a helper function skips a call to 1711 * skb_tx_hash and will put the skbs in the queue we expect on their 1712 * way down to the team driver. 1713 */ 1714 u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0; 1715 1716 /* 1717 * Save the original txq to restore before passing to the driver 1718 */ 1719 qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping; 1720 1721 if (unlikely(txq >= dev->real_num_tx_queues)) { 1722 do { 1723 txq -= dev->real_num_tx_queues; 1724 } while (txq >= dev->real_num_tx_queues); 1725 } 1726 return txq; 1727 } 1728 1729 static void team_change_rx_flags(struct net_device *dev, int change) 1730 { 1731 struct team *team = netdev_priv(dev); 1732 struct team_port *port; 1733 int inc; 1734 1735 rcu_read_lock(); 1736 list_for_each_entry_rcu(port, &team->port_list, list) { 1737 if (change & IFF_PROMISC) { 1738 inc = dev->flags & IFF_PROMISC ? 1 : -1; 1739 dev_set_promiscuity(port->dev, inc); 1740 } 1741 if (change & IFF_ALLMULTI) { 1742 inc = dev->flags & IFF_ALLMULTI ? 1 : -1; 1743 dev_set_allmulti(port->dev, inc); 1744 } 1745 } 1746 rcu_read_unlock(); 1747 } 1748 1749 static void team_set_rx_mode(struct net_device *dev) 1750 { 1751 struct team *team = netdev_priv(dev); 1752 struct team_port *port; 1753 1754 rcu_read_lock(); 1755 list_for_each_entry_rcu(port, &team->port_list, list) { 1756 dev_uc_sync_multiple(port->dev, dev); 1757 dev_mc_sync_multiple(port->dev, dev); 1758 } 1759 rcu_read_unlock(); 1760 } 1761 1762 static int team_set_mac_address(struct net_device *dev, void *p) 1763 { 1764 struct sockaddr *addr = p; 1765 struct team *team = netdev_priv(dev); 1766 struct team_port *port; 1767 1768 if (dev->type == ARPHRD_ETHER && !is_valid_ether_addr(addr->sa_data)) 1769 return -EADDRNOTAVAIL; 1770 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len); 1771 mutex_lock(&team->lock); 1772 list_for_each_entry(port, &team->port_list, list) 1773 if (team->ops.port_change_dev_addr) 1774 team->ops.port_change_dev_addr(team, port); 1775 mutex_unlock(&team->lock); 1776 return 0; 1777 } 1778 1779 static int team_change_mtu(struct net_device *dev, int new_mtu) 1780 { 1781 struct team *team = netdev_priv(dev); 1782 struct team_port *port; 1783 int err; 1784 1785 /* 1786 * Alhough this is reader, it's guarded by team lock. It's not possible 1787 * to traverse list in reverse under rcu_read_lock 1788 */ 1789 mutex_lock(&team->lock); 1790 team->port_mtu_change_allowed = true; 1791 list_for_each_entry(port, &team->port_list, list) { 1792 err = dev_set_mtu(port->dev, new_mtu); 1793 if (err) { 1794 netdev_err(dev, "Device %s failed to change mtu", 1795 port->dev->name); 1796 goto unwind; 1797 } 1798 } 1799 team->port_mtu_change_allowed = false; 1800 mutex_unlock(&team->lock); 1801 1802 dev->mtu = new_mtu; 1803 1804 return 0; 1805 1806 unwind: 1807 list_for_each_entry_continue_reverse(port, &team->port_list, list) 1808 dev_set_mtu(port->dev, dev->mtu); 1809 team->port_mtu_change_allowed = false; 1810 mutex_unlock(&team->lock); 1811 1812 return err; 1813 } 1814 1815 static void 1816 team_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats) 1817 { 1818 struct team *team = netdev_priv(dev); 1819 struct team_pcpu_stats *p; 1820 u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes; 1821 u32 rx_dropped = 0, tx_dropped = 0, rx_nohandler = 0; 1822 unsigned int start; 1823 int i; 1824 1825 for_each_possible_cpu(i) { 1826 p = per_cpu_ptr(team->pcpu_stats, i); 1827 do { 1828 start = u64_stats_fetch_begin_irq(&p->syncp); 1829 rx_packets = p->rx_packets; 1830 rx_bytes = p->rx_bytes; 1831 rx_multicast = p->rx_multicast; 1832 tx_packets = p->tx_packets; 1833 tx_bytes = p->tx_bytes; 1834 } while (u64_stats_fetch_retry_irq(&p->syncp, start)); 1835 1836 stats->rx_packets += rx_packets; 1837 stats->rx_bytes += rx_bytes; 1838 stats->multicast += rx_multicast; 1839 stats->tx_packets += tx_packets; 1840 stats->tx_bytes += tx_bytes; 1841 /* 1842 * rx_dropped, tx_dropped & rx_nohandler are u32, 1843 * updated without syncp protection. 1844 */ 1845 rx_dropped += p->rx_dropped; 1846 tx_dropped += p->tx_dropped; 1847 rx_nohandler += p->rx_nohandler; 1848 } 1849 stats->rx_dropped = rx_dropped; 1850 stats->tx_dropped = tx_dropped; 1851 stats->rx_nohandler = rx_nohandler; 1852 } 1853 1854 static int team_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid) 1855 { 1856 struct team *team = netdev_priv(dev); 1857 struct team_port *port; 1858 int err; 1859 1860 /* 1861 * Alhough this is reader, it's guarded by team lock. It's not possible 1862 * to traverse list in reverse under rcu_read_lock 1863 */ 1864 mutex_lock(&team->lock); 1865 list_for_each_entry(port, &team->port_list, list) { 1866 err = vlan_vid_add(port->dev, proto, vid); 1867 if (err) 1868 goto unwind; 1869 } 1870 mutex_unlock(&team->lock); 1871 1872 return 0; 1873 1874 unwind: 1875 list_for_each_entry_continue_reverse(port, &team->port_list, list) 1876 vlan_vid_del(port->dev, proto, vid); 1877 mutex_unlock(&team->lock); 1878 1879 return err; 1880 } 1881 1882 static int team_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid) 1883 { 1884 struct team *team = netdev_priv(dev); 1885 struct team_port *port; 1886 1887 mutex_lock(&team->lock); 1888 list_for_each_entry(port, &team->port_list, list) 1889 vlan_vid_del(port->dev, proto, vid); 1890 mutex_unlock(&team->lock); 1891 1892 return 0; 1893 } 1894 1895 #ifdef CONFIG_NET_POLL_CONTROLLER 1896 static void team_poll_controller(struct net_device *dev) 1897 { 1898 } 1899 1900 static void __team_netpoll_cleanup(struct team *team) 1901 { 1902 struct team_port *port; 1903 1904 list_for_each_entry(port, &team->port_list, list) 1905 team_port_disable_netpoll(port); 1906 } 1907 1908 static void team_netpoll_cleanup(struct net_device *dev) 1909 { 1910 struct team *team = netdev_priv(dev); 1911 1912 mutex_lock(&team->lock); 1913 __team_netpoll_cleanup(team); 1914 mutex_unlock(&team->lock); 1915 } 1916 1917 static int team_netpoll_setup(struct net_device *dev, 1918 struct netpoll_info *npifo) 1919 { 1920 struct team *team = netdev_priv(dev); 1921 struct team_port *port; 1922 int err = 0; 1923 1924 mutex_lock(&team->lock); 1925 list_for_each_entry(port, &team->port_list, list) { 1926 err = __team_port_enable_netpoll(port); 1927 if (err) { 1928 __team_netpoll_cleanup(team); 1929 break; 1930 } 1931 } 1932 mutex_unlock(&team->lock); 1933 return err; 1934 } 1935 #endif 1936 1937 static int team_add_slave(struct net_device *dev, struct net_device *port_dev, 1938 struct netlink_ext_ack *extack) 1939 { 1940 struct team *team = netdev_priv(dev); 1941 int err; 1942 1943 mutex_lock(&team->lock); 1944 err = team_port_add(team, port_dev, extack); 1945 mutex_unlock(&team->lock); 1946 1947 if (!err) 1948 netdev_change_features(dev); 1949 1950 return err; 1951 } 1952 1953 static int team_del_slave(struct net_device *dev, struct net_device *port_dev) 1954 { 1955 struct team *team = netdev_priv(dev); 1956 int err; 1957 1958 mutex_lock(&team->lock); 1959 err = team_port_del(team, port_dev); 1960 mutex_unlock(&team->lock); 1961 1962 if (!err) 1963 netdev_change_features(dev); 1964 1965 return err; 1966 } 1967 1968 static netdev_features_t team_fix_features(struct net_device *dev, 1969 netdev_features_t features) 1970 { 1971 struct team_port *port; 1972 struct team *team = netdev_priv(dev); 1973 netdev_features_t mask; 1974 1975 mask = features; 1976 features &= ~NETIF_F_ONE_FOR_ALL; 1977 features |= NETIF_F_ALL_FOR_ALL; 1978 1979 rcu_read_lock(); 1980 list_for_each_entry_rcu(port, &team->port_list, list) { 1981 features = netdev_increment_features(features, 1982 port->dev->features, 1983 mask); 1984 } 1985 rcu_read_unlock(); 1986 1987 features = netdev_add_tso_features(features, mask); 1988 1989 return features; 1990 } 1991 1992 static int team_change_carrier(struct net_device *dev, bool new_carrier) 1993 { 1994 struct team *team = netdev_priv(dev); 1995 1996 team->user_carrier_enabled = true; 1997 1998 if (new_carrier) 1999 netif_carrier_on(dev); 2000 else 2001 netif_carrier_off(dev); 2002 return 0; 2003 } 2004 2005 static const struct net_device_ops team_netdev_ops = { 2006 .ndo_init = team_init, 2007 .ndo_uninit = team_uninit, 2008 .ndo_open = team_open, 2009 .ndo_stop = team_close, 2010 .ndo_start_xmit = team_xmit, 2011 .ndo_select_queue = team_select_queue, 2012 .ndo_change_rx_flags = team_change_rx_flags, 2013 .ndo_set_rx_mode = team_set_rx_mode, 2014 .ndo_set_mac_address = team_set_mac_address, 2015 .ndo_change_mtu = team_change_mtu, 2016 .ndo_get_stats64 = team_get_stats64, 2017 .ndo_vlan_rx_add_vid = team_vlan_rx_add_vid, 2018 .ndo_vlan_rx_kill_vid = team_vlan_rx_kill_vid, 2019 #ifdef CONFIG_NET_POLL_CONTROLLER 2020 .ndo_poll_controller = team_poll_controller, 2021 .ndo_netpoll_setup = team_netpoll_setup, 2022 .ndo_netpoll_cleanup = team_netpoll_cleanup, 2023 #endif 2024 .ndo_add_slave = team_add_slave, 2025 .ndo_del_slave = team_del_slave, 2026 .ndo_fix_features = team_fix_features, 2027 .ndo_change_carrier = team_change_carrier, 2028 .ndo_features_check = passthru_features_check, 2029 }; 2030 2031 /*********************** 2032 * ethtool interface 2033 ***********************/ 2034 2035 static void team_ethtool_get_drvinfo(struct net_device *dev, 2036 struct ethtool_drvinfo *drvinfo) 2037 { 2038 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver)); 2039 strlcpy(drvinfo->version, UTS_RELEASE, sizeof(drvinfo->version)); 2040 } 2041 2042 static const struct ethtool_ops team_ethtool_ops = { 2043 .get_drvinfo = team_ethtool_get_drvinfo, 2044 .get_link = ethtool_op_get_link, 2045 }; 2046 2047 /*********************** 2048 * rt netlink interface 2049 ***********************/ 2050 2051 static void team_setup_by_port(struct net_device *dev, 2052 struct net_device *port_dev) 2053 { 2054 dev->header_ops = port_dev->header_ops; 2055 dev->type = port_dev->type; 2056 dev->hard_header_len = port_dev->hard_header_len; 2057 dev->addr_len = port_dev->addr_len; 2058 dev->mtu = port_dev->mtu; 2059 memcpy(dev->broadcast, port_dev->broadcast, port_dev->addr_len); 2060 eth_hw_addr_inherit(dev, port_dev); 2061 } 2062 2063 static int team_dev_type_check_change(struct net_device *dev, 2064 struct net_device *port_dev) 2065 { 2066 struct team *team = netdev_priv(dev); 2067 char *portname = port_dev->name; 2068 int err; 2069 2070 if (dev->type == port_dev->type) 2071 return 0; 2072 if (!list_empty(&team->port_list)) { 2073 netdev_err(dev, "Device %s is of different type\n", portname); 2074 return -EBUSY; 2075 } 2076 err = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE, dev); 2077 err = notifier_to_errno(err); 2078 if (err) { 2079 netdev_err(dev, "Refused to change device type\n"); 2080 return err; 2081 } 2082 dev_uc_flush(dev); 2083 dev_mc_flush(dev); 2084 team_setup_by_port(dev, port_dev); 2085 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, dev); 2086 return 0; 2087 } 2088 2089 static void team_setup(struct net_device *dev) 2090 { 2091 ether_setup(dev); 2092 dev->max_mtu = ETH_MAX_MTU; 2093 2094 dev->netdev_ops = &team_netdev_ops; 2095 dev->ethtool_ops = &team_ethtool_ops; 2096 dev->needs_free_netdev = true; 2097 dev->priv_destructor = team_destructor; 2098 dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING); 2099 dev->priv_flags |= IFF_NO_QUEUE; 2100 dev->priv_flags |= IFF_TEAM; 2101 2102 /* 2103 * Indicate we support unicast address filtering. That way core won't 2104 * bring us to promisc mode in case a unicast addr is added. 2105 * Let this up to underlay drivers. 2106 */ 2107 dev->priv_flags |= IFF_UNICAST_FLT | IFF_LIVE_ADDR_CHANGE; 2108 2109 dev->features |= NETIF_F_LLTX; 2110 dev->features |= NETIF_F_GRO; 2111 2112 /* Don't allow team devices to change network namespaces. */ 2113 dev->features |= NETIF_F_NETNS_LOCAL; 2114 2115 dev->hw_features = TEAM_VLAN_FEATURES | 2116 NETIF_F_HW_VLAN_CTAG_TX | 2117 NETIF_F_HW_VLAN_CTAG_RX | 2118 NETIF_F_HW_VLAN_CTAG_FILTER; 2119 2120 dev->hw_features |= NETIF_F_GSO_ENCAP_ALL; 2121 dev->features |= dev->hw_features; 2122 } 2123 2124 static int team_newlink(struct net *src_net, struct net_device *dev, 2125 struct nlattr *tb[], struct nlattr *data[], 2126 struct netlink_ext_ack *extack) 2127 { 2128 if (tb[IFLA_ADDRESS] == NULL) 2129 eth_hw_addr_random(dev); 2130 2131 return register_netdevice(dev); 2132 } 2133 2134 static int team_validate(struct nlattr *tb[], struct nlattr *data[], 2135 struct netlink_ext_ack *extack) 2136 { 2137 if (tb[IFLA_ADDRESS]) { 2138 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) 2139 return -EINVAL; 2140 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) 2141 return -EADDRNOTAVAIL; 2142 } 2143 return 0; 2144 } 2145 2146 static unsigned int team_get_num_tx_queues(void) 2147 { 2148 return TEAM_DEFAULT_NUM_TX_QUEUES; 2149 } 2150 2151 static unsigned int team_get_num_rx_queues(void) 2152 { 2153 return TEAM_DEFAULT_NUM_RX_QUEUES; 2154 } 2155 2156 static struct rtnl_link_ops team_link_ops __read_mostly = { 2157 .kind = DRV_NAME, 2158 .priv_size = sizeof(struct team), 2159 .setup = team_setup, 2160 .newlink = team_newlink, 2161 .validate = team_validate, 2162 .get_num_tx_queues = team_get_num_tx_queues, 2163 .get_num_rx_queues = team_get_num_rx_queues, 2164 }; 2165 2166 2167 /*********************************** 2168 * Generic netlink custom interface 2169 ***********************************/ 2170 2171 static struct genl_family team_nl_family; 2172 2173 static const struct nla_policy team_nl_policy[TEAM_ATTR_MAX + 1] = { 2174 [TEAM_ATTR_UNSPEC] = { .type = NLA_UNSPEC, }, 2175 [TEAM_ATTR_TEAM_IFINDEX] = { .type = NLA_U32 }, 2176 [TEAM_ATTR_LIST_OPTION] = { .type = NLA_NESTED }, 2177 [TEAM_ATTR_LIST_PORT] = { .type = NLA_NESTED }, 2178 }; 2179 2180 static const struct nla_policy 2181 team_nl_option_policy[TEAM_ATTR_OPTION_MAX + 1] = { 2182 [TEAM_ATTR_OPTION_UNSPEC] = { .type = NLA_UNSPEC, }, 2183 [TEAM_ATTR_OPTION_NAME] = { 2184 .type = NLA_STRING, 2185 .len = TEAM_STRING_MAX_LEN, 2186 }, 2187 [TEAM_ATTR_OPTION_CHANGED] = { .type = NLA_FLAG }, 2188 [TEAM_ATTR_OPTION_TYPE] = { .type = NLA_U8 }, 2189 [TEAM_ATTR_OPTION_DATA] = { .type = NLA_BINARY }, 2190 }; 2191 2192 static int team_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info) 2193 { 2194 struct sk_buff *msg; 2195 void *hdr; 2196 int err; 2197 2198 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 2199 if (!msg) 2200 return -ENOMEM; 2201 2202 hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq, 2203 &team_nl_family, 0, TEAM_CMD_NOOP); 2204 if (!hdr) { 2205 err = -EMSGSIZE; 2206 goto err_msg_put; 2207 } 2208 2209 genlmsg_end(msg, hdr); 2210 2211 return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid); 2212 2213 err_msg_put: 2214 nlmsg_free(msg); 2215 2216 return err; 2217 } 2218 2219 /* 2220 * Netlink cmd functions should be locked by following two functions. 2221 * Since dev gets held here, that ensures dev won't disappear in between. 2222 */ 2223 static struct team *team_nl_team_get(struct genl_info *info) 2224 { 2225 struct net *net = genl_info_net(info); 2226 int ifindex; 2227 struct net_device *dev; 2228 struct team *team; 2229 2230 if (!info->attrs[TEAM_ATTR_TEAM_IFINDEX]) 2231 return NULL; 2232 2233 ifindex = nla_get_u32(info->attrs[TEAM_ATTR_TEAM_IFINDEX]); 2234 dev = dev_get_by_index(net, ifindex); 2235 if (!dev || dev->netdev_ops != &team_netdev_ops) { 2236 if (dev) 2237 dev_put(dev); 2238 return NULL; 2239 } 2240 2241 team = netdev_priv(dev); 2242 mutex_lock(&team->lock); 2243 return team; 2244 } 2245 2246 static void team_nl_team_put(struct team *team) 2247 { 2248 mutex_unlock(&team->lock); 2249 dev_put(team->dev); 2250 } 2251 2252 typedef int team_nl_send_func_t(struct sk_buff *skb, 2253 struct team *team, u32 portid); 2254 2255 static int team_nl_send_unicast(struct sk_buff *skb, struct team *team, u32 portid) 2256 { 2257 return genlmsg_unicast(dev_net(team->dev), skb, portid); 2258 } 2259 2260 static int team_nl_fill_one_option_get(struct sk_buff *skb, struct team *team, 2261 struct team_option_inst *opt_inst) 2262 { 2263 struct nlattr *option_item; 2264 struct team_option *option = opt_inst->option; 2265 struct team_option_inst_info *opt_inst_info = &opt_inst->info; 2266 struct team_gsetter_ctx ctx; 2267 int err; 2268 2269 ctx.info = opt_inst_info; 2270 err = team_option_get(team, opt_inst, &ctx); 2271 if (err) 2272 return err; 2273 2274 option_item = nla_nest_start(skb, TEAM_ATTR_ITEM_OPTION); 2275 if (!option_item) 2276 return -EMSGSIZE; 2277 2278 if (nla_put_string(skb, TEAM_ATTR_OPTION_NAME, option->name)) 2279 goto nest_cancel; 2280 if (opt_inst_info->port && 2281 nla_put_u32(skb, TEAM_ATTR_OPTION_PORT_IFINDEX, 2282 opt_inst_info->port->dev->ifindex)) 2283 goto nest_cancel; 2284 if (opt_inst->option->array_size && 2285 nla_put_u32(skb, TEAM_ATTR_OPTION_ARRAY_INDEX, 2286 opt_inst_info->array_index)) 2287 goto nest_cancel; 2288 2289 switch (option->type) { 2290 case TEAM_OPTION_TYPE_U32: 2291 if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_U32)) 2292 goto nest_cancel; 2293 if (nla_put_u32(skb, TEAM_ATTR_OPTION_DATA, ctx.data.u32_val)) 2294 goto nest_cancel; 2295 break; 2296 case TEAM_OPTION_TYPE_STRING: 2297 if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_STRING)) 2298 goto nest_cancel; 2299 if (nla_put_string(skb, TEAM_ATTR_OPTION_DATA, 2300 ctx.data.str_val)) 2301 goto nest_cancel; 2302 break; 2303 case TEAM_OPTION_TYPE_BINARY: 2304 if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_BINARY)) 2305 goto nest_cancel; 2306 if (nla_put(skb, TEAM_ATTR_OPTION_DATA, ctx.data.bin_val.len, 2307 ctx.data.bin_val.ptr)) 2308 goto nest_cancel; 2309 break; 2310 case TEAM_OPTION_TYPE_BOOL: 2311 if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_FLAG)) 2312 goto nest_cancel; 2313 if (ctx.data.bool_val && 2314 nla_put_flag(skb, TEAM_ATTR_OPTION_DATA)) 2315 goto nest_cancel; 2316 break; 2317 case TEAM_OPTION_TYPE_S32: 2318 if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_S32)) 2319 goto nest_cancel; 2320 if (nla_put_s32(skb, TEAM_ATTR_OPTION_DATA, ctx.data.s32_val)) 2321 goto nest_cancel; 2322 break; 2323 default: 2324 BUG(); 2325 } 2326 if (opt_inst->removed && nla_put_flag(skb, TEAM_ATTR_OPTION_REMOVED)) 2327 goto nest_cancel; 2328 if (opt_inst->changed) { 2329 if (nla_put_flag(skb, TEAM_ATTR_OPTION_CHANGED)) 2330 goto nest_cancel; 2331 opt_inst->changed = false; 2332 } 2333 nla_nest_end(skb, option_item); 2334 return 0; 2335 2336 nest_cancel: 2337 nla_nest_cancel(skb, option_item); 2338 return -EMSGSIZE; 2339 } 2340 2341 static int __send_and_alloc_skb(struct sk_buff **pskb, 2342 struct team *team, u32 portid, 2343 team_nl_send_func_t *send_func) 2344 { 2345 int err; 2346 2347 if (*pskb) { 2348 err = send_func(*pskb, team, portid); 2349 if (err) 2350 return err; 2351 } 2352 *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL); 2353 if (!*pskb) 2354 return -ENOMEM; 2355 return 0; 2356 } 2357 2358 static int team_nl_send_options_get(struct team *team, u32 portid, u32 seq, 2359 int flags, team_nl_send_func_t *send_func, 2360 struct list_head *sel_opt_inst_list) 2361 { 2362 struct nlattr *option_list; 2363 struct nlmsghdr *nlh; 2364 void *hdr; 2365 struct team_option_inst *opt_inst; 2366 int err; 2367 struct sk_buff *skb = NULL; 2368 bool incomplete; 2369 int i; 2370 2371 opt_inst = list_first_entry(sel_opt_inst_list, 2372 struct team_option_inst, tmp_list); 2373 2374 start_again: 2375 err = __send_and_alloc_skb(&skb, team, portid, send_func); 2376 if (err) 2377 return err; 2378 2379 hdr = genlmsg_put(skb, portid, seq, &team_nl_family, flags | NLM_F_MULTI, 2380 TEAM_CMD_OPTIONS_GET); 2381 if (!hdr) { 2382 nlmsg_free(skb); 2383 return -EMSGSIZE; 2384 } 2385 2386 if (nla_put_u32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex)) 2387 goto nla_put_failure; 2388 option_list = nla_nest_start(skb, TEAM_ATTR_LIST_OPTION); 2389 if (!option_list) 2390 goto nla_put_failure; 2391 2392 i = 0; 2393 incomplete = false; 2394 list_for_each_entry_from(opt_inst, sel_opt_inst_list, tmp_list) { 2395 err = team_nl_fill_one_option_get(skb, team, opt_inst); 2396 if (err) { 2397 if (err == -EMSGSIZE) { 2398 if (!i) 2399 goto errout; 2400 incomplete = true; 2401 break; 2402 } 2403 goto errout; 2404 } 2405 i++; 2406 } 2407 2408 nla_nest_end(skb, option_list); 2409 genlmsg_end(skb, hdr); 2410 if (incomplete) 2411 goto start_again; 2412 2413 send_done: 2414 nlh = nlmsg_put(skb, portid, seq, NLMSG_DONE, 0, flags | NLM_F_MULTI); 2415 if (!nlh) { 2416 err = __send_and_alloc_skb(&skb, team, portid, send_func); 2417 if (err) 2418 return err; 2419 goto send_done; 2420 } 2421 2422 return send_func(skb, team, portid); 2423 2424 nla_put_failure: 2425 err = -EMSGSIZE; 2426 errout: 2427 genlmsg_cancel(skb, hdr); 2428 nlmsg_free(skb); 2429 return err; 2430 } 2431 2432 static int team_nl_cmd_options_get(struct sk_buff *skb, struct genl_info *info) 2433 { 2434 struct team *team; 2435 struct team_option_inst *opt_inst; 2436 int err; 2437 LIST_HEAD(sel_opt_inst_list); 2438 2439 team = team_nl_team_get(info); 2440 if (!team) 2441 return -EINVAL; 2442 2443 list_for_each_entry(opt_inst, &team->option_inst_list, list) 2444 list_add_tail(&opt_inst->tmp_list, &sel_opt_inst_list); 2445 err = team_nl_send_options_get(team, info->snd_portid, info->snd_seq, 2446 NLM_F_ACK, team_nl_send_unicast, 2447 &sel_opt_inst_list); 2448 2449 team_nl_team_put(team); 2450 2451 return err; 2452 } 2453 2454 static int team_nl_send_event_options_get(struct team *team, 2455 struct list_head *sel_opt_inst_list); 2456 2457 static int team_nl_cmd_options_set(struct sk_buff *skb, struct genl_info *info) 2458 { 2459 struct team *team; 2460 int err = 0; 2461 int i; 2462 struct nlattr *nl_option; 2463 LIST_HEAD(opt_inst_list); 2464 2465 rtnl_lock(); 2466 2467 team = team_nl_team_get(info); 2468 if (!team) { 2469 err = -EINVAL; 2470 goto rtnl_unlock; 2471 } 2472 2473 err = -EINVAL; 2474 if (!info->attrs[TEAM_ATTR_LIST_OPTION]) { 2475 err = -EINVAL; 2476 goto team_put; 2477 } 2478 2479 nla_for_each_nested(nl_option, info->attrs[TEAM_ATTR_LIST_OPTION], i) { 2480 struct nlattr *opt_attrs[TEAM_ATTR_OPTION_MAX + 1]; 2481 struct nlattr *attr; 2482 struct nlattr *attr_data; 2483 enum team_option_type opt_type; 2484 int opt_port_ifindex = 0; /* != 0 for per-port options */ 2485 u32 opt_array_index = 0; 2486 bool opt_is_array = false; 2487 struct team_option_inst *opt_inst; 2488 char *opt_name; 2489 bool opt_found = false; 2490 2491 if (nla_type(nl_option) != TEAM_ATTR_ITEM_OPTION) { 2492 err = -EINVAL; 2493 goto team_put; 2494 } 2495 err = nla_parse_nested(opt_attrs, TEAM_ATTR_OPTION_MAX, 2496 nl_option, team_nl_option_policy, 2497 info->extack); 2498 if (err) 2499 goto team_put; 2500 if (!opt_attrs[TEAM_ATTR_OPTION_NAME] || 2501 !opt_attrs[TEAM_ATTR_OPTION_TYPE]) { 2502 err = -EINVAL; 2503 goto team_put; 2504 } 2505 switch (nla_get_u8(opt_attrs[TEAM_ATTR_OPTION_TYPE])) { 2506 case NLA_U32: 2507 opt_type = TEAM_OPTION_TYPE_U32; 2508 break; 2509 case NLA_STRING: 2510 opt_type = TEAM_OPTION_TYPE_STRING; 2511 break; 2512 case NLA_BINARY: 2513 opt_type = TEAM_OPTION_TYPE_BINARY; 2514 break; 2515 case NLA_FLAG: 2516 opt_type = TEAM_OPTION_TYPE_BOOL; 2517 break; 2518 case NLA_S32: 2519 opt_type = TEAM_OPTION_TYPE_S32; 2520 break; 2521 default: 2522 goto team_put; 2523 } 2524 2525 attr_data = opt_attrs[TEAM_ATTR_OPTION_DATA]; 2526 if (opt_type != TEAM_OPTION_TYPE_BOOL && !attr_data) { 2527 err = -EINVAL; 2528 goto team_put; 2529 } 2530 2531 opt_name = nla_data(opt_attrs[TEAM_ATTR_OPTION_NAME]); 2532 attr = opt_attrs[TEAM_ATTR_OPTION_PORT_IFINDEX]; 2533 if (attr) 2534 opt_port_ifindex = nla_get_u32(attr); 2535 2536 attr = opt_attrs[TEAM_ATTR_OPTION_ARRAY_INDEX]; 2537 if (attr) { 2538 opt_is_array = true; 2539 opt_array_index = nla_get_u32(attr); 2540 } 2541 2542 list_for_each_entry(opt_inst, &team->option_inst_list, list) { 2543 struct team_option *option = opt_inst->option; 2544 struct team_gsetter_ctx ctx; 2545 struct team_option_inst_info *opt_inst_info; 2546 int tmp_ifindex; 2547 2548 opt_inst_info = &opt_inst->info; 2549 tmp_ifindex = opt_inst_info->port ? 2550 opt_inst_info->port->dev->ifindex : 0; 2551 if (option->type != opt_type || 2552 strcmp(option->name, opt_name) || 2553 tmp_ifindex != opt_port_ifindex || 2554 (option->array_size && !opt_is_array) || 2555 opt_inst_info->array_index != opt_array_index) 2556 continue; 2557 opt_found = true; 2558 ctx.info = opt_inst_info; 2559 switch (opt_type) { 2560 case TEAM_OPTION_TYPE_U32: 2561 ctx.data.u32_val = nla_get_u32(attr_data); 2562 break; 2563 case TEAM_OPTION_TYPE_STRING: 2564 if (nla_len(attr_data) > TEAM_STRING_MAX_LEN) { 2565 err = -EINVAL; 2566 goto team_put; 2567 } 2568 ctx.data.str_val = nla_data(attr_data); 2569 break; 2570 case TEAM_OPTION_TYPE_BINARY: 2571 ctx.data.bin_val.len = nla_len(attr_data); 2572 ctx.data.bin_val.ptr = nla_data(attr_data); 2573 break; 2574 case TEAM_OPTION_TYPE_BOOL: 2575 ctx.data.bool_val = attr_data ? true : false; 2576 break; 2577 case TEAM_OPTION_TYPE_S32: 2578 ctx.data.s32_val = nla_get_s32(attr_data); 2579 break; 2580 default: 2581 BUG(); 2582 } 2583 err = team_option_set(team, opt_inst, &ctx); 2584 if (err) 2585 goto team_put; 2586 opt_inst->changed = true; 2587 2588 /* dumb/evil user-space can send us duplicate opt, 2589 * keep only the last one 2590 */ 2591 if (__team_option_inst_tmp_find(&opt_inst_list, 2592 opt_inst)) 2593 continue; 2594 2595 list_add(&opt_inst->tmp_list, &opt_inst_list); 2596 } 2597 if (!opt_found) { 2598 err = -ENOENT; 2599 goto team_put; 2600 } 2601 } 2602 2603 err = team_nl_send_event_options_get(team, &opt_inst_list); 2604 2605 team_put: 2606 team_nl_team_put(team); 2607 rtnl_unlock: 2608 rtnl_unlock(); 2609 return err; 2610 } 2611 2612 static int team_nl_fill_one_port_get(struct sk_buff *skb, 2613 struct team_port *port) 2614 { 2615 struct nlattr *port_item; 2616 2617 port_item = nla_nest_start(skb, TEAM_ATTR_ITEM_PORT); 2618 if (!port_item) 2619 goto nest_cancel; 2620 if (nla_put_u32(skb, TEAM_ATTR_PORT_IFINDEX, port->dev->ifindex)) 2621 goto nest_cancel; 2622 if (port->changed) { 2623 if (nla_put_flag(skb, TEAM_ATTR_PORT_CHANGED)) 2624 goto nest_cancel; 2625 port->changed = false; 2626 } 2627 if ((port->removed && 2628 nla_put_flag(skb, TEAM_ATTR_PORT_REMOVED)) || 2629 (port->state.linkup && 2630 nla_put_flag(skb, TEAM_ATTR_PORT_LINKUP)) || 2631 nla_put_u32(skb, TEAM_ATTR_PORT_SPEED, port->state.speed) || 2632 nla_put_u8(skb, TEAM_ATTR_PORT_DUPLEX, port->state.duplex)) 2633 goto nest_cancel; 2634 nla_nest_end(skb, port_item); 2635 return 0; 2636 2637 nest_cancel: 2638 nla_nest_cancel(skb, port_item); 2639 return -EMSGSIZE; 2640 } 2641 2642 static int team_nl_send_port_list_get(struct team *team, u32 portid, u32 seq, 2643 int flags, team_nl_send_func_t *send_func, 2644 struct team_port *one_port) 2645 { 2646 struct nlattr *port_list; 2647 struct nlmsghdr *nlh; 2648 void *hdr; 2649 struct team_port *port; 2650 int err; 2651 struct sk_buff *skb = NULL; 2652 bool incomplete; 2653 int i; 2654 2655 port = list_first_entry_or_null(&team->port_list, 2656 struct team_port, list); 2657 2658 start_again: 2659 err = __send_and_alloc_skb(&skb, team, portid, send_func); 2660 if (err) 2661 return err; 2662 2663 hdr = genlmsg_put(skb, portid, seq, &team_nl_family, flags | NLM_F_MULTI, 2664 TEAM_CMD_PORT_LIST_GET); 2665 if (!hdr) { 2666 nlmsg_free(skb); 2667 return -EMSGSIZE; 2668 } 2669 2670 if (nla_put_u32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex)) 2671 goto nla_put_failure; 2672 port_list = nla_nest_start(skb, TEAM_ATTR_LIST_PORT); 2673 if (!port_list) 2674 goto nla_put_failure; 2675 2676 i = 0; 2677 incomplete = false; 2678 2679 /* If one port is selected, called wants to send port list containing 2680 * only this port. Otherwise go through all listed ports and send all 2681 */ 2682 if (one_port) { 2683 err = team_nl_fill_one_port_get(skb, one_port); 2684 if (err) 2685 goto errout; 2686 } else if (port) { 2687 list_for_each_entry_from(port, &team->port_list, list) { 2688 err = team_nl_fill_one_port_get(skb, port); 2689 if (err) { 2690 if (err == -EMSGSIZE) { 2691 if (!i) 2692 goto errout; 2693 incomplete = true; 2694 break; 2695 } 2696 goto errout; 2697 } 2698 i++; 2699 } 2700 } 2701 2702 nla_nest_end(skb, port_list); 2703 genlmsg_end(skb, hdr); 2704 if (incomplete) 2705 goto start_again; 2706 2707 send_done: 2708 nlh = nlmsg_put(skb, portid, seq, NLMSG_DONE, 0, flags | NLM_F_MULTI); 2709 if (!nlh) { 2710 err = __send_and_alloc_skb(&skb, team, portid, send_func); 2711 if (err) 2712 return err; 2713 goto send_done; 2714 } 2715 2716 return send_func(skb, team, portid); 2717 2718 nla_put_failure: 2719 err = -EMSGSIZE; 2720 errout: 2721 genlmsg_cancel(skb, hdr); 2722 nlmsg_free(skb); 2723 return err; 2724 } 2725 2726 static int team_nl_cmd_port_list_get(struct sk_buff *skb, 2727 struct genl_info *info) 2728 { 2729 struct team *team; 2730 int err; 2731 2732 team = team_nl_team_get(info); 2733 if (!team) 2734 return -EINVAL; 2735 2736 err = team_nl_send_port_list_get(team, info->snd_portid, info->snd_seq, 2737 NLM_F_ACK, team_nl_send_unicast, NULL); 2738 2739 team_nl_team_put(team); 2740 2741 return err; 2742 } 2743 2744 static const struct genl_ops team_nl_ops[] = { 2745 { 2746 .cmd = TEAM_CMD_NOOP, 2747 .doit = team_nl_cmd_noop, 2748 .policy = team_nl_policy, 2749 }, 2750 { 2751 .cmd = TEAM_CMD_OPTIONS_SET, 2752 .doit = team_nl_cmd_options_set, 2753 .policy = team_nl_policy, 2754 .flags = GENL_ADMIN_PERM, 2755 }, 2756 { 2757 .cmd = TEAM_CMD_OPTIONS_GET, 2758 .doit = team_nl_cmd_options_get, 2759 .policy = team_nl_policy, 2760 .flags = GENL_ADMIN_PERM, 2761 }, 2762 { 2763 .cmd = TEAM_CMD_PORT_LIST_GET, 2764 .doit = team_nl_cmd_port_list_get, 2765 .policy = team_nl_policy, 2766 .flags = GENL_ADMIN_PERM, 2767 }, 2768 }; 2769 2770 static const struct genl_multicast_group team_nl_mcgrps[] = { 2771 { .name = TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME, }, 2772 }; 2773 2774 static struct genl_family team_nl_family __ro_after_init = { 2775 .name = TEAM_GENL_NAME, 2776 .version = TEAM_GENL_VERSION, 2777 .maxattr = TEAM_ATTR_MAX, 2778 .netnsok = true, 2779 .module = THIS_MODULE, 2780 .ops = team_nl_ops, 2781 .n_ops = ARRAY_SIZE(team_nl_ops), 2782 .mcgrps = team_nl_mcgrps, 2783 .n_mcgrps = ARRAY_SIZE(team_nl_mcgrps), 2784 }; 2785 2786 static int team_nl_send_multicast(struct sk_buff *skb, 2787 struct team *team, u32 portid) 2788 { 2789 return genlmsg_multicast_netns(&team_nl_family, dev_net(team->dev), 2790 skb, 0, 0, GFP_KERNEL); 2791 } 2792 2793 static int team_nl_send_event_options_get(struct team *team, 2794 struct list_head *sel_opt_inst_list) 2795 { 2796 return team_nl_send_options_get(team, 0, 0, 0, team_nl_send_multicast, 2797 sel_opt_inst_list); 2798 } 2799 2800 static int team_nl_send_event_port_get(struct team *team, 2801 struct team_port *port) 2802 { 2803 return team_nl_send_port_list_get(team, 0, 0, 0, team_nl_send_multicast, 2804 port); 2805 } 2806 2807 static int __init team_nl_init(void) 2808 { 2809 return genl_register_family(&team_nl_family); 2810 } 2811 2812 static void team_nl_fini(void) 2813 { 2814 genl_unregister_family(&team_nl_family); 2815 } 2816 2817 2818 /****************** 2819 * Change checkers 2820 ******************/ 2821 2822 static void __team_options_change_check(struct team *team) 2823 { 2824 int err; 2825 struct team_option_inst *opt_inst; 2826 LIST_HEAD(sel_opt_inst_list); 2827 2828 list_for_each_entry(opt_inst, &team->option_inst_list, list) { 2829 if (opt_inst->changed) 2830 list_add_tail(&opt_inst->tmp_list, &sel_opt_inst_list); 2831 } 2832 err = team_nl_send_event_options_get(team, &sel_opt_inst_list); 2833 if (err && err != -ESRCH) 2834 netdev_warn(team->dev, "Failed to send options change via netlink (err %d)\n", 2835 err); 2836 } 2837 2838 /* rtnl lock is held */ 2839 2840 static void __team_port_change_send(struct team_port *port, bool linkup) 2841 { 2842 int err; 2843 2844 port->changed = true; 2845 port->state.linkup = linkup; 2846 team_refresh_port_linkup(port); 2847 if (linkup) { 2848 struct ethtool_link_ksettings ecmd; 2849 2850 err = __ethtool_get_link_ksettings(port->dev, &ecmd); 2851 if (!err) { 2852 port->state.speed = ecmd.base.speed; 2853 port->state.duplex = ecmd.base.duplex; 2854 goto send_event; 2855 } 2856 } 2857 port->state.speed = 0; 2858 port->state.duplex = 0; 2859 2860 send_event: 2861 err = team_nl_send_event_port_get(port->team, port); 2862 if (err && err != -ESRCH) 2863 netdev_warn(port->team->dev, "Failed to send port change of device %s via netlink (err %d)\n", 2864 port->dev->name, err); 2865 2866 } 2867 2868 static void __team_carrier_check(struct team *team) 2869 { 2870 struct team_port *port; 2871 bool team_linkup; 2872 2873 if (team->user_carrier_enabled) 2874 return; 2875 2876 team_linkup = false; 2877 list_for_each_entry(port, &team->port_list, list) { 2878 if (port->linkup) { 2879 team_linkup = true; 2880 break; 2881 } 2882 } 2883 2884 if (team_linkup) 2885 netif_carrier_on(team->dev); 2886 else 2887 netif_carrier_off(team->dev); 2888 } 2889 2890 static void __team_port_change_check(struct team_port *port, bool linkup) 2891 { 2892 if (port->state.linkup != linkup) 2893 __team_port_change_send(port, linkup); 2894 __team_carrier_check(port->team); 2895 } 2896 2897 static void __team_port_change_port_added(struct team_port *port, bool linkup) 2898 { 2899 __team_port_change_send(port, linkup); 2900 __team_carrier_check(port->team); 2901 } 2902 2903 static void __team_port_change_port_removed(struct team_port *port) 2904 { 2905 port->removed = true; 2906 __team_port_change_send(port, false); 2907 __team_carrier_check(port->team); 2908 } 2909 2910 static void team_port_change_check(struct team_port *port, bool linkup) 2911 { 2912 struct team *team = port->team; 2913 2914 mutex_lock(&team->lock); 2915 __team_port_change_check(port, linkup); 2916 mutex_unlock(&team->lock); 2917 } 2918 2919 2920 /************************************ 2921 * Net device notifier event handler 2922 ************************************/ 2923 2924 static int team_device_event(struct notifier_block *unused, 2925 unsigned long event, void *ptr) 2926 { 2927 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 2928 struct team_port *port; 2929 2930 port = team_port_get_rtnl(dev); 2931 if (!port) 2932 return NOTIFY_DONE; 2933 2934 switch (event) { 2935 case NETDEV_UP: 2936 if (netif_carrier_ok(dev)) 2937 team_port_change_check(port, true); 2938 break; 2939 case NETDEV_DOWN: 2940 team_port_change_check(port, false); 2941 break; 2942 case NETDEV_CHANGE: 2943 if (netif_running(port->dev)) 2944 team_port_change_check(port, 2945 !!netif_carrier_ok(port->dev)); 2946 break; 2947 case NETDEV_UNREGISTER: 2948 team_del_slave(port->team->dev, dev); 2949 break; 2950 case NETDEV_FEAT_CHANGE: 2951 team_compute_features(port->team); 2952 break; 2953 case NETDEV_PRECHANGEMTU: 2954 /* Forbid to change mtu of underlaying device */ 2955 if (!port->team->port_mtu_change_allowed) 2956 return NOTIFY_BAD; 2957 break; 2958 case NETDEV_PRE_TYPE_CHANGE: 2959 /* Forbid to change type of underlaying device */ 2960 return NOTIFY_BAD; 2961 case NETDEV_RESEND_IGMP: 2962 /* Propagate to master device */ 2963 call_netdevice_notifiers(event, port->team->dev); 2964 break; 2965 } 2966 return NOTIFY_DONE; 2967 } 2968 2969 static struct notifier_block team_notifier_block __read_mostly = { 2970 .notifier_call = team_device_event, 2971 }; 2972 2973 2974 /*********************** 2975 * Module init and exit 2976 ***********************/ 2977 2978 static int __init team_module_init(void) 2979 { 2980 int err; 2981 2982 register_netdevice_notifier(&team_notifier_block); 2983 2984 err = rtnl_link_register(&team_link_ops); 2985 if (err) 2986 goto err_rtnl_reg; 2987 2988 err = team_nl_init(); 2989 if (err) 2990 goto err_nl_init; 2991 2992 return 0; 2993 2994 err_nl_init: 2995 rtnl_link_unregister(&team_link_ops); 2996 2997 err_rtnl_reg: 2998 unregister_netdevice_notifier(&team_notifier_block); 2999 3000 return err; 3001 } 3002 3003 static void __exit team_module_exit(void) 3004 { 3005 team_nl_fini(); 3006 rtnl_link_unregister(&team_link_ops); 3007 unregister_netdevice_notifier(&team_notifier_block); 3008 } 3009 3010 module_init(team_module_init); 3011 module_exit(team_module_exit); 3012 3013 MODULE_LICENSE("GPL v2"); 3014 MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>"); 3015 MODULE_DESCRIPTION("Ethernet team device driver"); 3016 MODULE_ALIAS_RTNL_LINK(DRV_NAME); 3017