drivers/infiniband/ulp/iser/iser_memory.c

   1 /*
   2  * Copyright (c) 2004, 2005, 2006 Voltaire, Inc. All rights reserved.
   3  * Copyright (c) 2013-2014 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 #include <linux/module.h>
  34 #include <linux/kernel.h>
  35 #include <linux/slab.h>
  36 #include <linux/mm.h>
  37 #include <linux/highmem.h>
  38 #include <linux/scatterlist.h>
  39
  40 #include "iscsi_iser.h"
  41
  42 static struct iser_reg_ops fastreg_ops = {
  43         .alloc_reg_res  = iser_alloc_fastreg_pool,
  44         .free_reg_res   = iser_free_fastreg_pool,
  45         .reg_rdma_mem   = iser_reg_rdma_mem_fastreg,
  46         .unreg_rdma_mem = iser_unreg_mem_fastreg,
  47 };
  48
  49 static struct iser_reg_ops fmr_ops = {
  50         .alloc_reg_res  = iser_alloc_fmr_pool,
  51         .free_reg_res   = iser_free_fmr_pool,
  52         .reg_rdma_mem   = iser_reg_rdma_mem_fmr,
  53         .unreg_rdma_mem = iser_unreg_mem_fmr,
  54 };
  55
  56 int iser_assign_reg_ops(struct iser_device *device)
  57 {
  58         struct ib_device_attr *dev_attr = &device->dev_attr;
  59
  60         /* Assign function handles  - based on FMR support */
  61         if (device->ib_device->alloc_fmr && device->ib_device->dealloc_fmr &&
  62             device->ib_device->map_phys_fmr && device->ib_device->unmap_fmr) {
  63                 iser_info("FMR supported, using FMR for registration\n");
  64                 device->reg_ops = &fmr_ops;
  65         } else
  66         if (dev_attr->device_cap_flags & IB_DEVICE_MEM_MGT_EXTENSIONS) {
  67                 iser_info("FastReg supported, using FastReg for registration\n");
  68                 device->reg_ops = &fastreg_ops;
  69         } else {
  70                 iser_err("IB device does not support FMRs nor FastRegs, can't register memory\n");
  71                 return -1;
  72         }
  73
  74         return 0;
  75 }
  76
  77 static void
  78 iser_free_bounce_sg(struct iser_data_buf *data)
  79 {
  80         struct scatterlist *sg;
  81         int count;
  82
  83         for_each_sg(data->sg, sg, data->size, count)
  84                 __free_page(sg_page(sg));
  85
  86         kfree(data->sg);
  87
  88         data->sg = data->orig_sg;
  89         data->size = data->orig_size;
  90         data->orig_sg = NULL;
  91         data->orig_size = 0;
  92 }
  93
  94 static int
  95 iser_alloc_bounce_sg(struct iser_data_buf *data)
  96 {
  97         struct scatterlist *sg;
  98         struct page *page;
  99         unsigned long length = data->data_len;
 100         int i = 0, nents = DIV_ROUND_UP(length, PAGE_SIZE);
 101
 102         sg = kcalloc(nents, sizeof(*sg), GFP_ATOMIC);
 103         if (!sg)
 104                 goto err;
 105
 106         sg_init_table(sg, nents);
 107         while (length) {
 108                 u32 page_len = min_t(u32, length, PAGE_SIZE);
 109
 110                 page = alloc_page(GFP_ATOMIC);
 111                 if (!page)
 112                         goto err;
 113
 114                 sg_set_page(&sg[i], page, page_len, 0);
 115                 length -= page_len;
 116                 i++;
 117         }
 118
 119         data->orig_sg = data->sg;
 120         data->orig_size = data->size;
 121         data->sg = sg;
 122         data->size = nents;
 123
 124         return 0;
 125
 126 err:
 127         for (; i > 0; i--)
 128                 __free_page(sg_page(&sg[i - 1]));
 129         kfree(sg);
 130
 131         return -ENOMEM;
 132 }
 133
 134 static void
 135 iser_copy_bounce(struct iser_data_buf *data, bool to_buffer)
 136 {
 137         struct scatterlist *osg, *bsg = data->sg;
 138         void *oaddr, *baddr;
 139         unsigned int left = data->data_len;
 140         unsigned int bsg_off = 0;
 141         int i;
 142
 143         for_each_sg(data->orig_sg, osg, data->orig_size, i) {
 144                 unsigned int copy_len, osg_off = 0;
 145
 146                 oaddr = kmap_atomic(sg_page(osg)) + osg->offset;
 147                 copy_len = min(left, osg->length);
 148                 while (copy_len) {
 149                         unsigned int len = min(copy_len, bsg->length - bsg_off);
 150
 151                         baddr = kmap_atomic(sg_page(bsg)) + bsg->offset;
 152                         if (to_buffer)
 153                                 memcpy(baddr + bsg_off, oaddr + osg_off, len);
 154                         else
 155                                 memcpy(oaddr + osg_off, baddr + bsg_off, len);
 156
 157                         kunmap_atomic(baddr - bsg->offset);
 158                         osg_off += len;
 159                         bsg_off += len;
 160                         copy_len -= len;
 161
 162                         if (bsg_off >= bsg->length) {
 163                                 bsg = sg_next(bsg);
 164                                 bsg_off = 0;
 165                         }
 166                 }
 167                 kunmap_atomic(oaddr - osg->offset);
 168                 left -= osg_off;
 169         }
 170 }
 171
 172 static inline void
 173 iser_copy_from_bounce(struct iser_data_buf *data)
 174 {
 175         iser_copy_bounce(data, false);
 176 }
 177
 178 static inline void
 179 iser_copy_to_bounce(struct iser_data_buf *data)
 180 {
 181         iser_copy_bounce(data, true);
 182 }
 183
 184 struct iser_fr_desc *
 185 iser_reg_desc_get(struct ib_conn *ib_conn)
 186 {
 187         struct iser_fr_pool *fr_pool = &ib_conn->fr_pool;
 188         struct iser_fr_desc *desc;
 189         unsigned long flags;
 190
 191         spin_lock_irqsave(&fr_pool->lock, flags);
 192         desc = list_first_entry(&fr_pool->list,
 193                                 struct iser_fr_desc, list);
 194         list_del(&desc->list);
 195         spin_unlock_irqrestore(&fr_pool->lock, flags);
 196
 197         return desc;
 198 }
 199
 200 void
 201 iser_reg_desc_put(struct ib_conn *ib_conn,
 202                   struct iser_fr_desc *desc)
 203 {
 204         struct iser_fr_pool *fr_pool = &ib_conn->fr_pool;
 205         unsigned long flags;
 206
 207         spin_lock_irqsave(&fr_pool->lock, flags);
 208         list_add(&desc->list, &fr_pool->list);
 209         spin_unlock_irqrestore(&fr_pool->lock, flags);
 210 }
 211
 212 /**
 213  * iser_start_rdma_unaligned_sg
 214  */
 215 static int iser_start_rdma_unaligned_sg(struct iscsi_iser_task *iser_task,
 216                                         struct iser_data_buf *data,
 217                                         enum iser_data_dir cmd_dir)
 218 {
 219         struct ib_device *dev = iser_task->iser_conn->ib_conn.device->ib_device;
 220         int rc;
 221
 222         rc = iser_alloc_bounce_sg(data);
 223         if (rc) {
 224                 iser_err("Failed to allocate bounce for data len %lu\n",
 225                          data->data_len);
 226                 return rc;
 227         }
 228
 229         if (cmd_dir == ISER_DIR_OUT)
 230                 iser_copy_to_bounce(data);
 231
 232         data->dma_nents = ib_dma_map_sg(dev, data->sg, data->size,
 233                                         (cmd_dir == ISER_DIR_OUT) ?
 234                                         DMA_TO_DEVICE : DMA_FROM_DEVICE);
 235         if (!data->dma_nents) {
 236                 iser_err("Got dma_nents %d, something went wrong...\n",
 237                          data->dma_nents);
 238                 rc = -ENOMEM;
 239                 goto err;
 240         }
 241
 242         return 0;
 243 err:
 244         iser_free_bounce_sg(data);
 245         return rc;
 246 }
 247
 248 /**
 249  * iser_finalize_rdma_unaligned_sg
 250  */
 251
 252 void iser_finalize_rdma_unaligned_sg(struct iscsi_iser_task *iser_task,
 253                                      struct iser_data_buf *data,
 254                                      enum iser_data_dir cmd_dir)
 255 {
 256         struct ib_device *dev = iser_task->iser_conn->ib_conn.device->ib_device;
 257
 258         ib_dma_unmap_sg(dev, data->sg, data->size,
 259                         (cmd_dir == ISER_DIR_OUT) ?
 260                         DMA_TO_DEVICE : DMA_FROM_DEVICE);
 261
 262         if (cmd_dir == ISER_DIR_IN)
 263                 iser_copy_from_bounce(data);
 264
 265         iser_free_bounce_sg(data);
 266 }
 267
 268 #define IS_4K_ALIGNED(addr)     ((((unsigned long)addr) & ~MASK_4K) == 0)
 269
 270 /**
 271  * iser_sg_to_page_vec - Translates scatterlist entries to physical addresses
 272  * and returns the length of resulting physical address array (may be less than
 273  * the original due to possible compaction).
 274  *
 275  * we build a "page vec" under the assumption that the SG meets the RDMA
 276  * alignment requirements. Other then the first and last SG elements, all
 277  * the "internal" elements can be compacted into a list whose elements are
 278  * dma addresses of physical pages. The code supports also the weird case
 279  * where --few fragments of the same page-- are present in the SG as
 280  * consecutive elements. Also, it handles one entry SG.
 281  */
 282
 283 static int iser_sg_to_page_vec(struct iser_data_buf *data,
 284                                struct ib_device *ibdev, u64 *pages,
 285                                int *offset, int *data_size)
 286 {
 287         struct scatterlist *sg, *sgl = data->sg;
 288         u64 start_addr, end_addr, page, chunk_start = 0;
 289         unsigned long total_sz = 0;
 290         unsigned int dma_len;
 291         int i, new_chunk, cur_page, last_ent = data->dma_nents - 1;
 292
 293         /* compute the offset of first element */
 294         *offset = (u64) sgl[0].offset & ~MASK_4K;
 295
 296         new_chunk = 1;
 297         cur_page  = 0;
 298         for_each_sg(sgl, sg, data->dma_nents, i) {
 299                 start_addr = ib_sg_dma_address(ibdev, sg);
 300                 if (new_chunk)
 301                         chunk_start = start_addr;
 302                 dma_len = ib_sg_dma_len(ibdev, sg);
 303                 end_addr = start_addr + dma_len;
 304                 total_sz += dma_len;
 305
 306                 /* collect page fragments until aligned or end of SG list */
 307                 if (!IS_4K_ALIGNED(end_addr) && i < last_ent) {
 308                         new_chunk = 0;
 309                         continue;
 310                 }
 311                 new_chunk = 1;
 312
 313                 /* address of the first page in the contiguous chunk;
 314                    masking relevant for the very first SG entry,
 315                    which might be unaligned */
 316                 page = chunk_start & MASK_4K;
 317                 do {
 318                         pages[cur_page++] = page;
 319                         page += SIZE_4K;
 320                 } while (page < end_addr);
 321         }
 322
 323         *data_size = total_sz;
 324         iser_dbg("page_vec->data_size:%d cur_page %d\n",
 325                  *data_size, cur_page);
 326         return cur_page;
 327 }
 328
 329
 330 /**
 331  * iser_data_buf_aligned_len - Tries to determine the maximal correctly aligned
 332  * for RDMA sub-list of a scatter-gather list of memory buffers, and  returns
 333  * the number of entries which are aligned correctly. Supports the case where
 334  * consecutive SG elements are actually fragments of the same physcial page.
 335  */
 336 static int iser_data_buf_aligned_len(struct iser_data_buf *data,
 337                                       struct ib_device *ibdev)
 338 {
 339         struct scatterlist *sg, *sgl, *next_sg = NULL;
 340         u64 start_addr, end_addr;
 341         int i, ret_len, start_check = 0;
 342
 343         if (data->dma_nents == 1)
 344                 return 1;
 345
 346         sgl = data->sg;
 347         start_addr  = ib_sg_dma_address(ibdev, sgl);
 348
 349         for_each_sg(sgl, sg, data->dma_nents, i) {
 350                 if (start_check && !IS_4K_ALIGNED(start_addr))
 351                         break;
 352
 353                 next_sg = sg_next(sg);
 354                 if (!next_sg)
 355                         break;
 356
 357                 end_addr    = start_addr + ib_sg_dma_len(ibdev, sg);
 358                 start_addr  = ib_sg_dma_address(ibdev, next_sg);
 359
 360                 if (end_addr == start_addr) {
 361                         start_check = 0;
 362                         continue;
 363                 } else
 364                         start_check = 1;
 365
 366                 if (!IS_4K_ALIGNED(end_addr))
 367                         break;
 368         }
 369         ret_len = (next_sg) ? i : i+1;
 370
 371         if (unlikely(ret_len != data->dma_nents))
 372                 iser_warn("rdma alignment violation (%d/%d aligned)\n",
 373                           ret_len, data->dma_nents);
 374
 375         return ret_len;
 376 }
 377
 378 static void iser_data_buf_dump(struct iser_data_buf *data,
 379                                struct ib_device *ibdev)
 380 {
 381         struct scatterlist *sg;
 382         int i;
 383
 384         for_each_sg(data->sg, sg, data->dma_nents, i)
 385                 iser_dbg("sg[%d] dma_addr:0x%lX page:0x%p "
 386                          "off:0x%x sz:0x%x dma_len:0x%x\n",
 387                          i, (unsigned long)ib_sg_dma_address(ibdev, sg),
 388                          sg_page(sg), sg->offset,
 389                          sg->length, ib_sg_dma_len(ibdev, sg));
 390 }
 391
 392 static void iser_dump_page_vec(struct iser_page_vec *page_vec)
 393 {
 394         int i;
 395
 396         iser_err("page vec length %d data size %d\n",
 397                  page_vec->length, page_vec->data_size);
 398         for (i = 0; i < page_vec->length; i++)
 399                 iser_err("%d %lx\n",i,(unsigned long)page_vec->pages[i]);
 400 }
 401
 402 int iser_dma_map_task_data(struct iscsi_iser_task *iser_task,
 403                             struct iser_data_buf *data,
 404                             enum iser_data_dir iser_dir,
 405                             enum dma_data_direction dma_dir)
 406 {
 407         struct ib_device *dev;
 408
 409         iser_task->dir[iser_dir] = 1;
 410         dev = iser_task->iser_conn->ib_conn.device->ib_device;
 411
 412         data->dma_nents = ib_dma_map_sg(dev, data->sg, data->size, dma_dir);
 413         if (data->dma_nents == 0) {
 414                 iser_err("dma_map_sg failed!!!\n");
 415                 return -EINVAL;
 416         }
 417         return 0;
 418 }
 419
 420 void iser_dma_unmap_task_data(struct iscsi_iser_task *iser_task,
 421                               struct iser_data_buf *data,
 422                               enum dma_data_direction dir)
 423 {
 424         struct ib_device *dev;
 425
 426         dev = iser_task->iser_conn->ib_conn.device->ib_device;
 427         ib_dma_unmap_sg(dev, data->sg, data->size, dir);
 428 }
 429
 430 static int
 431 iser_reg_dma(struct iser_device *device, struct iser_data_buf *mem,
 432              struct iser_mem_reg *reg)
 433 {
 434         struct scatterlist *sg = mem->sg;
 435
 436         reg->sge.lkey = device->mr->lkey;
 437         reg->rkey = device->mr->rkey;
 438         reg->sge.addr = ib_sg_dma_address(device->ib_device, &sg[0]);
 439         reg->sge.length = ib_sg_dma_len(device->ib_device, &sg[0]);
 440
 441         iser_dbg("Single DMA entry: lkey=0x%x, rkey=0x%x, addr=0x%llx,"
 442                  " length=0x%x\n", reg->sge.lkey, reg->rkey,
 443                  reg->sge.addr, reg->sge.length);
 444
 445         return 0;
 446 }
 447
 448 static int fall_to_bounce_buf(struct iscsi_iser_task *iser_task,
 449                               struct iser_data_buf *mem,
 450                               enum iser_data_dir cmd_dir)
 451 {
 452         struct iscsi_conn *iscsi_conn = iser_task->iser_conn->iscsi_conn;
 453         struct iser_device *device = iser_task->iser_conn->ib_conn.device;
 454
 455         iscsi_conn->fmr_unalign_cnt++;
 456
 457         if (iser_debug_level > 0)
 458                 iser_data_buf_dump(mem, device->ib_device);
 459
 460         /* unmap the command data before accessing it */
 461         iser_dma_unmap_task_data(iser_task, mem,
 462                                  (cmd_dir == ISER_DIR_OUT) ?
 463                                  DMA_TO_DEVICE : DMA_FROM_DEVICE);
 464
 465         /* allocate copy buf, if we are writing, copy the */
 466         /* unaligned scatterlist, dma map the copy        */
 467         if (iser_start_rdma_unaligned_sg(iser_task, mem, cmd_dir) != 0)
 468                 return -ENOMEM;
 469
 470         return 0;
 471 }
 472
 473 /**
 474  * iser_reg_page_vec - Register physical memory
 475  *
 476  * returns: 0 on success, errno code on failure
 477  */
 478 static
 479 int iser_fast_reg_fmr(struct iscsi_iser_task *iser_task,
 480                       struct iser_data_buf *mem,
 481                       struct iser_reg_resources *rsc,
 482                       struct iser_mem_reg *reg)
 483 {
 484         struct ib_conn *ib_conn = &iser_task->iser_conn->ib_conn;
 485         struct iser_device *device = ib_conn->device;
 486         struct iser_page_vec *page_vec = rsc->page_vec;
 487         struct ib_fmr_pool *fmr_pool = rsc->fmr_pool;
 488         struct ib_pool_fmr *fmr;
 489         int ret, plen;
 490
 491         plen = iser_sg_to_page_vec(mem, device->ib_device,
 492                                    page_vec->pages,
 493                                    &page_vec->offset,
 494                                    &page_vec->data_size);
 495         page_vec->length = plen;
 496         if (plen * SIZE_4K < page_vec->data_size) {
 497                 iser_err("page vec too short to hold this SG\n");
 498                 iser_data_buf_dump(mem, device->ib_device);
 499                 iser_dump_page_vec(page_vec);
 500                 return -EINVAL;
 501         }
 502
 503         fmr  = ib_fmr_pool_map_phys(fmr_pool,
 504                                     page_vec->pages,
 505                                     page_vec->length,
 506                                     page_vec->pages[0]);
 507         if (IS_ERR(fmr)) {
 508                 ret = PTR_ERR(fmr);
 509                 iser_err("ib_fmr_pool_map_phys failed: %d\n", ret);
 510                 return ret;
 511         }
 512
 513         reg->sge.lkey = fmr->fmr->lkey;
 514         reg->rkey = fmr->fmr->rkey;
 515         reg->sge.addr = page_vec->pages[0] + page_vec->offset;
 516         reg->sge.length = page_vec->data_size;
 517         reg->mem_h = fmr;
 518
 519         return 0;
 520 }
 521
 522 /**
 523  * Unregister (previosuly registered using FMR) memory.
 524  * If memory is non-FMR does nothing.
 525  */
 526 void iser_unreg_mem_fmr(struct iscsi_iser_task *iser_task,
 527                         enum iser_data_dir cmd_dir)
 528 {
 529         struct iser_mem_reg *reg = &iser_task->rdma_reg[cmd_dir];
 530         int ret;
 531
 532         if (!reg->mem_h)
 533                 return;
 534
 535         iser_dbg("PHYSICAL Mem.Unregister mem_h %p\n", reg->mem_h);
 536
 537         ret = ib_fmr_pool_unmap((struct ib_pool_fmr *)reg->mem_h);
 538         if (ret)
 539                 iser_err("ib_fmr_pool_unmap failed %d\n", ret);
 540
 541         reg->mem_h = NULL;
 542 }
 543
 544 void iser_unreg_mem_fastreg(struct iscsi_iser_task *iser_task,
 545                             enum iser_data_dir cmd_dir)
 546 {
 547         struct iser_mem_reg *reg = &iser_task->rdma_reg[cmd_dir];
 548
 549         if (!reg->mem_h)
 550                 return;
 551
 552         iser_reg_desc_put(&iser_task->iser_conn->ib_conn,
 553                           reg->mem_h);
 554         reg->mem_h = NULL;
 555 }
 556
 557 /**
 558  * iser_reg_rdma_mem_fmr - Registers memory intended for RDMA,
 559  * using FMR (if possible) obtaining rkey and va
 560  *
 561  * returns 0 on success, errno code on failure
 562  */
 563 int iser_reg_rdma_mem_fmr(struct iscsi_iser_task *iser_task,
 564                           enum iser_data_dir cmd_dir)
 565 {
 566         struct ib_conn *ib_conn = &iser_task->iser_conn->ib_conn;
 567         struct iser_fr_pool *fr_pool = &ib_conn->fr_pool;
 568         struct iser_device   *device = ib_conn->device;
 569         struct ib_device     *ibdev = device->ib_device;
 570         struct iser_data_buf *mem = &iser_task->data[cmd_dir];
 571         struct iser_mem_reg *mem_reg;
 572         int aligned_len;
 573         int err;
 574         int i;
 575
 576         mem_reg = &iser_task->rdma_reg[cmd_dir];
 577
 578         aligned_len = iser_data_buf_aligned_len(mem, ibdev);
 579         if (aligned_len != mem->dma_nents) {
 580                 err = fall_to_bounce_buf(iser_task, mem, cmd_dir);
 581                 if (err) {
 582                         iser_err("failed to allocate bounce buffer\n");
 583                         return err;
 584                 }
 585         }
 586
 587         /* if there a single dma entry, FMR is not needed */
 588         if (mem->dma_nents == 1) {
 589                 return iser_reg_dma(device, mem, mem_reg);
 590         } else { /* use FMR for multiple dma entries */
 591                 struct iser_fr_desc *desc;
 592
 593                 desc = list_first_entry(&fr_pool->list,
 594                                         struct iser_fr_desc, list);
 595                 err = iser_fast_reg_fmr(iser_task, mem, &desc->rsc, mem_reg);
 596                 if (err && err != -EAGAIN) {
 597                         iser_data_buf_dump(mem, ibdev);
 598                         iser_err("mem->dma_nents = %d (dlength = 0x%x)\n",
 599                                  mem->dma_nents,
 600                                  ntoh24(iser_task->desc.iscsi_header.dlength));
 601                         iser_err("page_vec: data_size = 0x%x, length = %d, offset = 0x%x\n",
 602                                  desc->rsc.page_vec->data_size,
 603                                  desc->rsc.page_vec->length,
 604                                  desc->rsc.page_vec->offset);
 605                         for (i = 0; i < desc->rsc.page_vec->length; i++)
 606                                 iser_err("page_vec[%d] = 0x%llx\n", i,
 607                                          (unsigned long long)desc->rsc.page_vec->pages[i]);
 608                 }
 609                 if (err)
 610                         return err;
 611         }
 612         return 0;
 613 }
 614
 615 static void
 616 iser_set_dif_domain(struct scsi_cmnd *sc, struct ib_sig_attrs *sig_attrs,
 617                     struct ib_sig_domain *domain)
 618 {
 619         domain->sig_type = IB_SIG_TYPE_T10_DIF;
 620         domain->sig.dif.pi_interval = scsi_prot_interval(sc);
 621         domain->sig.dif.ref_tag = scsi_prot_ref_tag(sc);
 622         /*
 623          * At the moment we hard code those, but in the future
 624          * we will take them from sc.
 625          */
 626         domain->sig.dif.apptag_check_mask = 0xffff;
 627         domain->sig.dif.app_escape = true;
 628         domain->sig.dif.ref_escape = true;
 629         if (sc->prot_flags & SCSI_PROT_REF_INCREMENT)
 630                 domain->sig.dif.ref_remap = true;
 631 };
 632
 633 static int
 634 iser_set_sig_attrs(struct scsi_cmnd *sc, struct ib_sig_attrs *sig_attrs)
 635 {
 636         switch (scsi_get_prot_op(sc)) {
 637         case SCSI_PROT_WRITE_INSERT:
 638         case SCSI_PROT_READ_STRIP:
 639                 sig_attrs->mem.sig_type = IB_SIG_TYPE_NONE;
 640                 iser_set_dif_domain(sc, sig_attrs, &sig_attrs->wire);
 641                 sig_attrs->wire.sig.dif.bg_type = IB_T10DIF_CRC;
 642                 break;
 643         case SCSI_PROT_READ_INSERT:
 644         case SCSI_PROT_WRITE_STRIP:
 645                 sig_attrs->wire.sig_type = IB_SIG_TYPE_NONE;
 646                 iser_set_dif_domain(sc, sig_attrs, &sig_attrs->mem);
 647                 sig_attrs->mem.sig.dif.bg_type = sc->prot_flags & SCSI_PROT_IP_CHECKSUM ?
 648                                                 IB_T10DIF_CSUM : IB_T10DIF_CRC;
 649                 break;
 650         case SCSI_PROT_READ_PASS:
 651         case SCSI_PROT_WRITE_PASS:
 652                 iser_set_dif_domain(sc, sig_attrs, &sig_attrs->wire);
 653                 sig_attrs->wire.sig.dif.bg_type = IB_T10DIF_CRC;
 654                 iser_set_dif_domain(sc, sig_attrs, &sig_attrs->mem);
 655                 sig_attrs->mem.sig.dif.bg_type = sc->prot_flags & SCSI_PROT_IP_CHECKSUM ?
 656                                                 IB_T10DIF_CSUM : IB_T10DIF_CRC;
 657                 break;
 658         default:
 659                 iser_err("Unsupported PI operation %d\n",
 660                          scsi_get_prot_op(sc));
 661                 return -EINVAL;
 662         }
 663
 664         return 0;
 665 }
 666
 667 static inline void
 668 iser_set_prot_checks(struct scsi_cmnd *sc, u8 *mask)
 669 {
 670         *mask = 0;
 671         if (sc->prot_flags & SCSI_PROT_REF_CHECK)
 672                 *mask |= ISER_CHECK_REFTAG;
 673         if (sc->prot_flags & SCSI_PROT_GUARD_CHECK)
 674                 *mask |= ISER_CHECK_GUARD;
 675 }
 676
 677 static void
 678 iser_inv_rkey(struct ib_send_wr *inv_wr, struct ib_mr *mr)
 679 {
 680         u32 rkey;
 681
 682         memset(inv_wr, 0, sizeof(*inv_wr));
 683         inv_wr->opcode = IB_WR_LOCAL_INV;
 684         inv_wr->wr_id = ISER_FASTREG_LI_WRID;
 685         inv_wr->ex.invalidate_rkey = mr->rkey;
 686
 687         rkey = ib_inc_rkey(mr->rkey);
 688         ib_update_fast_reg_key(mr, rkey);
 689 }
 690
 691 static int
 692 iser_reg_sig_mr(struct iscsi_iser_task *iser_task,
 693                 struct iser_pi_context *pi_ctx,
 694                 struct iser_mem_reg *data_reg,
 695                 struct iser_mem_reg *prot_reg,
 696                 struct iser_mem_reg *sig_reg)
 697 {
 698         struct ib_conn *ib_conn = &iser_task->iser_conn->ib_conn;
 699         struct ib_send_wr sig_wr, inv_wr;
 700         struct ib_send_wr *bad_wr, *wr = NULL;
 701         struct ib_sig_attrs sig_attrs;
 702         int ret;
 703
 704         memset(&sig_attrs, 0, sizeof(sig_attrs));
 705         ret = iser_set_sig_attrs(iser_task->sc, &sig_attrs);
 706         if (ret)
 707                 goto err;
 708
 709         iser_set_prot_checks(iser_task->sc, &sig_attrs.check_mask);
 710
 711         if (!pi_ctx->sig_mr_valid) {
 712                 iser_inv_rkey(&inv_wr, pi_ctx->sig_mr);
 713                 wr = &inv_wr;
 714         }
 715
 716         memset(&sig_wr, 0, sizeof(sig_wr));
 717         sig_wr.opcode = IB_WR_REG_SIG_MR;
 718         sig_wr.wr_id = ISER_FASTREG_LI_WRID;
 719         sig_wr.sg_list = &data_reg->sge;
 720         sig_wr.num_sge = 1;
 721         sig_wr.wr.sig_handover.sig_attrs = &sig_attrs;
 722         sig_wr.wr.sig_handover.sig_mr = pi_ctx->sig_mr;
 723         if (scsi_prot_sg_count(iser_task->sc))
 724                 sig_wr.wr.sig_handover.prot = &prot_reg->sge;
 725         sig_wr.wr.sig_handover.access_flags = IB_ACCESS_LOCAL_WRITE |
 726                                               IB_ACCESS_REMOTE_READ |
 727                                               IB_ACCESS_REMOTE_WRITE;
 728
 729         if (!wr)
 730                 wr = &sig_wr;
 731         else
 732                 wr->next = &sig_wr;
 733
 734         ret = ib_post_send(ib_conn->qp, wr, &bad_wr);
 735         if (ret) {
 736                 iser_err("reg_sig_mr failed, ret:%d\n", ret);
 737                 goto err;
 738         }
 739         pi_ctx->sig_mr_valid = 0;
 740
 741         sig_reg->sge.lkey = pi_ctx->sig_mr->lkey;
 742         sig_reg->rkey = pi_ctx->sig_mr->rkey;
 743         sig_reg->sge.addr = 0;
 744         sig_reg->sge.length = scsi_transfer_length(iser_task->sc);
 745
 746         iser_dbg("sig_sge: lkey: 0x%x, rkey: 0x%x, addr: 0x%llx, length: %u\n",
 747                  sig_reg->sge.lkey, sig_reg->rkey, sig_reg->sge.addr,
 748                  sig_reg->sge.length);
 749 err:
 750         return ret;
 751 }
 752
 753 static int iser_fast_reg_mr(struct iscsi_iser_task *iser_task,
 754                             struct iser_data_buf *mem,
 755                             struct iser_reg_resources *rsc,
 756                             struct iser_mem_reg *reg)
 757 {
 758         struct ib_conn *ib_conn = &iser_task->iser_conn->ib_conn;
 759         struct iser_device *device = ib_conn->device;
 760         struct ib_mr *mr;
 761         struct ib_fast_reg_page_list *frpl;
 762         struct ib_send_wr fastreg_wr, inv_wr;
 763         struct ib_send_wr *bad_wr, *wr = NULL;
 764         int ret, offset, size, plen;
 765
 766         /* if there a single dma entry, dma mr suffices */
 767         if (mem->dma_nents == 1)
 768                 return iser_reg_dma(device, mem, reg);
 769
 770         mr = rsc->mr;
 771         frpl = rsc->frpl;
 772
 773         plen = iser_sg_to_page_vec(mem, device->ib_device, frpl->page_list,
 774                                    &offset, &size);
 775         if (plen * SIZE_4K < size) {
 776                 iser_err("fast reg page_list too short to hold this SG\n");
 777                 return -EINVAL;
 778         }
 779
 780         if (!rsc->mr_valid) {
 781                 iser_inv_rkey(&inv_wr, mr);
 782                 wr = &inv_wr;
 783         }
 784
 785         /* Prepare FASTREG WR */
 786         memset(&fastreg_wr, 0, sizeof(fastreg_wr));
 787         fastreg_wr.wr_id = ISER_FASTREG_LI_WRID;
 788         fastreg_wr.opcode = IB_WR_FAST_REG_MR;
 789         fastreg_wr.wr.fast_reg.iova_start = frpl->page_list[0] + offset;
 790         fastreg_wr.wr.fast_reg.page_list = frpl;
 791         fastreg_wr.wr.fast_reg.page_list_len = plen;
 792         fastreg_wr.wr.fast_reg.page_shift = SHIFT_4K;
 793         fastreg_wr.wr.fast_reg.length = size;
 794         fastreg_wr.wr.fast_reg.rkey = mr->rkey;
 795         fastreg_wr.wr.fast_reg.access_flags = (IB_ACCESS_LOCAL_WRITE  |
 796                                                IB_ACCESS_REMOTE_WRITE |
 797                                                IB_ACCESS_REMOTE_READ);
 798
 799         if (!wr)
 800                 wr = &fastreg_wr;
 801         else
 802                 wr->next = &fastreg_wr;
 803
 804         ret = ib_post_send(ib_conn->qp, wr, &bad_wr);
 805         if (ret) {
 806                 iser_err("fast registration failed, ret:%d\n", ret);
 807                 return ret;
 808         }
 809         rsc->mr_valid = 0;
 810
 811         reg->sge.lkey = mr->lkey;
 812         reg->rkey = mr->rkey;
 813         reg->sge.addr = frpl->page_list[0] + offset;
 814         reg->sge.length = size;
 815
 816         return ret;
 817 }
 818
 819 /**
 820  * iser_reg_rdma_mem_fastreg - Registers memory intended for RDMA,
 821  * using Fast Registration WR (if possible) obtaining rkey and va
 822  *
 823  * returns 0 on success, errno code on failure
 824  */
 825 int iser_reg_rdma_mem_fastreg(struct iscsi_iser_task *iser_task,
 826                               enum iser_data_dir cmd_dir)
 827 {
 828         struct ib_conn *ib_conn = &iser_task->iser_conn->ib_conn;
 829         struct iser_device *device = ib_conn->device;
 830         struct ib_device *ibdev = device->ib_device;
 831         struct iser_data_buf *mem = &iser_task->data[cmd_dir];
 832         struct iser_mem_reg *mem_reg = &iser_task->rdma_reg[cmd_dir];
 833         struct iser_fr_desc *desc = NULL;
 834         int err, aligned_len;
 835
 836         aligned_len = iser_data_buf_aligned_len(mem, ibdev);
 837         if (aligned_len != mem->dma_nents) {
 838                 err = fall_to_bounce_buf(iser_task, mem, cmd_dir);
 839                 if (err) {
 840                         iser_err("failed to allocate bounce buffer\n");
 841                         return err;
 842                 }
 843         }
 844
 845         if (mem->dma_nents != 1 ||
 846             scsi_get_prot_op(iser_task->sc) != SCSI_PROT_NORMAL) {
 847                 desc = iser_reg_desc_get(ib_conn);
 848                 mem_reg->mem_h = desc;
 849         }
 850
 851         err = iser_fast_reg_mr(iser_task, mem,
 852                                desc ? &desc->rsc : NULL, mem_reg);
 853         if (err)
 854                 goto err_reg;
 855
 856         if (scsi_get_prot_op(iser_task->sc) != SCSI_PROT_NORMAL) {
 857                 struct iser_mem_reg prot_reg;
 858
 859                 memset(&prot_reg, 0, sizeof(prot_reg));
 860                 if (scsi_prot_sg_count(iser_task->sc)) {
 861                         mem = &iser_task->prot[cmd_dir];
 862                         aligned_len = iser_data_buf_aligned_len(mem, ibdev);
 863                         if (aligned_len != mem->dma_nents) {
 864                                 err = fall_to_bounce_buf(iser_task, mem,
 865                                                          cmd_dir);
 866                                 if (err) {
 867                                         iser_err("failed to allocate bounce buffer\n");
 868                                         return err;
 869                                 }
 870                         }
 871
 872                         err = iser_fast_reg_mr(iser_task, mem,
 873                                                &desc->pi_ctx->rsc, &prot_reg);
 874                         if (err)
 875                                 goto err_reg;
 876                 }
 877
 878                 err = iser_reg_sig_mr(iser_task, desc->pi_ctx, mem_reg,
 879                                       &prot_reg, mem_reg);
 880                 if (err) {
 881                         iser_err("Failed to register signature mr\n");
 882                         return err;
 883                 }
 884                 desc->pi_ctx->sig_protected = 1;
 885         }
 886
 887         return 0;
 888 err_reg:
 889         if (desc)
 890                 iser_reg_desc_put(ib_conn, desc);
 891
 892         return err;
 893 }