2 * Copyright(c) 2016 Intel Corporation.
4 * This file is provided under a dual BSD/GPLv2 license. When using or
5 * redistributing this file, you may do so under either license.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of version 2 of the GNU General Public License as
11 * published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
20 * Redistribution and use in source and binary forms, with or without
21 * modification, are permitted provided that the following conditions
24 * - Redistributions of source code must retain the above copyright
25 * notice, this list of conditions and the following disclaimer.
26 * - Redistributions in binary form must reproduce the above copyright
27 * notice, this list of conditions and the following disclaimer in
28 * the documentation and/or other materials provided with the
30 * - Neither the name of Intel Corporation nor the names of its
31 * contributors may be used to endorse or promote products derived
32 * from this software without specific prior written permission.
34 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
35 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
36 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
37 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
38 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
39 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
40 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
41 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
42 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
43 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
44 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
48 #include <linux/slab.h>
49 #include <linux/vmalloc.h>
50 #include <rdma/ib_umem.h>
51 #include <rdma/rdma_vt.h>
57 * rvt_driver_mr_init - Init MR resources per driver
58 * @rdi: rvt dev struct
60 * Do any intilization needed when a driver registers with rdmavt.
62 * Return: 0 on success or errno on failure
64 int rvt_driver_mr_init(struct rvt_dev_info *rdi)
66 unsigned int lkey_table_size = rdi->dparms.lkey_table_size;
71 * The top hfi1_lkey_table_size bits are used to index the
72 * table. The lower 8 bits can be owned by the user (copied from
73 * the LKEY). The remaining bits act as a generation number or tag.
78 spin_lock_init(&rdi->lkey_table.lock);
80 /* ensure generation is at least 4 bits */
81 if (lkey_table_size > RVT_MAX_LKEY_TABLE_BITS) {
82 rvt_pr_warn(rdi, "lkey bits %u too large, reduced to %u\n",
83 lkey_table_size, RVT_MAX_LKEY_TABLE_BITS);
84 rdi->dparms.lkey_table_size = RVT_MAX_LKEY_TABLE_BITS;
85 lkey_table_size = rdi->dparms.lkey_table_size;
87 rdi->lkey_table.max = 1 << lkey_table_size;
88 rdi->lkey_table.shift = 32 - lkey_table_size;
89 lk_tab_size = rdi->lkey_table.max * sizeof(*rdi->lkey_table.table);
90 rdi->lkey_table.table = (struct rvt_mregion __rcu **)
91 vmalloc_node(lk_tab_size, rdi->dparms.node);
92 if (!rdi->lkey_table.table)
95 RCU_INIT_POINTER(rdi->dma_mr, NULL);
96 for (i = 0; i < rdi->lkey_table.max; i++)
97 RCU_INIT_POINTER(rdi->lkey_table.table[i], NULL);
103 *rvt_mr_exit: clean up MR
104 *@rdi: rvt dev structure
106 * called when drivers have unregistered or perhaps failed to register with us
108 void rvt_mr_exit(struct rvt_dev_info *rdi)
111 rvt_pr_err(rdi, "DMA MR not null!\n");
113 vfree(rdi->lkey_table.table);
116 static void rvt_deinit_mregion(struct rvt_mregion *mr)
125 static int rvt_init_mregion(struct rvt_mregion *mr, struct ib_pd *pd,
129 struct rvt_dev_info *dev = ib_to_rvt(pd->device);
132 m = (count + RVT_SEGSZ - 1) / RVT_SEGSZ;
134 mr->map[i] = kzalloc_node(sizeof(*mr->map[0]), GFP_KERNEL,
137 rvt_deinit_mregion(mr);
142 init_completion(&mr->comp);
143 /* count returning the ptr to user */
144 atomic_set(&mr->refcount, 1);
145 atomic_set(&mr->lkey_invalid, 0);
147 mr->max_segs = count;
152 * rvt_alloc_lkey - allocate an lkey
153 * @mr: memory region that this lkey protects
154 * @dma_region: 0->normal key, 1->restricted DMA key
156 * Returns 0 if successful, otherwise returns -errno.
158 * Increments mr reference count as required.
160 * Sets the lkey field mr for non-dma regions.
163 static int rvt_alloc_lkey(struct rvt_mregion *mr, int dma_region)
169 struct rvt_dev_info *dev = ib_to_rvt(mr->pd->device);
170 struct rvt_lkey_table *rkt = &dev->lkey_table;
173 spin_lock_irqsave(&rkt->lock, flags);
175 /* special case for dma_mr lkey == 0 */
177 struct rvt_mregion *tmr;
179 tmr = rcu_access_pointer(dev->dma_mr);
181 rcu_assign_pointer(dev->dma_mr, mr);
182 mr->lkey_published = 1;
189 /* Find the next available LKEY */
193 if (!rcu_access_pointer(rkt->table[r]))
195 r = (r + 1) & (rkt->max - 1);
199 rkt->next = (r + 1) & (rkt->max - 1);
201 * Make sure lkey is never zero which is reserved to indicate an
206 * bits are capped to ensure enough bits for generation number
208 mr->lkey = (r << (32 - dev->dparms.lkey_table_size)) |
209 ((((1 << (24 - dev->dparms.lkey_table_size)) - 1) & rkt->gen)
215 rcu_assign_pointer(rkt->table[r], mr);
216 mr->lkey_published = 1;
218 spin_unlock_irqrestore(&rkt->lock, flags);
223 spin_unlock_irqrestore(&rkt->lock, flags);
229 * rvt_free_lkey - free an lkey
230 * @mr: mr to free from tables
232 static void rvt_free_lkey(struct rvt_mregion *mr)
237 struct rvt_dev_info *dev = ib_to_rvt(mr->pd->device);
238 struct rvt_lkey_table *rkt = &dev->lkey_table;
241 spin_lock_irqsave(&rkt->lock, flags);
242 if (!mr->lkey_published)
245 RCU_INIT_POINTER(dev->dma_mr, NULL);
247 r = lkey >> (32 - dev->dparms.lkey_table_size);
248 RCU_INIT_POINTER(rkt->table[r], NULL);
250 mr->lkey_published = 0;
253 spin_unlock_irqrestore(&rkt->lock, flags);
260 static struct rvt_mr *__rvt_alloc_mr(int count, struct ib_pd *pd)
266 /* Allocate struct plus pointers to first level page tables. */
267 m = (count + RVT_SEGSZ - 1) / RVT_SEGSZ;
268 mr = kzalloc(sizeof(*mr) + m * sizeof(mr->mr.map[0]), GFP_KERNEL);
272 rval = rvt_init_mregion(&mr->mr, pd, count);
276 * ib_reg_phys_mr() will initialize mr->ibmr except for
279 rval = rvt_alloc_lkey(&mr->mr, 0);
282 mr->ibmr.lkey = mr->mr.lkey;
283 mr->ibmr.rkey = mr->mr.lkey;
288 rvt_deinit_mregion(&mr->mr);
295 static void __rvt_free_mr(struct rvt_mr *mr)
297 rvt_deinit_mregion(&mr->mr);
298 rvt_free_lkey(&mr->mr);
303 * rvt_get_dma_mr - get a DMA memory region
304 * @pd: protection domain for this memory region
307 * Return: the memory region on success, otherwise returns an errno.
308 * Note that all DMA addresses should be created via the
309 * struct ib_dma_mapping_ops functions (see dma.c).
311 struct ib_mr *rvt_get_dma_mr(struct ib_pd *pd, int acc)
317 if (ibpd_to_rvtpd(pd)->user)
318 return ERR_PTR(-EPERM);
320 mr = kzalloc(sizeof(*mr), GFP_KERNEL);
322 ret = ERR_PTR(-ENOMEM);
326 rval = rvt_init_mregion(&mr->mr, pd, 0);
332 rval = rvt_alloc_lkey(&mr->mr, 1);
338 mr->mr.access_flags = acc;
344 rvt_deinit_mregion(&mr->mr);
351 * rvt_reg_user_mr - register a userspace memory region
352 * @pd: protection domain for this memory region
353 * @start: starting userspace address
354 * @length: length of region to register
355 * @mr_access_flags: access flags for this memory region
356 * @udata: unused by the driver
358 * Return: the memory region on success, otherwise returns an errno.
360 struct ib_mr *rvt_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
361 u64 virt_addr, int mr_access_flags,
362 struct ib_udata *udata)
365 struct ib_umem *umem;
366 struct scatterlist *sg;
371 return ERR_PTR(-EINVAL);
373 umem = ib_umem_get(pd->uobject->context, start, length,
380 mr = __rvt_alloc_mr(n, pd);
382 ret = (struct ib_mr *)mr;
386 mr->mr.user_base = start;
387 mr->mr.iova = virt_addr;
388 mr->mr.length = length;
389 mr->mr.offset = ib_umem_offset(umem);
390 mr->mr.access_flags = mr_access_flags;
393 if (is_power_of_2(umem->page_size))
394 mr->mr.page_shift = ilog2(umem->page_size);
397 for_each_sg(umem->sg_head.sgl, sg, umem->nmap, entry) {
400 vaddr = page_address(sg_page(sg));
402 ret = ERR_PTR(-EINVAL);
405 mr->mr.map[m]->segs[n].vaddr = vaddr;
406 mr->mr.map[m]->segs[n].length = umem->page_size;
407 trace_rvt_mr_user_seg(&mr->mr, m, n, vaddr, umem->page_size);
409 if (n == RVT_SEGSZ) {
420 ib_umem_release(umem);
426 * rvt_dereg_mr - unregister and free a memory region
427 * @ibmr: the memory region to free
430 * Note that this is called to free MRs created by rvt_get_dma_mr()
431 * or rvt_reg_user_mr().
433 * Returns 0 on success.
435 int rvt_dereg_mr(struct ib_mr *ibmr)
437 struct rvt_mr *mr = to_imr(ibmr);
438 struct rvt_dev_info *rdi = ib_to_rvt(ibmr->pd->device);
440 unsigned long timeout;
442 rvt_free_lkey(&mr->mr);
444 rvt_put_mr(&mr->mr); /* will set completion if last */
445 timeout = wait_for_completion_timeout(&mr->mr.comp, 5 * HZ);
448 "rvt_dereg_mr timeout mr %p pd %p refcount %u\n",
449 mr, mr->mr.pd, atomic_read(&mr->mr.refcount));
454 rvt_deinit_mregion(&mr->mr);
456 ib_umem_release(mr->umem);
463 * rvt_alloc_mr - Allocate a memory region usable with the
464 * @pd: protection domain for this memory region
465 * @mr_type: mem region type
466 * @max_num_sg: Max number of segments allowed
468 * Return: the memory region on success, otherwise return an errno.
470 struct ib_mr *rvt_alloc_mr(struct ib_pd *pd,
471 enum ib_mr_type mr_type,
476 if (mr_type != IB_MR_TYPE_MEM_REG)
477 return ERR_PTR(-EINVAL);
479 mr = __rvt_alloc_mr(max_num_sg, pd);
481 return (struct ib_mr *)mr;
487 * rvt_set_page - page assignment function called by ib_sg_to_pages
488 * @ibmr: memory region
489 * @addr: dma address of mapped page
491 * Return: 0 on success
493 static int rvt_set_page(struct ib_mr *ibmr, u64 addr)
495 struct rvt_mr *mr = to_imr(ibmr);
496 u32 ps = 1 << mr->mr.page_shift;
497 u32 mapped_segs = mr->mr.length >> mr->mr.page_shift;
500 if (unlikely(mapped_segs == mr->mr.max_segs))
503 if (mr->mr.length == 0) {
504 mr->mr.user_base = addr;
508 m = mapped_segs / RVT_SEGSZ;
509 n = mapped_segs % RVT_SEGSZ;
510 mr->mr.map[m]->segs[n].vaddr = (void *)addr;
511 mr->mr.map[m]->segs[n].length = ps;
512 trace_rvt_mr_page_seg(&mr->mr, m, n, (void *)addr, ps);
519 * rvt_map_mr_sg - map sg list and set it the memory region
520 * @ibmr: memory region
521 * @sg: dma mapped scatterlist
522 * @sg_nents: number of entries in sg
523 * @sg_offset: offset in bytes into sg
525 * Return: number of sg elements mapped to the memory region
527 int rvt_map_mr_sg(struct ib_mr *ibmr, struct scatterlist *sg,
528 int sg_nents, unsigned int *sg_offset)
530 struct rvt_mr *mr = to_imr(ibmr);
533 mr->mr.page_shift = PAGE_SHIFT;
534 return ib_sg_to_pages(ibmr, sg, sg_nents, sg_offset,
539 * rvt_fast_reg_mr - fast register physical MR
540 * @qp: the queue pair where the work request comes from
541 * @ibmr: the memory region to be registered
542 * @key: updated key for this memory region
543 * @access: access flags for this memory region
545 * Returns 0 on success.
547 int rvt_fast_reg_mr(struct rvt_qp *qp, struct ib_mr *ibmr, u32 key,
550 struct rvt_mr *mr = to_imr(ibmr);
552 if (qp->ibqp.pd != mr->mr.pd)
555 /* not applicable to dma MR or user MR */
556 if (!mr->mr.lkey || mr->umem)
559 if ((key & 0xFFFFFF00) != (mr->mr.lkey & 0xFFFFFF00))
565 mr->mr.access_flags = access;
566 atomic_set(&mr->mr.lkey_invalid, 0);
570 EXPORT_SYMBOL(rvt_fast_reg_mr);
573 * rvt_invalidate_rkey - invalidate an MR rkey
574 * @qp: queue pair associated with the invalidate op
575 * @rkey: rkey to invalidate
577 * Returns 0 on success.
579 int rvt_invalidate_rkey(struct rvt_qp *qp, u32 rkey)
581 struct rvt_dev_info *dev = ib_to_rvt(qp->ibqp.device);
582 struct rvt_lkey_table *rkt = &dev->lkey_table;
583 struct rvt_mregion *mr;
589 mr = rcu_dereference(
590 rkt->table[(rkey >> (32 - dev->dparms.lkey_table_size))]);
591 if (unlikely(!mr || mr->lkey != rkey || qp->ibqp.pd != mr->pd))
594 atomic_set(&mr->lkey_invalid, 1);
602 EXPORT_SYMBOL(rvt_invalidate_rkey);
605 * rvt_alloc_fmr - allocate a fast memory region
606 * @pd: the protection domain for this memory region
607 * @mr_access_flags: access flags for this memory region
608 * @fmr_attr: fast memory region attributes
610 * Return: the memory region on success, otherwise returns an errno.
612 struct ib_fmr *rvt_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
613 struct ib_fmr_attr *fmr_attr)
620 /* Allocate struct plus pointers to first level page tables. */
621 m = (fmr_attr->max_pages + RVT_SEGSZ - 1) / RVT_SEGSZ;
622 fmr = kzalloc(sizeof(*fmr) + m * sizeof(fmr->mr.map[0]), GFP_KERNEL);
626 rval = rvt_init_mregion(&fmr->mr, pd, fmr_attr->max_pages);
631 * ib_alloc_fmr() will initialize fmr->ibfmr except for lkey &
634 rval = rvt_alloc_lkey(&fmr->mr, 0);
637 fmr->ibfmr.rkey = fmr->mr.lkey;
638 fmr->ibfmr.lkey = fmr->mr.lkey;
640 * Resources are allocated but no valid mapping (RKEY can't be
643 fmr->mr.access_flags = mr_access_flags;
644 fmr->mr.max_segs = fmr_attr->max_pages;
645 fmr->mr.page_shift = fmr_attr->page_shift;
652 rvt_deinit_mregion(&fmr->mr);
660 * rvt_map_phys_fmr - set up a fast memory region
661 * @ibmfr: the fast memory region to set up
662 * @page_list: the list of pages to associate with the fast memory region
663 * @list_len: the number of pages to associate with the fast memory region
664 * @iova: the virtual address of the start of the fast memory region
666 * This may be called from interrupt context.
668 * Return: 0 on success
671 int rvt_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
672 int list_len, u64 iova)
674 struct rvt_fmr *fmr = to_ifmr(ibfmr);
675 struct rvt_lkey_table *rkt;
679 struct rvt_dev_info *rdi = ib_to_rvt(ibfmr->device);
681 i = atomic_read(&fmr->mr.refcount);
685 if (list_len > fmr->mr.max_segs)
688 rkt = &rdi->lkey_table;
689 spin_lock_irqsave(&rkt->lock, flags);
690 fmr->mr.user_base = iova;
692 ps = 1 << fmr->mr.page_shift;
693 fmr->mr.length = list_len * ps;
696 for (i = 0; i < list_len; i++) {
697 fmr->mr.map[m]->segs[n].vaddr = (void *)page_list[i];
698 fmr->mr.map[m]->segs[n].length = ps;
699 trace_rvt_mr_fmr_seg(&fmr->mr, m, n, (void *)page_list[i], ps);
700 if (++n == RVT_SEGSZ) {
705 spin_unlock_irqrestore(&rkt->lock, flags);
710 * rvt_unmap_fmr - unmap fast memory regions
711 * @fmr_list: the list of fast memory regions to unmap
713 * Return: 0 on success.
715 int rvt_unmap_fmr(struct list_head *fmr_list)
718 struct rvt_lkey_table *rkt;
720 struct rvt_dev_info *rdi;
722 list_for_each_entry(fmr, fmr_list, ibfmr.list) {
723 rdi = ib_to_rvt(fmr->ibfmr.device);
724 rkt = &rdi->lkey_table;
725 spin_lock_irqsave(&rkt->lock, flags);
726 fmr->mr.user_base = 0;
729 spin_unlock_irqrestore(&rkt->lock, flags);
735 * rvt_dealloc_fmr - deallocate a fast memory region
736 * @ibfmr: the fast memory region to deallocate
738 * Return: 0 on success.
740 int rvt_dealloc_fmr(struct ib_fmr *ibfmr)
742 struct rvt_fmr *fmr = to_ifmr(ibfmr);
744 unsigned long timeout;
746 rvt_free_lkey(&fmr->mr);
747 rvt_put_mr(&fmr->mr); /* will set completion if last */
748 timeout = wait_for_completion_timeout(&fmr->mr.comp, 5 * HZ);
750 rvt_get_mr(&fmr->mr);
754 rvt_deinit_mregion(&fmr->mr);
761 * rvt_lkey_ok - check IB SGE for validity and initialize
762 * @rkt: table containing lkey to check SGE against
763 * @pd: protection domain
764 * @isge: outgoing internal SGE
768 * Check the IB SGE for validity and initialize our internal version
771 * Return: 1 if valid and successful, otherwise returns 0.
773 * increments the reference count upon success
776 int rvt_lkey_ok(struct rvt_lkey_table *rkt, struct rvt_pd *pd,
777 struct rvt_sge *isge, struct ib_sge *sge, int acc)
779 struct rvt_mregion *mr;
784 * We use LKEY == zero for kernel virtual addresses
785 * (see rvt_get_dma_mr and dma.c).
788 if (sge->lkey == 0) {
789 struct rvt_dev_info *dev = ib_to_rvt(pd->ibpd.device);
793 mr = rcu_dereference(dev->dma_mr);
800 isge->vaddr = (void *)sge->addr;
801 isge->length = sge->length;
802 isge->sge_length = sge->length;
807 mr = rcu_dereference(rkt->table[sge->lkey >> rkt->shift]);
808 if (unlikely(!mr || atomic_read(&mr->lkey_invalid) ||
809 mr->lkey != sge->lkey || mr->pd != &pd->ibpd))
812 off = sge->addr - mr->user_base;
813 if (unlikely(sge->addr < mr->user_base ||
814 off + sge->length > mr->length ||
815 (mr->access_flags & acc) != acc))
821 if (mr->page_shift) {
823 * page sizes are uniform power of 2 so no loop is necessary
824 * entries_spanned_by_off is the number of times the loop below
825 * would have executed.
827 size_t entries_spanned_by_off;
829 entries_spanned_by_off = off >> mr->page_shift;
830 off -= (entries_spanned_by_off << mr->page_shift);
831 m = entries_spanned_by_off / RVT_SEGSZ;
832 n = entries_spanned_by_off % RVT_SEGSZ;
836 while (off >= mr->map[m]->segs[n].length) {
837 off -= mr->map[m]->segs[n].length;
839 if (n >= RVT_SEGSZ) {
846 isge->vaddr = mr->map[m]->segs[n].vaddr + off;
847 isge->length = mr->map[m]->segs[n].length - off;
848 isge->sge_length = sge->length;
857 EXPORT_SYMBOL(rvt_lkey_ok);
860 * rvt_rkey_ok - check the IB virtual address, length, and RKEY
861 * @qp: qp for validation
863 * @len: length of data
864 * @vaddr: virtual address to place data
865 * @rkey: rkey to check
868 * Return: 1 if successful, otherwise 0.
870 * increments the reference count upon success
872 int rvt_rkey_ok(struct rvt_qp *qp, struct rvt_sge *sge,
873 u32 len, u64 vaddr, u32 rkey, int acc)
875 struct rvt_dev_info *dev = ib_to_rvt(qp->ibqp.device);
876 struct rvt_lkey_table *rkt = &dev->lkey_table;
877 struct rvt_mregion *mr;
882 * We use RKEY == zero for kernel virtual addresses
883 * (see rvt_get_dma_mr and dma.c).
887 struct rvt_pd *pd = ibpd_to_rvtpd(qp->ibqp.pd);
888 struct rvt_dev_info *rdi = ib_to_rvt(pd->ibpd.device);
892 mr = rcu_dereference(rdi->dma_mr);
899 sge->vaddr = (void *)vaddr;
901 sge->sge_length = len;
907 mr = rcu_dereference(rkt->table[rkey >> rkt->shift]);
908 if (unlikely(!mr || atomic_read(&mr->lkey_invalid) ||
909 mr->lkey != rkey || qp->ibqp.pd != mr->pd))
912 off = vaddr - mr->iova;
913 if (unlikely(vaddr < mr->iova || off + len > mr->length ||
914 (mr->access_flags & acc) == 0))
920 if (mr->page_shift) {
922 * page sizes are uniform power of 2 so no loop is necessary
923 * entries_spanned_by_off is the number of times the loop below
924 * would have executed.
926 size_t entries_spanned_by_off;
928 entries_spanned_by_off = off >> mr->page_shift;
929 off -= (entries_spanned_by_off << mr->page_shift);
930 m = entries_spanned_by_off / RVT_SEGSZ;
931 n = entries_spanned_by_off % RVT_SEGSZ;
935 while (off >= mr->map[m]->segs[n].length) {
936 off -= mr->map[m]->segs[n].length;
938 if (n >= RVT_SEGSZ) {
945 sge->vaddr = mr->map[m]->segs[n].vaddr + off;
946 sge->length = mr->map[m]->segs[n].length - off;
947 sge->sge_length = len;
956 EXPORT_SYMBOL(rvt_rkey_ok);