1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* drivers/net/team/team.c - Network team device driver
4	* Copyright (c) 2011 Jiri Pirko <jpirko@redhat.com>
5	*/
6
7	#include <linux/ethtool.h>
8	#include <linux/kernel.h>
9	#include <linux/types.h>
10	#include <linux/module.h>
11	#include <linux/init.h>
12	#include <linux/slab.h>
13	#include <linux/rcupdate.h>
14	#include <linux/errno.h>
15	#include <linux/ctype.h>
16	#include <linux/notifier.h>
17	#include <linux/netdevice.h>
18	#include <linux/netpoll.h>
19	#include <linux/if_vlan.h>
20	#include <linux/if_arp.h>
21	#include <linux/socket.h>
22	#include <linux/etherdevice.h>
23	#include <linux/rtnetlink.h>
24	#include <net/rtnetlink.h>
25	#include <net/genetlink.h>
26	#include <net/netlink.h>
27	#include <net/sch_generic.h>
28	#include <linux/if_team.h>
29
30	#define DRV_NAME "team"
31
32
33	/**********
34	* Helpers
35	**********/
36
37	static struct team_port *team_port_get_rtnl(const struct net_device *dev)
38	{
39	struct team_port *port = rtnl_dereference(dev->rx_handler_data);
40
41	return netif_is_team_port(dev) ? port : NULL;
42	}
43
44	/*
45	* Since the ability to change device address for open port device is tested in
46	* team_port_add, this function can be called without control of return value
47	*/
48	static int __set_port_dev_addr(struct net_device *port_dev,
49	const unsigned char *dev_addr)
50	{
51	struct sockaddr_storage addr;
52
53	memcpy(addr.__data, dev_addr, port_dev->addr_len);
54	addr.ss_family = port_dev->type;
55	return dev_set_mac_address(dev: port_dev, sa: (struct sockaddr *)&addr, NULL);
56	}
57
58	static int team_port_set_orig_dev_addr(struct team_port *port)
59	{
60	return __set_port_dev_addr(port_dev: port->dev, dev_addr: port->orig.dev_addr);
61	}
62
63	static int team_port_set_team_dev_addr(struct team *team,
64	struct team_port *port)
65	{
66	return __set_port_dev_addr(port_dev: port->dev, dev_addr: team->dev->dev_addr);
67	}
68
69	int team_modeop_port_enter(struct team *team, struct team_port *port)
70	{
71	return team_port_set_team_dev_addr(team, port);
72	}
73	EXPORT_SYMBOL(team_modeop_port_enter);
74
75	void team_modeop_port_change_dev_addr(struct team *team,
76	struct team_port *port)
77	{
78	team_port_set_team_dev_addr(team, port);
79	}
80	EXPORT_SYMBOL(team_modeop_port_change_dev_addr);
81
82	static void team_lower_state_changed(struct team_port *port)
83	{
84	struct netdev_lag_lower_state_info info;
85
86	info.link_up = port->linkup;
87	info.tx_enabled = team_port_enabled(port);
88	netdev_lower_state_changed(lower_dev: port->dev, lower_state_info: &info);
89	}
90
91	static void team_refresh_port_linkup(struct team_port *port)
92	{
93	bool new_linkup = port->user.linkup_enabled ? port->user.linkup :
94	port->state.linkup;
95
96	if (port->linkup != new_linkup) {
97	port->linkup = new_linkup;
98	team_lower_state_changed(port);
99	}
100	}
101
102
103	/*******************
104	* Options handling
105	*******************/
106
107	struct team_option_inst { /* One for each option instance */
108	struct list_head list;
109	struct list_head tmp_list;
110	struct team_option *option;
111	struct team_option_inst_info info;
112	bool changed;
113	bool removed;
114	};
115
116	static struct team_option *__team_find_option(struct team *team,
117	const char *opt_name)
118	{
119	struct team_option *option;
120
121	list_for_each_entry(option, &team->option_list, list) {
122	if (strcmp(option->name, opt_name) == 0)
123	return option;
124	}
125	return NULL;
126	}
127
128	static void __team_option_inst_del(struct team_option_inst *opt_inst)
129	{
130	list_del(entry: &opt_inst->list);
131	kfree(objp: opt_inst);
132	}
133
134	static void __team_option_inst_del_option(struct team *team,
135	struct team_option *option)
136	{
137	struct team_option_inst *opt_inst, *tmp;
138
139	list_for_each_entry_safe(opt_inst, tmp, &team->option_inst_list, list) {
140	if (opt_inst->option == option)
141	__team_option_inst_del(opt_inst);
142	}
143	}
144
145	static int __team_option_inst_add(struct team *team, struct team_option *option,
146	struct team_port *port)
147	{
148	struct team_option_inst *opt_inst;
149	unsigned int array_size;
150	unsigned int i;
151
152	array_size = option->array_size;
153	if (!array_size)
154	array_size = 1; /* No array but still need one instance */
155
156	for (i = 0; i < array_size; i++) {
157	opt_inst = kmalloc(size: sizeof(*opt_inst), GFP_KERNEL);
158	if (!opt_inst)
159	return -ENOMEM;
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(new: &opt_inst->list, head: &team->option_inst_list);
166	if (option->init)
167	option->init(team, &opt_inst->info);
168
169	}
170	return 0;
171	}
172
173	static int __team_option_inst_add_option(struct team *team,
174	struct team_option *option)
175	{
176	int err;
177
178	if (!option->per_port) {
179	err = __team_option_inst_add(team, option, NULL);
180	if (err)
181	goto inst_del_option;
182	}
183	return 0;
184
185	inst_del_option:
186	__team_option_inst_del_option(team, option);
187	return err;
188	}
189
190	static void __team_option_inst_mark_removed_option(struct team *team,
191	struct team_option *option)
192	{
193	struct team_option_inst *opt_inst;
194
195	list_for_each_entry(opt_inst, &team->option_inst_list, list) {
196	if (opt_inst->option == option) {
197	opt_inst->changed = true;
198	opt_inst->removed = true;
199	}
200	}
201	}
202
203	static void __team_option_inst_del_port(struct team *team,
204	struct team_port *port)
205	{
206	struct team_option_inst *opt_inst, *tmp;
207
208	list_for_each_entry_safe(opt_inst, tmp, &team->option_inst_list, list) {
209	if (opt_inst->option->per_port &&
210	opt_inst->info.port == port)
211	__team_option_inst_del(opt_inst);
212	}
213	}
214
215	static int __team_option_inst_add_port(struct team *team,
216	struct team_port *port)
217	{
218	struct team_option *option;
219	int err;
220
221	list_for_each_entry(option, &team->option_list, list) {
222	if (!option->per_port)
223	continue;
224	err = __team_option_inst_add(team, option, port);
225	if (err)
226	goto inst_del_port;
227	}
228	return 0;
229
230	inst_del_port:
231	__team_option_inst_del_port(team, port);
232	return err;
233	}
234
235	static void __team_option_inst_mark_removed_port(struct team *team,
236	struct team_port *port)
237	{
238	struct team_option_inst *opt_inst;
239
240	list_for_each_entry(opt_inst, &team->option_inst_list, list) {
241	if (opt_inst->info.port == port) {
242	opt_inst->changed = true;
243	opt_inst->removed = true;
244	}
245	}
246	}
247
248	static int __team_options_register(struct team *team,
249	const struct team_option *option,
250	size_t option_count)
251	{
252	int i;
253	struct team_option **dst_opts;
254	int err;
255
256	dst_opts = kcalloc(n: option_count, size: sizeof(struct team_option *),
257	GFP_KERNEL);
258	if (!dst_opts)
259	return -ENOMEM;
260	for (i = 0; i < option_count; i++, option++) {
261	if (__team_find_option(team, opt_name: option->name)) {
262	err = -EEXIST;
263	goto alloc_rollback;
264	}
265	dst_opts[i] = kmemdup(p: option, size: sizeof(*option), GFP_KERNEL);
266	if (!dst_opts[i]) {
267	err = -ENOMEM;
268	goto alloc_rollback;
269	}
270	}
271
272	for (i = 0; i < option_count; i++) {
273	err = __team_option_inst_add_option(team, option: dst_opts[i]);
274	if (err)
275	goto inst_rollback;
276	list_add_tail(new: &dst_opts[i]->list, head: &team->option_list);
277	}
278
279	kfree(objp: dst_opts);
280	return 0;
281
282	inst_rollback:
283	for (i--; i >= 0; i--) {
284	__team_option_inst_del_option(team, option: dst_opts[i]);
285	list_del(entry: &dst_opts[i]->list);
286	}
287
288	i = option_count;
289	alloc_rollback:
290	for (i--; i >= 0; i--)
291	kfree(objp: dst_opts[i]);
292
293	kfree(objp: dst_opts);
294	return err;
295	}
296
297	static void __team_options_mark_removed(struct team *team,
298	const struct team_option *option,
299	size_t option_count)
300	{
301	int i;
302
303	for (i = 0; i < option_count; i++, option++) {
304	struct team_option *del_opt;
305
306	del_opt = __team_find_option(team, opt_name: option->name);
307	if (del_opt)
308	__team_option_inst_mark_removed_option(team, option: del_opt);
309	}
310	}
311
312	static void __team_options_unregister(struct team *team,
313	const struct team_option *option,
314	size_t option_count)
315	{
316	int i;
317
318	for (i = 0; i < option_count; i++, option++) {
319	struct team_option *del_opt;
320
321	del_opt = __team_find_option(team, opt_name: option->name);
322	if (del_opt) {
323	__team_option_inst_del_option(team, option: del_opt);
324	list_del(entry: &del_opt->list);
325	kfree(objp: del_opt);
326	}
327	}
328	}
329
330	static void __team_options_change_check(struct team *team);
331
332	int team_options_register(struct team *team,
333	const struct team_option *option,
334	size_t option_count)
335	{
336	int err;
337
338	err = __team_options_register(team, option, option_count);
339	if (err)
340	return err;
341	__team_options_change_check(team);
342	return 0;
343	}
344	EXPORT_SYMBOL(team_options_register);
345
346	void team_options_unregister(struct team *team,
347	const struct team_option *option,
348	size_t option_count)
349	{
350	__team_options_mark_removed(team, option, option_count);
351	__team_options_change_check(team);
352	__team_options_unregister(team, option, option_count);
353	}
354	EXPORT_SYMBOL(team_options_unregister);
355
356	static int team_option_get(struct team *team,
357	struct team_option_inst *opt_inst,
358	struct team_gsetter_ctx *ctx)
359	{
360	if (!opt_inst->option->getter)
361	return -EOPNOTSUPP;
362
363	opt_inst->option->getter(team, ctx);
364	return 0;
365	}
366
367	static int team_option_set(struct team *team,
368	struct team_option_inst *opt_inst,
369	struct team_gsetter_ctx *ctx)
370	{
371	if (!opt_inst->option->setter)
372	return -EOPNOTSUPP;
373	return opt_inst->option->setter(team, ctx);
374	}
375
376	void team_option_inst_set_change(struct team_option_inst_info *opt_inst_info)
377	{
378	struct team_option_inst *opt_inst;
379
380	opt_inst = container_of(opt_inst_info, struct team_option_inst, info);
381	opt_inst->changed = true;
382	}
383	EXPORT_SYMBOL(team_option_inst_set_change);
384
385	void team_options_change_check(struct team *team)
386	{
387	__team_options_change_check(team);
388	}
389	EXPORT_SYMBOL(team_options_change_check);
390
391
392	/****************
393	* Mode handling
394	****************/
395
396	static LIST_HEAD(mode_list);
397	static DEFINE_SPINLOCK(mode_list_lock);
398
399	struct team_mode_item {
400	struct list_head list;
401	const struct team_mode *mode;
402	};
403
404	static struct team_mode_item *__find_mode(const char *kind)
405	{
406	struct team_mode_item *mitem;
407
408	list_for_each_entry(mitem, &mode_list, list) {
409	if (strcmp(mitem->mode->kind, kind) == 0)
410	return mitem;
411	}
412	return NULL;
413	}
414
415	static bool is_good_mode_name(const char *name)
416	{
417	while (*name != '\0') {
418	if (!isalpha(*name) && !isdigit(c: *name) && *name != '_')
419	return false;
420	name++;
421	}
422	return true;
423	}
424
425	int team_mode_register(const struct team_mode *mode)
426	{
427	int err = 0;
428	struct team_mode_item *mitem;
429
430	if (!is_good_mode_name(name: mode->kind) ||
431	mode->priv_size > TEAM_MODE_PRIV_SIZE)
432	return -EINVAL;
433
434	mitem = kmalloc(size: sizeof(*mitem), GFP_KERNEL);
435	if (!mitem)
436	return -ENOMEM;
437
438	spin_lock(lock: &mode_list_lock);
439	if (__find_mode(kind: mode->kind)) {
440	err = -EEXIST;
441	kfree(objp: mitem);
442	goto unlock;
443	}
444	mitem->mode = mode;
445	list_add_tail(new: &mitem->list, head: &mode_list);
446	unlock:
447	spin_unlock(lock: &mode_list_lock);
448	return err;
449	}
450	EXPORT_SYMBOL(team_mode_register);
451
452	void team_mode_unregister(const struct team_mode *mode)
453	{
454	struct team_mode_item *mitem;
455
456	spin_lock(lock: &mode_list_lock);
457	mitem = __find_mode(kind: mode->kind);
458	if (mitem) {
459	list_del_init(entry: &mitem->list);
460	kfree(objp: mitem);
461	}
462	spin_unlock(lock: &mode_list_lock);
463	}
464	EXPORT_SYMBOL(team_mode_unregister);
465
466	static const struct team_mode *team_mode_get(const char *kind)
467	{
468	struct team_mode_item *mitem;
469	const struct team_mode *mode = NULL;
470
471	if (!try_module_get(THIS_MODULE))
472	return NULL;
473
474	spin_lock(lock: &mode_list_lock);
475	mitem = __find_mode(kind);
476	if (!mitem) {
477	spin_unlock(lock: &mode_list_lock);
478	request_module("team-mode-%s", kind);
479	spin_lock(lock: &mode_list_lock);
480	mitem = __find_mode(kind);
481	}
482	if (mitem) {
483	mode = mitem->mode;
484	if (!try_module_get(module: mode->owner))
485	mode = NULL;
486	}
487
488	spin_unlock(lock: &mode_list_lock);
489	module_put(THIS_MODULE);
490	return mode;
491	}
492
493	static void team_mode_put(const struct team_mode *mode)
494	{
495	module_put(module: mode->owner);
496	}
497
498	static bool team_dummy_transmit(struct team *team, struct sk_buff *skb)
499	{
500	dev_kfree_skb_any(skb);
501	return false;
502	}
503
504	static rx_handler_result_t team_dummy_receive(struct team *team,
505	struct team_port *port,
506	struct sk_buff *skb)
507	{
508	return RX_HANDLER_ANOTHER;
509	}
510
511	static const struct team_mode __team_no_mode = {
512	.kind = "*NOMODE*",
513	};
514
515	static bool team_is_mode_set(struct team *team)
516	{
517	return team->mode != &__team_no_mode;
518	}
519
520	static void team_set_no_mode(struct team *team)
521	{
522	team->user_carrier_enabled = false;
523	team->mode = &__team_no_mode;
524	}
525
526	static void team_adjust_ops(struct team *team)
527	{
528	/*
529	* To avoid checks in rx/tx skb paths, ensure here that non-null and
530	* correct ops are always set.
531	*/
532
533	if (!team->en_port_count || !team_is_mode_set(team) ||
534	!team->mode->ops->transmit)
535	team->ops.transmit = team_dummy_transmit;
536	else
537	team->ops.transmit = team->mode->ops->transmit;
538
539	if (!team->en_port_count || !team_is_mode_set(team) ||
540	!team->mode->ops->receive)
541	team->ops.receive = team_dummy_receive;
542	else
543	team->ops.receive = team->mode->ops->receive;
544	}
545
546	/*
547	* We can benefit from the fact that it's ensured no port is present
548	* at the time of mode change. Therefore no packets are in fly so there's no
549	* need to set mode operations in any special way.
550	*/
551	static int __team_change_mode(struct team *team,
552	const struct team_mode *new_mode)
553	{
554	/* Check if mode was previously set and do cleanup if so */
555	if (team_is_mode_set(team)) {
556	void (*exit_op)(struct team *team) = team->ops.exit;
557
558	/* Clear ops area so no callback is called any longer */
559	memset(&team->ops, 0, sizeof(struct team_mode_ops));
560	team_adjust_ops(team);
561
562	if (exit_op)
563	exit_op(team);
564	team_mode_put(mode: team->mode);
565	team_set_no_mode(team);
566	/* zero private data area */
567	memset(&team->mode_priv, 0,
568	sizeof(struct team) - offsetof(struct team, mode_priv));
569	}
570
571	if (!new_mode)
572	return 0;
573
574	if (new_mode->ops->init) {
575	int err;
576
577	err = new_mode->ops->init(team);
578	if (err)
579	return err;
580	}
581
582	team->mode = new_mode;
583	memcpy(&team->ops, new_mode->ops, sizeof(struct team_mode_ops));
584	team_adjust_ops(team);
585
586	return 0;
587	}
588
589	static int team_change_mode(struct team *team, const char *kind)
590	{
591	const struct team_mode *new_mode;
592	struct net_device *dev = team->dev;
593	int err;
594
595	if (!list_empty(head: &team->port_list)) {
596	netdev_err(dev, format: "No ports can be present during mode change\n");
597	return -EBUSY;
598	}
599
600	if (team_is_mode_set(team) && strcmp(team->mode->kind, kind) == 0) {
601	netdev_err(dev, format: "Unable to change to the same mode the team is in\n");
602	return -EINVAL;
603	}
604
605	new_mode = team_mode_get(kind);
606	if (!new_mode) {
607	netdev_err(dev, format: "Mode \"%s\" not found\n", kind);
608	return -EINVAL;
609	}
610
611	err = __team_change_mode(team, new_mode);
612	if (err) {
613	netdev_err(dev, format: "Failed to change to mode \"%s\"\n", kind);
614	team_mode_put(mode: new_mode);
615	return err;
616	}
617
618	netdev_info(dev, format: "Mode changed to \"%s\"\n", kind);
619	return 0;
620	}
621
622
623	/*********************
624	* Peers notification
625	*********************/
626
627	static void team_notify_peers_work(struct work_struct *work)
628	{
629	struct team *team;
630	int val;
631
632	team = container_of(work, struct team, notify_peers.dw.work);
633
634	if (!rtnl_trylock()) {
635	schedule_delayed_work(dwork: &team->notify_peers.dw, delay: 0);
636	return;
637	}
638	val = atomic_dec_if_positive(v: &team->notify_peers.count_pending);
639	if (val < 0) {
640	rtnl_unlock();
641	return;
642	}
643	call_netdevice_notifiers(val: NETDEV_NOTIFY_PEERS, dev: team->dev);
644	rtnl_unlock();
645	if (val)
646	schedule_delayed_work(dwork: &team->notify_peers.dw,
647	delay: msecs_to_jiffies(m: team->notify_peers.interval));
648	}
649
650	static void team_notify_peers(struct team *team)
651	{
652	if (!team->notify_peers.count || !netif_running(dev: team->dev))
653	return;
654	atomic_add(i: team->notify_peers.count, v: &team->notify_peers.count_pending);
655	schedule_delayed_work(dwork: &team->notify_peers.dw, delay: 0);
656	}
657
658	static void team_notify_peers_init(struct team *team)
659	{
660	INIT_DELAYED_WORK(&team->notify_peers.dw, team_notify_peers_work);
661	}
662
663	static void team_notify_peers_fini(struct team *team)
664	{
665	cancel_delayed_work_sync(dwork: &team->notify_peers.dw);
666	}
667
668
669	/*******************************
670	* Send multicast group rejoins
671	*******************************/
672
673	static void team_mcast_rejoin_work(struct work_struct *work)
674	{
675	struct team *team;
676	int val;
677
678	team = container_of(work, struct team, mcast_rejoin.dw.work);
679
680	if (!rtnl_trylock()) {
681	schedule_delayed_work(dwork: &team->mcast_rejoin.dw, delay: 0);
682	return;
683	}
684	val = atomic_dec_if_positive(v: &team->mcast_rejoin.count_pending);
685	if (val < 0) {
686	rtnl_unlock();
687	return;
688	}
689	call_netdevice_notifiers(val: NETDEV_RESEND_IGMP, dev: team->dev);
690	rtnl_unlock();
691	if (val)
692	schedule_delayed_work(dwork: &team->mcast_rejoin.dw,
693	delay: msecs_to_jiffies(m: team->mcast_rejoin.interval));
694	}
695
696	static void team_mcast_rejoin(struct team *team)
697	{
698	if (!team->mcast_rejoin.count || !netif_running(dev: team->dev))
699	return;
700	atomic_add(i: team->mcast_rejoin.count, v: &team->mcast_rejoin.count_pending);
701	schedule_delayed_work(dwork: &team->mcast_rejoin.dw, delay: 0);
702	}
703
704	static void team_mcast_rejoin_init(struct team *team)
705	{
706	INIT_DELAYED_WORK(&team->mcast_rejoin.dw, team_mcast_rejoin_work);
707	}
708
709	static void team_mcast_rejoin_fini(struct team *team)
710	{
711	cancel_delayed_work_sync(dwork: &team->mcast_rejoin.dw);
712	}
713
714
715	/************************
716	* Rx path frame handler
717	************************/
718
719	/* note: already called with rcu_read_lock */
720	static rx_handler_result_t team_handle_frame(struct sk_buff **pskb)
721	{
722	struct sk_buff *skb = *pskb;
723	struct team_port *port;
724	struct team *team;
725	rx_handler_result_t res;
726
727	skb = skb_share_check(skb, GFP_ATOMIC);
728	if (!skb)
729	return RX_HANDLER_CONSUMED;
730
731	*pskb = skb;
732
733	port = team_port_get_rcu(dev: skb->dev);
734	team = port->team;
735	if (!team_port_enabled(port)) {
736	if (is_link_local_ether_addr(addr: eth_hdr(skb)->h_dest))
737	/* link-local packets are mostly useful when stack receives them
738	* with the link they arrive on.
739	*/
740	return RX_HANDLER_PASS;
741	/* allow exact match delivery for disabled ports */
742	res = RX_HANDLER_EXACT;
743	} else {
744	res = team->ops.receive(team, port, skb);
745	}
746	if (res == RX_HANDLER_ANOTHER) {
747	struct team_pcpu_stats *pcpu_stats;
748
749	pcpu_stats = this_cpu_ptr(team->pcpu_stats);
750	u64_stats_update_begin(syncp: &pcpu_stats->syncp);
751	u64_stats_inc(p: &pcpu_stats->rx_packets);
752	u64_stats_add(p: &pcpu_stats->rx_bytes, val: skb->len);
753	if (skb->pkt_type == PACKET_MULTICAST)
754	u64_stats_inc(p: &pcpu_stats->rx_multicast);
755	u64_stats_update_end(syncp: &pcpu_stats->syncp);
756
757	skb->dev = team->dev;
758	} else if (res == RX_HANDLER_EXACT) {
759	this_cpu_inc(team->pcpu_stats->rx_nohandler);
760	} else {
761	this_cpu_inc(team->pcpu_stats->rx_dropped);
762	}
763
764	return res;
765	}
766
767
768	/*************************************
769	* Multiqueue Tx port select override
770	*************************************/
771
772	static int team_queue_override_init(struct team *team)
773	{
774	struct list_head *listarr;
775	unsigned int queue_cnt = team->dev->num_tx_queues - 1;
776	unsigned int i;
777
778	if (!queue_cnt)
779	return 0;
780	listarr = kmalloc_array(n: queue_cnt, size: sizeof(struct list_head),
781	GFP_KERNEL);
782	if (!listarr)
783	return -ENOMEM;
784	team->qom_lists = listarr;
785	for (i = 0; i < queue_cnt; i++)
786	INIT_LIST_HEAD(list: listarr++);
787	return 0;
788	}
789
790	static void team_queue_override_fini(struct team *team)
791	{
792	kfree(objp: team->qom_lists);
793	}
794
795	static struct list_head *__team_get_qom_list(struct team *team, u16 queue_id)
796	{
797	return &team->qom_lists[queue_id - 1];
798	}
799
800	/*
801	* note: already called with rcu_read_lock
802	*/
803	static bool team_queue_override_transmit(struct team *team, struct sk_buff *skb)
804	{
805	struct list_head *qom_list;
806	struct team_port *port;
807
808	if (!team->queue_override_enabled || !skb->queue_mapping)
809	return false;
810	qom_list = __team_get_qom_list(team, queue_id: skb->queue_mapping);
811	list_for_each_entry_rcu(port, qom_list, qom_list) {
812	if (!team_dev_queue_xmit(team, port, skb))
813	return true;
814	}
815	return false;
816	}
817
818	static void __team_queue_override_port_del(struct team *team,
819	struct team_port *port)
820	{
821	if (!port->queue_id)
822	return;
823	list_del_rcu(entry: &port->qom_list);
824	}
825
826	static bool team_queue_override_port_has_gt_prio_than(struct team_port *port,
827	struct team_port *cur)
828	{
829	if (port->priority < cur->priority)
830	return true;
831	if (port->priority > cur->priority)
832	return false;
833	if (port->index < cur->index)
834	return true;
835	return false;
836	}
837
838	static void __team_queue_override_port_add(struct team *team,
839	struct team_port *port)
840	{
841	struct team_port *cur;
842	struct list_head *qom_list;
843	struct list_head *node;
844
845	if (!port->queue_id)
846	return;
847	qom_list = __team_get_qom_list(team, queue_id: port->queue_id);
848	node = qom_list;
849	list_for_each_entry(cur, qom_list, qom_list) {
850	if (team_queue_override_port_has_gt_prio_than(port, cur))
851	break;
852	node = &cur->qom_list;
853	}
854	list_add_tail_rcu(new: &port->qom_list, head: node);
855	}
856
857	static void __team_queue_override_enabled_check(struct team *team)
858	{
859	struct team_port *port;
860	bool enabled = false;
861
862	list_for_each_entry(port, &team->port_list, list) {
863	if (port->queue_id) {
864	enabled = true;
865	break;
866	}
867	}
868	if (enabled == team->queue_override_enabled)
869	return;
870	netdev_dbg(team->dev, "%s queue override\n",
871	enabled ? "Enabling" : "Disabling");
872	team->queue_override_enabled = enabled;
873	}
874
875	static void team_queue_override_port_prio_changed(struct team *team,
876	struct team_port *port)
877	{
878	if (!port->queue_id || team_port_enabled(port))
879	return;
880	__team_queue_override_port_del(team, port);
881	__team_queue_override_port_add(team, port);
882	__team_queue_override_enabled_check(team);
883	}
884
885	static void team_queue_override_port_change_queue_id(struct team *team,
886	struct team_port *port,
887	u16 new_queue_id)
888	{
889	if (team_port_enabled(port)) {
890	__team_queue_override_port_del(team, port);
891	port->queue_id = new_queue_id;
892	__team_queue_override_port_add(team, port);
893	__team_queue_override_enabled_check(team);
894	} else {
895	port->queue_id = new_queue_id;
896	}
897	}
898
899	static void team_queue_override_port_add(struct team *team,
900	struct team_port *port)
901	{
902	__team_queue_override_port_add(team, port);
903	__team_queue_override_enabled_check(team);
904	}
905
906	static void team_queue_override_port_del(struct team *team,
907	struct team_port *port)
908	{
909	__team_queue_override_port_del(team, port);
910	__team_queue_override_enabled_check(team);
911	}
912
913
914	/****************
915	* Port handling
916	****************/
917
918	static bool team_port_find(const struct team *team,
919	const struct team_port *port)
920	{
921	struct team_port *cur;
922
923	list_for_each_entry(cur, &team->port_list, list)
924	if (cur == port)
925	return true;
926	return false;
927	}
928
929	/*
930	* Enable/disable port by adding to enabled port hashlist and setting
931	* port->index (Might be racy so reader could see incorrect ifindex when
932	* processing a flying packet, but that is not a problem). Write guarded
933	* by team->lock.
934	*/
935	static void team_port_enable(struct team *team,
936	struct team_port *port)
937	{
938	if (team_port_enabled(port))
939	return;
940	port->index = team->en_port_count++;
941	hlist_add_head_rcu(n: &port->hlist,
942	h: team_port_index_hash(team, port_index: port->index));
943	team_adjust_ops(team);
944	team_queue_override_port_add(team, port);
945	if (team->ops.port_enabled)
946	team->ops.port_enabled(team, port);
947	team_notify_peers(team);
948	team_mcast_rejoin(team);
949	team_lower_state_changed(port);
950	}
951
952	static void __reconstruct_port_hlist(struct team *team, int rm_index)
953	{
954	int i;
955	struct team_port *port;
956
957	for (i = rm_index + 1; i < team->en_port_count; i++) {
958	port = team_get_port_by_index(team, port_index: i);
959	hlist_del_rcu(n: &port->hlist);
960	port->index--;
961	hlist_add_head_rcu(n: &port->hlist,
962	h: team_port_index_hash(team, port_index: port->index));
963	}
964	}
965
966	static void team_port_disable(struct team *team,
967	struct team_port *port)
968	{
969	if (!team_port_enabled(port))
970	return;
971	if (team->ops.port_disabled)
972	team->ops.port_disabled(team, port);
973	hlist_del_rcu(n: &port->hlist);
974	__reconstruct_port_hlist(team, rm_index: port->index);
975	port->index = -1;
976	team->en_port_count--;
977	team_queue_override_port_del(team, port);
978	team_adjust_ops(team);
979	team_lower_state_changed(port);
980	}
981
982	#define TEAM_VLAN_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
983	NETIF_F_FRAGLIST | NETIF_F_GSO_SOFTWARE | \
984	NETIF_F_HIGHDMA | NETIF_F_LRO)
985
986	#define TEAM_ENC_FEATURES (NETIF_F_HW_CSUM | NETIF_F_SG | \
987	NETIF_F_RXCSUM | NETIF_F_GSO_SOFTWARE)
988
989	static void __team_compute_features(struct team *team)
990	{
991	struct team_port *port;
992	netdev_features_t vlan_features = TEAM_VLAN_FEATURES &
993	NETIF_F_ALL_FOR_ALL;
994	netdev_features_t enc_features = TEAM_ENC_FEATURES;
995	unsigned short max_hard_header_len = ETH_HLEN;
996	unsigned int dst_release_flag = IFF_XMIT_DST_RELEASE |
997	IFF_XMIT_DST_RELEASE_PERM;
998
999	rcu_read_lock();
1000	list_for_each_entry_rcu(port, &team->port_list, list) {
1001	vlan_features = netdev_increment_features(all: vlan_features,
1002	one: port->dev->vlan_features,
1003	TEAM_VLAN_FEATURES);
1004	enc_features =
1005	netdev_increment_features(all: enc_features,
1006	one: port->dev->hw_enc_features,
1007	TEAM_ENC_FEATURES);
1008
1009
1010	dst_release_flag &= port->dev->priv_flags;
1011	if (port->dev->hard_header_len > max_hard_header_len)
1012	max_hard_header_len = port->dev->hard_header_len;
1013	}
1014	rcu_read_unlock();
1015
1016	team->dev->vlan_features = vlan_features;
1017	team->dev->hw_enc_features = enc_features | NETIF_F_GSO_ENCAP_ALL |
1018	NETIF_F_HW_VLAN_CTAG_TX |
1019	NETIF_F_HW_VLAN_STAG_TX;
1020	team->dev->hard_header_len = max_hard_header_len;
1021
1022	team->dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
1023	if (dst_release_flag == (IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM))
1024	team->dev->priv_flags |= IFF_XMIT_DST_RELEASE;
1025	}
1026
1027	static void team_compute_features(struct team *team)
1028	{
1029	__team_compute_features(team);
1030	netdev_change_features(dev: team->dev);
1031	}
1032
1033	static int team_port_enter(struct team *team, struct team_port *port)
1034	{
1035	int err = 0;
1036
1037	dev_hold(dev: team->dev);
1038	if (team->ops.port_enter) {
1039	err = team->ops.port_enter(team, port);
1040	if (err) {
1041	netdev_err(dev: team->dev, format: "Device %s failed to enter team mode\n",
1042	port->dev->name);
1043	goto err_port_enter;
1044	}
1045	}
1046
1047	return 0;
1048
1049	err_port_enter:
1050	dev_put(dev: team->dev);
1051
1052	return err;
1053	}
1054
1055	static void team_port_leave(struct team *team, struct team_port *port)
1056	{
1057	if (team->ops.port_leave)
1058	team->ops.port_leave(team, port);
1059	dev_put(dev: team->dev);
1060	}
1061
1062	#ifdef CONFIG_NET_POLL_CONTROLLER
1063	static int __team_port_enable_netpoll(struct team_port *port)
1064	{
1065	struct netpoll *np;
1066	int err;
1067
1068	np = kzalloc(size: sizeof(*np), GFP_KERNEL);
1069	if (!np)
1070	return -ENOMEM;
1071
1072	err = __netpoll_setup(np, ndev: port->dev);
1073	if (err) {
1074	kfree(objp: np);
1075	return err;
1076	}
1077	port->np = np;
1078	return err;
1079	}
1080
1081	static int team_port_enable_netpoll(struct team_port *port)
1082	{
1083	if (!port->team->dev->npinfo)
1084	return 0;
1085
1086	return __team_port_enable_netpoll(port);
1087	}
1088
1089	static void team_port_disable_netpoll(struct team_port *port)
1090	{
1091	struct netpoll *np = port->np;
1092
1093	if (!np)
1094	return;
1095	port->np = NULL;
1096
1097	__netpoll_free(np);
1098	}
1099	#else
1100	static int team_port_enable_netpoll(struct team_port *port)
1101	{
1102	return 0;
1103	}
1104	static void team_port_disable_netpoll(struct team_port *port)
1105	{
1106	}
1107	#endif
1108
1109	static int team_upper_dev_link(struct team *team, struct team_port *port,
1110	struct netlink_ext_ack *extack)
1111	{
1112	struct netdev_lag_upper_info lag_upper_info;
1113	int err;
1114
1115	lag_upper_info.tx_type = team->mode->lag_tx_type;
1116	lag_upper_info.hash_type = NETDEV_LAG_HASH_UNKNOWN;
1117	err = netdev_master_upper_dev_link(dev: port->dev, upper_dev: team->dev, NULL,
1118	upper_info: &lag_upper_info, extack);
1119	if (err)
1120	return err;
1121	port->dev->priv_flags |= IFF_TEAM_PORT;
1122	return 0;
1123	}
1124
1125	static void team_upper_dev_unlink(struct team *team, struct team_port *port)
1126	{
1127	netdev_upper_dev_unlink(dev: port->dev, upper_dev: team->dev);
1128	port->dev->priv_flags &= ~IFF_TEAM_PORT;
1129	}
1130
1131	static void __team_port_change_port_added(struct team_port *port, bool linkup);
1132	static int team_dev_type_check_change(struct net_device *dev,
1133	struct net_device *port_dev);
1134
1135	static int team_port_add(struct team *team, struct net_device *port_dev,
1136	struct netlink_ext_ack *extack)
1137	{
1138	struct net_device *dev = team->dev;
1139	struct team_port *port;
1140	char *portname = port_dev->name;
1141	int err;
1142
1143	if (port_dev->flags & IFF_LOOPBACK) {
1144	NL_SET_ERR_MSG(extack, "Loopback device can't be added as a team port");
1145	netdev_err(dev, format: "Device %s is loopback device. Loopback devices can't be added as a team port\n",
1146	portname);
1147	return -EINVAL;
1148	}
1149
1150	if (netif_is_team_port(dev: port_dev)) {
1151	NL_SET_ERR_MSG(extack, "Device is already a port of a team device");
1152	netdev_err(dev, format: "Device %s is already a port "
1153	"of a team device\n", portname);
1154	return -EBUSY;
1155	}
1156
1157	if (dev == port_dev) {
1158	NL_SET_ERR_MSG(extack, "Cannot enslave team device to itself");
1159	netdev_err(dev, format: "Cannot enslave team device to itself\n");
1160	return -EINVAL;
1161	}
1162
1163	if (netdev_has_upper_dev(dev, upper_dev: port_dev)) {
1164	NL_SET_ERR_MSG(extack, "Device is already an upper device of the team interface");
1165	netdev_err(dev, format: "Device %s is already an upper device of the team interface\n",
1166	portname);
1167	return -EBUSY;
1168	}
1169
1170	if (port_dev->features & NETIF_F_VLAN_CHALLENGED &&
1171	vlan_uses_dev(dev)) {
1172	NL_SET_ERR_MSG(extack, "Device is VLAN challenged and team device has VLAN set up");
1173	netdev_err(dev, format: "Device %s is VLAN challenged and team device has VLAN set up\n",
1174	portname);
1175	return -EPERM;
1176	}
1177
1178	err = team_dev_type_check_change(dev, port_dev);
1179	if (err)
1180	return err;
1181
1182	if (port_dev->flags & IFF_UP) {
1183	NL_SET_ERR_MSG(extack, "Device is up. Set it down before adding it as a team port");
1184	netdev_err(dev, format: "Device %s is up. Set it down before adding it as a team port\n",
1185	portname);
1186	return -EBUSY;
1187	}
1188
1189	port = kzalloc(size: sizeof(struct team_port) + team->mode->port_priv_size,
1190	GFP_KERNEL);
1191	if (!port)
1192	return -ENOMEM;
1193
1194	port->dev = port_dev;
1195	port->team = team;
1196	INIT_LIST_HEAD(list: &port->qom_list);
1197
1198	port->orig.mtu = port_dev->mtu;
1199	err = dev_set_mtu(port_dev, dev->mtu);
1200	if (err) {
1201	netdev_dbg(dev, "Error %d calling dev_set_mtu\n", err);
1202	goto err_set_mtu;
1203	}
1204
1205	memcpy(port->orig.dev_addr, port_dev->dev_addr, port_dev->addr_len);
1206
1207	err = team_port_enter(team, port);
1208	if (err) {
1209	netdev_err(dev, format: "Device %s failed to enter team mode\n",
1210	portname);
1211	goto err_port_enter;
1212	}
1213
1214	err = dev_open(dev: port_dev, extack);
1215	if (err) {
1216	netdev_dbg(dev, "Device %s opening failed\n",
1217	portname);
1218	goto err_dev_open;
1219	}
1220
1221	err = vlan_vids_add_by_dev(dev: port_dev, by_dev: dev);
1222	if (err) {
1223	netdev_err(dev, format: "Failed to add vlan ids to device %s\n",
1224	portname);
1225	goto err_vids_add;
1226	}
1227
1228	err = team_port_enable_netpoll(port);
1229	if (err) {
1230	netdev_err(dev, format: "Failed to enable netpoll on device %s\n",
1231	portname);
1232	goto err_enable_netpoll;
1233	}
1234
1235	if (!(dev->features & NETIF_F_LRO))
1236	dev_disable_lro(dev: port_dev);
1237
1238	err = netdev_rx_handler_register(dev: port_dev, rx_handler: team_handle_frame,
1239	rx_handler_data: port);
1240	if (err) {
1241	netdev_err(dev, format: "Device %s failed to register rx_handler\n",
1242	portname);
1243	goto err_handler_register;
1244	}
1245
1246	err = team_upper_dev_link(team, port, extack);
1247	if (err) {
1248	netdev_err(dev, format: "Device %s failed to set upper link\n",
1249	portname);
1250	goto err_set_upper_link;
1251	}
1252
1253	err = __team_option_inst_add_port(team, port);
1254	if (err) {
1255	netdev_err(dev, format: "Device %s failed to add per-port options\n",
1256	portname);
1257	goto err_option_port_add;
1258	}
1259
1260	/* set promiscuity level to new slave */
1261	if (dev->flags & IFF_PROMISC) {
1262	err = dev_set_promiscuity(dev: port_dev, inc: 1);
1263	if (err)
1264	goto err_set_slave_promisc;
1265	}
1266
1267	/* set allmulti level to new slave */
1268	if (dev->flags & IFF_ALLMULTI) {
1269	err = dev_set_allmulti(dev: port_dev, inc: 1);
1270	if (err) {
1271	if (dev->flags & IFF_PROMISC)
1272	dev_set_promiscuity(dev: port_dev, inc: -1);
1273	goto err_set_slave_promisc;
1274	}
1275	}
1276
1277	if (dev->flags & IFF_UP) {
1278	netif_addr_lock_bh(dev);
1279	dev_uc_sync_multiple(to: port_dev, from: dev);
1280	dev_mc_sync_multiple(to: port_dev, from: dev);
1281	netif_addr_unlock_bh(dev);
1282	}
1283
1284	port->index = -1;
1285	list_add_tail_rcu(new: &port->list, head: &team->port_list);
1286	team_port_enable(team, port);
1287	__team_compute_features(team);
1288	__team_port_change_port_added(port, linkup: !!netif_oper_up(dev: port_dev));
1289	__team_options_change_check(team);
1290
1291	netdev_info(dev, format: "Port device %s added\n", portname);
1292
1293	return 0;
1294
1295	err_set_slave_promisc:
1296	__team_option_inst_del_port(team, port);
1297
1298	err_option_port_add:
1299	team_upper_dev_unlink(team, port);
1300
1301	err_set_upper_link:
1302	netdev_rx_handler_unregister(dev: port_dev);
1303
1304	err_handler_register:
1305	team_port_disable_netpoll(port);
1306
1307	err_enable_netpoll:
1308	vlan_vids_del_by_dev(dev: port_dev, by_dev: dev);
1309
1310	err_vids_add:
1311	dev_close(dev: port_dev);
1312
1313	err_dev_open:
1314	team_port_leave(team, port);
1315	team_port_set_orig_dev_addr(port);
1316
1317	err_port_enter:
1318	dev_set_mtu(port_dev, port->orig.mtu);
1319
1320	err_set_mtu:
1321	kfree(objp: port);
1322
1323	return err;
1324	}
1325
1326	static void __team_port_change_port_removed(struct team_port *port);
1327
1328	static int team_port_del(struct team *team, struct net_device *port_dev)
1329	{
1330	struct net_device *dev = team->dev;
1331	struct team_port *port;
1332	char *portname = port_dev->name;
1333
1334	port = team_port_get_rtnl(dev: port_dev);
1335	if (!port || !team_port_find(team, port)) {
1336	netdev_err(dev, format: "Device %s does not act as a port of this team\n",
1337	portname);
1338	return -ENOENT;
1339	}
1340
1341	team_port_disable(team, port);
1342	list_del_rcu(entry: &port->list);
1343
1344	if (dev->flags & IFF_PROMISC)
1345	dev_set_promiscuity(dev: port_dev, inc: -1);
1346	if (dev->flags & IFF_ALLMULTI)
1347	dev_set_allmulti(dev: port_dev, inc: -1);
1348
1349	team_upper_dev_unlink(team, port);
1350	netdev_rx_handler_unregister(dev: port_dev);
1351	team_port_disable_netpoll(port);
1352	vlan_vids_del_by_dev(dev: port_dev, by_dev: dev);
1353	if (dev->flags & IFF_UP) {
1354	dev_uc_unsync(to: port_dev, from: dev);
1355	dev_mc_unsync(to: port_dev, from: dev);
1356	}
1357	dev_close(dev: port_dev);
1358	team_port_leave(team, port);
1359
1360	__team_option_inst_mark_removed_port(team, port);
1361	__team_options_change_check(team);
1362	__team_option_inst_del_port(team, port);
1363	__team_port_change_port_removed(port);
1364
1365	team_port_set_orig_dev_addr(port);
1366	dev_set_mtu(port_dev, port->orig.mtu);
1367	kfree_rcu(port, rcu);
1368	netdev_info(dev, format: "Port device %s removed\n", portname);
1369	__team_compute_features(team);
1370
1371	return 0;
1372	}
1373
1374
1375	/*****************
1376	* Net device ops
1377	*****************/
1378
1379	static void team_mode_option_get(struct team *team, struct team_gsetter_ctx *ctx)
1380	{
1381	ctx->data.str_val = team->mode->kind;
1382	}
1383
1384	static int team_mode_option_set(struct team *team, struct team_gsetter_ctx *ctx)
1385	{
1386	return team_change_mode(team, kind: ctx->data.str_val);
1387	}
1388
1389	static void team_notify_peers_count_get(struct team *team,
1390	struct team_gsetter_ctx *ctx)
1391	{
1392	ctx->data.u32_val = team->notify_peers.count;
1393	}
1394
1395	static int team_notify_peers_count_set(struct team *team,
1396	struct team_gsetter_ctx *ctx)
1397	{
1398	team->notify_peers.count = ctx->data.u32_val;
1399	return 0;
1400	}
1401
1402	static void team_notify_peers_interval_get(struct team *team,
1403	struct team_gsetter_ctx *ctx)
1404	{
1405	ctx->data.u32_val = team->notify_peers.interval;
1406	}
1407
1408	static int team_notify_peers_interval_set(struct team *team,
1409	struct team_gsetter_ctx *ctx)
1410	{
1411	team->notify_peers.interval = ctx->data.u32_val;
1412	return 0;
1413	}
1414
1415	static void team_mcast_rejoin_count_get(struct team *team,
1416	struct team_gsetter_ctx *ctx)
1417	{
1418	ctx->data.u32_val = team->mcast_rejoin.count;
1419	}
1420
1421	static int team_mcast_rejoin_count_set(struct team *team,
1422	struct team_gsetter_ctx *ctx)
1423	{
1424	team->mcast_rejoin.count = ctx->data.u32_val;
1425	return 0;
1426	}
1427
1428	static void team_mcast_rejoin_interval_get(struct team *team,
1429	struct team_gsetter_ctx *ctx)
1430	{
1431	ctx->data.u32_val = team->mcast_rejoin.interval;
1432	}
1433
1434	static int team_mcast_rejoin_interval_set(struct team *team,
1435	struct team_gsetter_ctx *ctx)
1436	{
1437	team->mcast_rejoin.interval = ctx->data.u32_val;
1438	return 0;
1439	}
1440
1441	static void team_port_en_option_get(struct team *team,
1442	struct team_gsetter_ctx *ctx)
1443	{
1444	struct team_port *port = ctx->info->port;
1445
1446	ctx->data.bool_val = team_port_enabled(port);
1447	}
1448
1449	static int team_port_en_option_set(struct team *team,
1450	struct team_gsetter_ctx *ctx)
1451	{
1452	struct team_port *port = ctx->info->port;
1453
1454	if (ctx->data.bool_val)
1455	team_port_enable(team, port);
1456	else
1457	team_port_disable(team, port);
1458	return 0;
1459	}
1460
1461	static void team_user_linkup_option_get(struct team *team,
1462	struct team_gsetter_ctx *ctx)
1463	{
1464	struct team_port *port = ctx->info->port;
1465
1466	ctx->data.bool_val = port->user.linkup;
1467	}
1468
1469	static void __team_carrier_check(struct team *team);
1470
1471	static int team_user_linkup_option_set(struct team *team,
1472	struct team_gsetter_ctx *ctx)
1473	{
1474	struct team_port *port = ctx->info->port;
1475
1476	port->user.linkup = ctx->data.bool_val;
1477	team_refresh_port_linkup(port);
1478	__team_carrier_check(team: port->team);
1479	return 0;
1480	}
1481
1482	static void team_user_linkup_en_option_get(struct team *team,
1483	struct team_gsetter_ctx *ctx)
1484	{
1485	struct team_port *port = ctx->info->port;
1486
1487	ctx->data.bool_val = port->user.linkup_enabled;
1488	}
1489
1490	static int team_user_linkup_en_option_set(struct team *team,
1491	struct team_gsetter_ctx *ctx)
1492	{
1493	struct team_port *port = ctx->info->port;
1494
1495	port->user.linkup_enabled = ctx->data.bool_val;
1496	team_refresh_port_linkup(port);
1497	__team_carrier_check(team: port->team);
1498	return 0;
1499	}
1500
1501	static void team_priority_option_get(struct team *team,
1502	struct team_gsetter_ctx *ctx)
1503	{
1504	struct team_port *port = ctx->info->port;
1505
1506	ctx->data.s32_val = port->priority;
1507	}
1508
1509	static int team_priority_option_set(struct team *team,
1510	struct team_gsetter_ctx *ctx)
1511	{
1512	struct team_port *port = ctx->info->port;
1513	s32 priority = ctx->data.s32_val;
1514
1515	if (port->priority == priority)
1516	return 0;
1517	port->priority = priority;
1518	team_queue_override_port_prio_changed(team, port);
1519	return 0;
1520	}
1521
1522	static void team_queue_id_option_get(struct team *team,
1523	struct team_gsetter_ctx *ctx)
1524	{
1525	struct team_port *port = ctx->info->port;
1526
1527	ctx->data.u32_val = port->queue_id;
1528	}
1529
1530	static int team_queue_id_option_set(struct team *team,
1531	struct team_gsetter_ctx *ctx)
1532	{
1533	struct team_port *port = ctx->info->port;
1534	u16 new_queue_id = ctx->data.u32_val;
1535
1536	if (port->queue_id == new_queue_id)
1537	return 0;
1538	if (new_queue_id >= team->dev->real_num_tx_queues)
1539	return -EINVAL;
1540	team_queue_override_port_change_queue_id(team, port, new_queue_id);
1541	return 0;
1542	}
1543
1544	static const struct team_option team_options[] = {
1545	{
1546	.name = "mode",
1547	.type = TEAM_OPTION_TYPE_STRING,
1548	.getter = team_mode_option_get,
1549	.setter = team_mode_option_set,
1550	},
1551	{
1552	.name = "notify_peers_count",
1553	.type = TEAM_OPTION_TYPE_U32,
1554	.getter = team_notify_peers_count_get,
1555	.setter = team_notify_peers_count_set,
1556	},
1557	{
1558	.name = "notify_peers_interval",
1559	.type = TEAM_OPTION_TYPE_U32,
1560	.getter = team_notify_peers_interval_get,
1561	.setter = team_notify_peers_interval_set,
1562	},
1563	{
1564	.name = "mcast_rejoin_count",
1565	.type = TEAM_OPTION_TYPE_U32,
1566	.getter = team_mcast_rejoin_count_get,
1567	.setter = team_mcast_rejoin_count_set,
1568	},
1569	{
1570	.name = "mcast_rejoin_interval",
1571	.type = TEAM_OPTION_TYPE_U32,
1572	.getter = team_mcast_rejoin_interval_get,
1573	.setter = team_mcast_rejoin_interval_set,
1574	},
1575	{
1576	.name = "enabled",
1577	.type = TEAM_OPTION_TYPE_BOOL,
1578	.per_port = true,
1579	.getter = team_port_en_option_get,
1580	.setter = team_port_en_option_set,
1581	},
1582	{
1583	.name = "user_linkup",
1584	.type = TEAM_OPTION_TYPE_BOOL,
1585	.per_port = true,
1586	.getter = team_user_linkup_option_get,
1587	.setter = team_user_linkup_option_set,
1588	},
1589	{
1590	.name = "user_linkup_enabled",
1591	.type = TEAM_OPTION_TYPE_BOOL,
1592	.per_port = true,
1593	.getter = team_user_linkup_en_option_get,
1594	.setter = team_user_linkup_en_option_set,
1595	},
1596	{
1597	.name = "priority",
1598	.type = TEAM_OPTION_TYPE_S32,
1599	.per_port = true,
1600	.getter = team_priority_option_get,
1601	.setter = team_priority_option_set,
1602	},
1603	{
1604	.name = "queue_id",
1605	.type = TEAM_OPTION_TYPE_U32,
1606	.per_port = true,
1607	.getter = team_queue_id_option_get,
1608	.setter = team_queue_id_option_set,
1609	},
1610	};
1611
1612
1613	static int team_init(struct net_device *dev)
1614	{
1615	struct team *team = netdev_priv(dev);
1616	int i;
1617	int err;
1618
1619	team->dev = dev;
1620	team_set_no_mode(team);
1621	team->notifier_ctx = false;
1622
1623	team->pcpu_stats = netdev_alloc_pcpu_stats(struct team_pcpu_stats);
1624	if (!team->pcpu_stats)
1625	return -ENOMEM;
1626
1627	for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
1628	INIT_HLIST_HEAD(&team->en_port_hlist[i]);
1629	INIT_LIST_HEAD(list: &team->port_list);
1630	err = team_queue_override_init(team);
1631	if (err)
1632	goto err_team_queue_override_init;
1633
1634	team_adjust_ops(team);
1635
1636	INIT_LIST_HEAD(list: &team->option_list);
1637	INIT_LIST_HEAD(list: &team->option_inst_list);
1638
1639	team_notify_peers_init(team);
1640	team_mcast_rejoin_init(team);
1641
1642	err = team_options_register(team, team_options, ARRAY_SIZE(team_options));
1643	if (err)
1644	goto err_options_register;
1645	netif_carrier_off(dev);
1646
1647	lockdep_register_key(key: &team->team_lock_key);
1648	__mutex_init(lock: &team->lock, name: "team->team_lock_key", key: &team->team_lock_key);
1649	netdev_lockdep_set_classes(dev);
1650
1651	return 0;
1652
1653	err_options_register:
1654	team_mcast_rejoin_fini(team);
1655	team_notify_peers_fini(team);
1656	team_queue_override_fini(team);
1657	err_team_queue_override_init:
1658	free_percpu(pdata: team->pcpu_stats);
1659
1660	return err;
1661	}
1662
1663	static void team_uninit(struct net_device *dev)
1664	{
1665	struct team *team = netdev_priv(dev);
1666	struct team_port *port;
1667	struct team_port *tmp;
1668
1669	mutex_lock(&team->lock);
1670	list_for_each_entry_safe(port, tmp, &team->port_list, list)
1671	team_port_del(team, port_dev: port->dev);
1672
1673	__team_change_mode(team, NULL); /* cleanup */
1674	__team_options_unregister(team, option: team_options, ARRAY_SIZE(team_options));
1675	team_mcast_rejoin_fini(team);
1676	team_notify_peers_fini(team);
1677	team_queue_override_fini(team);
1678	mutex_unlock(lock: &team->lock);
1679	netdev_change_features(dev);
1680	lockdep_unregister_key(key: &team->team_lock_key);
1681	}
1682
1683	static void team_destructor(struct net_device *dev)
1684	{
1685	struct team *team = netdev_priv(dev);
1686
1687	free_percpu(pdata: team->pcpu_stats);
1688	}
1689
1690	static int team_open(struct net_device *dev)
1691	{
1692	return 0;
1693	}
1694
1695	static int team_close(struct net_device *dev)
1696	{
1697	struct team *team = netdev_priv(dev);
1698	struct team_port *port;
1699
1700	list_for_each_entry(port, &team->port_list, list) {
1701	dev_uc_unsync(to: port->dev, from: dev);
1702	dev_mc_unsync(to: port->dev, from: dev);
1703	}
1704
1705	return 0;
1706	}
1707
1708	/*
1709	* note: already called with rcu_read_lock
1710	*/
1711	static netdev_tx_t team_xmit(struct sk_buff *skb, struct net_device *dev)
1712	{
1713	struct team *team = netdev_priv(dev);
1714	bool tx_success;
1715	unsigned int len = skb->len;
1716
1717	tx_success = team_queue_override_transmit(team, skb);
1718	if (!tx_success)
1719	tx_success = team->ops.transmit(team, skb);
1720	if (tx_success) {
1721	struct team_pcpu_stats *pcpu_stats;
1722
1723	pcpu_stats = this_cpu_ptr(team->pcpu_stats);
1724	u64_stats_update_begin(syncp: &pcpu_stats->syncp);
1725	u64_stats_inc(p: &pcpu_stats->tx_packets);
1726	u64_stats_add(p: &pcpu_stats->tx_bytes, val: len);
1727	u64_stats_update_end(syncp: &pcpu_stats->syncp);
1728	} else {
1729	this_cpu_inc(team->pcpu_stats->tx_dropped);
1730	}
1731
1732	return NETDEV_TX_OK;
1733	}
1734
1735	static u16 team_select_queue(struct net_device *dev, struct sk_buff *skb,
1736	struct net_device *sb_dev)
1737	{
1738	/*
1739	* This helper function exists to help dev_pick_tx get the correct
1740	* destination queue. Using a helper function skips a call to
1741	* skb_tx_hash and will put the skbs in the queue we expect on their
1742	* way down to the team driver.
1743	*/
1744	u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
1745
1746	/*
1747	* Save the original txq to restore before passing to the driver
1748	*/
1749	qdisc_skb_cb(skb)->slave_dev_queue_mapping = skb->queue_mapping;
1750
1751	if (unlikely(txq >= dev->real_num_tx_queues)) {
1752	do {
1753	txq -= dev->real_num_tx_queues;
1754	} while (txq >= dev->real_num_tx_queues);
1755	}
1756	return txq;
1757	}
1758
1759	static void team_change_rx_flags(struct net_device *dev, int change)
1760	{
1761	struct team *team = netdev_priv(dev);
1762	struct team_port *port;
1763	int inc;
1764
1765	rcu_read_lock();
1766	list_for_each_entry_rcu(port, &team->port_list, list) {
1767	if (change & IFF_PROMISC) {
1768	inc = dev->flags & IFF_PROMISC ? 1 : -1;
1769	dev_set_promiscuity(dev: port->dev, inc);
1770	}
1771	if (change & IFF_ALLMULTI) {
1772	inc = dev->flags & IFF_ALLMULTI ? 1 : -1;
1773	dev_set_allmulti(dev: port->dev, inc);
1774	}
1775	}
1776	rcu_read_unlock();
1777	}
1778
1779	static void team_set_rx_mode(struct net_device *dev)
1780	{
1781	struct team *team = netdev_priv(dev);
1782	struct team_port *port;
1783
1784	rcu_read_lock();
1785	list_for_each_entry_rcu(port, &team->port_list, list) {
1786	dev_uc_sync_multiple(to: port->dev, from: dev);
1787	dev_mc_sync_multiple(to: port->dev, from: dev);
1788	}
1789	rcu_read_unlock();
1790	}
1791
1792	static int team_set_mac_address(struct net_device *dev, void *p)
1793	{
1794	struct sockaddr *addr = p;
1795	struct team *team = netdev_priv(dev);
1796	struct team_port *port;
1797
1798	if (dev->type == ARPHRD_ETHER && !is_valid_ether_addr(addr: addr->sa_data))
1799	return -EADDRNOTAVAIL;
1800	dev_addr_set(dev, addr: addr->sa_data);
1801	mutex_lock(&team->lock);
1802	list_for_each_entry(port, &team->port_list, list)
1803	if (team->ops.port_change_dev_addr)
1804	team->ops.port_change_dev_addr(team, port);
1805	mutex_unlock(lock: &team->lock);
1806	return 0;
1807	}
1808
1809	static int team_change_mtu(struct net_device *dev, int new_mtu)
1810	{
1811	struct team *team = netdev_priv(dev);
1812	struct team_port *port;
1813	int err;
1814
1815	/*
1816	* Alhough this is reader, it's guarded by team lock. It's not possible
1817	* to traverse list in reverse under rcu_read_lock
1818	*/
1819	mutex_lock(&team->lock);
1820	team->port_mtu_change_allowed = true;
1821	list_for_each_entry(port, &team->port_list, list) {
1822	err = dev_set_mtu(port->dev, new_mtu);
1823	if (err) {
1824	netdev_err(dev, format: "Device %s failed to change mtu",
1825	port->dev->name);
1826	goto unwind;
1827	}
1828	}
1829	team->port_mtu_change_allowed = false;
1830	mutex_unlock(lock: &team->lock);
1831
1832	dev->mtu = new_mtu;
1833
1834	return 0;
1835
1836	unwind:
1837	list_for_each_entry_continue_reverse(port, &team->port_list, list)
1838	dev_set_mtu(port->dev, dev->mtu);
1839	team->port_mtu_change_allowed = false;
1840	mutex_unlock(lock: &team->lock);
1841
1842	return err;
1843	}
1844
1845	static void
1846	team_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
1847	{
1848	struct team *team = netdev_priv(dev);
1849	struct team_pcpu_stats *p;
1850	u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes;
1851	u32 rx_dropped = 0, tx_dropped = 0, rx_nohandler = 0;
1852	unsigned int start;
1853	int i;
1854
1855	for_each_possible_cpu(i) {
1856	p = per_cpu_ptr(team->pcpu_stats, i);
1857	do {
1858	start = u64_stats_fetch_begin(syncp: &p->syncp);
1859	rx_packets = u64_stats_read(p: &p->rx_packets);
1860	rx_bytes = u64_stats_read(p: &p->rx_bytes);
1861	rx_multicast = u64_stats_read(p: &p->rx_multicast);
1862	tx_packets = u64_stats_read(p: &p->tx_packets);
1863	tx_bytes = u64_stats_read(p: &p->tx_bytes);
1864	} while (u64_stats_fetch_retry(syncp: &p->syncp, start));
1865
1866	stats->rx_packets += rx_packets;
1867	stats->rx_bytes += rx_bytes;
1868	stats->multicast += rx_multicast;
1869	stats->tx_packets += tx_packets;
1870	stats->tx_bytes += tx_bytes;
1871	/*
1872	* rx_dropped, tx_dropped & rx_nohandler are u32,
1873	* updated without syncp protection.
1874	*/
1875	rx_dropped += READ_ONCE(p->rx_dropped);
1876	tx_dropped += READ_ONCE(p->tx_dropped);
1877	rx_nohandler += READ_ONCE(p->rx_nohandler);
1878	}
1879	stats->rx_dropped = rx_dropped;
1880	stats->tx_dropped = tx_dropped;
1881	stats->rx_nohandler = rx_nohandler;
1882	}
1883
1884	static int team_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid)
1885	{
1886	struct team *team = netdev_priv(dev);
1887	struct team_port *port;
1888	int err;
1889
1890	/*
1891	* Alhough this is reader, it's guarded by team lock. It's not possible
1892	* to traverse list in reverse under rcu_read_lock
1893	*/
1894	mutex_lock(&team->lock);
1895	list_for_each_entry(port, &team->port_list, list) {
1896	err = vlan_vid_add(dev: port->dev, proto, vid);
1897	if (err)
1898	goto unwind;
1899	}
1900	mutex_unlock(lock: &team->lock);
1901
1902	return 0;
1903
1904	unwind:
1905	list_for_each_entry_continue_reverse(port, &team->port_list, list)
1906	vlan_vid_del(dev: port->dev, proto, vid);
1907	mutex_unlock(lock: &team->lock);
1908
1909	return err;
1910	}
1911
1912	static int team_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, u16 vid)
1913	{
1914	struct team *team = netdev_priv(dev);
1915	struct team_port *port;
1916
1917	mutex_lock(&team->lock);
1918	list_for_each_entry(port, &team->port_list, list)
1919	vlan_vid_del(dev: port->dev, proto, vid);
1920	mutex_unlock(lock: &team->lock);
1921
1922	return 0;
1923	}
1924
1925	#ifdef CONFIG_NET_POLL_CONTROLLER
1926	static void team_poll_controller(struct net_device *dev)
1927	{
1928	}
1929
1930	static void __team_netpoll_cleanup(struct team *team)
1931	{
1932	struct team_port *port;
1933
1934	list_for_each_entry(port, &team->port_list, list)
1935	team_port_disable_netpoll(port);
1936	}
1937
1938	static void team_netpoll_cleanup(struct net_device *dev)
1939	{
1940	struct team *team = netdev_priv(dev);
1941
1942	mutex_lock(&team->lock);
1943	__team_netpoll_cleanup(team);
1944	mutex_unlock(lock: &team->lock);
1945	}
1946
1947	static int team_netpoll_setup(struct net_device *dev,
1948	struct netpoll_info *npifo)
1949	{
1950	struct team *team = netdev_priv(dev);
1951	struct team_port *port;
1952	int err = 0;
1953
1954	mutex_lock(&team->lock);
1955	list_for_each_entry(port, &team->port_list, list) {
1956	err = __team_port_enable_netpoll(port);
1957	if (err) {
1958	__team_netpoll_cleanup(team);
1959	break;
1960	}
1961	}
1962	mutex_unlock(lock: &team->lock);
1963	return err;
1964	}
1965	#endif
1966
1967	static int team_add_slave(struct net_device *dev, struct net_device *port_dev,
1968	struct netlink_ext_ack *extack)
1969	{
1970	struct team *team = netdev_priv(dev);
1971	int err;
1972
1973	mutex_lock(&team->lock);
1974	err = team_port_add(team, port_dev, extack);
1975	mutex_unlock(lock: &team->lock);
1976
1977	if (!err)
1978	netdev_change_features(dev);
1979
1980	return err;
1981	}
1982
1983	static int team_del_slave(struct net_device *dev, struct net_device *port_dev)
1984	{
1985	struct team *team = netdev_priv(dev);
1986	int err;
1987
1988	mutex_lock(&team->lock);
1989	err = team_port_del(team, port_dev);
1990	mutex_unlock(lock: &team->lock);
1991
1992	if (err)
1993	return err;
1994
1995	if (netif_is_team_master(dev: port_dev)) {
1996	lockdep_unregister_key(key: &team->team_lock_key);
1997	lockdep_register_key(key: &team->team_lock_key);
1998	lockdep_set_class(&team->lock, &team->team_lock_key);
1999	}
2000	netdev_change_features(dev);
2001
2002	return err;
2003	}
2004
2005	static netdev_features_t team_fix_features(struct net_device *dev,
2006	netdev_features_t features)
2007	{
2008	struct team_port *port;
2009	struct team *team = netdev_priv(dev);
2010	netdev_features_t mask;
2011
2012	mask = features;
2013	features &= ~NETIF_F_ONE_FOR_ALL;
2014	features |= NETIF_F_ALL_FOR_ALL;
2015
2016	rcu_read_lock();
2017	list_for_each_entry_rcu(port, &team->port_list, list) {
2018	features = netdev_increment_features(all: features,
2019	one: port->dev->features,
2020	mask);
2021	}
2022	rcu_read_unlock();
2023
2024	features = netdev_add_tso_features(features, mask);
2025
2026	return features;
2027	}
2028
2029	static int team_change_carrier(struct net_device *dev, bool new_carrier)
2030	{
2031	struct team *team = netdev_priv(dev);
2032
2033	team->user_carrier_enabled = true;
2034
2035	if (new_carrier)
2036	netif_carrier_on(dev);
2037	else
2038	netif_carrier_off(dev);
2039	return 0;
2040	}
2041
2042	static const struct net_device_ops team_netdev_ops = {
2043	.ndo_init = team_init,
2044	.ndo_uninit = team_uninit,
2045	.ndo_open = team_open,
2046	.ndo_stop = team_close,
2047	.ndo_start_xmit = team_xmit,
2048	.ndo_select_queue = team_select_queue,
2049	.ndo_change_rx_flags = team_change_rx_flags,
2050	.ndo_set_rx_mode = team_set_rx_mode,
2051	.ndo_set_mac_address = team_set_mac_address,
2052	.ndo_change_mtu = team_change_mtu,
2053	.ndo_get_stats64 = team_get_stats64,
2054	.ndo_vlan_rx_add_vid = team_vlan_rx_add_vid,
2055	.ndo_vlan_rx_kill_vid = team_vlan_rx_kill_vid,
2056	#ifdef CONFIG_NET_POLL_CONTROLLER
2057	.ndo_poll_controller = team_poll_controller,
2058	.ndo_netpoll_setup = team_netpoll_setup,
2059	.ndo_netpoll_cleanup = team_netpoll_cleanup,
2060	#endif
2061	.ndo_add_slave = team_add_slave,
2062	.ndo_del_slave = team_del_slave,
2063	.ndo_fix_features = team_fix_features,
2064	.ndo_change_carrier = team_change_carrier,
2065	.ndo_features_check = passthru_features_check,
2066	};
2067
2068	/***********************
2069	* ethtool interface
2070	***********************/
2071
2072	static void team_ethtool_get_drvinfo(struct net_device *dev,
2073	struct ethtool_drvinfo *drvinfo)
2074	{
2075	strscpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
2076	}
2077
2078	static int team_ethtool_get_link_ksettings(struct net_device *dev,
2079	struct ethtool_link_ksettings *cmd)
2080	{
2081	struct team *team= netdev_priv(dev);
2082	unsigned long speed = 0;
2083	struct team_port *port;
2084
2085	cmd->base.duplex = DUPLEX_UNKNOWN;
2086	cmd->base.port = PORT_OTHER;
2087
2088	rcu_read_lock();
2089	list_for_each_entry_rcu(port, &team->port_list, list) {
2090	if (team_port_txable(port)) {
2091	if (port->state.speed != SPEED_UNKNOWN)
2092	speed += port->state.speed;
2093	if (cmd->base.duplex == DUPLEX_UNKNOWN &&
2094	port->state.duplex != DUPLEX_UNKNOWN)
2095	cmd->base.duplex = port->state.duplex;
2096	}
2097	}
2098	rcu_read_unlock();
2099
2100	cmd->base.speed = speed ? : SPEED_UNKNOWN;
2101
2102	return 0;
2103	}
2104
2105	static const struct ethtool_ops team_ethtool_ops = {
2106	.get_drvinfo = team_ethtool_get_drvinfo,
2107	.get_link = ethtool_op_get_link,
2108	.get_link_ksettings = team_ethtool_get_link_ksettings,
2109	};
2110
2111	/***********************
2112	* rt netlink interface
2113	***********************/
2114
2115	static void team_setup_by_port(struct net_device *dev,
2116	struct net_device *port_dev)
2117	{
2118	struct team *team = netdev_priv(dev);
2119
2120	if (port_dev->type == ARPHRD_ETHER)
2121	dev->header_ops = team->header_ops_cache;
2122	else
2123	dev->header_ops = port_dev->header_ops;
2124	dev->type = port_dev->type;
2125	dev->hard_header_len = port_dev->hard_header_len;
2126	dev->needed_headroom = port_dev->needed_headroom;
2127	dev->addr_len = port_dev->addr_len;
2128	dev->mtu = port_dev->mtu;
2129	memcpy(dev->broadcast, port_dev->broadcast, port_dev->addr_len);
2130	eth_hw_addr_inherit(dst: dev, src: port_dev);
2131
2132	if (port_dev->flags & IFF_POINTOPOINT) {
2133	dev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST);
2134	dev->flags |= (IFF_POINTOPOINT | IFF_NOARP);
2135	} else if ((port_dev->flags & (IFF_BROADCAST | IFF_MULTICAST)) ==
2136	(IFF_BROADCAST | IFF_MULTICAST)) {
2137	dev->flags |= (IFF_BROADCAST | IFF_MULTICAST);
2138	dev->flags &= ~(IFF_POINTOPOINT | IFF_NOARP);
2139	}
2140	}
2141
2142	static int team_dev_type_check_change(struct net_device *dev,
2143	struct net_device *port_dev)
2144	{
2145	struct team *team = netdev_priv(dev);
2146	char *portname = port_dev->name;
2147	int err;
2148
2149	if (dev->type == port_dev->type)
2150	return 0;
2151	if (!list_empty(head: &team->port_list)) {
2152	netdev_err(dev, format: "Device %s is of different type\n", portname);
2153	return -EBUSY;
2154	}
2155	err = call_netdevice_notifiers(val: NETDEV_PRE_TYPE_CHANGE, dev);
2156	err = notifier_to_errno(ret: err);
2157	if (err) {
2158	netdev_err(dev, format: "Refused to change device type\n");
2159	return err;
2160	}
2161	dev_uc_flush(dev);
2162	dev_mc_flush(dev);
2163	team_setup_by_port(dev, port_dev);
2164	call_netdevice_notifiers(val: NETDEV_POST_TYPE_CHANGE, dev);
2165	return 0;
2166	}
2167
2168	static void team_setup(struct net_device *dev)
2169	{
2170	struct team *team = netdev_priv(dev);
2171
2172	ether_setup(dev);
2173	dev->max_mtu = ETH_MAX_MTU;
2174	team->header_ops_cache = dev->header_ops;
2175
2176	dev->netdev_ops = &team_netdev_ops;
2177	dev->ethtool_ops = &team_ethtool_ops;
2178	dev->needs_free_netdev = true;
2179	dev->priv_destructor = team_destructor;
2180	dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
2181	dev->priv_flags |= IFF_NO_QUEUE;
2182	dev->priv_flags |= IFF_TEAM;
2183
2184	/*
2185	* Indicate we support unicast address filtering. That way core won't
2186	* bring us to promisc mode in case a unicast addr is added.
2187	* Let this up to underlay drivers.
2188	*/
2189	dev->priv_flags |= IFF_UNICAST_FLT | IFF_LIVE_ADDR_CHANGE;
2190
2191	dev->features |= NETIF_F_LLTX;
2192	dev->features |= NETIF_F_GRO;
2193
2194	/* Don't allow team devices to change network namespaces. */
2195	dev->features |= NETIF_F_NETNS_LOCAL;
2196
2197	dev->hw_features = TEAM_VLAN_FEATURES |
2198	NETIF_F_HW_VLAN_CTAG_RX |
2199	NETIF_F_HW_VLAN_CTAG_FILTER |
2200	NETIF_F_HW_VLAN_STAG_RX |
2201	NETIF_F_HW_VLAN_STAG_FILTER;
2202
2203	dev->hw_features |= NETIF_F_GSO_ENCAP_ALL;
2204	dev->features |= dev->hw_features;
2205	dev->features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
2206	}
2207
2208	static int team_newlink(struct net *src_net, struct net_device *dev,
2209	struct nlattr *tb[], struct nlattr *data[],
2210	struct netlink_ext_ack *extack)
2211	{
2212	if (tb[IFLA_ADDRESS] == NULL)
2213	eth_hw_addr_random(dev);
2214
2215	return register_netdevice(dev);
2216	}
2217
2218	static int team_validate(struct nlattr *tb[], struct nlattr *data[],
2219	struct netlink_ext_ack *extack)
2220	{
2221	if (tb[IFLA_ADDRESS]) {
2222	if (nla_len(nla: tb[IFLA_ADDRESS]) != ETH_ALEN)
2223	return -EINVAL;
2224	if (!is_valid_ether_addr(addr: nla_data(nla: tb[IFLA_ADDRESS])))
2225	return -EADDRNOTAVAIL;
2226	}
2227	return 0;
2228	}
2229
2230	static unsigned int team_get_num_tx_queues(void)
2231	{
2232	return TEAM_DEFAULT_NUM_TX_QUEUES;
2233	}
2234
2235	static unsigned int team_get_num_rx_queues(void)
2236	{
2237	return TEAM_DEFAULT_NUM_RX_QUEUES;
2238	}
2239
2240	static struct rtnl_link_ops team_link_ops __read_mostly = {
2241	.kind = DRV_NAME,
2242	.priv_size = sizeof(struct team),
2243	.setup = team_setup,
2244	.newlink = team_newlink,
2245	.validate = team_validate,
2246	.get_num_tx_queues = team_get_num_tx_queues,
2247	.get_num_rx_queues = team_get_num_rx_queues,
2248	};
2249
2250
2251	/***********************************
2252	* Generic netlink custom interface
2253	***********************************/
2254
2255	static struct genl_family team_nl_family;
2256
2257	static const struct nla_policy team_nl_policy[TEAM_ATTR_MAX + 1] = {
2258	[TEAM_ATTR_UNSPEC] = { .type = NLA_UNSPEC, },
2259	[TEAM_ATTR_TEAM_IFINDEX] = { .type = NLA_U32 },
2260	[TEAM_ATTR_LIST_OPTION] = { .type = NLA_NESTED },
2261	[TEAM_ATTR_LIST_PORT] = { .type = NLA_NESTED },
2262	};
2263
2264	static const struct nla_policy
2265	team_nl_option_policy[TEAM_ATTR_OPTION_MAX + 1] = {
2266	[TEAM_ATTR_OPTION_UNSPEC] = { .type = NLA_UNSPEC, },
2267	[TEAM_ATTR_OPTION_NAME] = {
2268	.type = NLA_STRING,
2269	.len = TEAM_STRING_MAX_LEN,
2270	},
2271	[TEAM_ATTR_OPTION_CHANGED] = { .type = NLA_FLAG },
2272	[TEAM_ATTR_OPTION_TYPE] = { .type = NLA_U8 },
2273	[TEAM_ATTR_OPTION_DATA] = { .type = NLA_BINARY },
2274	[TEAM_ATTR_OPTION_PORT_IFINDEX] = { .type = NLA_U32 },
2275	[TEAM_ATTR_OPTION_ARRAY_INDEX] = { .type = NLA_U32 },
2276	};
2277
2278	static int team_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
2279	{
2280	struct sk_buff *msg;
2281	void *hdr;
2282	int err;
2283
2284	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2285	if (!msg)
2286	return -ENOMEM;
2287
2288	hdr = genlmsg_put(skb: msg, portid: info->snd_portid, seq: info->snd_seq,
2289	family: &team_nl_family, flags: 0, cmd: TEAM_CMD_NOOP);
2290	if (!hdr) {
2291	err = -EMSGSIZE;
2292	goto err_msg_put;
2293	}
2294
2295	genlmsg_end(skb: msg, hdr);
2296
2297	return genlmsg_unicast(net: genl_info_net(info), skb: msg, portid: info->snd_portid);
2298
2299	err_msg_put:
2300	nlmsg_free(skb: msg);
2301
2302	return err;
2303	}
2304
2305	/*
2306	* Netlink cmd functions should be locked by following two functions.
2307	* Since dev gets held here, that ensures dev won't disappear in between.
2308	*/
2309	static struct team *team_nl_team_get(struct genl_info *info)
2310	{
2311	struct net *net = genl_info_net(info);
2312	int ifindex;
2313	struct net_device *dev;
2314	struct team *team;
2315
2316	if (!info->attrs[TEAM_ATTR_TEAM_IFINDEX])
2317	return NULL;
2318
2319	ifindex = nla_get_u32(nla: info->attrs[TEAM_ATTR_TEAM_IFINDEX]);
2320	dev = dev_get_by_index(net, ifindex);
2321	if (!dev || dev->netdev_ops != &team_netdev_ops) {
2322	dev_put(dev);
2323	return NULL;
2324	}
2325
2326	team = netdev_priv(dev);
2327	mutex_lock(&team->lock);
2328	return team;
2329	}
2330
2331	static void team_nl_team_put(struct team *team)
2332	{
2333	mutex_unlock(lock: &team->lock);
2334	dev_put(dev: team->dev);
2335	}
2336
2337	typedef int team_nl_send_func_t(struct sk_buff *skb,
2338	struct team *team, u32 portid);
2339
2340	static int team_nl_send_unicast(struct sk_buff *skb, struct team *team, u32 portid)
2341	{
2342	return genlmsg_unicast(net: dev_net(dev: team->dev), skb, portid);
2343	}
2344
2345	static int team_nl_fill_one_option_get(struct sk_buff *skb, struct team *team,
2346	struct team_option_inst *opt_inst)
2347	{
2348	struct nlattr *option_item;
2349	struct team_option *option = opt_inst->option;
2350	struct team_option_inst_info *opt_inst_info = &opt_inst->info;
2351	struct team_gsetter_ctx ctx;
2352	int err;
2353
2354	ctx.info = opt_inst_info;
2355	err = team_option_get(team, opt_inst, ctx: &ctx);
2356	if (err)
2357	return err;
2358
2359	option_item = nla_nest_start_noflag(skb, attrtype: TEAM_ATTR_ITEM_OPTION);
2360	if (!option_item)
2361	return -EMSGSIZE;
2362
2363	if (nla_put_string(skb, attrtype: TEAM_ATTR_OPTION_NAME, str: option->name))
2364	goto nest_cancel;
2365	if (opt_inst_info->port &&
2366	nla_put_u32(skb, attrtype: TEAM_ATTR_OPTION_PORT_IFINDEX,
2367	value: opt_inst_info->port->dev->ifindex))
2368	goto nest_cancel;
2369	if (opt_inst->option->array_size &&
2370	nla_put_u32(skb, attrtype: TEAM_ATTR_OPTION_ARRAY_INDEX,
2371	value: opt_inst_info->array_index))
2372	goto nest_cancel;
2373
2374	switch (option->type) {
2375	case TEAM_OPTION_TYPE_U32:
2376	if (nla_put_u8(skb, attrtype: TEAM_ATTR_OPTION_TYPE, value: NLA_U32))
2377	goto nest_cancel;
2378	if (nla_put_u32(skb, attrtype: TEAM_ATTR_OPTION_DATA, value: ctx.data.u32_val))
2379	goto nest_cancel;
2380	break;
2381	case TEAM_OPTION_TYPE_STRING:
2382	if (nla_put_u8(skb, attrtype: TEAM_ATTR_OPTION_TYPE, value: NLA_STRING))
2383	goto nest_cancel;
2384	if (nla_put_string(skb, attrtype: TEAM_ATTR_OPTION_DATA,
2385	str: ctx.data.str_val))
2386	goto nest_cancel;
2387	break;
2388	case TEAM_OPTION_TYPE_BINARY:
2389	if (nla_put_u8(skb, attrtype: TEAM_ATTR_OPTION_TYPE, value: NLA_BINARY))
2390	goto nest_cancel;
2391	if (nla_put(skb, attrtype: TEAM_ATTR_OPTION_DATA, attrlen: ctx.data.bin_val.len,
2392	data: ctx.data.bin_val.ptr))
2393	goto nest_cancel;
2394	break;
2395	case TEAM_OPTION_TYPE_BOOL:
2396	if (nla_put_u8(skb, attrtype: TEAM_ATTR_OPTION_TYPE, value: NLA_FLAG))
2397	goto nest_cancel;
2398	if (ctx.data.bool_val &&
2399	nla_put_flag(skb, attrtype: TEAM_ATTR_OPTION_DATA))
2400	goto nest_cancel;
2401	break;
2402	case TEAM_OPTION_TYPE_S32:
2403	if (nla_put_u8(skb, attrtype: TEAM_ATTR_OPTION_TYPE, value: NLA_S32))
2404	goto nest_cancel;
2405	if (nla_put_s32(skb, attrtype: TEAM_ATTR_OPTION_DATA, value: ctx.data.s32_val))
2406	goto nest_cancel;
2407	break;
2408	default:
2409	BUG();
2410	}
2411	if (opt_inst->removed && nla_put_flag(skb, attrtype: TEAM_ATTR_OPTION_REMOVED))
2412	goto nest_cancel;
2413	if (opt_inst->changed) {
2414	if (nla_put_flag(skb, attrtype: TEAM_ATTR_OPTION_CHANGED))
2415	goto nest_cancel;
2416	opt_inst->changed = false;
2417	}
2418	nla_nest_end(skb, start: option_item);
2419	return 0;
2420
2421	nest_cancel:
2422	nla_nest_cancel(skb, start: option_item);
2423	return -EMSGSIZE;
2424	}
2425
2426	static int __send_and_alloc_skb(struct sk_buff **pskb,
2427	struct team *team, u32 portid,
2428	team_nl_send_func_t *send_func)
2429	{
2430	int err;
2431
2432	if (*pskb) {
2433	err = send_func(*pskb, team, portid);
2434	if (err)
2435	return err;
2436	}
2437	*pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2438	if (!*pskb)
2439	return -ENOMEM;
2440	return 0;
2441	}
2442
2443	static int team_nl_send_options_get(struct team *team, u32 portid, u32 seq,
2444	int flags, team_nl_send_func_t *send_func,
2445	struct list_head *sel_opt_inst_list)
2446	{
2447	struct nlattr *option_list;
2448	struct nlmsghdr *nlh;
2449	void *hdr;
2450	struct team_option_inst *opt_inst;
2451	int err;
2452	struct sk_buff *skb = NULL;
2453	bool incomplete;
2454	int i;
2455
2456	opt_inst = list_first_entry(sel_opt_inst_list,
2457	struct team_option_inst, tmp_list);
2458
2459	start_again:
2460	err = __send_and_alloc_skb(pskb: &skb, team, portid, send_func);
2461	if (err)
2462	return err;
2463
2464	hdr = genlmsg_put(skb, portid, seq, family: &team_nl_family, flags: flags | NLM_F_MULTI,
2465	cmd: TEAM_CMD_OPTIONS_GET);
2466	if (!hdr) {
2467	nlmsg_free(skb);
2468	return -EMSGSIZE;
2469	}
2470
2471	if (nla_put_u32(skb, attrtype: TEAM_ATTR_TEAM_IFINDEX, value: team->dev->ifindex))
2472	goto nla_put_failure;
2473	option_list = nla_nest_start_noflag(skb, attrtype: TEAM_ATTR_LIST_OPTION);
2474	if (!option_list)
2475	goto nla_put_failure;
2476
2477	i = 0;
2478	incomplete = false;
2479	list_for_each_entry_from(opt_inst, sel_opt_inst_list, tmp_list) {
2480	err = team_nl_fill_one_option_get(skb, team, opt_inst);
2481	if (err) {
2482	if (err == -EMSGSIZE) {
2483	if (!i)
2484	goto errout;
2485	incomplete = true;
2486	break;
2487	}
2488	goto errout;
2489	}
2490	i++;
2491	}
2492
2493	nla_nest_end(skb, start: option_list);
2494	genlmsg_end(skb, hdr);
2495	if (incomplete)
2496	goto start_again;
2497
2498	send_done:
2499	nlh = nlmsg_put(skb, portid, seq, NLMSG_DONE, payload: 0, flags: flags | NLM_F_MULTI);
2500	if (!nlh) {
2501	err = __send_and_alloc_skb(pskb: &skb, team, portid, send_func);
2502	if (err)
2503	return err;
2504	goto send_done;
2505	}
2506
2507	return send_func(skb, team, portid);
2508
2509	nla_put_failure:
2510	err = -EMSGSIZE;
2511	errout:
2512	nlmsg_free(skb);
2513	return err;
2514	}
2515
2516	static int team_nl_cmd_options_get(struct sk_buff *skb, struct genl_info *info)
2517	{
2518	struct team *team;
2519	struct team_option_inst *opt_inst;
2520	int err;
2521	LIST_HEAD(sel_opt_inst_list);
2522
2523	team = team_nl_team_get(info);
2524	if (!team)
2525	return -EINVAL;
2526
2527	list_for_each_entry(opt_inst, &team->option_inst_list, list)
2528	list_add_tail(new: &opt_inst->tmp_list, head: &sel_opt_inst_list);
2529	err = team_nl_send_options_get(team, portid: info->snd_portid, seq: info->snd_seq,
2530	NLM_F_ACK, send_func: team_nl_send_unicast,
2531	sel_opt_inst_list: &sel_opt_inst_list);
2532
2533	team_nl_team_put(team);
2534
2535	return err;
2536	}
2537
2538	static int team_nl_send_event_options_get(struct team *team,
2539	struct list_head *sel_opt_inst_list);
2540
2541	static int team_nl_cmd_options_set(struct sk_buff *skb, struct genl_info *info)
2542	{
2543	struct team *team;
2544	int err = 0;
2545	int i;
2546	struct nlattr *nl_option;
2547
2548	rtnl_lock();
2549
2550	team = team_nl_team_get(info);
2551	if (!team) {
2552	err = -EINVAL;
2553	goto rtnl_unlock;
2554	}
2555
2556	err = -EINVAL;
2557	if (!info->attrs[TEAM_ATTR_LIST_OPTION]) {
2558	err = -EINVAL;
2559	goto team_put;
2560	}
2561
2562	nla_for_each_nested(nl_option, info->attrs[TEAM_ATTR_LIST_OPTION], i) {
2563	struct nlattr *opt_attrs[TEAM_ATTR_OPTION_MAX + 1];
2564	struct nlattr *attr;
2565	struct nlattr *attr_data;
2566	LIST_HEAD(opt_inst_list);
2567	enum team_option_type opt_type;
2568	int opt_port_ifindex = 0; /* != 0 for per-port options */
2569	u32 opt_array_index = 0;
2570	bool opt_is_array = false;
2571	struct team_option_inst *opt_inst;
2572	char *opt_name;
2573	bool opt_found = false;
2574
2575	if (nla_type(nla: nl_option) != TEAM_ATTR_ITEM_OPTION) {
2576	err = -EINVAL;
2577	goto team_put;
2578	}
2579	err = nla_parse_nested_deprecated(tb: opt_attrs,
2580	maxtype: TEAM_ATTR_OPTION_MAX,
2581	nla: nl_option,
2582	policy: team_nl_option_policy,
2583	extack: info->extack);
2584	if (err)
2585	goto team_put;
2586	if (!opt_attrs[TEAM_ATTR_OPTION_NAME] ||
2587	!opt_attrs[TEAM_ATTR_OPTION_TYPE]) {
2588	err = -EINVAL;
2589	goto team_put;
2590	}
2591	switch (nla_get_u8(nla: opt_attrs[TEAM_ATTR_OPTION_TYPE])) {
2592	case NLA_U32:
2593	opt_type = TEAM_OPTION_TYPE_U32;
2594	break;
2595	case NLA_STRING:
2596	opt_type = TEAM_OPTION_TYPE_STRING;
2597	break;
2598	case NLA_BINARY:
2599	opt_type = TEAM_OPTION_TYPE_BINARY;
2600	break;
2601	case NLA_FLAG:
2602	opt_type = TEAM_OPTION_TYPE_BOOL;
2603	break;
2604	case NLA_S32:
2605	opt_type = TEAM_OPTION_TYPE_S32;
2606	break;
2607	default:
2608	goto team_put;
2609	}
2610
2611	attr_data = opt_attrs[TEAM_ATTR_OPTION_DATA];
2612	if (opt_type != TEAM_OPTION_TYPE_BOOL && !attr_data) {
2613	err = -EINVAL;
2614	goto team_put;
2615	}
2616
2617	opt_name = nla_data(nla: opt_attrs[TEAM_ATTR_OPTION_NAME]);
2618	attr = opt_attrs[TEAM_ATTR_OPTION_PORT_IFINDEX];
2619	if (attr)
2620	opt_port_ifindex = nla_get_u32(nla: attr);
2621
2622	attr = opt_attrs[TEAM_ATTR_OPTION_ARRAY_INDEX];
2623	if (attr) {
2624	opt_is_array = true;
2625	opt_array_index = nla_get_u32(nla: attr);
2626	}
2627
2628	list_for_each_entry(opt_inst, &team->option_inst_list, list) {
2629	struct team_option *option = opt_inst->option;
2630	struct team_gsetter_ctx ctx;
2631	struct team_option_inst_info *opt_inst_info;
2632	int tmp_ifindex;
2633
2634	opt_inst_info = &opt_inst->info;
2635	tmp_ifindex = opt_inst_info->port ?
2636	opt_inst_info->port->dev->ifindex : 0;
2637	if (option->type != opt_type ||
2638	strcmp(option->name, opt_name) ||
2639	tmp_ifindex != opt_port_ifindex ||
2640	(option->array_size && !opt_is_array) ||
2641	opt_inst_info->array_index != opt_array_index)
2642	continue;
2643	opt_found = true;
2644	ctx.info = opt_inst_info;
2645	switch (opt_type) {
2646	case TEAM_OPTION_TYPE_U32:
2647	ctx.data.u32_val = nla_get_u32(nla: attr_data);
2648	break;
2649	case TEAM_OPTION_TYPE_STRING:
2650	if (nla_len(nla: attr_data) > TEAM_STRING_MAX_LEN) {
2651	err = -EINVAL;
2652	goto team_put;
2653	}
2654	ctx.data.str_val = nla_data(nla: attr_data);
2655	break;
2656	case TEAM_OPTION_TYPE_BINARY:
2657	ctx.data.bin_val.len = nla_len(nla: attr_data);
2658	ctx.data.bin_val.ptr = nla_data(nla: attr_data);
2659	break;
2660	case TEAM_OPTION_TYPE_BOOL:
2661	ctx.data.bool_val = attr_data ? true : false;
2662	break;
2663	case TEAM_OPTION_TYPE_S32:
2664	ctx.data.s32_val = nla_get_s32(nla: attr_data);
2665	break;
2666	default:
2667	BUG();
2668	}
2669	err = team_option_set(team, opt_inst, ctx: &ctx);
2670	if (err)
2671	goto team_put;
2672	opt_inst->changed = true;
2673	list_add(new: &opt_inst->tmp_list, head: &opt_inst_list);
2674	}
2675	if (!opt_found) {
2676	err = -ENOENT;
2677	goto team_put;
2678	}
2679
2680	err = team_nl_send_event_options_get(team, sel_opt_inst_list: &opt_inst_list);
2681	if (err)
2682	break;
2683	}
2684
2685	team_put:
2686	team_nl_team_put(team);
2687	rtnl_unlock:
2688	rtnl_unlock();
2689	return err;
2690	}
2691
2692	static int team_nl_fill_one_port_get(struct sk_buff *skb,
2693	struct team_port *port)
2694	{
2695	struct nlattr *port_item;
2696
2697	port_item = nla_nest_start_noflag(skb, attrtype: TEAM_ATTR_ITEM_PORT);
2698	if (!port_item)
2699	goto nest_cancel;
2700	if (nla_put_u32(skb, attrtype: TEAM_ATTR_PORT_IFINDEX, value: port->dev->ifindex))
2701	goto nest_cancel;
2702	if (port->changed) {
2703	if (nla_put_flag(skb, attrtype: TEAM_ATTR_PORT_CHANGED))
2704	goto nest_cancel;
2705	port->changed = false;
2706	}
2707	if ((port->removed &&
2708	nla_put_flag(skb, attrtype: TEAM_ATTR_PORT_REMOVED)) ||
2709	(port->state.linkup &&
2710	nla_put_flag(skb, attrtype: TEAM_ATTR_PORT_LINKUP)) ||
2711	nla_put_u32(skb, attrtype: TEAM_ATTR_PORT_SPEED, value: port->state.speed) ||
2712	nla_put_u8(skb, attrtype: TEAM_ATTR_PORT_DUPLEX, value: port->state.duplex))
2713	goto nest_cancel;
2714	nla_nest_end(skb, start: port_item);
2715	return 0;
2716
2717	nest_cancel:
2718	nla_nest_cancel(skb, start: port_item);
2719	return -EMSGSIZE;
2720	}
2721
2722	static int team_nl_send_port_list_get(struct team *team, u32 portid, u32 seq,
2723	int flags, team_nl_send_func_t *send_func,
2724	struct team_port *one_port)
2725	{
2726	struct nlattr *port_list;
2727	struct nlmsghdr *nlh;
2728	void *hdr;
2729	struct team_port *port;
2730	int err;
2731	struct sk_buff *skb = NULL;
2732	bool incomplete;
2733	int i;
2734
2735	port = list_first_entry_or_null(&team->port_list,
2736	struct team_port, list);
2737
2738	start_again:
2739	err = __send_and_alloc_skb(pskb: &skb, team, portid, send_func);
2740	if (err)
2741	return err;
2742
2743	hdr = genlmsg_put(skb, portid, seq, family: &team_nl_family, flags: flags | NLM_F_MULTI,
2744	cmd: TEAM_CMD_PORT_LIST_GET);
2745	if (!hdr) {
2746	nlmsg_free(skb);
2747	return -EMSGSIZE;
2748	}
2749
2750	if (nla_put_u32(skb, attrtype: TEAM_ATTR_TEAM_IFINDEX, value: team->dev->ifindex))
2751	goto nla_put_failure;
2752	port_list = nla_nest_start_noflag(skb, attrtype: TEAM_ATTR_LIST_PORT);
2753	if (!port_list)
2754	goto nla_put_failure;
2755
2756	i = 0;
2757	incomplete = false;
2758
2759	/* If one port is selected, called wants to send port list containing
2760	* only this port. Otherwise go through all listed ports and send all
2761	*/
2762	if (one_port) {
2763	err = team_nl_fill_one_port_get(skb, port: one_port);
2764	if (err)
2765	goto errout;
2766	} else if (port) {
2767	list_for_each_entry_from(port, &team->port_list, list) {
2768	err = team_nl_fill_one_port_get(skb, port);
2769	if (err) {
2770	if (err == -EMSGSIZE) {
2771	if (!i)
2772	goto errout;
2773	incomplete = true;
2774	break;
2775	}
2776	goto errout;
2777	}
2778	i++;
2779	}
2780	}
2781
2782	nla_nest_end(skb, start: port_list);
2783	genlmsg_end(skb, hdr);
2784	if (incomplete)
2785	goto start_again;
2786
2787	send_done:
2788	nlh = nlmsg_put(skb, portid, seq, NLMSG_DONE, payload: 0, flags: flags | NLM_F_MULTI);
2789	if (!nlh) {
2790	err = __send_and_alloc_skb(pskb: &skb, team, portid, send_func);
2791	if (err)
2792	return err;
2793	goto send_done;
2794	}
2795
2796	return send_func(skb, team, portid);
2797
2798	nla_put_failure:
2799	err = -EMSGSIZE;
2800	errout:
2801	nlmsg_free(skb);
2802	return err;
2803	}
2804
2805	static int team_nl_cmd_port_list_get(struct sk_buff *skb,
2806	struct genl_info *info)
2807	{
2808	struct team *team;
2809	int err;
2810
2811	team = team_nl_team_get(info);
2812	if (!team)
2813	return -EINVAL;
2814
2815	err = team_nl_send_port_list_get(team, portid: info->snd_portid, seq: info->snd_seq,
2816	NLM_F_ACK, send_func: team_nl_send_unicast, NULL);
2817
2818	team_nl_team_put(team);
2819
2820	return err;
2821	}
2822
2823	static const struct genl_small_ops team_nl_ops[] = {
2824	{
2825	.cmd = TEAM_CMD_NOOP,
2826	.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
2827	.doit = team_nl_cmd_noop,
2828	},
2829	{
2830	.cmd = TEAM_CMD_OPTIONS_SET,
2831	.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
2832	.doit = team_nl_cmd_options_set,
2833	.flags = GENL_ADMIN_PERM,
2834	},
2835	{
2836	.cmd = TEAM_CMD_OPTIONS_GET,
2837	.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
2838	.doit = team_nl_cmd_options_get,
2839	.flags = GENL_ADMIN_PERM,
2840	},
2841	{
2842	.cmd = TEAM_CMD_PORT_LIST_GET,
2843	.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
2844	.doit = team_nl_cmd_port_list_get,
2845	.flags = GENL_ADMIN_PERM,
2846	},
2847	};
2848
2849	static const struct genl_multicast_group team_nl_mcgrps[] = {
2850	{ .name = TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME, },
2851	};
2852
2853	static struct genl_family team_nl_family __ro_after_init = {
2854	.name = TEAM_GENL_NAME,
2855	.version = TEAM_GENL_VERSION,
2856	.maxattr = TEAM_ATTR_MAX,
2857	.policy = team_nl_policy,
2858	.netnsok = true,
2859	.module = THIS_MODULE,
2860	.small_ops = team_nl_ops,
2861	.n_small_ops = ARRAY_SIZE(team_nl_ops),
2862	.resv_start_op = TEAM_CMD_PORT_LIST_GET + 1,
2863	.mcgrps = team_nl_mcgrps,
2864	.n_mcgrps = ARRAY_SIZE(team_nl_mcgrps),
2865	};
2866
2867	static int team_nl_send_multicast(struct sk_buff *skb,
2868	struct team *team, u32 portid)
2869	{
2870	return genlmsg_multicast_netns(family: &team_nl_family, net: dev_net(dev: team->dev),
2871	skb, portid: 0, group: 0, GFP_KERNEL);
2872	}
2873
2874	static int team_nl_send_event_options_get(struct team *team,
2875	struct list_head *sel_opt_inst_list)
2876	{
2877	return team_nl_send_options_get(team, portid: 0, seq: 0, flags: 0, send_func: team_nl_send_multicast,
2878	sel_opt_inst_list);
2879	}
2880
2881	static int team_nl_send_event_port_get(struct team *team,
2882	struct team_port *port)
2883	{
2884	return team_nl_send_port_list_get(team, portid: 0, seq: 0, flags: 0, send_func: team_nl_send_multicast,
2885	one_port: port);
2886	}
2887
2888	static int __init team_nl_init(void)
2889	{
2890	return genl_register_family(family: &team_nl_family);
2891	}
2892
2893	static void __exit team_nl_fini(void)
2894	{
2895	genl_unregister_family(family: &team_nl_family);
2896	}
2897
2898
2899	/******************
2900	* Change checkers
2901	******************/
2902
2903	static void __team_options_change_check(struct team *team)
2904	{
2905	int err;
2906	struct team_option_inst *opt_inst;
2907	LIST_HEAD(sel_opt_inst_list);
2908
2909	list_for_each_entry(opt_inst, &team->option_inst_list, list) {
2910	if (opt_inst->changed)
2911	list_add_tail(new: &opt_inst->tmp_list, head: &sel_opt_inst_list);
2912	}
2913	err = team_nl_send_event_options_get(team, sel_opt_inst_list: &sel_opt_inst_list);
2914	if (err && err != -ESRCH)
2915	netdev_warn(dev: team->dev, format: "Failed to send options change via netlink (err %d)\n",
2916	err);
2917	}
2918
2919	/* rtnl lock is held */
2920
2921	static void __team_port_change_send(struct team_port *port, bool linkup)
2922	{
2923	int err;
2924
2925	port->changed = true;
2926	port->state.linkup = linkup;
2927	team_refresh_port_linkup(port);
2928	if (linkup) {
2929	struct ethtool_link_ksettings ecmd;
2930
2931	err = __ethtool_get_link_ksettings(dev: port->dev, link_ksettings: &ecmd);
2932	if (!err) {
2933	port->state.speed = ecmd.base.speed;
2934	port->state.duplex = ecmd.base.duplex;
2935	goto send_event;
2936	}
2937	}
2938	port->state.speed = 0;
2939	port->state.duplex = 0;
2940
2941	send_event:
2942	err = team_nl_send_event_port_get(team: port->team, port);
2943	if (err && err != -ESRCH)
2944	netdev_warn(dev: port->team->dev, format: "Failed to send port change of device %s via netlink (err %d)\n",
2945	port->dev->name, err);
2946
2947	}
2948
2949	static void __team_carrier_check(struct team *team)
2950	{
2951	struct team_port *port;
2952	bool team_linkup;
2953
2954	if (team->user_carrier_enabled)
2955	return;
2956
2957	team_linkup = false;
2958	list_for_each_entry(port, &team->port_list, list) {
2959	if (port->linkup) {
2960	team_linkup = true;
2961	break;
2962	}
2963	}
2964
2965	if (team_linkup)
2966	netif_carrier_on(dev: team->dev);
2967	else
2968	netif_carrier_off(dev: team->dev);
2969	}
2970
2971	static void __team_port_change_check(struct team_port *port, bool linkup)
2972	{
2973	if (port->state.linkup != linkup)
2974	__team_port_change_send(port, linkup);
2975	__team_carrier_check(team: port->team);
2976	}
2977
2978	static void __team_port_change_port_added(struct team_port *port, bool linkup)
2979	{
2980	__team_port_change_send(port, linkup);
2981	__team_carrier_check(team: port->team);
2982	}
2983
2984	static void __team_port_change_port_removed(struct team_port *port)
2985	{
2986	port->removed = true;
2987	__team_port_change_send(port, linkup: false);
2988	__team_carrier_check(team: port->team);
2989	}
2990
2991	static void team_port_change_check(struct team_port *port, bool linkup)
2992	{
2993	struct team *team = port->team;
2994
2995	mutex_lock(&team->lock);
2996	__team_port_change_check(port, linkup);
2997	mutex_unlock(lock: &team->lock);
2998	}
2999
3000
3001	/************************************
3002	* Net device notifier event handler
3003	************************************/
3004
3005	static int team_device_event(struct notifier_block *unused,
3006	unsigned long event, void *ptr)
3007	{
3008	struct net_device *dev = netdev_notifier_info_to_dev(info: ptr);
3009	struct team_port *port;
3010
3011	port = team_port_get_rtnl(dev);
3012	if (!port)
3013	return NOTIFY_DONE;
3014
3015	switch (event) {
3016	case NETDEV_UP:
3017	if (netif_oper_up(dev))
3018	team_port_change_check(port, linkup: true);
3019	break;
3020	case NETDEV_DOWN:
3021	team_port_change_check(port, linkup: false);
3022	break;
3023	case NETDEV_CHANGE:
3024	if (netif_running(dev: port->dev))
3025	team_port_change_check(port,
3026	linkup: !!netif_oper_up(dev: port->dev));
3027	break;
3028	case NETDEV_UNREGISTER:
3029	team_del_slave(dev: port->team->dev, port_dev: dev);
3030	break;
3031	case NETDEV_FEAT_CHANGE:
3032	if (!port->team->notifier_ctx) {
3033	port->team->notifier_ctx = true;
3034	team_compute_features(team: port->team);
3035	port->team->notifier_ctx = false;
3036	}
3037	break;
3038	case NETDEV_PRECHANGEMTU:
3039	/* Forbid to change mtu of underlaying device */
3040	if (!port->team->port_mtu_change_allowed)
3041	return NOTIFY_BAD;
3042	break;
3043	case NETDEV_PRE_TYPE_CHANGE:
3044	/* Forbid to change type of underlaying device */
3045	return NOTIFY_BAD;
3046	case NETDEV_RESEND_IGMP:
3047	/* Propagate to master device */
3048	call_netdevice_notifiers(val: event, dev: port->team->dev);
3049	break;
3050	}
3051	return NOTIFY_DONE;
3052	}
3053
3054	static struct notifier_block team_notifier_block __read_mostly = {
3055	.notifier_call = team_device_event,
3056	};
3057
3058
3059	/***********************
3060	* Module init and exit
3061	***********************/
3062
3063	static int __init team_module_init(void)
3064	{
3065	int err;
3066
3067	register_netdevice_notifier(nb: &team_notifier_block);
3068
3069	err = rtnl_link_register(ops: &team_link_ops);
3070	if (err)
3071	goto err_rtnl_reg;
3072
3073	err = team_nl_init();
3074	if (err)
3075	goto err_nl_init;
3076
3077	return 0;
3078
3079	err_nl_init:
3080	rtnl_link_unregister(ops: &team_link_ops);
3081
3082	err_rtnl_reg:
3083	unregister_netdevice_notifier(nb: &team_notifier_block);
3084
3085	return err;
3086	}
3087
3088	static void __exit team_module_exit(void)
3089	{
3090	team_nl_fini();
3091	rtnl_link_unregister(ops: &team_link_ops);
3092	unregister_netdevice_notifier(nb: &team_notifier_block);
3093	}
3094
3095	module_init(team_module_init);
3096	module_exit(team_module_exit);
3097
3098	MODULE_LICENSE("GPL v2");
3099	MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
3100	MODULE_DESCRIPTION("Ethernet team device driver");
3101	MODULE_ALIAS_RTNL_LINK(DRV_NAME);
3102