1 #include <linux/kernel.h> 2 #include <linux/netdevice.h> 3 #include <linux/rtnetlink.h> 4 #include <linux/slab.h> 5 6 #include "br_private.h" 7 8 static void __vlan_add_pvid(struct net_port_vlans *v, u16 vid) 9 { 10 if (v->pvid == vid) 11 return; 12 13 smp_wmb(); 14 v->pvid = vid; 15 } 16 17 static void __vlan_delete_pvid(struct net_port_vlans *v, u16 vid) 18 { 19 if (v->pvid != vid) 20 return; 21 22 smp_wmb(); 23 v->pvid = 0; 24 } 25 26 static void __vlan_add_flags(struct net_port_vlans *v, u16 vid, u16 flags) 27 { 28 if (flags & BRIDGE_VLAN_INFO_PVID) 29 __vlan_add_pvid(v, vid); 30 else 31 __vlan_delete_pvid(v, vid); 32 33 if (flags & BRIDGE_VLAN_INFO_UNTAGGED) 34 set_bit(vid, v->untagged_bitmap); 35 else 36 clear_bit(vid, v->untagged_bitmap); 37 } 38 39 static int __vlan_add(struct net_port_vlans *v, u16 vid, u16 flags) 40 { 41 struct net_bridge_port *p = NULL; 42 struct net_bridge *br; 43 struct net_device *dev; 44 int err; 45 46 if (test_bit(vid, v->vlan_bitmap)) { 47 __vlan_add_flags(v, vid, flags); 48 return 0; 49 } 50 51 if (v->port_idx) { 52 p = v->parent.port; 53 br = p->br; 54 dev = p->dev; 55 } else { 56 br = v->parent.br; 57 dev = br->dev; 58 } 59 60 if (p) { 61 /* Add VLAN to the device filter if it is supported. 62 * This ensures tagged traffic enters the bridge when 63 * promiscuous mode is disabled by br_manage_promisc(). 64 */ 65 err = vlan_vid_add(dev, br->vlan_proto, vid); 66 if (err) 67 return err; 68 } 69 70 err = br_fdb_insert(br, p, dev->dev_addr, vid); 71 if (err) { 72 br_err(br, "failed insert local address into bridge " 73 "forwarding table\n"); 74 goto out_filt; 75 } 76 77 set_bit(vid, v->vlan_bitmap); 78 v->num_vlans++; 79 __vlan_add_flags(v, vid, flags); 80 81 return 0; 82 83 out_filt: 84 if (p) 85 vlan_vid_del(dev, br->vlan_proto, vid); 86 return err; 87 } 88 89 static int __vlan_del(struct net_port_vlans *v, u16 vid) 90 { 91 if (!test_bit(vid, v->vlan_bitmap)) 92 return -EINVAL; 93 94 __vlan_delete_pvid(v, vid); 95 clear_bit(vid, v->untagged_bitmap); 96 97 if (v->port_idx) { 98 struct net_bridge_port *p = v->parent.port; 99 vlan_vid_del(p->dev, p->br->vlan_proto, vid); 100 } 101 102 clear_bit(vid, v->vlan_bitmap); 103 v->num_vlans--; 104 if (bitmap_empty(v->vlan_bitmap, VLAN_N_VID)) { 105 if (v->port_idx) 106 RCU_INIT_POINTER(v->parent.port->vlan_info, NULL); 107 else 108 RCU_INIT_POINTER(v->parent.br->vlan_info, NULL); 109 kfree_rcu(v, rcu); 110 } 111 return 0; 112 } 113 114 static void __vlan_flush(struct net_port_vlans *v) 115 { 116 smp_wmb(); 117 v->pvid = 0; 118 bitmap_zero(v->vlan_bitmap, VLAN_N_VID); 119 if (v->port_idx) 120 RCU_INIT_POINTER(v->parent.port->vlan_info, NULL); 121 else 122 RCU_INIT_POINTER(v->parent.br->vlan_info, NULL); 123 kfree_rcu(v, rcu); 124 } 125 126 struct sk_buff *br_handle_vlan(struct net_bridge *br, 127 const struct net_port_vlans *pv, 128 struct sk_buff *skb) 129 { 130 u16 vid; 131 132 /* If this packet was not filtered at input, let it pass */ 133 if (!BR_INPUT_SKB_CB(skb)->vlan_filtered) 134 goto out; 135 136 /* Vlan filter table must be configured at this point. The 137 * only exception is the bridge is set in promisc mode and the 138 * packet is destined for the bridge device. In this case 139 * pass the packet as is. 140 */ 141 if (!pv) { 142 if ((br->dev->flags & IFF_PROMISC) && skb->dev == br->dev) { 143 goto out; 144 } else { 145 kfree_skb(skb); 146 return NULL; 147 } 148 } 149 150 /* At this point, we know that the frame was filtered and contains 151 * a valid vlan id. If the vlan id is set in the untagged bitmap, 152 * send untagged; otherwise, send tagged. 153 */ 154 br_vlan_get_tag(skb, &vid); 155 if (test_bit(vid, pv->untagged_bitmap)) 156 skb->vlan_tci = 0; 157 158 out: 159 return skb; 160 } 161 162 /* Called under RCU */ 163 bool br_allowed_ingress(struct net_bridge *br, struct net_port_vlans *v, 164 struct sk_buff *skb, u16 *vid) 165 { 166 bool tagged; 167 __be16 proto; 168 169 /* If VLAN filtering is disabled on the bridge, all packets are 170 * permitted. 171 */ 172 if (!br->vlan_enabled) { 173 BR_INPUT_SKB_CB(skb)->vlan_filtered = false; 174 return true; 175 } 176 177 /* If there are no vlan in the permitted list, all packets are 178 * rejected. 179 */ 180 if (!v) 181 goto drop; 182 183 BR_INPUT_SKB_CB(skb)->vlan_filtered = true; 184 proto = br->vlan_proto; 185 186 /* If vlan tx offload is disabled on bridge device and frame was 187 * sent from vlan device on the bridge device, it does not have 188 * HW accelerated vlan tag. 189 */ 190 if (unlikely(!vlan_tx_tag_present(skb) && 191 skb->protocol == proto)) { 192 skb = skb_vlan_untag(skb); 193 if (unlikely(!skb)) 194 return false; 195 } 196 197 if (!br_vlan_get_tag(skb, vid)) { 198 /* Tagged frame */ 199 if (skb->vlan_proto != proto) { 200 /* Protocol-mismatch, empty out vlan_tci for new tag */ 201 skb_push(skb, ETH_HLEN); 202 skb = __vlan_put_tag(skb, skb->vlan_proto, 203 vlan_tx_tag_get(skb)); 204 if (unlikely(!skb)) 205 return false; 206 207 skb_pull(skb, ETH_HLEN); 208 skb_reset_mac_len(skb); 209 *vid = 0; 210 tagged = false; 211 } else { 212 tagged = true; 213 } 214 } else { 215 /* Untagged frame */ 216 tagged = false; 217 } 218 219 if (!*vid) { 220 u16 pvid = br_get_pvid(v); 221 222 /* Frame had a tag with VID 0 or did not have a tag. 223 * See if pvid is set on this port. That tells us which 224 * vlan untagged or priority-tagged traffic belongs to. 225 */ 226 if (pvid == VLAN_N_VID) 227 goto drop; 228 229 /* PVID is set on this port. Any untagged or priority-tagged 230 * ingress frame is considered to belong to this vlan. 231 */ 232 *vid = pvid; 233 if (likely(!tagged)) 234 /* Untagged Frame. */ 235 __vlan_hwaccel_put_tag(skb, proto, pvid); 236 else 237 /* Priority-tagged Frame. 238 * At this point, We know that skb->vlan_tci had 239 * VLAN_TAG_PRESENT bit and its VID field was 0x000. 240 * We update only VID field and preserve PCP field. 241 */ 242 skb->vlan_tci |= pvid; 243 244 return true; 245 } 246 247 /* Frame had a valid vlan tag. See if vlan is allowed */ 248 if (test_bit(*vid, v->vlan_bitmap)) 249 return true; 250 drop: 251 kfree_skb(skb); 252 return false; 253 } 254 255 /* Called under RCU. */ 256 bool br_allowed_egress(struct net_bridge *br, 257 const struct net_port_vlans *v, 258 const struct sk_buff *skb) 259 { 260 u16 vid; 261 262 /* If this packet was not filtered at input, let it pass */ 263 if (!BR_INPUT_SKB_CB(skb)->vlan_filtered) 264 return true; 265 266 if (!v) 267 return false; 268 269 br_vlan_get_tag(skb, &vid); 270 if (test_bit(vid, v->vlan_bitmap)) 271 return true; 272 273 return false; 274 } 275 276 /* Called under RCU */ 277 bool br_should_learn(struct net_bridge_port *p, struct sk_buff *skb, u16 *vid) 278 { 279 struct net_bridge *br = p->br; 280 struct net_port_vlans *v; 281 282 /* If filtering was disabled at input, let it pass. */ 283 if (!br->vlan_enabled) 284 return true; 285 286 v = rcu_dereference(p->vlan_info); 287 if (!v) 288 return false; 289 290 if (!br_vlan_get_tag(skb, vid) && skb->vlan_proto != br->vlan_proto) 291 *vid = 0; 292 293 if (!*vid) { 294 *vid = br_get_pvid(v); 295 if (*vid == VLAN_N_VID) 296 return false; 297 298 return true; 299 } 300 301 if (test_bit(*vid, v->vlan_bitmap)) 302 return true; 303 304 return false; 305 } 306 307 /* Must be protected by RTNL. 308 * Must be called with vid in range from 1 to 4094 inclusive. 309 */ 310 int br_vlan_add(struct net_bridge *br, u16 vid, u16 flags) 311 { 312 struct net_port_vlans *pv = NULL; 313 int err; 314 315 ASSERT_RTNL(); 316 317 pv = rtnl_dereference(br->vlan_info); 318 if (pv) 319 return __vlan_add(pv, vid, flags); 320 321 /* Create port vlan infomration 322 */ 323 pv = kzalloc(sizeof(*pv), GFP_KERNEL); 324 if (!pv) 325 return -ENOMEM; 326 327 pv->parent.br = br; 328 err = __vlan_add(pv, vid, flags); 329 if (err) 330 goto out; 331 332 rcu_assign_pointer(br->vlan_info, pv); 333 return 0; 334 out: 335 kfree(pv); 336 return err; 337 } 338 339 /* Must be protected by RTNL. 340 * Must be called with vid in range from 1 to 4094 inclusive. 341 */ 342 int br_vlan_delete(struct net_bridge *br, u16 vid) 343 { 344 struct net_port_vlans *pv; 345 346 ASSERT_RTNL(); 347 348 pv = rtnl_dereference(br->vlan_info); 349 if (!pv) 350 return -EINVAL; 351 352 br_fdb_find_delete_local(br, NULL, br->dev->dev_addr, vid); 353 354 __vlan_del(pv, vid); 355 return 0; 356 } 357 358 void br_vlan_flush(struct net_bridge *br) 359 { 360 struct net_port_vlans *pv; 361 362 ASSERT_RTNL(); 363 pv = rtnl_dereference(br->vlan_info); 364 if (!pv) 365 return; 366 367 __vlan_flush(pv); 368 } 369 370 bool br_vlan_find(struct net_bridge *br, u16 vid) 371 { 372 struct net_port_vlans *pv; 373 bool found = false; 374 375 rcu_read_lock(); 376 pv = rcu_dereference(br->vlan_info); 377 378 if (!pv) 379 goto out; 380 381 if (test_bit(vid, pv->vlan_bitmap)) 382 found = true; 383 384 out: 385 rcu_read_unlock(); 386 return found; 387 } 388 389 /* Must be protected by RTNL. */ 390 static void recalculate_group_addr(struct net_bridge *br) 391 { 392 if (br->group_addr_set) 393 return; 394 395 spin_lock_bh(&br->lock); 396 if (!br->vlan_enabled || br->vlan_proto == htons(ETH_P_8021Q)) { 397 /* Bridge Group Address */ 398 br->group_addr[5] = 0x00; 399 } else { /* vlan_enabled && ETH_P_8021AD */ 400 /* Provider Bridge Group Address */ 401 br->group_addr[5] = 0x08; 402 } 403 spin_unlock_bh(&br->lock); 404 } 405 406 /* Must be protected by RTNL. */ 407 void br_recalculate_fwd_mask(struct net_bridge *br) 408 { 409 if (!br->vlan_enabled || br->vlan_proto == htons(ETH_P_8021Q)) 410 br->group_fwd_mask_required = BR_GROUPFWD_DEFAULT; 411 else /* vlan_enabled && ETH_P_8021AD */ 412 br->group_fwd_mask_required = BR_GROUPFWD_8021AD & 413 ~(1u << br->group_addr[5]); 414 } 415 416 int br_vlan_filter_toggle(struct net_bridge *br, unsigned long val) 417 { 418 if (!rtnl_trylock()) 419 return restart_syscall(); 420 421 if (br->vlan_enabled == val) 422 goto unlock; 423 424 br->vlan_enabled = val; 425 br_manage_promisc(br); 426 recalculate_group_addr(br); 427 br_recalculate_fwd_mask(br); 428 429 unlock: 430 rtnl_unlock(); 431 return 0; 432 } 433 434 int br_vlan_set_proto(struct net_bridge *br, unsigned long val) 435 { 436 int err = 0; 437 struct net_bridge_port *p; 438 struct net_port_vlans *pv; 439 __be16 proto, oldproto; 440 u16 vid, errvid; 441 442 if (val != ETH_P_8021Q && val != ETH_P_8021AD) 443 return -EPROTONOSUPPORT; 444 445 if (!rtnl_trylock()) 446 return restart_syscall(); 447 448 proto = htons(val); 449 if (br->vlan_proto == proto) 450 goto unlock; 451 452 /* Add VLANs for the new proto to the device filter. */ 453 list_for_each_entry(p, &br->port_list, list) { 454 pv = rtnl_dereference(p->vlan_info); 455 if (!pv) 456 continue; 457 458 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) { 459 err = vlan_vid_add(p->dev, proto, vid); 460 if (err) 461 goto err_filt; 462 } 463 } 464 465 oldproto = br->vlan_proto; 466 br->vlan_proto = proto; 467 468 recalculate_group_addr(br); 469 br_recalculate_fwd_mask(br); 470 471 /* Delete VLANs for the old proto from the device filter. */ 472 list_for_each_entry(p, &br->port_list, list) { 473 pv = rtnl_dereference(p->vlan_info); 474 if (!pv) 475 continue; 476 477 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) 478 vlan_vid_del(p->dev, oldproto, vid); 479 } 480 481 unlock: 482 rtnl_unlock(); 483 return err; 484 485 err_filt: 486 errvid = vid; 487 for_each_set_bit(vid, pv->vlan_bitmap, errvid) 488 vlan_vid_del(p->dev, proto, vid); 489 490 list_for_each_entry_continue_reverse(p, &br->port_list, list) { 491 pv = rtnl_dereference(p->vlan_info); 492 if (!pv) 493 continue; 494 495 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) 496 vlan_vid_del(p->dev, proto, vid); 497 } 498 499 goto unlock; 500 } 501 502 void br_vlan_init(struct net_bridge *br) 503 { 504 br->vlan_proto = htons(ETH_P_8021Q); 505 } 506 507 /* Must be protected by RTNL. 508 * Must be called with vid in range from 1 to 4094 inclusive. 509 */ 510 int nbp_vlan_add(struct net_bridge_port *port, u16 vid, u16 flags) 511 { 512 struct net_port_vlans *pv = NULL; 513 int err; 514 515 ASSERT_RTNL(); 516 517 pv = rtnl_dereference(port->vlan_info); 518 if (pv) 519 return __vlan_add(pv, vid, flags); 520 521 /* Create port vlan infomration 522 */ 523 pv = kzalloc(sizeof(*pv), GFP_KERNEL); 524 if (!pv) { 525 err = -ENOMEM; 526 goto clean_up; 527 } 528 529 pv->port_idx = port->port_no; 530 pv->parent.port = port; 531 err = __vlan_add(pv, vid, flags); 532 if (err) 533 goto clean_up; 534 535 rcu_assign_pointer(port->vlan_info, pv); 536 return 0; 537 538 clean_up: 539 kfree(pv); 540 return err; 541 } 542 543 /* Must be protected by RTNL. 544 * Must be called with vid in range from 1 to 4094 inclusive. 545 */ 546 int nbp_vlan_delete(struct net_bridge_port *port, u16 vid) 547 { 548 struct net_port_vlans *pv; 549 550 ASSERT_RTNL(); 551 552 pv = rtnl_dereference(port->vlan_info); 553 if (!pv) 554 return -EINVAL; 555 556 br_fdb_find_delete_local(port->br, port, port->dev->dev_addr, vid); 557 558 return __vlan_del(pv, vid); 559 } 560 561 void nbp_vlan_flush(struct net_bridge_port *port) 562 { 563 struct net_port_vlans *pv; 564 u16 vid; 565 566 ASSERT_RTNL(); 567 568 pv = rtnl_dereference(port->vlan_info); 569 if (!pv) 570 return; 571 572 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) 573 vlan_vid_del(port->dev, port->br->vlan_proto, vid); 574 575 __vlan_flush(pv); 576 } 577 578 bool nbp_vlan_find(struct net_bridge_port *port, u16 vid) 579 { 580 struct net_port_vlans *pv; 581 bool found = false; 582 583 rcu_read_lock(); 584 pv = rcu_dereference(port->vlan_info); 585 586 if (!pv) 587 goto out; 588 589 if (test_bit(vid, pv->vlan_bitmap)) 590 found = true; 591 592 out: 593 rcu_read_unlock(); 594 return found; 595 } 596