drivers/infiniband/hw/mlx5/mr.c

   1 /*
   2  * Copyright (c) 2013-2015, Mellanox Technologies. All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33
  34 #include <linux/kref.h>
  35 #include <linux/random.h>
  36 #include <linux/debugfs.h>
  37 #include <linux/export.h>
  38 #include <linux/delay.h>
  39 #include <rdma/ib_umem.h>
  40 #include <rdma/ib_umem_odp.h>
  41 #include <rdma/ib_verbs.h>
  42 #include "mlx5_ib.h"
  43
  44 enum {
  45         MAX_PENDING_REG_MR = 8,
  46 };
  47
  48 #define MLX5_UMR_ALIGN 2048
  49
  50 static int clean_mr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr);
  51 static int dereg_mr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr);
  52 static int mr_cache_max_order(struct mlx5_ib_dev *dev);
  53 static int unreg_umr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr);
  54
  55 static int destroy_mkey(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
  56 {
  57         int err = mlx5_core_destroy_mkey(dev->mdev, &mr->mmkey);
  58
  59 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
  60         /* Wait until all page fault handlers using the mr complete. */
  61         synchronize_srcu(&dev->mr_srcu);
  62 #endif
  63
  64         return err;
  65 }
  66
  67 static int order2idx(struct mlx5_ib_dev *dev, int order)
  68 {
  69         struct mlx5_mr_cache *cache = &dev->cache;
  70
  71         if (order < cache->ent[0].order)
  72                 return 0;
  73         else
  74                 return order - cache->ent[0].order;
  75 }
  76
  77 static bool use_umr_mtt_update(struct mlx5_ib_mr *mr, u64 start, u64 length)
  78 {
  79         return ((u64)1 << mr->order) * MLX5_ADAPTER_PAGE_SIZE >=
  80                 length + (start & (MLX5_ADAPTER_PAGE_SIZE - 1));
  81 }
  82
  83 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
  84 static void update_odp_mr(struct mlx5_ib_mr *mr)
  85 {
  86         if (mr->umem->odp_data) {
  87                 /*
  88                  * This barrier prevents the compiler from moving the
  89                  * setting of umem->odp_data->private to point to our
  90                  * MR, before reg_umr finished, to ensure that the MR
  91                  * initialization have finished before starting to
  92                  * handle invalidations.
  93                  */
  94                 smp_wmb();
  95                 mr->umem->odp_data->private = mr;
  96                 /*
  97                  * Make sure we will see the new
  98                  * umem->odp_data->private value in the invalidation
  99                  * routines, before we can get page faults on the
 100                  * MR. Page faults can happen once we put the MR in
 101                  * the tree, below this line. Without the barrier,
 102                  * there can be a fault handling and an invalidation
 103                  * before umem->odp_data->private == mr is visible to
 104                  * the invalidation handler.
 105                  */
 106                 smp_wmb();
 107         }
 108 }
 109 #endif
 110
 111 static void reg_mr_callback(int status, void *context)
 112 {
 113         struct mlx5_ib_mr *mr = context;
 114         struct mlx5_ib_dev *dev = mr->dev;
 115         struct mlx5_mr_cache *cache = &dev->cache;
 116         int c = order2idx(dev, mr->order);
 117         struct mlx5_cache_ent *ent = &cache->ent[c];
 118         u8 key;
 119         unsigned long flags;
 120         struct mlx5_mkey_table *table = &dev->mdev->priv.mkey_table;
 121         int err;
 122
 123         spin_lock_irqsave(&ent->lock, flags);
 124         ent->pending--;
 125         spin_unlock_irqrestore(&ent->lock, flags);
 126         if (status) {
 127                 mlx5_ib_warn(dev, "async reg mr failed. status %d\n", status);
 128                 kfree(mr);
 129                 dev->fill_delay = 1;
 130                 mod_timer(&dev->delay_timer, jiffies + HZ);
 131                 return;
 132         }
 133
 134         mr->mmkey.type = MLX5_MKEY_MR;
 135         spin_lock_irqsave(&dev->mdev->priv.mkey_lock, flags);
 136         key = dev->mdev->priv.mkey_key++;
 137         spin_unlock_irqrestore(&dev->mdev->priv.mkey_lock, flags);
 138         mr->mmkey.key = mlx5_idx_to_mkey(MLX5_GET(create_mkey_out, mr->out, mkey_index)) | key;
 139
 140         cache->last_add = jiffies;
 141
 142         spin_lock_irqsave(&ent->lock, flags);
 143         list_add_tail(&mr->list, &ent->head);
 144         ent->cur++;
 145         ent->size++;
 146         spin_unlock_irqrestore(&ent->lock, flags);
 147
 148         write_lock_irqsave(&table->lock, flags);
 149         err = radix_tree_insert(&table->tree, mlx5_base_mkey(mr->mmkey.key),
 150                                 &mr->mmkey);
 151         if (err)
 152                 pr_err("Error inserting to mkey tree. 0x%x\n", -err);
 153         write_unlock_irqrestore(&table->lock, flags);
 154
 155         if (!completion_done(&ent->compl))
 156                 complete(&ent->compl);
 157 }
 158
 159 static int add_keys(struct mlx5_ib_dev *dev, int c, int num)
 160 {
 161         struct mlx5_mr_cache *cache = &dev->cache;
 162         struct mlx5_cache_ent *ent = &cache->ent[c];
 163         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
 164         struct mlx5_ib_mr *mr;
 165         void *mkc;
 166         u32 *in;
 167         int err = 0;
 168         int i;
 169
 170         in = kzalloc(inlen, GFP_KERNEL);
 171         if (!in)
 172                 return -ENOMEM;
 173
 174         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
 175         for (i = 0; i < num; i++) {
 176                 if (ent->pending >= MAX_PENDING_REG_MR) {
 177                         err = -EAGAIN;
 178                         break;
 179                 }
 180
 181                 mr = kzalloc(sizeof(*mr), GFP_KERNEL);
 182                 if (!mr) {
 183                         err = -ENOMEM;
 184                         break;
 185                 }
 186                 mr->order = ent->order;
 187                 mr->allocated_from_cache = 1;
 188                 mr->dev = dev;
 189
 190                 MLX5_SET(mkc, mkc, free, 1);
 191                 MLX5_SET(mkc, mkc, umr_en, 1);
 192                 MLX5_SET(mkc, mkc, access_mode, ent->access_mode);
 193
 194                 MLX5_SET(mkc, mkc, qpn, 0xffffff);
 195                 MLX5_SET(mkc, mkc, translations_octword_size, ent->xlt);
 196                 MLX5_SET(mkc, mkc, log_page_size, ent->page);
 197
 198                 spin_lock_irq(&ent->lock);
 199                 ent->pending++;
 200                 spin_unlock_irq(&ent->lock);
 201                 err = mlx5_core_create_mkey_cb(dev->mdev, &mr->mmkey,
 202                                                in, inlen,
 203                                                mr->out, sizeof(mr->out),
 204                                                reg_mr_callback, mr);
 205                 if (err) {
 206                         spin_lock_irq(&ent->lock);
 207                         ent->pending--;
 208                         spin_unlock_irq(&ent->lock);
 209                         mlx5_ib_warn(dev, "create mkey failed %d\n", err);
 210                         kfree(mr);
 211                         break;
 212                 }
 213         }
 214
 215         kfree(in);
 216         return err;
 217 }
 218
 219 static void remove_keys(struct mlx5_ib_dev *dev, int c, int num)
 220 {
 221         struct mlx5_mr_cache *cache = &dev->cache;
 222         struct mlx5_cache_ent *ent = &cache->ent[c];
 223         struct mlx5_ib_mr *mr;
 224         int err;
 225         int i;
 226
 227         for (i = 0; i < num; i++) {
 228                 spin_lock_irq(&ent->lock);
 229                 if (list_empty(&ent->head)) {
 230                         spin_unlock_irq(&ent->lock);
 231                         return;
 232                 }
 233                 mr = list_first_entry(&ent->head, struct mlx5_ib_mr, list);
 234                 list_del(&mr->list);
 235                 ent->cur--;
 236                 ent->size--;
 237                 spin_unlock_irq(&ent->lock);
 238                 err = destroy_mkey(dev, mr);
 239                 if (err)
 240                         mlx5_ib_warn(dev, "failed destroy mkey\n");
 241                 else
 242                         kfree(mr);
 243         }
 244 }
 245
 246 static ssize_t size_write(struct file *filp, const char __user *buf,
 247                           size_t count, loff_t *pos)
 248 {
 249         struct mlx5_cache_ent *ent = filp->private_data;
 250         struct mlx5_ib_dev *dev = ent->dev;
 251         char lbuf[20];
 252         u32 var;
 253         int err;
 254         int c;
 255
 256         if (copy_from_user(lbuf, buf, sizeof(lbuf)))
 257                 return -EFAULT;
 258
 259         c = order2idx(dev, ent->order);
 260         lbuf[sizeof(lbuf) - 1] = 0;
 261
 262         if (sscanf(lbuf, "%u", &var) != 1)
 263                 return -EINVAL;
 264
 265         if (var < ent->limit)
 266                 return -EINVAL;
 267
 268         if (var > ent->size) {
 269                 do {
 270                         err = add_keys(dev, c, var - ent->size);
 271                         if (err && err != -EAGAIN)
 272                                 return err;
 273
 274                         usleep_range(3000, 5000);
 275                 } while (err);
 276         } else if (var < ent->size) {
 277                 remove_keys(dev, c, ent->size - var);
 278         }
 279
 280         return count;
 281 }
 282
 283 static ssize_t size_read(struct file *filp, char __user *buf, size_t count,
 284                          loff_t *pos)
 285 {
 286         struct mlx5_cache_ent *ent = filp->private_data;
 287         char lbuf[20];
 288         int err;
 289
 290         if (*pos)
 291                 return 0;
 292
 293         err = snprintf(lbuf, sizeof(lbuf), "%d\n", ent->size);
 294         if (err < 0)
 295                 return err;
 296
 297         if (copy_to_user(buf, lbuf, err))
 298                 return -EFAULT;
 299
 300         *pos += err;
 301
 302         return err;
 303 }
 304
 305 static const struct file_operations size_fops = {
 306         .owner  = THIS_MODULE,
 307         .open   = simple_open,
 308         .write  = size_write,
 309         .read   = size_read,
 310 };
 311
 312 static ssize_t limit_write(struct file *filp, const char __user *buf,
 313                            size_t count, loff_t *pos)
 314 {
 315         struct mlx5_cache_ent *ent = filp->private_data;
 316         struct mlx5_ib_dev *dev = ent->dev;
 317         char lbuf[20];
 318         u32 var;
 319         int err;
 320         int c;
 321
 322         if (copy_from_user(lbuf, buf, sizeof(lbuf)))
 323                 return -EFAULT;
 324
 325         c = order2idx(dev, ent->order);
 326         lbuf[sizeof(lbuf) - 1] = 0;
 327
 328         if (sscanf(lbuf, "%u", &var) != 1)
 329                 return -EINVAL;
 330
 331         if (var > ent->size)
 332                 return -EINVAL;
 333
 334         ent->limit = var;
 335
 336         if (ent->cur < ent->limit) {
 337                 err = add_keys(dev, c, 2 * ent->limit - ent->cur);
 338                 if (err)
 339                         return err;
 340         }
 341
 342         return count;
 343 }
 344
 345 static ssize_t limit_read(struct file *filp, char __user *buf, size_t count,
 346                           loff_t *pos)
 347 {
 348         struct mlx5_cache_ent *ent = filp->private_data;
 349         char lbuf[20];
 350         int err;
 351
 352         if (*pos)
 353                 return 0;
 354
 355         err = snprintf(lbuf, sizeof(lbuf), "%d\n", ent->limit);
 356         if (err < 0)
 357                 return err;
 358
 359         if (copy_to_user(buf, lbuf, err))
 360                 return -EFAULT;
 361
 362         *pos += err;
 363
 364         return err;
 365 }
 366
 367 static const struct file_operations limit_fops = {
 368         .owner  = THIS_MODULE,
 369         .open   = simple_open,
 370         .write  = limit_write,
 371         .read   = limit_read,
 372 };
 373
 374 static int someone_adding(struct mlx5_mr_cache *cache)
 375 {
 376         int i;
 377
 378         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++) {
 379                 if (cache->ent[i].cur < cache->ent[i].limit)
 380                         return 1;
 381         }
 382
 383         return 0;
 384 }
 385
 386 static void __cache_work_func(struct mlx5_cache_ent *ent)
 387 {
 388         struct mlx5_ib_dev *dev = ent->dev;
 389         struct mlx5_mr_cache *cache = &dev->cache;
 390         int i = order2idx(dev, ent->order);
 391         int err;
 392
 393         if (cache->stopped)
 394                 return;
 395
 396         ent = &dev->cache.ent[i];
 397         if (ent->cur < 2 * ent->limit && !dev->fill_delay) {
 398                 err = add_keys(dev, i, 1);
 399                 if (ent->cur < 2 * ent->limit) {
 400                         if (err == -EAGAIN) {
 401                                 mlx5_ib_dbg(dev, "returned eagain, order %d\n",
 402                                             i + 2);
 403                                 queue_delayed_work(cache->wq, &ent->dwork,
 404                                                    msecs_to_jiffies(3));
 405                         } else if (err) {
 406                                 mlx5_ib_warn(dev, "command failed order %d, err %d\n",
 407                                              i + 2, err);
 408                                 queue_delayed_work(cache->wq, &ent->dwork,
 409                                                    msecs_to_jiffies(1000));
 410                         } else {
 411                                 queue_work(cache->wq, &ent->work);
 412                         }
 413                 }
 414         } else if (ent->cur > 2 * ent->limit) {
 415                 /*
 416                  * The remove_keys() logic is performed as garbage collection
 417                  * task. Such task is intended to be run when no other active
 418                  * processes are running.
 419                  *
 420                  * The need_resched() will return TRUE if there are user tasks
 421                  * to be activated in near future.
 422                  *
 423                  * In such case, we don't execute remove_keys() and postpone
 424                  * the garbage collection work to try to run in next cycle,
 425                  * in order to free CPU resources to other tasks.
 426                  */
 427                 if (!need_resched() && !someone_adding(cache) &&
 428                     time_after(jiffies, cache->last_add + 300 * HZ)) {
 429                         remove_keys(dev, i, 1);
 430                         if (ent->cur > ent->limit)
 431                                 queue_work(cache->wq, &ent->work);
 432                 } else {
 433                         queue_delayed_work(cache->wq, &ent->dwork, 300 * HZ);
 434                 }
 435         }
 436 }
 437
 438 static void delayed_cache_work_func(struct work_struct *work)
 439 {
 440         struct mlx5_cache_ent *ent;
 441
 442         ent = container_of(work, struct mlx5_cache_ent, dwork.work);
 443         __cache_work_func(ent);
 444 }
 445
 446 static void cache_work_func(struct work_struct *work)
 447 {
 448         struct mlx5_cache_ent *ent;
 449
 450         ent = container_of(work, struct mlx5_cache_ent, work);
 451         __cache_work_func(ent);
 452 }
 453
 454 struct mlx5_ib_mr *mlx5_mr_cache_alloc(struct mlx5_ib_dev *dev, int entry)
 455 {
 456         struct mlx5_mr_cache *cache = &dev->cache;
 457         struct mlx5_cache_ent *ent;
 458         struct mlx5_ib_mr *mr;
 459         int err;
 460
 461         if (entry < 0 || entry >= MAX_MR_CACHE_ENTRIES) {
 462                 mlx5_ib_err(dev, "cache entry %d is out of range\n", entry);
 463                 return ERR_PTR(-EINVAL);
 464         }
 465
 466         ent = &cache->ent[entry];
 467         while (1) {
 468                 spin_lock_irq(&ent->lock);
 469                 if (list_empty(&ent->head)) {
 470                         spin_unlock_irq(&ent->lock);
 471
 472                         err = add_keys(dev, entry, 1);
 473                         if (err && err != -EAGAIN)
 474                                 return ERR_PTR(err);
 475
 476                         wait_for_completion(&ent->compl);
 477                 } else {
 478                         mr = list_first_entry(&ent->head, struct mlx5_ib_mr,
 479                                               list);
 480                         list_del(&mr->list);
 481                         ent->cur--;
 482                         spin_unlock_irq(&ent->lock);
 483                         if (ent->cur < ent->limit)
 484                                 queue_work(cache->wq, &ent->work);
 485                         return mr;
 486                 }
 487         }
 488 }
 489
 490 static struct mlx5_ib_mr *alloc_cached_mr(struct mlx5_ib_dev *dev, int order)
 491 {
 492         struct mlx5_mr_cache *cache = &dev->cache;
 493         struct mlx5_ib_mr *mr = NULL;
 494         struct mlx5_cache_ent *ent;
 495         int last_umr_cache_entry;
 496         int c;
 497         int i;
 498
 499         c = order2idx(dev, order);
 500         last_umr_cache_entry = order2idx(dev, mr_cache_max_order(dev));
 501         if (c < 0 || c > last_umr_cache_entry) {
 502                 mlx5_ib_warn(dev, "order %d, cache index %d\n", order, c);
 503                 return NULL;
 504         }
 505
 506         for (i = c; i <= last_umr_cache_entry; i++) {
 507                 ent = &cache->ent[i];
 508
 509                 mlx5_ib_dbg(dev, "order %d, cache index %d\n", ent->order, i);
 510
 511                 spin_lock_irq(&ent->lock);
 512                 if (!list_empty(&ent->head)) {
 513                         mr = list_first_entry(&ent->head, struct mlx5_ib_mr,
 514                                               list);
 515                         list_del(&mr->list);
 516                         ent->cur--;
 517                         spin_unlock_irq(&ent->lock);
 518                         if (ent->cur < ent->limit)
 519                                 queue_work(cache->wq, &ent->work);
 520                         break;
 521                 }
 522                 spin_unlock_irq(&ent->lock);
 523
 524                 queue_work(cache->wq, &ent->work);
 525         }
 526
 527         if (!mr)
 528                 cache->ent[c].miss++;
 529
 530         return mr;
 531 }
 532
 533 void mlx5_mr_cache_free(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
 534 {
 535         struct mlx5_mr_cache *cache = &dev->cache;
 536         struct mlx5_cache_ent *ent;
 537         int shrink = 0;
 538         int c;
 539
 540         c = order2idx(dev, mr->order);
 541         WARN_ON(c < 0 || c >= MAX_MR_CACHE_ENTRIES);
 542
 543         if (unreg_umr(dev, mr)) {
 544                 mr->allocated_from_cache = false;
 545                 destroy_mkey(dev, mr);
 546                 ent = &cache->ent[c];
 547                 if (ent->cur < ent->limit)
 548                         queue_work(cache->wq, &ent->work);
 549                 return;
 550         }
 551
 552         ent = &cache->ent[c];
 553         spin_lock_irq(&ent->lock);
 554         list_add_tail(&mr->list, &ent->head);
 555         ent->cur++;
 556         if (ent->cur > 2 * ent->limit)
 557                 shrink = 1;
 558         spin_unlock_irq(&ent->lock);
 559
 560         if (shrink)
 561                 queue_work(cache->wq, &ent->work);
 562 }
 563
 564 static void clean_keys(struct mlx5_ib_dev *dev, int c)
 565 {
 566         struct mlx5_mr_cache *cache = &dev->cache;
 567         struct mlx5_cache_ent *ent = &cache->ent[c];
 568         struct mlx5_ib_mr *mr;
 569         int err;
 570
 571         cancel_delayed_work(&ent->dwork);
 572         while (1) {
 573                 spin_lock_irq(&ent->lock);
 574                 if (list_empty(&ent->head)) {
 575                         spin_unlock_irq(&ent->lock);
 576                         return;
 577                 }
 578                 mr = list_first_entry(&ent->head, struct mlx5_ib_mr, list);
 579                 list_del(&mr->list);
 580                 ent->cur--;
 581                 ent->size--;
 582                 spin_unlock_irq(&ent->lock);
 583                 err = destroy_mkey(dev, mr);
 584                 if (err)
 585                         mlx5_ib_warn(dev, "failed destroy mkey\n");
 586                 else
 587                         kfree(mr);
 588         }
 589 }
 590
 591 static void mlx5_mr_cache_debugfs_cleanup(struct mlx5_ib_dev *dev)
 592 {
 593         if (!mlx5_debugfs_root)
 594                 return;
 595
 596         debugfs_remove_recursive(dev->cache.root);
 597         dev->cache.root = NULL;
 598 }
 599
 600 static int mlx5_mr_cache_debugfs_init(struct mlx5_ib_dev *dev)
 601 {
 602         struct mlx5_mr_cache *cache = &dev->cache;
 603         struct mlx5_cache_ent *ent;
 604         int i;
 605
 606         if (!mlx5_debugfs_root)
 607                 return 0;
 608
 609         cache->root = debugfs_create_dir("mr_cache", dev->mdev->priv.dbg_root);
 610         if (!cache->root)
 611                 return -ENOMEM;
 612
 613         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++) {
 614                 ent = &cache->ent[i];
 615                 sprintf(ent->name, "%d", ent->order);
 616                 ent->dir = debugfs_create_dir(ent->name,  cache->root);
 617                 if (!ent->dir)
 618                         goto err;
 619
 620                 ent->fsize = debugfs_create_file("size", 0600, ent->dir, ent,
 621                                                  &size_fops);
 622                 if (!ent->fsize)
 623                         goto err;
 624
 625                 ent->flimit = debugfs_create_file("limit", 0600, ent->dir, ent,
 626                                                   &limit_fops);
 627                 if (!ent->flimit)
 628                         goto err;
 629
 630                 ent->fcur = debugfs_create_u32("cur", 0400, ent->dir,
 631                                                &ent->cur);
 632                 if (!ent->fcur)
 633                         goto err;
 634
 635                 ent->fmiss = debugfs_create_u32("miss", 0600, ent->dir,
 636                                                 &ent->miss);
 637                 if (!ent->fmiss)
 638                         goto err;
 639         }
 640
 641         return 0;
 642 err:
 643         mlx5_mr_cache_debugfs_cleanup(dev);
 644
 645         return -ENOMEM;
 646 }
 647
 648 static void delay_time_func(unsigned long ctx)
 649 {
 650         struct mlx5_ib_dev *dev = (struct mlx5_ib_dev *)ctx;
 651
 652         dev->fill_delay = 0;
 653 }
 654
 655 int mlx5_mr_cache_init(struct mlx5_ib_dev *dev)
 656 {
 657         struct mlx5_mr_cache *cache = &dev->cache;
 658         struct mlx5_cache_ent *ent;
 659         int err;
 660         int i;
 661
 662         mutex_init(&dev->slow_path_mutex);
 663         cache->wq = alloc_ordered_workqueue("mkey_cache", WQ_MEM_RECLAIM);
 664         if (!cache->wq) {
 665                 mlx5_ib_warn(dev, "failed to create work queue\n");
 666                 return -ENOMEM;
 667         }
 668
 669         setup_timer(&dev->delay_timer, delay_time_func, (unsigned long)dev);
 670         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++) {
 671                 ent = &cache->ent[i];
 672                 INIT_LIST_HEAD(&ent->head);
 673                 spin_lock_init(&ent->lock);
 674                 ent->order = i + 2;
 675                 ent->dev = dev;
 676                 ent->limit = 0;
 677
 678                 init_completion(&ent->compl);
 679                 INIT_WORK(&ent->work, cache_work_func);
 680                 INIT_DELAYED_WORK(&ent->dwork, delayed_cache_work_func);
 681
 682                 if (i > MR_CACHE_LAST_STD_ENTRY) {
 683                         mlx5_odp_init_mr_cache_entry(ent);
 684                         continue;
 685                 }
 686
 687                 if (ent->order > mr_cache_max_order(dev))
 688                         continue;
 689
 690                 ent->page = PAGE_SHIFT;
 691                 ent->xlt = (1 << ent->order) * sizeof(struct mlx5_mtt) /
 692                            MLX5_IB_UMR_OCTOWORD;
 693                 ent->access_mode = MLX5_MKC_ACCESS_MODE_MTT;
 694                 if ((dev->mdev->profile->mask & MLX5_PROF_MASK_MR_CACHE) &&
 695                     mlx5_core_is_pf(dev->mdev))
 696                         ent->limit = dev->mdev->profile->mr_cache[i].limit;
 697                 else
 698                         ent->limit = 0;
 699                 queue_work(cache->wq, &ent->work);
 700         }
 701
 702         err = mlx5_mr_cache_debugfs_init(dev);
 703         if (err)
 704                 mlx5_ib_warn(dev, "cache debugfs failure\n");
 705
 706         /*
 707          * We don't want to fail driver if debugfs failed to initialize,
 708          * so we are not forwarding error to the user.
 709          */
 710
 711         return 0;
 712 }
 713
 714 static void wait_for_async_commands(struct mlx5_ib_dev *dev)
 715 {
 716         struct mlx5_mr_cache *cache = &dev->cache;
 717         struct mlx5_cache_ent *ent;
 718         int total = 0;
 719         int i;
 720         int j;
 721
 722         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++) {
 723                 ent = &cache->ent[i];
 724                 for (j = 0 ; j < 1000; j++) {
 725                         if (!ent->pending)
 726                                 break;
 727                         msleep(50);
 728                 }
 729         }
 730         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++) {
 731                 ent = &cache->ent[i];
 732                 total += ent->pending;
 733         }
 734
 735         if (total)
 736                 mlx5_ib_warn(dev, "aborted while there are %d pending mr requests\n", total);
 737         else
 738                 mlx5_ib_warn(dev, "done with all pending requests\n");
 739 }
 740
 741 int mlx5_mr_cache_cleanup(struct mlx5_ib_dev *dev)
 742 {
 743         int i;
 744
 745         dev->cache.stopped = 1;
 746         flush_workqueue(dev->cache.wq);
 747
 748         mlx5_mr_cache_debugfs_cleanup(dev);
 749
 750         for (i = 0; i < MAX_MR_CACHE_ENTRIES; i++)
 751                 clean_keys(dev, i);
 752
 753         destroy_workqueue(dev->cache.wq);
 754         wait_for_async_commands(dev);
 755         del_timer_sync(&dev->delay_timer);
 756
 757         return 0;
 758 }
 759
 760 struct ib_mr *mlx5_ib_get_dma_mr(struct ib_pd *pd, int acc)
 761 {
 762         struct mlx5_ib_dev *dev = to_mdev(pd->device);
 763         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
 764         struct mlx5_core_dev *mdev = dev->mdev;
 765         struct mlx5_ib_mr *mr;
 766         void *mkc;
 767         u32 *in;
 768         int err;
 769
 770         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
 771         if (!mr)
 772                 return ERR_PTR(-ENOMEM);
 773
 774         in = kzalloc(inlen, GFP_KERNEL);
 775         if (!in) {
 776                 err = -ENOMEM;
 777                 goto err_free;
 778         }
 779
 780         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
 781
 782         MLX5_SET(mkc, mkc, access_mode, MLX5_MKC_ACCESS_MODE_PA);
 783         MLX5_SET(mkc, mkc, a, !!(acc & IB_ACCESS_REMOTE_ATOMIC));
 784         MLX5_SET(mkc, mkc, rw, !!(acc & IB_ACCESS_REMOTE_WRITE));
 785         MLX5_SET(mkc, mkc, rr, !!(acc & IB_ACCESS_REMOTE_READ));
 786         MLX5_SET(mkc, mkc, lw, !!(acc & IB_ACCESS_LOCAL_WRITE));
 787         MLX5_SET(mkc, mkc, lr, 1);
 788
 789         MLX5_SET(mkc, mkc, length64, 1);
 790         MLX5_SET(mkc, mkc, pd, to_mpd(pd)->pdn);
 791         MLX5_SET(mkc, mkc, qpn, 0xffffff);
 792         MLX5_SET64(mkc, mkc, start_addr, 0);
 793
 794         err = mlx5_core_create_mkey(mdev, &mr->mmkey, in, inlen);
 795         if (err)
 796                 goto err_in;
 797
 798         kfree(in);
 799         mr->mmkey.type = MLX5_MKEY_MR;
 800         mr->ibmr.lkey = mr->mmkey.key;
 801         mr->ibmr.rkey = mr->mmkey.key;
 802         mr->umem = NULL;
 803
 804         return &mr->ibmr;
 805
 806 err_in:
 807         kfree(in);
 808
 809 err_free:
 810         kfree(mr);
 811
 812         return ERR_PTR(err);
 813 }
 814
 815 static int get_octo_len(u64 addr, u64 len, int page_shift)
 816 {
 817         u64 page_size = 1ULL << page_shift;
 818         u64 offset;
 819         int npages;
 820
 821         offset = addr & (page_size - 1);
 822         npages = ALIGN(len + offset, page_size) >> page_shift;
 823         return (npages + 1) / 2;
 824 }
 825
 826 static int mr_cache_max_order(struct mlx5_ib_dev *dev)
 827 {
 828         if (MLX5_CAP_GEN(dev->mdev, umr_extended_translation_offset))
 829                 return MR_CACHE_LAST_STD_ENTRY + 2;
 830         return MLX5_MAX_UMR_SHIFT;
 831 }
 832
 833 static int mr_umem_get(struct ib_pd *pd, u64 start, u64 length,
 834                        int access_flags, struct ib_umem **umem,
 835                        int *npages, int *page_shift, int *ncont,
 836                        int *order)
 837 {
 838         struct mlx5_ib_dev *dev = to_mdev(pd->device);
 839         struct ib_umem *u;
 840         int err;
 841
 842         *umem = NULL;
 843
 844         u = ib_umem_get(pd->uobject->context, start, length, access_flags, 0);
 845         err = PTR_ERR_OR_ZERO(u);
 846         if (err) {
 847                 mlx5_ib_dbg(dev, "umem get failed (%d)\n", err);
 848                 return err;
 849         }
 850
 851         mlx5_ib_cont_pages(u, start, MLX5_MKEY_PAGE_SHIFT_MASK, npages,
 852                            page_shift, ncont, order);
 853         if (!*npages) {
 854                 mlx5_ib_warn(dev, "avoid zero region\n");
 855                 ib_umem_release(u);
 856                 return -EINVAL;
 857         }
 858
 859         *umem = u;
 860
 861         mlx5_ib_dbg(dev, "npages %d, ncont %d, order %d, page_shift %d\n",
 862                     *npages, *ncont, *order, *page_shift);
 863
 864         return 0;
 865 }
 866
 867 static void mlx5_ib_umr_done(struct ib_cq *cq, struct ib_wc *wc)
 868 {
 869         struct mlx5_ib_umr_context *context =
 870                 container_of(wc->wr_cqe, struct mlx5_ib_umr_context, cqe);
 871
 872         context->status = wc->status;
 873         complete(&context->done);
 874 }
 875
 876 static inline void mlx5_ib_init_umr_context(struct mlx5_ib_umr_context *context)
 877 {
 878         context->cqe.done = mlx5_ib_umr_done;
 879         context->status = -1;
 880         init_completion(&context->done);
 881 }
 882
 883 static int mlx5_ib_post_send_wait(struct mlx5_ib_dev *dev,
 884                                   struct mlx5_umr_wr *umrwr)
 885 {
 886         struct umr_common *umrc = &dev->umrc;
 887         struct ib_send_wr *bad;
 888         int err;
 889         struct mlx5_ib_umr_context umr_context;
 890
 891         mlx5_ib_init_umr_context(&umr_context);
 892         umrwr->wr.wr_cqe = &umr_context.cqe;
 893
 894         down(&umrc->sem);
 895         err = ib_post_send(umrc->qp, &umrwr->wr, &bad);
 896         if (err) {
 897                 mlx5_ib_warn(dev, "UMR post send failed, err %d\n", err);
 898         } else {
 899                 wait_for_completion(&umr_context.done);
 900                 if (umr_context.status != IB_WC_SUCCESS) {
 901                         mlx5_ib_warn(dev, "reg umr failed (%u)\n",
 902                                      umr_context.status);
 903                         err = -EFAULT;
 904                 }
 905         }
 906         up(&umrc->sem);
 907         return err;
 908 }
 909
 910 static struct mlx5_ib_mr *alloc_mr_from_cache(
 911                                   struct ib_pd *pd, struct ib_umem *umem,
 912                                   u64 virt_addr, u64 len, int npages,
 913                                   int page_shift, int order, int access_flags)
 914 {
 915         struct mlx5_ib_dev *dev = to_mdev(pd->device);
 916         struct mlx5_ib_mr *mr;
 917         int err = 0;
 918         int i;
 919
 920         for (i = 0; i < 1; i++) {
 921                 mr = alloc_cached_mr(dev, order);
 922                 if (mr)
 923                         break;
 924
 925                 err = add_keys(dev, order2idx(dev, order), 1);
 926                 if (err && err != -EAGAIN) {
 927                         mlx5_ib_warn(dev, "add_keys failed, err %d\n", err);
 928                         break;
 929                 }
 930         }
 931
 932         if (!mr)
 933                 return ERR_PTR(-EAGAIN);
 934
 935         mr->ibmr.pd = pd;
 936         mr->umem = umem;
 937         mr->access_flags = access_flags;
 938         mr->desc_size = sizeof(struct mlx5_mtt);
 939         mr->mmkey.iova = virt_addr;
 940         mr->mmkey.size = len;
 941         mr->mmkey.pd = to_mpd(pd)->pdn;
 942
 943         return mr;
 944 }
 945
 946 static inline int populate_xlt(struct mlx5_ib_mr *mr, int idx, int npages,
 947                                void *xlt, int page_shift, size_t size,
 948                                int flags)
 949 {
 950         struct mlx5_ib_dev *dev = mr->dev;
 951         struct ib_umem *umem = mr->umem;
 952         if (flags & MLX5_IB_UPD_XLT_INDIRECT) {
 953                 mlx5_odp_populate_klm(xlt, idx, npages, mr, flags);
 954                 return npages;
 955         }
 956
 957         npages = min_t(size_t, npages, ib_umem_num_pages(umem) - idx);
 958
 959         if (!(flags & MLX5_IB_UPD_XLT_ZAP)) {
 960                 __mlx5_ib_populate_pas(dev, umem, page_shift,
 961                                        idx, npages, xlt,
 962                                        MLX5_IB_MTT_PRESENT);
 963                 /* Clear padding after the pages
 964                  * brought from the umem.
 965                  */
 966                 memset(xlt + (npages * sizeof(struct mlx5_mtt)), 0,
 967                        size - npages * sizeof(struct mlx5_mtt));
 968         }
 969
 970         return npages;
 971 }
 972
 973 #define MLX5_MAX_UMR_CHUNK ((1 << (MLX5_MAX_UMR_SHIFT + 4)) - \
 974                             MLX5_UMR_MTT_ALIGNMENT)
 975 #define MLX5_SPARE_UMR_CHUNK 0x10000
 976
 977 int mlx5_ib_update_xlt(struct mlx5_ib_mr *mr, u64 idx, int npages,
 978                        int page_shift, int flags)
 979 {
 980         struct mlx5_ib_dev *dev = mr->dev;
 981         struct device *ddev = dev->ib_dev.dev.parent;
 982         struct mlx5_ib_ucontext *uctx = NULL;
 983         int size;
 984         void *xlt;
 985         dma_addr_t dma;
 986         struct mlx5_umr_wr wr;
 987         struct ib_sge sg;
 988         int err = 0;
 989         int desc_size = (flags & MLX5_IB_UPD_XLT_INDIRECT)
 990                                ? sizeof(struct mlx5_klm)
 991                                : sizeof(struct mlx5_mtt);
 992         const int page_align = MLX5_UMR_MTT_ALIGNMENT / desc_size;
 993         const int page_mask = page_align - 1;
 994         size_t pages_mapped = 0;
 995         size_t pages_to_map = 0;
 996         size_t pages_iter = 0;
 997         gfp_t gfp;
 998
 999         /* UMR copies MTTs in units of MLX5_UMR_MTT_ALIGNMENT bytes,
1000          * so we need to align the offset and length accordingly
1001          */
1002         if (idx & page_mask) {
1003                 npages += idx & page_mask;
1004                 idx &= ~page_mask;
1005         }
1006
1007         gfp = flags & MLX5_IB_UPD_XLT_ATOMIC ? GFP_ATOMIC : GFP_KERNEL;
1008         gfp |= __GFP_ZERO | __GFP_NOWARN;
1009
1010         pages_to_map = ALIGN(npages, page_align);
1011         size = desc_size * pages_to_map;
1012         size = min_t(int, size, MLX5_MAX_UMR_CHUNK);
1013
1014         xlt = (void *)__get_free_pages(gfp, get_order(size));
1015         if (!xlt && size > MLX5_SPARE_UMR_CHUNK) {
1016                 mlx5_ib_dbg(dev, "Failed to allocate %d bytes of order %d. fallback to spare UMR allocation od %d bytes\n",
1017                             size, get_order(size), MLX5_SPARE_UMR_CHUNK);
1018
1019                 size = MLX5_SPARE_UMR_CHUNK;
1020                 xlt = (void *)__get_free_pages(gfp, get_order(size));
1021         }
1022
1023         if (!xlt) {
1024                 uctx = to_mucontext(mr->ibmr.pd->uobject->context);
1025                 mlx5_ib_warn(dev, "Using XLT emergency buffer\n");
1026                 size = PAGE_SIZE;
1027                 xlt = (void *)uctx->upd_xlt_page;
1028                 mutex_lock(&uctx->upd_xlt_page_mutex);
1029                 memset(xlt, 0, size);
1030         }
1031         pages_iter = size / desc_size;
1032         dma = dma_map_single(ddev, xlt, size, DMA_TO_DEVICE);
1033         if (dma_mapping_error(ddev, dma)) {
1034                 mlx5_ib_err(dev, "unable to map DMA during XLT update.\n");
1035                 err = -ENOMEM;
1036                 goto free_xlt;
1037         }
1038
1039         sg.addr = dma;
1040         sg.lkey = dev->umrc.pd->local_dma_lkey;
1041
1042         memset(&wr, 0, sizeof(wr));
1043         wr.wr.send_flags = MLX5_IB_SEND_UMR_UPDATE_XLT;
1044         if (!(flags & MLX5_IB_UPD_XLT_ENABLE))
1045                 wr.wr.send_flags |= MLX5_IB_SEND_UMR_FAIL_IF_FREE;
1046         wr.wr.sg_list = &sg;
1047         wr.wr.num_sge = 1;
1048         wr.wr.opcode = MLX5_IB_WR_UMR;
1049
1050         wr.pd = mr->ibmr.pd;
1051         wr.mkey = mr->mmkey.key;
1052         wr.length = mr->mmkey.size;
1053         wr.virt_addr = mr->mmkey.iova;
1054         wr.access_flags = mr->access_flags;
1055         wr.page_shift = page_shift;
1056
1057         for (pages_mapped = 0;
1058              pages_mapped < pages_to_map && !err;
1059              pages_mapped += pages_iter, idx += pages_iter) {
1060                 npages = min_t(int, pages_iter, pages_to_map - pages_mapped);
1061                 dma_sync_single_for_cpu(ddev, dma, size, DMA_TO_DEVICE);
1062                 npages = populate_xlt(mr, idx, npages, xlt,
1063                                       page_shift, size, flags);
1064
1065                 dma_sync_single_for_device(ddev, dma, size, DMA_TO_DEVICE);
1066
1067                 sg.length = ALIGN(npages * desc_size,
1068                                   MLX5_UMR_MTT_ALIGNMENT);
1069
1070                 if (pages_mapped + pages_iter >= pages_to_map) {
1071                         if (flags & MLX5_IB_UPD_XLT_ENABLE)
1072                                 wr.wr.send_flags |=
1073                                         MLX5_IB_SEND_UMR_ENABLE_MR |
1074                                         MLX5_IB_SEND_UMR_UPDATE_PD_ACCESS |
1075                                         MLX5_IB_SEND_UMR_UPDATE_TRANSLATION;
1076                         if (flags & MLX5_IB_UPD_XLT_PD ||
1077                             flags & MLX5_IB_UPD_XLT_ACCESS)
1078                                 wr.wr.send_flags |=
1079                                         MLX5_IB_SEND_UMR_UPDATE_PD_ACCESS;
1080                         if (flags & MLX5_IB_UPD_XLT_ADDR)
1081                                 wr.wr.send_flags |=
1082                                         MLX5_IB_SEND_UMR_UPDATE_TRANSLATION;
1083                 }
1084
1085                 wr.offset = idx * desc_size;
1086                 wr.xlt_size = sg.length;
1087
1088                 err = mlx5_ib_post_send_wait(dev, &wr);
1089         }
1090         dma_unmap_single(ddev, dma, size, DMA_TO_DEVICE);
1091
1092 free_xlt:
1093         if (uctx)
1094                 mutex_unlock(&uctx->upd_xlt_page_mutex);
1095         else
1096                 free_pages((unsigned long)xlt, get_order(size));
1097
1098         return err;
1099 }
1100
1101 /*
1102  * If ibmr is NULL it will be allocated by reg_create.
1103  * Else, the given ibmr will be used.
1104  */
1105 static struct mlx5_ib_mr *reg_create(struct ib_mr *ibmr, struct ib_pd *pd,
1106                                      u64 virt_addr, u64 length,
1107                                      struct ib_umem *umem, int npages,
1108                                      int page_shift, int access_flags,
1109                                      bool populate)
1110 {
1111         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1112         struct mlx5_ib_mr *mr;
1113         __be64 *pas;
1114         void *mkc;
1115         int inlen;
1116         u32 *in;
1117         int err;
1118         bool pg_cap = !!(MLX5_CAP_GEN(dev->mdev, pg));
1119
1120         mr = ibmr ? to_mmr(ibmr) : kzalloc(sizeof(*mr), GFP_KERNEL);
1121         if (!mr)
1122                 return ERR_PTR(-ENOMEM);
1123
1124         mr->ibmr.pd = pd;
1125         mr->access_flags = access_flags;
1126
1127         inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
1128         if (populate)
1129                 inlen += sizeof(*pas) * roundup(npages, 2);
1130         in = kvzalloc(inlen, GFP_KERNEL);
1131         if (!in) {
1132                 err = -ENOMEM;
1133                 goto err_1;
1134         }
1135         pas = (__be64 *)MLX5_ADDR_OF(create_mkey_in, in, klm_pas_mtt);
1136         if (populate && !(access_flags & IB_ACCESS_ON_DEMAND))
1137                 mlx5_ib_populate_pas(dev, umem, page_shift, pas,
1138                                      pg_cap ? MLX5_IB_MTT_PRESENT : 0);
1139
1140         /* The pg_access bit allows setting the access flags
1141          * in the page list submitted with the command. */
1142         MLX5_SET(create_mkey_in, in, pg_access, !!(pg_cap));
1143
1144         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
1145         MLX5_SET(mkc, mkc, free, !populate);
1146         MLX5_SET(mkc, mkc, access_mode, MLX5_MKC_ACCESS_MODE_MTT);
1147         MLX5_SET(mkc, mkc, a, !!(access_flags & IB_ACCESS_REMOTE_ATOMIC));
1148         MLX5_SET(mkc, mkc, rw, !!(access_flags & IB_ACCESS_REMOTE_WRITE));
1149         MLX5_SET(mkc, mkc, rr, !!(access_flags & IB_ACCESS_REMOTE_READ));
1150         MLX5_SET(mkc, mkc, lw, !!(access_flags & IB_ACCESS_LOCAL_WRITE));
1151         MLX5_SET(mkc, mkc, lr, 1);
1152         MLX5_SET(mkc, mkc, umr_en, 1);
1153
1154         MLX5_SET64(mkc, mkc, start_addr, virt_addr);
1155         MLX5_SET64(mkc, mkc, len, length);
1156         MLX5_SET(mkc, mkc, pd, to_mpd(pd)->pdn);
1157         MLX5_SET(mkc, mkc, bsf_octword_size, 0);
1158         MLX5_SET(mkc, mkc, translations_octword_size,
1159                  get_octo_len(virt_addr, length, page_shift));
1160         MLX5_SET(mkc, mkc, log_page_size, page_shift);
1161         MLX5_SET(mkc, mkc, qpn, 0xffffff);
1162         if (populate) {
1163                 MLX5_SET(create_mkey_in, in, translations_octword_actual_size,
1164                          get_octo_len(virt_addr, length, page_shift));
1165         }
1166
1167         err = mlx5_core_create_mkey(dev->mdev, &mr->mmkey, in, inlen);
1168         if (err) {
1169                 mlx5_ib_warn(dev, "create mkey failed\n");
1170                 goto err_2;
1171         }
1172         mr->mmkey.type = MLX5_MKEY_MR;
1173         mr->desc_size = sizeof(struct mlx5_mtt);
1174         mr->dev = dev;
1175         kvfree(in);
1176
1177         mlx5_ib_dbg(dev, "mkey = 0x%x\n", mr->mmkey.key);
1178
1179         return mr;
1180
1181 err_2:
1182         kvfree(in);
1183
1184 err_1:
1185         if (!ibmr)
1186                 kfree(mr);
1187
1188         return ERR_PTR(err);
1189 }
1190
1191 static void set_mr_fileds(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr,
1192                           int npages, u64 length, int access_flags)
1193 {
1194         mr->npages = npages;
1195         atomic_add(npages, &dev->mdev->priv.reg_pages);
1196         mr->ibmr.lkey = mr->mmkey.key;
1197         mr->ibmr.rkey = mr->mmkey.key;
1198         mr->ibmr.length = length;
1199         mr->access_flags = access_flags;
1200 }
1201
1202 struct ib_mr *mlx5_ib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
1203                                   u64 virt_addr, int access_flags,
1204                                   struct ib_udata *udata)
1205 {
1206         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1207         struct mlx5_ib_mr *mr = NULL;
1208         struct ib_umem *umem;
1209         int page_shift;
1210         int npages;
1211         int ncont;
1212         int order;
1213         int err;
1214         bool use_umr = true;
1215
1216         if (!IS_ENABLED(CONFIG_INFINIBAND_USER_MEM))
1217                 return ERR_PTR(-EINVAL);
1218
1219         mlx5_ib_dbg(dev, "start 0x%llx, virt_addr 0x%llx, length 0x%llx, access_flags 0x%x\n",
1220                     start, virt_addr, length, access_flags);
1221
1222 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
1223         if (!start && length == U64_MAX) {
1224                 if (!(access_flags & IB_ACCESS_ON_DEMAND) ||
1225                     !(dev->odp_caps.general_caps & IB_ODP_SUPPORT_IMPLICIT))
1226                         return ERR_PTR(-EINVAL);
1227
1228                 mr = mlx5_ib_alloc_implicit_mr(to_mpd(pd), access_flags);
1229                 if (IS_ERR(mr))
1230                         return ERR_CAST(mr);
1231                 return &mr->ibmr;
1232         }
1233 #endif
1234
1235         err = mr_umem_get(pd, start, length, access_flags, &umem, &npages,
1236                            &page_shift, &ncont, &order);
1237
1238         if (err < 0)
1239                 return ERR_PTR(err);
1240
1241         if (order <= mr_cache_max_order(dev)) {
1242                 mr = alloc_mr_from_cache(pd, umem, virt_addr, length, ncont,
1243                                          page_shift, order, access_flags);
1244                 if (PTR_ERR(mr) == -EAGAIN) {
1245                         mlx5_ib_dbg(dev, "cache empty for order %d", order);
1246                         mr = NULL;
1247                 }
1248         } else if (!MLX5_CAP_GEN(dev->mdev, umr_extended_translation_offset)) {
1249                 if (access_flags & IB_ACCESS_ON_DEMAND) {
1250                         err = -EINVAL;
1251                         pr_err("Got MR registration for ODP MR > 512MB, not supported for Connect-IB");
1252                         goto error;
1253                 }
1254                 use_umr = false;
1255         }
1256
1257         if (!mr) {
1258                 mutex_lock(&dev->slow_path_mutex);
1259                 mr = reg_create(NULL, pd, virt_addr, length, umem, ncont,
1260                                 page_shift, access_flags, !use_umr);
1261                 mutex_unlock(&dev->slow_path_mutex);
1262         }
1263
1264         if (IS_ERR(mr)) {
1265                 err = PTR_ERR(mr);
1266                 goto error;
1267         }
1268
1269         mlx5_ib_dbg(dev, "mkey 0x%x\n", mr->mmkey.key);
1270
1271         mr->umem = umem;
1272         set_mr_fileds(dev, mr, npages, length, access_flags);
1273
1274 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
1275         update_odp_mr(mr);
1276 #endif
1277
1278         if (use_umr) {
1279                 int update_xlt_flags = MLX5_IB_UPD_XLT_ENABLE;
1280
1281                 if (access_flags & IB_ACCESS_ON_DEMAND)
1282                         update_xlt_flags |= MLX5_IB_UPD_XLT_ZAP;
1283
1284                 err = mlx5_ib_update_xlt(mr, 0, ncont, page_shift,
1285                                          update_xlt_flags);
1286
1287                 if (err) {
1288                         dereg_mr(dev, mr);
1289                         return ERR_PTR(err);
1290                 }
1291         }
1292
1293         mr->live = 1;
1294         return &mr->ibmr;
1295 error:
1296         ib_umem_release(umem);
1297         return ERR_PTR(err);
1298 }
1299
1300 static int unreg_umr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
1301 {
1302         struct mlx5_core_dev *mdev = dev->mdev;
1303         struct mlx5_umr_wr umrwr = {};
1304
1305         if (mdev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR)
1306                 return 0;
1307
1308         umrwr.wr.send_flags = MLX5_IB_SEND_UMR_DISABLE_MR |
1309                               MLX5_IB_SEND_UMR_UPDATE_PD_ACCESS;
1310         umrwr.wr.opcode = MLX5_IB_WR_UMR;
1311         umrwr.pd = dev->umrc.pd;
1312         umrwr.mkey = mr->mmkey.key;
1313         umrwr.ignore_free_state = 1;
1314
1315         return mlx5_ib_post_send_wait(dev, &umrwr);
1316 }
1317
1318 static int rereg_umr(struct ib_pd *pd, struct mlx5_ib_mr *mr,
1319                      int access_flags, int flags)
1320 {
1321         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1322         struct mlx5_umr_wr umrwr = {};
1323         int err;
1324
1325         umrwr.wr.send_flags = MLX5_IB_SEND_UMR_FAIL_IF_FREE;
1326
1327         umrwr.wr.opcode = MLX5_IB_WR_UMR;
1328         umrwr.mkey = mr->mmkey.key;
1329
1330         if (flags & IB_MR_REREG_PD || flags & IB_MR_REREG_ACCESS) {
1331                 umrwr.pd = pd;
1332                 umrwr.access_flags = access_flags;
1333                 umrwr.wr.send_flags |= MLX5_IB_SEND_UMR_UPDATE_PD_ACCESS;
1334         }
1335
1336         err = mlx5_ib_post_send_wait(dev, &umrwr);
1337
1338         return err;
1339 }
1340
1341 int mlx5_ib_rereg_user_mr(struct ib_mr *ib_mr, int flags, u64 start,
1342                           u64 length, u64 virt_addr, int new_access_flags,
1343                           struct ib_pd *new_pd, struct ib_udata *udata)
1344 {
1345         struct mlx5_ib_dev *dev = to_mdev(ib_mr->device);
1346         struct mlx5_ib_mr *mr = to_mmr(ib_mr);
1347         struct ib_pd *pd = (flags & IB_MR_REREG_PD) ? new_pd : ib_mr->pd;
1348         int access_flags = flags & IB_MR_REREG_ACCESS ?
1349                             new_access_flags :
1350                             mr->access_flags;
1351         int page_shift = 0;
1352         int upd_flags = 0;
1353         int npages = 0;
1354         int ncont = 0;
1355         int order = 0;
1356         u64 addr, len;
1357         int err;
1358
1359         mlx5_ib_dbg(dev, "start 0x%llx, virt_addr 0x%llx, length 0x%llx, access_flags 0x%x\n",
1360                     start, virt_addr, length, access_flags);
1361
1362         atomic_sub(mr->npages, &dev->mdev->priv.reg_pages);
1363
1364         if (!mr->umem)
1365                 return -EINVAL;
1366
1367         if (flags & IB_MR_REREG_TRANS) {
1368                 addr = virt_addr;
1369                 len = length;
1370         } else {
1371                 addr = mr->umem->address;
1372                 len = mr->umem->length;
1373         }
1374
1375         if (flags != IB_MR_REREG_PD) {
1376                 /*
1377                  * Replace umem. This needs to be done whether or not UMR is
1378                  * used.
1379                  */
1380                 flags |= IB_MR_REREG_TRANS;
1381                 ib_umem_release(mr->umem);
1382                 mr->umem = NULL;
1383                 err = mr_umem_get(pd, addr, len, access_flags, &mr->umem,
1384                                   &npages, &page_shift, &ncont, &order);
1385                 if (err < 0) {
1386                         clean_mr(dev, mr);
1387                         return err;
1388                 }
1389         }
1390
1391         if (flags & IB_MR_REREG_TRANS && !use_umr_mtt_update(mr, addr, len)) {
1392                 /*
1393                  * UMR can't be used - MKey needs to be replaced.
1394                  */
1395                 if (mr->allocated_from_cache) {
1396                         err = unreg_umr(dev, mr);
1397                         if (err)
1398                                 mlx5_ib_warn(dev, "Failed to unregister MR\n");
1399                 } else {
1400                         err = destroy_mkey(dev, mr);
1401                         if (err)
1402                                 mlx5_ib_warn(dev, "Failed to destroy MKey\n");
1403                 }
1404                 if (err)
1405                         return err;
1406
1407                 mr = reg_create(ib_mr, pd, addr, len, mr->umem, ncont,
1408                                 page_shift, access_flags, true);
1409
1410                 if (IS_ERR(mr))
1411                         return PTR_ERR(mr);
1412
1413                 mr->allocated_from_cache = 0;
1414                 mr->live = 1;
1415         } else {
1416                 /*
1417                  * Send a UMR WQE
1418                  */
1419                 mr->ibmr.pd = pd;
1420                 mr->access_flags = access_flags;
1421                 mr->mmkey.iova = addr;
1422                 mr->mmkey.size = len;
1423                 mr->mmkey.pd = to_mpd(pd)->pdn;
1424
1425                 if (flags & IB_MR_REREG_TRANS) {
1426                         upd_flags = MLX5_IB_UPD_XLT_ADDR;
1427                         if (flags & IB_MR_REREG_PD)
1428                                 upd_flags |= MLX5_IB_UPD_XLT_PD;
1429                         if (flags & IB_MR_REREG_ACCESS)
1430                                 upd_flags |= MLX5_IB_UPD_XLT_ACCESS;
1431                         err = mlx5_ib_update_xlt(mr, 0, npages, page_shift,
1432                                                  upd_flags);
1433                 } else {
1434                         err = rereg_umr(pd, mr, access_flags, flags);
1435                 }
1436
1437                 if (err) {
1438                         mlx5_ib_warn(dev, "Failed to rereg UMR\n");
1439                         ib_umem_release(mr->umem);
1440                         mr->umem = NULL;
1441                         clean_mr(dev, mr);
1442                         return err;
1443                 }
1444         }
1445
1446         set_mr_fileds(dev, mr, npages, len, access_flags);
1447
1448 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
1449         update_odp_mr(mr);
1450 #endif
1451         return 0;
1452 }
1453
1454 static int
1455 mlx5_alloc_priv_descs(struct ib_device *device,
1456                       struct mlx5_ib_mr *mr,
1457                       int ndescs,
1458                       int desc_size)
1459 {
1460         int size = ndescs * desc_size;
1461         int add_size;
1462         int ret;
1463
1464         add_size = max_t(int, MLX5_UMR_ALIGN - ARCH_KMALLOC_MINALIGN, 0);
1465
1466         mr->descs_alloc = kzalloc(size + add_size, GFP_KERNEL);
1467         if (!mr->descs_alloc)
1468                 return -ENOMEM;
1469
1470         mr->descs = PTR_ALIGN(mr->descs_alloc, MLX5_UMR_ALIGN);
1471
1472         mr->desc_map = dma_map_single(device->dev.parent, mr->descs,
1473                                       size, DMA_TO_DEVICE);
1474         if (dma_mapping_error(device->dev.parent, mr->desc_map)) {
1475                 ret = -ENOMEM;
1476                 goto err;
1477         }
1478
1479         return 0;
1480 err:
1481         kfree(mr->descs_alloc);
1482
1483         return ret;
1484 }
1485
1486 static void
1487 mlx5_free_priv_descs(struct mlx5_ib_mr *mr)
1488 {
1489         if (mr->descs) {
1490                 struct ib_device *device = mr->ibmr.device;
1491                 int size = mr->max_descs * mr->desc_size;
1492
1493                 dma_unmap_single(device->dev.parent, mr->desc_map,
1494                                  size, DMA_TO_DEVICE);
1495                 kfree(mr->descs_alloc);
1496                 mr->descs = NULL;
1497         }
1498 }
1499
1500 static int clean_mr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
1501 {
1502         int allocated_from_cache = mr->allocated_from_cache;
1503         int err;
1504
1505         if (mr->sig) {
1506                 if (mlx5_core_destroy_psv(dev->mdev,
1507                                           mr->sig->psv_memory.psv_idx))
1508                         mlx5_ib_warn(dev, "failed to destroy mem psv %d\n",
1509                                      mr->sig->psv_memory.psv_idx);
1510                 if (mlx5_core_destroy_psv(dev->mdev,
1511                                           mr->sig->psv_wire.psv_idx))
1512                         mlx5_ib_warn(dev, "failed to destroy wire psv %d\n",
1513                                      mr->sig->psv_wire.psv_idx);
1514                 kfree(mr->sig);
1515                 mr->sig = NULL;
1516         }
1517
1518         mlx5_free_priv_descs(mr);
1519
1520         if (!allocated_from_cache) {
1521                 u32 key = mr->mmkey.key;
1522
1523                 err = destroy_mkey(dev, mr);
1524                 if (err) {
1525                         mlx5_ib_warn(dev, "failed to destroy mkey 0x%x (%d)\n",
1526                                      key, err);
1527                         return err;
1528                 }
1529         }
1530
1531         return 0;
1532 }
1533
1534 static int dereg_mr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
1535 {
1536         int npages = mr->npages;
1537         struct ib_umem *umem = mr->umem;
1538
1539 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
1540         if (umem && umem->odp_data) {
1541                 /* Prevent new page faults from succeeding */
1542                 mr->live = 0;
1543                 /* Wait for all running page-fault handlers to finish. */
1544                 synchronize_srcu(&dev->mr_srcu);
1545                 /* Destroy all page mappings */
1546                 if (umem->odp_data->page_list)
1547                         mlx5_ib_invalidate_range(umem, ib_umem_start(umem),
1548                                                  ib_umem_end(umem));
1549                 else
1550                         mlx5_ib_free_implicit_mr(mr);
1551                 /*
1552                  * We kill the umem before the MR for ODP,
1553                  * so that there will not be any invalidations in
1554                  * flight, looking at the *mr struct.
1555                  */
1556                 ib_umem_release(umem);
1557                 atomic_sub(npages, &dev->mdev->priv.reg_pages);
1558
1559                 /* Avoid double-freeing the umem. */
1560                 umem = NULL;
1561         }
1562 #endif
1563
1564         clean_mr(dev, mr);
1565
1566         if (umem) {
1567                 ib_umem_release(umem);
1568                 atomic_sub(npages, &dev->mdev->priv.reg_pages);
1569         }
1570
1571         if (!mr->allocated_from_cache)
1572                 kfree(mr);
1573         else
1574                 mlx5_mr_cache_free(dev, mr);
1575
1576         return 0;
1577 }
1578
1579 int mlx5_ib_dereg_mr(struct ib_mr *ibmr)
1580 {
1581         struct mlx5_ib_dev *dev = to_mdev(ibmr->device);
1582         struct mlx5_ib_mr *mr = to_mmr(ibmr);
1583
1584         return dereg_mr(dev, mr);
1585 }
1586
1587 struct ib_mr *mlx5_ib_alloc_mr(struct ib_pd *pd,
1588                                enum ib_mr_type mr_type,
1589                                u32 max_num_sg)
1590 {
1591         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1592         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
1593         int ndescs = ALIGN(max_num_sg, 4);
1594         struct mlx5_ib_mr *mr;
1595         void *mkc;
1596         u32 *in;
1597         int err;
1598
1599         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
1600         if (!mr)
1601                 return ERR_PTR(-ENOMEM);
1602
1603         in = kzalloc(inlen, GFP_KERNEL);
1604         if (!in) {
1605                 err = -ENOMEM;
1606                 goto err_free;
1607         }
1608
1609         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
1610         MLX5_SET(mkc, mkc, free, 1);
1611         MLX5_SET(mkc, mkc, translations_octword_size, ndescs);
1612         MLX5_SET(mkc, mkc, qpn, 0xffffff);
1613         MLX5_SET(mkc, mkc, pd, to_mpd(pd)->pdn);
1614
1615         if (mr_type == IB_MR_TYPE_MEM_REG) {
1616                 mr->access_mode = MLX5_MKC_ACCESS_MODE_MTT;
1617                 MLX5_SET(mkc, mkc, log_page_size, PAGE_SHIFT);
1618                 err = mlx5_alloc_priv_descs(pd->device, mr,
1619                                             ndescs, sizeof(struct mlx5_mtt));
1620                 if (err)
1621                         goto err_free_in;
1622
1623                 mr->desc_size = sizeof(struct mlx5_mtt);
1624                 mr->max_descs = ndescs;
1625         } else if (mr_type == IB_MR_TYPE_SG_GAPS) {
1626                 mr->access_mode = MLX5_MKC_ACCESS_MODE_KLMS;
1627
1628                 err = mlx5_alloc_priv_descs(pd->device, mr,
1629                                             ndescs, sizeof(struct mlx5_klm));
1630                 if (err)
1631                         goto err_free_in;
1632                 mr->desc_size = sizeof(struct mlx5_klm);
1633                 mr->max_descs = ndescs;
1634         } else if (mr_type == IB_MR_TYPE_SIGNATURE) {
1635                 u32 psv_index[2];
1636
1637                 MLX5_SET(mkc, mkc, bsf_en, 1);
1638                 MLX5_SET(mkc, mkc, bsf_octword_size, MLX5_MKEY_BSF_OCTO_SIZE);
1639                 mr->sig = kzalloc(sizeof(*mr->sig), GFP_KERNEL);
1640                 if (!mr->sig) {
1641                         err = -ENOMEM;
1642                         goto err_free_in;
1643                 }
1644
1645                 /* create mem & wire PSVs */
1646                 err = mlx5_core_create_psv(dev->mdev, to_mpd(pd)->pdn,
1647                                            2, psv_index);
1648                 if (err)
1649                         goto err_free_sig;
1650
1651                 mr->access_mode = MLX5_MKC_ACCESS_MODE_KLMS;
1652                 mr->sig->psv_memory.psv_idx = psv_index[0];
1653                 mr->sig->psv_wire.psv_idx = psv_index[1];
1654
1655                 mr->sig->sig_status_checked = true;
1656                 mr->sig->sig_err_exists = false;
1657                 /* Next UMR, Arm SIGERR */
1658                 ++mr->sig->sigerr_count;
1659         } else {
1660                 mlx5_ib_warn(dev, "Invalid mr type %d\n", mr_type);
1661                 err = -EINVAL;
1662                 goto err_free_in;
1663         }
1664
1665         MLX5_SET(mkc, mkc, access_mode, mr->access_mode);
1666         MLX5_SET(mkc, mkc, umr_en, 1);
1667
1668         mr->ibmr.device = pd->device;
1669         err = mlx5_core_create_mkey(dev->mdev, &mr->mmkey, in, inlen);
1670         if (err)
1671                 goto err_destroy_psv;
1672
1673         mr->mmkey.type = MLX5_MKEY_MR;
1674         mr->ibmr.lkey = mr->mmkey.key;
1675         mr->ibmr.rkey = mr->mmkey.key;
1676         mr->umem = NULL;
1677         kfree(in);
1678
1679         return &mr->ibmr;
1680
1681 err_destroy_psv:
1682         if (mr->sig) {
1683                 if (mlx5_core_destroy_psv(dev->mdev,
1684                                           mr->sig->psv_memory.psv_idx))
1685                         mlx5_ib_warn(dev, "failed to destroy mem psv %d\n",
1686                                      mr->sig->psv_memory.psv_idx);
1687                 if (mlx5_core_destroy_psv(dev->mdev,
1688                                           mr->sig->psv_wire.psv_idx))
1689                         mlx5_ib_warn(dev, "failed to destroy wire psv %d\n",
1690                                      mr->sig->psv_wire.psv_idx);
1691         }
1692         mlx5_free_priv_descs(mr);
1693 err_free_sig:
1694         kfree(mr->sig);
1695 err_free_in:
1696         kfree(in);
1697 err_free:
1698         kfree(mr);
1699         return ERR_PTR(err);
1700 }
1701
1702 struct ib_mw *mlx5_ib_alloc_mw(struct ib_pd *pd, enum ib_mw_type type,
1703                                struct ib_udata *udata)
1704 {
1705         struct mlx5_ib_dev *dev = to_mdev(pd->device);
1706         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
1707         struct mlx5_ib_mw *mw = NULL;
1708         u32 *in = NULL;
1709         void *mkc;
1710         int ndescs;
1711         int err;
1712         struct mlx5_ib_alloc_mw req = {};
1713         struct {
1714                 __u32   comp_mask;
1715                 __u32   response_length;
1716         } resp = {};
1717
1718         err = ib_copy_from_udata(&req, udata, min(udata->inlen, sizeof(req)));
1719         if (err)
1720                 return ERR_PTR(err);
1721
1722         if (req.comp_mask || req.reserved1 || req.reserved2)
1723                 return ERR_PTR(-EOPNOTSUPP);
1724
1725         if (udata->inlen > sizeof(req) &&
1726             !ib_is_udata_cleared(udata, sizeof(req),
1727                                  udata->inlen - sizeof(req)))
1728                 return ERR_PTR(-EOPNOTSUPP);
1729
1730         ndescs = req.num_klms ? roundup(req.num_klms, 4) : roundup(1, 4);
1731
1732         mw = kzalloc(sizeof(*mw), GFP_KERNEL);
1733         in = kzalloc(inlen, GFP_KERNEL);
1734         if (!mw || !in) {
1735                 err = -ENOMEM;
1736                 goto free;
1737         }
1738
1739         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
1740
1741         MLX5_SET(mkc, mkc, free, 1);
1742         MLX5_SET(mkc, mkc, translations_octword_size, ndescs);
1743         MLX5_SET(mkc, mkc, pd, to_mpd(pd)->pdn);
1744         MLX5_SET(mkc, mkc, umr_en, 1);
1745         MLX5_SET(mkc, mkc, lr, 1);
1746         MLX5_SET(mkc, mkc, access_mode, MLX5_MKC_ACCESS_MODE_KLMS);
1747         MLX5_SET(mkc, mkc, en_rinval, !!((type == IB_MW_TYPE_2)));
1748         MLX5_SET(mkc, mkc, qpn, 0xffffff);
1749
1750         err = mlx5_core_create_mkey(dev->mdev, &mw->mmkey, in, inlen);
1751         if (err)
1752                 goto free;
1753
1754         mw->mmkey.type = MLX5_MKEY_MW;
1755         mw->ibmw.rkey = mw->mmkey.key;
1756         mw->ndescs = ndescs;
1757
1758         resp.response_length = min(offsetof(typeof(resp), response_length) +
1759                                    sizeof(resp.response_length), udata->outlen);
1760         if (resp.response_length) {
1761                 err = ib_copy_to_udata(udata, &resp, resp.response_length);
1762                 if (err) {
1763                         mlx5_core_destroy_mkey(dev->mdev, &mw->mmkey);
1764                         goto free;
1765                 }
1766         }
1767
1768         kfree(in);
1769         return &mw->ibmw;
1770
1771 free:
1772         kfree(mw);
1773         kfree(in);
1774         return ERR_PTR(err);
1775 }
1776
1777 int mlx5_ib_dealloc_mw(struct ib_mw *mw)
1778 {
1779         struct mlx5_ib_mw *mmw = to_mmw(mw);
1780         int err;
1781
1782         err =  mlx5_core_destroy_mkey((to_mdev(mw->device))->mdev,
1783                                       &mmw->mmkey);
1784         if (!err)
1785                 kfree(mmw);
1786         return err;
1787 }
1788
1789 int mlx5_ib_check_mr_status(struct ib_mr *ibmr, u32 check_mask,
1790                             struct ib_mr_status *mr_status)
1791 {
1792         struct mlx5_ib_mr *mmr = to_mmr(ibmr);
1793         int ret = 0;
1794
1795         if (check_mask & ~IB_MR_CHECK_SIG_STATUS) {
1796                 pr_err("Invalid status check mask\n");
1797                 ret = -EINVAL;
1798                 goto done;
1799         }
1800
1801         mr_status->fail_status = 0;
1802         if (check_mask & IB_MR_CHECK_SIG_STATUS) {
1803                 if (!mmr->sig) {
1804                         ret = -EINVAL;
1805                         pr_err("signature status check requested on a non-signature enabled MR\n");
1806                         goto done;
1807                 }
1808
1809                 mmr->sig->sig_status_checked = true;
1810                 if (!mmr->sig->sig_err_exists)
1811                         goto done;
1812
1813                 if (ibmr->lkey == mmr->sig->err_item.key)
1814                         memcpy(&mr_status->sig_err, &mmr->sig->err_item,
1815                                sizeof(mr_status->sig_err));
1816                 else {
1817                         mr_status->sig_err.err_type = IB_SIG_BAD_GUARD;
1818                         mr_status->sig_err.sig_err_offset = 0;
1819                         mr_status->sig_err.key = mmr->sig->err_item.key;
1820                 }
1821
1822                 mmr->sig->sig_err_exists = false;
1823                 mr_status->fail_status |= IB_MR_CHECK_SIG_STATUS;
1824         }
1825
1826 done:
1827         return ret;
1828 }
1829
1830 static int
1831 mlx5_ib_sg_to_klms(struct mlx5_ib_mr *mr,
1832                    struct scatterlist *sgl,
1833                    unsigned short sg_nents,
1834                    unsigned int *sg_offset_p)
1835 {
1836         struct scatterlist *sg = sgl;
1837         struct mlx5_klm *klms = mr->descs;
1838         unsigned int sg_offset = sg_offset_p ? *sg_offset_p : 0;
1839         u32 lkey = mr->ibmr.pd->local_dma_lkey;
1840         int i;
1841
1842         mr->ibmr.iova = sg_dma_address(sg) + sg_offset;
1843         mr->ibmr.length = 0;
1844
1845         for_each_sg(sgl, sg, sg_nents, i) {
1846                 if (unlikely(i >= mr->max_descs))
1847                         break;
1848                 klms[i].va = cpu_to_be64(sg_dma_address(sg) + sg_offset);
1849                 klms[i].bcount = cpu_to_be32(sg_dma_len(sg) - sg_offset);
1850                 klms[i].key = cpu_to_be32(lkey);
1851                 mr->ibmr.length += sg_dma_len(sg) - sg_offset;
1852
1853                 sg_offset = 0;
1854         }
1855         mr->ndescs = i;
1856
1857         if (sg_offset_p)
1858                 *sg_offset_p = sg_offset;
1859
1860         return i;
1861 }
1862
1863 static int mlx5_set_page(struct ib_mr *ibmr, u64 addr)
1864 {
1865         struct mlx5_ib_mr *mr = to_mmr(ibmr);
1866         __be64 *descs;
1867
1868         if (unlikely(mr->ndescs == mr->max_descs))
1869                 return -ENOMEM;
1870
1871         descs = mr->descs;
1872         descs[mr->ndescs++] = cpu_to_be64(addr | MLX5_EN_RD | MLX5_EN_WR);
1873
1874         return 0;
1875 }
1876
1877 int mlx5_ib_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,
1878                       unsigned int *sg_offset)
1879 {
1880         struct mlx5_ib_mr *mr = to_mmr(ibmr);
1881         int n;
1882
1883         mr->ndescs = 0;
1884
1885         ib_dma_sync_single_for_cpu(ibmr->device, mr->desc_map,
1886                                    mr->desc_size * mr->max_descs,
1887                                    DMA_TO_DEVICE);
1888
1889         if (mr->access_mode == MLX5_MKC_ACCESS_MODE_KLMS)
1890                 n = mlx5_ib_sg_to_klms(mr, sg, sg_nents, sg_offset);
1891         else
1892                 n = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset,
1893                                 mlx5_set_page);
1894
1895         ib_dma_sync_single_for_device(ibmr->device, mr->desc_map,
1896                                       mr->desc_size * mr->max_descs,
1897                                       DMA_TO_DEVICE);
1898
1899         return n;
1900 }