2 * drivers/net/team/team.c - Network team device driver
3 * Copyright (c) 2011 Jiri Pirko <jpirko@redhat.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
11 #include <linux/kernel.h>
12 #include <linux/types.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/rcupdate.h>
17 #include <linux/errno.h>
18 #include <linux/ctype.h>
19 #include <linux/notifier.h>
20 #include <linux/netdevice.h>
21 #include <linux/netpoll.h>
22 #include <linux/if_vlan.h>
23 #include <linux/if_arp.h>
24 #include <linux/socket.h>
25 #include <linux/etherdevice.h>
26 #include <linux/rtnetlink.h>
27 #include <net/rtnetlink.h>
28 #include <net/genetlink.h>
29 #include <net/netlink.h>
30 #include <net/sch_generic.h>
31 #include <net/switchdev.h>
32 #include <generated/utsrelease.h>
33 #include <linux/if_team.h>
35 #define DRV_NAME "team"
42 #define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT)
44 static struct team_port
*team_port_get_rcu(const struct net_device
*dev
)
46 return rcu_dereference(dev
->rx_handler_data
);
49 static struct team_port
*team_port_get_rtnl(const struct net_device
*dev
)
51 struct team_port
*port
= rtnl_dereference(dev
->rx_handler_data
);
53 return team_port_exists(dev
) ? port
: NULL
;
57 * Since the ability to change device address for open port device is tested in
58 * team_port_add, this function can be called without control of return value
60 static int __set_port_dev_addr(struct net_device
*port_dev
,
61 const unsigned char *dev_addr
)
65 memcpy(addr
.sa_data
, dev_addr
, port_dev
->addr_len
);
66 addr
.sa_family
= port_dev
->type
;
67 return dev_set_mac_address(port_dev
, &addr
);
70 static int team_port_set_orig_dev_addr(struct team_port
*port
)
72 return __set_port_dev_addr(port
->dev
, port
->orig
.dev_addr
);
75 static int team_port_set_team_dev_addr(struct team
*team
,
76 struct team_port
*port
)
78 return __set_port_dev_addr(port
->dev
, team
->dev
->dev_addr
);
81 int team_modeop_port_enter(struct team
*team
, struct team_port
*port
)
83 return team_port_set_team_dev_addr(team
, port
);
85 EXPORT_SYMBOL(team_modeop_port_enter
);
87 void team_modeop_port_change_dev_addr(struct team
*team
,
88 struct team_port
*port
)
90 team_port_set_team_dev_addr(team
, port
);
92 EXPORT_SYMBOL(team_modeop_port_change_dev_addr
);
94 static void team_lower_state_changed(struct team_port
*port
)
96 struct netdev_lag_lower_state_info info
;
98 info
.link_up
= port
->linkup
;
99 info
.tx_enabled
= team_port_enabled(port
);
100 netdev_lower_state_changed(port
->dev
, &info
);
103 static void team_refresh_port_linkup(struct team_port
*port
)
105 bool new_linkup
= port
->user
.linkup_enabled
? port
->user
.linkup
:
108 if (port
->linkup
!= new_linkup
) {
109 port
->linkup
= new_linkup
;
110 team_lower_state_changed(port
);
119 struct team_option_inst
{ /* One for each option instance */
120 struct list_head list
;
121 struct list_head tmp_list
;
122 struct team_option
*option
;
123 struct team_option_inst_info info
;
128 static struct team_option
*__team_find_option(struct team
*team
,
129 const char *opt_name
)
131 struct team_option
*option
;
133 list_for_each_entry(option
, &team
->option_list
, list
) {
134 if (strcmp(option
->name
, opt_name
) == 0)
140 static void __team_option_inst_del(struct team_option_inst
*opt_inst
)
142 list_del(&opt_inst
->list
);
146 static void __team_option_inst_del_option(struct team
*team
,
147 struct team_option
*option
)
149 struct team_option_inst
*opt_inst
, *tmp
;
151 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
152 if (opt_inst
->option
== option
)
153 __team_option_inst_del(opt_inst
);
157 static int __team_option_inst_add(struct team
*team
, struct team_option
*option
,
158 struct team_port
*port
)
160 struct team_option_inst
*opt_inst
;
161 unsigned int array_size
;
165 array_size
= option
->array_size
;
167 array_size
= 1; /* No array but still need one instance */
169 for (i
= 0; i
< array_size
; i
++) {
170 opt_inst
= kmalloc(sizeof(*opt_inst
), GFP_KERNEL
);
173 opt_inst
->option
= option
;
174 opt_inst
->info
.port
= port
;
175 opt_inst
->info
.array_index
= i
;
176 opt_inst
->changed
= true;
177 opt_inst
->removed
= false;
178 list_add_tail(&opt_inst
->list
, &team
->option_inst_list
);
180 err
= option
->init(team
, &opt_inst
->info
);
189 static int __team_option_inst_add_option(struct team
*team
,
190 struct team_option
*option
)
194 if (!option
->per_port
) {
195 err
= __team_option_inst_add(team
, option
, NULL
);
197 goto inst_del_option
;
202 __team_option_inst_del_option(team
, option
);
206 static void __team_option_inst_mark_removed_option(struct team
*team
,
207 struct team_option
*option
)
209 struct team_option_inst
*opt_inst
;
211 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
212 if (opt_inst
->option
== option
) {
213 opt_inst
->changed
= true;
214 opt_inst
->removed
= true;
219 static void __team_option_inst_del_port(struct team
*team
,
220 struct team_port
*port
)
222 struct team_option_inst
*opt_inst
, *tmp
;
224 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
225 if (opt_inst
->option
->per_port
&&
226 opt_inst
->info
.port
== port
)
227 __team_option_inst_del(opt_inst
);
231 static int __team_option_inst_add_port(struct team
*team
,
232 struct team_port
*port
)
234 struct team_option
*option
;
237 list_for_each_entry(option
, &team
->option_list
, list
) {
238 if (!option
->per_port
)
240 err
= __team_option_inst_add(team
, option
, port
);
247 __team_option_inst_del_port(team
, port
);
251 static void __team_option_inst_mark_removed_port(struct team
*team
,
252 struct team_port
*port
)
254 struct team_option_inst
*opt_inst
;
256 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
257 if (opt_inst
->info
.port
== port
) {
258 opt_inst
->changed
= true;
259 opt_inst
->removed
= true;
264 static int __team_options_register(struct team
*team
,
265 const struct team_option
*option
,
269 struct team_option
**dst_opts
;
272 dst_opts
= kzalloc(sizeof(struct team_option
*) * option_count
,
276 for (i
= 0; i
< option_count
; i
++, option
++) {
277 if (__team_find_option(team
, option
->name
)) {
281 dst_opts
[i
] = kmemdup(option
, sizeof(*option
), GFP_KERNEL
);
288 for (i
= 0; i
< option_count
; i
++) {
289 err
= __team_option_inst_add_option(team
, dst_opts
[i
]);
292 list_add_tail(&dst_opts
[i
]->list
, &team
->option_list
);
299 for (i
--; i
>= 0; i
--)
300 __team_option_inst_del_option(team
, dst_opts
[i
]);
302 i
= option_count
- 1;
304 for (i
--; i
>= 0; i
--)
311 static void __team_options_mark_removed(struct team
*team
,
312 const struct team_option
*option
,
317 for (i
= 0; i
< option_count
; i
++, option
++) {
318 struct team_option
*del_opt
;
320 del_opt
= __team_find_option(team
, option
->name
);
322 __team_option_inst_mark_removed_option(team
, del_opt
);
326 static void __team_options_unregister(struct team
*team
,
327 const struct team_option
*option
,
332 for (i
= 0; i
< option_count
; i
++, option
++) {
333 struct team_option
*del_opt
;
335 del_opt
= __team_find_option(team
, option
->name
);
337 __team_option_inst_del_option(team
, del_opt
);
338 list_del(&del_opt
->list
);
344 static void __team_options_change_check(struct team
*team
);
346 int team_options_register(struct team
*team
,
347 const struct team_option
*option
,
352 err
= __team_options_register(team
, option
, option_count
);
355 __team_options_change_check(team
);
358 EXPORT_SYMBOL(team_options_register
);
360 void team_options_unregister(struct team
*team
,
361 const struct team_option
*option
,
364 __team_options_mark_removed(team
, option
, option_count
);
365 __team_options_change_check(team
);
366 __team_options_unregister(team
, option
, option_count
);
368 EXPORT_SYMBOL(team_options_unregister
);
370 static int team_option_get(struct team
*team
,
371 struct team_option_inst
*opt_inst
,
372 struct team_gsetter_ctx
*ctx
)
374 if (!opt_inst
->option
->getter
)
376 return opt_inst
->option
->getter(team
, ctx
);
379 static int team_option_set(struct team
*team
,
380 struct team_option_inst
*opt_inst
,
381 struct team_gsetter_ctx
*ctx
)
383 if (!opt_inst
->option
->setter
)
385 return opt_inst
->option
->setter(team
, ctx
);
388 void team_option_inst_set_change(struct team_option_inst_info
*opt_inst_info
)
390 struct team_option_inst
*opt_inst
;
392 opt_inst
= container_of(opt_inst_info
, struct team_option_inst
, info
);
393 opt_inst
->changed
= true;
395 EXPORT_SYMBOL(team_option_inst_set_change
);
397 void team_options_change_check(struct team
*team
)
399 __team_options_change_check(team
);
401 EXPORT_SYMBOL(team_options_change_check
);
408 static LIST_HEAD(mode_list
);
409 static DEFINE_SPINLOCK(mode_list_lock
);
411 struct team_mode_item
{
412 struct list_head list
;
413 const struct team_mode
*mode
;
416 static struct team_mode_item
*__find_mode(const char *kind
)
418 struct team_mode_item
*mitem
;
420 list_for_each_entry(mitem
, &mode_list
, list
) {
421 if (strcmp(mitem
->mode
->kind
, kind
) == 0)
427 static bool is_good_mode_name(const char *name
)
429 while (*name
!= '\0') {
430 if (!isalpha(*name
) && !isdigit(*name
) && *name
!= '_')
437 int team_mode_register(const struct team_mode
*mode
)
440 struct team_mode_item
*mitem
;
442 if (!is_good_mode_name(mode
->kind
) ||
443 mode
->priv_size
> TEAM_MODE_PRIV_SIZE
)
446 mitem
= kmalloc(sizeof(*mitem
), GFP_KERNEL
);
450 spin_lock(&mode_list_lock
);
451 if (__find_mode(mode
->kind
)) {
457 list_add_tail(&mitem
->list
, &mode_list
);
459 spin_unlock(&mode_list_lock
);
462 EXPORT_SYMBOL(team_mode_register
);
464 void team_mode_unregister(const struct team_mode
*mode
)
466 struct team_mode_item
*mitem
;
468 spin_lock(&mode_list_lock
);
469 mitem
= __find_mode(mode
->kind
);
471 list_del_init(&mitem
->list
);
474 spin_unlock(&mode_list_lock
);
476 EXPORT_SYMBOL(team_mode_unregister
);
478 static const struct team_mode
*team_mode_get(const char *kind
)
480 struct team_mode_item
*mitem
;
481 const struct team_mode
*mode
= NULL
;
483 spin_lock(&mode_list_lock
);
484 mitem
= __find_mode(kind
);
486 spin_unlock(&mode_list_lock
);
487 request_module("team-mode-%s", kind
);
488 spin_lock(&mode_list_lock
);
489 mitem
= __find_mode(kind
);
493 if (!try_module_get(mode
->owner
))
497 spin_unlock(&mode_list_lock
);
501 static void team_mode_put(const struct team_mode
*mode
)
503 module_put(mode
->owner
);
506 static bool team_dummy_transmit(struct team
*team
, struct sk_buff
*skb
)
508 dev_kfree_skb_any(skb
);
512 static rx_handler_result_t
team_dummy_receive(struct team
*team
,
513 struct team_port
*port
,
516 return RX_HANDLER_ANOTHER
;
519 static const struct team_mode __team_no_mode
= {
523 static bool team_is_mode_set(struct team
*team
)
525 return team
->mode
!= &__team_no_mode
;
528 static void team_set_no_mode(struct team
*team
)
530 team
->user_carrier_enabled
= false;
531 team
->mode
= &__team_no_mode
;
534 static void team_adjust_ops(struct team
*team
)
537 * To avoid checks in rx/tx skb paths, ensure here that non-null and
538 * correct ops are always set.
541 if (!team
->en_port_count
|| !team_is_mode_set(team
) ||
542 !team
->mode
->ops
->transmit
)
543 team
->ops
.transmit
= team_dummy_transmit
;
545 team
->ops
.transmit
= team
->mode
->ops
->transmit
;
547 if (!team
->en_port_count
|| !team_is_mode_set(team
) ||
548 !team
->mode
->ops
->receive
)
549 team
->ops
.receive
= team_dummy_receive
;
551 team
->ops
.receive
= team
->mode
->ops
->receive
;
555 * We can benefit from the fact that it's ensured no port is present
556 * at the time of mode change. Therefore no packets are in fly so there's no
557 * need to set mode operations in any special way.
559 static int __team_change_mode(struct team
*team
,
560 const struct team_mode
*new_mode
)
562 /* Check if mode was previously set and do cleanup if so */
563 if (team_is_mode_set(team
)) {
564 void (*exit_op
)(struct team
*team
) = team
->ops
.exit
;
566 /* Clear ops area so no callback is called any longer */
567 memset(&team
->ops
, 0, sizeof(struct team_mode_ops
));
568 team_adjust_ops(team
);
572 team_mode_put(team
->mode
);
573 team_set_no_mode(team
);
574 /* zero private data area */
575 memset(&team
->mode_priv
, 0,
576 sizeof(struct team
) - offsetof(struct team
, mode_priv
));
582 if (new_mode
->ops
->init
) {
585 err
= new_mode
->ops
->init(team
);
590 team
->mode
= new_mode
;
591 memcpy(&team
->ops
, new_mode
->ops
, sizeof(struct team_mode_ops
));
592 team_adjust_ops(team
);
597 static int team_change_mode(struct team
*team
, const char *kind
)
599 const struct team_mode
*new_mode
;
600 struct net_device
*dev
= team
->dev
;
603 if (!list_empty(&team
->port_list
)) {
604 netdev_err(dev
, "No ports can be present during mode change\n");
608 if (team_is_mode_set(team
) && strcmp(team
->mode
->kind
, kind
) == 0) {
609 netdev_err(dev
, "Unable to change to the same mode the team is in\n");
613 new_mode
= team_mode_get(kind
);
615 netdev_err(dev
, "Mode \"%s\" not found\n", kind
);
619 err
= __team_change_mode(team
, new_mode
);
621 netdev_err(dev
, "Failed to change to mode \"%s\"\n", kind
);
622 team_mode_put(new_mode
);
626 netdev_info(dev
, "Mode changed to \"%s\"\n", kind
);
631 /*********************
633 *********************/
635 static void team_notify_peers_work(struct work_struct
*work
)
640 team
= container_of(work
, struct team
, notify_peers
.dw
.work
);
642 if (!rtnl_trylock()) {
643 schedule_delayed_work(&team
->notify_peers
.dw
, 0);
646 val
= atomic_dec_if_positive(&team
->notify_peers
.count_pending
);
651 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS
, team
->dev
);
654 schedule_delayed_work(&team
->notify_peers
.dw
,
655 msecs_to_jiffies(team
->notify_peers
.interval
));
658 static void team_notify_peers(struct team
*team
)
660 if (!team
->notify_peers
.count
|| !netif_running(team
->dev
))
662 atomic_add(team
->notify_peers
.count
, &team
->notify_peers
.count_pending
);
663 schedule_delayed_work(&team
->notify_peers
.dw
, 0);
666 static void team_notify_peers_init(struct team
*team
)
668 INIT_DELAYED_WORK(&team
->notify_peers
.dw
, team_notify_peers_work
);
671 static void team_notify_peers_fini(struct team
*team
)
673 cancel_delayed_work_sync(&team
->notify_peers
.dw
);
677 /*******************************
678 * Send multicast group rejoins
679 *******************************/
681 static void team_mcast_rejoin_work(struct work_struct
*work
)
686 team
= container_of(work
, struct team
, mcast_rejoin
.dw
.work
);
688 if (!rtnl_trylock()) {
689 schedule_delayed_work(&team
->mcast_rejoin
.dw
, 0);
692 val
= atomic_dec_if_positive(&team
->mcast_rejoin
.count_pending
);
697 call_netdevice_notifiers(NETDEV_RESEND_IGMP
, team
->dev
);
700 schedule_delayed_work(&team
->mcast_rejoin
.dw
,
701 msecs_to_jiffies(team
->mcast_rejoin
.interval
));
704 static void team_mcast_rejoin(struct team
*team
)
706 if (!team
->mcast_rejoin
.count
|| !netif_running(team
->dev
))
708 atomic_add(team
->mcast_rejoin
.count
, &team
->mcast_rejoin
.count_pending
);
709 schedule_delayed_work(&team
->mcast_rejoin
.dw
, 0);
712 static void team_mcast_rejoin_init(struct team
*team
)
714 INIT_DELAYED_WORK(&team
->mcast_rejoin
.dw
, team_mcast_rejoin_work
);
717 static void team_mcast_rejoin_fini(struct team
*team
)
719 cancel_delayed_work_sync(&team
->mcast_rejoin
.dw
);
723 /************************
724 * Rx path frame handler
725 ************************/
727 /* note: already called with rcu_read_lock */
728 static rx_handler_result_t
team_handle_frame(struct sk_buff
**pskb
)
730 struct sk_buff
*skb
= *pskb
;
731 struct team_port
*port
;
733 rx_handler_result_t res
;
735 skb
= skb_share_check(skb
, GFP_ATOMIC
);
737 return RX_HANDLER_CONSUMED
;
741 port
= team_port_get_rcu(skb
->dev
);
743 if (!team_port_enabled(port
)) {
744 /* allow exact match delivery for disabled ports */
745 res
= RX_HANDLER_EXACT
;
747 res
= team
->ops
.receive(team
, port
, skb
);
749 if (res
== RX_HANDLER_ANOTHER
) {
750 struct team_pcpu_stats
*pcpu_stats
;
752 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
753 u64_stats_update_begin(&pcpu_stats
->syncp
);
754 pcpu_stats
->rx_packets
++;
755 pcpu_stats
->rx_bytes
+= skb
->len
;
756 if (skb
->pkt_type
== PACKET_MULTICAST
)
757 pcpu_stats
->rx_multicast
++;
758 u64_stats_update_end(&pcpu_stats
->syncp
);
760 skb
->dev
= team
->dev
;
761 } else if (res
== RX_HANDLER_EXACT
) {
762 this_cpu_inc(team
->pcpu_stats
->rx_nohandler
);
764 this_cpu_inc(team
->pcpu_stats
->rx_dropped
);
771 /*************************************
772 * Multiqueue Tx port select override
773 *************************************/
775 static int team_queue_override_init(struct team
*team
)
777 struct list_head
*listarr
;
778 unsigned int queue_cnt
= team
->dev
->num_tx_queues
- 1;
783 listarr
= kmalloc(sizeof(struct list_head
) * queue_cnt
, GFP_KERNEL
);
786 team
->qom_lists
= listarr
;
787 for (i
= 0; i
< queue_cnt
; i
++)
788 INIT_LIST_HEAD(listarr
++);
792 static void team_queue_override_fini(struct team
*team
)
794 kfree(team
->qom_lists
);
797 static struct list_head
*__team_get_qom_list(struct team
*team
, u16 queue_id
)
799 return &team
->qom_lists
[queue_id
- 1];
803 * note: already called with rcu_read_lock
805 static bool team_queue_override_transmit(struct team
*team
, struct sk_buff
*skb
)
807 struct list_head
*qom_list
;
808 struct team_port
*port
;
810 if (!team
->queue_override_enabled
|| !skb
->queue_mapping
)
812 qom_list
= __team_get_qom_list(team
, skb
->queue_mapping
);
813 list_for_each_entry_rcu(port
, qom_list
, qom_list
) {
814 if (!team_dev_queue_xmit(team
, port
, skb
))
820 static void __team_queue_override_port_del(struct team
*team
,
821 struct team_port
*port
)
825 list_del_rcu(&port
->qom_list
);
828 static bool team_queue_override_port_has_gt_prio_than(struct team_port
*port
,
829 struct team_port
*cur
)
831 if (port
->priority
< cur
->priority
)
833 if (port
->priority
> cur
->priority
)
835 if (port
->index
< cur
->index
)
840 static void __team_queue_override_port_add(struct team
*team
,
841 struct team_port
*port
)
843 struct team_port
*cur
;
844 struct list_head
*qom_list
;
845 struct list_head
*node
;
849 qom_list
= __team_get_qom_list(team
, port
->queue_id
);
851 list_for_each_entry(cur
, qom_list
, qom_list
) {
852 if (team_queue_override_port_has_gt_prio_than(port
, cur
))
854 node
= &cur
->qom_list
;
856 list_add_tail_rcu(&port
->qom_list
, node
);
859 static void __team_queue_override_enabled_check(struct team
*team
)
861 struct team_port
*port
;
862 bool enabled
= false;
864 list_for_each_entry(port
, &team
->port_list
, list
) {
865 if (port
->queue_id
) {
870 if (enabled
== team
->queue_override_enabled
)
872 netdev_dbg(team
->dev
, "%s queue override\n",
873 enabled
? "Enabling" : "Disabling");
874 team
->queue_override_enabled
= enabled
;
877 static void team_queue_override_port_prio_changed(struct team
*team
,
878 struct team_port
*port
)
880 if (!port
->queue_id
|| team_port_enabled(port
))
882 __team_queue_override_port_del(team
, port
);
883 __team_queue_override_port_add(team
, port
);
884 __team_queue_override_enabled_check(team
);
887 static void team_queue_override_port_change_queue_id(struct team
*team
,
888 struct team_port
*port
,
891 if (team_port_enabled(port
)) {
892 __team_queue_override_port_del(team
, port
);
893 port
->queue_id
= new_queue_id
;
894 __team_queue_override_port_add(team
, port
);
895 __team_queue_override_enabled_check(team
);
897 port
->queue_id
= new_queue_id
;
901 static void team_queue_override_port_add(struct team
*team
,
902 struct team_port
*port
)
904 __team_queue_override_port_add(team
, port
);
905 __team_queue_override_enabled_check(team
);
908 static void team_queue_override_port_del(struct team
*team
,
909 struct team_port
*port
)
911 __team_queue_override_port_del(team
, port
);
912 __team_queue_override_enabled_check(team
);
920 static bool team_port_find(const struct team
*team
,
921 const struct team_port
*port
)
923 struct team_port
*cur
;
925 list_for_each_entry(cur
, &team
->port_list
, list
)
932 * Enable/disable port by adding to enabled port hashlist and setting
933 * port->index (Might be racy so reader could see incorrect ifindex when
934 * processing a flying packet, but that is not a problem). Write guarded
937 static void team_port_enable(struct team
*team
,
938 struct team_port
*port
)
940 if (team_port_enabled(port
))
942 port
->index
= team
->en_port_count
++;
943 hlist_add_head_rcu(&port
->hlist
,
944 team_port_index_hash(team
, port
->index
));
945 team_adjust_ops(team
);
946 team_queue_override_port_add(team
, port
);
947 if (team
->ops
.port_enabled
)
948 team
->ops
.port_enabled(team
, port
);
949 team_notify_peers(team
);
950 team_mcast_rejoin(team
);
951 team_lower_state_changed(port
);
954 static void __reconstruct_port_hlist(struct team
*team
, int rm_index
)
957 struct team_port
*port
;
959 for (i
= rm_index
+ 1; i
< team
->en_port_count
; i
++) {
960 port
= team_get_port_by_index(team
, i
);
961 hlist_del_rcu(&port
->hlist
);
963 hlist_add_head_rcu(&port
->hlist
,
964 team_port_index_hash(team
, port
->index
));
968 static void team_port_disable(struct team
*team
,
969 struct team_port
*port
)
971 if (!team_port_enabled(port
))
973 if (team
->ops
.port_disabled
)
974 team
->ops
.port_disabled(team
, port
);
975 hlist_del_rcu(&port
->hlist
);
976 __reconstruct_port_hlist(team
, port
->index
);
978 team
->en_port_count
--;
979 team_queue_override_port_del(team
, port
);
980 team_adjust_ops(team
);
981 team_notify_peers(team
);
982 team_mcast_rejoin(team
);
983 team_lower_state_changed(port
);
986 #define TEAM_VLAN_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
987 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
988 NETIF_F_HIGHDMA | NETIF_F_LRO)
990 #define TEAM_ENC_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
991 NETIF_F_RXCSUM | NETIF_F_ALL_TSO)
993 static void __team_compute_features(struct team
*team
)
995 struct team_port
*port
;
996 u32 vlan_features
= TEAM_VLAN_FEATURES
& NETIF_F_ALL_FOR_ALL
;
997 netdev_features_t enc_features
= TEAM_ENC_FEATURES
;
998 unsigned short max_hard_header_len
= ETH_HLEN
;
999 unsigned int dst_release_flag
= IFF_XMIT_DST_RELEASE
|
1000 IFF_XMIT_DST_RELEASE_PERM
;
1002 list_for_each_entry(port
, &team
->port_list
, list
) {
1003 vlan_features
= netdev_increment_features(vlan_features
,
1004 port
->dev
->vlan_features
,
1005 TEAM_VLAN_FEATURES
);
1007 netdev_increment_features(enc_features
,
1008 port
->dev
->hw_enc_features
,
1012 dst_release_flag
&= port
->dev
->priv_flags
;
1013 if (port
->dev
->hard_header_len
> max_hard_header_len
)
1014 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 team
->dev
->hard_header_len
= max_hard_header_len
;
1021 team
->dev
->priv_flags
&= ~IFF_XMIT_DST_RELEASE
;
1022 if (dst_release_flag
== (IFF_XMIT_DST_RELEASE
| IFF_XMIT_DST_RELEASE_PERM
))
1023 team
->dev
->priv_flags
|= IFF_XMIT_DST_RELEASE
;
1025 netdev_change_features(team
->dev
);
1028 static void team_compute_features(struct team
*team
)
1030 mutex_lock(&team
->lock
);
1031 __team_compute_features(team
);
1032 mutex_unlock(&team
->lock
);
1035 static int team_port_enter(struct team
*team
, struct team_port
*port
)
1039 dev_hold(team
->dev
);
1040 if (team
->ops
.port_enter
) {
1041 err
= team
->ops
.port_enter(team
, port
);
1043 netdev_err(team
->dev
, "Device %s failed to enter team mode\n",
1045 goto err_port_enter
;
1057 static void team_port_leave(struct team
*team
, struct team_port
*port
)
1059 if (team
->ops
.port_leave
)
1060 team
->ops
.port_leave(team
, port
);
1064 #ifdef CONFIG_NET_POLL_CONTROLLER
1065 static int team_port_enable_netpoll(struct team
*team
, struct team_port
*port
)
1070 if (!team
->dev
->npinfo
)
1073 np
= kzalloc(sizeof(*np
), GFP_KERNEL
);
1077 err
= __netpoll_setup(np
, port
->dev
);
1086 static void team_port_disable_netpoll(struct team_port
*port
)
1088 struct netpoll
*np
= port
->np
;
1094 /* Wait for transmitting packets to finish before freeing. */
1095 synchronize_rcu_bh();
1096 __netpoll_cleanup(np
);
1100 static int team_port_enable_netpoll(struct team
*team
, struct team_port
*port
)
1104 static void team_port_disable_netpoll(struct team_port
*port
)
1109 static int team_upper_dev_link(struct team
*team
, struct team_port
*port
)
1111 struct netdev_lag_upper_info lag_upper_info
;
1114 lag_upper_info
.tx_type
= team
->mode
->lag_tx_type
;
1115 err
= netdev_master_upper_dev_link(port
->dev
, team
->dev
, NULL
,
1119 port
->dev
->priv_flags
|= IFF_TEAM_PORT
;
1123 static void team_upper_dev_unlink(struct team
*team
, struct team_port
*port
)
1125 netdev_upper_dev_unlink(port
->dev
, team
->dev
);
1126 port
->dev
->priv_flags
&= ~IFF_TEAM_PORT
;
1129 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
);
1130 static int team_dev_type_check_change(struct net_device
*dev
,
1131 struct net_device
*port_dev
);
1133 static int team_port_add(struct team
*team
, struct net_device
*port_dev
)
1135 struct net_device
*dev
= team
->dev
;
1136 struct team_port
*port
;
1137 char *portname
= port_dev
->name
;
1140 if (port_dev
->flags
& IFF_LOOPBACK
) {
1141 netdev_err(dev
, "Device %s is loopback device. Loopback devices can't be added as a team port\n",
1146 if (team_port_exists(port_dev
)) {
1147 netdev_err(dev
, "Device %s is already a port "
1148 "of a team device\n", portname
);
1152 if (port_dev
->features
& NETIF_F_VLAN_CHALLENGED
&&
1153 vlan_uses_dev(dev
)) {
1154 netdev_err(dev
, "Device %s is VLAN challenged and team device has VLAN set up\n",
1159 err
= team_dev_type_check_change(dev
, port_dev
);
1163 if (port_dev
->flags
& IFF_UP
) {
1164 netdev_err(dev
, "Device %s is up. Set it down before adding it as a team port\n",
1169 port
= kzalloc(sizeof(struct team_port
) + team
->mode
->port_priv_size
,
1174 port
->dev
= port_dev
;
1176 INIT_LIST_HEAD(&port
->qom_list
);
1178 port
->orig
.mtu
= port_dev
->mtu
;
1179 err
= dev_set_mtu(port_dev
, dev
->mtu
);
1181 netdev_dbg(dev
, "Error %d calling dev_set_mtu\n", err
);
1185 memcpy(port
->orig
.dev_addr
, port_dev
->dev_addr
, port_dev
->addr_len
);
1187 err
= team_port_enter(team
, port
);
1189 netdev_err(dev
, "Device %s failed to enter team mode\n",
1191 goto err_port_enter
;
1194 err
= dev_open(port_dev
);
1196 netdev_dbg(dev
, "Device %s opening failed\n",
1201 err
= vlan_vids_add_by_dev(port_dev
, dev
);
1203 netdev_err(dev
, "Failed to add vlan ids to device %s\n",
1208 err
= team_port_enable_netpoll(team
, port
);
1210 netdev_err(dev
, "Failed to enable netpoll on device %s\n",
1212 goto err_enable_netpoll
;
1215 if (!(dev
->features
& NETIF_F_LRO
))
1216 dev_disable_lro(port_dev
);
1218 err
= netdev_rx_handler_register(port_dev
, team_handle_frame
,
1221 netdev_err(dev
, "Device %s failed to register rx_handler\n",
1223 goto err_handler_register
;
1226 err
= team_upper_dev_link(team
, port
);
1228 netdev_err(dev
, "Device %s failed to set upper link\n",
1230 goto err_set_upper_link
;
1233 err
= __team_option_inst_add_port(team
, port
);
1235 netdev_err(dev
, "Device %s failed to add per-port options\n",
1237 goto err_option_port_add
;
1241 list_add_tail_rcu(&port
->list
, &team
->port_list
);
1242 team_port_enable(team
, port
);
1243 __team_compute_features(team
);
1244 __team_port_change_port_added(port
, !!netif_carrier_ok(port_dev
));
1245 __team_options_change_check(team
);
1247 netdev_info(dev
, "Port device %s added\n", portname
);
1251 err_option_port_add
:
1252 team_upper_dev_unlink(team
, port
);
1255 netdev_rx_handler_unregister(port_dev
);
1257 err_handler_register
:
1258 team_port_disable_netpoll(port
);
1261 vlan_vids_del_by_dev(port_dev
, dev
);
1264 dev_close(port_dev
);
1267 team_port_leave(team
, port
);
1268 team_port_set_orig_dev_addr(port
);
1271 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1279 static void __team_port_change_port_removed(struct team_port
*port
);
1281 static int team_port_del(struct team
*team
, struct net_device
*port_dev
)
1283 struct net_device
*dev
= team
->dev
;
1284 struct team_port
*port
;
1285 char *portname
= port_dev
->name
;
1287 port
= team_port_get_rtnl(port_dev
);
1288 if (!port
|| !team_port_find(team
, port
)) {
1289 netdev_err(dev
, "Device %s does not act as a port of this team\n",
1294 team_port_disable(team
, port
);
1295 list_del_rcu(&port
->list
);
1296 team_upper_dev_unlink(team
, port
);
1297 netdev_rx_handler_unregister(port_dev
);
1298 team_port_disable_netpoll(port
);
1299 vlan_vids_del_by_dev(port_dev
, dev
);
1300 dev_uc_unsync(port_dev
, dev
);
1301 dev_mc_unsync(port_dev
, dev
);
1302 dev_close(port_dev
);
1303 team_port_leave(team
, port
);
1305 __team_option_inst_mark_removed_port(team
, port
);
1306 __team_options_change_check(team
);
1307 __team_option_inst_del_port(team
, port
);
1308 __team_port_change_port_removed(port
);
1310 team_port_set_orig_dev_addr(port
);
1311 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1312 kfree_rcu(port
, rcu
);
1313 netdev_info(dev
, "Port device %s removed\n", portname
);
1314 __team_compute_features(team
);
1324 static int team_mode_option_get(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1326 ctx
->data
.str_val
= team
->mode
->kind
;
1330 static int team_mode_option_set(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1332 return team_change_mode(team
, ctx
->data
.str_val
);
1335 static int team_notify_peers_count_get(struct team
*team
,
1336 struct team_gsetter_ctx
*ctx
)
1338 ctx
->data
.u32_val
= team
->notify_peers
.count
;
1342 static int team_notify_peers_count_set(struct team
*team
,
1343 struct team_gsetter_ctx
*ctx
)
1345 team
->notify_peers
.count
= ctx
->data
.u32_val
;
1349 static int team_notify_peers_interval_get(struct team
*team
,
1350 struct team_gsetter_ctx
*ctx
)
1352 ctx
->data
.u32_val
= team
->notify_peers
.interval
;
1356 static int team_notify_peers_interval_set(struct team
*team
,
1357 struct team_gsetter_ctx
*ctx
)
1359 team
->notify_peers
.interval
= ctx
->data
.u32_val
;
1363 static int team_mcast_rejoin_count_get(struct team
*team
,
1364 struct team_gsetter_ctx
*ctx
)
1366 ctx
->data
.u32_val
= team
->mcast_rejoin
.count
;
1370 static int team_mcast_rejoin_count_set(struct team
*team
,
1371 struct team_gsetter_ctx
*ctx
)
1373 team
->mcast_rejoin
.count
= ctx
->data
.u32_val
;
1377 static int team_mcast_rejoin_interval_get(struct team
*team
,
1378 struct team_gsetter_ctx
*ctx
)
1380 ctx
->data
.u32_val
= team
->mcast_rejoin
.interval
;
1384 static int team_mcast_rejoin_interval_set(struct team
*team
,
1385 struct team_gsetter_ctx
*ctx
)
1387 team
->mcast_rejoin
.interval
= ctx
->data
.u32_val
;
1391 static int team_port_en_option_get(struct team
*team
,
1392 struct team_gsetter_ctx
*ctx
)
1394 struct team_port
*port
= ctx
->info
->port
;
1396 ctx
->data
.bool_val
= team_port_enabled(port
);
1400 static int team_port_en_option_set(struct team
*team
,
1401 struct team_gsetter_ctx
*ctx
)
1403 struct team_port
*port
= ctx
->info
->port
;
1405 if (ctx
->data
.bool_val
)
1406 team_port_enable(team
, port
);
1408 team_port_disable(team
, port
);
1412 static int team_user_linkup_option_get(struct team
*team
,
1413 struct team_gsetter_ctx
*ctx
)
1415 struct team_port
*port
= ctx
->info
->port
;
1417 ctx
->data
.bool_val
= port
->user
.linkup
;
1421 static void __team_carrier_check(struct team
*team
);
1423 static int team_user_linkup_option_set(struct team
*team
,
1424 struct team_gsetter_ctx
*ctx
)
1426 struct team_port
*port
= ctx
->info
->port
;
1428 port
->user
.linkup
= ctx
->data
.bool_val
;
1429 team_refresh_port_linkup(port
);
1430 __team_carrier_check(port
->team
);
1434 static int team_user_linkup_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
= port
->user
.linkup_enabled
;
1443 static int team_user_linkup_en_option_set(struct team
*team
,
1444 struct team_gsetter_ctx
*ctx
)
1446 struct team_port
*port
= ctx
->info
->port
;
1448 port
->user
.linkup_enabled
= ctx
->data
.bool_val
;
1449 team_refresh_port_linkup(port
);
1450 __team_carrier_check(port
->team
);
1454 static int team_priority_option_get(struct team
*team
,
1455 struct team_gsetter_ctx
*ctx
)
1457 struct team_port
*port
= ctx
->info
->port
;
1459 ctx
->data
.s32_val
= port
->priority
;
1463 static int team_priority_option_set(struct team
*team
,
1464 struct team_gsetter_ctx
*ctx
)
1466 struct team_port
*port
= ctx
->info
->port
;
1467 s32 priority
= ctx
->data
.s32_val
;
1469 if (port
->priority
== priority
)
1471 port
->priority
= priority
;
1472 team_queue_override_port_prio_changed(team
, port
);
1476 static int team_queue_id_option_get(struct team
*team
,
1477 struct team_gsetter_ctx
*ctx
)
1479 struct team_port
*port
= ctx
->info
->port
;
1481 ctx
->data
.u32_val
= port
->queue_id
;
1485 static int team_queue_id_option_set(struct team
*team
,
1486 struct team_gsetter_ctx
*ctx
)
1488 struct team_port
*port
= ctx
->info
->port
;
1489 u16 new_queue_id
= ctx
->data
.u32_val
;
1491 if (port
->queue_id
== new_queue_id
)
1493 if (new_queue_id
>= team
->dev
->real_num_tx_queues
)
1495 team_queue_override_port_change_queue_id(team
, port
, new_queue_id
);
1499 static const struct team_option team_options
[] = {
1502 .type
= TEAM_OPTION_TYPE_STRING
,
1503 .getter
= team_mode_option_get
,
1504 .setter
= team_mode_option_set
,
1507 .name
= "notify_peers_count",
1508 .type
= TEAM_OPTION_TYPE_U32
,
1509 .getter
= team_notify_peers_count_get
,
1510 .setter
= team_notify_peers_count_set
,
1513 .name
= "notify_peers_interval",
1514 .type
= TEAM_OPTION_TYPE_U32
,
1515 .getter
= team_notify_peers_interval_get
,
1516 .setter
= team_notify_peers_interval_set
,
1519 .name
= "mcast_rejoin_count",
1520 .type
= TEAM_OPTION_TYPE_U32
,
1521 .getter
= team_mcast_rejoin_count_get
,
1522 .setter
= team_mcast_rejoin_count_set
,
1525 .name
= "mcast_rejoin_interval",
1526 .type
= TEAM_OPTION_TYPE_U32
,
1527 .getter
= team_mcast_rejoin_interval_get
,
1528 .setter
= team_mcast_rejoin_interval_set
,
1532 .type
= TEAM_OPTION_TYPE_BOOL
,
1534 .getter
= team_port_en_option_get
,
1535 .setter
= team_port_en_option_set
,
1538 .name
= "user_linkup",
1539 .type
= TEAM_OPTION_TYPE_BOOL
,
1541 .getter
= team_user_linkup_option_get
,
1542 .setter
= team_user_linkup_option_set
,
1545 .name
= "user_linkup_enabled",
1546 .type
= TEAM_OPTION_TYPE_BOOL
,
1548 .getter
= team_user_linkup_en_option_get
,
1549 .setter
= team_user_linkup_en_option_set
,
1553 .type
= TEAM_OPTION_TYPE_S32
,
1555 .getter
= team_priority_option_get
,
1556 .setter
= team_priority_option_set
,
1560 .type
= TEAM_OPTION_TYPE_U32
,
1562 .getter
= team_queue_id_option_get
,
1563 .setter
= team_queue_id_option_set
,
1567 static struct lock_class_key team_netdev_xmit_lock_key
;
1568 static struct lock_class_key team_netdev_addr_lock_key
;
1569 static struct lock_class_key team_tx_busylock_key
;
1571 static void team_set_lockdep_class_one(struct net_device
*dev
,
1572 struct netdev_queue
*txq
,
1575 lockdep_set_class(&txq
->_xmit_lock
, &team_netdev_xmit_lock_key
);
1578 static void team_set_lockdep_class(struct net_device
*dev
)
1580 lockdep_set_class(&dev
->addr_list_lock
, &team_netdev_addr_lock_key
);
1581 netdev_for_each_tx_queue(dev
, team_set_lockdep_class_one
, NULL
);
1582 dev
->qdisc_tx_busylock
= &team_tx_busylock_key
;
1585 static int team_init(struct net_device
*dev
)
1587 struct team
*team
= netdev_priv(dev
);
1592 mutex_init(&team
->lock
);
1593 team_set_no_mode(team
);
1595 team
->pcpu_stats
= netdev_alloc_pcpu_stats(struct team_pcpu_stats
);
1596 if (!team
->pcpu_stats
)
1599 for (i
= 0; i
< TEAM_PORT_HASHENTRIES
; i
++)
1600 INIT_HLIST_HEAD(&team
->en_port_hlist
[i
]);
1601 INIT_LIST_HEAD(&team
->port_list
);
1602 err
= team_queue_override_init(team
);
1604 goto err_team_queue_override_init
;
1606 team_adjust_ops(team
);
1608 INIT_LIST_HEAD(&team
->option_list
);
1609 INIT_LIST_HEAD(&team
->option_inst_list
);
1611 team_notify_peers_init(team
);
1612 team_mcast_rejoin_init(team
);
1614 err
= team_options_register(team
, team_options
, ARRAY_SIZE(team_options
));
1616 goto err_options_register
;
1617 netif_carrier_off(dev
);
1619 team_set_lockdep_class(dev
);
1623 err_options_register
:
1624 team_mcast_rejoin_fini(team
);
1625 team_notify_peers_fini(team
);
1626 team_queue_override_fini(team
);
1627 err_team_queue_override_init
:
1628 free_percpu(team
->pcpu_stats
);
1633 static void team_uninit(struct net_device
*dev
)
1635 struct team
*team
= netdev_priv(dev
);
1636 struct team_port
*port
;
1637 struct team_port
*tmp
;
1639 mutex_lock(&team
->lock
);
1640 list_for_each_entry_safe(port
, tmp
, &team
->port_list
, list
)
1641 team_port_del(team
, port
->dev
);
1643 __team_change_mode(team
, NULL
); /* cleanup */
1644 __team_options_unregister(team
, team_options
, ARRAY_SIZE(team_options
));
1645 team_mcast_rejoin_fini(team
);
1646 team_notify_peers_fini(team
);
1647 team_queue_override_fini(team
);
1648 mutex_unlock(&team
->lock
);
1651 static void team_destructor(struct net_device
*dev
)
1653 struct team
*team
= netdev_priv(dev
);
1655 free_percpu(team
->pcpu_stats
);
1659 static int team_open(struct net_device
*dev
)
1664 static int team_close(struct net_device
*dev
)
1670 * note: already called with rcu_read_lock
1672 static netdev_tx_t
team_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1674 struct team
*team
= netdev_priv(dev
);
1676 unsigned int len
= skb
->len
;
1678 tx_success
= team_queue_override_transmit(team
, skb
);
1680 tx_success
= team
->ops
.transmit(team
, skb
);
1682 struct team_pcpu_stats
*pcpu_stats
;
1684 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
1685 u64_stats_update_begin(&pcpu_stats
->syncp
);
1686 pcpu_stats
->tx_packets
++;
1687 pcpu_stats
->tx_bytes
+= len
;
1688 u64_stats_update_end(&pcpu_stats
->syncp
);
1690 this_cpu_inc(team
->pcpu_stats
->tx_dropped
);
1693 return NETDEV_TX_OK
;
1696 static u16
team_select_queue(struct net_device
*dev
, struct sk_buff
*skb
,
1697 void *accel_priv
, select_queue_fallback_t fallback
)
1700 * This helper function exists to help dev_pick_tx get the correct
1701 * destination queue. Using a helper function skips a call to
1702 * skb_tx_hash and will put the skbs in the queue we expect on their
1703 * way down to the team driver.
1705 u16 txq
= skb_rx_queue_recorded(skb
) ? skb_get_rx_queue(skb
) : 0;
1708 * Save the original txq to restore before passing to the driver
1710 qdisc_skb_cb(skb
)->slave_dev_queue_mapping
= skb
->queue_mapping
;
1712 if (unlikely(txq
>= dev
->real_num_tx_queues
)) {
1714 txq
-= dev
->real_num_tx_queues
;
1715 } while (txq
>= dev
->real_num_tx_queues
);
1720 static void team_change_rx_flags(struct net_device
*dev
, int change
)
1722 struct team
*team
= netdev_priv(dev
);
1723 struct team_port
*port
;
1727 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1728 if (change
& IFF_PROMISC
) {
1729 inc
= dev
->flags
& IFF_PROMISC
? 1 : -1;
1730 dev_set_promiscuity(port
->dev
, inc
);
1732 if (change
& IFF_ALLMULTI
) {
1733 inc
= dev
->flags
& IFF_ALLMULTI
? 1 : -1;
1734 dev_set_allmulti(port
->dev
, inc
);
1740 static void team_set_rx_mode(struct net_device
*dev
)
1742 struct team
*team
= netdev_priv(dev
);
1743 struct team_port
*port
;
1746 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1747 dev_uc_sync_multiple(port
->dev
, dev
);
1748 dev_mc_sync_multiple(port
->dev
, dev
);
1753 static int team_set_mac_address(struct net_device
*dev
, void *p
)
1755 struct sockaddr
*addr
= p
;
1756 struct team
*team
= netdev_priv(dev
);
1757 struct team_port
*port
;
1759 if (dev
->type
== ARPHRD_ETHER
&& !is_valid_ether_addr(addr
->sa_data
))
1760 return -EADDRNOTAVAIL
;
1761 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1762 mutex_lock(&team
->lock
);
1763 list_for_each_entry(port
, &team
->port_list
, list
)
1764 if (team
->ops
.port_change_dev_addr
)
1765 team
->ops
.port_change_dev_addr(team
, port
);
1766 mutex_unlock(&team
->lock
);
1770 static int team_change_mtu(struct net_device
*dev
, int new_mtu
)
1772 struct team
*team
= netdev_priv(dev
);
1773 struct team_port
*port
;
1777 * Alhough this is reader, it's guarded by team lock. It's not possible
1778 * to traverse list in reverse under rcu_read_lock
1780 mutex_lock(&team
->lock
);
1781 team
->port_mtu_change_allowed
= true;
1782 list_for_each_entry(port
, &team
->port_list
, list
) {
1783 err
= dev_set_mtu(port
->dev
, new_mtu
);
1785 netdev_err(dev
, "Device %s failed to change mtu",
1790 team
->port_mtu_change_allowed
= false;
1791 mutex_unlock(&team
->lock
);
1798 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1799 dev_set_mtu(port
->dev
, dev
->mtu
);
1800 team
->port_mtu_change_allowed
= false;
1801 mutex_unlock(&team
->lock
);
1806 static struct rtnl_link_stats64
*
1807 team_get_stats64(struct net_device
*dev
, struct rtnl_link_stats64
*stats
)
1809 struct team
*team
= netdev_priv(dev
);
1810 struct team_pcpu_stats
*p
;
1811 u64 rx_packets
, rx_bytes
, rx_multicast
, tx_packets
, tx_bytes
;
1812 u32 rx_dropped
= 0, tx_dropped
= 0, rx_nohandler
= 0;
1816 for_each_possible_cpu(i
) {
1817 p
= per_cpu_ptr(team
->pcpu_stats
, i
);
1819 start
= u64_stats_fetch_begin_irq(&p
->syncp
);
1820 rx_packets
= p
->rx_packets
;
1821 rx_bytes
= p
->rx_bytes
;
1822 rx_multicast
= p
->rx_multicast
;
1823 tx_packets
= p
->tx_packets
;
1824 tx_bytes
= p
->tx_bytes
;
1825 } while (u64_stats_fetch_retry_irq(&p
->syncp
, start
));
1827 stats
->rx_packets
+= rx_packets
;
1828 stats
->rx_bytes
+= rx_bytes
;
1829 stats
->multicast
+= rx_multicast
;
1830 stats
->tx_packets
+= tx_packets
;
1831 stats
->tx_bytes
+= tx_bytes
;
1833 * rx_dropped, tx_dropped & rx_nohandler are u32,
1834 * updated without syncp protection.
1836 rx_dropped
+= p
->rx_dropped
;
1837 tx_dropped
+= p
->tx_dropped
;
1838 rx_nohandler
+= p
->rx_nohandler
;
1840 stats
->rx_dropped
= rx_dropped
;
1841 stats
->tx_dropped
= tx_dropped
;
1842 stats
->rx_nohandler
= rx_nohandler
;
1846 static int team_vlan_rx_add_vid(struct net_device
*dev
, __be16 proto
, u16 vid
)
1848 struct team
*team
= netdev_priv(dev
);
1849 struct team_port
*port
;
1853 * Alhough this is reader, it's guarded by team lock. It's not possible
1854 * to traverse list in reverse under rcu_read_lock
1856 mutex_lock(&team
->lock
);
1857 list_for_each_entry(port
, &team
->port_list
, list
) {
1858 err
= vlan_vid_add(port
->dev
, proto
, vid
);
1862 mutex_unlock(&team
->lock
);
1867 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1868 vlan_vid_del(port
->dev
, proto
, vid
);
1869 mutex_unlock(&team
->lock
);
1874 static int team_vlan_rx_kill_vid(struct net_device
*dev
, __be16 proto
, u16 vid
)
1876 struct team
*team
= netdev_priv(dev
);
1877 struct team_port
*port
;
1879 mutex_lock(&team
->lock
);
1880 list_for_each_entry(port
, &team
->port_list
, list
)
1881 vlan_vid_del(port
->dev
, proto
, vid
);
1882 mutex_unlock(&team
->lock
);
1887 #ifdef CONFIG_NET_POLL_CONTROLLER
1888 static void team_poll_controller(struct net_device
*dev
)
1892 static void __team_netpoll_cleanup(struct team
*team
)
1894 struct team_port
*port
;
1896 list_for_each_entry(port
, &team
->port_list
, list
)
1897 team_port_disable_netpoll(port
);
1900 static void team_netpoll_cleanup(struct net_device
*dev
)
1902 struct team
*team
= netdev_priv(dev
);
1904 mutex_lock(&team
->lock
);
1905 __team_netpoll_cleanup(team
);
1906 mutex_unlock(&team
->lock
);
1909 static int team_netpoll_setup(struct net_device
*dev
,
1910 struct netpoll_info
*npifo
)
1912 struct team
*team
= netdev_priv(dev
);
1913 struct team_port
*port
;
1916 mutex_lock(&team
->lock
);
1917 list_for_each_entry(port
, &team
->port_list
, list
) {
1918 err
= team_port_enable_netpoll(team
, port
);
1920 __team_netpoll_cleanup(team
);
1924 mutex_unlock(&team
->lock
);
1929 static int team_add_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1931 struct team
*team
= netdev_priv(dev
);
1934 mutex_lock(&team
->lock
);
1935 err
= team_port_add(team
, port_dev
);
1936 mutex_unlock(&team
->lock
);
1940 static int team_del_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1942 struct team
*team
= netdev_priv(dev
);
1945 mutex_lock(&team
->lock
);
1946 err
= team_port_del(team
, port_dev
);
1947 mutex_unlock(&team
->lock
);
1951 static netdev_features_t
team_fix_features(struct net_device
*dev
,
1952 netdev_features_t features
)
1954 struct team_port
*port
;
1955 struct team
*team
= netdev_priv(dev
);
1956 netdev_features_t mask
;
1959 features
&= ~NETIF_F_ONE_FOR_ALL
;
1960 features
|= NETIF_F_ALL_FOR_ALL
;
1963 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1964 features
= netdev_increment_features(features
,
1965 port
->dev
->features
,
1970 features
= netdev_add_tso_features(features
, mask
);
1975 static int team_change_carrier(struct net_device
*dev
, bool new_carrier
)
1977 struct team
*team
= netdev_priv(dev
);
1979 team
->user_carrier_enabled
= true;
1982 netif_carrier_on(dev
);
1984 netif_carrier_off(dev
);
1988 static const struct net_device_ops team_netdev_ops
= {
1989 .ndo_init
= team_init
,
1990 .ndo_uninit
= team_uninit
,
1991 .ndo_open
= team_open
,
1992 .ndo_stop
= team_close
,
1993 .ndo_start_xmit
= team_xmit
,
1994 .ndo_select_queue
= team_select_queue
,
1995 .ndo_change_rx_flags
= team_change_rx_flags
,
1996 .ndo_set_rx_mode
= team_set_rx_mode
,
1997 .ndo_set_mac_address
= team_set_mac_address
,
1998 .ndo_change_mtu
= team_change_mtu
,
1999 .ndo_get_stats64
= team_get_stats64
,
2000 .ndo_vlan_rx_add_vid
= team_vlan_rx_add_vid
,
2001 .ndo_vlan_rx_kill_vid
= team_vlan_rx_kill_vid
,
2002 #ifdef CONFIG_NET_POLL_CONTROLLER
2003 .ndo_poll_controller
= team_poll_controller
,
2004 .ndo_netpoll_setup
= team_netpoll_setup
,
2005 .ndo_netpoll_cleanup
= team_netpoll_cleanup
,
2007 .ndo_add_slave
= team_add_slave
,
2008 .ndo_del_slave
= team_del_slave
,
2009 .ndo_fix_features
= team_fix_features
,
2010 .ndo_change_carrier
= team_change_carrier
,
2011 .ndo_bridge_setlink
= switchdev_port_bridge_setlink
,
2012 .ndo_bridge_getlink
= switchdev_port_bridge_getlink
,
2013 .ndo_bridge_dellink
= switchdev_port_bridge_dellink
,
2014 .ndo_fdb_add
= switchdev_port_fdb_add
,
2015 .ndo_fdb_del
= switchdev_port_fdb_del
,
2016 .ndo_fdb_dump
= switchdev_port_fdb_dump
,
2017 .ndo_features_check
= passthru_features_check
,
2020 /***********************
2022 ***********************/
2024 static void team_ethtool_get_drvinfo(struct net_device
*dev
,
2025 struct ethtool_drvinfo
*drvinfo
)
2027 strlcpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
2028 strlcpy(drvinfo
->version
, UTS_RELEASE
, sizeof(drvinfo
->version
));
2031 static const struct ethtool_ops team_ethtool_ops
= {
2032 .get_drvinfo
= team_ethtool_get_drvinfo
,
2033 .get_link
= ethtool_op_get_link
,
2036 /***********************
2037 * rt netlink interface
2038 ***********************/
2040 static void team_setup_by_port(struct net_device
*dev
,
2041 struct net_device
*port_dev
)
2043 dev
->header_ops
= port_dev
->header_ops
;
2044 dev
->type
= port_dev
->type
;
2045 dev
->hard_header_len
= port_dev
->hard_header_len
;
2046 dev
->addr_len
= port_dev
->addr_len
;
2047 dev
->mtu
= port_dev
->mtu
;
2048 memcpy(dev
->broadcast
, port_dev
->broadcast
, port_dev
->addr_len
);
2049 eth_hw_addr_inherit(dev
, port_dev
);
2052 static int team_dev_type_check_change(struct net_device
*dev
,
2053 struct net_device
*port_dev
)
2055 struct team
*team
= netdev_priv(dev
);
2056 char *portname
= port_dev
->name
;
2059 if (dev
->type
== port_dev
->type
)
2061 if (!list_empty(&team
->port_list
)) {
2062 netdev_err(dev
, "Device %s is of different type\n", portname
);
2065 err
= call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE
, dev
);
2066 err
= notifier_to_errno(err
);
2068 netdev_err(dev
, "Refused to change device type\n");
2073 team_setup_by_port(dev
, port_dev
);
2074 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE
, dev
);
2078 static void team_setup(struct net_device
*dev
)
2082 dev
->netdev_ops
= &team_netdev_ops
;
2083 dev
->ethtool_ops
= &team_ethtool_ops
;
2084 dev
->destructor
= team_destructor
;
2085 dev
->priv_flags
&= ~(IFF_XMIT_DST_RELEASE
| IFF_TX_SKB_SHARING
);
2086 dev
->priv_flags
|= IFF_NO_QUEUE
;
2087 dev
->priv_flags
|= IFF_TEAM
;
2090 * Indicate we support unicast address filtering. That way core won't
2091 * bring us to promisc mode in case a unicast addr is added.
2092 * Let this up to underlay drivers.
2094 dev
->priv_flags
|= IFF_UNICAST_FLT
| IFF_LIVE_ADDR_CHANGE
;
2096 dev
->features
|= NETIF_F_LLTX
;
2097 dev
->features
|= NETIF_F_GRO
;
2099 /* Don't allow team devices to change network namespaces. */
2100 dev
->features
|= NETIF_F_NETNS_LOCAL
;
2102 dev
->hw_features
= TEAM_VLAN_FEATURES
|
2103 NETIF_F_HW_VLAN_CTAG_TX
|
2104 NETIF_F_HW_VLAN_CTAG_RX
|
2105 NETIF_F_HW_VLAN_CTAG_FILTER
;
2107 dev
->hw_features
|= NETIF_F_GSO_ENCAP_ALL
;
2108 dev
->features
|= dev
->hw_features
;
2111 static int team_newlink(struct net
*src_net
, struct net_device
*dev
,
2112 struct nlattr
*tb
[], struct nlattr
*data
[])
2114 if (tb
[IFLA_ADDRESS
] == NULL
)
2115 eth_hw_addr_random(dev
);
2117 return register_netdevice(dev
);
2120 static int team_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
2122 if (tb
[IFLA_ADDRESS
]) {
2123 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
2125 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
2126 return -EADDRNOTAVAIL
;
2131 static unsigned int team_get_num_tx_queues(void)
2133 return TEAM_DEFAULT_NUM_TX_QUEUES
;
2136 static unsigned int team_get_num_rx_queues(void)
2138 return TEAM_DEFAULT_NUM_RX_QUEUES
;
2141 static struct rtnl_link_ops team_link_ops __read_mostly
= {
2143 .priv_size
= sizeof(struct team
),
2144 .setup
= team_setup
,
2145 .newlink
= team_newlink
,
2146 .validate
= team_validate
,
2147 .get_num_tx_queues
= team_get_num_tx_queues
,
2148 .get_num_rx_queues
= team_get_num_rx_queues
,
2152 /***********************************
2153 * Generic netlink custom interface
2154 ***********************************/
2156 static struct genl_family team_nl_family
= {
2157 .id
= GENL_ID_GENERATE
,
2158 .name
= TEAM_GENL_NAME
,
2159 .version
= TEAM_GENL_VERSION
,
2160 .maxattr
= TEAM_ATTR_MAX
,
2164 static const struct nla_policy team_nl_policy
[TEAM_ATTR_MAX
+ 1] = {
2165 [TEAM_ATTR_UNSPEC
] = { .type
= NLA_UNSPEC
, },
2166 [TEAM_ATTR_TEAM_IFINDEX
] = { .type
= NLA_U32
},
2167 [TEAM_ATTR_LIST_OPTION
] = { .type
= NLA_NESTED
},
2168 [TEAM_ATTR_LIST_PORT
] = { .type
= NLA_NESTED
},
2171 static const struct nla_policy
2172 team_nl_option_policy
[TEAM_ATTR_OPTION_MAX
+ 1] = {
2173 [TEAM_ATTR_OPTION_UNSPEC
] = { .type
= NLA_UNSPEC
, },
2174 [TEAM_ATTR_OPTION_NAME
] = {
2176 .len
= TEAM_STRING_MAX_LEN
,
2178 [TEAM_ATTR_OPTION_CHANGED
] = { .type
= NLA_FLAG
},
2179 [TEAM_ATTR_OPTION_TYPE
] = { .type
= NLA_U8
},
2180 [TEAM_ATTR_OPTION_DATA
] = { .type
= NLA_BINARY
},
2183 static int team_nl_cmd_noop(struct sk_buff
*skb
, struct genl_info
*info
)
2185 struct sk_buff
*msg
;
2189 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2193 hdr
= genlmsg_put(msg
, info
->snd_portid
, info
->snd_seq
,
2194 &team_nl_family
, 0, TEAM_CMD_NOOP
);
2200 genlmsg_end(msg
, hdr
);
2202 return genlmsg_unicast(genl_info_net(info
), msg
, info
->snd_portid
);
2211 * Netlink cmd functions should be locked by following two functions.
2212 * Since dev gets held here, that ensures dev won't disappear in between.
2214 static struct team
*team_nl_team_get(struct genl_info
*info
)
2216 struct net
*net
= genl_info_net(info
);
2218 struct net_device
*dev
;
2221 if (!info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
])
2224 ifindex
= nla_get_u32(info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
]);
2225 dev
= dev_get_by_index(net
, ifindex
);
2226 if (!dev
|| dev
->netdev_ops
!= &team_netdev_ops
) {
2232 team
= netdev_priv(dev
);
2233 mutex_lock(&team
->lock
);
2237 static void team_nl_team_put(struct team
*team
)
2239 mutex_unlock(&team
->lock
);
2243 typedef int team_nl_send_func_t(struct sk_buff
*skb
,
2244 struct team
*team
, u32 portid
);
2246 static int team_nl_send_unicast(struct sk_buff
*skb
, struct team
*team
, u32 portid
)
2248 return genlmsg_unicast(dev_net(team
->dev
), skb
, portid
);
2251 static int team_nl_fill_one_option_get(struct sk_buff
*skb
, struct team
*team
,
2252 struct team_option_inst
*opt_inst
)
2254 struct nlattr
*option_item
;
2255 struct team_option
*option
= opt_inst
->option
;
2256 struct team_option_inst_info
*opt_inst_info
= &opt_inst
->info
;
2257 struct team_gsetter_ctx ctx
;
2260 ctx
.info
= opt_inst_info
;
2261 err
= team_option_get(team
, opt_inst
, &ctx
);
2265 option_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_OPTION
);
2269 if (nla_put_string(skb
, TEAM_ATTR_OPTION_NAME
, option
->name
))
2271 if (opt_inst_info
->port
&&
2272 nla_put_u32(skb
, TEAM_ATTR_OPTION_PORT_IFINDEX
,
2273 opt_inst_info
->port
->dev
->ifindex
))
2275 if (opt_inst
->option
->array_size
&&
2276 nla_put_u32(skb
, TEAM_ATTR_OPTION_ARRAY_INDEX
,
2277 opt_inst_info
->array_index
))
2280 switch (option
->type
) {
2281 case TEAM_OPTION_TYPE_U32
:
2282 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_U32
))
2284 if (nla_put_u32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.u32_val
))
2287 case TEAM_OPTION_TYPE_STRING
:
2288 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_STRING
))
2290 if (nla_put_string(skb
, TEAM_ATTR_OPTION_DATA
,
2294 case TEAM_OPTION_TYPE_BINARY
:
2295 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_BINARY
))
2297 if (nla_put(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.bin_val
.len
,
2298 ctx
.data
.bin_val
.ptr
))
2301 case TEAM_OPTION_TYPE_BOOL
:
2302 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_FLAG
))
2304 if (ctx
.data
.bool_val
&&
2305 nla_put_flag(skb
, TEAM_ATTR_OPTION_DATA
))
2308 case TEAM_OPTION_TYPE_S32
:
2309 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_S32
))
2311 if (nla_put_s32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.s32_val
))
2317 if (opt_inst
->removed
&& nla_put_flag(skb
, TEAM_ATTR_OPTION_REMOVED
))
2319 if (opt_inst
->changed
) {
2320 if (nla_put_flag(skb
, TEAM_ATTR_OPTION_CHANGED
))
2322 opt_inst
->changed
= false;
2324 nla_nest_end(skb
, option_item
);
2328 nla_nest_cancel(skb
, option_item
);
2332 static int __send_and_alloc_skb(struct sk_buff
**pskb
,
2333 struct team
*team
, u32 portid
,
2334 team_nl_send_func_t
*send_func
)
2339 err
= send_func(*pskb
, team
, portid
);
2343 *pskb
= genlmsg_new(GENLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2349 static int team_nl_send_options_get(struct team
*team
, u32 portid
, u32 seq
,
2350 int flags
, team_nl_send_func_t
*send_func
,
2351 struct list_head
*sel_opt_inst_list
)
2353 struct nlattr
*option_list
;
2354 struct nlmsghdr
*nlh
;
2356 struct team_option_inst
*opt_inst
;
2358 struct sk_buff
*skb
= NULL
;
2362 opt_inst
= list_first_entry(sel_opt_inst_list
,
2363 struct team_option_inst
, tmp_list
);
2366 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2370 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2371 TEAM_CMD_OPTIONS_GET
);
2375 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2376 goto nla_put_failure
;
2377 option_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_OPTION
);
2379 goto nla_put_failure
;
2383 list_for_each_entry_from(opt_inst
, sel_opt_inst_list
, tmp_list
) {
2384 err
= team_nl_fill_one_option_get(skb
, team
, opt_inst
);
2386 if (err
== -EMSGSIZE
) {
2397 nla_nest_end(skb
, option_list
);
2398 genlmsg_end(skb
, hdr
);
2403 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2405 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2411 return send_func(skb
, team
, portid
);
2416 genlmsg_cancel(skb
, hdr
);
2421 static int team_nl_cmd_options_get(struct sk_buff
*skb
, struct genl_info
*info
)
2424 struct team_option_inst
*opt_inst
;
2426 LIST_HEAD(sel_opt_inst_list
);
2428 team
= team_nl_team_get(info
);
2432 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
)
2433 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2434 err
= team_nl_send_options_get(team
, info
->snd_portid
, info
->snd_seq
,
2435 NLM_F_ACK
, team_nl_send_unicast
,
2436 &sel_opt_inst_list
);
2438 team_nl_team_put(team
);
2443 static int team_nl_send_event_options_get(struct team
*team
,
2444 struct list_head
*sel_opt_inst_list
);
2446 static int team_nl_cmd_options_set(struct sk_buff
*skb
, struct genl_info
*info
)
2451 struct nlattr
*nl_option
;
2452 LIST_HEAD(opt_inst_list
);
2456 team
= team_nl_team_get(info
);
2463 if (!info
->attrs
[TEAM_ATTR_LIST_OPTION
]) {
2468 nla_for_each_nested(nl_option
, info
->attrs
[TEAM_ATTR_LIST_OPTION
], i
) {
2469 struct nlattr
*opt_attrs
[TEAM_ATTR_OPTION_MAX
+ 1];
2470 struct nlattr
*attr
;
2471 struct nlattr
*attr_data
;
2472 enum team_option_type opt_type
;
2473 int opt_port_ifindex
= 0; /* != 0 for per-port options */
2474 u32 opt_array_index
= 0;
2475 bool opt_is_array
= false;
2476 struct team_option_inst
*opt_inst
;
2478 bool opt_found
= false;
2480 if (nla_type(nl_option
) != TEAM_ATTR_ITEM_OPTION
) {
2484 err
= nla_parse_nested(opt_attrs
, TEAM_ATTR_OPTION_MAX
,
2485 nl_option
, team_nl_option_policy
);
2488 if (!opt_attrs
[TEAM_ATTR_OPTION_NAME
] ||
2489 !opt_attrs
[TEAM_ATTR_OPTION_TYPE
]) {
2493 switch (nla_get_u8(opt_attrs
[TEAM_ATTR_OPTION_TYPE
])) {
2495 opt_type
= TEAM_OPTION_TYPE_U32
;
2498 opt_type
= TEAM_OPTION_TYPE_STRING
;
2501 opt_type
= TEAM_OPTION_TYPE_BINARY
;
2504 opt_type
= TEAM_OPTION_TYPE_BOOL
;
2507 opt_type
= TEAM_OPTION_TYPE_S32
;
2513 attr_data
= opt_attrs
[TEAM_ATTR_OPTION_DATA
];
2514 if (opt_type
!= TEAM_OPTION_TYPE_BOOL
&& !attr_data
) {
2519 opt_name
= nla_data(opt_attrs
[TEAM_ATTR_OPTION_NAME
]);
2520 attr
= opt_attrs
[TEAM_ATTR_OPTION_PORT_IFINDEX
];
2522 opt_port_ifindex
= nla_get_u32(attr
);
2524 attr
= opt_attrs
[TEAM_ATTR_OPTION_ARRAY_INDEX
];
2526 opt_is_array
= true;
2527 opt_array_index
= nla_get_u32(attr
);
2530 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2531 struct team_option
*option
= opt_inst
->option
;
2532 struct team_gsetter_ctx ctx
;
2533 struct team_option_inst_info
*opt_inst_info
;
2536 opt_inst_info
= &opt_inst
->info
;
2537 tmp_ifindex
= opt_inst_info
->port
?
2538 opt_inst_info
->port
->dev
->ifindex
: 0;
2539 if (option
->type
!= opt_type
||
2540 strcmp(option
->name
, opt_name
) ||
2541 tmp_ifindex
!= opt_port_ifindex
||
2542 (option
->array_size
&& !opt_is_array
) ||
2543 opt_inst_info
->array_index
!= opt_array_index
)
2546 ctx
.info
= opt_inst_info
;
2548 case TEAM_OPTION_TYPE_U32
:
2549 ctx
.data
.u32_val
= nla_get_u32(attr_data
);
2551 case TEAM_OPTION_TYPE_STRING
:
2552 if (nla_len(attr_data
) > TEAM_STRING_MAX_LEN
) {
2556 ctx
.data
.str_val
= nla_data(attr_data
);
2558 case TEAM_OPTION_TYPE_BINARY
:
2559 ctx
.data
.bin_val
.len
= nla_len(attr_data
);
2560 ctx
.data
.bin_val
.ptr
= nla_data(attr_data
);
2562 case TEAM_OPTION_TYPE_BOOL
:
2563 ctx
.data
.bool_val
= attr_data
? true : false;
2565 case TEAM_OPTION_TYPE_S32
:
2566 ctx
.data
.s32_val
= nla_get_s32(attr_data
);
2571 err
= team_option_set(team
, opt_inst
, &ctx
);
2574 opt_inst
->changed
= true;
2575 list_add(&opt_inst
->tmp_list
, &opt_inst_list
);
2583 err
= team_nl_send_event_options_get(team
, &opt_inst_list
);
2586 team_nl_team_put(team
);
2592 static int team_nl_fill_one_port_get(struct sk_buff
*skb
,
2593 struct team_port
*port
)
2595 struct nlattr
*port_item
;
2597 port_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_PORT
);
2600 if (nla_put_u32(skb
, TEAM_ATTR_PORT_IFINDEX
, port
->dev
->ifindex
))
2602 if (port
->changed
) {
2603 if (nla_put_flag(skb
, TEAM_ATTR_PORT_CHANGED
))
2605 port
->changed
= false;
2607 if ((port
->removed
&&
2608 nla_put_flag(skb
, TEAM_ATTR_PORT_REMOVED
)) ||
2609 (port
->state
.linkup
&&
2610 nla_put_flag(skb
, TEAM_ATTR_PORT_LINKUP
)) ||
2611 nla_put_u32(skb
, TEAM_ATTR_PORT_SPEED
, port
->state
.speed
) ||
2612 nla_put_u8(skb
, TEAM_ATTR_PORT_DUPLEX
, port
->state
.duplex
))
2614 nla_nest_end(skb
, port_item
);
2618 nla_nest_cancel(skb
, port_item
);
2622 static int team_nl_send_port_list_get(struct team
*team
, u32 portid
, u32 seq
,
2623 int flags
, team_nl_send_func_t
*send_func
,
2624 struct team_port
*one_port
)
2626 struct nlattr
*port_list
;
2627 struct nlmsghdr
*nlh
;
2629 struct team_port
*port
;
2631 struct sk_buff
*skb
= NULL
;
2635 port
= list_first_entry_or_null(&team
->port_list
,
2636 struct team_port
, list
);
2639 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2643 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2644 TEAM_CMD_PORT_LIST_GET
);
2648 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2649 goto nla_put_failure
;
2650 port_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_PORT
);
2652 goto nla_put_failure
;
2657 /* If one port is selected, called wants to send port list containing
2658 * only this port. Otherwise go through all listed ports and send all
2661 err
= team_nl_fill_one_port_get(skb
, one_port
);
2665 list_for_each_entry_from(port
, &team
->port_list
, list
) {
2666 err
= team_nl_fill_one_port_get(skb
, port
);
2668 if (err
== -EMSGSIZE
) {
2680 nla_nest_end(skb
, port_list
);
2681 genlmsg_end(skb
, hdr
);
2686 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2688 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2694 return send_func(skb
, team
, portid
);
2699 genlmsg_cancel(skb
, hdr
);
2704 static int team_nl_cmd_port_list_get(struct sk_buff
*skb
,
2705 struct genl_info
*info
)
2710 team
= team_nl_team_get(info
);
2714 err
= team_nl_send_port_list_get(team
, info
->snd_portid
, info
->snd_seq
,
2715 NLM_F_ACK
, team_nl_send_unicast
, NULL
);
2717 team_nl_team_put(team
);
2722 static const struct genl_ops team_nl_ops
[] = {
2724 .cmd
= TEAM_CMD_NOOP
,
2725 .doit
= team_nl_cmd_noop
,
2726 .policy
= team_nl_policy
,
2729 .cmd
= TEAM_CMD_OPTIONS_SET
,
2730 .doit
= team_nl_cmd_options_set
,
2731 .policy
= team_nl_policy
,
2732 .flags
= GENL_ADMIN_PERM
,
2735 .cmd
= TEAM_CMD_OPTIONS_GET
,
2736 .doit
= team_nl_cmd_options_get
,
2737 .policy
= team_nl_policy
,
2738 .flags
= GENL_ADMIN_PERM
,
2741 .cmd
= TEAM_CMD_PORT_LIST_GET
,
2742 .doit
= team_nl_cmd_port_list_get
,
2743 .policy
= team_nl_policy
,
2744 .flags
= GENL_ADMIN_PERM
,
2748 static const struct genl_multicast_group team_nl_mcgrps
[] = {
2749 { .name
= TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME
, },
2752 static int team_nl_send_multicast(struct sk_buff
*skb
,
2753 struct team
*team
, u32 portid
)
2755 return genlmsg_multicast_netns(&team_nl_family
, dev_net(team
->dev
),
2756 skb
, 0, 0, GFP_KERNEL
);
2759 static int team_nl_send_event_options_get(struct team
*team
,
2760 struct list_head
*sel_opt_inst_list
)
2762 return team_nl_send_options_get(team
, 0, 0, 0, team_nl_send_multicast
,
2766 static int team_nl_send_event_port_get(struct team
*team
,
2767 struct team_port
*port
)
2769 return team_nl_send_port_list_get(team
, 0, 0, 0, team_nl_send_multicast
,
2773 static int team_nl_init(void)
2775 return genl_register_family_with_ops_groups(&team_nl_family
, team_nl_ops
,
2779 static void team_nl_fini(void)
2781 genl_unregister_family(&team_nl_family
);
2789 static void __team_options_change_check(struct team
*team
)
2792 struct team_option_inst
*opt_inst
;
2793 LIST_HEAD(sel_opt_inst_list
);
2795 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2796 if (opt_inst
->changed
)
2797 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2799 err
= team_nl_send_event_options_get(team
, &sel_opt_inst_list
);
2800 if (err
&& err
!= -ESRCH
)
2801 netdev_warn(team
->dev
, "Failed to send options change via netlink (err %d)\n",
2805 /* rtnl lock is held */
2807 static void __team_port_change_send(struct team_port
*port
, bool linkup
)
2811 port
->changed
= true;
2812 port
->state
.linkup
= linkup
;
2813 team_refresh_port_linkup(port
);
2815 struct ethtool_link_ksettings ecmd
;
2817 err
= __ethtool_get_link_ksettings(port
->dev
, &ecmd
);
2819 port
->state
.speed
= ecmd
.base
.speed
;
2820 port
->state
.duplex
= ecmd
.base
.duplex
;
2824 port
->state
.speed
= 0;
2825 port
->state
.duplex
= 0;
2828 err
= team_nl_send_event_port_get(port
->team
, port
);
2829 if (err
&& err
!= -ESRCH
)
2830 netdev_warn(port
->team
->dev
, "Failed to send port change of device %s via netlink (err %d)\n",
2831 port
->dev
->name
, err
);
2835 static void __team_carrier_check(struct team
*team
)
2837 struct team_port
*port
;
2840 if (team
->user_carrier_enabled
)
2843 team_linkup
= false;
2844 list_for_each_entry(port
, &team
->port_list
, list
) {
2852 netif_carrier_on(team
->dev
);
2854 netif_carrier_off(team
->dev
);
2857 static void __team_port_change_check(struct team_port
*port
, bool linkup
)
2859 if (port
->state
.linkup
!= linkup
)
2860 __team_port_change_send(port
, linkup
);
2861 __team_carrier_check(port
->team
);
2864 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
)
2866 __team_port_change_send(port
, linkup
);
2867 __team_carrier_check(port
->team
);
2870 static void __team_port_change_port_removed(struct team_port
*port
)
2872 port
->removed
= true;
2873 __team_port_change_send(port
, false);
2874 __team_carrier_check(port
->team
);
2877 static void team_port_change_check(struct team_port
*port
, bool linkup
)
2879 struct team
*team
= port
->team
;
2881 mutex_lock(&team
->lock
);
2882 __team_port_change_check(port
, linkup
);
2883 mutex_unlock(&team
->lock
);
2887 /************************************
2888 * Net device notifier event handler
2889 ************************************/
2891 static int team_device_event(struct notifier_block
*unused
,
2892 unsigned long event
, void *ptr
)
2894 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
2895 struct team_port
*port
;
2897 port
= team_port_get_rtnl(dev
);
2903 if (netif_carrier_ok(dev
))
2904 team_port_change_check(port
, true);
2907 team_port_change_check(port
, false);
2910 if (netif_running(port
->dev
))
2911 team_port_change_check(port
,
2912 !!netif_carrier_ok(port
->dev
));
2914 case NETDEV_UNREGISTER
:
2915 team_del_slave(port
->team
->dev
, dev
);
2917 case NETDEV_FEAT_CHANGE
:
2918 team_compute_features(port
->team
);
2920 case NETDEV_PRECHANGEMTU
:
2921 /* Forbid to change mtu of underlaying device */
2922 if (!port
->team
->port_mtu_change_allowed
)
2925 case NETDEV_PRE_TYPE_CHANGE
:
2926 /* Forbid to change type of underlaying device */
2928 case NETDEV_RESEND_IGMP
:
2929 /* Propagate to master device */
2930 call_netdevice_notifiers(event
, port
->team
->dev
);
2936 static struct notifier_block team_notifier_block __read_mostly
= {
2937 .notifier_call
= team_device_event
,
2941 /***********************
2942 * Module init and exit
2943 ***********************/
2945 static int __init
team_module_init(void)
2949 register_netdevice_notifier(&team_notifier_block
);
2951 err
= rtnl_link_register(&team_link_ops
);
2955 err
= team_nl_init();
2962 rtnl_link_unregister(&team_link_ops
);
2965 unregister_netdevice_notifier(&team_notifier_block
);
2970 static void __exit
team_module_exit(void)
2973 rtnl_link_unregister(&team_link_ops
);
2974 unregister_netdevice_notifier(&team_notifier_block
);
2977 module_init(team_module_init
);
2978 module_exit(team_module_exit
);
2980 MODULE_LICENSE("GPL v2");
2981 MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
2982 MODULE_DESCRIPTION("Ethernet team device driver");
2983 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);