[mirror_ubuntu-bionic-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 <linux/net_tstamp.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);

	skb_tx_timestamp(skb);
	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 int dummy_get_ts_info(struct net_device *dev,
			      struct ethtool_ts_info *ts_info)
{
	ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
				   SOF_TIMESTAMPING_RX_SOFTWARE |
				   SOF_TIMESTAMPING_SOFTWARE;

	ts_info->phc_index = -1;

	return 0;
};

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

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

	kfree(priv->vfinfo);
}

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->needs_free_netdev = true;
	dev->priv_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;
	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 = 0;
}

static int dummy_validate(struct nlattr *tb[], struct nlattr *data[],
			  struct netlink_ext_ack *extack)
{
	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_ENUM, 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>
6df014cf	38	#include <linux/net_tstamp.h>
5d5cb173	39	#include <net/rtnetlink.h>
6d81f41c	40	#include <linux/u64_stats_sync.h>
206c9fb2	41
c19be735 FL	42	#define DRV_NAME "dummy"
	43	#define DRV_VERSION "1.0"
	44
e1636836 PS	45	#undef pr_fmt
	46	#define pr_fmt(fmt) DRV_NAME ": " fmt
	47
1da177e4	48	static int numdummies = 1;
e1636836 PS	49	static int num_vfs;
	50
	51	struct vf_data_storage {
	52	u8 vf_mac[ETH_ALEN];
	53	u16 pf_vlan; /* When set, guest VLAN config not allowed. */
	54	u16 pf_qos;
	55	__be16 vlan_proto;
	56	u16 min_tx_rate;
	57	u16 max_tx_rate;
	58	u8 spoofchk_enabled;
	59	bool rss_query_enabled;
	60	u8 trusted;
	61	int link_state;
	62	};
	63
	64	struct dummy_priv {
	65	struct vf_data_storage *vfinfo;
	66	};
	67
	68	static int dummy_num_vf(struct device *dev)
	69	{
	70	return num_vfs;
	71	}
	72
	73	static struct bus_type dummy_bus = {
	74	.name = "dummy",
	75	.num_vf = dummy_num_vf,
	76	};
	77
	78	static void release_dummy_parent(struct device *dev)
	79	{
	80	}
	81
	82	static struct device dummy_parent = {
	83	.init_name = "dummy",
	84	.bus = &dummy_bus,
	85	.release = release_dummy_parent,
	86	};
1da177e4	87
1da177e4 LT	88	/* fake multicast ability */
	89	static void set_multicast_list(struct net_device *dev)
	90	{
	91	}
	92
6d81f41c ED	93	struct pcpu_dstats {
	94	u64 tx_packets;
	95	u64 tx_bytes;
	96	struct u64_stats_sync syncp;
	97	};
	98
bc1f4470	99	static void dummy_get_stats64(struct net_device *dev,
bc1f4470	100	struct rtnl_link_stats64 *stats)
6d81f41c ED	101	{
	102	int i;
	103
	104	for_each_possible_cpu(i) {
	105	const struct pcpu_dstats *dstats;
	106	u64 tbytes, tpackets;
	107	unsigned int start;
	108
	109	dstats = per_cpu_ptr(dev->dstats, i);
	110	do {
57a7744e	111	start = u64_stats_fetch_begin_irq(&dstats->syncp);
6d81f41c ED	112	tbytes = dstats->tx_bytes;
6d81f41c ED	113	tpackets = dstats->tx_packets;
57a7744e	114	} while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
6d81f41c ED	115	stats->tx_bytes += tbytes;
	116	stats->tx_packets += tpackets;
	117	}
6d81f41c	118	}
424efe9c SH	119
	120	static netdev_tx_t dummy_xmit(struct sk_buff skb, struct net_device dev)
	121	{
6d81f41c ED	122	struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
	123
	124	u64_stats_update_begin(&dstats->syncp);
	125	dstats->tx_packets++;
	126	dstats->tx_bytes += skb->len;
	127	u64_stats_update_end(&dstats->syncp);
424efe9c	128
6df014cf	129	skb_tx_timestamp(skb);
424efe9c SH	130	dev_kfree_skb(skb);
	131	return NETDEV_TX_OK;
	132	}
	133
6d81f41c ED	134	static int dummy_dev_init(struct net_device *dev)
6d81f41c ED	135	{
e1636836 PS	136	struct dummy_priv *priv = netdev_priv(dev);
e1636836 PS	137
1c213bd2	138	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
6d81f41c ED	139	if (!dev->dstats)
	140	return -ENOMEM;
	141
e1636836 PS	142	priv->vfinfo = NULL;
	143
	144	if (!num_vfs)
	145	return 0;
	146
	147	dev->dev.parent = &dummy_parent;
	148	priv->vfinfo = kcalloc(num_vfs, sizeof(struct vf_data_storage),
	149	GFP_KERNEL);
	150	if (!priv->vfinfo) {
	151	free_percpu(dev->dstats);
	152	return -ENOMEM;
	153	}
	154
6d81f41c ED	155	return 0;
	156	}
	157
890fdf2a	158	static void dummy_dev_uninit(struct net_device *dev)
6d81f41c ED	159	{
6d81f41c ED	160	free_percpu(dev->dstats);
6d81f41c ED	161	}
6d81f41c ED	162
210ab665 JP	163	static int dummy_change_carrier(struct net_device *dev, bool new_carrier)
	164	{
	165	if (new_carrier)
	166	netif_carrier_on(dev);
	167	else
	168	netif_carrier_off(dev);
	169	return 0;
	170	}
	171
e1636836 PS	172	static int dummy_set_vf_mac(struct net_device dev, int vf, u8 mac)
	173	{
	174	struct dummy_priv *priv = netdev_priv(dev);
	175
	176	if (!is_valid_ether_addr(mac) \|\| (vf >= num_vfs))
	177	return -EINVAL;
	178
	179	memcpy(priv->vfinfo[vf].vf_mac, mac, ETH_ALEN);
	180
	181	return 0;
	182	}
	183
	184	static int dummy_set_vf_vlan(struct net_device *dev, int vf,
	185	u16 vlan, u8 qos, __be16 vlan_proto)
	186	{
	187	struct dummy_priv *priv = netdev_priv(dev);
	188
	189	if ((vf >= num_vfs) \|\| (vlan > 4095) \|\| (qos > 7))
	190	return -EINVAL;
	191
	192	priv->vfinfo[vf].pf_vlan = vlan;
	193	priv->vfinfo[vf].pf_qos = qos;
	194	priv->vfinfo[vf].vlan_proto = vlan_proto;
	195
	196	return 0;
	197	}
	198
	199	static int dummy_set_vf_rate(struct net_device *dev, int vf, int min, int max)
	200	{
	201	struct dummy_priv *priv = netdev_priv(dev);
	202
	203	if (vf >= num_vfs)
	204	return -EINVAL;
	205
	206	priv->vfinfo[vf].min_tx_rate = min;
	207	priv->vfinfo[vf].max_tx_rate = max;
	208
	209	return 0;
	210	}
	211
	212	static int dummy_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
	213	{
	214	struct dummy_priv *priv = netdev_priv(dev);
	215
	216	if (vf >= num_vfs)
	217	return -EINVAL;
	218
	219	priv->vfinfo[vf].spoofchk_enabled = val;
	220
	221	return 0;
	222	}
	223
	224	static int dummy_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
	225	{
	226	struct dummy_priv *priv = netdev_priv(dev);
	227
	228	if (vf >= num_vfs)
	229	return -EINVAL;
	230
	231	priv->vfinfo[vf].rss_query_enabled = val;
	232
	233	return 0;
	234	}
	235
236	static int dummy_set_vf_trust(struct net_device *dev, int vf, bool val)
237	{
238	struct dummy_priv *priv = netdev_priv(dev);
239
240	if (vf >= num_vfs)
241	return -EINVAL;
242
243	priv->vfinfo[vf].trusted = val;
244
245	return 0;
246	}
247
248	static int dummy_get_vf_config(struct net_device *dev,
249	int vf, struct ifla_vf_info *ivi)
250	{
251	struct dummy_priv *priv = netdev_priv(dev);
252
253	if (vf >= num_vfs)
254	return -EINVAL;
255
256	ivi->vf = vf;
257	memcpy(&ivi->mac, priv->vfinfo[vf].vf_mac, ETH_ALEN);
258	ivi->vlan = priv->vfinfo[vf].pf_vlan;
259	ivi->qos = priv->vfinfo[vf].pf_qos;
260	ivi->spoofchk = priv->vfinfo[vf].spoofchk_enabled;
261	ivi->linkstate = priv->vfinfo[vf].link_state;
262	ivi->min_tx_rate = priv->vfinfo[vf].min_tx_rate;
263	ivi->max_tx_rate = priv->vfinfo[vf].max_tx_rate;
264	ivi->rss_query_en = priv->vfinfo[vf].rss_query_enabled;
265	ivi->trusted = priv->vfinfo[vf].trusted;
266	ivi->vlan_proto = priv->vfinfo[vf].vlan_proto;
267
268	return 0;
269	}
270
271	static int dummy_set_vf_link_state(struct net_device *dev, int vf, int state)
272	{
273	struct dummy_priv *priv = netdev_priv(dev);
274
275	if (vf >= num_vfs)
276	return -EINVAL;
277
278	priv->vfinfo[vf].link_state = state;
279
280	return 0;
281	}
282
aa18e9e8	283	static const struct net_device_ops dummy_netdev_ops = {
6d81f41c	284	.ndo_init = dummy_dev_init,
890fdf2a	285	.ndo_uninit = dummy_dev_uninit,
aa18e9e8 SH	286	.ndo_start_xmit = dummy_xmit,
aa18e9e8 SH	287	.ndo_validate_addr = eth_validate_addr,
afc4b13d	288	.ndo_set_rx_mode = set_multicast_list,
0d1632b4	289	.ndo_set_mac_address = eth_mac_addr,
6d81f41c	290	.ndo_get_stats64 = dummy_get_stats64,
210ab665	291	.ndo_change_carrier = dummy_change_carrier,
e1636836 PS	292	.ndo_set_vf_mac = dummy_set_vf_mac,
	293	.ndo_set_vf_vlan = dummy_set_vf_vlan,
	294	.ndo_set_vf_rate = dummy_set_vf_rate,
	295	.ndo_set_vf_spoofchk = dummy_set_vf_spoofchk,
	296	.ndo_set_vf_trust = dummy_set_vf_trust,
	297	.ndo_get_vf_config = dummy_get_vf_config,
	298	.ndo_set_vf_link_state = dummy_set_vf_link_state,
	299	.ndo_set_vf_rss_query_en = dummy_set_vf_rss_query_en,
aa18e9e8 SH	300	};
aa18e9e8 SH	301
c19be735 FL	302	static void dummy_get_drvinfo(struct net_device *dev,
	303	struct ethtool_drvinfo *info)
	304	{
	305	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
	306	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
	307	}
	308
6df014cf ELG	309	static int dummy_get_ts_info(struct net_device *dev,
	310	struct ethtool_ts_info *ts_info)
	311	{
	312	ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE \|
	313	SOF_TIMESTAMPING_RX_SOFTWARE \|
	314	SOF_TIMESTAMPING_SOFTWARE;
	315
	316	ts_info->phc_index = -1;
	317
	318	return 0;
	319	};
	320
c19be735 FL	321	static const struct ethtool_ops dummy_ethtool_ops = {
c19be735 FL	322	.get_drvinfo = dummy_get_drvinfo,
6df014cf	323	.get_ts_info = dummy_get_ts_info,
c19be735 FL	324	};
c19be735 FL	325
e1636836 PS	326	static void dummy_free_netdev(struct net_device *dev)
	327	{
	328	struct dummy_priv *priv = netdev_priv(dev);
	329
	330	kfree(priv->vfinfo);
e1636836 PS	331	}
e1636836 PS	332
5d5cb173	333	static void dummy_setup(struct net_device *dev)
1da177e4	334	{
aa18e9e8 SH	335	ether_setup(dev);
aa18e9e8 SH	336
1da177e4	337	/* Initialize the device structure. */
aa18e9e8	338	dev->netdev_ops = &dummy_netdev_ops;
c19be735	339	dev->ethtool_ops = &dummy_ethtool_ops;
cf124db5 DM	340	dev->needs_free_netdev = true;
cf124db5 DM	341	dev->priv_destructor = dummy_free_netdev;
1da177e4 LT	342
1da177e4 LT	343	/* Fill in device structure with ethernet-generic values. */
1da177e4 LT	344	dev->flags \|= IFF_NOARP;
1da177e4 LT	345	dev->flags &= ~IFF_MULTICAST;
ff42c02c	346	dev->priv_flags \|= IFF_LIVE_ADDR_CHANGE \| IFF_NO_QUEUE;
8f3af277	347	dev->features \|= NETIF_F_SG \| NETIF_F_FRAGLIST;
2082499a	348	dev->features \|= NETIF_F_ALL_TSO;
34324dc2	349	dev->features \|= NETIF_F_HW_CSUM \| NETIF_F_HIGHDMA \| NETIF_F_LLTX;
8f3af277 ED	350	dev->features \|= NETIF_F_GSO_ENCAP_ALL;
	351	dev->hw_features \|= dev->features;
	352	dev->hw_enc_features \|= dev->features;
7ce5d222	353	eth_hw_addr_random(dev);
25e3e84b ZS	354
25e3e84b ZS	355	dev->min_mtu = 0;
e94cd811	356	dev->max_mtu = 0;
1da177e4	357	}
6d81f41c	358
a8b8a889 MS	359	static int dummy_validate(struct nlattr tb[], struct nlattr data[],
a8b8a889 MS	360	struct netlink_ext_ack *extack)
0e06877c PM	361	{
	362	if (tb[IFLA_ADDRESS]) {
	363	if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
	364	return -EINVAL;
	365	if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
	366	return -EADDRNOTAVAIL;
	367	}
	368	return 0;
	369	}
	370
5d5cb173	371	static struct rtnl_link_ops dummy_link_ops __read_mostly = {
c19be735	372	.kind = DRV_NAME,
e1636836	373	.priv_size = sizeof(struct dummy_priv),
5d5cb173	374	.setup = dummy_setup,
0e06877c	375	.validate = dummy_validate,
5d5cb173 PM	376	};
5d5cb173 PM	377
1da177e4 LT	378	/* Number of dummy devices to be set up by this module. */
	379	module_param(numdummies, int, 0);
	380	MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");
	381
e1636836 PS	382	module_param(num_vfs, int, 0);
	383	MODULE_PARM_DESC(num_vfs, "Number of dummy VFs per dummy device");
	384
206c9fb2	385	static int __init dummy_init_one(void)
1da177e4 LT	386	{
	387	struct net_device *dev_dummy;
	388	int err;
	389
e1636836	390	dev_dummy = alloc_netdev(sizeof(struct dummy_priv),
ab076b94	391	"dummy%d", NET_NAME_ENUM, dummy_setup);
1da177e4 LT	392	if (!dev_dummy)
	393	return -ENOMEM;
	394
5d5cb173 PM	395	dev_dummy->rtnl_link_ops = &dummy_link_ops;
	396	err = register_netdevice(dev_dummy);
	397	if (err < 0)
	398	goto err;
5d5cb173	399	return 0;
206c9fb2	400
5d5cb173 PM	401	err:
	402	free_netdev(dev_dummy);
	403	return err;
6aa20a22	404	}
1da177e4 LT	405
1da177e4 LT	406	static int __init dummy_init_module(void)
6aa20a22	407	{
1da177e4	408	int i, err = 0;
206c9fb2	409
e1636836 PS	410	if (num_vfs) {
	411	err = bus_register(&dummy_bus);
	412	if (err < 0) {
	413	pr_err("registering dummy bus failed\n");
	414	return err;
	415	}
	416
	417	err = device_register(&dummy_parent);
	418	if (err < 0) {
	419	pr_err("registering dummy parent device failed\n");
	420	bus_unregister(&dummy_bus);
	421	return err;
	422	}
	423	}
	424
5d5cb173 PM	425	rtnl_lock();
5d5cb173 PM	426	err = __rtnl_link_register(&dummy_link_ops);
2c8a0189	427	if (err < 0)
2c8a0189	428	goto out;
5d5cb173	429
16b0dc29	430	for (i = 0; i < numdummies && !err; i++) {
206c9fb2	431	err = dummy_init_one();
16b0dc29 ED	432	cond_resched();
16b0dc29 ED	433	}
2d85cba2	434	if (err < 0)
5d5cb173	435	__rtnl_link_unregister(&dummy_link_ops);
2c8a0189	436
2c8a0189	437	out:
5d5cb173 PM	438	rtnl_unlock();
5d5cb173 PM	439
e1636836 PS	440	if (err && num_vfs) {
	441	device_unregister(&dummy_parent);
	442	bus_unregister(&dummy_bus);
	443	}
	444
1da177e4	445	return err;
6aa20a22	446	}
1da177e4 LT	447
	448	static void __exit dummy_cleanup_module(void)
	449	{
2d85cba2	450	rtnl_link_unregister(&dummy_link_ops);
e1636836 PS	451
	452	if (num_vfs) {
	453	device_unregister(&dummy_parent);
	454	bus_unregister(&dummy_bus);
	455	}
1da177e4 LT	456	}
	457
	458	module_init(dummy_init_module);
	459	module_exit(dummy_cleanup_module);
	460	MODULE_LICENSE("GPL");
c19be735	461	MODULE_ALIAS_RTNL_LINK(DRV_NAME);
6c702fab	462	MODULE_VERSION(DRV_VERSION);