2 * drivers/net/team/team.c - Network team device driver
3 * Copyright (c) 2011 Jiri Pirko <jpirko@redhat.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
11 #include <linux/kernel.h>
12 #include <linux/types.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/rcupdate.h>
17 #include <linux/errno.h>
18 #include <linux/ctype.h>
19 #include <linux/notifier.h>
20 #include <linux/netdevice.h>
21 #include <linux/netpoll.h>
22 #include <linux/if_vlan.h>
23 #include <linux/if_arp.h>
24 #include <linux/socket.h>
25 #include <linux/etherdevice.h>
26 #include <linux/rtnetlink.h>
27 #include <net/rtnetlink.h>
28 #include <net/genetlink.h>
29 #include <net/netlink.h>
30 #include <net/sch_generic.h>
31 #include <generated/utsrelease.h>
32 #include <linux/if_team.h>
34 #define DRV_NAME "team"
41 #define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT)
43 static struct team_port
*team_port_get_rcu(const struct net_device
*dev
)
45 struct team_port
*port
= rcu_dereference(dev
->rx_handler_data
);
47 return team_port_exists(dev
) ? port
: NULL
;
50 static struct team_port
*team_port_get_rtnl(const struct net_device
*dev
)
52 struct team_port
*port
= rtnl_dereference(dev
->rx_handler_data
);
54 return team_port_exists(dev
) ? port
: NULL
;
58 * Since the ability to change device address for open port device is tested in
59 * team_port_add, this function can be called without control of return value
61 static int __set_port_dev_addr(struct net_device
*port_dev
,
62 const unsigned char *dev_addr
)
66 memcpy(addr
.sa_data
, dev_addr
, port_dev
->addr_len
);
67 addr
.sa_family
= port_dev
->type
;
68 return dev_set_mac_address(port_dev
, &addr
);
71 static int team_port_set_orig_dev_addr(struct team_port
*port
)
73 return __set_port_dev_addr(port
->dev
, port
->orig
.dev_addr
);
76 static int team_port_set_team_dev_addr(struct team
*team
,
77 struct team_port
*port
)
79 return __set_port_dev_addr(port
->dev
, team
->dev
->dev_addr
);
82 int team_modeop_port_enter(struct team
*team
, struct team_port
*port
)
84 return team_port_set_team_dev_addr(team
, port
);
86 EXPORT_SYMBOL(team_modeop_port_enter
);
88 void team_modeop_port_change_dev_addr(struct team
*team
,
89 struct team_port
*port
)
91 team_port_set_team_dev_addr(team
, port
);
93 EXPORT_SYMBOL(team_modeop_port_change_dev_addr
);
95 static void team_refresh_port_linkup(struct team_port
*port
)
97 port
->linkup
= port
->user
.linkup_enabled
? port
->user
.linkup
:
106 struct team_option_inst
{ /* One for each option instance */
107 struct list_head list
;
108 struct list_head tmp_list
;
109 struct team_option
*option
;
110 struct team_option_inst_info info
;
115 static struct team_option
*__team_find_option(struct team
*team
,
116 const char *opt_name
)
118 struct team_option
*option
;
120 list_for_each_entry(option
, &team
->option_list
, list
) {
121 if (strcmp(option
->name
, opt_name
) == 0)
127 static void __team_option_inst_del(struct team_option_inst
*opt_inst
)
129 list_del(&opt_inst
->list
);
133 static void __team_option_inst_del_option(struct team
*team
,
134 struct team_option
*option
)
136 struct team_option_inst
*opt_inst
, *tmp
;
138 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
139 if (opt_inst
->option
== option
)
140 __team_option_inst_del(opt_inst
);
144 static int __team_option_inst_add(struct team
*team
, struct team_option
*option
,
145 struct team_port
*port
)
147 struct team_option_inst
*opt_inst
;
148 unsigned int array_size
;
152 array_size
= option
->array_size
;
154 array_size
= 1; /* No array but still need one instance */
156 for (i
= 0; i
< array_size
; i
++) {
157 opt_inst
= kmalloc(sizeof(*opt_inst
), GFP_KERNEL
);
160 opt_inst
->option
= option
;
161 opt_inst
->info
.port
= port
;
162 opt_inst
->info
.array_index
= i
;
163 opt_inst
->changed
= true;
164 opt_inst
->removed
= false;
165 list_add_tail(&opt_inst
->list
, &team
->option_inst_list
);
167 err
= option
->init(team
, &opt_inst
->info
);
176 static int __team_option_inst_add_option(struct team
*team
,
177 struct team_option
*option
)
179 struct team_port
*port
;
182 if (!option
->per_port
) {
183 err
= __team_option_inst_add(team
, option
, NULL
);
185 goto inst_del_option
;
188 list_for_each_entry(port
, &team
->port_list
, list
) {
189 err
= __team_option_inst_add(team
, option
, port
);
191 goto inst_del_option
;
196 __team_option_inst_del_option(team
, option
);
200 static void __team_option_inst_mark_removed_option(struct team
*team
,
201 struct team_option
*option
)
203 struct team_option_inst
*opt_inst
;
205 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
206 if (opt_inst
->option
== option
) {
207 opt_inst
->changed
= true;
208 opt_inst
->removed
= true;
213 static void __team_option_inst_del_port(struct team
*team
,
214 struct team_port
*port
)
216 struct team_option_inst
*opt_inst
, *tmp
;
218 list_for_each_entry_safe(opt_inst
, tmp
, &team
->option_inst_list
, list
) {
219 if (opt_inst
->option
->per_port
&&
220 opt_inst
->info
.port
== port
)
221 __team_option_inst_del(opt_inst
);
225 static int __team_option_inst_add_port(struct team
*team
,
226 struct team_port
*port
)
228 struct team_option
*option
;
231 list_for_each_entry(option
, &team
->option_list
, list
) {
232 if (!option
->per_port
)
234 err
= __team_option_inst_add(team
, option
, port
);
241 __team_option_inst_del_port(team
, port
);
245 static void __team_option_inst_mark_removed_port(struct team
*team
,
246 struct team_port
*port
)
248 struct team_option_inst
*opt_inst
;
250 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
251 if (opt_inst
->info
.port
== port
) {
252 opt_inst
->changed
= true;
253 opt_inst
->removed
= true;
258 static int __team_options_register(struct team
*team
,
259 const struct team_option
*option
,
263 struct team_option
**dst_opts
;
266 dst_opts
= kzalloc(sizeof(struct team_option
*) * option_count
,
270 for (i
= 0; i
< option_count
; i
++, option
++) {
271 if (__team_find_option(team
, option
->name
)) {
275 dst_opts
[i
] = kmemdup(option
, sizeof(*option
), GFP_KERNEL
);
282 for (i
= 0; i
< option_count
; i
++) {
283 err
= __team_option_inst_add_option(team
, dst_opts
[i
]);
286 list_add_tail(&dst_opts
[i
]->list
, &team
->option_list
);
293 for (i
--; i
>= 0; i
--)
294 __team_option_inst_del_option(team
, dst_opts
[i
]);
296 i
= option_count
- 1;
298 for (i
--; i
>= 0; i
--)
305 static void __team_options_mark_removed(struct team
*team
,
306 const struct team_option
*option
,
311 for (i
= 0; i
< option_count
; i
++, option
++) {
312 struct team_option
*del_opt
;
314 del_opt
= __team_find_option(team
, option
->name
);
316 __team_option_inst_mark_removed_option(team
, del_opt
);
320 static void __team_options_unregister(struct team
*team
,
321 const struct team_option
*option
,
326 for (i
= 0; i
< option_count
; i
++, option
++) {
327 struct team_option
*del_opt
;
329 del_opt
= __team_find_option(team
, option
->name
);
331 __team_option_inst_del_option(team
, del_opt
);
332 list_del(&del_opt
->list
);
338 static void __team_options_change_check(struct team
*team
);
340 int team_options_register(struct team
*team
,
341 const struct team_option
*option
,
346 err
= __team_options_register(team
, option
, option_count
);
349 __team_options_change_check(team
);
352 EXPORT_SYMBOL(team_options_register
);
354 void team_options_unregister(struct team
*team
,
355 const struct team_option
*option
,
358 __team_options_mark_removed(team
, option
, option_count
);
359 __team_options_change_check(team
);
360 __team_options_unregister(team
, option
, option_count
);
362 EXPORT_SYMBOL(team_options_unregister
);
364 static int team_option_get(struct team
*team
,
365 struct team_option_inst
*opt_inst
,
366 struct team_gsetter_ctx
*ctx
)
368 if (!opt_inst
->option
->getter
)
370 return opt_inst
->option
->getter(team
, ctx
);
373 static int team_option_set(struct team
*team
,
374 struct team_option_inst
*opt_inst
,
375 struct team_gsetter_ctx
*ctx
)
377 if (!opt_inst
->option
->setter
)
379 return opt_inst
->option
->setter(team
, ctx
);
382 void team_option_inst_set_change(struct team_option_inst_info
*opt_inst_info
)
384 struct team_option_inst
*opt_inst
;
386 opt_inst
= container_of(opt_inst_info
, struct team_option_inst
, info
);
387 opt_inst
->changed
= true;
389 EXPORT_SYMBOL(team_option_inst_set_change
);
391 void team_options_change_check(struct team
*team
)
393 __team_options_change_check(team
);
395 EXPORT_SYMBOL(team_options_change_check
);
402 static LIST_HEAD(mode_list
);
403 static DEFINE_SPINLOCK(mode_list_lock
);
405 struct team_mode_item
{
406 struct list_head list
;
407 const struct team_mode
*mode
;
410 static struct team_mode_item
*__find_mode(const char *kind
)
412 struct team_mode_item
*mitem
;
414 list_for_each_entry(mitem
, &mode_list
, list
) {
415 if (strcmp(mitem
->mode
->kind
, kind
) == 0)
421 static bool is_good_mode_name(const char *name
)
423 while (*name
!= '\0') {
424 if (!isalpha(*name
) && !isdigit(*name
) && *name
!= '_')
431 int team_mode_register(const struct team_mode
*mode
)
434 struct team_mode_item
*mitem
;
436 if (!is_good_mode_name(mode
->kind
) ||
437 mode
->priv_size
> TEAM_MODE_PRIV_SIZE
)
440 mitem
= kmalloc(sizeof(*mitem
), GFP_KERNEL
);
444 spin_lock(&mode_list_lock
);
445 if (__find_mode(mode
->kind
)) {
451 list_add_tail(&mitem
->list
, &mode_list
);
453 spin_unlock(&mode_list_lock
);
456 EXPORT_SYMBOL(team_mode_register
);
458 void team_mode_unregister(const struct team_mode
*mode
)
460 struct team_mode_item
*mitem
;
462 spin_lock(&mode_list_lock
);
463 mitem
= __find_mode(mode
->kind
);
465 list_del_init(&mitem
->list
);
468 spin_unlock(&mode_list_lock
);
470 EXPORT_SYMBOL(team_mode_unregister
);
472 static const struct team_mode
*team_mode_get(const char *kind
)
474 struct team_mode_item
*mitem
;
475 const struct team_mode
*mode
= NULL
;
477 spin_lock(&mode_list_lock
);
478 mitem
= __find_mode(kind
);
480 spin_unlock(&mode_list_lock
);
481 request_module("team-mode-%s", kind
);
482 spin_lock(&mode_list_lock
);
483 mitem
= __find_mode(kind
);
487 if (!try_module_get(mode
->owner
))
491 spin_unlock(&mode_list_lock
);
495 static void team_mode_put(const struct team_mode
*mode
)
497 module_put(mode
->owner
);
500 static bool team_dummy_transmit(struct team
*team
, struct sk_buff
*skb
)
502 dev_kfree_skb_any(skb
);
506 static rx_handler_result_t
team_dummy_receive(struct team
*team
,
507 struct team_port
*port
,
510 return RX_HANDLER_ANOTHER
;
513 static const struct team_mode __team_no_mode
= {
517 static bool team_is_mode_set(struct team
*team
)
519 return team
->mode
!= &__team_no_mode
;
522 static void team_set_no_mode(struct team
*team
)
524 team
->user_carrier_enabled
= false;
525 team
->mode
= &__team_no_mode
;
528 static void team_adjust_ops(struct team
*team
)
531 * To avoid checks in rx/tx skb paths, ensure here that non-null and
532 * correct ops are always set.
535 if (!team
->en_port_count
|| !team_is_mode_set(team
) ||
536 !team
->mode
->ops
->transmit
)
537 team
->ops
.transmit
= team_dummy_transmit
;
539 team
->ops
.transmit
= team
->mode
->ops
->transmit
;
541 if (!team
->en_port_count
|| !team_is_mode_set(team
) ||
542 !team
->mode
->ops
->receive
)
543 team
->ops
.receive
= team_dummy_receive
;
545 team
->ops
.receive
= team
->mode
->ops
->receive
;
549 * We can benefit from the fact that it's ensured no port is present
550 * at the time of mode change. Therefore no packets are in fly so there's no
551 * need to set mode operations in any special way.
553 static int __team_change_mode(struct team
*team
,
554 const struct team_mode
*new_mode
)
556 /* Check if mode was previously set and do cleanup if so */
557 if (team_is_mode_set(team
)) {
558 void (*exit_op
)(struct team
*team
) = team
->ops
.exit
;
560 /* Clear ops area so no callback is called any longer */
561 memset(&team
->ops
, 0, sizeof(struct team_mode_ops
));
562 team_adjust_ops(team
);
566 team_mode_put(team
->mode
);
567 team_set_no_mode(team
);
568 /* zero private data area */
569 memset(&team
->mode_priv
, 0,
570 sizeof(struct team
) - offsetof(struct team
, mode_priv
));
576 if (new_mode
->ops
->init
) {
579 err
= new_mode
->ops
->init(team
);
584 team
->mode
= new_mode
;
585 memcpy(&team
->ops
, new_mode
->ops
, sizeof(struct team_mode_ops
));
586 team_adjust_ops(team
);
591 static int team_change_mode(struct team
*team
, const char *kind
)
593 const struct team_mode
*new_mode
;
594 struct net_device
*dev
= team
->dev
;
597 if (!list_empty(&team
->port_list
)) {
598 netdev_err(dev
, "No ports can be present during mode change\n");
602 if (team_is_mode_set(team
) && strcmp(team
->mode
->kind
, kind
) == 0) {
603 netdev_err(dev
, "Unable to change to the same mode the team is in\n");
607 new_mode
= team_mode_get(kind
);
609 netdev_err(dev
, "Mode \"%s\" not found\n", kind
);
613 err
= __team_change_mode(team
, new_mode
);
615 netdev_err(dev
, "Failed to change to mode \"%s\"\n", kind
);
616 team_mode_put(new_mode
);
620 netdev_info(dev
, "Mode changed to \"%s\"\n", kind
);
625 /*********************
627 *********************/
629 static void team_notify_peers_work(struct work_struct
*work
)
633 team
= container_of(work
, struct team
, notify_peers
.dw
.work
);
635 if (!rtnl_trylock()) {
636 schedule_delayed_work(&team
->notify_peers
.dw
, 0);
639 call_netdevice_notifiers(NETDEV_NOTIFY_PEERS
, team
->dev
);
641 if (!atomic_dec_and_test(&team
->notify_peers
.count_pending
))
642 schedule_delayed_work(&team
->notify_peers
.dw
,
643 msecs_to_jiffies(team
->notify_peers
.interval
));
646 static void team_notify_peers(struct team
*team
)
648 if (!team
->notify_peers
.count
|| !netif_running(team
->dev
))
650 atomic_add(team
->notify_peers
.count
, &team
->notify_peers
.count_pending
);
651 schedule_delayed_work(&team
->notify_peers
.dw
, 0);
654 static void team_notify_peers_init(struct team
*team
)
656 INIT_DELAYED_WORK(&team
->notify_peers
.dw
, team_notify_peers_work
);
659 static void team_notify_peers_fini(struct team
*team
)
661 cancel_delayed_work_sync(&team
->notify_peers
.dw
);
665 /*******************************
666 * Send multicast group rejoins
667 *******************************/
669 static void team_mcast_rejoin_work(struct work_struct
*work
)
673 team
= container_of(work
, struct team
, mcast_rejoin
.dw
.work
);
675 if (!rtnl_trylock()) {
676 schedule_delayed_work(&team
->mcast_rejoin
.dw
, 0);
679 call_netdevice_notifiers(NETDEV_RESEND_IGMP
, team
->dev
);
681 if (!atomic_dec_and_test(&team
->mcast_rejoin
.count_pending
))
682 schedule_delayed_work(&team
->mcast_rejoin
.dw
,
683 msecs_to_jiffies(team
->mcast_rejoin
.interval
));
686 static void team_mcast_rejoin(struct team
*team
)
688 if (!team
->mcast_rejoin
.count
|| !netif_running(team
->dev
))
690 atomic_add(team
->mcast_rejoin
.count
, &team
->mcast_rejoin
.count_pending
);
691 schedule_delayed_work(&team
->mcast_rejoin
.dw
, 0);
694 static void team_mcast_rejoin_init(struct team
*team
)
696 INIT_DELAYED_WORK(&team
->mcast_rejoin
.dw
, team_mcast_rejoin_work
);
699 static void team_mcast_rejoin_fini(struct team
*team
)
701 cancel_delayed_work_sync(&team
->mcast_rejoin
.dw
);
705 /************************
706 * Rx path frame handler
707 ************************/
709 /* note: already called with rcu_read_lock */
710 static rx_handler_result_t
team_handle_frame(struct sk_buff
**pskb
)
712 struct sk_buff
*skb
= *pskb
;
713 struct team_port
*port
;
715 rx_handler_result_t res
;
717 skb
= skb_share_check(skb
, GFP_ATOMIC
);
719 return RX_HANDLER_CONSUMED
;
723 port
= team_port_get_rcu(skb
->dev
);
725 if (!team_port_enabled(port
)) {
726 /* allow exact match delivery for disabled ports */
727 res
= RX_HANDLER_EXACT
;
729 res
= team
->ops
.receive(team
, port
, skb
);
731 if (res
== RX_HANDLER_ANOTHER
) {
732 struct team_pcpu_stats
*pcpu_stats
;
734 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
735 u64_stats_update_begin(&pcpu_stats
->syncp
);
736 pcpu_stats
->rx_packets
++;
737 pcpu_stats
->rx_bytes
+= skb
->len
;
738 if (skb
->pkt_type
== PACKET_MULTICAST
)
739 pcpu_stats
->rx_multicast
++;
740 u64_stats_update_end(&pcpu_stats
->syncp
);
742 skb
->dev
= team
->dev
;
744 this_cpu_inc(team
->pcpu_stats
->rx_dropped
);
751 /*************************************
752 * Multiqueue Tx port select override
753 *************************************/
755 static int team_queue_override_init(struct team
*team
)
757 struct list_head
*listarr
;
758 unsigned int queue_cnt
= team
->dev
->num_tx_queues
- 1;
763 listarr
= kmalloc(sizeof(struct list_head
) * queue_cnt
, GFP_KERNEL
);
766 team
->qom_lists
= listarr
;
767 for (i
= 0; i
< queue_cnt
; i
++)
768 INIT_LIST_HEAD(listarr
++);
772 static void team_queue_override_fini(struct team
*team
)
774 kfree(team
->qom_lists
);
777 static struct list_head
*__team_get_qom_list(struct team
*team
, u16 queue_id
)
779 return &team
->qom_lists
[queue_id
- 1];
783 * note: already called with rcu_read_lock
785 static bool team_queue_override_transmit(struct team
*team
, struct sk_buff
*skb
)
787 struct list_head
*qom_list
;
788 struct team_port
*port
;
790 if (!team
->queue_override_enabled
|| !skb
->queue_mapping
)
792 qom_list
= __team_get_qom_list(team
, skb
->queue_mapping
);
793 list_for_each_entry_rcu(port
, qom_list
, qom_list
) {
794 if (!team_dev_queue_xmit(team
, port
, skb
))
800 static void __team_queue_override_port_del(struct team
*team
,
801 struct team_port
*port
)
805 list_del_rcu(&port
->qom_list
);
808 static bool team_queue_override_port_has_gt_prio_than(struct team_port
*port
,
809 struct team_port
*cur
)
811 if (port
->priority
< cur
->priority
)
813 if (port
->priority
> cur
->priority
)
815 if (port
->index
< cur
->index
)
820 static void __team_queue_override_port_add(struct team
*team
,
821 struct team_port
*port
)
823 struct team_port
*cur
;
824 struct list_head
*qom_list
;
825 struct list_head
*node
;
829 qom_list
= __team_get_qom_list(team
, port
->queue_id
);
831 list_for_each_entry(cur
, qom_list
, qom_list
) {
832 if (team_queue_override_port_has_gt_prio_than(port
, cur
))
834 node
= &cur
->qom_list
;
836 list_add_tail_rcu(&port
->qom_list
, node
);
839 static void __team_queue_override_enabled_check(struct team
*team
)
841 struct team_port
*port
;
842 bool enabled
= false;
844 list_for_each_entry(port
, &team
->port_list
, list
) {
845 if (port
->queue_id
) {
850 if (enabled
== team
->queue_override_enabled
)
852 netdev_dbg(team
->dev
, "%s queue override\n",
853 enabled
? "Enabling" : "Disabling");
854 team
->queue_override_enabled
= enabled
;
857 static void team_queue_override_port_prio_changed(struct team
*team
,
858 struct team_port
*port
)
860 if (!port
->queue_id
|| team_port_enabled(port
))
862 __team_queue_override_port_del(team
, port
);
863 __team_queue_override_port_add(team
, port
);
864 __team_queue_override_enabled_check(team
);
867 static void team_queue_override_port_change_queue_id(struct team
*team
,
868 struct team_port
*port
,
871 if (team_port_enabled(port
)) {
872 __team_queue_override_port_del(team
, port
);
873 port
->queue_id
= new_queue_id
;
874 __team_queue_override_port_add(team
, port
);
875 __team_queue_override_enabled_check(team
);
877 port
->queue_id
= new_queue_id
;
881 static void team_queue_override_port_add(struct team
*team
,
882 struct team_port
*port
)
884 __team_queue_override_port_add(team
, port
);
885 __team_queue_override_enabled_check(team
);
888 static void team_queue_override_port_del(struct team
*team
,
889 struct team_port
*port
)
891 __team_queue_override_port_del(team
, port
);
892 __team_queue_override_enabled_check(team
);
900 static bool team_port_find(const struct team
*team
,
901 const struct team_port
*port
)
903 struct team_port
*cur
;
905 list_for_each_entry(cur
, &team
->port_list
, list
)
912 * Enable/disable port by adding to enabled port hashlist and setting
913 * port->index (Might be racy so reader could see incorrect ifindex when
914 * processing a flying packet, but that is not a problem). Write guarded
917 static void team_port_enable(struct team
*team
,
918 struct team_port
*port
)
920 if (team_port_enabled(port
))
922 port
->index
= team
->en_port_count
++;
923 hlist_add_head_rcu(&port
->hlist
,
924 team_port_index_hash(team
, port
->index
));
925 team_adjust_ops(team
);
926 team_queue_override_port_add(team
, port
);
927 if (team
->ops
.port_enabled
)
928 team
->ops
.port_enabled(team
, port
);
929 team_notify_peers(team
);
930 team_mcast_rejoin(team
);
933 static void __reconstruct_port_hlist(struct team
*team
, int rm_index
)
936 struct team_port
*port
;
938 for (i
= rm_index
+ 1; i
< team
->en_port_count
; i
++) {
939 port
= team_get_port_by_index(team
, i
);
940 hlist_del_rcu(&port
->hlist
);
942 hlist_add_head_rcu(&port
->hlist
,
943 team_port_index_hash(team
, port
->index
));
947 static void team_port_disable(struct team
*team
,
948 struct team_port
*port
)
950 if (!team_port_enabled(port
))
952 if (team
->ops
.port_disabled
)
953 team
->ops
.port_disabled(team
, port
);
954 hlist_del_rcu(&port
->hlist
);
955 __reconstruct_port_hlist(team
, port
->index
);
957 team
->en_port_count
--;
958 team_queue_override_port_del(team
, port
);
959 team_adjust_ops(team
);
960 team_notify_peers(team
);
961 team_mcast_rejoin(team
);
964 #define TEAM_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
965 NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
966 NETIF_F_HIGHDMA | NETIF_F_LRO)
968 static void __team_compute_features(struct team
*team
)
970 struct team_port
*port
;
971 u32 vlan_features
= TEAM_VLAN_FEATURES
& NETIF_F_ALL_FOR_ALL
;
972 unsigned short max_hard_header_len
= ETH_HLEN
;
973 unsigned int dst_release_flag
= IFF_XMIT_DST_RELEASE
|
974 IFF_XMIT_DST_RELEASE_PERM
;
976 list_for_each_entry(port
, &team
->port_list
, list
) {
977 vlan_features
= netdev_increment_features(vlan_features
,
978 port
->dev
->vlan_features
,
981 dst_release_flag
&= port
->dev
->priv_flags
;
982 if (port
->dev
->hard_header_len
> max_hard_header_len
)
983 max_hard_header_len
= port
->dev
->hard_header_len
;
986 team
->dev
->vlan_features
= vlan_features
;
987 team
->dev
->hard_header_len
= max_hard_header_len
;
989 team
->dev
->priv_flags
&= ~IFF_XMIT_DST_RELEASE
;
990 if (dst_release_flag
== (IFF_XMIT_DST_RELEASE
| IFF_XMIT_DST_RELEASE_PERM
))
991 team
->dev
->priv_flags
|= IFF_XMIT_DST_RELEASE
;
993 netdev_change_features(team
->dev
);
996 static void team_compute_features(struct team
*team
)
998 mutex_lock(&team
->lock
);
999 __team_compute_features(team
);
1000 mutex_unlock(&team
->lock
);
1003 static int team_port_enter(struct team
*team
, struct team_port
*port
)
1007 dev_hold(team
->dev
);
1008 if (team
->ops
.port_enter
) {
1009 err
= team
->ops
.port_enter(team
, port
);
1011 netdev_err(team
->dev
, "Device %s failed to enter team mode\n",
1013 goto err_port_enter
;
1025 static void team_port_leave(struct team
*team
, struct team_port
*port
)
1027 if (team
->ops
.port_leave
)
1028 team
->ops
.port_leave(team
, port
);
1032 #ifdef CONFIG_NET_POLL_CONTROLLER
1033 static int team_port_enable_netpoll(struct team
*team
, struct team_port
*port
)
1038 if (!team
->dev
->npinfo
)
1041 np
= kzalloc(sizeof(*np
), GFP_KERNEL
);
1045 err
= __netpoll_setup(np
, port
->dev
);
1054 static void team_port_disable_netpoll(struct team_port
*port
)
1056 struct netpoll
*np
= port
->np
;
1062 /* Wait for transmitting packets to finish before freeing. */
1063 synchronize_rcu_bh();
1064 __netpoll_cleanup(np
);
1068 static int team_port_enable_netpoll(struct team
*team
, struct team_port
*port
)
1072 static void team_port_disable_netpoll(struct team_port
*port
)
1077 static int team_upper_dev_link(struct net_device
*dev
,
1078 struct net_device
*port_dev
)
1082 err
= netdev_master_upper_dev_link(port_dev
, dev
);
1085 port_dev
->priv_flags
|= IFF_TEAM_PORT
;
1089 static void team_upper_dev_unlink(struct net_device
*dev
,
1090 struct net_device
*port_dev
)
1092 netdev_upper_dev_unlink(port_dev
, dev
);
1093 port_dev
->priv_flags
&= ~IFF_TEAM_PORT
;
1096 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
);
1097 static int team_dev_type_check_change(struct net_device
*dev
,
1098 struct net_device
*port_dev
);
1100 static int team_port_add(struct team
*team
, struct net_device
*port_dev
)
1102 struct net_device
*dev
= team
->dev
;
1103 struct team_port
*port
;
1104 char *portname
= port_dev
->name
;
1107 if (port_dev
->flags
& IFF_LOOPBACK
) {
1108 netdev_err(dev
, "Device %s is loopback device. Loopback devices can't be added as a team port\n",
1113 if (team_port_exists(port_dev
)) {
1114 netdev_err(dev
, "Device %s is already a port "
1115 "of a team device\n", portname
);
1119 if (port_dev
->features
& NETIF_F_VLAN_CHALLENGED
&&
1120 vlan_uses_dev(dev
)) {
1121 netdev_err(dev
, "Device %s is VLAN challenged and team device has VLAN set up\n",
1126 err
= team_dev_type_check_change(dev
, port_dev
);
1130 if (port_dev
->flags
& IFF_UP
) {
1131 netdev_err(dev
, "Device %s is up. Set it down before adding it as a team port\n",
1136 port
= kzalloc(sizeof(struct team_port
) + team
->mode
->port_priv_size
,
1141 port
->dev
= port_dev
;
1143 INIT_LIST_HEAD(&port
->qom_list
);
1145 port
->orig
.mtu
= port_dev
->mtu
;
1146 err
= dev_set_mtu(port_dev
, dev
->mtu
);
1148 netdev_dbg(dev
, "Error %d calling dev_set_mtu\n", err
);
1152 memcpy(port
->orig
.dev_addr
, port_dev
->dev_addr
, port_dev
->addr_len
);
1154 err
= team_port_enter(team
, port
);
1156 netdev_err(dev
, "Device %s failed to enter team mode\n",
1158 goto err_port_enter
;
1161 err
= dev_open(port_dev
);
1163 netdev_dbg(dev
, "Device %s opening failed\n",
1168 err
= vlan_vids_add_by_dev(port_dev
, dev
);
1170 netdev_err(dev
, "Failed to add vlan ids to device %s\n",
1175 err
= team_port_enable_netpoll(team
, port
);
1177 netdev_err(dev
, "Failed to enable netpoll on device %s\n",
1179 goto err_enable_netpoll
;
1182 if (!(dev
->features
& NETIF_F_LRO
))
1183 dev_disable_lro(port_dev
);
1185 err
= netdev_rx_handler_register(port_dev
, team_handle_frame
,
1188 netdev_err(dev
, "Device %s failed to register rx_handler\n",
1190 goto err_handler_register
;
1193 err
= team_upper_dev_link(dev
, port_dev
);
1195 netdev_err(dev
, "Device %s failed to set upper link\n",
1197 goto err_set_upper_link
;
1200 err
= __team_option_inst_add_port(team
, port
);
1202 netdev_err(dev
, "Device %s failed to add per-port options\n",
1204 goto err_option_port_add
;
1208 list_add_tail_rcu(&port
->list
, &team
->port_list
);
1209 team_port_enable(team
, port
);
1210 __team_compute_features(team
);
1211 __team_port_change_port_added(port
, !!netif_carrier_ok(port_dev
));
1212 __team_options_change_check(team
);
1214 netdev_info(dev
, "Port device %s added\n", portname
);
1218 err_option_port_add
:
1219 team_upper_dev_unlink(dev
, port_dev
);
1222 netdev_rx_handler_unregister(port_dev
);
1224 err_handler_register
:
1225 team_port_disable_netpoll(port
);
1228 vlan_vids_del_by_dev(port_dev
, dev
);
1231 dev_close(port_dev
);
1234 team_port_leave(team
, port
);
1235 team_port_set_orig_dev_addr(port
);
1238 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1246 static void __team_port_change_port_removed(struct team_port
*port
);
1248 static int team_port_del(struct team
*team
, struct net_device
*port_dev
)
1250 struct net_device
*dev
= team
->dev
;
1251 struct team_port
*port
;
1252 char *portname
= port_dev
->name
;
1254 port
= team_port_get_rtnl(port_dev
);
1255 if (!port
|| !team_port_find(team
, port
)) {
1256 netdev_err(dev
, "Device %s does not act as a port of this team\n",
1261 team_port_disable(team
, port
);
1262 list_del_rcu(&port
->list
);
1263 team_upper_dev_unlink(dev
, port_dev
);
1264 netdev_rx_handler_unregister(port_dev
);
1265 team_port_disable_netpoll(port
);
1266 vlan_vids_del_by_dev(port_dev
, dev
);
1267 dev_uc_unsync(port_dev
, dev
);
1268 dev_mc_unsync(port_dev
, dev
);
1269 dev_close(port_dev
);
1270 team_port_leave(team
, port
);
1272 __team_option_inst_mark_removed_port(team
, port
);
1273 __team_options_change_check(team
);
1274 __team_option_inst_del_port(team
, port
);
1275 __team_port_change_port_removed(port
);
1277 team_port_set_orig_dev_addr(port
);
1278 dev_set_mtu(port_dev
, port
->orig
.mtu
);
1279 kfree_rcu(port
, rcu
);
1280 netdev_info(dev
, "Port device %s removed\n", portname
);
1281 __team_compute_features(team
);
1291 static int team_mode_option_get(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1293 ctx
->data
.str_val
= team
->mode
->kind
;
1297 static int team_mode_option_set(struct team
*team
, struct team_gsetter_ctx
*ctx
)
1299 return team_change_mode(team
, ctx
->data
.str_val
);
1302 static int team_notify_peers_count_get(struct team
*team
,
1303 struct team_gsetter_ctx
*ctx
)
1305 ctx
->data
.u32_val
= team
->notify_peers
.count
;
1309 static int team_notify_peers_count_set(struct team
*team
,
1310 struct team_gsetter_ctx
*ctx
)
1312 team
->notify_peers
.count
= ctx
->data
.u32_val
;
1316 static int team_notify_peers_interval_get(struct team
*team
,
1317 struct team_gsetter_ctx
*ctx
)
1319 ctx
->data
.u32_val
= team
->notify_peers
.interval
;
1323 static int team_notify_peers_interval_set(struct team
*team
,
1324 struct team_gsetter_ctx
*ctx
)
1326 team
->notify_peers
.interval
= ctx
->data
.u32_val
;
1330 static int team_mcast_rejoin_count_get(struct team
*team
,
1331 struct team_gsetter_ctx
*ctx
)
1333 ctx
->data
.u32_val
= team
->mcast_rejoin
.count
;
1337 static int team_mcast_rejoin_count_set(struct team
*team
,
1338 struct team_gsetter_ctx
*ctx
)
1340 team
->mcast_rejoin
.count
= ctx
->data
.u32_val
;
1344 static int team_mcast_rejoin_interval_get(struct team
*team
,
1345 struct team_gsetter_ctx
*ctx
)
1347 ctx
->data
.u32_val
= team
->mcast_rejoin
.interval
;
1351 static int team_mcast_rejoin_interval_set(struct team
*team
,
1352 struct team_gsetter_ctx
*ctx
)
1354 team
->mcast_rejoin
.interval
= ctx
->data
.u32_val
;
1358 static int team_port_en_option_get(struct team
*team
,
1359 struct team_gsetter_ctx
*ctx
)
1361 struct team_port
*port
= ctx
->info
->port
;
1363 ctx
->data
.bool_val
= team_port_enabled(port
);
1367 static int team_port_en_option_set(struct team
*team
,
1368 struct team_gsetter_ctx
*ctx
)
1370 struct team_port
*port
= ctx
->info
->port
;
1372 if (ctx
->data
.bool_val
)
1373 team_port_enable(team
, port
);
1375 team_port_disable(team
, port
);
1379 static int team_user_linkup_option_get(struct team
*team
,
1380 struct team_gsetter_ctx
*ctx
)
1382 struct team_port
*port
= ctx
->info
->port
;
1384 ctx
->data
.bool_val
= port
->user
.linkup
;
1388 static void __team_carrier_check(struct team
*team
);
1390 static int team_user_linkup_option_set(struct team
*team
,
1391 struct team_gsetter_ctx
*ctx
)
1393 struct team_port
*port
= ctx
->info
->port
;
1395 port
->user
.linkup
= ctx
->data
.bool_val
;
1396 team_refresh_port_linkup(port
);
1397 __team_carrier_check(port
->team
);
1401 static int team_user_linkup_en_option_get(struct team
*team
,
1402 struct team_gsetter_ctx
*ctx
)
1404 struct team_port
*port
= ctx
->info
->port
;
1406 ctx
->data
.bool_val
= port
->user
.linkup_enabled
;
1410 static int team_user_linkup_en_option_set(struct team
*team
,
1411 struct team_gsetter_ctx
*ctx
)
1413 struct team_port
*port
= ctx
->info
->port
;
1415 port
->user
.linkup_enabled
= ctx
->data
.bool_val
;
1416 team_refresh_port_linkup(port
);
1417 __team_carrier_check(port
->team
);
1421 static int team_priority_option_get(struct team
*team
,
1422 struct team_gsetter_ctx
*ctx
)
1424 struct team_port
*port
= ctx
->info
->port
;
1426 ctx
->data
.s32_val
= port
->priority
;
1430 static int team_priority_option_set(struct team
*team
,
1431 struct team_gsetter_ctx
*ctx
)
1433 struct team_port
*port
= ctx
->info
->port
;
1434 s32 priority
= ctx
->data
.s32_val
;
1436 if (port
->priority
== priority
)
1438 port
->priority
= priority
;
1439 team_queue_override_port_prio_changed(team
, port
);
1443 static int team_queue_id_option_get(struct team
*team
,
1444 struct team_gsetter_ctx
*ctx
)
1446 struct team_port
*port
= ctx
->info
->port
;
1448 ctx
->data
.u32_val
= port
->queue_id
;
1452 static int team_queue_id_option_set(struct team
*team
,
1453 struct team_gsetter_ctx
*ctx
)
1455 struct team_port
*port
= ctx
->info
->port
;
1456 u16 new_queue_id
= ctx
->data
.u32_val
;
1458 if (port
->queue_id
== new_queue_id
)
1460 if (new_queue_id
>= team
->dev
->real_num_tx_queues
)
1462 team_queue_override_port_change_queue_id(team
, port
, new_queue_id
);
1466 static const struct team_option team_options
[] = {
1469 .type
= TEAM_OPTION_TYPE_STRING
,
1470 .getter
= team_mode_option_get
,
1471 .setter
= team_mode_option_set
,
1474 .name
= "notify_peers_count",
1475 .type
= TEAM_OPTION_TYPE_U32
,
1476 .getter
= team_notify_peers_count_get
,
1477 .setter
= team_notify_peers_count_set
,
1480 .name
= "notify_peers_interval",
1481 .type
= TEAM_OPTION_TYPE_U32
,
1482 .getter
= team_notify_peers_interval_get
,
1483 .setter
= team_notify_peers_interval_set
,
1486 .name
= "mcast_rejoin_count",
1487 .type
= TEAM_OPTION_TYPE_U32
,
1488 .getter
= team_mcast_rejoin_count_get
,
1489 .setter
= team_mcast_rejoin_count_set
,
1492 .name
= "mcast_rejoin_interval",
1493 .type
= TEAM_OPTION_TYPE_U32
,
1494 .getter
= team_mcast_rejoin_interval_get
,
1495 .setter
= team_mcast_rejoin_interval_set
,
1499 .type
= TEAM_OPTION_TYPE_BOOL
,
1501 .getter
= team_port_en_option_get
,
1502 .setter
= team_port_en_option_set
,
1505 .name
= "user_linkup",
1506 .type
= TEAM_OPTION_TYPE_BOOL
,
1508 .getter
= team_user_linkup_option_get
,
1509 .setter
= team_user_linkup_option_set
,
1512 .name
= "user_linkup_enabled",
1513 .type
= TEAM_OPTION_TYPE_BOOL
,
1515 .getter
= team_user_linkup_en_option_get
,
1516 .setter
= team_user_linkup_en_option_set
,
1520 .type
= TEAM_OPTION_TYPE_S32
,
1522 .getter
= team_priority_option_get
,
1523 .setter
= team_priority_option_set
,
1527 .type
= TEAM_OPTION_TYPE_U32
,
1529 .getter
= team_queue_id_option_get
,
1530 .setter
= team_queue_id_option_set
,
1534 static struct lock_class_key team_netdev_xmit_lock_key
;
1535 static struct lock_class_key team_netdev_addr_lock_key
;
1536 static struct lock_class_key team_tx_busylock_key
;
1538 static void team_set_lockdep_class_one(struct net_device
*dev
,
1539 struct netdev_queue
*txq
,
1542 lockdep_set_class(&txq
->_xmit_lock
, &team_netdev_xmit_lock_key
);
1545 static void team_set_lockdep_class(struct net_device
*dev
)
1547 lockdep_set_class(&dev
->addr_list_lock
, &team_netdev_addr_lock_key
);
1548 netdev_for_each_tx_queue(dev
, team_set_lockdep_class_one
, NULL
);
1549 dev
->qdisc_tx_busylock
= &team_tx_busylock_key
;
1552 static int team_init(struct net_device
*dev
)
1554 struct team
*team
= netdev_priv(dev
);
1559 mutex_init(&team
->lock
);
1560 team_set_no_mode(team
);
1562 team
->pcpu_stats
= netdev_alloc_pcpu_stats(struct team_pcpu_stats
);
1563 if (!team
->pcpu_stats
)
1566 for (i
= 0; i
< TEAM_PORT_HASHENTRIES
; i
++)
1567 INIT_HLIST_HEAD(&team
->en_port_hlist
[i
]);
1568 INIT_LIST_HEAD(&team
->port_list
);
1569 err
= team_queue_override_init(team
);
1571 goto err_team_queue_override_init
;
1573 team_adjust_ops(team
);
1575 INIT_LIST_HEAD(&team
->option_list
);
1576 INIT_LIST_HEAD(&team
->option_inst_list
);
1578 team_notify_peers_init(team
);
1579 team_mcast_rejoin_init(team
);
1581 err
= team_options_register(team
, team_options
, ARRAY_SIZE(team_options
));
1583 goto err_options_register
;
1584 netif_carrier_off(dev
);
1586 team_set_lockdep_class(dev
);
1590 err_options_register
:
1591 team_mcast_rejoin_fini(team
);
1592 team_notify_peers_fini(team
);
1593 team_queue_override_fini(team
);
1594 err_team_queue_override_init
:
1595 free_percpu(team
->pcpu_stats
);
1600 static void team_uninit(struct net_device
*dev
)
1602 struct team
*team
= netdev_priv(dev
);
1603 struct team_port
*port
;
1604 struct team_port
*tmp
;
1606 mutex_lock(&team
->lock
);
1607 list_for_each_entry_safe(port
, tmp
, &team
->port_list
, list
)
1608 team_port_del(team
, port
->dev
);
1610 __team_change_mode(team
, NULL
); /* cleanup */
1611 __team_options_unregister(team
, team_options
, ARRAY_SIZE(team_options
));
1612 team_mcast_rejoin_fini(team
);
1613 team_notify_peers_fini(team
);
1614 team_queue_override_fini(team
);
1615 mutex_unlock(&team
->lock
);
1618 static void team_destructor(struct net_device
*dev
)
1620 struct team
*team
= netdev_priv(dev
);
1622 free_percpu(team
->pcpu_stats
);
1626 static int team_open(struct net_device
*dev
)
1631 static int team_close(struct net_device
*dev
)
1637 * note: already called with rcu_read_lock
1639 static netdev_tx_t
team_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1641 struct team
*team
= netdev_priv(dev
);
1643 unsigned int len
= skb
->len
;
1645 tx_success
= team_queue_override_transmit(team
, skb
);
1647 tx_success
= team
->ops
.transmit(team
, skb
);
1649 struct team_pcpu_stats
*pcpu_stats
;
1651 pcpu_stats
= this_cpu_ptr(team
->pcpu_stats
);
1652 u64_stats_update_begin(&pcpu_stats
->syncp
);
1653 pcpu_stats
->tx_packets
++;
1654 pcpu_stats
->tx_bytes
+= len
;
1655 u64_stats_update_end(&pcpu_stats
->syncp
);
1657 this_cpu_inc(team
->pcpu_stats
->tx_dropped
);
1660 return NETDEV_TX_OK
;
1663 static u16
team_select_queue(struct net_device
*dev
, struct sk_buff
*skb
,
1664 void *accel_priv
, select_queue_fallback_t fallback
)
1667 * This helper function exists to help dev_pick_tx get the correct
1668 * destination queue. Using a helper function skips a call to
1669 * skb_tx_hash and will put the skbs in the queue we expect on their
1670 * way down to the team driver.
1672 u16 txq
= skb_rx_queue_recorded(skb
) ? skb_get_rx_queue(skb
) : 0;
1675 * Save the original txq to restore before passing to the driver
1677 qdisc_skb_cb(skb
)->slave_dev_queue_mapping
= skb
->queue_mapping
;
1679 if (unlikely(txq
>= dev
->real_num_tx_queues
)) {
1681 txq
-= dev
->real_num_tx_queues
;
1682 } while (txq
>= dev
->real_num_tx_queues
);
1687 static void team_change_rx_flags(struct net_device
*dev
, int change
)
1689 struct team
*team
= netdev_priv(dev
);
1690 struct team_port
*port
;
1694 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1695 if (change
& IFF_PROMISC
) {
1696 inc
= dev
->flags
& IFF_PROMISC
? 1 : -1;
1697 dev_set_promiscuity(port
->dev
, inc
);
1699 if (change
& IFF_ALLMULTI
) {
1700 inc
= dev
->flags
& IFF_ALLMULTI
? 1 : -1;
1701 dev_set_allmulti(port
->dev
, inc
);
1707 static void team_set_rx_mode(struct net_device
*dev
)
1709 struct team
*team
= netdev_priv(dev
);
1710 struct team_port
*port
;
1713 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1714 dev_uc_sync_multiple(port
->dev
, dev
);
1715 dev_mc_sync_multiple(port
->dev
, dev
);
1720 static int team_set_mac_address(struct net_device
*dev
, void *p
)
1722 struct sockaddr
*addr
= p
;
1723 struct team
*team
= netdev_priv(dev
);
1724 struct team_port
*port
;
1726 if (dev
->type
== ARPHRD_ETHER
&& !is_valid_ether_addr(addr
->sa_data
))
1727 return -EADDRNOTAVAIL
;
1728 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1730 list_for_each_entry_rcu(port
, &team
->port_list
, list
)
1731 if (team
->ops
.port_change_dev_addr
)
1732 team
->ops
.port_change_dev_addr(team
, port
);
1737 static int team_change_mtu(struct net_device
*dev
, int new_mtu
)
1739 struct team
*team
= netdev_priv(dev
);
1740 struct team_port
*port
;
1744 * Alhough this is reader, it's guarded by team lock. It's not possible
1745 * to traverse list in reverse under rcu_read_lock
1747 mutex_lock(&team
->lock
);
1748 team
->port_mtu_change_allowed
= true;
1749 list_for_each_entry(port
, &team
->port_list
, list
) {
1750 err
= dev_set_mtu(port
->dev
, new_mtu
);
1752 netdev_err(dev
, "Device %s failed to change mtu",
1757 team
->port_mtu_change_allowed
= false;
1758 mutex_unlock(&team
->lock
);
1765 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1766 dev_set_mtu(port
->dev
, dev
->mtu
);
1767 team
->port_mtu_change_allowed
= false;
1768 mutex_unlock(&team
->lock
);
1773 static struct rtnl_link_stats64
*
1774 team_get_stats64(struct net_device
*dev
, struct rtnl_link_stats64
*stats
)
1776 struct team
*team
= netdev_priv(dev
);
1777 struct team_pcpu_stats
*p
;
1778 u64 rx_packets
, rx_bytes
, rx_multicast
, tx_packets
, tx_bytes
;
1779 u32 rx_dropped
= 0, tx_dropped
= 0;
1783 for_each_possible_cpu(i
) {
1784 p
= per_cpu_ptr(team
->pcpu_stats
, i
);
1786 start
= u64_stats_fetch_begin_irq(&p
->syncp
);
1787 rx_packets
= p
->rx_packets
;
1788 rx_bytes
= p
->rx_bytes
;
1789 rx_multicast
= p
->rx_multicast
;
1790 tx_packets
= p
->tx_packets
;
1791 tx_bytes
= p
->tx_bytes
;
1792 } while (u64_stats_fetch_retry_irq(&p
->syncp
, start
));
1794 stats
->rx_packets
+= rx_packets
;
1795 stats
->rx_bytes
+= rx_bytes
;
1796 stats
->multicast
+= rx_multicast
;
1797 stats
->tx_packets
+= tx_packets
;
1798 stats
->tx_bytes
+= tx_bytes
;
1800 * rx_dropped & tx_dropped are u32, updated
1801 * without syncp protection.
1803 rx_dropped
+= p
->rx_dropped
;
1804 tx_dropped
+= p
->tx_dropped
;
1806 stats
->rx_dropped
= rx_dropped
;
1807 stats
->tx_dropped
= tx_dropped
;
1811 static int team_vlan_rx_add_vid(struct net_device
*dev
, __be16 proto
, u16 vid
)
1813 struct team
*team
= netdev_priv(dev
);
1814 struct team_port
*port
;
1818 * Alhough this is reader, it's guarded by team lock. It's not possible
1819 * to traverse list in reverse under rcu_read_lock
1821 mutex_lock(&team
->lock
);
1822 list_for_each_entry(port
, &team
->port_list
, list
) {
1823 err
= vlan_vid_add(port
->dev
, proto
, vid
);
1827 mutex_unlock(&team
->lock
);
1832 list_for_each_entry_continue_reverse(port
, &team
->port_list
, list
)
1833 vlan_vid_del(port
->dev
, proto
, vid
);
1834 mutex_unlock(&team
->lock
);
1839 static int team_vlan_rx_kill_vid(struct net_device
*dev
, __be16 proto
, u16 vid
)
1841 struct team
*team
= netdev_priv(dev
);
1842 struct team_port
*port
;
1845 list_for_each_entry_rcu(port
, &team
->port_list
, list
)
1846 vlan_vid_del(port
->dev
, proto
, vid
);
1852 #ifdef CONFIG_NET_POLL_CONTROLLER
1853 static void team_poll_controller(struct net_device
*dev
)
1857 static void __team_netpoll_cleanup(struct team
*team
)
1859 struct team_port
*port
;
1861 list_for_each_entry(port
, &team
->port_list
, list
)
1862 team_port_disable_netpoll(port
);
1865 static void team_netpoll_cleanup(struct net_device
*dev
)
1867 struct team
*team
= netdev_priv(dev
);
1869 mutex_lock(&team
->lock
);
1870 __team_netpoll_cleanup(team
);
1871 mutex_unlock(&team
->lock
);
1874 static int team_netpoll_setup(struct net_device
*dev
,
1875 struct netpoll_info
*npifo
)
1877 struct team
*team
= netdev_priv(dev
);
1878 struct team_port
*port
;
1881 mutex_lock(&team
->lock
);
1882 list_for_each_entry(port
, &team
->port_list
, list
) {
1883 err
= team_port_enable_netpoll(team
, port
);
1885 __team_netpoll_cleanup(team
);
1889 mutex_unlock(&team
->lock
);
1894 static int team_add_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1896 struct team
*team
= netdev_priv(dev
);
1899 mutex_lock(&team
->lock
);
1900 err
= team_port_add(team
, port_dev
);
1901 mutex_unlock(&team
->lock
);
1905 static int team_del_slave(struct net_device
*dev
, struct net_device
*port_dev
)
1907 struct team
*team
= netdev_priv(dev
);
1910 mutex_lock(&team
->lock
);
1911 err
= team_port_del(team
, port_dev
);
1912 mutex_unlock(&team
->lock
);
1916 static netdev_features_t
team_fix_features(struct net_device
*dev
,
1917 netdev_features_t features
)
1919 struct team_port
*port
;
1920 struct team
*team
= netdev_priv(dev
);
1921 netdev_features_t mask
;
1924 features
&= ~NETIF_F_ONE_FOR_ALL
;
1925 features
|= NETIF_F_ALL_FOR_ALL
;
1928 list_for_each_entry_rcu(port
, &team
->port_list
, list
) {
1929 features
= netdev_increment_features(features
,
1930 port
->dev
->features
,
1937 static int team_change_carrier(struct net_device
*dev
, bool new_carrier
)
1939 struct team
*team
= netdev_priv(dev
);
1941 team
->user_carrier_enabled
= true;
1944 netif_carrier_on(dev
);
1946 netif_carrier_off(dev
);
1950 static const struct net_device_ops team_netdev_ops
= {
1951 .ndo_init
= team_init
,
1952 .ndo_uninit
= team_uninit
,
1953 .ndo_open
= team_open
,
1954 .ndo_stop
= team_close
,
1955 .ndo_start_xmit
= team_xmit
,
1956 .ndo_select_queue
= team_select_queue
,
1957 .ndo_change_rx_flags
= team_change_rx_flags
,
1958 .ndo_set_rx_mode
= team_set_rx_mode
,
1959 .ndo_set_mac_address
= team_set_mac_address
,
1960 .ndo_change_mtu
= team_change_mtu
,
1961 .ndo_get_stats64
= team_get_stats64
,
1962 .ndo_vlan_rx_add_vid
= team_vlan_rx_add_vid
,
1963 .ndo_vlan_rx_kill_vid
= team_vlan_rx_kill_vid
,
1964 #ifdef CONFIG_NET_POLL_CONTROLLER
1965 .ndo_poll_controller
= team_poll_controller
,
1966 .ndo_netpoll_setup
= team_netpoll_setup
,
1967 .ndo_netpoll_cleanup
= team_netpoll_cleanup
,
1969 .ndo_add_slave
= team_add_slave
,
1970 .ndo_del_slave
= team_del_slave
,
1971 .ndo_fix_features
= team_fix_features
,
1972 .ndo_change_carrier
= team_change_carrier
,
1975 /***********************
1977 ***********************/
1979 static void team_ethtool_get_drvinfo(struct net_device
*dev
,
1980 struct ethtool_drvinfo
*drvinfo
)
1982 strlcpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
1983 strlcpy(drvinfo
->version
, UTS_RELEASE
, sizeof(drvinfo
->version
));
1986 static const struct ethtool_ops team_ethtool_ops
= {
1987 .get_drvinfo
= team_ethtool_get_drvinfo
,
1988 .get_link
= ethtool_op_get_link
,
1991 /***********************
1992 * rt netlink interface
1993 ***********************/
1995 static void team_setup_by_port(struct net_device
*dev
,
1996 struct net_device
*port_dev
)
1998 dev
->header_ops
= port_dev
->header_ops
;
1999 dev
->type
= port_dev
->type
;
2000 dev
->hard_header_len
= port_dev
->hard_header_len
;
2001 dev
->addr_len
= port_dev
->addr_len
;
2002 dev
->mtu
= port_dev
->mtu
;
2003 memcpy(dev
->broadcast
, port_dev
->broadcast
, port_dev
->addr_len
);
2004 eth_hw_addr_inherit(dev
, port_dev
);
2007 static int team_dev_type_check_change(struct net_device
*dev
,
2008 struct net_device
*port_dev
)
2010 struct team
*team
= netdev_priv(dev
);
2011 char *portname
= port_dev
->name
;
2014 if (dev
->type
== port_dev
->type
)
2016 if (!list_empty(&team
->port_list
)) {
2017 netdev_err(dev
, "Device %s is of different type\n", portname
);
2020 err
= call_netdevice_notifiers(NETDEV_PRE_TYPE_CHANGE
, dev
);
2021 err
= notifier_to_errno(err
);
2023 netdev_err(dev
, "Refused to change device type\n");
2028 team_setup_by_port(dev
, port_dev
);
2029 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE
, dev
);
2033 static void team_setup(struct net_device
*dev
)
2037 dev
->netdev_ops
= &team_netdev_ops
;
2038 dev
->ethtool_ops
= &team_ethtool_ops
;
2039 dev
->destructor
= team_destructor
;
2040 dev
->tx_queue_len
= 0;
2041 dev
->flags
|= IFF_MULTICAST
;
2042 dev
->priv_flags
&= ~(IFF_XMIT_DST_RELEASE
| IFF_TX_SKB_SHARING
);
2045 * Indicate we support unicast address filtering. That way core won't
2046 * bring us to promisc mode in case a unicast addr is added.
2047 * Let this up to underlay drivers.
2049 dev
->priv_flags
|= IFF_UNICAST_FLT
| IFF_LIVE_ADDR_CHANGE
;
2051 dev
->features
|= NETIF_F_LLTX
;
2052 dev
->features
|= NETIF_F_GRO
;
2054 /* Don't allow team devices to change network namespaces. */
2055 dev
->features
|= NETIF_F_NETNS_LOCAL
;
2057 dev
->hw_features
= TEAM_VLAN_FEATURES
|
2058 NETIF_F_HW_VLAN_CTAG_TX
|
2059 NETIF_F_HW_VLAN_CTAG_RX
|
2060 NETIF_F_HW_VLAN_CTAG_FILTER
;
2062 dev
->hw_features
&= ~(NETIF_F_ALL_CSUM
& ~NETIF_F_HW_CSUM
);
2063 dev
->features
|= dev
->hw_features
;
2066 static int team_newlink(struct net
*src_net
, struct net_device
*dev
,
2067 struct nlattr
*tb
[], struct nlattr
*data
[])
2069 if (tb
[IFLA_ADDRESS
] == NULL
)
2070 eth_hw_addr_random(dev
);
2072 return register_netdevice(dev
);
2075 static int team_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
2077 if (tb
[IFLA_ADDRESS
]) {
2078 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
2080 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
2081 return -EADDRNOTAVAIL
;
2086 static unsigned int team_get_num_tx_queues(void)
2088 return TEAM_DEFAULT_NUM_TX_QUEUES
;
2091 static unsigned int team_get_num_rx_queues(void)
2093 return TEAM_DEFAULT_NUM_RX_QUEUES
;
2096 static struct rtnl_link_ops team_link_ops __read_mostly
= {
2098 .priv_size
= sizeof(struct team
),
2099 .setup
= team_setup
,
2100 .newlink
= team_newlink
,
2101 .validate
= team_validate
,
2102 .get_num_tx_queues
= team_get_num_tx_queues
,
2103 .get_num_rx_queues
= team_get_num_rx_queues
,
2107 /***********************************
2108 * Generic netlink custom interface
2109 ***********************************/
2111 static struct genl_family team_nl_family
= {
2112 .id
= GENL_ID_GENERATE
,
2113 .name
= TEAM_GENL_NAME
,
2114 .version
= TEAM_GENL_VERSION
,
2115 .maxattr
= TEAM_ATTR_MAX
,
2119 static const struct nla_policy team_nl_policy
[TEAM_ATTR_MAX
+ 1] = {
2120 [TEAM_ATTR_UNSPEC
] = { .type
= NLA_UNSPEC
, },
2121 [TEAM_ATTR_TEAM_IFINDEX
] = { .type
= NLA_U32
},
2122 [TEAM_ATTR_LIST_OPTION
] = { .type
= NLA_NESTED
},
2123 [TEAM_ATTR_LIST_PORT
] = { .type
= NLA_NESTED
},
2126 static const struct nla_policy
2127 team_nl_option_policy
[TEAM_ATTR_OPTION_MAX
+ 1] = {
2128 [TEAM_ATTR_OPTION_UNSPEC
] = { .type
= NLA_UNSPEC
, },
2129 [TEAM_ATTR_OPTION_NAME
] = {
2131 .len
= TEAM_STRING_MAX_LEN
,
2133 [TEAM_ATTR_OPTION_CHANGED
] = { .type
= NLA_FLAG
},
2134 [TEAM_ATTR_OPTION_TYPE
] = { .type
= NLA_U8
},
2135 [TEAM_ATTR_OPTION_DATA
] = { .type
= NLA_BINARY
},
2138 static int team_nl_cmd_noop(struct sk_buff
*skb
, struct genl_info
*info
)
2140 struct sk_buff
*msg
;
2144 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2148 hdr
= genlmsg_put(msg
, info
->snd_portid
, info
->snd_seq
,
2149 &team_nl_family
, 0, TEAM_CMD_NOOP
);
2155 genlmsg_end(msg
, hdr
);
2157 return genlmsg_unicast(genl_info_net(info
), msg
, info
->snd_portid
);
2166 * Netlink cmd functions should be locked by following two functions.
2167 * Since dev gets held here, that ensures dev won't disappear in between.
2169 static struct team
*team_nl_team_get(struct genl_info
*info
)
2171 struct net
*net
= genl_info_net(info
);
2173 struct net_device
*dev
;
2176 if (!info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
])
2179 ifindex
= nla_get_u32(info
->attrs
[TEAM_ATTR_TEAM_IFINDEX
]);
2180 dev
= dev_get_by_index(net
, ifindex
);
2181 if (!dev
|| dev
->netdev_ops
!= &team_netdev_ops
) {
2187 team
= netdev_priv(dev
);
2188 mutex_lock(&team
->lock
);
2192 static void team_nl_team_put(struct team
*team
)
2194 mutex_unlock(&team
->lock
);
2198 typedef int team_nl_send_func_t(struct sk_buff
*skb
,
2199 struct team
*team
, u32 portid
);
2201 static int team_nl_send_unicast(struct sk_buff
*skb
, struct team
*team
, u32 portid
)
2203 return genlmsg_unicast(dev_net(team
->dev
), skb
, portid
);
2206 static int team_nl_fill_one_option_get(struct sk_buff
*skb
, struct team
*team
,
2207 struct team_option_inst
*opt_inst
)
2209 struct nlattr
*option_item
;
2210 struct team_option
*option
= opt_inst
->option
;
2211 struct team_option_inst_info
*opt_inst_info
= &opt_inst
->info
;
2212 struct team_gsetter_ctx ctx
;
2215 ctx
.info
= opt_inst_info
;
2216 err
= team_option_get(team
, opt_inst
, &ctx
);
2220 option_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_OPTION
);
2224 if (nla_put_string(skb
, TEAM_ATTR_OPTION_NAME
, option
->name
))
2226 if (opt_inst_info
->port
&&
2227 nla_put_u32(skb
, TEAM_ATTR_OPTION_PORT_IFINDEX
,
2228 opt_inst_info
->port
->dev
->ifindex
))
2230 if (opt_inst
->option
->array_size
&&
2231 nla_put_u32(skb
, TEAM_ATTR_OPTION_ARRAY_INDEX
,
2232 opt_inst_info
->array_index
))
2235 switch (option
->type
) {
2236 case TEAM_OPTION_TYPE_U32
:
2237 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_U32
))
2239 if (nla_put_u32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.u32_val
))
2242 case TEAM_OPTION_TYPE_STRING
:
2243 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_STRING
))
2245 if (nla_put_string(skb
, TEAM_ATTR_OPTION_DATA
,
2249 case TEAM_OPTION_TYPE_BINARY
:
2250 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_BINARY
))
2252 if (nla_put(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.bin_val
.len
,
2253 ctx
.data
.bin_val
.ptr
))
2256 case TEAM_OPTION_TYPE_BOOL
:
2257 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_FLAG
))
2259 if (ctx
.data
.bool_val
&&
2260 nla_put_flag(skb
, TEAM_ATTR_OPTION_DATA
))
2263 case TEAM_OPTION_TYPE_S32
:
2264 if (nla_put_u8(skb
, TEAM_ATTR_OPTION_TYPE
, NLA_S32
))
2266 if (nla_put_s32(skb
, TEAM_ATTR_OPTION_DATA
, ctx
.data
.s32_val
))
2272 if (opt_inst
->removed
&& nla_put_flag(skb
, TEAM_ATTR_OPTION_REMOVED
))
2274 if (opt_inst
->changed
) {
2275 if (nla_put_flag(skb
, TEAM_ATTR_OPTION_CHANGED
))
2277 opt_inst
->changed
= false;
2279 nla_nest_end(skb
, option_item
);
2283 nla_nest_cancel(skb
, option_item
);
2287 static int __send_and_alloc_skb(struct sk_buff
**pskb
,
2288 struct team
*team
, u32 portid
,
2289 team_nl_send_func_t
*send_func
)
2294 err
= send_func(*pskb
, team
, portid
);
2298 *pskb
= genlmsg_new(GENLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2304 static int team_nl_send_options_get(struct team
*team
, u32 portid
, u32 seq
,
2305 int flags
, team_nl_send_func_t
*send_func
,
2306 struct list_head
*sel_opt_inst_list
)
2308 struct nlattr
*option_list
;
2309 struct nlmsghdr
*nlh
;
2311 struct team_option_inst
*opt_inst
;
2313 struct sk_buff
*skb
= NULL
;
2317 opt_inst
= list_first_entry(sel_opt_inst_list
,
2318 struct team_option_inst
, tmp_list
);
2321 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2325 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2326 TEAM_CMD_OPTIONS_GET
);
2330 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2331 goto nla_put_failure
;
2332 option_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_OPTION
);
2334 goto nla_put_failure
;
2338 list_for_each_entry_from(opt_inst
, sel_opt_inst_list
, tmp_list
) {
2339 err
= team_nl_fill_one_option_get(skb
, team
, opt_inst
);
2341 if (err
== -EMSGSIZE
) {
2352 nla_nest_end(skb
, option_list
);
2353 genlmsg_end(skb
, hdr
);
2358 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2360 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2366 return send_func(skb
, team
, portid
);
2371 genlmsg_cancel(skb
, hdr
);
2376 static int team_nl_cmd_options_get(struct sk_buff
*skb
, struct genl_info
*info
)
2379 struct team_option_inst
*opt_inst
;
2381 LIST_HEAD(sel_opt_inst_list
);
2383 team
= team_nl_team_get(info
);
2387 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
)
2388 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2389 err
= team_nl_send_options_get(team
, info
->snd_portid
, info
->snd_seq
,
2390 NLM_F_ACK
, team_nl_send_unicast
,
2391 &sel_opt_inst_list
);
2393 team_nl_team_put(team
);
2398 static int team_nl_send_event_options_get(struct team
*team
,
2399 struct list_head
*sel_opt_inst_list
);
2401 static int team_nl_cmd_options_set(struct sk_buff
*skb
, struct genl_info
*info
)
2406 struct nlattr
*nl_option
;
2407 LIST_HEAD(opt_inst_list
);
2409 team
= team_nl_team_get(info
);
2414 if (!info
->attrs
[TEAM_ATTR_LIST_OPTION
]) {
2419 nla_for_each_nested(nl_option
, info
->attrs
[TEAM_ATTR_LIST_OPTION
], i
) {
2420 struct nlattr
*opt_attrs
[TEAM_ATTR_OPTION_MAX
+ 1];
2421 struct nlattr
*attr
;
2422 struct nlattr
*attr_data
;
2423 enum team_option_type opt_type
;
2424 int opt_port_ifindex
= 0; /* != 0 for per-port options */
2425 u32 opt_array_index
= 0;
2426 bool opt_is_array
= false;
2427 struct team_option_inst
*opt_inst
;
2429 bool opt_found
= false;
2431 if (nla_type(nl_option
) != TEAM_ATTR_ITEM_OPTION
) {
2435 err
= nla_parse_nested(opt_attrs
, TEAM_ATTR_OPTION_MAX
,
2436 nl_option
, team_nl_option_policy
);
2439 if (!opt_attrs
[TEAM_ATTR_OPTION_NAME
] ||
2440 !opt_attrs
[TEAM_ATTR_OPTION_TYPE
]) {
2444 switch (nla_get_u8(opt_attrs
[TEAM_ATTR_OPTION_TYPE
])) {
2446 opt_type
= TEAM_OPTION_TYPE_U32
;
2449 opt_type
= TEAM_OPTION_TYPE_STRING
;
2452 opt_type
= TEAM_OPTION_TYPE_BINARY
;
2455 opt_type
= TEAM_OPTION_TYPE_BOOL
;
2458 opt_type
= TEAM_OPTION_TYPE_S32
;
2464 attr_data
= opt_attrs
[TEAM_ATTR_OPTION_DATA
];
2465 if (opt_type
!= TEAM_OPTION_TYPE_BOOL
&& !attr_data
) {
2470 opt_name
= nla_data(opt_attrs
[TEAM_ATTR_OPTION_NAME
]);
2471 attr
= opt_attrs
[TEAM_ATTR_OPTION_PORT_IFINDEX
];
2473 opt_port_ifindex
= nla_get_u32(attr
);
2475 attr
= opt_attrs
[TEAM_ATTR_OPTION_ARRAY_INDEX
];
2477 opt_is_array
= true;
2478 opt_array_index
= nla_get_u32(attr
);
2481 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2482 struct team_option
*option
= opt_inst
->option
;
2483 struct team_gsetter_ctx ctx
;
2484 struct team_option_inst_info
*opt_inst_info
;
2487 opt_inst_info
= &opt_inst
->info
;
2488 tmp_ifindex
= opt_inst_info
->port
?
2489 opt_inst_info
->port
->dev
->ifindex
: 0;
2490 if (option
->type
!= opt_type
||
2491 strcmp(option
->name
, opt_name
) ||
2492 tmp_ifindex
!= opt_port_ifindex
||
2493 (option
->array_size
&& !opt_is_array
) ||
2494 opt_inst_info
->array_index
!= opt_array_index
)
2497 ctx
.info
= opt_inst_info
;
2499 case TEAM_OPTION_TYPE_U32
:
2500 ctx
.data
.u32_val
= nla_get_u32(attr_data
);
2502 case TEAM_OPTION_TYPE_STRING
:
2503 if (nla_len(attr_data
) > TEAM_STRING_MAX_LEN
) {
2507 ctx
.data
.str_val
= nla_data(attr_data
);
2509 case TEAM_OPTION_TYPE_BINARY
:
2510 ctx
.data
.bin_val
.len
= nla_len(attr_data
);
2511 ctx
.data
.bin_val
.ptr
= nla_data(attr_data
);
2513 case TEAM_OPTION_TYPE_BOOL
:
2514 ctx
.data
.bool_val
= attr_data
? true : false;
2516 case TEAM_OPTION_TYPE_S32
:
2517 ctx
.data
.s32_val
= nla_get_s32(attr_data
);
2522 err
= team_option_set(team
, opt_inst
, &ctx
);
2525 opt_inst
->changed
= true;
2526 list_add(&opt_inst
->tmp_list
, &opt_inst_list
);
2534 err
= team_nl_send_event_options_get(team
, &opt_inst_list
);
2537 team_nl_team_put(team
);
2542 static int team_nl_fill_one_port_get(struct sk_buff
*skb
,
2543 struct team_port
*port
)
2545 struct nlattr
*port_item
;
2547 port_item
= nla_nest_start(skb
, TEAM_ATTR_ITEM_PORT
);
2550 if (nla_put_u32(skb
, TEAM_ATTR_PORT_IFINDEX
, port
->dev
->ifindex
))
2552 if (port
->changed
) {
2553 if (nla_put_flag(skb
, TEAM_ATTR_PORT_CHANGED
))
2555 port
->changed
= false;
2557 if ((port
->removed
&&
2558 nla_put_flag(skb
, TEAM_ATTR_PORT_REMOVED
)) ||
2559 (port
->state
.linkup
&&
2560 nla_put_flag(skb
, TEAM_ATTR_PORT_LINKUP
)) ||
2561 nla_put_u32(skb
, TEAM_ATTR_PORT_SPEED
, port
->state
.speed
) ||
2562 nla_put_u8(skb
, TEAM_ATTR_PORT_DUPLEX
, port
->state
.duplex
))
2564 nla_nest_end(skb
, port_item
);
2568 nla_nest_cancel(skb
, port_item
);
2572 static int team_nl_send_port_list_get(struct team
*team
, u32 portid
, u32 seq
,
2573 int flags
, team_nl_send_func_t
*send_func
,
2574 struct team_port
*one_port
)
2576 struct nlattr
*port_list
;
2577 struct nlmsghdr
*nlh
;
2579 struct team_port
*port
;
2581 struct sk_buff
*skb
= NULL
;
2585 port
= list_first_entry_or_null(&team
->port_list
,
2586 struct team_port
, list
);
2589 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2593 hdr
= genlmsg_put(skb
, portid
, seq
, &team_nl_family
, flags
| NLM_F_MULTI
,
2594 TEAM_CMD_PORT_LIST_GET
);
2598 if (nla_put_u32(skb
, TEAM_ATTR_TEAM_IFINDEX
, team
->dev
->ifindex
))
2599 goto nla_put_failure
;
2600 port_list
= nla_nest_start(skb
, TEAM_ATTR_LIST_PORT
);
2602 goto nla_put_failure
;
2607 /* If one port is selected, called wants to send port list containing
2608 * only this port. Otherwise go through all listed ports and send all
2611 err
= team_nl_fill_one_port_get(skb
, one_port
);
2615 list_for_each_entry_from(port
, &team
->port_list
, list
) {
2616 err
= team_nl_fill_one_port_get(skb
, port
);
2618 if (err
== -EMSGSIZE
) {
2630 nla_nest_end(skb
, port_list
);
2631 genlmsg_end(skb
, hdr
);
2636 nlh
= nlmsg_put(skb
, portid
, seq
, NLMSG_DONE
, 0, flags
| NLM_F_MULTI
);
2638 err
= __send_and_alloc_skb(&skb
, team
, portid
, send_func
);
2644 return send_func(skb
, team
, portid
);
2649 genlmsg_cancel(skb
, hdr
);
2654 static int team_nl_cmd_port_list_get(struct sk_buff
*skb
,
2655 struct genl_info
*info
)
2660 team
= team_nl_team_get(info
);
2664 err
= team_nl_send_port_list_get(team
, info
->snd_portid
, info
->snd_seq
,
2665 NLM_F_ACK
, team_nl_send_unicast
, NULL
);
2667 team_nl_team_put(team
);
2672 static const struct genl_ops team_nl_ops
[] = {
2674 .cmd
= TEAM_CMD_NOOP
,
2675 .doit
= team_nl_cmd_noop
,
2676 .policy
= team_nl_policy
,
2679 .cmd
= TEAM_CMD_OPTIONS_SET
,
2680 .doit
= team_nl_cmd_options_set
,
2681 .policy
= team_nl_policy
,
2682 .flags
= GENL_ADMIN_PERM
,
2685 .cmd
= TEAM_CMD_OPTIONS_GET
,
2686 .doit
= team_nl_cmd_options_get
,
2687 .policy
= team_nl_policy
,
2688 .flags
= GENL_ADMIN_PERM
,
2691 .cmd
= TEAM_CMD_PORT_LIST_GET
,
2692 .doit
= team_nl_cmd_port_list_get
,
2693 .policy
= team_nl_policy
,
2694 .flags
= GENL_ADMIN_PERM
,
2698 static const struct genl_multicast_group team_nl_mcgrps
[] = {
2699 { .name
= TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME
, },
2702 static int team_nl_send_multicast(struct sk_buff
*skb
,
2703 struct team
*team
, u32 portid
)
2705 return genlmsg_multicast_netns(&team_nl_family
, dev_net(team
->dev
),
2706 skb
, 0, 0, GFP_KERNEL
);
2709 static int team_nl_send_event_options_get(struct team
*team
,
2710 struct list_head
*sel_opt_inst_list
)
2712 return team_nl_send_options_get(team
, 0, 0, 0, team_nl_send_multicast
,
2716 static int team_nl_send_event_port_get(struct team
*team
,
2717 struct team_port
*port
)
2719 return team_nl_send_port_list_get(team
, 0, 0, 0, team_nl_send_multicast
,
2723 static int team_nl_init(void)
2725 return genl_register_family_with_ops_groups(&team_nl_family
, team_nl_ops
,
2729 static void team_nl_fini(void)
2731 genl_unregister_family(&team_nl_family
);
2739 static void __team_options_change_check(struct team
*team
)
2742 struct team_option_inst
*opt_inst
;
2743 LIST_HEAD(sel_opt_inst_list
);
2745 list_for_each_entry(opt_inst
, &team
->option_inst_list
, list
) {
2746 if (opt_inst
->changed
)
2747 list_add_tail(&opt_inst
->tmp_list
, &sel_opt_inst_list
);
2749 err
= team_nl_send_event_options_get(team
, &sel_opt_inst_list
);
2750 if (err
&& err
!= -ESRCH
)
2751 netdev_warn(team
->dev
, "Failed to send options change via netlink (err %d)\n",
2755 /* rtnl lock is held */
2757 static void __team_port_change_send(struct team_port
*port
, bool linkup
)
2761 port
->changed
= true;
2762 port
->state
.linkup
= linkup
;
2763 team_refresh_port_linkup(port
);
2765 struct ethtool_cmd ecmd
;
2767 err
= __ethtool_get_settings(port
->dev
, &ecmd
);
2769 port
->state
.speed
= ethtool_cmd_speed(&ecmd
);
2770 port
->state
.duplex
= ecmd
.duplex
;
2774 port
->state
.speed
= 0;
2775 port
->state
.duplex
= 0;
2778 err
= team_nl_send_event_port_get(port
->team
, port
);
2779 if (err
&& err
!= -ESRCH
)
2780 netdev_warn(port
->team
->dev
, "Failed to send port change of device %s via netlink (err %d)\n",
2781 port
->dev
->name
, err
);
2785 static void __team_carrier_check(struct team
*team
)
2787 struct team_port
*port
;
2790 if (team
->user_carrier_enabled
)
2793 team_linkup
= false;
2794 list_for_each_entry(port
, &team
->port_list
, list
) {
2802 netif_carrier_on(team
->dev
);
2804 netif_carrier_off(team
->dev
);
2807 static void __team_port_change_check(struct team_port
*port
, bool linkup
)
2809 if (port
->state
.linkup
!= linkup
)
2810 __team_port_change_send(port
, linkup
);
2811 __team_carrier_check(port
->team
);
2814 static void __team_port_change_port_added(struct team_port
*port
, bool linkup
)
2816 __team_port_change_send(port
, linkup
);
2817 __team_carrier_check(port
->team
);
2820 static void __team_port_change_port_removed(struct team_port
*port
)
2822 port
->removed
= true;
2823 __team_port_change_send(port
, false);
2824 __team_carrier_check(port
->team
);
2827 static void team_port_change_check(struct team_port
*port
, bool linkup
)
2829 struct team
*team
= port
->team
;
2831 mutex_lock(&team
->lock
);
2832 __team_port_change_check(port
, linkup
);
2833 mutex_unlock(&team
->lock
);
2837 /************************************
2838 * Net device notifier event handler
2839 ************************************/
2841 static int team_device_event(struct notifier_block
*unused
,
2842 unsigned long event
, void *ptr
)
2844 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
2845 struct team_port
*port
;
2847 port
= team_port_get_rtnl(dev
);
2853 if (netif_carrier_ok(dev
))
2854 team_port_change_check(port
, true);
2857 team_port_change_check(port
, false);
2860 if (netif_running(port
->dev
))
2861 team_port_change_check(port
,
2862 !!netif_carrier_ok(port
->dev
));
2864 case NETDEV_UNREGISTER
:
2865 team_del_slave(port
->team
->dev
, dev
);
2867 case NETDEV_FEAT_CHANGE
:
2868 team_compute_features(port
->team
);
2870 case NETDEV_PRECHANGEMTU
:
2871 /* Forbid to change mtu of underlaying device */
2872 if (!port
->team
->port_mtu_change_allowed
)
2875 case NETDEV_PRE_TYPE_CHANGE
:
2876 /* Forbid to change type of underlaying device */
2878 case NETDEV_RESEND_IGMP
:
2879 /* Propagate to master device */
2880 call_netdevice_notifiers(event
, port
->team
->dev
);
2886 static struct notifier_block team_notifier_block __read_mostly
= {
2887 .notifier_call
= team_device_event
,
2891 /***********************
2892 * Module init and exit
2893 ***********************/
2895 static int __init
team_module_init(void)
2899 register_netdevice_notifier(&team_notifier_block
);
2901 err
= rtnl_link_register(&team_link_ops
);
2905 err
= team_nl_init();
2912 rtnl_link_unregister(&team_link_ops
);
2915 unregister_netdevice_notifier(&team_notifier_block
);
2920 static void __exit
team_module_exit(void)
2923 rtnl_link_unregister(&team_link_ops
);
2924 unregister_netdevice_notifier(&team_notifier_block
);
2927 module_init(team_module_init
);
2928 module_exit(team_module_exit
);
2930 MODULE_LICENSE("GPL v2");
2931 MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
2932 MODULE_DESCRIPTION("Ethernet team device driver");
2933 MODULE_ALIAS_RTNL_LINK(DRV_NAME
);