LCOV - code coverage report
Current view: top level - drivers/net - loopback.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 72 100 72.0 %
Date: 2022-04-01 14:17:54 Functions: 7 11 63.6 %
Branches: 10 24 41.7 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       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                 :            :  *
      11                 :            :  * Authors:     Ross Biro
      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
      17                 :            :  *              Alan Cox        :       Fixed NET3.029 bugs and sped up
      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.
      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>
      38                 :            : 
      39                 :            : #include <linux/uaccess.h>
      40                 :            : #include <linux/io.h>
      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>
      47                 :            : #include <net/sock.h>
      48                 :            : #include <net/checksum.h>
      49                 :            : #include <linux/if_ether.h>       /* For the statistics structure. */
      50                 :            : #include <linux/if_arp.h> /* For ARPHRD_ETHER */
      51                 :            : #include <linux/ip.h>
      52                 :            : #include <linux/tcp.h>
      53                 :            : #include <linux/percpu.h>
      54                 :            : #include <linux/net_tstamp.h>
      55                 :            : #include <net/net_namespace.h>
      56                 :            : #include <linux/u64_stats_sync.h>
      57                 :            : 
      58                 :            : /* blackhole_netdev - a device used for dsts that are marked expired!
      59                 :            :  * This is global device (instead of per-net-ns) since it's not needed
      60                 :            :  * to be per-ns and gets initialized at boot time.
      61                 :            :  */
      62                 :            : struct net_device *blackhole_netdev;
      63                 :            : EXPORT_SYMBOL(blackhole_netdev);
      64                 :            : 
      65                 :            : /* The higher levels take care of making this non-reentrant (it's
      66                 :            :  * called with bh's disabled).
      67                 :            :  */
      68                 :          0 : static netdev_tx_t loopback_xmit(struct sk_buff *skb,
      69                 :            :                                  struct net_device *dev)
      70                 :            : {
      71                 :          0 :         int len;
      72                 :            : 
      73         [ #  # ]:          0 :         skb_tx_timestamp(skb);
      74                 :            : 
      75                 :            :         /* do not fool net_timestamp_check() with various clock bases */
      76                 :          0 :         skb->tstamp = 0;
      77                 :            : 
      78                 :          0 :         skb_orphan(skb);
      79                 :            : 
      80                 :            :         /* Before queueing this packet to netif_rx(),
      81                 :            :          * make sure dst is refcounted.
      82                 :            :          */
      83                 :          0 :         skb_dst_force(skb);
      84                 :            : 
      85                 :          0 :         skb->protocol = eth_type_trans(skb, dev);
      86                 :            : 
      87                 :          0 :         len = skb->len;
      88         [ #  # ]:          0 :         if (likely(netif_rx(skb) == NET_RX_SUCCESS))
      89                 :          0 :                 dev_lstats_add(dev, len);
      90                 :            : 
      91                 :          0 :         return NETDEV_TX_OK;
      92                 :            : }
      93                 :            : 
      94                 :         77 : void dev_lstats_read(struct net_device *dev, u64 *packets, u64 *bytes)
      95                 :            : {
      96                 :         77 :         int i;
      97                 :            : 
      98                 :         77 :         *packets = 0;
      99                 :         77 :         *bytes = 0;
     100                 :            : 
     101         [ +  + ]:        154 :         for_each_possible_cpu(i) {
     102                 :         77 :                 const struct pcpu_lstats *lb_stats;
     103                 :         77 :                 u64 tbytes, tpackets;
     104                 :         77 :                 unsigned int start;
     105                 :            : 
     106                 :         77 :                 lb_stats = per_cpu_ptr(dev->lstats, i);
     107                 :         77 :                 do {
     108                 :         77 :                         start = u64_stats_fetch_begin_irq(&lb_stats->syncp);
     109                 :         77 :                         tpackets = u64_stats_read(&lb_stats->packets);
     110                 :         77 :                         tbytes = u64_stats_read(&lb_stats->bytes);
     111                 :         77 :                 } while (u64_stats_fetch_retry_irq(&lb_stats->syncp, start));
     112                 :         77 :                 *bytes   += tbytes;
     113                 :         77 :                 *packets += tpackets;
     114                 :            :         }
     115                 :         77 : }
     116                 :            : EXPORT_SYMBOL(dev_lstats_read);
     117                 :            : 
     118                 :         77 : static void loopback_get_stats64(struct net_device *dev,
     119                 :            :                                  struct rtnl_link_stats64 *stats)
     120                 :            : {
     121                 :         77 :         u64 packets, bytes;
     122                 :            : 
     123                 :         77 :         dev_lstats_read(dev, &packets, &bytes);
     124                 :            : 
     125                 :         77 :         stats->rx_packets = packets;
     126                 :         77 :         stats->tx_packets = packets;
     127                 :         77 :         stats->rx_bytes   = bytes;
     128                 :         77 :         stats->tx_bytes   = bytes;
     129                 :         77 : }
     130                 :            : 
     131                 :          0 : static u32 always_on(struct net_device *dev)
     132                 :            : {
     133                 :          0 :         return 1;
     134                 :            : }
     135                 :            : 
     136                 :            : static const struct ethtool_ops loopback_ethtool_ops = {
     137                 :            :         .get_link               = always_on,
     138                 :            :         .get_ts_info            = ethtool_op_get_ts_info,
     139                 :            : };
     140                 :            : 
     141                 :         11 : static int loopback_dev_init(struct net_device *dev)
     142                 :            : {
     143   [ +  -  +  + ]:         22 :         dev->lstats = netdev_alloc_pcpu_stats(struct pcpu_lstats);
     144         [ -  + ]:         11 :         if (!dev->lstats)
     145                 :          0 :                 return -ENOMEM;
     146                 :            :         return 0;
     147                 :            : }
     148                 :            : 
     149                 :          0 : static void loopback_dev_free(struct net_device *dev)
     150                 :            : {
     151                 :          0 :         dev_net(dev)->loopback_dev = NULL;
     152                 :          0 :         free_percpu(dev->lstats);
     153                 :          0 : }
     154                 :            : 
     155                 :            : static const struct net_device_ops loopback_ops = {
     156                 :            :         .ndo_init        = loopback_dev_init,
     157                 :            :         .ndo_start_xmit  = loopback_xmit,
     158                 :            :         .ndo_get_stats64 = loopback_get_stats64,
     159                 :            :         .ndo_set_mac_address = eth_mac_addr,
     160                 :            : };
     161                 :            : 
     162                 :         22 : static void gen_lo_setup(struct net_device *dev,
     163                 :            :                          unsigned int mtu,
     164                 :            :                          const struct ethtool_ops *eth_ops,
     165                 :            :                          const struct header_ops *hdr_ops,
     166                 :            :                          const struct net_device_ops *dev_ops,
     167                 :            :                          void (*dev_destructor)(struct net_device *dev))
     168                 :            : {
     169                 :         22 :         dev->mtu             = mtu;
     170                 :         22 :         dev->hard_header_len = ETH_HLEN;     /* 14   */
     171                 :         22 :         dev->min_header_len  = ETH_HLEN;     /* 14   */
     172                 :         22 :         dev->addr_len                = ETH_ALEN;     /* 6    */
     173                 :         22 :         dev->type            = ARPHRD_LOOPBACK;      /* 0x0001*/
     174                 :         22 :         dev->flags           = IFF_LOOPBACK;
     175                 :         22 :         dev->priv_flags              |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
     176                 :         22 :         netif_keep_dst(dev);
     177                 :         22 :         dev->hw_features     = NETIF_F_GSO_SOFTWARE;
     178                 :         22 :         dev->features                = NETIF_F_SG | NETIF_F_FRAGLIST
     179                 :            :                 | NETIF_F_GSO_SOFTWARE
     180                 :            :                 | NETIF_F_HW_CSUM
     181                 :            :                 | NETIF_F_RXCSUM
     182                 :            :                 | NETIF_F_SCTP_CRC
     183                 :            :                 | NETIF_F_HIGHDMA
     184                 :            :                 | NETIF_F_LLTX
     185                 :            :                 | NETIF_F_NETNS_LOCAL
     186                 :            :                 | NETIF_F_VLAN_CHALLENGED
     187                 :            :                 | NETIF_F_LOOPBACK;
     188                 :         22 :         dev->ethtool_ops     = eth_ops;
     189                 :         22 :         dev->header_ops              = hdr_ops;
     190                 :         22 :         dev->netdev_ops              = dev_ops;
     191                 :         22 :         dev->needs_free_netdev       = true;
     192                 :         22 :         dev->priv_destructor = dev_destructor;
     193                 :            : }
     194                 :            : 
     195                 :            : /* The loopback device is special. There is only one instance
     196                 :            :  * per network namespace.
     197                 :            :  */
     198                 :         11 : static void loopback_setup(struct net_device *dev)
     199                 :            : {
     200                 :         11 :         gen_lo_setup(dev, (64 * 1024), &loopback_ethtool_ops, &eth_header_ops,
     201                 :            :                      &loopback_ops, loopback_dev_free);
     202                 :         11 : }
     203                 :            : 
     204                 :            : /* Setup and register the loopback device. */
     205                 :         11 : static __net_init int loopback_net_init(struct net *net)
     206                 :            : {
     207                 :         11 :         struct net_device *dev;
     208                 :         11 :         int err;
     209                 :            : 
     210                 :         11 :         err = -ENOMEM;
     211                 :         11 :         dev = alloc_netdev(0, "lo", NET_NAME_UNKNOWN, loopback_setup);
     212         [ -  + ]:         11 :         if (!dev)
     213                 :          0 :                 goto out;
     214                 :            : 
     215                 :         11 :         dev_net_set(dev, net);
     216                 :         11 :         err = register_netdev(dev);
     217         [ -  + ]:         11 :         if (err)
     218                 :          0 :                 goto out_free_netdev;
     219                 :            : 
     220         [ -  + ]:         11 :         BUG_ON(dev->ifindex != LOOPBACK_IFINDEX);
     221                 :         11 :         net->loopback_dev = dev;
     222                 :         11 :         return 0;
     223                 :            : 
     224                 :            : out_free_netdev:
     225                 :          0 :         free_netdev(dev);
     226                 :          0 : out:
     227         [ #  # ]:          0 :         if (net_eq(net, &init_net))
     228                 :          0 :                 panic("loopback: Failed to register netdevice: %d\n", err);
     229                 :            :         return err;
     230                 :            : }
     231                 :            : 
     232                 :            : /* Registered in net/core/dev.c */
     233                 :            : struct pernet_operations __net_initdata loopback_net_ops = {
     234                 :            :         .init = loopback_net_init,
     235                 :            : };
     236                 :            : 
     237                 :            : /* blackhole netdevice */
     238                 :          0 : static netdev_tx_t blackhole_netdev_xmit(struct sk_buff *skb,
     239                 :            :                                          struct net_device *dev)
     240                 :            : {
     241                 :          0 :         kfree_skb(skb);
     242         [ #  # ]:          0 :         net_warn_ratelimited("%s(): Dropping skb.\n", __func__);
     243                 :          0 :         return NETDEV_TX_OK;
     244                 :            : }
     245                 :            : 
     246                 :            : static const struct net_device_ops blackhole_netdev_ops = {
     247                 :            :         .ndo_start_xmit = blackhole_netdev_xmit,
     248                 :            : };
     249                 :            : 
     250                 :            : /* This is a dst-dummy device used specifically for invalidated
     251                 :            :  * DSTs and unlike loopback, this is not per-ns.
     252                 :            :  */
     253                 :         11 : static void blackhole_netdev_setup(struct net_device *dev)
     254                 :            : {
     255                 :         11 :         gen_lo_setup(dev, ETH_MIN_MTU, NULL, NULL, &blackhole_netdev_ops, NULL);
     256                 :         11 : }
     257                 :            : 
     258                 :            : /* Setup and register the blackhole_netdev. */
     259                 :         11 : static int __init blackhole_netdev_init(void)
     260                 :            : {
     261                 :         11 :         blackhole_netdev = alloc_netdev(0, "blackhole_dev", NET_NAME_UNKNOWN,
     262                 :            :                                         blackhole_netdev_setup);
     263         [ +  - ]:         11 :         if (!blackhole_netdev)
     264                 :            :                 return -ENOMEM;
     265                 :            : 
     266                 :         11 :         rtnl_lock();
     267                 :         11 :         dev_init_scheduler(blackhole_netdev);
     268                 :         11 :         dev_activate(blackhole_netdev);
     269                 :         11 :         rtnl_unlock();
     270                 :            : 
     271                 :         11 :         blackhole_netdev->flags |= IFF_UP | IFF_RUNNING;
     272                 :         11 :         dev_net_set(blackhole_netdev, &init_net);
     273                 :            : 
     274                 :         11 :         return 0;
     275                 :            : }
     276                 :            : 
     277                 :            : device_initcall(blackhole_netdev_init);

Generated by: LCOV version 1.14