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); 479