drivers/net/mlx5/mlx5_mr.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2016 6WIND S.A.
   3  * Copyright 2016 Mellanox Technologies, Ltd
   4  */
   5
   6 #ifdef PEDANTIC
   7 #pragma GCC diagnostic ignored "-Wpedantic"
   8 #endif
   9 #include <infiniband/verbs.h>
  10 #ifdef PEDANTIC
  11 #pragma GCC diagnostic error "-Wpedantic"
  12 #endif
  13
  14 #include <rte_mempool.h>
  15 #include <rte_malloc.h>
  16 #include <rte_rwlock.h>
  17 #include <rte_bus_pci.h>
  18
  19 #include "mlx5.h"
  20 #include "mlx5_mr.h"
  21 #include "mlx5_rxtx.h"
  22 #include "mlx5_glue.h"
  23
  24 struct mr_find_contig_memsegs_data {
  25         uintptr_t addr;
  26         uintptr_t start;
  27         uintptr_t end;
  28         const struct rte_memseg_list *msl;
  29 };
  30
  31 struct mr_update_mp_data {
  32         struct rte_eth_dev *dev;
  33         struct mlx5_mr_ctrl *mr_ctrl;
  34         int ret;
  35 };
  36
  37 /**
  38  * Expand B-tree table to a given size. Can't be called with holding
  39  * memory_hotplug_lock or priv->mr.rwlock due to rte_realloc().
  40  *
  41  * @param bt
  42  *   Pointer to B-tree structure.
  43  * @param n
  44  *   Number of entries for expansion.
  45  *
  46  * @return
  47  *   0 on success, -1 on failure.
  48  */
  49 static int
  50 mr_btree_expand(struct mlx5_mr_btree *bt, int n)
  51 {
  52         void *mem;
  53         int ret = 0;
  54
  55         if (n <= bt->size)
  56                 return ret;
  57         /*
  58          * Downside of directly using rte_realloc() is that SOCKET_ID_ANY is
  59          * used inside if there's no room to expand. Because this is a quite
  60          * rare case and a part of very slow path, it is very acceptable.
  61          * Initially cache_bh[] will be given practically enough space and once
  62          * it is expanded, expansion wouldn't be needed again ever.
  63          */
  64         mem = rte_realloc(bt->table, n * sizeof(struct mlx5_mr_cache), 0);
  65         if (mem == NULL) {
  66                 /* Not an error, B-tree search will be skipped. */
  67                 DRV_LOG(WARNING, "failed to expand MR B-tree (%p) table",
  68                         (void *)bt);
  69                 ret = -1;
  70         } else {
  71                 DRV_LOG(DEBUG, "expanded MR B-tree table (size=%u)", n);
  72                 bt->table = mem;
  73                 bt->size = n;
  74         }
  75         return ret;
  76 }
  77
  78 /**
  79  * Look up LKey from given B-tree lookup table, store the last index and return
  80  * searched LKey.
  81  *
  82  * @param bt
  83  *   Pointer to B-tree structure.
  84  * @param[out] idx
  85  *   Pointer to index. Even on search failure, returns index where it stops
  86  *   searching so that index can be used when inserting a new entry.
  87  * @param addr
  88  *   Search key.
  89  *
  90  * @return
  91  *   Searched LKey on success, UINT32_MAX on no match.
  92  */
  93 static uint32_t
  94 mr_btree_lookup(struct mlx5_mr_btree *bt, uint16_t *idx, uintptr_t addr)
  95 {
  96         struct mlx5_mr_cache *lkp_tbl;
  97         uint16_t n;
  98         uint16_t base = 0;
  99
 100         assert(bt != NULL);
 101         lkp_tbl = *bt->table;
 102         n = bt->len;
 103         /* First entry must be NULL for comparison. */
 104         assert(bt->len > 0 || (lkp_tbl[0].start == 0 &&
 105                                lkp_tbl[0].lkey == UINT32_MAX));
 106         /* Binary search. */
 107         do {
 108                 register uint16_t delta = n >> 1;
 109
 110                 if (addr < lkp_tbl[base + delta].start) {
 111                         n = delta;
 112                 } else {
 113                         base += delta;
 114                         n -= delta;
 115                 }
 116         } while (n > 1);
 117         assert(addr >= lkp_tbl[base].start);
 118         *idx = base;
 119         if (addr < lkp_tbl[base].end)
 120                 return lkp_tbl[base].lkey;
 121         /* Not found. */
 122         return UINT32_MAX;
 123 }
 124
 125 /**
 126  * Insert an entry to B-tree lookup table.
 127  *
 128  * @param bt
 129  *   Pointer to B-tree structure.
 130  * @param entry
 131  *   Pointer to new entry to insert.
 132  *
 133  * @return
 134  *   0 on success, -1 on failure.
 135  */
 136 static int
 137 mr_btree_insert(struct mlx5_mr_btree *bt, struct mlx5_mr_cache *entry)
 138 {
 139         struct mlx5_mr_cache *lkp_tbl;
 140         uint16_t idx = 0;
 141         size_t shift;
 142
 143         assert(bt != NULL);
 144         assert(bt->len <= bt->size);
 145         assert(bt->len > 0);
 146         lkp_tbl = *bt->table;
 147         /* Find out the slot for insertion. */
 148         if (mr_btree_lookup(bt, &idx, entry->start) != UINT32_MAX) {
 149                 DRV_LOG(DEBUG,
 150                         "abort insertion to B-tree(%p): already exist at"
 151                         " idx=%u [0x%" PRIxPTR ", 0x%" PRIxPTR ") lkey=0x%x",
 152                         (void *)bt, idx, entry->start, entry->end, entry->lkey);
 153                 /* Already exist, return. */
 154                 return 0;
 155         }
 156         /* If table is full, return error. */
 157         if (unlikely(bt->len == bt->size)) {
 158                 bt->overflow = 1;
 159                 return -1;
 160         }
 161         /* Insert entry. */
 162         ++idx;
 163         shift = (bt->len - idx) * sizeof(struct mlx5_mr_cache);
 164         if (shift)
 165                 memmove(&lkp_tbl[idx + 1], &lkp_tbl[idx], shift);
 166         lkp_tbl[idx] = *entry;
 167         bt->len++;
 168         DRV_LOG(DEBUG,
 169                 "inserted B-tree(%p)[%u],"
 170                 " [0x%" PRIxPTR ", 0x%" PRIxPTR ") lkey=0x%x",
 171                 (void *)bt, idx, entry->start, entry->end, entry->lkey);
 172         return 0;
 173 }
 174
 175 /**
 176  * Initialize B-tree and allocate memory for lookup table.
 177  *
 178  * @param bt
 179  *   Pointer to B-tree structure.
 180  * @param n
 181  *   Number of entries to allocate.
 182  * @param socket
 183  *   NUMA socket on which memory must be allocated.
 184  *
 185  * @return
 186  *   0 on success, a negative errno value otherwise and rte_errno is set.
 187  */
 188 int
 189 mlx5_mr_btree_init(struct mlx5_mr_btree *bt, int n, int socket)
 190 {
 191         if (bt == NULL) {
 192                 rte_errno = EINVAL;
 193                 return -rte_errno;
 194         }
 195         assert(!bt->table && !bt->size);
 196         memset(bt, 0, sizeof(*bt));
 197         bt->table = rte_calloc_socket("B-tree table",
 198                                       n, sizeof(struct mlx5_mr_cache),
 199                                       0, socket);
 200         if (bt->table == NULL) {
 201                 rte_errno = ENOMEM;
 202                 DEBUG("failed to allocate memory for btree cache on socket %d",
 203                       socket);
 204                 return -rte_errno;
 205         }
 206         bt->size = n;
 207         /* First entry must be NULL for binary search. */
 208         (*bt->table)[bt->len++] = (struct mlx5_mr_cache) {
 209                 .lkey = UINT32_MAX,
 210         };
 211         DEBUG("initialized B-tree %p with table %p",
 212               (void *)bt, (void *)bt->table);
 213         return 0;
 214 }
 215
 216 /**
 217  * Free B-tree resources.
 218  *
 219  * @param bt
 220  *   Pointer to B-tree structure.
 221  */
 222 void
 223 mlx5_mr_btree_free(struct mlx5_mr_btree *bt)
 224 {
 225         if (bt == NULL)
 226                 return;
 227         DEBUG("freeing B-tree %p with table %p",
 228               (void *)bt, (void *)bt->table);
 229         rte_free(bt->table);
 230         memset(bt, 0, sizeof(*bt));
 231 }
 232
 233 /**
 234  * Dump all the entries in a B-tree
 235  *
 236  * @param bt
 237  *   Pointer to B-tree structure.
 238  */
 239 void
 240 mlx5_mr_btree_dump(struct mlx5_mr_btree *bt __rte_unused)
 241 {
 242 #ifndef NDEBUG
 243         int idx;
 244         struct mlx5_mr_cache *lkp_tbl;
 245
 246         if (bt == NULL)
 247                 return;
 248         lkp_tbl = *bt->table;
 249         for (idx = 0; idx < bt->len; ++idx) {
 250                 struct mlx5_mr_cache *entry = &lkp_tbl[idx];
 251
 252                 DEBUG("B-tree(%p)[%u],"
 253                       " [0x%" PRIxPTR ", 0x%" PRIxPTR ") lkey=0x%x",
 254                       (void *)bt, idx, entry->start, entry->end, entry->lkey);
 255         }
 256 #endif
 257 }
 258
 259 /**
 260  * Find virtually contiguous memory chunk in a given MR.
 261  *
 262  * @param dev
 263  *   Pointer to MR structure.
 264  * @param[out] entry
 265  *   Pointer to returning MR cache entry. If not found, this will not be
 266  *   updated.
 267  * @param start_idx
 268  *   Start index of the memseg bitmap.
 269  *
 270  * @return
 271  *   Next index to go on lookup.
 272  */
 273 static int
 274 mr_find_next_chunk(struct mlx5_mr *mr, struct mlx5_mr_cache *entry,
 275                    int base_idx)
 276 {
 277         uintptr_t start = 0;
 278         uintptr_t end = 0;
 279         uint32_t idx = 0;
 280
 281         /* MR for external memory doesn't have memseg list. */
 282         if (mr->msl == NULL) {
 283                 struct ibv_mr *ibv_mr = mr->ibv_mr;
 284
 285                 assert(mr->ms_bmp_n == 1);
 286                 assert(mr->ms_n == 1);
 287                 assert(base_idx == 0);
 288                 /*
 289                  * Can't search it from memseg list but get it directly from
 290                  * verbs MR as there's only one chunk.
 291                  */
 292                 entry->start = (uintptr_t)ibv_mr->addr;
 293                 entry->end = (uintptr_t)ibv_mr->addr + mr->ibv_mr->length;
 294                 entry->lkey = rte_cpu_to_be_32(mr->ibv_mr->lkey);
 295                 /* Returning 1 ends iteration. */
 296                 return 1;
 297         }
 298         for (idx = base_idx; idx < mr->ms_bmp_n; ++idx) {
 299                 if (rte_bitmap_get(mr->ms_bmp, idx)) {
 300                         const struct rte_memseg_list *msl;
 301                         const struct rte_memseg *ms;
 302
 303                         msl = mr->msl;
 304                         ms = rte_fbarray_get(&msl->memseg_arr,
 305                                              mr->ms_base_idx + idx);
 306                         assert(msl->page_sz == ms->hugepage_sz);
 307                         if (!start)
 308                                 start = ms->addr_64;
 309                         end = ms->addr_64 + ms->hugepage_sz;
 310                 } else if (start) {
 311                         /* Passed the end of a fragment. */
 312                         break;
 313                 }
 314         }
 315         if (start) {
 316                 /* Found one chunk. */
 317                 entry->start = start;
 318                 entry->end = end;
 319                 entry->lkey = rte_cpu_to_be_32(mr->ibv_mr->lkey);
 320         }
 321         return idx;
 322 }
 323
 324 /**
 325  * Insert a MR to the global B-tree cache. It may fail due to low-on-memory.
 326  * Then, this entry will have to be searched by mr_lookup_dev_list() in
 327  * mlx5_mr_create() on miss.
 328  *
 329  * @param dev
 330  *   Pointer to Ethernet device.
 331  * @param mr
 332  *   Pointer to MR to insert.
 333  *
 334  * @return
 335  *   0 on success, -1 on failure.
 336  */
 337 static int
 338 mr_insert_dev_cache(struct rte_eth_dev *dev, struct mlx5_mr *mr)
 339 {
 340         struct mlx5_priv *priv = dev->data->dev_private;
 341         unsigned int n;
 342
 343         DRV_LOG(DEBUG, "port %u inserting MR(%p) to global cache",
 344                 dev->data->port_id, (void *)mr);
 345         for (n = 0; n < mr->ms_bmp_n; ) {
 346                 struct mlx5_mr_cache entry;
 347
 348                 memset(&entry, 0, sizeof(entry));
 349                 /* Find a contiguous chunk and advance the index. */
 350                 n = mr_find_next_chunk(mr, &entry, n);
 351                 if (!entry.end)
 352                         break;
 353                 if (mr_btree_insert(&priv->mr.cache, &entry) < 0) {
 354                         /*
 355                          * Overflowed, but the global table cannot be expanded
 356                          * because of deadlock.
 357                          */
 358                         return -1;
 359                 }
 360         }
 361         return 0;
 362 }
 363
 364 /**
 365  * Look up address in the original global MR list.
 366  *
 367  * @param dev
 368  *   Pointer to Ethernet device.
 369  * @param[out] entry
 370  *   Pointer to returning MR cache entry. If no match, this will not be updated.
 371  * @param addr
 372  *   Search key.
 373  *
 374  * @return
 375  *   Found MR on match, NULL otherwise.
 376  */
 377 static struct mlx5_mr *
 378 mr_lookup_dev_list(struct rte_eth_dev *dev, struct mlx5_mr_cache *entry,
 379                    uintptr_t addr)
 380 {
 381         struct mlx5_priv *priv = dev->data->dev_private;
 382         struct mlx5_mr *mr;
 383
 384         /* Iterate all the existing MRs. */
 385         LIST_FOREACH(mr, &priv->mr.mr_list, mr) {
 386                 unsigned int n;
 387
 388                 if (mr->ms_n == 0)
 389                         continue;
 390                 for (n = 0; n < mr->ms_bmp_n; ) {
 391                         struct mlx5_mr_cache ret;
 392
 393                         memset(&ret, 0, sizeof(ret));
 394                         n = mr_find_next_chunk(mr, &ret, n);
 395                         if (addr >= ret.start && addr < ret.end) {
 396                                 /* Found. */
 397                                 *entry = ret;
 398                                 return mr;
 399                         }
 400                 }
 401         }
 402         return NULL;
 403 }
 404
 405 /**
 406  * Look up address on device.
 407  *
 408  * @param dev
 409  *   Pointer to Ethernet device.
 410  * @param[out] entry
 411  *   Pointer to returning MR cache entry. If no match, this will not be updated.
 412  * @param addr
 413  *   Search key.
 414  *
 415  * @return
 416  *   Searched LKey on success, UINT32_MAX on failure and rte_errno is set.
 417  */
 418 static uint32_t
 419 mr_lookup_dev(struct rte_eth_dev *dev, struct mlx5_mr_cache *entry,
 420               uintptr_t addr)
 421 {
 422         struct mlx5_priv *priv = dev->data->dev_private;
 423         uint16_t idx;
 424         uint32_t lkey = UINT32_MAX;
 425         struct mlx5_mr *mr;
 426
 427         /*
 428          * If the global cache has overflowed since it failed to expand the
 429          * B-tree table, it can't have all the existing MRs. Then, the address
 430          * has to be searched by traversing the original MR list instead, which
 431          * is very slow path. Otherwise, the global cache is all inclusive.
 432          */
 433         if (!unlikely(priv->mr.cache.overflow)) {
 434                 lkey = mr_btree_lookup(&priv->mr.cache, &idx, addr);
 435                 if (lkey != UINT32_MAX)
 436                         *entry = (*priv->mr.cache.table)[idx];
 437         } else {
 438                 /* Falling back to the slowest path. */
 439                 mr = mr_lookup_dev_list(dev, entry, addr);
 440                 if (mr != NULL)
 441                         lkey = entry->lkey;
 442         }
 443         assert(lkey == UINT32_MAX || (addr >= entry->start &&
 444                                       addr < entry->end));
 445         return lkey;
 446 }
 447
 448 /**
 449  * Free MR resources. MR lock must not be held to avoid a deadlock. rte_free()
 450  * can raise memory free event and the callback function will spin on the lock.
 451  *
 452  * @param mr
 453  *   Pointer to MR to free.
 454  */
 455 static void
 456 mr_free(struct mlx5_mr *mr)
 457 {
 458         if (mr == NULL)
 459                 return;
 460         DRV_LOG(DEBUG, "freeing MR(%p):", (void *)mr);
 461         if (mr->ibv_mr != NULL)
 462                 claim_zero(mlx5_glue->dereg_mr(mr->ibv_mr));
 463         if (mr->ms_bmp != NULL)
 464                 rte_bitmap_free(mr->ms_bmp);
 465         rte_free(mr);
 466 }
 467
 468 /**
 469  * Releass resources of detached MR having no online entry.
 470  *
 471  * @param dev
 472  *   Pointer to Ethernet device.
 473  */
 474 static void
 475 mlx5_mr_garbage_collect(struct rte_eth_dev *dev)
 476 {
 477         struct mlx5_priv *priv = dev->data->dev_private;
 478         struct mlx5_mr *mr_next;
 479         struct mlx5_mr_list free_list = LIST_HEAD_INITIALIZER(free_list);
 480
 481         /* Must be called from the primary process. */
 482         assert(rte_eal_process_type() == RTE_PROC_PRIMARY);
 483         /*
 484          * MR can't be freed with holding the lock because rte_free() could call
 485          * memory free callback function. This will be a deadlock situation.
 486          */
 487         rte_rwlock_write_lock(&priv->mr.rwlock);
 488         /* Detach the whole free list and release it after unlocking. */
 489         free_list = priv->mr.mr_free_list;
 490         LIST_INIT(&priv->mr.mr_free_list);
 491         rte_rwlock_write_unlock(&priv->mr.rwlock);
 492         /* Release resources. */
 493         mr_next = LIST_FIRST(&free_list);
 494         while (mr_next != NULL) {
 495                 struct mlx5_mr *mr = mr_next;
 496
 497                 mr_next = LIST_NEXT(mr, mr);
 498                 mr_free(mr);
 499         }
 500 }
 501
 502 /* Called during rte_memseg_contig_walk() by mlx5_mr_create(). */
 503 static int
 504 mr_find_contig_memsegs_cb(const struct rte_memseg_list *msl,
 505                           const struct rte_memseg *ms, size_t len, void *arg)
 506 {
 507         struct mr_find_contig_memsegs_data *data = arg;
 508
 509         if (data->addr < ms->addr_64 || data->addr >= ms->addr_64 + len)
 510                 return 0;
 511         /* Found, save it and stop walking. */
 512         data->start = ms->addr_64;
 513         data->end = ms->addr_64 + len;
 514         data->msl = msl;
 515         return 1;
 516 }
 517
 518 /**
 519  * Create a new global Memroy Region (MR) for a missing virtual address.
 520  * Register entire virtually contiguous memory chunk around the address.
 521  *
 522  * @param dev
 523  *   Pointer to Ethernet device.
 524  * @param[out] entry
 525  *   Pointer to returning MR cache entry, found in the global cache or newly
 526  *   created. If failed to create one, this will not be updated.
 527  * @param addr
 528  *   Target virtual address to register.
 529  *
 530  * @return
 531  *   Searched LKey on success, UINT32_MAX on failure and rte_errno is set.
 532  */
 533 static uint32_t
 534 mlx5_mr_create(struct rte_eth_dev *dev, struct mlx5_mr_cache *entry,
 535                uintptr_t addr)
 536 {
 537         struct mlx5_priv *priv = dev->data->dev_private;
 538         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 539         const struct rte_memseg_list *msl;
 540         const struct rte_memseg *ms;
 541         struct mlx5_mr *mr = NULL;
 542         size_t len;
 543         uint32_t ms_n;
 544         uint32_t bmp_size;
 545         void *bmp_mem;
 546         int ms_idx_shift = -1;
 547         unsigned int n;
 548         struct mr_find_contig_memsegs_data data = {
 549                 .addr = addr,
 550         };
 551         struct mr_find_contig_memsegs_data data_re;
 552
 553         DRV_LOG(DEBUG, "port %u creating a MR using address (%p)",
 554                 dev->data->port_id, (void *)addr);
 555         if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
 556                 DRV_LOG(WARNING,
 557                         "port %u using address (%p) of unregistered mempool"
 558                         " in secondary process, please create mempool"
 559                         " before rte_eth_dev_start()",
 560                         dev->data->port_id, (void *)addr);
 561                 rte_errno = EPERM;
 562                 goto err_nolock;
 563         }
 564         /*
 565          * Release detached MRs if any. This can't be called with holding either
 566          * memory_hotplug_lock or priv->mr.rwlock. MRs on the free list have
 567          * been detached by the memory free event but it couldn't be released
 568          * inside the callback due to deadlock. As a result, releasing resources
 569          * is quite opportunistic.
 570          */
 571         mlx5_mr_garbage_collect(dev);
 572         /*
 573          * Find out a contiguous virtual address chunk in use, to which the
 574          * given address belongs, in order to register maximum range. In the
 575          * best case where mempools are not dynamically recreated and
 576          * '--socket-mem' is specified as an EAL option, it is very likely to
 577          * have only one MR(LKey) per a socket and per a hugepage-size even
 578          * though the system memory is highly fragmented.
 579          */
 580         if (!rte_memseg_contig_walk(mr_find_contig_memsegs_cb, &data)) {
 581                 DRV_LOG(WARNING,
 582                         "port %u unable to find virtually contiguous"
 583                         " chunk for address (%p)."
 584                         " rte_memseg_contig_walk() failed.",
 585                         dev->data->port_id, (void *)addr);
 586                 rte_errno = ENXIO;
 587                 goto err_nolock;
 588         }
 589 alloc_resources:
 590         /* Addresses must be page-aligned. */
 591         assert(rte_is_aligned((void *)data.start, data.msl->page_sz));
 592         assert(rte_is_aligned((void *)data.end, data.msl->page_sz));
 593         msl = data.msl;
 594         ms = rte_mem_virt2memseg((void *)data.start, msl);
 595         len = data.end - data.start;
 596         assert(msl->page_sz == ms->hugepage_sz);
 597         /* Number of memsegs in the range. */
 598         ms_n = len / msl->page_sz;
 599         DEBUG("port %u extending %p to [0x%" PRIxPTR ", 0x%" PRIxPTR "),"
 600               " page_sz=0x%" PRIx64 ", ms_n=%u",
 601               dev->data->port_id, (void *)addr,
 602               data.start, data.end, msl->page_sz, ms_n);
 603         /* Size of memory for bitmap. */
 604         bmp_size = rte_bitmap_get_memory_footprint(ms_n);
 605         mr = rte_zmalloc_socket(NULL,
 606                                 RTE_ALIGN_CEIL(sizeof(*mr),
 607                                                RTE_CACHE_LINE_SIZE) +
 608                                 bmp_size,
 609                                 RTE_CACHE_LINE_SIZE, msl->socket_id);
 610         if (mr == NULL) {
 611                 DEBUG("port %u unable to allocate memory for a new MR of"
 612                       " address (%p).",
 613                       dev->data->port_id, (void *)addr);
 614                 rte_errno = ENOMEM;
 615                 goto err_nolock;
 616         }
 617         mr->msl = msl;
 618         /*
 619          * Save the index of the first memseg and initialize memseg bitmap. To
 620          * see if a memseg of ms_idx in the memseg-list is still valid, check:
 621          *      rte_bitmap_get(mr->bmp, ms_idx - mr->ms_base_idx)
 622          */
 623         mr->ms_base_idx = rte_fbarray_find_idx(&msl->memseg_arr, ms);
 624         bmp_mem = RTE_PTR_ALIGN_CEIL(mr + 1, RTE_CACHE_LINE_SIZE);
 625         mr->ms_bmp = rte_bitmap_init(ms_n, bmp_mem, bmp_size);
 626         if (mr->ms_bmp == NULL) {
 627                 DEBUG("port %u unable to initialize bitamp for a new MR of"
 628                       " address (%p).",
 629                       dev->data->port_id, (void *)addr);
 630                 rte_errno = EINVAL;
 631                 goto err_nolock;
 632         }
 633         /*
 634          * Should recheck whether the extended contiguous chunk is still valid.
 635          * Because memory_hotplug_lock can't be held if there's any memory
 636          * related calls in a critical path, resource allocation above can't be
 637          * locked. If the memory has been changed at this point, try again with
 638          * just single page. If not, go on with the big chunk atomically from
 639          * here.
 640          */
 641         rte_rwlock_read_lock(&mcfg->memory_hotplug_lock);
 642         data_re = data;
 643         if (len > msl->page_sz &&
 644             !rte_memseg_contig_walk(mr_find_contig_memsegs_cb, &data_re)) {
 645                 DEBUG("port %u unable to find virtually contiguous"
 646                       " chunk for address (%p)."
 647                       " rte_memseg_contig_walk() failed.",
 648                       dev->data->port_id, (void *)addr);
 649                 rte_errno = ENXIO;
 650                 goto err_memlock;
 651         }
 652         if (data.start != data_re.start || data.end != data_re.end) {
 653                 /*
 654                  * The extended contiguous chunk has been changed. Try again
 655                  * with single memseg instead.
 656                  */
 657                 data.start = RTE_ALIGN_FLOOR(addr, msl->page_sz);
 658                 data.end = data.start + msl->page_sz;
 659                 rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);
 660                 mr_free(mr);
 661                 goto alloc_resources;
 662         }
 663         assert(data.msl == data_re.msl);
 664         rte_rwlock_write_lock(&priv->mr.rwlock);
 665         /*
 666          * Check the address is really missing. If other thread already created
 667          * one or it is not found due to overflow, abort and return.
 668          */
 669         if (mr_lookup_dev(dev, entry, addr) != UINT32_MAX) {
 670                 /*
 671                  * Insert to the global cache table. It may fail due to
 672                  * low-on-memory. Then, this entry will have to be searched
 673                  * here again.
 674                  */
 675                 mr_btree_insert(&priv->mr.cache, entry);
 676                 DEBUG("port %u found MR for %p on final lookup, abort",
 677                       dev->data->port_id, (void *)addr);
 678                 rte_rwlock_write_unlock(&priv->mr.rwlock);
 679                 rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);
 680                 /*
 681                  * Must be unlocked before calling rte_free() because
 682                  * mlx5_mr_mem_event_free_cb() can be called inside.
 683                  */
 684                 mr_free(mr);
 685                 return entry->lkey;
 686         }
 687         /*
 688          * Trim start and end addresses for verbs MR. Set bits for registering
 689          * memsegs but exclude already registered ones. Bitmap can be
 690          * fragmented.
 691          */
 692         for (n = 0; n < ms_n; ++n) {
 693                 uintptr_t start;
 694                 struct mlx5_mr_cache ret;
 695
 696                 memset(&ret, 0, sizeof(ret));
 697                 start = data_re.start + n * msl->page_sz;
 698                 /* Exclude memsegs already registered by other MRs. */
 699                 if (mr_lookup_dev(dev, &ret, start) == UINT32_MAX) {
 700                         /*
 701                          * Start from the first unregistered memseg in the
 702                          * extended range.
 703                          */
 704                         if (ms_idx_shift == -1) {
 705                                 mr->ms_base_idx += n;
 706                                 data.start = start;
 707                                 ms_idx_shift = n;
 708                         }
 709                         data.end = start + msl->page_sz;
 710                         rte_bitmap_set(mr->ms_bmp, n - ms_idx_shift);
 711                         ++mr->ms_n;
 712                 }
 713         }
 714         len = data.end - data.start;
 715         mr->ms_bmp_n = len / msl->page_sz;
 716         assert(ms_idx_shift + mr->ms_bmp_n <= ms_n);
 717         /*
 718          * Finally create a verbs MR for the memory chunk. ibv_reg_mr() can be
 719          * called with holding the memory lock because it doesn't use
 720          * mlx5_alloc_buf_extern() which eventually calls rte_malloc_socket()
 721          * through mlx5_alloc_verbs_buf().
 722          */
 723         mr->ibv_mr = mlx5_glue->reg_mr(priv->sh->pd, (void *)data.start, len,
 724                                        IBV_ACCESS_LOCAL_WRITE);
 725         if (mr->ibv_mr == NULL) {
 726                 DEBUG("port %u fail to create a verbs MR for address (%p)",
 727                       dev->data->port_id, (void *)addr);
 728                 rte_errno = EINVAL;
 729                 goto err_mrlock;
 730         }
 731         assert((uintptr_t)mr->ibv_mr->addr == data.start);
 732         assert(mr->ibv_mr->length == len);
 733         LIST_INSERT_HEAD(&priv->mr.mr_list, mr, mr);
 734         DEBUG("port %u MR CREATED (%p) for %p:\n"
 735               "  [0x%" PRIxPTR ", 0x%" PRIxPTR "),"
 736               " lkey=0x%x base_idx=%u ms_n=%u, ms_bmp_n=%u",
 737               dev->data->port_id, (void *)mr, (void *)addr,
 738               data.start, data.end, rte_cpu_to_be_32(mr->ibv_mr->lkey),
 739               mr->ms_base_idx, mr->ms_n, mr->ms_bmp_n);
 740         /* Insert to the global cache table. */
 741         mr_insert_dev_cache(dev, mr);
 742         /* Fill in output data. */
 743         mr_lookup_dev(dev, entry, addr);
 744         /* Lookup can't fail. */
 745         assert(entry->lkey != UINT32_MAX);
 746         rte_rwlock_write_unlock(&priv->mr.rwlock);
 747         rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);
 748         return entry->lkey;
 749 err_mrlock:
 750         rte_rwlock_write_unlock(&priv->mr.rwlock);
 751 err_memlock:
 752         rte_rwlock_read_unlock(&mcfg->memory_hotplug_lock);
 753 err_nolock:
 754         /*
 755          * In case of error, as this can be called in a datapath, a warning
 756          * message per an error is preferable instead. Must be unlocked before
 757          * calling rte_free() because mlx5_mr_mem_event_free_cb() can be called
 758          * inside.
 759          */
 760         mr_free(mr);
 761         return UINT32_MAX;
 762 }
 763
 764 /**
 765  * Rebuild the global B-tree cache of device from the original MR list.
 766  *
 767  * @param dev
 768  *   Pointer to Ethernet device.
 769  */
 770 static void
 771 mr_rebuild_dev_cache(struct rte_eth_dev *dev)
 772 {
 773         struct mlx5_priv *priv = dev->data->dev_private;
 774         struct mlx5_mr *mr;
 775
 776         DRV_LOG(DEBUG, "port %u rebuild dev cache[]", dev->data->port_id);
 777         /* Flush cache to rebuild. */
 778         priv->mr.cache.len = 1;
 779         priv->mr.cache.overflow = 0;
 780         /* Iterate all the existing MRs. */
 781         LIST_FOREACH(mr, &priv->mr.mr_list, mr)
 782                 if (mr_insert_dev_cache(dev, mr) < 0)
 783                         return;
 784 }
 785
 786 /**
 787  * Callback for memory free event. Iterate freed memsegs and check whether it
 788  * belongs to an existing MR. If found, clear the bit from bitmap of MR. As a
 789  * result, the MR would be fragmented. If it becomes empty, the MR will be freed
 790  * later by mlx5_mr_garbage_collect(). Even if this callback is called from a
 791  * secondary process, the garbage collector will be called in primary process
 792  * as the secondary process can't call mlx5_mr_create().
 793  *
 794  * The global cache must be rebuilt if there's any change and this event has to
 795  * be propagated to dataplane threads to flush the local caches.
 796  *
 797  * @param dev
 798  *   Pointer to Ethernet device.
 799  * @param addr
 800  *   Address of freed memory.
 801  * @param len
 802  *   Size of freed memory.
 803  */
 804 static void
 805 mlx5_mr_mem_event_free_cb(struct rte_eth_dev *dev, const void *addr, size_t len)
 806 {
 807         struct mlx5_priv *priv = dev->data->dev_private;
 808         const struct rte_memseg_list *msl;
 809         struct mlx5_mr *mr;
 810         int ms_n;
 811         int i;
 812         int rebuild = 0;
 813
 814         DEBUG("port %u free callback: addr=%p, len=%zu",
 815               dev->data->port_id, addr, len);
 816         msl = rte_mem_virt2memseg_list(addr);
 817         /* addr and len must be page-aligned. */
 818         assert((uintptr_t)addr == RTE_ALIGN((uintptr_t)addr, msl->page_sz));
 819         assert(len == RTE_ALIGN(len, msl->page_sz));
 820         ms_n = len / msl->page_sz;
 821         rte_rwlock_write_lock(&priv->mr.rwlock);
 822         /* Clear bits of freed memsegs from MR. */
 823         for (i = 0; i < ms_n; ++i) {
 824                 const struct rte_memseg *ms;
 825                 struct mlx5_mr_cache entry;
 826                 uintptr_t start;
 827                 int ms_idx;
 828                 uint32_t pos;
 829
 830                 /* Find MR having this memseg. */
 831                 start = (uintptr_t)addr + i * msl->page_sz;
 832                 mr = mr_lookup_dev_list(dev, &entry, start);
 833                 if (mr == NULL)
 834                         continue;
 835                 assert(mr->msl); /* Can't be external memory. */
 836                 ms = rte_mem_virt2memseg((void *)start, msl);
 837                 assert(ms != NULL);
 838                 assert(msl->page_sz == ms->hugepage_sz);
 839                 ms_idx = rte_fbarray_find_idx(&msl->memseg_arr, ms);
 840                 pos = ms_idx - mr->ms_base_idx;
 841                 assert(rte_bitmap_get(mr->ms_bmp, pos));
 842                 assert(pos < mr->ms_bmp_n);
 843                 DEBUG("port %u MR(%p): clear bitmap[%u] for addr %p",
 844                       dev->data->port_id, (void *)mr, pos, (void *)start);
 845                 rte_bitmap_clear(mr->ms_bmp, pos);
 846                 if (--mr->ms_n == 0) {
 847                         LIST_REMOVE(mr, mr);
 848                         LIST_INSERT_HEAD(&priv->mr.mr_free_list, mr, mr);
 849                         DEBUG("port %u remove MR(%p) from list",
 850                               dev->data->port_id, (void *)mr);
 851                 }
 852                 /*
 853                  * MR is fragmented or will be freed. the global cache must be
 854                  * rebuilt.
 855                  */
 856                 rebuild = 1;
 857         }
 858         if (rebuild) {
 859                 mr_rebuild_dev_cache(dev);
 860                 /*
 861                  * Flush local caches by propagating invalidation across cores.
 862                  * rte_smp_wmb() is enough to synchronize this event. If one of
 863                  * freed memsegs is seen by other core, that means the memseg
 864                  * has been allocated by allocator, which will come after this
 865                  * free call. Therefore, this store instruction (incrementing
 866                  * generation below) will be guaranteed to be seen by other core
 867                  * before the core sees the newly allocated memory.
 868                  */
 869                 ++priv->mr.dev_gen;
 870                 DEBUG("broadcasting local cache flush, gen=%d",
 871                       priv->mr.dev_gen);
 872                 rte_smp_wmb();
 873         }
 874         rte_rwlock_write_unlock(&priv->mr.rwlock);
 875 }
 876
 877 /**
 878  * Callback for memory event. This can be called from both primary and secondary
 879  * process.
 880  *
 881  * @param event_type
 882  *   Memory event type.
 883  * @param addr
 884  *   Address of memory.
 885  * @param len
 886  *   Size of memory.
 887  */
 888 void
 889 mlx5_mr_mem_event_cb(enum rte_mem_event event_type, const void *addr,
 890                      size_t len, void *arg __rte_unused)
 891 {
 892         struct mlx5_priv *priv;
 893         struct mlx5_dev_list *dev_list = &mlx5_shared_data->mem_event_cb_list;
 894
 895         /* Must be called from the primary process. */
 896         assert(rte_eal_process_type() == RTE_PROC_PRIMARY);
 897         switch (event_type) {
 898         case RTE_MEM_EVENT_FREE:
 899                 rte_rwlock_write_lock(&mlx5_shared_data->mem_event_rwlock);
 900                 /* Iterate all the existing mlx5 devices. */
 901                 LIST_FOREACH(priv, dev_list, mem_event_cb)
 902                         mlx5_mr_mem_event_free_cb(ETH_DEV(priv), addr, len);
 903                 rte_rwlock_write_unlock(&mlx5_shared_data->mem_event_rwlock);
 904                 break;
 905         case RTE_MEM_EVENT_ALLOC:
 906         default:
 907                 break;
 908         }
 909 }
 910
 911 /**
 912  * Look up address in the global MR cache table. If not found, create a new MR.
 913  * Insert the found/created entry to local bottom-half cache table.
 914  *
 915  * @param dev
 916  *   Pointer to Ethernet device.
 917  * @param mr_ctrl
 918  *   Pointer to per-queue MR control structure.
 919  * @param[out] entry
 920  *   Pointer to returning MR cache entry, found in the global cache or newly
 921  *   created. If failed to create one, this is not written.
 922  * @param addr
 923  *   Search key.
 924  *
 925  * @return
 926  *   Searched LKey on success, UINT32_MAX on no match.
 927  */
 928 static uint32_t
 929 mlx5_mr_lookup_dev(struct rte_eth_dev *dev, struct mlx5_mr_ctrl *mr_ctrl,
 930                    struct mlx5_mr_cache *entry, uintptr_t addr)
 931 {
 932         struct mlx5_priv *priv = dev->data->dev_private;
 933         struct mlx5_mr_btree *bt = &mr_ctrl->cache_bh;
 934         uint16_t idx;
 935         uint32_t lkey;
 936
 937         /* If local cache table is full, try to double it. */
 938         if (unlikely(bt->len == bt->size))
 939                 mr_btree_expand(bt, bt->size << 1);
 940         /* Look up in the global cache. */
 941         rte_rwlock_read_lock(&priv->mr.rwlock);
 942         lkey = mr_btree_lookup(&priv->mr.cache, &idx, addr);
 943         if (lkey != UINT32_MAX) {
 944                 /* Found. */
 945                 *entry = (*priv->mr.cache.table)[idx];
 946                 rte_rwlock_read_unlock(&priv->mr.rwlock);
 947                 /*
 948                  * Update local cache. Even if it fails, return the found entry
 949                  * to update top-half cache. Next time, this entry will be found
 950                  * in the global cache.
 951                  */
 952                 mr_btree_insert(bt, entry);
 953                 return lkey;
 954         }
 955         rte_rwlock_read_unlock(&priv->mr.rwlock);
 956         /* First time to see the address? Create a new MR. */
 957         lkey = mlx5_mr_create(dev, entry, addr);
 958         /*
 959          * Update the local cache if successfully created a new global MR. Even
 960          * if failed to create one, there's no action to take in this datapath
 961          * code. As returning LKey is invalid, this will eventually make HW
 962          * fail.
 963          */
 964         if (lkey != UINT32_MAX)
 965                 mr_btree_insert(bt, entry);
 966         return lkey;
 967 }
 968
 969 /**
 970  * Bottom-half of LKey search on datapath. Firstly search in cache_bh[] and if
 971  * misses, search in the global MR cache table and update the new entry to
 972  * per-queue local caches.
 973  *
 974  * @param dev
 975  *   Pointer to Ethernet device.
 976  * @param mr_ctrl
 977  *   Pointer to per-queue MR control structure.
 978  * @param addr
 979  *   Search key.
 980  *
 981  * @return
 982  *   Searched LKey on success, UINT32_MAX on no match.
 983  */
 984 static uint32_t
 985 mlx5_mr_addr2mr_bh(struct rte_eth_dev *dev, struct mlx5_mr_ctrl *mr_ctrl,
 986                    uintptr_t addr)
 987 {
 988         uint32_t lkey;
 989         uint16_t bh_idx = 0;
 990         /* Victim in top-half cache to replace with new entry. */
 991         struct mlx5_mr_cache *repl = &mr_ctrl->cache[mr_ctrl->head];
 992
 993         /* Binary-search MR translation table. */
 994         lkey = mr_btree_lookup(&mr_ctrl->cache_bh, &bh_idx, addr);
 995         /* Update top-half cache. */
 996         if (likely(lkey != UINT32_MAX)) {
 997                 *repl = (*mr_ctrl->cache_bh.table)[bh_idx];
 998         } else {
 999                 /*
1000                  * If missed in local lookup table, search in the global cache
1001                  * and local cache_bh[] will be updated inside if possible.
1002                  * Top-half cache entry will also be updated.
1003                  */
1004                 lkey = mlx5_mr_lookup_dev(dev, mr_ctrl, repl, addr);
1005                 if (unlikely(lkey == UINT32_MAX))
1006                         return UINT32_MAX;
1007         }
1008         /* Update the most recently used entry. */
1009         mr_ctrl->mru = mr_ctrl->head;
1010         /* Point to the next victim, the oldest. */
1011         mr_ctrl->head = (mr_ctrl->head + 1) % MLX5_MR_CACHE_N;
1012         return lkey;
1013 }
1014
1015 /**
1016  * Bottom-half of LKey search on Rx.
1017  *
1018  * @param rxq
1019  *   Pointer to Rx queue structure.
1020  * @param addr
1021  *   Search key.
1022  *
1023  * @return
1024  *   Searched LKey on success, UINT32_MAX on no match.
1025  */
1026 uint32_t
1027 mlx5_rx_addr2mr_bh(struct mlx5_rxq_data *rxq, uintptr_t addr)
1028 {
1029         struct mlx5_rxq_ctrl *rxq_ctrl =
1030                 container_of(rxq, struct mlx5_rxq_ctrl, rxq);
1031         struct mlx5_mr_ctrl *mr_ctrl = &rxq->mr_ctrl;
1032         struct mlx5_priv *priv = rxq_ctrl->priv;
1033
1034         return mlx5_mr_addr2mr_bh(ETH_DEV(priv), mr_ctrl, addr);
1035 }
1036
1037 /**
1038  * Bottom-half of LKey search on Tx.
1039  *
1040  * @param txq
1041  *   Pointer to Tx queue structure.
1042  * @param addr
1043  *   Search key.
1044  *
1045  * @return
1046  *   Searched LKey on success, UINT32_MAX on no match.
1047  */
1048 static uint32_t
1049 mlx5_tx_addr2mr_bh(struct mlx5_txq_data *txq, uintptr_t addr)
1050 {
1051         struct mlx5_txq_ctrl *txq_ctrl =
1052                 container_of(txq, struct mlx5_txq_ctrl, txq);
1053         struct mlx5_mr_ctrl *mr_ctrl = &txq->mr_ctrl;
1054         struct mlx5_priv *priv = txq_ctrl->priv;
1055
1056         return mlx5_mr_addr2mr_bh(ETH_DEV(priv), mr_ctrl, addr);
1057 }
1058
1059 /**
1060  * Bottom-half of LKey search on Tx. If it can't be searched in the memseg
1061  * list, register the mempool of the mbuf as externally allocated memory.
1062  *
1063  * @param txq
1064  *   Pointer to Tx queue structure.
1065  * @param mb
1066  *   Pointer to mbuf.
1067  *
1068  * @return
1069  *   Searched LKey on success, UINT32_MAX on no match.
1070  */
1071 uint32_t
1072 mlx5_tx_mb2mr_bh(struct mlx5_txq_data *txq, struct rte_mbuf *mb)
1073 {
1074         uintptr_t addr = (uintptr_t)mb->buf_addr;
1075         uint32_t lkey;
1076
1077         lkey = mlx5_tx_addr2mr_bh(txq, addr);
1078         if (lkey == UINT32_MAX && rte_errno == ENXIO) {
1079                 /* Mempool may have externally allocated memory. */
1080                 return mlx5_tx_update_ext_mp(txq, addr, mlx5_mb2mp(mb));
1081         }
1082         return lkey;
1083 }
1084
1085 /**
1086  * Flush all of the local cache entries.
1087  *
1088  * @param mr_ctrl
1089  *   Pointer to per-queue MR control structure.
1090  */
1091 void
1092 mlx5_mr_flush_local_cache(struct mlx5_mr_ctrl *mr_ctrl)
1093 {
1094         /* Reset the most-recently-used index. */
1095         mr_ctrl->mru = 0;
1096         /* Reset the linear search array. */
1097         mr_ctrl->head = 0;
1098         memset(mr_ctrl->cache, 0, sizeof(mr_ctrl->cache));
1099         /* Reset the B-tree table. */
1100         mr_ctrl->cache_bh.len = 1;
1101         mr_ctrl->cache_bh.overflow = 0;
1102         /* Update the generation number. */
1103         mr_ctrl->cur_gen = *mr_ctrl->dev_gen_ptr;
1104         DRV_LOG(DEBUG, "mr_ctrl(%p): flushed, cur_gen=%d",
1105                 (void *)mr_ctrl, mr_ctrl->cur_gen);
1106 }
1107
1108 /**
1109  * Creates a memory region for external memory, that is memory which is not
1110  * part of the DPDK memory segments.
1111  *
1112  * @param dev
1113  *   Pointer to the ethernet device.
1114  * @param addr
1115  *   Starting virtual address of memory.
1116  * @param len
1117  *   Length of memory segment being mapped.
1118  * @param socked_id
1119  *   Socket to allocate heap memory for the control structures.
1120  *
1121  * @return
1122  *   Pointer to MR structure on success, NULL otherwise.
1123  */
1124 static struct mlx5_mr *
1125 mlx5_create_mr_ext(struct rte_eth_dev *dev, uintptr_t addr, size_t len,
1126                    int socket_id)
1127 {
1128         struct mlx5_priv *priv = dev->data->dev_private;
1129         struct mlx5_mr *mr = NULL;
1130
1131         mr = rte_zmalloc_socket(NULL,
1132                                 RTE_ALIGN_CEIL(sizeof(*mr),
1133                                                RTE_CACHE_LINE_SIZE),
1134                                 RTE_CACHE_LINE_SIZE, socket_id);
1135         if (mr == NULL)
1136                 return NULL;
1137         mr->ibv_mr = mlx5_glue->reg_mr(priv->sh->pd, (void *)addr, len,
1138                                        IBV_ACCESS_LOCAL_WRITE);
1139         if (mr->ibv_mr == NULL) {
1140                 DRV_LOG(WARNING,
1141                         "port %u fail to create a verbs MR for address (%p)",
1142                         dev->data->port_id, (void *)addr);
1143                 rte_free(mr);
1144                 return NULL;
1145         }
1146         mr->msl = NULL; /* Mark it is external memory. */
1147         mr->ms_bmp = NULL;
1148         mr->ms_n = 1;
1149         mr->ms_bmp_n = 1;
1150         DRV_LOG(DEBUG,
1151                 "port %u MR CREATED (%p) for external memory %p:\n"
1152                 "  [0x%" PRIxPTR ", 0x%" PRIxPTR "),"
1153                 " lkey=0x%x base_idx=%u ms_n=%u, ms_bmp_n=%u",
1154                 dev->data->port_id, (void *)mr, (void *)addr,
1155                 addr, addr + len, rte_cpu_to_be_32(mr->ibv_mr->lkey),
1156                 mr->ms_base_idx, mr->ms_n, mr->ms_bmp_n);
1157         return mr;
1158 }
1159
1160 /**
1161  * Called during rte_mempool_mem_iter() by mlx5_mr_update_ext_mp().
1162  *
1163  * Externally allocated chunk is registered and a MR is created for the chunk.
1164  * The MR object is added to the global list. If memseg list of a MR object
1165  * (mr->msl) is null, the MR object can be regarded as externally allocated
1166  * memory.
1167  *
1168  * Once external memory is registered, it should be static. If the memory is
1169  * freed and the virtual address range has different physical memory mapped
1170  * again, it may cause crash on device due to the wrong translation entry. PMD
1171  * can't track the free event of the external memory for now.
1172  */
1173 static void
1174 mlx5_mr_update_ext_mp_cb(struct rte_mempool *mp, void *opaque,
1175                          struct rte_mempool_memhdr *memhdr,
1176                          unsigned mem_idx __rte_unused)
1177 {
1178         struct mr_update_mp_data *data = opaque;
1179         struct rte_eth_dev *dev = data->dev;
1180         struct mlx5_priv *priv = dev->data->dev_private;
1181         struct mlx5_mr_ctrl *mr_ctrl = data->mr_ctrl;
1182         struct mlx5_mr *mr = NULL;
1183         uintptr_t addr = (uintptr_t)memhdr->addr;
1184         size_t len = memhdr->len;
1185         struct mlx5_mr_cache entry;
1186         uint32_t lkey;
1187
1188         /* If already registered, it should return. */
1189         rte_rwlock_read_lock(&priv->mr.rwlock);
1190         lkey = mr_lookup_dev(dev, &entry, addr);
1191         rte_rwlock_read_unlock(&priv->mr.rwlock);
1192         if (lkey != UINT32_MAX)
1193                 return;
1194         DRV_LOG(DEBUG, "port %u register MR for chunk #%d of mempool (%s)",
1195                 dev->data->port_id, mem_idx, mp->name);
1196         mr = mlx5_create_mr_ext(dev, addr, len, mp->socket_id);
1197         if (!mr) {
1198                 DRV_LOG(WARNING,
1199                         "port %u unable to allocate a new MR of"
1200                         " mempool (%s).",
1201                         dev->data->port_id, mp->name);
1202                 data->ret = -1;
1203                 return;
1204         }
1205         rte_rwlock_write_lock(&priv->mr.rwlock);
1206         LIST_INSERT_HEAD(&priv->mr.mr_list, mr, mr);
1207         /* Insert to the global cache table. */
1208         mr_insert_dev_cache(dev, mr);
1209         rte_rwlock_write_unlock(&priv->mr.rwlock);
1210         /* Insert to the local cache table */
1211         mlx5_mr_addr2mr_bh(dev, mr_ctrl, addr);
1212 }
1213
1214 /**
1215  * Finds the first ethdev that match the pci device.
1216  * The existence of multiple ethdev per pci device is only with representors.
1217  * On such case, it is enough to get only one of the ports as they all share
1218  * the same ibv context.
1219  *
1220  * @param pdev
1221  *   Pointer to the PCI device.
1222  *
1223  * @return
1224  *   Pointer to the ethdev if found, NULL otherwise.
1225  */
1226 static struct rte_eth_dev *
1227 pci_dev_to_eth_dev(struct rte_pci_device *pdev)
1228 {
1229         struct rte_dev_iterator it;
1230         struct rte_device *dev;
1231
1232         /**
1233          *  We really need to iterate all devices regardless of
1234          *  their owner.
1235          */
1236         RTE_DEV_FOREACH(dev, "class=eth", &it)
1237                 if (dev == &pdev->device)
1238                         return it.class_device;
1239         return NULL;
1240 }
1241
1242 /**
1243  * DPDK callback to DMA map external memory to a PCI device.
1244  *
1245  * @param pdev
1246  *   Pointer to the PCI device.
1247  * @param addr
1248  *   Starting virtual address of memory to be mapped.
1249  * @param iova
1250  *   Starting IOVA address of memory to be mapped.
1251  * @param len
1252  *   Length of memory segment being mapped.
1253  *
1254  * @return
1255  *   0 on success, negative value on error.
1256  */
1257 int
1258 mlx5_dma_map(struct rte_pci_device *pdev, void *addr,
1259              uint64_t iova __rte_unused, size_t len)
1260 {
1261         struct rte_eth_dev *dev;
1262         struct mlx5_mr *mr;
1263         struct mlx5_priv *priv;
1264
1265         dev = pci_dev_to_eth_dev(pdev);
1266         if (!dev) {
1267                 DRV_LOG(WARNING, "unable to find matching ethdev "
1268                                  "to PCI device %p", (void *)pdev);
1269                 rte_errno = ENODEV;
1270                 return -1;
1271         }
1272         priv = dev->data->dev_private;
1273         mr = mlx5_create_mr_ext(dev, (uintptr_t)addr, len, SOCKET_ID_ANY);
1274         if (!mr) {
1275                 DRV_LOG(WARNING,
1276                         "port %u unable to dma map", dev->data->port_id);
1277                 rte_errno = EINVAL;
1278                 return -1;
1279         }
1280         rte_rwlock_write_lock(&priv->mr.rwlock);
1281         LIST_INSERT_HEAD(&priv->mr.mr_list, mr, mr);
1282         /* Insert to the global cache table. */
1283         mr_insert_dev_cache(dev, mr);
1284         rte_rwlock_write_unlock(&priv->mr.rwlock);
1285         return 0;
1286 }
1287
1288 /**
1289  * DPDK callback to DMA unmap external memory to a PCI device.
1290  *
1291  * @param pdev
1292  *   Pointer to the PCI device.
1293  * @param addr
1294  *   Starting virtual address of memory to be unmapped.
1295  * @param iova
1296  *   Starting IOVA address of memory to be unmapped.
1297  * @param len
1298  *   Length of memory segment being unmapped.
1299  *
1300  * @return
1301  *   0 on success, negative value on error.
1302  */
1303 int
1304 mlx5_dma_unmap(struct rte_pci_device *pdev, void *addr,
1305                uint64_t iova __rte_unused, size_t len __rte_unused)
1306 {
1307         struct rte_eth_dev *dev;
1308         struct mlx5_priv *priv;
1309         struct mlx5_mr *mr;
1310         struct mlx5_mr_cache entry;
1311
1312         dev = pci_dev_to_eth_dev(pdev);
1313         if (!dev) {
1314                 DRV_LOG(WARNING, "unable to find matching ethdev "
1315                                  "to PCI device %p", (void *)pdev);
1316                 rte_errno = ENODEV;
1317                 return -1;
1318         }
1319         priv = dev->data->dev_private;
1320         rte_rwlock_read_lock(&priv->mr.rwlock);
1321         mr = mr_lookup_dev_list(dev, &entry, (uintptr_t)addr);
1322         if (!mr) {
1323                 rte_rwlock_read_unlock(&priv->mr.rwlock);
1324                 DRV_LOG(WARNING, "address 0x%" PRIxPTR " wasn't registered "
1325                                  "to PCI device %p", (uintptr_t)addr,
1326                                  (void *)pdev);
1327                 rte_errno = EINVAL;
1328                 return -1;
1329         }
1330         LIST_REMOVE(mr, mr);
1331         LIST_INSERT_HEAD(&priv->mr.mr_free_list, mr, mr);
1332         DEBUG("port %u remove MR(%p) from list", dev->data->port_id,
1333               (void *)mr);
1334         mr_rebuild_dev_cache(dev);
1335         /*
1336          * Flush local caches by propagating invalidation across cores.
1337          * rte_smp_wmb() is enough to synchronize this event. If one of
1338          * freed memsegs is seen by other core, that means the memseg
1339          * has been allocated by allocator, which will come after this
1340          * free call. Therefore, this store instruction (incrementing
1341          * generation below) will be guaranteed to be seen by other core
1342          * before the core sees the newly allocated memory.
1343          */
1344         ++priv->mr.dev_gen;
1345         DEBUG("broadcasting local cache flush, gen=%d",
1346                         priv->mr.dev_gen);
1347         rte_smp_wmb();
1348         rte_rwlock_read_unlock(&priv->mr.rwlock);
1349         return 0;
1350 }
1351
1352 /**
1353  * Register MR for entire memory chunks in a Mempool having externally allocated
1354  * memory and fill in local cache.
1355  *
1356  * @param dev
1357  *   Pointer to Ethernet device.
1358  * @param mr_ctrl
1359  *   Pointer to per-queue MR control structure.
1360  * @param mp
1361  *   Pointer to registering Mempool.
1362  *
1363  * @return
1364  *   0 on success, -1 on failure.
1365  */
1366 static uint32_t
1367 mlx5_mr_update_ext_mp(struct rte_eth_dev *dev, struct mlx5_mr_ctrl *mr_ctrl,
1368                       struct rte_mempool *mp)
1369 {
1370         struct mr_update_mp_data data = {
1371                 .dev = dev,
1372                 .mr_ctrl = mr_ctrl,
1373                 .ret = 0,
1374         };
1375
1376         rte_mempool_mem_iter(mp, mlx5_mr_update_ext_mp_cb, &data);
1377         return data.ret;
1378 }
1379
1380 /**
1381  * Register MR entire memory chunks in a Mempool having externally allocated
1382  * memory and search LKey of the address to return.
1383  *
1384  * @param dev
1385  *   Pointer to Ethernet device.
1386  * @param addr
1387  *   Search key.
1388  * @param mp
1389  *   Pointer to registering Mempool where addr belongs.
1390  *
1391  * @return
1392  *   LKey for address on success, UINT32_MAX on failure.
1393  */
1394 uint32_t
1395 mlx5_tx_update_ext_mp(struct mlx5_txq_data *txq, uintptr_t addr,
1396                       struct rte_mempool *mp)
1397 {
1398         struct mlx5_txq_ctrl *txq_ctrl =
1399                 container_of(txq, struct mlx5_txq_ctrl, txq);
1400         struct mlx5_mr_ctrl *mr_ctrl = &txq->mr_ctrl;
1401         struct mlx5_priv *priv = txq_ctrl->priv;
1402
1403         mlx5_mr_update_ext_mp(ETH_DEV(priv), mr_ctrl, mp);
1404         return mlx5_tx_addr2mr_bh(txq, addr);
1405 }
1406
1407 /* Called during rte_mempool_mem_iter() by mlx5_mr_update_mp(). */
1408 static void
1409 mlx5_mr_update_mp_cb(struct rte_mempool *mp __rte_unused, void *opaque,
1410                      struct rte_mempool_memhdr *memhdr,
1411                      unsigned mem_idx __rte_unused)
1412 {
1413         struct mr_update_mp_data *data = opaque;
1414         uint32_t lkey;
1415
1416         /* Stop iteration if failed in the previous walk. */
1417         if (data->ret < 0)
1418                 return;
1419         /* Register address of the chunk and update local caches. */
1420         lkey = mlx5_mr_addr2mr_bh(data->dev, data->mr_ctrl,
1421                                   (uintptr_t)memhdr->addr);
1422         if (lkey == UINT32_MAX)
1423                 data->ret = -1;
1424 }
1425
1426 /**
1427  * Register entire memory chunks in a Mempool.
1428  *
1429  * @param dev
1430  *   Pointer to Ethernet device.
1431  * @param mr_ctrl
1432  *   Pointer to per-queue MR control structure.
1433  * @param mp
1434  *   Pointer to registering Mempool.
1435  *
1436  * @return
1437  *   0 on success, -1 on failure.
1438  */
1439 int
1440 mlx5_mr_update_mp(struct rte_eth_dev *dev, struct mlx5_mr_ctrl *mr_ctrl,
1441                   struct rte_mempool *mp)
1442 {
1443         struct mr_update_mp_data data = {
1444                 .dev = dev,
1445                 .mr_ctrl = mr_ctrl,
1446                 .ret = 0,
1447         };
1448
1449         rte_mempool_mem_iter(mp, mlx5_mr_update_mp_cb, &data);
1450         if (data.ret < 0 && rte_errno == ENXIO) {
1451                 /* Mempool may have externally allocated memory. */
1452                 return mlx5_mr_update_ext_mp(dev, mr_ctrl, mp);
1453         }
1454         return data.ret;
1455 }
1456
1457 /**
1458  * Dump all the created MRs and the global cache entries.
1459  *
1460  * @param dev
1461  *   Pointer to Ethernet device.
1462  */
1463 void
1464 mlx5_mr_dump_dev(struct rte_eth_dev *dev __rte_unused)
1465 {
1466 #ifndef NDEBUG
1467         struct mlx5_priv *priv = dev->data->dev_private;
1468         struct mlx5_mr *mr;
1469         int mr_n = 0;
1470         int chunk_n = 0;
1471
1472         rte_rwlock_read_lock(&priv->mr.rwlock);
1473         /* Iterate all the existing MRs. */
1474         LIST_FOREACH(mr, &priv->mr.mr_list, mr) {
1475                 unsigned int n;
1476
1477                 DEBUG("port %u MR[%u], LKey = 0x%x, ms_n = %u, ms_bmp_n = %u",
1478                       dev->data->port_id, mr_n++,
1479                       rte_cpu_to_be_32(mr->ibv_mr->lkey),
1480                       mr->ms_n, mr->ms_bmp_n);
1481                 if (mr->ms_n == 0)
1482                         continue;
1483                 for (n = 0; n < mr->ms_bmp_n; ) {
1484                         struct mlx5_mr_cache ret = { 0, };
1485
1486                         n = mr_find_next_chunk(mr, &ret, n);
1487                         if (!ret.end)
1488                                 break;
1489                         DEBUG("  chunk[%u], [0x%" PRIxPTR ", 0x%" PRIxPTR ")",
1490                               chunk_n++, ret.start, ret.end);
1491                 }
1492         }
1493         DEBUG("port %u dumping global cache", dev->data->port_id);
1494         mlx5_mr_btree_dump(&priv->mr.cache);
1495         rte_rwlock_read_unlock(&priv->mr.rwlock);
1496 #endif
1497 }
1498
1499 /**
1500  * Release all the created MRs and resources. Remove device from memory callback
1501  * list.
1502  *
1503  * @param dev
1504  *   Pointer to Ethernet device.
1505  */
1506 void
1507 mlx5_mr_release(struct rte_eth_dev *dev)
1508 {
1509         struct mlx5_priv *priv = dev->data->dev_private;
1510         struct mlx5_mr *mr_next = LIST_FIRST(&priv->mr.mr_list);
1511
1512         /* Remove from memory callback device list. */
1513         rte_rwlock_write_lock(&mlx5_shared_data->mem_event_rwlock);
1514         LIST_REMOVE(priv, mem_event_cb);
1515         rte_rwlock_write_unlock(&mlx5_shared_data->mem_event_rwlock);
1516         if (rte_log_get_level(mlx5_logtype) == RTE_LOG_DEBUG)
1517                 mlx5_mr_dump_dev(dev);
1518         rte_rwlock_write_lock(&priv->mr.rwlock);
1519         /* Detach from MR list and move to free list. */
1520         while (mr_next != NULL) {
1521                 struct mlx5_mr *mr = mr_next;
1522
1523                 mr_next = LIST_NEXT(mr, mr);
1524                 LIST_REMOVE(mr, mr);
1525                 LIST_INSERT_HEAD(&priv->mr.mr_free_list, mr, mr);
1526         }
1527         LIST_INIT(&priv->mr.mr_list);
1528         /* Free global cache. */
1529         mlx5_mr_btree_free(&priv->mr.cache);
1530         rte_rwlock_write_unlock(&priv->mr.rwlock);
1531         /* Free all remaining MRs. */
1532         mlx5_mr_garbage_collect(dev);
1533 }