drivers/infiniband/hw/mlx5/mr.c

   1 /*
   2  * Copyright (c) 2013-2015, Mellanox Technologies. All rights reserved.
   3  * Copyright (c) 2020, Intel Corporation. All rights reserved.
   4  *
   5  * This software is available to you under a choice of one of two
   6  * licenses.  You may choose to be licensed under the terms of the GNU
   7  * General Public License (GPL) Version 2, available from the file
   8  * COPYING in the main directory of this source tree, or the
   9  * OpenIB.org BSD license below:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      - Redistributions of source code must retain the above
  16  *        copyright notice, this list of conditions and the following
  17  *        disclaimer.
  18  *
  19  *      - Redistributions in binary form must reproduce the above
  20  *        copyright notice, this list of conditions and the following
  21  *        disclaimer in the documentation and/or other materials
  22  *        provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33
  34
  35 #include <linux/kref.h>
  36 #include <linux/random.h>
  37 #include <linux/debugfs.h>
  38 #include <linux/export.h>
  39 #include <linux/delay.h>
  40 #include <linux/dma-buf.h>
  41 #include <linux/dma-resv.h>
  42 #include <rdma/ib_umem.h>
  43 #include <rdma/ib_umem_odp.h>
  44 #include <rdma/ib_verbs.h>
  45 #include "dm.h"
  46 #include "mlx5_ib.h"
  47 #include "umr.h"
  48
  49 enum {
  50         MAX_PENDING_REG_MR = 8,
  51 };
  52
  53 #define MLX5_UMR_ALIGN 2048
  54
  55 static void
  56 create_mkey_callback(int status, struct mlx5_async_work *context);
  57 static struct mlx5_ib_mr *reg_create(struct ib_pd *pd, struct ib_umem *umem,
  58                                      u64 iova, int access_flags,
  59                                      unsigned int page_size, bool populate);
  60
  61 static void set_mkc_access_pd_addr_fields(void *mkc, int acc, u64 start_addr,
  62                                           struct ib_pd *pd)
  63 {
  64         struct mlx5_ib_dev *dev = to_mdev(pd->device);
  65
  66         MLX5_SET(mkc, mkc, a, !!(acc & IB_ACCESS_REMOTE_ATOMIC));
  67         MLX5_SET(mkc, mkc, rw, !!(acc & IB_ACCESS_REMOTE_WRITE));
  68         MLX5_SET(mkc, mkc, rr, !!(acc & IB_ACCESS_REMOTE_READ));
  69         MLX5_SET(mkc, mkc, lw, !!(acc & IB_ACCESS_LOCAL_WRITE));
  70         MLX5_SET(mkc, mkc, lr, 1);
  71
  72         if ((acc & IB_ACCESS_RELAXED_ORDERING) &&
  73             pcie_relaxed_ordering_enabled(dev->mdev->pdev)) {
  74                 if (MLX5_CAP_GEN(dev->mdev, relaxed_ordering_write))
  75                         MLX5_SET(mkc, mkc, relaxed_ordering_write, 1);
  76                 if (MLX5_CAP_GEN(dev->mdev, relaxed_ordering_read))
  77                         MLX5_SET(mkc, mkc, relaxed_ordering_read, 1);
  78         }
  79
  80         MLX5_SET(mkc, mkc, pd, to_mpd(pd)->pdn);
  81         MLX5_SET(mkc, mkc, qpn, 0xffffff);
  82         MLX5_SET64(mkc, mkc, start_addr, start_addr);
  83 }
  84
  85 static void assign_mkey_variant(struct mlx5_ib_dev *dev,
  86                                 struct mlx5_ib_mkey *mkey, u32 *in)
  87 {
  88         u8 key = atomic_inc_return(&dev->mkey_var);
  89         void *mkc;
  90
  91         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
  92         MLX5_SET(mkc, mkc, mkey_7_0, key);
  93         mkey->key = key;
  94 }
  95
  96 static int mlx5_ib_create_mkey(struct mlx5_ib_dev *dev,
  97                                struct mlx5_ib_mkey *mkey, u32 *in, int inlen)
  98 {
  99         int ret;
 100
 101         assign_mkey_variant(dev, mkey, in);
 102         ret = mlx5_core_create_mkey(dev->mdev, &mkey->key, in, inlen);
 103         if (!ret)
 104                 init_waitqueue_head(&mkey->wait);
 105
 106         return ret;
 107 }
 108
 109 static int
 110 mlx5_ib_create_mkey_cb(struct mlx5_ib_dev *dev,
 111                        struct mlx5_ib_mkey *mkey,
 112                        struct mlx5_async_ctx *async_ctx,
 113                        u32 *in, int inlen, u32 *out, int outlen,
 114                        struct mlx5_async_work *context)
 115 {
 116         MLX5_SET(create_mkey_in, in, opcode, MLX5_CMD_OP_CREATE_MKEY);
 117         assign_mkey_variant(dev, mkey, in);
 118         return mlx5_cmd_exec_cb(async_ctx, in, inlen, out, outlen,
 119                                 create_mkey_callback, context);
 120 }
 121
 122 static int mr_cache_max_order(struct mlx5_ib_dev *dev);
 123 static void queue_adjust_cache_locked(struct mlx5_cache_ent *ent);
 124
 125 static bool umr_can_use_indirect_mkey(struct mlx5_ib_dev *dev)
 126 {
 127         return !MLX5_CAP_GEN(dev->mdev, umr_indirect_mkey_disabled);
 128 }
 129
 130 static int destroy_mkey(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
 131 {
 132         WARN_ON(xa_load(&dev->odp_mkeys, mlx5_base_mkey(mr->mmkey.key)));
 133
 134         return mlx5_core_destroy_mkey(dev->mdev, mr->mmkey.key);
 135 }
 136
 137 static void create_mkey_warn(struct mlx5_ib_dev *dev, int status, void *out)
 138 {
 139         if (status == -ENXIO) /* core driver is not available */
 140                 return;
 141
 142         mlx5_ib_warn(dev, "async reg mr failed. status %d\n", status);
 143         if (status != -EREMOTEIO) /* driver specific failure */
 144                 return;
 145
 146         /* Failed in FW, print cmd out failure details */
 147         mlx5_cmd_out_err(dev->mdev, MLX5_CMD_OP_CREATE_MKEY, 0, out);
 148 }
 149
 150 static void create_mkey_callback(int status, struct mlx5_async_work *context)
 151 {
 152         struct mlx5_ib_mr *mr =
 153                 container_of(context, struct mlx5_ib_mr, cb_work);
 154         struct mlx5_cache_ent *ent = mr->cache_ent;
 155         struct mlx5_ib_dev *dev = ent->dev;
 156         unsigned long flags;
 157
 158         if (status) {
 159                 create_mkey_warn(dev, status, mr->out);
 160                 kfree(mr);
 161                 spin_lock_irqsave(&ent->lock, flags);
 162                 ent->pending--;
 163                 WRITE_ONCE(dev->fill_delay, 1);
 164                 spin_unlock_irqrestore(&ent->lock, flags);
 165                 mod_timer(&dev->delay_timer, jiffies + HZ);
 166                 return;
 167         }
 168
 169         mr->mmkey.type = MLX5_MKEY_MR;
 170         mr->mmkey.key |= mlx5_idx_to_mkey(
 171                 MLX5_GET(create_mkey_out, mr->out, mkey_index));
 172         init_waitqueue_head(&mr->mmkey.wait);
 173
 174         WRITE_ONCE(dev->cache.last_add, jiffies);
 175
 176         spin_lock_irqsave(&ent->lock, flags);
 177         list_add_tail(&mr->list, &ent->head);
 178         ent->available_mrs++;
 179         ent->total_mrs++;
 180         /* If we are doing fill_to_high_water then keep going. */
 181         queue_adjust_cache_locked(ent);
 182         ent->pending--;
 183         spin_unlock_irqrestore(&ent->lock, flags);
 184 }
 185
 186 static int get_mkc_octo_size(unsigned int access_mode, unsigned int ndescs)
 187 {
 188         int ret = 0;
 189
 190         switch (access_mode) {
 191         case MLX5_MKC_ACCESS_MODE_MTT:
 192                 ret = DIV_ROUND_UP(ndescs, MLX5_IB_UMR_OCTOWORD /
 193                                                    sizeof(struct mlx5_mtt));
 194                 break;
 195         case MLX5_MKC_ACCESS_MODE_KSM:
 196                 ret = DIV_ROUND_UP(ndescs, MLX5_IB_UMR_OCTOWORD /
 197                                                    sizeof(struct mlx5_klm));
 198                 break;
 199         default:
 200                 WARN_ON(1);
 201         }
 202         return ret;
 203 }
 204
 205 static struct mlx5_ib_mr *alloc_cache_mr(struct mlx5_cache_ent *ent, void *mkc)
 206 {
 207         struct mlx5_ib_mr *mr;
 208
 209         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
 210         if (!mr)
 211                 return NULL;
 212         mr->cache_ent = ent;
 213
 214         set_mkc_access_pd_addr_fields(mkc, 0, 0, ent->dev->umrc.pd);
 215         MLX5_SET(mkc, mkc, free, 1);
 216         MLX5_SET(mkc, mkc, umr_en, 1);
 217         MLX5_SET(mkc, mkc, access_mode_1_0, ent->access_mode & 0x3);
 218         MLX5_SET(mkc, mkc, access_mode_4_2, (ent->access_mode >> 2) & 0x7);
 219
 220         MLX5_SET(mkc, mkc, translations_octword_size,
 221                  get_mkc_octo_size(ent->access_mode, ent->ndescs));
 222         MLX5_SET(mkc, mkc, log_page_size, ent->page);
 223         return mr;
 224 }
 225
 226 /* Asynchronously schedule new MRs to be populated in the cache. */
 227 static int add_keys(struct mlx5_cache_ent *ent, unsigned int num)
 228 {
 229         size_t inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
 230         struct mlx5_ib_mr *mr;
 231         void *mkc;
 232         u32 *in;
 233         int err = 0;
 234         int i;
 235
 236         in = kzalloc(inlen, GFP_KERNEL);
 237         if (!in)
 238                 return -ENOMEM;
 239
 240         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
 241         for (i = 0; i < num; i++) {
 242                 mr = alloc_cache_mr(ent, mkc);
 243                 if (!mr) {
 244                         err = -ENOMEM;
 245                         break;
 246                 }
 247                 spin_lock_irq(&ent->lock);
 248                 if (ent->pending >= MAX_PENDING_REG_MR) {
 249                         err = -EAGAIN;
 250                         spin_unlock_irq(&ent->lock);
 251                         kfree(mr);
 252                         break;
 253                 }
 254                 ent->pending++;
 255                 spin_unlock_irq(&ent->lock);
 256                 err = mlx5_ib_create_mkey_cb(ent->dev, &mr->mmkey,
 257                                              &ent->dev->async_ctx, in, inlen,
 258                                              mr->out, sizeof(mr->out),
 259                                              &mr->cb_work);
 260                 if (err) {
 261                         spin_lock_irq(&ent->lock);
 262                         ent->pending--;
 263                         spin_unlock_irq(&ent->lock);
 264                         mlx5_ib_warn(ent->dev, "create mkey failed %d\n", err);
 265                         kfree(mr);
 266                         break;
 267                 }
 268         }
 269
 270         kfree(in);
 271         return err;
 272 }
 273
 274 /* Synchronously create a MR in the cache */
 275 static struct mlx5_ib_mr *create_cache_mr(struct mlx5_cache_ent *ent)
 276 {
 277         size_t inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
 278         struct mlx5_ib_mr *mr;
 279         void *mkc;
 280         u32 *in;
 281         int err;
 282
 283         in = kzalloc(inlen, GFP_KERNEL);
 284         if (!in)
 285                 return ERR_PTR(-ENOMEM);
 286         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
 287
 288         mr = alloc_cache_mr(ent, mkc);
 289         if (!mr) {
 290                 err = -ENOMEM;
 291                 goto free_in;
 292         }
 293
 294         err = mlx5_core_create_mkey(ent->dev->mdev, &mr->mmkey.key, in, inlen);
 295         if (err)
 296                 goto free_mr;
 297
 298         init_waitqueue_head(&mr->mmkey.wait);
 299         mr->mmkey.type = MLX5_MKEY_MR;
 300         WRITE_ONCE(ent->dev->cache.last_add, jiffies);
 301         spin_lock_irq(&ent->lock);
 302         ent->total_mrs++;
 303         spin_unlock_irq(&ent->lock);
 304         kfree(in);
 305         return mr;
 306 free_mr:
 307         kfree(mr);
 308 free_in:
 309         kfree(in);
 310         return ERR_PTR(err);
 311 }
 312
 313 static void remove_cache_mr_locked(struct mlx5_cache_ent *ent)
 314 {
 315         struct mlx5_ib_mr *mr;
 316
 317         lockdep_assert_held(&ent->lock);
 318         if (list_empty(&ent->head))
 319                 return;
 320         mr = list_first_entry(&ent->head, struct mlx5_ib_mr, list);
 321         list_del(&mr->list);
 322         ent->available_mrs--;
 323         ent->total_mrs--;
 324         spin_unlock_irq(&ent->lock);
 325         mlx5_core_destroy_mkey(ent->dev->mdev, mr->mmkey.key);
 326         kfree(mr);
 327         spin_lock_irq(&ent->lock);
 328 }
 329
 330 static int resize_available_mrs(struct mlx5_cache_ent *ent, unsigned int target,
 331                                 bool limit_fill)
 332 {
 333         int err;
 334
 335         lockdep_assert_held(&ent->lock);
 336
 337         while (true) {
 338                 if (limit_fill)
 339                         target = ent->limit * 2;
 340                 if (target == ent->available_mrs + ent->pending)
 341                         return 0;
 342                 if (target > ent->available_mrs + ent->pending) {
 343                         u32 todo = target - (ent->available_mrs + ent->pending);
 344
 345                         spin_unlock_irq(&ent->lock);
 346                         err = add_keys(ent, todo);
 347                         if (err == -EAGAIN)
 348                                 usleep_range(3000, 5000);
 349                         spin_lock_irq(&ent->lock);
 350                         if (err) {
 351                                 if (err != -EAGAIN)
 352                                         return err;
 353                         } else
 354                                 return 0;
 355                 } else {
 356                         remove_cache_mr_locked(ent);
 357                 }
 358         }
 359 }
 360
 361 static ssize_t size_write(struct file *filp, const char __user *buf,
 362                           size_t count, loff_t *pos)
 363 {
 364         struct mlx5_cache_ent *ent = filp->private_data;
 365         u32 target;
 366         int err;
 367
 368         err = kstrtou32_from_user(buf, count, 0, &target);
 369         if (err)
 370                 return err;
 371
 372         /*
 373          * Target is the new value of total_mrs the user requests, however we
 374          * cannot free MRs that are in use. Compute the target value for
 375          * available_mrs.
 376          */
 377         spin_lock_irq(&ent->lock);
 378         if (target < ent->total_mrs - ent->available_mrs) {
 379                 err = -EINVAL;
 380                 goto err_unlock;
 381         }
 382         target = target - (ent->total_mrs - ent->available_mrs);
 383         if (target < ent->limit || target > ent->limit*2) {
 384                 err = -EINVAL;
 385                 goto err_unlock;
 386         }
 387         err = resize_available_mrs(ent, target, false);
 388         if (err)
 389                 goto err_unlock;
 390         spin_unlock_irq(&ent->lock);
 391
 392         return count;
 393
 394 err_unlock:
 395         spin_unlock_irq(&ent->lock);
 396         return err;
 397 }
 398
 399 static ssize_t size_read(struct file *filp, char __user *buf, size_t count,
 400                          loff_t *pos)
 401 {
 402         struct mlx5_cache_ent *ent = filp->private_data;
 403         char lbuf[20];
 404         int err;
 405
 406         err = snprintf(lbuf, sizeof(lbuf), "%d\n", ent->total_mrs);
 407         if (err < 0)
 408                 return err;
 409
 410         return simple_read_from_buffer(buf, count, pos, lbuf, err);
 411 }
 412
 413 static const struct file_operations size_fops = {
 414         .owner  = THIS_MODULE,
 415         .open   = simple_open,
 416         .write  = size_write,
 417         .read   = size_read,
 418 };
 419
 420 static ssize_t limit_write(struct file *filp, const char __user *buf,
 421                            size_t count, loff_t *pos)
 422 {
 423         struct mlx5_cache_ent *ent = filp->private_data;
 424         u32 var;
 425         int err;
 426
 427         err = kstrtou32_from_user(buf, count, 0, &var);
 428         if (err)
 429                 return err;
 430
 431         /*
 432          * Upon set we immediately fill the cache to high water mark implied by
 433          * the limit.
 434          */
 435         spin_lock_irq(&ent->lock);
 436         ent->limit = var;
 437         err = resize_available_mrs(ent, 0, true);
 438         spin_unlock_irq(&ent->lock);
 439         if (err)
 440                 return err;
 441         return count;
 442 }
 443
 444 static ssize_t limit_read(struct file *filp, char __user *buf, size_t count,
 445                           loff_t *pos)
 446 {
 447         struct mlx5_cache_ent *ent = filp->private_data;
 448         char lbuf[20];
 449         int err;
 450
 451         err = snprintf(lbuf, sizeof(lbuf), "%d\n", ent->limit);
 452         if (err < 0)
 453                 return err;
 454
 455         return simple_read_from_buffer(buf, count, pos, lbuf, err);
 456 }
 457
 458 static const struct file_operations limit_fops = {
 459         .owner  = THIS_MODULE,
 460         .open   = simple_open,
 461         .write  = limit_write,
 462         .read   = limit_read,
 463 };
 464
 465 static bool someone_adding(struct mlx5_mr_cache *cache)
 466 {
 467         unsigned int i;
 468
 469         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++) {
 470                 struct mlx5_cache_ent *ent = &cache->ent[i];
 471                 bool ret;
 472
 473                 spin_lock_irq(&ent->lock);
 474                 ret = ent->available_mrs < ent->limit;
 475                 spin_unlock_irq(&ent->lock);
 476                 if (ret)
 477                         return true;
 478         }
 479         return false;
 480 }
 481
 482 /*
 483  * Check if the bucket is outside the high/low water mark and schedule an async
 484  * update. The cache refill has hysteresis, once the low water mark is hit it is
 485  * refilled up to the high mark.
 486  */
 487 static void queue_adjust_cache_locked(struct mlx5_cache_ent *ent)
 488 {
 489         lockdep_assert_held(&ent->lock);
 490
 491         if (ent->disabled || READ_ONCE(ent->dev->fill_delay))
 492                 return;
 493         if (ent->available_mrs < ent->limit) {
 494                 ent->fill_to_high_water = true;
 495                 mod_delayed_work(ent->dev->cache.wq, &ent->dwork, 0);
 496         } else if (ent->fill_to_high_water &&
 497                    ent->available_mrs + ent->pending < 2 * ent->limit) {
 498                 /*
 499                  * Once we start populating due to hitting a low water mark
 500                  * continue until we pass the high water mark.
 501                  */
 502                 mod_delayed_work(ent->dev->cache.wq, &ent->dwork, 0);
 503         } else if (ent->available_mrs == 2 * ent->limit) {
 504                 ent->fill_to_high_water = false;
 505         } else if (ent->available_mrs > 2 * ent->limit) {
 506                 /* Queue deletion of excess entries */
 507                 ent->fill_to_high_water = false;
 508                 if (ent->pending)
 509                         queue_delayed_work(ent->dev->cache.wq, &ent->dwork,
 510                                            msecs_to_jiffies(1000));
 511                 else
 512                         mod_delayed_work(ent->dev->cache.wq, &ent->dwork, 0);
 513         }
 514 }
 515
 516 static void __cache_work_func(struct mlx5_cache_ent *ent)
 517 {
 518         struct mlx5_ib_dev *dev = ent->dev;
 519         struct mlx5_mr_cache *cache = &dev->cache;
 520         int err;
 521
 522         spin_lock_irq(&ent->lock);
 523         if (ent->disabled)
 524                 goto out;
 525
 526         if (ent->fill_to_high_water &&
 527             ent->available_mrs + ent->pending < 2 * ent->limit &&
 528             !READ_ONCE(dev->fill_delay)) {
 529                 spin_unlock_irq(&ent->lock);
 530                 err = add_keys(ent, 1);
 531                 spin_lock_irq(&ent->lock);
 532                 if (ent->disabled)
 533                         goto out;
 534                 if (err) {
 535                         /*
 536                          * EAGAIN only happens if pending is positive, so we
 537                          * will be rescheduled from reg_mr_callback(). The only
 538                          * failure path here is ENOMEM.
 539                          */
 540                         if (err != -EAGAIN) {
 541                                 mlx5_ib_warn(
 542                                         dev,
 543                                         "command failed order %d, err %d\n",
 544                                         ent->order, err);
 545                                 queue_delayed_work(cache->wq, &ent->dwork,
 546                                                    msecs_to_jiffies(1000));
 547                         }
 548                 }
 549         } else if (ent->available_mrs > 2 * ent->limit) {
 550                 bool need_delay;
 551
 552                 /*
 553                  * The remove_cache_mr() logic is performed as garbage
 554                  * collection task. Such task is intended to be run when no
 555                  * other active processes are running.
 556                  *
 557                  * The need_resched() will return TRUE if there are user tasks
 558                  * to be activated in near future.
 559                  *
 560                  * In such case, we don't execute remove_cache_mr() and postpone
 561                  * the garbage collection work to try to run in next cycle, in
 562                  * order to free CPU resources to other tasks.
 563                  */
 564                 spin_unlock_irq(&ent->lock);
 565                 need_delay = need_resched() || someone_adding(cache) ||
 566                              !time_after(jiffies,
 567                                          READ_ONCE(cache->last_add) + 300 * HZ);
 568                 spin_lock_irq(&ent->lock);
 569                 if (ent->disabled)
 570                         goto out;
 571                 if (need_delay)
 572                         queue_delayed_work(cache->wq, &ent->dwork, 300 * HZ);
 573                 remove_cache_mr_locked(ent);
 574                 queue_adjust_cache_locked(ent);
 575         }
 576 out:
 577         spin_unlock_irq(&ent->lock);
 578 }
 579
 580 static void delayed_cache_work_func(struct work_struct *work)
 581 {
 582         struct mlx5_cache_ent *ent;
 583
 584         ent = container_of(work, struct mlx5_cache_ent, dwork.work);
 585         __cache_work_func(ent);
 586 }
 587
 588 struct mlx5_ib_mr *mlx5_mr_cache_alloc(struct mlx5_ib_dev *dev,
 589                                        struct mlx5_cache_ent *ent,
 590                                        int access_flags)
 591 {
 592         struct mlx5_ib_mr *mr;
 593
 594         /* Matches access in alloc_cache_mr() */
 595         if (!mlx5r_umr_can_reconfig(dev, 0, access_flags))
 596                 return ERR_PTR(-EOPNOTSUPP);
 597
 598         spin_lock_irq(&ent->lock);
 599         if (list_empty(&ent->head)) {
 600                 queue_adjust_cache_locked(ent);
 601                 ent->miss++;
 602                 spin_unlock_irq(&ent->lock);
 603                 mr = create_cache_mr(ent);
 604                 if (IS_ERR(mr))
 605                         return mr;
 606         } else {
 607                 mr = list_first_entry(&ent->head, struct mlx5_ib_mr, list);
 608                 list_del(&mr->list);
 609                 ent->available_mrs--;
 610                 queue_adjust_cache_locked(ent);
 611                 spin_unlock_irq(&ent->lock);
 612
 613                 mlx5_clear_mr(mr);
 614         }
 615         return mr;
 616 }
 617
 618 static void mlx5_mr_cache_free(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
 619 {
 620         struct mlx5_cache_ent *ent = mr->cache_ent;
 621
 622         spin_lock_irq(&ent->lock);
 623         list_add_tail(&mr->list, &ent->head);
 624         ent->available_mrs++;
 625         queue_adjust_cache_locked(ent);
 626         spin_unlock_irq(&ent->lock);
 627 }
 628
 629 static void clean_keys(struct mlx5_ib_dev *dev, int c)
 630 {
 631         struct mlx5_mr_cache *cache = &dev->cache;
 632         struct mlx5_cache_ent *ent = &cache->ent[c];
 633         struct mlx5_ib_mr *tmp_mr;
 634         struct mlx5_ib_mr *mr;
 635         LIST_HEAD(del_list);
 636
 637         cancel_delayed_work(&ent->dwork);
 638         while (1) {
 639                 spin_lock_irq(&ent->lock);
 640                 if (list_empty(&ent->head)) {
 641                         spin_unlock_irq(&ent->lock);
 642                         break;
 643                 }
 644                 mr = list_first_entry(&ent->head, struct mlx5_ib_mr, list);
 645                 list_move(&mr->list, &del_list);
 646                 ent->available_mrs--;
 647                 ent->total_mrs--;
 648                 spin_unlock_irq(&ent->lock);
 649                 mlx5_core_destroy_mkey(dev->mdev, mr->mmkey.key);
 650         }
 651
 652         list_for_each_entry_safe(mr, tmp_mr, &del_list, list) {
 653                 list_del(&mr->list);
 654                 kfree(mr);
 655         }
 656 }
 657
 658 static void mlx5_mr_cache_debugfs_cleanup(struct mlx5_ib_dev *dev)
 659 {
 660         if (!mlx5_debugfs_root || dev->is_rep)
 661                 return;
 662
 663         debugfs_remove_recursive(dev->cache.root);
 664         dev->cache.root = NULL;
 665 }
 666
 667 static void mlx5_mr_cache_debugfs_init(struct mlx5_ib_dev *dev)
 668 {
 669         struct mlx5_mr_cache *cache = &dev->cache;
 670         struct mlx5_cache_ent *ent;
 671         struct dentry *dir;
 672         int i;
 673
 674         if (!mlx5_debugfs_root || dev->is_rep)
 675                 return;
 676
 677         cache->root = debugfs_create_dir("mr_cache", mlx5_debugfs_get_dev_root(dev->mdev));
 678
 679         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++) {
 680                 ent = &cache->ent[i];
 681                 sprintf(ent->name, "%d", ent->order);
 682                 dir = debugfs_create_dir(ent->name, cache->root);
 683                 debugfs_create_file("size", 0600, dir, ent, &size_fops);
 684                 debugfs_create_file("limit", 0600, dir, ent, &limit_fops);
 685                 debugfs_create_u32("cur", 0400, dir, &ent->available_mrs);
 686                 debugfs_create_u32("miss", 0600, dir, &ent->miss);
 687         }
 688 }
 689
 690 static void delay_time_func(struct timer_list *t)
 691 {
 692         struct mlx5_ib_dev *dev = from_timer(dev, t, delay_timer);
 693
 694         WRITE_ONCE(dev->fill_delay, 0);
 695 }
 696
 697 int mlx5_mr_cache_init(struct mlx5_ib_dev *dev)
 698 {
 699         struct mlx5_mr_cache *cache = &dev->cache;
 700         struct mlx5_cache_ent *ent;
 701         int i;
 702
 703         mutex_init(&dev->slow_path_mutex);
 704         cache->wq = alloc_ordered_workqueue("mkey_cache", WQ_MEM_RECLAIM);
 705         if (!cache->wq) {
 706                 mlx5_ib_warn(dev, "failed to create work queue\n");
 707                 return -ENOMEM;
 708         }
 709
 710         mlx5_cmd_init_async_ctx(dev->mdev, &dev->async_ctx);
 711         timer_setup(&dev->delay_timer, delay_time_func, 0);
 712         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++) {
 713                 ent = &cache->ent[i];
 714                 INIT_LIST_HEAD(&ent->head);
 715                 spin_lock_init(&ent->lock);
 716                 ent->order = i + 2;
 717                 ent->dev = dev;
 718                 ent->limit = 0;
 719
 720                 INIT_DELAYED_WORK(&ent->dwork, delayed_cache_work_func);
 721
 722                 if (i > MR_CACHE_LAST_STD_ENTRY) {
 723                         mlx5_odp_init_mr_cache_entry(ent);
 724                         continue;
 725                 }
 726
 727                 if (ent->order > mr_cache_max_order(dev))
 728                         continue;
 729
 730                 ent->page = PAGE_SHIFT;
 731                 ent->ndescs = 1 << ent->order;
 732                 ent->access_mode = MLX5_MKC_ACCESS_MODE_MTT;
 733                 if ((dev->mdev->profile.mask & MLX5_PROF_MASK_MR_CACHE) &&
 734                     !dev->is_rep && mlx5_core_is_pf(dev->mdev) &&
 735                     mlx5r_umr_can_load_pas(dev, 0))
 736                         ent->limit = dev->mdev->profile.mr_cache[i].limit;
 737                 else
 738                         ent->limit = 0;
 739                 spin_lock_irq(&ent->lock);
 740                 queue_adjust_cache_locked(ent);
 741                 spin_unlock_irq(&ent->lock);
 742         }
 743
 744         mlx5_mr_cache_debugfs_init(dev);
 745
 746         return 0;
 747 }
 748
 749 int mlx5_mr_cache_cleanup(struct mlx5_ib_dev *dev)
 750 {
 751         unsigned int i;
 752
 753         if (!dev->cache.wq)
 754                 return 0;
 755
 756         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++) {
 757                 struct mlx5_cache_ent *ent = &dev->cache.ent[i];
 758
 759                 spin_lock_irq(&ent->lock);
 760                 ent->disabled = true;
 761                 spin_unlock_irq(&ent->lock);
 762                 cancel_delayed_work_sync(&ent->dwork);
 763         }
 764
 765         mlx5_mr_cache_debugfs_cleanup(dev);
 766         mlx5_cmd_cleanup_async_ctx(&dev->async_ctx);
 767
 768         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++)
 769                 clean_keys(dev, i);
 770
 771         destroy_workqueue(dev->cache.wq);
 772         del_timer_sync(&dev->delay_timer);
 773
 774         return 0;
 775 }
 776
 777 struct ib_mr *mlx5_ib_get_dma_mr(struct ib_pd *pd, int acc)
 778 {
 779         struct mlx5_ib_dev *dev = to_mdev(pd->device);
 780         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
 781         struct mlx5_ib_mr *mr;
 782         void *mkc;
 783         u32 *in;
 784         int err;
 785
 786         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
 787         if (!mr)
 788                 return ERR_PTR(-ENOMEM);
 789
 790         in = kzalloc(inlen, GFP_KERNEL);
 791         if (!in) {
 792                 err = -ENOMEM;
 793                 goto err_free;
 794         }
 795
 796         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
 797
 798         MLX5_SET(mkc, mkc, access_mode_1_0, MLX5_MKC_ACCESS_MODE_PA);
 799         MLX5_SET(mkc, mkc, length64, 1);
 800         set_mkc_access_pd_addr_fields(mkc, acc | IB_ACCESS_RELAXED_ORDERING, 0,
 801                                       pd);
 802
 803         err = mlx5_ib_create_mkey(dev, &mr->mmkey, in, inlen);
 804         if (err)
 805                 goto err_in;
 806
 807         kfree(in);
 808         mr->mmkey.type = MLX5_MKEY_MR;
 809         mr->ibmr.lkey = mr->mmkey.key;
 810         mr->ibmr.rkey = mr->mmkey.key;
 811         mr->umem = NULL;
 812
 813         return &mr->ibmr;
 814
 815 err_in:
 816         kfree(in);
 817
 818 err_free:
 819         kfree(mr);
 820
 821         return ERR_PTR(err);
 822 }
 823
 824 static int get_octo_len(u64 addr, u64 len, int page_shift)
 825 {
 826         u64 page_size = 1ULL << page_shift;
 827         u64 offset;
 828         int npages;
 829
 830         offset = addr & (page_size - 1);
 831         npages = ALIGN(len + offset, page_size) >> page_shift;
 832         return (npages + 1) / 2;
 833 }
 834
 835 static int mr_cache_max_order(struct mlx5_ib_dev *dev)
 836 {
 837         if (MLX5_CAP_GEN(dev->mdev, umr_extended_translation_offset))
 838                 return MR_CACHE_LAST_STD_ENTRY + 2;
 839         return MLX5_MAX_UMR_SHIFT;
 840 }
 841
 842 static void mlx5_ib_umr_done(struct ib_cq *cq, struct ib_wc *wc)
 843 {
 844         struct mlx5_ib_umr_context *context =
 845                 container_of(wc->wr_cqe, struct mlx5_ib_umr_context, cqe);
 846
 847         context->status = wc->status;
 848         complete(&context->done);
 849 }
 850
 851 static inline void mlx5_ib_init_umr_context(struct mlx5_ib_umr_context *context)
 852 {
 853         context->cqe.done = mlx5_ib_umr_done;
 854         context->status = -1;
 855         init_completion(&context->done);
 856 }
 857
 858 static int mlx5_ib_post_send_wait(struct mlx5_ib_dev *dev,
 859                                   struct mlx5_umr_wr *umrwr)
 860 {
 861         struct umr_common *umrc = &dev->umrc;
 862         const struct ib_send_wr *bad;
 863         int err;
 864         struct mlx5_ib_umr_context umr_context;
 865
 866         mlx5_ib_init_umr_context(&umr_context);
 867         umrwr->wr.wr_cqe = &umr_context.cqe;
 868
 869         down(&umrc->sem);
 870         err = ib_post_send(umrc->qp, &umrwr->wr, &bad);
 871         if (err) {
 872                 mlx5_ib_warn(dev, "UMR post send failed, err %d\n", err);
 873         } else {
 874                 wait_for_completion(&umr_context.done);
 875                 if (umr_context.status != IB_WC_SUCCESS) {
 876                         mlx5_ib_warn(dev, "reg umr failed (%u)\n",
 877                                      umr_context.status);
 878                         err = -EFAULT;
 879                 }
 880         }
 881         up(&umrc->sem);
 882         return err;
 883 }
 884
 885 static struct mlx5_cache_ent *mr_cache_ent_from_order(struct mlx5_ib_dev *dev,
 886                                                       unsigned int order)
 887 {
 888         struct mlx5_mr_cache *cache = &dev->cache;
 889
 890         if (order < cache->ent[0].order)
 891                 return &cache->ent[0];
 892         order = order - cache->ent[0].order;
 893         if (order > MR_CACHE_LAST_STD_ENTRY)
 894                 return NULL;
 895         return &cache->ent[order];
 896 }
 897
 898 static void set_mr_fields(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr,
 899                           u64 length, int access_flags, u64 iova)
 900 {
 901         mr->ibmr.lkey = mr->mmkey.key;
 902         mr->ibmr.rkey = mr->mmkey.key;
 903         mr->ibmr.length = length;
 904         mr->ibmr.device = &dev->ib_dev;
 905         mr->ibmr.iova = iova;
 906         mr->access_flags = access_flags;
 907 }
 908
 909 static unsigned int mlx5_umem_dmabuf_default_pgsz(struct ib_umem *umem,
 910                                                   u64 iova)
 911 {
 912         /*
 913          * The alignment of iova has already been checked upon entering
 914          * UVERBS_METHOD_REG_DMABUF_MR
 915          */
 916         umem->iova = iova;
 917         return PAGE_SIZE;
 918 }
 919
 920 static struct mlx5_ib_mr *alloc_cacheable_mr(struct ib_pd *pd,
 921                                              struct ib_umem *umem, u64 iova,
 922                                              int access_flags)
 923 {
 924         struct mlx5_ib_dev *dev = to_mdev(pd->device);
 925         struct mlx5_cache_ent *ent;
 926         struct mlx5_ib_mr *mr;
 927         unsigned int page_size;
 928
 929         if (umem->is_dmabuf)
 930                 page_size = mlx5_umem_dmabuf_default_pgsz(umem, iova);
 931         else
 932                 page_size = mlx5_umem_find_best_pgsz(umem, mkc, log_page_size,
 933                                                      0, iova);
 934         if (WARN_ON(!page_size))
 935                 return ERR_PTR(-EINVAL);
 936         ent = mr_cache_ent_from_order(
 937                 dev, order_base_2(ib_umem_num_dma_blocks(umem, page_size)));
 938         /*
 939          * Matches access in alloc_cache_mr(). If the MR can't come from the
 940          * cache then synchronously create an uncached one.
 941          */
 942         if (!ent || ent->limit == 0 ||
 943             !mlx5r_umr_can_reconfig(dev, 0, access_flags)) {
 944                 mutex_lock(&dev->slow_path_mutex);
 945                 mr = reg_create(pd, umem, iova, access_flags, page_size, false);
 946                 mutex_unlock(&dev->slow_path_mutex);
 947                 return mr;
 948         }
 949
 950         mr = mlx5_mr_cache_alloc(dev, ent, access_flags);
 951         if (IS_ERR(mr))
 952                 return mr;
 953
 954         mr->ibmr.pd = pd;
 955         mr->umem = umem;
 956         mr->page_shift = order_base_2(page_size);
 957         set_mr_fields(dev, mr, umem->length, access_flags, iova);
 958
 959         return mr;
 960 }
 961
 962 /*
 963  * Create a MLX5_IB_SEND_UMR_UPDATE_XLT work request and XLT buffer ready for
 964  * submission.
 965  */
 966 static void *mlx5_ib_create_xlt_wr(struct mlx5_ib_mr *mr,
 967                                    struct mlx5_umr_wr *wr, struct ib_sge *sg,
 968                                    size_t nents, size_t ent_size,
 969                                    unsigned int flags)
 970 {
 971         struct mlx5_ib_dev *dev = mr_to_mdev(mr);
 972         void *xlt;
 973
 974         xlt = mlx5r_umr_create_xlt(dev, sg, nents, ent_size, flags);
 975
 976         memset(wr, 0, sizeof(*wr));
 977         wr->wr.send_flags = MLX5_IB_SEND_UMR_UPDATE_XLT;
 978         if (!(flags & MLX5_IB_UPD_XLT_ENABLE))
 979                 wr->wr.send_flags |= MLX5_IB_SEND_UMR_FAIL_IF_FREE;
 980         wr->wr.sg_list = sg;
 981         wr->wr.num_sge = 1;
 982         wr->wr.opcode = MLX5_IB_WR_UMR;
 983         wr->pd = mr->ibmr.pd;
 984         wr->mkey = mr->mmkey.key;
 985         wr->length = mr->ibmr.length;
 986         wr->virt_addr = mr->ibmr.iova;
 987         wr->access_flags = mr->access_flags;
 988         wr->page_shift = mr->page_shift;
 989         wr->xlt_size = sg->length;
 990         return xlt;
 991 }
 992
 993 static unsigned int xlt_wr_final_send_flags(unsigned int flags)
 994 {
 995         unsigned int res = 0;
 996
 997         if (flags & MLX5_IB_UPD_XLT_ENABLE)
 998                 res |= MLX5_IB_SEND_UMR_ENABLE_MR |
 999                        MLX5_IB_SEND_UMR_UPDATE_PD_ACCESS |
1000                        MLX5_IB_SEND_UMR_UPDATE_TRANSLATION;
1001         if (flags & MLX5_IB_UPD_XLT_PD || flags & MLX5_IB_UPD_XLT_ACCESS)
1002                 res |= MLX5_IB_SEND_UMR_UPDATE_PD_ACCESS;
1003         if (flags & MLX5_IB_UPD_XLT_ADDR)
1004                 res |= MLX5_IB_SEND_UMR_UPDATE_TRANSLATION;
1005         return res;
1006 }
1007
1008 int mlx5_ib_update_xlt(struct mlx5_ib_mr *mr, u64 idx, int npages,
1009                        int page_shift, int flags)
1010 {
1011         struct mlx5_ib_dev *dev = mr_to_mdev(mr);
1012         struct device *ddev = &dev->mdev->pdev->dev;
1013         void *xlt;
1014         struct mlx5_umr_wr wr;
1015         struct ib_sge sg;
1016         int err = 0;
1017         int desc_size = (flags & MLX5_IB_UPD_XLT_INDIRECT)
1018                                ? sizeof(struct mlx5_klm)
1019                                : sizeof(struct mlx5_mtt);
1020         const int page_align = MLX5_UMR_MTT_ALIGNMENT / desc_size;
1021         const int page_mask = page_align - 1;
1022         size_t pages_mapped = 0;
1023         size_t pages_to_map = 0;
1024         size_t pages_iter;
1025         size_t size_to_map = 0;
1026         size_t orig_sg_length;
1027
1028         if ((flags & MLX5_IB_UPD_XLT_INDIRECT) &&
1029             !umr_can_use_indirect_mkey(dev))
1030                 return -EPERM;
1031
1032         if (WARN_ON(!mr->umem->is_odp))
1033                 return -EINVAL;
1034
1035         /* UMR copies MTTs in units of MLX5_UMR_MTT_ALIGNMENT bytes,
1036          * so we need to align the offset and length accordingly
1037          */
1038         if (idx & page_mask) {
1039                 npages += idx & page_mask;
1040                 idx &= ~page_mask;
1041         }
1042         pages_to_map = ALIGN(npages, page_align);
1043
1044         xlt = mlx5_ib_create_xlt_wr(mr, &wr, &sg, npages, desc_size, flags);
1045         if (!xlt)
1046                 return -ENOMEM;
1047         pages_iter = sg.length / desc_size;
1048         orig_sg_length = sg.length;
1049
1050         if (!(flags & MLX5_IB_UPD_XLT_INDIRECT)) {
1051                 struct ib_umem_odp *odp = to_ib_umem_odp(mr->umem);
1052                 size_t max_pages = ib_umem_odp_num_pages(odp) - idx;
1053
1054                 pages_to_map = min_t(size_t, pages_to_map, max_pages);
1055         }
1056
1057         wr.page_shift = page_shift;
1058
1059         for (pages_mapped = 0;
1060              pages_mapped < pages_to_map && !err;
1061              pages_mapped += pages_iter, idx += pages_iter) {
1062                 npages = min_t(int, pages_iter, pages_to_map - pages_mapped);
1063                 size_to_map = npages * desc_size;
1064                 dma_sync_single_for_cpu(ddev, sg.addr, sg.length,
1065                                         DMA_TO_DEVICE);
1066                 mlx5_odp_populate_xlt(xlt, idx, npages, mr, flags);
1067                 dma_sync_single_for_device(ddev, sg.addr, sg.length,
1068                                            DMA_TO_DEVICE);
1069
1070                 sg.length = ALIGN(size_to_map, MLX5_UMR_MTT_ALIGNMENT);
1071
1072                 if (pages_mapped + pages_iter >= pages_to_map)
1073                         wr.wr.send_flags |= xlt_wr_final_send_flags(flags);
1074
1075                 wr.offset = idx * desc_size;
1076                 wr.xlt_size = sg.length;
1077
1078                 err = mlx5_ib_post_send_wait(dev, &wr);
1079         }
1080         sg.length = orig_sg_length;
1081         mlx5r_umr_unmap_free_xlt(dev, xlt, &sg);
1082         return err;
1083 }
1084
1085 /*
1086  * Send the DMA list to the HW for a normal MR using UMR.
1087  * Dmabuf MR is handled in a similar way, except that the MLX5_IB_UPD_XLT_ZAP
1088  * flag may be used.
1089  */
1090 int mlx5_ib_update_mr_pas(struct mlx5_ib_mr *mr, unsigned int flags)
1091 {
1092         struct mlx5_ib_dev *dev = mr_to_mdev(mr);
1093         struct device *ddev = &dev->mdev->pdev->dev;
1094         struct ib_block_iter biter;
1095         struct mlx5_mtt *cur_mtt;
1096         struct mlx5_umr_wr wr;
1097         size_t orig_sg_length;
1098         struct mlx5_mtt *mtt;
1099         size_t final_size;
1100         struct ib_sge sg;
1101         int err = 0;
1102
1103         if (WARN_ON(mr->umem->is_odp))
1104                 return -EINVAL;
1105
1106         mtt = mlx5_ib_create_xlt_wr(mr, &wr, &sg,
1107                                     ib_umem_num_dma_blocks(mr->umem,
1108                                                            1 << mr->page_shift),
1109                                     sizeof(*mtt), flags);
1110         if (!mtt)
1111                 return -ENOMEM;
1112         orig_sg_length = sg.length;
1113
1114         cur_mtt = mtt;
1115         rdma_for_each_block (mr->umem->sgt_append.sgt.sgl, &biter,
1116                              mr->umem->sgt_append.sgt.nents,
1117                              BIT(mr->page_shift)) {
1118                 if (cur_mtt == (void *)mtt + sg.length) {
1119                         dma_sync_single_for_device(ddev, sg.addr, sg.length,
1120                                                    DMA_TO_DEVICE);
1121                         err = mlx5_ib_post_send_wait(dev, &wr);
1122                         if (err)
1123                                 goto err;
1124                         dma_sync_single_for_cpu(ddev, sg.addr, sg.length,
1125                                                 DMA_TO_DEVICE);
1126                         wr.offset += sg.length;
1127                         cur_mtt = mtt;
1128                 }
1129
1130                 cur_mtt->ptag =
1131                         cpu_to_be64(rdma_block_iter_dma_address(&biter) |
1132                                     MLX5_IB_MTT_PRESENT);
1133
1134                 if (mr->umem->is_dmabuf && (flags & MLX5_IB_UPD_XLT_ZAP))
1135                         cur_mtt->ptag = 0;
1136
1137                 cur_mtt++;
1138         }
1139
1140         final_size = (void *)cur_mtt - (void *)mtt;
1141         sg.length = ALIGN(final_size, MLX5_UMR_MTT_ALIGNMENT);
1142         memset(cur_mtt, 0, sg.length - final_size);
1143         wr.wr.send_flags |= xlt_wr_final_send_flags(flags);
1144         wr.xlt_size = sg.length;
1145
1146         dma_sync_single_for_device(ddev, sg.addr, sg.length, DMA_TO_DEVICE);
1147         err = mlx5_ib_post_send_wait(dev, &wr);
1148
1149 err:
1150         sg.length = orig_sg_length;
1151         mlx5r_umr_unmap_free_xlt(dev, mtt, &sg);
1152         return err;
1153 }
1154
1155 /*
1156  * If ibmr is NULL it will be allocated by reg_create.
1157  * Else, the given ibmr will be used.
1158  */
1159 static struct mlx5_ib_mr *reg_create(struct ib_pd *pd, struct ib_umem *umem,
1160                                      u64 iova, int access_flags,
1161                                      unsigned int page_size, bool populate)
1162 {
1163         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1164         struct mlx5_ib_mr *mr;
1165         __be64 *pas;
1166         void *mkc;
1167         int inlen;
1168         u32 *in;
1169         int err;
1170         bool pg_cap = !!(MLX5_CAP_GEN(dev->mdev, pg));
1171
1172         if (!page_size)
1173                 return ERR_PTR(-EINVAL);
1174         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
1175         if (!mr)
1176                 return ERR_PTR(-ENOMEM);
1177
1178         mr->ibmr.pd = pd;
1179         mr->access_flags = access_flags;
1180         mr->page_shift = order_base_2(page_size);
1181
1182         inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
1183         if (populate)
1184                 inlen += sizeof(*pas) *
1185                          roundup(ib_umem_num_dma_blocks(umem, page_size), 2);
1186         in = kvzalloc(inlen, GFP_KERNEL);
1187         if (!in) {
1188                 err = -ENOMEM;
1189                 goto err_1;
1190         }
1191         pas = (__be64 *)MLX5_ADDR_OF(create_mkey_in, in, klm_pas_mtt);
1192         if (populate) {
1193                 if (WARN_ON(access_flags & IB_ACCESS_ON_DEMAND)) {
1194                         err = -EINVAL;
1195                         goto err_2;
1196                 }
1197                 mlx5_ib_populate_pas(umem, 1UL << mr->page_shift, pas,
1198                                      pg_cap ? MLX5_IB_MTT_PRESENT : 0);
1199         }
1200
1201         /* The pg_access bit allows setting the access flags
1202          * in the page list submitted with the command. */
1203         MLX5_SET(create_mkey_in, in, pg_access, !!(pg_cap));
1204
1205         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
1206         set_mkc_access_pd_addr_fields(mkc, access_flags, iova,
1207                                       populate ? pd : dev->umrc.pd);
1208         MLX5_SET(mkc, mkc, free, !populate);
1209         MLX5_SET(mkc, mkc, access_mode_1_0, MLX5_MKC_ACCESS_MODE_MTT);
1210         MLX5_SET(mkc, mkc, umr_en, 1);
1211
1212         MLX5_SET64(mkc, mkc, len, umem->length);
1213         MLX5_SET(mkc, mkc, bsf_octword_size, 0);
1214         MLX5_SET(mkc, mkc, translations_octword_size,
1215                  get_octo_len(iova, umem->length, mr->page_shift));
1216         MLX5_SET(mkc, mkc, log_page_size, mr->page_shift);
1217         if (populate) {
1218                 MLX5_SET(create_mkey_in, in, translations_octword_actual_size,
1219                          get_octo_len(iova, umem->length, mr->page_shift));
1220         }
1221
1222         err = mlx5_ib_create_mkey(dev, &mr->mmkey, in, inlen);
1223         if (err) {
1224                 mlx5_ib_warn(dev, "create mkey failed\n");
1225                 goto err_2;
1226         }
1227         mr->mmkey.type = MLX5_MKEY_MR;
1228         mr->umem = umem;
1229         set_mr_fields(dev, mr, umem->length, access_flags, iova);
1230         kvfree(in);
1231
1232         mlx5_ib_dbg(dev, "mkey = 0x%x\n", mr->mmkey.key);
1233
1234         return mr;
1235
1236 err_2:
1237         kvfree(in);
1238 err_1:
1239         kfree(mr);
1240         return ERR_PTR(err);
1241 }
1242
1243 static struct ib_mr *mlx5_ib_get_dm_mr(struct ib_pd *pd, u64 start_addr,
1244                                        u64 length, int acc, int mode)
1245 {
1246         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1247         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
1248         struct mlx5_ib_mr *mr;
1249         void *mkc;
1250         u32 *in;
1251         int err;
1252
1253         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
1254         if (!mr)
1255                 return ERR_PTR(-ENOMEM);
1256
1257         in = kzalloc(inlen, GFP_KERNEL);
1258         if (!in) {
1259                 err = -ENOMEM;
1260                 goto err_free;
1261         }
1262
1263         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
1264
1265         MLX5_SET(mkc, mkc, access_mode_1_0, mode & 0x3);
1266         MLX5_SET(mkc, mkc, access_mode_4_2, (mode >> 2) & 0x7);
1267         MLX5_SET64(mkc, mkc, len, length);
1268         set_mkc_access_pd_addr_fields(mkc, acc, start_addr, pd);
1269
1270         err = mlx5_ib_create_mkey(dev, &mr->mmkey, in, inlen);
1271         if (err)
1272                 goto err_in;
1273
1274         kfree(in);
1275
1276         set_mr_fields(dev, mr, length, acc, start_addr);
1277
1278         return &mr->ibmr;
1279
1280 err_in:
1281         kfree(in);
1282
1283 err_free:
1284         kfree(mr);
1285
1286         return ERR_PTR(err);
1287 }
1288
1289 int mlx5_ib_advise_mr(struct ib_pd *pd,
1290                       enum ib_uverbs_advise_mr_advice advice,
1291                       u32 flags,
1292                       struct ib_sge *sg_list,
1293                       u32 num_sge,
1294                       struct uverbs_attr_bundle *attrs)
1295 {
1296         if (advice != IB_UVERBS_ADVISE_MR_ADVICE_PREFETCH &&
1297             advice != IB_UVERBS_ADVISE_MR_ADVICE_PREFETCH_WRITE &&
1298             advice != IB_UVERBS_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT)
1299                 return -EOPNOTSUPP;
1300
1301         return mlx5_ib_advise_mr_prefetch(pd, advice, flags,
1302                                          sg_list, num_sge);
1303 }
1304
1305 struct ib_mr *mlx5_ib_reg_dm_mr(struct ib_pd *pd, struct ib_dm *dm,
1306                                 struct ib_dm_mr_attr *attr,
1307                                 struct uverbs_attr_bundle *attrs)
1308 {
1309         struct mlx5_ib_dm *mdm = to_mdm(dm);
1310         struct mlx5_core_dev *dev = to_mdev(dm->device)->mdev;
1311         u64 start_addr = mdm->dev_addr + attr->offset;
1312         int mode;
1313
1314         switch (mdm->type) {
1315         case MLX5_IB_UAPI_DM_TYPE_MEMIC:
1316                 if (attr->access_flags & ~MLX5_IB_DM_MEMIC_ALLOWED_ACCESS)
1317                         return ERR_PTR(-EINVAL);
1318
1319                 mode = MLX5_MKC_ACCESS_MODE_MEMIC;
1320                 start_addr -= pci_resource_start(dev->pdev, 0);
1321                 break;
1322         case MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM:
1323         case MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM:
1324                 if (attr->access_flags & ~MLX5_IB_DM_SW_ICM_ALLOWED_ACCESS)
1325                         return ERR_PTR(-EINVAL);
1326
1327                 mode = MLX5_MKC_ACCESS_MODE_SW_ICM;
1328                 break;
1329         default:
1330                 return ERR_PTR(-EINVAL);
1331         }
1332
1333         return mlx5_ib_get_dm_mr(pd, start_addr, attr->length,
1334                                  attr->access_flags, mode);
1335 }
1336
1337 static struct ib_mr *create_real_mr(struct ib_pd *pd, struct ib_umem *umem,
1338                                     u64 iova, int access_flags)
1339 {
1340         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1341         struct mlx5_ib_mr *mr = NULL;
1342         bool xlt_with_umr;
1343         int err;
1344
1345         xlt_with_umr = mlx5r_umr_can_load_pas(dev, umem->length);
1346         if (xlt_with_umr) {
1347                 mr = alloc_cacheable_mr(pd, umem, iova, access_flags);
1348         } else {
1349                 unsigned int page_size = mlx5_umem_find_best_pgsz(
1350                         umem, mkc, log_page_size, 0, iova);
1351
1352                 mutex_lock(&dev->slow_path_mutex);
1353                 mr = reg_create(pd, umem, iova, access_flags, page_size, true);
1354                 mutex_unlock(&dev->slow_path_mutex);
1355         }
1356         if (IS_ERR(mr)) {
1357                 ib_umem_release(umem);
1358                 return ERR_CAST(mr);
1359         }
1360
1361         mlx5_ib_dbg(dev, "mkey 0x%x\n", mr->mmkey.key);
1362
1363         atomic_add(ib_umem_num_pages(umem), &dev->mdev->priv.reg_pages);
1364
1365         if (xlt_with_umr) {
1366                 /*
1367                  * If the MR was created with reg_create then it will be
1368                  * configured properly but left disabled. It is safe to go ahead
1369                  * and configure it again via UMR while enabling it.
1370                  */
1371                 err = mlx5_ib_update_mr_pas(mr, MLX5_IB_UPD_XLT_ENABLE);
1372                 if (err) {
1373                         mlx5_ib_dereg_mr(&mr->ibmr, NULL);
1374                         return ERR_PTR(err);
1375                 }
1376         }
1377         return &mr->ibmr;
1378 }
1379
1380 static struct ib_mr *create_user_odp_mr(struct ib_pd *pd, u64 start, u64 length,
1381                                         u64 iova, int access_flags,
1382                                         struct ib_udata *udata)
1383 {
1384         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1385         struct ib_umem_odp *odp;
1386         struct mlx5_ib_mr *mr;
1387         int err;
1388
1389         if (!IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING))
1390                 return ERR_PTR(-EOPNOTSUPP);
1391
1392         err = mlx5r_odp_create_eq(dev, &dev->odp_pf_eq);
1393         if (err)
1394                 return ERR_PTR(err);
1395         if (!start && length == U64_MAX) {
1396                 if (iova != 0)
1397                         return ERR_PTR(-EINVAL);
1398                 if (!(dev->odp_caps.general_caps & IB_ODP_SUPPORT_IMPLICIT))
1399                         return ERR_PTR(-EINVAL);
1400
1401                 mr = mlx5_ib_alloc_implicit_mr(to_mpd(pd), access_flags);
1402                 if (IS_ERR(mr))
1403                         return ERR_CAST(mr);
1404                 return &mr->ibmr;
1405         }
1406
1407         /* ODP requires xlt update via umr to work. */
1408         if (!mlx5r_umr_can_load_pas(dev, length))
1409                 return ERR_PTR(-EINVAL);
1410
1411         odp = ib_umem_odp_get(&dev->ib_dev, start, length, access_flags,
1412                               &mlx5_mn_ops);
1413         if (IS_ERR(odp))
1414                 return ERR_CAST(odp);
1415
1416         mr = alloc_cacheable_mr(pd, &odp->umem, iova, access_flags);
1417         if (IS_ERR(mr)) {
1418                 ib_umem_release(&odp->umem);
1419                 return ERR_CAST(mr);
1420         }
1421         xa_init(&mr->implicit_children);
1422
1423         odp->private = mr;
1424         err = mlx5r_store_odp_mkey(dev, &mr->mmkey);
1425         if (err)
1426                 goto err_dereg_mr;
1427
1428         err = mlx5_ib_init_odp_mr(mr);
1429         if (err)
1430                 goto err_dereg_mr;
1431         return &mr->ibmr;
1432
1433 err_dereg_mr:
1434         mlx5_ib_dereg_mr(&mr->ibmr, NULL);
1435         return ERR_PTR(err);
1436 }
1437
1438 struct ib_mr *mlx5_ib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
1439                                   u64 iova, int access_flags,
1440                                   struct ib_udata *udata)
1441 {
1442         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1443         struct ib_umem *umem;
1444
1445         if (!IS_ENABLED(CONFIG_INFINIBAND_USER_MEM))
1446                 return ERR_PTR(-EOPNOTSUPP);
1447
1448         mlx5_ib_dbg(dev, "start 0x%llx, iova 0x%llx, length 0x%llx, access_flags 0x%x\n",
1449                     start, iova, length, access_flags);
1450
1451         if (access_flags & IB_ACCESS_ON_DEMAND)
1452                 return create_user_odp_mr(pd, start, length, iova, access_flags,
1453                                           udata);
1454         umem = ib_umem_get(&dev->ib_dev, start, length, access_flags);
1455         if (IS_ERR(umem))
1456                 return ERR_CAST(umem);
1457         return create_real_mr(pd, umem, iova, access_flags);
1458 }
1459
1460 static void mlx5_ib_dmabuf_invalidate_cb(struct dma_buf_attachment *attach)
1461 {
1462         struct ib_umem_dmabuf *umem_dmabuf = attach->importer_priv;
1463         struct mlx5_ib_mr *mr = umem_dmabuf->private;
1464
1465         dma_resv_assert_held(umem_dmabuf->attach->dmabuf->resv);
1466
1467         if (!umem_dmabuf->sgt)
1468                 return;
1469
1470         mlx5_ib_update_mr_pas(mr, MLX5_IB_UPD_XLT_ZAP);
1471         ib_umem_dmabuf_unmap_pages(umem_dmabuf);
1472 }
1473
1474 static struct dma_buf_attach_ops mlx5_ib_dmabuf_attach_ops = {
1475         .allow_peer2peer = 1,
1476         .move_notify = mlx5_ib_dmabuf_invalidate_cb,
1477 };
1478
1479 struct ib_mr *mlx5_ib_reg_user_mr_dmabuf(struct ib_pd *pd, u64 offset,
1480                                          u64 length, u64 virt_addr,
1481                                          int fd, int access_flags,
1482                                          struct ib_udata *udata)
1483 {
1484         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1485         struct mlx5_ib_mr *mr = NULL;
1486         struct ib_umem_dmabuf *umem_dmabuf;
1487         int err;
1488
1489         if (!IS_ENABLED(CONFIG_INFINIBAND_USER_MEM) ||
1490             !IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING))
1491                 return ERR_PTR(-EOPNOTSUPP);
1492
1493         mlx5_ib_dbg(dev,
1494                     "offset 0x%llx, virt_addr 0x%llx, length 0x%llx, fd %d, access_flags 0x%x\n",
1495                     offset, virt_addr, length, fd, access_flags);
1496
1497         /* dmabuf requires xlt update via umr to work. */
1498         if (!mlx5r_umr_can_load_pas(dev, length))
1499                 return ERR_PTR(-EINVAL);
1500
1501         umem_dmabuf = ib_umem_dmabuf_get(&dev->ib_dev, offset, length, fd,
1502                                          access_flags,
1503                                          &mlx5_ib_dmabuf_attach_ops);
1504         if (IS_ERR(umem_dmabuf)) {
1505                 mlx5_ib_dbg(dev, "umem_dmabuf get failed (%ld)\n",
1506                             PTR_ERR(umem_dmabuf));
1507                 return ERR_CAST(umem_dmabuf);
1508         }
1509
1510         mr = alloc_cacheable_mr(pd, &umem_dmabuf->umem, virt_addr,
1511                                 access_flags);
1512         if (IS_ERR(mr)) {
1513                 ib_umem_release(&umem_dmabuf->umem);
1514                 return ERR_CAST(mr);
1515         }
1516
1517         mlx5_ib_dbg(dev, "mkey 0x%x\n", mr->mmkey.key);
1518
1519         atomic_add(ib_umem_num_pages(mr->umem), &dev->mdev->priv.reg_pages);
1520         umem_dmabuf->private = mr;
1521         err = mlx5r_store_odp_mkey(dev, &mr->mmkey);
1522         if (err)
1523                 goto err_dereg_mr;
1524
1525         err = mlx5_ib_init_dmabuf_mr(mr);
1526         if (err)
1527                 goto err_dereg_mr;
1528         return &mr->ibmr;
1529
1530 err_dereg_mr:
1531         mlx5_ib_dereg_mr(&mr->ibmr, NULL);
1532         return ERR_PTR(err);
1533 }
1534
1535 /*
1536  * True if the change in access flags can be done via UMR, only some access
1537  * flags can be updated.
1538  */
1539 static bool can_use_umr_rereg_access(struct mlx5_ib_dev *dev,
1540                                      unsigned int current_access_flags,
1541                                      unsigned int target_access_flags)
1542 {
1543         unsigned int diffs = current_access_flags ^ target_access_flags;
1544
1545         if (diffs & ~(IB_ACCESS_LOCAL_WRITE | IB_ACCESS_REMOTE_WRITE |
1546                       IB_ACCESS_REMOTE_READ | IB_ACCESS_RELAXED_ORDERING))
1547                 return false;
1548         return mlx5r_umr_can_reconfig(dev, current_access_flags,
1549                                       target_access_flags);
1550 }
1551
1552 static bool can_use_umr_rereg_pas(struct mlx5_ib_mr *mr,
1553                                   struct ib_umem *new_umem,
1554                                   int new_access_flags, u64 iova,
1555                                   unsigned long *page_size)
1556 {
1557         struct mlx5_ib_dev *dev = to_mdev(mr->ibmr.device);
1558
1559         /* We only track the allocated sizes of MRs from the cache */
1560         if (!mr->cache_ent)
1561                 return false;
1562         if (!mlx5r_umr_can_load_pas(dev, new_umem->length))
1563                 return false;
1564
1565         *page_size =
1566                 mlx5_umem_find_best_pgsz(new_umem, mkc, log_page_size, 0, iova);
1567         if (WARN_ON(!*page_size))
1568                 return false;
1569         return (1ULL << mr->cache_ent->order) >=
1570                ib_umem_num_dma_blocks(new_umem, *page_size);
1571 }
1572
1573 static int umr_rereg_pas(struct mlx5_ib_mr *mr, struct ib_pd *pd,
1574                          int access_flags, int flags, struct ib_umem *new_umem,
1575                          u64 iova, unsigned long page_size)
1576 {
1577         struct mlx5_ib_dev *dev = to_mdev(mr->ibmr.device);
1578         int upd_flags = MLX5_IB_UPD_XLT_ADDR | MLX5_IB_UPD_XLT_ENABLE;
1579         struct ib_umem *old_umem = mr->umem;
1580         int err;
1581
1582         /*
1583          * To keep everything simple the MR is revoked before we start to mess
1584          * with it. This ensure the change is atomic relative to any use of the
1585          * MR.
1586          */
1587         err = mlx5r_umr_revoke_mr(mr);
1588         if (err)
1589                 return err;
1590
1591         if (flags & IB_MR_REREG_PD) {
1592                 mr->ibmr.pd = pd;
1593                 upd_flags |= MLX5_IB_UPD_XLT_PD;
1594         }
1595         if (flags & IB_MR_REREG_ACCESS) {
1596                 mr->access_flags = access_flags;
1597                 upd_flags |= MLX5_IB_UPD_XLT_ACCESS;
1598         }
1599
1600         mr->ibmr.length = new_umem->length;
1601         mr->ibmr.iova = iova;
1602         mr->ibmr.length = new_umem->length;
1603         mr->page_shift = order_base_2(page_size);
1604         mr->umem = new_umem;
1605         err = mlx5_ib_update_mr_pas(mr, upd_flags);
1606         if (err) {
1607                 /*
1608                  * The MR is revoked at this point so there is no issue to free
1609                  * new_umem.
1610                  */
1611                 mr->umem = old_umem;
1612                 return err;
1613         }
1614
1615         atomic_sub(ib_umem_num_pages(old_umem), &dev->mdev->priv.reg_pages);
1616         ib_umem_release(old_umem);
1617         atomic_add(ib_umem_num_pages(new_umem), &dev->mdev->priv.reg_pages);
1618         return 0;
1619 }
1620
1621 struct ib_mr *mlx5_ib_rereg_user_mr(struct ib_mr *ib_mr, int flags, u64 start,
1622                                     u64 length, u64 iova, int new_access_flags,
1623                                     struct ib_pd *new_pd,
1624                                     struct ib_udata *udata)
1625 {
1626         struct mlx5_ib_dev *dev = to_mdev(ib_mr->device);
1627         struct mlx5_ib_mr *mr = to_mmr(ib_mr);
1628         int err;
1629
1630         if (!IS_ENABLED(CONFIG_INFINIBAND_USER_MEM))
1631                 return ERR_PTR(-EOPNOTSUPP);
1632
1633         mlx5_ib_dbg(
1634                 dev,
1635                 "start 0x%llx, iova 0x%llx, length 0x%llx, access_flags 0x%x\n",
1636                 start, iova, length, new_access_flags);
1637
1638         if (flags & ~(IB_MR_REREG_TRANS | IB_MR_REREG_PD | IB_MR_REREG_ACCESS))
1639                 return ERR_PTR(-EOPNOTSUPP);
1640
1641         if (!(flags & IB_MR_REREG_ACCESS))
1642                 new_access_flags = mr->access_flags;
1643         if (!(flags & IB_MR_REREG_PD))
1644                 new_pd = ib_mr->pd;
1645
1646         if (!(flags & IB_MR_REREG_TRANS)) {
1647                 struct ib_umem *umem;
1648
1649                 /* Fast path for PD/access change */
1650                 if (can_use_umr_rereg_access(dev, mr->access_flags,
1651                                              new_access_flags)) {
1652                         err = mlx5r_umr_rereg_pd_access(mr, new_pd,
1653                                                         new_access_flags);
1654                         if (err)
1655                                 return ERR_PTR(err);
1656                         return NULL;
1657                 }
1658                 /* DM or ODP MR's don't have a normal umem so we can't re-use it */
1659                 if (!mr->umem || is_odp_mr(mr) || is_dmabuf_mr(mr))
1660                         goto recreate;
1661
1662                 /*
1663                  * Only one active MR can refer to a umem at one time, revoke
1664                  * the old MR before assigning the umem to the new one.
1665                  */
1666                 err = mlx5r_umr_revoke_mr(mr);
1667                 if (err)
1668                         return ERR_PTR(err);
1669                 umem = mr->umem;
1670                 mr->umem = NULL;
1671                 atomic_sub(ib_umem_num_pages(umem), &dev->mdev->priv.reg_pages);
1672
1673                 return create_real_mr(new_pd, umem, mr->ibmr.iova,
1674                                       new_access_flags);
1675         }
1676
1677         /*
1678          * DM doesn't have a PAS list so we can't re-use it, odp/dmabuf does
1679          * but the logic around releasing the umem is different
1680          */
1681         if (!mr->umem || is_odp_mr(mr) || is_dmabuf_mr(mr))
1682                 goto recreate;
1683
1684         if (!(new_access_flags & IB_ACCESS_ON_DEMAND) &&
1685             can_use_umr_rereg_access(dev, mr->access_flags, new_access_flags)) {
1686                 struct ib_umem *new_umem;
1687                 unsigned long page_size;
1688
1689                 new_umem = ib_umem_get(&dev->ib_dev, start, length,
1690                                        new_access_flags);
1691                 if (IS_ERR(new_umem))
1692                         return ERR_CAST(new_umem);
1693
1694                 /* Fast path for PAS change */
1695                 if (can_use_umr_rereg_pas(mr, new_umem, new_access_flags, iova,
1696                                           &page_size)) {
1697                         err = umr_rereg_pas(mr, new_pd, new_access_flags, flags,
1698                                             new_umem, iova, page_size);
1699                         if (err) {
1700                                 ib_umem_release(new_umem);
1701                                 return ERR_PTR(err);
1702                         }
1703                         return NULL;
1704                 }
1705                 return create_real_mr(new_pd, new_umem, iova, new_access_flags);
1706         }
1707
1708         /*
1709          * Everything else has no state we can preserve, just create a new MR
1710          * from scratch
1711          */
1712 recreate:
1713         return mlx5_ib_reg_user_mr(new_pd, start, length, iova,
1714                                    new_access_flags, udata);
1715 }
1716
1717 static int
1718 mlx5_alloc_priv_descs(struct ib_device *device,
1719                       struct mlx5_ib_mr *mr,
1720                       int ndescs,
1721                       int desc_size)
1722 {
1723         struct mlx5_ib_dev *dev = to_mdev(device);
1724         struct device *ddev = &dev->mdev->pdev->dev;
1725         int size = ndescs * desc_size;
1726         int add_size;
1727         int ret;
1728
1729         add_size = max_t(int, MLX5_UMR_ALIGN - ARCH_KMALLOC_MINALIGN, 0);
1730
1731         mr->descs_alloc = kzalloc(size + add_size, GFP_KERNEL);
1732         if (!mr->descs_alloc)
1733                 return -ENOMEM;
1734
1735         mr->descs = PTR_ALIGN(mr->descs_alloc, MLX5_UMR_ALIGN);
1736
1737         mr->desc_map = dma_map_single(ddev, mr->descs, size, DMA_TO_DEVICE);
1738         if (dma_mapping_error(ddev, mr->desc_map)) {
1739                 ret = -ENOMEM;
1740                 goto err;
1741         }
1742
1743         return 0;
1744 err:
1745         kfree(mr->descs_alloc);
1746
1747         return ret;
1748 }
1749
1750 static void
1751 mlx5_free_priv_descs(struct mlx5_ib_mr *mr)
1752 {
1753         if (!mr->umem && mr->descs) {
1754                 struct ib_device *device = mr->ibmr.device;
1755                 int size = mr->max_descs * mr->desc_size;
1756                 struct mlx5_ib_dev *dev = to_mdev(device);
1757
1758                 dma_unmap_single(&dev->mdev->pdev->dev, mr->desc_map, size,
1759                                  DMA_TO_DEVICE);
1760                 kfree(mr->descs_alloc);
1761                 mr->descs = NULL;
1762         }
1763 }
1764
1765 int mlx5_ib_dereg_mr(struct ib_mr *ibmr, struct ib_udata *udata)
1766 {
1767         struct mlx5_ib_mr *mr = to_mmr(ibmr);
1768         struct mlx5_ib_dev *dev = to_mdev(ibmr->device);
1769         int rc;
1770
1771         /*
1772          * Any async use of the mr must hold the refcount, once the refcount
1773          * goes to zero no other thread, such as ODP page faults, prefetch, any
1774          * UMR activity, etc can touch the mkey. Thus it is safe to destroy it.
1775          */
1776         if (IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING) &&
1777             refcount_read(&mr->mmkey.usecount) != 0 &&
1778             xa_erase(&mr_to_mdev(mr)->odp_mkeys, mlx5_base_mkey(mr->mmkey.key)))
1779                 mlx5r_deref_wait_odp_mkey(&mr->mmkey);
1780
1781         if (ibmr->type == IB_MR_TYPE_INTEGRITY) {
1782                 xa_cmpxchg(&dev->sig_mrs, mlx5_base_mkey(mr->mmkey.key),
1783                            mr->sig, NULL, GFP_KERNEL);
1784
1785                 if (mr->mtt_mr) {
1786                         rc = mlx5_ib_dereg_mr(&mr->mtt_mr->ibmr, NULL);
1787                         if (rc)
1788                                 return rc;
1789                         mr->mtt_mr = NULL;
1790                 }
1791                 if (mr->klm_mr) {
1792                         rc = mlx5_ib_dereg_mr(&mr->klm_mr->ibmr, NULL);
1793                         if (rc)
1794                                 return rc;
1795                         mr->klm_mr = NULL;
1796                 }
1797
1798                 if (mlx5_core_destroy_psv(dev->mdev,
1799                                           mr->sig->psv_memory.psv_idx))
1800                         mlx5_ib_warn(dev, "failed to destroy mem psv %d\n",
1801                                      mr->sig->psv_memory.psv_idx);
1802                 if (mlx5_core_destroy_psv(dev->mdev, mr->sig->psv_wire.psv_idx))
1803                         mlx5_ib_warn(dev, "failed to destroy wire psv %d\n",
1804                                      mr->sig->psv_wire.psv_idx);
1805                 kfree(mr->sig);
1806                 mr->sig = NULL;
1807         }
1808
1809         /* Stop DMA */
1810         if (mr->cache_ent) {
1811                 if (mlx5r_umr_revoke_mr(mr)) {
1812                         spin_lock_irq(&mr->cache_ent->lock);
1813                         mr->cache_ent->total_mrs--;
1814                         spin_unlock_irq(&mr->cache_ent->lock);
1815                         mr->cache_ent = NULL;
1816                 }
1817         }
1818         if (!mr->cache_ent) {
1819                 rc = destroy_mkey(to_mdev(mr->ibmr.device), mr);
1820                 if (rc)
1821                         return rc;
1822         }
1823
1824         if (mr->umem) {
1825                 bool is_odp = is_odp_mr(mr);
1826
1827                 if (!is_odp)
1828                         atomic_sub(ib_umem_num_pages(mr->umem),
1829                                    &dev->mdev->priv.reg_pages);
1830                 ib_umem_release(mr->umem);
1831                 if (is_odp)
1832                         mlx5_ib_free_odp_mr(mr);
1833         }
1834
1835         if (mr->cache_ent) {
1836                 mlx5_mr_cache_free(dev, mr);
1837         } else {
1838                 mlx5_free_priv_descs(mr);
1839                 kfree(mr);
1840         }
1841         return 0;
1842 }
1843
1844 static void mlx5_set_umr_free_mkey(struct ib_pd *pd, u32 *in, int ndescs,
1845                                    int access_mode, int page_shift)
1846 {
1847         void *mkc;
1848
1849         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
1850
1851         /* This is only used from the kernel, so setting the PD is OK. */
1852         set_mkc_access_pd_addr_fields(mkc, IB_ACCESS_RELAXED_ORDERING, 0, pd);
1853         MLX5_SET(mkc, mkc, free, 1);
1854         MLX5_SET(mkc, mkc, translations_octword_size, ndescs);
1855         MLX5_SET(mkc, mkc, access_mode_1_0, access_mode & 0x3);
1856         MLX5_SET(mkc, mkc, access_mode_4_2, (access_mode >> 2) & 0x7);
1857         MLX5_SET(mkc, mkc, umr_en, 1);
1858         MLX5_SET(mkc, mkc, log_page_size, page_shift);
1859 }
1860
1861 static int _mlx5_alloc_mkey_descs(struct ib_pd *pd, struct mlx5_ib_mr *mr,
1862                                   int ndescs, int desc_size, int page_shift,
1863                                   int access_mode, u32 *in, int inlen)
1864 {
1865         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1866         int err;
1867
1868         mr->access_mode = access_mode;
1869         mr->desc_size = desc_size;
1870         mr->max_descs = ndescs;
1871
1872         err = mlx5_alloc_priv_descs(pd->device, mr, ndescs, desc_size);
1873         if (err)
1874                 return err;
1875
1876         mlx5_set_umr_free_mkey(pd, in, ndescs, access_mode, page_shift);
1877
1878         err = mlx5_ib_create_mkey(dev, &mr->mmkey, in, inlen);
1879         if (err)
1880                 goto err_free_descs;
1881
1882         mr->mmkey.type = MLX5_MKEY_MR;
1883         mr->ibmr.lkey = mr->mmkey.key;
1884         mr->ibmr.rkey = mr->mmkey.key;
1885
1886         return 0;
1887
1888 err_free_descs:
1889         mlx5_free_priv_descs(mr);
1890         return err;
1891 }
1892
1893 static struct mlx5_ib_mr *mlx5_ib_alloc_pi_mr(struct ib_pd *pd,
1894                                 u32 max_num_sg, u32 max_num_meta_sg,
1895                                 int desc_size, int access_mode)
1896 {
1897         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
1898         int ndescs = ALIGN(max_num_sg + max_num_meta_sg, 4);
1899         int page_shift = 0;
1900         struct mlx5_ib_mr *mr;
1901         u32 *in;
1902         int err;
1903
1904         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
1905         if (!mr)
1906                 return ERR_PTR(-ENOMEM);
1907
1908         mr->ibmr.pd = pd;
1909         mr->ibmr.device = pd->device;
1910
1911         in = kzalloc(inlen, GFP_KERNEL);
1912         if (!in) {
1913                 err = -ENOMEM;
1914                 goto err_free;
1915         }
1916
1917         if (access_mode == MLX5_MKC_ACCESS_MODE_MTT)
1918                 page_shift = PAGE_SHIFT;
1919
1920         err = _mlx5_alloc_mkey_descs(pd, mr, ndescs, desc_size, page_shift,
1921                                      access_mode, in, inlen);
1922         if (err)
1923                 goto err_free_in;
1924
1925         mr->umem = NULL;
1926         kfree(in);
1927
1928         return mr;
1929
1930 err_free_in:
1931         kfree(in);
1932 err_free:
1933         kfree(mr);
1934         return ERR_PTR(err);
1935 }
1936
1937 static int mlx5_alloc_mem_reg_descs(struct ib_pd *pd, struct mlx5_ib_mr *mr,
1938                                     int ndescs, u32 *in, int inlen)
1939 {
1940         return _mlx5_alloc_mkey_descs(pd, mr, ndescs, sizeof(struct mlx5_mtt),
1941                                       PAGE_SHIFT, MLX5_MKC_ACCESS_MODE_MTT, in,
1942                                       inlen);
1943 }
1944
1945 static int mlx5_alloc_sg_gaps_descs(struct ib_pd *pd, struct mlx5_ib_mr *mr,
1946                                     int ndescs, u32 *in, int inlen)
1947 {
1948         return _mlx5_alloc_mkey_descs(pd, mr, ndescs, sizeof(struct mlx5_klm),
1949                                       0, MLX5_MKC_ACCESS_MODE_KLMS, in, inlen);
1950 }
1951
1952 static int mlx5_alloc_integrity_descs(struct ib_pd *pd, struct mlx5_ib_mr *mr,
1953                                       int max_num_sg, int max_num_meta_sg,
1954                                       u32 *in, int inlen)
1955 {
1956         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1957         u32 psv_index[2];
1958         void *mkc;
1959         int err;
1960
1961         mr->sig = kzalloc(sizeof(*mr->sig), GFP_KERNEL);
1962         if (!mr->sig)
1963                 return -ENOMEM;
1964
1965         /* create mem & wire PSVs */
1966         err = mlx5_core_create_psv(dev->mdev, to_mpd(pd)->pdn, 2, psv_index);
1967         if (err)
1968                 goto err_free_sig;
1969
1970         mr->sig->psv_memory.psv_idx = psv_index[0];
1971         mr->sig->psv_wire.psv_idx = psv_index[1];
1972
1973         mr->sig->sig_status_checked = true;
1974         mr->sig->sig_err_exists = false;
1975         /* Next UMR, Arm SIGERR */
1976         ++mr->sig->sigerr_count;
1977         mr->klm_mr = mlx5_ib_alloc_pi_mr(pd, max_num_sg, max_num_meta_sg,
1978                                          sizeof(struct mlx5_klm),
1979                                          MLX5_MKC_ACCESS_MODE_KLMS);
1980         if (IS_ERR(mr->klm_mr)) {
1981                 err = PTR_ERR(mr->klm_mr);
1982                 goto err_destroy_psv;
1983         }
1984         mr->mtt_mr = mlx5_ib_alloc_pi_mr(pd, max_num_sg, max_num_meta_sg,
1985                                          sizeof(struct mlx5_mtt),
1986                                          MLX5_MKC_ACCESS_MODE_MTT);
1987         if (IS_ERR(mr->mtt_mr)) {
1988                 err = PTR_ERR(mr->mtt_mr);
1989                 goto err_free_klm_mr;
1990         }
1991
1992         /* Set bsf descriptors for mkey */
1993         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
1994         MLX5_SET(mkc, mkc, bsf_en, 1);
1995         MLX5_SET(mkc, mkc, bsf_octword_size, MLX5_MKEY_BSF_OCTO_SIZE);
1996
1997         err = _mlx5_alloc_mkey_descs(pd, mr, 4, sizeof(struct mlx5_klm), 0,
1998                                      MLX5_MKC_ACCESS_MODE_KLMS, in, inlen);
1999         if (err)
2000                 goto err_free_mtt_mr;
2001
2002         err = xa_err(xa_store(&dev->sig_mrs, mlx5_base_mkey(mr->mmkey.key),
2003                               mr->sig, GFP_KERNEL));
2004         if (err)
2005                 goto err_free_descs;
2006         return 0;
2007
2008 err_free_descs:
2009         destroy_mkey(dev, mr);
2010         mlx5_free_priv_descs(mr);
2011 err_free_mtt_mr:
2012         mlx5_ib_dereg_mr(&mr->mtt_mr->ibmr, NULL);
2013         mr->mtt_mr = NULL;
2014 err_free_klm_mr:
2015         mlx5_ib_dereg_mr(&mr->klm_mr->ibmr, NULL);
2016         mr->klm_mr = NULL;
2017 err_destroy_psv:
2018         if (mlx5_core_destroy_psv(dev->mdev, mr->sig->psv_memory.psv_idx))
2019                 mlx5_ib_warn(dev, "failed to destroy mem psv %d\n",
2020                              mr->sig->psv_memory.psv_idx);
2021         if (mlx5_core_destroy_psv(dev->mdev, mr->sig->psv_wire.psv_idx))
2022                 mlx5_ib_warn(dev, "failed to destroy wire psv %d\n",
2023                              mr->sig->psv_wire.psv_idx);
2024 err_free_sig:
2025         kfree(mr->sig);
2026
2027         return err;
2028 }
2029
2030 static struct ib_mr *__mlx5_ib_alloc_mr(struct ib_pd *pd,
2031                                         enum ib_mr_type mr_type, u32 max_num_sg,
2032                                         u32 max_num_meta_sg)
2033 {
2034         struct mlx5_ib_dev *dev = to_mdev(pd->device);
2035         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
2036         int ndescs = ALIGN(max_num_sg, 4);
2037         struct mlx5_ib_mr *mr;
2038         u32 *in;
2039         int err;
2040
2041         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
2042         if (!mr)
2043                 return ERR_PTR(-ENOMEM);
2044
2045         in = kzalloc(inlen, GFP_KERNEL);
2046         if (!in) {
2047                 err = -ENOMEM;
2048                 goto err_free;
2049         }
2050
2051         mr->ibmr.device = pd->device;
2052         mr->umem = NULL;
2053
2054         switch (mr_type) {
2055         case IB_MR_TYPE_MEM_REG:
2056                 err = mlx5_alloc_mem_reg_descs(pd, mr, ndescs, in, inlen);
2057                 break;
2058         case IB_MR_TYPE_SG_GAPS:
2059                 err = mlx5_alloc_sg_gaps_descs(pd, mr, ndescs, in, inlen);
2060                 break;
2061         case IB_MR_TYPE_INTEGRITY:
2062                 err = mlx5_alloc_integrity_descs(pd, mr, max_num_sg,
2063                                                  max_num_meta_sg, in, inlen);
2064                 break;
2065         default:
2066                 mlx5_ib_warn(dev, "Invalid mr type %d\n", mr_type);
2067                 err = -EINVAL;
2068         }
2069
2070         if (err)
2071                 goto err_free_in;
2072
2073         kfree(in);
2074
2075         return &mr->ibmr;
2076
2077 err_free_in:
2078         kfree(in);
2079 err_free:
2080         kfree(mr);
2081         return ERR_PTR(err);
2082 }
2083
2084 struct ib_mr *mlx5_ib_alloc_mr(struct ib_pd *pd, enum ib_mr_type mr_type,
2085                                u32 max_num_sg)
2086 {
2087         return __mlx5_ib_alloc_mr(pd, mr_type, max_num_sg, 0);
2088 }
2089
2090 struct ib_mr *mlx5_ib_alloc_mr_integrity(struct ib_pd *pd,
2091                                          u32 max_num_sg, u32 max_num_meta_sg)
2092 {
2093         return __mlx5_ib_alloc_mr(pd, IB_MR_TYPE_INTEGRITY, max_num_sg,
2094                                   max_num_meta_sg);
2095 }
2096
2097 int mlx5_ib_alloc_mw(struct ib_mw *ibmw, struct ib_udata *udata)
2098 {
2099         struct mlx5_ib_dev *dev = to_mdev(ibmw->device);
2100         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
2101         struct mlx5_ib_mw *mw = to_mmw(ibmw);
2102         unsigned int ndescs;
2103         u32 *in = NULL;
2104         void *mkc;
2105         int err;
2106         struct mlx5_ib_alloc_mw req = {};
2107         struct {
2108                 __u32   comp_mask;
2109                 __u32   response_length;
2110         } resp = {};
2111
2112         err = ib_copy_from_udata(&req, udata, min(udata->inlen, sizeof(req)));
2113         if (err)
2114                 return err;
2115
2116         if (req.comp_mask || req.reserved1 || req.reserved2)
2117                 return -EOPNOTSUPP;
2118
2119         if (udata->inlen > sizeof(req) &&
2120             !ib_is_udata_cleared(udata, sizeof(req),
2121                                  udata->inlen - sizeof(req)))
2122                 return -EOPNOTSUPP;
2123
2124         ndescs = req.num_klms ? roundup(req.num_klms, 4) : roundup(1, 4);
2125
2126         in = kzalloc(inlen, GFP_KERNEL);
2127         if (!in) {
2128                 err = -ENOMEM;
2129                 goto free;
2130         }
2131
2132         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
2133
2134         MLX5_SET(mkc, mkc, free, 1);
2135         MLX5_SET(mkc, mkc, translations_octword_size, ndescs);
2136         MLX5_SET(mkc, mkc, pd, to_mpd(ibmw->pd)->pdn);
2137         MLX5_SET(mkc, mkc, umr_en, 1);
2138         MLX5_SET(mkc, mkc, lr, 1);
2139         MLX5_SET(mkc, mkc, access_mode_1_0, MLX5_MKC_ACCESS_MODE_KLMS);
2140         MLX5_SET(mkc, mkc, en_rinval, !!((ibmw->type == IB_MW_TYPE_2)));
2141         MLX5_SET(mkc, mkc, qpn, 0xffffff);
2142
2143         err = mlx5_ib_create_mkey(dev, &mw->mmkey, in, inlen);
2144         if (err)
2145                 goto free;
2146
2147         mw->mmkey.type = MLX5_MKEY_MW;
2148         ibmw->rkey = mw->mmkey.key;
2149         mw->mmkey.ndescs = ndescs;
2150
2151         resp.response_length =
2152                 min(offsetofend(typeof(resp), response_length), udata->outlen);
2153         if (resp.response_length) {
2154                 err = ib_copy_to_udata(udata, &resp, resp.response_length);
2155                 if (err)
2156                         goto free_mkey;
2157         }
2158
2159         if (IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING)) {
2160                 err = mlx5r_store_odp_mkey(dev, &mw->mmkey);
2161                 if (err)
2162                         goto free_mkey;
2163         }
2164
2165         kfree(in);
2166         return 0;
2167
2168 free_mkey:
2169         mlx5_core_destroy_mkey(dev->mdev, mw->mmkey.key);
2170 free:
2171         kfree(in);
2172         return err;
2173 }
2174
2175 int mlx5_ib_dealloc_mw(struct ib_mw *mw)
2176 {
2177         struct mlx5_ib_dev *dev = to_mdev(mw->device);
2178         struct mlx5_ib_mw *mmw = to_mmw(mw);
2179
2180         if (IS_ENABLED(CONFIG_INFINIBAND_ON_DEMAND_PAGING) &&
2181             xa_erase(&dev->odp_mkeys, mlx5_base_mkey(mmw->mmkey.key)))
2182                 /*
2183                  * pagefault_single_data_segment() may be accessing mmw
2184                  * if the user bound an ODP MR to this MW.
2185                  */
2186                 mlx5r_deref_wait_odp_mkey(&mmw->mmkey);
2187
2188         return mlx5_core_destroy_mkey(dev->mdev, mmw->mmkey.key);
2189 }
2190
2191 int mlx5_ib_check_mr_status(struct ib_mr *ibmr, u32 check_mask,
2192                             struct ib_mr_status *mr_status)
2193 {
2194         struct mlx5_ib_mr *mmr = to_mmr(ibmr);
2195         int ret = 0;
2196
2197         if (check_mask & ~IB_MR_CHECK_SIG_STATUS) {
2198                 pr_err("Invalid status check mask\n");
2199                 ret = -EINVAL;
2200                 goto done;
2201         }
2202
2203         mr_status->fail_status = 0;
2204         if (check_mask & IB_MR_CHECK_SIG_STATUS) {
2205                 if (!mmr->sig) {
2206                         ret = -EINVAL;
2207                         pr_err("signature status check requested on a non-signature enabled MR\n");
2208                         goto done;
2209                 }
2210
2211                 mmr->sig->sig_status_checked = true;
2212                 if (!mmr->sig->sig_err_exists)
2213                         goto done;
2214
2215                 if (ibmr->lkey == mmr->sig->err_item.key)
2216                         memcpy(&mr_status->sig_err, &mmr->sig->err_item,
2217                                sizeof(mr_status->sig_err));
2218                 else {
2219                         mr_status->sig_err.err_type = IB_SIG_BAD_GUARD;
2220                         mr_status->sig_err.sig_err_offset = 0;
2221                         mr_status->sig_err.key = mmr->sig->err_item.key;
2222                 }
2223
2224                 mmr->sig->sig_err_exists = false;
2225                 mr_status->fail_status |= IB_MR_CHECK_SIG_STATUS;
2226         }
2227
2228 done:
2229         return ret;
2230 }
2231
2232 static int
2233 mlx5_ib_map_pa_mr_sg_pi(struct ib_mr *ibmr, struct scatterlist *data_sg,
2234                         int data_sg_nents, unsigned int *data_sg_offset,
2235                         struct scatterlist *meta_sg, int meta_sg_nents,
2236                         unsigned int *meta_sg_offset)
2237 {
2238         struct mlx5_ib_mr *mr = to_mmr(ibmr);
2239         unsigned int sg_offset = 0;
2240         int n = 0;
2241
2242         mr->meta_length = 0;
2243         if (data_sg_nents == 1) {
2244                 n++;
2245                 mr->mmkey.ndescs = 1;
2246                 if (data_sg_offset)
2247                         sg_offset = *data_sg_offset;
2248                 mr->data_length = sg_dma_len(data_sg) - sg_offset;
2249                 mr->data_iova = sg_dma_address(data_sg) + sg_offset;
2250                 if (meta_sg_nents == 1) {
2251                         n++;
2252                         mr->meta_ndescs = 1;
2253                         if (meta_sg_offset)
2254                                 sg_offset = *meta_sg_offset;
2255                         else
2256                                 sg_offset = 0;
2257                         mr->meta_length = sg_dma_len(meta_sg) - sg_offset;
2258                         mr->pi_iova = sg_dma_address(meta_sg) + sg_offset;
2259                 }
2260                 ibmr->length = mr->data_length + mr->meta_length;
2261         }
2262
2263         return n;
2264 }
2265
2266 static int
2267 mlx5_ib_sg_to_klms(struct mlx5_ib_mr *mr,
2268                    struct scatterlist *sgl,
2269                    unsigned short sg_nents,
2270                    unsigned int *sg_offset_p,
2271                    struct scatterlist *meta_sgl,
2272                    unsigned short meta_sg_nents,
2273                    unsigned int *meta_sg_offset_p)
2274 {
2275         struct scatterlist *sg = sgl;
2276         struct mlx5_klm *klms = mr->descs;
2277         unsigned int sg_offset = sg_offset_p ? *sg_offset_p : 0;
2278         u32 lkey = mr->ibmr.pd->local_dma_lkey;
2279         int i, j = 0;
2280
2281         mr->ibmr.iova = sg_dma_address(sg) + sg_offset;
2282         mr->ibmr.length = 0;
2283
2284         for_each_sg(sgl, sg, sg_nents, i) {
2285                 if (unlikely(i >= mr->max_descs))
2286                         break;
2287                 klms[i].va = cpu_to_be64(sg_dma_address(sg) + sg_offset);
2288                 klms[i].bcount = cpu_to_be32(sg_dma_len(sg) - sg_offset);
2289                 klms[i].key = cpu_to_be32(lkey);
2290                 mr->ibmr.length += sg_dma_len(sg) - sg_offset;
2291
2292                 sg_offset = 0;
2293         }
2294
2295         if (sg_offset_p)
2296                 *sg_offset_p = sg_offset;
2297
2298         mr->mmkey.ndescs = i;
2299         mr->data_length = mr->ibmr.length;
2300
2301         if (meta_sg_nents) {
2302                 sg = meta_sgl;
2303                 sg_offset = meta_sg_offset_p ? *meta_sg_offset_p : 0;
2304                 for_each_sg(meta_sgl, sg, meta_sg_nents, j) {
2305                         if (unlikely(i + j >= mr->max_descs))
2306                                 break;
2307                         klms[i + j].va = cpu_to_be64(sg_dma_address(sg) +
2308                                                      sg_offset);
2309                         klms[i + j].bcount = cpu_to_be32(sg_dma_len(sg) -
2310                                                          sg_offset);
2311                         klms[i + j].key = cpu_to_be32(lkey);
2312                         mr->ibmr.length += sg_dma_len(sg) - sg_offset;
2313
2314                         sg_offset = 0;
2315                 }
2316                 if (meta_sg_offset_p)
2317                         *meta_sg_offset_p = sg_offset;
2318
2319                 mr->meta_ndescs = j;
2320                 mr->meta_length = mr->ibmr.length - mr->data_length;
2321         }
2322
2323         return i + j;
2324 }
2325
2326 static int mlx5_set_page(struct ib_mr *ibmr, u64 addr)
2327 {
2328         struct mlx5_ib_mr *mr = to_mmr(ibmr);
2329         __be64 *descs;
2330
2331         if (unlikely(mr->mmkey.ndescs == mr->max_descs))
2332                 return -ENOMEM;
2333
2334         descs = mr->descs;
2335         descs[mr->mmkey.ndescs++] = cpu_to_be64(addr | MLX5_EN_RD | MLX5_EN_WR);
2336
2337         return 0;
2338 }
2339
2340 static int mlx5_set_page_pi(struct ib_mr *ibmr, u64 addr)
2341 {
2342         struct mlx5_ib_mr *mr = to_mmr(ibmr);
2343         __be64 *descs;
2344
2345         if (unlikely(mr->mmkey.ndescs + mr->meta_ndescs == mr->max_descs))
2346                 return -ENOMEM;
2347
2348         descs = mr->descs;
2349         descs[mr->mmkey.ndescs + mr->meta_ndescs++] =
2350                 cpu_to_be64(addr | MLX5_EN_RD | MLX5_EN_WR);
2351
2352         return 0;
2353 }
2354
2355 static int
2356 mlx5_ib_map_mtt_mr_sg_pi(struct ib_mr *ibmr, struct scatterlist *data_sg,
2357                          int data_sg_nents, unsigned int *data_sg_offset,
2358                          struct scatterlist *meta_sg, int meta_sg_nents,
2359                          unsigned int *meta_sg_offset)
2360 {
2361         struct mlx5_ib_mr *mr = to_mmr(ibmr);
2362         struct mlx5_ib_mr *pi_mr = mr->mtt_mr;
2363         int n;
2364
2365         pi_mr->mmkey.ndescs = 0;
2366         pi_mr->meta_ndescs = 0;
2367         pi_mr->meta_length = 0;
2368
2369         ib_dma_sync_single_for_cpu(ibmr->device, pi_mr->desc_map,
2370                                    pi_mr->desc_size * pi_mr->max_descs,
2371                                    DMA_TO_DEVICE);
2372
2373         pi_mr->ibmr.page_size = ibmr->page_size;
2374         n = ib_sg_to_pages(&pi_mr->ibmr, data_sg, data_sg_nents, data_sg_offset,
2375                            mlx5_set_page);
2376         if (n != data_sg_nents)
2377                 return n;
2378
2379         pi_mr->data_iova = pi_mr->ibmr.iova;
2380         pi_mr->data_length = pi_mr->ibmr.length;
2381         pi_mr->ibmr.length = pi_mr->data_length;
2382         ibmr->length = pi_mr->data_length;
2383
2384         if (meta_sg_nents) {
2385                 u64 page_mask = ~((u64)ibmr->page_size - 1);
2386                 u64 iova = pi_mr->data_iova;
2387
2388                 n += ib_sg_to_pages(&pi_mr->ibmr, meta_sg, meta_sg_nents,
2389                                     meta_sg_offset, mlx5_set_page_pi);
2390
2391                 pi_mr->meta_length = pi_mr->ibmr.length;
2392                 /*
2393                  * PI address for the HW is the offset of the metadata address
2394                  * relative to the first data page address.
2395                  * It equals to first data page address + size of data pages +
2396                  * metadata offset at the first metadata page
2397                  */
2398                 pi_mr->pi_iova = (iova & page_mask) +
2399                                  pi_mr->mmkey.ndescs * ibmr->page_size +
2400                                  (pi_mr->ibmr.iova & ~page_mask);
2401                 /*
2402                  * In order to use one MTT MR for data and metadata, we register
2403                  * also the gaps between the end of the data and the start of
2404                  * the metadata (the sig MR will verify that the HW will access
2405                  * to right addresses). This mapping is safe because we use
2406                  * internal mkey for the registration.
2407                  */
2408                 pi_mr->ibmr.length = pi_mr->pi_iova + pi_mr->meta_length - iova;
2409                 pi_mr->ibmr.iova = iova;
2410                 ibmr->length += pi_mr->meta_length;
2411         }
2412
2413         ib_dma_sync_single_for_device(ibmr->device, pi_mr->desc_map,
2414                                       pi_mr->desc_size * pi_mr->max_descs,
2415                                       DMA_TO_DEVICE);
2416
2417         return n;
2418 }
2419
2420 static int
2421 mlx5_ib_map_klm_mr_sg_pi(struct ib_mr *ibmr, struct scatterlist *data_sg,
2422                          int data_sg_nents, unsigned int *data_sg_offset,
2423                          struct scatterlist *meta_sg, int meta_sg_nents,
2424                          unsigned int *meta_sg_offset)
2425 {
2426         struct mlx5_ib_mr *mr = to_mmr(ibmr);
2427         struct mlx5_ib_mr *pi_mr = mr->klm_mr;
2428         int n;
2429
2430         pi_mr->mmkey.ndescs = 0;
2431         pi_mr->meta_ndescs = 0;
2432         pi_mr->meta_length = 0;
2433
2434         ib_dma_sync_single_for_cpu(ibmr->device, pi_mr->desc_map,
2435                                    pi_mr->desc_size * pi_mr->max_descs,
2436                                    DMA_TO_DEVICE);
2437
2438         n = mlx5_ib_sg_to_klms(pi_mr, data_sg, data_sg_nents, data_sg_offset,
2439                                meta_sg, meta_sg_nents, meta_sg_offset);
2440
2441         ib_dma_sync_single_for_device(ibmr->device, pi_mr->desc_map,
2442                                       pi_mr->desc_size * pi_mr->max_descs,
2443                                       DMA_TO_DEVICE);
2444
2445         /* This is zero-based memory region */
2446         pi_mr->data_iova = 0;
2447         pi_mr->ibmr.iova = 0;
2448         pi_mr->pi_iova = pi_mr->data_length;
2449         ibmr->length = pi_mr->ibmr.length;
2450
2451         return n;
2452 }
2453
2454 int mlx5_ib_map_mr_sg_pi(struct ib_mr *ibmr, struct scatterlist *data_sg,
2455                          int data_sg_nents, unsigned int *data_sg_offset,
2456                          struct scatterlist *meta_sg, int meta_sg_nents,
2457                          unsigned int *meta_sg_offset)
2458 {
2459         struct mlx5_ib_mr *mr = to_mmr(ibmr);
2460         struct mlx5_ib_mr *pi_mr = NULL;
2461         int n;
2462
2463         WARN_ON(ibmr->type != IB_MR_TYPE_INTEGRITY);
2464
2465         mr->mmkey.ndescs = 0;
2466         mr->data_length = 0;
2467         mr->data_iova = 0;
2468         mr->meta_ndescs = 0;
2469         mr->pi_iova = 0;
2470         /*
2471          * As a performance optimization, if possible, there is no need to
2472          * perform UMR operation to register the data/metadata buffers.
2473          * First try to map the sg lists to PA descriptors with local_dma_lkey.
2474          * Fallback to UMR only in case of a failure.
2475          */
2476         n = mlx5_ib_map_pa_mr_sg_pi(ibmr, data_sg, data_sg_nents,
2477                                     data_sg_offset, meta_sg, meta_sg_nents,
2478                                     meta_sg_offset);
2479         if (n == data_sg_nents + meta_sg_nents)
2480                 goto out;
2481         /*
2482          * As a performance optimization, if possible, there is no need to map
2483          * the sg lists to KLM descriptors. First try to map the sg lists to MTT
2484          * descriptors and fallback to KLM only in case of a failure.
2485          * It's more efficient for the HW to work with MTT descriptors
2486          * (especially in high load).
2487          * Use KLM (indirect access) only if it's mandatory.
2488          */
2489         pi_mr = mr->mtt_mr;
2490         n = mlx5_ib_map_mtt_mr_sg_pi(ibmr, data_sg, data_sg_nents,
2491                                      data_sg_offset, meta_sg, meta_sg_nents,
2492                                      meta_sg_offset);
2493         if (n == data_sg_nents + meta_sg_nents)
2494                 goto out;
2495
2496         pi_mr = mr->klm_mr;
2497         n = mlx5_ib_map_klm_mr_sg_pi(ibmr, data_sg, data_sg_nents,
2498                                      data_sg_offset, meta_sg, meta_sg_nents,
2499                                      meta_sg_offset);
2500         if (unlikely(n != data_sg_nents + meta_sg_nents))
2501                 return -ENOMEM;
2502
2503 out:
2504         /* This is zero-based memory region */
2505         ibmr->iova = 0;
2506         mr->pi_mr = pi_mr;
2507         if (pi_mr)
2508                 ibmr->sig_attrs->meta_length = pi_mr->meta_length;
2509         else
2510                 ibmr->sig_attrs->meta_length = mr->meta_length;
2511
2512         return 0;
2513 }
2514
2515 int mlx5_ib_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,
2516                       unsigned int *sg_offset)
2517 {
2518         struct mlx5_ib_mr *mr = to_mmr(ibmr);
2519         int n;
2520
2521         mr->mmkey.ndescs = 0;
2522
2523         ib_dma_sync_single_for_cpu(ibmr->device, mr->desc_map,
2524                                    mr->desc_size * mr->max_descs,
2525                                    DMA_TO_DEVICE);
2526
2527         if (mr->access_mode == MLX5_MKC_ACCESS_MODE_KLMS)
2528                 n = mlx5_ib_sg_to_klms(mr, sg, sg_nents, sg_offset, NULL, 0,
2529                                        NULL);
2530         else
2531                 n = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset,
2532                                 mlx5_set_page);
2533
2534         ib_dma_sync_single_for_device(ibmr->device, mr->desc_map,
2535                                       mr->desc_size * mr->max_descs,
2536                                       DMA_TO_DEVICE);
2537
2538         return n;
2539 }