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 static void 50 nfp_repr_inc_tx_stats(struct net_device *netdev, unsigned int len, 51 int tx_status) 52 { 53 struct nfp_repr *repr = netdev_priv(netdev); 54 struct nfp_repr_pcpu_stats *stats; 55 56 if (unlikely(tx_status != NET_XMIT_SUCCESS && 57 tx_status != NET_XMIT_CN)) { 58 this_cpu_inc(repr->stats->tx_drops); 59 return; 60 } 61 62 stats = this_cpu_ptr(repr->stats); 63 u64_stats_update_begin(&stats->syncp); 64 stats->tx_packets++; 65 stats->tx_bytes += len; 66 u64_stats_update_end(&stats->syncp); 67 } 68 69 void nfp_repr_inc_rx_stats(struct net_device *netdev, unsigned int len) 70 { 71 struct nfp_repr *repr = netdev_priv(netdev); 72 struct nfp_repr_pcpu_stats *stats; 73 74 stats = this_cpu_ptr(repr->stats); 75 u64_stats_update_begin(&stats->syncp); 76 stats->rx_packets++; 77 stats->rx_bytes += len; 78 u64_stats_update_end(&stats->syncp); 79 } 80 81 static void 82 nfp_repr_phy_port_get_stats64(struct nfp_port *port, 83 struct rtnl_link_stats64 *stats) 84 { 85 u8 __iomem *mem = port->eth_stats; 86 87 stats->tx_packets = readq(mem + NFP_MAC_STATS_TX_FRAMES_TRANSMITTED_OK); 88 stats->tx_bytes = readq(mem + NFP_MAC_STATS_TX_OUT_OCTETS); 89 stats->tx_dropped = readq(mem + NFP_MAC_STATS_TX_OUT_ERRORS); 90 91 stats->rx_packets = readq(mem + NFP_MAC_STATS_RX_FRAMES_RECEIVED_OK); 92 stats->rx_bytes = readq(mem + NFP_MAC_STATS_RX_IN_OCTETS); 93 stats->rx_dropped = readq(mem + NFP_MAC_STATS_RX_IN_ERRORS); 94 } 95 96 static void 97 nfp_repr_vnic_get_stats64(struct nfp_port *port, 98 struct rtnl_link_stats64 *stats) 99 { 100 /* TX and RX stats are flipped as we are returning the stats as seen 101 * at the switch port corresponding to the VF. 102 */ 103 stats->tx_packets = readq(port->vnic + NFP_NET_CFG_STATS_RX_FRAMES); 104 stats->tx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_RX_OCTETS); 105 stats->tx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_RX_DISCARDS); 106 107 stats->rx_packets = readq(port->vnic + NFP_NET_CFG_STATS_TX_FRAMES); 108 stats->rx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_TX_OCTETS); 109 stats->rx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_TX_DISCARDS); 110 } 111 112 static void 113 nfp_repr_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) 114 { 115 struct nfp_repr *repr = netdev_priv(netdev); 116 117 if (WARN_ON(!repr->port)) 118 return; 119 120 switch (repr->port->type) { 121 case NFP_PORT_PHYS_PORT: 122 if (!__nfp_port_get_eth_port(repr->port)) 123 break; 124 nfp_repr_phy_port_get_stats64(repr->port, stats); 125 break; 126 case NFP_PORT_PF_PORT: 127 case NFP_PORT_VF_PORT: 128 nfp_repr_vnic_get_stats64(repr->port, stats); 129 default: 130 break; 131 } 132 } 133 134 static bool 135 nfp_repr_has_offload_stats(const struct net_device *dev, int attr_id) 136 { 137 switch (attr_id) { 138 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 139 return true; 140 } 141 142 return false; 143 } 144 145 static int 146 nfp_repr_get_host_stats64(const struct net_device *netdev, 147 struct rtnl_link_stats64 *stats) 148 { 149 struct nfp_repr *repr = netdev_priv(netdev); 150 int i; 151 152 for_each_possible_cpu(i) { 153 u64 tbytes, tpkts, tdrops, rbytes, rpkts; 154 struct nfp_repr_pcpu_stats *repr_stats; 155 unsigned int start; 156 157 repr_stats = per_cpu_ptr(repr->stats, i); 158 do { 159 start = u64_stats_fetch_begin_irq(&repr_stats->syncp); 160 tbytes = repr_stats->tx_bytes; 161 tpkts = repr_stats->tx_packets; 162 tdrops = repr_stats->tx_drops; 163 rbytes = repr_stats->rx_bytes; 164 rpkts = repr_stats->rx_packets; 165 } while (u64_stats_fetch_retry_irq(&repr_stats->syncp, start)); 166 167 stats->tx_bytes += tbytes; 168 stats->tx_packets += tpkts; 169 stats->tx_dropped += tdrops; 170 stats->rx_bytes += rbytes; 171 stats->rx_packets += rpkts; 172 } 173 174 return 0; 175 } 176 177 static int 178 nfp_repr_get_offload_stats(int attr_id, const struct net_device *dev, 179 void *stats) 180 { 181 switch (attr_id) { 182 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 183 return nfp_repr_get_host_stats64(dev, stats); 184 } 185 186 return -EINVAL; 187 } 188 189 static netdev_tx_t nfp_repr_xmit(struct sk_buff *skb, struct net_device *netdev) 190 { 191 struct nfp_repr *repr = netdev_priv(netdev); 192 unsigned int len = skb->len; 193 int ret; 194 195 skb_dst_drop(skb); 196 dst_hold((struct dst_entry *)repr->dst); 197 skb_dst_set(skb, (struct dst_entry *)repr->dst); 198 skb->dev = repr->dst->u.port_info.lower_dev; 199 200 ret = dev_queue_xmit(skb); 201 nfp_repr_inc_tx_stats(netdev, len, ret); 202 203 return ret; 204 } 205 206 static int nfp_repr_stop(struct net_device *netdev) 207 { 208 struct nfp_repr *repr = netdev_priv(netdev); 209 int err; 210 211 err = nfp_app_repr_stop(repr->app, repr); 212 if (err) 213 return err; 214 215 nfp_port_configure(netdev, false); 216 return 0; 217 } 218 219 static int nfp_repr_open(struct net_device *netdev) 220 { 221 struct nfp_repr *repr = netdev_priv(netdev); 222 int err; 223 224 err = nfp_port_configure(netdev, true); 225 if (err) 226 return err; 227 228 err = nfp_app_repr_open(repr->app, repr); 229 if (err) 230 goto err_port_disable; 231 232 return 0; 233 234 err_port_disable: 235 nfp_port_configure(netdev, false); 236 return err; 237 } 238 239 const struct net_device_ops nfp_repr_netdev_ops = { 240 .ndo_open = nfp_repr_open, 241 .ndo_stop = nfp_repr_stop, 242 .ndo_start_xmit = nfp_repr_xmit, 243 .ndo_get_stats64 = nfp_repr_get_stats64, 244 .ndo_has_offload_stats = nfp_repr_has_offload_stats, 245 .ndo_get_offload_stats = nfp_repr_get_offload_stats, 246 .ndo_get_phys_port_name = nfp_port_get_phys_port_name, 247 .ndo_setup_tc = nfp_port_setup_tc, 248 .ndo_set_vf_mac = nfp_app_set_vf_mac, 249 .ndo_set_vf_vlan = nfp_app_set_vf_vlan, 250 .ndo_set_vf_spoofchk = nfp_app_set_vf_spoofchk, 251 .ndo_get_vf_config = nfp_app_get_vf_config, 252 .ndo_set_vf_link_state = nfp_app_set_vf_link_state, 253 }; 254 255 static void nfp_repr_clean(struct nfp_repr *repr) 256 { 257 unregister_netdev(repr->netdev); 258 nfp_app_repr_clean(repr->app, repr->netdev); 259 dst_release((struct dst_entry *)repr->dst); 260 nfp_port_free(repr->port); 261 } 262 263 static struct lock_class_key nfp_repr_netdev_xmit_lock_key; 264 static struct lock_class_key nfp_repr_netdev_addr_lock_key; 265 266 static void nfp_repr_set_lockdep_class_one(struct net_device *dev, 267 struct netdev_queue *txq, 268 void *_unused) 269 { 270 lockdep_set_class(&txq->_xmit_lock, &nfp_repr_netdev_xmit_lock_key); 271 } 272 273 static void nfp_repr_set_lockdep_class(struct net_device *dev) 274 { 275 lockdep_set_class(&dev->addr_list_lock, &nfp_repr_netdev_addr_lock_key); 276 netdev_for_each_tx_queue(dev, nfp_repr_set_lockdep_class_one, NULL); 277 } 278 279 int nfp_repr_init(struct nfp_app *app, struct net_device *netdev, 280 u32 cmsg_port_id, struct nfp_port *port, 281 struct net_device *pf_netdev) 282 { 283 struct nfp_repr *repr = netdev_priv(netdev); 284 int err; 285 286 nfp_repr_set_lockdep_class(netdev); 287 288 repr->port = port; 289 repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX, GFP_KERNEL); 290 if (!repr->dst) 291 return -ENOMEM; 292 repr->dst->u.port_info.port_id = cmsg_port_id; 293 repr->dst->u.port_info.lower_dev = pf_netdev; 294 295 netdev->netdev_ops = &nfp_repr_netdev_ops; 296 netdev->ethtool_ops = &nfp_port_ethtool_ops; 297 298 netdev->max_mtu = pf_netdev->max_mtu; 299 300 SWITCHDEV_SET_OPS(netdev, &nfp_port_switchdev_ops); 301 302 if (nfp_app_has_tc(app)) { 303 netdev->features |= NETIF_F_HW_TC; 304 netdev->hw_features |= NETIF_F_HW_TC; 305 } 306 307 err = nfp_app_repr_init(app, netdev); 308 if (err) 309 goto err_clean; 310 311 err = register_netdev(netdev); 312 if (err) 313 goto err_repr_clean; 314 315 return 0; 316 317 err_repr_clean: 318 nfp_app_repr_clean(app, netdev); 319 err_clean: 320 dst_release((struct dst_entry *)repr->dst); 321 return err; 322 } 323 324 static void nfp_repr_free(struct nfp_repr *repr) 325 { 326 free_percpu(repr->stats); 327 free_netdev(repr->netdev); 328 } 329 330 struct net_device *nfp_repr_alloc(struct nfp_app *app) 331 { 332 struct net_device *netdev; 333 struct nfp_repr *repr; 334 335 netdev = alloc_etherdev(sizeof(*repr)); 336 if (!netdev) 337 return NULL; 338 339 repr = netdev_priv(netdev); 340 repr->netdev = netdev; 341 repr->app = app; 342 343 repr->stats = netdev_alloc_pcpu_stats(struct nfp_repr_pcpu_stats); 344 if (!repr->stats) 345 goto err_free_netdev; 346 347 return netdev; 348 349 err_free_netdev: 350 free_netdev(netdev); 351 return NULL; 352 } 353 354 static void nfp_repr_clean_and_free(struct nfp_repr *repr) 355 { 356 nfp_info(repr->app->cpp, "Destroying Representor(%s)\n", 357 repr->netdev->name); 358 nfp_repr_clean(repr); 359 nfp_repr_free(repr); 360 } 361 362 void nfp_reprs_clean_and_free(struct nfp_reprs *reprs) 363 { 364 unsigned int i; 365 366 for (i = 0; i < reprs->num_reprs; i++) 367 if (reprs->reprs[i]) 368 nfp_repr_clean_and_free(netdev_priv(reprs->reprs[i])); 369 370 kfree(reprs); 371 } 372 373 void 374 nfp_reprs_clean_and_free_by_type(struct nfp_app *app, 375 enum nfp_repr_type type) 376 { 377 struct nfp_reprs *reprs; 378 379 reprs = nfp_app_reprs_set(app, type, NULL); 380 if (!reprs) 381 return; 382 383 synchronize_rcu(); 384 nfp_reprs_clean_and_free(reprs); 385 } 386 387 struct nfp_reprs *nfp_reprs_alloc(unsigned int num_reprs) 388 { 389 struct nfp_reprs *reprs; 390 391 reprs = kzalloc(sizeof(*reprs) + 392 num_reprs * sizeof(struct net_device *), GFP_KERNEL); 393 if (!reprs) 394 return NULL; 395 reprs->num_reprs = num_reprs; 396 397 return reprs; 398 } 399 400 int nfp_reprs_resync_phys_ports(struct nfp_app *app) 401 { 402 struct nfp_reprs *reprs, *old_reprs; 403 struct nfp_repr *repr; 404 int i; 405 406 old_reprs = 407 rcu_dereference_protected(app->reprs[NFP_REPR_TYPE_PHYS_PORT], 408 lockdep_is_held(&app->pf->lock)); 409 if (!old_reprs) 410 return 0; 411 412 reprs = nfp_reprs_alloc(old_reprs->num_reprs); 413 if (!reprs) 414 return -ENOMEM; 415 416 for (i = 0; i < old_reprs->num_reprs; i++) { 417 if (!old_reprs->reprs[i]) 418 continue; 419 420 repr = netdev_priv(old_reprs->reprs[i]); 421 if (repr->port->type == NFP_PORT_INVALID) 422 continue; 423 424 reprs->reprs[i] = old_reprs->reprs[i]; 425 } 426 427 old_reprs = nfp_app_reprs_set(app, NFP_REPR_TYPE_PHYS_PORT, reprs); 428 synchronize_rcu(); 429 430 /* Now we free up removed representors */ 431 for (i = 0; i < old_reprs->num_reprs; i++) { 432 if (!old_reprs->reprs[i]) 433 continue; 434 435 repr = netdev_priv(old_reprs->reprs[i]); 436 if (repr->port->type != NFP_PORT_INVALID) 437 continue; 438 439 nfp_app_repr_stop(app, repr); 440 nfp_repr_clean(repr); 441 } 442 443 kfree(old_reprs); 444 return 0; 445 } 446