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

/*
 * 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, <[email protected]>
 *		Donald Becker, <[email protected]>
 *
 *		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.
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 */
#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/init.h>

#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/ethtool.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>

static DEFINE_PER_CPU(struct net_device_stats, loopback_stats);

#define LOOPBACK_OVERHEAD (128 + MAX_HEADER + 16 + 16)

/* KISS: just allocate small chunks and copy bits.
 *
 * So, in fact, this is documentation, explaining what we expect
 * of largesending device modulo TCP checksum, which is ignored for loopback.
 */

#ifdef LOOPBACK_TSO
static void emulate_large_send_offload(struct sk_buff *skb)
{
	struct iphdr *iph = skb->nh.iph;
	struct tcphdr *th = (struct tcphdr*)(skb->nh.raw + (iph->ihl * 4));
	unsigned int doffset = (iph->ihl + th->doff) * 4;
	unsigned int mtu = skb_shinfo(skb)->tso_size + doffset;
	unsigned int offset = 0;
	u32 seq = ntohl(th->seq);
	u16 id  = ntohs(iph->id);

	while (offset + doffset < skb->len) {
		unsigned int frag_size = min(mtu, skb->len - offset) - doffset;
		struct sk_buff *nskb = alloc_skb(mtu + 32, GFP_ATOMIC);

		if (!nskb)
			break;
		skb_reserve(nskb, 32);
		nskb->mac.raw = nskb->data - 14;
		nskb->nh.raw = nskb->data;
		iph = nskb->nh.iph;
		memcpy(nskb->data, skb->nh.raw, doffset);
		if (skb_copy_bits(skb,
				  doffset + offset,
				  nskb->data + doffset,
				  frag_size))
			BUG();
		skb_put(nskb, doffset + frag_size);
		nskb->ip_summed = CHECKSUM_UNNECESSARY;
		nskb->dev = skb->dev;
		nskb->priority = skb->priority;
		nskb->protocol = skb->protocol;
		nskb->dst = dst_clone(skb->dst);
		memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
		nskb->pkt_type = skb->pkt_type;

		th = (struct tcphdr*)(nskb->nh.raw + iph->ihl*4);
		iph->tot_len = htons(frag_size + doffset);
		iph->id = htons(id);
		iph->check = 0;
		iph->check = ip_fast_csum((unsigned char *) iph, iph->ihl);
		th->seq = htonl(seq);
		if (offset + doffset + frag_size < skb->len)
			th->fin = th->psh = 0;
		netif_rx(nskb);
		offset += frag_size;
		seq += frag_size;
		id++;
	}

	dev_kfree_skb(skb);
}
#endif /* LOOPBACK_TSO */

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

	skb_orphan(skb);

	skb->protocol = eth_type_trans(skb,dev);
	skb->dev = dev;
#ifndef LOOPBACK_MUST_CHECKSUM
	skb->ip_summed = CHECKSUM_UNNECESSARY;
#endif

#ifdef LOOPBACK_TSO
	if (skb_shinfo(skb)->tso_size) {
		BUG_ON(skb->protocol != htons(ETH_P_IP));
		BUG_ON(skb->nh.iph->protocol != IPPROTO_TCP);

		emulate_large_send_offload(skb);
		return 0;
	}
#endif
	dev->last_rx = jiffies;

	lb_stats = &per_cpu(loopback_stats, get_cpu());
	lb_stats->rx_bytes += skb->len;
	lb_stats->tx_bytes = lb_stats->rx_bytes;
	lb_stats->rx_packets++;
	lb_stats->tx_packets = lb_stats->rx_packets;
	put_cpu();

	netif_rx(skb);

	return(0);
}

static struct net_device_stats *get_stats(struct net_device *dev)
{
	struct net_device_stats *stats = dev->priv;
	int i;

	if (!stats) {
		return NULL;
	}

	memset(stats, 0, sizeof(struct net_device_stats));

	for (i=0; i < NR_CPUS; i++) {
		struct net_device_stats *lb_stats;

		if (!cpu_possible(i)) 
			continue;
		lb_stats = &per_cpu(loopback_stats, i);
		stats->rx_bytes   += lb_stats->rx_bytes;
		stats->tx_bytes   += lb_stats->tx_bytes;
		stats->rx_packets += lb_stats->rx_packets;
		stats->tx_packets += lb_stats->tx_packets;
	}
				
	return stats;
}

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

static struct ethtool_ops loopback_ethtool_ops = {
	.get_link		= loopback_get_link,
	.get_tso		= ethtool_op_get_tso,
	.set_tso		= ethtool_op_set_tso,
};

struct net_device loopback_dev = {
	.name	 		= "lo",
	.mtu			= (16 * 1024) + 20 + 20 + 12,
	.hard_start_xmit	= loopback_xmit,
	.hard_header		= eth_header,
	.hard_header_cache	= eth_header_cache,
	.header_cache_update	= eth_header_cache_update,
	.hard_header_len	= ETH_HLEN,	/* 14	*/
	.addr_len		= ETH_ALEN,	/* 6	*/
	.tx_queue_len		= 0,
	.type			= ARPHRD_LOOPBACK,	/* 0x0001*/
	.rebuild_header		= eth_rebuild_header,
	.flags			= IFF_LOOPBACK,
	.features 		= NETIF_F_SG | NETIF_F_FRAGLIST
#ifdef LOOPBACK_TSO
				  | NETIF_F_TSO
#endif
				  | NETIF_F_NO_CSUM | NETIF_F_HIGHDMA
				  | NETIF_F_LLTX,
	.ethtool_ops		= &loopback_ethtool_ops,
};

/* Setup and register the loopback device. */
int __init loopback_init(void)
{
	struct net_device_stats *stats;

	/* Can survive without statistics */
	stats = kmalloc(sizeof(struct net_device_stats), GFP_KERNEL);
	if (stats) {
		memset(stats, 0, sizeof(struct net_device_stats));
		loopback_dev.priv = stats;
		loopback_dev.get_stats = &get_stats;
	}
	
	return register_netdev(&loopback_dev);
};

EXPORT_SYMBOL(loopback_dev);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* INET An implementation of the TCP/IP protocol suite for the LINUX
	3	* operating system. INET is implemented using the BSD Socket
	4	* interface as the means of communication with the user level.
	5	*
	6	* Pseudo-driver for the loopback interface.
	7	*
	8	* Version: @(#)loopback.c 1.0.4b 08/16/93
	9	*
02c30a84	10	* Authors: Ross Biro
1da177e4 LT	11	* Fred N. van Kempen, <[email protected]>
	12	* Donald Becker, <[email protected]>
	13	*
	14	* Alan Cox : Fixed oddments for NET3.014
	15	* Alan Cox : Rejig for NET3.029 snap #3
	16	* Alan Cox : Fixed NET3.029 bugs and sped up
	17	* Larry McVoy : Tiny tweak to double performance
	18	* Alan Cox : Backed out LMV's tweak - the linux mm
	19	* can't take it...
	20	* Michael Griffith: Don't bother computing the checksums
	21	* on packets received on the loopback
	22	* interface.
	23	* Alexey Kuznetsov: Potential hang under some extreme
	24	* cases removed.
	25	*
	26	* This program is free software; you can redistribute it and/or
	27	* modify it under the terms of the GNU General Public License
	28	* as published by the Free Software Foundation; either version
	29	* 2 of the License, or (at your option) any later version.
	30	*/
	31	#include <linux/kernel.h>
	32	#include <linux/jiffies.h>
	33	#include <linux/module.h>
	34	#include <linux/interrupt.h>
	35	#include <linux/fs.h>
	36	#include <linux/types.h>
	37	#include <linux/string.h>
	38	#include <linux/socket.h>
	39	#include <linux/errno.h>
	40	#include <linux/fcntl.h>
	41	#include <linux/in.h>
	42	#include <linux/init.h>
	43
	44	#include <asm/system.h>
	45	#include <asm/uaccess.h>
	46	#include <asm/io.h>
	47
	48	#include <linux/inet.h>
	49	#include <linux/netdevice.h>
	50	#include <linux/etherdevice.h>
	51	#include <linux/skbuff.h>
	52	#include <linux/ethtool.h>
	53	#include <net/sock.h>
	54	#include <net/checksum.h>
	55	#include <linux/if_ether.h> /* For the statistics structure. */
	56	#include <linux/if_arp.h> /* For ARPHRD_ETHER */
	57	#include <linux/ip.h>
	58	#include <linux/tcp.h>
	59	#include <linux/percpu.h>
	60
	61	static DEFINE_PER_CPU(struct net_device_stats, loopback_stats);
	62
	63	#define LOOPBACK_OVERHEAD (128 + MAX_HEADER + 16 + 16)
	64
	65	/* KISS: just allocate small chunks and copy bits.
	66	*
	67	* So, in fact, this is documentation, explaining what we expect
	68	* of largesending device modulo TCP checksum, which is ignored for loopback.
	69	*/
	70
d2ae1d2f	71	#ifdef LOOPBACK_TSO
1da177e4 LT	72	static void emulate_large_send_offload(struct sk_buff *skb)
	73	{
	74	struct iphdr *iph = skb->nh.iph;
	75	struct tcphdr th = (struct tcphdr)(skb->nh.raw + (iph->ihl * 4));
	76	unsigned int doffset = (iph->ihl + th->doff) * 4;
	77	unsigned int mtu = skb_shinfo(skb)->tso_size + doffset;
	78	unsigned int offset = 0;
	79	u32 seq = ntohl(th->seq);
	80	u16 id = ntohs(iph->id);
	81
	82	while (offset + doffset < skb->len) {
	83	unsigned int frag_size = min(mtu, skb->len - offset) - doffset;
	84	struct sk_buff *nskb = alloc_skb(mtu + 32, GFP_ATOMIC);
	85
	86	if (!nskb)
	87	break;
	88	skb_reserve(nskb, 32);
	89	nskb->mac.raw = nskb->data - 14;
	90	nskb->nh.raw = nskb->data;
	91	iph = nskb->nh.iph;
	92	memcpy(nskb->data, skb->nh.raw, doffset);
	93	if (skb_copy_bits(skb,
	94	doffset + offset,
	95	nskb->data + doffset,
	96	frag_size))
	97	BUG();
	98	skb_put(nskb, doffset + frag_size);
	99	nskb->ip_summed = CHECKSUM_UNNECESSARY;
	100	nskb->dev = skb->dev;
	101	nskb->priority = skb->priority;
	102	nskb->protocol = skb->protocol;
	103	nskb->dst = dst_clone(skb->dst);
	104	memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
	105	nskb->pkt_type = skb->pkt_type;
	106
	107	th = (struct tcphdr)(nskb->nh.raw + iph->ihl4);
	108	iph->tot_len = htons(frag_size + doffset);
	109	iph->id = htons(id);
	110	iph->check = 0;
	111	iph->check = ip_fast_csum((unsigned char *) iph, iph->ihl);
	112	th->seq = htonl(seq);
	113	if (offset + doffset + frag_size < skb->len)
	114	th->fin = th->psh = 0;
	115	netif_rx(nskb);
	116	offset += frag_size;
	117	seq += frag_size;
	118	id++;
	119	}
	120
	121	dev_kfree_skb(skb);
	122	}
d2ae1d2f	123	#endif /* LOOPBACK_TSO */
1da177e4 LT	124
	125	/*
	126	* The higher levels take care of making this non-reentrant (it's
	127	* called with bh's disabled).
	128	*/
	129	static int loopback_xmit(struct sk_buff skb, struct net_device dev)
	130	{
	131	struct net_device_stats *lb_stats;
	132
	133	skb_orphan(skb);
	134
0e920bfb CE	135	skb->protocol = eth_type_trans(skb,dev);
0e920bfb CE	136	skb->dev = dev;
1da177e4 LT	137	#ifndef LOOPBACK_MUST_CHECKSUM
	138	skb->ip_summed = CHECKSUM_UNNECESSARY;
	139	#endif
	140
d2ae1d2f	141	#ifdef LOOPBACK_TSO
1da177e4 LT	142	if (skb_shinfo(skb)->tso_size) {
	143	BUG_ON(skb->protocol != htons(ETH_P_IP));
	144	BUG_ON(skb->nh.iph->protocol != IPPROTO_TCP);
	145
	146	emulate_large_send_offload(skb);
	147	return 0;
	148	}
d2ae1d2f	149	#endif
1da177e4 LT	150	dev->last_rx = jiffies;
	151
	152	lb_stats = &per_cpu(loopback_stats, get_cpu());
	153	lb_stats->rx_bytes += skb->len;
18c16c69	154	lb_stats->tx_bytes = lb_stats->rx_bytes;
1da177e4	155	lb_stats->rx_packets++;
18c16c69	156	lb_stats->tx_packets = lb_stats->rx_packets;
1da177e4 LT	157	put_cpu();
	158
	159	netif_rx(skb);
	160
	161	return(0);
	162	}
	163
	164	static struct net_device_stats get_stats(struct net_device dev)
	165	{
	166	struct net_device_stats *stats = dev->priv;
	167	int i;
	168
	169	if (!stats) {
	170	return NULL;
	171	}
	172
	173	memset(stats, 0, sizeof(struct net_device_stats));
	174
	175	for (i=0; i < NR_CPUS; i++) {
	176	struct net_device_stats *lb_stats;
	177
	178	if (!cpu_possible(i))
	179	continue;
	180	lb_stats = &per_cpu(loopback_stats, i);
	181	stats->rx_bytes += lb_stats->rx_bytes;
	182	stats->tx_bytes += lb_stats->tx_bytes;
	183	stats->rx_packets += lb_stats->rx_packets;
	184	stats->tx_packets += lb_stats->tx_packets;
	185	}
	186
	187	return stats;
	188	}
	189
	190	static u32 loopback_get_link(struct net_device *dev)
	191	{
	192	return 1;
	193	}
	194
	195	static struct ethtool_ops loopback_ethtool_ops = {
	196	.get_link = loopback_get_link,
	197	.get_tso = ethtool_op_get_tso,
	198	.set_tso = ethtool_op_set_tso,
	199	};
	200
	201	struct net_device loopback_dev = {
	202	.name = "lo",
	203	.mtu = (16 * 1024) + 20 + 20 + 12,
	204	.hard_start_xmit = loopback_xmit,
	205	.hard_header = eth_header,
	206	.hard_header_cache = eth_header_cache,
	207	.header_cache_update = eth_header_cache_update,
	208	.hard_header_len = ETH_HLEN, /* 14 */
	209	.addr_len = ETH_ALEN, /* 6 */
	210	.tx_queue_len = 0,
	211	.type = ARPHRD_LOOPBACK, /* 0x0001*/
	212	.rebuild_header = eth_rebuild_header,
	213	.flags = IFF_LOOPBACK,
0e920bfb	214	.features = NETIF_F_SG \| NETIF_F_FRAGLIST
d2ae1d2f	215	#ifdef LOOPBACK_TSO
0e920bfb	216	\| NETIF_F_TSO
d2ae1d2f	217	#endif
0e920bfb CE	218	\| NETIF_F_NO_CSUM \| NETIF_F_HIGHDMA
0e920bfb CE	219	\| NETIF_F_LLTX,
1da177e4 LT	220	.ethtool_ops = &loopback_ethtool_ops,
	221	};
	222
22783649	223	/* Setup and register the loopback device. */
1da177e4 LT	224	int __init loopback_init(void)
	225	{
	226	struct net_device_stats *stats;
	227
	228	/* Can survive without statistics */
	229	stats = kmalloc(sizeof(struct net_device_stats), GFP_KERNEL);
	230	if (stats) {
	231	memset(stats, 0, sizeof(struct net_device_stats));
	232	loopback_dev.priv = stats;
	233	loopback_dev.get_stats = &get_stats;
	234	}
	235
	236	return register_netdev(&loopback_dev);
	237	};
	238
	239	EXPORT_SYMBOL(loopback_dev);