12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
23d249d4cSJiri Pirko /*
30d572e45SJiri Pirko * drivers/net/team/team.c - Network team device driver
43d249d4cSJiri Pirko * Copyright (c) 2011 Jiri Pirko <jpirko@redhat.com>
53d249d4cSJiri Pirko */
63d249d4cSJiri Pirko
7cc69837fSJakub Kicinski #include <linux/ethtool.h>
83d249d4cSJiri Pirko #include <linux/kernel.h>
93d249d4cSJiri Pirko #include <linux/types.h>
103d249d4cSJiri Pirko #include <linux/module.h>
113d249d4cSJiri Pirko #include <linux/init.h>
123d249d4cSJiri Pirko #include <linux/slab.h>
133d249d4cSJiri Pirko #include <linux/rcupdate.h>
143d249d4cSJiri Pirko #include <linux/errno.h>
153d249d4cSJiri Pirko #include <linux/ctype.h>
163d249d4cSJiri Pirko #include <linux/notifier.h>
173d249d4cSJiri Pirko #include <linux/netdevice.h>
18bd2d0837SJiri Pirko #include <linux/netpoll.h>
1987002b03SJiri Pirko #include <linux/if_vlan.h>
203d249d4cSJiri Pirko #include <linux/if_arp.h>
213d249d4cSJiri Pirko #include <linux/socket.h>
223d249d4cSJiri Pirko #include <linux/etherdevice.h>
233d249d4cSJiri Pirko #include <linux/rtnetlink.h>
243d249d4cSJiri Pirko #include <net/rtnetlink.h>
253d249d4cSJiri Pirko #include <net/genetlink.h>
263d249d4cSJiri Pirko #include <net/netlink.h>
276c85f2bdSJiri Pirko #include <net/sch_generic.h>
287f51c587SFlavio Leitner #include <generated/utsrelease.h>
293d249d4cSJiri Pirko #include <linux/if_team.h>
303d249d4cSJiri Pirko
313d249d4cSJiri Pirko #define DRV_NAME "team"
323d249d4cSJiri Pirko
333d249d4cSJiri Pirko
343d249d4cSJiri Pirko /**********
353d249d4cSJiri Pirko * Helpers
363d249d4cSJiri Pirko **********/
373d249d4cSJiri Pirko
team_port_get_rtnl(const struct net_device * dev)383d249d4cSJiri Pirko static struct team_port *team_port_get_rtnl(const struct net_device *dev)
393d249d4cSJiri Pirko {
403d249d4cSJiri Pirko struct team_port *port = rtnl_dereference(dev->rx_handler_data);
413d249d4cSJiri Pirko
42acb10eacSJulian Wiedmann return netif_is_team_port(dev) ? port : NULL;
433d249d4cSJiri Pirko }
443d249d4cSJiri Pirko
453d249d4cSJiri Pirko /*
461d76efe1SJiri Pirko * Since the ability to change device address for open port device is tested in
473d249d4cSJiri Pirko * team_port_add, this function can be called without control of return value
483d249d4cSJiri Pirko */
__set_port_dev_addr(struct net_device * port_dev,const unsigned char * dev_addr)491d76efe1SJiri Pirko static int __set_port_dev_addr(struct net_device *port_dev,
503d249d4cSJiri Pirko const unsigned char *dev_addr)
513d249d4cSJiri Pirko {
52996f6e12SWANG Cong struct sockaddr_storage addr;
533d249d4cSJiri Pirko
54996f6e12SWANG Cong memcpy(addr.__data, dev_addr, port_dev->addr_len);
55996f6e12SWANG Cong addr.ss_family = port_dev->type;
563a37a963SPetr Machata return dev_set_mac_address(port_dev, (struct sockaddr *)&addr, NULL);
573d249d4cSJiri Pirko }
583d249d4cSJiri Pirko
team_port_set_orig_dev_addr(struct team_port * port)591d76efe1SJiri Pirko static int team_port_set_orig_dev_addr(struct team_port *port)
603d249d4cSJiri Pirko {
611d76efe1SJiri Pirko return __set_port_dev_addr(port->dev, port->orig.dev_addr);
623d249d4cSJiri Pirko }
633d249d4cSJiri Pirko
team_port_set_team_dev_addr(struct team * team,struct team_port * port)64acbba0d0SJiri Pirko static int team_port_set_team_dev_addr(struct team *team,
65acbba0d0SJiri Pirko struct team_port *port)
663d249d4cSJiri Pirko {
67acbba0d0SJiri Pirko return __set_port_dev_addr(port->dev, team->dev->dev_addr);
683d249d4cSJiri Pirko }
69acbba0d0SJiri Pirko
team_modeop_port_enter(struct team * team,struct team_port * port)70acbba0d0SJiri Pirko int team_modeop_port_enter(struct team *team, struct team_port *port)
71acbba0d0SJiri Pirko {
72acbba0d0SJiri Pirko return team_port_set_team_dev_addr(team, port);
73acbba0d0SJiri Pirko }
74acbba0d0SJiri Pirko EXPORT_SYMBOL(team_modeop_port_enter);
75acbba0d0SJiri Pirko
team_modeop_port_change_dev_addr(struct team * team,struct team_port * port)76acbba0d0SJiri Pirko void team_modeop_port_change_dev_addr(struct team *team,
77acbba0d0SJiri Pirko struct team_port *port)
78acbba0d0SJiri Pirko {
79acbba0d0SJiri Pirko team_port_set_team_dev_addr(team, port);
80acbba0d0SJiri Pirko }
81acbba0d0SJiri Pirko EXPORT_SYMBOL(team_modeop_port_change_dev_addr);
823d249d4cSJiri Pirko
team_lower_state_changed(struct team_port * port)833a0d6c5aSJiri Pirko static void team_lower_state_changed(struct team_port *port)
843a0d6c5aSJiri Pirko {
853a0d6c5aSJiri Pirko struct netdev_lag_lower_state_info info;
863a0d6c5aSJiri Pirko
873a0d6c5aSJiri Pirko info.link_up = port->linkup;
883a0d6c5aSJiri Pirko info.tx_enabled = team_port_enabled(port);
893a0d6c5aSJiri Pirko netdev_lower_state_changed(port->dev, &info);
903a0d6c5aSJiri Pirko }
913a0d6c5aSJiri Pirko
team_refresh_port_linkup(struct team_port * port)9271472ec1SJiri Pirko static void team_refresh_port_linkup(struct team_port *port)
9371472ec1SJiri Pirko {
943a0d6c5aSJiri Pirko bool new_linkup = port->user.linkup_enabled ? port->user.linkup :
9571472ec1SJiri Pirko port->state.linkup;
963a0d6c5aSJiri Pirko
973a0d6c5aSJiri Pirko if (port->linkup != new_linkup) {
983a0d6c5aSJiri Pirko port->linkup = new_linkup;
993a0d6c5aSJiri Pirko team_lower_state_changed(port);
1003a0d6c5aSJiri Pirko }
10171472ec1SJiri Pirko }
1023d249d4cSJiri Pirko
1030f1aad2bSJiri Pirko
1043d249d4cSJiri Pirko /*******************
1053d249d4cSJiri Pirko * Options handling
1063d249d4cSJiri Pirko *******************/
1073d249d4cSJiri Pirko
10880f7c668SJiri Pirko struct team_option_inst { /* One for each option instance */
10980f7c668SJiri Pirko struct list_head list;
11001048d9aSJiri Pirko struct list_head tmp_list;
11180f7c668SJiri Pirko struct team_option *option;
11285d59a87SJiri Pirko struct team_option_inst_info info;
11380f7c668SJiri Pirko bool changed;
11480f7c668SJiri Pirko bool removed;
11580f7c668SJiri Pirko };
11680f7c668SJiri Pirko
__team_find_option(struct team * team,const char * opt_name)11780f7c668SJiri Pirko static struct team_option *__team_find_option(struct team *team,
11880f7c668SJiri Pirko const char *opt_name)
119358b8382SJiri Pirko {
120358b8382SJiri Pirko struct team_option *option;
121358b8382SJiri Pirko
122358b8382SJiri Pirko list_for_each_entry(option, &team->option_list, list) {
123358b8382SJiri Pirko if (strcmp(option->name, opt_name) == 0)
124358b8382SJiri Pirko return option;
125358b8382SJiri Pirko }
126358b8382SJiri Pirko return NULL;
127358b8382SJiri Pirko }
128358b8382SJiri Pirko
__team_option_inst_del(struct team_option_inst * opt_inst)12980f7c668SJiri Pirko static void __team_option_inst_del(struct team_option_inst *opt_inst)
13080f7c668SJiri Pirko {
13180f7c668SJiri Pirko list_del(&opt_inst->list);
13280f7c668SJiri Pirko kfree(opt_inst);
13380f7c668SJiri Pirko }
13480f7c668SJiri Pirko
__team_option_inst_del_option(struct team * team,struct team_option * option)13580f7c668SJiri Pirko static void __team_option_inst_del_option(struct team *team,
13680f7c668SJiri Pirko struct team_option *option)
13780f7c668SJiri Pirko {
13880f7c668SJiri Pirko struct team_option_inst *opt_inst, *tmp;
13980f7c668SJiri Pirko
14080f7c668SJiri Pirko list_for_each_entry_safe(opt_inst, tmp, &team->option_inst_list, list) {
14180f7c668SJiri Pirko if (opt_inst->option == option)
14280f7c668SJiri Pirko __team_option_inst_del(opt_inst);
14380f7c668SJiri Pirko }
14480f7c668SJiri Pirko }
14580f7c668SJiri Pirko
__team_option_inst_add(struct team * team,struct team_option * option,struct team_port * port)146b1303326SJiri Pirko static int __team_option_inst_add(struct team *team, struct team_option *option,
147b1303326SJiri Pirko struct team_port *port)
148b1303326SJiri Pirko {
149b1303326SJiri Pirko struct team_option_inst *opt_inst;
150b1303326SJiri Pirko unsigned int array_size;
151b1303326SJiri Pirko unsigned int i;
152b1303326SJiri Pirko
153b1303326SJiri Pirko array_size = option->array_size;
154b1303326SJiri Pirko if (!array_size)
155b1303326SJiri Pirko array_size = 1; /* No array but still need one instance */
156b1303326SJiri Pirko
157b1303326SJiri Pirko for (i = 0; i < array_size; i++) {
158b1303326SJiri Pirko opt_inst = kmalloc(sizeof(*opt_inst), GFP_KERNEL);
159b1303326SJiri Pirko if (!opt_inst)
160b1303326SJiri Pirko return -ENOMEM;
161b1303326SJiri Pirko opt_inst->option = option;
16285d59a87SJiri Pirko opt_inst->info.port = port;
16385d59a87SJiri Pirko opt_inst->info.array_index = i;
164b1303326SJiri Pirko opt_inst->changed = true;
165b1303326SJiri Pirko opt_inst->removed = false;
166b1303326SJiri Pirko list_add_tail(&opt_inst->list, &team->option_inst_list);
167de3ecc4fSZhengchao Shao if (option->init)
168de3ecc4fSZhengchao Shao option->init(team, &opt_inst->info);
16985d59a87SJiri Pirko
170b1303326SJiri Pirko }
171b1303326SJiri Pirko return 0;
172b1303326SJiri Pirko }
173b1303326SJiri Pirko
__team_option_inst_add_option(struct team * team,struct team_option * option)17480f7c668SJiri Pirko static int __team_option_inst_add_option(struct team *team,
17580f7c668SJiri Pirko struct team_option *option)
17680f7c668SJiri Pirko {
17780f7c668SJiri Pirko int err;
17880f7c668SJiri Pirko
179b1303326SJiri Pirko if (!option->per_port) {
180f88725ffSJiri Pirko err = __team_option_inst_add(team, option, NULL);
181b1303326SJiri Pirko if (err)
182b1303326SJiri Pirko goto inst_del_option;
183b1303326SJiri Pirko }
18480f7c668SJiri Pirko return 0;
18580f7c668SJiri Pirko
18680f7c668SJiri Pirko inst_del_option:
18780f7c668SJiri Pirko __team_option_inst_del_option(team, option);
18880f7c668SJiri Pirko return err;
18980f7c668SJiri Pirko }
19080f7c668SJiri Pirko
__team_option_inst_mark_removed_option(struct team * team,struct team_option * option)19180f7c668SJiri Pirko static void __team_option_inst_mark_removed_option(struct team *team,
19280f7c668SJiri Pirko struct team_option *option)
19380f7c668SJiri Pirko {
19480f7c668SJiri Pirko struct team_option_inst *opt_inst;
19580f7c668SJiri Pirko
19680f7c668SJiri Pirko list_for_each_entry(opt_inst, &team->option_inst_list, list) {
19780f7c668SJiri Pirko if (opt_inst->option == option) {
19880f7c668SJiri Pirko opt_inst->changed = true;
19980f7c668SJiri Pirko opt_inst->removed = true;
20080f7c668SJiri Pirko }
20180f7c668SJiri Pirko }
20280f7c668SJiri Pirko }
20380f7c668SJiri Pirko
__team_option_inst_del_port(struct team * team,struct team_port * port)20480f7c668SJiri Pirko static void __team_option_inst_del_port(struct team *team,
20580f7c668SJiri Pirko struct team_port *port)
20680f7c668SJiri Pirko {
20780f7c668SJiri Pirko struct team_option_inst *opt_inst, *tmp;
20880f7c668SJiri Pirko
20980f7c668SJiri Pirko list_for_each_entry_safe(opt_inst, tmp, &team->option_inst_list, list) {
21080f7c668SJiri Pirko if (opt_inst->option->per_port &&
21185d59a87SJiri Pirko opt_inst->info.port == port)
21280f7c668SJiri Pirko __team_option_inst_del(opt_inst);
21380f7c668SJiri Pirko }
21480f7c668SJiri Pirko }
21580f7c668SJiri Pirko
__team_option_inst_add_port(struct team * team,struct team_port * port)21680f7c668SJiri Pirko static int __team_option_inst_add_port(struct team *team,
21780f7c668SJiri Pirko struct team_port *port)
21880f7c668SJiri Pirko {
21980f7c668SJiri Pirko struct team_option *option;
22080f7c668SJiri Pirko int err;
22180f7c668SJiri Pirko
22280f7c668SJiri Pirko list_for_each_entry(option, &team->option_list, list) {
22380f7c668SJiri Pirko if (!option->per_port)
22480f7c668SJiri Pirko continue;
22580f7c668SJiri Pirko err = __team_option_inst_add(team, option, port);
22680f7c668SJiri Pirko if (err)
22780f7c668SJiri Pirko goto inst_del_port;
22880f7c668SJiri Pirko }
22980f7c668SJiri Pirko return 0;
23080f7c668SJiri Pirko
23180f7c668SJiri Pirko inst_del_port:
23280f7c668SJiri Pirko __team_option_inst_del_port(team, port);
23380f7c668SJiri Pirko return err;
23480f7c668SJiri Pirko }
23580f7c668SJiri Pirko
__team_option_inst_mark_removed_port(struct team * team,struct team_port * port)23680f7c668SJiri Pirko static void __team_option_inst_mark_removed_port(struct team *team,
23780f7c668SJiri Pirko struct team_port *port)
23880f7c668SJiri Pirko {
23980f7c668SJiri Pirko struct team_option_inst *opt_inst;
24080f7c668SJiri Pirko
24180f7c668SJiri Pirko list_for_each_entry(opt_inst, &team->option_inst_list, list) {
24285d59a87SJiri Pirko if (opt_inst->info.port == port) {
24380f7c668SJiri Pirko opt_inst->changed = true;
24480f7c668SJiri Pirko opt_inst->removed = true;
24580f7c668SJiri Pirko }
24680f7c668SJiri Pirko }
24780f7c668SJiri Pirko }
24880f7c668SJiri Pirko
__team_options_register(struct team * team,const struct team_option * option,size_t option_count)24980f7c668SJiri Pirko static int __team_options_register(struct team *team,
250358b8382SJiri Pirko const struct team_option *option,
2513d249d4cSJiri Pirko size_t option_count)
2523d249d4cSJiri Pirko {
2533d249d4cSJiri Pirko int i;
2542bba19ffSJiri Pirko struct team_option **dst_opts;
255358b8382SJiri Pirko int err;
2563d249d4cSJiri Pirko
2576396bb22SKees Cook dst_opts = kcalloc(option_count, sizeof(struct team_option *),
2582bba19ffSJiri Pirko GFP_KERNEL);
2592bba19ffSJiri Pirko if (!dst_opts)
2602bba19ffSJiri Pirko return -ENOMEM;
261358b8382SJiri Pirko for (i = 0; i < option_count; i++, option++) {
262358b8382SJiri Pirko if (__team_find_option(team, option->name)) {
263358b8382SJiri Pirko err = -EEXIST;
26480f7c668SJiri Pirko goto alloc_rollback;
2653d249d4cSJiri Pirko }
266f8a15af0SJiri Pirko dst_opts[i] = kmemdup(option, sizeof(*option), GFP_KERNEL);
267f8a15af0SJiri Pirko if (!dst_opts[i]) {
268358b8382SJiri Pirko err = -ENOMEM;
26980f7c668SJiri Pirko goto alloc_rollback;
270358b8382SJiri Pirko }
271358b8382SJiri Pirko }
272358b8382SJiri Pirko
273b82b9183SJiri Pirko for (i = 0; i < option_count; i++) {
27480f7c668SJiri Pirko err = __team_option_inst_add_option(team, dst_opts[i]);
27580f7c668SJiri Pirko if (err)
27680f7c668SJiri Pirko goto inst_rollback;
277358b8382SJiri Pirko list_add_tail(&dst_opts[i]->list, &team->option_list);
278b82b9183SJiri Pirko }
279358b8382SJiri Pirko
2802bba19ffSJiri Pirko kfree(dst_opts);
281358b8382SJiri Pirko return 0;
282358b8382SJiri Pirko
28380f7c668SJiri Pirko inst_rollback:
284*28b36426SFlorent Revest for (i--; i >= 0; i--) {
28580f7c668SJiri Pirko __team_option_inst_del_option(team, dst_opts[i]);
286*28b36426SFlorent Revest list_del(&dst_opts[i]->list);
287*28b36426SFlorent Revest }
28880f7c668SJiri Pirko
2899a9e7749SAnant Thazhemadam i = option_count;
29080f7c668SJiri Pirko alloc_rollback:
29180f7c668SJiri Pirko for (i--; i >= 0; i--)
292358b8382SJiri Pirko kfree(dst_opts[i]);
293358b8382SJiri Pirko
2942bba19ffSJiri Pirko kfree(dst_opts);
295358b8382SJiri Pirko return err;
296358b8382SJiri Pirko }
297358b8382SJiri Pirko
__team_options_mark_removed(struct team * team,const struct team_option * option,size_t option_count)298b82b9183SJiri Pirko static void __team_options_mark_removed(struct team *team,
299b82b9183SJiri Pirko const struct team_option *option,
300b82b9183SJiri Pirko size_t option_count)
301b82b9183SJiri Pirko {
302b82b9183SJiri Pirko int i;
3033d249d4cSJiri Pirko
304b82b9183SJiri Pirko for (i = 0; i < option_count; i++, option++) {
305b82b9183SJiri Pirko struct team_option *del_opt;
306b82b9183SJiri Pirko
307b82b9183SJiri Pirko del_opt = __team_find_option(team, option->name);
30880f7c668SJiri Pirko if (del_opt)
30980f7c668SJiri Pirko __team_option_inst_mark_removed_option(team, del_opt);
310b82b9183SJiri Pirko }
311b82b9183SJiri Pirko }
3123d249d4cSJiri Pirko
__team_options_unregister(struct team * team,const struct team_option * option,size_t option_count)3133d249d4cSJiri Pirko static void __team_options_unregister(struct team *team,
314358b8382SJiri Pirko const struct team_option *option,
3153d249d4cSJiri Pirko size_t option_count)
3163d249d4cSJiri Pirko {
3173d249d4cSJiri Pirko int i;
3183d249d4cSJiri Pirko
319358b8382SJiri Pirko for (i = 0; i < option_count; i++, option++) {
320358b8382SJiri Pirko struct team_option *del_opt;
321358b8382SJiri Pirko
322358b8382SJiri Pirko del_opt = __team_find_option(team, option->name);
323358b8382SJiri Pirko if (del_opt) {
32480f7c668SJiri Pirko __team_option_inst_del_option(team, del_opt);
325358b8382SJiri Pirko list_del(&del_opt->list);
326358b8382SJiri Pirko kfree(del_opt);
327358b8382SJiri Pirko }
328358b8382SJiri Pirko }
3293d249d4cSJiri Pirko }
3303d249d4cSJiri Pirko
331b82b9183SJiri Pirko static void __team_options_change_check(struct team *team);
332b82b9183SJiri Pirko
team_options_register(struct team * team,const struct team_option * option,size_t option_count)333b82b9183SJiri Pirko int team_options_register(struct team *team,
334b82b9183SJiri Pirko const struct team_option *option,
335b82b9183SJiri Pirko size_t option_count)
336b82b9183SJiri Pirko {
337b82b9183SJiri Pirko int err;
338b82b9183SJiri Pirko
339b82b9183SJiri Pirko err = __team_options_register(team, option, option_count);
340b82b9183SJiri Pirko if (err)
341b82b9183SJiri Pirko return err;
342b82b9183SJiri Pirko __team_options_change_check(team);
343b82b9183SJiri Pirko return 0;
344b82b9183SJiri Pirko }
345b82b9183SJiri Pirko EXPORT_SYMBOL(team_options_register);
346b82b9183SJiri Pirko
team_options_unregister(struct team * team,const struct team_option * option,size_t option_count)347358b8382SJiri Pirko void team_options_unregister(struct team *team,
348358b8382SJiri Pirko const struct team_option *option,
3493d249d4cSJiri Pirko size_t option_count)
3503d249d4cSJiri Pirko {
351b82b9183SJiri Pirko __team_options_mark_removed(team, option, option_count);
352b82b9183SJiri Pirko __team_options_change_check(team);
3533d249d4cSJiri Pirko __team_options_unregister(team, option, option_count);
3543d249d4cSJiri Pirko }
3553d249d4cSJiri Pirko EXPORT_SYMBOL(team_options_unregister);
3563d249d4cSJiri Pirko
team_option_get(struct team * team,struct team_option_inst * opt_inst,struct team_gsetter_ctx * ctx)35780f7c668SJiri Pirko static int team_option_get(struct team *team,
35880f7c668SJiri Pirko struct team_option_inst *opt_inst,
35980f7c668SJiri Pirko struct team_gsetter_ctx *ctx)
36080f7c668SJiri Pirko {
361f82b959dSJiri Pirko if (!opt_inst->option->getter)
362f82b959dSJiri Pirko return -EOPNOTSUPP;
363c3b41f4cSZhengchao Shao
364c3b41f4cSZhengchao Shao opt_inst->option->getter(team, ctx);
365c3b41f4cSZhengchao Shao return 0;
36680f7c668SJiri Pirko }
36780f7c668SJiri Pirko
team_option_set(struct team * team,struct team_option_inst * opt_inst,struct team_gsetter_ctx * ctx)36880f7c668SJiri Pirko static int team_option_set(struct team *team,
36980f7c668SJiri Pirko struct team_option_inst *opt_inst,
37080f7c668SJiri Pirko struct team_gsetter_ctx *ctx)
37180f7c668SJiri Pirko {
372f82b959dSJiri Pirko if (!opt_inst->option->setter)
373f82b959dSJiri Pirko return -EOPNOTSUPP;
3742fcdb2c9SJiri Pirko return opt_inst->option->setter(team, ctx);
3753d249d4cSJiri Pirko }
3763d249d4cSJiri Pirko
team_option_inst_set_change(struct team_option_inst_info * opt_inst_info)3770f1aad2bSJiri Pirko void team_option_inst_set_change(struct team_option_inst_info *opt_inst_info)
3780f1aad2bSJiri Pirko {
3790f1aad2bSJiri Pirko struct team_option_inst *opt_inst;
3800f1aad2bSJiri Pirko
3810f1aad2bSJiri Pirko opt_inst = container_of(opt_inst_info, struct team_option_inst, info);
3820f1aad2bSJiri Pirko opt_inst->changed = true;
3830f1aad2bSJiri Pirko }
3840f1aad2bSJiri Pirko EXPORT_SYMBOL(team_option_inst_set_change);
3850f1aad2bSJiri Pirko
team_options_change_check(struct team * team)3860f1aad2bSJiri Pirko void team_options_change_check(struct team *team)
3870f1aad2bSJiri Pirko {
3880f1aad2bSJiri Pirko __team_options_change_check(team);
3890f1aad2bSJiri Pirko }
3900f1aad2bSJiri Pirko EXPORT_SYMBOL(team_options_change_check);
3910f1aad2bSJiri Pirko
3920f1aad2bSJiri Pirko
3933d249d4cSJiri Pirko /****************
3943d249d4cSJiri Pirko * Mode handling
3953d249d4cSJiri Pirko ****************/
3963d249d4cSJiri Pirko
3973d249d4cSJiri Pirko static LIST_HEAD(mode_list);
3983d249d4cSJiri Pirko static DEFINE_SPINLOCK(mode_list_lock);
3993d249d4cSJiri Pirko
4000402788aSJiri Pirko struct team_mode_item {
4010402788aSJiri Pirko struct list_head list;
4020402788aSJiri Pirko const struct team_mode *mode;
4030402788aSJiri Pirko };
4043d249d4cSJiri Pirko
__find_mode(const char * kind)4050402788aSJiri Pirko static struct team_mode_item *__find_mode(const char *kind)
4060402788aSJiri Pirko {
4070402788aSJiri Pirko struct team_mode_item *mitem;
4080402788aSJiri Pirko
4090402788aSJiri Pirko list_for_each_entry(mitem, &mode_list, list) {
4100402788aSJiri Pirko if (strcmp(mitem->mode->kind, kind) == 0)
4110402788aSJiri Pirko return mitem;
4123d249d4cSJiri Pirko }
4133d249d4cSJiri Pirko return NULL;
4143d249d4cSJiri Pirko }
4153d249d4cSJiri Pirko
is_good_mode_name(const char * name)4163d249d4cSJiri Pirko static bool is_good_mode_name(const char *name)
4173d249d4cSJiri Pirko {
4183d249d4cSJiri Pirko while (*name != '\0') {
4193d249d4cSJiri Pirko if (!isalpha(*name) && !isdigit(*name) && *name != '_')
4203d249d4cSJiri Pirko return false;
4213d249d4cSJiri Pirko name++;
4223d249d4cSJiri Pirko }
4233d249d4cSJiri Pirko return true;
4243d249d4cSJiri Pirko }
4253d249d4cSJiri Pirko
team_mode_register(const struct team_mode * mode)4260402788aSJiri Pirko int team_mode_register(const struct team_mode *mode)
4273d249d4cSJiri Pirko {
4283d249d4cSJiri Pirko int err = 0;
4290402788aSJiri Pirko struct team_mode_item *mitem;
4303d249d4cSJiri Pirko
4313d249d4cSJiri Pirko if (!is_good_mode_name(mode->kind) ||
4323d249d4cSJiri Pirko mode->priv_size > TEAM_MODE_PRIV_SIZE)
4333d249d4cSJiri Pirko return -EINVAL;
4340402788aSJiri Pirko
4350402788aSJiri Pirko mitem = kmalloc(sizeof(*mitem), GFP_KERNEL);
4360402788aSJiri Pirko if (!mitem)
4370402788aSJiri Pirko return -ENOMEM;
4380402788aSJiri Pirko
4393d249d4cSJiri Pirko spin_lock(&mode_list_lock);
4403d249d4cSJiri Pirko if (__find_mode(mode->kind)) {
4413d249d4cSJiri Pirko err = -EEXIST;
4420402788aSJiri Pirko kfree(mitem);
4433d249d4cSJiri Pirko goto unlock;
4443d249d4cSJiri Pirko }
4450402788aSJiri Pirko mitem->mode = mode;
4460402788aSJiri Pirko list_add_tail(&mitem->list, &mode_list);
4473d249d4cSJiri Pirko unlock:
4483d249d4cSJiri Pirko spin_unlock(&mode_list_lock);
4493d249d4cSJiri Pirko return err;
4503d249d4cSJiri Pirko }
4513d249d4cSJiri Pirko EXPORT_SYMBOL(team_mode_register);
4523d249d4cSJiri Pirko
team_mode_unregister(const struct team_mode * mode)4530402788aSJiri Pirko void team_mode_unregister(const struct team_mode *mode)
4543d249d4cSJiri Pirko {
4550402788aSJiri Pirko struct team_mode_item *mitem;
4560402788aSJiri Pirko
4573d249d4cSJiri Pirko spin_lock(&mode_list_lock);
4580402788aSJiri Pirko mitem = __find_mode(mode->kind);
4590402788aSJiri Pirko if (mitem) {
4600402788aSJiri Pirko list_del_init(&mitem->list);
4610402788aSJiri Pirko kfree(mitem);
4620402788aSJiri Pirko }
4633d249d4cSJiri Pirko spin_unlock(&mode_list_lock);
4643d249d4cSJiri Pirko }
4653d249d4cSJiri Pirko EXPORT_SYMBOL(team_mode_unregister);
4663d249d4cSJiri Pirko
team_mode_get(const char * kind)4670402788aSJiri Pirko static const struct team_mode *team_mode_get(const char *kind)
4683d249d4cSJiri Pirko {
4690402788aSJiri Pirko struct team_mode_item *mitem;
4700402788aSJiri Pirko const struct team_mode *mode = NULL;
4713d249d4cSJiri Pirko
4721c30fbc7STaehee Yoo if (!try_module_get(THIS_MODULE))
4731c30fbc7STaehee Yoo return NULL;
4741c30fbc7STaehee Yoo
4753d249d4cSJiri Pirko spin_lock(&mode_list_lock);
4760402788aSJiri Pirko mitem = __find_mode(kind);
4770402788aSJiri Pirko if (!mitem) {
4783d249d4cSJiri Pirko spin_unlock(&mode_list_lock);
4793d249d4cSJiri Pirko request_module("team-mode-%s", kind);
4803d249d4cSJiri Pirko spin_lock(&mode_list_lock);
4810402788aSJiri Pirko mitem = __find_mode(kind);
4823d249d4cSJiri Pirko }
4830402788aSJiri Pirko if (mitem) {
4840402788aSJiri Pirko mode = mitem->mode;
4853d249d4cSJiri Pirko if (!try_module_get(mode->owner))
4863d249d4cSJiri Pirko mode = NULL;
4870402788aSJiri Pirko }
4883d249d4cSJiri Pirko
4893d249d4cSJiri Pirko spin_unlock(&mode_list_lock);
4901c30fbc7STaehee Yoo module_put(THIS_MODULE);
4913d249d4cSJiri Pirko return mode;
4923d249d4cSJiri Pirko }
4933d249d4cSJiri Pirko
team_mode_put(const struct team_mode * mode)4943d249d4cSJiri Pirko static void team_mode_put(const struct team_mode *mode)
4953d249d4cSJiri Pirko {
4963d249d4cSJiri Pirko module_put(mode->owner);
4973d249d4cSJiri Pirko }
4983d249d4cSJiri Pirko
team_dummy_transmit(struct team * team,struct sk_buff * skb)4993d249d4cSJiri Pirko static bool team_dummy_transmit(struct team *team, struct sk_buff *skb)
5003d249d4cSJiri Pirko {
5013d249d4cSJiri Pirko dev_kfree_skb_any(skb);
5023d249d4cSJiri Pirko return false;
5033d249d4cSJiri Pirko }
5043d249d4cSJiri Pirko
team_dummy_receive(struct team * team,struct team_port * port,struct sk_buff * skb)5052ea46599Sstephen hemminger static rx_handler_result_t team_dummy_receive(struct team *team,
5063d249d4cSJiri Pirko struct team_port *port,
5073d249d4cSJiri Pirko struct sk_buff *skb)
5083d249d4cSJiri Pirko {
5093d249d4cSJiri Pirko return RX_HANDLER_ANOTHER;
5103d249d4cSJiri Pirko }
5113d249d4cSJiri Pirko
512d299cd51SJiri Pirko static const struct team_mode __team_no_mode = {
513d299cd51SJiri Pirko .kind = "*NOMODE*",
514d299cd51SJiri Pirko };
515d299cd51SJiri Pirko
team_is_mode_set(struct team * team)516d299cd51SJiri Pirko static bool team_is_mode_set(struct team *team)
517d299cd51SJiri Pirko {
518d299cd51SJiri Pirko return team->mode != &__team_no_mode;
519d299cd51SJiri Pirko }
520d299cd51SJiri Pirko
team_set_no_mode(struct team * team)521d299cd51SJiri Pirko static void team_set_no_mode(struct team *team)
522d299cd51SJiri Pirko {
523e185483eSFlavio Leitner team->user_carrier_enabled = false;
524d299cd51SJiri Pirko team->mode = &__team_no_mode;
525d299cd51SJiri Pirko }
526d299cd51SJiri Pirko
team_adjust_ops(struct team * team)527735d381fSJiri Pirko static void team_adjust_ops(struct team *team)
5283d249d4cSJiri Pirko {
5293d249d4cSJiri Pirko /*
5303d249d4cSJiri Pirko * To avoid checks in rx/tx skb paths, ensure here that non-null and
5313d249d4cSJiri Pirko * correct ops are always set.
5323d249d4cSJiri Pirko */
5333d249d4cSJiri Pirko
534735d381fSJiri Pirko if (!team->en_port_count || !team_is_mode_set(team) ||
535122bb046SJiri Pirko !team->mode->ops->transmit)
5363d249d4cSJiri Pirko team->ops.transmit = team_dummy_transmit;
5373d249d4cSJiri Pirko else
5383d249d4cSJiri Pirko team->ops.transmit = team->mode->ops->transmit;
5393d249d4cSJiri Pirko
540735d381fSJiri Pirko if (!team->en_port_count || !team_is_mode_set(team) ||
541122bb046SJiri Pirko !team->mode->ops->receive)
5423d249d4cSJiri Pirko team->ops.receive = team_dummy_receive;
5433d249d4cSJiri Pirko else
5443d249d4cSJiri Pirko team->ops.receive = team->mode->ops->receive;
5453d249d4cSJiri Pirko }
5463d249d4cSJiri Pirko
5473d249d4cSJiri Pirko /*
5483d249d4cSJiri Pirko * We can benefit from the fact that it's ensured no port is present
5493d249d4cSJiri Pirko * at the time of mode change. Therefore no packets are in fly so there's no
5503d249d4cSJiri Pirko * need to set mode operations in any special way.
5513d249d4cSJiri Pirko */
__team_change_mode(struct team * team,const struct team_mode * new_mode)5523d249d4cSJiri Pirko static int __team_change_mode(struct team *team,
5533d249d4cSJiri Pirko const struct team_mode *new_mode)
5543d249d4cSJiri Pirko {
5553d249d4cSJiri Pirko /* Check if mode was previously set and do cleanup if so */
556d299cd51SJiri Pirko if (team_is_mode_set(team)) {
5573d249d4cSJiri Pirko void (*exit_op)(struct team *team) = team->ops.exit;
5583d249d4cSJiri Pirko
5593d249d4cSJiri Pirko /* Clear ops area so no callback is called any longer */
5603d249d4cSJiri Pirko memset(&team->ops, 0, sizeof(struct team_mode_ops));
5613d249d4cSJiri Pirko team_adjust_ops(team);
5623d249d4cSJiri Pirko
5633d249d4cSJiri Pirko if (exit_op)
5643d249d4cSJiri Pirko exit_op(team);
5653d249d4cSJiri Pirko team_mode_put(team->mode);
566d299cd51SJiri Pirko team_set_no_mode(team);
5673d249d4cSJiri Pirko /* zero private data area */
5683d249d4cSJiri Pirko memset(&team->mode_priv, 0,
5693d249d4cSJiri Pirko sizeof(struct team) - offsetof(struct team, mode_priv));
5703d249d4cSJiri Pirko }
5713d249d4cSJiri Pirko
5723d249d4cSJiri Pirko if (!new_mode)
5733d249d4cSJiri Pirko return 0;
5743d249d4cSJiri Pirko
5753d249d4cSJiri Pirko if (new_mode->ops->init) {
5763d249d4cSJiri Pirko int err;
5773d249d4cSJiri Pirko
5783d249d4cSJiri Pirko err = new_mode->ops->init(team);
5793d249d4cSJiri Pirko if (err)
5803d249d4cSJiri Pirko return err;
5813d249d4cSJiri Pirko }
5823d249d4cSJiri Pirko
5833d249d4cSJiri Pirko team->mode = new_mode;
5843d249d4cSJiri Pirko memcpy(&team->ops, new_mode->ops, sizeof(struct team_mode_ops));
5853d249d4cSJiri Pirko team_adjust_ops(team);
5863d249d4cSJiri Pirko
5873d249d4cSJiri Pirko return 0;
5883d249d4cSJiri Pirko }
5893d249d4cSJiri Pirko
team_change_mode(struct team * team,const char * kind)5903d249d4cSJiri Pirko static int team_change_mode(struct team *team, const char *kind)
5913d249d4cSJiri Pirko {
5920402788aSJiri Pirko const struct team_mode *new_mode;
5933d249d4cSJiri Pirko struct net_device *dev = team->dev;
5943d249d4cSJiri Pirko int err;
5953d249d4cSJiri Pirko
5963d249d4cSJiri Pirko if (!list_empty(&team->port_list)) {
5973d249d4cSJiri Pirko netdev_err(dev, "No ports can be present during mode change\n");
5983d249d4cSJiri Pirko return -EBUSY;
5993d249d4cSJiri Pirko }
6003d249d4cSJiri Pirko
601d299cd51SJiri Pirko if (team_is_mode_set(team) && strcmp(team->mode->kind, kind) == 0) {
6023d249d4cSJiri Pirko netdev_err(dev, "Unable to change to the same mode the team is in\n");
6033d249d4cSJiri Pirko return -EINVAL;
6043d249d4cSJiri Pirko }
6053d249d4cSJiri Pirko
6063d249d4cSJiri Pirko new_mode = team_mode_get(kind);
6073d249d4cSJiri Pirko if (!new_mode) {
6083d249d4cSJiri Pirko netdev_err(dev, "Mode \"%s\" not found\n", kind);
6093d249d4cSJiri Pirko return -EINVAL;
6103d249d4cSJiri Pirko }
6113d249d4cSJiri Pirko
6123d249d4cSJiri Pirko err = __team_change_mode(team, new_mode);
6133d249d4cSJiri Pirko if (err) {
6143d249d4cSJiri Pirko netdev_err(dev, "Failed to change to mode \"%s\"\n", kind);
6153d249d4cSJiri Pirko team_mode_put(new_mode);
6163d249d4cSJiri Pirko return err;
6173d249d4cSJiri Pirko }
6183d249d4cSJiri Pirko
6193d249d4cSJiri Pirko netdev_info(dev, "Mode changed to \"%s\"\n", kind);
6203d249d4cSJiri Pirko return 0;
6213d249d4cSJiri Pirko }
6223d249d4cSJiri Pirko
6233d249d4cSJiri Pirko
624fc423ff0SJiri Pirko /*********************
625fc423ff0SJiri Pirko * Peers notification
626fc423ff0SJiri Pirko *********************/
627fc423ff0SJiri Pirko
team_notify_peers_work(struct work_struct * work)628fc423ff0SJiri Pirko static void team_notify_peers_work(struct work_struct *work)
629fc423ff0SJiri Pirko {
630fc423ff0SJiri Pirko struct team *team;
631b0d11b42SJiri Pirko int val;
632fc423ff0SJiri Pirko
633fc423ff0SJiri Pirko team = container_of(work, struct team, notify_peers.dw.work);
634fc423ff0SJiri Pirko
635fc423ff0SJiri Pirko if (!rtnl_trylock()) {
636fc423ff0SJiri Pirko schedule_delayed_work(&team->notify_peers.dw, 0);
637fc423ff0SJiri Pirko return;
638fc423ff0SJiri Pirko }
639b0d11b42SJiri Pirko val = atomic_dec_if_positive(&team->notify_peers.count_pending);
640b0d11b42SJiri Pirko if (val < 0) {
641b0d11b42SJiri Pirko rtnl_unlock();
642b0d11b42SJiri Pirko return;
643b0d11b42SJiri Pirko }
644fc423ff0SJiri Pirko call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, team->dev);
645fc423ff0SJiri Pirko rtnl_unlock();
646b0d11b42SJiri Pirko if (val)
647fc423ff0SJiri Pirko schedule_delayed_work(&team->notify_peers.dw,
648fc423ff0SJiri Pirko msecs_to_jiffies(team->notify_peers.interval));
649fc423ff0SJiri Pirko }
650fc423ff0SJiri Pirko
team_notify_peers(struct team * team)651fc423ff0SJiri Pirko static void team_notify_peers(struct team *team)
652fc423ff0SJiri Pirko {
653fc423ff0SJiri Pirko if (!team->notify_peers.count || !netif_running(team->dev))
654fc423ff0SJiri Pirko return;
65547549650SJoe Lawrence atomic_add(team->notify_peers.count, &team->notify_peers.count_pending);
656fc423ff0SJiri Pirko schedule_delayed_work(&team->notify_peers.dw, 0);
657fc423ff0SJiri Pirko }
658fc423ff0SJiri Pirko
team_notify_peers_init(struct team * team)659fc423ff0SJiri Pirko static void team_notify_peers_init(struct team *team)
660fc423ff0SJiri Pirko {
661fc423ff0SJiri Pirko INIT_DELAYED_WORK(&team->notify_peers.dw, team_notify_peers_work);
662fc423ff0SJiri Pirko }
663fc423ff0SJiri Pirko
team_notify_peers_fini(struct team * team)664fc423ff0SJiri Pirko static void team_notify_peers_fini(struct team *team)
665fc423ff0SJiri Pirko {
666fc423ff0SJiri Pirko cancel_delayed_work_sync(&team->notify_peers.dw);
667fc423ff0SJiri Pirko }
668fc423ff0SJiri Pirko
669fc423ff0SJiri Pirko
670492b200eSJiri Pirko /*******************************
671492b200eSJiri Pirko * Send multicast group rejoins
672492b200eSJiri Pirko *******************************/
673492b200eSJiri Pirko
team_mcast_rejoin_work(struct work_struct * work)674492b200eSJiri Pirko static void team_mcast_rejoin_work(struct work_struct *work)
675492b200eSJiri Pirko {
676492b200eSJiri Pirko struct team *team;
677b0d11b42SJiri Pirko int val;
678492b200eSJiri Pirko
679492b200eSJiri Pirko team = container_of(work, struct team, mcast_rejoin.dw.work);
680492b200eSJiri Pirko
681492b200eSJiri Pirko if (!rtnl_trylock()) {
682492b200eSJiri Pirko schedule_delayed_work(&team->mcast_rejoin.dw, 0);
683492b200eSJiri Pirko return;
684492b200eSJiri Pirko }
685b0d11b42SJiri Pirko val = atomic_dec_if_positive(&team->mcast_rejoin.count_pending);
686b0d11b42SJiri Pirko if (val < 0) {
687b0d11b42SJiri Pirko rtnl_unlock();
688b0d11b42SJiri Pirko return;
689b0d11b42SJiri Pirko }
690492b200eSJiri Pirko call_netdevice_notifiers(NETDEV_RESEND_IGMP, team->dev);
691492b200eSJiri Pirko rtnl_unlock();
692b0d11b42SJiri Pirko if (val)
693492b200eSJiri Pirko schedule_delayed_work(&team->mcast_rejoin.dw,
694492b200eSJiri Pirko msecs_to_jiffies(team->mcast_rejoin.interval));
695492b200eSJiri Pirko }
696492b200eSJiri Pirko
team_mcast_rejoin(struct team * team)697492b200eSJiri Pirko static void team_mcast_rejoin(struct team *team)
698492b200eSJiri Pirko {
699492b200eSJiri Pirko if (!team->mcast_rejoin.count || !netif_running(team->dev))
700492b200eSJiri Pirko return;
70147549650SJoe Lawrence atomic_add(team->mcast_rejoin.count, &team->mcast_rejoin.count_pending);
702492b200eSJiri Pirko schedule_delayed_work(&team->mcast_rejoin.dw, 0);
703492b200eSJiri Pirko }
704492b200eSJiri Pirko
team_mcast_rejoin_init(struct team * team)705492b200eSJiri Pirko static void team_mcast_rejoin_init(struct team *team)
706492b200eSJiri Pirko {
707492b200eSJiri Pirko INIT_DELAYED_WORK(&team->mcast_rejoin.dw, team_mcast_rejoin_work);
708492b200eSJiri Pirko }
709492b200eSJiri Pirko
team_mcast_rejoin_fini(struct team * team)710492b200eSJiri Pirko static void team_mcast_rejoin_fini(struct team *team)
711492b200eSJiri Pirko {
712492b200eSJiri Pirko cancel_delayed_work_sync(&team->mcast_rejoin.dw);
713492b200eSJiri Pirko }
714492b200eSJiri Pirko
715492b200eSJiri Pirko
7163d249d4cSJiri Pirko /************************
7173d249d4cSJiri Pirko * Rx path frame handler
7183d249d4cSJiri Pirko ************************/
7193d249d4cSJiri Pirko
7203d249d4cSJiri Pirko /* note: already called with rcu_read_lock */
team_handle_frame(struct sk_buff ** pskb)7213d249d4cSJiri Pirko static rx_handler_result_t team_handle_frame(struct sk_buff **pskb)
7223d249d4cSJiri Pirko {
7233d249d4cSJiri Pirko struct sk_buff *skb = *pskb;
7243d249d4cSJiri Pirko struct team_port *port;
7253d249d4cSJiri Pirko struct team *team;
7263d249d4cSJiri Pirko rx_handler_result_t res;
7273d249d4cSJiri Pirko
7283d249d4cSJiri Pirko skb = skb_share_check(skb, GFP_ATOMIC);
7293d249d4cSJiri Pirko if (!skb)
7303d249d4cSJiri Pirko return RX_HANDLER_CONSUMED;
7313d249d4cSJiri Pirko
7323d249d4cSJiri Pirko *pskb = skb;
7333d249d4cSJiri Pirko
7343d249d4cSJiri Pirko port = team_port_get_rcu(skb->dev);
7353d249d4cSJiri Pirko team = port->team;
73619a0b58eSJiri Pirko if (!team_port_enabled(port)) {
737aaae162aSjeffreyji if (is_link_local_ether_addr(eth_hdr(skb)->h_dest))
738aaae162aSjeffreyji /* link-local packets are mostly useful when stack receives them
739aaae162aSjeffreyji * with the link they arrive on.
740aaae162aSjeffreyji */
741aaae162aSjeffreyji return RX_HANDLER_PASS;
74219a0b58eSJiri Pirko /* allow exact match delivery for disabled ports */
74319a0b58eSJiri Pirko res = RX_HANDLER_EXACT;
74419a0b58eSJiri Pirko } else {
7453d249d4cSJiri Pirko res = team->ops.receive(team, port, skb);
74619a0b58eSJiri Pirko }
7473d249d4cSJiri Pirko if (res == RX_HANDLER_ANOTHER) {
7483d249d4cSJiri Pirko struct team_pcpu_stats *pcpu_stats;
7493d249d4cSJiri Pirko
7503d249d4cSJiri Pirko pcpu_stats = this_cpu_ptr(team->pcpu_stats);
7513d249d4cSJiri Pirko u64_stats_update_begin(&pcpu_stats->syncp);
7529ec321abSEric Dumazet u64_stats_inc(&pcpu_stats->rx_packets);
7539ec321abSEric Dumazet u64_stats_add(&pcpu_stats->rx_bytes, skb->len);
7543d249d4cSJiri Pirko if (skb->pkt_type == PACKET_MULTICAST)
7559ec321abSEric Dumazet u64_stats_inc(&pcpu_stats->rx_multicast);
7563d249d4cSJiri Pirko u64_stats_update_end(&pcpu_stats->syncp);
7573d249d4cSJiri Pirko
7583d249d4cSJiri Pirko skb->dev = team->dev;
759bb63daf9SJarod Wilson } else if (res == RX_HANDLER_EXACT) {
760bb63daf9SJarod Wilson this_cpu_inc(team->pcpu_stats->rx_nohandler);
7613d249d4cSJiri Pirko } else {
7623d249d4cSJiri Pirko this_cpu_inc(team->pcpu_stats->rx_dropped);
7633d249d4cSJiri Pirko }
7643d249d4cSJiri Pirko
7653d249d4cSJiri Pirko return res;
7663d249d4cSJiri Pirko }
7673d249d4cSJiri Pirko
7683d249d4cSJiri Pirko
7698ff5105aSJiri Pirko /*************************************
7708ff5105aSJiri Pirko * Multiqueue Tx port select override
7718ff5105aSJiri Pirko *************************************/
7728ff5105aSJiri Pirko
team_queue_override_init(struct team * team)7738ff5105aSJiri Pirko static int team_queue_override_init(struct team *team)
7748ff5105aSJiri Pirko {
7758ff5105aSJiri Pirko struct list_head *listarr;
7768ff5105aSJiri Pirko unsigned int queue_cnt = team->dev->num_tx_queues - 1;
7778ff5105aSJiri Pirko unsigned int i;
7788ff5105aSJiri Pirko
7798ff5105aSJiri Pirko if (!queue_cnt)
7808ff5105aSJiri Pirko return 0;
7816da2ec56SKees Cook listarr = kmalloc_array(queue_cnt, sizeof(struct list_head),
7826da2ec56SKees Cook GFP_KERNEL);
7838ff5105aSJiri Pirko if (!listarr)
7848ff5105aSJiri Pirko return -ENOMEM;
7858ff5105aSJiri Pirko team->qom_lists = listarr;
7868ff5105aSJiri Pirko for (i = 0; i < queue_cnt; i++)
7878ff5105aSJiri Pirko INIT_LIST_HEAD(listarr++);
7888ff5105aSJiri Pirko return 0;
7898ff5105aSJiri Pirko }
7908ff5105aSJiri Pirko
team_queue_override_fini(struct team * team)7918ff5105aSJiri Pirko static void team_queue_override_fini(struct team *team)
7928ff5105aSJiri Pirko {
7938ff5105aSJiri Pirko kfree(team->qom_lists);
7948ff5105aSJiri Pirko }
7958ff5105aSJiri Pirko
__team_get_qom_list(struct team * team,u16 queue_id)7968ff5105aSJiri Pirko static struct list_head *__team_get_qom_list(struct team *team, u16 queue_id)
7978ff5105aSJiri Pirko {
7988ff5105aSJiri Pirko return &team->qom_lists[queue_id - 1];
7998ff5105aSJiri Pirko }
8008ff5105aSJiri Pirko
8018ff5105aSJiri Pirko /*
8028ff5105aSJiri Pirko * note: already called with rcu_read_lock
8038ff5105aSJiri Pirko */
team_queue_override_transmit(struct team * team,struct sk_buff * skb)8048ff5105aSJiri Pirko static bool team_queue_override_transmit(struct team *team, struct sk_buff *skb)
8058ff5105aSJiri Pirko {
8068ff5105aSJiri Pirko struct list_head *qom_list;
8078ff5105aSJiri Pirko struct team_port *port;
8088ff5105aSJiri Pirko
8098ff5105aSJiri Pirko if (!team->queue_override_enabled || !skb->queue_mapping)
8108ff5105aSJiri Pirko return false;
8118ff5105aSJiri Pirko qom_list = __team_get_qom_list(team, skb->queue_mapping);
8128ff5105aSJiri Pirko list_for_each_entry_rcu(port, qom_list, qom_list) {
8138ff5105aSJiri Pirko if (!team_dev_queue_xmit(team, port, skb))
8148ff5105aSJiri Pirko return true;
8158ff5105aSJiri Pirko }
8168ff5105aSJiri Pirko return false;
8178ff5105aSJiri Pirko }
8188ff5105aSJiri Pirko
__team_queue_override_port_del(struct team * team,struct team_port * port)8198ff5105aSJiri Pirko static void __team_queue_override_port_del(struct team *team,
8208ff5105aSJiri Pirko struct team_port *port)
8218ff5105aSJiri Pirko {
8226c31ff36SJiri Pirko if (!port->queue_id)
8236c31ff36SJiri Pirko return;
8248ff5105aSJiri Pirko list_del_rcu(&port->qom_list);
8258ff5105aSJiri Pirko }
8268ff5105aSJiri Pirko
team_queue_override_port_has_gt_prio_than(struct team_port * port,struct team_port * cur)8278ff5105aSJiri Pirko static bool team_queue_override_port_has_gt_prio_than(struct team_port *port,
8288ff5105aSJiri Pirko struct team_port *cur)
8298ff5105aSJiri Pirko {
8308ff5105aSJiri Pirko if (port->priority < cur->priority)
8318ff5105aSJiri Pirko return true;
8328ff5105aSJiri Pirko if (port->priority > cur->priority)
8338ff5105aSJiri Pirko return false;
8348ff5105aSJiri Pirko if (port->index < cur->index)
8358ff5105aSJiri Pirko return true;
8368ff5105aSJiri Pirko return false;
8378ff5105aSJiri Pirko }
8388ff5105aSJiri Pirko
__team_queue_override_port_add(struct team * team,struct team_port * port)8398ff5105aSJiri Pirko static void __team_queue_override_port_add(struct team *team,
8408ff5105aSJiri Pirko struct team_port *port)
8418ff5105aSJiri Pirko {
8428ff5105aSJiri Pirko struct team_port *cur;
8438ff5105aSJiri Pirko struct list_head *qom_list;
8448ff5105aSJiri Pirko struct list_head *node;
8458ff5105aSJiri Pirko
8466c31ff36SJiri Pirko if (!port->queue_id)
8478ff5105aSJiri Pirko return;
8488ff5105aSJiri Pirko qom_list = __team_get_qom_list(team, port->queue_id);
8498ff5105aSJiri Pirko node = qom_list;
8508ff5105aSJiri Pirko list_for_each_entry(cur, qom_list, qom_list) {
8518ff5105aSJiri Pirko if (team_queue_override_port_has_gt_prio_than(port, cur))
8528ff5105aSJiri Pirko break;
8538ff5105aSJiri Pirko node = &cur->qom_list;
8548ff5105aSJiri Pirko }
8558ff5105aSJiri Pirko list_add_tail_rcu(&port->qom_list, node);
8568ff5105aSJiri Pirko }
8578ff5105aSJiri Pirko
__team_queue_override_enabled_check(struct team * team)8588ff5105aSJiri Pirko static void __team_queue_override_enabled_check(struct team *team)
8598ff5105aSJiri Pirko {
8608ff5105aSJiri Pirko struct team_port *port;
8618ff5105aSJiri Pirko bool enabled = false;
8628ff5105aSJiri Pirko
8638ff5105aSJiri Pirko list_for_each_entry(port, &team->port_list, list) {
8646c31ff36SJiri Pirko if (port->queue_id) {
8658ff5105aSJiri Pirko enabled = true;
8668ff5105aSJiri Pirko break;
8678ff5105aSJiri Pirko }
8688ff5105aSJiri Pirko }
8698ff5105aSJiri Pirko if (enabled == team->queue_override_enabled)
8708ff5105aSJiri Pirko return;
8718ff5105aSJiri Pirko netdev_dbg(team->dev, "%s queue override\n",
8728ff5105aSJiri Pirko enabled ? "Enabling" : "Disabling");
8738ff5105aSJiri Pirko team->queue_override_enabled = enabled;
8748ff5105aSJiri Pirko }
8758ff5105aSJiri Pirko
team_queue_override_port_prio_changed(struct team * team,struct team_port * port)8766c31ff36SJiri Pirko static void team_queue_override_port_prio_changed(struct team *team,
8776c31ff36SJiri Pirko struct team_port *port)
8786c31ff36SJiri Pirko {
8796c31ff36SJiri Pirko if (!port->queue_id || team_port_enabled(port))
8806c31ff36SJiri Pirko return;
8816c31ff36SJiri Pirko __team_queue_override_port_del(team, port);
8826c31ff36SJiri Pirko __team_queue_override_port_add(team, port);
8836c31ff36SJiri Pirko __team_queue_override_enabled_check(team);
8846c31ff36SJiri Pirko }
8856c31ff36SJiri Pirko
team_queue_override_port_change_queue_id(struct team * team,struct team_port * port,u16 new_queue_id)8866c31ff36SJiri Pirko static void team_queue_override_port_change_queue_id(struct team *team,
8876c31ff36SJiri Pirko struct team_port *port,
8886c31ff36SJiri Pirko u16 new_queue_id)
8896c31ff36SJiri Pirko {
8906c31ff36SJiri Pirko if (team_port_enabled(port)) {
8916c31ff36SJiri Pirko __team_queue_override_port_del(team, port);
8926c31ff36SJiri Pirko port->queue_id = new_queue_id;
8936c31ff36SJiri Pirko __team_queue_override_port_add(team, port);
8946c31ff36SJiri Pirko __team_queue_override_enabled_check(team);
8956c31ff36SJiri Pirko } else {
8966c31ff36SJiri Pirko port->queue_id = new_queue_id;
8976c31ff36SJiri Pirko }
8986c31ff36SJiri Pirko }
8996c31ff36SJiri Pirko
team_queue_override_port_add(struct team * team,struct team_port * port)9006c31ff36SJiri Pirko static void team_queue_override_port_add(struct team *team,
9016c31ff36SJiri Pirko struct team_port *port)
9026c31ff36SJiri Pirko {
9036c31ff36SJiri Pirko __team_queue_override_port_add(team, port);
9046c31ff36SJiri Pirko __team_queue_override_enabled_check(team);
9056c31ff36SJiri Pirko }
9066c31ff36SJiri Pirko
team_queue_override_port_del(struct team * team,struct team_port * port)9076c31ff36SJiri Pirko static void team_queue_override_port_del(struct team *team,
9088ff5105aSJiri Pirko struct team_port *port)
9098ff5105aSJiri Pirko {
9108ff5105aSJiri Pirko __team_queue_override_port_del(team, port);
9118ff5105aSJiri Pirko __team_queue_override_enabled_check(team);
9128ff5105aSJiri Pirko }
9138ff5105aSJiri Pirko
9148ff5105aSJiri Pirko
9153d249d4cSJiri Pirko /****************
9163d249d4cSJiri Pirko * Port handling
9173d249d4cSJiri Pirko ****************/
9183d249d4cSJiri Pirko
team_port_find(const struct team * team,const struct team_port * port)9193d249d4cSJiri Pirko static bool team_port_find(const struct team *team,
9203d249d4cSJiri Pirko const struct team_port *port)
9213d249d4cSJiri Pirko {
9223d249d4cSJiri Pirko struct team_port *cur;
9233d249d4cSJiri Pirko
9243d249d4cSJiri Pirko list_for_each_entry(cur, &team->port_list, list)
9253d249d4cSJiri Pirko if (cur == port)
9263d249d4cSJiri Pirko return true;
9273d249d4cSJiri Pirko return false;
9283d249d4cSJiri Pirko }
9293d249d4cSJiri Pirko
9303d249d4cSJiri Pirko /*
93119a0b58eSJiri Pirko * Enable/disable port by adding to enabled port hashlist and setting
93219a0b58eSJiri Pirko * port->index (Might be racy so reader could see incorrect ifindex when
93319a0b58eSJiri Pirko * processing a flying packet, but that is not a problem). Write guarded
93419a0b58eSJiri Pirko * by team->lock.
9353d249d4cSJiri Pirko */
team_port_enable(struct team * team,struct team_port * port)93619a0b58eSJiri Pirko static void team_port_enable(struct team *team,
9373d249d4cSJiri Pirko struct team_port *port)
9383d249d4cSJiri Pirko {
93919a0b58eSJiri Pirko if (team_port_enabled(port))
94019a0b58eSJiri Pirko return;
94119a0b58eSJiri Pirko port->index = team->en_port_count++;
9423d249d4cSJiri Pirko hlist_add_head_rcu(&port->hlist,
9433d249d4cSJiri Pirko team_port_index_hash(team, port->index));
944122bb046SJiri Pirko team_adjust_ops(team);
9456c31ff36SJiri Pirko team_queue_override_port_add(team, port);
9464bccfd17SJiri Pirko if (team->ops.port_enabled)
9474bccfd17SJiri Pirko team->ops.port_enabled(team, port);
948fc423ff0SJiri Pirko team_notify_peers(team);
949492b200eSJiri Pirko team_mcast_rejoin(team);
9503a0d6c5aSJiri Pirko team_lower_state_changed(port);
9513d249d4cSJiri Pirko }
9523d249d4cSJiri Pirko
__reconstruct_port_hlist(struct team * team,int rm_index)9533d249d4cSJiri Pirko static void __reconstruct_port_hlist(struct team *team, int rm_index)
9543d249d4cSJiri Pirko {
9553d249d4cSJiri Pirko int i;
9563d249d4cSJiri Pirko struct team_port *port;
9573d249d4cSJiri Pirko
95819a0b58eSJiri Pirko for (i = rm_index + 1; i < team->en_port_count; i++) {
9593d249d4cSJiri Pirko port = team_get_port_by_index(team, i);
9603d249d4cSJiri Pirko hlist_del_rcu(&port->hlist);
9613d249d4cSJiri Pirko port->index--;
9623d249d4cSJiri Pirko hlist_add_head_rcu(&port->hlist,
9633d249d4cSJiri Pirko team_port_index_hash(team, port->index));
9643d249d4cSJiri Pirko }
9653d249d4cSJiri Pirko }
9663d249d4cSJiri Pirko
team_port_disable(struct team * team,struct team_port * port)96719a0b58eSJiri Pirko static void team_port_disable(struct team *team,
9683d249d4cSJiri Pirko struct team_port *port)
9693d249d4cSJiri Pirko {
97019a0b58eSJiri Pirko if (!team_port_enabled(port))
97119a0b58eSJiri Pirko return;
9724bccfd17SJiri Pirko if (team->ops.port_disabled)
9734bccfd17SJiri Pirko team->ops.port_disabled(team, port);
9743d249d4cSJiri Pirko hlist_del_rcu(&port->hlist);
975122bb046SJiri Pirko __reconstruct_port_hlist(team, port->index);
97619a0b58eSJiri Pirko port->index = -1;
977122bb046SJiri Pirko team->en_port_count--;
978735d381fSJiri Pirko team_queue_override_port_del(team, port);
979735d381fSJiri Pirko team_adjust_ops(team);
9803a0d6c5aSJiri Pirko team_lower_state_changed(port);
9813d249d4cSJiri Pirko }
9823d249d4cSJiri Pirko
983a188222bSTom Herbert #define TEAM_VLAN_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
984ecb8fed4SAlexander Lobakin NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE | \
9853d249d4cSJiri Pirko NETIF_F_HIGHDMA | NETIF_F_LRO)
9863d249d4cSJiri Pirko
9873268e5cbSEran Ben Elisha #define TEAM_ENC_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
988ecb8fed4SAlexander Lobakin NETIF_F_RXCSUM | NETIF_F_GSO_SOFTWARE)
9893268e5cbSEran Ben Elisha
__team_compute_features(struct team * team)99016cf72bbSXin Long static void __team_compute_features(struct team *team)
9913d249d4cSJiri Pirko {
9923d249d4cSJiri Pirko struct team_port *port;
99325ea6654SDan Carpenter netdev_features_t vlan_features = TEAM_VLAN_FEATURES &
99425ea6654SDan Carpenter NETIF_F_ALL_FOR_ALL;
9953268e5cbSEran Ben Elisha netdev_features_t enc_features = TEAM_ENC_FEATURES;
9963d249d4cSJiri Pirko unsigned short max_hard_header_len = ETH_HLEN;
99702875878SEric Dumazet unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE |
99802875878SEric Dumazet IFF_XMIT_DST_RELEASE_PERM;
9993d249d4cSJiri Pirko
1000f0947d0dSIvan Vecera rcu_read_lock();
1001f0947d0dSIvan Vecera list_for_each_entry_rcu(port, &team->port_list, list) {
10023d249d4cSJiri Pirko vlan_features = netdev_increment_features(vlan_features,
10033d249d4cSJiri Pirko port->dev->vlan_features,
10043d249d4cSJiri Pirko TEAM_VLAN_FEATURES);
10053268e5cbSEran Ben Elisha enc_features =
10063268e5cbSEran Ben Elisha netdev_increment_features(enc_features,
10073268e5cbSEran Ben Elisha port->dev->hw_enc_features,
10083268e5cbSEran Ben Elisha TEAM_ENC_FEATURES);
10093268e5cbSEran Ben Elisha
10103d249d4cSJiri Pirko
1011dc905951SJiri Pirko dst_release_flag &= port->dev->priv_flags;
10123d249d4cSJiri Pirko if (port->dev->hard_header_len > max_hard_header_len)
10133d249d4cSJiri Pirko max_hard_header_len = port->dev->hard_header_len;
10143d249d4cSJiri Pirko }
1015f0947d0dSIvan Vecera rcu_read_unlock();
10163d249d4cSJiri Pirko
10173d249d4cSJiri Pirko team->dev->vlan_features = vlan_features;
10188eea1ca8SWillem de Bruijn team->dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL |
1019227f2f03SYueHaibing NETIF_F_HW_VLAN_CTAG_TX |
1020ecb8fed4SAlexander Lobakin NETIF_F_HW_VLAN_STAG_TX;
10213d249d4cSJiri Pirko team->dev->hard_header_len = max_hard_header_len;
10223d249d4cSJiri Pirko
102302875878SEric Dumazet team->dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
102402875878SEric Dumazet if (dst_release_flag == (IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM))
102502875878SEric Dumazet team->dev->priv_flags |= IFF_XMIT_DST_RELEASE;
1026f6988cb6SIvan Vecera }
1027dc905951SJiri Pirko
team_compute_features(struct team * team)10283d249d4cSJiri Pirko static void team_compute_features(struct team *team)
10293d249d4cSJiri Pirko {
103016cf72bbSXin Long __team_compute_features(team);
1031f6988cb6SIvan Vecera netdev_change_features(team->dev);
10323d249d4cSJiri Pirko }
10333d249d4cSJiri Pirko
team_port_enter(struct team * team,struct team_port * port)10343d249d4cSJiri Pirko static int team_port_enter(struct team *team, struct team_port *port)
10353d249d4cSJiri Pirko {
10363d249d4cSJiri Pirko int err = 0;
10373d249d4cSJiri Pirko
10383d249d4cSJiri Pirko dev_hold(team->dev);
10393d249d4cSJiri Pirko if (team->ops.port_enter) {
10403d249d4cSJiri Pirko err = team->ops.port_enter(team, port);
10413d249d4cSJiri Pirko if (err) {
10423d249d4cSJiri Pirko netdev_err(team->dev, "Device %s failed to enter team mode\n",
10433d249d4cSJiri Pirko port->dev->name);
10443d249d4cSJiri Pirko goto err_port_enter;
10453d249d4cSJiri Pirko }
10463d249d4cSJiri Pirko }
10473d249d4cSJiri Pirko
10483d249d4cSJiri Pirko return 0;
10493d249d4cSJiri Pirko
10503d249d4cSJiri Pirko err_port_enter:
10513d249d4cSJiri Pirko dev_put(team->dev);
10523d249d4cSJiri Pirko
10533d249d4cSJiri Pirko return err;
10543d249d4cSJiri Pirko }
10553d249d4cSJiri Pirko
team_port_leave(struct team * team,struct team_port * port)10563d249d4cSJiri Pirko static void team_port_leave(struct team *team, struct team_port *port)
10573d249d4cSJiri Pirko {
10583d249d4cSJiri Pirko if (team->ops.port_leave)
10593d249d4cSJiri Pirko team->ops.port_leave(team, port);
10603d249d4cSJiri Pirko dev_put(team->dev);
10613d249d4cSJiri Pirko }
10623d249d4cSJiri Pirko
1063bd2d0837SJiri Pirko #ifdef CONFIG_NET_POLL_CONTROLLER
__team_port_enable_netpoll(struct team_port * port)10649cf2f437SXin Long static int __team_port_enable_netpoll(struct team_port *port)
1065bd2d0837SJiri Pirko {
1066bd2d0837SJiri Pirko struct netpoll *np;
1067bd2d0837SJiri Pirko int err;
1068bd2d0837SJiri Pirko
1069a8779ec1SEric W. Biederman np = kzalloc(sizeof(*np), GFP_KERNEL);
1070bd2d0837SJiri Pirko if (!np)
1071bd2d0837SJiri Pirko return -ENOMEM;
1072bd2d0837SJiri Pirko
1073a8779ec1SEric W. Biederman err = __netpoll_setup(np, port->dev);
1074bd2d0837SJiri Pirko if (err) {
1075bd2d0837SJiri Pirko kfree(np);
1076bd2d0837SJiri Pirko return err;
1077bd2d0837SJiri Pirko }
1078bd2d0837SJiri Pirko port->np = np;
1079bd2d0837SJiri Pirko return err;
1080bd2d0837SJiri Pirko }
1081bd2d0837SJiri Pirko
team_port_enable_netpoll(struct team_port * port)10829cf2f437SXin Long static int team_port_enable_netpoll(struct team_port *port)
10839cf2f437SXin Long {
10849cf2f437SXin Long if (!port->team->dev->npinfo)
10859cf2f437SXin Long return 0;
10869cf2f437SXin Long
10879cf2f437SXin Long return __team_port_enable_netpoll(port);
10889cf2f437SXin Long }
10899cf2f437SXin Long
team_port_disable_netpoll(struct team_port * port)1090bd2d0837SJiri Pirko static void team_port_disable_netpoll(struct team_port *port)
1091bd2d0837SJiri Pirko {
1092bd2d0837SJiri Pirko struct netpoll *np = port->np;
1093bd2d0837SJiri Pirko
1094bd2d0837SJiri Pirko if (!np)
1095bd2d0837SJiri Pirko return;
1096bd2d0837SJiri Pirko port->np = NULL;
1097bd2d0837SJiri Pirko
1098c9fbd71fSDebabrata Banerjee __netpoll_free(np);
1099bd2d0837SJiri Pirko }
1100bd2d0837SJiri Pirko #else
team_port_enable_netpoll(struct team_port * port)11019cf2f437SXin Long static int team_port_enable_netpoll(struct team_port *port)
1102bd2d0837SJiri Pirko {
1103bd2d0837SJiri Pirko return 0;
1104bd2d0837SJiri Pirko }
team_port_disable_netpoll(struct team_port * port)1105bd2d0837SJiri Pirko static void team_port_disable_netpoll(struct team_port *port)
1106bd2d0837SJiri Pirko {
1107bd2d0837SJiri Pirko }
1108bd2d0837SJiri Pirko #endif
1109bd2d0837SJiri Pirko
team_upper_dev_link(struct team * team,struct team_port * port,struct netlink_ext_ack * extack)111044d15d93SIdo Schimmel static int team_upper_dev_link(struct team *team, struct team_port *port,
111144d15d93SIdo Schimmel struct netlink_ext_ack *extack)
1112d7d3c051SJiri Pirko {
11138fd72856SJiri Pirko struct netdev_lag_upper_info lag_upper_info;
1114d7d3c051SJiri Pirko int err;
1115d7d3c051SJiri Pirko
11168fd72856SJiri Pirko lag_upper_info.tx_type = team->mode->lag_tx_type;
1117f44aa9efSJohn Hurley lag_upper_info.hash_type = NETDEV_LAG_HASH_UNKNOWN;
11188fd72856SJiri Pirko err = netdev_master_upper_dev_link(port->dev, team->dev, NULL,
111944d15d93SIdo Schimmel &lag_upper_info, extack);
1120d7d3c051SJiri Pirko if (err)
1121d7d3c051SJiri Pirko return err;
11228fd72856SJiri Pirko port->dev->priv_flags |= IFF_TEAM_PORT;
1123d7d3c051SJiri Pirko return 0;
1124d7d3c051SJiri Pirko }
1125d7d3c051SJiri Pirko
team_upper_dev_unlink(struct team * team,struct team_port * port)11268fd72856SJiri Pirko static void team_upper_dev_unlink(struct team *team, struct team_port *port)
1127d7d3c051SJiri Pirko {
11288fd72856SJiri Pirko netdev_upper_dev_unlink(port->dev, team->dev);
11298fd72856SJiri Pirko port->dev->priv_flags &= ~IFF_TEAM_PORT;
1130d7d3c051SJiri Pirko }
1131d7d3c051SJiri Pirko
113210f3f51dSJiri Pirko static void __team_port_change_port_added(struct team_port *port, bool linkup);
11331d76efe1SJiri Pirko static int team_dev_type_check_change(struct net_device *dev,
11341d76efe1SJiri Pirko struct net_device *port_dev);
11353d249d4cSJiri Pirko
team_port_add(struct team * team,struct net_device * port_dev,struct netlink_ext_ack * extack)113644d15d93SIdo Schimmel static int team_port_add(struct team *team, struct net_device *port_dev,
113744d15d93SIdo Schimmel struct netlink_ext_ack *extack)
11383d249d4cSJiri Pirko {
11393d249d4cSJiri Pirko struct net_device *dev = team->dev;
11403d249d4cSJiri Pirko struct team_port *port;
11413d249d4cSJiri Pirko char *portname = port_dev->name;
11423d249d4cSJiri Pirko int err;
11433d249d4cSJiri Pirko
11441d76efe1SJiri Pirko if (port_dev->flags & IFF_LOOPBACK) {
114544d15d93SIdo Schimmel NL_SET_ERR_MSG(extack, "Loopback device can't be added as a team port");
11461d76efe1SJiri Pirko netdev_err(dev, "Device %s is loopback device. Loopback devices can't be added as a team port\n",
11473d249d4cSJiri Pirko portname);
11483d249d4cSJiri Pirko return -EINVAL;
11493d249d4cSJiri Pirko }
11503d249d4cSJiri Pirko
1151acb10eacSJulian Wiedmann if (netif_is_team_port(port_dev)) {
115244d15d93SIdo Schimmel NL_SET_ERR_MSG(extack, "Device is already a port of a team device");
11533d249d4cSJiri Pirko netdev_err(dev, "Device %s is already a port "
11543d249d4cSJiri Pirko "of a team device\n", portname);
11553d249d4cSJiri Pirko return -EBUSY;
11563d249d4cSJiri Pirko }
11573d249d4cSJiri Pirko
1158471b83bdSIdo Schimmel if (dev == port_dev) {
1159471b83bdSIdo Schimmel NL_SET_ERR_MSG(extack, "Cannot enslave team device to itself");
1160471b83bdSIdo Schimmel netdev_err(dev, "Cannot enslave team device to itself\n");
1161471b83bdSIdo Schimmel return -EINVAL;
1162471b83bdSIdo Schimmel }
1163471b83bdSIdo Schimmel
1164925b0c84SHangbin Liu if (netdev_has_upper_dev(dev, port_dev)) {
1165925b0c84SHangbin Liu NL_SET_ERR_MSG(extack, "Device is already an upper device of the team interface");
1166925b0c84SHangbin Liu netdev_err(dev, "Device %s is already an upper device of the team interface\n",
1167925b0c84SHangbin Liu portname);
1168925b0c84SHangbin Liu return -EBUSY;
1169925b0c84SHangbin Liu }
1170925b0c84SHangbin Liu
11712c33bb37SJiri Pirko if (port_dev->features & NETIF_F_VLAN_CHALLENGED &&
11722c33bb37SJiri Pirko vlan_uses_dev(dev)) {
117344d15d93SIdo Schimmel NL_SET_ERR_MSG(extack, "Device is VLAN challenged and team device has VLAN set up");
11742c33bb37SJiri Pirko netdev_err(dev, "Device %s is VLAN challenged and team device has VLAN set up\n",
11752c33bb37SJiri Pirko portname);
11762c33bb37SJiri Pirko return -EPERM;
11772c33bb37SJiri Pirko }
11782c33bb37SJiri Pirko
11791d76efe1SJiri Pirko err = team_dev_type_check_change(dev, port_dev);
11801d76efe1SJiri Pirko if (err)
11811d76efe1SJiri Pirko return err;
11821d76efe1SJiri Pirko
11833d249d4cSJiri Pirko if (port_dev->flags & IFF_UP) {
118444d15d93SIdo Schimmel NL_SET_ERR_MSG(extack, "Device is up. Set it down before adding it as a team port");
11853d249d4cSJiri Pirko netdev_err(dev, "Device %s is up. Set it down before adding it as a team port\n",
11863d249d4cSJiri Pirko portname);
11873d249d4cSJiri Pirko return -EBUSY;
11883d249d4cSJiri Pirko }
11893d249d4cSJiri Pirko
11905149ee58SJiri Pirko port = kzalloc(sizeof(struct team_port) + team->mode->port_priv_size,
11915149ee58SJiri Pirko GFP_KERNEL);
11923d249d4cSJiri Pirko if (!port)
11933d249d4cSJiri Pirko return -ENOMEM;
11943d249d4cSJiri Pirko
11953d249d4cSJiri Pirko port->dev = port_dev;
11963d249d4cSJiri Pirko port->team = team;
11978ff5105aSJiri Pirko INIT_LIST_HEAD(&port->qom_list);
11983d249d4cSJiri Pirko
11993d249d4cSJiri Pirko port->orig.mtu = port_dev->mtu;
12003d249d4cSJiri Pirko err = dev_set_mtu(port_dev, dev->mtu);
12013d249d4cSJiri Pirko if (err) {
12023d249d4cSJiri Pirko netdev_dbg(dev, "Error %d calling dev_set_mtu\n", err);
12033d249d4cSJiri Pirko goto err_set_mtu;
12043d249d4cSJiri Pirko }
12053d249d4cSJiri Pirko
12061d76efe1SJiri Pirko memcpy(port->orig.dev_addr, port_dev->dev_addr, port_dev->addr_len);
12073d249d4cSJiri Pirko
12083d249d4cSJiri Pirko err = team_port_enter(team, port);
12093d249d4cSJiri Pirko if (err) {
12103d249d4cSJiri Pirko netdev_err(dev, "Device %s failed to enter team mode\n",
12113d249d4cSJiri Pirko portname);
12123d249d4cSJiri Pirko goto err_port_enter;
12133d249d4cSJiri Pirko }
12143d249d4cSJiri Pirko
121500f54e68SPetr Machata err = dev_open(port_dev, extack);
12163d249d4cSJiri Pirko if (err) {
12173d249d4cSJiri Pirko netdev_dbg(dev, "Device %s opening failed\n",
12183d249d4cSJiri Pirko portname);
12193d249d4cSJiri Pirko goto err_dev_open;
12203d249d4cSJiri Pirko }
12213d249d4cSJiri Pirko
122257459185SJiri Pirko err = vlan_vids_add_by_dev(port_dev, dev);
122357459185SJiri Pirko if (err) {
122457459185SJiri Pirko netdev_err(dev, "Failed to add vlan ids to device %s\n",
122557459185SJiri Pirko portname);
122657459185SJiri Pirko goto err_vids_add;
122757459185SJiri Pirko }
122857459185SJiri Pirko
12299cf2f437SXin Long err = team_port_enable_netpoll(port);
1230bd2d0837SJiri Pirko if (err) {
1231bd2d0837SJiri Pirko netdev_err(dev, "Failed to enable netpoll on device %s\n",
1232bd2d0837SJiri Pirko portname);
1233bd2d0837SJiri Pirko goto err_enable_netpoll;
1234bd2d0837SJiri Pirko }
1235bd2d0837SJiri Pirko
1236fbe168baSMichal Kubeček if (!(dev->features & NETIF_F_LRO))
1237fbe168baSMichal Kubeček dev_disable_lro(port_dev);
1238fbe168baSMichal Kubeček
12393d249d4cSJiri Pirko err = netdev_rx_handler_register(port_dev, team_handle_frame,
12403d249d4cSJiri Pirko port);
12413d249d4cSJiri Pirko if (err) {
12423d249d4cSJiri Pirko netdev_err(dev, "Device %s failed to register rx_handler\n",
12433d249d4cSJiri Pirko portname);
12443d249d4cSJiri Pirko goto err_handler_register;
12453d249d4cSJiri Pirko }
12463d249d4cSJiri Pirko
124744d15d93SIdo Schimmel err = team_upper_dev_link(team, port, extack);
1248d7d3c051SJiri Pirko if (err) {
1249d7d3c051SJiri Pirko netdev_err(dev, "Device %s failed to set upper link\n",
1250d7d3c051SJiri Pirko portname);
1251d7d3c051SJiri Pirko goto err_set_upper_link;
1252d7d3c051SJiri Pirko }
1253d7d3c051SJiri Pirko
125435b384bdSJiri Pirko err = __team_option_inst_add_port(team, port);
125580f7c668SJiri Pirko if (err) {
125680f7c668SJiri Pirko netdev_err(dev, "Device %s failed to add per-port options\n",
125780f7c668SJiri Pirko portname);
125880f7c668SJiri Pirko goto err_option_port_add;
125980f7c668SJiri Pirko }
126080f7c668SJiri Pirko
126143c2adb9SHangbin Liu /* set promiscuity level to new slave */
126243c2adb9SHangbin Liu if (dev->flags & IFF_PROMISC) {
126343c2adb9SHangbin Liu err = dev_set_promiscuity(port_dev, 1);
126443c2adb9SHangbin Liu if (err)
126543c2adb9SHangbin Liu goto err_set_slave_promisc;
126643c2adb9SHangbin Liu }
126743c2adb9SHangbin Liu
126843c2adb9SHangbin Liu /* set allmulti level to new slave */
126943c2adb9SHangbin Liu if (dev->flags & IFF_ALLMULTI) {
127043c2adb9SHangbin Liu err = dev_set_allmulti(port_dev, 1);
127143c2adb9SHangbin Liu if (err) {
127243c2adb9SHangbin Liu if (dev->flags & IFF_PROMISC)
127343c2adb9SHangbin Liu dev_set_promiscuity(port_dev, -1);
127443c2adb9SHangbin Liu goto err_set_slave_promisc;
127543c2adb9SHangbin Liu }
127643c2adb9SHangbin Liu }
127743c2adb9SHangbin Liu
1278bd602342SBenjamin Poirier if (dev->flags & IFF_UP) {
1279982cf3b3SXin Long netif_addr_lock_bh(dev);
1280982cf3b3SXin Long dev_uc_sync_multiple(port_dev, dev);
1281982cf3b3SXin Long dev_mc_sync_multiple(port_dev, dev);
1282982cf3b3SXin Long netif_addr_unlock_bh(dev);
1283bd602342SBenjamin Poirier }
1284982cf3b3SXin Long
128519a0b58eSJiri Pirko port->index = -1;
128619a0b58eSJiri Pirko list_add_tail_rcu(&port->list, &team->port_list);
128772df935dSJiri Pirko team_port_enable(team, port);
12883d249d4cSJiri Pirko __team_compute_features(team);
12898c7a7726SGeorge Wilkie __team_port_change_port_added(port, !!netif_oper_up(port_dev));
129035b384bdSJiri Pirko __team_options_change_check(team);
12913d249d4cSJiri Pirko
12923d249d4cSJiri Pirko netdev_info(dev, "Port device %s added\n", portname);
12933d249d4cSJiri Pirko
12943d249d4cSJiri Pirko return 0;
12953d249d4cSJiri Pirko
129643c2adb9SHangbin Liu err_set_slave_promisc:
129743c2adb9SHangbin Liu __team_option_inst_del_port(team, port);
129843c2adb9SHangbin Liu
129980f7c668SJiri Pirko err_option_port_add:
13008fd72856SJiri Pirko team_upper_dev_unlink(team, port);
1301d7d3c051SJiri Pirko
1302d7d3c051SJiri Pirko err_set_upper_link:
130380f7c668SJiri Pirko netdev_rx_handler_unregister(port_dev);
130480f7c668SJiri Pirko
13053d249d4cSJiri Pirko err_handler_register:
1306bd2d0837SJiri Pirko team_port_disable_netpoll(port);
1307bd2d0837SJiri Pirko
1308bd2d0837SJiri Pirko err_enable_netpoll:
130957459185SJiri Pirko vlan_vids_del_by_dev(port_dev, dev);
131057459185SJiri Pirko
131157459185SJiri Pirko err_vids_add:
13123d249d4cSJiri Pirko dev_close(port_dev);
13133d249d4cSJiri Pirko
13143d249d4cSJiri Pirko err_dev_open:
13153d249d4cSJiri Pirko team_port_leave(team, port);
13161d76efe1SJiri Pirko team_port_set_orig_dev_addr(port);
13173d249d4cSJiri Pirko
13183d249d4cSJiri Pirko err_port_enter:
13193d249d4cSJiri Pirko dev_set_mtu(port_dev, port->orig.mtu);
13203d249d4cSJiri Pirko
13213d249d4cSJiri Pirko err_set_mtu:
13223d249d4cSJiri Pirko kfree(port);
13233d249d4cSJiri Pirko
13243d249d4cSJiri Pirko return err;
13253d249d4cSJiri Pirko }
13263d249d4cSJiri Pirko
132710f3f51dSJiri Pirko static void __team_port_change_port_removed(struct team_port *port);
132810f3f51dSJiri Pirko
team_port_del(struct team * team,struct net_device * port_dev)13293d249d4cSJiri Pirko static int team_port_del(struct team *team, struct net_device *port_dev)
13303d249d4cSJiri Pirko {
13313d249d4cSJiri Pirko struct net_device *dev = team->dev;
13323d249d4cSJiri Pirko struct team_port *port;
13333d249d4cSJiri Pirko char *portname = port_dev->name;
13343d249d4cSJiri Pirko
13353d249d4cSJiri Pirko port = team_port_get_rtnl(port_dev);
13363d249d4cSJiri Pirko if (!port || !team_port_find(team, port)) {
13373d249d4cSJiri Pirko netdev_err(dev, "Device %s does not act as a port of this team\n",
13383d249d4cSJiri Pirko portname);
13393d249d4cSJiri Pirko return -ENOENT;
13403d249d4cSJiri Pirko }
13413d249d4cSJiri Pirko
134219a0b58eSJiri Pirko team_port_disable(team, port);
134319a0b58eSJiri Pirko list_del_rcu(&port->list);
134443c2adb9SHangbin Liu
134543c2adb9SHangbin Liu if (dev->flags & IFF_PROMISC)
134643c2adb9SHangbin Liu dev_set_promiscuity(port_dev, -1);
134743c2adb9SHangbin Liu if (dev->flags & IFF_ALLMULTI)
134843c2adb9SHangbin Liu dev_set_allmulti(port_dev, -1);
134943c2adb9SHangbin Liu
13508fd72856SJiri Pirko team_upper_dev_unlink(team, port);
13513d249d4cSJiri Pirko netdev_rx_handler_unregister(port_dev);
1352bd2d0837SJiri Pirko team_port_disable_netpoll(port);
135357459185SJiri Pirko vlan_vids_del_by_dev(port_dev, dev);
1354bd602342SBenjamin Poirier if (dev->flags & IFF_UP) {
1355ba81276bSVlad Yasevich dev_uc_unsync(port_dev, dev);
1356ba81276bSVlad Yasevich dev_mc_unsync(port_dev, dev);
1357bd602342SBenjamin Poirier }
13583d249d4cSJiri Pirko dev_close(port_dev);
13593d249d4cSJiri Pirko team_port_leave(team, port);
1360c3969d80SJiri Pirko
1361c3969d80SJiri Pirko __team_option_inst_mark_removed_port(team, port);
1362c3969d80SJiri Pirko __team_options_change_check(team);
1363c3969d80SJiri Pirko __team_option_inst_del_port(team, port);
1364c3969d80SJiri Pirko __team_port_change_port_removed(port);
1365c3969d80SJiri Pirko
13661d76efe1SJiri Pirko team_port_set_orig_dev_addr(port);
13673d249d4cSJiri Pirko dev_set_mtu(port_dev, port->orig.mtu);
1368d80b35beSJiri Pirko kfree_rcu(port, rcu);
13693d249d4cSJiri Pirko netdev_info(dev, "Port device %s removed\n", portname);
13703d249d4cSJiri Pirko __team_compute_features(team);
13713d249d4cSJiri Pirko
13723d249d4cSJiri Pirko return 0;
13733d249d4cSJiri Pirko }
13743d249d4cSJiri Pirko
13753d249d4cSJiri Pirko
13763d249d4cSJiri Pirko /*****************
13773d249d4cSJiri Pirko * Net device ops
13783d249d4cSJiri Pirko *****************/
13793d249d4cSJiri Pirko
team_mode_option_get(struct team * team,struct team_gsetter_ctx * ctx)1380c3b41f4cSZhengchao Shao static void team_mode_option_get(struct team *team, struct team_gsetter_ctx *ctx)
13813d249d4cSJiri Pirko {
1382d299cd51SJiri Pirko ctx->data.str_val = team->mode->kind;
13833d249d4cSJiri Pirko }
13843d249d4cSJiri Pirko
team_mode_option_set(struct team * team,struct team_gsetter_ctx * ctx)138580f7c668SJiri Pirko static int team_mode_option_set(struct team *team, struct team_gsetter_ctx *ctx)
13863d249d4cSJiri Pirko {
138780f7c668SJiri Pirko return team_change_mode(team, ctx->data.str_val);
13883d249d4cSJiri Pirko }
13893d249d4cSJiri Pirko
team_notify_peers_count_get(struct team * team,struct team_gsetter_ctx * ctx)1390c3b41f4cSZhengchao Shao static void team_notify_peers_count_get(struct team *team,
1391fc423ff0SJiri Pirko struct team_gsetter_ctx *ctx)
1392fc423ff0SJiri Pirko {
1393fc423ff0SJiri Pirko ctx->data.u32_val = team->notify_peers.count;
1394fc423ff0SJiri Pirko }
1395fc423ff0SJiri Pirko
team_notify_peers_count_set(struct team * team,struct team_gsetter_ctx * ctx)1396fc423ff0SJiri Pirko static int team_notify_peers_count_set(struct team *team,
1397fc423ff0SJiri Pirko struct team_gsetter_ctx *ctx)
1398fc423ff0SJiri Pirko {
1399fc423ff0SJiri Pirko team->notify_peers.count = ctx->data.u32_val;
1400fc423ff0SJiri Pirko return 0;
1401fc423ff0SJiri Pirko }
1402fc423ff0SJiri Pirko
team_notify_peers_interval_get(struct team * team,struct team_gsetter_ctx * ctx)1403c3b41f4cSZhengchao Shao static void team_notify_peers_interval_get(struct team *team,
1404fc423ff0SJiri Pirko struct team_gsetter_ctx *ctx)
1405fc423ff0SJiri Pirko {
1406fc423ff0SJiri Pirko ctx->data.u32_val = team->notify_peers.interval;
1407fc423ff0SJiri Pirko }
1408fc423ff0SJiri Pirko
team_notify_peers_interval_set(struct team * team,struct team_gsetter_ctx * ctx)1409fc423ff0SJiri Pirko static int team_notify_peers_interval_set(struct team *team,
1410fc423ff0SJiri Pirko struct team_gsetter_ctx *ctx)
1411fc423ff0SJiri Pirko {
1412fc423ff0SJiri Pirko team->notify_peers.interval = ctx->data.u32_val;
1413fc423ff0SJiri Pirko return 0;
1414fc423ff0SJiri Pirko }
1415fc423ff0SJiri Pirko
team_mcast_rejoin_count_get(struct team * team,struct team_gsetter_ctx * ctx)1416c3b41f4cSZhengchao Shao static void team_mcast_rejoin_count_get(struct team *team,
1417492b200eSJiri Pirko struct team_gsetter_ctx *ctx)
1418492b200eSJiri Pirko {
1419492b200eSJiri Pirko ctx->data.u32_val = team->mcast_rejoin.count;
1420492b200eSJiri Pirko }
1421492b200eSJiri Pirko
team_mcast_rejoin_count_set(struct team * team,struct team_gsetter_ctx * ctx)1422492b200eSJiri Pirko static int team_mcast_rejoin_count_set(struct team *team,
1423492b200eSJiri Pirko struct team_gsetter_ctx *ctx)
1424492b200eSJiri Pirko {
1425492b200eSJiri Pirko team->mcast_rejoin.count = ctx->data.u32_val;
1426492b200eSJiri Pirko return 0;
1427492b200eSJiri Pirko }
1428492b200eSJiri Pirko
team_mcast_rejoin_interval_get(struct team * team,struct team_gsetter_ctx * ctx)1429c3b41f4cSZhengchao Shao static void team_mcast_rejoin_interval_get(struct team *team,
1430492b200eSJiri Pirko struct team_gsetter_ctx *ctx)
1431492b200eSJiri Pirko {
1432492b200eSJiri Pirko ctx->data.u32_val = team->mcast_rejoin.interval;
1433492b200eSJiri Pirko }
1434492b200eSJiri Pirko
team_mcast_rejoin_interval_set(struct team * team,struct team_gsetter_ctx * ctx)1435492b200eSJiri Pirko static int team_mcast_rejoin_interval_set(struct team *team,
1436492b200eSJiri Pirko struct team_gsetter_ctx *ctx)
1437492b200eSJiri Pirko {
1438492b200eSJiri Pirko team->mcast_rejoin.interval = ctx->data.u32_val;
1439492b200eSJiri Pirko return 0;
1440492b200eSJiri Pirko }
1441492b200eSJiri Pirko
team_port_en_option_get(struct team * team,struct team_gsetter_ctx * ctx)1442c3b41f4cSZhengchao Shao static void team_port_en_option_get(struct team *team,
1443acd69962SJiri Pirko struct team_gsetter_ctx *ctx)
1444acd69962SJiri Pirko {
144585d59a87SJiri Pirko struct team_port *port = ctx->info->port;
144685d59a87SJiri Pirko
144785d59a87SJiri Pirko ctx->data.bool_val = team_port_enabled(port);
1448acd69962SJiri Pirko }
1449acd69962SJiri Pirko
team_port_en_option_set(struct team * team,struct team_gsetter_ctx * ctx)1450acd69962SJiri Pirko static int team_port_en_option_set(struct team *team,
1451acd69962SJiri Pirko struct team_gsetter_ctx *ctx)
1452acd69962SJiri Pirko {
145385d59a87SJiri Pirko struct team_port *port = ctx->info->port;
145485d59a87SJiri Pirko
1455acd69962SJiri Pirko if (ctx->data.bool_val)
145685d59a87SJiri Pirko team_port_enable(team, port);
1457acd69962SJiri Pirko else
145885d59a87SJiri Pirko team_port_disable(team, port);
1459acd69962SJiri Pirko return 0;
1460acd69962SJiri Pirko }
1461acd69962SJiri Pirko
team_user_linkup_option_get(struct team * team,struct team_gsetter_ctx * ctx)1462c3b41f4cSZhengchao Shao static void team_user_linkup_option_get(struct team *team,
146371472ec1SJiri Pirko struct team_gsetter_ctx *ctx)
146471472ec1SJiri Pirko {
146585d59a87SJiri Pirko struct team_port *port = ctx->info->port;
146685d59a87SJiri Pirko
146785d59a87SJiri Pirko ctx->data.bool_val = port->user.linkup;
146871472ec1SJiri Pirko }
146971472ec1SJiri Pirko
1470f5e0d343SJiri Pirko static void __team_carrier_check(struct team *team);
1471f5e0d343SJiri Pirko
team_user_linkup_option_set(struct team * team,struct team_gsetter_ctx * ctx)147271472ec1SJiri Pirko static int team_user_linkup_option_set(struct team *team,
147371472ec1SJiri Pirko struct team_gsetter_ctx *ctx)
147471472ec1SJiri Pirko {
147585d59a87SJiri Pirko struct team_port *port = ctx->info->port;
147685d59a87SJiri Pirko
147785d59a87SJiri Pirko port->user.linkup = ctx->data.bool_val;
147885d59a87SJiri Pirko team_refresh_port_linkup(port);
1479f5e0d343SJiri Pirko __team_carrier_check(port->team);
148071472ec1SJiri Pirko return 0;
148171472ec1SJiri Pirko }
148271472ec1SJiri Pirko
team_user_linkup_en_option_get(struct team * team,struct team_gsetter_ctx * ctx)1483c3b41f4cSZhengchao Shao static void team_user_linkup_en_option_get(struct team *team,
148471472ec1SJiri Pirko struct team_gsetter_ctx *ctx)
148571472ec1SJiri Pirko {
148685d59a87SJiri Pirko struct team_port *port = ctx->info->port;
148771472ec1SJiri Pirko
148871472ec1SJiri Pirko ctx->data.bool_val = port->user.linkup_enabled;
148971472ec1SJiri Pirko }
149071472ec1SJiri Pirko
team_user_linkup_en_option_set(struct team * team,struct team_gsetter_ctx * ctx)149171472ec1SJiri Pirko static int team_user_linkup_en_option_set(struct team *team,
149271472ec1SJiri Pirko struct team_gsetter_ctx *ctx)
149371472ec1SJiri Pirko {
149485d59a87SJiri Pirko struct team_port *port = ctx->info->port;
149571472ec1SJiri Pirko
149671472ec1SJiri Pirko port->user.linkup_enabled = ctx->data.bool_val;
149785d59a87SJiri Pirko team_refresh_port_linkup(port);
1498f5e0d343SJiri Pirko __team_carrier_check(port->team);
149971472ec1SJiri Pirko return 0;
150071472ec1SJiri Pirko }
150171472ec1SJiri Pirko
team_priority_option_get(struct team * team,struct team_gsetter_ctx * ctx)1502c3b41f4cSZhengchao Shao static void team_priority_option_get(struct team *team,
1503a86fc6b7SJiri Pirko struct team_gsetter_ctx *ctx)
1504a86fc6b7SJiri Pirko {
1505a86fc6b7SJiri Pirko struct team_port *port = ctx->info->port;
1506a86fc6b7SJiri Pirko
1507a86fc6b7SJiri Pirko ctx->data.s32_val = port->priority;
1508a86fc6b7SJiri Pirko }
1509a86fc6b7SJiri Pirko
team_priority_option_set(struct team * team,struct team_gsetter_ctx * ctx)1510a86fc6b7SJiri Pirko static int team_priority_option_set(struct team *team,
1511a86fc6b7SJiri Pirko struct team_gsetter_ctx *ctx)
1512a86fc6b7SJiri Pirko {
1513a86fc6b7SJiri Pirko struct team_port *port = ctx->info->port;
15146c31ff36SJiri Pirko s32 priority = ctx->data.s32_val;
1515a86fc6b7SJiri Pirko
15166c31ff36SJiri Pirko if (port->priority == priority)
15176c31ff36SJiri Pirko return 0;
15186c31ff36SJiri Pirko port->priority = priority;
15196c31ff36SJiri Pirko team_queue_override_port_prio_changed(team, port);
1520a86fc6b7SJiri Pirko return 0;
1521a86fc6b7SJiri Pirko }
1522a86fc6b7SJiri Pirko
team_queue_id_option_get(struct team * team,struct team_gsetter_ctx * ctx)1523c3b41f4cSZhengchao Shao static void team_queue_id_option_get(struct team *team,
15248ff5105aSJiri Pirko struct team_gsetter_ctx *ctx)
15258ff5105aSJiri Pirko {
15268ff5105aSJiri Pirko struct team_port *port = ctx->info->port;
15278ff5105aSJiri Pirko
15288ff5105aSJiri Pirko ctx->data.u32_val = port->queue_id;
15298ff5105aSJiri Pirko }
15308ff5105aSJiri Pirko
team_queue_id_option_set(struct team * team,struct team_gsetter_ctx * ctx)15318ff5105aSJiri Pirko static int team_queue_id_option_set(struct team *team,
15328ff5105aSJiri Pirko struct team_gsetter_ctx *ctx)
15338ff5105aSJiri Pirko {
15348ff5105aSJiri Pirko struct team_port *port = ctx->info->port;
15356c31ff36SJiri Pirko u16 new_queue_id = ctx->data.u32_val;
15368ff5105aSJiri Pirko
15376c31ff36SJiri Pirko if (port->queue_id == new_queue_id)
15388ff5105aSJiri Pirko return 0;
15396c31ff36SJiri Pirko if (new_queue_id >= team->dev->real_num_tx_queues)
15408ff5105aSJiri Pirko return -EINVAL;
15416c31ff36SJiri Pirko team_queue_override_port_change_queue_id(team, port, new_queue_id);
15428ff5105aSJiri Pirko return 0;
15438ff5105aSJiri Pirko }
15448ff5105aSJiri Pirko
1545358b8382SJiri Pirko static const struct team_option team_options[] = {
15463d249d4cSJiri Pirko {
15473d249d4cSJiri Pirko .name = "mode",
15483d249d4cSJiri Pirko .type = TEAM_OPTION_TYPE_STRING,
15493d249d4cSJiri Pirko .getter = team_mode_option_get,
15503d249d4cSJiri Pirko .setter = team_mode_option_set,
15513d249d4cSJiri Pirko },
155271472ec1SJiri Pirko {
1553fc423ff0SJiri Pirko .name = "notify_peers_count",
1554fc423ff0SJiri Pirko .type = TEAM_OPTION_TYPE_U32,
1555fc423ff0SJiri Pirko .getter = team_notify_peers_count_get,
1556fc423ff0SJiri Pirko .setter = team_notify_peers_count_set,
1557fc423ff0SJiri Pirko },
1558fc423ff0SJiri Pirko {
1559fc423ff0SJiri Pirko .name = "notify_peers_interval",
1560fc423ff0SJiri Pirko .type = TEAM_OPTION_TYPE_U32,
1561fc423ff0SJiri Pirko .getter = team_notify_peers_interval_get,
1562fc423ff0SJiri Pirko .setter = team_notify_peers_interval_set,
1563fc423ff0SJiri Pirko },
1564fc423ff0SJiri Pirko {
1565492b200eSJiri Pirko .name = "mcast_rejoin_count",
1566492b200eSJiri Pirko .type = TEAM_OPTION_TYPE_U32,
1567492b200eSJiri Pirko .getter = team_mcast_rejoin_count_get,
1568492b200eSJiri Pirko .setter = team_mcast_rejoin_count_set,
1569492b200eSJiri Pirko },
1570492b200eSJiri Pirko {
1571492b200eSJiri Pirko .name = "mcast_rejoin_interval",
1572492b200eSJiri Pirko .type = TEAM_OPTION_TYPE_U32,
1573492b200eSJiri Pirko .getter = team_mcast_rejoin_interval_get,
1574492b200eSJiri Pirko .setter = team_mcast_rejoin_interval_set,
1575492b200eSJiri Pirko },
1576492b200eSJiri Pirko {
1577acd69962SJiri Pirko .name = "enabled",
1578acd69962SJiri Pirko .type = TEAM_OPTION_TYPE_BOOL,
1579acd69962SJiri Pirko .per_port = true,
1580acd69962SJiri Pirko .getter = team_port_en_option_get,
1581acd69962SJiri Pirko .setter = team_port_en_option_set,
1582acd69962SJiri Pirko },
1583acd69962SJiri Pirko {
158471472ec1SJiri Pirko .name = "user_linkup",
158571472ec1SJiri Pirko .type = TEAM_OPTION_TYPE_BOOL,
158671472ec1SJiri Pirko .per_port = true,
158771472ec1SJiri Pirko .getter = team_user_linkup_option_get,
158871472ec1SJiri Pirko .setter = team_user_linkup_option_set,
158971472ec1SJiri Pirko },
159071472ec1SJiri Pirko {
159171472ec1SJiri Pirko .name = "user_linkup_enabled",
159271472ec1SJiri Pirko .type = TEAM_OPTION_TYPE_BOOL,
159371472ec1SJiri Pirko .per_port = true,
159471472ec1SJiri Pirko .getter = team_user_linkup_en_option_get,
159571472ec1SJiri Pirko .setter = team_user_linkup_en_option_set,
159671472ec1SJiri Pirko },
1597a86fc6b7SJiri Pirko {
1598a86fc6b7SJiri Pirko .name = "priority",
1599a86fc6b7SJiri Pirko .type = TEAM_OPTION_TYPE_S32,
1600a86fc6b7SJiri Pirko .per_port = true,
1601a86fc6b7SJiri Pirko .getter = team_priority_option_get,
1602a86fc6b7SJiri Pirko .setter = team_priority_option_set,
1603a86fc6b7SJiri Pirko },
16048ff5105aSJiri Pirko {
16058ff5105aSJiri Pirko .name = "queue_id",
16068ff5105aSJiri Pirko .type = TEAM_OPTION_TYPE_U32,
16078ff5105aSJiri Pirko .per_port = true,
16088ff5105aSJiri Pirko .getter = team_queue_id_option_get,
16098ff5105aSJiri Pirko .setter = team_queue_id_option_set,
16108ff5105aSJiri Pirko },
16113d249d4cSJiri Pirko };
16123d249d4cSJiri Pirko
16136c85f2bdSJiri Pirko
team_init(struct net_device * dev)16143d249d4cSJiri Pirko static int team_init(struct net_device *dev)
16153d249d4cSJiri Pirko {
16163d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
16173d249d4cSJiri Pirko int i;
1618358b8382SJiri Pirko int err;
16193d249d4cSJiri Pirko
16203d249d4cSJiri Pirko team->dev = dev;
1621d299cd51SJiri Pirko team_set_no_mode(team);
1622ae9b15fbSTaehee Yoo team->notifier_ctx = false;
16233d249d4cSJiri Pirko
16241c213bd2SWANG Cong team->pcpu_stats = netdev_alloc_pcpu_stats(struct team_pcpu_stats);
16253d249d4cSJiri Pirko if (!team->pcpu_stats)
16263d249d4cSJiri Pirko return -ENOMEM;
16273d249d4cSJiri Pirko
16283d249d4cSJiri Pirko for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
162919a0b58eSJiri Pirko INIT_HLIST_HEAD(&team->en_port_hlist[i]);
16303d249d4cSJiri Pirko INIT_LIST_HEAD(&team->port_list);
16318ff5105aSJiri Pirko err = team_queue_override_init(team);
16328ff5105aSJiri Pirko if (err)
16338ff5105aSJiri Pirko goto err_team_queue_override_init;
16343d249d4cSJiri Pirko
16353d249d4cSJiri Pirko team_adjust_ops(team);
16363d249d4cSJiri Pirko
16373d249d4cSJiri Pirko INIT_LIST_HEAD(&team->option_list);
163880f7c668SJiri Pirko INIT_LIST_HEAD(&team->option_inst_list);
1639fc423ff0SJiri Pirko
1640fc423ff0SJiri Pirko team_notify_peers_init(team);
1641492b200eSJiri Pirko team_mcast_rejoin_init(team);
1642fc423ff0SJiri Pirko
1643358b8382SJiri Pirko err = team_options_register(team, team_options, ARRAY_SIZE(team_options));
1644358b8382SJiri Pirko if (err)
1645358b8382SJiri Pirko goto err_options_register;
16463d249d4cSJiri Pirko netif_carrier_off(dev);
16473d249d4cSJiri Pirko
1648369f61beSTaehee Yoo lockdep_register_key(&team->team_lock_key);
1649369f61beSTaehee Yoo __mutex_init(&team->lock, "team->team_lock_key", &team->team_lock_key);
16501a33e10eSCong Wang netdev_lockdep_set_classes(dev);
16516c85f2bdSJiri Pirko
16523d249d4cSJiri Pirko return 0;
1653358b8382SJiri Pirko
1654358b8382SJiri Pirko err_options_register:
1655492b200eSJiri Pirko team_mcast_rejoin_fini(team);
1656fc423ff0SJiri Pirko team_notify_peers_fini(team);
16578ff5105aSJiri Pirko team_queue_override_fini(team);
16588ff5105aSJiri Pirko err_team_queue_override_init:
1659358b8382SJiri Pirko free_percpu(team->pcpu_stats);
1660358b8382SJiri Pirko
1661358b8382SJiri Pirko return err;
16623d249d4cSJiri Pirko }
16633d249d4cSJiri Pirko
team_uninit(struct net_device * dev)16643d249d4cSJiri Pirko static void team_uninit(struct net_device *dev)
16653d249d4cSJiri Pirko {
16663d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
16673d249d4cSJiri Pirko struct team_port *port;
16683d249d4cSJiri Pirko struct team_port *tmp;
16693d249d4cSJiri Pirko
167061dc3461SJiri Pirko mutex_lock(&team->lock);
16713d249d4cSJiri Pirko list_for_each_entry_safe(port, tmp, &team->port_list, list)
16723d249d4cSJiri Pirko team_port_del(team, port->dev);
16733d249d4cSJiri Pirko
16743d249d4cSJiri Pirko __team_change_mode(team, NULL); /* cleanup */
16753d249d4cSJiri Pirko __team_options_unregister(team, team_options, ARRAY_SIZE(team_options));
1676492b200eSJiri Pirko team_mcast_rejoin_fini(team);
1677fc423ff0SJiri Pirko team_notify_peers_fini(team);
16788ff5105aSJiri Pirko team_queue_override_fini(team);
167961dc3461SJiri Pirko mutex_unlock(&team->lock);
168016cf72bbSXin Long netdev_change_features(dev);
1681369f61beSTaehee Yoo lockdep_unregister_key(&team->team_lock_key);
16823d249d4cSJiri Pirko }
16833d249d4cSJiri Pirko
team_destructor(struct net_device * dev)16843d249d4cSJiri Pirko static void team_destructor(struct net_device *dev)
16853d249d4cSJiri Pirko {
16863d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
16873d249d4cSJiri Pirko
16883d249d4cSJiri Pirko free_percpu(team->pcpu_stats);
16893d249d4cSJiri Pirko }
16903d249d4cSJiri Pirko
team_open(struct net_device * dev)16913d249d4cSJiri Pirko static int team_open(struct net_device *dev)
16923d249d4cSJiri Pirko {
16933d249d4cSJiri Pirko return 0;
16943d249d4cSJiri Pirko }
16953d249d4cSJiri Pirko
team_close(struct net_device * dev)16963d249d4cSJiri Pirko static int team_close(struct net_device *dev)
16973d249d4cSJiri Pirko {
1698bd602342SBenjamin Poirier struct team *team = netdev_priv(dev);
1699bd602342SBenjamin Poirier struct team_port *port;
1700bd602342SBenjamin Poirier
1701bd602342SBenjamin Poirier list_for_each_entry(port, &team->port_list, list) {
1702bd602342SBenjamin Poirier dev_uc_unsync(port->dev, dev);
1703bd602342SBenjamin Poirier dev_mc_unsync(port->dev, dev);
1704bd602342SBenjamin Poirier }
1705bd602342SBenjamin Poirier
17063d249d4cSJiri Pirko return 0;
17073d249d4cSJiri Pirko }
17083d249d4cSJiri Pirko
17093d249d4cSJiri Pirko /*
17103d249d4cSJiri Pirko * note: already called with rcu_read_lock
17113d249d4cSJiri Pirko */
team_xmit(struct sk_buff * skb,struct net_device * dev)17123d249d4cSJiri Pirko static netdev_tx_t team_xmit(struct sk_buff *skb, struct net_device *dev)
17133d249d4cSJiri Pirko {
17143d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
17158ff5105aSJiri Pirko bool tx_success;
17163d249d4cSJiri Pirko unsigned int len = skb->len;
17173d249d4cSJiri Pirko
17188ff5105aSJiri Pirko tx_success = team_queue_override_transmit(team, skb);
17198ff5105aSJiri Pirko if (!tx_success)
17203d249d4cSJiri Pirko tx_success = team->ops.transmit(team, skb);
17213d249d4cSJiri Pirko if (tx_success) {
17223d249d4cSJiri Pirko struct team_pcpu_stats *pcpu_stats;
17233d249d4cSJiri Pirko
17243d249d4cSJiri Pirko pcpu_stats = this_cpu_ptr(team->pcpu_stats);
17253d249d4cSJiri Pirko u64_stats_update_begin(&pcpu_stats->syncp);
17269ec321abSEric Dumazet u64_stats_inc(&pcpu_stats->tx_packets);
17279ec321abSEric Dumazet u64_stats_add(&pcpu_stats->tx_bytes, len);
17283d249d4cSJiri Pirko u64_stats_update_end(&pcpu_stats->syncp);
17293d249d4cSJiri Pirko } else {
17303d249d4cSJiri Pirko this_cpu_inc(team->pcpu_stats->tx_dropped);
17313d249d4cSJiri Pirko }
17323d249d4cSJiri Pirko
17333d249d4cSJiri Pirko return NETDEV_TX_OK;
17343d249d4cSJiri Pirko }
17353d249d4cSJiri Pirko
team_select_queue(struct net_device * dev,struct sk_buff * skb,struct net_device * sb_dev)1736f663dd9aSJason Wang static u16 team_select_queue(struct net_device *dev, struct sk_buff *skb,
1737a350ecceSPaolo Abeni struct net_device *sb_dev)
17386c85f2bdSJiri Pirko {
17396c85f2bdSJiri Pirko /*
17406c85f2bdSJiri Pirko * This helper function exists to help dev_pick_tx get the correct
17416c85f2bdSJiri Pirko * destination queue. Using a helper function skips a call to
17426c85f2bdSJiri Pirko * skb_tx_hash and will put the skbs in the queue we expect on their
17436c85f2bdSJiri Pirko * way down to the team driver.
17446c85f2bdSJiri Pirko */
17456c85f2bdSJiri Pirko u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
17466c85f2bdSJiri Pirko
17476c85f2bdSJiri Pirko /*
17486c85f2bdSJiri Pirko * Save the original txq to restore before passing to the driver
17496c85f2bdSJiri Pirko */
17506c85f2bdSJiri Pirko qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
17516c85f2bdSJiri Pirko
17526c85f2bdSJiri Pirko if (unlikely(txq >= dev->real_num_tx_queues)) {
17536c85f2bdSJiri Pirko do {
17546c85f2bdSJiri Pirko txq -= dev->real_num_tx_queues;
17556c85f2bdSJiri Pirko } while (txq >= dev->real_num_tx_queues);
17566c85f2bdSJiri Pirko }
17576c85f2bdSJiri Pirko return txq;
17586c85f2bdSJiri Pirko }
17596c85f2bdSJiri Pirko
team_change_rx_flags(struct net_device * dev,int change)17603d249d4cSJiri Pirko static void team_change_rx_flags(struct net_device *dev, int change)
17613d249d4cSJiri Pirko {
17623d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
17633d249d4cSJiri Pirko struct team_port *port;
17643d249d4cSJiri Pirko int inc;
17653d249d4cSJiri Pirko
17663d249d4cSJiri Pirko rcu_read_lock();
17673d249d4cSJiri Pirko list_for_each_entry_rcu(port, &team->port_list, list) {
17683d249d4cSJiri Pirko if (change & IFF_PROMISC) {
17693d249d4cSJiri Pirko inc = dev->flags & IFF_PROMISC ? 1 : -1;
17703d249d4cSJiri Pirko dev_set_promiscuity(port->dev, inc);
17713d249d4cSJiri Pirko }
17723d249d4cSJiri Pirko if (change & IFF_ALLMULTI) {
17733d249d4cSJiri Pirko inc = dev->flags & IFF_ALLMULTI ? 1 : -1;
17743d249d4cSJiri Pirko dev_set_allmulti(port->dev, inc);
17753d249d4cSJiri Pirko }
17763d249d4cSJiri Pirko }
17773d249d4cSJiri Pirko rcu_read_unlock();
17783d249d4cSJiri Pirko }
17793d249d4cSJiri Pirko
team_set_rx_mode(struct net_device * dev)17803d249d4cSJiri Pirko static void team_set_rx_mode(struct net_device *dev)
17813d249d4cSJiri Pirko {
17823d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
17833d249d4cSJiri Pirko struct team_port *port;
17843d249d4cSJiri Pirko
17853d249d4cSJiri Pirko rcu_read_lock();
17863d249d4cSJiri Pirko list_for_each_entry_rcu(port, &team->port_list, list) {
178772b27032SVlad Yasevich dev_uc_sync_multiple(port->dev, dev);
178872b27032SVlad Yasevich dev_mc_sync_multiple(port->dev, dev);
17893d249d4cSJiri Pirko }
17903d249d4cSJiri Pirko rcu_read_unlock();
17913d249d4cSJiri Pirko }
17923d249d4cSJiri Pirko
team_set_mac_address(struct net_device * dev,void * p)17933d249d4cSJiri Pirko static int team_set_mac_address(struct net_device *dev, void *p)
17943d249d4cSJiri Pirko {
17951d76efe1SJiri Pirko struct sockaddr *addr = p;
17963d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
17973d249d4cSJiri Pirko struct team_port *port;
17983d249d4cSJiri Pirko
17991d76efe1SJiri Pirko if (dev->type == ARPHRD_ETHER && !is_valid_ether_addr(addr->sa_data))
18001d76efe1SJiri Pirko return -EADDRNOTAVAIL;
1801ea52a0b5SJakub Kicinski dev_addr_set(dev, addr->sa_data);
18029215f437SJiri Pirko mutex_lock(&team->lock);
18039215f437SJiri Pirko list_for_each_entry(port, &team->port_list, list)
18041d76efe1SJiri Pirko if (team->ops.port_change_dev_addr)
18051d76efe1SJiri Pirko team->ops.port_change_dev_addr(team, port);
18069215f437SJiri Pirko mutex_unlock(&team->lock);
18073d249d4cSJiri Pirko return 0;
18083d249d4cSJiri Pirko }
18093d249d4cSJiri Pirko
team_change_mtu(struct net_device * dev,int new_mtu)18103d249d4cSJiri Pirko static int team_change_mtu(struct net_device *dev, int new_mtu)
18113d249d4cSJiri Pirko {
18123d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
18133d249d4cSJiri Pirko struct team_port *port;
18143d249d4cSJiri Pirko int err;
18153d249d4cSJiri Pirko
18163d249d4cSJiri Pirko /*
18173d249d4cSJiri Pirko * Alhough this is reader, it's guarded by team lock. It's not possible
18183d249d4cSJiri Pirko * to traverse list in reverse under rcu_read_lock
18193d249d4cSJiri Pirko */
182061dc3461SJiri Pirko mutex_lock(&team->lock);
18219d0d68faSJiri Pirko team->port_mtu_change_allowed = true;
18223d249d4cSJiri Pirko list_for_each_entry(port, &team->port_list, list) {
18233d249d4cSJiri Pirko err = dev_set_mtu(port->dev, new_mtu);
18243d249d4cSJiri Pirko if (err) {
18253d249d4cSJiri Pirko netdev_err(dev, "Device %s failed to change mtu",
18263d249d4cSJiri Pirko port->dev->name);
18273d249d4cSJiri Pirko goto unwind;
18283d249d4cSJiri Pirko }
18293d249d4cSJiri Pirko }
18309d0d68faSJiri Pirko team->port_mtu_change_allowed = false;
183161dc3461SJiri Pirko mutex_unlock(&team->lock);
18323d249d4cSJiri Pirko
18333d249d4cSJiri Pirko dev->mtu = new_mtu;
18343d249d4cSJiri Pirko
18353d249d4cSJiri Pirko return 0;
18363d249d4cSJiri Pirko
18373d249d4cSJiri Pirko unwind:
18383d249d4cSJiri Pirko list_for_each_entry_continue_reverse(port, &team->port_list, list)
18393d249d4cSJiri Pirko dev_set_mtu(port->dev, dev->mtu);
18409d0d68faSJiri Pirko team->port_mtu_change_allowed = false;
184161dc3461SJiri Pirko mutex_unlock(&team->lock);
18423d249d4cSJiri Pirko
18433d249d4cSJiri Pirko return err;
18443d249d4cSJiri Pirko }
18453d249d4cSJiri Pirko
1846bc1f4470Sstephen hemminger static void
team_get_stats64(struct net_device * dev,struct rtnl_link_stats64 * stats)18473d249d4cSJiri Pirko team_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
18483d249d4cSJiri Pirko {
18493d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
18503d249d4cSJiri Pirko struct team_pcpu_stats *p;
18513d249d4cSJiri Pirko u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes;
1852bb63daf9SJarod Wilson u32 rx_dropped = 0, tx_dropped = 0, rx_nohandler = 0;
18533d249d4cSJiri Pirko unsigned int start;
18543d249d4cSJiri Pirko int i;
18553d249d4cSJiri Pirko
18563d249d4cSJiri Pirko for_each_possible_cpu(i) {
18573d249d4cSJiri Pirko p = per_cpu_ptr(team->pcpu_stats, i);
18583d249d4cSJiri Pirko do {
1859068c38adSThomas Gleixner start = u64_stats_fetch_begin(&p->syncp);
18609ec321abSEric Dumazet rx_packets = u64_stats_read(&p->rx_packets);
18619ec321abSEric Dumazet rx_bytes = u64_stats_read(&p->rx_bytes);
18629ec321abSEric Dumazet rx_multicast = u64_stats_read(&p->rx_multicast);
18639ec321abSEric Dumazet tx_packets = u64_stats_read(&p->tx_packets);
18649ec321abSEric Dumazet tx_bytes = u64_stats_read(&p->tx_bytes);
1865068c38adSThomas Gleixner } while (u64_stats_fetch_retry(&p->syncp, start));
18663d249d4cSJiri Pirko
18673d249d4cSJiri Pirko stats->rx_packets += rx_packets;
18683d249d4cSJiri Pirko stats->rx_bytes += rx_bytes;
18693d249d4cSJiri Pirko stats->multicast += rx_multicast;
18703d249d4cSJiri Pirko stats->tx_packets += tx_packets;
18713d249d4cSJiri Pirko stats->tx_bytes += tx_bytes;
18723d249d4cSJiri Pirko /*
1873bb63daf9SJarod Wilson * rx_dropped, tx_dropped & rx_nohandler are u32,
1874bb63daf9SJarod Wilson * updated without syncp protection.
18753d249d4cSJiri Pirko */
18769ec321abSEric Dumazet rx_dropped += READ_ONCE(p->rx_dropped);
18779ec321abSEric Dumazet tx_dropped += READ_ONCE(p->tx_dropped);
18789ec321abSEric Dumazet rx_nohandler += READ_ONCE(p->rx_nohandler);
18793d249d4cSJiri Pirko }
18803d249d4cSJiri Pirko stats->rx_dropped = rx_dropped;
18813d249d4cSJiri Pirko stats->tx_dropped = tx_dropped;
1882bb63daf9SJarod Wilson stats->rx_nohandler = rx_nohandler;
18833d249d4cSJiri Pirko }
18843d249d4cSJiri Pirko
team_vlan_rx_add_vid(struct net_device * dev,__be16 proto,u16 vid)188580d5c368SPatrick McHardy static int team_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid)
18863d249d4cSJiri Pirko {
18873d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
18883d249d4cSJiri Pirko struct team_port *port;
188987002b03SJiri Pirko int err;
18903d249d4cSJiri Pirko
189187002b03SJiri Pirko /*
189287002b03SJiri Pirko * Alhough this is reader, it's guarded by team lock. It's not possible
189387002b03SJiri Pirko * to traverse list in reverse under rcu_read_lock
189487002b03SJiri Pirko */
189587002b03SJiri Pirko mutex_lock(&team->lock);
189687002b03SJiri Pirko list_for_each_entry(port, &team->port_list, list) {
189780d5c368SPatrick McHardy err = vlan_vid_add(port->dev, proto, vid);
189887002b03SJiri Pirko if (err)
189987002b03SJiri Pirko goto unwind;
19003d249d4cSJiri Pirko }
190187002b03SJiri Pirko mutex_unlock(&team->lock);
19028e586137SJiri Pirko
19038e586137SJiri Pirko return 0;
190487002b03SJiri Pirko
190587002b03SJiri Pirko unwind:
190687002b03SJiri Pirko list_for_each_entry_continue_reverse(port, &team->port_list, list)
190780d5c368SPatrick McHardy vlan_vid_del(port->dev, proto, vid);
190887002b03SJiri Pirko mutex_unlock(&team->lock);
190987002b03SJiri Pirko
191087002b03SJiri Pirko return err;
19113d249d4cSJiri Pirko }
19123d249d4cSJiri Pirko
team_vlan_rx_kill_vid(struct net_device * dev,__be16 proto,u16 vid)191380d5c368SPatrick McHardy static int team_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid)
19143d249d4cSJiri Pirko {
19153d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
19163d249d4cSJiri Pirko struct team_port *port;
19173d249d4cSJiri Pirko
191860a6531bSIdo Schimmel mutex_lock(&team->lock);
191960a6531bSIdo Schimmel list_for_each_entry(port, &team->port_list, list)
192080d5c368SPatrick McHardy vlan_vid_del(port->dev, proto, vid);
192160a6531bSIdo Schimmel mutex_unlock(&team->lock);
19228e586137SJiri Pirko
19238e586137SJiri Pirko return 0;
19243d249d4cSJiri Pirko }
19253d249d4cSJiri Pirko
1926bd2d0837SJiri Pirko #ifdef CONFIG_NET_POLL_CONTROLLER
team_poll_controller(struct net_device * dev)1927bd2d0837SJiri Pirko static void team_poll_controller(struct net_device *dev)
1928bd2d0837SJiri Pirko {
1929bd2d0837SJiri Pirko }
1930bd2d0837SJiri Pirko
__team_netpoll_cleanup(struct team * team)1931bd2d0837SJiri Pirko static void __team_netpoll_cleanup(struct team *team)
1932bd2d0837SJiri Pirko {
1933bd2d0837SJiri Pirko struct team_port *port;
1934bd2d0837SJiri Pirko
1935bd2d0837SJiri Pirko list_for_each_entry(port, &team->port_list, list)
1936bd2d0837SJiri Pirko team_port_disable_netpoll(port);
1937bd2d0837SJiri Pirko }
1938bd2d0837SJiri Pirko
team_netpoll_cleanup(struct net_device * dev)1939bd2d0837SJiri Pirko static void team_netpoll_cleanup(struct net_device *dev)
1940bd2d0837SJiri Pirko {
1941bd2d0837SJiri Pirko struct team *team = netdev_priv(dev);
1942bd2d0837SJiri Pirko
1943bd2d0837SJiri Pirko mutex_lock(&team->lock);
1944bd2d0837SJiri Pirko __team_netpoll_cleanup(team);
1945bd2d0837SJiri Pirko mutex_unlock(&team->lock);
1946bd2d0837SJiri Pirko }
1947bd2d0837SJiri Pirko
team_netpoll_setup(struct net_device * dev,struct netpoll_info * npifo)1948bd2d0837SJiri Pirko static int team_netpoll_setup(struct net_device *dev,
1949a8779ec1SEric W. Biederman struct netpoll_info *npifo)
1950bd2d0837SJiri Pirko {
1951bd2d0837SJiri Pirko struct team *team = netdev_priv(dev);
1952bd2d0837SJiri Pirko struct team_port *port;
19533324d024SJiri Pirko int err = 0;
1954bd2d0837SJiri Pirko
1955bd2d0837SJiri Pirko mutex_lock(&team->lock);
1956bd2d0837SJiri Pirko list_for_each_entry(port, &team->port_list, list) {
19579cf2f437SXin Long err = __team_port_enable_netpoll(port);
1958bd2d0837SJiri Pirko if (err) {
1959bd2d0837SJiri Pirko __team_netpoll_cleanup(team);
1960bd2d0837SJiri Pirko break;
1961bd2d0837SJiri Pirko }
1962bd2d0837SJiri Pirko }
1963bd2d0837SJiri Pirko mutex_unlock(&team->lock);
1964bd2d0837SJiri Pirko return err;
1965bd2d0837SJiri Pirko }
1966bd2d0837SJiri Pirko #endif
1967bd2d0837SJiri Pirko
team_add_slave(struct net_device * dev,struct net_device * port_dev,struct netlink_ext_ack * extack)196833eaf2a6SDavid Ahern static int team_add_slave(struct net_device *dev, struct net_device *port_dev,
196933eaf2a6SDavid Ahern struct netlink_ext_ack *extack)
19703d249d4cSJiri Pirko {
19713d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
19723d249d4cSJiri Pirko int err;
19733d249d4cSJiri Pirko
197461dc3461SJiri Pirko mutex_lock(&team->lock);
197544d15d93SIdo Schimmel err = team_port_add(team, port_dev, extack);
197661dc3461SJiri Pirko mutex_unlock(&team->lock);
197716cf72bbSXin Long
197816cf72bbSXin Long if (!err)
197916cf72bbSXin Long netdev_change_features(dev);
198016cf72bbSXin Long
19813d249d4cSJiri Pirko return err;
19823d249d4cSJiri Pirko }
19833d249d4cSJiri Pirko
team_del_slave(struct net_device * dev,struct net_device * port_dev)19843d249d4cSJiri Pirko static int team_del_slave(struct net_device *dev, struct net_device *port_dev)
19853d249d4cSJiri Pirko {
19863d249d4cSJiri Pirko struct team *team = netdev_priv(dev);
19873d249d4cSJiri Pirko int err;
19883d249d4cSJiri Pirko
198961dc3461SJiri Pirko mutex_lock(&team->lock);
19903d249d4cSJiri Pirko err = team_port_del(team, port_dev);
199161dc3461SJiri Pirko mutex_unlock(&team->lock);
199216cf72bbSXin Long
1993369f61beSTaehee Yoo if (err)
1994369f61beSTaehee Yoo return err;
1995369f61beSTaehee Yoo
1996369f61beSTaehee Yoo if (netif_is_team_master(port_dev)) {
1997369f61beSTaehee Yoo lockdep_unregister_key(&team->team_lock_key);
1998369f61beSTaehee Yoo lockdep_register_key(&team->team_lock_key);
1999369f61beSTaehee Yoo lockdep_set_class(&team->lock, &team->team_lock_key);
2000369f61beSTaehee Yoo }
200116cf72bbSXin Long netdev_change_features(dev);
200216cf72bbSXin Long
20033d249d4cSJiri Pirko return err;
20043d249d4cSJiri Pirko }
20053d249d4cSJiri Pirko
team_fix_features(struct net_device * dev,netdev_features_t features)2006234a8fd4SJiri Pirko static netdev_features_t team_fix_features(struct net_device *dev,
2007234a8fd4SJiri Pirko netdev_features_t features)
2008234a8fd4SJiri Pirko {
2009234a8fd4SJiri Pirko struct team_port *port;
2010234a8fd4SJiri Pirko struct team *team = netdev_priv(dev);
2011234a8fd4SJiri Pirko netdev_features_t mask;
2012234a8fd4SJiri Pirko
20137889cbeeSScott Feldman mask = features;
2014234a8fd4SJiri Pirko features &= ~NETIF_F_ONE_FOR_ALL;
2015234a8fd4SJiri Pirko features |= NETIF_F_ALL_FOR_ALL;
2016234a8fd4SJiri Pirko
2017234a8fd4SJiri Pirko rcu_read_lock();
2018234a8fd4SJiri Pirko list_for_each_entry_rcu(port, &team->port_list, list) {
2019234a8fd4SJiri Pirko features = netdev_increment_features(features,
2020234a8fd4SJiri Pirko port->dev->features,
2021234a8fd4SJiri Pirko mask);
2022234a8fd4SJiri Pirko }
2023234a8fd4SJiri Pirko rcu_read_unlock();
2024247f6d0fSJiri Pirko
2025247f6d0fSJiri Pirko features = netdev_add_tso_features(features, mask);
2026247f6d0fSJiri Pirko
2027234a8fd4SJiri Pirko return features;
2028234a8fd4SJiri Pirko }
2029234a8fd4SJiri Pirko
team_change_carrier(struct net_device * dev,bool new_carrier)20304cafe373SFlavio Leitner static int team_change_carrier(struct net_device *dev, bool new_carrier)
20314cafe373SFlavio Leitner {
2032e185483eSFlavio Leitner struct team *team = netdev_priv(dev);
2033e185483eSFlavio Leitner
2034e185483eSFlavio Leitner team->user_carrier_enabled = true;
2035e185483eSFlavio Leitner
20364cafe373SFlavio Leitner if (new_carrier)
20374cafe373SFlavio Leitner netif_carrier_on(dev);
20384cafe373SFlavio Leitner else
20394cafe373SFlavio Leitner netif_carrier_off(dev);
20404cafe373SFlavio Leitner return 0;
20414cafe373SFlavio Leitner }
20424cafe373SFlavio Leitner
20433d249d4cSJiri Pirko static const struct net_device_ops team_netdev_ops = {
20443d249d4cSJiri Pirko .ndo_init = team_init,
20453d249d4cSJiri Pirko .ndo_uninit = team_uninit,
20463d249d4cSJiri Pirko .ndo_open = team_open,
20473d249d4cSJiri Pirko .ndo_stop = team_close,
20483d249d4cSJiri Pirko .ndo_start_xmit = team_xmit,
20496c85f2bdSJiri Pirko .ndo_select_queue = team_select_queue,
20503d249d4cSJiri Pirko .ndo_change_rx_flags = team_change_rx_flags,
20513d249d4cSJiri Pirko .ndo_set_rx_mode = team_set_rx_mode,
20523d249d4cSJiri Pirko .ndo_set_mac_address = team_set_mac_address,
20533d249d4cSJiri Pirko .ndo_change_mtu = team_change_mtu,
20543d249d4cSJiri Pirko .ndo_get_stats64 = team_get_stats64,
20553d249d4cSJiri Pirko .ndo_vlan_rx_add_vid = team_vlan_rx_add_vid,
20563d249d4cSJiri Pirko .ndo_vlan_rx_kill_vid = team_vlan_rx_kill_vid,
2057bd2d0837SJiri Pirko #ifdef CONFIG_NET_POLL_CONTROLLER
2058bd2d0837SJiri Pirko .ndo_poll_controller = team_poll_controller,
2059bd2d0837SJiri Pirko .ndo_netpoll_setup = team_netpoll_setup,
2060bd2d0837SJiri Pirko .ndo_netpoll_cleanup = team_netpoll_cleanup,
2061bd2d0837SJiri Pirko #endif
20623d249d4cSJiri Pirko .ndo_add_slave = team_add_slave,
20633d249d4cSJiri Pirko .ndo_del_slave = team_del_slave,
2064234a8fd4SJiri Pirko .ndo_fix_features = team_fix_features,
20654cafe373SFlavio Leitner .ndo_change_carrier = team_change_carrier,
2066b9f4cf75SToshiaki Makita .ndo_features_check = passthru_features_check,
20673d249d4cSJiri Pirko };
20683d249d4cSJiri Pirko
20697f51c587SFlavio Leitner /***********************
20707f51c587SFlavio Leitner * ethtool interface
20717f51c587SFlavio Leitner ***********************/
20727f51c587SFlavio Leitner
team_ethtool_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * drvinfo)20737f51c587SFlavio Leitner static void team_ethtool_get_drvinfo(struct net_device *dev,
20747f51c587SFlavio Leitner struct ethtool_drvinfo *drvinfo)
20757f51c587SFlavio Leitner {
2076fb3ceec1SWolfram Sang strscpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
2077fb3ceec1SWolfram Sang strscpy(drvinfo->version, UTS_RELEASE, sizeof(drvinfo->version));
20787f51c587SFlavio Leitner }
20797f51c587SFlavio Leitner
team_ethtool_get_link_ksettings(struct net_device * dev,struct ethtool_link_ksettings * cmd)20809ed68ca0SHangbin Liu static int team_ethtool_get_link_ksettings(struct net_device *dev,
20819ed68ca0SHangbin Liu struct ethtool_link_ksettings *cmd)
20829ed68ca0SHangbin Liu {
20839ed68ca0SHangbin Liu struct team *team= netdev_priv(dev);
20849ed68ca0SHangbin Liu unsigned long speed = 0;
20859ed68ca0SHangbin Liu struct team_port *port;
20869ed68ca0SHangbin Liu
20879ed68ca0SHangbin Liu cmd->base.duplex = DUPLEX_UNKNOWN;
20889ed68ca0SHangbin Liu cmd->base.port = PORT_OTHER;
20899ed68ca0SHangbin Liu
2090c17e26ddSHangbin Liu rcu_read_lock();
2091c17e26ddSHangbin Liu list_for_each_entry_rcu(port, &team->port_list, list) {
20929ed68ca0SHangbin Liu if (team_port_txable(port)) {
20939ed68ca0SHangbin Liu if (port->state.speed != SPEED_UNKNOWN)
20949ed68ca0SHangbin Liu speed += port->state.speed;
20959ed68ca0SHangbin Liu if (cmd->base.duplex == DUPLEX_UNKNOWN &&
20969ed68ca0SHangbin Liu port->state.duplex != DUPLEX_UNKNOWN)
20979ed68ca0SHangbin Liu cmd->base.duplex = port->state.duplex;
20989ed68ca0SHangbin Liu }
20999ed68ca0SHangbin Liu }
2100c17e26ddSHangbin Liu rcu_read_unlock();
2101c17e26ddSHangbin Liu
21029ed68ca0SHangbin Liu cmd->base.speed = speed ? : SPEED_UNKNOWN;
21039ed68ca0SHangbin Liu
21049ed68ca0SHangbin Liu return 0;
21059ed68ca0SHangbin Liu }
21069ed68ca0SHangbin Liu
21077f51c587SFlavio Leitner static const struct ethtool_ops team_ethtool_ops = {
21087f51c587SFlavio Leitner .get_drvinfo = team_ethtool_get_drvinfo,
21097f51c587SFlavio Leitner .get_link = ethtool_op_get_link,
21109ed68ca0SHangbin Liu .get_link_ksettings = team_ethtool_get_link_ksettings,
21117f51c587SFlavio Leitner };
21123d249d4cSJiri Pirko
21133d249d4cSJiri Pirko /***********************
21143d249d4cSJiri Pirko * rt netlink interface
21153d249d4cSJiri Pirko ***********************/
21163d249d4cSJiri Pirko
team_setup_by_port(struct net_device * dev,struct net_device * port_dev)21171d76efe1SJiri Pirko static void team_setup_by_port(struct net_device *dev,
21181d76efe1SJiri Pirko struct net_device *port_dev)
21191d76efe1SJiri Pirko {
212049203276SZiyang Xuan struct team *team = netdev_priv(dev);
212149203276SZiyang Xuan
212249203276SZiyang Xuan if (port_dev->type == ARPHRD_ETHER)
212349203276SZiyang Xuan dev->header_ops = team->header_ops_cache;
212449203276SZiyang Xuan else
21251d76efe1SJiri Pirko dev->header_ops = port_dev->header_ops;
21261d76efe1SJiri Pirko dev->type = port_dev->type;
21271d76efe1SJiri Pirko dev->hard_header_len = port_dev->hard_header_len;
212889d01748SEric Dumazet dev->needed_headroom = port_dev->needed_headroom;
21291d76efe1SJiri Pirko dev->addr_len = port_dev->addr_len;
21301d76efe1SJiri Pirko dev->mtu = port_dev->mtu;
21311d76efe1SJiri Pirko memcpy(dev->broadcast, port_dev->broadcast, port_dev->addr_len);
213293af7357SBjørn Mork eth_hw_addr_inherit(dev, port_dev);
2133fa532beeSHangbin Liu
2134fa532beeSHangbin Liu if (port_dev->flags & IFF_POINTOPOINT) {
2135fa532beeSHangbin Liu dev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST);
2136fa532beeSHangbin Liu dev->flags |= (IFF_POINTOPOINT | IFF_NOARP);
2137fa532beeSHangbin Liu } else if ((port_dev->flags & (IFF_BROADCAST | IFF_MULTICAST)) ==
2138fa532beeSHangbin Liu (IFF_BROADCAST | IFF_MULTICAST)) {
2139fa532beeSHangbin Liu dev->flags |= (IFF_BROADCAST | IFF_MULTICAST);
2140fa532beeSHangbin Liu dev->flags &= ~(IFF_POINTOPOINT | IFF_NOARP);
2141fa532beeSHangbin Liu }
21421d76efe1SJiri Pirko }
21431d76efe1SJiri Pirko
team_dev_type_check_change(struct net_device * dev,struct net_device * port_dev)21441d76efe1SJiri Pirko static int team_dev_type_check_change(struct net_device *dev,
21451d76efe1SJiri Pirko struct net_device *port_dev)
21461d76efe1SJiri Pirko {
21471d76efe1SJiri Pirko struct team *team = netdev_priv(dev);
21481d76efe1SJiri Pirko char *portname = port_dev->name;
21491d76efe1SJiri Pirko int err;
21501d76efe1SJiri Pirko
21511d76efe1SJiri Pirko if (dev->type == port_dev->type)
21521d76efe1SJiri Pirko return 0;
21531d76efe1SJiri Pirko if (!list_empty(&team->port_list)) {
21541d76efe1SJiri Pirko netdev_err(dev, "Device %s is of different type\n", portname);
21551d76efe1SJiri Pirko return -EBUSY;
21561d76efe1SJiri Pirko }
21571d76efe1SJiri Pirko err = call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE, dev);
21581d76efe1SJiri Pirko err = notifier_to_errno(err);
21591d76efe1SJiri Pirko if (err) {
21601d76efe1SJiri Pirko netdev_err(dev, "Refused to change device type\n");
21611d76efe1SJiri Pirko return err;
21621d76efe1SJiri Pirko }
21631d76efe1SJiri Pirko dev_uc_flush(dev);
21641d76efe1SJiri Pirko dev_mc_flush(dev);
21651d76efe1SJiri Pirko team_setup_by_port(dev, port_dev);
21661d76efe1SJiri Pirko call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, dev);
21671d76efe1SJiri Pirko return 0;
21681d76efe1SJiri Pirko }
21691d76efe1SJiri Pirko
team_setup(struct net_device * dev)21703d249d4cSJiri Pirko static void team_setup(struct net_device *dev)
21713d249d4cSJiri Pirko {
217249203276SZiyang Xuan struct team *team = netdev_priv(dev);
217349203276SZiyang Xuan
21743d249d4cSJiri Pirko ether_setup(dev);
21753331aa37SJarod Wilson dev->max_mtu = ETH_MAX_MTU;
217649203276SZiyang Xuan team->header_ops_cache = dev->header_ops;
21773d249d4cSJiri Pirko
21783d249d4cSJiri Pirko dev->netdev_ops = &team_netdev_ops;
21797f51c587SFlavio Leitner dev->ethtool_ops = &team_ethtool_ops;
2180cf124db5SDavid S. Miller dev->needs_free_netdev = true;
2181cf124db5SDavid S. Miller dev->priv_destructor = team_destructor;
21823d249d4cSJiri Pirko dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
218322e380a6SPhil Sutter dev->priv_flags |= IFF_NO_QUEUE;
2184c981e421SJiri Pirko dev->priv_flags |= IFF_TEAM;
21853d249d4cSJiri Pirko
21863d249d4cSJiri Pirko /*
21873d249d4cSJiri Pirko * Indicate we support unicast address filtering. That way core won't
21883d249d4cSJiri Pirko * bring us to promisc mode in case a unicast addr is added.
21893d249d4cSJiri Pirko * Let this up to underlay drivers.
21903d249d4cSJiri Pirko */
21915a1d1c8cSJiri Pirko dev->priv_flags |= IFF_UNICAST_FLT | IFF_LIVE_ADDR_CHANGE;
21923d249d4cSJiri Pirko
21933d249d4cSJiri Pirko dev->features |= NETIF_F_LLTX;
21943d249d4cSJiri Pirko dev->features |= NETIF_F_GRO;
219599301ba1SWeilong Chen
219699301ba1SWeilong Chen /* Don't allow team devices to change network namespaces. */
219799301ba1SWeilong Chen dev->features |= NETIF_F_NETNS_LOCAL;
219899301ba1SWeilong Chen
21993ed71471SJiri Pirko dev->hw_features = TEAM_VLAN_FEATURES |
2200f646968fSPatrick McHardy NETIF_F_HW_VLAN_CTAG_RX |
2201dafcbce0SZiyang Xuan NETIF_F_HW_VLAN_CTAG_FILTER |
2202dafcbce0SZiyang Xuan NETIF_F_HW_VLAN_STAG_RX |
2203dafcbce0SZiyang Xuan NETIF_F_HW_VLAN_STAG_FILTER;
22043d249d4cSJiri Pirko
2205ecb8fed4SAlexander Lobakin dev->hw_features |= NETIF_F_GSO_ENCAP_ALL;
22063d249d4cSJiri Pirko dev->features |= dev->hw_features;
2207ee429742SYueHaibing dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
22083d249d4cSJiri Pirko }
22093d249d4cSJiri Pirko
team_newlink(struct net * src_net,struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)22103d249d4cSJiri Pirko static int team_newlink(struct net *src_net, struct net_device *dev,
22117a3f4a18SMatthias Schiffer struct nlattr *tb[], struct nlattr *data[],
22127a3f4a18SMatthias Schiffer struct netlink_ext_ack *extack)
22133d249d4cSJiri Pirko {
22143d249d4cSJiri Pirko if (tb[IFLA_ADDRESS] == NULL)
22157ce5d222SDanny Kukawka eth_hw_addr_random(dev);
22163d249d4cSJiri Pirko
2217ff204cceSToshiaki Makita return register_netdevice(dev);
22183d249d4cSJiri Pirko }
22193d249d4cSJiri Pirko
team_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)2220a8b8a889SMatthias Schiffer static int team_validate(struct nlattr *tb[], struct nlattr *data[],
2221a8b8a889SMatthias Schiffer struct netlink_ext_ack *extack)
22223d249d4cSJiri Pirko {
22233d249d4cSJiri Pirko if (tb[IFLA_ADDRESS]) {
22243d249d4cSJiri Pirko if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
22253d249d4cSJiri Pirko return -EINVAL;
22263d249d4cSJiri Pirko if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
22273d249d4cSJiri Pirko return -EADDRNOTAVAIL;
22283d249d4cSJiri Pirko }
22293d249d4cSJiri Pirko return 0;
22303d249d4cSJiri Pirko }
22313d249d4cSJiri Pirko
team_get_num_tx_queues(void)22326c85f2bdSJiri Pirko static unsigned int team_get_num_tx_queues(void)
22336c85f2bdSJiri Pirko {
22346c85f2bdSJiri Pirko return TEAM_DEFAULT_NUM_TX_QUEUES;
22356c85f2bdSJiri Pirko }
22366c85f2bdSJiri Pirko
team_get_num_rx_queues(void)22376c85f2bdSJiri Pirko static unsigned int team_get_num_rx_queues(void)
22386c85f2bdSJiri Pirko {
22396c85f2bdSJiri Pirko return TEAM_DEFAULT_NUM_RX_QUEUES;
22406c85f2bdSJiri Pirko }
22416c85f2bdSJiri Pirko
22423d249d4cSJiri Pirko static struct rtnl_link_ops team_link_ops __read_mostly = {
22433d249d4cSJiri Pirko .kind = DRV_NAME,
22443d249d4cSJiri Pirko .priv_size = sizeof(struct team),
22453d249d4cSJiri Pirko .setup = team_setup,
22463d249d4cSJiri Pirko .newlink = team_newlink,
22473d249d4cSJiri Pirko .validate = team_validate,
22486c85f2bdSJiri Pirko .get_num_tx_queues = team_get_num_tx_queues,
22496c85f2bdSJiri Pirko .get_num_rx_queues = team_get_num_rx_queues,
22503d249d4cSJiri Pirko };
22513d249d4cSJiri Pirko
22523d249d4cSJiri Pirko
22533d249d4cSJiri Pirko /***********************************
22543d249d4cSJiri Pirko * Generic netlink custom interface
22553d249d4cSJiri Pirko ***********************************/
22563d249d4cSJiri Pirko
2257489111e5SJohannes Berg static struct genl_family team_nl_family;
22583d249d4cSJiri Pirko
22593d249d4cSJiri Pirko static const struct nla_policy team_nl_policy[TEAM_ATTR_MAX + 1] = {
22603d249d4cSJiri Pirko [TEAM_ATTR_UNSPEC] = { .type = NLA_UNSPEC, },
22613d249d4cSJiri Pirko [TEAM_ATTR_TEAM_IFINDEX] = { .type = NLA_U32 },
22623d249d4cSJiri Pirko [TEAM_ATTR_LIST_OPTION] = { .type = NLA_NESTED },
22633d249d4cSJiri Pirko [TEAM_ATTR_LIST_PORT] = { .type = NLA_NESTED },
22643d249d4cSJiri Pirko };
22653d249d4cSJiri Pirko
22663d249d4cSJiri Pirko static const struct nla_policy
22673d249d4cSJiri Pirko team_nl_option_policy[TEAM_ATTR_OPTION_MAX + 1] = {
22683d249d4cSJiri Pirko [TEAM_ATTR_OPTION_UNSPEC] = { .type = NLA_UNSPEC, },
22693d249d4cSJiri Pirko [TEAM_ATTR_OPTION_NAME] = {
22703d249d4cSJiri Pirko .type = NLA_STRING,
22713d249d4cSJiri Pirko .len = TEAM_STRING_MAX_LEN,
22723d249d4cSJiri Pirko },
22733d249d4cSJiri Pirko [TEAM_ATTR_OPTION_CHANGED] = { .type = NLA_FLAG },
22743d249d4cSJiri Pirko [TEAM_ATTR_OPTION_TYPE] = { .type = NLA_U8 },
22752615598fSJiri Pirko [TEAM_ATTR_OPTION_DATA] = { .type = NLA_BINARY },
2276dd25cb27SJakub Kicinski [TEAM_ATTR_OPTION_PORT_IFINDEX] = { .type = NLA_U32 },
2277669fcd77SJakub Kicinski [TEAM_ATTR_OPTION_ARRAY_INDEX] = { .type = NLA_U32 },
22783d249d4cSJiri Pirko };
22793d249d4cSJiri Pirko
team_nl_cmd_noop(struct sk_buff * skb,struct genl_info * info)22803d249d4cSJiri Pirko static int team_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
22813d249d4cSJiri Pirko {
22823d249d4cSJiri Pirko struct sk_buff *msg;
22833d249d4cSJiri Pirko void *hdr;
22843d249d4cSJiri Pirko int err;
22853d249d4cSJiri Pirko
228658050fceSThomas Graf msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
22873d249d4cSJiri Pirko if (!msg)
22883d249d4cSJiri Pirko return -ENOMEM;
22893d249d4cSJiri Pirko
229015e47304SEric W. Biederman hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
22913d249d4cSJiri Pirko &team_nl_family, 0, TEAM_CMD_NOOP);
2292a326e6ddSWei Yongjun if (!hdr) {
2293a326e6ddSWei Yongjun err = -EMSGSIZE;
22943d249d4cSJiri Pirko goto err_msg_put;
22953d249d4cSJiri Pirko }
22963d249d4cSJiri Pirko
22973d249d4cSJiri Pirko genlmsg_end(msg, hdr);
22983d249d4cSJiri Pirko
229915e47304SEric W. Biederman return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid);
23003d249d4cSJiri Pirko
23013d249d4cSJiri Pirko err_msg_put:
23023d249d4cSJiri Pirko nlmsg_free(msg);
23033d249d4cSJiri Pirko
23043d249d4cSJiri Pirko return err;
23053d249d4cSJiri Pirko }
23063d249d4cSJiri Pirko
23073d249d4cSJiri Pirko /*
23083d249d4cSJiri Pirko * Netlink cmd functions should be locked by following two functions.
23098c0713a5SJiri Pirko * Since dev gets held here, that ensures dev won't disappear in between.
23103d249d4cSJiri Pirko */
team_nl_team_get(struct genl_info * info)23113d249d4cSJiri Pirko static struct team *team_nl_team_get(struct genl_info *info)
23123d249d4cSJiri Pirko {
23133d249d4cSJiri Pirko struct net *net = genl_info_net(info);
23143d249d4cSJiri Pirko int ifindex;
23153d249d4cSJiri Pirko struct net_device *dev;
23163d249d4cSJiri Pirko struct team *team;
23173d249d4cSJiri Pirko
23183d249d4cSJiri Pirko if (!info->attrs[TEAM_ATTR_TEAM_IFINDEX])
23193d249d4cSJiri Pirko return NULL;
23203d249d4cSJiri Pirko
23213d249d4cSJiri Pirko ifindex = nla_get_u32(info->attrs[TEAM_ATTR_TEAM_IFINDEX]);
23228c0713a5SJiri Pirko dev = dev_get_by_index(net, ifindex);
23233d249d4cSJiri Pirko if (!dev || dev->netdev_ops != &team_netdev_ops) {
23248c0713a5SJiri Pirko dev_put(dev);
23253d249d4cSJiri Pirko return NULL;
23263d249d4cSJiri Pirko }
23273d249d4cSJiri Pirko
23283d249d4cSJiri Pirko team = netdev_priv(dev);
232961dc3461SJiri Pirko mutex_lock(&team->lock);
23303d249d4cSJiri Pirko return team;
23313d249d4cSJiri Pirko }
23323d249d4cSJiri Pirko
team_nl_team_put(struct team * team)23333d249d4cSJiri Pirko static void team_nl_team_put(struct team *team)
23343d249d4cSJiri Pirko {
233561dc3461SJiri Pirko mutex_unlock(&team->lock);
23368c0713a5SJiri Pirko dev_put(team->dev);
23373d249d4cSJiri Pirko }
23383d249d4cSJiri Pirko
23399b00cf2dSJiri Pirko typedef int team_nl_send_func_t(struct sk_buff *skb,
234015e47304SEric W. Biederman struct team *team, u32 portid);
23419b00cf2dSJiri Pirko
team_nl_send_unicast(struct sk_buff * skb,struct team * team,u32 portid)234215e47304SEric W. Biederman static int team_nl_send_unicast(struct sk_buff *skb, struct team *team, u32 portid)
23439b00cf2dSJiri Pirko {
234415e47304SEric W. Biederman return genlmsg_unicast(dev_net(team->dev), skb, portid);
23459b00cf2dSJiri Pirko }
23469b00cf2dSJiri Pirko
team_nl_fill_one_option_get(struct sk_buff * skb,struct team * team,struct team_option_inst * opt_inst)234701048d9aSJiri Pirko static int team_nl_fill_one_option_get(struct sk_buff *skb, struct team *team,
234801048d9aSJiri Pirko struct team_option_inst *opt_inst)
23493d249d4cSJiri Pirko {
23503d249d4cSJiri Pirko struct nlattr *option_item;
235180f7c668SJiri Pirko struct team_option *option = opt_inst->option;
23529b00cf2dSJiri Pirko struct team_option_inst_info *opt_inst_info = &opt_inst->info;
235380f7c668SJiri Pirko struct team_gsetter_ctx ctx;
235401048d9aSJiri Pirko int err;
23553d249d4cSJiri Pirko
23569b00cf2dSJiri Pirko ctx.info = opt_inst_info;
23579b00cf2dSJiri Pirko err = team_option_get(team, opt_inst, &ctx);
23589b00cf2dSJiri Pirko if (err)
23599b00cf2dSJiri Pirko return err;
23609b00cf2dSJiri Pirko
2361ae0be8deSMichal Kubecek option_item = nla_nest_start_noflag(skb, TEAM_ATTR_ITEM_OPTION);
23623d249d4cSJiri Pirko if (!option_item)
23639b00cf2dSJiri Pirko return -EMSGSIZE;
236485d59a87SJiri Pirko
23659b00cf2dSJiri Pirko if (nla_put_string(skb, TEAM_ATTR_OPTION_NAME, option->name))
23669b00cf2dSJiri Pirko goto nest_cancel;
236785d59a87SJiri Pirko if (opt_inst_info->port &&
236880f7c668SJiri Pirko nla_put_u32(skb, TEAM_ATTR_OPTION_PORT_IFINDEX,
236985d59a87SJiri Pirko opt_inst_info->port->dev->ifindex))
23709b00cf2dSJiri Pirko goto nest_cancel;
2371b1303326SJiri Pirko if (opt_inst->option->array_size &&
2372b1303326SJiri Pirko nla_put_u32(skb, TEAM_ATTR_OPTION_ARRAY_INDEX,
237385d59a87SJiri Pirko opt_inst_info->array_index))
23749b00cf2dSJiri Pirko goto nest_cancel;
237585d59a87SJiri Pirko
23763d249d4cSJiri Pirko switch (option->type) {
23773d249d4cSJiri Pirko case TEAM_OPTION_TYPE_U32:
237886ebb02dSDavid S. Miller if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_U32))
23799b00cf2dSJiri Pirko goto nest_cancel;
238001048d9aSJiri Pirko if (nla_put_u32(skb, TEAM_ATTR_OPTION_DATA, ctx.data.u32_val))
23819b00cf2dSJiri Pirko goto nest_cancel;
23823d249d4cSJiri Pirko break;
23833d249d4cSJiri Pirko case TEAM_OPTION_TYPE_STRING:
238486ebb02dSDavid S. Miller if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_STRING))
23859b00cf2dSJiri Pirko goto nest_cancel;
238686ebb02dSDavid S. Miller if (nla_put_string(skb, TEAM_ATTR_OPTION_DATA,
238780f7c668SJiri Pirko ctx.data.str_val))
23889b00cf2dSJiri Pirko goto nest_cancel;
23893d249d4cSJiri Pirko break;
23902615598fSJiri Pirko case TEAM_OPTION_TYPE_BINARY:
23912615598fSJiri Pirko if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_BINARY))
23929b00cf2dSJiri Pirko goto nest_cancel;
239301048d9aSJiri Pirko if (nla_put(skb, TEAM_ATTR_OPTION_DATA, ctx.data.bin_val.len,
239401048d9aSJiri Pirko ctx.data.bin_val.ptr))
23959b00cf2dSJiri Pirko goto nest_cancel;
23962615598fSJiri Pirko break;
239714f066baSJiri Pirko case TEAM_OPTION_TYPE_BOOL:
239814f066baSJiri Pirko if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_FLAG))
23999b00cf2dSJiri Pirko goto nest_cancel;
240014f066baSJiri Pirko if (ctx.data.bool_val &&
240114f066baSJiri Pirko nla_put_flag(skb, TEAM_ATTR_OPTION_DATA))
24029b00cf2dSJiri Pirko goto nest_cancel;
240314f066baSJiri Pirko break;
240469821638SJiri Pirko case TEAM_OPTION_TYPE_S32:
240569821638SJiri Pirko if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_S32))
240669821638SJiri Pirko goto nest_cancel;
240769821638SJiri Pirko if (nla_put_s32(skb, TEAM_ATTR_OPTION_DATA, ctx.data.s32_val))
240869821638SJiri Pirko goto nest_cancel;
240969821638SJiri Pirko break;
24103d249d4cSJiri Pirko default:
24113d249d4cSJiri Pirko BUG();
24123d249d4cSJiri Pirko }
24139b00cf2dSJiri Pirko if (opt_inst->removed && nla_put_flag(skb, TEAM_ATTR_OPTION_REMOVED))
24149b00cf2dSJiri Pirko goto nest_cancel;
24159b00cf2dSJiri Pirko if (opt_inst->changed) {
24169b00cf2dSJiri Pirko if (nla_put_flag(skb, TEAM_ATTR_OPTION_CHANGED))
24179b00cf2dSJiri Pirko goto nest_cancel;
24189b00cf2dSJiri Pirko opt_inst->changed = false;
24199b00cf2dSJiri Pirko }
24203d249d4cSJiri Pirko nla_nest_end(skb, option_item);
242101048d9aSJiri Pirko return 0;
242201048d9aSJiri Pirko
24239b00cf2dSJiri Pirko nest_cancel:
24249b00cf2dSJiri Pirko nla_nest_cancel(skb, option_item);
24259b00cf2dSJiri Pirko return -EMSGSIZE;
242601048d9aSJiri Pirko }
242701048d9aSJiri Pirko
__send_and_alloc_skb(struct sk_buff ** pskb,struct team * team,u32 portid,team_nl_send_func_t * send_func)24289b00cf2dSJiri Pirko static int __send_and_alloc_skb(struct sk_buff **pskb,
242915e47304SEric W. Biederman struct team *team, u32 portid,
24309b00cf2dSJiri Pirko team_nl_send_func_t *send_func)
24319b00cf2dSJiri Pirko {
24329b00cf2dSJiri Pirko int err;
24339b00cf2dSJiri Pirko
24349b00cf2dSJiri Pirko if (*pskb) {
243515e47304SEric W. Biederman err = send_func(*pskb, team, portid);
24369b00cf2dSJiri Pirko if (err)
24379b00cf2dSJiri Pirko return err;
24389b00cf2dSJiri Pirko }
243958050fceSThomas Graf *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
24409b00cf2dSJiri Pirko if (!*pskb)
24419b00cf2dSJiri Pirko return -ENOMEM;
24429b00cf2dSJiri Pirko return 0;
24439b00cf2dSJiri Pirko }
24449b00cf2dSJiri Pirko
team_nl_send_options_get(struct team * team,u32 portid,u32 seq,int flags,team_nl_send_func_t * send_func,struct list_head * sel_opt_inst_list)244515e47304SEric W. Biederman static int team_nl_send_options_get(struct team *team, u32 portid, u32 seq,
24469b00cf2dSJiri Pirko int flags, team_nl_send_func_t *send_func,
244701048d9aSJiri Pirko struct list_head *sel_opt_inst_list)
244801048d9aSJiri Pirko {
244901048d9aSJiri Pirko struct nlattr *option_list;
24509b00cf2dSJiri Pirko struct nlmsghdr *nlh;
245101048d9aSJiri Pirko void *hdr;
245201048d9aSJiri Pirko struct team_option_inst *opt_inst;
245301048d9aSJiri Pirko int err;
24549b00cf2dSJiri Pirko struct sk_buff *skb = NULL;
24559b00cf2dSJiri Pirko bool incomplete;
24569b00cf2dSJiri Pirko int i;
245701048d9aSJiri Pirko
24589b00cf2dSJiri Pirko opt_inst = list_first_entry(sel_opt_inst_list,
24599b00cf2dSJiri Pirko struct team_option_inst, tmp_list);
24609b00cf2dSJiri Pirko
24619b00cf2dSJiri Pirko start_again:
246215e47304SEric W. Biederman err = __send_and_alloc_skb(&skb, team, portid, send_func);
24639b00cf2dSJiri Pirko if (err)
24649b00cf2dSJiri Pirko return err;
24659b00cf2dSJiri Pirko
246615e47304SEric W. Biederman hdr = genlmsg_put(skb, portid, seq, &team_nl_family, flags | NLM_F_MULTI,
246701048d9aSJiri Pirko TEAM_CMD_OPTIONS_GET);
246872ec0bc6SPan Bian if (!hdr) {
246972ec0bc6SPan Bian nlmsg_free(skb);
2470a326e6ddSWei Yongjun return -EMSGSIZE;
247172ec0bc6SPan Bian }
247201048d9aSJiri Pirko
247301048d9aSJiri Pirko if (nla_put_u32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex))
247401048d9aSJiri Pirko goto nla_put_failure;
2475ae0be8deSMichal Kubecek option_list = nla_nest_start_noflag(skb, TEAM_ATTR_LIST_OPTION);
247601048d9aSJiri Pirko if (!option_list)
247701048d9aSJiri Pirko goto nla_put_failure;
247801048d9aSJiri Pirko
24799b00cf2dSJiri Pirko i = 0;
24809b00cf2dSJiri Pirko incomplete = false;
24819b00cf2dSJiri Pirko list_for_each_entry_from(opt_inst, sel_opt_inst_list, tmp_list) {
248201048d9aSJiri Pirko err = team_nl_fill_one_option_get(skb, team, opt_inst);
24839b00cf2dSJiri Pirko if (err) {
24849b00cf2dSJiri Pirko if (err == -EMSGSIZE) {
24859b00cf2dSJiri Pirko if (!i)
248601048d9aSJiri Pirko goto errout;
24879b00cf2dSJiri Pirko incomplete = true;
24889b00cf2dSJiri Pirko break;
24899b00cf2dSJiri Pirko }
24909b00cf2dSJiri Pirko goto errout;
24919b00cf2dSJiri Pirko }
24929b00cf2dSJiri Pirko i++;
24933d249d4cSJiri Pirko }
24943d249d4cSJiri Pirko
24953d249d4cSJiri Pirko nla_nest_end(skb, option_list);
24969b00cf2dSJiri Pirko genlmsg_end(skb, hdr);
24979b00cf2dSJiri Pirko if (incomplete)
24989b00cf2dSJiri Pirko goto start_again;
24999b00cf2dSJiri Pirko
25009b00cf2dSJiri Pirko send_done:
250115e47304SEric W. Biederman nlh = nlmsg_put(skb, portid, seq, NLMSG_DONE, 0, flags | NLM_F_MULTI);
25029b00cf2dSJiri Pirko if (!nlh) {
250315e47304SEric W. Biederman err = __send_and_alloc_skb(&skb, team, portid, send_func);
25049b00cf2dSJiri Pirko if (err)
2505cbcc607eSArkadi Sharshevsky return err;
25069b00cf2dSJiri Pirko goto send_done;
25079b00cf2dSJiri Pirko }
25089b00cf2dSJiri Pirko
250915e47304SEric W. Biederman return send_func(skb, team, portid);
25103d249d4cSJiri Pirko
25113d249d4cSJiri Pirko nla_put_failure:
251280f7c668SJiri Pirko err = -EMSGSIZE;
251380f7c668SJiri Pirko errout:
25149b00cf2dSJiri Pirko nlmsg_free(skb);
251580f7c668SJiri Pirko return err;
25163d249d4cSJiri Pirko }
25173d249d4cSJiri Pirko
team_nl_cmd_options_get(struct sk_buff * skb,struct genl_info * info)25183d249d4cSJiri Pirko static int team_nl_cmd_options_get(struct sk_buff *skb, struct genl_info *info)
25193d249d4cSJiri Pirko {
25203d249d4cSJiri Pirko struct team *team;
25219b00cf2dSJiri Pirko struct team_option_inst *opt_inst;
25223d249d4cSJiri Pirko int err;
25239b00cf2dSJiri Pirko LIST_HEAD(sel_opt_inst_list);
25243d249d4cSJiri Pirko
25253d249d4cSJiri Pirko team = team_nl_team_get(info);
25263d249d4cSJiri Pirko if (!team)
25273d249d4cSJiri Pirko return -EINVAL;
25283d249d4cSJiri Pirko
25299b00cf2dSJiri Pirko list_for_each_entry(opt_inst, &team->option_inst_list, list)
25309b00cf2dSJiri Pirko list_add_tail(&opt_inst->tmp_list, &sel_opt_inst_list);
253115e47304SEric W. Biederman err = team_nl_send_options_get(team, info->snd_portid, info->snd_seq,
25329b00cf2dSJiri Pirko NLM_F_ACK, team_nl_send_unicast,
25339b00cf2dSJiri Pirko &sel_opt_inst_list);
25343d249d4cSJiri Pirko
25353d249d4cSJiri Pirko team_nl_team_put(team);
25363d249d4cSJiri Pirko
25373d249d4cSJiri Pirko return err;
25383d249d4cSJiri Pirko }
25393d249d4cSJiri Pirko
25402fcdb2c9SJiri Pirko static int team_nl_send_event_options_get(struct team *team,
25412fcdb2c9SJiri Pirko struct list_head *sel_opt_inst_list);
25422fcdb2c9SJiri Pirko
team_nl_cmd_options_set(struct sk_buff * skb,struct genl_info * info)25433d249d4cSJiri Pirko static int team_nl_cmd_options_set(struct sk_buff *skb, struct genl_info *info)
25443d249d4cSJiri Pirko {
25453d249d4cSJiri Pirko struct team *team;
25463d249d4cSJiri Pirko int err = 0;
25473d249d4cSJiri Pirko int i;
25483d249d4cSJiri Pirko struct nlattr *nl_option;
25493d249d4cSJiri Pirko
25507d259505SJiri Pirko rtnl_lock();
25517d259505SJiri Pirko
25523d249d4cSJiri Pirko team = team_nl_team_get(info);
25537d259505SJiri Pirko if (!team) {
25547d259505SJiri Pirko err = -EINVAL;
25557d259505SJiri Pirko goto rtnl_unlock;
25567d259505SJiri Pirko }
25573d249d4cSJiri Pirko
25583d249d4cSJiri Pirko err = -EINVAL;
25593d249d4cSJiri Pirko if (!info->attrs[TEAM_ATTR_LIST_OPTION]) {
25603d249d4cSJiri Pirko err = -EINVAL;
25613d249d4cSJiri Pirko goto team_put;
25623d249d4cSJiri Pirko }
25633d249d4cSJiri Pirko
25643d249d4cSJiri Pirko nla_for_each_nested(nl_option, info->attrs[TEAM_ATTR_LIST_OPTION], i) {
256580f7c668SJiri Pirko struct nlattr *opt_attrs[TEAM_ATTR_OPTION_MAX + 1];
2566b1303326SJiri Pirko struct nlattr *attr;
256714f066baSJiri Pirko struct nlattr *attr_data;
25682fdeee25SCong Wang LIST_HEAD(opt_inst_list);
25693d249d4cSJiri Pirko enum team_option_type opt_type;
257080f7c668SJiri Pirko int opt_port_ifindex = 0; /* != 0 for per-port options */
2571b1303326SJiri Pirko u32 opt_array_index = 0;
2572b1303326SJiri Pirko bool opt_is_array = false;
257380f7c668SJiri Pirko struct team_option_inst *opt_inst;
25743d249d4cSJiri Pirko char *opt_name;
25753d249d4cSJiri Pirko bool opt_found = false;
25763d249d4cSJiri Pirko
25773d249d4cSJiri Pirko if (nla_type(nl_option) != TEAM_ATTR_ITEM_OPTION) {
25783d249d4cSJiri Pirko err = -EINVAL;
25793d249d4cSJiri Pirko goto team_put;
25803d249d4cSJiri Pirko }
25818cb08174SJohannes Berg err = nla_parse_nested_deprecated(opt_attrs,
25828cb08174SJohannes Berg TEAM_ATTR_OPTION_MAX,
25838cb08174SJohannes Berg nl_option,
25848cb08174SJohannes Berg team_nl_option_policy,
2585fe52145fSJohannes Berg info->extack);
25863d249d4cSJiri Pirko if (err)
25873d249d4cSJiri Pirko goto team_put;
258880f7c668SJiri Pirko if (!opt_attrs[TEAM_ATTR_OPTION_NAME] ||
258914f066baSJiri Pirko !opt_attrs[TEAM_ATTR_OPTION_TYPE]) {
25903d249d4cSJiri Pirko err = -EINVAL;
25913d249d4cSJiri Pirko goto team_put;
25923d249d4cSJiri Pirko }
259380f7c668SJiri Pirko switch (nla_get_u8(opt_attrs[TEAM_ATTR_OPTION_TYPE])) {
25943d249d4cSJiri Pirko case NLA_U32:
25953d249d4cSJiri Pirko opt_type = TEAM_OPTION_TYPE_U32;
25963d249d4cSJiri Pirko break;
25973d249d4cSJiri Pirko case NLA_STRING:
25983d249d4cSJiri Pirko opt_type = TEAM_OPTION_TYPE_STRING;
25993d249d4cSJiri Pirko break;
26002615598fSJiri Pirko case NLA_BINARY:
26012615598fSJiri Pirko opt_type = TEAM_OPTION_TYPE_BINARY;
26022615598fSJiri Pirko break;
260314f066baSJiri Pirko case NLA_FLAG:
260414f066baSJiri Pirko opt_type = TEAM_OPTION_TYPE_BOOL;
260514f066baSJiri Pirko break;
260669821638SJiri Pirko case NLA_S32:
260769821638SJiri Pirko opt_type = TEAM_OPTION_TYPE_S32;
260869821638SJiri Pirko break;
26093d249d4cSJiri Pirko default:
26103d249d4cSJiri Pirko goto team_put;
26113d249d4cSJiri Pirko }
26123d249d4cSJiri Pirko
261314f066baSJiri Pirko attr_data = opt_attrs[TEAM_ATTR_OPTION_DATA];
261414f066baSJiri Pirko if (opt_type != TEAM_OPTION_TYPE_BOOL && !attr_data) {
261514f066baSJiri Pirko err = -EINVAL;
261614f066baSJiri Pirko goto team_put;
261714f066baSJiri Pirko }
261814f066baSJiri Pirko
261980f7c668SJiri Pirko opt_name = nla_data(opt_attrs[TEAM_ATTR_OPTION_NAME]);
2620b1303326SJiri Pirko attr = opt_attrs[TEAM_ATTR_OPTION_PORT_IFINDEX];
2621b1303326SJiri Pirko if (attr)
2622b1303326SJiri Pirko opt_port_ifindex = nla_get_u32(attr);
2623b1303326SJiri Pirko
2624b1303326SJiri Pirko attr = opt_attrs[TEAM_ATTR_OPTION_ARRAY_INDEX];
2625b1303326SJiri Pirko if (attr) {
2626b1303326SJiri Pirko opt_is_array = true;
2627b1303326SJiri Pirko opt_array_index = nla_get_u32(attr);
2628b1303326SJiri Pirko }
26293d249d4cSJiri Pirko
263080f7c668SJiri Pirko list_for_each_entry(opt_inst, &team->option_inst_list, list) {
263180f7c668SJiri Pirko struct team_option *option = opt_inst->option;
263280f7c668SJiri Pirko struct team_gsetter_ctx ctx;
263385d59a87SJiri Pirko struct team_option_inst_info *opt_inst_info;
263480f7c668SJiri Pirko int tmp_ifindex;
263580f7c668SJiri Pirko
263685d59a87SJiri Pirko opt_inst_info = &opt_inst->info;
263785d59a87SJiri Pirko tmp_ifindex = opt_inst_info->port ?
263885d59a87SJiri Pirko opt_inst_info->port->dev->ifindex : 0;
26393d249d4cSJiri Pirko if (option->type != opt_type ||
264080f7c668SJiri Pirko strcmp(option->name, opt_name) ||
2641b1303326SJiri Pirko tmp_ifindex != opt_port_ifindex ||
2642b1303326SJiri Pirko (option->array_size && !opt_is_array) ||
264385d59a87SJiri Pirko opt_inst_info->array_index != opt_array_index)
26443d249d4cSJiri Pirko continue;
26453d249d4cSJiri Pirko opt_found = true;
264685d59a87SJiri Pirko ctx.info = opt_inst_info;
26473d249d4cSJiri Pirko switch (opt_type) {
26483d249d4cSJiri Pirko case TEAM_OPTION_TYPE_U32:
264914f066baSJiri Pirko ctx.data.u32_val = nla_get_u32(attr_data);
26503d249d4cSJiri Pirko break;
26513d249d4cSJiri Pirko case TEAM_OPTION_TYPE_STRING:
265214f066baSJiri Pirko if (nla_len(attr_data) > TEAM_STRING_MAX_LEN) {
26532615598fSJiri Pirko err = -EINVAL;
26542615598fSJiri Pirko goto team_put;
26552615598fSJiri Pirko }
265614f066baSJiri Pirko ctx.data.str_val = nla_data(attr_data);
26573d249d4cSJiri Pirko break;
26582615598fSJiri Pirko case TEAM_OPTION_TYPE_BINARY:
265914f066baSJiri Pirko ctx.data.bin_val.len = nla_len(attr_data);
266014f066baSJiri Pirko ctx.data.bin_val.ptr = nla_data(attr_data);
266114f066baSJiri Pirko break;
266214f066baSJiri Pirko case TEAM_OPTION_TYPE_BOOL:
266314f066baSJiri Pirko ctx.data.bool_val = attr_data ? true : false;
26642615598fSJiri Pirko break;
266569821638SJiri Pirko case TEAM_OPTION_TYPE_S32:
266669821638SJiri Pirko ctx.data.s32_val = nla_get_s32(attr_data);
266769821638SJiri Pirko break;
26683d249d4cSJiri Pirko default:
26693d249d4cSJiri Pirko BUG();
26703d249d4cSJiri Pirko }
267180f7c668SJiri Pirko err = team_option_set(team, opt_inst, &ctx);
26723d249d4cSJiri Pirko if (err)
26733d249d4cSJiri Pirko goto team_put;
26742fcdb2c9SJiri Pirko opt_inst->changed = true;
26752fcdb2c9SJiri Pirko list_add(&opt_inst->tmp_list, &opt_inst_list);
26763d249d4cSJiri Pirko }
26773d249d4cSJiri Pirko if (!opt_found) {
26783d249d4cSJiri Pirko err = -ENOENT;
26793d249d4cSJiri Pirko goto team_put;
26803d249d4cSJiri Pirko }
26813d249d4cSJiri Pirko
26822fcdb2c9SJiri Pirko err = team_nl_send_event_options_get(team, &opt_inst_list);
26832fdeee25SCong Wang if (err)
26842fdeee25SCong Wang break;
26852fdeee25SCong Wang }
26862fcdb2c9SJiri Pirko
26873d249d4cSJiri Pirko team_put:
26883d249d4cSJiri Pirko team_nl_team_put(team);
26897d259505SJiri Pirko rtnl_unlock:
26907d259505SJiri Pirko rtnl_unlock();
26913d249d4cSJiri Pirko return err;
26923d249d4cSJiri Pirko }
26933d249d4cSJiri Pirko
team_nl_fill_one_port_get(struct sk_buff * skb,struct team_port * port)2694d90f889eSJiri Pirko static int team_nl_fill_one_port_get(struct sk_buff *skb,
2695d90f889eSJiri Pirko struct team_port *port)
2696d90f889eSJiri Pirko {
2697d90f889eSJiri Pirko struct nlattr *port_item;
2698d90f889eSJiri Pirko
2699ae0be8deSMichal Kubecek port_item = nla_nest_start_noflag(skb, TEAM_ATTR_ITEM_PORT);
2700d90f889eSJiri Pirko if (!port_item)
2701d90f889eSJiri Pirko goto nest_cancel;
2702d90f889eSJiri Pirko if (nla_put_u32(skb, TEAM_ATTR_PORT_IFINDEX, port->dev->ifindex))
2703d90f889eSJiri Pirko goto nest_cancel;
2704d90f889eSJiri Pirko if (port->changed) {
2705d90f889eSJiri Pirko if (nla_put_flag(skb, TEAM_ATTR_PORT_CHANGED))
2706d90f889eSJiri Pirko goto nest_cancel;
2707d90f889eSJiri Pirko port->changed = false;
2708d90f889eSJiri Pirko }
2709d90f889eSJiri Pirko if ((port->removed &&
2710d90f889eSJiri Pirko nla_put_flag(skb, TEAM_ATTR_PORT_REMOVED)) ||
2711d90f889eSJiri Pirko (port->state.linkup &&
2712d90f889eSJiri Pirko nla_put_flag(skb, TEAM_ATTR_PORT_LINKUP)) ||
2713d90f889eSJiri Pirko nla_put_u32(skb, TEAM_ATTR_PORT_SPEED, port->state.speed) ||
2714d90f889eSJiri Pirko nla_put_u8(skb, TEAM_ATTR_PORT_DUPLEX, port->state.duplex))
2715d90f889eSJiri Pirko goto nest_cancel;
2716d90f889eSJiri Pirko nla_nest_end(skb, port_item);
2717d90f889eSJiri Pirko return 0;
2718d90f889eSJiri Pirko
2719d90f889eSJiri Pirko nest_cancel:
2720d90f889eSJiri Pirko nla_nest_cancel(skb, port_item);
2721d90f889eSJiri Pirko return -EMSGSIZE;
2722d90f889eSJiri Pirko }
2723d90f889eSJiri Pirko
team_nl_send_port_list_get(struct team * team,u32 portid,u32 seq,int flags,team_nl_send_func_t * send_func,struct team_port * one_port)2724d90f889eSJiri Pirko static int team_nl_send_port_list_get(struct team *team, u32 portid, u32 seq,
2725d90f889eSJiri Pirko int flags, team_nl_send_func_t *send_func,
2726d90f889eSJiri Pirko struct team_port *one_port)
27273d249d4cSJiri Pirko {
27283d249d4cSJiri Pirko struct nlattr *port_list;
2729d90f889eSJiri Pirko struct nlmsghdr *nlh;
27303d249d4cSJiri Pirko void *hdr;
27313d249d4cSJiri Pirko struct team_port *port;
2732d90f889eSJiri Pirko int err;
2733d90f889eSJiri Pirko struct sk_buff *skb = NULL;
2734d90f889eSJiri Pirko bool incomplete;
2735d90f889eSJiri Pirko int i;
27363d249d4cSJiri Pirko
27373f3e7ce4SJiri Pirko port = list_first_entry_or_null(&team->port_list,
27383f3e7ce4SJiri Pirko struct team_port, list);
2739d90f889eSJiri Pirko
2740d90f889eSJiri Pirko start_again:
2741d90f889eSJiri Pirko err = __send_and_alloc_skb(&skb, team, portid, send_func);
2742d90f889eSJiri Pirko if (err)
2743d90f889eSJiri Pirko return err;
2744d90f889eSJiri Pirko
2745d90f889eSJiri Pirko hdr = genlmsg_put(skb, portid, seq, &team_nl_family, flags | NLM_F_MULTI,
27463d249d4cSJiri Pirko TEAM_CMD_PORT_LIST_GET);
274772ec0bc6SPan Bian if (!hdr) {
274872ec0bc6SPan Bian nlmsg_free(skb);
2749a326e6ddSWei Yongjun return -EMSGSIZE;
275072ec0bc6SPan Bian }
27513d249d4cSJiri Pirko
275286ebb02dSDavid S. Miller if (nla_put_u32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex))
275386ebb02dSDavid S. Miller goto nla_put_failure;
2754ae0be8deSMichal Kubecek port_list = nla_nest_start_noflag(skb, TEAM_ATTR_LIST_PORT);
27553d249d4cSJiri Pirko if (!port_list)
27563221c646SJiri Pirko goto nla_put_failure;
27573d249d4cSJiri Pirko
2758d90f889eSJiri Pirko i = 0;
2759d90f889eSJiri Pirko incomplete = false;
27603d249d4cSJiri Pirko
2761d90f889eSJiri Pirko /* If one port is selected, called wants to send port list containing
2762d90f889eSJiri Pirko * only this port. Otherwise go through all listed ports and send all
2763d90f889eSJiri Pirko */
2764d90f889eSJiri Pirko if (one_port) {
2765d90f889eSJiri Pirko err = team_nl_fill_one_port_get(skb, one_port);
2766d90f889eSJiri Pirko if (err)
2767d90f889eSJiri Pirko goto errout;
27683f3e7ce4SJiri Pirko } else if (port) {
27693f3e7ce4SJiri Pirko list_for_each_entry_from(port, &team->port_list, list) {
2770d90f889eSJiri Pirko err = team_nl_fill_one_port_get(skb, port);
2771d90f889eSJiri Pirko if (err) {
2772d90f889eSJiri Pirko if (err == -EMSGSIZE) {
2773d90f889eSJiri Pirko if (!i)
2774d90f889eSJiri Pirko goto errout;
2775d90f889eSJiri Pirko incomplete = true;
2776d90f889eSJiri Pirko break;
2777b82b9183SJiri Pirko }
2778d90f889eSJiri Pirko goto errout;
2779d90f889eSJiri Pirko }
2780d90f889eSJiri Pirko i++;
2781d90f889eSJiri Pirko }
27823d249d4cSJiri Pirko }
27833d249d4cSJiri Pirko
27843d249d4cSJiri Pirko nla_nest_end(skb, port_list);
2785d90f889eSJiri Pirko genlmsg_end(skb, hdr);
2786d90f889eSJiri Pirko if (incomplete)
2787d90f889eSJiri Pirko goto start_again;
27883d249d4cSJiri Pirko
2789d90f889eSJiri Pirko send_done:
2790d90f889eSJiri Pirko nlh = nlmsg_put(skb, portid, seq, NLMSG_DONE, 0, flags | NLM_F_MULTI);
2791d90f889eSJiri Pirko if (!nlh) {
2792d90f889eSJiri Pirko err = __send_and_alloc_skb(&skb, team, portid, send_func);
2793d90f889eSJiri Pirko if (err)
2794cbcc607eSArkadi Sharshevsky return err;
2795d90f889eSJiri Pirko goto send_done;
27963d249d4cSJiri Pirko }
27973d249d4cSJiri Pirko
2798d90f889eSJiri Pirko return send_func(skb, team, portid);
2799d90f889eSJiri Pirko
2800d90f889eSJiri Pirko nla_put_failure:
2801d90f889eSJiri Pirko err = -EMSGSIZE;
2802d90f889eSJiri Pirko errout:
2803d90f889eSJiri Pirko nlmsg_free(skb);
2804d90f889eSJiri Pirko return err;
28053d249d4cSJiri Pirko }
28063d249d4cSJiri Pirko
team_nl_cmd_port_list_get(struct sk_buff * skb,struct genl_info * info)28073d249d4cSJiri Pirko static int team_nl_cmd_port_list_get(struct sk_buff *skb,
28083d249d4cSJiri Pirko struct genl_info *info)
28093d249d4cSJiri Pirko {
28103d249d4cSJiri Pirko struct team *team;
28113d249d4cSJiri Pirko int err;
28123d249d4cSJiri Pirko
28133d249d4cSJiri Pirko team = team_nl_team_get(info);
28143d249d4cSJiri Pirko if (!team)
28153d249d4cSJiri Pirko return -EINVAL;
28163d249d4cSJiri Pirko
2817d90f889eSJiri Pirko err = team_nl_send_port_list_get(team, info->snd_portid, info->snd_seq,
2818d90f889eSJiri Pirko NLM_F_ACK, team_nl_send_unicast, NULL);
28193d249d4cSJiri Pirko
28203d249d4cSJiri Pirko team_nl_team_put(team);
28213d249d4cSJiri Pirko
28223d249d4cSJiri Pirko return err;
28233d249d4cSJiri Pirko }
28243d249d4cSJiri Pirko
282566a9b928SJakub Kicinski static const struct genl_small_ops team_nl_ops[] = {
28263d249d4cSJiri Pirko {
28273d249d4cSJiri Pirko .cmd = TEAM_CMD_NOOP,
2828ef6243acSJohannes Berg .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
28293d249d4cSJiri Pirko .doit = team_nl_cmd_noop,
28303d249d4cSJiri Pirko },
28313d249d4cSJiri Pirko {
28323d249d4cSJiri Pirko .cmd = TEAM_CMD_OPTIONS_SET,
2833ef6243acSJohannes Berg .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
28343d249d4cSJiri Pirko .doit = team_nl_cmd_options_set,
28353d249d4cSJiri Pirko .flags = GENL_ADMIN_PERM,
28363d249d4cSJiri Pirko },
28373d249d4cSJiri Pirko {
28383d249d4cSJiri Pirko .cmd = TEAM_CMD_OPTIONS_GET,
2839ef6243acSJohannes Berg .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
28403d249d4cSJiri Pirko .doit = team_nl_cmd_options_get,
28413d249d4cSJiri Pirko .flags = GENL_ADMIN_PERM,
28423d249d4cSJiri Pirko },
28433d249d4cSJiri Pirko {
28443d249d4cSJiri Pirko .cmd = TEAM_CMD_PORT_LIST_GET,
2845ef6243acSJohannes Berg .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
28463d249d4cSJiri Pirko .doit = team_nl_cmd_port_list_get,
28473d249d4cSJiri Pirko .flags = GENL_ADMIN_PERM,
28483d249d4cSJiri Pirko },
28493d249d4cSJiri Pirko };
28503d249d4cSJiri Pirko
28512a94fe48SJohannes Berg static const struct genl_multicast_group team_nl_mcgrps[] = {
28522a94fe48SJohannes Berg { .name = TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME, },
28533d249d4cSJiri Pirko };
28543d249d4cSJiri Pirko
285556989f6dSJohannes Berg static struct genl_family team_nl_family __ro_after_init = {
2856489111e5SJohannes Berg .name = TEAM_GENL_NAME,
2857489111e5SJohannes Berg .version = TEAM_GENL_VERSION,
2858489111e5SJohannes Berg .maxattr = TEAM_ATTR_MAX,
28593b0f31f2SJohannes Berg .policy = team_nl_policy,
2860489111e5SJohannes Berg .netnsok = true,
2861489111e5SJohannes Berg .module = THIS_MODULE,
286266a9b928SJakub Kicinski .small_ops = team_nl_ops,
286366a9b928SJakub Kicinski .n_small_ops = ARRAY_SIZE(team_nl_ops),
28649c5d03d3SJakub Kicinski .resv_start_op = TEAM_CMD_PORT_LIST_GET + 1,
2865489111e5SJohannes Berg .mcgrps = team_nl_mcgrps,
2866489111e5SJohannes Berg .n_mcgrps = ARRAY_SIZE(team_nl_mcgrps),
2867489111e5SJohannes Berg };
2868489111e5SJohannes Berg
team_nl_send_multicast(struct sk_buff * skb,struct team * team,u32 portid)28699b00cf2dSJiri Pirko static int team_nl_send_multicast(struct sk_buff *skb,
287015e47304SEric W. Biederman struct team *team, u32 portid)
28719b00cf2dSJiri Pirko {
287268eb5503SJohannes Berg return genlmsg_multicast_netns(&team_nl_family, dev_net(team->dev),
28732a94fe48SJohannes Berg skb, 0, 0, GFP_KERNEL);
28749b00cf2dSJiri Pirko }
28759b00cf2dSJiri Pirko
team_nl_send_event_options_get(struct team * team,struct list_head * sel_opt_inst_list)287601048d9aSJiri Pirko static int team_nl_send_event_options_get(struct team *team,
287701048d9aSJiri Pirko struct list_head *sel_opt_inst_list)
28783d249d4cSJiri Pirko {
28799b00cf2dSJiri Pirko return team_nl_send_options_get(team, 0, 0, 0, team_nl_send_multicast,
28809b00cf2dSJiri Pirko sel_opt_inst_list);
28813d249d4cSJiri Pirko }
28823d249d4cSJiri Pirko
team_nl_send_event_port_get(struct team * team,struct team_port * port)2883d90f889eSJiri Pirko static int team_nl_send_event_port_get(struct team *team,
2884d90f889eSJiri Pirko struct team_port *port)
28853d249d4cSJiri Pirko {
2886d90f889eSJiri Pirko return team_nl_send_port_list_get(team, 0, 0, 0, team_nl_send_multicast,
2887d90f889eSJiri Pirko port);
28883d249d4cSJiri Pirko }
28893d249d4cSJiri Pirko
team_nl_init(void)289056989f6dSJohannes Berg static int __init team_nl_init(void)
28913d249d4cSJiri Pirko {
2892489111e5SJohannes Berg return genl_register_family(&team_nl_family);
28933d249d4cSJiri Pirko }
28943d249d4cSJiri Pirko
team_nl_fini(void)28958958ef51SZhengchao Shao static void __exit team_nl_fini(void)
28963d249d4cSJiri Pirko {
28973d249d4cSJiri Pirko genl_unregister_family(&team_nl_family);
28983d249d4cSJiri Pirko }
28993d249d4cSJiri Pirko
29003d249d4cSJiri Pirko
29013d249d4cSJiri Pirko /******************
29023d249d4cSJiri Pirko * Change checkers
29033d249d4cSJiri Pirko ******************/
29043d249d4cSJiri Pirko
__team_options_change_check(struct team * team)2905b82b9183SJiri Pirko static void __team_options_change_check(struct team *team)
29063d249d4cSJiri Pirko {
29073d249d4cSJiri Pirko int err;
290801048d9aSJiri Pirko struct team_option_inst *opt_inst;
290901048d9aSJiri Pirko LIST_HEAD(sel_opt_inst_list);
29103d249d4cSJiri Pirko
291101048d9aSJiri Pirko list_for_each_entry(opt_inst, &team->option_inst_list, list) {
291201048d9aSJiri Pirko if (opt_inst->changed)
291301048d9aSJiri Pirko list_add_tail(&opt_inst->tmp_list, &sel_opt_inst_list);
291401048d9aSJiri Pirko }
291501048d9aSJiri Pirko err = team_nl_send_event_options_get(team, &sel_opt_inst_list);
29160c7517e9SJiri Pirko if (err && err != -ESRCH)
29179b00cf2dSJiri Pirko netdev_warn(team->dev, "Failed to send options change via netlink (err %d)\n",
29189b00cf2dSJiri Pirko err);
29193d249d4cSJiri Pirko }
29203d249d4cSJiri Pirko
29213d249d4cSJiri Pirko /* rtnl lock is held */
292210f3f51dSJiri Pirko
__team_port_change_send(struct team_port * port,bool linkup)292310f3f51dSJiri Pirko static void __team_port_change_send(struct team_port *port, bool linkup)
29243d249d4cSJiri Pirko {
29253d249d4cSJiri Pirko int err;
29263d249d4cSJiri Pirko
2927b82b9183SJiri Pirko port->changed = true;
292871472ec1SJiri Pirko port->state.linkup = linkup;
292971472ec1SJiri Pirko team_refresh_port_linkup(port);
29303d249d4cSJiri Pirko if (linkup) {
29310ab6b544SDavid Decotigny struct ethtool_link_ksettings ecmd;
29323d249d4cSJiri Pirko
29330ab6b544SDavid Decotigny err = __ethtool_get_link_ksettings(port->dev, &ecmd);
29343d249d4cSJiri Pirko if (!err) {
29350ab6b544SDavid Decotigny port->state.speed = ecmd.base.speed;
29360ab6b544SDavid Decotigny port->state.duplex = ecmd.base.duplex;
29373d249d4cSJiri Pirko goto send_event;
29383d249d4cSJiri Pirko }
29393d249d4cSJiri Pirko }
294071472ec1SJiri Pirko port->state.speed = 0;
294171472ec1SJiri Pirko port->state.duplex = 0;
29423d249d4cSJiri Pirko
29433d249d4cSJiri Pirko send_event:
2944d90f889eSJiri Pirko err = team_nl_send_event_port_get(port->team, port);
29450c7517e9SJiri Pirko if (err && err != -ESRCH)
29460c7517e9SJiri Pirko netdev_warn(port->team->dev, "Failed to send port change of device %s via netlink (err %d)\n",
29470c7517e9SJiri Pirko port->dev->name, err);
29483d249d4cSJiri Pirko
29493d249d4cSJiri Pirko }
29503d249d4cSJiri Pirko
__team_carrier_check(struct team * team)295106a7fc42SFlavio Leitner static void __team_carrier_check(struct team *team)
295206a7fc42SFlavio Leitner {
295306a7fc42SFlavio Leitner struct team_port *port;
295406a7fc42SFlavio Leitner bool team_linkup;
295506a7fc42SFlavio Leitner
2956e185483eSFlavio Leitner if (team->user_carrier_enabled)
2957e185483eSFlavio Leitner return;
2958e185483eSFlavio Leitner
295906a7fc42SFlavio Leitner team_linkup = false;
296006a7fc42SFlavio Leitner list_for_each_entry(port, &team->port_list, list) {
296106a7fc42SFlavio Leitner if (port->linkup) {
296206a7fc42SFlavio Leitner team_linkup = true;
296306a7fc42SFlavio Leitner break;
296406a7fc42SFlavio Leitner }
296506a7fc42SFlavio Leitner }
296606a7fc42SFlavio Leitner
296706a7fc42SFlavio Leitner if (team_linkup)
296806a7fc42SFlavio Leitner netif_carrier_on(team->dev);
296906a7fc42SFlavio Leitner else
297006a7fc42SFlavio Leitner netif_carrier_off(team->dev);
297106a7fc42SFlavio Leitner }
297206a7fc42SFlavio Leitner
__team_port_change_check(struct team_port * port,bool linkup)297310f3f51dSJiri Pirko static void __team_port_change_check(struct team_port *port, bool linkup)
297410f3f51dSJiri Pirko {
297510f3f51dSJiri Pirko if (port->state.linkup != linkup)
297610f3f51dSJiri Pirko __team_port_change_send(port, linkup);
297706a7fc42SFlavio Leitner __team_carrier_check(port->team);
297810f3f51dSJiri Pirko }
297910f3f51dSJiri Pirko
__team_port_change_port_added(struct team_port * port,bool linkup)298010f3f51dSJiri Pirko static void __team_port_change_port_added(struct team_port *port, bool linkup)
298110f3f51dSJiri Pirko {
298210f3f51dSJiri Pirko __team_port_change_send(port, linkup);
298306a7fc42SFlavio Leitner __team_carrier_check(port->team);
298410f3f51dSJiri Pirko }
298510f3f51dSJiri Pirko
__team_port_change_port_removed(struct team_port * port)298610f3f51dSJiri Pirko static void __team_port_change_port_removed(struct team_port *port)
298710f3f51dSJiri Pirko {
298810f3f51dSJiri Pirko port->removed = true;
298910f3f51dSJiri Pirko __team_port_change_send(port, false);
299006a7fc42SFlavio Leitner __team_carrier_check(port->team);
299110f3f51dSJiri Pirko }
299210f3f51dSJiri Pirko
team_port_change_check(struct team_port * port,bool linkup)29933d249d4cSJiri Pirko static void team_port_change_check(struct team_port *port, bool linkup)
29943d249d4cSJiri Pirko {
29953d249d4cSJiri Pirko struct team *team = port->team;
29963d249d4cSJiri Pirko
299761dc3461SJiri Pirko mutex_lock(&team->lock);
29983d249d4cSJiri Pirko __team_port_change_check(port, linkup);
299961dc3461SJiri Pirko mutex_unlock(&team->lock);
30003d249d4cSJiri Pirko }
30013d249d4cSJiri Pirko
30020f1aad2bSJiri Pirko
30033d249d4cSJiri Pirko /************************************
30043d249d4cSJiri Pirko * Net device notifier event handler
30053d249d4cSJiri Pirko ************************************/
30063d249d4cSJiri Pirko
team_device_event(struct notifier_block * unused,unsigned long event,void * ptr)30073d249d4cSJiri Pirko static int team_device_event(struct notifier_block *unused,
30083d249d4cSJiri Pirko unsigned long event, void *ptr)
30093d249d4cSJiri Pirko {
3010351638e7SJiri Pirko struct net_device *dev = netdev_notifier_info_to_dev(ptr);
30113d249d4cSJiri Pirko struct team_port *port;
30123d249d4cSJiri Pirko
30133d249d4cSJiri Pirko port = team_port_get_rtnl(dev);
30143d249d4cSJiri Pirko if (!port)
30153d249d4cSJiri Pirko return NOTIFY_DONE;
30163d249d4cSJiri Pirko
30173d249d4cSJiri Pirko switch (event) {
30183d249d4cSJiri Pirko case NETDEV_UP:
30198c7a7726SGeorge Wilkie if (netif_oper_up(dev))
30203d249d4cSJiri Pirko team_port_change_check(port, true);
3021ed2da03cSJiri Pirko break;
30223d249d4cSJiri Pirko case NETDEV_DOWN:
30233d249d4cSJiri Pirko team_port_change_check(port, false);
3024ed2da03cSJiri Pirko break;
30253d249d4cSJiri Pirko case NETDEV_CHANGE:
30263d249d4cSJiri Pirko if (netif_running(port->dev))
30273d249d4cSJiri Pirko team_port_change_check(port,
3028f1d22a1eSGeorge Wilkie !!netif_oper_up(port->dev));
30293d249d4cSJiri Pirko break;
30303d249d4cSJiri Pirko case NETDEV_UNREGISTER:
30313d249d4cSJiri Pirko team_del_slave(port->team->dev, dev);
30323d249d4cSJiri Pirko break;
30333d249d4cSJiri Pirko case NETDEV_FEAT_CHANGE:
3034ae9b15fbSTaehee Yoo if (!port->team->notifier_ctx) {
3035ae9b15fbSTaehee Yoo port->team->notifier_ctx = true;
30363d249d4cSJiri Pirko team_compute_features(port->team);
3037ae9b15fbSTaehee Yoo port->team->notifier_ctx = false;
3038ae9b15fbSTaehee Yoo }
30393d249d4cSJiri Pirko break;
3040b01f236cSVeaceslav Falico case NETDEV_PRECHANGEMTU:
30413d249d4cSJiri Pirko /* Forbid to change mtu of underlaying device */
30429d0d68faSJiri Pirko if (!port->team->port_mtu_change_allowed)
30433d249d4cSJiri Pirko return NOTIFY_BAD;
30449d0d68faSJiri Pirko break;
30453d249d4cSJiri Pirko case NETDEV_PRE_TYPE_CHANGE:
30463d249d4cSJiri Pirko /* Forbid to change type of underlaying device */
30473d249d4cSJiri Pirko return NOTIFY_BAD;
30484aa5dee4SJiri Pirko case NETDEV_RESEND_IGMP:
30494aa5dee4SJiri Pirko /* Propagate to master device */
30504aa5dee4SJiri Pirko call_netdevice_notifiers(event, port->team->dev);
30514aa5dee4SJiri Pirko break;
30523d249d4cSJiri Pirko }
30533d249d4cSJiri Pirko return NOTIFY_DONE;
30543d249d4cSJiri Pirko }
30553d249d4cSJiri Pirko
30563d249d4cSJiri Pirko static struct notifier_block team_notifier_block __read_mostly = {
30573d249d4cSJiri Pirko .notifier_call = team_device_event,
30583d249d4cSJiri Pirko };
30593d249d4cSJiri Pirko
30603d249d4cSJiri Pirko
30613d249d4cSJiri Pirko /***********************
30623d249d4cSJiri Pirko * Module init and exit
30633d249d4cSJiri Pirko ***********************/
30643d249d4cSJiri Pirko
team_module_init(void)30653d249d4cSJiri Pirko static int __init team_module_init(void)
30663d249d4cSJiri Pirko {
30673d249d4cSJiri Pirko int err;
30683d249d4cSJiri Pirko
30693d249d4cSJiri Pirko register_netdevice_notifier(&team_notifier_block);
30703d249d4cSJiri Pirko
30713d249d4cSJiri Pirko err = rtnl_link_register(&team_link_ops);
30723d249d4cSJiri Pirko if (err)
30733d249d4cSJiri Pirko goto err_rtnl_reg;
30743d249d4cSJiri Pirko
30753d249d4cSJiri Pirko err = team_nl_init();
30763d249d4cSJiri Pirko if (err)
30773d249d4cSJiri Pirko goto err_nl_init;
30783d249d4cSJiri Pirko
30793d249d4cSJiri Pirko return 0;
30803d249d4cSJiri Pirko
30813d249d4cSJiri Pirko err_nl_init:
30823d249d4cSJiri Pirko rtnl_link_unregister(&team_link_ops);
30833d249d4cSJiri Pirko
30843d249d4cSJiri Pirko err_rtnl_reg:
30853d249d4cSJiri Pirko unregister_netdevice_notifier(&team_notifier_block);
30863d249d4cSJiri Pirko
30873d249d4cSJiri Pirko return err;
30883d249d4cSJiri Pirko }
30893d249d4cSJiri Pirko
team_module_exit(void)30903d249d4cSJiri Pirko static void __exit team_module_exit(void)
30913d249d4cSJiri Pirko {
30923d249d4cSJiri Pirko team_nl_fini();
30933d249d4cSJiri Pirko rtnl_link_unregister(&team_link_ops);
30943d249d4cSJiri Pirko unregister_netdevice_notifier(&team_notifier_block);
30953d249d4cSJiri Pirko }
30963d249d4cSJiri Pirko
30973d249d4cSJiri Pirko module_init(team_module_init);
30983d249d4cSJiri Pirko module_exit(team_module_exit);
30993d249d4cSJiri Pirko
31003d249d4cSJiri Pirko MODULE_LICENSE("GPL v2");
31013d249d4cSJiri Pirko MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
31023d249d4cSJiri Pirko MODULE_DESCRIPTION("Ethernet team device driver");
31033d249d4cSJiri Pirko MODULE_ALIAS_RTNL_LINK(DRV_NAME);
3104