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 * Stricly speaking, this is not necessary now, since 59 * devices are made promiscuous by the bridge, but if 60 * that ever changes this code will allow tagged 61 * traffic to enter the bridge. 62 */ 63 err = vlan_vid_add(dev, htons(ETH_P_8021Q), vid); 64 if (err) 65 return err; 66 } 67 68 err = br_fdb_insert(br, p, dev->dev_addr, vid); 69 if (err) { 70 br_err(br, "failed insert local address into bridge " 71 "forwarding table\n"); 72 goto out_filt; 73 } 74 75 set_bit(vid, v->vlan_bitmap); 76 v->num_vlans++; 77 __vlan_add_flags(v, vid, flags); 78 79 return 0; 80 81 out_filt: 82 if (p) 83 vlan_vid_del(dev, htons(ETH_P_8021Q), vid); 84 return err; 85 } 86 87 static int __vlan_del(struct net_port_vlans *v, u16 vid) 88 { 89 if (!test_bit(vid, v->vlan_bitmap)) 90 return -EINVAL; 91 92 __vlan_delete_pvid(v, vid); 93 clear_bit(vid, v->untagged_bitmap); 94 95 if (v->port_idx) 96 vlan_vid_del(v->parent.port->dev, htons(ETH_P_8021Q), vid); 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_assign_pointer(v->parent.port->vlan_info, NULL); 103 else 104 rcu_assign_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_assign_pointer(v->parent.port->vlan_info, NULL); 117 else 118 rcu_assign_pointer(v->parent.br->vlan_info, NULL); 119 kfree_rcu(v, rcu); 120 } 121 122 /* Strip the tag from the packet. Will return skb with tci set 0. */ 123 static struct sk_buff *br_vlan_untag(struct sk_buff *skb) 124 { 125 if (skb->protocol != htons(ETH_P_8021Q)) { 126 skb->vlan_tci = 0; 127 return skb; 128 } 129 130 skb->vlan_tci = 0; 131 skb = vlan_untag(skb); 132 if (skb) 133 skb->vlan_tci = 0; 134 135 return skb; 136 } 137 138 struct sk_buff *br_handle_vlan(struct net_bridge *br, 139 const struct net_port_vlans *pv, 140 struct sk_buff *skb) 141 { 142 u16 vid; 143 144 if (!br->vlan_enabled) 145 goto out; 146 147 /* At this point, we know that the frame was filtered and contains 148 * a valid vlan id. If the vlan id is set in the untagged bitmap, 149 * send untagged; otherwise, send tagged. 150 */ 151 br_vlan_get_tag(skb, &vid); 152 if (test_bit(vid, pv->untagged_bitmap)) 153 skb = br_vlan_untag(skb); 154 155 out: 156 return skb; 157 } 158 159 /* Called under RCU */ 160 bool br_allowed_ingress(struct net_bridge *br, struct net_port_vlans *v, 161 struct sk_buff *skb, u16 *vid) 162 { 163 int err; 164 165 /* If VLAN filtering is disabled on the bridge, all packets are 166 * permitted. 167 */ 168 if (!br->vlan_enabled) 169 return true; 170 171 /* If there are no vlan in the permitted list, all packets are 172 * rejected. 173 */ 174 if (!v) 175 return false; 176 177 err = br_vlan_get_tag(skb, vid); 178 if (!*vid) { 179 u16 pvid = br_get_pvid(v); 180 181 /* Frame had a tag with VID 0 or did not have a tag. 182 * See if pvid is set on this port. That tells us which 183 * vlan untagged or priority-tagged traffic belongs to. 184 */ 185 if (pvid == VLAN_N_VID) 186 return false; 187 188 /* PVID is set on this port. Any untagged or priority-tagged 189 * ingress frame is considered to belong to this vlan. 190 */ 191 *vid = pvid; 192 if (likely(err)) 193 /* Untagged Frame. */ 194 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), pvid); 195 else 196 /* Priority-tagged Frame. 197 * At this point, We know that skb->vlan_tci had 198 * VLAN_TAG_PRESENT bit and its VID field was 0x000. 199 * We update only VID field and preserve PCP field. 200 */ 201 skb->vlan_tci |= pvid; 202 203 return true; 204 } 205 206 /* Frame had a valid vlan tag. See if vlan is allowed */ 207 if (test_bit(*vid, v->vlan_bitmap)) 208 return true; 209 210 return false; 211 } 212 213 /* Called under RCU. */ 214 bool br_allowed_egress(struct net_bridge *br, 215 const struct net_port_vlans *v, 216 const struct sk_buff *skb) 217 { 218 u16 vid; 219 220 if (!br->vlan_enabled) 221 return true; 222 223 if (!v) 224 return false; 225 226 br_vlan_get_tag(skb, &vid); 227 if (test_bit(vid, v->vlan_bitmap)) 228 return true; 229 230 return false; 231 } 232 233 /* Must be protected by RTNL. 234 * Must be called with vid in range from 1 to 4094 inclusive. 235 */ 236 int br_vlan_add(struct net_bridge *br, u16 vid, u16 flags) 237 { 238 struct net_port_vlans *pv = NULL; 239 int err; 240 241 ASSERT_RTNL(); 242 243 pv = rtnl_dereference(br->vlan_info); 244 if (pv) 245 return __vlan_add(pv, vid, flags); 246 247 /* Create port vlan infomration 248 */ 249 pv = kzalloc(sizeof(*pv), GFP_KERNEL); 250 if (!pv) 251 return -ENOMEM; 252 253 pv->parent.br = br; 254 err = __vlan_add(pv, vid, flags); 255 if (err) 256 goto out; 257 258 rcu_assign_pointer(br->vlan_info, pv); 259 return 0; 260 out: 261 kfree(pv); 262 return err; 263 } 264 265 /* Must be protected by RTNL. 266 * Must be called with vid in range from 1 to 4094 inclusive. 267 */ 268 int br_vlan_delete(struct net_bridge *br, u16 vid) 269 { 270 struct net_port_vlans *pv; 271 272 ASSERT_RTNL(); 273 274 pv = rtnl_dereference(br->vlan_info); 275 if (!pv) 276 return -EINVAL; 277 278 br_fdb_find_delete_local(br, NULL, br->dev->dev_addr, vid); 279 280 __vlan_del(pv, vid); 281 return 0; 282 } 283 284 void br_vlan_flush(struct net_bridge *br) 285 { 286 struct net_port_vlans *pv; 287 288 ASSERT_RTNL(); 289 pv = rtnl_dereference(br->vlan_info); 290 if (!pv) 291 return; 292 293 __vlan_flush(pv); 294 } 295 296 bool br_vlan_find(struct net_bridge *br, u16 vid) 297 { 298 struct net_port_vlans *pv; 299 bool found = false; 300 301 rcu_read_lock(); 302 pv = rcu_dereference(br->vlan_info); 303 304 if (!pv) 305 goto out; 306 307 if (test_bit(vid, pv->vlan_bitmap)) 308 found = true; 309 310 out: 311 rcu_read_unlock(); 312 return found; 313 } 314 315 int br_vlan_filter_toggle(struct net_bridge *br, unsigned long val) 316 { 317 if (!rtnl_trylock()) 318 return restart_syscall(); 319 320 if (br->vlan_enabled == val) 321 goto unlock; 322 323 br->vlan_enabled = val; 324 325 unlock: 326 rtnl_unlock(); 327 return 0; 328 } 329 330 /* Must be protected by RTNL. 331 * Must be called with vid in range from 1 to 4094 inclusive. 332 */ 333 int nbp_vlan_add(struct net_bridge_port *port, u16 vid, u16 flags) 334 { 335 struct net_port_vlans *pv = NULL; 336 int err; 337 338 ASSERT_RTNL(); 339 340 pv = rtnl_dereference(port->vlan_info); 341 if (pv) 342 return __vlan_add(pv, vid, flags); 343 344 /* Create port vlan infomration 345 */ 346 pv = kzalloc(sizeof(*pv), GFP_KERNEL); 347 if (!pv) { 348 err = -ENOMEM; 349 goto clean_up; 350 } 351 352 pv->port_idx = port->port_no; 353 pv->parent.port = port; 354 err = __vlan_add(pv, vid, flags); 355 if (err) 356 goto clean_up; 357 358 rcu_assign_pointer(port->vlan_info, pv); 359 return 0; 360 361 clean_up: 362 kfree(pv); 363 return err; 364 } 365 366 /* Must be protected by RTNL. 367 * Must be called with vid in range from 1 to 4094 inclusive. 368 */ 369 int nbp_vlan_delete(struct net_bridge_port *port, u16 vid) 370 { 371 struct net_port_vlans *pv; 372 373 ASSERT_RTNL(); 374 375 pv = rtnl_dereference(port->vlan_info); 376 if (!pv) 377 return -EINVAL; 378 379 br_fdb_find_delete_local(port->br, port, port->dev->dev_addr, vid); 380 381 return __vlan_del(pv, vid); 382 } 383 384 void nbp_vlan_flush(struct net_bridge_port *port) 385 { 386 struct net_port_vlans *pv; 387 u16 vid; 388 389 ASSERT_RTNL(); 390 391 pv = rtnl_dereference(port->vlan_info); 392 if (!pv) 393 return; 394 395 for_each_set_bit(vid, pv->vlan_bitmap, VLAN_N_VID) 396 vlan_vid_del(port->dev, htons(ETH_P_8021Q), vid); 397 398 __vlan_flush(pv); 399 } 400 401 bool nbp_vlan_find(struct net_bridge_port *port, u16 vid) 402 { 403 struct net_port_vlans *pv; 404 bool found = false; 405 406 rcu_read_lock(); 407 pv = rcu_dereference(port->vlan_info); 408 409 if (!pv) 410 goto out; 411 412 if (test_bit(vid, pv->vlan_bitmap)) 413 found = true; 414 415 out: 416 rcu_read_unlock(); 417 return found; 418 } 419