1 /* 2 * INET 802.1Q VLAN 3 * Ethernet-type device handling. 4 * 5 * Authors: Ben Greear <greearb@candelatech.com> 6 * Please send support related email to: netdev@vger.kernel.org 7 * VLAN Home Page: http://www.candelatech.com/~greear/vlan.html 8 * 9 * Fixes: 10 * Fix for packet capture - Nick Eggleston <nick@dccinc.com>; 11 * Add HW acceleration hooks - David S. Miller <davem@redhat.com>; 12 * Correct all the locking - David S. Miller <davem@redhat.com>; 13 * Use hash table for VLAN groups - David S. Miller <davem@redhat.com> 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License 17 * as published by the Free Software Foundation; either version 18 * 2 of the License, or (at your option) any later version. 19 */ 20 21 #include <asm/uaccess.h> /* for copy_from_user */ 22 #include <linux/capability.h> 23 #include <linux/module.h> 24 #include <linux/netdevice.h> 25 #include <linux/skbuff.h> 26 #include <net/datalink.h> 27 #include <linux/mm.h> 28 #include <linux/in.h> 29 #include <linux/init.h> 30 #include <net/p8022.h> 31 #include <net/arp.h> 32 #include <linux/rtnetlink.h> 33 #include <linux/notifier.h> 34 #include <net/net_namespace.h> 35 36 #include <linux/if_vlan.h> 37 #include "vlan.h" 38 #include "vlanproc.h" 39 40 #define DRV_VERSION "1.8" 41 42 /* Global VLAN variables */ 43 44 /* Our listing of VLAN group(s) */ 45 static struct hlist_head vlan_group_hash[VLAN_GRP_HASH_SIZE]; 46 47 static char vlan_fullname[] = "802.1Q VLAN Support"; 48 static char vlan_version[] = DRV_VERSION; 49 static char vlan_copyright[] = "Ben Greear <greearb@candelatech.com>"; 50 static char vlan_buggyright[] = "David S. Miller <davem@redhat.com>"; 51 52 /* Determines interface naming scheme. */ 53 unsigned short vlan_name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD; 54 55 static struct packet_type vlan_packet_type = { 56 .type = __constant_htons(ETH_P_8021Q), 57 .func = vlan_skb_recv, /* VLAN receive method */ 58 }; 59 60 /* End of global variables definitions. */ 61 62 static inline unsigned int vlan_grp_hashfn(unsigned int idx) 63 { 64 return ((idx >> VLAN_GRP_HASH_SHIFT) ^ idx) & VLAN_GRP_HASH_MASK; 65 } 66 67 /* Must be invoked with RCU read lock (no preempt) */ 68 static struct vlan_group *__vlan_find_group(int real_dev_ifindex) 69 { 70 struct vlan_group *grp; 71 struct hlist_node *n; 72 int hash = vlan_grp_hashfn(real_dev_ifindex); 73 74 hlist_for_each_entry_rcu(grp, n, &vlan_group_hash[hash], hlist) { 75 if (grp->real_dev_ifindex == real_dev_ifindex) 76 return grp; 77 } 78 79 return NULL; 80 } 81 82 /* Find the protocol handler. Assumes VID < VLAN_VID_MASK. 83 * 84 * Must be invoked with RCU read lock (no preempt) 85 */ 86 struct net_device *__find_vlan_dev(struct net_device *real_dev, 87 unsigned short VID) 88 { 89 struct vlan_group *grp = __vlan_find_group(real_dev->ifindex); 90 91 if (grp) 92 return vlan_group_get_device(grp, VID); 93 94 return NULL; 95 } 96 97 static void vlan_group_free(struct vlan_group *grp) 98 { 99 int i; 100 101 for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++) 102 kfree(grp->vlan_devices_arrays[i]); 103 kfree(grp); 104 } 105 106 static struct vlan_group *vlan_group_alloc(int ifindex) 107 { 108 struct vlan_group *grp; 109 unsigned int size; 110 unsigned int i; 111 112 grp = kzalloc(sizeof(struct vlan_group), GFP_KERNEL); 113 if (!grp) 114 return NULL; 115 116 size = sizeof(struct net_device *) * VLAN_GROUP_ARRAY_PART_LEN; 117 118 for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++) { 119 grp->vlan_devices_arrays[i] = kzalloc(size, GFP_KERNEL); 120 if (!grp->vlan_devices_arrays[i]) 121 goto err; 122 } 123 124 grp->real_dev_ifindex = ifindex; 125 hlist_add_head_rcu(&grp->hlist, 126 &vlan_group_hash[vlan_grp_hashfn(ifindex)]); 127 return grp; 128 129 err: 130 vlan_group_free(grp); 131 return NULL; 132 } 133 134 static void vlan_rcu_free(struct rcu_head *rcu) 135 { 136 vlan_group_free(container_of(rcu, struct vlan_group, rcu)); 137 } 138 139 void unregister_vlan_dev(struct net_device *dev) 140 { 141 struct vlan_dev_info *vlan = vlan_dev_info(dev); 142 struct net_device *real_dev = vlan->real_dev; 143 struct vlan_group *grp; 144 unsigned short vlan_id = vlan->vlan_id; 145 146 ASSERT_RTNL(); 147 148 grp = __vlan_find_group(real_dev->ifindex); 149 BUG_ON(!grp); 150 151 vlan_proc_rem_dev(dev); 152 153 /* Take it out of our own structures, but be sure to interlock with 154 * HW accelerating devices or SW vlan input packet processing. 155 */ 156 if (real_dev->features & NETIF_F_HW_VLAN_FILTER) 157 real_dev->vlan_rx_kill_vid(real_dev, vlan_id); 158 159 vlan_group_set_device(grp, vlan_id, NULL); 160 grp->nr_vlans--; 161 162 synchronize_net(); 163 164 /* If the group is now empty, kill off the group. */ 165 if (grp->nr_vlans == 0) { 166 if (real_dev->features & NETIF_F_HW_VLAN_RX) 167 real_dev->vlan_rx_register(real_dev, NULL); 168 169 hlist_del_rcu(&grp->hlist); 170 171 /* Free the group, after all cpu's are done. */ 172 call_rcu(&grp->rcu, vlan_rcu_free); 173 } 174 175 /* Get rid of the vlan's reference to real_dev */ 176 dev_put(real_dev); 177 178 unregister_netdevice(dev); 179 } 180 181 static void vlan_transfer_operstate(const struct net_device *dev, 182 struct net_device *vlandev) 183 { 184 /* Have to respect userspace enforced dormant state 185 * of real device, also must allow supplicant running 186 * on VLAN device 187 */ 188 if (dev->operstate == IF_OPER_DORMANT) 189 netif_dormant_on(vlandev); 190 else 191 netif_dormant_off(vlandev); 192 193 if (netif_carrier_ok(dev)) { 194 if (!netif_carrier_ok(vlandev)) 195 netif_carrier_on(vlandev); 196 } else { 197 if (netif_carrier_ok(vlandev)) 198 netif_carrier_off(vlandev); 199 } 200 } 201 202 int vlan_check_real_dev(struct net_device *real_dev, unsigned short vlan_id) 203 { 204 char *name = real_dev->name; 205 206 if (real_dev->features & NETIF_F_VLAN_CHALLENGED) { 207 pr_info("8021q: VLANs not supported on %s\n", name); 208 return -EOPNOTSUPP; 209 } 210 211 if ((real_dev->features & NETIF_F_HW_VLAN_RX) && 212 !real_dev->vlan_rx_register) { 213 pr_info("8021q: device %s has buggy VLAN hw accel\n", name); 214 return -EOPNOTSUPP; 215 } 216 217 if ((real_dev->features & NETIF_F_HW_VLAN_FILTER) && 218 (!real_dev->vlan_rx_add_vid || !real_dev->vlan_rx_kill_vid)) { 219 pr_info("8021q: Device %s has buggy VLAN hw accel\n", name); 220 return -EOPNOTSUPP; 221 } 222 223 /* The real device must be up and operating in order to 224 * assosciate a VLAN device with it. 225 */ 226 if (!(real_dev->flags & IFF_UP)) 227 return -ENETDOWN; 228 229 if (__find_vlan_dev(real_dev, vlan_id) != NULL) 230 return -EEXIST; 231 232 return 0; 233 } 234 235 int register_vlan_dev(struct net_device *dev) 236 { 237 struct vlan_dev_info *vlan = vlan_dev_info(dev); 238 struct net_device *real_dev = vlan->real_dev; 239 unsigned short vlan_id = vlan->vlan_id; 240 struct vlan_group *grp, *ngrp = NULL; 241 int err; 242 243 grp = __vlan_find_group(real_dev->ifindex); 244 if (!grp) { 245 ngrp = grp = vlan_group_alloc(real_dev->ifindex); 246 if (!grp) 247 return -ENOBUFS; 248 } 249 250 err = register_netdevice(dev); 251 if (err < 0) 252 goto out_free_group; 253 254 /* Account for reference in struct vlan_dev_info */ 255 dev_hold(real_dev); 256 257 vlan_transfer_operstate(real_dev, dev); 258 linkwatch_fire_event(dev); /* _MUST_ call rfc2863_policy() */ 259 260 /* So, got the sucker initialized, now lets place 261 * it into our local structure. 262 */ 263 vlan_group_set_device(grp, vlan_id, dev); 264 grp->nr_vlans++; 265 266 if (ngrp && real_dev->features & NETIF_F_HW_VLAN_RX) 267 real_dev->vlan_rx_register(real_dev, ngrp); 268 if (real_dev->features & NETIF_F_HW_VLAN_FILTER) 269 real_dev->vlan_rx_add_vid(real_dev, vlan_id); 270 271 if (vlan_proc_add_dev(dev) < 0) 272 pr_warning("8021q: failed to add proc entry for %s\n", 273 dev->name); 274 return 0; 275 276 out_free_group: 277 if (ngrp) 278 vlan_group_free(ngrp); 279 return err; 280 } 281 282 /* Attach a VLAN device to a mac address (ie Ethernet Card). 283 * Returns 0 if the device was created or a negative error code otherwise. 284 */ 285 static int register_vlan_device(struct net_device *real_dev, 286 unsigned short VLAN_ID) 287 { 288 struct net_device *new_dev; 289 char name[IFNAMSIZ]; 290 int err; 291 292 if (VLAN_ID >= VLAN_VID_MASK) 293 return -ERANGE; 294 295 err = vlan_check_real_dev(real_dev, VLAN_ID); 296 if (err < 0) 297 return err; 298 299 /* Gotta set up the fields for the device. */ 300 switch (vlan_name_type) { 301 case VLAN_NAME_TYPE_RAW_PLUS_VID: 302 /* name will look like: eth1.0005 */ 303 snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, VLAN_ID); 304 break; 305 case VLAN_NAME_TYPE_PLUS_VID_NO_PAD: 306 /* Put our vlan.VID in the name. 307 * Name will look like: vlan5 308 */ 309 snprintf(name, IFNAMSIZ, "vlan%i", VLAN_ID); 310 break; 311 case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD: 312 /* Put our vlan.VID in the name. 313 * Name will look like: eth0.5 314 */ 315 snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, VLAN_ID); 316 break; 317 case VLAN_NAME_TYPE_PLUS_VID: 318 /* Put our vlan.VID in the name. 319 * Name will look like: vlan0005 320 */ 321 default: 322 snprintf(name, IFNAMSIZ, "vlan%.4i", VLAN_ID); 323 } 324 325 new_dev = alloc_netdev(sizeof(struct vlan_dev_info), name, 326 vlan_setup); 327 328 if (new_dev == NULL) 329 return -ENOBUFS; 330 331 /* need 4 bytes for extra VLAN header info, 332 * hope the underlying device can handle it. 333 */ 334 new_dev->mtu = real_dev->mtu; 335 336 vlan_dev_info(new_dev)->vlan_id = VLAN_ID; /* 1 through VLAN_VID_MASK */ 337 vlan_dev_info(new_dev)->real_dev = real_dev; 338 vlan_dev_info(new_dev)->dent = NULL; 339 vlan_dev_info(new_dev)->flags = VLAN_FLAG_REORDER_HDR; 340 341 new_dev->rtnl_link_ops = &vlan_link_ops; 342 err = register_vlan_dev(new_dev); 343 if (err < 0) 344 goto out_free_newdev; 345 346 return 0; 347 348 out_free_newdev: 349 free_netdev(new_dev); 350 return err; 351 } 352 353 static void vlan_sync_address(struct net_device *dev, 354 struct net_device *vlandev) 355 { 356 struct vlan_dev_info *vlan = vlan_dev_info(vlandev); 357 358 /* May be called without an actual change */ 359 if (!compare_ether_addr(vlan->real_dev_addr, dev->dev_addr)) 360 return; 361 362 /* vlan address was different from the old address and is equal to 363 * the new address */ 364 if (compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) && 365 !compare_ether_addr(vlandev->dev_addr, dev->dev_addr)) 366 dev_unicast_delete(dev, vlandev->dev_addr, ETH_ALEN); 367 368 /* vlan address was equal to the old address and is different from 369 * the new address */ 370 if (!compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) && 371 compare_ether_addr(vlandev->dev_addr, dev->dev_addr)) 372 dev_unicast_add(dev, vlandev->dev_addr, ETH_ALEN); 373 374 memcpy(vlan->real_dev_addr, dev->dev_addr, ETH_ALEN); 375 } 376 377 static int vlan_device_event(struct notifier_block *unused, unsigned long event, 378 void *ptr) 379 { 380 struct net_device *dev = ptr; 381 struct vlan_group *grp = __vlan_find_group(dev->ifindex); 382 int i, flgs; 383 struct net_device *vlandev; 384 385 if (dev->nd_net != &init_net) 386 return NOTIFY_DONE; 387 388 if (!grp) 389 goto out; 390 391 /* It is OK that we do not hold the group lock right now, 392 * as we run under the RTNL lock. 393 */ 394 395 switch (event) { 396 case NETDEV_CHANGE: 397 /* Propagate real device state to vlan devices */ 398 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 399 vlandev = vlan_group_get_device(grp, i); 400 if (!vlandev) 401 continue; 402 403 vlan_transfer_operstate(dev, vlandev); 404 } 405 break; 406 407 case NETDEV_CHANGEADDR: 408 /* Adjust unicast filters on underlying device */ 409 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 410 vlandev = vlan_group_get_device(grp, i); 411 if (!vlandev) 412 continue; 413 414 flgs = vlandev->flags; 415 if (!(flgs & IFF_UP)) 416 continue; 417 418 vlan_sync_address(dev, vlandev); 419 } 420 break; 421 422 case NETDEV_DOWN: 423 /* Put all VLANs for this dev in the down state too. */ 424 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 425 vlandev = vlan_group_get_device(grp, i); 426 if (!vlandev) 427 continue; 428 429 flgs = vlandev->flags; 430 if (!(flgs & IFF_UP)) 431 continue; 432 433 dev_change_flags(vlandev, flgs & ~IFF_UP); 434 } 435 break; 436 437 case NETDEV_UP: 438 /* Put all VLANs for this dev in the up state too. */ 439 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 440 vlandev = vlan_group_get_device(grp, i); 441 if (!vlandev) 442 continue; 443 444 flgs = vlandev->flags; 445 if (flgs & IFF_UP) 446 continue; 447 448 dev_change_flags(vlandev, flgs | IFF_UP); 449 } 450 break; 451 452 case NETDEV_UNREGISTER: 453 /* Delete all VLANs for this dev. */ 454 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 455 vlandev = vlan_group_get_device(grp, i); 456 if (!vlandev) 457 continue; 458 459 /* unregistration of last vlan destroys group, abort 460 * afterwards */ 461 if (grp->nr_vlans == 1) 462 i = VLAN_GROUP_ARRAY_LEN; 463 464 unregister_vlan_dev(vlandev); 465 } 466 break; 467 } 468 469 out: 470 return NOTIFY_DONE; 471 } 472 473 static struct notifier_block vlan_notifier_block __read_mostly = { 474 .notifier_call = vlan_device_event, 475 }; 476 477 /* 478 * VLAN IOCTL handler. 479 * o execute requested action or pass command to the device driver 480 * arg is really a struct vlan_ioctl_args __user *. 481 */ 482 static int vlan_ioctl_handler(struct net *net, void __user *arg) 483 { 484 int err; 485 unsigned short vid = 0; 486 struct vlan_ioctl_args args; 487 struct net_device *dev = NULL; 488 489 if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args))) 490 return -EFAULT; 491 492 /* Null terminate this sucker, just in case. */ 493 args.device1[23] = 0; 494 args.u.device2[23] = 0; 495 496 rtnl_lock(); 497 498 switch (args.cmd) { 499 case SET_VLAN_INGRESS_PRIORITY_CMD: 500 case SET_VLAN_EGRESS_PRIORITY_CMD: 501 case SET_VLAN_FLAG_CMD: 502 case ADD_VLAN_CMD: 503 case DEL_VLAN_CMD: 504 case GET_VLAN_REALDEV_NAME_CMD: 505 case GET_VLAN_VID_CMD: 506 err = -ENODEV; 507 dev = __dev_get_by_name(&init_net, args.device1); 508 if (!dev) 509 goto out; 510 511 err = -EINVAL; 512 if (args.cmd != ADD_VLAN_CMD && 513 !(dev->priv_flags & IFF_802_1Q_VLAN)) 514 goto out; 515 } 516 517 switch (args.cmd) { 518 case SET_VLAN_INGRESS_PRIORITY_CMD: 519 err = -EPERM; 520 if (!capable(CAP_NET_ADMIN)) 521 break; 522 vlan_dev_set_ingress_priority(dev, 523 args.u.skb_priority, 524 args.vlan_qos); 525 err = 0; 526 break; 527 528 case SET_VLAN_EGRESS_PRIORITY_CMD: 529 err = -EPERM; 530 if (!capable(CAP_NET_ADMIN)) 531 break; 532 err = vlan_dev_set_egress_priority(dev, 533 args.u.skb_priority, 534 args.vlan_qos); 535 break; 536 537 case SET_VLAN_FLAG_CMD: 538 err = -EPERM; 539 if (!capable(CAP_NET_ADMIN)) 540 break; 541 err = vlan_dev_set_vlan_flag(dev, 542 args.u.flag, 543 args.vlan_qos); 544 break; 545 546 case SET_VLAN_NAME_TYPE_CMD: 547 err = -EPERM; 548 if (!capable(CAP_NET_ADMIN)) 549 break; 550 if ((args.u.name_type >= 0) && 551 (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) { 552 vlan_name_type = args.u.name_type; 553 err = 0; 554 } else { 555 err = -EINVAL; 556 } 557 break; 558 559 case ADD_VLAN_CMD: 560 err = -EPERM; 561 if (!capable(CAP_NET_ADMIN)) 562 break; 563 err = register_vlan_device(dev, args.u.VID); 564 break; 565 566 case DEL_VLAN_CMD: 567 err = -EPERM; 568 if (!capable(CAP_NET_ADMIN)) 569 break; 570 unregister_vlan_dev(dev); 571 err = 0; 572 break; 573 574 case GET_VLAN_REALDEV_NAME_CMD: 575 err = 0; 576 vlan_dev_get_realdev_name(dev, args.u.device2); 577 if (copy_to_user(arg, &args, 578 sizeof(struct vlan_ioctl_args))) 579 err = -EFAULT; 580 break; 581 582 case GET_VLAN_VID_CMD: 583 err = 0; 584 vlan_dev_get_vid(dev, &vid); 585 args.u.VID = vid; 586 if (copy_to_user(arg, &args, 587 sizeof(struct vlan_ioctl_args))) 588 err = -EFAULT; 589 break; 590 591 default: 592 err = -EOPNOTSUPP; 593 break; 594 } 595 out: 596 rtnl_unlock(); 597 return err; 598 } 599 600 static int __init vlan_proto_init(void) 601 { 602 int err; 603 604 pr_info("%s v%s %s\n", vlan_fullname, vlan_version, vlan_copyright); 605 pr_info("All bugs added by %s\n", vlan_buggyright); 606 607 err = vlan_proc_init(); 608 if (err < 0) 609 goto err1; 610 611 err = register_netdevice_notifier(&vlan_notifier_block); 612 if (err < 0) 613 goto err2; 614 615 err = vlan_netlink_init(); 616 if (err < 0) 617 goto err3; 618 619 dev_add_pack(&vlan_packet_type); 620 vlan_ioctl_set(vlan_ioctl_handler); 621 return 0; 622 623 err3: 624 unregister_netdevice_notifier(&vlan_notifier_block); 625 err2: 626 vlan_proc_cleanup(); 627 err1: 628 return err; 629 } 630 631 static void __exit vlan_cleanup_module(void) 632 { 633 unsigned int i; 634 635 vlan_ioctl_set(NULL); 636 vlan_netlink_fini(); 637 638 unregister_netdevice_notifier(&vlan_notifier_block); 639 640 dev_remove_pack(&vlan_packet_type); 641 642 /* This table must be empty if there are no module references left. */ 643 for (i = 0; i < VLAN_GRP_HASH_SIZE; i++) 644 BUG_ON(!hlist_empty(&vlan_group_hash[i])); 645 646 vlan_proc_cleanup(); 647 648 synchronize_net(); 649 } 650 651 module_init(vlan_proto_init); 652 module_exit(vlan_cleanup_module); 653 654 MODULE_LICENSE("GPL"); 655 MODULE_VERSION(DRV_VERSION); 656