netns: net_identifiers should be read_mostly
[linux-2.6.git] / net / phonet / pn_dev.c
index 6b30cc1..d5ad794 100644 (file)
 #include <linux/netdevice.h>
 #include <linux/phonet.h>
 #include <linux/proc_fs.h>
+#include <linux/if_arp.h>
 #include <net/sock.h>
 #include <net/netns/generic.h>
 #include <net/phonet/pn_dev.h>
 
+struct phonet_routes {
+       struct mutex            lock;
+       struct net_device       *table[64];
+};
+
 struct phonet_net {
        struct phonet_device_list pndevs;
+       struct phonet_routes routes;
 };
 
-int phonet_net_id;
+int phonet_net_id __read_mostly;
 
 struct phonet_device_list *phonet_device_list(struct net *net)
 {
@@ -97,7 +104,7 @@ struct net_device *phonet_device_get(struct net *net)
 {
        struct phonet_device_list *pndevs = phonet_device_list(net);
        struct phonet_device *pnd;
-       struct net_device *dev;
+       struct net_device *dev = NULL;
 
        spin_lock_bh(&pndevs->lock);
        list_for_each_entry(pnd, &pndevs->list, list) {
@@ -153,10 +160,11 @@ int phonet_address_del(struct net_device *dev, u8 addr)
 }
 
 /* Gets a source address toward a destination, through a interface. */
-u8 phonet_address_get(struct net_device *dev, u8 addr)
+u8 phonet_address_get(struct net_device *dev, u8 daddr)
 {
        struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
        struct phonet_device *pnd;
+       u8 saddr;
 
        spin_lock_bh(&pndevs->lock);
        pnd = __phonet_get(dev);
@@ -164,12 +172,26 @@ u8 phonet_address_get(struct net_device *dev, u8 addr)
                BUG_ON(bitmap_empty(pnd->addrs, 64));
 
                /* Use same source address as destination, if possible */
-               if (!test_bit(addr >> 2, pnd->addrs))
-                       addr = find_first_bit(pnd->addrs, 64) << 2;
+               if (test_bit(daddr >> 2, pnd->addrs))
+                       saddr = daddr;
+               else
+                       saddr = find_first_bit(pnd->addrs, 64) << 2;
        } else
-               addr = PN_NO_ADDR;
+               saddr = PN_NO_ADDR;
        spin_unlock_bh(&pndevs->lock);
-       return addr;
+
+       if (saddr == PN_NO_ADDR) {
+               /* Fallback to another device */
+               struct net_device *def_dev;
+
+               def_dev = phonet_device_get(dev_net(dev));
+               if (def_dev) {
+                       if (def_dev != dev)
+                               saddr = phonet_address_get(def_dev, daddr);
+                       dev_put(def_dev);
+               }
+       }
+       return saddr;
 }
 
 int phonet_address_lookup(struct net *net, u8 addr)
@@ -195,14 +217,71 @@ found:
        return err;
 }
 
+/* automatically configure a Phonet device, if supported */
+static int phonet_device_autoconf(struct net_device *dev)
+{
+       struct if_phonet_req req;
+       int ret;
+
+       if (!dev->netdev_ops->ndo_do_ioctl)
+               return -EOPNOTSUPP;
+
+       ret = dev->netdev_ops->ndo_do_ioctl(dev, (struct ifreq *)&req,
+                                               SIOCPNGAUTOCONF);
+       if (ret < 0)
+               return ret;
+
+       ASSERT_RTNL();
+       ret = phonet_address_add(dev, req.ifr_phonet_autoconf.device);
+       if (ret)
+               return ret;
+       phonet_address_notify(RTM_NEWADDR, dev,
+                               req.ifr_phonet_autoconf.device);
+       return 0;
+}
+
+static void phonet_route_autodel(struct net_device *dev)
+{
+       struct phonet_net *pnn = net_generic(dev_net(dev), phonet_net_id);
+       unsigned i;
+       DECLARE_BITMAP(deleted, 64);
+
+       /* Remove left-over Phonet routes */
+       bitmap_zero(deleted, 64);
+       mutex_lock(&pnn->routes.lock);
+       for (i = 0; i < 64; i++)
+               if (dev == pnn->routes.table[i]) {
+                       rcu_assign_pointer(pnn->routes.table[i], NULL);
+                       set_bit(i, deleted);
+               }
+       mutex_unlock(&pnn->routes.lock);
+
+       if (bitmap_empty(deleted, 64))
+               return; /* short-circuit RCU */
+       synchronize_rcu();
+       for (i = find_first_bit(deleted, 64); i < 64;
+                       i = find_next_bit(deleted, 64, i + 1)) {
+               rtm_phonet_notify(RTM_DELROUTE, dev, i);
+               dev_put(dev);
+       }
+}
+
 /* notify Phonet of device events */
 static int phonet_device_notify(struct notifier_block *me, unsigned long what,
                                void *arg)
 {
        struct net_device *dev = arg;
 
-       if (what == NETDEV_UNREGISTER)
+       switch (what) {
+       case NETDEV_REGISTER:
+               if (dev->type == ARPHRD_PHONET)
+                       phonet_device_autoconf(dev);
+               break;
+       case NETDEV_UNREGISTER:
                phonet_device_destroy(dev);
+               phonet_route_autodel(dev);
+               break;
+       }
        return 0;
 
 }
@@ -215,7 +294,7 @@ static struct notifier_block phonet_device_notifier = {
 /* Per-namespace Phonet devices handling */
 static int phonet_init_net(struct net *net)
 {
-       struct phonet_net *pnn = kmalloc(sizeof(*pnn), GFP_KERNEL);
+       struct phonet_net *pnn = kzalloc(sizeof(*pnn), GFP_KERNEL);
        if (!pnn)
                return -ENOMEM;
 
@@ -226,6 +305,7 @@ static int phonet_init_net(struct net *net)
 
        INIT_LIST_HEAD(&pnn->pndevs.list);
        spin_lock_init(&pnn->pndevs.lock);
+       mutex_init(&pnn->routes.lock);
        net_assign_generic(net, phonet_net_id, pnn);
        return 0;
 }
@@ -234,10 +314,19 @@ static void phonet_exit_net(struct net *net)
 {
        struct phonet_net *pnn = net_generic(net, phonet_net_id);
        struct net_device *dev;
+       unsigned i;
 
        rtnl_lock();
        for_each_netdev(net, dev)
                phonet_device_destroy(dev);
+
+       for (i = 0; i < 64; i++) {
+               dev = pnn->routes.table[i];
+               if (dev) {
+                       rtm_phonet_notify(RTM_DELROUTE, dev, i);
+                       dev_put(dev);
+               }
+       }
        rtnl_unlock();
 
        proc_net_remove(net, "phonet");
@@ -269,3 +358,73 @@ void phonet_device_exit(void)
        unregister_netdevice_notifier(&phonet_device_notifier);
        unregister_pernet_gen_device(phonet_net_id, &phonet_net_ops);
 }
+
+int phonet_route_add(struct net_device *dev, u8 daddr)
+{
+       struct phonet_net *pnn = net_generic(dev_net(dev), phonet_net_id);
+       struct phonet_routes *routes = &pnn->routes;
+       int err = -EEXIST;
+
+       daddr = daddr >> 2;
+       mutex_lock(&routes->lock);
+       if (routes->table[daddr] == NULL) {
+               rcu_assign_pointer(routes->table[daddr], dev);
+               dev_hold(dev);
+               err = 0;
+       }
+       mutex_unlock(&routes->lock);
+       return err;
+}
+
+int phonet_route_del(struct net_device *dev, u8 daddr)
+{
+       struct phonet_net *pnn = net_generic(dev_net(dev), phonet_net_id);
+       struct phonet_routes *routes = &pnn->routes;
+
+       daddr = daddr >> 2;
+       mutex_lock(&routes->lock);
+       if (dev == routes->table[daddr])
+               rcu_assign_pointer(routes->table[daddr], NULL);
+       else
+               dev = NULL;
+       mutex_unlock(&routes->lock);
+
+       if (!dev)
+               return -ENOENT;
+       synchronize_rcu();
+       dev_put(dev);
+       return 0;
+}
+
+struct net_device *phonet_route_get(struct net *net, u8 daddr)
+{
+       struct phonet_net *pnn = net_generic(net, phonet_net_id);
+       struct phonet_routes *routes = &pnn->routes;
+       struct net_device *dev;
+
+       ASSERT_RTNL(); /* no need to hold the device */
+
+       daddr >>= 2;
+       rcu_read_lock();
+       dev = rcu_dereference(routes->table[daddr]);
+       rcu_read_unlock();
+       return dev;
+}
+
+struct net_device *phonet_route_output(struct net *net, u8 daddr)
+{
+       struct phonet_net *pnn = net_generic(net, phonet_net_id);
+       struct phonet_routes *routes = &pnn->routes;
+       struct net_device *dev;
+
+       daddr >>= 2;
+       rcu_read_lock();
+       dev = rcu_dereference(routes->table[daddr]);
+       if (dev)
+               dev_hold(dev);
+       rcu_read_unlock();
+
+       if (!dev)
+               dev = phonet_device_get(net); /* Default route */
+       return dev;
+}