sas_scsi_host.c revision 831441862956fffa17b9801db37e6ea1650b0f69
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 28#include "sas_internal.h" 29 30#include <scsi/scsi_host.h> 31#include <scsi/scsi_device.h> 32#include <scsi/scsi_tcq.h> 33#include <scsi/scsi.h> 34#include <scsi/scsi_eh.h> 35#include <scsi/scsi_transport.h> 36#include <scsi/scsi_transport_sas.h> 37#include "../scsi_sas_internal.h" 38#include "../scsi_transport_api.h" 39#include "../scsi_priv.h" 40 41#include <linux/err.h> 42#include <linux/blkdev.h> 43#include <linux/freezer.h> 44#include <linux/scatterlist.h> 45 46/* ---------- SCSI Host glue ---------- */ 47 48#define TO_SAS_TASK(_scsi_cmd) ((void *)(_scsi_cmd)->host_scribble) 49#define ASSIGN_SAS_TASK(_sc, _t) do { (_sc)->host_scribble = (void *) _t; } while (0) 50 51static void sas_scsi_task_done(struct sas_task *task) 52{ 53 struct task_status_struct *ts = &task->task_status; 54 struct scsi_cmnd *sc = task->uldd_task; 55 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(sc->device->host); 56 unsigned ts_flags = task->task_state_flags; 57 int hs = 0, stat = 0; 58 59 if (unlikely(!sc)) { 60 SAS_DPRINTK("task_done called with non existing SCSI cmnd!\n"); 61 list_del_init(&task->list); 62 sas_free_task(task); 63 return; 64 } 65 66 if (ts->resp == SAS_TASK_UNDELIVERED) { 67 /* transport error */ 68 hs = DID_NO_CONNECT; 69 } else { /* ts->resp == SAS_TASK_COMPLETE */ 70 /* task delivered, what happened afterwards? */ 71 switch (ts->stat) { 72 case SAS_DEV_NO_RESPONSE: 73 case SAS_INTERRUPTED: 74 case SAS_PHY_DOWN: 75 case SAS_NAK_R_ERR: 76 case SAS_OPEN_TO: 77 hs = DID_NO_CONNECT; 78 break; 79 case SAS_DATA_UNDERRUN: 80 scsi_set_resid(sc, ts->residual); 81 if (scsi_bufflen(sc) - scsi_get_resid(sc) < sc->underflow) 82 hs = DID_ERROR; 83 break; 84 case SAS_DATA_OVERRUN: 85 hs = DID_ERROR; 86 break; 87 case SAS_QUEUE_FULL: 88 hs = DID_SOFT_ERROR; /* retry */ 89 break; 90 case SAS_DEVICE_UNKNOWN: 91 hs = DID_BAD_TARGET; 92 break; 93 case SAS_SG_ERR: 94 hs = DID_PARITY; 95 break; 96 case SAS_OPEN_REJECT: 97 if (ts->open_rej_reason == SAS_OREJ_RSVD_RETRY) 98 hs = DID_SOFT_ERROR; /* retry */ 99 else 100 hs = DID_ERROR; 101 break; 102 case SAS_PROTO_RESPONSE: 103 SAS_DPRINTK("LLDD:%s sent SAS_PROTO_RESP for an SSP " 104 "task; please report this\n", 105 task->dev->port->ha->sas_ha_name); 106 break; 107 case SAS_ABORTED_TASK: 108 hs = DID_ABORT; 109 break; 110 case SAM_CHECK_COND: 111 memcpy(sc->sense_buffer, ts->buf, 112 max(SCSI_SENSE_BUFFERSIZE, ts->buf_valid_size)); 113 stat = SAM_CHECK_COND; 114 break; 115 default: 116 stat = ts->stat; 117 break; 118 } 119 } 120 ASSIGN_SAS_TASK(sc, NULL); 121 sc->result = (hs << 16) | stat; 122 list_del_init(&task->list); 123 sas_free_task(task); 124 /* This is very ugly but this is how SCSI Core works. */ 125 if (ts_flags & SAS_TASK_STATE_ABORTED) 126 scsi_eh_finish_cmd(sc, &sas_ha->eh_done_q); 127 else 128 sc->scsi_done(sc); 129} 130 131static enum task_attribute sas_scsi_get_task_attr(struct scsi_cmnd *cmd) 132{ 133 enum task_attribute ta = TASK_ATTR_SIMPLE; 134 if (cmd->request && blk_rq_tagged(cmd->request)) { 135 if (cmd->device->ordered_tags && 136 (cmd->request->cmd_flags & REQ_HARDBARRIER)) 137 ta = TASK_ATTR_ORDERED; 138 } 139 return ta; 140} 141 142static struct sas_task *sas_create_task(struct scsi_cmnd *cmd, 143 struct domain_device *dev, 144 gfp_t gfp_flags) 145{ 146 struct sas_task *task = sas_alloc_task(gfp_flags); 147 struct scsi_lun lun; 148 149 if (!task) 150 return NULL; 151 152 *(u32 *)cmd->sense_buffer = 0; 153 task->uldd_task = cmd; 154 ASSIGN_SAS_TASK(cmd, task); 155 156 task->dev = dev; 157 task->task_proto = task->dev->tproto; /* BUG_ON(!SSP) */ 158 159 task->ssp_task.retry_count = 1; 160 int_to_scsilun(cmd->device->lun, &lun); 161 memcpy(task->ssp_task.LUN, &lun.scsi_lun, 8); 162 task->ssp_task.task_attr = sas_scsi_get_task_attr(cmd); 163 memcpy(task->ssp_task.cdb, cmd->cmnd, 16); 164 165 task->scatter = scsi_sglist(cmd); 166 task->num_scatter = scsi_sg_count(cmd); 167 task->total_xfer_len = scsi_bufflen(cmd); 168 task->data_dir = cmd->sc_data_direction; 169 170 task->task_done = sas_scsi_task_done; 171 172 return task; 173} 174 175static int sas_queue_up(struct sas_task *task) 176{ 177 struct sas_ha_struct *sas_ha = task->dev->port->ha; 178 struct scsi_core *core = &sas_ha->core; 179 unsigned long flags; 180 LIST_HEAD(list); 181 182 spin_lock_irqsave(&core->task_queue_lock, flags); 183 if (sas_ha->lldd_queue_size < core->task_queue_size + 1) { 184 spin_unlock_irqrestore(&core->task_queue_lock, flags); 185 return -SAS_QUEUE_FULL; 186 } 187 list_add_tail(&task->list, &core->task_queue); 188 core->task_queue_size += 1; 189 spin_unlock_irqrestore(&core->task_queue_lock, flags); 190 wake_up_process(core->queue_thread); 191 192 return 0; 193} 194 195/** 196 * sas_queuecommand -- Enqueue a command for processing 197 * @parameters: See SCSI Core documentation 198 * 199 * Note: XXX: Remove the host unlock/lock pair when SCSI Core can 200 * call us without holding an IRQ spinlock... 201 */ 202int sas_queuecommand(struct scsi_cmnd *cmd, 203 void (*scsi_done)(struct scsi_cmnd *)) 204{ 205 int res = 0; 206 struct domain_device *dev = cmd_to_domain_dev(cmd); 207 struct Scsi_Host *host = cmd->device->host; 208 struct sas_internal *i = to_sas_internal(host->transportt); 209 210 spin_unlock_irq(host->host_lock); 211 212 { 213 struct sas_ha_struct *sas_ha = dev->port->ha; 214 struct sas_task *task; 215 216 res = -ENOMEM; 217 task = sas_create_task(cmd, dev, GFP_ATOMIC); 218 if (!task) 219 goto out; 220 221 cmd->scsi_done = scsi_done; 222 /* Queue up, Direct Mode or Task Collector Mode. */ 223 if (sas_ha->lldd_max_execute_num < 2) 224 res = i->dft->lldd_execute_task(task, 1, GFP_ATOMIC); 225 else 226 res = sas_queue_up(task); 227 228 /* Examine */ 229 if (res) { 230 SAS_DPRINTK("lldd_execute_task returned: %d\n", res); 231 ASSIGN_SAS_TASK(cmd, NULL); 232 sas_free_task(task); 233 if (res == -SAS_QUEUE_FULL) { 234 cmd->result = DID_SOFT_ERROR << 16; /* retry */ 235 res = 0; 236 scsi_done(cmd); 237 } 238 goto out; 239 } 240 } 241out: 242 spin_lock_irq(host->host_lock); 243 return res; 244} 245 246static void sas_scsi_clear_queue_lu(struct list_head *error_q, struct scsi_cmnd *my_cmd) 247{ 248 struct scsi_cmnd *cmd, *n; 249 250 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 251 if (cmd == my_cmd) 252 list_del_init(&cmd->eh_entry); 253 } 254} 255 256static void sas_scsi_clear_queue_I_T(struct list_head *error_q, 257 struct domain_device *dev) 258{ 259 struct scsi_cmnd *cmd, *n; 260 261 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 262 struct domain_device *x = cmd_to_domain_dev(cmd); 263 264 if (x == dev) 265 list_del_init(&cmd->eh_entry); 266 } 267} 268 269static void sas_scsi_clear_queue_port(struct list_head *error_q, 270 struct asd_sas_port *port) 271{ 272 struct scsi_cmnd *cmd, *n; 273 274 list_for_each_entry_safe(cmd, n, error_q, eh_entry) { 275 struct domain_device *dev = cmd_to_domain_dev(cmd); 276 struct asd_sas_port *x = dev->port; 277 278 if (x == port) 279 list_del_init(&cmd->eh_entry); 280 } 281} 282 283enum task_disposition { 284 TASK_IS_DONE, 285 TASK_IS_ABORTED, 286 TASK_IS_AT_LU, 287 TASK_IS_NOT_AT_LU, 288 TASK_ABORT_FAILED, 289}; 290 291static enum task_disposition sas_scsi_find_task(struct sas_task *task) 292{ 293 struct sas_ha_struct *ha = task->dev->port->ha; 294 unsigned long flags; 295 int i, res; 296 struct sas_internal *si = 297 to_sas_internal(task->dev->port->ha->core.shost->transportt); 298 299 if (ha->lldd_max_execute_num > 1) { 300 struct scsi_core *core = &ha->core; 301 struct sas_task *t, *n; 302 303 spin_lock_irqsave(&core->task_queue_lock, flags); 304 list_for_each_entry_safe(t, n, &core->task_queue, list) { 305 if (task == t) { 306 list_del_init(&t->list); 307 spin_unlock_irqrestore(&core->task_queue_lock, 308 flags); 309 SAS_DPRINTK("%s: task 0x%p aborted from " 310 "task_queue\n", 311 __FUNCTION__, task); 312 return TASK_IS_ABORTED; 313 } 314 } 315 spin_unlock_irqrestore(&core->task_queue_lock, flags); 316 } 317 318 for (i = 0; i < 5; i++) { 319 SAS_DPRINTK("%s: aborting task 0x%p\n", __FUNCTION__, task); 320 res = si->dft->lldd_abort_task(task); 321 322 spin_lock_irqsave(&task->task_state_lock, flags); 323 if (task->task_state_flags & SAS_TASK_STATE_DONE) { 324 spin_unlock_irqrestore(&task->task_state_lock, flags); 325 SAS_DPRINTK("%s: task 0x%p is done\n", __FUNCTION__, 326 task); 327 return TASK_IS_DONE; 328 } 329 spin_unlock_irqrestore(&task->task_state_lock, flags); 330 331 if (res == TMF_RESP_FUNC_COMPLETE) { 332 SAS_DPRINTK("%s: task 0x%p is aborted\n", 333 __FUNCTION__, task); 334 return TASK_IS_ABORTED; 335 } else if (si->dft->lldd_query_task) { 336 SAS_DPRINTK("%s: querying task 0x%p\n", 337 __FUNCTION__, task); 338 res = si->dft->lldd_query_task(task); 339 switch (res) { 340 case TMF_RESP_FUNC_SUCC: 341 SAS_DPRINTK("%s: task 0x%p at LU\n", 342 __FUNCTION__, task); 343 return TASK_IS_AT_LU; 344 case TMF_RESP_FUNC_COMPLETE: 345 SAS_DPRINTK("%s: task 0x%p not at LU\n", 346 __FUNCTION__, task); 347 return TASK_IS_NOT_AT_LU; 348 case TMF_RESP_FUNC_FAILED: 349 SAS_DPRINTK("%s: task 0x%p failed to abort\n", 350 __FUNCTION__, task); 351 return TASK_ABORT_FAILED; 352 } 353 354 } 355 } 356 return res; 357} 358 359static int sas_recover_lu(struct domain_device *dev, struct scsi_cmnd *cmd) 360{ 361 int res = TMF_RESP_FUNC_FAILED; 362 struct scsi_lun lun; 363 struct sas_internal *i = 364 to_sas_internal(dev->port->ha->core.shost->transportt); 365 366 int_to_scsilun(cmd->device->lun, &lun); 367 368 SAS_DPRINTK("eh: device %llx LUN %x has the task\n", 369 SAS_ADDR(dev->sas_addr), 370 cmd->device->lun); 371 372 if (i->dft->lldd_abort_task_set) 373 res = i->dft->lldd_abort_task_set(dev, lun.scsi_lun); 374 375 if (res == TMF_RESP_FUNC_FAILED) { 376 if (i->dft->lldd_clear_task_set) 377 res = i->dft->lldd_clear_task_set(dev, lun.scsi_lun); 378 } 379 380 if (res == TMF_RESP_FUNC_FAILED) { 381 if (i->dft->lldd_lu_reset) 382 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 383 } 384 385 return res; 386} 387 388static int sas_recover_I_T(struct domain_device *dev) 389{ 390 int res = TMF_RESP_FUNC_FAILED; 391 struct sas_internal *i = 392 to_sas_internal(dev->port->ha->core.shost->transportt); 393 394 SAS_DPRINTK("I_T nexus reset for dev %016llx\n", 395 SAS_ADDR(dev->sas_addr)); 396 397 if (i->dft->lldd_I_T_nexus_reset) 398 res = i->dft->lldd_I_T_nexus_reset(dev); 399 400 return res; 401} 402 403/* Find the sas_phy that's attached to this device */ 404struct sas_phy *find_local_sas_phy(struct domain_device *dev) 405{ 406 struct domain_device *pdev = dev->parent; 407 struct ex_phy *exphy = NULL; 408 int i; 409 410 /* Directly attached device */ 411 if (!pdev) 412 return dev->port->phy; 413 414 /* Otherwise look in the expander */ 415 for (i = 0; i < pdev->ex_dev.num_phys; i++) 416 if (!memcmp(dev->sas_addr, 417 pdev->ex_dev.ex_phy[i].attached_sas_addr, 418 SAS_ADDR_SIZE)) { 419 exphy = &pdev->ex_dev.ex_phy[i]; 420 break; 421 } 422 423 BUG_ON(!exphy); 424 return exphy->phy; 425} 426 427/* Attempt to send a LUN reset message to a device */ 428int sas_eh_device_reset_handler(struct scsi_cmnd *cmd) 429{ 430 struct domain_device *dev = cmd_to_domain_dev(cmd); 431 struct sas_internal *i = 432 to_sas_internal(dev->port->ha->core.shost->transportt); 433 struct scsi_lun lun; 434 int res; 435 436 int_to_scsilun(cmd->device->lun, &lun); 437 438 if (!i->dft->lldd_lu_reset) 439 return FAILED; 440 441 res = i->dft->lldd_lu_reset(dev, lun.scsi_lun); 442 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 443 return SUCCESS; 444 445 return FAILED; 446} 447 448/* Attempt to send a phy (bus) reset */ 449int sas_eh_bus_reset_handler(struct scsi_cmnd *cmd) 450{ 451 struct domain_device *dev = cmd_to_domain_dev(cmd); 452 struct sas_phy *phy = find_local_sas_phy(dev); 453 int res; 454 455 res = sas_phy_reset(phy, 1); 456 if (res) 457 SAS_DPRINTK("Bus reset of %s failed 0x%x\n", 458 phy->dev.kobj.k_name, 459 res); 460 if (res == TMF_RESP_FUNC_SUCC || res == TMF_RESP_FUNC_COMPLETE) 461 return SUCCESS; 462 463 return FAILED; 464} 465 466/* Try to reset a device */ 467static int try_to_reset_cmd_device(struct Scsi_Host *shost, 468 struct scsi_cmnd *cmd) 469{ 470 int res; 471 472 if (!shost->hostt->eh_device_reset_handler) 473 goto try_bus_reset; 474 475 res = shost->hostt->eh_device_reset_handler(cmd); 476 if (res == SUCCESS) 477 return res; 478 479try_bus_reset: 480 if (shost->hostt->eh_bus_reset_handler) 481 return shost->hostt->eh_bus_reset_handler(cmd); 482 483 return FAILED; 484} 485 486static int sas_eh_handle_sas_errors(struct Scsi_Host *shost, 487 struct list_head *work_q, 488 struct list_head *done_q) 489{ 490 struct scsi_cmnd *cmd, *n; 491 enum task_disposition res = TASK_IS_DONE; 492 int tmf_resp, need_reset; 493 struct sas_internal *i = to_sas_internal(shost->transportt); 494 unsigned long flags; 495 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 496 497Again: 498 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 499 struct sas_task *task = TO_SAS_TASK(cmd); 500 501 if (!task) 502 continue; 503 504 list_del_init(&cmd->eh_entry); 505 506 spin_lock_irqsave(&task->task_state_lock, flags); 507 need_reset = task->task_state_flags & SAS_TASK_NEED_DEV_RESET; 508 spin_unlock_irqrestore(&task->task_state_lock, flags); 509 510 SAS_DPRINTK("trying to find task 0x%p\n", task); 511 res = sas_scsi_find_task(task); 512 513 cmd->eh_eflags = 0; 514 515 switch (res) { 516 case TASK_IS_DONE: 517 SAS_DPRINTK("%s: task 0x%p is done\n", __FUNCTION__, 518 task); 519 task->task_done(task); 520 if (need_reset) 521 try_to_reset_cmd_device(shost, cmd); 522 continue; 523 case TASK_IS_ABORTED: 524 SAS_DPRINTK("%s: task 0x%p is aborted\n", 525 __FUNCTION__, task); 526 task->task_done(task); 527 if (need_reset) 528 try_to_reset_cmd_device(shost, cmd); 529 continue; 530 case TASK_IS_AT_LU: 531 SAS_DPRINTK("task 0x%p is at LU: lu recover\n", task); 532 tmf_resp = sas_recover_lu(task->dev, cmd); 533 if (tmf_resp == TMF_RESP_FUNC_COMPLETE) { 534 SAS_DPRINTK("dev %016llx LU %x is " 535 "recovered\n", 536 SAS_ADDR(task->dev), 537 cmd->device->lun); 538 task->task_done(task); 539 if (need_reset) 540 try_to_reset_cmd_device(shost, cmd); 541 sas_scsi_clear_queue_lu(work_q, cmd); 542 goto Again; 543 } 544 /* fallthrough */ 545 case TASK_IS_NOT_AT_LU: 546 case TASK_ABORT_FAILED: 547 SAS_DPRINTK("task 0x%p is not at LU: I_T recover\n", 548 task); 549 tmf_resp = sas_recover_I_T(task->dev); 550 if (tmf_resp == TMF_RESP_FUNC_COMPLETE) { 551 SAS_DPRINTK("I_T %016llx recovered\n", 552 SAS_ADDR(task->dev->sas_addr)); 553 task->task_done(task); 554 if (need_reset) 555 try_to_reset_cmd_device(shost, cmd); 556 sas_scsi_clear_queue_I_T(work_q, task->dev); 557 goto Again; 558 } 559 /* Hammer time :-) */ 560 if (i->dft->lldd_clear_nexus_port) { 561 struct asd_sas_port *port = task->dev->port; 562 SAS_DPRINTK("clearing nexus for port:%d\n", 563 port->id); 564 res = i->dft->lldd_clear_nexus_port(port); 565 if (res == TMF_RESP_FUNC_COMPLETE) { 566 SAS_DPRINTK("clear nexus port:%d " 567 "succeeded\n", port->id); 568 task->task_done(task); 569 if (need_reset) 570 try_to_reset_cmd_device(shost, cmd); 571 sas_scsi_clear_queue_port(work_q, 572 port); 573 goto Again; 574 } 575 } 576 if (i->dft->lldd_clear_nexus_ha) { 577 SAS_DPRINTK("clear nexus ha\n"); 578 res = i->dft->lldd_clear_nexus_ha(ha); 579 if (res == TMF_RESP_FUNC_COMPLETE) { 580 SAS_DPRINTK("clear nexus ha " 581 "succeeded\n"); 582 task->task_done(task); 583 if (need_reset) 584 try_to_reset_cmd_device(shost, cmd); 585 goto out; 586 } 587 } 588 /* If we are here -- this means that no amount 589 * of effort could recover from errors. Quite 590 * possibly the HA just disappeared. 591 */ 592 SAS_DPRINTK("error from device %llx, LUN %x " 593 "couldn't be recovered in any way\n", 594 SAS_ADDR(task->dev->sas_addr), 595 cmd->device->lun); 596 597 task->task_done(task); 598 if (need_reset) 599 try_to_reset_cmd_device(shost, cmd); 600 goto clear_q; 601 } 602 } 603out: 604 return list_empty(work_q); 605clear_q: 606 SAS_DPRINTK("--- Exit %s -- clear_q\n", __FUNCTION__); 607 list_for_each_entry_safe(cmd, n, work_q, eh_entry) { 608 struct sas_task *task = TO_SAS_TASK(cmd); 609 list_del_init(&cmd->eh_entry); 610 task->task_done(task); 611 } 612 return list_empty(work_q); 613} 614 615void sas_scsi_recover_host(struct Scsi_Host *shost) 616{ 617 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 618 unsigned long flags; 619 LIST_HEAD(eh_work_q); 620 621 spin_lock_irqsave(shost->host_lock, flags); 622 list_splice_init(&shost->eh_cmd_q, &eh_work_q); 623 spin_unlock_irqrestore(shost->host_lock, flags); 624 625 SAS_DPRINTK("Enter %s\n", __FUNCTION__); 626 /* 627 * Deal with commands that still have SAS tasks (i.e. they didn't 628 * complete via the normal sas_task completion mechanism) 629 */ 630 if (sas_eh_handle_sas_errors(shost, &eh_work_q, &ha->eh_done_q)) 631 goto out; 632 633 /* 634 * Now deal with SCSI commands that completed ok but have a an error 635 * code (and hopefully sense data) attached. This is roughly what 636 * scsi_unjam_host does, but we skip scsi_eh_abort_cmds because any 637 * command we see here has no sas_task and is thus unknown to the HA. 638 */ 639 if (!scsi_eh_get_sense(&eh_work_q, &ha->eh_done_q)) 640 scsi_eh_ready_devs(shost, &eh_work_q, &ha->eh_done_q); 641 642out: 643 scsi_eh_flush_done_q(&ha->eh_done_q); 644 SAS_DPRINTK("--- Exit %s\n", __FUNCTION__); 645 return; 646} 647 648enum scsi_eh_timer_return sas_scsi_timed_out(struct scsi_cmnd *cmd) 649{ 650 struct sas_task *task = TO_SAS_TASK(cmd); 651 unsigned long flags; 652 653 if (!task) { 654 cmd->timeout_per_command /= 2; 655 SAS_DPRINTK("command 0x%p, task 0x%p, gone: %s\n", 656 cmd, task, (cmd->timeout_per_command ? 657 "EH_RESET_TIMER" : "EH_NOT_HANDLED")); 658 if (!cmd->timeout_per_command) 659 return EH_NOT_HANDLED; 660 return EH_RESET_TIMER; 661 } 662 663 spin_lock_irqsave(&task->task_state_lock, flags); 664 BUG_ON(task->task_state_flags & SAS_TASK_STATE_ABORTED); 665 if (task->task_state_flags & SAS_TASK_STATE_DONE) { 666 spin_unlock_irqrestore(&task->task_state_lock, flags); 667 SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_HANDLED\n", 668 cmd, task); 669 return EH_HANDLED; 670 } 671 if (!(task->task_state_flags & SAS_TASK_AT_INITIATOR)) { 672 spin_unlock_irqrestore(&task->task_state_lock, flags); 673 SAS_DPRINTK("command 0x%p, task 0x%p, not at initiator: " 674 "EH_RESET_TIMER\n", 675 cmd, task); 676 return EH_RESET_TIMER; 677 } 678 task->task_state_flags |= SAS_TASK_STATE_ABORTED; 679 spin_unlock_irqrestore(&task->task_state_lock, flags); 680 681 SAS_DPRINTK("command 0x%p, task 0x%p, timed out: EH_NOT_HANDLED\n", 682 cmd, task); 683 684 return EH_NOT_HANDLED; 685} 686 687struct domain_device *sas_find_dev_by_rphy(struct sas_rphy *rphy) 688{ 689 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent); 690 struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost); 691 struct domain_device *found_dev = NULL; 692 int i; 693 unsigned long flags; 694 695 spin_lock_irqsave(&ha->phy_port_lock, flags); 696 for (i = 0; i < ha->num_phys; i++) { 697 struct asd_sas_port *port = ha->sas_port[i]; 698 struct domain_device *dev; 699 700 spin_lock(&port->dev_list_lock); 701 list_for_each_entry(dev, &port->dev_list, dev_list_node) { 702 if (rphy == dev->rphy) { 703 found_dev = dev; 704 spin_unlock(&port->dev_list_lock); 705 goto found; 706 } 707 } 708 spin_unlock(&port->dev_list_lock); 709 } 710 found: 711 spin_unlock_irqrestore(&ha->phy_port_lock, flags); 712 713 return found_dev; 714} 715 716static inline struct domain_device *sas_find_target(struct scsi_target *starget) 717{ 718 struct sas_rphy *rphy = dev_to_rphy(starget->dev.parent); 719 720 return sas_find_dev_by_rphy(rphy); 721} 722 723int sas_target_alloc(struct scsi_target *starget) 724{ 725 struct domain_device *found_dev = sas_find_target(starget); 726 727 if (!found_dev) 728 return -ENODEV; 729 730 starget->hostdata = found_dev; 731 return 0; 732} 733 734#define SAS_DEF_QD 32 735#define SAS_MAX_QD 64 736 737int sas_slave_configure(struct scsi_device *scsi_dev) 738{ 739 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 740 struct sas_ha_struct *sas_ha; 741 742 BUG_ON(dev->rphy->identify.device_type != SAS_END_DEVICE); 743 744 sas_ha = dev->port->ha; 745 746 sas_read_port_mode_page(scsi_dev); 747 748 if (scsi_dev->tagged_supported) { 749 scsi_set_tag_type(scsi_dev, MSG_SIMPLE_TAG); 750 scsi_activate_tcq(scsi_dev, SAS_DEF_QD); 751 } else { 752 SAS_DPRINTK("device %llx, LUN %x doesn't support " 753 "TCQ\n", SAS_ADDR(dev->sas_addr), 754 scsi_dev->lun); 755 scsi_dev->tagged_supported = 0; 756 scsi_set_tag_type(scsi_dev, 0); 757 scsi_deactivate_tcq(scsi_dev, 1); 758 } 759 760 scsi_dev->allow_restart = 1; 761 762 return 0; 763} 764 765void sas_slave_destroy(struct scsi_device *scsi_dev) 766{ 767} 768 769int sas_change_queue_depth(struct scsi_device *scsi_dev, int new_depth) 770{ 771 int res = min(new_depth, SAS_MAX_QD); 772 773 if (scsi_dev->tagged_supported) 774 scsi_adjust_queue_depth(scsi_dev, scsi_get_tag_type(scsi_dev), 775 res); 776 else { 777 struct domain_device *dev = sdev_to_domain_dev(scsi_dev); 778 sas_printk("device %llx LUN %x queue depth changed to 1\n", 779 SAS_ADDR(dev->sas_addr), 780 scsi_dev->lun); 781 scsi_adjust_queue_depth(scsi_dev, 0, 1); 782 res = 1; 783 } 784 785 return res; 786} 787 788int sas_change_queue_type(struct scsi_device *scsi_dev, int qt) 789{ 790 if (!scsi_dev->tagged_supported) 791 return 0; 792 793 scsi_deactivate_tcq(scsi_dev, 1); 794 795 scsi_set_tag_type(scsi_dev, qt); 796 scsi_activate_tcq(scsi_dev, scsi_dev->queue_depth); 797 798 return qt; 799} 800 801int sas_bios_param(struct scsi_device *scsi_dev, 802 struct block_device *bdev, 803 sector_t capacity, int *hsc) 804{ 805 hsc[0] = 255; 806 hsc[1] = 63; 807 sector_div(capacity, 255*63); 808 hsc[2] = capacity; 809 810 return 0; 811} 812 813/* ---------- Task Collector Thread implementation ---------- */ 814 815static void sas_queue(struct sas_ha_struct *sas_ha) 816{ 817 struct scsi_core *core = &sas_ha->core; 818 unsigned long flags; 819 LIST_HEAD(q); 820 int can_queue; 821 int res; 822 struct sas_internal *i = to_sas_internal(core->shost->transportt); 823 824 spin_lock_irqsave(&core->task_queue_lock, flags); 825 while (!kthread_should_stop() && 826 !list_empty(&core->task_queue)) { 827 828 can_queue = sas_ha->lldd_queue_size - core->task_queue_size; 829 if (can_queue >= 0) { 830 can_queue = core->task_queue_size; 831 list_splice_init(&core->task_queue, &q); 832 } else { 833 struct list_head *a, *n; 834 835 can_queue = sas_ha->lldd_queue_size; 836 list_for_each_safe(a, n, &core->task_queue) { 837 list_move_tail(a, &q); 838 if (--can_queue == 0) 839 break; 840 } 841 can_queue = sas_ha->lldd_queue_size; 842 } 843 core->task_queue_size -= can_queue; 844 spin_unlock_irqrestore(&core->task_queue_lock, flags); 845 { 846 struct sas_task *task = list_entry(q.next, 847 struct sas_task, 848 list); 849 list_del_init(&q); 850 res = i->dft->lldd_execute_task(task, can_queue, 851 GFP_KERNEL); 852 if (unlikely(res)) 853 __list_add(&q, task->list.prev, &task->list); 854 } 855 spin_lock_irqsave(&core->task_queue_lock, flags); 856 if (res) { 857 list_splice_init(&q, &core->task_queue); /*at head*/ 858 core->task_queue_size += can_queue; 859 } 860 } 861 spin_unlock_irqrestore(&core->task_queue_lock, flags); 862} 863 864/** 865 * sas_queue_thread -- The Task Collector thread 866 * @_sas_ha: pointer to struct sas_ha 867 */ 868static int sas_queue_thread(void *_sas_ha) 869{ 870 struct sas_ha_struct *sas_ha = _sas_ha; 871 872 while (1) { 873 set_current_state(TASK_INTERRUPTIBLE); 874 schedule(); 875 sas_queue(sas_ha); 876 if (kthread_should_stop()) 877 break; 878 } 879 880 return 0; 881} 882 883int sas_init_queue(struct sas_ha_struct *sas_ha) 884{ 885 struct scsi_core *core = &sas_ha->core; 886 887 spin_lock_init(&core->task_queue_lock); 888 core->task_queue_size = 0; 889 INIT_LIST_HEAD(&core->task_queue); 890 891 core->queue_thread = kthread_run(sas_queue_thread, sas_ha, 892 "sas_queue_%d", core->shost->host_no); 893 if (IS_ERR(core->queue_thread)) 894 return PTR_ERR(core->queue_thread); 895 return 0; 896} 897 898void sas_shutdown_queue(struct sas_ha_struct *sas_ha) 899{ 900 unsigned long flags; 901 struct scsi_core *core = &sas_ha->core; 902 struct sas_task *task, *n; 903 904 kthread_stop(core->queue_thread); 905 906 if (!list_empty(&core->task_queue)) 907 SAS_DPRINTK("HA: %llx: scsi core task queue is NOT empty!?\n", 908 SAS_ADDR(sas_ha->sas_addr)); 909 910 spin_lock_irqsave(&core->task_queue_lock, flags); 911 list_for_each_entry_safe(task, n, &core->task_queue, list) { 912 struct scsi_cmnd *cmd = task->uldd_task; 913 914 list_del_init(&task->list); 915 916 ASSIGN_SAS_TASK(cmd, NULL); 917 sas_free_task(task); 918 cmd->result = DID_ABORT << 16; 919 cmd->scsi_done(cmd); 920 } 921 spin_unlock_irqrestore(&core->task_queue_lock, flags); 922} 923 924/* 925 * Call the LLDD task abort routine directly. This function is intended for 926 * use by upper layers that need to tell the LLDD to abort a task. 927 */ 928int __sas_task_abort(struct sas_task *task) 929{ 930 struct sas_internal *si = 931 to_sas_internal(task->dev->port->ha->core.shost->transportt); 932 unsigned long flags; 933 int res; 934 935 spin_lock_irqsave(&task->task_state_lock, flags); 936 if (task->task_state_flags & SAS_TASK_STATE_ABORTED || 937 task->task_state_flags & SAS_TASK_STATE_DONE) { 938 spin_unlock_irqrestore(&task->task_state_lock, flags); 939 SAS_DPRINTK("%s: Task %p already finished.\n", __FUNCTION__, 940 task); 941 return 0; 942 } 943 task->task_state_flags |= SAS_TASK_STATE_ABORTED; 944 spin_unlock_irqrestore(&task->task_state_lock, flags); 945 946 if (!si->dft->lldd_abort_task) 947 return -ENODEV; 948 949 res = si->dft->lldd_abort_task(task); 950 951 spin_lock_irqsave(&task->task_state_lock, flags); 952 if ((task->task_state_flags & SAS_TASK_STATE_DONE) || 953 (res == TMF_RESP_FUNC_COMPLETE)) 954 { 955 spin_unlock_irqrestore(&task->task_state_lock, flags); 956 task->task_done(task); 957 return 0; 958 } 959 960 if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) 961 task->task_state_flags &= ~SAS_TASK_STATE_ABORTED; 962 spin_unlock_irqrestore(&task->task_state_lock, flags); 963 964 return -EAGAIN; 965} 966 967/* 968 * Tell an upper layer that it needs to initiate an abort for a given task. 969 * This should only ever be called by an LLDD. 970 */ 971void sas_task_abort(struct sas_task *task) 972{ 973 struct scsi_cmnd *sc = task->uldd_task; 974 975 /* Escape for libsas internal commands */ 976 if (!sc) { 977 if (!del_timer(&task->timer)) 978 return; 979 task->timer.function(task->timer.data); 980 return; 981 } 982 983 scsi_req_abort_cmd(sc); 984 scsi_schedule_eh(sc->device->host); 985} 986 987EXPORT_SYMBOL_GPL(sas_queuecommand); 988EXPORT_SYMBOL_GPL(sas_target_alloc); 989EXPORT_SYMBOL_GPL(sas_slave_configure); 990EXPORT_SYMBOL_GPL(sas_slave_destroy); 991EXPORT_SYMBOL_GPL(sas_change_queue_depth); 992EXPORT_SYMBOL_GPL(sas_change_queue_type); 993EXPORT_SYMBOL_GPL(sas_bios_param); 994EXPORT_SYMBOL_GPL(__sas_task_abort); 995EXPORT_SYMBOL_GPL(sas_task_abort); 996EXPORT_SYMBOL_GPL(sas_phy_reset); 997EXPORT_SYMBOL_GPL(sas_phy_enable); 998EXPORT_SYMBOL_GPL(sas_eh_device_reset_handler); 999EXPORT_SYMBOL_GPL(sas_eh_bus_reset_handler); 1000