Release 4.14 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
14
100.00%
1
100.00%
Total
14
100.00%
1
100.00%


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



static void release_dummy_parent(struct device *dev)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
10
100.00%
1
100.00%
Total
10
100.00%
1
100.00%


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)
{
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Linus Torvalds (pre-git)
10
100.00%
2
100.00%
Total
10
100.00%
2
100.00%


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;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Eric Dumazet
98
97.03%
1
33.33%
Eric W. Biedermann
2
1.98%
1
33.33%
Stephen Hemminger
1
0.99%
1
33.33%
Total
101
100.00%
3
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Stephen Hemminger
36
51.43%
1
33.33%
Eric Dumazet
29
41.43%
1
33.33%
Ezequiel Lara Gomez
5
7.14%
1
33.33%
Total
70
100.00%
3
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
95
90.48%
1
50.00%
Eric Dumazet
10
9.52%
1
50.00%
Total
105
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
18
100.00%
1
100.00%
Total
18
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
32
100.00%
1
100.00%
Total
32
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
64
98.46%
1
50.00%
Eric Dumazet
1
1.54%
1
50.00%
Total
65
100.00%
2
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
93
100.00%
1
100.00%
Total
93
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
65
100.00%
1
100.00%
Total
65
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
51
100.00%
1
100.00%
Total
51
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
51
100.00%
1
100.00%
Total
51
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
51
100.00%
1
100.00%
Total
51
100.00%
1
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
176
95.65%
1
50.00%
Eric Dumazet
8
4.35%
1
50.00%
Total
184
100.00%
2
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
32
62.75%
1
33.33%
Jiri Pirko
11
21.57%
1
33.33%
Eric Dumazet
8
15.69%
1
33.33%
Total
51
100.00%
3
100.00%


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));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Flavio Leitner
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%



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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Ezequiel Lara Gomez
36
100.00%
1
100.00%
Total
36
100.00%
1
100.00%

;


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
28
100.00%
1
100.00%
Total
28
100.00%
1
100.00%



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 = ETH_MAX_MTU;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Eric Dumazet
45
35.16%
2
8.70%
Linus Torvalds (pre-git)
23
17.97%
8
34.78%
Stephen Hemminger
17
13.28%
3
13.04%
Zhang Shengju
12
9.38%
1
4.35%
Flavio Leitner
7
5.47%
1
4.35%
David S. Miller
7
5.47%
1
4.35%
Jiri Pirko
6
4.69%
1
4.35%
Patrick McHardy
4
3.12%
1
4.35%
Phil Sutter
3
2.34%
2
8.70%
Linus Torvalds
2
1.56%
1
4.35%
Michał Mirosław
1
0.78%
1
4.35%
Danny Kukawka
1
0.78%
1
4.35%
Total
128
100.00%
23
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Patrick McHardy
64
92.75%
1
50.00%
Matthias Schiffer
5
7.25%
1
50.00%
Total
69
100.00%
2
100.00%


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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Patrick McHardy
28
35.44%
2
15.38%
Linus Torvalds (pre-git)
26
32.91%
6
46.15%
Stephen Hemminger
11
13.92%
2
15.38%
Andi Kleen
7
8.86%
1
7.69%
Phil Sutter
5
6.33%
1
7.69%
Tom Gundersen
2
2.53%
1
7.69%
Total
79
100.00%
13
100.00%



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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
80
49.38%
1
16.67%
Andi Kleen
43
26.54%
1
16.67%
Patrick McHardy
23
14.20%
2
33.33%
Ding Tianhong
11
6.79%
1
16.67%
Eric Dumazet
5
3.09%
1
16.67%
Total
162
100.00%
6
100.00%



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

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
18
54.55%
1
20.00%
Andi Kleen
8
24.24%
1
20.00%
Patrick McHardy
6
18.18%
2
40.00%
Linus Torvalds (pre-git)
1
3.03%
1
20.00%
Total
33
100.00%
5
100.00%


module_init(dummy_init_module);

module_exit(dummy_cleanup_module);
MODULE_LICENSE("GPL");

MODULE_ALIAS_RTNL_LINK(DRV_NAME);

MODULE_VERSION(DRV_VERSION);
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Phil Sutter
1054
55.04%
2
4.17%
Eric Dumazet
232
12.11%
3
6.25%
Patrick McHardy
157
8.20%
4
8.33%
Stephen Hemminger
99
5.17%
6
12.50%
Linus Torvalds (pre-git)
83
4.33%
13
27.08%
Flavio Leitner
83
4.33%
2
4.17%
Andi Kleen
77
4.02%
1
2.08%
Ezequiel Lara Gomez
50
2.61%
1
2.08%
Jiri Pirko
24
1.25%
3
6.25%
Zhang Shengju
12
0.63%
1
2.08%
Ding Tianhong
11
0.57%
1
2.08%
David S. Miller
7
0.37%
1
2.08%
Linus Torvalds
7
0.37%
2
4.17%
Matthias Schiffer
5
0.26%
1
2.08%
Hiroaki SHIMODA
5
0.26%
1
2.08%
Tom Gundersen
2
0.10%
1
2.08%
Eric W. Biedermann
2
0.10%
1
2.08%
Rusty Russell
2
0.10%
1
2.08%
Jeff Garzik
1
0.05%
1
2.08%
Michał Mirosław
1
0.05%
1
2.08%
Danny Kukawka
1
0.05%
1
2.08%
Total
1915
100.00%
48
100.00%
Directory: drivers/net

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.