1 #include <linux/kernel.h>
2 #include <linux/netdevice.h>
3 #include <linux/rtnetlink.h>
4 #include <linux/slab.h>
5 #include <net/switchdev.h>
7 #include "br_private.h"
8 #include "br_private_tunnel.h"
10 static inline int br_vlan_cmp(struct rhashtable_compare_arg
*arg
,
13 const struct net_bridge_vlan
*vle
= ptr
;
14 u16 vid
= *(u16
*)arg
->key
;
16 return vle
->vid
!= vid
;
19 static const struct rhashtable_params br_vlan_rht_params
= {
20 .head_offset
= offsetof(struct net_bridge_vlan
, vnode
),
21 .key_offset
= offsetof(struct net_bridge_vlan
, vid
),
22 .key_len
= sizeof(u16
),
25 .max_size
= VLAN_N_VID
,
26 .obj_cmpfn
= br_vlan_cmp
,
27 .automatic_shrinking
= true,
30 static struct net_bridge_vlan
*br_vlan_lookup(struct rhashtable
*tbl
, u16 vid
)
32 return rhashtable_lookup_fast(tbl
, &vid
, br_vlan_rht_params
);
35 static bool __vlan_add_pvid(struct net_bridge_vlan_group
*vg
, u16 vid
)
46 static bool __vlan_delete_pvid(struct net_bridge_vlan_group
*vg
, u16 vid
)
57 /* return true if anything changed, false otherwise */
58 static bool __vlan_add_flags(struct net_bridge_vlan
*v
, u16 flags
)
60 struct net_bridge_vlan_group
*vg
;
61 u16 old_flags
= v
->flags
;
64 if (br_vlan_is_master(v
))
65 vg
= br_vlan_group(v
->br
);
67 vg
= nbp_vlan_group(v
->port
);
69 if (flags
& BRIDGE_VLAN_INFO_PVID
)
70 ret
= __vlan_add_pvid(vg
, v
->vid
);
72 ret
= __vlan_delete_pvid(vg
, v
->vid
);
74 if (flags
& BRIDGE_VLAN_INFO_UNTAGGED
)
75 v
->flags
|= BRIDGE_VLAN_INFO_UNTAGGED
;
77 v
->flags
&= ~BRIDGE_VLAN_INFO_UNTAGGED
;
79 return ret
|| !!(old_flags
^ v
->flags
);
82 static int __vlan_vid_add(struct net_device
*dev
, struct net_bridge
*br
,
83 u16 vid
, u16 flags
, struct netlink_ext_ack
*extack
)
87 /* Try switchdev op first. In case it is not supported, fallback to
90 err
= br_switchdev_port_vlan_add(dev
, vid
, flags
, extack
);
91 if (err
== -EOPNOTSUPP
)
92 return vlan_vid_add(dev
, br
->vlan_proto
, vid
);
96 static void __vlan_add_list(struct net_bridge_vlan
*v
)
98 struct net_bridge_vlan_group
*vg
;
99 struct list_head
*headp
, *hpos
;
100 struct net_bridge_vlan
*vent
;
102 if (br_vlan_is_master(v
))
103 vg
= br_vlan_group(v
->br
);
105 vg
= nbp_vlan_group(v
->port
);
107 headp
= &vg
->vlan_list
;
108 list_for_each_prev(hpos
, headp
) {
109 vent
= list_entry(hpos
, struct net_bridge_vlan
, vlist
);
110 if (v
->vid
< vent
->vid
)
115 list_add_rcu(&v
->vlist
, hpos
);
118 static void __vlan_del_list(struct net_bridge_vlan
*v
)
120 list_del_rcu(&v
->vlist
);
123 static int __vlan_vid_del(struct net_device
*dev
, struct net_bridge
*br
,
128 /* Try switchdev op first. In case it is not supported, fallback to
131 err
= br_switchdev_port_vlan_del(dev
, vid
);
132 if (err
== -EOPNOTSUPP
) {
133 vlan_vid_del(dev
, br
->vlan_proto
, vid
);
139 /* Returns a master vlan, if it didn't exist it gets created. In all cases a
140 * a reference is taken to the master vlan before returning.
142 static struct net_bridge_vlan
*
143 br_vlan_get_master(struct net_bridge
*br
, u16 vid
,
144 struct netlink_ext_ack
*extack
)
146 struct net_bridge_vlan_group
*vg
;
147 struct net_bridge_vlan
*masterv
;
149 vg
= br_vlan_group(br
);
150 masterv
= br_vlan_find(vg
, vid
);
154 /* missing global ctx, create it now */
155 if (br_vlan_add(br
, vid
, 0, &changed
, extack
))
157 masterv
= br_vlan_find(vg
, vid
);
158 if (WARN_ON(!masterv
))
160 refcount_set(&masterv
->refcnt
, 1);
163 refcount_inc(&masterv
->refcnt
);
168 static void br_master_vlan_rcu_free(struct rcu_head
*rcu
)
170 struct net_bridge_vlan
*v
;
172 v
= container_of(rcu
, struct net_bridge_vlan
, rcu
);
173 WARN_ON(!br_vlan_is_master(v
));
174 free_percpu(v
->stats
);
179 static void br_vlan_put_master(struct net_bridge_vlan
*masterv
)
181 struct net_bridge_vlan_group
*vg
;
183 if (!br_vlan_is_master(masterv
))
186 vg
= br_vlan_group(masterv
->br
);
187 if (refcount_dec_and_test(&masterv
->refcnt
)) {
188 rhashtable_remove_fast(&vg
->vlan_hash
,
189 &masterv
->vnode
, br_vlan_rht_params
);
190 __vlan_del_list(masterv
);
191 call_rcu(&masterv
->rcu
, br_master_vlan_rcu_free
);
195 static void nbp_vlan_rcu_free(struct rcu_head
*rcu
)
197 struct net_bridge_vlan
*v
;
199 v
= container_of(rcu
, struct net_bridge_vlan
, rcu
);
200 WARN_ON(br_vlan_is_master(v
));
201 /* if we had per-port stats configured then free them here */
202 if (v
->priv_flags
& BR_VLFLAG_PER_PORT_STATS
)
203 free_percpu(v
->stats
);
208 /* This is the shared VLAN add function which works for both ports and bridge
209 * devices. There are four possible calls to this function in terms of the
211 * 1. vlan is being added on a port (no master flags, global entry exists)
212 * 2. vlan is being added on a bridge (both master and brentry flags)
213 * 3. vlan is being added on a port, but a global entry didn't exist which
214 * is being created right now (master flag set, brentry flag unset), the
215 * global entry is used for global per-vlan features, but not for filtering
216 * 4. same as 3 but with both master and brentry flags set so the entry
217 * will be used for filtering in both the port and the bridge
219 static int __vlan_add(struct net_bridge_vlan
*v
, u16 flags
,
220 struct netlink_ext_ack
*extack
)
222 struct net_bridge_vlan
*masterv
= NULL
;
223 struct net_bridge_port
*p
= NULL
;
224 struct net_bridge_vlan_group
*vg
;
225 struct net_device
*dev
;
226 struct net_bridge
*br
;
229 if (br_vlan_is_master(v
)) {
232 vg
= br_vlan_group(br
);
237 vg
= nbp_vlan_group(p
);
241 /* Add VLAN to the device filter if it is supported.
242 * This ensures tagged traffic enters the bridge when
243 * promiscuous mode is disabled by br_manage_promisc().
245 err
= __vlan_vid_add(dev
, br
, v
->vid
, flags
, extack
);
249 /* need to work on the master vlan too */
250 if (flags
& BRIDGE_VLAN_INFO_MASTER
) {
253 err
= br_vlan_add(br
, v
->vid
,
254 flags
| BRIDGE_VLAN_INFO_BRENTRY
,
260 masterv
= br_vlan_get_master(br
, v
->vid
, extack
);
264 if (br_opt_get(br
, BROPT_VLAN_STATS_PER_PORT
)) {
265 v
->stats
= netdev_alloc_pcpu_stats(struct br_vlan_stats
);
270 v
->priv_flags
|= BR_VLFLAG_PER_PORT_STATS
;
272 v
->stats
= masterv
->stats
;
275 err
= br_switchdev_port_vlan_add(dev
, v
->vid
, flags
, extack
);
276 if (err
&& err
!= -EOPNOTSUPP
)
280 /* Add the dev mac and count the vlan only if it's usable */
281 if (br_vlan_should_use(v
)) {
282 err
= br_fdb_insert(br
, p
, dev
->dev_addr
, v
->vid
);
284 br_err(br
, "failed insert local address into bridge forwarding table\n");
290 err
= rhashtable_lookup_insert_fast(&vg
->vlan_hash
, &v
->vnode
,
296 __vlan_add_flags(v
, flags
);
301 if (br_vlan_should_use(v
)) {
302 br_fdb_find_delete_local(br
, p
, dev
->dev_addr
, v
->vid
);
308 __vlan_vid_del(dev
, br
, v
->vid
);
310 if (v
->stats
&& masterv
->stats
!= v
->stats
)
311 free_percpu(v
->stats
);
314 br_vlan_put_master(masterv
);
318 br_switchdev_port_vlan_del(dev
, v
->vid
);
324 static int __vlan_del(struct net_bridge_vlan
*v
)
326 struct net_bridge_vlan
*masterv
= v
;
327 struct net_bridge_vlan_group
*vg
;
328 struct net_bridge_port
*p
= NULL
;
331 if (br_vlan_is_master(v
)) {
332 vg
= br_vlan_group(v
->br
);
335 vg
= nbp_vlan_group(v
->port
);
339 __vlan_delete_pvid(vg
, v
->vid
);
341 err
= __vlan_vid_del(p
->dev
, p
->br
, v
->vid
);
345 err
= br_switchdev_port_vlan_del(v
->br
->dev
, v
->vid
);
346 if (err
&& err
!= -EOPNOTSUPP
)
351 if (br_vlan_should_use(v
)) {
352 v
->flags
&= ~BRIDGE_VLAN_INFO_BRENTRY
;
357 vlan_tunnel_info_del(vg
, v
);
358 rhashtable_remove_fast(&vg
->vlan_hash
, &v
->vnode
,
361 call_rcu(&v
->rcu
, nbp_vlan_rcu_free
);
364 br_vlan_put_master(masterv
);
369 static void __vlan_group_free(struct net_bridge_vlan_group
*vg
)
371 WARN_ON(!list_empty(&vg
->vlan_list
));
372 rhashtable_destroy(&vg
->vlan_hash
);
373 vlan_tunnel_deinit(vg
);
377 static void __vlan_flush(struct net_bridge_vlan_group
*vg
)
379 struct net_bridge_vlan
*vlan
, *tmp
;
381 __vlan_delete_pvid(vg
, vg
->pvid
);
382 list_for_each_entry_safe(vlan
, tmp
, &vg
->vlan_list
, vlist
)
386 struct sk_buff
*br_handle_vlan(struct net_bridge
*br
,
387 const struct net_bridge_port
*p
,
388 struct net_bridge_vlan_group
*vg
,
391 struct br_vlan_stats
*stats
;
392 struct net_bridge_vlan
*v
;
395 /* If this packet was not filtered at input, let it pass */
396 if (!BR_INPUT_SKB_CB(skb
)->vlan_filtered
)
399 /* At this point, we know that the frame was filtered and contains
400 * a valid vlan id. If the vlan id has untagged flag set,
401 * send untagged; otherwise, send tagged.
403 br_vlan_get_tag(skb
, &vid
);
404 v
= br_vlan_find(vg
, vid
);
405 /* Vlan entry must be configured at this point. The
406 * only exception is the bridge is set in promisc mode and the
407 * packet is destined for the bridge device. In this case
408 * pass the packet as is.
410 if (!v
|| !br_vlan_should_use(v
)) {
411 if ((br
->dev
->flags
& IFF_PROMISC
) && skb
->dev
== br
->dev
) {
418 if (br_opt_get(br
, BROPT_VLAN_STATS_ENABLED
)) {
419 stats
= this_cpu_ptr(v
->stats
);
420 u64_stats_update_begin(&stats
->syncp
);
421 stats
->tx_bytes
+= skb
->len
;
423 u64_stats_update_end(&stats
->syncp
);
426 if (v
->flags
& BRIDGE_VLAN_INFO_UNTAGGED
)
427 __vlan_hwaccel_clear_tag(skb
);
429 if (p
&& (p
->flags
& BR_VLAN_TUNNEL
) &&
430 br_handle_egress_vlan_tunnel(skb
, v
)) {
438 /* Called under RCU */
439 static bool __allowed_ingress(const struct net_bridge
*br
,
440 struct net_bridge_vlan_group
*vg
,
441 struct sk_buff
*skb
, u16
*vid
)
443 struct br_vlan_stats
*stats
;
444 struct net_bridge_vlan
*v
;
447 BR_INPUT_SKB_CB(skb
)->vlan_filtered
= true;
448 /* If vlan tx offload is disabled on bridge device and frame was
449 * sent from vlan device on the bridge device, it does not have
450 * HW accelerated vlan tag.
452 if (unlikely(!skb_vlan_tag_present(skb
) &&
453 skb
->protocol
== br
->vlan_proto
)) {
454 skb
= skb_vlan_untag(skb
);
459 if (!br_vlan_get_tag(skb
, vid
)) {
461 if (skb
->vlan_proto
!= br
->vlan_proto
) {
462 /* Protocol-mismatch, empty out vlan_tci for new tag */
463 skb_push(skb
, ETH_HLEN
);
464 skb
= vlan_insert_tag_set_proto(skb
, skb
->vlan_proto
,
465 skb_vlan_tag_get(skb
));
469 skb_pull(skb
, ETH_HLEN
);
470 skb_reset_mac_len(skb
);
482 u16 pvid
= br_get_pvid(vg
);
484 /* Frame had a tag with VID 0 or did not have a tag.
485 * See if pvid is set on this port. That tells us which
486 * vlan untagged or priority-tagged traffic belongs to.
491 /* PVID is set on this port. Any untagged or priority-tagged
492 * ingress frame is considered to belong to this vlan.
496 /* Untagged Frame. */
497 __vlan_hwaccel_put_tag(skb
, br
->vlan_proto
, pvid
);
499 /* Priority-tagged Frame.
500 * At this point, we know that skb->vlan_tci VID
502 * We update only VID field and preserve PCP field.
504 skb
->vlan_tci
|= pvid
;
506 /* if stats are disabled we can avoid the lookup */
507 if (!br_opt_get(br
, BROPT_VLAN_STATS_ENABLED
))
510 v
= br_vlan_find(vg
, *vid
);
511 if (!v
|| !br_vlan_should_use(v
))
514 if (br_opt_get(br
, BROPT_VLAN_STATS_ENABLED
)) {
515 stats
= this_cpu_ptr(v
->stats
);
516 u64_stats_update_begin(&stats
->syncp
);
517 stats
->rx_bytes
+= skb
->len
;
519 u64_stats_update_end(&stats
->syncp
);
529 bool br_allowed_ingress(const struct net_bridge
*br
,
530 struct net_bridge_vlan_group
*vg
, struct sk_buff
*skb
,
533 /* If VLAN filtering is disabled on the bridge, all packets are
536 if (!br_opt_get(br
, BROPT_VLAN_ENABLED
)) {
537 BR_INPUT_SKB_CB(skb
)->vlan_filtered
= false;
541 return __allowed_ingress(br
, vg
, skb
, vid
);
544 /* Called under RCU. */
545 bool br_allowed_egress(struct net_bridge_vlan_group
*vg
,
546 const struct sk_buff
*skb
)
548 const struct net_bridge_vlan
*v
;
551 /* If this packet was not filtered at input, let it pass */
552 if (!BR_INPUT_SKB_CB(skb
)->vlan_filtered
)
555 br_vlan_get_tag(skb
, &vid
);
556 v
= br_vlan_find(vg
, vid
);
557 if (v
&& br_vlan_should_use(v
))
563 /* Called under RCU */
564 bool br_should_learn(struct net_bridge_port
*p
, struct sk_buff
*skb
, u16
*vid
)
566 struct net_bridge_vlan_group
*vg
;
567 struct net_bridge
*br
= p
->br
;
569 /* If filtering was disabled at input, let it pass. */
570 if (!br_opt_get(br
, BROPT_VLAN_ENABLED
))
573 vg
= nbp_vlan_group_rcu(p
);
574 if (!vg
|| !vg
->num_vlans
)
577 if (!br_vlan_get_tag(skb
, vid
) && skb
->vlan_proto
!= br
->vlan_proto
)
581 *vid
= br_get_pvid(vg
);
588 if (br_vlan_find(vg
, *vid
))
594 static int br_vlan_add_existing(struct net_bridge
*br
,
595 struct net_bridge_vlan_group
*vg
,
596 struct net_bridge_vlan
*vlan
,
597 u16 flags
, bool *changed
,
598 struct netlink_ext_ack
*extack
)
602 err
= br_switchdev_port_vlan_add(br
->dev
, vlan
->vid
, flags
, extack
);
603 if (err
&& err
!= -EOPNOTSUPP
)
606 if (!br_vlan_is_brentry(vlan
)) {
607 /* Trying to change flags of non-existent bridge vlan */
608 if (!(flags
& BRIDGE_VLAN_INFO_BRENTRY
)) {
612 /* It was only kept for port vlans, now make it real */
613 err
= br_fdb_insert(br
, NULL
, br
->dev
->dev_addr
,
616 br_err(br
, "failed to insert local address into bridge forwarding table\n");
620 refcount_inc(&vlan
->refcnt
);
621 vlan
->flags
|= BRIDGE_VLAN_INFO_BRENTRY
;
626 if (__vlan_add_flags(vlan
, flags
))
633 br_switchdev_port_vlan_del(br
->dev
, vlan
->vid
);
637 /* Must be protected by RTNL.
638 * Must be called with vid in range from 1 to 4094 inclusive.
639 * changed must be true only if the vlan was created or updated
641 int br_vlan_add(struct net_bridge
*br
, u16 vid
, u16 flags
, bool *changed
,
642 struct netlink_ext_ack
*extack
)
644 struct net_bridge_vlan_group
*vg
;
645 struct net_bridge_vlan
*vlan
;
651 vg
= br_vlan_group(br
);
652 vlan
= br_vlan_find(vg
, vid
);
654 return br_vlan_add_existing(br
, vg
, vlan
, flags
, changed
,
657 vlan
= kzalloc(sizeof(*vlan
), GFP_KERNEL
);
661 vlan
->stats
= netdev_alloc_pcpu_stats(struct br_vlan_stats
);
667 vlan
->flags
= flags
| BRIDGE_VLAN_INFO_MASTER
;
668 vlan
->flags
&= ~BRIDGE_VLAN_INFO_PVID
;
670 if (flags
& BRIDGE_VLAN_INFO_BRENTRY
)
671 refcount_set(&vlan
->refcnt
, 1);
672 ret
= __vlan_add(vlan
, flags
, extack
);
674 free_percpu(vlan
->stats
);
683 /* Must be protected by RTNL.
684 * Must be called with vid in range from 1 to 4094 inclusive.
686 int br_vlan_delete(struct net_bridge
*br
, u16 vid
)
688 struct net_bridge_vlan_group
*vg
;
689 struct net_bridge_vlan
*v
;
693 vg
= br_vlan_group(br
);
694 v
= br_vlan_find(vg
, vid
);
695 if (!v
|| !br_vlan_is_brentry(v
))
698 br_fdb_find_delete_local(br
, NULL
, br
->dev
->dev_addr
, vid
);
699 br_fdb_delete_by_port(br
, NULL
, vid
, 0);
701 vlan_tunnel_info_del(vg
, v
);
703 return __vlan_del(v
);
706 void br_vlan_flush(struct net_bridge
*br
)
708 struct net_bridge_vlan_group
*vg
;
712 vg
= br_vlan_group(br
);
714 RCU_INIT_POINTER(br
->vlgrp
, NULL
);
716 __vlan_group_free(vg
);
719 struct net_bridge_vlan
*br_vlan_find(struct net_bridge_vlan_group
*vg
, u16 vid
)
724 return br_vlan_lookup(&vg
->vlan_hash
, vid
);
727 /* Must be protected by RTNL. */
728 static void recalculate_group_addr(struct net_bridge
*br
)
730 if (br_opt_get(br
, BROPT_GROUP_ADDR_SET
))
733 spin_lock_bh(&br
->lock
);
734 if (!br_opt_get(br
, BROPT_VLAN_ENABLED
) ||
735 br
->vlan_proto
== htons(ETH_P_8021Q
)) {
736 /* Bridge Group Address */
737 br
->group_addr
[5] = 0x00;
738 } else { /* vlan_enabled && ETH_P_8021AD */
739 /* Provider Bridge Group Address */
740 br
->group_addr
[5] = 0x08;
742 spin_unlock_bh(&br
->lock
);
745 /* Must be protected by RTNL. */
746 void br_recalculate_fwd_mask(struct net_bridge
*br
)
748 if (!br_opt_get(br
, BROPT_VLAN_ENABLED
) ||
749 br
->vlan_proto
== htons(ETH_P_8021Q
))
750 br
->group_fwd_mask_required
= BR_GROUPFWD_DEFAULT
;
751 else /* vlan_enabled && ETH_P_8021AD */
752 br
->group_fwd_mask_required
= BR_GROUPFWD_8021AD
&
753 ~(1u << br
->group_addr
[5]);
756 int __br_vlan_filter_toggle(struct net_bridge
*br
, unsigned long val
)
758 struct switchdev_attr attr
= {
760 .id
= SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING
,
761 .flags
= SWITCHDEV_F_SKIP_EOPNOTSUPP
,
762 .u
.vlan_filtering
= val
,
766 if (br_opt_get(br
, BROPT_VLAN_ENABLED
) == !!val
)
769 err
= switchdev_port_attr_set(br
->dev
, &attr
);
770 if (err
&& err
!= -EOPNOTSUPP
)
773 br_opt_toggle(br
, BROPT_VLAN_ENABLED
, !!val
);
774 br_manage_promisc(br
);
775 recalculate_group_addr(br
);
776 br_recalculate_fwd_mask(br
);
781 int br_vlan_filter_toggle(struct net_bridge
*br
, unsigned long val
)
783 return __br_vlan_filter_toggle(br
, val
);
786 bool br_vlan_enabled(const struct net_device
*dev
)
788 struct net_bridge
*br
= netdev_priv(dev
);
790 return br_opt_get(br
, BROPT_VLAN_ENABLED
);
792 EXPORT_SYMBOL_GPL(br_vlan_enabled
);
794 int __br_vlan_set_proto(struct net_bridge
*br
, __be16 proto
)
797 struct net_bridge_port
*p
;
798 struct net_bridge_vlan
*vlan
;
799 struct net_bridge_vlan_group
*vg
;
802 if (br
->vlan_proto
== proto
)
805 /* Add VLANs for the new proto to the device filter. */
806 list_for_each_entry(p
, &br
->port_list
, list
) {
807 vg
= nbp_vlan_group(p
);
808 list_for_each_entry(vlan
, &vg
->vlan_list
, vlist
) {
809 err
= vlan_vid_add(p
->dev
, proto
, vlan
->vid
);
815 oldproto
= br
->vlan_proto
;
816 br
->vlan_proto
= proto
;
818 recalculate_group_addr(br
);
819 br_recalculate_fwd_mask(br
);
821 /* Delete VLANs for the old proto from the device filter. */
822 list_for_each_entry(p
, &br
->port_list
, list
) {
823 vg
= nbp_vlan_group(p
);
824 list_for_each_entry(vlan
, &vg
->vlan_list
, vlist
)
825 vlan_vid_del(p
->dev
, oldproto
, vlan
->vid
);
831 list_for_each_entry_continue_reverse(vlan
, &vg
->vlan_list
, vlist
)
832 vlan_vid_del(p
->dev
, proto
, vlan
->vid
);
834 list_for_each_entry_continue_reverse(p
, &br
->port_list
, list
) {
835 vg
= nbp_vlan_group(p
);
836 list_for_each_entry(vlan
, &vg
->vlan_list
, vlist
)
837 vlan_vid_del(p
->dev
, proto
, vlan
->vid
);
843 int br_vlan_set_proto(struct net_bridge
*br
, unsigned long val
)
845 if (val
!= ETH_P_8021Q
&& val
!= ETH_P_8021AD
)
846 return -EPROTONOSUPPORT
;
848 return __br_vlan_set_proto(br
, htons(val
));
851 int br_vlan_set_stats(struct net_bridge
*br
, unsigned long val
)
856 br_opt_toggle(br
, BROPT_VLAN_STATS_ENABLED
, !!val
);
865 int br_vlan_set_stats_per_port(struct net_bridge
*br
, unsigned long val
)
867 struct net_bridge_port
*p
;
869 /* allow to change the option if there are no port vlans configured */
870 list_for_each_entry(p
, &br
->port_list
, list
) {
871 struct net_bridge_vlan_group
*vg
= nbp_vlan_group(p
);
880 br_opt_toggle(br
, BROPT_VLAN_STATS_PER_PORT
, !!val
);
889 static bool vlan_default_pvid(struct net_bridge_vlan_group
*vg
, u16 vid
)
891 struct net_bridge_vlan
*v
;
896 v
= br_vlan_lookup(&vg
->vlan_hash
, vid
);
897 if (v
&& br_vlan_should_use(v
) &&
898 (v
->flags
& BRIDGE_VLAN_INFO_UNTAGGED
))
904 static void br_vlan_disable_default_pvid(struct net_bridge
*br
)
906 struct net_bridge_port
*p
;
907 u16 pvid
= br
->default_pvid
;
909 /* Disable default_pvid on all ports where it is still
912 if (vlan_default_pvid(br_vlan_group(br
), pvid
))
913 br_vlan_delete(br
, pvid
);
915 list_for_each_entry(p
, &br
->port_list
, list
) {
916 if (vlan_default_pvid(nbp_vlan_group(p
), pvid
))
917 nbp_vlan_delete(p
, pvid
);
920 br
->default_pvid
= 0;
923 int __br_vlan_set_default_pvid(struct net_bridge
*br
, u16 pvid
,
924 struct netlink_ext_ack
*extack
)
926 const struct net_bridge_vlan
*pvent
;
927 struct net_bridge_vlan_group
*vg
;
928 struct net_bridge_port
*p
;
929 unsigned long *changed
;
935 br_vlan_disable_default_pvid(br
);
939 changed
= bitmap_zalloc(BR_MAX_PORTS
, GFP_KERNEL
);
943 old_pvid
= br
->default_pvid
;
945 /* Update default_pvid config only if we do not conflict with
946 * user configuration.
948 vg
= br_vlan_group(br
);
949 pvent
= br_vlan_find(vg
, pvid
);
950 if ((!old_pvid
|| vlan_default_pvid(vg
, old_pvid
)) &&
951 (!pvent
|| !br_vlan_should_use(pvent
))) {
952 err
= br_vlan_add(br
, pvid
,
953 BRIDGE_VLAN_INFO_PVID
|
954 BRIDGE_VLAN_INFO_UNTAGGED
|
955 BRIDGE_VLAN_INFO_BRENTRY
,
959 br_vlan_delete(br
, old_pvid
);
963 list_for_each_entry(p
, &br
->port_list
, list
) {
964 /* Update default_pvid config only if we do not conflict with
965 * user configuration.
967 vg
= nbp_vlan_group(p
);
969 !vlan_default_pvid(vg
, old_pvid
)) ||
970 br_vlan_find(vg
, pvid
))
973 err
= nbp_vlan_add(p
, pvid
,
974 BRIDGE_VLAN_INFO_PVID
|
975 BRIDGE_VLAN_INFO_UNTAGGED
,
979 nbp_vlan_delete(p
, old_pvid
);
980 set_bit(p
->port_no
, changed
);
983 br
->default_pvid
= pvid
;
986 bitmap_free(changed
);
990 list_for_each_entry_continue_reverse(p
, &br
->port_list
, list
) {
991 if (!test_bit(p
->port_no
, changed
))
995 nbp_vlan_add(p
, old_pvid
,
996 BRIDGE_VLAN_INFO_PVID
|
997 BRIDGE_VLAN_INFO_UNTAGGED
,
999 nbp_vlan_delete(p
, pvid
);
1002 if (test_bit(0, changed
)) {
1004 br_vlan_add(br
, old_pvid
,
1005 BRIDGE_VLAN_INFO_PVID
|
1006 BRIDGE_VLAN_INFO_UNTAGGED
|
1007 BRIDGE_VLAN_INFO_BRENTRY
,
1009 br_vlan_delete(br
, pvid
);
1014 int br_vlan_set_default_pvid(struct net_bridge
*br
, unsigned long val
)
1019 if (val
>= VLAN_VID_MASK
)
1022 if (pvid
== br
->default_pvid
)
1025 /* Only allow default pvid change when filtering is disabled */
1026 if (br_opt_get(br
, BROPT_VLAN_ENABLED
)) {
1027 pr_info_once("Please disable vlan filtering to change default_pvid\n");
1031 err
= __br_vlan_set_default_pvid(br
, pvid
, NULL
);
1036 int br_vlan_init(struct net_bridge
*br
)
1038 struct net_bridge_vlan_group
*vg
;
1042 vg
= kzalloc(sizeof(*vg
), GFP_KERNEL
);
1045 ret
= rhashtable_init(&vg
->vlan_hash
, &br_vlan_rht_params
);
1048 ret
= vlan_tunnel_init(vg
);
1050 goto err_tunnel_init
;
1051 INIT_LIST_HEAD(&vg
->vlan_list
);
1052 br
->vlan_proto
= htons(ETH_P_8021Q
);
1053 br
->default_pvid
= 1;
1054 rcu_assign_pointer(br
->vlgrp
, vg
);
1055 ret
= br_vlan_add(br
, 1,
1056 BRIDGE_VLAN_INFO_PVID
| BRIDGE_VLAN_INFO_UNTAGGED
|
1057 BRIDGE_VLAN_INFO_BRENTRY
, &changed
, NULL
);
1065 vlan_tunnel_deinit(vg
);
1067 rhashtable_destroy(&vg
->vlan_hash
);
1074 int nbp_vlan_init(struct net_bridge_port
*p
, struct netlink_ext_ack
*extack
)
1076 struct switchdev_attr attr
= {
1077 .orig_dev
= p
->br
->dev
,
1078 .id
= SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING
,
1079 .flags
= SWITCHDEV_F_SKIP_EOPNOTSUPP
,
1080 .u
.vlan_filtering
= br_opt_get(p
->br
, BROPT_VLAN_ENABLED
),
1082 struct net_bridge_vlan_group
*vg
;
1085 vg
= kzalloc(sizeof(struct net_bridge_vlan_group
), GFP_KERNEL
);
1089 ret
= switchdev_port_attr_set(p
->dev
, &attr
);
1090 if (ret
&& ret
!= -EOPNOTSUPP
)
1091 goto err_vlan_enabled
;
1093 ret
= rhashtable_init(&vg
->vlan_hash
, &br_vlan_rht_params
);
1096 ret
= vlan_tunnel_init(vg
);
1098 goto err_tunnel_init
;
1099 INIT_LIST_HEAD(&vg
->vlan_list
);
1100 rcu_assign_pointer(p
->vlgrp
, vg
);
1101 if (p
->br
->default_pvid
) {
1104 ret
= nbp_vlan_add(p
, p
->br
->default_pvid
,
1105 BRIDGE_VLAN_INFO_PVID
|
1106 BRIDGE_VLAN_INFO_UNTAGGED
,
1115 RCU_INIT_POINTER(p
->vlgrp
, NULL
);
1117 vlan_tunnel_deinit(vg
);
1119 rhashtable_destroy(&vg
->vlan_hash
);
1127 /* Must be protected by RTNL.
1128 * Must be called with vid in range from 1 to 4094 inclusive.
1129 * changed must be true only if the vlan was created or updated
1131 int nbp_vlan_add(struct net_bridge_port
*port
, u16 vid
, u16 flags
,
1132 bool *changed
, struct netlink_ext_ack
*extack
)
1134 struct net_bridge_vlan
*vlan
;
1140 vlan
= br_vlan_find(nbp_vlan_group(port
), vid
);
1142 /* Pass the flags to the hardware bridge */
1143 ret
= br_switchdev_port_vlan_add(port
->dev
, vid
, flags
, extack
);
1144 if (ret
&& ret
!= -EOPNOTSUPP
)
1146 *changed
= __vlan_add_flags(vlan
, flags
);
1151 vlan
= kzalloc(sizeof(*vlan
), GFP_KERNEL
);
1157 ret
= __vlan_add(vlan
, flags
, extack
);
1166 /* Must be protected by RTNL.
1167 * Must be called with vid in range from 1 to 4094 inclusive.
1169 int nbp_vlan_delete(struct net_bridge_port
*port
, u16 vid
)
1171 struct net_bridge_vlan
*v
;
1175 v
= br_vlan_find(nbp_vlan_group(port
), vid
);
1178 br_fdb_find_delete_local(port
->br
, port
, port
->dev
->dev_addr
, vid
);
1179 br_fdb_delete_by_port(port
->br
, port
, vid
, 0);
1181 return __vlan_del(v
);
1184 void nbp_vlan_flush(struct net_bridge_port
*port
)
1186 struct net_bridge_vlan_group
*vg
;
1190 vg
= nbp_vlan_group(port
);
1192 RCU_INIT_POINTER(port
->vlgrp
, NULL
);
1194 __vlan_group_free(vg
);
1197 void br_vlan_get_stats(const struct net_bridge_vlan
*v
,
1198 struct br_vlan_stats
*stats
)
1202 memset(stats
, 0, sizeof(*stats
));
1203 for_each_possible_cpu(i
) {
1204 u64 rxpackets
, rxbytes
, txpackets
, txbytes
;
1205 struct br_vlan_stats
*cpu_stats
;
1208 cpu_stats
= per_cpu_ptr(v
->stats
, i
);
1210 start
= u64_stats_fetch_begin_irq(&cpu_stats
->syncp
);
1211 rxpackets
= cpu_stats
->rx_packets
;
1212 rxbytes
= cpu_stats
->rx_bytes
;
1213 txbytes
= cpu_stats
->tx_bytes
;
1214 txpackets
= cpu_stats
->tx_packets
;
1215 } while (u64_stats_fetch_retry_irq(&cpu_stats
->syncp
, start
));
1217 stats
->rx_packets
+= rxpackets
;
1218 stats
->rx_bytes
+= rxbytes
;
1219 stats
->tx_bytes
+= txbytes
;
1220 stats
->tx_packets
+= txpackets
;
1224 int br_vlan_get_pvid(const struct net_device
*dev
, u16
*p_pvid
)
1226 struct net_bridge_vlan_group
*vg
;
1227 struct net_bridge_port
*p
;
1230 p
= br_port_get_check_rtnl(dev
);
1232 vg
= nbp_vlan_group(p
);
1233 else if (netif_is_bridge_master(dev
))
1234 vg
= br_vlan_group(netdev_priv(dev
));
1238 *p_pvid
= br_get_pvid(vg
);
1241 EXPORT_SYMBOL_GPL(br_vlan_get_pvid
);
1243 int br_vlan_get_info(const struct net_device
*dev
, u16 vid
,
1244 struct bridge_vlan_info
*p_vinfo
)
1246 struct net_bridge_vlan_group
*vg
;
1247 struct net_bridge_vlan
*v
;
1248 struct net_bridge_port
*p
;
1251 p
= br_port_get_check_rtnl(dev
);
1253 vg
= nbp_vlan_group(p
);
1254 else if (netif_is_bridge_master(dev
))
1255 vg
= br_vlan_group(netdev_priv(dev
));
1259 v
= br_vlan_find(vg
, vid
);
1264 p_vinfo
->flags
= v
->flags
;
1267 EXPORT_SYMBOL_GPL(br_vlan_get_info
);