1 /******************************************************************************* 2 * IBM Virtual SCSI Target Driver 3 * Copyright (C) 2003-2005 Dave Boutcher (boutcher@us.ibm.com) IBM Corp. 4 * Santiago Leon (santil@us.ibm.com) IBM Corp. 5 * Linda Xie (lxie@us.ibm.com) IBM Corp. 6 * 7 * Copyright (C) 2005-2011 FUJITA Tomonori <tomof@acm.org> 8 * Copyright (C) 2010 Nicholas A. Bellinger <nab@kernel.org> 9 * 10 * Authors: Bryant G. Ly <bryantly@linux.vnet.ibm.com> 11 * Authors: Michael Cyr <mikecyr@linux.vnet.ibm.com> 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License as published by 15 * the Free Software Foundation; either version 2 of the License, or 16 * (at your option) any later version. 17 * 18 * This program is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 * GNU General Public License for more details. 22 * 23 ****************************************************************************/ 24 25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 26 27 #include <linux/module.h> 28 #include <linux/kernel.h> 29 #include <linux/slab.h> 30 #include <linux/types.h> 31 #include <linux/list.h> 32 #include <linux/string.h> 33 #include <linux/delay.h> 34 35 #include <target/target_core_base.h> 36 #include <target/target_core_fabric.h> 37 38 #include <asm/hvcall.h> 39 #include <asm/vio.h> 40 41 #include <scsi/viosrp.h> 42 43 #include "ibmvscsi_tgt.h" 44 45 #define IBMVSCSIS_VERSION "v0.2" 46 47 #define INITIAL_SRP_LIMIT 800 48 #define DEFAULT_MAX_SECTORS 256 49 #define MAX_TXU 1024 * 1024 50 51 static uint max_vdma_size = MAX_H_COPY_RDMA; 52 53 static char system_id[SYS_ID_NAME_LEN] = ""; 54 static char partition_name[PARTITION_NAMELEN] = "UNKNOWN"; 55 static uint partition_number = -1; 56 57 /* Adapter list and lock to control it */ 58 static DEFINE_SPINLOCK(ibmvscsis_dev_lock); 59 static LIST_HEAD(ibmvscsis_dev_list); 60 61 static long ibmvscsis_parse_command(struct scsi_info *vscsi, 62 struct viosrp_crq *crq); 63 64 static void ibmvscsis_adapter_idle(struct scsi_info *vscsi); 65 66 static void ibmvscsis_determine_resid(struct se_cmd *se_cmd, 67 struct srp_rsp *rsp) 68 { 69 u32 residual_count = se_cmd->residual_count; 70 71 if (!residual_count) 72 return; 73 74 if (se_cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) { 75 if (se_cmd->data_direction == DMA_TO_DEVICE) { 76 /* residual data from an underflow write */ 77 rsp->flags = SRP_RSP_FLAG_DOUNDER; 78 rsp->data_out_res_cnt = cpu_to_be32(residual_count); 79 } else if (se_cmd->data_direction == DMA_FROM_DEVICE) { 80 /* residual data from an underflow read */ 81 rsp->flags = SRP_RSP_FLAG_DIUNDER; 82 rsp->data_in_res_cnt = cpu_to_be32(residual_count); 83 } 84 } else if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT) { 85 if (se_cmd->data_direction == DMA_TO_DEVICE) { 86 /* residual data from an overflow write */ 87 rsp->flags = SRP_RSP_FLAG_DOOVER; 88 rsp->data_out_res_cnt = cpu_to_be32(residual_count); 89 } else if (se_cmd->data_direction == DMA_FROM_DEVICE) { 90 /* residual data from an overflow read */ 91 rsp->flags = SRP_RSP_FLAG_DIOVER; 92 rsp->data_in_res_cnt = cpu_to_be32(residual_count); 93 } 94 } 95 } 96 97 /** 98 * connection_broken() - Determine if the connection to the client is good 99 * @vscsi: Pointer to our adapter structure 100 * 101 * This function attempts to send a ping MAD to the client. If the call to 102 * queue the request returns H_CLOSED then the connection has been broken 103 * and the function returns TRUE. 104 * 105 * EXECUTION ENVIRONMENT: 106 * Interrupt or Process environment 107 */ 108 static bool connection_broken(struct scsi_info *vscsi) 109 { 110 struct viosrp_crq *crq; 111 u64 buffer[2] = { 0, 0 }; 112 long h_return_code; 113 bool rc = false; 114 115 /* create a PING crq */ 116 crq = (struct viosrp_crq *)&buffer; 117 crq->valid = VALID_CMD_RESP_EL; 118 crq->format = MESSAGE_IN_CRQ; 119 crq->status = PING; 120 121 h_return_code = h_send_crq(vscsi->dds.unit_id, 122 cpu_to_be64(buffer[MSG_HI]), 123 cpu_to_be64(buffer[MSG_LOW])); 124 125 pr_debug("connection_broken: rc %ld\n", h_return_code); 126 127 if (h_return_code == H_CLOSED) 128 rc = true; 129 130 return rc; 131 } 132 133 /** 134 * ibmvscsis_unregister_command_q() - Helper Function-Unregister Command Queue 135 * @vscsi: Pointer to our adapter structure 136 * 137 * This function calls h_free_q then frees the interrupt bit etc. 138 * It must release the lock before doing so because of the time it can take 139 * for h_free_crq in PHYP 140 * NOTE: the caller must make sure that state and or flags will prevent 141 * interrupt handler from scheduling work. 142 * NOTE: anyone calling this function may need to set the CRQ_CLOSED flag 143 * we can't do it here, because we don't have the lock 144 * 145 * EXECUTION ENVIRONMENT: 146 * Process level 147 */ 148 static long ibmvscsis_unregister_command_q(struct scsi_info *vscsi) 149 { 150 long qrc; 151 long rc = ADAPT_SUCCESS; 152 int ticks = 0; 153 154 do { 155 qrc = h_free_crq(vscsi->dds.unit_id); 156 switch (qrc) { 157 case H_SUCCESS: 158 break; 159 160 case H_HARDWARE: 161 case H_PARAMETER: 162 dev_err(&vscsi->dev, "unregister_command_q: error from h_free_crq %ld\n", 163 qrc); 164 rc = ERROR; 165 break; 166 167 case H_BUSY: 168 case H_LONG_BUSY_ORDER_1_MSEC: 169 /* msleep not good for small values */ 170 usleep_range(1000, 2000); 171 ticks += 1; 172 break; 173 case H_LONG_BUSY_ORDER_10_MSEC: 174 usleep_range(10000, 20000); 175 ticks += 10; 176 break; 177 case H_LONG_BUSY_ORDER_100_MSEC: 178 msleep(100); 179 ticks += 100; 180 break; 181 case H_LONG_BUSY_ORDER_1_SEC: 182 ssleep(1); 183 ticks += 1000; 184 break; 185 case H_LONG_BUSY_ORDER_10_SEC: 186 ssleep(10); 187 ticks += 10000; 188 break; 189 case H_LONG_BUSY_ORDER_100_SEC: 190 ssleep(100); 191 ticks += 100000; 192 break; 193 default: 194 dev_err(&vscsi->dev, "unregister_command_q: unknown error %ld from h_free_crq\n", 195 qrc); 196 rc = ERROR; 197 break; 198 } 199 200 /* 201 * dont wait more then 300 seconds 202 * ticks are in milliseconds more or less 203 */ 204 if (ticks > 300000 && qrc != H_SUCCESS) { 205 rc = ERROR; 206 dev_err(&vscsi->dev, "Excessive wait for h_free_crq\n"); 207 } 208 } while (qrc != H_SUCCESS && rc == ADAPT_SUCCESS); 209 210 pr_debug("Freeing CRQ: phyp rc %ld, rc %ld\n", qrc, rc); 211 212 return rc; 213 } 214 215 /** 216 * ibmvscsis_delete_client_info() - Helper function to Delete Client Info 217 * @vscsi: Pointer to our adapter structure 218 * @client_closed: True if client closed its queue 219 * 220 * Deletes information specific to the client when the client goes away 221 * 222 * EXECUTION ENVIRONMENT: 223 * Interrupt or Process 224 */ 225 static void ibmvscsis_delete_client_info(struct scsi_info *vscsi, 226 bool client_closed) 227 { 228 vscsi->client_cap = 0; 229 230 /* 231 * Some things we don't want to clear if we're closing the queue, 232 * because some clients don't resend the host handshake when they 233 * get a transport event. 234 */ 235 if (client_closed) 236 vscsi->client_data.os_type = 0; 237 } 238 239 /** 240 * ibmvscsis_free_command_q() - Free Command Queue 241 * @vscsi: Pointer to our adapter structure 242 * 243 * This function calls unregister_command_q, then clears interrupts and 244 * any pending interrupt acknowledgments associated with the command q. 245 * It also clears memory if there is no error. 246 * 247 * PHYP did not meet the PAPR architecture so that we must give up the 248 * lock. This causes a timing hole regarding state change. To close the 249 * hole this routine does accounting on any change that occurred during 250 * the time the lock is not held. 251 * NOTE: must give up and then acquire the interrupt lock, the caller must 252 * make sure that state and or flags will prevent interrupt handler from 253 * scheduling work. 254 * 255 * EXECUTION ENVIRONMENT: 256 * Process level, interrupt lock is held 257 */ 258 static long ibmvscsis_free_command_q(struct scsi_info *vscsi) 259 { 260 int bytes; 261 u32 flags_under_lock; 262 u16 state_under_lock; 263 long rc = ADAPT_SUCCESS; 264 265 if (!(vscsi->flags & CRQ_CLOSED)) { 266 vio_disable_interrupts(vscsi->dma_dev); 267 268 state_under_lock = vscsi->new_state; 269 flags_under_lock = vscsi->flags; 270 vscsi->phyp_acr_state = 0; 271 vscsi->phyp_acr_flags = 0; 272 273 spin_unlock_bh(&vscsi->intr_lock); 274 rc = ibmvscsis_unregister_command_q(vscsi); 275 spin_lock_bh(&vscsi->intr_lock); 276 277 if (state_under_lock != vscsi->new_state) 278 vscsi->phyp_acr_state = vscsi->new_state; 279 280 vscsi->phyp_acr_flags = ((~flags_under_lock) & vscsi->flags); 281 282 if (rc == ADAPT_SUCCESS) { 283 bytes = vscsi->cmd_q.size * PAGE_SIZE; 284 memset(vscsi->cmd_q.base_addr, 0, bytes); 285 vscsi->cmd_q.index = 0; 286 vscsi->flags |= CRQ_CLOSED; 287 288 ibmvscsis_delete_client_info(vscsi, false); 289 } 290 291 pr_debug("free_command_q: flags 0x%x, state 0x%hx, acr_flags 0x%x, acr_state 0x%hx\n", 292 vscsi->flags, vscsi->state, vscsi->phyp_acr_flags, 293 vscsi->phyp_acr_state); 294 } 295 return rc; 296 } 297 298 /** 299 * ibmvscsis_cmd_q_dequeue() - Get valid Command element 300 * @mask: Mask to use in case index wraps 301 * @current_index: Current index into command queue 302 * @base_addr: Pointer to start of command queue 303 * 304 * Returns a pointer to a valid command element or NULL, if the command 305 * queue is empty 306 * 307 * EXECUTION ENVIRONMENT: 308 * Interrupt environment, interrupt lock held 309 */ 310 static struct viosrp_crq *ibmvscsis_cmd_q_dequeue(uint mask, 311 uint *current_index, 312 struct viosrp_crq *base_addr) 313 { 314 struct viosrp_crq *ptr; 315 316 ptr = base_addr + *current_index; 317 318 if (ptr->valid) { 319 *current_index = (*current_index + 1) & mask; 320 dma_rmb(); 321 } else { 322 ptr = NULL; 323 } 324 325 return ptr; 326 } 327 328 /** 329 * ibmvscsis_send_init_message() - send initialize message to the client 330 * @vscsi: Pointer to our adapter structure 331 * @format: Which Init Message format to send 332 * 333 * EXECUTION ENVIRONMENT: 334 * Interrupt environment interrupt lock held 335 */ 336 static long ibmvscsis_send_init_message(struct scsi_info *vscsi, u8 format) 337 { 338 struct viosrp_crq *crq; 339 u64 buffer[2] = { 0, 0 }; 340 long rc; 341 342 crq = (struct viosrp_crq *)&buffer; 343 crq->valid = VALID_INIT_MSG; 344 crq->format = format; 345 rc = h_send_crq(vscsi->dds.unit_id, cpu_to_be64(buffer[MSG_HI]), 346 cpu_to_be64(buffer[MSG_LOW])); 347 348 return rc; 349 } 350 351 /** 352 * ibmvscsis_check_init_msg() - Check init message valid 353 * @vscsi: Pointer to our adapter structure 354 * @format: Pointer to return format of Init Message, if any. 355 * Set to UNUSED_FORMAT if no Init Message in queue. 356 * 357 * Checks if an initialize message was queued by the initiatior 358 * after the queue was created and before the interrupt was enabled. 359 * 360 * EXECUTION ENVIRONMENT: 361 * Process level only, interrupt lock held 362 */ 363 static long ibmvscsis_check_init_msg(struct scsi_info *vscsi, uint *format) 364 { 365 struct viosrp_crq *crq; 366 long rc = ADAPT_SUCCESS; 367 368 crq = ibmvscsis_cmd_q_dequeue(vscsi->cmd_q.mask, &vscsi->cmd_q.index, 369 vscsi->cmd_q.base_addr); 370 if (!crq) { 371 *format = (uint)UNUSED_FORMAT; 372 } else if (crq->valid == VALID_INIT_MSG && crq->format == INIT_MSG) { 373 *format = (uint)INIT_MSG; 374 crq->valid = INVALIDATE_CMD_RESP_EL; 375 dma_rmb(); 376 377 /* 378 * the caller has ensured no initialize message was 379 * sent after the queue was 380 * created so there should be no other message on the queue. 381 */ 382 crq = ibmvscsis_cmd_q_dequeue(vscsi->cmd_q.mask, 383 &vscsi->cmd_q.index, 384 vscsi->cmd_q.base_addr); 385 if (crq) { 386 *format = (uint)(crq->format); 387 rc = ERROR; 388 crq->valid = INVALIDATE_CMD_RESP_EL; 389 dma_rmb(); 390 } 391 } else { 392 *format = (uint)(crq->format); 393 rc = ERROR; 394 crq->valid = INVALIDATE_CMD_RESP_EL; 395 dma_rmb(); 396 } 397 398 return rc; 399 } 400 401 /** 402 * ibmvscsis_disconnect() - Helper function to disconnect 403 * @work: Pointer to work_struct, gives access to our adapter structure 404 * 405 * An error has occurred or the driver received a Transport event, 406 * and the driver is requesting that the command queue be de-registered 407 * in a safe manner. If there is no outstanding I/O then we can stop the 408 * queue. If we are restarting the queue it will be reflected in the 409 * the state of the adapter. 410 * 411 * EXECUTION ENVIRONMENT: 412 * Process environment 413 */ 414 static void ibmvscsis_disconnect(struct work_struct *work) 415 { 416 struct scsi_info *vscsi = container_of(work, struct scsi_info, 417 proc_work); 418 u16 new_state; 419 bool wait_idle = false; 420 421 spin_lock_bh(&vscsi->intr_lock); 422 new_state = vscsi->new_state; 423 vscsi->new_state = 0; 424 425 pr_debug("disconnect: flags 0x%x, state 0x%hx\n", vscsi->flags, 426 vscsi->state); 427 428 /* 429 * check which state we are in and see if we 430 * should transitition to the new state 431 */ 432 switch (vscsi->state) { 433 /* Should never be called while in this state. */ 434 case NO_QUEUE: 435 /* 436 * Can never transition from this state; 437 * igonore errors and logout. 438 */ 439 case UNCONFIGURING: 440 break; 441 442 /* can transition from this state to UNCONFIGURING */ 443 case ERR_DISCONNECT: 444 if (new_state == UNCONFIGURING) 445 vscsi->state = new_state; 446 break; 447 448 /* 449 * Can transition from this state to to unconfiguring 450 * or err disconnect. 451 */ 452 case ERR_DISCONNECT_RECONNECT: 453 switch (new_state) { 454 case UNCONFIGURING: 455 case ERR_DISCONNECT: 456 vscsi->state = new_state; 457 break; 458 459 case WAIT_IDLE: 460 break; 461 default: 462 break; 463 } 464 break; 465 466 /* can transition from this state to UNCONFIGURING */ 467 case ERR_DISCONNECTED: 468 if (new_state == UNCONFIGURING) 469 vscsi->state = new_state; 470 break; 471 472 case WAIT_ENABLED: 473 switch (new_state) { 474 case UNCONFIGURING: 475 vscsi->state = new_state; 476 vscsi->flags |= RESPONSE_Q_DOWN; 477 vscsi->flags &= ~(SCHEDULE_DISCONNECT | 478 DISCONNECT_SCHEDULED); 479 dma_rmb(); 480 if (vscsi->flags & CFG_SLEEPING) { 481 vscsi->flags &= ~CFG_SLEEPING; 482 complete(&vscsi->unconfig); 483 } 484 break; 485 486 /* should never happen */ 487 case ERR_DISCONNECT: 488 case ERR_DISCONNECT_RECONNECT: 489 case WAIT_IDLE: 490 dev_err(&vscsi->dev, "disconnect: invalid state %d for WAIT_IDLE\n", 491 vscsi->state); 492 break; 493 } 494 break; 495 496 case WAIT_IDLE: 497 switch (new_state) { 498 case UNCONFIGURING: 499 vscsi->flags |= RESPONSE_Q_DOWN; 500 vscsi->state = new_state; 501 vscsi->flags &= ~(SCHEDULE_DISCONNECT | 502 DISCONNECT_SCHEDULED); 503 ibmvscsis_free_command_q(vscsi); 504 break; 505 case ERR_DISCONNECT: 506 case ERR_DISCONNECT_RECONNECT: 507 vscsi->state = new_state; 508 break; 509 } 510 break; 511 512 /* 513 * Initiator has not done a successful srp login 514 * or has done a successful srp logout ( adapter was not 515 * busy). In the first case there can be responses queued 516 * waiting for space on the initiators response queue (MAD) 517 * The second case the adapter is idle. Assume the worse case, 518 * i.e. the second case. 519 */ 520 case WAIT_CONNECTION: 521 case CONNECTED: 522 case SRP_PROCESSING: 523 wait_idle = true; 524 vscsi->state = new_state; 525 break; 526 527 /* can transition from this state to UNCONFIGURING */ 528 case UNDEFINED: 529 if (new_state == UNCONFIGURING) 530 vscsi->state = new_state; 531 break; 532 default: 533 break; 534 } 535 536 if (wait_idle) { 537 pr_debug("disconnect start wait, active %d, sched %d\n", 538 (int)list_empty(&vscsi->active_q), 539 (int)list_empty(&vscsi->schedule_q)); 540 if (!list_empty(&vscsi->active_q) || 541 !list_empty(&vscsi->schedule_q)) { 542 vscsi->flags |= WAIT_FOR_IDLE; 543 pr_debug("disconnect flags 0x%x\n", vscsi->flags); 544 /* 545 * This routine is can not be called with the interrupt 546 * lock held. 547 */ 548 spin_unlock_bh(&vscsi->intr_lock); 549 wait_for_completion(&vscsi->wait_idle); 550 spin_lock_bh(&vscsi->intr_lock); 551 } 552 pr_debug("disconnect stop wait\n"); 553 554 ibmvscsis_adapter_idle(vscsi); 555 } 556 557 spin_unlock_bh(&vscsi->intr_lock); 558 } 559 560 /** 561 * ibmvscsis_post_disconnect() - Schedule the disconnect 562 * @vscsi: Pointer to our adapter structure 563 * @new_state: State to move to after disconnecting 564 * @flag_bits: Flags to turn on in adapter structure 565 * 566 * If it's already been scheduled, then see if we need to "upgrade" 567 * the new state (if the one passed in is more "severe" than the 568 * previous one). 569 * 570 * PRECONDITION: 571 * interrupt lock is held 572 */ 573 static void ibmvscsis_post_disconnect(struct scsi_info *vscsi, uint new_state, 574 uint flag_bits) 575 { 576 uint state; 577 578 /* check the validity of the new state */ 579 switch (new_state) { 580 case UNCONFIGURING: 581 case ERR_DISCONNECT: 582 case ERR_DISCONNECT_RECONNECT: 583 case WAIT_IDLE: 584 break; 585 586 default: 587 dev_err(&vscsi->dev, "post_disconnect: Invalid new state %d\n", 588 new_state); 589 return; 590 } 591 592 vscsi->flags |= flag_bits; 593 594 pr_debug("post_disconnect: new_state 0x%x, flag_bits 0x%x, vscsi->flags 0x%x, state %hx\n", 595 new_state, flag_bits, vscsi->flags, vscsi->state); 596 597 if (!(vscsi->flags & (DISCONNECT_SCHEDULED | SCHEDULE_DISCONNECT))) { 598 vscsi->flags |= SCHEDULE_DISCONNECT; 599 vscsi->new_state = new_state; 600 601 INIT_WORK(&vscsi->proc_work, ibmvscsis_disconnect); 602 (void)queue_work(vscsi->work_q, &vscsi->proc_work); 603 } else { 604 if (vscsi->new_state) 605 state = vscsi->new_state; 606 else 607 state = vscsi->state; 608 609 switch (state) { 610 case NO_QUEUE: 611 case UNCONFIGURING: 612 break; 613 614 case ERR_DISCONNECTED: 615 case ERR_DISCONNECT: 616 case UNDEFINED: 617 if (new_state == UNCONFIGURING) 618 vscsi->new_state = new_state; 619 break; 620 621 case ERR_DISCONNECT_RECONNECT: 622 switch (new_state) { 623 case UNCONFIGURING: 624 case ERR_DISCONNECT: 625 vscsi->new_state = new_state; 626 break; 627 default: 628 break; 629 } 630 break; 631 632 case WAIT_ENABLED: 633 case WAIT_IDLE: 634 case WAIT_CONNECTION: 635 case CONNECTED: 636 case SRP_PROCESSING: 637 vscsi->new_state = new_state; 638 break; 639 640 default: 641 break; 642 } 643 } 644 645 pr_debug("Leaving post_disconnect: flags 0x%x, new_state 0x%x\n", 646 vscsi->flags, vscsi->new_state); 647 } 648 649 /** 650 * ibmvscsis_handle_init_compl_msg() - Respond to an Init Complete Message 651 * @vscsi: Pointer to our adapter structure 652 * 653 * Must be called with interrupt lock held. 654 */ 655 static long ibmvscsis_handle_init_compl_msg(struct scsi_info *vscsi) 656 { 657 long rc = ADAPT_SUCCESS; 658 659 switch (vscsi->state) { 660 case NO_QUEUE: 661 case ERR_DISCONNECT: 662 case ERR_DISCONNECT_RECONNECT: 663 case ERR_DISCONNECTED: 664 case UNCONFIGURING: 665 case UNDEFINED: 666 rc = ERROR; 667 break; 668 669 case WAIT_CONNECTION: 670 vscsi->state = CONNECTED; 671 break; 672 673 case WAIT_IDLE: 674 case SRP_PROCESSING: 675 case CONNECTED: 676 case WAIT_ENABLED: 677 default: 678 rc = ERROR; 679 dev_err(&vscsi->dev, "init_msg: invalid state %d to get init compl msg\n", 680 vscsi->state); 681 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 682 break; 683 } 684 685 return rc; 686 } 687 688 /** 689 * ibmvscsis_handle_init_msg() - Respond to an Init Message 690 * @vscsi: Pointer to our adapter structure 691 * 692 * Must be called with interrupt lock held. 693 */ 694 static long ibmvscsis_handle_init_msg(struct scsi_info *vscsi) 695 { 696 long rc = ADAPT_SUCCESS; 697 698 switch (vscsi->state) { 699 case WAIT_CONNECTION: 700 rc = ibmvscsis_send_init_message(vscsi, INIT_COMPLETE_MSG); 701 switch (rc) { 702 case H_SUCCESS: 703 vscsi->state = CONNECTED; 704 break; 705 706 case H_PARAMETER: 707 dev_err(&vscsi->dev, "init_msg: failed to send, rc %ld\n", 708 rc); 709 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0); 710 break; 711 712 case H_DROPPED: 713 dev_err(&vscsi->dev, "init_msg: failed to send, rc %ld\n", 714 rc); 715 rc = ERROR; 716 ibmvscsis_post_disconnect(vscsi, 717 ERR_DISCONNECT_RECONNECT, 0); 718 break; 719 720 case H_CLOSED: 721 pr_warn("init_msg: failed to send, rc %ld\n", rc); 722 rc = 0; 723 break; 724 } 725 break; 726 727 case UNDEFINED: 728 rc = ERROR; 729 break; 730 731 case UNCONFIGURING: 732 break; 733 734 case WAIT_ENABLED: 735 case CONNECTED: 736 case SRP_PROCESSING: 737 case WAIT_IDLE: 738 case NO_QUEUE: 739 case ERR_DISCONNECT: 740 case ERR_DISCONNECT_RECONNECT: 741 case ERR_DISCONNECTED: 742 default: 743 rc = ERROR; 744 dev_err(&vscsi->dev, "init_msg: invalid state %d to get init msg\n", 745 vscsi->state); 746 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 747 break; 748 } 749 750 return rc; 751 } 752 753 /** 754 * ibmvscsis_init_msg() - Respond to an init message 755 * @vscsi: Pointer to our adapter structure 756 * @crq: Pointer to CRQ element containing the Init Message 757 * 758 * EXECUTION ENVIRONMENT: 759 * Interrupt, interrupt lock held 760 */ 761 static long ibmvscsis_init_msg(struct scsi_info *vscsi, struct viosrp_crq *crq) 762 { 763 long rc = ADAPT_SUCCESS; 764 765 pr_debug("init_msg: state 0x%hx\n", vscsi->state); 766 767 rc = h_vioctl(vscsi->dds.unit_id, H_GET_PARTNER_INFO, 768 (u64)vscsi->map_ioba | ((u64)PAGE_SIZE << 32), 0, 0, 0, 769 0); 770 if (rc == H_SUCCESS) { 771 vscsi->client_data.partition_number = 772 be64_to_cpu(*(u64 *)vscsi->map_buf); 773 pr_debug("init_msg, part num %d\n", 774 vscsi->client_data.partition_number); 775 } else { 776 pr_debug("init_msg h_vioctl rc %ld\n", rc); 777 rc = ADAPT_SUCCESS; 778 } 779 780 if (crq->format == INIT_MSG) { 781 rc = ibmvscsis_handle_init_msg(vscsi); 782 } else if (crq->format == INIT_COMPLETE_MSG) { 783 rc = ibmvscsis_handle_init_compl_msg(vscsi); 784 } else { 785 rc = ERROR; 786 dev_err(&vscsi->dev, "init_msg: invalid format %d\n", 787 (uint)crq->format); 788 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 789 } 790 791 return rc; 792 } 793 794 /** 795 * ibmvscsis_establish_new_q() - Establish new CRQ queue 796 * @vscsi: Pointer to our adapter structure 797 * 798 * Must be called with interrupt lock held. 799 */ 800 static long ibmvscsis_establish_new_q(struct scsi_info *vscsi) 801 { 802 long rc = ADAPT_SUCCESS; 803 uint format; 804 805 vscsi->flags &= PRESERVE_FLAG_FIELDS; 806 vscsi->rsp_q_timer.timer_pops = 0; 807 vscsi->debit = 0; 808 vscsi->credit = 0; 809 810 rc = vio_enable_interrupts(vscsi->dma_dev); 811 if (rc) { 812 pr_warn("establish_new_q: failed to enable interrupts, rc %ld\n", 813 rc); 814 return rc; 815 } 816 817 rc = ibmvscsis_check_init_msg(vscsi, &format); 818 if (rc) { 819 dev_err(&vscsi->dev, "establish_new_q: check_init_msg failed, rc %ld\n", 820 rc); 821 return rc; 822 } 823 824 if (format == UNUSED_FORMAT) { 825 rc = ibmvscsis_send_init_message(vscsi, INIT_MSG); 826 switch (rc) { 827 case H_SUCCESS: 828 case H_DROPPED: 829 case H_CLOSED: 830 rc = ADAPT_SUCCESS; 831 break; 832 833 case H_PARAMETER: 834 case H_HARDWARE: 835 break; 836 837 default: 838 vscsi->state = UNDEFINED; 839 rc = H_HARDWARE; 840 break; 841 } 842 } else if (format == INIT_MSG) { 843 rc = ibmvscsis_handle_init_msg(vscsi); 844 } 845 846 return rc; 847 } 848 849 /** 850 * ibmvscsis_reset_queue() - Reset CRQ Queue 851 * @vscsi: Pointer to our adapter structure 852 * 853 * This function calls h_free_q and then calls h_reg_q and does all 854 * of the bookkeeping to get us back to where we can communicate. 855 * 856 * Actually, we don't always call h_free_crq. A problem was discovered 857 * where one partition would close and reopen his queue, which would 858 * cause his partner to get a transport event, which would cause him to 859 * close and reopen his queue, which would cause the original partition 860 * to get a transport event, etc., etc. To prevent this, we don't 861 * actually close our queue if the client initiated the reset, (i.e. 862 * either we got a transport event or we have detected that the client's 863 * queue is gone) 864 * 865 * EXECUTION ENVIRONMENT: 866 * Process environment, called with interrupt lock held 867 */ 868 static void ibmvscsis_reset_queue(struct scsi_info *vscsi) 869 { 870 int bytes; 871 long rc = ADAPT_SUCCESS; 872 873 pr_debug("reset_queue: flags 0x%x\n", vscsi->flags); 874 875 /* don't reset, the client did it for us */ 876 if (vscsi->flags & (CLIENT_FAILED | TRANS_EVENT)) { 877 vscsi->flags &= PRESERVE_FLAG_FIELDS; 878 vscsi->rsp_q_timer.timer_pops = 0; 879 vscsi->debit = 0; 880 vscsi->credit = 0; 881 vscsi->state = WAIT_CONNECTION; 882 vio_enable_interrupts(vscsi->dma_dev); 883 } else { 884 rc = ibmvscsis_free_command_q(vscsi); 885 if (rc == ADAPT_SUCCESS) { 886 vscsi->state = WAIT_CONNECTION; 887 888 bytes = vscsi->cmd_q.size * PAGE_SIZE; 889 rc = h_reg_crq(vscsi->dds.unit_id, 890 vscsi->cmd_q.crq_token, bytes); 891 if (rc == H_CLOSED || rc == H_SUCCESS) { 892 rc = ibmvscsis_establish_new_q(vscsi); 893 } 894 895 if (rc != ADAPT_SUCCESS) { 896 pr_debug("reset_queue: reg_crq rc %ld\n", rc); 897 898 vscsi->state = ERR_DISCONNECTED; 899 vscsi->flags |= RESPONSE_Q_DOWN; 900 ibmvscsis_free_command_q(vscsi); 901 } 902 } else { 903 vscsi->state = ERR_DISCONNECTED; 904 vscsi->flags |= RESPONSE_Q_DOWN; 905 } 906 } 907 } 908 909 /** 910 * ibmvscsis_free_cmd_resources() - Free command resources 911 * @vscsi: Pointer to our adapter structure 912 * @cmd: Command which is not longer in use 913 * 914 * Must be called with interrupt lock held. 915 */ 916 static void ibmvscsis_free_cmd_resources(struct scsi_info *vscsi, 917 struct ibmvscsis_cmd *cmd) 918 { 919 struct iu_entry *iue = cmd->iue; 920 921 switch (cmd->type) { 922 case TASK_MANAGEMENT: 923 case SCSI_CDB: 924 /* 925 * When the queue goes down this value is cleared, so it 926 * cannot be cleared in this general purpose function. 927 */ 928 if (vscsi->debit) 929 vscsi->debit -= 1; 930 break; 931 case ADAPTER_MAD: 932 vscsi->flags &= ~PROCESSING_MAD; 933 break; 934 case UNSET_TYPE: 935 break; 936 default: 937 dev_err(&vscsi->dev, "free_cmd_resources unknown type %d\n", 938 cmd->type); 939 break; 940 } 941 942 cmd->iue = NULL; 943 list_add_tail(&cmd->list, &vscsi->free_cmd); 944 srp_iu_put(iue); 945 946 if (list_empty(&vscsi->active_q) && list_empty(&vscsi->schedule_q) && 947 list_empty(&vscsi->waiting_rsp) && (vscsi->flags & WAIT_FOR_IDLE)) { 948 vscsi->flags &= ~WAIT_FOR_IDLE; 949 complete(&vscsi->wait_idle); 950 } 951 } 952 953 /** 954 * ibmvscsis_trans_event() - Handle a Transport Event 955 * @vscsi: Pointer to our adapter structure 956 * @crq: Pointer to CRQ entry containing the Transport Event 957 * 958 * Do the logic to close the I_T nexus. This function may not 959 * behave to specification. 960 * 961 * EXECUTION ENVIRONMENT: 962 * Interrupt, interrupt lock held 963 */ 964 static long ibmvscsis_trans_event(struct scsi_info *vscsi, 965 struct viosrp_crq *crq) 966 { 967 long rc = ADAPT_SUCCESS; 968 969 pr_debug("trans_event: format %d, flags 0x%x, state 0x%hx\n", 970 (int)crq->format, vscsi->flags, vscsi->state); 971 972 switch (crq->format) { 973 case MIGRATED: 974 case PARTNER_FAILED: 975 case PARTNER_DEREGISTER: 976 ibmvscsis_delete_client_info(vscsi, true); 977 break; 978 979 default: 980 rc = ERROR; 981 dev_err(&vscsi->dev, "trans_event: invalid format %d\n", 982 (uint)crq->format); 983 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 984 RESPONSE_Q_DOWN); 985 break; 986 } 987 988 if (rc == ADAPT_SUCCESS) { 989 switch (vscsi->state) { 990 case NO_QUEUE: 991 case ERR_DISCONNECTED: 992 case UNDEFINED: 993 break; 994 995 case UNCONFIGURING: 996 vscsi->flags |= (RESPONSE_Q_DOWN | TRANS_EVENT); 997 break; 998 999 case WAIT_ENABLED: 1000 break; 1001 1002 case WAIT_CONNECTION: 1003 break; 1004 1005 case CONNECTED: 1006 ibmvscsis_post_disconnect(vscsi, WAIT_IDLE, 1007 (RESPONSE_Q_DOWN | 1008 TRANS_EVENT)); 1009 break; 1010 1011 case SRP_PROCESSING: 1012 if ((vscsi->debit > 0) || 1013 !list_empty(&vscsi->schedule_q) || 1014 !list_empty(&vscsi->waiting_rsp) || 1015 !list_empty(&vscsi->active_q)) { 1016 pr_debug("debit %d, sched %d, wait %d, active %d\n", 1017 vscsi->debit, 1018 (int)list_empty(&vscsi->schedule_q), 1019 (int)list_empty(&vscsi->waiting_rsp), 1020 (int)list_empty(&vscsi->active_q)); 1021 pr_warn("connection lost with outstanding work\n"); 1022 } else { 1023 pr_debug("trans_event: SRP Processing, but no outstanding work\n"); 1024 } 1025 1026 ibmvscsis_post_disconnect(vscsi, WAIT_IDLE, 1027 (RESPONSE_Q_DOWN | 1028 TRANS_EVENT)); 1029 break; 1030 1031 case ERR_DISCONNECT: 1032 case ERR_DISCONNECT_RECONNECT: 1033 case WAIT_IDLE: 1034 vscsi->flags |= (RESPONSE_Q_DOWN | TRANS_EVENT); 1035 break; 1036 } 1037 } 1038 1039 rc = vscsi->flags & SCHEDULE_DISCONNECT; 1040 1041 pr_debug("Leaving trans_event: flags 0x%x, state 0x%hx, rc %ld\n", 1042 vscsi->flags, vscsi->state, rc); 1043 1044 return rc; 1045 } 1046 1047 /** 1048 * ibmvscsis_poll_cmd_q() - Poll Command Queue 1049 * @vscsi: Pointer to our adapter structure 1050 * 1051 * Called to handle command elements that may have arrived while 1052 * interrupts were disabled. 1053 * 1054 * EXECUTION ENVIRONMENT: 1055 * intr_lock must be held 1056 */ 1057 static void ibmvscsis_poll_cmd_q(struct scsi_info *vscsi) 1058 { 1059 struct viosrp_crq *crq; 1060 long rc; 1061 bool ack = true; 1062 volatile u8 valid; 1063 1064 pr_debug("poll_cmd_q: flags 0x%x, state 0x%hx, q index %ud\n", 1065 vscsi->flags, vscsi->state, vscsi->cmd_q.index); 1066 1067 rc = vscsi->flags & SCHEDULE_DISCONNECT; 1068 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index; 1069 valid = crq->valid; 1070 dma_rmb(); 1071 1072 while (valid) { 1073 poll_work: 1074 vscsi->cmd_q.index = 1075 (vscsi->cmd_q.index + 1) & vscsi->cmd_q.mask; 1076 1077 if (!rc) { 1078 rc = ibmvscsis_parse_command(vscsi, crq); 1079 } else { 1080 if ((uint)crq->valid == VALID_TRANS_EVENT) { 1081 /* 1082 * must service the transport layer events even 1083 * in an error state, dont break out until all 1084 * the consecutive transport events have been 1085 * processed 1086 */ 1087 rc = ibmvscsis_trans_event(vscsi, crq); 1088 } else if (vscsi->flags & TRANS_EVENT) { 1089 /* 1090 * if a tranport event has occurred leave 1091 * everything but transport events on the queue 1092 */ 1093 pr_debug("poll_cmd_q, ignoring\n"); 1094 1095 /* 1096 * need to decrement the queue index so we can 1097 * look at the elment again 1098 */ 1099 if (vscsi->cmd_q.index) 1100 vscsi->cmd_q.index -= 1; 1101 else 1102 /* 1103 * index is at 0 it just wrapped. 1104 * have it index last element in q 1105 */ 1106 vscsi->cmd_q.index = vscsi->cmd_q.mask; 1107 break; 1108 } 1109 } 1110 1111 crq->valid = INVALIDATE_CMD_RESP_EL; 1112 1113 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index; 1114 valid = crq->valid; 1115 dma_rmb(); 1116 } 1117 1118 if (!rc) { 1119 if (ack) { 1120 vio_enable_interrupts(vscsi->dma_dev); 1121 ack = false; 1122 pr_debug("poll_cmd_q, reenabling interrupts\n"); 1123 } 1124 valid = crq->valid; 1125 dma_rmb(); 1126 if (valid) 1127 goto poll_work; 1128 } 1129 1130 pr_debug("Leaving poll_cmd_q: rc %ld\n", rc); 1131 } 1132 1133 /** 1134 * ibmvscsis_free_cmd_qs() - Free elements in queue 1135 * @vscsi: Pointer to our adapter structure 1136 * 1137 * Free all of the elements on all queues that are waiting for 1138 * whatever reason. 1139 * 1140 * PRECONDITION: 1141 * Called with interrupt lock held 1142 */ 1143 static void ibmvscsis_free_cmd_qs(struct scsi_info *vscsi) 1144 { 1145 struct ibmvscsis_cmd *cmd, *nxt; 1146 1147 pr_debug("free_cmd_qs: waiting_rsp empty %d, timer starter %d\n", 1148 (int)list_empty(&vscsi->waiting_rsp), 1149 vscsi->rsp_q_timer.started); 1150 1151 list_for_each_entry_safe(cmd, nxt, &vscsi->waiting_rsp, list) { 1152 list_del(&cmd->list); 1153 ibmvscsis_free_cmd_resources(vscsi, cmd); 1154 } 1155 } 1156 1157 /** 1158 * ibmvscsis_get_free_cmd() - Get free command from list 1159 * @vscsi: Pointer to our adapter structure 1160 * 1161 * Must be called with interrupt lock held. 1162 */ 1163 static struct ibmvscsis_cmd *ibmvscsis_get_free_cmd(struct scsi_info *vscsi) 1164 { 1165 struct ibmvscsis_cmd *cmd = NULL; 1166 struct iu_entry *iue; 1167 1168 iue = srp_iu_get(&vscsi->target); 1169 if (iue) { 1170 cmd = list_first_entry_or_null(&vscsi->free_cmd, 1171 struct ibmvscsis_cmd, list); 1172 if (cmd) { 1173 if (cmd->abort_cmd) 1174 cmd->abort_cmd = NULL; 1175 cmd->flags &= ~(DELAY_SEND); 1176 list_del(&cmd->list); 1177 cmd->iue = iue; 1178 cmd->type = UNSET_TYPE; 1179 memset(&cmd->se_cmd, 0, sizeof(cmd->se_cmd)); 1180 } else { 1181 srp_iu_put(iue); 1182 } 1183 } 1184 1185 return cmd; 1186 } 1187 1188 /** 1189 * ibmvscsis_adapter_idle() - Helper function to handle idle adapter 1190 * @vscsi: Pointer to our adapter structure 1191 * 1192 * This function is called when the adapter is idle when the driver 1193 * is attempting to clear an error condition. 1194 * The adapter is considered busy if any of its cmd queues 1195 * are non-empty. This function can be invoked 1196 * from the off level disconnect function. 1197 * 1198 * EXECUTION ENVIRONMENT: 1199 * Process environment called with interrupt lock held 1200 */ 1201 static void ibmvscsis_adapter_idle(struct scsi_info *vscsi) 1202 { 1203 int free_qs = false; 1204 1205 pr_debug("adapter_idle: flags 0x%x, state 0x%hx\n", vscsi->flags, 1206 vscsi->state); 1207 1208 /* Only need to free qs if we're disconnecting from client */ 1209 if (vscsi->state != WAIT_CONNECTION || vscsi->flags & TRANS_EVENT) 1210 free_qs = true; 1211 1212 switch (vscsi->state) { 1213 case UNCONFIGURING: 1214 ibmvscsis_free_command_q(vscsi); 1215 dma_rmb(); 1216 isync(); 1217 if (vscsi->flags & CFG_SLEEPING) { 1218 vscsi->flags &= ~CFG_SLEEPING; 1219 complete(&vscsi->unconfig); 1220 } 1221 break; 1222 case ERR_DISCONNECT_RECONNECT: 1223 ibmvscsis_reset_queue(vscsi); 1224 pr_debug("adapter_idle, disc_rec: flags 0x%x\n", vscsi->flags); 1225 break; 1226 1227 case ERR_DISCONNECT: 1228 ibmvscsis_free_command_q(vscsi); 1229 vscsi->flags &= ~(SCHEDULE_DISCONNECT | DISCONNECT_SCHEDULED); 1230 vscsi->flags |= RESPONSE_Q_DOWN; 1231 if (vscsi->tport.enabled) 1232 vscsi->state = ERR_DISCONNECTED; 1233 else 1234 vscsi->state = WAIT_ENABLED; 1235 pr_debug("adapter_idle, disc: flags 0x%x, state 0x%hx\n", 1236 vscsi->flags, vscsi->state); 1237 break; 1238 1239 case WAIT_IDLE: 1240 vscsi->rsp_q_timer.timer_pops = 0; 1241 vscsi->debit = 0; 1242 vscsi->credit = 0; 1243 if (vscsi->flags & TRANS_EVENT) { 1244 vscsi->state = WAIT_CONNECTION; 1245 vscsi->flags &= PRESERVE_FLAG_FIELDS; 1246 } else { 1247 vscsi->state = CONNECTED; 1248 vscsi->flags &= ~DISCONNECT_SCHEDULED; 1249 } 1250 1251 pr_debug("adapter_idle, wait: flags 0x%x, state 0x%hx\n", 1252 vscsi->flags, vscsi->state); 1253 ibmvscsis_poll_cmd_q(vscsi); 1254 break; 1255 1256 case ERR_DISCONNECTED: 1257 vscsi->flags &= ~DISCONNECT_SCHEDULED; 1258 pr_debug("adapter_idle, disconnected: flags 0x%x, state 0x%hx\n", 1259 vscsi->flags, vscsi->state); 1260 break; 1261 1262 default: 1263 dev_err(&vscsi->dev, "adapter_idle: in invalid state %d\n", 1264 vscsi->state); 1265 break; 1266 } 1267 1268 if (free_qs) 1269 ibmvscsis_free_cmd_qs(vscsi); 1270 1271 /* 1272 * There is a timing window where we could lose a disconnect request. 1273 * The known path to this window occurs during the DISCONNECT_RECONNECT 1274 * case above: reset_queue calls free_command_q, which will release the 1275 * interrupt lock. During that time, a new post_disconnect call can be 1276 * made with a "more severe" state (DISCONNECT or UNCONFIGURING). 1277 * Because the DISCONNECT_SCHEDULED flag is already set, post_disconnect 1278 * will only set the new_state. Now free_command_q reacquires the intr 1279 * lock and clears the DISCONNECT_SCHEDULED flag (using PRESERVE_FLAG_ 1280 * FIELDS), and the disconnect is lost. This is particularly bad when 1281 * the new disconnect was for UNCONFIGURING, since the unconfigure hangs 1282 * forever. 1283 * Fix is that free command queue sets acr state and acr flags if there 1284 * is a change under the lock 1285 * note free command queue writes to this state it clears it 1286 * before releasing the lock, different drivers call the free command 1287 * queue different times so dont initialize above 1288 */ 1289 if (vscsi->phyp_acr_state != 0) { 1290 /* 1291 * set any bits in flags that may have been cleared by 1292 * a call to free command queue in switch statement 1293 * or reset queue 1294 */ 1295 vscsi->flags |= vscsi->phyp_acr_flags; 1296 ibmvscsis_post_disconnect(vscsi, vscsi->phyp_acr_state, 0); 1297 vscsi->phyp_acr_state = 0; 1298 vscsi->phyp_acr_flags = 0; 1299 1300 pr_debug("adapter_idle: flags 0x%x, state 0x%hx, acr_flags 0x%x, acr_state 0x%hx\n", 1301 vscsi->flags, vscsi->state, vscsi->phyp_acr_flags, 1302 vscsi->phyp_acr_state); 1303 } 1304 1305 pr_debug("Leaving adapter_idle: flags 0x%x, state 0x%hx, new_state 0x%x\n", 1306 vscsi->flags, vscsi->state, vscsi->new_state); 1307 } 1308 1309 /** 1310 * ibmvscsis_copy_crq_packet() - Copy CRQ Packet 1311 * @vscsi: Pointer to our adapter structure 1312 * @cmd: Pointer to command element to use to process the request 1313 * @crq: Pointer to CRQ entry containing the request 1314 * 1315 * Copy the srp information unit from the hosted 1316 * partition using remote dma 1317 * 1318 * EXECUTION ENVIRONMENT: 1319 * Interrupt, interrupt lock held 1320 */ 1321 static long ibmvscsis_copy_crq_packet(struct scsi_info *vscsi, 1322 struct ibmvscsis_cmd *cmd, 1323 struct viosrp_crq *crq) 1324 { 1325 struct iu_entry *iue = cmd->iue; 1326 long rc = 0; 1327 u16 len; 1328 1329 len = be16_to_cpu(crq->IU_length); 1330 if ((len > SRP_MAX_IU_LEN) || (len == 0)) { 1331 dev_err(&vscsi->dev, "copy_crq: Invalid len %d passed", len); 1332 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 1333 return SRP_VIOLATION; 1334 } 1335 1336 rc = h_copy_rdma(len, vscsi->dds.window[REMOTE].liobn, 1337 be64_to_cpu(crq->IU_data_ptr), 1338 vscsi->dds.window[LOCAL].liobn, iue->sbuf->dma); 1339 1340 switch (rc) { 1341 case H_SUCCESS: 1342 cmd->init_time = mftb(); 1343 iue->remote_token = crq->IU_data_ptr; 1344 iue->iu_len = len; 1345 pr_debug("copy_crq: ioba 0x%llx, init_time 0x%llx\n", 1346 be64_to_cpu(crq->IU_data_ptr), cmd->init_time); 1347 break; 1348 case H_PERMISSION: 1349 if (connection_broken(vscsi)) 1350 ibmvscsis_post_disconnect(vscsi, 1351 ERR_DISCONNECT_RECONNECT, 1352 (RESPONSE_Q_DOWN | 1353 CLIENT_FAILED)); 1354 else 1355 ibmvscsis_post_disconnect(vscsi, 1356 ERR_DISCONNECT_RECONNECT, 0); 1357 1358 dev_err(&vscsi->dev, "copy_crq: h_copy_rdma failed, rc %ld\n", 1359 rc); 1360 break; 1361 case H_DEST_PARM: 1362 case H_SOURCE_PARM: 1363 default: 1364 dev_err(&vscsi->dev, "copy_crq: h_copy_rdma failed, rc %ld\n", 1365 rc); 1366 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 1367 break; 1368 } 1369 1370 return rc; 1371 } 1372 1373 /** 1374 * ibmvscsis_adapter_info - Service an Adapter Info MAnagement Data gram 1375 * @vscsi: Pointer to our adapter structure 1376 * @iue: Information Unit containing the Adapter Info MAD request 1377 * 1378 * EXECUTION ENVIRONMENT: 1379 * Interrupt adapter lock is held 1380 */ 1381 static long ibmvscsis_adapter_info(struct scsi_info *vscsi, 1382 struct iu_entry *iue) 1383 { 1384 struct viosrp_adapter_info *mad = &vio_iu(iue)->mad.adapter_info; 1385 struct mad_adapter_info_data *info; 1386 uint flag_bits = 0; 1387 dma_addr_t token; 1388 long rc; 1389 1390 mad->common.status = cpu_to_be16(VIOSRP_MAD_SUCCESS); 1391 1392 if (be16_to_cpu(mad->common.length) > sizeof(*info)) { 1393 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED); 1394 return 0; 1395 } 1396 1397 info = dma_alloc_coherent(&vscsi->dma_dev->dev, sizeof(*info), &token, 1398 GFP_ATOMIC); 1399 if (!info) { 1400 dev_err(&vscsi->dev, "bad dma_alloc_coherent %p\n", 1401 iue->target); 1402 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED); 1403 return 0; 1404 } 1405 1406 /* Get remote info */ 1407 rc = h_copy_rdma(be16_to_cpu(mad->common.length), 1408 vscsi->dds.window[REMOTE].liobn, 1409 be64_to_cpu(mad->buffer), 1410 vscsi->dds.window[LOCAL].liobn, token); 1411 1412 if (rc != H_SUCCESS) { 1413 if (rc == H_PERMISSION) { 1414 if (connection_broken(vscsi)) 1415 flag_bits = (RESPONSE_Q_DOWN | CLIENT_FAILED); 1416 } 1417 pr_warn("adapter_info: h_copy_rdma from client failed, rc %ld\n", 1418 rc); 1419 pr_debug("adapter_info: ioba 0x%llx, flags 0x%x, flag_bits 0x%x\n", 1420 be64_to_cpu(mad->buffer), vscsi->flags, flag_bits); 1421 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 1422 flag_bits); 1423 goto free_dma; 1424 } 1425 1426 /* 1427 * Copy client info, but ignore partition number, which we 1428 * already got from phyp - unless we failed to get it from 1429 * phyp (e.g. if we're running on a p5 system). 1430 */ 1431 if (vscsi->client_data.partition_number == 0) 1432 vscsi->client_data.partition_number = 1433 be32_to_cpu(info->partition_number); 1434 strncpy(vscsi->client_data.srp_version, info->srp_version, 1435 sizeof(vscsi->client_data.srp_version)); 1436 strncpy(vscsi->client_data.partition_name, info->partition_name, 1437 sizeof(vscsi->client_data.partition_name)); 1438 vscsi->client_data.mad_version = be32_to_cpu(info->mad_version); 1439 vscsi->client_data.os_type = be32_to_cpu(info->os_type); 1440 1441 /* Copy our info */ 1442 strncpy(info->srp_version, SRP_VERSION, 1443 sizeof(info->srp_version)); 1444 strncpy(info->partition_name, vscsi->dds.partition_name, 1445 sizeof(info->partition_name)); 1446 info->partition_number = cpu_to_be32(vscsi->dds.partition_num); 1447 info->mad_version = cpu_to_be32(MAD_VERSION_1); 1448 info->os_type = cpu_to_be32(LINUX); 1449 memset(&info->port_max_txu[0], 0, sizeof(info->port_max_txu)); 1450 info->port_max_txu[0] = cpu_to_be32(MAX_TXU); 1451 1452 dma_wmb(); 1453 rc = h_copy_rdma(sizeof(*info), vscsi->dds.window[LOCAL].liobn, 1454 token, vscsi->dds.window[REMOTE].liobn, 1455 be64_to_cpu(mad->buffer)); 1456 switch (rc) { 1457 case H_SUCCESS: 1458 break; 1459 1460 case H_SOURCE_PARM: 1461 case H_DEST_PARM: 1462 case H_PERMISSION: 1463 if (connection_broken(vscsi)) 1464 flag_bits = (RESPONSE_Q_DOWN | CLIENT_FAILED); 1465 default: 1466 dev_err(&vscsi->dev, "adapter_info: h_copy_rdma to client failed, rc %ld\n", 1467 rc); 1468 ibmvscsis_post_disconnect(vscsi, 1469 ERR_DISCONNECT_RECONNECT, 1470 flag_bits); 1471 break; 1472 } 1473 1474 free_dma: 1475 dma_free_coherent(&vscsi->dma_dev->dev, sizeof(*info), info, token); 1476 pr_debug("Leaving adapter_info, rc %ld\n", rc); 1477 1478 return rc; 1479 } 1480 1481 /** 1482 * ibmvscsis_cap_mad() - Service a Capabilities MAnagement Data gram 1483 * @vscsi: Pointer to our adapter structure 1484 * @iue: Information Unit containing the Capabilities MAD request 1485 * 1486 * NOTE: if you return an error from this routine you must be 1487 * disconnecting or you will cause a hang 1488 * 1489 * EXECUTION ENVIRONMENT: 1490 * Interrupt called with adapter lock held 1491 */ 1492 static int ibmvscsis_cap_mad(struct scsi_info *vscsi, struct iu_entry *iue) 1493 { 1494 struct viosrp_capabilities *mad = &vio_iu(iue)->mad.capabilities; 1495 struct capabilities *cap; 1496 struct mad_capability_common *common; 1497 dma_addr_t token; 1498 u16 olen, len, status, min_len, cap_len; 1499 u32 flag; 1500 uint flag_bits = 0; 1501 long rc = 0; 1502 1503 olen = be16_to_cpu(mad->common.length); 1504 /* 1505 * struct capabilities hardcodes a couple capabilities after the 1506 * header, but the capabilities can actually be in any order. 1507 */ 1508 min_len = offsetof(struct capabilities, migration); 1509 if ((olen < min_len) || (olen > PAGE_SIZE)) { 1510 pr_warn("cap_mad: invalid len %d\n", olen); 1511 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED); 1512 return 0; 1513 } 1514 1515 cap = dma_alloc_coherent(&vscsi->dma_dev->dev, olen, &token, 1516 GFP_ATOMIC); 1517 if (!cap) { 1518 dev_err(&vscsi->dev, "bad dma_alloc_coherent %p\n", 1519 iue->target); 1520 mad->common.status = cpu_to_be16(VIOSRP_MAD_FAILED); 1521 return 0; 1522 } 1523 rc = h_copy_rdma(olen, vscsi->dds.window[REMOTE].liobn, 1524 be64_to_cpu(mad->buffer), 1525 vscsi->dds.window[LOCAL].liobn, token); 1526 if (rc == H_SUCCESS) { 1527 strncpy(cap->name, dev_name(&vscsi->dma_dev->dev), 1528 SRP_MAX_LOC_LEN); 1529 1530 len = olen - min_len; 1531 status = VIOSRP_MAD_SUCCESS; 1532 common = (struct mad_capability_common *)&cap->migration; 1533 1534 while ((len > 0) && (status == VIOSRP_MAD_SUCCESS) && !rc) { 1535 pr_debug("cap_mad: len left %hd, cap type %d, cap len %hd\n", 1536 len, be32_to_cpu(common->cap_type), 1537 be16_to_cpu(common->length)); 1538 1539 cap_len = be16_to_cpu(common->length); 1540 if (cap_len > len) { 1541 dev_err(&vscsi->dev, "cap_mad: cap len mismatch with total len\n"); 1542 status = VIOSRP_MAD_FAILED; 1543 break; 1544 } 1545 1546 if (cap_len == 0) { 1547 dev_err(&vscsi->dev, "cap_mad: cap len is 0\n"); 1548 status = VIOSRP_MAD_FAILED; 1549 break; 1550 } 1551 1552 switch (common->cap_type) { 1553 default: 1554 pr_debug("cap_mad: unsupported capability\n"); 1555 common->server_support = 0; 1556 flag = cpu_to_be32((u32)CAP_LIST_SUPPORTED); 1557 cap->flags &= ~flag; 1558 break; 1559 } 1560 1561 len = len - cap_len; 1562 common = (struct mad_capability_common *) 1563 ((char *)common + cap_len); 1564 } 1565 1566 mad->common.status = cpu_to_be16(status); 1567 1568 dma_wmb(); 1569 rc = h_copy_rdma(olen, vscsi->dds.window[LOCAL].liobn, token, 1570 vscsi->dds.window[REMOTE].liobn, 1571 be64_to_cpu(mad->buffer)); 1572 1573 if (rc != H_SUCCESS) { 1574 pr_debug("cap_mad: failed to copy to client, rc %ld\n", 1575 rc); 1576 1577 if (rc == H_PERMISSION) { 1578 if (connection_broken(vscsi)) 1579 flag_bits = (RESPONSE_Q_DOWN | 1580 CLIENT_FAILED); 1581 } 1582 1583 pr_warn("cap_mad: error copying data to client, rc %ld\n", 1584 rc); 1585 ibmvscsis_post_disconnect(vscsi, 1586 ERR_DISCONNECT_RECONNECT, 1587 flag_bits); 1588 } 1589 } 1590 1591 dma_free_coherent(&vscsi->dma_dev->dev, olen, cap, token); 1592 1593 pr_debug("Leaving cap_mad, rc %ld, client_cap 0x%x\n", 1594 rc, vscsi->client_cap); 1595 1596 return rc; 1597 } 1598 1599 /** 1600 * ibmvscsis_process_mad() - Service a MAnagement Data gram 1601 * @vscsi: Pointer to our adapter structure 1602 * @iue: Information Unit containing the MAD request 1603 * 1604 * Must be called with interrupt lock held. 1605 */ 1606 static long ibmvscsis_process_mad(struct scsi_info *vscsi, struct iu_entry *iue) 1607 { 1608 struct mad_common *mad = (struct mad_common *)&vio_iu(iue)->mad; 1609 struct viosrp_empty_iu *empty; 1610 long rc = ADAPT_SUCCESS; 1611 1612 switch (be32_to_cpu(mad->type)) { 1613 case VIOSRP_EMPTY_IU_TYPE: 1614 empty = &vio_iu(iue)->mad.empty_iu; 1615 vscsi->empty_iu_id = be64_to_cpu(empty->buffer); 1616 vscsi->empty_iu_tag = be64_to_cpu(empty->common.tag); 1617 mad->status = cpu_to_be16(VIOSRP_MAD_SUCCESS); 1618 break; 1619 case VIOSRP_ADAPTER_INFO_TYPE: 1620 rc = ibmvscsis_adapter_info(vscsi, iue); 1621 break; 1622 case VIOSRP_CAPABILITIES_TYPE: 1623 rc = ibmvscsis_cap_mad(vscsi, iue); 1624 break; 1625 case VIOSRP_ENABLE_FAST_FAIL: 1626 if (vscsi->state == CONNECTED) { 1627 vscsi->fast_fail = true; 1628 mad->status = cpu_to_be16(VIOSRP_MAD_SUCCESS); 1629 } else { 1630 pr_warn("fast fail mad sent after login\n"); 1631 mad->status = cpu_to_be16(VIOSRP_MAD_FAILED); 1632 } 1633 break; 1634 default: 1635 mad->status = cpu_to_be16(VIOSRP_MAD_NOT_SUPPORTED); 1636 break; 1637 } 1638 1639 return rc; 1640 } 1641 1642 /** 1643 * srp_snd_msg_failed() - Handle an error when sending a response 1644 * @vscsi: Pointer to our adapter structure 1645 * @rc: The return code from the h_send_crq command 1646 * 1647 * Must be called with interrupt lock held. 1648 */ 1649 static void srp_snd_msg_failed(struct scsi_info *vscsi, long rc) 1650 { 1651 ktime_t kt; 1652 1653 if (rc != H_DROPPED) { 1654 ibmvscsis_free_cmd_qs(vscsi); 1655 1656 if (rc == H_CLOSED) 1657 vscsi->flags |= CLIENT_FAILED; 1658 1659 /* don't flag the same problem multiple times */ 1660 if (!(vscsi->flags & RESPONSE_Q_DOWN)) { 1661 vscsi->flags |= RESPONSE_Q_DOWN; 1662 if (!(vscsi->state & (ERR_DISCONNECT | 1663 ERR_DISCONNECT_RECONNECT | 1664 ERR_DISCONNECTED | UNDEFINED))) { 1665 dev_err(&vscsi->dev, "snd_msg_failed: setting RESPONSE_Q_DOWN, state 0x%hx, flags 0x%x, rc %ld\n", 1666 vscsi->state, vscsi->flags, rc); 1667 } 1668 ibmvscsis_post_disconnect(vscsi, 1669 ERR_DISCONNECT_RECONNECT, 0); 1670 } 1671 return; 1672 } 1673 1674 /* 1675 * The response queue is full. 1676 * If the server is processing SRP requests, i.e. 1677 * the client has successfully done an 1678 * SRP_LOGIN, then it will wait forever for room in 1679 * the queue. However if the system admin 1680 * is attempting to unconfigure the server then one 1681 * or more children will be in a state where 1682 * they are being removed. So if there is even one 1683 * child being removed then the driver assumes 1684 * the system admin is attempting to break the 1685 * connection with the client and MAX_TIMER_POPS 1686 * is honored. 1687 */ 1688 if ((vscsi->rsp_q_timer.timer_pops < MAX_TIMER_POPS) || 1689 (vscsi->state == SRP_PROCESSING)) { 1690 pr_debug("snd_msg_failed: response queue full, flags 0x%x, timer started %d, pops %d\n", 1691 vscsi->flags, (int)vscsi->rsp_q_timer.started, 1692 vscsi->rsp_q_timer.timer_pops); 1693 1694 /* 1695 * Check if the timer is running; if it 1696 * is not then start it up. 1697 */ 1698 if (!vscsi->rsp_q_timer.started) { 1699 if (vscsi->rsp_q_timer.timer_pops < 1700 MAX_TIMER_POPS) { 1701 kt = WAIT_NANO_SECONDS; 1702 } else { 1703 /* 1704 * slide the timeslice if the maximum 1705 * timer pops have already happened 1706 */ 1707 kt = ktime_set(WAIT_SECONDS, 0); 1708 } 1709 1710 vscsi->rsp_q_timer.started = true; 1711 hrtimer_start(&vscsi->rsp_q_timer.timer, kt, 1712 HRTIMER_MODE_REL); 1713 } 1714 } else { 1715 /* 1716 * TBD: Do we need to worry about this? Need to get 1717 * remove working. 1718 */ 1719 /* 1720 * waited a long time and it appears the system admin 1721 * is bring this driver down 1722 */ 1723 vscsi->flags |= RESPONSE_Q_DOWN; 1724 ibmvscsis_free_cmd_qs(vscsi); 1725 /* 1726 * if the driver is already attempting to disconnect 1727 * from the client and has already logged an error 1728 * trace this event but don't put it in the error log 1729 */ 1730 if (!(vscsi->state & (ERR_DISCONNECT | 1731 ERR_DISCONNECT_RECONNECT | 1732 ERR_DISCONNECTED | UNDEFINED))) { 1733 dev_err(&vscsi->dev, "client crq full too long\n"); 1734 ibmvscsis_post_disconnect(vscsi, 1735 ERR_DISCONNECT_RECONNECT, 1736 0); 1737 } 1738 } 1739 } 1740 1741 /** 1742 * ibmvscsis_send_messages() - Send a Response 1743 * @vscsi: Pointer to our adapter structure 1744 * 1745 * Send a response, first checking the waiting queue. Responses are 1746 * sent in order they are received. If the response cannot be sent, 1747 * because the client queue is full, it stays on the waiting queue. 1748 * 1749 * PRECONDITION: 1750 * Called with interrupt lock held 1751 */ 1752 static void ibmvscsis_send_messages(struct scsi_info *vscsi) 1753 { 1754 u64 msg_hi = 0; 1755 /* note do not attempt to access the IU_data_ptr with this pointer 1756 * it is not valid 1757 */ 1758 struct viosrp_crq *crq = (struct viosrp_crq *)&msg_hi; 1759 struct ibmvscsis_cmd *cmd, *nxt; 1760 struct iu_entry *iue; 1761 long rc = ADAPT_SUCCESS; 1762 bool retry = false; 1763 1764 if (!(vscsi->flags & RESPONSE_Q_DOWN)) { 1765 do { 1766 retry = false; 1767 list_for_each_entry_safe(cmd, nxt, &vscsi->waiting_rsp, 1768 list) { 1769 /* 1770 * Check to make sure abort cmd gets processed 1771 * prior to the abort tmr cmd 1772 */ 1773 if (cmd->flags & DELAY_SEND) 1774 continue; 1775 1776 if (cmd->abort_cmd) { 1777 retry = true; 1778 cmd->abort_cmd->flags &= ~(DELAY_SEND); 1779 cmd->abort_cmd = NULL; 1780 } 1781 1782 /* 1783 * If CMD_T_ABORTED w/o CMD_T_TAS scenarios and 1784 * the case where LIO issued a 1785 * ABORT_TASK: Sending TMR_TASK_DOES_NOT_EXIST 1786 * case then we dont send a response, since it 1787 * was already done. 1788 */ 1789 if (cmd->se_cmd.transport_state & CMD_T_ABORTED && 1790 !(cmd->se_cmd.transport_state & CMD_T_TAS)) { 1791 list_del(&cmd->list); 1792 ibmvscsis_free_cmd_resources(vscsi, 1793 cmd); 1794 /* 1795 * With a successfully aborted op 1796 * through LIO we want to increment the 1797 * the vscsi credit so that when we dont 1798 * send a rsp to the original scsi abort 1799 * op (h_send_crq), but the tm rsp to 1800 * the abort is sent, the credit is 1801 * correctly sent with the abort tm rsp. 1802 * We would need 1 for the abort tm rsp 1803 * and 1 credit for the aborted scsi op. 1804 * Thus we need to increment here. 1805 * Also we want to increment the credit 1806 * here because we want to make sure 1807 * cmd is actually released first 1808 * otherwise the client will think it 1809 * it can send a new cmd, and we could 1810 * find ourselves short of cmd elements. 1811 */ 1812 vscsi->credit += 1; 1813 } else { 1814 iue = cmd->iue; 1815 1816 crq->valid = VALID_CMD_RESP_EL; 1817 crq->format = cmd->rsp.format; 1818 1819 if (cmd->flags & CMD_FAST_FAIL) 1820 crq->status = VIOSRP_ADAPTER_FAIL; 1821 1822 crq->IU_length = cpu_to_be16(cmd->rsp.len); 1823 1824 rc = h_send_crq(vscsi->dma_dev->unit_address, 1825 be64_to_cpu(msg_hi), 1826 be64_to_cpu(cmd->rsp.tag)); 1827 1828 pr_debug("send_messages: cmd %p, tag 0x%llx, rc %ld\n", 1829 cmd, be64_to_cpu(cmd->rsp.tag), rc); 1830 1831 /* if all ok free up the command 1832 * element resources 1833 */ 1834 if (rc == H_SUCCESS) { 1835 /* some movement has occurred */ 1836 vscsi->rsp_q_timer.timer_pops = 0; 1837 list_del(&cmd->list); 1838 1839 ibmvscsis_free_cmd_resources(vscsi, 1840 cmd); 1841 } else { 1842 srp_snd_msg_failed(vscsi, rc); 1843 break; 1844 } 1845 } 1846 } 1847 } while (retry); 1848 1849 if (!rc) { 1850 /* 1851 * The timer could pop with the queue empty. If 1852 * this happens, rc will always indicate a 1853 * success; clear the pop count. 1854 */ 1855 vscsi->rsp_q_timer.timer_pops = 0; 1856 } 1857 } else { 1858 ibmvscsis_free_cmd_qs(vscsi); 1859 } 1860 } 1861 1862 /* Called with intr lock held */ 1863 static void ibmvscsis_send_mad_resp(struct scsi_info *vscsi, 1864 struct ibmvscsis_cmd *cmd, 1865 struct viosrp_crq *crq) 1866 { 1867 struct iu_entry *iue = cmd->iue; 1868 struct mad_common *mad = (struct mad_common *)&vio_iu(iue)->mad; 1869 uint flag_bits = 0; 1870 long rc; 1871 1872 dma_wmb(); 1873 rc = h_copy_rdma(sizeof(struct mad_common), 1874 vscsi->dds.window[LOCAL].liobn, iue->sbuf->dma, 1875 vscsi->dds.window[REMOTE].liobn, 1876 be64_to_cpu(crq->IU_data_ptr)); 1877 if (!rc) { 1878 cmd->rsp.format = VIOSRP_MAD_FORMAT; 1879 cmd->rsp.len = sizeof(struct mad_common); 1880 cmd->rsp.tag = mad->tag; 1881 list_add_tail(&cmd->list, &vscsi->waiting_rsp); 1882 ibmvscsis_send_messages(vscsi); 1883 } else { 1884 pr_debug("Error sending mad response, rc %ld\n", rc); 1885 if (rc == H_PERMISSION) { 1886 if (connection_broken(vscsi)) 1887 flag_bits = (RESPONSE_Q_DOWN | CLIENT_FAILED); 1888 } 1889 dev_err(&vscsi->dev, "mad: failed to copy to client, rc %ld\n", 1890 rc); 1891 1892 ibmvscsis_free_cmd_resources(vscsi, cmd); 1893 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 1894 flag_bits); 1895 } 1896 } 1897 1898 /** 1899 * ibmvscsis_mad() - Service a MAnagement Data gram. 1900 * @vscsi: Pointer to our adapter structure 1901 * @crq: Pointer to the CRQ entry containing the MAD request 1902 * 1903 * EXECUTION ENVIRONMENT: 1904 * Interrupt, called with adapter lock held 1905 */ 1906 static long ibmvscsis_mad(struct scsi_info *vscsi, struct viosrp_crq *crq) 1907 { 1908 struct iu_entry *iue; 1909 struct ibmvscsis_cmd *cmd; 1910 struct mad_common *mad; 1911 long rc = ADAPT_SUCCESS; 1912 1913 switch (vscsi->state) { 1914 /* 1915 * We have not exchanged Init Msgs yet, so this MAD was sent 1916 * before the last Transport Event; client will not be 1917 * expecting a response. 1918 */ 1919 case WAIT_CONNECTION: 1920 pr_debug("mad: in Wait Connection state, ignoring MAD, flags %d\n", 1921 vscsi->flags); 1922 return ADAPT_SUCCESS; 1923 1924 case SRP_PROCESSING: 1925 case CONNECTED: 1926 break; 1927 1928 /* 1929 * We should never get here while we're in these states. 1930 * Just log an error and get out. 1931 */ 1932 case UNCONFIGURING: 1933 case WAIT_IDLE: 1934 case ERR_DISCONNECT: 1935 case ERR_DISCONNECT_RECONNECT: 1936 default: 1937 dev_err(&vscsi->dev, "mad: invalid adapter state %d for mad\n", 1938 vscsi->state); 1939 return ADAPT_SUCCESS; 1940 } 1941 1942 cmd = ibmvscsis_get_free_cmd(vscsi); 1943 if (!cmd) { 1944 dev_err(&vscsi->dev, "mad: failed to get cmd, debit %d\n", 1945 vscsi->debit); 1946 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 1947 return ERROR; 1948 } 1949 iue = cmd->iue; 1950 cmd->type = ADAPTER_MAD; 1951 1952 rc = ibmvscsis_copy_crq_packet(vscsi, cmd, crq); 1953 if (!rc) { 1954 mad = (struct mad_common *)&vio_iu(iue)->mad; 1955 1956 pr_debug("mad: type %d\n", be32_to_cpu(mad->type)); 1957 1958 rc = ibmvscsis_process_mad(vscsi, iue); 1959 1960 pr_debug("mad: status %hd, rc %ld\n", be16_to_cpu(mad->status), 1961 rc); 1962 1963 if (!rc) 1964 ibmvscsis_send_mad_resp(vscsi, cmd, crq); 1965 } else { 1966 ibmvscsis_free_cmd_resources(vscsi, cmd); 1967 } 1968 1969 pr_debug("Leaving mad, rc %ld\n", rc); 1970 return rc; 1971 } 1972 1973 /** 1974 * ibmvscsis_login_rsp() - Create/copy a login response notice to the client 1975 * @vscsi: Pointer to our adapter structure 1976 * @cmd: Pointer to the command for the SRP Login request 1977 * 1978 * EXECUTION ENVIRONMENT: 1979 * Interrupt, interrupt lock held 1980 */ 1981 static long ibmvscsis_login_rsp(struct scsi_info *vscsi, 1982 struct ibmvscsis_cmd *cmd) 1983 { 1984 struct iu_entry *iue = cmd->iue; 1985 struct srp_login_rsp *rsp = &vio_iu(iue)->srp.login_rsp; 1986 struct format_code *fmt; 1987 uint flag_bits = 0; 1988 long rc = ADAPT_SUCCESS; 1989 1990 memset(rsp, 0, sizeof(struct srp_login_rsp)); 1991 1992 rsp->opcode = SRP_LOGIN_RSP; 1993 rsp->req_lim_delta = cpu_to_be32(vscsi->request_limit); 1994 rsp->tag = cmd->rsp.tag; 1995 rsp->max_it_iu_len = cpu_to_be32(SRP_MAX_IU_LEN); 1996 rsp->max_ti_iu_len = cpu_to_be32(SRP_MAX_IU_LEN); 1997 fmt = (struct format_code *)&rsp->buf_fmt; 1998 fmt->buffers = SUPPORTED_FORMATS; 1999 vscsi->credit = 0; 2000 2001 cmd->rsp.len = sizeof(struct srp_login_rsp); 2002 2003 dma_wmb(); 2004 rc = h_copy_rdma(cmd->rsp.len, vscsi->dds.window[LOCAL].liobn, 2005 iue->sbuf->dma, vscsi->dds.window[REMOTE].liobn, 2006 be64_to_cpu(iue->remote_token)); 2007 2008 switch (rc) { 2009 case H_SUCCESS: 2010 break; 2011 2012 case H_PERMISSION: 2013 if (connection_broken(vscsi)) 2014 flag_bits = RESPONSE_Q_DOWN | CLIENT_FAILED; 2015 dev_err(&vscsi->dev, "login_rsp: error copying to client, rc %ld\n", 2016 rc); 2017 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 2018 flag_bits); 2019 break; 2020 case H_SOURCE_PARM: 2021 case H_DEST_PARM: 2022 default: 2023 dev_err(&vscsi->dev, "login_rsp: error copying to client, rc %ld\n", 2024 rc); 2025 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2026 break; 2027 } 2028 2029 return rc; 2030 } 2031 2032 /** 2033 * ibmvscsis_srp_login_rej() - Create/copy a login rejection notice to client 2034 * @vscsi: Pointer to our adapter structure 2035 * @cmd: Pointer to the command for the SRP Login request 2036 * @reason: The reason the SRP Login is being rejected, per SRP protocol 2037 * 2038 * EXECUTION ENVIRONMENT: 2039 * Interrupt, interrupt lock held 2040 */ 2041 static long ibmvscsis_srp_login_rej(struct scsi_info *vscsi, 2042 struct ibmvscsis_cmd *cmd, u32 reason) 2043 { 2044 struct iu_entry *iue = cmd->iue; 2045 struct srp_login_rej *rej = &vio_iu(iue)->srp.login_rej; 2046 struct format_code *fmt; 2047 uint flag_bits = 0; 2048 long rc = ADAPT_SUCCESS; 2049 2050 memset(rej, 0, sizeof(*rej)); 2051 2052 rej->opcode = SRP_LOGIN_REJ; 2053 rej->reason = cpu_to_be32(reason); 2054 rej->tag = cmd->rsp.tag; 2055 fmt = (struct format_code *)&rej->buf_fmt; 2056 fmt->buffers = SUPPORTED_FORMATS; 2057 2058 cmd->rsp.len = sizeof(*rej); 2059 2060 dma_wmb(); 2061 rc = h_copy_rdma(cmd->rsp.len, vscsi->dds.window[LOCAL].liobn, 2062 iue->sbuf->dma, vscsi->dds.window[REMOTE].liobn, 2063 be64_to_cpu(iue->remote_token)); 2064 2065 switch (rc) { 2066 case H_SUCCESS: 2067 break; 2068 case H_PERMISSION: 2069 if (connection_broken(vscsi)) 2070 flag_bits = RESPONSE_Q_DOWN | CLIENT_FAILED; 2071 dev_err(&vscsi->dev, "login_rej: error copying to client, rc %ld\n", 2072 rc); 2073 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 2074 flag_bits); 2075 break; 2076 case H_SOURCE_PARM: 2077 case H_DEST_PARM: 2078 default: 2079 dev_err(&vscsi->dev, "login_rej: error copying to client, rc %ld\n", 2080 rc); 2081 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2082 break; 2083 } 2084 2085 return rc; 2086 } 2087 2088 static int ibmvscsis_make_nexus(struct ibmvscsis_tport *tport) 2089 { 2090 char *name = tport->tport_name; 2091 struct ibmvscsis_nexus *nexus; 2092 int rc; 2093 2094 if (tport->ibmv_nexus) { 2095 pr_debug("tport->ibmv_nexus already exists\n"); 2096 return 0; 2097 } 2098 2099 nexus = kzalloc(sizeof(*nexus), GFP_KERNEL); 2100 if (!nexus) { 2101 pr_err("Unable to allocate struct ibmvscsis_nexus\n"); 2102 return -ENOMEM; 2103 } 2104 2105 nexus->se_sess = target_alloc_session(&tport->se_tpg, 0, 0, 2106 TARGET_PROT_NORMAL, name, nexus, 2107 NULL); 2108 if (IS_ERR(nexus->se_sess)) { 2109 rc = PTR_ERR(nexus->se_sess); 2110 goto transport_init_fail; 2111 } 2112 2113 tport->ibmv_nexus = nexus; 2114 2115 return 0; 2116 2117 transport_init_fail: 2118 kfree(nexus); 2119 return rc; 2120 } 2121 2122 static int ibmvscsis_drop_nexus(struct ibmvscsis_tport *tport) 2123 { 2124 struct se_session *se_sess; 2125 struct ibmvscsis_nexus *nexus; 2126 2127 nexus = tport->ibmv_nexus; 2128 if (!nexus) 2129 return -ENODEV; 2130 2131 se_sess = nexus->se_sess; 2132 if (!se_sess) 2133 return -ENODEV; 2134 2135 /* 2136 * Release the SCSI I_T Nexus to the emulated ibmvscsis Target Port 2137 */ 2138 target_wait_for_sess_cmds(se_sess); 2139 transport_deregister_session_configfs(se_sess); 2140 transport_deregister_session(se_sess); 2141 tport->ibmv_nexus = NULL; 2142 kfree(nexus); 2143 2144 return 0; 2145 } 2146 2147 /** 2148 * ibmvscsis_srp_login() - Process an SRP Login Request 2149 * @vscsi: Pointer to our adapter structure 2150 * @cmd: Command element to use to process the SRP Login request 2151 * @crq: Pointer to CRQ entry containing the SRP Login request 2152 * 2153 * EXECUTION ENVIRONMENT: 2154 * Interrupt, called with interrupt lock held 2155 */ 2156 static long ibmvscsis_srp_login(struct scsi_info *vscsi, 2157 struct ibmvscsis_cmd *cmd, 2158 struct viosrp_crq *crq) 2159 { 2160 struct iu_entry *iue = cmd->iue; 2161 struct srp_login_req *req = &vio_iu(iue)->srp.login_req; 2162 struct port_id { 2163 __be64 id_extension; 2164 __be64 io_guid; 2165 } *iport, *tport; 2166 struct format_code *fmt; 2167 u32 reason = 0x0; 2168 long rc = ADAPT_SUCCESS; 2169 2170 iport = (struct port_id *)req->initiator_port_id; 2171 tport = (struct port_id *)req->target_port_id; 2172 fmt = (struct format_code *)&req->req_buf_fmt; 2173 if (be32_to_cpu(req->req_it_iu_len) > SRP_MAX_IU_LEN) 2174 reason = SRP_LOGIN_REJ_REQ_IT_IU_LENGTH_TOO_LARGE; 2175 else if (be32_to_cpu(req->req_it_iu_len) < 64) 2176 reason = SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL; 2177 else if ((be64_to_cpu(iport->id_extension) > (MAX_NUM_PORTS - 1)) || 2178 (be64_to_cpu(tport->id_extension) > (MAX_NUM_PORTS - 1))) 2179 reason = SRP_LOGIN_REJ_UNABLE_ASSOCIATE_CHANNEL; 2180 else if (req->req_flags & SRP_MULTICHAN_MULTI) 2181 reason = SRP_LOGIN_REJ_MULTI_CHANNEL_UNSUPPORTED; 2182 else if (fmt->buffers & (~SUPPORTED_FORMATS)) 2183 reason = SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT; 2184 else if ((fmt->buffers & SUPPORTED_FORMATS) == 0) 2185 reason = SRP_LOGIN_REJ_UNSUPPORTED_DESCRIPTOR_FMT; 2186 2187 if (vscsi->state == SRP_PROCESSING) 2188 reason = SRP_LOGIN_REJ_CHANNEL_LIMIT_REACHED; 2189 2190 rc = ibmvscsis_make_nexus(&vscsi->tport); 2191 if (rc) 2192 reason = SRP_LOGIN_REJ_UNABLE_ESTABLISH_CHANNEL; 2193 2194 cmd->rsp.format = VIOSRP_SRP_FORMAT; 2195 cmd->rsp.tag = req->tag; 2196 2197 pr_debug("srp_login: reason 0x%x\n", reason); 2198 2199 if (reason) 2200 rc = ibmvscsis_srp_login_rej(vscsi, cmd, reason); 2201 else 2202 rc = ibmvscsis_login_rsp(vscsi, cmd); 2203 2204 if (!rc) { 2205 if (!reason) 2206 vscsi->state = SRP_PROCESSING; 2207 2208 list_add_tail(&cmd->list, &vscsi->waiting_rsp); 2209 ibmvscsis_send_messages(vscsi); 2210 } else { 2211 ibmvscsis_free_cmd_resources(vscsi, cmd); 2212 } 2213 2214 pr_debug("Leaving srp_login, rc %ld\n", rc); 2215 return rc; 2216 } 2217 2218 /** 2219 * ibmvscsis_srp_i_logout() - Helper Function to close I_T Nexus 2220 * @vscsi: Pointer to our adapter structure 2221 * @cmd: Command element to use to process the Implicit Logout request 2222 * @crq: Pointer to CRQ entry containing the Implicit Logout request 2223 * 2224 * Do the logic to close the I_T nexus. This function may not 2225 * behave to specification. 2226 * 2227 * EXECUTION ENVIRONMENT: 2228 * Interrupt, interrupt lock held 2229 */ 2230 static long ibmvscsis_srp_i_logout(struct scsi_info *vscsi, 2231 struct ibmvscsis_cmd *cmd, 2232 struct viosrp_crq *crq) 2233 { 2234 struct iu_entry *iue = cmd->iue; 2235 struct srp_i_logout *log_out = &vio_iu(iue)->srp.i_logout; 2236 long rc = ADAPT_SUCCESS; 2237 2238 if ((vscsi->debit > 0) || !list_empty(&vscsi->schedule_q) || 2239 !list_empty(&vscsi->waiting_rsp)) { 2240 dev_err(&vscsi->dev, "i_logout: outstanding work\n"); 2241 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0); 2242 } else { 2243 cmd->rsp.format = SRP_FORMAT; 2244 cmd->rsp.tag = log_out->tag; 2245 cmd->rsp.len = sizeof(struct mad_common); 2246 list_add_tail(&cmd->list, &vscsi->waiting_rsp); 2247 ibmvscsis_send_messages(vscsi); 2248 2249 ibmvscsis_post_disconnect(vscsi, WAIT_IDLE, 0); 2250 } 2251 2252 return rc; 2253 } 2254 2255 /* Called with intr lock held */ 2256 static void ibmvscsis_srp_cmd(struct scsi_info *vscsi, struct viosrp_crq *crq) 2257 { 2258 struct ibmvscsis_cmd *cmd; 2259 struct iu_entry *iue; 2260 struct srp_cmd *srp; 2261 struct srp_tsk_mgmt *tsk; 2262 long rc; 2263 2264 if (vscsi->request_limit - vscsi->debit <= 0) { 2265 /* Client has exceeded request limit */ 2266 dev_err(&vscsi->dev, "Client exceeded the request limit (%d), debit %d\n", 2267 vscsi->request_limit, vscsi->debit); 2268 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2269 return; 2270 } 2271 2272 cmd = ibmvscsis_get_free_cmd(vscsi); 2273 if (!cmd) { 2274 dev_err(&vscsi->dev, "srp_cmd failed to get cmd, debit %d\n", 2275 vscsi->debit); 2276 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2277 return; 2278 } 2279 iue = cmd->iue; 2280 srp = &vio_iu(iue)->srp.cmd; 2281 2282 rc = ibmvscsis_copy_crq_packet(vscsi, cmd, crq); 2283 if (rc) { 2284 ibmvscsis_free_cmd_resources(vscsi, cmd); 2285 return; 2286 } 2287 2288 if (vscsi->state == SRP_PROCESSING) { 2289 switch (srp->opcode) { 2290 case SRP_LOGIN_REQ: 2291 rc = ibmvscsis_srp_login(vscsi, cmd, crq); 2292 break; 2293 2294 case SRP_TSK_MGMT: 2295 tsk = &vio_iu(iue)->srp.tsk_mgmt; 2296 pr_debug("tsk_mgmt tag: %llu (0x%llx)\n", tsk->tag, 2297 tsk->tag); 2298 cmd->rsp.tag = tsk->tag; 2299 vscsi->debit += 1; 2300 cmd->type = TASK_MANAGEMENT; 2301 list_add_tail(&cmd->list, &vscsi->schedule_q); 2302 queue_work(vscsi->work_q, &cmd->work); 2303 break; 2304 2305 case SRP_CMD: 2306 pr_debug("srp_cmd tag: %llu (0x%llx)\n", srp->tag, 2307 srp->tag); 2308 cmd->rsp.tag = srp->tag; 2309 vscsi->debit += 1; 2310 cmd->type = SCSI_CDB; 2311 /* 2312 * We want to keep track of work waiting for 2313 * the workqueue. 2314 */ 2315 list_add_tail(&cmd->list, &vscsi->schedule_q); 2316 queue_work(vscsi->work_q, &cmd->work); 2317 break; 2318 2319 case SRP_I_LOGOUT: 2320 rc = ibmvscsis_srp_i_logout(vscsi, cmd, crq); 2321 break; 2322 2323 case SRP_CRED_RSP: 2324 case SRP_AER_RSP: 2325 default: 2326 ibmvscsis_free_cmd_resources(vscsi, cmd); 2327 dev_err(&vscsi->dev, "invalid srp cmd, opcode %d\n", 2328 (uint)srp->opcode); 2329 ibmvscsis_post_disconnect(vscsi, 2330 ERR_DISCONNECT_RECONNECT, 0); 2331 break; 2332 } 2333 } else if (srp->opcode == SRP_LOGIN_REQ && vscsi->state == CONNECTED) { 2334 rc = ibmvscsis_srp_login(vscsi, cmd, crq); 2335 } else { 2336 ibmvscsis_free_cmd_resources(vscsi, cmd); 2337 dev_err(&vscsi->dev, "Invalid state %d to handle srp cmd\n", 2338 vscsi->state); 2339 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2340 } 2341 } 2342 2343 /** 2344 * ibmvscsis_ping_response() - Respond to a ping request 2345 * @vscsi: Pointer to our adapter structure 2346 * 2347 * Let the client know that the server is alive and waiting on 2348 * its native I/O stack. 2349 * If any type of error occurs from the call to queue a ping 2350 * response then the client is either not accepting or receiving 2351 * interrupts. Disconnect with an error. 2352 * 2353 * EXECUTION ENVIRONMENT: 2354 * Interrupt, interrupt lock held 2355 */ 2356 static long ibmvscsis_ping_response(struct scsi_info *vscsi) 2357 { 2358 struct viosrp_crq *crq; 2359 u64 buffer[2] = { 0, 0 }; 2360 long rc; 2361 2362 crq = (struct viosrp_crq *)&buffer; 2363 crq->valid = VALID_CMD_RESP_EL; 2364 crq->format = (u8)MESSAGE_IN_CRQ; 2365 crq->status = PING_RESPONSE; 2366 2367 rc = h_send_crq(vscsi->dds.unit_id, cpu_to_be64(buffer[MSG_HI]), 2368 cpu_to_be64(buffer[MSG_LOW])); 2369 2370 switch (rc) { 2371 case H_SUCCESS: 2372 break; 2373 case H_CLOSED: 2374 vscsi->flags |= CLIENT_FAILED; 2375 case H_DROPPED: 2376 vscsi->flags |= RESPONSE_Q_DOWN; 2377 case H_REMOTE_PARM: 2378 dev_err(&vscsi->dev, "ping_response: h_send_crq failed, rc %ld\n", 2379 rc); 2380 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2381 break; 2382 default: 2383 dev_err(&vscsi->dev, "ping_response: h_send_crq returned unknown rc %ld\n", 2384 rc); 2385 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0); 2386 break; 2387 } 2388 2389 return rc; 2390 } 2391 2392 /** 2393 * ibmvscsis_parse_command() - Parse an element taken from the cmd rsp queue. 2394 * @vscsi: Pointer to our adapter structure 2395 * @crq: Pointer to CRQ element containing the SRP request 2396 * 2397 * This function will return success if the command queue element is valid 2398 * and the srp iu or MAD request it pointed to was also valid. That does 2399 * not mean that an error was not returned to the client. 2400 * 2401 * EXECUTION ENVIRONMENT: 2402 * Interrupt, intr lock held 2403 */ 2404 static long ibmvscsis_parse_command(struct scsi_info *vscsi, 2405 struct viosrp_crq *crq) 2406 { 2407 long rc = ADAPT_SUCCESS; 2408 2409 switch (crq->valid) { 2410 case VALID_CMD_RESP_EL: 2411 switch (crq->format) { 2412 case OS400_FORMAT: 2413 case AIX_FORMAT: 2414 case LINUX_FORMAT: 2415 case MAD_FORMAT: 2416 if (vscsi->flags & PROCESSING_MAD) { 2417 rc = ERROR; 2418 dev_err(&vscsi->dev, "parse_command: already processing mad\n"); 2419 ibmvscsis_post_disconnect(vscsi, 2420 ERR_DISCONNECT_RECONNECT, 2421 0); 2422 } else { 2423 vscsi->flags |= PROCESSING_MAD; 2424 rc = ibmvscsis_mad(vscsi, crq); 2425 } 2426 break; 2427 2428 case SRP_FORMAT: 2429 ibmvscsis_srp_cmd(vscsi, crq); 2430 break; 2431 2432 case MESSAGE_IN_CRQ: 2433 if (crq->status == PING) 2434 ibmvscsis_ping_response(vscsi); 2435 break; 2436 2437 default: 2438 dev_err(&vscsi->dev, "parse_command: invalid format %d\n", 2439 (uint)crq->format); 2440 ibmvscsis_post_disconnect(vscsi, 2441 ERR_DISCONNECT_RECONNECT, 0); 2442 break; 2443 } 2444 break; 2445 2446 case VALID_TRANS_EVENT: 2447 rc = ibmvscsis_trans_event(vscsi, crq); 2448 break; 2449 2450 case VALID_INIT_MSG: 2451 rc = ibmvscsis_init_msg(vscsi, crq); 2452 break; 2453 2454 default: 2455 dev_err(&vscsi->dev, "parse_command: invalid valid field %d\n", 2456 (uint)crq->valid); 2457 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2458 break; 2459 } 2460 2461 /* 2462 * Return only what the interrupt handler cares 2463 * about. Most errors we keep right on trucking. 2464 */ 2465 rc = vscsi->flags & SCHEDULE_DISCONNECT; 2466 2467 return rc; 2468 } 2469 2470 static int read_dma_window(struct scsi_info *vscsi) 2471 { 2472 struct vio_dev *vdev = vscsi->dma_dev; 2473 const __be32 *dma_window; 2474 const __be32 *prop; 2475 2476 /* TODO Using of_parse_dma_window would be better, but it doesn't give 2477 * a way to read multiple windows without already knowing the size of 2478 * a window or the number of windows. 2479 */ 2480 dma_window = (const __be32 *)vio_get_attribute(vdev, 2481 "ibm,my-dma-window", 2482 NULL); 2483 if (!dma_window) { 2484 pr_err("Couldn't find ibm,my-dma-window property\n"); 2485 return -1; 2486 } 2487 2488 vscsi->dds.window[LOCAL].liobn = be32_to_cpu(*dma_window); 2489 dma_window++; 2490 2491 prop = (const __be32 *)vio_get_attribute(vdev, "ibm,#dma-address-cells", 2492 NULL); 2493 if (!prop) { 2494 pr_warn("Couldn't find ibm,#dma-address-cells property\n"); 2495 dma_window++; 2496 } else { 2497 dma_window += be32_to_cpu(*prop); 2498 } 2499 2500 prop = (const __be32 *)vio_get_attribute(vdev, "ibm,#dma-size-cells", 2501 NULL); 2502 if (!prop) { 2503 pr_warn("Couldn't find ibm,#dma-size-cells property\n"); 2504 dma_window++; 2505 } else { 2506 dma_window += be32_to_cpu(*prop); 2507 } 2508 2509 /* dma_window should point to the second window now */ 2510 vscsi->dds.window[REMOTE].liobn = be32_to_cpu(*dma_window); 2511 2512 return 0; 2513 } 2514 2515 static struct ibmvscsis_tport *ibmvscsis_lookup_port(const char *name) 2516 { 2517 struct ibmvscsis_tport *tport = NULL; 2518 struct vio_dev *vdev; 2519 struct scsi_info *vscsi; 2520 2521 spin_lock_bh(&ibmvscsis_dev_lock); 2522 list_for_each_entry(vscsi, &ibmvscsis_dev_list, list) { 2523 vdev = vscsi->dma_dev; 2524 if (!strcmp(dev_name(&vdev->dev), name)) { 2525 tport = &vscsi->tport; 2526 break; 2527 } 2528 } 2529 spin_unlock_bh(&ibmvscsis_dev_lock); 2530 2531 return tport; 2532 } 2533 2534 /** 2535 * ibmvscsis_parse_cmd() - Parse SRP Command 2536 * @vscsi: Pointer to our adapter structure 2537 * @cmd: Pointer to command element with SRP command 2538 * 2539 * Parse the srp command; if it is valid then submit it to tcm. 2540 * Note: The return code does not reflect the status of the SCSI CDB. 2541 * 2542 * EXECUTION ENVIRONMENT: 2543 * Process level 2544 */ 2545 static void ibmvscsis_parse_cmd(struct scsi_info *vscsi, 2546 struct ibmvscsis_cmd *cmd) 2547 { 2548 struct iu_entry *iue = cmd->iue; 2549 struct srp_cmd *srp = (struct srp_cmd *)iue->sbuf->buf; 2550 struct ibmvscsis_nexus *nexus; 2551 u64 data_len = 0; 2552 enum dma_data_direction dir; 2553 int attr = 0; 2554 int rc = 0; 2555 2556 nexus = vscsi->tport.ibmv_nexus; 2557 /* 2558 * additional length in bytes. Note that the SRP spec says that 2559 * additional length is in 4-byte words, but technically the 2560 * additional length field is only the upper 6 bits of the byte. 2561 * The lower 2 bits are reserved. If the lower 2 bits are 0 (as 2562 * all reserved fields should be), then interpreting the byte as 2563 * an int will yield the length in bytes. 2564 */ 2565 if (srp->add_cdb_len & 0x03) { 2566 dev_err(&vscsi->dev, "parse_cmd: reserved bits set in IU\n"); 2567 spin_lock_bh(&vscsi->intr_lock); 2568 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2569 ibmvscsis_free_cmd_resources(vscsi, cmd); 2570 spin_unlock_bh(&vscsi->intr_lock); 2571 return; 2572 } 2573 2574 if (srp_get_desc_table(srp, &dir, &data_len)) { 2575 dev_err(&vscsi->dev, "0x%llx: parsing SRP descriptor table failed.\n", 2576 srp->tag); 2577 goto fail; 2578 } 2579 2580 cmd->rsp.sol_not = srp->sol_not; 2581 2582 switch (srp->task_attr) { 2583 case SRP_SIMPLE_TASK: 2584 attr = TCM_SIMPLE_TAG; 2585 break; 2586 case SRP_ORDERED_TASK: 2587 attr = TCM_ORDERED_TAG; 2588 break; 2589 case SRP_HEAD_TASK: 2590 attr = TCM_HEAD_TAG; 2591 break; 2592 case SRP_ACA_TASK: 2593 attr = TCM_ACA_TAG; 2594 break; 2595 default: 2596 dev_err(&vscsi->dev, "Invalid task attribute %d\n", 2597 srp->task_attr); 2598 goto fail; 2599 } 2600 2601 cmd->se_cmd.tag = be64_to_cpu(srp->tag); 2602 2603 spin_lock_bh(&vscsi->intr_lock); 2604 list_add_tail(&cmd->list, &vscsi->active_q); 2605 spin_unlock_bh(&vscsi->intr_lock); 2606 2607 srp->lun.scsi_lun[0] &= 0x3f; 2608 2609 rc = target_submit_cmd(&cmd->se_cmd, nexus->se_sess, srp->cdb, 2610 cmd->sense_buf, scsilun_to_int(&srp->lun), 2611 data_len, attr, dir, 0); 2612 if (rc) { 2613 dev_err(&vscsi->dev, "target_submit_cmd failed, rc %d\n", rc); 2614 spin_lock_bh(&vscsi->intr_lock); 2615 list_del(&cmd->list); 2616 ibmvscsis_free_cmd_resources(vscsi, cmd); 2617 spin_unlock_bh(&vscsi->intr_lock); 2618 goto fail; 2619 } 2620 return; 2621 2622 fail: 2623 spin_lock_bh(&vscsi->intr_lock); 2624 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT_RECONNECT, 0); 2625 spin_unlock_bh(&vscsi->intr_lock); 2626 } 2627 2628 /** 2629 * ibmvscsis_parse_task() - Parse SRP Task Management Request 2630 * @vscsi: Pointer to our adapter structure 2631 * @cmd: Pointer to command element with SRP task management request 2632 * 2633 * Parse the srp task management request; if it is valid then submit it to tcm. 2634 * Note: The return code does not reflect the status of the task management 2635 * request. 2636 * 2637 * EXECUTION ENVIRONMENT: 2638 * Processor level 2639 */ 2640 static void ibmvscsis_parse_task(struct scsi_info *vscsi, 2641 struct ibmvscsis_cmd *cmd) 2642 { 2643 struct iu_entry *iue = cmd->iue; 2644 struct srp_tsk_mgmt *srp_tsk = &vio_iu(iue)->srp.tsk_mgmt; 2645 int tcm_type; 2646 u64 tag_to_abort = 0; 2647 int rc = 0; 2648 struct ibmvscsis_nexus *nexus; 2649 2650 nexus = vscsi->tport.ibmv_nexus; 2651 2652 cmd->rsp.sol_not = srp_tsk->sol_not; 2653 2654 switch (srp_tsk->tsk_mgmt_func) { 2655 case SRP_TSK_ABORT_TASK: 2656 tcm_type = TMR_ABORT_TASK; 2657 tag_to_abort = be64_to_cpu(srp_tsk->task_tag); 2658 break; 2659 case SRP_TSK_ABORT_TASK_SET: 2660 tcm_type = TMR_ABORT_TASK_SET; 2661 break; 2662 case SRP_TSK_CLEAR_TASK_SET: 2663 tcm_type = TMR_CLEAR_TASK_SET; 2664 break; 2665 case SRP_TSK_LUN_RESET: 2666 tcm_type = TMR_LUN_RESET; 2667 break; 2668 case SRP_TSK_CLEAR_ACA: 2669 tcm_type = TMR_CLEAR_ACA; 2670 break; 2671 default: 2672 dev_err(&vscsi->dev, "unknown task mgmt func %d\n", 2673 srp_tsk->tsk_mgmt_func); 2674 cmd->se_cmd.se_tmr_req->response = 2675 TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED; 2676 rc = -1; 2677 break; 2678 } 2679 2680 if (!rc) { 2681 cmd->se_cmd.tag = be64_to_cpu(srp_tsk->tag); 2682 2683 spin_lock_bh(&vscsi->intr_lock); 2684 list_add_tail(&cmd->list, &vscsi->active_q); 2685 spin_unlock_bh(&vscsi->intr_lock); 2686 2687 srp_tsk->lun.scsi_lun[0] &= 0x3f; 2688 2689 pr_debug("calling submit_tmr, func %d\n", 2690 srp_tsk->tsk_mgmt_func); 2691 rc = target_submit_tmr(&cmd->se_cmd, nexus->se_sess, NULL, 2692 scsilun_to_int(&srp_tsk->lun), srp_tsk, 2693 tcm_type, GFP_KERNEL, tag_to_abort, 0); 2694 if (rc) { 2695 dev_err(&vscsi->dev, "target_submit_tmr failed, rc %d\n", 2696 rc); 2697 spin_lock_bh(&vscsi->intr_lock); 2698 list_del(&cmd->list); 2699 spin_unlock_bh(&vscsi->intr_lock); 2700 cmd->se_cmd.se_tmr_req->response = 2701 TMR_FUNCTION_REJECTED; 2702 } 2703 } 2704 2705 if (rc) 2706 transport_send_check_condition_and_sense(&cmd->se_cmd, 0, 0); 2707 } 2708 2709 static void ibmvscsis_scheduler(struct work_struct *work) 2710 { 2711 struct ibmvscsis_cmd *cmd = container_of(work, struct ibmvscsis_cmd, 2712 work); 2713 struct scsi_info *vscsi = cmd->adapter; 2714 2715 spin_lock_bh(&vscsi->intr_lock); 2716 2717 /* Remove from schedule_q */ 2718 list_del(&cmd->list); 2719 2720 /* Don't submit cmd if we're disconnecting */ 2721 if (vscsi->flags & (SCHEDULE_DISCONNECT | DISCONNECT_SCHEDULED)) { 2722 ibmvscsis_free_cmd_resources(vscsi, cmd); 2723 2724 /* ibmvscsis_disconnect might be waiting for us */ 2725 if (list_empty(&vscsi->active_q) && 2726 list_empty(&vscsi->schedule_q) && 2727 (vscsi->flags & WAIT_FOR_IDLE)) { 2728 vscsi->flags &= ~WAIT_FOR_IDLE; 2729 complete(&vscsi->wait_idle); 2730 } 2731 2732 spin_unlock_bh(&vscsi->intr_lock); 2733 return; 2734 } 2735 2736 spin_unlock_bh(&vscsi->intr_lock); 2737 2738 switch (cmd->type) { 2739 case SCSI_CDB: 2740 ibmvscsis_parse_cmd(vscsi, cmd); 2741 break; 2742 case TASK_MANAGEMENT: 2743 ibmvscsis_parse_task(vscsi, cmd); 2744 break; 2745 default: 2746 dev_err(&vscsi->dev, "scheduler, invalid cmd type %d\n", 2747 cmd->type); 2748 spin_lock_bh(&vscsi->intr_lock); 2749 ibmvscsis_free_cmd_resources(vscsi, cmd); 2750 spin_unlock_bh(&vscsi->intr_lock); 2751 break; 2752 } 2753 } 2754 2755 static int ibmvscsis_alloc_cmds(struct scsi_info *vscsi, int num) 2756 { 2757 struct ibmvscsis_cmd *cmd; 2758 int i; 2759 2760 INIT_LIST_HEAD(&vscsi->free_cmd); 2761 vscsi->cmd_pool = kcalloc(num, sizeof(struct ibmvscsis_cmd), 2762 GFP_KERNEL); 2763 if (!vscsi->cmd_pool) 2764 return -ENOMEM; 2765 2766 for (i = 0, cmd = (struct ibmvscsis_cmd *)vscsi->cmd_pool; i < num; 2767 i++, cmd++) { 2768 cmd->abort_cmd = NULL; 2769 cmd->adapter = vscsi; 2770 INIT_WORK(&cmd->work, ibmvscsis_scheduler); 2771 list_add_tail(&cmd->list, &vscsi->free_cmd); 2772 } 2773 2774 return 0; 2775 } 2776 2777 static void ibmvscsis_free_cmds(struct scsi_info *vscsi) 2778 { 2779 kfree(vscsi->cmd_pool); 2780 vscsi->cmd_pool = NULL; 2781 INIT_LIST_HEAD(&vscsi->free_cmd); 2782 } 2783 2784 /** 2785 * ibmvscsis_service_wait_q() - Service Waiting Queue 2786 * @timer: Pointer to timer which has expired 2787 * 2788 * This routine is called when the timer pops to service the waiting 2789 * queue. Elements on the queue have completed, their responses have been 2790 * copied to the client, but the client's response queue was full so 2791 * the queue message could not be sent. The routine grabs the proper locks 2792 * and calls send messages. 2793 * 2794 * EXECUTION ENVIRONMENT: 2795 * called at interrupt level 2796 */ 2797 static enum hrtimer_restart ibmvscsis_service_wait_q(struct hrtimer *timer) 2798 { 2799 struct timer_cb *p_timer = container_of(timer, struct timer_cb, timer); 2800 struct scsi_info *vscsi = container_of(p_timer, struct scsi_info, 2801 rsp_q_timer); 2802 2803 spin_lock_bh(&vscsi->intr_lock); 2804 p_timer->timer_pops += 1; 2805 p_timer->started = false; 2806 ibmvscsis_send_messages(vscsi); 2807 spin_unlock_bh(&vscsi->intr_lock); 2808 2809 return HRTIMER_NORESTART; 2810 } 2811 2812 static long ibmvscsis_alloctimer(struct scsi_info *vscsi) 2813 { 2814 struct timer_cb *p_timer; 2815 2816 p_timer = &vscsi->rsp_q_timer; 2817 hrtimer_init(&p_timer->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 2818 2819 p_timer->timer.function = ibmvscsis_service_wait_q; 2820 p_timer->started = false; 2821 p_timer->timer_pops = 0; 2822 2823 return ADAPT_SUCCESS; 2824 } 2825 2826 static void ibmvscsis_freetimer(struct scsi_info *vscsi) 2827 { 2828 struct timer_cb *p_timer; 2829 2830 p_timer = &vscsi->rsp_q_timer; 2831 2832 (void)hrtimer_cancel(&p_timer->timer); 2833 2834 p_timer->started = false; 2835 p_timer->timer_pops = 0; 2836 } 2837 2838 static irqreturn_t ibmvscsis_interrupt(int dummy, void *data) 2839 { 2840 struct scsi_info *vscsi = data; 2841 2842 vio_disable_interrupts(vscsi->dma_dev); 2843 tasklet_schedule(&vscsi->work_task); 2844 2845 return IRQ_HANDLED; 2846 } 2847 2848 /** 2849 * ibmvscsis_enable_change_state() - Set new state based on enabled status 2850 * @vscsi: Pointer to our adapter structure 2851 * 2852 * This function determines our new state now that we are enabled. This 2853 * may involve sending an Init Complete message to the client. 2854 * 2855 * Must be called with interrupt lock held. 2856 */ 2857 static long ibmvscsis_enable_change_state(struct scsi_info *vscsi) 2858 { 2859 int bytes; 2860 long rc = ADAPT_SUCCESS; 2861 2862 bytes = vscsi->cmd_q.size * PAGE_SIZE; 2863 rc = h_reg_crq(vscsi->dds.unit_id, vscsi->cmd_q.crq_token, bytes); 2864 if (rc == H_CLOSED || rc == H_SUCCESS) { 2865 vscsi->state = WAIT_CONNECTION; 2866 rc = ibmvscsis_establish_new_q(vscsi); 2867 } 2868 2869 if (rc != ADAPT_SUCCESS) { 2870 vscsi->state = ERR_DISCONNECTED; 2871 vscsi->flags |= RESPONSE_Q_DOWN; 2872 } 2873 2874 return rc; 2875 } 2876 2877 /** 2878 * ibmvscsis_create_command_q() - Create Command Queue 2879 * @vscsi: Pointer to our adapter structure 2880 * @num_cmds: Currently unused. In the future, may be used to determine 2881 * the size of the CRQ. 2882 * 2883 * Allocates memory for command queue maps remote memory into an ioba 2884 * initializes the command response queue 2885 * 2886 * EXECUTION ENVIRONMENT: 2887 * Process level only 2888 */ 2889 static long ibmvscsis_create_command_q(struct scsi_info *vscsi, int num_cmds) 2890 { 2891 int pages; 2892 struct vio_dev *vdev = vscsi->dma_dev; 2893 2894 /* We might support multiple pages in the future, but just 1 for now */ 2895 pages = 1; 2896 2897 vscsi->cmd_q.size = pages; 2898 2899 vscsi->cmd_q.base_addr = 2900 (struct viosrp_crq *)get_zeroed_page(GFP_KERNEL); 2901 if (!vscsi->cmd_q.base_addr) 2902 return -ENOMEM; 2903 2904 vscsi->cmd_q.mask = ((uint)pages * CRQ_PER_PAGE) - 1; 2905 2906 vscsi->cmd_q.crq_token = dma_map_single(&vdev->dev, 2907 vscsi->cmd_q.base_addr, 2908 PAGE_SIZE, DMA_BIDIRECTIONAL); 2909 if (dma_mapping_error(&vdev->dev, vscsi->cmd_q.crq_token)) { 2910 free_page((unsigned long)vscsi->cmd_q.base_addr); 2911 return -ENOMEM; 2912 } 2913 2914 return 0; 2915 } 2916 2917 /** 2918 * ibmvscsis_destroy_command_q - Destroy Command Queue 2919 * @vscsi: Pointer to our adapter structure 2920 * 2921 * Releases memory for command queue and unmaps mapped remote memory. 2922 * 2923 * EXECUTION ENVIRONMENT: 2924 * Process level only 2925 */ 2926 static void ibmvscsis_destroy_command_q(struct scsi_info *vscsi) 2927 { 2928 dma_unmap_single(&vscsi->dma_dev->dev, vscsi->cmd_q.crq_token, 2929 PAGE_SIZE, DMA_BIDIRECTIONAL); 2930 free_page((unsigned long)vscsi->cmd_q.base_addr); 2931 vscsi->cmd_q.base_addr = NULL; 2932 vscsi->state = NO_QUEUE; 2933 } 2934 2935 static u8 ibmvscsis_fast_fail(struct scsi_info *vscsi, 2936 struct ibmvscsis_cmd *cmd) 2937 { 2938 struct iu_entry *iue = cmd->iue; 2939 struct se_cmd *se_cmd = &cmd->se_cmd; 2940 struct srp_cmd *srp = (struct srp_cmd *)iue->sbuf->buf; 2941 struct scsi_sense_hdr sshdr; 2942 u8 rc = se_cmd->scsi_status; 2943 2944 if (vscsi->fast_fail && (READ_CMD(srp->cdb) || WRITE_CMD(srp->cdb))) 2945 if (scsi_normalize_sense(se_cmd->sense_buffer, 2946 se_cmd->scsi_sense_length, &sshdr)) 2947 if (sshdr.sense_key == HARDWARE_ERROR && 2948 (se_cmd->residual_count == 0 || 2949 se_cmd->residual_count == se_cmd->data_length)) { 2950 rc = NO_SENSE; 2951 cmd->flags |= CMD_FAST_FAIL; 2952 } 2953 2954 return rc; 2955 } 2956 2957 /** 2958 * srp_build_response() - Build an SRP response buffer 2959 * @vscsi: Pointer to our adapter structure 2960 * @cmd: Pointer to command for which to send the response 2961 * @len_p: Where to return the length of the IU response sent. This 2962 * is needed to construct the CRQ response. 2963 * 2964 * Build the SRP response buffer and copy it to the client's memory space. 2965 */ 2966 static long srp_build_response(struct scsi_info *vscsi, 2967 struct ibmvscsis_cmd *cmd, uint *len_p) 2968 { 2969 struct iu_entry *iue = cmd->iue; 2970 struct se_cmd *se_cmd = &cmd->se_cmd; 2971 struct srp_rsp *rsp; 2972 uint len; 2973 u32 rsp_code; 2974 char *data; 2975 u32 *tsk_status; 2976 long rc = ADAPT_SUCCESS; 2977 2978 spin_lock_bh(&vscsi->intr_lock); 2979 2980 rsp = &vio_iu(iue)->srp.rsp; 2981 len = sizeof(*rsp); 2982 memset(rsp, 0, len); 2983 data = rsp->data; 2984 2985 rsp->opcode = SRP_RSP; 2986 2987 rsp->req_lim_delta = cpu_to_be32(1 + vscsi->credit); 2988 rsp->tag = cmd->rsp.tag; 2989 rsp->flags = 0; 2990 2991 if (cmd->type == SCSI_CDB) { 2992 rsp->status = ibmvscsis_fast_fail(vscsi, cmd); 2993 if (rsp->status) { 2994 pr_debug("build_resp: cmd %p, scsi status %d\n", cmd, 2995 (int)rsp->status); 2996 ibmvscsis_determine_resid(se_cmd, rsp); 2997 if (se_cmd->scsi_sense_length && se_cmd->sense_buffer) { 2998 rsp->sense_data_len = 2999 cpu_to_be32(se_cmd->scsi_sense_length); 3000 rsp->flags |= SRP_RSP_FLAG_SNSVALID; 3001 len += se_cmd->scsi_sense_length; 3002 memcpy(data, se_cmd->sense_buffer, 3003 se_cmd->scsi_sense_length); 3004 } 3005 rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >> 3006 UCSOLNT_RESP_SHIFT; 3007 } else if (cmd->flags & CMD_FAST_FAIL) { 3008 pr_debug("build_resp: cmd %p, fast fail\n", cmd); 3009 rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >> 3010 UCSOLNT_RESP_SHIFT; 3011 } else { 3012 rsp->sol_not = (cmd->rsp.sol_not & SCSOLNT) >> 3013 SCSOLNT_RESP_SHIFT; 3014 } 3015 } else { 3016 /* this is task management */ 3017 rsp->status = 0; 3018 rsp->resp_data_len = cpu_to_be32(4); 3019 rsp->flags |= SRP_RSP_FLAG_RSPVALID; 3020 3021 switch (se_cmd->se_tmr_req->response) { 3022 case TMR_FUNCTION_COMPLETE: 3023 case TMR_TASK_DOES_NOT_EXIST: 3024 rsp_code = SRP_TASK_MANAGEMENT_FUNCTION_COMPLETE; 3025 rsp->sol_not = (cmd->rsp.sol_not & SCSOLNT) >> 3026 SCSOLNT_RESP_SHIFT; 3027 break; 3028 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED: 3029 case TMR_LUN_DOES_NOT_EXIST: 3030 rsp_code = SRP_TASK_MANAGEMENT_FUNCTION_NOT_SUPPORTED; 3031 rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >> 3032 UCSOLNT_RESP_SHIFT; 3033 break; 3034 case TMR_FUNCTION_FAILED: 3035 case TMR_FUNCTION_REJECTED: 3036 default: 3037 rsp_code = SRP_TASK_MANAGEMENT_FUNCTION_FAILED; 3038 rsp->sol_not = (cmd->rsp.sol_not & UCSOLNT) >> 3039 UCSOLNT_RESP_SHIFT; 3040 break; 3041 } 3042 3043 tsk_status = (u32 *)data; 3044 *tsk_status = cpu_to_be32(rsp_code); 3045 data = (char *)(tsk_status + 1); 3046 len += 4; 3047 } 3048 3049 dma_wmb(); 3050 rc = h_copy_rdma(len, vscsi->dds.window[LOCAL].liobn, iue->sbuf->dma, 3051 vscsi->dds.window[REMOTE].liobn, 3052 be64_to_cpu(iue->remote_token)); 3053 3054 switch (rc) { 3055 case H_SUCCESS: 3056 vscsi->credit = 0; 3057 *len_p = len; 3058 break; 3059 case H_PERMISSION: 3060 if (connection_broken(vscsi)) 3061 vscsi->flags |= RESPONSE_Q_DOWN | CLIENT_FAILED; 3062 3063 dev_err(&vscsi->dev, "build_response: error copying to client, rc %ld, flags 0x%x, state 0x%hx\n", 3064 rc, vscsi->flags, vscsi->state); 3065 break; 3066 case H_SOURCE_PARM: 3067 case H_DEST_PARM: 3068 default: 3069 dev_err(&vscsi->dev, "build_response: error copying to client, rc %ld\n", 3070 rc); 3071 break; 3072 } 3073 3074 spin_unlock_bh(&vscsi->intr_lock); 3075 3076 return rc; 3077 } 3078 3079 static int ibmvscsis_rdma(struct ibmvscsis_cmd *cmd, struct scatterlist *sg, 3080 int nsg, struct srp_direct_buf *md, int nmd, 3081 enum dma_data_direction dir, unsigned int bytes) 3082 { 3083 struct iu_entry *iue = cmd->iue; 3084 struct srp_target *target = iue->target; 3085 struct scsi_info *vscsi = target->ldata; 3086 struct scatterlist *sgp; 3087 dma_addr_t client_ioba, server_ioba; 3088 ulong buf_len; 3089 ulong client_len, server_len; 3090 int md_idx; 3091 long tx_len; 3092 long rc = 0; 3093 3094 if (bytes == 0) 3095 return 0; 3096 3097 sgp = sg; 3098 client_len = 0; 3099 server_len = 0; 3100 md_idx = 0; 3101 tx_len = bytes; 3102 3103 do { 3104 if (client_len == 0) { 3105 if (md_idx >= nmd) { 3106 dev_err(&vscsi->dev, "rdma: ran out of client memory descriptors\n"); 3107 rc = -EIO; 3108 break; 3109 } 3110 client_ioba = be64_to_cpu(md[md_idx].va); 3111 client_len = be32_to_cpu(md[md_idx].len); 3112 } 3113 if (server_len == 0) { 3114 if (!sgp) { 3115 dev_err(&vscsi->dev, "rdma: ran out of scatter/gather list\n"); 3116 rc = -EIO; 3117 break; 3118 } 3119 server_ioba = sg_dma_address(sgp); 3120 server_len = sg_dma_len(sgp); 3121 } 3122 3123 buf_len = tx_len; 3124 3125 if (buf_len > client_len) 3126 buf_len = client_len; 3127 3128 if (buf_len > server_len) 3129 buf_len = server_len; 3130 3131 if (buf_len > max_vdma_size) 3132 buf_len = max_vdma_size; 3133 3134 if (dir == DMA_TO_DEVICE) { 3135 /* read from client */ 3136 rc = h_copy_rdma(buf_len, 3137 vscsi->dds.window[REMOTE].liobn, 3138 client_ioba, 3139 vscsi->dds.window[LOCAL].liobn, 3140 server_ioba); 3141 } else { 3142 /* The h_copy_rdma will cause phyp, running in another 3143 * partition, to read memory, so we need to make sure 3144 * the data has been written out, hence these syncs. 3145 */ 3146 /* ensure that everything is in memory */ 3147 isync(); 3148 /* ensure that memory has been made visible */ 3149 dma_wmb(); 3150 rc = h_copy_rdma(buf_len, 3151 vscsi->dds.window[LOCAL].liobn, 3152 server_ioba, 3153 vscsi->dds.window[REMOTE].liobn, 3154 client_ioba); 3155 } 3156 switch (rc) { 3157 case H_SUCCESS: 3158 break; 3159 case H_PERMISSION: 3160 case H_SOURCE_PARM: 3161 case H_DEST_PARM: 3162 if (connection_broken(vscsi)) { 3163 spin_lock_bh(&vscsi->intr_lock); 3164 vscsi->flags |= 3165 (RESPONSE_Q_DOWN | CLIENT_FAILED); 3166 spin_unlock_bh(&vscsi->intr_lock); 3167 } 3168 dev_err(&vscsi->dev, "rdma: h_copy_rdma failed, rc %ld\n", 3169 rc); 3170 break; 3171 3172 default: 3173 dev_err(&vscsi->dev, "rdma: unknown error %ld from h_copy_rdma\n", 3174 rc); 3175 break; 3176 } 3177 3178 if (!rc) { 3179 tx_len -= buf_len; 3180 if (tx_len) { 3181 client_len -= buf_len; 3182 if (client_len == 0) 3183 md_idx++; 3184 else 3185 client_ioba += buf_len; 3186 3187 server_len -= buf_len; 3188 if (server_len == 0) 3189 sgp = sg_next(sgp); 3190 else 3191 server_ioba += buf_len; 3192 } else { 3193 break; 3194 } 3195 } 3196 } while (!rc); 3197 3198 return rc; 3199 } 3200 3201 /** 3202 * ibmvscsis_handle_crq() - Handle CRQ 3203 * @data: Pointer to our adapter structure 3204 * 3205 * Read the command elements from the command queue and copy the payloads 3206 * associated with the command elements to local memory and execute the 3207 * SRP requests. 3208 * 3209 * Note: this is an edge triggered interrupt. It can not be shared. 3210 */ 3211 static void ibmvscsis_handle_crq(unsigned long data) 3212 { 3213 struct scsi_info *vscsi = (struct scsi_info *)data; 3214 struct viosrp_crq *crq; 3215 long rc; 3216 bool ack = true; 3217 volatile u8 valid; 3218 3219 spin_lock_bh(&vscsi->intr_lock); 3220 3221 pr_debug("got interrupt\n"); 3222 3223 /* 3224 * if we are in a path where we are waiting for all pending commands 3225 * to complete because we received a transport event and anything in 3226 * the command queue is for a new connection, do nothing 3227 */ 3228 if (TARGET_STOP(vscsi)) { 3229 vio_enable_interrupts(vscsi->dma_dev); 3230 3231 pr_debug("handle_crq, don't process: flags 0x%x, state 0x%hx\n", 3232 vscsi->flags, vscsi->state); 3233 spin_unlock_bh(&vscsi->intr_lock); 3234 return; 3235 } 3236 3237 rc = vscsi->flags & SCHEDULE_DISCONNECT; 3238 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index; 3239 valid = crq->valid; 3240 dma_rmb(); 3241 3242 while (valid) { 3243 /* 3244 * These are edege triggered interrupts. After dropping out of 3245 * the while loop, the code must check for work since an 3246 * interrupt could be lost, and an elment be left on the queue, 3247 * hence the label. 3248 */ 3249 cmd_work: 3250 vscsi->cmd_q.index = 3251 (vscsi->cmd_q.index + 1) & vscsi->cmd_q.mask; 3252 3253 if (!rc) { 3254 rc = ibmvscsis_parse_command(vscsi, crq); 3255 } else { 3256 if ((uint)crq->valid == VALID_TRANS_EVENT) { 3257 /* 3258 * must service the transport layer events even 3259 * in an error state, dont break out until all 3260 * the consecutive transport events have been 3261 * processed 3262 */ 3263 rc = ibmvscsis_trans_event(vscsi, crq); 3264 } else if (vscsi->flags & TRANS_EVENT) { 3265 /* 3266 * if a transport event has occurred leave 3267 * everything but transport events on the queue 3268 * 3269 * need to decrement the queue index so we can 3270 * look at the element again 3271 */ 3272 if (vscsi->cmd_q.index) 3273 vscsi->cmd_q.index -= 1; 3274 else 3275 /* 3276 * index is at 0 it just wrapped. 3277 * have it index last element in q 3278 */ 3279 vscsi->cmd_q.index = vscsi->cmd_q.mask; 3280 break; 3281 } 3282 } 3283 3284 crq->valid = INVALIDATE_CMD_RESP_EL; 3285 3286 crq = vscsi->cmd_q.base_addr + vscsi->cmd_q.index; 3287 valid = crq->valid; 3288 dma_rmb(); 3289 } 3290 3291 if (!rc) { 3292 if (ack) { 3293 vio_enable_interrupts(vscsi->dma_dev); 3294 ack = false; 3295 pr_debug("handle_crq, reenabling interrupts\n"); 3296 } 3297 valid = crq->valid; 3298 dma_rmb(); 3299 if (valid) 3300 goto cmd_work; 3301 } else { 3302 pr_debug("handle_crq, error: flags 0x%x, state 0x%hx, crq index 0x%x\n", 3303 vscsi->flags, vscsi->state, vscsi->cmd_q.index); 3304 } 3305 3306 pr_debug("Leaving handle_crq: schedule_q empty %d, flags 0x%x, state 0x%hx\n", 3307 (int)list_empty(&vscsi->schedule_q), vscsi->flags, 3308 vscsi->state); 3309 3310 spin_unlock_bh(&vscsi->intr_lock); 3311 } 3312 3313 static int ibmvscsis_probe(struct vio_dev *vdev, 3314 const struct vio_device_id *id) 3315 { 3316 struct scsi_info *vscsi; 3317 int rc = 0; 3318 long hrc = 0; 3319 char wq_name[24]; 3320 3321 vscsi = kzalloc(sizeof(*vscsi), GFP_KERNEL); 3322 if (!vscsi) { 3323 rc = -ENOMEM; 3324 pr_err("probe: allocation of adapter failed\n"); 3325 return rc; 3326 } 3327 3328 vscsi->dma_dev = vdev; 3329 vscsi->dev = vdev->dev; 3330 INIT_LIST_HEAD(&vscsi->schedule_q); 3331 INIT_LIST_HEAD(&vscsi->waiting_rsp); 3332 INIT_LIST_HEAD(&vscsi->active_q); 3333 3334 snprintf(vscsi->tport.tport_name, IBMVSCSIS_NAMELEN, "%s", 3335 dev_name(&vdev->dev)); 3336 3337 pr_debug("probe tport_name: %s\n", vscsi->tport.tport_name); 3338 3339 rc = read_dma_window(vscsi); 3340 if (rc) 3341 goto free_adapter; 3342 pr_debug("Probe: liobn 0x%x, riobn 0x%x\n", 3343 vscsi->dds.window[LOCAL].liobn, 3344 vscsi->dds.window[REMOTE].liobn); 3345 3346 strcpy(vscsi->eye, "VSCSI "); 3347 strncat(vscsi->eye, vdev->name, MAX_EYE); 3348 3349 vscsi->dds.unit_id = vdev->unit_address; 3350 strncpy(vscsi->dds.partition_name, partition_name, 3351 sizeof(vscsi->dds.partition_name)); 3352 vscsi->dds.partition_num = partition_number; 3353 3354 spin_lock_bh(&ibmvscsis_dev_lock); 3355 list_add_tail(&vscsi->list, &ibmvscsis_dev_list); 3356 spin_unlock_bh(&ibmvscsis_dev_lock); 3357 3358 /* 3359 * TBD: How do we determine # of cmds to request? Do we know how 3360 * many "children" we have? 3361 */ 3362 vscsi->request_limit = INITIAL_SRP_LIMIT; 3363 rc = srp_target_alloc(&vscsi->target, &vdev->dev, vscsi->request_limit, 3364 SRP_MAX_IU_LEN); 3365 if (rc) 3366 goto rem_list; 3367 3368 vscsi->target.ldata = vscsi; 3369 3370 rc = ibmvscsis_alloc_cmds(vscsi, vscsi->request_limit); 3371 if (rc) { 3372 dev_err(&vscsi->dev, "alloc_cmds failed, rc %d, num %d\n", 3373 rc, vscsi->request_limit); 3374 goto free_target; 3375 } 3376 3377 /* 3378 * Note: the lock is used in freeing timers, so must initialize 3379 * first so that ordering in case of error is correct. 3380 */ 3381 spin_lock_init(&vscsi->intr_lock); 3382 3383 rc = ibmvscsis_alloctimer(vscsi); 3384 if (rc) { 3385 dev_err(&vscsi->dev, "probe: alloctimer failed, rc %d\n", rc); 3386 goto free_cmds; 3387 } 3388 3389 rc = ibmvscsis_create_command_q(vscsi, 256); 3390 if (rc) { 3391 dev_err(&vscsi->dev, "probe: create_command_q failed, rc %d\n", 3392 rc); 3393 goto free_timer; 3394 } 3395 3396 vscsi->map_buf = kzalloc(PAGE_SIZE, GFP_KERNEL); 3397 if (!vscsi->map_buf) { 3398 rc = -ENOMEM; 3399 dev_err(&vscsi->dev, "probe: allocating cmd buffer failed\n"); 3400 goto destroy_queue; 3401 } 3402 3403 vscsi->map_ioba = dma_map_single(&vdev->dev, vscsi->map_buf, PAGE_SIZE, 3404 DMA_BIDIRECTIONAL); 3405 if (dma_mapping_error(&vdev->dev, vscsi->map_ioba)) { 3406 rc = -ENOMEM; 3407 dev_err(&vscsi->dev, "probe: error mapping command buffer\n"); 3408 goto free_buf; 3409 } 3410 3411 hrc = h_vioctl(vscsi->dds.unit_id, H_GET_PARTNER_INFO, 3412 (u64)vscsi->map_ioba | ((u64)PAGE_SIZE << 32), 0, 0, 0, 3413 0); 3414 if (hrc == H_SUCCESS) 3415 vscsi->client_data.partition_number = 3416 be64_to_cpu(*(u64 *)vscsi->map_buf); 3417 /* 3418 * We expect the VIOCTL to fail if we're configured as "any 3419 * client can connect" and the client isn't activated yet. 3420 * We'll make the call again when he sends an init msg. 3421 */ 3422 pr_debug("probe hrc %ld, client partition num %d\n", 3423 hrc, vscsi->client_data.partition_number); 3424 3425 tasklet_init(&vscsi->work_task, ibmvscsis_handle_crq, 3426 (unsigned long)vscsi); 3427 3428 init_completion(&vscsi->wait_idle); 3429 init_completion(&vscsi->unconfig); 3430 3431 snprintf(wq_name, 24, "ibmvscsis%s", dev_name(&vdev->dev)); 3432 vscsi->work_q = create_workqueue(wq_name); 3433 if (!vscsi->work_q) { 3434 rc = -ENOMEM; 3435 dev_err(&vscsi->dev, "create_workqueue failed\n"); 3436 goto unmap_buf; 3437 } 3438 3439 rc = request_irq(vdev->irq, ibmvscsis_interrupt, 0, "ibmvscsis", vscsi); 3440 if (rc) { 3441 rc = -EPERM; 3442 dev_err(&vscsi->dev, "probe: request_irq failed, rc %d\n", rc); 3443 goto destroy_WQ; 3444 } 3445 3446 vscsi->state = WAIT_ENABLED; 3447 3448 dev_set_drvdata(&vdev->dev, vscsi); 3449 3450 return 0; 3451 3452 destroy_WQ: 3453 destroy_workqueue(vscsi->work_q); 3454 unmap_buf: 3455 dma_unmap_single(&vdev->dev, vscsi->map_ioba, PAGE_SIZE, 3456 DMA_BIDIRECTIONAL); 3457 free_buf: 3458 kfree(vscsi->map_buf); 3459 destroy_queue: 3460 tasklet_kill(&vscsi->work_task); 3461 ibmvscsis_unregister_command_q(vscsi); 3462 ibmvscsis_destroy_command_q(vscsi); 3463 free_timer: 3464 ibmvscsis_freetimer(vscsi); 3465 free_cmds: 3466 ibmvscsis_free_cmds(vscsi); 3467 free_target: 3468 srp_target_free(&vscsi->target); 3469 rem_list: 3470 spin_lock_bh(&ibmvscsis_dev_lock); 3471 list_del(&vscsi->list); 3472 spin_unlock_bh(&ibmvscsis_dev_lock); 3473 free_adapter: 3474 kfree(vscsi); 3475 3476 return rc; 3477 } 3478 3479 static int ibmvscsis_remove(struct vio_dev *vdev) 3480 { 3481 struct scsi_info *vscsi = dev_get_drvdata(&vdev->dev); 3482 3483 pr_debug("remove (%s)\n", dev_name(&vscsi->dma_dev->dev)); 3484 3485 spin_lock_bh(&vscsi->intr_lock); 3486 ibmvscsis_post_disconnect(vscsi, UNCONFIGURING, 0); 3487 vscsi->flags |= CFG_SLEEPING; 3488 spin_unlock_bh(&vscsi->intr_lock); 3489 wait_for_completion(&vscsi->unconfig); 3490 3491 vio_disable_interrupts(vdev); 3492 free_irq(vdev->irq, vscsi); 3493 destroy_workqueue(vscsi->work_q); 3494 dma_unmap_single(&vdev->dev, vscsi->map_ioba, PAGE_SIZE, 3495 DMA_BIDIRECTIONAL); 3496 kfree(vscsi->map_buf); 3497 tasklet_kill(&vscsi->work_task); 3498 ibmvscsis_destroy_command_q(vscsi); 3499 ibmvscsis_freetimer(vscsi); 3500 ibmvscsis_free_cmds(vscsi); 3501 srp_target_free(&vscsi->target); 3502 spin_lock_bh(&ibmvscsis_dev_lock); 3503 list_del(&vscsi->list); 3504 spin_unlock_bh(&ibmvscsis_dev_lock); 3505 kfree(vscsi); 3506 3507 return 0; 3508 } 3509 3510 static ssize_t system_id_show(struct device *dev, 3511 struct device_attribute *attr, char *buf) 3512 { 3513 return snprintf(buf, PAGE_SIZE, "%s\n", system_id); 3514 } 3515 3516 static ssize_t partition_number_show(struct device *dev, 3517 struct device_attribute *attr, char *buf) 3518 { 3519 return snprintf(buf, PAGE_SIZE, "%x\n", partition_number); 3520 } 3521 3522 static ssize_t unit_address_show(struct device *dev, 3523 struct device_attribute *attr, char *buf) 3524 { 3525 struct scsi_info *vscsi = container_of(dev, struct scsi_info, dev); 3526 3527 return snprintf(buf, PAGE_SIZE, "%x\n", vscsi->dma_dev->unit_address); 3528 } 3529 3530 static int ibmvscsis_get_system_info(void) 3531 { 3532 struct device_node *rootdn, *vdevdn; 3533 const char *id, *model, *name; 3534 const uint *num; 3535 3536 rootdn = of_find_node_by_path("/"); 3537 if (!rootdn) 3538 return -ENOENT; 3539 3540 model = of_get_property(rootdn, "model", NULL); 3541 id = of_get_property(rootdn, "system-id", NULL); 3542 if (model && id) 3543 snprintf(system_id, sizeof(system_id), "%s-%s", model, id); 3544 3545 name = of_get_property(rootdn, "ibm,partition-name", NULL); 3546 if (name) 3547 strncpy(partition_name, name, sizeof(partition_name)); 3548 3549 num = of_get_property(rootdn, "ibm,partition-no", NULL); 3550 if (num) 3551 partition_number = of_read_number(num, 1); 3552 3553 of_node_put(rootdn); 3554 3555 vdevdn = of_find_node_by_path("/vdevice"); 3556 if (vdevdn) { 3557 const uint *mvds; 3558 3559 mvds = of_get_property(vdevdn, "ibm,max-virtual-dma-size", 3560 NULL); 3561 if (mvds) 3562 max_vdma_size = *mvds; 3563 of_node_put(vdevdn); 3564 } 3565 3566 return 0; 3567 } 3568 3569 static char *ibmvscsis_get_fabric_name(void) 3570 { 3571 return "ibmvscsis"; 3572 } 3573 3574 static char *ibmvscsis_get_fabric_wwn(struct se_portal_group *se_tpg) 3575 { 3576 struct ibmvscsis_tport *tport = 3577 container_of(se_tpg, struct ibmvscsis_tport, se_tpg); 3578 3579 return tport->tport_name; 3580 } 3581 3582 static u16 ibmvscsis_get_tag(struct se_portal_group *se_tpg) 3583 { 3584 struct ibmvscsis_tport *tport = 3585 container_of(se_tpg, struct ibmvscsis_tport, se_tpg); 3586 3587 return tport->tport_tpgt; 3588 } 3589 3590 static u32 ibmvscsis_get_default_depth(struct se_portal_group *se_tpg) 3591 { 3592 return 1; 3593 } 3594 3595 static int ibmvscsis_check_true(struct se_portal_group *se_tpg) 3596 { 3597 return 1; 3598 } 3599 3600 static int ibmvscsis_check_false(struct se_portal_group *se_tpg) 3601 { 3602 return 0; 3603 } 3604 3605 static u32 ibmvscsis_tpg_get_inst_index(struct se_portal_group *se_tpg) 3606 { 3607 return 1; 3608 } 3609 3610 static int ibmvscsis_check_stop_free(struct se_cmd *se_cmd) 3611 { 3612 return target_put_sess_cmd(se_cmd); 3613 } 3614 3615 static void ibmvscsis_release_cmd(struct se_cmd *se_cmd) 3616 { 3617 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3618 se_cmd); 3619 struct scsi_info *vscsi = cmd->adapter; 3620 3621 spin_lock_bh(&vscsi->intr_lock); 3622 /* Remove from active_q */ 3623 list_move_tail(&cmd->list, &vscsi->waiting_rsp); 3624 ibmvscsis_send_messages(vscsi); 3625 spin_unlock_bh(&vscsi->intr_lock); 3626 } 3627 3628 static u32 ibmvscsis_sess_get_index(struct se_session *se_sess) 3629 { 3630 return 0; 3631 } 3632 3633 static int ibmvscsis_write_pending(struct se_cmd *se_cmd) 3634 { 3635 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3636 se_cmd); 3637 struct scsi_info *vscsi = cmd->adapter; 3638 struct iu_entry *iue = cmd->iue; 3639 int rc; 3640 3641 /* 3642 * If CLIENT_FAILED OR RESPONSE_Q_DOWN, then just return success 3643 * since LIO can't do anything about it, and we dont want to 3644 * attempt an srp_transfer_data. 3645 */ 3646 if ((vscsi->flags & (CLIENT_FAILED | RESPONSE_Q_DOWN))) { 3647 pr_err("write_pending failed since: %d\n", vscsi->flags); 3648 return 0; 3649 } 3650 3651 rc = srp_transfer_data(cmd, &vio_iu(iue)->srp.cmd, ibmvscsis_rdma, 3652 1, 1); 3653 if (rc) { 3654 pr_err("srp_transfer_data() failed: %d\n", rc); 3655 return -EIO; 3656 } 3657 /* 3658 * We now tell TCM to add this WRITE CDB directly into the TCM storage 3659 * object execution queue. 3660 */ 3661 target_execute_cmd(se_cmd); 3662 return 0; 3663 } 3664 3665 static int ibmvscsis_write_pending_status(struct se_cmd *se_cmd) 3666 { 3667 return 0; 3668 } 3669 3670 static void ibmvscsis_set_default_node_attrs(struct se_node_acl *nacl) 3671 { 3672 } 3673 3674 static int ibmvscsis_get_cmd_state(struct se_cmd *se_cmd) 3675 { 3676 return 0; 3677 } 3678 3679 static int ibmvscsis_queue_data_in(struct se_cmd *se_cmd) 3680 { 3681 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3682 se_cmd); 3683 struct iu_entry *iue = cmd->iue; 3684 struct scsi_info *vscsi = cmd->adapter; 3685 char *sd; 3686 uint len = 0; 3687 int rc; 3688 3689 rc = srp_transfer_data(cmd, &vio_iu(iue)->srp.cmd, ibmvscsis_rdma, 1, 3690 1); 3691 if (rc) { 3692 pr_err("srp_transfer_data failed: %d\n", rc); 3693 sd = se_cmd->sense_buffer; 3694 se_cmd->scsi_sense_length = 18; 3695 memset(se_cmd->sense_buffer, 0, se_cmd->scsi_sense_length); 3696 /* Logical Unit Communication Time-out asc/ascq = 0x0801 */ 3697 scsi_build_sense_buffer(0, se_cmd->sense_buffer, MEDIUM_ERROR, 3698 0x08, 0x01); 3699 } 3700 3701 srp_build_response(vscsi, cmd, &len); 3702 cmd->rsp.format = SRP_FORMAT; 3703 cmd->rsp.len = len; 3704 3705 return 0; 3706 } 3707 3708 static int ibmvscsis_queue_status(struct se_cmd *se_cmd) 3709 { 3710 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3711 se_cmd); 3712 struct scsi_info *vscsi = cmd->adapter; 3713 uint len; 3714 3715 pr_debug("queue_status %p\n", se_cmd); 3716 3717 srp_build_response(vscsi, cmd, &len); 3718 cmd->rsp.format = SRP_FORMAT; 3719 cmd->rsp.len = len; 3720 3721 return 0; 3722 } 3723 3724 static void ibmvscsis_queue_tm_rsp(struct se_cmd *se_cmd) 3725 { 3726 struct ibmvscsis_cmd *cmd = container_of(se_cmd, struct ibmvscsis_cmd, 3727 se_cmd); 3728 struct scsi_info *vscsi = cmd->adapter; 3729 struct ibmvscsis_cmd *cmd_itr; 3730 struct iu_entry *iue = iue = cmd->iue; 3731 struct srp_tsk_mgmt *srp_tsk = &vio_iu(iue)->srp.tsk_mgmt; 3732 u64 tag_to_abort = be64_to_cpu(srp_tsk->task_tag); 3733 uint len; 3734 3735 pr_debug("queue_tm_rsp %p, status %d\n", 3736 se_cmd, (int)se_cmd->se_tmr_req->response); 3737 3738 if (srp_tsk->tsk_mgmt_func == SRP_TSK_ABORT_TASK && 3739 cmd->se_cmd.se_tmr_req->response == TMR_TASK_DOES_NOT_EXIST) { 3740 spin_lock_bh(&vscsi->intr_lock); 3741 list_for_each_entry(cmd_itr, &vscsi->active_q, list) { 3742 if (tag_to_abort == cmd_itr->se_cmd.tag) { 3743 cmd_itr->abort_cmd = cmd; 3744 cmd->flags |= DELAY_SEND; 3745 break; 3746 } 3747 } 3748 spin_unlock_bh(&vscsi->intr_lock); 3749 } 3750 3751 srp_build_response(vscsi, cmd, &len); 3752 cmd->rsp.format = SRP_FORMAT; 3753 cmd->rsp.len = len; 3754 } 3755 3756 static void ibmvscsis_aborted_task(struct se_cmd *se_cmd) 3757 { 3758 pr_debug("ibmvscsis_aborted_task %p task_tag: %llu\n", 3759 se_cmd, se_cmd->tag); 3760 } 3761 3762 static struct se_wwn *ibmvscsis_make_tport(struct target_fabric_configfs *tf, 3763 struct config_group *group, 3764 const char *name) 3765 { 3766 struct ibmvscsis_tport *tport; 3767 3768 tport = ibmvscsis_lookup_port(name); 3769 if (tport) { 3770 tport->tport_proto_id = SCSI_PROTOCOL_SRP; 3771 pr_debug("make_tport(%s), pointer:%p, tport_id:%x\n", 3772 name, tport, tport->tport_proto_id); 3773 return &tport->tport_wwn; 3774 } 3775 3776 return ERR_PTR(-EINVAL); 3777 } 3778 3779 static void ibmvscsis_drop_tport(struct se_wwn *wwn) 3780 { 3781 struct ibmvscsis_tport *tport = container_of(wwn, 3782 struct ibmvscsis_tport, 3783 tport_wwn); 3784 3785 pr_debug("drop_tport(%s)\n", 3786 config_item_name(&tport->tport_wwn.wwn_group.cg_item)); 3787 } 3788 3789 static struct se_portal_group *ibmvscsis_make_tpg(struct se_wwn *wwn, 3790 struct config_group *group, 3791 const char *name) 3792 { 3793 struct ibmvscsis_tport *tport = 3794 container_of(wwn, struct ibmvscsis_tport, tport_wwn); 3795 int rc; 3796 3797 tport->releasing = false; 3798 3799 rc = core_tpg_register(&tport->tport_wwn, &tport->se_tpg, 3800 tport->tport_proto_id); 3801 if (rc) 3802 return ERR_PTR(rc); 3803 3804 return &tport->se_tpg; 3805 } 3806 3807 static void ibmvscsis_drop_tpg(struct se_portal_group *se_tpg) 3808 { 3809 struct ibmvscsis_tport *tport = container_of(se_tpg, 3810 struct ibmvscsis_tport, 3811 se_tpg); 3812 3813 tport->releasing = true; 3814 tport->enabled = false; 3815 3816 /* 3817 * Release the virtual I_T Nexus for this ibmvscsis TPG 3818 */ 3819 ibmvscsis_drop_nexus(tport); 3820 /* 3821 * Deregister the se_tpg from TCM.. 3822 */ 3823 core_tpg_deregister(se_tpg); 3824 } 3825 3826 static ssize_t ibmvscsis_wwn_version_show(struct config_item *item, 3827 char *page) 3828 { 3829 return scnprintf(page, PAGE_SIZE, "%s\n", IBMVSCSIS_VERSION); 3830 } 3831 CONFIGFS_ATTR_RO(ibmvscsis_wwn_, version); 3832 3833 static struct configfs_attribute *ibmvscsis_wwn_attrs[] = { 3834 &ibmvscsis_wwn_attr_version, 3835 NULL, 3836 }; 3837 3838 static ssize_t ibmvscsis_tpg_enable_show(struct config_item *item, 3839 char *page) 3840 { 3841 struct se_portal_group *se_tpg = to_tpg(item); 3842 struct ibmvscsis_tport *tport = container_of(se_tpg, 3843 struct ibmvscsis_tport, 3844 se_tpg); 3845 3846 return snprintf(page, PAGE_SIZE, "%d\n", (tport->enabled) ? 1 : 0); 3847 } 3848 3849 static ssize_t ibmvscsis_tpg_enable_store(struct config_item *item, 3850 const char *page, size_t count) 3851 { 3852 struct se_portal_group *se_tpg = to_tpg(item); 3853 struct ibmvscsis_tport *tport = container_of(se_tpg, 3854 struct ibmvscsis_tport, 3855 se_tpg); 3856 struct scsi_info *vscsi = container_of(tport, struct scsi_info, tport); 3857 unsigned long tmp; 3858 int rc; 3859 long lrc; 3860 3861 rc = kstrtoul(page, 0, &tmp); 3862 if (rc < 0) { 3863 pr_err("Unable to extract srpt_tpg_store_enable\n"); 3864 return -EINVAL; 3865 } 3866 3867 if ((tmp != 0) && (tmp != 1)) { 3868 pr_err("Illegal value for srpt_tpg_store_enable\n"); 3869 return -EINVAL; 3870 } 3871 3872 if (tmp) { 3873 spin_lock_bh(&vscsi->intr_lock); 3874 tport->enabled = true; 3875 lrc = ibmvscsis_enable_change_state(vscsi); 3876 if (lrc) 3877 pr_err("enable_change_state failed, rc %ld state %d\n", 3878 lrc, vscsi->state); 3879 spin_unlock_bh(&vscsi->intr_lock); 3880 } else { 3881 spin_lock_bh(&vscsi->intr_lock); 3882 tport->enabled = false; 3883 /* This simulates the server going down */ 3884 ibmvscsis_post_disconnect(vscsi, ERR_DISCONNECT, 0); 3885 spin_unlock_bh(&vscsi->intr_lock); 3886 } 3887 3888 pr_debug("tpg_enable_store, tmp %ld, state %d\n", tmp, vscsi->state); 3889 3890 return count; 3891 } 3892 CONFIGFS_ATTR(ibmvscsis_tpg_, enable); 3893 3894 static struct configfs_attribute *ibmvscsis_tpg_attrs[] = { 3895 &ibmvscsis_tpg_attr_enable, 3896 NULL, 3897 }; 3898 3899 static const struct target_core_fabric_ops ibmvscsis_ops = { 3900 .module = THIS_MODULE, 3901 .name = "ibmvscsis", 3902 .max_data_sg_nents = MAX_TXU / PAGE_SIZE, 3903 .get_fabric_name = ibmvscsis_get_fabric_name, 3904 .tpg_get_wwn = ibmvscsis_get_fabric_wwn, 3905 .tpg_get_tag = ibmvscsis_get_tag, 3906 .tpg_get_default_depth = ibmvscsis_get_default_depth, 3907 .tpg_check_demo_mode = ibmvscsis_check_true, 3908 .tpg_check_demo_mode_cache = ibmvscsis_check_true, 3909 .tpg_check_demo_mode_write_protect = ibmvscsis_check_false, 3910 .tpg_check_prod_mode_write_protect = ibmvscsis_check_false, 3911 .tpg_get_inst_index = ibmvscsis_tpg_get_inst_index, 3912 .check_stop_free = ibmvscsis_check_stop_free, 3913 .release_cmd = ibmvscsis_release_cmd, 3914 .sess_get_index = ibmvscsis_sess_get_index, 3915 .write_pending = ibmvscsis_write_pending, 3916 .write_pending_status = ibmvscsis_write_pending_status, 3917 .set_default_node_attributes = ibmvscsis_set_default_node_attrs, 3918 .get_cmd_state = ibmvscsis_get_cmd_state, 3919 .queue_data_in = ibmvscsis_queue_data_in, 3920 .queue_status = ibmvscsis_queue_status, 3921 .queue_tm_rsp = ibmvscsis_queue_tm_rsp, 3922 .aborted_task = ibmvscsis_aborted_task, 3923 /* 3924 * Setup function pointers for logic in target_core_fabric_configfs.c 3925 */ 3926 .fabric_make_wwn = ibmvscsis_make_tport, 3927 .fabric_drop_wwn = ibmvscsis_drop_tport, 3928 .fabric_make_tpg = ibmvscsis_make_tpg, 3929 .fabric_drop_tpg = ibmvscsis_drop_tpg, 3930 3931 .tfc_wwn_attrs = ibmvscsis_wwn_attrs, 3932 .tfc_tpg_base_attrs = ibmvscsis_tpg_attrs, 3933 }; 3934 3935 static void ibmvscsis_dev_release(struct device *dev) {}; 3936 3937 static struct class_attribute ibmvscsis_class_attrs[] = { 3938 __ATTR_NULL, 3939 }; 3940 3941 static struct device_attribute dev_attr_system_id = 3942 __ATTR(system_id, S_IRUGO, system_id_show, NULL); 3943 3944 static struct device_attribute dev_attr_partition_number = 3945 __ATTR(partition_number, S_IRUGO, partition_number_show, NULL); 3946 3947 static struct device_attribute dev_attr_unit_address = 3948 __ATTR(unit_address, S_IRUGO, unit_address_show, NULL); 3949 3950 static struct attribute *ibmvscsis_dev_attrs[] = { 3951 &dev_attr_system_id.attr, 3952 &dev_attr_partition_number.attr, 3953 &dev_attr_unit_address.attr, 3954 }; 3955 ATTRIBUTE_GROUPS(ibmvscsis_dev); 3956 3957 static struct class ibmvscsis_class = { 3958 .name = "ibmvscsis", 3959 .dev_release = ibmvscsis_dev_release, 3960 .class_attrs = ibmvscsis_class_attrs, 3961 .dev_groups = ibmvscsis_dev_groups, 3962 }; 3963 3964 static struct vio_device_id ibmvscsis_device_table[] = { 3965 { "v-scsi-host", "IBM,v-scsi-host" }, 3966 { "", "" } 3967 }; 3968 MODULE_DEVICE_TABLE(vio, ibmvscsis_device_table); 3969 3970 static struct vio_driver ibmvscsis_driver = { 3971 .name = "ibmvscsis", 3972 .id_table = ibmvscsis_device_table, 3973 .probe = ibmvscsis_probe, 3974 .remove = ibmvscsis_remove, 3975 }; 3976 3977 /* 3978 * ibmvscsis_init() - Kernel Module initialization 3979 * 3980 * Note: vio_register_driver() registers callback functions, and at least one 3981 * of those callback functions calls TCM - Linux IO Target Subsystem, thus 3982 * the SCSI Target template must be registered before vio_register_driver() 3983 * is called. 3984 */ 3985 static int __init ibmvscsis_init(void) 3986 { 3987 int rc = 0; 3988 3989 rc = ibmvscsis_get_system_info(); 3990 if (rc) { 3991 pr_err("rc %d from get_system_info\n", rc); 3992 goto out; 3993 } 3994 3995 rc = class_register(&ibmvscsis_class); 3996 if (rc) { 3997 pr_err("failed class register\n"); 3998 goto out; 3999 } 4000 4001 rc = target_register_template(&ibmvscsis_ops); 4002 if (rc) { 4003 pr_err("rc %d from target_register_template\n", rc); 4004 goto unregister_class; 4005 } 4006 4007 rc = vio_register_driver(&ibmvscsis_driver); 4008 if (rc) { 4009 pr_err("rc %d from vio_register_driver\n", rc); 4010 goto unregister_target; 4011 } 4012 4013 return 0; 4014 4015 unregister_target: 4016 target_unregister_template(&ibmvscsis_ops); 4017 unregister_class: 4018 class_unregister(&ibmvscsis_class); 4019 out: 4020 return rc; 4021 } 4022 4023 static void __exit ibmvscsis_exit(void) 4024 { 4025 pr_info("Unregister IBM virtual SCSI host driver\n"); 4026 vio_unregister_driver(&ibmvscsis_driver); 4027 target_unregister_template(&ibmvscsis_ops); 4028 class_unregister(&ibmvscsis_class); 4029 } 4030 4031 MODULE_DESCRIPTION("IBMVSCSIS fabric driver"); 4032 MODULE_AUTHOR("Bryant G. Ly and Michael Cyr"); 4033 MODULE_LICENSE("GPL"); 4034 MODULE_VERSION(IBMVSCSIS_VERSION); 4035 module_init(ibmvscsis_init); 4036 module_exit(ibmvscsis_exit); 4037