Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
team.c
Go to the documentation of this file.
1 /*
2  * drivers/net/team/team.c - Network team device driver
3  * Copyright (c) 2011 Jiri Pirko <[email protected]>
4  *
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.
9  */
10 
11 #include <linux/kernel.h>
12 #include <linux/types.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/rcupdate.h>
17 #include <linux/errno.h>
18 #include <linux/ctype.h>
19 #include <linux/notifier.h>
20 #include <linux/netdevice.h>
21 #include <linux/netpoll.h>
22 #include <linux/if_vlan.h>
23 #include <linux/if_arp.h>
24 #include <linux/socket.h>
25 #include <linux/etherdevice.h>
26 #include <linux/rtnetlink.h>
27 #include <net/rtnetlink.h>
28 #include <net/genetlink.h>
29 #include <net/netlink.h>
30 #include <net/sch_generic.h>
31 #include <linux/if_team.h>
32 
33 #define DRV_NAME "team"
34 
35 
36 /**********
37  * Helpers
38  **********/
39 
40 #define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT)
41 
42 static struct team_port *team_port_get_rcu(const struct net_device *dev)
43 {
45 
46  return team_port_exists(dev) ? port : NULL;
47 }
48 
49 static struct team_port *team_port_get_rtnl(const struct net_device *dev)
50 {
52 
53  return team_port_exists(dev) ? port : NULL;
54 }
55 
56 /*
57  * Since the ability to change device address for open port device is tested in
58  * team_port_add, this function can be called without control of return value
59  */
60 static int __set_port_dev_addr(struct net_device *port_dev,
61  const unsigned char *dev_addr)
62 {
63  struct sockaddr addr;
64 
65  memcpy(addr.sa_data, dev_addr, port_dev->addr_len);
66  addr.sa_family = port_dev->type;
67  return dev_set_mac_address(port_dev, &addr);
68 }
69 
70 static int team_port_set_orig_dev_addr(struct team_port *port)
71 {
72  return __set_port_dev_addr(port->dev, port->orig.dev_addr);
73 }
74 
76 {
77  return __set_port_dev_addr(port->dev, port->team->dev->dev_addr);
78 }
80 
81 static void team_refresh_port_linkup(struct team_port *port)
82 {
83  port->linkup = port->user.linkup_enabled ? port->user.linkup :
84  port->state.linkup;
85 }
86 
87 
88 /*******************
89  * Options handling
90  *******************/
91 
92 struct team_option_inst { /* One for each option instance */
93  struct list_head list;
97  bool changed;
98  bool removed;
99 };
100 
101 static struct team_option *__team_find_option(struct team *team,
102  const char *opt_name)
103 {
104  struct team_option *option;
105 
106  list_for_each_entry(option, &team->option_list, list) {
107  if (strcmp(option->name, opt_name) == 0)
108  return option;
109  }
110  return NULL;
111 }
112 
113 static void __team_option_inst_del(struct team_option_inst *opt_inst)
114 {
115  list_del(&opt_inst->list);
116  kfree(opt_inst);
117 }
118 
119 static void __team_option_inst_del_option(struct team *team,
120  struct team_option *option)
121 {
122  struct team_option_inst *opt_inst, *tmp;
123 
124  list_for_each_entry_safe(opt_inst, tmp, &team->option_inst_list, list) {
125  if (opt_inst->option == option)
126  __team_option_inst_del(opt_inst);
127  }
128 }
129 
130 static int __team_option_inst_add(struct team *team, struct team_option *option,
131  struct team_port *port)
132 {
133  struct team_option_inst *opt_inst;
134  unsigned int array_size;
135  unsigned int i;
136  int err;
137 
138  array_size = option->array_size;
139  if (!array_size)
140  array_size = 1; /* No array but still need one instance */
141 
142  for (i = 0; i < array_size; i++) {
143  opt_inst = kmalloc(sizeof(*opt_inst), GFP_KERNEL);
144  if (!opt_inst)
145  return -ENOMEM;
146  opt_inst->option = option;
147  opt_inst->info.port = port;
148  opt_inst->info.array_index = i;
149  opt_inst->changed = true;
150  opt_inst->removed = false;
151  list_add_tail(&opt_inst->list, &team->option_inst_list);
152  if (option->init) {
153  err = option->init(team, &opt_inst->info);
154  if (err)
155  return err;
156  }
157 
158  }
159  return 0;
160 }
161 
162 static int __team_option_inst_add_option(struct team *team,
163  struct team_option *option)
164 {
165  struct team_port *port;
166  int err;
167 
168  if (!option->per_port) {
169  err = __team_option_inst_add(team, option, NULL);
170  if (err)
171  goto inst_del_option;
172  }
173 
174  list_for_each_entry(port, &team->port_list, list) {
175  err = __team_option_inst_add(team, option, port);
176  if (err)
177  goto inst_del_option;
178  }
179  return 0;
180 
181 inst_del_option:
182  __team_option_inst_del_option(team, option);
183  return err;
184 }
185 
186 static void __team_option_inst_mark_removed_option(struct team *team,
187  struct team_option *option)
188 {
189  struct team_option_inst *opt_inst;
190 
191  list_for_each_entry(opt_inst, &team->option_inst_list, list) {
192  if (opt_inst->option == option) {
193  opt_inst->changed = true;
194  opt_inst->removed = true;
195  }
196  }
197 }
198 
199 static void __team_option_inst_del_port(struct team *team,
200  struct team_port *port)
201 {
202  struct team_option_inst *opt_inst, *tmp;
203 
204  list_for_each_entry_safe(opt_inst, tmp, &team->option_inst_list, list) {
205  if (opt_inst->option->per_port &&
206  opt_inst->info.port == port)
207  __team_option_inst_del(opt_inst);
208  }
209 }
210 
211 static int __team_option_inst_add_port(struct team *team,
212  struct team_port *port)
213 {
214  struct team_option *option;
215  int err;
216 
217  list_for_each_entry(option, &team->option_list, list) {
218  if (!option->per_port)
219  continue;
220  err = __team_option_inst_add(team, option, port);
221  if (err)
222  goto inst_del_port;
223  }
224  return 0;
225 
226 inst_del_port:
227  __team_option_inst_del_port(team, port);
228  return err;
229 }
230 
231 static void __team_option_inst_mark_removed_port(struct team *team,
232  struct team_port *port)
233 {
234  struct team_option_inst *opt_inst;
235 
236  list_for_each_entry(opt_inst, &team->option_inst_list, list) {
237  if (opt_inst->info.port == port) {
238  opt_inst->changed = true;
239  opt_inst->removed = true;
240  }
241  }
242 }
243 
244 static int __team_options_register(struct team *team,
245  const struct team_option *option,
246  size_t option_count)
247 {
248  int i;
249  struct team_option **dst_opts;
250  int err;
251 
252  dst_opts = kzalloc(sizeof(struct team_option *) * option_count,
253  GFP_KERNEL);
254  if (!dst_opts)
255  return -ENOMEM;
256  for (i = 0; i < option_count; i++, option++) {
257  if (__team_find_option(team, option->name)) {
258  err = -EEXIST;
259  goto alloc_rollback;
260  }
261  dst_opts[i] = kmemdup(option, sizeof(*option), GFP_KERNEL);
262  if (!dst_opts[i]) {
263  err = -ENOMEM;
264  goto alloc_rollback;
265  }
266  }
267 
268  for (i = 0; i < option_count; i++) {
269  err = __team_option_inst_add_option(team, dst_opts[i]);
270  if (err)
271  goto inst_rollback;
272  list_add_tail(&dst_opts[i]->list, &team->option_list);
273  }
274 
275  kfree(dst_opts);
276  return 0;
277 
278 inst_rollback:
279  for (i--; i >= 0; i--)
280  __team_option_inst_del_option(team, dst_opts[i]);
281 
282  i = option_count - 1;
283 alloc_rollback:
284  for (i--; i >= 0; i--)
285  kfree(dst_opts[i]);
286 
287  kfree(dst_opts);
288  return err;
289 }
290 
291 static void __team_options_mark_removed(struct team *team,
292  const struct team_option *option,
293  size_t option_count)
294 {
295  int i;
296 
297  for (i = 0; i < option_count; i++, option++) {
298  struct team_option *del_opt;
299 
300  del_opt = __team_find_option(team, option->name);
301  if (del_opt)
302  __team_option_inst_mark_removed_option(team, del_opt);
303  }
304 }
305 
306 static void __team_options_unregister(struct team *team,
307  const struct team_option *option,
308  size_t option_count)
309 {
310  int i;
311 
312  for (i = 0; i < option_count; i++, option++) {
313  struct team_option *del_opt;
314 
315  del_opt = __team_find_option(team, option->name);
316  if (del_opt) {
317  __team_option_inst_del_option(team, del_opt);
318  list_del(&del_opt->list);
319  kfree(del_opt);
320  }
321  }
322 }
323 
324 static void __team_options_change_check(struct team *team);
325 
326 int team_options_register(struct team *team,
327  const struct team_option *option,
328  size_t option_count)
329 {
330  int err;
331 
332  err = __team_options_register(team, option, option_count);
333  if (err)
334  return err;
335  __team_options_change_check(team);
336  return 0;
337 }
339 
340 void team_options_unregister(struct team *team,
341  const struct team_option *option,
342  size_t option_count)
343 {
344  __team_options_mark_removed(team, option, option_count);
345  __team_options_change_check(team);
346  __team_options_unregister(team, option, option_count);
347 }
349 
350 static int team_option_get(struct team *team,
351  struct team_option_inst *opt_inst,
352  struct team_gsetter_ctx *ctx)
353 {
354  if (!opt_inst->option->getter)
355  return -EOPNOTSUPP;
356  return opt_inst->option->getter(team, ctx);
357 }
358 
359 static int team_option_set(struct team *team,
360  struct team_option_inst *opt_inst,
361  struct team_gsetter_ctx *ctx)
362 {
363  if (!opt_inst->option->setter)
364  return -EOPNOTSUPP;
365  return opt_inst->option->setter(team, ctx);
366 }
367 
369 {
370  struct team_option_inst *opt_inst;
371 
372  opt_inst = container_of(opt_inst_info, struct team_option_inst, info);
373  opt_inst->changed = true;
374 }
376 
377 void team_options_change_check(struct team *team)
378 {
379  __team_options_change_check(team);
380 }
382 
383 
384 /****************
385  * Mode handling
386  ****************/
387 
388 static LIST_HEAD(mode_list);
389 static DEFINE_SPINLOCK(mode_list_lock);
390 
392  struct list_head list;
393  const struct team_mode *mode;
394 };
395 
396 static struct team_mode_item *__find_mode(const char *kind)
397 {
398  struct team_mode_item *mitem;
399 
400  list_for_each_entry(mitem, &mode_list, list) {
401  if (strcmp(mitem->mode->kind, kind) == 0)
402  return mitem;
403  }
404  return NULL;
405 }
406 
407 static bool is_good_mode_name(const char *name)
408 {
409  while (*name != '\0') {
410  if (!isalpha(*name) && !isdigit(*name) && *name != '_')
411  return false;
412  name++;
413  }
414  return true;
415 }
416 
418 {
419  int err = 0;
420  struct team_mode_item *mitem;
421 
422  if (!is_good_mode_name(mode->kind) ||
424  return -EINVAL;
425 
426  mitem = kmalloc(sizeof(*mitem), GFP_KERNEL);
427  if (!mitem)
428  return -ENOMEM;
429 
430  spin_lock(&mode_list_lock);
431  if (__find_mode(mode->kind)) {
432  err = -EEXIST;
433  kfree(mitem);
434  goto unlock;
435  }
436  mitem->mode = mode;
437  list_add_tail(&mitem->list, &mode_list);
438 unlock:
439  spin_unlock(&mode_list_lock);
440  return err;
441 }
443 
445 {
446  struct team_mode_item *mitem;
447 
448  spin_lock(&mode_list_lock);
449  mitem = __find_mode(mode->kind);
450  if (mitem) {
451  list_del_init(&mitem->list);
452  kfree(mitem);
453  }
454  spin_unlock(&mode_list_lock);
455 }
457 
458 static const struct team_mode *team_mode_get(const char *kind)
459 {
460  struct team_mode_item *mitem;
461  const struct team_mode *mode = NULL;
462 
463  spin_lock(&mode_list_lock);
464  mitem = __find_mode(kind);
465  if (!mitem) {
466  spin_unlock(&mode_list_lock);
467  request_module("team-mode-%s", kind);
468  spin_lock(&mode_list_lock);
469  mitem = __find_mode(kind);
470  }
471  if (mitem) {
472  mode = mitem->mode;
473  if (!try_module_get(mode->owner))
474  mode = NULL;
475  }
476 
477  spin_unlock(&mode_list_lock);
478  return mode;
479 }
480 
481 static void team_mode_put(const struct team_mode *mode)
482 {
483  module_put(mode->owner);
484 }
485 
486 static bool team_dummy_transmit(struct team *team, struct sk_buff *skb)
487 {
488  dev_kfree_skb_any(skb);
489  return false;
490 }
491 
493  struct team_port *port,
494  struct sk_buff *skb)
495 {
496  return RX_HANDLER_ANOTHER;
497 }
498 
499 static const struct team_mode __team_no_mode = {
500  .kind = "*NOMODE*",
501 };
502 
503 static bool team_is_mode_set(struct team *team)
504 {
505  return team->mode != &__team_no_mode;
506 }
507 
508 static void team_set_no_mode(struct team *team)
509 {
510  team->mode = &__team_no_mode;
511 }
512 
513 static void __team_adjust_ops(struct team *team, int en_port_count)
514 {
515  /*
516  * To avoid checks in rx/tx skb paths, ensure here that non-null and
517  * correct ops are always set.
518  */
519 
520  if (!en_port_count || !team_is_mode_set(team) ||
521  !team->mode->ops->transmit)
522  team->ops.transmit = team_dummy_transmit;
523  else
524  team->ops.transmit = team->mode->ops->transmit;
525 
526  if (!en_port_count || !team_is_mode_set(team) ||
527  !team->mode->ops->receive)
528  team->ops.receive = team_dummy_receive;
529  else
530  team->ops.receive = team->mode->ops->receive;
531 }
532 
533 static void team_adjust_ops(struct team *team)
534 {
535  __team_adjust_ops(team, team->en_port_count);
536 }
537 
538 /*
539  * We can benefit from the fact that it's ensured no port is present
540  * at the time of mode change. Therefore no packets are in fly so there's no
541  * need to set mode operations in any special way.
542  */
543 static int __team_change_mode(struct team *team,
544  const struct team_mode *new_mode)
545 {
546  /* Check if mode was previously set and do cleanup if so */
547  if (team_is_mode_set(team)) {
548  void (*exit_op)(struct team *team) = team->ops.exit;
549 
550  /* Clear ops area so no callback is called any longer */
551  memset(&team->ops, 0, sizeof(struct team_mode_ops));
552  team_adjust_ops(team);
553 
554  if (exit_op)
555  exit_op(team);
556  team_mode_put(team->mode);
557  team_set_no_mode(team);
558  /* zero private data area */
559  memset(&team->mode_priv, 0,
560  sizeof(struct team) - offsetof(struct team, mode_priv));
561  }
562 
563  if (!new_mode)
564  return 0;
565 
566  if (new_mode->ops->init) {
567  int err;
568 
569  err = new_mode->ops->init(team);
570  if (err)
571  return err;
572  }
573 
574  team->mode = new_mode;
575  memcpy(&team->ops, new_mode->ops, sizeof(struct team_mode_ops));
576  team_adjust_ops(team);
577 
578  return 0;
579 }
580 
581 static int team_change_mode(struct team *team, const char *kind)
582 {
583  const struct team_mode *new_mode;
584  struct net_device *dev = team->dev;
585  int err;
586 
587  if (!list_empty(&team->port_list)) {
588  netdev_err(dev, "No ports can be present during mode change\n");
589  return -EBUSY;
590  }
591 
592  if (team_is_mode_set(team) && strcmp(team->mode->kind, kind) == 0) {
593  netdev_err(dev, "Unable to change to the same mode the team is in\n");
594  return -EINVAL;
595  }
596 
597  new_mode = team_mode_get(kind);
598  if (!new_mode) {
599  netdev_err(dev, "Mode \"%s\" not found\n", kind);
600  return -EINVAL;
601  }
602 
603  err = __team_change_mode(team, new_mode);
604  if (err) {
605  netdev_err(dev, "Failed to change to mode \"%s\"\n", kind);
606  team_mode_put(new_mode);
607  return err;
608  }
609 
610  netdev_info(dev, "Mode changed to \"%s\"\n", kind);
611  return 0;
612 }
613 
614 
615 /************************
616  * Rx path frame handler
617  ************************/
618 
619 /* note: already called with rcu_read_lock */
620 static rx_handler_result_t team_handle_frame(struct sk_buff **pskb)
621 {
622  struct sk_buff *skb = *pskb;
623  struct team_port *port;
624  struct team *team;
626 
627  skb = skb_share_check(skb, GFP_ATOMIC);
628  if (!skb)
629  return RX_HANDLER_CONSUMED;
630 
631  *pskb = skb;
632 
633  port = team_port_get_rcu(skb->dev);
634  team = port->team;
635  if (!team_port_enabled(port)) {
636  /* allow exact match delivery for disabled ports */
637  res = RX_HANDLER_EXACT;
638  } else {
639  res = team->ops.receive(team, port, skb);
640  }
641  if (res == RX_HANDLER_ANOTHER) {
642  struct team_pcpu_stats *pcpu_stats;
643 
644  pcpu_stats = this_cpu_ptr(team->pcpu_stats);
645  u64_stats_update_begin(&pcpu_stats->syncp);
646  pcpu_stats->rx_packets++;
647  pcpu_stats->rx_bytes += skb->len;
648  if (skb->pkt_type == PACKET_MULTICAST)
649  pcpu_stats->rx_multicast++;
650  u64_stats_update_end(&pcpu_stats->syncp);
651 
652  skb->dev = team->dev;
653  } else {
654  this_cpu_inc(team->pcpu_stats->rx_dropped);
655  }
656 
657  return res;
658 }
659 
660 
661 /*************************************
662  * Multiqueue Tx port select override
663  *************************************/
664 
665 static int team_queue_override_init(struct team *team)
666 {
667  struct list_head *listarr;
668  unsigned int queue_cnt = team->dev->num_tx_queues - 1;
669  unsigned int i;
670 
671  if (!queue_cnt)
672  return 0;
673  listarr = kmalloc(sizeof(struct list_head) * queue_cnt, GFP_KERNEL);
674  if (!listarr)
675  return -ENOMEM;
676  team->qom_lists = listarr;
677  for (i = 0; i < queue_cnt; i++)
678  INIT_LIST_HEAD(listarr++);
679  return 0;
680 }
681 
682 static void team_queue_override_fini(struct team *team)
683 {
684  kfree(team->qom_lists);
685 }
686 
687 static struct list_head *__team_get_qom_list(struct team *team, u16 queue_id)
688 {
689  return &team->qom_lists[queue_id - 1];
690 }
691 
692 /*
693  * note: already called with rcu_read_lock
694  */
695 static bool team_queue_override_transmit(struct team *team, struct sk_buff *skb)
696 {
697  struct list_head *qom_list;
698  struct team_port *port;
699 
700  if (!team->queue_override_enabled || !skb->queue_mapping)
701  return false;
702  qom_list = __team_get_qom_list(team, skb->queue_mapping);
703  list_for_each_entry_rcu(port, qom_list, qom_list) {
704  if (!team_dev_queue_xmit(team, port, skb))
705  return true;
706  }
707  return false;
708 }
709 
710 static void __team_queue_override_port_del(struct team *team,
711  struct team_port *port)
712 {
713  list_del_rcu(&port->qom_list);
714  synchronize_rcu();
715  INIT_LIST_HEAD(&port->qom_list);
716 }
717 
718 static bool team_queue_override_port_has_gt_prio_than(struct team_port *port,
719  struct team_port *cur)
720 {
721  if (port->priority < cur->priority)
722  return true;
723  if (port->priority > cur->priority)
724  return false;
725  if (port->index < cur->index)
726  return true;
727  return false;
728 }
729 
730 static void __team_queue_override_port_add(struct team *team,
731  struct team_port *port)
732 {
733  struct team_port *cur;
734  struct list_head *qom_list;
735  struct list_head *node;
736 
737  if (!port->queue_id || !team_port_enabled(port))
738  return;
739 
740  qom_list = __team_get_qom_list(team, port->queue_id);
741  node = qom_list;
742  list_for_each_entry(cur, qom_list, qom_list) {
743  if (team_queue_override_port_has_gt_prio_than(port, cur))
744  break;
745  node = &cur->qom_list;
746  }
747  list_add_tail_rcu(&port->qom_list, node);
748 }
749 
750 static void __team_queue_override_enabled_check(struct team *team)
751 {
752  struct team_port *port;
753  bool enabled = false;
754 
755  list_for_each_entry(port, &team->port_list, list) {
756  if (!list_empty(&port->qom_list)) {
757  enabled = true;
758  break;
759  }
760  }
761  if (enabled == team->queue_override_enabled)
762  return;
763  netdev_dbg(team->dev, "%s queue override\n",
764  enabled ? "Enabling" : "Disabling");
766 }
767 
768 static void team_queue_override_port_refresh(struct team *team,
769  struct team_port *port)
770 {
771  __team_queue_override_port_del(team, port);
772  __team_queue_override_port_add(team, port);
773  __team_queue_override_enabled_check(team);
774 }
775 
776 
777 /****************
778  * Port handling
779  ****************/
780 
781 static bool team_port_find(const struct team *team,
782  const struct team_port *port)
783 {
784  struct team_port *cur;
785 
786  list_for_each_entry(cur, &team->port_list, list)
787  if (cur == port)
788  return true;
789  return false;
790 }
791 
792 /*
793  * Enable/disable port by adding to enabled port hashlist and setting
794  * port->index (Might be racy so reader could see incorrect ifindex when
795  * processing a flying packet, but that is not a problem). Write guarded
796  * by team->lock.
797  */
798 static void team_port_enable(struct team *team,
799  struct team_port *port)
800 {
801  if (team_port_enabled(port))
802  return;
803  port->index = team->en_port_count++;
804  hlist_add_head_rcu(&port->hlist,
805  team_port_index_hash(team, port->index));
806  team_adjust_ops(team);
807  team_queue_override_port_refresh(team, port);
808  if (team->ops.port_enabled)
809  team->ops.port_enabled(team, port);
810 }
811 
812 static void __reconstruct_port_hlist(struct team *team, int rm_index)
813 {
814  int i;
815  struct team_port *port;
816 
817  for (i = rm_index + 1; i < team->en_port_count; i++) {
818  port = team_get_port_by_index(team, i);
819  hlist_del_rcu(&port->hlist);
820  port->index--;
821  hlist_add_head_rcu(&port->hlist,
822  team_port_index_hash(team, port->index));
823  }
824 }
825 
826 static void team_port_disable(struct team *team,
827  struct team_port *port)
828 {
829  if (!team_port_enabled(port))
830  return;
831  if (team->ops.port_disabled)
832  team->ops.port_disabled(team, port);
833  hlist_del_rcu(&port->hlist);
834  __reconstruct_port_hlist(team, port->index);
835  port->index = -1;
836  team_queue_override_port_refresh(team, port);
837  __team_adjust_ops(team, team->en_port_count - 1);
838  /*
839  * Wait until readers see adjusted ops. This ensures that
840  * readers never see team->en_port_count == 0
841  */
842  synchronize_rcu();
843  team->en_port_count--;
844 }
845 
846 #define TEAM_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
847  NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
848  NETIF_F_HIGHDMA | NETIF_F_LRO)
849 
850 static void __team_compute_features(struct team *team)
851 {
852  struct team_port *port;
853  u32 vlan_features = TEAM_VLAN_FEATURES;
854  unsigned short max_hard_header_len = ETH_HLEN;
855  unsigned int flags, dst_release_flag = IFF_XMIT_DST_RELEASE;
856 
857  list_for_each_entry(port, &team->port_list, list) {
858  vlan_features = netdev_increment_features(vlan_features,
859  port->dev->vlan_features,
861 
862  dst_release_flag &= port->dev->priv_flags;
863  if (port->dev->hard_header_len > max_hard_header_len)
864  max_hard_header_len = port->dev->hard_header_len;
865  }
866 
867  team->dev->vlan_features = vlan_features;
868  team->dev->hard_header_len = max_hard_header_len;
869 
870  flags = team->dev->priv_flags & ~IFF_XMIT_DST_RELEASE;
871  team->dev->priv_flags = flags | dst_release_flag;
872 
874 }
875 
876 static void team_compute_features(struct team *team)
877 {
878  mutex_lock(&team->lock);
879  __team_compute_features(team);
880  mutex_unlock(&team->lock);
881 }
882 
883 static int team_port_enter(struct team *team, struct team_port *port)
884 {
885  int err = 0;
886 
887  dev_hold(team->dev);
888  port->dev->priv_flags |= IFF_TEAM_PORT;
889  if (team->ops.port_enter) {
890  err = team->ops.port_enter(team, port);
891  if (err) {
892  netdev_err(team->dev, "Device %s failed to enter team mode\n",
893  port->dev->name);
894  goto err_port_enter;
895  }
896  }
897 
898  return 0;
899 
900 err_port_enter:
901  port->dev->priv_flags &= ~IFF_TEAM_PORT;
902  dev_put(team->dev);
903 
904  return err;
905 }
906 
907 static void team_port_leave(struct team *team, struct team_port *port)
908 {
909  if (team->ops.port_leave)
910  team->ops.port_leave(team, port);
911  port->dev->priv_flags &= ~IFF_TEAM_PORT;
912  dev_put(team->dev);
913 }
914 
915 #ifdef CONFIG_NET_POLL_CONTROLLER
916 static int team_port_enable_netpoll(struct team *team, struct team_port *port,
917  gfp_t gfp)
918 {
919  struct netpoll *np;
920  int err;
921 
922  np = kzalloc(sizeof(*np), gfp);
923  if (!np)
924  return -ENOMEM;
925 
926  err = __netpoll_setup(np, port->dev, gfp);
927  if (err) {
928  kfree(np);
929  return err;
930  }
931  port->np = np;
932  return err;
933 }
934 
935 static void team_port_disable_netpoll(struct team_port *port)
936 {
937  struct netpoll *np = port->np;
938 
939  if (!np)
940  return;
941  port->np = NULL;
942 
943  /* Wait for transmitting packets to finish before freeing. */
945  __netpoll_cleanup(np);
946  kfree(np);
947 }
948 
949 static struct netpoll_info *team_netpoll_info(struct team *team)
950 {
951  return team->dev->npinfo;
952 }
953 
954 #else
955 static int team_port_enable_netpoll(struct team *team, struct team_port *port,
956  gfp_t gfp)
957 {
958  return 0;
959 }
960 static void team_port_disable_netpoll(struct team_port *port)
961 {
962 }
963 static struct netpoll_info *team_netpoll_info(struct team *team)
964 {
965  return NULL;
966 }
967 #endif
968 
969 static void __team_port_change_port_added(struct team_port *port, bool linkup);
970 static int team_dev_type_check_change(struct net_device *dev,
971  struct net_device *port_dev);
972 
973 static int team_port_add(struct team *team, struct net_device *port_dev)
974 {
975  struct net_device *dev = team->dev;
976  struct team_port *port;
977  char *portname = port_dev->name;
978  int err;
979 
980  if (port_dev->flags & IFF_LOOPBACK) {
981  netdev_err(dev, "Device %s is loopback device. Loopback devices can't be added as a team port\n",
982  portname);
983  return -EINVAL;
984  }
985 
986  if (team_port_exists(port_dev)) {
987  netdev_err(dev, "Device %s is already a port "
988  "of a team device\n", portname);
989  return -EBUSY;
990  }
991 
992  if (port_dev->features & NETIF_F_VLAN_CHALLENGED &&
993  vlan_uses_dev(dev)) {
994  netdev_err(dev, "Device %s is VLAN challenged and team device has VLAN set up\n",
995  portname);
996  return -EPERM;
997  }
998 
999  err = team_dev_type_check_change(dev, port_dev);
1000  if (err)
1001  return err;
1002 
1003  if (port_dev->flags & IFF_UP) {
1004  netdev_err(dev, "Device %s is up. Set it down before adding it as a team port\n",
1005  portname);
1006  return -EBUSY;
1007  }
1008 
1009  port = kzalloc(sizeof(struct team_port) + team->mode->port_priv_size,
1010  GFP_KERNEL);
1011  if (!port)
1012  return -ENOMEM;
1013 
1014  port->dev = port_dev;
1015  port->team = team;
1016  INIT_LIST_HEAD(&port->qom_list);
1017 
1018  port->orig.mtu = port_dev->mtu;
1019  err = dev_set_mtu(port_dev, dev->mtu);
1020  if (err) {
1021  netdev_dbg(dev, "Error %d calling dev_set_mtu\n", err);
1022  goto err_set_mtu;
1023  }
1024 
1025  memcpy(port->orig.dev_addr, port_dev->dev_addr, port_dev->addr_len);
1026 
1027  err = team_port_enter(team, port);
1028  if (err) {
1029  netdev_err(dev, "Device %s failed to enter team mode\n",
1030  portname);
1031  goto err_port_enter;
1032  }
1033 
1034  err = dev_open(port_dev);
1035  if (err) {
1036  netdev_dbg(dev, "Device %s opening failed\n",
1037  portname);
1038  goto err_dev_open;
1039  }
1040 
1041  err = vlan_vids_add_by_dev(port_dev, dev);
1042  if (err) {
1043  netdev_err(dev, "Failed to add vlan ids to device %s\n",
1044  portname);
1045  goto err_vids_add;
1046  }
1047 
1048  if (team_netpoll_info(team)) {
1049  err = team_port_enable_netpoll(team, port, GFP_KERNEL);
1050  if (err) {
1051  netdev_err(dev, "Failed to enable netpoll on device %s\n",
1052  portname);
1053  goto err_enable_netpoll;
1054  }
1055  }
1056 
1057  err = netdev_set_master(port_dev, dev);
1058  if (err) {
1059  netdev_err(dev, "Device %s failed to set master\n", portname);
1060  goto err_set_master;
1061  }
1062 
1063  err = netdev_rx_handler_register(port_dev, team_handle_frame,
1064  port);
1065  if (err) {
1066  netdev_err(dev, "Device %s failed to register rx_handler\n",
1067  portname);
1068  goto err_handler_register;
1069  }
1070 
1071  err = __team_option_inst_add_port(team, port);
1072  if (err) {
1073  netdev_err(dev, "Device %s failed to add per-port options\n",
1074  portname);
1075  goto err_option_port_add;
1076  }
1077 
1078  port->index = -1;
1079  team_port_enable(team, port);
1080  list_add_tail_rcu(&port->list, &team->port_list);
1081  __team_compute_features(team);
1082  __team_port_change_port_added(port, !!netif_carrier_ok(port_dev));
1083  __team_options_change_check(team);
1084 
1085  netdev_info(dev, "Port device %s added\n", portname);
1086 
1087  return 0;
1088 
1089 err_option_port_add:
1090  netdev_rx_handler_unregister(port_dev);
1091 
1092 err_handler_register:
1093  netdev_set_master(port_dev, NULL);
1094 
1095 err_set_master:
1096  team_port_disable_netpoll(port);
1097 
1098 err_enable_netpoll:
1099  vlan_vids_del_by_dev(port_dev, dev);
1100 
1101 err_vids_add:
1102  dev_close(port_dev);
1103 
1104 err_dev_open:
1105  team_port_leave(team, port);
1106  team_port_set_orig_dev_addr(port);
1107 
1108 err_port_enter:
1109  dev_set_mtu(port_dev, port->orig.mtu);
1110 
1111 err_set_mtu:
1112  kfree(port);
1113 
1114  return err;
1115 }
1116 
1117 static void __team_port_change_port_removed(struct team_port *port);
1118 
1119 static int team_port_del(struct team *team, struct net_device *port_dev)
1120 {
1121  struct net_device *dev = team->dev;
1122  struct team_port *port;
1123  char *portname = port_dev->name;
1124 
1125  port = team_port_get_rtnl(port_dev);
1126  if (!port || !team_port_find(team, port)) {
1127  netdev_err(dev, "Device %s does not act as a port of this team\n",
1128  portname);
1129  return -ENOENT;
1130  }
1131 
1132  __team_option_inst_mark_removed_port(team, port);
1133  __team_options_change_check(team);
1134  __team_option_inst_del_port(team, port);
1135  __team_port_change_port_removed(port);
1136  team_port_disable(team, port);
1137  list_del_rcu(&port->list);
1138  netdev_rx_handler_unregister(port_dev);
1139  netdev_set_master(port_dev, NULL);
1140  team_port_disable_netpoll(port);
1141  vlan_vids_del_by_dev(port_dev, dev);
1142  dev_close(port_dev);
1143  team_port_leave(team, port);
1144  team_port_set_orig_dev_addr(port);
1145  dev_set_mtu(port_dev, port->orig.mtu);
1146  synchronize_rcu();
1147  kfree(port);
1148  netdev_info(dev, "Port device %s removed\n", portname);
1149  __team_compute_features(team);
1150 
1151  return 0;
1152 }
1153 
1154 
1155 /*****************
1156  * Net device ops
1157  *****************/
1158 
1159 static int team_mode_option_get(struct team *team, struct team_gsetter_ctx *ctx)
1160 {
1161  ctx->data.str_val = team->mode->kind;
1162  return 0;
1163 }
1164 
1165 static int team_mode_option_set(struct team *team, struct team_gsetter_ctx *ctx)
1166 {
1167  return team_change_mode(team, ctx->data.str_val);
1168 }
1169 
1170 static int team_port_en_option_get(struct team *team,
1171  struct team_gsetter_ctx *ctx)
1172 {
1173  struct team_port *port = ctx->info->port;
1174 
1175  ctx->data.bool_val = team_port_enabled(port);
1176  return 0;
1177 }
1178 
1179 static int team_port_en_option_set(struct team *team,
1180  struct team_gsetter_ctx *ctx)
1181 {
1182  struct team_port *port = ctx->info->port;
1183 
1184  if (ctx->data.bool_val)
1185  team_port_enable(team, port);
1186  else
1187  team_port_disable(team, port);
1188  return 0;
1189 }
1190 
1191 static int team_user_linkup_option_get(struct team *team,
1192  struct team_gsetter_ctx *ctx)
1193 {
1194  struct team_port *port = ctx->info->port;
1195 
1196  ctx->data.bool_val = port->user.linkup;
1197  return 0;
1198 }
1199 
1200 static int team_user_linkup_option_set(struct team *team,
1201  struct team_gsetter_ctx *ctx)
1202 {
1203  struct team_port *port = ctx->info->port;
1204 
1205  port->user.linkup = ctx->data.bool_val;
1206  team_refresh_port_linkup(port);
1207  return 0;
1208 }
1209 
1210 static int team_user_linkup_en_option_get(struct team *team,
1211  struct team_gsetter_ctx *ctx)
1212 {
1213  struct team_port *port = ctx->info->port;
1214 
1215  ctx->data.bool_val = port->user.linkup_enabled;
1216  return 0;
1217 }
1218 
1219 static int team_user_linkup_en_option_set(struct team *team,
1220  struct team_gsetter_ctx *ctx)
1221 {
1222  struct team_port *port = ctx->info->port;
1223 
1224  port->user.linkup_enabled = ctx->data.bool_val;
1225  team_refresh_port_linkup(port);
1226  return 0;
1227 }
1228 
1229 static int team_priority_option_get(struct team *team,
1230  struct team_gsetter_ctx *ctx)
1231 {
1232  struct team_port *port = ctx->info->port;
1233 
1234  ctx->data.s32_val = port->priority;
1235  return 0;
1236 }
1237 
1238 static int team_priority_option_set(struct team *team,
1239  struct team_gsetter_ctx *ctx)
1240 {
1241  struct team_port *port = ctx->info->port;
1242 
1243  port->priority = ctx->data.s32_val;
1244  team_queue_override_port_refresh(team, port);
1245  return 0;
1246 }
1247 
1248 static int team_queue_id_option_get(struct team *team,
1249  struct team_gsetter_ctx *ctx)
1250 {
1251  struct team_port *port = ctx->info->port;
1252 
1253  ctx->data.u32_val = port->queue_id;
1254  return 0;
1255 }
1256 
1257 static int team_queue_id_option_set(struct team *team,
1258  struct team_gsetter_ctx *ctx)
1259 {
1260  struct team_port *port = ctx->info->port;
1261 
1262  if (port->queue_id == ctx->data.u32_val)
1263  return 0;
1264  if (ctx->data.u32_val >= team->dev->real_num_tx_queues)
1265  return -EINVAL;
1266  port->queue_id = ctx->data.u32_val;
1267  team_queue_override_port_refresh(team, port);
1268  return 0;
1269 }
1270 
1271 
1272 static const struct team_option team_options[] = {
1273  {
1274  .name = "mode",
1275  .type = TEAM_OPTION_TYPE_STRING,
1276  .getter = team_mode_option_get,
1277  .setter = team_mode_option_set,
1278  },
1279  {
1280  .name = "enabled",
1281  .type = TEAM_OPTION_TYPE_BOOL,
1282  .per_port = true,
1283  .getter = team_port_en_option_get,
1284  .setter = team_port_en_option_set,
1285  },
1286  {
1287  .name = "user_linkup",
1288  .type = TEAM_OPTION_TYPE_BOOL,
1289  .per_port = true,
1290  .getter = team_user_linkup_option_get,
1291  .setter = team_user_linkup_option_set,
1292  },
1293  {
1294  .name = "user_linkup_enabled",
1295  .type = TEAM_OPTION_TYPE_BOOL,
1296  .per_port = true,
1297  .getter = team_user_linkup_en_option_get,
1298  .setter = team_user_linkup_en_option_set,
1299  },
1300  {
1301  .name = "priority",
1302  .type = TEAM_OPTION_TYPE_S32,
1303  .per_port = true,
1304  .getter = team_priority_option_get,
1305  .setter = team_priority_option_set,
1306  },
1307  {
1308  .name = "queue_id",
1309  .type = TEAM_OPTION_TYPE_U32,
1310  .per_port = true,
1311  .getter = team_queue_id_option_get,
1312  .setter = team_queue_id_option_set,
1313  },
1314 };
1315 
1316 static struct lock_class_key team_netdev_xmit_lock_key;
1317 static struct lock_class_key team_netdev_addr_lock_key;
1318 static struct lock_class_key team_tx_busylock_key;
1319 
1320 static void team_set_lockdep_class_one(struct net_device *dev,
1321  struct netdev_queue *txq,
1322  void *unused)
1323 {
1324  lockdep_set_class(&txq->_xmit_lock, &team_netdev_xmit_lock_key);
1325 }
1326 
1327 static void team_set_lockdep_class(struct net_device *dev)
1328 {
1329  lockdep_set_class(&dev->addr_list_lock, &team_netdev_addr_lock_key);
1330  netdev_for_each_tx_queue(dev, team_set_lockdep_class_one, NULL);
1331  dev->qdisc_tx_busylock = &team_tx_busylock_key;
1332 }
1333 
1334 static int team_init(struct net_device *dev)
1335 {
1336  struct team *team = netdev_priv(dev);
1337  int i;
1338  int err;
1339 
1340  team->dev = dev;
1341  mutex_init(&team->lock);
1342  team_set_no_mode(team);
1343 
1344  team->pcpu_stats = alloc_percpu(struct team_pcpu_stats);
1345  if (!team->pcpu_stats)
1346  return -ENOMEM;
1347 
1348  for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
1349  INIT_HLIST_HEAD(&team->en_port_hlist[i]);
1350  INIT_LIST_HEAD(&team->port_list);
1351  err = team_queue_override_init(team);
1352  if (err)
1353  goto err_team_queue_override_init;
1354 
1355  team_adjust_ops(team);
1356 
1357  INIT_LIST_HEAD(&team->option_list);
1358  INIT_LIST_HEAD(&team->option_inst_list);
1359  err = team_options_register(team, team_options, ARRAY_SIZE(team_options));
1360  if (err)
1361  goto err_options_register;
1362  netif_carrier_off(dev);
1363 
1364  team_set_lockdep_class(dev);
1365 
1366  return 0;
1367 
1368 err_options_register:
1369  team_queue_override_fini(team);
1370 err_team_queue_override_init:
1371  free_percpu(team->pcpu_stats);
1372 
1373  return err;
1374 }
1375 
1376 static void team_uninit(struct net_device *dev)
1377 {
1378  struct team *team = netdev_priv(dev);
1379  struct team_port *port;
1380  struct team_port *tmp;
1381 
1382  mutex_lock(&team->lock);
1383  list_for_each_entry_safe(port, tmp, &team->port_list, list)
1384  team_port_del(team, port->dev);
1385 
1386  __team_change_mode(team, NULL); /* cleanup */
1387  __team_options_unregister(team, team_options, ARRAY_SIZE(team_options));
1388  team_queue_override_fini(team);
1389  mutex_unlock(&team->lock);
1390 }
1391 
1392 static void team_destructor(struct net_device *dev)
1393 {
1394  struct team *team = netdev_priv(dev);
1395 
1396  free_percpu(team->pcpu_stats);
1397  free_netdev(dev);
1398 }
1399 
1400 static int team_open(struct net_device *dev)
1401 {
1402  netif_carrier_on(dev);
1403  return 0;
1404 }
1405 
1406 static int team_close(struct net_device *dev)
1407 {
1408  netif_carrier_off(dev);
1409  return 0;
1410 }
1411 
1412 /*
1413  * note: already called with rcu_read_lock
1414  */
1415 static netdev_tx_t team_xmit(struct sk_buff *skb, struct net_device *dev)
1416 {
1417  struct team *team = netdev_priv(dev);
1418  bool tx_success;
1419  unsigned int len = skb->len;
1420 
1421  tx_success = team_queue_override_transmit(team, skb);
1422  if (!tx_success)
1423  tx_success = team->ops.transmit(team, skb);
1424  if (tx_success) {
1425  struct team_pcpu_stats *pcpu_stats;
1426 
1427  pcpu_stats = this_cpu_ptr(team->pcpu_stats);
1428  u64_stats_update_begin(&pcpu_stats->syncp);
1429  pcpu_stats->tx_packets++;
1430  pcpu_stats->tx_bytes += len;
1431  u64_stats_update_end(&pcpu_stats->syncp);
1432  } else {
1433  this_cpu_inc(team->pcpu_stats->tx_dropped);
1434  }
1435 
1436  return NETDEV_TX_OK;
1437 }
1438 
1439 static u16 team_select_queue(struct net_device *dev, struct sk_buff *skb)
1440 {
1441  /*
1442  * This helper function exists to help dev_pick_tx get the correct
1443  * destination queue. Using a helper function skips a call to
1444  * skb_tx_hash and will put the skbs in the queue we expect on their
1445  * way down to the team driver.
1446  */
1447  u16 txq = skb_rx_queue_recorded(skb) ? skb_get_rx_queue(skb) : 0;
1448 
1449  /*
1450  * Save the original txq to restore before passing to the driver
1451  */
1453 
1454  if (unlikely(txq >= dev->real_num_tx_queues)) {
1455  do {
1456  txq -= dev->real_num_tx_queues;
1457  } while (txq >= dev->real_num_tx_queues);
1458  }
1459  return txq;
1460 }
1461 
1462 static void team_change_rx_flags(struct net_device *dev, int change)
1463 {
1464  struct team *team = netdev_priv(dev);
1465  struct team_port *port;
1466  int inc;
1467 
1468  rcu_read_lock();
1469  list_for_each_entry_rcu(port, &team->port_list, list) {
1470  if (change & IFF_PROMISC) {
1471  inc = dev->flags & IFF_PROMISC ? 1 : -1;
1472  dev_set_promiscuity(port->dev, inc);
1473  }
1474  if (change & IFF_ALLMULTI) {
1475  inc = dev->flags & IFF_ALLMULTI ? 1 : -1;
1476  dev_set_allmulti(port->dev, inc);
1477  }
1478  }
1479  rcu_read_unlock();
1480 }
1481 
1482 static void team_set_rx_mode(struct net_device *dev)
1483 {
1484  struct team *team = netdev_priv(dev);
1485  struct team_port *port;
1486 
1487  rcu_read_lock();
1488  list_for_each_entry_rcu(port, &team->port_list, list) {
1489  dev_uc_sync(port->dev, dev);
1490  dev_mc_sync(port->dev, dev);
1491  }
1492  rcu_read_unlock();
1493 }
1494 
1495 static int team_set_mac_address(struct net_device *dev, void *p)
1496 {
1497  struct sockaddr *addr = p;
1498  struct team *team = netdev_priv(dev);
1499  struct team_port *port;
1500 
1501  if (dev->type == ARPHRD_ETHER && !is_valid_ether_addr(addr->sa_data))
1502  return -EADDRNOTAVAIL;
1503  memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1505  rcu_read_lock();
1506  list_for_each_entry_rcu(port, &team->port_list, list)
1507  if (team->ops.port_change_dev_addr)
1508  team->ops.port_change_dev_addr(team, port);
1509  rcu_read_unlock();
1510  return 0;
1511 }
1512 
1513 static int team_change_mtu(struct net_device *dev, int new_mtu)
1514 {
1515  struct team *team = netdev_priv(dev);
1516  struct team_port *port;
1517  int err;
1518 
1519  /*
1520  * Alhough this is reader, it's guarded by team lock. It's not possible
1521  * to traverse list in reverse under rcu_read_lock
1522  */
1523  mutex_lock(&team->lock);
1524  list_for_each_entry(port, &team->port_list, list) {
1525  err = dev_set_mtu(port->dev, new_mtu);
1526  if (err) {
1527  netdev_err(dev, "Device %s failed to change mtu",
1528  port->dev->name);
1529  goto unwind;
1530  }
1531  }
1532  mutex_unlock(&team->lock);
1533 
1534  dev->mtu = new_mtu;
1535 
1536  return 0;
1537 
1538 unwind:
1540  dev_set_mtu(port->dev, dev->mtu);
1541  mutex_unlock(&team->lock);
1542 
1543  return err;
1544 }
1545 
1546 static struct rtnl_link_stats64 *
1547 team_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
1548 {
1549  struct team *team = netdev_priv(dev);
1550  struct team_pcpu_stats *p;
1552  u32 rx_dropped = 0, tx_dropped = 0;
1553  unsigned int start;
1554  int i;
1555 
1557  p = per_cpu_ptr(team->pcpu_stats, i);
1558  do {
1559  start = u64_stats_fetch_begin_bh(&p->syncp);
1560  rx_packets = p->rx_packets;
1561  rx_bytes = p->rx_bytes;
1562  rx_multicast = p->rx_multicast;
1563  tx_packets = p->tx_packets;
1564  tx_bytes = p->tx_bytes;
1565  } while (u64_stats_fetch_retry_bh(&p->syncp, start));
1566 
1567  stats->rx_packets += rx_packets;
1568  stats->rx_bytes += rx_bytes;
1569  stats->multicast += rx_multicast;
1570  stats->tx_packets += tx_packets;
1571  stats->tx_bytes += tx_bytes;
1572  /*
1573  * rx_dropped & tx_dropped are u32, updated
1574  * without syncp protection.
1575  */
1576  rx_dropped += p->rx_dropped;
1577  tx_dropped += p->tx_dropped;
1578  }
1579  stats->rx_dropped = rx_dropped;
1580  stats->tx_dropped = tx_dropped;
1581  return stats;
1582 }
1583 
1584 static int team_vlan_rx_add_vid(struct net_device *dev, uint16_t vid)
1585 {
1586  struct team *team = netdev_priv(dev);
1587  struct team_port *port;
1588  int err;
1589 
1590  /*
1591  * Alhough this is reader, it's guarded by team lock. It's not possible
1592  * to traverse list in reverse under rcu_read_lock
1593  */
1594  mutex_lock(&team->lock);
1595  list_for_each_entry(port, &team->port_list, list) {
1596  err = vlan_vid_add(port->dev, vid);
1597  if (err)
1598  goto unwind;
1599  }
1600  mutex_unlock(&team->lock);
1601 
1602  return 0;
1603 
1604 unwind:
1606  vlan_vid_del(port->dev, vid);
1607  mutex_unlock(&team->lock);
1608 
1609  return err;
1610 }
1611 
1612 static int team_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid)
1613 {
1614  struct team *team = netdev_priv(dev);
1615  struct team_port *port;
1616 
1617  rcu_read_lock();
1618  list_for_each_entry_rcu(port, &team->port_list, list)
1619  vlan_vid_del(port->dev, vid);
1620  rcu_read_unlock();
1621 
1622  return 0;
1623 }
1624 
1625 #ifdef CONFIG_NET_POLL_CONTROLLER
1626 static void team_poll_controller(struct net_device *dev)
1627 {
1628 }
1629 
1630 static void __team_netpoll_cleanup(struct team *team)
1631 {
1632  struct team_port *port;
1633 
1634  list_for_each_entry(port, &team->port_list, list)
1635  team_port_disable_netpoll(port);
1636 }
1637 
1638 static void team_netpoll_cleanup(struct net_device *dev)
1639 {
1640  struct team *team = netdev_priv(dev);
1641 
1642  mutex_lock(&team->lock);
1643  __team_netpoll_cleanup(team);
1644  mutex_unlock(&team->lock);
1645 }
1646 
1647 static int team_netpoll_setup(struct net_device *dev,
1648  struct netpoll_info *npifo, gfp_t gfp)
1649 {
1650  struct team *team = netdev_priv(dev);
1651  struct team_port *port;
1652  int err = 0;
1653 
1654  mutex_lock(&team->lock);
1655  list_for_each_entry(port, &team->port_list, list) {
1656  err = team_port_enable_netpoll(team, port, gfp);
1657  if (err) {
1658  __team_netpoll_cleanup(team);
1659  break;
1660  }
1661  }
1662  mutex_unlock(&team->lock);
1663  return err;
1664 }
1665 #endif
1666 
1667 static int team_add_slave(struct net_device *dev, struct net_device *port_dev)
1668 {
1669  struct team *team = netdev_priv(dev);
1670  int err;
1671 
1672  mutex_lock(&team->lock);
1673  err = team_port_add(team, port_dev);
1674  mutex_unlock(&team->lock);
1675  return err;
1676 }
1677 
1678 static int team_del_slave(struct net_device *dev, struct net_device *port_dev)
1679 {
1680  struct team *team = netdev_priv(dev);
1681  int err;
1682 
1683  mutex_lock(&team->lock);
1684  err = team_port_del(team, port_dev);
1685  mutex_unlock(&team->lock);
1686  return err;
1687 }
1688 
1689 static netdev_features_t team_fix_features(struct net_device *dev,
1691 {
1692  struct team_port *port;
1693  struct team *team = netdev_priv(dev);
1695 
1696  mask = features;
1697  features &= ~NETIF_F_ONE_FOR_ALL;
1698  features |= NETIF_F_ALL_FOR_ALL;
1699 
1700  rcu_read_lock();
1701  list_for_each_entry_rcu(port, &team->port_list, list) {
1702  features = netdev_increment_features(features,
1703  port->dev->features,
1704  mask);
1705  }
1706  rcu_read_unlock();
1707  return features;
1708 }
1709 
1710 static const struct net_device_ops team_netdev_ops = {
1711  .ndo_init = team_init,
1712  .ndo_uninit = team_uninit,
1713  .ndo_open = team_open,
1714  .ndo_stop = team_close,
1715  .ndo_start_xmit = team_xmit,
1716  .ndo_select_queue = team_select_queue,
1717  .ndo_change_rx_flags = team_change_rx_flags,
1718  .ndo_set_rx_mode = team_set_rx_mode,
1719  .ndo_set_mac_address = team_set_mac_address,
1720  .ndo_change_mtu = team_change_mtu,
1721  .ndo_get_stats64 = team_get_stats64,
1722  .ndo_vlan_rx_add_vid = team_vlan_rx_add_vid,
1723  .ndo_vlan_rx_kill_vid = team_vlan_rx_kill_vid,
1724 #ifdef CONFIG_NET_POLL_CONTROLLER
1725  .ndo_poll_controller = team_poll_controller,
1726  .ndo_netpoll_setup = team_netpoll_setup,
1727  .ndo_netpoll_cleanup = team_netpoll_cleanup,
1728 #endif
1729  .ndo_add_slave = team_add_slave,
1730  .ndo_del_slave = team_del_slave,
1731  .ndo_fix_features = team_fix_features,
1732 };
1733 
1734 
1735 /***********************
1736  * rt netlink interface
1737  ***********************/
1738 
1739 static void team_setup_by_port(struct net_device *dev,
1740  struct net_device *port_dev)
1741 {
1742  dev->header_ops = port_dev->header_ops;
1743  dev->type = port_dev->type;
1744  dev->hard_header_len = port_dev->hard_header_len;
1745  dev->addr_len = port_dev->addr_len;
1746  dev->mtu = port_dev->mtu;
1747  memcpy(dev->broadcast, port_dev->broadcast, port_dev->addr_len);
1748  memcpy(dev->dev_addr, port_dev->dev_addr, port_dev->addr_len);
1750 }
1751 
1752 static int team_dev_type_check_change(struct net_device *dev,
1753  struct net_device *port_dev)
1754 {
1755  struct team *team = netdev_priv(dev);
1756  char *portname = port_dev->name;
1757  int err;
1758 
1759  if (dev->type == port_dev->type)
1760  return 0;
1761  if (!list_empty(&team->port_list)) {
1762  netdev_err(dev, "Device %s is of different type\n", portname);
1763  return -EBUSY;
1764  }
1766  err = notifier_to_errno(err);
1767  if (err) {
1768  netdev_err(dev, "Refused to change device type\n");
1769  return err;
1770  }
1771  dev_uc_flush(dev);
1772  dev_mc_flush(dev);
1773  team_setup_by_port(dev, port_dev);
1775  return 0;
1776 }
1777 
1778 static void team_setup(struct net_device *dev)
1779 {
1780  ether_setup(dev);
1781 
1782  dev->netdev_ops = &team_netdev_ops;
1783  dev->destructor = team_destructor;
1784  dev->tx_queue_len = 0;
1785  dev->flags |= IFF_MULTICAST;
1787 
1788  /*
1789  * Indicate we support unicast address filtering. That way core won't
1790  * bring us to promisc mode in case a unicast addr is added.
1791  * Let this up to underlay drivers.
1792  */
1794 
1795  dev->features |= NETIF_F_LLTX;
1796  dev->features |= NETIF_F_GRO;
1801 
1803  dev->features |= dev->hw_features;
1804 }
1805 
1806 static int team_newlink(struct net *src_net, struct net_device *dev,
1807  struct nlattr *tb[], struct nlattr *data[])
1808 {
1809  int err;
1810 
1811  if (tb[IFLA_ADDRESS] == NULL)
1812  eth_hw_addr_random(dev);
1813 
1814  err = register_netdevice(dev);
1815  if (err)
1816  return err;
1817 
1818  return 0;
1819 }
1820 
1821 static int team_validate(struct nlattr *tb[], struct nlattr *data[])
1822 {
1823  if (tb[IFLA_ADDRESS]) {
1824  if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1825  return -EINVAL;
1826  if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1827  return -EADDRNOTAVAIL;
1828  }
1829  return 0;
1830 }
1831 
1832 static unsigned int team_get_num_tx_queues(void)
1833 {
1835 }
1836 
1837 static unsigned int team_get_num_rx_queues(void)
1838 {
1840 }
1841 
1842 static struct rtnl_link_ops team_link_ops __read_mostly = {
1843  .kind = DRV_NAME,
1844  .priv_size = sizeof(struct team),
1845  .setup = team_setup,
1846  .newlink = team_newlink,
1847  .validate = team_validate,
1848  .get_num_tx_queues = team_get_num_tx_queues,
1849  .get_num_rx_queues = team_get_num_rx_queues,
1850 };
1851 
1852 
1853 /***********************************
1854  * Generic netlink custom interface
1855  ***********************************/
1856 
1857 static struct genl_family team_nl_family = {
1858  .id = GENL_ID_GENERATE,
1859  .name = TEAM_GENL_NAME,
1860  .version = TEAM_GENL_VERSION,
1861  .maxattr = TEAM_ATTR_MAX,
1862  .netnsok = true,
1863 };
1864 
1865 static const struct nla_policy team_nl_policy[TEAM_ATTR_MAX + 1] = {
1866  [TEAM_ATTR_UNSPEC] = { .type = NLA_UNSPEC, },
1867  [TEAM_ATTR_TEAM_IFINDEX] = { .type = NLA_U32 },
1868  [TEAM_ATTR_LIST_OPTION] = { .type = NLA_NESTED },
1869  [TEAM_ATTR_LIST_PORT] = { .type = NLA_NESTED },
1870 };
1871 
1872 static const struct nla_policy
1873 team_nl_option_policy[TEAM_ATTR_OPTION_MAX + 1] = {
1874  [TEAM_ATTR_OPTION_UNSPEC] = { .type = NLA_UNSPEC, },
1875  [TEAM_ATTR_OPTION_NAME] = {
1876  .type = NLA_STRING,
1877  .len = TEAM_STRING_MAX_LEN,
1878  },
1879  [TEAM_ATTR_OPTION_CHANGED] = { .type = NLA_FLAG },
1880  [TEAM_ATTR_OPTION_TYPE] = { .type = NLA_U8 },
1881  [TEAM_ATTR_OPTION_DATA] = { .type = NLA_BINARY },
1882 };
1883 
1884 static int team_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
1885 {
1886  struct sk_buff *msg;
1887  void *hdr;
1888  int err;
1889 
1890  msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1891  if (!msg)
1892  return -ENOMEM;
1893 
1894  hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
1895  &team_nl_family, 0, TEAM_CMD_NOOP);
1896  if (!hdr) {
1897  err = -EMSGSIZE;
1898  goto err_msg_put;
1899  }
1900 
1901  genlmsg_end(msg, hdr);
1902 
1903  return genlmsg_unicast(genl_info_net(info), msg, info->snd_portid);
1904 
1905 err_msg_put:
1906  nlmsg_free(msg);
1907 
1908  return err;
1909 }
1910 
1911 /*
1912  * Netlink cmd functions should be locked by following two functions.
1913  * Since dev gets held here, that ensures dev won't disappear in between.
1914  */
1915 static struct team *team_nl_team_get(struct genl_info *info)
1916 {
1917  struct net *net = genl_info_net(info);
1918  int ifindex;
1919  struct net_device *dev;
1920  struct team *team;
1921 
1922  if (!info->attrs[TEAM_ATTR_TEAM_IFINDEX])
1923  return NULL;
1924 
1925  ifindex = nla_get_u32(info->attrs[TEAM_ATTR_TEAM_IFINDEX]);
1926  dev = dev_get_by_index(net, ifindex);
1927  if (!dev || dev->netdev_ops != &team_netdev_ops) {
1928  if (dev)
1929  dev_put(dev);
1930  return NULL;
1931  }
1932 
1933  team = netdev_priv(dev);
1934  mutex_lock(&team->lock);
1935  return team;
1936 }
1937 
1938 static void team_nl_team_put(struct team *team)
1939 {
1940  mutex_unlock(&team->lock);
1941  dev_put(team->dev);
1942 }
1943 
1944 static int team_nl_send_generic(struct genl_info *info, struct team *team,
1945  int (*fill_func)(struct sk_buff *skb,
1946  struct genl_info *info,
1947  int flags, struct team *team))
1948 {
1949  struct sk_buff *skb;
1950  int err;
1951 
1952  skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1953  if (!skb)
1954  return -ENOMEM;
1955 
1956  err = fill_func(skb, info, NLM_F_ACK, team);
1957  if (err < 0)
1958  goto err_fill;
1959 
1960  err = genlmsg_unicast(genl_info_net(info), skb, info->snd_portid);
1961  return err;
1962 
1963 err_fill:
1964  nlmsg_free(skb);
1965  return err;
1966 }
1967 
1968 typedef int team_nl_send_func_t(struct sk_buff *skb,
1969  struct team *team, u32 portid);
1970 
1971 static int team_nl_send_unicast(struct sk_buff *skb, struct team *team, u32 portid)
1972 {
1973  return genlmsg_unicast(dev_net(team->dev), skb, portid);
1974 }
1975 
1976 static int team_nl_fill_one_option_get(struct sk_buff *skb, struct team *team,
1977  struct team_option_inst *opt_inst)
1978 {
1979  struct nlattr *option_item;
1980  struct team_option *option = opt_inst->option;
1981  struct team_option_inst_info *opt_inst_info = &opt_inst->info;
1982  struct team_gsetter_ctx ctx;
1983  int err;
1984 
1985  ctx.info = opt_inst_info;
1986  err = team_option_get(team, opt_inst, &ctx);
1987  if (err)
1988  return err;
1989 
1990  option_item = nla_nest_start(skb, TEAM_ATTR_ITEM_OPTION);
1991  if (!option_item)
1992  return -EMSGSIZE;
1993 
1994  if (nla_put_string(skb, TEAM_ATTR_OPTION_NAME, option->name))
1995  goto nest_cancel;
1996  if (opt_inst_info->port &&
1997  nla_put_u32(skb, TEAM_ATTR_OPTION_PORT_IFINDEX,
1998  opt_inst_info->port->dev->ifindex))
1999  goto nest_cancel;
2000  if (opt_inst->option->array_size &&
2001  nla_put_u32(skb, TEAM_ATTR_OPTION_ARRAY_INDEX,
2002  opt_inst_info->array_index))
2003  goto nest_cancel;
2004 
2005  switch (option->type) {
2006  case TEAM_OPTION_TYPE_U32:
2007  if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_U32))
2008  goto nest_cancel;
2009  if (nla_put_u32(skb, TEAM_ATTR_OPTION_DATA, ctx.data.u32_val))
2010  goto nest_cancel;
2011  break;
2013  if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_STRING))
2014  goto nest_cancel;
2015  if (nla_put_string(skb, TEAM_ATTR_OPTION_DATA,
2016  ctx.data.str_val))
2017  goto nest_cancel;
2018  break;
2020  if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_BINARY))
2021  goto nest_cancel;
2022  if (nla_put(skb, TEAM_ATTR_OPTION_DATA, ctx.data.bin_val.len,
2023  ctx.data.bin_val.ptr))
2024  goto nest_cancel;
2025  break;
2026  case TEAM_OPTION_TYPE_BOOL:
2027  if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_FLAG))
2028  goto nest_cancel;
2029  if (ctx.data.bool_val &&
2030  nla_put_flag(skb, TEAM_ATTR_OPTION_DATA))
2031  goto nest_cancel;
2032  break;
2033  case TEAM_OPTION_TYPE_S32:
2034  if (nla_put_u8(skb, TEAM_ATTR_OPTION_TYPE, NLA_S32))
2035  goto nest_cancel;
2036  if (nla_put_s32(skb, TEAM_ATTR_OPTION_DATA, ctx.data.s32_val))
2037  goto nest_cancel;
2038  break;
2039  default:
2040  BUG();
2041  }
2042  if (opt_inst->removed && nla_put_flag(skb, TEAM_ATTR_OPTION_REMOVED))
2043  goto nest_cancel;
2044  if (opt_inst->changed) {
2045  if (nla_put_flag(skb, TEAM_ATTR_OPTION_CHANGED))
2046  goto nest_cancel;
2047  opt_inst->changed = false;
2048  }
2049  nla_nest_end(skb, option_item);
2050  return 0;
2051 
2052 nest_cancel:
2053  nla_nest_cancel(skb, option_item);
2054  return -EMSGSIZE;
2055 }
2056 
2057 static int __send_and_alloc_skb(struct sk_buff **pskb,
2058  struct team *team, u32 portid,
2059  team_nl_send_func_t *send_func)
2060 {
2061  int err;
2062 
2063  if (*pskb) {
2064  err = send_func(*pskb, team, portid);
2065  if (err)
2066  return err;
2067  }
2068  *pskb = genlmsg_new(GENLMSG_DEFAULT_SIZE, GFP_KERNEL);
2069  if (!*pskb)
2070  return -ENOMEM;
2071  return 0;
2072 }
2073 
2074 static int team_nl_send_options_get(struct team *team, u32 portid, u32 seq,
2075  int flags, team_nl_send_func_t *send_func,
2076  struct list_head *sel_opt_inst_list)
2077 {
2078  struct nlattr *option_list;
2079  struct nlmsghdr *nlh;
2080  void *hdr;
2081  struct team_option_inst *opt_inst;
2082  int err;
2083  struct sk_buff *skb = NULL;
2084  bool incomplete;
2085  int i;
2086 
2087  opt_inst = list_first_entry(sel_opt_inst_list,
2088  struct team_option_inst, tmp_list);
2089 
2090 start_again:
2091  err = __send_and_alloc_skb(&skb, team, portid, send_func);
2092  if (err)
2093  return err;
2094 
2095  hdr = genlmsg_put(skb, portid, seq, &team_nl_family, flags | NLM_F_MULTI,
2097  if (!hdr)
2098  return -EMSGSIZE;
2099 
2100  if (nla_put_u32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex))
2101  goto nla_put_failure;
2102  option_list = nla_nest_start(skb, TEAM_ATTR_LIST_OPTION);
2103  if (!option_list)
2104  goto nla_put_failure;
2105 
2106  i = 0;
2107  incomplete = false;
2108  list_for_each_entry_from(opt_inst, sel_opt_inst_list, tmp_list) {
2109  err = team_nl_fill_one_option_get(skb, team, opt_inst);
2110  if (err) {
2111  if (err == -EMSGSIZE) {
2112  if (!i)
2113  goto errout;
2114  incomplete = true;
2115  break;
2116  }
2117  goto errout;
2118  }
2119  i++;
2120  }
2121 
2122  nla_nest_end(skb, option_list);
2123  genlmsg_end(skb, hdr);
2124  if (incomplete)
2125  goto start_again;
2126 
2127 send_done:
2128  nlh = nlmsg_put(skb, portid, seq, NLMSG_DONE, 0, flags | NLM_F_MULTI);
2129  if (!nlh) {
2130  err = __send_and_alloc_skb(&skb, team, portid, send_func);
2131  if (err)
2132  goto errout;
2133  goto send_done;
2134  }
2135 
2136  return send_func(skb, team, portid);
2137 
2138 nla_put_failure:
2139  err = -EMSGSIZE;
2140 errout:
2141  genlmsg_cancel(skb, hdr);
2142  nlmsg_free(skb);
2143  return err;
2144 }
2145 
2146 static int team_nl_cmd_options_get(struct sk_buff *skb, struct genl_info *info)
2147 {
2148  struct team *team;
2149  struct team_option_inst *opt_inst;
2150  int err;
2151  LIST_HEAD(sel_opt_inst_list);
2152 
2153  team = team_nl_team_get(info);
2154  if (!team)
2155  return -EINVAL;
2156 
2157  list_for_each_entry(opt_inst, &team->option_inst_list, list)
2158  list_add_tail(&opt_inst->tmp_list, &sel_opt_inst_list);
2159  err = team_nl_send_options_get(team, info->snd_portid, info->snd_seq,
2160  NLM_F_ACK, team_nl_send_unicast,
2161  &sel_opt_inst_list);
2162 
2163  team_nl_team_put(team);
2164 
2165  return err;
2166 }
2167 
2168 static int team_nl_send_event_options_get(struct team *team,
2169  struct list_head *sel_opt_inst_list);
2170 
2171 static int team_nl_cmd_options_set(struct sk_buff *skb, struct genl_info *info)
2172 {
2173  struct team *team;
2174  int err = 0;
2175  int i;
2176  struct nlattr *nl_option;
2177  LIST_HEAD(opt_inst_list);
2178 
2179  team = team_nl_team_get(info);
2180  if (!team)
2181  return -EINVAL;
2182 
2183  err = -EINVAL;
2184  if (!info->attrs[TEAM_ATTR_LIST_OPTION]) {
2185  err = -EINVAL;
2186  goto team_put;
2187  }
2188 
2189  nla_for_each_nested(nl_option, info->attrs[TEAM_ATTR_LIST_OPTION], i) {
2190  struct nlattr *opt_attrs[TEAM_ATTR_OPTION_MAX + 1];
2191  struct nlattr *attr;
2192  struct nlattr *attr_data;
2194  int opt_port_ifindex = 0; /* != 0 for per-port options */
2195  u32 opt_array_index = 0;
2196  bool opt_is_array = false;
2197  struct team_option_inst *opt_inst;
2198  char *opt_name;
2199  bool opt_found = false;
2200 
2201  if (nla_type(nl_option) != TEAM_ATTR_ITEM_OPTION) {
2202  err = -EINVAL;
2203  goto team_put;
2204  }
2205  err = nla_parse_nested(opt_attrs, TEAM_ATTR_OPTION_MAX,
2206  nl_option, team_nl_option_policy);
2207  if (err)
2208  goto team_put;
2209  if (!opt_attrs[TEAM_ATTR_OPTION_NAME] ||
2210  !opt_attrs[TEAM_ATTR_OPTION_TYPE]) {
2211  err = -EINVAL;
2212  goto team_put;
2213  }
2214  switch (nla_get_u8(opt_attrs[TEAM_ATTR_OPTION_TYPE])) {
2215  case NLA_U32:
2216  opt_type = TEAM_OPTION_TYPE_U32;
2217  break;
2218  case NLA_STRING:
2219  opt_type = TEAM_OPTION_TYPE_STRING;
2220  break;
2221  case NLA_BINARY:
2222  opt_type = TEAM_OPTION_TYPE_BINARY;
2223  break;
2224  case NLA_FLAG:
2225  opt_type = TEAM_OPTION_TYPE_BOOL;
2226  break;
2227  case NLA_S32:
2228  opt_type = TEAM_OPTION_TYPE_S32;
2229  break;
2230  default:
2231  goto team_put;
2232  }
2233 
2234  attr_data = opt_attrs[TEAM_ATTR_OPTION_DATA];
2235  if (opt_type != TEAM_OPTION_TYPE_BOOL && !attr_data) {
2236  err = -EINVAL;
2237  goto team_put;
2238  }
2239 
2240  opt_name = nla_data(opt_attrs[TEAM_ATTR_OPTION_NAME]);
2241  attr = opt_attrs[TEAM_ATTR_OPTION_PORT_IFINDEX];
2242  if (attr)
2243  opt_port_ifindex = nla_get_u32(attr);
2244 
2245  attr = opt_attrs[TEAM_ATTR_OPTION_ARRAY_INDEX];
2246  if (attr) {
2247  opt_is_array = true;
2248  opt_array_index = nla_get_u32(attr);
2249  }
2250 
2251  list_for_each_entry(opt_inst, &team->option_inst_list, list) {
2252  struct team_option *option = opt_inst->option;
2253  struct team_gsetter_ctx ctx;
2254  struct team_option_inst_info *opt_inst_info;
2255  int tmp_ifindex;
2256 
2257  opt_inst_info = &opt_inst->info;
2258  tmp_ifindex = opt_inst_info->port ?
2259  opt_inst_info->port->dev->ifindex : 0;
2260  if (option->type != opt_type ||
2261  strcmp(option->name, opt_name) ||
2262  tmp_ifindex != opt_port_ifindex ||
2263  (option->array_size && !opt_is_array) ||
2264  opt_inst_info->array_index != opt_array_index)
2265  continue;
2266  opt_found = true;
2267  ctx.info = opt_inst_info;
2268  switch (opt_type) {
2269  case TEAM_OPTION_TYPE_U32:
2270  ctx.data.u32_val = nla_get_u32(attr_data);
2271  break;
2273  if (nla_len(attr_data) > TEAM_STRING_MAX_LEN) {
2274  err = -EINVAL;
2275  goto team_put;
2276  }
2277  ctx.data.str_val = nla_data(attr_data);
2278  break;
2280  ctx.data.bin_val.len = nla_len(attr_data);
2281  ctx.data.bin_val.ptr = nla_data(attr_data);
2282  break;
2283  case TEAM_OPTION_TYPE_BOOL:
2284  ctx.data.bool_val = attr_data ? true : false;
2285  break;
2286  case TEAM_OPTION_TYPE_S32:
2287  ctx.data.s32_val = nla_get_s32(attr_data);
2288  break;
2289  default:
2290  BUG();
2291  }
2292  err = team_option_set(team, opt_inst, &ctx);
2293  if (err)
2294  goto team_put;
2295  opt_inst->changed = true;
2296  list_add(&opt_inst->tmp_list, &opt_inst_list);
2297  }
2298  if (!opt_found) {
2299  err = -ENOENT;
2300  goto team_put;
2301  }
2302  }
2303 
2304  err = team_nl_send_event_options_get(team, &opt_inst_list);
2305 
2306 team_put:
2307  team_nl_team_put(team);
2308 
2309  return err;
2310 }
2311 
2312 static int team_nl_fill_port_list_get(struct sk_buff *skb,
2313  u32 portid, u32 seq, int flags,
2314  struct team *team,
2315  bool fillall)
2316 {
2317  struct nlattr *port_list;
2318  void *hdr;
2319  struct team_port *port;
2320 
2321  hdr = genlmsg_put(skb, portid, seq, &team_nl_family, flags,
2323  if (!hdr)
2324  return -EMSGSIZE;
2325 
2326  if (nla_put_u32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex))
2327  goto nla_put_failure;
2328  port_list = nla_nest_start(skb, TEAM_ATTR_LIST_PORT);
2329  if (!port_list)
2330  goto nla_put_failure;
2331 
2332  list_for_each_entry(port, &team->port_list, list) {
2333  struct nlattr *port_item;
2334 
2335  /* Include only changed ports if fill all mode is not on */
2336  if (!fillall && !port->changed)
2337  continue;
2338  port_item = nla_nest_start(skb, TEAM_ATTR_ITEM_PORT);
2339  if (!port_item)
2340  goto nla_put_failure;
2341  if (nla_put_u32(skb, TEAM_ATTR_PORT_IFINDEX, port->dev->ifindex))
2342  goto nla_put_failure;
2343  if (port->changed) {
2344  if (nla_put_flag(skb, TEAM_ATTR_PORT_CHANGED))
2345  goto nla_put_failure;
2346  port->changed = false;
2347  }
2348  if ((port->removed &&
2349  nla_put_flag(skb, TEAM_ATTR_PORT_REMOVED)) ||
2350  (port->state.linkup &&
2351  nla_put_flag(skb, TEAM_ATTR_PORT_LINKUP)) ||
2352  nla_put_u32(skb, TEAM_ATTR_PORT_SPEED, port->state.speed) ||
2353  nla_put_u8(skb, TEAM_ATTR_PORT_DUPLEX, port->state.duplex))
2354  goto nla_put_failure;
2355  nla_nest_end(skb, port_item);
2356  }
2357 
2358  nla_nest_end(skb, port_list);
2359  return genlmsg_end(skb, hdr);
2360 
2361 nla_put_failure:
2362  genlmsg_cancel(skb, hdr);
2363  return -EMSGSIZE;
2364 }
2365 
2366 static int team_nl_fill_port_list_get_all(struct sk_buff *skb,
2367  struct genl_info *info, int flags,
2368  struct team *team)
2369 {
2370  return team_nl_fill_port_list_get(skb, info->snd_portid,
2371  info->snd_seq, NLM_F_ACK,
2372  team, true);
2373 }
2374 
2375 static int team_nl_cmd_port_list_get(struct sk_buff *skb,
2376  struct genl_info *info)
2377 {
2378  struct team *team;
2379  int err;
2380 
2381  team = team_nl_team_get(info);
2382  if (!team)
2383  return -EINVAL;
2384 
2385  err = team_nl_send_generic(info, team, team_nl_fill_port_list_get_all);
2386 
2387  team_nl_team_put(team);
2388 
2389  return err;
2390 }
2391 
2392 static struct genl_ops team_nl_ops[] = {
2393  {
2394  .cmd = TEAM_CMD_NOOP,
2395  .doit = team_nl_cmd_noop,
2396  .policy = team_nl_policy,
2397  },
2398  {
2399  .cmd = TEAM_CMD_OPTIONS_SET,
2400  .doit = team_nl_cmd_options_set,
2401  .policy = team_nl_policy,
2402  .flags = GENL_ADMIN_PERM,
2403  },
2404  {
2405  .cmd = TEAM_CMD_OPTIONS_GET,
2406  .doit = team_nl_cmd_options_get,
2407  .policy = team_nl_policy,
2408  .flags = GENL_ADMIN_PERM,
2409  },
2410  {
2411  .cmd = TEAM_CMD_PORT_LIST_GET,
2412  .doit = team_nl_cmd_port_list_get,
2413  .policy = team_nl_policy,
2414  .flags = GENL_ADMIN_PERM,
2415  },
2416 };
2417 
2418 static struct genl_multicast_group team_change_event_mcgrp = {
2420 };
2421 
2422 static int team_nl_send_multicast(struct sk_buff *skb,
2423  struct team *team, u32 portid)
2424 {
2425  return genlmsg_multicast_netns(dev_net(team->dev), skb, 0,
2426  team_change_event_mcgrp.id, GFP_KERNEL);
2427 }
2428 
2429 static int team_nl_send_event_options_get(struct team *team,
2430  struct list_head *sel_opt_inst_list)
2431 {
2432  return team_nl_send_options_get(team, 0, 0, 0, team_nl_send_multicast,
2433  sel_opt_inst_list);
2434 }
2435 
2436 static int team_nl_send_event_port_list_get(struct team *team)
2437 {
2438  struct sk_buff *skb;
2439  int err;
2440  struct net *net = dev_net(team->dev);
2441 
2442  skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2443  if (!skb)
2444  return -ENOMEM;
2445 
2446  err = team_nl_fill_port_list_get(skb, 0, 0, 0, team, false);
2447  if (err < 0)
2448  goto err_fill;
2449 
2450  err = genlmsg_multicast_netns(net, skb, 0, team_change_event_mcgrp.id,
2451  GFP_KERNEL);
2452  return err;
2453 
2454 err_fill:
2455  nlmsg_free(skb);
2456  return err;
2457 }
2458 
2459 static int team_nl_init(void)
2460 {
2461  int err;
2462 
2463  err = genl_register_family_with_ops(&team_nl_family, team_nl_ops,
2464  ARRAY_SIZE(team_nl_ops));
2465  if (err)
2466  return err;
2467 
2468  err = genl_register_mc_group(&team_nl_family, &team_change_event_mcgrp);
2469  if (err)
2470  goto err_change_event_grp_reg;
2471 
2472  return 0;
2473 
2474 err_change_event_grp_reg:
2475  genl_unregister_family(&team_nl_family);
2476 
2477  return err;
2478 }
2479 
2480 static void team_nl_fini(void)
2481 {
2482  genl_unregister_family(&team_nl_family);
2483 }
2484 
2485 
2486 /******************
2487  * Change checkers
2488  ******************/
2489 
2490 static void __team_options_change_check(struct team *team)
2491 {
2492  int err;
2493  struct team_option_inst *opt_inst;
2494  LIST_HEAD(sel_opt_inst_list);
2495 
2496  list_for_each_entry(opt_inst, &team->option_inst_list, list) {
2497  if (opt_inst->changed)
2498  list_add_tail(&opt_inst->tmp_list, &sel_opt_inst_list);
2499  }
2500  err = team_nl_send_event_options_get(team, &sel_opt_inst_list);
2501  if (err && err != -ESRCH)
2502  netdev_warn(team->dev, "Failed to send options change via netlink (err %d)\n",
2503  err);
2504 }
2505 
2506 /* rtnl lock is held */
2507 
2508 static void __team_port_change_send(struct team_port *port, bool linkup)
2509 {
2510  int err;
2511 
2512  port->changed = true;
2513  port->state.linkup = linkup;
2514  team_refresh_port_linkup(port);
2515  if (linkup) {
2516  struct ethtool_cmd ecmd;
2517 
2518  err = __ethtool_get_settings(port->dev, &ecmd);
2519  if (!err) {
2520  port->state.speed = ethtool_cmd_speed(&ecmd);
2521  port->state.duplex = ecmd.duplex;
2522  goto send_event;
2523  }
2524  }
2525  port->state.speed = 0;
2526  port->state.duplex = 0;
2527 
2528 send_event:
2529  err = team_nl_send_event_port_list_get(port->team);
2530  if (err && err != -ESRCH)
2531  netdev_warn(port->team->dev, "Failed to send port change of device %s via netlink (err %d)\n",
2532  port->dev->name, err);
2533 
2534 }
2535 
2536 static void __team_port_change_check(struct team_port *port, bool linkup)
2537 {
2538  if (port->state.linkup != linkup)
2539  __team_port_change_send(port, linkup);
2540 }
2541 
2542 static void __team_port_change_port_added(struct team_port *port, bool linkup)
2543 {
2544  __team_port_change_send(port, linkup);
2545 }
2546 
2547 static void __team_port_change_port_removed(struct team_port *port)
2548 {
2549  port->removed = true;
2550  __team_port_change_send(port, false);
2551 }
2552 
2553 static void team_port_change_check(struct team_port *port, bool linkup)
2554 {
2555  struct team *team = port->team;
2556 
2557  mutex_lock(&team->lock);
2558  __team_port_change_check(port, linkup);
2559  mutex_unlock(&team->lock);
2560 }
2561 
2562 
2563 /************************************
2564  * Net device notifier event handler
2565  ************************************/
2566 
2567 static int team_device_event(struct notifier_block *unused,
2568  unsigned long event, void *ptr)
2569 {
2570  struct net_device *dev = (struct net_device *) ptr;
2571  struct team_port *port;
2572 
2573  port = team_port_get_rtnl(dev);
2574  if (!port)
2575  return NOTIFY_DONE;
2576 
2577  switch (event) {
2578  case NETDEV_UP:
2579  if (netif_carrier_ok(dev))
2580  team_port_change_check(port, true);
2581  case NETDEV_DOWN:
2582  team_port_change_check(port, false);
2583  case NETDEV_CHANGE:
2584  if (netif_running(port->dev))
2585  team_port_change_check(port,
2586  !!netif_carrier_ok(port->dev));
2587  break;
2588  case NETDEV_UNREGISTER:
2589  team_del_slave(port->team->dev, dev);
2590  break;
2591  case NETDEV_FEAT_CHANGE:
2592  team_compute_features(port->team);
2593  break;
2594  case NETDEV_CHANGEMTU:
2595  /* Forbid to change mtu of underlaying device */
2596  return NOTIFY_BAD;
2598  /* Forbid to change type of underlaying device */
2599  return NOTIFY_BAD;
2600  }
2601  return NOTIFY_DONE;
2602 }
2603 
2604 static struct notifier_block team_notifier_block __read_mostly = {
2605  .notifier_call = team_device_event,
2606 };
2607 
2608 
2609 /***********************
2610  * Module init and exit
2611  ***********************/
2612 
2613 static int __init team_module_init(void)
2614 {
2615  int err;
2616 
2617  register_netdevice_notifier(&team_notifier_block);
2618 
2619  err = rtnl_link_register(&team_link_ops);
2620  if (err)
2621  goto err_rtnl_reg;
2622 
2623  err = team_nl_init();
2624  if (err)
2625  goto err_nl_init;
2626 
2627  return 0;
2628 
2629 err_nl_init:
2630  rtnl_link_unregister(&team_link_ops);
2631 
2632 err_rtnl_reg:
2633  unregister_netdevice_notifier(&team_notifier_block);
2634 
2635  return err;
2636 }
2637 
2638 static void __exit team_module_exit(void)
2639 {
2640  team_nl_fini();
2641  rtnl_link_unregister(&team_link_ops);
2642  unregister_netdevice_notifier(&team_notifier_block);
2643 }
2644 
2645 module_init(team_module_init);
2646 module_exit(team_module_exit);
2647 
2648 MODULE_LICENSE("GPL v2");
2649 MODULE_AUTHOR("Jiri Pirko <[email protected]>");
2650 MODULE_DESCRIPTION("Ethernet team device driver");