drivers/common/mlx5/mlx5_common_mr.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2016 6WIND S.A.
   3  * Copyright 2020 Mellanox Technologies, Ltd
   4  */
   5 #include <stddef.h>
   6
   7 #include <rte_eal_memconfig.h>
   8 #include <rte_eal_paging.h>
   9 #include <rte_errno.h>
  10 #include <rte_mempool.h>
  11 #include <rte_malloc.h>
  12 #include <rte_rwlock.h>
  13
  14 #include "mlx5_glue.h"
  15 #include "mlx5_common_mp.h"
  16 #include "mlx5_common_mr.h"
  17 #include "mlx5_common_log.h"
  18 #include "mlx5_malloc.h"
  19
  20 struct mr_find_contig_memsegs_data {
  21         uintptr_t addr;
  22         uintptr_t start;
  23         uintptr_t end;
  24         const struct rte_memseg_list *msl;
  25 };
  26
  27 /* Virtual memory range. */
  28 struct mlx5_range {
  29         uintptr_t start;
  30         uintptr_t end;
  31 };
  32
  33 /** Memory region for a mempool. */
  34 struct mlx5_mempool_mr {
  35         struct mlx5_pmd_mr pmd_mr;
  36         uint32_t refcnt; /**< Number of mempools sharing this MR. */
  37 };
  38
  39 /* Mempool registration. */
  40 struct mlx5_mempool_reg {
  41         LIST_ENTRY(mlx5_mempool_reg) next;
  42         /** Registered mempool, used to designate registrations. */
  43         struct rte_mempool *mp;
  44         /** Memory regions for the address ranges of the mempool. */
  45         struct mlx5_mempool_mr *mrs;
  46         /** Number of memory regions. */
  47         unsigned int mrs_n;
  48 };
  49
  50 /**
  51  * Expand B-tree table to a given size. Can't be called with holding
  52  * memory_hotplug_lock or share_cache.rwlock due to rte_realloc().
  53  *
  54  * @param bt
  55  *   Pointer to B-tree structure.
  56  * @param n
  57  *   Number of entries for expansion.
  58  *
  59  * @return
  60  *   0 on success, -1 on failure.
  61  */
  62 static int
  63 mr_btree_expand(struct mlx5_mr_btree *bt, int n)
  64 {
  65         void *mem;
  66         int ret = 0;
  67
  68         if (n <= bt->size)
  69                 return ret;
  70         /*
  71          * Downside of directly using rte_realloc() is that SOCKET_ID_ANY is
  72          * used inside if there's no room to expand. Because this is a quite
  73          * rare case and a part of very slow path, it is very acceptable.
  74          * Initially cache_bh[] will be given practically enough space and once
  75          * it is expanded, expansion wouldn't be needed again ever.
  76          */
  77         mem = mlx5_realloc(bt->table, MLX5_MEM_RTE | MLX5_MEM_ZERO,
  78                            n * sizeof(struct mr_cache_entry), 0, SOCKET_ID_ANY);
  79         if (mem == NULL) {
  80                 /* Not an error, B-tree search will be skipped. */
  81                 DRV_LOG(WARNING, "failed to expand MR B-tree (%p) table",
  82                         (void *)bt);
  83                 ret = -1;
  84         } else {
  85                 DRV_LOG(DEBUG, "expanded MR B-tree table (size=%u)", n);
  86                 bt->table = mem;
  87                 bt->size = n;
  88         }
  89         return ret;
  90 }
  91
  92 /**
  93  * Look up LKey from given B-tree lookup table, store the last index and return
  94  * searched LKey.
  95  *
  96  * @param bt
  97  *   Pointer to B-tree structure.
  98  * @param[out] idx
  99  *   Pointer to index. Even on search failure, returns index where it stops
 100  *   searching so that index can be used when inserting a new entry.
 101  * @param addr
 102  *   Search key.
 103  *
 104  * @return
 105  *   Searched LKey on success, UINT32_MAX on no match.
 106  */
 107 static uint32_t
 108 mr_btree_lookup(struct mlx5_mr_btree *bt, uint16_t *idx, uintptr_t addr)
 109 {
 110         struct mr_cache_entry *lkp_tbl;
 111         uint16_t n;
 112         uint16_t base = 0;
 113
 114         MLX5_ASSERT(bt != NULL);
 115         lkp_tbl = *bt->table;
 116         n = bt->len;
 117         /* First entry must be NULL for comparison. */
 118         MLX5_ASSERT(bt->len > 0 || (lkp_tbl[0].start == 0 &&
 119                                     lkp_tbl[0].lkey == UINT32_MAX));
 120         /* Binary search. */
 121         do {
 122                 register uint16_t delta = n >> 1;
 123
 124                 if (addr < lkp_tbl[base + delta].start) {
 125                         n = delta;
 126                 } else {
 127                         base += delta;
 128                         n -= delta;
 129                 }
 130         } while (n > 1);
 131         MLX5_ASSERT(addr >= lkp_tbl[base].start);
 132         *idx = base;
 133         if (addr < lkp_tbl[base].end)
 134                 return lkp_tbl[base].lkey;
 135         /* Not found. */
 136         return UINT32_MAX;
 137 }
 138
 139 /**
 140  * Insert an entry to B-tree lookup table.
 141  *
 142  * @param bt
 143  *   Pointer to B-tree structure.
 144  * @param entry
 145  *   Pointer to new entry to insert.
 146  *
 147  * @return
 148  *   0 on success, -1 on failure.
 149  */
 150 static int
 151 mr_btree_insert(struct mlx5_mr_btree *bt, struct mr_cache_entry *entry)
 152 {
 153         struct mr_cache_entry *lkp_tbl;
 154         uint16_t idx = 0;
 155         size_t shift;
 156
 157         MLX5_ASSERT(bt != NULL);
 158         MLX5_ASSERT(bt->len <= bt->size);
 159         MLX5_ASSERT(bt->len > 0);
 160         lkp_tbl = *bt->table;
 161         /* Find out the slot for insertion. */
 162         if (mr_btree_lookup(bt, &idx, entry->start) != UINT32_MAX) {
 163                 DRV_LOG(DEBUG,
 164                         "abort insertion to B-tree(%p): already exist at"
 165                         " idx=%u [0x%" PRIxPTR ", 0x%" PRIxPTR ") lkey=0x%x",
 166                         (void *)bt, idx, entry->start, entry->end, entry->lkey);
 167                 /* Already exist, return. */
 168                 return 0;
 169         }
 170         /* If table is full, return error. */
 171         if (unlikely(bt->len == bt->size)) {
 172                 bt->overflow = 1;
 173                 return -1;
 174         }
 175         /* Insert entry. */
 176         ++idx;
 177         shift = (bt->len - idx) * sizeof(struct mr_cache_entry);
 178         if (shift)
 179                 memmove(&lkp_tbl[idx + 1], &lkp_tbl[idx], shift);
 180         lkp_tbl[idx] = *entry;
 181         bt->len++;
 182         DRV_LOG(DEBUG,
 183                 "inserted B-tree(%p)[%u],"
 184                 " [0x%" PRIxPTR ", 0x%" PRIxPTR ") lkey=0x%x",
 185                 (void *)bt, idx, entry->start, entry->end, entry->lkey);
 186         return 0;
 187 }
 188
 189 /**
 190  * Initialize B-tree and allocate memory for lookup table.
 191  *
 192  * @param bt
 193  *   Pointer to B-tree structure.
 194  * @param n
 195  *   Number of entries to allocate.
 196  * @param socket
 197  *   NUMA socket on which memory must be allocated.
 198  *
 199  * @return
 200  *   0 on success, a negative errno value otherwise and rte_errno is set.
 201  */
 202 int
 203 mlx5_mr_btree_init(struct mlx5_mr_btree *bt, int n, int socket)
 204 {
 205         if (bt == NULL) {
 206                 rte_errno = EINVAL;
 207                 return -rte_errno;
 208         }
 209         MLX5_ASSERT(!bt->table && !bt->size);
 210         memset(bt, 0, sizeof(*bt));
 211         bt->table = mlx5_malloc(MLX5_MEM_RTE | MLX5_MEM_ZERO,
 212                                 sizeof(struct mr_cache_entry) * n,
 213                                 0, socket);
 214         if (bt->table == NULL) {
 215                 rte_errno = ENOMEM;
 216                 DRV_LOG(DEBUG,
 217                         "failed to allocate memory for btree cache on socket "
 218                         "%d", socket);
 219                 return -rte_errno;
 220         }
 221         bt->size = n;
 222         /* First entry must be NULL for binary search. */
 223         (*bt->table)[bt->len++] = (struct mr_cache_entry) {
 224                 .lkey = UINT32_MAX,
 225         };
 226         DRV_LOG(DEBUG, "initialized B-tree %p with table %p",
 227               (void *)bt, (void *)bt->table);
 228         return 0;
 229 }
 230
 231 /**
 232  * Free B-tree resources.
 233  *
 234  * @param bt
 235  *   Pointer to B-tree structure.
 236  */
 237 void
 238 mlx5_mr_btree_free(struct mlx5_mr_btree *bt)
 239 {
 240         if (bt == NULL)
 241                 return;
 242         DRV_LOG(DEBUG, "freeing B-tree %p with table %p",
 243               (void *)bt, (void *)bt->table);
 244         mlx5_free(bt->table);
 245         memset(bt, 0, sizeof(*bt));
 246 }
 247
 248 /**
 249  * Dump all the entries in a B-tree
 250  *
 251  * @param bt
 252  *   Pointer to B-tree structure.
 253  */
 254 void
 255 mlx5_mr_btree_dump(struct mlx5_mr_btree *bt __rte_unused)
 256 {
 257 #ifdef RTE_LIBRTE_MLX5_DEBUG
 258         int idx;
 259         struct mr_cache_entry *lkp_tbl;
 260
 261         if (bt == NULL)
 262                 return;
 263         lkp_tbl = *bt->table;
 264         for (idx = 0; idx < bt->len; ++idx) {
 265                 struct mr_cache_entry *entry = &lkp_tbl[idx];
 266
 267                 DRV_LOG(DEBUG, "B-tree(%p)[%u],"
 268                       " [0x%" PRIxPTR ", 0x%" PRIxPTR ") lkey=0x%x",
 269                       (void *)bt, idx, entry->start, entry->end, entry->lkey);
 270         }
 271 #endif
 272 }
 273
 274 /**
 275  * Find virtually contiguous memory chunk in a given MR.
 276  *
 277  * @param dev
 278  *   Pointer to MR structure.
 279  * @param[out] entry
 280  *   Pointer to returning MR cache entry. If not found, this will not be
 281  *   updated.
 282  * @param start_idx
 283  *   Start index of the memseg bitmap.
 284  *
 285  * @return
 286  *   Next index to go on lookup.
 287  */
 288 static int
 289 mr_find_next_chunk(struct mlx5_mr *mr, struct mr_cache_entry *entry,
 290                    int base_idx)
 291 {
 292         uintptr_t start = 0;
 293         uintptr_t end = 0;
 294         uint32_t idx = 0;
 295
 296         /* MR for external memory doesn't have memseg list. */
 297         if (mr->msl == NULL) {
 298                 MLX5_ASSERT(mr->ms_bmp_n == 1);
 299                 MLX5_ASSERT(mr->ms_n == 1);
 300                 MLX5_ASSERT(base_idx == 0);
 301                 /*
 302                  * Can't search it from memseg list but get it directly from
 303                  * pmd_mr as there's only one chunk.
 304                  */
 305                 entry->start = (uintptr_t)mr->pmd_mr.addr;
 306                 entry->end = (uintptr_t)mr->pmd_mr.addr + mr->pmd_mr.len;
 307                 entry->lkey = rte_cpu_to_be_32(mr->pmd_mr.lkey);
 308                 /* Returning 1 ends iteration. */
 309                 return 1;
 310         }
 311         for (idx = base_idx; idx < mr->ms_bmp_n; ++idx) {
 312                 if (rte_bitmap_get(mr->ms_bmp, idx)) {
 313                         const struct rte_memseg_list *msl;
 314                         const struct rte_memseg *ms;
 315
 316                         msl = mr->msl;
 317                         ms = rte_fbarray_get(&msl->memseg_arr,
 318                                              mr->ms_base_idx + idx);
 319                         MLX5_ASSERT(msl->page_sz == ms->hugepage_sz);
 320                         if (!start)
 321                                 start = ms->addr_64;
 322                         end = ms->addr_64 + ms->hugepage_sz;
 323                 } else if (start) {
 324                         /* Passed the end of a fragment. */
 325                         break;
 326                 }
 327         }
 328         if (start) {
 329                 /* Found one chunk. */
 330                 entry->start = start;
 331                 entry->end = end;
 332                 entry->lkey = rte_cpu_to_be_32(mr->pmd_mr.lkey);
 333         }
 334         return idx;
 335 }
 336
 337 /**
 338  * Insert a MR to the global B-tree cache. It may fail due to low-on-memory.
 339  * Then, this entry will have to be searched by mr_lookup_list() in
 340  * mlx5_mr_create() on miss.
 341  *
 342  * @param share_cache
 343  *   Pointer to a global shared MR cache.
 344  * @param mr
 345  *   Pointer to MR to insert.
 346  *
 347  * @return
 348  *   0 on success, -1 on failure.
 349  */
 350 int
 351 mlx5_mr_insert_cache(struct mlx5_mr_share_cache *share_cache,
 352                      struct mlx5_mr *mr)
 353 {
 354         unsigned int n;
 355
 356         DRV_LOG(DEBUG, "Inserting MR(%p) to global cache(%p)",
 357                 (void *)mr, (void *)share_cache);
 358         for (n = 0; n < mr->ms_bmp_n; ) {
 359                 struct mr_cache_entry entry;
 360
 361                 memset(&entry, 0, sizeof(entry));
 362                 /* Find a contiguous chunk and advance the index. */
 363                 n = mr_find_next_chunk(mr, &entry, n);
 364                 if (!entry.end)
 365                         break;
 366                 if (mr_btree_insert(&share_cache->cache, &entry) < 0) {
 367                         /*
 368                          * Overflowed, but the global table cannot be expanded
 369                          * because of deadlock.
 370                          */
 371                         return -1;
 372                 }
 373         }
 374         return 0;
 375 }
 376
 377 /**
 378  * Look up address in the original global MR list.
 379  *
 380  * @param share_cache
 381  *   Pointer to a global shared MR cache.
 382  * @param[out] entry
 383  *   Pointer to returning MR cache entry. If no match, this will not be updated.
 384  * @param addr
 385  *   Search key.
 386  *
 387  * @return
 388  *   Found MR on match, NULL otherwise.
 389  */
 390 struct mlx5_mr *
 391 mlx5_mr_lookup_list(struct mlx5_mr_share_cache *share_cache,
 392                     struct mr_cache_entry *entry, uintptr_t addr)
 393 {
 394         struct mlx5_mr *mr;
 395
 396         /* Iterate all the existing MRs. */
 397         LIST_FOREACH(mr, &share_cache->mr_list, mr) {
 398                 unsigned int n;
 399
 400                 if (mr->ms_n == 0)
 401                         continue;
 402                 for (n = 0; n < mr->ms_bmp_n; ) {
 403                         struct mr_cache_entry ret;
 404
 405                         memset(&ret, 0, sizeof(ret));
 406                         n = mr_find_next_chunk(mr, &ret, n);
 407                         if (addr >= ret.start && addr < ret.end) {
 408                                 /* Found. */
 409                                 *entry = ret;
 410                                 return mr;
 411                         }
 412                 }
 413         }
 414         return NULL;
 415 }
 416
 417 /**
 418  * Look up address on global MR cache.
 419  *
 420  * @param share_cache
 421  *   Pointer to a global shared MR cache.
 422  * @param[out] entry
 423  *   Pointer to returning MR cache entry. If no match, this will not be updated.
 424  * @param addr
 425  *   Search key.
 426  *
 427  * @return
 428  *   Searched LKey on success, UINT32_MAX on failure and rte_errno is set.
 429  */
 430 uint32_t
 431 mlx5_mr_lookup_cache(struct mlx5_mr_share_cache *share_cache,
 432                      struct mr_cache_entry *entry, uintptr_t addr)
 433 {
 434         uint16_t idx;
 435         uint32_t lkey = UINT32_MAX;
 436         struct mlx5_mr *mr;
 437
 438         /*
 439          * If the global cache has overflowed since it failed to expand the
 440          * B-tree table, it can't have all the existing MRs. Then, the address
 441          * has to be searched by traversing the original MR list instead, which
 442          * is very slow path. Otherwise, the global cache is all inclusive.
 443          */
 444         if (!unlikely(share_cache->cache.overflow)) {
 445                 lkey = mr_btree_lookup(&share_cache->cache, &idx, addr);
 446                 if (lkey != UINT32_MAX)
 447                         *entry = (*share_cache->cache.table)[idx];
 448         } else {
 449                 /* Falling back to the slowest path. */
 450                 mr = mlx5_mr_lookup_list(share_cache, entry, addr);
 451                 if (mr != NULL)
 452                         lkey = entry->lkey;
 453         }
 454         MLX5_ASSERT(lkey == UINT32_MAX || (addr >= entry->start &&
 455                                            addr < entry->end));
 456         return lkey;
 457 }
 458
 459 /**
 460  * Free MR resources. MR lock must not be held to avoid a deadlock. rte_free()
 461  * can raise memory free event and the callback function will spin on the lock.
 462  *
 463  * @param mr
 464  *   Pointer to MR to free.
 465  */
 466 void
 467 mlx5_mr_free(struct mlx5_mr *mr, mlx5_dereg_mr_t dereg_mr_cb)
 468 {
 469         if (mr == NULL)
 470                 return;
 471         DRV_LOG(DEBUG, "freeing MR(%p):", (void *)mr);
 472         dereg_mr_cb(&mr->pmd_mr);
 473         if (mr->ms_bmp != NULL)
 474                 rte_bitmap_free(mr->ms_bmp);
 475         mlx5_free(mr);
 476 }
 477
 478 void
 479 mlx5_mr_rebuild_cache(struct mlx5_mr_share_cache *share_cache)
 480 {
 481         struct mlx5_mr *mr;
 482
 483         DRV_LOG(DEBUG, "Rebuild dev cache[] %p", (void *)share_cache);
 484         /* Flush cache to rebuild. */
 485         share_cache->cache.len = 1;
 486         share_cache->cache.overflow = 0;
 487         /* Iterate all the existing MRs. */
 488         LIST_FOREACH(mr, &share_cache->mr_list, mr)
 489                 if (mlx5_mr_insert_cache(share_cache, mr) < 0)
 490                         return;
 491 }
 492
 493 /**
 494  * Release resources of detached MR having no online entry.
 495  *
 496  * @param share_cache
 497  *   Pointer to a global shared MR cache.
 498  */
 499 static void
 500 mlx5_mr_garbage_collect(struct mlx5_mr_share_cache *share_cache)
 501 {
 502         struct mlx5_mr *mr_next;
 503         struct mlx5_mr_list free_list = LIST_HEAD_INITIALIZER(free_list);
 504
 505         /* Must be called from the primary process. */
 506         MLX5_ASSERT(rte_eal_process_type() == RTE_PROC_PRIMARY);
 507         /*
 508          * MR can't be freed with holding the lock because rte_free() could call
 509          * memory free callback function. This will be a deadlock situation.
 510          */
 511         rte_rwlock_write_lock(&share_cache->rwlock);
 512         /* Detach the whole free list and release it after unlocking. */
 513         free_list = share_cache->mr_free_list;
 514         LIST_INIT(&share_cache->mr_free_list);
 515         rte_rwlock_write_unlock(&share_cache->rwlock);
 516         /* Release resources. */
 517         mr_next = LIST_FIRST(&free_list);
 518         while (mr_next != NULL) {
 519                 struct mlx5_mr *mr = mr_next;
 520
 521                 mr_next = LIST_NEXT(mr, mr);
 522                 mlx5_mr_free(mr, share_cache->dereg_mr_cb);
 523         }
 524 }
 525
 526 /* Called during rte_memseg_contig_walk() by mlx5_mr_create(). */
 527 static int
 528 mr_find_contig_memsegs_cb(const struct rte_memseg_list *msl,
 529                           const struct rte_memseg *ms, size_t len, void *arg)
 530 {
 531         struct mr_find_contig_memsegs_data *data = arg;
 532
 533         if (data->addr < ms->addr_64 || data->addr >= ms->addr_64 + len)
 534                 return 0;
 535         /* Found, save it and stop walking. */
 536         data->start = ms->addr_64;
 537         data->end = ms->addr_64 + len;
 538         data->msl = msl;
 539         return 1;
 540 }
 541
 542 /**
 543  * Create a new global Memory Region (MR) for a missing virtual address.
 544  * This API should be called on a secondary process, then a request is sent to
 545  * the primary process in order to create a MR for the address. As the global MR
 546  * list is on the shared memory, following LKey lookup should succeed unless the
 547  * request fails.
 548  *
 549  * @param pd
 550  *   Pointer to pd of a device (net, regex, vdpa,...).
 551  * @param share_cache
 552  *   Pointer to a global shared MR cache.
 553  * @param[out] entry
 554  *   Pointer to returning MR cache entry, found in the global cache or newly
 555  *   created. If failed to create one, this will not be updated.
 556  * @param addr
 557  *   Target virtual address to register.
 558  * @param mr_ext_memseg_en
 559  *   Configurable flag about external memory segment enable or not.
 560  *
 561  * @return
 562  *   Searched LKey on success, UINT32_MAX on failure and rte_errno is set.
 563  */
 564 static uint32_t
 565 mlx5_mr_create_secondary(void *pd __rte_unused,
 566                          struct mlx5_mp_id *mp_id,
 567                          struct mlx5_mr_share_cache *share_cache,
 568                          struct mr_cache_entry *entry, uintptr_t addr,
 569                          unsigned int mr_ext_memseg_en __rte_unused)
 570 {
 571         int ret;
 572
 573         DRV_LOG(DEBUG, "port %u requesting MR creation for address (%p)",
 574               mp_id->port_id, (void *)addr);
 575         ret = mlx5_mp_req_mr_create(mp_id, addr);
 576         if (ret) {
 577                 DRV_LOG(DEBUG, "Fail to request MR creation for address (%p)",
 578                       (void *)addr);
 579                 return UINT32_MAX;
 580         }
 581         rte_rwlock_read_lock(&share_cache->rwlock);
 582         /* Fill in output data. */
 583         mlx5_mr_lookup_cache(share_cache, entry, addr);
 584         /* Lookup can't fail. */
 585         MLX5_ASSERT(entry->lkey != UINT32_MAX);
 586         rte_rwlock_read_unlock(&share_cache->rwlock);
 587         DRV_LOG(DEBUG, "MR CREATED by primary process for %p:\n"
 588               "  [0x%" PRIxPTR ", 0x%" PRIxPTR "), lkey=0x%x",
 589               (void *)addr, entry->start, entry->end, entry->lkey);
 590         return entry->lkey;
 591 }
 592
 593 /**
 594  * Create a new global Memory Region (MR) for a missing virtual address.
 595  * Register entire virtually contiguous memory chunk around the address.
 596  *
 597  * @param pd
 598  *   Pointer to pd of a device (net, regex, vdpa,...).
 599  * @param share_cache
 600  *   Pointer to a global shared MR cache.
 601  * @param[out] entry
 602  *   Pointer to returning MR cache entry, found in the global cache or newly
 603  *   created. If failed to create one, this will not be updated.
 604  * @param addr
 605  *   Target virtual address to register.
 606  * @param mr_ext_memseg_en
 607  *   Configurable flag about external memory segment enable or not.
 608  *
 609  * @return
 610  *   Searched LKey on success, UINT32_MAX on failure and rte_errno is set.
 611  */
 612 uint32_t
 613 mlx5_mr_create_primary(void *pd,
 614                        struct mlx5_mr_share_cache *share_cache,
 615                        struct mr_cache_entry *entry, uintptr_t addr,
 616                        unsigned int mr_ext_memseg_en)
 617 {
 618         struct mr_find_contig_memsegs_data data = {.addr = addr, };
 619         struct mr_find_contig_memsegs_data data_re;
 620         const struct rte_memseg_list *msl;
 621         const struct rte_memseg *ms;
 622         struct mlx5_mr *mr = NULL;
 623         int ms_idx_shift = -1;
 624         uint32_t bmp_size;
 625         void *bmp_mem;
 626         uint32_t ms_n;
 627         uint32_t n;
 628         size_t len;
 629
 630         DRV_LOG(DEBUG, "Creating a MR using address (%p)", (void *)addr);
 631         /*
 632          * Release detached MRs if any. This can't be called with holding either
 633          * memory_hotplug_lock or share_cache->rwlock. MRs on the free list have
 634          * been detached by the memory free event but it couldn't be released
 635          * inside the callback due to deadlock. As a result, releasing resources
 636          * is quite opportunistic.
 637          */
 638         mlx5_mr_garbage_collect(share_cache);
 639         /*
 640          * If enabled, find out a contiguous virtual address chunk in use, to
 641          * which the given address belongs, in order to register maximum range.
 642          * In the best case where mempools are not dynamically recreated and
 643          * '--socket-mem' is specified as an EAL option, it is very likely to
 644          * have only one MR(LKey) per a socket and per a hugepage-size even
 645          * though the system memory is highly fragmented. As the whole memory
 646          * chunk will be pinned by kernel, it can't be reused unless entire
 647          * chunk is freed from EAL.
 648          *
 649          * If disabled, just register one memseg (page). Then, memory
 650          * consumption will be minimized but it may drop performance if there
 651          * are many MRs to lookup on the datapath.
 652          */
 653         if (!mr_ext_memseg_en) {
 654                 data.msl = rte_mem_virt2memseg_list((void *)addr);
 655                 data.start = RTE_ALIGN_FLOOR(addr, data.msl->page_sz);
 656                 data.end = data.start + data.msl->page_sz;
 657         } else if (!rte_memseg_contig_walk(mr_find_contig_memsegs_cb, &data)) {
 658                 DRV_LOG(WARNING,
 659                         "Unable to find virtually contiguous"
 660                         " chunk for address (%p)."
 661                         " rte_memseg_contig_walk() failed.", (void *)addr);
 662                 rte_errno = ENXIO;
 663                 goto err_nolock;
 664         }
 665 alloc_resources:
 666         /* Addresses must be page-aligned. */
 667         MLX5_ASSERT(data.msl);
 668         MLX5_ASSERT(rte_is_aligned((void *)data.start, data.msl->page_sz));
 669         MLX5_ASSERT(rte_is_aligned((void *)data.end, data.msl->page_sz));
 670         msl = data.msl;
 671         ms = rte_mem_virt2memseg((void *)data.start, msl);
 672         len = data.end - data.start;
 673         MLX5_ASSERT(ms);
 674         MLX5_ASSERT(msl->page_sz == ms->hugepage_sz);
 675         /* Number of memsegs in the range. */
 676         ms_n = len / msl->page_sz;
 677         DRV_LOG(DEBUG, "Extending %p to [0x%" PRIxPTR ", 0x%" PRIxPTR "),"
 678               " page_sz=0x%" PRIx64 ", ms_n=%u",
 679               (void *)addr, data.start, data.end, msl->page_sz, ms_n);
 680         /* Size of memory for bitmap. */
 681         bmp_size = rte_bitmap_get_memory_footprint(ms_n);
 682         mr = mlx5_malloc(MLX5_MEM_RTE |  MLX5_MEM_ZERO,
 683                          RTE_ALIGN_CEIL(sizeof(*mr), RTE_CACHE_LINE_SIZE) +
 684                          bmp_size, RTE_CACHE_LINE_SIZE, msl->socket_id);
 685         if (mr == NULL) {
 686                 DRV_LOG(DEBUG, "Unable to allocate memory for a new MR of"
 687                       " address (%p).", (void *)addr);
 688                 rte_errno = ENOMEM;
 689                 goto err_nolock;
 690         }
 691         mr->msl = msl;
 692         /*
 693          * Save the index of the first memseg and initialize memseg bitmap. To
 694          * see if a memseg of ms_idx in the memseg-list is still valid, check:
 695          *      rte_bitmap_get(mr->bmp, ms_idx - mr->ms_base_idx)
 696          */
 697         mr->ms_base_idx = rte_fbarray_find_idx(&msl->memseg_arr, ms);
 698         bmp_mem = RTE_PTR_ALIGN_CEIL(mr + 1, RTE_CACHE_LINE_SIZE);
 699         mr->ms_bmp = rte_bitmap_init(ms_n, bmp_mem, bmp_size);
 700         if (mr->ms_bmp == NULL) {
 701                 DRV_LOG(DEBUG, "Unable to initialize bitmap for a new MR of"
 702                       " address (%p).", (void *)addr);
 703                 rte_errno = EINVAL;
 704                 goto err_nolock;
 705         }
 706         /*
 707          * Should recheck whether the extended contiguous chunk is still valid.
 708          * Because memory_hotplug_lock can't be held if there's any memory
 709          * related calls in a critical path, resource allocation above can't be
 710          * locked. If the memory has been changed at this point, try again with
 711          * just single page. If not, go on with the big chunk atomically from
 712          * here.
 713          */
 714         rte_mcfg_mem_read_lock();
 715         data_re = data;
 716         if (len > msl->page_sz &&
 717             !rte_memseg_contig_walk(mr_find_contig_memsegs_cb, &data_re)) {
 718                 DRV_LOG(DEBUG,
 719                         "Unable to find virtually contiguous chunk for address "
 720                         "(%p). rte_memseg_contig_walk() failed.", (void *)addr);
 721                 rte_errno = ENXIO;
 722                 goto err_memlock;
 723         }
 724         if (data.start != data_re.start || data.end != data_re.end) {
 725                 /*
 726                  * The extended contiguous chunk has been changed. Try again
 727                  * with single memseg instead.
 728                  */
 729                 data.start = RTE_ALIGN_FLOOR(addr, msl->page_sz);
 730                 data.end = data.start + msl->page_sz;
 731                 rte_mcfg_mem_read_unlock();
 732                 mlx5_mr_free(mr, share_cache->dereg_mr_cb);
 733                 goto alloc_resources;
 734         }
 735         MLX5_ASSERT(data.msl == data_re.msl);
 736         rte_rwlock_write_lock(&share_cache->rwlock);
 737         /*
 738          * Check the address is really missing. If other thread already created
 739          * one or it is not found due to overflow, abort and return.
 740          */
 741         if (mlx5_mr_lookup_cache(share_cache, entry, addr) != UINT32_MAX) {
 742                 /*
 743                  * Insert to the global cache table. It may fail due to
 744                  * low-on-memory. Then, this entry will have to be searched
 745                  * here again.
 746                  */
 747                 mr_btree_insert(&share_cache->cache, entry);
 748                 DRV_LOG(DEBUG, "Found MR for %p on final lookup, abort",
 749                         (void *)addr);
 750                 rte_rwlock_write_unlock(&share_cache->rwlock);
 751                 rte_mcfg_mem_read_unlock();
 752                 /*
 753                  * Must be unlocked before calling rte_free() because
 754                  * mlx5_mr_mem_event_free_cb() can be called inside.
 755                  */
 756                 mlx5_mr_free(mr, share_cache->dereg_mr_cb);
 757                 return entry->lkey;
 758         }
 759         /*
 760          * Trim start and end addresses for verbs MR. Set bits for registering
 761          * memsegs but exclude already registered ones. Bitmap can be
 762          * fragmented.
 763          */
 764         for (n = 0; n < ms_n; ++n) {
 765                 uintptr_t start;
 766                 struct mr_cache_entry ret;
 767
 768                 memset(&ret, 0, sizeof(ret));
 769                 start = data_re.start + n * msl->page_sz;
 770                 /* Exclude memsegs already registered by other MRs. */
 771                 if (mlx5_mr_lookup_cache(share_cache, &ret, start) ==
 772                     UINT32_MAX) {
 773                         /*
 774                          * Start from the first unregistered memseg in the
 775                          * extended range.
 776                          */
 777                         if (ms_idx_shift == -1) {
 778                                 mr->ms_base_idx += n;
 779                                 data.start = start;
 780                                 ms_idx_shift = n;
 781                         }
 782                         data.end = start + msl->page_sz;
 783                         rte_bitmap_set(mr->ms_bmp, n - ms_idx_shift);
 784                         ++mr->ms_n;
 785                 }
 786         }
 787         len = data.end - data.start;
 788         mr->ms_bmp_n = len / msl->page_sz;
 789         MLX5_ASSERT(ms_idx_shift + mr->ms_bmp_n <= ms_n);
 790         /*
 791          * Finally create an MR for the memory chunk. Verbs: ibv_reg_mr() can
 792          * be called with holding the memory lock because it doesn't use
 793          * mlx5_alloc_buf_extern() which eventually calls rte_malloc_socket()
 794          * through mlx5_alloc_verbs_buf().
 795          */
 796         share_cache->reg_mr_cb(pd, (void *)data.start, len, &mr->pmd_mr);
 797         if (mr->pmd_mr.obj == NULL) {
 798                 DRV_LOG(DEBUG, "Fail to create an MR for address (%p)",
 799                       (void *)addr);
 800                 rte_errno = EINVAL;
 801                 goto err_mrlock;
 802         }
 803         MLX5_ASSERT((uintptr_t)mr->pmd_mr.addr == data.start);
 804         MLX5_ASSERT(mr->pmd_mr.len);
 805         LIST_INSERT_HEAD(&share_cache->mr_list, mr, mr);
 806         DRV_LOG(DEBUG, "MR CREATED (%p) for %p:\n"
 807               "  [0x%" PRIxPTR ", 0x%" PRIxPTR "),"
 808               " lkey=0x%x base_idx=%u ms_n=%u, ms_bmp_n=%u",
 809               (void *)mr, (void *)addr, data.start, data.end,
 810               rte_cpu_to_be_32(mr->pmd_mr.lkey),
 811               mr->ms_base_idx, mr->ms_n, mr->ms_bmp_n);
 812         /* Insert to the global cache table. */
 813         mlx5_mr_insert_cache(share_cache, mr);
 814         /* Fill in output data. */
 815         mlx5_mr_lookup_cache(share_cache, entry, addr);
 816         /* Lookup can't fail. */
 817         MLX5_ASSERT(entry->lkey != UINT32_MAX);
 818         rte_rwlock_write_unlock(&share_cache->rwlock);
 819         rte_mcfg_mem_read_unlock();
 820         return entry->lkey;
 821 err_mrlock:
 822         rte_rwlock_write_unlock(&share_cache->rwlock);
 823 err_memlock:
 824         rte_mcfg_mem_read_unlock();
 825 err_nolock:
 826         /*
 827          * In case of error, as this can be called in a datapath, a warning
 828          * message per an error is preferable instead. Must be unlocked before
 829          * calling rte_free() because mlx5_mr_mem_event_free_cb() can be called
 830          * inside.
 831          */
 832         mlx5_mr_free(mr, share_cache->dereg_mr_cb);
 833         return UINT32_MAX;
 834 }
 835
 836 /**
 837  * Create a new global Memory Region (MR) for a missing virtual address.
 838  * This can be called from primary and secondary process.
 839  *
 840  * @param pd
 841  *   Pointer to pd handle of a device (net, regex, vdpa,...).
 842  * @param share_cache
 843  *   Pointer to a global shared MR cache.
 844  * @param[out] entry
 845  *   Pointer to returning MR cache entry, found in the global cache or newly
 846  *   created. If failed to create one, this will not be updated.
 847  * @param addr
 848  *   Target virtual address to register.
 849  *
 850  * @return
 851  *   Searched LKey on success, UINT32_MAX on failure and rte_errno is set.
 852  */
 853 static uint32_t
 854 mlx5_mr_create(void *pd, struct mlx5_mp_id *mp_id,
 855                struct mlx5_mr_share_cache *share_cache,
 856                struct mr_cache_entry *entry, uintptr_t addr,
 857                unsigned int mr_ext_memseg_en)
 858 {
 859         uint32_t ret = 0;
 860
 861         switch (rte_eal_process_type()) {
 862         case RTE_PROC_PRIMARY:
 863                 ret = mlx5_mr_create_primary(pd, share_cache, entry,
 864                                              addr, mr_ext_memseg_en);
 865                 break;
 866         case RTE_PROC_SECONDARY:
 867                 ret = mlx5_mr_create_secondary(pd, mp_id, share_cache, entry,
 868                                                addr, mr_ext_memseg_en);
 869                 break;
 870         default:
 871                 break;
 872         }
 873         return ret;
 874 }
 875
 876 /**
 877  * Look up address in the global MR cache table. If not found, create a new MR.
 878  * Insert the found/created entry to local bottom-half cache table.
 879  *
 880  * @param pd
 881  *   Pointer to pd of a device (net, regex, vdpa,...).
 882  * @param share_cache
 883  *   Pointer to a global shared MR cache.
 884  * @param mr_ctrl
 885  *   Pointer to per-queue MR control structure.
 886  * @param[out] entry
 887  *   Pointer to returning MR cache entry, found in the global cache or newly
 888  *   created. If failed to create one, this is not written.
 889  * @param addr
 890  *   Search key.
 891  *
 892  * @return
 893  *   Searched LKey on success, UINT32_MAX on no match.
 894  */
 895 static uint32_t
 896 mr_lookup_caches(void *pd, struct mlx5_mp_id *mp_id,
 897                  struct mlx5_mr_share_cache *share_cache,
 898                  struct mlx5_mr_ctrl *mr_ctrl,
 899                  struct mr_cache_entry *entry, uintptr_t addr,
 900                  unsigned int mr_ext_memseg_en)
 901 {
 902         struct mlx5_mr_btree *bt = &mr_ctrl->cache_bh;
 903         uint32_t lkey;
 904         uint16_t idx;
 905
 906         /* If local cache table is full, try to double it. */
 907         if (unlikely(bt->len == bt->size))
 908                 mr_btree_expand(bt, bt->size << 1);
 909         /* Look up in the global cache. */
 910         rte_rwlock_read_lock(&share_cache->rwlock);
 911         lkey = mr_btree_lookup(&share_cache->cache, &idx, addr);
 912         if (lkey != UINT32_MAX) {
 913                 /* Found. */
 914                 *entry = (*share_cache->cache.table)[idx];
 915                 rte_rwlock_read_unlock(&share_cache->rwlock);
 916                 /*
 917                  * Update local cache. Even if it fails, return the found entry
 918                  * to update top-half cache. Next time, this entry will be found
 919                  * in the global cache.
 920                  */
 921                 mr_btree_insert(bt, entry);
 922                 return lkey;
 923         }
 924         rte_rwlock_read_unlock(&share_cache->rwlock);
 925         /* First time to see the address? Create a new MR. */
 926         lkey = mlx5_mr_create(pd, mp_id, share_cache, entry, addr,
 927                               mr_ext_memseg_en);
 928         /*
 929          * Update the local cache if successfully created a new global MR. Even
 930          * if failed to create one, there's no action to take in this datapath
 931          * code. As returning LKey is invalid, this will eventually make HW
 932          * fail.
 933          */
 934         if (lkey != UINT32_MAX)
 935                 mr_btree_insert(bt, entry);
 936         return lkey;
 937 }
 938
 939 /**
 940  * Bottom-half of LKey search on datapath. First search in cache_bh[] and if
 941  * misses, search in the global MR cache table and update the new entry to
 942  * per-queue local caches.
 943  *
 944  * @param pd
 945  *   Pointer to pd of a device (net, regex, vdpa,...).
 946  * @param share_cache
 947  *   Pointer to a global shared MR cache.
 948  * @param mr_ctrl
 949  *   Pointer to per-queue MR control structure.
 950  * @param addr
 951  *   Search key.
 952  *
 953  * @return
 954  *   Searched LKey on success, UINT32_MAX on no match.
 955  */
 956 uint32_t mlx5_mr_addr2mr_bh(void *pd, struct mlx5_mp_id *mp_id,
 957                             struct mlx5_mr_share_cache *share_cache,
 958                             struct mlx5_mr_ctrl *mr_ctrl,
 959                             uintptr_t addr, unsigned int mr_ext_memseg_en)
 960 {
 961         uint32_t lkey;
 962         uint16_t bh_idx = 0;
 963         /* Victim in top-half cache to replace with new entry. */
 964         struct mr_cache_entry *repl = &mr_ctrl->cache[mr_ctrl->head];
 965
 966         /* Binary-search MR translation table. */
 967         lkey = mr_btree_lookup(&mr_ctrl->cache_bh, &bh_idx, addr);
 968         /* Update top-half cache. */
 969         if (likely(lkey != UINT32_MAX)) {
 970                 *repl = (*mr_ctrl->cache_bh.table)[bh_idx];
 971         } else {
 972                 /*
 973                  * If missed in local lookup table, search in the global cache
 974                  * and local cache_bh[] will be updated inside if possible.
 975                  * Top-half cache entry will also be updated.
 976                  */
 977                 lkey = mr_lookup_caches(pd, mp_id, share_cache, mr_ctrl,
 978                                         repl, addr, mr_ext_memseg_en);
 979                 if (unlikely(lkey == UINT32_MAX))
 980                         return UINT32_MAX;
 981         }
 982         /* Update the most recently used entry. */
 983         mr_ctrl->mru = mr_ctrl->head;
 984         /* Point to the next victim, the oldest. */
 985         mr_ctrl->head = (mr_ctrl->head + 1) % MLX5_MR_CACHE_N;
 986         return lkey;
 987 }
 988
 989 /**
 990  * Release all the created MRs and resources on global MR cache of a device.
 991  * list.
 992  *
 993  * @param share_cache
 994  *   Pointer to a global shared MR cache.
 995  */
 996 void
 997 mlx5_mr_release_cache(struct mlx5_mr_share_cache *share_cache)
 998 {
 999         struct mlx5_mr *mr_next;
1000
1001         rte_rwlock_write_lock(&share_cache->rwlock);
1002         /* Detach from MR list and move to free list. */
1003         mr_next = LIST_FIRST(&share_cache->mr_list);
1004         while (mr_next != NULL) {
1005                 struct mlx5_mr *mr = mr_next;
1006
1007                 mr_next = LIST_NEXT(mr, mr);
1008                 LIST_REMOVE(mr, mr);
1009                 LIST_INSERT_HEAD(&share_cache->mr_free_list, mr, mr);
1010         }
1011         LIST_INIT(&share_cache->mr_list);
1012         /* Free global cache. */
1013         mlx5_mr_btree_free(&share_cache->cache);
1014         rte_rwlock_write_unlock(&share_cache->rwlock);
1015         /* Free all remaining MRs. */
1016         mlx5_mr_garbage_collect(share_cache);
1017 }
1018
1019 /**
1020  * Flush all of the local cache entries.
1021  *
1022  * @param mr_ctrl
1023  *   Pointer to per-queue MR local cache.
1024  */
1025 void
1026 mlx5_mr_flush_local_cache(struct mlx5_mr_ctrl *mr_ctrl)
1027 {
1028         /* Reset the most-recently-used index. */
1029         mr_ctrl->mru = 0;
1030         /* Reset the linear search array. */
1031         mr_ctrl->head = 0;
1032         memset(mr_ctrl->cache, 0, sizeof(mr_ctrl->cache));
1033         /* Reset the B-tree table. */
1034         mr_ctrl->cache_bh.len = 1;
1035         mr_ctrl->cache_bh.overflow = 0;
1036         /* Update the generation number. */
1037         mr_ctrl->cur_gen = *mr_ctrl->dev_gen_ptr;
1038         DRV_LOG(DEBUG, "mr_ctrl(%p): flushed, cur_gen=%d",
1039                 (void *)mr_ctrl, mr_ctrl->cur_gen);
1040 }
1041
1042 /**
1043  * Creates a memory region for external memory, that is memory which is not
1044  * part of the DPDK memory segments.
1045  *
1046  * @param pd
1047  *   Pointer to pd of a device (net, regex, vdpa,...).
1048  * @param addr
1049  *   Starting virtual address of memory.
1050  * @param len
1051  *   Length of memory segment being mapped.
1052  * @param socked_id
1053  *   Socket to allocate heap memory for the control structures.
1054  *
1055  * @return
1056  *   Pointer to MR structure on success, NULL otherwise.
1057  */
1058 struct mlx5_mr *
1059 mlx5_create_mr_ext(void *pd, uintptr_t addr, size_t len, int socket_id,
1060                    mlx5_reg_mr_t reg_mr_cb)
1061 {
1062         struct mlx5_mr *mr = NULL;
1063
1064         mr = mlx5_malloc(MLX5_MEM_RTE | MLX5_MEM_ZERO,
1065                          RTE_ALIGN_CEIL(sizeof(*mr), RTE_CACHE_LINE_SIZE),
1066                          RTE_CACHE_LINE_SIZE, socket_id);
1067         if (mr == NULL)
1068                 return NULL;
1069         reg_mr_cb(pd, (void *)addr, len, &mr->pmd_mr);
1070         if (mr->pmd_mr.obj == NULL) {
1071                 DRV_LOG(WARNING,
1072                         "Fail to create MR for address (%p)",
1073                         (void *)addr);
1074                 mlx5_free(mr);
1075                 return NULL;
1076         }
1077         mr->msl = NULL; /* Mark it is external memory. */
1078         mr->ms_bmp = NULL;
1079         mr->ms_n = 1;
1080         mr->ms_bmp_n = 1;
1081         DRV_LOG(DEBUG,
1082                 "MR CREATED (%p) for external memory %p:\n"
1083                 "  [0x%" PRIxPTR ", 0x%" PRIxPTR "),"
1084                 " lkey=0x%x base_idx=%u ms_n=%u, ms_bmp_n=%u",
1085                 (void *)mr, (void *)addr,
1086                 addr, addr + len, rte_cpu_to_be_32(mr->pmd_mr.lkey),
1087                 mr->ms_base_idx, mr->ms_n, mr->ms_bmp_n);
1088         return mr;
1089 }
1090
1091 /**
1092  * Callback for memory free event. Iterate freed memsegs and check whether it
1093  * belongs to an existing MR. If found, clear the bit from bitmap of MR. As a
1094  * result, the MR would be fragmented. If it becomes empty, the MR will be freed
1095  * later by mlx5_mr_garbage_collect(). Even if this callback is called from a
1096  * secondary process, the garbage collector will be called in primary process
1097  * as the secondary process can't call mlx5_mr_create().
1098  *
1099  * The global cache must be rebuilt if there's any change and this event has to
1100  * be propagated to dataplane threads to flush the local caches.
1101  *
1102  * @param share_cache
1103  *   Pointer to a global shared MR cache.
1104  * @param ibdev_name
1105  *   Name of ibv device.
1106  * @param addr
1107  *   Address of freed memory.
1108  * @param len
1109  *   Size of freed memory.
1110  */
1111 void
1112 mlx5_free_mr_by_addr(struct mlx5_mr_share_cache *share_cache,
1113                      const char *ibdev_name, const void *addr, size_t len)
1114 {
1115         const struct rte_memseg_list *msl;
1116         struct mlx5_mr *mr;
1117         int ms_n;
1118         int i;
1119         int rebuild = 0;
1120
1121         DRV_LOG(DEBUG, "device %s free callback: addr=%p, len=%zu",
1122                 ibdev_name, addr, len);
1123         msl = rte_mem_virt2memseg_list(addr);
1124         /* addr and len must be page-aligned. */
1125         MLX5_ASSERT((uintptr_t)addr ==
1126                     RTE_ALIGN((uintptr_t)addr, msl->page_sz));
1127         MLX5_ASSERT(len == RTE_ALIGN(len, msl->page_sz));
1128         ms_n = len / msl->page_sz;
1129         rte_rwlock_write_lock(&share_cache->rwlock);
1130         /* Clear bits of freed memsegs from MR. */
1131         for (i = 0; i < ms_n; ++i) {
1132                 const struct rte_memseg *ms;
1133                 struct mr_cache_entry entry;
1134                 uintptr_t start;
1135                 int ms_idx;
1136                 uint32_t pos;
1137
1138                 /* Find MR having this memseg. */
1139                 start = (uintptr_t)addr + i * msl->page_sz;
1140                 mr = mlx5_mr_lookup_list(share_cache, &entry, start);
1141                 if (mr == NULL)
1142                         continue;
1143                 MLX5_ASSERT(mr->msl); /* Can't be external memory. */
1144                 ms = rte_mem_virt2memseg((void *)start, msl);
1145                 MLX5_ASSERT(ms != NULL);
1146                 MLX5_ASSERT(msl->page_sz == ms->hugepage_sz);
1147                 ms_idx = rte_fbarray_find_idx(&msl->memseg_arr, ms);
1148                 pos = ms_idx - mr->ms_base_idx;
1149                 MLX5_ASSERT(rte_bitmap_get(mr->ms_bmp, pos));
1150                 MLX5_ASSERT(pos < mr->ms_bmp_n);
1151                 DRV_LOG(DEBUG, "device %s MR(%p): clear bitmap[%u] for addr %p",
1152                         ibdev_name, (void *)mr, pos, (void *)start);
1153                 rte_bitmap_clear(mr->ms_bmp, pos);
1154                 if (--mr->ms_n == 0) {
1155                         LIST_REMOVE(mr, mr);
1156                         LIST_INSERT_HEAD(&share_cache->mr_free_list, mr, mr);
1157                         DRV_LOG(DEBUG, "device %s remove MR(%p) from list",
1158                                 ibdev_name, (void *)mr);
1159                 }
1160                 /*
1161                  * MR is fragmented or will be freed. the global cache must be
1162                  * rebuilt.
1163                  */
1164                 rebuild = 1;
1165         }
1166         if (rebuild) {
1167                 mlx5_mr_rebuild_cache(share_cache);
1168                 /*
1169                  * No explicit wmb is needed after updating dev_gen due to
1170                  * store-release ordering in unlock that provides the
1171                  * implicit barrier at the software visible level.
1172                  */
1173                 ++share_cache->dev_gen;
1174                 DRV_LOG(DEBUG, "broadcasting local cache flush, gen=%d",
1175                         share_cache->dev_gen);
1176         }
1177         rte_rwlock_write_unlock(&share_cache->rwlock);
1178 }
1179
1180 /**
1181  * Dump all the created MRs and the global cache entries.
1182  *
1183  * @param sh
1184  *   Pointer to Ethernet device shared context.
1185  */
1186 void
1187 mlx5_mr_dump_cache(struct mlx5_mr_share_cache *share_cache __rte_unused)
1188 {
1189 #ifdef RTE_LIBRTE_MLX5_DEBUG
1190         struct mlx5_mr *mr;
1191         int mr_n = 0;
1192         int chunk_n = 0;
1193
1194         rte_rwlock_read_lock(&share_cache->rwlock);
1195         /* Iterate all the existing MRs. */
1196         LIST_FOREACH(mr, &share_cache->mr_list, mr) {
1197                 unsigned int n;
1198
1199                 DRV_LOG(DEBUG, "MR[%u], LKey = 0x%x, ms_n = %u, ms_bmp_n = %u",
1200                       mr_n++, rte_cpu_to_be_32(mr->pmd_mr.lkey),
1201                       mr->ms_n, mr->ms_bmp_n);
1202                 if (mr->ms_n == 0)
1203                         continue;
1204                 for (n = 0; n < mr->ms_bmp_n; ) {
1205                         struct mr_cache_entry ret = { 0, };
1206
1207                         n = mr_find_next_chunk(mr, &ret, n);
1208                         if (!ret.end)
1209                                 break;
1210                         DRV_LOG(DEBUG,
1211                                 "  chunk[%u], [0x%" PRIxPTR ", 0x%" PRIxPTR ")",
1212                                 chunk_n++, ret.start, ret.end);
1213                 }
1214         }
1215         DRV_LOG(DEBUG, "Dumping global cache %p", (void *)share_cache);
1216         mlx5_mr_btree_dump(&share_cache->cache);
1217         rte_rwlock_read_unlock(&share_cache->rwlock);
1218 #endif
1219 }
1220
1221 static int
1222 mlx5_range_compare_start(const void *lhs, const void *rhs)
1223 {
1224         const struct mlx5_range *r1 = lhs, *r2 = rhs;
1225
1226         if (r1->start > r2->start)
1227                 return 1;
1228         else if (r1->start < r2->start)
1229                 return -1;
1230         return 0;
1231 }
1232
1233 static void
1234 mlx5_range_from_mempool_chunk(struct rte_mempool *mp, void *opaque,
1235                               struct rte_mempool_memhdr *memhdr,
1236                               unsigned int idx)
1237 {
1238         struct mlx5_range *ranges = opaque, *range = &ranges[idx];
1239         uint64_t page_size = rte_mem_page_size();
1240
1241         RTE_SET_USED(mp);
1242         range->start = RTE_ALIGN_FLOOR((uintptr_t)memhdr->addr, page_size);
1243         range->end = RTE_ALIGN_CEIL(range->start + memhdr->len, page_size);
1244 }
1245
1246 /**
1247  * Get VA-contiguous ranges of the mempool memory.
1248  * Each range start and end is aligned to the system page size.
1249  *
1250  * @param[in] mp
1251  *   Analyzed mempool.
1252  * @param[out] out
1253  *   Receives the ranges, caller must release it with free().
1254  * @param[out] ount_n
1255  *   Receives the number of @p out elements.
1256  *
1257  * @return
1258  *   0 on success, (-1) on failure.
1259  */
1260 static int
1261 mlx5_get_mempool_ranges(struct rte_mempool *mp, struct mlx5_range **out,
1262                         unsigned int *out_n)
1263 {
1264         struct mlx5_range *chunks;
1265         unsigned int chunks_n = mp->nb_mem_chunks, contig_n, i;
1266
1267         /* Collect page-aligned memory ranges of the mempool. */
1268         chunks = calloc(sizeof(chunks[0]), chunks_n);
1269         if (chunks == NULL)
1270                 return -1;
1271         rte_mempool_mem_iter(mp, mlx5_range_from_mempool_chunk, chunks);
1272         /* Merge adjacent chunks and place them at the beginning. */
1273         qsort(chunks, chunks_n, sizeof(chunks[0]), mlx5_range_compare_start);
1274         contig_n = 1;
1275         for (i = 1; i < chunks_n; i++)
1276                 if (chunks[i - 1].end != chunks[i].start) {
1277                         chunks[contig_n - 1].end = chunks[i - 1].end;
1278                         chunks[contig_n] = chunks[i];
1279                         contig_n++;
1280                 }
1281         /* Extend the last contiguous chunk to the end of the mempool. */
1282         chunks[contig_n - 1].end = chunks[i - 1].end;
1283         *out = chunks;
1284         *out_n = contig_n;
1285         return 0;
1286 }
1287
1288 /**
1289  * Analyze mempool memory to select memory ranges to register.
1290  *
1291  * @param[in] mp
1292  *   Mempool to analyze.
1293  * @param[out] out
1294  *   Receives memory ranges to register, aligned to the system page size.
1295  *   The caller must release them with free().
1296  * @param[out] out_n
1297  *   Receives the number of @p out items.
1298  * @param[out] share_hugepage
1299  *   Receives True if the entire pool resides within a single hugepage.
1300  *
1301  * @return
1302  *   0 on success, (-1) on failure.
1303  */
1304 static int
1305 mlx5_mempool_reg_analyze(struct rte_mempool *mp, struct mlx5_range **out,
1306                          unsigned int *out_n, bool *share_hugepage)
1307 {
1308         struct mlx5_range *ranges = NULL;
1309         unsigned int i, ranges_n = 0;
1310         struct rte_memseg_list *msl;
1311
1312         if (mlx5_get_mempool_ranges(mp, &ranges, &ranges_n) < 0) {
1313                 DRV_LOG(ERR, "Cannot get address ranges for mempool %s",
1314                         mp->name);
1315                 return -1;
1316         }
1317         /* Check if the hugepage of the pool can be shared. */
1318         *share_hugepage = false;
1319         msl = rte_mem_virt2memseg_list((void *)ranges[0].start);
1320         if (msl != NULL) {
1321                 uint64_t hugepage_sz = 0;
1322
1323                 /* Check that all ranges are on pages of the same size. */
1324                 for (i = 0; i < ranges_n; i++) {
1325                         if (hugepage_sz != 0 && hugepage_sz != msl->page_sz)
1326                                 break;
1327                         hugepage_sz = msl->page_sz;
1328                 }
1329                 if (i == ranges_n) {
1330                         /*
1331                          * If the entire pool is within one hugepage,
1332                          * combine all ranges into one of the hugepage size.
1333                          */
1334                         uintptr_t reg_start = ranges[0].start;
1335                         uintptr_t reg_end = ranges[ranges_n - 1].end;
1336                         uintptr_t hugepage_start =
1337                                 RTE_ALIGN_FLOOR(reg_start, hugepage_sz);
1338                         uintptr_t hugepage_end = hugepage_start + hugepage_sz;
1339                         if (reg_end < hugepage_end) {
1340                                 ranges[0].start = hugepage_start;
1341                                 ranges[0].end = hugepage_end;
1342                                 ranges_n = 1;
1343                                 *share_hugepage = true;
1344                         }
1345                 }
1346         }
1347         *out = ranges;
1348         *out_n = ranges_n;
1349         return 0;
1350 }
1351
1352 /** Create a registration object for the mempool. */
1353 static struct mlx5_mempool_reg *
1354 mlx5_mempool_reg_create(struct rte_mempool *mp, unsigned int mrs_n)
1355 {
1356         struct mlx5_mempool_reg *mpr = NULL;
1357
1358         mpr = mlx5_malloc(MLX5_MEM_RTE | MLX5_MEM_ZERO,
1359                           sizeof(*mpr) + mrs_n * sizeof(mpr->mrs[0]),
1360                           RTE_CACHE_LINE_SIZE, SOCKET_ID_ANY);
1361         if (mpr == NULL) {
1362                 DRV_LOG(ERR, "Cannot allocate mempool %s registration object",
1363                         mp->name);
1364                 return NULL;
1365         }
1366         mpr->mp = mp;
1367         mpr->mrs = (struct mlx5_mempool_mr *)(mpr + 1);
1368         mpr->mrs_n = mrs_n;
1369         return mpr;
1370 }
1371
1372 /**
1373  * Destroy a mempool registration object.
1374  *
1375  * @param standalone
1376  *   Whether @p mpr owns its MRs excludively, i.e. they are not shared.
1377  */
1378 static void
1379 mlx5_mempool_reg_destroy(struct mlx5_mr_share_cache *share_cache,
1380                          struct mlx5_mempool_reg *mpr, bool standalone)
1381 {
1382         if (standalone) {
1383                 unsigned int i;
1384
1385                 for (i = 0; i < mpr->mrs_n; i++)
1386                         share_cache->dereg_mr_cb(&mpr->mrs[i].pmd_mr);
1387         }
1388         mlx5_free(mpr);
1389 }
1390
1391 /** Find registration object of a mempool. */
1392 static struct mlx5_mempool_reg *
1393 mlx5_mempool_reg_lookup(struct mlx5_mr_share_cache *share_cache,
1394                         struct rte_mempool *mp)
1395 {
1396         struct mlx5_mempool_reg *mpr;
1397
1398         LIST_FOREACH(mpr, &share_cache->mempool_reg_list, next)
1399                 if (mpr->mp == mp)
1400                         break;
1401         return mpr;
1402 }
1403
1404 /** Increment reference counters of MRs used in the registration. */
1405 static void
1406 mlx5_mempool_reg_attach(struct mlx5_mempool_reg *mpr)
1407 {
1408         unsigned int i;
1409
1410         for (i = 0; i < mpr->mrs_n; i++)
1411                 __atomic_add_fetch(&mpr->mrs[i].refcnt, 1, __ATOMIC_RELAXED);
1412 }
1413
1414 /**
1415  * Decrement reference counters of MRs used in the registration.
1416  *
1417  * @return True if no more references to @p mpr MRs exist, False otherwise.
1418  */
1419 static bool
1420 mlx5_mempool_reg_detach(struct mlx5_mempool_reg *mpr)
1421 {
1422         unsigned int i;
1423         bool ret = false;
1424
1425         for (i = 0; i < mpr->mrs_n; i++)
1426                 ret |= __atomic_sub_fetch(&mpr->mrs[i].refcnt, 1,
1427                                           __ATOMIC_RELAXED) == 0;
1428         return ret;
1429 }
1430
1431 static int
1432 mlx5_mr_mempool_register_primary(struct mlx5_mr_share_cache *share_cache,
1433                                  void *pd, struct rte_mempool *mp)
1434 {
1435         struct mlx5_range *ranges = NULL;
1436         struct mlx5_mempool_reg *mpr, *new_mpr;
1437         unsigned int i, ranges_n;
1438         bool share_hugepage;
1439         int ret = -1;
1440
1441         /* Early check to avoid unnecessary creation of MRs. */
1442         rte_rwlock_read_lock(&share_cache->rwlock);
1443         mpr = mlx5_mempool_reg_lookup(share_cache, mp);
1444         rte_rwlock_read_unlock(&share_cache->rwlock);
1445         if (mpr != NULL) {
1446                 DRV_LOG(DEBUG, "Mempool %s is already registered for PD %p",
1447                         mp->name, pd);
1448                 rte_errno = EEXIST;
1449                 goto exit;
1450         }
1451         if (mlx5_mempool_reg_analyze(mp, &ranges, &ranges_n,
1452                                      &share_hugepage) < 0) {
1453                 DRV_LOG(ERR, "Cannot get mempool %s memory ranges", mp->name);
1454                 rte_errno = ENOMEM;
1455                 goto exit;
1456         }
1457         new_mpr = mlx5_mempool_reg_create(mp, ranges_n);
1458         if (new_mpr == NULL) {
1459                 DRV_LOG(ERR,
1460                         "Cannot create a registration object for mempool %s in PD %p",
1461                         mp->name, pd);
1462                 rte_errno = ENOMEM;
1463                 goto exit;
1464         }
1465         /*
1466          * If the entire mempool fits in a single hugepage, the MR for this
1467          * hugepage can be shared across mempools that also fit in it.
1468          */
1469         if (share_hugepage) {
1470                 rte_rwlock_write_lock(&share_cache->rwlock);
1471                 LIST_FOREACH(mpr, &share_cache->mempool_reg_list, next) {
1472                         if (mpr->mrs[0].pmd_mr.addr == (void *)ranges[0].start)
1473                                 break;
1474                 }
1475                 if (mpr != NULL) {
1476                         new_mpr->mrs = mpr->mrs;
1477                         mlx5_mempool_reg_attach(new_mpr);
1478                         LIST_INSERT_HEAD(&share_cache->mempool_reg_list,
1479                                          new_mpr, next);
1480                 }
1481                 rte_rwlock_write_unlock(&share_cache->rwlock);
1482                 if (mpr != NULL) {
1483                         DRV_LOG(DEBUG, "Shared MR %#x in PD %p for mempool %s with mempool %s",
1484                                 mpr->mrs[0].pmd_mr.lkey, pd, mp->name,
1485                                 mpr->mp->name);
1486                         ret = 0;
1487                         goto exit;
1488                 }
1489         }
1490         for (i = 0; i < ranges_n; i++) {
1491                 struct mlx5_mempool_mr *mr = &new_mpr->mrs[i];
1492                 const struct mlx5_range *range = &ranges[i];
1493                 size_t len = range->end - range->start;
1494
1495                 if (share_cache->reg_mr_cb(pd, (void *)range->start, len,
1496                     &mr->pmd_mr) < 0) {
1497                         DRV_LOG(ERR,
1498                                 "Failed to create an MR in PD %p for address range "
1499                                 "[0x%" PRIxPTR ", 0x%" PRIxPTR "] (%zu bytes) for mempool %s",
1500                                 pd, range->start, range->end, len, mp->name);
1501                         break;
1502                 }
1503                 DRV_LOG(DEBUG,
1504                         "Created a new MR %#x in PD %p for address range "
1505                         "[0x%" PRIxPTR ", 0x%" PRIxPTR "] (%zu bytes) for mempool %s",
1506                         mr->pmd_mr.lkey, pd, range->start, range->end, len,
1507                         mp->name);
1508         }
1509         if (i != ranges_n) {
1510                 mlx5_mempool_reg_destroy(share_cache, new_mpr, true);
1511                 rte_errno = EINVAL;
1512                 goto exit;
1513         }
1514         /* Concurrent registration is not supposed to happen. */
1515         rte_rwlock_write_lock(&share_cache->rwlock);
1516         mpr = mlx5_mempool_reg_lookup(share_cache, mp);
1517         if (mpr == NULL) {
1518                 mlx5_mempool_reg_attach(new_mpr);
1519                 LIST_INSERT_HEAD(&share_cache->mempool_reg_list,
1520                                  new_mpr, next);
1521                 ret = 0;
1522         }
1523         rte_rwlock_write_unlock(&share_cache->rwlock);
1524         if (mpr != NULL) {
1525                 DRV_LOG(DEBUG, "Mempool %s is already registered for PD %p",
1526                         mp->name, pd);
1527                 mlx5_mempool_reg_destroy(share_cache, new_mpr, true);
1528                 rte_errno = EEXIST;
1529                 goto exit;
1530         }
1531 exit:
1532         free(ranges);
1533         return ret;
1534 }
1535
1536 static int
1537 mlx5_mr_mempool_register_secondary(struct mlx5_mr_share_cache *share_cache,
1538                                    void *pd, struct rte_mempool *mp,
1539                                    struct mlx5_mp_id *mp_id)
1540 {
1541         if (mp_id == NULL) {
1542                 rte_errno = EINVAL;
1543                 return -1;
1544         }
1545         return mlx5_mp_req_mempool_reg(mp_id, share_cache, pd, mp, true);
1546 }
1547
1548 /**
1549  * Register the memory of a mempool in the protection domain.
1550  *
1551  * @param share_cache
1552  *   Shared MR cache of the protection domain.
1553  * @param pd
1554  *   Protection domain object.
1555  * @param mp
1556  *   Mempool to register.
1557  * @param mp_id
1558  *   Multi-process identifier, may be NULL for the primary process.
1559  *
1560  * @return
1561  *   0 on success, (-1) on failure and rte_errno is set.
1562  */
1563 int
1564 mlx5_mr_mempool_register(struct mlx5_mr_share_cache *share_cache, void *pd,
1565                          struct rte_mempool *mp, struct mlx5_mp_id *mp_id)
1566 {
1567         if (mp->flags & MEMPOOL_F_NON_IO)
1568                 return 0;
1569         switch (rte_eal_process_type()) {
1570         case RTE_PROC_PRIMARY:
1571                 return mlx5_mr_mempool_register_primary(share_cache, pd, mp);
1572         case RTE_PROC_SECONDARY:
1573                 return mlx5_mr_mempool_register_secondary(share_cache, pd, mp,
1574                                                           mp_id);
1575         default:
1576                 return -1;
1577         }
1578 }
1579
1580 static int
1581 mlx5_mr_mempool_unregister_primary(struct mlx5_mr_share_cache *share_cache,
1582                                    struct rte_mempool *mp)
1583 {
1584         struct mlx5_mempool_reg *mpr;
1585         bool standalone = false;
1586
1587         rte_rwlock_write_lock(&share_cache->rwlock);
1588         LIST_FOREACH(mpr, &share_cache->mempool_reg_list, next)
1589                 if (mpr->mp == mp) {
1590                         LIST_REMOVE(mpr, next);
1591                         standalone = mlx5_mempool_reg_detach(mpr);
1592                         if (standalone)
1593                                 /*
1594                                  * The unlock operation below provides a memory
1595                                  * barrier due to its store-release semantics.
1596                                  */
1597                                 ++share_cache->dev_gen;
1598                         break;
1599                 }
1600         rte_rwlock_write_unlock(&share_cache->rwlock);
1601         if (mpr == NULL) {
1602                 rte_errno = ENOENT;
1603                 return -1;
1604         }
1605         mlx5_mempool_reg_destroy(share_cache, mpr, standalone);
1606         return 0;
1607 }
1608
1609 static int
1610 mlx5_mr_mempool_unregister_secondary(struct mlx5_mr_share_cache *share_cache,
1611                                      struct rte_mempool *mp,
1612                                      struct mlx5_mp_id *mp_id)
1613 {
1614         if (mp_id == NULL) {
1615                 rte_errno = EINVAL;
1616                 return -1;
1617         }
1618         return mlx5_mp_req_mempool_reg(mp_id, share_cache, NULL, mp, false);
1619 }
1620
1621 /**
1622  * Unregister the memory of a mempool from the protection domain.
1623  *
1624  * @param share_cache
1625  *   Shared MR cache of the protection domain.
1626  * @param mp
1627  *   Mempool to unregister.
1628  * @param mp_id
1629  *   Multi-process identifier, may be NULL for the primary process.
1630  *
1631  * @return
1632  *   0 on success, (-1) on failure and rte_errno is set.
1633  */
1634 int
1635 mlx5_mr_mempool_unregister(struct mlx5_mr_share_cache *share_cache,
1636                            struct rte_mempool *mp, struct mlx5_mp_id *mp_id)
1637 {
1638         if (mp->flags & MEMPOOL_F_NON_IO)
1639                 return 0;
1640         switch (rte_eal_process_type()) {
1641         case RTE_PROC_PRIMARY:
1642                 return mlx5_mr_mempool_unregister_primary(share_cache, mp);
1643         case RTE_PROC_SECONDARY:
1644                 return mlx5_mr_mempool_unregister_secondary(share_cache, mp,
1645                                                             mp_id);
1646         default:
1647                 return -1;
1648         }
1649 }
1650
1651 /**
1652  * Lookup a MR key by and address in a registered mempool.
1653  *
1654  * @param mpr
1655  *   Mempool registration object.
1656  * @param addr
1657  *   Address within the mempool.
1658  * @param entry
1659  *   Bottom-half cache entry to fill.
1660  *
1661  * @return
1662  *   MR key or UINT32_MAX on failure, which can only happen
1663  *   if the address is not from within the mempool.
1664  */
1665 static uint32_t
1666 mlx5_mempool_reg_addr2mr(struct mlx5_mempool_reg *mpr, uintptr_t addr,
1667                          struct mr_cache_entry *entry)
1668 {
1669         uint32_t lkey = UINT32_MAX;
1670         unsigned int i;
1671
1672         for (i = 0; i < mpr->mrs_n; i++) {
1673                 const struct mlx5_pmd_mr *mr = &mpr->mrs[i].pmd_mr;
1674                 uintptr_t mr_addr = (uintptr_t)mr->addr;
1675
1676                 if (mr_addr <= addr) {
1677                         lkey = rte_cpu_to_be_32(mr->lkey);
1678                         entry->start = mr_addr;
1679                         entry->end = mr_addr + mr->len;
1680                         entry->lkey = lkey;
1681                         break;
1682                 }
1683         }
1684         return lkey;
1685 }
1686
1687 /**
1688  * Update bottom-half cache from the list of mempool registrations.
1689  *
1690  * @param share_cache
1691  *   Pointer to a global shared MR cache.
1692  * @param mr_ctrl
1693  *   Per-queue MR control handle.
1694  * @param entry
1695  *   Pointer to an entry in the bottom-half cache to update
1696  *   with the MR lkey looked up.
1697  * @param mp
1698  *   Mempool containing the address.
1699  * @param addr
1700  *   Address to lookup.
1701  * @return
1702  *   MR lkey on success, UINT32_MAX on failure.
1703  */
1704 static uint32_t
1705 mlx5_lookup_mempool_regs(struct mlx5_mr_share_cache *share_cache,
1706                          struct mlx5_mr_ctrl *mr_ctrl,
1707                          struct mr_cache_entry *entry,
1708                          struct rte_mempool *mp, uintptr_t addr)
1709 {
1710         struct mlx5_mr_btree *bt = &mr_ctrl->cache_bh;
1711         struct mlx5_mempool_reg *mpr;
1712         uint32_t lkey = UINT32_MAX;
1713
1714         /* If local cache table is full, try to double it. */
1715         if (unlikely(bt->len == bt->size))
1716                 mr_btree_expand(bt, bt->size << 1);
1717         /* Look up in mempool registrations. */
1718         rte_rwlock_read_lock(&share_cache->rwlock);
1719         mpr = mlx5_mempool_reg_lookup(share_cache, mp);
1720         if (mpr != NULL)
1721                 lkey = mlx5_mempool_reg_addr2mr(mpr, addr, entry);
1722         rte_rwlock_read_unlock(&share_cache->rwlock);
1723         /*
1724          * Update local cache. Even if it fails, return the found entry
1725          * to update top-half cache. Next time, this entry will be found
1726          * in the global cache.
1727          */
1728         if (lkey != UINT32_MAX)
1729                 mr_btree_insert(bt, entry);
1730         return lkey;
1731 }
1732
1733 /**
1734  * Bottom-half lookup for the address from the mempool.
1735  *
1736  * @param share_cache
1737  *   Pointer to a global shared MR cache.
1738  * @param mr_ctrl
1739  *   Per-queue MR control handle.
1740  * @param mp
1741  *   Mempool containing the address.
1742  * @param addr
1743  *   Address to lookup.
1744  * @return
1745  *   MR lkey on success, UINT32_MAX on failure.
1746  */
1747 uint32_t
1748 mlx5_mr_mempool2mr_bh(struct mlx5_mr_share_cache *share_cache,
1749                       struct mlx5_mr_ctrl *mr_ctrl,
1750                       struct rte_mempool *mp, uintptr_t addr)
1751 {
1752         struct mr_cache_entry *repl = &mr_ctrl->cache[mr_ctrl->head];
1753         uint32_t lkey;
1754         uint16_t bh_idx = 0;
1755
1756         /* Binary-search MR translation table. */
1757         lkey = mr_btree_lookup(&mr_ctrl->cache_bh, &bh_idx, addr);
1758         /* Update top-half cache. */
1759         if (likely(lkey != UINT32_MAX)) {
1760                 *repl = (*mr_ctrl->cache_bh.table)[bh_idx];
1761         } else {
1762                 lkey = mlx5_lookup_mempool_regs(share_cache, mr_ctrl, repl,
1763                                                 mp, addr);
1764                 /* Can only fail if the address is not from the mempool. */
1765                 if (unlikely(lkey == UINT32_MAX))
1766                         return UINT32_MAX;
1767         }
1768         /* Update the most recently used entry. */
1769         mr_ctrl->mru = mr_ctrl->head;
1770         /* Point to the next victim, the oldest. */
1771         mr_ctrl->head = (mr_ctrl->head + 1) % MLX5_MR_CACHE_N;
1772         return lkey;
1773 }