drivers/net/ethernet/intel/ice/ice_repr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2019-2021, Intel Corporation. */
   3
   4 #include "ice.h"
   5 #include "ice_eswitch.h"
   6 #include "devlink/devlink.h"
   7 #include "devlink/devlink_port.h"
   8 #include "ice_sriov.h"
   9 #include "ice_tc_lib.h"
  10 #include "ice_dcb_lib.h"
  11
  12 /**
  13  * ice_repr_inc_tx_stats - increment Tx statistic by one packet
  14  * @repr: repr to increment stats on
  15  * @len: length of the packet
  16  * @xmit_status: value returned by xmit function
  17  */
  18 void ice_repr_inc_tx_stats(struct ice_repr *repr, unsigned int len,
  19                            int xmit_status)
  20 {
  21         struct ice_repr_pcpu_stats *stats;
  22
  23         if (unlikely(xmit_status != NET_XMIT_SUCCESS &&
  24                      xmit_status != NET_XMIT_CN)) {
  25                 this_cpu_inc(repr->stats->tx_drops);
  26                 return;
  27         }
  28
  29         stats = this_cpu_ptr(repr->stats);
  30         u64_stats_update_begin(&stats->syncp);
  31         stats->tx_packets++;
  32         stats->tx_bytes += len;
  33         u64_stats_update_end(&stats->syncp);
  34 }
  35
  36 /**
  37  * ice_repr_inc_rx_stats - increment Rx statistic by one packet
  38  * @netdev: repr netdev to increment stats on
  39  * @len: length of the packet
  40  */
  41 void ice_repr_inc_rx_stats(struct net_device *netdev, unsigned int len)
  42 {
  43         struct ice_repr *repr = ice_netdev_to_repr(netdev);
  44         struct ice_repr_pcpu_stats *stats;
  45
  46         stats = this_cpu_ptr(repr->stats);
  47         u64_stats_update_begin(&stats->syncp);
  48         stats->rx_packets++;
  49         stats->rx_bytes += len;
  50         u64_stats_update_end(&stats->syncp);
  51 }
  52
  53 /**
  54  * ice_repr_get_stats64 - get VF stats for VFPR use
  55  * @netdev: pointer to port representor netdev
  56  * @stats: pointer to struct where stats can be stored
  57  */
  58 static void
  59 ice_repr_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats)
  60 {
  61         struct ice_netdev_priv *np = netdev_priv(netdev);
  62         struct ice_repr *repr = np->repr;
  63         struct ice_eth_stats *eth_stats;
  64         struct ice_vsi *vsi;
  65
  66         if (repr->ops.ready(repr))
  67                 return;
  68         vsi = repr->src_vsi;
  69
  70         ice_update_vsi_stats(vsi);
  71         eth_stats = &vsi->eth_stats;
  72
  73         stats->tx_packets = eth_stats->tx_unicast + eth_stats->tx_broadcast +
  74                             eth_stats->tx_multicast;
  75         stats->rx_packets = eth_stats->rx_unicast + eth_stats->rx_broadcast +
  76                             eth_stats->rx_multicast;
  77         stats->tx_bytes = eth_stats->tx_bytes;
  78         stats->rx_bytes = eth_stats->rx_bytes;
  79         stats->multicast = eth_stats->rx_multicast;
  80         stats->tx_errors = eth_stats->tx_errors;
  81         stats->tx_dropped = eth_stats->tx_discards;
  82         stats->rx_dropped = eth_stats->rx_discards;
  83 }
  84
  85 /**
  86  * ice_netdev_to_repr - Get port representor for given netdevice
  87  * @netdev: pointer to port representor netdev
  88  */
  89 struct ice_repr *ice_netdev_to_repr(const struct net_device *netdev)
  90 {
  91         struct ice_netdev_priv *np = netdev_priv(netdev);
  92
  93         return np->repr;
  94 }
  95
  96 /**
  97  * ice_repr_vf_open - Enable port representor's network interface
  98  * @netdev: network interface device structure
  99  *
 100  * The open entry point is called when a port representor's network
 101  * interface is made active by the system (IFF_UP). Corresponding
 102  * VF is notified about link status change.
 103  *
 104  * Returns 0 on success
 105  */
 106 static int ice_repr_vf_open(struct net_device *netdev)
 107 {
 108         struct ice_repr *repr = ice_netdev_to_repr(netdev);
 109         struct ice_vf *vf;
 110
 111         vf = repr->vf;
 112         vf->link_forced = true;
 113         vf->link_up = true;
 114         ice_vc_notify_vf_link_state(vf);
 115
 116         netif_carrier_on(netdev);
 117         netif_tx_start_all_queues(netdev);
 118
 119         return 0;
 120 }
 121
 122 static int ice_repr_sf_open(struct net_device *netdev)
 123 {
 124         netif_carrier_on(netdev);
 125         netif_tx_start_all_queues(netdev);
 126
 127         return 0;
 128 }
 129
 130 /**
 131  * ice_repr_vf_stop - Disable port representor's network interface
 132  * @netdev: network interface device structure
 133  *
 134  * The stop entry point is called when a port representor's network
 135  * interface is de-activated by the system. Corresponding
 136  * VF is notified about link status change.
 137  *
 138  * Returns 0 on success
 139  */
 140 static int ice_repr_vf_stop(struct net_device *netdev)
 141 {
 142         struct ice_repr *repr = ice_netdev_to_repr(netdev);
 143         struct ice_vf *vf;
 144
 145         vf = repr->vf;
 146         vf->link_forced = true;
 147         vf->link_up = false;
 148         ice_vc_notify_vf_link_state(vf);
 149
 150         netif_carrier_off(netdev);
 151         netif_tx_stop_all_queues(netdev);
 152
 153         return 0;
 154 }
 155
 156 static int ice_repr_sf_stop(struct net_device *netdev)
 157 {
 158         netif_carrier_off(netdev);
 159         netif_tx_stop_all_queues(netdev);
 160
 161         return 0;
 162 }
 163
 164 /**
 165  * ice_repr_sp_stats64 - get slow path stats for port representor
 166  * @dev: network interface device structure
 167  * @stats: netlink stats structure
 168  */
 169 static int
 170 ice_repr_sp_stats64(const struct net_device *dev,
 171                     struct rtnl_link_stats64 *stats)
 172 {
 173         struct ice_repr *repr = ice_netdev_to_repr(dev);
 174         int i;
 175
 176         for_each_possible_cpu(i) {
 177                 u64 tbytes, tpkts, tdrops, rbytes, rpkts;
 178                 struct ice_repr_pcpu_stats *repr_stats;
 179                 unsigned int start;
 180
 181                 repr_stats = per_cpu_ptr(repr->stats, i);
 182                 do {
 183                         start = u64_stats_fetch_begin(&repr_stats->syncp);
 184                         tbytes = repr_stats->tx_bytes;
 185                         tpkts = repr_stats->tx_packets;
 186                         tdrops = repr_stats->tx_drops;
 187                         rbytes = repr_stats->rx_bytes;
 188                         rpkts = repr_stats->rx_packets;
 189                 } while (u64_stats_fetch_retry(&repr_stats->syncp, start));
 190
 191                 stats->tx_bytes += tbytes;
 192                 stats->tx_packets += tpkts;
 193                 stats->tx_dropped += tdrops;
 194                 stats->rx_bytes += rbytes;
 195                 stats->rx_packets += rpkts;
 196         }
 197         return 0;
 198 }
 199
 200 static bool
 201 ice_repr_ndo_has_offload_stats(const struct net_device *dev, int attr_id)
 202 {
 203         return attr_id == IFLA_OFFLOAD_XSTATS_CPU_HIT;
 204 }
 205
 206 static int
 207 ice_repr_ndo_get_offload_stats(int attr_id, const struct net_device *dev,
 208                                void *sp)
 209 {
 210         if (attr_id == IFLA_OFFLOAD_XSTATS_CPU_HIT)
 211                 return ice_repr_sp_stats64(dev, (struct rtnl_link_stats64 *)sp);
 212
 213         return -EINVAL;
 214 }
 215
 216 static int
 217 ice_repr_setup_tc_cls_flower(struct ice_repr *repr,
 218                              struct flow_cls_offload *flower)
 219 {
 220         switch (flower->command) {
 221         case FLOW_CLS_REPLACE:
 222                 return ice_add_cls_flower(repr->netdev, repr->src_vsi, flower);
 223         case FLOW_CLS_DESTROY:
 224                 return ice_del_cls_flower(repr->src_vsi, flower);
 225         default:
 226                 return -EINVAL;
 227         }
 228 }
 229
 230 static int
 231 ice_repr_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
 232                            void *cb_priv)
 233 {
 234         struct flow_cls_offload *flower = (struct flow_cls_offload *)type_data;
 235         struct ice_netdev_priv *np = (struct ice_netdev_priv *)cb_priv;
 236
 237         switch (type) {
 238         case TC_SETUP_CLSFLOWER:
 239                 return ice_repr_setup_tc_cls_flower(np->repr, flower);
 240         default:
 241                 return -EOPNOTSUPP;
 242         }
 243 }
 244
 245 static LIST_HEAD(ice_repr_block_cb_list);
 246
 247 static int
 248 ice_repr_setup_tc(struct net_device *netdev, enum tc_setup_type type,
 249                   void *type_data)
 250 {
 251         struct ice_netdev_priv *np = netdev_priv(netdev);
 252
 253         switch (type) {
 254         case TC_SETUP_BLOCK:
 255                 return flow_block_cb_setup_simple((struct flow_block_offload *)
 256                                                   type_data,
 257                                                   &ice_repr_block_cb_list,
 258                                                   ice_repr_setup_tc_block_cb,
 259                                                   np, np, true);
 260         default:
 261                 return -EOPNOTSUPP;
 262         }
 263 }
 264
 265 static const struct net_device_ops ice_repr_vf_netdev_ops = {
 266         .ndo_get_stats64 = ice_repr_get_stats64,
 267         .ndo_open = ice_repr_vf_open,
 268         .ndo_stop = ice_repr_vf_stop,
 269         .ndo_start_xmit = ice_eswitch_port_start_xmit,
 270         .ndo_setup_tc = ice_repr_setup_tc,
 271         .ndo_has_offload_stats = ice_repr_ndo_has_offload_stats,
 272         .ndo_get_offload_stats = ice_repr_ndo_get_offload_stats,
 273 };
 274
 275 static const struct net_device_ops ice_repr_sf_netdev_ops = {
 276         .ndo_get_stats64 = ice_repr_get_stats64,
 277         .ndo_open = ice_repr_sf_open,
 278         .ndo_stop = ice_repr_sf_stop,
 279         .ndo_start_xmit = ice_eswitch_port_start_xmit,
 280         .ndo_setup_tc = ice_repr_setup_tc,
 281         .ndo_has_offload_stats = ice_repr_ndo_has_offload_stats,
 282         .ndo_get_offload_stats = ice_repr_ndo_get_offload_stats,
 283 };
 284
 285 /**
 286  * ice_is_port_repr_netdev - Check if a given netdevice is a port representor netdev
 287  * @netdev: pointer to netdev
 288  */
 289 bool ice_is_port_repr_netdev(const struct net_device *netdev)
 290 {
 291         return netdev && (netdev->netdev_ops == &ice_repr_vf_netdev_ops ||
 292                           netdev->netdev_ops == &ice_repr_sf_netdev_ops);
 293 }
 294
 295 /**
 296  * ice_repr_reg_netdev - register port representor netdev
 297  * @netdev: pointer to port representor netdev
 298  * @ops: new ops for netdev
 299  */
 300 static int
 301 ice_repr_reg_netdev(struct net_device *netdev, const struct net_device_ops *ops)
 302 {
 303         eth_hw_addr_random(netdev);
 304         netdev->netdev_ops = ops;
 305         ice_set_ethtool_repr_ops(netdev);
 306
 307         netdev->hw_features |= NETIF_F_HW_TC;
 308
 309         netif_carrier_off(netdev);
 310         netif_tx_stop_all_queues(netdev);
 311
 312         return register_netdev(netdev);
 313 }
 314
 315 static int ice_repr_ready_vf(struct ice_repr *repr)
 316 {
 317         return !ice_check_vf_ready_for_cfg(repr->vf);
 318 }
 319
 320 static int ice_repr_ready_sf(struct ice_repr *repr)
 321 {
 322         return !repr->sf->active;
 323 }
 324
 325 /**
 326  * ice_repr_destroy - remove representor from VF
 327  * @repr: pointer to representor structure
 328  */
 329 void ice_repr_destroy(struct ice_repr *repr)
 330 {
 331         free_percpu(repr->stats);
 332         free_netdev(repr->netdev);
 333         kfree(repr);
 334 }
 335
 336 static void ice_repr_rem_vf(struct ice_repr *repr)
 337 {
 338         ice_eswitch_decfg_vsi(repr->src_vsi, repr->parent_mac);
 339         unregister_netdev(repr->netdev);
 340         ice_devlink_destroy_vf_port(repr->vf);
 341         ice_virtchnl_set_dflt_ops(repr->vf);
 342 }
 343
 344 static void ice_repr_rem_sf(struct ice_repr *repr)
 345 {
 346         unregister_netdev(repr->netdev);
 347         ice_devlink_destroy_sf_port(repr->sf);
 348 }
 349
 350 static void ice_repr_set_tx_topology(struct ice_pf *pf, struct devlink *devlink)
 351 {
 352         /* only export if ADQ and DCB disabled and eswitch enabled*/
 353         if (ice_is_adq_active(pf) || ice_is_dcb_active(pf) ||
 354             !ice_is_switchdev_running(pf))
 355                 return;
 356
 357         ice_devlink_rate_init_tx_topology(devlink, ice_get_main_vsi(pf));
 358 }
 359
 360 /**
 361  * ice_repr_create - add representor for generic VSI
 362  * @src_vsi: pointer to VSI structure of device to represent
 363  */
 364 static struct ice_repr *ice_repr_create(struct ice_vsi *src_vsi)
 365 {
 366         struct ice_netdev_priv *np;
 367         struct ice_repr *repr;
 368         int err;
 369
 370         repr = kzalloc(sizeof(*repr), GFP_KERNEL);
 371         if (!repr)
 372                 return ERR_PTR(-ENOMEM);
 373
 374         repr->netdev = alloc_etherdev(sizeof(struct ice_netdev_priv));
 375         if (!repr->netdev) {
 376                 err =  -ENOMEM;
 377                 goto err_alloc;
 378         }
 379
 380         repr->stats = netdev_alloc_pcpu_stats(struct ice_repr_pcpu_stats);
 381         if (!repr->stats) {
 382                 err = -ENOMEM;
 383                 goto err_stats;
 384         }
 385
 386         repr->src_vsi = src_vsi;
 387         repr->id = src_vsi->vsi_num;
 388         np = netdev_priv(repr->netdev);
 389         np->repr = repr;
 390
 391         repr->netdev->min_mtu = ETH_MIN_MTU;
 392         repr->netdev->max_mtu = ICE_MAX_MTU;
 393
 394         SET_NETDEV_DEV(repr->netdev, ice_pf_to_dev(src_vsi->back));
 395
 396         return repr;
 397
 398 err_stats:
 399         free_netdev(repr->netdev);
 400 err_alloc:
 401         kfree(repr);
 402         return ERR_PTR(err);
 403 }
 404
 405 static int ice_repr_add_vf(struct ice_repr *repr)
 406 {
 407         struct ice_vf *vf = repr->vf;
 408         struct devlink *devlink;
 409         int err;
 410
 411         err = ice_devlink_create_vf_port(vf);
 412         if (err)
 413                 return err;
 414
 415         SET_NETDEV_DEVLINK_PORT(repr->netdev, &vf->devlink_port);
 416         err = ice_repr_reg_netdev(repr->netdev, &ice_repr_vf_netdev_ops);
 417         if (err)
 418                 goto err_netdev;
 419
 420         err = ice_eswitch_cfg_vsi(repr->src_vsi, repr->parent_mac);
 421         if (err)
 422                 goto err_cfg_vsi;
 423
 424         ice_virtchnl_set_repr_ops(vf);
 425
 426         devlink = priv_to_devlink(vf->pf);
 427         ice_repr_set_tx_topology(vf->pf, devlink);
 428
 429         return 0;
 430
 431 err_cfg_vsi:
 432         unregister_netdev(repr->netdev);
 433 err_netdev:
 434         ice_devlink_destroy_vf_port(vf);
 435         return err;
 436 }
 437
 438 /**
 439  * ice_repr_create_vf - add representor for VF VSI
 440  * @vf: VF to create port representor on
 441  *
 442  * Set correct representor type for VF and functions pointer.
 443  *
 444  * Return: created port representor on success, error otherwise
 445  */
 446 struct ice_repr *ice_repr_create_vf(struct ice_vf *vf)
 447 {
 448         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 449         struct ice_repr *repr;
 450
 451         if (!vsi)
 452                 return ERR_PTR(-EINVAL);
 453
 454         repr = ice_repr_create(vsi);
 455         if (IS_ERR(repr))
 456                 return repr;
 457
 458         repr->type = ICE_REPR_TYPE_VF;
 459         repr->vf = vf;
 460         repr->ops.add = ice_repr_add_vf;
 461         repr->ops.rem = ice_repr_rem_vf;
 462         repr->ops.ready = ice_repr_ready_vf;
 463
 464         ether_addr_copy(repr->parent_mac, vf->hw_lan_addr);
 465
 466         return repr;
 467 }
 468
 469 static int ice_repr_add_sf(struct ice_repr *repr)
 470 {
 471         struct ice_dynamic_port *sf = repr->sf;
 472         int err;
 473
 474         err = ice_devlink_create_sf_port(sf);
 475         if (err)
 476                 return err;
 477
 478         SET_NETDEV_DEVLINK_PORT(repr->netdev, &sf->devlink_port);
 479         err = ice_repr_reg_netdev(repr->netdev, &ice_repr_sf_netdev_ops);
 480         if (err)
 481                 goto err_netdev;
 482
 483         ice_repr_set_tx_topology(sf->vsi->back, priv_to_devlink(sf->vsi->back));
 484
 485         return 0;
 486
 487 err_netdev:
 488         ice_devlink_destroy_sf_port(sf);
 489         return err;
 490 }
 491
 492 /**
 493  * ice_repr_create_sf - add representor for SF VSI
 494  * @sf: SF to create port representor on
 495  *
 496  * Set correct representor type for SF and functions pointer.
 497  *
 498  * Return: created port representor on success, error otherwise
 499  */
 500 struct ice_repr *ice_repr_create_sf(struct ice_dynamic_port *sf)
 501 {
 502         struct ice_repr *repr = ice_repr_create(sf->vsi);
 503
 504         if (IS_ERR(repr))
 505                 return repr;
 506
 507         repr->type = ICE_REPR_TYPE_SF;
 508         repr->sf = sf;
 509         repr->ops.add = ice_repr_add_sf;
 510         repr->ops.rem = ice_repr_rem_sf;
 511         repr->ops.ready = ice_repr_ready_sf;
 512
 513         ether_addr_copy(repr->parent_mac, sf->hw_addr);
 514
 515         return repr;
 516 }
 517
 518 struct ice_repr *ice_repr_get(struct ice_pf *pf, u32 id)
 519 {
 520         return xa_load(&pf->eswitch.reprs, id);
 521 }
 522
 523 /**
 524  * ice_repr_start_tx_queues - start Tx queues of port representor
 525  * @repr: pointer to repr structure
 526  */
 527 void ice_repr_start_tx_queues(struct ice_repr *repr)
 528 {
 529         netif_carrier_on(repr->netdev);
 530         netif_tx_start_all_queues(repr->netdev);
 531 }
 532
 533 /**
 534  * ice_repr_stop_tx_queues - stop Tx queues of port representor
 535  * @repr: pointer to repr structure
 536  */
 537 void ice_repr_stop_tx_queues(struct ice_repr *repr)
 538 {
 539         netif_carrier_off(repr->netdev);
 540         netif_tx_stop_all_queues(repr->netdev);
 541 }