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
,
85 struct switchdev_obj_port_vlan v
= {
87 .obj
.id
= SWITCHDEV_OBJ_ID_PORT_VLAN
,
94 /* Try switchdev op first. In case it is not supported, fallback to
97 err
= switchdev_port_obj_add(dev
, &v
.obj
);
98 if (err
== -EOPNOTSUPP
)
99 return vlan_vid_add(dev
, br
->vlan_proto
, vid
);
103 static void __vlan_add_list(struct net_bridge_vlan
*v
)
105 struct net_bridge_vlan_group
*vg
;
106 struct list_head
*headp
, *hpos
;
107 struct net_bridge_vlan
*vent
;
109 if (br_vlan_is_master(v
))
110 vg
= br_vlan_group(v
->br
);
112 vg
= nbp_vlan_group(v
->port
);
114 headp
= &vg
->vlan_list
;
115 list_for_each_prev(hpos
, headp
) {
116 vent
= list_entry(hpos
, struct net_bridge_vlan
, vlist
);
117 if (v
->vid
< vent
->vid
)
122 list_add_rcu(&v
->vlist
, hpos
);
125 static void __vlan_del_list(struct net_bridge_vlan
*v
)
127 list_del_rcu(&v
->vlist
);
130 static int __vlan_vid_del(struct net_device
*dev
, struct net_bridge
*br
,
133 struct switchdev_obj_port_vlan v
= {
135 .obj
.id
= SWITCHDEV_OBJ_ID_PORT_VLAN
,
141 /* Try switchdev op first. In case it is not supported, fallback to
144 err
= switchdev_port_obj_del(dev
, &v
.obj
);
145 if (err
== -EOPNOTSUPP
) {
146 vlan_vid_del(dev
, br
->vlan_proto
, vid
);
152 /* Returns a master vlan, if it didn't exist it gets created. In all cases a
153 * a reference is taken to the master vlan before returning.
155 static struct net_bridge_vlan
*br_vlan_get_master(struct net_bridge
*br
, u16 vid
)
157 struct net_bridge_vlan_group
*vg
;
158 struct net_bridge_vlan
*masterv
;
160 vg
= br_vlan_group(br
);
161 masterv
= br_vlan_find(vg
, vid
);
165 /* missing global ctx, create it now */
166 if (br_vlan_add(br
, vid
, 0, &changed
))
168 masterv
= br_vlan_find(vg
, vid
);
169 if (WARN_ON(!masterv
))
171 refcount_set(&masterv
->refcnt
, 1);
174 refcount_inc(&masterv
->refcnt
);
179 static void br_master_vlan_rcu_free(struct rcu_head
*rcu
)
181 struct net_bridge_vlan
*v
;
183 v
= container_of(rcu
, struct net_bridge_vlan
, rcu
);
184 WARN_ON(!br_vlan_is_master(v
));
185 free_percpu(v
->stats
);
190 static void br_vlan_put_master(struct net_bridge_vlan
*masterv
)
192 struct net_bridge_vlan_group
*vg
;
194 if (!br_vlan_is_master(masterv
))
197 vg
= br_vlan_group(masterv
->br
);
198 if (refcount_dec_and_test(&masterv
->refcnt
)) {
199 rhashtable_remove_fast(&vg
->vlan_hash
,
200 &masterv
->vnode
, br_vlan_rht_params
);
201 __vlan_del_list(masterv
);
202 call_rcu(&masterv
->rcu
, br_master_vlan_rcu_free
);
206 /* This is the shared VLAN add function which works for both ports and bridge
207 * devices. There are four possible calls to this function in terms of the
209 * 1. vlan is being added on a port (no master flags, global entry exists)
210 * 2. vlan is being added on a bridge (both master and brentry flags)
211 * 3. vlan is being added on a port, but a global entry didn't exist which
212 * is being created right now (master flag set, brentry flag unset), the
213 * global entry is used for global per-vlan features, but not for filtering
214 * 4. same as 3 but with both master and brentry flags set so the entry
215 * will be used for filtering in both the port and the bridge
217 static int __vlan_add(struct net_bridge_vlan
*v
, u16 flags
)
219 struct net_bridge_vlan
*masterv
= NULL
;
220 struct net_bridge_port
*p
= NULL
;
221 struct net_bridge_vlan_group
*vg
;
222 struct net_device
*dev
;
223 struct net_bridge
*br
;
226 if (br_vlan_is_master(v
)) {
229 vg
= br_vlan_group(br
);
234 vg
= nbp_vlan_group(p
);
238 /* Add VLAN to the device filter if it is supported.
239 * This ensures tagged traffic enters the bridge when
240 * promiscuous mode is disabled by br_manage_promisc().
242 err
= __vlan_vid_add(dev
, br
, v
->vid
, flags
);
246 /* need to work on the master vlan too */
247 if (flags
& BRIDGE_VLAN_INFO_MASTER
) {
250 err
= br_vlan_add(br
, v
->vid
,
251 flags
| BRIDGE_VLAN_INFO_BRENTRY
,
257 masterv
= br_vlan_get_master(br
, v
->vid
);
261 v
->stats
= masterv
->stats
;
264 /* Add the dev mac and count the vlan only if it's usable */
265 if (br_vlan_should_use(v
)) {
266 err
= br_fdb_insert(br
, p
, dev
->dev_addr
, v
->vid
);
268 br_err(br
, "failed insert local address into bridge forwarding table\n");
274 err
= rhashtable_lookup_insert_fast(&vg
->vlan_hash
, &v
->vnode
,
280 __vlan_add_flags(v
, flags
);
285 if (br_vlan_should_use(v
)) {
286 br_fdb_find_delete_local(br
, p
, dev
->dev_addr
, v
->vid
);
292 __vlan_vid_del(dev
, br
, v
->vid
);
294 br_vlan_put_master(masterv
);
302 static int __vlan_del(struct net_bridge_vlan
*v
)
304 struct net_bridge_vlan
*masterv
= v
;
305 struct net_bridge_vlan_group
*vg
;
306 struct net_bridge_port
*p
= NULL
;
309 if (br_vlan_is_master(v
)) {
310 vg
= br_vlan_group(v
->br
);
313 vg
= nbp_vlan_group(v
->port
);
317 __vlan_delete_pvid(vg
, v
->vid
);
319 err
= __vlan_vid_del(p
->dev
, p
->br
, v
->vid
);
324 if (br_vlan_should_use(v
)) {
325 v
->flags
&= ~BRIDGE_VLAN_INFO_BRENTRY
;
330 vlan_tunnel_info_del(vg
, v
);
331 rhashtable_remove_fast(&vg
->vlan_hash
, &v
->vnode
,
337 br_vlan_put_master(masterv
);
342 static void __vlan_group_free(struct net_bridge_vlan_group
*vg
)
344 WARN_ON(!list_empty(&vg
->vlan_list
));
345 rhashtable_destroy(&vg
->vlan_hash
);
346 vlan_tunnel_deinit(vg
);
350 static void __vlan_flush(struct net_bridge_vlan_group
*vg
)
352 struct net_bridge_vlan
*vlan
, *tmp
;
354 __vlan_delete_pvid(vg
, vg
->pvid
);
355 list_for_each_entry_safe(vlan
, tmp
, &vg
->vlan_list
, vlist
)
359 struct sk_buff
*br_handle_vlan(struct net_bridge
*br
,
360 const struct net_bridge_port
*p
,
361 struct net_bridge_vlan_group
*vg
,
364 struct br_vlan_stats
*stats
;
365 struct net_bridge_vlan
*v
;
368 /* If this packet was not filtered at input, let it pass */
369 if (!BR_INPUT_SKB_CB(skb
)->vlan_filtered
)
372 /* At this point, we know that the frame was filtered and contains
373 * a valid vlan id. If the vlan id has untagged flag set,
374 * send untagged; otherwise, send tagged.
376 br_vlan_get_tag(skb
, &vid
);
377 v
= br_vlan_find(vg
, vid
);
378 /* Vlan entry must be configured at this point. The
379 * only exception is the bridge is set in promisc mode and the
380 * packet is destined for the bridge device. In this case
381 * pass the packet as is.
383 if (!v
|| !br_vlan_should_use(v
)) {
384 if ((br
->dev
->flags
& IFF_PROMISC
) && skb
->dev
== br
->dev
) {
391 if (br_opt_get(br
, BROPT_VLAN_STATS_ENABLED
)) {
392 stats
= this_cpu_ptr(v
->stats
);
393 u64_stats_update_begin(&stats
->syncp
);
394 stats
->tx_bytes
+= skb
->len
;
396 u64_stats_update_end(&stats
->syncp
);
399 if (v
->flags
& BRIDGE_VLAN_INFO_UNTAGGED
)
402 if (p
&& (p
->flags
& BR_VLAN_TUNNEL
) &&
403 br_handle_egress_vlan_tunnel(skb
, v
)) {
411 /* Called under RCU */
412 static bool __allowed_ingress(const struct net_bridge
*br
,
413 struct net_bridge_vlan_group
*vg
,
414 struct sk_buff
*skb
, u16
*vid
)
416 struct br_vlan_stats
*stats
;
417 struct net_bridge_vlan
*v
;
420 BR_INPUT_SKB_CB(skb
)->vlan_filtered
= true;
421 /* If vlan tx offload is disabled on bridge device and frame was
422 * sent from vlan device on the bridge device, it does not have
423 * HW accelerated vlan tag.
425 if (unlikely(!skb_vlan_tag_present(skb
) &&
426 skb
->protocol
== br
->vlan_proto
)) {
427 skb
= skb_vlan_untag(skb
);
432 if (!br_vlan_get_tag(skb
, vid
)) {
434 if (skb
->vlan_proto
!= br
->vlan_proto
) {
435 /* Protocol-mismatch, empty out vlan_tci for new tag */
436 skb_push(skb
, ETH_HLEN
);
437 skb
= vlan_insert_tag_set_proto(skb
, skb
->vlan_proto
,
438 skb_vlan_tag_get(skb
));
442 skb_pull(skb
, ETH_HLEN
);
443 skb_reset_mac_len(skb
);
455 u16 pvid
= br_get_pvid(vg
);
457 /* Frame had a tag with VID 0 or did not have a tag.
458 * See if pvid is set on this port. That tells us which
459 * vlan untagged or priority-tagged traffic belongs to.
464 /* PVID is set on this port. Any untagged or priority-tagged
465 * ingress frame is considered to belong to this vlan.
469 /* Untagged Frame. */
470 __vlan_hwaccel_put_tag(skb
, br
->vlan_proto
, pvid
);
472 /* Priority-tagged Frame.
473 * At this point, We know that skb->vlan_tci had
474 * VLAN_TAG_PRESENT bit and its VID field was 0x000.
475 * We update only VID field and preserve PCP field.
477 skb
->vlan_tci
|= pvid
;
479 /* if stats are disabled we can avoid the lookup */
480 if (!br_opt_get(br
, BROPT_VLAN_STATS_ENABLED
))
483 v
= br_vlan_find(vg
, *vid
);
484 if (!v
|| !br_vlan_should_use(v
))
487 if (br_opt_get(br
, BROPT_VLAN_STATS_ENABLED
)) {
488 stats
= this_cpu_ptr(v
->stats
);
489 u64_stats_update_begin(&stats
->syncp
);
490 stats
->rx_bytes
+= skb
->len
;
492 u64_stats_update_end(&stats
->syncp
);
502 bool br_allowed_ingress(const struct net_bridge
*br
,
503 struct net_bridge_vlan_group
*vg
, struct sk_buff
*skb
,
506 /* If VLAN filtering is disabled on the bridge, all packets are
509 if (!br_opt_get(br
, BROPT_VLAN_ENABLED
)) {
510 BR_INPUT_SKB_CB(skb
)->vlan_filtered
= false;
514 return __allowed_ingress(br
, vg
, skb
, vid
);
517 /* Called under RCU. */
518 bool br_allowed_egress(struct net_bridge_vlan_group
*vg
,
519 const struct sk_buff
*skb
)
521 const struct net_bridge_vlan
*v
;
524 /* If this packet was not filtered at input, let it pass */
525 if (!BR_INPUT_SKB_CB(skb
)->vlan_filtered
)
528 br_vlan_get_tag(skb
, &vid
);
529 v
= br_vlan_find(vg
, vid
);
530 if (v
&& br_vlan_should_use(v
))
536 /* Called under RCU */
537 bool br_should_learn(struct net_bridge_port
*p
, struct sk_buff
*skb
, u16
*vid
)
539 struct net_bridge_vlan_group
*vg
;
540 struct net_bridge
*br
= p
->br
;
542 /* If filtering was disabled at input, let it pass. */
543 if (!br_opt_get(br
, BROPT_VLAN_ENABLED
))
546 vg
= nbp_vlan_group_rcu(p
);
547 if (!vg
|| !vg
->num_vlans
)
550 if (!br_vlan_get_tag(skb
, vid
) && skb
->vlan_proto
!= br
->vlan_proto
)
554 *vid
= br_get_pvid(vg
);
561 if (br_vlan_find(vg
, *vid
))
567 /* Must be protected by RTNL.
568 * Must be called with vid in range from 1 to 4094 inclusive.
569 * changed must be true only if the vlan was created or updated
571 int br_vlan_add(struct net_bridge
*br
, u16 vid
, u16 flags
, bool *changed
)
573 struct net_bridge_vlan_group
*vg
;
574 struct net_bridge_vlan
*vlan
;
580 vg
= br_vlan_group(br
);
581 vlan
= br_vlan_find(vg
, vid
);
583 if (!br_vlan_is_brentry(vlan
)) {
584 /* Trying to change flags of non-existent bridge vlan */
585 if (!(flags
& BRIDGE_VLAN_INFO_BRENTRY
))
587 /* It was only kept for port vlans, now make it real */
588 ret
= br_fdb_insert(br
, NULL
, br
->dev
->dev_addr
,
591 br_err(br
, "failed insert local address into bridge forwarding table\n");
594 refcount_inc(&vlan
->refcnt
);
595 vlan
->flags
|= BRIDGE_VLAN_INFO_BRENTRY
;
599 if (__vlan_add_flags(vlan
, flags
))
605 vlan
= kzalloc(sizeof(*vlan
), GFP_KERNEL
);
609 vlan
->stats
= netdev_alloc_pcpu_stats(struct br_vlan_stats
);
615 vlan
->flags
= flags
| BRIDGE_VLAN_INFO_MASTER
;
616 vlan
->flags
&= ~BRIDGE_VLAN_INFO_PVID
;
618 if (flags
& BRIDGE_VLAN_INFO_BRENTRY
)
619 refcount_set(&vlan
->refcnt
, 1);
620 ret
= __vlan_add(vlan
, flags
);
622 free_percpu(vlan
->stats
);
631 /* Must be protected by RTNL.
632 * Must be called with vid in range from 1 to 4094 inclusive.
634 int br_vlan_delete(struct net_bridge
*br
, u16 vid
)
636 struct net_bridge_vlan_group
*vg
;
637 struct net_bridge_vlan
*v
;
641 vg
= br_vlan_group(br
);
642 v
= br_vlan_find(vg
, vid
);
643 if (!v
|| !br_vlan_is_brentry(v
))
646 br_fdb_find_delete_local(br
, NULL
, br
->dev
->dev_addr
, vid
);
647 br_fdb_delete_by_port(br
, NULL
, vid
, 0);
649 vlan_tunnel_info_del(vg
, v
);
651 return __vlan_del(v
);
654 void br_vlan_flush(struct net_bridge
*br
)
656 struct net_bridge_vlan_group
*vg
;
660 /* delete auto-added default pvid local fdb before flushing vlans
661 * otherwise it will be leaked on bridge device init failure
663 br_fdb_delete_by_port(br
, NULL
, 0, 1);
665 vg
= br_vlan_group(br
);
667 RCU_INIT_POINTER(br
->vlgrp
, NULL
);
669 __vlan_group_free(vg
);
672 struct net_bridge_vlan
*br_vlan_find(struct net_bridge_vlan_group
*vg
, u16 vid
)
677 return br_vlan_lookup(&vg
->vlan_hash
, vid
);
680 /* Must be protected by RTNL. */
681 static void recalculate_group_addr(struct net_bridge
*br
)
683 if (br
->group_addr_set
)
686 spin_lock_bh(&br
->lock
);
687 if (!br_opt_get(br
, BROPT_VLAN_ENABLED
) ||
688 br
->vlan_proto
== htons(ETH_P_8021Q
)) {
689 /* Bridge Group Address */
690 br
->group_addr
[5] = 0x00;
691 } else { /* vlan_enabled && ETH_P_8021AD */
692 /* Provider Bridge Group Address */
693 br
->group_addr
[5] = 0x08;
695 spin_unlock_bh(&br
->lock
);
698 /* Must be protected by RTNL. */
699 void br_recalculate_fwd_mask(struct net_bridge
*br
)
701 if (!br_opt_get(br
, BROPT_VLAN_ENABLED
) ||
702 br
->vlan_proto
== htons(ETH_P_8021Q
))
703 br
->group_fwd_mask_required
= BR_GROUPFWD_DEFAULT
;
704 else /* vlan_enabled && ETH_P_8021AD */
705 br
->group_fwd_mask_required
= BR_GROUPFWD_8021AD
&
706 ~(1u << br
->group_addr
[5]);
709 int __br_vlan_filter_toggle(struct net_bridge
*br
, unsigned long val
)
711 struct switchdev_attr attr
= {
713 .id
= SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING
,
714 .flags
= SWITCHDEV_F_SKIP_EOPNOTSUPP
,
715 .u
.vlan_filtering
= val
,
719 if (br_opt_get(br
, BROPT_VLAN_ENABLED
) == !!val
)
722 err
= switchdev_port_attr_set(br
->dev
, &attr
);
723 if (err
&& err
!= -EOPNOTSUPP
)
726 br_opt_toggle(br
, BROPT_VLAN_ENABLED
, !!val
);
727 br_manage_promisc(br
);
728 recalculate_group_addr(br
);
729 br_recalculate_fwd_mask(br
);
734 int br_vlan_filter_toggle(struct net_bridge
*br
, unsigned long val
)
736 return __br_vlan_filter_toggle(br
, val
);
739 bool br_vlan_enabled(const struct net_device
*dev
)
741 struct net_bridge
*br
= netdev_priv(dev
);
743 return br_opt_get(br
, BROPT_VLAN_ENABLED
);
745 EXPORT_SYMBOL_GPL(br_vlan_enabled
);
747 int __br_vlan_set_proto(struct net_bridge
*br
, __be16 proto
)
750 struct net_bridge_port
*p
;
751 struct net_bridge_vlan
*vlan
;
752 struct net_bridge_vlan_group
*vg
;
755 if (br
->vlan_proto
== proto
)
758 /* Add VLANs for the new proto to the device filter. */
759 list_for_each_entry(p
, &br
->port_list
, list
) {
760 vg
= nbp_vlan_group(p
);
761 list_for_each_entry(vlan
, &vg
->vlan_list
, vlist
) {
762 err
= vlan_vid_add(p
->dev
, proto
, vlan
->vid
);
768 oldproto
= br
->vlan_proto
;
769 br
->vlan_proto
= proto
;
771 recalculate_group_addr(br
);
772 br_recalculate_fwd_mask(br
);
774 /* Delete VLANs for the old proto from the device filter. */
775 list_for_each_entry(p
, &br
->port_list
, list
) {
776 vg
= nbp_vlan_group(p
);
777 list_for_each_entry(vlan
, &vg
->vlan_list
, vlist
)
778 vlan_vid_del(p
->dev
, oldproto
, vlan
->vid
);
784 list_for_each_entry_continue_reverse(vlan
, &vg
->vlan_list
, vlist
)
785 vlan_vid_del(p
->dev
, proto
, vlan
->vid
);
787 list_for_each_entry_continue_reverse(p
, &br
->port_list
, list
) {
788 vg
= nbp_vlan_group(p
);
789 list_for_each_entry(vlan
, &vg
->vlan_list
, vlist
)
790 vlan_vid_del(p
->dev
, proto
, vlan
->vid
);
796 int br_vlan_set_proto(struct net_bridge
*br
, unsigned long val
)
798 if (val
!= ETH_P_8021Q
&& val
!= ETH_P_8021AD
)
799 return -EPROTONOSUPPORT
;
801 return __br_vlan_set_proto(br
, htons(val
));
804 int br_vlan_set_stats(struct net_bridge
*br
, unsigned long val
)
809 br_opt_toggle(br
, BROPT_VLAN_STATS_ENABLED
, !!val
);
818 static bool vlan_default_pvid(struct net_bridge_vlan_group
*vg
, u16 vid
)
820 struct net_bridge_vlan
*v
;
825 v
= br_vlan_lookup(&vg
->vlan_hash
, vid
);
826 if (v
&& br_vlan_should_use(v
) &&
827 (v
->flags
& BRIDGE_VLAN_INFO_UNTAGGED
))
833 static void br_vlan_disable_default_pvid(struct net_bridge
*br
)
835 struct net_bridge_port
*p
;
836 u16 pvid
= br
->default_pvid
;
838 /* Disable default_pvid on all ports where it is still
841 if (vlan_default_pvid(br_vlan_group(br
), pvid
))
842 br_vlan_delete(br
, pvid
);
844 list_for_each_entry(p
, &br
->port_list
, list
) {
845 if (vlan_default_pvid(nbp_vlan_group(p
), pvid
))
846 nbp_vlan_delete(p
, pvid
);
849 br
->default_pvid
= 0;
852 int __br_vlan_set_default_pvid(struct net_bridge
*br
, u16 pvid
)
854 const struct net_bridge_vlan
*pvent
;
855 struct net_bridge_vlan_group
*vg
;
856 struct net_bridge_port
*p
;
857 unsigned long *changed
;
863 br_vlan_disable_default_pvid(br
);
867 changed
= kcalloc(BITS_TO_LONGS(BR_MAX_PORTS
), sizeof(unsigned long),
872 old_pvid
= br
->default_pvid
;
874 /* Update default_pvid config only if we do not conflict with
875 * user configuration.
877 vg
= br_vlan_group(br
);
878 pvent
= br_vlan_find(vg
, pvid
);
879 if ((!old_pvid
|| vlan_default_pvid(vg
, old_pvid
)) &&
880 (!pvent
|| !br_vlan_should_use(pvent
))) {
881 err
= br_vlan_add(br
, pvid
,
882 BRIDGE_VLAN_INFO_PVID
|
883 BRIDGE_VLAN_INFO_UNTAGGED
|
884 BRIDGE_VLAN_INFO_BRENTRY
,
888 br_vlan_delete(br
, old_pvid
);
892 list_for_each_entry(p
, &br
->port_list
, list
) {
893 /* Update default_pvid config only if we do not conflict with
894 * user configuration.
896 vg
= nbp_vlan_group(p
);
898 !vlan_default_pvid(vg
, old_pvid
)) ||
899 br_vlan_find(vg
, pvid
))
902 err
= nbp_vlan_add(p
, pvid
,
903 BRIDGE_VLAN_INFO_PVID
|
904 BRIDGE_VLAN_INFO_UNTAGGED
,
908 nbp_vlan_delete(p
, old_pvid
);
909 set_bit(p
->port_no
, changed
);
912 br
->default_pvid
= pvid
;
919 list_for_each_entry_continue_reverse(p
, &br
->port_list
, list
) {
920 if (!test_bit(p
->port_no
, changed
))
924 nbp_vlan_add(p
, old_pvid
,
925 BRIDGE_VLAN_INFO_PVID
|
926 BRIDGE_VLAN_INFO_UNTAGGED
,
928 nbp_vlan_delete(p
, pvid
);
931 if (test_bit(0, changed
)) {
933 br_vlan_add(br
, old_pvid
,
934 BRIDGE_VLAN_INFO_PVID
|
935 BRIDGE_VLAN_INFO_UNTAGGED
|
936 BRIDGE_VLAN_INFO_BRENTRY
,
938 br_vlan_delete(br
, pvid
);
943 int br_vlan_set_default_pvid(struct net_bridge
*br
, unsigned long val
)
948 if (val
>= VLAN_VID_MASK
)
951 if (pvid
== br
->default_pvid
)
954 /* Only allow default pvid change when filtering is disabled */
955 if (br_opt_get(br
, BROPT_VLAN_ENABLED
)) {
956 pr_info_once("Please disable vlan filtering to change default_pvid\n");
960 err
= __br_vlan_set_default_pvid(br
, pvid
);
965 int br_vlan_init(struct net_bridge
*br
)
967 struct net_bridge_vlan_group
*vg
;
971 vg
= kzalloc(sizeof(*vg
), GFP_KERNEL
);
974 ret
= rhashtable_init(&vg
->vlan_hash
, &br_vlan_rht_params
);
977 ret
= vlan_tunnel_init(vg
);
979 goto err_tunnel_init
;
980 INIT_LIST_HEAD(&vg
->vlan_list
);
981 br
->vlan_proto
= htons(ETH_P_8021Q
);
982 br
->default_pvid
= 1;
983 rcu_assign_pointer(br
->vlgrp
, vg
);
984 ret
= br_vlan_add(br
, 1,
985 BRIDGE_VLAN_INFO_PVID
| BRIDGE_VLAN_INFO_UNTAGGED
|
986 BRIDGE_VLAN_INFO_BRENTRY
, &changed
);
994 vlan_tunnel_deinit(vg
);
996 rhashtable_destroy(&vg
->vlan_hash
);
1003 int nbp_vlan_init(struct net_bridge_port
*p
)
1005 struct switchdev_attr attr
= {
1006 .orig_dev
= p
->br
->dev
,
1007 .id
= SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING
,
1008 .flags
= SWITCHDEV_F_SKIP_EOPNOTSUPP
,
1009 .u
.vlan_filtering
= br_opt_get(p
->br
, BROPT_VLAN_ENABLED
),
1011 struct net_bridge_vlan_group
*vg
;
1014 vg
= kzalloc(sizeof(struct net_bridge_vlan_group
), GFP_KERNEL
);
1018 ret
= switchdev_port_attr_set(p
->dev
, &attr
);
1019 if (ret
&& ret
!= -EOPNOTSUPP
)
1020 goto err_vlan_enabled
;
1022 ret
= rhashtable_init(&vg
->vlan_hash
, &br_vlan_rht_params
);
1025 ret
= vlan_tunnel_init(vg
);
1027 goto err_tunnel_init
;
1028 INIT_LIST_HEAD(&vg
->vlan_list
);
1029 rcu_assign_pointer(p
->vlgrp
, vg
);
1030 if (p
->br
->default_pvid
) {
1033 ret
= nbp_vlan_add(p
, p
->br
->default_pvid
,
1034 BRIDGE_VLAN_INFO_PVID
|
1035 BRIDGE_VLAN_INFO_UNTAGGED
,
1044 RCU_INIT_POINTER(p
->vlgrp
, NULL
);
1046 vlan_tunnel_deinit(vg
);
1048 rhashtable_destroy(&vg
->vlan_hash
);
1056 /* Must be protected by RTNL.
1057 * Must be called with vid in range from 1 to 4094 inclusive.
1058 * changed must be true only if the vlan was created or updated
1060 int nbp_vlan_add(struct net_bridge_port
*port
, u16 vid
, u16 flags
,
1063 struct switchdev_obj_port_vlan v
= {
1064 .obj
.orig_dev
= port
->dev
,
1065 .obj
.id
= SWITCHDEV_OBJ_ID_PORT_VLAN
,
1070 struct net_bridge_vlan
*vlan
;
1076 vlan
= br_vlan_find(nbp_vlan_group(port
), vid
);
1078 /* Pass the flags to the hardware bridge */
1079 ret
= switchdev_port_obj_add(port
->dev
, &v
.obj
);
1080 if (ret
&& ret
!= -EOPNOTSUPP
)
1082 *changed
= __vlan_add_flags(vlan
, flags
);
1087 vlan
= kzalloc(sizeof(*vlan
), GFP_KERNEL
);
1093 ret
= __vlan_add(vlan
, flags
);
1102 /* Must be protected by RTNL.
1103 * Must be called with vid in range from 1 to 4094 inclusive.
1105 int nbp_vlan_delete(struct net_bridge_port
*port
, u16 vid
)
1107 struct net_bridge_vlan
*v
;
1111 v
= br_vlan_find(nbp_vlan_group(port
), vid
);
1114 br_fdb_find_delete_local(port
->br
, port
, port
->dev
->dev_addr
, vid
);
1115 br_fdb_delete_by_port(port
->br
, port
, vid
, 0);
1117 return __vlan_del(v
);
1120 void nbp_vlan_flush(struct net_bridge_port
*port
)
1122 struct net_bridge_vlan_group
*vg
;
1126 vg
= nbp_vlan_group(port
);
1128 RCU_INIT_POINTER(port
->vlgrp
, NULL
);
1130 __vlan_group_free(vg
);
1133 void br_vlan_get_stats(const struct net_bridge_vlan
*v
,
1134 struct br_vlan_stats
*stats
)
1138 memset(stats
, 0, sizeof(*stats
));
1139 for_each_possible_cpu(i
) {
1140 u64 rxpackets
, rxbytes
, txpackets
, txbytes
;
1141 struct br_vlan_stats
*cpu_stats
;
1144 cpu_stats
= per_cpu_ptr(v
->stats
, i
);
1146 start
= u64_stats_fetch_begin_irq(&cpu_stats
->syncp
);
1147 rxpackets
= cpu_stats
->rx_packets
;
1148 rxbytes
= cpu_stats
->rx_bytes
;
1149 txbytes
= cpu_stats
->tx_bytes
;
1150 txpackets
= cpu_stats
->tx_packets
;
1151 } while (u64_stats_fetch_retry_irq(&cpu_stats
->syncp
, start
));
1153 stats
->rx_packets
+= rxpackets
;
1154 stats
->rx_bytes
+= rxbytes
;
1155 stats
->tx_bytes
+= txbytes
;
1156 stats
->tx_packets
+= txpackets
;