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 <generated/utsrelease.h>
32 #include <linux/if_team.h>
34 #define DRV_NAME "team"
41 #define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT)
43 static struct team_port
*team_port_get_rcu(const struct net_device
*dev
)
45 struct team_port
*port
= rcu_dereference(dev
->rx_handler_data
);
47 return team_port_exists(dev
) ? port
: NULL
;
50 static struct team_port
*team_port_get_rtnl(const struct net_device
*dev
)
52 struct team_port
*port
= rtnl_dereference(dev
->rx_handler_data
);
54 return team_port_exists(dev
) ? port
: NULL
;
58 * Since the ability to change device address for open port device is tested in
59 * team_port_add, this function can be called without control of return value
61 static int __set_port_dev_addr(struct net_device
*port_dev
,
62 const unsigned char *dev_addr
)
66 memcpy(addr
.sa_data
, dev_addr
, port_dev
->addr_len
);
67 addr
.sa_family
= port_dev
->type
;
68 return dev_set_mac_address(port_dev
, &addr
);
71 static int team_port_set_orig_dev_addr(struct team_port
*port
)
73 return __set_port_dev_addr(port
->dev
, port
->orig
.dev_addr
);
76 int team_port_set_team_dev_addr(struct team_port
*port
)
78 return __set_port_dev_addr(port
->dev
, port
->team
->dev
->dev_addr
);
80 EXPORT_SYMBOL(team_port_set_team_dev_addr
);
82 static void team_refresh_port_linkup(struct team_port
*port
)
84 port
->linkup
= port
->user
.linkup_enabled
? port
->user
.linkup
:
93 struct team_option_inst
{ /* One for each option instance */
94 struct list_head list
;
95 struct list_head tmp_list
;
96 struct team_option
*option
;
97 struct team_option_inst_info info
;
102 static struct team_option
*__team_find_option(struct team
*team
,
103 const char *opt_name
)
105 struct team_option
*option
;
107 list_for_each_entry(option
, &team
->option_list
, list
) {
108 if (strcmp(option
->name
, opt_name
) == 0)
114 static void __team_option_inst_del(struct team_option_inst
*opt_inst
)
116 list_del(&opt_inst
->list
);
120 static void __team_option_inst_del_option(struct team
*team
,
121 struct team_option
*option
)
123 struct team_option_inst
*opt_inst
, *tmp
;
125 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
126 if (opt_inst
->option
== option
)
127 __team_option_inst_del(opt_inst
);
131 static int __team_option_inst_add(struct team
*team
, struct team_option
*option
,
132 struct team_port
*port
)
134 struct team_option_inst
*opt_inst
;
135 unsigned int array_size
;
139 array_size
= option
->array_size
;
141 array_size
= 1; /* No array but still need one instance */
143 for (i
= 0; i
< array_size
; i
++) {
144 opt_inst
= kmalloc(sizeof(*opt_inst
), GFP_KERNEL
);
147 opt_inst
->option
= option
;
148 opt_inst
->info
.port
= port
;
149 opt_inst
->info
.array_index
= i
;
150 opt_inst
->changed
= true;
151 opt_inst
->removed
= false;
152 list_add_tail(&opt_inst
->list
, &team
->option_inst_list
);
154 err
= option
->init(team
, &opt_inst
->info
);
163 static int __team_option_inst_add_option(struct team
*team
,
164 struct team_option
*option
)
166 struct team_port
*port
;
169 if (!option
->per_port
) {
170 err
= __team_option_inst_add(team
, option
, NULL
);
172 goto inst_del_option
;
175 list_for_each_entry(port
, &team
->port_list
, list
) {
176 err
= __team_option_inst_add(team
, option
, port
);
178 goto inst_del_option
;
183 __team_option_inst_del_option(team
, option
);
187 static void __team_option_inst_mark_removed_option(struct team
*team
,
188 struct team_option
*option
)
190 struct team_option_inst
*opt_inst
;
192 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
193 if (opt_inst
->option
== option
) {
194 opt_inst
->changed
= true;
195 opt_inst
->removed
= true;
200 static void __team_option_inst_del_port(struct team
*team
,
201 struct team_port
*port
)
203 struct team_option_inst
*opt_inst
, *tmp
;
205 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
206 if (opt_inst
->option
->per_port
&&
207 opt_inst
->info
.port
== port
)
208 __team_option_inst_del(opt_inst
);
212 static int __team_option_inst_add_port(struct team
*team
,
213 struct team_port
*port
)
215 struct team_option
*option
;
218 list_for_each_entry(option
, &team
->option_list
, list
) {
219 if (!option
->per_port
)
221 err
= __team_option_inst_add(team
, option
, port
);
228 __team_option_inst_del_port(team
, port
);
232 static void __team_option_inst_mark_removed_port(struct team
*team
,
233 struct team_port
*port
)
235 struct team_option_inst
*opt_inst
;
237 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
238 if (opt_inst
->info
.port
== port
) {
239 opt_inst
->changed
= true;
240 opt_inst
->removed
= true;
245 static int __team_options_register(struct team
*team
,
246 const struct team_option
*option
,
250 struct team_option
**dst_opts
;
253 dst_opts
= kzalloc(sizeof(struct team_option
*) * option_count
,
257 for (i
= 0; i
< option_count
; i
++, option
++) {
258 if (__team_find_option(team
, option
->name
)) {
262 dst_opts
[i
] = kmemdup(option
, sizeof(*option
), GFP_KERNEL
);
269 for (i
= 0; i
< option_count
; i
++) {
270 err
= __team_option_inst_add_option(team
, dst_opts
[i
]);
273 list_add_tail(&dst_opts
[i
]->list
, &team
->option_list
);
280 for (i
--; i
>= 0; i
--)
281 __team_option_inst_del_option(team
, dst_opts
[i
]);
283 i
= option_count
- 1;
285 for (i
--; i
>= 0; i
--)
292 static void __team_options_mark_removed(struct team
*team
,
293 const struct team_option
*option
,
298 for (i
= 0; i
< option_count
; i
++, option
++) {
299 struct team_option
*del_opt
;
301 del_opt
= __team_find_option(team
, option
->name
);
303 __team_option_inst_mark_removed_option(team
, del_opt
);
307 static void __team_options_unregister(struct team
*team
,
308 const struct team_option
*option
,
313 for (i
= 0; i
< option_count
; i
++, option
++) {
314 struct team_option
*del_opt
;
316 del_opt
= __team_find_option(team
, option
->name
);
318 __team_option_inst_del_option(team
, del_opt
);
319 list_del(&del_opt
->list
);
325 static void __team_options_change_check(struct team
*team
);
327 int team_options_register(struct team
*team
,
328 const struct team_option
*option
,
333 err
= __team_options_register(team
, option
, option_count
);
336 __team_options_change_check(team
);
339 EXPORT_SYMBOL(team_options_register
);
341 void team_options_unregister(struct team
*team
,
342 const struct team_option
*option
,
345 __team_options_mark_removed(team
, option
, option_count
);
346 __team_options_change_check(team
);
347 __team_options_unregister(team
, option
, option_count
);
349 EXPORT_SYMBOL(team_options_unregister
);
351 static int team_option_get(struct team
*team
,
352 struct team_option_inst
*opt_inst
,
353 struct team_gsetter_ctx
*ctx
)
355 if (!opt_inst
->option
->getter
)
357 return opt_inst
->option
->getter(team
, ctx
);
360 static int team_option_set(struct team
*team
,
361 struct team_option_inst
*opt_inst
,
362 struct team_gsetter_ctx
*ctx
)
364 if (!opt_inst
->option
->setter
)
366 return opt_inst
->option
->setter(team
, ctx
);
369 void team_option_inst_set_change(struct team_option_inst_info
*opt_inst_info
)
371 struct team_option_inst
*opt_inst
;
373 opt_inst
= container_of(opt_inst_info
, struct team_option_inst
, info
);
374 opt_inst
->changed
= true;
376 EXPORT_SYMBOL(team_option_inst_set_change
);
378 void team_options_change_check(struct team
*team
)
380 __team_options_change_check(team
);
382 EXPORT_SYMBOL(team_options_change_check
);
389 static LIST_HEAD(mode_list
);
390 static DEFINE_SPINLOCK(mode_list_lock
);
392 struct team_mode_item
{
393 struct list_head list
;
394 const struct team_mode
*mode
;
397 static struct team_mode_item
*__find_mode(const char *kind
)
399 struct team_mode_item
*mitem
;
401 list_for_each_entry(mitem
, &mode_list
, list
) {
402 if (strcmp(mitem
->mode
->kind
, kind
) == 0)
408 static bool is_good_mode_name(const char *name
)
410 while (*name
!= '\0') {
411 if (!isalpha(*name
) && !isdigit(*name
) && *name
!= '_')
418 int team_mode_register(const struct team_mode
*mode
)
421 struct team_mode_item
*mitem
;
423 if (!is_good_mode_name(mode
->kind
) ||
424 mode
->priv_size
> TEAM_MODE_PRIV_SIZE
)
427 mitem
= kmalloc(sizeof(*mitem
), GFP_KERNEL
);
431 spin_lock(&mode_list_lock
);
432 if (__find_mode(mode
->kind
)) {
438 list_add_tail(&mitem
->list
, &mode_list
);
440 spin_unlock(&mode_list_lock
);
443 EXPORT_SYMBOL(team_mode_register
);
445 void team_mode_unregister(const struct team_mode
*mode
)
447 struct team_mode_item
*mitem
;
449 spin_lock(&mode_list_lock
);
450 mitem
= __find_mode(mode
->kind
);
452 list_del_init(&mitem
->list
);
455 spin_unlock(&mode_list_lock
);
457 EXPORT_SYMBOL(team_mode_unregister
);
459 static const struct team_mode
*team_mode_get(const char *kind
)
461 struct team_mode_item
*mitem
;
462 const struct team_mode
*mode
= NULL
;
464 spin_lock(&mode_list_lock
);
465 mitem
= __find_mode(kind
);
467 spin_unlock(&mode_list_lock
);
468 request_module("team-mode-%s", kind
);
469 spin_lock(&mode_list_lock
);
470 mitem
= __find_mode(kind
);
474 if (!try_module_get(mode
->owner
))
478 spin_unlock(&mode_list_lock
);
482 static void team_mode_put(const struct team_mode
*mode
)
484 module_put(mode
->owner
);
487 static bool team_dummy_transmit(struct team
*team
, struct sk_buff
*skb
)
489 dev_kfree_skb_any(skb
);
493 rx_handler_result_t
team_dummy_receive(struct team
*team
,
494 struct team_port
*port
,
497 return RX_HANDLER_ANOTHER
;
500 static const struct team_mode __team_no_mode
= {
504 static bool team_is_mode_set(struct team
*team
)
506 return team
->mode
!= &__team_no_mode
;
509 static void team_set_no_mode(struct team
*team
)
511 team
->user_carrier_enabled
= false;
512 team
->mode
= &__team_no_mode
;
515 static void __team_adjust_ops(struct team
*team
, int en_port_count
)
518 * To avoid checks in rx/tx skb paths, ensure here that non-null and
519 * correct ops are always set.
522 if (!en_port_count
|| !team_is_mode_set(team
) ||
523 !team
->mode
->ops
->transmit
)
524 team
->ops
.transmit
= team_dummy_transmit
;
526 team
->ops
.transmit
= team
->mode
->ops
->transmit
;
528 if (!en_port_count
|| !team_is_mode_set(team
) ||
529 !team
->mode
->ops
->receive
)
530 team
->ops
.receive
= team_dummy_receive
;
532 team
->ops
.receive
= team
->mode
->ops
->receive
;
535 static void team_adjust_ops(struct team
*team
)
537 __team_adjust_ops(team
, team
->en_port_count
);
541 * We can benefit from the fact that it's ensured no port is present
542 * at the time of mode change. Therefore no packets are in fly so there's no
543 * need to set mode operations in any special way.
545 static int __team_change_mode(struct team
*team
,
546 const struct team_mode
*new_mode
)
548 /* Check if mode was previously set and do cleanup if so */
549 if (team_is_mode_set(team
)) {
550 void (*exit_op
)(struct team
*team
) = team
->ops
.exit
;
552 /* Clear ops area so no callback is called any longer */
553 memset(&team
->ops
, 0, sizeof(struct team_mode_ops
));
554 team_adjust_ops(team
);
558 team_mode_put(team
->mode
);
559 team_set_no_mode(team
);
560 /* zero private data area */
561 memset(&team
->mode_priv
, 0,
562 sizeof(struct team
) - offsetof(struct team
, mode_priv
));
568 if (new_mode
->ops
->init
) {
571 err
= new_mode
->ops
->init(team
);
576 team
->mode
= new_mode
;
577 memcpy(&team
->ops
, new_mode
->ops
, sizeof(struct team_mode_ops
));
578 team_adjust_ops(team
);
583 static int team_change_mode(struct team
*team
, const char *kind
)
585 const struct team_mode
*new_mode
;
586 struct net_device
*dev
= team
->dev
;
589 if (!list_empty(&team
->port_list
)) {
590 netdev_err(dev
, "No ports can be present during mode change\n");
594 if (team_is_mode_set(team
) && strcmp(team
->mode
->kind
, kind
) == 0) {
595 netdev_err(dev
, "Unable to change to the same mode the team is in\n");
599 new_mode
= team_mode_get(kind
);
601 netdev_err(dev
, "Mode \"%s\" not found\n", kind
);
605 err
= __team_change_mode(team
, new_mode
);
607 netdev_err(dev
, "Failed to change to mode \"%s\"\n", kind
);
608 team_mode_put(new_mode
);
612 netdev_info(dev
, "Mode changed to \"%s\"\n", kind
);
617 /************************
618 * Rx path frame handler
619 ************************/
621 /* note: already called with rcu_read_lock */
622 static rx_handler_result_t
team_handle_frame(struct sk_buff
**pskb
)
624 struct sk_buff
*skb
= *pskb
;
625 struct team_port
*port
;
627 rx_handler_result_t res
;
629 skb
= skb_share_check(skb
, GFP_ATOMIC
);
631 return RX_HANDLER_CONSUMED
;
635 port
= team_port_get_rcu(skb
->dev
);
637 if (!team_port_enabled(port
)) {
638 /* allow exact match delivery for disabled ports */
639 res
= RX_HANDLER_EXACT
;
641 res
= team
->ops
.receive(team
, port
, skb
);
643 if (res
== RX_HANDLER_ANOTHER
) {
644 struct team_pcpu_stats
*pcpu_stats
;
646 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
647 u64_stats_update_begin(&pcpu_stats
->syncp
);
648 pcpu_stats
->rx_packets
++;
649 pcpu_stats
->rx_bytes
+= skb
->len
;
650 if (skb
->pkt_type
== PACKET_MULTICAST
)
651 pcpu_stats
->rx_multicast
++;
652 u64_stats_update_end(&pcpu_stats
->syncp
);
654 skb
->dev
= team
->dev
;
656 this_cpu_inc(team
->pcpu_stats
->rx_dropped
);
663 /*************************************
664 * Multiqueue Tx port select override
665 *************************************/
667 static int team_queue_override_init(struct team
*team
)
669 struct list_head
*listarr
;
670 unsigned int queue_cnt
= team
->dev
->num_tx_queues
- 1;
675 listarr
= kmalloc(sizeof(struct list_head
) * queue_cnt
, GFP_KERNEL
);
678 team
->qom_lists
= listarr
;
679 for (i
= 0; i
< queue_cnt
; i
++)
680 INIT_LIST_HEAD(listarr
++);
684 static void team_queue_override_fini(struct team
*team
)
686 kfree(team
->qom_lists
);
689 static struct list_head
*__team_get_qom_list(struct team
*team
, u16 queue_id
)
691 return &team
->qom_lists
[queue_id
- 1];
695 * note: already called with rcu_read_lock
697 static bool team_queue_override_transmit(struct team
*team
, struct sk_buff
*skb
)
699 struct list_head
*qom_list
;
700 struct team_port
*port
;
702 if (!team
->queue_override_enabled
|| !skb
->queue_mapping
)
704 qom_list
= __team_get_qom_list(team
, skb
->queue_mapping
);
705 list_for_each_entry_rcu(port
, qom_list
, qom_list
) {
706 if (!team_dev_queue_xmit(team
, port
, skb
))
712 static void __team_queue_override_port_del(struct team
*team
,
713 struct team_port
*port
)
715 list_del_rcu(&port
->qom_list
);
717 INIT_LIST_HEAD(&port
->qom_list
);
720 static bool team_queue_override_port_has_gt_prio_than(struct team_port
*port
,
721 struct team_port
*cur
)
723 if (port
->priority
< cur
->priority
)
725 if (port
->priority
> cur
->priority
)
727 if (port
->index
< cur
->index
)
732 static void __team_queue_override_port_add(struct team
*team
,
733 struct team_port
*port
)
735 struct team_port
*cur
;
736 struct list_head
*qom_list
;
737 struct list_head
*node
;
739 if (!port
->queue_id
|| !team_port_enabled(port
))
742 qom_list
= __team_get_qom_list(team
, port
->queue_id
);
744 list_for_each_entry(cur
, qom_list
, qom_list
) {
745 if (team_queue_override_port_has_gt_prio_than(port
, cur
))
747 node
= &cur
->qom_list
;
749 list_add_tail_rcu(&port
->qom_list
, node
);
752 static void __team_queue_override_enabled_check(struct team
*team
)
754 struct team_port
*port
;
755 bool enabled
= false;
757 list_for_each_entry(port
, &team
->port_list
, list
) {
758 if (!list_empty(&port
->qom_list
)) {
763 if (enabled
== team
->queue_override_enabled
)
765 netdev_dbg(team
->dev
, "%s queue override\n",
766 enabled
? "Enabling" : "Disabling");
767 team
->queue_override_enabled
= enabled
;
770 static void team_queue_override_port_refresh(struct team
*team
,
771 struct team_port
*port
)
773 __team_queue_override_port_del(team
, port
);
774 __team_queue_override_port_add(team
, port
);
775 __team_queue_override_enabled_check(team
);
783 static bool team_port_find(const struct team
*team
,
784 const struct team_port
*port
)
786 struct team_port
*cur
;
788 list_for_each_entry(cur
, &team
->port_list
, list
)
795 * Enable/disable port by adding to enabled port hashlist and setting
796 * port->index (Might be racy so reader could see incorrect ifindex when
797 * processing a flying packet, but that is not a problem). Write guarded
800 static void team_port_enable(struct team
*team
,
801 struct team_port
*port
)
803 if (team_port_enabled(port
))
805 port
->index
= team
->en_port_count
++;
806 hlist_add_head_rcu(&port
->hlist
,
807 team_port_index_hash(team
, port
->index
));
808 team_adjust_ops(team
);
809 team_queue_override_port_refresh(team
, port
);
810 if (team
->ops
.port_enabled
)
811 team
->ops
.port_enabled(team
, port
);
814 static void __reconstruct_port_hlist(struct team
*team
, int rm_index
)
817 struct team_port
*port
;
819 for (i
= rm_index
+ 1; i
< team
->en_port_count
; i
++) {
820 port
= team_get_port_by_index(team
, i
);
821 hlist_del_rcu(&port
->hlist
);
823 hlist_add_head_rcu(&port
->hlist
,
824 team_port_index_hash(team
, port
->index
));
828 static void team_port_disable(struct team
*team
,
829 struct team_port
*port
)
831 if (!team_port_enabled(port
))
833 if (team
->ops
.port_disabled
)
834 team
->ops
.port_disabled(team
, port
);
835 hlist_del_rcu(&port
->hlist
);
836 __reconstruct_port_hlist(team
, port
->index
);
838 team_queue_override_port_refresh(team
, port
);
839 __team_adjust_ops(team
, team
->en_port_count
- 1);
841 * Wait until readers see adjusted ops. This ensures that
842 * readers never see team->en_port_count == 0
845 team
->en_port_count
--;
848 #define TEAM_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
849 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
850 NETIF_F_HIGHDMA | NETIF_F_LRO)
852 static void __team_compute_features(struct team
*team
)
854 struct team_port
*port
;
855 u32 vlan_features
= TEAM_VLAN_FEATURES
;
856 unsigned short max_hard_header_len
= ETH_HLEN
;
857 unsigned int flags
, dst_release_flag
= IFF_XMIT_DST_RELEASE
;
859 list_for_each_entry(port
, &team
->port_list
, list
) {
860 vlan_features
= netdev_increment_features(vlan_features
,
861 port
->dev
->vlan_features
,
864 dst_release_flag
&= port
->dev
->priv_flags
;
865 if (port
->dev
->hard_header_len
> max_hard_header_len
)
866 max_hard_header_len
= port
->dev
->hard_header_len
;
869 team
->dev
->vlan_features
= vlan_features
;
870 team
->dev
->hard_header_len
= max_hard_header_len
;
872 flags
= team
->dev
->priv_flags
& ~IFF_XMIT_DST_RELEASE
;
873 team
->dev
->priv_flags
= flags
| dst_release_flag
;
875 netdev_change_features(team
->dev
);
878 static void team_compute_features(struct team
*team
)
880 mutex_lock(&team
->lock
);
881 __team_compute_features(team
);
882 mutex_unlock(&team
->lock
);
885 static int team_port_enter(struct team
*team
, struct team_port
*port
)
890 port
->dev
->priv_flags
|= IFF_TEAM_PORT
;
891 if (team
->ops
.port_enter
) {
892 err
= team
->ops
.port_enter(team
, port
);
894 netdev_err(team
->dev
, "Device %s failed to enter team mode\n",
903 port
->dev
->priv_flags
&= ~IFF_TEAM_PORT
;
909 static void team_port_leave(struct team
*team
, struct team_port
*port
)
911 if (team
->ops
.port_leave
)
912 team
->ops
.port_leave(team
, port
);
913 port
->dev
->priv_flags
&= ~IFF_TEAM_PORT
;
917 #ifdef CONFIG_NET_POLL_CONTROLLER
918 static int team_port_enable_netpoll(struct team
*team
, struct team_port
*port
,
924 np
= kzalloc(sizeof(*np
), gfp
);
928 err
= __netpoll_setup(np
, port
->dev
, gfp
);
937 static void team_port_disable_netpoll(struct team_port
*port
)
939 struct netpoll
*np
= port
->np
;
945 /* Wait for transmitting packets to finish before freeing. */
946 synchronize_rcu_bh();
947 __netpoll_cleanup(np
);
951 static struct netpoll_info
*team_netpoll_info(struct team
*team
)
953 return team
->dev
->npinfo
;
957 static int team_port_enable_netpoll(struct team
*team
, struct team_port
*port
,
962 static void team_port_disable_netpoll(struct team_port
*port
)
965 static struct netpoll_info
*team_netpoll_info(struct team
*team
)
971 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
);
972 static int team_dev_type_check_change(struct net_device
*dev
,
973 struct net_device
*port_dev
);
975 static int team_port_add(struct team
*team
, struct net_device
*port_dev
)
977 struct net_device
*dev
= team
->dev
;
978 struct team_port
*port
;
979 char *portname
= port_dev
->name
;
982 if (port_dev
->flags
& IFF_LOOPBACK
) {
983 netdev_err(dev
, "Device %s is loopback device. Loopback devices can't be added as a team port\n",
988 if (team_port_exists(port_dev
)) {
989 netdev_err(dev
, "Device %s is already a port "
990 "of a team device\n", portname
);
994 if (port_dev
->features
& NETIF_F_VLAN_CHALLENGED
&&
995 vlan_uses_dev(dev
)) {
996 netdev_err(dev
, "Device %s is VLAN challenged and team device has VLAN set up\n",
1001 err
= team_dev_type_check_change(dev
, port_dev
);
1005 if (port_dev
->flags
& IFF_UP
) {
1006 netdev_err(dev
, "Device %s is up. Set it down before adding it as a team port\n",
1011 port
= kzalloc(sizeof(struct team_port
) + team
->mode
->port_priv_size
,
1016 port
->dev
= port_dev
;
1018 INIT_LIST_HEAD(&port
->qom_list
);
1020 port
->orig
.mtu
= port_dev
->mtu
;
1021 err
= dev_set_mtu(port_dev
, dev
->mtu
);
1023 netdev_dbg(dev
, "Error %d calling dev_set_mtu\n", err
);
1027 memcpy(port
->orig
.dev_addr
, port_dev
->dev_addr
, port_dev
->addr_len
);
1029 err
= team_port_enter(team
, port
);
1031 netdev_err(dev
, "Device %s failed to enter team mode\n",
1033 goto err_port_enter
;
1036 err
= dev_open(port_dev
);
1038 netdev_dbg(dev
, "Device %s opening failed\n",
1043 err
= vlan_vids_add_by_dev(port_dev
, dev
);
1045 netdev_err(dev
, "Failed to add vlan ids to device %s\n",
1050 if (team_netpoll_info(team
)) {
1051 err
= team_port_enable_netpoll(team
, port
, GFP_KERNEL
);
1053 netdev_err(dev
, "Failed to enable netpoll on device %s\n",
1055 goto err_enable_netpoll
;
1059 err
= netdev_master_upper_dev_link(port_dev
, dev
);
1061 netdev_err(dev
, "Device %s failed to set upper link\n",
1063 goto err_set_upper_link
;
1066 err
= netdev_rx_handler_register(port_dev
, team_handle_frame
,
1069 netdev_err(dev
, "Device %s failed to register rx_handler\n",
1071 goto err_handler_register
;
1074 err
= __team_option_inst_add_port(team
, port
);
1076 netdev_err(dev
, "Device %s failed to add per-port options\n",
1078 goto err_option_port_add
;
1082 team_port_enable(team
, port
);
1083 list_add_tail_rcu(&port
->list
, &team
->port_list
);
1084 __team_compute_features(team
);
1085 __team_port_change_port_added(port
, !!netif_carrier_ok(port_dev
));
1086 __team_options_change_check(team
);
1088 netdev_info(dev
, "Port device %s added\n", portname
);
1092 err_option_port_add
:
1093 netdev_rx_handler_unregister(port_dev
);
1095 err_handler_register
:
1096 netdev_upper_dev_unlink(port_dev
, dev
);
1099 team_port_disable_netpoll(port
);
1102 vlan_vids_del_by_dev(port_dev
, dev
);
1105 dev_close(port_dev
);
1108 team_port_leave(team
, port
);
1109 team_port_set_orig_dev_addr(port
);
1112 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1120 static void __team_port_change_port_removed(struct team_port
*port
);
1122 static int team_port_del(struct team
*team
, struct net_device
*port_dev
)
1124 struct net_device
*dev
= team
->dev
;
1125 struct team_port
*port
;
1126 char *portname
= port_dev
->name
;
1128 port
= team_port_get_rtnl(port_dev
);
1129 if (!port
|| !team_port_find(team
, port
)) {
1130 netdev_err(dev
, "Device %s does not act as a port of this team\n",
1135 team_port_disable(team
, port
);
1136 list_del_rcu(&port
->list
);
1137 netdev_rx_handler_unregister(port_dev
);
1138 netdev_upper_dev_unlink(port_dev
, dev
);
1139 team_port_disable_netpoll(port
);
1140 vlan_vids_del_by_dev(port_dev
, dev
);
1141 dev_uc_unsync(port_dev
, dev
);
1142 dev_mc_unsync(port_dev
, dev
);
1143 dev_close(port_dev
);
1144 team_port_leave(team
, port
);
1146 __team_option_inst_mark_removed_port(team
, port
);
1147 __team_options_change_check(team
);
1148 __team_option_inst_del_port(team
, port
);
1149 __team_port_change_port_removed(port
);
1151 team_port_set_orig_dev_addr(port
);
1152 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1155 netdev_info(dev
, "Port device %s removed\n", portname
);
1156 __team_compute_features(team
);
1166 static int team_mode_option_get(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1168 ctx
->data
.str_val
= team
->mode
->kind
;
1172 static int team_mode_option_set(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1174 return team_change_mode(team
, ctx
->data
.str_val
);
1177 static int team_port_en_option_get(struct team
*team
,
1178 struct team_gsetter_ctx
*ctx
)
1180 struct team_port
*port
= ctx
->info
->port
;
1182 ctx
->data
.bool_val
= team_port_enabled(port
);
1186 static int team_port_en_option_set(struct team
*team
,
1187 struct team_gsetter_ctx
*ctx
)
1189 struct team_port
*port
= ctx
->info
->port
;
1191 if (ctx
->data
.bool_val
)
1192 team_port_enable(team
, port
);
1194 team_port_disable(team
, port
);
1198 static int team_user_linkup_option_get(struct team
*team
,
1199 struct team_gsetter_ctx
*ctx
)
1201 struct team_port
*port
= ctx
->info
->port
;
1203 ctx
->data
.bool_val
= port
->user
.linkup
;
1207 static int team_user_linkup_option_set(struct team
*team
,
1208 struct team_gsetter_ctx
*ctx
)
1210 struct team_port
*port
= ctx
->info
->port
;
1212 port
->user
.linkup
= ctx
->data
.bool_val
;
1213 team_refresh_port_linkup(port
);
1217 static int team_user_linkup_en_option_get(struct team
*team
,
1218 struct team_gsetter_ctx
*ctx
)
1220 struct team_port
*port
= ctx
->info
->port
;
1222 ctx
->data
.bool_val
= port
->user
.linkup_enabled
;
1226 static int team_user_linkup_en_option_set(struct team
*team
,
1227 struct team_gsetter_ctx
*ctx
)
1229 struct team_port
*port
= ctx
->info
->port
;
1231 port
->user
.linkup_enabled
= ctx
->data
.bool_val
;
1232 team_refresh_port_linkup(port
);
1236 static int team_priority_option_get(struct team
*team
,
1237 struct team_gsetter_ctx
*ctx
)
1239 struct team_port
*port
= ctx
->info
->port
;
1241 ctx
->data
.s32_val
= port
->priority
;
1245 static int team_priority_option_set(struct team
*team
,
1246 struct team_gsetter_ctx
*ctx
)
1248 struct team_port
*port
= ctx
->info
->port
;
1250 port
->priority
= ctx
->data
.s32_val
;
1251 team_queue_override_port_refresh(team
, port
);
1255 static int team_queue_id_option_get(struct team
*team
,
1256 struct team_gsetter_ctx
*ctx
)
1258 struct team_port
*port
= ctx
->info
->port
;
1260 ctx
->data
.u32_val
= port
->queue_id
;
1264 static int team_queue_id_option_set(struct team
*team
,
1265 struct team_gsetter_ctx
*ctx
)
1267 struct team_port
*port
= ctx
->info
->port
;
1269 if (port
->queue_id
== ctx
->data
.u32_val
)
1271 if (ctx
->data
.u32_val
>= team
->dev
->real_num_tx_queues
)
1273 port
->queue_id
= ctx
->data
.u32_val
;
1274 team_queue_override_port_refresh(team
, port
);
1279 static const struct team_option team_options
[] = {
1282 .type
= TEAM_OPTION_TYPE_STRING
,
1283 .getter
= team_mode_option_get
,
1284 .setter
= team_mode_option_set
,
1288 .type
= TEAM_OPTION_TYPE_BOOL
,
1290 .getter
= team_port_en_option_get
,
1291 .setter
= team_port_en_option_set
,
1294 .name
= "user_linkup",
1295 .type
= TEAM_OPTION_TYPE_BOOL
,
1297 .getter
= team_user_linkup_option_get
,
1298 .setter
= team_user_linkup_option_set
,
1301 .name
= "user_linkup_enabled",
1302 .type
= TEAM_OPTION_TYPE_BOOL
,
1304 .getter
= team_user_linkup_en_option_get
,
1305 .setter
= team_user_linkup_en_option_set
,
1309 .type
= TEAM_OPTION_TYPE_S32
,
1311 .getter
= team_priority_option_get
,
1312 .setter
= team_priority_option_set
,
1316 .type
= TEAM_OPTION_TYPE_U32
,
1318 .getter
= team_queue_id_option_get
,
1319 .setter
= team_queue_id_option_set
,
1323 static struct lock_class_key team_netdev_xmit_lock_key
;
1324 static struct lock_class_key team_netdev_addr_lock_key
;
1325 static struct lock_class_key team_tx_busylock_key
;
1327 static void team_set_lockdep_class_one(struct net_device
*dev
,
1328 struct netdev_queue
*txq
,
1331 lockdep_set_class(&txq
->_xmit_lock
, &team_netdev_xmit_lock_key
);
1334 static void team_set_lockdep_class(struct net_device
*dev
)
1336 lockdep_set_class(&dev
->addr_list_lock
, &team_netdev_addr_lock_key
);
1337 netdev_for_each_tx_queue(dev
, team_set_lockdep_class_one
, NULL
);
1338 dev
->qdisc_tx_busylock
= &team_tx_busylock_key
;
1341 static int team_init(struct net_device
*dev
)
1343 struct team
*team
= netdev_priv(dev
);
1348 mutex_init(&team
->lock
);
1349 team_set_no_mode(team
);
1351 team
->pcpu_stats
= alloc_percpu(struct team_pcpu_stats
);
1352 if (!team
->pcpu_stats
)
1355 for (i
= 0; i
< TEAM_PORT_HASHENTRIES
; i
++)
1356 INIT_HLIST_HEAD(&team
->en_port_hlist
[i
]);
1357 INIT_LIST_HEAD(&team
->port_list
);
1358 err
= team_queue_override_init(team
);
1360 goto err_team_queue_override_init
;
1362 team_adjust_ops(team
);
1364 INIT_LIST_HEAD(&team
->option_list
);
1365 INIT_LIST_HEAD(&team
->option_inst_list
);
1366 err
= team_options_register(team
, team_options
, ARRAY_SIZE(team_options
));
1368 goto err_options_register
;
1369 netif_carrier_off(dev
);
1371 team_set_lockdep_class(dev
);
1375 err_options_register
:
1376 team_queue_override_fini(team
);
1377 err_team_queue_override_init
:
1378 free_percpu(team
->pcpu_stats
);
1383 static void team_uninit(struct net_device
*dev
)
1385 struct team
*team
= netdev_priv(dev
);
1386 struct team_port
*port
;
1387 struct team_port
*tmp
;
1389 mutex_lock(&team
->lock
);
1390 list_for_each_entry_safe(port
, tmp
, &team
->port_list
, list
)
1391 team_port_del(team
, port
->dev
);
1393 __team_change_mode(team
, NULL
); /* cleanup */
1394 __team_options_unregister(team
, team_options
, ARRAY_SIZE(team_options
));
1395 team_queue_override_fini(team
);
1396 mutex_unlock(&team
->lock
);
1399 static void team_destructor(struct net_device
*dev
)
1401 struct team
*team
= netdev_priv(dev
);
1403 free_percpu(team
->pcpu_stats
);
1407 static int team_open(struct net_device
*dev
)
1412 static int team_close(struct net_device
*dev
)
1418 * note: already called with rcu_read_lock
1420 static netdev_tx_t
team_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1422 struct team
*team
= netdev_priv(dev
);
1424 unsigned int len
= skb
->len
;
1426 tx_success
= team_queue_override_transmit(team
, skb
);
1428 tx_success
= team
->ops
.transmit(team
, skb
);
1430 struct team_pcpu_stats
*pcpu_stats
;
1432 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
1433 u64_stats_update_begin(&pcpu_stats
->syncp
);
1434 pcpu_stats
->tx_packets
++;
1435 pcpu_stats
->tx_bytes
+= len
;
1436 u64_stats_update_end(&pcpu_stats
->syncp
);
1438 this_cpu_inc(team
->pcpu_stats
->tx_dropped
);
1441 return NETDEV_TX_OK
;
1444 static u16
team_select_queue(struct net_device
*dev
, struct sk_buff
*skb
)
1447 * This helper function exists to help dev_pick_tx get the correct
1448 * destination queue. Using a helper function skips a call to
1449 * skb_tx_hash and will put the skbs in the queue we expect on their
1450 * way down to the team driver.
1452 u16 txq
= skb_rx_queue_recorded(skb
) ? skb_get_rx_queue(skb
) : 0;
1455 * Save the original txq to restore before passing to the driver
1457 qdisc_skb_cb(skb
)->slave_dev_queue_mapping
= skb
->queue_mapping
;
1459 if (unlikely(txq
>= dev
->real_num_tx_queues
)) {
1461 txq
-= dev
->real_num_tx_queues
;
1462 } while (txq
>= dev
->real_num_tx_queues
);
1467 static void team_change_rx_flags(struct net_device
*dev
, int change
)
1469 struct team
*team
= netdev_priv(dev
);
1470 struct team_port
*port
;
1474 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1475 if (change
& IFF_PROMISC
) {
1476 inc
= dev
->flags
& IFF_PROMISC
? 1 : -1;
1477 dev_set_promiscuity(port
->dev
, inc
);
1479 if (change
& IFF_ALLMULTI
) {
1480 inc
= dev
->flags
& IFF_ALLMULTI
? 1 : -1;
1481 dev_set_allmulti(port
->dev
, inc
);
1487 static void team_set_rx_mode(struct net_device
*dev
)
1489 struct team
*team
= netdev_priv(dev
);
1490 struct team_port
*port
;
1493 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1494 dev_uc_sync(port
->dev
, dev
);
1495 dev_mc_sync(port
->dev
, dev
);
1500 static int team_set_mac_address(struct net_device
*dev
, void *p
)
1502 struct sockaddr
*addr
= p
;
1503 struct team
*team
= netdev_priv(dev
);
1504 struct team_port
*port
;
1506 if (dev
->type
== ARPHRD_ETHER
&& !is_valid_ether_addr(addr
->sa_data
))
1507 return -EADDRNOTAVAIL
;
1508 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1510 list_for_each_entry_rcu(port
, &team
->port_list
, list
)
1511 if (team
->ops
.port_change_dev_addr
)
1512 team
->ops
.port_change_dev_addr(team
, port
);
1517 static int team_change_mtu(struct net_device
*dev
, int new_mtu
)
1519 struct team
*team
= netdev_priv(dev
);
1520 struct team_port
*port
;
1524 * Alhough this is reader, it's guarded by team lock. It's not possible
1525 * to traverse list in reverse under rcu_read_lock
1527 mutex_lock(&team
->lock
);
1528 list_for_each_entry(port
, &team
->port_list
, list
) {
1529 err
= dev_set_mtu(port
->dev
, new_mtu
);
1531 netdev_err(dev
, "Device %s failed to change mtu",
1536 mutex_unlock(&team
->lock
);
1543 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1544 dev_set_mtu(port
->dev
, dev
->mtu
);
1545 mutex_unlock(&team
->lock
);
1550 static struct rtnl_link_stats64
*
1551 team_get_stats64(struct net_device
*dev
, struct rtnl_link_stats64
*stats
)
1553 struct team
*team
= netdev_priv(dev
);
1554 struct team_pcpu_stats
*p
;
1555 u64 rx_packets
, rx_bytes
, rx_multicast
, tx_packets
, tx_bytes
;
1556 u32 rx_dropped
= 0, tx_dropped
= 0;
1560 for_each_possible_cpu(i
) {
1561 p
= per_cpu_ptr(team
->pcpu_stats
, i
);
1563 start
= u64_stats_fetch_begin_bh(&p
->syncp
);
1564 rx_packets
= p
->rx_packets
;
1565 rx_bytes
= p
->rx_bytes
;
1566 rx_multicast
= p
->rx_multicast
;
1567 tx_packets
= p
->tx_packets
;
1568 tx_bytes
= p
->tx_bytes
;
1569 } while (u64_stats_fetch_retry_bh(&p
->syncp
, start
));
1571 stats
->rx_packets
+= rx_packets
;
1572 stats
->rx_bytes
+= rx_bytes
;
1573 stats
->multicast
+= rx_multicast
;
1574 stats
->tx_packets
+= tx_packets
;
1575 stats
->tx_bytes
+= tx_bytes
;
1577 * rx_dropped & tx_dropped are u32, updated
1578 * without syncp protection.
1580 rx_dropped
+= p
->rx_dropped
;
1581 tx_dropped
+= p
->tx_dropped
;
1583 stats
->rx_dropped
= rx_dropped
;
1584 stats
->tx_dropped
= tx_dropped
;
1588 static int team_vlan_rx_add_vid(struct net_device
*dev
, uint16_t vid
)
1590 struct team
*team
= netdev_priv(dev
);
1591 struct team_port
*port
;
1595 * Alhough this is reader, it's guarded by team lock. It's not possible
1596 * to traverse list in reverse under rcu_read_lock
1598 mutex_lock(&team
->lock
);
1599 list_for_each_entry(port
, &team
->port_list
, list
) {
1600 err
= vlan_vid_add(port
->dev
, vid
);
1604 mutex_unlock(&team
->lock
);
1609 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1610 vlan_vid_del(port
->dev
, vid
);
1611 mutex_unlock(&team
->lock
);
1616 static int team_vlan_rx_kill_vid(struct net_device
*dev
, uint16_t vid
)
1618 struct team
*team
= netdev_priv(dev
);
1619 struct team_port
*port
;
1622 list_for_each_entry_rcu(port
, &team
->port_list
, list
)
1623 vlan_vid_del(port
->dev
, vid
);
1629 #ifdef CONFIG_NET_POLL_CONTROLLER
1630 static void team_poll_controller(struct net_device
*dev
)
1634 static void __team_netpoll_cleanup(struct team
*team
)
1636 struct team_port
*port
;
1638 list_for_each_entry(port
, &team
->port_list
, list
)
1639 team_port_disable_netpoll(port
);
1642 static void team_netpoll_cleanup(struct net_device
*dev
)
1644 struct team
*team
= netdev_priv(dev
);
1646 mutex_lock(&team
->lock
);
1647 __team_netpoll_cleanup(team
);
1648 mutex_unlock(&team
->lock
);
1651 static int team_netpoll_setup(struct net_device
*dev
,
1652 struct netpoll_info
*npifo
, gfp_t gfp
)
1654 struct team
*team
= netdev_priv(dev
);
1655 struct team_port
*port
;
1658 mutex_lock(&team
->lock
);
1659 list_for_each_entry(port
, &team
->port_list
, list
) {
1660 err
= team_port_enable_netpoll(team
, port
, gfp
);
1662 __team_netpoll_cleanup(team
);
1666 mutex_unlock(&team
->lock
);
1671 static int team_add_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1673 struct team
*team
= netdev_priv(dev
);
1676 mutex_lock(&team
->lock
);
1677 err
= team_port_add(team
, port_dev
);
1678 mutex_unlock(&team
->lock
);
1682 static int team_del_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1684 struct team
*team
= netdev_priv(dev
);
1687 mutex_lock(&team
->lock
);
1688 err
= team_port_del(team
, port_dev
);
1689 mutex_unlock(&team
->lock
);
1693 static netdev_features_t
team_fix_features(struct net_device
*dev
,
1694 netdev_features_t features
)
1696 struct team_port
*port
;
1697 struct team
*team
= netdev_priv(dev
);
1698 netdev_features_t mask
;
1701 features
&= ~NETIF_F_ONE_FOR_ALL
;
1702 features
|= NETIF_F_ALL_FOR_ALL
;
1705 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1706 features
= netdev_increment_features(features
,
1707 port
->dev
->features
,
1714 static int team_change_carrier(struct net_device
*dev
, bool new_carrier
)
1716 struct team
*team
= netdev_priv(dev
);
1718 team
->user_carrier_enabled
= true;
1721 netif_carrier_on(dev
);
1723 netif_carrier_off(dev
);
1727 static const struct net_device_ops team_netdev_ops
= {
1728 .ndo_init
= team_init
,
1729 .ndo_uninit
= team_uninit
,
1730 .ndo_open
= team_open
,
1731 .ndo_stop
= team_close
,
1732 .ndo_start_xmit
= team_xmit
,
1733 .ndo_select_queue
= team_select_queue
,
1734 .ndo_change_rx_flags
= team_change_rx_flags
,
1735 .ndo_set_rx_mode
= team_set_rx_mode
,
1736 .ndo_set_mac_address
= team_set_mac_address
,
1737 .ndo_change_mtu
= team_change_mtu
,
1738 .ndo_get_stats64
= team_get_stats64
,
1739 .ndo_vlan_rx_add_vid
= team_vlan_rx_add_vid
,
1740 .ndo_vlan_rx_kill_vid
= team_vlan_rx_kill_vid
,
1741 #ifdef CONFIG_NET_POLL_CONTROLLER
1742 .ndo_poll_controller
= team_poll_controller
,
1743 .ndo_netpoll_setup
= team_netpoll_setup
,
1744 .ndo_netpoll_cleanup
= team_netpoll_cleanup
,
1746 .ndo_add_slave
= team_add_slave
,
1747 .ndo_del_slave
= team_del_slave
,
1748 .ndo_fix_features
= team_fix_features
,
1749 .ndo_change_carrier
= team_change_carrier
,
1752 /***********************
1754 ***********************/
1756 static void team_ethtool_get_drvinfo(struct net_device
*dev
,
1757 struct ethtool_drvinfo
*drvinfo
)
1759 strlcpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
1760 strlcpy(drvinfo
->version
, UTS_RELEASE
, sizeof(drvinfo
->version
));
1763 static const struct ethtool_ops team_ethtool_ops
= {
1764 .get_drvinfo
= team_ethtool_get_drvinfo
,
1765 .get_link
= ethtool_op_get_link
,
1768 /***********************
1769 * rt netlink interface
1770 ***********************/
1772 static void team_setup_by_port(struct net_device
*dev
,
1773 struct net_device
*port_dev
)
1775 dev
->header_ops
= port_dev
->header_ops
;
1776 dev
->type
= port_dev
->type
;
1777 dev
->hard_header_len
= port_dev
->hard_header_len
;
1778 dev
->addr_len
= port_dev
->addr_len
;
1779 dev
->mtu
= port_dev
->mtu
;
1780 memcpy(dev
->broadcast
, port_dev
->broadcast
, port_dev
->addr_len
);
1781 memcpy(dev
->dev_addr
, port_dev
->dev_addr
, port_dev
->addr_len
);
1784 static int team_dev_type_check_change(struct net_device
*dev
,
1785 struct net_device
*port_dev
)
1787 struct team
*team
= netdev_priv(dev
);
1788 char *portname
= port_dev
->name
;
1791 if (dev
->type
== port_dev
->type
)
1793 if (!list_empty(&team
->port_list
)) {
1794 netdev_err(dev
, "Device %s is of different type\n", portname
);
1797 err
= call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE
, dev
);
1798 err
= notifier_to_errno(err
);
1800 netdev_err(dev
, "Refused to change device type\n");
1805 team_setup_by_port(dev
, port_dev
);
1806 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE
, dev
);
1810 static void team_setup(struct net_device
*dev
)
1814 dev
->netdev_ops
= &team_netdev_ops
;
1815 dev
->ethtool_ops
= &team_ethtool_ops
;
1816 dev
->destructor
= team_destructor
;
1817 dev
->tx_queue_len
= 0;
1818 dev
->flags
|= IFF_MULTICAST
;
1819 dev
->priv_flags
&= ~(IFF_XMIT_DST_RELEASE
| IFF_TX_SKB_SHARING
);
1822 * Indicate we support unicast address filtering. That way core won't
1823 * bring us to promisc mode in case a unicast addr is added.
1824 * Let this up to underlay drivers.
1826 dev
->priv_flags
|= IFF_UNICAST_FLT
| IFF_LIVE_ADDR_CHANGE
;
1828 dev
->features
|= NETIF_F_LLTX
;
1829 dev
->features
|= NETIF_F_GRO
;
1830 dev
->hw_features
= TEAM_VLAN_FEATURES
|
1831 NETIF_F_HW_VLAN_TX
|
1832 NETIF_F_HW_VLAN_RX
|
1833 NETIF_F_HW_VLAN_FILTER
;
1835 dev
->hw_features
&= ~(NETIF_F_ALL_CSUM
& ~NETIF_F_HW_CSUM
);
1836 dev
->features
|= dev
->hw_features
;
1839 static int team_newlink(struct net
*src_net
, struct net_device
*dev
,
1840 struct nlattr
*tb
[], struct nlattr
*data
[])
1844 if (tb
[IFLA_ADDRESS
] == NULL
)
1845 eth_hw_addr_random(dev
);
1847 err
= register_netdevice(dev
);
1854 static int team_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
1856 if (tb
[IFLA_ADDRESS
]) {
1857 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
1859 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
1860 return -EADDRNOTAVAIL
;
1865 static unsigned int team_get_num_tx_queues(void)
1867 return TEAM_DEFAULT_NUM_TX_QUEUES
;
1870 static unsigned int team_get_num_rx_queues(void)
1872 return TEAM_DEFAULT_NUM_RX_QUEUES
;
1875 static struct rtnl_link_ops team_link_ops __read_mostly
= {
1877 .priv_size
= sizeof(struct team
),
1878 .setup
= team_setup
,
1879 .newlink
= team_newlink
,
1880 .validate
= team_validate
,
1881 .get_num_tx_queues
= team_get_num_tx_queues
,
1882 .get_num_rx_queues
= team_get_num_rx_queues
,
1886 /***********************************
1887 * Generic netlink custom interface
1888 ***********************************/
1890 static struct genl_family team_nl_family
= {
1891 .id
= GENL_ID_GENERATE
,
1892 .name
= TEAM_GENL_NAME
,
1893 .version
= TEAM_GENL_VERSION
,
1894 .maxattr
= TEAM_ATTR_MAX
,
1898 static const struct nla_policy team_nl_policy
[TEAM_ATTR_MAX
+ 1] = {
1899 [TEAM_ATTR_UNSPEC
] = { .type
= NLA_UNSPEC
, },
1900 [TEAM_ATTR_TEAM_IFINDEX
] = { .type
= NLA_U32
},
1901 [TEAM_ATTR_LIST_OPTION
] = { .type
= NLA_NESTED
},
1902 [TEAM_ATTR_LIST_PORT
] = { .type
= NLA_NESTED
},
1905 static const struct nla_policy
1906 team_nl_option_policy
[TEAM_ATTR_OPTION_MAX
+ 1] = {
1907 [TEAM_ATTR_OPTION_UNSPEC
] = { .type
= NLA_UNSPEC
, },
1908 [TEAM_ATTR_OPTION_NAME
] = {
1910 .len
= TEAM_STRING_MAX_LEN
,
1912 [TEAM_ATTR_OPTION_CHANGED
] = { .type
= NLA_FLAG
},
1913 [TEAM_ATTR_OPTION_TYPE
] = { .type
= NLA_U8
},
1914 [TEAM_ATTR_OPTION_DATA
] = { .type
= NLA_BINARY
},
1917 static int team_nl_cmd_noop(struct sk_buff
*skb
, struct genl_info
*info
)
1919 struct sk_buff
*msg
;
1923 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1927 hdr
= genlmsg_put(msg
, info
->snd_portid
, info
->snd_seq
,
1928 &team_nl_family
, 0, TEAM_CMD_NOOP
);
1934 genlmsg_end(msg
, hdr
);
1936 return genlmsg_unicast(genl_info_net(info
), msg
, info
->snd_portid
);
1945 * Netlink cmd functions should be locked by following two functions.
1946 * Since dev gets held here, that ensures dev won't disappear in between.
1948 static struct team
*team_nl_team_get(struct genl_info
*info
)
1950 struct net
*net
= genl_info_net(info
);
1952 struct net_device
*dev
;
1955 if (!info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
])
1958 ifindex
= nla_get_u32(info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
]);
1959 dev
= dev_get_by_index(net
, ifindex
);
1960 if (!dev
|| dev
->netdev_ops
!= &team_netdev_ops
) {
1966 team
= netdev_priv(dev
);
1967 mutex_lock(&team
->lock
);
1971 static void team_nl_team_put(struct team
*team
)
1973 mutex_unlock(&team
->lock
);
1977 typedef int team_nl_send_func_t(struct sk_buff
*skb
,
1978 struct team
*team
, u32 portid
);
1980 static int team_nl_send_unicast(struct sk_buff
*skb
, struct team
*team
, u32 portid
)
1982 return genlmsg_unicast(dev_net(team
->dev
), skb
, portid
);
1985 static int team_nl_fill_one_option_get(struct sk_buff
*skb
, struct team
*team
,
1986 struct team_option_inst
*opt_inst
)
1988 struct nlattr
*option_item
;
1989 struct team_option
*option
= opt_inst
->option
;
1990 struct team_option_inst_info
*opt_inst_info
= &opt_inst
->info
;
1991 struct team_gsetter_ctx ctx
;
1994 ctx
.info
= opt_inst_info
;
1995 err
= team_option_get(team
, opt_inst
, &ctx
);
1999 option_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_OPTION
);
2003 if (nla_put_string(skb
, TEAM_ATTR_OPTION_NAME
, option
->name
))
2005 if (opt_inst_info
->port
&&
2006 nla_put_u32(skb
, TEAM_ATTR_OPTION_PORT_IFINDEX
,
2007 opt_inst_info
->port
->dev
->ifindex
))
2009 if (opt_inst
->option
->array_size
&&
2010 nla_put_u32(skb
, TEAM_ATTR_OPTION_ARRAY_INDEX
,
2011 opt_inst_info
->array_index
))
2014 switch (option
->type
) {
2015 case TEAM_OPTION_TYPE_U32
:
2016 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_U32
))
2018 if (nla_put_u32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.u32_val
))
2021 case TEAM_OPTION_TYPE_STRING
:
2022 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_STRING
))
2024 if (nla_put_string(skb
, TEAM_ATTR_OPTION_DATA
,
2028 case TEAM_OPTION_TYPE_BINARY
:
2029 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_BINARY
))
2031 if (nla_put(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.bin_val
.len
,
2032 ctx
.data
.bin_val
.ptr
))
2035 case TEAM_OPTION_TYPE_BOOL
:
2036 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_FLAG
))
2038 if (ctx
.data
.bool_val
&&
2039 nla_put_flag(skb
, TEAM_ATTR_OPTION_DATA
))
2042 case TEAM_OPTION_TYPE_S32
:
2043 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_S32
))
2045 if (nla_put_s32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.s32_val
))
2051 if (opt_inst
->removed
&& nla_put_flag(skb
, TEAM_ATTR_OPTION_REMOVED
))
2053 if (opt_inst
->changed
) {
2054 if (nla_put_flag(skb
, TEAM_ATTR_OPTION_CHANGED
))
2056 opt_inst
->changed
= false;
2058 nla_nest_end(skb
, option_item
);
2062 nla_nest_cancel(skb
, option_item
);
2066 static int __send_and_alloc_skb(struct sk_buff
**pskb
,
2067 struct team
*team
, u32 portid
,
2068 team_nl_send_func_t
*send_func
)
2073 err
= send_func(*pskb
, team
, portid
);
2077 *pskb
= genlmsg_new(GENLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2083 static int team_nl_send_options_get(struct team
*team
, u32 portid
, u32 seq
,
2084 int flags
, team_nl_send_func_t
*send_func
,
2085 struct list_head
*sel_opt_inst_list
)
2087 struct nlattr
*option_list
;
2088 struct nlmsghdr
*nlh
;
2090 struct team_option_inst
*opt_inst
;
2092 struct sk_buff
*skb
= NULL
;
2096 opt_inst
= list_first_entry(sel_opt_inst_list
,
2097 struct team_option_inst
, tmp_list
);
2100 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2104 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2105 TEAM_CMD_OPTIONS_GET
);
2109 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2110 goto nla_put_failure
;
2111 option_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_OPTION
);
2113 goto nla_put_failure
;
2117 list_for_each_entry_from(opt_inst
, sel_opt_inst_list
, tmp_list
) {
2118 err
= team_nl_fill_one_option_get(skb
, team
, opt_inst
);
2120 if (err
== -EMSGSIZE
) {
2131 nla_nest_end(skb
, option_list
);
2132 genlmsg_end(skb
, hdr
);
2137 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2139 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2145 return send_func(skb
, team
, portid
);
2150 genlmsg_cancel(skb
, hdr
);
2155 static int team_nl_cmd_options_get(struct sk_buff
*skb
, struct genl_info
*info
)
2158 struct team_option_inst
*opt_inst
;
2160 LIST_HEAD(sel_opt_inst_list
);
2162 team
= team_nl_team_get(info
);
2166 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
)
2167 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2168 err
= team_nl_send_options_get(team
, info
->snd_portid
, info
->snd_seq
,
2169 NLM_F_ACK
, team_nl_send_unicast
,
2170 &sel_opt_inst_list
);
2172 team_nl_team_put(team
);
2177 static int team_nl_send_event_options_get(struct team
*team
,
2178 struct list_head
*sel_opt_inst_list
);
2180 static int team_nl_cmd_options_set(struct sk_buff
*skb
, struct genl_info
*info
)
2185 struct nlattr
*nl_option
;
2186 LIST_HEAD(opt_inst_list
);
2188 team
= team_nl_team_get(info
);
2193 if (!info
->attrs
[TEAM_ATTR_LIST_OPTION
]) {
2198 nla_for_each_nested(nl_option
, info
->attrs
[TEAM_ATTR_LIST_OPTION
], i
) {
2199 struct nlattr
*opt_attrs
[TEAM_ATTR_OPTION_MAX
+ 1];
2200 struct nlattr
*attr
;
2201 struct nlattr
*attr_data
;
2202 enum team_option_type opt_type
;
2203 int opt_port_ifindex
= 0; /* != 0 for per-port options */
2204 u32 opt_array_index
= 0;
2205 bool opt_is_array
= false;
2206 struct team_option_inst
*opt_inst
;
2208 bool opt_found
= false;
2210 if (nla_type(nl_option
) != TEAM_ATTR_ITEM_OPTION
) {
2214 err
= nla_parse_nested(opt_attrs
, TEAM_ATTR_OPTION_MAX
,
2215 nl_option
, team_nl_option_policy
);
2218 if (!opt_attrs
[TEAM_ATTR_OPTION_NAME
] ||
2219 !opt_attrs
[TEAM_ATTR_OPTION_TYPE
]) {
2223 switch (nla_get_u8(opt_attrs
[TEAM_ATTR_OPTION_TYPE
])) {
2225 opt_type
= TEAM_OPTION_TYPE_U32
;
2228 opt_type
= TEAM_OPTION_TYPE_STRING
;
2231 opt_type
= TEAM_OPTION_TYPE_BINARY
;
2234 opt_type
= TEAM_OPTION_TYPE_BOOL
;
2237 opt_type
= TEAM_OPTION_TYPE_S32
;
2243 attr_data
= opt_attrs
[TEAM_ATTR_OPTION_DATA
];
2244 if (opt_type
!= TEAM_OPTION_TYPE_BOOL
&& !attr_data
) {
2249 opt_name
= nla_data(opt_attrs
[TEAM_ATTR_OPTION_NAME
]);
2250 attr
= opt_attrs
[TEAM_ATTR_OPTION_PORT_IFINDEX
];
2252 opt_port_ifindex
= nla_get_u32(attr
);
2254 attr
= opt_attrs
[TEAM_ATTR_OPTION_ARRAY_INDEX
];
2256 opt_is_array
= true;
2257 opt_array_index
= nla_get_u32(attr
);
2260 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2261 struct team_option
*option
= opt_inst
->option
;
2262 struct team_gsetter_ctx ctx
;
2263 struct team_option_inst_info
*opt_inst_info
;
2266 opt_inst_info
= &opt_inst
->info
;
2267 tmp_ifindex
= opt_inst_info
->port
?
2268 opt_inst_info
->port
->dev
->ifindex
: 0;
2269 if (option
->type
!= opt_type
||
2270 strcmp(option
->name
, opt_name
) ||
2271 tmp_ifindex
!= opt_port_ifindex
||
2272 (option
->array_size
&& !opt_is_array
) ||
2273 opt_inst_info
->array_index
!= opt_array_index
)
2276 ctx
.info
= opt_inst_info
;
2278 case TEAM_OPTION_TYPE_U32
:
2279 ctx
.data
.u32_val
= nla_get_u32(attr_data
);
2281 case TEAM_OPTION_TYPE_STRING
:
2282 if (nla_len(attr_data
) > TEAM_STRING_MAX_LEN
) {
2286 ctx
.data
.str_val
= nla_data(attr_data
);
2288 case TEAM_OPTION_TYPE_BINARY
:
2289 ctx
.data
.bin_val
.len
= nla_len(attr_data
);
2290 ctx
.data
.bin_val
.ptr
= nla_data(attr_data
);
2292 case TEAM_OPTION_TYPE_BOOL
:
2293 ctx
.data
.bool_val
= attr_data
? true : false;
2295 case TEAM_OPTION_TYPE_S32
:
2296 ctx
.data
.s32_val
= nla_get_s32(attr_data
);
2301 err
= team_option_set(team
, opt_inst
, &ctx
);
2304 opt_inst
->changed
= true;
2305 list_add(&opt_inst
->tmp_list
, &opt_inst_list
);
2313 err
= team_nl_send_event_options_get(team
, &opt_inst_list
);
2316 team_nl_team_put(team
);
2321 static int team_nl_fill_one_port_get(struct sk_buff
*skb
,
2322 struct team_port
*port
)
2324 struct nlattr
*port_item
;
2326 port_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_PORT
);
2329 if (nla_put_u32(skb
, TEAM_ATTR_PORT_IFINDEX
, port
->dev
->ifindex
))
2331 if (port
->changed
) {
2332 if (nla_put_flag(skb
, TEAM_ATTR_PORT_CHANGED
))
2334 port
->changed
= false;
2336 if ((port
->removed
&&
2337 nla_put_flag(skb
, TEAM_ATTR_PORT_REMOVED
)) ||
2338 (port
->state
.linkup
&&
2339 nla_put_flag(skb
, TEAM_ATTR_PORT_LINKUP
)) ||
2340 nla_put_u32(skb
, TEAM_ATTR_PORT_SPEED
, port
->state
.speed
) ||
2341 nla_put_u8(skb
, TEAM_ATTR_PORT_DUPLEX
, port
->state
.duplex
))
2343 nla_nest_end(skb
, port_item
);
2347 nla_nest_cancel(skb
, port_item
);
2351 static int team_nl_send_port_list_get(struct team
*team
, u32 portid
, u32 seq
,
2352 int flags
, team_nl_send_func_t
*send_func
,
2353 struct team_port
*one_port
)
2355 struct nlattr
*port_list
;
2356 struct nlmsghdr
*nlh
;
2358 struct team_port
*port
;
2360 struct sk_buff
*skb
= NULL
;
2364 port
= list_first_entry(&team
->port_list
, struct team_port
, list
);
2367 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2371 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2372 TEAM_CMD_PORT_LIST_GET
);
2376 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2377 goto nla_put_failure
;
2378 port_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_PORT
);
2380 goto nla_put_failure
;
2385 /* If one port is selected, called wants to send port list containing
2386 * only this port. Otherwise go through all listed ports and send all
2389 err
= team_nl_fill_one_port_get(skb
, one_port
);
2393 list_for_each_entry(port
, &team
->port_list
, list
) {
2394 err
= team_nl_fill_one_port_get(skb
, port
);
2396 if (err
== -EMSGSIZE
) {
2408 nla_nest_end(skb
, port_list
);
2409 genlmsg_end(skb
, hdr
);
2414 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2416 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2422 return send_func(skb
, team
, portid
);
2427 genlmsg_cancel(skb
, hdr
);
2432 static int team_nl_cmd_port_list_get(struct sk_buff
*skb
,
2433 struct genl_info
*info
)
2438 team
= team_nl_team_get(info
);
2442 err
= team_nl_send_port_list_get(team
, info
->snd_portid
, info
->snd_seq
,
2443 NLM_F_ACK
, team_nl_send_unicast
, NULL
);
2445 team_nl_team_put(team
);
2450 static struct genl_ops team_nl_ops
[] = {
2452 .cmd
= TEAM_CMD_NOOP
,
2453 .doit
= team_nl_cmd_noop
,
2454 .policy
= team_nl_policy
,
2457 .cmd
= TEAM_CMD_OPTIONS_SET
,
2458 .doit
= team_nl_cmd_options_set
,
2459 .policy
= team_nl_policy
,
2460 .flags
= GENL_ADMIN_PERM
,
2463 .cmd
= TEAM_CMD_OPTIONS_GET
,
2464 .doit
= team_nl_cmd_options_get
,
2465 .policy
= team_nl_policy
,
2466 .flags
= GENL_ADMIN_PERM
,
2469 .cmd
= TEAM_CMD_PORT_LIST_GET
,
2470 .doit
= team_nl_cmd_port_list_get
,
2471 .policy
= team_nl_policy
,
2472 .flags
= GENL_ADMIN_PERM
,
2476 static struct genl_multicast_group team_change_event_mcgrp
= {
2477 .name
= TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME
,
2480 static int team_nl_send_multicast(struct sk_buff
*skb
,
2481 struct team
*team
, u32 portid
)
2483 return genlmsg_multicast_netns(dev_net(team
->dev
), skb
, 0,
2484 team_change_event_mcgrp
.id
, GFP_KERNEL
);
2487 static int team_nl_send_event_options_get(struct team
*team
,
2488 struct list_head
*sel_opt_inst_list
)
2490 return team_nl_send_options_get(team
, 0, 0, 0, team_nl_send_multicast
,
2494 static int team_nl_send_event_port_get(struct team
*team
,
2495 struct team_port
*port
)
2497 return team_nl_send_port_list_get(team
, 0, 0, 0, team_nl_send_multicast
,
2501 static int team_nl_init(void)
2505 err
= genl_register_family_with_ops(&team_nl_family
, team_nl_ops
,
2506 ARRAY_SIZE(team_nl_ops
));
2510 err
= genl_register_mc_group(&team_nl_family
, &team_change_event_mcgrp
);
2512 goto err_change_event_grp_reg
;
2516 err_change_event_grp_reg
:
2517 genl_unregister_family(&team_nl_family
);
2522 static void team_nl_fini(void)
2524 genl_unregister_family(&team_nl_family
);
2532 static void __team_options_change_check(struct team
*team
)
2535 struct team_option_inst
*opt_inst
;
2536 LIST_HEAD(sel_opt_inst_list
);
2538 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2539 if (opt_inst
->changed
)
2540 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2542 err
= team_nl_send_event_options_get(team
, &sel_opt_inst_list
);
2543 if (err
&& err
!= -ESRCH
)
2544 netdev_warn(team
->dev
, "Failed to send options change via netlink (err %d)\n",
2548 /* rtnl lock is held */
2550 static void __team_port_change_send(struct team_port
*port
, bool linkup
)
2554 port
->changed
= true;
2555 port
->state
.linkup
= linkup
;
2556 team_refresh_port_linkup(port
);
2558 struct ethtool_cmd ecmd
;
2560 err
= __ethtool_get_settings(port
->dev
, &ecmd
);
2562 port
->state
.speed
= ethtool_cmd_speed(&ecmd
);
2563 port
->state
.duplex
= ecmd
.duplex
;
2567 port
->state
.speed
= 0;
2568 port
->state
.duplex
= 0;
2571 err
= team_nl_send_event_port_get(port
->team
, port
);
2572 if (err
&& err
!= -ESRCH
)
2573 netdev_warn(port
->team
->dev
, "Failed to send port change of device %s via netlink (err %d)\n",
2574 port
->dev
->name
, err
);
2578 static void __team_carrier_check(struct team
*team
)
2580 struct team_port
*port
;
2583 if (team
->user_carrier_enabled
)
2586 team_linkup
= false;
2587 list_for_each_entry(port
, &team
->port_list
, list
) {
2595 netif_carrier_on(team
->dev
);
2597 netif_carrier_off(team
->dev
);
2600 static void __team_port_change_check(struct team_port
*port
, bool linkup
)
2602 if (port
->state
.linkup
!= linkup
)
2603 __team_port_change_send(port
, linkup
);
2604 __team_carrier_check(port
->team
);
2607 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
)
2609 __team_port_change_send(port
, linkup
);
2610 __team_carrier_check(port
->team
);
2613 static void __team_port_change_port_removed(struct team_port
*port
)
2615 port
->removed
= true;
2616 __team_port_change_send(port
, false);
2617 __team_carrier_check(port
->team
);
2620 static void team_port_change_check(struct team_port
*port
, bool linkup
)
2622 struct team
*team
= port
->team
;
2624 mutex_lock(&team
->lock
);
2625 __team_port_change_check(port
, linkup
);
2626 mutex_unlock(&team
->lock
);
2630 /************************************
2631 * Net device notifier event handler
2632 ************************************/
2634 static int team_device_event(struct notifier_block
*unused
,
2635 unsigned long event
, void *ptr
)
2637 struct net_device
*dev
= (struct net_device
*) ptr
;
2638 struct team_port
*port
;
2640 port
= team_port_get_rtnl(dev
);
2646 if (netif_carrier_ok(dev
))
2647 team_port_change_check(port
, true);
2649 team_port_change_check(port
, false);
2651 if (netif_running(port
->dev
))
2652 team_port_change_check(port
,
2653 !!netif_carrier_ok(port
->dev
));
2655 case NETDEV_UNREGISTER
:
2656 team_del_slave(port
->team
->dev
, dev
);
2658 case NETDEV_FEAT_CHANGE
:
2659 team_compute_features(port
->team
);
2661 case NETDEV_CHANGEMTU
:
2662 /* Forbid to change mtu of underlaying device */
2664 case NETDEV_PRE_TYPE_CHANGE
:
2665 /* Forbid to change type of underlaying device */
2671 static struct notifier_block team_notifier_block __read_mostly
= {
2672 .notifier_call
= team_device_event
,
2676 /***********************
2677 * Module init and exit
2678 ***********************/
2680 static int __init
team_module_init(void)
2684 register_netdevice_notifier(&team_notifier_block
);
2686 err
= rtnl_link_register(&team_link_ops
);
2690 err
= team_nl_init();
2697 rtnl_link_unregister(&team_link_ops
);
2700 unregister_netdevice_notifier(&team_notifier_block
);
2705 static void __exit
team_module_exit(void)
2708 rtnl_link_unregister(&team_link_ops
);
2709 unregister_netdevice_notifier(&team_notifier_block
);
2712 module_init(team_module_init
);
2713 module_exit(team_module_exit
);
2715 MODULE_LICENSE("GPL v2");
2716 MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
2717 MODULE_DESCRIPTION("Ethernet team device driver");
2718 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);