[mirror_ubuntu-artful-kernel.git] / drivers / net / dummy.c

/* dummy.c: a dummy net driver

	The purpose of this driver is to provide a device to point a
	route through, but not to actually transmit packets.

	Why?  If you have a machine whose only connection is an occasional
	PPP/SLIP/PLIP link, you can only connect to your own hostname
	when the link is up.  Otherwise you have to use localhost.
	This isn't very consistent.

	One solution is to set up a dummy link using PPP/SLIP/PLIP,
	but this seems (to me) too much overhead for too little gain.
	This driver provides a small alternative. Thus you can do

	[when not running slip]
		ifconfig dummy slip.addr.ess.here up
	[to go to slip]
		ifconfig dummy down
		dip whatever

	This was written by looking at Donald Becker's skeleton driver
	and the loopback driver.  I then threw away anything that didn't
	apply!	Thanks to Alan Cox for the key clue on what to do with
	misguided packets.

			Nick Holloway, 27th May 1994
	[I tweaked this explanation a little but that's all]
			Alan Cox, 30th May 1994
*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/init.h>
#include <linux/moduleparam.h>
#include <linux/rtnetlink.h>
#include <net/rtnetlink.h>
#include <linux/u64_stats_sync.h>

#define DRV_NAME	"dummy"
#define DRV_VERSION	"1.0"

#undef pr_fmt
#define pr_fmt(fmt) DRV_NAME ": " fmt

static int numdummies = 1;
static int num_vfs;

struct vf_data_storage {
	u8	vf_mac[ETH_ALEN];
	u16	pf_vlan; /* When set, guest VLAN config not allowed. */
	u16	pf_qos;
	__be16	vlan_proto;
	u16	min_tx_rate;
	u16	max_tx_rate;
	u8	spoofchk_enabled;
	bool	rss_query_enabled;
	u8	trusted;
	int	link_state;
};

struct dummy_priv {
	struct vf_data_storage	*vfinfo;
};

static int dummy_num_vf(struct device *dev)
{
	return num_vfs;
}

static struct bus_type dummy_bus = {
	.name	= "dummy",
	.num_vf	= dummy_num_vf,
};

static void release_dummy_parent(struct device *dev)
{
}

static struct device dummy_parent = {
	.init_name	= "dummy",
	.bus		= &dummy_bus,
	.release	= release_dummy_parent,
};

/* fake multicast ability */
static void set_multicast_list(struct net_device *dev)
{
}

struct pcpu_dstats {
	u64			tx_packets;
	u64			tx_bytes;
	struct u64_stats_sync	syncp;
};

static void dummy_get_stats64(struct net_device *dev,
			      struct rtnl_link_stats64 *stats)
{
	int i;

	for_each_possible_cpu(i) {
		const struct pcpu_dstats *dstats;
		u64 tbytes, tpackets;
		unsigned int start;

		dstats = per_cpu_ptr(dev->dstats, i);
		do {
			start = u64_stats_fetch_begin_irq(&dstats->syncp);
			tbytes = dstats->tx_bytes;
			tpackets = dstats->tx_packets;
		} while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
		stats->tx_bytes += tbytes;
		stats->tx_packets += tpackets;
	}
}

static netdev_tx_t dummy_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);

	u64_stats_update_begin(&dstats->syncp);
	dstats->tx_packets++;
	dstats->tx_bytes += skb->len;
	u64_stats_update_end(&dstats->syncp);

	dev_kfree_skb(skb);
	return NETDEV_TX_OK;
}

static int dummy_dev_init(struct net_device *dev)
{
	struct dummy_priv *priv = netdev_priv(dev);

	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
	if (!dev->dstats)
		return -ENOMEM;

	priv->vfinfo = NULL;

	if (!num_vfs)
		return 0;

	dev->dev.parent = &dummy_parent;
	priv->vfinfo = kcalloc(num_vfs, sizeof(struct vf_data_storage),
			       GFP_KERNEL);
	if (!priv->vfinfo) {
		free_percpu(dev->dstats);
		return -ENOMEM;
	}

	return 0;
}

static void dummy_dev_uninit(struct net_device *dev)
{
	free_percpu(dev->dstats);
}

static int dummy_change_carrier(struct net_device *dev, bool new_carrier)
{
	if (new_carrier)
		netif_carrier_on(dev);
	else
		netif_carrier_off(dev);
	return 0;
}

static int dummy_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (!is_valid_ether_addr(mac) || (vf >= num_vfs))
		return -EINVAL;

	memcpy(priv->vfinfo[vf].vf_mac, mac, ETH_ALEN);

	return 0;
}

static int dummy_set_vf_vlan(struct net_device *dev, int vf,
			     u16 vlan, u8 qos, __be16 vlan_proto)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if ((vf >= num_vfs) || (vlan > 4095) || (qos > 7))
		return -EINVAL;

	priv->vfinfo[vf].pf_vlan = vlan;
	priv->vfinfo[vf].pf_qos = qos;
	priv->vfinfo[vf].vlan_proto = vlan_proto;

	return 0;
}

static int dummy_set_vf_rate(struct net_device *dev, int vf, int min, int max)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].min_tx_rate = min;
	priv->vfinfo[vf].max_tx_rate = max;

	return 0;
}

static int dummy_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].spoofchk_enabled = val;

	return 0;
}

static int dummy_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].rss_query_enabled = val;

	return 0;
}

static int dummy_set_vf_trust(struct net_device *dev, int vf, bool val)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].trusted = val;

	return 0;
}

static int dummy_get_vf_config(struct net_device *dev,
			       int vf, struct ifla_vf_info *ivi)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	ivi->vf = vf;
	memcpy(&ivi->mac, priv->vfinfo[vf].vf_mac, ETH_ALEN);
	ivi->vlan = priv->vfinfo[vf].pf_vlan;
	ivi->qos = priv->vfinfo[vf].pf_qos;
	ivi->spoofchk = priv->vfinfo[vf].spoofchk_enabled;
	ivi->linkstate = priv->vfinfo[vf].link_state;
	ivi->min_tx_rate = priv->vfinfo[vf].min_tx_rate;
	ivi->max_tx_rate = priv->vfinfo[vf].max_tx_rate;
	ivi->rss_query_en = priv->vfinfo[vf].rss_query_enabled;
	ivi->trusted = priv->vfinfo[vf].trusted;
	ivi->vlan_proto = priv->vfinfo[vf].vlan_proto;

	return 0;
}

static int dummy_set_vf_link_state(struct net_device *dev, int vf, int state)
{
	struct dummy_priv *priv = netdev_priv(dev);

	if (vf >= num_vfs)
		return -EINVAL;

	priv->vfinfo[vf].link_state = state;

	return 0;
}

static const struct net_device_ops dummy_netdev_ops = {
	.ndo_init		= dummy_dev_init,
	.ndo_uninit		= dummy_dev_uninit,
	.ndo_start_xmit		= dummy_xmit,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_set_rx_mode	= set_multicast_list,
	.ndo_set_mac_address	= eth_mac_addr,
	.ndo_get_stats64	= dummy_get_stats64,
	.ndo_change_carrier	= dummy_change_carrier,
	.ndo_set_vf_mac		= dummy_set_vf_mac,
	.ndo_set_vf_vlan	= dummy_set_vf_vlan,
	.ndo_set_vf_rate	= dummy_set_vf_rate,
	.ndo_set_vf_spoofchk	= dummy_set_vf_spoofchk,
	.ndo_set_vf_trust	= dummy_set_vf_trust,
	.ndo_get_vf_config	= dummy_get_vf_config,
	.ndo_set_vf_link_state	= dummy_set_vf_link_state,
	.ndo_set_vf_rss_query_en = dummy_set_vf_rss_query_en,
};

static void dummy_get_drvinfo(struct net_device *dev,
			      struct ethtool_drvinfo *info)
{
	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
}

static const struct ethtool_ops dummy_ethtool_ops = {
	.get_drvinfo            = dummy_get_drvinfo,
};

static void dummy_free_netdev(struct net_device *dev)
{
	struct dummy_priv *priv = netdev_priv(dev);

	kfree(priv->vfinfo);
	free_netdev(dev);
}

static void dummy_setup(struct net_device *dev)
{
	ether_setup(dev);

	/* Initialize the device structure. */
	dev->netdev_ops = &dummy_netdev_ops;
	dev->ethtool_ops = &dummy_ethtool_ops;
	dev->destructor = dummy_free_netdev;

	/* Fill in device structure with ethernet-generic values. */
	dev->flags |= IFF_NOARP;
	dev->flags &= ~IFF_MULTICAST;
	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
	dev->features	|= NETIF_F_SG | NETIF_F_FRAGLIST;
	dev->features	|= NETIF_F_ALL_TSO | NETIF_F_UFO;
	dev->features	|= NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_LLTX;
	dev->features	|= NETIF_F_GSO_ENCAP_ALL;
	dev->hw_features |= dev->features;
	dev->hw_enc_features |= dev->features;
	eth_hw_addr_random(dev);

	dev->min_mtu = 0;
	dev->max_mtu = ETH_MAX_MTU;
}

static int dummy_validate(struct nlattr *tb[], struct nlattr *data[])
{
	if (tb[IFLA_ADDRESS]) {
		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
			return -EINVAL;
		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
			return -EADDRNOTAVAIL;
	}
	return 0;
}

static struct rtnl_link_ops dummy_link_ops __read_mostly = {
	.kind		= DRV_NAME,
	.priv_size	= sizeof(struct dummy_priv),
	.setup		= dummy_setup,
	.validate	= dummy_validate,
};

/* Number of dummy devices to be set up by this module. */
module_param(numdummies, int, 0);
MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");

module_param(num_vfs, int, 0);
MODULE_PARM_DESC(num_vfs, "Number of dummy VFs per dummy device");

static int __init dummy_init_one(void)
{
	struct net_device *dev_dummy;
	int err;

	dev_dummy = alloc_netdev(sizeof(struct dummy_priv),
				 "dummy%d", NET_NAME_UNKNOWN, dummy_setup);
	if (!dev_dummy)
		return -ENOMEM;

	dev_dummy->rtnl_link_ops = &dummy_link_ops;
	err = register_netdevice(dev_dummy);
	if (err < 0)
		goto err;
	return 0;

err:
	free_netdev(dev_dummy);
	return err;
}

static int __init dummy_init_module(void)
{
	int i, err = 0;

	if (num_vfs) {
		err = bus_register(&dummy_bus);
		if (err < 0) {
			pr_err("registering dummy bus failed\n");
			return err;
		}

		err = device_register(&dummy_parent);
		if (err < 0) {
			pr_err("registering dummy parent device failed\n");
			bus_unregister(&dummy_bus);
			return err;
		}
	}

	rtnl_lock();
	err = __rtnl_link_register(&dummy_link_ops);
	if (err < 0)
		goto out;

	for (i = 0; i < numdummies && !err; i++) {
		err = dummy_init_one();
		cond_resched();
	}
	if (err < 0)
		__rtnl_link_unregister(&dummy_link_ops);

out:
	rtnl_unlock();

	if (err && num_vfs) {
		device_unregister(&dummy_parent);
		bus_unregister(&dummy_bus);
	}

	return err;
}

static void __exit dummy_cleanup_module(void)
{
	rtnl_link_unregister(&dummy_link_ops);

	if (num_vfs) {
		device_unregister(&dummy_parent);
		bus_unregister(&dummy_bus);
	}
}

module_init(dummy_init_module);
module_exit(dummy_cleanup_module);
MODULE_LICENSE("GPL");
MODULE_ALIAS_RTNL_LINK(DRV_NAME);
MODULE_VERSION(DRV_VERSION);
Commit	Line	Data
1da177e4 LT	1	/* dummy.c: a dummy net driver
	2
	3	The purpose of this driver is to provide a device to point a
	4	route through, but not to actually transmit packets.
	5
	6	Why? If you have a machine whose only connection is an occasional
	7	PPP/SLIP/PLIP link, you can only connect to your own hostname
	8	when the link is up. Otherwise you have to use localhost.
	9	This isn't very consistent.
	10
	11	One solution is to set up a dummy link using PPP/SLIP/PLIP,
	12	but this seems (to me) too much overhead for too little gain.
	13	This driver provides a small alternative. Thus you can do
6aa20a22	14
1da177e4 LT	15	[when not running slip]
	16	ifconfig dummy slip.addr.ess.here up
	17	[to go to slip]
	18	ifconfig dummy down
	19	dip whatever
	20
	21	This was written by looking at Donald Becker's skeleton driver
	22	and the loopback driver. I then threw away anything that didn't
	23	apply! Thanks to Alan Cox for the key clue on what to do with
	24	misguided packets.
	25
	26	Nick Holloway, 27th May 1994
	27	[I tweaked this explanation a little but that's all]
	28	Alan Cox, 30th May 1994
	29	*/
	30
1da177e4 LT	31	#include <linux/module.h>
	32	#include <linux/kernel.h>
	33	#include <linux/netdevice.h>
	34	#include <linux/etherdevice.h>
	35	#include <linux/init.h>
	36	#include <linux/moduleparam.h>
206c9fb2	37	#include <linux/rtnetlink.h>
5d5cb173	38	#include <net/rtnetlink.h>
6d81f41c	39	#include <linux/u64_stats_sync.h>
206c9fb2	40
c19be735 FL	41	#define DRV_NAME "dummy"
	42	#define DRV_VERSION "1.0"
	43
e1636836 PS	44	#undef pr_fmt
	45	#define pr_fmt(fmt) DRV_NAME ": " fmt
	46
1da177e4	47	static int numdummies = 1;
e1636836 PS	48	static int num_vfs;
	49
	50	struct vf_data_storage {
	51	u8 vf_mac[ETH_ALEN];
	52	u16 pf_vlan; /* When set, guest VLAN config not allowed. */
	53	u16 pf_qos;
	54	__be16 vlan_proto;
	55	u16 min_tx_rate;
	56	u16 max_tx_rate;
	57	u8 spoofchk_enabled;
	58	bool rss_query_enabled;
	59	u8 trusted;
	60	int link_state;
	61	};
	62
	63	struct dummy_priv {
	64	struct vf_data_storage *vfinfo;
	65	};
	66
	67	static int dummy_num_vf(struct device *dev)
	68	{
	69	return num_vfs;
	70	}
	71
	72	static struct bus_type dummy_bus = {
	73	.name = "dummy",
	74	.num_vf = dummy_num_vf,
	75	};
	76
	77	static void release_dummy_parent(struct device *dev)
	78	{
	79	}
	80
	81	static struct device dummy_parent = {
	82	.init_name = "dummy",
	83	.bus = &dummy_bus,
	84	.release = release_dummy_parent,
	85	};
1da177e4	86
1da177e4 LT	87	/* fake multicast ability */
	88	static void set_multicast_list(struct net_device *dev)
	89	{
	90	}
	91
6d81f41c ED	92	struct pcpu_dstats {
	93	u64 tx_packets;
	94	u64 tx_bytes;
	95	struct u64_stats_sync syncp;
	96	};
	97
bc1f4470	98	static void dummy_get_stats64(struct net_device *dev,
bc1f4470	99	struct rtnl_link_stats64 *stats)
6d81f41c ED	100	{
	101	int i;
	102
	103	for_each_possible_cpu(i) {
	104	const struct pcpu_dstats *dstats;
	105	u64 tbytes, tpackets;
	106	unsigned int start;
	107
	108	dstats = per_cpu_ptr(dev->dstats, i);
	109	do {
57a7744e	110	start = u64_stats_fetch_begin_irq(&dstats->syncp);
6d81f41c ED	111	tbytes = dstats->tx_bytes;
6d81f41c ED	112	tpackets = dstats->tx_packets;
57a7744e	113	} while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
6d81f41c ED	114	stats->tx_bytes += tbytes;
	115	stats->tx_packets += tpackets;
	116	}
6d81f41c	117	}
424efe9c SH	118
	119	static netdev_tx_t dummy_xmit(struct sk_buff skb, struct net_device dev)
	120	{
6d81f41c ED	121	struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
	122
	123	u64_stats_update_begin(&dstats->syncp);
	124	dstats->tx_packets++;
	125	dstats->tx_bytes += skb->len;
	126	u64_stats_update_end(&dstats->syncp);
424efe9c SH	127
	128	dev_kfree_skb(skb);
	129	return NETDEV_TX_OK;
	130	}
	131
6d81f41c ED	132	static int dummy_dev_init(struct net_device *dev)
6d81f41c ED	133	{
e1636836 PS	134	struct dummy_priv *priv = netdev_priv(dev);
e1636836 PS	135
1c213bd2	136	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
6d81f41c ED	137	if (!dev->dstats)
	138	return -ENOMEM;
	139
e1636836 PS	140	priv->vfinfo = NULL;
	141
	142	if (!num_vfs)
	143	return 0;
	144
	145	dev->dev.parent = &dummy_parent;
	146	priv->vfinfo = kcalloc(num_vfs, sizeof(struct vf_data_storage),
	147	GFP_KERNEL);
	148	if (!priv->vfinfo) {
	149	free_percpu(dev->dstats);
	150	return -ENOMEM;
	151	}
	152
6d81f41c ED	153	return 0;
	154	}
	155
890fdf2a	156	static void dummy_dev_uninit(struct net_device *dev)
6d81f41c ED	157	{
6d81f41c ED	158	free_percpu(dev->dstats);
6d81f41c ED	159	}
6d81f41c ED	160
210ab665 JP	161	static int dummy_change_carrier(struct net_device *dev, bool new_carrier)
	162	{
	163	if (new_carrier)
	164	netif_carrier_on(dev);
	165	else
	166	netif_carrier_off(dev);
	167	return 0;
	168	}
	169
e1636836 PS	170	static int dummy_set_vf_mac(struct net_device dev, int vf, u8 mac)
	171	{
	172	struct dummy_priv *priv = netdev_priv(dev);
	173
	174	if (!is_valid_ether_addr(mac) \|\| (vf >= num_vfs))
	175	return -EINVAL;
	176
	177	memcpy(priv->vfinfo[vf].vf_mac, mac, ETH_ALEN);
	178
	179	return 0;
	180	}
	181
	182	static int dummy_set_vf_vlan(struct net_device *dev, int vf,
	183	u16 vlan, u8 qos, __be16 vlan_proto)
	184	{
	185	struct dummy_priv *priv = netdev_priv(dev);
	186
	187	if ((vf >= num_vfs) \|\| (vlan > 4095) \|\| (qos > 7))
	188	return -EINVAL;
	189
	190	priv->vfinfo[vf].pf_vlan = vlan;
	191	priv->vfinfo[vf].pf_qos = qos;
	192	priv->vfinfo[vf].vlan_proto = vlan_proto;
	193
	194	return 0;
	195	}
	196
	197	static int dummy_set_vf_rate(struct net_device *dev, int vf, int min, int max)
	198	{
	199	struct dummy_priv *priv = netdev_priv(dev);
	200
	201	if (vf >= num_vfs)
	202	return -EINVAL;
	203
	204	priv->vfinfo[vf].min_tx_rate = min;
	205	priv->vfinfo[vf].max_tx_rate = max;
	206
	207	return 0;
	208	}
	209
	210	static int dummy_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
	211	{
	212	struct dummy_priv *priv = netdev_priv(dev);
	213
	214	if (vf >= num_vfs)
	215	return -EINVAL;
	216
	217	priv->vfinfo[vf].spoofchk_enabled = val;
	218
	219	return 0;
	220	}
	221
	222	static int dummy_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
	223	{
	224	struct dummy_priv *priv = netdev_priv(dev);
	225
	226	if (vf >= num_vfs)
	227	return -EINVAL;
	228
	229	priv->vfinfo[vf].rss_query_enabled = val;
	230
	231	return 0;
	232	}
	233
234	static int dummy_set_vf_trust(struct net_device *dev, int vf, bool val)
235	{
236	struct dummy_priv *priv = netdev_priv(dev);
237
238	if (vf >= num_vfs)
239	return -EINVAL;
240
241	priv->vfinfo[vf].trusted = val;
242
243	return 0;
244	}
245
246	static int dummy_get_vf_config(struct net_device *dev,
247	int vf, struct ifla_vf_info *ivi)
248	{
249	struct dummy_priv *priv = netdev_priv(dev);
250
251	if (vf >= num_vfs)
252	return -EINVAL;
253
254	ivi->vf = vf;
255	memcpy(&ivi->mac, priv->vfinfo[vf].vf_mac, ETH_ALEN);
256	ivi->vlan = priv->vfinfo[vf].pf_vlan;
257	ivi->qos = priv->vfinfo[vf].pf_qos;
258	ivi->spoofchk = priv->vfinfo[vf].spoofchk_enabled;
259	ivi->linkstate = priv->vfinfo[vf].link_state;
260	ivi->min_tx_rate = priv->vfinfo[vf].min_tx_rate;
261	ivi->max_tx_rate = priv->vfinfo[vf].max_tx_rate;
262	ivi->rss_query_en = priv->vfinfo[vf].rss_query_enabled;
263	ivi->trusted = priv->vfinfo[vf].trusted;
264	ivi->vlan_proto = priv->vfinfo[vf].vlan_proto;
265
266	return 0;
267	}
268
269	static int dummy_set_vf_link_state(struct net_device *dev, int vf, int state)
270	{
271	struct dummy_priv *priv = netdev_priv(dev);
272
273	if (vf >= num_vfs)
274	return -EINVAL;
275
276	priv->vfinfo[vf].link_state = state;
277
278	return 0;
279	}
280
aa18e9e8	281	static const struct net_device_ops dummy_netdev_ops = {
6d81f41c	282	.ndo_init = dummy_dev_init,
890fdf2a	283	.ndo_uninit = dummy_dev_uninit,
aa18e9e8 SH	284	.ndo_start_xmit = dummy_xmit,
aa18e9e8 SH	285	.ndo_validate_addr = eth_validate_addr,
afc4b13d	286	.ndo_set_rx_mode = set_multicast_list,
0d1632b4	287	.ndo_set_mac_address = eth_mac_addr,
6d81f41c	288	.ndo_get_stats64 = dummy_get_stats64,
210ab665	289	.ndo_change_carrier = dummy_change_carrier,
e1636836 PS	290	.ndo_set_vf_mac = dummy_set_vf_mac,
	291	.ndo_set_vf_vlan = dummy_set_vf_vlan,
	292	.ndo_set_vf_rate = dummy_set_vf_rate,
	293	.ndo_set_vf_spoofchk = dummy_set_vf_spoofchk,
	294	.ndo_set_vf_trust = dummy_set_vf_trust,
	295	.ndo_get_vf_config = dummy_get_vf_config,
	296	.ndo_set_vf_link_state = dummy_set_vf_link_state,
	297	.ndo_set_vf_rss_query_en = dummy_set_vf_rss_query_en,
aa18e9e8 SH	298	};
aa18e9e8 SH	299
c19be735 FL	300	static void dummy_get_drvinfo(struct net_device *dev,
	301	struct ethtool_drvinfo *info)
	302	{
	303	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
	304	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
	305	}
	306
	307	static const struct ethtool_ops dummy_ethtool_ops = {
	308	.get_drvinfo = dummy_get_drvinfo,
	309	};
	310
e1636836 PS	311	static void dummy_free_netdev(struct net_device *dev)
	312	{
	313	struct dummy_priv *priv = netdev_priv(dev);
	314
	315	kfree(priv->vfinfo);
	316	free_netdev(dev);
	317	}
	318
5d5cb173	319	static void dummy_setup(struct net_device *dev)
1da177e4	320	{
aa18e9e8 SH	321	ether_setup(dev);
aa18e9e8 SH	322
1da177e4	323	/* Initialize the device structure. */
aa18e9e8	324	dev->netdev_ops = &dummy_netdev_ops;
c19be735	325	dev->ethtool_ops = &dummy_ethtool_ops;
e1636836	326	dev->destructor = dummy_free_netdev;
1da177e4 LT	327
1da177e4 LT	328	/* Fill in device structure with ethernet-generic values. */
1da177e4 LT	329	dev->flags \|= IFF_NOARP;
1da177e4 LT	330	dev->flags &= ~IFF_MULTICAST;
ff42c02c	331	dev->priv_flags \|= IFF_LIVE_ADDR_CHANGE \| IFF_NO_QUEUE;
8f3af277 ED	332	dev->features \|= NETIF_F_SG \| NETIF_F_FRAGLIST;
8f3af277 ED	333	dev->features \|= NETIF_F_ALL_TSO \| NETIF_F_UFO;
34324dc2	334	dev->features \|= NETIF_F_HW_CSUM \| NETIF_F_HIGHDMA \| NETIF_F_LLTX;
8f3af277 ED	335	dev->features \|= NETIF_F_GSO_ENCAP_ALL;
	336	dev->hw_features \|= dev->features;
	337	dev->hw_enc_features \|= dev->features;
7ce5d222	338	eth_hw_addr_random(dev);
25e3e84b ZS	339
	340	dev->min_mtu = 0;
	341	dev->max_mtu = ETH_MAX_MTU;
1da177e4	342	}
6d81f41c	343
0e06877c PM	344	static int dummy_validate(struct nlattr tb[], struct nlattr data[])
	345	{
	346	if (tb[IFLA_ADDRESS]) {
	347	if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
	348	return -EINVAL;
	349	if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
	350	return -EADDRNOTAVAIL;
	351	}
	352	return 0;
	353	}
	354
5d5cb173	355	static struct rtnl_link_ops dummy_link_ops __read_mostly = {
c19be735	356	.kind = DRV_NAME,
e1636836	357	.priv_size = sizeof(struct dummy_priv),
5d5cb173	358	.setup = dummy_setup,
0e06877c	359	.validate = dummy_validate,
5d5cb173 PM	360	};
5d5cb173 PM	361
1da177e4 LT	362	/* Number of dummy devices to be set up by this module. */
	363	module_param(numdummies, int, 0);
	364	MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");
	365
e1636836 PS	366	module_param(num_vfs, int, 0);
	367	MODULE_PARM_DESC(num_vfs, "Number of dummy VFs per dummy device");
	368
206c9fb2	369	static int __init dummy_init_one(void)
1da177e4 LT	370	{
	371	struct net_device *dev_dummy;
	372	int err;
	373
e1636836 PS	374	dev_dummy = alloc_netdev(sizeof(struct dummy_priv),
e1636836 PS	375	"dummy%d", NET_NAME_UNKNOWN, dummy_setup);
1da177e4 LT	376	if (!dev_dummy)
	377	return -ENOMEM;
	378
5d5cb173 PM	379	dev_dummy->rtnl_link_ops = &dummy_link_ops;
	380	err = register_netdevice(dev_dummy);
	381	if (err < 0)
	382	goto err;
5d5cb173	383	return 0;
206c9fb2	384
5d5cb173 PM	385	err:
	386	free_netdev(dev_dummy);
	387	return err;
6aa20a22	388	}
1da177e4 LT	389
1da177e4 LT	390	static int __init dummy_init_module(void)
6aa20a22	391	{
1da177e4	392	int i, err = 0;
206c9fb2	393
e1636836 PS	394	if (num_vfs) {
	395	err = bus_register(&dummy_bus);
	396	if (err < 0) {
	397	pr_err("registering dummy bus failed\n");
	398	return err;
	399	}
	400
	401	err = device_register(&dummy_parent);
	402	if (err < 0) {
	403	pr_err("registering dummy parent device failed\n");
	404	bus_unregister(&dummy_bus);
	405	return err;
	406	}
	407	}
	408
5d5cb173 PM	409	rtnl_lock();
5d5cb173 PM	410	err = __rtnl_link_register(&dummy_link_ops);
2c8a0189	411	if (err < 0)
2c8a0189	412	goto out;
5d5cb173	413
16b0dc29	414	for (i = 0; i < numdummies && !err; i++) {
206c9fb2	415	err = dummy_init_one();
16b0dc29 ED	416	cond_resched();
16b0dc29 ED	417	}
2d85cba2	418	if (err < 0)
5d5cb173	419	__rtnl_link_unregister(&dummy_link_ops);
2c8a0189	420
2c8a0189	421	out:
5d5cb173 PM	422	rtnl_unlock();
5d5cb173 PM	423
e1636836 PS	424	if (err && num_vfs) {
	425	device_unregister(&dummy_parent);
	426	bus_unregister(&dummy_bus);
	427	}
	428
1da177e4	429	return err;
6aa20a22	430	}
1da177e4 LT	431
	432	static void __exit dummy_cleanup_module(void)
	433	{
2d85cba2	434	rtnl_link_unregister(&dummy_link_ops);
e1636836 PS	435
	436	if (num_vfs) {
	437	device_unregister(&dummy_parent);
	438	bus_unregister(&dummy_bus);
	439	}
1da177e4 LT	440	}
	441
	442	module_init(dummy_init_module);
	443	module_exit(dummy_cleanup_module);
	444	MODULE_LICENSE("GPL");
c19be735	445	MODULE_ALIAS_RTNL_LINK(DRV_NAME);
6c702fab	446	MODULE_VERSION(DRV_VERSION);