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