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/kernel.h>
8 #include <linux/types.h>
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/slab.h>
12 #include <linux/rcupdate.h>
13 #include <linux/errno.h>
14 #include <linux/ctype.h>
15 #include <linux/notifier.h>
16 #include <linux/netdevice.h>
17 #include <linux/netpoll.h>
18 #include <linux/if_vlan.h>
19 #include <linux/if_arp.h>
20 #include <linux/socket.h>
21 #include <linux/etherdevice.h>
22 #include <linux/rtnetlink.h>
23 #include <net/rtnetlink.h>
24 #include <net/genetlink.h>
25 #include <net/netlink.h>
26 #include <net/sch_generic.h>
27 #include <generated/utsrelease.h>
28 #include <linux/if_team.h>
30 #define DRV_NAME "team"
37 static struct team_port
*team_port_get_rtnl(const struct net_device
*dev
)
39 struct team_port
*port
= rtnl_dereference(dev
->rx_handler_data
);
41 return netif_is_team_port(dev
) ? port
: NULL
;
45 * Since the ability to change device address for open port device is tested in
46 * team_port_add, this function can be called without control of return value
48 static int __set_port_dev_addr(struct net_device
*port_dev
,
49 const unsigned char *dev_addr
)
51 struct sockaddr_storage addr
;
53 memcpy(addr
.__data
, dev_addr
, port_dev
->addr_len
);
54 addr
.ss_family
= port_dev
->type
;
55 return dev_set_mac_address(port_dev
, (struct sockaddr
*)&addr
, NULL
);
58 static int team_port_set_orig_dev_addr(struct team_port
*port
)
60 return __set_port_dev_addr(port
->dev
, port
->orig
.dev_addr
);
63 static int team_port_set_team_dev_addr(struct team
*team
,
64 struct team_port
*port
)
66 return __set_port_dev_addr(port
->dev
, team
->dev
->dev_addr
);
69 int team_modeop_port_enter(struct team
*team
, struct team_port
*port
)
71 return team_port_set_team_dev_addr(team
, port
);
73 EXPORT_SYMBOL(team_modeop_port_enter
);
75 void team_modeop_port_change_dev_addr(struct team
*team
,
76 struct team_port
*port
)
78 team_port_set_team_dev_addr(team
, port
);
80 EXPORT_SYMBOL(team_modeop_port_change_dev_addr
);
82 static void team_lower_state_changed(struct team_port
*port
)
84 struct netdev_lag_lower_state_info info
;
86 info
.link_up
= port
->linkup
;
87 info
.tx_enabled
= team_port_enabled(port
);
88 netdev_lower_state_changed(port
->dev
, &info
);
91 static void team_refresh_port_linkup(struct team_port
*port
)
93 bool new_linkup
= port
->user
.linkup_enabled
? port
->user
.linkup
:
96 if (port
->linkup
!= new_linkup
) {
97 port
->linkup
= new_linkup
;
98 team_lower_state_changed(port
);
107 struct team_option_inst
{ /* One for each option instance */
108 struct list_head list
;
109 struct list_head tmp_list
;
110 struct team_option
*option
;
111 struct team_option_inst_info info
;
116 static struct team_option
*__team_find_option(struct team
*team
,
117 const char *opt_name
)
119 struct team_option
*option
;
121 list_for_each_entry(option
, &team
->option_list
, list
) {
122 if (strcmp(option
->name
, opt_name
) == 0)
128 static void __team_option_inst_del(struct team_option_inst
*opt_inst
)
130 list_del(&opt_inst
->list
);
134 static void __team_option_inst_del_option(struct team
*team
,
135 struct team_option
*option
)
137 struct team_option_inst
*opt_inst
, *tmp
;
139 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
140 if (opt_inst
->option
== option
)
141 __team_option_inst_del(opt_inst
);
145 static int __team_option_inst_add(struct team
*team
, struct team_option
*option
,
146 struct team_port
*port
)
148 struct team_option_inst
*opt_inst
;
149 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 err
= option
->init(team
, &opt_inst
->info
);
177 static int __team_option_inst_add_option(struct team
*team
,
178 struct team_option
*option
)
182 if (!option
->per_port
) {
183 err
= __team_option_inst_add(team
, option
, NULL
);
185 goto inst_del_option
;
190 __team_option_inst_del_option(team
, option
);
194 static void __team_option_inst_mark_removed_option(struct team
*team
,
195 struct team_option
*option
)
197 struct team_option_inst
*opt_inst
;
199 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
200 if (opt_inst
->option
== option
) {
201 opt_inst
->changed
= true;
202 opt_inst
->removed
= true;
207 static void __team_option_inst_del_port(struct team
*team
,
208 struct team_port
*port
)
210 struct team_option_inst
*opt_inst
, *tmp
;
212 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
213 if (opt_inst
->option
->per_port
&&
214 opt_inst
->info
.port
== port
)
215 __team_option_inst_del(opt_inst
);
219 static int __team_option_inst_add_port(struct team
*team
,
220 struct team_port
*port
)
222 struct team_option
*option
;
225 list_for_each_entry(option
, &team
->option_list
, list
) {
226 if (!option
->per_port
)
228 err
= __team_option_inst_add(team
, option
, port
);
235 __team_option_inst_del_port(team
, port
);
239 static void __team_option_inst_mark_removed_port(struct team
*team
,
240 struct team_port
*port
)
242 struct team_option_inst
*opt_inst
;
244 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
245 if (opt_inst
->info
.port
== port
) {
246 opt_inst
->changed
= true;
247 opt_inst
->removed
= true;
252 static int __team_options_register(struct team
*team
,
253 const struct team_option
*option
,
257 struct team_option
**dst_opts
;
260 dst_opts
= kcalloc(option_count
, sizeof(struct team_option
*),
264 for (i
= 0; i
< option_count
; i
++, option
++) {
265 if (__team_find_option(team
, option
->name
)) {
269 dst_opts
[i
] = kmemdup(option
, sizeof(*option
), GFP_KERNEL
);
276 for (i
= 0; i
< option_count
; i
++) {
277 err
= __team_option_inst_add_option(team
, dst_opts
[i
]);
280 list_add_tail(&dst_opts
[i
]->list
, &team
->option_list
);
287 for (i
--; i
>= 0; i
--)
288 __team_option_inst_del_option(team
, dst_opts
[i
]);
290 i
= option_count
- 1;
292 for (i
--; i
>= 0; i
--)
299 static void __team_options_mark_removed(struct team
*team
,
300 const struct team_option
*option
,
305 for (i
= 0; i
< option_count
; i
++, option
++) {
306 struct team_option
*del_opt
;
308 del_opt
= __team_find_option(team
, option
->name
);
310 __team_option_inst_mark_removed_option(team
, del_opt
);
314 static void __team_options_unregister(struct team
*team
,
315 const struct team_option
*option
,
320 for (i
= 0; i
< option_count
; i
++, option
++) {
321 struct team_option
*del_opt
;
323 del_opt
= __team_find_option(team
, option
->name
);
325 __team_option_inst_del_option(team
, del_opt
);
326 list_del(&del_opt
->list
);
332 static void __team_options_change_check(struct team
*team
);
334 int team_options_register(struct team
*team
,
335 const struct team_option
*option
,
340 err
= __team_options_register(team
, option
, option_count
);
343 __team_options_change_check(team
);
346 EXPORT_SYMBOL(team_options_register
);
348 void team_options_unregister(struct team
*team
,
349 const struct team_option
*option
,
352 __team_options_mark_removed(team
, option
, option_count
);
353 __team_options_change_check(team
);
354 __team_options_unregister(team
, option
, option_count
);
356 EXPORT_SYMBOL(team_options_unregister
);
358 static int team_option_get(struct team
*team
,
359 struct team_option_inst
*opt_inst
,
360 struct team_gsetter_ctx
*ctx
)
362 if (!opt_inst
->option
->getter
)
364 return opt_inst
->option
->getter(team
, ctx
);
367 static int team_option_set(struct team
*team
,
368 struct team_option_inst
*opt_inst
,
369 struct team_gsetter_ctx
*ctx
)
371 if (!opt_inst
->option
->setter
)
373 return opt_inst
->option
->setter(team
, ctx
);
376 void team_option_inst_set_change(struct team_option_inst_info
*opt_inst_info
)
378 struct team_option_inst
*opt_inst
;
380 opt_inst
= container_of(opt_inst_info
, struct team_option_inst
, info
);
381 opt_inst
->changed
= true;
383 EXPORT_SYMBOL(team_option_inst_set_change
);
385 void team_options_change_check(struct team
*team
)
387 __team_options_change_check(team
);
389 EXPORT_SYMBOL(team_options_change_check
);
396 static LIST_HEAD(mode_list
);
397 static DEFINE_SPINLOCK(mode_list_lock
);
399 struct team_mode_item
{
400 struct list_head list
;
401 const struct team_mode
*mode
;
404 static struct team_mode_item
*__find_mode(const char *kind
)
406 struct team_mode_item
*mitem
;
408 list_for_each_entry(mitem
, &mode_list
, list
) {
409 if (strcmp(mitem
->mode
->kind
, kind
) == 0)
415 static bool is_good_mode_name(const char *name
)
417 while (*name
!= '\0') {
418 if (!isalpha(*name
) && !isdigit(*name
) && *name
!= '_')
425 int team_mode_register(const struct team_mode
*mode
)
428 struct team_mode_item
*mitem
;
430 if (!is_good_mode_name(mode
->kind
) ||
431 mode
->priv_size
> TEAM_MODE_PRIV_SIZE
)
434 mitem
= kmalloc(sizeof(*mitem
), GFP_KERNEL
);
438 spin_lock(&mode_list_lock
);
439 if (__find_mode(mode
->kind
)) {
445 list_add_tail(&mitem
->list
, &mode_list
);
447 spin_unlock(&mode_list_lock
);
450 EXPORT_SYMBOL(team_mode_register
);
452 void team_mode_unregister(const struct team_mode
*mode
)
454 struct team_mode_item
*mitem
;
456 spin_lock(&mode_list_lock
);
457 mitem
= __find_mode(mode
->kind
);
459 list_del_init(&mitem
->list
);
462 spin_unlock(&mode_list_lock
);
464 EXPORT_SYMBOL(team_mode_unregister
);
466 static const struct team_mode
*team_mode_get(const char *kind
)
468 struct team_mode_item
*mitem
;
469 const struct team_mode
*mode
= NULL
;
471 spin_lock(&mode_list_lock
);
472 mitem
= __find_mode(kind
);
474 spin_unlock(&mode_list_lock
);
475 request_module("team-mode-%s", kind
);
476 spin_lock(&mode_list_lock
);
477 mitem
= __find_mode(kind
);
481 if (!try_module_get(mode
->owner
))
485 spin_unlock(&mode_list_lock
);
489 static void team_mode_put(const struct team_mode
*mode
)
491 module_put(mode
->owner
);
494 static bool team_dummy_transmit(struct team
*team
, struct sk_buff
*skb
)
496 dev_kfree_skb_any(skb
);
500 static rx_handler_result_t
team_dummy_receive(struct team
*team
,
501 struct team_port
*port
,
504 return RX_HANDLER_ANOTHER
;
507 static const struct team_mode __team_no_mode
= {
511 static bool team_is_mode_set(struct team
*team
)
513 return team
->mode
!= &__team_no_mode
;
516 static void team_set_no_mode(struct team
*team
)
518 team
->user_carrier_enabled
= false;
519 team
->mode
= &__team_no_mode
;
522 static void team_adjust_ops(struct team
*team
)
525 * To avoid checks in rx/tx skb paths, ensure here that non-null and
526 * correct ops are always set.
529 if (!team
->en_port_count
|| !team_is_mode_set(team
) ||
530 !team
->mode
->ops
->transmit
)
531 team
->ops
.transmit
= team_dummy_transmit
;
533 team
->ops
.transmit
= team
->mode
->ops
->transmit
;
535 if (!team
->en_port_count
|| !team_is_mode_set(team
) ||
536 !team
->mode
->ops
->receive
)
537 team
->ops
.receive
= team_dummy_receive
;
539 team
->ops
.receive
= team
->mode
->ops
->receive
;
543 * We can benefit from the fact that it's ensured no port is present
544 * at the time of mode change. Therefore no packets are in fly so there's no
545 * need to set mode operations in any special way.
547 static int __team_change_mode(struct team
*team
,
548 const struct team_mode
*new_mode
)
550 /* Check if mode was previously set and do cleanup if so */
551 if (team_is_mode_set(team
)) {
552 void (*exit_op
)(struct team
*team
) = team
->ops
.exit
;
554 /* Clear ops area so no callback is called any longer */
555 memset(&team
->ops
, 0, sizeof(struct team_mode_ops
));
556 team_adjust_ops(team
);
560 team_mode_put(team
->mode
);
561 team_set_no_mode(team
);
562 /* zero private data area */
563 memset(&team
->mode_priv
, 0,
564 sizeof(struct team
) - offsetof(struct team
, mode_priv
));
570 if (new_mode
->ops
->init
) {
573 err
= new_mode
->ops
->init(team
);
578 team
->mode
= new_mode
;
579 memcpy(&team
->ops
, new_mode
->ops
, sizeof(struct team_mode_ops
));
580 team_adjust_ops(team
);
585 static int team_change_mode(struct team
*team
, const char *kind
)
587 const struct team_mode
*new_mode
;
588 struct net_device
*dev
= team
->dev
;
591 if (!list_empty(&team
->port_list
)) {
592 netdev_err(dev
, "No ports can be present during mode change\n");
596 if (team_is_mode_set(team
) && strcmp(team
->mode
->kind
, kind
) == 0) {
597 netdev_err(dev
, "Unable to change to the same mode the team is in\n");
601 new_mode
= team_mode_get(kind
);
603 netdev_err(dev
, "Mode \"%s\" not found\n", kind
);
607 err
= __team_change_mode(team
, new_mode
);
609 netdev_err(dev
, "Failed to change to mode \"%s\"\n", kind
);
610 team_mode_put(new_mode
);
614 netdev_info(dev
, "Mode changed to \"%s\"\n", kind
);
619 /*********************
621 *********************/
623 static void team_notify_peers_work(struct work_struct
*work
)
628 team
= container_of(work
, struct team
, notify_peers
.dw
.work
);
630 if (!rtnl_trylock()) {
631 schedule_delayed_work(&team
->notify_peers
.dw
, 0);
634 val
= atomic_dec_if_positive(&team
->notify_peers
.count_pending
);
639 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS
, team
->dev
);
642 schedule_delayed_work(&team
->notify_peers
.dw
,
643 msecs_to_jiffies(team
->notify_peers
.interval
));
646 static void team_notify_peers(struct team
*team
)
648 if (!team
->notify_peers
.count
|| !netif_running(team
->dev
))
650 atomic_add(team
->notify_peers
.count
, &team
->notify_peers
.count_pending
);
651 schedule_delayed_work(&team
->notify_peers
.dw
, 0);
654 static void team_notify_peers_init(struct team
*team
)
656 INIT_DELAYED_WORK(&team
->notify_peers
.dw
, team_notify_peers_work
);
659 static void team_notify_peers_fini(struct team
*team
)
661 cancel_delayed_work_sync(&team
->notify_peers
.dw
);
665 /*******************************
666 * Send multicast group rejoins
667 *******************************/
669 static void team_mcast_rejoin_work(struct work_struct
*work
)
674 team
= container_of(work
, struct team
, mcast_rejoin
.dw
.work
);
676 if (!rtnl_trylock()) {
677 schedule_delayed_work(&team
->mcast_rejoin
.dw
, 0);
680 val
= atomic_dec_if_positive(&team
->mcast_rejoin
.count_pending
);
685 call_netdevice_notifiers(NETDEV_RESEND_IGMP
, team
->dev
);
688 schedule_delayed_work(&team
->mcast_rejoin
.dw
,
689 msecs_to_jiffies(team
->mcast_rejoin
.interval
));
692 static void team_mcast_rejoin(struct team
*team
)
694 if (!team
->mcast_rejoin
.count
|| !netif_running(team
->dev
))
696 atomic_add(team
->mcast_rejoin
.count
, &team
->mcast_rejoin
.count_pending
);
697 schedule_delayed_work(&team
->mcast_rejoin
.dw
, 0);
700 static void team_mcast_rejoin_init(struct team
*team
)
702 INIT_DELAYED_WORK(&team
->mcast_rejoin
.dw
, team_mcast_rejoin_work
);
705 static void team_mcast_rejoin_fini(struct team
*team
)
707 cancel_delayed_work_sync(&team
->mcast_rejoin
.dw
);
711 /************************
712 * Rx path frame handler
713 ************************/
715 /* note: already called with rcu_read_lock */
716 static rx_handler_result_t
team_handle_frame(struct sk_buff
**pskb
)
718 struct sk_buff
*skb
= *pskb
;
719 struct team_port
*port
;
721 rx_handler_result_t res
;
723 skb
= skb_share_check(skb
, GFP_ATOMIC
);
725 return RX_HANDLER_CONSUMED
;
729 port
= team_port_get_rcu(skb
->dev
);
731 if (!team_port_enabled(port
)) {
732 /* allow exact match delivery for disabled ports */
733 res
= RX_HANDLER_EXACT
;
735 res
= team
->ops
.receive(team
, port
, skb
);
737 if (res
== RX_HANDLER_ANOTHER
) {
738 struct team_pcpu_stats
*pcpu_stats
;
740 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
741 u64_stats_update_begin(&pcpu_stats
->syncp
);
742 pcpu_stats
->rx_packets
++;
743 pcpu_stats
->rx_bytes
+= skb
->len
;
744 if (skb
->pkt_type
== PACKET_MULTICAST
)
745 pcpu_stats
->rx_multicast
++;
746 u64_stats_update_end(&pcpu_stats
->syncp
);
748 skb
->dev
= team
->dev
;
749 } else if (res
== RX_HANDLER_EXACT
) {
750 this_cpu_inc(team
->pcpu_stats
->rx_nohandler
);
752 this_cpu_inc(team
->pcpu_stats
->rx_dropped
);
759 /*************************************
760 * Multiqueue Tx port select override
761 *************************************/
763 static int team_queue_override_init(struct team
*team
)
765 struct list_head
*listarr
;
766 unsigned int queue_cnt
= team
->dev
->num_tx_queues
- 1;
771 listarr
= kmalloc_array(queue_cnt
, sizeof(struct list_head
),
775 team
->qom_lists
= listarr
;
776 for (i
= 0; i
< queue_cnt
; i
++)
777 INIT_LIST_HEAD(listarr
++);
781 static void team_queue_override_fini(struct team
*team
)
783 kfree(team
->qom_lists
);
786 static struct list_head
*__team_get_qom_list(struct team
*team
, u16 queue_id
)
788 return &team
->qom_lists
[queue_id
- 1];
792 * note: already called with rcu_read_lock
794 static bool team_queue_override_transmit(struct team
*team
, struct sk_buff
*skb
)
796 struct list_head
*qom_list
;
797 struct team_port
*port
;
799 if (!team
->queue_override_enabled
|| !skb
->queue_mapping
)
801 qom_list
= __team_get_qom_list(team
, skb
->queue_mapping
);
802 list_for_each_entry_rcu(port
, qom_list
, qom_list
) {
803 if (!team_dev_queue_xmit(team
, port
, skb
))
809 static void __team_queue_override_port_del(struct team
*team
,
810 struct team_port
*port
)
814 list_del_rcu(&port
->qom_list
);
817 static bool team_queue_override_port_has_gt_prio_than(struct team_port
*port
,
818 struct team_port
*cur
)
820 if (port
->priority
< cur
->priority
)
822 if (port
->priority
> cur
->priority
)
824 if (port
->index
< cur
->index
)
829 static void __team_queue_override_port_add(struct team
*team
,
830 struct team_port
*port
)
832 struct team_port
*cur
;
833 struct list_head
*qom_list
;
834 struct list_head
*node
;
838 qom_list
= __team_get_qom_list(team
, port
->queue_id
);
840 list_for_each_entry(cur
, qom_list
, qom_list
) {
841 if (team_queue_override_port_has_gt_prio_than(port
, cur
))
843 node
= &cur
->qom_list
;
845 list_add_tail_rcu(&port
->qom_list
, node
);
848 static void __team_queue_override_enabled_check(struct team
*team
)
850 struct team_port
*port
;
851 bool enabled
= false;
853 list_for_each_entry(port
, &team
->port_list
, list
) {
854 if (port
->queue_id
) {
859 if (enabled
== team
->queue_override_enabled
)
861 netdev_dbg(team
->dev
, "%s queue override\n",
862 enabled
? "Enabling" : "Disabling");
863 team
->queue_override_enabled
= enabled
;
866 static void team_queue_override_port_prio_changed(struct team
*team
,
867 struct team_port
*port
)
869 if (!port
->queue_id
|| team_port_enabled(port
))
871 __team_queue_override_port_del(team
, port
);
872 __team_queue_override_port_add(team
, port
);
873 __team_queue_override_enabled_check(team
);
876 static void team_queue_override_port_change_queue_id(struct team
*team
,
877 struct team_port
*port
,
880 if (team_port_enabled(port
)) {
881 __team_queue_override_port_del(team
, port
);
882 port
->queue_id
= new_queue_id
;
883 __team_queue_override_port_add(team
, port
);
884 __team_queue_override_enabled_check(team
);
886 port
->queue_id
= new_queue_id
;
890 static void team_queue_override_port_add(struct team
*team
,
891 struct team_port
*port
)
893 __team_queue_override_port_add(team
, port
);
894 __team_queue_override_enabled_check(team
);
897 static void team_queue_override_port_del(struct team
*team
,
898 struct team_port
*port
)
900 __team_queue_override_port_del(team
, port
);
901 __team_queue_override_enabled_check(team
);
909 static bool team_port_find(const struct team
*team
,
910 const struct team_port
*port
)
912 struct team_port
*cur
;
914 list_for_each_entry(cur
, &team
->port_list
, list
)
921 * Enable/disable port by adding to enabled port hashlist and setting
922 * port->index (Might be racy so reader could see incorrect ifindex when
923 * processing a flying packet, but that is not a problem). Write guarded
926 static void team_port_enable(struct team
*team
,
927 struct team_port
*port
)
929 if (team_port_enabled(port
))
931 port
->index
= team
->en_port_count
++;
932 hlist_add_head_rcu(&port
->hlist
,
933 team_port_index_hash(team
, port
->index
));
934 team_adjust_ops(team
);
935 team_queue_override_port_add(team
, port
);
936 if (team
->ops
.port_enabled
)
937 team
->ops
.port_enabled(team
, port
);
938 team_notify_peers(team
);
939 team_mcast_rejoin(team
);
940 team_lower_state_changed(port
);
943 static void __reconstruct_port_hlist(struct team
*team
, int rm_index
)
946 struct team_port
*port
;
948 for (i
= rm_index
+ 1; i
< team
->en_port_count
; i
++) {
949 port
= team_get_port_by_index(team
, i
);
950 hlist_del_rcu(&port
->hlist
);
952 hlist_add_head_rcu(&port
->hlist
,
953 team_port_index_hash(team
, port
->index
));
957 static void team_port_disable(struct team
*team
,
958 struct team_port
*port
)
960 if (!team_port_enabled(port
))
962 if (team
->ops
.port_disabled
)
963 team
->ops
.port_disabled(team
, port
);
964 hlist_del_rcu(&port
->hlist
);
965 __reconstruct_port_hlist(team
, port
->index
);
967 team
->en_port_count
--;
968 team_queue_override_port_del(team
, port
);
969 team_adjust_ops(team
);
970 team_lower_state_changed(port
);
973 #define TEAM_VLAN_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
974 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
975 NETIF_F_HIGHDMA | NETIF_F_LRO)
977 #define TEAM_ENC_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
978 NETIF_F_RXCSUM | NETIF_F_ALL_TSO)
980 static void __team_compute_features(struct team
*team
)
982 struct team_port
*port
;
983 netdev_features_t vlan_features
= TEAM_VLAN_FEATURES
&
985 netdev_features_t enc_features
= TEAM_ENC_FEATURES
;
986 unsigned short max_hard_header_len
= ETH_HLEN
;
987 unsigned int dst_release_flag
= IFF_XMIT_DST_RELEASE
|
988 IFF_XMIT_DST_RELEASE_PERM
;
990 list_for_each_entry(port
, &team
->port_list
, list
) {
991 vlan_features
= netdev_increment_features(vlan_features
,
992 port
->dev
->vlan_features
,
995 netdev_increment_features(enc_features
,
996 port
->dev
->hw_enc_features
,
1000 dst_release_flag
&= port
->dev
->priv_flags
;
1001 if (port
->dev
->hard_header_len
> max_hard_header_len
)
1002 max_hard_header_len
= port
->dev
->hard_header_len
;
1005 team
->dev
->vlan_features
= vlan_features
;
1006 team
->dev
->hw_enc_features
= enc_features
| NETIF_F_GSO_ENCAP_ALL
|
1007 NETIF_F_HW_VLAN_CTAG_TX
|
1008 NETIF_F_HW_VLAN_STAG_TX
|
1010 team
->dev
->hard_header_len
= max_hard_header_len
;
1012 team
->dev
->priv_flags
&= ~IFF_XMIT_DST_RELEASE
;
1013 if (dst_release_flag
== (IFF_XMIT_DST_RELEASE
| IFF_XMIT_DST_RELEASE_PERM
))
1014 team
->dev
->priv_flags
|= IFF_XMIT_DST_RELEASE
;
1017 static void team_compute_features(struct team
*team
)
1019 mutex_lock(&team
->lock
);
1020 __team_compute_features(team
);
1021 mutex_unlock(&team
->lock
);
1022 netdev_change_features(team
->dev
);
1025 static int team_port_enter(struct team
*team
, struct team_port
*port
)
1029 dev_hold(team
->dev
);
1030 if (team
->ops
.port_enter
) {
1031 err
= team
->ops
.port_enter(team
, port
);
1033 netdev_err(team
->dev
, "Device %s failed to enter team mode\n",
1035 goto err_port_enter
;
1047 static void team_port_leave(struct team
*team
, struct team_port
*port
)
1049 if (team
->ops
.port_leave
)
1050 team
->ops
.port_leave(team
, port
);
1054 #ifdef CONFIG_NET_POLL_CONTROLLER
1055 static int __team_port_enable_netpoll(struct team_port
*port
)
1060 np
= kzalloc(sizeof(*np
), GFP_KERNEL
);
1064 err
= __netpoll_setup(np
, port
->dev
);
1073 static int team_port_enable_netpoll(struct team_port
*port
)
1075 if (!port
->team
->dev
->npinfo
)
1078 return __team_port_enable_netpoll(port
);
1081 static void team_port_disable_netpoll(struct team_port
*port
)
1083 struct netpoll
*np
= port
->np
;
1092 static int team_port_enable_netpoll(struct team_port
*port
)
1096 static void team_port_disable_netpoll(struct team_port
*port
)
1101 static int team_upper_dev_link(struct team
*team
, struct team_port
*port
,
1102 struct netlink_ext_ack
*extack
)
1104 struct netdev_lag_upper_info lag_upper_info
;
1107 lag_upper_info
.tx_type
= team
->mode
->lag_tx_type
;
1108 lag_upper_info
.hash_type
= NETDEV_LAG_HASH_UNKNOWN
;
1109 err
= netdev_master_upper_dev_link(port
->dev
, team
->dev
, NULL
,
1110 &lag_upper_info
, extack
);
1113 port
->dev
->priv_flags
|= IFF_TEAM_PORT
;
1117 static void team_upper_dev_unlink(struct team
*team
, struct team_port
*port
)
1119 netdev_upper_dev_unlink(port
->dev
, team
->dev
);
1120 port
->dev
->priv_flags
&= ~IFF_TEAM_PORT
;
1123 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
);
1124 static int team_dev_type_check_change(struct net_device
*dev
,
1125 struct net_device
*port_dev
);
1127 static int team_port_add(struct team
*team
, struct net_device
*port_dev
,
1128 struct netlink_ext_ack
*extack
)
1130 struct net_device
*dev
= team
->dev
;
1131 struct team_port
*port
;
1132 char *portname
= port_dev
->name
;
1135 if (port_dev
->flags
& IFF_LOOPBACK
) {
1136 NL_SET_ERR_MSG(extack
, "Loopback device can't be added as a team port");
1137 netdev_err(dev
, "Device %s is loopback device. Loopback devices can't be added as a team port\n",
1142 if (netif_is_team_port(port_dev
)) {
1143 NL_SET_ERR_MSG(extack
, "Device is already a port of a team device");
1144 netdev_err(dev
, "Device %s is already a port "
1145 "of a team device\n", portname
);
1149 if (dev
== port_dev
) {
1150 NL_SET_ERR_MSG(extack
, "Cannot enslave team device to itself");
1151 netdev_err(dev
, "Cannot enslave team device to itself\n");
1155 if (netdev_has_upper_dev(dev
, port_dev
)) {
1156 NL_SET_ERR_MSG(extack
, "Device is already an upper device of the team interface");
1157 netdev_err(dev
, "Device %s is already an upper device of the team interface\n",
1162 if (port_dev
->features
& NETIF_F_VLAN_CHALLENGED
&&
1163 vlan_uses_dev(dev
)) {
1164 NL_SET_ERR_MSG(extack
, "Device is VLAN challenged and team device has VLAN set up");
1165 netdev_err(dev
, "Device %s is VLAN challenged and team device has VLAN set up\n",
1170 err
= team_dev_type_check_change(dev
, port_dev
);
1174 if (port_dev
->flags
& IFF_UP
) {
1175 NL_SET_ERR_MSG(extack
, "Device is up. Set it down before adding it as a team port");
1176 netdev_err(dev
, "Device %s is up. Set it down before adding it as a team port\n",
1181 port
= kzalloc(sizeof(struct team_port
) + team
->mode
->port_priv_size
,
1186 port
->dev
= port_dev
;
1188 INIT_LIST_HEAD(&port
->qom_list
);
1190 port
->orig
.mtu
= port_dev
->mtu
;
1191 err
= dev_set_mtu(port_dev
, dev
->mtu
);
1193 netdev_dbg(dev
, "Error %d calling dev_set_mtu\n", err
);
1197 memcpy(port
->orig
.dev_addr
, port_dev
->dev_addr
, port_dev
->addr_len
);
1199 err
= team_port_enter(team
, port
);
1201 netdev_err(dev
, "Device %s failed to enter team mode\n",
1203 goto err_port_enter
;
1206 err
= dev_open(port_dev
, extack
);
1208 netdev_dbg(dev
, "Device %s opening failed\n",
1213 err
= vlan_vids_add_by_dev(port_dev
, dev
);
1215 netdev_err(dev
, "Failed to add vlan ids to device %s\n",
1220 err
= team_port_enable_netpoll(port
);
1222 netdev_err(dev
, "Failed to enable netpoll on device %s\n",
1224 goto err_enable_netpoll
;
1227 if (!(dev
->features
& NETIF_F_LRO
))
1228 dev_disable_lro(port_dev
);
1230 err
= netdev_rx_handler_register(port_dev
, team_handle_frame
,
1233 netdev_err(dev
, "Device %s failed to register rx_handler\n",
1235 goto err_handler_register
;
1238 err
= team_upper_dev_link(team
, port
, extack
);
1240 netdev_err(dev
, "Device %s failed to set upper link\n",
1242 goto err_set_upper_link
;
1245 err
= __team_option_inst_add_port(team
, port
);
1247 netdev_err(dev
, "Device %s failed to add per-port options\n",
1249 goto err_option_port_add
;
1252 /* set promiscuity level to new slave */
1253 if (dev
->flags
& IFF_PROMISC
) {
1254 err
= dev_set_promiscuity(port_dev
, 1);
1256 goto err_set_slave_promisc
;
1259 /* set allmulti level to new slave */
1260 if (dev
->flags
& IFF_ALLMULTI
) {
1261 err
= dev_set_allmulti(port_dev
, 1);
1263 if (dev
->flags
& IFF_PROMISC
)
1264 dev_set_promiscuity(port_dev
, -1);
1265 goto err_set_slave_promisc
;
1269 netif_addr_lock_bh(dev
);
1270 dev_uc_sync_multiple(port_dev
, dev
);
1271 dev_mc_sync_multiple(port_dev
, dev
);
1272 netif_addr_unlock_bh(dev
);
1275 list_add_tail_rcu(&port
->list
, &team
->port_list
);
1276 team_port_enable(team
, port
);
1277 __team_compute_features(team
);
1278 __team_port_change_port_added(port
, !!netif_oper_up(port_dev
));
1279 __team_options_change_check(team
);
1281 netdev_info(dev
, "Port device %s added\n", portname
);
1285 err_set_slave_promisc
:
1286 __team_option_inst_del_port(team
, port
);
1288 err_option_port_add
:
1289 team_upper_dev_unlink(team
, port
);
1292 netdev_rx_handler_unregister(port_dev
);
1294 err_handler_register
:
1295 team_port_disable_netpoll(port
);
1298 vlan_vids_del_by_dev(port_dev
, dev
);
1301 dev_close(port_dev
);
1304 team_port_leave(team
, port
);
1305 team_port_set_orig_dev_addr(port
);
1308 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1316 static void __team_port_change_port_removed(struct team_port
*port
);
1318 static int team_port_del(struct team
*team
, struct net_device
*port_dev
)
1320 struct net_device
*dev
= team
->dev
;
1321 struct team_port
*port
;
1322 char *portname
= port_dev
->name
;
1324 port
= team_port_get_rtnl(port_dev
);
1325 if (!port
|| !team_port_find(team
, port
)) {
1326 netdev_err(dev
, "Device %s does not act as a port of this team\n",
1331 team_port_disable(team
, port
);
1332 list_del_rcu(&port
->list
);
1334 if (dev
->flags
& IFF_PROMISC
)
1335 dev_set_promiscuity(port_dev
, -1);
1336 if (dev
->flags
& IFF_ALLMULTI
)
1337 dev_set_allmulti(port_dev
, -1);
1339 team_upper_dev_unlink(team
, port
);
1340 netdev_rx_handler_unregister(port_dev
);
1341 team_port_disable_netpoll(port
);
1342 vlan_vids_del_by_dev(port_dev
, dev
);
1343 dev_uc_unsync(port_dev
, dev
);
1344 dev_mc_unsync(port_dev
, dev
);
1345 dev_close(port_dev
);
1346 team_port_leave(team
, port
);
1348 __team_option_inst_mark_removed_port(team
, port
);
1349 __team_options_change_check(team
);
1350 __team_option_inst_del_port(team
, port
);
1351 __team_port_change_port_removed(port
);
1353 team_port_set_orig_dev_addr(port
);
1354 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1355 kfree_rcu(port
, rcu
);
1356 netdev_info(dev
, "Port device %s removed\n", portname
);
1357 __team_compute_features(team
);
1367 static int team_mode_option_get(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1369 ctx
->data
.str_val
= team
->mode
->kind
;
1373 static int team_mode_option_set(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1375 return team_change_mode(team
, ctx
->data
.str_val
);
1378 static int team_notify_peers_count_get(struct team
*team
,
1379 struct team_gsetter_ctx
*ctx
)
1381 ctx
->data
.u32_val
= team
->notify_peers
.count
;
1385 static int team_notify_peers_count_set(struct team
*team
,
1386 struct team_gsetter_ctx
*ctx
)
1388 team
->notify_peers
.count
= ctx
->data
.u32_val
;
1392 static int team_notify_peers_interval_get(struct team
*team
,
1393 struct team_gsetter_ctx
*ctx
)
1395 ctx
->data
.u32_val
= team
->notify_peers
.interval
;
1399 static int team_notify_peers_interval_set(struct team
*team
,
1400 struct team_gsetter_ctx
*ctx
)
1402 team
->notify_peers
.interval
= ctx
->data
.u32_val
;
1406 static int team_mcast_rejoin_count_get(struct team
*team
,
1407 struct team_gsetter_ctx
*ctx
)
1409 ctx
->data
.u32_val
= team
->mcast_rejoin
.count
;
1413 static int team_mcast_rejoin_count_set(struct team
*team
,
1414 struct team_gsetter_ctx
*ctx
)
1416 team
->mcast_rejoin
.count
= ctx
->data
.u32_val
;
1420 static int team_mcast_rejoin_interval_get(struct team
*team
,
1421 struct team_gsetter_ctx
*ctx
)
1423 ctx
->data
.u32_val
= team
->mcast_rejoin
.interval
;
1427 static int team_mcast_rejoin_interval_set(struct team
*team
,
1428 struct team_gsetter_ctx
*ctx
)
1430 team
->mcast_rejoin
.interval
= ctx
->data
.u32_val
;
1434 static int team_port_en_option_get(struct team
*team
,
1435 struct team_gsetter_ctx
*ctx
)
1437 struct team_port
*port
= ctx
->info
->port
;
1439 ctx
->data
.bool_val
= team_port_enabled(port
);
1443 static int team_port_en_option_set(struct team
*team
,
1444 struct team_gsetter_ctx
*ctx
)
1446 struct team_port
*port
= ctx
->info
->port
;
1448 if (ctx
->data
.bool_val
)
1449 team_port_enable(team
, port
);
1451 team_port_disable(team
, port
);
1455 static int team_user_linkup_option_get(struct team
*team
,
1456 struct team_gsetter_ctx
*ctx
)
1458 struct team_port
*port
= ctx
->info
->port
;
1460 ctx
->data
.bool_val
= port
->user
.linkup
;
1464 static void __team_carrier_check(struct team
*team
);
1466 static int team_user_linkup_option_set(struct team
*team
,
1467 struct team_gsetter_ctx
*ctx
)
1469 struct team_port
*port
= ctx
->info
->port
;
1471 port
->user
.linkup
= ctx
->data
.bool_val
;
1472 team_refresh_port_linkup(port
);
1473 __team_carrier_check(port
->team
);
1477 static int team_user_linkup_en_option_get(struct team
*team
,
1478 struct team_gsetter_ctx
*ctx
)
1480 struct team_port
*port
= ctx
->info
->port
;
1482 ctx
->data
.bool_val
= port
->user
.linkup_enabled
;
1486 static int team_user_linkup_en_option_set(struct team
*team
,
1487 struct team_gsetter_ctx
*ctx
)
1489 struct team_port
*port
= ctx
->info
->port
;
1491 port
->user
.linkup_enabled
= ctx
->data
.bool_val
;
1492 team_refresh_port_linkup(port
);
1493 __team_carrier_check(port
->team
);
1497 static int team_priority_option_get(struct team
*team
,
1498 struct team_gsetter_ctx
*ctx
)
1500 struct team_port
*port
= ctx
->info
->port
;
1502 ctx
->data
.s32_val
= port
->priority
;
1506 static int team_priority_option_set(struct team
*team
,
1507 struct team_gsetter_ctx
*ctx
)
1509 struct team_port
*port
= ctx
->info
->port
;
1510 s32 priority
= ctx
->data
.s32_val
;
1512 if (port
->priority
== priority
)
1514 port
->priority
= priority
;
1515 team_queue_override_port_prio_changed(team
, port
);
1519 static int team_queue_id_option_get(struct team
*team
,
1520 struct team_gsetter_ctx
*ctx
)
1522 struct team_port
*port
= ctx
->info
->port
;
1524 ctx
->data
.u32_val
= port
->queue_id
;
1528 static int team_queue_id_option_set(struct team
*team
,
1529 struct team_gsetter_ctx
*ctx
)
1531 struct team_port
*port
= ctx
->info
->port
;
1532 u16 new_queue_id
= ctx
->data
.u32_val
;
1534 if (port
->queue_id
== new_queue_id
)
1536 if (new_queue_id
>= team
->dev
->real_num_tx_queues
)
1538 team_queue_override_port_change_queue_id(team
, port
, new_queue_id
);
1542 static const struct team_option team_options
[] = {
1545 .type
= TEAM_OPTION_TYPE_STRING
,
1546 .getter
= team_mode_option_get
,
1547 .setter
= team_mode_option_set
,
1550 .name
= "notify_peers_count",
1551 .type
= TEAM_OPTION_TYPE_U32
,
1552 .getter
= team_notify_peers_count_get
,
1553 .setter
= team_notify_peers_count_set
,
1556 .name
= "notify_peers_interval",
1557 .type
= TEAM_OPTION_TYPE_U32
,
1558 .getter
= team_notify_peers_interval_get
,
1559 .setter
= team_notify_peers_interval_set
,
1562 .name
= "mcast_rejoin_count",
1563 .type
= TEAM_OPTION_TYPE_U32
,
1564 .getter
= team_mcast_rejoin_count_get
,
1565 .setter
= team_mcast_rejoin_count_set
,
1568 .name
= "mcast_rejoin_interval",
1569 .type
= TEAM_OPTION_TYPE_U32
,
1570 .getter
= team_mcast_rejoin_interval_get
,
1571 .setter
= team_mcast_rejoin_interval_set
,
1575 .type
= TEAM_OPTION_TYPE_BOOL
,
1577 .getter
= team_port_en_option_get
,
1578 .setter
= team_port_en_option_set
,
1581 .name
= "user_linkup",
1582 .type
= TEAM_OPTION_TYPE_BOOL
,
1584 .getter
= team_user_linkup_option_get
,
1585 .setter
= team_user_linkup_option_set
,
1588 .name
= "user_linkup_enabled",
1589 .type
= TEAM_OPTION_TYPE_BOOL
,
1591 .getter
= team_user_linkup_en_option_get
,
1592 .setter
= team_user_linkup_en_option_set
,
1596 .type
= TEAM_OPTION_TYPE_S32
,
1598 .getter
= team_priority_option_get
,
1599 .setter
= team_priority_option_set
,
1603 .type
= TEAM_OPTION_TYPE_U32
,
1605 .getter
= team_queue_id_option_get
,
1606 .setter
= team_queue_id_option_set
,
1611 static int team_init(struct net_device
*dev
)
1613 struct team
*team
= netdev_priv(dev
);
1618 mutex_init(&team
->lock
);
1619 team_set_no_mode(team
);
1621 team
->pcpu_stats
= netdev_alloc_pcpu_stats(struct team_pcpu_stats
);
1622 if (!team
->pcpu_stats
)
1625 for (i
= 0; i
< TEAM_PORT_HASHENTRIES
; i
++)
1626 INIT_HLIST_HEAD(&team
->en_port_hlist
[i
]);
1627 INIT_LIST_HEAD(&team
->port_list
);
1628 err
= team_queue_override_init(team
);
1630 goto err_team_queue_override_init
;
1632 team_adjust_ops(team
);
1634 INIT_LIST_HEAD(&team
->option_list
);
1635 INIT_LIST_HEAD(&team
->option_inst_list
);
1637 team_notify_peers_init(team
);
1638 team_mcast_rejoin_init(team
);
1640 err
= team_options_register(team
, team_options
, ARRAY_SIZE(team_options
));
1642 goto err_options_register
;
1643 netif_carrier_off(dev
);
1645 netdev_lockdep_set_classes(dev
);
1649 err_options_register
:
1650 team_mcast_rejoin_fini(team
);
1651 team_notify_peers_fini(team
);
1652 team_queue_override_fini(team
);
1653 err_team_queue_override_init
:
1654 free_percpu(team
->pcpu_stats
);
1659 static void team_uninit(struct net_device
*dev
)
1661 struct team
*team
= netdev_priv(dev
);
1662 struct team_port
*port
;
1663 struct team_port
*tmp
;
1665 mutex_lock(&team
->lock
);
1666 list_for_each_entry_safe(port
, tmp
, &team
->port_list
, list
)
1667 team_port_del(team
, port
->dev
);
1669 __team_change_mode(team
, NULL
); /* cleanup */
1670 __team_options_unregister(team
, team_options
, ARRAY_SIZE(team_options
));
1671 team_mcast_rejoin_fini(team
);
1672 team_notify_peers_fini(team
);
1673 team_queue_override_fini(team
);
1674 mutex_unlock(&team
->lock
);
1675 netdev_change_features(dev
);
1678 static void team_destructor(struct net_device
*dev
)
1680 struct team
*team
= netdev_priv(dev
);
1682 free_percpu(team
->pcpu_stats
);
1685 static int team_open(struct net_device
*dev
)
1690 static int team_close(struct net_device
*dev
)
1696 * note: already called with rcu_read_lock
1698 static netdev_tx_t
team_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1700 struct team
*team
= netdev_priv(dev
);
1702 unsigned int len
= skb
->len
;
1704 tx_success
= team_queue_override_transmit(team
, skb
);
1706 tx_success
= team
->ops
.transmit(team
, skb
);
1708 struct team_pcpu_stats
*pcpu_stats
;
1710 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
1711 u64_stats_update_begin(&pcpu_stats
->syncp
);
1712 pcpu_stats
->tx_packets
++;
1713 pcpu_stats
->tx_bytes
+= len
;
1714 u64_stats_update_end(&pcpu_stats
->syncp
);
1716 this_cpu_inc(team
->pcpu_stats
->tx_dropped
);
1719 return NETDEV_TX_OK
;
1722 static u16
team_select_queue(struct net_device
*dev
, struct sk_buff
*skb
,
1723 struct net_device
*sb_dev
)
1726 * This helper function exists to help dev_pick_tx get the correct
1727 * destination queue. Using a helper function skips a call to
1728 * skb_tx_hash and will put the skbs in the queue we expect on their
1729 * way down to the team driver.
1731 u16 txq
= skb_rx_queue_recorded(skb
) ? skb_get_rx_queue(skb
) : 0;
1734 * Save the original txq to restore before passing to the driver
1736 qdisc_skb_cb(skb
)->slave_dev_queue_mapping
= skb
->queue_mapping
;
1738 if (unlikely(txq
>= dev
->real_num_tx_queues
)) {
1740 txq
-= dev
->real_num_tx_queues
;
1741 } while (txq
>= dev
->real_num_tx_queues
);
1746 static void team_change_rx_flags(struct net_device
*dev
, int change
)
1748 struct team
*team
= netdev_priv(dev
);
1749 struct team_port
*port
;
1753 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1754 if (change
& IFF_PROMISC
) {
1755 inc
= dev
->flags
& IFF_PROMISC
? 1 : -1;
1756 dev_set_promiscuity(port
->dev
, inc
);
1758 if (change
& IFF_ALLMULTI
) {
1759 inc
= dev
->flags
& IFF_ALLMULTI
? 1 : -1;
1760 dev_set_allmulti(port
->dev
, inc
);
1766 static void team_set_rx_mode(struct net_device
*dev
)
1768 struct team
*team
= netdev_priv(dev
);
1769 struct team_port
*port
;
1772 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1773 dev_uc_sync_multiple(port
->dev
, dev
);
1774 dev_mc_sync_multiple(port
->dev
, dev
);
1779 static int team_set_mac_address(struct net_device
*dev
, void *p
)
1781 struct sockaddr
*addr
= p
;
1782 struct team
*team
= netdev_priv(dev
);
1783 struct team_port
*port
;
1785 if (dev
->type
== ARPHRD_ETHER
&& !is_valid_ether_addr(addr
->sa_data
))
1786 return -EADDRNOTAVAIL
;
1787 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1788 mutex_lock(&team
->lock
);
1789 list_for_each_entry(port
, &team
->port_list
, list
)
1790 if (team
->ops
.port_change_dev_addr
)
1791 team
->ops
.port_change_dev_addr(team
, port
);
1792 mutex_unlock(&team
->lock
);
1796 static int team_change_mtu(struct net_device
*dev
, int new_mtu
)
1798 struct team
*team
= netdev_priv(dev
);
1799 struct team_port
*port
;
1803 * Alhough this is reader, it's guarded by team lock. It's not possible
1804 * to traverse list in reverse under rcu_read_lock
1806 mutex_lock(&team
->lock
);
1807 team
->port_mtu_change_allowed
= true;
1808 list_for_each_entry(port
, &team
->port_list
, list
) {
1809 err
= dev_set_mtu(port
->dev
, new_mtu
);
1811 netdev_err(dev
, "Device %s failed to change mtu",
1816 team
->port_mtu_change_allowed
= false;
1817 mutex_unlock(&team
->lock
);
1824 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1825 dev_set_mtu(port
->dev
, dev
->mtu
);
1826 team
->port_mtu_change_allowed
= false;
1827 mutex_unlock(&team
->lock
);
1833 team_get_stats64(struct net_device
*dev
, struct rtnl_link_stats64
*stats
)
1835 struct team
*team
= netdev_priv(dev
);
1836 struct team_pcpu_stats
*p
;
1837 u64 rx_packets
, rx_bytes
, rx_multicast
, tx_packets
, tx_bytes
;
1838 u32 rx_dropped
= 0, tx_dropped
= 0, rx_nohandler
= 0;
1842 for_each_possible_cpu(i
) {
1843 p
= per_cpu_ptr(team
->pcpu_stats
, i
);
1845 start
= u64_stats_fetch_begin_irq(&p
->syncp
);
1846 rx_packets
= p
->rx_packets
;
1847 rx_bytes
= p
->rx_bytes
;
1848 rx_multicast
= p
->rx_multicast
;
1849 tx_packets
= p
->tx_packets
;
1850 tx_bytes
= p
->tx_bytes
;
1851 } while (u64_stats_fetch_retry_irq(&p
->syncp
, start
));
1853 stats
->rx_packets
+= rx_packets
;
1854 stats
->rx_bytes
+= rx_bytes
;
1855 stats
->multicast
+= rx_multicast
;
1856 stats
->tx_packets
+= tx_packets
;
1857 stats
->tx_bytes
+= tx_bytes
;
1859 * rx_dropped, tx_dropped & rx_nohandler are u32,
1860 * updated without syncp protection.
1862 rx_dropped
+= p
->rx_dropped
;
1863 tx_dropped
+= p
->tx_dropped
;
1864 rx_nohandler
+= p
->rx_nohandler
;
1866 stats
->rx_dropped
= rx_dropped
;
1867 stats
->tx_dropped
= tx_dropped
;
1868 stats
->rx_nohandler
= rx_nohandler
;
1871 static int team_vlan_rx_add_vid(struct net_device
*dev
, __be16 proto
, u16 vid
)
1873 struct team
*team
= netdev_priv(dev
);
1874 struct team_port
*port
;
1878 * Alhough this is reader, it's guarded by team lock. It's not possible
1879 * to traverse list in reverse under rcu_read_lock
1881 mutex_lock(&team
->lock
);
1882 list_for_each_entry(port
, &team
->port_list
, list
) {
1883 err
= vlan_vid_add(port
->dev
, proto
, vid
);
1887 mutex_unlock(&team
->lock
);
1892 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1893 vlan_vid_del(port
->dev
, proto
, vid
);
1894 mutex_unlock(&team
->lock
);
1899 static int team_vlan_rx_kill_vid(struct net_device
*dev
, __be16 proto
, u16 vid
)
1901 struct team
*team
= netdev_priv(dev
);
1902 struct team_port
*port
;
1904 mutex_lock(&team
->lock
);
1905 list_for_each_entry(port
, &team
->port_list
, list
)
1906 vlan_vid_del(port
->dev
, proto
, vid
);
1907 mutex_unlock(&team
->lock
);
1912 #ifdef CONFIG_NET_POLL_CONTROLLER
1913 static void team_poll_controller(struct net_device
*dev
)
1917 static void __team_netpoll_cleanup(struct team
*team
)
1919 struct team_port
*port
;
1921 list_for_each_entry(port
, &team
->port_list
, list
)
1922 team_port_disable_netpoll(port
);
1925 static void team_netpoll_cleanup(struct net_device
*dev
)
1927 struct team
*team
= netdev_priv(dev
);
1929 mutex_lock(&team
->lock
);
1930 __team_netpoll_cleanup(team
);
1931 mutex_unlock(&team
->lock
);
1934 static int team_netpoll_setup(struct net_device
*dev
,
1935 struct netpoll_info
*npifo
)
1937 struct team
*team
= netdev_priv(dev
);
1938 struct team_port
*port
;
1941 mutex_lock(&team
->lock
);
1942 list_for_each_entry(port
, &team
->port_list
, list
) {
1943 err
= __team_port_enable_netpoll(port
);
1945 __team_netpoll_cleanup(team
);
1949 mutex_unlock(&team
->lock
);
1954 static int team_add_slave(struct net_device
*dev
, struct net_device
*port_dev
,
1955 struct netlink_ext_ack
*extack
)
1957 struct team
*team
= netdev_priv(dev
);
1960 mutex_lock(&team
->lock
);
1961 err
= team_port_add(team
, port_dev
, extack
);
1962 mutex_unlock(&team
->lock
);
1965 netdev_change_features(dev
);
1970 static int team_del_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1972 struct team
*team
= netdev_priv(dev
);
1975 mutex_lock(&team
->lock
);
1976 err
= team_port_del(team
, port_dev
);
1977 mutex_unlock(&team
->lock
);
1980 netdev_change_features(dev
);
1985 static netdev_features_t
team_fix_features(struct net_device
*dev
,
1986 netdev_features_t features
)
1988 struct team_port
*port
;
1989 struct team
*team
= netdev_priv(dev
);
1990 netdev_features_t mask
;
1993 features
&= ~NETIF_F_ONE_FOR_ALL
;
1994 features
|= NETIF_F_ALL_FOR_ALL
;
1997 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1998 features
= netdev_increment_features(features
,
1999 port
->dev
->features
,
2004 features
= netdev_add_tso_features(features
, mask
);
2009 static int team_change_carrier(struct net_device
*dev
, bool new_carrier
)
2011 struct team
*team
= netdev_priv(dev
);
2013 team
->user_carrier_enabled
= true;
2016 netif_carrier_on(dev
);
2018 netif_carrier_off(dev
);
2022 static const struct net_device_ops team_netdev_ops
= {
2023 .ndo_init
= team_init
,
2024 .ndo_uninit
= team_uninit
,
2025 .ndo_open
= team_open
,
2026 .ndo_stop
= team_close
,
2027 .ndo_start_xmit
= team_xmit
,
2028 .ndo_select_queue
= team_select_queue
,
2029 .ndo_change_rx_flags
= team_change_rx_flags
,
2030 .ndo_set_rx_mode
= team_set_rx_mode
,
2031 .ndo_set_mac_address
= team_set_mac_address
,
2032 .ndo_change_mtu
= team_change_mtu
,
2033 .ndo_get_stats64
= team_get_stats64
,
2034 .ndo_vlan_rx_add_vid
= team_vlan_rx_add_vid
,
2035 .ndo_vlan_rx_kill_vid
= team_vlan_rx_kill_vid
,
2036 #ifdef CONFIG_NET_POLL_CONTROLLER
2037 .ndo_poll_controller
= team_poll_controller
,
2038 .ndo_netpoll_setup
= team_netpoll_setup
,
2039 .ndo_netpoll_cleanup
= team_netpoll_cleanup
,
2041 .ndo_add_slave
= team_add_slave
,
2042 .ndo_del_slave
= team_del_slave
,
2043 .ndo_fix_features
= team_fix_features
,
2044 .ndo_change_carrier
= team_change_carrier
,
2045 .ndo_features_check
= passthru_features_check
,
2048 /***********************
2050 ***********************/
2052 static void team_ethtool_get_drvinfo(struct net_device
*dev
,
2053 struct ethtool_drvinfo
*drvinfo
)
2055 strlcpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
2056 strlcpy(drvinfo
->version
, UTS_RELEASE
, sizeof(drvinfo
->version
));
2059 static int team_ethtool_get_link_ksettings(struct net_device
*dev
,
2060 struct ethtool_link_ksettings
*cmd
)
2062 struct team
*team
= netdev_priv(dev
);
2063 unsigned long speed
= 0;
2064 struct team_port
*port
;
2066 cmd
->base
.duplex
= DUPLEX_UNKNOWN
;
2067 cmd
->base
.port
= PORT_OTHER
;
2069 list_for_each_entry(port
, &team
->port_list
, list
) {
2070 if (team_port_txable(port
)) {
2071 if (port
->state
.speed
!= SPEED_UNKNOWN
)
2072 speed
+= port
->state
.speed
;
2073 if (cmd
->base
.duplex
== DUPLEX_UNKNOWN
&&
2074 port
->state
.duplex
!= DUPLEX_UNKNOWN
)
2075 cmd
->base
.duplex
= port
->state
.duplex
;
2078 cmd
->base
.speed
= speed
? : SPEED_UNKNOWN
;
2083 static const struct ethtool_ops team_ethtool_ops
= {
2084 .get_drvinfo
= team_ethtool_get_drvinfo
,
2085 .get_link
= ethtool_op_get_link
,
2086 .get_link_ksettings
= team_ethtool_get_link_ksettings
,
2089 /***********************
2090 * rt netlink interface
2091 ***********************/
2093 static void team_setup_by_port(struct net_device
*dev
,
2094 struct net_device
*port_dev
)
2096 dev
->header_ops
= port_dev
->header_ops
;
2097 dev
->type
= port_dev
->type
;
2098 dev
->hard_header_len
= port_dev
->hard_header_len
;
2099 dev
->addr_len
= port_dev
->addr_len
;
2100 dev
->mtu
= port_dev
->mtu
;
2101 memcpy(dev
->broadcast
, port_dev
->broadcast
, port_dev
->addr_len
);
2102 eth_hw_addr_inherit(dev
, port_dev
);
2105 static int team_dev_type_check_change(struct net_device
*dev
,
2106 struct net_device
*port_dev
)
2108 struct team
*team
= netdev_priv(dev
);
2109 char *portname
= port_dev
->name
;
2112 if (dev
->type
== port_dev
->type
)
2114 if (!list_empty(&team
->port_list
)) {
2115 netdev_err(dev
, "Device %s is of different type\n", portname
);
2118 err
= call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE
, dev
);
2119 err
= notifier_to_errno(err
);
2121 netdev_err(dev
, "Refused to change device type\n");
2126 team_setup_by_port(dev
, port_dev
);
2127 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE
, dev
);
2131 static void team_setup(struct net_device
*dev
)
2134 dev
->max_mtu
= ETH_MAX_MTU
;
2136 dev
->netdev_ops
= &team_netdev_ops
;
2137 dev
->ethtool_ops
= &team_ethtool_ops
;
2138 dev
->needs_free_netdev
= true;
2139 dev
->priv_destructor
= team_destructor
;
2140 dev
->priv_flags
&= ~(IFF_XMIT_DST_RELEASE
| IFF_TX_SKB_SHARING
);
2141 dev
->priv_flags
|= IFF_NO_QUEUE
;
2142 dev
->priv_flags
|= IFF_TEAM
;
2145 * Indicate we support unicast address filtering. That way core won't
2146 * bring us to promisc mode in case a unicast addr is added.
2147 * Let this up to underlay drivers.
2149 dev
->priv_flags
|= IFF_UNICAST_FLT
| IFF_LIVE_ADDR_CHANGE
;
2151 dev
->features
|= NETIF_F_LLTX
;
2152 dev
->features
|= NETIF_F_GRO
;
2154 /* Don't allow team devices to change network namespaces. */
2155 dev
->features
|= NETIF_F_NETNS_LOCAL
;
2157 dev
->hw_features
= TEAM_VLAN_FEATURES
|
2158 NETIF_F_HW_VLAN_CTAG_RX
|
2159 NETIF_F_HW_VLAN_CTAG_FILTER
;
2161 dev
->hw_features
|= NETIF_F_GSO_ENCAP_ALL
| NETIF_F_GSO_UDP_L4
;
2162 dev
->features
|= dev
->hw_features
;
2163 dev
->features
|= NETIF_F_HW_VLAN_CTAG_TX
| NETIF_F_HW_VLAN_STAG_TX
;
2166 static int team_newlink(struct net
*src_net
, struct net_device
*dev
,
2167 struct nlattr
*tb
[], struct nlattr
*data
[],
2168 struct netlink_ext_ack
*extack
)
2170 if (tb
[IFLA_ADDRESS
] == NULL
)
2171 eth_hw_addr_random(dev
);
2173 return register_netdevice(dev
);
2176 static int team_validate(struct nlattr
*tb
[], struct nlattr
*data
[],
2177 struct netlink_ext_ack
*extack
)
2179 if (tb
[IFLA_ADDRESS
]) {
2180 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
2182 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
2183 return -EADDRNOTAVAIL
;
2188 static unsigned int team_get_num_tx_queues(void)
2190 return TEAM_DEFAULT_NUM_TX_QUEUES
;
2193 static unsigned int team_get_num_rx_queues(void)
2195 return TEAM_DEFAULT_NUM_RX_QUEUES
;
2198 static struct rtnl_link_ops team_link_ops __read_mostly
= {
2200 .priv_size
= sizeof(struct team
),
2201 .setup
= team_setup
,
2202 .newlink
= team_newlink
,
2203 .validate
= team_validate
,
2204 .get_num_tx_queues
= team_get_num_tx_queues
,
2205 .get_num_rx_queues
= team_get_num_rx_queues
,
2209 /***********************************
2210 * Generic netlink custom interface
2211 ***********************************/
2213 static struct genl_family team_nl_family
;
2215 static const struct nla_policy team_nl_policy
[TEAM_ATTR_MAX
+ 1] = {
2216 [TEAM_ATTR_UNSPEC
] = { .type
= NLA_UNSPEC
, },
2217 [TEAM_ATTR_TEAM_IFINDEX
] = { .type
= NLA_U32
},
2218 [TEAM_ATTR_LIST_OPTION
] = { .type
= NLA_NESTED
},
2219 [TEAM_ATTR_LIST_PORT
] = { .type
= NLA_NESTED
},
2222 static const struct nla_policy
2223 team_nl_option_policy
[TEAM_ATTR_OPTION_MAX
+ 1] = {
2224 [TEAM_ATTR_OPTION_UNSPEC
] = { .type
= NLA_UNSPEC
, },
2225 [TEAM_ATTR_OPTION_NAME
] = {
2227 .len
= TEAM_STRING_MAX_LEN
,
2229 [TEAM_ATTR_OPTION_CHANGED
] = { .type
= NLA_FLAG
},
2230 [TEAM_ATTR_OPTION_TYPE
] = { .type
= NLA_U8
},
2231 [TEAM_ATTR_OPTION_DATA
] = { .type
= NLA_BINARY
},
2234 static int team_nl_cmd_noop(struct sk_buff
*skb
, struct genl_info
*info
)
2236 struct sk_buff
*msg
;
2240 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2244 hdr
= genlmsg_put(msg
, info
->snd_portid
, info
->snd_seq
,
2245 &team_nl_family
, 0, TEAM_CMD_NOOP
);
2251 genlmsg_end(msg
, hdr
);
2253 return genlmsg_unicast(genl_info_net(info
), msg
, info
->snd_portid
);
2262 * Netlink cmd functions should be locked by following two functions.
2263 * Since dev gets held here, that ensures dev won't disappear in between.
2265 static struct team
*team_nl_team_get(struct genl_info
*info
)
2267 struct net
*net
= genl_info_net(info
);
2269 struct net_device
*dev
;
2272 if (!info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
])
2275 ifindex
= nla_get_u32(info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
]);
2276 dev
= dev_get_by_index(net
, ifindex
);
2277 if (!dev
|| dev
->netdev_ops
!= &team_netdev_ops
) {
2283 team
= netdev_priv(dev
);
2284 mutex_lock(&team
->lock
);
2288 static void team_nl_team_put(struct team
*team
)
2290 mutex_unlock(&team
->lock
);
2294 typedef int team_nl_send_func_t(struct sk_buff
*skb
,
2295 struct team
*team
, u32 portid
);
2297 static int team_nl_send_unicast(struct sk_buff
*skb
, struct team
*team
, u32 portid
)
2299 return genlmsg_unicast(dev_net(team
->dev
), skb
, portid
);
2302 static int team_nl_fill_one_option_get(struct sk_buff
*skb
, struct team
*team
,
2303 struct team_option_inst
*opt_inst
)
2305 struct nlattr
*option_item
;
2306 struct team_option
*option
= opt_inst
->option
;
2307 struct team_option_inst_info
*opt_inst_info
= &opt_inst
->info
;
2308 struct team_gsetter_ctx ctx
;
2311 ctx
.info
= opt_inst_info
;
2312 err
= team_option_get(team
, opt_inst
, &ctx
);
2316 option_item
= nla_nest_start_noflag(skb
, TEAM_ATTR_ITEM_OPTION
);
2320 if (nla_put_string(skb
, TEAM_ATTR_OPTION_NAME
, option
->name
))
2322 if (opt_inst_info
->port
&&
2323 nla_put_u32(skb
, TEAM_ATTR_OPTION_PORT_IFINDEX
,
2324 opt_inst_info
->port
->dev
->ifindex
))
2326 if (opt_inst
->option
->array_size
&&
2327 nla_put_u32(skb
, TEAM_ATTR_OPTION_ARRAY_INDEX
,
2328 opt_inst_info
->array_index
))
2331 switch (option
->type
) {
2332 case TEAM_OPTION_TYPE_U32
:
2333 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_U32
))
2335 if (nla_put_u32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.u32_val
))
2338 case TEAM_OPTION_TYPE_STRING
:
2339 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_STRING
))
2341 if (nla_put_string(skb
, TEAM_ATTR_OPTION_DATA
,
2345 case TEAM_OPTION_TYPE_BINARY
:
2346 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_BINARY
))
2348 if (nla_put(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.bin_val
.len
,
2349 ctx
.data
.bin_val
.ptr
))
2352 case TEAM_OPTION_TYPE_BOOL
:
2353 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_FLAG
))
2355 if (ctx
.data
.bool_val
&&
2356 nla_put_flag(skb
, TEAM_ATTR_OPTION_DATA
))
2359 case TEAM_OPTION_TYPE_S32
:
2360 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_S32
))
2362 if (nla_put_s32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.s32_val
))
2368 if (opt_inst
->removed
&& nla_put_flag(skb
, TEAM_ATTR_OPTION_REMOVED
))
2370 if (opt_inst
->changed
) {
2371 if (nla_put_flag(skb
, TEAM_ATTR_OPTION_CHANGED
))
2373 opt_inst
->changed
= false;
2375 nla_nest_end(skb
, option_item
);
2379 nla_nest_cancel(skb
, option_item
);
2383 static int __send_and_alloc_skb(struct sk_buff
**pskb
,
2384 struct team
*team
, u32 portid
,
2385 team_nl_send_func_t
*send_func
)
2390 err
= send_func(*pskb
, team
, portid
);
2394 *pskb
= genlmsg_new(GENLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2400 static int team_nl_send_options_get(struct team
*team
, u32 portid
, u32 seq
,
2401 int flags
, team_nl_send_func_t
*send_func
,
2402 struct list_head
*sel_opt_inst_list
)
2404 struct nlattr
*option_list
;
2405 struct nlmsghdr
*nlh
;
2407 struct team_option_inst
*opt_inst
;
2409 struct sk_buff
*skb
= NULL
;
2413 opt_inst
= list_first_entry(sel_opt_inst_list
,
2414 struct team_option_inst
, tmp_list
);
2417 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2421 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2422 TEAM_CMD_OPTIONS_GET
);
2428 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2429 goto nla_put_failure
;
2430 option_list
= nla_nest_start_noflag(skb
, TEAM_ATTR_LIST_OPTION
);
2432 goto nla_put_failure
;
2436 list_for_each_entry_from(opt_inst
, sel_opt_inst_list
, tmp_list
) {
2437 err
= team_nl_fill_one_option_get(skb
, team
, opt_inst
);
2439 if (err
== -EMSGSIZE
) {
2450 nla_nest_end(skb
, option_list
);
2451 genlmsg_end(skb
, hdr
);
2456 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2458 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2464 return send_func(skb
, team
, portid
);
2473 static int team_nl_cmd_options_get(struct sk_buff
*skb
, struct genl_info
*info
)
2476 struct team_option_inst
*opt_inst
;
2478 LIST_HEAD(sel_opt_inst_list
);
2480 team
= team_nl_team_get(info
);
2484 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
)
2485 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2486 err
= team_nl_send_options_get(team
, info
->snd_portid
, info
->snd_seq
,
2487 NLM_F_ACK
, team_nl_send_unicast
,
2488 &sel_opt_inst_list
);
2490 team_nl_team_put(team
);
2495 static int team_nl_send_event_options_get(struct team
*team
,
2496 struct list_head
*sel_opt_inst_list
);
2498 static int team_nl_cmd_options_set(struct sk_buff
*skb
, struct genl_info
*info
)
2503 struct nlattr
*nl_option
;
2507 team
= team_nl_team_get(info
);
2514 if (!info
->attrs
[TEAM_ATTR_LIST_OPTION
]) {
2519 nla_for_each_nested(nl_option
, info
->attrs
[TEAM_ATTR_LIST_OPTION
], i
) {
2520 struct nlattr
*opt_attrs
[TEAM_ATTR_OPTION_MAX
+ 1];
2521 struct nlattr
*attr
;
2522 struct nlattr
*attr_data
;
2523 LIST_HEAD(opt_inst_list
);
2524 enum team_option_type opt_type
;
2525 int opt_port_ifindex
= 0; /* != 0 for per-port options */
2526 u32 opt_array_index
= 0;
2527 bool opt_is_array
= false;
2528 struct team_option_inst
*opt_inst
;
2530 bool opt_found
= false;
2532 if (nla_type(nl_option
) != TEAM_ATTR_ITEM_OPTION
) {
2536 err
= nla_parse_nested_deprecated(opt_attrs
,
2537 TEAM_ATTR_OPTION_MAX
,
2539 team_nl_option_policy
,
2543 if (!opt_attrs
[TEAM_ATTR_OPTION_NAME
] ||
2544 !opt_attrs
[TEAM_ATTR_OPTION_TYPE
]) {
2548 switch (nla_get_u8(opt_attrs
[TEAM_ATTR_OPTION_TYPE
])) {
2550 opt_type
= TEAM_OPTION_TYPE_U32
;
2553 opt_type
= TEAM_OPTION_TYPE_STRING
;
2556 opt_type
= TEAM_OPTION_TYPE_BINARY
;
2559 opt_type
= TEAM_OPTION_TYPE_BOOL
;
2562 opt_type
= TEAM_OPTION_TYPE_S32
;
2568 attr_data
= opt_attrs
[TEAM_ATTR_OPTION_DATA
];
2569 if (opt_type
!= TEAM_OPTION_TYPE_BOOL
&& !attr_data
) {
2574 opt_name
= nla_data(opt_attrs
[TEAM_ATTR_OPTION_NAME
]);
2575 attr
= opt_attrs
[TEAM_ATTR_OPTION_PORT_IFINDEX
];
2577 opt_port_ifindex
= nla_get_u32(attr
);
2579 attr
= opt_attrs
[TEAM_ATTR_OPTION_ARRAY_INDEX
];
2581 opt_is_array
= true;
2582 opt_array_index
= nla_get_u32(attr
);
2585 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2586 struct team_option
*option
= opt_inst
->option
;
2587 struct team_gsetter_ctx ctx
;
2588 struct team_option_inst_info
*opt_inst_info
;
2591 opt_inst_info
= &opt_inst
->info
;
2592 tmp_ifindex
= opt_inst_info
->port
?
2593 opt_inst_info
->port
->dev
->ifindex
: 0;
2594 if (option
->type
!= opt_type
||
2595 strcmp(option
->name
, opt_name
) ||
2596 tmp_ifindex
!= opt_port_ifindex
||
2597 (option
->array_size
&& !opt_is_array
) ||
2598 opt_inst_info
->array_index
!= opt_array_index
)
2601 ctx
.info
= opt_inst_info
;
2603 case TEAM_OPTION_TYPE_U32
:
2604 ctx
.data
.u32_val
= nla_get_u32(attr_data
);
2606 case TEAM_OPTION_TYPE_STRING
:
2607 if (nla_len(attr_data
) > TEAM_STRING_MAX_LEN
) {
2611 ctx
.data
.str_val
= nla_data(attr_data
);
2613 case TEAM_OPTION_TYPE_BINARY
:
2614 ctx
.data
.bin_val
.len
= nla_len(attr_data
);
2615 ctx
.data
.bin_val
.ptr
= nla_data(attr_data
);
2617 case TEAM_OPTION_TYPE_BOOL
:
2618 ctx
.data
.bool_val
= attr_data
? true : false;
2620 case TEAM_OPTION_TYPE_S32
:
2621 ctx
.data
.s32_val
= nla_get_s32(attr_data
);
2626 err
= team_option_set(team
, opt_inst
, &ctx
);
2629 opt_inst
->changed
= true;
2630 list_add(&opt_inst
->tmp_list
, &opt_inst_list
);
2637 err
= team_nl_send_event_options_get(team
, &opt_inst_list
);
2643 team_nl_team_put(team
);
2649 static int team_nl_fill_one_port_get(struct sk_buff
*skb
,
2650 struct team_port
*port
)
2652 struct nlattr
*port_item
;
2654 port_item
= nla_nest_start_noflag(skb
, TEAM_ATTR_ITEM_PORT
);
2657 if (nla_put_u32(skb
, TEAM_ATTR_PORT_IFINDEX
, port
->dev
->ifindex
))
2659 if (port
->changed
) {
2660 if (nla_put_flag(skb
, TEAM_ATTR_PORT_CHANGED
))
2662 port
->changed
= false;
2664 if ((port
->removed
&&
2665 nla_put_flag(skb
, TEAM_ATTR_PORT_REMOVED
)) ||
2666 (port
->state
.linkup
&&
2667 nla_put_flag(skb
, TEAM_ATTR_PORT_LINKUP
)) ||
2668 nla_put_u32(skb
, TEAM_ATTR_PORT_SPEED
, port
->state
.speed
) ||
2669 nla_put_u8(skb
, TEAM_ATTR_PORT_DUPLEX
, port
->state
.duplex
))
2671 nla_nest_end(skb
, port_item
);
2675 nla_nest_cancel(skb
, port_item
);
2679 static int team_nl_send_port_list_get(struct team
*team
, u32 portid
, u32 seq
,
2680 int flags
, team_nl_send_func_t
*send_func
,
2681 struct team_port
*one_port
)
2683 struct nlattr
*port_list
;
2684 struct nlmsghdr
*nlh
;
2686 struct team_port
*port
;
2688 struct sk_buff
*skb
= NULL
;
2692 port
= list_first_entry_or_null(&team
->port_list
,
2693 struct team_port
, list
);
2696 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2700 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2701 TEAM_CMD_PORT_LIST_GET
);
2707 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2708 goto nla_put_failure
;
2709 port_list
= nla_nest_start_noflag(skb
, TEAM_ATTR_LIST_PORT
);
2711 goto nla_put_failure
;
2716 /* If one port is selected, called wants to send port list containing
2717 * only this port. Otherwise go through all listed ports and send all
2720 err
= team_nl_fill_one_port_get(skb
, one_port
);
2724 list_for_each_entry_from(port
, &team
->port_list
, list
) {
2725 err
= team_nl_fill_one_port_get(skb
, port
);
2727 if (err
== -EMSGSIZE
) {
2739 nla_nest_end(skb
, port_list
);
2740 genlmsg_end(skb
, hdr
);
2745 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2747 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2753 return send_func(skb
, team
, portid
);
2762 static int team_nl_cmd_port_list_get(struct sk_buff
*skb
,
2763 struct genl_info
*info
)
2768 team
= team_nl_team_get(info
);
2772 err
= team_nl_send_port_list_get(team
, info
->snd_portid
, info
->snd_seq
,
2773 NLM_F_ACK
, team_nl_send_unicast
, NULL
);
2775 team_nl_team_put(team
);
2780 static const struct genl_ops team_nl_ops
[] = {
2782 .cmd
= TEAM_CMD_NOOP
,
2783 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
2784 .doit
= team_nl_cmd_noop
,
2787 .cmd
= TEAM_CMD_OPTIONS_SET
,
2788 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
2789 .doit
= team_nl_cmd_options_set
,
2790 .flags
= GENL_ADMIN_PERM
,
2793 .cmd
= TEAM_CMD_OPTIONS_GET
,
2794 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
2795 .doit
= team_nl_cmd_options_get
,
2796 .flags
= GENL_ADMIN_PERM
,
2799 .cmd
= TEAM_CMD_PORT_LIST_GET
,
2800 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
2801 .doit
= team_nl_cmd_port_list_get
,
2802 .flags
= GENL_ADMIN_PERM
,
2806 static const struct genl_multicast_group team_nl_mcgrps
[] = {
2807 { .name
= TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME
, },
2810 static struct genl_family team_nl_family __ro_after_init
= {
2811 .name
= TEAM_GENL_NAME
,
2812 .version
= TEAM_GENL_VERSION
,
2813 .maxattr
= TEAM_ATTR_MAX
,
2814 .policy
= team_nl_policy
,
2816 .module
= THIS_MODULE
,
2818 .n_ops
= ARRAY_SIZE(team_nl_ops
),
2819 .mcgrps
= team_nl_mcgrps
,
2820 .n_mcgrps
= ARRAY_SIZE(team_nl_mcgrps
),
2823 static int team_nl_send_multicast(struct sk_buff
*skb
,
2824 struct team
*team
, u32 portid
)
2826 return genlmsg_multicast_netns(&team_nl_family
, dev_net(team
->dev
),
2827 skb
, 0, 0, GFP_KERNEL
);
2830 static int team_nl_send_event_options_get(struct team
*team
,
2831 struct list_head
*sel_opt_inst_list
)
2833 return team_nl_send_options_get(team
, 0, 0, 0, team_nl_send_multicast
,
2837 static int team_nl_send_event_port_get(struct team
*team
,
2838 struct team_port
*port
)
2840 return team_nl_send_port_list_get(team
, 0, 0, 0, team_nl_send_multicast
,
2844 static int __init
team_nl_init(void)
2846 return genl_register_family(&team_nl_family
);
2849 static void team_nl_fini(void)
2851 genl_unregister_family(&team_nl_family
);
2859 static void __team_options_change_check(struct team
*team
)
2862 struct team_option_inst
*opt_inst
;
2863 LIST_HEAD(sel_opt_inst_list
);
2865 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2866 if (opt_inst
->changed
)
2867 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2869 err
= team_nl_send_event_options_get(team
, &sel_opt_inst_list
);
2870 if (err
&& err
!= -ESRCH
)
2871 netdev_warn(team
->dev
, "Failed to send options change via netlink (err %d)\n",
2875 /* rtnl lock is held */
2877 static void __team_port_change_send(struct team_port
*port
, bool linkup
)
2881 port
->changed
= true;
2882 port
->state
.linkup
= linkup
;
2883 team_refresh_port_linkup(port
);
2885 struct ethtool_link_ksettings ecmd
;
2887 err
= __ethtool_get_link_ksettings(port
->dev
, &ecmd
);
2889 port
->state
.speed
= ecmd
.base
.speed
;
2890 port
->state
.duplex
= ecmd
.base
.duplex
;
2894 port
->state
.speed
= 0;
2895 port
->state
.duplex
= 0;
2898 err
= team_nl_send_event_port_get(port
->team
, port
);
2899 if (err
&& err
!= -ESRCH
)
2900 netdev_warn(port
->team
->dev
, "Failed to send port change of device %s via netlink (err %d)\n",
2901 port
->dev
->name
, err
);
2905 static void __team_carrier_check(struct team
*team
)
2907 struct team_port
*port
;
2910 if (team
->user_carrier_enabled
)
2913 team_linkup
= false;
2914 list_for_each_entry(port
, &team
->port_list
, list
) {
2922 netif_carrier_on(team
->dev
);
2924 netif_carrier_off(team
->dev
);
2927 static void __team_port_change_check(struct team_port
*port
, bool linkup
)
2929 if (port
->state
.linkup
!= linkup
)
2930 __team_port_change_send(port
, linkup
);
2931 __team_carrier_check(port
->team
);
2934 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
)
2936 __team_port_change_send(port
, linkup
);
2937 __team_carrier_check(port
->team
);
2940 static void __team_port_change_port_removed(struct team_port
*port
)
2942 port
->removed
= true;
2943 __team_port_change_send(port
, false);
2944 __team_carrier_check(port
->team
);
2947 static void team_port_change_check(struct team_port
*port
, bool linkup
)
2949 struct team
*team
= port
->team
;
2951 mutex_lock(&team
->lock
);
2952 __team_port_change_check(port
, linkup
);
2953 mutex_unlock(&team
->lock
);
2957 /************************************
2958 * Net device notifier event handler
2959 ************************************/
2961 static int team_device_event(struct notifier_block
*unused
,
2962 unsigned long event
, void *ptr
)
2964 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
2965 struct team_port
*port
;
2967 port
= team_port_get_rtnl(dev
);
2973 if (netif_oper_up(dev
))
2974 team_port_change_check(port
, true);
2977 team_port_change_check(port
, false);
2980 if (netif_running(port
->dev
))
2981 team_port_change_check(port
,
2982 !!netif_oper_up(port
->dev
));
2984 case NETDEV_UNREGISTER
:
2985 team_del_slave(port
->team
->dev
, dev
);
2987 case NETDEV_FEAT_CHANGE
:
2988 team_compute_features(port
->team
);
2990 case NETDEV_PRECHANGEMTU
:
2991 /* Forbid to change mtu of underlaying device */
2992 if (!port
->team
->port_mtu_change_allowed
)
2995 case NETDEV_PRE_TYPE_CHANGE
:
2996 /* Forbid to change type of underlaying device */
2998 case NETDEV_RESEND_IGMP
:
2999 /* Propagate to master device */
3000 call_netdevice_notifiers(event
, port
->team
->dev
);
3006 static struct notifier_block team_notifier_block __read_mostly
= {
3007 .notifier_call
= team_device_event
,
3011 /***********************
3012 * Module init and exit
3013 ***********************/
3015 static int __init
team_module_init(void)
3019 register_netdevice_notifier(&team_notifier_block
);
3021 err
= rtnl_link_register(&team_link_ops
);
3025 err
= team_nl_init();
3032 rtnl_link_unregister(&team_link_ops
);
3035 unregister_netdevice_notifier(&team_notifier_block
);
3040 static void __exit
team_module_exit(void)
3043 rtnl_link_unregister(&team_link_ops
);
3044 unregister_netdevice_notifier(&team_notifier_block
);
3047 module_init(team_module_init
);
3048 module_exit(team_module_exit
);
3050 MODULE_LICENSE("GPL v2");
3051 MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
3052 MODULE_DESCRIPTION("Ethernet team device driver");
3053 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);