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