lib/librte_eal/linuxapp/eal/eal_vfio.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <inttypes.h>
   6 #include <string.h>
   7 #include <fcntl.h>
   8 #include <unistd.h>
   9 #include <sys/ioctl.h>
  10
  11 #include <rte_errno.h>
  12 #include <rte_log.h>
  13 #include <rte_memory.h>
  14 #include <rte_eal_memconfig.h>
  15 #include <rte_vfio.h>
  16
  17 #include "eal_filesystem.h"
  18 #include "eal_vfio.h"
  19 #include "eal_private.h"
  20
  21 #ifdef VFIO_PRESENT
  22
  23 #define VFIO_MEM_EVENT_CLB_NAME "vfio_mem_event_clb"
  24
  25 /* per-process VFIO config */
  26 static struct vfio_config vfio_cfg;
  27
  28 static int vfio_type1_dma_map(int);
  29 static int vfio_type1_dma_mem_map(int, uint64_t, uint64_t, uint64_t, int);
  30 static int vfio_spapr_dma_map(int);
  31 static int vfio_spapr_dma_mem_map(int, uint64_t, uint64_t, uint64_t, int);
  32 static int vfio_noiommu_dma_map(int);
  33 static int vfio_noiommu_dma_mem_map(int, uint64_t, uint64_t, uint64_t, int);
  34 static int vfio_dma_mem_map(uint64_t vaddr, uint64_t iova, uint64_t len,
  35                 int do_map);
  36
  37 /* IOMMU types we support */
  38 static const struct vfio_iommu_type iommu_types[] = {
  39         /* x86 IOMMU, otherwise known as type 1 */
  40         {
  41                 .type_id = RTE_VFIO_TYPE1,
  42                 .name = "Type 1",
  43                 .dma_map_func = &vfio_type1_dma_map,
  44                 .dma_user_map_func = &vfio_type1_dma_mem_map
  45         },
  46         /* ppc64 IOMMU, otherwise known as spapr */
  47         {
  48                 .type_id = RTE_VFIO_SPAPR,
  49                 .name = "sPAPR",
  50                 .dma_map_func = &vfio_spapr_dma_map,
  51                 .dma_user_map_func = &vfio_spapr_dma_mem_map
  52         },
  53         /* IOMMU-less mode */
  54         {
  55                 .type_id = RTE_VFIO_NOIOMMU,
  56                 .name = "No-IOMMU",
  57                 .dma_map_func = &vfio_noiommu_dma_map,
  58                 .dma_user_map_func = &vfio_noiommu_dma_mem_map
  59         },
  60 };
  61
  62 /* hot plug/unplug of VFIO groups may cause all DMA maps to be dropped. we can
  63  * recreate the mappings for DPDK segments, but we cannot do so for memory that
  64  * was registered by the user themselves, so we need to store the user mappings
  65  * somewhere, to recreate them later.
  66  */
  67 #define VFIO_MAX_USER_MEM_MAPS 256
  68 struct user_mem_map {
  69         uint64_t addr;
  70         uint64_t iova;
  71         uint64_t len;
  72 };
  73 static struct {
  74         rte_spinlock_recursive_t lock;
  75         int n_maps;
  76         struct user_mem_map maps[VFIO_MAX_USER_MEM_MAPS];
  77 } user_mem_maps = {
  78         .lock = RTE_SPINLOCK_RECURSIVE_INITIALIZER
  79 };
  80
  81 /* for sPAPR IOMMU, we will need to walk memseg list, but we cannot use
  82  * rte_memseg_walk() because by the time we enter callback we will be holding a
  83  * write lock, so regular rte-memseg_walk will deadlock. copying the same
  84  * iteration code everywhere is not ideal as well. so, use a lockless copy of
  85  * memseg walk here.
  86  */
  87 static int
  88 memseg_walk_thread_unsafe(rte_memseg_walk_t func, void *arg)
  89 {
  90         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
  91         int i, ms_idx, ret = 0;
  92
  93         for (i = 0; i < RTE_MAX_MEMSEG_LISTS; i++) {
  94                 struct rte_memseg_list *msl = &mcfg->memsegs[i];
  95                 const struct rte_memseg *ms;
  96                 struct rte_fbarray *arr;
  97
  98                 if (msl->memseg_arr.count == 0)
  99                         continue;
 100
 101                 arr = &msl->memseg_arr;
 102
 103                 ms_idx = rte_fbarray_find_next_used(arr, 0);
 104                 while (ms_idx >= 0) {
 105                         ms = rte_fbarray_get(arr, ms_idx);
 106                         ret = func(msl, ms, arg);
 107                         if (ret < 0)
 108                                 return -1;
 109                         if (ret > 0)
 110                                 return 1;
 111                         ms_idx = rte_fbarray_find_next_used(arr, ms_idx + 1);
 112                 }
 113         }
 114         return 0;
 115 }
 116
 117 static int
 118 is_null_map(const struct user_mem_map *map)
 119 {
 120         return map->addr == 0 && map->iova == 0 && map->len == 0;
 121 }
 122
 123 /* we may need to merge user mem maps together in case of user mapping/unmapping
 124  * chunks of memory, so we'll need a comparator function to sort segments.
 125  */
 126 static int
 127 user_mem_map_cmp(const void *a, const void *b)
 128 {
 129         const struct user_mem_map *umm_a = a;
 130         const struct user_mem_map *umm_b = b;
 131
 132         /* move null entries to end */
 133         if (is_null_map(umm_a))
 134                 return 1;
 135         if (is_null_map(umm_b))
 136                 return -1;
 137
 138         /* sort by iova first */
 139         if (umm_a->iova < umm_b->iova)
 140                 return -1;
 141         if (umm_a->iova > umm_b->iova)
 142                 return 1;
 143
 144         if (umm_a->addr < umm_b->addr)
 145                 return -1;
 146         if (umm_a->addr > umm_b->addr)
 147                 return 1;
 148
 149         if (umm_a->len < umm_b->len)
 150                 return -1;
 151         if (umm_a->len > umm_b->len)
 152                 return 1;
 153
 154         return 0;
 155 }
 156
 157 /* adjust user map entry. this may result in shortening of existing map, or in
 158  * splitting existing map in two pieces.
 159  */
 160 static void
 161 adjust_map(struct user_mem_map *src, struct user_mem_map *end,
 162                 uint64_t remove_va_start, uint64_t remove_len)
 163 {
 164         /* if va start is same as start address, we're simply moving start */
 165         if (remove_va_start == src->addr) {
 166                 src->addr += remove_len;
 167                 src->iova += remove_len;
 168                 src->len -= remove_len;
 169         } else if (remove_va_start + remove_len == src->addr + src->len) {
 170                 /* we're shrinking mapping from the end */
 171                 src->len -= remove_len;
 172         } else {
 173                 /* we're blowing a hole in the middle */
 174                 struct user_mem_map tmp;
 175                 uint64_t total_len = src->len;
 176
 177                 /* adjust source segment length */
 178                 src->len = remove_va_start - src->addr;
 179
 180                 /* create temporary segment in the middle */
 181                 tmp.addr = src->addr + src->len;
 182                 tmp.iova = src->iova + src->len;
 183                 tmp.len = remove_len;
 184
 185                 /* populate end segment - this one we will be keeping */
 186                 end->addr = tmp.addr + tmp.len;
 187                 end->iova = tmp.iova + tmp.len;
 188                 end->len = total_len - src->len - tmp.len;
 189         }
 190 }
 191
 192 /* try merging two maps into one, return 1 if succeeded */
 193 static int
 194 merge_map(struct user_mem_map *left, struct user_mem_map *right)
 195 {
 196         if (left->addr + left->len != right->addr)
 197                 return 0;
 198         if (left->iova + left->len != right->iova)
 199                 return 0;
 200
 201         left->len += right->len;
 202
 203         memset(right, 0, sizeof(*right));
 204
 205         return 1;
 206 }
 207
 208 static struct user_mem_map *
 209 find_user_mem_map(uint64_t addr, uint64_t iova, uint64_t len)
 210 {
 211         uint64_t va_end = addr + len;
 212         uint64_t iova_end = iova + len;
 213         int i;
 214
 215         for (i = 0; i < user_mem_maps.n_maps; i++) {
 216                 struct user_mem_map *map = &user_mem_maps.maps[i];
 217                 uint64_t map_va_end = map->addr + map->len;
 218                 uint64_t map_iova_end = map->iova + map->len;
 219
 220                 /* check start VA */
 221                 if (addr < map->addr || addr >= map_va_end)
 222                         continue;
 223                 /* check if IOVA end is within boundaries */
 224                 if (va_end <= map->addr || va_end >= map_va_end)
 225                         continue;
 226
 227                 /* check start PA */
 228                 if (iova < map->iova || iova >= map_iova_end)
 229                         continue;
 230                 /* check if IOVA end is within boundaries */
 231                 if (iova_end <= map->iova || iova_end >= map_iova_end)
 232                         continue;
 233
 234                 /* we've found our map */
 235                 return map;
 236         }
 237         return NULL;
 238 }
 239
 240 /* this will sort all user maps, and merge/compact any adjacent maps */
 241 static void
 242 compact_user_maps(void)
 243 {
 244         int i, n_merged, cur_idx;
 245
 246         qsort(user_mem_maps.maps, user_mem_maps.n_maps,
 247                         sizeof(user_mem_maps.maps[0]), user_mem_map_cmp);
 248
 249         /* we'll go over the list backwards when merging */
 250         n_merged = 0;
 251         for (i = user_mem_maps.n_maps - 2; i >= 0; i--) {
 252                 struct user_mem_map *l, *r;
 253
 254                 l = &user_mem_maps.maps[i];
 255                 r = &user_mem_maps.maps[i + 1];
 256
 257                 if (is_null_map(l) || is_null_map(r))
 258                         continue;
 259
 260                 if (merge_map(l, r))
 261                         n_merged++;
 262         }
 263
 264         /* the entries are still sorted, but now they have holes in them, so
 265          * walk through the list and remove the holes
 266          */
 267         if (n_merged > 0) {
 268                 cur_idx = 0;
 269                 for (i = 0; i < user_mem_maps.n_maps; i++) {
 270                         if (!is_null_map(&user_mem_maps.maps[i])) {
 271                                 struct user_mem_map *src, *dst;
 272
 273                                 src = &user_mem_maps.maps[i];
 274                                 dst = &user_mem_maps.maps[cur_idx++];
 275
 276                                 if (src != dst) {
 277                                         memcpy(dst, src, sizeof(*src));
 278                                         memset(src, 0, sizeof(*src));
 279                                 }
 280                         }
 281                 }
 282                 user_mem_maps.n_maps = cur_idx;
 283         }
 284 }
 285
 286 int
 287 rte_vfio_get_group_fd(int iommu_group_num)
 288 {
 289         int i;
 290         int vfio_group_fd;
 291         char filename[PATH_MAX];
 292         struct vfio_group *cur_grp;
 293
 294         /* check if we already have the group descriptor open */
 295         for (i = 0; i < VFIO_MAX_GROUPS; i++)
 296                 if (vfio_cfg.vfio_groups[i].group_num == iommu_group_num)
 297                         return vfio_cfg.vfio_groups[i].fd;
 298
 299         /* Lets see first if there is room for a new group */
 300         if (vfio_cfg.vfio_active_groups == VFIO_MAX_GROUPS) {
 301                 RTE_LOG(ERR, EAL, "Maximum number of VFIO groups reached!\n");
 302                 return -1;
 303         }
 304
 305         /* Now lets get an index for the new group */
 306         for (i = 0; i < VFIO_MAX_GROUPS; i++)
 307                 if (vfio_cfg.vfio_groups[i].group_num == -1) {
 308                         cur_grp = &vfio_cfg.vfio_groups[i];
 309                         break;
 310                 }
 311
 312         /* This should not happen */
 313         if (i == VFIO_MAX_GROUPS) {
 314                 RTE_LOG(ERR, EAL, "No VFIO group free slot found\n");
 315                 return -1;
 316         }
 317         /* if primary, try to open the group */
 318         if (internal_config.process_type == RTE_PROC_PRIMARY) {
 319                 /* try regular group format */
 320                 snprintf(filename, sizeof(filename),
 321                                  VFIO_GROUP_FMT, iommu_group_num);
 322                 vfio_group_fd = open(filename, O_RDWR);
 323                 if (vfio_group_fd < 0) {
 324                         /* if file not found, it's not an error */
 325                         if (errno != ENOENT) {
 326                                 RTE_LOG(ERR, EAL, "Cannot open %s: %s\n", filename,
 327                                                 strerror(errno));
 328                                 return -1;
 329                         }
 330
 331                         /* special case: try no-IOMMU path as well */
 332                         snprintf(filename, sizeof(filename),
 333                                         VFIO_NOIOMMU_GROUP_FMT,
 334                                         iommu_group_num);
 335                         vfio_group_fd = open(filename, O_RDWR);
 336                         if (vfio_group_fd < 0) {
 337                                 if (errno != ENOENT) {
 338                                         RTE_LOG(ERR, EAL, "Cannot open %s: %s\n", filename,
 339                                                         strerror(errno));
 340                                         return -1;
 341                                 }
 342                                 return 0;
 343                         }
 344                         /* noiommu group found */
 345                 }
 346
 347                 cur_grp->group_num = iommu_group_num;
 348                 cur_grp->fd = vfio_group_fd;
 349                 vfio_cfg.vfio_active_groups++;
 350                 return vfio_group_fd;
 351         }
 352         /* if we're in a secondary process, request group fd from the primary
 353          * process via our socket
 354          */
 355         else {
 356                 int socket_fd, ret;
 357
 358                 socket_fd = vfio_mp_sync_connect_to_primary();
 359
 360                 if (socket_fd < 0) {
 361                         RTE_LOG(ERR, EAL, "  cannot connect to primary process!\n");
 362                         return -1;
 363                 }
 364                 if (vfio_mp_sync_send_request(socket_fd, SOCKET_REQ_GROUP) < 0) {
 365                         RTE_LOG(ERR, EAL, "  cannot request container fd!\n");
 366                         close(socket_fd);
 367                         return -1;
 368                 }
 369                 if (vfio_mp_sync_send_request(socket_fd, iommu_group_num) < 0) {
 370                         RTE_LOG(ERR, EAL, "  cannot send group number!\n");
 371                         close(socket_fd);
 372                         return -1;
 373                 }
 374                 ret = vfio_mp_sync_receive_request(socket_fd);
 375                 switch (ret) {
 376                 case SOCKET_NO_FD:
 377                         close(socket_fd);
 378                         return 0;
 379                 case SOCKET_OK:
 380                         vfio_group_fd = vfio_mp_sync_receive_fd(socket_fd);
 381                         /* if we got the fd, store it and return it */
 382                         if (vfio_group_fd > 0) {
 383                                 close(socket_fd);
 384                                 cur_grp->group_num = iommu_group_num;
 385                                 cur_grp->fd = vfio_group_fd;
 386                                 vfio_cfg.vfio_active_groups++;
 387                                 return vfio_group_fd;
 388                         }
 389                         /* fall-through on error */
 390                 default:
 391                         RTE_LOG(ERR, EAL, "  cannot get container fd!\n");
 392                         close(socket_fd);
 393                         return -1;
 394                 }
 395         }
 396         return -1;
 397 }
 398
 399
 400 static int
 401 get_vfio_group_idx(int vfio_group_fd)
 402 {
 403         int i;
 404         for (i = 0; i < VFIO_MAX_GROUPS; i++)
 405                 if (vfio_cfg.vfio_groups[i].fd == vfio_group_fd)
 406                         return i;
 407         return -1;
 408 }
 409
 410 static void
 411 vfio_group_device_get(int vfio_group_fd)
 412 {
 413         int i;
 414
 415         i = get_vfio_group_idx(vfio_group_fd);
 416         if (i < 0 || i > (VFIO_MAX_GROUPS - 1))
 417                 RTE_LOG(ERR, EAL, "  wrong vfio_group index (%d)\n", i);
 418         else
 419                 vfio_cfg.vfio_groups[i].devices++;
 420 }
 421
 422 static void
 423 vfio_group_device_put(int vfio_group_fd)
 424 {
 425         int i;
 426
 427         i = get_vfio_group_idx(vfio_group_fd);
 428         if (i < 0 || i > (VFIO_MAX_GROUPS - 1))
 429                 RTE_LOG(ERR, EAL, "  wrong vfio_group index (%d)\n", i);
 430         else
 431                 vfio_cfg.vfio_groups[i].devices--;
 432 }
 433
 434 static int
 435 vfio_group_device_count(int vfio_group_fd)
 436 {
 437         int i;
 438
 439         i = get_vfio_group_idx(vfio_group_fd);
 440         if (i < 0 || i > (VFIO_MAX_GROUPS - 1)) {
 441                 RTE_LOG(ERR, EAL, "  wrong vfio_group index (%d)\n", i);
 442                 return -1;
 443         }
 444
 445         return vfio_cfg.vfio_groups[i].devices;
 446 }
 447
 448 static void
 449 vfio_mem_event_callback(enum rte_mem_event type, const void *addr, size_t len)
 450 {
 451         struct rte_memseg_list *msl;
 452         struct rte_memseg *ms;
 453         size_t cur_len = 0;
 454
 455         msl = rte_mem_virt2memseg_list(addr);
 456
 457         /* for IOVA as VA mode, no need to care for IOVA addresses */
 458         if (rte_eal_iova_mode() == RTE_IOVA_VA) {
 459                 uint64_t vfio_va = (uint64_t)(uintptr_t)addr;
 460                 if (type == RTE_MEM_EVENT_ALLOC)
 461                         vfio_dma_mem_map(vfio_va, vfio_va, len, 1);
 462                 else
 463                         vfio_dma_mem_map(vfio_va, vfio_va, len, 0);
 464                 return;
 465         }
 466
 467         /* memsegs are contiguous in memory */
 468         ms = rte_mem_virt2memseg(addr, msl);
 469         while (cur_len < len) {
 470                 if (type == RTE_MEM_EVENT_ALLOC)
 471                         vfio_dma_mem_map(ms->addr_64, ms->iova, ms->len, 1);
 472                 else
 473                         vfio_dma_mem_map(ms->addr_64, ms->iova, ms->len, 0);
 474
 475                 cur_len += ms->len;
 476                 ++ms;
 477         }
 478 }
 479
 480 int
 481 rte_vfio_clear_group(int vfio_group_fd)
 482 {
 483         int i;
 484         int socket_fd, ret;
 485
 486         if (internal_config.process_type == RTE_PROC_PRIMARY) {
 487
 488                 i = get_vfio_group_idx(vfio_group_fd);
 489                 if (i < 0)
 490                         return -1;
 491                 vfio_cfg.vfio_groups[i].group_num = -1;
 492                 vfio_cfg.vfio_groups[i].fd = -1;
 493                 vfio_cfg.vfio_groups[i].devices = 0;
 494                 vfio_cfg.vfio_active_groups--;
 495                 return 0;
 496         }
 497
 498         /* This is just for SECONDARY processes */
 499         socket_fd = vfio_mp_sync_connect_to_primary();
 500
 501         if (socket_fd < 0) {
 502                 RTE_LOG(ERR, EAL, "  cannot connect to primary process!\n");
 503                 return -1;
 504         }
 505
 506         if (vfio_mp_sync_send_request(socket_fd, SOCKET_CLR_GROUP) < 0) {
 507                 RTE_LOG(ERR, EAL, "  cannot request container fd!\n");
 508                 close(socket_fd);
 509                 return -1;
 510         }
 511
 512         if (vfio_mp_sync_send_request(socket_fd, vfio_group_fd) < 0) {
 513                 RTE_LOG(ERR, EAL, "  cannot send group fd!\n");
 514                 close(socket_fd);
 515                 return -1;
 516         }
 517
 518         ret = vfio_mp_sync_receive_request(socket_fd);
 519         switch (ret) {
 520         case SOCKET_NO_FD:
 521                 RTE_LOG(ERR, EAL, "  BAD VFIO group fd!\n");
 522                 close(socket_fd);
 523                 break;
 524         case SOCKET_OK:
 525                 close(socket_fd);
 526                 return 0;
 527         case SOCKET_ERR:
 528                 RTE_LOG(ERR, EAL, "  Socket error\n");
 529                 close(socket_fd);
 530                 break;
 531         default:
 532                 RTE_LOG(ERR, EAL, "  UNKNOWN reply, %d\n", ret);
 533                 close(socket_fd);
 534         }
 535         return -1;
 536 }
 537
 538 int
 539 rte_vfio_setup_device(const char *sysfs_base, const char *dev_addr,
 540                 int *vfio_dev_fd, struct vfio_device_info *device_info)
 541 {
 542         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 543         rte_rwlock_t *mem_lock = &mcfg->memory_hotplug_lock;
 544         struct vfio_group_status group_status = {
 545                         .argsz = sizeof(group_status)
 546         };
 547         int vfio_group_fd;
 548         int iommu_group_num;
 549         int i, ret;
 550
 551         /* get group number */
 552         ret = rte_vfio_get_group_num(sysfs_base, dev_addr, &iommu_group_num);
 553         if (ret == 0) {
 554                 RTE_LOG(WARNING, EAL, "  %s not managed by VFIO driver, skipping\n",
 555                         dev_addr);
 556                 return 1;
 557         }
 558
 559         /* if negative, something failed */
 560         if (ret < 0)
 561                 return -1;
 562
 563         /* get the actual group fd */
 564         vfio_group_fd = rte_vfio_get_group_fd(iommu_group_num);
 565         if (vfio_group_fd < 0)
 566                 return -1;
 567
 568         /* if group_fd == 0, that means the device isn't managed by VFIO */
 569         if (vfio_group_fd == 0) {
 570                 RTE_LOG(WARNING, EAL, " %s not managed by VFIO driver, skipping\n",
 571                                 dev_addr);
 572                 return 1;
 573         }
 574
 575         /*
 576          * at this point, we know that this group is viable (meaning, all devices
 577          * are either bound to VFIO or not bound to anything)
 578          */
 579
 580         /* check if the group is viable */
 581         ret = ioctl(vfio_group_fd, VFIO_GROUP_GET_STATUS, &group_status);
 582         if (ret) {
 583                 RTE_LOG(ERR, EAL, "  %s cannot get group status, "
 584                                 "error %i (%s)\n", dev_addr, errno, strerror(errno));
 585                 close(vfio_group_fd);
 586                 rte_vfio_clear_group(vfio_group_fd);
 587                 return -1;
 588         } else if (!(group_status.flags & VFIO_GROUP_FLAGS_VIABLE)) {
 589                 RTE_LOG(ERR, EAL, "  %s VFIO group is not viable!\n", dev_addr);
 590                 close(vfio_group_fd);
 591                 rte_vfio_clear_group(vfio_group_fd);
 592                 return -1;
 593         }
 594
 595         /* check if group does not have a container yet */
 596         if (!(group_status.flags & VFIO_GROUP_FLAGS_CONTAINER_SET)) {
 597
 598                 /* add group to a container */
 599                 ret = ioctl(vfio_group_fd, VFIO_GROUP_SET_CONTAINER,
 600                                 &vfio_cfg.vfio_container_fd);
 601                 if (ret) {
 602                         RTE_LOG(ERR, EAL, "  %s cannot add VFIO group to container, "
 603                                         "error %i (%s)\n", dev_addr, errno, strerror(errno));
 604                         close(vfio_group_fd);
 605                         rte_vfio_clear_group(vfio_group_fd);
 606                         return -1;
 607                 }
 608
 609                 /*
 610                  * pick an IOMMU type and set up DMA mappings for container
 611                  *
 612                  * needs to be done only once, only when first group is
 613                  * assigned to a container and only in primary process.
 614                  * Note this can happen several times with the hotplug
 615                  * functionality.
 616                  */
 617                 if (internal_config.process_type == RTE_PROC_PRIMARY &&
 618                                 vfio_cfg.vfio_active_groups == 1) {
 619                         const struct vfio_iommu_type *t;
 620
 621                         /* select an IOMMU type which we will be using */
 622                         t = vfio_set_iommu_type(vfio_cfg.vfio_container_fd);
 623                         if (!t) {
 624                                 RTE_LOG(ERR, EAL,
 625                                         "  %s failed to select IOMMU type\n",
 626                                         dev_addr);
 627                                 close(vfio_group_fd);
 628                                 rte_vfio_clear_group(vfio_group_fd);
 629                                 return -1;
 630                         }
 631                         /* lock memory hotplug before mapping and release it
 632                          * after registering callback, to prevent races
 633                          */
 634                         rte_rwlock_read_lock(mem_lock);
 635                         ret = t->dma_map_func(vfio_cfg.vfio_container_fd);
 636                         if (ret) {
 637                                 RTE_LOG(ERR, EAL,
 638                                         "  %s DMA remapping failed, error %i (%s)\n",
 639                                         dev_addr, errno, strerror(errno));
 640                                 close(vfio_group_fd);
 641                                 rte_vfio_clear_group(vfio_group_fd);
 642                                 rte_rwlock_read_unlock(mem_lock);
 643                                 return -1;
 644                         }
 645
 646                         vfio_cfg.vfio_iommu_type = t;
 647
 648                         /* re-map all user-mapped segments */
 649                         rte_spinlock_recursive_lock(&user_mem_maps.lock);
 650
 651                         /* this IOMMU type may not support DMA mapping, but
 652                          * if we have mappings in the list - that means we have
 653                          * previously mapped something successfully, so we can
 654                          * be sure that DMA mapping is supported.
 655                          */
 656                         for (i = 0; i < user_mem_maps.n_maps; i++) {
 657                                 struct user_mem_map *map;
 658                                 map = &user_mem_maps.maps[i];
 659
 660                                 ret = t->dma_user_map_func(
 661                                                 vfio_cfg.vfio_container_fd,
 662                                                 map->addr, map->iova, map->len,
 663                                                 1);
 664                                 if (ret) {
 665                                         RTE_LOG(ERR, EAL, "Couldn't map user memory for DMA: "
 666                                                         "va: 0x%" PRIx64 " "
 667                                                         "iova: 0x%" PRIx64 " "
 668                                                         "len: 0x%" PRIu64 "\n",
 669                                                         map->addr, map->iova,
 670                                                         map->len);
 671                                         rte_spinlock_recursive_unlock(
 672                                                         &user_mem_maps.lock);
 673                                         rte_rwlock_read_unlock(mem_lock);
 674                                         return -1;
 675                                 }
 676                         }
 677                         rte_spinlock_recursive_unlock(&user_mem_maps.lock);
 678
 679                         /* register callback for mem events */
 680                         ret = rte_mem_event_callback_register(
 681                                         VFIO_MEM_EVENT_CLB_NAME,
 682                                         vfio_mem_event_callback);
 683                         /* unlock memory hotplug */
 684                         rte_rwlock_read_unlock(mem_lock);
 685
 686                         if (ret && rte_errno != ENOTSUP) {
 687                                 RTE_LOG(ERR, EAL, "Could not install memory event callback for VFIO\n");
 688                                 return -1;
 689                         }
 690                         if (ret)
 691                                 RTE_LOG(DEBUG, EAL, "Memory event callbacks not supported\n");
 692                         else
 693                                 RTE_LOG(DEBUG, EAL, "Installed memory event callback for VFIO\n");
 694                 }
 695         }
 696
 697         /* get a file descriptor for the device */
 698         *vfio_dev_fd = ioctl(vfio_group_fd, VFIO_GROUP_GET_DEVICE_FD, dev_addr);
 699         if (*vfio_dev_fd < 0) {
 700                 /* if we cannot get a device fd, this implies a problem with
 701                  * the VFIO group or the container not having IOMMU configured.
 702                  */
 703
 704                 RTE_LOG(WARNING, EAL, "Getting a vfio_dev_fd for %s failed\n",
 705                                 dev_addr);
 706                 close(vfio_group_fd);
 707                 rte_vfio_clear_group(vfio_group_fd);
 708                 return -1;
 709         }
 710
 711         /* test and setup the device */
 712         ret = ioctl(*vfio_dev_fd, VFIO_DEVICE_GET_INFO, device_info);
 713         if (ret) {
 714                 RTE_LOG(ERR, EAL, "  %s cannot get device info, "
 715                                 "error %i (%s)\n", dev_addr, errno,
 716                                 strerror(errno));
 717                 close(*vfio_dev_fd);
 718                 close(vfio_group_fd);
 719                 rte_vfio_clear_group(vfio_group_fd);
 720                 return -1;
 721         }
 722         vfio_group_device_get(vfio_group_fd);
 723
 724         return 0;
 725 }
 726
 727 int
 728 rte_vfio_release_device(const char *sysfs_base, const char *dev_addr,
 729                     int vfio_dev_fd)
 730 {
 731         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 732         rte_rwlock_t *mem_lock = &mcfg->memory_hotplug_lock;
 733         struct vfio_group_status group_status = {
 734                         .argsz = sizeof(group_status)
 735         };
 736         int vfio_group_fd;
 737         int iommu_group_num;
 738         int ret;
 739
 740         /* we don't want any DMA mapping messages to come while we're detaching
 741          * VFIO device, because this might be the last device and we might need
 742          * to unregister the callback.
 743          */
 744         rte_rwlock_read_lock(mem_lock);
 745
 746         /* get group number */
 747         ret = rte_vfio_get_group_num(sysfs_base, dev_addr, &iommu_group_num);
 748         if (ret <= 0) {
 749                 RTE_LOG(WARNING, EAL, "  %s not managed by VFIO driver\n",
 750                         dev_addr);
 751                 /* This is an error at this point. */
 752                 ret = -1;
 753                 goto out;
 754         }
 755
 756         /* get the actual group fd */
 757         vfio_group_fd = rte_vfio_get_group_fd(iommu_group_num);
 758         if (vfio_group_fd <= 0) {
 759                 RTE_LOG(INFO, EAL, "rte_vfio_get_group_fd failed for %s\n",
 760                                    dev_addr);
 761                 ret = -1;
 762                 goto out;
 763         }
 764
 765         /* At this point we got an active group. Closing it will make the
 766          * container detachment. If this is the last active group, VFIO kernel
 767          * code will unset the container and the IOMMU mappings.
 768          */
 769
 770         /* Closing a device */
 771         if (close(vfio_dev_fd) < 0) {
 772                 RTE_LOG(INFO, EAL, "Error when closing vfio_dev_fd for %s\n",
 773                                    dev_addr);
 774                 ret = -1;
 775                 goto out;
 776         }
 777
 778         /* An VFIO group can have several devices attached. Just when there is
 779          * no devices remaining should the group be closed.
 780          */
 781         vfio_group_device_put(vfio_group_fd);
 782         if (!vfio_group_device_count(vfio_group_fd)) {
 783
 784                 if (close(vfio_group_fd) < 0) {
 785                         RTE_LOG(INFO, EAL, "Error when closing vfio_group_fd for %s\n",
 786                                 dev_addr);
 787                         ret = -1;
 788                         goto out;
 789                 }
 790
 791                 if (rte_vfio_clear_group(vfio_group_fd) < 0) {
 792                         RTE_LOG(INFO, EAL, "Error when clearing group for %s\n",
 793                                            dev_addr);
 794                         ret = -1;
 795                         goto out;
 796                 }
 797         }
 798
 799         /* if there are no active device groups, unregister the callback to
 800          * avoid spurious attempts to map/unmap memory from VFIO.
 801          */
 802         if (vfio_cfg.vfio_active_groups == 0)
 803                 rte_mem_event_callback_unregister(VFIO_MEM_EVENT_CLB_NAME);
 804
 805         /* success */
 806         ret = 0;
 807
 808 out:
 809         rte_rwlock_read_unlock(mem_lock);
 810         return ret;
 811 }
 812
 813 int
 814 rte_vfio_enable(const char *modname)
 815 {
 816         /* initialize group list */
 817         int i;
 818         int vfio_available;
 819
 820         for (i = 0; i < VFIO_MAX_GROUPS; i++) {
 821                 vfio_cfg.vfio_groups[i].fd = -1;
 822                 vfio_cfg.vfio_groups[i].group_num = -1;
 823                 vfio_cfg.vfio_groups[i].devices = 0;
 824         }
 825
 826         /* inform the user that we are probing for VFIO */
 827         RTE_LOG(INFO, EAL, "Probing VFIO support...\n");
 828
 829         /* check if vfio module is loaded */
 830         vfio_available = rte_eal_check_module(modname);
 831
 832         /* return error directly */
 833         if (vfio_available == -1) {
 834                 RTE_LOG(INFO, EAL, "Could not get loaded module details!\n");
 835                 return -1;
 836         }
 837
 838         /* return 0 if VFIO modules not loaded */
 839         if (vfio_available == 0) {
 840                 RTE_LOG(DEBUG, EAL, "VFIO modules not loaded, "
 841                         "skipping VFIO support...\n");
 842                 return 0;
 843         }
 844
 845         vfio_cfg.vfio_container_fd = rte_vfio_get_container_fd();
 846
 847         /* check if we have VFIO driver enabled */
 848         if (vfio_cfg.vfio_container_fd != -1) {
 849                 RTE_LOG(NOTICE, EAL, "VFIO support initialized\n");
 850                 vfio_cfg.vfio_enabled = 1;
 851         } else {
 852                 RTE_LOG(NOTICE, EAL, "VFIO support could not be initialized\n");
 853         }
 854
 855         return 0;
 856 }
 857
 858 int
 859 rte_vfio_is_enabled(const char *modname)
 860 {
 861         const int mod_available = rte_eal_check_module(modname) > 0;
 862         return vfio_cfg.vfio_enabled && mod_available;
 863 }
 864
 865 const struct vfio_iommu_type *
 866 vfio_set_iommu_type(int vfio_container_fd)
 867 {
 868         unsigned idx;
 869         for (idx = 0; idx < RTE_DIM(iommu_types); idx++) {
 870                 const struct vfio_iommu_type *t = &iommu_types[idx];
 871
 872                 int ret = ioctl(vfio_container_fd, VFIO_SET_IOMMU,
 873                                 t->type_id);
 874                 if (!ret) {
 875                         RTE_LOG(NOTICE, EAL, "  using IOMMU type %d (%s)\n",
 876                                         t->type_id, t->name);
 877                         return t;
 878                 }
 879                 /* not an error, there may be more supported IOMMU types */
 880                 RTE_LOG(DEBUG, EAL, "  set IOMMU type %d (%s) failed, "
 881                                 "error %i (%s)\n", t->type_id, t->name, errno,
 882                                 strerror(errno));
 883         }
 884         /* if we didn't find a suitable IOMMU type, fail */
 885         return NULL;
 886 }
 887
 888 int
 889 vfio_has_supported_extensions(int vfio_container_fd)
 890 {
 891         int ret;
 892         unsigned idx, n_extensions = 0;
 893         for (idx = 0; idx < RTE_DIM(iommu_types); idx++) {
 894                 const struct vfio_iommu_type *t = &iommu_types[idx];
 895
 896                 ret = ioctl(vfio_container_fd, VFIO_CHECK_EXTENSION,
 897                                 t->type_id);
 898                 if (ret < 0) {
 899                         RTE_LOG(ERR, EAL, "  could not get IOMMU type, "
 900                                 "error %i (%s)\n", errno,
 901                                 strerror(errno));
 902                         close(vfio_container_fd);
 903                         return -1;
 904                 } else if (ret == 1) {
 905                         /* we found a supported extension */
 906                         n_extensions++;
 907                 }
 908                 RTE_LOG(DEBUG, EAL, "  IOMMU type %d (%s) is %s\n",
 909                                 t->type_id, t->name,
 910                                 ret ? "supported" : "not supported");
 911         }
 912
 913         /* if we didn't find any supported IOMMU types, fail */
 914         if (!n_extensions) {
 915                 close(vfio_container_fd);
 916                 return -1;
 917         }
 918
 919         return 0;
 920 }
 921
 922 int
 923 rte_vfio_get_container_fd(void)
 924 {
 925         int ret, vfio_container_fd;
 926
 927         /* if we're in a primary process, try to open the container */
 928         if (internal_config.process_type == RTE_PROC_PRIMARY) {
 929                 vfio_container_fd = open(VFIO_CONTAINER_PATH, O_RDWR);
 930                 if (vfio_container_fd < 0) {
 931                         RTE_LOG(ERR, EAL, "  cannot open VFIO container, "
 932                                         "error %i (%s)\n", errno, strerror(errno));
 933                         return -1;
 934                 }
 935
 936                 /* check VFIO API version */
 937                 ret = ioctl(vfio_container_fd, VFIO_GET_API_VERSION);
 938                 if (ret != VFIO_API_VERSION) {
 939                         if (ret < 0)
 940                                 RTE_LOG(ERR, EAL, "  could not get VFIO API version, "
 941                                                 "error %i (%s)\n", errno, strerror(errno));
 942                         else
 943                                 RTE_LOG(ERR, EAL, "  unsupported VFIO API version!\n");
 944                         close(vfio_container_fd);
 945                         return -1;
 946                 }
 947
 948                 ret = vfio_has_supported_extensions(vfio_container_fd);
 949                 if (ret) {
 950                         RTE_LOG(ERR, EAL, "  no supported IOMMU "
 951                                         "extensions found!\n");
 952                         return -1;
 953                 }
 954
 955                 return vfio_container_fd;
 956         } else {
 957                 /*
 958                  * if we're in a secondary process, request container fd from the
 959                  * primary process via our socket
 960                  */
 961                 int socket_fd;
 962
 963                 socket_fd = vfio_mp_sync_connect_to_primary();
 964                 if (socket_fd < 0) {
 965                         RTE_LOG(ERR, EAL, "  cannot connect to primary process!\n");
 966                         return -1;
 967                 }
 968                 if (vfio_mp_sync_send_request(socket_fd, SOCKET_REQ_CONTAINER) < 0) {
 969                         RTE_LOG(ERR, EAL, "  cannot request container fd!\n");
 970                         close(socket_fd);
 971                         return -1;
 972                 }
 973                 vfio_container_fd = vfio_mp_sync_receive_fd(socket_fd);
 974                 if (vfio_container_fd < 0) {
 975                         RTE_LOG(ERR, EAL, "  cannot get container fd!\n");
 976                         close(socket_fd);
 977                         return -1;
 978                 }
 979                 close(socket_fd);
 980                 return vfio_container_fd;
 981         }
 982
 983         return -1;
 984 }
 985
 986 int
 987 rte_vfio_get_group_num(const char *sysfs_base,
 988                 const char *dev_addr, int *iommu_group_num)
 989 {
 990         char linkname[PATH_MAX];
 991         char filename[PATH_MAX];
 992         char *tok[16], *group_tok, *end;
 993         int ret;
 994
 995         memset(linkname, 0, sizeof(linkname));
 996         memset(filename, 0, sizeof(filename));
 997
 998         /* try to find out IOMMU group for this device */
 999         snprintf(linkname, sizeof(linkname),
1000                          "%s/%s/iommu_group", sysfs_base, dev_addr);
1001
1002         ret = readlink(linkname, filename, sizeof(filename));
1003
1004         /* if the link doesn't exist, no VFIO for us */
1005         if (ret < 0)
1006                 return 0;
1007
1008         ret = rte_strsplit(filename, sizeof(filename),
1009                         tok, RTE_DIM(tok), '/');
1010
1011         if (ret <= 0) {
1012                 RTE_LOG(ERR, EAL, "  %s cannot get IOMMU group\n", dev_addr);
1013                 return -1;
1014         }
1015
1016         /* IOMMU group is always the last token */
1017         errno = 0;
1018         group_tok = tok[ret - 1];
1019         end = group_tok;
1020         *iommu_group_num = strtol(group_tok, &end, 10);
1021         if ((end != group_tok && *end != '\0') || errno != 0) {
1022                 RTE_LOG(ERR, EAL, "  %s error parsing IOMMU number!\n", dev_addr);
1023                 return -1;
1024         }
1025
1026         return 1;
1027 }
1028
1029 static int
1030 type1_map(const struct rte_memseg_list *msl __rte_unused,
1031                 const struct rte_memseg *ms, void *arg)
1032 {
1033         int *vfio_container_fd = arg;
1034
1035         return vfio_type1_dma_mem_map(*vfio_container_fd, ms->addr_64, ms->iova,
1036                         ms->len, 1);
1037 }
1038
1039 static int
1040 vfio_type1_dma_mem_map(int vfio_container_fd, uint64_t vaddr, uint64_t iova,
1041                 uint64_t len, int do_map)
1042 {
1043         struct vfio_iommu_type1_dma_map dma_map;
1044         struct vfio_iommu_type1_dma_unmap dma_unmap;
1045         int ret;
1046
1047         if (do_map != 0) {
1048                 memset(&dma_map, 0, sizeof(dma_map));
1049                 dma_map.argsz = sizeof(struct vfio_iommu_type1_dma_map);
1050                 dma_map.vaddr = vaddr;
1051                 dma_map.size = len;
1052                 dma_map.iova = iova;
1053                 dma_map.flags = VFIO_DMA_MAP_FLAG_READ |
1054                                 VFIO_DMA_MAP_FLAG_WRITE;
1055
1056                 ret = ioctl(vfio_container_fd, VFIO_IOMMU_MAP_DMA, &dma_map);
1057                 if (ret) {
1058                         RTE_LOG(ERR, EAL, "  cannot set up DMA remapping, error %i (%s)\n",
1059                                 errno, strerror(errno));
1060                                 return -1;
1061                 }
1062         } else {
1063                 memset(&dma_unmap, 0, sizeof(dma_unmap));
1064                 dma_unmap.argsz = sizeof(struct vfio_iommu_type1_dma_unmap);
1065                 dma_unmap.size = len;
1066                 dma_unmap.iova = iova;
1067
1068                 ret = ioctl(vfio_container_fd, VFIO_IOMMU_UNMAP_DMA,
1069                                 &dma_unmap);
1070                 if (ret) {
1071                         RTE_LOG(ERR, EAL, "  cannot clear DMA remapping, error %i (%s)\n",
1072                                         errno, strerror(errno));
1073                         return -1;
1074                 }
1075         }
1076
1077         return 0;
1078 }
1079
1080 static int
1081 vfio_type1_dma_map(int vfio_container_fd)
1082 {
1083         return rte_memseg_walk(type1_map, &vfio_container_fd);
1084 }
1085
1086 static int
1087 vfio_spapr_dma_do_map(int vfio_container_fd, uint64_t vaddr, uint64_t iova,
1088                 uint64_t len, int do_map)
1089 {
1090         struct vfio_iommu_type1_dma_map dma_map;
1091         struct vfio_iommu_type1_dma_unmap dma_unmap;
1092         int ret;
1093
1094         if (do_map != 0) {
1095                 memset(&dma_map, 0, sizeof(dma_map));
1096                 dma_map.argsz = sizeof(struct vfio_iommu_type1_dma_map);
1097                 dma_map.vaddr = vaddr;
1098                 dma_map.size = len;
1099                 dma_map.iova = iova;
1100                 dma_map.flags = VFIO_DMA_MAP_FLAG_READ |
1101                                 VFIO_DMA_MAP_FLAG_WRITE;
1102
1103                 ret = ioctl(vfio_container_fd, VFIO_IOMMU_MAP_DMA, &dma_map);
1104                 if (ret) {
1105                         RTE_LOG(ERR, EAL, "  cannot set up DMA remapping, error %i (%s)\n",
1106                                 errno, strerror(errno));
1107                                 return -1;
1108                 }
1109
1110         } else {
1111                 struct vfio_iommu_spapr_register_memory reg = {
1112                         .argsz = sizeof(reg),
1113                         .flags = 0
1114                 };
1115                 reg.vaddr = (uintptr_t) vaddr;
1116                 reg.size = len;
1117
1118                 ret = ioctl(vfio_container_fd,
1119                                 VFIO_IOMMU_SPAPR_UNREGISTER_MEMORY, &reg);
1120                 if (ret) {
1121                         RTE_LOG(ERR, EAL, "  cannot unregister vaddr for IOMMU, error %i (%s)\n",
1122                                         errno, strerror(errno));
1123                         return -1;
1124                 }
1125
1126                 memset(&dma_unmap, 0, sizeof(dma_unmap));
1127                 dma_unmap.argsz = sizeof(struct vfio_iommu_type1_dma_unmap);
1128                 dma_unmap.size = len;
1129                 dma_unmap.iova = iova;
1130
1131                 ret = ioctl(vfio_container_fd, VFIO_IOMMU_UNMAP_DMA,
1132                                 &dma_unmap);
1133                 if (ret) {
1134                         RTE_LOG(ERR, EAL, "  cannot clear DMA remapping, error %i (%s)\n",
1135                                         errno, strerror(errno));
1136                         return -1;
1137                 }
1138         }
1139
1140         return 0;
1141 }
1142
1143 static int
1144 vfio_spapr_map_walk(const struct rte_memseg_list *msl __rte_unused,
1145                 const struct rte_memseg *ms, void *arg)
1146 {
1147         int *vfio_container_fd = arg;
1148
1149         return vfio_spapr_dma_mem_map(*vfio_container_fd, ms->addr_64, ms->iova,
1150                         ms->len, 1);
1151 }
1152
1153 struct spapr_walk_param {
1154         uint64_t window_size;
1155         uint64_t hugepage_sz;
1156 };
1157 static int
1158 vfio_spapr_window_size_walk(const struct rte_memseg_list *msl __rte_unused,
1159                 const struct rte_memseg *ms, void *arg)
1160 {
1161         struct spapr_walk_param *param = arg;
1162         uint64_t max = ms->iova + ms->len;
1163
1164         if (max > param->window_size) {
1165                 param->hugepage_sz = ms->hugepage_sz;
1166                 param->window_size = max;
1167         }
1168
1169         return 0;
1170 }
1171
1172 static int
1173 vfio_spapr_create_new_dma_window(int vfio_container_fd,
1174                 struct vfio_iommu_spapr_tce_create *create) {
1175         struct vfio_iommu_spapr_tce_remove remove = {
1176                 .argsz = sizeof(remove),
1177         };
1178         struct vfio_iommu_spapr_tce_info info = {
1179                 .argsz = sizeof(info),
1180         };
1181         int ret;
1182
1183         /* query spapr iommu info */
1184         ret = ioctl(vfio_container_fd, VFIO_IOMMU_SPAPR_TCE_GET_INFO, &info);
1185         if (ret) {
1186                 RTE_LOG(ERR, EAL, "  cannot get iommu info, "
1187                                 "error %i (%s)\n", errno, strerror(errno));
1188                 return -1;
1189         }
1190
1191         /* remove default DMA of 32 bit window */
1192         remove.start_addr = info.dma32_window_start;
1193         ret = ioctl(vfio_container_fd, VFIO_IOMMU_SPAPR_TCE_REMOVE, &remove);
1194         if (ret) {
1195                 RTE_LOG(ERR, EAL, "  cannot remove default DMA window, "
1196                                 "error %i (%s)\n", errno, strerror(errno));
1197                 return -1;
1198         }
1199
1200         /* create new DMA window */
1201         ret = ioctl(vfio_container_fd, VFIO_IOMMU_SPAPR_TCE_CREATE, create);
1202         if (ret) {
1203                 RTE_LOG(ERR, EAL, "  cannot create new DMA window, "
1204                                 "error %i (%s)\n", errno, strerror(errno));
1205                 return -1;
1206         }
1207
1208         if (create->start_addr != 0) {
1209                 RTE_LOG(ERR, EAL, "  DMA window start address != 0\n");
1210                 return -1;
1211         }
1212
1213         return 0;
1214 }
1215
1216 static int
1217 vfio_spapr_dma_mem_map(int vfio_container_fd, uint64_t vaddr, uint64_t iova,
1218                 uint64_t len, int do_map)
1219 {
1220         struct spapr_walk_param param;
1221         struct vfio_iommu_spapr_tce_create create = {
1222                 .argsz = sizeof(create),
1223         };
1224         int i, ret = 0;
1225
1226         rte_spinlock_recursive_lock(&user_mem_maps.lock);
1227
1228         /* check if window size needs to be adjusted */
1229         memset(&param, 0, sizeof(param));
1230
1231         if (memseg_walk_thread_unsafe(vfio_spapr_window_size_walk,
1232                                 &param) < 0) {
1233                 RTE_LOG(ERR, EAL, "Could not get window size\n");
1234                 ret = -1;
1235                 goto out;
1236         }
1237
1238         /* also check user maps */
1239         for (i = 0; i < user_mem_maps.n_maps; i++) {
1240                 uint64_t max = user_mem_maps.maps[i].iova +
1241                                 user_mem_maps.maps[i].len;
1242                 create.window_size = RTE_MAX(create.window_size, max);
1243         }
1244
1245         /* sPAPR requires window size to be a power of 2 */
1246         create.window_size = rte_align64pow2(param.window_size);
1247         create.page_shift = __builtin_ctzll(param.hugepage_sz);
1248         create.levels = 1;
1249
1250         if (do_map) {
1251                 void *addr;
1252                 /* re-create window and remap the entire memory */
1253                 if (iova > create.window_size) {
1254                         if (vfio_spapr_create_new_dma_window(vfio_container_fd,
1255                                         &create) < 0) {
1256                                 RTE_LOG(ERR, EAL, "Could not create new DMA window\n");
1257                                 ret = -1;
1258                                 goto out;
1259                         }
1260                         if (memseg_walk_thread_unsafe(vfio_spapr_map_walk,
1261                                         &vfio_container_fd) < 0) {
1262                                 RTE_LOG(ERR, EAL, "Could not recreate DMA maps\n");
1263                                 ret = -1;
1264                                 goto out;
1265                         }
1266                         /* remap all user maps */
1267                         for (i = 0; i < user_mem_maps.n_maps; i++) {
1268                                 struct user_mem_map *map =
1269                                                 &user_mem_maps.maps[i];
1270                                 if (vfio_spapr_dma_do_map(vfio_container_fd,
1271                                                 map->addr, map->iova, map->len,
1272                                                 1)) {
1273                                         RTE_LOG(ERR, EAL, "Could not recreate user DMA maps\n");
1274                                         ret = -1;
1275                                         goto out;
1276                                 }
1277                         }
1278                 }
1279
1280                 /* now that we've remapped all of the memory that was present
1281                  * before, map the segment that we were requested to map.
1282                  *
1283                  * however, if we were called by the callback, the memory we
1284                  * were called with was already in the memseg list, so previous
1285                  * mapping should've mapped that segment already.
1286                  *
1287                  * virt2memseg_list is a relatively cheap check, so use that. if
1288                  * memory is within any memseg list, it's a memseg, so it's
1289                  * already mapped.
1290                  */
1291                 addr = (void *)(uintptr_t)vaddr;
1292                 if (rte_mem_virt2memseg_list(addr) == NULL &&
1293                                 vfio_spapr_dma_do_map(vfio_container_fd,
1294                                         vaddr, iova, len, 1) < 0) {
1295                         RTE_LOG(ERR, EAL, "Could not map segment\n");
1296                         ret = -1;
1297                         goto out;
1298                 }
1299         } else {
1300                 /* for unmap, check if iova within DMA window */
1301                 if (iova > create.window_size) {
1302                         RTE_LOG(ERR, EAL, "iova beyond DMA window for unmap");
1303                         ret = -1;
1304                         goto out;
1305                 }
1306
1307                 vfio_spapr_dma_do_map(vfio_container_fd, vaddr, iova, len, 0);
1308         }
1309 out:
1310         rte_spinlock_recursive_unlock(&user_mem_maps.lock);
1311         return ret;
1312 }
1313
1314 static int
1315 vfio_spapr_dma_map(int vfio_container_fd)
1316 {
1317         struct vfio_iommu_spapr_tce_create create = {
1318                 .argsz = sizeof(create),
1319         };
1320         struct spapr_walk_param param;
1321
1322         memset(&param, 0, sizeof(param));
1323
1324         /* create DMA window from 0 to max(phys_addr + len) */
1325         rte_memseg_walk(vfio_spapr_window_size_walk, &param);
1326
1327         /* sPAPR requires window size to be a power of 2 */
1328         create.window_size = rte_align64pow2(param.window_size);
1329         create.page_shift = __builtin_ctzll(param.hugepage_sz);
1330         create.levels = 1;
1331
1332         if (vfio_spapr_create_new_dma_window(vfio_container_fd, &create) < 0) {
1333                 RTE_LOG(ERR, EAL, "Could not create new DMA window\n");
1334                 return -1;
1335         }
1336
1337         /* map all DPDK segments for DMA. use 1:1 PA to IOVA mapping */
1338         if (rte_memseg_walk(vfio_spapr_map_walk, &vfio_container_fd) < 0)
1339                 return -1;
1340
1341         return 0;
1342 }
1343
1344 static int
1345 vfio_noiommu_dma_map(int __rte_unused vfio_container_fd)
1346 {
1347         /* No-IOMMU mode does not need DMA mapping */
1348         return 0;
1349 }
1350
1351 static int
1352 vfio_noiommu_dma_mem_map(int __rte_unused vfio_container_fd,
1353                          uint64_t __rte_unused vaddr,
1354                          uint64_t __rte_unused iova, uint64_t __rte_unused len,
1355                          int __rte_unused do_map)
1356 {
1357         /* No-IOMMU mode does not need DMA mapping */
1358         return 0;
1359 }
1360
1361 static int
1362 vfio_dma_mem_map(uint64_t vaddr, uint64_t iova, uint64_t len, int do_map)
1363 {
1364         const struct vfio_iommu_type *t = vfio_cfg.vfio_iommu_type;
1365
1366         if (!t) {
1367                 RTE_LOG(ERR, EAL, "  VFIO support not initialized\n");
1368                 rte_errno = ENODEV;
1369                 return -1;
1370         }
1371
1372         if (!t->dma_user_map_func) {
1373                 RTE_LOG(ERR, EAL,
1374                         "  VFIO custom DMA region maping not supported by IOMMU %s\n",
1375                         t->name);
1376                 rte_errno = ENOTSUP;
1377                 return -1;
1378         }
1379
1380         return t->dma_user_map_func(vfio_cfg.vfio_container_fd, vaddr, iova,
1381                         len, do_map);
1382 }
1383
1384 int __rte_experimental
1385 rte_vfio_dma_map(uint64_t vaddr, uint64_t iova, uint64_t len)
1386 {
1387         struct user_mem_map *new_map;
1388         int ret = 0;
1389
1390         if (len == 0) {
1391                 rte_errno = EINVAL;
1392                 return -1;
1393         }
1394
1395         rte_spinlock_recursive_lock(&user_mem_maps.lock);
1396         if (user_mem_maps.n_maps == VFIO_MAX_USER_MEM_MAPS) {
1397                 RTE_LOG(ERR, EAL, "No more space for user mem maps\n");
1398                 rte_errno = ENOMEM;
1399                 ret = -1;
1400                 goto out;
1401         }
1402         /* map the entry */
1403         if (vfio_dma_mem_map(vaddr, iova, len, 1)) {
1404                 /* technically, this will fail if there are currently no devices
1405                  * plugged in, even if a device were added later, this mapping
1406                  * might have succeeded. however, since we cannot verify if this
1407                  * is a valid mapping without having a device attached, consider
1408                  * this to be unsupported, because we can't just store any old
1409                  * mapping and pollute list of active mappings willy-nilly.
1410                  */
1411                 RTE_LOG(ERR, EAL, "Couldn't map new region for DMA\n");
1412                 ret = -1;
1413                 goto out;
1414         }
1415         /* create new user mem map entry */
1416         new_map = &user_mem_maps.maps[user_mem_maps.n_maps++];
1417         new_map->addr = vaddr;
1418         new_map->iova = iova;
1419         new_map->len = len;
1420
1421         compact_user_maps();
1422 out:
1423         rte_spinlock_recursive_unlock(&user_mem_maps.lock);
1424         return ret;
1425 }
1426
1427 int __rte_experimental
1428 rte_vfio_dma_unmap(uint64_t vaddr, uint64_t iova, uint64_t len)
1429 {
1430         struct user_mem_map *map, *new_map = NULL;
1431         int ret = 0;
1432
1433         if (len == 0) {
1434                 rte_errno = EINVAL;
1435                 return -1;
1436         }
1437
1438         rte_spinlock_recursive_lock(&user_mem_maps.lock);
1439
1440         /* find our mapping */
1441         map = find_user_mem_map(vaddr, iova, len);
1442         if (!map) {
1443                 RTE_LOG(ERR, EAL, "Couldn't find previously mapped region\n");
1444                 rte_errno = EINVAL;
1445                 ret = -1;
1446                 goto out;
1447         }
1448         if (map->addr != vaddr || map->iova != iova || map->len != len) {
1449                 /* we're partially unmapping a previously mapped region, so we
1450                  * need to split entry into two.
1451                  */
1452                 if (user_mem_maps.n_maps == VFIO_MAX_USER_MEM_MAPS) {
1453                         RTE_LOG(ERR, EAL, "Not enough space to store partial mapping\n");
1454                         rte_errno = ENOMEM;
1455                         ret = -1;
1456                         goto out;
1457                 }
1458                 new_map = &user_mem_maps.maps[user_mem_maps.n_maps++];
1459         }
1460
1461         /* unmap the entry */
1462         if (vfio_dma_mem_map(vaddr, iova, len, 0)) {
1463                 /* there may not be any devices plugged in, so unmapping will
1464                  * fail with ENODEV/ENOTSUP rte_errno values, but that doesn't
1465                  * stop us from removing the mapping, as the assumption is we
1466                  * won't be needing this memory any more and thus will want to
1467                  * prevent it from being remapped again on hotplug. so, only
1468                  * fail if we indeed failed to unmap (e.g. if the mapping was
1469                  * within our mapped range but had invalid alignment).
1470                  */
1471                 if (rte_errno != ENODEV && rte_errno != ENOTSUP) {
1472                         RTE_LOG(ERR, EAL, "Couldn't unmap region for DMA\n");
1473                         ret = -1;
1474                         goto out;
1475                 } else {
1476                         RTE_LOG(DEBUG, EAL, "DMA unmapping failed, but removing mappings anyway\n");
1477                 }
1478         }
1479         /* remove map from the list of active mappings */
1480         if (new_map != NULL) {
1481                 adjust_map(map, new_map, vaddr, len);
1482
1483                 /* if we've created a new map by splitting, sort everything */
1484                 if (!is_null_map(new_map)) {
1485                         compact_user_maps();
1486                 } else {
1487                         /* we've created a new mapping, but it was unused */
1488                         user_mem_maps.n_maps--;
1489                 }
1490         } else {
1491                 memset(map, 0, sizeof(*map));
1492                 compact_user_maps();
1493                 user_mem_maps.n_maps--;
1494         }
1495
1496 out:
1497         rte_spinlock_recursive_unlock(&user_mem_maps.lock);
1498         return ret;
1499 }
1500
1501 int
1502 rte_vfio_noiommu_is_enabled(void)
1503 {
1504         int fd;
1505         ssize_t cnt;
1506         char c;
1507
1508         fd = open(VFIO_NOIOMMU_MODE, O_RDONLY);
1509         if (fd < 0) {
1510                 if (errno != ENOENT) {
1511                         RTE_LOG(ERR, EAL, "  cannot open vfio noiommu file %i (%s)\n",
1512                                         errno, strerror(errno));
1513                         return -1;
1514                 }
1515                 /*
1516                  * else the file does not exists
1517                  * i.e. noiommu is not enabled
1518                  */
1519                 return 0;
1520         }
1521
1522         cnt = read(fd, &c, 1);
1523         close(fd);
1524         if (cnt != 1) {
1525                 RTE_LOG(ERR, EAL, "  unable to read from vfio noiommu "
1526                                 "file %i (%s)\n", errno, strerror(errno));
1527                 return -1;
1528         }
1529
1530         return c == 'Y';
1531 }
1532
1533 #else
1534
1535 int __rte_experimental
1536 rte_vfio_dma_map(uint64_t __rte_unused vaddr, __rte_unused uint64_t iova,
1537                   __rte_unused uint64_t len)
1538 {
1539         return -1;
1540 }
1541
1542 int __rte_experimental
1543 rte_vfio_dma_unmap(uint64_t __rte_unused vaddr, uint64_t __rte_unused iova,
1544                     __rte_unused uint64_t len)
1545 {
1546         return -1;
1547 }
1548
1549 #endif