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 <linux/capability.h> 22 #include <linux/module.h> 23 #include <linux/netdevice.h> 24 #include <linux/skbuff.h> 25 #include <linux/init.h> 26 #include <linux/rculist.h> 27 #include <net/p8022.h> 28 #include <net/arp.h> 29 #include <linux/rtnetlink.h> 30 #include <linux/notifier.h> 31 #include <net/rtnetlink.h> 32 #include <net/net_namespace.h> 33 #include <net/netns/generic.h> 34 #include <asm/uaccess.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 int vlan_net_id; 45 46 /* Our listing of VLAN group(s) */ 47 static struct hlist_head vlan_group_hash[VLAN_GRP_HASH_SIZE]; 48 49 const char vlan_fullname[] = "802.1Q VLAN Support"; 50 const char vlan_version[] = DRV_VERSION; 51 static const char vlan_copyright[] = "Ben Greear <greearb@candelatech.com>"; 52 static const char vlan_buggyright[] = "David S. Miller <davem@redhat.com>"; 53 54 static struct packet_type vlan_packet_type __read_mostly = { 55 .type = cpu_to_be16(ETH_P_8021Q), 56 .func = vlan_skb_recv, /* VLAN receive method */ 57 }; 58 59 /* End of global variables definitions. */ 60 61 static inline unsigned int vlan_grp_hashfn(unsigned int idx) 62 { 63 return ((idx >> VLAN_GRP_HASH_SHIFT) ^ idx) & VLAN_GRP_HASH_MASK; 64 } 65 66 /* Must be invoked with RCU read lock (no preempt) */ 67 static struct vlan_group *__vlan_find_group(struct net_device *real_dev) 68 { 69 struct vlan_group *grp; 70 struct hlist_node *n; 71 int hash = vlan_grp_hashfn(real_dev->ifindex); 72 73 hlist_for_each_entry_rcu(grp, n, &vlan_group_hash[hash], hlist) { 74 if (grp->real_dev == real_dev) 75 return grp; 76 } 77 78 return NULL; 79 } 80 81 /* Find the protocol handler. Assumes VID < VLAN_VID_MASK. 82 * 83 * Must be invoked with RCU read lock (no preempt) 84 */ 85 struct net_device *__find_vlan_dev(struct net_device *real_dev, u16 vlan_id) 86 { 87 struct vlan_group *grp = __vlan_find_group(real_dev); 88 89 if (grp) 90 return vlan_group_get_device(grp, vlan_id); 91 92 return NULL; 93 } 94 95 static void vlan_group_free(struct vlan_group *grp) 96 { 97 int i; 98 99 for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++) 100 kfree(grp->vlan_devices_arrays[i]); 101 kfree(grp); 102 } 103 104 static struct vlan_group *vlan_group_alloc(struct net_device *real_dev) 105 { 106 struct vlan_group *grp; 107 108 grp = kzalloc(sizeof(struct vlan_group), GFP_KERNEL); 109 if (!grp) 110 return NULL; 111 112 grp->real_dev = real_dev; 113 hlist_add_head_rcu(&grp->hlist, 114 &vlan_group_hash[vlan_grp_hashfn(real_dev->ifindex)]); 115 return grp; 116 } 117 118 static int vlan_group_prealloc_vid(struct vlan_group *vg, u16 vlan_id) 119 { 120 struct net_device **array; 121 unsigned int size; 122 123 ASSERT_RTNL(); 124 125 array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN]; 126 if (array != NULL) 127 return 0; 128 129 size = sizeof(struct net_device *) * VLAN_GROUP_ARRAY_PART_LEN; 130 array = kzalloc(size, GFP_KERNEL); 131 if (array == NULL) 132 return -ENOBUFS; 133 134 vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN] = array; 135 return 0; 136 } 137 138 static void vlan_rcu_free(struct rcu_head *rcu) 139 { 140 vlan_group_free(container_of(rcu, struct vlan_group, rcu)); 141 } 142 143 void unregister_vlan_dev(struct net_device *dev) 144 { 145 struct vlan_dev_info *vlan = vlan_dev_info(dev); 146 struct net_device *real_dev = vlan->real_dev; 147 const struct net_device_ops *ops = real_dev->netdev_ops; 148 struct vlan_group *grp; 149 u16 vlan_id = vlan->vlan_id; 150 151 ASSERT_RTNL(); 152 153 grp = __vlan_find_group(real_dev); 154 BUG_ON(!grp); 155 156 /* Take it out of our own structures, but be sure to interlock with 157 * HW accelerating devices or SW vlan input packet processing. 158 */ 159 if (real_dev->features & NETIF_F_HW_VLAN_FILTER) 160 ops->ndo_vlan_rx_kill_vid(real_dev, vlan_id); 161 162 vlan_group_set_device(grp, vlan_id, NULL); 163 grp->nr_vlans--; 164 165 synchronize_net(); 166 167 unregister_netdevice(dev); 168 169 /* If the group is now empty, kill off the group. */ 170 if (grp->nr_vlans == 0) { 171 vlan_gvrp_uninit_applicant(real_dev); 172 173 if (real_dev->features & NETIF_F_HW_VLAN_RX) 174 ops->ndo_vlan_rx_register(real_dev, NULL); 175 176 hlist_del_rcu(&grp->hlist); 177 178 /* Free the group, after all cpu's are done. */ 179 call_rcu(&grp->rcu, vlan_rcu_free); 180 } 181 182 /* Get rid of the vlan's reference to real_dev */ 183 dev_put(real_dev); 184 } 185 186 static void vlan_transfer_operstate(const struct net_device *dev, 187 struct net_device *vlandev) 188 { 189 /* Have to respect userspace enforced dormant state 190 * of real device, also must allow supplicant running 191 * on VLAN device 192 */ 193 if (dev->operstate == IF_OPER_DORMANT) 194 netif_dormant_on(vlandev); 195 else 196 netif_dormant_off(vlandev); 197 198 if (netif_carrier_ok(dev)) { 199 if (!netif_carrier_ok(vlandev)) 200 netif_carrier_on(vlandev); 201 } else { 202 if (netif_carrier_ok(vlandev)) 203 netif_carrier_off(vlandev); 204 } 205 } 206 207 int vlan_check_real_dev(struct net_device *real_dev, u16 vlan_id) 208 { 209 const char *name = real_dev->name; 210 const struct net_device_ops *ops = real_dev->netdev_ops; 211 212 if (real_dev->features & NETIF_F_VLAN_CHALLENGED) { 213 pr_info("8021q: VLANs not supported on %s\n", name); 214 return -EOPNOTSUPP; 215 } 216 217 if ((real_dev->features & NETIF_F_HW_VLAN_RX) && !ops->ndo_vlan_rx_register) { 218 pr_info("8021q: device %s has buggy VLAN hw accel\n", name); 219 return -EOPNOTSUPP; 220 } 221 222 if ((real_dev->features & NETIF_F_HW_VLAN_FILTER) && 223 (!ops->ndo_vlan_rx_add_vid || !ops->ndo_vlan_rx_kill_vid)) { 224 pr_info("8021q: Device %s has buggy VLAN hw accel\n", name); 225 return -EOPNOTSUPP; 226 } 227 228 /* The real device must be up and operating in order to 229 * assosciate a VLAN device with it. 230 */ 231 if (!(real_dev->flags & IFF_UP)) 232 return -ENETDOWN; 233 234 if (__find_vlan_dev(real_dev, vlan_id) != NULL) 235 return -EEXIST; 236 237 return 0; 238 } 239 240 int register_vlan_dev(struct net_device *dev) 241 { 242 struct vlan_dev_info *vlan = vlan_dev_info(dev); 243 struct net_device *real_dev = vlan->real_dev; 244 const struct net_device_ops *ops = real_dev->netdev_ops; 245 u16 vlan_id = vlan->vlan_id; 246 struct vlan_group *grp, *ngrp = NULL; 247 int err; 248 249 grp = __vlan_find_group(real_dev); 250 if (!grp) { 251 ngrp = grp = vlan_group_alloc(real_dev); 252 if (!grp) 253 return -ENOBUFS; 254 err = vlan_gvrp_init_applicant(real_dev); 255 if (err < 0) 256 goto out_free_group; 257 } 258 259 err = vlan_group_prealloc_vid(grp, vlan_id); 260 if (err < 0) 261 goto out_uninit_applicant; 262 263 err = register_netdevice(dev); 264 if (err < 0) 265 goto out_uninit_applicant; 266 267 /* Account for reference in struct vlan_dev_info */ 268 dev_hold(real_dev); 269 270 vlan_transfer_operstate(real_dev, dev); 271 linkwatch_fire_event(dev); /* _MUST_ call rfc2863_policy() */ 272 273 /* So, got the sucker initialized, now lets place 274 * it into our local structure. 275 */ 276 vlan_group_set_device(grp, vlan_id, dev); 277 grp->nr_vlans++; 278 279 if (ngrp && real_dev->features & NETIF_F_HW_VLAN_RX) 280 ops->ndo_vlan_rx_register(real_dev, ngrp); 281 if (real_dev->features & NETIF_F_HW_VLAN_FILTER) 282 ops->ndo_vlan_rx_add_vid(real_dev, vlan_id); 283 284 return 0; 285 286 out_uninit_applicant: 287 if (ngrp) 288 vlan_gvrp_uninit_applicant(real_dev); 289 out_free_group: 290 if (ngrp) 291 vlan_group_free(ngrp); 292 return err; 293 } 294 295 /* Attach a VLAN device to a mac address (ie Ethernet Card). 296 * Returns 0 if the device was created or a negative error code otherwise. 297 */ 298 static int register_vlan_device(struct net_device *real_dev, u16 vlan_id) 299 { 300 struct net_device *new_dev; 301 struct net *net = dev_net(real_dev); 302 struct vlan_net *vn = net_generic(net, vlan_net_id); 303 char name[IFNAMSIZ]; 304 int err; 305 306 if (vlan_id >= VLAN_VID_MASK) 307 return -ERANGE; 308 309 err = vlan_check_real_dev(real_dev, vlan_id); 310 if (err < 0) 311 return err; 312 313 /* Gotta set up the fields for the device. */ 314 switch (vn->name_type) { 315 case VLAN_NAME_TYPE_RAW_PLUS_VID: 316 /* name will look like: eth1.0005 */ 317 snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, vlan_id); 318 break; 319 case VLAN_NAME_TYPE_PLUS_VID_NO_PAD: 320 /* Put our vlan.VID in the name. 321 * Name will look like: vlan5 322 */ 323 snprintf(name, IFNAMSIZ, "vlan%i", vlan_id); 324 break; 325 case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD: 326 /* Put our vlan.VID in the name. 327 * Name will look like: eth0.5 328 */ 329 snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, vlan_id); 330 break; 331 case VLAN_NAME_TYPE_PLUS_VID: 332 /* Put our vlan.VID in the name. 333 * Name will look like: vlan0005 334 */ 335 default: 336 snprintf(name, IFNAMSIZ, "vlan%.4i", vlan_id); 337 } 338 339 new_dev = alloc_netdev(sizeof(struct vlan_dev_info), name, 340 vlan_setup); 341 342 if (new_dev == NULL) 343 return -ENOBUFS; 344 345 dev_net_set(new_dev, net); 346 /* need 4 bytes for extra VLAN header info, 347 * hope the underlying device can handle it. 348 */ 349 new_dev->mtu = real_dev->mtu; 350 351 vlan_dev_info(new_dev)->vlan_id = vlan_id; 352 vlan_dev_info(new_dev)->real_dev = real_dev; 353 vlan_dev_info(new_dev)->dent = NULL; 354 vlan_dev_info(new_dev)->flags = VLAN_FLAG_REORDER_HDR; 355 356 new_dev->rtnl_link_ops = &vlan_link_ops; 357 err = register_vlan_dev(new_dev); 358 if (err < 0) 359 goto out_free_newdev; 360 361 return 0; 362 363 out_free_newdev: 364 free_netdev(new_dev); 365 return err; 366 } 367 368 static void vlan_sync_address(struct net_device *dev, 369 struct net_device *vlandev) 370 { 371 struct vlan_dev_info *vlan = vlan_dev_info(vlandev); 372 373 /* May be called without an actual change */ 374 if (!compare_ether_addr(vlan->real_dev_addr, dev->dev_addr)) 375 return; 376 377 /* vlan address was different from the old address and is equal to 378 * the new address */ 379 if (compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) && 380 !compare_ether_addr(vlandev->dev_addr, dev->dev_addr)) 381 dev_unicast_delete(dev, vlandev->dev_addr, ETH_ALEN); 382 383 /* vlan address was equal to the old address and is different from 384 * the new address */ 385 if (!compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) && 386 compare_ether_addr(vlandev->dev_addr, dev->dev_addr)) 387 dev_unicast_add(dev, vlandev->dev_addr, ETH_ALEN); 388 389 memcpy(vlan->real_dev_addr, dev->dev_addr, ETH_ALEN); 390 } 391 392 static void vlan_transfer_features(struct net_device *dev, 393 struct net_device *vlandev) 394 { 395 unsigned long old_features = vlandev->features; 396 397 vlandev->features &= ~dev->vlan_features; 398 vlandev->features |= dev->features & dev->vlan_features; 399 vlandev->gso_max_size = dev->gso_max_size; 400 401 if (old_features != vlandev->features) 402 netdev_features_change(vlandev); 403 } 404 405 static void __vlan_device_event(struct net_device *dev, unsigned long event) 406 { 407 switch (event) { 408 case NETDEV_CHANGENAME: 409 vlan_proc_rem_dev(dev); 410 if (vlan_proc_add_dev(dev) < 0) 411 pr_warning("8021q: failed to change proc name for %s\n", 412 dev->name); 413 break; 414 case NETDEV_REGISTER: 415 if (vlan_proc_add_dev(dev) < 0) 416 pr_warning("8021q: failed to add proc entry for %s\n", 417 dev->name); 418 break; 419 case NETDEV_UNREGISTER: 420 vlan_proc_rem_dev(dev); 421 break; 422 } 423 } 424 425 static int vlan_device_event(struct notifier_block *unused, unsigned long event, 426 void *ptr) 427 { 428 struct net_device *dev = ptr; 429 struct vlan_group *grp; 430 int i, flgs; 431 struct net_device *vlandev; 432 433 if (is_vlan_dev(dev)) 434 __vlan_device_event(dev, event); 435 436 grp = __vlan_find_group(dev); 437 if (!grp) 438 goto out; 439 440 /* It is OK that we do not hold the group lock right now, 441 * as we run under the RTNL lock. 442 */ 443 444 switch (event) { 445 case NETDEV_CHANGE: 446 /* Propagate real device state to vlan devices */ 447 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 448 vlandev = vlan_group_get_device(grp, i); 449 if (!vlandev) 450 continue; 451 452 vlan_transfer_operstate(dev, vlandev); 453 } 454 break; 455 456 case NETDEV_CHANGEADDR: 457 /* Adjust unicast filters on underlying device */ 458 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 459 vlandev = vlan_group_get_device(grp, i); 460 if (!vlandev) 461 continue; 462 463 flgs = vlandev->flags; 464 if (!(flgs & IFF_UP)) 465 continue; 466 467 vlan_sync_address(dev, vlandev); 468 } 469 break; 470 471 case NETDEV_FEAT_CHANGE: 472 /* Propagate device features to underlying device */ 473 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 474 vlandev = vlan_group_get_device(grp, i); 475 if (!vlandev) 476 continue; 477 478 vlan_transfer_features(dev, vlandev); 479 } 480 481 break; 482 483 case NETDEV_DOWN: 484 /* Put all VLANs for this dev in the down state too. */ 485 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 486 vlandev = vlan_group_get_device(grp, i); 487 if (!vlandev) 488 continue; 489 490 flgs = vlandev->flags; 491 if (!(flgs & IFF_UP)) 492 continue; 493 494 dev_change_flags(vlandev, flgs & ~IFF_UP); 495 } 496 break; 497 498 case NETDEV_UP: 499 /* Put all VLANs for this dev in the up state too. */ 500 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 501 vlandev = vlan_group_get_device(grp, i); 502 if (!vlandev) 503 continue; 504 505 flgs = vlandev->flags; 506 if (flgs & IFF_UP) 507 continue; 508 509 dev_change_flags(vlandev, flgs | IFF_UP); 510 } 511 break; 512 513 case NETDEV_UNREGISTER: 514 /* Delete all VLANs for this dev. */ 515 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 516 vlandev = vlan_group_get_device(grp, i); 517 if (!vlandev) 518 continue; 519 520 /* unregistration of last vlan destroys group, abort 521 * afterwards */ 522 if (grp->nr_vlans == 1) 523 i = VLAN_GROUP_ARRAY_LEN; 524 525 unregister_vlan_dev(vlandev); 526 } 527 break; 528 } 529 530 out: 531 return NOTIFY_DONE; 532 } 533 534 static struct notifier_block vlan_notifier_block __read_mostly = { 535 .notifier_call = vlan_device_event, 536 }; 537 538 /* 539 * VLAN IOCTL handler. 540 * o execute requested action or pass command to the device driver 541 * arg is really a struct vlan_ioctl_args __user *. 542 */ 543 static int vlan_ioctl_handler(struct net *net, void __user *arg) 544 { 545 int err; 546 struct vlan_ioctl_args args; 547 struct net_device *dev = NULL; 548 549 if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args))) 550 return -EFAULT; 551 552 /* Null terminate this sucker, just in case. */ 553 args.device1[23] = 0; 554 args.u.device2[23] = 0; 555 556 rtnl_lock(); 557 558 switch (args.cmd) { 559 case SET_VLAN_INGRESS_PRIORITY_CMD: 560 case SET_VLAN_EGRESS_PRIORITY_CMD: 561 case SET_VLAN_FLAG_CMD: 562 case ADD_VLAN_CMD: 563 case DEL_VLAN_CMD: 564 case GET_VLAN_REALDEV_NAME_CMD: 565 case GET_VLAN_VID_CMD: 566 err = -ENODEV; 567 dev = __dev_get_by_name(net, args.device1); 568 if (!dev) 569 goto out; 570 571 err = -EINVAL; 572 if (args.cmd != ADD_VLAN_CMD && !is_vlan_dev(dev)) 573 goto out; 574 } 575 576 switch (args.cmd) { 577 case SET_VLAN_INGRESS_PRIORITY_CMD: 578 err = -EPERM; 579 if (!capable(CAP_NET_ADMIN)) 580 break; 581 vlan_dev_set_ingress_priority(dev, 582 args.u.skb_priority, 583 args.vlan_qos); 584 err = 0; 585 break; 586 587 case SET_VLAN_EGRESS_PRIORITY_CMD: 588 err = -EPERM; 589 if (!capable(CAP_NET_ADMIN)) 590 break; 591 err = vlan_dev_set_egress_priority(dev, 592 args.u.skb_priority, 593 args.vlan_qos); 594 break; 595 596 case SET_VLAN_FLAG_CMD: 597 err = -EPERM; 598 if (!capable(CAP_NET_ADMIN)) 599 break; 600 err = vlan_dev_change_flags(dev, 601 args.vlan_qos ? args.u.flag : 0, 602 args.u.flag); 603 break; 604 605 case SET_VLAN_NAME_TYPE_CMD: 606 err = -EPERM; 607 if (!capable(CAP_NET_ADMIN)) 608 break; 609 if ((args.u.name_type >= 0) && 610 (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) { 611 struct vlan_net *vn; 612 613 vn = net_generic(net, vlan_net_id); 614 vn->name_type = args.u.name_type; 615 err = 0; 616 } else { 617 err = -EINVAL; 618 } 619 break; 620 621 case ADD_VLAN_CMD: 622 err = -EPERM; 623 if (!capable(CAP_NET_ADMIN)) 624 break; 625 err = register_vlan_device(dev, args.u.VID); 626 break; 627 628 case DEL_VLAN_CMD: 629 err = -EPERM; 630 if (!capable(CAP_NET_ADMIN)) 631 break; 632 unregister_vlan_dev(dev); 633 err = 0; 634 break; 635 636 case GET_VLAN_REALDEV_NAME_CMD: 637 err = 0; 638 vlan_dev_get_realdev_name(dev, args.u.device2); 639 if (copy_to_user(arg, &args, 640 sizeof(struct vlan_ioctl_args))) 641 err = -EFAULT; 642 break; 643 644 case GET_VLAN_VID_CMD: 645 err = 0; 646 args.u.VID = vlan_dev_vlan_id(dev); 647 if (copy_to_user(arg, &args, 648 sizeof(struct vlan_ioctl_args))) 649 err = -EFAULT; 650 break; 651 652 default: 653 err = -EOPNOTSUPP; 654 break; 655 } 656 out: 657 rtnl_unlock(); 658 return err; 659 } 660 661 static int vlan_init_net(struct net *net) 662 { 663 int err; 664 struct vlan_net *vn; 665 666 err = -ENOMEM; 667 vn = kzalloc(sizeof(struct vlan_net), GFP_KERNEL); 668 if (vn == NULL) 669 goto err_alloc; 670 671 err = net_assign_generic(net, vlan_net_id, vn); 672 if (err < 0) 673 goto err_assign; 674 675 vn->name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD; 676 677 err = vlan_proc_init(net); 678 if (err < 0) 679 goto err_proc; 680 681 return 0; 682 683 err_proc: 684 /* nothing */ 685 err_assign: 686 kfree(vn); 687 err_alloc: 688 return err; 689 } 690 691 static void vlan_exit_net(struct net *net) 692 { 693 struct vlan_net *vn; 694 695 vn = net_generic(net, vlan_net_id); 696 rtnl_kill_links(net, &vlan_link_ops); 697 vlan_proc_cleanup(net); 698 kfree(vn); 699 } 700 701 static struct pernet_operations vlan_net_ops = { 702 .init = vlan_init_net, 703 .exit = vlan_exit_net, 704 }; 705 706 static int __init vlan_proto_init(void) 707 { 708 int err; 709 710 pr_info("%s v%s %s\n", vlan_fullname, vlan_version, vlan_copyright); 711 pr_info("All bugs added by %s\n", vlan_buggyright); 712 713 err = register_pernet_gen_device(&vlan_net_id, &vlan_net_ops); 714 if (err < 0) 715 goto err0; 716 717 err = register_netdevice_notifier(&vlan_notifier_block); 718 if (err < 0) 719 goto err2; 720 721 err = vlan_gvrp_init(); 722 if (err < 0) 723 goto err3; 724 725 err = vlan_netlink_init(); 726 if (err < 0) 727 goto err4; 728 729 dev_add_pack(&vlan_packet_type); 730 vlan_ioctl_set(vlan_ioctl_handler); 731 return 0; 732 733 err4: 734 vlan_gvrp_uninit(); 735 err3: 736 unregister_netdevice_notifier(&vlan_notifier_block); 737 err2: 738 unregister_pernet_gen_device(vlan_net_id, &vlan_net_ops); 739 err0: 740 return err; 741 } 742 743 static void __exit vlan_cleanup_module(void) 744 { 745 unsigned int i; 746 747 vlan_ioctl_set(NULL); 748 vlan_netlink_fini(); 749 750 unregister_netdevice_notifier(&vlan_notifier_block); 751 752 dev_remove_pack(&vlan_packet_type); 753 754 /* This table must be empty if there are no module references left. */ 755 for (i = 0; i < VLAN_GRP_HASH_SIZE; i++) 756 BUG_ON(!hlist_empty(&vlan_group_hash[i])); 757 758 unregister_pernet_gen_device(vlan_net_id, &vlan_net_ops); 759 synchronize_net(); 760 761 vlan_gvrp_uninit(); 762 } 763 764 module_init(vlan_proto_init); 765 module_exit(vlan_cleanup_module); 766 767 MODULE_LICENSE("GPL"); 768 MODULE_VERSION(DRV_VERSION); 769