[NET]: Make the device list and device lookups per namespace.

This patch makes most of the generic device layer network
namespace safe.  This patch makes dev_base_head a
network namespace variable, and then it picks up
a few associated variables.  The functions:
dev_getbyhwaddr
dev_getfirsthwbytype
dev_get_by_flags
dev_get_by_name
__dev_get_by_name
dev_get_by_index
__dev_get_by_index
dev_ioctl
dev_ethtool
dev_load
wireless_process_ioctl

were modified to take a network namespace argument, and
deal with it.

vlan_ioctl_set and brioctl_set were modified so their
hooks will receive a network namespace argument.

So basically anthing in the core of the network stack that was
affected to by the change of dev_base was modified to handle
multiple network namespaces.  The rest of the network stack was
simply modified to explicitly use &init_net the initial network
namespace.  This can be fixed when those components of the network
stack are modified to handle multiple network namespaces.

For now the ifindex generator is left global.

Fundametally ifindex numbers are per namespace, or else
we will have corner case problems with migration when
we get that far.

At the same time there are assumptions in the network stack
that the ifindex of a network device won't change.  Making
the ifindex number global seems a good compromise until
the network stack can cope with ifindex changes when
you change namespaces, and the like.

Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 178 insertions, 93 deletions

diff --git a/net/core/dev.c b/net/core/dev.c
index 40fd66fbe4e1..3a3d5ee73909 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -190,25 +190,22 @@ static struct net_dma net_dma = {
  * unregister_netdevice(), which must be called with the rtnl
  * semaphore held.
  */
-LIST_HEAD(dev_base_head);
 DEFINE_RWLOCK(dev_base_lock);
 
-EXPORT_SYMBOL(dev_base_head);
 EXPORT_SYMBOL(dev_base_lock);
 
 #define NETDEV_HASHBITS 8
-static struct hlist_head dev_name_head[1<<NETDEV_HASHBITS];
-static struct hlist_head dev_index_head[1<<NETDEV_HASHBITS];
+#define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
 
-static inline struct hlist_head *dev_name_hash(const char *name)
+static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
 {
         unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
-        return &dev_name_head[hash & ((1<<NETDEV_HASHBITS)-1)];
+        return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
 }
 
-static inline struct hlist_head *dev_index_hash(int ifindex)
+static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
 {
-        return &dev_index_head[ifindex & ((1<<NETDEV_HASHBITS)-1)];
+        return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
 }
 
 /*
@@ -492,7 +489,7 @@ unsigned long netdev_boot_base(const char *prefix, int unit)
          * If device already registered then return base of 1
          * to indicate not to probe for this interface
          */
-        if (__dev_get_by_name(name))
+        if (__dev_get_by_name(&init_net, name))
                 return 1;
 
         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
@@ -547,11 +544,11 @@ __setup("netdev=", netdev_boot_setup);
  *      careful with locks.
  */
 
-struct net_device *__dev_get_by_name(const char *name)
+struct net_device *__dev_get_by_name(struct net *net, const char *name)
 {
         struct hlist_node *p;
 
-        hlist_for_each(p, dev_name_hash(name)) {
+        hlist_for_each(p, dev_name_hash(net, name)) {
                 struct net_device *dev
                         = hlist_entry(p, struct net_device, name_hlist);
                 if (!strncmp(dev->name, name, IFNAMSIZ))
@@ -571,12 +568,12 @@ struct net_device *__dev_get_by_name(const char *name)
  *      matching device is found.
  */
 
-struct net_device *dev_get_by_name(const char *name)
+struct net_device *dev_get_by_name(struct net *net, const char *name)
 {
         struct net_device *dev;
 
         read_lock(&dev_base_lock);
-        dev = __dev_get_by_name(name);
+        dev = __dev_get_by_name(net, name);
         if (dev)
                 dev_hold(dev);
         read_unlock(&dev_base_lock);
@@ -594,11 +591,11 @@ struct net_device *dev_get_by_name(const char *name)
  *      or @dev_base_lock.
  */
 
-struct net_device *__dev_get_by_index(int ifindex)
+struct net_device *__dev_get_by_index(struct net *net, int ifindex)
 {
         struct hlist_node *p;
 
-        hlist_for_each(p, dev_index_hash(ifindex)) {
+        hlist_for_each(p, dev_index_hash(net, ifindex)) {
                 struct net_device *dev
                         = hlist_entry(p, struct net_device, index_hlist);
                 if (dev->ifindex == ifindex)
@@ -618,12 +615,12 @@ struct net_device *__dev_get_by_index(int ifindex)
  *      dev_put to indicate they have finished with it.
  */
 
-struct net_device *dev_get_by_index(int ifindex)
+struct net_device *dev_get_by_index(struct net *net, int ifindex)
 {
         struct net_device *dev;
 
         read_lock(&dev_base_lock);
-        dev = __dev_get_by_index(ifindex);
+        dev = __dev_get_by_index(net, ifindex);
         if (dev)
                 dev_hold(dev);
         read_unlock(&dev_base_lock);
@@ -644,13 +641,13 @@ struct net_device *dev_get_by_index(int ifindex)
  *      If the API was consistent this would be __dev_get_by_hwaddr
  */
 
-struct net_device *dev_getbyhwaddr(unsigned short type, char *ha)
+struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
 {
         struct net_device *dev;
 
         ASSERT_RTNL();
 
-        for_each_netdev(dev)
+        for_each_netdev(&init_net, dev)
                 if (dev->type == type &&
                     !memcmp(dev->dev_addr, ha, dev->addr_len))
                         return dev;
@@ -660,12 +657,12 @@ struct net_device *dev_getbyhwaddr(unsigned short type, char *ha)
 
 EXPORT_SYMBOL(dev_getbyhwaddr);
 
-struct net_device *__dev_getfirstbyhwtype(unsigned short type)
+struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
 {
         struct net_device *dev;
 
         ASSERT_RTNL();
-        for_each_netdev(dev)
+        for_each_netdev(net, dev)
                 if (dev->type == type)
                         return dev;
 
@@ -674,12 +671,12 @@ struct net_device *__dev_getfirstbyhwtype(unsigned short type)
 
 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
 
-struct net_device *dev_getfirstbyhwtype(unsigned short type)
+struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
 {
         struct net_device *dev;
 
         rtnl_lock();
-        dev = __dev_getfirstbyhwtype(type);
+        dev = __dev_getfirstbyhwtype(net, type);
         if (dev)
                 dev_hold(dev);
         rtnl_unlock();
@@ -699,13 +696,13 @@ EXPORT_SYMBOL(dev_getfirstbyhwtype);
  *      dev_put to indicate they have finished with it.
  */
 
-struct net_device * dev_get_by_flags(unsigned short if_flags, unsigned short mask)
+struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
 {
         struct net_device *dev, *ret;
 
         ret = NULL;
         read_lock(&dev_base_lock);
-        for_each_netdev(dev) {
+        for_each_netdev(net, dev) {
                 if (((dev->flags ^ if_flags) & mask) == 0) {
                         dev_hold(dev);
                         ret = dev;
@@ -763,6 +760,10 @@ int dev_alloc_name(struct net_device *dev, const char *name)
         const int max_netdevices = 8*PAGE_SIZE;
         long *inuse;
         struct net_device *d;
+        struct net *net;
+
+        BUG_ON(!dev->nd_net);
+        net = dev->nd_net;
 
         p = strnchr(name, IFNAMSIZ-1, '%');
         if (p) {
@@ -779,7 +780,7 @@ int dev_alloc_name(struct net_device *dev, const char *name)
                 if (!inuse)
                         return -ENOMEM;
 
-                for_each_netdev(d) {
+                for_each_netdev(net, d) {
                         if (!sscanf(d->name, name, &i))
                                 continue;
                         if (i < 0 || i >= max_netdevices)
@@ -796,7 +797,7 @@ int dev_alloc_name(struct net_device *dev, const char *name)
         }
 
         snprintf(buf, sizeof(buf), name, i);
-        if (!__dev_get_by_name(buf)) {
+        if (!__dev_get_by_name(net, buf)) {
                 strlcpy(dev->name, buf, IFNAMSIZ);
                 return i;
         }
@@ -822,9 +823,12 @@ int dev_change_name(struct net_device *dev, char *newname)
         char oldname[IFNAMSIZ];
         int err = 0;
         int ret;
+        struct net *net;
 
         ASSERT_RTNL();
+        BUG_ON(!dev->nd_net);
 
+        net = dev->nd_net;
         if (dev->flags & IFF_UP)
                 return -EBUSY;
 
@@ -839,7 +843,7 @@ int dev_change_name(struct net_device *dev, char *newname)
                         return err;
                 strcpy(newname, dev->name);
         }
-        else if (__dev_get_by_name(newname))
+        else if (__dev_get_by_name(net, newname))
                 return -EEXIST;
         else
                 strlcpy(dev->name, newname, IFNAMSIZ);
@@ -849,7 +853,7 @@ rollback:
 
         write_lock_bh(&dev_base_lock);
         hlist_del(&dev->name_hlist);
-        hlist_add_head(&dev->name_hlist, dev_name_hash(dev->name));
+        hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
         write_unlock_bh(&dev_base_lock);
 
         ret = raw_notifier_call_chain(&netdev_chain, NETDEV_CHANGENAME, dev);
@@ -908,12 +912,12 @@ void netdev_state_change(struct net_device *dev)
  *      available in this kernel then it becomes a nop.
  */
 
-void dev_load(const char *name)
+void dev_load(struct net *net, const char *name)
 {
         struct net_device *dev;
 
         read_lock(&dev_base_lock);
-        dev = __dev_get_by_name(name);
+        dev = __dev_get_by_name(net, name);
         read_unlock(&dev_base_lock);
 
         if (!dev && capable(CAP_SYS_MODULE))
@@ -1052,6 +1056,8 @@ int dev_close(struct net_device *dev)
 }
 
 
+static int dev_boot_phase = 1;
+
 /*
  *      Device change register/unregister. These are not inline or static
  *      as we export them to the world.
@@ -1075,23 +1081,27 @@ int register_netdevice_notifier(struct notifier_block *nb)
 {
         struct net_device *dev;
         struct net_device *last;
+        struct net *net;
         int err;
 
         rtnl_lock();
         err = raw_notifier_chain_register(&netdev_chain, nb);
         if (err)
                 goto unlock;
+        if (dev_boot_phase)
+                goto unlock;
+        for_each_net(net) {
+                for_each_netdev(net, dev) {
+                        err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
+                        err = notifier_to_errno(err);
+                        if (err)
+                                goto rollback;
+
+                        if (!(dev->flags & IFF_UP))
+                                continue;
 
-        for_each_netdev(dev) {
-                err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
-                err = notifier_to_errno(err);
-                if (err)
-                        goto rollback;
-
-                if (!(dev->flags & IFF_UP))
-                        continue;
-
-                nb->notifier_call(nb, NETDEV_UP, dev);
+                        nb->notifier_call(nb, NETDEV_UP, dev);
+                }
         }
 
 unlock:
@@ -1100,15 +1110,17 @@ unlock:
 
 rollback:
         last = dev;
-        for_each_netdev(dev) {
-                if (dev == last)
-                        break;
+        for_each_net(net) {
+                for_each_netdev(net, dev) {
+                        if (dev == last)
+                                break;
 
-                if (dev->flags & IFF_UP) {
-                        nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
-                        nb->notifier_call(nb, NETDEV_DOWN, dev);
+                        if (dev->flags & IFF_UP) {
+                                nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
+                                nb->notifier_call(nb, NETDEV_DOWN, dev);
+                        }
+                        nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
                 }
-                nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
         }
         goto unlock;
 }
@@ -2187,7 +2199,7 @@ int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
  *      match.  --pb
  */
 
-static int dev_ifname(struct ifreq __user *arg)
+static int dev_ifname(struct net *net, struct ifreq __user *arg)
 {
         struct net_device *dev;
         struct ifreq ifr;
@@ -2200,7 +2212,7 @@ static int dev_ifname(struct ifreq __user *arg)
                 return -EFAULT;
 
         read_lock(&dev_base_lock);
-        dev = __dev_get_by_index(ifr.ifr_ifindex);
+        dev = __dev_get_by_index(net, ifr.ifr_ifindex);
         if (!dev) {
                 read_unlock(&dev_base_lock);
                 return -ENODEV;
@@ -2220,7 +2232,7 @@ static int dev_ifname(struct ifreq __user *arg)
  *      Thus we will need a 'compatibility mode'.
  */
 
-static int dev_ifconf(char __user *arg)
+static int dev_ifconf(struct net *net, char __user *arg)
 {
         struct ifconf ifc;
         struct net_device *dev;
@@ -2244,7 +2256,7 @@ static int dev_ifconf(char __user *arg)
          */
 
         total = 0;
-        for_each_netdev(dev) {
+        for_each_netdev(net, dev) {
                 for (i = 0; i < NPROTO; i++) {
                         if (gifconf_list[i]) {
                                 int done;
@@ -2278,6 +2290,7 @@ static int dev_ifconf(char __user *arg)
  */
 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
 {
+        struct net *net = seq->private;
         loff_t off;
         struct net_device *dev;
 
@@ -2286,7 +2299,7 @@ void *dev_seq_start(struct seq_file *seq, loff_t *pos)
                 return SEQ_START_TOKEN;
 
         off = 1;
-        for_each_netdev(dev)
+        for_each_netdev(net, dev)
                 if (off++ == *pos)
                         return dev;
 
@@ -2295,9 +2308,10 @@ void *dev_seq_start(struct seq_file *seq, loff_t *pos)
 
 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 {
+        struct net *net = seq->private;
         ++*pos;
         return v == SEQ_START_TOKEN ?
-                first_net_device() : next_net_device((struct net_device *)v);
+                first_net_device(net) : next_net_device((struct net_device *)v);
 }
 
 void dev_seq_stop(struct seq_file *seq, void *v)
@@ -2393,7 +2407,22 @@ static const struct seq_operations dev_seq_ops = {
 
 static int dev_seq_open(struct inode *inode, struct file *file)
 {
-        return seq_open(file, &dev_seq_ops);
+        struct seq_file *seq;
+        int res;
+        res =  seq_open(file, &dev_seq_ops);
+        if (!res) {
+                seq = file->private_data;
+                seq->private = get_net(PROC_NET(inode));
+        }
+        return res;
+}
+
+static int dev_seq_release(struct inode *inode, struct file *file)
+{
+        struct seq_file *seq = file->private_data;
+        struct net *net = seq->private;
+        put_net(net);
+        return seq_release(inode, file);
 }
 
 static const struct file_operations dev_seq_fops = {
@@ -2401,7 +2430,7 @@ static const struct file_operations dev_seq_fops = {
         .open    = dev_seq_open,
         .read    = seq_read,
         .llseek  = seq_lseek,
-        .release = seq_release,
+        .release = dev_seq_release,
 };
 
 static const struct seq_operations softnet_seq_ops = {
@@ -2553,30 +2582,49 @@ static const struct file_operations ptype_seq_fops = {
 };
 
 
-static int __init dev_proc_init(void)
+static int dev_proc_net_init(struct net *net)
 {
         int rc = -ENOMEM;
 
-        if (!proc_net_fops_create(&init_net, "dev", S_IRUGO, &dev_seq_fops))
+        if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
                 goto out;
-        if (!proc_net_fops_create(&init_net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
+        if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
                 goto out_dev;
-        if (!proc_net_fops_create(&init_net, "ptype", S_IRUGO, &ptype_seq_fops))
+        if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
                 goto out_softnet;
 
-        if (wext_proc_init())
+        if (wext_proc_init(net))
                 goto out_ptype;
         rc = 0;
 out:
         return rc;
 out_ptype:
-        proc_net_remove(&init_net, "ptype");
+        proc_net_remove(net, "ptype");
 out_softnet:
-        proc_net_remove(&init_net, "softnet_stat");
+        proc_net_remove(net, "softnet_stat");
 out_dev:
-        proc_net_remove(&init_net, "dev");
+        proc_net_remove(net, "dev");
         goto out;
 }
+
+static void dev_proc_net_exit(struct net *net)
+{
+        wext_proc_exit(net);
+
+        proc_net_remove(net, "ptype");
+        proc_net_remove(net, "softnet_stat");
+        proc_net_remove(net, "dev");
+}
+
+static struct pernet_operations dev_proc_ops = {
+        .init = dev_proc_net_init,
+        .exit = dev_proc_net_exit,
+};
+
+static int __init dev_proc_init(void)
+{
+        return register_pernet_subsys(&dev_proc_ops);
+}
 #else
 #define dev_proc_init() 0
 #endif  /* CONFIG_PROC_FS */
@@ -3011,10 +3059,10 @@ int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
 /*
  *      Perform the SIOCxIFxxx calls.
  */
-static int dev_ifsioc(struct ifreq *ifr, unsigned int cmd)
+static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
 {
         int err;
-        struct net_device *dev = __dev_get_by_name(ifr->ifr_name);
+        struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
 
         if (!dev)
                 return -ENODEV;
@@ -3167,7 +3215,7 @@ static int dev_ifsioc(struct ifreq *ifr, unsigned int cmd)
  *      positive or a negative errno code on error.
  */
 
-int dev_ioctl(unsigned int cmd, void __user *arg)
+int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
 {
         struct ifreq ifr;
         int ret;
@@ -3180,12 +3228,12 @@ int dev_ioctl(unsigned int cmd, void __user *arg)
 
         if (cmd == SIOCGIFCONF) {
                 rtnl_lock();
-                ret = dev_ifconf((char __user *) arg);
+                ret = dev_ifconf(net, (char __user *) arg);
                 rtnl_unlock();
                 return ret;
         }
         if (cmd == SIOCGIFNAME)
-                return dev_ifname((struct ifreq __user *)arg);
+                return dev_ifname(net, (struct ifreq __user *)arg);
 
         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
                 return -EFAULT;
@@ -3215,9 +3263,9 @@ int dev_ioctl(unsigned int cmd, void __user *arg)
                 case SIOCGIFMAP:
                 case SIOCGIFINDEX:
                 case SIOCGIFTXQLEN:
-                        dev_load(ifr.ifr_name);
+                        dev_load(net, ifr.ifr_name);
                         read_lock(&dev_base_lock);
-                        ret = dev_ifsioc(&ifr, cmd);
+                        ret = dev_ifsioc(net, &ifr, cmd);
                         read_unlock(&dev_base_lock);
                         if (!ret) {
                                 if (colon)
@@ -3229,9 +3277,9 @@ int dev_ioctl(unsigned int cmd, void __user *arg)
                         return ret;
 
                 case SIOCETHTOOL:
-                        dev_load(ifr.ifr_name);
+                        dev_load(net, ifr.ifr_name);
                         rtnl_lock();
-                        ret = dev_ethtool(&ifr);
+                        ret = dev_ethtool(net, &ifr);
                         rtnl_unlock();
                         if (!ret) {
                                 if (colon)
@@ -3253,9 +3301,9 @@ int dev_ioctl(unsigned int cmd, void __user *arg)
                 case SIOCSIFNAME:
                         if (!capable(CAP_NET_ADMIN))
                                 return -EPERM;
-                        dev_load(ifr.ifr_name);
+                        dev_load(net, ifr.ifr_name);
                         rtnl_lock();
-                        ret = dev_ifsioc(&ifr, cmd);
+                        ret = dev_ifsioc(net, &ifr, cmd);
                         rtnl_unlock();
                         if (!ret) {
                                 if (colon)
@@ -3294,9 +3342,9 @@ int dev_ioctl(unsigned int cmd, void __user *arg)
                         /* fall through */
                 case SIOCBONDSLAVEINFOQUERY:
                 case SIOCBONDINFOQUERY:
-                        dev_load(ifr.ifr_name);
+                        dev_load(net, ifr.ifr_name);
                         rtnl_lock();
-                        ret = dev_ifsioc(&ifr, cmd);
+                        ret = dev_ifsioc(net, &ifr, cmd);
                         rtnl_unlock();
                         return ret;
 
@@ -3316,9 +3364,9 @@ int dev_ioctl(unsigned int cmd, void __user *arg)
                         if (cmd == SIOCWANDEV ||
                             (cmd >= SIOCDEVPRIVATE &&
                              cmd <= SIOCDEVPRIVATE + 15)) {
-                                dev_load(ifr.ifr_name);
+                                dev_load(net, ifr.ifr_name);
                                 rtnl_lock();
-                                ret = dev_ifsioc(&ifr, cmd);
+                                ret = dev_ifsioc(net, &ifr, cmd);
                                 rtnl_unlock();
                                 if (!ret && copy_to_user(arg, &ifr,
                                                          sizeof(struct ifreq)))
@@ -3327,7 +3375,7 @@ int dev_ioctl(unsigned int cmd, void __user *arg)
                         }
                         /* Take care of Wireless Extensions */
                         if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
-                                return wext_handle_ioctl(&ifr, cmd, arg);
+                                return wext_handle_ioctl(net, &ifr, cmd, arg);
                         return -EINVAL;
         }
 }
@@ -3340,19 +3388,17 @@ int dev_ioctl(unsigned int cmd, void __user *arg)
  *      number.  The caller must hold the rtnl semaphore or the
  *      dev_base_lock to be sure it remains unique.
  */
-static int dev_new_index(void)
+static int dev_new_index(struct net *net)
 {
         static int ifindex;
         for (;;) {
                 if (++ifindex <= 0)
                         ifindex = 1;
-                if (!__dev_get_by_index(ifindex))
+                if (!__dev_get_by_index(net, ifindex))
                         return ifindex;
         }
 }
 
-static int dev_boot_phase = 1;
-
 /* Delayed registration/unregisteration */
 static DEFINE_SPINLOCK(net_todo_list_lock);
 static struct list_head net_todo_list = LIST_HEAD_INIT(net_todo_list);
@@ -3386,6 +3432,7 @@ int register_netdevice(struct net_device *dev)
         struct hlist_head *head;
         struct hlist_node *p;
         int ret;
+        struct net *net;
 
         BUG_ON(dev_boot_phase);
         ASSERT_RTNL();
@@ -3394,6 +3441,8 @@ int register_netdevice(struct net_device *dev)
 
         /* When net_device's are persistent, this will be fatal. */
         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
+        BUG_ON(!dev->nd_net);
+        net = dev->nd_net;
 
         spin_lock_init(&dev->queue_lock);
         spin_lock_init(&dev->_xmit_lock);
@@ -3418,12 +3467,12 @@ int register_netdevice(struct net_device *dev)
                 goto err_uninit;
         }
 
-        dev->ifindex = dev_new_index();
+        dev->ifindex = dev_new_index(net);
         if (dev->iflink == -1)
                 dev->iflink = dev->ifindex;
 
         /* Check for existence of name */
-        head = dev_name_hash(dev->name);
+        head = dev_name_hash(net, dev->name);
         hlist_for_each(p, head) {
                 struct net_device *d
                         = hlist_entry(p, struct net_device, name_hlist);
@@ -3501,9 +3550,9 @@ int register_netdevice(struct net_device *dev)
 
         dev_init_scheduler(dev);
         write_lock_bh(&dev_base_lock);
-        list_add_tail(&dev->dev_list, &dev_base_head);
+        list_add_tail(&dev->dev_list, &net->dev_base_head);
         hlist_add_head(&dev->name_hlist, head);
-        hlist_add_head(&dev->index_hlist, dev_index_hash(dev->ifindex));
+        hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
         dev_hold(dev);
         write_unlock_bh(&dev_base_lock);
 
@@ -4067,6 +4116,45 @@ int netdev_compute_features(unsigned long all, unsigned long one)
 }
 EXPORT_SYMBOL(netdev_compute_features);
 
+/* Initialize per network namespace state */
+static int netdev_init(struct net *net)
+{
+        int i;
+        INIT_LIST_HEAD(&net->dev_base_head);
+        rwlock_init(&dev_base_lock);
+
+        net->dev_name_head = kmalloc(
+                sizeof(*net->dev_name_head)*NETDEV_HASHENTRIES, GFP_KERNEL);
+        if (!net->dev_name_head)
+                return -ENOMEM;
+
+        net->dev_index_head = kmalloc(
+                sizeof(*net->dev_index_head)*NETDEV_HASHENTRIES, GFP_KERNEL);
+        if (!net->dev_index_head) {
+                kfree(net->dev_name_head);
+                return -ENOMEM;
+        }
+
+        for (i = 0; i < NETDEV_HASHENTRIES; i++)
+                INIT_HLIST_HEAD(&net->dev_name_head[i]);
+
+        for (i = 0; i < NETDEV_HASHENTRIES; i++)
+                INIT_HLIST_HEAD(&net->dev_index_head[i]);
+
+        return 0;
+}
+
+static void netdev_exit(struct net *net)
+{
+        kfree(net->dev_name_head);
+        kfree(net->dev_index_head);
+}
+
+static struct pernet_operations netdev_net_ops = {
+        .init = netdev_init,
+        .exit = netdev_exit,
+};
+
 /*
  *      Initialize the DEV module. At boot time this walks the device list and
  *      unhooks any devices that fail to initialise (normally hardware not
@@ -4094,11 +4182,8 @@ static int __init net_dev_init(void)
         for (i = 0; i < 16; i++)
                 INIT_LIST_HEAD(&ptype_base[i]);
 
-        for (i = 0; i < ARRAY_SIZE(dev_name_head); i++)
-                INIT_HLIST_HEAD(&dev_name_head[i]);
-
-        for (i = 0; i < ARRAY_SIZE(dev_index_head); i++)
-                INIT_HLIST_HEAD(&dev_index_head[i]);
+        if (register_pernet_subsys(&netdev_net_ops))
+                goto out;
 
         /*
          *      Initialise the packet receive queues.