?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bnx2fc: Read npiv table from nvram and create vports.
[linux/fpc-iii.git] / net / switchdev / switchdev.c
blob33bafa2e703e299f3b423d1f95b2a21cf177c634
1 /*
2 * net/switchdev/switchdev.c - Switch device API
3 * Copyright (c) 2014 Jiri Pirko <jiri@resnulli.us>
4 * Copyright (c) 2014-2015 Scott Feldman <sfeldma@gmail.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 */
11
12 #include <linux/kernel.h>
13 #include <linux/types.h>
14 #include <linux/init.h>
15 #include <linux/mutex.h>
16 #include <linux/notifier.h>
17 #include <linux/netdevice.h>
18 #include <linux/if_bridge.h>
19 #include <net/ip_fib.h>
20 #include <net/switchdev.h>
21
22 /**
23 * switchdev_port_attr_get - Get port attribute
24 *
25 * @dev: port device
26 * @attr: attribute to get
27 */
28 int switchdev_port_attr_get(struct net_device *dev, struct switchdev_attr *attr)
29 {
30 const struct switchdev_ops *ops = dev->switchdev_ops;
31 struct net_device *lower_dev;
32 struct list_head *iter;
33 struct switchdev_attr first = {
34 .id = SWITCHDEV_ATTR_UNDEFINED
35 };
36 int err = -EOPNOTSUPP;
37
38 if (ops && ops->switchdev_port_attr_get)
39 return ops->switchdev_port_attr_get(dev, attr);
40
41 if (attr->flags & SWITCHDEV_F_NO_RECURSE)
42 return err;
43
44 /* Switch device port(s) may be stacked under
45 * bond/team/vlan dev, so recurse down to get attr on
46 * each port. Return -ENODATA if attr values don't
47 * compare across ports.
48 */
49
50 netdev_for_each_lower_dev(dev, lower_dev, iter) {
51 err = switchdev_port_attr_get(lower_dev, attr);
52 if (err)
53 break;
54 if (first.id == SWITCHDEV_ATTR_UNDEFINED)
55 first = *attr;
56 else if (memcmp(&first, attr, sizeof(*attr)))
57 return -ENODATA;
58 }
59
60 return err;
61 }
62 EXPORT_SYMBOL_GPL(switchdev_port_attr_get);
63
64 static int __switchdev_port_attr_set(struct net_device *dev,
65 struct switchdev_attr *attr)
66 {
67 const struct switchdev_ops *ops = dev->switchdev_ops;
68 struct net_device *lower_dev;
69 struct list_head *iter;
70 int err = -EOPNOTSUPP;
71
72 if (ops && ops->switchdev_port_attr_set)
73 return ops->switchdev_port_attr_set(dev, attr);
74
75 if (attr->flags & SWITCHDEV_F_NO_RECURSE)
76 return err;
77
78 /* Switch device port(s) may be stacked under
79 * bond/team/vlan dev, so recurse down to set attr on
80 * each port.
81 */
82
83 netdev_for_each_lower_dev(dev, lower_dev, iter) {
84 err = __switchdev_port_attr_set(lower_dev, attr);
85 if (err)
86 break;
87 }
88
89 return err;
90 }
91
92 struct switchdev_attr_set_work {
93 struct work_struct work;
94 struct net_device *dev;
95 struct switchdev_attr attr;
96 };
97
98 static void switchdev_port_attr_set_work(struct work_struct *work)
99 {
100 struct switchdev_attr_set_work *asw =
101 container_of(work, struct switchdev_attr_set_work, work);
102 int err;
103
104 rtnl_lock();
105 err = switchdev_port_attr_set(asw->dev, &asw->attr);
106 if (err && err != -EOPNOTSUPP)
107 netdev_err(asw->dev, "failed (err=%d) to set attribute (id=%d)\n",
108 err, asw->attr.id);
109 rtnl_unlock();
110
111 dev_put(asw->dev);
112 kfree(work);
113 }
114
115 static int switchdev_port_attr_set_defer(struct net_device *dev,
116 struct switchdev_attr *attr)
117 {
118 struct switchdev_attr_set_work *asw;
119
120 asw = kmalloc(sizeof(*asw), GFP_ATOMIC);
121 if (!asw)
122 return -ENOMEM;
123
124 INIT_WORK(&asw->work, switchdev_port_attr_set_work);
125
126 dev_hold(dev);
127 asw->dev = dev;
128 memcpy(&asw->attr, attr, sizeof(asw->attr));
129
130 schedule_work(&asw->work);
131
132 return 0;
133 }
134
135 /**
136 * switchdev_port_attr_set - Set port attribute
137 *
138 * @dev: port device
139 * @attr: attribute to set
140 *
141 * Use a 2-phase prepare-commit transaction model to ensure
142 * system is not left in a partially updated state due to
143 * failure from driver/device.
144 */
145 int switchdev_port_attr_set(struct net_device *dev, struct switchdev_attr *attr)
146 {
147 int err;
148
149 if (!rtnl_is_locked()) {
150 /* Running prepare-commit transaction across stacked
151 * devices requires nothing moves, so if rtnl_lock is
152 * not held, schedule a worker thread to hold rtnl_lock
153 * while setting attr.
154 */
155
156 return switchdev_port_attr_set_defer(dev, attr);
157 }
158
159 /* Phase I: prepare for attr set. Driver/device should fail
160 * here if there are going to be issues in the commit phase,
161 * such as lack of resources or support. The driver/device
162 * should reserve resources needed for the commit phase here,
163 * but should not commit the attr.
164 */
165
166 attr->trans = SWITCHDEV_TRANS_PREPARE;
167 err = __switchdev_port_attr_set(dev, attr);
168 if (err) {
169 /* Prepare phase failed: abort the transaction. Any
170 * resources reserved in the prepare phase are
171 * released.
172 */
173
174 if (err != -EOPNOTSUPP) {
175 attr->trans = SWITCHDEV_TRANS_ABORT;
176 __switchdev_port_attr_set(dev, attr);
177 }
178
179 return err;
180 }
181
182 /* Phase II: commit attr set. This cannot fail as a fault
183 * of driver/device. If it does, it's a bug in the driver/device
184 * because the driver said everythings was OK in phase I.
185 */
186
187 attr->trans = SWITCHDEV_TRANS_COMMIT;
188 err = __switchdev_port_attr_set(dev, attr);
189 WARN(err, "%s: Commit of attribute (id=%d) failed.\n",
190 dev->name, attr->id);
191
192 return err;
193 }
194 EXPORT_SYMBOL_GPL(switchdev_port_attr_set);
195
196 static int __switchdev_port_obj_add(struct net_device *dev,
197 struct switchdev_obj *obj)
198 {
199 const struct switchdev_ops *ops = dev->switchdev_ops;
200 struct net_device *lower_dev;
201 struct list_head *iter;
202 int err = -EOPNOTSUPP;
203
204 if (ops && ops->switchdev_port_obj_add)
205 return ops->switchdev_port_obj_add(dev, obj);
206
207 /* Switch device port(s) may be stacked under
208 * bond/team/vlan dev, so recurse down to add object on
209 * each port.
210 */
211
212 netdev_for_each_lower_dev(dev, lower_dev, iter) {
213 err = __switchdev_port_obj_add(lower_dev, obj);
214 if (err)
215 break;
216 }
217
218 return err;
219 }
220
221 /**
222 * switchdev_port_obj_add - Add port object
223 *
224 * @dev: port device
225 * @obj: object to add
226 *
227 * Use a 2-phase prepare-commit transaction model to ensure
228 * system is not left in a partially updated state due to
229 * failure from driver/device.
230 *
231 * rtnl_lock must be held.
232 */
233 int switchdev_port_obj_add(struct net_device *dev, struct switchdev_obj *obj)
234 {
235 int err;
236
237 ASSERT_RTNL();
238
239 /* Phase I: prepare for obj add. Driver/device should fail
240 * here if there are going to be issues in the commit phase,
241 * such as lack of resources or support. The driver/device
242 * should reserve resources needed for the commit phase here,
243 * but should not commit the obj.
244 */
245
246 obj->trans = SWITCHDEV_TRANS_PREPARE;
247 err = __switchdev_port_obj_add(dev, obj);
248 if (err) {
249 /* Prepare phase failed: abort the transaction. Any
250 * resources reserved in the prepare phase are
251 * released.
252 */
253
254 if (err != -EOPNOTSUPP) {
255 obj->trans = SWITCHDEV_TRANS_ABORT;
256 __switchdev_port_obj_add(dev, obj);
257 }
258
259 return err;
260 }
261
262 /* Phase II: commit obj add. This cannot fail as a fault
263 * of driver/device. If it does, it's a bug in the driver/device
264 * because the driver said everythings was OK in phase I.
265 */
266
267 obj->trans = SWITCHDEV_TRANS_COMMIT;
268 err = __switchdev_port_obj_add(dev, obj);
269 WARN(err, "%s: Commit of object (id=%d) failed.\n", dev->name, obj->id);
270
271 return err;
272 }
273 EXPORT_SYMBOL_GPL(switchdev_port_obj_add);
274
275 /**
276 * switchdev_port_obj_del - Delete port object
277 *
278 * @dev: port device
279 * @obj: object to delete
280 */
281 int switchdev_port_obj_del(struct net_device *dev, struct switchdev_obj *obj)
282 {
283 const struct switchdev_ops *ops = dev->switchdev_ops;
284 struct net_device *lower_dev;
285 struct list_head *iter;
286 int err = -EOPNOTSUPP;
287
288 if (ops && ops->switchdev_port_obj_del)
289 return ops->switchdev_port_obj_del(dev, obj);
290
291 /* Switch device port(s) may be stacked under
292 * bond/team/vlan dev, so recurse down to delete object on
293 * each port.
294 */
295
296 netdev_for_each_lower_dev(dev, lower_dev, iter) {
297 err = switchdev_port_obj_del(lower_dev, obj);
298 if (err)
299 break;
300 }
301
302 return err;
303 }
304 EXPORT_SYMBOL_GPL(switchdev_port_obj_del);
305
306 /**
307 * switchdev_port_obj_dump - Dump port objects
308 *
309 * @dev: port device
310 * @obj: object to dump
311 */
312 int switchdev_port_obj_dump(struct net_device *dev, struct switchdev_obj *obj)
313 {
314 const struct switchdev_ops *ops = dev->switchdev_ops;
315 struct net_device *lower_dev;
316 struct list_head *iter;
317 int err = -EOPNOTSUPP;
318
319 if (ops && ops->switchdev_port_obj_dump)
320 return ops->switchdev_port_obj_dump(dev, obj);
321
322 /* Switch device port(s) may be stacked under
323 * bond/team/vlan dev, so recurse down to dump objects on
324 * first port at bottom of stack.
325 */
326
327 netdev_for_each_lower_dev(dev, lower_dev, iter) {
328 err = switchdev_port_obj_dump(lower_dev, obj);
329 break;
330 }
331
332 return err;
333 }
334 EXPORT_SYMBOL_GPL(switchdev_port_obj_dump);
335
336 static DEFINE_MUTEX(switchdev_mutex);
337 static RAW_NOTIFIER_HEAD(switchdev_notif_chain);
338
339 /**
340 * register_switchdev_notifier - Register notifier
341 * @nb: notifier_block
342 *
343 * Register switch device notifier. This should be used by code
344 * which needs to monitor events happening in particular device.
345 * Return values are same as for atomic_notifier_chain_register().
346 */
347 int register_switchdev_notifier(struct notifier_block *nb)
348 {
349 int err;
350
351 mutex_lock(&switchdev_mutex);
352 err = raw_notifier_chain_register(&switchdev_notif_chain, nb);
353 mutex_unlock(&switchdev_mutex);
354 return err;
355 }
356 EXPORT_SYMBOL_GPL(register_switchdev_notifier);
357
358 /**
359 * unregister_switchdev_notifier - Unregister notifier
360 * @nb: notifier_block
361 *
362 * Unregister switch device notifier.
363 * Return values are same as for atomic_notifier_chain_unregister().
364 */
365 int unregister_switchdev_notifier(struct notifier_block *nb)
366 {
367 int err;
368
369 mutex_lock(&switchdev_mutex);
370 err = raw_notifier_chain_unregister(&switchdev_notif_chain, nb);
371 mutex_unlock(&switchdev_mutex);
372 return err;
373 }
374 EXPORT_SYMBOL_GPL(unregister_switchdev_notifier);
375
376 /**
377 * call_switchdev_notifiers - Call notifiers
378 * @val: value passed unmodified to notifier function
379 * @dev: port device
380 * @info: notifier information data
381 *
382 * Call all network notifier blocks. This should be called by driver
383 * when it needs to propagate hardware event.
384 * Return values are same as for atomic_notifier_call_chain().
385 */
386 int call_switchdev_notifiers(unsigned long val, struct net_device *dev,
387 struct switchdev_notifier_info *info)
388 {
389 int err;
390
391 info->dev = dev;
392 mutex_lock(&switchdev_mutex);
393 err = raw_notifier_call_chain(&switchdev_notif_chain, val, info);
394 mutex_unlock(&switchdev_mutex);
395 return err;
396 }
397 EXPORT_SYMBOL_GPL(call_switchdev_notifiers);
398
399 struct switchdev_vlan_dump {
400 struct switchdev_obj obj;
401 struct sk_buff *skb;
402 u32 filter_mask;
403 u16 flags;
404 u16 begin;
405 u16 end;
406 };
407
408 static int switchdev_port_vlan_dump_put(struct net_device *dev,
409 struct switchdev_vlan_dump *dump)
410 {
411 struct bridge_vlan_info vinfo;
412
413 vinfo.flags = dump->flags;
414
415 if (dump->begin == 0 && dump->end == 0) {
416 return 0;
417 } else if (dump->begin == dump->end) {
418 vinfo.vid = dump->begin;
419 if (nla_put(dump->skb, IFLA_BRIDGE_VLAN_INFO,
420 sizeof(vinfo), &vinfo))
421 return -EMSGSIZE;
422 } else {
423 vinfo.vid = dump->begin;
424 vinfo.flags |= BRIDGE_VLAN_INFO_RANGE_BEGIN;
425 if (nla_put(dump->skb, IFLA_BRIDGE_VLAN_INFO,
426 sizeof(vinfo), &vinfo))
427 return -EMSGSIZE;
428 vinfo.vid = dump->end;
429 vinfo.flags &= ~BRIDGE_VLAN_INFO_RANGE_BEGIN;
430 vinfo.flags |= BRIDGE_VLAN_INFO_RANGE_END;
431 if (nla_put(dump->skb, IFLA_BRIDGE_VLAN_INFO,
432 sizeof(vinfo), &vinfo))
433 return -EMSGSIZE;
434 }
435
436 return 0;
437 }
438
439 static int switchdev_port_vlan_dump_cb(struct net_device *dev,
440 struct switchdev_obj *obj)
441 {
442 struct switchdev_vlan_dump *dump =
443 container_of(obj, struct switchdev_vlan_dump, obj);
444 struct switchdev_obj_vlan *vlan = &dump->obj.u.vlan;
445 int err = 0;
446
447 if (vlan->vid_begin > vlan->vid_end)
448 return -EINVAL;
449
450 if (dump->filter_mask & RTEXT_FILTER_BRVLAN) {
451 dump->flags = vlan->flags;
452 for (dump->begin = dump->end = vlan->vid_begin;
453 dump->begin <= vlan->vid_end;
454 dump->begin++, dump->end++) {
455 err = switchdev_port_vlan_dump_put(dev, dump);
456 if (err)
457 return err;
458 }
459 } else if (dump->filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED) {
460 if (dump->begin > vlan->vid_begin &&
461 dump->begin >= vlan->vid_end) {
462 if ((dump->begin - 1) == vlan->vid_end &&
463 dump->flags == vlan->flags) {
464 /* prepend */
465 dump->begin = vlan->vid_begin;
466 } else {
467 err = switchdev_port_vlan_dump_put(dev, dump);
468 dump->flags = vlan->flags;
469 dump->begin = vlan->vid_begin;
470 dump->end = vlan->vid_end;
471 }
472 } else if (dump->end <= vlan->vid_begin &&
473 dump->end < vlan->vid_end) {
474 if ((dump->end + 1) == vlan->vid_begin &&
475 dump->flags == vlan->flags) {
476 /* append */
477 dump->end = vlan->vid_end;
478 } else {
479 err = switchdev_port_vlan_dump_put(dev, dump);
480 dump->flags = vlan->flags;
481 dump->begin = vlan->vid_begin;
482 dump->end = vlan->vid_end;
483 }
484 } else {
485 err = -EINVAL;
486 }
487 }
488
489 return err;
490 }
491
492 static int switchdev_port_vlan_fill(struct sk_buff *skb, struct net_device *dev,
493 u32 filter_mask)
494 {
495 struct switchdev_vlan_dump dump = {
496 .obj = {
497 .id = SWITCHDEV_OBJ_PORT_VLAN,
498 .cb = switchdev_port_vlan_dump_cb,
499 },
500 .skb = skb,
501 .filter_mask = filter_mask,
502 };
503 int err = 0;
504
505 if ((filter_mask & RTEXT_FILTER_BRVLAN) ||
506 (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)) {
507 err = switchdev_port_obj_dump(dev, &dump.obj);
508 if (err)
509 goto err_out;
510 if (filter_mask & RTEXT_FILTER_BRVLAN_COMPRESSED)
511 /* last one */
512 err = switchdev_port_vlan_dump_put(dev, &dump);
513 }
514
515 err_out:
516 return err == -EOPNOTSUPP ? 0 : err;
517 }
518
519 /**
520 * switchdev_port_bridge_getlink - Get bridge port attributes
521 *
522 * @dev: port device
523 *
524 * Called for SELF on rtnl_bridge_getlink to get bridge port
525 * attributes.
526 */
527 int switchdev_port_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
528 struct net_device *dev, u32 filter_mask,
529 int nlflags)
530 {
531 struct switchdev_attr attr = {
532 .id = SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
533 };
534 u16 mode = BRIDGE_MODE_UNDEF;
535 u32 mask = BR_LEARNING | BR_LEARNING_SYNC;
536 int err;
537
538 err = switchdev_port_attr_get(dev, &attr);
539 if (err && err != -EOPNOTSUPP)
540 return err;
541
542 return ndo_dflt_bridge_getlink(skb, pid, seq, dev, mode,
543 attr.u.brport_flags, mask, nlflags,
544 filter_mask, switchdev_port_vlan_fill);
545 }
546 EXPORT_SYMBOL_GPL(switchdev_port_bridge_getlink);
547
548 static int switchdev_port_br_setflag(struct net_device *dev,
549 struct nlattr *nlattr,
550 unsigned long brport_flag)
551 {
552 struct switchdev_attr attr = {
553 .id = SWITCHDEV_ATTR_PORT_BRIDGE_FLAGS,
554 };
555 u8 flag = nla_get_u8(nlattr);
556 int err;
557
558 err = switchdev_port_attr_get(dev, &attr);
559 if (err)
560 return err;
561
562 if (flag)
563 attr.u.brport_flags |= brport_flag;
564 else
565 attr.u.brport_flags &= ~brport_flag;
566
567 return switchdev_port_attr_set(dev, &attr);
568 }
569
570 static const struct nla_policy
571 switchdev_port_bridge_policy[IFLA_BRPORT_MAX + 1] = {
572 [IFLA_BRPORT_STATE] = { .type = NLA_U8 },
573 [IFLA_BRPORT_COST] = { .type = NLA_U32 },
574 [IFLA_BRPORT_PRIORITY] = { .type = NLA_U16 },
575 [IFLA_BRPORT_MODE] = { .type = NLA_U8 },
576 [IFLA_BRPORT_GUARD] = { .type = NLA_U8 },
577 [IFLA_BRPORT_PROTECT] = { .type = NLA_U8 },
578 [IFLA_BRPORT_FAST_LEAVE] = { .type = NLA_U8 },
579 [IFLA_BRPORT_LEARNING] = { .type = NLA_U8 },
580 [IFLA_BRPORT_LEARNING_SYNC] = { .type = NLA_U8 },
581 [IFLA_BRPORT_UNICAST_FLOOD] = { .type = NLA_U8 },
582 };
583
584 static int switchdev_port_br_setlink_protinfo(struct net_device *dev,
585 struct nlattr *protinfo)
586 {
587 struct nlattr *attr;
588 int rem;
589 int err;
590
591 err = nla_validate_nested(protinfo, IFLA_BRPORT_MAX,
592 switchdev_port_bridge_policy);
593 if (err)
594 return err;
595
596 nla_for_each_nested(attr, protinfo, rem) {
597 switch (nla_type(attr)) {
598 case IFLA_BRPORT_LEARNING:
599 err = switchdev_port_br_setflag(dev, attr,
600 BR_LEARNING);
601 break;
602 case IFLA_BRPORT_LEARNING_SYNC:
603 err = switchdev_port_br_setflag(dev, attr,
604 BR_LEARNING_SYNC);
605 break;
606 default:
607 err = -EOPNOTSUPP;
608 break;
609 }
610 if (err)
611 return err;
612 }
613
614 return 0;
615 }
616
617 static int switchdev_port_br_afspec(struct net_device *dev,
618 struct nlattr *afspec,
619 int (*f)(struct net_device *dev,
620 struct switchdev_obj *obj))
621 {
622 struct nlattr *attr;
623 struct bridge_vlan_info *vinfo;
624 struct switchdev_obj obj = {
625 .id = SWITCHDEV_OBJ_PORT_VLAN,
626 };
627 struct switchdev_obj_vlan *vlan = &obj.u.vlan;
628 int rem;
629 int err;
630
631 nla_for_each_nested(attr, afspec, rem) {
632 if (nla_type(attr) != IFLA_BRIDGE_VLAN_INFO)
633 continue;
634 if (nla_len(attr) != sizeof(struct bridge_vlan_info))
635 return -EINVAL;
636 vinfo = nla_data(attr);
637 vlan->flags = vinfo->flags;
638 if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
639 if (vlan->vid_begin)
640 return -EINVAL;
641 vlan->vid_begin = vinfo->vid;
642 } else if (vinfo->flags & BRIDGE_VLAN_INFO_RANGE_END) {
643 if (!vlan->vid_begin)
644 return -EINVAL;
645 vlan->vid_end = vinfo->vid;
646 if (vlan->vid_end <= vlan->vid_begin)
647 return -EINVAL;
648 err = f(dev, &obj);
649 if (err)
650 return err;
651 memset(vlan, 0, sizeof(*vlan));
652 } else {
653 if (vlan->vid_begin)
654 return -EINVAL;
655 vlan->vid_begin = vinfo->vid;
656 vlan->vid_end = vinfo->vid;
657 err = f(dev, &obj);
658 if (err)
659 return err;
660 memset(vlan, 0, sizeof(*vlan));
661 }
662 }
663
664 return 0;
665 }
666
667 /**
668 * switchdev_port_bridge_setlink - Set bridge port attributes
669 *
670 * @dev: port device
671 * @nlh: netlink header
672 * @flags: netlink flags
673 *
674 * Called for SELF on rtnl_bridge_setlink to set bridge port
675 * attributes.
676 */
677 int switchdev_port_bridge_setlink(struct net_device *dev,
678 struct nlmsghdr *nlh, u16 flags)
679 {
680 struct nlattr *protinfo;
681 struct nlattr *afspec;
682 int err = 0;
683
684 protinfo = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg),
685 IFLA_PROTINFO);
686 if (protinfo) {
687 err = switchdev_port_br_setlink_protinfo(dev, protinfo);
688 if (err)
689 return err;
690 }
691
692 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg),
693 IFLA_AF_SPEC);
694 if (afspec)
695 err = switchdev_port_br_afspec(dev, afspec,
696 switchdev_port_obj_add);
697
698 return err;
699 }
700 EXPORT_SYMBOL_GPL(switchdev_port_bridge_setlink);
701
702 /**
703 * switchdev_port_bridge_dellink - Set bridge port attributes
704 *
705 * @dev: port device
706 * @nlh: netlink header
707 * @flags: netlink flags
708 *
709 * Called for SELF on rtnl_bridge_dellink to set bridge port
710 * attributes.
711 */
712 int switchdev_port_bridge_dellink(struct net_device *dev,
713 struct nlmsghdr *nlh, u16 flags)
714 {
715 struct nlattr *afspec;
716
717 afspec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg),
718 IFLA_AF_SPEC);
719 if (afspec)
720 return switchdev_port_br_afspec(dev, afspec,
721 switchdev_port_obj_del);
722
723 return 0;
724 }
725 EXPORT_SYMBOL_GPL(switchdev_port_bridge_dellink);
726
727 /**
728 * switchdev_port_fdb_add - Add FDB (MAC/VLAN) entry to port
729 *
730 * @ndmsg: netlink hdr
731 * @nlattr: netlink attributes
732 * @dev: port device
733 * @addr: MAC address to add
734 * @vid: VLAN to add
735 *
736 * Add FDB entry to switch device.
737 */
738 int switchdev_port_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
739 struct net_device *dev, const unsigned char *addr,
740 u16 vid, u16 nlm_flags)
741 {
742 struct switchdev_obj obj = {
743 .id = SWITCHDEV_OBJ_PORT_FDB,
744 .u.fdb = {
745 .addr = addr,
746 .vid = vid,
747 },
748 };
749
750 return switchdev_port_obj_add(dev, &obj);
751 }
752 EXPORT_SYMBOL_GPL(switchdev_port_fdb_add);
753
754 /**
755 * switchdev_port_fdb_del - Delete FDB (MAC/VLAN) entry from port
756 *
757 * @ndmsg: netlink hdr
758 * @nlattr: netlink attributes
759 * @dev: port device
760 * @addr: MAC address to delete
761 * @vid: VLAN to delete
762 *
763 * Delete FDB entry from switch device.
764 */
765 int switchdev_port_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
766 struct net_device *dev, const unsigned char *addr,
767 u16 vid)
768 {
769 struct switchdev_obj obj = {
770 .id = SWITCHDEV_OBJ_PORT_FDB,
771 .u.fdb = {
772 .addr = addr,
773 .vid = vid,
774 },
775 };
776
777 return switchdev_port_obj_del(dev, &obj);
778 }
779 EXPORT_SYMBOL_GPL(switchdev_port_fdb_del);
780
781 struct switchdev_fdb_dump {
782 struct switchdev_obj obj;
783 struct sk_buff *skb;
784 struct netlink_callback *cb;
785 int idx;
786 };
787
788 static int switchdev_port_fdb_dump_cb(struct net_device *dev,
789 struct switchdev_obj *obj)
790 {
791 struct switchdev_fdb_dump *dump =
792 container_of(obj, struct switchdev_fdb_dump, obj);
793 u32 portid = NETLINK_CB(dump->cb->skb).portid;
794 u32 seq = dump->cb->nlh->nlmsg_seq;
795 struct nlmsghdr *nlh;
796 struct ndmsg *ndm;
797
798 if (dump->idx < dump->cb->args[0])
799 goto skip;
800
801 nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH,
802 sizeof(*ndm), NLM_F_MULTI);
803 if (!nlh)
804 return -EMSGSIZE;
805
806 ndm = nlmsg_data(nlh);
807 ndm->ndm_family = AF_BRIDGE;
808 ndm->ndm_pad1 = 0;
809 ndm->ndm_pad2 = 0;
810 ndm->ndm_flags = NTF_SELF;
811 ndm->ndm_type = 0;
812 ndm->ndm_ifindex = dev->ifindex;
813 ndm->ndm_state = NUD_REACHABLE;
814
815 if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, obj->u.fdb.addr))
816 goto nla_put_failure;
817
818 if (obj->u.fdb.vid && nla_put_u16(dump->skb, NDA_VLAN, obj->u.fdb.vid))
819 goto nla_put_failure;
820
821 nlmsg_end(dump->skb, nlh);
822
823 skip:
824 dump->idx++;
825 return 0;
826
827 nla_put_failure:
828 nlmsg_cancel(dump->skb, nlh);
829 return -EMSGSIZE;
830 }
831
832 /**
833 * switchdev_port_fdb_dump - Dump port FDB (MAC/VLAN) entries
834 *
835 * @skb: netlink skb
836 * @cb: netlink callback
837 * @dev: port device
838 * @filter_dev: filter device
839 * @idx:
840 *
841 * Delete FDB entry from switch device.
842 */
843 int switchdev_port_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
844 struct net_device *dev,
845 struct net_device *filter_dev, int idx)
846 {
847 struct switchdev_fdb_dump dump = {
848 .obj = {
849 .id = SWITCHDEV_OBJ_PORT_FDB,
850 .cb = switchdev_port_fdb_dump_cb,
851 },
852 .skb = skb,
853 .cb = cb,
854 .idx = idx,
855 };
856 int err;
857
858 err = switchdev_port_obj_dump(dev, &dump.obj);
859 if (err)
860 return err;
861
862 return dump.idx;
863 }
864 EXPORT_SYMBOL_GPL(switchdev_port_fdb_dump);
865
866 static struct net_device *switchdev_get_lowest_dev(struct net_device *dev)
867 {
868 const struct switchdev_ops *ops = dev->switchdev_ops;
869 struct net_device *lower_dev;
870 struct net_device *port_dev;
871 struct list_head *iter;
872
873 /* Recusively search down until we find a sw port dev.
874 * (A sw port dev supports switchdev_port_attr_get).
875 */
876
877 if (ops && ops->switchdev_port_attr_get)
878 return dev;
879
880 netdev_for_each_lower_dev(dev, lower_dev, iter) {
881 port_dev = switchdev_get_lowest_dev(lower_dev);
882 if (port_dev)
883 return port_dev;
884 }
885
886 return NULL;
887 }
888
889 static struct net_device *switchdev_get_dev_by_nhs(struct fib_info *fi)
890 {
891 struct switchdev_attr attr = {
892 .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
893 };
894 struct switchdev_attr prev_attr;
895 struct net_device *dev = NULL;
896 int nhsel;
897
898 /* For this route, all nexthop devs must be on the same switch. */
899
900 for (nhsel = 0; nhsel < fi->fib_nhs; nhsel++) {
901 const struct fib_nh *nh = &fi->fib_nh[nhsel];
902
903 if (!nh->nh_dev)
904 return NULL;
905
906 dev = switchdev_get_lowest_dev(nh->nh_dev);
907 if (!dev)
908 return NULL;
909
910 if (switchdev_port_attr_get(dev, &attr))
911 return NULL;
912
913 if (nhsel > 0 &&
914 !netdev_phys_item_id_same(&prev_attr.u.ppid, &attr.u.ppid))
915 return NULL;
916
917 prev_attr = attr;
918 }
919
920 return dev;
921 }
922
923 /**
924 * switchdev_fib_ipv4_add - Add/modify switch IPv4 route entry
925 *
926 * @dst: route's IPv4 destination address
927 * @dst_len: destination address length (prefix length)
928 * @fi: route FIB info structure
929 * @tos: route TOS
930 * @type: route type
931 * @nlflags: netlink flags passed in (NLM_F_*)
932 * @tb_id: route table ID
933 *
934 * Add/modify switch IPv4 route entry.
935 */
936 int switchdev_fib_ipv4_add(u32 dst, int dst_len, struct fib_info *fi,
937 u8 tos, u8 type, u32 nlflags, u32 tb_id)
938 {
939 struct switchdev_obj fib_obj = {
940 .id = SWITCHDEV_OBJ_IPV4_FIB,
941 .u.ipv4_fib = {
942 .dst = dst,
943 .dst_len = dst_len,
944 .fi = fi,
945 .tos = tos,
946 .type = type,
947 .nlflags = nlflags,
948 .tb_id = tb_id,
949 },
950 };
951 struct net_device *dev;
952 int err = 0;
953
954 /* Don't offload route if using custom ip rules or if
955 * IPv4 FIB offloading has been disabled completely.
956 */
957
958 #ifdef CONFIG_IP_MULTIPLE_TABLES
959 if (fi->fib_net->ipv4.fib_has_custom_rules)
960 return 0;
961 #endif
962
963 if (fi->fib_net->ipv4.fib_offload_disabled)
964 return 0;
965
966 dev = switchdev_get_dev_by_nhs(fi);
967 if (!dev)
968 return 0;
969
970 err = switchdev_port_obj_add(dev, &fib_obj);
971 if (!err)
972 fi->fib_flags |= RTNH_F_OFFLOAD;
973
974 return err == -EOPNOTSUPP ? 0 : err;
975 }
976 EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_add);
977
978 /**
979 * switchdev_fib_ipv4_del - Delete IPv4 route entry from switch
980 *
981 * @dst: route's IPv4 destination address
982 * @dst_len: destination address length (prefix length)
983 * @fi: route FIB info structure
984 * @tos: route TOS
985 * @type: route type
986 * @tb_id: route table ID
987 *
988 * Delete IPv4 route entry from switch device.
989 */
990 int switchdev_fib_ipv4_del(u32 dst, int dst_len, struct fib_info *fi,
991 u8 tos, u8 type, u32 tb_id)
992 {
993 struct switchdev_obj fib_obj = {
994 .id = SWITCHDEV_OBJ_IPV4_FIB,
995 .u.ipv4_fib = {
996 .dst = dst,
997 .dst_len = dst_len,
998 .fi = fi,
999 .tos = tos,
1000 .type = type,
1001 .nlflags = 0,
1002 .tb_id = tb_id,
1003 },
1004 };
1005 struct net_device *dev;
1006 int err = 0;
1007
1008 if (!(fi->fib_flags & RTNH_F_OFFLOAD))
1009 return 0;
1010
1011 dev = switchdev_get_dev_by_nhs(fi);
1012 if (!dev)
1013 return 0;
1014
1015 err = switchdev_port_obj_del(dev, &fib_obj);
1016 if (!err)
1017 fi->fib_flags &= ~RTNH_F_OFFLOAD;
1018
1019 return err == -EOPNOTSUPP ? 0 : err;
1020 }
1021 EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_del);
1022
1023 /**
1024 * switchdev_fib_ipv4_abort - Abort an IPv4 FIB operation
1025 *
1026 * @fi: route FIB info structure
1027 */
1028 void switchdev_fib_ipv4_abort(struct fib_info *fi)
1029 {
1030 /* There was a problem installing this route to the offload
1031 * device. For now, until we come up with more refined
1032 * policy handling, abruptly end IPv4 fib offloading for
1033 * for entire net by flushing offload device(s) of all
1034 * IPv4 routes, and mark IPv4 fib offloading broken from
1035 * this point forward.
1036 */
1037
1038 fib_flush_external(fi->fib_net);
1039 fi->fib_net->ipv4.fib_offload_disabled = true;
1040 }
1041 EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_abort);
1042
1043 static bool switchdev_port_same_parent_id(struct net_device *a,
1044 struct net_device *b)
1045 {
1046 struct switchdev_attr a_attr = {
1047 .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
1048 .flags = SWITCHDEV_F_NO_RECURSE,
1049 };
1050 struct switchdev_attr b_attr = {
1051 .id = SWITCHDEV_ATTR_PORT_PARENT_ID,
1052 .flags = SWITCHDEV_F_NO_RECURSE,
1053 };
1054
1055 if (switchdev_port_attr_get(a, &a_attr) ||
1056 switchdev_port_attr_get(b, &b_attr))
1057 return false;
1058
1059 return netdev_phys_item_id_same(&a_attr.u.ppid, &b_attr.u.ppid);
1060 }
1061
1062 static u32 switchdev_port_fwd_mark_get(struct net_device *dev,
1063 struct net_device *group_dev)
1064 {
1065 struct net_device *lower_dev;
1066 struct list_head *iter;
1067
1068 netdev_for_each_lower_dev(group_dev, lower_dev, iter) {
1069 if (lower_dev == dev)
1070 continue;
1071 if (switchdev_port_same_parent_id(dev, lower_dev))
1072 return lower_dev->offload_fwd_mark;
1073 return switchdev_port_fwd_mark_get(dev, lower_dev);
1074 }
1075
1076 return dev->ifindex;
1077 }
1078
1079 static void switchdev_port_fwd_mark_reset(struct net_device *group_dev,
1080 u32 old_mark, u32 *reset_mark)
1081 {
1082 struct net_device *lower_dev;
1083 struct list_head *iter;
1084
1085 netdev_for_each_lower_dev(group_dev, lower_dev, iter) {
1086 if (lower_dev->offload_fwd_mark == old_mark) {
1087 if (!*reset_mark)
1088 *reset_mark = lower_dev->ifindex;
1089 lower_dev->offload_fwd_mark = *reset_mark;
1090 }
1091 switchdev_port_fwd_mark_reset(lower_dev, old_mark, reset_mark);
1092 }
1093 }
1094
1095 /**
1096 * switchdev_port_fwd_mark_set - Set port offload forwarding mark
1097 *
1098 * @dev: port device
1099 * @group_dev: containing device
1100 * @joining: true if dev is joining group; false if leaving group
1101 *
1102 * An ungrouped port's offload mark is just its ifindex. A grouped
1103 * port's (member of a bridge, for example) offload mark is the ifindex
1104 * of one of the ports in the group with the same parent (switch) ID.
1105 * Ports on the same device in the same group will have the same mark.
1106 *
1107 * Example:
1108 *
1109 * br0 ifindex=9
1110 * sw1p1 ifindex=2 mark=2
1111 * sw1p2 ifindex=3 mark=2
1112 * sw2p1 ifindex=4 mark=5
1113 * sw2p2 ifindex=5 mark=5
1114 *
1115 * If sw2p2 leaves the bridge, we'll have:
1116 *
1117 * br0 ifindex=9
1118 * sw1p1 ifindex=2 mark=2
1119 * sw1p2 ifindex=3 mark=2
1120 * sw2p1 ifindex=4 mark=4
1121 * sw2p2 ifindex=5 mark=5
1122 */
1123 void switchdev_port_fwd_mark_set(struct net_device *dev,
1124 struct net_device *group_dev,
1125 bool joining)
1126 {
1127 u32 mark = dev->ifindex;
1128 u32 reset_mark = 0;
1129
1130 if (group_dev && joining) {
1131 mark = switchdev_port_fwd_mark_get(dev, group_dev);
1132 } else if (group_dev && !joining) {
1133 if (dev->offload_fwd_mark == mark)
1134 /* Ohoh, this port was the mark reference port,
1135 * but it's leaving the group, so reset the
1136 * mark for the remaining ports in the group.
1137 */
1138 switchdev_port_fwd_mark_reset(group_dev, mark,
1139 &reset_mark);
1140 }
1141
1142 dev->offload_fwd_mark = mark;
1143 }
1144 EXPORT_SYMBOL_GPL(switchdev_port_fwd_mark_set);
Linux with added FPC-III support