[linux-2.6-block.git] / net / phonet / pn_dev.c

/*
 * File: pn_dev.c
 *
 * Phonet network device
 *
 * Copyright (C) 2008 Nokia Corporation.
 *
 * Contact: Remi Denis-Courmont <remi.denis-courmont@nokia.com>
 * Original author: Sakari Ailus <sakari.ailus@nokia.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 */

#include <linux/kernel.h>
#include <linux/net.h>
#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 __read_mostly;

struct phonet_device_list *phonet_device_list(struct net *net)
{
	struct phonet_net *pnn = net_generic(net, phonet_net_id);
	return &pnn->pndevs;
}

/* Allocate new Phonet device. */
static struct phonet_device *__phonet_device_alloc(struct net_device *dev)
{
	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
	struct phonet_device *pnd = kmalloc(sizeof(*pnd), GFP_ATOMIC);
	if (pnd == NULL)
		return NULL;
	pnd->netdev = dev;
	bitmap_zero(pnd->addrs, 64);

	BUG_ON(!mutex_is_locked(&pndevs->lock));
	list_add_rcu(&pnd->list, &pndevs->list);
	return pnd;
}

static struct phonet_device *__phonet_get(struct net_device *dev)
{
	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
	struct phonet_device *pnd;

	BUG_ON(!mutex_is_locked(&pndevs->lock));
	list_for_each_entry(pnd, &pndevs->list, list) {
		if (pnd->netdev == dev)
			return pnd;
	}
	return NULL;
}

static struct phonet_device *__phonet_get_rcu(struct net_device *dev)
{
	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
	struct phonet_device *pnd;

	list_for_each_entry_rcu(pnd, &pndevs->list, list) {
		if (pnd->netdev == dev)
			return pnd;
	}
	return NULL;
}

static void phonet_device_destroy(struct net_device *dev)
{
	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
	struct phonet_device *pnd;

	ASSERT_RTNL();

	mutex_lock(&pndevs->lock);
	pnd = __phonet_get(dev);
	if (pnd)
		list_del_rcu(&pnd->list);
	mutex_unlock(&pndevs->lock);

	if (pnd) {
		u8 addr;

		for_each_set_bit(addr, pnd->addrs, 64)
			phonet_address_notify(RTM_DELADDR, dev, addr);
		kfree(pnd);
	}
}

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 = NULL;

	rcu_read_lock();
	list_for_each_entry_rcu(pnd, &pndevs->list, list) {
		dev = pnd->netdev;
		BUG_ON(!dev);

		if ((dev->reg_state == NETREG_REGISTERED) &&
			((pnd->netdev->flags & IFF_UP)) == IFF_UP)
			break;
		dev = NULL;
	}
	if (dev)
		dev_hold(dev);
	rcu_read_unlock();
	return dev;
}

int phonet_address_add(struct net_device *dev, u8 addr)
{
	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
	struct phonet_device *pnd;
	int err = 0;

	mutex_lock(&pndevs->lock);
	/* Find or create Phonet-specific device data */
	pnd = __phonet_get(dev);
	if (pnd == NULL)
		pnd = __phonet_device_alloc(dev);
	if (unlikely(pnd == NULL))
		err = -ENOMEM;
	else if (test_and_set_bit(addr >> 2, pnd->addrs))
		err = -EEXIST;
	mutex_unlock(&pndevs->lock);
	return err;
}

int phonet_address_del(struct net_device *dev, u8 addr)
{
	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
	struct phonet_device *pnd;
	int err = 0;

	mutex_lock(&pndevs->lock);
	pnd = __phonet_get(dev);
	if (!pnd || !test_and_clear_bit(addr >> 2, pnd->addrs)) {
		err = -EADDRNOTAVAIL;
		pnd = NULL;
	} else if (bitmap_empty(pnd->addrs, 64))
		list_del_rcu(&pnd->list);
	else
		pnd = NULL;
	mutex_unlock(&pndevs->lock);

	if (pnd) {
		synchronize_rcu();
		kfree(pnd);
	}
	return err;
}

/* Gets a source address toward a destination, through a interface. */
u8 phonet_address_get(struct net_device *dev, u8 daddr)
{
	struct phonet_device *pnd;
	u8 saddr;

	rcu_read_lock();
	pnd = __phonet_get_rcu(dev);
	if (pnd) {
		BUG_ON(bitmap_empty(pnd->addrs, 64));

		/* Use same source address as destination, if possible */
		if (test_bit(daddr >> 2, pnd->addrs))
			saddr = daddr;
		else
			saddr = find_first_bit(pnd->addrs, 64) << 2;
	} else
		saddr = PN_NO_ADDR;
	rcu_read_unlock();

	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)
{
	struct phonet_device_list *pndevs = phonet_device_list(net);
	struct phonet_device *pnd;
	int err = -EADDRNOTAVAIL;

	rcu_read_lock();
	list_for_each_entry_rcu(pnd, &pndevs->list, list) {
		/* Don't allow unregistering devices! */
		if ((pnd->netdev->reg_state != NETREG_REGISTERED) ||
				((pnd->netdev->flags & IFF_UP)) != IFF_UP)
			continue;

		if (test_bit(addr >> 2, pnd->addrs)) {
			err = 0;
			goto found;
		}
	}
found:
	rcu_read_unlock();
	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;

	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;

}

static struct notifier_block phonet_device_notifier = {
	.notifier_call = phonet_device_notify,
	.priority = 0,
};

/* Per-namespace Phonet devices handling */
static int __net_init phonet_init_net(struct net *net)
{
	struct phonet_net *pnn = net_generic(net, phonet_net_id);

	if (!proc_net_fops_create(net, "phonet", 0, &pn_sock_seq_fops))
		return -ENOMEM;

	INIT_LIST_HEAD(&pnn->pndevs.list);
	mutex_init(&pnn->pndevs.lock);
	mutex_init(&pnn->routes.lock);
	return 0;
}

static void __net_exit 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");
}

static struct pernet_operations phonet_net_ops = {
	.init = phonet_init_net,
	.exit = phonet_exit_net,
	.id   = &phonet_net_id,
	.size = sizeof(struct phonet_net),
};

/* Initialize Phonet devices list */
int __init phonet_device_init(void)
{
	int err = register_pernet_device(&phonet_net_ops);
	if (err)
		return err;

	register_netdevice_notifier(&phonet_device_notifier);
	err = phonet_netlink_register();
	if (err)
		phonet_device_exit();
	return err;
}

void phonet_device_exit(void)
{
	rtnl_unregister_all(PF_PHONET);
	unregister_netdevice_notifier(&phonet_device_notifier);
	unregister_pernet_device(&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;
}
Commit	Line	Data
f8ff6028 RDC	1	/*
	2	* File: pn_dev.c
	3	*
	4	* Phonet network device
	5	*
	6	* Copyright (C) 2008 Nokia Corporation.
	7	*
	8	* Contact: Remi Denis-Courmont <remi.denis-courmont@nokia.com>
	9	* Original author: Sakari Ailus <sakari.ailus@nokia.com>
	10	*
	11	* This program is free software; you can redistribute it and/or
	12	* modify it under the terms of the GNU General Public License
	13	* version 2 as published by the Free Software Foundation.
	14	*
	15	* This program is distributed in the hope that it will be useful, but
	16	* WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	* General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	23	* 02110-1301 USA
	24	*/
	25
	26	#include <linux/kernel.h>
	27	#include <linux/net.h>
	28	#include <linux/netdevice.h>
	29	#include <linux/phonet.h>
421d20a3	30	#include <linux/proc_fs.h>
f5bb1c55	31	#include <linux/if_arp.h>
f8ff6028	32	#include <net/sock.h>
9a3b7a42	33	#include <net/netns/generic.h>
f8ff6028 RDC	34	#include <net/phonet/pn_dev.h>
f8ff6028 RDC	35
55748ac0	36	struct phonet_routes {
88880135	37	struct mutex lock;
55748ac0 RDC	38	struct net_device *table[64];
	39	};
	40
9a3b7a42	41	struct phonet_net {
9a3b7a42	42	struct phonet_device_list pndevs;
55748ac0	43	struct phonet_routes routes;
f8ff6028 RDC	44	};
f8ff6028 RDC	45
f99189b1	46	int phonet_net_id __read_mostly;
9a3b7a42	47
	48	struct phonet_device_list phonet_device_list(struct net net)
	49	{
	50	struct phonet_net *pnn = net_generic(net, phonet_net_id);
	51	return &pnn->pndevs;
	52	}
	53
f8ff6028 RDC	54	/* Allocate new Phonet device. */
	55	static struct phonet_device __phonet_device_alloc(struct net_device dev)
	56	{
9a3b7a42	57	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
f8ff6028 RDC	58	struct phonet_device pnd = kmalloc(sizeof(pnd), GFP_ATOMIC);
	59	if (pnd == NULL)
	60	return NULL;
	61	pnd->netdev = dev;
	62	bitmap_zero(pnd->addrs, 64);
	63
eeb74a9d RDC	64	BUG_ON(!mutex_is_locked(&pndevs->lock));
eeb74a9d RDC	65	list_add_rcu(&pnd->list, &pndevs->list);
f8ff6028 RDC	66	return pnd;
	67	}
	68
	69	static struct phonet_device __phonet_get(struct net_device dev)
	70	{
9a3b7a42	71	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
f8ff6028 RDC	72	struct phonet_device *pnd;
f8ff6028 RDC	73
eeb74a9d	74	BUG_ON(!mutex_is_locked(&pndevs->lock));
9a3b7a42	75	list_for_each_entry(pnd, &pndevs->list, list) {
f8ff6028 RDC	76	if (pnd->netdev == dev)
	77	return pnd;
	78	}
	79	return NULL;
	80	}
	81
eeb74a9d RDC	82	static struct phonet_device __phonet_get_rcu(struct net_device dev)
	83	{
	84	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
	85	struct phonet_device *pnd;
	86
	87	list_for_each_entry_rcu(pnd, &pndevs->list, list) {
	88	if (pnd->netdev == dev)
	89	return pnd;
	90	}
	91	return NULL;
	92	}
	93
2be6fa4c	94	static void phonet_device_destroy(struct net_device *dev)
f8ff6028	95	{
2be6fa4c RDC	96	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
	97	struct phonet_device *pnd;
	98
	99	ASSERT_RTNL();
	100
eeb74a9d	101	mutex_lock(&pndevs->lock);
2be6fa4c RDC	102	pnd = __phonet_get(dev);
2be6fa4c RDC	103	if (pnd)
eeb74a9d RDC	104	list_del_rcu(&pnd->list);
eeb74a9d RDC	105	mutex_unlock(&pndevs->lock);
2be6fa4c RDC	106
	107	if (pnd) {
	108	u8 addr;
	109
a1ca14ac	110	for_each_set_bit(addr, pnd->addrs, 64)
2be6fa4c RDC	111	phonet_address_notify(RTM_DELADDR, dev, addr);
	112	kfree(pnd);
	113	}
f8ff6028 RDC	114	}
	115
	116	struct net_device phonet_device_get(struct net net)
	117	{
9a3b7a42	118	struct phonet_device_list *pndevs = phonet_device_list(net);
f8ff6028	119	struct phonet_device *pnd;
59e57f44	120	struct net_device *dev = NULL;
f8ff6028	121
eeb74a9d RDC	122	rcu_read_lock();
eeb74a9d RDC	123	list_for_each_entry_rcu(pnd, &pndevs->list, list) {
f8ff6028 RDC	124	dev = pnd->netdev;
	125	BUG_ON(!dev);
	126
9a3b7a42	127	if ((dev->reg_state == NETREG_REGISTERED) &&
f8ff6028 RDC	128	((pnd->netdev->flags & IFF_UP)) == IFF_UP)
	129	break;
	130	dev = NULL;
	131	}
	132	if (dev)
	133	dev_hold(dev);
eeb74a9d	134	rcu_read_unlock();
f8ff6028 RDC	135	return dev;
	136	}
	137
	138	int phonet_address_add(struct net_device *dev, u8 addr)
	139	{
9a3b7a42	140	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
f8ff6028 RDC	141	struct phonet_device *pnd;
	142	int err = 0;
	143
eeb74a9d	144	mutex_lock(&pndevs->lock);
f8ff6028 RDC	145	/* Find or create Phonet-specific device data */
	146	pnd = __phonet_get(dev);
	147	if (pnd == NULL)
	148	pnd = __phonet_device_alloc(dev);
	149	if (unlikely(pnd == NULL))
	150	err = -ENOMEM;
	151	else if (test_and_set_bit(addr >> 2, pnd->addrs))
	152	err = -EEXIST;
eeb74a9d	153	mutex_unlock(&pndevs->lock);
f8ff6028 RDC	154	return err;
	155	}
	156
	157	int phonet_address_del(struct net_device *dev, u8 addr)
	158	{
9a3b7a42	159	struct phonet_device_list *pndevs = phonet_device_list(dev_net(dev));
f8ff6028 RDC	160	struct phonet_device *pnd;
	161	int err = 0;
	162
eeb74a9d	163	mutex_lock(&pndevs->lock);
f8ff6028	164	pnd = __phonet_get(dev);
eeb74a9d	165	if (!pnd \|\| !test_and_clear_bit(addr >> 2, pnd->addrs)) {
f8ff6028	166	err = -EADDRNOTAVAIL;
eeb74a9d RDC	167	pnd = NULL;
	168	} else if (bitmap_empty(pnd->addrs, 64))
	169	list_del_rcu(&pnd->list);
	170	else
	171	pnd = NULL;
	172	mutex_unlock(&pndevs->lock);
	173
	174	if (pnd) {
	175	synchronize_rcu();
2be6fa4c RDC	176	kfree(pnd);
2be6fa4c RDC	177	}
f8ff6028 RDC	178	return err;
	179	}
	180
	181	/* Gets a source address toward a destination, through a interface. */
55748ac0	182	u8 phonet_address_get(struct net_device *dev, u8 daddr)
f8ff6028 RDC	183	{
f8ff6028 RDC	184	struct phonet_device *pnd;
55748ac0	185	u8 saddr;
f8ff6028	186
eeb74a9d RDC	187	rcu_read_lock();
eeb74a9d RDC	188	pnd = __phonet_get_rcu(dev);
f8ff6028 RDC	189	if (pnd) {
	190	BUG_ON(bitmap_empty(pnd->addrs, 64));
	191
	192	/* Use same source address as destination, if possible */
55748ac0 RDC	193	if (test_bit(daddr >> 2, pnd->addrs))
	194	saddr = daddr;
	195	else
	196	saddr = find_first_bit(pnd->addrs, 64) << 2;
f8ff6028	197	} else
55748ac0	198	saddr = PN_NO_ADDR;
eeb74a9d	199	rcu_read_unlock();
55748ac0 RDC	200
	201	if (saddr == PN_NO_ADDR) {
	202	/* Fallback to another device */
	203	struct net_device *def_dev;
	204
	205	def_dev = phonet_device_get(dev_net(dev));
	206	if (def_dev) {
	207	if (def_dev != dev)
	208	saddr = phonet_address_get(def_dev, daddr);
	209	dev_put(def_dev);
	210	}
	211	}
	212	return saddr;
f8ff6028 RDC	213	}
f8ff6028 RDC	214
52404881	215	int phonet_address_lookup(struct net *net, u8 addr)
f8ff6028	216	{
9a3b7a42	217	struct phonet_device_list *pndevs = phonet_device_list(net);
f8ff6028	218	struct phonet_device *pnd;
9a3b7a42	219	int err = -EADDRNOTAVAIL;
f8ff6028	220
eeb74a9d RDC	221	rcu_read_lock();
eeb74a9d RDC	222	list_for_each_entry_rcu(pnd, &pndevs->list, list) {
f8ff6028 RDC	223	/* Don't allow unregistering devices! */
	224	if ((pnd->netdev->reg_state != NETREG_REGISTERED) \|\|
	225	((pnd->netdev->flags & IFF_UP)) != IFF_UP)
	226	continue;
	227
	228	if (test_bit(addr >> 2, pnd->addrs)) {
9a3b7a42	229	err = 0;
9a3b7a42	230	goto found;
f8ff6028 RDC	231	}
f8ff6028 RDC	232	}
9a3b7a42	233	found:
eeb74a9d	234	rcu_read_unlock();
9a3b7a42	235	return err;
f8ff6028 RDC	236	}
f8ff6028 RDC	237
f5bb1c55 RDC	238	/* automatically configure a Phonet device, if supported */
	239	static int phonet_device_autoconf(struct net_device *dev)
	240	{
	241	struct if_phonet_req req;
	242	int ret;
	243
	244	if (!dev->netdev_ops->ndo_do_ioctl)
	245	return -EOPNOTSUPP;
	246
	247	ret = dev->netdev_ops->ndo_do_ioctl(dev, (struct ifreq *)&req,
	248	SIOCPNGAUTOCONF);
	249	if (ret < 0)
	250	return ret;
b11b5165 RDC	251
	252	ASSERT_RTNL();
	253	ret = phonet_address_add(dev, req.ifr_phonet_autoconf.device);
	254	if (ret)
	255	return ret;
	256	phonet_address_notify(RTM_NEWADDR, dev,
	257	req.ifr_phonet_autoconf.device);
	258	return 0;
f5bb1c55 RDC	259	}
f5bb1c55 RDC	260
f062f41d RDC	261	static void phonet_route_autodel(struct net_device *dev)
	262	{
	263	struct phonet_net *pnn = net_generic(dev_net(dev), phonet_net_id);
	264	unsigned i;
	265	DECLARE_BITMAP(deleted, 64);
	266
	267	/* Remove left-over Phonet routes */
	268	bitmap_zero(deleted, 64);
88880135	269	mutex_lock(&pnn->routes.lock);
f062f41d RDC	270	for (i = 0; i < 64; i++)
f062f41d RDC	271	if (dev == pnn->routes.table[i]) {
88880135	272	rcu_assign_pointer(pnn->routes.table[i], NULL);
f062f41d	273	set_bit(i, deleted);
f062f41d	274	}
88880135 RDC	275	mutex_unlock(&pnn->routes.lock);
	276
	277	if (bitmap_empty(deleted, 64))
	278	return; /* short-circuit RCU */
	279	synchronize_rcu();
f062f41d	280	for (i = find_first_bit(deleted, 64); i < 64;
88880135	281	i = find_next_bit(deleted, 64, i + 1)) {
f062f41d	282	rtm_phonet_notify(RTM_DELROUTE, dev, i);
88880135 RDC	283	dev_put(dev);
88880135 RDC	284	}
f062f41d RDC	285	}
f062f41d RDC	286
f8ff6028 RDC	287	/* notify Phonet of device events */
	288	static int phonet_device_notify(struct notifier_block *me, unsigned long what,
	289	void *arg)
	290	{
	291	struct net_device *dev = arg;
	292
f5bb1c55 RDC	293	switch (what) {
	294	case NETDEV_REGISTER:
	295	if (dev->type == ARPHRD_PHONET)
	296	phonet_device_autoconf(dev);
	297	break;
	298	case NETDEV_UNREGISTER:
2be6fa4c	299	phonet_device_destroy(dev);
f062f41d	300	phonet_route_autodel(dev);
f5bb1c55 RDC	301	break;
f5bb1c55 RDC	302	}
f8ff6028 RDC	303	return 0;
	304
	305	}
	306
	307	static struct notifier_block phonet_device_notifier = {
	308	.notifier_call = phonet_device_notify,
	309	.priority = 0,
	310	};
	311
9a3b7a42	312	/* Per-namespace Phonet devices handling */
2c8c1e72	313	static int __net_init phonet_init_net(struct net *net)
9a3b7a42	314	{
d2b3eb63	315	struct phonet_net *pnn = net_generic(net, phonet_net_id);
9a3b7a42	316
d2b3eb63	317	if (!proc_net_fops_create(net, "phonet", 0, &pn_sock_seq_fops))
c1dc13e9	318	return -ENOMEM;
c1dc13e9	319
9a3b7a42	320	INIT_LIST_HEAD(&pnn->pndevs.list);
eeb74a9d	321	mutex_init(&pnn->pndevs.lock);
88880135	322	mutex_init(&pnn->routes.lock);
9a3b7a42	323	return 0;
	324	}
	325
2c8c1e72	326	static void __net_exit phonet_exit_net(struct net *net)
9a3b7a42	327	{
9a3b7a42	328	struct phonet_net *pnn = net_generic(net, phonet_net_id);
2be6fa4c	329	struct net_device *dev;
f062f41d	330	unsigned i;
9a3b7a42	331
2be6fa4c RDC	332	rtnl_lock();
	333	for_each_netdev(net, dev)
	334	phonet_device_destroy(dev);
f062f41d RDC	335
	336	for (i = 0; i < 64; i++) {
	337	dev = pnn->routes.table[i];
	338	if (dev) {
	339	rtm_phonet_notify(RTM_DELROUTE, dev, i);
	340	dev_put(dev);
	341	}
	342	}
2be6fa4c	343	rtnl_unlock();
c1dc13e9 RDC	344
c1dc13e9 RDC	345	proc_net_remove(net, "phonet");
9a3b7a42	346	}
	347
	348	static struct pernet_operations phonet_net_ops = {
	349	.init = phonet_init_net,
	350	.exit = phonet_exit_net,
d2b3eb63 EB	351	.id = &phonet_net_id,
d2b3eb63 EB	352	.size = sizeof(struct phonet_net),
9a3b7a42	353	};
9a3b7a42	354
f8ff6028	355	/* Initialize Phonet devices list */
76e02cf6	356	int __init phonet_device_init(void)
f8ff6028	357	{
d2b3eb63	358	int err = register_pernet_device(&phonet_net_ops);
9a3b7a42	359	if (err)
9a3b7a42	360	return err;
660f706d	361
f8ff6028	362	register_netdevice_notifier(&phonet_device_notifier);
660f706d	363	err = phonet_netlink_register();
	364	if (err)
	365	phonet_device_exit();
	366	return err;
f8ff6028 RDC	367	}
	368
	369	void phonet_device_exit(void)
	370	{
f8ff6028	371	rtnl_unregister_all(PF_PHONET);
6530e0fe	372	unregister_netdevice_notifier(&phonet_device_notifier);
d2b3eb63	373	unregister_pernet_device(&phonet_net_ops);
f8ff6028	374	}
55748ac0 RDC	375
	376	int phonet_route_add(struct net_device *dev, u8 daddr)
	377	{
	378	struct phonet_net *pnn = net_generic(dev_net(dev), phonet_net_id);
	379	struct phonet_routes *routes = &pnn->routes;
	380	int err = -EEXIST;
	381
	382	daddr = daddr >> 2;
88880135	383	mutex_lock(&routes->lock);
55748ac0	384	if (routes->table[daddr] == NULL) {
88880135	385	rcu_assign_pointer(routes->table[daddr], dev);
55748ac0 RDC	386	dev_hold(dev);
	387	err = 0;
	388	}
88880135	389	mutex_unlock(&routes->lock);
55748ac0 RDC	390	return err;
	391	}
	392
	393	int phonet_route_del(struct net_device *dev, u8 daddr)
	394	{
	395	struct phonet_net *pnn = net_generic(dev_net(dev), phonet_net_id);
	396	struct phonet_routes *routes = &pnn->routes;
55748ac0 RDC	397
55748ac0 RDC	398	daddr = daddr >> 2;
88880135 RDC	399	mutex_lock(&routes->lock);
	400	if (dev == routes->table[daddr])
	401	rcu_assign_pointer(routes->table[daddr], NULL);
	402	else
	403	dev = NULL;
	404	mutex_unlock(&routes->lock);
	405
	406	if (!dev)
	407	return -ENOENT;
	408	synchronize_rcu();
	409	dev_put(dev);
	410	return 0;
55748ac0 RDC	411	}
	412
	413	struct net_device phonet_route_get(struct net net, u8 daddr)
	414	{
	415	struct phonet_net *pnn = net_generic(net, phonet_net_id);
	416	struct phonet_routes *routes = &pnn->routes;
	417	struct net_device *dev;
	418
	419	ASSERT_RTNL(); /* no need to hold the device */
	420
	421	daddr >>= 2;
88880135 RDC	422	rcu_read_lock();
	423	dev = rcu_dereference(routes->table[daddr]);
	424	rcu_read_unlock();
55748ac0 RDC	425	return dev;
	426	}
	427
	428	struct net_device phonet_route_output(struct net net, u8 daddr)
	429	{
	430	struct phonet_net *pnn = net_generic(net, phonet_net_id);
	431	struct phonet_routes *routes = &pnn->routes;
	432	struct net_device *dev;
	433
88880135 RDC	434	daddr >>= 2;
	435	rcu_read_lock();
	436	dev = rcu_dereference(routes->table[daddr]);
55748ac0 RDC	437	if (dev)
55748ac0 RDC	438	dev_hold(dev);
88880135	439	rcu_read_unlock();
55748ac0 RDC	440
	441	if (!dev)
	442	dev = phonet_device_get(net); /* Default route */
	443	return dev;
	444	}