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