[linux-block.git] / drivers / net / loopback.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * INET		An implementation of the TCP/IP protocol suite for the LINUX
 *		operating system.  INET is implemented using the  BSD Socket
 *		interface as the means of communication with the user level.
 *
 *		Pseudo-driver for the loopback interface.
 *
 * Version:	@(#)loopback.c	1.0.4b	08/16/93
 *
 * Authors:	Ross Biro
 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *		Donald Becker, <becker@scyld.com>
 *
 *		Alan Cox	:	Fixed oddments for NET3.014
 *		Alan Cox	:	Rejig for NET3.029 snap #3
 *		Alan Cox	:	Fixed NET3.029 bugs and sped up
 *		Larry McVoy	:	Tiny tweak to double performance
 *		Alan Cox	:	Backed out LMV's tweak - the linux mm
 *					can't take it...
 *              Michael Griffith:       Don't bother computing the checksums
 *                                      on packets received on the loopback
 *                                      interface.
 *		Alexey Kuznetsov:	Potential hang under some extreme
 *					cases removed.
 */
#include <linux/kernel.h>
#include <linux/jiffies.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/socket.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/in.h>

#include <linux/uaccess.h>
#include <linux/io.h>

#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/ethtool.h>
#include <net/sch_generic.h>
#include <net/sock.h>
#include <net/checksum.h>
#include <linux/if_ether.h>	/* For the statistics structure. */
#include <linux/if_arp.h>	/* For ARPHRD_ETHER */
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/percpu.h>
#include <linux/net_tstamp.h>
#include <net/net_namespace.h>
#include <linux/u64_stats_sync.h>

/* blackhole_netdev - a device used for dsts that are marked expired!
 * This is global device (instead of per-net-ns) since it's not needed
 * to be per-ns and gets initialized at boot time.
 */
struct net_device *blackhole_netdev;
EXPORT_SYMBOL(blackhole_netdev);

/* The higher levels take care of making this non-reentrant (it's
 * called with bh's disabled).
 */
static netdev_tx_t loopback_xmit(struct sk_buff *skb,
				 struct net_device *dev)
{
	int len;

	skb_tx_timestamp(skb);

	/* do not fool net_timestamp_check() with various clock bases */
	skb_clear_tstamp(skb);

	skb_orphan(skb);

	/* Before queueing this packet to __netif_rx(),
	 * make sure dst is refcounted.
	 */
	skb_dst_force(skb);

	skb->protocol = eth_type_trans(skb, dev);

	len = skb->len;
	if (likely(__netif_rx(skb) == NET_RX_SUCCESS))
		dev_lstats_add(dev, len);

	return NETDEV_TX_OK;
}

void dev_lstats_read(struct net_device *dev, u64 *packets, u64 *bytes)
{
	int i;

	*packets = 0;
	*bytes = 0;

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

		lb_stats = per_cpu_ptr(dev->lstats, i);
		do {
			start = u64_stats_fetch_begin(&lb_stats->syncp);
			tpackets = u64_stats_read(&lb_stats->packets);
			tbytes = u64_stats_read(&lb_stats->bytes);
		} while (u64_stats_fetch_retry(&lb_stats->syncp, start));
		*bytes   += tbytes;
		*packets += tpackets;
	}
}
EXPORT_SYMBOL(dev_lstats_read);

static void loopback_get_stats64(struct net_device *dev,
				 struct rtnl_link_stats64 *stats)
{
	u64 packets, bytes;

	dev_lstats_read(dev, &packets, &bytes);

	stats->rx_packets = packets;
	stats->tx_packets = packets;
	stats->rx_bytes   = bytes;
	stats->tx_bytes   = bytes;
}

static u32 always_on(struct net_device *dev)
{
	return 1;
}

static const struct ethtool_ops loopback_ethtool_ops = {
	.get_link		= always_on,
	.get_ts_info		= ethtool_op_get_ts_info,
};

static int loopback_dev_init(struct net_device *dev)
{
	dev->lstats = netdev_alloc_pcpu_stats(struct pcpu_lstats);
	if (!dev->lstats)
		return -ENOMEM;
	return 0;
}

static void loopback_dev_free(struct net_device *dev)
{
	dev_net(dev)->loopback_dev = NULL;
	free_percpu(dev->lstats);
}

static const struct net_device_ops loopback_ops = {
	.ndo_init        = loopback_dev_init,
	.ndo_start_xmit  = loopback_xmit,
	.ndo_get_stats64 = loopback_get_stats64,
	.ndo_set_mac_address = eth_mac_addr,
};

static void gen_lo_setup(struct net_device *dev,
			 unsigned int mtu,
			 const struct ethtool_ops *eth_ops,
			 const struct header_ops *hdr_ops,
			 const struct net_device_ops *dev_ops,
			 void (*dev_destructor)(struct net_device *dev))
{
	dev->mtu		= mtu;
	dev->hard_header_len	= ETH_HLEN;	/* 14	*/
	dev->min_header_len	= ETH_HLEN;	/* 14	*/
	dev->addr_len		= ETH_ALEN;	/* 6	*/
	dev->type		= ARPHRD_LOOPBACK;	/* 0x0001*/
	dev->flags		= IFF_LOOPBACK;
	dev->priv_flags		|= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
	netif_keep_dst(dev);
	dev->hw_features	= NETIF_F_GSO_SOFTWARE;
	dev->features		= NETIF_F_SG | NETIF_F_FRAGLIST
		| NETIF_F_GSO_SOFTWARE
		| NETIF_F_HW_CSUM
		| NETIF_F_RXCSUM
		| NETIF_F_SCTP_CRC
		| NETIF_F_HIGHDMA
		| NETIF_F_LLTX
		| NETIF_F_NETNS_LOCAL
		| NETIF_F_VLAN_CHALLENGED
		| NETIF_F_LOOPBACK;
	dev->ethtool_ops	= eth_ops;
	dev->header_ops		= hdr_ops;
	dev->netdev_ops		= dev_ops;
	dev->needs_free_netdev	= true;
	dev->priv_destructor	= dev_destructor;

	netif_set_tso_max_size(dev, GSO_MAX_SIZE);
}

/* The loopback device is special. There is only one instance
 * per network namespace.
 */
static void loopback_setup(struct net_device *dev)
{
	gen_lo_setup(dev, (64 * 1024), &loopback_ethtool_ops, &eth_header_ops,
		     &loopback_ops, loopback_dev_free);
}

/* Setup and register the loopback device. */
static __net_init int loopback_net_init(struct net *net)
{
	struct net_device *dev;
	int err;

	err = -ENOMEM;
	dev = alloc_netdev(0, "lo", NET_NAME_PREDICTABLE, loopback_setup);
	if (!dev)
		goto out;

	dev_net_set(dev, net);
	err = register_netdev(dev);
	if (err)
		goto out_free_netdev;

	BUG_ON(dev->ifindex != LOOPBACK_IFINDEX);
	net->loopback_dev = dev;
	return 0;

out_free_netdev:
	free_netdev(dev);
out:
	if (net_eq(net, &init_net))
		panic("loopback: Failed to register netdevice: %d\n", err);
	return err;
}

/* Registered in net/core/dev.c */
struct pernet_operations __net_initdata loopback_net_ops = {
	.init = loopback_net_init,
};

/* blackhole netdevice */
static netdev_tx_t blackhole_netdev_xmit(struct sk_buff *skb,
					 struct net_device *dev)
{
	kfree_skb(skb);
	net_warn_ratelimited("%s(): Dropping skb.\n", __func__);
	return NETDEV_TX_OK;
}

static const struct net_device_ops blackhole_netdev_ops = {
	.ndo_start_xmit = blackhole_netdev_xmit,
};

/* This is a dst-dummy device used specifically for invalidated
 * DSTs and unlike loopback, this is not per-ns.
 */
static void blackhole_netdev_setup(struct net_device *dev)
{
	gen_lo_setup(dev, ETH_MIN_MTU, NULL, NULL, &blackhole_netdev_ops, NULL);
}

/* Setup and register the blackhole_netdev. */
static int __init blackhole_netdev_init(void)
{
	blackhole_netdev = alloc_netdev(0, "blackhole_dev", NET_NAME_UNKNOWN,
					blackhole_netdev_setup);
	if (!blackhole_netdev)
		return -ENOMEM;

	rtnl_lock();
	dev_init_scheduler(blackhole_netdev);
	dev_activate(blackhole_netdev);
	rtnl_unlock();

	blackhole_netdev->flags |= IFF_UP | IFF_RUNNING;
	dev_net_set(blackhole_netdev, &init_net);

	return 0;
}

device_initcall(blackhole_netdev_init);
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
	3	* INET An implementation of the TCP/IP protocol suite for the LINUX
	4	* operating system. INET is implemented using the BSD Socket
	5	* interface as the means of communication with the user level.
	6	*
	7	* Pseudo-driver for the loopback interface.
	8	*
	9	* Version: @(#)loopback.c 1.0.4b 08/16/93
	10	*
02c30a84	11	* Authors: Ross Biro
1da177e4 LT	12	* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
	13	* Donald Becker, <becker@scyld.com>
	14	*
	15	* Alan Cox : Fixed oddments for NET3.014
	16	* Alan Cox : Rejig for NET3.029 snap #3
b3407c8e	17	* Alan Cox : Fixed NET3.029 bugs and sped up
1da177e4 LT	18	* Larry McVoy : Tiny tweak to double performance
	19	* Alan Cox : Backed out LMV's tweak - the linux mm
	20	* can't take it...
	21	* Michael Griffith: Don't bother computing the checksums
	22	* on packets received on the loopback
	23	* interface.
	24	* Alexey Kuznetsov: Potential hang under some extreme
	25	* cases removed.
1da177e4 LT	26	*/
	27	#include <linux/kernel.h>
	28	#include <linux/jiffies.h>
	29	#include <linux/module.h>
	30	#include <linux/interrupt.h>
	31	#include <linux/fs.h>
	32	#include <linux/types.h>
	33	#include <linux/string.h>
	34	#include <linux/socket.h>
	35	#include <linux/errno.h>
	36	#include <linux/fcntl.h>
	37	#include <linux/in.h>
1da177e4	38
7c0f6ba6	39	#include <linux/uaccess.h>
b3407c8e	40	#include <linux/io.h>
1da177e4 LT	41
	42	#include <linux/inet.h>
	43	#include <linux/netdevice.h>
	44	#include <linux/etherdevice.h>
	45	#include <linux/skbuff.h>
	46	#include <linux/ethtool.h>
b6459415	47	#include <net/sch_generic.h>
1da177e4 LT	48	#include <net/sock.h>
	49	#include <net/checksum.h>
	50	#include <linux/if_ether.h> /* For the statistics structure. */
	51	#include <linux/if_arp.h> /* For ARPHRD_ETHER */
	52	#include <linux/ip.h>
	53	#include <linux/tcp.h>
	54	#include <linux/percpu.h>
6df014cf	55	#include <linux/net_tstamp.h>
2774c7ab	56	#include <net/net_namespace.h>
5eaa0bd8	57	#include <linux/u64_stats_sync.h>
1da177e4	58
4de83b88 MB	59	/* blackhole_netdev - a device used for dsts that are marked expired!
	60	* This is global device (instead of per-net-ns) since it's not needed
	61	* to be per-ns and gets initialized at boot time.
	62	*/
	63	struct net_device *blackhole_netdev;
	64	EXPORT_SYMBOL(blackhole_netdev);
	65
b3407c8e	66	/* The higher levels take care of making this non-reentrant (it's
1da177e4 LT	67	* called with bh's disabled).
1da177e4 LT	68	*/
61357325 SH	69	static netdev_tx_t loopback_xmit(struct sk_buff *skb,
61357325 SH	70	struct net_device *dev)
1da177e4	71	{
7eebb0b2	72	int len;
1da177e4	73
6df014cf	74	skb_tx_timestamp(skb);
4c16128b ED	75
4c16128b ED	76	/* do not fool net_timestamp_check() with various clock bases */
de799101	77	skb_clear_tstamp(skb);
4c16128b	78
1da177e4 LT	79	skb_orphan(skb);
1da177e4 LT	80
baebdf48	81	/* Before queueing this packet to __netif_rx(),
794ed393 ED	82	* make sure dst is refcounted.
	83	*/
	84	skb_dst_force(skb);
	85
7eebb0b2	86	skb->protocol = eth_type_trans(skb, dev);
1da177e4	87
7eebb0b2	88	len = skb->len;
baebdf48	89	if (likely(__netif_rx(skb) == NET_RX_SUCCESS))
dd5382a0	90	dev_lstats_add(dev, len);
1da177e4	91
6ed10654	92	return NETDEV_TX_OK;
1da177e4 LT	93	}
1da177e4 LT	94
de7d5084	95	void dev_lstats_read(struct net_device dev, u64 packets, u64 *bytes)
1da177e4	96	{
1da177e4 LT	97	int i;
1da177e4 LT	98
de7d5084 ED	99	*packets = 0;
	100	*bytes = 0;
	101
0fed4846	102	for_each_possible_cpu(i) {
5175c378	103	const struct pcpu_lstats *lb_stats;
5eaa0bd8 ED	104	u64 tbytes, tpackets;
5eaa0bd8 ED	105	unsigned int start;
1da177e4	106
a7855c78	107	lb_stats = per_cpu_ptr(dev->lstats, i);
5eaa0bd8	108	do {
068c38ad	109	start = u64_stats_fetch_begin(&lb_stats->syncp);
fd2f4737 ED	110	tpackets = u64_stats_read(&lb_stats->packets);
fd2f4737 ED	111	tbytes = u64_stats_read(&lb_stats->bytes);
068c38ad	112	} while (u64_stats_fetch_retry(&lb_stats->syncp, start));
de7d5084 ED	113	*bytes += tbytes;
de7d5084 ED	114	*packets += tpackets;
1da177e4	115	}
de7d5084 ED	116	}
	117	EXPORT_SYMBOL(dev_lstats_read);
	118
	119	static void loopback_get_stats64(struct net_device *dev,
	120	struct rtnl_link_stats64 *stats)
	121	{
	122	u64 packets, bytes;
	123
	124	dev_lstats_read(dev, &packets, &bytes);
	125
5175c378 ED	126	stats->rx_packets = packets;
5175c378 ED	127	stats->tx_packets = packets;
7eebb0b2 ED	128	stats->rx_bytes = bytes;
7eebb0b2 ED	129	stats->tx_bytes = bytes;
1da177e4 LT	130	}
1da177e4 LT	131
7fa6b066	132	static u32 always_on(struct net_device *dev)
1da177e4 LT	133	{
	134	return 1;
	135	}
	136
7282d491	137	static const struct ethtool_ops loopback_ethtool_ops = {
7fa6b066	138	.get_link = always_on,
af730342	139	.get_ts_info = ethtool_op_get_ts_info,
1da177e4 LT	140	};
1da177e4 LT	141
5f6d88b9 EB	142	static int loopback_dev_init(struct net_device *dev)
5f6d88b9 EB	143	{
1c213bd2	144	dev->lstats = netdev_alloc_pcpu_stats(struct pcpu_lstats);
a7855c78	145	if (!dev->lstats)
5f6d88b9	146	return -ENOMEM;
5f6d88b9 EB	147	return 0;
	148	}
	149
	150	static void loopback_dev_free(struct net_device *dev)
	151	{
e05e9070	152	dev_net(dev)->loopback_dev = NULL;
a7855c78	153	free_percpu(dev->lstats);
5f6d88b9 EB	154	}
5f6d88b9 EB	155
c02373bf	156	static const struct net_device_ops loopback_ops = {
b3407c8e ELG	157	.ndo_init = loopback_dev_init,
b3407c8e ELG	158	.ndo_start_xmit = loopback_xmit,
6b10de38	159	.ndo_get_stats64 = loopback_get_stats64,
25f929fb	160	.ndo_set_mac_address = eth_mac_addr,
c02373bf SH	161	};
c02373bf SH	162
4de83b88 MB	163	static void gen_lo_setup(struct net_device *dev,
	164	unsigned int mtu,
	165	const struct ethtool_ops *eth_ops,
	166	const struct header_ops *hdr_ops,
	167	const struct net_device_ops *dev_ops,
	168	void (dev_destructor)(struct net_device dev))
854d8363	169	{
4de83b88	170	dev->mtu = mtu;
854d8363	171	dev->hard_header_len = ETH_HLEN; /* 14 */
217e6fa2	172	dev->min_header_len = ETH_HLEN; /* 14 */
854d8363	173	dev->addr_len = ETH_ALEN; /* 6 */
854d8363	174	dev->type = ARPHRD_LOOPBACK; /* 0x0001*/
854d8363	175	dev->flags = IFF_LOOPBACK;
e65db2b7	176	dev->priv_flags \|= IFF_LIVE_ADDR_CHANGE \| IFF_NO_QUEUE;
02875878	177	netif_keep_dst(dev);
f6c382fc	178	dev->hw_features = NETIF_F_GSO_SOFTWARE;
b3407c8e	179	dev->features = NETIF_F_SG \| NETIF_F_FRAGLIST
f6c382fc	180	\| NETIF_F_GSO_SOFTWARE
34324dc2	181	\| NETIF_F_HW_CSUM
cf0bdefd	182	\| NETIF_F_RXCSUM
53692b1d	183	\| NETIF_F_SCTP_CRC
854d8363 DL	184	\| NETIF_F_HIGHDMA
854d8363 DL	185	\| NETIF_F_LLTX
0553c891	186	\| NETIF_F_NETNS_LOCAL
eed2a12f MB	187	\| NETIF_F_VLAN_CHALLENGED
eed2a12f MB	188	\| NETIF_F_LOOPBACK;
4de83b88 MB	189	dev->ethtool_ops = eth_ops;
	190	dev->header_ops = hdr_ops;
	191	dev->netdev_ops = dev_ops;
cf124db5	192	dev->needs_free_netdev = true;
4de83b88	193	dev->priv_destructor = dev_destructor;
d6f938ce ED	194
d6f938ce ED	195	netif_set_tso_max_size(dev, GSO_MAX_SIZE);
4de83b88 MB	196	}
	197
	198	/* The loopback device is special. There is only one instance
	199	* per network namespace.
	200	*/
	201	static void loopback_setup(struct net_device *dev)
	202	{
	203	gen_lo_setup(dev, (64 * 1024), &loopback_ethtool_ops, &eth_header_ops,
	204	&loopback_ops, loopback_dev_free);
854d8363	205	}
de3cb747	206
22783649	207	/* Setup and register the loopback device. */
4665079c	208	static __net_init int loopback_net_init(struct net *net)
1da177e4	209	{
854d8363 DL	210	struct net_device *dev;
	211	int err;
	212
	213	err = -ENOMEM;
31d929de	214	dev = alloc_netdev(0, "lo", NET_NAME_PREDICTABLE, loopback_setup);
854d8363 DL	215	if (!dev)
854d8363 DL	216	goto out;
aeed9e82	217
c346dca1	218	dev_net_set(dev, net);
854d8363	219	err = register_netdev(dev);
aeed9e82	220	if (err)
854d8363	221	goto out_free_netdev;
aeed9e82	222
1fb9489b	223	BUG_ON(dev->ifindex != LOOPBACK_IFINDEX);
2774c7ab	224	net->loopback_dev = dev;
9d6dda32	225	return 0;
854d8363	226
854d8363 DL	227	out_free_netdev:
854d8363 DL	228	free_netdev(dev);
9d6dda32	229	out:
09ad9bc7	230	if (net_eq(net, &init_net))
9d6dda32 PE	231	panic("loopback: Failed to register netdevice: %d\n", err);
9d6dda32 PE	232	return err;
854d8363 DL	233	}
854d8363 DL	234
505d4f73 EB	235	/* Registered in net/core/dev.c */
505d4f73 EB	236	struct pernet_operations __net_initdata loopback_net_ops = {
b3407c8e	237	.init = loopback_net_init,
2774c7ab	238	};
4de83b88 MB	239
	240	/* blackhole netdevice */
	241	static netdev_tx_t blackhole_netdev_xmit(struct sk_buff *skb,
	242	struct net_device *dev)
	243	{
	244	kfree_skb(skb);
	245	net_warn_ratelimited("%s(): Dropping skb.\n", __func__);
	246	return NETDEV_TX_OK;
	247	}
	248
	249	static const struct net_device_ops blackhole_netdev_ops = {
	250	.ndo_start_xmit = blackhole_netdev_xmit,
	251	};
	252
	253	/* This is a dst-dummy device used specifically for invalidated
	254	* DSTs and unlike loopback, this is not per-ns.
	255	*/
	256	static void blackhole_netdev_setup(struct net_device *dev)
	257	{
	258	gen_lo_setup(dev, ETH_MIN_MTU, NULL, NULL, &blackhole_netdev_ops, NULL);
	259	}
	260
	261	/* Setup and register the blackhole_netdev. */
	262	static int __init blackhole_netdev_init(void)
	263	{
	264	blackhole_netdev = alloc_netdev(0, "blackhole_dev", NET_NAME_UNKNOWN,
	265	blackhole_netdev_setup);
	266	if (!blackhole_netdev)
	267	return -ENOMEM;
	268
d62962b3	269	rtnl_lock();
4de83b88 MB	270	dev_init_scheduler(blackhole_netdev);
4de83b88 MB	271	dev_activate(blackhole_netdev);
d62962b3	272	rtnl_unlock();
4de83b88 MB	273
	274	blackhole_netdev->flags \|= IFF_UP \| IFF_RUNNING;
	275	dev_net_set(blackhole_netdev, &init_net);
	276
	277	return 0;
	278	}
	279
	280	device_initcall(blackhole_netdev_init);