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 void __vlan_device_event(struct net_device *dev, unsigned long event) 378 { 379 switch (event) { 380 case NETDEV_CHANGENAME: 381 vlan_proc_rem_dev(dev); 382 if (vlan_proc_add_dev(dev) < 0) 383 pr_warning("8021q: failed to change proc name for %s\n", 384 dev->name); 385 break; 386 } 387 } 388 389 static int vlan_device_event(struct notifier_block *unused, unsigned long event, 390 void *ptr) 391 { 392 struct net_device *dev = ptr; 393 struct vlan_group *grp; 394 int i, flgs; 395 struct net_device *vlandev; 396 397 if (dev->nd_net != &init_net) 398 return NOTIFY_DONE; 399 400 if (is_vlan_dev(dev)) { 401 __vlan_device_event(dev, event); 402 goto out; 403 } 404 405 grp = __vlan_find_group(dev->ifindex); 406 if (!grp) 407 goto out; 408 409 /* It is OK that we do not hold the group lock right now, 410 * as we run under the RTNL lock. 411 */ 412 413 switch (event) { 414 case NETDEV_CHANGE: 415 /* Propagate real device state to vlan devices */ 416 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 417 vlandev = vlan_group_get_device(grp, i); 418 if (!vlandev) 419 continue; 420 421 vlan_transfer_operstate(dev, vlandev); 422 } 423 break; 424 425 case NETDEV_CHANGEADDR: 426 /* Adjust unicast filters on underlying device */ 427 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 428 vlandev = vlan_group_get_device(grp, i); 429 if (!vlandev) 430 continue; 431 432 flgs = vlandev->flags; 433 if (!(flgs & IFF_UP)) 434 continue; 435 436 vlan_sync_address(dev, vlandev); 437 } 438 break; 439 440 case NETDEV_DOWN: 441 /* Put all VLANs for this dev in the down state too. */ 442 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 443 vlandev = vlan_group_get_device(grp, i); 444 if (!vlandev) 445 continue; 446 447 flgs = vlandev->flags; 448 if (!(flgs & IFF_UP)) 449 continue; 450 451 dev_change_flags(vlandev, flgs & ~IFF_UP); 452 } 453 break; 454 455 case NETDEV_UP: 456 /* Put all VLANs for this dev in the up state too. */ 457 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 458 vlandev = vlan_group_get_device(grp, i); 459 if (!vlandev) 460 continue; 461 462 flgs = vlandev->flags; 463 if (flgs & IFF_UP) 464 continue; 465 466 dev_change_flags(vlandev, flgs | IFF_UP); 467 } 468 break; 469 470 case NETDEV_UNREGISTER: 471 /* Delete all VLANs for this dev. */ 472 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 473 vlandev = vlan_group_get_device(grp, i); 474 if (!vlandev) 475 continue; 476 477 /* unregistration of last vlan destroys group, abort 478 * afterwards */ 479 if (grp->nr_vlans == 1) 480 i = VLAN_GROUP_ARRAY_LEN; 481 482 unregister_vlan_dev(vlandev); 483 } 484 break; 485 } 486 487 out: 488 return NOTIFY_DONE; 489 } 490 491 static struct notifier_block vlan_notifier_block __read_mostly = { 492 .notifier_call = vlan_device_event, 493 }; 494 495 /* 496 * VLAN IOCTL handler. 497 * o execute requested action or pass command to the device driver 498 * arg is really a struct vlan_ioctl_args __user *. 499 */ 500 static int vlan_ioctl_handler(struct net *net, void __user *arg) 501 { 502 int err; 503 unsigned short vid = 0; 504 struct vlan_ioctl_args args; 505 struct net_device *dev = NULL; 506 507 if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args))) 508 return -EFAULT; 509 510 /* Null terminate this sucker, just in case. */ 511 args.device1[23] = 0; 512 args.u.device2[23] = 0; 513 514 rtnl_lock(); 515 516 switch (args.cmd) { 517 case SET_VLAN_INGRESS_PRIORITY_CMD: 518 case SET_VLAN_EGRESS_PRIORITY_CMD: 519 case SET_VLAN_FLAG_CMD: 520 case ADD_VLAN_CMD: 521 case DEL_VLAN_CMD: 522 case GET_VLAN_REALDEV_NAME_CMD: 523 case GET_VLAN_VID_CMD: 524 err = -ENODEV; 525 dev = __dev_get_by_name(&init_net, args.device1); 526 if (!dev) 527 goto out; 528 529 err = -EINVAL; 530 if (args.cmd != ADD_VLAN_CMD && 531 !(dev->priv_flags & IFF_802_1Q_VLAN)) 532 goto out; 533 } 534 535 switch (args.cmd) { 536 case SET_VLAN_INGRESS_PRIORITY_CMD: 537 err = -EPERM; 538 if (!capable(CAP_NET_ADMIN)) 539 break; 540 vlan_dev_set_ingress_priority(dev, 541 args.u.skb_priority, 542 args.vlan_qos); 543 err = 0; 544 break; 545 546 case SET_VLAN_EGRESS_PRIORITY_CMD: 547 err = -EPERM; 548 if (!capable(CAP_NET_ADMIN)) 549 break; 550 err = vlan_dev_set_egress_priority(dev, 551 args.u.skb_priority, 552 args.vlan_qos); 553 break; 554 555 case SET_VLAN_FLAG_CMD: 556 err = -EPERM; 557 if (!capable(CAP_NET_ADMIN)) 558 break; 559 err = vlan_dev_set_vlan_flag(dev, 560 args.u.flag, 561 args.vlan_qos); 562 break; 563 564 case SET_VLAN_NAME_TYPE_CMD: 565 err = -EPERM; 566 if (!capable(CAP_NET_ADMIN)) 567 break; 568 if ((args.u.name_type >= 0) && 569 (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) { 570 vlan_name_type = args.u.name_type; 571 err = 0; 572 } else { 573 err = -EINVAL; 574 } 575 break; 576 577 case ADD_VLAN_CMD: 578 err = -EPERM; 579 if (!capable(CAP_NET_ADMIN)) 580 break; 581 err = register_vlan_device(dev, args.u.VID); 582 break; 583 584 case DEL_VLAN_CMD: 585 err = -EPERM; 586 if (!capable(CAP_NET_ADMIN)) 587 break; 588 unregister_vlan_dev(dev); 589 err = 0; 590 break; 591 592 case GET_VLAN_REALDEV_NAME_CMD: 593 err = 0; 594 vlan_dev_get_realdev_name(dev, args.u.device2); 595 if (copy_to_user(arg, &args, 596 sizeof(struct vlan_ioctl_args))) 597 err = -EFAULT; 598 break; 599 600 case GET_VLAN_VID_CMD: 601 err = 0; 602 vlan_dev_get_vid(dev, &vid); 603 args.u.VID = vid; 604 if (copy_to_user(arg, &args, 605 sizeof(struct vlan_ioctl_args))) 606 err = -EFAULT; 607 break; 608 609 default: 610 err = -EOPNOTSUPP; 611 break; 612 } 613 out: 614 rtnl_unlock(); 615 return err; 616 } 617 618 static int __init vlan_proto_init(void) 619 { 620 int err; 621 622 pr_info("%s v%s %s\n", vlan_fullname, vlan_version, vlan_copyright); 623 pr_info("All bugs added by %s\n", vlan_buggyright); 624 625 err = vlan_proc_init(); 626 if (err < 0) 627 goto err1; 628 629 err = register_netdevice_notifier(&vlan_notifier_block); 630 if (err < 0) 631 goto err2; 632 633 err = vlan_netlink_init(); 634 if (err < 0) 635 goto err3; 636 637 dev_add_pack(&vlan_packet_type); 638 vlan_ioctl_set(vlan_ioctl_handler); 639 return 0; 640 641 err3: 642 unregister_netdevice_notifier(&vlan_notifier_block); 643 err2: 644 vlan_proc_cleanup(); 645 err1: 646 return err; 647 } 648 649 static void __exit vlan_cleanup_module(void) 650 { 651 unsigned int i; 652 653 vlan_ioctl_set(NULL); 654 vlan_netlink_fini(); 655 656 unregister_netdevice_notifier(&vlan_notifier_block); 657 658 dev_remove_pack(&vlan_packet_type); 659 660 /* This table must be empty if there are no module references left. */ 661 for (i = 0; i < VLAN_GRP_HASH_SIZE; i++) 662 BUG_ON(!hlist_empty(&vlan_group_hash[i])); 663 664 vlan_proc_cleanup(); 665 666 synchronize_net(); 667 } 668 669 module_init(vlan_proto_init); 670 module_exit(vlan_cleanup_module); 671 672 MODULE_LICENSE("GPL"); 673 MODULE_VERSION(DRV_VERSION); 674