1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Serial Attached SCSI (SAS) class SCSI Host glue. 4 * 5 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 6 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 7 */ 8 9 #include <linux/kthread.h> 10 #include <linux/firmware.h> 11 #include <linux/export.h> 12 #include <linux/ctype.h> 13 #include <linux/kernel.h> 14 15 #include "sas_internal.h" 16 17 #include <scsi/scsi_host.h> 18 #include <scsi/scsi_device.h> 19 #include <scsi/scsi_tcq.h> 20 #include <scsi/scsi.h> 21 #include <scsi/scsi_eh.h> 22 #include <scsi/scsi_transport.h> 23 #include <scsi/scsi_transport_sas.h> 24 #include <scsi/sas_ata.h> 25 #include "../scsi_sas_internal.h" 26 #include "../scsi_transport_api.h" 27 #include "../scsi_priv.h" 28 29 #include <linux/err.h> 30 #include <linux/blkdev.h> 31 #include <linux/freezer.h> 32 #include <linux/gfp.h> 33 #include <linux/scatterlist.h> 34 #include <linux/libata.h> 35 36 /* record final status and free the task */ 37 static void sas_end_task(struct scsi_cmnd *sc, struct sas_task *task) 38 { 39 struct task_status_struct *ts = &task->task_status; 40 int hs = 0, stat = 0; 41 42 if (ts->resp == SAS_TASK_UNDELIVERED) { 43 /* transport error */ 44 hs = DID_NO_CONNECT; 45 } else { /* ts->resp == SAS_TASK_COMPLETE */ 46 /* task delivered, what happened afterwards? */ 47 switch (ts->stat) { 48 case SAS_DEV_NO_RESPONSE: 49 case SAS_INTERRUPTED: 50 case SAS_PHY_DOWN: 51 case SAS_NAK_R_ERR: 52 case SAS_OPEN_TO: 53 hs = DID_NO_CONNECT; 54 break; 55 case SAS_DATA_UNDERRUN: 56 scsi_set_resid(sc, ts->residual); 57 if (scsi_bufflen(sc) - scsi_get_resid(sc) < sc->underflow) 58 hs = DID_ERROR; 59 break; 60 case SAS_DATA_OVERRUN: 61 hs = DID_ERROR; 62 break; 63 case SAS_QUEUE_FULL: 64 hs = DID_SOFT_ERROR; /* retry */ 65 break; 66 case SAS_DEVICE_UNKNOWN: 67 hs = DID_BAD_TARGET; 68 break; 69 case SAS_SG_ERR: 70 hs = DID_PARITY; 71 break; 72 case SAS_OPEN_REJECT: 73 if (ts->open_rej_reason == SAS_OREJ_RSVD_RETRY) 74 hs = DID_SOFT_ERROR; /* retry */ 75 else 76 hs = DID_ERROR; 77 break; 78 case SAS_PROTO_RESPONSE: 79 pr_notice("LLDD:%s sent SAS_PROTO_RESP for an SSP task; please report this\n", 80 task->dev->port->ha->sas_ha_name); 81 break; 82 case SAS_ABORTED_TASK: 83 hs = DID_ABORT; 84 break; 85 case SAM_STAT_CHECK_CONDITION: 86 memcpy(sc->sense_buffer, ts->buf, 87 min(SCSI_SENSE_BUFFERSIZE, ts->buf_valid_size)); 88 stat = SAM_STAT_CHECK_CONDITION; 89 break; 90 default: 91 stat = ts->stat; 92 break; 93 } 94 } 95 96 sc->result = (hs << 16) | stat; 97 ASSIGN_SAS_TASK(sc, NULL); 98 sas_free_task(task); 99 } 100 101 static void sas_scsi_task_done(struct sas_task *task) 102 { 103 struct scsi_cmnd *sc = task->uldd_task; 104 struct domain_device *dev = task->dev; 105 struct sas_ha_struct *ha = dev->port->ha; 106 unsigned long flags; 107 108 spin_lock_irqsave(&dev->done_lock, flags); 109 if (test_bit(SAS_HA_FROZEN, &ha->state)) 110 task = NULL; 111 else 112 ASSIGN_SAS_TASK(sc, NULL); 113 spin_unlock_irqrestore(&dev->done_lock, flags); 114 115 if (unlikely(!task)) { 116 /* task will be completed by the error handler */ 117 pr_debug("task done but aborted\n"); 118 return; 119 } 120 121 if (unlikely(!sc)) { 122 pr_debug("task_done called with non existing SCSI cmnd!\n"); 123 sas_free_task(task); 124 return; 125 } 126 127 sas_end_task(sc, task); 128 sc->scsi_done(sc); 129 } 130 131 static struct sas_task *sas_create_task(struct scsi_cmnd *cmd, 132 struct domain_device *dev, 133 gfp_t gfp_flags) 134 { 135 struct sas_task *task = sas_alloc_task(gfp_flags); 136 struct scsi_lun lun; 137 138 if (!task) 139 return NULL; 140 141 task->uldd_task = cmd; 142 ASSIGN_SAS_TASK(cmd, task); 143 144 task->dev = dev; 145 task->task_proto = task->dev->tproto; /* BUG_ON(!SSP) */ 146 147 task->ssp_task.retry_count = 1; 148 int_to_scsilun(cmd->device->lun, &lun); 149 memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8); 150 task->ssp_task.task_attr = TASK_ATTR_SIMPLE; 151 task->ssp_task.cmd = cmd; 152 153 task->scatter = scsi_sglist(cmd); 154 task->num_scatter = scsi_sg_count(cmd); 155 task->total_xfer_len = scsi_bufflen(cmd); 156 task->data_dir = cmd->sc_data_direction; 157 158 task->task_done = sas_scsi_task_done; 159 160 return task; 161 } 162 163 int sas_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd) 164 { 165 struct sas_internal *i = to_sas_internal(host->transportt); 166 struct domain_device *dev = cmd_to_domain_dev(cmd); 167 struct sas_task *task; 168 int res = 0; 169 170 /* If the device fell off, no sense in issuing commands */ 171 if (test_bit(SAS_DEV_GONE, &dev->state)) { 172 cmd->result = DID_BAD_TARGET << 16; 173 goto out_done; 174 } 175 176 if (dev_is_sata(dev)) { 177 spin_lock_irq(dev->sata_dev.ap->lock); 178 res = ata_sas_queuecmd(cmd, dev->sata_dev.ap); 179 spin_unlock_irq(dev->sata_dev.ap->lock); 180 return res; 181 } 182 183 task = sas_create_task(cmd, dev, GFP_ATOMIC); 184 if (!task) 185 return SCSI_MLQUEUE_HOST_BUSY; 186 187 res = i->dft->lldd_execute_task(task, GFP_ATOMIC); 188 if (res) 189 goto out_free_task; 190 return 0; 191 192 out_free_task: 193 pr_debug("lldd_execute_task returned: %d\n", res); 194 ASSIGN_SAS_TASK(cmd, NULL); 195 sas_free_task(task); 196 if (res == -SAS_QUEUE_FULL) 197 cmd->result = DID_SOFT_ERROR << 16; /* retry */ 198 else 199 cmd->result = DID_ERROR << 16; 200 out_done: 201 cmd->scsi_done(cmd); 202 return 0; 203 } 204 205 static void sas_eh_finish_cmd(struct scsi_cmnd *cmd) 206 { 207 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(cmd->device->host); 208 struct domain_device *dev = cmd_to_domain_dev(cmd); 209 struct sas_task *task = TO_SAS_TASK(cmd); 210 211 /* At this point, we only get called following an actual abort 212 * of the task, so we should be guaranteed not to be racing with 213 * any completions from the LLD. Task is freed after this. 214 */ 215 sas_end_task(cmd, task); 216 217 if (dev_is_sata(dev)) { 218 /* defer commands to libata so that libata EH can 219 * handle ata qcs correctly 220 */ 221 list_move_tail(&cmd->eh_entry, &sas_ha->eh_ata_q); 222 return; 223 } 224 225 /* now finish the command and move it on to the error 226 * handler done list, this also takes it off the 227 * error handler pending list. 228 */ 229 scsi_eh_finish_cmd(cmd, &sas_ha->eh_done_q); 230 } 231 232 static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd) 233 { 234 struct scsi_cmnd *cmd, *n; 235 236 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 237 if (cmd->device->sdev_target == my_cmd->device->sdev_target && 238 cmd->device->lun == my_cmd->device->lun) 239 sas_eh_finish_cmd(cmd); 240 } 241 } 242 243 static void sas_scsi_clear_queue_I_T(struct list_head *error_q, 244 struct domain_device *dev) 245 { 246 struct scsi_cmnd *cmd, *n; 247 248 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 249 struct domain_device *x = cmd_to_domain_dev(cmd); 250 251 if (x == dev) 252 sas_eh_finish_cmd(cmd); 253 } 254 } 255 256 static void sas_scsi_clear_queue_port(struct list_head *error_q, 257 struct asd_sas_port *port) 258 { 259 struct scsi_cmnd *cmd, *n; 260 261 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 262 struct domain_device *dev = cmd_to_domain_dev(cmd); 263 struct asd_sas_port *x = dev->port; 264 265 if (x == port) 266 sas_eh_finish_cmd(cmd); 267 } 268 } 269 270 enum task_disposition { 271 TASK_IS_DONE, 272 TASK_IS_ABORTED, 273 TASK_IS_AT_LU, 274 TASK_IS_NOT_AT_LU, 275 TASK_ABORT_FAILED, 276 }; 277 278 static enum task_disposition sas_scsi_find_task(struct sas_task *task) 279 { 280 unsigned long flags; 281 int i, res; 282 struct sas_internal *si = 283 to_sas_internal(task->dev->port->ha->core.shost->transportt); 284 285 for (i = 0; i < 5; i++) { 286 pr_notice("%s: aborting task 0x%p\n", __func__, task); 287 res = si->dft->lldd_abort_task(task); 288 289 spin_lock_irqsave(&task->task_state_lock, flags); 290 if (task->task_state_flags & SAS_TASK_STATE_DONE) { 291 spin_unlock_irqrestore(&task->task_state_lock, flags); 292 pr_debug("%s: task 0x%p is done\n", __func__, task); 293 return TASK_IS_DONE; 294 } 295 spin_unlock_irqrestore(&task->task_state_lock, flags); 296 297 if (res == TMF_RESP_FUNC_COMPLETE) { 298 pr_notice("%s: task 0x%p is aborted\n", 299 __func__, task); 300 return TASK_IS_ABORTED; 301 } else if (si->dft->lldd_query_task) { 302 pr_notice("%s: querying task 0x%p\n", __func__, task); 303 res = si->dft->lldd_query_task(task); 304 switch (res) { 305 case TMF_RESP_FUNC_SUCC: 306 pr_notice("%s: task 0x%p at LU\n", __func__, 307 task); 308 return TASK_IS_AT_LU; 309 case TMF_RESP_FUNC_COMPLETE: 310 pr_notice("%s: task 0x%p not at LU\n", 311 __func__, task); 312 return TASK_IS_NOT_AT_LU; 313 case TMF_RESP_FUNC_FAILED: 314 pr_notice("%s: task 0x%p failed to abort\n", 315 __func__, task); 316 return TASK_ABORT_FAILED; 317 } 318 319 } 320 } 321 return res; 322 } 323 324 static int sas_recover_lu(struct domain_device *dev, struct scsi_cmnd *cmd) 325 { 326 int res = TMF_RESP_FUNC_FAILED; 327 struct scsi_lun lun; 328 struct sas_internal *i = 329 to_sas_internal(dev->port->ha->core.shost->transportt); 330 331 int_to_scsilun(cmd->device->lun, &lun); 332 333 pr_notice("eh: device %llx LUN %llx has the task\n", 334 SAS_ADDR(dev->sas_addr), 335 cmd->device->lun); 336 337 if (i->dft->lldd_abort_task_set) 338 res = i->dft->lldd_abort_task_set(dev, lun.scsi_lun); 339 340 if (res == TMF_RESP_FUNC_FAILED) { 341 if (i->dft->lldd_clear_task_set) 342 res = i->dft->lldd_clear_task_set(dev, lun.scsi_lun); 343 } 344 345 if (res == TMF_RESP_FUNC_FAILED) { 346 if (i->dft->lldd_lu_reset) 347 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 348 } 349 350 return res; 351 } 352 353 static int sas_recover_I_T(struct domain_device *dev) 354 { 355 int res = TMF_RESP_FUNC_FAILED; 356 struct sas_internal *i = 357 to_sas_internal(dev->port->ha->core.shost->transportt); 358 359 pr_notice("I_T nexus reset for dev %016llx\n", 360 SAS_ADDR(dev->sas_addr)); 361 362 if (i->dft->lldd_I_T_nexus_reset) 363 res = i->dft->lldd_I_T_nexus_reset(dev); 364 365 return res; 366 } 367 368 /* take a reference on the last known good phy for this device */ 369 struct sas_phy *sas_get_local_phy(struct domain_device *dev) 370 { 371 struct sas_ha_struct *ha = dev->port->ha; 372 struct sas_phy *phy; 373 unsigned long flags; 374 375 /* a published domain device always has a valid phy, it may be 376 * stale, but it is never NULL 377 */ 378 BUG_ON(!dev->phy); 379 380 spin_lock_irqsave(&ha->phy_port_lock, flags); 381 phy = dev->phy; 382 get_device(&phy->dev); 383 spin_unlock_irqrestore(&ha->phy_port_lock, flags); 384 385 return phy; 386 } 387 EXPORT_SYMBOL_GPL(sas_get_local_phy); 388 389 static void sas_wait_eh(struct domain_device *dev) 390 { 391 struct sas_ha_struct *ha = dev->port->ha; 392 DEFINE_WAIT(wait); 393 394 if (dev_is_sata(dev)) { 395 ata_port_wait_eh(dev->sata_dev.ap); 396 return; 397 } 398 retry: 399 spin_lock_irq(&ha->lock); 400 401 while (test_bit(SAS_DEV_EH_PENDING, &dev->state)) { 402 prepare_to_wait(&ha->eh_wait_q, &wait, TASK_UNINTERRUPTIBLE); 403 spin_unlock_irq(&ha->lock); 404 schedule(); 405 spin_lock_irq(&ha->lock); 406 } 407 finish_wait(&ha->eh_wait_q, &wait); 408 409 spin_unlock_irq(&ha->lock); 410 411 /* make sure SCSI EH is complete */ 412 if (scsi_host_in_recovery(ha->core.shost)) { 413 msleep(10); 414 goto retry; 415 } 416 } 417 418 static int sas_queue_reset(struct domain_device *dev, int reset_type, 419 u64 lun, int wait) 420 { 421 struct sas_ha_struct *ha = dev->port->ha; 422 int scheduled = 0, tries = 100; 423 424 /* ata: promote lun reset to bus reset */ 425 if (dev_is_sata(dev)) { 426 sas_ata_schedule_reset(dev); 427 if (wait) 428 sas_ata_wait_eh(dev); 429 return SUCCESS; 430 } 431 432 while (!scheduled && tries--) { 433 spin_lock_irq(&ha->lock); 434 if (!test_bit(SAS_DEV_EH_PENDING, &dev->state) && 435 !test_bit(reset_type, &dev->state)) { 436 scheduled = 1; 437 ha->eh_active++; 438 list_add_tail(&dev->ssp_dev.eh_list_node, &ha->eh_dev_q); 439 set_bit(SAS_DEV_EH_PENDING, &dev->state); 440 set_bit(reset_type, &dev->state); 441 int_to_scsilun(lun, &dev->ssp_dev.reset_lun); 442 scsi_schedule_eh(ha->core.shost); 443 } 444 spin_unlock_irq(&ha->lock); 445 446 if (wait) 447 sas_wait_eh(dev); 448 449 if (scheduled) 450 return SUCCESS; 451 } 452 453 pr_warn("%s reset of %s failed\n", 454 reset_type == SAS_DEV_LU_RESET ? "LUN" : "Bus", 455 dev_name(&dev->rphy->dev)); 456 457 return FAILED; 458 } 459 460 int sas_eh_abort_handler(struct scsi_cmnd *cmd) 461 { 462 int res = TMF_RESP_FUNC_FAILED; 463 struct sas_task *task = TO_SAS_TASK(cmd); 464 struct Scsi_Host *host = cmd->device->host; 465 struct domain_device *dev = cmd_to_domain_dev(cmd); 466 struct sas_internal *i = to_sas_internal(host->transportt); 467 unsigned long flags; 468 469 if (!i->dft->lldd_abort_task) 470 return FAILED; 471 472 spin_lock_irqsave(host->host_lock, flags); 473 /* We cannot do async aborts for SATA devices */ 474 if (dev_is_sata(dev) && !host->host_eh_scheduled) { 475 spin_unlock_irqrestore(host->host_lock, flags); 476 return FAILED; 477 } 478 spin_unlock_irqrestore(host->host_lock, flags); 479 480 if (task) 481 res = i->dft->lldd_abort_task(task); 482 else 483 pr_notice("no task to abort\n"); 484 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 485 return SUCCESS; 486 487 return FAILED; 488 } 489 EXPORT_SYMBOL_GPL(sas_eh_abort_handler); 490 491 /* Attempt to send a LUN reset message to a device */ 492 int sas_eh_device_reset_handler(struct scsi_cmnd *cmd) 493 { 494 int res; 495 struct scsi_lun lun; 496 struct Scsi_Host *host = cmd->device->host; 497 struct domain_device *dev = cmd_to_domain_dev(cmd); 498 struct sas_internal *i = to_sas_internal(host->transportt); 499 500 if (current != host->ehandler) 501 return sas_queue_reset(dev, SAS_DEV_LU_RESET, cmd->device->lun, 0); 502 503 int_to_scsilun(cmd->device->lun, &lun); 504 505 if (!i->dft->lldd_lu_reset) 506 return FAILED; 507 508 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 509 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 510 return SUCCESS; 511 512 return FAILED; 513 } 514 515 int sas_eh_target_reset_handler(struct scsi_cmnd *cmd) 516 { 517 int res; 518 struct Scsi_Host *host = cmd->device->host; 519 struct domain_device *dev = cmd_to_domain_dev(cmd); 520 struct sas_internal *i = to_sas_internal(host->transportt); 521 522 if (current != host->ehandler) 523 return sas_queue_reset(dev, SAS_DEV_RESET, 0, 0); 524 525 if (!i->dft->lldd_I_T_nexus_reset) 526 return FAILED; 527 528 res = i->dft->lldd_I_T_nexus_reset(dev); 529 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE || 530 res == -ENODEV) 531 return SUCCESS; 532 533 return FAILED; 534 } 535 536 /* Try to reset a device */ 537 static int try_to_reset_cmd_device(struct scsi_cmnd *cmd) 538 { 539 int res; 540 struct Scsi_Host *shost = cmd->device->host; 541 542 if (!shost->hostt->eh_device_reset_handler) 543 goto try_target_reset; 544 545 res = shost->hostt->eh_device_reset_handler(cmd); 546 if (res == SUCCESS) 547 return res; 548 549 try_target_reset: 550 if (shost->hostt->eh_target_reset_handler) 551 return shost->hostt->eh_target_reset_handler(cmd); 552 553 return FAILED; 554 } 555 556 static void sas_eh_handle_sas_errors(struct Scsi_Host *shost, struct list_head *work_q) 557 { 558 struct scsi_cmnd *cmd, *n; 559 enum task_disposition res = TASK_IS_DONE; 560 int tmf_resp, need_reset; 561 struct sas_internal *i = to_sas_internal(shost->transportt); 562 unsigned long flags; 563 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 564 LIST_HEAD(done); 565 566 /* clean out any commands that won the completion vs eh race */ 567 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 568 struct domain_device *dev = cmd_to_domain_dev(cmd); 569 struct sas_task *task; 570 571 spin_lock_irqsave(&dev->done_lock, flags); 572 /* by this point the lldd has either observed 573 * SAS_HA_FROZEN and is leaving the task alone, or has 574 * won the race with eh and decided to complete it 575 */ 576 task = TO_SAS_TASK(cmd); 577 spin_unlock_irqrestore(&dev->done_lock, flags); 578 579 if (!task) 580 list_move_tail(&cmd->eh_entry, &done); 581 } 582 583 Again: 584 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 585 struct sas_task *task = TO_SAS_TASK(cmd); 586 587 list_del_init(&cmd->eh_entry); 588 589 spin_lock_irqsave(&task->task_state_lock, flags); 590 need_reset = task->task_state_flags & SAS_TASK_NEED_DEV_RESET; 591 spin_unlock_irqrestore(&task->task_state_lock, flags); 592 593 if (need_reset) { 594 pr_notice("%s: task 0x%p requests reset\n", 595 __func__, task); 596 goto reset; 597 } 598 599 pr_debug("trying to find task 0x%p\n", task); 600 res = sas_scsi_find_task(task); 601 602 switch (res) { 603 case TASK_IS_DONE: 604 pr_notice("%s: task 0x%p is done\n", __func__, 605 task); 606 sas_eh_finish_cmd(cmd); 607 continue; 608 case TASK_IS_ABORTED: 609 pr_notice("%s: task 0x%p is aborted\n", 610 __func__, task); 611 sas_eh_finish_cmd(cmd); 612 continue; 613 case TASK_IS_AT_LU: 614 pr_info("task 0x%p is at LU: lu recover\n", task); 615 reset: 616 tmf_resp = sas_recover_lu(task->dev, cmd); 617 if (tmf_resp == TMF_RESP_FUNC_COMPLETE) { 618 pr_notice("dev %016llx LU %llx is recovered\n", 619 SAS_ADDR(task->dev), 620 cmd->device->lun); 621 sas_eh_finish_cmd(cmd); 622 sas_scsi_clear_queue_lu(work_q, cmd); 623 goto Again; 624 } 625 /* fallthrough */ 626 case TASK_IS_NOT_AT_LU: 627 case TASK_ABORT_FAILED: 628 pr_notice("task 0x%p is not at LU: I_T recover\n", 629 task); 630 tmf_resp = sas_recover_I_T(task->dev); 631 if (tmf_resp == TMF_RESP_FUNC_COMPLETE || 632 tmf_resp == -ENODEV) { 633 struct domain_device *dev = task->dev; 634 pr_notice("I_T %016llx recovered\n", 635 SAS_ADDR(task->dev->sas_addr)); 636 sas_eh_finish_cmd(cmd); 637 sas_scsi_clear_queue_I_T(work_q, dev); 638 goto Again; 639 } 640 /* Hammer time :-) */ 641 try_to_reset_cmd_device(cmd); 642 if (i->dft->lldd_clear_nexus_port) { 643 struct asd_sas_port *port = task->dev->port; 644 pr_debug("clearing nexus for port:%d\n", 645 port->id); 646 res = i->dft->lldd_clear_nexus_port(port); 647 if (res == TMF_RESP_FUNC_COMPLETE) { 648 pr_notice("clear nexus port:%d succeeded\n", 649 port->id); 650 sas_eh_finish_cmd(cmd); 651 sas_scsi_clear_queue_port(work_q, 652 port); 653 goto Again; 654 } 655 } 656 if (i->dft->lldd_clear_nexus_ha) { 657 pr_debug("clear nexus ha\n"); 658 res = i->dft->lldd_clear_nexus_ha(ha); 659 if (res == TMF_RESP_FUNC_COMPLETE) { 660 pr_notice("clear nexus ha succeeded\n"); 661 sas_eh_finish_cmd(cmd); 662 goto clear_q; 663 } 664 } 665 /* If we are here -- this means that no amount 666 * of effort could recover from errors. Quite 667 * possibly the HA just disappeared. 668 */ 669 pr_err("error from device %llx, LUN %llx couldn't be recovered in any way\n", 670 SAS_ADDR(task->dev->sas_addr), 671 cmd->device->lun); 672 673 sas_eh_finish_cmd(cmd); 674 goto clear_q; 675 } 676 } 677 out: 678 list_splice_tail(&done, work_q); 679 list_splice_tail_init(&ha->eh_ata_q, work_q); 680 return; 681 682 clear_q: 683 pr_debug("--- Exit %s -- clear_q\n", __func__); 684 list_for_each_entry_safe(cmd, n, work_q, eh_entry) 685 sas_eh_finish_cmd(cmd); 686 goto out; 687 } 688 689 static void sas_eh_handle_resets(struct Scsi_Host *shost) 690 { 691 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 692 struct sas_internal *i = to_sas_internal(shost->transportt); 693 694 /* handle directed resets to sas devices */ 695 spin_lock_irq(&ha->lock); 696 while (!list_empty(&ha->eh_dev_q)) { 697 struct domain_device *dev; 698 struct ssp_device *ssp; 699 700 ssp = list_entry(ha->eh_dev_q.next, typeof(*ssp), eh_list_node); 701 list_del_init(&ssp->eh_list_node); 702 dev = container_of(ssp, typeof(*dev), ssp_dev); 703 kref_get(&dev->kref); 704 WARN_ONCE(dev_is_sata(dev), "ssp reset to ata device?\n"); 705 706 spin_unlock_irq(&ha->lock); 707 708 if (test_and_clear_bit(SAS_DEV_LU_RESET, &dev->state)) 709 i->dft->lldd_lu_reset(dev, ssp->reset_lun.scsi_lun); 710 711 if (test_and_clear_bit(SAS_DEV_RESET, &dev->state)) 712 i->dft->lldd_I_T_nexus_reset(dev); 713 714 sas_put_device(dev); 715 spin_lock_irq(&ha->lock); 716 clear_bit(SAS_DEV_EH_PENDING, &dev->state); 717 ha->eh_active--; 718 } 719 spin_unlock_irq(&ha->lock); 720 } 721 722 723 void sas_scsi_recover_host(struct Scsi_Host *shost) 724 { 725 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 726 LIST_HEAD(eh_work_q); 727 int tries = 0; 728 bool retry; 729 730 retry: 731 tries++; 732 retry = true; 733 spin_lock_irq(shost->host_lock); 734 list_splice_init(&shost->eh_cmd_q, &eh_work_q); 735 spin_unlock_irq(shost->host_lock); 736 737 pr_notice("Enter %s busy: %d failed: %d\n", 738 __func__, scsi_host_busy(shost), shost->host_failed); 739 /* 740 * Deal with commands that still have SAS tasks (i.e. they didn't 741 * complete via the normal sas_task completion mechanism), 742 * SAS_HA_FROZEN gives eh dominion over all sas_task completion. 743 */ 744 set_bit(SAS_HA_FROZEN, &ha->state); 745 sas_eh_handle_sas_errors(shost, &eh_work_q); 746 clear_bit(SAS_HA_FROZEN, &ha->state); 747 if (list_empty(&eh_work_q)) 748 goto out; 749 750 /* 751 * Now deal with SCSI commands that completed ok but have a an error 752 * code (and hopefully sense data) attached. This is roughly what 753 * scsi_unjam_host does, but we skip scsi_eh_abort_cmds because any 754 * command we see here has no sas_task and is thus unknown to the HA. 755 */ 756 sas_ata_eh(shost, &eh_work_q, &ha->eh_done_q); 757 if (!scsi_eh_get_sense(&eh_work_q, &ha->eh_done_q)) 758 scsi_eh_ready_devs(shost, &eh_work_q, &ha->eh_done_q); 759 760 out: 761 sas_eh_handle_resets(shost); 762 763 /* now link into libata eh --- if we have any ata devices */ 764 sas_ata_strategy_handler(shost); 765 766 scsi_eh_flush_done_q(&ha->eh_done_q); 767 768 /* check if any new eh work was scheduled during the last run */ 769 spin_lock_irq(&ha->lock); 770 if (ha->eh_active == 0) { 771 shost->host_eh_scheduled = 0; 772 retry = false; 773 } 774 spin_unlock_irq(&ha->lock); 775 776 if (retry) 777 goto retry; 778 779 pr_notice("--- Exit %s: busy: %d failed: %d tries: %d\n", 780 __func__, scsi_host_busy(shost), 781 shost->host_failed, tries); 782 } 783 784 int sas_ioctl(struct scsi_device *sdev, unsigned int cmd, void __user *arg) 785 { 786 struct domain_device *dev = sdev_to_domain_dev(sdev); 787 788 if (dev_is_sata(dev)) 789 return ata_sas_scsi_ioctl(dev->sata_dev.ap, sdev, cmd, arg); 790 791 return -EINVAL; 792 } 793 794 struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy) 795 { 796 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent); 797 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 798 struct domain_device *found_dev = NULL; 799 int i; 800 unsigned long flags; 801 802 spin_lock_irqsave(&ha->phy_port_lock, flags); 803 for (i = 0; i < ha->num_phys; i++) { 804 struct asd_sas_port *port = ha->sas_port[i]; 805 struct domain_device *dev; 806 807 spin_lock(&port->dev_list_lock); 808 list_for_each_entry(dev, &port->dev_list, dev_list_node) { 809 if (rphy == dev->rphy) { 810 found_dev = dev; 811 spin_unlock(&port->dev_list_lock); 812 goto found; 813 } 814 } 815 spin_unlock(&port->dev_list_lock); 816 } 817 found: 818 spin_unlock_irqrestore(&ha->phy_port_lock, flags); 819 820 return found_dev; 821 } 822 823 int sas_target_alloc(struct scsi_target *starget) 824 { 825 struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent); 826 struct domain_device *found_dev = sas_find_dev_by_rphy(rphy); 827 828 if (!found_dev) 829 return -ENODEV; 830 831 kref_get(&found_dev->kref); 832 starget->hostdata = found_dev; 833 return 0; 834 } 835 836 #define SAS_DEF_QD 256 837 838 int sas_slave_configure(struct scsi_device *scsi_dev) 839 { 840 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 841 842 BUG_ON(dev->rphy->identify.device_type != SAS_END_DEVICE); 843 844 if (dev_is_sata(dev)) { 845 ata_sas_slave_configure(scsi_dev, dev->sata_dev.ap); 846 return 0; 847 } 848 849 sas_read_port_mode_page(scsi_dev); 850 851 if (scsi_dev->tagged_supported) { 852 scsi_change_queue_depth(scsi_dev, SAS_DEF_QD); 853 } else { 854 pr_notice("device %llx, LUN %llx doesn't support TCQ\n", 855 SAS_ADDR(dev->sas_addr), scsi_dev->lun); 856 scsi_change_queue_depth(scsi_dev, 1); 857 } 858 859 scsi_dev->allow_restart = 1; 860 861 return 0; 862 } 863 864 int sas_change_queue_depth(struct scsi_device *sdev, int depth) 865 { 866 struct domain_device *dev = sdev_to_domain_dev(sdev); 867 868 if (dev_is_sata(dev)) 869 return __ata_change_queue_depth(dev->sata_dev.ap, sdev, depth); 870 871 if (!sdev->tagged_supported) 872 depth = 1; 873 return scsi_change_queue_depth(sdev, depth); 874 } 875 876 int sas_bios_param(struct scsi_device *scsi_dev, 877 struct block_device *bdev, 878 sector_t capacity, int *hsc) 879 { 880 hsc[0] = 255; 881 hsc[1] = 63; 882 sector_div(capacity, 255*63); 883 hsc[2] = capacity; 884 885 return 0; 886 } 887 888 /* 889 * Tell an upper layer that it needs to initiate an abort for a given task. 890 * This should only ever be called by an LLDD. 891 */ 892 void sas_task_abort(struct sas_task *task) 893 { 894 struct scsi_cmnd *sc = task->uldd_task; 895 896 /* Escape for libsas internal commands */ 897 if (!sc) { 898 struct sas_task_slow *slow = task->slow_task; 899 900 if (!slow) 901 return; 902 if (!del_timer(&slow->timer)) 903 return; 904 slow->timer.function(&slow->timer); 905 return; 906 } 907 908 if (dev_is_sata(task->dev)) 909 sas_ata_task_abort(task); 910 else 911 blk_abort_request(sc->request); 912 } 913 914 void sas_target_destroy(struct scsi_target *starget) 915 { 916 struct domain_device *found_dev = starget->hostdata; 917 918 if (!found_dev) 919 return; 920 921 starget->hostdata = NULL; 922 sas_put_device(found_dev); 923 } 924 925 #define SAS_STRING_ADDR_SIZE 16 926 927 int sas_request_addr(struct Scsi_Host *shost, u8 *addr) 928 { 929 int res; 930 const struct firmware *fw; 931 932 res = request_firmware(&fw, "sas_addr", &shost->shost_gendev); 933 if (res) 934 return res; 935 936 if (fw->size < SAS_STRING_ADDR_SIZE) { 937 res = -ENODEV; 938 goto out; 939 } 940 941 res = hex2bin(addr, fw->data, strnlen(fw->data, SAS_ADDR_SIZE * 2) / 2); 942 if (res) 943 goto out; 944 945 out: 946 release_firmware(fw); 947 return res; 948 } 949 EXPORT_SYMBOL_GPL(sas_request_addr); 950 951 EXPORT_SYMBOL_GPL(sas_queuecommand); 952 EXPORT_SYMBOL_GPL(sas_target_alloc); 953 EXPORT_SYMBOL_GPL(sas_slave_configure); 954 EXPORT_SYMBOL_GPL(sas_change_queue_depth); 955 EXPORT_SYMBOL_GPL(sas_bios_param); 956 EXPORT_SYMBOL_GPL(sas_task_abort); 957 EXPORT_SYMBOL_GPL(sas_phy_reset); 958 EXPORT_SYMBOL_GPL(sas_eh_device_reset_handler); 959 EXPORT_SYMBOL_GPL(sas_eh_target_reset_handler); 960 EXPORT_SYMBOL_GPL(sas_target_destroy); 961 EXPORT_SYMBOL_GPL(sas_ioctl); 962