2014-02-28 06:32:48 +00:00
|
|
|
/* Copyright 2011, Siemens AG
|
2011-08-25 02:34:42 +00:00
|
|
|
* written by Alexander Smirnov <alex.bluesman.smirnov@gmail.com>
|
|
|
|
*/
|
|
|
|
|
2014-02-28 06:32:48 +00:00
|
|
|
/* Based on patches from Jon Smirl <jonsmirl@gmail.com>
|
2011-08-25 02:34:42 +00:00
|
|
|
* Copyright (c) 2011 Jon Smirl <jonsmirl@gmail.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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Jon's code is based on 6lowpan implementation for Contiki which is:
|
|
|
|
* Copyright (c) 2008, Swedish Institute of Computer Science.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. Neither the name of the Institute nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/netdevice.h>
|
2014-10-25 07:41:04 +00:00
|
|
|
#include <linux/ieee802154.h>
|
2022-02-03 23:12:40 +00:00
|
|
|
#include <linux/if_arp.h>
|
2015-01-04 16:10:56 +00:00
|
|
|
|
2011-08-25 02:34:42 +00:00
|
|
|
#include <net/ipv6.h>
|
|
|
|
|
2015-01-04 16:10:54 +00:00
|
|
|
#include "6lowpan_i.h"
|
2011-08-25 02:34:42 +00:00
|
|
|
|
2015-08-15 09:00:32 +00:00
|
|
|
static int open_count;
|
|
|
|
|
2017-08-25 14:21:43 +00:00
|
|
|
static const struct header_ops lowpan_header_ops = {
|
2011-08-25 02:34:42 +00:00
|
|
|
.create = lowpan_header_create,
|
|
|
|
};
|
|
|
|
|
2020-05-03 05:22:19 +00:00
|
|
|
static int lowpan_dev_init(struct net_device *ldev)
|
|
|
|
{
|
|
|
|
netdev_lockdep_set_classes(ldev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-02 12:21:17 +00:00
|
|
|
static int lowpan_open(struct net_device *dev)
|
|
|
|
{
|
|
|
|
if (!open_count)
|
|
|
|
lowpan_rx_init();
|
|
|
|
open_count++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int lowpan_stop(struct net_device *dev)
|
|
|
|
{
|
|
|
|
open_count--;
|
|
|
|
if (!open_count)
|
|
|
|
lowpan_rx_exit();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-07-05 09:27:37 +00:00
|
|
|
static int lowpan_neigh_construct(struct net_device *dev, struct neighbour *n)
|
2016-06-15 19:20:16 +00:00
|
|
|
{
|
|
|
|
struct lowpan_802154_neigh *neigh = lowpan_802154_neigh(neighbour_priv(n));
|
|
|
|
|
|
|
|
/* default no short_addr is available for a neighbour */
|
|
|
|
neigh->short_addr = cpu_to_le16(IEEE802154_ADDR_SHORT_UNSPEC);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-07-02 09:21:47 +00:00
|
|
|
static int lowpan_get_iflink(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
return lowpan_802154_dev(dev)->wdev->ifindex;
|
|
|
|
}
|
|
|
|
|
2011-08-25 02:34:42 +00:00
|
|
|
static const struct net_device_ops lowpan_netdev_ops = {
|
2020-05-03 05:22:19 +00:00
|
|
|
.ndo_init = lowpan_dev_init,
|
2011-08-25 02:34:42 +00:00
|
|
|
.ndo_start_xmit = lowpan_xmit,
|
2015-09-02 12:21:17 +00:00
|
|
|
.ndo_open = lowpan_open,
|
|
|
|
.ndo_stop = lowpan_stop,
|
2016-06-15 19:20:16 +00:00
|
|
|
.ndo_neigh_construct = lowpan_neigh_construct,
|
2018-07-02 09:21:47 +00:00
|
|
|
.ndo_get_iflink = lowpan_get_iflink,
|
2011-08-25 02:34:42 +00:00
|
|
|
};
|
|
|
|
|
2015-09-02 12:21:16 +00:00
|
|
|
static void lowpan_setup(struct net_device *ldev)
|
2011-08-25 02:34:42 +00:00
|
|
|
{
|
2015-09-02 12:21:16 +00:00
|
|
|
memset(ldev->broadcast, 0xff, IEEE802154_ADDR_LEN);
|
2015-09-18 09:30:43 +00:00
|
|
|
/* We need an ipv6hdr as minimum len when calling xmit */
|
|
|
|
ldev->hard_header_len = sizeof(struct ipv6hdr);
|
2015-09-02 12:21:16 +00:00
|
|
|
ldev->flags = IFF_BROADCAST | IFF_MULTICAST;
|
2018-02-12 03:50:46 +00:00
|
|
|
ldev->priv_flags |= IFF_NO_QUEUE;
|
2015-09-02 12:21:16 +00:00
|
|
|
|
|
|
|
ldev->netdev_ops = &lowpan_netdev_ops;
|
|
|
|
ldev->header_ops = &lowpan_header_ops;
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-08 16:52:56 +00:00
|
|
|
ldev->needs_free_netdev = true;
|
2015-09-02 12:21:16 +00:00
|
|
|
ldev->features |= NETIF_F_NETNS_LOCAL;
|
2011-08-25 02:34:42 +00:00
|
|
|
}
|
|
|
|
|
2017-06-25 21:56:01 +00:00
|
|
|
static int lowpan_validate(struct nlattr *tb[], struct nlattr *data[],
|
|
|
|
struct netlink_ext_ack *extack)
|
2011-08-25 02:34:42 +00:00
|
|
|
{
|
|
|
|
if (tb[IFLA_ADDRESS]) {
|
|
|
|
if (nla_len(tb[IFLA_ADDRESS]) != IEEE802154_ADDR_LEN)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-02 12:21:16 +00:00
|
|
|
static int lowpan_newlink(struct net *src_net, struct net_device *ldev,
|
2017-06-25 21:55:59 +00:00
|
|
|
struct nlattr *tb[], struct nlattr *data[],
|
|
|
|
struct netlink_ext_ack *extack)
|
2011-08-25 02:34:42 +00:00
|
|
|
{
|
2015-09-02 12:21:16 +00:00
|
|
|
struct net_device *wdev;
|
2014-10-13 08:33:06 +00:00
|
|
|
int ret;
|
2011-08-25 02:34:42 +00:00
|
|
|
|
2014-10-13 08:33:07 +00:00
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2012-06-25 03:49:03 +00:00
|
|
|
pr_debug("adding new link\n");
|
2011-08-25 02:34:42 +00:00
|
|
|
|
2016-06-18 08:45:35 +00:00
|
|
|
if (!tb[IFLA_LINK])
|
2011-08-25 02:34:42 +00:00
|
|
|
return -EINVAL;
|
2015-09-02 12:21:16 +00:00
|
|
|
/* find and hold wpan device */
|
|
|
|
wdev = dev_get_by_index(dev_net(ldev), nla_get_u32(tb[IFLA_LINK]));
|
|
|
|
if (!wdev)
|
2011-08-25 02:34:42 +00:00
|
|
|
return -ENODEV;
|
2015-09-02 12:21:16 +00:00
|
|
|
if (wdev->type != ARPHRD_IEEE802154) {
|
|
|
|
dev_put(wdev);
|
2013-10-06 03:15:18 +00:00
|
|
|
return -EINVAL;
|
2013-11-07 07:44:45 +00:00
|
|
|
}
|
2011-08-25 02:34:42 +00:00
|
|
|
|
2015-09-02 12:21:16 +00:00
|
|
|
if (wdev->ieee802154_ptr->lowpan_dev) {
|
|
|
|
dev_put(wdev);
|
2015-08-10 19:15:53 +00:00
|
|
|
return -EBUSY;
|
2011-08-30 03:51:09 +00:00
|
|
|
}
|
2011-08-25 02:34:42 +00:00
|
|
|
|
2016-04-11 09:04:18 +00:00
|
|
|
lowpan_802154_dev(ldev)->wdev = wdev;
|
2014-11-25 04:34:57 +00:00
|
|
|
/* Set the lowpan hardware address to the wpan hardware address. */
|
2021-10-19 16:36:06 +00:00
|
|
|
__dev_addr_set(ldev, wdev->dev_addr, IEEE802154_ADDR_LEN);
|
2015-09-18 09:30:43 +00:00
|
|
|
/* We need headroom for possible wpan_dev_hard_header call and tailroom
|
|
|
|
* for encryption/fcs handling. The lowpan interface will replace
|
|
|
|
* the IPv6 header with 6LoWPAN header. At worst case the 6LoWPAN
|
|
|
|
* header has LOWPAN_IPHC_MAX_HEADER_LEN more bytes than the IPv6
|
|
|
|
* header.
|
|
|
|
*/
|
|
|
|
ldev->needed_headroom = LOWPAN_IPHC_MAX_HEADER_LEN +
|
|
|
|
wdev->needed_headroom;
|
|
|
|
ldev->needed_tailroom = wdev->needed_tailroom;
|
2013-10-06 03:15:19 +00:00
|
|
|
|
2016-06-15 19:20:16 +00:00
|
|
|
ldev->neigh_priv_len = sizeof(struct lowpan_802154_neigh);
|
|
|
|
|
2015-12-09 21:46:29 +00:00
|
|
|
ret = lowpan_register_netdevice(ldev, LOWPAN_LLTYPE_IEEE802154);
|
2015-08-15 09:00:32 +00:00
|
|
|
if (ret < 0) {
|
2015-09-02 12:21:16 +00:00
|
|
|
dev_put(wdev);
|
2015-08-15 09:00:32 +00:00
|
|
|
return ret;
|
2014-10-13 08:33:06 +00:00
|
|
|
}
|
2011-08-25 02:34:42 +00:00
|
|
|
|
2015-09-02 12:21:16 +00:00
|
|
|
wdev->ieee802154_ptr->lowpan_dev = ldev;
|
2015-08-15 09:00:32 +00:00
|
|
|
return 0;
|
2011-08-25 02:34:42 +00:00
|
|
|
}
|
|
|
|
|
2015-09-02 12:21:16 +00:00
|
|
|
static void lowpan_dellink(struct net_device *ldev, struct list_head *head)
|
2011-08-25 02:34:42 +00:00
|
|
|
{
|
2016-04-11 09:04:18 +00:00
|
|
|
struct net_device *wdev = lowpan_802154_dev(ldev)->wdev;
|
2011-08-25 02:34:42 +00:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2015-09-02 12:21:16 +00:00
|
|
|
wdev->ieee802154_ptr->lowpan_dev = NULL;
|
2015-12-09 21:46:29 +00:00
|
|
|
lowpan_unregister_netdevice(ldev);
|
2015-09-02 12:21:16 +00:00
|
|
|
dev_put(wdev);
|
2011-08-25 02:34:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct rtnl_link_ops lowpan_link_ops __read_mostly = {
|
|
|
|
.kind = "lowpan",
|
2016-04-11 09:04:18 +00:00
|
|
|
.priv_size = LOWPAN_PRIV_SIZE(sizeof(struct lowpan_802154_dev)),
|
2011-08-25 02:34:42 +00:00
|
|
|
.setup = lowpan_setup,
|
|
|
|
.newlink = lowpan_newlink,
|
|
|
|
.dellink = lowpan_dellink,
|
|
|
|
.validate = lowpan_validate,
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline int __init lowpan_netlink_init(void)
|
|
|
|
{
|
|
|
|
return rtnl_link_register(&lowpan_link_ops);
|
|
|
|
}
|
|
|
|
|
2013-02-06 20:54:38 +00:00
|
|
|
static inline void lowpan_netlink_fini(void)
|
2011-08-25 02:34:42 +00:00
|
|
|
{
|
|
|
|
rtnl_link_unregister(&lowpan_link_ops);
|
|
|
|
}
|
|
|
|
|
2012-09-01 05:57:07 +00:00
|
|
|
static int lowpan_device_event(struct notifier_block *unused,
|
2013-05-28 01:30:21 +00:00
|
|
|
unsigned long event, void *ptr)
|
2012-09-01 05:57:07 +00:00
|
|
|
{
|
2018-03-05 16:51:03 +00:00
|
|
|
struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
|
|
|
|
struct wpan_dev *wpan_dev;
|
2012-09-01 05:57:07 +00:00
|
|
|
|
2018-03-05 16:51:03 +00:00
|
|
|
if (ndev->type != ARPHRD_IEEE802154)
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
wpan_dev = ndev->ieee802154_ptr;
|
|
|
|
if (!wpan_dev)
|
2016-02-22 08:13:55 +00:00
|
|
|
return NOTIFY_DONE;
|
2012-09-01 05:57:07 +00:00
|
|
|
|
2015-08-10 19:15:53 +00:00
|
|
|
switch (event) {
|
|
|
|
case NETDEV_UNREGISTER:
|
|
|
|
/* Check if wpan interface is unregistered that we
|
|
|
|
* also delete possible lowpan interfaces which belongs
|
|
|
|
* to the wpan interface.
|
|
|
|
*/
|
2018-03-05 16:51:03 +00:00
|
|
|
if (wpan_dev->lowpan_dev)
|
|
|
|
lowpan_dellink(wpan_dev->lowpan_dev, NULL);
|
2015-08-10 19:15:53 +00:00
|
|
|
break;
|
|
|
|
default:
|
2016-02-22 08:13:55 +00:00
|
|
|
return NOTIFY_DONE;
|
2012-09-18 07:10:43 +00:00
|
|
|
}
|
2012-09-01 05:57:07 +00:00
|
|
|
|
2016-02-22 08:13:55 +00:00
|
|
|
return NOTIFY_OK;
|
2012-09-01 05:57:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block lowpan_dev_notifier = {
|
|
|
|
.notifier_call = lowpan_device_event,
|
|
|
|
};
|
|
|
|
|
2011-08-25 02:34:42 +00:00
|
|
|
static int __init lowpan_init_module(void)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
|
2014-02-28 06:32:50 +00:00
|
|
|
err = lowpan_net_frag_init();
|
2011-08-25 02:34:42 +00:00
|
|
|
if (err < 0)
|
|
|
|
goto out;
|
|
|
|
|
2014-02-28 06:32:50 +00:00
|
|
|
err = lowpan_netlink_init();
|
|
|
|
if (err < 0)
|
|
|
|
goto out_frag;
|
|
|
|
|
2012-09-01 05:57:07 +00:00
|
|
|
err = register_netdevice_notifier(&lowpan_dev_notifier);
|
2014-02-28 06:32:50 +00:00
|
|
|
if (err < 0)
|
|
|
|
goto out_pack;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_pack:
|
|
|
|
lowpan_netlink_fini();
|
|
|
|
out_frag:
|
|
|
|
lowpan_net_frag_exit();
|
2011-08-25 02:34:42 +00:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit lowpan_cleanup_module(void)
|
|
|
|
{
|
|
|
|
lowpan_netlink_fini();
|
|
|
|
|
2014-02-28 06:32:50 +00:00
|
|
|
lowpan_net_frag_exit();
|
2012-09-01 05:57:07 +00:00
|
|
|
|
2014-02-28 06:32:50 +00:00
|
|
|
unregister_netdevice_notifier(&lowpan_dev_notifier);
|
2011-08-25 02:34:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(lowpan_init_module);
|
|
|
|
module_exit(lowpan_cleanup_module);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_ALIAS_RTNL_LINK("lowpan");
|