drivers/bus/pci/linux/pci_vfio.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <fcntl.h>
   7 #include <linux/pci_regs.h>
   8 #include <sys/eventfd.h>
   9 #include <sys/socket.h>
  10 #include <sys/ioctl.h>
  11 #include <sys/mman.h>
  12 #include <stdbool.h>
  13
  14 #include <rte_log.h>
  15 #include <rte_pci.h>
  16 #include <rte_bus_pci.h>
  17 #include <rte_eal_memconfig.h>
  18 #include <rte_malloc.h>
  19 #include <rte_vfio.h>
  20
  21 #include "eal_filesystem.h"
  22
  23 #include "pci_init.h"
  24 #include "private.h"
  25
  26 /**
  27  * @file
  28  * PCI probing under linux (VFIO version)
  29  *
  30  * This code tries to determine if the PCI device is bound to VFIO driver,
  31  * and initialize it (map BARs, set up interrupts) if that's the case.
  32  *
  33  * This file is only compiled if CONFIG_RTE_EAL_VFIO is set to "y".
  34  */
  35
  36 #ifdef VFIO_PRESENT
  37
  38 #define PAGE_SIZE   (sysconf(_SC_PAGESIZE))
  39 #define PAGE_MASK   (~(PAGE_SIZE - 1))
  40
  41 static struct rte_tailq_elem rte_vfio_tailq = {
  42         .name = "VFIO_RESOURCE_LIST",
  43 };
  44 EAL_REGISTER_TAILQ(rte_vfio_tailq)
  45
  46 int
  47 pci_vfio_read_config(const struct rte_intr_handle *intr_handle,
  48                     void *buf, size_t len, off_t offs)
  49 {
  50         return pread64(intr_handle->vfio_dev_fd, buf, len,
  51                VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) + offs);
  52 }
  53
  54 int
  55 pci_vfio_write_config(const struct rte_intr_handle *intr_handle,
  56                     const void *buf, size_t len, off_t offs)
  57 {
  58         return pwrite64(intr_handle->vfio_dev_fd, buf, len,
  59                VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) + offs);
  60 }
  61
  62 /* get PCI BAR number where MSI-X interrupts are */
  63 static int
  64 pci_vfio_get_msix_bar(int fd, struct pci_msix_table *msix_table)
  65 {
  66         int ret;
  67         uint32_t reg;
  68         uint16_t flags;
  69         uint8_t cap_id, cap_offset;
  70
  71         /* read PCI capability pointer from config space */
  72         ret = pread64(fd, &reg, sizeof(reg),
  73                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
  74                         PCI_CAPABILITY_LIST);
  75         if (ret != sizeof(reg)) {
  76                 RTE_LOG(ERR, EAL, "Cannot read capability pointer from PCI "
  77                                 "config space!\n");
  78                 return -1;
  79         }
  80
  81         /* we need first byte */
  82         cap_offset = reg & 0xFF;
  83
  84         while (cap_offset) {
  85
  86                 /* read PCI capability ID */
  87                 ret = pread64(fd, &reg, sizeof(reg),
  88                                 VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
  89                                 cap_offset);
  90                 if (ret != sizeof(reg)) {
  91                         RTE_LOG(ERR, EAL, "Cannot read capability ID from PCI "
  92                                         "config space!\n");
  93                         return -1;
  94                 }
  95
  96                 /* we need first byte */
  97                 cap_id = reg & 0xFF;
  98
  99                 /* if we haven't reached MSI-X, check next capability */
 100                 if (cap_id != PCI_CAP_ID_MSIX) {
 101                         ret = pread64(fd, &reg, sizeof(reg),
 102                                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 103                                         cap_offset);
 104                         if (ret != sizeof(reg)) {
 105                                 RTE_LOG(ERR, EAL, "Cannot read capability pointer from PCI "
 106                                                 "config space!\n");
 107                                 return -1;
 108                         }
 109
 110                         /* we need second byte */
 111                         cap_offset = (reg & 0xFF00) >> 8;
 112
 113                         continue;
 114                 }
 115                 /* else, read table offset */
 116                 else {
 117                         /* table offset resides in the next 4 bytes */
 118                         ret = pread64(fd, &reg, sizeof(reg),
 119                                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 120                                         cap_offset + 4);
 121                         if (ret != sizeof(reg)) {
 122                                 RTE_LOG(ERR, EAL, "Cannot read table offset from PCI config "
 123                                                 "space!\n");
 124                                 return -1;
 125                         }
 126
 127                         ret = pread64(fd, &flags, sizeof(flags),
 128                                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 129                                         cap_offset + 2);
 130                         if (ret != sizeof(flags)) {
 131                                 RTE_LOG(ERR, EAL, "Cannot read table flags from PCI config "
 132                                                 "space!\n");
 133                                 return -1;
 134                         }
 135
 136                         msix_table->bar_index = reg & RTE_PCI_MSIX_TABLE_BIR;
 137                         msix_table->offset = reg & RTE_PCI_MSIX_TABLE_OFFSET;
 138                         msix_table->size =
 139                                 16 * (1 + (flags & RTE_PCI_MSIX_FLAGS_QSIZE));
 140
 141                         return 0;
 142                 }
 143         }
 144         return 0;
 145 }
 146
 147 /* set PCI bus mastering */
 148 static int
 149 pci_vfio_set_bus_master(int dev_fd, bool op)
 150 {
 151         uint16_t reg;
 152         int ret;
 153
 154         ret = pread64(dev_fd, &reg, sizeof(reg),
 155                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 156                         PCI_COMMAND);
 157         if (ret != sizeof(reg)) {
 158                 RTE_LOG(ERR, EAL, "Cannot read command from PCI config space!\n");
 159                 return -1;
 160         }
 161
 162         if (op)
 163                 /* set the master bit */
 164                 reg |= PCI_COMMAND_MASTER;
 165         else
 166                 reg &= ~(PCI_COMMAND_MASTER);
 167
 168         ret = pwrite64(dev_fd, &reg, sizeof(reg),
 169                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 170                         PCI_COMMAND);
 171
 172         if (ret != sizeof(reg)) {
 173                 RTE_LOG(ERR, EAL, "Cannot write command to PCI config space!\n");
 174                 return -1;
 175         }
 176
 177         return 0;
 178 }
 179
 180 /* set up interrupt support (but not enable interrupts) */
 181 static int
 182 pci_vfio_setup_interrupts(struct rte_pci_device *dev, int vfio_dev_fd)
 183 {
 184         int i, ret, intr_idx;
 185         enum rte_intr_mode intr_mode;
 186
 187         /* default to invalid index */
 188         intr_idx = VFIO_PCI_NUM_IRQS;
 189
 190         /* Get default / configured intr_mode */
 191         intr_mode = rte_eal_vfio_intr_mode();
 192
 193         /* get interrupt type from internal config (MSI-X by default, can be
 194          * overridden from the command line
 195          */
 196         switch (intr_mode) {
 197         case RTE_INTR_MODE_MSIX:
 198                 intr_idx = VFIO_PCI_MSIX_IRQ_INDEX;
 199                 break;
 200         case RTE_INTR_MODE_MSI:
 201                 intr_idx = VFIO_PCI_MSI_IRQ_INDEX;
 202                 break;
 203         case RTE_INTR_MODE_LEGACY:
 204                 intr_idx = VFIO_PCI_INTX_IRQ_INDEX;
 205                 break;
 206         /* don't do anything if we want to automatically determine interrupt type */
 207         case RTE_INTR_MODE_NONE:
 208                 break;
 209         default:
 210                 RTE_LOG(ERR, EAL, "  unknown default interrupt type!\n");
 211                 return -1;
 212         }
 213
 214         /* start from MSI-X interrupt type */
 215         for (i = VFIO_PCI_MSIX_IRQ_INDEX; i >= 0; i--) {
 216                 struct vfio_irq_info irq = { .argsz = sizeof(irq) };
 217                 int fd = -1;
 218
 219                 /* skip interrupt modes we don't want */
 220                 if (intr_mode != RTE_INTR_MODE_NONE &&
 221                                 i != intr_idx)
 222                         continue;
 223
 224                 irq.index = i;
 225
 226                 ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_IRQ_INFO, &irq);
 227                 if (ret < 0) {
 228                         RTE_LOG(ERR, EAL, "  cannot get IRQ info, "
 229                                         "error %i (%s)\n", errno, strerror(errno));
 230                         return -1;
 231                 }
 232
 233                 /* if this vector cannot be used with eventfd, fail if we explicitly
 234                  * specified interrupt type, otherwise continue */
 235                 if ((irq.flags & VFIO_IRQ_INFO_EVENTFD) == 0) {
 236                         if (intr_mode != RTE_INTR_MODE_NONE) {
 237                                 RTE_LOG(ERR, EAL,
 238                                                 "  interrupt vector does not support eventfd!\n");
 239                                 return -1;
 240                         } else
 241                                 continue;
 242                 }
 243
 244                 /* set up an eventfd for interrupts */
 245                 fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
 246                 if (fd < 0) {
 247                         RTE_LOG(ERR, EAL, "  cannot set up eventfd, "
 248                                         "error %i (%s)\n", errno, strerror(errno));
 249                         return -1;
 250                 }
 251
 252                 dev->intr_handle.fd = fd;
 253                 dev->intr_handle.vfio_dev_fd = vfio_dev_fd;
 254
 255                 switch (i) {
 256                 case VFIO_PCI_MSIX_IRQ_INDEX:
 257                         intr_mode = RTE_INTR_MODE_MSIX;
 258                         dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_MSIX;
 259                         break;
 260                 case VFIO_PCI_MSI_IRQ_INDEX:
 261                         intr_mode = RTE_INTR_MODE_MSI;
 262                         dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_MSI;
 263                         break;
 264                 case VFIO_PCI_INTX_IRQ_INDEX:
 265                         intr_mode = RTE_INTR_MODE_LEGACY;
 266                         dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_LEGACY;
 267                         break;
 268                 default:
 269                         RTE_LOG(ERR, EAL, "  unknown interrupt type!\n");
 270                         return -1;
 271                 }
 272
 273                 return 0;
 274         }
 275
 276         /* if we're here, we haven't found a suitable interrupt vector */
 277         return -1;
 278 }
 279
 280 static int
 281 pci_vfio_is_ioport_bar(int vfio_dev_fd, int bar_index)
 282 {
 283         uint32_t ioport_bar;
 284         int ret;
 285
 286         ret = pread64(vfio_dev_fd, &ioport_bar, sizeof(ioport_bar),
 287                           VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX)
 288                           + PCI_BASE_ADDRESS_0 + bar_index*4);
 289         if (ret != sizeof(ioport_bar)) {
 290                 RTE_LOG(ERR, EAL, "Cannot read command (%x) from config space!\n",
 291                         PCI_BASE_ADDRESS_0 + bar_index*4);
 292                 return -1;
 293         }
 294
 295         return (ioport_bar & PCI_BASE_ADDRESS_SPACE_IO) != 0;
 296 }
 297
 298 static int
 299 pci_rte_vfio_setup_device(struct rte_pci_device *dev, int vfio_dev_fd)
 300 {
 301         if (pci_vfio_setup_interrupts(dev, vfio_dev_fd) != 0) {
 302                 RTE_LOG(ERR, EAL, "Error setting up interrupts!\n");
 303                 return -1;
 304         }
 305
 306         /* set bus mastering for the device */
 307         if (pci_vfio_set_bus_master(vfio_dev_fd, true)) {
 308                 RTE_LOG(ERR, EAL, "Cannot set up bus mastering!\n");
 309                 return -1;
 310         }
 311
 312         /*
 313          * Reset the device. If the device is not capable of resetting,
 314          * then it updates errno as EINVAL.
 315          */
 316         if (ioctl(vfio_dev_fd, VFIO_DEVICE_RESET) && errno != EINVAL) {
 317                 RTE_LOG(ERR, EAL, "Unable to reset device! Error: %d (%s)\n",
 318                                 errno, strerror(errno));
 319                 return -1;
 320         }
 321
 322         return 0;
 323 }
 324
 325 static int
 326 pci_vfio_mmap_bar(int vfio_dev_fd, struct mapped_pci_resource *vfio_res,
 327                 int bar_index, int additional_flags)
 328 {
 329         struct memreg {
 330                 unsigned long offset, size;
 331         } memreg[2] = {};
 332         void *bar_addr;
 333         struct pci_msix_table *msix_table = &vfio_res->msix_table;
 334         struct pci_map *bar = &vfio_res->maps[bar_index];
 335         bool again = false;
 336
 337         if (bar->size == 0)
 338                 /* Skip this BAR */
 339                 return 0;
 340
 341         /* reserve the address using an inaccessible mapping */
 342         bar_addr = mmap(bar->addr, bar->size, 0, MAP_PRIVATE |
 343                         MAP_ANONYMOUS | additional_flags, -1, 0);
 344         if (bar_addr == MAP_FAILED) {
 345                 RTE_LOG(ERR, EAL,
 346                         "Failed to create inaccessible mapping for BAR%d\n",
 347                         bar_index);
 348                 return -1;
 349         }
 350
 351         memreg[0].offset = bar->offset;
 352         memreg[0].size = bar->size;
 353         do {
 354                 void *map_addr = NULL;
 355                 if (again) {
 356                         /*
 357                          * VFIO did not let us map the MSI-X table,
 358                          * but we can map around it.
 359                          */
 360                         uint32_t table_start = msix_table->offset;
 361                         uint32_t table_end = table_start + msix_table->size;
 362                         table_end = (table_end + ~PAGE_MASK) & PAGE_MASK;
 363                         table_start &= PAGE_MASK;
 364
 365                         if (table_start == 0 && table_end >= bar->size) {
 366                                 /* Cannot map this BAR */
 367                                 RTE_LOG(DEBUG, EAL, "Skipping BAR%d\n",
 368                                                 bar_index);
 369                                 munmap(bar_addr, bar->size);
 370                                 bar->size = 0;
 371                                 bar->addr = 0;
 372                                 return 0;
 373                         }
 374
 375                         memreg[0].offset = bar->offset;
 376                         memreg[0].size = table_start;
 377                         memreg[1].offset = bar->offset + table_end;
 378                         memreg[1].size = bar->size - table_end;
 379
 380                         RTE_LOG(DEBUG, EAL,
 381                                 "Trying to map BAR%d that contains the MSI-X "
 382                                 "table. Trying offsets: "
 383                                 "0x%04lx:0x%04lx, 0x%04lx:0x%04lx\n", bar_index,
 384                                 memreg[0].offset, memreg[0].size,
 385                                 memreg[1].offset, memreg[1].size);
 386                 }
 387
 388                 if (memreg[0].size) {
 389                         /* actual map of first part */
 390                         map_addr = pci_map_resource(bar_addr, vfio_dev_fd,
 391                                                         memreg[0].offset,
 392                                                         memreg[0].size,
 393                                                         MAP_FIXED);
 394                 }
 395
 396                 if (map_addr == MAP_FAILED &&
 397                         msix_table->bar_index == bar_index && !again) {
 398                         again = true;
 399                         continue;
 400                 }
 401
 402                 /* if there's a second part, try to map it */
 403                 if (map_addr != MAP_FAILED
 404                         && memreg[1].offset && memreg[1].size) {
 405                         void *second_addr = RTE_PTR_ADD(bar_addr,
 406                                                         memreg[1].offset -
 407                                                         (uintptr_t)bar->offset);
 408                         map_addr = pci_map_resource(second_addr,
 409                                                         vfio_dev_fd,
 410                                                         memreg[1].offset,
 411                                                         memreg[1].size,
 412                                                         MAP_FIXED);
 413                 }
 414
 415                 if (map_addr == MAP_FAILED || !map_addr) {
 416                         munmap(bar_addr, bar->size);
 417                         bar_addr = MAP_FAILED;
 418                         RTE_LOG(ERR, EAL, "Failed to map pci BAR%d\n",
 419                                         bar_index);
 420                         return -1;
 421                 }
 422                 break;
 423         } while (again);
 424
 425         bar->addr = bar_addr;
 426         return 0;
 427 }
 428
 429 static int
 430 pci_vfio_map_resource_primary(struct rte_pci_device *dev)
 431 {
 432         struct vfio_device_info device_info = { .argsz = sizeof(device_info) };
 433         char pci_addr[PATH_MAX] = {0};
 434         int vfio_dev_fd;
 435         struct rte_pci_addr *loc = &dev->addr;
 436         int i, ret;
 437         struct mapped_pci_resource *vfio_res = NULL;
 438         struct mapped_pci_res_list *vfio_res_list =
 439                 RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
 440
 441         struct pci_map *maps;
 442
 443         dev->intr_handle.fd = -1;
 444
 445         /* store PCI address string */
 446         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
 447                         loc->domain, loc->bus, loc->devid, loc->function);
 448
 449         ret = rte_vfio_setup_device(rte_pci_get_sysfs_path(), pci_addr,
 450                                         &vfio_dev_fd, &device_info);
 451         if (ret)
 452                 return ret;
 453
 454         /* allocate vfio_res and get region info */
 455         vfio_res = rte_zmalloc("VFIO_RES", sizeof(*vfio_res), 0);
 456         if (vfio_res == NULL) {
 457                 RTE_LOG(ERR, EAL,
 458                         "%s(): cannot store uio mmap details\n", __func__);
 459                 goto err_vfio_dev_fd;
 460         }
 461         memcpy(&vfio_res->pci_addr, &dev->addr, sizeof(vfio_res->pci_addr));
 462
 463         /* get number of registers (up to BAR5) */
 464         vfio_res->nb_maps = RTE_MIN((int) device_info.num_regions,
 465                         VFIO_PCI_BAR5_REGION_INDEX + 1);
 466
 467         /* map BARs */
 468         maps = vfio_res->maps;
 469
 470         vfio_res->msix_table.bar_index = -1;
 471         /* get MSI-X BAR, if any (we have to know where it is because we can't
 472          * easily mmap it when using VFIO)
 473          */
 474         ret = pci_vfio_get_msix_bar(vfio_dev_fd, &vfio_res->msix_table);
 475         if (ret < 0) {
 476                 RTE_LOG(ERR, EAL, "  %s cannot get MSI-X BAR number!\n",
 477                                 pci_addr);
 478                 goto err_vfio_dev_fd;
 479         }
 480
 481         for (i = 0; i < (int) vfio_res->nb_maps; i++) {
 482                 struct vfio_region_info reg = { .argsz = sizeof(reg) };
 483                 void *bar_addr;
 484
 485                 reg.index = i;
 486
 487                 ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_REGION_INFO, &reg);
 488                 if (ret) {
 489                         RTE_LOG(ERR, EAL, "  %s cannot get device region info "
 490                                         "error %i (%s)\n", pci_addr, errno, strerror(errno));
 491                         goto err_vfio_res;
 492                 }
 493
 494                 /* chk for io port region */
 495                 ret = pci_vfio_is_ioport_bar(vfio_dev_fd, i);
 496                 if (ret < 0)
 497                         goto err_vfio_res;
 498                 else if (ret) {
 499                         RTE_LOG(INFO, EAL, "Ignore mapping IO port bar(%d)\n",
 500                                         i);
 501                         continue;
 502                 }
 503
 504                 /* skip non-mmapable BARs */
 505                 if ((reg.flags & VFIO_REGION_INFO_FLAG_MMAP) == 0)
 506                         continue;
 507
 508                 /* try mapping somewhere close to the end of hugepages */
 509                 if (pci_map_addr == NULL)
 510                         pci_map_addr = pci_find_max_end_va();
 511
 512                 bar_addr = pci_map_addr;
 513                 pci_map_addr = RTE_PTR_ADD(bar_addr, (size_t) reg.size);
 514
 515                 maps[i].addr = bar_addr;
 516                 maps[i].offset = reg.offset;
 517                 maps[i].size = reg.size;
 518                 maps[i].path = NULL; /* vfio doesn't have per-resource paths */
 519
 520                 ret = pci_vfio_mmap_bar(vfio_dev_fd, vfio_res, i, 0);
 521                 if (ret < 0) {
 522                         RTE_LOG(ERR, EAL, "  %s mapping BAR%i failed: %s\n",
 523                                         pci_addr, i, strerror(errno));
 524                         goto err_vfio_res;
 525                 }
 526
 527                 dev->mem_resource[i].addr = maps[i].addr;
 528         }
 529
 530         if (pci_rte_vfio_setup_device(dev, vfio_dev_fd) < 0) {
 531                 RTE_LOG(ERR, EAL, "  %s setup device failed\n", pci_addr);
 532                 goto err_vfio_res;
 533         }
 534
 535         TAILQ_INSERT_TAIL(vfio_res_list, vfio_res, next);
 536
 537         return 0;
 538 err_vfio_res:
 539         rte_free(vfio_res);
 540 err_vfio_dev_fd:
 541         close(vfio_dev_fd);
 542         return -1;
 543 }
 544
 545 static int
 546 pci_vfio_map_resource_secondary(struct rte_pci_device *dev)
 547 {
 548         struct vfio_device_info device_info = { .argsz = sizeof(device_info) };
 549         char pci_addr[PATH_MAX] = {0};
 550         int vfio_dev_fd;
 551         struct rte_pci_addr *loc = &dev->addr;
 552         int i, ret;
 553         struct mapped_pci_resource *vfio_res = NULL;
 554         struct mapped_pci_res_list *vfio_res_list =
 555                 RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
 556
 557         struct pci_map *maps;
 558
 559         dev->intr_handle.fd = -1;
 560
 561         /* store PCI address string */
 562         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
 563                         loc->domain, loc->bus, loc->devid, loc->function);
 564
 565         ret = rte_vfio_setup_device(rte_pci_get_sysfs_path(), pci_addr,
 566                                         &vfio_dev_fd, &device_info);
 567         if (ret)
 568                 return ret;
 569
 570         /* if we're in a secondary process, just find our tailq entry */
 571         TAILQ_FOREACH(vfio_res, vfio_res_list, next) {
 572                 if (rte_pci_addr_cmp(&vfio_res->pci_addr,
 573                                                  &dev->addr))
 574                         continue;
 575                 break;
 576         }
 577         /* if we haven't found our tailq entry, something's wrong */
 578         if (vfio_res == NULL) {
 579                 RTE_LOG(ERR, EAL, "  %s cannot find TAILQ entry for PCI device!\n",
 580                                 pci_addr);
 581                 goto err_vfio_dev_fd;
 582         }
 583
 584         /* map BARs */
 585         maps = vfio_res->maps;
 586
 587         for (i = 0; i < (int) vfio_res->nb_maps; i++) {
 588                 ret = pci_vfio_mmap_bar(vfio_dev_fd, vfio_res, i, MAP_FIXED);
 589                 if (ret < 0) {
 590                         RTE_LOG(ERR, EAL, "  %s mapping BAR%i failed: %s\n",
 591                                         pci_addr, i, strerror(errno));
 592                         goto err_vfio_dev_fd;
 593                 }
 594
 595                 dev->mem_resource[i].addr = maps[i].addr;
 596         }
 597
 598         /* we need save vfio_dev_fd, so it can be used during release */
 599         dev->intr_handle.vfio_dev_fd = vfio_dev_fd;
 600
 601         return 0;
 602 err_vfio_dev_fd:
 603         close(vfio_dev_fd);
 604         return -1;
 605 }
 606
 607 /*
 608  * map the PCI resources of a PCI device in virtual memory (VFIO version).
 609  * primary and secondary processes follow almost exactly the same path
 610  */
 611 int
 612 pci_vfio_map_resource(struct rte_pci_device *dev)
 613 {
 614         if (rte_eal_process_type() == RTE_PROC_PRIMARY)
 615                 return pci_vfio_map_resource_primary(dev);
 616         else
 617                 return pci_vfio_map_resource_secondary(dev);
 618 }
 619
 620 static struct mapped_pci_resource *
 621 find_and_unmap_vfio_resource(struct mapped_pci_res_list *vfio_res_list,
 622                         struct rte_pci_device *dev,
 623                         const char *pci_addr)
 624 {
 625         struct mapped_pci_resource *vfio_res = NULL;
 626         struct pci_map *maps;
 627         int i;
 628
 629         /* Get vfio_res */
 630         TAILQ_FOREACH(vfio_res, vfio_res_list, next) {
 631                 if (rte_pci_addr_cmp(&vfio_res->pci_addr, &dev->addr))
 632                         continue;
 633                 break;
 634         }
 635
 636         if  (vfio_res == NULL)
 637                 return vfio_res;
 638
 639         RTE_LOG(INFO, EAL, "Releasing pci mapped resource for %s\n",
 640                 pci_addr);
 641
 642         maps = vfio_res->maps;
 643         for (i = 0; i < (int) vfio_res->nb_maps; i++) {
 644
 645                 /*
 646                  * We do not need to be aware of MSI-X table BAR mappings as
 647                  * when mapping. Just using current maps array is enough
 648                  */
 649                 if (maps[i].addr) {
 650                         RTE_LOG(INFO, EAL, "Calling pci_unmap_resource for %s at %p\n",
 651                                 pci_addr, maps[i].addr);
 652                         pci_unmap_resource(maps[i].addr, maps[i].size);
 653                 }
 654         }
 655
 656         return vfio_res;
 657 }
 658
 659 static int
 660 pci_vfio_unmap_resource_primary(struct rte_pci_device *dev)
 661 {
 662         char pci_addr[PATH_MAX] = {0};
 663         struct rte_pci_addr *loc = &dev->addr;
 664         struct mapped_pci_resource *vfio_res = NULL;
 665         struct mapped_pci_res_list *vfio_res_list;
 666         int ret;
 667
 668         /* store PCI address string */
 669         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
 670                         loc->domain, loc->bus, loc->devid, loc->function);
 671
 672         if (close(dev->intr_handle.fd) < 0) {
 673                 RTE_LOG(INFO, EAL, "Error when closing eventfd file descriptor for %s\n",
 674                         pci_addr);
 675                 return -1;
 676         }
 677
 678         if (pci_vfio_set_bus_master(dev->intr_handle.vfio_dev_fd, false)) {
 679                 RTE_LOG(ERR, EAL, "  %s cannot unset bus mastering for PCI device!\n",
 680                                 pci_addr);
 681                 return -1;
 682         }
 683
 684         ret = rte_vfio_release_device(rte_pci_get_sysfs_path(), pci_addr,
 685                                   dev->intr_handle.vfio_dev_fd);
 686         if (ret < 0) {
 687                 RTE_LOG(ERR, EAL,
 688                         "%s(): cannot release device\n", __func__);
 689                 return ret;
 690         }
 691
 692         vfio_res_list =
 693                 RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
 694         vfio_res = find_and_unmap_vfio_resource(vfio_res_list, dev, pci_addr);
 695
 696         /* if we haven't found our tailq entry, something's wrong */
 697         if (vfio_res == NULL) {
 698                 RTE_LOG(ERR, EAL, "  %s cannot find TAILQ entry for PCI device!\n",
 699                                 pci_addr);
 700                 return -1;
 701         }
 702
 703         TAILQ_REMOVE(vfio_res_list, vfio_res, next);
 704
 705         return 0;
 706 }
 707
 708 static int
 709 pci_vfio_unmap_resource_secondary(struct rte_pci_device *dev)
 710 {
 711         char pci_addr[PATH_MAX] = {0};
 712         struct rte_pci_addr *loc = &dev->addr;
 713         struct mapped_pci_resource *vfio_res = NULL;
 714         struct mapped_pci_res_list *vfio_res_list;
 715         int ret;
 716
 717         /* store PCI address string */
 718         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
 719                         loc->domain, loc->bus, loc->devid, loc->function);
 720
 721         ret = rte_vfio_release_device(rte_pci_get_sysfs_path(), pci_addr,
 722                                   dev->intr_handle.vfio_dev_fd);
 723         if (ret < 0) {
 724                 RTE_LOG(ERR, EAL,
 725                         "%s(): cannot release device\n", __func__);
 726                 return ret;
 727         }
 728
 729         vfio_res_list =
 730                 RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
 731         vfio_res = find_and_unmap_vfio_resource(vfio_res_list, dev, pci_addr);
 732
 733         /* if we haven't found our tailq entry, something's wrong */
 734         if (vfio_res == NULL) {
 735                 RTE_LOG(ERR, EAL, "  %s cannot find TAILQ entry for PCI device!\n",
 736                                 pci_addr);
 737                 return -1;
 738         }
 739
 740         return 0;
 741 }
 742
 743 int
 744 pci_vfio_unmap_resource(struct rte_pci_device *dev)
 745 {
 746         if (rte_eal_process_type() == RTE_PROC_PRIMARY)
 747                 return pci_vfio_unmap_resource_primary(dev);
 748         else
 749                 return pci_vfio_unmap_resource_secondary(dev);
 750 }
 751
 752 int
 753 pci_vfio_ioport_map(struct rte_pci_device *dev, int bar,
 754                     struct rte_pci_ioport *p)
 755 {
 756         if (bar < VFIO_PCI_BAR0_REGION_INDEX ||
 757             bar > VFIO_PCI_BAR5_REGION_INDEX) {
 758                 RTE_LOG(ERR, EAL, "invalid bar (%d)!\n", bar);
 759                 return -1;
 760         }
 761
 762         p->dev = dev;
 763         p->base = VFIO_GET_REGION_ADDR(bar);
 764         return 0;
 765 }
 766
 767 void
 768 pci_vfio_ioport_read(struct rte_pci_ioport *p,
 769                      void *data, size_t len, off_t offset)
 770 {
 771         const struct rte_intr_handle *intr_handle = &p->dev->intr_handle;
 772
 773         if (pread64(intr_handle->vfio_dev_fd, data,
 774                     len, p->base + offset) <= 0)
 775                 RTE_LOG(ERR, EAL,
 776                         "Can't read from PCI bar (%" PRIu64 ") : offset (%x)\n",
 777                         VFIO_GET_REGION_IDX(p->base), (int)offset);
 778 }
 779
 780 void
 781 pci_vfio_ioport_write(struct rte_pci_ioport *p,
 782                       const void *data, size_t len, off_t offset)
 783 {
 784         const struct rte_intr_handle *intr_handle = &p->dev->intr_handle;
 785
 786         if (pwrite64(intr_handle->vfio_dev_fd, data,
 787                      len, p->base + offset) <= 0)
 788                 RTE_LOG(ERR, EAL,
 789                         "Can't write to PCI bar (%" PRIu64 ") : offset (%x)\n",
 790                         VFIO_GET_REGION_IDX(p->base), (int)offset);
 791 }
 792
 793 int
 794 pci_vfio_ioport_unmap(struct rte_pci_ioport *p)
 795 {
 796         RTE_SET_USED(p);
 797         return -1;
 798 }
 799
 800 int
 801 pci_vfio_is_enabled(void)
 802 {
 803         return rte_vfio_is_enabled("vfio_pci");
 804 }
 805 #endif