blob: 5471628d3ffe73fd0f8b3cc8d3504cfeae78019c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * INET 802.1Q VLAN
3 * Ethernet-type device handling.
4 *
5 * Authors: Ben Greear <greearb@candelatech.com>
Patrick McHardyad712082008-01-21 00:27:00 -08006 * Please send support related email to: netdev@vger.kernel.org
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
YOSHIFUJI Hideaki122952f2007-02-09 23:24:25 +09008 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * 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
Joe Perchesafab2d22011-05-26 10:58:31 +000021#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
Randy Dunlap4fc268d2006-01-11 12:17:47 -080023#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/module.h>
25#include <linux/netdevice.h>
26#include <linux/skbuff.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090027#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/init.h>
Franck Bui-Huu82524742008-05-12 21:21:05 +020029#include <linux/rculist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <net/p8022.h>
31#include <net/arp.h>
32#include <linux/rtnetlink.h>
33#include <linux/notifier.h>
Patrick McHardy61362762008-07-14 22:51:55 -070034#include <net/rtnetlink.h>
Eric W. Biedermane9dc8652007-09-12 13:02:17 +020035#include <net/net_namespace.h>
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -070036#include <net/netns/generic.h>
Patrick McHardy61362762008-07-14 22:51:55 -070037#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
39#include <linux/if_vlan.h>
40#include "vlan.h"
41#include "vlanproc.h"
42
43#define DRV_VERSION "1.8"
44
45/* Global VLAN variables */
46
Eric Dumazetf99189b2009-11-17 10:42:49 +000047int vlan_net_id __read_mostly;
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -070048
Stephen Hemmingerb30200612008-10-28 22:12:36 -070049const char vlan_fullname[] = "802.1Q VLAN Support";
50const char vlan_version[] = DRV_VERSION;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Linus Torvalds1da177e2005-04-16 15:20:36 -070052/* End of global variables definitions. */
53
Dan Aloni5c15bde2007-03-02 20:44:51 -080054static void vlan_group_free(struct vlan_group *grp)
55{
56 int i;
57
Patrick McHardy2029cc22008-01-21 00:26:41 -080058 for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++)
Dan Aloni5c15bde2007-03-02 20:44:51 -080059 kfree(grp->vlan_devices_arrays[i]);
60 kfree(grp);
61}
62
Pavel Emelyanova9fde262008-04-16 00:48:04 -070063static struct vlan_group *vlan_group_alloc(struct net_device *real_dev)
Patrick McHardy42429aa2007-06-13 12:05:59 -070064{
65 struct vlan_group *grp;
Patrick McHardy42429aa2007-06-13 12:05:59 -070066
67 grp = kzalloc(sizeof(struct vlan_group), GFP_KERNEL);
68 if (!grp)
69 return NULL;
70
Pavel Emelyanova9fde262008-04-16 00:48:04 -070071 grp->real_dev = real_dev;
Patrick McHardy42429aa2007-06-13 12:05:59 -070072 return grp;
Pavel Emelyanov67727182008-03-26 16:27:22 -070073}
Patrick McHardy42429aa2007-06-13 12:05:59 -070074
Patrick McHardy9bb85822008-07-08 03:24:44 -070075static int vlan_group_prealloc_vid(struct vlan_group *vg, u16 vlan_id)
Pavel Emelyanov67727182008-03-26 16:27:22 -070076{
77 struct net_device **array;
78 unsigned int size;
79
80 ASSERT_RTNL();
81
Patrick McHardy9bb85822008-07-08 03:24:44 -070082 array = vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN];
Pavel Emelyanov67727182008-03-26 16:27:22 -070083 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
Patrick McHardy9bb85822008-07-08 03:24:44 -070091 vg->vlan_devices_arrays[vlan_id / VLAN_GROUP_ARRAY_PART_LEN] = array;
Pavel Emelyanov67727182008-03-26 16:27:22 -070092 return 0;
Patrick McHardy42429aa2007-06-13 12:05:59 -070093}
94
Linus Torvalds1da177e2005-04-16 15:20:36 -070095static void vlan_rcu_free(struct rcu_head *rcu)
96{
Dan Aloni5c15bde2007-03-02 20:44:51 -080097 vlan_group_free(container_of(rcu, struct vlan_group, rcu));
Linus Torvalds1da177e2005-04-16 15:20:36 -070098}
99
Eric Dumazet23289a32009-10-27 07:06:36 +0000100void unregister_vlan_dev(struct net_device *dev, struct list_head *head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Patrick McHardy9dfebcc2008-01-21 00:26:07 -0800102 struct vlan_dev_info *vlan = vlan_dev_info(dev);
Patrick McHardyaf301512008-01-21 00:25:50 -0800103 struct net_device *real_dev = vlan->real_dev;
Stephen Hemminger656299f2008-11-19 21:53:47 -0800104 const struct net_device_ops *ops = real_dev->netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 struct vlan_group *grp;
Patrick McHardy9bb85822008-07-08 03:24:44 -0700106 u16 vlan_id = vlan->vlan_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108 ASSERT_RTNL();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Eric Dumazetb616b092010-10-24 21:31:58 +0000110 grp = rtnl_dereference(real_dev->vlgrp);
Patrick McHardyaf301512008-01-21 00:25:50 -0800111 BUG_ON(!grp);
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800112
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800113 /* Take it out of our own structures, but be sure to interlock with
Pedro Garciaad1afb02010-07-18 15:38:44 -0700114 * HW accelerating devices or SW vlan input packet processing if
115 * VLAN is not 0 (leave it there for 802.1p).
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800116 */
Pedro Garciaad1afb02010-07-18 15:38:44 -0700117 if (vlan_id && (real_dev->features & NETIF_F_HW_VLAN_FILTER))
Stephen Hemminger656299f2008-11-19 21:53:47 -0800118 ops->ndo_vlan_rx_kill_vid(real_dev, vlan_id);
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800119
Patrick McHardyaf301512008-01-21 00:25:50 -0800120 grp->nr_vlans--;
121
Eric Dumazet55aee102011-05-10 12:22:54 -0700122 if (vlan->flags & VLAN_FLAG_GVRP)
123 vlan_gvrp_request_leave(dev);
124
Patrick McHardy29906f62009-10-29 23:43:00 -0700125 vlan_group_set_device(grp, vlan_id, NULL);
Eric Dumazet48752e12011-05-09 04:40:44 +0000126 /* Because unregister_netdevice_queue() makes sure at least one rcu
127 * grace period is respected before device freeing,
128 * we dont need to call synchronize_net() here.
129 */
Eric Dumazet23289a32009-10-27 07:06:36 +0000130 unregister_netdevice_queue(dev, head);
Patrick McHardyce305002008-07-05 21:26:41 -0700131
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800132 /* If the group is now empty, kill off the group. */
Patrick McHardyaf301512008-01-21 00:25:50 -0800133 if (grp->nr_vlans == 0) {
Patrick McHardy70c03b42008-07-05 21:26:57 -0700134 vlan_gvrp_uninit_applicant(real_dev);
135
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +0000136 RCU_INIT_POINTER(real_dev->vlgrp, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800138 /* Free the group, after all cpu's are done. */
139 call_rcu(&grp->rcu, vlan_rcu_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 }
141
Patrick McHardyaf301512008-01-21 00:25:50 -0800142 /* Get rid of the vlan's reference to real_dev */
143 dev_put(real_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144}
145
Patrick McHardy9bb85822008-07-08 03:24:44 -0700146int vlan_check_real_dev(struct net_device *real_dev, u16 vlan_id)
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700147{
Stephen Hemminger656299f2008-11-19 21:53:47 -0800148 const char *name = real_dev->name;
149 const struct net_device_ops *ops = real_dev->netdev_ops;
Patrick McHardy40f98e12008-01-21 00:24:30 -0800150
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700151 if (real_dev->features & NETIF_F_VLAN_CHALLENGED) {
Joe Perchesafab2d22011-05-26 10:58:31 +0000152 pr_info("VLANs not supported on %s\n", name);
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700153 return -EOPNOTSUPP;
154 }
155
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700156 if ((real_dev->features & NETIF_F_HW_VLAN_FILTER) &&
Stephen Hemminger656299f2008-11-19 21:53:47 -0800157 (!ops->ndo_vlan_rx_add_vid || !ops->ndo_vlan_rx_kill_vid)) {
Joe Perchesafab2d22011-05-26 10:58:31 +0000158 pr_info("Device %s has buggy VLAN hw accel\n", name);
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700159 return -EOPNOTSUPP;
160 }
161
Jesse Gross65ac6a52010-10-20 13:56:05 +0000162 if (vlan_find_dev(real_dev, vlan_id) != NULL)
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700163 return -EEXIST;
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700164
165 return 0;
166}
167
Patrick McHardy07b5b172007-06-13 12:07:54 -0700168int register_vlan_dev(struct net_device *dev)
Patrick McHardye89fe422007-06-13 12:06:29 -0700169{
Patrick McHardy9dfebcc2008-01-21 00:26:07 -0800170 struct vlan_dev_info *vlan = vlan_dev_info(dev);
Patrick McHardye89fe422007-06-13 12:06:29 -0700171 struct net_device *real_dev = vlan->real_dev;
Stephen Hemminger656299f2008-11-19 21:53:47 -0800172 const struct net_device_ops *ops = real_dev->netdev_ops;
Patrick McHardy9bb85822008-07-08 03:24:44 -0700173 u16 vlan_id = vlan->vlan_id;
Patrick McHardye89fe422007-06-13 12:06:29 -0700174 struct vlan_group *grp, *ngrp = NULL;
175 int err;
176
Eric Dumazetb616b092010-10-24 21:31:58 +0000177 grp = rtnl_dereference(real_dev->vlgrp);
Patrick McHardye89fe422007-06-13 12:06:29 -0700178 if (!grp) {
Pavel Emelyanova9fde262008-04-16 00:48:04 -0700179 ngrp = grp = vlan_group_alloc(real_dev);
Patrick McHardye89fe422007-06-13 12:06:29 -0700180 if (!grp)
181 return -ENOBUFS;
Patrick McHardy70c03b42008-07-05 21:26:57 -0700182 err = vlan_gvrp_init_applicant(real_dev);
183 if (err < 0)
184 goto out_free_group;
Patrick McHardye89fe422007-06-13 12:06:29 -0700185 }
186
Pavel Emelyanov67727182008-03-26 16:27:22 -0700187 err = vlan_group_prealloc_vid(grp, vlan_id);
188 if (err < 0)
Patrick McHardy70c03b42008-07-05 21:26:57 -0700189 goto out_uninit_applicant;
Pavel Emelyanov67727182008-03-26 16:27:22 -0700190
Patrick McHardye89fe422007-06-13 12:06:29 -0700191 err = register_netdevice(dev);
192 if (err < 0)
Patrick McHardy70c03b42008-07-05 21:26:57 -0700193 goto out_uninit_applicant;
Patrick McHardye89fe422007-06-13 12:06:29 -0700194
195 /* Account for reference in struct vlan_dev_info */
196 dev_hold(real_dev);
197
Patrick Mullaneyfc4a7482009-12-03 15:59:22 -0800198 netif_stacked_transfer_operstate(real_dev, dev);
Patrick McHardye89fe422007-06-13 12:06:29 -0700199 linkwatch_fire_event(dev); /* _MUST_ call rfc2863_policy() */
200
201 /* So, got the sucker initialized, now lets place
202 * it into our local structure.
203 */
204 vlan_group_set_device(grp, vlan_id, dev);
Patrick McHardyaf301512008-01-21 00:25:50 -0800205 grp->nr_vlans++;
206
Jesse Gross65ac6a52010-10-20 13:56:05 +0000207 if (ngrp) {
Jesse Gross65ac6a52010-10-20 13:56:05 +0000208 rcu_assign_pointer(real_dev->vlgrp, ngrp);
209 }
Patrick McHardye89fe422007-06-13 12:06:29 -0700210 if (real_dev->features & NETIF_F_HW_VLAN_FILTER)
Stephen Hemminger656299f2008-11-19 21:53:47 -0800211 ops->ndo_vlan_rx_add_vid(real_dev, vlan_id);
Patrick McHardye89fe422007-06-13 12:06:29 -0700212
Patrick McHardye89fe422007-06-13 12:06:29 -0700213 return 0;
214
Patrick McHardy70c03b42008-07-05 21:26:57 -0700215out_uninit_applicant:
216 if (ngrp)
217 vlan_gvrp_uninit_applicant(real_dev);
Patrick McHardye89fe422007-06-13 12:06:29 -0700218out_free_group:
Eric Dumazet6b863d12009-11-17 06:45:04 -0800219 if (ngrp) {
Eric Dumazet6b863d12009-11-17 06:45:04 -0800220 /* Free the group, after all cpu's are done. */
221 call_rcu(&ngrp->rcu, vlan_rcu_free);
222 }
Patrick McHardye89fe422007-06-13 12:06:29 -0700223 return err;
224}
225
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226/* Attach a VLAN device to a mac address (ie Ethernet Card).
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700227 * Returns 0 if the device was created or a negative error code otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 */
Patrick McHardy9bb85822008-07-08 03:24:44 -0700229static int register_vlan_device(struct net_device *real_dev, u16 vlan_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 struct net_device *new_dev;
Pavel Emelyanov7a17a2f2008-04-16 00:54:39 -0700232 struct net *net = dev_net(real_dev);
233 struct vlan_net *vn = net_generic(net, vlan_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 char name[IFNAMSIZ];
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700235 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Patrick McHardy9bb85822008-07-08 03:24:44 -0700237 if (vlan_id >= VLAN_VID_MASK)
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700238 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
Patrick McHardy9bb85822008-07-08 03:24:44 -0700240 err = vlan_check_real_dev(real_dev, vlan_id);
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700241 if (err < 0)
242 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 /* Gotta set up the fields for the device. */
Pavel Emelyanov7a17a2f2008-04-16 00:54:39 -0700245 switch (vn->name_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 case VLAN_NAME_TYPE_RAW_PLUS_VID:
247 /* name will look like: eth1.0005 */
Patrick McHardy9bb85822008-07-08 03:24:44 -0700248 snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, vlan_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 break;
250 case VLAN_NAME_TYPE_PLUS_VID_NO_PAD:
251 /* Put our vlan.VID in the name.
252 * Name will look like: vlan5
253 */
Patrick McHardy9bb85822008-07-08 03:24:44 -0700254 snprintf(name, IFNAMSIZ, "vlan%i", vlan_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 break;
256 case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD:
257 /* Put our vlan.VID in the name.
258 * Name will look like: eth0.5
259 */
Patrick McHardy9bb85822008-07-08 03:24:44 -0700260 snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, vlan_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 break;
262 case VLAN_NAME_TYPE_PLUS_VID:
263 /* Put our vlan.VID in the name.
264 * Name will look like: vlan0005
265 */
266 default:
Patrick McHardy9bb85822008-07-08 03:24:44 -0700267 snprintf(name, IFNAMSIZ, "vlan%.4i", vlan_id);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700268 }
YOSHIFUJI Hideaki122952f2007-02-09 23:24:25 +0900269
Eric Dumazet4af429d2010-11-10 23:42:00 +0000270 new_dev = alloc_netdev(sizeof(struct vlan_dev_info), name, vlan_setup);
Arjan van de Ven5dd8d1e2006-07-03 00:25:33 -0700271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 if (new_dev == NULL)
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700273 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
Pavel Emelyanov65d292a2008-04-16 00:55:06 -0700275 dev_net_set(new_dev, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 /* need 4 bytes for extra VLAN header info,
277 * hope the underlying device can handle it.
278 */
279 new_dev->mtu = real_dev->mtu;
280
Patrick McHardy9bb85822008-07-08 03:24:44 -0700281 vlan_dev_info(new_dev)->vlan_id = vlan_id;
Patrick McHardy9dfebcc2008-01-21 00:26:07 -0800282 vlan_dev_info(new_dev)->real_dev = real_dev;
283 vlan_dev_info(new_dev)->dent = NULL;
284 vlan_dev_info(new_dev)->flags = VLAN_FLAG_REORDER_HDR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
Patrick McHardy07b5b172007-06-13 12:07:54 -0700286 new_dev->rtnl_link_ops = &vlan_link_ops;
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700287 err = register_vlan_dev(new_dev);
288 if (err < 0)
Patrick McHardye89fe422007-06-13 12:06:29 -0700289 goto out_free_newdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700291 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293out_free_newdev:
294 free_netdev(new_dev);
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700295 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
Patrick McHardy8c979c22007-07-11 19:45:24 -0700298static void vlan_sync_address(struct net_device *dev,
299 struct net_device *vlandev)
300{
Patrick McHardy9dfebcc2008-01-21 00:26:07 -0800301 struct vlan_dev_info *vlan = vlan_dev_info(vlandev);
Patrick McHardy8c979c22007-07-11 19:45:24 -0700302
303 /* May be called without an actual change */
304 if (!compare_ether_addr(vlan->real_dev_addr, dev->dev_addr))
305 return;
306
307 /* vlan address was different from the old address and is equal to
308 * the new address */
309 if (compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
310 !compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000311 dev_uc_del(dev, vlandev->dev_addr);
Patrick McHardy8c979c22007-07-11 19:45:24 -0700312
313 /* vlan address was equal to the old address and is different from
314 * the new address */
315 if (!compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
316 compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
Jiri Pirkoa748ee22010-04-01 21:22:09 +0000317 dev_uc_add(dev, vlandev->dev_addr);
Patrick McHardy8c979c22007-07-11 19:45:24 -0700318
319 memcpy(vlan->real_dev_addr, dev->dev_addr, ETH_ALEN);
320}
321
Patrick McHardy5fb13572008-05-20 14:54:50 -0700322static void vlan_transfer_features(struct net_device *dev,
323 struct net_device *vlandev)
324{
Alexander Duyck1ae4be22008-09-11 20:17:05 -0700325 vlandev->gso_max_size = dev->gso_max_size;
John Fastabend029f5fc2010-10-30 14:22:32 +0000326
327 if (dev->features & NETIF_F_HW_VLAN_TX)
328 vlandev->hard_header_len = dev->hard_header_len;
329 else
330 vlandev->hard_header_len = dev->hard_header_len + VLAN_HLEN;
331
Vasu Devb85daa52009-08-14 12:41:07 +0000332#if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
333 vlandev->fcoe_ddp_xid = dev->fcoe_ddp_xid;
334#endif
Michał Mirosław8a0427b2011-04-02 22:49:12 -0700335
336 netdev_update_features(vlandev);
Patrick McHardy5fb13572008-05-20 14:54:50 -0700337}
338
Pavel Emelyanov802fb172008-04-02 00:08:01 -0700339static void __vlan_device_event(struct net_device *dev, unsigned long event)
340{
341 switch (event) {
342 case NETDEV_CHANGENAME:
343 vlan_proc_rem_dev(dev);
344 if (vlan_proc_add_dev(dev) < 0)
Joe Perchesafab2d22011-05-26 10:58:31 +0000345 pr_warn("failed to change proc name for %s\n",
346 dev->name);
Pavel Emelyanov802fb172008-04-02 00:08:01 -0700347 break;
Pavel Emelyanov30688a92008-04-16 00:57:01 -0700348 case NETDEV_REGISTER:
349 if (vlan_proc_add_dev(dev) < 0)
Joe Perchesafab2d22011-05-26 10:58:31 +0000350 pr_warn("failed to add proc entry for %s\n", dev->name);
Pavel Emelyanov30688a92008-04-16 00:57:01 -0700351 break;
352 case NETDEV_UNREGISTER:
353 vlan_proc_rem_dev(dev);
354 break;
Pavel Emelyanov802fb172008-04-02 00:08:01 -0700355 }
356}
357
Patrick McHardy2029cc22008-01-21 00:26:41 -0800358static int vlan_device_event(struct notifier_block *unused, unsigned long event,
359 void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
361 struct net_device *dev = ptr;
Pavel Emelyanov802fb172008-04-02 00:08:01 -0700362 struct vlan_group *grp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 int i, flgs;
364 struct net_device *vlandev;
Patrick McHardy5e756592009-11-25 07:54:54 +0000365 struct vlan_dev_info *vlan;
Patrick McHardy29906f62009-10-29 23:43:00 -0700366 LIST_HEAD(list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
Patrick McHardy81d85342008-05-20 14:37:36 -0700368 if (is_vlan_dev(dev))
Pavel Emelyanov802fb172008-04-02 00:08:01 -0700369 __vlan_device_event(dev, event);
Pavel Emelyanov802fb172008-04-02 00:08:01 -0700370
Pedro Garciaad1afb02010-07-18 15:38:44 -0700371 if ((event == NETDEV_UP) &&
372 (dev->features & NETIF_F_HW_VLAN_FILTER) &&
373 dev->netdev_ops->ndo_vlan_rx_add_vid) {
Joe Perchesafab2d22011-05-26 10:58:31 +0000374 pr_info("adding VLAN 0 to HW filter on device %s\n",
Pedro Garciaad1afb02010-07-18 15:38:44 -0700375 dev->name);
376 dev->netdev_ops->ndo_vlan_rx_add_vid(dev, 0);
377 }
378
Eric Dumazetb616b092010-10-24 21:31:58 +0000379 grp = rtnl_dereference(dev->vlgrp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 if (!grp)
381 goto out;
382
383 /* It is OK that we do not hold the group lock right now,
384 * as we run under the RTNL lock.
385 */
386
387 switch (event) {
388 case NETDEV_CHANGE:
389 /* Propagate real device state to vlan devices */
Jesse Grossb7381272010-10-20 13:56:02 +0000390 for (i = 0; i < VLAN_N_VID; i++) {
Dan Aloni5c15bde2007-03-02 20:44:51 -0800391 vlandev = vlan_group_get_device(grp, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 if (!vlandev)
393 continue;
394
Patrick Mullaneyfc4a7482009-12-03 15:59:22 -0800395 netif_stacked_transfer_operstate(dev, vlandev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
397 break;
398
Patrick McHardy8c979c22007-07-11 19:45:24 -0700399 case NETDEV_CHANGEADDR:
400 /* Adjust unicast filters on underlying device */
Jesse Grossb7381272010-10-20 13:56:02 +0000401 for (i = 0; i < VLAN_N_VID; i++) {
Patrick McHardy8c979c22007-07-11 19:45:24 -0700402 vlandev = vlan_group_get_device(grp, i);
403 if (!vlandev)
404 continue;
405
Patrick McHardyd932e042007-11-10 21:51:40 -0800406 flgs = vlandev->flags;
407 if (!(flgs & IFF_UP))
408 continue;
409
Patrick McHardy8c979c22007-07-11 19:45:24 -0700410 vlan_sync_address(dev, vlandev);
411 }
412 break;
413
Herbert Xu2e477c92009-07-20 07:35:37 -0700414 case NETDEV_CHANGEMTU:
Jesse Grossb7381272010-10-20 13:56:02 +0000415 for (i = 0; i < VLAN_N_VID; i++) {
Herbert Xu2e477c92009-07-20 07:35:37 -0700416 vlandev = vlan_group_get_device(grp, i);
417 if (!vlandev)
418 continue;
419
420 if (vlandev->mtu <= dev->mtu)
421 continue;
422
423 dev_set_mtu(vlandev, dev->mtu);
424 }
425 break;
426
Patrick McHardy5fb13572008-05-20 14:54:50 -0700427 case NETDEV_FEAT_CHANGE:
428 /* Propagate device features to underlying device */
Jesse Grossb7381272010-10-20 13:56:02 +0000429 for (i = 0; i < VLAN_N_VID; i++) {
Patrick McHardy5fb13572008-05-20 14:54:50 -0700430 vlandev = vlan_group_get_device(grp, i);
431 if (!vlandev)
432 continue;
433
434 vlan_transfer_features(dev, vlandev);
435 }
436
437 break;
438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 case NETDEV_DOWN:
440 /* Put all VLANs for this dev in the down state too. */
Jesse Grossb7381272010-10-20 13:56:02 +0000441 for (i = 0; i < VLAN_N_VID; i++) {
Dan Aloni5c15bde2007-03-02 20:44:51 -0800442 vlandev = vlan_group_get_device(grp, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 if (!vlandev)
444 continue;
445
446 flgs = vlandev->flags;
447 if (!(flgs & IFF_UP))
448 continue;
449
Patrick McHardy5e756592009-11-25 07:54:54 +0000450 vlan = vlan_dev_info(vlandev);
451 if (!(vlan->flags & VLAN_FLAG_LOOSE_BINDING))
452 dev_change_flags(vlandev, flgs & ~IFF_UP);
Patrick Mullaneyfc4a7482009-12-03 15:59:22 -0800453 netif_stacked_transfer_operstate(dev, vlandev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 }
455 break;
456
457 case NETDEV_UP:
458 /* Put all VLANs for this dev in the up state too. */
Jesse Grossb7381272010-10-20 13:56:02 +0000459 for (i = 0; i < VLAN_N_VID; i++) {
Dan Aloni5c15bde2007-03-02 20:44:51 -0800460 vlandev = vlan_group_get_device(grp, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 if (!vlandev)
462 continue;
YOSHIFUJI Hideaki122952f2007-02-09 23:24:25 +0900463
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 flgs = vlandev->flags;
465 if (flgs & IFF_UP)
466 continue;
467
Patrick McHardy5e756592009-11-25 07:54:54 +0000468 vlan = vlan_dev_info(vlandev);
469 if (!(vlan->flags & VLAN_FLAG_LOOSE_BINDING))
470 dev_change_flags(vlandev, flgs | IFF_UP);
Patrick Mullaneyfc4a7482009-12-03 15:59:22 -0800471 netif_stacked_transfer_operstate(dev, vlandev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 }
473 break;
YOSHIFUJI Hideaki122952f2007-02-09 23:24:25 +0900474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 case NETDEV_UNREGISTER:
David Lamparter3b27e102010-09-17 03:22:19 +0000476 /* twiddle thumbs on netns device moves */
477 if (dev->reg_state != NETREG_UNREGISTERING)
478 break;
479
Jesse Grossb7381272010-10-20 13:56:02 +0000480 for (i = 0; i < VLAN_N_VID; i++) {
Patrick McHardy29906f62009-10-29 23:43:00 -0700481 vlandev = vlan_group_get_device(grp, i);
482 if (!vlandev)
483 continue;
484
485 /* unregistration of last vlan destroys group, abort
486 * afterwards */
487 if (grp->nr_vlans == 1)
Jesse Grossb7381272010-10-20 13:56:02 +0000488 i = VLAN_N_VID;
Patrick McHardy29906f62009-10-29 23:43:00 -0700489
490 unregister_vlan_dev(vlandev, &list);
491 }
492 unregister_netdevice_many(&list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 break;
Jiri Pirko1c01fe12010-03-10 10:30:19 +0000494
495 case NETDEV_PRE_TYPE_CHANGE:
496 /* Forbid underlaying device to change its type. */
497 return NOTIFY_BAD;
Ben Hutchings99606472011-04-15 13:46:49 +0000498
499 case NETDEV_NOTIFY_PEERS:
Ben Hutchings7c899432011-04-15 13:47:51 +0000500 case NETDEV_BONDING_FAILOVER:
Ben Hutchings99606472011-04-15 13:46:49 +0000501 /* Propagate to vlan devices */
502 for (i = 0; i < VLAN_N_VID; i++) {
503 vlandev = vlan_group_get_device(grp, i);
504 if (!vlandev)
505 continue;
506
Ben Hutchings7c899432011-04-15 13:47:51 +0000507 call_netdevice_notifiers(event, vlandev);
Ben Hutchings99606472011-04-15 13:46:49 +0000508 }
509 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700510 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
512out:
513 return NOTIFY_DONE;
514}
515
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800516static struct notifier_block vlan_notifier_block __read_mostly = {
517 .notifier_call = vlan_device_event,
518};
519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520/*
521 * VLAN IOCTL handler.
522 * o execute requested action or pass command to the device driver
523 * arg is really a struct vlan_ioctl_args __user *.
524 */
Eric W. Biederman881d9662007-09-17 11:56:21 -0700525static int vlan_ioctl_handler(struct net *net, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526{
Patrick McHardyc17d8872007-06-13 12:05:22 -0700527 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 struct vlan_ioctl_args args;
Patrick McHardyc17d8872007-06-13 12:05:22 -0700529 struct net_device *dev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
531 if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args)))
532 return -EFAULT;
533
534 /* Null terminate this sucker, just in case. */
535 args.device1[23] = 0;
536 args.u.device2[23] = 0;
537
Patrick McHardyc17d8872007-06-13 12:05:22 -0700538 rtnl_lock();
539
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 switch (args.cmd) {
541 case SET_VLAN_INGRESS_PRIORITY_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700542 case SET_VLAN_EGRESS_PRIORITY_CMD:
543 case SET_VLAN_FLAG_CMD:
544 case ADD_VLAN_CMD:
545 case DEL_VLAN_CMD:
546 case GET_VLAN_REALDEV_NAME_CMD:
547 case GET_VLAN_VID_CMD:
548 err = -ENODEV;
Pavel Emelyanov65d292a2008-04-16 00:55:06 -0700549 dev = __dev_get_by_name(net, args.device1);
Patrick McHardyc17d8872007-06-13 12:05:22 -0700550 if (!dev)
551 goto out;
552
553 err = -EINVAL;
Joonwoo Park26a25232008-07-08 03:22:16 -0700554 if (args.cmd != ADD_VLAN_CMD && !is_vlan_dev(dev))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700555 goto out;
556 }
557
558 switch (args.cmd) {
559 case SET_VLAN_INGRESS_PRIORITY_CMD:
560 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700562 break;
563 vlan_dev_set_ingress_priority(dev,
564 args.u.skb_priority,
565 args.vlan_qos);
Patrick McHardyfffe4702007-11-07 01:31:32 -0800566 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 break;
568
569 case SET_VLAN_EGRESS_PRIORITY_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700570 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700572 break;
573 err = vlan_dev_set_egress_priority(dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 args.u.skb_priority,
575 args.vlan_qos);
576 break;
577
578 case SET_VLAN_FLAG_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700579 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700581 break;
Patrick McHardyb3ce0322008-07-05 21:26:27 -0700582 err = vlan_dev_change_flags(dev,
583 args.vlan_qos ? args.u.flag : 0,
584 args.u.flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 break;
586
587 case SET_VLAN_NAME_TYPE_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700588 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 if (!capable(CAP_NET_ADMIN))
Pavel Emelyanove35de022007-12-06 22:52:16 -0800590 break;
Patrick McHardyc17d8872007-06-13 12:05:22 -0700591 if ((args.u.name_type >= 0) &&
592 (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
Pavel Emelyanov7a17a2f2008-04-16 00:54:39 -0700593 struct vlan_net *vn;
594
595 vn = net_generic(net, vlan_net_id);
596 vn->name_type = args.u.name_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 err = 0;
598 } else {
599 err = -EINVAL;
600 }
601 break;
602
603 case ADD_VLAN_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700604 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700606 break;
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700607 err = register_vlan_device(dev, args.u.VID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 break;
609
610 case DEL_VLAN_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700611 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700613 break;
Eric Dumazet23289a32009-10-27 07:06:36 +0000614 unregister_vlan_dev(dev, NULL);
Patrick McHardyaf301512008-01-21 00:25:50 -0800615 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 break;
617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 case GET_VLAN_REALDEV_NAME_CMD:
Andrew Morton3f5f4342007-07-24 15:37:11 -0700619 err = 0;
Patrick McHardyc17d8872007-06-13 12:05:22 -0700620 vlan_dev_get_realdev_name(dev, args.u.device2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 if (copy_to_user(arg, &args,
Patrick McHardy2029cc22008-01-21 00:26:41 -0800622 sizeof(struct vlan_ioctl_args)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 err = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 break;
625
626 case GET_VLAN_VID_CMD:
Andrew Morton3f5f4342007-07-24 15:37:11 -0700627 err = 0;
Patrick McHardy22d1ba72008-07-08 03:23:57 -0700628 args.u.VID = vlan_dev_vlan_id(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 if (copy_to_user(arg, &args,
Patrick McHardy2029cc22008-01-21 00:26:41 -0800630 sizeof(struct vlan_ioctl_args)))
YOSHIFUJI Hideaki122952f2007-02-09 23:24:25 +0900631 err = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 break;
633
634 default:
Patrick McHardy198a2912008-01-21 00:24:59 -0800635 err = -EOPNOTSUPP;
Patrick McHardyc17d8872007-06-13 12:05:22 -0700636 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700637 }
Mika Kukkonen7eb1b3d2005-12-21 18:39:49 -0800638out:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700639 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 return err;
641}
642
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000643static int __net_init vlan_init_net(struct net *net)
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -0700644{
Eric W. Biederman946d1a92009-11-29 15:46:05 +0000645 struct vlan_net *vn = net_generic(net, vlan_net_id);
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -0700646 int err;
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -0700647
Pavel Emelyanov7a17a2f2008-04-16 00:54:39 -0700648 vn->name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
649
Pavel Emelyanovcd1c7012008-04-16 00:51:12 -0700650 err = vlan_proc_init(net);
Pavel Emelyanovcd1c7012008-04-16 00:51:12 -0700651
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -0700652 return err;
653}
654
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000655static void __net_exit vlan_exit_net(struct net *net)
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -0700656{
Pavel Emelyanovcd1c7012008-04-16 00:51:12 -0700657 vlan_proc_cleanup(net);
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -0700658}
659
660static struct pernet_operations vlan_net_ops = {
661 .init = vlan_init_net,
662 .exit = vlan_exit_net,
Eric W. Biederman946d1a92009-11-29 15:46:05 +0000663 .id = &vlan_net_id,
664 .size = sizeof(struct vlan_net),
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -0700665};
666
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800667static int __init vlan_proto_init(void)
668{
669 int err;
670
Justin Mattockda7c06c2011-05-23 20:43:48 +0000671 pr_info("%s v%s\n", vlan_fullname, vlan_version);
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800672
Eric W. Biederman91e2ff32009-12-02 13:19:08 +0000673 err = register_pernet_subsys(&vlan_net_ops);
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -0700674 if (err < 0)
675 goto err0;
676
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800677 err = register_netdevice_notifier(&vlan_notifier_block);
678 if (err < 0)
679 goto err2;
680
Patrick McHardy70c03b42008-07-05 21:26:57 -0700681 err = vlan_gvrp_init();
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800682 if (err < 0)
683 goto err3;
684
Patrick McHardy70c03b42008-07-05 21:26:57 -0700685 err = vlan_netlink_init();
686 if (err < 0)
687 goto err4;
688
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800689 vlan_ioctl_set(vlan_ioctl_handler);
690 return 0;
691
Patrick McHardy70c03b42008-07-05 21:26:57 -0700692err4:
693 vlan_gvrp_uninit();
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800694err3:
695 unregister_netdevice_notifier(&vlan_notifier_block);
696err2:
Eric W. Biederman91e2ff32009-12-02 13:19:08 +0000697 unregister_pernet_subsys(&vlan_net_ops);
Pavel Emelyanovd9ed0f02008-04-16 00:49:09 -0700698err0:
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800699 return err;
700}
701
702static void __exit vlan_cleanup_module(void)
703{
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800704 vlan_ioctl_set(NULL);
705 vlan_netlink_fini();
706
707 unregister_netdevice_notifier(&vlan_notifier_block);
708
Eric W. Biederman91e2ff32009-12-02 13:19:08 +0000709 unregister_pernet_subsys(&vlan_net_ops);
Jesper Dangaard Brouer6e327c12009-06-08 03:11:28 +0000710 rcu_barrier(); /* Wait for completion of call_rcu()'s */
Patrick McHardy70c03b42008-07-05 21:26:57 -0700711
712 vlan_gvrp_uninit();
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800713}
714
715module_init(vlan_proto_init);
716module_exit(vlan_cleanup_module);
717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718MODULE_LICENSE("GPL");
719MODULE_VERSION(DRV_VERSION);