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 | NETIF_F_UFO;
 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 = ETH_MAX_MTU;
 357 }
 358
 359 static int dummy_validate(struct nlattr *tb[], struct nlattr *data[])
 360 {
 361         if (tb[IFLA_ADDRESS]) {
 362                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 363                         return -EINVAL;
 364                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 365                         return -EADDRNOTAVAIL;
 366         }
 367         return 0;
 368 }
 369
 370 static struct rtnl_link_ops dummy_link_ops __read_mostly = {
 371         .kind           = DRV_NAME,
 372         .priv_size      = sizeof(struct dummy_priv),
 373         .setup          = dummy_setup,
 374         .validate       = dummy_validate,
 375 };
 376
 377 /* Number of dummy devices to be set up by this module. */
 378 module_param(numdummies, int, 0);
 379 MODULE_PARM_DESC(numdummies, "Number of dummy pseudo devices");
 380
 381 module_param(num_vfs, int, 0);
 382 MODULE_PARM_DESC(num_vfs, "Number of dummy VFs per dummy device");
 383
 384 static int __init dummy_init_one(void)
 385 {
 386         struct net_device *dev_dummy;
 387         int err;
 388
 389         dev_dummy = alloc_netdev(sizeof(struct dummy_priv),
 390                                  "dummy%d", NET_NAME_UNKNOWN, dummy_setup);
 391         if (!dev_dummy)
 392                 return -ENOMEM;
 393
 394         dev_dummy->rtnl_link_ops = &dummy_link_ops;
 395         err = register_netdevice(dev_dummy);
 396         if (err < 0)
 397                 goto err;
 398         return 0;
 399
 400 err:
 401         free_netdev(dev_dummy);
 402         return err;
 403 }
 404
 405 static int __init dummy_init_module(void)
 406 {
 407         int i, err = 0;
 408
 409         if (num_vfs) {
 410                 err = bus_register(&dummy_bus);
 411                 if (err < 0) {
 412                         pr_err("registering dummy bus failed\n");
 413                         return err;
 414                 }
 415
 416                 err = device_register(&dummy_parent);
 417                 if (err < 0) {
 418                         pr_err("registering dummy parent device failed\n");
 419                         bus_unregister(&dummy_bus);
 420                         return err;
 421                 }
 422         }
 423
 424         rtnl_lock();
 425         err = __rtnl_link_register(&dummy_link_ops);
 426         if (err < 0)
 427                 goto out;
 428
 429         for (i = 0; i < numdummies && !err; i++) {
 430                 err = dummy_init_one();
 431                 cond_resched();
 432         }
 433         if (err < 0)
 434                 __rtnl_link_unregister(&dummy_link_ops);
 435
 436 out:
 437         rtnl_unlock();
 438
 439         if (err && num_vfs) {
 440                 device_unregister(&dummy_parent);
 441                 bus_unregister(&dummy_bus);
 442         }
 443
 444         return err;
 445 }
 446
 447 static void __exit dummy_cleanup_module(void)
 448 {
 449         rtnl_link_unregister(&dummy_link_ops);
 450
 451         if (num_vfs) {
 452                 device_unregister(&dummy_parent);
 453                 bus_unregister(&dummy_bus);
 454         }
 455 }
 456
 457 module_init(dummy_init_module);
 458 module_exit(dummy_cleanup_module);
 459 MODULE_LICENSE("GPL");
 460 MODULE_ALIAS_RTNL_LINK(DRV_NAME);
 461 MODULE_VERSION(DRV_VERSION);