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/udp_tunnel.h>
  26
  27 #include "netdevsim.h"
  28
  29 static netdev_tx_t nsim_start_xmit(struct sk_buff *skb, struct net_device *dev)
  30 {
  31         struct netdevsim *ns = netdev_priv(dev);
  32
  33         if (!nsim_ipsec_tx(ns, skb))
  34                 goto out;
  35
  36         u64_stats_update_begin(&ns->syncp);
  37         ns->tx_packets++;
  38         ns->tx_bytes += skb->len;
  39         u64_stats_update_end(&ns->syncp);
  40
  41 out:
  42         dev_kfree_skb(skb);
  43
  44         return NETDEV_TX_OK;
  45 }
  46
  47 static void nsim_set_rx_mode(struct net_device *dev)
  48 {
  49 }
  50
  51 static int nsim_change_mtu(struct net_device *dev, int new_mtu)
  52 {
  53         struct netdevsim *ns = netdev_priv(dev);
  54
  55         if (ns->xdp.prog && new_mtu > NSIM_XDP_MAX_MTU)
  56                 return -EBUSY;
  57
  58         dev->mtu = new_mtu;
  59
  60         return 0;
  61 }
  62
  63 static void
  64 nsim_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
  65 {
  66         struct netdevsim *ns = netdev_priv(dev);
  67         unsigned int start;
  68
  69         do {
  70                 start = u64_stats_fetch_begin(&ns->syncp);
  71                 stats->tx_bytes = ns->tx_bytes;
  72                 stats->tx_packets = ns->tx_packets;
  73         } while (u64_stats_fetch_retry(&ns->syncp, start));
  74 }
  75
  76 static int
  77 nsim_setup_tc_block_cb(enum tc_setup_type type, void *type_data, void *cb_priv)
  78 {
  79         return nsim_bpf_setup_tc_block_cb(type, type_data, cb_priv);
  80 }
  81
  82 static int nsim_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
  83 {
  84         struct netdevsim *ns = netdev_priv(dev);
  85         struct nsim_dev *nsim_dev = ns->nsim_dev;
  86
  87         /* Only refuse multicast addresses, zero address can mean unset/any. */
  88         if (vf >= nsim_dev_get_vfs(nsim_dev) || is_multicast_ether_addr(mac))
  89                 return -EINVAL;
  90         memcpy(nsim_dev->vfconfigs[vf].vf_mac, mac, ETH_ALEN);
  91
  92         return 0;
  93 }
  94
  95 static int nsim_set_vf_vlan(struct net_device *dev, int vf,
  96                             u16 vlan, u8 qos, __be16 vlan_proto)
  97 {
  98         struct netdevsim *ns = netdev_priv(dev);
  99         struct nsim_dev *nsim_dev = ns->nsim_dev;
 100
 101         if (vf >= nsim_dev_get_vfs(nsim_dev) || vlan > 4095 || qos > 7)
 102                 return -EINVAL;
 103
 104         nsim_dev->vfconfigs[vf].vlan = vlan;
 105         nsim_dev->vfconfigs[vf].qos = qos;
 106         nsim_dev->vfconfigs[vf].vlan_proto = vlan_proto;
 107
 108         return 0;
 109 }
 110
 111 static int nsim_set_vf_rate(struct net_device *dev, int vf, int min, int max)
 112 {
 113         struct netdevsim *ns = netdev_priv(dev);
 114         struct nsim_dev *nsim_dev = ns->nsim_dev;
 115
 116         if (nsim_esw_mode_is_switchdev(ns->nsim_dev)) {
 117                 pr_err("Not supported in switchdev mode. Please use devlink API.\n");
 118                 return -EOPNOTSUPP;
 119         }
 120
 121         if (vf >= nsim_dev_get_vfs(nsim_dev))
 122                 return -EINVAL;
 123
 124         nsim_dev->vfconfigs[vf].min_tx_rate = min;
 125         nsim_dev->vfconfigs[vf].max_tx_rate = max;
 126
 127         return 0;
 128 }
 129
 130 static int nsim_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
 131 {
 132         struct netdevsim *ns = netdev_priv(dev);
 133         struct nsim_dev *nsim_dev = ns->nsim_dev;
 134
 135         if (vf >= nsim_dev_get_vfs(nsim_dev))
 136                 return -EINVAL;
 137         nsim_dev->vfconfigs[vf].spoofchk_enabled = val;
 138
 139         return 0;
 140 }
 141
 142 static int nsim_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
 143 {
 144         struct netdevsim *ns = netdev_priv(dev);
 145         struct nsim_dev *nsim_dev = ns->nsim_dev;
 146
 147         if (vf >= nsim_dev_get_vfs(nsim_dev))
 148                 return -EINVAL;
 149         nsim_dev->vfconfigs[vf].rss_query_enabled = val;
 150
 151         return 0;
 152 }
 153
 154 static int nsim_set_vf_trust(struct net_device *dev, int vf, bool val)
 155 {
 156         struct netdevsim *ns = netdev_priv(dev);
 157         struct nsim_dev *nsim_dev = ns->nsim_dev;
 158
 159         if (vf >= nsim_dev_get_vfs(nsim_dev))
 160                 return -EINVAL;
 161         nsim_dev->vfconfigs[vf].trusted = val;
 162
 163         return 0;
 164 }
 165
 166 static int
 167 nsim_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_info *ivi)
 168 {
 169         struct netdevsim *ns = netdev_priv(dev);
 170         struct nsim_dev *nsim_dev = ns->nsim_dev;
 171
 172         if (vf >= nsim_dev_get_vfs(nsim_dev))
 173                 return -EINVAL;
 174
 175         ivi->vf = vf;
 176         ivi->linkstate = nsim_dev->vfconfigs[vf].link_state;
 177         ivi->min_tx_rate = nsim_dev->vfconfigs[vf].min_tx_rate;
 178         ivi->max_tx_rate = nsim_dev->vfconfigs[vf].max_tx_rate;
 179         ivi->vlan = nsim_dev->vfconfigs[vf].vlan;
 180         ivi->vlan_proto = nsim_dev->vfconfigs[vf].vlan_proto;
 181         ivi->qos = nsim_dev->vfconfigs[vf].qos;
 182         memcpy(&ivi->mac, nsim_dev->vfconfigs[vf].vf_mac, ETH_ALEN);
 183         ivi->spoofchk = nsim_dev->vfconfigs[vf].spoofchk_enabled;
 184         ivi->trusted = nsim_dev->vfconfigs[vf].trusted;
 185         ivi->rss_query_en = nsim_dev->vfconfigs[vf].rss_query_enabled;
 186
 187         return 0;
 188 }
 189
 190 static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state)
 191 {
 192         struct netdevsim *ns = netdev_priv(dev);
 193         struct nsim_dev *nsim_dev = ns->nsim_dev;
 194
 195         if (vf >= nsim_dev_get_vfs(nsim_dev))
 196                 return -EINVAL;
 197
 198         switch (state) {
 199         case IFLA_VF_LINK_STATE_AUTO:
 200         case IFLA_VF_LINK_STATE_ENABLE:
 201         case IFLA_VF_LINK_STATE_DISABLE:
 202                 break;
 203         default:
 204                 return -EINVAL;
 205         }
 206
 207         nsim_dev->vfconfigs[vf].link_state = state;
 208
 209         return 0;
 210 }
 211
 212 static void nsim_taprio_stats(struct tc_taprio_qopt_stats *stats)
 213 {
 214         stats->window_drops = 0;
 215         stats->tx_overruns = 0;
 216 }
 217
 218 static int nsim_setup_tc_taprio(struct net_device *dev,
 219                                 struct tc_taprio_qopt_offload *offload)
 220 {
 221         int err = 0;
 222
 223         switch (offload->cmd) {
 224         case TAPRIO_CMD_REPLACE:
 225         case TAPRIO_CMD_DESTROY:
 226                 break;
 227         case TAPRIO_CMD_STATS:
 228                 nsim_taprio_stats(&offload->stats);
 229                 break;
 230         default:
 231                 err = -EOPNOTSUPP;
 232         }
 233
 234         return err;
 235 }
 236
 237 static LIST_HEAD(nsim_block_cb_list);
 238
 239 static int
 240 nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
 241 {
 242         struct netdevsim *ns = netdev_priv(dev);
 243
 244         switch (type) {
 245         case TC_SETUP_QDISC_TAPRIO:
 246                 return nsim_setup_tc_taprio(dev, type_data);
 247         case TC_SETUP_BLOCK:
 248                 return flow_block_cb_setup_simple(type_data,
 249                                                   &nsim_block_cb_list,
 250                                                   nsim_setup_tc_block_cb,
 251                                                   ns, ns, true);
 252         default:
 253                 return -EOPNOTSUPP;
 254         }
 255 }
 256
 257 static int
 258 nsim_set_features(struct net_device *dev, netdev_features_t features)
 259 {
 260         struct netdevsim *ns = netdev_priv(dev);
 261
 262         if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC))
 263                 return nsim_bpf_disable_tc(ns);
 264
 265         return 0;
 266 }
 267
 268 static const struct net_device_ops nsim_netdev_ops = {
 269         .ndo_start_xmit         = nsim_start_xmit,
 270         .ndo_set_rx_mode        = nsim_set_rx_mode,
 271         .ndo_set_mac_address    = eth_mac_addr,
 272         .ndo_validate_addr      = eth_validate_addr,
 273         .ndo_change_mtu         = nsim_change_mtu,
 274         .ndo_get_stats64        = nsim_get_stats64,
 275         .ndo_set_vf_mac         = nsim_set_vf_mac,
 276         .ndo_set_vf_vlan        = nsim_set_vf_vlan,
 277         .ndo_set_vf_rate        = nsim_set_vf_rate,
 278         .ndo_set_vf_spoofchk    = nsim_set_vf_spoofchk,
 279         .ndo_set_vf_trust       = nsim_set_vf_trust,
 280         .ndo_get_vf_config      = nsim_get_vf_config,
 281         .ndo_set_vf_link_state  = nsim_set_vf_link_state,
 282         .ndo_set_vf_rss_query_en = nsim_set_vf_rss_query_en,
 283         .ndo_setup_tc           = nsim_setup_tc,
 284         .ndo_set_features       = nsim_set_features,
 285         .ndo_bpf                = nsim_bpf,
 286 };
 287
 288 static const struct net_device_ops nsim_vf_netdev_ops = {
 289         .ndo_start_xmit         = nsim_start_xmit,
 290         .ndo_set_rx_mode        = nsim_set_rx_mode,
 291         .ndo_set_mac_address    = eth_mac_addr,
 292         .ndo_validate_addr      = eth_validate_addr,
 293         .ndo_change_mtu         = nsim_change_mtu,
 294         .ndo_get_stats64        = nsim_get_stats64,
 295         .ndo_setup_tc           = nsim_setup_tc,
 296         .ndo_set_features       = nsim_set_features,
 297 };
 298
 299 static void nsim_setup(struct net_device *dev)
 300 {
 301         ether_setup(dev);
 302         eth_hw_addr_random(dev);
 303
 304         dev->tx_queue_len = 0;
 305         dev->flags |= IFF_NOARP;
 306         dev->flags &= ~IFF_MULTICAST;
 307         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE |
 308                            IFF_NO_QUEUE;
 309         dev->features |= NETIF_F_HIGHDMA |
 310                          NETIF_F_SG |
 311                          NETIF_F_FRAGLIST |
 312                          NETIF_F_HW_CSUM |
 313                          NETIF_F_TSO;
 314         dev->hw_features |= NETIF_F_HW_TC;
 315         dev->max_mtu = ETH_MAX_MTU;
 316         dev->xdp_features = NETDEV_XDP_ACT_HW_OFFLOAD;
 317 }
 318
 319 static int nsim_init_netdevsim(struct netdevsim *ns)
 320 {
 321         struct mock_phc *phc;
 322         int err;
 323
 324         phc = mock_phc_create(&ns->nsim_bus_dev->dev);
 325         if (IS_ERR(phc))
 326                 return PTR_ERR(phc);
 327
 328         ns->phc = phc;
 329         ns->netdev->netdev_ops = &nsim_netdev_ops;
 330
 331         err = nsim_udp_tunnels_info_create(ns->nsim_dev, ns->netdev);
 332         if (err)
 333                 goto err_phc_destroy;
 334
 335         rtnl_lock();
 336         err = nsim_bpf_init(ns);
 337         if (err)
 338                 goto err_utn_destroy;
 339
 340         nsim_macsec_init(ns);
 341         nsim_ipsec_init(ns);
 342
 343         err = register_netdevice(ns->netdev);
 344         if (err)
 345                 goto err_ipsec_teardown;
 346         rtnl_unlock();
 347         return 0;
 348
 349 err_ipsec_teardown:
 350         nsim_ipsec_teardown(ns);
 351         nsim_macsec_teardown(ns);
 352         nsim_bpf_uninit(ns);
 353 err_utn_destroy:
 354         rtnl_unlock();
 355         nsim_udp_tunnels_info_destroy(ns->netdev);
 356 err_phc_destroy:
 357         mock_phc_destroy(ns->phc);
 358         return err;
 359 }
 360
 361 static int nsim_init_netdevsim_vf(struct netdevsim *ns)
 362 {
 363         int err;
 364
 365         ns->netdev->netdev_ops = &nsim_vf_netdev_ops;
 366         rtnl_lock();
 367         err = register_netdevice(ns->netdev);
 368         rtnl_unlock();
 369         return err;
 370 }
 371
 372 static void nsim_exit_netdevsim(struct netdevsim *ns)
 373 {
 374         nsim_udp_tunnels_info_destroy(ns->netdev);
 375         mock_phc_destroy(ns->phc);
 376 }
 377
 378 struct netdevsim *
 379 nsim_create(struct nsim_dev *nsim_dev, struct nsim_dev_port *nsim_dev_port)
 380 {
 381         struct net_device *dev;
 382         struct netdevsim *ns;
 383         int err;
 384
 385         dev = alloc_netdev_mq(sizeof(*ns), "eth%d", NET_NAME_UNKNOWN, nsim_setup,
 386                               nsim_dev->nsim_bus_dev->num_queues);
 387         if (!dev)
 388                 return ERR_PTR(-ENOMEM);
 389
 390         dev_net_set(dev, nsim_dev_net(nsim_dev));
 391         ns = netdev_priv(dev);
 392         ns->netdev = dev;
 393         u64_stats_init(&ns->syncp);
 394         ns->nsim_dev = nsim_dev;
 395         ns->nsim_dev_port = nsim_dev_port;
 396         ns->nsim_bus_dev = nsim_dev->nsim_bus_dev;
 397         SET_NETDEV_DEV(dev, &ns->nsim_bus_dev->dev);
 398         SET_NETDEV_DEVLINK_PORT(dev, &nsim_dev_port->devlink_port);
 399         nsim_ethtool_init(ns);
 400         if (nsim_dev_port_is_pf(nsim_dev_port))
 401                 err = nsim_init_netdevsim(ns);
 402         else
 403                 err = nsim_init_netdevsim_vf(ns);
 404         if (err)
 405                 goto err_free_netdev;
 406         return ns;
 407
 408 err_free_netdev:
 409         free_netdev(dev);
 410         return ERR_PTR(err);
 411 }
 412
 413 void nsim_destroy(struct netdevsim *ns)
 414 {
 415         struct net_device *dev = ns->netdev;
 416
 417         rtnl_lock();
 418         unregister_netdevice(dev);
 419         if (nsim_dev_port_is_pf(ns->nsim_dev_port)) {
 420                 nsim_macsec_teardown(ns);
 421                 nsim_ipsec_teardown(ns);
 422                 nsim_bpf_uninit(ns);
 423         }
 424         rtnl_unlock();
 425         if (nsim_dev_port_is_pf(ns->nsim_dev_port))
 426                 nsim_exit_netdevsim(ns);
 427         free_netdev(dev);
 428 }
 429
 430 static int nsim_validate(struct nlattr *tb[], struct nlattr *data[],
 431                          struct netlink_ext_ack *extack)
 432 {
 433         NL_SET_ERR_MSG_MOD(extack,
 434                            "Please use: echo \"[ID] [PORT_COUNT] [NUM_QUEUES]\" > /sys/bus/netdevsim/new_device");
 435         return -EOPNOTSUPP;
 436 }
 437
 438 static struct rtnl_link_ops nsim_link_ops __read_mostly = {
 439         .kind           = DRV_NAME,
 440         .validate       = nsim_validate,
 441 };
 442
 443 static int __init nsim_module_init(void)
 444 {
 445         int err;
 446
 447         err = nsim_dev_init();
 448         if (err)
 449                 return err;
 450
 451         err = nsim_bus_init();
 452         if (err)
 453                 goto err_dev_exit;
 454
 455         err = rtnl_link_register(&nsim_link_ops);
 456         if (err)
 457                 goto err_bus_exit;
 458
 459         return 0;
 460
 461 err_bus_exit:
 462         nsim_bus_exit();
 463 err_dev_exit:
 464         nsim_dev_exit();
 465         return err;
 466 }
 467
 468 static void __exit nsim_module_exit(void)
 469 {
 470         rtnl_link_unregister(&nsim_link_ops);
 471         nsim_bus_exit();
 472         nsim_dev_exit();
 473 }
 474
 475 module_init(nsim_module_init);
 476 module_exit(nsim_module_exit);
 477 MODULE_LICENSE("GPL");
 478 MODULE_ALIAS_RTNL_LINK(DRV_NAME);