1 // SPDX-License-Identifier: GPL-2.0-only 2 #include <linux/kernel.h> 3 #include <linux/netdevice.h> 4 #include <linux/rtnetlink.h> 5 #include <linux/slab.h> 6 #include <net/switchdev.h> 7 8 #include "br_private.h" 9 #include "br_private_tunnel.h" 10 11 static void nbp_vlan_set_vlan_dev_state(struct net_bridge_port *p, u16 vid); 12 13 static inline int br_vlan_cmp(struct rhashtable_compare_arg *arg, 14 const void *ptr) 15 { 16 const struct net_bridge_vlan *vle = ptr; 17 u16 vid = *(u16 *)arg->key; 18 19 return vle->vid != vid; 20 } 21 22 static const struct rhashtable_params br_vlan_rht_params = { 23 .head_offset = offsetof(struct net_bridge_vlan, vnode), 24 .key_offset = offsetof(struct net_bridge_vlan, vid), 25 .key_len = sizeof(u16), 26 .nelem_hint = 3, 27 .max_size = VLAN_N_VID, 28 .obj_cmpfn = br_vlan_cmp, 29 .automatic_shrinking = true, 30 }; 31 32 static struct net_bridge_vlan *br_vlan_lookup(struct rhashtable *tbl, u16 vid) 33 { 34 return rhashtable_lookup_fast(tbl, &vid, br_vlan_rht_params); 35 } 36 37 static void __vlan_add_pvid(struct net_bridge_vlan_group *vg, 38 const struct net_bridge_vlan *v) 39 { 40 if (vg->pvid == v->vid) 41 return; 42 43 smp_wmb(); 44 br_vlan_set_pvid_state(vg, v->state); 45 vg->pvid = v->vid; 46 } 47 48 static void __vlan_delete_pvid(struct net_bridge_vlan_group *vg, u16 vid) 49 { 50 if (vg->pvid != vid) 51 return; 52 53 smp_wmb(); 54 vg->pvid = 0; 55 } 56 57 /* Update the BRIDGE_VLAN_INFO_PVID and BRIDGE_VLAN_INFO_UNTAGGED flags of @v. 58 * If @commit is false, return just whether the BRIDGE_VLAN_INFO_PVID and 59 * BRIDGE_VLAN_INFO_UNTAGGED bits of @flags would produce any change onto @v. 60 */ 61 static bool __vlan_flags_update(struct net_bridge_vlan *v, u16 flags, 62 bool commit) 63 { 64 struct net_bridge_vlan_group *vg; 65 bool change; 66 67 if (br_vlan_is_master(v)) 68 vg = br_vlan_group(v->br); 69 else 70 vg = nbp_vlan_group(v->port); 71 72 /* check if anything would be changed on commit */ 73 change = !!(flags & BRIDGE_VLAN_INFO_PVID) == !!(vg->pvid != v->vid) || 74 ((flags ^ v->flags) & BRIDGE_VLAN_INFO_UNTAGGED); 75 76 if (!commit) 77 goto out; 78 79 if (flags & BRIDGE_VLAN_INFO_PVID) 80 __vlan_add_pvid(vg, v); 81 else 82 __vlan_delete_pvid(vg, v->vid); 83 84 if (flags & BRIDGE_VLAN_INFO_UNTAGGED) 85 v->flags |= BRIDGE_VLAN_INFO_UNTAGGED; 86 else 87 v->flags &= ~BRIDGE_VLAN_INFO_UNTAGGED; 88 89 out: 90 return change; 91 } 92 93 static bool __vlan_flags_would_change(struct net_bridge_vlan *v, u16 flags) 94 { 95 return __vlan_flags_update(v, flags, false); 96 } 97 98 static void __vlan_flags_commit(struct net_bridge_vlan *v, u16 flags) 99 { 100 __vlan_flags_update(v, flags, true); 101 } 102 103 static int __vlan_vid_add(struct net_device *dev, struct net_bridge *br, 104 struct net_bridge_vlan *v, u16 flags, 105 struct netlink_ext_ack *extack) 106 { 107 int err; 108 109 /* Try switchdev op first. In case it is not supported, fallback to 110 * 8021q add. 111 */ 112 err = br_switchdev_port_vlan_no_foreign_add(dev, v->vid, flags, false, extack); 113 if (err != -EOPNOTSUPP) { 114 v->priv_flags |= BR_VLFLAG_ADDED_BY_SWITCHDEV | BR_VLFLAG_TAGGING_BY_SWITCHDEV; 115 return err; 116 } 117 err = br_switchdev_port_vlan_add(dev, v->vid, flags, false, extack); 118 if (err == -EOPNOTSUPP) 119 return vlan_vid_add(dev, br->vlan_proto, v->vid); 120 v->priv_flags |= BR_VLFLAG_ADDED_BY_SWITCHDEV; 121 return err; 122 } 123 124 static void __vlan_add_list(struct net_bridge_vlan *v) 125 { 126 struct net_bridge_vlan_group *vg; 127 struct list_head *headp, *hpos; 128 struct net_bridge_vlan *vent; 129 130 if (br_vlan_is_master(v)) 131 vg = br_vlan_group(v->br); 132 else 133 vg = nbp_vlan_group(v->port); 134 135 headp = &vg->vlan_list; 136 list_for_each_prev(hpos, headp) { 137 vent = list_entry(hpos, struct net_bridge_vlan, vlist); 138 if (v->vid >= vent->vid) 139 break; 140 } 141 list_add_rcu(&v->vlist, hpos); 142 } 143 144 static void __vlan_del_list(struct net_bridge_vlan *v) 145 { 146 list_del_rcu(&v->vlist); 147 } 148 149 static int __vlan_vid_del(struct net_device *dev, struct net_bridge *br, 150 const struct net_bridge_vlan *v) 151 { 152 int err; 153 154 /* Try switchdev op first. In case it is not supported, fallback to 155 * 8021q del. 156 */ 157 err = br_switchdev_port_vlan_del(dev, v->vid); 158 if (!(v->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV)) 159 vlan_vid_del(dev, br->vlan_proto, v->vid); 160 return err == -EOPNOTSUPP ? 0 : err; 161 } 162 163 /* Returns a master vlan, if it didn't exist it gets created. In all cases 164 * a reference is taken to the master vlan before returning. 165 */ 166 static struct net_bridge_vlan * 167 br_vlan_get_master(struct net_bridge *br, u16 vid, 168 struct netlink_ext_ack *extack) 169 { 170 struct net_bridge_vlan_group *vg; 171 struct net_bridge_vlan *masterv; 172 173 vg = br_vlan_group(br); 174 masterv = br_vlan_find(vg, vid); 175 if (!masterv) { 176 bool changed; 177 178 /* missing global ctx, create it now */ 179 if (br_vlan_add(br, vid, 0, &changed, extack)) 180 return NULL; 181 masterv = br_vlan_find(vg, vid); 182 if (WARN_ON(!masterv)) 183 return NULL; 184 refcount_set(&masterv->refcnt, 1); 185 return masterv; 186 } 187 refcount_inc(&masterv->refcnt); 188 189 return masterv; 190 } 191 192 static void br_master_vlan_rcu_free(struct rcu_head *rcu) 193 { 194 struct net_bridge_vlan *v; 195 196 v = container_of(rcu, struct net_bridge_vlan, rcu); 197 WARN_ON(!br_vlan_is_master(v)); 198 free_percpu(v->stats); 199 v->stats = NULL; 200 kfree(v); 201 } 202 203 static void br_vlan_put_master(struct net_bridge_vlan *masterv) 204 { 205 struct net_bridge_vlan_group *vg; 206 207 if (!br_vlan_is_master(masterv)) 208 return; 209 210 vg = br_vlan_group(masterv->br); 211 if (refcount_dec_and_test(&masterv->refcnt)) { 212 rhashtable_remove_fast(&vg->vlan_hash, 213 &masterv->vnode, br_vlan_rht_params); 214 __vlan_del_list(masterv); 215 br_multicast_toggle_one_vlan(masterv, false); 216 br_multicast_ctx_deinit(&masterv->br_mcast_ctx); 217 call_rcu(&masterv->rcu, br_master_vlan_rcu_free); 218 } 219 } 220 221 static void nbp_vlan_rcu_free(struct rcu_head *rcu) 222 { 223 struct net_bridge_vlan *v; 224 225 v = container_of(rcu, struct net_bridge_vlan, rcu); 226 WARN_ON(br_vlan_is_master(v)); 227 /* if we had per-port stats configured then free them here */ 228 if (v->priv_flags & BR_VLFLAG_PER_PORT_STATS) 229 free_percpu(v->stats); 230 v->stats = NULL; 231 kfree(v); 232 } 233 234 static void br_vlan_init_state(struct net_bridge_vlan *v) 235 { 236 struct net_bridge *br; 237 238 if (br_vlan_is_master(v)) 239 br = v->br; 240 else 241 br = v->port->br; 242 243 if (br_opt_get(br, BROPT_MST_ENABLED)) { 244 br_mst_vlan_init_state(v); 245 return; 246 } 247 248 v->state = BR_STATE_FORWARDING; 249 v->msti = 0; 250 } 251 252 /* This is the shared VLAN add function which works for both ports and bridge 253 * devices. There are four possible calls to this function in terms of the 254 * vlan entry type: 255 * 1. vlan is being added on a port (no master flags, global entry exists) 256 * 2. vlan is being added on a bridge (both master and brentry flags) 257 * 3. vlan is being added on a port, but a global entry didn't exist which 258 * is being created right now (master flag set, brentry flag unset), the 259 * global entry is used for global per-vlan features, but not for filtering 260 * 4. same as 3 but with both master and brentry flags set so the entry 261 * will be used for filtering in both the port and the bridge 262 */ 263 static int __vlan_add(struct net_bridge_vlan *v, u16 flags, 264 struct netlink_ext_ack *extack) 265 { 266 struct net_bridge_vlan *masterv = NULL; 267 struct net_bridge_port *p = NULL; 268 struct net_bridge_vlan_group *vg; 269 struct net_device *dev; 270 struct net_bridge *br; 271 int err; 272 273 if (br_vlan_is_master(v)) { 274 br = v->br; 275 dev = br->dev; 276 vg = br_vlan_group(br); 277 } else { 278 p = v->port; 279 br = p->br; 280 dev = p->dev; 281 vg = nbp_vlan_group(p); 282 } 283 284 if (p) { 285 /* Add VLAN to the device filter if it is supported. 286 * This ensures tagged traffic enters the bridge when 287 * promiscuous mode is disabled by br_manage_promisc(). 288 */ 289 err = __vlan_vid_add(dev, br, v, flags, extack); 290 if (err) 291 goto out; 292 293 /* need to work on the master vlan too */ 294 if (flags & BRIDGE_VLAN_INFO_MASTER) { 295 bool changed; 296 297 err = br_vlan_add(br, v->vid, 298 flags | BRIDGE_VLAN_INFO_BRENTRY, 299 &changed, extack); 300 if (err) 301 goto out_filt; 302 303 if (changed) 304 br_vlan_notify(br, NULL, v->vid, 0, 305 RTM_NEWVLAN); 306 } 307 308 masterv = br_vlan_get_master(br, v->vid, extack); 309 if (!masterv) { 310 err = -ENOMEM; 311 goto out_filt; 312 } 313 v->brvlan = masterv; 314 if (br_opt_get(br, BROPT_VLAN_STATS_PER_PORT)) { 315 v->stats = 316 netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 317 if (!v->stats) { 318 err = -ENOMEM; 319 goto out_filt; 320 } 321 v->priv_flags |= BR_VLFLAG_PER_PORT_STATS; 322 } else { 323 v->stats = masterv->stats; 324 } 325 br_multicast_port_ctx_init(p, v, &v->port_mcast_ctx); 326 } else { 327 if (br_vlan_should_use(v)) { 328 err = br_switchdev_port_vlan_add(dev, v->vid, flags, 329 false, extack); 330 if (err && err != -EOPNOTSUPP) 331 goto out; 332 } 333 br_multicast_ctx_init(br, v, &v->br_mcast_ctx); 334 v->priv_flags |= BR_VLFLAG_GLOBAL_MCAST_ENABLED; 335 } 336 337 /* Add the dev mac and count the vlan only if it's usable */ 338 if (br_vlan_should_use(v)) { 339 if (!br_opt_get(br, BROPT_FDB_LOCAL_VLAN_0)) { 340 err = br_fdb_add_local(br, p, dev->dev_addr, v->vid); 341 if (err) { 342 br_err(br, "failed insert local address into bridge forwarding table\n"); 343 goto out_filt; 344 } 345 } 346 vg->num_vlans++; 347 } 348 349 /* set the state before publishing */ 350 br_vlan_init_state(v); 351 352 err = rhashtable_lookup_insert_fast(&vg->vlan_hash, &v->vnode, 353 br_vlan_rht_params); 354 if (err) 355 goto out_fdb_insert; 356 357 __vlan_add_list(v); 358 __vlan_flags_commit(v, flags); 359 br_multicast_toggle_one_vlan(v, true); 360 361 if (p) 362 nbp_vlan_set_vlan_dev_state(p, v->vid); 363 out: 364 return err; 365 366 out_fdb_insert: 367 if (br_vlan_should_use(v)) { 368 br_fdb_find_delete_local(br, p, dev->dev_addr, v->vid); 369 vg->num_vlans--; 370 } 371 372 out_filt: 373 if (p) { 374 __vlan_vid_del(dev, br, v); 375 if (masterv) { 376 if (v->stats && masterv->stats != v->stats) 377 free_percpu(v->stats); 378 v->stats = NULL; 379 380 br_vlan_put_master(masterv); 381 v->brvlan = NULL; 382 } 383 } else { 384 br_switchdev_port_vlan_del(dev, v->vid); 385 } 386 387 goto out; 388 } 389 390 static void __vlan_del(struct net_bridge_vlan *v) 391 { 392 struct net_bridge_vlan *masterv = v; 393 struct net_bridge_vlan_group *vg; 394 struct net_bridge_port *p = NULL; 395 int err; 396 397 if (br_vlan_is_master(v)) { 398 vg = br_vlan_group(v->br); 399 } else { 400 p = v->port; 401 vg = nbp_vlan_group(v->port); 402 masterv = v->brvlan; 403 } 404 405 __vlan_delete_pvid(vg, v->vid); 406 if (p) { 407 err = __vlan_vid_del(p->dev, p->br, v); 408 if (err) 409 br_warn(p->br, 410 "port %u(%s) failed to delete vlan %u from switchdev: %pe\n", 411 (unsigned int)p->port_no, p->dev->name, 412 v->vid, ERR_PTR(err)); 413 } else { 414 err = br_switchdev_port_vlan_del(v->br->dev, v->vid); 415 if (err && err != -EOPNOTSUPP) 416 br_warn(v->br, 417 "failed to delete bridge vlan %u from switchdev: %pe\n", 418 v->vid, ERR_PTR(err)); 419 } 420 421 if (br_vlan_should_use(v)) { 422 v->flags &= ~BRIDGE_VLAN_INFO_BRENTRY; 423 vg->num_vlans--; 424 } 425 426 if (masterv != v) { 427 vlan_tunnel_info_del(vg, v); 428 rhashtable_remove_fast(&vg->vlan_hash, &v->vnode, 429 br_vlan_rht_params); 430 __vlan_del_list(v); 431 nbp_vlan_set_vlan_dev_state(p, v->vid); 432 br_multicast_toggle_one_vlan(v, false); 433 br_multicast_port_ctx_deinit(&v->port_mcast_ctx); 434 call_rcu(&v->rcu, nbp_vlan_rcu_free); 435 } 436 437 br_vlan_put_master(masterv); 438 } 439 440 static void __vlan_group_free(struct net_bridge_vlan_group *vg) 441 { 442 WARN_ON(!list_empty(&vg->vlan_list)); 443 rhashtable_destroy(&vg->vlan_hash); 444 vlan_tunnel_deinit(vg); 445 kfree(vg); 446 } 447 448 static void __vlan_flush(const struct net_bridge *br, 449 const struct net_bridge_port *p, 450 struct net_bridge_vlan_group *vg) 451 { 452 struct net_bridge_vlan *vlan, *tmp; 453 u16 v_start = 0, v_end = 0; 454 455 __vlan_delete_pvid(vg, vg->pvid); 456 list_for_each_entry_safe(vlan, tmp, &vg->vlan_list, vlist) { 457 /* take care of disjoint ranges */ 458 if (!v_start) { 459 v_start = vlan->vid; 460 } else if (vlan->vid - v_end != 1) { 461 /* found range end, notify and start next one */ 462 br_vlan_notify(br, p, v_start, v_end, RTM_DELVLAN); 463 v_start = vlan->vid; 464 } 465 v_end = vlan->vid; 466 467 __vlan_del(vlan); 468 } 469 470 /* notify about the last/whole vlan range */ 471 if (v_start) 472 br_vlan_notify(br, p, v_start, v_end, RTM_DELVLAN); 473 } 474 475 struct sk_buff *br_handle_vlan(struct net_bridge *br, 476 const struct net_bridge_port *p, 477 struct net_bridge_vlan_group *vg, 478 struct sk_buff *skb) 479 { 480 struct pcpu_sw_netstats *stats; 481 struct net_bridge_vlan *v; 482 u16 vid; 483 484 /* If this packet was not filtered at input, let it pass */ 485 if (!BR_INPUT_SKB_CB(skb)->vlan_filtered) 486 goto out; 487 488 /* At this point, we know that the frame was filtered and contains 489 * a valid vlan id. If the vlan id has untagged flag set, 490 * send untagged; otherwise, send tagged. 491 */ 492 br_vlan_get_tag(skb, &vid); 493 v = br_vlan_find(vg, vid); 494 /* Vlan entry must be configured at this point. The 495 * only exception is the bridge is set in promisc mode and the 496 * packet is destined for the bridge device. In this case 497 * pass the packet as is. 498 */ 499 if (!v || !br_vlan_should_use(v)) { 500 if ((br->dev->flags & IFF_PROMISC) && skb->dev == br->dev) { 501 goto out; 502 } else { 503 kfree_skb(skb); 504 return NULL; 505 } 506 } 507 if (br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) { 508 stats = this_cpu_ptr(v->stats); 509 u64_stats_update_begin(&stats->syncp); 510 u64_stats_add(&stats->tx_bytes, skb->len); 511 u64_stats_inc(&stats->tx_packets); 512 u64_stats_update_end(&stats->syncp); 513 } 514 515 /* If the skb will be sent using forwarding offload, the assumption is 516 * that the switchdev will inject the packet into hardware together 517 * with the bridge VLAN, so that it can be forwarded according to that 518 * VLAN. The switchdev should deal with popping the VLAN header in 519 * hardware on each egress port as appropriate. So only strip the VLAN 520 * header if forwarding offload is not being used. 521 */ 522 if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED && 523 !br_switchdev_frame_uses_tx_fwd_offload(skb)) 524 __vlan_hwaccel_clear_tag(skb); 525 526 if (p && (p->flags & BR_VLAN_TUNNEL) && 527 br_handle_egress_vlan_tunnel(skb, v)) { 528 kfree_skb(skb); 529 return NULL; 530 } 531 out: 532 return skb; 533 } 534 535 /* Called under RCU */ 536 static bool __allowed_ingress(const struct net_bridge *br, 537 struct net_bridge_vlan_group *vg, 538 struct sk_buff *skb, u16 *vid, 539 u8 *state, 540 struct net_bridge_vlan **vlan) 541 { 542 struct pcpu_sw_netstats *stats; 543 struct net_bridge_vlan *v; 544 bool tagged; 545 546 BR_INPUT_SKB_CB(skb)->vlan_filtered = true; 547 /* If vlan tx offload is disabled on bridge device and frame was 548 * sent from vlan device on the bridge device, it does not have 549 * HW accelerated vlan tag. 550 */ 551 if (unlikely(!skb_vlan_tag_present(skb) && 552 skb->protocol == br->vlan_proto)) { 553 skb = skb_vlan_untag(skb); 554 if (unlikely(!skb)) 555 return false; 556 } 557 558 if (!br_vlan_get_tag(skb, vid)) { 559 /* Tagged frame */ 560 if (skb->vlan_proto != br->vlan_proto) { 561 /* Protocol-mismatch, empty out vlan_tci for new tag */ 562 skb_push(skb, ETH_HLEN); 563 skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto, 564 skb_vlan_tag_get(skb)); 565 if (unlikely(!skb)) 566 return false; 567 568 skb_pull(skb, ETH_HLEN); 569 skb_reset_mac_len(skb); 570 *vid = 0; 571 tagged = false; 572 } else { 573 tagged = true; 574 } 575 } else { 576 /* Untagged frame */ 577 tagged = false; 578 } 579 580 if (!*vid) { 581 u16 pvid = br_get_pvid(vg); 582 583 /* Frame had a tag with VID 0 or did not have a tag. 584 * See if pvid is set on this port. That tells us which 585 * vlan untagged or priority-tagged traffic belongs to. 586 */ 587 if (!pvid) 588 goto drop; 589 590 /* PVID is set on this port. Any untagged or priority-tagged 591 * ingress frame is considered to belong to this vlan. 592 */ 593 *vid = pvid; 594 if (likely(!tagged)) 595 /* Untagged Frame. */ 596 __vlan_hwaccel_put_tag(skb, br->vlan_proto, pvid); 597 else 598 /* Priority-tagged Frame. 599 * At this point, we know that skb->vlan_tci VID 600 * field was 0. 601 * We update only VID field and preserve PCP field. 602 */ 603 skb->vlan_tci |= pvid; 604 605 /* if snooping and stats are disabled we can avoid the lookup */ 606 if (!br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED) && 607 !br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) { 608 if (*state == BR_STATE_FORWARDING) { 609 *state = br_vlan_get_pvid_state(vg); 610 if (!br_vlan_state_allowed(*state, true)) 611 goto drop; 612 } 613 return true; 614 } 615 } 616 v = br_vlan_find(vg, *vid); 617 if (!v || !br_vlan_should_use(v)) 618 goto drop; 619 620 if (*state == BR_STATE_FORWARDING) { 621 *state = br_vlan_get_state(v); 622 if (!br_vlan_state_allowed(*state, true)) 623 goto drop; 624 } 625 626 if (br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) { 627 stats = this_cpu_ptr(v->stats); 628 u64_stats_update_begin(&stats->syncp); 629 u64_stats_add(&stats->rx_bytes, skb->len); 630 u64_stats_inc(&stats->rx_packets); 631 u64_stats_update_end(&stats->syncp); 632 } 633 634 *vlan = v; 635 636 return true; 637 638 drop: 639 kfree_skb(skb); 640 return false; 641 } 642 643 bool br_allowed_ingress(const struct net_bridge *br, 644 struct net_bridge_vlan_group *vg, struct sk_buff *skb, 645 u16 *vid, u8 *state, 646 struct net_bridge_vlan **vlan) 647 { 648 /* If VLAN filtering is disabled on the bridge, all packets are 649 * permitted. 650 */ 651 *vlan = NULL; 652 if (!br_opt_get(br, BROPT_VLAN_ENABLED)) { 653 BR_INPUT_SKB_CB(skb)->vlan_filtered = false; 654 return true; 655 } 656 657 return __allowed_ingress(br, vg, skb, vid, state, vlan); 658 } 659 660 /* Called under RCU. */ 661 bool br_allowed_egress(struct net_bridge_vlan_group *vg, 662 const struct sk_buff *skb) 663 { 664 const struct net_bridge_vlan *v; 665 u16 vid; 666 667 /* If this packet was not filtered at input, let it pass */ 668 if (!BR_INPUT_SKB_CB(skb)->vlan_filtered) 669 return true; 670 671 br_vlan_get_tag(skb, &vid); 672 v = br_vlan_find(vg, vid); 673 if (v && br_vlan_should_use(v) && 674 br_vlan_state_allowed(br_vlan_get_state(v), false)) 675 return true; 676 677 return false; 678 } 679 680 /* Called under RCU */ 681 bool br_should_learn(struct net_bridge_port *p, struct sk_buff *skb, u16 *vid) 682 { 683 struct net_bridge_vlan_group *vg; 684 struct net_bridge *br = p->br; 685 struct net_bridge_vlan *v; 686 687 /* If filtering was disabled at input, let it pass. */ 688 if (!br_opt_get(br, BROPT_VLAN_ENABLED)) 689 return true; 690 691 vg = nbp_vlan_group_rcu(p); 692 if (!vg || !vg->num_vlans) 693 return false; 694 695 if (!br_vlan_get_tag(skb, vid) && skb->vlan_proto != br->vlan_proto) 696 *vid = 0; 697 698 if (!*vid) { 699 *vid = br_get_pvid(vg); 700 if (!*vid || 701 !br_vlan_state_allowed(br_vlan_get_pvid_state(vg), true)) 702 return false; 703 704 return true; 705 } 706 707 v = br_vlan_find(vg, *vid); 708 if (v && br_vlan_state_allowed(br_vlan_get_state(v), true)) 709 return true; 710 711 return false; 712 } 713 714 static int br_vlan_add_existing(struct net_bridge *br, 715 struct net_bridge_vlan_group *vg, 716 struct net_bridge_vlan *vlan, 717 u16 flags, bool *changed, 718 struct netlink_ext_ack *extack) 719 { 720 bool becomes_brentry = false; 721 bool would_change = false; 722 int err; 723 724 if (!br_vlan_is_brentry(vlan)) { 725 /* Trying to change flags of non-existent bridge vlan */ 726 if (!(flags & BRIDGE_VLAN_INFO_BRENTRY)) 727 return -EINVAL; 728 729 becomes_brentry = true; 730 } else { 731 would_change = __vlan_flags_would_change(vlan, flags); 732 } 733 734 /* Master VLANs that aren't brentries weren't notified before, 735 * time to notify them now. 736 */ 737 if (becomes_brentry || would_change) { 738 err = br_switchdev_port_vlan_add(br->dev, vlan->vid, flags, 739 would_change, extack); 740 if (err && err != -EOPNOTSUPP) 741 return err; 742 } 743 744 if (becomes_brentry) { 745 /* It was only kept for port vlans, now make it real */ 746 err = br_fdb_add_local(br, NULL, br->dev->dev_addr, vlan->vid); 747 if (err) { 748 br_err(br, "failed to insert local address into bridge forwarding table\n"); 749 goto err_fdb_insert; 750 } 751 752 refcount_inc(&vlan->refcnt); 753 vlan->flags |= BRIDGE_VLAN_INFO_BRENTRY; 754 vg->num_vlans++; 755 *changed = true; 756 br_multicast_toggle_one_vlan(vlan, true); 757 } 758 759 __vlan_flags_commit(vlan, flags); 760 if (would_change) 761 *changed = true; 762 763 return 0; 764 765 err_fdb_insert: 766 br_switchdev_port_vlan_del(br->dev, vlan->vid); 767 return err; 768 } 769 770 /* Must be protected by RTNL. 771 * Must be called with vid in range from 1 to 4094 inclusive. 772 * changed must be true only if the vlan was created or updated 773 */ 774 int br_vlan_add(struct net_bridge *br, u16 vid, u16 flags, bool *changed, 775 struct netlink_ext_ack *extack) 776 { 777 struct net_bridge_vlan_group *vg; 778 struct net_bridge_vlan *vlan; 779 int ret; 780 781 ASSERT_RTNL(); 782 783 *changed = false; 784 vg = br_vlan_group(br); 785 vlan = br_vlan_find(vg, vid); 786 if (vlan) 787 return br_vlan_add_existing(br, vg, vlan, flags, changed, 788 extack); 789 790 vlan = kzalloc_obj(*vlan); 791 if (!vlan) 792 return -ENOMEM; 793 794 vlan->stats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats); 795 if (!vlan->stats) { 796 kfree(vlan); 797 return -ENOMEM; 798 } 799 vlan->vid = vid; 800 vlan->flags = flags | BRIDGE_VLAN_INFO_MASTER; 801 vlan->flags &= ~BRIDGE_VLAN_INFO_PVID; 802 vlan->br = br; 803 if (flags & BRIDGE_VLAN_INFO_BRENTRY) 804 refcount_set(&vlan->refcnt, 1); 805 ret = __vlan_add(vlan, flags, extack); 806 if (ret) { 807 free_percpu(vlan->stats); 808 kfree(vlan); 809 } else { 810 *changed = true; 811 } 812 813 return ret; 814 } 815 816 /* Must be protected by RTNL. 817 * Must be called with vid in range from 1 to 4094 inclusive. 818 */ 819 int br_vlan_delete(struct net_bridge *br, u16 vid) 820 { 821 struct net_bridge_vlan_group *vg; 822 struct net_bridge_vlan *v; 823 824 ASSERT_RTNL(); 825 826 vg = br_vlan_group(br); 827 v = br_vlan_find(vg, vid); 828 if (!v || !br_vlan_is_brentry(v)) 829 return -ENOENT; 830 831 br_fdb_find_delete_local(br, NULL, br->dev->dev_addr, vid); 832 br_fdb_delete_by_port(br, NULL, vid, 0); 833 834 vlan_tunnel_info_del(vg, v); 835 __vlan_del(v); 836 837 return 0; 838 } 839 840 void br_vlan_flush(struct net_bridge *br) 841 { 842 struct net_bridge_vlan_group *vg; 843 844 ASSERT_RTNL(); 845 846 vg = br_vlan_group(br); 847 __vlan_flush(br, NULL, vg); 848 RCU_INIT_POINTER(br->vlgrp, NULL); 849 synchronize_net(); 850 __vlan_group_free(vg); 851 } 852 853 struct net_bridge_vlan *br_vlan_find(struct net_bridge_vlan_group *vg, u16 vid) 854 { 855 if (!vg) 856 return NULL; 857 858 return br_vlan_lookup(&vg->vlan_hash, vid); 859 } 860 861 /* Must be protected by RTNL. */ 862 static void recalculate_group_addr(struct net_bridge *br) 863 { 864 if (br_opt_get(br, BROPT_GROUP_ADDR_SET)) 865 return; 866 867 spin_lock_bh(&br->lock); 868 if (!br_opt_get(br, BROPT_VLAN_ENABLED) || 869 br->vlan_proto == htons(ETH_P_8021Q)) { 870 /* Bridge Group Address */ 871 br->group_addr[5] = 0x00; 872 } else { /* vlan_enabled && ETH_P_8021AD */ 873 /* Provider Bridge Group Address */ 874 br->group_addr[5] = 0x08; 875 } 876 spin_unlock_bh(&br->lock); 877 } 878 879 /* Must be protected by RTNL. */ 880 void br_recalculate_fwd_mask(struct net_bridge *br) 881 { 882 if (!br_opt_get(br, BROPT_VLAN_ENABLED) || 883 br->vlan_proto == htons(ETH_P_8021Q)) 884 br->group_fwd_mask_required = BR_GROUPFWD_DEFAULT; 885 else /* vlan_enabled && ETH_P_8021AD */ 886 br->group_fwd_mask_required = BR_GROUPFWD_8021AD & 887 ~(1u << br->group_addr[5]); 888 } 889 890 int br_vlan_filter_toggle(struct net_bridge *br, unsigned long val, 891 struct netlink_ext_ack *extack) 892 { 893 struct switchdev_attr attr = { 894 .orig_dev = br->dev, 895 .id = SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING, 896 .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP, 897 .u.vlan_filtering = val, 898 }; 899 int err; 900 901 if (br_opt_get(br, BROPT_VLAN_ENABLED) == !!val) 902 return 0; 903 904 br_opt_toggle(br, BROPT_VLAN_ENABLED, !!val); 905 906 err = switchdev_port_attr_set(br->dev, &attr, extack); 907 if (err && err != -EOPNOTSUPP) { 908 br_opt_toggle(br, BROPT_VLAN_ENABLED, !val); 909 return err; 910 } 911 912 br_manage_promisc(br); 913 recalculate_group_addr(br); 914 br_recalculate_fwd_mask(br); 915 if (!val && br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED)) { 916 br_info(br, "vlan filtering disabled, automatically disabling multicast vlan snooping\n"); 917 br_multicast_toggle_vlan_snooping(br, false, NULL); 918 } 919 920 return 0; 921 } 922 923 bool br_vlan_enabled(const struct net_device *dev) 924 { 925 struct net_bridge *br = netdev_priv(dev); 926 927 return br_opt_get(br, BROPT_VLAN_ENABLED); 928 } 929 EXPORT_SYMBOL_GPL(br_vlan_enabled); 930 931 int br_vlan_get_proto(const struct net_device *dev, u16 *p_proto) 932 { 933 struct net_bridge *br = netdev_priv(dev); 934 935 *p_proto = ntohs(br->vlan_proto); 936 937 return 0; 938 } 939 EXPORT_SYMBOL_GPL(br_vlan_get_proto); 940 941 int __br_vlan_set_proto(struct net_bridge *br, __be16 proto, 942 struct netlink_ext_ack *extack) 943 { 944 struct switchdev_attr attr = { 945 .orig_dev = br->dev, 946 .id = SWITCHDEV_ATTR_ID_BRIDGE_VLAN_PROTOCOL, 947 .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP, 948 .u.vlan_protocol = ntohs(proto), 949 }; 950 int err = 0; 951 struct net_bridge_port *p; 952 struct net_bridge_vlan *vlan; 953 struct net_bridge_vlan_group *vg; 954 __be16 oldproto = br->vlan_proto; 955 956 if (br->vlan_proto == proto) 957 return 0; 958 959 err = switchdev_port_attr_set(br->dev, &attr, extack); 960 if (err && err != -EOPNOTSUPP) 961 return err; 962 963 /* Add VLANs for the new proto to the device filter. */ 964 list_for_each_entry(p, &br->port_list, list) { 965 vg = nbp_vlan_group(p); 966 list_for_each_entry(vlan, &vg->vlan_list, vlist) { 967 if (vlan->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV) 968 continue; 969 err = vlan_vid_add(p->dev, proto, vlan->vid); 970 if (err) 971 goto err_filt; 972 } 973 } 974 975 br->vlan_proto = proto; 976 977 recalculate_group_addr(br); 978 br_recalculate_fwd_mask(br); 979 980 /* Delete VLANs for the old proto from the device filter. */ 981 list_for_each_entry(p, &br->port_list, list) { 982 vg = nbp_vlan_group(p); 983 list_for_each_entry(vlan, &vg->vlan_list, vlist) { 984 if (vlan->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV) 985 continue; 986 vlan_vid_del(p->dev, oldproto, vlan->vid); 987 } 988 } 989 990 return 0; 991 992 err_filt: 993 attr.u.vlan_protocol = ntohs(oldproto); 994 switchdev_port_attr_set(br->dev, &attr, NULL); 995 996 list_for_each_entry_continue_reverse(vlan, &vg->vlan_list, vlist) { 997 if (vlan->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV) 998 continue; 999 vlan_vid_del(p->dev, proto, vlan->vid); 1000 } 1001 1002 list_for_each_entry_continue_reverse(p, &br->port_list, list) { 1003 vg = nbp_vlan_group(p); 1004 list_for_each_entry(vlan, &vg->vlan_list, vlist) { 1005 if (vlan->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV) 1006 continue; 1007 vlan_vid_del(p->dev, proto, vlan->vid); 1008 } 1009 } 1010 1011 return err; 1012 } 1013 1014 int br_vlan_set_proto(struct net_bridge *br, unsigned long val, 1015 struct netlink_ext_ack *extack) 1016 { 1017 if (!eth_type_vlan(htons(val))) 1018 return -EPROTONOSUPPORT; 1019 1020 return __br_vlan_set_proto(br, htons(val), extack); 1021 } 1022 1023 int br_vlan_set_stats(struct net_bridge *br, unsigned long val) 1024 { 1025 switch (val) { 1026 case 0: 1027 case 1: 1028 br_opt_toggle(br, BROPT_VLAN_STATS_ENABLED, !!val); 1029 break; 1030 default: 1031 return -EINVAL; 1032 } 1033 1034 return 0; 1035 } 1036 1037 int br_vlan_set_stats_per_port(struct net_bridge *br, unsigned long val) 1038 { 1039 struct net_bridge_port *p; 1040 1041 /* allow to change the option if there are no port vlans configured */ 1042 list_for_each_entry(p, &br->port_list, list) { 1043 struct net_bridge_vlan_group *vg = nbp_vlan_group(p); 1044 1045 if (vg->num_vlans) 1046 return -EBUSY; 1047 } 1048 1049 switch (val) { 1050 case 0: 1051 case 1: 1052 br_opt_toggle(br, BROPT_VLAN_STATS_PER_PORT, !!val); 1053 break; 1054 default: 1055 return -EINVAL; 1056 } 1057 1058 return 0; 1059 } 1060 1061 static bool vlan_default_pvid(struct net_bridge_vlan_group *vg, u16 vid) 1062 { 1063 struct net_bridge_vlan *v; 1064 1065 if (vid != vg->pvid) 1066 return false; 1067 1068 v = br_vlan_lookup(&vg->vlan_hash, vid); 1069 if (v && br_vlan_should_use(v) && 1070 (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)) 1071 return true; 1072 1073 return false; 1074 } 1075 1076 static void br_vlan_disable_default_pvid(struct net_bridge *br) 1077 { 1078 struct net_bridge_port *p; 1079 u16 pvid = br->default_pvid; 1080 1081 /* Disable default_pvid on all ports where it is still 1082 * configured. 1083 */ 1084 if (vlan_default_pvid(br_vlan_group(br), pvid)) { 1085 if (!br_vlan_delete(br, pvid)) 1086 br_vlan_notify(br, NULL, pvid, 0, RTM_DELVLAN); 1087 } 1088 1089 list_for_each_entry(p, &br->port_list, list) { 1090 if (vlan_default_pvid(nbp_vlan_group(p), pvid) && 1091 !nbp_vlan_delete(p, pvid)) 1092 br_vlan_notify(br, p, pvid, 0, RTM_DELVLAN); 1093 } 1094 1095 br->default_pvid = 0; 1096 } 1097 1098 int __br_vlan_set_default_pvid(struct net_bridge *br, u16 pvid, 1099 struct netlink_ext_ack *extack) 1100 { 1101 const struct net_bridge_vlan *pvent; 1102 struct net_bridge_vlan_group *vg; 1103 struct net_bridge_port *p; 1104 unsigned long *changed; 1105 bool vlchange; 1106 u16 old_pvid; 1107 int err = 0; 1108 1109 if (!pvid) { 1110 br_vlan_disable_default_pvid(br); 1111 return 0; 1112 } 1113 1114 changed = bitmap_zalloc(BR_MAX_PORTS, GFP_KERNEL); 1115 if (!changed) 1116 return -ENOMEM; 1117 1118 old_pvid = br->default_pvid; 1119 1120 /* Update default_pvid config only if we do not conflict with 1121 * user configuration. 1122 */ 1123 vg = br_vlan_group(br); 1124 pvent = br_vlan_find(vg, pvid); 1125 if ((!old_pvid || vlan_default_pvid(vg, old_pvid)) && 1126 (!pvent || !br_vlan_should_use(pvent))) { 1127 err = br_vlan_add(br, pvid, 1128 BRIDGE_VLAN_INFO_PVID | 1129 BRIDGE_VLAN_INFO_UNTAGGED | 1130 BRIDGE_VLAN_INFO_BRENTRY, 1131 &vlchange, extack); 1132 if (err) 1133 goto out; 1134 1135 if (!br_vlan_delete(br, old_pvid)) 1136 br_vlan_notify(br, NULL, old_pvid, 0, RTM_DELVLAN); 1137 br_vlan_notify(br, NULL, pvid, 0, RTM_NEWVLAN); 1138 __set_bit(0, changed); 1139 } 1140 1141 list_for_each_entry(p, &br->port_list, list) { 1142 /* Update default_pvid config only if we do not conflict with 1143 * user configuration. 1144 */ 1145 vg = nbp_vlan_group(p); 1146 if ((old_pvid && 1147 !vlan_default_pvid(vg, old_pvid)) || 1148 br_vlan_find(vg, pvid)) 1149 continue; 1150 1151 err = nbp_vlan_add(p, pvid, 1152 BRIDGE_VLAN_INFO_PVID | 1153 BRIDGE_VLAN_INFO_UNTAGGED, 1154 &vlchange, extack); 1155 if (err) 1156 goto err_port; 1157 if (!nbp_vlan_delete(p, old_pvid)) 1158 br_vlan_notify(br, p, old_pvid, 0, RTM_DELVLAN); 1159 br_vlan_notify(p->br, p, pvid, 0, RTM_NEWVLAN); 1160 __set_bit(p->port_no, changed); 1161 } 1162 1163 br->default_pvid = pvid; 1164 1165 out: 1166 bitmap_free(changed); 1167 return err; 1168 1169 err_port: 1170 list_for_each_entry_continue_reverse(p, &br->port_list, list) { 1171 if (!test_bit(p->port_no, changed)) 1172 continue; 1173 1174 if (old_pvid) { 1175 nbp_vlan_add(p, old_pvid, 1176 BRIDGE_VLAN_INFO_PVID | 1177 BRIDGE_VLAN_INFO_UNTAGGED, 1178 &vlchange, NULL); 1179 br_vlan_notify(p->br, p, old_pvid, 0, RTM_NEWVLAN); 1180 } 1181 nbp_vlan_delete(p, pvid); 1182 br_vlan_notify(br, p, pvid, 0, RTM_DELVLAN); 1183 } 1184 1185 if (test_bit(0, changed)) { 1186 if (old_pvid) { 1187 br_vlan_add(br, old_pvid, 1188 BRIDGE_VLAN_INFO_PVID | 1189 BRIDGE_VLAN_INFO_UNTAGGED | 1190 BRIDGE_VLAN_INFO_BRENTRY, 1191 &vlchange, NULL); 1192 br_vlan_notify(br, NULL, old_pvid, 0, RTM_NEWVLAN); 1193 } 1194 br_vlan_delete(br, pvid); 1195 br_vlan_notify(br, NULL, pvid, 0, RTM_DELVLAN); 1196 } 1197 goto out; 1198 } 1199 1200 int br_vlan_set_default_pvid(struct net_bridge *br, unsigned long val, 1201 struct netlink_ext_ack *extack) 1202 { 1203 u16 pvid = val; 1204 int err = 0; 1205 1206 if (val >= VLAN_VID_MASK) 1207 return -EINVAL; 1208 1209 if (pvid == br->default_pvid) 1210 goto out; 1211 1212 /* Only allow default pvid change when filtering is disabled */ 1213 if (br_opt_get(br, BROPT_VLAN_ENABLED)) { 1214 pr_info_once("Please disable vlan filtering to change default_pvid\n"); 1215 err = -EPERM; 1216 goto out; 1217 } 1218 err = __br_vlan_set_default_pvid(br, pvid, extack); 1219 out: 1220 return err; 1221 } 1222 1223 int br_vlan_init(struct net_bridge *br) 1224 { 1225 struct net_bridge_vlan_group *vg; 1226 int ret = -ENOMEM; 1227 1228 vg = kzalloc_obj(*vg); 1229 if (!vg) 1230 goto out; 1231 ret = rhashtable_init(&vg->vlan_hash, &br_vlan_rht_params); 1232 if (ret) 1233 goto err_rhtbl; 1234 ret = vlan_tunnel_init(vg); 1235 if (ret) 1236 goto err_tunnel_init; 1237 INIT_LIST_HEAD(&vg->vlan_list); 1238 br->vlan_proto = htons(ETH_P_8021Q); 1239 br->default_pvid = 1; 1240 rcu_assign_pointer(br->vlgrp, vg); 1241 1242 out: 1243 return ret; 1244 1245 err_tunnel_init: 1246 rhashtable_destroy(&vg->vlan_hash); 1247 err_rhtbl: 1248 kfree(vg); 1249 1250 goto out; 1251 } 1252 1253 int nbp_vlan_init(struct net_bridge_port *p, struct netlink_ext_ack *extack) 1254 { 1255 struct switchdev_attr attr = { 1256 .orig_dev = p->br->dev, 1257 .id = SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING, 1258 .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP, 1259 .u.vlan_filtering = br_opt_get(p->br, BROPT_VLAN_ENABLED), 1260 }; 1261 struct net_bridge_vlan_group *vg; 1262 int ret = -ENOMEM; 1263 1264 vg = kzalloc_obj(struct net_bridge_vlan_group); 1265 if (!vg) 1266 goto out; 1267 1268 ret = switchdev_port_attr_set(p->dev, &attr, extack); 1269 if (ret && ret != -EOPNOTSUPP) 1270 goto err_vlan_enabled; 1271 1272 ret = rhashtable_init(&vg->vlan_hash, &br_vlan_rht_params); 1273 if (ret) 1274 goto err_rhtbl; 1275 ret = vlan_tunnel_init(vg); 1276 if (ret) 1277 goto err_tunnel_init; 1278 INIT_LIST_HEAD(&vg->vlan_list); 1279 rcu_assign_pointer(p->vlgrp, vg); 1280 if (p->br->default_pvid) { 1281 bool changed; 1282 1283 ret = nbp_vlan_add(p, p->br->default_pvid, 1284 BRIDGE_VLAN_INFO_PVID | 1285 BRIDGE_VLAN_INFO_UNTAGGED, 1286 &changed, extack); 1287 if (ret) 1288 goto err_vlan_add; 1289 br_vlan_notify(p->br, p, p->br->default_pvid, 0, RTM_NEWVLAN); 1290 } 1291 out: 1292 return ret; 1293 1294 err_vlan_add: 1295 RCU_INIT_POINTER(p->vlgrp, NULL); 1296 synchronize_rcu(); 1297 vlan_tunnel_deinit(vg); 1298 err_tunnel_init: 1299 rhashtable_destroy(&vg->vlan_hash); 1300 err_rhtbl: 1301 err_vlan_enabled: 1302 kfree(vg); 1303 1304 goto out; 1305 } 1306 1307 /* Must be protected by RTNL. 1308 * Must be called with vid in range from 1 to 4094 inclusive. 1309 * changed must be true only if the vlan was created or updated 1310 */ 1311 int nbp_vlan_add(struct net_bridge_port *port, u16 vid, u16 flags, 1312 bool *changed, struct netlink_ext_ack *extack) 1313 { 1314 struct net_bridge_vlan *vlan; 1315 int ret; 1316 1317 ASSERT_RTNL(); 1318 1319 *changed = false; 1320 vlan = br_vlan_find(nbp_vlan_group(port), vid); 1321 if (vlan) { 1322 bool would_change = __vlan_flags_would_change(vlan, flags); 1323 1324 if (would_change) { 1325 /* Pass the flags to the hardware bridge */ 1326 ret = br_switchdev_port_vlan_add(port->dev, vid, flags, 1327 true, extack); 1328 if (ret && ret != -EOPNOTSUPP) 1329 return ret; 1330 } 1331 1332 __vlan_flags_commit(vlan, flags); 1333 *changed = would_change; 1334 1335 return 0; 1336 } 1337 1338 vlan = kzalloc_obj(*vlan); 1339 if (!vlan) 1340 return -ENOMEM; 1341 1342 vlan->vid = vid; 1343 vlan->port = port; 1344 ret = __vlan_add(vlan, flags, extack); 1345 if (ret) 1346 kfree(vlan); 1347 else 1348 *changed = true; 1349 1350 return ret; 1351 } 1352 1353 /* Must be protected by RTNL. 1354 * Must be called with vid in range from 1 to 4094 inclusive. 1355 */ 1356 int nbp_vlan_delete(struct net_bridge_port *port, u16 vid) 1357 { 1358 struct net_bridge_vlan *v; 1359 1360 ASSERT_RTNL(); 1361 1362 v = br_vlan_find(nbp_vlan_group(port), vid); 1363 if (!v) 1364 return -ENOENT; 1365 br_fdb_find_delete_local(port->br, port, port->dev->dev_addr, vid); 1366 br_fdb_delete_by_port(port->br, port, vid, 0); 1367 __vlan_del(v); 1368 1369 return 0; 1370 } 1371 1372 void nbp_vlan_flush(struct net_bridge_port *port) 1373 { 1374 struct net_bridge_vlan_group *vg; 1375 1376 ASSERT_RTNL(); 1377 1378 vg = nbp_vlan_group(port); 1379 __vlan_flush(port->br, port, vg); 1380 RCU_INIT_POINTER(port->vlgrp, NULL); 1381 synchronize_net(); 1382 __vlan_group_free(vg); 1383 } 1384 1385 void br_vlan_get_stats(const struct net_bridge_vlan *v, 1386 struct pcpu_sw_netstats *stats) 1387 { 1388 int i; 1389 1390 memset(stats, 0, sizeof(*stats)); 1391 for_each_possible_cpu(i) { 1392 u64 rxpackets, rxbytes, txpackets, txbytes; 1393 struct pcpu_sw_netstats *cpu_stats; 1394 unsigned int start; 1395 1396 cpu_stats = per_cpu_ptr(v->stats, i); 1397 do { 1398 start = u64_stats_fetch_begin(&cpu_stats->syncp); 1399 rxpackets = u64_stats_read(&cpu_stats->rx_packets); 1400 rxbytes = u64_stats_read(&cpu_stats->rx_bytes); 1401 txbytes = u64_stats_read(&cpu_stats->tx_bytes); 1402 txpackets = u64_stats_read(&cpu_stats->tx_packets); 1403 } while (u64_stats_fetch_retry(&cpu_stats->syncp, start)); 1404 1405 u64_stats_add(&stats->rx_packets, rxpackets); 1406 u64_stats_add(&stats->rx_bytes, rxbytes); 1407 u64_stats_add(&stats->tx_bytes, txbytes); 1408 u64_stats_add(&stats->tx_packets, txpackets); 1409 } 1410 } 1411 1412 int br_vlan_get_pvid(const struct net_device *dev, u16 *p_pvid) 1413 { 1414 struct net_bridge_vlan_group *vg; 1415 struct net_bridge_port *p; 1416 1417 ASSERT_RTNL(); 1418 p = br_port_get_check_rtnl(dev); 1419 if (p) 1420 vg = nbp_vlan_group(p); 1421 else if (netif_is_bridge_master(dev)) 1422 vg = br_vlan_group(netdev_priv(dev)); 1423 else 1424 return -EINVAL; 1425 1426 *p_pvid = br_get_pvid(vg); 1427 return 0; 1428 } 1429 EXPORT_SYMBOL_GPL(br_vlan_get_pvid); 1430 1431 int br_vlan_get_pvid_rcu(const struct net_device *dev, u16 *p_pvid) 1432 { 1433 struct net_bridge_vlan_group *vg; 1434 struct net_bridge_port *p; 1435 1436 p = br_port_get_check_rcu(dev); 1437 if (p) 1438 vg = nbp_vlan_group_rcu(p); 1439 else if (netif_is_bridge_master(dev)) 1440 vg = br_vlan_group_rcu(netdev_priv(dev)); 1441 else 1442 return -EINVAL; 1443 1444 *p_pvid = br_get_pvid(vg); 1445 return 0; 1446 } 1447 EXPORT_SYMBOL_GPL(br_vlan_get_pvid_rcu); 1448 1449 void br_vlan_fill_forward_path_pvid(struct net_bridge *br, 1450 struct net_device_path_ctx *ctx, 1451 struct net_device_path *path) 1452 { 1453 struct net_bridge_vlan_group *vg; 1454 int idx = ctx->num_vlans - 1; 1455 u16 vid; 1456 1457 path->bridge.vlan_mode = DEV_PATH_BR_VLAN_KEEP; 1458 1459 if (!br_opt_get(br, BROPT_VLAN_ENABLED)) 1460 return; 1461 1462 vg = br_vlan_group_rcu(br); 1463 1464 if (idx >= 0 && 1465 ctx->vlan[idx].proto == br->vlan_proto) { 1466 vid = ctx->vlan[idx].id; 1467 } else { 1468 path->bridge.vlan_mode = DEV_PATH_BR_VLAN_TAG; 1469 vid = br_get_pvid(vg); 1470 } 1471 1472 path->bridge.vlan_id = vid; 1473 path->bridge.vlan_proto = br->vlan_proto; 1474 } 1475 1476 int br_vlan_fill_forward_path_mode(struct net_bridge *br, 1477 struct net_bridge_port *dst, 1478 struct net_device_path *path) 1479 { 1480 struct net_bridge_vlan_group *vg; 1481 struct net_bridge_vlan *v; 1482 1483 if (!br_opt_get(br, BROPT_VLAN_ENABLED)) 1484 return 0; 1485 1486 vg = nbp_vlan_group_rcu(dst); 1487 v = br_vlan_find(vg, path->bridge.vlan_id); 1488 if (!v || !br_vlan_should_use(v)) 1489 return -EINVAL; 1490 1491 if (!(v->flags & BRIDGE_VLAN_INFO_UNTAGGED)) 1492 return 0; 1493 1494 if (path->bridge.vlan_mode == DEV_PATH_BR_VLAN_TAG) 1495 path->bridge.vlan_mode = DEV_PATH_BR_VLAN_KEEP; 1496 else if (v->priv_flags & BR_VLFLAG_TAGGING_BY_SWITCHDEV) 1497 path->bridge.vlan_mode = DEV_PATH_BR_VLAN_UNTAG_HW; 1498 else 1499 path->bridge.vlan_mode = DEV_PATH_BR_VLAN_UNTAG; 1500 1501 return 0; 1502 } 1503 1504 int br_vlan_get_info(const struct net_device *dev, u16 vid, 1505 struct bridge_vlan_info *p_vinfo) 1506 { 1507 struct net_bridge_vlan_group *vg; 1508 struct net_bridge_vlan *v; 1509 struct net_bridge_port *p; 1510 1511 ASSERT_RTNL(); 1512 p = br_port_get_check_rtnl(dev); 1513 if (p) 1514 vg = nbp_vlan_group(p); 1515 else if (netif_is_bridge_master(dev)) 1516 vg = br_vlan_group(netdev_priv(dev)); 1517 else 1518 return -EINVAL; 1519 1520 v = br_vlan_find(vg, vid); 1521 if (!v) 1522 return -ENOENT; 1523 1524 p_vinfo->vid = vid; 1525 p_vinfo->flags = v->flags; 1526 if (vid == br_get_pvid(vg)) 1527 p_vinfo->flags |= BRIDGE_VLAN_INFO_PVID; 1528 return 0; 1529 } 1530 EXPORT_SYMBOL_GPL(br_vlan_get_info); 1531 1532 int br_vlan_get_info_rcu(const struct net_device *dev, u16 vid, 1533 struct bridge_vlan_info *p_vinfo) 1534 { 1535 struct net_bridge_vlan_group *vg; 1536 struct net_bridge_vlan *v; 1537 struct net_bridge_port *p; 1538 1539 p = br_port_get_check_rcu(dev); 1540 if (p) 1541 vg = nbp_vlan_group_rcu(p); 1542 else if (netif_is_bridge_master(dev)) 1543 vg = br_vlan_group_rcu(netdev_priv(dev)); 1544 else 1545 return -EINVAL; 1546 1547 v = br_vlan_find(vg, vid); 1548 if (!v) 1549 return -ENOENT; 1550 1551 p_vinfo->vid = vid; 1552 p_vinfo->flags = v->flags; 1553 if (vid == br_get_pvid(vg)) 1554 p_vinfo->flags |= BRIDGE_VLAN_INFO_PVID; 1555 return 0; 1556 } 1557 EXPORT_SYMBOL_GPL(br_vlan_get_info_rcu); 1558 1559 static int br_vlan_is_bind_vlan_dev(const struct net_device *dev) 1560 { 1561 return is_vlan_dev(dev) && 1562 !!(vlan_dev_priv(dev)->flags & VLAN_FLAG_BRIDGE_BINDING); 1563 } 1564 1565 static int br_vlan_is_bind_vlan_dev_fn(struct net_device *dev, 1566 __always_unused struct netdev_nested_priv *priv) 1567 { 1568 return br_vlan_is_bind_vlan_dev(dev); 1569 } 1570 1571 static bool br_vlan_has_upper_bind_vlan_dev(struct net_device *dev) 1572 { 1573 int found; 1574 1575 rcu_read_lock(); 1576 found = netdev_walk_all_upper_dev_rcu(dev, br_vlan_is_bind_vlan_dev_fn, 1577 NULL); 1578 rcu_read_unlock(); 1579 1580 return !!found; 1581 } 1582 1583 struct br_vlan_bind_walk_data { 1584 u16 vid; 1585 struct net_device *result; 1586 }; 1587 1588 static int br_vlan_match_bind_vlan_dev_fn(struct net_device *dev, 1589 struct netdev_nested_priv *priv) 1590 { 1591 struct br_vlan_bind_walk_data *data = priv->data; 1592 int found = 0; 1593 1594 if (br_vlan_is_bind_vlan_dev(dev) && 1595 vlan_dev_priv(dev)->vlan_id == data->vid) { 1596 data->result = dev; 1597 found = 1; 1598 } 1599 1600 return found; 1601 } 1602 1603 static struct net_device * 1604 br_vlan_get_upper_bind_vlan_dev(struct net_device *dev, u16 vid) 1605 { 1606 struct br_vlan_bind_walk_data data = { 1607 .vid = vid, 1608 }; 1609 struct netdev_nested_priv priv = { 1610 .data = (void *)&data, 1611 }; 1612 1613 rcu_read_lock(); 1614 netdev_walk_all_upper_dev_rcu(dev, br_vlan_match_bind_vlan_dev_fn, 1615 &priv); 1616 rcu_read_unlock(); 1617 1618 return data.result; 1619 } 1620 1621 static bool br_vlan_is_dev_up(const struct net_device *dev) 1622 { 1623 return !!(dev->flags & IFF_UP) && netif_oper_up(dev); 1624 } 1625 1626 static void br_vlan_set_vlan_dev_state(const struct net_bridge *br, 1627 struct net_device *vlan_dev) 1628 { 1629 u16 vid = vlan_dev_priv(vlan_dev)->vlan_id; 1630 struct net_bridge_vlan_group *vg; 1631 struct net_bridge_port *p; 1632 bool has_carrier = false; 1633 1634 if (!netif_carrier_ok(br->dev)) { 1635 netif_carrier_off(vlan_dev); 1636 return; 1637 } 1638 1639 list_for_each_entry(p, &br->port_list, list) { 1640 vg = nbp_vlan_group(p); 1641 if (br_vlan_find(vg, vid) && br_vlan_is_dev_up(p->dev)) { 1642 has_carrier = true; 1643 break; 1644 } 1645 } 1646 1647 if (has_carrier) 1648 netif_carrier_on(vlan_dev); 1649 else 1650 netif_carrier_off(vlan_dev); 1651 } 1652 1653 static void br_vlan_set_all_vlan_dev_state(struct net_bridge_port *p) 1654 { 1655 struct net_bridge_vlan_group *vg = nbp_vlan_group(p); 1656 struct net_bridge_vlan *vlan; 1657 struct net_device *vlan_dev; 1658 1659 list_for_each_entry(vlan, &vg->vlan_list, vlist) { 1660 vlan_dev = br_vlan_get_upper_bind_vlan_dev(p->br->dev, 1661 vlan->vid); 1662 if (vlan_dev) { 1663 if (br_vlan_is_dev_up(p->dev)) { 1664 if (netif_carrier_ok(p->br->dev)) 1665 netif_carrier_on(vlan_dev); 1666 } else { 1667 br_vlan_set_vlan_dev_state(p->br, vlan_dev); 1668 } 1669 } 1670 } 1671 } 1672 1673 static void br_vlan_toggle_bridge_binding(struct net_device *br_dev, 1674 bool enable) 1675 { 1676 struct net_bridge *br = netdev_priv(br_dev); 1677 1678 if (enable) 1679 br_opt_toggle(br, BROPT_VLAN_BRIDGE_BINDING, true); 1680 else 1681 br_opt_toggle(br, BROPT_VLAN_BRIDGE_BINDING, 1682 br_vlan_has_upper_bind_vlan_dev(br_dev)); 1683 } 1684 1685 static void br_vlan_upper_change(struct net_device *dev, 1686 struct net_device *upper_dev, 1687 bool linking) 1688 { 1689 struct net_bridge *br = netdev_priv(dev); 1690 1691 if (!br_vlan_is_bind_vlan_dev(upper_dev)) 1692 return; 1693 1694 br_vlan_toggle_bridge_binding(dev, linking); 1695 if (linking) 1696 br_vlan_set_vlan_dev_state(br, upper_dev); 1697 } 1698 1699 struct br_vlan_link_state_walk_data { 1700 struct net_bridge *br; 1701 }; 1702 1703 static int br_vlan_link_state_change_fn(struct net_device *vlan_dev, 1704 struct netdev_nested_priv *priv) 1705 { 1706 struct br_vlan_link_state_walk_data *data = priv->data; 1707 1708 if (br_vlan_is_bind_vlan_dev(vlan_dev)) 1709 br_vlan_set_vlan_dev_state(data->br, vlan_dev); 1710 1711 return 0; 1712 } 1713 1714 static void br_vlan_link_state_change(struct net_device *dev, 1715 struct net_bridge *br) 1716 { 1717 struct br_vlan_link_state_walk_data data = { 1718 .br = br 1719 }; 1720 struct netdev_nested_priv priv = { 1721 .data = (void *)&data, 1722 }; 1723 1724 rcu_read_lock(); 1725 netdev_walk_all_upper_dev_rcu(dev, br_vlan_link_state_change_fn, 1726 &priv); 1727 rcu_read_unlock(); 1728 } 1729 1730 /* Must be protected by RTNL. */ 1731 static void nbp_vlan_set_vlan_dev_state(struct net_bridge_port *p, u16 vid) 1732 { 1733 struct net_device *vlan_dev; 1734 1735 if (!br_opt_get(p->br, BROPT_VLAN_BRIDGE_BINDING)) 1736 return; 1737 1738 vlan_dev = br_vlan_get_upper_bind_vlan_dev(p->br->dev, vid); 1739 if (vlan_dev) 1740 br_vlan_set_vlan_dev_state(p->br, vlan_dev); 1741 } 1742 1743 /* Must be protected by RTNL. */ 1744 int br_vlan_bridge_event(struct net_device *dev, unsigned long event, void *ptr) 1745 { 1746 struct netdev_notifier_changeupper_info *info; 1747 struct net_bridge *br = netdev_priv(dev); 1748 int vlcmd = 0, ret = 0; 1749 bool changed = false; 1750 1751 switch (event) { 1752 case NETDEV_REGISTER: 1753 ret = br_vlan_add(br, br->default_pvid, 1754 BRIDGE_VLAN_INFO_PVID | 1755 BRIDGE_VLAN_INFO_UNTAGGED | 1756 BRIDGE_VLAN_INFO_BRENTRY, &changed, NULL); 1757 vlcmd = RTM_NEWVLAN; 1758 break; 1759 case NETDEV_UNREGISTER: 1760 changed = !br_vlan_delete(br, br->default_pvid); 1761 vlcmd = RTM_DELVLAN; 1762 break; 1763 case NETDEV_CHANGEUPPER: 1764 info = ptr; 1765 br_vlan_upper_change(dev, info->upper_dev, info->linking); 1766 break; 1767 1768 case NETDEV_CHANGE: 1769 case NETDEV_UP: 1770 if (!br_opt_get(br, BROPT_VLAN_BRIDGE_BINDING)) 1771 break; 1772 br_vlan_link_state_change(dev, br); 1773 break; 1774 } 1775 if (changed) 1776 br_vlan_notify(br, NULL, br->default_pvid, 0, vlcmd); 1777 1778 return ret; 1779 } 1780 1781 void br_vlan_vlan_upper_event(struct net_device *br_dev, 1782 struct net_device *vlan_dev, 1783 unsigned long event) 1784 { 1785 struct vlan_dev_priv *vlan = vlan_dev_priv(vlan_dev); 1786 struct net_bridge *br = netdev_priv(br_dev); 1787 bool bridge_binding; 1788 1789 switch (event) { 1790 case NETDEV_CHANGE: 1791 case NETDEV_UP: 1792 break; 1793 default: 1794 return; 1795 } 1796 1797 bridge_binding = vlan->flags & VLAN_FLAG_BRIDGE_BINDING; 1798 br_vlan_toggle_bridge_binding(br_dev, bridge_binding); 1799 if (bridge_binding) 1800 br_vlan_set_vlan_dev_state(br, vlan_dev); 1801 else if (!bridge_binding && netif_carrier_ok(br_dev)) 1802 netif_carrier_on(vlan_dev); 1803 } 1804 1805 /* Must be protected by RTNL. */ 1806 void br_vlan_port_event(struct net_bridge_port *p, unsigned long event) 1807 { 1808 if (!br_opt_get(p->br, BROPT_VLAN_BRIDGE_BINDING)) 1809 return; 1810 1811 switch (event) { 1812 case NETDEV_CHANGE: 1813 case NETDEV_DOWN: 1814 case NETDEV_UP: 1815 br_vlan_set_all_vlan_dev_state(p); 1816 break; 1817 } 1818 } 1819 1820 static bool br_vlan_stats_fill(struct sk_buff *skb, 1821 const struct net_bridge_vlan *v) 1822 { 1823 struct pcpu_sw_netstats stats; 1824 struct nlattr *nest; 1825 1826 nest = nla_nest_start(skb, BRIDGE_VLANDB_ENTRY_STATS); 1827 if (!nest) 1828 return false; 1829 1830 br_vlan_get_stats(v, &stats); 1831 if (nla_put_u64_64bit(skb, BRIDGE_VLANDB_STATS_RX_BYTES, 1832 u64_stats_read(&stats.rx_bytes), 1833 BRIDGE_VLANDB_STATS_PAD) || 1834 nla_put_u64_64bit(skb, BRIDGE_VLANDB_STATS_RX_PACKETS, 1835 u64_stats_read(&stats.rx_packets), 1836 BRIDGE_VLANDB_STATS_PAD) || 1837 nla_put_u64_64bit(skb, BRIDGE_VLANDB_STATS_TX_BYTES, 1838 u64_stats_read(&stats.tx_bytes), 1839 BRIDGE_VLANDB_STATS_PAD) || 1840 nla_put_u64_64bit(skb, BRIDGE_VLANDB_STATS_TX_PACKETS, 1841 u64_stats_read(&stats.tx_packets), 1842 BRIDGE_VLANDB_STATS_PAD)) 1843 goto out_err; 1844 1845 nla_nest_end(skb, nest); 1846 1847 return true; 1848 1849 out_err: 1850 nla_nest_cancel(skb, nest); 1851 return false; 1852 } 1853 1854 /* v_opts is used to dump the options which must be equal in the whole range */ 1855 static bool br_vlan_fill_vids(struct sk_buff *skb, u16 vid, u16 vid_range, 1856 const struct net_bridge_vlan *v_opts, 1857 const struct net_bridge_port *p, 1858 u16 flags, 1859 bool dump_stats) 1860 { 1861 struct bridge_vlan_info info; 1862 struct nlattr *nest; 1863 1864 nest = nla_nest_start(skb, BRIDGE_VLANDB_ENTRY); 1865 if (!nest) 1866 return false; 1867 1868 memset(&info, 0, sizeof(info)); 1869 info.vid = vid; 1870 if (flags & BRIDGE_VLAN_INFO_UNTAGGED) 1871 info.flags |= BRIDGE_VLAN_INFO_UNTAGGED; 1872 if (flags & BRIDGE_VLAN_INFO_PVID) 1873 info.flags |= BRIDGE_VLAN_INFO_PVID; 1874 1875 if (nla_put(skb, BRIDGE_VLANDB_ENTRY_INFO, sizeof(info), &info)) 1876 goto out_err; 1877 1878 if (vid_range && vid < vid_range && 1879 !(flags & BRIDGE_VLAN_INFO_PVID) && 1880 nla_put_u16(skb, BRIDGE_VLANDB_ENTRY_RANGE, vid_range)) 1881 goto out_err; 1882 1883 if (v_opts) { 1884 if (!br_vlan_opts_fill(skb, v_opts, p)) 1885 goto out_err; 1886 1887 if (dump_stats && !br_vlan_stats_fill(skb, v_opts)) 1888 goto out_err; 1889 } 1890 1891 nla_nest_end(skb, nest); 1892 1893 return true; 1894 1895 out_err: 1896 nla_nest_cancel(skb, nest); 1897 return false; 1898 } 1899 1900 static size_t rtnl_vlan_nlmsg_size(void) 1901 { 1902 return NLMSG_ALIGN(sizeof(struct br_vlan_msg)) 1903 + nla_total_size(0) /* BRIDGE_VLANDB_ENTRY */ 1904 + nla_total_size(sizeof(u16)) /* BRIDGE_VLANDB_ENTRY_RANGE */ 1905 + nla_total_size(sizeof(struct bridge_vlan_info)) /* BRIDGE_VLANDB_ENTRY_INFO */ 1906 + br_vlan_opts_nl_size(); /* bridge vlan options */ 1907 } 1908 1909 void br_vlan_notify(const struct net_bridge *br, 1910 const struct net_bridge_port *p, 1911 u16 vid, u16 vid_range, 1912 int cmd) 1913 { 1914 struct net_bridge_vlan_group *vg; 1915 struct net_bridge_vlan *v = NULL; 1916 struct br_vlan_msg *bvm; 1917 struct nlmsghdr *nlh; 1918 struct sk_buff *skb; 1919 int err = -ENOBUFS; 1920 struct net *net; 1921 u16 flags = 0; 1922 int ifindex; 1923 1924 /* right now notifications are done only with rtnl held */ 1925 ASSERT_RTNL(); 1926 1927 if (p) { 1928 ifindex = p->dev->ifindex; 1929 vg = nbp_vlan_group(p); 1930 net = dev_net(p->dev); 1931 } else { 1932 ifindex = br->dev->ifindex; 1933 vg = br_vlan_group(br); 1934 net = dev_net(br->dev); 1935 } 1936 1937 skb = nlmsg_new(rtnl_vlan_nlmsg_size(), GFP_KERNEL); 1938 if (!skb) 1939 goto out_err; 1940 1941 err = -EMSGSIZE; 1942 nlh = nlmsg_put(skb, 0, 0, cmd, sizeof(*bvm), 0); 1943 if (!nlh) 1944 goto out_err; 1945 bvm = nlmsg_data(nlh); 1946 memset(bvm, 0, sizeof(*bvm)); 1947 bvm->family = AF_BRIDGE; 1948 bvm->ifindex = ifindex; 1949 1950 switch (cmd) { 1951 case RTM_NEWVLAN: 1952 /* need to find the vlan due to flags/options */ 1953 v = br_vlan_find(vg, vid); 1954 if (!v || !br_vlan_should_use(v)) 1955 goto out_kfree; 1956 1957 flags = v->flags; 1958 if (br_get_pvid(vg) == v->vid) 1959 flags |= BRIDGE_VLAN_INFO_PVID; 1960 break; 1961 case RTM_DELVLAN: 1962 break; 1963 default: 1964 goto out_kfree; 1965 } 1966 1967 if (!br_vlan_fill_vids(skb, vid, vid_range, v, p, flags, false)) 1968 goto out_err; 1969 1970 nlmsg_end(skb, nlh); 1971 rtnl_notify(skb, net, 0, RTNLGRP_BRVLAN, NULL, GFP_KERNEL); 1972 return; 1973 1974 out_err: 1975 rtnl_set_sk_err(net, RTNLGRP_BRVLAN, err); 1976 out_kfree: 1977 kfree_skb(skb); 1978 } 1979 1980 /* check if v_curr can enter a range ending in range_end */ 1981 bool br_vlan_can_enter_range(const struct net_bridge_vlan *v_curr, 1982 const struct net_bridge_vlan *range_end, 1983 u16 pvid) 1984 { 1985 return v_curr->vid != pvid && range_end->vid != pvid && 1986 v_curr->vid - range_end->vid == 1 && 1987 range_end->flags == v_curr->flags && 1988 br_vlan_opts_eq_range(v_curr, range_end); 1989 } 1990 1991 static int br_vlan_dump_dev(const struct net_device *dev, 1992 struct sk_buff *skb, 1993 struct netlink_callback *cb, 1994 u32 dump_flags) 1995 { 1996 struct net_bridge_vlan *v, *range_start = NULL, *range_end = NULL; 1997 bool dump_global = !!(dump_flags & BRIDGE_VLANDB_DUMPF_GLOBAL); 1998 bool dump_stats = !!(dump_flags & BRIDGE_VLANDB_DUMPF_STATS); 1999 struct net_bridge_vlan_group *vg; 2000 int idx = 0, s_idx = cb->args[1]; 2001 struct nlmsghdr *nlh = NULL; 2002 struct net_bridge_port *p; 2003 struct br_vlan_msg *bvm; 2004 struct net_bridge *br; 2005 int err = 0; 2006 u16 pvid; 2007 2008 if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev)) 2009 return -EINVAL; 2010 2011 if (netif_is_bridge_master(dev)) { 2012 br = netdev_priv(dev); 2013 vg = br_vlan_group_rcu(br); 2014 p = NULL; 2015 } else { 2016 /* global options are dumped only for bridge devices */ 2017 if (dump_global) 2018 return 0; 2019 2020 p = br_port_get_rcu(dev); 2021 if (WARN_ON(!p)) 2022 return -EINVAL; 2023 vg = nbp_vlan_group_rcu(p); 2024 br = p->br; 2025 } 2026 2027 if (!vg) 2028 return 0; 2029 2030 nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, 2031 RTM_NEWVLAN, sizeof(*bvm), NLM_F_MULTI); 2032 if (!nlh) 2033 return -EMSGSIZE; 2034 bvm = nlmsg_data(nlh); 2035 memset(bvm, 0, sizeof(*bvm)); 2036 bvm->family = PF_BRIDGE; 2037 bvm->ifindex = dev->ifindex; 2038 pvid = br_get_pvid(vg); 2039 2040 /* idx must stay at range's beginning until it is filled in */ 2041 list_for_each_entry_rcu(v, &vg->vlan_list, vlist) { 2042 if (!dump_global && !br_vlan_should_use(v)) 2043 continue; 2044 if (idx < s_idx) { 2045 idx++; 2046 continue; 2047 } 2048 2049 if (!range_start) { 2050 range_start = v; 2051 range_end = v; 2052 continue; 2053 } 2054 2055 if (dump_global) { 2056 if (br_vlan_global_opts_can_enter_range(v, range_end)) 2057 goto update_end; 2058 if (!br_vlan_global_opts_fill(skb, range_start->vid, 2059 range_end->vid, 2060 range_start)) { 2061 err = -EMSGSIZE; 2062 break; 2063 } 2064 /* advance number of filled vlans */ 2065 idx += range_end->vid - range_start->vid + 1; 2066 2067 range_start = v; 2068 } else if (dump_stats || 2069 !br_vlan_can_enter_range(v, range_end, pvid)) { 2070 u16 vlan_flags = br_vlan_flags(range_start, pvid); 2071 2072 if (!br_vlan_fill_vids(skb, range_start->vid, 2073 range_end->vid, range_start, 2074 p, vlan_flags, dump_stats)) { 2075 err = -EMSGSIZE; 2076 break; 2077 } 2078 /* advance number of filled vlans */ 2079 idx += range_end->vid - range_start->vid + 1; 2080 2081 range_start = v; 2082 } 2083 update_end: 2084 range_end = v; 2085 } 2086 2087 /* err will be 0 and range_start will be set in 3 cases here: 2088 * - first vlan (range_start == range_end) 2089 * - last vlan (range_start == range_end, not in range) 2090 * - last vlan range (range_start != range_end, in range) 2091 */ 2092 if (!err && range_start) { 2093 if (dump_global && 2094 !br_vlan_global_opts_fill(skb, range_start->vid, 2095 range_end->vid, range_start)) 2096 err = -EMSGSIZE; 2097 else if (!dump_global && 2098 !br_vlan_fill_vids(skb, range_start->vid, 2099 range_end->vid, range_start, 2100 p, br_vlan_flags(range_start, pvid), 2101 dump_stats)) 2102 err = -EMSGSIZE; 2103 } 2104 2105 cb->args[1] = err ? idx : 0; 2106 2107 nlmsg_end(skb, nlh); 2108 2109 return err; 2110 } 2111 2112 static const struct nla_policy br_vlan_db_dump_pol[BRIDGE_VLANDB_DUMP_MAX + 1] = { 2113 [BRIDGE_VLANDB_DUMP_FLAGS] = { .type = NLA_U32 }, 2114 }; 2115 2116 static int br_vlan_rtm_dump(struct sk_buff *skb, struct netlink_callback *cb) 2117 { 2118 struct nlattr *dtb[BRIDGE_VLANDB_DUMP_MAX + 1]; 2119 int idx = 0, err = 0, s_idx = cb->args[0]; 2120 struct net *net = sock_net(skb->sk); 2121 struct br_vlan_msg *bvm; 2122 struct net_device *dev; 2123 u32 dump_flags = 0; 2124 2125 err = nlmsg_parse(cb->nlh, sizeof(*bvm), dtb, BRIDGE_VLANDB_DUMP_MAX, 2126 br_vlan_db_dump_pol, cb->extack); 2127 if (err < 0) 2128 return err; 2129 2130 bvm = nlmsg_data(cb->nlh); 2131 if (dtb[BRIDGE_VLANDB_DUMP_FLAGS]) 2132 dump_flags = nla_get_u32(dtb[BRIDGE_VLANDB_DUMP_FLAGS]); 2133 2134 rcu_read_lock(); 2135 if (bvm->ifindex) { 2136 dev = dev_get_by_index_rcu(net, bvm->ifindex); 2137 if (!dev) { 2138 err = -ENODEV; 2139 goto out_err; 2140 } 2141 err = br_vlan_dump_dev(dev, skb, cb, dump_flags); 2142 /* if the dump completed without an error we return 0 here */ 2143 if (err != -EMSGSIZE) 2144 goto out_err; 2145 } else { 2146 for_each_netdev_rcu(net, dev) { 2147 if (idx < s_idx) 2148 goto skip; 2149 2150 err = br_vlan_dump_dev(dev, skb, cb, dump_flags); 2151 if (err == -EMSGSIZE) 2152 break; 2153 skip: 2154 idx++; 2155 } 2156 } 2157 cb->args[0] = idx; 2158 rcu_read_unlock(); 2159 2160 return skb->len; 2161 2162 out_err: 2163 rcu_read_unlock(); 2164 2165 return err; 2166 } 2167 2168 static const struct nla_policy br_vlan_db_policy[BRIDGE_VLANDB_ENTRY_MAX + 1] = { 2169 [BRIDGE_VLANDB_ENTRY_INFO] = 2170 NLA_POLICY_EXACT_LEN(sizeof(struct bridge_vlan_info)), 2171 [BRIDGE_VLANDB_ENTRY_RANGE] = { .type = NLA_U16 }, 2172 [BRIDGE_VLANDB_ENTRY_STATE] = { .type = NLA_U8 }, 2173 [BRIDGE_VLANDB_ENTRY_TUNNEL_INFO] = { .type = NLA_NESTED }, 2174 [BRIDGE_VLANDB_ENTRY_MCAST_ROUTER] = { .type = NLA_U8 }, 2175 [BRIDGE_VLANDB_ENTRY_MCAST_N_GROUPS] = { .type = NLA_REJECT }, 2176 [BRIDGE_VLANDB_ENTRY_MCAST_MAX_GROUPS] = { .type = NLA_U32 }, 2177 [BRIDGE_VLANDB_ENTRY_NEIGH_SUPPRESS] = NLA_POLICY_MAX(NLA_U8, 1), 2178 [BRIDGE_VLANDB_ENTRY_NEIGH_FORWARD_GRAT] = NLA_POLICY_MAX(NLA_U8, 1), 2179 }; 2180 2181 static int br_vlan_rtm_process_one(struct net_device *dev, 2182 const struct nlattr *attr, 2183 int cmd, struct netlink_ext_ack *extack) 2184 { 2185 struct bridge_vlan_info *vinfo, vrange_end, *vinfo_last = NULL; 2186 struct nlattr *tb[BRIDGE_VLANDB_ENTRY_MAX + 1]; 2187 bool changed = false, skip_processing = false; 2188 struct net_bridge_vlan_group *vg; 2189 struct net_bridge_port *p = NULL; 2190 int err = 0, cmdmap = 0; 2191 struct net_bridge *br; 2192 2193 if (netif_is_bridge_master(dev)) { 2194 br = netdev_priv(dev); 2195 vg = br_vlan_group(br); 2196 } else { 2197 p = br_port_get_rtnl(dev); 2198 if (WARN_ON(!p)) 2199 return -ENODEV; 2200 br = p->br; 2201 vg = nbp_vlan_group(p); 2202 } 2203 2204 if (WARN_ON(!vg)) 2205 return -ENODEV; 2206 2207 err = nla_parse_nested(tb, BRIDGE_VLANDB_ENTRY_MAX, attr, 2208 br_vlan_db_policy, extack); 2209 if (err) 2210 return err; 2211 2212 if (!tb[BRIDGE_VLANDB_ENTRY_INFO]) { 2213 NL_SET_ERR_MSG_MOD(extack, "Missing vlan entry info"); 2214 return -EINVAL; 2215 } 2216 memset(&vrange_end, 0, sizeof(vrange_end)); 2217 2218 vinfo = nla_data(tb[BRIDGE_VLANDB_ENTRY_INFO]); 2219 if (vinfo->flags & (BRIDGE_VLAN_INFO_RANGE_BEGIN | 2220 BRIDGE_VLAN_INFO_RANGE_END)) { 2221 NL_SET_ERR_MSG_MOD(extack, "Old-style vlan ranges are not allowed when using RTM vlan calls"); 2222 return -EINVAL; 2223 } 2224 if (!br_vlan_valid_id(vinfo->vid, extack)) 2225 return -EINVAL; 2226 2227 if (tb[BRIDGE_VLANDB_ENTRY_RANGE]) { 2228 vrange_end.vid = nla_get_u16(tb[BRIDGE_VLANDB_ENTRY_RANGE]); 2229 /* validate user-provided flags without RANGE_BEGIN */ 2230 vrange_end.flags = BRIDGE_VLAN_INFO_RANGE_END | vinfo->flags; 2231 vinfo->flags |= BRIDGE_VLAN_INFO_RANGE_BEGIN; 2232 2233 /* vinfo_last is the range start, vinfo the range end */ 2234 vinfo_last = vinfo; 2235 vinfo = &vrange_end; 2236 2237 if (!br_vlan_valid_id(vinfo->vid, extack) || 2238 !br_vlan_valid_range(vinfo, vinfo_last, extack)) 2239 return -EINVAL; 2240 } 2241 2242 switch (cmd) { 2243 case RTM_NEWVLAN: 2244 cmdmap = RTM_SETLINK; 2245 skip_processing = !!(vinfo->flags & BRIDGE_VLAN_INFO_ONLY_OPTS); 2246 break; 2247 case RTM_DELVLAN: 2248 cmdmap = RTM_DELLINK; 2249 break; 2250 } 2251 2252 if (!skip_processing) { 2253 struct bridge_vlan_info *tmp_last = vinfo_last; 2254 2255 /* br_process_vlan_info may overwrite vinfo_last */ 2256 err = br_process_vlan_info(br, p, cmdmap, vinfo, &tmp_last, 2257 &changed, extack); 2258 2259 /* notify first if anything changed */ 2260 if (changed) 2261 br_ifinfo_notify(cmdmap, br, p); 2262 2263 if (err) 2264 return err; 2265 } 2266 2267 /* deal with options */ 2268 if (cmd == RTM_NEWVLAN) { 2269 struct net_bridge_vlan *range_start, *range_end; 2270 2271 if (vinfo_last) { 2272 range_start = br_vlan_find(vg, vinfo_last->vid); 2273 range_end = br_vlan_find(vg, vinfo->vid); 2274 } else { 2275 range_start = br_vlan_find(vg, vinfo->vid); 2276 range_end = range_start; 2277 } 2278 2279 err = br_vlan_process_options(br, p, range_start, range_end, 2280 tb, extack); 2281 } 2282 2283 return err; 2284 } 2285 2286 static int br_vlan_rtm_process(struct sk_buff *skb, struct nlmsghdr *nlh, 2287 struct netlink_ext_ack *extack) 2288 { 2289 struct net *net = sock_net(skb->sk); 2290 struct br_vlan_msg *bvm; 2291 struct net_device *dev; 2292 struct nlattr *attr; 2293 int err, vlans = 0; 2294 int rem; 2295 2296 /* this should validate the header and check for remaining bytes */ 2297 err = nlmsg_parse(nlh, sizeof(*bvm), NULL, BRIDGE_VLANDB_MAX, NULL, 2298 extack); 2299 if (err < 0) 2300 return err; 2301 2302 bvm = nlmsg_data(nlh); 2303 dev = __dev_get_by_index(net, bvm->ifindex); 2304 if (!dev) 2305 return -ENODEV; 2306 2307 if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev)) { 2308 NL_SET_ERR_MSG_MOD(extack, "The device is not a valid bridge or bridge port"); 2309 return -EINVAL; 2310 } 2311 2312 nlmsg_for_each_attr(attr, nlh, sizeof(*bvm), rem) { 2313 switch (nla_type(attr)) { 2314 case BRIDGE_VLANDB_ENTRY: 2315 err = br_vlan_rtm_process_one(dev, attr, 2316 nlh->nlmsg_type, 2317 extack); 2318 break; 2319 case BRIDGE_VLANDB_GLOBAL_OPTIONS: 2320 err = br_vlan_rtm_process_global_options(dev, attr, 2321 nlh->nlmsg_type, 2322 extack); 2323 break; 2324 default: 2325 continue; 2326 } 2327 2328 vlans++; 2329 if (err) 2330 break; 2331 } 2332 if (!vlans) { 2333 NL_SET_ERR_MSG_MOD(extack, "No vlans found to process"); 2334 err = -EINVAL; 2335 } 2336 2337 return err; 2338 } 2339 2340 static const struct rtnl_msg_handler br_vlan_rtnl_msg_handlers[] = { 2341 {THIS_MODULE, PF_BRIDGE, RTM_NEWVLAN, br_vlan_rtm_process, NULL, 0}, 2342 {THIS_MODULE, PF_BRIDGE, RTM_DELVLAN, br_vlan_rtm_process, NULL, 0}, 2343 {THIS_MODULE, PF_BRIDGE, RTM_GETVLAN, NULL, br_vlan_rtm_dump, 0}, 2344 }; 2345 2346 int br_vlan_rtnl_init(void) 2347 { 2348 return rtnl_register_many(br_vlan_rtnl_msg_handlers); 2349 } 2350 2351 void br_vlan_rtnl_uninit(void) 2352 { 2353 rtnl_unregister_many(br_vlan_rtnl_msg_handlers); 2354 } 2355