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