Lines Matching refs:mr
11 #include "mr.h"
75 static void rvt_deinit_mregion(struct rvt_mregion *mr)
77 int i = mr->mapsz;
79 mr->mapsz = 0;
81 kfree(mr->map[--i]);
82 percpu_ref_exit(&mr->refcount);
87 struct rvt_mregion *mr = container_of(ref, struct rvt_mregion,
90 complete(&mr->comp);
93 static int rvt_init_mregion(struct rvt_mregion *mr, struct ib_pd *pd,
99 mr->mapsz = 0;
102 mr->map[i] = kzalloc_node(sizeof(*mr->map[0]), GFP_KERNEL,
104 if (!mr->map[i])
106 mr->mapsz++;
108 init_completion(&mr->comp);
110 if (percpu_ref_init(&mr->refcount, &__rvt_mregion_complete,
114 atomic_set(&mr->lkey_invalid, 0);
115 mr->pd = pd;
116 mr->max_segs = count;
119 rvt_deinit_mregion(mr);
125 * @mr: memory region that this lkey protects
130 * Increments mr reference count as required.
132 * Sets the lkey field mr for non-dma regions.
135 static int rvt_alloc_lkey(struct rvt_mregion *mr, int dma_region)
141 struct rvt_dev_info *dev = ib_to_rvt(mr->pd->device);
144 rvt_get_mr(mr);
153 mr->lkey_published = 1;
155 rcu_assign_pointer(dev->dma_mr, mr);
156 rvt_get_mr(mr);
180 mr->lkey = (r << (32 - dev->dparms.lkey_table_size)) |
183 if (mr->lkey == 0) {
184 mr->lkey |= 1 << 8;
187 mr->lkey_published = 1;
189 rcu_assign_pointer(rkt->table[r], mr);
195 rvt_put_mr(mr);
203 * @mr: mr to free from tables
205 static void rvt_free_lkey(struct rvt_mregion *mr)
208 u32 lkey = mr->lkey;
210 struct rvt_dev_info *dev = ib_to_rvt(mr->pd->device);
216 if (mr->lkey_published) {
217 mr->lkey_published = 0;
220 rvt_put_mr(mr);
223 if (!mr->lkey_published)
226 mr->lkey_published = 0;
234 percpu_ref_kill(&mr->refcount);
239 struct rvt_mr *mr;
245 mr = kzalloc(struct_size(mr, mr.map, m), GFP_KERNEL);
246 if (!mr)
249 rval = rvt_init_mregion(&mr->mr, pd, count, 0);
253 * ib_reg_phys_mr() will initialize mr->ibmr except for
256 rval = rvt_alloc_lkey(&mr->mr, 0);
259 mr->ibmr.lkey = mr->mr.lkey;
260 mr->ibmr.rkey = mr->mr.lkey;
262 return mr;
265 rvt_deinit_mregion(&mr->mr);
267 kfree(mr);
268 mr = ERR_PTR(rval);
272 static void __rvt_free_mr(struct rvt_mr *mr)
274 rvt_free_lkey(&mr->mr);
275 rvt_deinit_mregion(&mr->mr);
276 kfree(mr);
288 struct rvt_mr *mr;
295 mr = kzalloc(sizeof(*mr), GFP_KERNEL);
296 if (!mr) {
301 rval = rvt_init_mregion(&mr->mr, pd, 0, 0);
307 rval = rvt_alloc_lkey(&mr->mr, 1);
313 mr->mr.access_flags = acc;
314 ret = &mr->ibmr;
319 rvt_deinit_mregion(&mr->mr);
321 kfree(mr);
340 struct rvt_mr *mr;
355 mr = __rvt_alloc_mr(n, pd);
356 if (IS_ERR(mr)) {
357 ret = (struct ib_mr *)mr;
361 mr->mr.user_base = start;
362 mr->mr.iova = virt_addr;
363 mr->mr.length = length;
364 mr->mr.offset = ib_umem_offset(umem);
365 mr->mr.access_flags = mr_access_flags;
366 mr->umem = umem;
368 mr->mr.page_shift = PAGE_SHIFT;
379 mr->mr.map[m]->segs[n].vaddr = vaddr;
380 mr->mr.map[m]->segs[n].length = PAGE_SIZE;
381 trace_rvt_mr_user_seg(&mr->mr, m, n, vaddr, PAGE_SIZE);
387 return &mr->ibmr;
390 __rvt_free_mr(mr);
409 struct rvt_mregion *mr = (struct rvt_mregion *)v;
412 if (mr->pd != qp->ibqp.pd)
414 rvt_qp_mr_clean(qp, mr->lkey);
419 * @mr: the MR that is being deregistered
422 * to the lkey noted in mr.
424 static void rvt_dereg_clean_qps(struct rvt_mregion *mr)
426 struct rvt_dev_info *rdi = ib_to_rvt(mr->pd->device);
428 rvt_qp_iter(rdi, (u64)mr, rvt_dereg_clean_qp_cb);
433 * @mr: the megion
442 static int rvt_check_refs(struct rvt_mregion *mr, const char *t)
445 struct rvt_dev_info *rdi = ib_to_rvt(mr->pd->device);
447 if (mr->lkey) {
448 /* avoid dma mr */
449 rvt_dereg_clean_qps(mr);
450 /* @mr was indexed on rcu protected @lkey_table */
454 timeout = wait_for_completion_timeout(&mr->comp, 5 * HZ);
457 "%s timeout mr %p pd %p lkey %x refcount %ld\n",
458 t, mr, mr->pd, mr->lkey,
459 atomic_long_read(&mr->refcount.data->count));
460 rvt_get_mr(mr);
468 * @mr: the mregion
471 bool rvt_mr_has_lkey(struct rvt_mregion *mr, u32 lkey)
473 return mr && lkey == mr->lkey;
477 * rvt_ss_has_lkey - is mr in sge tests
492 rval = rvt_mr_has_lkey(ss->sge.mr, lkey);
495 rval = rvt_mr_has_lkey(ss->sg_list[i].mr, lkey);
511 struct rvt_mr *mr = to_imr(ibmr);
514 rvt_free_lkey(&mr->mr);
516 rvt_put_mr(&mr->mr); /* will set completion if last */
517 ret = rvt_check_refs(&mr->mr, __func__);
520 rvt_deinit_mregion(&mr->mr);
521 ib_umem_release(mr->umem);
522 kfree(mr);
538 struct rvt_mr *mr;
543 mr = __rvt_alloc_mr(max_num_sg, pd);
544 if (IS_ERR(mr))
545 return (struct ib_mr *)mr;
547 return &mr->ibmr;
559 struct rvt_mr *mr = to_imr(ibmr);
560 u32 ps = 1 << mr->mr.page_shift;
561 u32 mapped_segs = mr->mr.length >> mr->mr.page_shift;
564 if (unlikely(mapped_segs == mr->mr.max_segs))
569 mr->mr.map[m]->segs[n].vaddr = (void *)addr;
570 mr->mr.map[m]->segs[n].length = ps;
571 mr->mr.length += ps;
572 trace_rvt_mr_page_seg(&mr->mr, m, n, (void *)addr, ps);
584 * Overwrite rvt_mr length with mr length calculated by ib_sg_to_pages.
591 struct rvt_mr *mr = to_imr(ibmr);
594 mr->mr.length = 0;
595 mr->mr.page_shift = PAGE_SHIFT;
597 mr->mr.user_base = ibmr->iova;
598 mr->mr.iova = ibmr->iova;
599 mr->mr.offset = ibmr->iova - (u64)mr->mr.map[0]->segs[0].vaddr;
600 mr->mr.length = (size_t)ibmr->length;
617 struct rvt_mr *mr = to_imr(ibmr);
619 if (qp->ibqp.pd != mr->mr.pd)
623 if (!mr->mr.lkey || mr->umem)
626 if ((key & 0xFFFFFF00) != (mr->mr.lkey & 0xFFFFFF00))
631 mr->mr.lkey = key;
632 mr->mr.access_flags = access;
633 mr->mr.iova = ibmr->iova;
634 atomic_set(&mr->mr.lkey_invalid, 0);
651 struct rvt_mregion *mr;
657 mr = rcu_dereference(
659 if (unlikely(!mr || mr->lkey != rkey || qp->ibqp.pd != mr->pd))
662 atomic_set(&mr->lkey_invalid, 1);
684 if (last_sge && sge->lkey == last_sge->mr->lkey &&
687 if (unlikely((sge->addr - last_sge->mr->user_base +
688 sge->length > last_sge->mr->length)))
720 struct rvt_mregion *mr;
736 mr = rcu_dereference(dev->dma_mr);
737 if (!mr)
739 rvt_get_mr(mr);
742 isge->mr = mr;
753 mr = rcu_dereference(rkt->table[sge->lkey >> rkt->shift]);
754 if (!mr)
756 rvt_get_mr(mr);
757 if (!READ_ONCE(mr->lkey_published))
760 if (unlikely(atomic_read(&mr->lkey_invalid) ||
761 mr->lkey != sge->lkey || mr->pd != &pd->ibpd))
764 off = sge->addr - mr->user_base;
765 if (unlikely(sge->addr < mr->user_base ||
766 off + sge->length > mr->length ||
767 (mr->access_flags & acc) != acc))
771 off += mr->offset;
772 if (mr->page_shift) {
780 entries_spanned_by_off = off >> mr->page_shift;
781 off -= (entries_spanned_by_off << mr->page_shift);
787 while (off >= mr->map[m]->segs[n].length) {
788 off -= mr->map[m]->segs[n].length;
796 isge->mr = mr;
797 isge->vaddr = mr->map[m]->segs[n].vaddr + off;
798 isge->length = mr->map[m]->segs[n].length - off;
806 rvt_put_mr(mr);
831 struct rvt_mregion *mr;
846 mr = rcu_dereference(rdi->dma_mr);
847 if (!mr)
849 rvt_get_mr(mr);
852 sge->mr = mr;
861 mr = rcu_dereference(rkt->table[rkey >> rkt->shift]);
862 if (!mr)
864 rvt_get_mr(mr);
865 /* insure mr read is before test */
866 if (!READ_ONCE(mr->lkey_published))
868 if (unlikely(atomic_read(&mr->lkey_invalid) ||
869 mr->lkey != rkey || qp->ibqp.pd != mr->pd))
872 off = vaddr - mr->iova;
873 if (unlikely(vaddr < mr->iova || off + len > mr->length ||
874 (mr->access_flags & acc) == 0))
878 off += mr->offset;
879 if (mr->page_shift) {
887 entries_spanned_by_off = off >> mr->page_shift;
888 off -= (entries_spanned_by_off << mr->page_shift);
894 while (off >= mr->map[m]->segs[n].length) {
895 off -= mr->map[m]->segs[n].length;
903 sge->mr = mr;
904 sge->vaddr = mr->map[m]->segs[n].vaddr + off;
905 sge->length = mr->map[m]->segs[n].length - off;
912 rvt_put_mr(mr);