blob: cf8d810a130d27cb4f146daf85720cf17ab9c9c1 [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
21#include <asm/uaccess.h> /* for copy_from_user */
Randy Dunlap4fc268d2006-01-11 12:17:47 -080022#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/module.h>
24#include <linux/netdevice.h>
25#include <linux/skbuff.h>
26#include <net/datalink.h>
27#include <linux/mm.h>
28#include <linux/in.h>
29#include <linux/init.h>
30#include <net/p8022.h>
31#include <net/arp.h>
32#include <linux/rtnetlink.h>
33#include <linux/notifier.h>
Eric W. Biedermane9dc8652007-09-12 13:02:17 +020034#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
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/* Our listing of VLAN group(s) */
45static struct hlist_head vlan_group_hash[VLAN_GRP_HASH_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47static char vlan_fullname[] = "802.1Q VLAN Support";
48static char vlan_version[] = DRV_VERSION;
49static char vlan_copyright[] = "Ben Greear <greearb@candelatech.com>";
50static char vlan_buggyright[] = "David S. Miller <davem@redhat.com>";
51
Linus Torvalds1da177e2005-04-16 15:20:36 -070052/* Determines interface naming scheme. */
53unsigned short vlan_name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
54
55static struct packet_type vlan_packet_type = {
56 .type = __constant_htons(ETH_P_8021Q),
57 .func = vlan_skb_recv, /* VLAN receive method */
58};
59
Linus Torvalds1da177e2005-04-16 15:20:36 -070060/* End of global variables definitions. */
61
Patrick McHardy2029cc22008-01-21 00:26:41 -080062static inline unsigned int vlan_grp_hashfn(unsigned int idx)
63{
64 return ((idx >> VLAN_GRP_HASH_SHIFT) ^ idx) & VLAN_GRP_HASH_MASK;
65}
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067/* Must be invoked with RCU read lock (no preempt) */
Pavel Emelyanova9fde262008-04-16 00:48:04 -070068static struct vlan_group *__vlan_find_group(struct net_device *real_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070069{
70 struct vlan_group *grp;
71 struct hlist_node *n;
Pavel Emelyanova9fde262008-04-16 00:48:04 -070072 int hash = vlan_grp_hashfn(real_dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
74 hlist_for_each_entry_rcu(grp, n, &vlan_group_hash[hash], hlist) {
Pavel Emelyanova9fde262008-04-16 00:48:04 -070075 if (grp->real_dev == real_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 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 */
86struct net_device *__find_vlan_dev(struct net_device *real_dev,
87 unsigned short VID)
88{
Pavel Emelyanova9fde262008-04-16 00:48:04 -070089 struct vlan_group *grp = __vlan_find_group(real_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
91 if (grp)
Dan Aloni5c15bde2007-03-02 20:44:51 -080092 return vlan_group_get_device(grp, VID);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94 return NULL;
95}
96
Dan Aloni5c15bde2007-03-02 20:44:51 -080097static void vlan_group_free(struct vlan_group *grp)
98{
99 int i;
100
Patrick McHardy2029cc22008-01-21 00:26:41 -0800101 for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++)
Dan Aloni5c15bde2007-03-02 20:44:51 -0800102 kfree(grp->vlan_devices_arrays[i]);
103 kfree(grp);
104}
105
Pavel Emelyanova9fde262008-04-16 00:48:04 -0700106static struct vlan_group *vlan_group_alloc(struct net_device *real_dev)
Patrick McHardy42429aa2007-06-13 12:05:59 -0700107{
108 struct vlan_group *grp;
Patrick McHardy42429aa2007-06-13 12:05:59 -0700109
110 grp = kzalloc(sizeof(struct vlan_group), GFP_KERNEL);
111 if (!grp)
112 return NULL;
113
Pavel Emelyanova9fde262008-04-16 00:48:04 -0700114 grp->real_dev = real_dev;
Patrick McHardy42429aa2007-06-13 12:05:59 -0700115 hlist_add_head_rcu(&grp->hlist,
Pavel Emelyanova9fde262008-04-16 00:48:04 -0700116 &vlan_group_hash[vlan_grp_hashfn(real_dev->ifindex)]);
Patrick McHardy42429aa2007-06-13 12:05:59 -0700117 return grp;
Pavel Emelyanov67727182008-03-26 16:27:22 -0700118}
Patrick McHardy42429aa2007-06-13 12:05:59 -0700119
Pavel Emelyanov67727182008-03-26 16:27:22 -0700120static int vlan_group_prealloc_vid(struct vlan_group *vg, int vid)
121{
122 struct net_device **array;
123 unsigned int size;
124
125 ASSERT_RTNL();
126
127 array = vg->vlan_devices_arrays[vid / VLAN_GROUP_ARRAY_PART_LEN];
128 if (array != NULL)
129 return 0;
130
131 size = sizeof(struct net_device *) * VLAN_GROUP_ARRAY_PART_LEN;
132 array = kzalloc(size, GFP_KERNEL);
133 if (array == NULL)
134 return -ENOBUFS;
135
136 vg->vlan_devices_arrays[vid / VLAN_GROUP_ARRAY_PART_LEN] = array;
137 return 0;
Patrick McHardy42429aa2007-06-13 12:05:59 -0700138}
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140static void vlan_rcu_free(struct rcu_head *rcu)
141{
Dan Aloni5c15bde2007-03-02 20:44:51 -0800142 vlan_group_free(container_of(rcu, struct vlan_group, rcu));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143}
144
Patrick McHardyaf301512008-01-21 00:25:50 -0800145void unregister_vlan_dev(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
Patrick McHardy9dfebcc2008-01-21 00:26:07 -0800147 struct vlan_dev_info *vlan = vlan_dev_info(dev);
Patrick McHardyaf301512008-01-21 00:25:50 -0800148 struct net_device *real_dev = vlan->real_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 struct vlan_group *grp;
Patrick McHardyaf301512008-01-21 00:25:50 -0800150 unsigned short vlan_id = vlan->vlan_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
152 ASSERT_RTNL();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
Pavel Emelyanova9fde262008-04-16 00:48:04 -0700154 grp = __vlan_find_group(real_dev);
Patrick McHardyaf301512008-01-21 00:25:50 -0800155 BUG_ON(!grp);
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800156
157 vlan_proc_rem_dev(dev);
158
159 /* Take it out of our own structures, but be sure to interlock with
160 * HW accelerating devices or SW vlan input packet processing.
161 */
162 if (real_dev->features & NETIF_F_HW_VLAN_FILTER)
163 real_dev->vlan_rx_kill_vid(real_dev, vlan_id);
164
165 vlan_group_set_device(grp, vlan_id, NULL);
Patrick McHardyaf301512008-01-21 00:25:50 -0800166 grp->nr_vlans--;
167
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800168 synchronize_net();
169
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800170 /* If the group is now empty, kill off the group. */
Patrick McHardyaf301512008-01-21 00:25:50 -0800171 if (grp->nr_vlans == 0) {
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800172 if (real_dev->features & NETIF_F_HW_VLAN_RX)
173 real_dev->vlan_rx_register(real_dev, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800175 hlist_del_rcu(&grp->hlist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
Patrick McHardyacc5efb2008-01-21 00:25:31 -0800177 /* Free the group, after all cpu's are done. */
178 call_rcu(&grp->rcu, vlan_rcu_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 }
180
Patrick McHardyaf301512008-01-21 00:25:50 -0800181 /* Get rid of the vlan's reference to real_dev */
182 dev_put(real_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Patrick McHardyc17d8872007-06-13 12:05:22 -0700184 unregister_netdevice(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185}
186
Patrick McHardy2029cc22008-01-21 00:26:41 -0800187static void vlan_transfer_operstate(const struct net_device *dev,
188 struct net_device *vlandev)
Stefan Rompfddd7bf92006-03-20 17:11:41 -0800189{
190 /* Have to respect userspace enforced dormant state
191 * of real device, also must allow supplicant running
192 * on VLAN device
193 */
194 if (dev->operstate == IF_OPER_DORMANT)
195 netif_dormant_on(vlandev);
196 else
197 netif_dormant_off(vlandev);
198
199 if (netif_carrier_ok(dev)) {
200 if (!netif_carrier_ok(vlandev))
201 netif_carrier_on(vlandev);
202 } else {
203 if (netif_carrier_ok(vlandev))
204 netif_carrier_off(vlandev);
205 }
206}
207
Patrick McHardy07b5b172007-06-13 12:07:54 -0700208int vlan_check_real_dev(struct net_device *real_dev, unsigned short vlan_id)
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700209{
Patrick McHardy40f98e12008-01-21 00:24:30 -0800210 char *name = real_dev->name;
211
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700212 if (real_dev->features & NETIF_F_VLAN_CHALLENGED) {
Patrick McHardy40f98e12008-01-21 00:24:30 -0800213 pr_info("8021q: VLANs not supported on %s\n", name);
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700214 return -EOPNOTSUPP;
215 }
216
217 if ((real_dev->features & NETIF_F_HW_VLAN_RX) &&
218 !real_dev->vlan_rx_register) {
Patrick McHardy40f98e12008-01-21 00:24:30 -0800219 pr_info("8021q: device %s has buggy VLAN hw accel\n", name);
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700220 return -EOPNOTSUPP;
221 }
222
223 if ((real_dev->features & NETIF_F_HW_VLAN_FILTER) &&
224 (!real_dev->vlan_rx_add_vid || !real_dev->vlan_rx_kill_vid)) {
Patrick McHardy40f98e12008-01-21 00:24:30 -0800225 pr_info("8021q: Device %s has buggy VLAN hw accel\n", name);
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700226 return -EOPNOTSUPP;
227 }
228
229 /* The real device must be up and operating in order to
230 * assosciate a VLAN device with it.
231 */
232 if (!(real_dev->flags & IFF_UP))
233 return -ENETDOWN;
234
Patrick McHardy40f98e12008-01-21 00:24:30 -0800235 if (__find_vlan_dev(real_dev, vlan_id) != NULL)
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700236 return -EEXIST;
Patrick McHardyc1d3ee92007-06-13 12:06:14 -0700237
238 return 0;
239}
240
Patrick McHardy07b5b172007-06-13 12:07:54 -0700241int register_vlan_dev(struct net_device *dev)
Patrick McHardye89fe422007-06-13 12:06:29 -0700242{
Patrick McHardy9dfebcc2008-01-21 00:26:07 -0800243 struct vlan_dev_info *vlan = vlan_dev_info(dev);
Patrick McHardye89fe422007-06-13 12:06:29 -0700244 struct net_device *real_dev = vlan->real_dev;
245 unsigned short vlan_id = vlan->vlan_id;
246 struct vlan_group *grp, *ngrp = NULL;
247 int err;
248
Pavel Emelyanova9fde262008-04-16 00:48:04 -0700249 grp = __vlan_find_group(real_dev);
Patrick McHardye89fe422007-06-13 12:06:29 -0700250 if (!grp) {
Pavel Emelyanova9fde262008-04-16 00:48:04 -0700251 ngrp = grp = vlan_group_alloc(real_dev);
Patrick McHardye89fe422007-06-13 12:06:29 -0700252 if (!grp)
253 return -ENOBUFS;
254 }
255
Pavel Emelyanov67727182008-03-26 16:27:22 -0700256 err = vlan_group_prealloc_vid(grp, vlan_id);
257 if (err < 0)
258 goto out_free_group;
259
Patrick McHardye89fe422007-06-13 12:06:29 -0700260 err = register_netdevice(dev);
261 if (err < 0)
262 goto out_free_group;
263
264 /* Account for reference in struct vlan_dev_info */
265 dev_hold(real_dev);
266
267 vlan_transfer_operstate(real_dev, dev);
268 linkwatch_fire_event(dev); /* _MUST_ call rfc2863_policy() */
269
270 /* So, got the sucker initialized, now lets place
271 * it into our local structure.
272 */
273 vlan_group_set_device(grp, vlan_id, dev);
Patrick McHardyaf301512008-01-21 00:25:50 -0800274 grp->nr_vlans++;
275
Patrick McHardye89fe422007-06-13 12:06:29 -0700276 if (ngrp && real_dev->features & NETIF_F_HW_VLAN_RX)
277 real_dev->vlan_rx_register(real_dev, ngrp);
278 if (real_dev->features & NETIF_F_HW_VLAN_FILTER)
279 real_dev->vlan_rx_add_vid(real_dev, vlan_id);
280
281 if (vlan_proc_add_dev(dev) < 0)
Patrick McHardy40f98e12008-01-21 00:24:30 -0800282 pr_warning("8021q: failed to add proc entry for %s\n",
283 dev->name);
Patrick McHardye89fe422007-06-13 12:06:29 -0700284 return 0;
285
286out_free_group:
287 if (ngrp)
288 vlan_group_free(ngrp);
289 return err;
290}
291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292/* Attach a VLAN device to a mac address (ie Ethernet Card).
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700293 * Returns 0 if the device was created or a negative error code otherwise.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 */
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700295static int register_vlan_device(struct net_device *real_dev,
296 unsigned short VLAN_ID)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 struct net_device *new_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 char name[IFNAMSIZ];
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700300 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 if (VLAN_ID >= VLAN_VID_MASK)
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700303 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700305 err = vlan_check_real_dev(real_dev, VLAN_ID);
306 if (err < 0)
307 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
309 /* Gotta set up the fields for the device. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 switch (vlan_name_type) {
311 case VLAN_NAME_TYPE_RAW_PLUS_VID:
312 /* name will look like: eth1.0005 */
313 snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, VLAN_ID);
314 break;
315 case VLAN_NAME_TYPE_PLUS_VID_NO_PAD:
316 /* Put our vlan.VID in the name.
317 * Name will look like: vlan5
318 */
319 snprintf(name, IFNAMSIZ, "vlan%i", VLAN_ID);
320 break;
321 case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD:
322 /* Put our vlan.VID in the name.
323 * Name will look like: eth0.5
324 */
325 snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, VLAN_ID);
326 break;
327 case VLAN_NAME_TYPE_PLUS_VID:
328 /* Put our vlan.VID in the name.
329 * Name will look like: vlan0005
330 */
331 default:
332 snprintf(name, IFNAMSIZ, "vlan%.4i", VLAN_ID);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700333 }
YOSHIFUJI Hideaki122952f2007-02-09 23:24:25 +0900334
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 new_dev = alloc_netdev(sizeof(struct vlan_dev_info), name,
336 vlan_setup);
Arjan van de Ven5dd8d1e2006-07-03 00:25:33 -0700337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 if (new_dev == NULL)
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700339 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 /* need 4 bytes for extra VLAN header info,
342 * hope the underlying device can handle it.
343 */
344 new_dev->mtu = real_dev->mtu;
345
Patrick McHardy9dfebcc2008-01-21 00:26:07 -0800346 vlan_dev_info(new_dev)->vlan_id = VLAN_ID; /* 1 through VLAN_VID_MASK */
347 vlan_dev_info(new_dev)->real_dev = real_dev;
348 vlan_dev_info(new_dev)->dent = NULL;
349 vlan_dev_info(new_dev)->flags = VLAN_FLAG_REORDER_HDR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
Patrick McHardy07b5b172007-06-13 12:07:54 -0700351 new_dev->rtnl_link_ops = &vlan_link_ops;
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700352 err = register_vlan_dev(new_dev);
353 if (err < 0)
Patrick McHardye89fe422007-06-13 12:06:29 -0700354 goto out_free_newdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700356 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358out_free_newdev:
359 free_netdev(new_dev);
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700360 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361}
362
Patrick McHardy8c979c22007-07-11 19:45:24 -0700363static void vlan_sync_address(struct net_device *dev,
364 struct net_device *vlandev)
365{
Patrick McHardy9dfebcc2008-01-21 00:26:07 -0800366 struct vlan_dev_info *vlan = vlan_dev_info(vlandev);
Patrick McHardy8c979c22007-07-11 19:45:24 -0700367
368 /* May be called without an actual change */
369 if (!compare_ether_addr(vlan->real_dev_addr, dev->dev_addr))
370 return;
371
372 /* vlan address was different from the old address and is equal to
373 * the new address */
374 if (compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
375 !compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
376 dev_unicast_delete(dev, vlandev->dev_addr, ETH_ALEN);
377
378 /* vlan address was equal to the old address and is different from
379 * the new address */
380 if (!compare_ether_addr(vlandev->dev_addr, vlan->real_dev_addr) &&
381 compare_ether_addr(vlandev->dev_addr, dev->dev_addr))
382 dev_unicast_add(dev, vlandev->dev_addr, ETH_ALEN);
383
384 memcpy(vlan->real_dev_addr, dev->dev_addr, ETH_ALEN);
385}
386
Pavel Emelyanov802fb172008-04-02 00:08:01 -0700387static void __vlan_device_event(struct net_device *dev, unsigned long event)
388{
389 switch (event) {
390 case NETDEV_CHANGENAME:
391 vlan_proc_rem_dev(dev);
392 if (vlan_proc_add_dev(dev) < 0)
393 pr_warning("8021q: failed to change proc name for %s\n",
394 dev->name);
395 break;
396 }
397}
398
Patrick McHardy2029cc22008-01-21 00:26:41 -0800399static int vlan_device_event(struct notifier_block *unused, unsigned long event,
400 void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401{
402 struct net_device *dev = ptr;
Pavel Emelyanov802fb172008-04-02 00:08:01 -0700403 struct vlan_group *grp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 int i, flgs;
405 struct net_device *vlandev;
406
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900407 if (dev_net(dev) != &init_net)
Eric W. Biedermane9dc8652007-09-12 13:02:17 +0200408 return NOTIFY_DONE;
409
Pavel Emelyanov802fb172008-04-02 00:08:01 -0700410 if (is_vlan_dev(dev)) {
411 __vlan_device_event(dev, event);
412 goto out;
413 }
414
Pavel Emelyanova9fde262008-04-16 00:48:04 -0700415 grp = __vlan_find_group(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 if (!grp)
417 goto out;
418
419 /* It is OK that we do not hold the group lock right now,
420 * as we run under the RTNL lock.
421 */
422
423 switch (event) {
424 case NETDEV_CHANGE:
425 /* Propagate real device state to vlan devices */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
Dan Aloni5c15bde2007-03-02 20:44:51 -0800427 vlandev = vlan_group_get_device(grp, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 if (!vlandev)
429 continue;
430
Stefan Rompfddd7bf92006-03-20 17:11:41 -0800431 vlan_transfer_operstate(dev, vlandev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 }
433 break;
434
Patrick McHardy8c979c22007-07-11 19:45:24 -0700435 case NETDEV_CHANGEADDR:
436 /* Adjust unicast filters on underlying device */
437 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
438 vlandev = vlan_group_get_device(grp, i);
439 if (!vlandev)
440 continue;
441
Patrick McHardyd932e042007-11-10 21:51:40 -0800442 flgs = vlandev->flags;
443 if (!(flgs & IFF_UP))
444 continue;
445
Patrick McHardy8c979c22007-07-11 19:45:24 -0700446 vlan_sync_address(dev, vlandev);
447 }
448 break;
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 case NETDEV_DOWN:
451 /* Put all VLANs for this dev in the down state too. */
452 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
Dan Aloni5c15bde2007-03-02 20:44:51 -0800453 vlandev = vlan_group_get_device(grp, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 if (!vlandev)
455 continue;
456
457 flgs = vlandev->flags;
458 if (!(flgs & IFF_UP))
459 continue;
460
461 dev_change_flags(vlandev, flgs & ~IFF_UP);
462 }
463 break;
464
465 case NETDEV_UP:
466 /* Put all VLANs for this dev in the up state too. */
467 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
Dan Aloni5c15bde2007-03-02 20:44:51 -0800468 vlandev = vlan_group_get_device(grp, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 if (!vlandev)
470 continue;
YOSHIFUJI Hideaki122952f2007-02-09 23:24:25 +0900471
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 flgs = vlandev->flags;
473 if (flgs & IFF_UP)
474 continue;
475
476 dev_change_flags(vlandev, flgs | IFF_UP);
477 }
478 break;
YOSHIFUJI Hideaki122952f2007-02-09 23:24:25 +0900479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 case NETDEV_UNREGISTER:
481 /* Delete all VLANs for this dev. */
482 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
Dan Aloni5c15bde2007-03-02 20:44:51 -0800483 vlandev = vlan_group_get_device(grp, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 if (!vlandev)
485 continue;
486
Patrick McHardyaf301512008-01-21 00:25:50 -0800487 /* unregistration of last vlan destroys group, abort
488 * afterwards */
489 if (grp->nr_vlans == 1)
490 i = VLAN_GROUP_ARRAY_LEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Patrick McHardyaf301512008-01-21 00:25:50 -0800492 unregister_vlan_dev(vlandev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 }
494 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700495 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
497out:
498 return NOTIFY_DONE;
499}
500
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800501static struct notifier_block vlan_notifier_block __read_mostly = {
502 .notifier_call = vlan_device_event,
503};
504
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505/*
506 * VLAN IOCTL handler.
507 * o execute requested action or pass command to the device driver
508 * arg is really a struct vlan_ioctl_args __user *.
509 */
Eric W. Biederman881d9662007-09-17 11:56:21 -0700510static int vlan_ioctl_handler(struct net *net, void __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511{
Patrick McHardyc17d8872007-06-13 12:05:22 -0700512 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 unsigned short vid = 0;
514 struct vlan_ioctl_args args;
Patrick McHardyc17d8872007-06-13 12:05:22 -0700515 struct net_device *dev = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
517 if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args)))
518 return -EFAULT;
519
520 /* Null terminate this sucker, just in case. */
521 args.device1[23] = 0;
522 args.u.device2[23] = 0;
523
Patrick McHardyc17d8872007-06-13 12:05:22 -0700524 rtnl_lock();
525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 switch (args.cmd) {
527 case SET_VLAN_INGRESS_PRIORITY_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700528 case SET_VLAN_EGRESS_PRIORITY_CMD:
529 case SET_VLAN_FLAG_CMD:
530 case ADD_VLAN_CMD:
531 case DEL_VLAN_CMD:
532 case GET_VLAN_REALDEV_NAME_CMD:
533 case GET_VLAN_VID_CMD:
534 err = -ENODEV;
Eric W. Biederman881d9662007-09-17 11:56:21 -0700535 dev = __dev_get_by_name(&init_net, args.device1);
Patrick McHardyc17d8872007-06-13 12:05:22 -0700536 if (!dev)
537 goto out;
538
539 err = -EINVAL;
540 if (args.cmd != ADD_VLAN_CMD &&
541 !(dev->priv_flags & IFF_802_1Q_VLAN))
542 goto out;
543 }
544
545 switch (args.cmd) {
546 case SET_VLAN_INGRESS_PRIORITY_CMD:
547 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700549 break;
550 vlan_dev_set_ingress_priority(dev,
551 args.u.skb_priority,
552 args.vlan_qos);
Patrick McHardyfffe4702007-11-07 01:31:32 -0800553 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 break;
555
556 case SET_VLAN_EGRESS_PRIORITY_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700557 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700559 break;
560 err = vlan_dev_set_egress_priority(dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 args.u.skb_priority,
562 args.vlan_qos);
563 break;
564
565 case SET_VLAN_FLAG_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700566 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700568 break;
569 err = vlan_dev_set_vlan_flag(dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 args.u.flag,
571 args.vlan_qos);
572 break;
573
574 case SET_VLAN_NAME_TYPE_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700575 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 if (!capable(CAP_NET_ADMIN))
Pavel Emelyanove35de022007-12-06 22:52:16 -0800577 break;
Patrick McHardyc17d8872007-06-13 12:05:22 -0700578 if ((args.u.name_type >= 0) &&
579 (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 vlan_name_type = args.u.name_type;
581 err = 0;
582 } else {
583 err = -EINVAL;
584 }
585 break;
586
587 case ADD_VLAN_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700588 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700590 break;
Patrick McHardy2ae0bf62007-06-13 12:06:43 -0700591 err = register_vlan_device(dev, args.u.VID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 break;
593
594 case DEL_VLAN_CMD:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700595 err = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 if (!capable(CAP_NET_ADMIN))
Patrick McHardyc17d8872007-06-13 12:05:22 -0700597 break;
Patrick McHardyaf301512008-01-21 00:25:50 -0800598 unregister_vlan_dev(dev);
599 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 break;
601
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 case GET_VLAN_REALDEV_NAME_CMD:
Andrew Morton3f5f4342007-07-24 15:37:11 -0700603 err = 0;
Patrick McHardyc17d8872007-06-13 12:05:22 -0700604 vlan_dev_get_realdev_name(dev, args.u.device2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 if (copy_to_user(arg, &args,
Patrick McHardy2029cc22008-01-21 00:26:41 -0800606 sizeof(struct vlan_ioctl_args)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 err = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 break;
609
610 case GET_VLAN_VID_CMD:
Andrew Morton3f5f4342007-07-24 15:37:11 -0700611 err = 0;
Patrick McHardyc17d8872007-06-13 12:05:22 -0700612 vlan_dev_get_vid(dev, &vid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 args.u.VID = vid;
614 if (copy_to_user(arg, &args,
Patrick McHardy2029cc22008-01-21 00:26:41 -0800615 sizeof(struct vlan_ioctl_args)))
YOSHIFUJI Hideaki122952f2007-02-09 23:24:25 +0900616 err = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 break;
618
619 default:
Patrick McHardy198a2912008-01-21 00:24:59 -0800620 err = -EOPNOTSUPP;
Patrick McHardyc17d8872007-06-13 12:05:22 -0700621 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700622 }
Mika Kukkonen7eb1b3d2005-12-21 18:39:49 -0800623out:
Patrick McHardyc17d8872007-06-13 12:05:22 -0700624 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 return err;
626}
627
Patrick McHardy69ab4b72008-01-21 00:25:15 -0800628static int __init vlan_proto_init(void)
629{
630 int err;
631
632 pr_info("%s v%s %s\n", vlan_fullname, vlan_version, vlan_copyright);
633 pr_info("All bugs added by %s\n", vlan_buggyright);
634
635 err = vlan_proc_init();
636 if (err < 0)
637 goto err1;
638
639 err = register_netdevice_notifier(&vlan_notifier_block);
640 if (err < 0)
641 goto err2;
642
643 err = vlan_netlink_init();
644 if (err < 0)
645 goto err3;
646
647 dev_add_pack(&vlan_packet_type);
648 vlan_ioctl_set(vlan_ioctl_handler);
649 return 0;
650
651err3:
652 unregister_netdevice_notifier(&vlan_notifier_block);
653err2:
654 vlan_proc_cleanup();
655err1:
656 return err;
657}
658
659static void __exit vlan_cleanup_module(void)
660{
661 unsigned int i;
662
663 vlan_ioctl_set(NULL);
664 vlan_netlink_fini();
665
666 unregister_netdevice_notifier(&vlan_notifier_block);
667
668 dev_remove_pack(&vlan_packet_type);
669
670 /* This table must be empty if there are no module references left. */
671 for (i = 0; i < VLAN_GRP_HASH_SIZE; i++)
672 BUG_ON(!hlist_empty(&vlan_group_hash[i]));
673
674 vlan_proc_cleanup();
675
676 synchronize_net();
677}
678
679module_init(vlan_proto_init);
680module_exit(vlan_cleanup_module);
681
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682MODULE_LICENSE("GPL");
683MODULE_VERSION(DRV_VERSION);