drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c - linux/torvalds/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /* Copyright (c) 2013-2018, The Linux Foundation. All rights reserved.
  *
  * RMNET configuration engine
  */

 #include <net/sock.h>
 #include <linux/module.h>
 #include <linux/netlink.h>
 #include <linux/netdevice.h>
 #include "rmnet_config.h"
 #include "rmnet_handlers.h"
 #include "rmnet_vnd.h"
 #include "rmnet_private.h"

 /* Locking scheme -
  * The shared resource which needs to be protected is realdev->rx_handler_data.
  * For the writer path, this is using rtnl_lock(). The writer paths are
  * rmnet_newlink(), rmnet_dellink() and rmnet_force_unassociate_device(). These
  * paths are already called with rtnl_lock() acquired in. There is also an
  * ASSERT_RTNL() to ensure that we are calling with rtnl acquired. For
  * dereference here, we will need to use rtnl_dereference(). Dev list writing
  * needs to happen with rtnl_lock() acquired for netdev_master_upper_dev_link().
  * For the reader path, the real_dev->rx_handler_data is called in the TX / RX
  * path. We only need rcu_read_lock() for these scenarios. In these cases,
  * the rcu_read_lock() is held in __dev_queue_xmit() and
  * netif_receive_skb_internal(), so readers need to use rcu_dereference_rtnl()
  * to get the relevant information. For dev list reading, we again acquire
  * rcu_read_lock() in rmnet_dellink() for netdev_master_upper_dev_get_rcu().
  * We also use unregister_netdevice_many() to free all rmnet devices in
  * rmnet_force_unassociate_device() so we dont lose the rtnl_lock() and free in
  * same context.
  */

 /* Local Definitions and Declarations */

 static const struct nla_policy rmnet_policy[IFLA_RMNET_MAX + 1] = {
 	[IFLA_RMNET_MUX_ID]	= { .type = NLA_U16 },
 	[IFLA_RMNET_FLAGS]	= { .len = sizeof(struct ifla_rmnet_flags) },
 };

 static int rmnet_is_real_dev_registered(const struct net_device *real_dev)
 {
 	return rcu_access_pointer(real_dev->rx_handler) == rmnet_rx_handler;
 }

 /* Needs rtnl lock */
 static struct rmnet_port*
 rmnet_get_port_rtnl(const struct net_device *real_dev)
 {
 	return rtnl_dereference(real_dev->rx_handler_data);
 }

 static int rmnet_unregister_real_device(struct net_device *real_dev,
 					struct rmnet_port *port)
 {
 	if (port->nr_rmnet_devs)
 		return -EINVAL;

 	netdev_rx_handler_unregister(real_dev);

 	kfree(port);

 	/* release reference on real_dev */
 	dev_put(real_dev);

 	netdev_dbg(real_dev, "Removed from rmnet\n");
 	return 0;
 }

 static int rmnet_register_real_device(struct net_device *real_dev)
 {
 	struct rmnet_port *port;
 	int rc, entry;

 	ASSERT_RTNL();

 	if (rmnet_is_real_dev_registered(real_dev))
 		return 0;

 	port = kzalloc(sizeof(*port), GFP_ATOMIC);
 	if (!port)
 		return -ENOMEM;

 	port->dev = real_dev;
 	rc = netdev_rx_handler_register(real_dev, rmnet_rx_handler, port);
 	if (rc) {
 		kfree(port);
 		return -EBUSY;
 	}

 	/* hold on to real dev for MAP data */
 	dev_hold(real_dev);

 	for (entry = 0; entry < RMNET_MAX_LOGICAL_EP; entry++)
 		INIT_HLIST_HEAD(&port->muxed_ep[entry]);

 	netdev_dbg(real_dev, "registered with rmnet\n");
 	return 0;
 }

 static void rmnet_unregister_bridge(struct net_device *dev,
 				    struct rmnet_port *port)
 {
 	struct rmnet_port *bridge_port;
 	struct net_device *bridge_dev;

 	if (port->rmnet_mode != RMNET_EPMODE_BRIDGE)
 		return;

 	/* bridge slave handling */
 	if (!port->nr_rmnet_devs) {
 		bridge_dev = port->bridge_ep;

 		bridge_port = rmnet_get_port_rtnl(bridge_dev);
 		bridge_port->bridge_ep = NULL;
 		bridge_port->rmnet_mode = RMNET_EPMODE_VND;
 	} else {
 		bridge_dev = port->bridge_ep;

 		bridge_port = rmnet_get_port_rtnl(bridge_dev);
 		rmnet_unregister_real_device(bridge_dev, bridge_port);
 	}
 }

 static int rmnet_newlink(struct net *src_net, struct net_device *dev,
 			 struct nlattr *tb[], struct nlattr *data[],
 			 struct netlink_ext_ack *extack)
 {
 	u32 data_format = RMNET_FLAGS_INGRESS_DEAGGREGATION;
 	struct net_device *real_dev;
 	int mode = RMNET_EPMODE_VND;
 	struct rmnet_endpoint *ep;
 	struct rmnet_port *port;
 	int err = 0;
 	u16 mux_id;

 	real_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
 	if (!real_dev || !dev)
 		return -ENODEV;

 	if (!data[IFLA_RMNET_MUX_ID])
 		return -EINVAL;

 	ep = kzalloc(sizeof(*ep), GFP_ATOMIC);
 	if (!ep)
 		return -ENOMEM;

 	mux_id = nla_get_u16(data[IFLA_RMNET_MUX_ID]);

 	err = rmnet_register_real_device(real_dev);
 	if (err)
 		goto err0;

 	port = rmnet_get_port_rtnl(real_dev);
 	err = rmnet_vnd_newlink(mux_id, dev, port, real_dev, ep);
 	if (err)
 		goto err1;

 	port->rmnet_mode = mode;

 	hlist_add_head_rcu(&ep->hlnode, &port->muxed_ep[mux_id]);

 	if (data[IFLA_RMNET_FLAGS]) {
 		struct ifla_rmnet_flags *flags;

 		flags = nla_data(data[IFLA_RMNET_FLAGS]);
 		data_format = flags->flags & flags->mask;
 	}

 	netdev_dbg(dev, "data format [0x%08X]\n", data_format);
 	port->data_format = data_format;

 	return 0;

 err1:
 	rmnet_unregister_real_device(real_dev, port);
 err0:
 	kfree(ep);
 	return err;
 }

 static void rmnet_dellink(struct net_device *dev, struct list_head *head)
 {
 	struct rmnet_priv *priv = netdev_priv(dev);
 	struct net_device *real_dev;
 	struct rmnet_endpoint *ep;
 	struct rmnet_port *port;
 	u8 mux_id;

 	real_dev = priv->real_dev;

 	if (!real_dev || !rmnet_is_real_dev_registered(real_dev))
 		return;

 	port = rmnet_get_port_rtnl(real_dev);

 	mux_id = rmnet_vnd_get_mux(dev);

 	ep = rmnet_get_endpoint(port, mux_id);
 	if (ep) {
 		hlist_del_init_rcu(&ep->hlnode);
 		rmnet_unregister_bridge(dev, port);
 		rmnet_vnd_dellink(mux_id, port, ep);
 		kfree(ep);
 	}
 	rmnet_unregister_real_device(real_dev, port);

 	unregister_netdevice_queue(dev, head);
 }

 static void rmnet_force_unassociate_device(struct net_device *dev)
 {
 	struct net_device *real_dev = dev;
 	struct hlist_node *tmp_ep;
 	struct rmnet_endpoint *ep;
 	struct rmnet_port *port;
 	unsigned long bkt_ep;
 	LIST_HEAD(list);

 	if (!rmnet_is_real_dev_registered(real_dev))
 		return;

 	ASSERT_RTNL();

 	port = rmnet_get_port_rtnl(dev);

 	rcu_read_lock();
 	rmnet_unregister_bridge(dev, port);

 	hash_for_each_safe(port->muxed_ep, bkt_ep, tmp_ep, ep, hlnode) {
 		unregister_netdevice_queue(ep->egress_dev, &list);
 		rmnet_vnd_dellink(ep->mux_id, port, ep);

 		hlist_del_init_rcu(&ep->hlnode);
 		kfree(ep);
 	}

 	rcu_read_unlock();
 	unregister_netdevice_many(&list);

 	rmnet_unregister_real_device(real_dev, port);
 }

 static int rmnet_config_notify_cb(struct notifier_block *nb,
 				  unsigned long event, void *data)
 {
 	struct net_device *dev = netdev_notifier_info_to_dev(data);

 	if (!dev)
 		return NOTIFY_DONE;

 	switch (event) {
 	case NETDEV_UNREGISTER:
 		netdev_dbg(dev, "Kernel unregister\n");
 		rmnet_force_unassociate_device(dev);
 		break;

 	default:
 		break;
 	}

 	return NOTIFY_DONE;
 }

 static struct notifier_block rmnet_dev_notifier __read_mostly = {
 	.notifier_call = rmnet_config_notify_cb,
 };

 static int rmnet_rtnl_validate(struct nlattr *tb[], struct nlattr *data[],
 			       struct netlink_ext_ack *extack)
 {
 	u16 mux_id;

 	if (!data || !data[IFLA_RMNET_MUX_ID])
 		return -EINVAL;

 	mux_id = nla_get_u16(data[IFLA_RMNET_MUX_ID]);
 	if (mux_id > (RMNET_MAX_LOGICAL_EP - 1))
 		return -ERANGE;

 	return 0;
 }

 static int rmnet_changelink(struct net_device *dev, struct nlattr *tb[],
 			    struct nlattr *data[],
 			    struct netlink_ext_ack *extack)
 {
 	struct rmnet_priv *priv = netdev_priv(dev);
 	struct net_device *real_dev;
 	struct rmnet_endpoint *ep;
 	struct rmnet_port *port;
 	u16 mux_id;

 	if (!dev)
 		return -ENODEV;

 	real_dev = __dev_get_by_index(dev_net(dev),
 				      nla_get_u32(tb[IFLA_LINK]));

 	if (!real_dev || !rmnet_is_real_dev_registered(real_dev))
 		return -ENODEV;

 	port = rmnet_get_port_rtnl(real_dev);

 	if (data[IFLA_RMNET_MUX_ID]) {
 		mux_id = nla_get_u16(data[IFLA_RMNET_MUX_ID]);
 		ep = rmnet_get_endpoint(port, priv->mux_id);
 		if (!ep)
 			return -ENODEV;

 		hlist_del_init_rcu(&ep->hlnode);
 		hlist_add_head_rcu(&ep->hlnode, &port->muxed_ep[mux_id]);

 		ep->mux_id = mux_id;
 		priv->mux_id = mux_id;
 	}

 	if (data[IFLA_RMNET_FLAGS]) {
 		struct ifla_rmnet_flags *flags;

 		flags = nla_data(data[IFLA_RMNET_FLAGS]);
 		port->data_format = flags->flags & flags->mask;
 	}

 	return 0;
 }

 static size_t rmnet_get_size(const struct net_device *dev)
 {
 	return
 		/* IFLA_RMNET_MUX_ID */
 		nla_total_size(2) +
 		/* IFLA_RMNET_FLAGS */
 		nla_total_size(sizeof(struct ifla_rmnet_flags));
 }

 static int rmnet_fill_info(struct sk_buff *skb, const struct net_device *dev)
 {
 	struct rmnet_priv *priv = netdev_priv(dev);
 	struct net_device *real_dev;
 	struct ifla_rmnet_flags f;
 	struct rmnet_port *port;

 	real_dev = priv->real_dev;

 	if (nla_put_u16(skb, IFLA_RMNET_MUX_ID, priv->mux_id))
 		goto nla_put_failure;

 	if (rmnet_is_real_dev_registered(real_dev)) {
 		port = rmnet_get_port_rtnl(real_dev);
 		f.flags = port->data_format;
 	} else {
 		f.flags = 0;
 	}

 	f.mask  = ~0;

 	if (nla_put(skb, IFLA_RMNET_FLAGS, sizeof(f), &f))
 		goto nla_put_failure;

 	return 0;

 nla_put_failure:
 	return -EMSGSIZE;
 }

 struct rtnl_link_ops rmnet_link_ops __read_mostly = {
 	.kind		= "rmnet",
 	.maxtype	= __IFLA_RMNET_MAX,
 	.priv_size	= sizeof(struct rmnet_priv),
 	.setup		= rmnet_vnd_setup,
 	.validate	= rmnet_rtnl_validate,
 	.newlink	= rmnet_newlink,
 	.dellink	= rmnet_dellink,
 	.get_size	= rmnet_get_size,
 	.changelink     = rmnet_changelink,
 	.policy		= rmnet_policy,
 	.fill_info	= rmnet_fill_info,
 };

 /* Needs either rcu_read_lock() or rtnl lock */
 struct rmnet_port *rmnet_get_port(struct net_device *real_dev)
 {
 	if (rmnet_is_real_dev_registered(real_dev))
 		return rcu_dereference_rtnl(real_dev->rx_handler_data);
 	else
 		return NULL;
 }

 struct rmnet_endpoint *rmnet_get_endpoint(struct rmnet_port *port, u8 mux_id)
 {
 	struct rmnet_endpoint *ep;

 	hlist_for_each_entry_rcu(ep, &port->muxed_ep[mux_id], hlnode) {
 		if (ep->mux_id == mux_id)
 			return ep;
 	}

 	return NULL;
 }

 int rmnet_add_bridge(struct net_device *rmnet_dev,
 		     struct net_device *slave_dev,
 		     struct netlink_ext_ack *extack)
 {
 	struct rmnet_priv *priv = netdev_priv(rmnet_dev);
 	struct net_device *real_dev = priv->real_dev;
 	struct rmnet_port *port, *slave_port;
 	int err;

 	port = rmnet_get_port(real_dev);

 	/* If there is more than one rmnet dev attached, its probably being
 	 * used for muxing. Skip the briding in that case
 	 */
 	if (port->nr_rmnet_devs > 1)
 		return -EINVAL;

 	if (rmnet_is_real_dev_registered(slave_dev))
 		return -EBUSY;

 	err = rmnet_register_real_device(slave_dev);
 	if (err)
 		return -EBUSY;

 	slave_port = rmnet_get_port(slave_dev);
 	slave_port->rmnet_mode = RMNET_EPMODE_BRIDGE;
 	slave_port->bridge_ep = real_dev;

 	port->rmnet_mode = RMNET_EPMODE_BRIDGE;
 	port->bridge_ep = slave_dev;

 	netdev_dbg(slave_dev, "registered with rmnet as slave\n");
 	return 0;
 }

 int rmnet_del_bridge(struct net_device *rmnet_dev,
 		     struct net_device *slave_dev)
 {
 	struct rmnet_priv *priv = netdev_priv(rmnet_dev);
 	struct net_device *real_dev = priv->real_dev;
 	struct rmnet_port *port, *slave_port;

 	port = rmnet_get_port(real_dev);
 	port->rmnet_mode = RMNET_EPMODE_VND;
 	port->bridge_ep = NULL;

 	slave_port = rmnet_get_port(slave_dev);
 	rmnet_unregister_real_device(slave_dev, slave_port);

 	netdev_dbg(slave_dev, "removed from rmnet as slave\n");
 	return 0;
 }

 /* Startup/Shutdown */

 static int __init rmnet_init(void)
 {
 	int rc;

 	rc = register_netdevice_notifier(&rmnet_dev_notifier);
 	if (rc != 0)
 		return rc;

 	rc = rtnl_link_register(&rmnet_link_ops);
 	if (rc != 0) {
 		unregister_netdevice_notifier(&rmnet_dev_notifier);
 		return rc;
 	}
 	return rc;
 }

 static void __exit rmnet_exit(void)
 {
 	unregister_netdevice_notifier(&rmnet_dev_notifier);
 	rtnl_link_unregister(&rmnet_link_ops);
 }

 module_init(rmnet_init)
 module_exit(rmnet_exit)
 MODULE_LICENSE("GPL v2");
	// SPDX-License-Identifier: GPL-2.0-only
	/* Copyright (c) 2013-2018, The Linux Foundation. All rights reserved.
	*
	* RMNET configuration engine
	*/

	#include <net/sock.h>
	#include <linux/module.h>
	#include <linux/netlink.h>
	#include <linux/netdevice.h>
	#include "rmnet_config.h"
	#include "rmnet_handlers.h"
	#include "rmnet_vnd.h"
	#include "rmnet_private.h"

	/* Locking scheme -
	* The shared resource which needs to be protected is realdev->rx_handler_data.
	* For the writer path, this is using rtnl_lock(). The writer paths are
	* rmnet_newlink(), rmnet_dellink() and rmnet_force_unassociate_device(). These
	* paths are already called with rtnl_lock() acquired in. There is also an
	* ASSERT_RTNL() to ensure that we are calling with rtnl acquired. For
	* dereference here, we will need to use rtnl_dereference(). Dev list writing
	* needs to happen with rtnl_lock() acquired for netdev_master_upper_dev_link().
	* For the reader path, the real_dev->rx_handler_data is called in the TX / RX
	* path. We only need rcu_read_lock() for these scenarios. In these cases,
	* the rcu_read_lock() is held in __dev_queue_xmit() and
	* netif_receive_skb_internal(), so readers need to use rcu_dereference_rtnl()
	* to get the relevant information. For dev list reading, we again acquire
	* rcu_read_lock() in rmnet_dellink() for netdev_master_upper_dev_get_rcu().
	* We also use unregister_netdevice_many() to free all rmnet devices in
	* rmnet_force_unassociate_device() so we dont lose the rtnl_lock() and free in
	* same context.
	*/

	/* Local Definitions and Declarations */

	static const struct nla_policy rmnet_policy[IFLA_RMNET_MAX + 1] = {
	[IFLA_RMNET_MUX_ID] = { .type = NLA_U16 },
	[IFLA_RMNET_FLAGS] = { .len = sizeof(struct ifla_rmnet_flags) },
	};

	static int rmnet_is_real_dev_registered(const struct net_device *real_dev)
	{
	return rcu_access_pointer(real_dev->rx_handler) == rmnet_rx_handler;
	}

	/* Needs rtnl lock */
	static struct rmnet_port*
	rmnet_get_port_rtnl(const struct net_device *real_dev)
	{
	return rtnl_dereference(real_dev->rx_handler_data);
	}

	static int rmnet_unregister_real_device(struct net_device *real_dev,
	struct rmnet_port *port)
	{
	if (port->nr_rmnet_devs)
	return -EINVAL;

	netdev_rx_handler_unregister(real_dev);

	kfree(port);

	/* release reference on real_dev */
	dev_put(real_dev);

	netdev_dbg(real_dev, "Removed from rmnet\n");
	return 0;
	}

	static int rmnet_register_real_device(struct net_device *real_dev)
	{
	struct rmnet_port *port;
	int rc, entry;

	ASSERT_RTNL();

	if (rmnet_is_real_dev_registered(real_dev))
	return 0;

	port = kzalloc(sizeof(*port), GFP_ATOMIC);
	if (!port)
	return -ENOMEM;

	port->dev = real_dev;
	rc = netdev_rx_handler_register(real_dev, rmnet_rx_handler, port);
	if (rc) {
	kfree(port);
	return -EBUSY;
	}

	/* hold on to real dev for MAP data */
	dev_hold(real_dev);

	for (entry = 0; entry < RMNET_MAX_LOGICAL_EP; entry++)
	INIT_HLIST_HEAD(&port->muxed_ep[entry]);

	netdev_dbg(real_dev, "registered with rmnet\n");
	return 0;
	}

	static void rmnet_unregister_bridge(struct net_device *dev,
	struct rmnet_port *port)
	{
	struct rmnet_port *bridge_port;
	struct net_device *bridge_dev;

	if (port->rmnet_mode != RMNET_EPMODE_BRIDGE)
	return;

	/* bridge slave handling */
	if (!port->nr_rmnet_devs) {
	bridge_dev = port->bridge_ep;

	bridge_port = rmnet_get_port_rtnl(bridge_dev);
	bridge_port->bridge_ep = NULL;
	bridge_port->rmnet_mode = RMNET_EPMODE_VND;
	} else {
	bridge_dev = port->bridge_ep;

	bridge_port = rmnet_get_port_rtnl(bridge_dev);
	rmnet_unregister_real_device(bridge_dev, bridge_port);
	}
	}

	static int rmnet_newlink(struct net src_net, struct net_device dev,
	struct nlattr tb[], struct nlattr data[],
	struct netlink_ext_ack *extack)
	{
	u32 data_format = RMNET_FLAGS_INGRESS_DEAGGREGATION;
	struct net_device *real_dev;
	int mode = RMNET_EPMODE_VND;
	struct rmnet_endpoint *ep;
	struct rmnet_port *port;
	int err = 0;
	u16 mux_id;

	real_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
	if (!real_dev \|\| !dev)
	return -ENODEV;

	if (!data[IFLA_RMNET_MUX_ID])
	return -EINVAL;

	ep = kzalloc(sizeof(*ep), GFP_ATOMIC);
	if (!ep)
	return -ENOMEM;

	mux_id = nla_get_u16(data[IFLA_RMNET_MUX_ID]);

	err = rmnet_register_real_device(real_dev);
	if (err)
	goto err0;

	port = rmnet_get_port_rtnl(real_dev);
	err = rmnet_vnd_newlink(mux_id, dev, port, real_dev, ep);
	if (err)
	goto err1;

	port->rmnet_mode = mode;

	hlist_add_head_rcu(&ep->hlnode, &port->muxed_ep[mux_id]);

	if (data[IFLA_RMNET_FLAGS]) {
	struct ifla_rmnet_flags *flags;

	flags = nla_data(data[IFLA_RMNET_FLAGS]);
	data_format = flags->flags & flags->mask;
	}

	netdev_dbg(dev, "data format [0x%08X]\n", data_format);
	port->data_format = data_format;

	return 0;

	err1:
	rmnet_unregister_real_device(real_dev, port);
	err0:
	kfree(ep);
	return err;
	}

	static void rmnet_dellink(struct net_device dev, struct list_head head)
	{
	struct rmnet_priv *priv = netdev_priv(dev);
	struct net_device *real_dev;
	struct rmnet_endpoint *ep;
	struct rmnet_port *port;
	u8 mux_id;

	real_dev = priv->real_dev;

	if (!real_dev \|\| !rmnet_is_real_dev_registered(real_dev))
	return;

	port = rmnet_get_port_rtnl(real_dev);

	mux_id = rmnet_vnd_get_mux(dev);

	ep = rmnet_get_endpoint(port, mux_id);
	if (ep) {
	hlist_del_init_rcu(&ep->hlnode);
	rmnet_unregister_bridge(dev, port);
	rmnet_vnd_dellink(mux_id, port, ep);
	kfree(ep);
	}
	rmnet_unregister_real_device(real_dev, port);

	unregister_netdevice_queue(dev, head);
	}

	static void rmnet_force_unassociate_device(struct net_device *dev)
	{
	struct net_device *real_dev = dev;
	struct hlist_node *tmp_ep;
	struct rmnet_endpoint *ep;
	struct rmnet_port *port;
	unsigned long bkt_ep;
	LIST_HEAD(list);

	if (!rmnet_is_real_dev_registered(real_dev))
	return;

	ASSERT_RTNL();

	port = rmnet_get_port_rtnl(dev);

	rcu_read_lock();
	rmnet_unregister_bridge(dev, port);

	hash_for_each_safe(port->muxed_ep, bkt_ep, tmp_ep, ep, hlnode) {
	unregister_netdevice_queue(ep->egress_dev, &list);
	rmnet_vnd_dellink(ep->mux_id, port, ep);

	hlist_del_init_rcu(&ep->hlnode);
	kfree(ep);
	}

	rcu_read_unlock();
	unregister_netdevice_many(&list);

	rmnet_unregister_real_device(real_dev, port);
	}

	static int rmnet_config_notify_cb(struct notifier_block *nb,
	unsigned long event, void *data)
	{
	struct net_device *dev = netdev_notifier_info_to_dev(data);

	if (!dev)
	return NOTIFY_DONE;

	switch (event) {
	case NETDEV_UNREGISTER:
	netdev_dbg(dev, "Kernel unregister\n");
	rmnet_force_unassociate_device(dev);
	break;

	default:
	break;
	}

	return NOTIFY_DONE;
	}

	static struct notifier_block rmnet_dev_notifier __read_mostly = {
	.notifier_call = rmnet_config_notify_cb,
	};

	static int rmnet_rtnl_validate(struct nlattr tb[], struct nlattr data[],
	struct netlink_ext_ack *extack)
	{
	u16 mux_id;

	if (!data \|\| !data[IFLA_RMNET_MUX_ID])
	return -EINVAL;

	mux_id = nla_get_u16(data[IFLA_RMNET_MUX_ID]);
	if (mux_id > (RMNET_MAX_LOGICAL_EP - 1))
	return -ERANGE;

	return 0;
	}

	static int rmnet_changelink(struct net_device dev, struct nlattr tb[],
	struct nlattr *data[],
	struct netlink_ext_ack *extack)
	{
	struct rmnet_priv *priv = netdev_priv(dev);
	struct net_device *real_dev;
	struct rmnet_endpoint *ep;
	struct rmnet_port *port;
	u16 mux_id;

	if (!dev)
	return -ENODEV;

	real_dev = __dev_get_by_index(dev_net(dev),
	nla_get_u32(tb[IFLA_LINK]));

	if (!real_dev \|\| !rmnet_is_real_dev_registered(real_dev))
	return -ENODEV;

	port = rmnet_get_port_rtnl(real_dev);

	if (data[IFLA_RMNET_MUX_ID]) {
	mux_id = nla_get_u16(data[IFLA_RMNET_MUX_ID]);
	ep = rmnet_get_endpoint(port, priv->mux_id);
	if (!ep)
	return -ENODEV;

	hlist_del_init_rcu(&ep->hlnode);
	hlist_add_head_rcu(&ep->hlnode, &port->muxed_ep[mux_id]);

	ep->mux_id = mux_id;
	priv->mux_id = mux_id;
	}

	if (data[IFLA_RMNET_FLAGS]) {
	struct ifla_rmnet_flags *flags;

	flags = nla_data(data[IFLA_RMNET_FLAGS]);
	port->data_format = flags->flags & flags->mask;
	}

	return 0;
	}

	static size_t rmnet_get_size(const struct net_device *dev)
	{
	return
	/* IFLA_RMNET_MUX_ID */
	nla_total_size(2) +
	/* IFLA_RMNET_FLAGS */
	nla_total_size(sizeof(struct ifla_rmnet_flags));
	}

	static int rmnet_fill_info(struct sk_buff skb, const struct net_device dev)
	{
	struct rmnet_priv *priv = netdev_priv(dev);
	struct net_device *real_dev;
	struct ifla_rmnet_flags f;
	struct rmnet_port *port;

	real_dev = priv->real_dev;

	if (nla_put_u16(skb, IFLA_RMNET_MUX_ID, priv->mux_id))
	goto nla_put_failure;

	if (rmnet_is_real_dev_registered(real_dev)) {
	port = rmnet_get_port_rtnl(real_dev);
	f.flags = port->data_format;
	} else {
	f.flags = 0;
	}

	f.mask = ~0;

	if (nla_put(skb, IFLA_RMNET_FLAGS, sizeof(f), &f))
	goto nla_put_failure;

	return 0;

	nla_put_failure:
	return -EMSGSIZE;
	}

	struct rtnl_link_ops rmnet_link_ops __read_mostly = {
	.kind = "rmnet",
	.maxtype = __IFLA_RMNET_MAX,
	.priv_size = sizeof(struct rmnet_priv),
	.setup = rmnet_vnd_setup,
	.validate = rmnet_rtnl_validate,
	.newlink = rmnet_newlink,
	.dellink = rmnet_dellink,
	.get_size = rmnet_get_size,
	.changelink = rmnet_changelink,
	.policy = rmnet_policy,
	.fill_info = rmnet_fill_info,
	};

	/* Needs either rcu_read_lock() or rtnl lock */
	struct rmnet_port rmnet_get_port(struct net_device real_dev)
	{
	if (rmnet_is_real_dev_registered(real_dev))
	return rcu_dereference_rtnl(real_dev->rx_handler_data);
	else
	return NULL;
	}

	struct rmnet_endpoint rmnet_get_endpoint(struct rmnet_port port, u8 mux_id)
	{
	struct rmnet_endpoint *ep;

	hlist_for_each_entry_rcu(ep, &port->muxed_ep[mux_id], hlnode) {
	if (ep->mux_id == mux_id)
	return ep;
	}

	return NULL;
	}

	int rmnet_add_bridge(struct net_device *rmnet_dev,
	struct net_device *slave_dev,
	struct netlink_ext_ack *extack)
	{
	struct rmnet_priv *priv = netdev_priv(rmnet_dev);
	struct net_device *real_dev = priv->real_dev;
	struct rmnet_port port, slave_port;
	int err;

	port = rmnet_get_port(real_dev);

	/* If there is more than one rmnet dev attached, its probably being
	* used for muxing. Skip the briding in that case
	*/
	if (port->nr_rmnet_devs > 1)
	return -EINVAL;

	if (rmnet_is_real_dev_registered(slave_dev))
	return -EBUSY;

	err = rmnet_register_real_device(slave_dev);
	if (err)
	return -EBUSY;

	slave_port = rmnet_get_port(slave_dev);
	slave_port->rmnet_mode = RMNET_EPMODE_BRIDGE;
	slave_port->bridge_ep = real_dev;

	port->rmnet_mode = RMNET_EPMODE_BRIDGE;
	port->bridge_ep = slave_dev;

	netdev_dbg(slave_dev, "registered with rmnet as slave\n");
	return 0;
	}

	int rmnet_del_bridge(struct net_device *rmnet_dev,
	struct net_device *slave_dev)
	{
	struct rmnet_priv *priv = netdev_priv(rmnet_dev);
	struct net_device *real_dev = priv->real_dev;
	struct rmnet_port port, slave_port;

	port = rmnet_get_port(real_dev);
	port->rmnet_mode = RMNET_EPMODE_VND;
	port->bridge_ep = NULL;

	slave_port = rmnet_get_port(slave_dev);
	rmnet_unregister_real_device(slave_dev, slave_port);

	netdev_dbg(slave_dev, "removed from rmnet as slave\n");
	return 0;
	}

	/* Startup/Shutdown */

	static int __init rmnet_init(void)
	{
	int rc;

	rc = register_netdevice_notifier(&rmnet_dev_notifier);
	if (rc != 0)
	return rc;

	rc = rtnl_link_register(&rmnet_link_ops);
	if (rc != 0) {
	unregister_netdevice_notifier(&rmnet_dev_notifier);
	return rc;
	}
	return rc;
	}

	static void __exit rmnet_exit(void)
	{
	unregister_netdevice_notifier(&rmnet_dev_notifier);
	rtnl_link_unregister(&rmnet_link_ops);
	}

	module_init(rmnet_init)
	module_exit(rmnet_exit)
	MODULE_LICENSE("GPL v2");