2 * net/switchdev/switchdev.c - Switch device API
3 * Copyright (c) 2014-2015 Jiri Pirko <jiri@resnulli.us>
4 * Copyright (c) 2014-2015 Scott Feldman <sfeldma@gmail.com>
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.
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/etherdevice.h>
19 #include <linux/if_bridge.h>
20 #include <linux/list.h>
21 #include <linux/workqueue.h>
22 #include <linux/if_vlan.h>
23 #include <net/ip_fib.h>
24 #include <net/switchdev.h>
27 * switchdev_trans_item_enqueue - Enqueue data item to transaction queue
30 * @data: pointer to data being queued
31 * @destructor: data destructor
32 * @tritem: transaction item being queued
34 * Enqeueue data item to transaction queue. tritem is typically placed in
35 * cointainter pointed at by data pointer. Destructor is called on
36 * transaction abort and after successful commit phase in case
37 * the caller did not dequeue the item before.
39 void switchdev_trans_item_enqueue(struct switchdev_trans
*trans
,
40 void *data
, void (*destructor
)(void const *),
41 struct switchdev_trans_item
*tritem
)
44 tritem
->destructor
= destructor
;
45 list_add_tail(&tritem
->list
, &trans
->item_list
);
47 EXPORT_SYMBOL_GPL(switchdev_trans_item_enqueue
);
49 static struct switchdev_trans_item
*
50 __switchdev_trans_item_dequeue(struct switchdev_trans
*trans
)
52 struct switchdev_trans_item
*tritem
;
54 if (list_empty(&trans
->item_list
))
56 tritem
= list_first_entry(&trans
->item_list
,
57 struct switchdev_trans_item
, list
);
58 list_del(&tritem
->list
);
63 * switchdev_trans_item_dequeue - Dequeue data item from transaction queue
67 void *switchdev_trans_item_dequeue(struct switchdev_trans
*trans
)
69 struct switchdev_trans_item
*tritem
;
71 tritem
= __switchdev_trans_item_dequeue(trans
);
75 EXPORT_SYMBOL_GPL(switchdev_trans_item_dequeue
);
77 static void switchdev_trans_init(struct switchdev_trans
*trans
)
79 INIT_LIST_HEAD(&trans
->item_list
);
82 static void switchdev_trans_items_destroy(struct switchdev_trans
*trans
)
84 struct switchdev_trans_item
*tritem
;
86 while ((tritem
= __switchdev_trans_item_dequeue(trans
)))
87 tritem
->destructor(tritem
->data
);
90 static void switchdev_trans_items_warn_destroy(struct net_device
*dev
,
91 struct switchdev_trans
*trans
)
93 WARN(!list_empty(&trans
->item_list
), "%s: transaction item queue is not empty.\n",
95 switchdev_trans_items_destroy(trans
);
98 static LIST_HEAD(deferred
);
99 static DEFINE_SPINLOCK(deferred_lock
);
101 typedef void switchdev_deferred_func_t(struct net_device
*dev
,
104 struct switchdev_deferred_item
{
105 struct list_head list
;
106 struct net_device
*dev
;
107 switchdev_deferred_func_t
*func
;
108 unsigned long data
[0];
111 static struct switchdev_deferred_item
*switchdev_deferred_dequeue(void)
113 struct switchdev_deferred_item
*dfitem
;
115 spin_lock_bh(&deferred_lock
);
116 if (list_empty(&deferred
)) {
120 dfitem
= list_first_entry(&deferred
,
121 struct switchdev_deferred_item
, list
);
122 list_del(&dfitem
->list
);
124 spin_unlock_bh(&deferred_lock
);
129 * switchdev_deferred_process - Process ops in deferred queue
131 * Called to flush the ops currently queued in deferred ops queue.
132 * rtnl_lock must be held.
134 void switchdev_deferred_process(void)
136 struct switchdev_deferred_item
*dfitem
;
140 while ((dfitem
= switchdev_deferred_dequeue())) {
141 dfitem
->func(dfitem
->dev
, dfitem
->data
);
142 dev_put(dfitem
->dev
);
146 EXPORT_SYMBOL_GPL(switchdev_deferred_process
);
148 static void switchdev_deferred_process_work(struct work_struct
*work
)
151 switchdev_deferred_process();
155 static DECLARE_WORK(deferred_process_work
, switchdev_deferred_process_work
);
157 static int switchdev_deferred_enqueue(struct net_device
*dev
,
158 const void *data
, size_t data_len
,
159 switchdev_deferred_func_t
*func
)
161 struct switchdev_deferred_item
*dfitem
;
163 dfitem
= kmalloc(sizeof(*dfitem
) + data_len
, GFP_ATOMIC
);
168 memcpy(dfitem
->data
, data
, data_len
);
170 spin_lock_bh(&deferred_lock
);
171 list_add_tail(&dfitem
->list
, &deferred
);
172 spin_unlock_bh(&deferred_lock
);
173 schedule_work(&deferred_process_work
);
178 * switchdev_port_attr_get - Get port attribute
181 * @attr: attribute to get
183 int switchdev_port_attr_get(struct net_device
*dev
, struct switchdev_attr
*attr
)
185 const struct switchdev_ops
*ops
= dev
->switchdev_ops
;
186 struct net_device
*lower_dev
;
187 struct list_head
*iter
;
188 struct switchdev_attr first
= {
189 .id
= SWITCHDEV_ATTR_ID_UNDEFINED
191 int err
= -EOPNOTSUPP
;
193 if (ops
&& ops
->switchdev_port_attr_get
)
194 return ops
->switchdev_port_attr_get(dev
, attr
);
196 if (attr
->flags
& SWITCHDEV_F_NO_RECURSE
)
199 /* Switch device port(s) may be stacked under
200 * bond/team/vlan dev, so recurse down to get attr on
201 * each port. Return -ENODATA if attr values don't
202 * compare across ports.
205 netdev_for_each_lower_dev(dev
, lower_dev
, iter
) {
206 err
= switchdev_port_attr_get(lower_dev
, attr
);
209 if (first
.id
== SWITCHDEV_ATTR_ID_UNDEFINED
)
211 else if (memcmp(&first
, attr
, sizeof(*attr
)))
217 EXPORT_SYMBOL_GPL(switchdev_port_attr_get
);
219 static int __switchdev_port_attr_set(struct net_device
*dev
,
220 const struct switchdev_attr
*attr
,
221 struct switchdev_trans
*trans
)
223 const struct switchdev_ops
*ops
= dev
->switchdev_ops
;
224 struct net_device
*lower_dev
;
225 struct list_head
*iter
;
226 int err
= -EOPNOTSUPP
;
228 if (ops
&& ops
->switchdev_port_attr_set
) {
229 err
= ops
->switchdev_port_attr_set(dev
, attr
, trans
);
233 if (attr
->flags
& SWITCHDEV_F_NO_RECURSE
)
236 /* Switch device port(s) may be stacked under
237 * bond/team/vlan dev, so recurse down to set attr on
241 netdev_for_each_lower_dev(dev
, lower_dev
, iter
) {
242 err
= __switchdev_port_attr_set(lower_dev
, attr
, trans
);
248 if (err
== -EOPNOTSUPP
&& attr
->flags
& SWITCHDEV_F_SKIP_EOPNOTSUPP
)
254 static int switchdev_port_attr_set_now(struct net_device
*dev
,
255 const struct switchdev_attr
*attr
)
257 struct switchdev_trans trans
;
260 switchdev_trans_init(&trans
);
262 /* Phase I: prepare for attr set. Driver/device should fail
263 * here if there are going to be issues in the commit phase,
264 * such as lack of resources or support. The driver/device
265 * should reserve resources needed for the commit phase here,
266 * but should not commit the attr.
269 trans
.ph_prepare
= true;
270 err
= __switchdev_port_attr_set(dev
, attr
, &trans
);
272 /* Prepare phase failed: abort the transaction. Any
273 * resources reserved in the prepare phase are
277 if (err
!= -EOPNOTSUPP
)
278 switchdev_trans_items_destroy(&trans
);
283 /* Phase II: commit attr set. This cannot fail as a fault
284 * of driver/device. If it does, it's a bug in the driver/device
285 * because the driver said everythings was OK in phase I.
288 trans
.ph_prepare
= false;
289 err
= __switchdev_port_attr_set(dev
, attr
, &trans
);
290 WARN(err
, "%s: Commit of attribute (id=%d) failed.\n",
291 dev
->name
, attr
->id
);
292 switchdev_trans_items_warn_destroy(dev
, &trans
);
297 static void switchdev_port_attr_set_deferred(struct net_device
*dev
,
300 const struct switchdev_attr
*attr
= data
;
303 err
= switchdev_port_attr_set_now(dev
, attr
);
304 if (err
&& err
!= -EOPNOTSUPP
)
305 netdev_err(dev
, "failed (err=%d) to set attribute (id=%d)\n",
309 static int switchdev_port_attr_set_defer(struct net_device
*dev
,
310 const struct switchdev_attr
*attr
)
312 return switchdev_deferred_enqueue(dev
, attr
, sizeof(*attr
),
313 switchdev_port_attr_set_deferred
);
317 * switchdev_port_attr_set - Set port attribute
320 * @attr: attribute to set
322 * Use a 2-phase prepare-commit transaction model to ensure
323 * system is not left in a partially updated state due to
324 * failure from driver/device.
326 * rtnl_lock must be held and must not be in atomic section,
327 * in case SWITCHDEV_F_DEFER flag is not set.
329 int switchdev_port_attr_set(struct net_device
*dev
,
330 const struct switchdev_attr
*attr
)
332 if (attr
->flags
& SWITCHDEV_F_DEFER
)
333 return switchdev_port_attr_set_defer(dev
, attr
);
335 return switchdev_port_attr_set_now(dev
, attr
);
337 EXPORT_SYMBOL_GPL(switchdev_port_attr_set
);
339 static size_t switchdev_obj_size(const struct switchdev_obj
*obj
)
342 case SWITCHDEV_OBJ_ID_PORT_VLAN
:
343 return sizeof(struct switchdev_obj_port_vlan
);
344 case SWITCHDEV_OBJ_ID_IPV4_FIB
:
345 return sizeof(struct switchdev_obj_ipv4_fib
);
346 case SWITCHDEV_OBJ_ID_PORT_FDB
:
347 return sizeof(struct switchdev_obj_port_fdb
);
348 case SWITCHDEV_OBJ_ID_PORT_MDB
:
349 return sizeof(struct switchdev_obj_port_mdb
);
356 static int __switchdev_port_obj_add(struct net_device
*dev
,
357 const struct switchdev_obj
*obj
,
358 struct switchdev_trans
*trans
)
360 const struct switchdev_ops
*ops
= dev
->switchdev_ops
;
361 struct net_device
*lower_dev
;
362 struct list_head
*iter
;
363 int err
= -EOPNOTSUPP
;
365 if (ops
&& ops
->switchdev_port_obj_add
)
366 return ops
->switchdev_port_obj_add(dev
, obj
, trans
);
368 /* Switch device port(s) may be stacked under
369 * bond/team/vlan dev, so recurse down to add object on
373 netdev_for_each_lower_dev(dev
, lower_dev
, iter
) {
374 err
= __switchdev_port_obj_add(lower_dev
, obj
, trans
);
382 static int switchdev_port_obj_add_now(struct net_device
*dev
,
383 const struct switchdev_obj
*obj
)
385 struct switchdev_trans trans
;
390 switchdev_trans_init(&trans
);
392 /* Phase I: prepare for obj add. Driver/device should fail
393 * here if there are going to be issues in the commit phase,
394 * such as lack of resources or support. The driver/device
395 * should reserve resources needed for the commit phase here,
396 * but should not commit the obj.
399 trans
.ph_prepare
= true;
400 err
= __switchdev_port_obj_add(dev
, obj
, &trans
);
402 /* Prepare phase failed: abort the transaction. Any
403 * resources reserved in the prepare phase are
407 if (err
!= -EOPNOTSUPP
)
408 switchdev_trans_items_destroy(&trans
);
413 /* Phase II: commit obj add. This cannot fail as a fault
414 * of driver/device. If it does, it's a bug in the driver/device
415 * because the driver said everythings was OK in phase I.
418 trans
.ph_prepare
= false;
419 err
= __switchdev_port_obj_add(dev
, obj
, &trans
);
420 WARN(err
, "%s: Commit of object (id=%d) failed.\n", dev
->name
, obj
->id
);
421 switchdev_trans_items_warn_destroy(dev
, &trans
);
426 static void switchdev_port_obj_add_deferred(struct net_device
*dev
,
429 const struct switchdev_obj
*obj
= data
;
432 err
= switchdev_port_obj_add_now(dev
, obj
);
433 if (err
&& err
!= -EOPNOTSUPP
)
434 netdev_err(dev
, "failed (err=%d) to add object (id=%d)\n",
438 static int switchdev_port_obj_add_defer(struct net_device
*dev
,
439 const struct switchdev_obj
*obj
)
441 return switchdev_deferred_enqueue(dev
, obj
, switchdev_obj_size(obj
),
442 switchdev_port_obj_add_deferred
);
446 * switchdev_port_obj_add - Add port object
450 * @obj: object to add
452 * Use a 2-phase prepare-commit transaction model to ensure
453 * system is not left in a partially updated state due to
454 * failure from driver/device.
456 * rtnl_lock must be held and must not be in atomic section,
457 * in case SWITCHDEV_F_DEFER flag is not set.
459 int switchdev_port_obj_add(struct net_device
*dev
,
460 const struct switchdev_obj
*obj
)
462 if (obj
->flags
& SWITCHDEV_F_DEFER
)
463 return switchdev_port_obj_add_defer(dev
, obj
);
465 return switchdev_port_obj_add_now(dev
, obj
);
467 EXPORT_SYMBOL_GPL(switchdev_port_obj_add
);
469 static int switchdev_port_obj_del_now(struct net_device
*dev
,
470 const struct switchdev_obj
*obj
)
472 const struct switchdev_ops
*ops
= dev
->switchdev_ops
;
473 struct net_device
*lower_dev
;
474 struct list_head
*iter
;
475 int err
= -EOPNOTSUPP
;
477 if (ops
&& ops
->switchdev_port_obj_del
)
478 return ops
->switchdev_port_obj_del(dev
, obj
);
480 /* Switch device port(s) may be stacked under
481 * bond/team/vlan dev, so recurse down to delete object on
485 netdev_for_each_lower_dev(dev
, lower_dev
, iter
) {
486 err
= switchdev_port_obj_del_now(lower_dev
, obj
);
494 static void switchdev_port_obj_del_deferred(struct net_device
*dev
,
497 const struct switchdev_obj
*obj
= data
;
500 err
= switchdev_port_obj_del_now(dev
, obj
);
501 if (err
&& err
!= -EOPNOTSUPP
)
502 netdev_err(dev
, "failed (err=%d) to del object (id=%d)\n",
506 static int switchdev_port_obj_del_defer(struct net_device
*dev
,
507 const struct switchdev_obj
*obj
)
509 return switchdev_deferred_enqueue(dev
, obj
, switchdev_obj_size(obj
),
510 switchdev_port_obj_del_deferred
);
514 * switchdev_port_obj_del - Delete port object
518 * @obj: object to delete
520 * rtnl_lock must be held and must not be in atomic section,
521 * in case SWITCHDEV_F_DEFER flag is not set.
523 int switchdev_port_obj_del(struct net_device
*dev
,
524 const struct switchdev_obj
*obj
)
526 if (obj
->flags
& SWITCHDEV_F_DEFER
)
527 return switchdev_port_obj_del_defer(dev
, obj
);
529 return switchdev_port_obj_del_now(dev
, obj
);
531 EXPORT_SYMBOL_GPL(switchdev_port_obj_del
);
534 * switchdev_port_obj_dump - Dump port objects
538 * @obj: object to dump
539 * @cb: function to call with a filled object
541 * rtnl_lock must be held.
543 int switchdev_port_obj_dump(struct net_device
*dev
, struct switchdev_obj
*obj
,
544 switchdev_obj_dump_cb_t
*cb
)
546 const struct switchdev_ops
*ops
= dev
->switchdev_ops
;
547 struct net_device
*lower_dev
;
548 struct list_head
*iter
;
549 int err
= -EOPNOTSUPP
;
553 if (ops
&& ops
->switchdev_port_obj_dump
)
554 return ops
->switchdev_port_obj_dump(dev
, obj
, cb
);
556 /* Switch device port(s) may be stacked under
557 * bond/team/vlan dev, so recurse down to dump objects on
558 * first port at bottom of stack.
561 netdev_for_each_lower_dev(dev
, lower_dev
, iter
) {
562 err
= switchdev_port_obj_dump(lower_dev
, obj
, cb
);
568 EXPORT_SYMBOL_GPL(switchdev_port_obj_dump
);
570 static DEFINE_MUTEX(switchdev_mutex
);
571 static RAW_NOTIFIER_HEAD(switchdev_notif_chain
);
574 * register_switchdev_notifier - Register notifier
575 * @nb: notifier_block
577 * Register switch device notifier. This should be used by code
578 * which needs to monitor events happening in particular device.
579 * Return values are same as for atomic_notifier_chain_register().
581 int register_switchdev_notifier(struct notifier_block
*nb
)
585 mutex_lock(&switchdev_mutex
);
586 err
= raw_notifier_chain_register(&switchdev_notif_chain
, nb
);
587 mutex_unlock(&switchdev_mutex
);
590 EXPORT_SYMBOL_GPL(register_switchdev_notifier
);
593 * unregister_switchdev_notifier - Unregister notifier
594 * @nb: notifier_block
596 * Unregister switch device notifier.
597 * Return values are same as for atomic_notifier_chain_unregister().
599 int unregister_switchdev_notifier(struct notifier_block
*nb
)
603 mutex_lock(&switchdev_mutex
);
604 err
= raw_notifier_chain_unregister(&switchdev_notif_chain
, nb
);
605 mutex_unlock(&switchdev_mutex
);
608 EXPORT_SYMBOL_GPL(unregister_switchdev_notifier
);
611 * call_switchdev_notifiers - Call notifiers
612 * @val: value passed unmodified to notifier function
614 * @info: notifier information data
616 * Call all network notifier blocks. This should be called by driver
617 * when it needs to propagate hardware event.
618 * Return values are same as for atomic_notifier_call_chain().
620 int call_switchdev_notifiers(unsigned long val
, struct net_device
*dev
,
621 struct switchdev_notifier_info
*info
)
626 mutex_lock(&switchdev_mutex
);
627 err
= raw_notifier_call_chain(&switchdev_notif_chain
, val
, info
);
628 mutex_unlock(&switchdev_mutex
);
631 EXPORT_SYMBOL_GPL(call_switchdev_notifiers
);
633 struct switchdev_vlan_dump
{
634 struct switchdev_obj_port_vlan vlan
;
642 static int switchdev_port_vlan_dump_put(struct switchdev_vlan_dump
*dump
)
644 struct bridge_vlan_info vinfo
;
646 vinfo
.flags
= dump
->flags
;
648 if (dump
->begin
== 0 && dump
->end
== 0) {
650 } else if (dump
->begin
== dump
->end
) {
651 vinfo
.vid
= dump
->begin
;
652 if (nla_put(dump
->skb
, IFLA_BRIDGE_VLAN_INFO
,
653 sizeof(vinfo
), &vinfo
))
656 vinfo
.vid
= dump
->begin
;
657 vinfo
.flags
|= BRIDGE_VLAN_INFO_RANGE_BEGIN
;
658 if (nla_put(dump
->skb
, IFLA_BRIDGE_VLAN_INFO
,
659 sizeof(vinfo
), &vinfo
))
661 vinfo
.vid
= dump
->end
;
662 vinfo
.flags
&= ~BRIDGE_VLAN_INFO_RANGE_BEGIN
;
663 vinfo
.flags
|= BRIDGE_VLAN_INFO_RANGE_END
;
664 if (nla_put(dump
->skb
, IFLA_BRIDGE_VLAN_INFO
,
665 sizeof(vinfo
), &vinfo
))
672 static int switchdev_port_vlan_dump_cb(struct switchdev_obj
*obj
)
674 struct switchdev_obj_port_vlan
*vlan
= SWITCHDEV_OBJ_PORT_VLAN(obj
);
675 struct switchdev_vlan_dump
*dump
=
676 container_of(vlan
, struct switchdev_vlan_dump
, vlan
);
679 if (vlan
->vid_begin
> vlan
->vid_end
)
682 if (dump
->filter_mask
& RTEXT_FILTER_BRVLAN
) {
683 dump
->flags
= vlan
->flags
;
684 for (dump
->begin
= dump
->end
= vlan
->vid_begin
;
685 dump
->begin
<= vlan
->vid_end
;
686 dump
->begin
++, dump
->end
++) {
687 err
= switchdev_port_vlan_dump_put(dump
);
691 } else if (dump
->filter_mask
& RTEXT_FILTER_BRVLAN_COMPRESSED
) {
692 if (dump
->begin
> vlan
->vid_begin
&&
693 dump
->begin
>= vlan
->vid_end
) {
694 if ((dump
->begin
- 1) == vlan
->vid_end
&&
695 dump
->flags
== vlan
->flags
) {
697 dump
->begin
= vlan
->vid_begin
;
699 err
= switchdev_port_vlan_dump_put(dump
);
700 dump
->flags
= vlan
->flags
;
701 dump
->begin
= vlan
->vid_begin
;
702 dump
->end
= vlan
->vid_end
;
704 } else if (dump
->end
<= vlan
->vid_begin
&&
705 dump
->end
< vlan
->vid_end
) {
706 if ((dump
->end
+ 1) == vlan
->vid_begin
&&
707 dump
->flags
== vlan
->flags
) {
709 dump
->end
= vlan
->vid_end
;
711 err
= switchdev_port_vlan_dump_put(dump
);
712 dump
->flags
= vlan
->flags
;
713 dump
->begin
= vlan
->vid_begin
;
714 dump
->end
= vlan
->vid_end
;
724 static int switchdev_port_vlan_fill(struct sk_buff
*skb
, struct net_device
*dev
,
727 struct switchdev_vlan_dump dump
= {
728 .vlan
.obj
.orig_dev
= dev
,
729 .vlan
.obj
.id
= SWITCHDEV_OBJ_ID_PORT_VLAN
,
731 .filter_mask
= filter_mask
,
735 if ((filter_mask
& RTEXT_FILTER_BRVLAN
) ||
736 (filter_mask
& RTEXT_FILTER_BRVLAN_COMPRESSED
)) {
737 err
= switchdev_port_obj_dump(dev
, &dump
.vlan
.obj
,
738 switchdev_port_vlan_dump_cb
);
741 if (filter_mask
& RTEXT_FILTER_BRVLAN_COMPRESSED
)
743 err
= switchdev_port_vlan_dump_put(&dump
);
747 return err
== -EOPNOTSUPP
? 0 : err
;
751 * switchdev_port_bridge_getlink - Get bridge port attributes
755 * Called for SELF on rtnl_bridge_getlink to get bridge port
758 int switchdev_port_bridge_getlink(struct sk_buff
*skb
, u32 pid
, u32 seq
,
759 struct net_device
*dev
, u32 filter_mask
,
762 struct switchdev_attr attr
= {
764 .id
= SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS
,
766 u16 mode
= BRIDGE_MODE_UNDEF
;
767 u32 mask
= BR_LEARNING
| BR_LEARNING_SYNC
| BR_FLOOD
;
770 err
= switchdev_port_attr_get(dev
, &attr
);
771 if (err
&& err
!= -EOPNOTSUPP
)
774 return ndo_dflt_bridge_getlink(skb
, pid
, seq
, dev
, mode
,
775 attr
.u
.brport_flags
, mask
, nlflags
,
776 filter_mask
, switchdev_port_vlan_fill
);
778 EXPORT_SYMBOL_GPL(switchdev_port_bridge_getlink
);
780 static int switchdev_port_br_setflag(struct net_device
*dev
,
781 struct nlattr
*nlattr
,
782 unsigned long brport_flag
)
784 struct switchdev_attr attr
= {
786 .id
= SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS
,
788 u8 flag
= nla_get_u8(nlattr
);
791 err
= switchdev_port_attr_get(dev
, &attr
);
796 attr
.u
.brport_flags
|= brport_flag
;
798 attr
.u
.brport_flags
&= ~brport_flag
;
800 return switchdev_port_attr_set(dev
, &attr
);
803 static const struct nla_policy
804 switchdev_port_bridge_policy
[IFLA_BRPORT_MAX
+ 1] = {
805 [IFLA_BRPORT_STATE
] = { .type
= NLA_U8
},
806 [IFLA_BRPORT_COST
] = { .type
= NLA_U32
},
807 [IFLA_BRPORT_PRIORITY
] = { .type
= NLA_U16
},
808 [IFLA_BRPORT_MODE
] = { .type
= NLA_U8
},
809 [IFLA_BRPORT_GUARD
] = { .type
= NLA_U8
},
810 [IFLA_BRPORT_PROTECT
] = { .type
= NLA_U8
},
811 [IFLA_BRPORT_FAST_LEAVE
] = { .type
= NLA_U8
},
812 [IFLA_BRPORT_LEARNING
] = { .type
= NLA_U8
},
813 [IFLA_BRPORT_LEARNING_SYNC
] = { .type
= NLA_U8
},
814 [IFLA_BRPORT_UNICAST_FLOOD
] = { .type
= NLA_U8
},
817 static int switchdev_port_br_setlink_protinfo(struct net_device
*dev
,
818 struct nlattr
*protinfo
)
824 err
= nla_validate_nested(protinfo
, IFLA_BRPORT_MAX
,
825 switchdev_port_bridge_policy
);
829 nla_for_each_nested(attr
, protinfo
, rem
) {
830 switch (nla_type(attr
)) {
831 case IFLA_BRPORT_LEARNING
:
832 err
= switchdev_port_br_setflag(dev
, attr
,
835 case IFLA_BRPORT_LEARNING_SYNC
:
836 err
= switchdev_port_br_setflag(dev
, attr
,
839 case IFLA_BRPORT_UNICAST_FLOOD
:
840 err
= switchdev_port_br_setflag(dev
, attr
, BR_FLOOD
);
853 static int switchdev_port_br_afspec(struct net_device
*dev
,
854 struct nlattr
*afspec
,
855 int (*f
)(struct net_device
*dev
,
856 const struct switchdev_obj
*obj
))
859 struct bridge_vlan_info
*vinfo
;
860 struct switchdev_obj_port_vlan vlan
= {
862 .obj
.id
= SWITCHDEV_OBJ_ID_PORT_VLAN
,
867 nla_for_each_nested(attr
, afspec
, rem
) {
868 if (nla_type(attr
) != IFLA_BRIDGE_VLAN_INFO
)
870 if (nla_len(attr
) != sizeof(struct bridge_vlan_info
))
872 vinfo
= nla_data(attr
);
873 if (!vinfo
->vid
|| vinfo
->vid
>= VLAN_VID_MASK
)
875 vlan
.flags
= vinfo
->flags
;
876 if (vinfo
->flags
& BRIDGE_VLAN_INFO_RANGE_BEGIN
) {
879 vlan
.vid_begin
= vinfo
->vid
;
880 /* don't allow range of pvids */
881 if (vlan
.flags
& BRIDGE_VLAN_INFO_PVID
)
883 } else if (vinfo
->flags
& BRIDGE_VLAN_INFO_RANGE_END
) {
886 vlan
.vid_end
= vinfo
->vid
;
887 if (vlan
.vid_end
<= vlan
.vid_begin
)
889 err
= f(dev
, &vlan
.obj
);
896 vlan
.vid_begin
= vinfo
->vid
;
897 vlan
.vid_end
= vinfo
->vid
;
898 err
= f(dev
, &vlan
.obj
);
909 * switchdev_port_bridge_setlink - Set bridge port attributes
912 * @nlh: netlink header
913 * @flags: netlink flags
915 * Called for SELF on rtnl_bridge_setlink to set bridge port
918 int switchdev_port_bridge_setlink(struct net_device
*dev
,
919 struct nlmsghdr
*nlh
, u16 flags
)
921 struct nlattr
*protinfo
;
922 struct nlattr
*afspec
;
925 protinfo
= nlmsg_find_attr(nlh
, sizeof(struct ifinfomsg
),
928 err
= switchdev_port_br_setlink_protinfo(dev
, protinfo
);
933 afspec
= nlmsg_find_attr(nlh
, sizeof(struct ifinfomsg
),
936 err
= switchdev_port_br_afspec(dev
, afspec
,
937 switchdev_port_obj_add
);
941 EXPORT_SYMBOL_GPL(switchdev_port_bridge_setlink
);
944 * switchdev_port_bridge_dellink - Set bridge port attributes
947 * @nlh: netlink header
948 * @flags: netlink flags
950 * Called for SELF on rtnl_bridge_dellink to set bridge port
953 int switchdev_port_bridge_dellink(struct net_device
*dev
,
954 struct nlmsghdr
*nlh
, u16 flags
)
956 struct nlattr
*afspec
;
958 afspec
= nlmsg_find_attr(nlh
, sizeof(struct ifinfomsg
),
961 return switchdev_port_br_afspec(dev
, afspec
,
962 switchdev_port_obj_del
);
966 EXPORT_SYMBOL_GPL(switchdev_port_bridge_dellink
);
969 * switchdev_port_fdb_add - Add FDB (MAC/VLAN) entry to port
971 * @ndmsg: netlink hdr
972 * @nlattr: netlink attributes
974 * @addr: MAC address to add
977 * Add FDB entry to switch device.
979 int switchdev_port_fdb_add(struct ndmsg
*ndm
, struct nlattr
*tb
[],
980 struct net_device
*dev
, const unsigned char *addr
,
981 u16 vid
, u16 nlm_flags
)
983 struct switchdev_obj_port_fdb fdb
= {
985 .obj
.id
= SWITCHDEV_OBJ_ID_PORT_FDB
,
989 ether_addr_copy(fdb
.addr
, addr
);
990 return switchdev_port_obj_add(dev
, &fdb
.obj
);
992 EXPORT_SYMBOL_GPL(switchdev_port_fdb_add
);
995 * switchdev_port_fdb_del - Delete FDB (MAC/VLAN) entry from port
997 * @ndmsg: netlink hdr
998 * @nlattr: netlink attributes
1000 * @addr: MAC address to delete
1001 * @vid: VLAN to delete
1003 * Delete FDB entry from switch device.
1005 int switchdev_port_fdb_del(struct ndmsg
*ndm
, struct nlattr
*tb
[],
1006 struct net_device
*dev
, const unsigned char *addr
,
1009 struct switchdev_obj_port_fdb fdb
= {
1010 .obj
.orig_dev
= dev
,
1011 .obj
.id
= SWITCHDEV_OBJ_ID_PORT_FDB
,
1015 ether_addr_copy(fdb
.addr
, addr
);
1016 return switchdev_port_obj_del(dev
, &fdb
.obj
);
1018 EXPORT_SYMBOL_GPL(switchdev_port_fdb_del
);
1020 struct switchdev_fdb_dump
{
1021 struct switchdev_obj_port_fdb fdb
;
1022 struct net_device
*dev
;
1023 struct sk_buff
*skb
;
1024 struct netlink_callback
*cb
;
1028 static int switchdev_port_fdb_dump_cb(struct switchdev_obj
*obj
)
1030 struct switchdev_obj_port_fdb
*fdb
= SWITCHDEV_OBJ_PORT_FDB(obj
);
1031 struct switchdev_fdb_dump
*dump
=
1032 container_of(fdb
, struct switchdev_fdb_dump
, fdb
);
1033 u32 portid
= NETLINK_CB(dump
->cb
->skb
).portid
;
1034 u32 seq
= dump
->cb
->nlh
->nlmsg_seq
;
1035 struct nlmsghdr
*nlh
;
1038 if (dump
->idx
< dump
->cb
->args
[0])
1041 nlh
= nlmsg_put(dump
->skb
, portid
, seq
, RTM_NEWNEIGH
,
1042 sizeof(*ndm
), NLM_F_MULTI
);
1046 ndm
= nlmsg_data(nlh
);
1047 ndm
->ndm_family
= AF_BRIDGE
;
1050 ndm
->ndm_flags
= NTF_SELF
;
1052 ndm
->ndm_ifindex
= dump
->dev
->ifindex
;
1053 ndm
->ndm_state
= fdb
->ndm_state
;
1055 if (nla_put(dump
->skb
, NDA_LLADDR
, ETH_ALEN
, fdb
->addr
))
1056 goto nla_put_failure
;
1058 if (fdb
->vid
&& nla_put_u16(dump
->skb
, NDA_VLAN
, fdb
->vid
))
1059 goto nla_put_failure
;
1061 nlmsg_end(dump
->skb
, nlh
);
1068 nlmsg_cancel(dump
->skb
, nlh
);
1073 * switchdev_port_fdb_dump - Dump port FDB (MAC/VLAN) entries
1076 * @cb: netlink callback
1078 * @filter_dev: filter device
1081 * Delete FDB entry from switch device.
1083 int switchdev_port_fdb_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
,
1084 struct net_device
*dev
,
1085 struct net_device
*filter_dev
, int idx
)
1087 struct switchdev_fdb_dump dump
= {
1088 .fdb
.obj
.orig_dev
= dev
,
1089 .fdb
.obj
.id
= SWITCHDEV_OBJ_ID_PORT_FDB
,
1096 switchdev_port_obj_dump(dev
, &dump
.fdb
.obj
, switchdev_port_fdb_dump_cb
);
1099 EXPORT_SYMBOL_GPL(switchdev_port_fdb_dump
);
1101 static struct net_device
*switchdev_get_lowest_dev(struct net_device
*dev
)
1103 const struct switchdev_ops
*ops
= dev
->switchdev_ops
;
1104 struct net_device
*lower_dev
;
1105 struct net_device
*port_dev
;
1106 struct list_head
*iter
;
1108 /* Recusively search down until we find a sw port dev.
1109 * (A sw port dev supports switchdev_port_attr_get).
1112 if (ops
&& ops
->switchdev_port_attr_get
)
1115 netdev_for_each_lower_dev(dev
, lower_dev
, iter
) {
1116 port_dev
= switchdev_get_lowest_dev(lower_dev
);
1124 static struct net_device
*switchdev_get_dev_by_nhs(struct fib_info
*fi
)
1126 struct switchdev_attr attr
= {
1127 .id
= SWITCHDEV_ATTR_ID_PORT_PARENT_ID
,
1129 struct switchdev_attr prev_attr
;
1130 struct net_device
*dev
= NULL
;
1135 /* For this route, all nexthop devs must be on the same switch. */
1137 for (nhsel
= 0; nhsel
< fi
->fib_nhs
; nhsel
++) {
1138 const struct fib_nh
*nh
= &fi
->fib_nh
[nhsel
];
1143 dev
= switchdev_get_lowest_dev(nh
->nh_dev
);
1147 attr
.orig_dev
= dev
;
1148 if (switchdev_port_attr_get(dev
, &attr
))
1152 !netdev_phys_item_id_same(&prev_attr
.u
.ppid
, &attr
.u
.ppid
))
1162 * switchdev_fib_ipv4_add - Add/modify switch IPv4 route entry
1164 * @dst: route's IPv4 destination address
1165 * @dst_len: destination address length (prefix length)
1166 * @fi: route FIB info structure
1169 * @nlflags: netlink flags passed in (NLM_F_*)
1170 * @tb_id: route table ID
1172 * Add/modify switch IPv4 route entry.
1174 int switchdev_fib_ipv4_add(u32 dst
, int dst_len
, struct fib_info
*fi
,
1175 u8 tos
, u8 type
, u32 nlflags
, u32 tb_id
)
1177 struct switchdev_obj_ipv4_fib ipv4_fib
= {
1178 .obj
.id
= SWITCHDEV_OBJ_ID_IPV4_FIB
,
1186 struct net_device
*dev
;
1189 memcpy(&ipv4_fib
.fi
, fi
, sizeof(ipv4_fib
.fi
));
1191 /* Don't offload route if using custom ip rules or if
1192 * IPv4 FIB offloading has been disabled completely.
1195 #ifdef CONFIG_IP_MULTIPLE_TABLES
1196 if (fi
->fib_net
->ipv4
.fib_has_custom_rules
)
1200 if (fi
->fib_net
->ipv4
.fib_offload_disabled
)
1203 dev
= switchdev_get_dev_by_nhs(fi
);
1207 ipv4_fib
.obj
.orig_dev
= dev
;
1208 err
= switchdev_port_obj_add(dev
, &ipv4_fib
.obj
);
1210 fi
->fib_flags
|= RTNH_F_OFFLOAD
;
1212 return err
== -EOPNOTSUPP
? 0 : err
;
1214 EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_add
);
1217 * switchdev_fib_ipv4_del - Delete IPv4 route entry from switch
1219 * @dst: route's IPv4 destination address
1220 * @dst_len: destination address length (prefix length)
1221 * @fi: route FIB info structure
1224 * @tb_id: route table ID
1226 * Delete IPv4 route entry from switch device.
1228 int switchdev_fib_ipv4_del(u32 dst
, int dst_len
, struct fib_info
*fi
,
1229 u8 tos
, u8 type
, u32 tb_id
)
1231 struct switchdev_obj_ipv4_fib ipv4_fib
= {
1232 .obj
.id
= SWITCHDEV_OBJ_ID_IPV4_FIB
,
1240 struct net_device
*dev
;
1243 memcpy(&ipv4_fib
.fi
, fi
, sizeof(ipv4_fib
.fi
));
1245 if (!(fi
->fib_flags
& RTNH_F_OFFLOAD
))
1248 dev
= switchdev_get_dev_by_nhs(fi
);
1252 ipv4_fib
.obj
.orig_dev
= dev
;
1253 err
= switchdev_port_obj_del(dev
, &ipv4_fib
.obj
);
1255 fi
->fib_flags
&= ~RTNH_F_OFFLOAD
;
1257 return err
== -EOPNOTSUPP
? 0 : err
;
1259 EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_del
);
1262 * switchdev_fib_ipv4_abort - Abort an IPv4 FIB operation
1264 * @fi: route FIB info structure
1266 void switchdev_fib_ipv4_abort(struct fib_info
*fi
)
1268 /* There was a problem installing this route to the offload
1269 * device. For now, until we come up with more refined
1270 * policy handling, abruptly end IPv4 fib offloading for
1271 * for entire net by flushing offload device(s) of all
1272 * IPv4 routes, and mark IPv4 fib offloading broken from
1273 * this point forward.
1276 fib_flush_external(fi
->fib_net
);
1277 fi
->fib_net
->ipv4
.fib_offload_disabled
= true;
1279 EXPORT_SYMBOL_GPL(switchdev_fib_ipv4_abort
);
1281 static bool switchdev_port_same_parent_id(struct net_device
*a
,
1282 struct net_device
*b
)
1284 struct switchdev_attr a_attr
= {
1286 .id
= SWITCHDEV_ATTR_ID_PORT_PARENT_ID
,
1287 .flags
= SWITCHDEV_F_NO_RECURSE
,
1289 struct switchdev_attr b_attr
= {
1291 .id
= SWITCHDEV_ATTR_ID_PORT_PARENT_ID
,
1292 .flags
= SWITCHDEV_F_NO_RECURSE
,
1295 if (switchdev_port_attr_get(a
, &a_attr
) ||
1296 switchdev_port_attr_get(b
, &b_attr
))
1299 return netdev_phys_item_id_same(&a_attr
.u
.ppid
, &b_attr
.u
.ppid
);
1302 static u32
switchdev_port_fwd_mark_get(struct net_device
*dev
,
1303 struct net_device
*group_dev
)
1305 struct net_device
*lower_dev
;
1306 struct list_head
*iter
;
1308 netdev_for_each_lower_dev(group_dev
, lower_dev
, iter
) {
1309 if (lower_dev
== dev
)
1311 if (switchdev_port_same_parent_id(dev
, lower_dev
))
1312 return lower_dev
->offload_fwd_mark
;
1313 return switchdev_port_fwd_mark_get(dev
, lower_dev
);
1316 return dev
->ifindex
;
1319 static void switchdev_port_fwd_mark_reset(struct net_device
*group_dev
,
1320 u32 old_mark
, u32
*reset_mark
)
1322 struct net_device
*lower_dev
;
1323 struct list_head
*iter
;
1325 netdev_for_each_lower_dev(group_dev
, lower_dev
, iter
) {
1326 if (lower_dev
->offload_fwd_mark
== old_mark
) {
1328 *reset_mark
= lower_dev
->ifindex
;
1329 lower_dev
->offload_fwd_mark
= *reset_mark
;
1331 switchdev_port_fwd_mark_reset(lower_dev
, old_mark
, reset_mark
);
1336 * switchdev_port_fwd_mark_set - Set port offload forwarding mark
1339 * @group_dev: containing device
1340 * @joining: true if dev is joining group; false if leaving group
1342 * An ungrouped port's offload mark is just its ifindex. A grouped
1343 * port's (member of a bridge, for example) offload mark is the ifindex
1344 * of one of the ports in the group with the same parent (switch) ID.
1345 * Ports on the same device in the same group will have the same mark.
1350 * sw1p1 ifindex=2 mark=2
1351 * sw1p2 ifindex=3 mark=2
1352 * sw2p1 ifindex=4 mark=5
1353 * sw2p2 ifindex=5 mark=5
1355 * If sw2p2 leaves the bridge, we'll have:
1358 * sw1p1 ifindex=2 mark=2
1359 * sw1p2 ifindex=3 mark=2
1360 * sw2p1 ifindex=4 mark=4
1361 * sw2p2 ifindex=5 mark=5
1363 void switchdev_port_fwd_mark_set(struct net_device
*dev
,
1364 struct net_device
*group_dev
,
1367 u32 mark
= dev
->ifindex
;
1373 mark
= switchdev_port_fwd_mark_get(dev
, group_dev
);
1374 else if (dev
->offload_fwd_mark
== mark
)
1375 /* Ohoh, this port was the mark reference port,
1376 * but it's leaving the group, so reset the
1377 * mark for the remaining ports in the group.
1379 switchdev_port_fwd_mark_reset(group_dev
, mark
,
1383 dev
->offload_fwd_mark
= mark
;
1385 EXPORT_SYMBOL_GPL(switchdev_port_fwd_mark_set
);