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_bus_dev *nsim_bus_dev = ns->nsim_bus_dev; 86 87 /* Only refuse multicast addresses, zero address can mean unset/any. */ 88 if (vf >= nsim_bus_dev->num_vfs || is_multicast_ether_addr(mac)) 89 return -EINVAL; 90 memcpy(nsim_bus_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_bus_dev *nsim_bus_dev = ns->nsim_bus_dev; 100 101 if (vf >= nsim_bus_dev->num_vfs || vlan > 4095 || qos > 7) 102 return -EINVAL; 103 104 nsim_bus_dev->vfconfigs[vf].vlan = vlan; 105 nsim_bus_dev->vfconfigs[vf].qos = qos; 106 nsim_bus_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_bus_dev *nsim_bus_dev = ns->nsim_bus_dev; 115 116 if (vf >= nsim_bus_dev->num_vfs) 117 return -EINVAL; 118 119 nsim_bus_dev->vfconfigs[vf].min_tx_rate = min; 120 nsim_bus_dev->vfconfigs[vf].max_tx_rate = max; 121 122 return 0; 123 } 124 125 static int nsim_set_vf_spoofchk(struct net_device *dev, int vf, bool val) 126 { 127 struct netdevsim *ns = netdev_priv(dev); 128 struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev; 129 130 if (vf >= nsim_bus_dev->num_vfs) 131 return -EINVAL; 132 nsim_bus_dev->vfconfigs[vf].spoofchk_enabled = val; 133 134 return 0; 135 } 136 137 static int nsim_set_vf_rss_query_en(struct net_device *dev, int vf, bool val) 138 { 139 struct netdevsim *ns = netdev_priv(dev); 140 struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev; 141 142 if (vf >= nsim_bus_dev->num_vfs) 143 return -EINVAL; 144 nsim_bus_dev->vfconfigs[vf].rss_query_enabled = val; 145 146 return 0; 147 } 148 149 static int nsim_set_vf_trust(struct net_device *dev, int vf, bool val) 150 { 151 struct netdevsim *ns = netdev_priv(dev); 152 struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev; 153 154 if (vf >= nsim_bus_dev->num_vfs) 155 return -EINVAL; 156 nsim_bus_dev->vfconfigs[vf].trusted = val; 157 158 return 0; 159 } 160 161 static int 162 nsim_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_info *ivi) 163 { 164 struct netdevsim *ns = netdev_priv(dev); 165 struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev; 166 167 if (vf >= nsim_bus_dev->num_vfs) 168 return -EINVAL; 169 170 ivi->vf = vf; 171 ivi->linkstate = nsim_bus_dev->vfconfigs[vf].link_state; 172 ivi->min_tx_rate = nsim_bus_dev->vfconfigs[vf].min_tx_rate; 173 ivi->max_tx_rate = nsim_bus_dev->vfconfigs[vf].max_tx_rate; 174 ivi->vlan = nsim_bus_dev->vfconfigs[vf].vlan; 175 ivi->vlan_proto = nsim_bus_dev->vfconfigs[vf].vlan_proto; 176 ivi->qos = nsim_bus_dev->vfconfigs[vf].qos; 177 memcpy(&ivi->mac, nsim_bus_dev->vfconfigs[vf].vf_mac, ETH_ALEN); 178 ivi->spoofchk = nsim_bus_dev->vfconfigs[vf].spoofchk_enabled; 179 ivi->trusted = nsim_bus_dev->vfconfigs[vf].trusted; 180 ivi->rss_query_en = nsim_bus_dev->vfconfigs[vf].rss_query_enabled; 181 182 return 0; 183 } 184 185 static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state) 186 { 187 struct netdevsim *ns = netdev_priv(dev); 188 struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev; 189 190 if (vf >= nsim_bus_dev->num_vfs) 191 return -EINVAL; 192 193 switch (state) { 194 case IFLA_VF_LINK_STATE_AUTO: 195 case IFLA_VF_LINK_STATE_ENABLE: 196 case IFLA_VF_LINK_STATE_DISABLE: 197 break; 198 default: 199 return -EINVAL; 200 } 201 202 nsim_bus_dev->vfconfigs[vf].link_state = state; 203 204 return 0; 205 } 206 207 static LIST_HEAD(nsim_block_cb_list); 208 209 static int 210 nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data) 211 { 212 struct netdevsim *ns = netdev_priv(dev); 213 214 switch (type) { 215 case TC_SETUP_BLOCK: 216 return flow_block_cb_setup_simple(type_data, 217 &nsim_block_cb_list, 218 nsim_setup_tc_block_cb, 219 ns, ns, true); 220 default: 221 return -EOPNOTSUPP; 222 } 223 } 224 225 static int 226 nsim_set_features(struct net_device *dev, netdev_features_t features) 227 { 228 struct netdevsim *ns = netdev_priv(dev); 229 230 if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC)) 231 return nsim_bpf_disable_tc(ns); 232 233 return 0; 234 } 235 236 static struct devlink_port *nsim_get_devlink_port(struct net_device *dev) 237 { 238 struct netdevsim *ns = netdev_priv(dev); 239 240 return &ns->nsim_dev_port->devlink_port; 241 } 242 243 static const struct net_device_ops nsim_netdev_ops = { 244 .ndo_start_xmit = nsim_start_xmit, 245 .ndo_set_rx_mode = nsim_set_rx_mode, 246 .ndo_set_mac_address = eth_mac_addr, 247 .ndo_validate_addr = eth_validate_addr, 248 .ndo_change_mtu = nsim_change_mtu, 249 .ndo_get_stats64 = nsim_get_stats64, 250 .ndo_set_vf_mac = nsim_set_vf_mac, 251 .ndo_set_vf_vlan = nsim_set_vf_vlan, 252 .ndo_set_vf_rate = nsim_set_vf_rate, 253 .ndo_set_vf_spoofchk = nsim_set_vf_spoofchk, 254 .ndo_set_vf_trust = nsim_set_vf_trust, 255 .ndo_get_vf_config = nsim_get_vf_config, 256 .ndo_set_vf_link_state = nsim_set_vf_link_state, 257 .ndo_set_vf_rss_query_en = nsim_set_vf_rss_query_en, 258 .ndo_setup_tc = nsim_setup_tc, 259 .ndo_set_features = nsim_set_features, 260 .ndo_bpf = nsim_bpf, 261 .ndo_udp_tunnel_add = udp_tunnel_nic_add_port, 262 .ndo_udp_tunnel_del = udp_tunnel_nic_del_port, 263 .ndo_get_devlink_port = nsim_get_devlink_port, 264 }; 265 266 static void nsim_setup(struct net_device *dev) 267 { 268 ether_setup(dev); 269 eth_hw_addr_random(dev); 270 271 dev->tx_queue_len = 0; 272 dev->flags |= IFF_NOARP; 273 dev->flags &= ~IFF_MULTICAST; 274 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | 275 IFF_NO_QUEUE; 276 dev->features |= NETIF_F_HIGHDMA | 277 NETIF_F_SG | 278 NETIF_F_FRAGLIST | 279 NETIF_F_HW_CSUM | 280 NETIF_F_TSO; 281 dev->hw_features |= NETIF_F_HW_TC; 282 dev->max_mtu = ETH_MAX_MTU; 283 } 284 285 struct netdevsim * 286 nsim_create(struct nsim_dev *nsim_dev, struct nsim_dev_port *nsim_dev_port) 287 { 288 struct net_device *dev; 289 struct netdevsim *ns; 290 int err; 291 292 dev = alloc_netdev(sizeof(*ns), "eth%d", NET_NAME_UNKNOWN, nsim_setup); 293 if (!dev) 294 return ERR_PTR(-ENOMEM); 295 296 dev_net_set(dev, nsim_dev_net(nsim_dev)); 297 ns = netdev_priv(dev); 298 ns->netdev = dev; 299 ns->nsim_dev = nsim_dev; 300 ns->nsim_dev_port = nsim_dev_port; 301 ns->nsim_bus_dev = nsim_dev->nsim_bus_dev; 302 SET_NETDEV_DEV(dev, &ns->nsim_bus_dev->dev); 303 dev->netdev_ops = &nsim_netdev_ops; 304 305 err = nsim_udp_tunnels_info_create(nsim_dev, dev); 306 if (err) 307 goto err_free_netdev; 308 309 rtnl_lock(); 310 err = nsim_bpf_init(ns); 311 if (err) 312 goto err_utn_destroy; 313 314 nsim_ipsec_init(ns); 315 316 err = register_netdevice(dev); 317 if (err) 318 goto err_ipsec_teardown; 319 rtnl_unlock(); 320 321 return ns; 322 323 err_ipsec_teardown: 324 nsim_ipsec_teardown(ns); 325 nsim_bpf_uninit(ns); 326 err_utn_destroy: 327 rtnl_unlock(); 328 nsim_udp_tunnels_info_destroy(dev); 329 err_free_netdev: 330 free_netdev(dev); 331 return ERR_PTR(err); 332 } 333 334 void nsim_destroy(struct netdevsim *ns) 335 { 336 struct net_device *dev = ns->netdev; 337 338 rtnl_lock(); 339 unregister_netdevice(dev); 340 nsim_ipsec_teardown(ns); 341 nsim_bpf_uninit(ns); 342 rtnl_unlock(); 343 nsim_udp_tunnels_info_destroy(dev); 344 free_netdev(dev); 345 } 346 347 static int nsim_validate(struct nlattr *tb[], struct nlattr *data[], 348 struct netlink_ext_ack *extack) 349 { 350 NL_SET_ERR_MSG_MOD(extack, "Please use: echo \"[ID] [PORT_COUNT]\" > /sys/bus/netdevsim/new_device"); 351 return -EOPNOTSUPP; 352 } 353 354 static struct rtnl_link_ops nsim_link_ops __read_mostly = { 355 .kind = DRV_NAME, 356 .validate = nsim_validate, 357 }; 358 359 static int __init nsim_module_init(void) 360 { 361 int err; 362 363 err = nsim_dev_init(); 364 if (err) 365 return err; 366 367 err = nsim_bus_init(); 368 if (err) 369 goto err_dev_exit; 370 371 err = rtnl_link_register(&nsim_link_ops); 372 if (err) 373 goto err_bus_exit; 374 375 return 0; 376 377 err_bus_exit: 378 nsim_bus_exit(); 379 err_dev_exit: 380 nsim_dev_exit(); 381 return err; 382 } 383 384 static void __exit nsim_module_exit(void) 385 { 386 rtnl_link_unregister(&nsim_link_ops); 387 nsim_bus_exit(); 388 nsim_dev_exit(); 389 } 390 391 module_init(nsim_module_init); 392 module_exit(nsim_module_exit); 393 MODULE_LICENSE("GPL"); 394 MODULE_ALIAS_RTNL_LINK(DRV_NAME); 395