projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
IB/core: Enhance ib_map_mr_sg()
[deliverable/linux.git] / 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 umrwr.wr.wr_cqe = &umr_context.cqe;
896 prep_umr_reg_wqe(pd, &umrwr.wr, &sg, dma, npages, mr->mmkey.key,
897 page_shift, virt_addr, len, access_flags);
898
899 down(&umrc->sem);
900 err = ib_post_send(umrc->qp, &umrwr.wr, &bad);
901 if (err) {
902 mlx5_ib_warn(dev, "post send failed, err %d\n", err);
903 goto unmap_dma;
904 } else {
905 wait_for_completion(&umr_context.done);
906 if (umr_context.status != IB_WC_SUCCESS) {
907 mlx5_ib_warn(dev, "reg umr failed\n");
908 err = -EFAULT;
909 }
910 }
911
912 mr->mmkey.iova = virt_addr;
913 mr->mmkey.size = len;
914 mr->mmkey.pd = to_mpd(pd)->pdn;
915
916 mr->live = 1;
917
918 unmap_dma:
919 up(&umrc->sem);
920 dma_unmap_single(ddev, dma, size, DMA_TO_DEVICE);
921
922 kfree(mr_pas);
923
924 free_mr:
925 if (err) {
926 free_cached_mr(dev, mr);
927 return ERR_PTR(err);
928 }
929
930 return mr;
931 }
932
933 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
934 int mlx5_ib_update_mtt(struct mlx5_ib_mr *mr, u64 start_page_index, int npages,
935 int zap)
936 {
937 struct mlx5_ib_dev *dev = mr->dev;
938 struct device *ddev = dev->ib_dev.dma_device;
939 struct umr_common *umrc = &dev->umrc;
940 struct mlx5_ib_umr_context umr_context;
941 struct ib_umem *umem = mr->umem;
942 int size;
943 __be64 *pas;
944 dma_addr_t dma;
945 struct ib_send_wr *bad;
946 struct mlx5_umr_wr wr;
947 struct ib_sge sg;
948 int err = 0;
949 const int page_index_alignment = MLX5_UMR_MTT_ALIGNMENT / sizeof(u64);
950 const int page_index_mask = page_index_alignment - 1;
951 size_t pages_mapped = 0;
952 size_t pages_to_map = 0;
953 size_t pages_iter = 0;
954 int use_emergency_buf = 0;
955
956 /* UMR copies MTTs in units of MLX5_UMR_MTT_ALIGNMENT bytes,
957 * so we need to align the offset and length accordingly */
958 if (start_page_index & page_index_mask) {
959 npages += start_page_index & page_index_mask;
960 start_page_index &= ~page_index_mask;
961 }
962
963 pages_to_map = ALIGN(npages, page_index_alignment);
964
965 if (start_page_index + pages_to_map > MLX5_MAX_UMR_PAGES)
966 return -EINVAL;
967
968 size = sizeof(u64) * pages_to_map;
969 size = min_t(int, PAGE_SIZE, size);
970 /* We allocate with GFP_ATOMIC to avoid recursion into page-reclaim
971 * code, when we are called from an invalidation. The pas buffer must
972 * be 2k-aligned for Connect-IB. */
973 pas = (__be64 *)get_zeroed_page(GFP_ATOMIC);
974 if (!pas) {
975 mlx5_ib_warn(dev, "unable to allocate memory during MTT update, falling back to slower chunked mechanism.\n");
976 pas = mlx5_ib_update_mtt_emergency_buffer;
977 size = MLX5_UMR_MTT_MIN_CHUNK_SIZE;
978 use_emergency_buf = 1;
979 mutex_lock(&mlx5_ib_update_mtt_emergency_buffer_mutex);
980 memset(pas, 0, size);
981 }
982 pages_iter = size / sizeof(u64);
983 dma = dma_map_single(ddev, pas, size, DMA_TO_DEVICE);
984 if (dma_mapping_error(ddev, dma)) {
985 mlx5_ib_err(dev, "unable to map DMA during MTT update.\n");
986 err = -ENOMEM;
987 goto free_pas;
988 }
989
990 for (pages_mapped = 0;
991 pages_mapped < pages_to_map && !err;
992 pages_mapped += pages_iter, start_page_index += pages_iter) {
993 dma_sync_single_for_cpu(ddev, dma, size, DMA_TO_DEVICE);
994
995 npages = min_t(size_t,
996 pages_iter,
997 ib_umem_num_pages(umem) - start_page_index);
998
999 if (!zap) {
1000 __mlx5_ib_populate_pas(dev, umem, PAGE_SHIFT,
1001 start_page_index, npages, pas,
1002 MLX5_IB_MTT_PRESENT);
1003 /* Clear padding after the pages brought from the
1004 * umem. */
1005 memset(pas + npages, 0, size - npages * sizeof(u64));
1006 }
1007
1008 dma_sync_single_for_device(ddev, dma, size, DMA_TO_DEVICE);
1009
1010 mlx5_ib_init_umr_context(&umr_context);
1011
1012 memset(&wr, 0, sizeof(wr));
1013 wr.wr.wr_cqe = &umr_context.cqe;
1014
1015 sg.addr = dma;
1016 sg.length = ALIGN(npages * sizeof(u64),
1017 MLX5_UMR_MTT_ALIGNMENT);
1018 sg.lkey = dev->umrc.pd->local_dma_lkey;
1019
1020 wr.wr.send_flags = MLX5_IB_SEND_UMR_FAIL_IF_FREE |
1021 MLX5_IB_SEND_UMR_UPDATE_MTT;
1022 wr.wr.sg_list = &sg;
1023 wr.wr.num_sge = 1;
1024 wr.wr.opcode = MLX5_IB_WR_UMR;
1025 wr.npages = sg.length / sizeof(u64);
1026 wr.page_shift = PAGE_SHIFT;
1027 wr.mkey = mr->mmkey.key;
1028 wr.target.offset = start_page_index;
1029
1030 down(&umrc->sem);
1031 err = ib_post_send(umrc->qp, &wr.wr, &bad);
1032 if (err) {
1033 mlx5_ib_err(dev, "UMR post send failed, err %d\n", err);
1034 } else {
1035 wait_for_completion(&umr_context.done);
1036 if (umr_context.status != IB_WC_SUCCESS) {
1037 mlx5_ib_err(dev, "UMR completion failed, code %d\n",
1038 umr_context.status);
1039 err = -EFAULT;
1040 }
1041 }
1042 up(&umrc->sem);
1043 }
1044 dma_unmap_single(ddev, dma, size, DMA_TO_DEVICE);
1045
1046 free_pas:
1047 if (!use_emergency_buf)
1048 free_page((unsigned long)pas);
1049 else
1050 mutex_unlock(&mlx5_ib_update_mtt_emergency_buffer_mutex);
1051
1052 return err;
1053 }
1054 #endif
1055
1056 /*
1057 * If ibmr is NULL it will be allocated by reg_create.
1058 * Else, the given ibmr will be used.
1059 */
1060 static struct mlx5_ib_mr *reg_create(struct ib_mr *ibmr, struct ib_pd *pd,
1061 u64 virt_addr, u64 length,
1062 struct ib_umem *umem, int npages,
1063 int page_shift, int access_flags)
1064 {
1065 struct mlx5_ib_dev *dev = to_mdev(pd->device);
1066 struct mlx5_create_mkey_mbox_in *in;
1067 struct mlx5_ib_mr *mr;
1068 int inlen;
1069 int err;
1070 bool pg_cap = !!(MLX5_CAP_GEN(dev->mdev, pg));
1071
1072 mr = ibmr ? to_mmr(ibmr) : kzalloc(sizeof(*mr), GFP_KERNEL);
1073 if (!mr)
1074 return ERR_PTR(-ENOMEM);
1075
1076 inlen = sizeof(*in) + sizeof(*in->pas) * ((npages + 1) / 2) * 2;
1077 in = mlx5_vzalloc(inlen);
1078 if (!in) {
1079 err = -ENOMEM;
1080 goto err_1;
1081 }
1082 mlx5_ib_populate_pas(dev, umem, page_shift, in->pas,
1083 pg_cap ? MLX5_IB_MTT_PRESENT : 0);
1084
1085 /* The MLX5_MKEY_INBOX_PG_ACCESS bit allows setting the access flags
1086 * in the page list submitted with the command. */
1087 in->flags = pg_cap ? cpu_to_be32(MLX5_MKEY_INBOX_PG_ACCESS) : 0;
1088 in->seg.flags = convert_access(access_flags) |
1089 MLX5_ACCESS_MODE_MTT;
1090 in->seg.flags_pd = cpu_to_be32(to_mpd(pd)->pdn);
1091 in->seg.start_addr = cpu_to_be64(virt_addr);
1092 in->seg.len = cpu_to_be64(length);
1093 in->seg.bsfs_octo_size = 0;
1094 in->seg.xlt_oct_size = cpu_to_be32(get_octo_len(virt_addr, length, 1 << page_shift));
1095 in->seg.log2_page_size = page_shift;
1096 in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8);
1097 in->xlat_oct_act_size = cpu_to_be32(get_octo_len(virt_addr, length,
1098 1 << page_shift));
1099 err = mlx5_core_create_mkey(dev->mdev, &mr->mmkey, in, inlen, NULL,
1100 NULL, NULL);
1101 if (err) {
1102 mlx5_ib_warn(dev, "create mkey failed\n");
1103 goto err_2;
1104 }
1105 mr->umem = umem;
1106 mr->dev = dev;
1107 mr->live = 1;
1108 kvfree(in);
1109
1110 mlx5_ib_dbg(dev, "mkey = 0x%x\n", mr->mmkey.key);
1111
1112 return mr;
1113
1114 err_2:
1115 kvfree(in);
1116
1117 err_1:
1118 if (!ibmr)
1119 kfree(mr);
1120
1121 return ERR_PTR(err);
1122 }
1123
1124 static void set_mr_fileds(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr,
1125 int npages, u64 length, int access_flags)
1126 {
1127 mr->npages = npages;
1128 atomic_add(npages, &dev->mdev->priv.reg_pages);
1129 mr->ibmr.lkey = mr->mmkey.key;
1130 mr->ibmr.rkey = mr->mmkey.key;
1131 mr->ibmr.length = length;
1132 mr->access_flags = access_flags;
1133 }
1134
1135 struct ib_mr *mlx5_ib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
1136 u64 virt_addr, int access_flags,
1137 struct ib_udata *udata)
1138 {
1139 struct mlx5_ib_dev *dev = to_mdev(pd->device);
1140 struct mlx5_ib_mr *mr = NULL;
1141 struct ib_umem *umem;
1142 int page_shift;
1143 int npages;
1144 int ncont;
1145 int order;
1146 int err;
1147
1148 mlx5_ib_dbg(dev, "start 0x%llx, virt_addr 0x%llx, length 0x%llx, access_flags 0x%x\n",
1149 start, virt_addr, length, access_flags);
1150 umem = mr_umem_get(pd, start, length, access_flags, &npages,
1151 &page_shift, &ncont, &order);
1152
1153 if (IS_ERR(umem))
1154 return (void *)umem;
1155
1156 if (use_umr(order)) {
1157 mr = reg_umr(pd, umem, virt_addr, length, ncont, page_shift,
1158 order, access_flags);
1159 if (PTR_ERR(mr) == -EAGAIN) {
1160 mlx5_ib_dbg(dev, "cache empty for order %d", order);
1161 mr = NULL;
1162 }
1163 } else if (access_flags & IB_ACCESS_ON_DEMAND) {
1164 err = -EINVAL;
1165 pr_err("Got MR registration for ODP MR > 512MB, not supported for Connect-IB");
1166 goto error;
1167 }
1168
1169 if (!mr)
1170 mr = reg_create(NULL, pd, virt_addr, length, umem, ncont,
1171 page_shift, access_flags);
1172
1173 if (IS_ERR(mr)) {
1174 err = PTR_ERR(mr);
1175 goto error;
1176 }
1177
1178 mlx5_ib_dbg(dev, "mkey 0x%x\n", mr->mmkey.key);
1179
1180 mr->umem = umem;
1181 set_mr_fileds(dev, mr, npages, length, access_flags);
1182
1183 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
1184 update_odp_mr(mr);
1185 #endif
1186
1187 return &mr->ibmr;
1188
1189 error:
1190 ib_umem_release(umem);
1191 return ERR_PTR(err);
1192 }
1193
1194 static int unreg_umr(struct mlx5_ib_dev *dev, struct mlx5_ib_mr *mr)
1195 {
1196 struct umr_common *umrc = &dev->umrc;
1197 struct mlx5_ib_umr_context umr_context;
1198 struct mlx5_umr_wr umrwr = {};
1199 struct ib_send_wr *bad;
1200 int err;
1201
1202 mlx5_ib_init_umr_context(&umr_context);
1203
1204 umrwr.wr.wr_cqe = &umr_context.cqe;
1205 prep_umr_unreg_wqe(dev, &umrwr.wr, mr->mmkey.key);
1206
1207 down(&umrc->sem);
1208 err = ib_post_send(umrc->qp, &umrwr.wr, &bad);
1209 if (err) {
1210 up(&umrc->sem);
1211 mlx5_ib_dbg(dev, "err %d\n", err);
1212 goto error;
1213 } else {
1214 wait_for_completion(&umr_context.done);
1215 up(&umrc->sem);
1216 }
1217 if (umr_context.status != IB_WC_SUCCESS) {
1218 mlx5_ib_warn(dev, "unreg umr failed\n");
1219 err = -EFAULT;
1220 goto error;
1221 }
1222 return 0;
1223
1224 error:
1225 return err;
1226 }
1227
1228 static int rereg_umr(struct ib_pd *pd, struct mlx5_ib_mr *mr, u64 virt_addr,
1229 u64 length, int npages, int page_shift, int order,
1230 int access_flags, int flags)
1231 {
1232 struct mlx5_ib_dev *dev = to_mdev(pd->device);
1233 struct device *ddev = dev->ib_dev.dma_device;
1234 struct mlx5_ib_umr_context umr_context;
1235 struct ib_send_wr *bad;
1236 struct mlx5_umr_wr umrwr = {};
1237 struct ib_sge sg;
1238 struct umr_common *umrc = &dev->umrc;
1239 dma_addr_t dma = 0;
1240 __be64 *mr_pas = NULL;
1241 int size;
1242 int err;
1243
1244 mlx5_ib_init_umr_context(&umr_context);
1245
1246 umrwr.wr.wr_cqe = &umr_context.cqe;
1247 umrwr.wr.send_flags = MLX5_IB_SEND_UMR_FAIL_IF_FREE;
1248
1249 if (flags & IB_MR_REREG_TRANS) {
1250 err = dma_map_mr_pas(dev, mr->umem, npages, page_shift, &size,
1251 &mr_pas, &dma);
1252 if (err)
1253 return err;
1254
1255 umrwr.target.virt_addr = virt_addr;
1256 umrwr.length = length;
1257 umrwr.wr.send_flags |= MLX5_IB_SEND_UMR_UPDATE_TRANSLATION;
1258 }
1259
1260 prep_umr_wqe_common(pd, &umrwr.wr, &sg, dma, npages, mr->mmkey.key,
1261 page_shift);
1262
1263 if (flags & IB_MR_REREG_PD) {
1264 umrwr.pd = pd;
1265 umrwr.wr.send_flags |= MLX5_IB_SEND_UMR_UPDATE_PD;
1266 }
1267
1268 if (flags & IB_MR_REREG_ACCESS) {
1269 umrwr.access_flags = access_flags;
1270 umrwr.wr.send_flags |= MLX5_IB_SEND_UMR_UPDATE_ACCESS;
1271 }
1272
1273 /* post send request to UMR QP */
1274 down(&umrc->sem);
1275 err = ib_post_send(umrc->qp, &umrwr.wr, &bad);
1276
1277 if (err) {
1278 mlx5_ib_warn(dev, "post send failed, err %d\n", err);
1279 } else {
1280 wait_for_completion(&umr_context.done);
1281 if (umr_context.status != IB_WC_SUCCESS) {
1282 mlx5_ib_warn(dev, "reg umr failed (%u)\n",
1283 umr_context.status);
1284 err = -EFAULT;
1285 }
1286 }
1287
1288 up(&umrc->sem);
1289 if (flags & IB_MR_REREG_TRANS) {
1290 dma_unmap_single(ddev, dma, size, DMA_TO_DEVICE);
1291 kfree(mr_pas);
1292 }
1293 return err;
1294 }
1295
1296 int mlx5_ib_rereg_user_mr(struct ib_mr *ib_mr, int flags, u64 start,
1297 u64 length, u64 virt_addr, int new_access_flags,
1298 struct ib_pd *new_pd, struct ib_udata *udata)
1299 {
1300 struct mlx5_ib_dev *dev = to_mdev(ib_mr->device);
1301 struct mlx5_ib_mr *mr = to_mmr(ib_mr);
1302 struct ib_pd *pd = (flags & IB_MR_REREG_PD) ? new_pd : ib_mr->pd;
1303 int access_flags = flags & IB_MR_REREG_ACCESS ?
1304 new_access_flags :
1305 mr->access_flags;
1306 u64 addr = (flags & IB_MR_REREG_TRANS) ? virt_addr : mr->umem->address;
1307 u64 len = (flags & IB_MR_REREG_TRANS) ? length : mr->umem->length;
1308 int page_shift = 0;
1309 int npages = 0;
1310 int ncont = 0;
1311 int order = 0;
1312 int err;
1313
1314 mlx5_ib_dbg(dev, "start 0x%llx, virt_addr 0x%llx, length 0x%llx, access_flags 0x%x\n",
1315 start, virt_addr, length, access_flags);
1316
1317 if (flags != IB_MR_REREG_PD) {
1318 /*
1319 * Replace umem. This needs to be done whether or not UMR is
1320 * used.
1321 */
1322 flags |= IB_MR_REREG_TRANS;
1323 ib_umem_release(mr->umem);
1324 mr->umem = mr_umem_get(pd, addr, len, access_flags, &npages,
1325 &page_shift, &ncont, &order);
1326 if (IS_ERR(mr->umem)) {
1327 err = PTR_ERR(mr->umem);
1328 mr->umem = NULL;
1329 return err;
1330 }
1331 }
1332
1333 if (flags & IB_MR_REREG_TRANS && !use_umr_mtt_update(mr, addr, len)) {
1334 /*
1335 * UMR can't be used - MKey needs to be replaced.
1336 */
1337 if (mr->umred) {
1338 err = unreg_umr(dev, mr);
1339 if (err)
1340 mlx5_ib_warn(dev, "Failed to unregister MR\n");
1341 } else {
1342 err = destroy_mkey(dev, mr);
1343 if (err)
1344 mlx5_ib_warn(dev, "Failed to destroy MKey\n");
1345 }
1346 if (err)
1347 return err;
1348
1349 mr = reg_create(ib_mr, pd, addr, len, mr->umem, ncont,
1350 page_shift, access_flags);
1351
1352 if (IS_ERR(mr))
1353 return PTR_ERR(mr);
1354
1355 mr->umred = 0;
1356 } else {
1357 /*
1358 * Send a UMR WQE
1359 */
1360 err = rereg_umr(pd, mr, addr, len, npages, page_shift,
1361 order, access_flags, flags);
1362 if (err) {
1363 mlx5_ib_warn(dev, "Failed to rereg UMR\n");
1364 return err;
1365 }
1366 }
1367
1368 if (flags & IB_MR_REREG_PD) {
1369 ib_mr->pd = pd;
1370 mr->mmkey.pd = to_mpd(pd)->pdn;
1371 }
1372
1373 if (flags & IB_MR_REREG_ACCESS)
1374 mr->access_flags = access_flags;
1375
1376 if (flags & IB_MR_REREG_TRANS) {
1377 atomic_sub(mr->npages, &dev->mdev->priv.reg_pages);
1378 set_mr_fileds(dev, mr, npages, len, access_flags);
1379 mr->mmkey.iova = addr;
1380 mr->mmkey.size = len;
1381 }
1382 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
1383 update_odp_mr(mr);
1384 #endif
1385
1386 return 0;
1387 }
1388
1389 static int
1390 mlx5_alloc_priv_descs(struct ib_device *device,
1391 struct mlx5_ib_mr *mr,
1392 int ndescs,
1393 int desc_size)
1394 {
1395 int size = ndescs * desc_size;
1396 int add_size;
1397 int ret;
1398
1399 add_size = max_t(int, MLX5_UMR_ALIGN - ARCH_KMALLOC_MINALIGN, 0);
1400
1401 mr->descs_alloc = kzalloc(size + add_size, GFP_KERNEL);
1402 if (!mr->descs_alloc)
1403 return -ENOMEM;
1404
1405 mr->descs = PTR_ALIGN(mr->descs_alloc, MLX5_UMR_ALIGN);
1406
1407 mr->desc_map = dma_map_single(device->dma_device, mr->descs,
1408 size, DMA_TO_DEVICE);
1409 if (dma_mapping_error(device->dma_device, mr->desc_map)) {
1410 ret = -ENOMEM;
1411 goto err;
1412 }
1413
1414 return 0;
1415 err:
1416 kfree(mr->descs_alloc);
1417
1418 return ret;
1419 }
1420
1421 static void
1422 mlx5_free_priv_descs(struct mlx5_ib_mr *mr)
1423 {
1424 if (mr->descs) {
1425 struct ib_device *device = mr->ibmr.device;
1426 int size = mr->max_descs * mr->desc_size;
1427
1428 dma_unmap_single(device->dma_device, mr->desc_map,
1429 size, DMA_TO_DEVICE);
1430 kfree(mr->descs_alloc);
1431 mr->descs = NULL;
1432 }
1433 }
1434
1435 static int clean_mr(struct mlx5_ib_mr *mr)
1436 {
1437 struct mlx5_ib_dev *dev = to_mdev(mr->ibmr.device);
1438 int umred = mr->umred;
1439 int err;
1440
1441 if (mr->sig) {
1442 if (mlx5_core_destroy_psv(dev->mdev,
1443 mr->sig->psv_memory.psv_idx))
1444 mlx5_ib_warn(dev, "failed to destroy mem psv %d\n",
1445 mr->sig->psv_memory.psv_idx);
1446 if (mlx5_core_destroy_psv(dev->mdev,
1447 mr->sig->psv_wire.psv_idx))
1448 mlx5_ib_warn(dev, "failed to destroy wire psv %d\n",
1449 mr->sig->psv_wire.psv_idx);
1450 kfree(mr->sig);
1451 mr->sig = NULL;
1452 }
1453
1454 mlx5_free_priv_descs(mr);
1455
1456 if (!umred) {
1457 err = destroy_mkey(dev, mr);
1458 if (err) {
1459 mlx5_ib_warn(dev, "failed to destroy mkey 0x%x (%d)\n",
1460 mr->mmkey.key, err);
1461 return err;
1462 }
1463 } else {
1464 err = unreg_umr(dev, mr);
1465 if (err) {
1466 mlx5_ib_warn(dev, "failed unregister\n");
1467 return err;
1468 }
1469 free_cached_mr(dev, mr);
1470 }
1471
1472 if (!umred)
1473 kfree(mr);
1474
1475 return 0;
1476 }
1477
1478 int mlx5_ib_dereg_mr(struct ib_mr *ibmr)
1479 {
1480 struct mlx5_ib_dev *dev = to_mdev(ibmr->device);
1481 struct mlx5_ib_mr *mr = to_mmr(ibmr);
1482 int npages = mr->npages;
1483 struct ib_umem *umem = mr->umem;
1484
1485 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
1486 if (umem && umem->odp_data) {
1487 /* Prevent new page faults from succeeding */
1488 mr->live = 0;
1489 /* Wait for all running page-fault handlers to finish. */
1490 synchronize_srcu(&dev->mr_srcu);
1491 /* Destroy all page mappings */
1492 mlx5_ib_invalidate_range(umem, ib_umem_start(umem),
1493 ib_umem_end(umem));
1494 /*
1495 * We kill the umem before the MR for ODP,
1496 * so that there will not be any invalidations in
1497 * flight, looking at the *mr struct.
1498 */
1499 ib_umem_release(umem);
1500 atomic_sub(npages, &dev->mdev->priv.reg_pages);
1501
1502 /* Avoid double-freeing the umem. */
1503 umem = NULL;
1504 }
1505 #endif
1506
1507 clean_mr(mr);
1508
1509 if (umem) {
1510 ib_umem_release(umem);
1511 atomic_sub(npages, &dev->mdev->priv.reg_pages);
1512 }
1513
1514 return 0;
1515 }
1516
1517 struct ib_mr *mlx5_ib_alloc_mr(struct ib_pd *pd,
1518 enum ib_mr_type mr_type,
1519 u32 max_num_sg)
1520 {
1521 struct mlx5_ib_dev *dev = to_mdev(pd->device);
1522 struct mlx5_create_mkey_mbox_in *in;
1523 struct mlx5_ib_mr *mr;
1524 int ndescs = ALIGN(max_num_sg, 4);
1525 int err;
1526
1527 mr = kzalloc(sizeof(*mr), GFP_KERNEL);
1528 if (!mr)
1529 return ERR_PTR(-ENOMEM);
1530
1531 in = kzalloc(sizeof(*in), GFP_KERNEL);
1532 if (!in) {
1533 err = -ENOMEM;
1534 goto err_free;
1535 }
1536
1537 in->seg.status = MLX5_MKEY_STATUS_FREE;
1538 in->seg.xlt_oct_size = cpu_to_be32(ndescs);
1539 in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8);
1540 in->seg.flags_pd = cpu_to_be32(to_mpd(pd)->pdn);
1541
1542 if (mr_type == IB_MR_TYPE_MEM_REG) {
1543 mr->access_mode = MLX5_ACCESS_MODE_MTT;
1544 in->seg.log2_page_size = PAGE_SHIFT;
1545
1546 err = mlx5_alloc_priv_descs(pd->device, mr,
1547 ndescs, sizeof(u64));
1548 if (err)
1549 goto err_free_in;
1550
1551 mr->desc_size = sizeof(u64);
1552 mr->max_descs = ndescs;
1553 } else if (mr_type == IB_MR_TYPE_SG_GAPS) {
1554 mr->access_mode = MLX5_ACCESS_MODE_KLM;
1555
1556 err = mlx5_alloc_priv_descs(pd->device, mr,
1557 ndescs, sizeof(struct mlx5_klm));
1558 if (err)
1559 goto err_free_in;
1560 mr->desc_size = sizeof(struct mlx5_klm);
1561 mr->max_descs = ndescs;
1562 } else if (mr_type == IB_MR_TYPE_SIGNATURE) {
1563 u32 psv_index[2];
1564
1565 in->seg.flags_pd = cpu_to_be32(be32_to_cpu(in->seg.flags_pd) |
1566 MLX5_MKEY_BSF_EN);
1567 in->seg.bsfs_octo_size = cpu_to_be32(MLX5_MKEY_BSF_OCTO_SIZE);
1568 mr->sig = kzalloc(sizeof(*mr->sig), GFP_KERNEL);
1569 if (!mr->sig) {
1570 err = -ENOMEM;
1571 goto err_free_in;
1572 }
1573
1574 /* create mem & wire PSVs */
1575 err = mlx5_core_create_psv(dev->mdev, to_mpd(pd)->pdn,
1576 2, psv_index);
1577 if (err)
1578 goto err_free_sig;
1579
1580 mr->access_mode = MLX5_ACCESS_MODE_KLM;
1581 mr->sig->psv_memory.psv_idx = psv_index[0];
1582 mr->sig->psv_wire.psv_idx = psv_index[1];
1583
1584 mr->sig->sig_status_checked = true;
1585 mr->sig->sig_err_exists = false;
1586 /* Next UMR, Arm SIGERR */
1587 ++mr->sig->sigerr_count;
1588 } else {
1589 mlx5_ib_warn(dev, "Invalid mr type %d\n", mr_type);
1590 err = -EINVAL;
1591 goto err_free_in;
1592 }
1593
1594 in->seg.flags = MLX5_PERM_UMR_EN | mr->access_mode;
1595 err = mlx5_core_create_mkey(dev->mdev, &mr->mmkey, in, sizeof(*in),
1596 NULL, NULL, NULL);
1597 if (err)
1598 goto err_destroy_psv;
1599
1600 mr->ibmr.lkey = mr->mmkey.key;
1601 mr->ibmr.rkey = mr->mmkey.key;
1602 mr->umem = NULL;
1603 kfree(in);
1604
1605 return &mr->ibmr;
1606
1607 err_destroy_psv:
1608 if (mr->sig) {
1609 if (mlx5_core_destroy_psv(dev->mdev,
1610 mr->sig->psv_memory.psv_idx))
1611 mlx5_ib_warn(dev, "failed to destroy mem psv %d\n",
1612 mr->sig->psv_memory.psv_idx);
1613 if (mlx5_core_destroy_psv(dev->mdev,
1614 mr->sig->psv_wire.psv_idx))
1615 mlx5_ib_warn(dev, "failed to destroy wire psv %d\n",
1616 mr->sig->psv_wire.psv_idx);
1617 }
1618 mlx5_free_priv_descs(mr);
1619 err_free_sig:
1620 kfree(mr->sig);
1621 err_free_in:
1622 kfree(in);
1623 err_free:
1624 kfree(mr);
1625 return ERR_PTR(err);
1626 }
1627
1628 struct ib_mw *mlx5_ib_alloc_mw(struct ib_pd *pd, enum ib_mw_type type,
1629 struct ib_udata *udata)
1630 {
1631 struct mlx5_ib_dev *dev = to_mdev(pd->device);
1632 struct mlx5_create_mkey_mbox_in *in = NULL;
1633 struct mlx5_ib_mw *mw = NULL;
1634 int ndescs;
1635 int err;
1636 struct mlx5_ib_alloc_mw req = {};
1637 struct {
1638 __u32 comp_mask;
1639 __u32 response_length;
1640 } resp = {};
1641
1642 err = ib_copy_from_udata(&req, udata, min(udata->inlen, sizeof(req)));
1643 if (err)
1644 return ERR_PTR(err);
1645
1646 if (req.comp_mask || req.reserved1 || req.reserved2)
1647 return ERR_PTR(-EOPNOTSUPP);
1648
1649 if (udata->inlen > sizeof(req) &&
1650 !ib_is_udata_cleared(udata, sizeof(req),
1651 udata->inlen - sizeof(req)))
1652 return ERR_PTR(-EOPNOTSUPP);
1653
1654 ndescs = req.num_klms ? roundup(req.num_klms, 4) : roundup(1, 4);
1655
1656 mw = kzalloc(sizeof(*mw), GFP_KERNEL);
1657 in = kzalloc(sizeof(*in), GFP_KERNEL);
1658 if (!mw || !in) {
1659 err = -ENOMEM;
1660 goto free;
1661 }
1662
1663 in->seg.status = MLX5_MKEY_STATUS_FREE;
1664 in->seg.xlt_oct_size = cpu_to_be32(ndescs);
1665 in->seg.flags_pd = cpu_to_be32(to_mpd(pd)->pdn);
1666 in->seg.flags = MLX5_PERM_UMR_EN | MLX5_ACCESS_MODE_KLM |
1667 MLX5_PERM_LOCAL_READ;
1668 if (type == IB_MW_TYPE_2)
1669 in->seg.flags_pd |= cpu_to_be32(MLX5_MKEY_REMOTE_INVAL);
1670 in->seg.qpn_mkey7_0 = cpu_to_be32(0xffffff << 8);
1671
1672 err = mlx5_core_create_mkey(dev->mdev, &mw->mmkey, in, sizeof(*in),
1673 NULL, NULL, NULL);
1674 if (err)
1675 goto free;
1676
1677 mw->ibmw.rkey = mw->mmkey.key;
1678
1679 resp.response_length = min(offsetof(typeof(resp), response_length) +
1680 sizeof(resp.response_length), udata->outlen);
1681 if (resp.response_length) {
1682 err = ib_copy_to_udata(udata, &resp, resp.response_length);
1683 if (err) {
1684 mlx5_core_destroy_mkey(dev->mdev, &mw->mmkey);
1685 goto free;
1686 }
1687 }
1688
1689 kfree(in);
1690 return &mw->ibmw;
1691
1692 free:
1693 kfree(mw);
1694 kfree(in);
1695 return ERR_PTR(err);
1696 }
1697
1698 int mlx5_ib_dealloc_mw(struct ib_mw *mw)
1699 {
1700 struct mlx5_ib_mw *mmw = to_mmw(mw);
1701 int err;
1702
1703 err = mlx5_core_destroy_mkey((to_mdev(mw->device))->mdev,
1704 &mmw->mmkey);
1705 if (!err)
1706 kfree(mmw);
1707 return err;
1708 }
1709
1710 int mlx5_ib_check_mr_status(struct ib_mr *ibmr, u32 check_mask,
1711 struct ib_mr_status *mr_status)
1712 {
1713 struct mlx5_ib_mr *mmr = to_mmr(ibmr);
1714 int ret = 0;
1715
1716 if (check_mask & ~IB_MR_CHECK_SIG_STATUS) {
1717 pr_err("Invalid status check mask\n");
1718 ret = -EINVAL;
1719 goto done;
1720 }
1721
1722 mr_status->fail_status = 0;
1723 if (check_mask & IB_MR_CHECK_SIG_STATUS) {
1724 if (!mmr->sig) {
1725 ret = -EINVAL;
1726 pr_err("signature status check requested on a non-signature enabled MR\n");
1727 goto done;
1728 }
1729
1730 mmr->sig->sig_status_checked = true;
1731 if (!mmr->sig->sig_err_exists)
1732 goto done;
1733
1734 if (ibmr->lkey == mmr->sig->err_item.key)
1735 memcpy(&mr_status->sig_err, &mmr->sig->err_item,
1736 sizeof(mr_status->sig_err));
1737 else {
1738 mr_status->sig_err.err_type = IB_SIG_BAD_GUARD;
1739 mr_status->sig_err.sig_err_offset = 0;
1740 mr_status->sig_err.key = mmr->sig->err_item.key;
1741 }
1742
1743 mmr->sig->sig_err_exists = false;
1744 mr_status->fail_status |= IB_MR_CHECK_SIG_STATUS;
1745 }
1746
1747 done:
1748 return ret;
1749 }
1750
1751 static int
1752 mlx5_ib_sg_to_klms(struct mlx5_ib_mr *mr,
1753 struct scatterlist *sgl,
1754 unsigned short sg_nents,
1755 unsigned int *sg_offset_p)
1756 {
1757 struct scatterlist *sg = sgl;
1758 struct mlx5_klm *klms = mr->descs;
1759 unsigned int sg_offset = sg_offset_p ? *sg_offset_p : 0;
1760 u32 lkey = mr->ibmr.pd->local_dma_lkey;
1761 int i;
1762
1763 mr->ibmr.iova = sg_dma_address(sg) + sg_offset;
1764 mr->ibmr.length = 0;
1765 mr->ndescs = sg_nents;
1766
1767 for_each_sg(sgl, sg, sg_nents, i) {
1768 if (unlikely(i > mr->max_descs))
1769 break;
1770 klms[i].va = cpu_to_be64(sg_dma_address(sg) + sg_offset);
1771 klms[i].bcount = cpu_to_be32(sg_dma_len(sg) - sg_offset);
1772 klms[i].key = cpu_to_be32(lkey);
1773 mr->ibmr.length += sg_dma_len(sg);
1774
1775 sg_offset = 0;
1776 }
1777
1778 if (sg_offset_p)
1779 *sg_offset_p = sg_offset;
1780
1781 return i;
1782 }
1783
1784 static int mlx5_set_page(struct ib_mr *ibmr, u64 addr)
1785 {
1786 struct mlx5_ib_mr *mr = to_mmr(ibmr);
1787 __be64 *descs;
1788
1789 if (unlikely(mr->ndescs == mr->max_descs))
1790 return -ENOMEM;
1791
1792 descs = mr->descs;
1793 descs[mr->ndescs++] = cpu_to_be64(addr | MLX5_EN_RD | MLX5_EN_WR);
1794
1795 return 0;
1796 }
1797
1798 int mlx5_ib_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,
1799 unsigned int *sg_offset)
1800 {
1801 struct mlx5_ib_mr *mr = to_mmr(ibmr);
1802 int n;
1803
1804 mr->ndescs = 0;
1805
1806 ib_dma_sync_single_for_cpu(ibmr->device, mr->desc_map,
1807 mr->desc_size * mr->max_descs,
1808 DMA_TO_DEVICE);
1809
1810 if (mr->access_mode == MLX5_ACCESS_MODE_KLM)
1811 n = mlx5_ib_sg_to_klms(mr, sg, sg_nents, sg_offset);
1812 else
1813 n = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset,
1814 mlx5_set_page);
1815
1816 ib_dma_sync_single_for_device(ibmr->device, mr->desc_map,
1817 mr->desc_size * mr->max_descs,
1818 DMA_TO_DEVICE);
1819
1820 return n;
1821 }
Linux kernel - Deliverables
This page took 0.071894 seconds and 5 git commands to generate.