service: add count per lcore
[dpdk.git] / 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
48 #include "eal_filesystem.h"
49 #include "eal_pci_init.h"
50 #include "eal_vfio.h"
51 #include "eal_private.h"
52
53 /**
54  * @file
55  * PCI probing under linux (VFIO version)
56  *
57  * This code tries to determine if the PCI device is bound to VFIO driver,
58  * and initialize it (map BARs, set up interrupts) if that's the case.
59  *
60  * This file is only compiled if CONFIG_RTE_EAL_VFIO is set to "y".
61  */
62
63 #ifdef VFIO_PRESENT
64
65 #define PAGE_SIZE   (sysconf(_SC_PAGESIZE))
66 #define PAGE_MASK   (~(PAGE_SIZE - 1))
67
68 static struct rte_tailq_elem rte_vfio_tailq = {
69         .name = "VFIO_RESOURCE_LIST",
70 };
71 EAL_REGISTER_TAILQ(rte_vfio_tailq)
72
73 int
74 pci_vfio_read_config(const struct rte_intr_handle *intr_handle,
75                     void *buf, size_t len, off_t offs)
76 {
77         return pread64(intr_handle->vfio_dev_fd, buf, len,
78                VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) + offs);
79 }
80
81 int
82 pci_vfio_write_config(const struct rte_intr_handle *intr_handle,
83                     const void *buf, size_t len, off_t offs)
84 {
85         return pwrite64(intr_handle->vfio_dev_fd, buf, len,
86                VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) + offs);
87 }
88
89 /* get PCI BAR number where MSI-X interrupts are */
90 static int
91 pci_vfio_get_msix_bar(int fd, int *msix_bar, uint32_t *msix_table_offset,
92                       uint32_t *msix_table_size)
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_bar = reg & RTE_PCI_MSIX_TABLE_BIR;
165                         *msix_table_offset = reg & RTE_PCI_MSIX_TABLE_OFFSET;
166                         *msix_table_size = 16 * (1 + (flags & RTE_PCI_MSIX_FLAGS_QSIZE));
167
168                         return 0;
169                 }
170         }
171         return 0;
172 }
173
174 /* set PCI bus mastering */
175 static int
176 pci_vfio_set_bus_master(int dev_fd, bool op)
177 {
178         uint16_t reg;
179         int ret;
180
181         ret = pread64(dev_fd, &reg, sizeof(reg),
182                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
183                         PCI_COMMAND);
184         if (ret != sizeof(reg)) {
185                 RTE_LOG(ERR, EAL, "Cannot read command from PCI config space!\n");
186                 return -1;
187         }
188
189         if (op)
190                 /* set the master bit */
191                 reg |= PCI_COMMAND_MASTER;
192         else
193                 reg &= ~(PCI_COMMAND_MASTER);
194
195         ret = pwrite64(dev_fd, &reg, sizeof(reg),
196                         VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX) +
197                         PCI_COMMAND);
198
199         if (ret != sizeof(reg)) {
200                 RTE_LOG(ERR, EAL, "Cannot write command to PCI config space!\n");
201                 return -1;
202         }
203
204         return 0;
205 }
206
207 /* set up interrupt support (but not enable interrupts) */
208 static int
209 pci_vfio_setup_interrupts(struct rte_pci_device *dev, int vfio_dev_fd)
210 {
211         int i, ret, intr_idx;
212
213         /* default to invalid index */
214         intr_idx = VFIO_PCI_NUM_IRQS;
215
216         /* get interrupt type from internal config (MSI-X by default, can be
217          * overridden from the command line
218          */
219         switch (internal_config.vfio_intr_mode) {
220         case RTE_INTR_MODE_MSIX:
221                 intr_idx = VFIO_PCI_MSIX_IRQ_INDEX;
222                 break;
223         case RTE_INTR_MODE_MSI:
224                 intr_idx = VFIO_PCI_MSI_IRQ_INDEX;
225                 break;
226         case RTE_INTR_MODE_LEGACY:
227                 intr_idx = VFIO_PCI_INTX_IRQ_INDEX;
228                 break;
229         /* don't do anything if we want to automatically determine interrupt type */
230         case RTE_INTR_MODE_NONE:
231                 break;
232         default:
233                 RTE_LOG(ERR, EAL, "  unknown default interrupt type!\n");
234                 return -1;
235         }
236
237         /* start from MSI-X interrupt type */
238         for (i = VFIO_PCI_MSIX_IRQ_INDEX; i >= 0; i--) {
239                 struct vfio_irq_info irq = { .argsz = sizeof(irq) };
240                 int fd = -1;
241
242                 /* skip interrupt modes we don't want */
243                 if (internal_config.vfio_intr_mode != RTE_INTR_MODE_NONE &&
244                                 i != intr_idx)
245                         continue;
246
247                 irq.index = i;
248
249                 ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_IRQ_INFO, &irq);
250                 if (ret < 0) {
251                         RTE_LOG(ERR, EAL, "  cannot get IRQ info, "
252                                         "error %i (%s)\n", errno, strerror(errno));
253                         return -1;
254                 }
255
256                 /* if this vector cannot be used with eventfd, fail if we explicitly
257                  * specified interrupt type, otherwise continue */
258                 if ((irq.flags & VFIO_IRQ_INFO_EVENTFD) == 0) {
259                         if (internal_config.vfio_intr_mode != RTE_INTR_MODE_NONE) {
260                                 RTE_LOG(ERR, EAL,
261                                                 "  interrupt vector does not support eventfd!\n");
262                                 return -1;
263                         } else
264                                 continue;
265                 }
266
267                 /* set up an eventfd for interrupts */
268                 fd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
269                 if (fd < 0) {
270                         RTE_LOG(ERR, EAL, "  cannot set up eventfd, "
271                                         "error %i (%s)\n", errno, strerror(errno));
272                         return -1;
273                 }
274
275                 dev->intr_handle.fd = fd;
276                 dev->intr_handle.vfio_dev_fd = vfio_dev_fd;
277
278                 switch (i) {
279                 case VFIO_PCI_MSIX_IRQ_INDEX:
280                         internal_config.vfio_intr_mode = RTE_INTR_MODE_MSIX;
281                         dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_MSIX;
282                         break;
283                 case VFIO_PCI_MSI_IRQ_INDEX:
284                         internal_config.vfio_intr_mode = RTE_INTR_MODE_MSI;
285                         dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_MSI;
286                         break;
287                 case VFIO_PCI_INTX_IRQ_INDEX:
288                         internal_config.vfio_intr_mode = RTE_INTR_MODE_LEGACY;
289                         dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_LEGACY;
290                         break;
291                 default:
292                         RTE_LOG(ERR, EAL, "  unknown interrupt type!\n");
293                         return -1;
294                 }
295
296                 return 0;
297         }
298
299         /* if we're here, we haven't found a suitable interrupt vector */
300         return -1;
301 }
302
303 /*
304  * map the PCI resources of a PCI device in virtual memory (VFIO version).
305  * primary and secondary processes follow almost exactly the same path
306  */
307 int
308 pci_vfio_map_resource(struct rte_pci_device *dev)
309 {
310         struct vfio_device_info device_info = { .argsz = sizeof(device_info) };
311         char pci_addr[PATH_MAX] = {0};
312         int vfio_dev_fd;
313         struct rte_pci_addr *loc = &dev->addr;
314         int i, ret, msix_bar;
315         struct mapped_pci_resource *vfio_res = NULL;
316         struct mapped_pci_res_list *vfio_res_list = RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
317
318         struct pci_map *maps;
319         uint32_t msix_table_offset = 0;
320         uint32_t msix_table_size = 0;
321         uint32_t ioport_bar;
322
323         dev->intr_handle.fd = -1;
324         dev->intr_handle.type = RTE_INTR_HANDLE_UNKNOWN;
325
326         /* store PCI address string */
327         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
328                         loc->domain, loc->bus, loc->devid, loc->function);
329
330         if ((ret = vfio_setup_device(pci_get_sysfs_path(), pci_addr,
331                                         &vfio_dev_fd, &device_info)))
332                 return ret;
333
334         /* get MSI-X BAR, if any (we have to know where it is because we can't
335          * easily mmap it when using VFIO) */
336         msix_bar = -1;
337         ret = pci_vfio_get_msix_bar(vfio_dev_fd, &msix_bar,
338                                     &msix_table_offset, &msix_table_size);
339         if (ret < 0) {
340                 RTE_LOG(ERR, EAL, "  %s cannot get MSI-X BAR number!\n", pci_addr);
341                 close(vfio_dev_fd);
342                 return -1;
343         }
344
345         /* if we're in a primary process, allocate vfio_res and get region info */
346         if (internal_config.process_type == RTE_PROC_PRIMARY) {
347                 vfio_res = rte_zmalloc("VFIO_RES", sizeof(*vfio_res), 0);
348                 if (vfio_res == NULL) {
349                         RTE_LOG(ERR, EAL,
350                                 "%s(): cannot store uio mmap details\n", __func__);
351                         close(vfio_dev_fd);
352                         return -1;
353                 }
354                 memcpy(&vfio_res->pci_addr, &dev->addr, sizeof(vfio_res->pci_addr));
355
356                 /* get number of registers (up to BAR5) */
357                 vfio_res->nb_maps = RTE_MIN((int) device_info.num_regions,
358                                 VFIO_PCI_BAR5_REGION_INDEX + 1);
359         } else {
360                 /* if we're in a secondary process, just find our tailq entry */
361                 TAILQ_FOREACH(vfio_res, vfio_res_list, next) {
362                         if (rte_eal_compare_pci_addr(&vfio_res->pci_addr,
363                                                      &dev->addr))
364                                 continue;
365                         break;
366                 }
367                 /* if we haven't found our tailq entry, something's wrong */
368                 if (vfio_res == NULL) {
369                         RTE_LOG(ERR, EAL, "  %s cannot find TAILQ entry for PCI device!\n",
370                                         pci_addr);
371                         close(vfio_dev_fd);
372                         return -1;
373                 }
374         }
375
376         /* map BARs */
377         maps = vfio_res->maps;
378
379         for (i = 0; i < (int) vfio_res->nb_maps; i++) {
380                 struct vfio_region_info reg = { .argsz = sizeof(reg) };
381                 void *bar_addr;
382                 struct memreg {
383                         unsigned long offset, size;
384                 } memreg[2] = {};
385
386                 reg.index = i;
387
388                 ret = ioctl(vfio_dev_fd, VFIO_DEVICE_GET_REGION_INFO, &reg);
389
390                 if (ret) {
391                         RTE_LOG(ERR, EAL, "  %s cannot get device region info "
392                                         "error %i (%s)\n", pci_addr, errno, strerror(errno));
393                         close(vfio_dev_fd);
394                         if (internal_config.process_type == RTE_PROC_PRIMARY)
395                                 rte_free(vfio_res);
396                         return -1;
397                 }
398
399                 /* chk for io port region */
400                 ret = pread64(vfio_dev_fd, &ioport_bar, sizeof(ioport_bar),
401                               VFIO_GET_REGION_ADDR(VFIO_PCI_CONFIG_REGION_INDEX)
402                               + PCI_BASE_ADDRESS_0 + i*4);
403
404                 if (ret != sizeof(ioport_bar)) {
405                         RTE_LOG(ERR, EAL,
406                                 "Cannot read command (%x) from config space!\n",
407                                 PCI_BASE_ADDRESS_0 + i*4);
408                         return -1;
409                 }
410
411                 if (ioport_bar & PCI_BASE_ADDRESS_SPACE_IO) {
412                         RTE_LOG(INFO, EAL,
413                                 "Ignore mapping IO port bar(%d) addr: %x\n",
414                                  i, ioport_bar);
415                         continue;
416                 }
417
418                 /* skip non-mmapable BARs */
419                 if ((reg.flags & VFIO_REGION_INFO_FLAG_MMAP) == 0)
420                         continue;
421
422                 if (i == msix_bar) {
423                         /*
424                          * VFIO will not let us map the MSI-X table,
425                          * but we can map around it.
426                          */
427                         uint32_t table_start = msix_table_offset;
428                         uint32_t table_end = table_start + msix_table_size;
429                         table_end = (table_end + ~PAGE_MASK) & PAGE_MASK;
430                         table_start &= PAGE_MASK;
431
432                         if (table_start == 0 && table_end >= reg.size) {
433                                 /* Cannot map this BAR */
434                                 RTE_LOG(DEBUG, EAL, "Skipping BAR %d\n", i);
435                                 continue;
436                         } else {
437                                 memreg[0].offset = reg.offset;
438                                 memreg[0].size = table_start;
439                                 memreg[1].offset = reg.offset + table_end;
440                                 memreg[1].size = reg.size - table_end;
441
442                                 RTE_LOG(DEBUG, EAL,
443                                         "Trying to map BAR %d that contains the MSI-X "
444                                         "table. Trying offsets: "
445                                         "0x%04lx:0x%04lx, 0x%04lx:0x%04lx\n", i,
446                                         memreg[0].offset, memreg[0].size,
447                                         memreg[1].offset, memreg[1].size);
448                         }
449                 } else {
450                         memreg[0].offset = reg.offset;
451                         memreg[0].size = reg.size;
452                 }
453
454                 /* try to figure out an address */
455                 if (internal_config.process_type == RTE_PROC_PRIMARY) {
456                         /* try mapping somewhere close to the end of hugepages */
457                         if (pci_map_addr == NULL)
458                                 pci_map_addr = pci_find_max_end_va();
459
460                         bar_addr = pci_map_addr;
461                         pci_map_addr = RTE_PTR_ADD(bar_addr, (size_t) reg.size);
462                 } else {
463                         bar_addr = maps[i].addr;
464                 }
465
466                 /* reserve the address using an inaccessible mapping */
467                 bar_addr = mmap(bar_addr, reg.size, 0, MAP_PRIVATE |
468                                 MAP_ANONYMOUS, -1, 0);
469                 if (bar_addr != MAP_FAILED) {
470                         void *map_addr = NULL;
471                         if (memreg[0].size) {
472                                 /* actual map of first part */
473                                 map_addr = pci_map_resource(bar_addr, vfio_dev_fd,
474                                                             memreg[0].offset,
475                                                             memreg[0].size,
476                                                             MAP_FIXED);
477                         }
478
479                         /* if there's a second part, try to map it */
480                         if (map_addr != MAP_FAILED
481                             && memreg[1].offset && memreg[1].size) {
482                                 void *second_addr = RTE_PTR_ADD(bar_addr,
483                                                                 memreg[1].offset -
484                                                                 (uintptr_t)reg.offset);
485                                 map_addr = pci_map_resource(second_addr,
486                                                             vfio_dev_fd, memreg[1].offset,
487                                                             memreg[1].size,
488                                                             MAP_FIXED);
489                         }
490
491                         if (map_addr == MAP_FAILED || !map_addr) {
492                                 munmap(bar_addr, reg.size);
493                                 bar_addr = MAP_FAILED;
494                         }
495                 }
496
497                 if (bar_addr == MAP_FAILED ||
498                                 (internal_config.process_type == RTE_PROC_SECONDARY &&
499                                                 bar_addr != maps[i].addr)) {
500                         RTE_LOG(ERR, EAL, "  %s mapping BAR%i failed: %s\n", pci_addr, i,
501                                         strerror(errno));
502                         close(vfio_dev_fd);
503                         if (internal_config.process_type == RTE_PROC_PRIMARY)
504                                 rte_free(vfio_res);
505                         return -1;
506                 }
507
508                 maps[i].addr = bar_addr;
509                 maps[i].offset = reg.offset;
510                 maps[i].size = reg.size;
511                 maps[i].path = NULL; /* vfio doesn't have per-resource paths */
512                 dev->mem_resource[i].addr = bar_addr;
513         }
514
515         /* if secondary process, do not set up interrupts */
516         if (internal_config.process_type == RTE_PROC_PRIMARY) {
517                 if (pci_vfio_setup_interrupts(dev, vfio_dev_fd) != 0) {
518                         RTE_LOG(ERR, EAL, "  %s error setting up interrupts!\n", pci_addr);
519                         close(vfio_dev_fd);
520                         rte_free(vfio_res);
521                         return -1;
522                 }
523
524                 /* set bus mastering for the device */
525                 if (pci_vfio_set_bus_master(vfio_dev_fd, true)) {
526                         RTE_LOG(ERR, EAL, "  %s cannot set up bus mastering!\n", pci_addr);
527                         close(vfio_dev_fd);
528                         rte_free(vfio_res);
529                         return -1;
530                 }
531
532                 /* Reset the device */
533                 ioctl(vfio_dev_fd, VFIO_DEVICE_RESET);
534         }
535
536         if (internal_config.process_type == RTE_PROC_PRIMARY)
537                 TAILQ_INSERT_TAIL(vfio_res_list, vfio_res, next);
538
539         return 0;
540 }
541
542 int
543 pci_vfio_unmap_resource(struct rte_pci_device *dev)
544 {
545         char pci_addr[PATH_MAX] = {0};
546         struct rte_pci_addr *loc = &dev->addr;
547         int i, ret;
548         struct mapped_pci_resource *vfio_res = NULL;
549         struct mapped_pci_res_list *vfio_res_list;
550
551         struct pci_map *maps;
552
553         /* store PCI address string */
554         snprintf(pci_addr, sizeof(pci_addr), PCI_PRI_FMT,
555                         loc->domain, loc->bus, loc->devid, loc->function);
556
557
558         if (close(dev->intr_handle.fd) < 0) {
559                 RTE_LOG(INFO, EAL, "Error when closing eventfd file descriptor for %s\n",
560                         pci_addr);
561                 return -1;
562         }
563
564         if (pci_vfio_set_bus_master(dev->intr_handle.vfio_dev_fd, false)) {
565                 RTE_LOG(ERR, EAL, "  %s cannot unset bus mastering for PCI device!\n",
566                                 pci_addr);
567                 return -1;
568         }
569
570         ret = vfio_release_device(pci_get_sysfs_path(), pci_addr,
571                                   dev->intr_handle.vfio_dev_fd);
572         if (ret < 0) {
573                 RTE_LOG(ERR, EAL,
574                         "%s(): cannot release device\n", __func__);
575                 return ret;
576         }
577
578         vfio_res_list = RTE_TAILQ_CAST(rte_vfio_tailq.head, mapped_pci_res_list);
579         /* Get vfio_res */
580         TAILQ_FOREACH(vfio_res, vfio_res_list, next) {
581                 if (memcmp(&vfio_res->pci_addr, &dev->addr, sizeof(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                 return -1;
590         }
591
592         /* unmap BARs */
593         maps = vfio_res->maps;
594
595         RTE_LOG(INFO, EAL, "Releasing pci mapped resource for %s\n",
596                 pci_addr);
597         for (i = 0; i < (int) vfio_res->nb_maps; i++) {
598
599                 /*
600                  * We do not need to be aware of MSI-X table BAR mappings as
601                  * when mapping. Just using current maps array is enough
602                  */
603                 if (maps[i].addr) {
604                         RTE_LOG(INFO, EAL, "Calling pci_unmap_resource for %s at %p\n",
605                                 pci_addr, maps[i].addr);
606                         pci_unmap_resource(maps[i].addr, maps[i].size);
607                 }
608         }
609
610         TAILQ_REMOVE(vfio_res_list, vfio_res, next);
611
612         return 0;
613 }
614
615 int
616 pci_vfio_ioport_map(struct rte_pci_device *dev, int bar,
617                     struct rte_pci_ioport *p)
618 {
619         if (bar < VFIO_PCI_BAR0_REGION_INDEX ||
620             bar > VFIO_PCI_BAR5_REGION_INDEX) {
621                 RTE_LOG(ERR, EAL, "invalid bar (%d)!\n", bar);
622                 return -1;
623         }
624
625         p->dev = dev;
626         p->base = VFIO_GET_REGION_ADDR(bar);
627         return 0;
628 }
629
630 void
631 pci_vfio_ioport_read(struct rte_pci_ioport *p,
632                      void *data, size_t len, off_t offset)
633 {
634         const struct rte_intr_handle *intr_handle = &p->dev->intr_handle;
635
636         if (pread64(intr_handle->vfio_dev_fd, data,
637                     len, p->base + offset) <= 0)
638                 RTE_LOG(ERR, EAL,
639                         "Can't read from PCI bar (%" PRIu64 ") : offset (%x)\n",
640                         VFIO_GET_REGION_IDX(p->base), (int)offset);
641 }
642
643 void
644 pci_vfio_ioport_write(struct rte_pci_ioport *p,
645                       const void *data, size_t len, off_t offset)
646 {
647         const struct rte_intr_handle *intr_handle = &p->dev->intr_handle;
648
649         if (pwrite64(intr_handle->vfio_dev_fd, data,
650                      len, p->base + offset) <= 0)
651                 RTE_LOG(ERR, EAL,
652                         "Can't write to PCI bar (%" PRIu64 ") : offset (%x)\n",
653                         VFIO_GET_REGION_IDX(p->base), (int)offset);
654 }
655
656 int
657 pci_vfio_ioport_unmap(struct rte_pci_ioport *p)
658 {
659         RTE_SET_USED(p);
660         return -1;
661 }
662
663 int
664 pci_vfio_enable(void)
665 {
666         return vfio_enable("vfio_pci");
667 }
668
669 int
670 pci_vfio_is_enabled(void)
671 {
672         return vfio_is_enabled("vfio_pci");
673 }
674 #endif