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         DRV_LOG(DEBUG,
1035                 "Rx queue %u: miss on top-half, mru=%u, head=%u, addr=%p",
1036                 rxq_ctrl->idx, mr_ctrl->mru, mr_ctrl->head, (void *)addr);
1037         return mlx5_mr_addr2mr_bh(ETH_DEV(priv), mr_ctrl, addr);
1038 }
1039
1040 /**
1041  * Bottom-half of LKey search on Tx.
1042  *
1043  * @param txq
1044  *   Pointer to Tx queue structure.
1045  * @param addr
1046  *   Search key.
1047  *
1048  * @return
1049  *   Searched LKey on success, UINT32_MAX on no match.
1050  */
1051 static uint32_t
1052 mlx5_tx_addr2mr_bh(struct mlx5_txq_data *txq, uintptr_t addr)
1053 {
1054         struct mlx5_txq_ctrl *txq_ctrl =
1055                 container_of(txq, struct mlx5_txq_ctrl, txq);
1056         struct mlx5_mr_ctrl *mr_ctrl = &txq->mr_ctrl;
1057         struct mlx5_priv *priv = txq_ctrl->priv;
1058
1059         DRV_LOG(DEBUG,
1060                 "Tx queue %u: miss on top-half, mru=%u, head=%u, addr=%p",
1061                 txq_ctrl->idx, mr_ctrl->mru, mr_ctrl->head, (void *)addr);
1062         return mlx5_mr_addr2mr_bh(ETH_DEV(priv), mr_ctrl, addr);
1063 }
1064
1065 /**
1066  * Bottom-half of LKey search on Tx. If it can't be searched in the memseg
1067  * list, register the mempool of the mbuf as externally allocated memory.
1068  *
1069  * @param txq
1070  *   Pointer to Tx queue structure.
1071  * @param mb
1072  *   Pointer to mbuf.
1073  *
1074  * @return
1075  *   Searched LKey on success, UINT32_MAX on no match.
1076  */
1077 uint32_t
1078 mlx5_tx_mb2mr_bh(struct mlx5_txq_data *txq, struct rte_mbuf *mb)
1079 {
1080         uintptr_t addr = (uintptr_t)mb->buf_addr;
1081         uint32_t lkey;
1082
1083         lkey = mlx5_tx_addr2mr_bh(txq, addr);
1084         if (lkey == UINT32_MAX && rte_errno == ENXIO) {
1085                 /* Mempool may have externally allocated memory. */
1086                 return mlx5_tx_update_ext_mp(txq, addr, mlx5_mb2mp(mb));
1087         }
1088         return lkey;
1089 }
1090
1091 /**
1092  * Flush all of the local cache entries.
1093  *
1094  * @param mr_ctrl
1095  *   Pointer to per-queue MR control structure.
1096  */
1097 void
1098 mlx5_mr_flush_local_cache(struct mlx5_mr_ctrl *mr_ctrl)
1099 {
1100         /* Reset the most-recently-used index. */
1101         mr_ctrl->mru = 0;
1102         /* Reset the linear search array. */
1103         mr_ctrl->head = 0;
1104         memset(mr_ctrl->cache, 0, sizeof(mr_ctrl->cache));
1105         /* Reset the B-tree table. */
1106         mr_ctrl->cache_bh.len = 1;
1107         mr_ctrl->cache_bh.overflow = 0;
1108         /* Update the generation number. */
1109         mr_ctrl->cur_gen = *mr_ctrl->dev_gen_ptr;
1110         DRV_LOG(DEBUG, "mr_ctrl(%p): flushed, cur_gen=%d",
1111                 (void *)mr_ctrl, mr_ctrl->cur_gen);
1112 }
1113
1114 /**
1115  * Creates a memory region for external memory, that is memory which is not
1116  * part of the DPDK memory segments.
1117  *
1118  * @param dev
1119  *   Pointer to the ethernet device.
1120  * @param addr
1121  *   Starting virtual address of memory.
1122  * @param len
1123  *   Length of memory segment being mapped.
1124  * @param socked_id
1125  *   Socket to allocate heap memory for the control structures.
1126  *
1127  * @return
1128  *   Pointer to MR structure on success, NULL otherwise.
1129  */
1130 static struct mlx5_mr *
1131 mlx5_create_mr_ext(struct rte_eth_dev *dev, uintptr_t addr, size_t len,
1132                    int socket_id)
1133 {
1134         struct mlx5_priv *priv = dev->data->dev_private;
1135         struct mlx5_mr *mr = NULL;
1136
1137         mr = rte_zmalloc_socket(NULL,
1138                                 RTE_ALIGN_CEIL(sizeof(*mr),
1139                                                RTE_CACHE_LINE_SIZE),
1140                                 RTE_CACHE_LINE_SIZE, socket_id);
1141         if (mr == NULL)
1142                 return NULL;
1143         mr->ibv_mr = mlx5_glue->reg_mr(priv->sh->pd, (void *)addr, len,
1144                                        IBV_ACCESS_LOCAL_WRITE);
1145         if (mr->ibv_mr == NULL) {
1146                 DRV_LOG(WARNING,
1147                         "port %u fail to create a verbs MR for address (%p)",
1148                         dev->data->port_id, (void *)addr);
1149                 rte_free(mr);
1150                 return NULL;
1151         }
1152         mr->msl = NULL; /* Mark it is external memory. */
1153         mr->ms_bmp = NULL;
1154         mr->ms_n = 1;
1155         mr->ms_bmp_n = 1;
1156         DRV_LOG(DEBUG,
1157                 "port %u MR CREATED (%p) for external memory %p:\n"
1158                 "  [0x%" PRIxPTR ", 0x%" PRIxPTR "),"
1159                 " lkey=0x%x base_idx=%u ms_n=%u, ms_bmp_n=%u",
1160                 dev->data->port_id, (void *)mr, (void *)addr,
1161                 addr, addr + len, rte_cpu_to_be_32(mr->ibv_mr->lkey),
1162                 mr->ms_base_idx, mr->ms_n, mr->ms_bmp_n);
1163         return mr;
1164 }
1165
1166 /**
1167  * Called during rte_mempool_mem_iter() by mlx5_mr_update_ext_mp().
1168  *
1169  * Externally allocated chunk is registered and a MR is created for the chunk.
1170  * The MR object is added to the global list. If memseg list of a MR object
1171  * (mr->msl) is null, the MR object can be regarded as externally allocated
1172  * memory.
1173  *
1174  * Once external memory is registered, it should be static. If the memory is
1175  * freed and the virtual address range has different physical memory mapped
1176  * again, it may cause crash on device due to the wrong translation entry. PMD
1177  * can't track the free event of the external memory for now.
1178  */
1179 static void
1180 mlx5_mr_update_ext_mp_cb(struct rte_mempool *mp, void *opaque,
1181                          struct rte_mempool_memhdr *memhdr,
1182                          unsigned mem_idx __rte_unused)
1183 {
1184         struct mr_update_mp_data *data = opaque;
1185         struct rte_eth_dev *dev = data->dev;
1186         struct mlx5_priv *priv = dev->data->dev_private;
1187         struct mlx5_mr_ctrl *mr_ctrl = data->mr_ctrl;
1188         struct mlx5_mr *mr = NULL;
1189         uintptr_t addr = (uintptr_t)memhdr->addr;
1190         size_t len = memhdr->len;
1191         struct mlx5_mr_cache entry;
1192         uint32_t lkey;
1193
1194         /* If already registered, it should return. */
1195         rte_rwlock_read_lock(&priv->mr.rwlock);
1196         lkey = mr_lookup_dev(dev, &entry, addr);
1197         rte_rwlock_read_unlock(&priv->mr.rwlock);
1198         if (lkey != UINT32_MAX)
1199                 return;
1200         DRV_LOG(DEBUG, "port %u register MR for chunk #%d of mempool (%s)",
1201                 dev->data->port_id, mem_idx, mp->name);
1202         mr = mlx5_create_mr_ext(dev, addr, len, mp->socket_id);
1203         if (!mr) {
1204                 DRV_LOG(WARNING,
1205                         "port %u unable to allocate a new MR of"
1206                         " mempool (%s).",
1207                         dev->data->port_id, mp->name);
1208                 data->ret = -1;
1209                 return;
1210         }
1211         rte_rwlock_write_lock(&priv->mr.rwlock);
1212         LIST_INSERT_HEAD(&priv->mr.mr_list, mr, mr);
1213         /* Insert to the global cache table. */
1214         mr_insert_dev_cache(dev, mr);
1215         rte_rwlock_write_unlock(&priv->mr.rwlock);
1216         /* Insert to the local cache table */
1217         mlx5_mr_addr2mr_bh(dev, mr_ctrl, addr);
1218 }
1219
1220 /**
1221  * Finds the first ethdev that match the pci device.
1222  * The existence of multiple ethdev per pci device is only with representors.
1223  * On such case, it is enough to get only one of the ports as they all share
1224  * the same ibv context.
1225  *
1226  * @param pdev
1227  *   Pointer to the PCI device.
1228  *
1229  * @return
1230  *   Pointer to the ethdev if found, NULL otherwise.
1231  */
1232 static struct rte_eth_dev *
1233 pci_dev_to_eth_dev(struct rte_pci_device *pdev)
1234 {
1235         struct rte_dev_iterator it;
1236         struct rte_device *dev;
1237
1238         /**
1239          *  We really need to iterate all devices regardless of
1240          *  their owner.
1241          */
1242         RTE_DEV_FOREACH(dev, "class=eth", &it)
1243                 if (dev == &pdev->device)
1244                         return it.class_device;
1245         return NULL;
1246 }
1247
1248 /**
1249  * DPDK callback to DMA map external memory to a PCI device.
1250  *
1251  * @param pdev
1252  *   Pointer to the PCI device.
1253  * @param addr
1254  *   Starting virtual address of memory to be mapped.
1255  * @param iova
1256  *   Starting IOVA address of memory to be mapped.
1257  * @param len
1258  *   Length of memory segment being mapped.
1259  *
1260  * @return
1261  *   0 on success, negative value on error.
1262  */
1263 int
1264 mlx5_dma_map(struct rte_pci_device *pdev, void *addr,
1265              uint64_t iova __rte_unused, size_t len)
1266 {
1267         struct rte_eth_dev *dev;
1268         struct mlx5_mr *mr;
1269         struct mlx5_priv *priv;
1270
1271         dev = pci_dev_to_eth_dev(pdev);
1272         if (!dev) {
1273                 DRV_LOG(WARNING, "unable to find matching ethdev "
1274                                  "to PCI device %p", (void *)pdev);
1275                 rte_errno = ENODEV;
1276                 return -1;
1277         }
1278         priv = dev->data->dev_private;
1279         mr = mlx5_create_mr_ext(dev, (uintptr_t)addr, len, SOCKET_ID_ANY);
1280         if (!mr) {
1281                 DRV_LOG(WARNING,
1282                         "port %u unable to dma map", dev->data->port_id);
1283                 rte_errno = EINVAL;
1284                 return -1;
1285         }
1286         rte_rwlock_write_lock(&priv->mr.rwlock);
1287         LIST_INSERT_HEAD(&priv->mr.mr_list, mr, mr);
1288         /* Insert to the global cache table. */
1289         mr_insert_dev_cache(dev, mr);
1290         rte_rwlock_write_unlock(&priv->mr.rwlock);
1291         return 0;
1292 }
1293
1294 /**
1295  * DPDK callback to DMA unmap external memory to a PCI device.
1296  *
1297  * @param pdev
1298  *   Pointer to the PCI device.
1299  * @param addr
1300  *   Starting virtual address of memory to be unmapped.
1301  * @param iova
1302  *   Starting IOVA address of memory to be unmapped.
1303  * @param len
1304  *   Length of memory segment being unmapped.
1305  *
1306  * @return
1307  *   0 on success, negative value on error.
1308  */
1309 int
1310 mlx5_dma_unmap(struct rte_pci_device *pdev, void *addr,
1311                uint64_t iova __rte_unused, size_t len __rte_unused)
1312 {
1313         struct rte_eth_dev *dev;
1314         struct mlx5_priv *priv;
1315         struct mlx5_mr *mr;
1316         struct mlx5_mr_cache entry;
1317
1318         dev = pci_dev_to_eth_dev(pdev);
1319         if (!dev) {
1320                 DRV_LOG(WARNING, "unable to find matching ethdev "
1321                                  "to PCI device %p", (void *)pdev);
1322                 rte_errno = ENODEV;
1323                 return -1;
1324         }
1325         priv = dev->data->dev_private;
1326         rte_rwlock_read_lock(&priv->mr.rwlock);
1327         mr = mr_lookup_dev_list(dev, &entry, (uintptr_t)addr);
1328         if (!mr) {
1329                 rte_rwlock_read_unlock(&priv->mr.rwlock);
1330                 DRV_LOG(WARNING, "address 0x%" PRIxPTR " wasn't registered "
1331                                  "to PCI device %p", (uintptr_t)addr,
1332                                  (void *)pdev);
1333                 rte_errno = EINVAL;
1334                 return -1;
1335         }
1336         LIST_REMOVE(mr, mr);
1337         LIST_INSERT_HEAD(&priv->mr.mr_free_list, mr, mr);
1338         DEBUG("port %u remove MR(%p) from list", dev->data->port_id,
1339               (void *)mr);
1340         mr_rebuild_dev_cache(dev);
1341         /*
1342          * Flush local caches by propagating invalidation across cores.
1343          * rte_smp_wmb() is enough to synchronize this event. If one of
1344          * freed memsegs is seen by other core, that means the memseg
1345          * has been allocated by allocator, which will come after this
1346          * free call. Therefore, this store instruction (incrementing
1347          * generation below) will be guaranteed to be seen by other core
1348          * before the core sees the newly allocated memory.
1349          */
1350         ++priv->mr.dev_gen;
1351         DEBUG("broadcasting local cache flush, gen=%d",
1352                         priv->mr.dev_gen);
1353         rte_smp_wmb();
1354         rte_rwlock_read_unlock(&priv->mr.rwlock);
1355         return 0;
1356 }
1357
1358 /**
1359  * Register MR for entire memory chunks in a Mempool having externally allocated
1360  * memory and fill in local cache.
1361  *
1362  * @param dev
1363  *   Pointer to Ethernet device.
1364  * @param mr_ctrl
1365  *   Pointer to per-queue MR control structure.
1366  * @param mp
1367  *   Pointer to registering Mempool.
1368  *
1369  * @return
1370  *   0 on success, -1 on failure.
1371  */
1372 static uint32_t
1373 mlx5_mr_update_ext_mp(struct rte_eth_dev *dev, struct mlx5_mr_ctrl *mr_ctrl,
1374                       struct rte_mempool *mp)
1375 {
1376         struct mr_update_mp_data data = {
1377                 .dev = dev,
1378                 .mr_ctrl = mr_ctrl,
1379                 .ret = 0,
1380         };
1381
1382         rte_mempool_mem_iter(mp, mlx5_mr_update_ext_mp_cb, &data);
1383         return data.ret;
1384 }
1385
1386 /**
1387  * Register MR entire memory chunks in a Mempool having externally allocated
1388  * memory and search LKey of the address to return.
1389  *
1390  * @param dev
1391  *   Pointer to Ethernet device.
1392  * @param addr
1393  *   Search key.
1394  * @param mp
1395  *   Pointer to registering Mempool where addr belongs.
1396  *
1397  * @return
1398  *   LKey for address on success, UINT32_MAX on failure.
1399  */
1400 uint32_t
1401 mlx5_tx_update_ext_mp(struct mlx5_txq_data *txq, uintptr_t addr,
1402                       struct rte_mempool *mp)
1403 {
1404         struct mlx5_txq_ctrl *txq_ctrl =
1405                 container_of(txq, struct mlx5_txq_ctrl, txq);
1406         struct mlx5_mr_ctrl *mr_ctrl = &txq->mr_ctrl;
1407         struct mlx5_priv *priv = txq_ctrl->priv;
1408
1409         mlx5_mr_update_ext_mp(ETH_DEV(priv), mr_ctrl, mp);
1410         return mlx5_tx_addr2mr_bh(txq, addr);
1411 }
1412
1413 /* Called during rte_mempool_mem_iter() by mlx5_mr_update_mp(). */
1414 static void
1415 mlx5_mr_update_mp_cb(struct rte_mempool *mp __rte_unused, void *opaque,
1416                      struct rte_mempool_memhdr *memhdr,
1417                      unsigned mem_idx __rte_unused)
1418 {
1419         struct mr_update_mp_data *data = opaque;
1420         uint32_t lkey;
1421
1422         /* Stop iteration if failed in the previous walk. */
1423         if (data->ret < 0)
1424                 return;
1425         /* Register address of the chunk and update local caches. */
1426         lkey = mlx5_mr_addr2mr_bh(data->dev, data->mr_ctrl,
1427                                   (uintptr_t)memhdr->addr);
1428         if (lkey == UINT32_MAX)
1429                 data->ret = -1;
1430 }
1431
1432 /**
1433  * Register entire memory chunks in a Mempool.
1434  *
1435  * @param dev
1436  *   Pointer to Ethernet device.
1437  * @param mr_ctrl
1438  *   Pointer to per-queue MR control structure.
1439  * @param mp
1440  *   Pointer to registering Mempool.
1441  *
1442  * @return
1443  *   0 on success, -1 on failure.
1444  */
1445 int
1446 mlx5_mr_update_mp(struct rte_eth_dev *dev, struct mlx5_mr_ctrl *mr_ctrl,
1447                   struct rte_mempool *mp)
1448 {
1449         struct mr_update_mp_data data = {
1450                 .dev = dev,
1451                 .mr_ctrl = mr_ctrl,
1452                 .ret = 0,
1453         };
1454
1455         rte_mempool_mem_iter(mp, mlx5_mr_update_mp_cb, &data);
1456         if (data.ret < 0 && rte_errno == ENXIO) {
1457                 /* Mempool may have externally allocated memory. */
1458                 return mlx5_mr_update_ext_mp(dev, mr_ctrl, mp);
1459         }
1460         return data.ret;
1461 }
1462
1463 /**
1464  * Dump all the created MRs and the global cache entries.
1465  *
1466  * @param dev
1467  *   Pointer to Ethernet device.
1468  */
1469 void
1470 mlx5_mr_dump_dev(struct rte_eth_dev *dev __rte_unused)
1471 {
1472 #ifndef NDEBUG
1473         struct mlx5_priv *priv = dev->data->dev_private;
1474         struct mlx5_mr *mr;
1475         int mr_n = 0;
1476         int chunk_n = 0;
1477
1478         rte_rwlock_read_lock(&priv->mr.rwlock);
1479         /* Iterate all the existing MRs. */
1480         LIST_FOREACH(mr, &priv->mr.mr_list, mr) {
1481                 unsigned int n;
1482
1483                 DEBUG("port %u MR[%u], LKey = 0x%x, ms_n = %u, ms_bmp_n = %u",
1484                       dev->data->port_id, mr_n++,
1485                       rte_cpu_to_be_32(mr->ibv_mr->lkey),
1486                       mr->ms_n, mr->ms_bmp_n);
1487                 if (mr->ms_n == 0)
1488                         continue;
1489                 for (n = 0; n < mr->ms_bmp_n; ) {
1490                         struct mlx5_mr_cache ret = { 0, };
1491
1492                         n = mr_find_next_chunk(mr, &ret, n);
1493                         if (!ret.end)
1494                                 break;
1495                         DEBUG("  chunk[%u], [0x%" PRIxPTR ", 0x%" PRIxPTR ")",
1496                               chunk_n++, ret.start, ret.end);
1497                 }
1498         }
1499         DEBUG("port %u dumping global cache", dev->data->port_id);
1500         mlx5_mr_btree_dump(&priv->mr.cache);
1501         rte_rwlock_read_unlock(&priv->mr.rwlock);
1502 #endif
1503 }
1504
1505 /**
1506  * Release all the created MRs and resources. Remove device from memory callback
1507  * list.
1508  *
1509  * @param dev
1510  *   Pointer to Ethernet device.
1511  */
1512 void
1513 mlx5_mr_release(struct rte_eth_dev *dev)
1514 {
1515         struct mlx5_priv *priv = dev->data->dev_private;
1516         struct mlx5_mr *mr_next = LIST_FIRST(&priv->mr.mr_list);
1517
1518         /* Remove from memory callback device list. */
1519         rte_rwlock_write_lock(&mlx5_shared_data->mem_event_rwlock);
1520         LIST_REMOVE(priv, mem_event_cb);
1521         rte_rwlock_write_unlock(&mlx5_shared_data->mem_event_rwlock);
1522         if (rte_log_get_level(mlx5_logtype) == RTE_LOG_DEBUG)
1523                 mlx5_mr_dump_dev(dev);
1524         rte_rwlock_write_lock(&priv->mr.rwlock);
1525         /* Detach from MR list and move to free list. */
1526         while (mr_next != NULL) {
1527                 struct mlx5_mr *mr = mr_next;
1528
1529                 mr_next = LIST_NEXT(mr, mr);
1530                 LIST_REMOVE(mr, mr);
1531                 LIST_INSERT_HEAD(&priv->mr.mr_free_list, mr, mr);
1532         }
1533         LIST_INIT(&priv->mr.mr_list);
1534         /* Free global cache. */
1535         mlx5_mr_btree_free(&priv->mr.cache);
1536         rte_rwlock_write_unlock(&priv->mr.rwlock);
1537         /* Free all remaining MRs. */
1538         mlx5_mr_garbage_collect(dev);
1539 }