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_eal_memconfig.h>
  15 #include <rte_mempool.h>
  16 #include <rte_malloc.h>
  17 #include <rte_rwlock.h>
  18 #include <rte_bus_pci.h>
  19
  20 #include <mlx5_glue.h>
  21 #include <mlx5_common_mp.h>
  22 #include <mlx5_common_mr.h>
  23
  24 #include "mlx5.h"
  25 #include "mlx5_mr.h"
  26 #include "mlx5_rxtx.h"
  27
  28 struct mr_find_contig_memsegs_data {
  29         uintptr_t addr;
  30         uintptr_t start;
  31         uintptr_t end;
  32         const struct rte_memseg_list *msl;
  33 };
  34
  35 struct mr_update_mp_data {
  36         struct rte_eth_dev *dev;
  37         struct mlx5_mr_ctrl *mr_ctrl;
  38         int ret;
  39 };
  40
  41 /**
  42  * Callback for memory free event. Iterate freed memsegs and check whether it
  43  * belongs to an existing MR. If found, clear the bit from bitmap of MR. As a
  44  * result, the MR would be fragmented. If it becomes empty, the MR will be freed
  45  * later by mlx5_mr_garbage_collect(). Even if this callback is called from a
  46  * secondary process, the garbage collector will be called in primary process
  47  * as the secondary process can't call mlx5_mr_create().
  48  *
  49  * The global cache must be rebuilt if there's any change and this event has to
  50  * be propagated to dataplane threads to flush the local caches.
  51  *
  52  * @param sh
  53  *   Pointer to the Ethernet device shared context.
  54  * @param addr
  55  *   Address of freed memory.
  56  * @param len
  57  *   Size of freed memory.
  58  */
  59 static void
  60 mlx5_mr_mem_event_free_cb(struct mlx5_dev_ctx_shared *sh,
  61                           const void *addr, size_t len)
  62 {
  63         const struct rte_memseg_list *msl;
  64         struct mlx5_mr *mr;
  65         int ms_n;
  66         int i;
  67         int rebuild = 0;
  68
  69         DEBUG("device %s free callback: addr=%p, len=%zu",
  70               sh->ibdev_name, addr, len);
  71         msl = rte_mem_virt2memseg_list(addr);
  72         /* addr and len must be page-aligned. */
  73         MLX5_ASSERT((uintptr_t)addr ==
  74                     RTE_ALIGN((uintptr_t)addr, msl->page_sz));
  75         MLX5_ASSERT(len == RTE_ALIGN(len, msl->page_sz));
  76         ms_n = len / msl->page_sz;
  77         rte_rwlock_write_lock(&sh->share_cache.rwlock);
  78         /* Clear bits of freed memsegs from MR. */
  79         for (i = 0; i < ms_n; ++i) {
  80                 const struct rte_memseg *ms;
  81                 struct mr_cache_entry entry;
  82                 uintptr_t start;
  83                 int ms_idx;
  84                 uint32_t pos;
  85
  86                 /* Find MR having this memseg. */
  87                 start = (uintptr_t)addr + i * msl->page_sz;
  88                 mr = mlx5_mr_lookup_list(&sh->share_cache, &entry, start);
  89                 if (mr == NULL)
  90                         continue;
  91                 MLX5_ASSERT(mr->msl); /* Can't be external memory. */
  92                 ms = rte_mem_virt2memseg((void *)start, msl);
  93                 MLX5_ASSERT(ms != NULL);
  94                 MLX5_ASSERT(msl->page_sz == ms->hugepage_sz);
  95                 ms_idx = rte_fbarray_find_idx(&msl->memseg_arr, ms);
  96                 pos = ms_idx - mr->ms_base_idx;
  97                 MLX5_ASSERT(rte_bitmap_get(mr->ms_bmp, pos));
  98                 MLX5_ASSERT(pos < mr->ms_bmp_n);
  99                 DEBUG("device %s MR(%p): clear bitmap[%u] for addr %p",
 100                       sh->ibdev_name, (void *)mr, pos, (void *)start);
 101                 rte_bitmap_clear(mr->ms_bmp, pos);
 102                 if (--mr->ms_n == 0) {
 103                         LIST_REMOVE(mr, mr);
 104                         LIST_INSERT_HEAD(&sh->share_cache.mr_free_list, mr, mr);
 105                         DEBUG("device %s remove MR(%p) from list",
 106                               sh->ibdev_name, (void *)mr);
 107                 }
 108                 /*
 109                  * MR is fragmented or will be freed. the global cache must be
 110                  * rebuilt.
 111                  */
 112                 rebuild = 1;
 113         }
 114         if (rebuild) {
 115                 mlx5_mr_rebuild_cache(&sh->share_cache);
 116                 /*
 117                  * Flush local caches by propagating invalidation across cores.
 118                  * rte_smp_wmb() is enough to synchronize this event. If one of
 119                  * freed memsegs is seen by other core, that means the memseg
 120                  * has been allocated by allocator, which will come after this
 121                  * free call. Therefore, this store instruction (incrementing
 122                  * generation below) will be guaranteed to be seen by other core
 123                  * before the core sees the newly allocated memory.
 124                  */
 125                 ++sh->share_cache.dev_gen;
 126                 DEBUG("broadcasting local cache flush, gen=%d",
 127                       sh->share_cache.dev_gen);
 128                 rte_smp_wmb();
 129         }
 130         rte_rwlock_write_unlock(&sh->share_cache.rwlock);
 131 }
 132
 133 /**
 134  * Callback for memory event. This can be called from both primary and secondary
 135  * process.
 136  *
 137  * @param event_type
 138  *   Memory event type.
 139  * @param addr
 140  *   Address of memory.
 141  * @param len
 142  *   Size of memory.
 143  */
 144 void
 145 mlx5_mr_mem_event_cb(enum rte_mem_event event_type, const void *addr,
 146                      size_t len, void *arg __rte_unused)
 147 {
 148         struct mlx5_dev_ctx_shared *sh;
 149         struct mlx5_dev_list *dev_list = &mlx5_shared_data->mem_event_cb_list;
 150
 151         /* Must be called from the primary process. */
 152         MLX5_ASSERT(rte_eal_process_type() == RTE_PROC_PRIMARY);
 153         switch (event_type) {
 154         case RTE_MEM_EVENT_FREE:
 155                 rte_rwlock_write_lock(&mlx5_shared_data->mem_event_rwlock);
 156                 /* Iterate all the existing mlx5 devices. */
 157                 LIST_FOREACH(sh, dev_list, mem_event_cb)
 158                         mlx5_mr_mem_event_free_cb(sh, addr, len);
 159                 rte_rwlock_write_unlock(&mlx5_shared_data->mem_event_rwlock);
 160                 break;
 161         case RTE_MEM_EVENT_ALLOC:
 162         default:
 163                 break;
 164         }
 165 }
 166
 167 /**
 168  * Bottom-half of LKey search on Rx.
 169  *
 170  * @param rxq
 171  *   Pointer to Rx queue structure.
 172  * @param addr
 173  *   Search key.
 174  *
 175  * @return
 176  *   Searched LKey on success, UINT32_MAX on no match.
 177  */
 178 uint32_t
 179 mlx5_rx_addr2mr_bh(struct mlx5_rxq_data *rxq, uintptr_t addr)
 180 {
 181         struct mlx5_rxq_ctrl *rxq_ctrl =
 182                 container_of(rxq, struct mlx5_rxq_ctrl, rxq);
 183         struct mlx5_mr_ctrl *mr_ctrl = &rxq->mr_ctrl;
 184         struct mlx5_priv *priv = rxq_ctrl->priv;
 185
 186         return mlx5_mr_addr2mr_bh(priv->sh->pd, &priv->mp_id,
 187                                   &priv->sh->share_cache, mr_ctrl, addr,
 188                                   priv->config.mr_ext_memseg_en);
 189 }
 190
 191 /**
 192  * Bottom-half of LKey search on Tx.
 193  *
 194  * @param txq
 195  *   Pointer to Tx queue structure.
 196  * @param addr
 197  *   Search key.
 198  *
 199  * @return
 200  *   Searched LKey on success, UINT32_MAX on no match.
 201  */
 202 static uint32_t
 203 mlx5_tx_addr2mr_bh(struct mlx5_txq_data *txq, uintptr_t addr)
 204 {
 205         struct mlx5_txq_ctrl *txq_ctrl =
 206                 container_of(txq, struct mlx5_txq_ctrl, txq);
 207         struct mlx5_mr_ctrl *mr_ctrl = &txq->mr_ctrl;
 208         struct mlx5_priv *priv = txq_ctrl->priv;
 209
 210         return mlx5_mr_addr2mr_bh(priv->sh->pd, &priv->mp_id,
 211                                   &priv->sh->share_cache, mr_ctrl, addr,
 212                                   priv->config.mr_ext_memseg_en);
 213 }
 214
 215 /**
 216  * Bottom-half of LKey search on Tx. If it can't be searched in the memseg
 217  * list, register the mempool of the mbuf as externally allocated memory.
 218  *
 219  * @param txq
 220  *   Pointer to Tx queue structure.
 221  * @param mb
 222  *   Pointer to mbuf.
 223  *
 224  * @return
 225  *   Searched LKey on success, UINT32_MAX on no match.
 226  */
 227 uint32_t
 228 mlx5_tx_mb2mr_bh(struct mlx5_txq_data *txq, struct rte_mbuf *mb)
 229 {
 230         uintptr_t addr = (uintptr_t)mb->buf_addr;
 231         uint32_t lkey;
 232
 233         lkey = mlx5_tx_addr2mr_bh(txq, addr);
 234         if (lkey == UINT32_MAX && rte_errno == ENXIO) {
 235                 /* Mempool may have externally allocated memory. */
 236                 return mlx5_tx_update_ext_mp(txq, addr, mlx5_mb2mp(mb));
 237         }
 238         return lkey;
 239 }
 240
 241 /**
 242  * Called during rte_mempool_mem_iter() by mlx5_mr_update_ext_mp().
 243  *
 244  * Externally allocated chunk is registered and a MR is created for the chunk.
 245  * The MR object is added to the global list. If memseg list of a MR object
 246  * (mr->msl) is null, the MR object can be regarded as externally allocated
 247  * memory.
 248  *
 249  * Once external memory is registered, it should be static. If the memory is
 250  * freed and the virtual address range has different physical memory mapped
 251  * again, it may cause crash on device due to the wrong translation entry. PMD
 252  * can't track the free event of the external memory for now.
 253  */
 254 static void
 255 mlx5_mr_update_ext_mp_cb(struct rte_mempool *mp, void *opaque,
 256                          struct rte_mempool_memhdr *memhdr,
 257                          unsigned mem_idx __rte_unused)
 258 {
 259         struct mr_update_mp_data *data = opaque;
 260         struct rte_eth_dev *dev = data->dev;
 261         struct mlx5_priv *priv = dev->data->dev_private;
 262         struct mlx5_dev_ctx_shared *sh = priv->sh;
 263         struct mlx5_mr_ctrl *mr_ctrl = data->mr_ctrl;
 264         struct mlx5_mr *mr = NULL;
 265         uintptr_t addr = (uintptr_t)memhdr->addr;
 266         size_t len = memhdr->len;
 267         struct mr_cache_entry entry;
 268         uint32_t lkey;
 269
 270         MLX5_ASSERT(rte_eal_process_type() == RTE_PROC_PRIMARY);
 271         /* If already registered, it should return. */
 272         rte_rwlock_read_lock(&sh->share_cache.rwlock);
 273         lkey = mlx5_mr_lookup_cache(&sh->share_cache, &entry, addr);
 274         rte_rwlock_read_unlock(&sh->share_cache.rwlock);
 275         if (lkey != UINT32_MAX)
 276                 return;
 277         DRV_LOG(DEBUG, "port %u register MR for chunk #%d of mempool (%s)",
 278                 dev->data->port_id, mem_idx, mp->name);
 279         mr = mlx5_create_mr_ext(sh->pd, addr, len, mp->socket_id,
 280                                 sh->share_cache.reg_mr_cb);
 281         if (!mr) {
 282                 DRV_LOG(WARNING,
 283                         "port %u unable to allocate a new MR of"
 284                         " mempool (%s).",
 285                         dev->data->port_id, mp->name);
 286                 data->ret = -1;
 287                 return;
 288         }
 289         rte_rwlock_write_lock(&sh->share_cache.rwlock);
 290         LIST_INSERT_HEAD(&sh->share_cache.mr_list, mr, mr);
 291         /* Insert to the global cache table. */
 292         mlx5_mr_insert_cache(&sh->share_cache, mr);
 293         rte_rwlock_write_unlock(&sh->share_cache.rwlock);
 294         /* Insert to the local cache table */
 295         mlx5_mr_addr2mr_bh(sh->pd, &priv->mp_id, &sh->share_cache,
 296                            mr_ctrl, addr, priv->config.mr_ext_memseg_en);
 297 }
 298
 299 /**
 300  * Finds the first ethdev that match the pci device.
 301  * The existence of multiple ethdev per pci device is only with representors.
 302  * On such case, it is enough to get only one of the ports as they all share
 303  * the same ibv context.
 304  *
 305  * @param pdev
 306  *   Pointer to the PCI device.
 307  *
 308  * @return
 309  *   Pointer to the ethdev if found, NULL otherwise.
 310  */
 311 static struct rte_eth_dev *
 312 pci_dev_to_eth_dev(struct rte_pci_device *pdev)
 313 {
 314         uint16_t port_id;
 315
 316         port_id = rte_eth_find_next_of(0, &pdev->device);
 317         if (port_id == RTE_MAX_ETHPORTS)
 318                 return NULL;
 319         return &rte_eth_devices[port_id];
 320 }
 321
 322 /**
 323  * DPDK callback to DMA map external memory to a PCI device.
 324  *
 325  * @param pdev
 326  *   Pointer to the PCI device.
 327  * @param addr
 328  *   Starting virtual address of memory to be mapped.
 329  * @param iova
 330  *   Starting IOVA address of memory to be mapped.
 331  * @param len
 332  *   Length of memory segment being mapped.
 333  *
 334  * @return
 335  *   0 on success, negative value on error.
 336  */
 337 int
 338 mlx5_dma_map(struct rte_pci_device *pdev, void *addr,
 339              uint64_t iova __rte_unused, size_t len)
 340 {
 341         struct rte_eth_dev *dev;
 342         struct mlx5_mr *mr;
 343         struct mlx5_priv *priv;
 344         struct mlx5_dev_ctx_shared *sh;
 345
 346         dev = pci_dev_to_eth_dev(pdev);
 347         if (!dev) {
 348                 DRV_LOG(WARNING, "unable to find matching ethdev "
 349                                  "to PCI device %p", (void *)pdev);
 350                 rte_errno = ENODEV;
 351                 return -1;
 352         }
 353         priv = dev->data->dev_private;
 354         sh = priv->sh;
 355         mr = mlx5_create_mr_ext(sh->pd, (uintptr_t)addr, len, SOCKET_ID_ANY,
 356                                 sh->share_cache.reg_mr_cb);
 357         if (!mr) {
 358                 DRV_LOG(WARNING,
 359                         "port %u unable to dma map", dev->data->port_id);
 360                 rte_errno = EINVAL;
 361                 return -1;
 362         }
 363         rte_rwlock_write_lock(&sh->share_cache.rwlock);
 364         LIST_INSERT_HEAD(&sh->share_cache.mr_list, mr, mr);
 365         /* Insert to the global cache table. */
 366         mlx5_mr_insert_cache(&sh->share_cache, mr);
 367         rte_rwlock_write_unlock(&sh->share_cache.rwlock);
 368         return 0;
 369 }
 370
 371 /**
 372  * DPDK callback to DMA unmap external memory to a PCI device.
 373  *
 374  * @param pdev
 375  *   Pointer to the PCI device.
 376  * @param addr
 377  *   Starting virtual address of memory to be unmapped.
 378  * @param iova
 379  *   Starting IOVA address of memory to be unmapped.
 380  * @param len
 381  *   Length of memory segment being unmapped.
 382  *
 383  * @return
 384  *   0 on success, negative value on error.
 385  */
 386 int
 387 mlx5_dma_unmap(struct rte_pci_device *pdev, void *addr,
 388                uint64_t iova __rte_unused, size_t len __rte_unused)
 389 {
 390         struct rte_eth_dev *dev;
 391         struct mlx5_priv *priv;
 392         struct mlx5_dev_ctx_shared *sh;
 393         struct mlx5_mr *mr;
 394         struct mr_cache_entry entry;
 395
 396         dev = pci_dev_to_eth_dev(pdev);
 397         if (!dev) {
 398                 DRV_LOG(WARNING, "unable to find matching ethdev "
 399                                  "to PCI device %p", (void *)pdev);
 400                 rte_errno = ENODEV;
 401                 return -1;
 402         }
 403         priv = dev->data->dev_private;
 404         sh = priv->sh;
 405         rte_rwlock_read_lock(&sh->share_cache.rwlock);
 406         mr = mlx5_mr_lookup_list(&sh->share_cache, &entry, (uintptr_t)addr);
 407         if (!mr) {
 408                 rte_rwlock_read_unlock(&sh->share_cache.rwlock);
 409                 DRV_LOG(WARNING, "address 0x%" PRIxPTR " wasn't registered "
 410                                  "to PCI device %p", (uintptr_t)addr,
 411                                  (void *)pdev);
 412                 rte_errno = EINVAL;
 413                 return -1;
 414         }
 415         LIST_REMOVE(mr, mr);
 416         LIST_INSERT_HEAD(&sh->share_cache.mr_free_list, mr, mr);
 417         DEBUG("port %u remove MR(%p) from list", dev->data->port_id,
 418               (void *)mr);
 419         mlx5_mr_rebuild_cache(&sh->share_cache);
 420         /*
 421          * Flush local caches by propagating invalidation across cores.
 422          * rte_smp_wmb() is enough to synchronize this event. If one of
 423          * freed memsegs is seen by other core, that means the memseg
 424          * has been allocated by allocator, which will come after this
 425          * free call. Therefore, this store instruction (incrementing
 426          * generation below) will be guaranteed to be seen by other core
 427          * before the core sees the newly allocated memory.
 428          */
 429         ++sh->share_cache.dev_gen;
 430         DEBUG("broadcasting local cache flush, gen=%d",
 431               sh->share_cache.dev_gen);
 432         rte_smp_wmb();
 433         rte_rwlock_read_unlock(&sh->share_cache.rwlock);
 434         return 0;
 435 }
 436
 437 /**
 438  * Register MR for entire memory chunks in a Mempool having externally allocated
 439  * memory and fill in local cache.
 440  *
 441  * @param dev
 442  *   Pointer to Ethernet device.
 443  * @param mr_ctrl
 444  *   Pointer to per-queue MR control structure.
 445  * @param mp
 446  *   Pointer to registering Mempool.
 447  *
 448  * @return
 449  *   0 on success, -1 on failure.
 450  */
 451 static uint32_t
 452 mlx5_mr_update_ext_mp(struct rte_eth_dev *dev, struct mlx5_mr_ctrl *mr_ctrl,
 453                       struct rte_mempool *mp)
 454 {
 455         struct mr_update_mp_data data = {
 456                 .dev = dev,
 457                 .mr_ctrl = mr_ctrl,
 458                 .ret = 0,
 459         };
 460
 461         rte_mempool_mem_iter(mp, mlx5_mr_update_ext_mp_cb, &data);
 462         return data.ret;
 463 }
 464
 465 /**
 466  * Register MR entire memory chunks in a Mempool having externally allocated
 467  * memory and search LKey of the address to return.
 468  *
 469  * @param dev
 470  *   Pointer to Ethernet device.
 471  * @param addr
 472  *   Search key.
 473  * @param mp
 474  *   Pointer to registering Mempool where addr belongs.
 475  *
 476  * @return
 477  *   LKey for address on success, UINT32_MAX on failure.
 478  */
 479 uint32_t
 480 mlx5_tx_update_ext_mp(struct mlx5_txq_data *txq, uintptr_t addr,
 481                       struct rte_mempool *mp)
 482 {
 483         struct mlx5_txq_ctrl *txq_ctrl =
 484                 container_of(txq, struct mlx5_txq_ctrl, txq);
 485         struct mlx5_mr_ctrl *mr_ctrl = &txq->mr_ctrl;
 486         struct mlx5_priv *priv = txq_ctrl->priv;
 487
 488         if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
 489                 DRV_LOG(WARNING,
 490                         "port %u using address (%p) from unregistered mempool"
 491                         " having externally allocated memory"
 492                         " in secondary process, please create mempool"
 493                         " prior to rte_eth_dev_start()",
 494                         PORT_ID(priv), (void *)addr);
 495                 return UINT32_MAX;
 496         }
 497         mlx5_mr_update_ext_mp(ETH_DEV(priv), mr_ctrl, mp);
 498         return mlx5_tx_addr2mr_bh(txq, addr);
 499 }
 500
 501 /* Called during rte_mempool_mem_iter() by mlx5_mr_update_mp(). */
 502 static void
 503 mlx5_mr_update_mp_cb(struct rte_mempool *mp __rte_unused, void *opaque,
 504                      struct rte_mempool_memhdr *memhdr,
 505                      unsigned mem_idx __rte_unused)
 506 {
 507         struct mr_update_mp_data *data = opaque;
 508         struct rte_eth_dev *dev = data->dev;
 509         struct mlx5_priv *priv = dev->data->dev_private;
 510
 511         uint32_t lkey;
 512
 513         /* Stop iteration if failed in the previous walk. */
 514         if (data->ret < 0)
 515                 return;
 516         /* Register address of the chunk and update local caches. */
 517         lkey = mlx5_mr_addr2mr_bh(priv->sh->pd, &priv->mp_id,
 518                                   &priv->sh->share_cache, data->mr_ctrl,
 519                                   (uintptr_t)memhdr->addr,
 520                                   priv->config.mr_ext_memseg_en);
 521         if (lkey == UINT32_MAX)
 522                 data->ret = -1;
 523 }
 524
 525 /**
 526  * Register entire memory chunks in a Mempool.
 527  *
 528  * @param dev
 529  *   Pointer to Ethernet device.
 530  * @param mr_ctrl
 531  *   Pointer to per-queue MR control structure.
 532  * @param mp
 533  *   Pointer to registering Mempool.
 534  *
 535  * @return
 536  *   0 on success, -1 on failure.
 537  */
 538 int
 539 mlx5_mr_update_mp(struct rte_eth_dev *dev, struct mlx5_mr_ctrl *mr_ctrl,
 540                   struct rte_mempool *mp)
 541 {
 542         struct mr_update_mp_data data = {
 543                 .dev = dev,
 544                 .mr_ctrl = mr_ctrl,
 545                 .ret = 0,
 546         };
 547
 548         rte_mempool_mem_iter(mp, mlx5_mr_update_mp_cb, &data);
 549         if (data.ret < 0 && rte_errno == ENXIO) {
 550                 /* Mempool may have externally allocated memory. */
 551                 return mlx5_mr_update_ext_mp(dev, mr_ctrl, mp);
 552         }
 553         return data.ret;
 554 }