1 /* 2 * Serial Attached SCSI (SAS) class SCSI Host glue. 3 * 4 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 5 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 6 * 7 * This file is licensed under GPLv2. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of the 12 * License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 22 * USA 23 * 24 */ 25 26 #include <linux/kthread.h> 27 #include <linux/firmware.h> 28 #include <linux/export.h> 29 #include <linux/ctype.h> 30 31 #include "sas_internal.h" 32 33 #include <scsi/scsi_host.h> 34 #include <scsi/scsi_device.h> 35 #include <scsi/scsi_tcq.h> 36 #include <scsi/scsi.h> 37 #include <scsi/scsi_eh.h> 38 #include <scsi/scsi_transport.h> 39 #include <scsi/scsi_transport_sas.h> 40 #include <scsi/sas_ata.h> 41 #include "../scsi_sas_internal.h" 42 #include "../scsi_transport_api.h" 43 #include "../scsi_priv.h" 44 45 #include <linux/err.h> 46 #include <linux/blkdev.h> 47 #include <linux/freezer.h> 48 #include <linux/gfp.h> 49 #include <linux/scatterlist.h> 50 #include <linux/libata.h> 51 52 /* record final status and free the task */ 53 static void sas_end_task(struct scsi_cmnd *sc, struct sas_task *task) 54 { 55 struct task_status_struct *ts = &task->task_status; 56 int hs = 0, stat = 0; 57 58 if (ts->resp == SAS_TASK_UNDELIVERED) { 59 /* transport error */ 60 hs = DID_NO_CONNECT; 61 } else { /* ts->resp == SAS_TASK_COMPLETE */ 62 /* task delivered, what happened afterwards? */ 63 switch (ts->stat) { 64 case SAS_DEV_NO_RESPONSE: 65 case SAS_INTERRUPTED: 66 case SAS_PHY_DOWN: 67 case SAS_NAK_R_ERR: 68 case SAS_OPEN_TO: 69 hs = DID_NO_CONNECT; 70 break; 71 case SAS_DATA_UNDERRUN: 72 scsi_set_resid(sc, ts->residual); 73 if (scsi_bufflen(sc) - scsi_get_resid(sc) < sc->underflow) 74 hs = DID_ERROR; 75 break; 76 case SAS_DATA_OVERRUN: 77 hs = DID_ERROR; 78 break; 79 case SAS_QUEUE_FULL: 80 hs = DID_SOFT_ERROR; /* retry */ 81 break; 82 case SAS_DEVICE_UNKNOWN: 83 hs = DID_BAD_TARGET; 84 break; 85 case SAS_SG_ERR: 86 hs = DID_PARITY; 87 break; 88 case SAS_OPEN_REJECT: 89 if (ts->open_rej_reason == SAS_OREJ_RSVD_RETRY) 90 hs = DID_SOFT_ERROR; /* retry */ 91 else 92 hs = DID_ERROR; 93 break; 94 case SAS_PROTO_RESPONSE: 95 SAS_DPRINTK("LLDD:%s sent SAS_PROTO_RESP for an SSP " 96 "task; please report this\n", 97 task->dev->port->ha->sas_ha_name); 98 break; 99 case SAS_ABORTED_TASK: 100 hs = DID_ABORT; 101 break; 102 case SAM_STAT_CHECK_CONDITION: 103 memcpy(sc->sense_buffer, ts->buf, 104 min(SCSI_SENSE_BUFFERSIZE, ts->buf_valid_size)); 105 stat = SAM_STAT_CHECK_CONDITION; 106 break; 107 default: 108 stat = ts->stat; 109 break; 110 } 111 } 112 113 sc->result = (hs << 16) | stat; 114 ASSIGN_SAS_TASK(sc, NULL); 115 list_del_init(&task->list); 116 sas_free_task(task); 117 } 118 119 static void sas_scsi_task_done(struct sas_task *task) 120 { 121 struct scsi_cmnd *sc = task->uldd_task; 122 struct domain_device *dev = task->dev; 123 struct sas_ha_struct *ha = dev->port->ha; 124 unsigned long flags; 125 126 spin_lock_irqsave(&dev->done_lock, flags); 127 if (test_bit(SAS_HA_FROZEN, &ha->state)) 128 task = NULL; 129 else 130 ASSIGN_SAS_TASK(sc, NULL); 131 spin_unlock_irqrestore(&dev->done_lock, flags); 132 133 if (unlikely(!task)) { 134 /* task will be completed by the error handler */ 135 SAS_DPRINTK("task done but aborted\n"); 136 return; 137 } 138 139 if (unlikely(!sc)) { 140 SAS_DPRINTK("task_done called with non existing SCSI cmnd!\n"); 141 list_del_init(&task->list); 142 sas_free_task(task); 143 return; 144 } 145 146 sas_end_task(sc, task); 147 sc->scsi_done(sc); 148 } 149 150 static struct sas_task *sas_create_task(struct scsi_cmnd *cmd, 151 struct domain_device *dev, 152 gfp_t gfp_flags) 153 { 154 struct sas_task *task = sas_alloc_task(gfp_flags); 155 struct scsi_lun lun; 156 157 if (!task) 158 return NULL; 159 160 task->uldd_task = cmd; 161 ASSIGN_SAS_TASK(cmd, task); 162 163 task->dev = dev; 164 task->task_proto = task->dev->tproto; /* BUG_ON(!SSP) */ 165 166 task->ssp_task.retry_count = 1; 167 int_to_scsilun(cmd->device->lun, &lun); 168 memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8); 169 task->ssp_task.task_attr = TASK_ATTR_SIMPLE; 170 task->ssp_task.cmd = cmd; 171 172 task->scatter = scsi_sglist(cmd); 173 task->num_scatter = scsi_sg_count(cmd); 174 task->total_xfer_len = scsi_bufflen(cmd); 175 task->data_dir = cmd->sc_data_direction; 176 177 task->task_done = sas_scsi_task_done; 178 179 return task; 180 } 181 182 int sas_queue_up(struct sas_task *task) 183 { 184 struct sas_ha_struct *sas_ha = task->dev->port->ha; 185 struct scsi_core *core = &sas_ha->core; 186 unsigned long flags; 187 LIST_HEAD(list); 188 189 spin_lock_irqsave(&core->task_queue_lock, flags); 190 if (sas_ha->lldd_queue_size < core->task_queue_size + 1) { 191 spin_unlock_irqrestore(&core->task_queue_lock, flags); 192 return -SAS_QUEUE_FULL; 193 } 194 list_add_tail(&task->list, &core->task_queue); 195 core->task_queue_size += 1; 196 spin_unlock_irqrestore(&core->task_queue_lock, flags); 197 wake_up_process(core->queue_thread); 198 199 return 0; 200 } 201 202 int sas_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd) 203 { 204 struct sas_internal *i = to_sas_internal(host->transportt); 205 struct domain_device *dev = cmd_to_domain_dev(cmd); 206 struct sas_ha_struct *sas_ha = dev->port->ha; 207 struct sas_task *task; 208 int res = 0; 209 210 /* If the device fell off, no sense in issuing commands */ 211 if (test_bit(SAS_DEV_GONE, &dev->state)) { 212 cmd->result = DID_BAD_TARGET << 16; 213 goto out_done; 214 } 215 216 if (dev_is_sata(dev)) { 217 spin_lock_irq(dev->sata_dev.ap->lock); 218 res = ata_sas_queuecmd(cmd, dev->sata_dev.ap); 219 spin_unlock_irq(dev->sata_dev.ap->lock); 220 return res; 221 } 222 223 task = sas_create_task(cmd, dev, GFP_ATOMIC); 224 if (!task) 225 return SCSI_MLQUEUE_HOST_BUSY; 226 227 /* Queue up, Direct Mode or Task Collector Mode. */ 228 if (sas_ha->lldd_max_execute_num < 2) 229 res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC); 230 else 231 res = sas_queue_up(task); 232 233 if (res) 234 goto out_free_task; 235 return 0; 236 237 out_free_task: 238 SAS_DPRINTK("lldd_execute_task returned: %d\n", res); 239 ASSIGN_SAS_TASK(cmd, NULL); 240 sas_free_task(task); 241 if (res == -SAS_QUEUE_FULL) 242 cmd->result = DID_SOFT_ERROR << 16; /* retry */ 243 else 244 cmd->result = DID_ERROR << 16; 245 out_done: 246 cmd->scsi_done(cmd); 247 return 0; 248 } 249 250 static void sas_eh_finish_cmd(struct scsi_cmnd *cmd) 251 { 252 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(cmd->device->host); 253 struct sas_task *task = TO_SAS_TASK(cmd); 254 255 /* At this point, we only get called following an actual abort 256 * of the task, so we should be guaranteed not to be racing with 257 * any completions from the LLD. Task is freed after this. 258 */ 259 sas_end_task(cmd, task); 260 261 /* now finish the command and move it on to the error 262 * handler done list, this also takes it off the 263 * error handler pending list. 264 */ 265 scsi_eh_finish_cmd(cmd, &sas_ha->eh_done_q); 266 } 267 268 static void sas_eh_defer_cmd(struct scsi_cmnd *cmd) 269 { 270 struct domain_device *dev = cmd_to_domain_dev(cmd); 271 struct sas_ha_struct *ha = dev->port->ha; 272 struct sas_task *task = TO_SAS_TASK(cmd); 273 274 if (!dev_is_sata(dev)) { 275 sas_eh_finish_cmd(cmd); 276 return; 277 } 278 279 /* report the timeout to libata */ 280 sas_end_task(cmd, task); 281 list_move_tail(&cmd->eh_entry, &ha->eh_ata_q); 282 } 283 284 static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd) 285 { 286 struct scsi_cmnd *cmd, *n; 287 288 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 289 if (cmd->device->sdev_target == my_cmd->device->sdev_target && 290 cmd->device->lun == my_cmd->device->lun) 291 sas_eh_defer_cmd(cmd); 292 } 293 } 294 295 static void sas_scsi_clear_queue_I_T(struct list_head *error_q, 296 struct domain_device *dev) 297 { 298 struct scsi_cmnd *cmd, *n; 299 300 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 301 struct domain_device *x = cmd_to_domain_dev(cmd); 302 303 if (x == dev) 304 sas_eh_finish_cmd(cmd); 305 } 306 } 307 308 static void sas_scsi_clear_queue_port(struct list_head *error_q, 309 struct asd_sas_port *port) 310 { 311 struct scsi_cmnd *cmd, *n; 312 313 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 314 struct domain_device *dev = cmd_to_domain_dev(cmd); 315 struct asd_sas_port *x = dev->port; 316 317 if (x == port) 318 sas_eh_finish_cmd(cmd); 319 } 320 } 321 322 enum task_disposition { 323 TASK_IS_DONE, 324 TASK_IS_ABORTED, 325 TASK_IS_AT_LU, 326 TASK_IS_NOT_AT_HA, 327 TASK_IS_NOT_AT_LU, 328 TASK_ABORT_FAILED, 329 }; 330 331 static enum task_disposition sas_scsi_find_task(struct sas_task *task) 332 { 333 struct sas_ha_struct *ha = task->dev->port->ha; 334 unsigned long flags; 335 int i, res; 336 struct sas_internal *si = 337 to_sas_internal(task->dev->port->ha->core.shost->transportt); 338 339 if (ha->lldd_max_execute_num > 1) { 340 struct scsi_core *core = &ha->core; 341 struct sas_task *t, *n; 342 343 mutex_lock(&core->task_queue_flush); 344 spin_lock_irqsave(&core->task_queue_lock, flags); 345 list_for_each_entry_safe(t, n, &core->task_queue, list) 346 if (task == t) { 347 list_del_init(&t->list); 348 break; 349 } 350 spin_unlock_irqrestore(&core->task_queue_lock, flags); 351 mutex_unlock(&core->task_queue_flush); 352 353 if (task == t) 354 return TASK_IS_NOT_AT_HA; 355 } 356 357 for (i = 0; i < 5; i++) { 358 SAS_DPRINTK("%s: aborting task 0x%p\n", __func__, task); 359 res = si->dft->lldd_abort_task(task); 360 361 spin_lock_irqsave(&task->task_state_lock, flags); 362 if (task->task_state_flags & SAS_TASK_STATE_DONE) { 363 spin_unlock_irqrestore(&task->task_state_lock, flags); 364 SAS_DPRINTK("%s: task 0x%p is done\n", __func__, 365 task); 366 return TASK_IS_DONE; 367 } 368 spin_unlock_irqrestore(&task->task_state_lock, flags); 369 370 if (res == TMF_RESP_FUNC_COMPLETE) { 371 SAS_DPRINTK("%s: task 0x%p is aborted\n", 372 __func__, task); 373 return TASK_IS_ABORTED; 374 } else if (si->dft->lldd_query_task) { 375 SAS_DPRINTK("%s: querying task 0x%p\n", 376 __func__, task); 377 res = si->dft->lldd_query_task(task); 378 switch (res) { 379 case TMF_RESP_FUNC_SUCC: 380 SAS_DPRINTK("%s: task 0x%p at LU\n", 381 __func__, task); 382 return TASK_IS_AT_LU; 383 case TMF_RESP_FUNC_COMPLETE: 384 SAS_DPRINTK("%s: task 0x%p not at LU\n", 385 __func__, task); 386 return TASK_IS_NOT_AT_LU; 387 case TMF_RESP_FUNC_FAILED: 388 SAS_DPRINTK("%s: task 0x%p failed to abort\n", 389 __func__, task); 390 return TASK_ABORT_FAILED; 391 } 392 393 } 394 } 395 return res; 396 } 397 398 static int sas_recover_lu(struct domain_device *dev, struct scsi_cmnd *cmd) 399 { 400 int res = TMF_RESP_FUNC_FAILED; 401 struct scsi_lun lun; 402 struct sas_internal *i = 403 to_sas_internal(dev->port->ha->core.shost->transportt); 404 405 int_to_scsilun(cmd->device->lun, &lun); 406 407 SAS_DPRINTK("eh: device %llx LUN %llx has the task\n", 408 SAS_ADDR(dev->sas_addr), 409 cmd->device->lun); 410 411 if (i->dft->lldd_abort_task_set) 412 res = i->dft->lldd_abort_task_set(dev, lun.scsi_lun); 413 414 if (res == TMF_RESP_FUNC_FAILED) { 415 if (i->dft->lldd_clear_task_set) 416 res = i->dft->lldd_clear_task_set(dev, lun.scsi_lun); 417 } 418 419 if (res == TMF_RESP_FUNC_FAILED) { 420 if (i->dft->lldd_lu_reset) 421 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 422 } 423 424 return res; 425 } 426 427 static int sas_recover_I_T(struct domain_device *dev) 428 { 429 int res = TMF_RESP_FUNC_FAILED; 430 struct sas_internal *i = 431 to_sas_internal(dev->port->ha->core.shost->transportt); 432 433 SAS_DPRINTK("I_T nexus reset for dev %016llx\n", 434 SAS_ADDR(dev->sas_addr)); 435 436 if (i->dft->lldd_I_T_nexus_reset) 437 res = i->dft->lldd_I_T_nexus_reset(dev); 438 439 return res; 440 } 441 442 /* take a reference on the last known good phy for this device */ 443 struct sas_phy *sas_get_local_phy(struct domain_device *dev) 444 { 445 struct sas_ha_struct *ha = dev->port->ha; 446 struct sas_phy *phy; 447 unsigned long flags; 448 449 /* a published domain device always has a valid phy, it may be 450 * stale, but it is never NULL 451 */ 452 BUG_ON(!dev->phy); 453 454 spin_lock_irqsave(&ha->phy_port_lock, flags); 455 phy = dev->phy; 456 get_device(&phy->dev); 457 spin_unlock_irqrestore(&ha->phy_port_lock, flags); 458 459 return phy; 460 } 461 EXPORT_SYMBOL_GPL(sas_get_local_phy); 462 463 static void sas_wait_eh(struct domain_device *dev) 464 { 465 struct sas_ha_struct *ha = dev->port->ha; 466 DEFINE_WAIT(wait); 467 468 if (dev_is_sata(dev)) { 469 ata_port_wait_eh(dev->sata_dev.ap); 470 return; 471 } 472 retry: 473 spin_lock_irq(&ha->lock); 474 475 while (test_bit(SAS_DEV_EH_PENDING, &dev->state)) { 476 prepare_to_wait(&ha->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE); 477 spin_unlock_irq(&ha->lock); 478 schedule(); 479 spin_lock_irq(&ha->lock); 480 } 481 finish_wait(&ha->eh_wait_q, &wait); 482 483 spin_unlock_irq(&ha->lock); 484 485 /* make sure SCSI EH is complete */ 486 if (scsi_host_in_recovery(ha->core.shost)) { 487 msleep(10); 488 goto retry; 489 } 490 } 491 EXPORT_SYMBOL(sas_wait_eh); 492 493 static int sas_queue_reset(struct domain_device *dev, int reset_type, 494 u64 lun, int wait) 495 { 496 struct sas_ha_struct *ha = dev->port->ha; 497 int scheduled = 0, tries = 100; 498 499 /* ata: promote lun reset to bus reset */ 500 if (dev_is_sata(dev)) { 501 sas_ata_schedule_reset(dev); 502 if (wait) 503 sas_ata_wait_eh(dev); 504 return SUCCESS; 505 } 506 507 while (!scheduled && tries--) { 508 spin_lock_irq(&ha->lock); 509 if (!test_bit(SAS_DEV_EH_PENDING, &dev->state) && 510 !test_bit(reset_type, &dev->state)) { 511 scheduled = 1; 512 ha->eh_active++; 513 list_add_tail(&dev->ssp_dev.eh_list_node, &ha->eh_dev_q); 514 set_bit(SAS_DEV_EH_PENDING, &dev->state); 515 set_bit(reset_type, &dev->state); 516 int_to_scsilun(lun, &dev->ssp_dev.reset_lun); 517 scsi_schedule_eh(ha->core.shost); 518 } 519 spin_unlock_irq(&ha->lock); 520 521 if (wait) 522 sas_wait_eh(dev); 523 524 if (scheduled) 525 return SUCCESS; 526 } 527 528 SAS_DPRINTK("%s reset of %s failed\n", 529 reset_type == SAS_DEV_LU_RESET ? "LUN" : "Bus", 530 dev_name(&dev->rphy->dev)); 531 532 return FAILED; 533 } 534 535 int sas_eh_abort_handler(struct scsi_cmnd *cmd) 536 { 537 int res; 538 struct sas_task *task = TO_SAS_TASK(cmd); 539 struct Scsi_Host *host = cmd->device->host; 540 struct sas_internal *i = to_sas_internal(host->transportt); 541 542 if (current != host->ehandler) 543 return FAILED; 544 545 if (!i->dft->lldd_abort_task) 546 return FAILED; 547 548 res = i->dft->lldd_abort_task(task); 549 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 550 return SUCCESS; 551 552 return FAILED; 553 } 554 EXPORT_SYMBOL_GPL(sas_eh_abort_handler); 555 556 /* Attempt to send a LUN reset message to a device */ 557 int sas_eh_device_reset_handler(struct scsi_cmnd *cmd) 558 { 559 int res; 560 struct scsi_lun lun; 561 struct Scsi_Host *host = cmd->device->host; 562 struct domain_device *dev = cmd_to_domain_dev(cmd); 563 struct sas_internal *i = to_sas_internal(host->transportt); 564 565 if (current != host->ehandler) 566 return sas_queue_reset(dev, SAS_DEV_LU_RESET, cmd->device->lun, 0); 567 568 int_to_scsilun(cmd->device->lun, &lun); 569 570 if (!i->dft->lldd_lu_reset) 571 return FAILED; 572 573 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 574 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 575 return SUCCESS; 576 577 return FAILED; 578 } 579 580 int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd) 581 { 582 int res; 583 struct Scsi_Host *host = cmd->device->host; 584 struct domain_device *dev = cmd_to_domain_dev(cmd); 585 struct sas_internal *i = to_sas_internal(host->transportt); 586 587 if (current != host->ehandler) 588 return sas_queue_reset(dev, SAS_DEV_RESET, 0, 0); 589 590 if (!i->dft->lldd_I_T_nexus_reset) 591 return FAILED; 592 593 res = i->dft->lldd_I_T_nexus_reset(dev); 594 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE || 595 res == -ENODEV) 596 return SUCCESS; 597 598 return FAILED; 599 } 600 601 /* Try to reset a device */ 602 static int try_to_reset_cmd_device(struct scsi_cmnd *cmd) 603 { 604 int res; 605 struct Scsi_Host *shost = cmd->device->host; 606 607 if (!shost->hostt->eh_device_reset_handler) 608 goto try_bus_reset; 609 610 res = shost->hostt->eh_device_reset_handler(cmd); 611 if (res == SUCCESS) 612 return res; 613 614 try_bus_reset: 615 if (shost->hostt->eh_bus_reset_handler) 616 return shost->hostt->eh_bus_reset_handler(cmd); 617 618 return FAILED; 619 } 620 621 static void sas_eh_handle_sas_errors(struct Scsi_Host *shost, struct list_head *work_q) 622 { 623 struct scsi_cmnd *cmd, *n; 624 enum task_disposition res = TASK_IS_DONE; 625 int tmf_resp, need_reset; 626 struct sas_internal *i = to_sas_internal(shost->transportt); 627 unsigned long flags; 628 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 629 LIST_HEAD(done); 630 631 /* clean out any commands that won the completion vs eh race */ 632 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 633 struct domain_device *dev = cmd_to_domain_dev(cmd); 634 struct sas_task *task; 635 636 spin_lock_irqsave(&dev->done_lock, flags); 637 /* by this point the lldd has either observed 638 * SAS_HA_FROZEN and is leaving the task alone, or has 639 * won the race with eh and decided to complete it 640 */ 641 task = TO_SAS_TASK(cmd); 642 spin_unlock_irqrestore(&dev->done_lock, flags); 643 644 if (!task) 645 list_move_tail(&cmd->eh_entry, &done); 646 } 647 648 Again: 649 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 650 struct sas_task *task = TO_SAS_TASK(cmd); 651 652 list_del_init(&cmd->eh_entry); 653 654 spin_lock_irqsave(&task->task_state_lock, flags); 655 need_reset = task->task_state_flags & SAS_TASK_NEED_DEV_RESET; 656 spin_unlock_irqrestore(&task->task_state_lock, flags); 657 658 if (need_reset) { 659 SAS_DPRINTK("%s: task 0x%p requests reset\n", 660 __func__, task); 661 goto reset; 662 } 663 664 SAS_DPRINTK("trying to find task 0x%p\n", task); 665 res = sas_scsi_find_task(task); 666 667 cmd->eh_eflags = 0; 668 669 switch (res) { 670 case TASK_IS_NOT_AT_HA: 671 SAS_DPRINTK("%s: task 0x%p is not at ha: %s\n", 672 __func__, task, 673 cmd->retries ? "retry" : "aborted"); 674 if (cmd->retries) 675 cmd->retries--; 676 sas_eh_finish_cmd(cmd); 677 continue; 678 case TASK_IS_DONE: 679 SAS_DPRINTK("%s: task 0x%p is done\n", __func__, 680 task); 681 sas_eh_defer_cmd(cmd); 682 continue; 683 case TASK_IS_ABORTED: 684 SAS_DPRINTK("%s: task 0x%p is aborted\n", 685 __func__, task); 686 sas_eh_defer_cmd(cmd); 687 continue; 688 case TASK_IS_AT_LU: 689 SAS_DPRINTK("task 0x%p is at LU: lu recover\n", task); 690 reset: 691 tmf_resp = sas_recover_lu(task->dev, cmd); 692 if (tmf_resp == TMF_RESP_FUNC_COMPLETE) { 693 SAS_DPRINTK("dev %016llx LU %llx is " 694 "recovered\n", 695 SAS_ADDR(task->dev), 696 cmd->device->lun); 697 sas_eh_defer_cmd(cmd); 698 sas_scsi_clear_queue_lu(work_q, cmd); 699 goto Again; 700 } 701 /* fallthrough */ 702 case TASK_IS_NOT_AT_LU: 703 case TASK_ABORT_FAILED: 704 SAS_DPRINTK("task 0x%p is not at LU: I_T recover\n", 705 task); 706 tmf_resp = sas_recover_I_T(task->dev); 707 if (tmf_resp == TMF_RESP_FUNC_COMPLETE || 708 tmf_resp == -ENODEV) { 709 struct domain_device *dev = task->dev; 710 SAS_DPRINTK("I_T %016llx recovered\n", 711 SAS_ADDR(task->dev->sas_addr)); 712 sas_eh_finish_cmd(cmd); 713 sas_scsi_clear_queue_I_T(work_q, dev); 714 goto Again; 715 } 716 /* Hammer time :-) */ 717 try_to_reset_cmd_device(cmd); 718 if (i->dft->lldd_clear_nexus_port) { 719 struct asd_sas_port *port = task->dev->port; 720 SAS_DPRINTK("clearing nexus for port:%d\n", 721 port->id); 722 res = i->dft->lldd_clear_nexus_port(port); 723 if (res == TMF_RESP_FUNC_COMPLETE) { 724 SAS_DPRINTK("clear nexus port:%d " 725 "succeeded\n", port->id); 726 sas_eh_finish_cmd(cmd); 727 sas_scsi_clear_queue_port(work_q, 728 port); 729 goto Again; 730 } 731 } 732 if (i->dft->lldd_clear_nexus_ha) { 733 SAS_DPRINTK("clear nexus ha\n"); 734 res = i->dft->lldd_clear_nexus_ha(ha); 735 if (res == TMF_RESP_FUNC_COMPLETE) { 736 SAS_DPRINTK("clear nexus ha " 737 "succeeded\n"); 738 sas_eh_finish_cmd(cmd); 739 goto clear_q; 740 } 741 } 742 /* If we are here -- this means that no amount 743 * of effort could recover from errors. Quite 744 * possibly the HA just disappeared. 745 */ 746 SAS_DPRINTK("error from device %llx, LUN %llx " 747 "couldn't be recovered in any way\n", 748 SAS_ADDR(task->dev->sas_addr), 749 cmd->device->lun); 750 751 sas_eh_finish_cmd(cmd); 752 goto clear_q; 753 } 754 } 755 out: 756 list_splice_tail(&done, work_q); 757 list_splice_tail_init(&ha->eh_ata_q, work_q); 758 return; 759 760 clear_q: 761 SAS_DPRINTK("--- Exit %s -- clear_q\n", __func__); 762 list_for_each_entry_safe(cmd, n, work_q, eh_entry) 763 sas_eh_finish_cmd(cmd); 764 goto out; 765 } 766 767 static void sas_eh_handle_resets(struct Scsi_Host *shost) 768 { 769 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 770 struct sas_internal *i = to_sas_internal(shost->transportt); 771 772 /* handle directed resets to sas devices */ 773 spin_lock_irq(&ha->lock); 774 while (!list_empty(&ha->eh_dev_q)) { 775 struct domain_device *dev; 776 struct ssp_device *ssp; 777 778 ssp = list_entry(ha->eh_dev_q.next, typeof(*ssp), eh_list_node); 779 list_del_init(&ssp->eh_list_node); 780 dev = container_of(ssp, typeof(*dev), ssp_dev); 781 kref_get(&dev->kref); 782 WARN_ONCE(dev_is_sata(dev), "ssp reset to ata device?\n"); 783 784 spin_unlock_irq(&ha->lock); 785 786 if (test_and_clear_bit(SAS_DEV_LU_RESET, &dev->state)) 787 i->dft->lldd_lu_reset(dev, ssp->reset_lun.scsi_lun); 788 789 if (test_and_clear_bit(SAS_DEV_RESET, &dev->state)) 790 i->dft->lldd_I_T_nexus_reset(dev); 791 792 sas_put_device(dev); 793 spin_lock_irq(&ha->lock); 794 clear_bit(SAS_DEV_EH_PENDING, &dev->state); 795 ha->eh_active--; 796 } 797 spin_unlock_irq(&ha->lock); 798 } 799 800 801 void sas_scsi_recover_host(struct Scsi_Host *shost) 802 { 803 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 804 LIST_HEAD(eh_work_q); 805 int tries = 0; 806 bool retry; 807 808 retry: 809 tries++; 810 retry = true; 811 spin_lock_irq(shost->host_lock); 812 list_splice_init(&shost->eh_cmd_q, &eh_work_q); 813 spin_unlock_irq(shost->host_lock); 814 815 SAS_DPRINTK("Enter %s busy: %d failed: %d\n", 816 __func__, atomic_read(&shost->host_busy), shost->host_failed); 817 /* 818 * Deal with commands that still have SAS tasks (i.e. they didn't 819 * complete via the normal sas_task completion mechanism), 820 * SAS_HA_FROZEN gives eh dominion over all sas_task completion. 821 */ 822 set_bit(SAS_HA_FROZEN, &ha->state); 823 sas_eh_handle_sas_errors(shost, &eh_work_q); 824 clear_bit(SAS_HA_FROZEN, &ha->state); 825 if (list_empty(&eh_work_q)) 826 goto out; 827 828 /* 829 * Now deal with SCSI commands that completed ok but have a an error 830 * code (and hopefully sense data) attached. This is roughly what 831 * scsi_unjam_host does, but we skip scsi_eh_abort_cmds because any 832 * command we see here has no sas_task and is thus unknown to the HA. 833 */ 834 sas_ata_eh(shost, &eh_work_q, &ha->eh_done_q); 835 if (!scsi_eh_get_sense(&eh_work_q, &ha->eh_done_q)) 836 scsi_eh_ready_devs(shost, &eh_work_q, &ha->eh_done_q); 837 838 out: 839 if (ha->lldd_max_execute_num > 1) 840 wake_up_process(ha->core.queue_thread); 841 842 sas_eh_handle_resets(shost); 843 844 /* now link into libata eh --- if we have any ata devices */ 845 sas_ata_strategy_handler(shost); 846 847 scsi_eh_flush_done_q(&ha->eh_done_q); 848 849 /* check if any new eh work was scheduled during the last run */ 850 spin_lock_irq(&ha->lock); 851 if (ha->eh_active == 0) { 852 shost->host_eh_scheduled = 0; 853 retry = false; 854 } 855 spin_unlock_irq(&ha->lock); 856 857 if (retry) 858 goto retry; 859 860 SAS_DPRINTK("--- Exit %s: busy: %d failed: %d tries: %d\n", 861 __func__, atomic_read(&shost->host_busy), 862 shost->host_failed, tries); 863 } 864 865 enum blk_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd) 866 { 867 scmd_dbg(cmd, "command %p timed out\n", cmd); 868 869 return BLK_EH_NOT_HANDLED; 870 } 871 872 int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg) 873 { 874 struct domain_device *dev = sdev_to_domain_dev(sdev); 875 876 if (dev_is_sata(dev)) 877 return ata_sas_scsi_ioctl(dev->sata_dev.ap, sdev, cmd, arg); 878 879 return -EINVAL; 880 } 881 882 struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy) 883 { 884 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent); 885 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 886 struct domain_device *found_dev = NULL; 887 int i; 888 unsigned long flags; 889 890 spin_lock_irqsave(&ha->phy_port_lock, flags); 891 for (i = 0; i < ha->num_phys; i++) { 892 struct asd_sas_port *port = ha->sas_port[i]; 893 struct domain_device *dev; 894 895 spin_lock(&port->dev_list_lock); 896 list_for_each_entry(dev, &port->dev_list, dev_list_node) { 897 if (rphy == dev->rphy) { 898 found_dev = dev; 899 spin_unlock(&port->dev_list_lock); 900 goto found; 901 } 902 } 903 spin_unlock(&port->dev_list_lock); 904 } 905 found: 906 spin_unlock_irqrestore(&ha->phy_port_lock, flags); 907 908 return found_dev; 909 } 910 911 int sas_target_alloc(struct scsi_target *starget) 912 { 913 struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent); 914 struct domain_device *found_dev = sas_find_dev_by_rphy(rphy); 915 916 if (!found_dev) 917 return -ENODEV; 918 919 kref_get(&found_dev->kref); 920 starget->hostdata = found_dev; 921 return 0; 922 } 923 924 #define SAS_DEF_QD 256 925 926 int sas_slave_configure(struct scsi_device *scsi_dev) 927 { 928 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 929 struct sas_ha_struct *sas_ha; 930 931 BUG_ON(dev->rphy->identify.device_type != SAS_END_DEVICE); 932 933 if (dev_is_sata(dev)) { 934 ata_sas_slave_configure(scsi_dev, dev->sata_dev.ap); 935 return 0; 936 } 937 938 sas_ha = dev->port->ha; 939 940 sas_read_port_mode_page(scsi_dev); 941 942 if (scsi_dev->tagged_supported) { 943 scsi_set_tag_type(scsi_dev, MSG_SIMPLE_TAG); 944 scsi_activate_tcq(scsi_dev, SAS_DEF_QD); 945 } else { 946 SAS_DPRINTK("device %llx, LUN %llx doesn't support " 947 "TCQ\n", SAS_ADDR(dev->sas_addr), 948 scsi_dev->lun); 949 scsi_dev->tagged_supported = 0; 950 scsi_set_tag_type(scsi_dev, 0); 951 scsi_deactivate_tcq(scsi_dev, 1); 952 } 953 954 scsi_dev->allow_restart = 1; 955 956 return 0; 957 } 958 959 int sas_change_queue_depth(struct scsi_device *sdev, int depth, int reason) 960 { 961 struct domain_device *dev = sdev_to_domain_dev(sdev); 962 963 if (dev_is_sata(dev)) 964 return __ata_change_queue_depth(dev->sata_dev.ap, sdev, depth, 965 reason); 966 967 switch (reason) { 968 case SCSI_QDEPTH_DEFAULT: 969 case SCSI_QDEPTH_RAMP_UP: 970 if (!sdev->tagged_supported) 971 depth = 1; 972 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 973 break; 974 case SCSI_QDEPTH_QFULL: 975 scsi_track_queue_full(sdev, depth); 976 break; 977 default: 978 return -EOPNOTSUPP; 979 } 980 981 return depth; 982 } 983 984 int sas_change_queue_type(struct scsi_device *scsi_dev, int qt) 985 { 986 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 987 988 if (dev_is_sata(dev)) 989 return -EINVAL; 990 991 if (!scsi_dev->tagged_supported) 992 return 0; 993 994 scsi_deactivate_tcq(scsi_dev, 1); 995 996 scsi_set_tag_type(scsi_dev, qt); 997 scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth); 998 999 return qt; 1000 } 1001 1002 int sas_bios_param(struct scsi_device *scsi_dev, 1003 struct block_device *bdev, 1004 sector_t capacity, int *hsc) 1005 { 1006 hsc[0] = 255; 1007 hsc[1] = 63; 1008 sector_div(capacity, 255*63); 1009 hsc[2] = capacity; 1010 1011 return 0; 1012 } 1013 1014 /* ---------- Task Collector Thread implementation ---------- */ 1015 1016 static void sas_queue(struct sas_ha_struct *sas_ha) 1017 { 1018 struct scsi_core *core = &sas_ha->core; 1019 unsigned long flags; 1020 LIST_HEAD(q); 1021 int can_queue; 1022 int res; 1023 struct sas_internal *i = to_sas_internal(core->shost->transportt); 1024 1025 mutex_lock(&core->task_queue_flush); 1026 spin_lock_irqsave(&core->task_queue_lock, flags); 1027 while (!kthread_should_stop() && 1028 !list_empty(&core->task_queue) && 1029 !test_bit(SAS_HA_FROZEN, &sas_ha->state)) { 1030 1031 can_queue = sas_ha->lldd_queue_size - core->task_queue_size; 1032 if (can_queue >= 0) { 1033 can_queue = core->task_queue_size; 1034 list_splice_init(&core->task_queue, &q); 1035 } else { 1036 struct list_head *a, *n; 1037 1038 can_queue = sas_ha->lldd_queue_size; 1039 list_for_each_safe(a, n, &core->task_queue) { 1040 list_move_tail(a, &q); 1041 if (--can_queue == 0) 1042 break; 1043 } 1044 can_queue = sas_ha->lldd_queue_size; 1045 } 1046 core->task_queue_size -= can_queue; 1047 spin_unlock_irqrestore(&core->task_queue_lock, flags); 1048 { 1049 struct sas_task *task = list_entry(q.next, 1050 struct sas_task, 1051 list); 1052 list_del_init(&q); 1053 res = i->dft->lldd_execute_task(task, can_queue, 1054 GFP_KERNEL); 1055 if (unlikely(res)) 1056 __list_add(&q, task->list.prev, &task->list); 1057 } 1058 spin_lock_irqsave(&core->task_queue_lock, flags); 1059 if (res) { 1060 list_splice_init(&q, &core->task_queue); /*at head*/ 1061 core->task_queue_size += can_queue; 1062 } 1063 } 1064 spin_unlock_irqrestore(&core->task_queue_lock, flags); 1065 mutex_unlock(&core->task_queue_flush); 1066 } 1067 1068 /** 1069 * sas_queue_thread -- The Task Collector thread 1070 * @_sas_ha: pointer to struct sas_ha 1071 */ 1072 static int sas_queue_thread(void *_sas_ha) 1073 { 1074 struct sas_ha_struct *sas_ha = _sas_ha; 1075 1076 while (1) { 1077 set_current_state(TASK_INTERRUPTIBLE); 1078 schedule(); 1079 sas_queue(sas_ha); 1080 if (kthread_should_stop()) 1081 break; 1082 } 1083 1084 return 0; 1085 } 1086 1087 int sas_init_queue(struct sas_ha_struct *sas_ha) 1088 { 1089 struct scsi_core *core = &sas_ha->core; 1090 1091 spin_lock_init(&core->task_queue_lock); 1092 mutex_init(&core->task_queue_flush); 1093 core->task_queue_size = 0; 1094 INIT_LIST_HEAD(&core->task_queue); 1095 1096 core->queue_thread = kthread_run(sas_queue_thread, sas_ha, 1097 "sas_queue_%d", core->shost->host_no); 1098 if (IS_ERR(core->queue_thread)) 1099 return PTR_ERR(core->queue_thread); 1100 return 0; 1101 } 1102 1103 void sas_shutdown_queue(struct sas_ha_struct *sas_ha) 1104 { 1105 unsigned long flags; 1106 struct scsi_core *core = &sas_ha->core; 1107 struct sas_task *task, *n; 1108 1109 kthread_stop(core->queue_thread); 1110 1111 if (!list_empty(&core->task_queue)) 1112 SAS_DPRINTK("HA: %llx: scsi core task queue is NOT empty!?\n", 1113 SAS_ADDR(sas_ha->sas_addr)); 1114 1115 spin_lock_irqsave(&core->task_queue_lock, flags); 1116 list_for_each_entry_safe(task, n, &core->task_queue, list) { 1117 struct scsi_cmnd *cmd = task->uldd_task; 1118 1119 list_del_init(&task->list); 1120 1121 ASSIGN_SAS_TASK(cmd, NULL); 1122 sas_free_task(task); 1123 cmd->result = DID_ABORT << 16; 1124 cmd->scsi_done(cmd); 1125 } 1126 spin_unlock_irqrestore(&core->task_queue_lock, flags); 1127 } 1128 1129 /* 1130 * Tell an upper layer that it needs to initiate an abort for a given task. 1131 * This should only ever be called by an LLDD. 1132 */ 1133 void sas_task_abort(struct sas_task *task) 1134 { 1135 struct scsi_cmnd *sc = task->uldd_task; 1136 1137 /* Escape for libsas internal commands */ 1138 if (!sc) { 1139 struct sas_task_slow *slow = task->slow_task; 1140 1141 if (!slow) 1142 return; 1143 if (!del_timer(&slow->timer)) 1144 return; 1145 slow->timer.function(slow->timer.data); 1146 return; 1147 } 1148 1149 if (dev_is_sata(task->dev)) { 1150 sas_ata_task_abort(task); 1151 } else { 1152 struct request_queue *q = sc->device->request_queue; 1153 unsigned long flags; 1154 1155 spin_lock_irqsave(q->queue_lock, flags); 1156 blk_abort_request(sc->request); 1157 spin_unlock_irqrestore(q->queue_lock, flags); 1158 } 1159 } 1160 1161 void sas_target_destroy(struct scsi_target *starget) 1162 { 1163 struct domain_device *found_dev = starget->hostdata; 1164 1165 if (!found_dev) 1166 return; 1167 1168 starget->hostdata = NULL; 1169 sas_put_device(found_dev); 1170 } 1171 1172 static void sas_parse_addr(u8 *sas_addr, const char *p) 1173 { 1174 int i; 1175 for (i = 0; i < SAS_ADDR_SIZE; i++) { 1176 u8 h, l; 1177 if (!*p) 1178 break; 1179 h = isdigit(*p) ? *p-'0' : toupper(*p)-'A'+10; 1180 p++; 1181 l = isdigit(*p) ? *p-'0' : toupper(*p)-'A'+10; 1182 p++; 1183 sas_addr[i] = (h<<4) | l; 1184 } 1185 } 1186 1187 #define SAS_STRING_ADDR_SIZE 16 1188 1189 int sas_request_addr(struct Scsi_Host *shost, u8 *addr) 1190 { 1191 int res; 1192 const struct firmware *fw; 1193 1194 res = request_firmware(&fw, "sas_addr", &shost->shost_gendev); 1195 if (res) 1196 return res; 1197 1198 if (fw->size < SAS_STRING_ADDR_SIZE) { 1199 res = -ENODEV; 1200 goto out; 1201 } 1202 1203 sas_parse_addr(addr, fw->data); 1204 1205 out: 1206 release_firmware(fw); 1207 return res; 1208 } 1209 EXPORT_SYMBOL_GPL(sas_request_addr); 1210 1211 EXPORT_SYMBOL_GPL(sas_queuecommand); 1212 EXPORT_SYMBOL_GPL(sas_target_alloc); 1213 EXPORT_SYMBOL_GPL(sas_slave_configure); 1214 EXPORT_SYMBOL_GPL(sas_change_queue_depth); 1215 EXPORT_SYMBOL_GPL(sas_change_queue_type); 1216 EXPORT_SYMBOL_GPL(sas_bios_param); 1217 EXPORT_SYMBOL_GPL(sas_task_abort); 1218 EXPORT_SYMBOL_GPL(sas_phy_reset); 1219 EXPORT_SYMBOL_GPL(sas_eh_device_reset_handler); 1220 EXPORT_SYMBOL_GPL(sas_eh_bus_reset_handler); 1221 EXPORT_SYMBOL_GPL(sas_target_destroy); 1222 EXPORT_SYMBOL_GPL(sas_ioctl); 1223