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