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#include <linux/module.h> 34#include <linux/init.h> 35#include <linux/slab.h> 36#include <linux/err.h> 37#include <linux/string.h> 38#include <linux/parser.h> 39#include <linux/random.h> 40#include <linux/jiffies.h> 41 42#include <asm/atomic.h> 43 44#include <scsi/scsi.h> 45#include <scsi/scsi_device.h> 46#include <scsi/scsi_dbg.h> 47#include <scsi/srp.h> 48#include <scsi/scsi_transport_srp.h> 49 50#include "ib_srp.h" 51 52#define DRV_NAME "ib_srp" 53#define PFX DRV_NAME ": " 54#define DRV_VERSION "0.2" 55#define DRV_RELDATE "November 1, 2005" 56 57MODULE_AUTHOR("Roland Dreier"); 58MODULE_DESCRIPTION("InfiniBand SCSI RDMA Protocol initiator " 59 "v" DRV_VERSION " (" DRV_RELDATE ")"); 60MODULE_LICENSE("Dual BSD/GPL"); 61 62static int srp_sg_tablesize = SRP_DEF_SG_TABLESIZE; 63static int srp_max_iu_len; 64 65module_param(srp_sg_tablesize, int, 0444); 66MODULE_PARM_DESC(srp_sg_tablesize, 67 "Max number of gather/scatter entries per I/O (default is 12, max 255)"); 68 69static int topspin_workarounds = 1; 70 71module_param(topspin_workarounds, int, 0444); 72MODULE_PARM_DESC(topspin_workarounds, 73 "Enable workarounds for Topspin/Cisco SRP target bugs if != 0"); 74 75static int mellanox_workarounds = 1; 76 77module_param(mellanox_workarounds, int, 0444); 78MODULE_PARM_DESC(mellanox_workarounds, 79 "Enable workarounds for Mellanox SRP target bugs if != 0"); 80 81static void srp_add_one(struct ib_device *device); 82static void srp_remove_one(struct ib_device *device); 83static void srp_recv_completion(struct ib_cq *cq, void *target_ptr); 84static void srp_send_completion(struct ib_cq *cq, void *target_ptr); 85static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event); 86 87static struct scsi_transport_template *ib_srp_transport_template; 88 89static struct ib_client srp_client = { 90 .name = "srp", 91 .add = srp_add_one, 92 .remove = srp_remove_one 93}; 94 95static struct ib_sa_client srp_sa_client; 96 97static inline struct srp_target_port *host_to_target(struct Scsi_Host *host) 98{ 99 return (struct srp_target_port *) host->hostdata; 100} 101 102static const char *srp_target_info(struct Scsi_Host *host) 103{ 104 return host_to_target(host)->target_name; 105} 106 107static int srp_target_is_topspin(struct srp_target_port *target) 108{ 109 static const u8 topspin_oui[3] = { 0x00, 0x05, 0xad }; 110 static const u8 cisco_oui[3] = { 0x00, 0x1b, 0x0d }; 111 112 return topspin_workarounds && 113 (!memcmp(&target->ioc_guid, topspin_oui, sizeof topspin_oui) || 114 !memcmp(&target->ioc_guid, cisco_oui, sizeof cisco_oui)); 115} 116 117static int srp_target_is_mellanox(struct srp_target_port *target) 118{ 119 static const u8 mellanox_oui[3] = { 0x00, 0x02, 0xc9 }; 120 121 return mellanox_workarounds && 122 !memcmp(&target->ioc_guid, mellanox_oui, sizeof mellanox_oui); 123} 124 125static 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 149out_free_buf: 150 kfree(iu->buf); 151out_free_iu: 152 kfree(iu); 153out: 154 return NULL; 155} 156 157static 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 168static void srp_qp_event(struct ib_event *event, void *context) 169{ 170 printk(KERN_ERR PFX "QP event %d\n", event->event); 171} 172 173static 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 201out: 202 kfree(attr); 203 return ret; 204} 205 206static 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 222static int srp_create_target_ib(struct srp_target_port *target) 223{ 224 struct ib_qp_init_attr *init_attr; 225 int ret; 226 227 init_attr = kzalloc(sizeof *init_attr, GFP_KERNEL); 228 if (!init_attr) 229 return -ENOMEM; 230 231 target->recv_cq = ib_create_cq(target->srp_host->srp_dev->dev, 232 srp_recv_completion, NULL, target, SRP_RQ_SIZE, 0); 233 if (IS_ERR(target->recv_cq)) { 234 ret = PTR_ERR(target->recv_cq); 235 goto err; 236 } 237 238 target->send_cq = ib_create_cq(target->srp_host->srp_dev->dev, 239 srp_send_completion, NULL, target, SRP_SQ_SIZE, 0); 240 if (IS_ERR(target->send_cq)) { 241 ret = PTR_ERR(target->send_cq); 242 goto err_recv_cq; 243 } 244 245 ib_req_notify_cq(target->recv_cq, IB_CQ_NEXT_COMP); 246 247 init_attr->event_handler = srp_qp_event; 248 init_attr->cap.max_send_wr = SRP_SQ_SIZE; 249 init_attr->cap.max_recv_wr = SRP_RQ_SIZE; 250 init_attr->cap.max_recv_sge = 1; 251 init_attr->cap.max_send_sge = 1; 252 init_attr->sq_sig_type = IB_SIGNAL_ALL_WR; 253 init_attr->qp_type = IB_QPT_RC; 254 init_attr->send_cq = target->send_cq; 255 init_attr->recv_cq = target->recv_cq; 256 257 target->qp = ib_create_qp(target->srp_host->srp_dev->pd, init_attr); 258 if (IS_ERR(target->qp)) { 259 ret = PTR_ERR(target->qp); 260 goto err_send_cq; 261 } 262 263 ret = srp_init_qp(target, target->qp); 264 if (ret) 265 goto err_qp; 266 267 kfree(init_attr); 268 return 0; 269 270err_qp: 271 ib_destroy_qp(target->qp); 272 273err_send_cq: 274 ib_destroy_cq(target->send_cq); 275 276err_recv_cq: 277 ib_destroy_cq(target->recv_cq); 278 279err: 280 kfree(init_attr); 281 return ret; 282} 283 284static void srp_free_target_ib(struct srp_target_port *target) 285{ 286 int i; 287 288 ib_destroy_qp(target->qp); 289 ib_destroy_cq(target->send_cq); 290 ib_destroy_cq(target->recv_cq); 291 292 for (i = 0; i < SRP_RQ_SIZE; ++i) 293 srp_free_iu(target->srp_host, target->rx_ring[i]); 294 for (i = 0; i < SRP_SQ_SIZE + 1; ++i) 295 srp_free_iu(target->srp_host, target->tx_ring[i]); 296} 297 298static void srp_path_rec_completion(int status, 299 struct ib_sa_path_rec *pathrec, 300 void *target_ptr) 301{ 302 struct srp_target_port *target = target_ptr; 303 304 target->status = status; 305 if (status) 306 shost_printk(KERN_ERR, target->scsi_host, 307 PFX "Got failed path rec status %d\n", status); 308 else 309 target->path = *pathrec; 310 complete(&target->done); 311} 312 313static int srp_lookup_path(struct srp_target_port *target) 314{ 315 target->path.numb_path = 1; 316 317 init_completion(&target->done); 318 319 target->path_query_id = ib_sa_path_rec_get(&srp_sa_client, 320 target->srp_host->srp_dev->dev, 321 target->srp_host->port, 322 &target->path, 323 IB_SA_PATH_REC_SERVICE_ID | 324 IB_SA_PATH_REC_DGID | 325 IB_SA_PATH_REC_SGID | 326 IB_SA_PATH_REC_NUMB_PATH | 327 IB_SA_PATH_REC_PKEY, 328 SRP_PATH_REC_TIMEOUT_MS, 329 GFP_KERNEL, 330 srp_path_rec_completion, 331 target, &target->path_query); 332 if (target->path_query_id < 0) 333 return target->path_query_id; 334 335 wait_for_completion(&target->done); 336 337 if (target->status < 0) 338 shost_printk(KERN_WARNING, target->scsi_host, 339 PFX "Path record query failed\n"); 340 341 return target->status; 342} 343 344static int srp_send_req(struct srp_target_port *target) 345{ 346 struct { 347 struct ib_cm_req_param param; 348 struct srp_login_req priv; 349 } *req = NULL; 350 int status; 351 352 req = kzalloc(sizeof *req, GFP_KERNEL); 353 if (!req) 354 return -ENOMEM; 355 356 req->param.primary_path = &target->path; 357 req->param.alternate_path = NULL; 358 req->param.service_id = target->service_id; 359 req->param.qp_num = target->qp->qp_num; 360 req->param.qp_type = target->qp->qp_type; 361 req->param.private_data = &req->priv; 362 req->param.private_data_len = sizeof req->priv; 363 req->param.flow_control = 1; 364 365 get_random_bytes(&req->param.starting_psn, 4); 366 req->param.starting_psn &= 0xffffff; 367 368 /* 369 * Pick some arbitrary defaults here; we could make these 370 * module parameters if anyone cared about setting them. 371 */ 372 req->param.responder_resources = 4; 373 req->param.remote_cm_response_timeout = 20; 374 req->param.local_cm_response_timeout = 20; 375 req->param.retry_count = 7; 376 req->param.rnr_retry_count = 7; 377 req->param.max_cm_retries = 15; 378 379 req->priv.opcode = SRP_LOGIN_REQ; 380 req->priv.tag = 0; 381 req->priv.req_it_iu_len = cpu_to_be32(srp_max_iu_len); 382 req->priv.req_buf_fmt = cpu_to_be16(SRP_BUF_FORMAT_DIRECT | 383 SRP_BUF_FORMAT_INDIRECT); 384 /* 385 * In the published SRP specification (draft rev. 16a), the 386 * port identifier format is 8 bytes of ID extension followed 387 * by 8 bytes of GUID. Older drafts put the two halves in the 388 * opposite order, so that the GUID comes first. 389 * 390 * Targets conforming to these obsolete drafts can be 391 * recognized by the I/O Class they report. 392 */ 393 if (target->io_class == SRP_REV10_IB_IO_CLASS) { 394 memcpy(req->priv.initiator_port_id, 395 &target->path.sgid.global.interface_id, 8); 396 memcpy(req->priv.initiator_port_id + 8, 397 &target->initiator_ext, 8); 398 memcpy(req->priv.target_port_id, &target->ioc_guid, 8); 399 memcpy(req->priv.target_port_id + 8, &target->id_ext, 8); 400 } else { 401 memcpy(req->priv.initiator_port_id, 402 &target->initiator_ext, 8); 403 memcpy(req->priv.initiator_port_id + 8, 404 &target->path.sgid.global.interface_id, 8); 405 memcpy(req->priv.target_port_id, &target->id_ext, 8); 406 memcpy(req->priv.target_port_id + 8, &target->ioc_guid, 8); 407 } 408 409 /* 410 * Topspin/Cisco SRP targets will reject our login unless we 411 * zero out the first 8 bytes of our initiator port ID and set 412 * the second 8 bytes to the local node GUID. 413 */ 414 if (srp_target_is_topspin(target)) { 415 shost_printk(KERN_DEBUG, target->scsi_host, 416 PFX "Topspin/Cisco initiator port ID workaround " 417 "activated for target GUID %016llx\n", 418 (unsigned long long) be64_to_cpu(target->ioc_guid)); 419 memset(req->priv.initiator_port_id, 0, 8); 420 memcpy(req->priv.initiator_port_id + 8, 421 &target->srp_host->srp_dev->dev->node_guid, 8); 422 } 423 424 status = ib_send_cm_req(target->cm_id, &req->param); 425 426 kfree(req); 427 428 return status; 429} 430 431static void srp_disconnect_target(struct srp_target_port *target) 432{ 433 434 init_completion(&target->done); 435 if (ib_send_cm_dreq(target->cm_id, NULL, 0)) { 436 shost_printk(KERN_DEBUG, target->scsi_host, 437 PFX "Sending CM DREQ failed\n"); 438 return; 439 } 440 wait_for_completion(&target->done); 441} 442 443static void srp_remove_work(struct work_struct *work) 444{ 445 struct srp_target_port *target = 446 container_of(work, struct srp_target_port, work); 447 448 spin_lock_irq(target->scsi_host->host_lock); 449 if (target->state != SRP_TARGET_DEAD) { 450 spin_unlock_irq(target->scsi_host->host_lock); 451 return; 452 } 453 target->state = SRP_TARGET_REMOVED; 454 spin_unlock_irq(target->scsi_host->host_lock); 455 456 spin_lock(&target->srp_host->target_lock); 457 list_del(&target->list); 458 spin_unlock(&target->srp_host->target_lock); 459 460 srp_remove_host(target->scsi_host); 461 scsi_remove_host(target->scsi_host); 462 ib_destroy_cm_id(target->cm_id); 463 srp_free_target_ib(target); 464 scsi_host_put(target->scsi_host); 465} 466 467static int srp_connect_target(struct srp_target_port *target) 468{ 469 int retries = 3; 470 int ret; 471 472 ret = srp_lookup_path(target); 473 if (ret) 474 return ret; 475 476 while (1) { 477 init_completion(&target->done); 478 ret = srp_send_req(target); 479 if (ret) 480 return ret; 481 wait_for_completion(&target->done); 482 483 /* 484 * The CM event handling code will set status to 485 * SRP_PORT_REDIRECT if we get a port redirect REJ 486 * back, or SRP_DLID_REDIRECT if we get a lid/qp 487 * redirect REJ back. 488 */ 489 switch (target->status) { 490 case 0: 491 return 0; 492 493 case SRP_PORT_REDIRECT: 494 ret = srp_lookup_path(target); 495 if (ret) 496 return ret; 497 break; 498 499 case SRP_DLID_REDIRECT: 500 break; 501 502 case SRP_STALE_CONN: 503 /* Our current CM id was stale, and is now in timewait. 504 * Try to reconnect with a new one. 505 */ 506 if (!retries-- || srp_new_cm_id(target)) { 507 shost_printk(KERN_ERR, target->scsi_host, PFX 508 "giving up on stale connection\n"); 509 target->status = -ECONNRESET; 510 return target->status; 511 } 512 513 shost_printk(KERN_ERR, target->scsi_host, PFX 514 "retrying stale connection\n"); 515 break; 516 517 default: 518 return target->status; 519 } 520 } 521} 522 523static void srp_unmap_data(struct scsi_cmnd *scmnd, 524 struct srp_target_port *target, 525 struct srp_request *req) 526{ 527 if (!scsi_sglist(scmnd) || 528 (scmnd->sc_data_direction != DMA_TO_DEVICE && 529 scmnd->sc_data_direction != DMA_FROM_DEVICE)) 530 return; 531 532 if (req->fmr) { 533 ib_fmr_pool_unmap(req->fmr); 534 req->fmr = NULL; 535 } 536 537 ib_dma_unmap_sg(target->srp_host->srp_dev->dev, scsi_sglist(scmnd), 538 scsi_sg_count(scmnd), scmnd->sc_data_direction); 539} 540 541static void srp_remove_req(struct srp_target_port *target, struct srp_request *req) 542{ 543 srp_unmap_data(req->scmnd, target, req); 544 list_move_tail(&req->list, &target->free_reqs); 545} 546 547static void srp_reset_req(struct srp_target_port *target, struct srp_request *req) 548{ 549 req->scmnd->result = DID_RESET << 16; 550 req->scmnd->scsi_done(req->scmnd); 551 srp_remove_req(target, req); 552} 553 554static int srp_reconnect_target(struct srp_target_port *target) 555{ 556 struct ib_qp_attr qp_attr; 557 struct srp_request *req, *tmp; 558 struct ib_wc wc; 559 int ret; 560 561 spin_lock_irq(target->scsi_host->host_lock); 562 if (target->state != SRP_TARGET_LIVE) { 563 spin_unlock_irq(target->scsi_host->host_lock); 564 return -EAGAIN; 565 } 566 target->state = SRP_TARGET_CONNECTING; 567 spin_unlock_irq(target->scsi_host->host_lock); 568 569 srp_disconnect_target(target); 570 /* 571 * Now get a new local CM ID so that we avoid confusing the 572 * target in case things are really fouled up. 573 */ 574 ret = srp_new_cm_id(target); 575 if (ret) 576 goto err; 577 578 qp_attr.qp_state = IB_QPS_RESET; 579 ret = ib_modify_qp(target->qp, &qp_attr, IB_QP_STATE); 580 if (ret) 581 goto err; 582 583 ret = srp_init_qp(target, target->qp); 584 if (ret) 585 goto err; 586 587 while (ib_poll_cq(target->recv_cq, 1, &wc) > 0) 588 ; /* nothing */ 589 while (ib_poll_cq(target->send_cq, 1, &wc) > 0) 590 ; /* nothing */ 591 592 spin_lock_irq(target->scsi_host->host_lock); 593 list_for_each_entry_safe(req, tmp, &target->req_queue, list) 594 srp_reset_req(target, req); 595 spin_unlock_irq(target->scsi_host->host_lock); 596 597 target->rx_head = 0; 598 target->tx_head = 0; 599 target->tx_tail = 0; 600 601 target->qp_in_error = 0; 602 ret = srp_connect_target(target); 603 if (ret) 604 goto err; 605 606 spin_lock_irq(target->scsi_host->host_lock); 607 if (target->state == SRP_TARGET_CONNECTING) { 608 ret = 0; 609 target->state = SRP_TARGET_LIVE; 610 } else 611 ret = -EAGAIN; 612 spin_unlock_irq(target->scsi_host->host_lock); 613 614 return ret; 615 616err: 617 shost_printk(KERN_ERR, target->scsi_host, 618 PFX "reconnect failed (%d), removing target port.\n", ret); 619 620 /* 621 * We couldn't reconnect, so kill our target port off. 622 * However, we have to defer the real removal because we might 623 * be in the context of the SCSI error handler now, which 624 * would deadlock if we call scsi_remove_host(). 625 */ 626 spin_lock_irq(target->scsi_host->host_lock); 627 if (target->state == SRP_TARGET_CONNECTING) { 628 target->state = SRP_TARGET_DEAD; 629 INIT_WORK(&target->work, srp_remove_work); 630 schedule_work(&target->work); 631 } 632 spin_unlock_irq(target->scsi_host->host_lock); 633 634 return ret; 635} 636 637static int srp_map_fmr(struct srp_target_port *target, struct scatterlist *scat, 638 int sg_cnt, struct srp_request *req, 639 struct srp_direct_buf *buf) 640{ 641 u64 io_addr = 0; 642 u64 *dma_pages; 643 u32 len; 644 int page_cnt; 645 int i, j; 646 int ret; 647 struct srp_device *dev = target->srp_host->srp_dev; 648 struct ib_device *ibdev = dev->dev; 649 struct scatterlist *sg; 650 651 if (!dev->fmr_pool) 652 return -ENODEV; 653 654 if (srp_target_is_mellanox(target) && 655 (ib_sg_dma_address(ibdev, &scat[0]) & ~dev->fmr_page_mask)) 656 return -EINVAL; 657 658 len = page_cnt = 0; 659 scsi_for_each_sg(req->scmnd, sg, sg_cnt, i) { 660 unsigned int dma_len = ib_sg_dma_len(ibdev, sg); 661 662 if (ib_sg_dma_address(ibdev, sg) & ~dev->fmr_page_mask) { 663 if (i > 0) 664 return -EINVAL; 665 else 666 ++page_cnt; 667 } 668 if ((ib_sg_dma_address(ibdev, sg) + dma_len) & 669 ~dev->fmr_page_mask) { 670 if (i < sg_cnt - 1) 671 return -EINVAL; 672 else 673 ++page_cnt; 674 } 675 676 len += dma_len; 677 } 678 679 page_cnt += len >> dev->fmr_page_shift; 680 if (page_cnt > SRP_FMR_SIZE) 681 return -ENOMEM; 682 683 dma_pages = kmalloc(sizeof (u64) * page_cnt, GFP_ATOMIC); 684 if (!dma_pages) 685 return -ENOMEM; 686 687 page_cnt = 0; 688 scsi_for_each_sg(req->scmnd, sg, sg_cnt, i) { 689 unsigned int dma_len = ib_sg_dma_len(ibdev, sg); 690 691 for (j = 0; j < dma_len; j += dev->fmr_page_size) 692 dma_pages[page_cnt++] = 693 (ib_sg_dma_address(ibdev, sg) & 694 dev->fmr_page_mask) + j; 695 } 696 697 req->fmr = ib_fmr_pool_map_phys(dev->fmr_pool, 698 dma_pages, page_cnt, io_addr); 699 if (IS_ERR(req->fmr)) { 700 ret = PTR_ERR(req->fmr); 701 req->fmr = NULL; 702 goto out; 703 } 704 705 buf->va = cpu_to_be64(ib_sg_dma_address(ibdev, &scat[0]) & 706 ~dev->fmr_page_mask); 707 buf->key = cpu_to_be32(req->fmr->fmr->rkey); 708 buf->len = cpu_to_be32(len); 709 710 ret = 0; 711 712out: 713 kfree(dma_pages); 714 715 return ret; 716} 717 718static int srp_map_data(struct scsi_cmnd *scmnd, struct srp_target_port *target, 719 struct srp_request *req) 720{ 721 struct scatterlist *scat; 722 struct srp_cmd *cmd = req->cmd->buf; 723 int len, nents, count; 724 u8 fmt = SRP_DATA_DESC_DIRECT; 725 struct srp_device *dev; 726 struct ib_device *ibdev; 727 728 if (!scsi_sglist(scmnd) || scmnd->sc_data_direction == DMA_NONE) 729 return sizeof (struct srp_cmd); 730 731 if (scmnd->sc_data_direction != DMA_FROM_DEVICE && 732 scmnd->sc_data_direction != DMA_TO_DEVICE) { 733 shost_printk(KERN_WARNING, target->scsi_host, 734 PFX "Unhandled data direction %d\n", 735 scmnd->sc_data_direction); 736 return -EINVAL; 737 } 738 739 nents = scsi_sg_count(scmnd); 740 scat = scsi_sglist(scmnd); 741 742 dev = target->srp_host->srp_dev; 743 ibdev = dev->dev; 744 745 count = ib_dma_map_sg(ibdev, scat, nents, scmnd->sc_data_direction); 746 747 fmt = SRP_DATA_DESC_DIRECT; 748 len = sizeof (struct srp_cmd) + sizeof (struct srp_direct_buf); 749 750 if (count == 1) { 751 /* 752 * The midlayer only generated a single gather/scatter 753 * entry, or DMA mapping coalesced everything to a 754 * single entry. So a direct descriptor along with 755 * the DMA MR suffices. 756 */ 757 struct srp_direct_buf *buf = (void *) cmd->add_data; 758 759 buf->va = cpu_to_be64(ib_sg_dma_address(ibdev, scat)); 760 buf->key = cpu_to_be32(dev->mr->rkey); 761 buf->len = cpu_to_be32(ib_sg_dma_len(ibdev, scat)); 762 } else if (srp_map_fmr(target, scat, count, req, 763 (void *) cmd->add_data)) { 764 /* 765 * FMR mapping failed, and the scatterlist has more 766 * than one entry. Generate an indirect memory 767 * descriptor. 768 */ 769 struct srp_indirect_buf *buf = (void *) cmd->add_data; 770 struct scatterlist *sg; 771 u32 datalen = 0; 772 int i; 773 774 fmt = SRP_DATA_DESC_INDIRECT; 775 len = sizeof (struct srp_cmd) + 776 sizeof (struct srp_indirect_buf) + 777 count * sizeof (struct srp_direct_buf); 778 779 scsi_for_each_sg(scmnd, sg, count, i) { 780 unsigned int dma_len = ib_sg_dma_len(ibdev, sg); 781 782 buf->desc_list[i].va = 783 cpu_to_be64(ib_sg_dma_address(ibdev, sg)); 784 buf->desc_list[i].key = 785 cpu_to_be32(dev->mr->rkey); 786 buf->desc_list[i].len = cpu_to_be32(dma_len); 787 datalen += dma_len; 788 } 789 790 if (scmnd->sc_data_direction == DMA_TO_DEVICE) 791 cmd->data_out_desc_cnt = count; 792 else 793 cmd->data_in_desc_cnt = count; 794 795 buf->table_desc.va = 796 cpu_to_be64(req->cmd->dma + sizeof *cmd + sizeof *buf); 797 buf->table_desc.key = 798 cpu_to_be32(target->srp_host->srp_dev->mr->rkey); 799 buf->table_desc.len = 800 cpu_to_be32(count * sizeof (struct srp_direct_buf)); 801 802 buf->len = cpu_to_be32(datalen); 803 } 804 805 if (scmnd->sc_data_direction == DMA_TO_DEVICE) 806 cmd->buf_fmt = fmt << 4; 807 else 808 cmd->buf_fmt = fmt; 809 810 return len; 811} 812 813static int srp_post_recv(struct srp_target_port *target) 814{ 815 unsigned long flags; 816 struct srp_iu *iu; 817 struct ib_sge list; 818 struct ib_recv_wr wr, *bad_wr; 819 unsigned int next; 820 int ret; 821 822 spin_lock_irqsave(target->scsi_host->host_lock, flags); 823 824 next = target->rx_head & (SRP_RQ_SIZE - 1); 825 wr.wr_id = next; 826 iu = target->rx_ring[next]; 827 828 list.addr = iu->dma; 829 list.length = iu->size; 830 list.lkey = target->srp_host->srp_dev->mr->lkey; 831 832 wr.next = NULL; 833 wr.sg_list = &list; 834 wr.num_sge = 1; 835 836 ret = ib_post_recv(target->qp, &wr, &bad_wr); 837 if (!ret) 838 ++target->rx_head; 839 840 spin_unlock_irqrestore(target->scsi_host->host_lock, flags); 841 842 return ret; 843} 844 845static void srp_process_rsp(struct srp_target_port *target, struct srp_rsp *rsp) 846{ 847 struct srp_request *req; 848 struct scsi_cmnd *scmnd; 849 unsigned long flags; 850 s32 delta; 851 852 delta = (s32) be32_to_cpu(rsp->req_lim_delta); 853 854 spin_lock_irqsave(target->scsi_host->host_lock, flags); 855 856 target->req_lim += delta; 857 858 req = &target->req_ring[rsp->tag & ~SRP_TAG_TSK_MGMT]; 859 860 if (unlikely(rsp->tag & SRP_TAG_TSK_MGMT)) { 861 if (be32_to_cpu(rsp->resp_data_len) < 4) 862 req->tsk_status = -1; 863 else 864 req->tsk_status = rsp->data[3]; 865 complete(&req->done); 866 } else { 867 scmnd = req->scmnd; 868 if (!scmnd) 869 shost_printk(KERN_ERR, target->scsi_host, 870 "Null scmnd for RSP w/tag %016llx\n", 871 (unsigned long long) rsp->tag); 872 scmnd->result = rsp->status; 873 874 if (rsp->flags & SRP_RSP_FLAG_SNSVALID) { 875 memcpy(scmnd->sense_buffer, rsp->data + 876 be32_to_cpu(rsp->resp_data_len), 877 min_t(int, be32_to_cpu(rsp->sense_data_len), 878 SCSI_SENSE_BUFFERSIZE)); 879 } 880 881 if (rsp->flags & (SRP_RSP_FLAG_DOOVER | SRP_RSP_FLAG_DOUNDER)) 882 scsi_set_resid(scmnd, be32_to_cpu(rsp->data_out_res_cnt)); 883 else if (rsp->flags & (SRP_RSP_FLAG_DIOVER | SRP_RSP_FLAG_DIUNDER)) 884 scsi_set_resid(scmnd, be32_to_cpu(rsp->data_in_res_cnt)); 885 886 if (!req->tsk_mgmt) { 887 scmnd->host_scribble = (void *) -1L; 888 scmnd->scsi_done(scmnd); 889 890 srp_remove_req(target, req); 891 } else 892 req->cmd_done = 1; 893 } 894 895 spin_unlock_irqrestore(target->scsi_host->host_lock, flags); 896} 897 898static void srp_handle_recv(struct srp_target_port *target, struct ib_wc *wc) 899{ 900 struct ib_device *dev; 901 struct srp_iu *iu; 902 int res; 903 u8 opcode; 904 905 iu = target->rx_ring[wc->wr_id]; 906 907 dev = target->srp_host->srp_dev->dev; 908 ib_dma_sync_single_for_cpu(dev, iu->dma, target->max_ti_iu_len, 909 DMA_FROM_DEVICE); 910 911 opcode = *(u8 *) iu->buf; 912 913 if (0) { 914 shost_printk(KERN_ERR, target->scsi_host, 915 PFX "recv completion, opcode 0x%02x\n", opcode); 916 print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 8, 1, 917 iu->buf, wc->byte_len, true); 918 } 919 920 switch (opcode) { 921 case SRP_RSP: 922 srp_process_rsp(target, iu->buf); 923 break; 924 925 case SRP_T_LOGOUT: 926 shost_printk(KERN_WARNING, target->scsi_host, 927 PFX "Got target logout request\n"); 928 break; 929 930 default: 931 shost_printk(KERN_WARNING, target->scsi_host, 932 PFX "Unhandled SRP opcode 0x%02x\n", opcode); 933 break; 934 } 935 936 ib_dma_sync_single_for_device(dev, iu->dma, target->max_ti_iu_len, 937 DMA_FROM_DEVICE); 938 939 res = srp_post_recv(target); 940 if (res != 0) 941 shost_printk(KERN_ERR, target->scsi_host, 942 PFX "Recv failed with error code %d\n", res); 943} 944 945static void srp_recv_completion(struct ib_cq *cq, void *target_ptr) 946{ 947 struct srp_target_port *target = target_ptr; 948 struct ib_wc wc; 949 950 ib_req_notify_cq(cq, IB_CQ_NEXT_COMP); 951 while (ib_poll_cq(cq, 1, &wc) > 0) { 952 if (wc.status) { 953 shost_printk(KERN_ERR, target->scsi_host, 954 PFX "failed receive status %d\n", 955 wc.status); 956 target->qp_in_error = 1; 957 break; 958 } 959 960 srp_handle_recv(target, &wc); 961 } 962} 963 964static void srp_send_completion(struct ib_cq *cq, void *target_ptr) 965{ 966 struct srp_target_port *target = target_ptr; 967 struct ib_wc wc; 968 969 while (ib_poll_cq(cq, 1, &wc) > 0) { 970 if (wc.status) { 971 shost_printk(KERN_ERR, target->scsi_host, 972 PFX "failed send status %d\n", 973 wc.status); 974 target->qp_in_error = 1; 975 break; 976 } 977 978 ++target->tx_tail; 979 } 980} 981 982/* 983 * Must be called with target->scsi_host->host_lock held to protect 984 * req_lim and tx_head. Lock cannot be dropped between call here and 985 * call to __srp_post_send(). 986 */ 987static struct srp_iu *__srp_get_tx_iu(struct srp_target_port *target, 988 enum srp_request_type req_type) 989{ 990 s32 min = (req_type == SRP_REQ_TASK_MGMT) ? 1 : 2; 991 992 srp_send_completion(target->send_cq, target); 993 994 if (target->tx_head - target->tx_tail >= SRP_SQ_SIZE) 995 return NULL; 996 997 if (target->req_lim < min) { 998 ++target->zero_req_lim; 999 return NULL; 1000 } 1001 1002 return target->tx_ring[target->tx_head & SRP_SQ_SIZE]; 1003} 1004 1005/* 1006 * Must be called with target->scsi_host->host_lock held to protect 1007 * req_lim and tx_head. 1008 */ 1009static int __srp_post_send(struct srp_target_port *target, 1010 struct srp_iu *iu, int len) 1011{ 1012 struct ib_sge list; 1013 struct ib_send_wr wr, *bad_wr; 1014 int ret = 0; 1015 1016 list.addr = iu->dma; 1017 list.length = len; 1018 list.lkey = target->srp_host->srp_dev->mr->lkey; 1019 1020 wr.next = NULL; 1021 wr.wr_id = target->tx_head & SRP_SQ_SIZE; 1022 wr.sg_list = &list; 1023 wr.num_sge = 1; 1024 wr.opcode = IB_WR_SEND; 1025 wr.send_flags = IB_SEND_SIGNALED; 1026 1027 ret = ib_post_send(target->qp, &wr, &bad_wr); 1028 1029 if (!ret) { 1030 ++target->tx_head; 1031 --target->req_lim; 1032 } 1033 1034 return ret; 1035} 1036 1037static int srp_queuecommand(struct scsi_cmnd *scmnd, 1038 void (*done)(struct scsi_cmnd *)) 1039{ 1040 struct srp_target_port *target = host_to_target(scmnd->device->host); 1041 struct srp_request *req; 1042 struct srp_iu *iu; 1043 struct srp_cmd *cmd; 1044 struct ib_device *dev; 1045 int len; 1046 1047 if (target->state == SRP_TARGET_CONNECTING) 1048 goto err; 1049 1050 if (target->state == SRP_TARGET_DEAD || 1051 target->state == SRP_TARGET_REMOVED) { 1052 scmnd->result = DID_BAD_TARGET << 16; 1053 done(scmnd); 1054 return 0; 1055 } 1056 1057 iu = __srp_get_tx_iu(target, SRP_REQ_NORMAL); 1058 if (!iu) 1059 goto err; 1060 1061 dev = target->srp_host->srp_dev->dev; 1062 ib_dma_sync_single_for_cpu(dev, iu->dma, srp_max_iu_len, 1063 DMA_TO_DEVICE); 1064 1065 req = list_entry(target->free_reqs.next, struct srp_request, list); 1066 1067 scmnd->scsi_done = done; 1068 scmnd->result = 0; 1069 scmnd->host_scribble = (void *) (long) req->index; 1070 1071 cmd = iu->buf; 1072 memset(cmd, 0, sizeof *cmd); 1073 1074 cmd->opcode = SRP_CMD; 1075 cmd->lun = cpu_to_be64((u64) scmnd->device->lun << 48); 1076 cmd->tag = req->index; 1077 memcpy(cmd->cdb, scmnd->cmnd, scmnd->cmd_len); 1078 1079 req->scmnd = scmnd; 1080 req->cmd = iu; 1081 req->cmd_done = 0; 1082 req->tsk_mgmt = NULL; 1083 1084 len = srp_map_data(scmnd, target, req); 1085 if (len < 0) { 1086 shost_printk(KERN_ERR, target->scsi_host, 1087 PFX "Failed to map data\n"); 1088 goto err; 1089 } 1090 1091 ib_dma_sync_single_for_device(dev, iu->dma, srp_max_iu_len, 1092 DMA_TO_DEVICE); 1093 1094 if (__srp_post_send(target, iu, len)) { 1095 shost_printk(KERN_ERR, target->scsi_host, PFX "Send failed\n"); 1096 goto err_unmap; 1097 } 1098 1099 list_move_tail(&req->list, &target->req_queue); 1100 1101 return 0; 1102 1103err_unmap: 1104 srp_unmap_data(scmnd, target, req); 1105 1106err: 1107 return SCSI_MLQUEUE_HOST_BUSY; 1108} 1109 1110static int srp_alloc_iu_bufs(struct srp_target_port *target) 1111{ 1112 int i; 1113 1114 for (i = 0; i < SRP_RQ_SIZE; ++i) { 1115 target->rx_ring[i] = srp_alloc_iu(target->srp_host, 1116 target->max_ti_iu_len, 1117 GFP_KERNEL, DMA_FROM_DEVICE); 1118 if (!target->rx_ring[i]) 1119 goto err; 1120 } 1121 1122 for (i = 0; i < SRP_SQ_SIZE + 1; ++i) { 1123 target->tx_ring[i] = srp_alloc_iu(target->srp_host, 1124 srp_max_iu_len, 1125 GFP_KERNEL, DMA_TO_DEVICE); 1126 if (!target->tx_ring[i]) 1127 goto err; 1128 } 1129 1130 return 0; 1131 1132err: 1133 for (i = 0; i < SRP_RQ_SIZE; ++i) { 1134 srp_free_iu(target->srp_host, target->rx_ring[i]); 1135 target->rx_ring[i] = NULL; 1136 } 1137 1138 for (i = 0; i < SRP_SQ_SIZE + 1; ++i) { 1139 srp_free_iu(target->srp_host, target->tx_ring[i]); 1140 target->tx_ring[i] = NULL; 1141 } 1142 1143 return -ENOMEM; 1144} 1145 1146static void srp_cm_rej_handler(struct ib_cm_id *cm_id, 1147 struct ib_cm_event *event, 1148 struct srp_target_port *target) 1149{ 1150 struct Scsi_Host *shost = target->scsi_host; 1151 struct ib_class_port_info *cpi; 1152 int opcode; 1153 1154 switch (event->param.rej_rcvd.reason) { 1155 case IB_CM_REJ_PORT_CM_REDIRECT: 1156 cpi = event->param.rej_rcvd.ari; 1157 target->path.dlid = cpi->redirect_lid; 1158 target->path.pkey = cpi->redirect_pkey; 1159 cm_id->remote_cm_qpn = be32_to_cpu(cpi->redirect_qp) & 0x00ffffff; 1160 memcpy(target->path.dgid.raw, cpi->redirect_gid, 16); 1161 1162 target->status = target->path.dlid ? 1163 SRP_DLID_REDIRECT : SRP_PORT_REDIRECT; 1164 break; 1165 1166 case IB_CM_REJ_PORT_REDIRECT: 1167 if (srp_target_is_topspin(target)) { 1168 /* 1169 * Topspin/Cisco SRP gateways incorrectly send 1170 * reject reason code 25 when they mean 24 1171 * (port redirect). 1172 */ 1173 memcpy(target->path.dgid.raw, 1174 event->param.rej_rcvd.ari, 16); 1175 1176 shost_printk(KERN_DEBUG, shost, 1177 PFX "Topspin/Cisco redirect to target port GID %016llx%016llx\n", 1178 (unsigned long long) be64_to_cpu(target->path.dgid.global.subnet_prefix), 1179 (unsigned long long) be64_to_cpu(target->path.dgid.global.interface_id)); 1180 1181 target->status = SRP_PORT_REDIRECT; 1182 } else { 1183 shost_printk(KERN_WARNING, shost, 1184 " REJ reason: IB_CM_REJ_PORT_REDIRECT\n"); 1185 target->status = -ECONNRESET; 1186 } 1187 break; 1188 1189 case IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID: 1190 shost_printk(KERN_WARNING, shost, 1191 " REJ reason: IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID\n"); 1192 target->status = -ECONNRESET; 1193 break; 1194 1195 case IB_CM_REJ_CONSUMER_DEFINED: 1196 opcode = *(u8 *) event->private_data; 1197 if (opcode == SRP_LOGIN_REJ) { 1198 struct srp_login_rej *rej = event->private_data; 1199 u32 reason = be32_to_cpu(rej->reason); 1200 1201 if (reason == SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE) 1202 shost_printk(KERN_WARNING, shost, 1203 PFX "SRP_LOGIN_REJ: requested max_it_iu_len too large\n"); 1204 else 1205 shost_printk(KERN_WARNING, shost, 1206 PFX "SRP LOGIN REJECTED, reason 0x%08x\n", reason); 1207 } else 1208 shost_printk(KERN_WARNING, shost, 1209 " REJ reason: IB_CM_REJ_CONSUMER_DEFINED," 1210 " opcode 0x%02x\n", opcode); 1211 target->status = -ECONNRESET; 1212 break; 1213 1214 case IB_CM_REJ_STALE_CONN: 1215 shost_printk(KERN_WARNING, shost, " REJ reason: stale connection\n"); 1216 target->status = SRP_STALE_CONN; 1217 break; 1218 1219 default: 1220 shost_printk(KERN_WARNING, shost, " REJ reason 0x%x\n", 1221 event->param.rej_rcvd.reason); 1222 target->status = -ECONNRESET; 1223 } 1224} 1225 1226static int srp_cm_handler(struct ib_cm_id *cm_id, struct ib_cm_event *event) 1227{ 1228 struct srp_target_port *target = cm_id->context; 1229 struct ib_qp_attr *qp_attr = NULL; 1230 int attr_mask = 0; 1231 int comp = 0; 1232 int opcode = 0; 1233 int i; 1234 1235 switch (event->event) { 1236 case IB_CM_REQ_ERROR: 1237 shost_printk(KERN_DEBUG, target->scsi_host, 1238 PFX "Sending CM REQ failed\n"); 1239 comp = 1; 1240 target->status = -ECONNRESET; 1241 break; 1242 1243 case IB_CM_REP_RECEIVED: 1244 comp = 1; 1245 opcode = *(u8 *) event->private_data; 1246 1247 if (opcode == SRP_LOGIN_RSP) { 1248 struct srp_login_rsp *rsp = event->private_data; 1249 1250 target->max_ti_iu_len = be32_to_cpu(rsp->max_ti_iu_len); 1251 target->req_lim = be32_to_cpu(rsp->req_lim_delta); 1252 1253 target->scsi_host->can_queue = min(target->req_lim, 1254 target->scsi_host->can_queue); 1255 } else { 1256 shost_printk(KERN_WARNING, target->scsi_host, 1257 PFX "Unhandled RSP opcode %#x\n", opcode); 1258 target->status = -ECONNRESET; 1259 break; 1260 } 1261 1262 if (!target->rx_ring[0]) { 1263 target->status = srp_alloc_iu_bufs(target); 1264 if (target->status) 1265 break; 1266 } 1267 1268 qp_attr = kmalloc(sizeof *qp_attr, GFP_KERNEL); 1269 if (!qp_attr) { 1270 target->status = -ENOMEM; 1271 break; 1272 } 1273 1274 qp_attr->qp_state = IB_QPS_RTR; 1275 target->status = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask); 1276 if (target->status) 1277 break; 1278 1279 target->status = ib_modify_qp(target->qp, qp_attr, attr_mask); 1280 if (target->status) 1281 break; 1282 1283 for (i = 0; i < SRP_RQ_SIZE; i++) { 1284 target->status = srp_post_recv(target); 1285 if (target->status) 1286 break; 1287 } 1288 if (target->status) 1289 break; 1290 1291 qp_attr->qp_state = IB_QPS_RTS; 1292 target->status = ib_cm_init_qp_attr(cm_id, qp_attr, &attr_mask); 1293 if (target->status) 1294 break; 1295 1296 target->status = ib_modify_qp(target->qp, qp_attr, attr_mask); 1297 if (target->status) 1298 break; 1299 1300 target->status = ib_send_cm_rtu(cm_id, NULL, 0); 1301 if (target->status) 1302 break; 1303 1304 break; 1305 1306 case IB_CM_REJ_RECEIVED: 1307 shost_printk(KERN_DEBUG, target->scsi_host, PFX "REJ received\n"); 1308 comp = 1; 1309 1310 srp_cm_rej_handler(cm_id, event, target); 1311 break; 1312 1313 case IB_CM_DREQ_RECEIVED: 1314 shost_printk(KERN_WARNING, target->scsi_host, 1315 PFX "DREQ received - connection closed\n"); 1316 if (ib_send_cm_drep(cm_id, NULL, 0)) 1317 shost_printk(KERN_ERR, target->scsi_host, 1318 PFX "Sending CM DREP failed\n"); 1319 break; 1320 1321 case IB_CM_TIMEWAIT_EXIT: 1322 shost_printk(KERN_ERR, target->scsi_host, 1323 PFX "connection closed\n"); 1324 1325 comp = 1; 1326 target->status = 0; 1327 break; 1328 1329 case IB_CM_MRA_RECEIVED: 1330 case IB_CM_DREQ_ERROR: 1331 case IB_CM_DREP_RECEIVED: 1332 break; 1333 1334 default: 1335 shost_printk(KERN_WARNING, target->scsi_host, 1336 PFX "Unhandled CM event %d\n", event->event); 1337 break; 1338 } 1339 1340 if (comp) 1341 complete(&target->done); 1342 1343 kfree(qp_attr); 1344 1345 return 0; 1346} 1347 1348static int srp_send_tsk_mgmt(struct srp_target_port *target, 1349 struct srp_request *req, u8 func) 1350{ 1351 struct srp_iu *iu; 1352 struct srp_tsk_mgmt *tsk_mgmt; 1353 1354 spin_lock_irq(target->scsi_host->host_lock); 1355 1356 if (target->state == SRP_TARGET_DEAD || 1357 target->state == SRP_TARGET_REMOVED) { 1358 req->scmnd->result = DID_BAD_TARGET << 16; 1359 goto out; 1360 } 1361 1362 init_completion(&req->done); 1363 1364 iu = __srp_get_tx_iu(target, SRP_REQ_TASK_MGMT); 1365 if (!iu) 1366 goto out; 1367 1368 tsk_mgmt = iu->buf; 1369 memset(tsk_mgmt, 0, sizeof *tsk_mgmt); 1370 1371 tsk_mgmt->opcode = SRP_TSK_MGMT; 1372 tsk_mgmt->lun = cpu_to_be64((u64) req->scmnd->device->lun << 48); 1373 tsk_mgmt->tag = req->index | SRP_TAG_TSK_MGMT; 1374 tsk_mgmt->tsk_mgmt_func = func; 1375 tsk_mgmt->task_tag = req->index; 1376 1377 if (__srp_post_send(target, iu, sizeof *tsk_mgmt)) 1378 goto out; 1379 1380 req->tsk_mgmt = iu; 1381 1382 spin_unlock_irq(target->scsi_host->host_lock); 1383 1384 if (!wait_for_completion_timeout(&req->done, 1385 msecs_to_jiffies(SRP_ABORT_TIMEOUT_MS))) 1386 return -1; 1387 1388 return 0; 1389 1390out: 1391 spin_unlock_irq(target->scsi_host->host_lock); 1392 return -1; 1393} 1394 1395static int srp_find_req(struct srp_target_port *target, 1396 struct scsi_cmnd *scmnd, 1397 struct srp_request **req) 1398{ 1399 if (scmnd->host_scribble == (void *) -1L) 1400 return -1; 1401 1402 *req = &target->req_ring[(long) scmnd->host_scribble]; 1403 1404 return 0; 1405} 1406 1407static int srp_abort(struct scsi_cmnd *scmnd) 1408{ 1409 struct srp_target_port *target = host_to_target(scmnd->device->host); 1410 struct srp_request *req; 1411 int ret = SUCCESS; 1412 1413 shost_printk(KERN_ERR, target->scsi_host, "SRP abort called\n"); 1414 1415 if (target->qp_in_error) 1416 return FAILED; 1417 if (srp_find_req(target, scmnd, &req)) 1418 return FAILED; 1419 if (srp_send_tsk_mgmt(target, req, SRP_TSK_ABORT_TASK)) 1420 return FAILED; 1421 1422 spin_lock_irq(target->scsi_host->host_lock); 1423 1424 if (req->cmd_done) { 1425 srp_remove_req(target, req); 1426 scmnd->scsi_done(scmnd); 1427 } else if (!req->tsk_status) { 1428 srp_remove_req(target, req); 1429 scmnd->result = DID_ABORT << 16; 1430 } else 1431 ret = FAILED; 1432 1433 spin_unlock_irq(target->scsi_host->host_lock); 1434 1435 return ret; 1436} 1437 1438static int srp_reset_device(struct scsi_cmnd *scmnd) 1439{ 1440 struct srp_target_port *target = host_to_target(scmnd->device->host); 1441 struct srp_request *req, *tmp; 1442 1443 shost_printk(KERN_ERR, target->scsi_host, "SRP reset_device called\n"); 1444 1445 if (target->qp_in_error) 1446 return FAILED; 1447 if (srp_find_req(target, scmnd, &req)) 1448 return FAILED; 1449 if (srp_send_tsk_mgmt(target, req, SRP_TSK_LUN_RESET)) 1450 return FAILED; 1451 if (req->tsk_status) 1452 return FAILED; 1453 1454 spin_lock_irq(target->scsi_host->host_lock); 1455 1456 list_for_each_entry_safe(req, tmp, &target->req_queue, list) 1457 if (req->scmnd->device == scmnd->device) 1458 srp_reset_req(target, req); 1459 1460 spin_unlock_irq(target->scsi_host->host_lock); 1461 1462 return SUCCESS; 1463} 1464 1465static int srp_reset_host(struct scsi_cmnd *scmnd) 1466{ 1467 struct srp_target_port *target = host_to_target(scmnd->device->host); 1468 int ret = FAILED; 1469 1470 shost_printk(KERN_ERR, target->scsi_host, PFX "SRP reset_host called\n"); 1471 1472 if (!srp_reconnect_target(target)) 1473 ret = SUCCESS; 1474 1475 return ret; 1476} 1477 1478static ssize_t show_id_ext(struct device *dev, struct device_attribute *attr, 1479 char *buf) 1480{ 1481 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1482 1483 if (target->state == SRP_TARGET_DEAD || 1484 target->state == SRP_TARGET_REMOVED) 1485 return -ENODEV; 1486 1487 return sprintf(buf, "0x%016llx\n", 1488 (unsigned long long) be64_to_cpu(target->id_ext)); 1489} 1490 1491static ssize_t show_ioc_guid(struct device *dev, struct device_attribute *attr, 1492 char *buf) 1493{ 1494 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1495 1496 if (target->state == SRP_TARGET_DEAD || 1497 target->state == SRP_TARGET_REMOVED) 1498 return -ENODEV; 1499 1500 return sprintf(buf, "0x%016llx\n", 1501 (unsigned long long) be64_to_cpu(target->ioc_guid)); 1502} 1503 1504static ssize_t show_service_id(struct device *dev, 1505 struct device_attribute *attr, char *buf) 1506{ 1507 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1508 1509 if (target->state == SRP_TARGET_DEAD || 1510 target->state == SRP_TARGET_REMOVED) 1511 return -ENODEV; 1512 1513 return sprintf(buf, "0x%016llx\n", 1514 (unsigned long long) be64_to_cpu(target->service_id)); 1515} 1516 1517static ssize_t show_pkey(struct device *dev, struct device_attribute *attr, 1518 char *buf) 1519{ 1520 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1521 1522 if (target->state == SRP_TARGET_DEAD || 1523 target->state == SRP_TARGET_REMOVED) 1524 return -ENODEV; 1525 1526 return sprintf(buf, "0x%04x\n", be16_to_cpu(target->path.pkey)); 1527} 1528 1529static ssize_t show_dgid(struct device *dev, struct device_attribute *attr, 1530 char *buf) 1531{ 1532 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1533 1534 if (target->state == SRP_TARGET_DEAD || 1535 target->state == SRP_TARGET_REMOVED) 1536 return -ENODEV; 1537 1538 return sprintf(buf, "%pI6\n", target->path.dgid.raw); 1539} 1540 1541static ssize_t show_orig_dgid(struct device *dev, 1542 struct device_attribute *attr, char *buf) 1543{ 1544 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1545 1546 if (target->state == SRP_TARGET_DEAD || 1547 target->state == SRP_TARGET_REMOVED) 1548 return -ENODEV; 1549 1550 return sprintf(buf, "%pI6\n", target->orig_dgid); 1551} 1552 1553static ssize_t show_req_lim(struct device *dev, 1554 struct device_attribute *attr, char *buf) 1555{ 1556 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1557 1558 if (target->state == SRP_TARGET_DEAD || 1559 target->state == SRP_TARGET_REMOVED) 1560 return -ENODEV; 1561 1562 return sprintf(buf, "%d\n", target->req_lim); 1563} 1564 1565static ssize_t show_zero_req_lim(struct device *dev, 1566 struct device_attribute *attr, char *buf) 1567{ 1568 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1569 1570 if (target->state == SRP_TARGET_DEAD || 1571 target->state == SRP_TARGET_REMOVED) 1572 return -ENODEV; 1573 1574 return sprintf(buf, "%d\n", target->zero_req_lim); 1575} 1576 1577static ssize_t show_local_ib_port(struct device *dev, 1578 struct device_attribute *attr, char *buf) 1579{ 1580 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1581 1582 return sprintf(buf, "%d\n", target->srp_host->port); 1583} 1584 1585static ssize_t show_local_ib_device(struct device *dev, 1586 struct device_attribute *attr, char *buf) 1587{ 1588 struct srp_target_port *target = host_to_target(class_to_shost(dev)); 1589 1590 return sprintf(buf, "%s\n", target->srp_host->srp_dev->dev->name); 1591} 1592 1593static DEVICE_ATTR(id_ext, S_IRUGO, show_id_ext, NULL); 1594static DEVICE_ATTR(ioc_guid, S_IRUGO, show_ioc_guid, NULL); 1595static DEVICE_ATTR(service_id, S_IRUGO, show_service_id, NULL); 1596static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); 1597static DEVICE_ATTR(dgid, S_IRUGO, show_dgid, NULL); 1598static DEVICE_ATTR(orig_dgid, S_IRUGO, show_orig_dgid, NULL); 1599static DEVICE_ATTR(req_lim, S_IRUGO, show_req_lim, NULL); 1600static DEVICE_ATTR(zero_req_lim, S_IRUGO, show_zero_req_lim, NULL); 1601static DEVICE_ATTR(local_ib_port, S_IRUGO, show_local_ib_port, NULL); 1602static DEVICE_ATTR(local_ib_device, S_IRUGO, show_local_ib_device, NULL); 1603 1604static struct device_attribute *srp_host_attrs[] = { 1605 &dev_attr_id_ext, 1606 &dev_attr_ioc_guid, 1607 &dev_attr_service_id, 1608 &dev_attr_pkey, 1609 &dev_attr_dgid, 1610 &dev_attr_orig_dgid, 1611 &dev_attr_req_lim, 1612 &dev_attr_zero_req_lim, 1613 &dev_attr_local_ib_port, 1614 &dev_attr_local_ib_device, 1615 NULL 1616}; 1617 1618static struct scsi_host_template srp_template = { 1619 .module = THIS_MODULE, 1620 .name = "InfiniBand SRP initiator", 1621 .proc_name = DRV_NAME, 1622 .info = srp_target_info, 1623 .queuecommand = srp_queuecommand, 1624 .eh_abort_handler = srp_abort, 1625 .eh_device_reset_handler = srp_reset_device, 1626 .eh_host_reset_handler = srp_reset_host, 1627 .can_queue = SRP_SQ_SIZE, 1628 .this_id = -1, 1629 .cmd_per_lun = SRP_SQ_SIZE, 1630 .use_clustering = ENABLE_CLUSTERING, 1631 .shost_attrs = srp_host_attrs 1632}; 1633 1634static int srp_add_target(struct srp_host *host, struct srp_target_port *target) 1635{ 1636 struct srp_rport_identifiers ids; 1637 struct srp_rport *rport; 1638 1639 sprintf(target->target_name, "SRP.T10:%016llX", 1640 (unsigned long long) be64_to_cpu(target->id_ext)); 1641 1642 if (scsi_add_host(target->scsi_host, host->srp_dev->dev->dma_device)) 1643 return -ENODEV; 1644 1645 memcpy(ids.port_id, &target->id_ext, 8); 1646 memcpy(ids.port_id + 8, &target->ioc_guid, 8); 1647 ids.roles = SRP_RPORT_ROLE_TARGET; 1648 rport = srp_rport_add(target->scsi_host, &ids); 1649 if (IS_ERR(rport)) { 1650 scsi_remove_host(target->scsi_host); 1651 return PTR_ERR(rport); 1652 } 1653 1654 spin_lock(&host->target_lock); 1655 list_add_tail(&target->list, &host->target_list); 1656 spin_unlock(&host->target_lock); 1657 1658 target->state = SRP_TARGET_LIVE; 1659 1660 scsi_scan_target(&target->scsi_host->shost_gendev, 1661 0, target->scsi_id, SCAN_WILD_CARD, 0); 1662 1663 return 0; 1664} 1665 1666static void srp_release_dev(struct device *dev) 1667{ 1668 struct srp_host *host = 1669 container_of(dev, struct srp_host, dev); 1670 1671 complete(&host->released); 1672} 1673 1674static struct class srp_class = { 1675 .name = "infiniband_srp", 1676 .dev_release = srp_release_dev 1677}; 1678 1679/* 1680 * Target ports are added by writing 1681 * 1682 * id_ext=<SRP ID ext>,ioc_guid=<SRP IOC GUID>,dgid=<dest GID>, 1683 * pkey=<P_Key>,service_id=<service ID> 1684 * 1685 * to the add_target sysfs attribute. 1686 */ 1687enum { 1688 SRP_OPT_ERR = 0, 1689 SRP_OPT_ID_EXT = 1 << 0, 1690 SRP_OPT_IOC_GUID = 1 << 1, 1691 SRP_OPT_DGID = 1 << 2, 1692 SRP_OPT_PKEY = 1 << 3, 1693 SRP_OPT_SERVICE_ID = 1 << 4, 1694 SRP_OPT_MAX_SECT = 1 << 5, 1695 SRP_OPT_MAX_CMD_PER_LUN = 1 << 6, 1696 SRP_OPT_IO_CLASS = 1 << 7, 1697 SRP_OPT_INITIATOR_EXT = 1 << 8, 1698 SRP_OPT_ALL = (SRP_OPT_ID_EXT | 1699 SRP_OPT_IOC_GUID | 1700 SRP_OPT_DGID | 1701 SRP_OPT_PKEY | 1702 SRP_OPT_SERVICE_ID), 1703}; 1704 1705static const match_table_t srp_opt_tokens = { 1706 { SRP_OPT_ID_EXT, "id_ext=%s" }, 1707 { SRP_OPT_IOC_GUID, "ioc_guid=%s" }, 1708 { SRP_OPT_DGID, "dgid=%s" }, 1709 { SRP_OPT_PKEY, "pkey=%x" }, 1710 { SRP_OPT_SERVICE_ID, "service_id=%s" }, 1711 { SRP_OPT_MAX_SECT, "max_sect=%d" }, 1712 { SRP_OPT_MAX_CMD_PER_LUN, "max_cmd_per_lun=%d" }, 1713 { SRP_OPT_IO_CLASS, "io_class=%x" }, 1714 { SRP_OPT_INITIATOR_EXT, "initiator_ext=%s" }, 1715 { SRP_OPT_ERR, NULL } 1716}; 1717 1718static int srp_parse_options(const char *buf, struct srp_target_port *target) 1719{ 1720 char *options, *sep_opt; 1721 char *p; 1722 char dgid[3]; 1723 substring_t args[MAX_OPT_ARGS]; 1724 int opt_mask = 0; 1725 int token; 1726 int ret = -EINVAL; 1727 int i; 1728 1729 options = kstrdup(buf, GFP_KERNEL); 1730 if (!options) 1731 return -ENOMEM; 1732 1733 sep_opt = options; 1734 while ((p = strsep(&sep_opt, ",")) != NULL) { 1735 if (!*p) 1736 continue; 1737 1738 token = match_token(p, srp_opt_tokens, args); 1739 opt_mask |= token; 1740 1741 switch (token) { 1742 case SRP_OPT_ID_EXT: 1743 p = match_strdup(args); 1744 if (!p) { 1745 ret = -ENOMEM; 1746 goto out; 1747 } 1748 target->id_ext = cpu_to_be64(simple_strtoull(p, NULL, 16)); 1749 kfree(p); 1750 break; 1751 1752 case SRP_OPT_IOC_GUID: 1753 p = match_strdup(args); 1754 if (!p) { 1755 ret = -ENOMEM; 1756 goto out; 1757 } 1758 target->ioc_guid = cpu_to_be64(simple_strtoull(p, NULL, 16)); 1759 kfree(p); 1760 break; 1761 1762 case SRP_OPT_DGID: 1763 p = match_strdup(args); 1764 if (!p) { 1765 ret = -ENOMEM; 1766 goto out; 1767 } 1768 if (strlen(p) != 32) { 1769 printk(KERN_WARNING PFX "bad dest GID parameter '%s'\n", p); 1770 kfree(p); 1771 goto out; 1772 } 1773 1774 for (i = 0; i < 16; ++i) { 1775 strlcpy(dgid, p + i * 2, 3); 1776 target->path.dgid.raw[i] = simple_strtoul(dgid, NULL, 16); 1777 } 1778 kfree(p); 1779 memcpy(target->orig_dgid, target->path.dgid.raw, 16); 1780 break; 1781 1782 case SRP_OPT_PKEY: 1783 if (match_hex(args, &token)) { 1784 printk(KERN_WARNING PFX "bad P_Key parameter '%s'\n", p); 1785 goto out; 1786 } 1787 target->path.pkey = cpu_to_be16(token); 1788 break; 1789 1790 case SRP_OPT_SERVICE_ID: 1791 p = match_strdup(args); 1792 if (!p) { 1793 ret = -ENOMEM; 1794 goto out; 1795 } 1796 target->service_id = cpu_to_be64(simple_strtoull(p, NULL, 16)); 1797 target->path.service_id = target->service_id; 1798 kfree(p); 1799 break; 1800 1801 case SRP_OPT_MAX_SECT: 1802 if (match_int(args, &token)) { 1803 printk(KERN_WARNING PFX "bad max sect parameter '%s'\n", p); 1804 goto out; 1805 } 1806 target->scsi_host->max_sectors = token; 1807 break; 1808 1809 case SRP_OPT_MAX_CMD_PER_LUN: 1810 if (match_int(args, &token)) { 1811 printk(KERN_WARNING PFX "bad max cmd_per_lun parameter '%s'\n", p); 1812 goto out; 1813 } 1814 target->scsi_host->cmd_per_lun = min(token, SRP_SQ_SIZE); 1815 break; 1816 1817 case SRP_OPT_IO_CLASS: 1818 if (match_hex(args, &token)) { 1819 printk(KERN_WARNING PFX "bad IO class parameter '%s' \n", p); 1820 goto out; 1821 } 1822 if (token != SRP_REV10_IB_IO_CLASS && 1823 token != SRP_REV16A_IB_IO_CLASS) { 1824 printk(KERN_WARNING PFX "unknown IO class parameter value" 1825 " %x specified (use %x or %x).\n", 1826 token, SRP_REV10_IB_IO_CLASS, SRP_REV16A_IB_IO_CLASS); 1827 goto out; 1828 } 1829 target->io_class = token; 1830 break; 1831 1832 case SRP_OPT_INITIATOR_EXT: 1833 p = match_strdup(args); 1834 if (!p) { 1835 ret = -ENOMEM; 1836 goto out; 1837 } 1838 target->initiator_ext = cpu_to_be64(simple_strtoull(p, NULL, 16)); 1839 kfree(p); 1840 break; 1841 1842 default: 1843 printk(KERN_WARNING PFX "unknown parameter or missing value " 1844 "'%s' in target creation request\n", p); 1845 goto out; 1846 } 1847 } 1848 1849 if ((opt_mask & SRP_OPT_ALL) == SRP_OPT_ALL) 1850 ret = 0; 1851 else 1852 for (i = 0; i < ARRAY_SIZE(srp_opt_tokens); ++i) 1853 if ((srp_opt_tokens[i].token & SRP_OPT_ALL) && 1854 !(srp_opt_tokens[i].token & opt_mask)) 1855 printk(KERN_WARNING PFX "target creation request is " 1856 "missing parameter '%s'\n", 1857 srp_opt_tokens[i].pattern); 1858 1859out: 1860 kfree(options); 1861 return ret; 1862} 1863 1864static ssize_t srp_create_target(struct device *dev, 1865 struct device_attribute *attr, 1866 const char *buf, size_t count) 1867{ 1868 struct srp_host *host = 1869 container_of(dev, struct srp_host, dev); 1870 struct Scsi_Host *target_host; 1871 struct srp_target_port *target; 1872 int ret; 1873 int i; 1874 1875 target_host = scsi_host_alloc(&srp_template, 1876 sizeof (struct srp_target_port)); 1877 if (!target_host) 1878 return -ENOMEM; 1879 1880 target_host->transportt = ib_srp_transport_template; 1881 target_host->max_lun = SRP_MAX_LUN; 1882 target_host->max_cmd_len = sizeof ((struct srp_cmd *) (void *) 0L)->cdb; 1883 1884 target = host_to_target(target_host); 1885 1886 target->io_class = SRP_REV16A_IB_IO_CLASS; 1887 target->scsi_host = target_host; 1888 target->srp_host = host; 1889 1890 INIT_LIST_HEAD(&target->free_reqs); 1891 INIT_LIST_HEAD(&target->req_queue); 1892 for (i = 0; i < SRP_SQ_SIZE; ++i) { 1893 target->req_ring[i].index = i; 1894 list_add_tail(&target->req_ring[i].list, &target->free_reqs); 1895 } 1896 1897 ret = srp_parse_options(buf, target); 1898 if (ret) 1899 goto err; 1900 1901 ib_query_gid(host->srp_dev->dev, host->port, 0, &target->path.sgid); 1902 1903 shost_printk(KERN_DEBUG, target->scsi_host, PFX 1904 "new target: id_ext %016llx ioc_guid %016llx pkey %04x " 1905 "service_id %016llx dgid %pI6\n", 1906 (unsigned long long) be64_to_cpu(target->id_ext), 1907 (unsigned long long) be64_to_cpu(target->ioc_guid), 1908 be16_to_cpu(target->path.pkey), 1909 (unsigned long long) be64_to_cpu(target->service_id), 1910 target->path.dgid.raw); 1911 1912 ret = srp_create_target_ib(target); 1913 if (ret) 1914 goto err; 1915 1916 ret = srp_new_cm_id(target); 1917 if (ret) 1918 goto err_free; 1919 1920 target->qp_in_error = 0; 1921 ret = srp_connect_target(target); 1922 if (ret) { 1923 shost_printk(KERN_ERR, target->scsi_host, 1924 PFX "Connection failed\n"); 1925 goto err_cm_id; 1926 } 1927 1928 ret = srp_add_target(host, target); 1929 if (ret) 1930 goto err_disconnect; 1931 1932 return count; 1933 1934err_disconnect: 1935 srp_disconnect_target(target); 1936 1937err_cm_id: 1938 ib_destroy_cm_id(target->cm_id); 1939 1940err_free: 1941 srp_free_target_ib(target); 1942 1943err: 1944 scsi_host_put(target_host); 1945 1946 return ret; 1947} 1948 1949static DEVICE_ATTR(add_target, S_IWUSR, NULL, srp_create_target); 1950 1951static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, 1952 char *buf) 1953{ 1954 struct srp_host *host = container_of(dev, struct srp_host, dev); 1955 1956 return sprintf(buf, "%s\n", host->srp_dev->dev->name); 1957} 1958 1959static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); 1960 1961static ssize_t show_port(struct device *dev, struct device_attribute *attr, 1962 char *buf) 1963{ 1964 struct srp_host *host = container_of(dev, struct srp_host, dev); 1965 1966 return sprintf(buf, "%d\n", host->port); 1967} 1968 1969static DEVICE_ATTR(port, S_IRUGO, show_port, NULL); 1970 1971static struct srp_host *srp_add_port(struct srp_device *device, u8 port) 1972{ 1973 struct srp_host *host; 1974 1975 host = kzalloc(sizeof *host, GFP_KERNEL); 1976 if (!host) 1977 return NULL; 1978 1979 INIT_LIST_HEAD(&host->target_list); 1980 spin_lock_init(&host->target_lock); 1981 init_completion(&host->released); 1982 host->srp_dev = device; 1983 host->port = port; 1984 1985 host->dev.class = &srp_class; 1986 host->dev.parent = device->dev->dma_device; 1987 dev_set_name(&host->dev, "srp-%s-%d", device->dev->name, port); 1988 1989 if (device_register(&host->dev)) 1990 goto free_host; 1991 if (device_create_file(&host->dev, &dev_attr_add_target)) 1992 goto err_class; 1993 if (device_create_file(&host->dev, &dev_attr_ibdev)) 1994 goto err_class; 1995 if (device_create_file(&host->dev, &dev_attr_port)) 1996 goto err_class; 1997 1998 return host; 1999 2000err_class: 2001 device_unregister(&host->dev); 2002 2003free_host: 2004 kfree(host); 2005 2006 return NULL; 2007} 2008 2009static void srp_add_one(struct ib_device *device) 2010{ 2011 struct srp_device *srp_dev; 2012 struct ib_device_attr *dev_attr; 2013 struct ib_fmr_pool_param fmr_param; 2014 struct srp_host *host; 2015 int s, e, p; 2016 2017 dev_attr = kmalloc(sizeof *dev_attr, GFP_KERNEL); 2018 if (!dev_attr) 2019 return; 2020 2021 if (ib_query_device(device, dev_attr)) { 2022 printk(KERN_WARNING PFX "Query device failed for %s\n", 2023 device->name); 2024 goto free_attr; 2025 } 2026 2027 srp_dev = kmalloc(sizeof *srp_dev, GFP_KERNEL); 2028 if (!srp_dev) 2029 goto free_attr; 2030 2031 /* 2032 * Use the smallest page size supported by the HCA, down to a 2033 * minimum of 512 bytes (which is the smallest sector that a 2034 * SCSI command will ever carry). 2035 */ 2036 srp_dev->fmr_page_shift = max(9, ffs(dev_attr->page_size_cap) - 1); 2037 srp_dev->fmr_page_size = 1 << srp_dev->fmr_page_shift; 2038 srp_dev->fmr_page_mask = ~((u64) srp_dev->fmr_page_size - 1); 2039 2040 INIT_LIST_HEAD(&srp_dev->dev_list); 2041 2042 srp_dev->dev = device; 2043 srp_dev->pd = ib_alloc_pd(device); 2044 if (IS_ERR(srp_dev->pd)) 2045 goto free_dev; 2046 2047 srp_dev->mr = ib_get_dma_mr(srp_dev->pd, 2048 IB_ACCESS_LOCAL_WRITE | 2049 IB_ACCESS_REMOTE_READ | 2050 IB_ACCESS_REMOTE_WRITE); 2051 if (IS_ERR(srp_dev->mr)) 2052 goto err_pd; 2053 2054 memset(&fmr_param, 0, sizeof fmr_param); 2055 fmr_param.pool_size = SRP_FMR_POOL_SIZE; 2056 fmr_param.dirty_watermark = SRP_FMR_DIRTY_SIZE; 2057 fmr_param.cache = 1; 2058 fmr_param.max_pages_per_fmr = SRP_FMR_SIZE; 2059 fmr_param.page_shift = srp_dev->fmr_page_shift; 2060 fmr_param.access = (IB_ACCESS_LOCAL_WRITE | 2061 IB_ACCESS_REMOTE_WRITE | 2062 IB_ACCESS_REMOTE_READ); 2063 2064 srp_dev->fmr_pool = ib_create_fmr_pool(srp_dev->pd, &fmr_param); 2065 if (IS_ERR(srp_dev->fmr_pool)) 2066 srp_dev->fmr_pool = NULL; 2067 2068 if (device->node_type == RDMA_NODE_IB_SWITCH) { 2069 s = 0; 2070 e = 0; 2071 } else { 2072 s = 1; 2073 e = device->phys_port_cnt; 2074 } 2075 2076 for (p = s; p <= e; ++p) { 2077 host = srp_add_port(srp_dev, p); 2078 if (host) 2079 list_add_tail(&host->list, &srp_dev->dev_list); 2080 } 2081 2082 ib_set_client_data(device, &srp_client, srp_dev); 2083 2084 goto free_attr; 2085 2086err_pd: 2087 ib_dealloc_pd(srp_dev->pd); 2088 2089free_dev: 2090 kfree(srp_dev); 2091 2092free_attr: 2093 kfree(dev_attr); 2094} 2095 2096static void srp_remove_one(struct ib_device *device) 2097{ 2098 struct srp_device *srp_dev; 2099 struct srp_host *host, *tmp_host; 2100 LIST_HEAD(target_list); 2101 struct srp_target_port *target, *tmp_target; 2102 2103 srp_dev = ib_get_client_data(device, &srp_client); 2104 2105 list_for_each_entry_safe(host, tmp_host, &srp_dev->dev_list, list) { 2106 device_unregister(&host->dev); 2107 /* 2108 * Wait for the sysfs entry to go away, so that no new 2109 * target ports can be created. 2110 */ 2111 wait_for_completion(&host->released); 2112 2113 /* 2114 * Mark all target ports as removed, so we stop queueing 2115 * commands and don't try to reconnect. 2116 */ 2117 spin_lock(&host->target_lock); 2118 list_for_each_entry(target, &host->target_list, list) { 2119 spin_lock_irq(target->scsi_host->host_lock); 2120 target->state = SRP_TARGET_REMOVED; 2121 spin_unlock_irq(target->scsi_host->host_lock); 2122 } 2123 spin_unlock(&host->target_lock); 2124 2125 /* 2126 * Wait for any reconnection tasks that may have 2127 * started before we marked our target ports as 2128 * removed, and any target port removal tasks. 2129 */ 2130 flush_scheduled_work(); 2131 2132 list_for_each_entry_safe(target, tmp_target, 2133 &host->target_list, list) { 2134 srp_remove_host(target->scsi_host); 2135 scsi_remove_host(target->scsi_host); 2136 srp_disconnect_target(target); 2137 ib_destroy_cm_id(target->cm_id); 2138 srp_free_target_ib(target); 2139 scsi_host_put(target->scsi_host); 2140 } 2141 2142 kfree(host); 2143 } 2144 2145 if (srp_dev->fmr_pool) 2146 ib_destroy_fmr_pool(srp_dev->fmr_pool); 2147 ib_dereg_mr(srp_dev->mr); 2148 ib_dealloc_pd(srp_dev->pd); 2149 2150 kfree(srp_dev); 2151} 2152 2153static struct srp_function_template ib_srp_transport_functions = { 2154}; 2155 2156static int __init srp_init_module(void) 2157{ 2158 int ret; 2159 2160 if (srp_sg_tablesize > 255) { 2161 printk(KERN_WARNING PFX "Clamping srp_sg_tablesize to 255\n"); 2162 srp_sg_tablesize = 255; 2163 } 2164 2165 ib_srp_transport_template = 2166 srp_attach_transport(&ib_srp_transport_functions); 2167 if (!ib_srp_transport_template) 2168 return -ENOMEM; 2169 2170 srp_template.sg_tablesize = srp_sg_tablesize; 2171 srp_max_iu_len = (sizeof (struct srp_cmd) + 2172 sizeof (struct srp_indirect_buf) + 2173 srp_sg_tablesize * 16); 2174 2175 ret = class_register(&srp_class); 2176 if (ret) { 2177 printk(KERN_ERR PFX "couldn't register class infiniband_srp\n"); 2178 srp_release_transport(ib_srp_transport_template); 2179 return ret; 2180 } 2181 2182 ib_sa_register_client(&srp_sa_client); 2183 2184 ret = ib_register_client(&srp_client); 2185 if (ret) { 2186 printk(KERN_ERR PFX "couldn't register IB client\n"); 2187 srp_release_transport(ib_srp_transport_template); 2188 ib_sa_unregister_client(&srp_sa_client); 2189 class_unregister(&srp_class); 2190 return ret; 2191 } 2192 2193 return 0; 2194} 2195 2196static void __exit srp_cleanup_module(void) 2197{ 2198 ib_unregister_client(&srp_client); 2199 ib_sa_unregister_client(&srp_sa_client); 2200 class_unregister(&srp_class); 2201 srp_release_transport(ib_srp_transport_template); 2202} 2203 2204module_init(srp_init_module); 2205module_exit(srp_cleanup_module); 2206