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 43static 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 50static 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 */ 61static 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 71static 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 76static 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 82int team_modeop_port_enter(struct team *team, struct team_port *port) 83{ 84 return team_port_set_team_dev_addr(team, port); 85} 86EXPORT_SYMBOL(team_modeop_port_enter); 87 88void 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} 93EXPORT_SYMBOL(team_modeop_port_change_dev_addr); 94 95static 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 106struct 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 115static 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 127static void __team_option_inst_del(struct team_option_inst *opt_inst) 128{ 129 list_del(&opt_inst->list); 130 kfree(opt_inst); 131} 132 133static 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 144static 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 176static 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 195inst_del_option: 196 __team_option_inst_del_option(team, option); 197 return err; 198} 199 200static 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 213static 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 225static 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 240inst_del_port: 241 __team_option_inst_del_port(team, port); 242 return err; 243} 244 245static 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 258static 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 292inst_rollback: 293 for (i--; i >= 0; i--) 294 __team_option_inst_del_option(team, dst_opts[i]); 295 296 i = option_count - 1; 297alloc_rollback: 298 for (i--; i >= 0; i--) 299 kfree(dst_opts[i]); 300 301 kfree(dst_opts); 302 return err; 303} 304 305static 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 320static 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 338static void __team_options_change_check(struct team *team); 339 340int 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} 352EXPORT_SYMBOL(team_options_register); 353 354void 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} 362EXPORT_SYMBOL(team_options_unregister); 363 364static 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 373static 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 382void 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} 389EXPORT_SYMBOL(team_option_inst_set_change); 390 391void team_options_change_check(struct team *team) 392{ 393 __team_options_change_check(team); 394} 395EXPORT_SYMBOL(team_options_change_check); 396 397 398/**************** 399 * Mode handling 400 ****************/ 401 402static LIST_HEAD(mode_list); 403static DEFINE_SPINLOCK(mode_list_lock); 404 405struct team_mode_item { 406 struct list_head list; 407 const struct team_mode *mode; 408}; 409 410static 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 421static 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 431int 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); 452unlock: 453 spin_unlock(&mode_list_lock); 454 return err; 455} 456EXPORT_SYMBOL(team_mode_register); 457 458void 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} 470EXPORT_SYMBOL(team_mode_unregister); 471 472static 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 495static void team_mode_put(const struct team_mode *mode) 496{ 497 module_put(mode->owner); 498} 499 500static bool team_dummy_transmit(struct team *team, struct sk_buff *skb) 501{ 502 dev_kfree_skb_any(skb); 503 return false; 504} 505 506static 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 513static const struct team_mode __team_no_mode = { 514 .kind = "*NOMODE*", 515}; 516 517static bool team_is_mode_set(struct team *team) 518{ 519 return team->mode != &__team_no_mode; 520} 521 522static void team_set_no_mode(struct team *team) 523{ 524 team->user_carrier_enabled = false; 525 team->mode = &__team_no_mode; 526} 527 528static 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 */ 553static 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 591static 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 629static 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 646static 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 654static void team_notify_peers_init(struct team *team) 655{ 656 INIT_DELAYED_WORK(&team->notify_peers.dw, team_notify_peers_work); 657} 658 659static 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 669static 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 686static 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 694static void team_mcast_rejoin_init(struct team *team) 695{ 696 INIT_DELAYED_WORK(&team->mcast_rejoin.dw, team_mcast_rejoin_work); 697} 698 699static 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 */ 710static 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 755static 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 772static void team_queue_override_fini(struct team *team) 773{ 774 kfree(team->qom_lists); 775} 776 777static 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 */ 785static 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 800static 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 808static 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 820static 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 839static 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 857static 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 867static 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 881static 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 888static 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 900static 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 */ 917static 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 933static 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 947static 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 968static 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 996static 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 1003static 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 1019err_port_enter: 1020 dev_put(team->dev); 1021 1022 return err; 1023} 1024 1025static 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 1033static 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 1054static 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 1068static int team_port_enable_netpoll(struct team *team, struct team_port *port) 1069{ 1070 return 0; 1071} 1072static void team_port_disable_netpoll(struct team_port *port) 1073{ 1074} 1075#endif 1076 1077static 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 1089static 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 1096static void __team_port_change_port_added(struct team_port *port, bool linkup); 1097static int team_dev_type_check_change(struct net_device *dev, 1098 struct net_device *port_dev); 1099 1100static 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 1215err_option_port_add: 1216 team_upper_dev_unlink(dev, port_dev); 1217 1218err_set_upper_link: 1219 netdev_rx_handler_unregister(port_dev); 1220 1221err_handler_register: 1222 team_port_disable_netpoll(port); 1223 1224err_enable_netpoll: 1225 vlan_vids_del_by_dev(port_dev, dev); 1226 1227err_vids_add: 1228 dev_close(port_dev); 1229 1230err_dev_open: 1231 team_port_leave(team, port); 1232 team_port_set_orig_dev_addr(port); 1233 1234err_port_enter: 1235 dev_set_mtu(port_dev, port->orig.mtu); 1236 1237err_set_mtu: 1238 kfree(port); 1239 1240 return err; 1241} 1242 1243static void __team_port_change_port_removed(struct team_port *port); 1244 1245static 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 1288static 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 1294static 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 1299static 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 1306static 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 1313static 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 1320static 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 1327static 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 1334static 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 1341static 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 1348static 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 1355static 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 1364static 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 1376static 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 1385static void __team_carrier_check(struct team *team); 1386 1387static 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 1398static 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 1407static 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 1418static 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 1427static 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 1440static 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 1449static 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 1463static 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 1531static struct lock_class_key team_netdev_xmit_lock_key; 1532static struct lock_class_key team_netdev_addr_lock_key; 1533static struct lock_class_key team_tx_busylock_key; 1534 1535static 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 1542static 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 1549static 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 1587err_options_register: 1588 team_mcast_rejoin_fini(team); 1589 team_notify_peers_fini(team); 1590 team_queue_override_fini(team); 1591err_team_queue_override_init: 1592 free_percpu(team->pcpu_stats); 1593 1594 return err; 1595} 1596 1597static 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 1615static 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 1623static int team_open(struct net_device *dev) 1624{ 1625 return 0; 1626} 1627 1628static int team_close(struct net_device *dev) 1629{ 1630 return 0; 1631} 1632 1633/* 1634 * note: already called with rcu_read_lock 1635 */ 1636static 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 1660static 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 1684static 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 1704static 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 1717static 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 1734static 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 1761unwind: 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 1770static struct rtnl_link_stats64 * 1771team_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 1808static 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 1828unwind: 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 1836static 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 1850static void team_poll_controller(struct net_device *dev) 1851{ 1852} 1853 1854static 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 1862static 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 1871static 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 1891static 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 1902static 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 1913static 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 1934static 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 1947static 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 1976static 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 1983static 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 1992static 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 2004static 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 2030static 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 2063static 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 2072static 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 2083static unsigned int team_get_num_tx_queues(void) 2084{ 2085 return TEAM_DEFAULT_NUM_TX_QUEUES; 2086} 2087 2088static unsigned int team_get_num_rx_queues(void) 2089{ 2090 return TEAM_DEFAULT_NUM_RX_QUEUES; 2091} 2092 2093static 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 2108static 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 2116static 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 2123static const struct nla_policy 2124team_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 2135static 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 2156err_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 */ 2166static 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 2189static void team_nl_team_put(struct team *team) 2190{ 2191 mutex_unlock(&team->lock); 2192 dev_put(team->dev); 2193} 2194 2195typedef int team_nl_send_func_t(struct sk_buff *skb, 2196 struct team *team, u32 portid); 2197 2198static 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 2203static 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 2279nest_cancel: 2280 nla_nest_cancel(skb, option_item); 2281 return -EMSGSIZE; 2282} 2283 2284static 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 2301static 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 2317start_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 2354send_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 2365nla_put_failure: 2366 err = -EMSGSIZE; 2367errout: 2368 genlmsg_cancel(skb, hdr); 2369 nlmsg_free(skb); 2370 return err; 2371} 2372 2373static 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 2395static int team_nl_send_event_options_get(struct team *team, 2396 struct list_head *sel_opt_inst_list); 2397 2398static 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 2533team_put: 2534 team_nl_team_put(team); 2535 2536 return err; 2537} 2538 2539static 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 2564nest_cancel: 2565 nla_nest_cancel(skb, port_item); 2566 return -EMSGSIZE; 2567} 2568 2569static 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 2585start_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 2632send_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 2643nla_put_failure: 2644 err = -EMSGSIZE; 2645errout: 2646 genlmsg_cancel(skb, hdr); 2647 nlmsg_free(skb); 2648 return err; 2649} 2650 2651static 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 2669static 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 2695static const struct genl_multicast_group team_nl_mcgrps[] = { 2696 { .name = TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME, }, 2697}; 2698 2699static 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 2706static 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 2713static 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 2720static 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 2726static void team_nl_fini(void) 2727{ 2728 genl_unregister_family(&team_nl_family); 2729} 2730 2731 2732/****************** 2733 * Change checkers 2734 ******************/ 2735 2736static 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 2754static 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 2774send_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 2782static 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 2804static 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 2811static 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 2817static 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 2824static 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 2838static 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 2883static 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 2892static 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 2908err_nl_init: 2909 rtnl_link_unregister(&team_link_ops); 2910 2911err_rtnl_reg: 2912 unregister_netdevice_notifier(&team_notifier_block); 2913 2914 return err; 2915} 2916 2917static 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 2924module_init(team_module_init); 2925module_exit(team_module_exit); 2926 2927MODULE_LICENSE("GPL v2"); 2928MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>"); 2929MODULE_DESCRIPTION("Ethernet team device driver"); 2930MODULE_ALIAS_RTNL_LINK(DRV_NAME); 2931