6 files changed, 166 insertions, 93 deletions

diff --git a/net/8021q/vlan.c b/net/8021q/vlan.c
index b33410abfd6b..2a739adaa92b 100644
--- a/net/8021q/vlan.c
+++ b/net/8021q/vlan.c
@@ -32,6 +32,7 @@
 #include <linux/rtnetlink.h>
 #include <linux/notifier.h>
 #include <net/net_namespace.h>
+#include <net/netns/generic.h>
 
 #include <linux/if_vlan.h>
 #include "vlan.h"
@@ -41,6 +42,8 @@
 
 /* Global VLAN variables */
 
+int vlan_net_id;
+
 /* Our listing of VLAN group(s) */
 static struct hlist_head vlan_group_hash[VLAN_GRP_HASH_SIZE];
 
@@ -49,9 +52,6 @@ static char vlan_version[] = DRV_VERSION;
 static char vlan_copyright[] = "Ben Greear <greearb@candelatech.com>";
 static char vlan_buggyright[] = "David S. Miller <davem@redhat.com>";
 
-/* Determines interface naming scheme. */
-unsigned short vlan_name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
-
 static struct packet_type vlan_packet_type = {
         .type = __constant_htons(ETH_P_8021Q),
         .func = vlan_skb_recv, /* VLAN receive method */
@@ -65,14 +65,14 @@ static inline unsigned int vlan_grp_hashfn(unsigned int idx)
 }
 
 /* Must be invoked with RCU read lock (no preempt) */
-static struct vlan_group *__vlan_find_group(int real_dev_ifindex)
+static struct vlan_group *__vlan_find_group(struct net_device *real_dev)
 {
         struct vlan_group *grp;
         struct hlist_node *n;
-        int hash = vlan_grp_hashfn(real_dev_ifindex);
+        int hash = vlan_grp_hashfn(real_dev->ifindex);
 
         hlist_for_each_entry_rcu(grp, n, &vlan_group_hash[hash], hlist) {
-                if (grp->real_dev_ifindex == real_dev_ifindex)
+                if (grp->real_dev == real_dev)
                         return grp;
         }
 
@@ -86,7 +86,7 @@ static struct vlan_group *__vlan_find_group(int real_dev_ifindex)
 struct net_device *__find_vlan_dev(struct net_device *real_dev,
                                    unsigned short VID)
 {
-        struct vlan_group *grp = __vlan_find_group(real_dev->ifindex);
+        struct vlan_group *grp = __vlan_find_group(real_dev);
 
         if (grp)
                 return vlan_group_get_device(grp, VID);
@@ -103,32 +103,38 @@ static void vlan_group_free(struct vlan_group *grp)
         kfree(grp);
 }
 
-static struct vlan_group *vlan_group_alloc(int ifindex)
+static struct vlan_group *vlan_group_alloc(struct net_device *real_dev)
 {
         struct vlan_group *grp;
-        unsigned int size;
-        unsigned int i;
 
         grp = kzalloc(sizeof(struct vlan_group), GFP_KERNEL);
         if (!grp)
                 return NULL;
 
-        size = sizeof(struct net_device *) * VLAN_GROUP_ARRAY_PART_LEN;
-
-        for (i = 0; i < VLAN_GROUP_ARRAY_SPLIT_PARTS; i++) {
-                grp->vlan_devices_arrays[i] = kzalloc(size, GFP_KERNEL);
-                if (!grp->vlan_devices_arrays[i])
-                        goto err;
-        }
-
-        grp->real_dev_ifindex = ifindex;
+        grp->real_dev = real_dev;
         hlist_add_head_rcu(&grp->hlist,
-                           &vlan_group_hash[vlan_grp_hashfn(ifindex)]);
+                        &vlan_group_hash[vlan_grp_hashfn(real_dev->ifindex)]);
         return grp;
+}
 
-err:
-        vlan_group_free(grp);
-        return NULL;
+static int vlan_group_prealloc_vid(struct vlan_group *vg, int vid)
+{
+        struct net_device **array;
+        unsigned int size;
+
+        ASSERT_RTNL();
+
+        array = vg->vlan_devices_arrays[vid / VLAN_GROUP_ARRAY_PART_LEN];
+        if (array != NULL)
+                return 0;
+
+        size = sizeof(struct net_device *) * VLAN_GROUP_ARRAY_PART_LEN;
+        array = kzalloc(size, GFP_KERNEL);
+        if (array == NULL)
+                return -ENOBUFS;
+
+        vg->vlan_devices_arrays[vid / VLAN_GROUP_ARRAY_PART_LEN] = array;
+        return 0;
 }
 
 static void vlan_rcu_free(struct rcu_head *rcu)
@@ -145,11 +151,9 @@ void unregister_vlan_dev(struct net_device *dev)
 
         ASSERT_RTNL();
 
-        grp = __vlan_find_group(real_dev->ifindex);
+        grp = __vlan_find_group(real_dev);
         BUG_ON(!grp);
 
-        vlan_proc_rem_dev(dev);
-
         /* Take it out of our own structures, but be sure to interlock with
          * HW accelerating devices or SW vlan input packet processing.
          */
@@ -240,13 +244,17 @@ int register_vlan_dev(struct net_device *dev)
         struct vlan_group *grp, *ngrp = NULL;
         int err;
 
-        grp = __vlan_find_group(real_dev->ifindex);
+        grp = __vlan_find_group(real_dev);
         if (!grp) {
-                ngrp = grp = vlan_group_alloc(real_dev->ifindex);
+                ngrp = grp = vlan_group_alloc(real_dev);
                 if (!grp)
                         return -ENOBUFS;
         }
 
+        err = vlan_group_prealloc_vid(grp, vlan_id);
+        if (err < 0)
+                goto out_free_group;
+
         err = register_netdevice(dev);
         if (err < 0)
                 goto out_free_group;
@@ -268,9 +276,6 @@ int register_vlan_dev(struct net_device *dev)
         if (real_dev->features & NETIF_F_HW_VLAN_FILTER)
                 real_dev->vlan_rx_add_vid(real_dev, vlan_id);
 
-        if (vlan_proc_add_dev(dev) < 0)
-                pr_warning("8021q: failed to add proc entry for %s\n",
-                           dev->name);
         return 0;
 
 out_free_group:
@@ -286,6 +291,8 @@ static int register_vlan_device(struct net_device *real_dev,
                                 unsigned short VLAN_ID)
 {
         struct net_device *new_dev;
+        struct net *net = dev_net(real_dev);
+        struct vlan_net *vn = net_generic(net, vlan_net_id);
         char name[IFNAMSIZ];
         int err;
 
@@ -297,7 +304,7 @@ static int register_vlan_device(struct net_device *real_dev,
                 return err;
 
         /* Gotta set up the fields for the device. */
-        switch (vlan_name_type) {
+        switch (vn->name_type) {
         case VLAN_NAME_TYPE_RAW_PLUS_VID:
                 /* name will look like:  eth1.0005 */
                 snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, VLAN_ID);
@@ -328,6 +335,7 @@ static int register_vlan_device(struct net_device *real_dev,
         if (new_dev == NULL)
                 return -ENOBUFS;
 
+        dev_net_set(new_dev, net);
         /* need 4 bytes for extra VLAN header info,
          * hope the underlying device can handle it.
          */
@@ -383,6 +391,14 @@ static void __vlan_device_event(struct net_device *dev, unsigned long event)
                         pr_warning("8021q: failed to change proc name for %s\n",
                                         dev->name);
                 break;
+        case NETDEV_REGISTER:
+                if (vlan_proc_add_dev(dev) < 0)
+                        pr_warning("8021q: failed to add proc entry for %s\n",
+                                        dev->name);
+                break;
+        case NETDEV_UNREGISTER:
+                vlan_proc_rem_dev(dev);
+                break;
         }
 }
 
@@ -394,15 +410,12 @@ static int vlan_device_event(struct notifier_block *unused, unsigned long event,
         int i, flgs;
         struct net_device *vlandev;
 
-        if (dev->nd_net != &init_net)
-                return NOTIFY_DONE;
-
         if (is_vlan_dev(dev)) {
                 __vlan_device_event(dev, event);
                 goto out;
         }
 
-        grp = __vlan_find_group(dev->ifindex);
+        grp = __vlan_find_group(dev);
         if (!grp)
                 goto out;
 
@@ -522,7 +535,7 @@ static int vlan_ioctl_handler(struct net *net, void __user *arg)
         case GET_VLAN_REALDEV_NAME_CMD:
         case GET_VLAN_VID_CMD:
                 err = -ENODEV;
-                dev = __dev_get_by_name(&init_net, args.device1);
+                dev = __dev_get_by_name(net, args.device1);
                 if (!dev)
                         goto out;
 
@@ -567,7 +580,10 @@ static int vlan_ioctl_handler(struct net *net, void __user *arg)
                         break;
                 if ((args.u.name_type >= 0) &&
                     (args.u.name_type < VLAN_NAME_TYPE_HIGHEST)) {
-                        vlan_name_type = args.u.name_type;
+                        struct vlan_net *vn;
+
+                        vn = net_generic(net, vlan_net_id);
+                        vn->name_type = args.u.name_type;
                         err = 0;
                 } else {
                         err = -EINVAL;
@@ -615,6 +631,51 @@ out:
         return err;
 }
 
+static int vlan_init_net(struct net *net)
+{
+        int err;
+        struct vlan_net *vn;
+
+        err = -ENOMEM;
+        vn = kzalloc(sizeof(struct vlan_net), GFP_KERNEL);
+        if (vn == NULL)
+                goto err_alloc;
+
+        err = net_assign_generic(net, vlan_net_id, vn);
+        if (err < 0)
+                goto err_assign;
+
+        vn->name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
+
+        err = vlan_proc_init(net);
+        if (err < 0)
+                goto err_proc;
+
+        return 0;
+
+err_proc:
+        /* nothing */
+err_assign:
+        kfree(vn);
+err_alloc:
+        return err;
+}
+
+static void vlan_exit_net(struct net *net)
+{
+        struct vlan_net *vn;
+
+        vn = net_generic(net, vlan_net_id);
+        rtnl_kill_links(net, &vlan_link_ops);
+        vlan_proc_cleanup(net);
+        kfree(vn);
+}
+
+static struct pernet_operations vlan_net_ops = {
+        .init = vlan_init_net,
+        .exit = vlan_exit_net,
+};
+
 static int __init vlan_proto_init(void)
 {
         int err;
@@ -622,9 +683,9 @@ static int __init vlan_proto_init(void)
         pr_info("%s v%s %s\n", vlan_fullname, vlan_version, vlan_copyright);
         pr_info("All bugs added by %s\n", vlan_buggyright);
 
-        err = vlan_proc_init();
+        err = register_pernet_gen_device(&vlan_net_id, &vlan_net_ops);
         if (err < 0)
-                goto err1;
+                goto err0;
 
         err = register_netdevice_notifier(&vlan_notifier_block);
         if (err < 0)
@@ -641,8 +702,8 @@ static int __init vlan_proto_init(void)
 err3:
         unregister_netdevice_notifier(&vlan_notifier_block);
 err2:
-        vlan_proc_cleanup();
-err1:
+        unregister_pernet_gen_device(vlan_net_id, &vlan_net_ops);
+err0:
         return err;
 }
 
@@ -661,7 +722,7 @@ static void __exit vlan_cleanup_module(void)
         for (i = 0; i < VLAN_GRP_HASH_SIZE; i++)
                 BUG_ON(!hlist_empty(&vlan_group_hash[i]));
 
-        vlan_proc_cleanup();
+        unregister_pernet_gen_device(vlan_net_id, &vlan_net_ops);
 
         synchronize_net();
 }
diff --git a/net/8021q/vlan.h b/net/8021q/vlan.h
index 51271aea402b..5229a72c7ea1 100644
--- a/net/8021q/vlan.h
+++ b/net/8021q/vlan.h
@@ -3,8 +3,6 @@
 
 #include <linux/if_vlan.h>
 
-extern unsigned short vlan_name_type;
-
 #define VLAN_GRP_HASH_SHIFT     5
 #define VLAN_GRP_HASH_SIZE      (1 << VLAN_GRP_HASH_SHIFT)
 #define VLAN_GRP_HASH_MASK      (VLAN_GRP_HASH_SIZE - 1)
@@ -50,4 +48,17 @@ static inline int is_vlan_dev(struct net_device *dev)
         return dev->priv_flags & IFF_802_1Q_VLAN;
 }
 
+extern int vlan_net_id;
+
+struct proc_dir_entry;
+
+struct vlan_net {
+        /* /proc/net/vlan */
+        struct proc_dir_entry *proc_vlan_dir;
+        /* /proc/net/vlan/config */
+        struct proc_dir_entry *proc_vlan_conf;
+        /* Determines interface naming scheme. */
+        unsigned short name_type;
+};
+
 #endif /* !(__BEN_VLAN_802_1Q_INC__) */
diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c
index 41a76a05e6fd..c961f0826005 100644
--- a/net/8021q/vlan_dev.c
+++ b/net/8021q/vlan_dev.c
@@ -153,9 +153,6 @@ int vlan_skb_recv(struct sk_buff *skb, struct net_device *dev,
         struct net_device_stats *stats;
         unsigned short vlan_TCI;
 
-        if (dev->nd_net != &init_net)
-                goto err_free;
-
         skb = skb_share_check(skb, GFP_ATOMIC);
         if (skb == NULL)
                 goto err_free;
@@ -171,7 +168,7 @@ int vlan_skb_recv(struct sk_buff *skb, struct net_device *dev,
         skb->dev = __find_vlan_dev(dev, vid);
         if (!skb->dev) {
                 pr_debug("%s: ERROR: No net_device for VID: %u on dev: %s\n",
-                         __FUNCTION__, (unsigned int)vid, dev->name);
+                         __func__, (unsigned int)vid, dev->name);
                 goto err_unlock;
         }
 
@@ -187,7 +184,7 @@ int vlan_skb_recv(struct sk_buff *skb, struct net_device *dev,
                                                   ntohs(vhdr->h_vlan_TCI));
 
         pr_debug("%s: priority: %u for TCI: %hu\n",
-                 __FUNCTION__, skb->priority, ntohs(vhdr->h_vlan_TCI));
+                 __func__, skb->priority, ntohs(vhdr->h_vlan_TCI));
 
         switch (skb->pkt_type) {
         case PACKET_BROADCAST: /* Yeah, stats collect these together.. */
@@ -268,7 +265,7 @@ static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev,
         struct net_device *vdev = dev;
 
         pr_debug("%s: skb: %p type: %hx len: %u vlan_id: %hx, daddr: %p\n",
-                 __FUNCTION__, skb, type, len, vlan_dev_info(dev)->vlan_id,
+                 __func__, skb, type, len, vlan_dev_info(dev)->vlan_id,
                  daddr);
 
         /* build vlan header only if re_order_header flag is NOT set.  This
@@ -340,7 +337,7 @@ static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev,
                         return -ENOMEM;
                 }
                 vlan_dev_info(vdev)->cnt_inc_headroom_on_tx++;
-                pr_debug("%s: %s: had to grow skb\n", __FUNCTION__, vdev->name);
+                pr_debug("%s: %s: had to grow skb\n", __func__, vdev->name);
         }
 
         if (build_vlan_header) {
@@ -382,7 +379,7 @@ static int vlan_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 vlan_dev_info(dev)->cnt_encap_on_xmit++;
 
                 pr_debug("%s: proto to encap: 0x%hx\n",
-                         __FUNCTION__, ntohs(veth->h_vlan_proto));
+                         __func__, ntohs(veth->h_vlan_proto));
                 /* Construct the second two bytes. This field looks something
                  * like:
                  * usr_priority: 3 bits  (high bits)
@@ -403,7 +400,7 @@ static int vlan_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
         }
 
         pr_debug("%s: about to send skb: %p to dev: %s\n",
-                __FUNCTION__, skb, skb->dev->name);
+                __func__, skb, skb->dev->name);
         pr_debug("  " MAC_FMT " " MAC_FMT " %4hx %4hx %4hx\n",
                  veth->h_dest[0], veth->h_dest[1], veth->h_dest[2],
                  veth->h_dest[3], veth->h_dest[4], veth->h_dest[5],
diff --git a/net/8021q/vlan_netlink.c b/net/8021q/vlan_netlink.c
index e32eeb37987e..c93e69ec28ed 100644
--- a/net/8021q/vlan_netlink.c
+++ b/net/8021q/vlan_netlink.c
@@ -113,7 +113,7 @@ static int vlan_newlink(struct net_device *dev,
 
         if (!tb[IFLA_LINK])
                 return -EINVAL;
-        real_dev = __dev_get_by_index(&init_net, nla_get_u32(tb[IFLA_LINK]));
+        real_dev = __dev_get_by_index(dev_net(dev), nla_get_u32(tb[IFLA_LINK]));
         if (!real_dev)
                 return -ENODEV;
 
diff --git a/net/8021q/vlanproc.c b/net/8021q/vlanproc.c
index 9671aa51af2c..daad0064e2c2 100644
--- a/net/8021q/vlanproc.c
+++ b/net/8021q/vlanproc.c
@@ -34,6 +34,7 @@
 #include <linux/netdevice.h>
 #include <linux/if_vlan.h>
 #include <net/net_namespace.h>
+#include <net/netns/generic.h>
 #include "vlanproc.h"
 #include "vlan.h"
 
@@ -79,7 +80,8 @@ static const struct seq_operations vlan_seq_ops = {
 
 static int vlan_seq_open(struct inode *inode, struct file *file)
 {
-        return seq_open(file, &vlan_seq_ops);
+        return seq_open_net(inode, file, &vlan_seq_ops,
+                        sizeof(struct seq_net_private));
 }
 
 static const struct file_operations vlan_fops = {
@@ -87,7 +89,7 @@ static const struct file_operations vlan_fops = {
         .open    = vlan_seq_open,
         .read    = seq_read,
         .llseek  = seq_lseek,
-        .release = seq_release,
+        .release = seq_release_net,
 };
 
 /*
@@ -111,18 +113,6 @@ static const struct file_operations vlandev_fops = {
  * Proc filesystem derectory entries.
  */
 
-/*
- *      /proc/net/vlan
- */
-
-static struct proc_dir_entry *proc_vlan_dir;
-
-/*
- *      /proc/net/vlan/config
- */
-
-static struct proc_dir_entry *proc_vlan_conf;
-
 /* Strings */
 static const char *vlan_name_type_str[VLAN_NAME_TYPE_HIGHEST] = {
     [VLAN_NAME_TYPE_RAW_PLUS_VID]        = "VLAN_NAME_TYPE_RAW_PLUS_VID",
@@ -138,13 +128,15 @@ static const char *vlan_name_type_str[VLAN_NAME_TYPE_HIGHEST] = {
  *      Clean up /proc/net/vlan entries
  */
 
-void vlan_proc_cleanup(void)
+void vlan_proc_cleanup(struct net *net)
 {
-        if (proc_vlan_conf)
-                remove_proc_entry(name_conf, proc_vlan_dir);
+        struct vlan_net *vn = net_generic(net, vlan_net_id);
+
+        if (vn->proc_vlan_conf)
+                remove_proc_entry(name_conf, vn->proc_vlan_dir);
 
-        if (proc_vlan_dir)
-                proc_net_remove(&init_net, name_root);
+        if (vn->proc_vlan_dir)
+                proc_net_remove(net, name_root);
 
         /* Dynamically added entries should be cleaned up as their vlan_device
          * is removed, so we should not have to take care of it here...
@@ -155,21 +147,23 @@ void vlan_proc_cleanup(void)
  *      Create /proc/net/vlan entries
  */
 
-int __init vlan_proc_init(void)
+int vlan_proc_init(struct net *net)
 {
-        proc_vlan_dir = proc_mkdir(name_root, init_net.proc_net);
-        if (!proc_vlan_dir)
+        struct vlan_net *vn = net_generic(net, vlan_net_id);
+
+        vn->proc_vlan_dir = proc_net_mkdir(net, name_root, net->proc_net);
+        if (!vn->proc_vlan_dir)
                 goto err;
 
-        proc_vlan_conf = proc_create(name_conf, S_IFREG|S_IRUSR|S_IWUSR,
-                                     proc_vlan_dir, &vlan_fops);
-        if (!proc_vlan_conf)
+        vn->proc_vlan_conf = proc_create(name_conf, S_IFREG|S_IRUSR|S_IWUSR,
+                                     vn->proc_vlan_dir, &vlan_fops);
+        if (!vn->proc_vlan_conf)
                 goto err;
         return 0;
 
 err:
-        pr_err("%s: can't create entry in proc filesystem!\n", __FUNCTION__);
-        vlan_proc_cleanup();
+        pr_err("%s: can't create entry in proc filesystem!\n", __func__);
+        vlan_proc_cleanup(net);
         return -ENOBUFS;
 }
 
@@ -180,9 +174,10 @@ err:
 int vlan_proc_add_dev(struct net_device *vlandev)
 {
         struct vlan_dev_info *dev_info = vlan_dev_info(vlandev);
+        struct vlan_net *vn = net_generic(dev_net(vlandev), vlan_net_id);
 
         dev_info->dent = proc_create(vlandev->name, S_IFREG|S_IRUSR|S_IWUSR,
-                                     proc_vlan_dir, &vlandev_fops);
+                                     vn->proc_vlan_dir, &vlandev_fops);
         if (!dev_info->dent)
                 return -ENOBUFS;
 
@@ -195,10 +190,12 @@ int vlan_proc_add_dev(struct net_device *vlandev)
  */
 int vlan_proc_rem_dev(struct net_device *vlandev)
 {
+        struct vlan_net *vn = net_generic(dev_net(vlandev), vlan_net_id);
+
         /** NOTE:  This will consume the memory pointed to by dent, it seems. */
         if (vlan_dev_info(vlandev)->dent) {
                 remove_proc_entry(vlan_dev_info(vlandev)->dent->name,
-                                  proc_vlan_dir);
+                                  vn->proc_vlan_dir);
                 vlan_dev_info(vlandev)->dent = NULL;
         }
         return 0;
@@ -215,6 +212,7 @@ static void *vlan_seq_start(struct seq_file *seq, loff_t *pos)
         __acquires(dev_base_lock)
 {
         struct net_device *dev;
+        struct net *net = seq_file_net(seq);
         loff_t i = 1;
 
         read_lock(&dev_base_lock);
@@ -222,7 +220,7 @@ static void *vlan_seq_start(struct seq_file *seq, loff_t *pos)
         if (*pos == 0)
                 return SEQ_START_TOKEN;
 
-        for_each_netdev(&init_net, dev) {
+        for_each_netdev(net, dev) {
                 if (!is_vlan_dev(dev))
                         continue;
 
@@ -236,14 +234,15 @@ static void *vlan_seq_start(struct seq_file *seq, loff_t *pos)
 static void *vlan_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
         struct net_device *dev;
+        struct net *net = seq_file_net(seq);
 
         ++*pos;
 
         dev = (struct net_device *)v;
         if (v == SEQ_START_TOKEN)
-                dev = net_device_entry(&init_net.dev_base_head);
+                dev = net_device_entry(&net->dev_base_head);
 
-        for_each_netdev_continue(&init_net, dev) {
+        for_each_netdev_continue(net, dev) {
                 if (!is_vlan_dev(dev))
                         continue;
 
@@ -261,13 +260,16 @@ static void vlan_seq_stop(struct seq_file *seq, void *v)
 
 static int vlan_seq_show(struct seq_file *seq, void *v)
 {
+        struct net *net = seq_file_net(seq);
+        struct vlan_net *vn = net_generic(net, vlan_net_id);
+
         if (v == SEQ_START_TOKEN) {
                 const char *nmtype = NULL;
 
                 seq_puts(seq, "VLAN Dev name     | VLAN ID\n");
 
-                if (vlan_name_type < ARRAY_SIZE(vlan_name_type_str))
-                    nmtype =  vlan_name_type_str[vlan_name_type];
+                if (vn->name_type < ARRAY_SIZE(vlan_name_type_str))
+                    nmtype =  vlan_name_type_str[vn->name_type];
 
                 seq_printf(seq, "Name-Type: %s\n",
                            nmtype ? nmtype :  "UNKNOWN");
diff --git a/net/8021q/vlanproc.h b/net/8021q/vlanproc.h
index da542cacc5a5..063f60a3d5cc 100644
--- a/net/8021q/vlanproc.h
+++ b/net/8021q/vlanproc.h
@@ -2,15 +2,17 @@
 #define __BEN_VLAN_PROC_INC__
 
 #ifdef CONFIG_PROC_FS
-int vlan_proc_init(void);
+struct net;
+
+int vlan_proc_init(struct net *net);
 int vlan_proc_rem_dev(struct net_device *vlandev);
 int vlan_proc_add_dev(struct net_device *vlandev);
-void vlan_proc_cleanup(void);
+void vlan_proc_cleanup(struct net *net);
 
 #else /* No CONFIG_PROC_FS */
 
-#define vlan_proc_init()        (0)
-#define vlan_proc_cleanup()     do {} while (0)
+#define vlan_proc_init(net)     (0)
+#define vlan_proc_cleanup(net)  do {} while (0)
 #define vlan_proc_add_dev(dev)  ({(void)(dev), 0; })
 #define vlan_proc_rem_dev(dev)  ({(void)(dev), 0; })
 #endif