1 /* 2 * Copyright (c) 2016, Mellanox Technologies. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 */ 32 33 #include <linux/mlx5/fs.h> 34 #include <net/switchdev.h> 35 #include <net/pkt_cls.h> 36 #include <net/act_api.h> 37 #include <net/devlink.h> 38 #include <net/ipv6_stubs.h> 39 40 #include "eswitch.h" 41 #include "en.h" 42 #include "en_rep.h" 43 #include "en/params.h" 44 #include "en/txrx.h" 45 #include "en_tc.h" 46 #include "en/rep/tc.h" 47 #include "en/rep/neigh.h" 48 #include "en/rep/bridge.h" 49 #include "en/devlink.h" 50 #include "fs_core.h" 51 #include "lib/mlx5.h" 52 #include "lib/devcom.h" 53 #include "lib/vxlan.h" 54 #define CREATE_TRACE_POINTS 55 #include "diag/en_rep_tracepoint.h" 56 #include "diag/reporter_vnic.h" 57 #include "en_accel/ipsec.h" 58 #include "en/tc/int_port.h" 59 #include "en/ptp.h" 60 #include "en/fs_ethtool.h" 61 62 #define MLX5E_REP_PARAMS_DEF_LOG_SQ_SIZE \ 63 max(0x7, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE) 64 #define MLX5E_REP_PARAMS_DEF_NUM_CHANNELS 1 65 66 static const char mlx5e_rep_driver_name[] = "mlx5e_rep"; 67 68 static void mlx5e_rep_get_drvinfo(struct net_device *dev, 69 struct ethtool_drvinfo *drvinfo) 70 { 71 struct mlx5e_priv *priv = netdev_priv(dev); 72 struct mlx5_core_dev *mdev = priv->mdev; 73 74 strscpy(drvinfo->driver, mlx5e_rep_driver_name, 75 sizeof(drvinfo->driver)); 76 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), 77 "%d.%d.%04d (%.16s)", 78 fw_rev_maj(mdev), fw_rev_min(mdev), 79 fw_rev_sub(mdev), mdev->board_id); 80 } 81 82 static const struct counter_desc sw_rep_stats_desc[] = { 83 { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_packets) }, 84 { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_bytes) }, 85 { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_packets) }, 86 { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_bytes) }, 87 }; 88 89 static const struct counter_desc vport_rep_stats_desc[] = { 90 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_rx_packets) }, 91 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_rx_bytes) }, 92 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_tx_packets) }, 93 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_tx_bytes) }, 94 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 95 rx_vport_rdma_unicast_packets) }, 96 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, rx_vport_rdma_unicast_bytes) }, 97 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 98 tx_vport_rdma_unicast_packets) }, 99 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, tx_vport_rdma_unicast_bytes) }, 100 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 101 rx_vport_rdma_multicast_packets) }, 102 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 103 rx_vport_rdma_multicast_bytes) }, 104 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 105 tx_vport_rdma_multicast_packets) }, 106 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 107 tx_vport_rdma_multicast_bytes) }, 108 }; 109 110 #define NUM_VPORT_REP_SW_COUNTERS ARRAY_SIZE(sw_rep_stats_desc) 111 #define NUM_VPORT_REP_HW_COUNTERS ARRAY_SIZE(vport_rep_stats_desc) 112 113 static MLX5E_DECLARE_STATS_GRP_OP_NUM_STATS(sw_rep) 114 { 115 return NUM_VPORT_REP_SW_COUNTERS; 116 } 117 118 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STRS(sw_rep) 119 { 120 int i; 121 122 for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++) 123 strcpy(data + (idx++) * ETH_GSTRING_LEN, 124 sw_rep_stats_desc[i].format); 125 return idx; 126 } 127 128 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STATS(sw_rep) 129 { 130 int i; 131 132 for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++) 133 data[idx++] = MLX5E_READ_CTR64_CPU(&priv->stats.sw, 134 sw_rep_stats_desc, i); 135 return idx; 136 } 137 138 static MLX5E_DECLARE_STATS_GRP_OP_UPDATE_STATS(sw_rep) 139 { 140 struct mlx5e_sw_stats *s = &priv->stats.sw; 141 struct rtnl_link_stats64 stats64 = {}; 142 143 memset(s, 0, sizeof(*s)); 144 mlx5e_fold_sw_stats64(priv, &stats64); 145 146 s->rx_packets = stats64.rx_packets; 147 s->rx_bytes = stats64.rx_bytes; 148 s->tx_packets = stats64.tx_packets; 149 s->tx_bytes = stats64.tx_bytes; 150 s->tx_queue_dropped = stats64.tx_dropped; 151 } 152 153 static MLX5E_DECLARE_STATS_GRP_OP_NUM_STATS(vport_rep) 154 { 155 return NUM_VPORT_REP_HW_COUNTERS; 156 } 157 158 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STRS(vport_rep) 159 { 160 int i; 161 162 for (i = 0; i < NUM_VPORT_REP_HW_COUNTERS; i++) 163 strcpy(data + (idx++) * ETH_GSTRING_LEN, vport_rep_stats_desc[i].format); 164 return idx; 165 } 166 167 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STATS(vport_rep) 168 { 169 int i; 170 171 for (i = 0; i < NUM_VPORT_REP_HW_COUNTERS; i++) 172 data[idx++] = MLX5E_READ_CTR64_CPU(&priv->stats.rep_stats, 173 vport_rep_stats_desc, i); 174 return idx; 175 } 176 177 static MLX5E_DECLARE_STATS_GRP_OP_UPDATE_STATS(vport_rep) 178 { 179 struct mlx5e_rep_stats *rep_stats = &priv->stats.rep_stats; 180 int outlen = MLX5_ST_SZ_BYTES(query_vport_counter_out); 181 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 182 struct mlx5e_rep_priv *rpriv = priv->ppriv; 183 struct mlx5_eswitch_rep *rep = rpriv->rep; 184 u32 *out; 185 int err; 186 187 out = kvzalloc(outlen, GFP_KERNEL); 188 if (!out) 189 return; 190 191 err = mlx5_core_query_vport_counter(esw->dev, 1, rep->vport - 1, 0, out); 192 if (err) { 193 netdev_warn(priv->netdev, "vport %d error %d reading stats\n", 194 rep->vport, err); 195 goto out; 196 } 197 198 #define MLX5_GET_CTR(p, x) \ 199 MLX5_GET64(query_vport_counter_out, p, x) 200 /* flip tx/rx as we are reporting the counters for the switch vport */ 201 rep_stats->vport_rx_packets = 202 MLX5_GET_CTR(out, transmitted_ib_unicast.packets) + 203 MLX5_GET_CTR(out, transmitted_eth_unicast.packets) + 204 MLX5_GET_CTR(out, transmitted_ib_multicast.packets) + 205 MLX5_GET_CTR(out, transmitted_eth_multicast.packets) + 206 MLX5_GET_CTR(out, transmitted_eth_broadcast.packets); 207 208 rep_stats->vport_tx_packets = 209 MLX5_GET_CTR(out, received_ib_unicast.packets) + 210 MLX5_GET_CTR(out, received_eth_unicast.packets) + 211 MLX5_GET_CTR(out, received_ib_multicast.packets) + 212 MLX5_GET_CTR(out, received_eth_multicast.packets) + 213 MLX5_GET_CTR(out, received_eth_broadcast.packets); 214 215 rep_stats->vport_rx_bytes = 216 MLX5_GET_CTR(out, transmitted_ib_unicast.octets) + 217 MLX5_GET_CTR(out, transmitted_eth_unicast.octets) + 218 MLX5_GET_CTR(out, transmitted_ib_multicast.octets) + 219 MLX5_GET_CTR(out, transmitted_eth_broadcast.octets); 220 221 rep_stats->vport_tx_bytes = 222 MLX5_GET_CTR(out, received_ib_unicast.octets) + 223 MLX5_GET_CTR(out, received_eth_unicast.octets) + 224 MLX5_GET_CTR(out, received_ib_multicast.octets) + 225 MLX5_GET_CTR(out, received_eth_multicast.octets) + 226 MLX5_GET_CTR(out, received_eth_broadcast.octets); 227 228 rep_stats->rx_vport_rdma_unicast_packets = 229 MLX5_GET_CTR(out, transmitted_ib_unicast.packets); 230 rep_stats->tx_vport_rdma_unicast_packets = 231 MLX5_GET_CTR(out, received_ib_unicast.packets); 232 rep_stats->rx_vport_rdma_unicast_bytes = 233 MLX5_GET_CTR(out, transmitted_ib_unicast.octets); 234 rep_stats->tx_vport_rdma_unicast_bytes = 235 MLX5_GET_CTR(out, received_ib_unicast.octets); 236 rep_stats->rx_vport_rdma_multicast_packets = 237 MLX5_GET_CTR(out, transmitted_ib_multicast.packets); 238 rep_stats->tx_vport_rdma_multicast_packets = 239 MLX5_GET_CTR(out, received_ib_multicast.packets); 240 rep_stats->rx_vport_rdma_multicast_bytes = 241 MLX5_GET_CTR(out, transmitted_ib_multicast.octets); 242 rep_stats->tx_vport_rdma_multicast_bytes = 243 MLX5_GET_CTR(out, received_ib_multicast.octets); 244 245 out: 246 kvfree(out); 247 } 248 249 static void mlx5e_rep_get_strings(struct net_device *dev, 250 u32 stringset, uint8_t *data) 251 { 252 struct mlx5e_priv *priv = netdev_priv(dev); 253 254 switch (stringset) { 255 case ETH_SS_STATS: 256 mlx5e_stats_fill_strings(priv, data); 257 break; 258 } 259 } 260 261 static void mlx5e_rep_get_ethtool_stats(struct net_device *dev, 262 struct ethtool_stats *stats, u64 *data) 263 { 264 struct mlx5e_priv *priv = netdev_priv(dev); 265 266 mlx5e_ethtool_get_ethtool_stats(priv, stats, data); 267 } 268 269 static int mlx5e_rep_get_sset_count(struct net_device *dev, int sset) 270 { 271 struct mlx5e_priv *priv = netdev_priv(dev); 272 273 switch (sset) { 274 case ETH_SS_STATS: 275 return mlx5e_stats_total_num(priv); 276 default: 277 return -EOPNOTSUPP; 278 } 279 } 280 281 static void 282 mlx5e_rep_get_ringparam(struct net_device *dev, 283 struct ethtool_ringparam *param, 284 struct kernel_ethtool_ringparam *kernel_param, 285 struct netlink_ext_ack *extack) 286 { 287 struct mlx5e_priv *priv = netdev_priv(dev); 288 289 mlx5e_ethtool_get_ringparam(priv, param, kernel_param); 290 } 291 292 static int 293 mlx5e_rep_set_ringparam(struct net_device *dev, 294 struct ethtool_ringparam *param, 295 struct kernel_ethtool_ringparam *kernel_param, 296 struct netlink_ext_ack *extack) 297 { 298 struct mlx5e_priv *priv = netdev_priv(dev); 299 300 return mlx5e_ethtool_set_ringparam(priv, param); 301 } 302 303 static void mlx5e_rep_get_channels(struct net_device *dev, 304 struct ethtool_channels *ch) 305 { 306 struct mlx5e_priv *priv = netdev_priv(dev); 307 308 mlx5e_ethtool_get_channels(priv, ch); 309 } 310 311 static int mlx5e_rep_set_channels(struct net_device *dev, 312 struct ethtool_channels *ch) 313 { 314 struct mlx5e_priv *priv = netdev_priv(dev); 315 316 return mlx5e_ethtool_set_channels(priv, ch); 317 } 318 319 static int mlx5e_rep_get_coalesce(struct net_device *netdev, 320 struct ethtool_coalesce *coal, 321 struct kernel_ethtool_coalesce *kernel_coal, 322 struct netlink_ext_ack *extack) 323 { 324 struct mlx5e_priv *priv = netdev_priv(netdev); 325 326 return mlx5e_ethtool_get_coalesce(priv, coal, kernel_coal); 327 } 328 329 static int mlx5e_rep_set_coalesce(struct net_device *netdev, 330 struct ethtool_coalesce *coal, 331 struct kernel_ethtool_coalesce *kernel_coal, 332 struct netlink_ext_ack *extack) 333 { 334 struct mlx5e_priv *priv = netdev_priv(netdev); 335 336 return mlx5e_ethtool_set_coalesce(priv, coal, kernel_coal, extack); 337 } 338 339 static u32 mlx5e_rep_get_rxfh_key_size(struct net_device *netdev) 340 { 341 struct mlx5e_priv *priv = netdev_priv(netdev); 342 343 return mlx5e_ethtool_get_rxfh_key_size(priv); 344 } 345 346 static u32 mlx5e_rep_get_rxfh_indir_size(struct net_device *netdev) 347 { 348 struct mlx5e_priv *priv = netdev_priv(netdev); 349 350 return mlx5e_ethtool_get_rxfh_indir_size(priv); 351 } 352 353 static const struct ethtool_ops mlx5e_rep_ethtool_ops = { 354 .supported_coalesce_params = ETHTOOL_COALESCE_USECS | 355 ETHTOOL_COALESCE_MAX_FRAMES | 356 ETHTOOL_COALESCE_USE_ADAPTIVE, 357 .get_drvinfo = mlx5e_rep_get_drvinfo, 358 .get_link = ethtool_op_get_link, 359 .get_strings = mlx5e_rep_get_strings, 360 .get_sset_count = mlx5e_rep_get_sset_count, 361 .get_ethtool_stats = mlx5e_rep_get_ethtool_stats, 362 .get_ringparam = mlx5e_rep_get_ringparam, 363 .set_ringparam = mlx5e_rep_set_ringparam, 364 .get_channels = mlx5e_rep_get_channels, 365 .set_channels = mlx5e_rep_set_channels, 366 .get_coalesce = mlx5e_rep_get_coalesce, 367 .set_coalesce = mlx5e_rep_set_coalesce, 368 .get_rxfh_key_size = mlx5e_rep_get_rxfh_key_size, 369 .get_rxfh_indir_size = mlx5e_rep_get_rxfh_indir_size, 370 }; 371 372 static void mlx5e_sqs2vport_stop(struct mlx5_eswitch *esw, 373 struct mlx5_eswitch_rep *rep) 374 { 375 struct mlx5e_rep_sq *rep_sq, *tmp; 376 struct mlx5e_rep_priv *rpriv; 377 378 if (esw->mode != MLX5_ESWITCH_OFFLOADS) 379 return; 380 381 rpriv = mlx5e_rep_to_rep_priv(rep); 382 list_for_each_entry_safe(rep_sq, tmp, &rpriv->vport_sqs_list, list) { 383 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule); 384 if (rep_sq->send_to_vport_rule_peer) 385 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule_peer); 386 list_del(&rep_sq->list); 387 kfree(rep_sq); 388 } 389 } 390 391 static int mlx5e_sqs2vport_start(struct mlx5_eswitch *esw, 392 struct mlx5_eswitch_rep *rep, 393 u32 *sqns_array, int sqns_num) 394 { 395 struct mlx5_eswitch *peer_esw = NULL; 396 struct mlx5_flow_handle *flow_rule; 397 struct mlx5e_rep_priv *rpriv; 398 struct mlx5e_rep_sq *rep_sq; 399 int err; 400 int i; 401 402 if (esw->mode != MLX5_ESWITCH_OFFLOADS) 403 return 0; 404 405 rpriv = mlx5e_rep_to_rep_priv(rep); 406 if (mlx5_devcom_is_paired(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS)) 407 peer_esw = mlx5_devcom_get_peer_data(esw->dev->priv.devcom, 408 MLX5_DEVCOM_ESW_OFFLOADS); 409 410 for (i = 0; i < sqns_num; i++) { 411 rep_sq = kzalloc(sizeof(*rep_sq), GFP_KERNEL); 412 if (!rep_sq) { 413 err = -ENOMEM; 414 goto out_err; 415 } 416 417 /* Add re-inject rule to the PF/representor sqs */ 418 flow_rule = mlx5_eswitch_add_send_to_vport_rule(esw, esw, rep, 419 sqns_array[i]); 420 if (IS_ERR(flow_rule)) { 421 err = PTR_ERR(flow_rule); 422 kfree(rep_sq); 423 goto out_err; 424 } 425 rep_sq->send_to_vport_rule = flow_rule; 426 rep_sq->sqn = sqns_array[i]; 427 428 if (peer_esw) { 429 flow_rule = mlx5_eswitch_add_send_to_vport_rule(peer_esw, esw, 430 rep, sqns_array[i]); 431 if (IS_ERR(flow_rule)) { 432 err = PTR_ERR(flow_rule); 433 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule); 434 kfree(rep_sq); 435 goto out_err; 436 } 437 rep_sq->send_to_vport_rule_peer = flow_rule; 438 } 439 440 list_add(&rep_sq->list, &rpriv->vport_sqs_list); 441 } 442 443 if (peer_esw) 444 mlx5_devcom_release_peer_data(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS); 445 446 return 0; 447 448 out_err: 449 mlx5e_sqs2vport_stop(esw, rep); 450 451 if (peer_esw) 452 mlx5_devcom_release_peer_data(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS); 453 454 return err; 455 } 456 457 static int 458 mlx5e_add_sqs_fwd_rules(struct mlx5e_priv *priv) 459 { 460 int sqs_per_channel = mlx5e_get_dcb_num_tc(&priv->channels.params); 461 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 462 bool is_uplink_rep = mlx5e_is_uplink_rep(priv); 463 struct mlx5e_rep_priv *rpriv = priv->ppriv; 464 struct mlx5_eswitch_rep *rep = rpriv->rep; 465 int n, tc, nch, num_sqs = 0; 466 struct mlx5e_channel *c; 467 int err = -ENOMEM; 468 bool ptp_sq; 469 u32 *sqs; 470 471 ptp_sq = !!(priv->channels.ptp && 472 MLX5E_GET_PFLAG(&priv->channels.params, MLX5E_PFLAG_TX_PORT_TS)); 473 nch = priv->channels.num + ptp_sq; 474 /* +2 for xdpsqs, they don't exist on the ptp channel but will not be 475 * counted for by num_sqs. 476 */ 477 if (is_uplink_rep) 478 sqs_per_channel += 2; 479 480 sqs = kvcalloc(nch * sqs_per_channel, sizeof(*sqs), GFP_KERNEL); 481 if (!sqs) 482 goto out; 483 484 for (n = 0; n < priv->channels.num; n++) { 485 c = priv->channels.c[n]; 486 for (tc = 0; tc < c->num_tc; tc++) 487 sqs[num_sqs++] = c->sq[tc].sqn; 488 489 if (is_uplink_rep) { 490 if (c->xdp) 491 sqs[num_sqs++] = c->rq_xdpsq.sqn; 492 493 sqs[num_sqs++] = c->xdpsq.sqn; 494 } 495 } 496 if (ptp_sq) { 497 struct mlx5e_ptp *ptp_ch = priv->channels.ptp; 498 499 for (tc = 0; tc < ptp_ch->num_tc; tc++) 500 sqs[num_sqs++] = ptp_ch->ptpsq[tc].txqsq.sqn; 501 } 502 503 err = mlx5e_sqs2vport_start(esw, rep, sqs, num_sqs); 504 kvfree(sqs); 505 506 out: 507 if (err) 508 netdev_warn(priv->netdev, "Failed to add SQs FWD rules %d\n", err); 509 return err; 510 } 511 512 static void 513 mlx5e_remove_sqs_fwd_rules(struct mlx5e_priv *priv) 514 { 515 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 516 struct mlx5e_rep_priv *rpriv = priv->ppriv; 517 struct mlx5_eswitch_rep *rep = rpriv->rep; 518 519 mlx5e_sqs2vport_stop(esw, rep); 520 } 521 522 static int 523 mlx5e_rep_add_meta_tunnel_rule(struct mlx5e_priv *priv) 524 { 525 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 526 struct mlx5e_rep_priv *rpriv = priv->ppriv; 527 struct mlx5_eswitch_rep *rep = rpriv->rep; 528 struct mlx5_flow_handle *flow_rule; 529 struct mlx5_flow_group *g; 530 531 g = esw->fdb_table.offloads.send_to_vport_meta_grp; 532 if (!g) 533 return 0; 534 535 flow_rule = mlx5_eswitch_add_send_to_vport_meta_rule(esw, rep->vport); 536 if (IS_ERR(flow_rule)) 537 return PTR_ERR(flow_rule); 538 539 rpriv->send_to_vport_meta_rule = flow_rule; 540 541 return 0; 542 } 543 544 static void 545 mlx5e_rep_del_meta_tunnel_rule(struct mlx5e_priv *priv) 546 { 547 struct mlx5e_rep_priv *rpriv = priv->ppriv; 548 549 if (rpriv->send_to_vport_meta_rule) 550 mlx5_eswitch_del_send_to_vport_meta_rule(rpriv->send_to_vport_meta_rule); 551 } 552 553 void mlx5e_rep_activate_channels(struct mlx5e_priv *priv) 554 { 555 mlx5e_add_sqs_fwd_rules(priv); 556 mlx5e_rep_add_meta_tunnel_rule(priv); 557 } 558 559 void mlx5e_rep_deactivate_channels(struct mlx5e_priv *priv) 560 { 561 mlx5e_rep_del_meta_tunnel_rule(priv); 562 mlx5e_remove_sqs_fwd_rules(priv); 563 } 564 565 static int mlx5e_rep_open(struct net_device *dev) 566 { 567 struct mlx5e_priv *priv = netdev_priv(dev); 568 struct mlx5e_rep_priv *rpriv = priv->ppriv; 569 struct mlx5_eswitch_rep *rep = rpriv->rep; 570 int err; 571 572 mutex_lock(&priv->state_lock); 573 err = mlx5e_open_locked(dev); 574 if (err) 575 goto unlock; 576 577 if (!mlx5_modify_vport_admin_state(priv->mdev, 578 MLX5_VPORT_STATE_OP_MOD_ESW_VPORT, 579 rep->vport, 1, 580 MLX5_VPORT_ADMIN_STATE_UP)) 581 netif_carrier_on(dev); 582 583 unlock: 584 mutex_unlock(&priv->state_lock); 585 return err; 586 } 587 588 static int mlx5e_rep_close(struct net_device *dev) 589 { 590 struct mlx5e_priv *priv = netdev_priv(dev); 591 struct mlx5e_rep_priv *rpriv = priv->ppriv; 592 struct mlx5_eswitch_rep *rep = rpriv->rep; 593 int ret; 594 595 mutex_lock(&priv->state_lock); 596 mlx5_modify_vport_admin_state(priv->mdev, 597 MLX5_VPORT_STATE_OP_MOD_ESW_VPORT, 598 rep->vport, 1, 599 MLX5_VPORT_ADMIN_STATE_DOWN); 600 ret = mlx5e_close_locked(dev); 601 mutex_unlock(&priv->state_lock); 602 return ret; 603 } 604 605 bool mlx5e_is_uplink_rep(struct mlx5e_priv *priv) 606 { 607 struct mlx5e_rep_priv *rpriv = priv->ppriv; 608 struct mlx5_eswitch_rep *rep; 609 610 if (!MLX5_ESWITCH_MANAGER(priv->mdev)) 611 return false; 612 613 if (!rpriv) /* non vport rep mlx5e instances don't use this field */ 614 return false; 615 616 rep = rpriv->rep; 617 return (rep->vport == MLX5_VPORT_UPLINK); 618 } 619 620 bool mlx5e_rep_has_offload_stats(const struct net_device *dev, int attr_id) 621 { 622 switch (attr_id) { 623 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 624 return true; 625 } 626 627 return false; 628 } 629 630 static int 631 mlx5e_get_sw_stats64(const struct net_device *dev, 632 struct rtnl_link_stats64 *stats) 633 { 634 struct mlx5e_priv *priv = netdev_priv(dev); 635 636 mlx5e_fold_sw_stats64(priv, stats); 637 return 0; 638 } 639 640 int mlx5e_rep_get_offload_stats(int attr_id, const struct net_device *dev, 641 void *sp) 642 { 643 switch (attr_id) { 644 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 645 return mlx5e_get_sw_stats64(dev, sp); 646 } 647 648 return -EINVAL; 649 } 650 651 static void 652 mlx5e_rep_get_stats(struct net_device *dev, struct rtnl_link_stats64 *stats) 653 { 654 struct mlx5e_priv *priv = netdev_priv(dev); 655 656 /* update HW stats in background for next time */ 657 mlx5e_queue_update_stats(priv); 658 memcpy(stats, &priv->stats.vf_vport, sizeof(*stats)); 659 } 660 661 static int mlx5e_rep_change_mtu(struct net_device *netdev, int new_mtu) 662 { 663 return mlx5e_change_mtu(netdev, new_mtu, NULL); 664 } 665 666 static int mlx5e_rep_change_carrier(struct net_device *dev, bool new_carrier) 667 { 668 struct mlx5e_priv *priv = netdev_priv(dev); 669 struct mlx5e_rep_priv *rpriv = priv->ppriv; 670 struct mlx5_eswitch_rep *rep = rpriv->rep; 671 int err; 672 673 if (new_carrier) { 674 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT, 675 rep->vport, 1, MLX5_VPORT_ADMIN_STATE_UP); 676 if (err) 677 return err; 678 netif_carrier_on(dev); 679 } else { 680 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT, 681 rep->vport, 1, MLX5_VPORT_ADMIN_STATE_DOWN); 682 if (err) 683 return err; 684 netif_carrier_off(dev); 685 } 686 return 0; 687 } 688 689 static const struct net_device_ops mlx5e_netdev_ops_rep = { 690 .ndo_open = mlx5e_rep_open, 691 .ndo_stop = mlx5e_rep_close, 692 .ndo_start_xmit = mlx5e_xmit, 693 .ndo_setup_tc = mlx5e_rep_setup_tc, 694 .ndo_get_stats64 = mlx5e_rep_get_stats, 695 .ndo_has_offload_stats = mlx5e_rep_has_offload_stats, 696 .ndo_get_offload_stats = mlx5e_rep_get_offload_stats, 697 .ndo_change_mtu = mlx5e_rep_change_mtu, 698 .ndo_change_carrier = mlx5e_rep_change_carrier, 699 }; 700 701 bool mlx5e_eswitch_uplink_rep(const struct net_device *netdev) 702 { 703 return netdev->netdev_ops == &mlx5e_netdev_ops && 704 mlx5e_is_uplink_rep(netdev_priv(netdev)); 705 } 706 707 bool mlx5e_eswitch_vf_rep(const struct net_device *netdev) 708 { 709 return netdev->netdev_ops == &mlx5e_netdev_ops_rep; 710 } 711 712 /* One indirect TIR set for outer. Inner not supported in reps. */ 713 #define REP_NUM_INDIR_TIRS MLX5E_NUM_INDIR_TIRS 714 715 static int mlx5e_rep_max_nch_limit(struct mlx5_core_dev *mdev) 716 { 717 int max_tir_num = 1 << MLX5_CAP_GEN(mdev, log_max_tir); 718 int num_vports = mlx5_eswitch_get_total_vports(mdev); 719 720 return (max_tir_num - mlx5e_get_pf_num_tirs(mdev) 721 - (num_vports * REP_NUM_INDIR_TIRS)) / num_vports; 722 } 723 724 static void mlx5e_build_rep_params(struct net_device *netdev) 725 { 726 struct mlx5e_priv *priv = netdev_priv(netdev); 727 struct mlx5e_rep_priv *rpriv = priv->ppriv; 728 struct mlx5_eswitch_rep *rep = rpriv->rep; 729 struct mlx5_core_dev *mdev = priv->mdev; 730 struct mlx5e_params *params; 731 732 u8 cq_period_mode = MLX5_CAP_GEN(mdev, cq_period_start_from_cqe) ? 733 MLX5_CQ_PERIOD_MODE_START_FROM_CQE : 734 MLX5_CQ_PERIOD_MODE_START_FROM_EQE; 735 736 params = &priv->channels.params; 737 738 params->num_channels = MLX5E_REP_PARAMS_DEF_NUM_CHANNELS; 739 params->hard_mtu = MLX5E_ETH_HARD_MTU; 740 params->sw_mtu = netdev->mtu; 741 742 /* SQ */ 743 if (rep->vport == MLX5_VPORT_UPLINK) 744 params->log_sq_size = MLX5E_PARAMS_DEFAULT_LOG_SQ_SIZE; 745 else 746 params->log_sq_size = MLX5E_REP_PARAMS_DEF_LOG_SQ_SIZE; 747 748 /* RQ */ 749 mlx5e_build_rq_params(mdev, params); 750 751 /* update XDP supported features */ 752 mlx5e_set_xdp_feature(netdev); 753 754 /* CQ moderation params */ 755 params->rx_dim_enabled = MLX5_CAP_GEN(mdev, cq_moderation); 756 mlx5e_set_rx_cq_mode_params(params, cq_period_mode); 757 758 params->mqprio.num_tc = 1; 759 if (rep->vport != MLX5_VPORT_UPLINK) 760 params->vlan_strip_disable = true; 761 762 mlx5_query_min_inline(mdev, ¶ms->tx_min_inline_mode); 763 } 764 765 static void mlx5e_build_rep_netdev(struct net_device *netdev, 766 struct mlx5_core_dev *mdev) 767 { 768 SET_NETDEV_DEV(netdev, mdev->device); 769 netdev->netdev_ops = &mlx5e_netdev_ops_rep; 770 eth_hw_addr_random(netdev); 771 netdev->ethtool_ops = &mlx5e_rep_ethtool_ops; 772 773 netdev->watchdog_timeo = 15 * HZ; 774 775 #if IS_ENABLED(CONFIG_MLX5_CLS_ACT) 776 netdev->hw_features |= NETIF_F_HW_TC; 777 #endif 778 netdev->hw_features |= NETIF_F_SG; 779 netdev->hw_features |= NETIF_F_IP_CSUM; 780 netdev->hw_features |= NETIF_F_IPV6_CSUM; 781 netdev->hw_features |= NETIF_F_GRO; 782 netdev->hw_features |= NETIF_F_TSO; 783 netdev->hw_features |= NETIF_F_TSO6; 784 netdev->hw_features |= NETIF_F_RXCSUM; 785 786 netdev->features |= netdev->hw_features; 787 netdev->features |= NETIF_F_NETNS_LOCAL; 788 } 789 790 static int mlx5e_init_rep(struct mlx5_core_dev *mdev, 791 struct net_device *netdev) 792 { 793 struct mlx5e_priv *priv = netdev_priv(netdev); 794 795 priv->fs = 796 mlx5e_fs_init(priv->profile, mdev, 797 !test_bit(MLX5E_STATE_DESTROYING, &priv->state), 798 priv->dfs_root); 799 if (!priv->fs) { 800 netdev_err(priv->netdev, "FS allocation failed\n"); 801 return -ENOMEM; 802 } 803 804 mlx5e_build_rep_params(netdev); 805 mlx5e_timestamp_init(priv); 806 807 return 0; 808 } 809 810 static int mlx5e_init_ul_rep(struct mlx5_core_dev *mdev, 811 struct net_device *netdev) 812 { 813 struct mlx5e_priv *priv = netdev_priv(netdev); 814 815 priv->fs = mlx5e_fs_init(priv->profile, mdev, 816 !test_bit(MLX5E_STATE_DESTROYING, &priv->state), 817 priv->dfs_root); 818 if (!priv->fs) { 819 netdev_err(priv->netdev, "FS allocation failed\n"); 820 return -ENOMEM; 821 } 822 823 mlx5e_vxlan_set_netdev_info(priv); 824 mlx5e_build_rep_params(netdev); 825 mlx5e_timestamp_init(priv); 826 return 0; 827 } 828 829 static void mlx5e_cleanup_rep(struct mlx5e_priv *priv) 830 { 831 mlx5e_fs_cleanup(priv->fs); 832 priv->fs = NULL; 833 } 834 835 static int mlx5e_create_rep_ttc_table(struct mlx5e_priv *priv) 836 { 837 struct mlx5e_rep_priv *rpriv = priv->ppriv; 838 struct mlx5_eswitch_rep *rep = rpriv->rep; 839 struct ttc_params ttc_params = {}; 840 int err; 841 842 mlx5e_fs_set_ns(priv->fs, 843 mlx5_get_flow_namespace(priv->mdev, 844 MLX5_FLOW_NAMESPACE_KERNEL), false); 845 846 /* The inner_ttc in the ttc params is intentionally not set */ 847 mlx5e_set_ttc_params(priv->fs, priv->rx_res, &ttc_params, false); 848 849 if (rep->vport != MLX5_VPORT_UPLINK) 850 /* To give uplik rep TTC a lower level for chaining from root ft */ 851 ttc_params.ft_attr.level = MLX5E_TTC_FT_LEVEL + 1; 852 853 mlx5e_fs_set_ttc(priv->fs, mlx5_create_ttc_table(priv->mdev, &ttc_params), false); 854 if (IS_ERR(mlx5e_fs_get_ttc(priv->fs, false))) { 855 err = PTR_ERR(mlx5e_fs_get_ttc(priv->fs, false)); 856 netdev_err(priv->netdev, "Failed to create rep ttc table, err=%d\n", 857 err); 858 return err; 859 } 860 return 0; 861 } 862 863 static int mlx5e_create_rep_root_ft(struct mlx5e_priv *priv) 864 { 865 struct mlx5e_rep_priv *rpriv = priv->ppriv; 866 struct mlx5_eswitch_rep *rep = rpriv->rep; 867 struct mlx5_flow_table_attr ft_attr = {}; 868 struct mlx5_flow_namespace *ns; 869 int err = 0; 870 871 if (rep->vport != MLX5_VPORT_UPLINK) { 872 /* non uplik reps will skip any bypass tables and go directly to 873 * their own ttc 874 */ 875 rpriv->root_ft = mlx5_get_ttc_flow_table(mlx5e_fs_get_ttc(priv->fs, false)); 876 return 0; 877 } 878 879 /* uplink root ft will be used to auto chain, to ethtool or ttc tables */ 880 ns = mlx5_get_flow_namespace(priv->mdev, MLX5_FLOW_NAMESPACE_OFFLOADS); 881 if (!ns) { 882 netdev_err(priv->netdev, "Failed to get reps offloads namespace\n"); 883 return -EOPNOTSUPP; 884 } 885 886 ft_attr.max_fte = 0; /* Empty table, miss rule will always point to next table */ 887 ft_attr.prio = 1; 888 ft_attr.level = 1; 889 890 rpriv->root_ft = mlx5_create_flow_table(ns, &ft_attr); 891 if (IS_ERR(rpriv->root_ft)) { 892 err = PTR_ERR(rpriv->root_ft); 893 rpriv->root_ft = NULL; 894 } 895 896 return err; 897 } 898 899 static void mlx5e_destroy_rep_root_ft(struct mlx5e_priv *priv) 900 { 901 struct mlx5e_rep_priv *rpriv = priv->ppriv; 902 struct mlx5_eswitch_rep *rep = rpriv->rep; 903 904 if (rep->vport != MLX5_VPORT_UPLINK) 905 return; 906 mlx5_destroy_flow_table(rpriv->root_ft); 907 } 908 909 static int mlx5e_create_rep_vport_rx_rule(struct mlx5e_priv *priv) 910 { 911 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 912 struct mlx5e_rep_priv *rpriv = priv->ppriv; 913 struct mlx5_eswitch_rep *rep = rpriv->rep; 914 struct mlx5_flow_handle *flow_rule; 915 struct mlx5_flow_destination dest; 916 917 dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE; 918 dest.ft = rpriv->root_ft; 919 920 flow_rule = mlx5_eswitch_create_vport_rx_rule(esw, rep->vport, &dest); 921 if (IS_ERR(flow_rule)) 922 return PTR_ERR(flow_rule); 923 rpriv->vport_rx_rule = flow_rule; 924 return 0; 925 } 926 927 static void rep_vport_rx_rule_destroy(struct mlx5e_priv *priv) 928 { 929 struct mlx5e_rep_priv *rpriv = priv->ppriv; 930 931 if (!rpriv->vport_rx_rule) 932 return; 933 934 mlx5_del_flow_rules(rpriv->vport_rx_rule); 935 rpriv->vport_rx_rule = NULL; 936 } 937 938 int mlx5e_rep_bond_update(struct mlx5e_priv *priv, bool cleanup) 939 { 940 rep_vport_rx_rule_destroy(priv); 941 942 return cleanup ? 0 : mlx5e_create_rep_vport_rx_rule(priv); 943 } 944 945 static int mlx5e_init_rep_rx(struct mlx5e_priv *priv) 946 { 947 struct mlx5_core_dev *mdev = priv->mdev; 948 int err; 949 950 priv->rx_res = mlx5e_rx_res_alloc(); 951 if (!priv->rx_res) { 952 err = -ENOMEM; 953 goto err_free_fs; 954 } 955 956 mlx5e_fs_init_l2_addr(priv->fs, priv->netdev); 957 958 err = mlx5e_open_drop_rq(priv, &priv->drop_rq); 959 if (err) { 960 mlx5_core_err(mdev, "open drop rq failed, %d\n", err); 961 return err; 962 } 963 964 err = mlx5e_rx_res_init(priv->rx_res, priv->mdev, 0, 965 priv->max_nch, priv->drop_rq.rqn, 966 &priv->channels.params.packet_merge, 967 priv->channels.params.num_channels); 968 if (err) 969 goto err_close_drop_rq; 970 971 err = mlx5e_create_rep_ttc_table(priv); 972 if (err) 973 goto err_destroy_rx_res; 974 975 err = mlx5e_create_rep_root_ft(priv); 976 if (err) 977 goto err_destroy_ttc_table; 978 979 err = mlx5e_create_rep_vport_rx_rule(priv); 980 if (err) 981 goto err_destroy_root_ft; 982 983 mlx5e_ethtool_init_steering(priv->fs); 984 985 return 0; 986 987 err_destroy_root_ft: 988 mlx5e_destroy_rep_root_ft(priv); 989 err_destroy_ttc_table: 990 mlx5_destroy_ttc_table(mlx5e_fs_get_ttc(priv->fs, false)); 991 err_destroy_rx_res: 992 mlx5e_rx_res_destroy(priv->rx_res); 993 err_close_drop_rq: 994 mlx5e_close_drop_rq(&priv->drop_rq); 995 mlx5e_rx_res_free(priv->rx_res); 996 priv->rx_res = NULL; 997 err_free_fs: 998 mlx5e_fs_cleanup(priv->fs); 999 priv->fs = NULL; 1000 return err; 1001 } 1002 1003 static void mlx5e_cleanup_rep_rx(struct mlx5e_priv *priv) 1004 { 1005 mlx5e_ethtool_cleanup_steering(priv->fs); 1006 rep_vport_rx_rule_destroy(priv); 1007 mlx5e_destroy_rep_root_ft(priv); 1008 mlx5_destroy_ttc_table(mlx5e_fs_get_ttc(priv->fs, false)); 1009 mlx5e_rx_res_destroy(priv->rx_res); 1010 mlx5e_close_drop_rq(&priv->drop_rq); 1011 mlx5e_rx_res_free(priv->rx_res); 1012 priv->rx_res = NULL; 1013 } 1014 1015 static void mlx5e_rep_mpesw_work(struct work_struct *work) 1016 { 1017 struct mlx5_rep_uplink_priv *uplink_priv = 1018 container_of(work, struct mlx5_rep_uplink_priv, 1019 mpesw_work); 1020 struct mlx5e_rep_priv *rpriv = 1021 container_of(uplink_priv, struct mlx5e_rep_priv, 1022 uplink_priv); 1023 struct mlx5e_priv *priv = netdev_priv(rpriv->netdev); 1024 1025 rep_vport_rx_rule_destroy(priv); 1026 mlx5e_create_rep_vport_rx_rule(priv); 1027 } 1028 1029 static int mlx5e_init_ul_rep_rx(struct mlx5e_priv *priv) 1030 { 1031 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1032 int err; 1033 1034 mlx5e_create_q_counters(priv); 1035 err = mlx5e_init_rep_rx(priv); 1036 if (err) 1037 goto out; 1038 1039 mlx5e_tc_int_port_init_rep_rx(priv); 1040 1041 INIT_WORK(&rpriv->uplink_priv.mpesw_work, mlx5e_rep_mpesw_work); 1042 1043 out: 1044 return err; 1045 } 1046 1047 static void mlx5e_cleanup_ul_rep_rx(struct mlx5e_priv *priv) 1048 { 1049 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1050 1051 cancel_work_sync(&rpriv->uplink_priv.mpesw_work); 1052 mlx5e_tc_int_port_cleanup_rep_rx(priv); 1053 mlx5e_cleanup_rep_rx(priv); 1054 mlx5e_destroy_q_counters(priv); 1055 } 1056 1057 static int mlx5e_init_uplink_rep_tx(struct mlx5e_rep_priv *rpriv) 1058 { 1059 struct mlx5_rep_uplink_priv *uplink_priv; 1060 struct net_device *netdev; 1061 struct mlx5e_priv *priv; 1062 int err; 1063 1064 netdev = rpriv->netdev; 1065 priv = netdev_priv(netdev); 1066 uplink_priv = &rpriv->uplink_priv; 1067 1068 err = mlx5e_rep_tc_init(rpriv); 1069 if (err) 1070 return err; 1071 1072 mlx5_init_port_tun_entropy(&uplink_priv->tun_entropy, priv->mdev); 1073 1074 mlx5e_rep_bond_init(rpriv); 1075 err = mlx5e_rep_tc_netdevice_event_register(rpriv); 1076 if (err) { 1077 mlx5_core_err(priv->mdev, "Failed to register netdev notifier, err: %d\n", 1078 err); 1079 goto err_event_reg; 1080 } 1081 1082 return 0; 1083 1084 err_event_reg: 1085 mlx5e_rep_bond_cleanup(rpriv); 1086 mlx5e_rep_tc_cleanup(rpriv); 1087 return err; 1088 } 1089 1090 static void mlx5e_cleanup_uplink_rep_tx(struct mlx5e_rep_priv *rpriv) 1091 { 1092 mlx5e_rep_tc_netdevice_event_unregister(rpriv); 1093 mlx5e_rep_bond_cleanup(rpriv); 1094 mlx5e_rep_tc_cleanup(rpriv); 1095 } 1096 1097 static int mlx5e_init_rep_tx(struct mlx5e_priv *priv) 1098 { 1099 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1100 int err; 1101 1102 err = mlx5e_create_tises(priv); 1103 if (err) { 1104 mlx5_core_warn(priv->mdev, "create tises failed, %d\n", err); 1105 return err; 1106 } 1107 1108 if (rpriv->rep->vport == MLX5_VPORT_UPLINK) { 1109 err = mlx5e_init_uplink_rep_tx(rpriv); 1110 if (err) 1111 goto err_init_tx; 1112 } 1113 1114 err = mlx5e_tc_ht_init(&rpriv->tc_ht); 1115 if (err) 1116 goto err_ht_init; 1117 1118 return 0; 1119 1120 err_ht_init: 1121 if (rpriv->rep->vport == MLX5_VPORT_UPLINK) 1122 mlx5e_cleanup_uplink_rep_tx(rpriv); 1123 err_init_tx: 1124 mlx5e_destroy_tises(priv); 1125 return err; 1126 } 1127 1128 static void mlx5e_cleanup_rep_tx(struct mlx5e_priv *priv) 1129 { 1130 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1131 1132 mlx5e_tc_ht_cleanup(&rpriv->tc_ht); 1133 1134 if (rpriv->rep->vport == MLX5_VPORT_UPLINK) 1135 mlx5e_cleanup_uplink_rep_tx(rpriv); 1136 1137 mlx5e_destroy_tises(priv); 1138 } 1139 1140 static void mlx5e_rep_enable(struct mlx5e_priv *priv) 1141 { 1142 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1143 1144 mlx5e_set_netdev_mtu_boundaries(priv); 1145 mlx5e_rep_neigh_init(rpriv); 1146 } 1147 1148 static void mlx5e_rep_disable(struct mlx5e_priv *priv) 1149 { 1150 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1151 1152 mlx5e_rep_neigh_cleanup(rpriv); 1153 } 1154 1155 static int mlx5e_update_rep_rx(struct mlx5e_priv *priv) 1156 { 1157 return 0; 1158 } 1159 1160 static int mlx5e_rep_event_mpesw(struct mlx5e_priv *priv) 1161 { 1162 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1163 struct mlx5_eswitch_rep *rep = rpriv->rep; 1164 1165 if (rep->vport != MLX5_VPORT_UPLINK) 1166 return NOTIFY_DONE; 1167 1168 queue_work(priv->wq, &rpriv->uplink_priv.mpesw_work); 1169 1170 return NOTIFY_OK; 1171 } 1172 1173 static int uplink_rep_async_event(struct notifier_block *nb, unsigned long event, void *data) 1174 { 1175 struct mlx5e_priv *priv = container_of(nb, struct mlx5e_priv, events_nb); 1176 1177 if (event == MLX5_EVENT_TYPE_PORT_CHANGE) { 1178 struct mlx5_eqe *eqe = data; 1179 1180 switch (eqe->sub_type) { 1181 case MLX5_PORT_CHANGE_SUBTYPE_DOWN: 1182 case MLX5_PORT_CHANGE_SUBTYPE_ACTIVE: 1183 queue_work(priv->wq, &priv->update_carrier_work); 1184 break; 1185 default: 1186 return NOTIFY_DONE; 1187 } 1188 1189 return NOTIFY_OK; 1190 } 1191 1192 if (event == MLX5_DEV_EVENT_PORT_AFFINITY) 1193 return mlx5e_rep_tc_event_port_affinity(priv); 1194 else if (event == MLX5_DEV_EVENT_MULTIPORT_ESW) 1195 return mlx5e_rep_event_mpesw(priv); 1196 1197 return NOTIFY_DONE; 1198 } 1199 1200 static void mlx5e_uplink_rep_enable(struct mlx5e_priv *priv) 1201 { 1202 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1203 struct net_device *netdev = priv->netdev; 1204 struct mlx5_core_dev *mdev = priv->mdev; 1205 u16 max_mtu; 1206 1207 mlx5e_ipsec_init(priv); 1208 1209 netdev->min_mtu = ETH_MIN_MTU; 1210 mlx5_query_port_max_mtu(priv->mdev, &max_mtu, 1); 1211 netdev->max_mtu = MLX5E_HW2SW_MTU(&priv->channels.params, max_mtu); 1212 mlx5e_set_dev_port_mtu(priv); 1213 1214 mlx5e_rep_tc_enable(priv); 1215 1216 if (MLX5_CAP_GEN(mdev, uplink_follow)) 1217 mlx5_modify_vport_admin_state(mdev, MLX5_VPORT_STATE_OP_MOD_UPLINK, 1218 0, 0, MLX5_VPORT_ADMIN_STATE_AUTO); 1219 mlx5_lag_add_netdev(mdev, netdev); 1220 priv->events_nb.notifier_call = uplink_rep_async_event; 1221 mlx5_notifier_register(mdev, &priv->events_nb); 1222 mlx5e_dcbnl_initialize(priv); 1223 mlx5e_dcbnl_init_app(priv); 1224 mlx5e_rep_neigh_init(rpriv); 1225 mlx5e_rep_bridge_init(priv); 1226 1227 netdev->wanted_features |= NETIF_F_HW_TC; 1228 1229 rtnl_lock(); 1230 if (netif_running(netdev)) 1231 mlx5e_open(netdev); 1232 udp_tunnel_nic_reset_ntf(priv->netdev); 1233 netif_device_attach(netdev); 1234 rtnl_unlock(); 1235 } 1236 1237 static void mlx5e_uplink_rep_disable(struct mlx5e_priv *priv) 1238 { 1239 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1240 struct mlx5_core_dev *mdev = priv->mdev; 1241 1242 rtnl_lock(); 1243 if (netif_running(priv->netdev)) 1244 mlx5e_close(priv->netdev); 1245 netif_device_detach(priv->netdev); 1246 rtnl_unlock(); 1247 1248 mlx5e_rep_bridge_cleanup(priv); 1249 mlx5e_rep_neigh_cleanup(rpriv); 1250 mlx5e_dcbnl_delete_app(priv); 1251 mlx5_notifier_unregister(mdev, &priv->events_nb); 1252 mlx5e_rep_tc_disable(priv); 1253 mlx5_lag_remove_netdev(mdev, priv->netdev); 1254 mlx5_vxlan_reset_to_default(mdev->vxlan); 1255 1256 mlx5e_ipsec_cleanup(priv); 1257 } 1258 1259 static MLX5E_DEFINE_STATS_GRP(sw_rep, 0); 1260 static MLX5E_DEFINE_STATS_GRP(vport_rep, MLX5E_NDO_UPDATE_STATS); 1261 1262 /* The stats groups order is opposite to the update_stats() order calls */ 1263 static mlx5e_stats_grp_t mlx5e_rep_stats_grps[] = { 1264 &MLX5E_STATS_GRP(sw_rep), 1265 &MLX5E_STATS_GRP(vport_rep), 1266 }; 1267 1268 static unsigned int mlx5e_rep_stats_grps_num(struct mlx5e_priv *priv) 1269 { 1270 return ARRAY_SIZE(mlx5e_rep_stats_grps); 1271 } 1272 1273 /* The stats groups order is opposite to the update_stats() order calls */ 1274 static mlx5e_stats_grp_t mlx5e_ul_rep_stats_grps[] = { 1275 &MLX5E_STATS_GRP(sw), 1276 &MLX5E_STATS_GRP(qcnt), 1277 &MLX5E_STATS_GRP(vnic_env), 1278 &MLX5E_STATS_GRP(vport), 1279 &MLX5E_STATS_GRP(802_3), 1280 &MLX5E_STATS_GRP(2863), 1281 &MLX5E_STATS_GRP(2819), 1282 &MLX5E_STATS_GRP(phy), 1283 &MLX5E_STATS_GRP(eth_ext), 1284 &MLX5E_STATS_GRP(pcie), 1285 &MLX5E_STATS_GRP(per_prio), 1286 &MLX5E_STATS_GRP(pme), 1287 &MLX5E_STATS_GRP(channels), 1288 &MLX5E_STATS_GRP(per_port_buff_congest), 1289 #ifdef CONFIG_MLX5_EN_IPSEC 1290 &MLX5E_STATS_GRP(ipsec_sw), 1291 #endif 1292 &MLX5E_STATS_GRP(ptp), 1293 }; 1294 1295 static unsigned int mlx5e_ul_rep_stats_grps_num(struct mlx5e_priv *priv) 1296 { 1297 return ARRAY_SIZE(mlx5e_ul_rep_stats_grps); 1298 } 1299 1300 static int 1301 mlx5e_rep_vnic_reporter_diagnose(struct devlink_health_reporter *reporter, 1302 struct devlink_fmsg *fmsg, 1303 struct netlink_ext_ack *extack) 1304 { 1305 struct mlx5e_rep_priv *rpriv = devlink_health_reporter_priv(reporter); 1306 struct mlx5_eswitch_rep *rep = rpriv->rep; 1307 1308 return mlx5_reporter_vnic_diagnose_counters(rep->esw->dev, fmsg, 1309 rep->vport, true); 1310 } 1311 1312 static const struct devlink_health_reporter_ops mlx5_rep_vnic_reporter_ops = { 1313 .name = "vnic", 1314 .diagnose = mlx5e_rep_vnic_reporter_diagnose, 1315 }; 1316 1317 static void mlx5e_rep_vnic_reporter_create(struct mlx5e_priv *priv, 1318 struct devlink_port *dl_port) 1319 { 1320 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1321 struct devlink_health_reporter *reporter; 1322 1323 reporter = devl_port_health_reporter_create(dl_port, 1324 &mlx5_rep_vnic_reporter_ops, 1325 0, rpriv); 1326 if (IS_ERR(reporter)) { 1327 mlx5_core_err(priv->mdev, 1328 "Failed to create representor vnic reporter, err = %ld\n", 1329 PTR_ERR(reporter)); 1330 return; 1331 } 1332 1333 rpriv->rep_vnic_reporter = reporter; 1334 } 1335 1336 static void mlx5e_rep_vnic_reporter_destroy(struct mlx5e_priv *priv) 1337 { 1338 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1339 1340 if (!IS_ERR_OR_NULL(rpriv->rep_vnic_reporter)) 1341 devl_health_reporter_destroy(rpriv->rep_vnic_reporter); 1342 } 1343 1344 static const struct mlx5e_profile mlx5e_rep_profile = { 1345 .init = mlx5e_init_rep, 1346 .cleanup = mlx5e_cleanup_rep, 1347 .init_rx = mlx5e_init_rep_rx, 1348 .cleanup_rx = mlx5e_cleanup_rep_rx, 1349 .init_tx = mlx5e_init_rep_tx, 1350 .cleanup_tx = mlx5e_cleanup_rep_tx, 1351 .enable = mlx5e_rep_enable, 1352 .disable = mlx5e_rep_disable, 1353 .update_rx = mlx5e_update_rep_rx, 1354 .update_stats = mlx5e_stats_update_ndo_stats, 1355 .rx_handlers = &mlx5e_rx_handlers_rep, 1356 .max_tc = 1, 1357 .stats_grps = mlx5e_rep_stats_grps, 1358 .stats_grps_num = mlx5e_rep_stats_grps_num, 1359 .max_nch_limit = mlx5e_rep_max_nch_limit, 1360 }; 1361 1362 static const struct mlx5e_profile mlx5e_uplink_rep_profile = { 1363 .init = mlx5e_init_ul_rep, 1364 .cleanup = mlx5e_cleanup_rep, 1365 .init_rx = mlx5e_init_ul_rep_rx, 1366 .cleanup_rx = mlx5e_cleanup_ul_rep_rx, 1367 .init_tx = mlx5e_init_rep_tx, 1368 .cleanup_tx = mlx5e_cleanup_rep_tx, 1369 .enable = mlx5e_uplink_rep_enable, 1370 .disable = mlx5e_uplink_rep_disable, 1371 .update_rx = mlx5e_update_rep_rx, 1372 .update_stats = mlx5e_stats_update_ndo_stats, 1373 .update_carrier = mlx5e_update_carrier, 1374 .rx_handlers = &mlx5e_rx_handlers_rep, 1375 .max_tc = MLX5E_MAX_NUM_TC, 1376 .stats_grps = mlx5e_ul_rep_stats_grps, 1377 .stats_grps_num = mlx5e_ul_rep_stats_grps_num, 1378 }; 1379 1380 /* e-Switch vport representors */ 1381 static int 1382 mlx5e_vport_uplink_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep) 1383 { 1384 struct mlx5e_priv *priv = netdev_priv(mlx5_uplink_netdev_get(dev)); 1385 struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep); 1386 1387 rpriv->netdev = priv->netdev; 1388 return mlx5e_netdev_change_profile(priv, &mlx5e_uplink_rep_profile, 1389 rpriv); 1390 } 1391 1392 static void 1393 mlx5e_vport_uplink_rep_unload(struct mlx5e_rep_priv *rpriv) 1394 { 1395 struct net_device *netdev = rpriv->netdev; 1396 struct mlx5e_priv *priv; 1397 1398 priv = netdev_priv(netdev); 1399 1400 mlx5e_netdev_attach_nic_profile(priv); 1401 } 1402 1403 static int 1404 mlx5e_vport_vf_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep) 1405 { 1406 struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep); 1407 const struct mlx5e_profile *profile; 1408 struct devlink_port *dl_port; 1409 struct net_device *netdev; 1410 struct mlx5e_priv *priv; 1411 int err; 1412 1413 profile = &mlx5e_rep_profile; 1414 netdev = mlx5e_create_netdev(dev, profile); 1415 if (!netdev) { 1416 mlx5_core_warn(dev, 1417 "Failed to create representor netdev for vport %d\n", 1418 rep->vport); 1419 return -EINVAL; 1420 } 1421 1422 mlx5e_build_rep_netdev(netdev, dev); 1423 rpriv->netdev = netdev; 1424 1425 priv = netdev_priv(netdev); 1426 priv->profile = profile; 1427 priv->ppriv = rpriv; 1428 err = profile->init(dev, netdev); 1429 if (err) { 1430 netdev_warn(netdev, "rep profile init failed, %d\n", err); 1431 goto err_destroy_netdev; 1432 } 1433 1434 err = mlx5e_attach_netdev(netdev_priv(netdev)); 1435 if (err) { 1436 netdev_warn(netdev, 1437 "Failed to attach representor netdev for vport %d\n", 1438 rep->vport); 1439 goto err_cleanup_profile; 1440 } 1441 1442 dl_port = mlx5_esw_offloads_devlink_port(dev->priv.eswitch, 1443 rpriv->rep->vport); 1444 if (dl_port) { 1445 SET_NETDEV_DEVLINK_PORT(netdev, dl_port); 1446 mlx5e_rep_vnic_reporter_create(priv, dl_port); 1447 } 1448 1449 err = register_netdev(netdev); 1450 if (err) { 1451 netdev_warn(netdev, 1452 "Failed to register representor netdev for vport %d\n", 1453 rep->vport); 1454 goto err_detach_netdev; 1455 } 1456 1457 return 0; 1458 1459 err_detach_netdev: 1460 mlx5e_rep_vnic_reporter_destroy(priv); 1461 mlx5e_detach_netdev(netdev_priv(netdev)); 1462 err_cleanup_profile: 1463 priv->profile->cleanup(priv); 1464 1465 err_destroy_netdev: 1466 mlx5e_destroy_netdev(netdev_priv(netdev)); 1467 return err; 1468 } 1469 1470 static int 1471 mlx5e_vport_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep) 1472 { 1473 struct mlx5e_rep_priv *rpriv; 1474 int err; 1475 1476 rpriv = kvzalloc(sizeof(*rpriv), GFP_KERNEL); 1477 if (!rpriv) 1478 return -ENOMEM; 1479 1480 /* rpriv->rep to be looked up when profile->init() is called */ 1481 rpriv->rep = rep; 1482 rep->rep_data[REP_ETH].priv = rpriv; 1483 INIT_LIST_HEAD(&rpriv->vport_sqs_list); 1484 1485 if (rep->vport == MLX5_VPORT_UPLINK) 1486 err = mlx5e_vport_uplink_rep_load(dev, rep); 1487 else 1488 err = mlx5e_vport_vf_rep_load(dev, rep); 1489 1490 if (err) 1491 kvfree(rpriv); 1492 1493 return err; 1494 } 1495 1496 static void 1497 mlx5e_vport_rep_unload(struct mlx5_eswitch_rep *rep) 1498 { 1499 struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep); 1500 struct net_device *netdev = rpriv->netdev; 1501 struct mlx5e_priv *priv = netdev_priv(netdev); 1502 void *ppriv = priv->ppriv; 1503 1504 if (rep->vport == MLX5_VPORT_UPLINK) { 1505 mlx5e_vport_uplink_rep_unload(rpriv); 1506 goto free_ppriv; 1507 } 1508 1509 unregister_netdev(netdev); 1510 mlx5e_rep_vnic_reporter_destroy(priv); 1511 mlx5e_detach_netdev(priv); 1512 priv->profile->cleanup(priv); 1513 mlx5e_destroy_netdev(priv); 1514 free_ppriv: 1515 kvfree(ppriv); /* mlx5e_rep_priv */ 1516 } 1517 1518 static void *mlx5e_vport_rep_get_proto_dev(struct mlx5_eswitch_rep *rep) 1519 { 1520 struct mlx5e_rep_priv *rpriv; 1521 1522 rpriv = mlx5e_rep_to_rep_priv(rep); 1523 1524 return rpriv->netdev; 1525 } 1526 1527 static void mlx5e_vport_rep_event_unpair(struct mlx5_eswitch_rep *rep) 1528 { 1529 struct mlx5e_rep_priv *rpriv; 1530 struct mlx5e_rep_sq *rep_sq; 1531 1532 rpriv = mlx5e_rep_to_rep_priv(rep); 1533 list_for_each_entry(rep_sq, &rpriv->vport_sqs_list, list) { 1534 if (!rep_sq->send_to_vport_rule_peer) 1535 continue; 1536 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule_peer); 1537 rep_sq->send_to_vport_rule_peer = NULL; 1538 } 1539 } 1540 1541 static int mlx5e_vport_rep_event_pair(struct mlx5_eswitch *esw, 1542 struct mlx5_eswitch_rep *rep, 1543 struct mlx5_eswitch *peer_esw) 1544 { 1545 struct mlx5_flow_handle *flow_rule; 1546 struct mlx5e_rep_priv *rpriv; 1547 struct mlx5e_rep_sq *rep_sq; 1548 1549 rpriv = mlx5e_rep_to_rep_priv(rep); 1550 list_for_each_entry(rep_sq, &rpriv->vport_sqs_list, list) { 1551 if (rep_sq->send_to_vport_rule_peer) 1552 continue; 1553 flow_rule = mlx5_eswitch_add_send_to_vport_rule(peer_esw, esw, rep, rep_sq->sqn); 1554 if (IS_ERR(flow_rule)) 1555 goto err_out; 1556 rep_sq->send_to_vport_rule_peer = flow_rule; 1557 } 1558 1559 return 0; 1560 err_out: 1561 mlx5e_vport_rep_event_unpair(rep); 1562 return PTR_ERR(flow_rule); 1563 } 1564 1565 static int mlx5e_vport_rep_event(struct mlx5_eswitch *esw, 1566 struct mlx5_eswitch_rep *rep, 1567 enum mlx5_switchdev_event event, 1568 void *data) 1569 { 1570 int err = 0; 1571 1572 if (event == MLX5_SWITCHDEV_EVENT_PAIR) 1573 err = mlx5e_vport_rep_event_pair(esw, rep, data); 1574 else if (event == MLX5_SWITCHDEV_EVENT_UNPAIR) 1575 mlx5e_vport_rep_event_unpair(rep); 1576 1577 return err; 1578 } 1579 1580 static const struct mlx5_eswitch_rep_ops rep_ops = { 1581 .load = mlx5e_vport_rep_load, 1582 .unload = mlx5e_vport_rep_unload, 1583 .get_proto_dev = mlx5e_vport_rep_get_proto_dev, 1584 .event = mlx5e_vport_rep_event, 1585 }; 1586 1587 static int mlx5e_rep_probe(struct auxiliary_device *adev, 1588 const struct auxiliary_device_id *id) 1589 { 1590 struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev); 1591 struct mlx5_core_dev *mdev = edev->mdev; 1592 struct mlx5_eswitch *esw; 1593 1594 esw = mdev->priv.eswitch; 1595 mlx5_eswitch_register_vport_reps(esw, &rep_ops, REP_ETH); 1596 return 0; 1597 } 1598 1599 static void mlx5e_rep_remove(struct auxiliary_device *adev) 1600 { 1601 struct mlx5_adev *vdev = container_of(adev, struct mlx5_adev, adev); 1602 struct mlx5_core_dev *mdev = vdev->mdev; 1603 struct mlx5_eswitch *esw; 1604 1605 esw = mdev->priv.eswitch; 1606 mlx5_eswitch_unregister_vport_reps(esw, REP_ETH); 1607 } 1608 1609 static const struct auxiliary_device_id mlx5e_rep_id_table[] = { 1610 { .name = MLX5_ADEV_NAME ".eth-rep", }, 1611 {}, 1612 }; 1613 1614 MODULE_DEVICE_TABLE(auxiliary, mlx5e_rep_id_table); 1615 1616 static struct auxiliary_driver mlx5e_rep_driver = { 1617 .name = "eth-rep", 1618 .probe = mlx5e_rep_probe, 1619 .remove = mlx5e_rep_remove, 1620 .id_table = mlx5e_rep_id_table, 1621 }; 1622 1623 int mlx5e_rep_init(void) 1624 { 1625 return auxiliary_driver_register(&mlx5e_rep_driver); 1626 } 1627 1628 void mlx5e_rep_cleanup(void) 1629 { 1630 auxiliary_driver_unregister(&mlx5e_rep_driver); 1631 } 1632