net/bridge/br_vlan.c

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