GNU Linux-libre 4.9.287-gnu1
[releases.git] / drivers / infiniband / hw / mlx4 / mr.c
1 /*
2  * Copyright (c) 2007 Cisco Systems, Inc. All rights reserved.
3  * Copyright (c) 2007, 2008 Mellanox Technologies. All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *        copyright notice, this list of conditions and the following
17  *        disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer in the documentation and/or other materials
22  *        provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33
34 #include <linux/slab.h>
35 #include <rdma/ib_user_verbs.h>
36
37 #include "mlx4_ib.h"
38
39 static u32 convert_access(int acc)
40 {
41         return (acc & IB_ACCESS_REMOTE_ATOMIC ? MLX4_PERM_ATOMIC       : 0) |
42                (acc & IB_ACCESS_REMOTE_WRITE  ? MLX4_PERM_REMOTE_WRITE : 0) |
43                (acc & IB_ACCESS_REMOTE_READ   ? MLX4_PERM_REMOTE_READ  : 0) |
44                (acc & IB_ACCESS_LOCAL_WRITE   ? MLX4_PERM_LOCAL_WRITE  : 0) |
45                (acc & IB_ACCESS_MW_BIND       ? MLX4_PERM_BIND_MW      : 0) |
46                MLX4_PERM_LOCAL_READ;
47 }
48
49 static enum mlx4_mw_type to_mlx4_type(enum ib_mw_type type)
50 {
51         switch (type) {
52         case IB_MW_TYPE_1:      return MLX4_MW_TYPE_1;
53         case IB_MW_TYPE_2:      return MLX4_MW_TYPE_2;
54         default:                return -1;
55         }
56 }
57
58 struct ib_mr *mlx4_ib_get_dma_mr(struct ib_pd *pd, int acc)
59 {
60         struct mlx4_ib_mr *mr;
61         int err;
62
63         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
64         if (!mr)
65                 return ERR_PTR(-ENOMEM);
66
67         err = mlx4_mr_alloc(to_mdev(pd->device)->dev, to_mpd(pd)->pdn, 0,
68                             ~0ull, convert_access(acc), 0, 0, &mr->mmr);
69         if (err)
70                 goto err_free;
71
72         err = mlx4_mr_enable(to_mdev(pd->device)->dev, &mr->mmr);
73         if (err)
74                 goto err_mr;
75
76         mr->ibmr.rkey = mr->ibmr.lkey = mr->mmr.key;
77         mr->umem = NULL;
78
79         return &mr->ibmr;
80
81 err_mr:
82         (void) mlx4_mr_free(to_mdev(pd->device)->dev, &mr->mmr);
83
84 err_free:
85         kfree(mr);
86
87         return ERR_PTR(err);
88 }
89
90 int mlx4_ib_umem_write_mtt(struct mlx4_ib_dev *dev, struct mlx4_mtt *mtt,
91                            struct ib_umem *umem)
92 {
93         u64 *pages;
94         int i, k, entry;
95         int n;
96         int len;
97         int err = 0;
98         struct scatterlist *sg;
99
100         pages = (u64 *) __get_free_page(GFP_KERNEL);
101         if (!pages)
102                 return -ENOMEM;
103
104         i = n = 0;
105
106         for_each_sg(umem->sg_head.sgl, sg, umem->nmap, entry) {
107                 len = sg_dma_len(sg) >> mtt->page_shift;
108                 for (k = 0; k < len; ++k) {
109                         pages[i++] = sg_dma_address(sg) +
110                                 umem->page_size * k;
111                         /*
112                          * Be friendly to mlx4_write_mtt() and
113                          * pass it chunks of appropriate size.
114                          */
115                         if (i == PAGE_SIZE / sizeof (u64)) {
116                                 err = mlx4_write_mtt(dev->dev, mtt, n,
117                                                      i, pages);
118                                 if (err)
119                                         goto out;
120                                 n += i;
121                                 i = 0;
122                         }
123                 }
124         }
125
126         if (i)
127                 err = mlx4_write_mtt(dev->dev, mtt, n, i, pages);
128
129 out:
130         free_page((unsigned long) pages);
131         return err;
132 }
133
134 static struct ib_umem *mlx4_get_umem_mr(struct ib_ucontext *context, u64 start,
135                                         u64 length, u64 virt_addr,
136                                         int access_flags)
137 {
138         /*
139          * Force registering the memory as writable if the underlying pages
140          * are writable.  This is so rereg can change the access permissions
141          * from readable to writable without having to run through ib_umem_get
142          * again
143          */
144         if (!ib_access_writable(access_flags)) {
145                 struct vm_area_struct *vma;
146
147                 down_read(&current->mm->mmap_sem);
148                 /*
149                  * FIXME: Ideally this would iterate over all the vmas that
150                  * cover the memory, but for now it requires a single vma to
151                  * entirely cover the MR to support RO mappings.
152                  */
153                 vma = find_vma(current->mm, start);
154                 if (vma && vma->vm_end >= start + length &&
155                     vma->vm_start <= start) {
156                         if (vma->vm_flags & VM_WRITE)
157                                 access_flags |= IB_ACCESS_LOCAL_WRITE;
158                 } else {
159                         access_flags |= IB_ACCESS_LOCAL_WRITE;
160                 }
161
162                 up_read(&current->mm->mmap_sem);
163         }
164
165         return ib_umem_get(context, start, length, access_flags, 0);
166 }
167
168 struct ib_mr *mlx4_ib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
169                                   u64 virt_addr, int access_flags,
170                                   struct ib_udata *udata)
171 {
172         struct mlx4_ib_dev *dev = to_mdev(pd->device);
173         struct mlx4_ib_mr *mr;
174         int shift;
175         int err;
176         int n;
177
178         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
179         if (!mr)
180                 return ERR_PTR(-ENOMEM);
181
182         mr->umem = mlx4_get_umem_mr(pd->uobject->context, start, length,
183                                     virt_addr, access_flags);
184         if (IS_ERR(mr->umem)) {
185                 err = PTR_ERR(mr->umem);
186                 goto err_free;
187         }
188
189         n = ib_umem_page_count(mr->umem);
190         shift = ilog2(mr->umem->page_size);
191
192         err = mlx4_mr_alloc(dev->dev, to_mpd(pd)->pdn, virt_addr, length,
193                             convert_access(access_flags), n, shift, &mr->mmr);
194         if (err)
195                 goto err_umem;
196
197         err = mlx4_ib_umem_write_mtt(dev, &mr->mmr.mtt, mr->umem);
198         if (err)
199                 goto err_mr;
200
201         err = mlx4_mr_enable(dev->dev, &mr->mmr);
202         if (err)
203                 goto err_mr;
204
205         mr->ibmr.rkey = mr->ibmr.lkey = mr->mmr.key;
206
207         return &mr->ibmr;
208
209 err_mr:
210         (void) mlx4_mr_free(to_mdev(pd->device)->dev, &mr->mmr);
211
212 err_umem:
213         ib_umem_release(mr->umem);
214
215 err_free:
216         kfree(mr);
217
218         return ERR_PTR(err);
219 }
220
221 int mlx4_ib_rereg_user_mr(struct ib_mr *mr, int flags,
222                           u64 start, u64 length, u64 virt_addr,
223                           int mr_access_flags, struct ib_pd *pd,
224                           struct ib_udata *udata)
225 {
226         struct mlx4_ib_dev *dev = to_mdev(mr->device);
227         struct mlx4_ib_mr *mmr = to_mmr(mr);
228         struct mlx4_mpt_entry *mpt_entry;
229         struct mlx4_mpt_entry **pmpt_entry = &mpt_entry;
230         int err;
231
232         /* Since we synchronize this call and mlx4_ib_dereg_mr via uverbs,
233          * we assume that the calls can't run concurrently. Otherwise, a
234          * race exists.
235          */
236         err =  mlx4_mr_hw_get_mpt(dev->dev, &mmr->mmr, &pmpt_entry);
237
238         if (err)
239                 return err;
240
241         if (flags & IB_MR_REREG_PD) {
242                 err = mlx4_mr_hw_change_pd(dev->dev, *pmpt_entry,
243                                            to_mpd(pd)->pdn);
244
245                 if (err)
246                         goto release_mpt_entry;
247         }
248
249         if (flags & IB_MR_REREG_ACCESS) {
250                 if (ib_access_writable(mr_access_flags) &&
251                     !mmr->umem->writable) {
252                         err = -EPERM;
253                         goto release_mpt_entry;
254                 }
255
256                 err = mlx4_mr_hw_change_access(dev->dev, *pmpt_entry,
257                                                convert_access(mr_access_flags));
258
259                 if (err)
260                         goto release_mpt_entry;
261         }
262
263         if (flags & IB_MR_REREG_TRANS) {
264                 int shift;
265                 int n;
266
267                 mlx4_mr_rereg_mem_cleanup(dev->dev, &mmr->mmr);
268                 ib_umem_release(mmr->umem);
269                 mmr->umem =
270                         mlx4_get_umem_mr(mr->uobject->context, start, length,
271                                          virt_addr, mr_access_flags);
272                 if (IS_ERR(mmr->umem)) {
273                         err = PTR_ERR(mmr->umem);
274                         /* Prevent mlx4_ib_dereg_mr from free'ing invalid pointer */
275                         mmr->umem = NULL;
276                         goto release_mpt_entry;
277                 }
278                 n = ib_umem_page_count(mmr->umem);
279                 shift = ilog2(mmr->umem->page_size);
280
281                 err = mlx4_mr_rereg_mem_write(dev->dev, &mmr->mmr,
282                                               virt_addr, length, n, shift,
283                                               *pmpt_entry);
284                 if (err) {
285                         ib_umem_release(mmr->umem);
286                         goto release_mpt_entry;
287                 }
288                 mmr->mmr.iova       = virt_addr;
289                 mmr->mmr.size       = length;
290
291                 err = mlx4_ib_umem_write_mtt(dev, &mmr->mmr.mtt, mmr->umem);
292                 if (err) {
293                         mlx4_mr_rereg_mem_cleanup(dev->dev, &mmr->mmr);
294                         ib_umem_release(mmr->umem);
295                         goto release_mpt_entry;
296                 }
297         }
298
299         /* If we couldn't transfer the MR to the HCA, just remember to
300          * return a failure. But dereg_mr will free the resources.
301          */
302         err = mlx4_mr_hw_write_mpt(dev->dev, &mmr->mmr, pmpt_entry);
303         if (!err && flags & IB_MR_REREG_ACCESS)
304                 mmr->mmr.access = mr_access_flags;
305
306 release_mpt_entry:
307         mlx4_mr_hw_put_mpt(dev->dev, pmpt_entry);
308
309         return err;
310 }
311
312 static int
313 mlx4_alloc_priv_pages(struct ib_device *device,
314                       struct mlx4_ib_mr *mr,
315                       int max_pages)
316 {
317         int ret;
318
319         /* Ensure that size is aligned to DMA cacheline
320          * requirements.
321          * max_pages is limited to MLX4_MAX_FAST_REG_PAGES
322          * so page_map_size will never cross PAGE_SIZE.
323          */
324         mr->page_map_size = roundup(max_pages * sizeof(u64),
325                                     MLX4_MR_PAGES_ALIGN);
326
327         /* Prevent cross page boundary allocation. */
328         mr->pages = (__be64 *)get_zeroed_page(GFP_KERNEL);
329         if (!mr->pages)
330                 return -ENOMEM;
331
332         mr->page_map = dma_map_single(device->dma_device, mr->pages,
333                                       mr->page_map_size, DMA_TO_DEVICE);
334
335         if (dma_mapping_error(device->dma_device, mr->page_map)) {
336                 ret = -ENOMEM;
337                 goto err;
338         }
339
340         return 0;
341
342 err:
343         free_page((unsigned long)mr->pages);
344         return ret;
345 }
346
347 static void
348 mlx4_free_priv_pages(struct mlx4_ib_mr *mr)
349 {
350         if (mr->pages) {
351                 struct ib_device *device = mr->ibmr.device;
352
353                 dma_unmap_single(device->dma_device, mr->page_map,
354                                  mr->page_map_size, DMA_TO_DEVICE);
355                 free_page((unsigned long)mr->pages);
356                 mr->pages = NULL;
357         }
358 }
359
360 int mlx4_ib_dereg_mr(struct ib_mr *ibmr)
361 {
362         struct mlx4_ib_mr *mr = to_mmr(ibmr);
363         int ret;
364
365         mlx4_free_priv_pages(mr);
366
367         ret = mlx4_mr_free(to_mdev(ibmr->device)->dev, &mr->mmr);
368         if (ret)
369                 return ret;
370         if (mr->umem)
371                 ib_umem_release(mr->umem);
372         kfree(mr);
373
374         return 0;
375 }
376
377 struct ib_mw *mlx4_ib_alloc_mw(struct ib_pd *pd, enum ib_mw_type type,
378                                struct ib_udata *udata)
379 {
380         struct mlx4_ib_dev *dev = to_mdev(pd->device);
381         struct mlx4_ib_mw *mw;
382         int err;
383
384         mw = kmalloc(sizeof(*mw), GFP_KERNEL);
385         if (!mw)
386                 return ERR_PTR(-ENOMEM);
387
388         err = mlx4_mw_alloc(dev->dev, to_mpd(pd)->pdn,
389                             to_mlx4_type(type), &mw->mmw);
390         if (err)
391                 goto err_free;
392
393         err = mlx4_mw_enable(dev->dev, &mw->mmw);
394         if (err)
395                 goto err_mw;
396
397         mw->ibmw.rkey = mw->mmw.key;
398
399         return &mw->ibmw;
400
401 err_mw:
402         mlx4_mw_free(dev->dev, &mw->mmw);
403
404 err_free:
405         kfree(mw);
406
407         return ERR_PTR(err);
408 }
409
410 int mlx4_ib_dealloc_mw(struct ib_mw *ibmw)
411 {
412         struct mlx4_ib_mw *mw = to_mmw(ibmw);
413
414         mlx4_mw_free(to_mdev(ibmw->device)->dev, &mw->mmw);
415         kfree(mw);
416
417         return 0;
418 }
419
420 struct ib_mr *mlx4_ib_alloc_mr(struct ib_pd *pd,
421                                enum ib_mr_type mr_type,
422                                u32 max_num_sg)
423 {
424         struct mlx4_ib_dev *dev = to_mdev(pd->device);
425         struct mlx4_ib_mr *mr;
426         int err;
427
428         if (mr_type != IB_MR_TYPE_MEM_REG ||
429             max_num_sg > MLX4_MAX_FAST_REG_PAGES)
430                 return ERR_PTR(-EINVAL);
431
432         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
433         if (!mr)
434                 return ERR_PTR(-ENOMEM);
435
436         err = mlx4_mr_alloc(dev->dev, to_mpd(pd)->pdn, 0, 0, 0,
437                             max_num_sg, 0, &mr->mmr);
438         if (err)
439                 goto err_free;
440
441         err = mlx4_alloc_priv_pages(pd->device, mr, max_num_sg);
442         if (err)
443                 goto err_free_mr;
444
445         mr->max_pages = max_num_sg;
446         err = mlx4_mr_enable(dev->dev, &mr->mmr);
447         if (err)
448                 goto err_free_pl;
449
450         mr->ibmr.rkey = mr->ibmr.lkey = mr->mmr.key;
451         mr->umem = NULL;
452
453         return &mr->ibmr;
454
455 err_free_pl:
456         mr->ibmr.device = pd->device;
457         mlx4_free_priv_pages(mr);
458 err_free_mr:
459         (void) mlx4_mr_free(dev->dev, &mr->mmr);
460 err_free:
461         kfree(mr);
462         return ERR_PTR(err);
463 }
464
465 struct ib_fmr *mlx4_ib_fmr_alloc(struct ib_pd *pd, int acc,
466                                  struct ib_fmr_attr *fmr_attr)
467 {
468         struct mlx4_ib_dev *dev = to_mdev(pd->device);
469         struct mlx4_ib_fmr *fmr;
470         int err = -ENOMEM;
471
472         fmr = kmalloc(sizeof *fmr, GFP_KERNEL);
473         if (!fmr)
474                 return ERR_PTR(-ENOMEM);
475
476         err = mlx4_fmr_alloc(dev->dev, to_mpd(pd)->pdn, convert_access(acc),
477                              fmr_attr->max_pages, fmr_attr->max_maps,
478                              fmr_attr->page_shift, &fmr->mfmr);
479         if (err)
480                 goto err_free;
481
482         err = mlx4_fmr_enable(to_mdev(pd->device)->dev, &fmr->mfmr);
483         if (err)
484                 goto err_mr;
485
486         fmr->ibfmr.rkey = fmr->ibfmr.lkey = fmr->mfmr.mr.key;
487
488         return &fmr->ibfmr;
489
490 err_mr:
491         (void) mlx4_mr_free(to_mdev(pd->device)->dev, &fmr->mfmr.mr);
492
493 err_free:
494         kfree(fmr);
495
496         return ERR_PTR(err);
497 }
498
499 int mlx4_ib_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
500                       int npages, u64 iova)
501 {
502         struct mlx4_ib_fmr *ifmr = to_mfmr(ibfmr);
503         struct mlx4_ib_dev *dev = to_mdev(ifmr->ibfmr.device);
504
505         return mlx4_map_phys_fmr(dev->dev, &ifmr->mfmr, page_list, npages, iova,
506                                  &ifmr->ibfmr.lkey, &ifmr->ibfmr.rkey);
507 }
508
509 int mlx4_ib_unmap_fmr(struct list_head *fmr_list)
510 {
511         struct ib_fmr *ibfmr;
512         int err;
513         struct mlx4_dev *mdev = NULL;
514
515         list_for_each_entry(ibfmr, fmr_list, list) {
516                 if (mdev && to_mdev(ibfmr->device)->dev != mdev)
517                         return -EINVAL;
518                 mdev = to_mdev(ibfmr->device)->dev;
519         }
520
521         if (!mdev)
522                 return 0;
523
524         list_for_each_entry(ibfmr, fmr_list, list) {
525                 struct mlx4_ib_fmr *ifmr = to_mfmr(ibfmr);
526
527                 mlx4_fmr_unmap(mdev, &ifmr->mfmr, &ifmr->ibfmr.lkey, &ifmr->ibfmr.rkey);
528         }
529
530         /*
531          * Make sure all MPT status updates are visible before issuing
532          * SYNC_TPT firmware command.
533          */
534         wmb();
535
536         err = mlx4_SYNC_TPT(mdev);
537         if (err)
538                 pr_warn("SYNC_TPT error %d when "
539                        "unmapping FMRs\n", err);
540
541         return 0;
542 }
543
544 int mlx4_ib_fmr_dealloc(struct ib_fmr *ibfmr)
545 {
546         struct mlx4_ib_fmr *ifmr = to_mfmr(ibfmr);
547         struct mlx4_ib_dev *dev = to_mdev(ibfmr->device);
548         int err;
549
550         err = mlx4_fmr_free(dev->dev, &ifmr->mfmr);
551
552         if (!err)
553                 kfree(ifmr);
554
555         return err;
556 }
557
558 static int mlx4_set_page(struct ib_mr *ibmr, u64 addr)
559 {
560         struct mlx4_ib_mr *mr = to_mmr(ibmr);
561
562         if (unlikely(mr->npages == mr->max_pages))
563                 return -ENOMEM;
564
565         mr->pages[mr->npages++] = cpu_to_be64(addr | MLX4_MTT_FLAG_PRESENT);
566
567         return 0;
568 }
569
570 int mlx4_ib_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg, int sg_nents,
571                       unsigned int *sg_offset)
572 {
573         struct mlx4_ib_mr *mr = to_mmr(ibmr);
574         int rc;
575
576         mr->npages = 0;
577
578         ib_dma_sync_single_for_cpu(ibmr->device, mr->page_map,
579                                    mr->page_map_size, DMA_TO_DEVICE);
580
581         rc = ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset, mlx4_set_page);
582
583         ib_dma_sync_single_for_device(ibmr->device, mr->page_map,
584                                       mr->page_map_size, DMA_TO_DEVICE);
585
586         return rc;
587 }