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
 14
 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
 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>
 37#include <linux/rtnetlink.h>
 38#include <linux/net_tstamp.h>
 39#include <net/rtnetlink.h>
 40#include <linux/u64_stats_sync.h>
 41
 42#define DRV_NAME	"dummy"
 43#define DRV_VERSION	"1.0"
 44
 45static int numdummies = 1;
 46
 47/* fake multicast ability */
 48static void set_multicast_list(struct net_device *dev)
 49{
 50}
 51
 52struct pcpu_dstats {
 53	u64			tx_packets;
 54	u64			tx_bytes;
 55	struct u64_stats_sync	syncp;
 56};
 57
 58static void dummy_get_stats64(struct net_device *dev,
 59			      struct rtnl_link_stats64 *stats)
 60{
 61	int i;
 62
 63	for_each_possible_cpu(i) {
 64		const struct pcpu_dstats *dstats;
 65		u64 tbytes, tpackets;
 66		unsigned int start;
 67
 68		dstats = per_cpu_ptr(dev->dstats, i);
 69		do {
 70			start = u64_stats_fetch_begin_irq(&dstats->syncp);
 71			tbytes = dstats->tx_bytes;
 72			tpackets = dstats->tx_packets;
 73		} while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
 74		stats->tx_bytes += tbytes;
 75		stats->tx_packets += tpackets;
 76	}
 77}
 78
 79static netdev_tx_t dummy_xmit(struct sk_buff *skb, struct net_device *dev)
 80{
 81	struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
 82
 83	u64_stats_update_begin(&dstats->syncp);
 84	dstats->tx_packets++;
 85	dstats->tx_bytes += skb->len;
 86	u64_stats_update_end(&dstats->syncp);
 87
 88	skb_tx_timestamp(skb);
 89	dev_kfree_skb(skb);
 90	return NETDEV_TX_OK;
 91}
 92
 93static int dummy_dev_init(struct net_device *dev)
 94{
 95	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
 96	if (!dev->dstats)
 97		return -ENOMEM;
 98
 99	return 0;
100}
101
102static void dummy_dev_uninit(struct net_device *dev)
103{
104	free_percpu(dev->dstats);
105}
106
107static int dummy_change_carrier(struct net_device *dev, bool new_carrier)
108{
109	if (new_carrier)
110		netif_carrier_on(dev);
111	else
112		netif_carrier_off(dev);
113	return 0;
114}
115
116static const struct net_device_ops dummy_netdev_ops = {
117	.ndo_init		= dummy_dev_init,
118	.ndo_uninit		= dummy_dev_uninit,
119	.ndo_start_xmit		= dummy_xmit,
120	.ndo_validate_addr	= eth_validate_addr,
121	.ndo_set_rx_mode	= set_multicast_list,
122	.ndo_set_mac_address	= eth_mac_addr,
123	.ndo_get_stats64	= dummy_get_stats64,
124	.ndo_change_carrier	= dummy_change_carrier,
125};
126
127static void dummy_get_drvinfo(struct net_device *dev,
128			      struct ethtool_drvinfo *info)
129{
130	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
131	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
132}
133
134static int dummy_get_ts_info(struct net_device *dev,
135			      struct ethtool_ts_info *ts_info)
136{
137	ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
138				   SOF_TIMESTAMPING_RX_SOFTWARE |
139				   SOF_TIMESTAMPING_SOFTWARE;
140
141	ts_info->phc_index = -1;
142
143	return 0;
144};
145
146static const struct ethtool_ops dummy_ethtool_ops = {
147	.get_drvinfo            = dummy_get_drvinfo,
148	.get_ts_info		= dummy_get_ts_info,
149};
150
151static void dummy_setup(struct net_device *dev)
152{
153	ether_setup(dev);
154
155	/* Initialize the device structure. */
156	dev->netdev_ops = &dummy_netdev_ops;
157	dev->ethtool_ops = &dummy_ethtool_ops;
158	dev->needs_free_netdev = true;
159
160	/* Fill in device structure with ethernet-generic values. */
161	dev->flags |= IFF_NOARP;
162	dev->flags &= ~IFF_MULTICAST;
163	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
164	dev->features	|= NETIF_F_SG | NETIF_F_FRAGLIST;
165	dev->features	|= NETIF_F_ALL_TSO;
166	dev->features	|= NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_LLTX;
167	dev->features	|= NETIF_F_GSO_ENCAP_ALL;
168	dev->hw_features |= dev->features;
169	dev->hw_enc_features |= dev->features;
170	eth_hw_addr_random(dev);
171
172	dev->min_mtu = 0;
173	dev->max_mtu = 0;
174}
175
176static int dummy_validate(struct nlattr *tb[], struct nlattr *data[],
177			  struct netlink_ext_ack *extack)
178{
179	if (tb[IFLA_ADDRESS]) {
180		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
181			return -EINVAL;
182		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
183			return -EADDRNOTAVAIL;
184	}
185	return 0;
186}
187
188static struct rtnl_link_ops dummy_link_ops __read_mostly = {
189	.kind		= DRV_NAME,
190	.setup		= dummy_setup,
191	.validate	= dummy_validate,
192};
193
194/* Number of dummy devices to be set up by this module. */
195module_param(numdummies, int, 0);
196MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");
197
198static int __init dummy_init_one(void)
199{
200	struct net_device *dev_dummy;
201	int err;
202
203	dev_dummy = alloc_netdev(0, "dummy%d", NET_NAME_ENUM, dummy_setup);
204	if (!dev_dummy)
205		return -ENOMEM;
206
207	dev_dummy->rtnl_link_ops = &dummy_link_ops;
208	err = register_netdevice(dev_dummy);
209	if (err < 0)
210		goto err;
211	return 0;
212
213err:
214	free_netdev(dev_dummy);
215	return err;
216}
217
218static int __init dummy_init_module(void)
219{
220	int i, err = 0;
221
222	down_write(&pernet_ops_rwsem);
223	rtnl_lock();
224	err = __rtnl_link_register(&dummy_link_ops);
225	if (err < 0)
226		goto out;
227
228	for (i = 0; i < numdummies && !err; i++) {
229		err = dummy_init_one();
230		cond_resched();
231	}
232	if (err < 0)
233		__rtnl_link_unregister(&dummy_link_ops);
234
235out:
236	rtnl_unlock();
237	up_write(&pernet_ops_rwsem);
238
239	return err;
240}
241
242static void __exit dummy_cleanup_module(void)
243{
244	rtnl_link_unregister(&dummy_link_ops);
245}
246
247module_init(dummy_init_module);
248module_exit(dummy_cleanup_module);
249MODULE_LICENSE("GPL");
250MODULE_ALIAS_RTNL_LINK(DRV_NAME);
251MODULE_VERSION(DRV_VERSION);

  1// SPDX-License-Identifier: GPL-2.0-only
  2/* dummy.c: a dummy net driver
  3
  4	The purpose of this driver is to provide a device to point a
  5	route through, but not to actually transmit packets.
  6
  7	Why?  If you have a machine whose only connection is an occasional
  8	PPP/SLIP/PLIP link, you can only connect to your own hostname
  9	when the link is up.  Otherwise you have to use localhost.
 10	This isn't very consistent.
 11
 12	One solution is to set up a dummy link using PPP/SLIP/PLIP,
 13	but this seems (to me) too much overhead for too little gain.
 14	This driver provides a small alternative. Thus you can do
 15
 16	[when not running slip]
 17		ifconfig dummy slip.addr.ess.here up
 18	[to go to slip]
 19		ifconfig dummy down
 20		dip whatever
 21
 22	This was written by looking at Donald Becker's skeleton driver
 23	and the loopback driver.  I then threw away anything that didn't
 24	apply!	Thanks to Alan Cox for the key clue on what to do with
 25	misguided packets.
 26
 27			Nick Holloway, 27th May 1994
 28	[I tweaked this explanation a little but that's all]
 29			Alan Cox, 30th May 1994
 30*/
 31
 32#include <linux/module.h>
 33#include <linux/kernel.h>
 34#include <linux/netdevice.h>
 35#include <linux/etherdevice.h>
 36#include <linux/ethtool.h>
 37#include <linux/init.h>
 38#include <linux/moduleparam.h>
 39#include <linux/rtnetlink.h>
 40#include <linux/net_tstamp.h>
 41#include <net/rtnetlink.h>
 42#include <linux/u64_stats_sync.h>
 43
 44#define DRV_NAME	"dummy"
 45#define DRV_VERSION	"1.0"
 46
 47static int numdummies = 1;
 48
 49/* fake multicast ability */
 50static void set_multicast_list(struct net_device *dev)
 51{
 52}
 53
 54struct pcpu_dstats {
 55	u64			tx_packets;
 56	u64			tx_bytes;
 57	struct u64_stats_sync	syncp;
 58};
 59
 60static void dummy_get_stats64(struct net_device *dev,
 61			      struct rtnl_link_stats64 *stats)
 62{
 63	int i;
 64
 65	for_each_possible_cpu(i) {
 66		const struct pcpu_dstats *dstats;
 67		u64 tbytes, tpackets;
 68		unsigned int start;
 69
 70		dstats = per_cpu_ptr(dev->dstats, i);
 71		do {
 72			start = u64_stats_fetch_begin_irq(&dstats->syncp);
 73			tbytes = dstats->tx_bytes;
 74			tpackets = dstats->tx_packets;
 75		} while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
 76		stats->tx_bytes += tbytes;
 77		stats->tx_packets += tpackets;
 78	}
 79}
 80
 81static netdev_tx_t dummy_xmit(struct sk_buff *skb, struct net_device *dev)
 82{
 83	struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
 84
 85	u64_stats_update_begin(&dstats->syncp);
 86	dstats->tx_packets++;
 87	dstats->tx_bytes += skb->len;
 88	u64_stats_update_end(&dstats->syncp);
 89
 90	skb_tx_timestamp(skb);
 91	dev_kfree_skb(skb);
 92	return NETDEV_TX_OK;
 93}
 94
 95static int dummy_dev_init(struct net_device *dev)
 96{
 97	dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
 98	if (!dev->dstats)
 99		return -ENOMEM;
100
101	return 0;
102}
103
104static void dummy_dev_uninit(struct net_device *dev)
105{
106	free_percpu(dev->dstats);
107}
108
109static int dummy_change_carrier(struct net_device *dev, bool new_carrier)
110{
111	if (new_carrier)
112		netif_carrier_on(dev);
113	else
114		netif_carrier_off(dev);
115	return 0;
116}
117
118static const struct net_device_ops dummy_netdev_ops = {
119	.ndo_init		= dummy_dev_init,
120	.ndo_uninit		= dummy_dev_uninit,
121	.ndo_start_xmit		= dummy_xmit,
122	.ndo_validate_addr	= eth_validate_addr,
123	.ndo_set_rx_mode	= set_multicast_list,
124	.ndo_set_mac_address	= eth_mac_addr,
125	.ndo_get_stats64	= dummy_get_stats64,
126	.ndo_change_carrier	= dummy_change_carrier,
127};
128
129static void dummy_get_drvinfo(struct net_device *dev,
130			      struct ethtool_drvinfo *info)
131{
132	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
133	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
134}
135
 
 
 
 
 
 
 
 
 
 
 
 
136static const struct ethtool_ops dummy_ethtool_ops = {
137	.get_drvinfo            = dummy_get_drvinfo,
138	.get_ts_info		= ethtool_op_get_ts_info,
139};
140
141static void dummy_setup(struct net_device *dev)
142{
143	ether_setup(dev);
144
145	/* Initialize the device structure. */
146	dev->netdev_ops = &dummy_netdev_ops;
147	dev->ethtool_ops = &dummy_ethtool_ops;
148	dev->needs_free_netdev = true;
149
150	/* Fill in device structure with ethernet-generic values. */
151	dev->flags |= IFF_NOARP;
152	dev->flags &= ~IFF_MULTICAST;
153	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
154	dev->features	|= NETIF_F_SG | NETIF_F_FRAGLIST;
155	dev->features	|= NETIF_F_ALL_TSO;
156	dev->features	|= NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_LLTX;
157	dev->features	|= NETIF_F_GSO_ENCAP_ALL;
158	dev->hw_features |= dev->features;
159	dev->hw_enc_features |= dev->features;
160	eth_hw_addr_random(dev);
161
162	dev->min_mtu = 0;
163	dev->max_mtu = 0;
164}
165
166static int dummy_validate(struct nlattr *tb[], struct nlattr *data[],
167			  struct netlink_ext_ack *extack)
168{
169	if (tb[IFLA_ADDRESS]) {
170		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
171			return -EINVAL;
172		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
173			return -EADDRNOTAVAIL;
174	}
175	return 0;
176}
177
178static struct rtnl_link_ops dummy_link_ops __read_mostly = {
179	.kind		= DRV_NAME,
180	.setup		= dummy_setup,
181	.validate	= dummy_validate,
182};
183
184/* Number of dummy devices to be set up by this module. */
185module_param(numdummies, int, 0);
186MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");
187
188static int __init dummy_init_one(void)
189{
190	struct net_device *dev_dummy;
191	int err;
192
193	dev_dummy = alloc_netdev(0, "dummy%d", NET_NAME_ENUM, dummy_setup);
194	if (!dev_dummy)
195		return -ENOMEM;
196
197	dev_dummy->rtnl_link_ops = &dummy_link_ops;
198	err = register_netdevice(dev_dummy);
199	if (err < 0)
200		goto err;
201	return 0;
202
203err:
204	free_netdev(dev_dummy);
205	return err;
206}
207
208static int __init dummy_init_module(void)
209{
210	int i, err = 0;
211
212	down_write(&pernet_ops_rwsem);
213	rtnl_lock();
214	err = __rtnl_link_register(&dummy_link_ops);
215	if (err < 0)
216		goto out;
217
218	for (i = 0; i < numdummies && !err; i++) {
219		err = dummy_init_one();
220		cond_resched();
221	}
222	if (err < 0)
223		__rtnl_link_unregister(&dummy_link_ops);
224
225out:
226	rtnl_unlock();
227	up_write(&pernet_ops_rwsem);
228
229	return err;
230}
231
232static void __exit dummy_cleanup_module(void)
233{
234	rtnl_link_unregister(&dummy_link_ops);
235}
236
237module_init(dummy_init_module);
238module_exit(dummy_cleanup_module);
239MODULE_LICENSE("GPL");
240MODULE_ALIAS_RTNL_LINK(DRV_NAME);
241MODULE_VERSION(DRV_VERSION);