1 /*
2 *
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
5 *
6 * GPL LICENSE SUMMARY
7 *
8 * Copyright(c) 2015 Intel Corporation.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * BSD LICENSE
20 *
21 * Copyright(c) 2015 Intel Corporation.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 *
27 * - Redistributions of source code must retain the above copyright
28 * notice, this list of conditions and the following disclaimer.
29 * - Redistributions in binary form must reproduce the above copyright
30 * notice, this list of conditions and the following disclaimer in
31 * the documentation and/or other materials provided with the
32 * distribution.
33 * - Neither the name of Intel Corporation nor the names of its
34 * contributors may be used to endorse or promote products derived
35 * from this software without specific prior written permission.
36 *
37 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
38 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
39 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
40 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
41 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
44 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
45 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
46 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
47 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
48 *
49 */
50
51 #include <rdma/ib_umem.h>
52 #include <rdma/ib_smi.h>
53
54 #include "hfi.h"
55
56 /* Fast memory region */
57 struct hfi1_fmr {
58 struct ib_fmr ibfmr;
59 struct hfi1_mregion mr; /* must be last */
60 };
61
to_ifmr(struct ib_fmr * ibfmr)62 static inline struct hfi1_fmr *to_ifmr(struct ib_fmr *ibfmr)
63 {
64 return container_of(ibfmr, struct hfi1_fmr, ibfmr);
65 }
66
init_mregion(struct hfi1_mregion * mr,struct ib_pd * pd,int count)67 static int init_mregion(struct hfi1_mregion *mr, struct ib_pd *pd,
68 int count)
69 {
70 int m, i = 0;
71 int rval = 0;
72
73 m = (count + HFI1_SEGSZ - 1) / HFI1_SEGSZ;
74 for (; i < m; i++) {
75 mr->map[i] = kzalloc(sizeof(*mr->map[0]), GFP_KERNEL);
76 if (!mr->map[i])
77 goto bail;
78 }
79 mr->mapsz = m;
80 init_completion(&mr->comp);
81 /* count returning the ptr to user */
82 atomic_set(&mr->refcount, 1);
83 mr->pd = pd;
84 mr->max_segs = count;
85 out:
86 return rval;
87 bail:
88 while (i)
89 kfree(mr->map[--i]);
90 rval = -ENOMEM;
91 goto out;
92 }
93
deinit_mregion(struct hfi1_mregion * mr)94 static void deinit_mregion(struct hfi1_mregion *mr)
95 {
96 int i = mr->mapsz;
97
98 mr->mapsz = 0;
99 while (i)
100 kfree(mr->map[--i]);
101 }
102
103
104 /**
105 * hfi1_get_dma_mr - get a DMA memory region
106 * @pd: protection domain for this memory region
107 * @acc: access flags
108 *
109 * Returns the memory region on success, otherwise returns an errno.
110 * Note that all DMA addresses should be created via the
111 * struct ib_dma_mapping_ops functions (see dma.c).
112 */
hfi1_get_dma_mr(struct ib_pd * pd,int acc)113 struct ib_mr *hfi1_get_dma_mr(struct ib_pd *pd, int acc)
114 {
115 struct hfi1_mr *mr = NULL;
116 struct ib_mr *ret;
117 int rval;
118
119 if (to_ipd(pd)->user) {
120 ret = ERR_PTR(-EPERM);
121 goto bail;
122 }
123
124 mr = kzalloc(sizeof(*mr), GFP_KERNEL);
125 if (!mr) {
126 ret = ERR_PTR(-ENOMEM);
127 goto bail;
128 }
129
130 rval = init_mregion(&mr->mr, pd, 0);
131 if (rval) {
132 ret = ERR_PTR(rval);
133 goto bail;
134 }
135
136
137 rval = hfi1_alloc_lkey(&mr->mr, 1);
138 if (rval) {
139 ret = ERR_PTR(rval);
140 goto bail_mregion;
141 }
142
143 mr->mr.access_flags = acc;
144 ret = &mr->ibmr;
145 done:
146 return ret;
147
148 bail_mregion:
149 deinit_mregion(&mr->mr);
150 bail:
151 kfree(mr);
152 goto done;
153 }
154
alloc_mr(int count,struct ib_pd * pd)155 static struct hfi1_mr *alloc_mr(int count, struct ib_pd *pd)
156 {
157 struct hfi1_mr *mr;
158 int rval = -ENOMEM;
159 int m;
160
161 /* Allocate struct plus pointers to first level page tables. */
162 m = (count + HFI1_SEGSZ - 1) / HFI1_SEGSZ;
163 mr = kzalloc(sizeof(*mr) + m * sizeof(mr->mr.map[0]), GFP_KERNEL);
164 if (!mr)
165 goto bail;
166
167 rval = init_mregion(&mr->mr, pd, count);
168 if (rval)
169 goto bail;
170 /*
171 * ib_reg_phys_mr() will initialize mr->ibmr except for
172 * lkey and rkey.
173 */
174 rval = hfi1_alloc_lkey(&mr->mr, 0);
175 if (rval)
176 goto bail_mregion;
177 mr->ibmr.lkey = mr->mr.lkey;
178 mr->ibmr.rkey = mr->mr.lkey;
179 done:
180 return mr;
181
182 bail_mregion:
183 deinit_mregion(&mr->mr);
184 bail:
185 kfree(mr);
186 mr = ERR_PTR(rval);
187 goto done;
188 }
189
190 /**
191 * hfi1_reg_phys_mr - register a physical memory region
192 * @pd: protection domain for this memory region
193 * @buffer_list: pointer to the list of physical buffers to register
194 * @num_phys_buf: the number of physical buffers to register
195 * @iova_start: the starting address passed over IB which maps to this MR
196 *
197 * Returns the memory region on success, otherwise returns an errno.
198 */
hfi1_reg_phys_mr(struct ib_pd * pd,struct ib_phys_buf * buffer_list,int num_phys_buf,int acc,u64 * iova_start)199 struct ib_mr *hfi1_reg_phys_mr(struct ib_pd *pd,
200 struct ib_phys_buf *buffer_list,
201 int num_phys_buf, int acc, u64 *iova_start)
202 {
203 struct hfi1_mr *mr;
204 int n, m, i;
205 struct ib_mr *ret;
206
207 mr = alloc_mr(num_phys_buf, pd);
208 if (IS_ERR(mr)) {
209 ret = (struct ib_mr *)mr;
210 goto bail;
211 }
212
213 mr->mr.user_base = *iova_start;
214 mr->mr.iova = *iova_start;
215 mr->mr.access_flags = acc;
216
217 m = 0;
218 n = 0;
219 for (i = 0; i < num_phys_buf; i++) {
220 mr->mr.map[m]->segs[n].vaddr = (void *) buffer_list[i].addr;
221 mr->mr.map[m]->segs[n].length = buffer_list[i].size;
222 mr->mr.length += buffer_list[i].size;
223 n++;
224 if (n == HFI1_SEGSZ) {
225 m++;
226 n = 0;
227 }
228 }
229
230 ret = &mr->ibmr;
231
232 bail:
233 return ret;
234 }
235
236 /**
237 * hfi1_reg_user_mr - register a userspace memory region
238 * @pd: protection domain for this memory region
239 * @start: starting userspace address
240 * @length: length of region to register
241 * @mr_access_flags: access flags for this memory region
242 * @udata: unused by the driver
243 *
244 * Returns the memory region on success, otherwise returns an errno.
245 */
hfi1_reg_user_mr(struct ib_pd * pd,u64 start,u64 length,u64 virt_addr,int mr_access_flags,struct ib_udata * udata)246 struct ib_mr *hfi1_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
247 u64 virt_addr, int mr_access_flags,
248 struct ib_udata *udata)
249 {
250 struct hfi1_mr *mr;
251 struct ib_umem *umem;
252 struct scatterlist *sg;
253 int n, m, entry;
254 struct ib_mr *ret;
255
256 if (length == 0) {
257 ret = ERR_PTR(-EINVAL);
258 goto bail;
259 }
260
261 umem = ib_umem_get(pd->uobject->context, start, length,
262 mr_access_flags, 0);
263 if (IS_ERR(umem))
264 return (void *) umem;
265
266 n = umem->nmap;
267
268 mr = alloc_mr(n, pd);
269 if (IS_ERR(mr)) {
270 ret = (struct ib_mr *)mr;
271 ib_umem_release(umem);
272 goto bail;
273 }
274
275 mr->mr.user_base = start;
276 mr->mr.iova = virt_addr;
277 mr->mr.length = length;
278 mr->mr.offset = ib_umem_offset(umem);
279 mr->mr.access_flags = mr_access_flags;
280 mr->umem = umem;
281
282 if (is_power_of_2(umem->page_size))
283 mr->mr.page_shift = ilog2(umem->page_size);
284 m = 0;
285 n = 0;
286 for_each_sg(umem->sg_head.sgl, sg, umem->nmap, entry) {
287 void *vaddr;
288
289 vaddr = page_address(sg_page(sg));
290 if (!vaddr) {
291 ret = ERR_PTR(-EINVAL);
292 goto bail;
293 }
294 mr->mr.map[m]->segs[n].vaddr = vaddr;
295 mr->mr.map[m]->segs[n].length = umem->page_size;
296 n++;
297 if (n == HFI1_SEGSZ) {
298 m++;
299 n = 0;
300 }
301 }
302 ret = &mr->ibmr;
303
304 bail:
305 return ret;
306 }
307
308 /**
309 * hfi1_dereg_mr - unregister and free a memory region
310 * @ibmr: the memory region to free
311 *
312 * Returns 0 on success.
313 *
314 * Note that this is called to free MRs created by hfi1_get_dma_mr()
315 * or hfi1_reg_user_mr().
316 */
hfi1_dereg_mr(struct ib_mr * ibmr)317 int hfi1_dereg_mr(struct ib_mr *ibmr)
318 {
319 struct hfi1_mr *mr = to_imr(ibmr);
320 int ret = 0;
321 unsigned long timeout;
322
323 hfi1_free_lkey(&mr->mr);
324
325 hfi1_put_mr(&mr->mr); /* will set completion if last */
326 timeout = wait_for_completion_timeout(&mr->mr.comp,
327 5 * HZ);
328 if (!timeout) {
329 dd_dev_err(
330 dd_from_ibdev(mr->mr.pd->device),
331 "hfi1_dereg_mr timeout mr %p pd %p refcount %u\n",
332 mr, mr->mr.pd, atomic_read(&mr->mr.refcount));
333 hfi1_get_mr(&mr->mr);
334 ret = -EBUSY;
335 goto out;
336 }
337 deinit_mregion(&mr->mr);
338 if (mr->umem)
339 ib_umem_release(mr->umem);
340 kfree(mr);
341 out:
342 return ret;
343 }
344
345 /*
346 * Allocate a memory region usable with the
347 * IB_WR_REG_MR send work request.
348 *
349 * Return the memory region on success, otherwise return an errno.
350 * FIXME: IB_WR_REG_MR is not supported
351 */
hfi1_alloc_mr(struct ib_pd * pd,enum ib_mr_type mr_type,u32 max_num_sg)352 struct ib_mr *hfi1_alloc_mr(struct ib_pd *pd,
353 enum ib_mr_type mr_type,
354 u32 max_num_sg)
355 {
356 struct hfi1_mr *mr;
357
358 if (mr_type != IB_MR_TYPE_MEM_REG)
359 return ERR_PTR(-EINVAL);
360
361 mr = alloc_mr(max_num_sg, pd);
362 if (IS_ERR(mr))
363 return (struct ib_mr *)mr;
364
365 return &mr->ibmr;
366 }
367
368 /**
369 * hfi1_alloc_fmr - allocate a fast memory region
370 * @pd: the protection domain for this memory region
371 * @mr_access_flags: access flags for this memory region
372 * @fmr_attr: fast memory region attributes
373 *
374 * Returns the memory region on success, otherwise returns an errno.
375 */
hfi1_alloc_fmr(struct ib_pd * pd,int mr_access_flags,struct ib_fmr_attr * fmr_attr)376 struct ib_fmr *hfi1_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
377 struct ib_fmr_attr *fmr_attr)
378 {
379 struct hfi1_fmr *fmr;
380 int m;
381 struct ib_fmr *ret;
382 int rval = -ENOMEM;
383
384 /* Allocate struct plus pointers to first level page tables. */
385 m = (fmr_attr->max_pages + HFI1_SEGSZ - 1) / HFI1_SEGSZ;
386 fmr = kzalloc(sizeof(*fmr) + m * sizeof(fmr->mr.map[0]), GFP_KERNEL);
387 if (!fmr)
388 goto bail;
389
390 rval = init_mregion(&fmr->mr, pd, fmr_attr->max_pages);
391 if (rval)
392 goto bail;
393
394 /*
395 * ib_alloc_fmr() will initialize fmr->ibfmr except for lkey &
396 * rkey.
397 */
398 rval = hfi1_alloc_lkey(&fmr->mr, 0);
399 if (rval)
400 goto bail_mregion;
401 fmr->ibfmr.rkey = fmr->mr.lkey;
402 fmr->ibfmr.lkey = fmr->mr.lkey;
403 /*
404 * Resources are allocated but no valid mapping (RKEY can't be
405 * used).
406 */
407 fmr->mr.access_flags = mr_access_flags;
408 fmr->mr.max_segs = fmr_attr->max_pages;
409 fmr->mr.page_shift = fmr_attr->page_shift;
410
411 ret = &fmr->ibfmr;
412 done:
413 return ret;
414
415 bail_mregion:
416 deinit_mregion(&fmr->mr);
417 bail:
418 kfree(fmr);
419 ret = ERR_PTR(rval);
420 goto done;
421 }
422
423 /**
424 * hfi1_map_phys_fmr - set up a fast memory region
425 * @ibmfr: the fast memory region to set up
426 * @page_list: the list of pages to associate with the fast memory region
427 * @list_len: the number of pages to associate with the fast memory region
428 * @iova: the virtual address of the start of the fast memory region
429 *
430 * This may be called from interrupt context.
431 */
432
hfi1_map_phys_fmr(struct ib_fmr * ibfmr,u64 * page_list,int list_len,u64 iova)433 int hfi1_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
434 int list_len, u64 iova)
435 {
436 struct hfi1_fmr *fmr = to_ifmr(ibfmr);
437 struct hfi1_lkey_table *rkt;
438 unsigned long flags;
439 int m, n, i;
440 u32 ps;
441 int ret;
442
443 i = atomic_read(&fmr->mr.refcount);
444 if (i > 2)
445 return -EBUSY;
446
447 if (list_len > fmr->mr.max_segs) {
448 ret = -EINVAL;
449 goto bail;
450 }
451 rkt = &to_idev(ibfmr->device)->lk_table;
452 spin_lock_irqsave(&rkt->lock, flags);
453 fmr->mr.user_base = iova;
454 fmr->mr.iova = iova;
455 ps = 1 << fmr->mr.page_shift;
456 fmr->mr.length = list_len * ps;
457 m = 0;
458 n = 0;
459 for (i = 0; i < list_len; i++) {
460 fmr->mr.map[m]->segs[n].vaddr = (void *) page_list[i];
461 fmr->mr.map[m]->segs[n].length = ps;
462 if (++n == HFI1_SEGSZ) {
463 m++;
464 n = 0;
465 }
466 }
467 spin_unlock_irqrestore(&rkt->lock, flags);
468 ret = 0;
469
470 bail:
471 return ret;
472 }
473
474 /**
475 * hfi1_unmap_fmr - unmap fast memory regions
476 * @fmr_list: the list of fast memory regions to unmap
477 *
478 * Returns 0 on success.
479 */
hfi1_unmap_fmr(struct list_head * fmr_list)480 int hfi1_unmap_fmr(struct list_head *fmr_list)
481 {
482 struct hfi1_fmr *fmr;
483 struct hfi1_lkey_table *rkt;
484 unsigned long flags;
485
486 list_for_each_entry(fmr, fmr_list, ibfmr.list) {
487 rkt = &to_idev(fmr->ibfmr.device)->lk_table;
488 spin_lock_irqsave(&rkt->lock, flags);
489 fmr->mr.user_base = 0;
490 fmr->mr.iova = 0;
491 fmr->mr.length = 0;
492 spin_unlock_irqrestore(&rkt->lock, flags);
493 }
494 return 0;
495 }
496
497 /**
498 * hfi1_dealloc_fmr - deallocate a fast memory region
499 * @ibfmr: the fast memory region to deallocate
500 *
501 * Returns 0 on success.
502 */
hfi1_dealloc_fmr(struct ib_fmr * ibfmr)503 int hfi1_dealloc_fmr(struct ib_fmr *ibfmr)
504 {
505 struct hfi1_fmr *fmr = to_ifmr(ibfmr);
506 int ret = 0;
507 unsigned long timeout;
508
509 hfi1_free_lkey(&fmr->mr);
510 hfi1_put_mr(&fmr->mr); /* will set completion if last */
511 timeout = wait_for_completion_timeout(&fmr->mr.comp,
512 5 * HZ);
513 if (!timeout) {
514 hfi1_get_mr(&fmr->mr);
515 ret = -EBUSY;
516 goto out;
517 }
518 deinit_mregion(&fmr->mr);
519 kfree(fmr);
520 out:
521 return ret;
522 }
523