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 <linux/if_team.h>
33 #define DRV_NAME "team"
40 #define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT)
42 static struct team_port
*team_port_get_rcu(const struct net_device
*dev
)
44 struct team_port
*port
= rcu_dereference(dev
->rx_handler_data
);
46 return team_port_exists(dev
) ? port
: NULL
;
49 static struct team_port
*team_port_get_rtnl(const struct net_device
*dev
)
51 struct team_port
*port
= rtnl_dereference(dev
->rx_handler_data
);
53 return team_port_exists(dev
) ? port
: NULL
;
57 * Since the ability to change mac address for open port device is tested in
58 * team_port_add, this function can be called without control of return value
60 static int __set_port_mac(struct net_device
*port_dev
,
61 const unsigned char *dev_addr
)
65 memcpy(addr
.sa_data
, dev_addr
, ETH_ALEN
);
66 addr
.sa_family
= ARPHRD_ETHER
;
67 return dev_set_mac_address(port_dev
, &addr
);
70 static int team_port_set_orig_mac(struct team_port
*port
)
72 return __set_port_mac(port
->dev
, port
->orig
.dev_addr
);
75 int team_port_set_team_mac(struct team_port
*port
)
77 return __set_port_mac(port
->dev
, port
->team
->dev
->dev_addr
);
79 EXPORT_SYMBOL(team_port_set_team_mac
);
81 static void team_refresh_port_linkup(struct team_port
*port
)
83 port
->linkup
= port
->user
.linkup_enabled
? port
->user
.linkup
:
92 struct team_option_inst
{ /* One for each option instance */
93 struct list_head list
;
94 struct list_head tmp_list
;
95 struct team_option
*option
;
96 struct team_option_inst_info info
;
101 static struct team_option
*__team_find_option(struct team
*team
,
102 const char *opt_name
)
104 struct team_option
*option
;
106 list_for_each_entry(option
, &team
->option_list
, list
) {
107 if (strcmp(option
->name
, opt_name
) == 0)
113 static void __team_option_inst_del(struct team_option_inst
*opt_inst
)
115 list_del(&opt_inst
->list
);
119 static void __team_option_inst_del_option(struct team
*team
,
120 struct team_option
*option
)
122 struct team_option_inst
*opt_inst
, *tmp
;
124 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
125 if (opt_inst
->option
== option
)
126 __team_option_inst_del(opt_inst
);
130 static int __team_option_inst_add(struct team
*team
, struct team_option
*option
,
131 struct team_port
*port
)
133 struct team_option_inst
*opt_inst
;
134 unsigned int array_size
;
138 array_size
= option
->array_size
;
140 array_size
= 1; /* No array but still need one instance */
142 for (i
= 0; i
< array_size
; i
++) {
143 opt_inst
= kmalloc(sizeof(*opt_inst
), GFP_KERNEL
);
146 opt_inst
->option
= option
;
147 opt_inst
->info
.port
= port
;
148 opt_inst
->info
.array_index
= i
;
149 opt_inst
->changed
= true;
150 opt_inst
->removed
= false;
151 list_add_tail(&opt_inst
->list
, &team
->option_inst_list
);
153 err
= option
->init(team
, &opt_inst
->info
);
162 static int __team_option_inst_add_option(struct team
*team
,
163 struct team_option
*option
)
165 struct team_port
*port
;
168 if (!option
->per_port
) {
169 err
= __team_option_inst_add(team
, option
, NULL
);
171 goto inst_del_option
;
174 list_for_each_entry(port
, &team
->port_list
, list
) {
175 err
= __team_option_inst_add(team
, option
, port
);
177 goto inst_del_option
;
182 __team_option_inst_del_option(team
, option
);
186 static void __team_option_inst_mark_removed_option(struct team
*team
,
187 struct team_option
*option
)
189 struct team_option_inst
*opt_inst
;
191 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
192 if (opt_inst
->option
== option
) {
193 opt_inst
->changed
= true;
194 opt_inst
->removed
= true;
199 static void __team_option_inst_del_port(struct team
*team
,
200 struct team_port
*port
)
202 struct team_option_inst
*opt_inst
, *tmp
;
204 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
205 if (opt_inst
->option
->per_port
&&
206 opt_inst
->info
.port
== port
)
207 __team_option_inst_del(opt_inst
);
211 static int __team_option_inst_add_port(struct team
*team
,
212 struct team_port
*port
)
214 struct team_option
*option
;
217 list_for_each_entry(option
, &team
->option_list
, list
) {
218 if (!option
->per_port
)
220 err
= __team_option_inst_add(team
, option
, port
);
227 __team_option_inst_del_port(team
, port
);
231 static void __team_option_inst_mark_removed_port(struct team
*team
,
232 struct team_port
*port
)
234 struct team_option_inst
*opt_inst
;
236 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
237 if (opt_inst
->info
.port
== port
) {
238 opt_inst
->changed
= true;
239 opt_inst
->removed
= true;
244 static int __team_options_register(struct team
*team
,
245 const struct team_option
*option
,
249 struct team_option
**dst_opts
;
252 dst_opts
= kzalloc(sizeof(struct team_option
*) * option_count
,
256 for (i
= 0; i
< option_count
; i
++, option
++) {
257 if (__team_find_option(team
, option
->name
)) {
261 dst_opts
[i
] = kmemdup(option
, sizeof(*option
), GFP_KERNEL
);
268 for (i
= 0; i
< option_count
; i
++) {
269 err
= __team_option_inst_add_option(team
, dst_opts
[i
]);
272 list_add_tail(&dst_opts
[i
]->list
, &team
->option_list
);
279 for (i
--; i
>= 0; i
--)
280 __team_option_inst_del_option(team
, dst_opts
[i
]);
282 i
= option_count
- 1;
284 for (i
--; i
>= 0; i
--)
291 static void __team_options_mark_removed(struct team
*team
,
292 const struct team_option
*option
,
297 for (i
= 0; i
< option_count
; i
++, option
++) {
298 struct team_option
*del_opt
;
300 del_opt
= __team_find_option(team
, option
->name
);
302 __team_option_inst_mark_removed_option(team
, del_opt
);
306 static void __team_options_unregister(struct team
*team
,
307 const struct team_option
*option
,
312 for (i
= 0; i
< option_count
; i
++, option
++) {
313 struct team_option
*del_opt
;
315 del_opt
= __team_find_option(team
, option
->name
);
317 __team_option_inst_del_option(team
, del_opt
);
318 list_del(&del_opt
->list
);
324 static void __team_options_change_check(struct team
*team
);
326 int team_options_register(struct team
*team
,
327 const struct team_option
*option
,
332 err
= __team_options_register(team
, option
, option_count
);
335 __team_options_change_check(team
);
338 EXPORT_SYMBOL(team_options_register
);
340 void team_options_unregister(struct team
*team
,
341 const struct team_option
*option
,
344 __team_options_mark_removed(team
, option
, option_count
);
345 __team_options_change_check(team
);
346 __team_options_unregister(team
, option
, option_count
);
348 EXPORT_SYMBOL(team_options_unregister
);
350 static int team_option_get(struct team
*team
,
351 struct team_option_inst
*opt_inst
,
352 struct team_gsetter_ctx
*ctx
)
354 if (!opt_inst
->option
->getter
)
356 return opt_inst
->option
->getter(team
, ctx
);
359 static int team_option_set(struct team
*team
,
360 struct team_option_inst
*opt_inst
,
361 struct team_gsetter_ctx
*ctx
)
363 if (!opt_inst
->option
->setter
)
365 return opt_inst
->option
->setter(team
, ctx
);
368 void team_option_inst_set_change(struct team_option_inst_info
*opt_inst_info
)
370 struct team_option_inst
*opt_inst
;
372 opt_inst
= container_of(opt_inst_info
, struct team_option_inst
, info
);
373 opt_inst
->changed
= true;
375 EXPORT_SYMBOL(team_option_inst_set_change
);
377 void team_options_change_check(struct team
*team
)
379 __team_options_change_check(team
);
381 EXPORT_SYMBOL(team_options_change_check
);
388 static LIST_HEAD(mode_list
);
389 static DEFINE_SPINLOCK(mode_list_lock
);
391 struct team_mode_item
{
392 struct list_head list
;
393 const struct team_mode
*mode
;
396 static struct team_mode_item
*__find_mode(const char *kind
)
398 struct team_mode_item
*mitem
;
400 list_for_each_entry(mitem
, &mode_list
, list
) {
401 if (strcmp(mitem
->mode
->kind
, kind
) == 0)
407 static bool is_good_mode_name(const char *name
)
409 while (*name
!= '\0') {
410 if (!isalpha(*name
) && !isdigit(*name
) && *name
!= '_')
417 int team_mode_register(const struct team_mode
*mode
)
420 struct team_mode_item
*mitem
;
422 if (!is_good_mode_name(mode
->kind
) ||
423 mode
->priv_size
> TEAM_MODE_PRIV_SIZE
)
426 mitem
= kmalloc(sizeof(*mitem
), GFP_KERNEL
);
430 spin_lock(&mode_list_lock
);
431 if (__find_mode(mode
->kind
)) {
437 list_add_tail(&mitem
->list
, &mode_list
);
439 spin_unlock(&mode_list_lock
);
442 EXPORT_SYMBOL(team_mode_register
);
444 void team_mode_unregister(const struct team_mode
*mode
)
446 struct team_mode_item
*mitem
;
448 spin_lock(&mode_list_lock
);
449 mitem
= __find_mode(mode
->kind
);
451 list_del_init(&mitem
->list
);
454 spin_unlock(&mode_list_lock
);
456 EXPORT_SYMBOL(team_mode_unregister
);
458 static const struct team_mode
*team_mode_get(const char *kind
)
460 struct team_mode_item
*mitem
;
461 const struct team_mode
*mode
= NULL
;
463 spin_lock(&mode_list_lock
);
464 mitem
= __find_mode(kind
);
466 spin_unlock(&mode_list_lock
);
467 request_module("team-mode-%s", kind
);
468 spin_lock(&mode_list_lock
);
469 mitem
= __find_mode(kind
);
473 if (!try_module_get(mode
->owner
))
477 spin_unlock(&mode_list_lock
);
481 static void team_mode_put(const struct team_mode
*mode
)
483 module_put(mode
->owner
);
486 static bool team_dummy_transmit(struct team
*team
, struct sk_buff
*skb
)
488 dev_kfree_skb_any(skb
);
492 rx_handler_result_t
team_dummy_receive(struct team
*team
,
493 struct team_port
*port
,
496 return RX_HANDLER_ANOTHER
;
499 static const struct team_mode __team_no_mode
= {
503 static bool team_is_mode_set(struct team
*team
)
505 return team
->mode
!= &__team_no_mode
;
508 static void team_set_no_mode(struct team
*team
)
510 team
->mode
= &__team_no_mode
;
513 static void __team_adjust_ops(struct team
*team
, int en_port_count
)
516 * To avoid checks in rx/tx skb paths, ensure here that non-null and
517 * correct ops are always set.
520 if (!en_port_count
|| !team_is_mode_set(team
) ||
521 !team
->mode
->ops
->transmit
)
522 team
->ops
.transmit
= team_dummy_transmit
;
524 team
->ops
.transmit
= team
->mode
->ops
->transmit
;
526 if (!en_port_count
|| !team_is_mode_set(team
) ||
527 !team
->mode
->ops
->receive
)
528 team
->ops
.receive
= team_dummy_receive
;
530 team
->ops
.receive
= team
->mode
->ops
->receive
;
533 static void team_adjust_ops(struct team
*team
)
535 __team_adjust_ops(team
, team
->en_port_count
);
539 * We can benefit from the fact that it's ensured no port is present
540 * at the time of mode change. Therefore no packets are in fly so there's no
541 * need to set mode operations in any special way.
543 static int __team_change_mode(struct team
*team
,
544 const struct team_mode
*new_mode
)
546 /* Check if mode was previously set and do cleanup if so */
547 if (team_is_mode_set(team
)) {
548 void (*exit_op
)(struct team
*team
) = team
->ops
.exit
;
550 /* Clear ops area so no callback is called any longer */
551 memset(&team
->ops
, 0, sizeof(struct team_mode_ops
));
552 team_adjust_ops(team
);
556 team_mode_put(team
->mode
);
557 team_set_no_mode(team
);
558 /* zero private data area */
559 memset(&team
->mode_priv
, 0,
560 sizeof(struct team
) - offsetof(struct team
, mode_priv
));
566 if (new_mode
->ops
->init
) {
569 err
= new_mode
->ops
->init(team
);
574 team
->mode
= new_mode
;
575 memcpy(&team
->ops
, new_mode
->ops
, sizeof(struct team_mode_ops
));
576 team_adjust_ops(team
);
581 static int team_change_mode(struct team
*team
, const char *kind
)
583 const struct team_mode
*new_mode
;
584 struct net_device
*dev
= team
->dev
;
587 if (!list_empty(&team
->port_list
)) {
588 netdev_err(dev
, "No ports can be present during mode change\n");
592 if (team_is_mode_set(team
) && strcmp(team
->mode
->kind
, kind
) == 0) {
593 netdev_err(dev
, "Unable to change to the same mode the team is in\n");
597 new_mode
= team_mode_get(kind
);
599 netdev_err(dev
, "Mode \"%s\" not found\n", kind
);
603 err
= __team_change_mode(team
, new_mode
);
605 netdev_err(dev
, "Failed to change to mode \"%s\"\n", kind
);
606 team_mode_put(new_mode
);
610 netdev_info(dev
, "Mode changed to \"%s\"\n", kind
);
615 /************************
616 * Rx path frame handler
617 ************************/
619 /* note: already called with rcu_read_lock */
620 static rx_handler_result_t
team_handle_frame(struct sk_buff
**pskb
)
622 struct sk_buff
*skb
= *pskb
;
623 struct team_port
*port
;
625 rx_handler_result_t res
;
627 skb
= skb_share_check(skb
, GFP_ATOMIC
);
629 return RX_HANDLER_CONSUMED
;
633 port
= team_port_get_rcu(skb
->dev
);
635 if (!team_port_enabled(port
)) {
636 /* allow exact match delivery for disabled ports */
637 res
= RX_HANDLER_EXACT
;
639 res
= team
->ops
.receive(team
, port
, skb
);
641 if (res
== RX_HANDLER_ANOTHER
) {
642 struct team_pcpu_stats
*pcpu_stats
;
644 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
645 u64_stats_update_begin(&pcpu_stats
->syncp
);
646 pcpu_stats
->rx_packets
++;
647 pcpu_stats
->rx_bytes
+= skb
->len
;
648 if (skb
->pkt_type
== PACKET_MULTICAST
)
649 pcpu_stats
->rx_multicast
++;
650 u64_stats_update_end(&pcpu_stats
->syncp
);
652 skb
->dev
= team
->dev
;
654 this_cpu_inc(team
->pcpu_stats
->rx_dropped
);
665 static bool team_port_find(const struct team
*team
,
666 const struct team_port
*port
)
668 struct team_port
*cur
;
670 list_for_each_entry(cur
, &team
->port_list
, list
)
677 * Enable/disable port by adding to enabled port hashlist and setting
678 * port->index (Might be racy so reader could see incorrect ifindex when
679 * processing a flying packet, but that is not a problem). Write guarded
682 static void team_port_enable(struct team
*team
,
683 struct team_port
*port
)
685 if (team_port_enabled(port
))
687 port
->index
= team
->en_port_count
++;
688 hlist_add_head_rcu(&port
->hlist
,
689 team_port_index_hash(team
, port
->index
));
690 team_adjust_ops(team
);
691 if (team
->ops
.port_enabled
)
692 team
->ops
.port_enabled(team
, port
);
695 static void __reconstruct_port_hlist(struct team
*team
, int rm_index
)
698 struct team_port
*port
;
700 for (i
= rm_index
+ 1; i
< team
->en_port_count
; i
++) {
701 port
= team_get_port_by_index(team
, i
);
702 hlist_del_rcu(&port
->hlist
);
704 hlist_add_head_rcu(&port
->hlist
,
705 team_port_index_hash(team
, port
->index
));
709 static void team_port_disable(struct team
*team
,
710 struct team_port
*port
)
712 if (!team_port_enabled(port
))
714 if (team
->ops
.port_disabled
)
715 team
->ops
.port_disabled(team
, port
);
716 hlist_del_rcu(&port
->hlist
);
717 __reconstruct_port_hlist(team
, port
->index
);
719 __team_adjust_ops(team
, team
->en_port_count
- 1);
721 * Wait until readers see adjusted ops. This ensures that
722 * readers never see team->en_port_count == 0
725 team
->en_port_count
--;
728 #define TEAM_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
729 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
730 NETIF_F_HIGHDMA | NETIF_F_LRO)
732 static void __team_compute_features(struct team
*team
)
734 struct team_port
*port
;
735 u32 vlan_features
= TEAM_VLAN_FEATURES
;
736 unsigned short max_hard_header_len
= ETH_HLEN
;
737 unsigned int flags
, dst_release_flag
= IFF_XMIT_DST_RELEASE
;
739 list_for_each_entry(port
, &team
->port_list
, list
) {
740 vlan_features
= netdev_increment_features(vlan_features
,
741 port
->dev
->vlan_features
,
744 dst_release_flag
&= port
->dev
->priv_flags
;
745 if (port
->dev
->hard_header_len
> max_hard_header_len
)
746 max_hard_header_len
= port
->dev
->hard_header_len
;
749 team
->dev
->vlan_features
= vlan_features
;
750 team
->dev
->hard_header_len
= max_hard_header_len
;
752 flags
= team
->dev
->priv_flags
& ~IFF_XMIT_DST_RELEASE
;
753 team
->dev
->priv_flags
= flags
| dst_release_flag
;
755 netdev_change_features(team
->dev
);
758 static void team_compute_features(struct team
*team
)
760 mutex_lock(&team
->lock
);
761 __team_compute_features(team
);
762 mutex_unlock(&team
->lock
);
765 static int team_port_enter(struct team
*team
, struct team_port
*port
)
770 port
->dev
->priv_flags
|= IFF_TEAM_PORT
;
771 if (team
->ops
.port_enter
) {
772 err
= team
->ops
.port_enter(team
, port
);
774 netdev_err(team
->dev
, "Device %s failed to enter team mode\n",
783 port
->dev
->priv_flags
&= ~IFF_TEAM_PORT
;
789 static void team_port_leave(struct team
*team
, struct team_port
*port
)
791 if (team
->ops
.port_leave
)
792 team
->ops
.port_leave(team
, port
);
793 port
->dev
->priv_flags
&= ~IFF_TEAM_PORT
;
797 #ifdef CONFIG_NET_POLL_CONTROLLER
798 static int team_port_enable_netpoll(struct team
*team
, struct team_port
*port
,
804 np
= kzalloc(sizeof(*np
), gfp
);
808 err
= __netpoll_setup(np
, port
->dev
, gfp
);
817 static void team_port_disable_netpoll(struct team_port
*port
)
819 struct netpoll
*np
= port
->np
;
825 /* Wait for transmitting packets to finish before freeing. */
826 synchronize_rcu_bh();
827 __netpoll_cleanup(np
);
831 static struct netpoll_info
*team_netpoll_info(struct team
*team
)
833 return team
->dev
->npinfo
;
837 static int team_port_enable_netpoll(struct team
*team
, struct team_port
*port
,
842 static void team_port_disable_netpoll(struct team_port
*port
)
845 static struct netpoll_info
*team_netpoll_info(struct team
*team
)
851 static void __team_port_change_check(struct team_port
*port
, bool linkup
);
853 static int team_port_add(struct team
*team
, struct net_device
*port_dev
)
855 struct net_device
*dev
= team
->dev
;
856 struct team_port
*port
;
857 char *portname
= port_dev
->name
;
860 if (port_dev
->flags
& IFF_LOOPBACK
||
861 port_dev
->type
!= ARPHRD_ETHER
) {
862 netdev_err(dev
, "Device %s is of an unsupported type\n",
867 if (team_port_exists(port_dev
)) {
868 netdev_err(dev
, "Device %s is already a port "
869 "of a team device\n", portname
);
873 if (port_dev
->flags
& IFF_UP
) {
874 netdev_err(dev
, "Device %s is up. Set it down before adding it as a team port\n",
879 port
= kzalloc(sizeof(struct team_port
) + team
->mode
->port_priv_size
,
884 port
->dev
= port_dev
;
887 port
->orig
.mtu
= port_dev
->mtu
;
888 err
= dev_set_mtu(port_dev
, dev
->mtu
);
890 netdev_dbg(dev
, "Error %d calling dev_set_mtu\n", err
);
894 memcpy(port
->orig
.dev_addr
, port_dev
->dev_addr
, ETH_ALEN
);
896 err
= team_port_enter(team
, port
);
898 netdev_err(dev
, "Device %s failed to enter team mode\n",
903 err
= dev_open(port_dev
);
905 netdev_dbg(dev
, "Device %s opening failed\n",
910 err
= vlan_vids_add_by_dev(port_dev
, dev
);
912 netdev_err(dev
, "Failed to add vlan ids to device %s\n",
917 if (team_netpoll_info(team
)) {
918 err
= team_port_enable_netpoll(team
, port
, GFP_KERNEL
);
920 netdev_err(dev
, "Failed to enable netpoll on device %s\n",
922 goto err_enable_netpoll
;
926 err
= netdev_set_master(port_dev
, dev
);
928 netdev_err(dev
, "Device %s failed to set master\n", portname
);
932 err
= netdev_rx_handler_register(port_dev
, team_handle_frame
,
935 netdev_err(dev
, "Device %s failed to register rx_handler\n",
937 goto err_handler_register
;
940 err
= __team_option_inst_add_port(team
, port
);
942 netdev_err(dev
, "Device %s failed to add per-port options\n",
944 goto err_option_port_add
;
948 team_port_enable(team
, port
);
949 list_add_tail_rcu(&port
->list
, &team
->port_list
);
950 __team_compute_features(team
);
951 __team_port_change_check(port
, !!netif_carrier_ok(port_dev
));
952 __team_options_change_check(team
);
954 netdev_info(dev
, "Port device %s added\n", portname
);
959 netdev_rx_handler_unregister(port_dev
);
961 err_handler_register
:
962 netdev_set_master(port_dev
, NULL
);
965 team_port_disable_netpoll(port
);
968 vlan_vids_del_by_dev(port_dev
, dev
);
974 team_port_leave(team
, port
);
975 team_port_set_orig_mac(port
);
978 dev_set_mtu(port_dev
, port
->orig
.mtu
);
986 static int team_port_del(struct team
*team
, struct net_device
*port_dev
)
988 struct net_device
*dev
= team
->dev
;
989 struct team_port
*port
;
990 char *portname
= port_dev
->name
;
992 port
= team_port_get_rtnl(port_dev
);
993 if (!port
|| !team_port_find(team
, port
)) {
994 netdev_err(dev
, "Device %s does not act as a port of this team\n",
999 __team_option_inst_mark_removed_port(team
, port
);
1000 __team_options_change_check(team
);
1001 __team_option_inst_del_port(team
, port
);
1002 port
->removed
= true;
1003 __team_port_change_check(port
, false);
1004 team_port_disable(team
, port
);
1005 list_del_rcu(&port
->list
);
1006 netdev_rx_handler_unregister(port_dev
);
1007 netdev_set_master(port_dev
, NULL
);
1008 team_port_disable_netpoll(port
);
1009 vlan_vids_del_by_dev(port_dev
, dev
);
1010 dev_close(port_dev
);
1011 team_port_leave(team
, port
);
1012 team_port_set_orig_mac(port
);
1013 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1016 netdev_info(dev
, "Port device %s removed\n", portname
);
1017 __team_compute_features(team
);
1027 static int team_mode_option_get(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1029 ctx
->data
.str_val
= team
->mode
->kind
;
1033 static int team_mode_option_set(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1035 return team_change_mode(team
, ctx
->data
.str_val
);
1038 static int team_port_en_option_get(struct team
*team
,
1039 struct team_gsetter_ctx
*ctx
)
1041 struct team_port
*port
= ctx
->info
->port
;
1043 ctx
->data
.bool_val
= team_port_enabled(port
);
1047 static int team_port_en_option_set(struct team
*team
,
1048 struct team_gsetter_ctx
*ctx
)
1050 struct team_port
*port
= ctx
->info
->port
;
1052 if (ctx
->data
.bool_val
)
1053 team_port_enable(team
, port
);
1055 team_port_disable(team
, port
);
1059 static int team_user_linkup_option_get(struct team
*team
,
1060 struct team_gsetter_ctx
*ctx
)
1062 struct team_port
*port
= ctx
->info
->port
;
1064 ctx
->data
.bool_val
= port
->user
.linkup
;
1068 static int team_user_linkup_option_set(struct team
*team
,
1069 struct team_gsetter_ctx
*ctx
)
1071 struct team_port
*port
= ctx
->info
->port
;
1073 port
->user
.linkup
= ctx
->data
.bool_val
;
1074 team_refresh_port_linkup(port
);
1078 static int team_user_linkup_en_option_get(struct team
*team
,
1079 struct team_gsetter_ctx
*ctx
)
1081 struct team_port
*port
= ctx
->info
->port
;
1083 ctx
->data
.bool_val
= port
->user
.linkup_enabled
;
1087 static int team_user_linkup_en_option_set(struct team
*team
,
1088 struct team_gsetter_ctx
*ctx
)
1090 struct team_port
*port
= ctx
->info
->port
;
1092 port
->user
.linkup_enabled
= ctx
->data
.bool_val
;
1093 team_refresh_port_linkup(port
);
1097 static const struct team_option team_options
[] = {
1100 .type
= TEAM_OPTION_TYPE_STRING
,
1101 .getter
= team_mode_option_get
,
1102 .setter
= team_mode_option_set
,
1106 .type
= TEAM_OPTION_TYPE_BOOL
,
1108 .getter
= team_port_en_option_get
,
1109 .setter
= team_port_en_option_set
,
1112 .name
= "user_linkup",
1113 .type
= TEAM_OPTION_TYPE_BOOL
,
1115 .getter
= team_user_linkup_option_get
,
1116 .setter
= team_user_linkup_option_set
,
1119 .name
= "user_linkup_enabled",
1120 .type
= TEAM_OPTION_TYPE_BOOL
,
1122 .getter
= team_user_linkup_en_option_get
,
1123 .setter
= team_user_linkup_en_option_set
,
1127 static struct lock_class_key team_netdev_xmit_lock_key
;
1128 static struct lock_class_key team_netdev_addr_lock_key
;
1130 static void team_set_lockdep_class_one(struct net_device
*dev
,
1131 struct netdev_queue
*txq
,
1134 lockdep_set_class(&txq
->_xmit_lock
, &team_netdev_xmit_lock_key
);
1137 static void team_set_lockdep_class(struct net_device
*dev
)
1139 lockdep_set_class(&dev
->addr_list_lock
, &team_netdev_addr_lock_key
);
1140 netdev_for_each_tx_queue(dev
, team_set_lockdep_class_one
, NULL
);
1143 static int team_init(struct net_device
*dev
)
1145 struct team
*team
= netdev_priv(dev
);
1150 mutex_init(&team
->lock
);
1151 team_set_no_mode(team
);
1153 team
->pcpu_stats
= alloc_percpu(struct team_pcpu_stats
);
1154 if (!team
->pcpu_stats
)
1157 for (i
= 0; i
< TEAM_PORT_HASHENTRIES
; i
++)
1158 INIT_HLIST_HEAD(&team
->en_port_hlist
[i
]);
1159 INIT_LIST_HEAD(&team
->port_list
);
1161 team_adjust_ops(team
);
1163 INIT_LIST_HEAD(&team
->option_list
);
1164 INIT_LIST_HEAD(&team
->option_inst_list
);
1165 err
= team_options_register(team
, team_options
, ARRAY_SIZE(team_options
));
1167 goto err_options_register
;
1168 netif_carrier_off(dev
);
1170 team_set_lockdep_class(dev
);
1174 err_options_register
:
1175 free_percpu(team
->pcpu_stats
);
1180 static void team_uninit(struct net_device
*dev
)
1182 struct team
*team
= netdev_priv(dev
);
1183 struct team_port
*port
;
1184 struct team_port
*tmp
;
1186 mutex_lock(&team
->lock
);
1187 list_for_each_entry_safe(port
, tmp
, &team
->port_list
, list
)
1188 team_port_del(team
, port
->dev
);
1190 __team_change_mode(team
, NULL
); /* cleanup */
1191 __team_options_unregister(team
, team_options
, ARRAY_SIZE(team_options
));
1192 mutex_unlock(&team
->lock
);
1195 static void team_destructor(struct net_device
*dev
)
1197 struct team
*team
= netdev_priv(dev
);
1199 free_percpu(team
->pcpu_stats
);
1203 static int team_open(struct net_device
*dev
)
1205 netif_carrier_on(dev
);
1209 static int team_close(struct net_device
*dev
)
1211 netif_carrier_off(dev
);
1216 * note: already called with rcu_read_lock
1218 static netdev_tx_t
team_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1220 struct team
*team
= netdev_priv(dev
);
1221 bool tx_success
= false;
1222 unsigned int len
= skb
->len
;
1224 tx_success
= team
->ops
.transmit(team
, skb
);
1226 struct team_pcpu_stats
*pcpu_stats
;
1228 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
1229 u64_stats_update_begin(&pcpu_stats
->syncp
);
1230 pcpu_stats
->tx_packets
++;
1231 pcpu_stats
->tx_bytes
+= len
;
1232 u64_stats_update_end(&pcpu_stats
->syncp
);
1234 this_cpu_inc(team
->pcpu_stats
->tx_dropped
);
1237 return NETDEV_TX_OK
;
1240 static u16
team_select_queue(struct net_device
*dev
, struct sk_buff
*skb
)
1243 * This helper function exists to help dev_pick_tx get the correct
1244 * destination queue. Using a helper function skips a call to
1245 * skb_tx_hash and will put the skbs in the queue we expect on their
1246 * way down to the team driver.
1248 u16 txq
= skb_rx_queue_recorded(skb
) ? skb_get_rx_queue(skb
) : 0;
1251 * Save the original txq to restore before passing to the driver
1253 qdisc_skb_cb(skb
)->slave_dev_queue_mapping
= skb
->queue_mapping
;
1255 if (unlikely(txq
>= dev
->real_num_tx_queues
)) {
1257 txq
-= dev
->real_num_tx_queues
;
1258 } while (txq
>= dev
->real_num_tx_queues
);
1263 static void team_change_rx_flags(struct net_device
*dev
, int change
)
1265 struct team
*team
= netdev_priv(dev
);
1266 struct team_port
*port
;
1270 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1271 if (change
& IFF_PROMISC
) {
1272 inc
= dev
->flags
& IFF_PROMISC
? 1 : -1;
1273 dev_set_promiscuity(port
->dev
, inc
);
1275 if (change
& IFF_ALLMULTI
) {
1276 inc
= dev
->flags
& IFF_ALLMULTI
? 1 : -1;
1277 dev_set_allmulti(port
->dev
, inc
);
1283 static void team_set_rx_mode(struct net_device
*dev
)
1285 struct team
*team
= netdev_priv(dev
);
1286 struct team_port
*port
;
1289 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1290 dev_uc_sync(port
->dev
, dev
);
1291 dev_mc_sync(port
->dev
, dev
);
1296 static int team_set_mac_address(struct net_device
*dev
, void *p
)
1298 struct team
*team
= netdev_priv(dev
);
1299 struct team_port
*port
;
1302 err
= eth_mac_addr(dev
, p
);
1306 list_for_each_entry_rcu(port
, &team
->port_list
, list
)
1307 if (team
->ops
.port_change_mac
)
1308 team
->ops
.port_change_mac(team
, port
);
1313 static int team_change_mtu(struct net_device
*dev
, int new_mtu
)
1315 struct team
*team
= netdev_priv(dev
);
1316 struct team_port
*port
;
1320 * Alhough this is reader, it's guarded by team lock. It's not possible
1321 * to traverse list in reverse under rcu_read_lock
1323 mutex_lock(&team
->lock
);
1324 list_for_each_entry(port
, &team
->port_list
, list
) {
1325 err
= dev_set_mtu(port
->dev
, new_mtu
);
1327 netdev_err(dev
, "Device %s failed to change mtu",
1332 mutex_unlock(&team
->lock
);
1339 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1340 dev_set_mtu(port
->dev
, dev
->mtu
);
1341 mutex_unlock(&team
->lock
);
1346 static struct rtnl_link_stats64
*
1347 team_get_stats64(struct net_device
*dev
, struct rtnl_link_stats64
*stats
)
1349 struct team
*team
= netdev_priv(dev
);
1350 struct team_pcpu_stats
*p
;
1351 u64 rx_packets
, rx_bytes
, rx_multicast
, tx_packets
, tx_bytes
;
1352 u32 rx_dropped
= 0, tx_dropped
= 0;
1356 for_each_possible_cpu(i
) {
1357 p
= per_cpu_ptr(team
->pcpu_stats
, i
);
1359 start
= u64_stats_fetch_begin_bh(&p
->syncp
);
1360 rx_packets
= p
->rx_packets
;
1361 rx_bytes
= p
->rx_bytes
;
1362 rx_multicast
= p
->rx_multicast
;
1363 tx_packets
= p
->tx_packets
;
1364 tx_bytes
= p
->tx_bytes
;
1365 } while (u64_stats_fetch_retry_bh(&p
->syncp
, start
));
1367 stats
->rx_packets
+= rx_packets
;
1368 stats
->rx_bytes
+= rx_bytes
;
1369 stats
->multicast
+= rx_multicast
;
1370 stats
->tx_packets
+= tx_packets
;
1371 stats
->tx_bytes
+= tx_bytes
;
1373 * rx_dropped & tx_dropped are u32, updated
1374 * without syncp protection.
1376 rx_dropped
+= p
->rx_dropped
;
1377 tx_dropped
+= p
->tx_dropped
;
1379 stats
->rx_dropped
= rx_dropped
;
1380 stats
->tx_dropped
= tx_dropped
;
1384 static int team_vlan_rx_add_vid(struct net_device
*dev
, uint16_t vid
)
1386 struct team
*team
= netdev_priv(dev
);
1387 struct team_port
*port
;
1391 * Alhough this is reader, it's guarded by team lock. It's not possible
1392 * to traverse list in reverse under rcu_read_lock
1394 mutex_lock(&team
->lock
);
1395 list_for_each_entry(port
, &team
->port_list
, list
) {
1396 err
= vlan_vid_add(port
->dev
, vid
);
1400 mutex_unlock(&team
->lock
);
1405 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1406 vlan_vid_del(port
->dev
, vid
);
1407 mutex_unlock(&team
->lock
);
1412 static int team_vlan_rx_kill_vid(struct net_device
*dev
, uint16_t vid
)
1414 struct team
*team
= netdev_priv(dev
);
1415 struct team_port
*port
;
1418 list_for_each_entry_rcu(port
, &team
->port_list
, list
)
1419 vlan_vid_del(port
->dev
, vid
);
1425 #ifdef CONFIG_NET_POLL_CONTROLLER
1426 static void team_poll_controller(struct net_device
*dev
)
1430 static void __team_netpoll_cleanup(struct team
*team
)
1432 struct team_port
*port
;
1434 list_for_each_entry(port
, &team
->port_list
, list
)
1435 team_port_disable_netpoll(port
);
1438 static void team_netpoll_cleanup(struct net_device
*dev
)
1440 struct team
*team
= netdev_priv(dev
);
1442 mutex_lock(&team
->lock
);
1443 __team_netpoll_cleanup(team
);
1444 mutex_unlock(&team
->lock
);
1447 static int team_netpoll_setup(struct net_device
*dev
,
1448 struct netpoll_info
*npifo
, gfp_t gfp
)
1450 struct team
*team
= netdev_priv(dev
);
1451 struct team_port
*port
;
1454 mutex_lock(&team
->lock
);
1455 list_for_each_entry(port
, &team
->port_list
, list
) {
1456 err
= team_port_enable_netpoll(team
, port
, gfp
);
1458 __team_netpoll_cleanup(team
);
1462 mutex_unlock(&team
->lock
);
1467 static int team_add_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1469 struct team
*team
= netdev_priv(dev
);
1472 mutex_lock(&team
->lock
);
1473 err
= team_port_add(team
, port_dev
);
1474 mutex_unlock(&team
->lock
);
1478 static int team_del_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1480 struct team
*team
= netdev_priv(dev
);
1483 mutex_lock(&team
->lock
);
1484 err
= team_port_del(team
, port_dev
);
1485 mutex_unlock(&team
->lock
);
1489 static netdev_features_t
team_fix_features(struct net_device
*dev
,
1490 netdev_features_t features
)
1492 struct team_port
*port
;
1493 struct team
*team
= netdev_priv(dev
);
1494 netdev_features_t mask
;
1497 features
&= ~NETIF_F_ONE_FOR_ALL
;
1498 features
|= NETIF_F_ALL_FOR_ALL
;
1501 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1502 features
= netdev_increment_features(features
,
1503 port
->dev
->features
,
1510 static const struct net_device_ops team_netdev_ops
= {
1511 .ndo_init
= team_init
,
1512 .ndo_uninit
= team_uninit
,
1513 .ndo_open
= team_open
,
1514 .ndo_stop
= team_close
,
1515 .ndo_start_xmit
= team_xmit
,
1516 .ndo_select_queue
= team_select_queue
,
1517 .ndo_change_rx_flags
= team_change_rx_flags
,
1518 .ndo_set_rx_mode
= team_set_rx_mode
,
1519 .ndo_set_mac_address
= team_set_mac_address
,
1520 .ndo_change_mtu
= team_change_mtu
,
1521 .ndo_get_stats64
= team_get_stats64
,
1522 .ndo_vlan_rx_add_vid
= team_vlan_rx_add_vid
,
1523 .ndo_vlan_rx_kill_vid
= team_vlan_rx_kill_vid
,
1524 #ifdef CONFIG_NET_POLL_CONTROLLER
1525 .ndo_poll_controller
= team_poll_controller
,
1526 .ndo_netpoll_setup
= team_netpoll_setup
,
1527 .ndo_netpoll_cleanup
= team_netpoll_cleanup
,
1529 .ndo_add_slave
= team_add_slave
,
1530 .ndo_del_slave
= team_del_slave
,
1531 .ndo_fix_features
= team_fix_features
,
1535 /***********************
1536 * rt netlink interface
1537 ***********************/
1539 static void team_setup(struct net_device
*dev
)
1543 dev
->netdev_ops
= &team_netdev_ops
;
1544 dev
->destructor
= team_destructor
;
1545 dev
->tx_queue_len
= 0;
1546 dev
->flags
|= IFF_MULTICAST
;
1547 dev
->priv_flags
&= ~(IFF_XMIT_DST_RELEASE
| IFF_TX_SKB_SHARING
);
1550 * Indicate we support unicast address filtering. That way core won't
1551 * bring us to promisc mode in case a unicast addr is added.
1552 * Let this up to underlay drivers.
1554 dev
->priv_flags
|= IFF_UNICAST_FLT
| IFF_LIVE_ADDR_CHANGE
;
1556 dev
->features
|= NETIF_F_LLTX
;
1557 dev
->features
|= NETIF_F_GRO
;
1558 dev
->hw_features
= NETIF_F_HW_VLAN_TX
|
1559 NETIF_F_HW_VLAN_RX
|
1560 NETIF_F_HW_VLAN_FILTER
;
1562 dev
->features
|= dev
->hw_features
;
1565 static int team_newlink(struct net
*src_net
, struct net_device
*dev
,
1566 struct nlattr
*tb
[], struct nlattr
*data
[])
1570 if (tb
[IFLA_ADDRESS
] == NULL
)
1571 eth_hw_addr_random(dev
);
1573 err
= register_netdevice(dev
);
1580 static int team_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
1582 if (tb
[IFLA_ADDRESS
]) {
1583 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
1585 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
1586 return -EADDRNOTAVAIL
;
1591 static unsigned int team_get_num_tx_queues(void)
1593 return TEAM_DEFAULT_NUM_TX_QUEUES
;
1596 static unsigned int team_get_num_rx_queues(void)
1598 return TEAM_DEFAULT_NUM_RX_QUEUES
;
1601 static struct rtnl_link_ops team_link_ops __read_mostly
= {
1603 .priv_size
= sizeof(struct team
),
1604 .setup
= team_setup
,
1605 .newlink
= team_newlink
,
1606 .validate
= team_validate
,
1607 .get_num_tx_queues
= team_get_num_tx_queues
,
1608 .get_num_rx_queues
= team_get_num_rx_queues
,
1612 /***********************************
1613 * Generic netlink custom interface
1614 ***********************************/
1616 static struct genl_family team_nl_family
= {
1617 .id
= GENL_ID_GENERATE
,
1618 .name
= TEAM_GENL_NAME
,
1619 .version
= TEAM_GENL_VERSION
,
1620 .maxattr
= TEAM_ATTR_MAX
,
1624 static const struct nla_policy team_nl_policy
[TEAM_ATTR_MAX
+ 1] = {
1625 [TEAM_ATTR_UNSPEC
] = { .type
= NLA_UNSPEC
, },
1626 [TEAM_ATTR_TEAM_IFINDEX
] = { .type
= NLA_U32
},
1627 [TEAM_ATTR_LIST_OPTION
] = { .type
= NLA_NESTED
},
1628 [TEAM_ATTR_LIST_PORT
] = { .type
= NLA_NESTED
},
1631 static const struct nla_policy
1632 team_nl_option_policy
[TEAM_ATTR_OPTION_MAX
+ 1] = {
1633 [TEAM_ATTR_OPTION_UNSPEC
] = { .type
= NLA_UNSPEC
, },
1634 [TEAM_ATTR_OPTION_NAME
] = {
1636 .len
= TEAM_STRING_MAX_LEN
,
1638 [TEAM_ATTR_OPTION_CHANGED
] = { .type
= NLA_FLAG
},
1639 [TEAM_ATTR_OPTION_TYPE
] = { .type
= NLA_U8
},
1640 [TEAM_ATTR_OPTION_DATA
] = { .type
= NLA_BINARY
},
1643 static int team_nl_cmd_noop(struct sk_buff
*skb
, struct genl_info
*info
)
1645 struct sk_buff
*msg
;
1649 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1653 hdr
= genlmsg_put(msg
, info
->snd_pid
, info
->snd_seq
,
1654 &team_nl_family
, 0, TEAM_CMD_NOOP
);
1660 genlmsg_end(msg
, hdr
);
1662 return genlmsg_unicast(genl_info_net(info
), msg
, info
->snd_pid
);
1671 * Netlink cmd functions should be locked by following two functions.
1672 * Since dev gets held here, that ensures dev won't disappear in between.
1674 static struct team
*team_nl_team_get(struct genl_info
*info
)
1676 struct net
*net
= genl_info_net(info
);
1678 struct net_device
*dev
;
1681 if (!info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
])
1684 ifindex
= nla_get_u32(info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
]);
1685 dev
= dev_get_by_index(net
, ifindex
);
1686 if (!dev
|| dev
->netdev_ops
!= &team_netdev_ops
) {
1692 team
= netdev_priv(dev
);
1693 mutex_lock(&team
->lock
);
1697 static void team_nl_team_put(struct team
*team
)
1699 mutex_unlock(&team
->lock
);
1703 static int team_nl_send_generic(struct genl_info
*info
, struct team
*team
,
1704 int (*fill_func
)(struct sk_buff
*skb
,
1705 struct genl_info
*info
,
1706 int flags
, struct team
*team
))
1708 struct sk_buff
*skb
;
1711 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1715 err
= fill_func(skb
, info
, NLM_F_ACK
, team
);
1719 err
= genlmsg_unicast(genl_info_net(info
), skb
, info
->snd_pid
);
1727 typedef int team_nl_send_func_t(struct sk_buff
*skb
,
1728 struct team
*team
, u32 pid
);
1730 static int team_nl_send_unicast(struct sk_buff
*skb
, struct team
*team
, u32 pid
)
1732 return genlmsg_unicast(dev_net(team
->dev
), skb
, pid
);
1735 static int team_nl_fill_one_option_get(struct sk_buff
*skb
, struct team
*team
,
1736 struct team_option_inst
*opt_inst
)
1738 struct nlattr
*option_item
;
1739 struct team_option
*option
= opt_inst
->option
;
1740 struct team_option_inst_info
*opt_inst_info
= &opt_inst
->info
;
1741 struct team_gsetter_ctx ctx
;
1744 ctx
.info
= opt_inst_info
;
1745 err
= team_option_get(team
, opt_inst
, &ctx
);
1749 option_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_OPTION
);
1753 if (nla_put_string(skb
, TEAM_ATTR_OPTION_NAME
, option
->name
))
1755 if (opt_inst_info
->port
&&
1756 nla_put_u32(skb
, TEAM_ATTR_OPTION_PORT_IFINDEX
,
1757 opt_inst_info
->port
->dev
->ifindex
))
1759 if (opt_inst
->option
->array_size
&&
1760 nla_put_u32(skb
, TEAM_ATTR_OPTION_ARRAY_INDEX
,
1761 opt_inst_info
->array_index
))
1764 switch (option
->type
) {
1765 case TEAM_OPTION_TYPE_U32
:
1766 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_U32
))
1768 if (nla_put_u32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.u32_val
))
1771 case TEAM_OPTION_TYPE_STRING
:
1772 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_STRING
))
1774 if (nla_put_string(skb
, TEAM_ATTR_OPTION_DATA
,
1778 case TEAM_OPTION_TYPE_BINARY
:
1779 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_BINARY
))
1781 if (nla_put(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.bin_val
.len
,
1782 ctx
.data
.bin_val
.ptr
))
1785 case TEAM_OPTION_TYPE_BOOL
:
1786 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_FLAG
))
1788 if (ctx
.data
.bool_val
&&
1789 nla_put_flag(skb
, TEAM_ATTR_OPTION_DATA
))
1795 if (opt_inst
->removed
&& nla_put_flag(skb
, TEAM_ATTR_OPTION_REMOVED
))
1797 if (opt_inst
->changed
) {
1798 if (nla_put_flag(skb
, TEAM_ATTR_OPTION_CHANGED
))
1800 opt_inst
->changed
= false;
1802 nla_nest_end(skb
, option_item
);
1806 nla_nest_cancel(skb
, option_item
);
1810 static int __send_and_alloc_skb(struct sk_buff
**pskb
,
1811 struct team
*team
, u32 pid
,
1812 team_nl_send_func_t
*send_func
)
1817 err
= send_func(*pskb
, team
, pid
);
1821 *pskb
= genlmsg_new(GENLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
1827 static int team_nl_send_options_get(struct team
*team
, u32 pid
, u32 seq
,
1828 int flags
, team_nl_send_func_t
*send_func
,
1829 struct list_head
*sel_opt_inst_list
)
1831 struct nlattr
*option_list
;
1832 struct nlmsghdr
*nlh
;
1834 struct team_option_inst
*opt_inst
;
1836 struct sk_buff
*skb
= NULL
;
1840 opt_inst
= list_first_entry(sel_opt_inst_list
,
1841 struct team_option_inst
, tmp_list
);
1844 err
= __send_and_alloc_skb(&skb
, team
, pid
, send_func
);
1848 hdr
= genlmsg_put(skb
, pid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
1849 TEAM_CMD_OPTIONS_GET
);
1851 return PTR_ERR(hdr
);
1853 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
1854 goto nla_put_failure
;
1855 option_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_OPTION
);
1857 goto nla_put_failure
;
1861 list_for_each_entry_from(opt_inst
, sel_opt_inst_list
, tmp_list
) {
1862 err
= team_nl_fill_one_option_get(skb
, team
, opt_inst
);
1864 if (err
== -EMSGSIZE
) {
1875 nla_nest_end(skb
, option_list
);
1876 genlmsg_end(skb
, hdr
);
1881 nlh
= nlmsg_put(skb
, pid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
1883 err
= __send_and_alloc_skb(&skb
, team
, pid
, send_func
);
1889 return send_func(skb
, team
, pid
);
1894 genlmsg_cancel(skb
, hdr
);
1899 static int team_nl_cmd_options_get(struct sk_buff
*skb
, struct genl_info
*info
)
1902 struct team_option_inst
*opt_inst
;
1904 LIST_HEAD(sel_opt_inst_list
);
1906 team
= team_nl_team_get(info
);
1910 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
)
1911 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
1912 err
= team_nl_send_options_get(team
, info
->snd_pid
, info
->snd_seq
,
1913 NLM_F_ACK
, team_nl_send_unicast
,
1914 &sel_opt_inst_list
);
1916 team_nl_team_put(team
);
1921 static int team_nl_send_event_options_get(struct team
*team
,
1922 struct list_head
*sel_opt_inst_list
);
1924 static int team_nl_cmd_options_set(struct sk_buff
*skb
, struct genl_info
*info
)
1929 struct nlattr
*nl_option
;
1930 LIST_HEAD(opt_inst_list
);
1932 team
= team_nl_team_get(info
);
1937 if (!info
->attrs
[TEAM_ATTR_LIST_OPTION
]) {
1942 nla_for_each_nested(nl_option
, info
->attrs
[TEAM_ATTR_LIST_OPTION
], i
) {
1943 struct nlattr
*opt_attrs
[TEAM_ATTR_OPTION_MAX
+ 1];
1944 struct nlattr
*attr
;
1945 struct nlattr
*attr_data
;
1946 enum team_option_type opt_type
;
1947 int opt_port_ifindex
= 0; /* != 0 for per-port options */
1948 u32 opt_array_index
= 0;
1949 bool opt_is_array
= false;
1950 struct team_option_inst
*opt_inst
;
1952 bool opt_found
= false;
1954 if (nla_type(nl_option
) != TEAM_ATTR_ITEM_OPTION
) {
1958 err
= nla_parse_nested(opt_attrs
, TEAM_ATTR_OPTION_MAX
,
1959 nl_option
, team_nl_option_policy
);
1962 if (!opt_attrs
[TEAM_ATTR_OPTION_NAME
] ||
1963 !opt_attrs
[TEAM_ATTR_OPTION_TYPE
]) {
1967 switch (nla_get_u8(opt_attrs
[TEAM_ATTR_OPTION_TYPE
])) {
1969 opt_type
= TEAM_OPTION_TYPE_U32
;
1972 opt_type
= TEAM_OPTION_TYPE_STRING
;
1975 opt_type
= TEAM_OPTION_TYPE_BINARY
;
1978 opt_type
= TEAM_OPTION_TYPE_BOOL
;
1984 attr_data
= opt_attrs
[TEAM_ATTR_OPTION_DATA
];
1985 if (opt_type
!= TEAM_OPTION_TYPE_BOOL
&& !attr_data
) {
1990 opt_name
= nla_data(opt_attrs
[TEAM_ATTR_OPTION_NAME
]);
1991 attr
= opt_attrs
[TEAM_ATTR_OPTION_PORT_IFINDEX
];
1993 opt_port_ifindex
= nla_get_u32(attr
);
1995 attr
= opt_attrs
[TEAM_ATTR_OPTION_ARRAY_INDEX
];
1997 opt_is_array
= true;
1998 opt_array_index
= nla_get_u32(attr
);
2001 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2002 struct team_option
*option
= opt_inst
->option
;
2003 struct team_gsetter_ctx ctx
;
2004 struct team_option_inst_info
*opt_inst_info
;
2007 opt_inst_info
= &opt_inst
->info
;
2008 tmp_ifindex
= opt_inst_info
->port
?
2009 opt_inst_info
->port
->dev
->ifindex
: 0;
2010 if (option
->type
!= opt_type
||
2011 strcmp(option
->name
, opt_name
) ||
2012 tmp_ifindex
!= opt_port_ifindex
||
2013 (option
->array_size
&& !opt_is_array
) ||
2014 opt_inst_info
->array_index
!= opt_array_index
)
2017 ctx
.info
= opt_inst_info
;
2019 case TEAM_OPTION_TYPE_U32
:
2020 ctx
.data
.u32_val
= nla_get_u32(attr_data
);
2022 case TEAM_OPTION_TYPE_STRING
:
2023 if (nla_len(attr_data
) > TEAM_STRING_MAX_LEN
) {
2027 ctx
.data
.str_val
= nla_data(attr_data
);
2029 case TEAM_OPTION_TYPE_BINARY
:
2030 ctx
.data
.bin_val
.len
= nla_len(attr_data
);
2031 ctx
.data
.bin_val
.ptr
= nla_data(attr_data
);
2033 case TEAM_OPTION_TYPE_BOOL
:
2034 ctx
.data
.bool_val
= attr_data
? true : false;
2039 err
= team_option_set(team
, opt_inst
, &ctx
);
2042 opt_inst
->changed
= true;
2043 list_add(&opt_inst
->tmp_list
, &opt_inst_list
);
2051 err
= team_nl_send_event_options_get(team
, &opt_inst_list
);
2054 team_nl_team_put(team
);
2059 static int team_nl_fill_port_list_get(struct sk_buff
*skb
,
2060 u32 pid
, u32 seq
, int flags
,
2064 struct nlattr
*port_list
;
2066 struct team_port
*port
;
2068 hdr
= genlmsg_put(skb
, pid
, seq
, &team_nl_family
, flags
,
2069 TEAM_CMD_PORT_LIST_GET
);
2071 return PTR_ERR(hdr
);
2073 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2074 goto nla_put_failure
;
2075 port_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_PORT
);
2077 goto nla_put_failure
;
2079 list_for_each_entry(port
, &team
->port_list
, list
) {
2080 struct nlattr
*port_item
;
2082 /* Include only changed ports if fill all mode is not on */
2083 if (!fillall
&& !port
->changed
)
2085 port_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_PORT
);
2087 goto nla_put_failure
;
2088 if (nla_put_u32(skb
, TEAM_ATTR_PORT_IFINDEX
, port
->dev
->ifindex
))
2089 goto nla_put_failure
;
2090 if (port
->changed
) {
2091 if (nla_put_flag(skb
, TEAM_ATTR_PORT_CHANGED
))
2092 goto nla_put_failure
;
2093 port
->changed
= false;
2095 if ((port
->removed
&&
2096 nla_put_flag(skb
, TEAM_ATTR_PORT_REMOVED
)) ||
2097 (port
->state
.linkup
&&
2098 nla_put_flag(skb
, TEAM_ATTR_PORT_LINKUP
)) ||
2099 nla_put_u32(skb
, TEAM_ATTR_PORT_SPEED
, port
->state
.speed
) ||
2100 nla_put_u8(skb
, TEAM_ATTR_PORT_DUPLEX
, port
->state
.duplex
))
2101 goto nla_put_failure
;
2102 nla_nest_end(skb
, port_item
);
2105 nla_nest_end(skb
, port_list
);
2106 return genlmsg_end(skb
, hdr
);
2109 genlmsg_cancel(skb
, hdr
);
2113 static int team_nl_fill_port_list_get_all(struct sk_buff
*skb
,
2114 struct genl_info
*info
, int flags
,
2117 return team_nl_fill_port_list_get(skb
, info
->snd_pid
,
2118 info
->snd_seq
, NLM_F_ACK
,
2122 static int team_nl_cmd_port_list_get(struct sk_buff
*skb
,
2123 struct genl_info
*info
)
2128 team
= team_nl_team_get(info
);
2132 err
= team_nl_send_generic(info
, team
, team_nl_fill_port_list_get_all
);
2134 team_nl_team_put(team
);
2139 static struct genl_ops team_nl_ops
[] = {
2141 .cmd
= TEAM_CMD_NOOP
,
2142 .doit
= team_nl_cmd_noop
,
2143 .policy
= team_nl_policy
,
2146 .cmd
= TEAM_CMD_OPTIONS_SET
,
2147 .doit
= team_nl_cmd_options_set
,
2148 .policy
= team_nl_policy
,
2149 .flags
= GENL_ADMIN_PERM
,
2152 .cmd
= TEAM_CMD_OPTIONS_GET
,
2153 .doit
= team_nl_cmd_options_get
,
2154 .policy
= team_nl_policy
,
2155 .flags
= GENL_ADMIN_PERM
,
2158 .cmd
= TEAM_CMD_PORT_LIST_GET
,
2159 .doit
= team_nl_cmd_port_list_get
,
2160 .policy
= team_nl_policy
,
2161 .flags
= GENL_ADMIN_PERM
,
2165 static struct genl_multicast_group team_change_event_mcgrp
= {
2166 .name
= TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME
,
2169 static int team_nl_send_multicast(struct sk_buff
*skb
,
2170 struct team
*team
, u32 pid
)
2172 return genlmsg_multicast_netns(dev_net(team
->dev
), skb
, 0,
2173 team_change_event_mcgrp
.id
, GFP_KERNEL
);
2176 static int team_nl_send_event_options_get(struct team
*team
,
2177 struct list_head
*sel_opt_inst_list
)
2179 return team_nl_send_options_get(team
, 0, 0, 0, team_nl_send_multicast
,
2183 static int team_nl_send_event_port_list_get(struct team
*team
)
2185 struct sk_buff
*skb
;
2187 struct net
*net
= dev_net(team
->dev
);
2189 skb
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2193 err
= team_nl_fill_port_list_get(skb
, 0, 0, 0, team
, false);
2197 err
= genlmsg_multicast_netns(net
, skb
, 0, team_change_event_mcgrp
.id
,
2206 static int team_nl_init(void)
2210 err
= genl_register_family_with_ops(&team_nl_family
, team_nl_ops
,
2211 ARRAY_SIZE(team_nl_ops
));
2215 err
= genl_register_mc_group(&team_nl_family
, &team_change_event_mcgrp
);
2217 goto err_change_event_grp_reg
;
2221 err_change_event_grp_reg
:
2222 genl_unregister_family(&team_nl_family
);
2227 static void team_nl_fini(void)
2229 genl_unregister_family(&team_nl_family
);
2237 static void __team_options_change_check(struct team
*team
)
2240 struct team_option_inst
*opt_inst
;
2241 LIST_HEAD(sel_opt_inst_list
);
2243 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2244 if (opt_inst
->changed
)
2245 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2247 err
= team_nl_send_event_options_get(team
, &sel_opt_inst_list
);
2249 netdev_warn(team
->dev
, "Failed to send options change via netlink (err %d)\n",
2253 /* rtnl lock is held */
2254 static void __team_port_change_check(struct team_port
*port
, bool linkup
)
2258 if (!port
->removed
&& port
->state
.linkup
== linkup
)
2261 port
->changed
= true;
2262 port
->state
.linkup
= linkup
;
2263 team_refresh_port_linkup(port
);
2265 struct ethtool_cmd ecmd
;
2267 err
= __ethtool_get_settings(port
->dev
, &ecmd
);
2269 port
->state
.speed
= ethtool_cmd_speed(&ecmd
);
2270 port
->state
.duplex
= ecmd
.duplex
;
2274 port
->state
.speed
= 0;
2275 port
->state
.duplex
= 0;
2278 err
= team_nl_send_event_port_list_get(port
->team
);
2280 netdev_warn(port
->team
->dev
, "Failed to send port change of device %s via netlink\n",
2285 static void team_port_change_check(struct team_port
*port
, bool linkup
)
2287 struct team
*team
= port
->team
;
2289 mutex_lock(&team
->lock
);
2290 __team_port_change_check(port
, linkup
);
2291 mutex_unlock(&team
->lock
);
2295 /************************************
2296 * Net device notifier event handler
2297 ************************************/
2299 static int team_device_event(struct notifier_block
*unused
,
2300 unsigned long event
, void *ptr
)
2302 struct net_device
*dev
= (struct net_device
*) ptr
;
2303 struct team_port
*port
;
2305 port
= team_port_get_rtnl(dev
);
2311 if (netif_carrier_ok(dev
))
2312 team_port_change_check(port
, true);
2314 team_port_change_check(port
, false);
2316 if (netif_running(port
->dev
))
2317 team_port_change_check(port
,
2318 !!netif_carrier_ok(port
->dev
));
2320 case NETDEV_UNREGISTER
:
2321 team_del_slave(port
->team
->dev
, dev
);
2323 case NETDEV_FEAT_CHANGE
:
2324 team_compute_features(port
->team
);
2326 case NETDEV_CHANGEMTU
:
2327 /* Forbid to change mtu of underlaying device */
2329 case NETDEV_PRE_TYPE_CHANGE
:
2330 /* Forbid to change type of underlaying device */
2336 static struct notifier_block team_notifier_block __read_mostly
= {
2337 .notifier_call
= team_device_event
,
2341 /***********************
2342 * Module init and exit
2343 ***********************/
2345 static int __init
team_module_init(void)
2349 register_netdevice_notifier(&team_notifier_block
);
2351 err
= rtnl_link_register(&team_link_ops
);
2355 err
= team_nl_init();
2362 rtnl_link_unregister(&team_link_ops
);
2365 unregister_netdevice_notifier(&team_notifier_block
);
2370 static void __exit
team_module_exit(void)
2373 rtnl_link_unregister(&team_link_ops
);
2374 unregister_netdevice_notifier(&team_notifier_block
);
2377 module_init(team_module_init
);
2378 module_exit(team_module_exit
);
2380 MODULE_LICENSE("GPL v2");
2381 MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
2382 MODULE_DESCRIPTION("Ethernet team device driver");
2383 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);