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