1 /* 2 * Copyright (c) 2005 Cisco Systems. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 */ 32 33 #define pr_fmt(fmt) PFX fmt 34 35 #include <linux/module.h> 36 #include <linux/init.h> 37 #include <linux/slab.h> 38 #include <linux/err.h> 39 #include <linux/string.h> 40 #include <linux/parser.h> 41 #include <linux/random.h> 42 #include <linux/jiffies.h> 43 44 #include <linux/atomic.h> 45 46 #include <scsi/scsi.h> 47 #include <scsi/scsi_device.h> 48 #include <scsi/scsi_dbg.h> 49 #include <scsi/srp.h> 50 #include <scsi/scsi_transport_srp.h> 51 52 #include "ib_srp.h" 53 54 #define DRV_NAME "ib_srp" 55 #define PFX DRV_NAME ": " 56 #define DRV_VERSION "0.2" 57 #define DRV_RELDATE "November 1, 2005" 58 59 MODULE_AUTHOR("Roland Dreier"); 60 MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator " 61 "v" DRV_VERSION " (" DRV_RELDATE ")"); 62 MODULE_LICENSE("Dual BSD/GPL"); 63 64 static unsigned int srp_sg_tablesize; 65 static unsigned int cmd_sg_entries; 66 static unsigned int indirect_sg_entries; 67 static bool allow_ext_sg; 68 static int topspin_workarounds = 1; 69 70 module_param(srp_sg_tablesize, uint, 0444); 71 MODULE_PARM_DESC(srp_sg_tablesize, "Deprecated name for cmd_sg_entries"); 72 73 module_param(cmd_sg_entries, uint, 0444); 74 MODULE_PARM_DESC(cmd_sg_entries, 75 "Default number of gather/scatter entries in the SRP command (default is 12, max 255)"); 76 77 module_param(indirect_sg_entries, uint, 0444); 78 MODULE_PARM_DESC(indirect_sg_entries, 79 "Default max number of gather/scatter entries (default is 12, max is " __stringify(SCSI_MAX_SG_CHAIN_SEGMENTS) ")"); 80 81 module_param(allow_ext_sg, bool, 0444); 82 MODULE_PARM_DESC(allow_ext_sg, 83 "Default behavior when there are more than cmd_sg_entries S/G entries after mapping; fails the request when false (default false)"); 84 85 module_param(topspin_workarounds, int, 0444); 86 MODULE_PARM_DESC(topspin_workarounds, 87 "Enable workarounds for Topspin/Cisco SRP target bugs if != 0"); 88 89 static void srp_add_one(struct ib_device *device); 90 static void srp_remove_one(struct ib_device *device); 91 static void srp_recv_completion(struct ib_cq *cq, void *target_ptr); 92 static void srp_send_completion(struct ib_cq *cq, void *target_ptr); 93 static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event); 94 95 static struct scsi_transport_template *ib_srp_transport_template; 96 97 static struct ib_client srp_client = { 98 .name = "srp", 99 .add = srp_add_one, 100 .remove = srp_remove_one 101 }; 102 103 static struct ib_sa_client srp_sa_client; 104 105 static inline struct srp_target_port *host_to_target(struct Scsi_Host *host) 106 { 107 return (struct srp_target_port *) host->hostdata; 108 } 109 110 static const char *srp_target_info(struct Scsi_Host *host) 111 { 112 return host_to_target(host)->target_name; 113 } 114 115 static int srp_target_is_topspin(struct srp_target_port *target) 116 { 117 static const u8 topspin_oui[3] = { 0x00, 0x05, 0xad }; 118 static const u8 cisco_oui[3] = { 0x00, 0x1b, 0x0d }; 119 120 return topspin_workarounds && 121 (!memcmp(&target->ioc_guid, topspin_oui, sizeof topspin_oui) || 122 !memcmp(&target->ioc_guid, cisco_oui, sizeof cisco_oui)); 123 } 124 125 static struct srp_iu *srp_alloc_iu(struct srp_host *host, size_t size, 126 gfp_t gfp_mask, 127 enum dma_data_direction direction) 128 { 129 struct srp_iu *iu; 130 131 iu = kmalloc(sizeof *iu, gfp_mask); 132 if (!iu) 133 goto out; 134 135 iu->buf = kzalloc(size, gfp_mask); 136 if (!iu->buf) 137 goto out_free_iu; 138 139 iu->dma = ib_dma_map_single(host->srp_dev->dev, iu->buf, size, 140 direction); 141 if (ib_dma_mapping_error(host->srp_dev->dev, iu->dma)) 142 goto out_free_buf; 143 144 iu->size = size; 145 iu->direction = direction; 146 147 return iu; 148 149 out_free_buf: 150 kfree(iu->buf); 151 out_free_iu: 152 kfree(iu); 153 out: 154 return NULL; 155 } 156 157 static void srp_free_iu(struct srp_host *host, struct srp_iu *iu) 158 { 159 if (!iu) 160 return; 161 162 ib_dma_unmap_single(host->srp_dev->dev, iu->dma, iu->size, 163 iu->direction); 164 kfree(iu->buf); 165 kfree(iu); 166 } 167 168 static void srp_qp_event(struct ib_event *event, void *context) 169 { 170 pr_debug("QP event %d\n", event->event); 171 } 172 173 static int srp_init_qp(struct srp_target_port *target, 174 struct ib_qp *qp) 175 { 176 struct ib_qp_attr *attr; 177 int ret; 178 179 attr = kmalloc(sizeof *attr, GFP_KERNEL); 180 if (!attr) 181 return -ENOMEM; 182 183 ret = ib_find_pkey(target->srp_host->srp_dev->dev, 184 target->srp_host->port, 185 be16_to_cpu(target->path.pkey), 186 &attr->pkey_index); 187 if (ret) 188 goto out; 189 190 attr->qp_state = IB_QPS_INIT; 191 attr->qp_access_flags = (IB_ACCESS_REMOTE_READ | 192 IB_ACCESS_REMOTE_WRITE); 193 attr->port_num = target->srp_host->port; 194 195 ret = ib_modify_qp(qp, attr, 196 IB_QP_STATE | 197 IB_QP_PKEY_INDEX | 198 IB_QP_ACCESS_FLAGS | 199 IB_QP_PORT); 200 201 out: 202 kfree(attr); 203 return ret; 204 } 205 206 static int srp_new_cm_id(struct srp_target_port *target) 207 { 208 struct ib_cm_id *new_cm_id; 209 210 new_cm_id = ib_create_cm_id(target->srp_host->srp_dev->dev, 211 srp_cm_handler, target); 212 if (IS_ERR(new_cm_id)) 213 return PTR_ERR(new_cm_id); 214 215 if (target->cm_id) 216 ib_destroy_cm_id(target->cm_id); 217 target->cm_id = new_cm_id; 218 219 return 0; 220 } 221 222 static int srp_create_target_ib(struct srp_target_port *target) 223 { 224 struct ib_qp_init_attr *init_attr; 225 struct ib_cq *recv_cq, *send_cq; 226 struct ib_qp *qp; 227 int ret; 228 229 init_attr = kzalloc(sizeof *init_attr, GFP_KERNEL); 230 if (!init_attr) 231 return -ENOMEM; 232 233 recv_cq = ib_create_cq(target->srp_host->srp_dev->dev, 234 srp_recv_completion, NULL, target, SRP_RQ_SIZE, 0); 235 if (IS_ERR(recv_cq)) { 236 ret = PTR_ERR(recv_cq); 237 goto err; 238 } 239 240 send_cq = ib_create_cq(target->srp_host->srp_dev->dev, 241 srp_send_completion, NULL, target, SRP_SQ_SIZE, 0); 242 if (IS_ERR(send_cq)) { 243 ret = PTR_ERR(send_cq); 244 goto err_recv_cq; 245 } 246 247 ib_req_notify_cq(recv_cq, IB_CQ_NEXT_COMP); 248 249 init_attr->event_handler = srp_qp_event; 250 init_attr->cap.max_send_wr = SRP_SQ_SIZE; 251 init_attr->cap.max_recv_wr = SRP_RQ_SIZE; 252 init_attr->cap.max_recv_sge = 1; 253 init_attr->cap.max_send_sge = 1; 254 init_attr->sq_sig_type = IB_SIGNAL_ALL_WR; 255 init_attr->qp_type = IB_QPT_RC; 256 init_attr->send_cq = send_cq; 257 init_attr->recv_cq = recv_cq; 258 259 qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr); 260 if (IS_ERR(qp)) { 261 ret = PTR_ERR(qp); 262 goto err_send_cq; 263 } 264 265 ret = srp_init_qp(target, qp); 266 if (ret) 267 goto err_qp; 268 269 if (target->qp) 270 ib_destroy_qp(target->qp); 271 if (target->recv_cq) 272 ib_destroy_cq(target->recv_cq); 273 if (target->send_cq) 274 ib_destroy_cq(target->send_cq); 275 276 target->qp = qp; 277 target->recv_cq = recv_cq; 278 target->send_cq = send_cq; 279 280 kfree(init_attr); 281 return 0; 282 283 err_qp: 284 ib_destroy_qp(qp); 285 286 err_send_cq: 287 ib_destroy_cq(send_cq); 288 289 err_recv_cq: 290 ib_destroy_cq(recv_cq); 291 292 err: 293 kfree(init_attr); 294 return ret; 295 } 296 297 static void srp_free_target_ib(struct srp_target_port *target) 298 { 299 int i; 300 301 ib_destroy_qp(target->qp); 302 ib_destroy_cq(target->send_cq); 303 ib_destroy_cq(target->recv_cq); 304 305 target->qp = NULL; 306 target->send_cq = target->recv_cq = NULL; 307 308 for (i = 0; i < SRP_RQ_SIZE; ++i) 309 srp_free_iu(target->srp_host, target->rx_ring[i]); 310 for (i = 0; i < SRP_SQ_SIZE; ++i) 311 srp_free_iu(target->srp_host, target->tx_ring[i]); 312 } 313 314 static void srp_path_rec_completion(int status, 315 struct ib_sa_path_rec *pathrec, 316 void *target_ptr) 317 { 318 struct srp_target_port *target = target_ptr; 319 320 target->status = status; 321 if (status) 322 shost_printk(KERN_ERR, target->scsi_host, 323 PFX "Got failed path rec status %d\n", status); 324 else 325 target->path = *pathrec; 326 complete(&target->done); 327 } 328 329 static int srp_lookup_path(struct srp_target_port *target) 330 { 331 target->path.numb_path = 1; 332 333 init_completion(&target->done); 334 335 target->path_query_id = ib_sa_path_rec_get(&srp_sa_client, 336 target->srp_host->srp_dev->dev, 337 target->srp_host->port, 338 &target->path, 339 IB_SA_PATH_REC_SERVICE_ID | 340 IB_SA_PATH_REC_DGID | 341 IB_SA_PATH_REC_SGID | 342 IB_SA_PATH_REC_NUMB_PATH | 343 IB_SA_PATH_REC_PKEY, 344 SRP_PATH_REC_TIMEOUT_MS, 345 GFP_KERNEL, 346 srp_path_rec_completion, 347 target, &target->path_query); 348 if (target->path_query_id < 0) 349 return target->path_query_id; 350 351 wait_for_completion(&target->done); 352 353 if (target->status < 0) 354 shost_printk(KERN_WARNING, target->scsi_host, 355 PFX "Path record query failed\n"); 356 357 return target->status; 358 } 359 360 static int srp_send_req(struct srp_target_port *target) 361 { 362 struct { 363 struct ib_cm_req_param param; 364 struct srp_login_req priv; 365 } *req = NULL; 366 int status; 367 368 req = kzalloc(sizeof *req, GFP_KERNEL); 369 if (!req) 370 return -ENOMEM; 371 372 req->param.primary_path = &target->path; 373 req->param.alternate_path = NULL; 374 req->param.service_id = target->service_id; 375 req->param.qp_num = target->qp->qp_num; 376 req->param.qp_type = target->qp->qp_type; 377 req->param.private_data = &req->priv; 378 req->param.private_data_len = sizeof req->priv; 379 req->param.flow_control = 1; 380 381 get_random_bytes(&req->param.starting_psn, 4); 382 req->param.starting_psn &= 0xffffff; 383 384 /* 385 * Pick some arbitrary defaults here; we could make these 386 * module parameters if anyone cared about setting them. 387 */ 388 req->param.responder_resources = 4; 389 req->param.remote_cm_response_timeout = 20; 390 req->param.local_cm_response_timeout = 20; 391 req->param.retry_count = 7; 392 req->param.rnr_retry_count = 7; 393 req->param.max_cm_retries = 15; 394 395 req->priv.opcode = SRP_LOGIN_REQ; 396 req->priv.tag = 0; 397 req->priv.req_it_iu_len = cpu_to_be32(target->max_iu_len); 398 req->priv.req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | 399 SRP_BUF_FORMAT_INDIRECT); 400 /* 401 * In the published SRP specification (draft rev. 16a), the 402 * port identifier format is 8 bytes of ID extension followed 403 * by 8 bytes of GUID. Older drafts put the two halves in the 404 * opposite order, so that the GUID comes first. 405 * 406 * Targets conforming to these obsolete drafts can be 407 * recognized by the I/O Class they report. 408 */ 409 if (target->io_class == SRP_REV10_IB_IO_CLASS) { 410 memcpy(req->priv.initiator_port_id, 411 &target->path.sgid.global.interface_id, 8); 412 memcpy(req->priv.initiator_port_id + 8, 413 &target->initiator_ext, 8); 414 memcpy(req->priv.target_port_id, &target->ioc_guid, 8); 415 memcpy(req->priv.target_port_id + 8, &target->id_ext, 8); 416 } else { 417 memcpy(req->priv.initiator_port_id, 418 &target->initiator_ext, 8); 419 memcpy(req->priv.initiator_port_id + 8, 420 &target->path.sgid.global.interface_id, 8); 421 memcpy(req->priv.target_port_id, &target->id_ext, 8); 422 memcpy(req->priv.target_port_id + 8, &target->ioc_guid, 8); 423 } 424 425 /* 426 * Topspin/Cisco SRP targets will reject our login unless we 427 * zero out the first 8 bytes of our initiator port ID and set 428 * the second 8 bytes to the local node GUID. 429 */ 430 if (srp_target_is_topspin(target)) { 431 shost_printk(KERN_DEBUG, target->scsi_host, 432 PFX "Topspin/Cisco initiator port ID workaround " 433 "activated for target GUID %016llx\n", 434 (unsigned long long) be64_to_cpu(target->ioc_guid)); 435 memset(req->priv.initiator_port_id, 0, 8); 436 memcpy(req->priv.initiator_port_id + 8, 437 &target->srp_host->srp_dev->dev->node_guid, 8); 438 } 439 440 status = ib_send_cm_req(target->cm_id, &req->param); 441 442 kfree(req); 443 444 return status; 445 } 446 447 static bool srp_queue_remove_work(struct srp_target_port *target) 448 { 449 bool changed = false; 450 451 spin_lock_irq(&target->lock); 452 if (target->state != SRP_TARGET_REMOVED) { 453 target->state = SRP_TARGET_REMOVED; 454 changed = true; 455 } 456 spin_unlock_irq(&target->lock); 457 458 if (changed) 459 queue_work(system_long_wq, &target->remove_work); 460 461 return changed; 462 } 463 464 static bool srp_change_conn_state(struct srp_target_port *target, 465 bool connected) 466 { 467 bool changed = false; 468 469 spin_lock_irq(&target->lock); 470 if (target->connected != connected) { 471 target->connected = connected; 472 changed = true; 473 } 474 spin_unlock_irq(&target->lock); 475 476 return changed; 477 } 478 479 static void srp_disconnect_target(struct srp_target_port *target) 480 { 481 if (srp_change_conn_state(target, false)) { 482 /* XXX should send SRP_I_LOGOUT request */ 483 484 if (ib_send_cm_dreq(target->cm_id, NULL, 0)) { 485 shost_printk(KERN_DEBUG, target->scsi_host, 486 PFX "Sending CM DREQ failed\n"); 487 } 488 } 489 } 490 491 static void srp_free_req_data(struct srp_target_port *target) 492 { 493 struct ib_device *ibdev = target->srp_host->srp_dev->dev; 494 struct srp_request *req; 495 int i; 496 497 for (i = 0, req = target->req_ring; i < SRP_CMD_SQ_SIZE; ++i, ++req) { 498 kfree(req->fmr_list); 499 kfree(req->map_page); 500 if (req->indirect_dma_addr) { 501 ib_dma_unmap_single(ibdev, req->indirect_dma_addr, 502 target->indirect_size, 503 DMA_TO_DEVICE); 504 } 505 kfree(req->indirect_desc); 506 } 507 } 508 509 /** 510 * srp_del_scsi_host_attr() - Remove attributes defined in the host template. 511 * @shost: SCSI host whose attributes to remove from sysfs. 512 * 513 * Note: Any attributes defined in the host template and that did not exist 514 * before invocation of this function will be ignored. 515 */ 516 static void srp_del_scsi_host_attr(struct Scsi_Host *shost) 517 { 518 struct device_attribute **attr; 519 520 for (attr = shost->hostt->shost_attrs; attr && *attr; ++attr) 521 device_remove_file(&shost->shost_dev, *attr); 522 } 523 524 static void srp_remove_target(struct srp_target_port *target) 525 { 526 WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED); 527 528 srp_del_scsi_host_attr(target->scsi_host); 529 srp_remove_host(target->scsi_host); 530 scsi_remove_host(target->scsi_host); 531 srp_disconnect_target(target); 532 ib_destroy_cm_id(target->cm_id); 533 srp_free_target_ib(target); 534 srp_free_req_data(target); 535 scsi_host_put(target->scsi_host); 536 } 537 538 static void srp_remove_work(struct work_struct *work) 539 { 540 struct srp_target_port *target = 541 container_of(work, struct srp_target_port, remove_work); 542 543 WARN_ON_ONCE(target->state != SRP_TARGET_REMOVED); 544 545 spin_lock(&target->srp_host->target_lock); 546 list_del(&target->list); 547 spin_unlock(&target->srp_host->target_lock); 548 549 srp_remove_target(target); 550 } 551 552 static void srp_rport_delete(struct srp_rport *rport) 553 { 554 struct srp_target_port *target = rport->lld_data; 555 556 srp_queue_remove_work(target); 557 } 558 559 static int srp_connect_target(struct srp_target_port *target) 560 { 561 int retries = 3; 562 int ret; 563 564 WARN_ON_ONCE(target->connected); 565 566 target->qp_in_error = false; 567 568 ret = srp_lookup_path(target); 569 if (ret) 570 return ret; 571 572 while (1) { 573 init_completion(&target->done); 574 ret = srp_send_req(target); 575 if (ret) 576 return ret; 577 wait_for_completion(&target->done); 578 579 /* 580 * The CM event handling code will set status to 581 * SRP_PORT_REDIRECT if we get a port redirect REJ 582 * back, or SRP_DLID_REDIRECT if we get a lid/qp 583 * redirect REJ back. 584 */ 585 switch (target->status) { 586 case 0: 587 srp_change_conn_state(target, true); 588 return 0; 589 590 case SRP_PORT_REDIRECT: 591 ret = srp_lookup_path(target); 592 if (ret) 593 return ret; 594 break; 595 596 case SRP_DLID_REDIRECT: 597 break; 598 599 case SRP_STALE_CONN: 600 /* Our current CM id was stale, and is now in timewait. 601 * Try to reconnect with a new one. 602 */ 603 if (!retries-- || srp_new_cm_id(target)) { 604 shost_printk(KERN_ERR, target->scsi_host, PFX 605 "giving up on stale connection\n"); 606 target->status = -ECONNRESET; 607 return target->status; 608 } 609 610 shost_printk(KERN_ERR, target->scsi_host, PFX 611 "retrying stale connection\n"); 612 break; 613 614 default: 615 return target->status; 616 } 617 } 618 } 619 620 static void srp_unmap_data(struct scsi_cmnd *scmnd, 621 struct srp_target_port *target, 622 struct srp_request *req) 623 { 624 struct ib_device *ibdev = target->srp_host->srp_dev->dev; 625 struct ib_pool_fmr **pfmr; 626 627 if (!scsi_sglist(scmnd) || 628 (scmnd->sc_data_direction != DMA_TO_DEVICE && 629 scmnd->sc_data_direction != DMA_FROM_DEVICE)) 630 return; 631 632 pfmr = req->fmr_list; 633 while (req->nfmr--) 634 ib_fmr_pool_unmap(*pfmr++); 635 636 ib_dma_unmap_sg(ibdev, scsi_sglist(scmnd), scsi_sg_count(scmnd), 637 scmnd->sc_data_direction); 638 } 639 640 /** 641 * srp_claim_req - Take ownership of the scmnd associated with a request. 642 * @target: SRP target port. 643 * @req: SRP request. 644 * @scmnd: If NULL, take ownership of @req->scmnd. If not NULL, only take 645 * ownership of @req->scmnd if it equals @scmnd. 646 * 647 * Return value: 648 * Either NULL or a pointer to the SCSI command the caller became owner of. 649 */ 650 static struct scsi_cmnd *srp_claim_req(struct srp_target_port *target, 651 struct srp_request *req, 652 struct scsi_cmnd *scmnd) 653 { 654 unsigned long flags; 655 656 spin_lock_irqsave(&target->lock, flags); 657 if (!scmnd) { 658 scmnd = req->scmnd; 659 req->scmnd = NULL; 660 } else if (req->scmnd == scmnd) { 661 req->scmnd = NULL; 662 } else { 663 scmnd = NULL; 664 } 665 spin_unlock_irqrestore(&target->lock, flags); 666 667 return scmnd; 668 } 669 670 /** 671 * srp_free_req() - Unmap data and add request to the free request list. 672 */ 673 static void srp_free_req(struct srp_target_port *target, 674 struct srp_request *req, struct scsi_cmnd *scmnd, 675 s32 req_lim_delta) 676 { 677 unsigned long flags; 678 679 srp_unmap_data(scmnd, target, req); 680 681 spin_lock_irqsave(&target->lock, flags); 682 target->req_lim += req_lim_delta; 683 list_add_tail(&req->list, &target->free_reqs); 684 spin_unlock_irqrestore(&target->lock, flags); 685 } 686 687 static void srp_reset_req(struct srp_target_port *target, struct srp_request *req) 688 { 689 struct scsi_cmnd *scmnd = srp_claim_req(target, req, NULL); 690 691 if (scmnd) { 692 srp_free_req(target, req, scmnd, 0); 693 scmnd->result = DID_RESET << 16; 694 scmnd->scsi_done(scmnd); 695 } 696 } 697 698 static int srp_reconnect_target(struct srp_target_port *target) 699 { 700 struct Scsi_Host *shost = target->scsi_host; 701 int i, ret; 702 703 if (target->state != SRP_TARGET_LIVE) 704 return -EAGAIN; 705 706 scsi_target_block(&shost->shost_gendev); 707 708 srp_disconnect_target(target); 709 /* 710 * Now get a new local CM ID so that we avoid confusing the 711 * target in case things are really fouled up. 712 */ 713 ret = srp_new_cm_id(target); 714 if (ret) 715 goto unblock; 716 717 ret = srp_create_target_ib(target); 718 if (ret) 719 goto unblock; 720 721 for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) { 722 struct srp_request *req = &target->req_ring[i]; 723 if (req->scmnd) 724 srp_reset_req(target, req); 725 } 726 727 INIT_LIST_HEAD(&target->free_tx); 728 for (i = 0; i < SRP_SQ_SIZE; ++i) 729 list_add(&target->tx_ring[i]->list, &target->free_tx); 730 731 ret = srp_connect_target(target); 732 733 unblock: 734 scsi_target_unblock(&shost->shost_gendev, ret == 0 ? SDEV_RUNNING : 735 SDEV_TRANSPORT_OFFLINE); 736 737 if (ret) 738 goto err; 739 740 shost_printk(KERN_INFO, target->scsi_host, PFX "reconnect succeeded\n"); 741 742 return ret; 743 744 err: 745 shost_printk(KERN_ERR, target->scsi_host, 746 PFX "reconnect failed (%d), removing target port.\n", ret); 747 748 /* 749 * We couldn't reconnect, so kill our target port off. 750 * However, we have to defer the real removal because we 751 * are in the context of the SCSI error handler now, which 752 * will deadlock if we call scsi_remove_host(). 753 */ 754 srp_queue_remove_work(target); 755 756 return ret; 757 } 758 759 static void srp_map_desc(struct srp_map_state *state, dma_addr_t dma_addr, 760 unsigned int dma_len, u32 rkey) 761 { 762 struct srp_direct_buf *desc = state->desc; 763 764 desc->va = cpu_to_be64(dma_addr); 765 desc->key = cpu_to_be32(rkey); 766 desc->len = cpu_to_be32(dma_len); 767 768 state->total_len += dma_len; 769 state->desc++; 770 state->ndesc++; 771 } 772 773 static int srp_map_finish_fmr(struct srp_map_state *state, 774 struct srp_target_port *target) 775 { 776 struct srp_device *dev = target->srp_host->srp_dev; 777 struct ib_pool_fmr *fmr; 778 u64 io_addr = 0; 779 780 if (!state->npages) 781 return 0; 782 783 if (state->npages == 1) { 784 srp_map_desc(state, state->base_dma_addr, state->fmr_len, 785 target->rkey); 786 state->npages = state->fmr_len = 0; 787 return 0; 788 } 789 790 fmr = ib_fmr_pool_map_phys(dev->fmr_pool, state->pages, 791 state->npages, io_addr); 792 if (IS_ERR(fmr)) 793 return PTR_ERR(fmr); 794 795 *state->next_fmr++ = fmr; 796 state->nfmr++; 797 798 srp_map_desc(state, 0, state->fmr_len, fmr->fmr->rkey); 799 state->npages = state->fmr_len = 0; 800 return 0; 801 } 802 803 static void srp_map_update_start(struct srp_map_state *state, 804 struct scatterlist *sg, int sg_index, 805 dma_addr_t dma_addr) 806 { 807 state->unmapped_sg = sg; 808 state->unmapped_index = sg_index; 809 state->unmapped_addr = dma_addr; 810 } 811 812 static int srp_map_sg_entry(struct srp_map_state *state, 813 struct srp_target_port *target, 814 struct scatterlist *sg, int sg_index, 815 int use_fmr) 816 { 817 struct srp_device *dev = target->srp_host->srp_dev; 818 struct ib_device *ibdev = dev->dev; 819 dma_addr_t dma_addr = ib_sg_dma_address(ibdev, sg); 820 unsigned int dma_len = ib_sg_dma_len(ibdev, sg); 821 unsigned int len; 822 int ret; 823 824 if (!dma_len) 825 return 0; 826 827 if (use_fmr == SRP_MAP_NO_FMR) { 828 /* Once we're in direct map mode for a request, we don't 829 * go back to FMR mode, so no need to update anything 830 * other than the descriptor. 831 */ 832 srp_map_desc(state, dma_addr, dma_len, target->rkey); 833 return 0; 834 } 835 836 /* If we start at an offset into the FMR page, don't merge into 837 * the current FMR. Finish it out, and use the kernel's MR for this 838 * sg entry. This is to avoid potential bugs on some SRP targets 839 * that were never quite defined, but went away when the initiator 840 * avoided using FMR on such page fragments. 841 */ 842 if (dma_addr & ~dev->fmr_page_mask || dma_len > dev->fmr_max_size) { 843 ret = srp_map_finish_fmr(state, target); 844 if (ret) 845 return ret; 846 847 srp_map_desc(state, dma_addr, dma_len, target->rkey); 848 srp_map_update_start(state, NULL, 0, 0); 849 return 0; 850 } 851 852 /* If this is the first sg to go into the FMR, save our position. 853 * We need to know the first unmapped entry, its index, and the 854 * first unmapped address within that entry to be able to restart 855 * mapping after an error. 856 */ 857 if (!state->unmapped_sg) 858 srp_map_update_start(state, sg, sg_index, dma_addr); 859 860 while (dma_len) { 861 if (state->npages == SRP_FMR_SIZE) { 862 ret = srp_map_finish_fmr(state, target); 863 if (ret) 864 return ret; 865 866 srp_map_update_start(state, sg, sg_index, dma_addr); 867 } 868 869 len = min_t(unsigned int, dma_len, dev->fmr_page_size); 870 871 if (!state->npages) 872 state->base_dma_addr = dma_addr; 873 state->pages[state->npages++] = dma_addr; 874 state->fmr_len += len; 875 dma_addr += len; 876 dma_len -= len; 877 } 878 879 /* If the last entry of the FMR wasn't a full page, then we need to 880 * close it out and start a new one -- we can only merge at page 881 * boundries. 882 */ 883 ret = 0; 884 if (len != dev->fmr_page_size) { 885 ret = srp_map_finish_fmr(state, target); 886 if (!ret) 887 srp_map_update_start(state, NULL, 0, 0); 888 } 889 return ret; 890 } 891 892 static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target, 893 struct srp_request *req) 894 { 895 struct scatterlist *scat, *sg; 896 struct srp_cmd *cmd = req->cmd->buf; 897 int i, len, nents, count, use_fmr; 898 struct srp_device *dev; 899 struct ib_device *ibdev; 900 struct srp_map_state state; 901 struct srp_indirect_buf *indirect_hdr; 902 u32 table_len; 903 u8 fmt; 904 905 if (!scsi_sglist(scmnd) || scmnd->sc_data_direction == DMA_NONE) 906 return sizeof (struct srp_cmd); 907 908 if (scmnd->sc_data_direction != DMA_FROM_DEVICE && 909 scmnd->sc_data_direction != DMA_TO_DEVICE) { 910 shost_printk(KERN_WARNING, target->scsi_host, 911 PFX "Unhandled data direction %d\n", 912 scmnd->sc_data_direction); 913 return -EINVAL; 914 } 915 916 nents = scsi_sg_count(scmnd); 917 scat = scsi_sglist(scmnd); 918 919 dev = target->srp_host->srp_dev; 920 ibdev = dev->dev; 921 922 count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction); 923 if (unlikely(count == 0)) 924 return -EIO; 925 926 fmt = SRP_DATA_DESC_DIRECT; 927 len = sizeof (struct srp_cmd) + sizeof (struct srp_direct_buf); 928 929 if (count == 1) { 930 /* 931 * The midlayer only generated a single gather/scatter 932 * entry, or DMA mapping coalesced everything to a 933 * single entry. So a direct descriptor along with 934 * the DMA MR suffices. 935 */ 936 struct srp_direct_buf *buf = (void *) cmd->add_data; 937 938 buf->va = cpu_to_be64(ib_sg_dma_address(ibdev, scat)); 939 buf->key = cpu_to_be32(target->rkey); 940 buf->len = cpu_to_be32(ib_sg_dma_len(ibdev, scat)); 941 942 req->nfmr = 0; 943 goto map_complete; 944 } 945 946 /* We have more than one scatter/gather entry, so build our indirect 947 * descriptor table, trying to merge as many entries with FMR as we 948 * can. 949 */ 950 indirect_hdr = (void *) cmd->add_data; 951 952 ib_dma_sync_single_for_cpu(ibdev, req->indirect_dma_addr, 953 target->indirect_size, DMA_TO_DEVICE); 954 955 memset(&state, 0, sizeof(state)); 956 state.desc = req->indirect_desc; 957 state.pages = req->map_page; 958 state.next_fmr = req->fmr_list; 959 960 use_fmr = dev->fmr_pool ? SRP_MAP_ALLOW_FMR : SRP_MAP_NO_FMR; 961 962 for_each_sg(scat, sg, count, i) { 963 if (srp_map_sg_entry(&state, target, sg, i, use_fmr)) { 964 /* FMR mapping failed, so backtrack to the first 965 * unmapped entry and continue on without using FMR. 966 */ 967 dma_addr_t dma_addr; 968 unsigned int dma_len; 969 970 backtrack: 971 sg = state.unmapped_sg; 972 i = state.unmapped_index; 973 974 dma_addr = ib_sg_dma_address(ibdev, sg); 975 dma_len = ib_sg_dma_len(ibdev, sg); 976 dma_len -= (state.unmapped_addr - dma_addr); 977 dma_addr = state.unmapped_addr; 978 use_fmr = SRP_MAP_NO_FMR; 979 srp_map_desc(&state, dma_addr, dma_len, target->rkey); 980 } 981 } 982 983 if (use_fmr == SRP_MAP_ALLOW_FMR && srp_map_finish_fmr(&state, target)) 984 goto backtrack; 985 986 /* We've mapped the request, now pull as much of the indirect 987 * descriptor table as we can into the command buffer. If this 988 * target is not using an external indirect table, we are 989 * guaranteed to fit into the command, as the SCSI layer won't 990 * give us more S/G entries than we allow. 991 */ 992 req->nfmr = state.nfmr; 993 if (state.ndesc == 1) { 994 /* FMR mapping was able to collapse this to one entry, 995 * so use a direct descriptor. 996 */ 997 struct srp_direct_buf *buf = (void *) cmd->add_data; 998 999 *buf = req->indirect_desc[0]; 1000 goto map_complete; 1001 } 1002 1003 if (unlikely(target->cmd_sg_cnt < state.ndesc && 1004 !target->allow_ext_sg)) { 1005 shost_printk(KERN_ERR, target->scsi_host, 1006 "Could not fit S/G list into SRP_CMD\n"); 1007 return -EIO; 1008 } 1009 1010 count = min(state.ndesc, target->cmd_sg_cnt); 1011 table_len = state.ndesc * sizeof (struct srp_direct_buf); 1012 1013 fmt = SRP_DATA_DESC_INDIRECT; 1014 len = sizeof(struct srp_cmd) + sizeof (struct srp_indirect_buf); 1015 len += count * sizeof (struct srp_direct_buf); 1016 1017 memcpy(indirect_hdr->desc_list, req->indirect_desc, 1018 count * sizeof (struct srp_direct_buf)); 1019 1020 indirect_hdr->table_desc.va = cpu_to_be64(req->indirect_dma_addr); 1021 indirect_hdr->table_desc.key = cpu_to_be32(target->rkey); 1022 indirect_hdr->table_desc.len = cpu_to_be32(table_len); 1023 indirect_hdr->len = cpu_to_be32(state.total_len); 1024 1025 if (scmnd->sc_data_direction == DMA_TO_DEVICE) 1026 cmd->data_out_desc_cnt = count; 1027 else 1028 cmd->data_in_desc_cnt = count; 1029 1030 ib_dma_sync_single_for_device(ibdev, req->indirect_dma_addr, table_len, 1031 DMA_TO_DEVICE); 1032 1033 map_complete: 1034 if (scmnd->sc_data_direction == DMA_TO_DEVICE) 1035 cmd->buf_fmt = fmt << 4; 1036 else 1037 cmd->buf_fmt = fmt; 1038 1039 return len; 1040 } 1041 1042 /* 1043 * Return an IU and possible credit to the free pool 1044 */ 1045 static void srp_put_tx_iu(struct srp_target_port *target, struct srp_iu *iu, 1046 enum srp_iu_type iu_type) 1047 { 1048 unsigned long flags; 1049 1050 spin_lock_irqsave(&target->lock, flags); 1051 list_add(&iu->list, &target->free_tx); 1052 if (iu_type != SRP_IU_RSP) 1053 ++target->req_lim; 1054 spin_unlock_irqrestore(&target->lock, flags); 1055 } 1056 1057 /* 1058 * Must be called with target->lock held to protect req_lim and free_tx. 1059 * If IU is not sent, it must be returned using srp_put_tx_iu(). 1060 * 1061 * Note: 1062 * An upper limit for the number of allocated information units for each 1063 * request type is: 1064 * - SRP_IU_CMD: SRP_CMD_SQ_SIZE, since the SCSI mid-layer never queues 1065 * more than Scsi_Host.can_queue requests. 1066 * - SRP_IU_TSK_MGMT: SRP_TSK_MGMT_SQ_SIZE. 1067 * - SRP_IU_RSP: 1, since a conforming SRP target never sends more than 1068 * one unanswered SRP request to an initiator. 1069 */ 1070 static struct srp_iu *__srp_get_tx_iu(struct srp_target_port *target, 1071 enum srp_iu_type iu_type) 1072 { 1073 s32 rsv = (iu_type == SRP_IU_TSK_MGMT) ? 0 : SRP_TSK_MGMT_SQ_SIZE; 1074 struct srp_iu *iu; 1075 1076 srp_send_completion(target->send_cq, target); 1077 1078 if (list_empty(&target->free_tx)) 1079 return NULL; 1080 1081 /* Initiator responses to target requests do not consume credits */ 1082 if (iu_type != SRP_IU_RSP) { 1083 if (target->req_lim <= rsv) { 1084 ++target->zero_req_lim; 1085 return NULL; 1086 } 1087 1088 --target->req_lim; 1089 } 1090 1091 iu = list_first_entry(&target->free_tx, struct srp_iu, list); 1092 list_del(&iu->list); 1093 return iu; 1094 } 1095 1096 static int srp_post_send(struct srp_target_port *target, 1097 struct srp_iu *iu, int len) 1098 { 1099 struct ib_sge list; 1100 struct ib_send_wr wr, *bad_wr; 1101 1102 list.addr = iu->dma; 1103 list.length = len; 1104 list.lkey = target->lkey; 1105 1106 wr.next = NULL; 1107 wr.wr_id = (uintptr_t) iu; 1108 wr.sg_list = &list; 1109 wr.num_sge = 1; 1110 wr.opcode = IB_WR_SEND; 1111 wr.send_flags = IB_SEND_SIGNALED; 1112 1113 return ib_post_send(target->qp, &wr, &bad_wr); 1114 } 1115 1116 static int srp_post_recv(struct srp_target_port *target, struct srp_iu *iu) 1117 { 1118 struct ib_recv_wr wr, *bad_wr; 1119 struct ib_sge list; 1120 1121 list.addr = iu->dma; 1122 list.length = iu->size; 1123 list.lkey = target->lkey; 1124 1125 wr.next = NULL; 1126 wr.wr_id = (uintptr_t) iu; 1127 wr.sg_list = &list; 1128 wr.num_sge = 1; 1129 1130 return ib_post_recv(target->qp, &wr, &bad_wr); 1131 } 1132 1133 static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp) 1134 { 1135 struct srp_request *req; 1136 struct scsi_cmnd *scmnd; 1137 unsigned long flags; 1138 1139 if (unlikely(rsp->tag & SRP_TAG_TSK_MGMT)) { 1140 spin_lock_irqsave(&target->lock, flags); 1141 target->req_lim += be32_to_cpu(rsp->req_lim_delta); 1142 spin_unlock_irqrestore(&target->lock, flags); 1143 1144 target->tsk_mgmt_status = -1; 1145 if (be32_to_cpu(rsp->resp_data_len) >= 4) 1146 target->tsk_mgmt_status = rsp->data[3]; 1147 complete(&target->tsk_mgmt_done); 1148 } else { 1149 req = &target->req_ring[rsp->tag]; 1150 scmnd = srp_claim_req(target, req, NULL); 1151 if (!scmnd) { 1152 shost_printk(KERN_ERR, target->scsi_host, 1153 "Null scmnd for RSP w/tag %016llx\n", 1154 (unsigned long long) rsp->tag); 1155 1156 spin_lock_irqsave(&target->lock, flags); 1157 target->req_lim += be32_to_cpu(rsp->req_lim_delta); 1158 spin_unlock_irqrestore(&target->lock, flags); 1159 1160 return; 1161 } 1162 scmnd->result = rsp->status; 1163 1164 if (rsp->flags & SRP_RSP_FLAG_SNSVALID) { 1165 memcpy(scmnd->sense_buffer, rsp->data + 1166 be32_to_cpu(rsp->resp_data_len), 1167 min_t(int, be32_to_cpu(rsp->sense_data_len), 1168 SCSI_SENSE_BUFFERSIZE)); 1169 } 1170 1171 if (rsp->flags & (SRP_RSP_FLAG_DOOVER | SRP_RSP_FLAG_DOUNDER)) 1172 scsi_set_resid(scmnd, be32_to_cpu(rsp->data_out_res_cnt)); 1173 else if (rsp->flags & (SRP_RSP_FLAG_DIOVER | SRP_RSP_FLAG_DIUNDER)) 1174 scsi_set_resid(scmnd, be32_to_cpu(rsp->data_in_res_cnt)); 1175 1176 srp_free_req(target, req, scmnd, 1177 be32_to_cpu(rsp->req_lim_delta)); 1178 1179 scmnd->host_scribble = NULL; 1180 scmnd->scsi_done(scmnd); 1181 } 1182 } 1183 1184 static int srp_response_common(struct srp_target_port *target, s32 req_delta, 1185 void *rsp, int len) 1186 { 1187 struct ib_device *dev = target->srp_host->srp_dev->dev; 1188 unsigned long flags; 1189 struct srp_iu *iu; 1190 int err; 1191 1192 spin_lock_irqsave(&target->lock, flags); 1193 target->req_lim += req_delta; 1194 iu = __srp_get_tx_iu(target, SRP_IU_RSP); 1195 spin_unlock_irqrestore(&target->lock, flags); 1196 1197 if (!iu) { 1198 shost_printk(KERN_ERR, target->scsi_host, PFX 1199 "no IU available to send response\n"); 1200 return 1; 1201 } 1202 1203 ib_dma_sync_single_for_cpu(dev, iu->dma, len, DMA_TO_DEVICE); 1204 memcpy(iu->buf, rsp, len); 1205 ib_dma_sync_single_for_device(dev, iu->dma, len, DMA_TO_DEVICE); 1206 1207 err = srp_post_send(target, iu, len); 1208 if (err) { 1209 shost_printk(KERN_ERR, target->scsi_host, PFX 1210 "unable to post response: %d\n", err); 1211 srp_put_tx_iu(target, iu, SRP_IU_RSP); 1212 } 1213 1214 return err; 1215 } 1216 1217 static void srp_process_cred_req(struct srp_target_port *target, 1218 struct srp_cred_req *req) 1219 { 1220 struct srp_cred_rsp rsp = { 1221 .opcode = SRP_CRED_RSP, 1222 .tag = req->tag, 1223 }; 1224 s32 delta = be32_to_cpu(req->req_lim_delta); 1225 1226 if (srp_response_common(target, delta, &rsp, sizeof rsp)) 1227 shost_printk(KERN_ERR, target->scsi_host, PFX 1228 "problems processing SRP_CRED_REQ\n"); 1229 } 1230 1231 static void srp_process_aer_req(struct srp_target_port *target, 1232 struct srp_aer_req *req) 1233 { 1234 struct srp_aer_rsp rsp = { 1235 .opcode = SRP_AER_RSP, 1236 .tag = req->tag, 1237 }; 1238 s32 delta = be32_to_cpu(req->req_lim_delta); 1239 1240 shost_printk(KERN_ERR, target->scsi_host, PFX 1241 "ignoring AER for LUN %llu\n", be64_to_cpu(req->lun)); 1242 1243 if (srp_response_common(target, delta, &rsp, sizeof rsp)) 1244 shost_printk(KERN_ERR, target->scsi_host, PFX 1245 "problems processing SRP_AER_REQ\n"); 1246 } 1247 1248 static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc) 1249 { 1250 struct ib_device *dev = target->srp_host->srp_dev->dev; 1251 struct srp_iu *iu = (struct srp_iu *) (uintptr_t) wc->wr_id; 1252 int res; 1253 u8 opcode; 1254 1255 ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_ti_iu_len, 1256 DMA_FROM_DEVICE); 1257 1258 opcode = *(u8 *) iu->buf; 1259 1260 if (0) { 1261 shost_printk(KERN_ERR, target->scsi_host, 1262 PFX "recv completion, opcode 0x%02x\n", opcode); 1263 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 8, 1, 1264 iu->buf, wc->byte_len, true); 1265 } 1266 1267 switch (opcode) { 1268 case SRP_RSP: 1269 srp_process_rsp(target, iu->buf); 1270 break; 1271 1272 case SRP_CRED_REQ: 1273 srp_process_cred_req(target, iu->buf); 1274 break; 1275 1276 case SRP_AER_REQ: 1277 srp_process_aer_req(target, iu->buf); 1278 break; 1279 1280 case SRP_T_LOGOUT: 1281 /* XXX Handle target logout */ 1282 shost_printk(KERN_WARNING, target->scsi_host, 1283 PFX "Got target logout request\n"); 1284 break; 1285 1286 default: 1287 shost_printk(KERN_WARNING, target->scsi_host, 1288 PFX "Unhandled SRP opcode 0x%02x\n", opcode); 1289 break; 1290 } 1291 1292 ib_dma_sync_single_for_device(dev, iu->dma, target->max_ti_iu_len, 1293 DMA_FROM_DEVICE); 1294 1295 res = srp_post_recv(target, iu); 1296 if (res != 0) 1297 shost_printk(KERN_ERR, target->scsi_host, 1298 PFX "Recv failed with error code %d\n", res); 1299 } 1300 1301 static void srp_handle_qp_err(enum ib_wc_status wc_status, 1302 enum ib_wc_opcode wc_opcode, 1303 struct srp_target_port *target) 1304 { 1305 if (target->connected && !target->qp_in_error) { 1306 shost_printk(KERN_ERR, target->scsi_host, 1307 PFX "failed %s status %d\n", 1308 wc_opcode & IB_WC_RECV ? "receive" : "send", 1309 wc_status); 1310 } 1311 target->qp_in_error = true; 1312 } 1313 1314 static void srp_recv_completion(struct ib_cq *cq, void *target_ptr) 1315 { 1316 struct srp_target_port *target = target_ptr; 1317 struct ib_wc wc; 1318 1319 ib_req_notify_cq(cq, IB_CQ_NEXT_COMP); 1320 while (ib_poll_cq(cq, 1, &wc) > 0) { 1321 if (likely(wc.status == IB_WC_SUCCESS)) { 1322 srp_handle_recv(target, &wc); 1323 } else { 1324 srp_handle_qp_err(wc.status, wc.opcode, target); 1325 } 1326 } 1327 } 1328 1329 static void srp_send_completion(struct ib_cq *cq, void *target_ptr) 1330 { 1331 struct srp_target_port *target = target_ptr; 1332 struct ib_wc wc; 1333 struct srp_iu *iu; 1334 1335 while (ib_poll_cq(cq, 1, &wc) > 0) { 1336 if (likely(wc.status == IB_WC_SUCCESS)) { 1337 iu = (struct srp_iu *) (uintptr_t) wc.wr_id; 1338 list_add(&iu->list, &target->free_tx); 1339 } else { 1340 srp_handle_qp_err(wc.status, wc.opcode, target); 1341 } 1342 } 1343 } 1344 1345 static int srp_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *scmnd) 1346 { 1347 struct srp_target_port *target = host_to_target(shost); 1348 struct srp_request *req; 1349 struct srp_iu *iu; 1350 struct srp_cmd *cmd; 1351 struct ib_device *dev; 1352 unsigned long flags; 1353 int len; 1354 1355 spin_lock_irqsave(&target->lock, flags); 1356 iu = __srp_get_tx_iu(target, SRP_IU_CMD); 1357 if (!iu) 1358 goto err_unlock; 1359 1360 req = list_first_entry(&target->free_reqs, struct srp_request, list); 1361 list_del(&req->list); 1362 spin_unlock_irqrestore(&target->lock, flags); 1363 1364 dev = target->srp_host->srp_dev->dev; 1365 ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_iu_len, 1366 DMA_TO_DEVICE); 1367 1368 scmnd->result = 0; 1369 scmnd->host_scribble = (void *) req; 1370 1371 cmd = iu->buf; 1372 memset(cmd, 0, sizeof *cmd); 1373 1374 cmd->opcode = SRP_CMD; 1375 cmd->lun = cpu_to_be64((u64) scmnd->device->lun << 48); 1376 cmd->tag = req->index; 1377 memcpy(cmd->cdb, scmnd->cmnd, scmnd->cmd_len); 1378 1379 req->scmnd = scmnd; 1380 req->cmd = iu; 1381 1382 len = srp_map_data(scmnd, target, req); 1383 if (len < 0) { 1384 shost_printk(KERN_ERR, target->scsi_host, 1385 PFX "Failed to map data\n"); 1386 goto err_iu; 1387 } 1388 1389 ib_dma_sync_single_for_device(dev, iu->dma, target->max_iu_len, 1390 DMA_TO_DEVICE); 1391 1392 if (srp_post_send(target, iu, len)) { 1393 shost_printk(KERN_ERR, target->scsi_host, PFX "Send failed\n"); 1394 goto err_unmap; 1395 } 1396 1397 return 0; 1398 1399 err_unmap: 1400 srp_unmap_data(scmnd, target, req); 1401 1402 err_iu: 1403 srp_put_tx_iu(target, iu, SRP_IU_CMD); 1404 1405 spin_lock_irqsave(&target->lock, flags); 1406 list_add(&req->list, &target->free_reqs); 1407 1408 err_unlock: 1409 spin_unlock_irqrestore(&target->lock, flags); 1410 1411 return SCSI_MLQUEUE_HOST_BUSY; 1412 } 1413 1414 static int srp_alloc_iu_bufs(struct srp_target_port *target) 1415 { 1416 int i; 1417 1418 for (i = 0; i < SRP_RQ_SIZE; ++i) { 1419 target->rx_ring[i] = srp_alloc_iu(target->srp_host, 1420 target->max_ti_iu_len, 1421 GFP_KERNEL, DMA_FROM_DEVICE); 1422 if (!target->rx_ring[i]) 1423 goto err; 1424 } 1425 1426 for (i = 0; i < SRP_SQ_SIZE; ++i) { 1427 target->tx_ring[i] = srp_alloc_iu(target->srp_host, 1428 target->max_iu_len, 1429 GFP_KERNEL, DMA_TO_DEVICE); 1430 if (!target->tx_ring[i]) 1431 goto err; 1432 1433 list_add(&target->tx_ring[i]->list, &target->free_tx); 1434 } 1435 1436 return 0; 1437 1438 err: 1439 for (i = 0; i < SRP_RQ_SIZE; ++i) { 1440 srp_free_iu(target->srp_host, target->rx_ring[i]); 1441 target->rx_ring[i] = NULL; 1442 } 1443 1444 for (i = 0; i < SRP_SQ_SIZE; ++i) { 1445 srp_free_iu(target->srp_host, target->tx_ring[i]); 1446 target->tx_ring[i] = NULL; 1447 } 1448 1449 return -ENOMEM; 1450 } 1451 1452 static uint32_t srp_compute_rq_tmo(struct ib_qp_attr *qp_attr, int attr_mask) 1453 { 1454 uint64_t T_tr_ns, max_compl_time_ms; 1455 uint32_t rq_tmo_jiffies; 1456 1457 /* 1458 * According to section 11.2.4.2 in the IBTA spec (Modify Queue Pair, 1459 * table 91), both the QP timeout and the retry count have to be set 1460 * for RC QP's during the RTR to RTS transition. 1461 */ 1462 WARN_ON_ONCE((attr_mask & (IB_QP_TIMEOUT | IB_QP_RETRY_CNT)) != 1463 (IB_QP_TIMEOUT | IB_QP_RETRY_CNT)); 1464 1465 /* 1466 * Set target->rq_tmo_jiffies to one second more than the largest time 1467 * it can take before an error completion is generated. See also 1468 * C9-140..142 in the IBTA spec for more information about how to 1469 * convert the QP Local ACK Timeout value to nanoseconds. 1470 */ 1471 T_tr_ns = 4096 * (1ULL << qp_attr->timeout); 1472 max_compl_time_ms = qp_attr->retry_cnt * 4 * T_tr_ns; 1473 do_div(max_compl_time_ms, NSEC_PER_MSEC); 1474 rq_tmo_jiffies = msecs_to_jiffies(max_compl_time_ms + 1000); 1475 1476 return rq_tmo_jiffies; 1477 } 1478 1479 static void srp_cm_rep_handler(struct ib_cm_id *cm_id, 1480 struct srp_login_rsp *lrsp, 1481 struct srp_target_port *target) 1482 { 1483 struct ib_qp_attr *qp_attr = NULL; 1484 int attr_mask = 0; 1485 int ret; 1486 int i; 1487 1488 if (lrsp->opcode == SRP_LOGIN_RSP) { 1489 target->max_ti_iu_len = be32_to_cpu(lrsp->max_ti_iu_len); 1490 target->req_lim = be32_to_cpu(lrsp->req_lim_delta); 1491 1492 /* 1493 * Reserve credits for task management so we don't 1494 * bounce requests back to the SCSI mid-layer. 1495 */ 1496 target->scsi_host->can_queue 1497 = min(target->req_lim - SRP_TSK_MGMT_SQ_SIZE, 1498 target->scsi_host->can_queue); 1499 } else { 1500 shost_printk(KERN_WARNING, target->scsi_host, 1501 PFX "Unhandled RSP opcode %#x\n", lrsp->opcode); 1502 ret = -ECONNRESET; 1503 goto error; 1504 } 1505 1506 if (!target->rx_ring[0]) { 1507 ret = srp_alloc_iu_bufs(target); 1508 if (ret) 1509 goto error; 1510 } 1511 1512 ret = -ENOMEM; 1513 qp_attr = kmalloc(sizeof *qp_attr, GFP_KERNEL); 1514 if (!qp_attr) 1515 goto error; 1516 1517 qp_attr->qp_state = IB_QPS_RTR; 1518 ret = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask); 1519 if (ret) 1520 goto error_free; 1521 1522 ret = ib_modify_qp(target->qp, qp_attr, attr_mask); 1523 if (ret) 1524 goto error_free; 1525 1526 for (i = 0; i < SRP_RQ_SIZE; i++) { 1527 struct srp_iu *iu = target->rx_ring[i]; 1528 ret = srp_post_recv(target, iu); 1529 if (ret) 1530 goto error_free; 1531 } 1532 1533 qp_attr->qp_state = IB_QPS_RTS; 1534 ret = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask); 1535 if (ret) 1536 goto error_free; 1537 1538 target->rq_tmo_jiffies = srp_compute_rq_tmo(qp_attr, attr_mask); 1539 1540 ret = ib_modify_qp(target->qp, qp_attr, attr_mask); 1541 if (ret) 1542 goto error_free; 1543 1544 ret = ib_send_cm_rtu(cm_id, NULL, 0); 1545 1546 error_free: 1547 kfree(qp_attr); 1548 1549 error: 1550 target->status = ret; 1551 } 1552 1553 static void srp_cm_rej_handler(struct ib_cm_id *cm_id, 1554 struct ib_cm_event *event, 1555 struct srp_target_port *target) 1556 { 1557 struct Scsi_Host *shost = target->scsi_host; 1558 struct ib_class_port_info *cpi; 1559 int opcode; 1560 1561 switch (event->param.rej_rcvd.reason) { 1562 case IB_CM_REJ_PORT_CM_REDIRECT: 1563 cpi = event->param.rej_rcvd.ari; 1564 target->path.dlid = cpi->redirect_lid; 1565 target->path.pkey = cpi->redirect_pkey; 1566 cm_id->remote_cm_qpn = be32_to_cpu(cpi->redirect_qp) & 0x00ffffff; 1567 memcpy(target->path.dgid.raw, cpi->redirect_gid, 16); 1568 1569 target->status = target->path.dlid ? 1570 SRP_DLID_REDIRECT : SRP_PORT_REDIRECT; 1571 break; 1572 1573 case IB_CM_REJ_PORT_REDIRECT: 1574 if (srp_target_is_topspin(target)) { 1575 /* 1576 * Topspin/Cisco SRP gateways incorrectly send 1577 * reject reason code 25 when they mean 24 1578 * (port redirect). 1579 */ 1580 memcpy(target->path.dgid.raw, 1581 event->param.rej_rcvd.ari, 16); 1582 1583 shost_printk(KERN_DEBUG, shost, 1584 PFX "Topspin/Cisco redirect to target port GID %016llx%016llx\n", 1585 (unsigned long long) be64_to_cpu(target->path.dgid.global.subnet_prefix), 1586 (unsigned long long) be64_to_cpu(target->path.dgid.global.interface_id)); 1587 1588 target->status = SRP_PORT_REDIRECT; 1589 } else { 1590 shost_printk(KERN_WARNING, shost, 1591 " REJ reason: IB_CM_REJ_PORT_REDIRECT\n"); 1592 target->status = -ECONNRESET; 1593 } 1594 break; 1595 1596 case IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID: 1597 shost_printk(KERN_WARNING, shost, 1598 " REJ reason: IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID\n"); 1599 target->status = -ECONNRESET; 1600 break; 1601 1602 case IB_CM_REJ_CONSUMER_DEFINED: 1603 opcode = *(u8 *) event->private_data; 1604 if (opcode == SRP_LOGIN_REJ) { 1605 struct srp_login_rej *rej = event->private_data; 1606 u32 reason = be32_to_cpu(rej->reason); 1607 1608 if (reason == SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE) 1609 shost_printk(KERN_WARNING, shost, 1610 PFX "SRP_LOGIN_REJ: requested max_it_iu_len too large\n"); 1611 else 1612 shost_printk(KERN_WARNING, shost, 1613 PFX "SRP LOGIN REJECTED, reason 0x%08x\n", reason); 1614 } else 1615 shost_printk(KERN_WARNING, shost, 1616 " REJ reason: IB_CM_REJ_CONSUMER_DEFINED," 1617 " opcode 0x%02x\n", opcode); 1618 target->status = -ECONNRESET; 1619 break; 1620 1621 case IB_CM_REJ_STALE_CONN: 1622 shost_printk(KERN_WARNING, shost, " REJ reason: stale connection\n"); 1623 target->status = SRP_STALE_CONN; 1624 break; 1625 1626 default: 1627 shost_printk(KERN_WARNING, shost, " REJ reason 0x%x\n", 1628 event->param.rej_rcvd.reason); 1629 target->status = -ECONNRESET; 1630 } 1631 } 1632 1633 static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event) 1634 { 1635 struct srp_target_port *target = cm_id->context; 1636 int comp = 0; 1637 1638 switch (event->event) { 1639 case IB_CM_REQ_ERROR: 1640 shost_printk(KERN_DEBUG, target->scsi_host, 1641 PFX "Sending CM REQ failed\n"); 1642 comp = 1; 1643 target->status = -ECONNRESET; 1644 break; 1645 1646 case IB_CM_REP_RECEIVED: 1647 comp = 1; 1648 srp_cm_rep_handler(cm_id, event->private_data, target); 1649 break; 1650 1651 case IB_CM_REJ_RECEIVED: 1652 shost_printk(KERN_DEBUG, target->scsi_host, PFX "REJ received\n"); 1653 comp = 1; 1654 1655 srp_cm_rej_handler(cm_id, event, target); 1656 break; 1657 1658 case IB_CM_DREQ_RECEIVED: 1659 shost_printk(KERN_WARNING, target->scsi_host, 1660 PFX "DREQ received - connection closed\n"); 1661 srp_change_conn_state(target, false); 1662 if (ib_send_cm_drep(cm_id, NULL, 0)) 1663 shost_printk(KERN_ERR, target->scsi_host, 1664 PFX "Sending CM DREP failed\n"); 1665 break; 1666 1667 case IB_CM_TIMEWAIT_EXIT: 1668 shost_printk(KERN_ERR, target->scsi_host, 1669 PFX "connection closed\n"); 1670 1671 target->status = 0; 1672 break; 1673 1674 case IB_CM_MRA_RECEIVED: 1675 case IB_CM_DREQ_ERROR: 1676 case IB_CM_DREP_RECEIVED: 1677 break; 1678 1679 default: 1680 shost_printk(KERN_WARNING, target->scsi_host, 1681 PFX "Unhandled CM event %d\n", event->event); 1682 break; 1683 } 1684 1685 if (comp) 1686 complete(&target->done); 1687 1688 return 0; 1689 } 1690 1691 static int srp_send_tsk_mgmt(struct srp_target_port *target, 1692 u64 req_tag, unsigned int lun, u8 func) 1693 { 1694 struct ib_device *dev = target->srp_host->srp_dev->dev; 1695 struct srp_iu *iu; 1696 struct srp_tsk_mgmt *tsk_mgmt; 1697 1698 init_completion(&target->tsk_mgmt_done); 1699 1700 spin_lock_irq(&target->lock); 1701 iu = __srp_get_tx_iu(target, SRP_IU_TSK_MGMT); 1702 spin_unlock_irq(&target->lock); 1703 1704 if (!iu) 1705 return -1; 1706 1707 ib_dma_sync_single_for_cpu(dev, iu->dma, sizeof *tsk_mgmt, 1708 DMA_TO_DEVICE); 1709 tsk_mgmt = iu->buf; 1710 memset(tsk_mgmt, 0, sizeof *tsk_mgmt); 1711 1712 tsk_mgmt->opcode = SRP_TSK_MGMT; 1713 tsk_mgmt->lun = cpu_to_be64((u64) lun << 48); 1714 tsk_mgmt->tag = req_tag | SRP_TAG_TSK_MGMT; 1715 tsk_mgmt->tsk_mgmt_func = func; 1716 tsk_mgmt->task_tag = req_tag; 1717 1718 ib_dma_sync_single_for_device(dev, iu->dma, sizeof *tsk_mgmt, 1719 DMA_TO_DEVICE); 1720 if (srp_post_send(target, iu, sizeof *tsk_mgmt)) { 1721 srp_put_tx_iu(target, iu, SRP_IU_TSK_MGMT); 1722 return -1; 1723 } 1724 1725 if (!wait_for_completion_timeout(&target->tsk_mgmt_done, 1726 msecs_to_jiffies(SRP_ABORT_TIMEOUT_MS))) 1727 return -1; 1728 1729 return 0; 1730 } 1731 1732 static int srp_abort(struct scsi_cmnd *scmnd) 1733 { 1734 struct srp_target_port *target = host_to_target(scmnd->device->host); 1735 struct srp_request *req = (struct srp_request *) scmnd->host_scribble; 1736 1737 shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n"); 1738 1739 if (!req || target->qp_in_error || !srp_claim_req(target, req, scmnd)) 1740 return FAILED; 1741 srp_send_tsk_mgmt(target, req->index, scmnd->device->lun, 1742 SRP_TSK_ABORT_TASK); 1743 srp_free_req(target, req, scmnd, 0); 1744 scmnd->result = DID_ABORT << 16; 1745 scmnd->scsi_done(scmnd); 1746 1747 return SUCCESS; 1748 } 1749 1750 static int srp_reset_device(struct scsi_cmnd *scmnd) 1751 { 1752 struct srp_target_port *target = host_to_target(scmnd->device->host); 1753 int i; 1754 1755 shost_printk(KERN_ERR, target->scsi_host, "SRP reset_device called\n"); 1756 1757 if (target->qp_in_error) 1758 return FAILED; 1759 if (srp_send_tsk_mgmt(target, SRP_TAG_NO_REQ, scmnd->device->lun, 1760 SRP_TSK_LUN_RESET)) 1761 return FAILED; 1762 if (target->tsk_mgmt_status) 1763 return FAILED; 1764 1765 for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) { 1766 struct srp_request *req = &target->req_ring[i]; 1767 if (req->scmnd && req->scmnd->device == scmnd->device) 1768 srp_reset_req(target, req); 1769 } 1770 1771 return SUCCESS; 1772 } 1773 1774 static int srp_reset_host(struct scsi_cmnd *scmnd) 1775 { 1776 struct srp_target_port *target = host_to_target(scmnd->device->host); 1777 int ret = FAILED; 1778 1779 shost_printk(KERN_ERR, target->scsi_host, PFX "SRP reset_host called\n"); 1780 1781 if (!srp_reconnect_target(target)) 1782 ret = SUCCESS; 1783 1784 return ret; 1785 } 1786 1787 static int srp_slave_configure(struct scsi_device *sdev) 1788 { 1789 struct Scsi_Host *shost = sdev->host; 1790 struct srp_target_port *target = host_to_target(shost); 1791 struct request_queue *q = sdev->request_queue; 1792 unsigned long timeout; 1793 1794 if (sdev->type == TYPE_DISK) { 1795 timeout = max_t(unsigned, 30 * HZ, target->rq_tmo_jiffies); 1796 blk_queue_rq_timeout(q, timeout); 1797 } 1798 1799 return 0; 1800 } 1801 1802 static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr, 1803 char *buf) 1804 { 1805 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1806 1807 return sprintf(buf, "0x%016llx\n", 1808 (unsigned long long) be64_to_cpu(target->id_ext)); 1809 } 1810 1811 static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr, 1812 char *buf) 1813 { 1814 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1815 1816 return sprintf(buf, "0x%016llx\n", 1817 (unsigned long long) be64_to_cpu(target->ioc_guid)); 1818 } 1819 1820 static ssize_t show_service_id(struct device *dev, 1821 struct device_attribute *attr, char *buf) 1822 { 1823 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1824 1825 return sprintf(buf, "0x%016llx\n", 1826 (unsigned long long) be64_to_cpu(target->service_id)); 1827 } 1828 1829 static ssize_t show_pkey(struct device *dev, struct device_attribute *attr, 1830 char *buf) 1831 { 1832 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1833 1834 return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey)); 1835 } 1836 1837 static ssize_t show_dgid(struct device *dev, struct device_attribute *attr, 1838 char *buf) 1839 { 1840 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1841 1842 return sprintf(buf, "%pI6\n", target->path.dgid.raw); 1843 } 1844 1845 static ssize_t show_orig_dgid(struct device *dev, 1846 struct device_attribute *attr, char *buf) 1847 { 1848 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1849 1850 return sprintf(buf, "%pI6\n", target->orig_dgid); 1851 } 1852 1853 static ssize_t show_req_lim(struct device *dev, 1854 struct device_attribute *attr, char *buf) 1855 { 1856 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1857 1858 return sprintf(buf, "%d\n", target->req_lim); 1859 } 1860 1861 static ssize_t show_zero_req_lim(struct device *dev, 1862 struct device_attribute *attr, char *buf) 1863 { 1864 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1865 1866 return sprintf(buf, "%d\n", target->zero_req_lim); 1867 } 1868 1869 static ssize_t show_local_ib_port(struct device *dev, 1870 struct device_attribute *attr, char *buf) 1871 { 1872 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1873 1874 return sprintf(buf, "%d\n", target->srp_host->port); 1875 } 1876 1877 static ssize_t show_local_ib_device(struct device *dev, 1878 struct device_attribute *attr, char *buf) 1879 { 1880 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1881 1882 return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name); 1883 } 1884 1885 static ssize_t show_cmd_sg_entries(struct device *dev, 1886 struct device_attribute *attr, char *buf) 1887 { 1888 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1889 1890 return sprintf(buf, "%u\n", target->cmd_sg_cnt); 1891 } 1892 1893 static ssize_t show_allow_ext_sg(struct device *dev, 1894 struct device_attribute *attr, char *buf) 1895 { 1896 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1897 1898 return sprintf(buf, "%s\n", target->allow_ext_sg ? "true" : "false"); 1899 } 1900 1901 static DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL); 1902 static DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); 1903 static DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL); 1904 static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); 1905 static DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); 1906 static DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL); 1907 static DEVICE_ATTR(req_lim, S_IRUGO, show_req_lim, NULL); 1908 static DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL); 1909 static DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL); 1910 static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL); 1911 static DEVICE_ATTR(cmd_sg_entries, S_IRUGO, show_cmd_sg_entries, NULL); 1912 static DEVICE_ATTR(allow_ext_sg, S_IRUGO, show_allow_ext_sg, NULL); 1913 1914 static struct device_attribute *srp_host_attrs[] = { 1915 &dev_attr_id_ext, 1916 &dev_attr_ioc_guid, 1917 &dev_attr_service_id, 1918 &dev_attr_pkey, 1919 &dev_attr_dgid, 1920 &dev_attr_orig_dgid, 1921 &dev_attr_req_lim, 1922 &dev_attr_zero_req_lim, 1923 &dev_attr_local_ib_port, 1924 &dev_attr_local_ib_device, 1925 &dev_attr_cmd_sg_entries, 1926 &dev_attr_allow_ext_sg, 1927 NULL 1928 }; 1929 1930 static struct scsi_host_template srp_template = { 1931 .module = THIS_MODULE, 1932 .name = "InfiniBand SRP initiator", 1933 .proc_name = DRV_NAME, 1934 .slave_configure = srp_slave_configure, 1935 .info = srp_target_info, 1936 .queuecommand = srp_queuecommand, 1937 .eh_abort_handler = srp_abort, 1938 .eh_device_reset_handler = srp_reset_device, 1939 .eh_host_reset_handler = srp_reset_host, 1940 .sg_tablesize = SRP_DEF_SG_TABLESIZE, 1941 .can_queue = SRP_CMD_SQ_SIZE, 1942 .this_id = -1, 1943 .cmd_per_lun = SRP_CMD_SQ_SIZE, 1944 .use_clustering = ENABLE_CLUSTERING, 1945 .shost_attrs = srp_host_attrs 1946 }; 1947 1948 static int srp_add_target(struct srp_host *host, struct srp_target_port *target) 1949 { 1950 struct srp_rport_identifiers ids; 1951 struct srp_rport *rport; 1952 1953 sprintf(target->target_name, "SRP.T10:%016llX", 1954 (unsigned long long) be64_to_cpu(target->id_ext)); 1955 1956 if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device)) 1957 return -ENODEV; 1958 1959 memcpy(ids.port_id, &target->id_ext, 8); 1960 memcpy(ids.port_id + 8, &target->ioc_guid, 8); 1961 ids.roles = SRP_RPORT_ROLE_TARGET; 1962 rport = srp_rport_add(target->scsi_host, &ids); 1963 if (IS_ERR(rport)) { 1964 scsi_remove_host(target->scsi_host); 1965 return PTR_ERR(rport); 1966 } 1967 1968 rport->lld_data = target; 1969 1970 spin_lock(&host->target_lock); 1971 list_add_tail(&target->list, &host->target_list); 1972 spin_unlock(&host->target_lock); 1973 1974 target->state = SRP_TARGET_LIVE; 1975 target->connected = false; 1976 1977 scsi_scan_target(&target->scsi_host->shost_gendev, 1978 0, target->scsi_id, SCAN_WILD_CARD, 0); 1979 1980 return 0; 1981 } 1982 1983 static void srp_release_dev(struct device *dev) 1984 { 1985 struct srp_host *host = 1986 container_of(dev, struct srp_host, dev); 1987 1988 complete(&host->released); 1989 } 1990 1991 static struct class srp_class = { 1992 .name = "infiniband_srp", 1993 .dev_release = srp_release_dev 1994 }; 1995 1996 /* 1997 * Target ports are added by writing 1998 * 1999 * id_ext=<SRP ID ext>,ioc_guid=<SRP IOC GUID>,dgid=<dest GID>, 2000 * pkey=<P_Key>,service_id=<service ID> 2001 * 2002 * to the add_target sysfs attribute. 2003 */ 2004 enum { 2005 SRP_OPT_ERR = 0, 2006 SRP_OPT_ID_EXT = 1 << 0, 2007 SRP_OPT_IOC_GUID = 1 << 1, 2008 SRP_OPT_DGID = 1 << 2, 2009 SRP_OPT_PKEY = 1 << 3, 2010 SRP_OPT_SERVICE_ID = 1 << 4, 2011 SRP_OPT_MAX_SECT = 1 << 5, 2012 SRP_OPT_MAX_CMD_PER_LUN = 1 << 6, 2013 SRP_OPT_IO_CLASS = 1 << 7, 2014 SRP_OPT_INITIATOR_EXT = 1 << 8, 2015 SRP_OPT_CMD_SG_ENTRIES = 1 << 9, 2016 SRP_OPT_ALLOW_EXT_SG = 1 << 10, 2017 SRP_OPT_SG_TABLESIZE = 1 << 11, 2018 SRP_OPT_ALL = (SRP_OPT_ID_EXT | 2019 SRP_OPT_IOC_GUID | 2020 SRP_OPT_DGID | 2021 SRP_OPT_PKEY | 2022 SRP_OPT_SERVICE_ID), 2023 }; 2024 2025 static const match_table_t srp_opt_tokens = { 2026 { SRP_OPT_ID_EXT, "id_ext=%s" }, 2027 { SRP_OPT_IOC_GUID, "ioc_guid=%s" }, 2028 { SRP_OPT_DGID, "dgid=%s" }, 2029 { SRP_OPT_PKEY, "pkey=%x" }, 2030 { SRP_OPT_SERVICE_ID, "service_id=%s" }, 2031 { SRP_OPT_MAX_SECT, "max_sect=%d" }, 2032 { SRP_OPT_MAX_CMD_PER_LUN, "max_cmd_per_lun=%d" }, 2033 { SRP_OPT_IO_CLASS, "io_class=%x" }, 2034 { SRP_OPT_INITIATOR_EXT, "initiator_ext=%s" }, 2035 { SRP_OPT_CMD_SG_ENTRIES, "cmd_sg_entries=%u" }, 2036 { SRP_OPT_ALLOW_EXT_SG, "allow_ext_sg=%u" }, 2037 { SRP_OPT_SG_TABLESIZE, "sg_tablesize=%u" }, 2038 { SRP_OPT_ERR, NULL } 2039 }; 2040 2041 static int srp_parse_options(const char *buf, struct srp_target_port *target) 2042 { 2043 char *options, *sep_opt; 2044 char *p; 2045 char dgid[3]; 2046 substring_t args[MAX_OPT_ARGS]; 2047 int opt_mask = 0; 2048 int token; 2049 int ret = -EINVAL; 2050 int i; 2051 2052 options = kstrdup(buf, GFP_KERNEL); 2053 if (!options) 2054 return -ENOMEM; 2055 2056 sep_opt = options; 2057 while ((p = strsep(&sep_opt, ",")) != NULL) { 2058 if (!*p) 2059 continue; 2060 2061 token = match_token(p, srp_opt_tokens, args); 2062 opt_mask |= token; 2063 2064 switch (token) { 2065 case SRP_OPT_ID_EXT: 2066 p = match_strdup(args); 2067 if (!p) { 2068 ret = -ENOMEM; 2069 goto out; 2070 } 2071 target->id_ext = cpu_to_be64(simple_strtoull(p, NULL, 16)); 2072 kfree(p); 2073 break; 2074 2075 case SRP_OPT_IOC_GUID: 2076 p = match_strdup(args); 2077 if (!p) { 2078 ret = -ENOMEM; 2079 goto out; 2080 } 2081 target->ioc_guid = cpu_to_be64(simple_strtoull(p, NULL, 16)); 2082 kfree(p); 2083 break; 2084 2085 case SRP_OPT_DGID: 2086 p = match_strdup(args); 2087 if (!p) { 2088 ret = -ENOMEM; 2089 goto out; 2090 } 2091 if (strlen(p) != 32) { 2092 pr_warn("bad dest GID parameter '%s'\n", p); 2093 kfree(p); 2094 goto out; 2095 } 2096 2097 for (i = 0; i < 16; ++i) { 2098 strlcpy(dgid, p + i * 2, 3); 2099 target->path.dgid.raw[i] = simple_strtoul(dgid, NULL, 16); 2100 } 2101 kfree(p); 2102 memcpy(target->orig_dgid, target->path.dgid.raw, 16); 2103 break; 2104 2105 case SRP_OPT_PKEY: 2106 if (match_hex(args, &token)) { 2107 pr_warn("bad P_Key parameter '%s'\n", p); 2108 goto out; 2109 } 2110 target->path.pkey = cpu_to_be16(token); 2111 break; 2112 2113 case SRP_OPT_SERVICE_ID: 2114 p = match_strdup(args); 2115 if (!p) { 2116 ret = -ENOMEM; 2117 goto out; 2118 } 2119 target->service_id = cpu_to_be64(simple_strtoull(p, NULL, 16)); 2120 target->path.service_id = target->service_id; 2121 kfree(p); 2122 break; 2123 2124 case SRP_OPT_MAX_SECT: 2125 if (match_int(args, &token)) { 2126 pr_warn("bad max sect parameter '%s'\n", p); 2127 goto out; 2128 } 2129 target->scsi_host->max_sectors = token; 2130 break; 2131 2132 case SRP_OPT_MAX_CMD_PER_LUN: 2133 if (match_int(args, &token)) { 2134 pr_warn("bad max cmd_per_lun parameter '%s'\n", 2135 p); 2136 goto out; 2137 } 2138 target->scsi_host->cmd_per_lun = min(token, SRP_CMD_SQ_SIZE); 2139 break; 2140 2141 case SRP_OPT_IO_CLASS: 2142 if (match_hex(args, &token)) { 2143 pr_warn("bad IO class parameter '%s'\n", p); 2144 goto out; 2145 } 2146 if (token != SRP_REV10_IB_IO_CLASS && 2147 token != SRP_REV16A_IB_IO_CLASS) { 2148 pr_warn("unknown IO class parameter value %x specified (use %x or %x).\n", 2149 token, SRP_REV10_IB_IO_CLASS, 2150 SRP_REV16A_IB_IO_CLASS); 2151 goto out; 2152 } 2153 target->io_class = token; 2154 break; 2155 2156 case SRP_OPT_INITIATOR_EXT: 2157 p = match_strdup(args); 2158 if (!p) { 2159 ret = -ENOMEM; 2160 goto out; 2161 } 2162 target->initiator_ext = cpu_to_be64(simple_strtoull(p, NULL, 16)); 2163 kfree(p); 2164 break; 2165 2166 case SRP_OPT_CMD_SG_ENTRIES: 2167 if (match_int(args, &token) || token < 1 || token > 255) { 2168 pr_warn("bad max cmd_sg_entries parameter '%s'\n", 2169 p); 2170 goto out; 2171 } 2172 target->cmd_sg_cnt = token; 2173 break; 2174 2175 case SRP_OPT_ALLOW_EXT_SG: 2176 if (match_int(args, &token)) { 2177 pr_warn("bad allow_ext_sg parameter '%s'\n", p); 2178 goto out; 2179 } 2180 target->allow_ext_sg = !!token; 2181 break; 2182 2183 case SRP_OPT_SG_TABLESIZE: 2184 if (match_int(args, &token) || token < 1 || 2185 token > SCSI_MAX_SG_CHAIN_SEGMENTS) { 2186 pr_warn("bad max sg_tablesize parameter '%s'\n", 2187 p); 2188 goto out; 2189 } 2190 target->sg_tablesize = token; 2191 break; 2192 2193 default: 2194 pr_warn("unknown parameter or missing value '%s' in target creation request\n", 2195 p); 2196 goto out; 2197 } 2198 } 2199 2200 if ((opt_mask & SRP_OPT_ALL) == SRP_OPT_ALL) 2201 ret = 0; 2202 else 2203 for (i = 0; i < ARRAY_SIZE(srp_opt_tokens); ++i) 2204 if ((srp_opt_tokens[i].token & SRP_OPT_ALL) && 2205 !(srp_opt_tokens[i].token & opt_mask)) 2206 pr_warn("target creation request is missing parameter '%s'\n", 2207 srp_opt_tokens[i].pattern); 2208 2209 out: 2210 kfree(options); 2211 return ret; 2212 } 2213 2214 static ssize_t srp_create_target(struct device *dev, 2215 struct device_attribute *attr, 2216 const char *buf, size_t count) 2217 { 2218 struct srp_host *host = 2219 container_of(dev, struct srp_host, dev); 2220 struct Scsi_Host *target_host; 2221 struct srp_target_port *target; 2222 struct ib_device *ibdev = host->srp_dev->dev; 2223 dma_addr_t dma_addr; 2224 int i, ret; 2225 2226 target_host = scsi_host_alloc(&srp_template, 2227 sizeof (struct srp_target_port)); 2228 if (!target_host) 2229 return -ENOMEM; 2230 2231 target_host->transportt = ib_srp_transport_template; 2232 target_host->max_channel = 0; 2233 target_host->max_id = 1; 2234 target_host->max_lun = SRP_MAX_LUN; 2235 target_host->max_cmd_len = sizeof ((struct srp_cmd *) (void *) 0L)->cdb; 2236 2237 target = host_to_target(target_host); 2238 2239 target->io_class = SRP_REV16A_IB_IO_CLASS; 2240 target->scsi_host = target_host; 2241 target->srp_host = host; 2242 target->lkey = host->srp_dev->mr->lkey; 2243 target->rkey = host->srp_dev->mr->rkey; 2244 target->cmd_sg_cnt = cmd_sg_entries; 2245 target->sg_tablesize = indirect_sg_entries ? : cmd_sg_entries; 2246 target->allow_ext_sg = allow_ext_sg; 2247 2248 ret = srp_parse_options(buf, target); 2249 if (ret) 2250 goto err; 2251 2252 if (!host->srp_dev->fmr_pool && !target->allow_ext_sg && 2253 target->cmd_sg_cnt < target->sg_tablesize) { 2254 pr_warn("No FMR pool and no external indirect descriptors, limiting sg_tablesize to cmd_sg_cnt\n"); 2255 target->sg_tablesize = target->cmd_sg_cnt; 2256 } 2257 2258 target_host->sg_tablesize = target->sg_tablesize; 2259 target->indirect_size = target->sg_tablesize * 2260 sizeof (struct srp_direct_buf); 2261 target->max_iu_len = sizeof (struct srp_cmd) + 2262 sizeof (struct srp_indirect_buf) + 2263 target->cmd_sg_cnt * sizeof (struct srp_direct_buf); 2264 2265 INIT_WORK(&target->remove_work, srp_remove_work); 2266 spin_lock_init(&target->lock); 2267 INIT_LIST_HEAD(&target->free_tx); 2268 INIT_LIST_HEAD(&target->free_reqs); 2269 for (i = 0; i < SRP_CMD_SQ_SIZE; ++i) { 2270 struct srp_request *req = &target->req_ring[i]; 2271 2272 req->fmr_list = kmalloc(target->cmd_sg_cnt * sizeof (void *), 2273 GFP_KERNEL); 2274 req->map_page = kmalloc(SRP_FMR_SIZE * sizeof (void *), 2275 GFP_KERNEL); 2276 req->indirect_desc = kmalloc(target->indirect_size, GFP_KERNEL); 2277 if (!req->fmr_list || !req->map_page || !req->indirect_desc) 2278 goto err_free_mem; 2279 2280 dma_addr = ib_dma_map_single(ibdev, req->indirect_desc, 2281 target->indirect_size, 2282 DMA_TO_DEVICE); 2283 if (ib_dma_mapping_error(ibdev, dma_addr)) 2284 goto err_free_mem; 2285 2286 req->indirect_dma_addr = dma_addr; 2287 req->index = i; 2288 list_add_tail(&req->list, &target->free_reqs); 2289 } 2290 2291 ib_query_gid(ibdev, host->port, 0, &target->path.sgid); 2292 2293 shost_printk(KERN_DEBUG, target->scsi_host, PFX 2294 "new target: id_ext %016llx ioc_guid %016llx pkey %04x " 2295 "service_id %016llx dgid %pI6\n", 2296 (unsigned long long) be64_to_cpu(target->id_ext), 2297 (unsigned long long) be64_to_cpu(target->ioc_guid), 2298 be16_to_cpu(target->path.pkey), 2299 (unsigned long long) be64_to_cpu(target->service_id), 2300 target->path.dgid.raw); 2301 2302 ret = srp_create_target_ib(target); 2303 if (ret) 2304 goto err_free_mem; 2305 2306 ret = srp_new_cm_id(target); 2307 if (ret) 2308 goto err_free_ib; 2309 2310 ret = srp_connect_target(target); 2311 if (ret) { 2312 shost_printk(KERN_ERR, target->scsi_host, 2313 PFX "Connection failed\n"); 2314 goto err_cm_id; 2315 } 2316 2317 ret = srp_add_target(host, target); 2318 if (ret) 2319 goto err_disconnect; 2320 2321 return count; 2322 2323 err_disconnect: 2324 srp_disconnect_target(target); 2325 2326 err_cm_id: 2327 ib_destroy_cm_id(target->cm_id); 2328 2329 err_free_ib: 2330 srp_free_target_ib(target); 2331 2332 err_free_mem: 2333 srp_free_req_data(target); 2334 2335 err: 2336 scsi_host_put(target_host); 2337 2338 return ret; 2339 } 2340 2341 static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target); 2342 2343 static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, 2344 char *buf) 2345 { 2346 struct srp_host *host = container_of(dev, struct srp_host, dev); 2347 2348 return sprintf(buf, "%s\n", host->srp_dev->dev->name); 2349 } 2350 2351 static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); 2352 2353 static ssize_t show_port(struct device *dev, struct device_attribute *attr, 2354 char *buf) 2355 { 2356 struct srp_host *host = container_of(dev, struct srp_host, dev); 2357 2358 return sprintf(buf, "%d\n", host->port); 2359 } 2360 2361 static DEVICE_ATTR(port, S_IRUGO, show_port, NULL); 2362 2363 static struct srp_host *srp_add_port(struct srp_device *device, u8 port) 2364 { 2365 struct srp_host *host; 2366 2367 host = kzalloc(sizeof *host, GFP_KERNEL); 2368 if (!host) 2369 return NULL; 2370 2371 INIT_LIST_HEAD(&host->target_list); 2372 spin_lock_init(&host->target_lock); 2373 init_completion(&host->released); 2374 host->srp_dev = device; 2375 host->port = port; 2376 2377 host->dev.class = &srp_class; 2378 host->dev.parent = device->dev->dma_device; 2379 dev_set_name(&host->dev, "srp-%s-%d", device->dev->name, port); 2380 2381 if (device_register(&host->dev)) 2382 goto free_host; 2383 if (device_create_file(&host->dev, &dev_attr_add_target)) 2384 goto err_class; 2385 if (device_create_file(&host->dev, &dev_attr_ibdev)) 2386 goto err_class; 2387 if (device_create_file(&host->dev, &dev_attr_port)) 2388 goto err_class; 2389 2390 return host; 2391 2392 err_class: 2393 device_unregister(&host->dev); 2394 2395 free_host: 2396 kfree(host); 2397 2398 return NULL; 2399 } 2400 2401 static void srp_add_one(struct ib_device *device) 2402 { 2403 struct srp_device *srp_dev; 2404 struct ib_device_attr *dev_attr; 2405 struct ib_fmr_pool_param fmr_param; 2406 struct srp_host *host; 2407 int max_pages_per_fmr, fmr_page_shift, s, e, p; 2408 2409 dev_attr = kmalloc(sizeof *dev_attr, GFP_KERNEL); 2410 if (!dev_attr) 2411 return; 2412 2413 if (ib_query_device(device, dev_attr)) { 2414 pr_warn("Query device failed for %s\n", device->name); 2415 goto free_attr; 2416 } 2417 2418 srp_dev = kmalloc(sizeof *srp_dev, GFP_KERNEL); 2419 if (!srp_dev) 2420 goto free_attr; 2421 2422 /* 2423 * Use the smallest page size supported by the HCA, down to a 2424 * minimum of 4096 bytes. We're unlikely to build large sglists 2425 * out of smaller entries. 2426 */ 2427 fmr_page_shift = max(12, ffs(dev_attr->page_size_cap) - 1); 2428 srp_dev->fmr_page_size = 1 << fmr_page_shift; 2429 srp_dev->fmr_page_mask = ~((u64) srp_dev->fmr_page_size - 1); 2430 srp_dev->fmr_max_size = srp_dev->fmr_page_size * SRP_FMR_SIZE; 2431 2432 INIT_LIST_HEAD(&srp_dev->dev_list); 2433 2434 srp_dev->dev = device; 2435 srp_dev->pd = ib_alloc_pd(device); 2436 if (IS_ERR(srp_dev->pd)) 2437 goto free_dev; 2438 2439 srp_dev->mr = ib_get_dma_mr(srp_dev->pd, 2440 IB_ACCESS_LOCAL_WRITE | 2441 IB_ACCESS_REMOTE_READ | 2442 IB_ACCESS_REMOTE_WRITE); 2443 if (IS_ERR(srp_dev->mr)) 2444 goto err_pd; 2445 2446 for (max_pages_per_fmr = SRP_FMR_SIZE; 2447 max_pages_per_fmr >= SRP_FMR_MIN_SIZE; 2448 max_pages_per_fmr /= 2, srp_dev->fmr_max_size /= 2) { 2449 memset(&fmr_param, 0, sizeof fmr_param); 2450 fmr_param.pool_size = SRP_FMR_POOL_SIZE; 2451 fmr_param.dirty_watermark = SRP_FMR_DIRTY_SIZE; 2452 fmr_param.cache = 1; 2453 fmr_param.max_pages_per_fmr = max_pages_per_fmr; 2454 fmr_param.page_shift = fmr_page_shift; 2455 fmr_param.access = (IB_ACCESS_LOCAL_WRITE | 2456 IB_ACCESS_REMOTE_WRITE | 2457 IB_ACCESS_REMOTE_READ); 2458 2459 srp_dev->fmr_pool = ib_create_fmr_pool(srp_dev->pd, &fmr_param); 2460 if (!IS_ERR(srp_dev->fmr_pool)) 2461 break; 2462 } 2463 2464 if (IS_ERR(srp_dev->fmr_pool)) 2465 srp_dev->fmr_pool = NULL; 2466 2467 if (device->node_type == RDMA_NODE_IB_SWITCH) { 2468 s = 0; 2469 e = 0; 2470 } else { 2471 s = 1; 2472 e = device->phys_port_cnt; 2473 } 2474 2475 for (p = s; p <= e; ++p) { 2476 host = srp_add_port(srp_dev, p); 2477 if (host) 2478 list_add_tail(&host->list, &srp_dev->dev_list); 2479 } 2480 2481 ib_set_client_data(device, &srp_client, srp_dev); 2482 2483 goto free_attr; 2484 2485 err_pd: 2486 ib_dealloc_pd(srp_dev->pd); 2487 2488 free_dev: 2489 kfree(srp_dev); 2490 2491 free_attr: 2492 kfree(dev_attr); 2493 } 2494 2495 static void srp_remove_one(struct ib_device *device) 2496 { 2497 struct srp_device *srp_dev; 2498 struct srp_host *host, *tmp_host; 2499 struct srp_target_port *target; 2500 2501 srp_dev = ib_get_client_data(device, &srp_client); 2502 2503 list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) { 2504 device_unregister(&host->dev); 2505 /* 2506 * Wait for the sysfs entry to go away, so that no new 2507 * target ports can be created. 2508 */ 2509 wait_for_completion(&host->released); 2510 2511 /* 2512 * Remove all target ports. 2513 */ 2514 spin_lock(&host->target_lock); 2515 list_for_each_entry(target, &host->target_list, list) 2516 srp_queue_remove_work(target); 2517 spin_unlock(&host->target_lock); 2518 2519 /* 2520 * Wait for target port removal tasks. 2521 */ 2522 flush_workqueue(system_long_wq); 2523 2524 kfree(host); 2525 } 2526 2527 if (srp_dev->fmr_pool) 2528 ib_destroy_fmr_pool(srp_dev->fmr_pool); 2529 ib_dereg_mr(srp_dev->mr); 2530 ib_dealloc_pd(srp_dev->pd); 2531 2532 kfree(srp_dev); 2533 } 2534 2535 static struct srp_function_template ib_srp_transport_functions = { 2536 .rport_delete = srp_rport_delete, 2537 }; 2538 2539 static int __init srp_init_module(void) 2540 { 2541 int ret; 2542 2543 BUILD_BUG_ON(FIELD_SIZEOF(struct ib_wc, wr_id) < sizeof(void *)); 2544 2545 if (srp_sg_tablesize) { 2546 pr_warn("srp_sg_tablesize is deprecated, please use cmd_sg_entries\n"); 2547 if (!cmd_sg_entries) 2548 cmd_sg_entries = srp_sg_tablesize; 2549 } 2550 2551 if (!cmd_sg_entries) 2552 cmd_sg_entries = SRP_DEF_SG_TABLESIZE; 2553 2554 if (cmd_sg_entries > 255) { 2555 pr_warn("Clamping cmd_sg_entries to 255\n"); 2556 cmd_sg_entries = 255; 2557 } 2558 2559 if (!indirect_sg_entries) 2560 indirect_sg_entries = cmd_sg_entries; 2561 else if (indirect_sg_entries < cmd_sg_entries) { 2562 pr_warn("Bumping up indirect_sg_entries to match cmd_sg_entries (%u)\n", 2563 cmd_sg_entries); 2564 indirect_sg_entries = cmd_sg_entries; 2565 } 2566 2567 ib_srp_transport_template = 2568 srp_attach_transport(&ib_srp_transport_functions); 2569 if (!ib_srp_transport_template) 2570 return -ENOMEM; 2571 2572 ret = class_register(&srp_class); 2573 if (ret) { 2574 pr_err("couldn't register class infiniband_srp\n"); 2575 srp_release_transport(ib_srp_transport_template); 2576 return ret; 2577 } 2578 2579 ib_sa_register_client(&srp_sa_client); 2580 2581 ret = ib_register_client(&srp_client); 2582 if (ret) { 2583 pr_err("couldn't register IB client\n"); 2584 srp_release_transport(ib_srp_transport_template); 2585 ib_sa_unregister_client(&srp_sa_client); 2586 class_unregister(&srp_class); 2587 return ret; 2588 } 2589 2590 return 0; 2591 } 2592 2593 static void __exit srp_cleanup_module(void) 2594 { 2595 ib_unregister_client(&srp_client); 2596 ib_sa_unregister_client(&srp_sa_client); 2597 class_unregister(&srp_class); 2598 srp_release_transport(ib_srp_transport_template); 2599 } 2600 2601 module_init(srp_init_module); 2602 module_exit(srp_cleanup_module); 2603