lib/librte_eal/linuxapp/eal/eal_pci_vfio.c

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