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