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