drivers/net/netdevsim/netdev.c

   1 /*
   2  * Copyright (C) 2017 Netronome Systems, Inc.
   3  *
   4  * This software is licensed under the GNU General License Version 2,
   5  * June 1991 as shown in the file COPYING in the top-level directory of this
   6  * source tree.
   7  *
   8  * THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
   9  * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  10  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  11  * FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
  12  * OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
  13  * THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  14  */
  15
  16 #include <linux/debugfs.h>
  17 #include <linux/etherdevice.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/netdevice.h>
  21 #include <linux/slab.h>
  22 #include <net/netlink.h>
  23 #include <net/pkt_cls.h>
  24 #include <net/rtnetlink.h>
  25 #include <net/switchdev.h>
  26
  27 #include "netdevsim.h"
  28
  29 struct nsim_vf_config {
  30         int link_state;
  31         u16 min_tx_rate;
  32         u16 max_tx_rate;
  33         u16 vlan;
  34         __be16 vlan_proto;
  35         u16 qos;
  36         u8 vf_mac[ETH_ALEN];
  37         bool spoofchk_enabled;
  38         bool trusted;
  39         bool rss_query_enabled;
  40 };
  41
  42 static u32 nsim_dev_id;
  43
  44 static struct dentry *nsim_ddir;
  45 static struct dentry *nsim_sdev_ddir;
  46
  47 static int nsim_num_vf(struct device *dev)
  48 {
  49         struct netdevsim *ns = to_nsim(dev);
  50
  51         return ns->num_vfs;
  52 }
  53
  54 static struct bus_type nsim_bus = {
  55         .name           = DRV_NAME,
  56         .dev_name       = DRV_NAME,
  57         .num_vf         = nsim_num_vf,
  58 };
  59
  60 static int nsim_vfs_enable(struct netdevsim *ns, unsigned int num_vfs)
  61 {
  62         ns->vfconfigs = kcalloc(num_vfs, sizeof(struct nsim_vf_config),
  63                                 GFP_KERNEL);
  64         if (!ns->vfconfigs)
  65                 return -ENOMEM;
  66         ns->num_vfs = num_vfs;
  67
  68         return 0;
  69 }
  70
  71 static void nsim_vfs_disable(struct netdevsim *ns)
  72 {
  73         kfree(ns->vfconfigs);
  74         ns->vfconfigs = NULL;
  75         ns->num_vfs = 0;
  76 }
  77
  78 static ssize_t
  79 nsim_numvfs_store(struct device *dev, struct device_attribute *attr,
  80                   const char *buf, size_t count)
  81 {
  82         struct netdevsim *ns = to_nsim(dev);
  83         unsigned int num_vfs;
  84         int ret;
  85
  86         ret = kstrtouint(buf, 0, &num_vfs);
  87         if (ret)
  88                 return ret;
  89
  90         rtnl_lock();
  91         if (ns->num_vfs == num_vfs)
  92                 goto exit_good;
  93         if (ns->num_vfs && num_vfs) {
  94                 ret = -EBUSY;
  95                 goto exit_unlock;
  96         }
  97
  98         if (num_vfs) {
  99                 ret = nsim_vfs_enable(ns, num_vfs);
 100                 if (ret)
 101                         goto exit_unlock;
 102         } else {
 103                 nsim_vfs_disable(ns);
 104         }
 105 exit_good:
 106         ret = count;
 107 exit_unlock:
 108         rtnl_unlock();
 109
 110         return ret;
 111 }
 112
 113 static ssize_t
 114 nsim_numvfs_show(struct device *dev, struct device_attribute *attr, char *buf)
 115 {
 116         struct netdevsim *ns = to_nsim(dev);
 117
 118         return sprintf(buf, "%u\n", ns->num_vfs);
 119 }
 120
 121 static struct device_attribute nsim_numvfs_attr =
 122         __ATTR(sriov_numvfs, 0664, nsim_numvfs_show, nsim_numvfs_store);
 123
 124 static struct attribute *nsim_dev_attrs[] = {
 125         &nsim_numvfs_attr.attr,
 126         NULL,
 127 };
 128
 129 static const struct attribute_group nsim_dev_attr_group = {
 130         .attrs = nsim_dev_attrs,
 131 };
 132
 133 static const struct attribute_group *nsim_dev_attr_groups[] = {
 134         &nsim_dev_attr_group,
 135         NULL,
 136 };
 137
 138 static void nsim_dev_release(struct device *dev)
 139 {
 140         struct netdevsim *ns = to_nsim(dev);
 141
 142         nsim_vfs_disable(ns);
 143         free_netdev(ns->netdev);
 144 }
 145
 146 static struct device_type nsim_dev_type = {
 147         .groups = nsim_dev_attr_groups,
 148         .release = nsim_dev_release,
 149 };
 150
 151 static int
 152 nsim_port_attr_get(struct net_device *dev, struct switchdev_attr *attr)
 153 {
 154         struct netdevsim *ns = netdev_priv(dev);
 155
 156         switch (attr->id) {
 157         case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
 158                 attr->u.ppid.id_len = sizeof(ns->sdev->switch_id);
 159                 memcpy(&attr->u.ppid.id, &ns->sdev->switch_id,
 160                        attr->u.ppid.id_len);
 161                 return 0;
 162         default:
 163                 return -EOPNOTSUPP;
 164         }
 165 }
 166
 167 static const struct switchdev_ops nsim_switchdev_ops = {
 168         .switchdev_port_attr_get        = nsim_port_attr_get,
 169 };
 170
 171 static int nsim_init(struct net_device *dev)
 172 {
 173         char sdev_ddir_name[10], sdev_link_name[32];
 174         struct netdevsim *ns = netdev_priv(dev);
 175         int err;
 176
 177         ns->netdev = dev;
 178         ns->ddir = debugfs_create_dir(netdev_name(dev), nsim_ddir);
 179         if (IS_ERR_OR_NULL(ns->ddir))
 180                 return -ENOMEM;
 181
 182         if (!ns->sdev) {
 183                 ns->sdev = kzalloc(sizeof(*ns->sdev), GFP_KERNEL);
 184                 if (!ns->sdev) {
 185                         err = -ENOMEM;
 186                         goto err_debugfs_destroy;
 187                 }
 188                 ns->sdev->refcnt = 1;
 189                 ns->sdev->switch_id = nsim_dev_id;
 190                 sprintf(sdev_ddir_name, "%u", ns->sdev->switch_id);
 191                 ns->sdev->ddir = debugfs_create_dir(sdev_ddir_name,
 192                                                     nsim_sdev_ddir);
 193                 if (IS_ERR_OR_NULL(ns->sdev->ddir)) {
 194                         err = PTR_ERR_OR_ZERO(ns->sdev->ddir) ?: -EINVAL;
 195                         goto err_sdev_free;
 196                 }
 197         } else {
 198                 sprintf(sdev_ddir_name, "%u", ns->sdev->switch_id);
 199                 ns->sdev->refcnt++;
 200         }
 201
 202         sprintf(sdev_link_name, "../../" DRV_NAME "_sdev/%s", sdev_ddir_name);
 203         debugfs_create_symlink("sdev", ns->ddir, sdev_link_name);
 204
 205         err = nsim_bpf_init(ns);
 206         if (err)
 207                 goto err_sdev_destroy;
 208
 209         ns->dev.id = nsim_dev_id++;
 210         ns->dev.bus = &nsim_bus;
 211         ns->dev.type = &nsim_dev_type;
 212         err = device_register(&ns->dev);
 213         if (err)
 214                 goto err_bpf_uninit;
 215
 216         SET_NETDEV_DEV(dev, &ns->dev);
 217         SWITCHDEV_SET_OPS(dev, &nsim_switchdev_ops);
 218
 219         err = nsim_devlink_setup(ns);
 220         if (err)
 221                 goto err_unreg_dev;
 222
 223         nsim_ipsec_init(ns);
 224
 225         return 0;
 226
 227 err_unreg_dev:
 228         device_unregister(&ns->dev);
 229 err_bpf_uninit:
 230         nsim_bpf_uninit(ns);
 231 err_sdev_destroy:
 232         if (!--ns->sdev->refcnt) {
 233                 debugfs_remove_recursive(ns->sdev->ddir);
 234 err_sdev_free:
 235                 kfree(ns->sdev);
 236         }
 237 err_debugfs_destroy:
 238         debugfs_remove_recursive(ns->ddir);
 239         return err;
 240 }
 241
 242 static void nsim_uninit(struct net_device *dev)
 243 {
 244         struct netdevsim *ns = netdev_priv(dev);
 245
 246         nsim_ipsec_teardown(ns);
 247         nsim_devlink_teardown(ns);
 248         debugfs_remove_recursive(ns->ddir);
 249         nsim_bpf_uninit(ns);
 250         if (!--ns->sdev->refcnt) {
 251                 debugfs_remove_recursive(ns->sdev->ddir);
 252                 kfree(ns->sdev);
 253         }
 254 }
 255
 256 static void nsim_free(struct net_device *dev)
 257 {
 258         struct netdevsim *ns = netdev_priv(dev);
 259
 260         device_unregister(&ns->dev);
 261         /* netdev and vf state will be freed out of device_release() */
 262 }
 263
 264 static netdev_tx_t nsim_start_xmit(struct sk_buff *skb, struct net_device *dev)
 265 {
 266         struct netdevsim *ns = netdev_priv(dev);
 267
 268         if (!nsim_ipsec_tx(ns, skb))
 269                 goto out;
 270
 271         u64_stats_update_begin(&ns->syncp);
 272         ns->tx_packets++;
 273         ns->tx_bytes += skb->len;
 274         u64_stats_update_end(&ns->syncp);
 275
 276 out:
 277         dev_kfree_skb(skb);
 278
 279         return NETDEV_TX_OK;
 280 }
 281
 282 static void nsim_set_rx_mode(struct net_device *dev)
 283 {
 284 }
 285
 286 static int nsim_change_mtu(struct net_device *dev, int new_mtu)
 287 {
 288         struct netdevsim *ns = netdev_priv(dev);
 289
 290         if (ns->xdp.prog && new_mtu > NSIM_XDP_MAX_MTU)
 291                 return -EBUSY;
 292
 293         dev->mtu = new_mtu;
 294
 295         return 0;
 296 }
 297
 298 static void
 299 nsim_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
 300 {
 301         struct netdevsim *ns = netdev_priv(dev);
 302         unsigned int start;
 303
 304         do {
 305                 start = u64_stats_fetch_begin(&ns->syncp);
 306                 stats->tx_bytes = ns->tx_bytes;
 307                 stats->tx_packets = ns->tx_packets;
 308         } while (u64_stats_fetch_retry(&ns->syncp, start));
 309 }
 310
 311 static int
 312 nsim_setup_tc_block_cb(enum tc_setup_type type, void *type_data, void *cb_priv)
 313 {
 314         return nsim_bpf_setup_tc_block_cb(type, type_data, cb_priv);
 315 }
 316
 317 static int
 318 nsim_setup_tc_block(struct net_device *dev, struct tc_block_offload *f)
 319 {
 320         struct netdevsim *ns = netdev_priv(dev);
 321
 322         if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
 323                 return -EOPNOTSUPP;
 324
 325         switch (f->command) {
 326         case TC_BLOCK_BIND:
 327                 return tcf_block_cb_register(f->block, nsim_setup_tc_block_cb,
 328                                              ns, ns, f->extack);
 329         case TC_BLOCK_UNBIND:
 330                 tcf_block_cb_unregister(f->block, nsim_setup_tc_block_cb, ns);
 331                 return 0;
 332         default:
 333                 return -EOPNOTSUPP;
 334         }
 335 }
 336
 337 static int nsim_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
 338 {
 339         struct netdevsim *ns = netdev_priv(dev);
 340
 341         /* Only refuse multicast addresses, zero address can mean unset/any. */
 342         if (vf >= ns->num_vfs || is_multicast_ether_addr(mac))
 343                 return -EINVAL;
 344         memcpy(ns->vfconfigs[vf].vf_mac, mac, ETH_ALEN);
 345
 346         return 0;
 347 }
 348
 349 static int nsim_set_vf_vlan(struct net_device *dev, int vf,
 350                             u16 vlan, u8 qos, __be16 vlan_proto)
 351 {
 352         struct netdevsim *ns = netdev_priv(dev);
 353
 354         if (vf >= ns->num_vfs || vlan > 4095 || qos > 7)
 355                 return -EINVAL;
 356
 357         ns->vfconfigs[vf].vlan = vlan;
 358         ns->vfconfigs[vf].qos = qos;
 359         ns->vfconfigs[vf].vlan_proto = vlan_proto;
 360
 361         return 0;
 362 }
 363
 364 static int nsim_set_vf_rate(struct net_device *dev, int vf, int min, int max)
 365 {
 366         struct netdevsim *ns = netdev_priv(dev);
 367
 368         if (vf >= ns->num_vfs)
 369                 return -EINVAL;
 370
 371         ns->vfconfigs[vf].min_tx_rate = min;
 372         ns->vfconfigs[vf].max_tx_rate = max;
 373
 374         return 0;
 375 }
 376
 377 static int nsim_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
 378 {
 379         struct netdevsim *ns = netdev_priv(dev);
 380
 381         if (vf >= ns->num_vfs)
 382                 return -EINVAL;
 383         ns->vfconfigs[vf].spoofchk_enabled = val;
 384
 385         return 0;
 386 }
 387
 388 static int nsim_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
 389 {
 390         struct netdevsim *ns = netdev_priv(dev);
 391
 392         if (vf >= ns->num_vfs)
 393                 return -EINVAL;
 394         ns->vfconfigs[vf].rss_query_enabled = val;
 395
 396         return 0;
 397 }
 398
 399 static int nsim_set_vf_trust(struct net_device *dev, int vf, bool val)
 400 {
 401         struct netdevsim *ns = netdev_priv(dev);
 402
 403         if (vf >= ns->num_vfs)
 404                 return -EINVAL;
 405         ns->vfconfigs[vf].trusted = val;
 406
 407         return 0;
 408 }
 409
 410 static int
 411 nsim_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_info *ivi)
 412 {
 413         struct netdevsim *ns = netdev_priv(dev);
 414
 415         if (vf >= ns->num_vfs)
 416                 return -EINVAL;
 417
 418         ivi->vf = vf;
 419         ivi->linkstate = ns->vfconfigs[vf].link_state;
 420         ivi->min_tx_rate = ns->vfconfigs[vf].min_tx_rate;
 421         ivi->max_tx_rate = ns->vfconfigs[vf].max_tx_rate;
 422         ivi->vlan = ns->vfconfigs[vf].vlan;
 423         ivi->vlan_proto = ns->vfconfigs[vf].vlan_proto;
 424         ivi->qos = ns->vfconfigs[vf].qos;
 425         memcpy(&ivi->mac, ns->vfconfigs[vf].vf_mac, ETH_ALEN);
 426         ivi->spoofchk = ns->vfconfigs[vf].spoofchk_enabled;
 427         ivi->trusted = ns->vfconfigs[vf].trusted;
 428         ivi->rss_query_en = ns->vfconfigs[vf].rss_query_enabled;
 429
 430         return 0;
 431 }
 432
 433 static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state)
 434 {
 435         struct netdevsim *ns = netdev_priv(dev);
 436
 437         if (vf >= ns->num_vfs)
 438                 return -EINVAL;
 439
 440         switch (state) {
 441         case IFLA_VF_LINK_STATE_AUTO:
 442         case IFLA_VF_LINK_STATE_ENABLE:
 443         case IFLA_VF_LINK_STATE_DISABLE:
 444                 break;
 445         default:
 446                 return -EINVAL;
 447         }
 448
 449         ns->vfconfigs[vf].link_state = state;
 450
 451         return 0;
 452 }
 453
 454 static int
 455 nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
 456 {
 457         switch (type) {
 458         case TC_SETUP_BLOCK:
 459                 return nsim_setup_tc_block(dev, type_data);
 460         default:
 461                 return -EOPNOTSUPP;
 462         }
 463 }
 464
 465 static int
 466 nsim_set_features(struct net_device *dev, netdev_features_t features)
 467 {
 468         struct netdevsim *ns = netdev_priv(dev);
 469
 470         if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC))
 471                 return nsim_bpf_disable_tc(ns);
 472
 473         return 0;
 474 }
 475
 476 static const struct net_device_ops nsim_netdev_ops = {
 477         .ndo_init               = nsim_init,
 478         .ndo_uninit             = nsim_uninit,
 479         .ndo_start_xmit         = nsim_start_xmit,
 480         .ndo_set_rx_mode        = nsim_set_rx_mode,
 481         .ndo_set_mac_address    = eth_mac_addr,
 482         .ndo_validate_addr      = eth_validate_addr,
 483         .ndo_change_mtu         = nsim_change_mtu,
 484         .ndo_get_stats64        = nsim_get_stats64,
 485         .ndo_set_vf_mac         = nsim_set_vf_mac,
 486         .ndo_set_vf_vlan        = nsim_set_vf_vlan,
 487         .ndo_set_vf_rate        = nsim_set_vf_rate,
 488         .ndo_set_vf_spoofchk    = nsim_set_vf_spoofchk,
 489         .ndo_set_vf_trust       = nsim_set_vf_trust,
 490         .ndo_get_vf_config      = nsim_get_vf_config,
 491         .ndo_set_vf_link_state  = nsim_set_vf_link_state,
 492         .ndo_set_vf_rss_query_en = nsim_set_vf_rss_query_en,
 493         .ndo_setup_tc           = nsim_setup_tc,
 494         .ndo_set_features       = nsim_set_features,
 495         .ndo_bpf                = nsim_bpf,
 496 };
 497
 498 static void nsim_setup(struct net_device *dev)
 499 {
 500         ether_setup(dev);
 501         eth_hw_addr_random(dev);
 502
 503         dev->netdev_ops = &nsim_netdev_ops;
 504         dev->priv_destructor = nsim_free;
 505
 506         dev->tx_queue_len = 0;
 507         dev->flags |= IFF_NOARP;
 508         dev->flags &= ~IFF_MULTICAST;
 509         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE |
 510                            IFF_NO_QUEUE;
 511         dev->features |= NETIF_F_HIGHDMA |
 512                          NETIF_F_SG |
 513                          NETIF_F_FRAGLIST |
 514                          NETIF_F_HW_CSUM |
 515                          NETIF_F_TSO;
 516         dev->hw_features |= NETIF_F_HW_TC;
 517         dev->max_mtu = ETH_MAX_MTU;
 518 }
 519
 520 static int nsim_validate(struct nlattr *tb[], struct nlattr *data[],
 521                          struct netlink_ext_ack *extack)
 522 {
 523         if (tb[IFLA_ADDRESS]) {
 524                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 525                         return -EINVAL;
 526                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 527                         return -EADDRNOTAVAIL;
 528         }
 529         return 0;
 530 }
 531
 532 static int nsim_newlink(struct net *src_net, struct net_device *dev,
 533                         struct nlattr *tb[], struct nlattr *data[],
 534                         struct netlink_ext_ack *extack)
 535 {
 536         struct netdevsim *ns = netdev_priv(dev);
 537
 538         if (tb[IFLA_LINK]) {
 539                 struct net_device *joindev;
 540                 struct netdevsim *joinns;
 541
 542                 joindev = __dev_get_by_index(src_net,
 543                                              nla_get_u32(tb[IFLA_LINK]));
 544                 if (!joindev)
 545                         return -ENODEV;
 546                 if (joindev->netdev_ops != &nsim_netdev_ops)
 547                         return -EINVAL;
 548
 549                 joinns = netdev_priv(joindev);
 550                 if (!joinns->sdev || !joinns->sdev->refcnt)
 551                         return -EINVAL;
 552                 ns->sdev = joinns->sdev;
 553         }
 554
 555         return register_netdevice(dev);
 556 }
 557
 558 static void nsim_dellink(struct net_device *dev, struct list_head *head)
 559 {
 560         unregister_netdevice_queue(dev, head);
 561 }
 562
 563 static struct rtnl_link_ops nsim_link_ops __read_mostly = {
 564         .kind           = DRV_NAME,
 565         .priv_size      = sizeof(struct netdevsim),
 566         .setup          = nsim_setup,
 567         .validate       = nsim_validate,
 568         .newlink        = nsim_newlink,
 569         .dellink        = nsim_dellink,
 570 };
 571
 572 static int __init nsim_module_init(void)
 573 {
 574         int err;
 575
 576         nsim_ddir = debugfs_create_dir(DRV_NAME, NULL);
 577         if (IS_ERR_OR_NULL(nsim_ddir))
 578                 return -ENOMEM;
 579
 580         nsim_sdev_ddir = debugfs_create_dir(DRV_NAME "_sdev", NULL);
 581         if (IS_ERR_OR_NULL(nsim_sdev_ddir)) {
 582                 err = -ENOMEM;
 583                 goto err_debugfs_destroy;
 584         }
 585
 586         err = bus_register(&nsim_bus);
 587         if (err)
 588                 goto err_sdir_destroy;
 589
 590         err = nsim_devlink_init();
 591         if (err)
 592                 goto err_unreg_bus;
 593
 594         err = rtnl_link_register(&nsim_link_ops);
 595         if (err)
 596                 goto err_dl_fini;
 597
 598         return 0;
 599
 600 err_dl_fini:
 601         nsim_devlink_exit();
 602 err_unreg_bus:
 603         bus_unregister(&nsim_bus);
 604 err_sdir_destroy:
 605         debugfs_remove_recursive(nsim_sdev_ddir);
 606 err_debugfs_destroy:
 607         debugfs_remove_recursive(nsim_ddir);
 608         return err;
 609 }
 610
 611 static void __exit nsim_module_exit(void)
 612 {
 613         rtnl_link_unregister(&nsim_link_ops);
 614         nsim_devlink_exit();
 615         bus_unregister(&nsim_bus);
 616         debugfs_remove_recursive(nsim_sdev_ddir);
 617         debugfs_remove_recursive(nsim_ddir);
 618 }
 619
 620 module_init(nsim_module_init);
 621 module_exit(nsim_module_exit);
 622 MODULE_LICENSE("GPL");
 623 MODULE_ALIAS_RTNL_LINK(DRV_NAME);