1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * drivers/net/team/team.c - Network team device driver
4 * Copyright (c) 2011 Jiri Pirko <jpirko@redhat.com>
7 #include <linux/ethtool.h>
8 #include <linux/kernel.h>
9 #include <linux/types.h>
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/slab.h>
13 #include <linux/rcupdate.h>
14 #include <linux/errno.h>
15 #include <linux/ctype.h>
16 #include <linux/notifier.h>
17 #include <linux/netdevice.h>
18 #include <linux/netpoll.h>
19 #include <linux/if_vlan.h>
20 #include <linux/if_arp.h>
21 #include <linux/socket.h>
22 #include <linux/etherdevice.h>
23 #include <linux/rtnetlink.h>
24 #include <net/rtnetlink.h>
25 #include <net/genetlink.h>
26 #include <net/netlink.h>
27 #include <net/sch_generic.h>
28 #include <generated/utsrelease.h>
29 #include <linux/if_team.h>
31 #define DRV_NAME "team"
38 static struct team_port
*team_port_get_rtnl(const struct net_device
*dev
)
40 struct team_port
*port
= rtnl_dereference(dev
->rx_handler_data
);
42 return netif_is_team_port(dev
) ? port
: NULL
;
46 * Since the ability to change device address for open port device is tested in
47 * team_port_add, this function can be called without control of return value
49 static int __set_port_dev_addr(struct net_device
*port_dev
,
50 const unsigned char *dev_addr
)
52 struct sockaddr_storage addr
;
54 memcpy(addr
.__data
, dev_addr
, port_dev
->addr_len
);
55 addr
.ss_family
= port_dev
->type
;
56 return dev_set_mac_address(port_dev
, (struct sockaddr
*)&addr
, NULL
);
59 static int team_port_set_orig_dev_addr(struct team_port
*port
)
61 return __set_port_dev_addr(port
->dev
, port
->orig
.dev_addr
);
64 static int team_port_set_team_dev_addr(struct team
*team
,
65 struct team_port
*port
)
67 return __set_port_dev_addr(port
->dev
, team
->dev
->dev_addr
);
70 int team_modeop_port_enter(struct team
*team
, struct team_port
*port
)
72 return team_port_set_team_dev_addr(team
, port
);
74 EXPORT_SYMBOL(team_modeop_port_enter
);
76 void team_modeop_port_change_dev_addr(struct team
*team
,
77 struct team_port
*port
)
79 team_port_set_team_dev_addr(team
, port
);
81 EXPORT_SYMBOL(team_modeop_port_change_dev_addr
);
83 static void team_lower_state_changed(struct team_port
*port
)
85 struct netdev_lag_lower_state_info info
;
87 info
.link_up
= port
->linkup
;
88 info
.tx_enabled
= team_port_enabled(port
);
89 netdev_lower_state_changed(port
->dev
, &info
);
92 static void team_refresh_port_linkup(struct team_port
*port
)
94 bool new_linkup
= port
->user
.linkup_enabled
? port
->user
.linkup
:
97 if (port
->linkup
!= new_linkup
) {
98 port
->linkup
= new_linkup
;
99 team_lower_state_changed(port
);
108 struct team_option_inst
{ /* One for each option instance */
109 struct list_head list
;
110 struct list_head tmp_list
;
111 struct team_option
*option
;
112 struct team_option_inst_info info
;
117 static struct team_option
*__team_find_option(struct team
*team
,
118 const char *opt_name
)
120 struct team_option
*option
;
122 list_for_each_entry(option
, &team
->option_list
, list
) {
123 if (strcmp(option
->name
, opt_name
) == 0)
129 static void __team_option_inst_del(struct team_option_inst
*opt_inst
)
131 list_del(&opt_inst
->list
);
135 static void __team_option_inst_del_option(struct team
*team
,
136 struct team_option
*option
)
138 struct team_option_inst
*opt_inst
, *tmp
;
140 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
141 if (opt_inst
->option
== option
)
142 __team_option_inst_del(opt_inst
);
146 static int __team_option_inst_add(struct team
*team
, struct team_option
*option
,
147 struct team_port
*port
)
149 struct team_option_inst
*opt_inst
;
150 unsigned int array_size
;
153 array_size
= option
->array_size
;
155 array_size
= 1; /* No array but still need one instance */
157 for (i
= 0; i
< array_size
; i
++) {
158 opt_inst
= kmalloc(sizeof(*opt_inst
), GFP_KERNEL
);
161 opt_inst
->option
= option
;
162 opt_inst
->info
.port
= port
;
163 opt_inst
->info
.array_index
= i
;
164 opt_inst
->changed
= true;
165 opt_inst
->removed
= false;
166 list_add_tail(&opt_inst
->list
, &team
->option_inst_list
);
168 option
->init(team
, &opt_inst
->info
);
174 static int __team_option_inst_add_option(struct team
*team
,
175 struct team_option
*option
)
179 if (!option
->per_port
) {
180 err
= __team_option_inst_add(team
, option
, NULL
);
182 goto inst_del_option
;
187 __team_option_inst_del_option(team
, option
);
191 static void __team_option_inst_mark_removed_option(struct team
*team
,
192 struct team_option
*option
)
194 struct team_option_inst
*opt_inst
;
196 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
197 if (opt_inst
->option
== option
) {
198 opt_inst
->changed
= true;
199 opt_inst
->removed
= true;
204 static void __team_option_inst_del_port(struct team
*team
,
205 struct team_port
*port
)
207 struct team_option_inst
*opt_inst
, *tmp
;
209 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
210 if (opt_inst
->option
->per_port
&&
211 opt_inst
->info
.port
== port
)
212 __team_option_inst_del(opt_inst
);
216 static int __team_option_inst_add_port(struct team
*team
,
217 struct team_port
*port
)
219 struct team_option
*option
;
222 list_for_each_entry(option
, &team
->option_list
, list
) {
223 if (!option
->per_port
)
225 err
= __team_option_inst_add(team
, option
, port
);
232 __team_option_inst_del_port(team
, port
);
236 static void __team_option_inst_mark_removed_port(struct team
*team
,
237 struct team_port
*port
)
239 struct team_option_inst
*opt_inst
;
241 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
242 if (opt_inst
->info
.port
== port
) {
243 opt_inst
->changed
= true;
244 opt_inst
->removed
= true;
249 static int __team_options_register(struct team
*team
,
250 const struct team_option
*option
,
254 struct team_option
**dst_opts
;
257 dst_opts
= kcalloc(option_count
, sizeof(struct team_option
*),
261 for (i
= 0; i
< option_count
; i
++, option
++) {
262 if (__team_find_option(team
, option
->name
)) {
266 dst_opts
[i
] = kmemdup(option
, sizeof(*option
), GFP_KERNEL
);
273 for (i
= 0; i
< option_count
; i
++) {
274 err
= __team_option_inst_add_option(team
, dst_opts
[i
]);
277 list_add_tail(&dst_opts
[i
]->list
, &team
->option_list
);
284 for (i
--; i
>= 0; i
--) {
285 __team_option_inst_del_option(team
, dst_opts
[i
]);
286 list_del(&dst_opts
[i
]->list
);
291 for (i
--; i
>= 0; i
--)
298 static void __team_options_mark_removed(struct team
*team
,
299 const struct team_option
*option
,
304 for (i
= 0; i
< option_count
; i
++, option
++) {
305 struct team_option
*del_opt
;
307 del_opt
= __team_find_option(team
, option
->name
);
309 __team_option_inst_mark_removed_option(team
, del_opt
);
313 static void __team_options_unregister(struct team
*team
,
314 const struct team_option
*option
,
319 for (i
= 0; i
< option_count
; i
++, option
++) {
320 struct team_option
*del_opt
;
322 del_opt
= __team_find_option(team
, option
->name
);
324 __team_option_inst_del_option(team
, del_opt
);
325 list_del(&del_opt
->list
);
331 static void __team_options_change_check(struct team
*team
);
333 int team_options_register(struct team
*team
,
334 const struct team_option
*option
,
339 err
= __team_options_register(team
, option
, option_count
);
342 __team_options_change_check(team
);
345 EXPORT_SYMBOL(team_options_register
);
347 void team_options_unregister(struct team
*team
,
348 const struct team_option
*option
,
351 __team_options_mark_removed(team
, option
, option_count
);
352 __team_options_change_check(team
);
353 __team_options_unregister(team
, option
, option_count
);
355 EXPORT_SYMBOL(team_options_unregister
);
357 static int team_option_get(struct team
*team
,
358 struct team_option_inst
*opt_inst
,
359 struct team_gsetter_ctx
*ctx
)
361 if (!opt_inst
->option
->getter
)
364 opt_inst
->option
->getter(team
, ctx
);
368 static int team_option_set(struct team
*team
,
369 struct team_option_inst
*opt_inst
,
370 struct team_gsetter_ctx
*ctx
)
372 if (!opt_inst
->option
->setter
)
374 return opt_inst
->option
->setter(team
, ctx
);
377 void team_option_inst_set_change(struct team_option_inst_info
*opt_inst_info
)
379 struct team_option_inst
*opt_inst
;
381 opt_inst
= container_of(opt_inst_info
, struct team_option_inst
, info
);
382 opt_inst
->changed
= true;
384 EXPORT_SYMBOL(team_option_inst_set_change
);
386 void team_options_change_check(struct team
*team
)
388 __team_options_change_check(team
);
390 EXPORT_SYMBOL(team_options_change_check
);
397 static LIST_HEAD(mode_list
);
398 static DEFINE_SPINLOCK(mode_list_lock
);
400 struct team_mode_item
{
401 struct list_head list
;
402 const struct team_mode
*mode
;
405 static struct team_mode_item
*__find_mode(const char *kind
)
407 struct team_mode_item
*mitem
;
409 list_for_each_entry(mitem
, &mode_list
, list
) {
410 if (strcmp(mitem
->mode
->kind
, kind
) == 0)
416 static bool is_good_mode_name(const char *name
)
418 while (*name
!= '\0') {
419 if (!isalpha(*name
) && !isdigit(*name
) && *name
!= '_')
426 int team_mode_register(const struct team_mode
*mode
)
429 struct team_mode_item
*mitem
;
431 if (!is_good_mode_name(mode
->kind
) ||
432 mode
->priv_size
> TEAM_MODE_PRIV_SIZE
)
435 mitem
= kmalloc(sizeof(*mitem
), GFP_KERNEL
);
439 spin_lock(&mode_list_lock
);
440 if (__find_mode(mode
->kind
)) {
446 list_add_tail(&mitem
->list
, &mode_list
);
448 spin_unlock(&mode_list_lock
);
451 EXPORT_SYMBOL(team_mode_register
);
453 void team_mode_unregister(const struct team_mode
*mode
)
455 struct team_mode_item
*mitem
;
457 spin_lock(&mode_list_lock
);
458 mitem
= __find_mode(mode
->kind
);
460 list_del_init(&mitem
->list
);
463 spin_unlock(&mode_list_lock
);
465 EXPORT_SYMBOL(team_mode_unregister
);
467 static const struct team_mode
*team_mode_get(const char *kind
)
469 struct team_mode_item
*mitem
;
470 const struct team_mode
*mode
= NULL
;
472 if (!try_module_get(THIS_MODULE
))
475 spin_lock(&mode_list_lock
);
476 mitem
= __find_mode(kind
);
478 spin_unlock(&mode_list_lock
);
479 request_module("team-mode-%s", kind
);
480 spin_lock(&mode_list_lock
);
481 mitem
= __find_mode(kind
);
485 if (!try_module_get(mode
->owner
))
489 spin_unlock(&mode_list_lock
);
490 module_put(THIS_MODULE
);
494 static void team_mode_put(const struct team_mode
*mode
)
496 module_put(mode
->owner
);
499 static bool team_dummy_transmit(struct team
*team
, struct sk_buff
*skb
)
501 dev_kfree_skb_any(skb
);
505 static rx_handler_result_t
team_dummy_receive(struct team
*team
,
506 struct team_port
*port
,
509 return RX_HANDLER_ANOTHER
;
512 static const struct team_mode __team_no_mode
= {
516 static bool team_is_mode_set(struct team
*team
)
518 return team
->mode
!= &__team_no_mode
;
521 static void team_set_no_mode(struct team
*team
)
523 team
->user_carrier_enabled
= false;
524 team
->mode
= &__team_no_mode
;
527 static void team_adjust_ops(struct team
*team
)
530 * To avoid checks in rx/tx skb paths, ensure here that non-null and
531 * correct ops are always set.
534 if (!team
->en_port_count
|| !team_is_mode_set(team
) ||
535 !team
->mode
->ops
->transmit
)
536 team
->ops
.transmit
= team_dummy_transmit
;
538 team
->ops
.transmit
= team
->mode
->ops
->transmit
;
540 if (!team
->en_port_count
|| !team_is_mode_set(team
) ||
541 !team
->mode
->ops
->receive
)
542 team
->ops
.receive
= team_dummy_receive
;
544 team
->ops
.receive
= team
->mode
->ops
->receive
;
548 * We can benefit from the fact that it's ensured no port is present
549 * at the time of mode change. Therefore no packets are in fly so there's no
550 * need to set mode operations in any special way.
552 static int __team_change_mode(struct team
*team
,
553 const struct team_mode
*new_mode
)
555 /* Check if mode was previously set and do cleanup if so */
556 if (team_is_mode_set(team
)) {
557 void (*exit_op
)(struct team
*team
) = team
->ops
.exit
;
559 /* Clear ops area so no callback is called any longer */
560 memset(&team
->ops
, 0, sizeof(struct team_mode_ops
));
561 team_adjust_ops(team
);
565 team_mode_put(team
->mode
);
566 team_set_no_mode(team
);
567 /* zero private data area */
568 memset(&team
->mode_priv
, 0,
569 sizeof(struct team
) - offsetof(struct team
, mode_priv
));
575 if (new_mode
->ops
->init
) {
578 err
= new_mode
->ops
->init(team
);
583 team
->mode
= new_mode
;
584 memcpy(&team
->ops
, new_mode
->ops
, sizeof(struct team_mode_ops
));
585 team_adjust_ops(team
);
590 static int team_change_mode(struct team
*team
, const char *kind
)
592 const struct team_mode
*new_mode
;
593 struct net_device
*dev
= team
->dev
;
596 if (!list_empty(&team
->port_list
)) {
597 netdev_err(dev
, "No ports can be present during mode change\n");
601 if (team_is_mode_set(team
) && strcmp(team
->mode
->kind
, kind
) == 0) {
602 netdev_err(dev
, "Unable to change to the same mode the team is in\n");
606 new_mode
= team_mode_get(kind
);
608 netdev_err(dev
, "Mode \"%s\" not found\n", kind
);
612 err
= __team_change_mode(team
, new_mode
);
614 netdev_err(dev
, "Failed to change to mode \"%s\"\n", kind
);
615 team_mode_put(new_mode
);
619 netdev_info(dev
, "Mode changed to \"%s\"\n", kind
);
624 /*********************
626 *********************/
628 static void team_notify_peers_work(struct work_struct
*work
)
633 team
= container_of(work
, struct team
, notify_peers
.dw
.work
);
635 if (!rtnl_trylock()) {
636 schedule_delayed_work(&team
->notify_peers
.dw
, 0);
639 val
= atomic_dec_if_positive(&team
->notify_peers
.count_pending
);
644 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS
, team
->dev
);
647 schedule_delayed_work(&team
->notify_peers
.dw
,
648 msecs_to_jiffies(team
->notify_peers
.interval
));
651 static void team_notify_peers(struct team
*team
)
653 if (!team
->notify_peers
.count
|| !netif_running(team
->dev
))
655 atomic_add(team
->notify_peers
.count
, &team
->notify_peers
.count_pending
);
656 schedule_delayed_work(&team
->notify_peers
.dw
, 0);
659 static void team_notify_peers_init(struct team
*team
)
661 INIT_DELAYED_WORK(&team
->notify_peers
.dw
, team_notify_peers_work
);
664 static void team_notify_peers_fini(struct team
*team
)
666 cancel_delayed_work_sync(&team
->notify_peers
.dw
);
670 /*******************************
671 * Send multicast group rejoins
672 *******************************/
674 static void team_mcast_rejoin_work(struct work_struct
*work
)
679 team
= container_of(work
, struct team
, mcast_rejoin
.dw
.work
);
681 if (!rtnl_trylock()) {
682 schedule_delayed_work(&team
->mcast_rejoin
.dw
, 0);
685 val
= atomic_dec_if_positive(&team
->mcast_rejoin
.count_pending
);
690 call_netdevice_notifiers(NETDEV_RESEND_IGMP
, team
->dev
);
693 schedule_delayed_work(&team
->mcast_rejoin
.dw
,
694 msecs_to_jiffies(team
->mcast_rejoin
.interval
));
697 static void team_mcast_rejoin(struct team
*team
)
699 if (!team
->mcast_rejoin
.count
|| !netif_running(team
->dev
))
701 atomic_add(team
->mcast_rejoin
.count
, &team
->mcast_rejoin
.count_pending
);
702 schedule_delayed_work(&team
->mcast_rejoin
.dw
, 0);
705 static void team_mcast_rejoin_init(struct team
*team
)
707 INIT_DELAYED_WORK(&team
->mcast_rejoin
.dw
, team_mcast_rejoin_work
);
710 static void team_mcast_rejoin_fini(struct team
*team
)
712 cancel_delayed_work_sync(&team
->mcast_rejoin
.dw
);
716 /************************
717 * Rx path frame handler
718 ************************/
720 /* note: already called with rcu_read_lock */
721 static rx_handler_result_t
team_handle_frame(struct sk_buff
**pskb
)
723 struct sk_buff
*skb
= *pskb
;
724 struct team_port
*port
;
726 rx_handler_result_t res
;
728 skb
= skb_share_check(skb
, GFP_ATOMIC
);
730 return RX_HANDLER_CONSUMED
;
734 port
= team_port_get_rcu(skb
->dev
);
736 if (!team_port_enabled(port
)) {
737 if (is_link_local_ether_addr(eth_hdr(skb
)->h_dest
))
738 /* link-local packets are mostly useful when stack receives them
739 * with the link they arrive on.
741 return RX_HANDLER_PASS
;
742 /* allow exact match delivery for disabled ports */
743 res
= RX_HANDLER_EXACT
;
745 res
= team
->ops
.receive(team
, port
, skb
);
747 if (res
== RX_HANDLER_ANOTHER
) {
748 struct team_pcpu_stats
*pcpu_stats
;
750 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
751 u64_stats_update_begin(&pcpu_stats
->syncp
);
752 u64_stats_inc(&pcpu_stats
->rx_packets
);
753 u64_stats_add(&pcpu_stats
->rx_bytes
, skb
->len
);
754 if (skb
->pkt_type
== PACKET_MULTICAST
)
755 u64_stats_inc(&pcpu_stats
->rx_multicast
);
756 u64_stats_update_end(&pcpu_stats
->syncp
);
758 skb
->dev
= team
->dev
;
759 } else if (res
== RX_HANDLER_EXACT
) {
760 this_cpu_inc(team
->pcpu_stats
->rx_nohandler
);
762 this_cpu_inc(team
->pcpu_stats
->rx_dropped
);
769 /*************************************
770 * Multiqueue Tx port select override
771 *************************************/
773 static int team_queue_override_init(struct team
*team
)
775 struct list_head
*listarr
;
776 unsigned int queue_cnt
= team
->dev
->num_tx_queues
- 1;
781 listarr
= kmalloc_array(queue_cnt
, sizeof(struct list_head
),
785 team
->qom_lists
= listarr
;
786 for (i
= 0; i
< queue_cnt
; i
++)
787 INIT_LIST_HEAD(listarr
++);
791 static void team_queue_override_fini(struct team
*team
)
793 kfree(team
->qom_lists
);
796 static struct list_head
*__team_get_qom_list(struct team
*team
, u16 queue_id
)
798 return &team
->qom_lists
[queue_id
- 1];
802 * note: already called with rcu_read_lock
804 static bool team_queue_override_transmit(struct team
*team
, struct sk_buff
*skb
)
806 struct list_head
*qom_list
;
807 struct team_port
*port
;
809 if (!team
->queue_override_enabled
|| !skb
->queue_mapping
)
811 qom_list
= __team_get_qom_list(team
, skb
->queue_mapping
);
812 list_for_each_entry_rcu(port
, qom_list
, qom_list
) {
813 if (!team_dev_queue_xmit(team
, port
, skb
))
819 static void __team_queue_override_port_del(struct team
*team
,
820 struct team_port
*port
)
824 list_del_rcu(&port
->qom_list
);
827 static bool team_queue_override_port_has_gt_prio_than(struct team_port
*port
,
828 struct team_port
*cur
)
830 if (port
->priority
< cur
->priority
)
832 if (port
->priority
> cur
->priority
)
834 if (port
->index
< cur
->index
)
839 static void __team_queue_override_port_add(struct team
*team
,
840 struct team_port
*port
)
842 struct team_port
*cur
;
843 struct list_head
*qom_list
;
844 struct list_head
*node
;
848 qom_list
= __team_get_qom_list(team
, port
->queue_id
);
850 list_for_each_entry(cur
, qom_list
, qom_list
) {
851 if (team_queue_override_port_has_gt_prio_than(port
, cur
))
853 node
= &cur
->qom_list
;
855 list_add_tail_rcu(&port
->qom_list
, node
);
858 static void __team_queue_override_enabled_check(struct team
*team
)
860 struct team_port
*port
;
861 bool enabled
= false;
863 list_for_each_entry(port
, &team
->port_list
, list
) {
864 if (port
->queue_id
) {
869 if (enabled
== team
->queue_override_enabled
)
871 netdev_dbg(team
->dev
, "%s queue override\n",
872 enabled
? "Enabling" : "Disabling");
873 team
->queue_override_enabled
= enabled
;
876 static void team_queue_override_port_prio_changed(struct team
*team
,
877 struct team_port
*port
)
879 if (!port
->queue_id
|| team_port_enabled(port
))
881 __team_queue_override_port_del(team
, port
);
882 __team_queue_override_port_add(team
, port
);
883 __team_queue_override_enabled_check(team
);
886 static void team_queue_override_port_change_queue_id(struct team
*team
,
887 struct team_port
*port
,
890 if (team_port_enabled(port
)) {
891 __team_queue_override_port_del(team
, port
);
892 port
->queue_id
= new_queue_id
;
893 __team_queue_override_port_add(team
, port
);
894 __team_queue_override_enabled_check(team
);
896 port
->queue_id
= new_queue_id
;
900 static void team_queue_override_port_add(struct team
*team
,
901 struct team_port
*port
)
903 __team_queue_override_port_add(team
, port
);
904 __team_queue_override_enabled_check(team
);
907 static void team_queue_override_port_del(struct team
*team
,
908 struct team_port
*port
)
910 __team_queue_override_port_del(team
, port
);
911 __team_queue_override_enabled_check(team
);
919 static bool team_port_find(const struct team
*team
,
920 const struct team_port
*port
)
922 struct team_port
*cur
;
924 list_for_each_entry(cur
, &team
->port_list
, list
)
931 * Enable/disable port by adding to enabled port hashlist and setting
932 * port->index (Might be racy so reader could see incorrect ifindex when
933 * processing a flying packet, but that is not a problem). Write guarded
936 static void team_port_enable(struct team
*team
,
937 struct team_port
*port
)
939 if (team_port_enabled(port
))
941 port
->index
= team
->en_port_count
++;
942 hlist_add_head_rcu(&port
->hlist
,
943 team_port_index_hash(team
, port
->index
));
944 team_adjust_ops(team
);
945 team_queue_override_port_add(team
, port
);
946 if (team
->ops
.port_enabled
)
947 team
->ops
.port_enabled(team
, port
);
948 team_notify_peers(team
);
949 team_mcast_rejoin(team
);
950 team_lower_state_changed(port
);
953 static void __reconstruct_port_hlist(struct team
*team
, int rm_index
)
956 struct team_port
*port
;
958 for (i
= rm_index
+ 1; i
< team
->en_port_count
; i
++) {
959 port
= team_get_port_by_index(team
, i
);
960 hlist_del_rcu(&port
->hlist
);
962 hlist_add_head_rcu(&port
->hlist
,
963 team_port_index_hash(team
, port
->index
));
967 static void team_port_disable(struct team
*team
,
968 struct team_port
*port
)
970 if (!team_port_enabled(port
))
972 if (team
->ops
.port_disabled
)
973 team
->ops
.port_disabled(team
, port
);
974 hlist_del_rcu(&port
->hlist
);
975 __reconstruct_port_hlist(team
, port
->index
);
977 team
->en_port_count
--;
978 team_queue_override_port_del(team
, port
);
979 team_adjust_ops(team
);
980 team_lower_state_changed(port
);
983 #define TEAM_VLAN_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
984 NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE | \
985 NETIF_F_HIGHDMA | NETIF_F_LRO)
987 #define TEAM_ENC_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
988 NETIF_F_RXCSUM | NETIF_F_GSO_SOFTWARE)
990 static void __team_compute_features(struct team
*team
)
992 struct team_port
*port
;
993 netdev_features_t vlan_features
= TEAM_VLAN_FEATURES
&
995 netdev_features_t enc_features
= TEAM_ENC_FEATURES
;
996 unsigned short max_hard_header_len
= ETH_HLEN
;
997 unsigned int dst_release_flag
= IFF_XMIT_DST_RELEASE
|
998 IFF_XMIT_DST_RELEASE_PERM
;
1001 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1002 vlan_features
= netdev_increment_features(vlan_features
,
1003 port
->dev
->vlan_features
,
1004 TEAM_VLAN_FEATURES
);
1006 netdev_increment_features(enc_features
,
1007 port
->dev
->hw_enc_features
,
1011 dst_release_flag
&= port
->dev
->priv_flags
;
1012 if (port
->dev
->hard_header_len
> max_hard_header_len
)
1013 max_hard_header_len
= port
->dev
->hard_header_len
;
1017 team
->dev
->vlan_features
= vlan_features
;
1018 team
->dev
->hw_enc_features
= enc_features
| NETIF_F_GSO_ENCAP_ALL
|
1019 NETIF_F_HW_VLAN_CTAG_TX
|
1020 NETIF_F_HW_VLAN_STAG_TX
;
1021 team
->dev
->hard_header_len
= max_hard_header_len
;
1023 team
->dev
->priv_flags
&= ~IFF_XMIT_DST_RELEASE
;
1024 if (dst_release_flag
== (IFF_XMIT_DST_RELEASE
| IFF_XMIT_DST_RELEASE_PERM
))
1025 team
->dev
->priv_flags
|= IFF_XMIT_DST_RELEASE
;
1028 static void team_compute_features(struct team
*team
)
1030 __team_compute_features(team
);
1031 netdev_change_features(team
->dev
);
1034 static int team_port_enter(struct team
*team
, struct team_port
*port
)
1038 dev_hold(team
->dev
);
1039 if (team
->ops
.port_enter
) {
1040 err
= team
->ops
.port_enter(team
, port
);
1042 netdev_err(team
->dev
, "Device %s failed to enter team mode\n",
1044 goto err_port_enter
;
1056 static void team_port_leave(struct team
*team
, struct team_port
*port
)
1058 if (team
->ops
.port_leave
)
1059 team
->ops
.port_leave(team
, port
);
1063 #ifdef CONFIG_NET_POLL_CONTROLLER
1064 static int __team_port_enable_netpoll(struct team_port
*port
)
1069 np
= kzalloc(sizeof(*np
), GFP_KERNEL
);
1073 err
= __netpoll_setup(np
, port
->dev
);
1082 static int team_port_enable_netpoll(struct team_port
*port
)
1084 if (!port
->team
->dev
->npinfo
)
1087 return __team_port_enable_netpoll(port
);
1090 static void team_port_disable_netpoll(struct team_port
*port
)
1092 struct netpoll
*np
= port
->np
;
1101 static int team_port_enable_netpoll(struct team_port
*port
)
1105 static void team_port_disable_netpoll(struct team_port
*port
)
1110 static int team_upper_dev_link(struct team
*team
, struct team_port
*port
,
1111 struct netlink_ext_ack
*extack
)
1113 struct netdev_lag_upper_info lag_upper_info
;
1116 lag_upper_info
.tx_type
= team
->mode
->lag_tx_type
;
1117 lag_upper_info
.hash_type
= NETDEV_LAG_HASH_UNKNOWN
;
1118 err
= netdev_master_upper_dev_link(port
->dev
, team
->dev
, NULL
,
1119 &lag_upper_info
, extack
);
1122 port
->dev
->priv_flags
|= IFF_TEAM_PORT
;
1126 static void team_upper_dev_unlink(struct team
*team
, struct team_port
*port
)
1128 netdev_upper_dev_unlink(port
->dev
, team
->dev
);
1129 port
->dev
->priv_flags
&= ~IFF_TEAM_PORT
;
1132 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
);
1133 static int team_dev_type_check_change(struct net_device
*dev
,
1134 struct net_device
*port_dev
);
1136 static int team_port_add(struct team
*team
, struct net_device
*port_dev
,
1137 struct netlink_ext_ack
*extack
)
1139 struct net_device
*dev
= team
->dev
;
1140 struct team_port
*port
;
1141 char *portname
= port_dev
->name
;
1144 if (port_dev
->flags
& IFF_LOOPBACK
) {
1145 NL_SET_ERR_MSG(extack
, "Loopback device can't be added as a team port");
1146 netdev_err(dev
, "Device %s is loopback device. Loopback devices can't be added as a team port\n",
1151 if (netif_is_team_port(port_dev
)) {
1152 NL_SET_ERR_MSG(extack
, "Device is already a port of a team device");
1153 netdev_err(dev
, "Device %s is already a port "
1154 "of a team device\n", portname
);
1158 if (dev
== port_dev
) {
1159 NL_SET_ERR_MSG(extack
, "Cannot enslave team device to itself");
1160 netdev_err(dev
, "Cannot enslave team device to itself\n");
1164 if (netdev_has_upper_dev(dev
, port_dev
)) {
1165 NL_SET_ERR_MSG(extack
, "Device is already an upper device of the team interface");
1166 netdev_err(dev
, "Device %s is already an upper device of the team interface\n",
1171 if (port_dev
->features
& NETIF_F_VLAN_CHALLENGED
&&
1172 vlan_uses_dev(dev
)) {
1173 NL_SET_ERR_MSG(extack
, "Device is VLAN challenged and team device has VLAN set up");
1174 netdev_err(dev
, "Device %s is VLAN challenged and team device has VLAN set up\n",
1179 err
= team_dev_type_check_change(dev
, port_dev
);
1183 if (port_dev
->flags
& IFF_UP
) {
1184 NL_SET_ERR_MSG(extack
, "Device is up. Set it down before adding it as a team port");
1185 netdev_err(dev
, "Device %s is up. Set it down before adding it as a team port\n",
1190 port
= kzalloc(sizeof(struct team_port
) + team
->mode
->port_priv_size
,
1195 port
->dev
= port_dev
;
1197 INIT_LIST_HEAD(&port
->qom_list
);
1199 port
->orig
.mtu
= port_dev
->mtu
;
1200 err
= dev_set_mtu(port_dev
, dev
->mtu
);
1202 netdev_dbg(dev
, "Error %d calling dev_set_mtu\n", err
);
1206 memcpy(port
->orig
.dev_addr
, port_dev
->dev_addr
, port_dev
->addr_len
);
1208 err
= team_port_enter(team
, port
);
1210 netdev_err(dev
, "Device %s failed to enter team mode\n",
1212 goto err_port_enter
;
1215 err
= dev_open(port_dev
, extack
);
1217 netdev_dbg(dev
, "Device %s opening failed\n",
1222 err
= vlan_vids_add_by_dev(port_dev
, dev
);
1224 netdev_err(dev
, "Failed to add vlan ids to device %s\n",
1229 err
= team_port_enable_netpoll(port
);
1231 netdev_err(dev
, "Failed to enable netpoll on device %s\n",
1233 goto err_enable_netpoll
;
1236 if (!(dev
->features
& NETIF_F_LRO
))
1237 dev_disable_lro(port_dev
);
1239 err
= netdev_rx_handler_register(port_dev
, team_handle_frame
,
1242 netdev_err(dev
, "Device %s failed to register rx_handler\n",
1244 goto err_handler_register
;
1247 err
= team_upper_dev_link(team
, port
, extack
);
1249 netdev_err(dev
, "Device %s failed to set upper link\n",
1251 goto err_set_upper_link
;
1254 err
= __team_option_inst_add_port(team
, port
);
1256 netdev_err(dev
, "Device %s failed to add per-port options\n",
1258 goto err_option_port_add
;
1261 /* set promiscuity level to new slave */
1262 if (dev
->flags
& IFF_PROMISC
) {
1263 err
= dev_set_promiscuity(port_dev
, 1);
1265 goto err_set_slave_promisc
;
1268 /* set allmulti level to new slave */
1269 if (dev
->flags
& IFF_ALLMULTI
) {
1270 err
= dev_set_allmulti(port_dev
, 1);
1272 if (dev
->flags
& IFF_PROMISC
)
1273 dev_set_promiscuity(port_dev
, -1);
1274 goto err_set_slave_promisc
;
1278 if (dev
->flags
& IFF_UP
) {
1279 netif_addr_lock_bh(dev
);
1280 dev_uc_sync_multiple(port_dev
, dev
);
1281 dev_mc_sync_multiple(port_dev
, dev
);
1282 netif_addr_unlock_bh(dev
);
1286 list_add_tail_rcu(&port
->list
, &team
->port_list
);
1287 team_port_enable(team
, port
);
1288 __team_compute_features(team
);
1289 __team_port_change_port_added(port
, !!netif_oper_up(port_dev
));
1290 __team_options_change_check(team
);
1292 netdev_info(dev
, "Port device %s added\n", portname
);
1296 err_set_slave_promisc
:
1297 __team_option_inst_del_port(team
, port
);
1299 err_option_port_add
:
1300 team_upper_dev_unlink(team
, port
);
1303 netdev_rx_handler_unregister(port_dev
);
1305 err_handler_register
:
1306 team_port_disable_netpoll(port
);
1309 vlan_vids_del_by_dev(port_dev
, dev
);
1312 dev_close(port_dev
);
1315 team_port_leave(team
, port
);
1316 team_port_set_orig_dev_addr(port
);
1319 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1327 static void __team_port_change_port_removed(struct team_port
*port
);
1329 static int team_port_del(struct team
*team
, struct net_device
*port_dev
)
1331 struct net_device
*dev
= team
->dev
;
1332 struct team_port
*port
;
1333 char *portname
= port_dev
->name
;
1335 port
= team_port_get_rtnl(port_dev
);
1336 if (!port
|| !team_port_find(team
, port
)) {
1337 netdev_err(dev
, "Device %s does not act as a port of this team\n",
1342 team_port_disable(team
, port
);
1343 list_del_rcu(&port
->list
);
1345 if (dev
->flags
& IFF_PROMISC
)
1346 dev_set_promiscuity(port_dev
, -1);
1347 if (dev
->flags
& IFF_ALLMULTI
)
1348 dev_set_allmulti(port_dev
, -1);
1350 team_upper_dev_unlink(team
, port
);
1351 netdev_rx_handler_unregister(port_dev
);
1352 team_port_disable_netpoll(port
);
1353 vlan_vids_del_by_dev(port_dev
, dev
);
1354 if (dev
->flags
& IFF_UP
) {
1355 dev_uc_unsync(port_dev
, dev
);
1356 dev_mc_unsync(port_dev
, dev
);
1358 dev_close(port_dev
);
1359 team_port_leave(team
, port
);
1361 __team_option_inst_mark_removed_port(team
, port
);
1362 __team_options_change_check(team
);
1363 __team_option_inst_del_port(team
, port
);
1364 __team_port_change_port_removed(port
);
1366 team_port_set_orig_dev_addr(port
);
1367 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1368 kfree_rcu(port
, rcu
);
1369 netdev_info(dev
, "Port device %s removed\n", portname
);
1370 __team_compute_features(team
);
1380 static void team_mode_option_get(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1382 ctx
->data
.str_val
= team
->mode
->kind
;
1385 static int team_mode_option_set(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1387 return team_change_mode(team
, ctx
->data
.str_val
);
1390 static void team_notify_peers_count_get(struct team
*team
,
1391 struct team_gsetter_ctx
*ctx
)
1393 ctx
->data
.u32_val
= team
->notify_peers
.count
;
1396 static int team_notify_peers_count_set(struct team
*team
,
1397 struct team_gsetter_ctx
*ctx
)
1399 team
->notify_peers
.count
= ctx
->data
.u32_val
;
1403 static void team_notify_peers_interval_get(struct team
*team
,
1404 struct team_gsetter_ctx
*ctx
)
1406 ctx
->data
.u32_val
= team
->notify_peers
.interval
;
1409 static int team_notify_peers_interval_set(struct team
*team
,
1410 struct team_gsetter_ctx
*ctx
)
1412 team
->notify_peers
.interval
= ctx
->data
.u32_val
;
1416 static void team_mcast_rejoin_count_get(struct team
*team
,
1417 struct team_gsetter_ctx
*ctx
)
1419 ctx
->data
.u32_val
= team
->mcast_rejoin
.count
;
1422 static int team_mcast_rejoin_count_set(struct team
*team
,
1423 struct team_gsetter_ctx
*ctx
)
1425 team
->mcast_rejoin
.count
= ctx
->data
.u32_val
;
1429 static void team_mcast_rejoin_interval_get(struct team
*team
,
1430 struct team_gsetter_ctx
*ctx
)
1432 ctx
->data
.u32_val
= team
->mcast_rejoin
.interval
;
1435 static int team_mcast_rejoin_interval_set(struct team
*team
,
1436 struct team_gsetter_ctx
*ctx
)
1438 team
->mcast_rejoin
.interval
= ctx
->data
.u32_val
;
1442 static void team_port_en_option_get(struct team
*team
,
1443 struct team_gsetter_ctx
*ctx
)
1445 struct team_port
*port
= ctx
->info
->port
;
1447 ctx
->data
.bool_val
= team_port_enabled(port
);
1450 static int team_port_en_option_set(struct team
*team
,
1451 struct team_gsetter_ctx
*ctx
)
1453 struct team_port
*port
= ctx
->info
->port
;
1455 if (ctx
->data
.bool_val
)
1456 team_port_enable(team
, port
);
1458 team_port_disable(team
, port
);
1462 static void team_user_linkup_option_get(struct team
*team
,
1463 struct team_gsetter_ctx
*ctx
)
1465 struct team_port
*port
= ctx
->info
->port
;
1467 ctx
->data
.bool_val
= port
->user
.linkup
;
1470 static void __team_carrier_check(struct team
*team
);
1472 static int team_user_linkup_option_set(struct team
*team
,
1473 struct team_gsetter_ctx
*ctx
)
1475 struct team_port
*port
= ctx
->info
->port
;
1477 port
->user
.linkup
= ctx
->data
.bool_val
;
1478 team_refresh_port_linkup(port
);
1479 __team_carrier_check(port
->team
);
1483 static void team_user_linkup_en_option_get(struct team
*team
,
1484 struct team_gsetter_ctx
*ctx
)
1486 struct team_port
*port
= ctx
->info
->port
;
1488 ctx
->data
.bool_val
= port
->user
.linkup_enabled
;
1491 static int team_user_linkup_en_option_set(struct team
*team
,
1492 struct team_gsetter_ctx
*ctx
)
1494 struct team_port
*port
= ctx
->info
->port
;
1496 port
->user
.linkup_enabled
= ctx
->data
.bool_val
;
1497 team_refresh_port_linkup(port
);
1498 __team_carrier_check(port
->team
);
1502 static void team_priority_option_get(struct team
*team
,
1503 struct team_gsetter_ctx
*ctx
)
1505 struct team_port
*port
= ctx
->info
->port
;
1507 ctx
->data
.s32_val
= port
->priority
;
1510 static int team_priority_option_set(struct team
*team
,
1511 struct team_gsetter_ctx
*ctx
)
1513 struct team_port
*port
= ctx
->info
->port
;
1514 s32 priority
= ctx
->data
.s32_val
;
1516 if (port
->priority
== priority
)
1518 port
->priority
= priority
;
1519 team_queue_override_port_prio_changed(team
, port
);
1523 static void team_queue_id_option_get(struct team
*team
,
1524 struct team_gsetter_ctx
*ctx
)
1526 struct team_port
*port
= ctx
->info
->port
;
1528 ctx
->data
.u32_val
= port
->queue_id
;
1531 static int team_queue_id_option_set(struct team
*team
,
1532 struct team_gsetter_ctx
*ctx
)
1534 struct team_port
*port
= ctx
->info
->port
;
1535 u16 new_queue_id
= ctx
->data
.u32_val
;
1537 if (port
->queue_id
== new_queue_id
)
1539 if (new_queue_id
>= team
->dev
->real_num_tx_queues
)
1541 team_queue_override_port_change_queue_id(team
, port
, new_queue_id
);
1545 static const struct team_option team_options
[] = {
1548 .type
= TEAM_OPTION_TYPE_STRING
,
1549 .getter
= team_mode_option_get
,
1550 .setter
= team_mode_option_set
,
1553 .name
= "notify_peers_count",
1554 .type
= TEAM_OPTION_TYPE_U32
,
1555 .getter
= team_notify_peers_count_get
,
1556 .setter
= team_notify_peers_count_set
,
1559 .name
= "notify_peers_interval",
1560 .type
= TEAM_OPTION_TYPE_U32
,
1561 .getter
= team_notify_peers_interval_get
,
1562 .setter
= team_notify_peers_interval_set
,
1565 .name
= "mcast_rejoin_count",
1566 .type
= TEAM_OPTION_TYPE_U32
,
1567 .getter
= team_mcast_rejoin_count_get
,
1568 .setter
= team_mcast_rejoin_count_set
,
1571 .name
= "mcast_rejoin_interval",
1572 .type
= TEAM_OPTION_TYPE_U32
,
1573 .getter
= team_mcast_rejoin_interval_get
,
1574 .setter
= team_mcast_rejoin_interval_set
,
1578 .type
= TEAM_OPTION_TYPE_BOOL
,
1580 .getter
= team_port_en_option_get
,
1581 .setter
= team_port_en_option_set
,
1584 .name
= "user_linkup",
1585 .type
= TEAM_OPTION_TYPE_BOOL
,
1587 .getter
= team_user_linkup_option_get
,
1588 .setter
= team_user_linkup_option_set
,
1591 .name
= "user_linkup_enabled",
1592 .type
= TEAM_OPTION_TYPE_BOOL
,
1594 .getter
= team_user_linkup_en_option_get
,
1595 .setter
= team_user_linkup_en_option_set
,
1599 .type
= TEAM_OPTION_TYPE_S32
,
1601 .getter
= team_priority_option_get
,
1602 .setter
= team_priority_option_set
,
1606 .type
= TEAM_OPTION_TYPE_U32
,
1608 .getter
= team_queue_id_option_get
,
1609 .setter
= team_queue_id_option_set
,
1614 static int team_init(struct net_device
*dev
)
1616 struct team
*team
= netdev_priv(dev
);
1621 team_set_no_mode(team
);
1622 team
->notifier_ctx
= false;
1624 team
->pcpu_stats
= netdev_alloc_pcpu_stats(struct team_pcpu_stats
);
1625 if (!team
->pcpu_stats
)
1628 for (i
= 0; i
< TEAM_PORT_HASHENTRIES
; i
++)
1629 INIT_HLIST_HEAD(&team
->en_port_hlist
[i
]);
1630 INIT_LIST_HEAD(&team
->port_list
);
1631 err
= team_queue_override_init(team
);
1633 goto err_team_queue_override_init
;
1635 team_adjust_ops(team
);
1637 INIT_LIST_HEAD(&team
->option_list
);
1638 INIT_LIST_HEAD(&team
->option_inst_list
);
1640 team_notify_peers_init(team
);
1641 team_mcast_rejoin_init(team
);
1643 err
= team_options_register(team
, team_options
, ARRAY_SIZE(team_options
));
1645 goto err_options_register
;
1646 netif_carrier_off(dev
);
1648 lockdep_register_key(&team
->team_lock_key
);
1649 __mutex_init(&team
->lock
, "team->team_lock_key", &team
->team_lock_key
);
1650 netdev_lockdep_set_classes(dev
);
1654 err_options_register
:
1655 team_mcast_rejoin_fini(team
);
1656 team_notify_peers_fini(team
);
1657 team_queue_override_fini(team
);
1658 err_team_queue_override_init
:
1659 free_percpu(team
->pcpu_stats
);
1664 static void team_uninit(struct net_device
*dev
)
1666 struct team
*team
= netdev_priv(dev
);
1667 struct team_port
*port
;
1668 struct team_port
*tmp
;
1670 mutex_lock(&team
->lock
);
1671 list_for_each_entry_safe(port
, tmp
, &team
->port_list
, list
)
1672 team_port_del(team
, port
->dev
);
1674 __team_change_mode(team
, NULL
); /* cleanup */
1675 __team_options_unregister(team
, team_options
, ARRAY_SIZE(team_options
));
1676 team_mcast_rejoin_fini(team
);
1677 team_notify_peers_fini(team
);
1678 team_queue_override_fini(team
);
1679 mutex_unlock(&team
->lock
);
1680 netdev_change_features(dev
);
1681 lockdep_unregister_key(&team
->team_lock_key
);
1684 static void team_destructor(struct net_device
*dev
)
1686 struct team
*team
= netdev_priv(dev
);
1688 free_percpu(team
->pcpu_stats
);
1691 static int team_open(struct net_device
*dev
)
1696 static int team_close(struct net_device
*dev
)
1698 struct team
*team
= netdev_priv(dev
);
1699 struct team_port
*port
;
1701 list_for_each_entry(port
, &team
->port_list
, list
) {
1702 dev_uc_unsync(port
->dev
, dev
);
1703 dev_mc_unsync(port
->dev
, dev
);
1710 * note: already called with rcu_read_lock
1712 static netdev_tx_t
team_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1714 struct team
*team
= netdev_priv(dev
);
1716 unsigned int len
= skb
->len
;
1718 tx_success
= team_queue_override_transmit(team
, skb
);
1720 tx_success
= team
->ops
.transmit(team
, skb
);
1722 struct team_pcpu_stats
*pcpu_stats
;
1724 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
1725 u64_stats_update_begin(&pcpu_stats
->syncp
);
1726 u64_stats_inc(&pcpu_stats
->tx_packets
);
1727 u64_stats_add(&pcpu_stats
->tx_bytes
, len
);
1728 u64_stats_update_end(&pcpu_stats
->syncp
);
1730 this_cpu_inc(team
->pcpu_stats
->tx_dropped
);
1733 return NETDEV_TX_OK
;
1736 static u16
team_select_queue(struct net_device
*dev
, struct sk_buff
*skb
,
1737 struct net_device
*sb_dev
)
1740 * This helper function exists to help dev_pick_tx get the correct
1741 * destination queue. Using a helper function skips a call to
1742 * skb_tx_hash and will put the skbs in the queue we expect on their
1743 * way down to the team driver.
1745 u16 txq
= skb_rx_queue_recorded(skb
) ? skb_get_rx_queue(skb
) : 0;
1748 * Save the original txq to restore before passing to the driver
1750 qdisc_skb_cb(skb
)->slave_dev_queue_mapping
= skb
->queue_mapping
;
1752 if (unlikely(txq
>= dev
->real_num_tx_queues
)) {
1754 txq
-= dev
->real_num_tx_queues
;
1755 } while (txq
>= dev
->real_num_tx_queues
);
1760 static void team_change_rx_flags(struct net_device
*dev
, int change
)
1762 struct team
*team
= netdev_priv(dev
);
1763 struct team_port
*port
;
1767 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1768 if (change
& IFF_PROMISC
) {
1769 inc
= dev
->flags
& IFF_PROMISC
? 1 : -1;
1770 dev_set_promiscuity(port
->dev
, inc
);
1772 if (change
& IFF_ALLMULTI
) {
1773 inc
= dev
->flags
& IFF_ALLMULTI
? 1 : -1;
1774 dev_set_allmulti(port
->dev
, inc
);
1780 static void team_set_rx_mode(struct net_device
*dev
)
1782 struct team
*team
= netdev_priv(dev
);
1783 struct team_port
*port
;
1786 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1787 dev_uc_sync_multiple(port
->dev
, dev
);
1788 dev_mc_sync_multiple(port
->dev
, dev
);
1793 static int team_set_mac_address(struct net_device
*dev
, void *p
)
1795 struct sockaddr
*addr
= p
;
1796 struct team
*team
= netdev_priv(dev
);
1797 struct team_port
*port
;
1799 if (dev
->type
== ARPHRD_ETHER
&& !is_valid_ether_addr(addr
->sa_data
))
1800 return -EADDRNOTAVAIL
;
1801 dev_addr_set(dev
, addr
->sa_data
);
1802 mutex_lock(&team
->lock
);
1803 list_for_each_entry(port
, &team
->port_list
, list
)
1804 if (team
->ops
.port_change_dev_addr
)
1805 team
->ops
.port_change_dev_addr(team
, port
);
1806 mutex_unlock(&team
->lock
);
1810 static int team_change_mtu(struct net_device
*dev
, int new_mtu
)
1812 struct team
*team
= netdev_priv(dev
);
1813 struct team_port
*port
;
1817 * Alhough this is reader, it's guarded by team lock. It's not possible
1818 * to traverse list in reverse under rcu_read_lock
1820 mutex_lock(&team
->lock
);
1821 team
->port_mtu_change_allowed
= true;
1822 list_for_each_entry(port
, &team
->port_list
, list
) {
1823 err
= dev_set_mtu(port
->dev
, new_mtu
);
1825 netdev_err(dev
, "Device %s failed to change mtu",
1830 team
->port_mtu_change_allowed
= false;
1831 mutex_unlock(&team
->lock
);
1838 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1839 dev_set_mtu(port
->dev
, dev
->mtu
);
1840 team
->port_mtu_change_allowed
= false;
1841 mutex_unlock(&team
->lock
);
1847 team_get_stats64(struct net_device
*dev
, struct rtnl_link_stats64
*stats
)
1849 struct team
*team
= netdev_priv(dev
);
1850 struct team_pcpu_stats
*p
;
1851 u64 rx_packets
, rx_bytes
, rx_multicast
, tx_packets
, tx_bytes
;
1852 u32 rx_dropped
= 0, tx_dropped
= 0, rx_nohandler
= 0;
1856 for_each_possible_cpu(i
) {
1857 p
= per_cpu_ptr(team
->pcpu_stats
, i
);
1859 start
= u64_stats_fetch_begin(&p
->syncp
);
1860 rx_packets
= u64_stats_read(&p
->rx_packets
);
1861 rx_bytes
= u64_stats_read(&p
->rx_bytes
);
1862 rx_multicast
= u64_stats_read(&p
->rx_multicast
);
1863 tx_packets
= u64_stats_read(&p
->tx_packets
);
1864 tx_bytes
= u64_stats_read(&p
->tx_bytes
);
1865 } while (u64_stats_fetch_retry(&p
->syncp
, start
));
1867 stats
->rx_packets
+= rx_packets
;
1868 stats
->rx_bytes
+= rx_bytes
;
1869 stats
->multicast
+= rx_multicast
;
1870 stats
->tx_packets
+= tx_packets
;
1871 stats
->tx_bytes
+= tx_bytes
;
1873 * rx_dropped, tx_dropped & rx_nohandler are u32,
1874 * updated without syncp protection.
1876 rx_dropped
+= READ_ONCE(p
->rx_dropped
);
1877 tx_dropped
+= READ_ONCE(p
->tx_dropped
);
1878 rx_nohandler
+= READ_ONCE(p
->rx_nohandler
);
1880 stats
->rx_dropped
= rx_dropped
;
1881 stats
->tx_dropped
= tx_dropped
;
1882 stats
->rx_nohandler
= rx_nohandler
;
1885 static int team_vlan_rx_add_vid(struct net_device
*dev
, __be16 proto
, u16 vid
)
1887 struct team
*team
= netdev_priv(dev
);
1888 struct team_port
*port
;
1892 * Alhough this is reader, it's guarded by team lock. It's not possible
1893 * to traverse list in reverse under rcu_read_lock
1895 mutex_lock(&team
->lock
);
1896 list_for_each_entry(port
, &team
->port_list
, list
) {
1897 err
= vlan_vid_add(port
->dev
, proto
, vid
);
1901 mutex_unlock(&team
->lock
);
1906 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1907 vlan_vid_del(port
->dev
, proto
, vid
);
1908 mutex_unlock(&team
->lock
);
1913 static int team_vlan_rx_kill_vid(struct net_device
*dev
, __be16 proto
, u16 vid
)
1915 struct team
*team
= netdev_priv(dev
);
1916 struct team_port
*port
;
1918 mutex_lock(&team
->lock
);
1919 list_for_each_entry(port
, &team
->port_list
, list
)
1920 vlan_vid_del(port
->dev
, proto
, vid
);
1921 mutex_unlock(&team
->lock
);
1926 #ifdef CONFIG_NET_POLL_CONTROLLER
1927 static void team_poll_controller(struct net_device
*dev
)
1931 static void __team_netpoll_cleanup(struct team
*team
)
1933 struct team_port
*port
;
1935 list_for_each_entry(port
, &team
->port_list
, list
)
1936 team_port_disable_netpoll(port
);
1939 static void team_netpoll_cleanup(struct net_device
*dev
)
1941 struct team
*team
= netdev_priv(dev
);
1943 mutex_lock(&team
->lock
);
1944 __team_netpoll_cleanup(team
);
1945 mutex_unlock(&team
->lock
);
1948 static int team_netpoll_setup(struct net_device
*dev
,
1949 struct netpoll_info
*npifo
)
1951 struct team
*team
= netdev_priv(dev
);
1952 struct team_port
*port
;
1955 mutex_lock(&team
->lock
);
1956 list_for_each_entry(port
, &team
->port_list
, list
) {
1957 err
= __team_port_enable_netpoll(port
);
1959 __team_netpoll_cleanup(team
);
1963 mutex_unlock(&team
->lock
);
1968 static int team_add_slave(struct net_device
*dev
, struct net_device
*port_dev
,
1969 struct netlink_ext_ack
*extack
)
1971 struct team
*team
= netdev_priv(dev
);
1974 mutex_lock(&team
->lock
);
1975 err
= team_port_add(team
, port_dev
, extack
);
1976 mutex_unlock(&team
->lock
);
1979 netdev_change_features(dev
);
1984 static int team_del_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1986 struct team
*team
= netdev_priv(dev
);
1989 mutex_lock(&team
->lock
);
1990 err
= team_port_del(team
, port_dev
);
1991 mutex_unlock(&team
->lock
);
1996 if (netif_is_team_master(port_dev
)) {
1997 lockdep_unregister_key(&team
->team_lock_key
);
1998 lockdep_register_key(&team
->team_lock_key
);
1999 lockdep_set_class(&team
->lock
, &team
->team_lock_key
);
2001 netdev_change_features(dev
);
2006 static netdev_features_t
team_fix_features(struct net_device
*dev
,
2007 netdev_features_t features
)
2009 struct team_port
*port
;
2010 struct team
*team
= netdev_priv(dev
);
2011 netdev_features_t mask
;
2014 features
&= ~NETIF_F_ONE_FOR_ALL
;
2015 features
|= NETIF_F_ALL_FOR_ALL
;
2018 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
2019 features
= netdev_increment_features(features
,
2020 port
->dev
->features
,
2025 features
= netdev_add_tso_features(features
, mask
);
2030 static int team_change_carrier(struct net_device
*dev
, bool new_carrier
)
2032 struct team
*team
= netdev_priv(dev
);
2034 team
->user_carrier_enabled
= true;
2037 netif_carrier_on(dev
);
2039 netif_carrier_off(dev
);
2043 static const struct net_device_ops team_netdev_ops
= {
2044 .ndo_init
= team_init
,
2045 .ndo_uninit
= team_uninit
,
2046 .ndo_open
= team_open
,
2047 .ndo_stop
= team_close
,
2048 .ndo_start_xmit
= team_xmit
,
2049 .ndo_select_queue
= team_select_queue
,
2050 .ndo_change_rx_flags
= team_change_rx_flags
,
2051 .ndo_set_rx_mode
= team_set_rx_mode
,
2052 .ndo_set_mac_address
= team_set_mac_address
,
2053 .ndo_change_mtu
= team_change_mtu
,
2054 .ndo_get_stats64
= team_get_stats64
,
2055 .ndo_vlan_rx_add_vid
= team_vlan_rx_add_vid
,
2056 .ndo_vlan_rx_kill_vid
= team_vlan_rx_kill_vid
,
2057 #ifdef CONFIG_NET_POLL_CONTROLLER
2058 .ndo_poll_controller
= team_poll_controller
,
2059 .ndo_netpoll_setup
= team_netpoll_setup
,
2060 .ndo_netpoll_cleanup
= team_netpoll_cleanup
,
2062 .ndo_add_slave
= team_add_slave
,
2063 .ndo_del_slave
= team_del_slave
,
2064 .ndo_fix_features
= team_fix_features
,
2065 .ndo_change_carrier
= team_change_carrier
,
2066 .ndo_features_check
= passthru_features_check
,
2069 /***********************
2071 ***********************/
2073 static void team_ethtool_get_drvinfo(struct net_device
*dev
,
2074 struct ethtool_drvinfo
*drvinfo
)
2076 strscpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
2077 strscpy(drvinfo
->version
, UTS_RELEASE
, sizeof(drvinfo
->version
));
2080 static int team_ethtool_get_link_ksettings(struct net_device
*dev
,
2081 struct ethtool_link_ksettings
*cmd
)
2083 struct team
*team
= netdev_priv(dev
);
2084 unsigned long speed
= 0;
2085 struct team_port
*port
;
2087 cmd
->base
.duplex
= DUPLEX_UNKNOWN
;
2088 cmd
->base
.port
= PORT_OTHER
;
2091 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
2092 if (team_port_txable(port
)) {
2093 if (port
->state
.speed
!= SPEED_UNKNOWN
)
2094 speed
+= port
->state
.speed
;
2095 if (cmd
->base
.duplex
== DUPLEX_UNKNOWN
&&
2096 port
->state
.duplex
!= DUPLEX_UNKNOWN
)
2097 cmd
->base
.duplex
= port
->state
.duplex
;
2102 cmd
->base
.speed
= speed
? : SPEED_UNKNOWN
;
2107 static const struct ethtool_ops team_ethtool_ops
= {
2108 .get_drvinfo
= team_ethtool_get_drvinfo
,
2109 .get_link
= ethtool_op_get_link
,
2110 .get_link_ksettings
= team_ethtool_get_link_ksettings
,
2113 /***********************
2114 * rt netlink interface
2115 ***********************/
2117 static void team_setup_by_port(struct net_device
*dev
,
2118 struct net_device
*port_dev
)
2120 struct team
*team
= netdev_priv(dev
);
2122 if (port_dev
->type
== ARPHRD_ETHER
)
2123 dev
->header_ops
= team
->header_ops_cache
;
2125 dev
->header_ops
= port_dev
->header_ops
;
2126 dev
->type
= port_dev
->type
;
2127 dev
->hard_header_len
= port_dev
->hard_header_len
;
2128 dev
->needed_headroom
= port_dev
->needed_headroom
;
2129 dev
->addr_len
= port_dev
->addr_len
;
2130 dev
->mtu
= port_dev
->mtu
;
2131 memcpy(dev
->broadcast
, port_dev
->broadcast
, port_dev
->addr_len
);
2132 eth_hw_addr_inherit(dev
, port_dev
);
2134 if (port_dev
->flags
& IFF_POINTOPOINT
) {
2135 dev
->flags
&= ~(IFF_BROADCAST
| IFF_MULTICAST
);
2136 dev
->flags
|= (IFF_POINTOPOINT
| IFF_NOARP
);
2137 } else if ((port_dev
->flags
& (IFF_BROADCAST
| IFF_MULTICAST
)) ==
2138 (IFF_BROADCAST
| IFF_MULTICAST
)) {
2139 dev
->flags
|= (IFF_BROADCAST
| IFF_MULTICAST
);
2140 dev
->flags
&= ~(IFF_POINTOPOINT
| IFF_NOARP
);
2144 static int team_dev_type_check_change(struct net_device
*dev
,
2145 struct net_device
*port_dev
)
2147 struct team
*team
= netdev_priv(dev
);
2148 char *portname
= port_dev
->name
;
2151 if (dev
->type
== port_dev
->type
)
2153 if (!list_empty(&team
->port_list
)) {
2154 netdev_err(dev
, "Device %s is of different type\n", portname
);
2157 err
= call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE
, dev
);
2158 err
= notifier_to_errno(err
);
2160 netdev_err(dev
, "Refused to change device type\n");
2165 team_setup_by_port(dev
, port_dev
);
2166 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE
, dev
);
2170 static void team_setup(struct net_device
*dev
)
2172 struct team
*team
= netdev_priv(dev
);
2175 dev
->max_mtu
= ETH_MAX_MTU
;
2176 team
->header_ops_cache
= dev
->header_ops
;
2178 dev
->netdev_ops
= &team_netdev_ops
;
2179 dev
->ethtool_ops
= &team_ethtool_ops
;
2180 dev
->needs_free_netdev
= true;
2181 dev
->priv_destructor
= team_destructor
;
2182 dev
->priv_flags
&= ~(IFF_XMIT_DST_RELEASE
| IFF_TX_SKB_SHARING
);
2183 dev
->priv_flags
|= IFF_NO_QUEUE
;
2184 dev
->priv_flags
|= IFF_TEAM
;
2187 * Indicate we support unicast address filtering. That way core won't
2188 * bring us to promisc mode in case a unicast addr is added.
2189 * Let this up to underlay drivers.
2191 dev
->priv_flags
|= IFF_UNICAST_FLT
| IFF_LIVE_ADDR_CHANGE
;
2193 dev
->features
|= NETIF_F_LLTX
;
2194 dev
->features
|= NETIF_F_GRO
;
2196 /* Don't allow team devices to change network namespaces. */
2197 dev
->features
|= NETIF_F_NETNS_LOCAL
;
2199 dev
->hw_features
= TEAM_VLAN_FEATURES
|
2200 NETIF_F_HW_VLAN_CTAG_RX
|
2201 NETIF_F_HW_VLAN_CTAG_FILTER
|
2202 NETIF_F_HW_VLAN_STAG_RX
|
2203 NETIF_F_HW_VLAN_STAG_FILTER
;
2205 dev
->hw_features
|= NETIF_F_GSO_ENCAP_ALL
;
2206 dev
->features
|= dev
->hw_features
;
2207 dev
->features
|= NETIF_F_HW_VLAN_CTAG_TX
| NETIF_F_HW_VLAN_STAG_TX
;
2210 static int team_newlink(struct net
*src_net
, struct net_device
*dev
,
2211 struct nlattr
*tb
[], struct nlattr
*data
[],
2212 struct netlink_ext_ack
*extack
)
2214 if (tb
[IFLA_ADDRESS
] == NULL
)
2215 eth_hw_addr_random(dev
);
2217 return register_netdevice(dev
);
2220 static int team_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
2221 struct netlink_ext_ack
*extack
)
2223 if (tb
[IFLA_ADDRESS
]) {
2224 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
2226 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
2227 return -EADDRNOTAVAIL
;
2232 static unsigned int team_get_num_tx_queues(void)
2234 return TEAM_DEFAULT_NUM_TX_QUEUES
;
2237 static unsigned int team_get_num_rx_queues(void)
2239 return TEAM_DEFAULT_NUM_RX_QUEUES
;
2242 static struct rtnl_link_ops team_link_ops __read_mostly
= {
2244 .priv_size
= sizeof(struct team
),
2245 .setup
= team_setup
,
2246 .newlink
= team_newlink
,
2247 .validate
= team_validate
,
2248 .get_num_tx_queues
= team_get_num_tx_queues
,
2249 .get_num_rx_queues
= team_get_num_rx_queues
,
2253 /***********************************
2254 * Generic netlink custom interface
2255 ***********************************/
2257 static struct genl_family team_nl_family
;
2259 static const struct nla_policy team_nl_policy
[TEAM_ATTR_MAX
+ 1] = {
2260 [TEAM_ATTR_UNSPEC
] = { .type
= NLA_UNSPEC
, },
2261 [TEAM_ATTR_TEAM_IFINDEX
] = { .type
= NLA_U32
},
2262 [TEAM_ATTR_LIST_OPTION
] = { .type
= NLA_NESTED
},
2263 [TEAM_ATTR_LIST_PORT
] = { .type
= NLA_NESTED
},
2266 static const struct nla_policy
2267 team_nl_option_policy
[TEAM_ATTR_OPTION_MAX
+ 1] = {
2268 [TEAM_ATTR_OPTION_UNSPEC
] = { .type
= NLA_UNSPEC
, },
2269 [TEAM_ATTR_OPTION_NAME
] = {
2271 .len
= TEAM_STRING_MAX_LEN
,
2273 [TEAM_ATTR_OPTION_CHANGED
] = { .type
= NLA_FLAG
},
2274 [TEAM_ATTR_OPTION_TYPE
] = { .type
= NLA_U8
},
2275 [TEAM_ATTR_OPTION_DATA
] = { .type
= NLA_BINARY
},
2276 [TEAM_ATTR_OPTION_PORT_IFINDEX
] = { .type
= NLA_U32
},
2277 [TEAM_ATTR_OPTION_ARRAY_INDEX
] = { .type
= NLA_U32
},
2280 static int team_nl_cmd_noop(struct sk_buff
*skb
, struct genl_info
*info
)
2282 struct sk_buff
*msg
;
2286 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2290 hdr
= genlmsg_put(msg
, info
->snd_portid
, info
->snd_seq
,
2291 &team_nl_family
, 0, TEAM_CMD_NOOP
);
2297 genlmsg_end(msg
, hdr
);
2299 return genlmsg_unicast(genl_info_net(info
), msg
, info
->snd_portid
);
2308 * Netlink cmd functions should be locked by following two functions.
2309 * Since dev gets held here, that ensures dev won't disappear in between.
2311 static struct team
*team_nl_team_get(struct genl_info
*info
)
2313 struct net
*net
= genl_info_net(info
);
2315 struct net_device
*dev
;
2318 if (!info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
])
2321 ifindex
= nla_get_u32(info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
]);
2322 dev
= dev_get_by_index(net
, ifindex
);
2323 if (!dev
|| dev
->netdev_ops
!= &team_netdev_ops
) {
2328 team
= netdev_priv(dev
);
2329 mutex_lock(&team
->lock
);
2333 static void team_nl_team_put(struct team
*team
)
2335 mutex_unlock(&team
->lock
);
2339 typedef int team_nl_send_func_t(struct sk_buff
*skb
,
2340 struct team
*team
, u32 portid
);
2342 static int team_nl_send_unicast(struct sk_buff
*skb
, struct team
*team
, u32 portid
)
2344 return genlmsg_unicast(dev_net(team
->dev
), skb
, portid
);
2347 static int team_nl_fill_one_option_get(struct sk_buff
*skb
, struct team
*team
,
2348 struct team_option_inst
*opt_inst
)
2350 struct nlattr
*option_item
;
2351 struct team_option
*option
= opt_inst
->option
;
2352 struct team_option_inst_info
*opt_inst_info
= &opt_inst
->info
;
2353 struct team_gsetter_ctx ctx
;
2356 ctx
.info
= opt_inst_info
;
2357 err
= team_option_get(team
, opt_inst
, &ctx
);
2361 option_item
= nla_nest_start_noflag(skb
, TEAM_ATTR_ITEM_OPTION
);
2365 if (nla_put_string(skb
, TEAM_ATTR_OPTION_NAME
, option
->name
))
2367 if (opt_inst_info
->port
&&
2368 nla_put_u32(skb
, TEAM_ATTR_OPTION_PORT_IFINDEX
,
2369 opt_inst_info
->port
->dev
->ifindex
))
2371 if (opt_inst
->option
->array_size
&&
2372 nla_put_u32(skb
, TEAM_ATTR_OPTION_ARRAY_INDEX
,
2373 opt_inst_info
->array_index
))
2376 switch (option
->type
) {
2377 case TEAM_OPTION_TYPE_U32
:
2378 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_U32
))
2380 if (nla_put_u32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.u32_val
))
2383 case TEAM_OPTION_TYPE_STRING
:
2384 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_STRING
))
2386 if (nla_put_string(skb
, TEAM_ATTR_OPTION_DATA
,
2390 case TEAM_OPTION_TYPE_BINARY
:
2391 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_BINARY
))
2393 if (nla_put(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.bin_val
.len
,
2394 ctx
.data
.bin_val
.ptr
))
2397 case TEAM_OPTION_TYPE_BOOL
:
2398 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_FLAG
))
2400 if (ctx
.data
.bool_val
&&
2401 nla_put_flag(skb
, TEAM_ATTR_OPTION_DATA
))
2404 case TEAM_OPTION_TYPE_S32
:
2405 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_S32
))
2407 if (nla_put_s32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.s32_val
))
2413 if (opt_inst
->removed
&& nla_put_flag(skb
, TEAM_ATTR_OPTION_REMOVED
))
2415 if (opt_inst
->changed
) {
2416 if (nla_put_flag(skb
, TEAM_ATTR_OPTION_CHANGED
))
2418 opt_inst
->changed
= false;
2420 nla_nest_end(skb
, option_item
);
2424 nla_nest_cancel(skb
, option_item
);
2428 static int __send_and_alloc_skb(struct sk_buff
**pskb
,
2429 struct team
*team
, u32 portid
,
2430 team_nl_send_func_t
*send_func
)
2435 err
= send_func(*pskb
, team
, portid
);
2439 *pskb
= genlmsg_new(GENLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2445 static int team_nl_send_options_get(struct team
*team
, u32 portid
, u32 seq
,
2446 int flags
, team_nl_send_func_t
*send_func
,
2447 struct list_head
*sel_opt_inst_list
)
2449 struct nlattr
*option_list
;
2450 struct nlmsghdr
*nlh
;
2452 struct team_option_inst
*opt_inst
;
2454 struct sk_buff
*skb
= NULL
;
2458 opt_inst
= list_first_entry(sel_opt_inst_list
,
2459 struct team_option_inst
, tmp_list
);
2462 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2466 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2467 TEAM_CMD_OPTIONS_GET
);
2473 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2474 goto nla_put_failure
;
2475 option_list
= nla_nest_start_noflag(skb
, TEAM_ATTR_LIST_OPTION
);
2477 goto nla_put_failure
;
2481 list_for_each_entry_from(opt_inst
, sel_opt_inst_list
, tmp_list
) {
2482 err
= team_nl_fill_one_option_get(skb
, team
, opt_inst
);
2484 if (err
== -EMSGSIZE
) {
2495 nla_nest_end(skb
, option_list
);
2496 genlmsg_end(skb
, hdr
);
2501 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2503 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2509 return send_func(skb
, team
, portid
);
2518 static int team_nl_cmd_options_get(struct sk_buff
*skb
, struct genl_info
*info
)
2521 struct team_option_inst
*opt_inst
;
2523 LIST_HEAD(sel_opt_inst_list
);
2525 team
= team_nl_team_get(info
);
2529 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
)
2530 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2531 err
= team_nl_send_options_get(team
, info
->snd_portid
, info
->snd_seq
,
2532 NLM_F_ACK
, team_nl_send_unicast
,
2533 &sel_opt_inst_list
);
2535 team_nl_team_put(team
);
2540 static int team_nl_send_event_options_get(struct team
*team
,
2541 struct list_head
*sel_opt_inst_list
);
2543 static int team_nl_cmd_options_set(struct sk_buff
*skb
, struct genl_info
*info
)
2548 struct nlattr
*nl_option
;
2552 team
= team_nl_team_get(info
);
2559 if (!info
->attrs
[TEAM_ATTR_LIST_OPTION
]) {
2564 nla_for_each_nested(nl_option
, info
->attrs
[TEAM_ATTR_LIST_OPTION
], i
) {
2565 struct nlattr
*opt_attrs
[TEAM_ATTR_OPTION_MAX
+ 1];
2566 struct nlattr
*attr
;
2567 struct nlattr
*attr_data
;
2568 LIST_HEAD(opt_inst_list
);
2569 enum team_option_type opt_type
;
2570 int opt_port_ifindex
= 0; /* != 0 for per-port options */
2571 u32 opt_array_index
= 0;
2572 bool opt_is_array
= false;
2573 struct team_option_inst
*opt_inst
;
2575 bool opt_found
= false;
2577 if (nla_type(nl_option
) != TEAM_ATTR_ITEM_OPTION
) {
2581 err
= nla_parse_nested_deprecated(opt_attrs
,
2582 TEAM_ATTR_OPTION_MAX
,
2584 team_nl_option_policy
,
2588 if (!opt_attrs
[TEAM_ATTR_OPTION_NAME
] ||
2589 !opt_attrs
[TEAM_ATTR_OPTION_TYPE
]) {
2593 switch (nla_get_u8(opt_attrs
[TEAM_ATTR_OPTION_TYPE
])) {
2595 opt_type
= TEAM_OPTION_TYPE_U32
;
2598 opt_type
= TEAM_OPTION_TYPE_STRING
;
2601 opt_type
= TEAM_OPTION_TYPE_BINARY
;
2604 opt_type
= TEAM_OPTION_TYPE_BOOL
;
2607 opt_type
= TEAM_OPTION_TYPE_S32
;
2613 attr_data
= opt_attrs
[TEAM_ATTR_OPTION_DATA
];
2614 if (opt_type
!= TEAM_OPTION_TYPE_BOOL
&& !attr_data
) {
2619 opt_name
= nla_data(opt_attrs
[TEAM_ATTR_OPTION_NAME
]);
2620 attr
= opt_attrs
[TEAM_ATTR_OPTION_PORT_IFINDEX
];
2622 opt_port_ifindex
= nla_get_u32(attr
);
2624 attr
= opt_attrs
[TEAM_ATTR_OPTION_ARRAY_INDEX
];
2626 opt_is_array
= true;
2627 opt_array_index
= nla_get_u32(attr
);
2630 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2631 struct team_option
*option
= opt_inst
->option
;
2632 struct team_gsetter_ctx ctx
;
2633 struct team_option_inst_info
*opt_inst_info
;
2636 opt_inst_info
= &opt_inst
->info
;
2637 tmp_ifindex
= opt_inst_info
->port
?
2638 opt_inst_info
->port
->dev
->ifindex
: 0;
2639 if (option
->type
!= opt_type
||
2640 strcmp(option
->name
, opt_name
) ||
2641 tmp_ifindex
!= opt_port_ifindex
||
2642 (option
->array_size
&& !opt_is_array
) ||
2643 opt_inst_info
->array_index
!= opt_array_index
)
2646 ctx
.info
= opt_inst_info
;
2648 case TEAM_OPTION_TYPE_U32
:
2649 ctx
.data
.u32_val
= nla_get_u32(attr_data
);
2651 case TEAM_OPTION_TYPE_STRING
:
2652 if (nla_len(attr_data
) > TEAM_STRING_MAX_LEN
) {
2656 ctx
.data
.str_val
= nla_data(attr_data
);
2658 case TEAM_OPTION_TYPE_BINARY
:
2659 ctx
.data
.bin_val
.len
= nla_len(attr_data
);
2660 ctx
.data
.bin_val
.ptr
= nla_data(attr_data
);
2662 case TEAM_OPTION_TYPE_BOOL
:
2663 ctx
.data
.bool_val
= attr_data
? true : false;
2665 case TEAM_OPTION_TYPE_S32
:
2666 ctx
.data
.s32_val
= nla_get_s32(attr_data
);
2671 err
= team_option_set(team
, opt_inst
, &ctx
);
2674 opt_inst
->changed
= true;
2675 list_add(&opt_inst
->tmp_list
, &opt_inst_list
);
2682 err
= team_nl_send_event_options_get(team
, &opt_inst_list
);
2688 team_nl_team_put(team
);
2694 static int team_nl_fill_one_port_get(struct sk_buff
*skb
,
2695 struct team_port
*port
)
2697 struct nlattr
*port_item
;
2699 port_item
= nla_nest_start_noflag(skb
, TEAM_ATTR_ITEM_PORT
);
2702 if (nla_put_u32(skb
, TEAM_ATTR_PORT_IFINDEX
, port
->dev
->ifindex
))
2704 if (port
->changed
) {
2705 if (nla_put_flag(skb
, TEAM_ATTR_PORT_CHANGED
))
2707 port
->changed
= false;
2709 if ((port
->removed
&&
2710 nla_put_flag(skb
, TEAM_ATTR_PORT_REMOVED
)) ||
2711 (port
->state
.linkup
&&
2712 nla_put_flag(skb
, TEAM_ATTR_PORT_LINKUP
)) ||
2713 nla_put_u32(skb
, TEAM_ATTR_PORT_SPEED
, port
->state
.speed
) ||
2714 nla_put_u8(skb
, TEAM_ATTR_PORT_DUPLEX
, port
->state
.duplex
))
2716 nla_nest_end(skb
, port_item
);
2720 nla_nest_cancel(skb
, port_item
);
2724 static int team_nl_send_port_list_get(struct team
*team
, u32 portid
, u32 seq
,
2725 int flags
, team_nl_send_func_t
*send_func
,
2726 struct team_port
*one_port
)
2728 struct nlattr
*port_list
;
2729 struct nlmsghdr
*nlh
;
2731 struct team_port
*port
;
2733 struct sk_buff
*skb
= NULL
;
2737 port
= list_first_entry_or_null(&team
->port_list
,
2738 struct team_port
, list
);
2741 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2745 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2746 TEAM_CMD_PORT_LIST_GET
);
2752 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2753 goto nla_put_failure
;
2754 port_list
= nla_nest_start_noflag(skb
, TEAM_ATTR_LIST_PORT
);
2756 goto nla_put_failure
;
2761 /* If one port is selected, called wants to send port list containing
2762 * only this port. Otherwise go through all listed ports and send all
2765 err
= team_nl_fill_one_port_get(skb
, one_port
);
2769 list_for_each_entry_from(port
, &team
->port_list
, list
) {
2770 err
= team_nl_fill_one_port_get(skb
, port
);
2772 if (err
== -EMSGSIZE
) {
2784 nla_nest_end(skb
, port_list
);
2785 genlmsg_end(skb
, hdr
);
2790 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2792 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2798 return send_func(skb
, team
, portid
);
2807 static int team_nl_cmd_port_list_get(struct sk_buff
*skb
,
2808 struct genl_info
*info
)
2813 team
= team_nl_team_get(info
);
2817 err
= team_nl_send_port_list_get(team
, info
->snd_portid
, info
->snd_seq
,
2818 NLM_F_ACK
, team_nl_send_unicast
, NULL
);
2820 team_nl_team_put(team
);
2825 static const struct genl_small_ops team_nl_ops
[] = {
2827 .cmd
= TEAM_CMD_NOOP
,
2828 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
2829 .doit
= team_nl_cmd_noop
,
2832 .cmd
= TEAM_CMD_OPTIONS_SET
,
2833 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
2834 .doit
= team_nl_cmd_options_set
,
2835 .flags
= GENL_ADMIN_PERM
,
2838 .cmd
= TEAM_CMD_OPTIONS_GET
,
2839 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
2840 .doit
= team_nl_cmd_options_get
,
2841 .flags
= GENL_ADMIN_PERM
,
2844 .cmd
= TEAM_CMD_PORT_LIST_GET
,
2845 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
2846 .doit
= team_nl_cmd_port_list_get
,
2847 .flags
= GENL_ADMIN_PERM
,
2851 static const struct genl_multicast_group team_nl_mcgrps
[] = {
2852 { .name
= TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME
, },
2855 static struct genl_family team_nl_family __ro_after_init
= {
2856 .name
= TEAM_GENL_NAME
,
2857 .version
= TEAM_GENL_VERSION
,
2858 .maxattr
= TEAM_ATTR_MAX
,
2859 .policy
= team_nl_policy
,
2861 .module
= THIS_MODULE
,
2862 .small_ops
= team_nl_ops
,
2863 .n_small_ops
= ARRAY_SIZE(team_nl_ops
),
2864 .resv_start_op
= TEAM_CMD_PORT_LIST_GET
+ 1,
2865 .mcgrps
= team_nl_mcgrps
,
2866 .n_mcgrps
= ARRAY_SIZE(team_nl_mcgrps
),
2869 static int team_nl_send_multicast(struct sk_buff
*skb
,
2870 struct team
*team
, u32 portid
)
2872 return genlmsg_multicast_netns(&team_nl_family
, dev_net(team
->dev
),
2873 skb
, 0, 0, GFP_KERNEL
);
2876 static int team_nl_send_event_options_get(struct team
*team
,
2877 struct list_head
*sel_opt_inst_list
)
2879 return team_nl_send_options_get(team
, 0, 0, 0, team_nl_send_multicast
,
2883 static int team_nl_send_event_port_get(struct team
*team
,
2884 struct team_port
*port
)
2886 return team_nl_send_port_list_get(team
, 0, 0, 0, team_nl_send_multicast
,
2890 static int __init
team_nl_init(void)
2892 return genl_register_family(&team_nl_family
);
2895 static void __exit
team_nl_fini(void)
2897 genl_unregister_family(&team_nl_family
);
2905 static void __team_options_change_check(struct team
*team
)
2908 struct team_option_inst
*opt_inst
;
2909 LIST_HEAD(sel_opt_inst_list
);
2911 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2912 if (opt_inst
->changed
)
2913 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2915 err
= team_nl_send_event_options_get(team
, &sel_opt_inst_list
);
2916 if (err
&& err
!= -ESRCH
)
2917 netdev_warn(team
->dev
, "Failed to send options change via netlink (err %d)\n",
2921 /* rtnl lock is held */
2923 static void __team_port_change_send(struct team_port
*port
, bool linkup
)
2927 port
->changed
= true;
2928 port
->state
.linkup
= linkup
;
2929 team_refresh_port_linkup(port
);
2931 struct ethtool_link_ksettings ecmd
;
2933 err
= __ethtool_get_link_ksettings(port
->dev
, &ecmd
);
2935 port
->state
.speed
= ecmd
.base
.speed
;
2936 port
->state
.duplex
= ecmd
.base
.duplex
;
2940 port
->state
.speed
= 0;
2941 port
->state
.duplex
= 0;
2944 err
= team_nl_send_event_port_get(port
->team
, port
);
2945 if (err
&& err
!= -ESRCH
)
2946 netdev_warn(port
->team
->dev
, "Failed to send port change of device %s via netlink (err %d)\n",
2947 port
->dev
->name
, err
);
2951 static void __team_carrier_check(struct team
*team
)
2953 struct team_port
*port
;
2956 if (team
->user_carrier_enabled
)
2959 team_linkup
= false;
2960 list_for_each_entry(port
, &team
->port_list
, list
) {
2968 netif_carrier_on(team
->dev
);
2970 netif_carrier_off(team
->dev
);
2973 static void __team_port_change_check(struct team_port
*port
, bool linkup
)
2975 if (port
->state
.linkup
!= linkup
)
2976 __team_port_change_send(port
, linkup
);
2977 __team_carrier_check(port
->team
);
2980 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
)
2982 __team_port_change_send(port
, linkup
);
2983 __team_carrier_check(port
->team
);
2986 static void __team_port_change_port_removed(struct team_port
*port
)
2988 port
->removed
= true;
2989 __team_port_change_send(port
, false);
2990 __team_carrier_check(port
->team
);
2993 static void team_port_change_check(struct team_port
*port
, bool linkup
)
2995 struct team
*team
= port
->team
;
2997 mutex_lock(&team
->lock
);
2998 __team_port_change_check(port
, linkup
);
2999 mutex_unlock(&team
->lock
);
3003 /************************************
3004 * Net device notifier event handler
3005 ************************************/
3007 static int team_device_event(struct notifier_block
*unused
,
3008 unsigned long event
, void *ptr
)
3010 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
3011 struct team_port
*port
;
3013 port
= team_port_get_rtnl(dev
);
3019 if (netif_oper_up(dev
))
3020 team_port_change_check(port
, true);
3023 team_port_change_check(port
, false);
3026 if (netif_running(port
->dev
))
3027 team_port_change_check(port
,
3028 !!netif_oper_up(port
->dev
));
3030 case NETDEV_UNREGISTER
:
3031 team_del_slave(port
->team
->dev
, dev
);
3033 case NETDEV_FEAT_CHANGE
:
3034 if (!port
->team
->notifier_ctx
) {
3035 port
->team
->notifier_ctx
= true;
3036 team_compute_features(port
->team
);
3037 port
->team
->notifier_ctx
= false;
3040 case NETDEV_PRECHANGEMTU
:
3041 /* Forbid to change mtu of underlaying device */
3042 if (!port
->team
->port_mtu_change_allowed
)
3045 case NETDEV_PRE_TYPE_CHANGE
:
3046 /* Forbid to change type of underlaying device */
3048 case NETDEV_RESEND_IGMP
:
3049 /* Propagate to master device */
3050 call_netdevice_notifiers(event
, port
->team
->dev
);
3056 static struct notifier_block team_notifier_block __read_mostly
= {
3057 .notifier_call
= team_device_event
,
3061 /***********************
3062 * Module init and exit
3063 ***********************/
3065 static int __init
team_module_init(void)
3069 register_netdevice_notifier(&team_notifier_block
);
3071 err
= rtnl_link_register(&team_link_ops
);
3075 err
= team_nl_init();
3082 rtnl_link_unregister(&team_link_ops
);
3085 unregister_netdevice_notifier(&team_notifier_block
);
3090 static void __exit
team_module_exit(void)
3093 rtnl_link_unregister(&team_link_ops
);
3094 unregister_netdevice_notifier(&team_notifier_block
);
3097 module_init(team_module_init
);
3098 module_exit(team_module_exit
);
3100 MODULE_LICENSE("GPL v2");
3101 MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
3102 MODULE_DESCRIPTION("Ethernet team device driver");
3103 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);