[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>

9 files changed, 250 insertions, 118 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.
diff --git a/net/core/dev_mcast.c b/net/core/dev_mcast.c
index 8e069fc207cb..1c4f6198459b 100644
--- a/net/core/dev_mcast.c
+++ b/net/core/dev_mcast.c
@@ -187,11 +187,12 @@ EXPORT_SYMBOL(dev_mc_unsync);
 #ifdef CONFIG_PROC_FS
 static void *dev_mc_seq_start(struct seq_file *seq, loff_t *pos)
 {
+        struct net *net = seq->private;
         struct net_device *dev;
         loff_t off = 0;
 
         read_lock(&dev_base_lock);
-        for_each_netdev(dev) {
+        for_each_netdev(net, dev) {
                 if (off++ == *pos)
                         return dev;
         }
@@ -240,7 +241,22 @@ static const struct seq_operations dev_mc_seq_ops = {
 
 static int dev_mc_seq_open(struct inode *inode, struct file *file)
 {
-        return seq_open(file, &dev_mc_seq_ops);
+        struct seq_file *seq;
+        int res;
+        res = seq_open(file, &dev_mc_seq_ops);
+        if (!res) {
+                seq = file->private_data;
+                seq->private = get_net(PROC_NET(inode));
+        }
+        return res;
+}
+
+static int dev_mc_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_mc_seq_fops = {
@@ -248,14 +264,31 @@ static const struct file_operations dev_mc_seq_fops = {
         .open    = dev_mc_seq_open,
         .read    = seq_read,
         .llseek  = seq_lseek,
-        .release = seq_release,
+        .release = dev_mc_seq_release,
 };
 
 #endif
 
+static int dev_mc_net_init(struct net *net)
+{
+        if (!proc_net_fops_create(net, "dev_mcast", 0, &dev_mc_seq_fops))
+                return -ENOMEM;
+        return 0;
+}
+
+static void dev_mc_net_exit(struct net *net)
+{
+        proc_net_remove(net, "dev_mcast");
+}
+
+static struct pernet_operations dev_mc_net_ops = {
+        .init = dev_mc_net_init,
+        .exit = dev_mc_net_exit,
+};
+
 void __init dev_mcast_init(void)
 {
-        proc_net_fops_create(&init_net, "dev_mcast", 0, &dev_mc_seq_fops);
+        register_pernet_subsys(&dev_mc_net_ops);
 }
 
 EXPORT_SYMBOL(dev_mc_add);
diff --git a/net/core/ethtool.c b/net/core/ethtool.c
index 7c43f032a7f9..0d0b13cc1dd3 100644
--- a/net/core/ethtool.c
+++ b/net/core/ethtool.c
@@ -779,9 +779,9 @@ static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
 
 /* The main entry point in this file.  Called from net/core/dev.c */
 
-int dev_ethtool(struct ifreq *ifr)
+int dev_ethtool(struct net *net, struct ifreq *ifr)
 {
-        struct net_device *dev = __dev_get_by_name(ifr->ifr_name);
+        struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
         void __user *useraddr = ifr->ifr_data;
         u32 ethcmd;
         int rc;
diff --git a/net/core/fib_rules.c b/net/core/fib_rules.c
index 9eabe1ae01dc..1ba71baf87ef 100644
--- a/net/core/fib_rules.c
+++ b/net/core/fib_rules.c
@@ -12,6 +12,7 @@
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <net/net_namespace.h>
+#include <net/sock.h>
 #include <net/fib_rules.h>
 
 static LIST_HEAD(rules_ops);
@@ -198,6 +199,7 @@ errout:
 
 static int fib_nl_newrule(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 {
+        struct net *net = skb->sk->sk_net;
         struct fib_rule_hdr *frh = nlmsg_data(nlh);
         struct fib_rules_ops *ops = NULL;
         struct fib_rule *rule, *r, *last = NULL;
@@ -235,7 +237,7 @@ static int fib_nl_newrule(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 
                 rule->ifindex = -1;
                 nla_strlcpy(rule->ifname, tb[FRA_IFNAME], IFNAMSIZ);
-                dev = __dev_get_by_name(rule->ifname);
+                dev = __dev_get_by_name(net, rule->ifname);
                 if (dev)
                         rule->ifindex = dev->ifindex;
         }
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index 5f25f4f79b8c..2c6577c1eedd 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -1441,6 +1441,7 @@ int neigh_table_clear(struct neigh_table *tbl)
 
 static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 {
+        struct net *net = skb->sk->sk_net;
         struct ndmsg *ndm;
         struct nlattr *dst_attr;
         struct neigh_table *tbl;
@@ -1456,7 +1457,7 @@ static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 
         ndm = nlmsg_data(nlh);
         if (ndm->ndm_ifindex) {
-                dev = dev_get_by_index(ndm->ndm_ifindex);
+                dev = dev_get_by_index(net, ndm->ndm_ifindex);
                 if (dev == NULL) {
                         err = -ENODEV;
                         goto out;
@@ -1506,6 +1507,7 @@ out:
 
 static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 {
+        struct net *net = skb->sk->sk_net;
         struct ndmsg *ndm;
         struct nlattr *tb[NDA_MAX+1];
         struct neigh_table *tbl;
@@ -1522,7 +1524,7 @@ static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 
         ndm = nlmsg_data(nlh);
         if (ndm->ndm_ifindex) {
-                dev = dev_get_by_index(ndm->ndm_ifindex);
+                dev = dev_get_by_index(net, ndm->ndm_ifindex);
                 if (dev == NULL) {
                         err = -ENODEV;
                         goto out;
diff --git a/net/core/netpoll.c b/net/core/netpoll.c
index 0952f936b292..bb7523a5b408 100644
--- a/net/core/netpoll.c
+++ b/net/core/netpoll.c
@@ -653,7 +653,7 @@ int netpoll_setup(struct netpoll *np)
         int err;
 
         if (np->dev_name)
-                ndev = dev_get_by_name(np->dev_name);
+                ndev = dev_get_by_name(&init_net, np->dev_name);
         if (!ndev) {
                 printk(KERN_ERR "%s: %s doesn't exist, aborting.\n",
                        np->name, np->dev_name);
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index d7c30ce095a1..94e42be16daa 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -2008,7 +2008,7 @@ static int pktgen_setup_dev(struct pktgen_dev *pkt_dev, const char *ifname)
                 pkt_dev->odev = NULL;
         }
 
-        odev = dev_get_by_name(ifname);
+        odev = dev_get_by_name(&init_net, ifname);
         if (!odev) {
                 printk(KERN_ERR "pktgen: no such netdevice: \"%s\"\n", ifname);
                 return -ENODEV;
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index 416768d1e0cd..44f91bb1ae8d 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -306,10 +306,13 @@ EXPORT_SYMBOL_GPL(rtnl_link_register);
 void __rtnl_link_unregister(struct rtnl_link_ops *ops)
 {
         struct net_device *dev, *n;
+        struct net *net;
 
-        for_each_netdev_safe(dev, n) {
-                if (dev->rtnl_link_ops == ops)
-                        ops->dellink(dev);
+        for_each_net(net) {
+                for_each_netdev_safe(net, dev, n) {
+                        if (dev->rtnl_link_ops == ops)
+                                ops->dellink(dev);
+                }
         }
         list_del(&ops->list);
 }
@@ -693,12 +696,13 @@ nla_put_failure:
 
 static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
 {
+        struct net *net = skb->sk->sk_net;
         int idx;
         int s_idx = cb->args[0];
         struct net_device *dev;
 
         idx = 0;
-        for_each_netdev(dev) {
+        for_each_netdev(net, dev) {
                 if (idx < s_idx)
                         goto cont;
                 if (rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
@@ -858,6 +862,7 @@ errout:
 
 static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 {
+        struct net *net = skb->sk->sk_net;
         struct ifinfomsg *ifm;
         struct net_device *dev;
         int err;
@@ -876,9 +881,9 @@ static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
         err = -EINVAL;
         ifm = nlmsg_data(nlh);
         if (ifm->ifi_index > 0)
-                dev = dev_get_by_index(ifm->ifi_index);
+                dev = dev_get_by_index(net, ifm->ifi_index);
         else if (tb[IFLA_IFNAME])
-                dev = dev_get_by_name(ifname);
+                dev = dev_get_by_name(net, ifname);
         else
                 goto errout;
 
@@ -904,6 +909,7 @@ errout:
 
 static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 {
+        struct net *net = skb->sk->sk_net;
         const struct rtnl_link_ops *ops;
         struct net_device *dev;
         struct ifinfomsg *ifm;
@@ -920,9 +926,9 @@ static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 
         ifm = nlmsg_data(nlh);
         if (ifm->ifi_index > 0)
-                dev = __dev_get_by_index(ifm->ifi_index);
+                dev = __dev_get_by_index(net, ifm->ifi_index);
         else if (tb[IFLA_IFNAME])
-                dev = __dev_get_by_name(ifname);
+                dev = __dev_get_by_name(net, ifname);
         else
                 return -EINVAL;
 
@@ -937,7 +943,7 @@ static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
         return 0;
 }
 
-struct net_device *rtnl_create_link(char *ifname,
+struct net_device *rtnl_create_link(struct net *net, char *ifname,
                 const struct rtnl_link_ops *ops, struct nlattr *tb[])
 {
         int err;
@@ -954,6 +960,7 @@ struct net_device *rtnl_create_link(char *ifname,
                         goto err_free;
         }
 
+        dev->nd_net = net;
         dev->rtnl_link_ops = ops;
 
         if (tb[IFLA_MTU])
@@ -981,6 +988,7 @@ err:
 
 static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
 {
+        struct net *net = skb->sk->sk_net;
         const struct rtnl_link_ops *ops;
         struct net_device *dev;
         struct ifinfomsg *ifm;
@@ -1004,9 +1012,9 @@ replay:
 
         ifm = nlmsg_data(nlh);
         if (ifm->ifi_index > 0)
-                dev = __dev_get_by_index(ifm->ifi_index);
+                dev = __dev_get_by_index(net, ifm->ifi_index);
         else if (ifname[0])
-                dev = __dev_get_by_name(ifname);
+                dev = __dev_get_by_name(net, ifname);
         else
                 dev = NULL;
 
@@ -1092,7 +1100,7 @@ replay:
                 if (!ifname[0])
                         snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
 
-                dev = rtnl_create_link(ifname, ops, tb);
+                dev = rtnl_create_link(net, ifname, ops, tb);
 
                 if (IS_ERR(dev))
                         err = PTR_ERR(dev);
@@ -1109,6 +1117,7 @@ replay:
 
 static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 {
+        struct net *net = skb->sk->sk_net;
         struct ifinfomsg *ifm;
         struct nlattr *tb[IFLA_MAX+1];
         struct net_device *dev = NULL;
@@ -1121,7 +1130,7 @@ static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
 
         ifm = nlmsg_data(nlh);
         if (ifm->ifi_index > 0) {
-                dev = dev_get_by_index(ifm->ifi_index);
+                dev = dev_get_by_index(net, ifm->ifi_index);
                 if (dev == NULL)
                         return -ENODEV;
         } else
diff --git a/net/core/sock.c b/net/core/sock.c
index a31455dc7024..4ed9b507c1e7 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -367,6 +367,7 @@ static int sock_bindtodevice(struct sock *sk, char __user *optval, int optlen)
 {
         int ret = -ENOPROTOOPT;
 #ifdef CONFIG_NETDEVICES
+        struct net *net = sk->sk_net;
         char devname[IFNAMSIZ];
         int index;
 
@@ -395,7 +396,7 @@ static int sock_bindtodevice(struct sock *sk, char __user *optval, int optlen)
         if (devname[0] == '\0') {
                 index = 0;
         } else {
-                struct net_device *dev = dev_get_by_name(devname);
+                struct net_device *dev = dev_get_by_name(net, devname);
 
                 ret = -ENODEV;
                 if (!dev)