3 * Ethernet-type device handling.
5 * Authors: Ben Greear <greearb@candelatech.com>
6 * Please send support related email to: vlan@scry.wanfear.com
7 * VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
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>
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.
21 #include <asm/uaccess.h> /* for copy_from_user */
22 #include <linux/module.h>
23 #include <linux/netdevice.h>
24 #include <linux/skbuff.h>
25 #include <net/datalink.h>
28 #include <linux/init.h>
29 #include <net/p8022.h>
31 #include <linux/rtnetlink.h>
32 #include <linux/notifier.h>
34 #include <linux/if_vlan.h>
38 /* Global VLAN variables */
40 /* Our listing of VLAN group(s) */
41 struct vlan_group *vlan_group_hash[VLAN_GRP_HASH_SIZE];
42 spinlock_t vlan_group_lock = SPIN_LOCK_UNLOCKED;
43 #define vlan_grp_hashfn(IDX) ((((IDX) >> VLAN_GRP_HASH_SHIFT) ^ (IDX)) & VLAN_GRP_HASH_MASK)
45 static char vlan_fullname[] = "802.1Q VLAN Support";
46 static unsigned int vlan_version = 1;
47 static unsigned int vlan_release = 8;
48 static char vlan_copyright[] = "Ben Greear <greearb@candelatech.com>";
49 static char vlan_buggyright[] = "David S. Miller <davem@redhat.com>";
51 static int vlan_device_event(struct notifier_block *, unsigned long, void *);
52 static int vlan_ioctl_handler(unsigned long);
53 static int unregister_vlan_dev(struct net_device *, unsigned short );
55 struct notifier_block vlan_notifier_block = {
56 .notifier_call = vlan_device_event,
59 /* These may be changed at run-time through IOCTLs */
61 /* Determines interface naming scheme. */
62 unsigned short vlan_name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
64 /* DO reorder the header by default */
65 unsigned short vlan_default_dev_flags = 1;
67 static struct packet_type vlan_packet_type = {
68 .type = __constant_htons(ETH_P_8021Q),
69 .func = vlan_skb_recv, /* VLAN receive method */
72 /* End of global variables definitions. */
75 * Function vlan_proto_init (pro)
77 * Initialize VLAN protocol layer,
80 static int __init vlan_proto_init(void)
84 printk(VLAN_INF "%s v%u.%u %s\n",
85 vlan_fullname, vlan_version, vlan_release, vlan_copyright);
86 printk(VLAN_INF "All bugs added by %s\n",
89 /* proc file system initialization */
90 err = vlan_proc_init();
93 "%s %s: can't create entry in proc filesystem!\n",
94 __FUNCTION__, VLAN_NAME);
98 dev_add_pack(&vlan_packet_type);
100 /* Register us to receive netdevice events */
101 register_netdevice_notifier(&vlan_notifier_block);
103 vlan_ioctl_set(vlan_ioctl_handler);
108 /* Cleanup all vlan devices
109 * Note: devices that have been registered that but not
110 * brought up will exist but have no module ref count.
112 static void __exit vlan_cleanup_devices(void)
114 struct net_device *dev, *nxt;
117 for (dev = dev_base; dev; dev = nxt) {
119 if (dev->priv_flags & IFF_802_1Q_VLAN) {
120 unregister_vlan_dev(VLAN_DEV_INFO(dev)->real_dev,
121 VLAN_DEV_INFO(dev)->vlan_id);
123 unregister_netdevice(dev);
130 * Module 'remove' entry point.
131 * o delete /proc/net/router directory and static entries.
133 static void __exit vlan_cleanup_module(void)
137 vlan_ioctl_set(NULL);
139 /* Un-register us from receiving netdevice events */
140 unregister_netdevice_notifier(&vlan_notifier_block);
142 dev_remove_pack(&vlan_packet_type);
143 vlan_cleanup_devices();
145 /* This table must be empty if there are no module
148 for (i = 0; i < VLAN_GRP_HASH_SIZE; i++) {
149 if (vlan_group_hash[i] != NULL)
157 module_init(vlan_proto_init);
158 module_exit(vlan_cleanup_module);
160 /* Must be invoked with vlan_group_lock held. */
161 static struct vlan_group *__vlan_find_group(int real_dev_ifindex)
163 struct vlan_group *grp;
165 for (grp = vlan_group_hash[vlan_grp_hashfn(real_dev_ifindex)];
168 if (grp->real_dev_ifindex == real_dev_ifindex)
175 /* Must hold vlan_group_lock. */
176 static void __grp_hash(struct vlan_group *grp)
178 struct vlan_group **head;
180 head = &vlan_group_hash[vlan_grp_hashfn(grp->real_dev_ifindex)];
185 /* Must hold vlan_group_lock. */
186 static void __grp_unhash(struct vlan_group *grp)
188 struct vlan_group *next, **pprev;
190 pprev = &vlan_group_hash[vlan_grp_hashfn(grp->real_dev_ifindex)];
192 while (next != grp) {
199 /* Find the protocol handler. Assumes VID < VLAN_VID_MASK.
201 * Must be invoked with vlan_group_lock held.
203 struct net_device *__find_vlan_dev(struct net_device *real_dev,
206 struct vlan_group *grp = __vlan_find_group(real_dev->ifindex);
209 return grp->vlan_devices[VID];
214 /* This returns 0 if everything went fine.
215 * It will return 1 if the group was killed as a result.
216 * A negative return indicates failure.
218 * The RTNL lock must be held.
220 static int unregister_vlan_dev(struct net_device *real_dev,
221 unsigned short vlan_id)
223 struct net_device *dev = NULL;
224 int real_dev_ifindex = real_dev->ifindex;
225 struct vlan_group *grp;
229 printk(VLAN_DBG "%s: VID: %i\n", __FUNCTION__, vlan_id);
233 if (vlan_id >= VLAN_VID_MASK)
236 spin_lock_bh(&vlan_group_lock);
237 grp = __vlan_find_group(real_dev_ifindex);
238 spin_unlock_bh(&vlan_group_lock);
243 dev = grp->vlan_devices[vlan_id];
245 /* Remove proc entry */
246 vlan_proc_rem_dev(dev);
248 /* Take it out of our own structures, but be sure to
249 * interlock with HW accelerating devices or SW vlan
250 * input packet processing.
252 if (real_dev->features &
253 (NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER)) {
254 real_dev->vlan_rx_kill_vid(real_dev, vlan_id);
257 grp->vlan_devices[vlan_id] = NULL;
261 /* Caller unregisters (and if necessary, puts)
262 * VLAN device, but we get rid of the reference to
267 /* If the group is now empty, kill off the
270 for (i = 0; i < VLAN_VID_MASK; i++)
271 if (grp->vlan_devices[i])
274 if (i == VLAN_VID_MASK) {
275 if (real_dev->features & NETIF_F_HW_VLAN_RX)
276 real_dev->vlan_rx_register(real_dev, NULL);
278 spin_lock_bh(&vlan_group_lock);
280 spin_unlock_bh(&vlan_group_lock);
282 /* Free the group, after we have removed it
296 static int unregister_vlan_device(const char *vlan_IF_name)
298 struct net_device *dev = NULL;
302 dev = dev_get_by_name(vlan_IF_name);
305 if (dev->priv_flags & IFF_802_1Q_VLAN) {
308 ret = unregister_vlan_dev(VLAN_DEV_INFO(dev)->real_dev,
309 VLAN_DEV_INFO(dev)->vlan_id);
312 unregister_netdevice(dev);
320 "%s: ERROR: Tried to remove a non-vlan device "
321 "with VLAN code, name: %s priv_flags: %hX\n",
322 __FUNCTION__, dev->name, dev->priv_flags);
328 printk(VLAN_DBG "%s: WARNING: Could not find dev.\n", __FUNCTION__);
336 static void vlan_setup(struct net_device *new_dev)
338 SET_MODULE_OWNER(new_dev);
340 /* new_dev->ifindex = 0; it will be set when added to
342 * iflink is set as well.
344 new_dev->get_stats = vlan_dev_get_stats;
346 /* Make this thing known as a VLAN device */
347 new_dev->priv_flags |= IFF_802_1Q_VLAN;
349 /* Set us up to have no queue, as the underlying Hardware device
350 * can do all the queueing we could want.
352 new_dev->tx_queue_len = 0;
354 /* set up method calls */
355 new_dev->change_mtu = vlan_dev_change_mtu;
356 new_dev->open = vlan_dev_open;
357 new_dev->stop = vlan_dev_stop;
358 new_dev->set_mac_address = vlan_dev_set_mac_address;
359 new_dev->set_multicast_list = vlan_dev_set_multicast_list;
360 new_dev->destructor = free_netdev;
363 /* Attach a VLAN device to a mac address (ie Ethernet Card).
364 * Returns the device that was created, or NULL if there was
365 * an error of some kind.
367 static struct net_device *register_vlan_device(const char *eth_IF_name,
368 unsigned short VLAN_ID)
370 struct vlan_group *grp;
371 struct net_device *new_dev;
372 struct net_device *real_dev; /* the ethernet device */
377 printk(VLAN_DBG "%s: if_name -:%s:- vid: %i\n",
378 __FUNCTION__, eth_IF_name, VLAN_ID);
381 if (VLAN_ID >= VLAN_VID_MASK)
384 /* find the device relating to eth_IF_name. */
385 real_dev = dev_get_by_name(eth_IF_name);
389 if (real_dev->features & NETIF_F_VLAN_CHALLENGED) {
390 printk(VLAN_DBG "%s: VLANs not supported on %s.\n",
391 __FUNCTION__, real_dev->name);
395 if ((real_dev->features & NETIF_F_HW_VLAN_RX) &&
396 (real_dev->vlan_rx_register == NULL ||
397 real_dev->vlan_rx_kill_vid == NULL)) {
398 printk(VLAN_DBG "%s: Device %s has buggy VLAN hw accel.\n",
399 __FUNCTION__, real_dev->name);
403 if ((real_dev->features & NETIF_F_HW_VLAN_FILTER) &&
404 (real_dev->vlan_rx_add_vid == NULL ||
405 real_dev->vlan_rx_kill_vid == NULL)) {
406 printk(VLAN_DBG "%s: Device %s has buggy VLAN hw accel.\n",
407 __FUNCTION__, real_dev->name);
411 /* From this point on, all the data structures must remain
416 /* The real device must be up and operating in order to
417 * assosciate a VLAN device with it.
419 if (!(real_dev->flags & IFF_UP))
422 spin_lock_bh(&vlan_group_lock);
423 r = (__find_vlan_dev(real_dev, VLAN_ID) != NULL);
424 spin_unlock_bh(&vlan_group_lock);
427 /* was already registered. */
428 printk(VLAN_DBG "%s: ALREADY had VLAN registered\n", __FUNCTION__);
432 /* Gotta set up the fields for the device. */
434 printk(VLAN_DBG "About to allocate name, vlan_name_type: %i\n",
437 switch (vlan_name_type) {
438 case VLAN_NAME_TYPE_RAW_PLUS_VID:
439 /* name will look like: eth1.0005 */
440 snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, VLAN_ID);
442 case VLAN_NAME_TYPE_PLUS_VID_NO_PAD:
443 /* Put our vlan.VID in the name.
444 * Name will look like: vlan5
446 snprintf(name, IFNAMSIZ, "vlan%i", VLAN_ID);
448 case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD:
449 /* Put our vlan.VID in the name.
450 * Name will look like: eth0.5
452 snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, VLAN_ID);
454 case VLAN_NAME_TYPE_PLUS_VID:
455 /* Put our vlan.VID in the name.
456 * Name will look like: vlan0005
459 snprintf(name, IFNAMSIZ, "vlan%.4i", VLAN_ID);
462 new_dev = alloc_netdev(sizeof(struct vlan_dev_info), name,
468 printk(VLAN_DBG "Allocated new name -:%s:-\n", new_dev->name);
470 /* IFF_BROADCAST|IFF_MULTICAST; ??? */
471 new_dev->flags = real_dev->flags;
472 new_dev->flags &= ~IFF_UP;
474 /* need 4 bytes for extra VLAN header info,
475 * hope the underlying device can handle it.
477 new_dev->mtu = real_dev->mtu;
479 /* TODO: maybe just assign it to be ETHERNET? */
480 new_dev->type = real_dev->type;
482 new_dev->hard_header_len = real_dev->hard_header_len;
483 if (!(real_dev->features & NETIF_F_HW_VLAN_TX)) {
484 /* Regular ethernet + 4 bytes (18 total). */
485 new_dev->hard_header_len += VLAN_HLEN;
488 VLAN_MEM_DBG("new_dev->priv malloc, addr: %p size: %i\n",
490 sizeof(struct vlan_dev_info));
492 memcpy(new_dev->broadcast, real_dev->broadcast, real_dev->addr_len);
493 memcpy(new_dev->dev_addr, real_dev->dev_addr, real_dev->addr_len);
494 new_dev->addr_len = real_dev->addr_len;
496 if (real_dev->features & NETIF_F_HW_VLAN_TX) {
497 new_dev->hard_header = real_dev->hard_header;
498 new_dev->hard_start_xmit = vlan_dev_hwaccel_hard_start_xmit;
499 new_dev->rebuild_header = real_dev->rebuild_header;
501 new_dev->hard_header = vlan_dev_hard_header;
502 new_dev->hard_start_xmit = vlan_dev_hard_start_xmit;
503 new_dev->rebuild_header = vlan_dev_rebuild_header;
505 new_dev->hard_header_parse = real_dev->hard_header_parse;
507 VLAN_DEV_INFO(new_dev)->vlan_id = VLAN_ID; /* 1 through VLAN_VID_MASK */
508 VLAN_DEV_INFO(new_dev)->real_dev = real_dev;
509 VLAN_DEV_INFO(new_dev)->dent = NULL;
510 VLAN_DEV_INFO(new_dev)->flags = vlan_default_dev_flags;
513 printk(VLAN_DBG "About to go find the group for idx: %i\n",
517 if (register_netdevice(new_dev))
518 goto out_free_newdev;
520 /* So, got the sucker initialized, now lets place
521 * it into our local structure.
523 spin_lock_bh(&vlan_group_lock);
524 grp = __vlan_find_group(real_dev->ifindex);
525 spin_unlock_bh(&vlan_group_lock);
527 /* Note, we are running under the RTNL semaphore
528 * so it cannot "appear" on us.
530 if (!grp) { /* need to add a new group */
531 grp = kmalloc(sizeof(struct vlan_group), GFP_KERNEL);
533 goto out_free_unregister;
535 /* printk(KERN_ALERT "VLAN REGISTER: Allocated new group.\n"); */
536 memset(grp, 0, sizeof(struct vlan_group));
537 grp->real_dev_ifindex = real_dev->ifindex;
539 spin_lock_bh(&vlan_group_lock);
541 spin_unlock_bh(&vlan_group_lock);
543 if (real_dev->features & NETIF_F_HW_VLAN_RX)
544 real_dev->vlan_rx_register(real_dev, grp);
547 grp->vlan_devices[VLAN_ID] = new_dev;
549 if (vlan_proc_add_dev(new_dev)<0)/* create it's proc entry */
550 printk(KERN_WARNING "VLAN: failed to add proc entry for %s\n",
553 if (real_dev->features & NETIF_F_HW_VLAN_FILTER)
554 real_dev->vlan_rx_add_vid(real_dev, VLAN_ID);
560 printk(VLAN_DBG "Allocated new device successfully, returning.\n");
565 unregister_netdev(new_dev);
569 free_netdev(new_dev);
581 static int vlan_device_event(struct notifier_block *unused, unsigned long event, void *ptr)
583 struct net_device *dev = (struct net_device *)(ptr);
584 struct vlan_group *grp = NULL;
586 struct net_device *vlandev = NULL;
588 spin_lock_bh(&vlan_group_lock);
589 grp = __vlan_find_group(dev->ifindex);
590 spin_unlock_bh(&vlan_group_lock);
595 /* It is OK that we do not hold the group lock right now,
596 * as we run under the RTNL lock.
600 case NETDEV_CHANGEADDR:
601 case NETDEV_GOING_DOWN:
606 /* Put all VLANs for this dev in the down state too. */
607 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
608 vlandev = grp->vlan_devices[i];
612 flgs = vlandev->flags;
613 if (!(flgs & IFF_UP))
616 dev_change_flags(vlandev, flgs & ~IFF_UP);
621 /* Put all VLANs for this dev in the up state too. */
622 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
623 vlandev = grp->vlan_devices[i];
627 flgs = vlandev->flags;
631 dev_change_flags(vlandev, flgs | IFF_UP);
635 case NETDEV_UNREGISTER:
636 /* Delete all VLANs for this dev. */
637 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
640 vlandev = grp->vlan_devices[i];
644 ret = unregister_vlan_dev(dev,
645 VLAN_DEV_INFO(vlandev)->vlan_id);
648 unregister_netdevice(vlandev);
650 /* Group was destroyed? */
662 * VLAN IOCTL handler.
663 * o execute requested action or pass command to the device driver
664 * arg is really a void* to a vlan_ioctl_args structure.
666 static int vlan_ioctl_handler(unsigned long arg)
669 struct vlan_ioctl_args args;
671 /* everything here needs root permissions, except aguably the
672 * hack ioctls for sending packets. However, I know _I_ don't
673 * want users running that on my network! --BLG
675 if (!capable(CAP_NET_ADMIN))
678 if (copy_from_user(&args, (void*)arg,
679 sizeof(struct vlan_ioctl_args)))
682 /* Null terminate this sucker, just in case. */
683 args.device1[23] = 0;
684 args.u.device2[23] = 0;
687 printk(VLAN_DBG "%s: args.cmd: %x\n", __FUNCTION__, args.cmd);
691 case SET_VLAN_INGRESS_PRIORITY_CMD:
692 err = vlan_dev_set_ingress_priority(args.device1,
697 case SET_VLAN_EGRESS_PRIORITY_CMD:
698 err = vlan_dev_set_egress_priority(args.device1,
703 case SET_VLAN_FLAG_CMD:
704 err = vlan_dev_set_vlan_flag(args.device1,
709 case SET_VLAN_NAME_TYPE_CMD:
710 if ((args.u.name_type >= 0) &&
711 (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
712 vlan_name_type = args.u.name_type;
719 /* TODO: Figure out how to pass info back...
720 case GET_VLAN_INGRESS_PRIORITY_IOCTL:
721 err = vlan_dev_get_ingress_priority(args);
724 case GET_VLAN_EGRESS_PRIORITY_IOCTL:
725 err = vlan_dev_get_egress_priority(args);
730 /* we have been given the name of the Ethernet Device we want to
731 * talk to: args.dev1 We also have the
732 * VLAN ID: args.u.VID
734 if (register_vlan_device(args.device1, args.u.VID)) {
742 /* Here, the args.dev1 is the actual VLAN we want
745 err = unregister_vlan_device(args.device1);
749 /* pass on to underlying device instead?? */
750 printk(VLAN_DBG "%s: Unknown VLAN CMD: %x \n",
751 __FUNCTION__, args.cmd);
758 MODULE_LICENSE("GPL");