/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only 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.
 *
 * 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 */
#define RMNET_LOCAL_LOGICAL_ENDPOINT -1

struct rmnet_walk_data {
	struct net_device *real_dev;
	struct list_head *head;
	struct rmnet_real_dev_info *real_dev_info;
};

static int rmnet_is_real_dev_registered(const struct net_device *real_dev)
{
	rx_handler_func_t *rx_handler;

	rx_handler = rcu_dereference(real_dev->rx_handler);
	return (rx_handler == rmnet_rx_handler);
}

/* Needs either rcu_read_lock() or rtnl lock */
static struct rmnet_real_dev_info*
__rmnet_get_real_dev_info(const 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;
}

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

static struct rmnet_endpoint*
rmnet_get_endpoint(struct net_device *dev, int config_id)
{
	struct rmnet_real_dev_info *r;
	struct rmnet_endpoint *ep;

	if (!rmnet_is_real_dev_registered(dev)) {
		ep = rmnet_vnd_get_endpoint(dev);
	} else {
		r = __rmnet_get_real_dev_info(dev);

		if (!r)
			return NULL;

		if (config_id == RMNET_LOCAL_LOGICAL_ENDPOINT)
			ep = &r->local_ep;
		else
			ep = &r->muxed_ep[config_id];
	}

	return ep;
}

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

	kfree(r);

	netdev_rx_handler_unregister(real_dev);

	/* 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_real_dev_info *r;
	int rc;

	ASSERT_RTNL();

	if (rmnet_is_real_dev_registered(real_dev))
		return 0;

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

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

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

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

static int rmnet_set_ingress_data_format(struct net_device *dev, u32 idf)
{
	struct rmnet_real_dev_info *r;

	netdev_dbg(dev, "Ingress format 0x%08X\n", idf);

	r = __rmnet_get_real_dev_info(dev);

	r->ingress_data_format = idf;

	return 0;
}

static int rmnet_set_egress_data_format(struct net_device *dev, u32 edf,
					u16 agg_size, u16 agg_count)
{
	struct rmnet_real_dev_info *r;

	netdev_dbg(dev, "Egress format 0x%08X agg size %d cnt %d\n",
		   edf, agg_size, agg_count);

	r = __rmnet_get_real_dev_info(dev);

	r->egress_data_format = edf;

	return 0;
}

static int __rmnet_set_endpoint_config(struct net_device *dev, int config_id,
				       struct rmnet_endpoint *ep)
{
	struct rmnet_endpoint *dev_ep;

	dev_ep = rmnet_get_endpoint(dev, config_id);

	if (!dev_ep)
		return -EINVAL;

	memcpy(dev_ep, ep, sizeof(struct rmnet_endpoint));
	if (config_id == RMNET_LOCAL_LOGICAL_ENDPOINT)
		dev_ep->mux_id = 0;
	else
		dev_ep->mux_id = config_id;

	return 0;
}

static int rmnet_set_endpoint_config(struct net_device *dev,
				     int config_id, u8 rmnet_mode,
				     struct net_device *egress_dev)
{
	struct rmnet_endpoint ep;

	netdev_dbg(dev, "id %d mode %d dev %s\n",
		   config_id, rmnet_mode, egress_dev->name);

	if (config_id < RMNET_LOCAL_LOGICAL_ENDPOINT ||
	    config_id >= RMNET_MAX_LOGICAL_EP)
		return -EINVAL;

	/* This config is cleared on every set, so its ok to not
	 * clear it on a device delete.
	 */
	memset(&ep, 0, sizeof(struct rmnet_endpoint));
	ep.rmnet_mode = rmnet_mode;
	ep.egress_dev = egress_dev;

	return __rmnet_set_endpoint_config(dev, config_id, &ep);
}

static int rmnet_newlink(struct net *src_net, struct net_device *dev,
			 struct nlattr *tb[], struct nlattr *data[],
			 struct netlink_ext_ack *extack)
{
	int ingress_format = RMNET_INGRESS_FORMAT_DEMUXING |
			     RMNET_INGRESS_FORMAT_DEAGGREGATION |
			     RMNET_INGRESS_FORMAT_MAP;
	int egress_format = RMNET_EGRESS_FORMAT_MUXING |
			    RMNET_EGRESS_FORMAT_MAP;
	struct rmnet_real_dev_info *r;
	struct net_device *real_dev;
	int mode = RMNET_EPMODE_VND;
	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_VLAN_ID])
		return -EINVAL;

	mux_id = nla_get_u16(data[IFLA_VLAN_ID]);

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

	r = rmnet_get_real_dev_info_rtnl(real_dev);
	err = rmnet_vnd_newlink(mux_id, dev, r);
	if (err)
		goto err1;

	err = netdev_master_upper_dev_link(dev, real_dev, NULL, NULL);
	if (err)
		goto err2;

	rmnet_vnd_set_mux(dev, mux_id);
	rmnet_set_egress_data_format(real_dev, egress_format, 0, 0);
	rmnet_set_ingress_data_format(real_dev, ingress_format);
	rmnet_set_endpoint_config(real_dev, mux_id, mode, dev);
	rmnet_set_endpoint_config(dev, mux_id, mode, real_dev);
	return 0;

err2:
	rmnet_vnd_dellink(mux_id, r);
err1:
	rmnet_unregister_real_device(real_dev, r);
err0:
	return err;
}

static void rmnet_dellink(struct net_device *dev, struct list_head *head)
{
	struct rmnet_real_dev_info *r;
	struct net_device *real_dev;
	u8 mux_id;

	rcu_read_lock();
	real_dev = netdev_master_upper_dev_get_rcu(dev);
	rcu_read_unlock();

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

	r = rmnet_get_real_dev_info_rtnl(real_dev);

	mux_id = rmnet_vnd_get_mux(dev);
	rmnet_vnd_dellink(mux_id, r);
	netdev_upper_dev_unlink(dev, real_dev);
	rmnet_unregister_real_device(real_dev, r);

	unregister_netdevice_queue(dev, head);
}

static int rmnet_dev_walk_unreg(struct net_device *rmnet_dev, void *data)
{
	struct rmnet_walk_data *d = data;
	u8 mux_id;

	mux_id = rmnet_vnd_get_mux(rmnet_dev);

	rmnet_vnd_dellink(mux_id, d->real_dev_info);
	netdev_upper_dev_unlink(rmnet_dev, d->real_dev);
	unregister_netdevice_queue(rmnet_dev, d->head);

	return 0;
}

static void rmnet_force_unassociate_device(struct net_device *dev)
{
	struct net_device *real_dev = dev;
	struct rmnet_real_dev_info *r;
	struct rmnet_walk_data d;
	LIST_HEAD(list);

	if (!rmnet_is_real_dev_registered(real_dev))
		return;

	ASSERT_RTNL();

	d.real_dev = real_dev;
	d.head = &list;

	r = rmnet_get_real_dev_info_rtnl(dev);
	d.real_dev_info = r;

	rcu_read_lock();
	netdev_walk_all_lower_dev_rcu(real_dev, rmnet_dev_walk_unreg, &d);
	rcu_read_unlock();
	unregister_netdevice_many(&list);

	rmnet_unregister_real_device(real_dev, r);
}

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_VLAN_ID])
		return -EINVAL;

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

	return 0;
}

static size_t rmnet_get_size(const struct net_device *dev)
{
	return nla_total_size(2); /* IFLA_VLAN_ID */
}

struct rtnl_link_ops rmnet_link_ops __read_mostly = {
	.kind		= "rmnet",
	.maxtype	= __IFLA_VLAN_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,
};

struct rmnet_real_dev_info*
rmnet_get_real_dev_info(struct net_device *real_dev)
{
	return __rmnet_get_real_dev_info(real_dev);
}

/* 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");