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