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/init.h>
  36 #include <linux/moduleparam.h>
  37 #include <linux/rtnetlink.h>
  38 #include <linux/net_tstamp.h>
  39 #include <net/rtnetlink.h>
  40 #include <linux/u64_stats_sync.h>
  41
  42 #define DRV_NAME        "dummy"
  43 #define DRV_VERSION     "1.0"
  44
  45 #undef pr_fmt
  46 #define pr_fmt(fmt) DRV_NAME ": " fmt
  47
  48 static int numdummies = 1;
  49 static int num_vfs;
  50
  51 struct vf_data_storage {
  52         u8      vf_mac[ETH_ALEN];
  53         u16     pf_vlan; /* When set, guest VLAN config not allowed. */
  54         u16     pf_qos;
  55         __be16  vlan_proto;
  56         u16     min_tx_rate;
  57         u16     max_tx_rate;
  58         u8      spoofchk_enabled;
  59         bool    rss_query_enabled;
  60         u8      trusted;
  61         int     link_state;
  62 };
  63
  64 struct dummy_priv {
  65         struct vf_data_storage  *vfinfo;
  66 };
  67
  68 static int dummy_num_vf(struct device *dev)
  69 {
  70         return num_vfs;
  71 }
  72
  73 static struct bus_type dummy_bus = {
  74         .name   = "dummy",
  75         .num_vf = dummy_num_vf,
  76 };
  77
  78 static void release_dummy_parent(struct device *dev)
  79 {
  80 }
  81
  82 static struct device dummy_parent = {
  83         .init_name      = "dummy",
  84         .bus            = &dummy_bus,
  85         .release        = release_dummy_parent,
  86 };
  87
  88 /* fake multicast ability */
  89 static void set_multicast_list(struct net_device *dev)
  90 {
  91 }
  92
  93 struct pcpu_dstats {
  94         u64                     tx_packets;
  95         u64                     tx_bytes;
  96         struct u64_stats_sync   syncp;
  97 };
  98
  99 static void dummy_get_stats64(struct net_device *dev,
 100                               struct rtnl_link_stats64 *stats)
 101 {
 102         int i;
 103
 104         for_each_possible_cpu(i) {
 105                 const struct pcpu_dstats *dstats;
 106                 u64 tbytes, tpackets;
 107                 unsigned int start;
 108
 109                 dstats = per_cpu_ptr(dev->dstats, i);
 110                 do {
 111                         start = u64_stats_fetch_begin_irq(&dstats->syncp);
 112                         tbytes = dstats->tx_bytes;
 113                         tpackets = dstats->tx_packets;
 114                 } while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
 115                 stats->tx_bytes += tbytes;
 116                 stats->tx_packets += tpackets;
 117         }
 118 }
 119
 120 static netdev_tx_t dummy_xmit(struct sk_buff *skb, struct net_device *dev)
 121 {
 122         struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
 123
 124         u64_stats_update_begin(&dstats->syncp);
 125         dstats->tx_packets++;
 126         dstats->tx_bytes += skb->len;
 127         u64_stats_update_end(&dstats->syncp);
 128
 129         skb_tx_timestamp(skb);
 130         dev_kfree_skb(skb);
 131         return NETDEV_TX_OK;
 132 }
 133
 134 static int dummy_dev_init(struct net_device *dev)
 135 {
 136         struct dummy_priv *priv = netdev_priv(dev);
 137
 138         dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
 139         if (!dev->dstats)
 140                 return -ENOMEM;
 141
 142         priv->vfinfo = NULL;
 143
 144         if (!num_vfs)
 145                 return 0;
 146
 147         dev->dev.parent = &dummy_parent;
 148         priv->vfinfo = kcalloc(num_vfs, sizeof(struct vf_data_storage),
 149                                GFP_KERNEL);
 150         if (!priv->vfinfo) {
 151                 free_percpu(dev->dstats);
 152                 return -ENOMEM;
 153         }
 154
 155         return 0;
 156 }
 157
 158 static void dummy_dev_uninit(struct net_device *dev)
 159 {
 160         free_percpu(dev->dstats);
 161 }
 162
 163 static int dummy_change_carrier(struct net_device *dev, bool new_carrier)
 164 {
 165         if (new_carrier)
 166                 netif_carrier_on(dev);
 167         else
 168                 netif_carrier_off(dev);
 169         return 0;
 170 }
 171
 172 static int dummy_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
 173 {
 174         struct dummy_priv *priv = netdev_priv(dev);
 175
 176         if (!is_valid_ether_addr(mac) || (vf >= num_vfs))
 177                 return -EINVAL;
 178
 179         memcpy(priv->vfinfo[vf].vf_mac, mac, ETH_ALEN);
 180
 181         return 0;
 182 }
 183
 184 static int dummy_set_vf_vlan(struct net_device *dev, int vf,
 185                              u16 vlan, u8 qos, __be16 vlan_proto)
 186 {
 187         struct dummy_priv *priv = netdev_priv(dev);
 188
 189         if ((vf >= num_vfs) || (vlan > 4095) || (qos > 7))
 190                 return -EINVAL;
 191
 192         priv->vfinfo[vf].pf_vlan = vlan;
 193         priv->vfinfo[vf].pf_qos = qos;
 194         priv->vfinfo[vf].vlan_proto = vlan_proto;
 195
 196         return 0;
 197 }
 198
 199 static int dummy_set_vf_rate(struct net_device *dev, int vf, int min, int max)
 200 {
 201         struct dummy_priv *priv = netdev_priv(dev);
 202
 203         if (vf >= num_vfs)
 204                 return -EINVAL;
 205
 206         priv->vfinfo[vf].min_tx_rate = min;
 207         priv->vfinfo[vf].max_tx_rate = max;
 208
 209         return 0;
 210 }
 211
 212 static int dummy_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
 213 {
 214         struct dummy_priv *priv = netdev_priv(dev);
 215
 216         if (vf >= num_vfs)
 217                 return -EINVAL;
 218
 219         priv->vfinfo[vf].spoofchk_enabled = val;
 220
 221         return 0;
 222 }
 223
 224 static int dummy_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
 225 {
 226         struct dummy_priv *priv = netdev_priv(dev);
 227
 228         if (vf >= num_vfs)
 229                 return -EINVAL;
 230
 231         priv->vfinfo[vf].rss_query_enabled = val;
 232
 233         return 0;
 234 }
 235
 236 static int dummy_set_vf_trust(struct net_device *dev, int vf, bool val)
 237 {
 238         struct dummy_priv *priv = netdev_priv(dev);
 239
 240         if (vf >= num_vfs)
 241                 return -EINVAL;
 242
 243         priv->vfinfo[vf].trusted = val;
 244
 245         return 0;
 246 }
 247
 248 static int dummy_get_vf_config(struct net_device *dev,
 249                                int vf, struct ifla_vf_info *ivi)
 250 {
 251         struct dummy_priv *priv = netdev_priv(dev);
 252
 253         if (vf >= num_vfs)
 254                 return -EINVAL;
 255
 256         ivi->vf = vf;
 257         memcpy(&ivi->mac, priv->vfinfo[vf].vf_mac, ETH_ALEN);
 258         ivi->vlan = priv->vfinfo[vf].pf_vlan;
 259         ivi->qos = priv->vfinfo[vf].pf_qos;
 260         ivi->spoofchk = priv->vfinfo[vf].spoofchk_enabled;
 261         ivi->linkstate = priv->vfinfo[vf].link_state;
 262         ivi->min_tx_rate = priv->vfinfo[vf].min_tx_rate;
 263         ivi->max_tx_rate = priv->vfinfo[vf].max_tx_rate;
 264         ivi->rss_query_en = priv->vfinfo[vf].rss_query_enabled;
 265         ivi->trusted = priv->vfinfo[vf].trusted;
 266         ivi->vlan_proto = priv->vfinfo[vf].vlan_proto;
 267
 268         return 0;
 269 }
 270
 271 static int dummy_set_vf_link_state(struct net_device *dev, int vf, int state)
 272 {
 273         struct dummy_priv *priv = netdev_priv(dev);
 274
 275         if (vf >= num_vfs)
 276                 return -EINVAL;
 277
 278         priv->vfinfo[vf].link_state = state;
 279
 280         return 0;
 281 }
 282
 283 static const struct net_device_ops dummy_netdev_ops = {
 284         .ndo_init               = dummy_dev_init,
 285         .ndo_uninit             = dummy_dev_uninit,
 286         .ndo_start_xmit         = dummy_xmit,
 287         .ndo_validate_addr      = eth_validate_addr,
 288         .ndo_set_rx_mode        = set_multicast_list,
 289         .ndo_set_mac_address    = eth_mac_addr,
 290         .ndo_get_stats64        = dummy_get_stats64,
 291         .ndo_change_carrier     = dummy_change_carrier,
 292         .ndo_set_vf_mac         = dummy_set_vf_mac,
 293         .ndo_set_vf_vlan        = dummy_set_vf_vlan,
 294         .ndo_set_vf_rate        = dummy_set_vf_rate,
 295         .ndo_set_vf_spoofchk    = dummy_set_vf_spoofchk,
 296         .ndo_set_vf_trust       = dummy_set_vf_trust,
 297         .ndo_get_vf_config      = dummy_get_vf_config,
 298         .ndo_set_vf_link_state  = dummy_set_vf_link_state,
 299         .ndo_set_vf_rss_query_en = dummy_set_vf_rss_query_en,
 300 };
 301
 302 static void dummy_get_drvinfo(struct net_device *dev,
 303                               struct ethtool_drvinfo *info)
 304 {
 305         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
 306         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
 307 }
 308
 309 static int dummy_get_ts_info(struct net_device *dev,
 310                               struct ethtool_ts_info *ts_info)
 311 {
 312         ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
 313                                    SOF_TIMESTAMPING_RX_SOFTWARE |
 314                                    SOF_TIMESTAMPING_SOFTWARE;
 315
 316         ts_info->phc_index = -1;
 317
 318         return 0;
 319 };
 320
 321 static const struct ethtool_ops dummy_ethtool_ops = {
 322         .get_drvinfo            = dummy_get_drvinfo,
 323         .get_ts_info            = dummy_get_ts_info,
 324 };
 325
 326 static void dummy_free_netdev(struct net_device *dev)
 327 {
 328         struct dummy_priv *priv = netdev_priv(dev);
 329
 330         kfree(priv->vfinfo);
 331 }
 332
 333 static void dummy_setup(struct net_device *dev)
 334 {
 335         ether_setup(dev);
 336
 337         /* Initialize the device structure. */
 338         dev->netdev_ops = &dummy_netdev_ops;
 339         dev->ethtool_ops = &dummy_ethtool_ops;
 340         dev->needs_free_netdev = true;
 341         dev->priv_destructor = dummy_free_netdev;
 342
 343         /* Fill in device structure with ethernet-generic values. */
 344         dev->flags |= IFF_NOARP;
 345         dev->flags &= ~IFF_MULTICAST;
 346         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
 347         dev->features   |= NETIF_F_SG | NETIF_F_FRAGLIST;
 348         dev->features   |= NETIF_F_ALL_TSO;
 349         dev->features   |= NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_LLTX;
 350         dev->features   |= NETIF_F_GSO_ENCAP_ALL;
 351         dev->hw_features |= dev->features;
 352         dev->hw_enc_features |= dev->features;
 353         eth_hw_addr_random(dev);
 354
 355         dev->min_mtu = 0;
 356         dev->max_mtu = 0;
 357 }
 358
 359 static int dummy_validate(struct nlattr *tb[], struct nlattr *data[],
 360                           struct netlink_ext_ack *extack)
 361 {
 362         if (tb[IFLA_ADDRESS]) {
 363                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 364                         return -EINVAL;
 365                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 366                         return -EADDRNOTAVAIL;
 367         }
 368         return 0;
 369 }
 370
 371 static struct rtnl_link_ops dummy_link_ops __read_mostly = {
 372         .kind           = DRV_NAME,
 373         .priv_size      = sizeof(struct dummy_priv),
 374         .setup          = dummy_setup,
 375         .validate       = dummy_validate,
 376 };
 377
 378 /* Number of dummy devices to be set up by this module. */
 379 module_param(numdummies, int, 0);
 380 MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");
 381
 382 module_param(num_vfs, int, 0);
 383 MODULE_PARM_DESC(num_vfs, "Number of dummy VFs per dummy device");
 384
 385 static int __init dummy_init_one(void)
 386 {
 387         struct net_device *dev_dummy;
 388         int err;
 389
 390         dev_dummy = alloc_netdev(sizeof(struct dummy_priv),
 391                                  "dummy%d", NET_NAME_ENUM, dummy_setup);
 392         if (!dev_dummy)
 393                 return -ENOMEM;
 394
 395         dev_dummy->rtnl_link_ops = &dummy_link_ops;
 396         err = register_netdevice(dev_dummy);
 397         if (err < 0)
 398                 goto err;
 399         return 0;
 400
 401 err:
 402         free_netdev(dev_dummy);
 403         return err;
 404 }
 405
 406 static int __init dummy_init_module(void)
 407 {
 408         int i, err = 0;
 409
 410         if (num_vfs) {
 411                 err = bus_register(&dummy_bus);
 412                 if (err < 0) {
 413                         pr_err("registering dummy bus failed\n");
 414                         return err;
 415                 }
 416
 417                 err = device_register(&dummy_parent);
 418                 if (err < 0) {
 419                         pr_err("registering dummy parent device failed\n");
 420                         bus_unregister(&dummy_bus);
 421                         return err;
 422                 }
 423         }
 424
 425         rtnl_lock();
 426         err = __rtnl_link_register(&dummy_link_ops);
 427         if (err < 0)
 428                 goto out;
 429
 430         for (i = 0; i < numdummies && !err; i++) {
 431                 err = dummy_init_one();
 432                 cond_resched();
 433         }
 434         if (err < 0)
 435                 __rtnl_link_unregister(&dummy_link_ops);
 436
 437 out:
 438         rtnl_unlock();
 439
 440         if (err && num_vfs) {
 441                 device_unregister(&dummy_parent);
 442                 bus_unregister(&dummy_bus);
 443         }
 444
 445         return err;
 446 }
 447
 448 static void __exit dummy_cleanup_module(void)
 449 {
 450         rtnl_link_unregister(&dummy_link_ops);
 451
 452         if (num_vfs) {
 453                 device_unregister(&dummy_parent);
 454                 bus_unregister(&dummy_bus);
 455         }
 456 }
 457
 458 module_init(dummy_init_module);
 459 module_exit(dummy_cleanup_module);
 460 MODULE_LICENSE("GPL");
 461 MODULE_ALIAS_RTNL_LINK(DRV_NAME);
 462 MODULE_VERSION(DRV_VERSION);