?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.14.87
[linux/fpc-iii.git] / net / bridge / br_vlan.c
blob9b8a53568b0f62f41310ada5340e9e943e9794e2
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>
6
7 #include "br_private.h"
8 #include "br_private_tunnel.h"
9
10 static inline int br_vlan_cmp(struct rhashtable_compare_arg *arg,
11 const void *ptr)
12 {
13 const struct net_bridge_vlan *vle = ptr;
14 u16 vid = *(u16 *)arg->key;
15
16 return vle->vid != vid;
17 }
18
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),
23 .nelem_hint = 3,
24 .locks_mul = 1,
25 .max_size = VLAN_N_VID,
26 .obj_cmpfn = br_vlan_cmp,
27 .automatic_shrinking = true,
28 };
29
30 static struct net_bridge_vlan *br_vlan_lookup(struct rhashtable *tbl, u16 vid)
31 {
32 return rhashtable_lookup_fast(tbl, &vid, br_vlan_rht_params);
33 }
34
35 static void __vlan_add_pvid(struct net_bridge_vlan_group *vg, u16 vid)
36 {
37 if (vg->pvid == vid)
38 return;
39
40 smp_wmb();
41 vg->pvid = vid;
42 }
43
44 static void __vlan_delete_pvid(struct net_bridge_vlan_group *vg, u16 vid)
45 {
46 if (vg->pvid != vid)
47 return;
48
49 smp_wmb();
50 vg->pvid = 0;
51 }
52
53 static void __vlan_add_flags(struct net_bridge_vlan *v, u16 flags)
54 {
55 struct net_bridge_vlan_group *vg;
56
57 if (br_vlan_is_master(v))
58 vg = br_vlan_group(v->br);
59 else
60 vg = nbp_vlan_group(v->port);
61
62 if (flags & BRIDGE_VLAN_INFO_PVID)
63 __vlan_add_pvid(vg, v->vid);
64 else
65 __vlan_delete_pvid(vg, v->vid);
66
67 if (flags & BRIDGE_VLAN_INFO_UNTAGGED)
68 v->flags |= BRIDGE_VLAN_INFO_UNTAGGED;
69 else
70 v->flags &= ~BRIDGE_VLAN_INFO_UNTAGGED;
71 }
72
73 static int __vlan_vid_add(struct net_device *dev, struct net_bridge *br,
74 u16 vid, u16 flags)
75 {
76 struct switchdev_obj_port_vlan v = {
77 .obj.orig_dev = dev,
78 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
79 .flags = flags,
80 .vid_begin = vid,
81 .vid_end = vid,
82 };
83 int err;
84
85 /* Try switchdev op first. In case it is not supported, fallback to
86 * 8021q add.
87 */
88 err = switchdev_port_obj_add(dev, &v.obj);
89 if (err == -EOPNOTSUPP)
90 return vlan_vid_add(dev, br->vlan_proto, vid);
91 return err;
92 }
93
94 static void __vlan_add_list(struct net_bridge_vlan *v)
95 {
96 struct net_bridge_vlan_group *vg;
97 struct list_head *headp, *hpos;
98 struct net_bridge_vlan *vent;
99
100 if (br_vlan_is_master(v))
101 vg = br_vlan_group(v->br);
102 else
103 vg = nbp_vlan_group(v->port);
104
105 headp = &vg->vlan_list;
106 list_for_each_prev(hpos, headp) {
107 vent = list_entry(hpos, struct net_bridge_vlan, vlist);
108 if (v->vid < vent->vid)
109 continue;
110 else
111 break;
112 }
113 list_add_rcu(&v->vlist, hpos);
114 }
115
116 static void __vlan_del_list(struct net_bridge_vlan *v)
117 {
118 list_del_rcu(&v->vlist);
119 }
120
121 static int __vlan_vid_del(struct net_device *dev, struct net_bridge *br,
122 u16 vid)
123 {
124 struct switchdev_obj_port_vlan v = {
125 .obj.orig_dev = dev,
126 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
127 .vid_begin = vid,
128 .vid_end = vid,
129 };
130 int err;
131
132 /* Try switchdev op first. In case it is not supported, fallback to
133 * 8021q del.
134 */
135 err = switchdev_port_obj_del(dev, &v.obj);
136 if (err == -EOPNOTSUPP) {
137 vlan_vid_del(dev, br->vlan_proto, vid);
138 return 0;
139 }
140 return err;
141 }
142
143 /* Returns a master vlan, if it didn't exist it gets created. In all cases a
144 * a reference is taken to the master vlan before returning.
145 */
146 static struct net_bridge_vlan *br_vlan_get_master(struct net_bridge *br, u16 vid)
147 {
148 struct net_bridge_vlan_group *vg;
149 struct net_bridge_vlan *masterv;
150
151 vg = br_vlan_group(br);
152 masterv = br_vlan_find(vg, vid);
153 if (!masterv) {
154 /* missing global ctx, create it now */
155 if (br_vlan_add(br, vid, 0))
156 return NULL;
157 masterv = br_vlan_find(vg, vid);
158 if (WARN_ON(!masterv))
159 return NULL;
160 refcount_set(&masterv->refcnt, 1);
161 return masterv;
162 }
163 refcount_inc(&masterv->refcnt);
164
165 return masterv;
166 }
167
168 static void br_master_vlan_rcu_free(struct rcu_head *rcu)
169 {
170 struct net_bridge_vlan *v;
171
172 v = container_of(rcu, struct net_bridge_vlan, rcu);
173 WARN_ON(!br_vlan_is_master(v));
174 free_percpu(v->stats);
175 v->stats = NULL;
176 kfree(v);
177 }
178
179 static void br_vlan_put_master(struct net_bridge_vlan *masterv)
180 {
181 struct net_bridge_vlan_group *vg;
182
183 if (!br_vlan_is_master(masterv))
184 return;
185
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);
192 }
193 }
194
195 /* This is the shared VLAN add function which works for both ports and bridge
196 * devices. There are four possible calls to this function in terms of the
197 * vlan entry type:
198 * 1. vlan is being added on a port (no master flags, global entry exists)
199 * 2. vlan is being added on a bridge (both master and brentry flags)
200 * 3. vlan is being added on a port, but a global entry didn't exist which
201 * is being created right now (master flag set, brentry flag unset), the
202 * global entry is used for global per-vlan features, but not for filtering
203 * 4. same as 3 but with both master and brentry flags set so the entry
204 * will be used for filtering in both the port and the bridge
205 */
206 static int __vlan_add(struct net_bridge_vlan *v, u16 flags)
207 {
208 struct net_bridge_vlan *masterv = NULL;
209 struct net_bridge_port *p = NULL;
210 struct net_bridge_vlan_group *vg;
211 struct net_device *dev;
212 struct net_bridge *br;
213 int err;
214
215 if (br_vlan_is_master(v)) {
216 br = v->br;
217 dev = br->dev;
218 vg = br_vlan_group(br);
219 } else {
220 p = v->port;
221 br = p->br;
222 dev = p->dev;
223 vg = nbp_vlan_group(p);
224 }
225
226 if (p) {
227 /* Add VLAN to the device filter if it is supported.
228 * This ensures tagged traffic enters the bridge when
229 * promiscuous mode is disabled by br_manage_promisc().
230 */
231 err = __vlan_vid_add(dev, br, v->vid, flags);
232 if (err)
233 goto out;
234
235 /* need to work on the master vlan too */
236 if (flags & BRIDGE_VLAN_INFO_MASTER) {
237 err = br_vlan_add(br, v->vid, flags |
238 BRIDGE_VLAN_INFO_BRENTRY);
239 if (err)
240 goto out_filt;
241 }
242
243 masterv = br_vlan_get_master(br, v->vid);
244 if (!masterv)
245 goto out_filt;
246 v->brvlan = masterv;
247 v->stats = masterv->stats;
248 }
249
250 /* Add the dev mac and count the vlan only if it's usable */
251 if (br_vlan_should_use(v)) {
252 err = br_fdb_insert(br, p, dev->dev_addr, v->vid);
253 if (err) {
254 br_err(br, "failed insert local address into bridge forwarding table\n");
255 goto out_filt;
256 }
257 vg->num_vlans++;
258 }
259
260 err = rhashtable_lookup_insert_fast(&vg->vlan_hash, &v->vnode,
261 br_vlan_rht_params);
262 if (err)
263 goto out_fdb_insert;
264
265 __vlan_add_list(v);
266 __vlan_add_flags(v, flags);
267 out:
268 return err;
269
270 out_fdb_insert:
271 if (br_vlan_should_use(v)) {
272 br_fdb_find_delete_local(br, p, dev->dev_addr, v->vid);
273 vg->num_vlans--;
274 }
275
276 out_filt:
277 if (p) {
278 __vlan_vid_del(dev, br, v->vid);
279 if (masterv) {
280 br_vlan_put_master(masterv);
281 v->brvlan = NULL;
282 }
283 }
284
285 goto out;
286 }
287
288 static int __vlan_del(struct net_bridge_vlan *v)
289 {
290 struct net_bridge_vlan *masterv = v;
291 struct net_bridge_vlan_group *vg;
292 struct net_bridge_port *p = NULL;
293 int err = 0;
294
295 if (br_vlan_is_master(v)) {
296 vg = br_vlan_group(v->br);
297 } else {
298 p = v->port;
299 vg = nbp_vlan_group(v->port);
300 masterv = v->brvlan;
301 }
302
303 __vlan_delete_pvid(vg, v->vid);
304 if (p) {
305 err = __vlan_vid_del(p->dev, p->br, v->vid);
306 if (err)
307 goto out;
308 }
309
310 if (br_vlan_should_use(v)) {
311 v->flags &= ~BRIDGE_VLAN_INFO_BRENTRY;
312 vg->num_vlans--;
313 }
314
315 if (masterv != v) {
316 vlan_tunnel_info_del(vg, v);
317 rhashtable_remove_fast(&vg->vlan_hash, &v->vnode,
318 br_vlan_rht_params);
319 __vlan_del_list(v);
320 kfree_rcu(v, rcu);
321 }
322
323 br_vlan_put_master(masterv);
324 out:
325 return err;
326 }
327
328 static void __vlan_group_free(struct net_bridge_vlan_group *vg)
329 {
330 WARN_ON(!list_empty(&vg->vlan_list));
331 rhashtable_destroy(&vg->vlan_hash);
332 vlan_tunnel_deinit(vg);
333 kfree(vg);
334 }
335
336 static void __vlan_flush(struct net_bridge_vlan_group *vg)
337 {
338 struct net_bridge_vlan *vlan, *tmp;
339
340 __vlan_delete_pvid(vg, vg->pvid);
341 list_for_each_entry_safe(vlan, tmp, &vg->vlan_list, vlist)
342 __vlan_del(vlan);
343 }
344
345 struct sk_buff *br_handle_vlan(struct net_bridge *br,
346 const struct net_bridge_port *p,
347 struct net_bridge_vlan_group *vg,
348 struct sk_buff *skb)
349 {
350 struct br_vlan_stats *stats;
351 struct net_bridge_vlan *v;
352 u16 vid;
353
354 /* If this packet was not filtered at input, let it pass */
355 if (!BR_INPUT_SKB_CB(skb)->vlan_filtered)
356 goto out;
357
358 /* At this point, we know that the frame was filtered and contains
359 * a valid vlan id. If the vlan id has untagged flag set,
360 * send untagged; otherwise, send tagged.
361 */
362 br_vlan_get_tag(skb, &vid);
363 v = br_vlan_find(vg, vid);
364 /* Vlan entry must be configured at this point. The
365 * only exception is the bridge is set in promisc mode and the
366 * packet is destined for the bridge device. In this case
367 * pass the packet as is.
368 */
369 if (!v || !br_vlan_should_use(v)) {
370 if ((br->dev->flags & IFF_PROMISC) && skb->dev == br->dev) {
371 goto out;
372 } else {
373 kfree_skb(skb);
374 return NULL;
375 }
376 }
377 if (br->vlan_stats_enabled) {
378 stats = this_cpu_ptr(v->stats);
379 u64_stats_update_begin(&stats->syncp);
380 stats->tx_bytes += skb->len;
381 stats->tx_packets++;
382 u64_stats_update_end(&stats->syncp);
383 }
384
385 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
386 skb->vlan_tci = 0;
387
388 if (p && (p->flags & BR_VLAN_TUNNEL) &&
389 br_handle_egress_vlan_tunnel(skb, v)) {
390 kfree_skb(skb);
391 return NULL;
392 }
393 out:
394 return skb;
395 }
396
397 /* Called under RCU */
398 static bool __allowed_ingress(const struct net_bridge *br,
399 struct net_bridge_vlan_group *vg,
400 struct sk_buff *skb, u16 *vid)
401 {
402 struct br_vlan_stats *stats;
403 struct net_bridge_vlan *v;
404 bool tagged;
405
406 BR_INPUT_SKB_CB(skb)->vlan_filtered = true;
407 /* If vlan tx offload is disabled on bridge device and frame was
408 * sent from vlan device on the bridge device, it does not have
409 * HW accelerated vlan tag.
410 */
411 if (unlikely(!skb_vlan_tag_present(skb) &&
412 skb->protocol == br->vlan_proto)) {
413 skb = skb_vlan_untag(skb);
414 if (unlikely(!skb))
415 return false;
416 }
417
418 if (!br_vlan_get_tag(skb, vid)) {
419 /* Tagged frame */
420 if (skb->vlan_proto != br->vlan_proto) {
421 /* Protocol-mismatch, empty out vlan_tci for new tag */
422 skb_push(skb, ETH_HLEN);
423 skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto,
424 skb_vlan_tag_get(skb));
425 if (unlikely(!skb))
426 return false;
427
428 skb_pull(skb, ETH_HLEN);
429 skb_reset_mac_len(skb);
430 *vid = 0;
431 tagged = false;
432 } else {
433 tagged = true;
434 }
435 } else {
436 /* Untagged frame */
437 tagged = false;
438 }
439
440 if (!*vid) {
441 u16 pvid = br_get_pvid(vg);
442
443 /* Frame had a tag with VID 0 or did not have a tag.
444 * See if pvid is set on this port. That tells us which
445 * vlan untagged or priority-tagged traffic belongs to.
446 */
447 if (!pvid)
448 goto drop;
449
450 /* PVID is set on this port. Any untagged or priority-tagged
451 * ingress frame is considered to belong to this vlan.
452 */
453 *vid = pvid;
454 if (likely(!tagged))
455 /* Untagged Frame. */
456 __vlan_hwaccel_put_tag(skb, br->vlan_proto, pvid);
457 else
458 /* Priority-tagged Frame.
459 * At this point, We know that skb->vlan_tci had
460 * VLAN_TAG_PRESENT bit and its VID field was 0x000.
461 * We update only VID field and preserve PCP field.
462 */
463 skb->vlan_tci |= pvid;
464
465 /* if stats are disabled we can avoid the lookup */
466 if (!br->vlan_stats_enabled)
467 return true;
468 }
469 v = br_vlan_find(vg, *vid);
470 if (!v || !br_vlan_should_use(v))
471 goto drop;
472
473 if (br->vlan_stats_enabled) {
474 stats = this_cpu_ptr(v->stats);
475 u64_stats_update_begin(&stats->syncp);
476 stats->rx_bytes += skb->len;
477 stats->rx_packets++;
478 u64_stats_update_end(&stats->syncp);
479 }
480
481 return true;
482
483 drop:
484 kfree_skb(skb);
485 return false;
486 }
487
488 bool br_allowed_ingress(const struct net_bridge *br,
489 struct net_bridge_vlan_group *vg, struct sk_buff *skb,
490 u16 *vid)
491 {
492 /* If VLAN filtering is disabled on the bridge, all packets are
493 * permitted.
494 */
495 if (!br->vlan_enabled) {
496 BR_INPUT_SKB_CB(skb)->vlan_filtered = false;
497 return true;
498 }
499
500 return __allowed_ingress(br, vg, skb, vid);
501 }
502
503 /* Called under RCU. */
504 bool br_allowed_egress(struct net_bridge_vlan_group *vg,
505 const struct sk_buff *skb)
506 {
507 const struct net_bridge_vlan *v;
508 u16 vid;
509
510 /* If this packet was not filtered at input, let it pass */
511 if (!BR_INPUT_SKB_CB(skb)->vlan_filtered)
512 return true;
513
514 br_vlan_get_tag(skb, &vid);
515 v = br_vlan_find(vg, vid);
516 if (v && br_vlan_should_use(v))
517 return true;
518
519 return false;
520 }
521
522 /* Called under RCU */
523 bool br_should_learn(struct net_bridge_port *p, struct sk_buff *skb, u16 *vid)
524 {
525 struct net_bridge_vlan_group *vg;
526 struct net_bridge *br = p->br;
527
528 /* If filtering was disabled at input, let it pass. */
529 if (!br->vlan_enabled)
530 return true;
531
532 vg = nbp_vlan_group_rcu(p);
533 if (!vg || !vg->num_vlans)
534 return false;
535
536 if (!br_vlan_get_tag(skb, vid) && skb->vlan_proto != br->vlan_proto)
537 *vid = 0;
538
539 if (!*vid) {
540 *vid = br_get_pvid(vg);
541 if (!*vid)
542 return false;
543
544 return true;
545 }
546
547 if (br_vlan_find(vg, *vid))
548 return true;
549
550 return false;
551 }
552
553 /* Must be protected by RTNL.
554 * Must be called with vid in range from 1 to 4094 inclusive.
555 */
556 int br_vlan_add(struct net_bridge *br, u16 vid, u16 flags)
557 {
558 struct net_bridge_vlan_group *vg;
559 struct net_bridge_vlan *vlan;
560 int ret;
561
562 ASSERT_RTNL();
563
564 vg = br_vlan_group(br);
565 vlan = br_vlan_find(vg, vid);
566 if (vlan) {
567 if (!br_vlan_is_brentry(vlan)) {
568 /* Trying to change flags of non-existent bridge vlan */
569 if (!(flags & BRIDGE_VLAN_INFO_BRENTRY))
570 return -EINVAL;
571 /* It was only kept for port vlans, now make it real */
572 ret = br_fdb_insert(br, NULL, br->dev->dev_addr,
573 vlan->vid);
574 if (ret) {
575 br_err(br, "failed insert local address into bridge forwarding table\n");
576 return ret;
577 }
578 refcount_inc(&vlan->refcnt);
579 vlan->flags |= BRIDGE_VLAN_INFO_BRENTRY;
580 vg->num_vlans++;
581 }
582 __vlan_add_flags(vlan, flags);
583 return 0;
584 }
585
586 vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
587 if (!vlan)
588 return -ENOMEM;
589
590 vlan->stats = netdev_alloc_pcpu_stats(struct br_vlan_stats);
591 if (!vlan->stats) {
592 kfree(vlan);
593 return -ENOMEM;
594 }
595 vlan->vid = vid;
596 vlan->flags = flags | BRIDGE_VLAN_INFO_MASTER;
597 vlan->flags &= ~BRIDGE_VLAN_INFO_PVID;
598 vlan->br = br;
599 if (flags & BRIDGE_VLAN_INFO_BRENTRY)
600 refcount_set(&vlan->refcnt, 1);
601 ret = __vlan_add(vlan, flags);
602 if (ret) {
603 free_percpu(vlan->stats);
604 kfree(vlan);
605 }
606
607 return ret;
608 }
609
610 /* Must be protected by RTNL.
611 * Must be called with vid in range from 1 to 4094 inclusive.
612 */
613 int br_vlan_delete(struct net_bridge *br, u16 vid)
614 {
615 struct net_bridge_vlan_group *vg;
616 struct net_bridge_vlan *v;
617
618 ASSERT_RTNL();
619
620 vg = br_vlan_group(br);
621 v = br_vlan_find(vg, vid);
622 if (!v || !br_vlan_is_brentry(v))
623 return -ENOENT;
624
625 br_fdb_find_delete_local(br, NULL, br->dev->dev_addr, vid);
626 br_fdb_delete_by_port(br, NULL, vid, 0);
627
628 vlan_tunnel_info_del(vg, v);
629
630 return __vlan_del(v);
631 }
632
633 void br_vlan_flush(struct net_bridge *br)
634 {
635 struct net_bridge_vlan_group *vg;
636
637 ASSERT_RTNL();
638
639 vg = br_vlan_group(br);
640 __vlan_flush(vg);
641 RCU_INIT_POINTER(br->vlgrp, NULL);
642 synchronize_rcu();
643 __vlan_group_free(vg);
644 }
645
646 struct net_bridge_vlan *br_vlan_find(struct net_bridge_vlan_group *vg, u16 vid)
647 {
648 if (!vg)
649 return NULL;
650
651 return br_vlan_lookup(&vg->vlan_hash, vid);
652 }
653
654 /* Must be protected by RTNL. */
655 static void recalculate_group_addr(struct net_bridge *br)
656 {
657 if (br->group_addr_set)
658 return;
659
660 spin_lock_bh(&br->lock);
661 if (!br->vlan_enabled || br->vlan_proto == htons(ETH_P_8021Q)) {
662 /* Bridge Group Address */
663 br->group_addr[5] = 0x00;
664 } else { /* vlan_enabled && ETH_P_8021AD */
665 /* Provider Bridge Group Address */
666 br->group_addr[5] = 0x08;
667 }
668 spin_unlock_bh(&br->lock);
669 }
670
671 /* Must be protected by RTNL. */
672 void br_recalculate_fwd_mask(struct net_bridge *br)
673 {
674 if (!br->vlan_enabled || br->vlan_proto == htons(ETH_P_8021Q))
675 br->group_fwd_mask_required = BR_GROUPFWD_DEFAULT;
676 else /* vlan_enabled && ETH_P_8021AD */
677 br->group_fwd_mask_required = BR_GROUPFWD_8021AD &
678 ~(1u << br->group_addr[5]);
679 }
680
681 int __br_vlan_filter_toggle(struct net_bridge *br, unsigned long val)
682 {
683 struct switchdev_attr attr = {
684 .orig_dev = br->dev,
685 .id = SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING,
686 .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP,
687 .u.vlan_filtering = val,
688 };
689 int err;
690
691 if (br->vlan_enabled == val)
692 return 0;
693
694 err = switchdev_port_attr_set(br->dev, &attr);
695 if (err && err != -EOPNOTSUPP)
696 return err;
697
698 br->vlan_enabled = val;
699 br_manage_promisc(br);
700 recalculate_group_addr(br);
701 br_recalculate_fwd_mask(br);
702
703 return 0;
704 }
705
706 int br_vlan_filter_toggle(struct net_bridge *br, unsigned long val)
707 {
708 return __br_vlan_filter_toggle(br, val);
709 }
710
711 bool br_vlan_enabled(const struct net_device *dev)
712 {
713 struct net_bridge *br = netdev_priv(dev);
714
715 return !!br->vlan_enabled;
716 }
717 EXPORT_SYMBOL_GPL(br_vlan_enabled);
718
719 int __br_vlan_set_proto(struct net_bridge *br, __be16 proto)
720 {
721 int err = 0;
722 struct net_bridge_port *p;
723 struct net_bridge_vlan *vlan;
724 struct net_bridge_vlan_group *vg;
725 __be16 oldproto;
726
727 if (br->vlan_proto == proto)
728 return 0;
729
730 /* Add VLANs for the new proto to the device filter. */
731 list_for_each_entry(p, &br->port_list, list) {
732 vg = nbp_vlan_group(p);
733 list_for_each_entry(vlan, &vg->vlan_list, vlist) {
734 err = vlan_vid_add(p->dev, proto, vlan->vid);
735 if (err)
736 goto err_filt;
737 }
738 }
739
740 oldproto = br->vlan_proto;
741 br->vlan_proto = proto;
742
743 recalculate_group_addr(br);
744 br_recalculate_fwd_mask(br);
745
746 /* Delete VLANs for the old proto from the device filter. */
747 list_for_each_entry(p, &br->port_list, list) {
748 vg = nbp_vlan_group(p);
749 list_for_each_entry(vlan, &vg->vlan_list, vlist)
750 vlan_vid_del(p->dev, oldproto, vlan->vid);
751 }
752
753 return 0;
754
755 err_filt:
756 list_for_each_entry_continue_reverse(vlan, &vg->vlan_list, vlist)
757 vlan_vid_del(p->dev, proto, vlan->vid);
758
759 list_for_each_entry_continue_reverse(p, &br->port_list, list) {
760 vg = nbp_vlan_group(p);
761 list_for_each_entry(vlan, &vg->vlan_list, vlist)
762 vlan_vid_del(p->dev, proto, vlan->vid);
763 }
764
765 return err;
766 }
767
768 int br_vlan_set_proto(struct net_bridge *br, unsigned long val)
769 {
770 if (val != ETH_P_8021Q && val != ETH_P_8021AD)
771 return -EPROTONOSUPPORT;
772
773 return __br_vlan_set_proto(br, htons(val));
774 }
775
776 int br_vlan_set_stats(struct net_bridge *br, unsigned long val)
777 {
778 switch (val) {
779 case 0:
780 case 1:
781 br->vlan_stats_enabled = val;
782 break;
783 default:
784 return -EINVAL;
785 }
786
787 return 0;
788 }
789
790 static bool vlan_default_pvid(struct net_bridge_vlan_group *vg, u16 vid)
791 {
792 struct net_bridge_vlan *v;
793
794 if (vid != vg->pvid)
795 return false;
796
797 v = br_vlan_lookup(&vg->vlan_hash, vid);
798 if (v && br_vlan_should_use(v) &&
799 (v->flags & BRIDGE_VLAN_INFO_UNTAGGED))
800 return true;
801
802 return false;
803 }
804
805 static void br_vlan_disable_default_pvid(struct net_bridge *br)
806 {
807 struct net_bridge_port *p;
808 u16 pvid = br->default_pvid;
809
810 /* Disable default_pvid on all ports where it is still
811 * configured.
812 */
813 if (vlan_default_pvid(br_vlan_group(br), pvid))
814 br_vlan_delete(br, pvid);
815
816 list_for_each_entry(p, &br->port_list, list) {
817 if (vlan_default_pvid(nbp_vlan_group(p), pvid))
818 nbp_vlan_delete(p, pvid);
819 }
820
821 br->default_pvid = 0;
822 }
823
824 int __br_vlan_set_default_pvid(struct net_bridge *br, u16 pvid)
825 {
826 const struct net_bridge_vlan *pvent;
827 struct net_bridge_vlan_group *vg;
828 struct net_bridge_port *p;
829 u16 old_pvid;
830 int err = 0;
831 unsigned long *changed;
832
833 if (!pvid) {
834 br_vlan_disable_default_pvid(br);
835 return 0;
836 }
837
838 changed = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
839 GFP_KERNEL);
840 if (!changed)
841 return -ENOMEM;
842
843 old_pvid = br->default_pvid;
844
845 /* Update default_pvid config only if we do not conflict with
846 * user configuration.
847 */
848 vg = br_vlan_group(br);
849 pvent = br_vlan_find(vg, pvid);
850 if ((!old_pvid || vlan_default_pvid(vg, old_pvid)) &&
851 (!pvent || !br_vlan_should_use(pvent))) {
852 err = br_vlan_add(br, pvid,
853 BRIDGE_VLAN_INFO_PVID |
854 BRIDGE_VLAN_INFO_UNTAGGED |
855 BRIDGE_VLAN_INFO_BRENTRY);
856 if (err)
857 goto out;
858 br_vlan_delete(br, old_pvid);
859 set_bit(0, changed);
860 }
861
862 list_for_each_entry(p, &br->port_list, list) {
863 /* Update default_pvid config only if we do not conflict with
864 * user configuration.
865 */
866 vg = nbp_vlan_group(p);
867 if ((old_pvid &&
868 !vlan_default_pvid(vg, old_pvid)) ||
869 br_vlan_find(vg, pvid))
870 continue;
871
872 err = nbp_vlan_add(p, pvid,
873 BRIDGE_VLAN_INFO_PVID |
874 BRIDGE_VLAN_INFO_UNTAGGED);
875 if (err)
876 goto err_port;
877 nbp_vlan_delete(p, old_pvid);
878 set_bit(p->port_no, changed);
879 }
880
881 br->default_pvid = pvid;
882
883 out:
884 kfree(changed);
885 return err;
886
887 err_port:
888 list_for_each_entry_continue_reverse(p, &br->port_list, list) {
889 if (!test_bit(p->port_no, changed))
890 continue;
891
892 if (old_pvid)
893 nbp_vlan_add(p, old_pvid,
894 BRIDGE_VLAN_INFO_PVID |
895 BRIDGE_VLAN_INFO_UNTAGGED);
896 nbp_vlan_delete(p, pvid);
897 }
898
899 if (test_bit(0, changed)) {
900 if (old_pvid)
901 br_vlan_add(br, old_pvid,
902 BRIDGE_VLAN_INFO_PVID |
903 BRIDGE_VLAN_INFO_UNTAGGED |
904 BRIDGE_VLAN_INFO_BRENTRY);
905 br_vlan_delete(br, pvid);
906 }
907 goto out;
908 }
909
910 int br_vlan_set_default_pvid(struct net_bridge *br, unsigned long val)
911 {
912 u16 pvid = val;
913 int err = 0;
914
915 if (val >= VLAN_VID_MASK)
916 return -EINVAL;
917
918 if (pvid == br->default_pvid)
919 goto out;
920
921 /* Only allow default pvid change when filtering is disabled */
922 if (br->vlan_enabled) {
923 pr_info_once("Please disable vlan filtering to change default_pvid\n");
924 err = -EPERM;
925 goto out;
926 }
927 err = __br_vlan_set_default_pvid(br, pvid);
928 out:
929 return err;
930 }
931
932 int br_vlan_init(struct net_bridge *br)
933 {
934 struct net_bridge_vlan_group *vg;
935 int ret = -ENOMEM;
936
937 vg = kzalloc(sizeof(*vg), GFP_KERNEL);
938 if (!vg)
939 goto out;
940 ret = rhashtable_init(&vg->vlan_hash, &br_vlan_rht_params);
941 if (ret)
942 goto err_rhtbl;
943 ret = vlan_tunnel_init(vg);
944 if (ret)
945 goto err_tunnel_init;
946 INIT_LIST_HEAD(&vg->vlan_list);
947 br->vlan_proto = htons(ETH_P_8021Q);
948 br->default_pvid = 1;
949 rcu_assign_pointer(br->vlgrp, vg);
950 ret = br_vlan_add(br, 1,
951 BRIDGE_VLAN_INFO_PVID | BRIDGE_VLAN_INFO_UNTAGGED |
952 BRIDGE_VLAN_INFO_BRENTRY);
953 if (ret)
954 goto err_vlan_add;
955
956 out:
957 return ret;
958
959 err_vlan_add:
960 vlan_tunnel_deinit(vg);
961 err_tunnel_init:
962 rhashtable_destroy(&vg->vlan_hash);
963 err_rhtbl:
964 kfree(vg);
965
966 goto out;
967 }
968
969 int nbp_vlan_init(struct net_bridge_port *p)
970 {
971 struct switchdev_attr attr = {
972 .orig_dev = p->br->dev,
973 .id = SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING,
974 .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP,
975 .u.vlan_filtering = p->br->vlan_enabled,
976 };
977 struct net_bridge_vlan_group *vg;
978 int ret = -ENOMEM;
979
980 vg = kzalloc(sizeof(struct net_bridge_vlan_group), GFP_KERNEL);
981 if (!vg)
982 goto out;
983
984 ret = switchdev_port_attr_set(p->dev, &attr);
985 if (ret && ret != -EOPNOTSUPP)
986 goto err_vlan_enabled;
987
988 ret = rhashtable_init(&vg->vlan_hash, &br_vlan_rht_params);
989 if (ret)
990 goto err_rhtbl;
991 ret = vlan_tunnel_init(vg);
992 if (ret)
993 goto err_tunnel_init;
994 INIT_LIST_HEAD(&vg->vlan_list);
995 rcu_assign_pointer(p->vlgrp, vg);
996 if (p->br->default_pvid) {
997 ret = nbp_vlan_add(p, p->br->default_pvid,
998 BRIDGE_VLAN_INFO_PVID |
999 BRIDGE_VLAN_INFO_UNTAGGED);
1000 if (ret)
1001 goto err_vlan_add;
1002 }
1003 out:
1004 return ret;
1005
1006 err_vlan_add:
1007 RCU_INIT_POINTER(p->vlgrp, NULL);
1008 synchronize_rcu();
1009 vlan_tunnel_deinit(vg);
1010 err_tunnel_init:
1011 rhashtable_destroy(&vg->vlan_hash);
1012 err_rhtbl:
1013 err_vlan_enabled:
1014 kfree(vg);
1015
1016 goto out;
1017 }
1018
1019 /* Must be protected by RTNL.
1020 * Must be called with vid in range from 1 to 4094 inclusive.
1021 */
1022 int nbp_vlan_add(struct net_bridge_port *port, u16 vid, u16 flags)
1023 {
1024 struct switchdev_obj_port_vlan v = {
1025 .obj.orig_dev = port->dev,
1026 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
1027 .flags = flags,
1028 .vid_begin = vid,
1029 .vid_end = vid,
1030 };
1031 struct net_bridge_vlan *vlan;
1032 int ret;
1033
1034 ASSERT_RTNL();
1035
1036 vlan = br_vlan_find(nbp_vlan_group(port), vid);
1037 if (vlan) {
1038 /* Pass the flags to the hardware bridge */
1039 ret = switchdev_port_obj_add(port->dev, &v.obj);
1040 if (ret && ret != -EOPNOTSUPP)
1041 return ret;
1042 __vlan_add_flags(vlan, flags);
1043 return 0;
1044 }
1045
1046 vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
1047 if (!vlan)
1048 return -ENOMEM;
1049
1050 vlan->vid = vid;
1051 vlan->port = port;
1052 ret = __vlan_add(vlan, flags);
1053 if (ret)
1054 kfree(vlan);
1055
1056 return ret;
1057 }
1058
1059 /* Must be protected by RTNL.
1060 * Must be called with vid in range from 1 to 4094 inclusive.
1061 */
1062 int nbp_vlan_delete(struct net_bridge_port *port, u16 vid)
1063 {
1064 struct net_bridge_vlan *v;
1065
1066 ASSERT_RTNL();
1067
1068 v = br_vlan_find(nbp_vlan_group(port), vid);
1069 if (!v)
1070 return -ENOENT;
1071 br_fdb_find_delete_local(port->br, port, port->dev->dev_addr, vid);
1072 br_fdb_delete_by_port(port->br, port, vid, 0);
1073
1074 return __vlan_del(v);
1075 }
1076
1077 void nbp_vlan_flush(struct net_bridge_port *port)
1078 {
1079 struct net_bridge_vlan_group *vg;
1080
1081 ASSERT_RTNL();
1082
1083 vg = nbp_vlan_group(port);
1084 __vlan_flush(vg);
1085 RCU_INIT_POINTER(port->vlgrp, NULL);
1086 synchronize_rcu();
1087 __vlan_group_free(vg);
1088 }
1089
1090 void br_vlan_get_stats(const struct net_bridge_vlan *v,
1091 struct br_vlan_stats *stats)
1092 {
1093 int i;
1094
1095 memset(stats, 0, sizeof(*stats));
1096 for_each_possible_cpu(i) {
1097 u64 rxpackets, rxbytes, txpackets, txbytes;
1098 struct br_vlan_stats *cpu_stats;
1099 unsigned int start;
1100
1101 cpu_stats = per_cpu_ptr(v->stats, i);
1102 do {
1103 start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
1104 rxpackets = cpu_stats->rx_packets;
1105 rxbytes = cpu_stats->rx_bytes;
1106 txbytes = cpu_stats->tx_bytes;
1107 txpackets = cpu_stats->tx_packets;
1108 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
1109
1110 stats->rx_packets += rxpackets;
1111 stats->rx_bytes += rxbytes;
1112 stats->tx_bytes += txbytes;
1113 stats->tx_packets += txpackets;
1114 }
1115 }
Linux with added FPC-III support