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