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