1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) 2018 Microsoft Corp. 3 * All rights reserved. 4 */ 5 6 #include <stdio.h> 7 #include <stdint.h> 8 #include <string.h> 9 #include <stdbool.h> 10 #include <errno.h> 11 #include <unistd.h> 12 #include <dirent.h> 13 #include <fcntl.h> 14 #include <sys/types.h> 15 #include <sys/uio.h> 16 17 #include <rte_ether.h> 18 #include <rte_ethdev.h> 19 #include <rte_ethdev_driver.h> 20 #include <rte_lcore.h> 21 #include <rte_memory.h> 22 #include <rte_bus_vmbus.h> 23 #include <rte_pci.h> 24 #include <rte_bus_pci.h> 25 #include <rte_log.h> 26 #include <rte_string_fns.h> 27 28 #include "hn_logs.h" 29 #include "hn_var.h" 30 #include "hn_nvs.h" 31 32 /* Search for VF with matching MAC address, return port id */ 33 static int hn_vf_match(const struct rte_eth_dev *dev) 34 { 35 const struct ether_addr *mac = dev->data->mac_addrs; 36 int i; 37 38 RTE_ETH_FOREACH_DEV(i) { 39 const struct rte_eth_dev *vf_dev = &rte_eth_devices[i]; 40 const struct ether_addr *vf_mac = vf_dev->data->mac_addrs; 41 42 if (vf_dev == dev) 43 continue; 44 45 if (is_same_ether_addr(mac, vf_mac)) 46 return i; 47 } 48 return -ENOENT; 49 } 50 51 52 /* 53 * Attach new PCI VF device and return the port_id 54 */ 55 static int hn_vf_attach(struct hn_data *hv, uint16_t port_id) 56 { 57 struct rte_eth_dev_owner owner = { .id = RTE_ETH_DEV_NO_OWNER }; 58 int ret; 59 60 if (hn_vf_attached(hv)) { 61 PMD_DRV_LOG(ERR, "VF already attached"); 62 return -EEXIST; 63 } 64 65 ret = rte_eth_dev_owner_get(port_id, &owner); 66 if (ret < 0) { 67 PMD_DRV_LOG(ERR, "Can not find owner for port %d", port_id); 68 return ret; 69 } 70 71 if (owner.id != RTE_ETH_DEV_NO_OWNER) { 72 PMD_DRV_LOG(ERR, "Port %u already owned by other device %s", 73 port_id, owner.name); 74 return -EBUSY; 75 } 76 77 ret = rte_eth_dev_owner_set(port_id, &hv->owner); 78 if (ret < 0) { 79 PMD_DRV_LOG(ERR, "Can set owner for port %d", port_id); 80 return ret; 81 } 82 83 PMD_DRV_LOG(DEBUG, "Attach VF device %u", port_id); 84 hv->vf_port = port_id; 85 rte_smp_wmb(); 86 87 return 0; 88 } 89 90 /* Add new VF device to synthetic device */ 91 int hn_vf_add(struct rte_eth_dev *dev, struct hn_data *hv) 92 { 93 int port, err; 94 95 port = hn_vf_match(dev); 96 if (port < 0) { 97 PMD_DRV_LOG(NOTICE, "No matching MAC found"); 98 return port; 99 } 100 101 rte_spinlock_lock(&hv->vf_lock); 102 err = hn_vf_attach(hv, port); 103 104 if (err == 0) { 105 dev->data->dev_flags |= RTE_ETH_DEV_INTR_LSC; 106 hv->vf_intr = (struct rte_intr_handle) { 107 .fd = -1, 108 .type = RTE_INTR_HANDLE_EXT, 109 }; 110 dev->intr_handle = &hv->vf_intr; 111 hn_nvs_set_datapath(hv, NVS_DATAPATH_VF); 112 } 113 rte_spinlock_unlock(&hv->vf_lock); 114 115 return err; 116 } 117 118 /* Remove new VF device */ 119 static void hn_vf_remove(struct hn_data *hv) 120 { 121 122 rte_spinlock_lock(&hv->vf_lock); 123 124 if (!hn_vf_attached(hv)) { 125 PMD_DRV_LOG(ERR, "VF path not active"); 126 } else { 127 /* Stop incoming packets from arriving on VF */ 128 hn_nvs_set_datapath(hv, NVS_DATAPATH_SYNTHETIC); 129 130 /* Stop transmission over VF */ 131 hv->vf_port = HN_INVALID_PORT; 132 rte_smp_wmb(); 133 134 /* Give back ownership */ 135 rte_eth_dev_owner_unset(hv->vf_port, hv->owner.id); 136 } 137 rte_spinlock_unlock(&hv->vf_lock); 138 } 139 140 /* Handle VF association message from host */ 141 void 142 hn_nvs_handle_vfassoc(struct rte_eth_dev *dev, 143 const struct vmbus_chanpkt_hdr *hdr, 144 const void *data) 145 { 146 struct hn_data *hv = dev->data->dev_private; 147 const struct hn_nvs_vf_association *vf_assoc = data; 148 149 if (unlikely(vmbus_chanpkt_datalen(hdr) < sizeof(*vf_assoc))) { 150 PMD_DRV_LOG(ERR, "invalid vf association NVS"); 151 return; 152 } 153 154 PMD_DRV_LOG(DEBUG, "VF serial %u %s port %u", 155 vf_assoc->serial, 156 vf_assoc->allocated ? "add to" : "remove from", 157 dev->data->port_id); 158 159 hv->vf_present = vf_assoc->allocated; 160 161 if (dev->state != RTE_ETH_DEV_ATTACHED) 162 return; 163 164 if (vf_assoc->allocated) 165 hn_vf_add(dev, hv); 166 else 167 hn_vf_remove(hv); 168 } 169 170 /* 171 * Merge the info from the VF and synthetic path. 172 * use the default config of the VF 173 * and the minimum number of queues and buffer sizes. 174 */ 175 static void hn_vf_info_merge(struct rte_eth_dev *vf_dev, 176 struct rte_eth_dev_info *info) 177 { 178 struct rte_eth_dev_info vf_info; 179 180 rte_eth_dev_info_get(vf_dev->data->port_id, &vf_info); 181 182 info->speed_capa = vf_info.speed_capa; 183 info->default_rxportconf = vf_info.default_rxportconf; 184 info->default_txportconf = vf_info.default_txportconf; 185 186 info->max_rx_queues = RTE_MIN(vf_info.max_rx_queues, 187 info->max_rx_queues); 188 info->rx_offload_capa &= vf_info.rx_offload_capa; 189 info->rx_queue_offload_capa &= vf_info.rx_queue_offload_capa; 190 info->flow_type_rss_offloads &= vf_info.flow_type_rss_offloads; 191 192 info->max_tx_queues = RTE_MIN(vf_info.max_tx_queues, 193 info->max_tx_queues); 194 info->tx_offload_capa &= vf_info.tx_offload_capa; 195 info->tx_queue_offload_capa &= vf_info.tx_queue_offload_capa; 196 197 info->min_rx_bufsize = RTE_MAX(vf_info.min_rx_bufsize, 198 info->min_rx_bufsize); 199 info->max_rx_pktlen = RTE_MAX(vf_info.max_rx_pktlen, 200 info->max_rx_pktlen); 201 } 202 203 void hn_vf_info_get(struct hn_data *hv, struct rte_eth_dev_info *info) 204 { 205 struct rte_eth_dev *vf_dev; 206 207 rte_spinlock_lock(&hv->vf_lock); 208 vf_dev = hn_get_vf_dev(hv); 209 if (vf_dev) 210 hn_vf_info_merge(vf_dev, info); 211 rte_spinlock_unlock(&hv->vf_lock); 212 } 213 214 int hn_vf_link_update(struct rte_eth_dev *dev, 215 int wait_to_complete) 216 { 217 struct hn_data *hv = dev->data->dev_private; 218 struct rte_eth_dev *vf_dev; 219 int ret = 0; 220 221 rte_spinlock_lock(&hv->vf_lock); 222 vf_dev = hn_get_vf_dev(hv); 223 if (vf_dev && vf_dev->dev_ops->link_update) 224 ret = (*vf_dev->dev_ops->link_update)(vf_dev, wait_to_complete); 225 rte_spinlock_unlock(&hv->vf_lock); 226 227 return ret; 228 } 229 230 /* called when VF has link state interrupts enabled */ 231 static int hn_vf_lsc_event(uint16_t port_id __rte_unused, 232 enum rte_eth_event_type event, 233 void *cb_arg, void *out __rte_unused) 234 { 235 struct rte_eth_dev *dev = cb_arg; 236 237 if (event != RTE_ETH_EVENT_INTR_LSC) 238 return 0; 239 240 /* if link state has changed pass on */ 241 if (hn_dev_link_update(dev, 0) == 0) 242 return 0; /* no change */ 243 244 return _rte_eth_dev_callback_process(dev, 245 RTE_ETH_EVENT_INTR_LSC, 246 NULL); 247 } 248 249 static int _hn_vf_configure(struct rte_eth_dev *dev, 250 uint16_t vf_port, 251 const struct rte_eth_conf *dev_conf) 252 { 253 struct rte_eth_conf vf_conf = *dev_conf; 254 struct rte_eth_dev *vf_dev; 255 int ret; 256 257 vf_dev = &rte_eth_devices[vf_port]; 258 if (dev_conf->intr_conf.lsc && 259 (vf_dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)) { 260 PMD_DRV_LOG(DEBUG, "enabling LSC for VF %u", 261 vf_port); 262 vf_conf.intr_conf.lsc = 1; 263 } else { 264 PMD_DRV_LOG(DEBUG, "disabling LSC for VF %u", 265 vf_port); 266 vf_conf.intr_conf.lsc = 0; 267 } 268 269 ret = rte_eth_dev_configure(vf_port, 270 dev->data->nb_rx_queues, 271 dev->data->nb_tx_queues, 272 &vf_conf); 273 if (ret) { 274 PMD_DRV_LOG(ERR, 275 "VF configuration failed: %d", ret); 276 } else if (vf_conf.intr_conf.lsc) { 277 ret = rte_eth_dev_callback_register(vf_port, 278 RTE_ETH_DEV_INTR_LSC, 279 hn_vf_lsc_event, dev); 280 if (ret) 281 PMD_DRV_LOG(ERR, 282 "Failed to register LSC callback for VF %u", 283 vf_port); 284 } 285 return ret; 286 } 287 288 /* 289 * Configure VF if present. 290 * Force VF to have same number of queues as synthetic device 291 */ 292 int hn_vf_configure(struct rte_eth_dev *dev, 293 const struct rte_eth_conf *dev_conf) 294 { 295 struct hn_data *hv = dev->data->dev_private; 296 int ret = 0; 297 298 rte_spinlock_lock(&hv->vf_lock); 299 if (hv->vf_port != HN_INVALID_PORT) 300 ret = _hn_vf_configure(dev, hv->vf_port, dev_conf); 301 rte_spinlock_unlock(&hv->vf_lock); 302 return ret; 303 } 304 305 const uint32_t *hn_vf_supported_ptypes(struct rte_eth_dev *dev) 306 { 307 struct hn_data *hv = dev->data->dev_private; 308 struct rte_eth_dev *vf_dev; 309 const uint32_t *ptypes = NULL; 310 311 rte_spinlock_lock(&hv->vf_lock); 312 vf_dev = hn_get_vf_dev(hv); 313 if (vf_dev && vf_dev->dev_ops->dev_supported_ptypes_get) 314 ptypes = (*vf_dev->dev_ops->dev_supported_ptypes_get)(vf_dev); 315 rte_spinlock_unlock(&hv->vf_lock); 316 317 return ptypes; 318 } 319 320 int hn_vf_start(struct rte_eth_dev *dev) 321 { 322 struct hn_data *hv = dev->data->dev_private; 323 struct rte_eth_dev *vf_dev; 324 int ret = 0; 325 326 rte_spinlock_lock(&hv->vf_lock); 327 vf_dev = hn_get_vf_dev(hv); 328 if (vf_dev) 329 ret = rte_eth_dev_start(vf_dev->data->port_id); 330 rte_spinlock_unlock(&hv->vf_lock); 331 return ret; 332 } 333 334 void hn_vf_stop(struct rte_eth_dev *dev) 335 { 336 struct hn_data *hv = dev->data->dev_private; 337 struct rte_eth_dev *vf_dev; 338 339 rte_spinlock_lock(&hv->vf_lock); 340 vf_dev = hn_get_vf_dev(hv); 341 if (vf_dev) 342 rte_eth_dev_stop(vf_dev->data->port_id); 343 rte_spinlock_unlock(&hv->vf_lock); 344 } 345 346 /* If VF is present, then cascade configuration down */ 347 #define VF_ETHDEV_FUNC(dev, func) \ 348 { \ 349 struct hn_data *hv = (dev)->data->dev_private; \ 350 struct rte_eth_dev *vf_dev; \ 351 rte_spinlock_lock(&hv->vf_lock); \ 352 vf_dev = hn_get_vf_dev(hv); \ 353 if (vf_dev) \ 354 func(vf_dev->data->port_id); \ 355 rte_spinlock_unlock(&hv->vf_lock); \ 356 } 357 358 void hn_vf_reset(struct rte_eth_dev *dev) 359 { 360 VF_ETHDEV_FUNC(dev, rte_eth_dev_reset); 361 } 362 363 void hn_vf_close(struct rte_eth_dev *dev) 364 { 365 VF_ETHDEV_FUNC(dev, rte_eth_dev_close); 366 } 367 368 void hn_vf_stats_reset(struct rte_eth_dev *dev) 369 { 370 VF_ETHDEV_FUNC(dev, rte_eth_stats_reset); 371 } 372 373 void hn_vf_allmulticast_enable(struct rte_eth_dev *dev) 374 { 375 VF_ETHDEV_FUNC(dev, rte_eth_allmulticast_enable); 376 } 377 378 void hn_vf_allmulticast_disable(struct rte_eth_dev *dev) 379 { 380 VF_ETHDEV_FUNC(dev, rte_eth_allmulticast_disable); 381 } 382 383 void hn_vf_promiscuous_enable(struct rte_eth_dev *dev) 384 { 385 VF_ETHDEV_FUNC(dev, rte_eth_promiscuous_enable); 386 } 387 388 void hn_vf_promiscuous_disable(struct rte_eth_dev *dev) 389 { 390 VF_ETHDEV_FUNC(dev, rte_eth_promiscuous_disable); 391 } 392 393 int hn_vf_mc_addr_list(struct rte_eth_dev *dev, 394 struct ether_addr *mc_addr_set, 395 uint32_t nb_mc_addr) 396 { 397 struct hn_data *hv = dev->data->dev_private; 398 struct rte_eth_dev *vf_dev; 399 int ret = 0; 400 401 rte_spinlock_lock(&hv->vf_lock); 402 vf_dev = hn_get_vf_dev(hv); 403 if (vf_dev) 404 ret = rte_eth_dev_set_mc_addr_list(vf_dev->data->port_id, 405 mc_addr_set, nb_mc_addr); 406 rte_spinlock_unlock(&hv->vf_lock); 407 return ret; 408 } 409 410 int hn_vf_tx_queue_setup(struct rte_eth_dev *dev, 411 uint16_t queue_idx, uint16_t nb_desc, 412 unsigned int socket_id, 413 const struct rte_eth_txconf *tx_conf) 414 { 415 struct hn_data *hv = dev->data->dev_private; 416 struct rte_eth_dev *vf_dev; 417 int ret = 0; 418 419 rte_spinlock_lock(&hv->vf_lock); 420 vf_dev = hn_get_vf_dev(hv); 421 if (vf_dev) 422 ret = rte_eth_tx_queue_setup(vf_dev->data->port_id, 423 queue_idx, nb_desc, 424 socket_id, tx_conf); 425 rte_spinlock_unlock(&hv->vf_lock); 426 return ret; 427 } 428 429 void hn_vf_tx_queue_release(struct hn_data *hv, uint16_t queue_id) 430 { 431 struct rte_eth_dev *vf_dev; 432 433 rte_spinlock_lock(&hv->vf_lock); 434 vf_dev = hn_get_vf_dev(hv); 435 if (vf_dev && vf_dev->dev_ops->tx_queue_release) { 436 void *subq = vf_dev->data->tx_queues[queue_id]; 437 438 (*vf_dev->dev_ops->tx_queue_release)(subq); 439 } 440 441 rte_spinlock_unlock(&hv->vf_lock); 442 } 443 444 int hn_vf_rx_queue_setup(struct rte_eth_dev *dev, 445 uint16_t queue_idx, uint16_t nb_desc, 446 unsigned int socket_id, 447 const struct rte_eth_rxconf *rx_conf, 448 struct rte_mempool *mp) 449 { 450 struct hn_data *hv = dev->data->dev_private; 451 struct rte_eth_dev *vf_dev; 452 int ret = 0; 453 454 rte_spinlock_lock(&hv->vf_lock); 455 vf_dev = hn_get_vf_dev(hv); 456 if (vf_dev) 457 ret = rte_eth_rx_queue_setup(vf_dev->data->port_id, 458 queue_idx, nb_desc, 459 socket_id, rx_conf, mp); 460 rte_spinlock_unlock(&hv->vf_lock); 461 return ret; 462 } 463 464 void hn_vf_rx_queue_release(struct hn_data *hv, uint16_t queue_id) 465 { 466 struct rte_eth_dev *vf_dev; 467 468 rte_spinlock_lock(&hv->vf_lock); 469 vf_dev = hn_get_vf_dev(hv); 470 if (vf_dev && vf_dev->dev_ops->rx_queue_release) { 471 void *subq = vf_dev->data->rx_queues[queue_id]; 472 473 (*vf_dev->dev_ops->rx_queue_release)(subq); 474 } 475 rte_spinlock_unlock(&hv->vf_lock); 476 } 477 478 int hn_vf_stats_get(struct rte_eth_dev *dev, 479 struct rte_eth_stats *stats) 480 { 481 struct hn_data *hv = dev->data->dev_private; 482 struct rte_eth_dev *vf_dev; 483 int ret = 0; 484 485 rte_spinlock_lock(&hv->vf_lock); 486 vf_dev = hn_get_vf_dev(hv); 487 if (vf_dev) 488 ret = rte_eth_stats_get(vf_dev->data->port_id, stats); 489 rte_spinlock_unlock(&hv->vf_lock); 490 return ret; 491 } 492 493 int hn_vf_xstats_get_names(struct rte_eth_dev *dev, 494 struct rte_eth_xstat_name *names, 495 unsigned int n) 496 { 497 struct hn_data *hv = dev->data->dev_private; 498 struct rte_eth_dev *vf_dev; 499 int i, count = 0; 500 char tmp[RTE_ETH_XSTATS_NAME_SIZE]; 501 502 rte_spinlock_lock(&hv->vf_lock); 503 vf_dev = hn_get_vf_dev(hv); 504 if (vf_dev && vf_dev->dev_ops->xstats_get_names) 505 count = vf_dev->dev_ops->xstats_get_names(vf_dev, names, n); 506 rte_spinlock_unlock(&hv->vf_lock); 507 508 /* add vf_ prefix to xstat names */ 509 if (names) { 510 for (i = 0; i < count; i++) { 511 snprintf(tmp, sizeof(tmp), "vf_%s", names[i].name); 512 strlcpy(names[i].name, tmp, sizeof(names[i].name)); 513 } 514 } 515 516 return count; 517 } 518 519 int hn_vf_xstats_get(struct rte_eth_dev *dev, 520 struct rte_eth_xstat *xstats, 521 unsigned int n) 522 { 523 struct hn_data *hv = dev->data->dev_private; 524 struct rte_eth_dev *vf_dev; 525 int count = 0; 526 527 rte_spinlock_lock(&hv->vf_lock); 528 vf_dev = hn_get_vf_dev(hv); 529 if (vf_dev && vf_dev->dev_ops->xstats_get) 530 count = vf_dev->dev_ops->xstats_get(vf_dev, xstats, n); 531 rte_spinlock_unlock(&hv->vf_lock); 532 533 return count; 534 } 535 536 void hn_vf_xstats_reset(struct rte_eth_dev *dev) 537 { 538 struct hn_data *hv = dev->data->dev_private; 539 struct rte_eth_dev *vf_dev; 540 541 rte_spinlock_lock(&hv->vf_lock); 542 vf_dev = hn_get_vf_dev(hv); 543 if (vf_dev && vf_dev->dev_ops->xstats_reset) 544 vf_dev->dev_ops->xstats_reset(vf_dev); 545 rte_spinlock_unlock(&hv->vf_lock); 546 } 547