drivers/infiniband/hw/qib/qib_mr.c

   1 /*
   2  * Copyright (c) 2006, 2007, 2008, 2009 QLogic Corporation. All rights reserved.
   3  * Copyright (c) 2005, 2006 PathScale, Inc. 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 <rdma/ib_umem.h>
  35 #include <rdma/ib_smi.h>
  36
  37 #include "qib.h"
  38
  39 /* Fast memory region */
  40 struct qib_fmr {
  41         struct ib_fmr ibfmr;
  42         struct qib_mregion mr;        /* must be last */
  43 };
  44
  45 static inline struct qib_fmr *to_ifmr(struct ib_fmr *ibfmr)
  46 {
  47         return container_of(ibfmr, struct qib_fmr, ibfmr);
  48 }
  49
  50 static int init_qib_mregion(struct qib_mregion *mr, struct ib_pd *pd,
  51         int count)
  52 {
  53         int m, i = 0;
  54         int rval = 0;
  55
  56         m = (count + QIB_SEGSZ - 1) / QIB_SEGSZ;
  57         for (; i < m; i++) {
  58                 mr->map[i] = kzalloc(sizeof(*mr->map[0]), GFP_KERNEL);
  59                 if (!mr->map[i])
  60                         goto bail;
  61         }
  62         mr->mapsz = m;
  63         init_completion(&mr->comp);
  64         /* count returning the ptr to user */
  65         atomic_set(&mr->refcount, 1);
  66         mr->pd = pd;
  67         mr->max_segs = count;
  68 out:
  69         return rval;
  70 bail:
  71         while (i)
  72                 kfree(mr->map[--i]);
  73         rval = -ENOMEM;
  74         goto out;
  75 }
  76
  77 static void deinit_qib_mregion(struct qib_mregion *mr)
  78 {
  79         int i = mr->mapsz;
  80
  81         mr->mapsz = 0;
  82         while (i)
  83                 kfree(mr->map[--i]);
  84 }
  85
  86
  87 /**
  88  * qib_get_dma_mr - get a DMA memory region
  89  * @pd: protection domain for this memory region
  90  * @acc: access flags
  91  *
  92  * Returns the memory region on success, otherwise returns an errno.
  93  * Note that all DMA addresses should be created via the
  94  * struct ib_dma_mapping_ops functions (see qib_dma.c).
  95  */
  96 struct ib_mr *qib_get_dma_mr(struct ib_pd *pd, int acc)
  97 {
  98         struct qib_mr *mr = NULL;
  99         struct ib_mr *ret;
 100         int rval;
 101
 102         if (to_ipd(pd)->user) {
 103                 ret = ERR_PTR(-EPERM);
 104                 goto bail;
 105         }
 106
 107         mr = kzalloc(sizeof(*mr), GFP_KERNEL);
 108         if (!mr) {
 109                 ret = ERR_PTR(-ENOMEM);
 110                 goto bail;
 111         }
 112
 113         rval = init_qib_mregion(&mr->mr, pd, 0);
 114         if (rval) {
 115                 ret = ERR_PTR(rval);
 116                 goto bail;
 117         }
 118
 119
 120         rval = qib_alloc_lkey(&mr->mr, 1);
 121         if (rval) {
 122                 ret = ERR_PTR(rval);
 123                 goto bail_mregion;
 124         }
 125
 126         mr->mr.access_flags = acc;
 127         ret = &mr->ibmr;
 128 done:
 129         return ret;
 130
 131 bail_mregion:
 132         deinit_qib_mregion(&mr->mr);
 133 bail:
 134         kfree(mr);
 135         goto done;
 136 }
 137
 138 static struct qib_mr *alloc_mr(int count, struct ib_pd *pd)
 139 {
 140         struct qib_mr *mr;
 141         int rval = -ENOMEM;
 142         int m;
 143
 144         /* Allocate struct plus pointers to first level page tables. */
 145         m = (count + QIB_SEGSZ - 1) / QIB_SEGSZ;
 146         mr = kzalloc(sizeof(*mr) + m * sizeof(mr->mr.map[0]), GFP_KERNEL);
 147         if (!mr)
 148                 goto bail;
 149
 150         rval = init_qib_mregion(&mr->mr, pd, count);
 151         if (rval)
 152                 goto bail;
 153
 154         rval = qib_alloc_lkey(&mr->mr, 0);
 155         if (rval)
 156                 goto bail_mregion;
 157         mr->ibmr.lkey = mr->mr.lkey;
 158         mr->ibmr.rkey = mr->mr.lkey;
 159 done:
 160         return mr;
 161
 162 bail_mregion:
 163         deinit_qib_mregion(&mr->mr);
 164 bail:
 165         kfree(mr);
 166         mr = ERR_PTR(rval);
 167         goto done;
 168 }
 169
 170 /**
 171  * qib_reg_user_mr - register a userspace memory region
 172  * @pd: protection domain for this memory region
 173  * @start: starting userspace address
 174  * @length: length of region to register
 175  * @mr_access_flags: access flags for this memory region
 176  * @udata: unused by the QLogic_IB driver
 177  *
 178  * Returns the memory region on success, otherwise returns an errno.
 179  */
 180 struct ib_mr *qib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
 181                               u64 virt_addr, int mr_access_flags,
 182                               struct ib_udata *udata)
 183 {
 184         struct qib_mr *mr;
 185         struct ib_umem *umem;
 186         struct scatterlist *sg;
 187         int n, m, entry;
 188         struct ib_mr *ret;
 189
 190         if (length == 0) {
 191                 ret = ERR_PTR(-EINVAL);
 192                 goto bail;
 193         }
 194
 195         umem = ib_umem_get(pd->uobject->context, start, length,
 196                            mr_access_flags, 0);
 197         if (IS_ERR(umem))
 198                 return (void *) umem;
 199
 200         n = umem->nmap;
 201
 202         mr = alloc_mr(n, pd);
 203         if (IS_ERR(mr)) {
 204                 ret = (struct ib_mr *)mr;
 205                 ib_umem_release(umem);
 206                 goto bail;
 207         }
 208
 209         mr->mr.user_base = start;
 210         mr->mr.iova = virt_addr;
 211         mr->mr.length = length;
 212         mr->mr.offset = ib_umem_offset(umem);
 213         mr->mr.access_flags = mr_access_flags;
 214         mr->umem = umem;
 215
 216         if (is_power_of_2(umem->page_size))
 217                 mr->mr.page_shift = ilog2(umem->page_size);
 218         m = 0;
 219         n = 0;
 220         for_each_sg(umem->sg_head.sgl, sg, umem->nmap, entry) {
 221                         void *vaddr;
 222
 223                         vaddr = page_address(sg_page(sg));
 224                         if (!vaddr) {
 225                                 ret = ERR_PTR(-EINVAL);
 226                                 goto bail;
 227                         }
 228                         mr->mr.map[m]->segs[n].vaddr = vaddr;
 229                         mr->mr.map[m]->segs[n].length = umem->page_size;
 230                         n++;
 231                         if (n == QIB_SEGSZ) {
 232                                 m++;
 233                                 n = 0;
 234                         }
 235         }
 236         ret = &mr->ibmr;
 237
 238 bail:
 239         return ret;
 240 }
 241
 242 /**
 243  * qib_dereg_mr - unregister and free a memory region
 244  * @ibmr: the memory region to free
 245  *
 246  * Returns 0 on success.
 247  *
 248  * Note that this is called to free MRs created by qib_get_dma_mr()
 249  * or qib_reg_user_mr().
 250  */
 251 int qib_dereg_mr(struct ib_mr *ibmr)
 252 {
 253         struct qib_mr *mr = to_imr(ibmr);
 254         int ret = 0;
 255         unsigned long timeout;
 256
 257         kfree(mr->pages);
 258         qib_free_lkey(&mr->mr);
 259
 260         qib_put_mr(&mr->mr); /* will set completion if last */
 261         timeout = wait_for_completion_timeout(&mr->mr.comp,
 262                 5 * HZ);
 263         if (!timeout) {
 264                 qib_get_mr(&mr->mr);
 265                 ret = -EBUSY;
 266                 goto out;
 267         }
 268         deinit_qib_mregion(&mr->mr);
 269         if (mr->umem)
 270                 ib_umem_release(mr->umem);
 271         kfree(mr);
 272 out:
 273         return ret;
 274 }
 275
 276 /*
 277  * Allocate a memory region usable with the
 278  * IB_WR_REG_MR send work request.
 279  *
 280  * Return the memory region on success, otherwise return an errno.
 281  */
 282 struct ib_mr *qib_alloc_mr(struct ib_pd *pd,
 283                            enum ib_mr_type mr_type,
 284                            u32 max_num_sg)
 285 {
 286         struct qib_mr *mr;
 287
 288         if (mr_type != IB_MR_TYPE_MEM_REG)
 289                 return ERR_PTR(-EINVAL);
 290
 291         mr = alloc_mr(max_num_sg, pd);
 292         if (IS_ERR(mr))
 293                 return (struct ib_mr *)mr;
 294
 295         mr->pages = kcalloc(max_num_sg, sizeof(u64), GFP_KERNEL);
 296         if (!mr->pages)
 297                 goto err;
 298
 299         return &mr->ibmr;
 300
 301 err:
 302         qib_dereg_mr(&mr->ibmr);
 303         return ERR_PTR(-ENOMEM);
 304 }
 305
 306 static int qib_set_page(struct ib_mr *ibmr, u64 addr)
 307 {
 308         struct qib_mr *mr = to_imr(ibmr);
 309
 310         if (unlikely(mr->npages == mr->mr.max_segs))
 311                 return -ENOMEM;
 312
 313         mr->pages[mr->npages++] = addr;
 314
 315         return 0;
 316 }
 317
 318 int qib_map_mr_sg(struct ib_mr *ibmr,
 319                   struct scatterlist *sg,
 320                   int sg_nents)
 321 {
 322         struct qib_mr *mr = to_imr(ibmr);
 323
 324         mr->npages = 0;
 325
 326         return ib_sg_to_pages(ibmr, sg, sg_nents, qib_set_page);
 327 }
 328
 329 /**
 330  * qib_alloc_fmr - allocate a fast memory region
 331  * @pd: the protection domain for this memory region
 332  * @mr_access_flags: access flags for this memory region
 333  * @fmr_attr: fast memory region attributes
 334  *
 335  * Returns the memory region on success, otherwise returns an errno.
 336  */
 337 struct ib_fmr *qib_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
 338                              struct ib_fmr_attr *fmr_attr)
 339 {
 340         struct qib_fmr *fmr;
 341         int m;
 342         struct ib_fmr *ret;
 343         int rval = -ENOMEM;
 344
 345         /* Allocate struct plus pointers to first level page tables. */
 346         m = (fmr_attr->max_pages + QIB_SEGSZ - 1) / QIB_SEGSZ;
 347         fmr = kzalloc(sizeof(*fmr) + m * sizeof(fmr->mr.map[0]), GFP_KERNEL);
 348         if (!fmr)
 349                 goto bail;
 350
 351         rval = init_qib_mregion(&fmr->mr, pd, fmr_attr->max_pages);
 352         if (rval)
 353                 goto bail;
 354
 355         /*
 356          * ib_alloc_fmr() will initialize fmr->ibfmr except for lkey &
 357          * rkey.
 358          */
 359         rval = qib_alloc_lkey(&fmr->mr, 0);
 360         if (rval)
 361                 goto bail_mregion;
 362         fmr->ibfmr.rkey = fmr->mr.lkey;
 363         fmr->ibfmr.lkey = fmr->mr.lkey;
 364         /*
 365          * Resources are allocated but no valid mapping (RKEY can't be
 366          * used).
 367          */
 368         fmr->mr.access_flags = mr_access_flags;
 369         fmr->mr.max_segs = fmr_attr->max_pages;
 370         fmr->mr.page_shift = fmr_attr->page_shift;
 371
 372         ret = &fmr->ibfmr;
 373 done:
 374         return ret;
 375
 376 bail_mregion:
 377         deinit_qib_mregion(&fmr->mr);
 378 bail:
 379         kfree(fmr);
 380         ret = ERR_PTR(rval);
 381         goto done;
 382 }
 383
 384 /**
 385  * qib_map_phys_fmr - set up a fast memory region
 386  * @ibmfr: the fast memory region to set up
 387  * @page_list: the list of pages to associate with the fast memory region
 388  * @list_len: the number of pages to associate with the fast memory region
 389  * @iova: the virtual address of the start of the fast memory region
 390  *
 391  * This may be called from interrupt context.
 392  */
 393
 394 int qib_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
 395                      int list_len, u64 iova)
 396 {
 397         struct qib_fmr *fmr = to_ifmr(ibfmr);
 398         struct qib_lkey_table *rkt;
 399         unsigned long flags;
 400         int m, n, i;
 401         u32 ps;
 402         int ret;
 403
 404         i = atomic_read(&fmr->mr.refcount);
 405         if (i > 2)
 406                 return -EBUSY;
 407
 408         if (list_len > fmr->mr.max_segs) {
 409                 ret = -EINVAL;
 410                 goto bail;
 411         }
 412         rkt = &to_idev(ibfmr->device)->lk_table;
 413         spin_lock_irqsave(&rkt->lock, flags);
 414         fmr->mr.user_base = iova;
 415         fmr->mr.iova = iova;
 416         ps = 1 << fmr->mr.page_shift;
 417         fmr->mr.length = list_len * ps;
 418         m = 0;
 419         n = 0;
 420         for (i = 0; i < list_len; i++) {
 421                 fmr->mr.map[m]->segs[n].vaddr = (void *) page_list[i];
 422                 fmr->mr.map[m]->segs[n].length = ps;
 423                 if (++n == QIB_SEGSZ) {
 424                         m++;
 425                         n = 0;
 426                 }
 427         }
 428         spin_unlock_irqrestore(&rkt->lock, flags);
 429         ret = 0;
 430
 431 bail:
 432         return ret;
 433 }
 434
 435 /**
 436  * qib_unmap_fmr - unmap fast memory regions
 437  * @fmr_list: the list of fast memory regions to unmap
 438  *
 439  * Returns 0 on success.
 440  */
 441 int qib_unmap_fmr(struct list_head *fmr_list)
 442 {
 443         struct qib_fmr *fmr;
 444         struct qib_lkey_table *rkt;
 445         unsigned long flags;
 446
 447         list_for_each_entry(fmr, fmr_list, ibfmr.list) {
 448                 rkt = &to_idev(fmr->ibfmr.device)->lk_table;
 449                 spin_lock_irqsave(&rkt->lock, flags);
 450                 fmr->mr.user_base = 0;
 451                 fmr->mr.iova = 0;
 452                 fmr->mr.length = 0;
 453                 spin_unlock_irqrestore(&rkt->lock, flags);
 454         }
 455         return 0;
 456 }
 457
 458 /**
 459  * qib_dealloc_fmr - deallocate a fast memory region
 460  * @ibfmr: the fast memory region to deallocate
 461  *
 462  * Returns 0 on success.
 463  */
 464 int qib_dealloc_fmr(struct ib_fmr *ibfmr)
 465 {
 466         struct qib_fmr *fmr = to_ifmr(ibfmr);
 467         int ret = 0;
 468         unsigned long timeout;
 469
 470         qib_free_lkey(&fmr->mr);
 471         qib_put_mr(&fmr->mr); /* will set completion if last */
 472         timeout = wait_for_completion_timeout(&fmr->mr.comp,
 473                 5 * HZ);
 474         if (!timeout) {
 475                 qib_get_mr(&fmr->mr);
 476                 ret = -EBUSY;
 477                 goto out;
 478         }
 479         deinit_qib_mregion(&fmr->mr);
 480         kfree(fmr);
 481 out:
 482         return ret;
 483 }
 484
 485 void mr_rcu_callback(struct rcu_head *list)
 486 {
 487         struct qib_mregion *mr = container_of(list, struct qib_mregion, list);
 488
 489         complete(&mr->comp);
 490 }