loopback.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239
  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. *
  10. * Authors: Ross Biro
  11. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12. * Donald Becker, <becker@scyld.com>
  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. #include <asm/system.h>
  44. #include <asm/uaccess.h>
  45. #include <asm/io.h>
  46. #include <linux/inet.h>
  47. #include <linux/netdevice.h>
  48. #include <linux/etherdevice.h>
  49. #include <linux/skbuff.h>
  50. #include <linux/ethtool.h>
  51. #include <net/sock.h>
  52. #include <net/checksum.h>
  53. #include <linux/if_ether.h> /* For the statistics structure. */
  54. #include <linux/if_arp.h> /* For ARPHRD_ETHER */
  55. #include <linux/ip.h>
  56. #include <linux/tcp.h>
  57. #include <linux/percpu.h>
  58. struct pcpu_lstats {
  59. unsigned long packets;
  60. unsigned long bytes;
  61. };
  62. static DEFINE_PER_CPU(struct pcpu_lstats, pcpu_lstats);
  63. #define LOOPBACK_OVERHEAD (128 + MAX_HEADER + 16 + 16)
  64. /* KISS: just allocate small chunks and copy bits.
  65. *
  66. * So, in fact, this is documentation, explaining what we expect
  67. * of largesending device modulo TCP checksum, which is ignored for loopback.
  68. */
  69. #ifdef LOOPBACK_TSO
  70. static void emulate_large_send_offload(struct sk_buff *skb)
  71. {
  72. struct iphdr *iph = skb->nh.iph;
  73. struct tcphdr *th = (struct tcphdr*)(skb->nh.raw + (iph->ihl * 4));
  74. unsigned int doffset = (iph->ihl + th->doff) * 4;
  75. unsigned int mtu = skb_shinfo(skb)->gso_size + doffset;
  76. unsigned int offset = 0;
  77. u32 seq = ntohl(th->seq);
  78. u16 id = ntohs(iph->id);
  79. while (offset + doffset < skb->len) {
  80. unsigned int frag_size = min(mtu, skb->len - offset) - doffset;
  81. struct sk_buff *nskb = alloc_skb(mtu + 32, GFP_ATOMIC);
  82. if (!nskb)
  83. break;
  84. skb_reserve(nskb, 32);
  85. nskb->mac.raw = nskb->data - 14;
  86. nskb->nh.raw = nskb->data;
  87. iph = nskb->nh.iph;
  88. memcpy(nskb->data, skb->nh.raw, doffset);
  89. if (skb_copy_bits(skb,
  90. doffset + offset,
  91. nskb->data + doffset,
  92. frag_size))
  93. BUG();
  94. skb_put(nskb, doffset + frag_size);
  95. nskb->ip_summed = CHECKSUM_UNNECESSARY;
  96. nskb->dev = skb->dev;
  97. nskb->priority = skb->priority;
  98. nskb->protocol = skb->protocol;
  99. nskb->dst = dst_clone(skb->dst);
  100. memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
  101. nskb->pkt_type = skb->pkt_type;
  102. th = (struct tcphdr*)(nskb->nh.raw + iph->ihl*4);
  103. iph->tot_len = htons(frag_size + doffset);
  104. iph->id = htons(id);
  105. iph->check = 0;
  106. iph->check = ip_fast_csum((unsigned char *) iph, iph->ihl);
  107. th->seq = htonl(seq);
  108. if (offset + doffset + frag_size < skb->len)
  109. th->fin = th->psh = 0;
  110. netif_rx(nskb);
  111. offset += frag_size;
  112. seq += frag_size;
  113. id++;
  114. }
  115. dev_kfree_skb(skb);
  116. }
  117. #endif /* LOOPBACK_TSO */
  118. /*
  119. * The higher levels take care of making this non-reentrant (it's
  120. * called with bh's disabled).
  121. */
  122. static int loopback_xmit(struct sk_buff *skb, struct net_device *dev)
  123. {
  124. struct pcpu_lstats *lb_stats;
  125. skb_orphan(skb);
  126. skb->protocol = eth_type_trans(skb,dev);
  127. skb->dev = dev;
  128. #ifndef LOOPBACK_MUST_CHECKSUM
  129. skb->ip_summed = CHECKSUM_UNNECESSARY;
  130. #endif
  131. #ifdef LOOPBACK_TSO
  132. if (skb_is_gso(skb)) {
  133. BUG_ON(skb->protocol != htons(ETH_P_IP));
  134. BUG_ON(skb->nh.iph->protocol != IPPROTO_TCP);
  135. emulate_large_send_offload(skb);
  136. return 0;
  137. }
  138. #endif
  139. dev->last_rx = jiffies;
  140. /* it's OK to use __get_cpu_var() because BHs are off */
  141. lb_stats = &__get_cpu_var(pcpu_lstats);
  142. lb_stats->bytes += skb->len;
  143. lb_stats->packets++;
  144. netif_rx(skb);
  145. return 0;
  146. }
  147. static struct net_device_stats loopback_stats;
  148. static struct net_device_stats *get_stats(struct net_device *dev)
  149. {
  150. struct net_device_stats *stats = &loopback_stats;
  151. unsigned long bytes = 0;
  152. unsigned long packets = 0;
  153. int i;
  154. for_each_possible_cpu(i) {
  155. const struct pcpu_lstats *lb_stats;
  156. lb_stats = &per_cpu(pcpu_lstats, i);
  157. bytes += lb_stats->bytes;
  158. packets += lb_stats->packets;
  159. }
  160. stats->rx_packets = packets;
  161. stats->tx_packets = packets;
  162. stats->rx_bytes = bytes;
  163. stats->tx_bytes = bytes;
  164. return stats;
  165. }
  166. static u32 always_on(struct net_device *dev)
  167. {
  168. return 1;
  169. }
  170. static const struct ethtool_ops loopback_ethtool_ops = {
  171. .get_link = always_on,
  172. .get_tso = ethtool_op_get_tso,
  173. .set_tso = ethtool_op_set_tso,
  174. .get_tx_csum = always_on,
  175. .get_sg = always_on,
  176. .get_rx_csum = always_on,
  177. };
  178. /*
  179. * The loopback device is special. There is only one instance and
  180. * it is statically allocated. Don't do this for other devices.
  181. */
  182. struct net_device loopback_dev = {
  183. .name = "lo",
  184. .get_stats = &get_stats,
  185. .priv = &loopback_stats,
  186. .mtu = (16 * 1024) + 20 + 20 + 12,
  187. .hard_start_xmit = loopback_xmit,
  188. .hard_header = eth_header,
  189. .hard_header_cache = eth_header_cache,
  190. .header_cache_update = eth_header_cache_update,
  191. .hard_header_len = ETH_HLEN, /* 14 */
  192. .addr_len = ETH_ALEN, /* 6 */
  193. .tx_queue_len = 0,
  194. .type = ARPHRD_LOOPBACK, /* 0x0001*/
  195. .rebuild_header = eth_rebuild_header,
  196. .flags = IFF_LOOPBACK,
  197. .features = NETIF_F_SG | NETIF_F_FRAGLIST
  198. #ifdef LOOPBACK_TSO
  199. | NETIF_F_TSO
  200. #endif
  201. | NETIF_F_NO_CSUM | NETIF_F_HIGHDMA
  202. | NETIF_F_LLTX,
  203. .ethtool_ops = &loopback_ethtool_ops,
  204. };
  205. /* Setup and register the loopback device. */
  206. static int __init loopback_init(void)
  207. {
  208. return register_netdev(&loopback_dev);
  209. };
  210. module_init(loopback_init);
  211. EXPORT_SYMBOL(loopback_dev);