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.orig_dev = dev,
  77                 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
  78                 .flags = flags,
  79                 .vid_begin = vid,
  80                 .vid_end = vid,
  81         };
  82         int err;
  83
  84         /* Try switchdev op first. In case it is not supported, fallback to
  85          * 8021q add.
  86          */
  87         err = switchdev_port_obj_add(dev, &v.obj);
  88         if (err == -EOPNOTSUPP)
  89                 return vlan_vid_add(dev, br->vlan_proto, vid);
  90         return err;
  91 }
  92
  93 static void __vlan_add_list(struct net_bridge_vlan *v)
  94 {
  95         struct net_bridge_vlan_group *vg;
  96         struct list_head *headp, *hpos;
  97         struct net_bridge_vlan *vent;
  98
  99         if (br_vlan_is_master(v))
 100                 vg = br_vlan_group(v->br);
 101         else
 102                 vg = nbp_vlan_group(v->port);
 103
 104         headp = &vg->vlan_list;
 105         list_for_each_prev(hpos, headp) {
 106                 vent = list_entry(hpos, struct net_bridge_vlan, vlist);
 107                 if (v->vid < vent->vid)
 108                         continue;
 109                 else
 110                         break;
 111         }
 112         list_add_rcu(&v->vlist, hpos);
 113 }
 114
 115 static void __vlan_del_list(struct net_bridge_vlan *v)
 116 {
 117         list_del_rcu(&v->vlist);
 118 }
 119
 120 static int __vlan_vid_del(struct net_device *dev, struct net_bridge *br,
 121                           u16 vid)
 122 {
 123         struct switchdev_obj_port_vlan v = {
 124                 .obj.orig_dev = dev,
 125                 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
 126                 .vid_begin = vid,
 127                 .vid_end = vid,
 128         };
 129         int err;
 130
 131         /* Try switchdev op first. In case it is not supported, fallback to
 132          * 8021q del.
 133          */
 134         err = switchdev_port_obj_del(dev, &v.obj);
 135         if (err == -EOPNOTSUPP) {
 136                 vlan_vid_del(dev, br->vlan_proto, vid);
 137                 return 0;
 138         }
 139         return err;
 140 }
 141
 142 /* Returns a master vlan, if it didn't exist it gets created. In all cases a
 143  * a reference is taken to the master vlan before returning.
 144  */
 145 static struct net_bridge_vlan *br_vlan_get_master(struct net_bridge *br, u16 vid)
 146 {
 147         struct net_bridge_vlan_group *vg;
 148         struct net_bridge_vlan *masterv;
 149
 150         vg = br_vlan_group(br);
 151         masterv = br_vlan_find(vg, vid);
 152         if (!masterv) {
 153                 /* missing global ctx, create it now */
 154                 if (br_vlan_add(br, vid, 0))
 155                         return NULL;
 156                 masterv = br_vlan_find(vg, vid);
 157                 if (WARN_ON(!masterv))
 158                         return NULL;
 159         }
 160         atomic_inc(&masterv->refcnt);
 161
 162         return masterv;
 163 }
 164
 165 static void br_vlan_put_master(struct net_bridge_vlan *masterv)
 166 {
 167         struct net_bridge_vlan_group *vg;
 168
 169         if (!br_vlan_is_master(masterv))
 170                 return;
 171
 172         vg = br_vlan_group(masterv->br);
 173         if (atomic_dec_and_test(&masterv->refcnt)) {
 174                 rhashtable_remove_fast(&vg->vlan_hash,
 175                                        &masterv->vnode, br_vlan_rht_params);
 176                 __vlan_del_list(masterv);
 177                 kfree_rcu(masterv, rcu);
 178         }
 179 }
 180
 181 /* This is the shared VLAN add function which works for both ports and bridge
 182  * devices. There are four possible calls to this function in terms of the
 183  * vlan entry type:
 184  * 1. vlan is being added on a port (no master flags, global entry exists)
 185  * 2. vlan is being added on a bridge (both master and brentry flags)
 186  * 3. vlan is being added on a port, but a global entry didn't exist which
 187  *    is being created right now (master flag set, brentry flag unset), the
 188  *    global entry is used for global per-vlan features, but not for filtering
 189  * 4. same as 3 but with both master and brentry flags set so the entry
 190  *    will be used for filtering in both the port and the bridge
 191  */
 192 static int __vlan_add(struct net_bridge_vlan *v, u16 flags)
 193 {
 194         struct net_bridge_vlan *masterv = NULL;
 195         struct net_bridge_port *p = NULL;
 196         struct net_bridge_vlan_group *vg;
 197         struct net_device *dev;
 198         struct net_bridge *br;
 199         int err;
 200
 201         if (br_vlan_is_master(v)) {
 202                 br = v->br;
 203                 dev = br->dev;
 204                 vg = br_vlan_group(br);
 205         } else {
 206                 p = v->port;
 207                 br = p->br;
 208                 dev = p->dev;
 209                 vg = nbp_vlan_group(p);
 210         }
 211
 212         if (p) {
 213                 /* Add VLAN to the device filter if it is supported.
 214                  * This ensures tagged traffic enters the bridge when
 215                  * promiscuous mode is disabled by br_manage_promisc().
 216                  */
 217                 err = __vlan_vid_add(dev, br, v->vid, flags);
 218                 if (err)
 219                         goto out;
 220
 221                 /* need to work on the master vlan too */
 222                 if (flags & BRIDGE_VLAN_INFO_MASTER) {
 223                         err = br_vlan_add(br, v->vid, flags |
 224                                                       BRIDGE_VLAN_INFO_BRENTRY);
 225                         if (err)
 226                                 goto out_filt;
 227                 }
 228
 229                 masterv = br_vlan_get_master(br, v->vid);
 230                 if (!masterv)
 231                         goto out_filt;
 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         vg = br_vlan_group(br);
 586         __vlan_flush(vg);
 587         RCU_INIT_POINTER(br->vlgrp, NULL);
 588         synchronize_rcu();
 589         __vlan_group_free(vg);
 590 }
 591
 592 struct net_bridge_vlan *br_vlan_find(struct net_bridge_vlan_group *vg, u16 vid)
 593 {
 594         if (!vg)
 595                 return NULL;
 596
 597         return br_vlan_lookup(&vg->vlan_hash, vid);
 598 }
 599
 600 /* Must be protected by RTNL. */
 601 static void recalculate_group_addr(struct net_bridge *br)
 602 {
 603         if (br->group_addr_set)
 604                 return;
 605
 606         spin_lock_bh(&br->lock);
 607         if (!br->vlan_enabled || br->vlan_proto == htons(ETH_P_8021Q)) {
 608                 /* Bridge Group Address */
 609                 br->group_addr[5] = 0x00;
 610         } else { /* vlan_enabled && ETH_P_8021AD */
 611                 /* Provider Bridge Group Address */
 612                 br->group_addr[5] = 0x08;
 613         }
 614         spin_unlock_bh(&br->lock);
 615 }
 616
 617 /* Must be protected by RTNL. */
 618 void br_recalculate_fwd_mask(struct net_bridge *br)
 619 {
 620         if (!br->vlan_enabled || br->vlan_proto == htons(ETH_P_8021Q))
 621                 br->group_fwd_mask_required = BR_GROUPFWD_DEFAULT;
 622         else /* vlan_enabled && ETH_P_8021AD */
 623                 br->group_fwd_mask_required = BR_GROUPFWD_8021AD &
 624                                               ~(1u << br->group_addr[5]);
 625 }
 626
 627 int __br_vlan_filter_toggle(struct net_bridge *br, unsigned long val)
 628 {
 629         struct switchdev_attr attr = {
 630                 .orig_dev = br->dev,
 631                 .id = SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING,
 632                 .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP,
 633                 .u.vlan_filtering = val,
 634         };
 635         int err;
 636
 637         if (br->vlan_enabled == val)
 638                 return 0;
 639
 640         err = switchdev_port_attr_set(br->dev, &attr);
 641         if (err && err != -EOPNOTSUPP)
 642                 return err;
 643
 644         br->vlan_enabled = val;
 645         br_manage_promisc(br);
 646         recalculate_group_addr(br);
 647         br_recalculate_fwd_mask(br);
 648
 649         return 0;
 650 }
 651
 652 int br_vlan_filter_toggle(struct net_bridge *br, unsigned long val)
 653 {
 654         return __br_vlan_filter_toggle(br, val);
 655 }
 656
 657 int __br_vlan_set_proto(struct net_bridge *br, __be16 proto)
 658 {
 659         int err = 0;
 660         struct net_bridge_port *p;
 661         struct net_bridge_vlan *vlan;
 662         struct net_bridge_vlan_group *vg;
 663         __be16 oldproto;
 664
 665         if (br->vlan_proto == proto)
 666                 return 0;
 667
 668         /* Add VLANs for the new proto to the device filter. */
 669         list_for_each_entry(p, &br->port_list, list) {
 670                 vg = nbp_vlan_group(p);
 671                 list_for_each_entry(vlan, &vg->vlan_list, vlist) {
 672                         err = vlan_vid_add(p->dev, proto, vlan->vid);
 673                         if (err)
 674                                 goto err_filt;
 675                 }
 676         }
 677
 678         oldproto = br->vlan_proto;
 679         br->vlan_proto = proto;
 680
 681         recalculate_group_addr(br);
 682         br_recalculate_fwd_mask(br);
 683
 684         /* Delete VLANs for the old proto from the device filter. */
 685         list_for_each_entry(p, &br->port_list, list) {
 686                 vg = nbp_vlan_group(p);
 687                 list_for_each_entry(vlan, &vg->vlan_list, vlist)
 688                         vlan_vid_del(p->dev, oldproto, vlan->vid);
 689         }
 690
 691         return 0;
 692
 693 err_filt:
 694         list_for_each_entry_continue_reverse(vlan, &vg->vlan_list, vlist)
 695                 vlan_vid_del(p->dev, proto, vlan->vid);
 696
 697         list_for_each_entry_continue_reverse(p, &br->port_list, list) {
 698                 vg = nbp_vlan_group(p);
 699                 list_for_each_entry(vlan, &vg->vlan_list, vlist)
 700                         vlan_vid_del(p->dev, proto, vlan->vid);
 701         }
 702
 703         return err;
 704 }
 705
 706 int br_vlan_set_proto(struct net_bridge *br, unsigned long val)
 707 {
 708         if (val != ETH_P_8021Q && val != ETH_P_8021AD)
 709                 return -EPROTONOSUPPORT;
 710
 711         return __br_vlan_set_proto(br, htons(val));
 712 }
 713
 714 static bool vlan_default_pvid(struct net_bridge_vlan_group *vg, u16 vid)
 715 {
 716         struct net_bridge_vlan *v;
 717
 718         if (vid != vg->pvid)
 719                 return false;
 720
 721         v = br_vlan_lookup(&vg->vlan_hash, vid);
 722         if (v && br_vlan_should_use(v) &&
 723             (v->flags & BRIDGE_VLAN_INFO_UNTAGGED))
 724                 return true;
 725
 726         return false;
 727 }
 728
 729 static void br_vlan_disable_default_pvid(struct net_bridge *br)
 730 {
 731         struct net_bridge_port *p;
 732         u16 pvid = br->default_pvid;
 733
 734         /* Disable default_pvid on all ports where it is still
 735          * configured.
 736          */
 737         if (vlan_default_pvid(br_vlan_group(br), pvid))
 738                 br_vlan_delete(br, pvid);
 739
 740         list_for_each_entry(p, &br->port_list, list) {
 741                 if (vlan_default_pvid(nbp_vlan_group(p), pvid))
 742                         nbp_vlan_delete(p, pvid);
 743         }
 744
 745         br->default_pvid = 0;
 746 }
 747
 748 int __br_vlan_set_default_pvid(struct net_bridge *br, u16 pvid)
 749 {
 750         const struct net_bridge_vlan *pvent;
 751         struct net_bridge_vlan_group *vg;
 752         struct net_bridge_port *p;
 753         u16 old_pvid;
 754         int err = 0;
 755         unsigned long *changed;
 756
 757         if (!pvid) {
 758                 br_vlan_disable_default_pvid(br);
 759                 return 0;
 760         }
 761
 762         changed = kcalloc(BITS_TO_LONGS(BR_MAX_PORTS), sizeof(unsigned long),
 763                           GFP_KERNEL);
 764         if (!changed)
 765                 return -ENOMEM;
 766
 767         old_pvid = br->default_pvid;
 768
 769         /* Update default_pvid config only if we do not conflict with
 770          * user configuration.
 771          */
 772         vg = br_vlan_group(br);
 773         pvent = br_vlan_find(vg, pvid);
 774         if ((!old_pvid || vlan_default_pvid(vg, old_pvid)) &&
 775             (!pvent || !br_vlan_should_use(pvent))) {
 776                 err = br_vlan_add(br, pvid,
 777                                   BRIDGE_VLAN_INFO_PVID |
 778                                   BRIDGE_VLAN_INFO_UNTAGGED |
 779                                   BRIDGE_VLAN_INFO_BRENTRY);
 780                 if (err)
 781                         goto out;
 782                 br_vlan_delete(br, old_pvid);
 783                 set_bit(0, changed);
 784         }
 785
 786         list_for_each_entry(p, &br->port_list, list) {
 787                 /* Update default_pvid config only if we do not conflict with
 788                  * user configuration.
 789                  */
 790                 vg = nbp_vlan_group(p);
 791                 if ((old_pvid &&
 792                      !vlan_default_pvid(vg, old_pvid)) ||
 793                     br_vlan_find(vg, pvid))
 794                         continue;
 795
 796                 err = nbp_vlan_add(p, pvid,
 797                                    BRIDGE_VLAN_INFO_PVID |
 798                                    BRIDGE_VLAN_INFO_UNTAGGED);
 799                 if (err)
 800                         goto err_port;
 801                 nbp_vlan_delete(p, old_pvid);
 802                 set_bit(p->port_no, changed);
 803         }
 804
 805         br->default_pvid = pvid;
 806
 807 out:
 808         kfree(changed);
 809         return err;
 810
 811 err_port:
 812         list_for_each_entry_continue_reverse(p, &br->port_list, list) {
 813                 if (!test_bit(p->port_no, changed))
 814                         continue;
 815
 816                 if (old_pvid)
 817                         nbp_vlan_add(p, old_pvid,
 818                                      BRIDGE_VLAN_INFO_PVID |
 819                                      BRIDGE_VLAN_INFO_UNTAGGED);
 820                 nbp_vlan_delete(p, pvid);
 821         }
 822
 823         if (test_bit(0, changed)) {
 824                 if (old_pvid)
 825                         br_vlan_add(br, old_pvid,
 826                                     BRIDGE_VLAN_INFO_PVID |
 827                                     BRIDGE_VLAN_INFO_UNTAGGED |
 828                                     BRIDGE_VLAN_INFO_BRENTRY);
 829                 br_vlan_delete(br, pvid);
 830         }
 831         goto out;
 832 }
 833
 834 int br_vlan_set_default_pvid(struct net_bridge *br, unsigned long val)
 835 {
 836         u16 pvid = val;
 837         int err = 0;
 838
 839         if (val >= VLAN_VID_MASK)
 840                 return -EINVAL;
 841
 842         if (pvid == br->default_pvid)
 843                 goto out;
 844
 845         /* Only allow default pvid change when filtering is disabled */
 846         if (br->vlan_enabled) {
 847                 pr_info_once("Please disable vlan filtering to change default_pvid\n");
 848                 err = -EPERM;
 849                 goto out;
 850         }
 851         err = __br_vlan_set_default_pvid(br, pvid);
 852 out:
 853         return err;
 854 }
 855
 856 int br_vlan_init(struct net_bridge *br)
 857 {
 858         struct net_bridge_vlan_group *vg;
 859         int ret = -ENOMEM;
 860
 861         vg = kzalloc(sizeof(*vg), GFP_KERNEL);
 862         if (!vg)
 863                 goto out;
 864         ret = rhashtable_init(&vg->vlan_hash, &br_vlan_rht_params);
 865         if (ret)
 866                 goto err_rhtbl;
 867         INIT_LIST_HEAD(&vg->vlan_list);
 868         br->vlan_proto = htons(ETH_P_8021Q);
 869         br->default_pvid = 1;
 870         rcu_assign_pointer(br->vlgrp, vg);
 871         ret = br_vlan_add(br, 1,
 872                           BRIDGE_VLAN_INFO_PVID | BRIDGE_VLAN_INFO_UNTAGGED |
 873                           BRIDGE_VLAN_INFO_BRENTRY);
 874         if (ret)
 875                 goto err_vlan_add;
 876
 877 out:
 878         return ret;
 879
 880 err_vlan_add:
 881         rhashtable_destroy(&vg->vlan_hash);
 882 err_rhtbl:
 883         kfree(vg);
 884
 885         goto out;
 886 }
 887
 888 int nbp_vlan_init(struct net_bridge_port *p)
 889 {
 890         struct switchdev_attr attr = {
 891                 .orig_dev = p->br->dev,
 892                 .id = SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING,
 893                 .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP,
 894                 .u.vlan_filtering = p->br->vlan_enabled,
 895         };
 896         struct net_bridge_vlan_group *vg;
 897         int ret = -ENOMEM;
 898
 899         vg = kzalloc(sizeof(struct net_bridge_vlan_group), GFP_KERNEL);
 900         if (!vg)
 901                 goto out;
 902
 903         ret = switchdev_port_attr_set(p->dev, &attr);
 904         if (ret && ret != -EOPNOTSUPP)
 905                 goto err_vlan_enabled;
 906
 907         ret = rhashtable_init(&vg->vlan_hash, &br_vlan_rht_params);
 908         if (ret)
 909                 goto err_rhtbl;
 910         INIT_LIST_HEAD(&vg->vlan_list);
 911         rcu_assign_pointer(p->vlgrp, vg);
 912         if (p->br->default_pvid) {
 913                 ret = nbp_vlan_add(p, p->br->default_pvid,
 914                                    BRIDGE_VLAN_INFO_PVID |
 915                                    BRIDGE_VLAN_INFO_UNTAGGED);
 916                 if (ret)
 917                         goto err_vlan_add;
 918         }
 919 out:
 920         return ret;
 921
 922 err_vlan_add:
 923         RCU_INIT_POINTER(p->vlgrp, NULL);
 924         synchronize_rcu();
 925         rhashtable_destroy(&vg->vlan_hash);
 926 err_vlan_enabled:
 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 switchdev_obj_port_vlan v = {
 939                 .obj.orig_dev = port->dev,
 940                 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
 941                 .flags = flags,
 942                 .vid_begin = vid,
 943                 .vid_end = vid,
 944         };
 945         struct net_bridge_vlan *vlan;
 946         int ret;
 947
 948         ASSERT_RTNL();
 949
 950         vlan = br_vlan_find(nbp_vlan_group(port), vid);
 951         if (vlan) {
 952                 /* Pass the flags to the hardware bridge */
 953                 ret = switchdev_port_obj_add(port->dev, &v.obj);
 954                 if (ret && ret != -EOPNOTSUPP)
 955                         return ret;
 956                 __vlan_add_flags(vlan, flags);
 957                 return 0;
 958         }
 959
 960         vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
 961         if (!vlan)
 962                 return -ENOMEM;
 963
 964         vlan->vid = vid;
 965         vlan->port = port;
 966         ret = __vlan_add(vlan, flags);
 967         if (ret)
 968                 kfree(vlan);
 969
 970         return ret;
 971 }
 972
 973 /* Must be protected by RTNL.
 974  * Must be called with vid in range from 1 to 4094 inclusive.
 975  */
 976 int nbp_vlan_delete(struct net_bridge_port *port, u16 vid)
 977 {
 978         struct net_bridge_vlan *v;
 979
 980         ASSERT_RTNL();
 981
 982         v = br_vlan_find(nbp_vlan_group(port), vid);
 983         if (!v)
 984                 return -ENOENT;
 985         br_fdb_find_delete_local(port->br, port, port->dev->dev_addr, vid);
 986         br_fdb_delete_by_port(port->br, port, vid, 0);
 987
 988         return __vlan_del(v);
 989 }
 990
 991 void nbp_vlan_flush(struct net_bridge_port *port)
 992 {
 993         struct net_bridge_vlan_group *vg;
 994
 995         ASSERT_RTNL();
 996
 997         vg = nbp_vlan_group(port);
 998         __vlan_flush(vg);
 999         RCU_INIT_POINTER(port->vlgrp, NULL);
1000         synchronize_rcu();
1001         __vlan_group_free(vg);
1002 }