1 /* 2 * Copyright (C) 2017 Netronome Systems, Inc. 3 * 4 * This software is dual 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 or the BSD 2-Clause License provided below. You have the 7 * option to license this software under the complete terms of either license. 8 * 9 * The BSD 2-Clause License: 10 * 11 * Redistribution and use in source and binary forms, with or 12 * without modification, are permitted provided that the following 13 * conditions are met: 14 * 15 * 1. Redistributions of source code must retain the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer. 18 * 19 * 2. Redistributions in binary form must reproduce the above 20 * copyright notice, this list of conditions and the following 21 * disclaimer in the documentation and/or other materials 22 * provided with the distribution. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 31 * SOFTWARE. 32 */ 33 34 #include <linux/etherdevice.h> 35 #include <linux/io-64-nonatomic-hi-lo.h> 36 #include <linux/lockdep.h> 37 #include <net/dst_metadata.h> 38 #include <net/switchdev.h> 39 40 #include "nfpcore/nfp_cpp.h" 41 #include "nfpcore/nfp_nsp.h" 42 #include "nfp_app.h" 43 #include "nfp_main.h" 44 #include "nfp_net_ctrl.h" 45 #include "nfp_net_repr.h" 46 #include "nfp_net_sriov.h" 47 #include "nfp_port.h" 48 49 struct net_device * 50 nfp_repr_get_locked(struct nfp_app *app, struct nfp_reprs *set, unsigned int id) 51 { 52 return rcu_dereference_protected(set->reprs[id], 53 lockdep_is_held(&app->pf->lock)); 54 } 55 56 static void 57 nfp_repr_inc_tx_stats(struct net_device *netdev, unsigned int len, 58 int tx_status) 59 { 60 struct nfp_repr *repr = netdev_priv(netdev); 61 struct nfp_repr_pcpu_stats *stats; 62 63 if (unlikely(tx_status != NET_XMIT_SUCCESS && 64 tx_status != NET_XMIT_CN)) { 65 this_cpu_inc(repr->stats->tx_drops); 66 return; 67 } 68 69 stats = this_cpu_ptr(repr->stats); 70 u64_stats_update_begin(&stats->syncp); 71 stats->tx_packets++; 72 stats->tx_bytes += len; 73 u64_stats_update_end(&stats->syncp); 74 } 75 76 void nfp_repr_inc_rx_stats(struct net_device *netdev, unsigned int len) 77 { 78 struct nfp_repr *repr = netdev_priv(netdev); 79 struct nfp_repr_pcpu_stats *stats; 80 81 stats = this_cpu_ptr(repr->stats); 82 u64_stats_update_begin(&stats->syncp); 83 stats->rx_packets++; 84 stats->rx_bytes += len; 85 u64_stats_update_end(&stats->syncp); 86 } 87 88 static void 89 nfp_repr_phy_port_get_stats64(struct nfp_port *port, 90 struct rtnl_link_stats64 *stats) 91 { 92 u8 __iomem *mem = port->eth_stats; 93 94 stats->tx_packets = readq(mem + NFP_MAC_STATS_TX_FRAMES_TRANSMITTED_OK); 95 stats->tx_bytes = readq(mem + NFP_MAC_STATS_TX_OUT_OCTETS); 96 stats->tx_dropped = readq(mem + NFP_MAC_STATS_TX_OUT_ERRORS); 97 98 stats->rx_packets = readq(mem + NFP_MAC_STATS_RX_FRAMES_RECEIVED_OK); 99 stats->rx_bytes = readq(mem + NFP_MAC_STATS_RX_IN_OCTETS); 100 stats->rx_dropped = readq(mem + NFP_MAC_STATS_RX_IN_ERRORS); 101 } 102 103 static void 104 nfp_repr_vnic_get_stats64(struct nfp_port *port, 105 struct rtnl_link_stats64 *stats) 106 { 107 /* TX and RX stats are flipped as we are returning the stats as seen 108 * at the switch port corresponding to the VF. 109 */ 110 stats->tx_packets = readq(port->vnic + NFP_NET_CFG_STATS_RX_FRAMES); 111 stats->tx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_RX_OCTETS); 112 stats->tx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_RX_DISCARDS); 113 114 stats->rx_packets = readq(port->vnic + NFP_NET_CFG_STATS_TX_FRAMES); 115 stats->rx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_TX_OCTETS); 116 stats->rx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_TX_DISCARDS); 117 } 118 119 static void 120 nfp_repr_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) 121 { 122 struct nfp_repr *repr = netdev_priv(netdev); 123 124 if (WARN_ON(!repr->port)) 125 return; 126 127 switch (repr->port->type) { 128 case NFP_PORT_PHYS_PORT: 129 if (!__nfp_port_get_eth_port(repr->port)) 130 break; 131 nfp_repr_phy_port_get_stats64(repr->port, stats); 132 break; 133 case NFP_PORT_PF_PORT: 134 case NFP_PORT_VF_PORT: 135 nfp_repr_vnic_get_stats64(repr->port, stats); 136 default: 137 break; 138 } 139 } 140 141 static bool 142 nfp_repr_has_offload_stats(const struct net_device *dev, int attr_id) 143 { 144 switch (attr_id) { 145 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 146 return true; 147 } 148 149 return false; 150 } 151 152 static int 153 nfp_repr_get_host_stats64(const struct net_device *netdev, 154 struct rtnl_link_stats64 *stats) 155 { 156 struct nfp_repr *repr = netdev_priv(netdev); 157 int i; 158 159 for_each_possible_cpu(i) { 160 u64 tbytes, tpkts, tdrops, rbytes, rpkts; 161 struct nfp_repr_pcpu_stats *repr_stats; 162 unsigned int start; 163 164 repr_stats = per_cpu_ptr(repr->stats, i); 165 do { 166 start = u64_stats_fetch_begin_irq(&repr_stats->syncp); 167 tbytes = repr_stats->tx_bytes; 168 tpkts = repr_stats->tx_packets; 169 tdrops = repr_stats->tx_drops; 170 rbytes = repr_stats->rx_bytes; 171 rpkts = repr_stats->rx_packets; 172 } while (u64_stats_fetch_retry_irq(&repr_stats->syncp, start)); 173 174 stats->tx_bytes += tbytes; 175 stats->tx_packets += tpkts; 176 stats->tx_dropped += tdrops; 177 stats->rx_bytes += rbytes; 178 stats->rx_packets += rpkts; 179 } 180 181 return 0; 182 } 183 184 static int 185 nfp_repr_get_offload_stats(int attr_id, const struct net_device *dev, 186 void *stats) 187 { 188 switch (attr_id) { 189 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 190 return nfp_repr_get_host_stats64(dev, stats); 191 } 192 193 return -EINVAL; 194 } 195 196 static int nfp_repr_change_mtu(struct net_device *netdev, int new_mtu) 197 { 198 struct nfp_repr *repr = netdev_priv(netdev); 199 int err; 200 201 err = nfp_app_check_mtu(repr->app, netdev, new_mtu); 202 if (err) 203 return err; 204 205 err = nfp_app_repr_change_mtu(repr->app, netdev, new_mtu); 206 if (err) 207 return err; 208 209 netdev->mtu = new_mtu; 210 211 return 0; 212 } 213 214 static netdev_tx_t nfp_repr_xmit(struct sk_buff *skb, struct net_device *netdev) 215 { 216 struct nfp_repr *repr = netdev_priv(netdev); 217 unsigned int len = skb->len; 218 int ret; 219 220 skb_dst_drop(skb); 221 dst_hold((struct dst_entry *)repr->dst); 222 skb_dst_set(skb, (struct dst_entry *)repr->dst); 223 skb->dev = repr->dst->u.port_info.lower_dev; 224 225 ret = dev_queue_xmit(skb); 226 nfp_repr_inc_tx_stats(netdev, len, ret); 227 228 return ret; 229 } 230 231 static int nfp_repr_stop(struct net_device *netdev) 232 { 233 struct nfp_repr *repr = netdev_priv(netdev); 234 int err; 235 236 err = nfp_app_repr_stop(repr->app, repr); 237 if (err) 238 return err; 239 240 nfp_port_configure(netdev, false); 241 return 0; 242 } 243 244 static int nfp_repr_open(struct net_device *netdev) 245 { 246 struct nfp_repr *repr = netdev_priv(netdev); 247 int err; 248 249 err = nfp_port_configure(netdev, true); 250 if (err) 251 return err; 252 253 err = nfp_app_repr_open(repr->app, repr); 254 if (err) 255 goto err_port_disable; 256 257 return 0; 258 259 err_port_disable: 260 nfp_port_configure(netdev, false); 261 return err; 262 } 263 264 const struct net_device_ops nfp_repr_netdev_ops = { 265 .ndo_init = nfp_app_ndo_init, 266 .ndo_uninit = nfp_app_ndo_uninit, 267 .ndo_open = nfp_repr_open, 268 .ndo_stop = nfp_repr_stop, 269 .ndo_start_xmit = nfp_repr_xmit, 270 .ndo_change_mtu = nfp_repr_change_mtu, 271 .ndo_get_stats64 = nfp_repr_get_stats64, 272 .ndo_has_offload_stats = nfp_repr_has_offload_stats, 273 .ndo_get_offload_stats = nfp_repr_get_offload_stats, 274 .ndo_get_phys_port_name = nfp_port_get_phys_port_name, 275 .ndo_setup_tc = nfp_port_setup_tc, 276 .ndo_set_vf_mac = nfp_app_set_vf_mac, 277 .ndo_set_vf_vlan = nfp_app_set_vf_vlan, 278 .ndo_set_vf_spoofchk = nfp_app_set_vf_spoofchk, 279 .ndo_get_vf_config = nfp_app_get_vf_config, 280 .ndo_set_vf_link_state = nfp_app_set_vf_link_state, 281 .ndo_set_features = nfp_port_set_features, 282 .ndo_set_mac_address = eth_mac_addr, 283 }; 284 285 static void nfp_repr_clean(struct nfp_repr *repr) 286 { 287 unregister_netdev(repr->netdev); 288 nfp_app_repr_clean(repr->app, repr->netdev); 289 dst_release((struct dst_entry *)repr->dst); 290 nfp_port_free(repr->port); 291 } 292 293 static struct lock_class_key nfp_repr_netdev_xmit_lock_key; 294 static struct lock_class_key nfp_repr_netdev_addr_lock_key; 295 296 static void nfp_repr_set_lockdep_class_one(struct net_device *dev, 297 struct netdev_queue *txq, 298 void *_unused) 299 { 300 lockdep_set_class(&txq->_xmit_lock, &nfp_repr_netdev_xmit_lock_key); 301 } 302 303 static void nfp_repr_set_lockdep_class(struct net_device *dev) 304 { 305 lockdep_set_class(&dev->addr_list_lock, &nfp_repr_netdev_addr_lock_key); 306 netdev_for_each_tx_queue(dev, nfp_repr_set_lockdep_class_one, NULL); 307 } 308 309 int nfp_repr_init(struct nfp_app *app, struct net_device *netdev, 310 u32 cmsg_port_id, struct nfp_port *port, 311 struct net_device *pf_netdev) 312 { 313 struct nfp_repr *repr = netdev_priv(netdev); 314 int err; 315 316 nfp_repr_set_lockdep_class(netdev); 317 318 repr->port = port; 319 repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX, GFP_KERNEL); 320 if (!repr->dst) 321 return -ENOMEM; 322 repr->dst->u.port_info.port_id = cmsg_port_id; 323 repr->dst->u.port_info.lower_dev = pf_netdev; 324 325 netdev->netdev_ops = &nfp_repr_netdev_ops; 326 netdev->ethtool_ops = &nfp_port_ethtool_ops; 327 328 netdev->max_mtu = pf_netdev->max_mtu; 329 330 SWITCHDEV_SET_OPS(netdev, &nfp_port_switchdev_ops); 331 332 if (nfp_app_has_tc(app)) { 333 netdev->features |= NETIF_F_HW_TC; 334 netdev->hw_features |= NETIF_F_HW_TC; 335 } 336 337 err = nfp_app_repr_init(app, netdev); 338 if (err) 339 goto err_clean; 340 341 err = register_netdev(netdev); 342 if (err) 343 goto err_repr_clean; 344 345 return 0; 346 347 err_repr_clean: 348 nfp_app_repr_clean(app, netdev); 349 err_clean: 350 dst_release((struct dst_entry *)repr->dst); 351 return err; 352 } 353 354 static void __nfp_repr_free(struct nfp_repr *repr) 355 { 356 free_percpu(repr->stats); 357 free_netdev(repr->netdev); 358 } 359 360 void nfp_repr_free(struct net_device *netdev) 361 { 362 __nfp_repr_free(netdev_priv(netdev)); 363 } 364 365 struct net_device * 366 nfp_repr_alloc_mqs(struct nfp_app *app, unsigned int txqs, unsigned int rxqs) 367 { 368 struct net_device *netdev; 369 struct nfp_repr *repr; 370 371 netdev = alloc_etherdev_mqs(sizeof(*repr), txqs, rxqs); 372 if (!netdev) 373 return NULL; 374 375 netif_carrier_off(netdev); 376 377 repr = netdev_priv(netdev); 378 repr->netdev = netdev; 379 repr->app = app; 380 381 repr->stats = netdev_alloc_pcpu_stats(struct nfp_repr_pcpu_stats); 382 if (!repr->stats) 383 goto err_free_netdev; 384 385 return netdev; 386 387 err_free_netdev: 388 free_netdev(netdev); 389 return NULL; 390 } 391 392 void nfp_repr_clean_and_free(struct nfp_repr *repr) 393 { 394 nfp_info(repr->app->cpp, "Destroying Representor(%s)\n", 395 repr->netdev->name); 396 nfp_repr_clean(repr); 397 __nfp_repr_free(repr); 398 } 399 400 void nfp_reprs_clean_and_free(struct nfp_app *app, struct nfp_reprs *reprs) 401 { 402 struct net_device *netdev; 403 unsigned int i; 404 405 for (i = 0; i < reprs->num_reprs; i++) { 406 netdev = nfp_repr_get_locked(app, reprs, i); 407 if (netdev) 408 nfp_repr_clean_and_free(netdev_priv(netdev)); 409 } 410 411 kfree(reprs); 412 } 413 414 void 415 nfp_reprs_clean_and_free_by_type(struct nfp_app *app, enum nfp_repr_type type) 416 { 417 struct net_device *netdev; 418 struct nfp_reprs *reprs; 419 int i; 420 421 reprs = rcu_dereference_protected(app->reprs[type], 422 lockdep_is_held(&app->pf->lock)); 423 if (!reprs) 424 return; 425 426 /* Preclean must happen before we remove the reprs reference from the 427 * app below. 428 */ 429 for (i = 0; i < reprs->num_reprs; i++) { 430 netdev = nfp_repr_get_locked(app, reprs, i); 431 if (netdev) 432 nfp_app_repr_preclean(app, netdev); 433 } 434 435 reprs = nfp_app_reprs_set(app, type, NULL); 436 437 synchronize_rcu(); 438 nfp_reprs_clean_and_free(app, reprs); 439 } 440 441 struct nfp_reprs *nfp_reprs_alloc(unsigned int num_reprs) 442 { 443 struct nfp_reprs *reprs; 444 445 reprs = kzalloc(sizeof(*reprs) + 446 num_reprs * sizeof(struct net_device *), GFP_KERNEL); 447 if (!reprs) 448 return NULL; 449 reprs->num_reprs = num_reprs; 450 451 return reprs; 452 } 453 454 int nfp_reprs_resync_phys_ports(struct nfp_app *app) 455 { 456 struct net_device *netdev; 457 struct nfp_reprs *reprs; 458 struct nfp_repr *repr; 459 int i; 460 461 reprs = nfp_reprs_get_locked(app, NFP_REPR_TYPE_PHYS_PORT); 462 if (!reprs) 463 return 0; 464 465 for (i = 0; i < reprs->num_reprs; i++) { 466 netdev = nfp_repr_get_locked(app, reprs, i); 467 if (!netdev) 468 continue; 469 470 repr = netdev_priv(netdev); 471 if (repr->port->type != NFP_PORT_INVALID) 472 continue; 473 474 nfp_app_repr_preclean(app, netdev); 475 rcu_assign_pointer(reprs->reprs[i], NULL); 476 synchronize_rcu(); 477 nfp_repr_clean(repr); 478 } 479 480 return 0; 481 } 482