drivers/net/dummy.c

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