2 * net/drivers/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/if_vlan.h>
22 #include <linux/if_arp.h>
23 #include <linux/socket.h>
24 #include <linux/etherdevice.h>
25 #include <linux/rtnetlink.h>
26 #include <net/rtnetlink.h>
27 #include <net/genetlink.h>
28 #include <net/netlink.h>
29 #include <linux/if_team.h>
31 #define DRV_NAME "team"
38 #define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT)
40 static struct team_port
*team_port_get_rcu(const struct net_device
*dev
)
42 struct team_port
*port
= rcu_dereference(dev
->rx_handler_data
);
44 return team_port_exists(dev
) ? port
: NULL
;
47 static struct team_port
*team_port_get_rtnl(const struct net_device
*dev
)
49 struct team_port
*port
= rtnl_dereference(dev
->rx_handler_data
);
51 return team_port_exists(dev
) ? port
: NULL
;
55 * Since the ability to change mac address for open port device is tested in
56 * team_port_add, this function can be called without control of return value
58 static int __set_port_mac(struct net_device
*port_dev
,
59 const unsigned char *dev_addr
)
63 memcpy(addr
.sa_data
, dev_addr
, ETH_ALEN
);
64 addr
.sa_family
= ARPHRD_ETHER
;
65 return dev_set_mac_address(port_dev
, &addr
);
68 static int team_port_set_orig_mac(struct team_port
*port
)
70 return __set_port_mac(port
->dev
, port
->orig
.dev_addr
);
73 int team_port_set_team_mac(struct team_port
*port
)
75 return __set_port_mac(port
->dev
, port
->team
->dev
->dev_addr
);
77 EXPORT_SYMBOL(team_port_set_team_mac
);
79 static void team_refresh_port_linkup(struct team_port
*port
)
81 port
->linkup
= port
->user
.linkup_enabled
? port
->user
.linkup
:
89 struct team_option_inst
{ /* One for each option instance */
90 struct list_head list
;
91 struct team_option
*option
;
92 struct team_port
*port
; /* != NULL if per-port */
97 static struct team_option
*__team_find_option(struct team
*team
,
100 struct team_option
*option
;
102 list_for_each_entry(option
, &team
->option_list
, list
) {
103 if (strcmp(option
->name
, opt_name
) == 0)
109 static int __team_option_inst_add(struct team
*team
, struct team_option
*option
,
110 struct team_port
*port
)
112 struct team_option_inst
*opt_inst
;
114 opt_inst
= kmalloc(sizeof(*opt_inst
), GFP_KERNEL
);
117 opt_inst
->option
= option
;
118 opt_inst
->port
= port
;
119 opt_inst
->changed
= true;
120 opt_inst
->removed
= false;
121 list_add_tail(&opt_inst
->list
, &team
->option_inst_list
);
125 static void __team_option_inst_del(struct team_option_inst
*opt_inst
)
127 list_del(&opt_inst
->list
);
131 static void __team_option_inst_del_option(struct team
*team
,
132 struct team_option
*option
)
134 struct team_option_inst
*opt_inst
, *tmp
;
136 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
137 if (opt_inst
->option
== option
)
138 __team_option_inst_del(opt_inst
);
142 static int __team_option_inst_add_option(struct team
*team
,
143 struct team_option
*option
)
145 struct team_port
*port
;
148 if (!option
->per_port
)
149 return __team_option_inst_add(team
, option
, 0);
151 list_for_each_entry(port
, &team
->port_list
, list
) {
152 err
= __team_option_inst_add(team
, option
, port
);
154 goto inst_del_option
;
159 __team_option_inst_del_option(team
, option
);
163 static void __team_option_inst_mark_removed_option(struct team
*team
,
164 struct team_option
*option
)
166 struct team_option_inst
*opt_inst
;
168 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
169 if (opt_inst
->option
== option
) {
170 opt_inst
->changed
= true;
171 opt_inst
->removed
= true;
176 static void __team_option_inst_del_port(struct team
*team
,
177 struct team_port
*port
)
179 struct team_option_inst
*opt_inst
, *tmp
;
181 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
182 if (opt_inst
->option
->per_port
&&
183 opt_inst
->port
== port
)
184 __team_option_inst_del(opt_inst
);
188 static int __team_option_inst_add_port(struct team
*team
,
189 struct team_port
*port
)
191 struct team_option
*option
;
194 list_for_each_entry(option
, &team
->option_list
, list
) {
195 if (!option
->per_port
)
197 err
= __team_option_inst_add(team
, option
, port
);
204 __team_option_inst_del_port(team
, port
);
208 static void __team_option_inst_mark_removed_port(struct team
*team
,
209 struct team_port
*port
)
211 struct team_option_inst
*opt_inst
;
213 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
214 if (opt_inst
->port
== port
) {
215 opt_inst
->changed
= true;
216 opt_inst
->removed
= true;
221 static int __team_options_register(struct team
*team
,
222 const struct team_option
*option
,
226 struct team_option
**dst_opts
;
229 dst_opts
= kzalloc(sizeof(struct team_option
*) * option_count
,
233 for (i
= 0; i
< option_count
; i
++, option
++) {
234 if (__team_find_option(team
, option
->name
)) {
238 dst_opts
[i
] = kmemdup(option
, sizeof(*option
), GFP_KERNEL
);
245 for (i
= 0; i
< option_count
; i
++) {
246 err
= __team_option_inst_add_option(team
, dst_opts
[i
]);
249 list_add_tail(&dst_opts
[i
]->list
, &team
->option_list
);
256 for (i
--; i
>= 0; i
--)
257 __team_option_inst_del_option(team
, dst_opts
[i
]);
259 i
= option_count
- 1;
261 for (i
--; i
>= 0; i
--)
268 static void __team_options_mark_removed(struct team
*team
,
269 const struct team_option
*option
,
274 for (i
= 0; i
< option_count
; i
++, option
++) {
275 struct team_option
*del_opt
;
277 del_opt
= __team_find_option(team
, option
->name
);
279 __team_option_inst_mark_removed_option(team
, del_opt
);
283 static void __team_options_unregister(struct team
*team
,
284 const struct team_option
*option
,
289 for (i
= 0; i
< option_count
; i
++, option
++) {
290 struct team_option
*del_opt
;
292 del_opt
= __team_find_option(team
, option
->name
);
294 __team_option_inst_del_option(team
, del_opt
);
295 list_del(&del_opt
->list
);
301 static void __team_options_change_check(struct team
*team
);
303 int team_options_register(struct team
*team
,
304 const struct team_option
*option
,
309 err
= __team_options_register(team
, option
, option_count
);
312 __team_options_change_check(team
);
315 EXPORT_SYMBOL(team_options_register
);
317 void team_options_unregister(struct team
*team
,
318 const struct team_option
*option
,
321 __team_options_mark_removed(team
, option
, option_count
);
322 __team_options_change_check(team
);
323 __team_options_unregister(team
, option
, option_count
);
325 EXPORT_SYMBOL(team_options_unregister
);
327 static int team_option_port_add(struct team
*team
, struct team_port
*port
)
331 err
= __team_option_inst_add_port(team
, port
);
334 __team_options_change_check(team
);
338 static void team_option_port_del(struct team
*team
, struct team_port
*port
)
340 __team_option_inst_mark_removed_port(team
, port
);
341 __team_options_change_check(team
);
342 __team_option_inst_del_port(team
, port
);
345 static int team_option_get(struct team
*team
,
346 struct team_option_inst
*opt_inst
,
347 struct team_gsetter_ctx
*ctx
)
349 return opt_inst
->option
->getter(team
, ctx
);
352 static int team_option_set(struct team
*team
,
353 struct team_option_inst
*opt_inst
,
354 struct team_gsetter_ctx
*ctx
)
358 err
= opt_inst
->option
->setter(team
, ctx
);
362 opt_inst
->changed
= true;
363 __team_options_change_check(team
);
371 static LIST_HEAD(mode_list
);
372 static DEFINE_SPINLOCK(mode_list_lock
);
374 static struct team_mode
*__find_mode(const char *kind
)
376 struct team_mode
*mode
;
378 list_for_each_entry(mode
, &mode_list
, list
) {
379 if (strcmp(mode
->kind
, kind
) == 0)
385 static bool is_good_mode_name(const char *name
)
387 while (*name
!= '\0') {
388 if (!isalpha(*name
) && !isdigit(*name
) && *name
!= '_')
395 int team_mode_register(struct team_mode
*mode
)
399 if (!is_good_mode_name(mode
->kind
) ||
400 mode
->priv_size
> TEAM_MODE_PRIV_SIZE
)
402 spin_lock(&mode_list_lock
);
403 if (__find_mode(mode
->kind
)) {
407 list_add_tail(&mode
->list
, &mode_list
);
409 spin_unlock(&mode_list_lock
);
412 EXPORT_SYMBOL(team_mode_register
);
414 int team_mode_unregister(struct team_mode
*mode
)
416 spin_lock(&mode_list_lock
);
417 list_del_init(&mode
->list
);
418 spin_unlock(&mode_list_lock
);
421 EXPORT_SYMBOL(team_mode_unregister
);
423 static struct team_mode
*team_mode_get(const char *kind
)
425 struct team_mode
*mode
;
427 spin_lock(&mode_list_lock
);
428 mode
= __find_mode(kind
);
430 spin_unlock(&mode_list_lock
);
431 request_module("team-mode-%s", kind
);
432 spin_lock(&mode_list_lock
);
433 mode
= __find_mode(kind
);
436 if (!try_module_get(mode
->owner
))
439 spin_unlock(&mode_list_lock
);
443 static void team_mode_put(const struct team_mode
*mode
)
445 module_put(mode
->owner
);
448 static bool team_dummy_transmit(struct team
*team
, struct sk_buff
*skb
)
450 dev_kfree_skb_any(skb
);
454 rx_handler_result_t
team_dummy_receive(struct team
*team
,
455 struct team_port
*port
,
458 return RX_HANDLER_ANOTHER
;
461 static void team_adjust_ops(struct team
*team
)
464 * To avoid checks in rx/tx skb paths, ensure here that non-null and
465 * correct ops are always set.
468 if (list_empty(&team
->port_list
) ||
469 !team
->mode
|| !team
->mode
->ops
->transmit
)
470 team
->ops
.transmit
= team_dummy_transmit
;
472 team
->ops
.transmit
= team
->mode
->ops
->transmit
;
474 if (list_empty(&team
->port_list
) ||
475 !team
->mode
|| !team
->mode
->ops
->receive
)
476 team
->ops
.receive
= team_dummy_receive
;
478 team
->ops
.receive
= team
->mode
->ops
->receive
;
482 * We can benefit from the fact that it's ensured no port is present
483 * at the time of mode change. Therefore no packets are in fly so there's no
484 * need to set mode operations in any special way.
486 static int __team_change_mode(struct team
*team
,
487 const struct team_mode
*new_mode
)
489 /* Check if mode was previously set and do cleanup if so */
491 void (*exit_op
)(struct team
*team
) = team
->ops
.exit
;
493 /* Clear ops area so no callback is called any longer */
494 memset(&team
->ops
, 0, sizeof(struct team_mode_ops
));
495 team_adjust_ops(team
);
499 team_mode_put(team
->mode
);
501 /* zero private data area */
502 memset(&team
->mode_priv
, 0,
503 sizeof(struct team
) - offsetof(struct team
, mode_priv
));
509 if (new_mode
->ops
->init
) {
512 err
= new_mode
->ops
->init(team
);
517 team
->mode
= new_mode
;
518 memcpy(&team
->ops
, new_mode
->ops
, sizeof(struct team_mode_ops
));
519 team_adjust_ops(team
);
524 static int team_change_mode(struct team
*team
, const char *kind
)
526 struct team_mode
*new_mode
;
527 struct net_device
*dev
= team
->dev
;
530 if (!list_empty(&team
->port_list
)) {
531 netdev_err(dev
, "No ports can be present during mode change\n");
535 if (team
->mode
&& strcmp(team
->mode
->kind
, kind
) == 0) {
536 netdev_err(dev
, "Unable to change to the same mode the team is in\n");
540 new_mode
= team_mode_get(kind
);
542 netdev_err(dev
, "Mode \"%s\" not found\n", kind
);
546 err
= __team_change_mode(team
, new_mode
);
548 netdev_err(dev
, "Failed to change to mode \"%s\"\n", kind
);
549 team_mode_put(new_mode
);
553 netdev_info(dev
, "Mode changed to \"%s\"\n", kind
);
558 /************************
559 * Rx path frame handler
560 ************************/
562 static bool team_port_enabled(struct team_port
*port
);
564 /* note: already called with rcu_read_lock */
565 static rx_handler_result_t
team_handle_frame(struct sk_buff
**pskb
)
567 struct sk_buff
*skb
= *pskb
;
568 struct team_port
*port
;
570 rx_handler_result_t res
;
572 skb
= skb_share_check(skb
, GFP_ATOMIC
);
574 return RX_HANDLER_CONSUMED
;
578 port
= team_port_get_rcu(skb
->dev
);
580 if (!team_port_enabled(port
)) {
581 /* allow exact match delivery for disabled ports */
582 res
= RX_HANDLER_EXACT
;
584 res
= team
->ops
.receive(team
, port
, skb
);
586 if (res
== RX_HANDLER_ANOTHER
) {
587 struct team_pcpu_stats
*pcpu_stats
;
589 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
590 u64_stats_update_begin(&pcpu_stats
->syncp
);
591 pcpu_stats
->rx_packets
++;
592 pcpu_stats
->rx_bytes
+= skb
->len
;
593 if (skb
->pkt_type
== PACKET_MULTICAST
)
594 pcpu_stats
->rx_multicast
++;
595 u64_stats_update_end(&pcpu_stats
->syncp
);
597 skb
->dev
= team
->dev
;
599 this_cpu_inc(team
->pcpu_stats
->rx_dropped
);
610 static bool team_port_find(const struct team
*team
,
611 const struct team_port
*port
)
613 struct team_port
*cur
;
615 list_for_each_entry(cur
, &team
->port_list
, list
)
621 static bool team_port_enabled(struct team_port
*port
)
623 return port
->index
!= -1;
627 * Enable/disable port by adding to enabled port hashlist and setting
628 * port->index (Might be racy so reader could see incorrect ifindex when
629 * processing a flying packet, but that is not a problem). Write guarded
632 static void team_port_enable(struct team
*team
,
633 struct team_port
*port
)
635 if (team_port_enabled(port
))
637 port
->index
= team
->en_port_count
++;
638 hlist_add_head_rcu(&port
->hlist
,
639 team_port_index_hash(team
, port
->index
));
642 static void __reconstruct_port_hlist(struct team
*team
, int rm_index
)
645 struct team_port
*port
;
647 for (i
= rm_index
+ 1; i
< team
->en_port_count
; i
++) {
648 port
= team_get_port_by_index(team
, i
);
649 hlist_del_rcu(&port
->hlist
);
651 hlist_add_head_rcu(&port
->hlist
,
652 team_port_index_hash(team
, port
->index
));
656 static void team_port_disable(struct team
*team
,
657 struct team_port
*port
)
659 int rm_index
= port
->index
;
661 if (!team_port_enabled(port
))
663 hlist_del_rcu(&port
->hlist
);
664 __reconstruct_port_hlist(team
, rm_index
);
665 team
->en_port_count
--;
669 #define TEAM_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
670 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
671 NETIF_F_HIGHDMA | NETIF_F_LRO)
673 static void __team_compute_features(struct team
*team
)
675 struct team_port
*port
;
676 u32 vlan_features
= TEAM_VLAN_FEATURES
;
677 unsigned short max_hard_header_len
= ETH_HLEN
;
679 list_for_each_entry(port
, &team
->port_list
, list
) {
680 vlan_features
= netdev_increment_features(vlan_features
,
681 port
->dev
->vlan_features
,
684 if (port
->dev
->hard_header_len
> max_hard_header_len
)
685 max_hard_header_len
= port
->dev
->hard_header_len
;
688 team
->dev
->vlan_features
= vlan_features
;
689 team
->dev
->hard_header_len
= max_hard_header_len
;
691 netdev_change_features(team
->dev
);
694 static void team_compute_features(struct team
*team
)
696 mutex_lock(&team
->lock
);
697 __team_compute_features(team
);
698 mutex_unlock(&team
->lock
);
701 static int team_port_enter(struct team
*team
, struct team_port
*port
)
706 port
->dev
->priv_flags
|= IFF_TEAM_PORT
;
707 if (team
->ops
.port_enter
) {
708 err
= team
->ops
.port_enter(team
, port
);
710 netdev_err(team
->dev
, "Device %s failed to enter team mode\n",
719 port
->dev
->priv_flags
&= ~IFF_TEAM_PORT
;
725 static void team_port_leave(struct team
*team
, struct team_port
*port
)
727 if (team
->ops
.port_leave
)
728 team
->ops
.port_leave(team
, port
);
729 port
->dev
->priv_flags
&= ~IFF_TEAM_PORT
;
733 static void __team_port_change_check(struct team_port
*port
, bool linkup
);
735 static int team_port_add(struct team
*team
, struct net_device
*port_dev
)
737 struct net_device
*dev
= team
->dev
;
738 struct team_port
*port
;
739 char *portname
= port_dev
->name
;
742 if (port_dev
->flags
& IFF_LOOPBACK
||
743 port_dev
->type
!= ARPHRD_ETHER
) {
744 netdev_err(dev
, "Device %s is of an unsupported type\n",
749 if (team_port_exists(port_dev
)) {
750 netdev_err(dev
, "Device %s is already a port "
751 "of a team device\n", portname
);
755 if (port_dev
->flags
& IFF_UP
) {
756 netdev_err(dev
, "Device %s is up. Set it down before adding it as a team port\n",
761 port
= kzalloc(sizeof(struct team_port
), GFP_KERNEL
);
765 port
->dev
= port_dev
;
768 port
->orig
.mtu
= port_dev
->mtu
;
769 err
= dev_set_mtu(port_dev
, dev
->mtu
);
771 netdev_dbg(dev
, "Error %d calling dev_set_mtu\n", err
);
775 memcpy(port
->orig
.dev_addr
, port_dev
->dev_addr
, ETH_ALEN
);
777 err
= team_port_enter(team
, port
);
779 netdev_err(dev
, "Device %s failed to enter team mode\n",
784 err
= dev_open(port_dev
);
786 netdev_dbg(dev
, "Device %s opening failed\n",
791 err
= vlan_vids_add_by_dev(port_dev
, dev
);
793 netdev_err(dev
, "Failed to add vlan ids to device %s\n",
798 err
= netdev_set_master(port_dev
, dev
);
800 netdev_err(dev
, "Device %s failed to set master\n", portname
);
804 err
= netdev_rx_handler_register(port_dev
, team_handle_frame
,
807 netdev_err(dev
, "Device %s failed to register rx_handler\n",
809 goto err_handler_register
;
812 err
= team_option_port_add(team
, port
);
814 netdev_err(dev
, "Device %s failed to add per-port options\n",
816 goto err_option_port_add
;
820 team_port_enable(team
, port
);
821 list_add_tail_rcu(&port
->list
, &team
->port_list
);
822 team_adjust_ops(team
);
823 __team_compute_features(team
);
824 __team_port_change_check(port
, !!netif_carrier_ok(port_dev
));
826 netdev_info(dev
, "Port device %s added\n", portname
);
831 netdev_rx_handler_unregister(port_dev
);
833 err_handler_register
:
834 netdev_set_master(port_dev
, NULL
);
837 vlan_vids_del_by_dev(port_dev
, dev
);
843 team_port_leave(team
, port
);
844 team_port_set_orig_mac(port
);
847 dev_set_mtu(port_dev
, port
->orig
.mtu
);
855 static int team_port_del(struct team
*team
, struct net_device
*port_dev
)
857 struct net_device
*dev
= team
->dev
;
858 struct team_port
*port
;
859 char *portname
= port_dev
->name
;
861 port
= team_port_get_rtnl(port_dev
);
862 if (!port
|| !team_port_find(team
, port
)) {
863 netdev_err(dev
, "Device %s does not act as a port of this team\n",
868 port
->removed
= true;
869 __team_port_change_check(port
, false);
870 team_port_disable(team
, port
);
871 list_del_rcu(&port
->list
);
872 team_adjust_ops(team
);
873 team_option_port_del(team
, port
);
874 netdev_rx_handler_unregister(port_dev
);
875 netdev_set_master(port_dev
, NULL
);
876 vlan_vids_del_by_dev(port_dev
, dev
);
878 team_port_leave(team
, port
);
879 team_port_set_orig_mac(port
);
880 dev_set_mtu(port_dev
, port
->orig
.mtu
);
883 netdev_info(dev
, "Port device %s removed\n", portname
);
884 __team_compute_features(team
);
894 static const char team_no_mode_kind
[] = "*NOMODE*";
896 static int team_mode_option_get(struct team
*team
, struct team_gsetter_ctx
*ctx
)
898 ctx
->data
.str_val
= team
->mode
? team
->mode
->kind
: team_no_mode_kind
;
902 static int team_mode_option_set(struct team
*team
, struct team_gsetter_ctx
*ctx
)
904 return team_change_mode(team
, ctx
->data
.str_val
);
907 static int team_port_en_option_get(struct team
*team
,
908 struct team_gsetter_ctx
*ctx
)
910 ctx
->data
.bool_val
= team_port_enabled(ctx
->port
);
914 static int team_port_en_option_set(struct team
*team
,
915 struct team_gsetter_ctx
*ctx
)
917 if (ctx
->data
.bool_val
)
918 team_port_enable(team
, ctx
->port
);
920 team_port_disable(team
, ctx
->port
);
924 static int team_user_linkup_option_get(struct team
*team
,
925 struct team_gsetter_ctx
*ctx
)
927 ctx
->data
.bool_val
= ctx
->port
->user
.linkup
;
931 static int team_user_linkup_option_set(struct team
*team
,
932 struct team_gsetter_ctx
*ctx
)
934 ctx
->port
->user
.linkup
= ctx
->data
.bool_val
;
935 team_refresh_port_linkup(ctx
->port
);
939 static int team_user_linkup_en_option_get(struct team
*team
,
940 struct team_gsetter_ctx
*ctx
)
942 struct team_port
*port
= ctx
->port
;
944 ctx
->data
.bool_val
= port
->user
.linkup_enabled
;
948 static int team_user_linkup_en_option_set(struct team
*team
,
949 struct team_gsetter_ctx
*ctx
)
951 struct team_port
*port
= ctx
->port
;
953 port
->user
.linkup_enabled
= ctx
->data
.bool_val
;
954 team_refresh_port_linkup(ctx
->port
);
958 static const struct team_option team_options
[] = {
961 .type
= TEAM_OPTION_TYPE_STRING
,
962 .getter
= team_mode_option_get
,
963 .setter
= team_mode_option_set
,
967 .type
= TEAM_OPTION_TYPE_BOOL
,
969 .getter
= team_port_en_option_get
,
970 .setter
= team_port_en_option_set
,
973 .name
= "user_linkup",
974 .type
= TEAM_OPTION_TYPE_BOOL
,
976 .getter
= team_user_linkup_option_get
,
977 .setter
= team_user_linkup_option_set
,
980 .name
= "user_linkup_enabled",
981 .type
= TEAM_OPTION_TYPE_BOOL
,
983 .getter
= team_user_linkup_en_option_get
,
984 .setter
= team_user_linkup_en_option_set
,
988 static int team_init(struct net_device
*dev
)
990 struct team
*team
= netdev_priv(dev
);
995 mutex_init(&team
->lock
);
997 team
->pcpu_stats
= alloc_percpu(struct team_pcpu_stats
);
998 if (!team
->pcpu_stats
)
1001 for (i
= 0; i
< TEAM_PORT_HASHENTRIES
; i
++)
1002 INIT_HLIST_HEAD(&team
->en_port_hlist
[i
]);
1003 INIT_LIST_HEAD(&team
->port_list
);
1005 team_adjust_ops(team
);
1007 INIT_LIST_HEAD(&team
->option_list
);
1008 INIT_LIST_HEAD(&team
->option_inst_list
);
1009 err
= team_options_register(team
, team_options
, ARRAY_SIZE(team_options
));
1011 goto err_options_register
;
1012 netif_carrier_off(dev
);
1016 err_options_register
:
1017 free_percpu(team
->pcpu_stats
);
1022 static void team_uninit(struct net_device
*dev
)
1024 struct team
*team
= netdev_priv(dev
);
1025 struct team_port
*port
;
1026 struct team_port
*tmp
;
1028 mutex_lock(&team
->lock
);
1029 list_for_each_entry_safe(port
, tmp
, &team
->port_list
, list
)
1030 team_port_del(team
, port
->dev
);
1032 __team_change_mode(team
, NULL
); /* cleanup */
1033 __team_options_unregister(team
, team_options
, ARRAY_SIZE(team_options
));
1034 mutex_unlock(&team
->lock
);
1037 static void team_destructor(struct net_device
*dev
)
1039 struct team
*team
= netdev_priv(dev
);
1041 free_percpu(team
->pcpu_stats
);
1045 static int team_open(struct net_device
*dev
)
1047 netif_carrier_on(dev
);
1051 static int team_close(struct net_device
*dev
)
1053 netif_carrier_off(dev
);
1058 * note: already called with rcu_read_lock
1060 static netdev_tx_t
team_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1062 struct team
*team
= netdev_priv(dev
);
1063 bool tx_success
= false;
1064 unsigned int len
= skb
->len
;
1066 tx_success
= team
->ops
.transmit(team
, skb
);
1068 struct team_pcpu_stats
*pcpu_stats
;
1070 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
1071 u64_stats_update_begin(&pcpu_stats
->syncp
);
1072 pcpu_stats
->tx_packets
++;
1073 pcpu_stats
->tx_bytes
+= len
;
1074 u64_stats_update_end(&pcpu_stats
->syncp
);
1076 this_cpu_inc(team
->pcpu_stats
->tx_dropped
);
1079 return NETDEV_TX_OK
;
1082 static void team_change_rx_flags(struct net_device
*dev
, int change
)
1084 struct team
*team
= netdev_priv(dev
);
1085 struct team_port
*port
;
1089 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1090 if (change
& IFF_PROMISC
) {
1091 inc
= dev
->flags
& IFF_PROMISC
? 1 : -1;
1092 dev_set_promiscuity(port
->dev
, inc
);
1094 if (change
& IFF_ALLMULTI
) {
1095 inc
= dev
->flags
& IFF_ALLMULTI
? 1 : -1;
1096 dev_set_allmulti(port
->dev
, inc
);
1102 static void team_set_rx_mode(struct net_device
*dev
)
1104 struct team
*team
= netdev_priv(dev
);
1105 struct team_port
*port
;
1108 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1109 dev_uc_sync(port
->dev
, dev
);
1110 dev_mc_sync(port
->dev
, dev
);
1115 static int team_set_mac_address(struct net_device
*dev
, void *p
)
1117 struct team
*team
= netdev_priv(dev
);
1118 struct team_port
*port
;
1119 struct sockaddr
*addr
= p
;
1121 dev
->addr_assign_type
&= ~NET_ADDR_RANDOM
;
1122 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
1124 list_for_each_entry_rcu(port
, &team
->port_list
, list
)
1125 if (team
->ops
.port_change_mac
)
1126 team
->ops
.port_change_mac(team
, port
);
1131 static int team_change_mtu(struct net_device
*dev
, int new_mtu
)
1133 struct team
*team
= netdev_priv(dev
);
1134 struct team_port
*port
;
1138 * Alhough this is reader, it's guarded by team lock. It's not possible
1139 * to traverse list in reverse under rcu_read_lock
1141 mutex_lock(&team
->lock
);
1142 list_for_each_entry(port
, &team
->port_list
, list
) {
1143 err
= dev_set_mtu(port
->dev
, new_mtu
);
1145 netdev_err(dev
, "Device %s failed to change mtu",
1150 mutex_unlock(&team
->lock
);
1157 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1158 dev_set_mtu(port
->dev
, dev
->mtu
);
1159 mutex_unlock(&team
->lock
);
1164 static struct rtnl_link_stats64
*
1165 team_get_stats64(struct net_device
*dev
, struct rtnl_link_stats64
*stats
)
1167 struct team
*team
= netdev_priv(dev
);
1168 struct team_pcpu_stats
*p
;
1169 u64 rx_packets
, rx_bytes
, rx_multicast
, tx_packets
, tx_bytes
;
1170 u32 rx_dropped
= 0, tx_dropped
= 0;
1174 for_each_possible_cpu(i
) {
1175 p
= per_cpu_ptr(team
->pcpu_stats
, i
);
1177 start
= u64_stats_fetch_begin_bh(&p
->syncp
);
1178 rx_packets
= p
->rx_packets
;
1179 rx_bytes
= p
->rx_bytes
;
1180 rx_multicast
= p
->rx_multicast
;
1181 tx_packets
= p
->tx_packets
;
1182 tx_bytes
= p
->tx_bytes
;
1183 } while (u64_stats_fetch_retry_bh(&p
->syncp
, start
));
1185 stats
->rx_packets
+= rx_packets
;
1186 stats
->rx_bytes
+= rx_bytes
;
1187 stats
->multicast
+= rx_multicast
;
1188 stats
->tx_packets
+= tx_packets
;
1189 stats
->tx_bytes
+= tx_bytes
;
1191 * rx_dropped & tx_dropped are u32, updated
1192 * without syncp protection.
1194 rx_dropped
+= p
->rx_dropped
;
1195 tx_dropped
+= p
->tx_dropped
;
1197 stats
->rx_dropped
= rx_dropped
;
1198 stats
->tx_dropped
= tx_dropped
;
1202 static int team_vlan_rx_add_vid(struct net_device
*dev
, uint16_t vid
)
1204 struct team
*team
= netdev_priv(dev
);
1205 struct team_port
*port
;
1209 * Alhough this is reader, it's guarded by team lock. It's not possible
1210 * to traverse list in reverse under rcu_read_lock
1212 mutex_lock(&team
->lock
);
1213 list_for_each_entry(port
, &team
->port_list
, list
) {
1214 err
= vlan_vid_add(port
->dev
, vid
);
1218 mutex_unlock(&team
->lock
);
1223 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1224 vlan_vid_del(port
->dev
, vid
);
1225 mutex_unlock(&team
->lock
);
1230 static int team_vlan_rx_kill_vid(struct net_device
*dev
, uint16_t vid
)
1232 struct team
*team
= netdev_priv(dev
);
1233 struct team_port
*port
;
1236 list_for_each_entry_rcu(port
, &team
->port_list
, list
)
1237 vlan_vid_del(port
->dev
, vid
);
1243 static int team_add_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1245 struct team
*team
= netdev_priv(dev
);
1248 mutex_lock(&team
->lock
);
1249 err
= team_port_add(team
, port_dev
);
1250 mutex_unlock(&team
->lock
);
1254 static int team_del_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1256 struct team
*team
= netdev_priv(dev
);
1259 mutex_lock(&team
->lock
);
1260 err
= team_port_del(team
, port_dev
);
1261 mutex_unlock(&team
->lock
);
1265 static netdev_features_t
team_fix_features(struct net_device
*dev
,
1266 netdev_features_t features
)
1268 struct team_port
*port
;
1269 struct team
*team
= netdev_priv(dev
);
1270 netdev_features_t mask
;
1273 features
&= ~NETIF_F_ONE_FOR_ALL
;
1274 features
|= NETIF_F_ALL_FOR_ALL
;
1277 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1278 features
= netdev_increment_features(features
,
1279 port
->dev
->features
,
1286 static const struct net_device_ops team_netdev_ops
= {
1287 .ndo_init
= team_init
,
1288 .ndo_uninit
= team_uninit
,
1289 .ndo_open
= team_open
,
1290 .ndo_stop
= team_close
,
1291 .ndo_start_xmit
= team_xmit
,
1292 .ndo_change_rx_flags
= team_change_rx_flags
,
1293 .ndo_set_rx_mode
= team_set_rx_mode
,
1294 .ndo_set_mac_address
= team_set_mac_address
,
1295 .ndo_change_mtu
= team_change_mtu
,
1296 .ndo_get_stats64
= team_get_stats64
,
1297 .ndo_vlan_rx_add_vid
= team_vlan_rx_add_vid
,
1298 .ndo_vlan_rx_kill_vid
= team_vlan_rx_kill_vid
,
1299 .ndo_add_slave
= team_add_slave
,
1300 .ndo_del_slave
= team_del_slave
,
1301 .ndo_fix_features
= team_fix_features
,
1305 /***********************
1306 * rt netlink interface
1307 ***********************/
1309 static void team_setup(struct net_device
*dev
)
1313 dev
->netdev_ops
= &team_netdev_ops
;
1314 dev
->destructor
= team_destructor
;
1315 dev
->tx_queue_len
= 0;
1316 dev
->flags
|= IFF_MULTICAST
;
1317 dev
->priv_flags
&= ~(IFF_XMIT_DST_RELEASE
| IFF_TX_SKB_SHARING
);
1320 * Indicate we support unicast address filtering. That way core won't
1321 * bring us to promisc mode in case a unicast addr is added.
1322 * Let this up to underlay drivers.
1324 dev
->priv_flags
|= IFF_UNICAST_FLT
;
1326 dev
->features
|= NETIF_F_LLTX
;
1327 dev
->features
|= NETIF_F_GRO
;
1328 dev
->hw_features
= NETIF_F_HW_VLAN_TX
|
1329 NETIF_F_HW_VLAN_RX
|
1330 NETIF_F_HW_VLAN_FILTER
;
1332 dev
->features
|= dev
->hw_features
;
1335 static int team_newlink(struct net
*src_net
, struct net_device
*dev
,
1336 struct nlattr
*tb
[], struct nlattr
*data
[])
1340 if (tb
[IFLA_ADDRESS
] == NULL
)
1341 eth_hw_addr_random(dev
);
1343 err
= register_netdevice(dev
);
1350 static int team_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
1352 if (tb
[IFLA_ADDRESS
]) {
1353 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
1355 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
1356 return -EADDRNOTAVAIL
;
1361 static struct rtnl_link_ops team_link_ops __read_mostly
= {
1363 .priv_size
= sizeof(struct team
),
1364 .setup
= team_setup
,
1365 .newlink
= team_newlink
,
1366 .validate
= team_validate
,
1370 /***********************************
1371 * Generic netlink custom interface
1372 ***********************************/
1374 static struct genl_family team_nl_family
= {
1375 .id
= GENL_ID_GENERATE
,
1376 .name
= TEAM_GENL_NAME
,
1377 .version
= TEAM_GENL_VERSION
,
1378 .maxattr
= TEAM_ATTR_MAX
,
1382 static const struct nla_policy team_nl_policy
[TEAM_ATTR_MAX
+ 1] = {
1383 [TEAM_ATTR_UNSPEC
] = { .type
= NLA_UNSPEC
, },
1384 [TEAM_ATTR_TEAM_IFINDEX
] = { .type
= NLA_U32
},
1385 [TEAM_ATTR_LIST_OPTION
] = { .type
= NLA_NESTED
},
1386 [TEAM_ATTR_LIST_PORT
] = { .type
= NLA_NESTED
},
1389 static const struct nla_policy
1390 team_nl_option_policy
[TEAM_ATTR_OPTION_MAX
+ 1] = {
1391 [TEAM_ATTR_OPTION_UNSPEC
] = { .type
= NLA_UNSPEC
, },
1392 [TEAM_ATTR_OPTION_NAME
] = {
1394 .len
= TEAM_STRING_MAX_LEN
,
1396 [TEAM_ATTR_OPTION_CHANGED
] = { .type
= NLA_FLAG
},
1397 [TEAM_ATTR_OPTION_TYPE
] = { .type
= NLA_U8
},
1398 [TEAM_ATTR_OPTION_DATA
] = { .type
= NLA_BINARY
},
1401 static int team_nl_cmd_noop(struct sk_buff
*skb
, struct genl_info
*info
)
1403 struct sk_buff
*msg
;
1407 msg
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1411 hdr
= genlmsg_put(msg
, info
->snd_pid
, info
->snd_seq
,
1412 &team_nl_family
, 0, TEAM_CMD_NOOP
);
1418 genlmsg_end(msg
, hdr
);
1420 return genlmsg_unicast(genl_info_net(info
), msg
, info
->snd_pid
);
1429 * Netlink cmd functions should be locked by following two functions.
1430 * Since dev gets held here, that ensures dev won't disappear in between.
1432 static struct team
*team_nl_team_get(struct genl_info
*info
)
1434 struct net
*net
= genl_info_net(info
);
1436 struct net_device
*dev
;
1439 if (!info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
])
1442 ifindex
= nla_get_u32(info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
]);
1443 dev
= dev_get_by_index(net
, ifindex
);
1444 if (!dev
|| dev
->netdev_ops
!= &team_netdev_ops
) {
1450 team
= netdev_priv(dev
);
1451 mutex_lock(&team
->lock
);
1455 static void team_nl_team_put(struct team
*team
)
1457 mutex_unlock(&team
->lock
);
1461 static int team_nl_send_generic(struct genl_info
*info
, struct team
*team
,
1462 int (*fill_func
)(struct sk_buff
*skb
,
1463 struct genl_info
*info
,
1464 int flags
, struct team
*team
))
1466 struct sk_buff
*skb
;
1469 skb
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1473 err
= fill_func(skb
, info
, NLM_F_ACK
, team
);
1477 err
= genlmsg_unicast(genl_info_net(info
), skb
, info
->snd_pid
);
1485 static int team_nl_fill_options_get(struct sk_buff
*skb
,
1486 u32 pid
, u32 seq
, int flags
,
1487 struct team
*team
, bool fillall
)
1489 struct nlattr
*option_list
;
1491 struct team_option_inst
*opt_inst
;
1494 hdr
= genlmsg_put(skb
, pid
, seq
, &team_nl_family
, flags
,
1495 TEAM_CMD_OPTIONS_GET
);
1497 return PTR_ERR(hdr
);
1499 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
1500 goto nla_put_failure
;
1501 option_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_OPTION
);
1505 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
1506 struct nlattr
*option_item
;
1507 struct team_option
*option
= opt_inst
->option
;
1508 struct team_gsetter_ctx ctx
;
1510 /* Include only changed options if fill all mode is not on */
1511 if (!fillall
&& !opt_inst
->changed
)
1513 option_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_OPTION
);
1515 goto nla_put_failure
;
1516 if (nla_put_string(skb
, TEAM_ATTR_OPTION_NAME
, option
->name
))
1517 goto nla_put_failure
;
1518 if (opt_inst
->changed
) {
1519 if (nla_put_flag(skb
, TEAM_ATTR_OPTION_CHANGED
))
1520 goto nla_put_failure
;
1521 opt_inst
->changed
= false;
1523 if (opt_inst
->removed
&&
1524 nla_put_flag(skb
, TEAM_ATTR_OPTION_REMOVED
))
1525 goto nla_put_failure
;
1526 if (opt_inst
->port
&&
1527 nla_put_u32(skb
, TEAM_ATTR_OPTION_PORT_IFINDEX
,
1528 opt_inst
->port
->dev
->ifindex
))
1529 goto nla_put_failure
;
1530 ctx
.port
= opt_inst
->port
;
1531 switch (option
->type
) {
1532 case TEAM_OPTION_TYPE_U32
:
1533 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_U32
))
1534 goto nla_put_failure
;
1535 err
= team_option_get(team
, opt_inst
, &ctx
);
1538 if (nla_put_u32(skb
, TEAM_ATTR_OPTION_DATA
,
1540 goto nla_put_failure
;
1542 case TEAM_OPTION_TYPE_STRING
:
1543 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_STRING
))
1544 goto nla_put_failure
;
1545 err
= team_option_get(team
, opt_inst
, &ctx
);
1548 if (nla_put_string(skb
, TEAM_ATTR_OPTION_DATA
,
1550 goto nla_put_failure
;
1552 case TEAM_OPTION_TYPE_BINARY
:
1553 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_BINARY
))
1554 goto nla_put_failure
;
1555 err
= team_option_get(team
, opt_inst
, &ctx
);
1558 if (nla_put(skb
, TEAM_ATTR_OPTION_DATA
,
1559 ctx
.data
.bin_val
.len
, ctx
.data
.bin_val
.ptr
))
1560 goto nla_put_failure
;
1562 case TEAM_OPTION_TYPE_BOOL
:
1563 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_FLAG
))
1564 goto nla_put_failure
;
1565 err
= team_option_get(team
, opt_inst
, &ctx
);
1568 if (ctx
.data
.bool_val
&&
1569 nla_put_flag(skb
, TEAM_ATTR_OPTION_DATA
))
1570 goto nla_put_failure
;
1575 nla_nest_end(skb
, option_item
);
1578 nla_nest_end(skb
, option_list
);
1579 return genlmsg_end(skb
, hdr
);
1584 genlmsg_cancel(skb
, hdr
);
1588 static int team_nl_fill_options_get_all(struct sk_buff
*skb
,
1589 struct genl_info
*info
, int flags
,
1592 return team_nl_fill_options_get(skb
, info
->snd_pid
,
1593 info
->snd_seq
, NLM_F_ACK
,
1597 static int team_nl_cmd_options_get(struct sk_buff
*skb
, struct genl_info
*info
)
1602 team
= team_nl_team_get(info
);
1606 err
= team_nl_send_generic(info
, team
, team_nl_fill_options_get_all
);
1608 team_nl_team_put(team
);
1613 static int team_nl_cmd_options_set(struct sk_buff
*skb
, struct genl_info
*info
)
1618 struct nlattr
*nl_option
;
1620 team
= team_nl_team_get(info
);
1625 if (!info
->attrs
[TEAM_ATTR_LIST_OPTION
]) {
1630 nla_for_each_nested(nl_option
, info
->attrs
[TEAM_ATTR_LIST_OPTION
], i
) {
1631 struct nlattr
*opt_attrs
[TEAM_ATTR_OPTION_MAX
+ 1];
1632 struct nlattr
*attr_port_ifindex
;
1633 struct nlattr
*attr_data
;
1634 enum team_option_type opt_type
;
1635 int opt_port_ifindex
= 0; /* != 0 for per-port options */
1636 struct team_option_inst
*opt_inst
;
1638 bool opt_found
= false;
1640 if (nla_type(nl_option
) != TEAM_ATTR_ITEM_OPTION
) {
1644 err
= nla_parse_nested(opt_attrs
, TEAM_ATTR_OPTION_MAX
,
1645 nl_option
, team_nl_option_policy
);
1648 if (!opt_attrs
[TEAM_ATTR_OPTION_NAME
] ||
1649 !opt_attrs
[TEAM_ATTR_OPTION_TYPE
]) {
1653 switch (nla_get_u8(opt_attrs
[TEAM_ATTR_OPTION_TYPE
])) {
1655 opt_type
= TEAM_OPTION_TYPE_U32
;
1658 opt_type
= TEAM_OPTION_TYPE_STRING
;
1661 opt_type
= TEAM_OPTION_TYPE_BINARY
;
1664 opt_type
= TEAM_OPTION_TYPE_BOOL
;
1670 attr_data
= opt_attrs
[TEAM_ATTR_OPTION_DATA
];
1671 if (opt_type
!= TEAM_OPTION_TYPE_BOOL
&& !attr_data
) {
1676 opt_name
= nla_data(opt_attrs
[TEAM_ATTR_OPTION_NAME
]);
1677 attr_port_ifindex
= opt_attrs
[TEAM_ATTR_OPTION_PORT_IFINDEX
];
1678 if (attr_port_ifindex
)
1679 opt_port_ifindex
= nla_get_u32(attr_port_ifindex
);
1681 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
1682 struct team_option
*option
= opt_inst
->option
;
1683 struct team_gsetter_ctx ctx
;
1686 tmp_ifindex
= opt_inst
->port
?
1687 opt_inst
->port
->dev
->ifindex
: 0;
1688 if (option
->type
!= opt_type
||
1689 strcmp(option
->name
, opt_name
) ||
1690 tmp_ifindex
!= opt_port_ifindex
)
1693 ctx
.port
= opt_inst
->port
;
1695 case TEAM_OPTION_TYPE_U32
:
1696 ctx
.data
.u32_val
= nla_get_u32(attr_data
);
1698 case TEAM_OPTION_TYPE_STRING
:
1699 if (nla_len(attr_data
) > TEAM_STRING_MAX_LEN
) {
1703 ctx
.data
.str_val
= nla_data(attr_data
);
1705 case TEAM_OPTION_TYPE_BINARY
:
1706 ctx
.data
.bin_val
.len
= nla_len(attr_data
);
1707 ctx
.data
.bin_val
.ptr
= nla_data(attr_data
);
1709 case TEAM_OPTION_TYPE_BOOL
:
1710 ctx
.data
.bool_val
= attr_data
? true : false;
1715 err
= team_option_set(team
, opt_inst
, &ctx
);
1726 team_nl_team_put(team
);
1731 static int team_nl_fill_port_list_get(struct sk_buff
*skb
,
1732 u32 pid
, u32 seq
, int flags
,
1736 struct nlattr
*port_list
;
1738 struct team_port
*port
;
1740 hdr
= genlmsg_put(skb
, pid
, seq
, &team_nl_family
, flags
,
1741 TEAM_CMD_PORT_LIST_GET
);
1743 return PTR_ERR(hdr
);
1745 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
1746 goto nla_put_failure
;
1747 port_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_PORT
);
1751 list_for_each_entry(port
, &team
->port_list
, list
) {
1752 struct nlattr
*port_item
;
1754 /* Include only changed ports if fill all mode is not on */
1755 if (!fillall
&& !port
->changed
)
1757 port_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_PORT
);
1759 goto nla_put_failure
;
1760 if (nla_put_u32(skb
, TEAM_ATTR_PORT_IFINDEX
, port
->dev
->ifindex
))
1761 goto nla_put_failure
;
1762 if (port
->changed
) {
1763 if (nla_put_flag(skb
, TEAM_ATTR_PORT_CHANGED
))
1764 goto nla_put_failure
;
1765 port
->changed
= false;
1767 if ((port
->removed
&&
1768 nla_put_flag(skb
, TEAM_ATTR_PORT_REMOVED
)) ||
1769 (port
->state
.linkup
&&
1770 nla_put_flag(skb
, TEAM_ATTR_PORT_LINKUP
)) ||
1771 nla_put_u32(skb
, TEAM_ATTR_PORT_SPEED
, port
->state
.speed
) ||
1772 nla_put_u8(skb
, TEAM_ATTR_PORT_DUPLEX
, port
->state
.duplex
))
1773 goto nla_put_failure
;
1774 nla_nest_end(skb
, port_item
);
1777 nla_nest_end(skb
, port_list
);
1778 return genlmsg_end(skb
, hdr
);
1781 genlmsg_cancel(skb
, hdr
);
1785 static int team_nl_fill_port_list_get_all(struct sk_buff
*skb
,
1786 struct genl_info
*info
, int flags
,
1789 return team_nl_fill_port_list_get(skb
, info
->snd_pid
,
1790 info
->snd_seq
, NLM_F_ACK
,
1794 static int team_nl_cmd_port_list_get(struct sk_buff
*skb
,
1795 struct genl_info
*info
)
1800 team
= team_nl_team_get(info
);
1804 err
= team_nl_send_generic(info
, team
, team_nl_fill_port_list_get_all
);
1806 team_nl_team_put(team
);
1811 static struct genl_ops team_nl_ops
[] = {
1813 .cmd
= TEAM_CMD_NOOP
,
1814 .doit
= team_nl_cmd_noop
,
1815 .policy
= team_nl_policy
,
1818 .cmd
= TEAM_CMD_OPTIONS_SET
,
1819 .doit
= team_nl_cmd_options_set
,
1820 .policy
= team_nl_policy
,
1821 .flags
= GENL_ADMIN_PERM
,
1824 .cmd
= TEAM_CMD_OPTIONS_GET
,
1825 .doit
= team_nl_cmd_options_get
,
1826 .policy
= team_nl_policy
,
1827 .flags
= GENL_ADMIN_PERM
,
1830 .cmd
= TEAM_CMD_PORT_LIST_GET
,
1831 .doit
= team_nl_cmd_port_list_get
,
1832 .policy
= team_nl_policy
,
1833 .flags
= GENL_ADMIN_PERM
,
1837 static struct genl_multicast_group team_change_event_mcgrp
= {
1838 .name
= TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME
,
1841 static int team_nl_send_event_options_get(struct team
*team
)
1843 struct sk_buff
*skb
;
1845 struct net
*net
= dev_net(team
->dev
);
1847 skb
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1851 err
= team_nl_fill_options_get(skb
, 0, 0, 0, team
, false);
1855 err
= genlmsg_multicast_netns(net
, skb
, 0, team_change_event_mcgrp
.id
,
1864 static int team_nl_send_event_port_list_get(struct team
*team
)
1866 struct sk_buff
*skb
;
1868 struct net
*net
= dev_net(team
->dev
);
1870 skb
= nlmsg_new(NLMSG_GOODSIZE
, GFP_KERNEL
);
1874 err
= team_nl_fill_port_list_get(skb
, 0, 0, 0, team
, false);
1878 err
= genlmsg_multicast_netns(net
, skb
, 0, team_change_event_mcgrp
.id
,
1887 static int team_nl_init(void)
1891 err
= genl_register_family_with_ops(&team_nl_family
, team_nl_ops
,
1892 ARRAY_SIZE(team_nl_ops
));
1896 err
= genl_register_mc_group(&team_nl_family
, &team_change_event_mcgrp
);
1898 goto err_change_event_grp_reg
;
1902 err_change_event_grp_reg
:
1903 genl_unregister_family(&team_nl_family
);
1908 static void team_nl_fini(void)
1910 genl_unregister_family(&team_nl_family
);
1918 static void __team_options_change_check(struct team
*team
)
1922 err
= team_nl_send_event_options_get(team
);
1924 netdev_warn(team
->dev
, "Failed to send options change via netlink\n");
1927 /* rtnl lock is held */
1928 static void __team_port_change_check(struct team_port
*port
, bool linkup
)
1932 if (!port
->removed
&& port
->state
.linkup
== linkup
)
1935 port
->changed
= true;
1936 port
->state
.linkup
= linkup
;
1937 team_refresh_port_linkup(port
);
1939 struct ethtool_cmd ecmd
;
1941 err
= __ethtool_get_settings(port
->dev
, &ecmd
);
1943 port
->state
.speed
= ethtool_cmd_speed(&ecmd
);
1944 port
->state
.duplex
= ecmd
.duplex
;
1948 port
->state
.speed
= 0;
1949 port
->state
.duplex
= 0;
1952 err
= team_nl_send_event_port_list_get(port
->team
);
1954 netdev_warn(port
->team
->dev
, "Failed to send port change of device %s via netlink\n",
1959 static void team_port_change_check(struct team_port
*port
, bool linkup
)
1961 struct team
*team
= port
->team
;
1963 mutex_lock(&team
->lock
);
1964 __team_port_change_check(port
, linkup
);
1965 mutex_unlock(&team
->lock
);
1968 /************************************
1969 * Net device notifier event handler
1970 ************************************/
1972 static int team_device_event(struct notifier_block
*unused
,
1973 unsigned long event
, void *ptr
)
1975 struct net_device
*dev
= (struct net_device
*) ptr
;
1976 struct team_port
*port
;
1978 port
= team_port_get_rtnl(dev
);
1984 if (netif_carrier_ok(dev
))
1985 team_port_change_check(port
, true);
1987 team_port_change_check(port
, false);
1989 if (netif_running(port
->dev
))
1990 team_port_change_check(port
,
1991 !!netif_carrier_ok(port
->dev
));
1993 case NETDEV_UNREGISTER
:
1994 team_del_slave(port
->team
->dev
, dev
);
1996 case NETDEV_FEAT_CHANGE
:
1997 team_compute_features(port
->team
);
1999 case NETDEV_CHANGEMTU
:
2000 /* Forbid to change mtu of underlaying device */
2002 case NETDEV_PRE_TYPE_CHANGE
:
2003 /* Forbid to change type of underlaying device */
2009 static struct notifier_block team_notifier_block __read_mostly
= {
2010 .notifier_call
= team_device_event
,
2014 /***********************
2015 * Module init and exit
2016 ***********************/
2018 static int __init
team_module_init(void)
2022 register_netdevice_notifier(&team_notifier_block
);
2024 err
= rtnl_link_register(&team_link_ops
);
2028 err
= team_nl_init();
2035 rtnl_link_unregister(&team_link_ops
);
2038 unregister_netdevice_notifier(&team_notifier_block
);
2043 static void __exit
team_module_exit(void)
2046 rtnl_link_unregister(&team_link_ops
);
2047 unregister_netdevice_notifier(&team_notifier_block
);
2050 module_init(team_module_init
);
2051 module_exit(team_module_exit
);
2053 MODULE_LICENSE("GPL v2");
2054 MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
2055 MODULE_DESCRIPTION("Ethernet team device driver");
2056 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);