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 "ice_devlink.h"
   7 #include "ice_sriov.h"
   8 #include "ice_tc_lib.h"
   9 #include "ice_dcb_lib.h"
  10
  11 /**
  12  * ice_repr_get_sw_port_id - get port ID associated with representor
  13  * @repr: pointer to port representor
  14  */
  15 static int ice_repr_get_sw_port_id(struct ice_repr *repr)
  16 {
  17         return repr->vf->pf->hw.port_info->lport;
  18 }
  19
  20 /**
  21  * ice_repr_get_phys_port_name - get phys port name
  22  * @netdev: pointer to port representor netdev
  23  * @buf: write here port name
  24  * @len: max length of buf
  25  */
  26 static int
  27 ice_repr_get_phys_port_name(struct net_device *netdev, char *buf, size_t len)
  28 {
  29         struct ice_netdev_priv *np = netdev_priv(netdev);
  30         struct ice_repr *repr = np->repr;
  31         int res;
  32
  33         /* Devlink port is registered and devlink core is taking care of name formatting. */
  34         if (repr->vf->devlink_port.devlink)
  35                 return -EOPNOTSUPP;
  36
  37         res = snprintf(buf, len, "pf%dvfr%d", ice_repr_get_sw_port_id(repr),
  38                        repr->vf->vf_id);
  39         if (res <= 0)
  40                 return -EOPNOTSUPP;
  41         return 0;
  42 }
  43
  44 /**
  45  * ice_repr_get_stats64 - get VF stats for VFPR use
  46  * @netdev: pointer to port representor netdev
  47  * @stats: pointer to struct where stats can be stored
  48  */
  49 static void
  50 ice_repr_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats)
  51 {
  52         struct ice_netdev_priv *np = netdev_priv(netdev);
  53         struct ice_eth_stats *eth_stats;
  54         struct ice_vsi *vsi;
  55
  56         if (ice_is_vf_disabled(np->repr->vf))
  57                 return;
  58         vsi = np->repr->src_vsi;
  59
  60         ice_update_vsi_stats(vsi);
  61         eth_stats = &vsi->eth_stats;
  62
  63         stats->tx_packets = eth_stats->tx_unicast + eth_stats->tx_broadcast +
  64                             eth_stats->tx_multicast;
  65         stats->rx_packets = eth_stats->rx_unicast + eth_stats->rx_broadcast +
  66                             eth_stats->rx_multicast;
  67         stats->tx_bytes = eth_stats->tx_bytes;
  68         stats->rx_bytes = eth_stats->rx_bytes;
  69         stats->multicast = eth_stats->rx_multicast;
  70         stats->tx_errors = eth_stats->tx_errors;
  71         stats->tx_dropped = eth_stats->tx_discards;
  72         stats->rx_dropped = eth_stats->rx_discards;
  73 }
  74
  75 /**
  76  * ice_netdev_to_repr - Get port representor for given netdevice
  77  * @netdev: pointer to port representor netdev
  78  */
  79 struct ice_repr *ice_netdev_to_repr(struct net_device *netdev)
  80 {
  81         struct ice_netdev_priv *np = netdev_priv(netdev);
  82
  83         return np->repr;
  84 }
  85
  86 /**
  87  * ice_repr_open - Enable port representor's network interface
  88  * @netdev: network interface device structure
  89  *
  90  * The open entry point is called when a port representor's network
  91  * interface is made active by the system (IFF_UP). Corresponding
  92  * VF is notified about link status change.
  93  *
  94  * Returns 0 on success
  95  */
  96 static int ice_repr_open(struct net_device *netdev)
  97 {
  98         struct ice_repr *repr = ice_netdev_to_repr(netdev);
  99         struct ice_vf *vf;
 100
 101         vf = repr->vf;
 102         vf->link_forced = true;
 103         vf->link_up = true;
 104         ice_vc_notify_vf_link_state(vf);
 105
 106         netif_carrier_on(netdev);
 107         netif_tx_start_all_queues(netdev);
 108
 109         return 0;
 110 }
 111
 112 /**
 113  * ice_repr_stop - Disable port representor's network interface
 114  * @netdev: network interface device structure
 115  *
 116  * The stop entry point is called when a port representor's network
 117  * interface is de-activated by the system. Corresponding
 118  * VF is notified about link status change.
 119  *
 120  * Returns 0 on success
 121  */
 122 static int ice_repr_stop(struct net_device *netdev)
 123 {
 124         struct ice_repr *repr = ice_netdev_to_repr(netdev);
 125         struct ice_vf *vf;
 126
 127         vf = repr->vf;
 128         vf->link_forced = true;
 129         vf->link_up = false;
 130         ice_vc_notify_vf_link_state(vf);
 131
 132         netif_carrier_off(netdev);
 133         netif_tx_stop_all_queues(netdev);
 134
 135         return 0;
 136 }
 137
 138 /**
 139  * ice_repr_sp_stats64 - get slow path stats for port representor
 140  * @dev: network interface device structure
 141  * @stats: netlink stats structure
 142  *
 143  * RX/TX stats are being swapped here to be consistent with VF stats. In slow
 144  * path, port representor receives data when the corresponding VF is sending it
 145  * (and vice versa), TX and RX bytes/packets are effectively swapped on port
 146  * representor.
 147  */
 148 static int
 149 ice_repr_sp_stats64(const struct net_device *dev,
 150                     struct rtnl_link_stats64 *stats)
 151 {
 152         struct ice_netdev_priv *np = netdev_priv(dev);
 153         int vf_id = np->repr->vf->vf_id;
 154         struct ice_tx_ring *tx_ring;
 155         struct ice_rx_ring *rx_ring;
 156         u64 pkts, bytes;
 157
 158         tx_ring = np->vsi->tx_rings[vf_id];
 159         ice_fetch_u64_stats_per_ring(&tx_ring->ring_stats->syncp,
 160                                      tx_ring->ring_stats->stats,
 161                                      &pkts, &bytes);
 162         stats->rx_packets = pkts;
 163         stats->rx_bytes = bytes;
 164
 165         rx_ring = np->vsi->rx_rings[vf_id];
 166         ice_fetch_u64_stats_per_ring(&rx_ring->ring_stats->syncp,
 167                                      rx_ring->ring_stats->stats,
 168                                      &pkts, &bytes);
 169         stats->tx_packets = pkts;
 170         stats->tx_bytes = bytes;
 171         stats->tx_dropped = rx_ring->ring_stats->rx_stats.alloc_page_failed +
 172                             rx_ring->ring_stats->rx_stats.alloc_buf_failed;
 173
 174         return 0;
 175 }
 176
 177 static bool
 178 ice_repr_ndo_has_offload_stats(const struct net_device *dev, int attr_id)
 179 {
 180         return attr_id == IFLA_OFFLOAD_XSTATS_CPU_HIT;
 181 }
 182
 183 static int
 184 ice_repr_ndo_get_offload_stats(int attr_id, const struct net_device *dev,
 185                                void *sp)
 186 {
 187         if (attr_id == IFLA_OFFLOAD_XSTATS_CPU_HIT)
 188                 return ice_repr_sp_stats64(dev, (struct rtnl_link_stats64 *)sp);
 189
 190         return -EINVAL;
 191 }
 192
 193 static int
 194 ice_repr_setup_tc_cls_flower(struct ice_repr *repr,
 195                              struct flow_cls_offload *flower)
 196 {
 197         switch (flower->command) {
 198         case FLOW_CLS_REPLACE:
 199                 return ice_add_cls_flower(repr->netdev, repr->src_vsi, flower);
 200         case FLOW_CLS_DESTROY:
 201                 return ice_del_cls_flower(repr->src_vsi, flower);
 202         default:
 203                 return -EINVAL;
 204         }
 205 }
 206
 207 static int
 208 ice_repr_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
 209                            void *cb_priv)
 210 {
 211         struct flow_cls_offload *flower = (struct flow_cls_offload *)type_data;
 212         struct ice_netdev_priv *np = (struct ice_netdev_priv *)cb_priv;
 213
 214         switch (type) {
 215         case TC_SETUP_CLSFLOWER:
 216                 return ice_repr_setup_tc_cls_flower(np->repr, flower);
 217         default:
 218                 return -EOPNOTSUPP;
 219         }
 220 }
 221
 222 static LIST_HEAD(ice_repr_block_cb_list);
 223
 224 static int
 225 ice_repr_setup_tc(struct net_device *netdev, enum tc_setup_type type,
 226                   void *type_data)
 227 {
 228         struct ice_netdev_priv *np = netdev_priv(netdev);
 229
 230         switch (type) {
 231         case TC_SETUP_BLOCK:
 232                 return flow_block_cb_setup_simple((struct flow_block_offload *)
 233                                                   type_data,
 234                                                   &ice_repr_block_cb_list,
 235                                                   ice_repr_setup_tc_block_cb,
 236                                                   np, np, true);
 237         default:
 238                 return -EOPNOTSUPP;
 239         }
 240 }
 241
 242 static const struct net_device_ops ice_repr_netdev_ops = {
 243         .ndo_get_phys_port_name = ice_repr_get_phys_port_name,
 244         .ndo_get_stats64 = ice_repr_get_stats64,
 245         .ndo_open = ice_repr_open,
 246         .ndo_stop = ice_repr_stop,
 247         .ndo_start_xmit = ice_eswitch_port_start_xmit,
 248         .ndo_setup_tc = ice_repr_setup_tc,
 249         .ndo_has_offload_stats = ice_repr_ndo_has_offload_stats,
 250         .ndo_get_offload_stats = ice_repr_ndo_get_offload_stats,
 251 };
 252
 253 /**
 254  * ice_is_port_repr_netdev - Check if a given netdevice is a port representor netdev
 255  * @netdev: pointer to netdev
 256  */
 257 bool ice_is_port_repr_netdev(const struct net_device *netdev)
 258 {
 259         return netdev && (netdev->netdev_ops == &ice_repr_netdev_ops);
 260 }
 261
 262 /**
 263  * ice_repr_reg_netdev - register port representor netdev
 264  * @netdev: pointer to port representor netdev
 265  */
 266 static int
 267 ice_repr_reg_netdev(struct net_device *netdev)
 268 {
 269         eth_hw_addr_random(netdev);
 270         netdev->netdev_ops = &ice_repr_netdev_ops;
 271         ice_set_ethtool_repr_ops(netdev);
 272
 273         netdev->hw_features |= NETIF_F_HW_TC;
 274
 275         netif_carrier_off(netdev);
 276         netif_tx_stop_all_queues(netdev);
 277
 278         return register_netdev(netdev);
 279 }
 280
 281 /**
 282  * ice_repr_add - add representor for VF
 283  * @vf: pointer to VF structure
 284  */
 285 static int ice_repr_add(struct ice_vf *vf)
 286 {
 287         struct ice_q_vector *q_vector;
 288         struct ice_netdev_priv *np;
 289         struct ice_repr *repr;
 290         struct ice_vsi *vsi;
 291         int err;
 292
 293         vsi = ice_get_vf_vsi(vf);
 294         if (!vsi)
 295                 return -EINVAL;
 296
 297         repr = kzalloc(sizeof(*repr), GFP_KERNEL);
 298         if (!repr)
 299                 return -ENOMEM;
 300
 301         repr->netdev = alloc_etherdev(sizeof(struct ice_netdev_priv));
 302         if (!repr->netdev) {
 303                 err =  -ENOMEM;
 304                 goto err_alloc;
 305         }
 306
 307         repr->src_vsi = vsi;
 308         repr->vf = vf;
 309         vf->repr = repr;
 310         np = netdev_priv(repr->netdev);
 311         np->repr = repr;
 312
 313         q_vector = kzalloc(sizeof(*q_vector), GFP_KERNEL);
 314         if (!q_vector) {
 315                 err = -ENOMEM;
 316                 goto err_alloc_q_vector;
 317         }
 318         repr->q_vector = q_vector;
 319
 320         err = ice_devlink_create_vf_port(vf);
 321         if (err)
 322                 goto err_devlink;
 323
 324         repr->netdev->min_mtu = ETH_MIN_MTU;
 325         repr->netdev->max_mtu = ICE_MAX_MTU;
 326
 327         SET_NETDEV_DEV(repr->netdev, ice_pf_to_dev(vf->pf));
 328         SET_NETDEV_DEVLINK_PORT(repr->netdev, &vf->devlink_port);
 329         err = ice_repr_reg_netdev(repr->netdev);
 330         if (err)
 331                 goto err_netdev;
 332
 333         ice_virtchnl_set_repr_ops(vf);
 334
 335         return 0;
 336
 337 err_netdev:
 338         ice_devlink_destroy_vf_port(vf);
 339 err_devlink:
 340         kfree(repr->q_vector);
 341         vf->repr->q_vector = NULL;
 342 err_alloc_q_vector:
 343         free_netdev(repr->netdev);
 344         repr->netdev = NULL;
 345 err_alloc:
 346         kfree(repr);
 347         vf->repr = NULL;
 348         return err;
 349 }
 350
 351 /**
 352  * ice_repr_rem - remove representor from VF
 353  * @vf: pointer to VF structure
 354  */
 355 static void ice_repr_rem(struct ice_vf *vf)
 356 {
 357         if (!vf->repr)
 358                 return;
 359
 360         kfree(vf->repr->q_vector);
 361         vf->repr->q_vector = NULL;
 362         unregister_netdev(vf->repr->netdev);
 363         ice_devlink_destroy_vf_port(vf);
 364         free_netdev(vf->repr->netdev);
 365         vf->repr->netdev = NULL;
 366         kfree(vf->repr);
 367         vf->repr = NULL;
 368
 369         ice_virtchnl_set_dflt_ops(vf);
 370 }
 371
 372 /**
 373  * ice_repr_rem_from_all_vfs - remove port representor for all VFs
 374  * @pf: pointer to PF structure
 375  */
 376 void ice_repr_rem_from_all_vfs(struct ice_pf *pf)
 377 {
 378         struct devlink *devlink;
 379         struct ice_vf *vf;
 380         unsigned int bkt;
 381
 382         lockdep_assert_held(&pf->vfs.table_lock);
 383
 384         ice_for_each_vf(pf, bkt, vf)
 385                 ice_repr_rem(vf);
 386
 387         /* since all port representors are destroyed, there is
 388          * no point in keeping the nodes
 389          */
 390         devlink = priv_to_devlink(pf);
 391         devl_lock(devlink);
 392         devl_rate_nodes_destroy(devlink);
 393         devl_unlock(devlink);
 394 }
 395
 396 /**
 397  * ice_repr_add_for_all_vfs - add port representor for all VFs
 398  * @pf: pointer to PF structure
 399  */
 400 int ice_repr_add_for_all_vfs(struct ice_pf *pf)
 401 {
 402         struct devlink *devlink;
 403         struct ice_vf *vf;
 404         unsigned int bkt;
 405         int err;
 406
 407         lockdep_assert_held(&pf->vfs.table_lock);
 408
 409         ice_for_each_vf(pf, bkt, vf) {
 410                 err = ice_repr_add(vf);
 411                 if (err)
 412                         goto err;
 413         }
 414
 415         /* only export if ADQ and DCB disabled */
 416         if (ice_is_adq_active(pf) || ice_is_dcb_active(pf))
 417                 return 0;
 418
 419         devlink = priv_to_devlink(pf);
 420         ice_devlink_rate_init_tx_topology(devlink, ice_get_main_vsi(pf));
 421
 422         return 0;
 423
 424 err:
 425         ice_repr_rem_from_all_vfs(pf);
 426
 427         return err;
 428 }
 429
 430 /**
 431  * ice_repr_start_tx_queues - start Tx queues of port representor
 432  * @repr: pointer to repr structure
 433  */
 434 void ice_repr_start_tx_queues(struct ice_repr *repr)
 435 {
 436         netif_carrier_on(repr->netdev);
 437         netif_tx_start_all_queues(repr->netdev);
 438 }
 439
 440 /**
 441  * ice_repr_stop_tx_queues - stop Tx queues of port representor
 442  * @repr: pointer to repr structure
 443  */
 444 void ice_repr_stop_tx_queues(struct ice_repr *repr)
 445 {
 446         netif_carrier_off(repr->netdev);
 447         netif_tx_stop_all_queues(repr->netdev);
 448 }
 449
 450 /**
 451  * ice_repr_set_traffic_vsi - set traffic VSI for port representor
 452  * @repr: repr on with VSI will be set
 453  * @vsi: pointer to VSI that will be used by port representor to pass traffic
 454  */
 455 void ice_repr_set_traffic_vsi(struct ice_repr *repr, struct ice_vsi *vsi)
 456 {
 457         struct ice_netdev_priv *np = netdev_priv(repr->netdev);
 458
 459         np->vsi = vsi;
 460 }