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_paging.h>
  18 #include <rte_malloc.h>
  19 #include <rte_vfio.h>
  20 #include <rte_eal.h>
  21 #include <rte_bus.h>
  22 #include <rte_spinlock.h>
  23 #include <rte_tailq.h>
  24
  25 #include "eal_filesystem.h"
  26
  27 #include "pci_init.h"
  28 #include "private.h"
  29
  30 /**
  31  * @file
  32  * PCI probing under linux (VFIO version)
  33  *
  34  * This code tries to determine if the PCI device is bound to VFIO driver,
  35  * and initialize it (map BARs, set up interrupts) if that's the case.
  36  *
  37  */
  38
  39 #ifdef VFIO_PRESENT
  40
  41 #ifndef PAGE_SIZE
  42 #define PAGE_SIZE   (sysconf(_SC_PAGESIZE))
  43 #endif
  44 #define PAGE_MASK   (~(PAGE_SIZE - 1))
  45
  46 static struct rte_tailq_elem rte_vfio_tailq = {
  47         .name = "VFIO_RESOURCE_LIST",
  48 };
  49 EAL_REGISTER_TAILQ(rte_vfio_tailq)
  50
  51 int
  52 pci_vfio_read_config(const struct rte_intr_handle *intr_handle,
  53                     void *buf, size_t len, off_t offs)
  54 {
  55         return pread64(intr_handle->vfio_dev_fd, buf, len,
  56                VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) + offs);
  57 }
  58
  59 int
  60 pci_vfio_write_config(const struct rte_intr_handle *intr_handle,
  61                     const void *buf, size_t len, off_t offs)
  62 {
  63         return pwrite64(intr_handle->vfio_dev_fd, buf, len,
  64                VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) + offs);
  65 }
  66
  67 /* get PCI BAR number where MSI-X interrupts are */
  68 static int
  69 pci_vfio_get_msix_bar(int fd, struct pci_msix_table *msix_table)
  70 {
  71         int ret;
  72         uint32_t reg;
  73         uint16_t flags;
  74         uint8_t cap_id, cap_offset;
  75
  76         /* read PCI capability pointer from config space */
  77         ret = pread64(fd, &reg, sizeof(reg),
  78                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
  79                         PCI_CAPABILITY_LIST);
  80         if (ret != sizeof(reg)) {
  81                 RTE_LOG(ERR, EAL, "Cannot read capability pointer from PCI "
  82                                 "config space!\n");
  83                 return -1;
  84         }
  85
  86         /* we need first byte */
  87         cap_offset = reg & 0xFF;
  88
  89         while (cap_offset) {
  90
  91                 /* read PCI capability ID */
  92                 ret = pread64(fd, &reg, sizeof(reg),
  93                                 VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
  94                                 cap_offset);
  95                 if (ret != sizeof(reg)) {
  96                         RTE_LOG(ERR, EAL, "Cannot read capability ID from PCI "
  97                                         "config space!\n");
  98                         return -1;
  99                 }
 100
 101                 /* we need first byte */
 102                 cap_id = reg & 0xFF;
 103
 104                 /* if we haven't reached MSI-X, check next capability */
 105                 if (cap_id != PCI_CAP_ID_MSIX) {
 106                         ret = pread64(fd, &reg, sizeof(reg),
 107                                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 108                                         cap_offset);
 109                         if (ret != sizeof(reg)) {
 110                                 RTE_LOG(ERR, EAL, "Cannot read capability pointer from PCI "
 111                                                 "config space!\n");
 112                                 return -1;
 113                         }
 114
 115                         /* we need second byte */
 116                         cap_offset = (reg & 0xFF00) >> 8;
 117
 118                         continue;
 119                 }
 120                 /* else, read table offset */
 121                 else {
 122                         /* table offset resides in the next 4 bytes */
 123                         ret = pread64(fd, &reg, sizeof(reg),
 124                                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 125                                         cap_offset + 4);
 126                         if (ret != sizeof(reg)) {
 127                                 RTE_LOG(ERR, EAL, "Cannot read table offset from PCI config "
 128                                                 "space!\n");
 129                                 return -1;
 130                         }
 131
 132                         ret = pread64(fd, &flags, sizeof(flags),
 133                                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 134                                         cap_offset + 2);
 135                         if (ret != sizeof(flags)) {
 136                                 RTE_LOG(ERR, EAL, "Cannot read table flags from PCI config "
 137                                                 "space!\n");
 138                                 return -1;
 139                         }
 140
 141                         msix_table->bar_index = reg & RTE_PCI_MSIX_TABLE_BIR;
 142                         msix_table->offset = reg & RTE_PCI_MSIX_TABLE_OFFSET;
 143                         msix_table->size =
 144                                 16 * (1 + (flags & RTE_PCI_MSIX_FLAGS_QSIZE));
 145
 146                         return 0;
 147                 }
 148         }
 149         return 0;
 150 }
 151
 152 /* enable PCI bus memory space */
 153 static int
 154 pci_vfio_enable_bus_memory(int dev_fd)
 155 {
 156         uint16_t cmd;
 157         int ret;
 158
 159         ret = pread64(dev_fd, &cmd, sizeof(cmd),
 160                       VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 161                       PCI_COMMAND);
 162
 163         if (ret != sizeof(cmd)) {
 164                 RTE_LOG(ERR, EAL, "Cannot read command from PCI config space!\n");
 165                 return -1;
 166         }
 167
 168         if (cmd & PCI_COMMAND_MEMORY)
 169                 return 0;
 170
 171         cmd |= PCI_COMMAND_MEMORY;
 172         ret = pwrite64(dev_fd, &cmd, sizeof(cmd),
 173                        VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 174                        PCI_COMMAND);
 175
 176         if (ret != sizeof(cmd)) {
 177                 RTE_LOG(ERR, EAL, "Cannot write command to PCI config space!\n");
 178                 return -1;
 179         }
 180
 181         return 0;
 182 }
 183
 184 /* set PCI bus mastering */
 185 static int
 186 pci_vfio_set_bus_master(int dev_fd, bool op)
 187 {
 188         uint16_t reg;
 189         int ret;
 190
 191         ret = pread64(dev_fd, &reg, sizeof(reg),
 192                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 193                         PCI_COMMAND);
 194         if (ret != sizeof(reg)) {
 195                 RTE_LOG(ERR, EAL, "Cannot read command from PCI config space!\n");
 196                 return -1;
 197         }
 198
 199         if (op)
 200                 /* set the master bit */
 201                 reg |= PCI_COMMAND_MASTER;
 202         else
 203                 reg &= ~(PCI_COMMAND_MASTER);
 204
 205         ret = pwrite64(dev_fd, &reg, sizeof(reg),
 206                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
 207                         PCI_COMMAND);
 208
 209         if (ret != sizeof(reg)) {
 210                 RTE_LOG(ERR, EAL, "Cannot write command to PCI config space!\n");
 211                 return -1;
 212         }
 213
 214         return 0;
 215 }
 216
 217 /* set up interrupt support (but not enable interrupts) */
 218 static int
 219 pci_vfio_setup_interrupts(struct rte_pci_device *dev, int vfio_dev_fd)
 220 {
 221         int i, ret, intr_idx;
 222         enum rte_intr_mode intr_mode;
 223
 224         /* default to invalid index */
 225         intr_idx = VFIO_PCI_NUM_IRQS;
 226
 227         /* Get default / configured intr_mode */
 228         intr_mode = rte_eal_vfio_intr_mode();
 229
 230         /* get interrupt type from internal config (MSI-X by default, can be
 231          * overridden from the command line
 232          */
 233         switch (intr_mode) {
 234         case RTE_INTR_MODE_MSIX:
 235                 intr_idx = VFIO_PCI_MSIX_IRQ_INDEX;
 236                 break;
 237         case RTE_INTR_MODE_MSI:
 238                 intr_idx = VFIO_PCI_MSI_IRQ_INDEX;
 239                 break;
 240         case RTE_INTR_MODE_LEGACY:
 241                 intr_idx = VFIO_PCI_INTX_IRQ_INDEX;
 242                 break;
 243         /* don't do anything if we want to automatically determine interrupt type */
 244         case RTE_INTR_MODE_NONE:
 245                 break;
 246         default:
 247                 RTE_LOG(ERR, EAL, "  unknown default interrupt type!\n");
 248                 return -1;
 249         }
 250
 251         /* start from MSI-X interrupt type */
 252         for (i = VFIO_PCI_MSIX_IRQ_INDEX; i >= 0; i--) {
 253                 struct vfio_irq_info irq = { .argsz = sizeof(irq) };
 254                 int fd = -1;
 255
 256                 /* skip interrupt modes we don't want */
 257                 if (intr_mode != RTE_INTR_MODE_NONE &&
 258                                 i != intr_idx)
 259                         continue;
 260
 261                 irq.index = i;
 262
 263                 ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_IRQ_INFO, &irq);
 264                 if (ret < 0) {
 265                         RTE_LOG(ERR, EAL, "  cannot get IRQ info, "
 266                                         "error %i (%s)\n", errno, strerror(errno));
 267                         return -1;
 268                 }
 269
 270                 /* if this vector cannot be used with eventfd, fail if we explicitly
 271                  * specified interrupt type, otherwise continue */
 272                 if ((irq.flags & VFIO_IRQ_INFO_EVENTFD) == 0) {
 273                         if (intr_mode != RTE_INTR_MODE_NONE) {
 274                                 RTE_LOG(ERR, EAL,
 275                                                 "  interrupt vector does not support eventfd!\n");
 276                                 return -1;
 277                         } else
 278                                 continue;
 279                 }
 280
 281                 /* set up an eventfd for interrupts */
 282                 fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
 283                 if (fd < 0) {
 284                         RTE_LOG(ERR, EAL, "  cannot set up eventfd, "
 285                                         "error %i (%s)\n", errno, strerror(errno));
 286                         return -1;
 287                 }
 288
 289                 dev->intr_handle.fd = fd;
 290                 dev->intr_handle.vfio_dev_fd = vfio_dev_fd;
 291
 292                 switch (i) {
 293                 case VFIO_PCI_MSIX_IRQ_INDEX:
 294                         intr_mode = RTE_INTR_MODE_MSIX;
 295                         dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_MSIX;
 296                         break;
 297                 case VFIO_PCI_MSI_IRQ_INDEX:
 298                         intr_mode = RTE_INTR_MODE_MSI;
 299                         dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_MSI;
 300                         break;
 301                 case VFIO_PCI_INTX_IRQ_INDEX:
 302                         intr_mode = RTE_INTR_MODE_LEGACY;
 303                         dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_LEGACY;
 304                         break;
 305                 default:
 306                         RTE_LOG(ERR, EAL, "  unknown interrupt type!\n");
 307                         return -1;
 308                 }
 309
 310                 return 0;
 311         }
 312
 313         /* if we're here, we haven't found a suitable interrupt vector */
 314         return -1;
 315 }
 316
 317 #ifdef HAVE_VFIO_DEV_REQ_INTERFACE
 318 /*
 319  * Spinlock for device hot-unplug failure handling.
 320  * If it tries to access bus or device, such as handle sigbus on bus
 321  * or handle memory failure for device, just need to use this lock.
 322  * It could protect the bus and the device to avoid race condition.
 323  */
 324 static rte_spinlock_t failure_handle_lock = RTE_SPINLOCK_INITIALIZER;
 325
 326 static void
 327 pci_vfio_req_handler(void *param)
 328 {
 329         struct rte_bus *bus;
 330         int ret;
 331         struct rte_device *device = (struct rte_device *)param;
 332
 333         rte_spinlock_lock(&failure_handle_lock);
 334         bus = rte_bus_find_by_device(device);
 335         if (bus == NULL) {
 336                 RTE_LOG(ERR, EAL, "Cannot find bus for device (%s)\n",
 337                         device->name);
 338                 goto handle_end;
 339         }
 340
 341         /*
 342          * vfio kernel module request user space to release allocated
 343          * resources before device be deleted in kernel, so it can directly
 344          * call the vfio bus hot-unplug handler to process it.
 345          */
 346         ret = bus->hot_unplug_handler(device);
 347         if (ret)
 348                 RTE_LOG(ERR, EAL,
 349                         "Can not handle hot-unplug for device (%s)\n",
 350                         device->name);
 351 handle_end:
 352         rte_spinlock_unlock(&failure_handle_lock);
 353 }
 354
 355 /* enable notifier (only enable req now) */
 356 static int
 357 pci_vfio_enable_notifier(struct rte_pci_device *dev, int vfio_dev_fd)
 358 {
 359         int ret;
 360         int fd = -1;
 361
 362         /* set up an eventfd for req notifier */
 363         fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
 364         if (fd < 0) {
 365                 RTE_LOG(ERR, EAL, "Cannot set up eventfd, error %i (%s)\n",
 366                         errno, strerror(errno));
 367                 return -1;
 368         }
 369
 370         dev->vfio_req_intr_handle.fd = fd;
 371         dev->vfio_req_intr_handle.type = RTE_INTR_HANDLE_VFIO_REQ;
 372         dev->vfio_req_intr_handle.vfio_dev_fd = vfio_dev_fd;
 373
 374         ret = rte_intr_callback_register(&dev->vfio_req_intr_handle,
 375                                          pci_vfio_req_handler,
 376                                          (void *)&dev->device);
 377         if (ret) {
 378                 RTE_LOG(ERR, EAL, "Fail to register req notifier handler.\n");
 379                 goto error;
 380         }
 381
 382         ret = rte_intr_enable(&dev->vfio_req_intr_handle);
 383         if (ret) {
 384                 RTE_LOG(ERR, EAL, "Fail to enable req notifier.\n");
 385                 ret = rte_intr_callback_unregister(&dev->vfio_req_intr_handle,
 386                                                  pci_vfio_req_handler,
 387                                                  (void *)&dev->device);
 388                 if (ret < 0)
 389                         RTE_LOG(ERR, EAL,
 390                                 "Fail to unregister req notifier handler.\n");
 391                 goto error;
 392         }
 393
 394         return 0;
 395 error:
 396         close(fd);
 397
 398         dev->vfio_req_intr_handle.fd = -1;
 399         dev->vfio_req_intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
 400         dev->vfio_req_intr_handle.vfio_dev_fd = -1;
 401
 402         return -1;
 403 }
 404
 405 /* disable notifier (only disable req now) */
 406 static int
 407 pci_vfio_disable_notifier(struct rte_pci_device *dev)
 408 {
 409         int ret;
 410
 411         ret = rte_intr_disable(&dev->vfio_req_intr_handle);
 412         if (ret) {
 413                 RTE_LOG(ERR, EAL, "fail to disable req notifier.\n");
 414                 return -1;
 415         }
 416
 417         ret = rte_intr_callback_unregister(&dev->vfio_req_intr_handle,
 418                                            pci_vfio_req_handler,
 419                                            (void *)&dev->device);
 420         if (ret < 0) {
 421                 RTE_LOG(ERR, EAL,
 422                          "fail to unregister req notifier handler.\n");
 423                 return -1;
 424         }
 425
 426         close(dev->vfio_req_intr_handle.fd);
 427
 428         dev->vfio_req_intr_handle.fd = -1;
 429         dev->vfio_req_intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
 430         dev->vfio_req_intr_handle.vfio_dev_fd = -1;
 431
 432         return 0;
 433 }
 434 #endif
 435
 436 static int
 437 pci_vfio_is_ioport_bar(int vfio_dev_fd, int bar_index)
 438 {
 439         uint32_t ioport_bar;
 440         int ret;
 441
 442         ret = pread64(vfio_dev_fd, &ioport_bar, sizeof(ioport_bar),
 443                           VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX)
 444                           + PCI_BASE_ADDRESS_0 + bar_index*4);
 445         if (ret != sizeof(ioport_bar)) {
 446                 RTE_LOG(ERR, EAL, "Cannot read command (%x) from config space!\n",
 447                         PCI_BASE_ADDRESS_0 + bar_index*4);
 448                 return -1;
 449         }
 450
 451         return (ioport_bar & PCI_BASE_ADDRESS_SPACE_IO) != 0;
 452 }
 453
 454 static int
 455 pci_rte_vfio_setup_device(struct rte_pci_device *dev, int vfio_dev_fd)
 456 {
 457         if (pci_vfio_setup_interrupts(dev, vfio_dev_fd) != 0) {
 458                 RTE_LOG(ERR, EAL, "Error setting up interrupts!\n");
 459                 return -1;
 460         }
 461
 462         if (pci_vfio_enable_bus_memory(vfio_dev_fd)) {
 463                 RTE_LOG(ERR, EAL, "Cannot enable bus memory!\n");
 464                 return -1;
 465         }
 466
 467         /* set bus mastering for the device */
 468         if (pci_vfio_set_bus_master(vfio_dev_fd, true)) {
 469                 RTE_LOG(ERR, EAL, "Cannot set up bus mastering!\n");
 470                 return -1;
 471         }
 472
 473         /*
 474          * Reset the device. If the device is not capable of resetting,
 475          * then it updates errno as EINVAL.
 476          */
 477         if (ioctl(vfio_dev_fd, VFIO_DEVICE_RESET) && errno != EINVAL) {
 478                 RTE_LOG(ERR, EAL, "Unable to reset device! Error: %d (%s)\n",
 479                                 errno, strerror(errno));
 480                 return -1;
 481         }
 482
 483         return 0;
 484 }
 485
 486 static int
 487 pci_vfio_mmap_bar(int vfio_dev_fd, struct mapped_pci_resource *vfio_res,
 488                 int bar_index, int additional_flags)
 489 {
 490         struct memreg {
 491                 uint64_t offset;
 492                 size_t   size;
 493         } memreg[2] = {};
 494         void *bar_addr;
 495         struct pci_msix_table *msix_table = &vfio_res->msix_table;
 496         struct pci_map *bar = &vfio_res->maps[bar_index];
 497
 498         if (bar->size == 0) {
 499                 RTE_LOG(DEBUG, EAL, "Bar size is 0, skip BAR%d\n", bar_index);
 500                 return 0;
 501         }
 502
 503         if (msix_table->bar_index == bar_index) {
 504                 /*
 505                  * VFIO will not let us map the MSI-X table,
 506                  * but we can map around it.
 507                  */
 508                 uint32_t table_start = msix_table->offset;
 509                 uint32_t table_end = table_start + msix_table->size;
 510                 table_end = RTE_ALIGN(table_end, PAGE_SIZE);
 511                 table_start = RTE_ALIGN_FLOOR(table_start, PAGE_SIZE);
 512
 513                 /* If page-aligned start of MSI-X table is less than the
 514                  * actual MSI-X table start address, reassign to the actual
 515                  * start address.
 516                  */
 517                 if (table_start < msix_table->offset)
 518                         table_start = msix_table->offset;
 519
 520                 if (table_start == 0 && table_end >= bar->size) {
 521                         /* Cannot map this BAR */
 522                         RTE_LOG(DEBUG, EAL, "Skipping BAR%d\n", bar_index);
 523                         bar->size = 0;
 524                         bar->addr = 0;
 525                         return 0;
 526                 }
 527
 528                 memreg[0].offset = bar->offset;
 529                 memreg[0].size = table_start;
 530                 if (bar->size < table_end) {
 531                         /*
 532                          * If MSI-X table end is beyond BAR end, don't attempt
 533                          * to perform second mapping.
 534                          */
 535                         memreg[1].offset = 0;
 536                         memreg[1].size = 0;
 537                 } else {
 538                         memreg[1].offset = bar->offset + table_end;
 539                         memreg[1].size = bar->size - table_end;
 540                 }
 541
 542                 RTE_LOG(DEBUG, EAL,
 543                         "Trying to map BAR%d that contains the MSI-X "
 544                         "table. Trying offsets: "
 545                         "0x%04" PRIx64 ":0x%04zx, 0x%04" PRIx64 ":0x%04zx\n",
 546                         bar_index,
 547                         memreg[0].offset, memreg[0].size,
 548                         memreg[1].offset, memreg[1].size);
 549         } else {
 550                 memreg[0].offset = bar->offset;
 551                 memreg[0].size = bar->size;
 552         }
 553
 554         /* reserve the address using an inaccessible mapping */
 555         bar_addr = mmap(bar->addr, bar->size, 0, MAP_PRIVATE |
 556                         MAP_ANONYMOUS | additional_flags, -1, 0);
 557         if (bar_addr != MAP_FAILED) {
 558                 void *map_addr = NULL;
 559                 if (memreg[0].size) {
 560                         /* actual map of first part */
 561                         map_addr = pci_map_resource(bar_addr, vfio_dev_fd,
 562                                                         memreg[0].offset,
 563                                                         memreg[0].size,
 564                                                         RTE_MAP_FORCE_ADDRESS);
 565                 }
 566
 567                 /* if there's a second part, try to map it */
 568                 if (map_addr != MAP_FAILED
 569                         && memreg[1].offset && memreg[1].size) {
 570                         void *second_addr = RTE_PTR_ADD(bar_addr,
 571                                                 (uintptr_t)(memreg[1].offset -
 572                                                 bar->offset));
 573                         map_addr = pci_map_resource(second_addr,
 574                                                         vfio_dev_fd,
 575                                                         memreg[1].offset,
 576                                                         memreg[1].size,
 577                                                         RTE_MAP_FORCE_ADDRESS);
 578                 }
 579
 580                 if (map_addr == NULL || map_addr == MAP_FAILED) {
 581                         munmap(bar_addr, bar->size);
 582                         bar_addr = MAP_FAILED;
 583                         RTE_LOG(ERR, EAL, "Failed to map pci BAR%d\n",
 584                                         bar_index);
 585                         return -1;
 586                 }
 587         } else {
 588                 RTE_LOG(ERR, EAL,
 589                                 "Failed to create inaccessible mapping for BAR%d\n",
 590                                 bar_index);
 591                 return -1;
 592         }
 593
 594         bar->addr = bar_addr;
 595         return 0;
 596 }
 597
 598 /*
 599  * region info may contain capability headers, so we need to keep reallocating
 600  * the memory until we match allocated memory size with argsz.
 601  */
 602 static int
 603 pci_vfio_get_region_info(int vfio_dev_fd, struct vfio_region_info **info,
 604                 int region)
 605 {
 606         struct vfio_region_info *ri;
 607         size_t argsz = sizeof(*ri);
 608         int ret;
 609
 610         ri = malloc(sizeof(*ri));
 611         if (ri == NULL) {
 612                 RTE_LOG(ERR, EAL, "Cannot allocate memory for region info\n");
 613                 return -1;
 614         }
 615 again:
 616         memset(ri, 0, argsz);
 617         ri->argsz = argsz;
 618         ri->index = region;
 619
 620         ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_REGION_INFO, ri);
 621         if (ret < 0) {
 622                 free(ri);
 623                 return ret;
 624         }
 625         if (ri->argsz != argsz) {
 626                 struct vfio_region_info *tmp;
 627
 628                 argsz = ri->argsz;
 629                 tmp = realloc(ri, argsz);
 630
 631                 if (tmp == NULL) {
 632                         /* realloc failed but the ri is still there */
 633                         free(ri);
 634                         RTE_LOG(ERR, EAL, "Cannot reallocate memory for region info\n");
 635                         return -1;
 636                 }
 637                 ri = tmp;
 638                 goto again;
 639         }
 640         *info = ri;
 641
 642         return 0;
 643 }
 644
 645 static struct vfio_info_cap_header *
 646 pci_vfio_info_cap(struct vfio_region_info *info, int cap)
 647 {
 648         struct vfio_info_cap_header *h;
 649         size_t offset;
 650
 651         if ((info->flags & RTE_VFIO_INFO_FLAG_CAPS) == 0) {
 652                 /* VFIO info does not advertise capabilities */
 653                 return NULL;
 654         }
 655
 656         offset = VFIO_CAP_OFFSET(info);
 657         while (offset != 0) {
 658                 h = RTE_PTR_ADD(info, offset);
 659                 if (h->id == cap)
 660                         return h;
 661                 offset = h->next;
 662         }
 663         return NULL;
 664 }
 665
 666 static int
 667 pci_vfio_msix_is_mappable(int vfio_dev_fd, int msix_region)
 668 {
 669         struct vfio_region_info *info;
 670         int ret;
 671
 672         ret = pci_vfio_get_region_info(vfio_dev_fd, &info, msix_region);
 673         if (ret < 0)
 674                 return -1;
 675
 676         ret = pci_vfio_info_cap(info, RTE_VFIO_CAP_MSIX_MAPPABLE) != NULL;
 677
 678         /* cleanup */
 679         free(info);
 680
 681         return ret;
 682 }
 683
 684
 685 static int
 686 pci_vfio_map_resource_primary(struct rte_pci_device *dev)
 687 {
 688         struct vfio_device_info device_info = { .argsz = sizeof(device_info) };
 689         char pci_addr[PATH_MAX] = {0};
 690         int vfio_dev_fd;
 691         struct rte_pci_addr *loc = &dev->addr;
 692         int i, ret;
 693         struct mapped_pci_resource *vfio_res = NULL;
 694         struct mapped_pci_res_list *vfio_res_list =
 695                 RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
 696
 697         struct pci_map *maps;
 698
 699         dev->intr_handle.fd = -1;
 700 #ifdef HAVE_VFIO_DEV_REQ_INTERFACE
 701         dev->vfio_req_intr_handle.fd = -1;
 702 #endif
 703
 704         /* store PCI address string */
 705         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
 706                         loc->domain, loc->bus, loc->devid, loc->function);
 707
 708         ret = rte_vfio_setup_device(rte_pci_get_sysfs_path(), pci_addr,
 709                                         &vfio_dev_fd, &device_info);
 710         if (ret)
 711                 return ret;
 712
 713         /* allocate vfio_res and get region info */
 714         vfio_res = rte_zmalloc("VFIO_RES", sizeof(*vfio_res), 0);
 715         if (vfio_res == NULL) {
 716                 RTE_LOG(ERR, EAL,
 717                         "%s(): cannot store vfio mmap details\n", __func__);
 718                 goto err_vfio_dev_fd;
 719         }
 720         memcpy(&vfio_res->pci_addr, &dev->addr, sizeof(vfio_res->pci_addr));
 721
 722         /* get number of registers (up to BAR5) */
 723         vfio_res->nb_maps = RTE_MIN((int) device_info.num_regions,
 724                         VFIO_PCI_BAR5_REGION_INDEX + 1);
 725
 726         /* map BARs */
 727         maps = vfio_res->maps;
 728
 729         vfio_res->msix_table.bar_index = -1;
 730         /* get MSI-X BAR, if any (we have to know where it is because we can't
 731          * easily mmap it when using VFIO)
 732          */
 733         ret = pci_vfio_get_msix_bar(vfio_dev_fd, &vfio_res->msix_table);
 734         if (ret < 0) {
 735                 RTE_LOG(ERR, EAL, "  %s cannot get MSI-X BAR number!\n",
 736                                 pci_addr);
 737                 goto err_vfio_res;
 738         }
 739         /* if we found our MSI-X BAR region, check if we can mmap it */
 740         if (vfio_res->msix_table.bar_index != -1) {
 741                 int ret = pci_vfio_msix_is_mappable(vfio_dev_fd,
 742                                 vfio_res->msix_table.bar_index);
 743                 if (ret < 0) {
 744                         RTE_LOG(ERR, EAL, "Couldn't check if MSI-X BAR is mappable\n");
 745                         goto err_vfio_res;
 746                 } else if (ret != 0) {
 747                         /* we can map it, so we don't care where it is */
 748                         RTE_LOG(DEBUG, EAL, "VFIO reports MSI-X BAR as mappable\n");
 749                         vfio_res->msix_table.bar_index = -1;
 750                 }
 751         }
 752
 753         for (i = 0; i < (int) vfio_res->nb_maps; i++) {
 754                 struct vfio_region_info *reg = NULL;
 755                 void *bar_addr;
 756
 757                 ret = pci_vfio_get_region_info(vfio_dev_fd, &reg, i);
 758                 if (ret < 0) {
 759                         RTE_LOG(ERR, EAL, "  %s cannot get device region info "
 760                                 "error %i (%s)\n", pci_addr, errno,
 761                                 strerror(errno));
 762                         goto err_vfio_res;
 763                 }
 764
 765                 /* chk for io port region */
 766                 ret = pci_vfio_is_ioport_bar(vfio_dev_fd, i);
 767                 if (ret < 0) {
 768                         free(reg);
 769                         goto err_vfio_res;
 770                 } else if (ret) {
 771                         RTE_LOG(INFO, EAL, "Ignore mapping IO port bar(%d)\n",
 772                                         i);
 773                         free(reg);
 774                         continue;
 775                 }
 776
 777                 /* skip non-mmapable BARs */
 778                 if ((reg->flags & VFIO_REGION_INFO_FLAG_MMAP) == 0) {
 779                         free(reg);
 780                         continue;
 781                 }
 782
 783                 /* try mapping somewhere close to the end of hugepages */
 784                 if (pci_map_addr == NULL)
 785                         pci_map_addr = pci_find_max_end_va();
 786
 787                 bar_addr = pci_map_addr;
 788                 pci_map_addr = RTE_PTR_ADD(bar_addr, (size_t) reg->size);
 789
 790                 pci_map_addr = RTE_PTR_ALIGN(pci_map_addr,
 791                                         sysconf(_SC_PAGE_SIZE));
 792
 793                 maps[i].addr = bar_addr;
 794                 maps[i].offset = reg->offset;
 795                 maps[i].size = reg->size;
 796                 maps[i].path = NULL; /* vfio doesn't have per-resource paths */
 797
 798                 ret = pci_vfio_mmap_bar(vfio_dev_fd, vfio_res, i, 0);
 799                 if (ret < 0) {
 800                         RTE_LOG(ERR, EAL, "  %s mapping BAR%i failed: %s\n",
 801                                         pci_addr, i, strerror(errno));
 802                         free(reg);
 803                         goto err_vfio_res;
 804                 }
 805
 806                 dev->mem_resource[i].addr = maps[i].addr;
 807
 808                 free(reg);
 809         }
 810
 811         if (pci_rte_vfio_setup_device(dev, vfio_dev_fd) < 0) {
 812                 RTE_LOG(ERR, EAL, "  %s setup device failed\n", pci_addr);
 813                 goto err_vfio_res;
 814         }
 815
 816 #ifdef HAVE_VFIO_DEV_REQ_INTERFACE
 817         if (pci_vfio_enable_notifier(dev, vfio_dev_fd) != 0) {
 818                 RTE_LOG(ERR, EAL, "Error setting up notifier!\n");
 819                 goto err_vfio_res;
 820         }
 821
 822 #endif
 823         TAILQ_INSERT_TAIL(vfio_res_list, vfio_res, next);
 824
 825         return 0;
 826 err_vfio_res:
 827         rte_free(vfio_res);
 828 err_vfio_dev_fd:
 829         close(vfio_dev_fd);
 830         return -1;
 831 }
 832
 833 static int
 834 pci_vfio_map_resource_secondary(struct rte_pci_device *dev)
 835 {
 836         struct vfio_device_info device_info = { .argsz = sizeof(device_info) };
 837         char pci_addr[PATH_MAX] = {0};
 838         int vfio_dev_fd;
 839         struct rte_pci_addr *loc = &dev->addr;
 840         int i, ret;
 841         struct mapped_pci_resource *vfio_res = NULL;
 842         struct mapped_pci_res_list *vfio_res_list =
 843                 RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
 844
 845         struct pci_map *maps;
 846
 847         dev->intr_handle.fd = -1;
 848 #ifdef HAVE_VFIO_DEV_REQ_INTERFACE
 849         dev->vfio_req_intr_handle.fd = -1;
 850 #endif
 851
 852         /* store PCI address string */
 853         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
 854                         loc->domain, loc->bus, loc->devid, loc->function);
 855
 856         /* if we're in a secondary process, just find our tailq entry */
 857         TAILQ_FOREACH(vfio_res, vfio_res_list, next) {
 858                 if (rte_pci_addr_cmp(&vfio_res->pci_addr,
 859                                                  &dev->addr))
 860                         continue;
 861                 break;
 862         }
 863         /* if we haven't found our tailq entry, something's wrong */
 864         if (vfio_res == NULL) {
 865                 RTE_LOG(ERR, EAL, "  %s cannot find TAILQ entry for PCI device!\n",
 866                                 pci_addr);
 867                 return -1;
 868         }
 869
 870         ret = rte_vfio_setup_device(rte_pci_get_sysfs_path(), pci_addr,
 871                                         &vfio_dev_fd, &device_info);
 872         if (ret)
 873                 return ret;
 874
 875         /* map BARs */
 876         maps = vfio_res->maps;
 877
 878         for (i = 0; i < (int) vfio_res->nb_maps; i++) {
 879                 ret = pci_vfio_mmap_bar(vfio_dev_fd, vfio_res, i, MAP_FIXED);
 880                 if (ret < 0) {
 881                         RTE_LOG(ERR, EAL, "  %s mapping BAR%i failed: %s\n",
 882                                         pci_addr, i, strerror(errno));
 883                         goto err_vfio_dev_fd;
 884                 }
 885
 886                 dev->mem_resource[i].addr = maps[i].addr;
 887         }
 888
 889         /* we need save vfio_dev_fd, so it can be used during release */
 890         dev->intr_handle.vfio_dev_fd = vfio_dev_fd;
 891 #ifdef HAVE_VFIO_DEV_REQ_INTERFACE
 892         dev->vfio_req_intr_handle.vfio_dev_fd = vfio_dev_fd;
 893 #endif
 894
 895         return 0;
 896 err_vfio_dev_fd:
 897         close(vfio_dev_fd);
 898         return -1;
 899 }
 900
 901 /*
 902  * map the PCI resources of a PCI device in virtual memory (VFIO version).
 903  * primary and secondary processes follow almost exactly the same path
 904  */
 905 int
 906 pci_vfio_map_resource(struct rte_pci_device *dev)
 907 {
 908         if (rte_eal_process_type() == RTE_PROC_PRIMARY)
 909                 return pci_vfio_map_resource_primary(dev);
 910         else
 911                 return pci_vfio_map_resource_secondary(dev);
 912 }
 913
 914 static struct mapped_pci_resource *
 915 find_and_unmap_vfio_resource(struct mapped_pci_res_list *vfio_res_list,
 916                         struct rte_pci_device *dev,
 917                         const char *pci_addr)
 918 {
 919         struct mapped_pci_resource *vfio_res = NULL;
 920         struct pci_map *maps;
 921         int i;
 922
 923         /* Get vfio_res */
 924         TAILQ_FOREACH(vfio_res, vfio_res_list, next) {
 925                 if (rte_pci_addr_cmp(&vfio_res->pci_addr, &dev->addr))
 926                         continue;
 927                 break;
 928         }
 929
 930         if  (vfio_res == NULL)
 931                 return vfio_res;
 932
 933         RTE_LOG(INFO, EAL, "Releasing pci mapped resource for %s\n",
 934                 pci_addr);
 935
 936         maps = vfio_res->maps;
 937         for (i = 0; i < (int) vfio_res->nb_maps; i++) {
 938
 939                 /*
 940                  * We do not need to be aware of MSI-X table BAR mappings as
 941                  * when mapping. Just using current maps array is enough
 942                  */
 943                 if (maps[i].addr) {
 944                         RTE_LOG(INFO, EAL, "Calling pci_unmap_resource for %s at %p\n",
 945                                 pci_addr, maps[i].addr);
 946                         pci_unmap_resource(maps[i].addr, maps[i].size);
 947                 }
 948         }
 949
 950         return vfio_res;
 951 }
 952
 953 static int
 954 pci_vfio_unmap_resource_primary(struct rte_pci_device *dev)
 955 {
 956         char pci_addr[PATH_MAX] = {0};
 957         struct rte_pci_addr *loc = &dev->addr;
 958         struct mapped_pci_resource *vfio_res = NULL;
 959         struct mapped_pci_res_list *vfio_res_list;
 960         int ret;
 961
 962         /* store PCI address string */
 963         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
 964                         loc->domain, loc->bus, loc->devid, loc->function);
 965
 966 #ifdef HAVE_VFIO_DEV_REQ_INTERFACE
 967         ret = pci_vfio_disable_notifier(dev);
 968         if (ret) {
 969                 RTE_LOG(ERR, EAL, "fail to disable req notifier.\n");
 970                 return -1;
 971         }
 972
 973 #endif
 974         if (close(dev->intr_handle.fd) < 0) {
 975                 RTE_LOG(INFO, EAL, "Error when closing eventfd file descriptor for %s\n",
 976                         pci_addr);
 977                 return -1;
 978         }
 979
 980         if (pci_vfio_set_bus_master(dev->intr_handle.vfio_dev_fd, false)) {
 981                 RTE_LOG(ERR, EAL, "  %s cannot unset bus mastering for PCI device!\n",
 982                                 pci_addr);
 983                 return -1;
 984         }
 985
 986         ret = rte_vfio_release_device(rte_pci_get_sysfs_path(), pci_addr,
 987                                   dev->intr_handle.vfio_dev_fd);
 988         if (ret < 0) {
 989                 RTE_LOG(ERR, EAL,
 990                         "%s(): cannot release device\n", __func__);
 991                 return ret;
 992         }
 993
 994         vfio_res_list =
 995                 RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
 996         vfio_res = find_and_unmap_vfio_resource(vfio_res_list, dev, pci_addr);
 997
 998         /* if we haven't found our tailq entry, something's wrong */
 999         if (vfio_res == NULL) {
1000                 RTE_LOG(ERR, EAL, "  %s cannot find TAILQ entry for PCI device!\n",
1001                                 pci_addr);
1002                 return -1;
1003         }
1004
1005         TAILQ_REMOVE(vfio_res_list, vfio_res, next);
1006
1007         return 0;
1008 }
1009
1010 static int
1011 pci_vfio_unmap_resource_secondary(struct rte_pci_device *dev)
1012 {
1013         char pci_addr[PATH_MAX] = {0};
1014         struct rte_pci_addr *loc = &dev->addr;
1015         struct mapped_pci_resource *vfio_res = NULL;
1016         struct mapped_pci_res_list *vfio_res_list;
1017         int ret;
1018
1019         /* store PCI address string */
1020         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
1021                         loc->domain, loc->bus, loc->devid, loc->function);
1022
1023         ret = rte_vfio_release_device(rte_pci_get_sysfs_path(), pci_addr,
1024                                   dev->intr_handle.vfio_dev_fd);
1025         if (ret < 0) {
1026                 RTE_LOG(ERR, EAL,
1027                         "%s(): cannot release device\n", __func__);
1028                 return ret;
1029         }
1030
1031         vfio_res_list =
1032                 RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
1033         vfio_res = find_and_unmap_vfio_resource(vfio_res_list, dev, pci_addr);
1034
1035         /* if we haven't found our tailq entry, something's wrong */
1036         if (vfio_res == NULL) {
1037                 RTE_LOG(ERR, EAL, "  %s cannot find TAILQ entry for PCI device!\n",
1038                                 pci_addr);
1039                 return -1;
1040         }
1041
1042         return 0;
1043 }
1044
1045 int
1046 pci_vfio_unmap_resource(struct rte_pci_device *dev)
1047 {
1048         if (rte_eal_process_type() == RTE_PROC_PRIMARY)
1049                 return pci_vfio_unmap_resource_primary(dev);
1050         else
1051                 return pci_vfio_unmap_resource_secondary(dev);
1052 }
1053
1054 int
1055 pci_vfio_ioport_map(struct rte_pci_device *dev, int bar,
1056                     struct rte_pci_ioport *p)
1057 {
1058         if (bar < VFIO_PCI_BAR0_REGION_INDEX ||
1059             bar > VFIO_PCI_BAR5_REGION_INDEX) {
1060                 RTE_LOG(ERR, EAL, "invalid bar (%d)!\n", bar);
1061                 return -1;
1062         }
1063
1064         p->dev = dev;
1065         p->base = VFIO_GET_REGION_ADDR(bar);
1066         return 0;
1067 }
1068
1069 void
1070 pci_vfio_ioport_read(struct rte_pci_ioport *p,
1071                      void *data, size_t len, off_t offset)
1072 {
1073         const struct rte_intr_handle *intr_handle = &p->dev->intr_handle;
1074
1075         if (pread64(intr_handle->vfio_dev_fd, data,
1076                     len, p->base + offset) <= 0)
1077                 RTE_LOG(ERR, EAL,
1078                         "Can't read from PCI bar (%" PRIu64 ") : offset (%x)\n",
1079                         VFIO_GET_REGION_IDX(p->base), (int)offset);
1080 }
1081
1082 void
1083 pci_vfio_ioport_write(struct rte_pci_ioport *p,
1084                       const void *data, size_t len, off_t offset)
1085 {
1086         const struct rte_intr_handle *intr_handle = &p->dev->intr_handle;
1087
1088         if (pwrite64(intr_handle->vfio_dev_fd, data,
1089                      len, p->base + offset) <= 0)
1090                 RTE_LOG(ERR, EAL,
1091                         "Can't write to PCI bar (%" PRIu64 ") : offset (%x)\n",
1092                         VFIO_GET_REGION_IDX(p->base), (int)offset);
1093 }
1094
1095 int
1096 pci_vfio_ioport_unmap(struct rte_pci_ioport *p)
1097 {
1098         RTE_SET_USED(p);
1099         return -1;
1100 }
1101
1102 int
1103 pci_vfio_is_enabled(void)
1104 {
1105         return rte_vfio_is_enabled("vfio_pci");
1106 }
1107 #endif