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 vlan_transfer_operstate(dev, vlandev); 496 } 497 break; 498 499 case NETDEV_UP: 500 /* Put all VLANs for this dev in the up state too. */ 501 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 502 vlandev = vlan_group_get_device(grp, i); 503 if (!vlandev) 504 continue; 505 506 flgs = vlandev->flags; 507 if (flgs & IFF_UP) 508 continue; 509 510 dev_change_flags(vlandev, flgs | IFF_UP); 511 vlan_transfer_operstate(dev, vlandev); 512 } 513 break; 514 515 case NETDEV_UNREGISTER: 516 /* Delete all VLANs for this dev. */ 517 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) { 518 vlandev = vlan_group_get_device(grp, i); 519 if (!vlandev) 520 continue; 521 522 /* unregistration of last vlan destroys group, abort 523 * afterwards */ 524 if (grp->nr_vlans == 1) 525 i = VLAN_GROUP_ARRAY_LEN; 526 527 unregister_vlan_dev(vlandev); 528 } 529 break; 530 } 531 532 out: 533 return NOTIFY_DONE; 534 } 535 536 static struct notifier_block vlan_notifier_block __read_mostly = { 537 .notifier_call = vlan_device_event, 538 }; 539 540 /* 541 * VLAN IOCTL handler. 542 * o execute requested action or pass command to the device driver 543 * arg is really a struct vlan_ioctl_args __user *. 544 */ 545 static int vlan_ioctl_handler(struct net *net, void __user *arg) 546 { 547 int err; 548 struct vlan_ioctl_args args; 549 struct net_device *dev = NULL; 550 551 if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args))) 552 return -EFAULT; 553 554 /* Null terminate this sucker, just in case. */ 555 args.device1[23] = 0; 556 args.u.device2[23] = 0; 557 558 rtnl_lock(); 559 560 switch (args.cmd) { 561 case SET_VLAN_INGRESS_PRIORITY_CMD: 562 case SET_VLAN_EGRESS_PRIORITY_CMD: 563 case SET_VLAN_FLAG_CMD: 564 case ADD_VLAN_CMD: 565 case DEL_VLAN_CMD: 566 case GET_VLAN_REALDEV_NAME_CMD: 567 case GET_VLAN_VID_CMD: 568 err = -ENODEV; 569 dev = __dev_get_by_name(net, args.device1); 570 if (!dev) 571 goto out; 572 573 err = -EINVAL; 574 if (args.cmd != ADD_VLAN_CMD && !is_vlan_dev(dev)) 575 goto out; 576 } 577 578 switch (args.cmd) { 579 case SET_VLAN_INGRESS_PRIORITY_CMD: 580 err = -EPERM; 581 if (!capable(CAP_NET_ADMIN)) 582 break; 583 vlan_dev_set_ingress_priority(dev, 584 args.u.skb_priority, 585 args.vlan_qos); 586 err = 0; 587 break; 588 589 case SET_VLAN_EGRESS_PRIORITY_CMD: 590 err = -EPERM; 591 if (!capable(CAP_NET_ADMIN)) 592 break; 593 err = vlan_dev_set_egress_priority(dev, 594 args.u.skb_priority, 595 args.vlan_qos); 596 break; 597 598 case SET_VLAN_FLAG_CMD: 599 err = -EPERM; 600 if (!capable(CAP_NET_ADMIN)) 601 break; 602 err = vlan_dev_change_flags(dev, 603 args.vlan_qos ? args.u.flag : 0, 604 args.u.flag); 605 break; 606 607 case SET_VLAN_NAME_TYPE_CMD: 608 err = -EPERM; 609 if (!capable(CAP_NET_ADMIN)) 610 break; 611 if ((args.u.name_type >= 0) && 612 (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) { 613 struct vlan_net *vn; 614 615 vn = net_generic(net, vlan_net_id); 616 vn->name_type = args.u.name_type; 617 err = 0; 618 } else { 619 err = -EINVAL; 620 } 621 break; 622 623 case ADD_VLAN_CMD: 624 err = -EPERM; 625 if (!capable(CAP_NET_ADMIN)) 626 break; 627 err = register_vlan_device(dev, args.u.VID); 628 break; 629 630 case DEL_VLAN_CMD: 631 err = -EPERM; 632 if (!capable(CAP_NET_ADMIN)) 633 break; 634 unregister_vlan_dev(dev); 635 err = 0; 636 break; 637 638 case GET_VLAN_REALDEV_NAME_CMD: 639 err = 0; 640 vlan_dev_get_realdev_name(dev, args.u.device2); 641 if (copy_to_user(arg, &args, 642 sizeof(struct vlan_ioctl_args))) 643 err = -EFAULT; 644 break; 645 646 case GET_VLAN_VID_CMD: 647 err = 0; 648 args.u.VID = vlan_dev_vlan_id(dev); 649 if (copy_to_user(arg, &args, 650 sizeof(struct vlan_ioctl_args))) 651 err = -EFAULT; 652 break; 653 654 default: 655 err = -EOPNOTSUPP; 656 break; 657 } 658 out: 659 rtnl_unlock(); 660 return err; 661 } 662 663 static int vlan_init_net(struct net *net) 664 { 665 int err; 666 struct vlan_net *vn; 667 668 err = -ENOMEM; 669 vn = kzalloc(sizeof(struct vlan_net), GFP_KERNEL); 670 if (vn == NULL) 671 goto err_alloc; 672 673 err = net_assign_generic(net, vlan_net_id, vn); 674 if (err < 0) 675 goto err_assign; 676 677 vn->name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD; 678 679 err = vlan_proc_init(net); 680 if (err < 0) 681 goto err_proc; 682 683 return 0; 684 685 err_proc: 686 /* nothing */ 687 err_assign: 688 kfree(vn); 689 err_alloc: 690 return err; 691 } 692 693 static void vlan_exit_net(struct net *net) 694 { 695 struct vlan_net *vn; 696 697 vn = net_generic(net, vlan_net_id); 698 rtnl_kill_links(net, &vlan_link_ops); 699 vlan_proc_cleanup(net); 700 kfree(vn); 701 } 702 703 static struct pernet_operations vlan_net_ops = { 704 .init = vlan_init_net, 705 .exit = vlan_exit_net, 706 }; 707 708 static int __init vlan_proto_init(void) 709 { 710 int err; 711 712 pr_info("%s v%s %s\n", vlan_fullname, vlan_version, vlan_copyright); 713 pr_info("All bugs added by %s\n", vlan_buggyright); 714 715 err = register_pernet_gen_device(&vlan_net_id, &vlan_net_ops); 716 if (err < 0) 717 goto err0; 718 719 err = register_netdevice_notifier(&vlan_notifier_block); 720 if (err < 0) 721 goto err2; 722 723 err = vlan_gvrp_init(); 724 if (err < 0) 725 goto err3; 726 727 err = vlan_netlink_init(); 728 if (err < 0) 729 goto err4; 730 731 dev_add_pack(&vlan_packet_type); 732 vlan_ioctl_set(vlan_ioctl_handler); 733 return 0; 734 735 err4: 736 vlan_gvrp_uninit(); 737 err3: 738 unregister_netdevice_notifier(&vlan_notifier_block); 739 err2: 740 unregister_pernet_gen_device(vlan_net_id, &vlan_net_ops); 741 err0: 742 return err; 743 } 744 745 static void __exit vlan_cleanup_module(void) 746 { 747 unsigned int i; 748 749 vlan_ioctl_set(NULL); 750 vlan_netlink_fini(); 751 752 unregister_netdevice_notifier(&vlan_notifier_block); 753 754 dev_remove_pack(&vlan_packet_type); 755 756 /* This table must be empty if there are no module references left. */ 757 for (i = 0; i < VLAN_GRP_HASH_SIZE; i++) 758 BUG_ON(!hlist_empty(&vlan_group_hash[i])); 759 760 unregister_pernet_gen_device(vlan_net_id, &vlan_net_ops); 761 synchronize_net(); 762 763 vlan_gvrp_uninit(); 764 } 765 766 module_init(vlan_proto_init); 767 module_exit(vlan_cleanup_module); 768 769 MODULE_LICENSE("GPL"); 770 MODULE_VERSION(DRV_VERSION); 771