1 /* 2 * Copyright 2014 Cisco Systems, Inc. All rights reserved. 3 * 4 * This program is free software; you may redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; version 2 of the License. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 9 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 10 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 11 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 12 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 13 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 14 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 15 * SOFTWARE. 16 */ 17 18 #include <linux/mempool.h> 19 #include <linux/errno.h> 20 #include <linux/init.h> 21 #include <linux/workqueue.h> 22 #include <linux/pci.h> 23 #include <linux/spinlock.h> 24 #include <linux/delay.h> 25 #include <linux/gfp.h> 26 #include <scsi/scsi.h> 27 #include <scsi/scsi_host.h> 28 #include <scsi/scsi_device.h> 29 #include <scsi/scsi_cmnd.h> 30 #include <scsi/scsi_tcq.h> 31 #include <scsi/scsi_dbg.h> 32 33 #include "snic_io.h" 34 #include "snic.h" 35 36 #define snic_cmd_tag(sc) (((struct scsi_cmnd *) sc)->request->tag) 37 38 const char *snic_state_str[] = { 39 [SNIC_INIT] = "SNIC_INIT", 40 [SNIC_ERROR] = "SNIC_ERROR", 41 [SNIC_ONLINE] = "SNIC_ONLINE", 42 [SNIC_OFFLINE] = "SNIC_OFFLINE", 43 [SNIC_FWRESET] = "SNIC_FWRESET", 44 }; 45 46 static const char * const snic_req_state_str[] = { 47 [SNIC_IOREQ_NOT_INITED] = "SNIC_IOREQ_NOT_INITED", 48 [SNIC_IOREQ_PENDING] = "SNIC_IOREQ_PENDING", 49 [SNIC_IOREQ_ABTS_PENDING] = "SNIC_IOREQ_ABTS_PENDING", 50 [SNIC_IOREQ_ABTS_COMPLETE] = "SNIC_IOREQ_ABTS_COMPELTE", 51 [SNIC_IOREQ_LR_PENDING] = "SNIC_IOREQ_LR_PENDING", 52 [SNIC_IOREQ_LR_COMPLETE] = "SNIC_IOREQ_LR_COMPELTE", 53 [SNIC_IOREQ_COMPLETE] = "SNIC_IOREQ_CMD_COMPELTE", 54 }; 55 56 /* snic cmd status strings */ 57 static const char * const snic_io_status_str[] = { 58 [SNIC_STAT_IO_SUCCESS] = "SNIC_STAT_IO_SUCCESS", /* 0x0 */ 59 [SNIC_STAT_INVALID_HDR] = "SNIC_STAT_INVALID_HDR", 60 [SNIC_STAT_OUT_OF_RES] = "SNIC_STAT_OUT_OF_RES", 61 [SNIC_STAT_INVALID_PARM] = "SNIC_STAT_INVALID_PARM", 62 [SNIC_STAT_REQ_NOT_SUP] = "SNIC_STAT_REQ_NOT_SUP", 63 [SNIC_STAT_IO_NOT_FOUND] = "SNIC_STAT_IO_NOT_FOUND", 64 [SNIC_STAT_ABORTED] = "SNIC_STAT_ABORTED", 65 [SNIC_STAT_TIMEOUT] = "SNIC_STAT_TIMEOUT", 66 [SNIC_STAT_SGL_INVALID] = "SNIC_STAT_SGL_INVALID", 67 [SNIC_STAT_DATA_CNT_MISMATCH] = "SNIC_STAT_DATA_CNT_MISMATCH", 68 [SNIC_STAT_FW_ERR] = "SNIC_STAT_FW_ERR", 69 [SNIC_STAT_ITMF_REJECT] = "SNIC_STAT_ITMF_REJECT", 70 [SNIC_STAT_ITMF_FAIL] = "SNIC_STAT_ITMF_FAIL", 71 [SNIC_STAT_ITMF_INCORRECT_LUN] = "SNIC_STAT_ITMF_INCORRECT_LUN", 72 [SNIC_STAT_CMND_REJECT] = "SNIC_STAT_CMND_REJECT", 73 [SNIC_STAT_DEV_OFFLINE] = "SNIC_STAT_DEV_OFFLINE", 74 [SNIC_STAT_NO_BOOTLUN] = "SNIC_STAT_NO_BOOTLUN", 75 [SNIC_STAT_SCSI_ERR] = "SNIC_STAT_SCSI_ERR", 76 [SNIC_STAT_NOT_READY] = "SNIC_STAT_NOT_READY", 77 [SNIC_STAT_FATAL_ERROR] = "SNIC_STAT_FATAL_ERROR", 78 }; 79 80 static void snic_scsi_cleanup(struct snic *, int); 81 82 const char * 83 snic_state_to_str(unsigned int state) 84 { 85 if (state >= ARRAY_SIZE(snic_state_str) || !snic_state_str[state]) 86 return "Unknown"; 87 88 return snic_state_str[state]; 89 } 90 91 static const char * 92 snic_io_status_to_str(unsigned int state) 93 { 94 if ((state >= ARRAY_SIZE(snic_io_status_str)) || 95 (!snic_io_status_str[state])) 96 return "Unknown"; 97 98 return snic_io_status_str[state]; 99 } 100 101 static const char * 102 snic_ioreq_state_to_str(unsigned int state) 103 { 104 if (state >= ARRAY_SIZE(snic_req_state_str) || 105 !snic_req_state_str[state]) 106 return "Unknown"; 107 108 return snic_req_state_str[state]; 109 } 110 111 static inline spinlock_t * 112 snic_io_lock_hash(struct snic *snic, struct scsi_cmnd *sc) 113 { 114 u32 hash = snic_cmd_tag(sc) & (SNIC_IO_LOCKS - 1); 115 116 return &snic->io_req_lock[hash]; 117 } 118 119 static inline spinlock_t * 120 snic_io_lock_tag(struct snic *snic, int tag) 121 { 122 return &snic->io_req_lock[tag & (SNIC_IO_LOCKS - 1)]; 123 } 124 125 /* snic_release_req_buf : Releases snic_req_info */ 126 static void 127 snic_release_req_buf(struct snic *snic, 128 struct snic_req_info *rqi, 129 struct scsi_cmnd *sc) 130 { 131 struct snic_host_req *req = rqi_to_req(rqi); 132 133 /* Freeing cmd without marking completion, not okay */ 134 SNIC_BUG_ON(!((CMD_STATE(sc) == SNIC_IOREQ_COMPLETE) || 135 (CMD_STATE(sc) == SNIC_IOREQ_ABTS_COMPLETE) || 136 (CMD_FLAGS(sc) & SNIC_DEV_RST_NOTSUP) || 137 (CMD_FLAGS(sc) & SNIC_IO_INTERNAL_TERM_ISSUED) || 138 (CMD_FLAGS(sc) & SNIC_DEV_RST_TERM_ISSUED) || 139 (CMD_FLAGS(sc) & SNIC_SCSI_CLEANUP) || 140 (CMD_STATE(sc) == SNIC_IOREQ_LR_COMPLETE))); 141 142 SNIC_SCSI_DBG(snic->shost, 143 "Rel_req:sc %p:tag %x:rqi %p:ioreq %p:abt %p:dr %p: state %s:flags 0x%llx\n", 144 sc, snic_cmd_tag(sc), rqi, rqi->req, rqi->abort_req, 145 rqi->dr_req, snic_ioreq_state_to_str(CMD_STATE(sc)), 146 CMD_FLAGS(sc)); 147 148 if (req->u.icmnd.sense_addr) 149 pci_unmap_single(snic->pdev, 150 le64_to_cpu(req->u.icmnd.sense_addr), 151 SCSI_SENSE_BUFFERSIZE, 152 PCI_DMA_FROMDEVICE); 153 154 scsi_dma_unmap(sc); 155 156 snic_req_free(snic, rqi); 157 } /* end of snic_release_req_buf */ 158 159 /* 160 * snic_queue_icmnd_req : Queues snic_icmnd request 161 */ 162 static int 163 snic_queue_icmnd_req(struct snic *snic, 164 struct snic_req_info *rqi, 165 struct scsi_cmnd *sc, 166 int sg_cnt) 167 { 168 struct scatterlist *sg; 169 struct snic_sg_desc *sgd; 170 dma_addr_t pa = 0; 171 struct scsi_lun lun; 172 u16 flags = 0; 173 int ret = 0; 174 unsigned int i; 175 176 if (sg_cnt) { 177 flags = SNIC_ICMND_ESGL; 178 sgd = (struct snic_sg_desc *) req_to_sgl(rqi->req); 179 180 for_each_sg(scsi_sglist(sc), sg, sg_cnt, i) { 181 sgd->addr = cpu_to_le64(sg_dma_address(sg)); 182 sgd->len = cpu_to_le32(sg_dma_len(sg)); 183 sgd->_resvd = 0; 184 sgd++; 185 } 186 } 187 188 pa = pci_map_single(snic->pdev, 189 sc->sense_buffer, 190 SCSI_SENSE_BUFFERSIZE, 191 PCI_DMA_FROMDEVICE); 192 193 if (pci_dma_mapping_error(snic->pdev, pa)) { 194 SNIC_HOST_ERR(snic->shost, 195 "QIcmnd:PCI Map Failed for sns buf %p tag %x\n", 196 sc->sense_buffer, snic_cmd_tag(sc)); 197 ret = -ENOMEM; 198 199 return ret; 200 } 201 202 int_to_scsilun(sc->device->lun, &lun); 203 if (sc->sc_data_direction == DMA_FROM_DEVICE) 204 flags |= SNIC_ICMND_RD; 205 if (sc->sc_data_direction == DMA_TO_DEVICE) 206 flags |= SNIC_ICMND_WR; 207 208 /* Initialize icmnd */ 209 snic_icmnd_init(rqi->req, 210 snic_cmd_tag(sc), 211 snic->config.hid, /* hid */ 212 (ulong) rqi, 213 flags, /* command flags */ 214 rqi->tgt_id, 215 lun.scsi_lun, 216 sc->cmnd, 217 sc->cmd_len, 218 scsi_bufflen(sc), 219 sg_cnt, 220 (ulong) req_to_sgl(rqi->req), 221 pa, /* sense buffer pa */ 222 SCSI_SENSE_BUFFERSIZE); 223 224 atomic64_inc(&snic->s_stats.io.active); 225 ret = snic_queue_wq_desc(snic, rqi->req, rqi->req_len); 226 if (ret) { 227 atomic64_dec(&snic->s_stats.io.active); 228 SNIC_HOST_ERR(snic->shost, 229 "QIcmnd: Queuing Icmnd Failed. ret = %d\n", 230 ret); 231 } else 232 snic_stats_update_active_ios(&snic->s_stats); 233 234 return ret; 235 } /* end of snic_queue_icmnd_req */ 236 237 /* 238 * snic_issue_scsi_req : Prepares IO request and Issues to FW. 239 */ 240 static int 241 snic_issue_scsi_req(struct snic *snic, 242 struct snic_tgt *tgt, 243 struct scsi_cmnd *sc) 244 { 245 struct snic_req_info *rqi = NULL; 246 int sg_cnt = 0; 247 int ret = 0; 248 u32 tag = snic_cmd_tag(sc); 249 u64 cmd_trc = 0, cmd_st_flags = 0; 250 spinlock_t *io_lock = NULL; 251 unsigned long flags; 252 253 CMD_STATE(sc) = SNIC_IOREQ_NOT_INITED; 254 CMD_FLAGS(sc) = SNIC_NO_FLAGS; 255 sg_cnt = scsi_dma_map(sc); 256 if (sg_cnt < 0) { 257 SNIC_TRC((u16)snic->shost->host_no, tag, (ulong) sc, 0, 258 sc->cmnd[0], sg_cnt, CMD_STATE(sc)); 259 260 SNIC_HOST_ERR(snic->shost, "issue_sc:Failed to map SG List.\n"); 261 ret = -ENOMEM; 262 263 goto issue_sc_end; 264 } 265 266 rqi = snic_req_init(snic, sg_cnt); 267 if (!rqi) { 268 scsi_dma_unmap(sc); 269 ret = -ENOMEM; 270 271 goto issue_sc_end; 272 } 273 274 rqi->tgt_id = tgt->id; 275 rqi->sc = sc; 276 277 CMD_STATE(sc) = SNIC_IOREQ_PENDING; 278 CMD_SP(sc) = (char *) rqi; 279 cmd_trc = SNIC_TRC_CMD(sc); 280 CMD_FLAGS(sc) |= (SNIC_IO_INITIALIZED | SNIC_IO_ISSUED); 281 cmd_st_flags = SNIC_TRC_CMD_STATE_FLAGS(sc); 282 io_lock = snic_io_lock_hash(snic, sc); 283 284 /* create wq desc and enqueue it */ 285 ret = snic_queue_icmnd_req(snic, rqi, sc, sg_cnt); 286 if (ret) { 287 SNIC_HOST_ERR(snic->shost, 288 "issue_sc: icmnd qing Failed for sc %p, err %d\n", 289 sc, ret); 290 291 spin_lock_irqsave(io_lock, flags); 292 rqi = (struct snic_req_info *) CMD_SP(sc); 293 CMD_SP(sc) = NULL; 294 CMD_STATE(sc) = SNIC_IOREQ_COMPLETE; 295 CMD_FLAGS(sc) &= ~SNIC_IO_ISSUED; /* turn off the flag */ 296 spin_unlock_irqrestore(io_lock, flags); 297 298 if (rqi) 299 snic_release_req_buf(snic, rqi, sc); 300 301 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc, 0, 0, 0, 302 SNIC_TRC_CMD_STATE_FLAGS(sc)); 303 } else { 304 u32 io_sz = scsi_bufflen(sc) >> 9; 305 u32 qtime = jiffies - rqi->start_time; 306 struct snic_io_stats *iostats = &snic->s_stats.io; 307 308 if (io_sz > atomic64_read(&iostats->max_io_sz)) 309 atomic64_set(&iostats->max_io_sz, io_sz); 310 311 if (qtime > atomic64_read(&iostats->max_qtime)) 312 atomic64_set(&iostats->max_qtime, qtime); 313 314 SNIC_SCSI_DBG(snic->shost, 315 "issue_sc:sc %p, tag %d queued to WQ.\n", 316 sc, tag); 317 318 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc, (ulong) rqi, 319 sg_cnt, cmd_trc, cmd_st_flags); 320 } 321 322 issue_sc_end: 323 324 return ret; 325 } /* end of snic_issue_scsi_req */ 326 327 328 /* 329 * snic_queuecommand 330 * Routine to send a scsi cdb to LLD 331 * Called with host_lock held and interrupts disabled 332 */ 333 int 334 snic_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc) 335 { 336 struct snic_tgt *tgt = NULL; 337 struct snic *snic = shost_priv(shost); 338 int ret; 339 340 tgt = starget_to_tgt(scsi_target(sc->device)); 341 ret = snic_tgt_chkready(tgt); 342 if (ret) { 343 SNIC_HOST_ERR(shost, "Tgt %p id %d Not Ready.\n", tgt, tgt->id); 344 atomic64_inc(&snic->s_stats.misc.tgt_not_rdy); 345 sc->result = ret; 346 sc->scsi_done(sc); 347 348 return 0; 349 } 350 351 if (snic_get_state(snic) != SNIC_ONLINE) { 352 SNIC_HOST_ERR(shost, "snic state is %s\n", 353 snic_state_str[snic_get_state(snic)]); 354 355 return SCSI_MLQUEUE_HOST_BUSY; 356 } 357 atomic_inc(&snic->ios_inflight); 358 359 SNIC_SCSI_DBG(shost, "sc %p Tag %d (sc %0x) lun %lld in snic_qcmd\n", 360 sc, snic_cmd_tag(sc), sc->cmnd[0], sc->device->lun); 361 362 memset(scsi_cmd_priv(sc), 0, sizeof(struct snic_internal_io_state)); 363 364 ret = snic_issue_scsi_req(snic, tgt, sc); 365 if (ret) { 366 SNIC_HOST_ERR(shost, "Failed to Q, Scsi Req w/ err %d.\n", ret); 367 ret = SCSI_MLQUEUE_HOST_BUSY; 368 } 369 370 atomic_dec(&snic->ios_inflight); 371 372 return ret; 373 } /* end of snic_queuecommand */ 374 375 /* 376 * snic_process_abts_pending_state: 377 * caller should hold IO lock 378 */ 379 static void 380 snic_proc_tmreq_pending_state(struct snic *snic, 381 struct scsi_cmnd *sc, 382 u8 cmpl_status) 383 { 384 int state = CMD_STATE(sc); 385 386 if (state == SNIC_IOREQ_ABTS_PENDING) 387 CMD_FLAGS(sc) |= SNIC_IO_ABTS_PENDING; 388 else if (state == SNIC_IOREQ_LR_PENDING) 389 CMD_FLAGS(sc) |= SNIC_DEV_RST_PENDING; 390 else 391 SNIC_BUG_ON(1); 392 393 switch (cmpl_status) { 394 case SNIC_STAT_IO_SUCCESS: 395 CMD_FLAGS(sc) |= SNIC_IO_DONE; 396 break; 397 398 case SNIC_STAT_ABORTED: 399 CMD_FLAGS(sc) |= SNIC_IO_ABORTED; 400 break; 401 402 default: 403 SNIC_BUG_ON(1); 404 } 405 } 406 407 /* 408 * snic_process_io_failed_state: 409 * Processes IO's error states 410 */ 411 static void 412 snic_process_io_failed_state(struct snic *snic, 413 struct snic_icmnd_cmpl *icmnd_cmpl, 414 struct scsi_cmnd *sc, 415 u8 cmpl_stat) 416 { 417 int res = 0; 418 419 switch (cmpl_stat) { 420 case SNIC_STAT_TIMEOUT: /* Req was timedout */ 421 atomic64_inc(&snic->s_stats.misc.io_tmo); 422 res = DID_TIME_OUT; 423 break; 424 425 case SNIC_STAT_ABORTED: /* Req was aborted */ 426 atomic64_inc(&snic->s_stats.misc.io_aborted); 427 res = DID_ABORT; 428 break; 429 430 case SNIC_STAT_DATA_CNT_MISMATCH:/* Recv/Sent more/less data than exp */ 431 atomic64_inc(&snic->s_stats.misc.data_cnt_mismat); 432 scsi_set_resid(sc, le32_to_cpu(icmnd_cmpl->resid)); 433 res = DID_ERROR; 434 break; 435 436 case SNIC_STAT_OUT_OF_RES: /* Out of resources to complete request */ 437 atomic64_inc(&snic->s_stats.fw.out_of_res); 438 res = DID_REQUEUE; 439 break; 440 441 case SNIC_STAT_IO_NOT_FOUND: /* Requested I/O was not found */ 442 atomic64_inc(&snic->s_stats.io.io_not_found); 443 res = DID_ERROR; 444 break; 445 446 case SNIC_STAT_SGL_INVALID: /* Req was aborted to due to sgl error*/ 447 atomic64_inc(&snic->s_stats.misc.sgl_inval); 448 res = DID_ERROR; 449 break; 450 451 case SNIC_STAT_FW_ERR: /* Req terminated due to FW Error */ 452 atomic64_inc(&snic->s_stats.fw.io_errs); 453 res = DID_ERROR; 454 break; 455 456 case SNIC_STAT_SCSI_ERR: /* FW hits SCSI Error */ 457 atomic64_inc(&snic->s_stats.fw.scsi_errs); 458 break; 459 460 case SNIC_STAT_NOT_READY: /* XPT yet to initialize */ 461 case SNIC_STAT_DEV_OFFLINE: /* Device offline */ 462 res = DID_NO_CONNECT; 463 break; 464 465 case SNIC_STAT_INVALID_HDR: /* Hdr contains invalid data */ 466 case SNIC_STAT_INVALID_PARM: /* Some param in req is invalid */ 467 case SNIC_STAT_REQ_NOT_SUP: /* Req type is not supported */ 468 case SNIC_STAT_CMND_REJECT: /* Req rejected */ 469 case SNIC_STAT_FATAL_ERROR: /* XPT Error */ 470 default: 471 SNIC_SCSI_DBG(snic->shost, 472 "Invalid Hdr/Param or Req Not Supported or Cmnd Rejected or Device Offline. or Unknown\n"); 473 res = DID_ERROR; 474 break; 475 } 476 477 SNIC_HOST_ERR(snic->shost, "fw returns failed status %s flags 0x%llx\n", 478 snic_io_status_to_str(cmpl_stat), CMD_FLAGS(sc)); 479 480 /* Set sc->result */ 481 sc->result = (res << 16) | icmnd_cmpl->scsi_status; 482 } /* end of snic_process_io_failed_state */ 483 484 /* 485 * snic_tmreq_pending : is task management in progress. 486 */ 487 static int 488 snic_tmreq_pending(struct scsi_cmnd *sc) 489 { 490 int state = CMD_STATE(sc); 491 492 return ((state == SNIC_IOREQ_ABTS_PENDING) || 493 (state == SNIC_IOREQ_LR_PENDING)); 494 } 495 496 /* 497 * snic_process_icmnd_cmpl_status: 498 * Caller should hold io_lock 499 */ 500 static int 501 snic_process_icmnd_cmpl_status(struct snic *snic, 502 struct snic_icmnd_cmpl *icmnd_cmpl, 503 u8 cmpl_stat, 504 struct scsi_cmnd *sc) 505 { 506 u8 scsi_stat = icmnd_cmpl->scsi_status; 507 u64 xfer_len = 0; 508 int ret = 0; 509 510 /* Mark the IO as complete */ 511 CMD_STATE(sc) = SNIC_IOREQ_COMPLETE; 512 513 if (likely(cmpl_stat == SNIC_STAT_IO_SUCCESS)) { 514 sc->result = (DID_OK << 16) | scsi_stat; 515 516 xfer_len = scsi_bufflen(sc); 517 518 /* Update SCSI Cmd with resid value */ 519 scsi_set_resid(sc, le32_to_cpu(icmnd_cmpl->resid)); 520 521 if (icmnd_cmpl->flags & SNIC_ICMND_CMPL_UNDR_RUN) { 522 xfer_len -= le32_to_cpu(icmnd_cmpl->resid); 523 atomic64_inc(&snic->s_stats.misc.io_under_run); 524 } 525 526 if (icmnd_cmpl->scsi_status == SAM_STAT_TASK_SET_FULL) 527 atomic64_inc(&snic->s_stats.misc.qfull); 528 529 ret = 0; 530 } else { 531 snic_process_io_failed_state(snic, icmnd_cmpl, sc, cmpl_stat); 532 atomic64_inc(&snic->s_stats.io.fail); 533 SNIC_HOST_ERR(snic->shost, 534 "icmnd_cmpl: IO Failed : Hdr Status %s flags 0x%llx\n", 535 snic_io_status_to_str(cmpl_stat), CMD_FLAGS(sc)); 536 ret = 1; 537 } 538 539 return ret; 540 } /* end of snic_process_icmnd_cmpl_status */ 541 542 543 /* 544 * snic_icmnd_cmpl_handler 545 * Routine to handle icmnd completions 546 */ 547 static void 548 snic_icmnd_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq) 549 { 550 u8 typ, hdr_stat; 551 u32 cmnd_id, hid; 552 ulong ctx; 553 struct scsi_cmnd *sc = NULL; 554 struct snic_icmnd_cmpl *icmnd_cmpl = NULL; 555 struct snic_host_req *req = NULL; 556 struct snic_req_info *rqi = NULL; 557 unsigned long flags, start_time; 558 spinlock_t *io_lock; 559 u8 sc_stat = 0; 560 561 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx); 562 icmnd_cmpl = &fwreq->u.icmnd_cmpl; 563 sc_stat = icmnd_cmpl->scsi_status; 564 565 SNIC_SCSI_DBG(snic->shost, 566 "Icmnd_cmpl: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x,i ctx = %lx\n", 567 typ, hdr_stat, cmnd_id, hid, ctx); 568 569 if (cmnd_id >= snic->max_tag_id) { 570 SNIC_HOST_ERR(snic->shost, 571 "Icmnd_cmpl:Tag Error:Out of Range Tag %d, hdr status = %s\n", 572 cmnd_id, snic_io_status_to_str(hdr_stat)); 573 return; 574 } 575 576 sc = scsi_host_find_tag(snic->shost, cmnd_id); 577 WARN_ON_ONCE(!sc); 578 579 if (!sc) { 580 atomic64_inc(&snic->s_stats.io.sc_null); 581 SNIC_HOST_ERR(snic->shost, 582 "Icmnd_cmpl: Scsi Cmnd Not found, sc = NULL Hdr Status = %s tag = 0x%x fwreq = 0x%p\n", 583 snic_io_status_to_str(hdr_stat), 584 cmnd_id, 585 fwreq); 586 587 SNIC_TRC(snic->shost->host_no, cmnd_id, 0, 588 ((u64)hdr_stat << 16 | 589 (u64)sc_stat << 8 | (u64)icmnd_cmpl->flags), 590 (ulong) fwreq, le32_to_cpu(icmnd_cmpl->resid), ctx); 591 592 return; 593 } 594 595 io_lock = snic_io_lock_hash(snic, sc); 596 597 spin_lock_irqsave(io_lock, flags); 598 rqi = (struct snic_req_info *) CMD_SP(sc); 599 SNIC_SCSI_DBG(snic->shost, 600 "Icmnd_cmpl:lun %lld sc %p cmd %xtag %d flags 0x%llx rqi %p\n", 601 sc->device->lun, sc, sc->cmnd[0], snic_cmd_tag(sc), 602 CMD_FLAGS(sc), rqi); 603 604 if (CMD_FLAGS(sc) & SNIC_HOST_RESET_CMD_TERM) { 605 spin_unlock_irqrestore(io_lock, flags); 606 607 return; 608 } 609 610 SNIC_BUG_ON(rqi != (struct snic_req_info *)ctx); 611 WARN_ON_ONCE(req); 612 if (!rqi) { 613 atomic64_inc(&snic->s_stats.io.req_null); 614 CMD_FLAGS(sc) |= SNIC_IO_REQ_NULL; 615 spin_unlock_irqrestore(io_lock, flags); 616 617 SNIC_HOST_ERR(snic->shost, 618 "Icmnd_cmpl:Host Req Not Found(null), Hdr Status %s, Tag 0x%x, sc 0x%p flags 0x%llx\n", 619 snic_io_status_to_str(hdr_stat), 620 cmnd_id, sc, CMD_FLAGS(sc)); 621 return; 622 } 623 624 rqi = (struct snic_req_info *) ctx; 625 start_time = rqi->start_time; 626 627 /* firmware completed the io */ 628 rqi->io_cmpl = 1; 629 630 /* 631 * if SCSI-ML has already issued abort on this command, 632 * ignore completion of the IO. The abts path will clean it up 633 */ 634 if (unlikely(snic_tmreq_pending(sc))) { 635 snic_proc_tmreq_pending_state(snic, sc, hdr_stat); 636 spin_unlock_irqrestore(io_lock, flags); 637 638 snic_stats_update_io_cmpl(&snic->s_stats); 639 640 /* Expected value is SNIC_STAT_ABORTED */ 641 if (likely(hdr_stat == SNIC_STAT_ABORTED)) 642 return; 643 644 SNIC_SCSI_DBG(snic->shost, 645 "icmnd_cmpl:TM Req Pending(%s), Hdr Status %s sc 0x%p scsi status %x resid %d flags 0x%llx\n", 646 snic_ioreq_state_to_str(CMD_STATE(sc)), 647 snic_io_status_to_str(hdr_stat), 648 sc, sc_stat, le32_to_cpu(icmnd_cmpl->resid), 649 CMD_FLAGS(sc)); 650 651 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc, 652 jiffies_to_msecs(jiffies - start_time), (ulong) fwreq, 653 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); 654 655 return; 656 } 657 658 if (snic_process_icmnd_cmpl_status(snic, icmnd_cmpl, hdr_stat, sc)) { 659 scsi_print_command(sc); 660 SNIC_HOST_ERR(snic->shost, 661 "icmnd_cmpl:IO Failed, sc 0x%p Tag %d Cmd %x Hdr Status %s flags 0x%llx\n", 662 sc, sc->cmnd[0], cmnd_id, 663 snic_io_status_to_str(hdr_stat), CMD_FLAGS(sc)); 664 } 665 666 /* Break link with the SCSI Command */ 667 CMD_SP(sc) = NULL; 668 CMD_FLAGS(sc) |= SNIC_IO_DONE; 669 670 spin_unlock_irqrestore(io_lock, flags); 671 672 /* For now, consider only successful IO. */ 673 snic_calc_io_process_time(snic, rqi); 674 675 snic_release_req_buf(snic, rqi, sc); 676 677 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc, 678 jiffies_to_msecs(jiffies - start_time), (ulong) fwreq, 679 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); 680 681 682 if (sc->scsi_done) 683 sc->scsi_done(sc); 684 685 snic_stats_update_io_cmpl(&snic->s_stats); 686 } /* end of snic_icmnd_cmpl_handler */ 687 688 static void 689 snic_proc_dr_cmpl_locked(struct snic *snic, 690 struct snic_fw_req *fwreq, 691 u8 cmpl_stat, 692 u32 cmnd_id, 693 struct scsi_cmnd *sc) 694 { 695 struct snic_req_info *rqi = (struct snic_req_info *) CMD_SP(sc); 696 u32 start_time = rqi->start_time; 697 698 CMD_LR_STATUS(sc) = cmpl_stat; 699 700 SNIC_SCSI_DBG(snic->shost, "itmf_cmpl: Cmd State = %s\n", 701 snic_ioreq_state_to_str(CMD_STATE(sc))); 702 703 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) { 704 CMD_FLAGS(sc) |= SNIC_DEV_RST_ABTS_PENDING; 705 706 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc, 707 jiffies_to_msecs(jiffies - start_time), 708 (ulong) fwreq, 0, SNIC_TRC_CMD_STATE_FLAGS(sc)); 709 710 SNIC_SCSI_DBG(snic->shost, 711 "itmf_cmpl: Terminate Pending Dev Reset Cmpl Recvd.id %x, status %s flags 0x%llx\n", 712 (int)(cmnd_id & SNIC_TAG_MASK), 713 snic_io_status_to_str(cmpl_stat), 714 CMD_FLAGS(sc)); 715 716 return; 717 } 718 719 720 if (CMD_FLAGS(sc) & SNIC_DEV_RST_TIMEDOUT) { 721 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc, 722 jiffies_to_msecs(jiffies - start_time), 723 (ulong) fwreq, 0, SNIC_TRC_CMD_STATE_FLAGS(sc)); 724 725 SNIC_SCSI_DBG(snic->shost, 726 "itmf_cmpl:Dev Reset Completion Received after timeout. id %d cmpl status %s flags 0x%llx\n", 727 (int)(cmnd_id & SNIC_TAG_MASK), 728 snic_io_status_to_str(cmpl_stat), 729 CMD_FLAGS(sc)); 730 731 return; 732 } 733 734 CMD_STATE(sc) = SNIC_IOREQ_LR_COMPLETE; 735 CMD_FLAGS(sc) |= SNIC_DEV_RST_DONE; 736 737 SNIC_SCSI_DBG(snic->shost, 738 "itmf_cmpl:Dev Reset Cmpl Recvd id %d cmpl status %s flags 0x%llx\n", 739 (int)(cmnd_id & SNIC_TAG_MASK), 740 snic_io_status_to_str(cmpl_stat), 741 CMD_FLAGS(sc)); 742 743 if (rqi->dr_done) 744 complete(rqi->dr_done); 745 } /* end of snic_proc_dr_cmpl_locked */ 746 747 /* 748 * snic_update_abort_stats : Updates abort stats based on completion status. 749 */ 750 static void 751 snic_update_abort_stats(struct snic *snic, u8 cmpl_stat) 752 { 753 struct snic_abort_stats *abt_stats = &snic->s_stats.abts; 754 755 SNIC_SCSI_DBG(snic->shost, "Updating Abort stats.\n"); 756 757 switch (cmpl_stat) { 758 case SNIC_STAT_IO_SUCCESS: 759 break; 760 761 case SNIC_STAT_TIMEOUT: 762 atomic64_inc(&abt_stats->fw_tmo); 763 break; 764 765 case SNIC_STAT_IO_NOT_FOUND: 766 atomic64_inc(&abt_stats->io_not_found); 767 break; 768 769 default: 770 atomic64_inc(&abt_stats->fail); 771 break; 772 } 773 } 774 775 static int 776 snic_process_itmf_cmpl(struct snic *snic, 777 struct snic_fw_req *fwreq, 778 u32 cmnd_id, 779 u8 cmpl_stat, 780 struct scsi_cmnd *sc) 781 { 782 struct snic_req_info *rqi = NULL; 783 u32 tm_tags = 0; 784 spinlock_t *io_lock = NULL; 785 unsigned long flags; 786 u32 start_time = 0; 787 int ret = 0; 788 789 io_lock = snic_io_lock_hash(snic, sc); 790 spin_lock_irqsave(io_lock, flags); 791 if (CMD_FLAGS(sc) & SNIC_HOST_RESET_CMD_TERM) { 792 spin_unlock_irqrestore(io_lock, flags); 793 794 return ret; 795 } 796 rqi = (struct snic_req_info *) CMD_SP(sc); 797 WARN_ON_ONCE(!rqi); 798 799 if (!rqi) { 800 atomic64_inc(&snic->s_stats.io.req_null); 801 spin_unlock_irqrestore(io_lock, flags); 802 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL; 803 SNIC_HOST_ERR(snic->shost, 804 "itmf_cmpl: rqi is null,Hdr stat = %s Tag = 0x%x sc = 0x%p flags 0x%llx\n", 805 snic_io_status_to_str(cmpl_stat), cmnd_id, sc, 806 CMD_FLAGS(sc)); 807 808 return ret; 809 } 810 811 /* Extract task management flags */ 812 tm_tags = cmnd_id & ~(SNIC_TAG_MASK); 813 814 start_time = rqi->start_time; 815 cmnd_id &= (SNIC_TAG_MASK); 816 817 switch (tm_tags) { 818 case SNIC_TAG_ABORT: 819 /* Abort only issued on cmd */ 820 snic_update_abort_stats(snic, cmpl_stat); 821 822 if (CMD_STATE(sc) != SNIC_IOREQ_ABTS_PENDING) { 823 /* This is a late completion. Ignore it. */ 824 ret = -1; 825 spin_unlock_irqrestore(io_lock, flags); 826 break; 827 } 828 829 CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE; 830 CMD_ABTS_STATUS(sc) = cmpl_stat; 831 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_DONE; 832 833 SNIC_SCSI_DBG(snic->shost, 834 "itmf_cmpl:Abort Cmpl Recvd.Tag 0x%x Status %s flags 0x%llx\n", 835 cmnd_id, 836 snic_io_status_to_str(cmpl_stat), 837 CMD_FLAGS(sc)); 838 839 /* 840 * If scsi_eh thread is blocked waiting for abts complete, 841 * signal completion to it. IO will be cleaned in the thread, 842 * else clean it in this context. 843 */ 844 if (rqi->abts_done) { 845 complete(rqi->abts_done); 846 spin_unlock_irqrestore(io_lock, flags); 847 848 break; /* jump out */ 849 } 850 851 CMD_SP(sc) = NULL; 852 sc->result = (DID_ERROR << 16); 853 SNIC_SCSI_DBG(snic->shost, 854 "itmf_cmpl: Completing IO. sc %p flags 0x%llx\n", 855 sc, CMD_FLAGS(sc)); 856 857 spin_unlock_irqrestore(io_lock, flags); 858 859 snic_release_req_buf(snic, rqi, sc); 860 861 if (sc->scsi_done) { 862 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc, 863 jiffies_to_msecs(jiffies - start_time), 864 (ulong) fwreq, SNIC_TRC_CMD(sc), 865 SNIC_TRC_CMD_STATE_FLAGS(sc)); 866 867 sc->scsi_done(sc); 868 } 869 870 break; 871 872 case SNIC_TAG_DEV_RST: 873 case SNIC_TAG_DEV_RST | SNIC_TAG_IOCTL_DEV_RST: 874 snic_proc_dr_cmpl_locked(snic, fwreq, cmpl_stat, cmnd_id, sc); 875 spin_unlock_irqrestore(io_lock, flags); 876 ret = 0; 877 878 break; 879 880 case SNIC_TAG_ABORT | SNIC_TAG_DEV_RST: 881 /* Abort and terminate completion of device reset req */ 882 883 CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE; 884 CMD_ABTS_STATUS(sc) = cmpl_stat; 885 CMD_FLAGS(sc) |= SNIC_DEV_RST_DONE; 886 887 SNIC_SCSI_DBG(snic->shost, 888 "itmf_cmpl:dev reset abts cmpl recvd. id %d status %s flags 0x%llx\n", 889 cmnd_id, snic_io_status_to_str(cmpl_stat), 890 CMD_FLAGS(sc)); 891 892 if (rqi->abts_done) 893 complete(rqi->abts_done); 894 895 spin_unlock_irqrestore(io_lock, flags); 896 897 break; 898 899 default: 900 spin_unlock_irqrestore(io_lock, flags); 901 SNIC_HOST_ERR(snic->shost, 902 "itmf_cmpl: Unknown TM tag bit 0x%x\n", tm_tags); 903 904 SNIC_HOST_ERR(snic->shost, 905 "itmf_cmpl:Unexpected itmf io stat %s Tag = 0x%x flags 0x%llx\n", 906 snic_ioreq_state_to_str(CMD_STATE(sc)), 907 cmnd_id, 908 CMD_FLAGS(sc)); 909 ret = -1; 910 SNIC_BUG_ON(1); 911 912 break; 913 } 914 915 return ret; 916 } /* end of snic_process_itmf_cmpl_status */ 917 918 /* 919 * snic_itmf_cmpl_handler. 920 * Routine to handle itmf completions. 921 */ 922 static void 923 snic_itmf_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq) 924 { 925 struct scsi_cmnd *sc = NULL; 926 struct snic_req_info *rqi = NULL; 927 struct snic_itmf_cmpl *itmf_cmpl = NULL; 928 ulong ctx; 929 u32 cmnd_id; 930 u32 hid; 931 u8 typ; 932 u8 hdr_stat; 933 934 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx); 935 SNIC_SCSI_DBG(snic->shost, 936 "Itmf_cmpl: %s: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x,ctx = %lx\n", 937 __func__, typ, hdr_stat, cmnd_id, hid, ctx); 938 939 itmf_cmpl = &fwreq->u.itmf_cmpl; 940 SNIC_SCSI_DBG(snic->shost, 941 "Itmf_cmpl: nterm %u , flags 0x%x\n", 942 le32_to_cpu(itmf_cmpl->nterminated), itmf_cmpl->flags); 943 944 /* spl case, dev reset issued through ioctl */ 945 if (cmnd_id & SNIC_TAG_IOCTL_DEV_RST) { 946 rqi = (struct snic_req_info *) ctx; 947 sc = rqi->sc; 948 949 goto ioctl_dev_rst; 950 } 951 952 if ((cmnd_id & SNIC_TAG_MASK) >= snic->max_tag_id) { 953 SNIC_HOST_ERR(snic->shost, 954 "Itmf_cmpl: Tag 0x%x out of Range,HdrStat %s\n", 955 cmnd_id, snic_io_status_to_str(hdr_stat)); 956 SNIC_BUG_ON(1); 957 958 return; 959 } 960 961 sc = scsi_host_find_tag(snic->shost, cmnd_id & SNIC_TAG_MASK); 962 WARN_ON_ONCE(!sc); 963 964 ioctl_dev_rst: 965 if (!sc) { 966 atomic64_inc(&snic->s_stats.io.sc_null); 967 SNIC_HOST_ERR(snic->shost, 968 "Itmf_cmpl: sc is NULL - Hdr Stat %s Tag 0x%x\n", 969 snic_io_status_to_str(hdr_stat), cmnd_id); 970 971 return; 972 } 973 974 snic_process_itmf_cmpl(snic, fwreq, cmnd_id, hdr_stat, sc); 975 } /* end of snic_itmf_cmpl_handler */ 976 977 978 979 static void 980 snic_hba_reset_scsi_cleanup(struct snic *snic, struct scsi_cmnd *sc) 981 { 982 struct snic_stats *st = &snic->s_stats; 983 long act_ios = 0, act_fwreqs = 0; 984 985 SNIC_SCSI_DBG(snic->shost, "HBA Reset scsi cleanup.\n"); 986 snic_scsi_cleanup(snic, snic_cmd_tag(sc)); 987 988 /* Update stats on pending IOs */ 989 act_ios = atomic64_read(&st->io.active); 990 atomic64_add(act_ios, &st->io.compl); 991 atomic64_sub(act_ios, &st->io.active); 992 993 act_fwreqs = atomic64_read(&st->fw.actv_reqs); 994 atomic64_sub(act_fwreqs, &st->fw.actv_reqs); 995 } 996 997 /* 998 * snic_hba_reset_cmpl_handler : 999 * 1000 * Notes : 1001 * 1. Cleanup all the scsi cmds, release all snic specific cmds 1002 * 2. Issue Report Targets in case of SAN targets 1003 */ 1004 static int 1005 snic_hba_reset_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq) 1006 { 1007 ulong ctx; 1008 u32 cmnd_id; 1009 u32 hid; 1010 u8 typ; 1011 u8 hdr_stat; 1012 struct scsi_cmnd *sc = NULL; 1013 struct snic_req_info *rqi = NULL; 1014 spinlock_t *io_lock = NULL; 1015 unsigned long flags, gflags; 1016 int ret = 0; 1017 1018 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx); 1019 SNIC_HOST_INFO(snic->shost, 1020 "reset_cmpl:Tag %d ctx %lx cmpl status %s HBA Reset Completion received.\n", 1021 cmnd_id, ctx, snic_io_status_to_str(hdr_stat)); 1022 1023 SNIC_SCSI_DBG(snic->shost, 1024 "reset_cmpl: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x, ctx = %lx\n", 1025 typ, hdr_stat, cmnd_id, hid, ctx); 1026 1027 /* spl case, host reset issued through ioctl */ 1028 if (cmnd_id == SCSI_NO_TAG) { 1029 rqi = (struct snic_req_info *) ctx; 1030 SNIC_HOST_INFO(snic->shost, 1031 "reset_cmpl:Tag %d ctx %lx cmpl stat %s\n", 1032 cmnd_id, ctx, snic_io_status_to_str(hdr_stat)); 1033 sc = rqi->sc; 1034 1035 goto ioctl_hba_rst; 1036 } 1037 1038 if (cmnd_id >= snic->max_tag_id) { 1039 SNIC_HOST_ERR(snic->shost, 1040 "reset_cmpl: Tag 0x%x out of Range,HdrStat %s\n", 1041 cmnd_id, snic_io_status_to_str(hdr_stat)); 1042 SNIC_BUG_ON(1); 1043 1044 return 1; 1045 } 1046 1047 sc = scsi_host_find_tag(snic->shost, cmnd_id); 1048 ioctl_hba_rst: 1049 if (!sc) { 1050 atomic64_inc(&snic->s_stats.io.sc_null); 1051 SNIC_HOST_ERR(snic->shost, 1052 "reset_cmpl: sc is NULL - Hdr Stat %s Tag 0x%x\n", 1053 snic_io_status_to_str(hdr_stat), cmnd_id); 1054 ret = 1; 1055 1056 return ret; 1057 } 1058 1059 SNIC_HOST_INFO(snic->shost, 1060 "reset_cmpl: sc %p rqi %p Tag %d flags 0x%llx\n", 1061 sc, rqi, cmnd_id, CMD_FLAGS(sc)); 1062 1063 io_lock = snic_io_lock_hash(snic, sc); 1064 spin_lock_irqsave(io_lock, flags); 1065 1066 if (!snic->remove_wait) { 1067 spin_unlock_irqrestore(io_lock, flags); 1068 SNIC_HOST_ERR(snic->shost, 1069 "reset_cmpl:host reset completed after timout\n"); 1070 ret = 1; 1071 1072 return ret; 1073 } 1074 1075 rqi = (struct snic_req_info *) CMD_SP(sc); 1076 WARN_ON_ONCE(!rqi); 1077 1078 if (!rqi) { 1079 atomic64_inc(&snic->s_stats.io.req_null); 1080 spin_unlock_irqrestore(io_lock, flags); 1081 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL; 1082 SNIC_HOST_ERR(snic->shost, 1083 "reset_cmpl: rqi is null,Hdr stat %s Tag 0x%x sc 0x%p flags 0x%llx\n", 1084 snic_io_status_to_str(hdr_stat), cmnd_id, sc, 1085 CMD_FLAGS(sc)); 1086 1087 ret = 1; 1088 1089 return ret; 1090 } 1091 /* stats */ 1092 spin_unlock_irqrestore(io_lock, flags); 1093 1094 /* scsi cleanup */ 1095 snic_hba_reset_scsi_cleanup(snic, sc); 1096 1097 SNIC_BUG_ON(snic_get_state(snic) != SNIC_OFFLINE && 1098 snic_get_state(snic) != SNIC_FWRESET); 1099 1100 /* Careful locking between snic_lock and io lock */ 1101 spin_lock_irqsave(io_lock, flags); 1102 spin_lock_irqsave(&snic->snic_lock, gflags); 1103 if (snic_get_state(snic) == SNIC_FWRESET) 1104 snic_set_state(snic, SNIC_ONLINE); 1105 spin_unlock_irqrestore(&snic->snic_lock, gflags); 1106 1107 if (snic->remove_wait) 1108 complete(snic->remove_wait); 1109 1110 spin_unlock_irqrestore(io_lock, flags); 1111 atomic64_inc(&snic->s_stats.reset.hba_reset_cmpl); 1112 1113 ret = 0; 1114 /* Rediscovery is for SAN */ 1115 if (snic->config.xpt_type == SNIC_DAS) 1116 return ret; 1117 1118 SNIC_SCSI_DBG(snic->shost, "reset_cmpl: Queuing discovery work.\n"); 1119 queue_work(snic_glob->event_q, &snic->disc_work); 1120 1121 return ret; 1122 } 1123 1124 static void 1125 snic_msg_ack_handler(struct snic *snic, struct snic_fw_req *fwreq) 1126 { 1127 SNIC_HOST_INFO(snic->shost, "Message Ack Received.\n"); 1128 1129 SNIC_ASSERT_NOT_IMPL(1); 1130 } 1131 1132 static void 1133 snic_aen_handler(struct snic *snic, struct snic_fw_req *fwreq) 1134 { 1135 u8 typ, hdr_stat; 1136 u32 cmnd_id, hid; 1137 ulong ctx; 1138 struct snic_async_evnotify *aen = &fwreq->u.async_ev; 1139 u32 event_id = 0; 1140 1141 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx); 1142 SNIC_SCSI_DBG(snic->shost, 1143 "aen: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x, ctx = %lx\n", 1144 typ, hdr_stat, cmnd_id, hid, ctx); 1145 1146 event_id = le32_to_cpu(aen->ev_id); 1147 1148 switch (event_id) { 1149 case SNIC_EV_TGT_OFFLINE: 1150 SNIC_HOST_INFO(snic->shost, "aen:TGT_OFFLINE Event Recvd.\n"); 1151 break; 1152 1153 case SNIC_EV_TGT_ONLINE: 1154 SNIC_HOST_INFO(snic->shost, "aen:TGT_ONLINE Event Recvd.\n"); 1155 break; 1156 1157 case SNIC_EV_LUN_OFFLINE: 1158 SNIC_HOST_INFO(snic->shost, "aen:LUN_OFFLINE Event Recvd.\n"); 1159 break; 1160 1161 case SNIC_EV_LUN_ONLINE: 1162 SNIC_HOST_INFO(snic->shost, "aen:LUN_ONLINE Event Recvd.\n"); 1163 break; 1164 1165 case SNIC_EV_CONF_CHG: 1166 SNIC_HOST_INFO(snic->shost, "aen:Config Change Event Recvd.\n"); 1167 break; 1168 1169 case SNIC_EV_TGT_ADDED: 1170 SNIC_HOST_INFO(snic->shost, "aen:TGT_ADD Event Recvd.\n"); 1171 break; 1172 1173 case SNIC_EV_TGT_DELTD: 1174 SNIC_HOST_INFO(snic->shost, "aen:TGT_DEL Event Recvd.\n"); 1175 break; 1176 1177 case SNIC_EV_LUN_ADDED: 1178 SNIC_HOST_INFO(snic->shost, "aen:LUN_ADD Event Recvd.\n"); 1179 break; 1180 1181 case SNIC_EV_LUN_DELTD: 1182 SNIC_HOST_INFO(snic->shost, "aen:LUN_DEL Event Recvd.\n"); 1183 break; 1184 1185 case SNIC_EV_DISC_CMPL: 1186 SNIC_HOST_INFO(snic->shost, "aen:DISC_CMPL Event Recvd.\n"); 1187 break; 1188 1189 default: 1190 SNIC_HOST_INFO(snic->shost, "aen:Unknown Event Recvd.\n"); 1191 SNIC_BUG_ON(1); 1192 break; 1193 } 1194 1195 SNIC_ASSERT_NOT_IMPL(1); 1196 } /* end of snic_aen_handler */ 1197 1198 /* 1199 * snic_io_cmpl_handler 1200 * Routine to process CQ entries(IO Completions) posted by fw. 1201 */ 1202 static int 1203 snic_io_cmpl_handler(struct vnic_dev *vdev, 1204 unsigned int cq_idx, 1205 struct snic_fw_req *fwreq) 1206 { 1207 struct snic *snic = svnic_dev_priv(vdev); 1208 u64 start = jiffies, cmpl_time; 1209 1210 snic_print_desc(__func__, (char *)fwreq, sizeof(*fwreq)); 1211 1212 /* Update FW Stats */ 1213 if ((fwreq->hdr.type >= SNIC_RSP_REPORT_TGTS_CMPL) && 1214 (fwreq->hdr.type <= SNIC_RSP_BOOT_LUNS_CMPL)) 1215 atomic64_dec(&snic->s_stats.fw.actv_reqs); 1216 1217 SNIC_BUG_ON((fwreq->hdr.type > SNIC_RSP_BOOT_LUNS_CMPL) && 1218 (fwreq->hdr.type < SNIC_MSG_ASYNC_EVNOTIFY)); 1219 1220 /* Check for snic subsys errors */ 1221 switch (fwreq->hdr.status) { 1222 case SNIC_STAT_NOT_READY: /* XPT yet to initialize */ 1223 SNIC_HOST_ERR(snic->shost, 1224 "sNIC SubSystem is NOT Ready.\n"); 1225 break; 1226 1227 case SNIC_STAT_FATAL_ERROR: /* XPT Error */ 1228 SNIC_HOST_ERR(snic->shost, 1229 "sNIC SubSystem in Unrecoverable State.\n"); 1230 break; 1231 } 1232 1233 switch (fwreq->hdr.type) { 1234 case SNIC_RSP_EXCH_VER_CMPL: 1235 snic_io_exch_ver_cmpl_handler(snic, fwreq); 1236 break; 1237 1238 case SNIC_RSP_REPORT_TGTS_CMPL: 1239 snic_report_tgt_cmpl_handler(snic, fwreq); 1240 break; 1241 1242 case SNIC_RSP_ICMND_CMPL: 1243 snic_icmnd_cmpl_handler(snic, fwreq); 1244 break; 1245 1246 case SNIC_RSP_ITMF_CMPL: 1247 snic_itmf_cmpl_handler(snic, fwreq); 1248 break; 1249 1250 case SNIC_RSP_HBA_RESET_CMPL: 1251 snic_hba_reset_cmpl_handler(snic, fwreq); 1252 break; 1253 1254 case SNIC_MSG_ACK: 1255 snic_msg_ack_handler(snic, fwreq); 1256 break; 1257 1258 case SNIC_MSG_ASYNC_EVNOTIFY: 1259 snic_aen_handler(snic, fwreq); 1260 break; 1261 1262 default: 1263 SNIC_BUG_ON(1); 1264 SNIC_SCSI_DBG(snic->shost, 1265 "Unknown Firmwqre completion request type %d\n", 1266 fwreq->hdr.type); 1267 break; 1268 } 1269 1270 /* Update Stats */ 1271 cmpl_time = jiffies - start; 1272 if (cmpl_time > atomic64_read(&snic->s_stats.io.max_cmpl_time)) 1273 atomic64_set(&snic->s_stats.io.max_cmpl_time, cmpl_time); 1274 1275 return 0; 1276 } /* end of snic_io_cmpl_handler */ 1277 1278 /* 1279 * snic_fwcq_cmpl_handler 1280 * Routine to process fwCQ 1281 * This CQ is independent, and not associated with wq/rq/wq_copy queues 1282 */ 1283 int 1284 snic_fwcq_cmpl_handler(struct snic *snic, int io_cmpl_work) 1285 { 1286 unsigned int num_ent = 0; /* number cq entries processed */ 1287 unsigned int cq_idx; 1288 unsigned int nent_per_cq; 1289 struct snic_misc_stats *misc_stats = &snic->s_stats.misc; 1290 1291 for (cq_idx = snic->wq_count; cq_idx < snic->cq_count; cq_idx++) { 1292 nent_per_cq = vnic_cq_fw_service(&snic->cq[cq_idx], 1293 snic_io_cmpl_handler, 1294 io_cmpl_work); 1295 num_ent += nent_per_cq; 1296 1297 if (nent_per_cq > atomic64_read(&misc_stats->max_cq_ents)) 1298 atomic64_set(&misc_stats->max_cq_ents, nent_per_cq); 1299 } 1300 1301 return num_ent; 1302 } /* end of snic_fwcq_cmpl_handler */ 1303 1304 /* 1305 * snic_queue_itmf_req: Common API to queue Task Management requests. 1306 * Use rqi->tm_tag for passing special tags. 1307 * @req_id : aborted request's tag, -1 for lun reset. 1308 */ 1309 static int 1310 snic_queue_itmf_req(struct snic *snic, 1311 struct snic_host_req *tmreq, 1312 struct scsi_cmnd *sc, 1313 u32 tmf, 1314 u32 req_id) 1315 { 1316 struct snic_req_info *rqi = req_to_rqi(tmreq); 1317 struct scsi_lun lun; 1318 int tm_tag = snic_cmd_tag(sc) | rqi->tm_tag; 1319 int ret = 0; 1320 1321 SNIC_BUG_ON(!rqi); 1322 SNIC_BUG_ON(!rqi->tm_tag); 1323 1324 /* fill in lun info */ 1325 int_to_scsilun(sc->device->lun, &lun); 1326 1327 /* Initialize snic_host_req: itmf */ 1328 snic_itmf_init(tmreq, 1329 tm_tag, 1330 snic->config.hid, 1331 (ulong) rqi, 1332 0 /* flags */, 1333 req_id, /* Command to be aborted. */ 1334 rqi->tgt_id, 1335 lun.scsi_lun, 1336 tmf); 1337 1338 /* 1339 * In case of multiple aborts on same cmd, 1340 * use try_wait_for_completion and completion_done() to check 1341 * whether it queues aborts even after completion of abort issued 1342 * prior.SNIC_BUG_ON(completion_done(&rqi->done)); 1343 */ 1344 1345 ret = snic_queue_wq_desc(snic, tmreq, sizeof(*tmreq)); 1346 if (ret) 1347 SNIC_HOST_ERR(snic->shost, 1348 "qitmf:Queuing ITMF(%d) Req sc %p, rqi %p, req_id %d tag %d Failed, ret = %d\n", 1349 tmf, sc, rqi, req_id, snic_cmd_tag(sc), ret); 1350 else 1351 SNIC_SCSI_DBG(snic->shost, 1352 "qitmf:Queuing ITMF(%d) Req sc %p, rqi %p, req_id %d, tag %d (req_id)- Success.", 1353 tmf, sc, rqi, req_id, snic_cmd_tag(sc)); 1354 1355 return ret; 1356 } /* end of snic_queue_itmf_req */ 1357 1358 static int 1359 snic_issue_tm_req(struct snic *snic, 1360 struct snic_req_info *rqi, 1361 struct scsi_cmnd *sc, 1362 int tmf) 1363 { 1364 struct snic_host_req *tmreq = NULL; 1365 int req_id = 0, tag = snic_cmd_tag(sc); 1366 int ret = 0; 1367 1368 if (snic_get_state(snic) == SNIC_FWRESET) 1369 return -EBUSY; 1370 1371 atomic_inc(&snic->ios_inflight); 1372 1373 SNIC_SCSI_DBG(snic->shost, 1374 "issu_tmreq: Task mgmt req %d. rqi %p w/ tag %x\n", 1375 tmf, rqi, tag); 1376 1377 1378 if (tmf == SNIC_ITMF_LUN_RESET) { 1379 tmreq = snic_dr_req_init(snic, rqi); 1380 req_id = SCSI_NO_TAG; 1381 } else { 1382 tmreq = snic_abort_req_init(snic, rqi); 1383 req_id = tag; 1384 } 1385 1386 if (!tmreq) { 1387 ret = -ENOMEM; 1388 1389 goto tmreq_err; 1390 } 1391 1392 ret = snic_queue_itmf_req(snic, tmreq, sc, tmf, req_id); 1393 if (ret) 1394 goto tmreq_err; 1395 1396 ret = 0; 1397 1398 tmreq_err: 1399 if (ret) { 1400 SNIC_HOST_ERR(snic->shost, 1401 "issu_tmreq: Queing ITMF(%d) Req, sc %p rqi %p req_id %d tag %x fails err = %d\n", 1402 tmf, sc, rqi, req_id, tag, ret); 1403 } else { 1404 SNIC_SCSI_DBG(snic->shost, 1405 "issu_tmreq: Queuing ITMF(%d) Req, sc %p, rqi %p, req_id %d tag %x - Success.\n", 1406 tmf, sc, rqi, req_id, tag); 1407 } 1408 1409 atomic_dec(&snic->ios_inflight); 1410 1411 return ret; 1412 } 1413 1414 /* 1415 * snic_queue_abort_req : Queues abort req to WQ 1416 */ 1417 static int 1418 snic_queue_abort_req(struct snic *snic, 1419 struct snic_req_info *rqi, 1420 struct scsi_cmnd *sc, 1421 int tmf) 1422 { 1423 SNIC_SCSI_DBG(snic->shost, "q_abtreq: sc %p, rqi %p, tag %x, tmf %d\n", 1424 sc, rqi, snic_cmd_tag(sc), tmf); 1425 1426 /* Add special tag for abort */ 1427 rqi->tm_tag |= SNIC_TAG_ABORT; 1428 1429 return snic_issue_tm_req(snic, rqi, sc, tmf); 1430 } 1431 1432 /* 1433 * snic_abort_finish : called by snic_abort_cmd on queuing abort successfully. 1434 */ 1435 static int 1436 snic_abort_finish(struct snic *snic, struct scsi_cmnd *sc) 1437 { 1438 struct snic_req_info *rqi = NULL; 1439 spinlock_t *io_lock = NULL; 1440 unsigned long flags; 1441 int ret = 0, tag = snic_cmd_tag(sc); 1442 1443 io_lock = snic_io_lock_hash(snic, sc); 1444 spin_lock_irqsave(io_lock, flags); 1445 rqi = (struct snic_req_info *) CMD_SP(sc); 1446 if (!rqi) { 1447 atomic64_inc(&snic->s_stats.io.req_null); 1448 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL; 1449 1450 SNIC_SCSI_DBG(snic->shost, 1451 "abt_fini:req info is null tag 0x%x, sc 0x%p flags 0x%llx\n", 1452 tag, sc, CMD_FLAGS(sc)); 1453 ret = FAILED; 1454 1455 goto abort_fail; 1456 } 1457 1458 rqi->abts_done = NULL; 1459 1460 ret = FAILED; 1461 1462 /* Check the abort status. */ 1463 switch (CMD_ABTS_STATUS(sc)) { 1464 case SNIC_INVALID_CODE: 1465 /* Firmware didn't complete abort req, timedout */ 1466 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TIMEDOUT; 1467 atomic64_inc(&snic->s_stats.abts.drv_tmo); 1468 SNIC_SCSI_DBG(snic->shost, 1469 "abt_fini:sc %p Tag %x Driver Timeout.flags 0x%llx\n", 1470 sc, snic_cmd_tag(sc), CMD_FLAGS(sc)); 1471 /* do not release snic request in timedout case */ 1472 rqi = NULL; 1473 1474 goto abort_fail; 1475 1476 case SNIC_STAT_IO_SUCCESS: 1477 case SNIC_STAT_IO_NOT_FOUND: 1478 ret = SUCCESS; 1479 /* 1480 * If abort path doesn't call scsi_done(), 1481 * the # IO timeouts == 2, will cause the LUN offline. 1482 * Call scsi_done to complete the IO. 1483 */ 1484 sc->result = (DID_ERROR << 16); 1485 sc->scsi_done(sc); 1486 break; 1487 1488 default: 1489 /* Firmware completed abort with error */ 1490 ret = FAILED; 1491 rqi = NULL; 1492 break; 1493 } 1494 1495 CMD_SP(sc) = NULL; 1496 SNIC_HOST_INFO(snic->shost, 1497 "abt_fini: Tag %x, Cmpl Status %s flags 0x%llx\n", 1498 tag, snic_io_status_to_str(CMD_ABTS_STATUS(sc)), 1499 CMD_FLAGS(sc)); 1500 1501 abort_fail: 1502 spin_unlock_irqrestore(io_lock, flags); 1503 if (rqi) 1504 snic_release_req_buf(snic, rqi, sc); 1505 1506 return ret; 1507 } /* end of snic_abort_finish */ 1508 1509 /* 1510 * snic_send_abort_and_wait : Issues Abort, and Waits 1511 */ 1512 static int 1513 snic_send_abort_and_wait(struct snic *snic, struct scsi_cmnd *sc) 1514 { 1515 struct snic_req_info *rqi = NULL; 1516 enum snic_ioreq_state sv_state; 1517 struct snic_tgt *tgt = NULL; 1518 spinlock_t *io_lock = NULL; 1519 DECLARE_COMPLETION_ONSTACK(tm_done); 1520 unsigned long flags; 1521 int ret = 0, tmf = 0, tag = snic_cmd_tag(sc); 1522 1523 tgt = starget_to_tgt(scsi_target(sc->device)); 1524 if ((snic_tgt_chkready(tgt) != 0) && (tgt->tdata.typ == SNIC_TGT_SAN)) 1525 tmf = SNIC_ITMF_ABTS_TASK_TERM; 1526 else 1527 tmf = SNIC_ITMF_ABTS_TASK; 1528 1529 /* stats */ 1530 1531 io_lock = snic_io_lock_hash(snic, sc); 1532 1533 /* 1534 * Avoid a race between SCSI issuing the abort and the device 1535 * completing the command. 1536 * 1537 * If the command is already completed by fw_cmpl code, 1538 * we just return SUCCESS from here. This means that the abort 1539 * succeeded. In the SCSI ML, since the timeout for command has 1540 * happend, the completion wont actually complete the command 1541 * and it will be considered as an aborted command 1542 * 1543 * The CMD_SP will not be cleared except while holding io_lock 1544 */ 1545 spin_lock_irqsave(io_lock, flags); 1546 rqi = (struct snic_req_info *) CMD_SP(sc); 1547 if (!rqi) { 1548 spin_unlock_irqrestore(io_lock, flags); 1549 1550 SNIC_HOST_ERR(snic->shost, 1551 "abt_cmd: rqi is null. Tag %d flags 0x%llx\n", 1552 tag, CMD_FLAGS(sc)); 1553 1554 ret = SUCCESS; 1555 1556 goto send_abts_end; 1557 } 1558 1559 rqi->abts_done = &tm_done; 1560 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) { 1561 spin_unlock_irqrestore(io_lock, flags); 1562 1563 ret = 0; 1564 goto abts_pending; 1565 } 1566 SNIC_BUG_ON(!rqi->abts_done); 1567 1568 /* Save Command State, should be restored on failed to Queue. */ 1569 sv_state = CMD_STATE(sc); 1570 1571 /* 1572 * Command is still pending, need to abort it 1573 * If the fw completes the command after this point, 1574 * the completion won't be done till mid-layer, since abot 1575 * has already started. 1576 */ 1577 CMD_STATE(sc) = SNIC_IOREQ_ABTS_PENDING; 1578 CMD_ABTS_STATUS(sc) = SNIC_INVALID_CODE; 1579 1580 SNIC_SCSI_DBG(snic->shost, "send_abt_cmd: TAG 0x%x\n", tag); 1581 1582 spin_unlock_irqrestore(io_lock, flags); 1583 1584 /* Now Queue the abort command to firmware */ 1585 ret = snic_queue_abort_req(snic, rqi, sc, tmf); 1586 if (ret) { 1587 atomic64_inc(&snic->s_stats.abts.q_fail); 1588 SNIC_HOST_ERR(snic->shost, 1589 "send_abt_cmd: IO w/ Tag 0x%x fail w/ err %d flags 0x%llx\n", 1590 tag, ret, CMD_FLAGS(sc)); 1591 1592 spin_lock_irqsave(io_lock, flags); 1593 /* Restore Command's previous state */ 1594 CMD_STATE(sc) = sv_state; 1595 rqi = (struct snic_req_info *) CMD_SP(sc); 1596 if (rqi) 1597 rqi->abts_done = NULL; 1598 spin_unlock_irqrestore(io_lock, flags); 1599 ret = FAILED; 1600 1601 goto send_abts_end; 1602 } 1603 1604 spin_lock_irqsave(io_lock, flags); 1605 if (tmf == SNIC_ITMF_ABTS_TASK) { 1606 CMD_FLAGS(sc) |= SNIC_IO_ABTS_ISSUED; 1607 atomic64_inc(&snic->s_stats.abts.num); 1608 } else { 1609 /* term stats */ 1610 CMD_FLAGS(sc) |= SNIC_IO_TERM_ISSUED; 1611 } 1612 spin_unlock_irqrestore(io_lock, flags); 1613 1614 SNIC_SCSI_DBG(snic->shost, 1615 "send_abt_cmd: sc %p Tag %x flags 0x%llx\n", 1616 sc, tag, CMD_FLAGS(sc)); 1617 1618 1619 ret = 0; 1620 1621 abts_pending: 1622 /* 1623 * Queued an abort IO, wait for its completion. 1624 * Once the fw completes the abort command, it will 1625 * wakeup this thread. 1626 */ 1627 wait_for_completion_timeout(&tm_done, SNIC_ABTS_TIMEOUT); 1628 1629 send_abts_end: 1630 return ret; 1631 } /* end of snic_send_abort_and_wait */ 1632 1633 /* 1634 * This function is exported to SCSI for sending abort cmnds. 1635 * A SCSI IO is represent by snic_ioreq in the driver. 1636 * The snic_ioreq is linked to the SCSI Cmd, thus a link with the ULP'S IO 1637 */ 1638 int 1639 snic_abort_cmd(struct scsi_cmnd *sc) 1640 { 1641 struct snic *snic = shost_priv(sc->device->host); 1642 int ret = SUCCESS, tag = snic_cmd_tag(sc); 1643 u32 start_time = jiffies; 1644 1645 SNIC_SCSI_DBG(snic->shost, "abt_cmd:sc %p :0x%x :req = %p :tag = %d\n", 1646 sc, sc->cmnd[0], sc->request, tag); 1647 1648 if (unlikely(snic_get_state(snic) != SNIC_ONLINE)) { 1649 SNIC_HOST_ERR(snic->shost, 1650 "abt_cmd: tag %x Parent Devs are not rdy\n", 1651 tag); 1652 ret = FAST_IO_FAIL; 1653 1654 goto abort_end; 1655 } 1656 1657 1658 ret = snic_send_abort_and_wait(snic, sc); 1659 if (ret) 1660 goto abort_end; 1661 1662 ret = snic_abort_finish(snic, sc); 1663 1664 abort_end: 1665 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc, 1666 jiffies_to_msecs(jiffies - start_time), 0, 1667 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); 1668 1669 SNIC_SCSI_DBG(snic->shost, 1670 "abts: Abort Req Status = %s\n", 1671 (ret == SUCCESS) ? "SUCCESS" : 1672 ((ret == FAST_IO_FAIL) ? "FAST_IO_FAIL" : "FAILED")); 1673 1674 return ret; 1675 } 1676 1677 1678 1679 static int 1680 snic_is_abts_pending(struct snic *snic, struct scsi_cmnd *lr_sc) 1681 { 1682 struct snic_req_info *rqi = NULL; 1683 struct scsi_cmnd *sc = NULL; 1684 struct scsi_device *lr_sdev = NULL; 1685 spinlock_t *io_lock = NULL; 1686 u32 tag; 1687 unsigned long flags; 1688 1689 if (lr_sc) 1690 lr_sdev = lr_sc->device; 1691 1692 /* walk through the tag map, an dcheck if IOs are still pending in fw*/ 1693 for (tag = 0; tag < snic->max_tag_id; tag++) { 1694 io_lock = snic_io_lock_tag(snic, tag); 1695 1696 spin_lock_irqsave(io_lock, flags); 1697 sc = scsi_host_find_tag(snic->shost, tag); 1698 1699 if (!sc || (lr_sc && (sc->device != lr_sdev || sc == lr_sc))) { 1700 spin_unlock_irqrestore(io_lock, flags); 1701 1702 continue; 1703 } 1704 1705 rqi = (struct snic_req_info *) CMD_SP(sc); 1706 if (!rqi) { 1707 spin_unlock_irqrestore(io_lock, flags); 1708 1709 continue; 1710 } 1711 1712 /* 1713 * Found IO that is still pending w/ firmware and belongs to 1714 * the LUN that is under reset, if lr_sc != NULL 1715 */ 1716 SNIC_SCSI_DBG(snic->shost, "Found IO in %s on LUN\n", 1717 snic_ioreq_state_to_str(CMD_STATE(sc))); 1718 1719 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) { 1720 spin_unlock_irqrestore(io_lock, flags); 1721 1722 return 1; 1723 } 1724 1725 spin_unlock_irqrestore(io_lock, flags); 1726 } 1727 1728 return 0; 1729 } /* end of snic_is_abts_pending */ 1730 1731 static int 1732 snic_dr_clean_single_req(struct snic *snic, 1733 u32 tag, 1734 struct scsi_device *lr_sdev) 1735 { 1736 struct snic_req_info *rqi = NULL; 1737 struct snic_tgt *tgt = NULL; 1738 struct scsi_cmnd *sc = NULL; 1739 spinlock_t *io_lock = NULL; 1740 u32 sv_state = 0, tmf = 0; 1741 DECLARE_COMPLETION_ONSTACK(tm_done); 1742 unsigned long flags; 1743 int ret = 0; 1744 1745 io_lock = snic_io_lock_tag(snic, tag); 1746 spin_lock_irqsave(io_lock, flags); 1747 sc = scsi_host_find_tag(snic->shost, tag); 1748 1749 /* Ignore Cmd that don't belong to Lun Reset device */ 1750 if (!sc || sc->device != lr_sdev) 1751 goto skip_clean; 1752 1753 rqi = (struct snic_req_info *) CMD_SP(sc); 1754 1755 if (!rqi) 1756 goto skip_clean; 1757 1758 1759 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) 1760 goto skip_clean; 1761 1762 1763 if ((CMD_FLAGS(sc) & SNIC_DEVICE_RESET) && 1764 (!(CMD_FLAGS(sc) & SNIC_DEV_RST_ISSUED))) { 1765 1766 SNIC_SCSI_DBG(snic->shost, 1767 "clean_single_req: devrst is not pending sc 0x%p\n", 1768 sc); 1769 1770 goto skip_clean; 1771 } 1772 1773 SNIC_SCSI_DBG(snic->shost, 1774 "clean_single_req: Found IO in %s on lun\n", 1775 snic_ioreq_state_to_str(CMD_STATE(sc))); 1776 1777 /* Save Command State */ 1778 sv_state = CMD_STATE(sc); 1779 1780 /* 1781 * Any pending IO issued prior to reset is expected to be 1782 * in abts pending state, if not we need to set SNIC_IOREQ_ABTS_PENDING 1783 * to indicate the IO is abort pending. 1784 * When IO is completed, the IO will be handed over and handled 1785 * in this function. 1786 */ 1787 1788 CMD_STATE(sc) = SNIC_IOREQ_ABTS_PENDING; 1789 SNIC_BUG_ON(rqi->abts_done); 1790 1791 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) { 1792 rqi->tm_tag = SNIC_TAG_DEV_RST; 1793 1794 SNIC_SCSI_DBG(snic->shost, 1795 "clean_single_req:devrst sc 0x%p\n", sc); 1796 } 1797 1798 CMD_ABTS_STATUS(sc) = SNIC_INVALID_CODE; 1799 rqi->abts_done = &tm_done; 1800 spin_unlock_irqrestore(io_lock, flags); 1801 1802 tgt = starget_to_tgt(scsi_target(sc->device)); 1803 if ((snic_tgt_chkready(tgt) != 0) && (tgt->tdata.typ == SNIC_TGT_SAN)) 1804 tmf = SNIC_ITMF_ABTS_TASK_TERM; 1805 else 1806 tmf = SNIC_ITMF_ABTS_TASK; 1807 1808 /* Now queue the abort command to firmware */ 1809 ret = snic_queue_abort_req(snic, rqi, sc, tmf); 1810 if (ret) { 1811 SNIC_HOST_ERR(snic->shost, 1812 "clean_single_req_err:sc %p, tag %d abt failed. tm_tag %d flags 0x%llx\n", 1813 sc, tag, rqi->tm_tag, CMD_FLAGS(sc)); 1814 1815 spin_lock_irqsave(io_lock, flags); 1816 rqi = (struct snic_req_info *) CMD_SP(sc); 1817 if (rqi) 1818 rqi->abts_done = NULL; 1819 1820 /* Restore Command State */ 1821 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) 1822 CMD_STATE(sc) = sv_state; 1823 1824 ret = 1; 1825 goto skip_clean; 1826 } 1827 1828 spin_lock_irqsave(io_lock, flags); 1829 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) 1830 CMD_FLAGS(sc) |= SNIC_DEV_RST_TERM_ISSUED; 1831 1832 CMD_FLAGS(sc) |= SNIC_IO_INTERNAL_TERM_ISSUED; 1833 spin_unlock_irqrestore(io_lock, flags); 1834 1835 wait_for_completion_timeout(&tm_done, SNIC_ABTS_TIMEOUT); 1836 1837 /* Recheck cmd state to check if it now aborted. */ 1838 spin_lock_irqsave(io_lock, flags); 1839 rqi = (struct snic_req_info *) CMD_SP(sc); 1840 if (!rqi) { 1841 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL; 1842 goto skip_clean; 1843 } 1844 rqi->abts_done = NULL; 1845 1846 /* if abort is still pending w/ fw, fail */ 1847 if (CMD_ABTS_STATUS(sc) == SNIC_INVALID_CODE) { 1848 SNIC_HOST_ERR(snic->shost, 1849 "clean_single_req_err:sc %p tag %d abt still pending w/ fw, tm_tag %d flags 0x%llx\n", 1850 sc, tag, rqi->tm_tag, CMD_FLAGS(sc)); 1851 1852 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_DONE; 1853 ret = 1; 1854 1855 goto skip_clean; 1856 } 1857 1858 CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE; 1859 CMD_SP(sc) = NULL; 1860 spin_unlock_irqrestore(io_lock, flags); 1861 1862 snic_release_req_buf(snic, rqi, sc); 1863 1864 sc->result = (DID_ERROR << 16); 1865 sc->scsi_done(sc); 1866 1867 ret = 0; 1868 1869 return ret; 1870 1871 skip_clean: 1872 spin_unlock_irqrestore(io_lock, flags); 1873 1874 return ret; 1875 } /* end of snic_dr_clean_single_req */ 1876 1877 static int 1878 snic_dr_clean_pending_req(struct snic *snic, struct scsi_cmnd *lr_sc) 1879 { 1880 struct scsi_device *lr_sdev = lr_sc->device; 1881 u32 tag = 0; 1882 int ret = FAILED; 1883 1884 for (tag = 0; tag < snic->max_tag_id; tag++) { 1885 if (tag == snic_cmd_tag(lr_sc)) 1886 continue; 1887 1888 ret = snic_dr_clean_single_req(snic, tag, lr_sdev); 1889 if (ret) { 1890 SNIC_HOST_ERR(snic->shost, "clean_err:tag = %d\n", tag); 1891 1892 goto clean_err; 1893 } 1894 } 1895 1896 schedule_timeout(msecs_to_jiffies(100)); 1897 1898 /* Walk through all the cmds and check abts status. */ 1899 if (snic_is_abts_pending(snic, lr_sc)) { 1900 ret = FAILED; 1901 1902 goto clean_err; 1903 } 1904 1905 ret = 0; 1906 SNIC_SCSI_DBG(snic->shost, "clean_pending_req: Success.\n"); 1907 1908 return ret; 1909 1910 clean_err: 1911 ret = FAILED; 1912 SNIC_HOST_ERR(snic->shost, 1913 "Failed to Clean Pending IOs on %s device.\n", 1914 dev_name(&lr_sdev->sdev_gendev)); 1915 1916 return ret; 1917 1918 } /* end of snic_dr_clean_pending_req */ 1919 1920 /* 1921 * snic_dr_finish : Called by snic_device_reset 1922 */ 1923 static int 1924 snic_dr_finish(struct snic *snic, struct scsi_cmnd *sc) 1925 { 1926 struct snic_req_info *rqi = NULL; 1927 spinlock_t *io_lock = NULL; 1928 unsigned long flags; 1929 int lr_res = 0; 1930 int ret = FAILED; 1931 1932 io_lock = snic_io_lock_hash(snic, sc); 1933 spin_lock_irqsave(io_lock, flags); 1934 rqi = (struct snic_req_info *) CMD_SP(sc); 1935 if (!rqi) { 1936 spin_unlock_irqrestore(io_lock, flags); 1937 SNIC_SCSI_DBG(snic->shost, 1938 "dr_fini: rqi is null tag 0x%x sc 0x%p flags 0x%llx\n", 1939 snic_cmd_tag(sc), sc, CMD_FLAGS(sc)); 1940 1941 ret = FAILED; 1942 goto dr_fini_end; 1943 } 1944 1945 rqi->dr_done = NULL; 1946 1947 lr_res = CMD_LR_STATUS(sc); 1948 1949 switch (lr_res) { 1950 case SNIC_INVALID_CODE: 1951 /* stats */ 1952 SNIC_SCSI_DBG(snic->shost, 1953 "dr_fini: Tag %x Dev Reset Timedout. flags 0x%llx\n", 1954 snic_cmd_tag(sc), CMD_FLAGS(sc)); 1955 1956 CMD_FLAGS(sc) |= SNIC_DEV_RST_TIMEDOUT; 1957 ret = FAILED; 1958 1959 goto dr_failed; 1960 1961 case SNIC_STAT_IO_SUCCESS: 1962 SNIC_SCSI_DBG(snic->shost, 1963 "dr_fini: Tag %x Dev Reset cmpl\n", 1964 snic_cmd_tag(sc)); 1965 ret = 0; 1966 break; 1967 1968 default: 1969 SNIC_HOST_ERR(snic->shost, 1970 "dr_fini:Device Reset completed& failed.Tag = %x lr_status %s flags 0x%llx\n", 1971 snic_cmd_tag(sc), 1972 snic_io_status_to_str(lr_res), CMD_FLAGS(sc)); 1973 ret = FAILED; 1974 goto dr_failed; 1975 } 1976 spin_unlock_irqrestore(io_lock, flags); 1977 1978 /* 1979 * Cleanup any IOs on this LUN that have still not completed. 1980 * If any of these fail, then LUN Reset fails. 1981 * Cleanup cleans all commands on this LUN except 1982 * the lun reset command. If all cmds get cleaned, the LUN Reset 1983 * succeeds. 1984 */ 1985 1986 ret = snic_dr_clean_pending_req(snic, sc); 1987 if (ret) { 1988 spin_lock_irqsave(io_lock, flags); 1989 SNIC_SCSI_DBG(snic->shost, 1990 "dr_fini: Device Reset Failed since could not abort all IOs. Tag = %x.\n", 1991 snic_cmd_tag(sc)); 1992 rqi = (struct snic_req_info *) CMD_SP(sc); 1993 1994 goto dr_failed; 1995 } else { 1996 /* Cleanup LUN Reset Command */ 1997 spin_lock_irqsave(io_lock, flags); 1998 rqi = (struct snic_req_info *) CMD_SP(sc); 1999 if (rqi) 2000 ret = SUCCESS; /* Completed Successfully */ 2001 else 2002 ret = FAILED; 2003 } 2004 2005 dr_failed: 2006 SNIC_BUG_ON(!spin_is_locked(io_lock)); 2007 if (rqi) 2008 CMD_SP(sc) = NULL; 2009 spin_unlock_irqrestore(io_lock, flags); 2010 2011 if (rqi) 2012 snic_release_req_buf(snic, rqi, sc); 2013 2014 dr_fini_end: 2015 return ret; 2016 } /* end of snic_dr_finish */ 2017 2018 static int 2019 snic_queue_dr_req(struct snic *snic, 2020 struct snic_req_info *rqi, 2021 struct scsi_cmnd *sc) 2022 { 2023 /* Add special tag for device reset */ 2024 rqi->tm_tag |= SNIC_TAG_DEV_RST; 2025 2026 return snic_issue_tm_req(snic, rqi, sc, SNIC_ITMF_LUN_RESET); 2027 } 2028 2029 static int 2030 snic_send_dr_and_wait(struct snic *snic, struct scsi_cmnd *sc) 2031 { 2032 struct snic_req_info *rqi = NULL; 2033 enum snic_ioreq_state sv_state; 2034 spinlock_t *io_lock = NULL; 2035 unsigned long flags; 2036 DECLARE_COMPLETION_ONSTACK(tm_done); 2037 int ret = FAILED, tag = snic_cmd_tag(sc); 2038 2039 io_lock = snic_io_lock_hash(snic, sc); 2040 spin_lock_irqsave(io_lock, flags); 2041 CMD_FLAGS(sc) |= SNIC_DEVICE_RESET; 2042 rqi = (struct snic_req_info *) CMD_SP(sc); 2043 if (!rqi) { 2044 SNIC_HOST_ERR(snic->shost, 2045 "send_dr: rqi is null, Tag 0x%x flags 0x%llx\n", 2046 tag, CMD_FLAGS(sc)); 2047 spin_unlock_irqrestore(io_lock, flags); 2048 2049 ret = FAILED; 2050 goto send_dr_end; 2051 } 2052 2053 /* Save Command state to restore in case Queuing failed. */ 2054 sv_state = CMD_STATE(sc); 2055 2056 CMD_STATE(sc) = SNIC_IOREQ_LR_PENDING; 2057 CMD_LR_STATUS(sc) = SNIC_INVALID_CODE; 2058 2059 SNIC_SCSI_DBG(snic->shost, "dr: TAG = %x\n", tag); 2060 2061 rqi->dr_done = &tm_done; 2062 SNIC_BUG_ON(!rqi->dr_done); 2063 2064 spin_unlock_irqrestore(io_lock, flags); 2065 /* 2066 * The Command state is changed to IOREQ_PENDING, 2067 * in this case, if the command is completed, the icmnd_cmpl will 2068 * mark the cmd as completed. 2069 * This logic still makes LUN Reset is inevitable. 2070 */ 2071 2072 ret = snic_queue_dr_req(snic, rqi, sc); 2073 if (ret) { 2074 SNIC_HOST_ERR(snic->shost, 2075 "send_dr: IO w/ Tag 0x%x Failed err = %d. flags 0x%llx\n", 2076 tag, ret, CMD_FLAGS(sc)); 2077 2078 spin_lock_irqsave(io_lock, flags); 2079 /* Restore State */ 2080 CMD_STATE(sc) = sv_state; 2081 rqi = (struct snic_req_info *) CMD_SP(sc); 2082 if (rqi) 2083 rqi->dr_done = NULL; 2084 /* rqi is freed in caller. */ 2085 spin_unlock_irqrestore(io_lock, flags); 2086 ret = FAILED; 2087 2088 goto send_dr_end; 2089 } 2090 2091 spin_lock_irqsave(io_lock, flags); 2092 CMD_FLAGS(sc) |= SNIC_DEV_RST_ISSUED; 2093 spin_unlock_irqrestore(io_lock, flags); 2094 2095 ret = 0; 2096 2097 wait_for_completion_timeout(&tm_done, SNIC_LUN_RESET_TIMEOUT); 2098 2099 send_dr_end: 2100 return ret; 2101 } 2102 2103 /* 2104 * auxillary funciton to check lun reset op is supported or not 2105 * Not supported if returns 0 2106 */ 2107 static int 2108 snic_dev_reset_supported(struct scsi_device *sdev) 2109 { 2110 struct snic_tgt *tgt = starget_to_tgt(scsi_target(sdev)); 2111 2112 if (tgt->tdata.typ == SNIC_TGT_DAS) 2113 return 0; 2114 2115 return 1; 2116 } 2117 2118 static void 2119 snic_unlink_and_release_req(struct snic *snic, struct scsi_cmnd *sc, int flag) 2120 { 2121 struct snic_req_info *rqi = NULL; 2122 spinlock_t *io_lock = NULL; 2123 unsigned long flags; 2124 u32 start_time = jiffies; 2125 2126 io_lock = snic_io_lock_hash(snic, sc); 2127 spin_lock_irqsave(io_lock, flags); 2128 rqi = (struct snic_req_info *) CMD_SP(sc); 2129 if (rqi) { 2130 start_time = rqi->start_time; 2131 CMD_SP(sc) = NULL; 2132 } 2133 2134 CMD_FLAGS(sc) |= flag; 2135 spin_unlock_irqrestore(io_lock, flags); 2136 2137 if (rqi) 2138 snic_release_req_buf(snic, rqi, sc); 2139 2140 SNIC_TRC(snic->shost->host_no, snic_cmd_tag(sc), (ulong) sc, 2141 jiffies_to_msecs(jiffies - start_time), (ulong) rqi, 2142 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); 2143 } 2144 2145 /* 2146 * SCSI Eh thread issues a LUN Reset when one or more commands on a LUN 2147 * fail to get aborted. It calls driver's eh_device_reset with a SCSI 2148 * command on the LUN. 2149 */ 2150 int 2151 snic_device_reset(struct scsi_cmnd *sc) 2152 { 2153 struct Scsi_Host *shost = sc->device->host; 2154 struct snic *snic = shost_priv(shost); 2155 struct snic_req_info *rqi = NULL; 2156 int tag = snic_cmd_tag(sc); 2157 int start_time = jiffies; 2158 int ret = FAILED; 2159 int dr_supp = 0; 2160 2161 SNIC_SCSI_DBG(shost, "dev_reset:sc %p :0x%x :req = %p :tag = %d\n", 2162 sc, sc->cmnd[0], sc->request, 2163 snic_cmd_tag(sc)); 2164 dr_supp = snic_dev_reset_supported(sc->device); 2165 if (!dr_supp) { 2166 /* device reset op is not supported */ 2167 SNIC_HOST_INFO(shost, "LUN Reset Op not supported.\n"); 2168 snic_unlink_and_release_req(snic, sc, SNIC_DEV_RST_NOTSUP); 2169 2170 goto dev_rst_end; 2171 } 2172 2173 if (unlikely(snic_get_state(snic) != SNIC_ONLINE)) { 2174 snic_unlink_and_release_req(snic, sc, 0); 2175 SNIC_HOST_ERR(shost, "Devrst: Parent Devs are not online.\n"); 2176 2177 goto dev_rst_end; 2178 } 2179 2180 /* There is no tag when lun reset is issue through ioctl. */ 2181 if (unlikely(tag <= SNIC_NO_TAG)) { 2182 SNIC_HOST_INFO(snic->shost, 2183 "Devrst: LUN Reset Recvd thru IOCTL.\n"); 2184 2185 rqi = snic_req_init(snic, 0); 2186 if (!rqi) 2187 goto dev_rst_end; 2188 2189 memset(scsi_cmd_priv(sc), 0, 2190 sizeof(struct snic_internal_io_state)); 2191 CMD_SP(sc) = (char *)rqi; 2192 CMD_FLAGS(sc) = SNIC_NO_FLAGS; 2193 2194 /* Add special tag for dr coming from user spc */ 2195 rqi->tm_tag = SNIC_TAG_IOCTL_DEV_RST; 2196 rqi->sc = sc; 2197 } 2198 2199 ret = snic_send_dr_and_wait(snic, sc); 2200 if (ret) { 2201 SNIC_HOST_ERR(snic->shost, 2202 "Devrst: IO w/ Tag %x Failed w/ err = %d\n", 2203 tag, ret); 2204 2205 snic_unlink_and_release_req(snic, sc, 0); 2206 2207 goto dev_rst_end; 2208 } 2209 2210 ret = snic_dr_finish(snic, sc); 2211 2212 dev_rst_end: 2213 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc, 2214 jiffies_to_msecs(jiffies - start_time), 2215 0, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); 2216 2217 SNIC_SCSI_DBG(snic->shost, 2218 "Devrst: Returning from Device Reset : %s\n", 2219 (ret == SUCCESS) ? "SUCCESS" : "FAILED"); 2220 2221 return ret; 2222 } /* end of snic_device_reset */ 2223 2224 /* 2225 * SCSI Error handling calls driver's eh_host_reset if all prior 2226 * error handling levels return FAILED. 2227 * 2228 * Host Reset is the highest level of error recovery. If this fails, then 2229 * host is offlined by SCSI. 2230 */ 2231 /* 2232 * snic_issue_hba_reset : Queues FW Reset Request. 2233 */ 2234 static int 2235 snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc) 2236 { 2237 struct snic_req_info *rqi = NULL; 2238 struct snic_host_req *req = NULL; 2239 spinlock_t *io_lock = NULL; 2240 DECLARE_COMPLETION_ONSTACK(wait); 2241 unsigned long flags; 2242 int ret = -ENOMEM; 2243 2244 rqi = snic_req_init(snic, 0); 2245 if (!rqi) { 2246 ret = -ENOMEM; 2247 2248 goto hba_rst_end; 2249 } 2250 2251 if (snic_cmd_tag(sc) == SCSI_NO_TAG) { 2252 memset(scsi_cmd_priv(sc), 0, 2253 sizeof(struct snic_internal_io_state)); 2254 SNIC_HOST_INFO(snic->shost, "issu_hr:Host reset thru ioctl.\n"); 2255 rqi->sc = sc; 2256 } 2257 2258 req = rqi_to_req(rqi); 2259 2260 io_lock = snic_io_lock_hash(snic, sc); 2261 spin_lock_irqsave(io_lock, flags); 2262 SNIC_BUG_ON(CMD_SP(sc) != NULL); 2263 CMD_STATE(sc) = SNIC_IOREQ_PENDING; 2264 CMD_SP(sc) = (char *) rqi; 2265 CMD_FLAGS(sc) |= SNIC_IO_INITIALIZED; 2266 snic->remove_wait = &wait; 2267 spin_unlock_irqrestore(io_lock, flags); 2268 2269 /* Initialize Request */ 2270 snic_io_hdr_enc(&req->hdr, SNIC_REQ_HBA_RESET, 0, snic_cmd_tag(sc), 2271 snic->config.hid, 0, (ulong) rqi); 2272 2273 req->u.reset.flags = 0; 2274 2275 ret = snic_queue_wq_desc(snic, req, sizeof(*req)); 2276 if (ret) { 2277 SNIC_HOST_ERR(snic->shost, 2278 "issu_hr:Queuing HBA Reset Failed. w err %d\n", 2279 ret); 2280 2281 goto hba_rst_err; 2282 } 2283 2284 spin_lock_irqsave(io_lock, flags); 2285 CMD_FLAGS(sc) |= SNIC_HOST_RESET_ISSUED; 2286 spin_unlock_irqrestore(io_lock, flags); 2287 atomic64_inc(&snic->s_stats.reset.hba_resets); 2288 SNIC_HOST_INFO(snic->shost, "Queued HBA Reset Successfully.\n"); 2289 2290 wait_for_completion_timeout(snic->remove_wait, 2291 SNIC_HOST_RESET_TIMEOUT); 2292 2293 if (snic_get_state(snic) == SNIC_FWRESET) { 2294 SNIC_HOST_ERR(snic->shost, "reset_cmpl: Reset Timedout.\n"); 2295 ret = -ETIMEDOUT; 2296 2297 goto hba_rst_err; 2298 } 2299 2300 spin_lock_irqsave(io_lock, flags); 2301 snic->remove_wait = NULL; 2302 rqi = (struct snic_req_info *) CMD_SP(sc); 2303 CMD_SP(sc) = NULL; 2304 spin_unlock_irqrestore(io_lock, flags); 2305 2306 if (rqi) 2307 snic_req_free(snic, rqi); 2308 2309 ret = 0; 2310 2311 return ret; 2312 2313 hba_rst_err: 2314 spin_lock_irqsave(io_lock, flags); 2315 snic->remove_wait = NULL; 2316 rqi = (struct snic_req_info *) CMD_SP(sc); 2317 CMD_SP(sc) = NULL; 2318 spin_unlock_irqrestore(io_lock, flags); 2319 2320 if (rqi) 2321 snic_req_free(snic, rqi); 2322 2323 hba_rst_end: 2324 SNIC_HOST_ERR(snic->shost, 2325 "reset:HBA Reset Failed w/ err = %d.\n", 2326 ret); 2327 2328 return ret; 2329 } /* end of snic_issue_hba_reset */ 2330 2331 int 2332 snic_reset(struct Scsi_Host *shost, struct scsi_cmnd *sc) 2333 { 2334 struct snic *snic = shost_priv(shost); 2335 enum snic_state sv_state; 2336 unsigned long flags; 2337 int ret = FAILED; 2338 2339 /* Set snic state as SNIC_FWRESET*/ 2340 sv_state = snic_get_state(snic); 2341 2342 spin_lock_irqsave(&snic->snic_lock, flags); 2343 if (snic_get_state(snic) == SNIC_FWRESET) { 2344 spin_unlock_irqrestore(&snic->snic_lock, flags); 2345 SNIC_HOST_INFO(shost, "reset:prev reset is in progres\n"); 2346 2347 msleep(SNIC_HOST_RESET_TIMEOUT); 2348 ret = SUCCESS; 2349 2350 goto reset_end; 2351 } 2352 2353 snic_set_state(snic, SNIC_FWRESET); 2354 spin_unlock_irqrestore(&snic->snic_lock, flags); 2355 2356 2357 /* Wait for all the IOs that are entered in Qcmd */ 2358 while (atomic_read(&snic->ios_inflight)) 2359 schedule_timeout(msecs_to_jiffies(1)); 2360 2361 ret = snic_issue_hba_reset(snic, sc); 2362 if (ret) { 2363 SNIC_HOST_ERR(shost, 2364 "reset:Host Reset Failed w/ err %d.\n", 2365 ret); 2366 spin_lock_irqsave(&snic->snic_lock, flags); 2367 snic_set_state(snic, sv_state); 2368 spin_unlock_irqrestore(&snic->snic_lock, flags); 2369 atomic64_inc(&snic->s_stats.reset.hba_reset_fail); 2370 ret = FAILED; 2371 2372 goto reset_end; 2373 } 2374 2375 ret = SUCCESS; 2376 2377 reset_end: 2378 return ret; 2379 } /* end of snic_reset */ 2380 2381 /* 2382 * SCSI Error handling calls driver's eh_host_reset if all prior 2383 * error handling levels return FAILED. 2384 * 2385 * Host Reset is the highest level of error recovery. If this fails, then 2386 * host is offlined by SCSI. 2387 */ 2388 int 2389 snic_host_reset(struct scsi_cmnd *sc) 2390 { 2391 struct Scsi_Host *shost = sc->device->host; 2392 u32 start_time = jiffies; 2393 int ret = FAILED; 2394 2395 SNIC_SCSI_DBG(shost, 2396 "host reset:sc %p sc_cmd 0x%x req %p tag %d flags 0x%llx\n", 2397 sc, sc->cmnd[0], sc->request, 2398 snic_cmd_tag(sc), CMD_FLAGS(sc)); 2399 2400 ret = snic_reset(shost, sc); 2401 2402 SNIC_TRC(shost->host_no, snic_cmd_tag(sc), (ulong) sc, 2403 jiffies_to_msecs(jiffies - start_time), 2404 0, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); 2405 2406 return ret; 2407 } /* end of snic_host_reset */ 2408 2409 /* 2410 * snic_cmpl_pending_tmreq : Caller should hold io_lock 2411 */ 2412 static void 2413 snic_cmpl_pending_tmreq(struct snic *snic, struct scsi_cmnd *sc) 2414 { 2415 struct snic_req_info *rqi = NULL; 2416 2417 SNIC_SCSI_DBG(snic->shost, 2418 "Completing Pending TM Req sc %p, state %s flags 0x%llx\n", 2419 sc, snic_io_status_to_str(CMD_STATE(sc)), CMD_FLAGS(sc)); 2420 2421 /* 2422 * CASE : FW didn't post itmf completion due to PCIe Errors. 2423 * Marking the abort status as Success to call scsi completion 2424 * in snic_abort_finish() 2425 */ 2426 CMD_ABTS_STATUS(sc) = SNIC_STAT_IO_SUCCESS; 2427 2428 rqi = (struct snic_req_info *) CMD_SP(sc); 2429 if (!rqi) 2430 return; 2431 2432 if (rqi->dr_done) 2433 complete(rqi->dr_done); 2434 else if (rqi->abts_done) 2435 complete(rqi->abts_done); 2436 } 2437 2438 /* 2439 * snic_scsi_cleanup: Walks through tag map and releases the reqs 2440 */ 2441 static void 2442 snic_scsi_cleanup(struct snic *snic, int ex_tag) 2443 { 2444 struct snic_req_info *rqi = NULL; 2445 struct scsi_cmnd *sc = NULL; 2446 spinlock_t *io_lock = NULL; 2447 unsigned long flags; 2448 int tag; 2449 u64 st_time = 0; 2450 2451 SNIC_SCSI_DBG(snic->shost, "sc_clean: scsi cleanup.\n"); 2452 2453 for (tag = 0; tag < snic->max_tag_id; tag++) { 2454 /* Skip ex_tag */ 2455 if (tag == ex_tag) 2456 continue; 2457 2458 io_lock = snic_io_lock_tag(snic, tag); 2459 spin_lock_irqsave(io_lock, flags); 2460 sc = scsi_host_find_tag(snic->shost, tag); 2461 if (!sc) { 2462 spin_unlock_irqrestore(io_lock, flags); 2463 2464 continue; 2465 } 2466 2467 if (unlikely(snic_tmreq_pending(sc))) { 2468 /* 2469 * When FW Completes reset w/o sending completions 2470 * for outstanding ios. 2471 */ 2472 snic_cmpl_pending_tmreq(snic, sc); 2473 spin_unlock_irqrestore(io_lock, flags); 2474 2475 continue; 2476 } 2477 2478 rqi = (struct snic_req_info *) CMD_SP(sc); 2479 if (!rqi) { 2480 spin_unlock_irqrestore(io_lock, flags); 2481 2482 goto cleanup; 2483 } 2484 2485 SNIC_SCSI_DBG(snic->shost, 2486 "sc_clean: sc %p, rqi %p, tag %d flags 0x%llx\n", 2487 sc, rqi, tag, CMD_FLAGS(sc)); 2488 2489 CMD_SP(sc) = NULL; 2490 CMD_FLAGS(sc) |= SNIC_SCSI_CLEANUP; 2491 spin_unlock_irqrestore(io_lock, flags); 2492 st_time = rqi->start_time; 2493 2494 SNIC_HOST_INFO(snic->shost, 2495 "sc_clean: Releasing rqi %p : flags 0x%llx\n", 2496 rqi, CMD_FLAGS(sc)); 2497 2498 snic_release_req_buf(snic, rqi, sc); 2499 2500 cleanup: 2501 sc->result = DID_TRANSPORT_DISRUPTED << 16; 2502 SNIC_HOST_INFO(snic->shost, 2503 "sc_clean: DID_TRANSPORT_DISRUPTED for sc %p, Tag %d flags 0x%llx rqi %p duration %u msecs\n", 2504 sc, sc->request->tag, CMD_FLAGS(sc), rqi, 2505 jiffies_to_msecs(jiffies - st_time)); 2506 2507 /* Update IO stats */ 2508 snic_stats_update_io_cmpl(&snic->s_stats); 2509 2510 if (sc->scsi_done) { 2511 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc, 2512 jiffies_to_msecs(jiffies - st_time), 0, 2513 SNIC_TRC_CMD(sc), 2514 SNIC_TRC_CMD_STATE_FLAGS(sc)); 2515 2516 sc->scsi_done(sc); 2517 } 2518 } 2519 } /* end of snic_scsi_cleanup */ 2520 2521 void 2522 snic_shutdown_scsi_cleanup(struct snic *snic) 2523 { 2524 SNIC_HOST_INFO(snic->shost, "Shutdown time SCSI Cleanup.\n"); 2525 2526 snic_scsi_cleanup(snic, SCSI_NO_TAG); 2527 } /* end of snic_shutdown_scsi_cleanup */ 2528 2529 /* 2530 * snic_internal_abort_io 2531 * called by : snic_tgt_scsi_abort_io 2532 */ 2533 static int 2534 snic_internal_abort_io(struct snic *snic, struct scsi_cmnd *sc, int tmf) 2535 { 2536 struct snic_req_info *rqi = NULL; 2537 spinlock_t *io_lock = NULL; 2538 unsigned long flags; 2539 u32 sv_state = 0; 2540 int ret = 0; 2541 2542 io_lock = snic_io_lock_hash(snic, sc); 2543 spin_lock_irqsave(io_lock, flags); 2544 rqi = (struct snic_req_info *) CMD_SP(sc); 2545 if (!rqi) 2546 goto skip_internal_abts; 2547 2548 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) 2549 goto skip_internal_abts; 2550 2551 if ((CMD_FLAGS(sc) & SNIC_DEVICE_RESET) && 2552 (!(CMD_FLAGS(sc) & SNIC_DEV_RST_ISSUED))) { 2553 2554 SNIC_SCSI_DBG(snic->shost, 2555 "internal_abts: dev rst not pending sc 0x%p\n", 2556 sc); 2557 2558 goto skip_internal_abts; 2559 } 2560 2561 2562 if (!(CMD_FLAGS(sc) & SNIC_IO_ISSUED)) { 2563 SNIC_SCSI_DBG(snic->shost, 2564 "internal_abts: IO not yet issued sc 0x%p tag 0x%x flags 0x%llx state %d\n", 2565 sc, snic_cmd_tag(sc), CMD_FLAGS(sc), CMD_STATE(sc)); 2566 2567 goto skip_internal_abts; 2568 } 2569 2570 sv_state = CMD_STATE(sc); 2571 CMD_STATE(sc) = SNIC_IOREQ_ABTS_PENDING; 2572 CMD_ABTS_STATUS(sc) = SNIC_INVALID_CODE; 2573 CMD_FLAGS(sc) |= SNIC_IO_INTERNAL_TERM_PENDING; 2574 2575 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) { 2576 /* stats */ 2577 rqi->tm_tag = SNIC_TAG_DEV_RST; 2578 SNIC_SCSI_DBG(snic->shost, "internal_abts:dev rst sc %p\n", sc); 2579 } 2580 2581 SNIC_SCSI_DBG(snic->shost, "internal_abts: Issuing abts tag %x\n", 2582 snic_cmd_tag(sc)); 2583 SNIC_BUG_ON(rqi->abts_done); 2584 spin_unlock_irqrestore(io_lock, flags); 2585 2586 ret = snic_queue_abort_req(snic, rqi, sc, tmf); 2587 if (ret) { 2588 SNIC_HOST_ERR(snic->shost, 2589 "internal_abts: Tag = %x , Failed w/ err = %d\n", 2590 snic_cmd_tag(sc), ret); 2591 2592 spin_lock_irqsave(io_lock, flags); 2593 2594 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) 2595 CMD_STATE(sc) = sv_state; 2596 2597 goto skip_internal_abts; 2598 } 2599 2600 spin_lock_irqsave(io_lock, flags); 2601 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) 2602 CMD_FLAGS(sc) |= SNIC_DEV_RST_TERM_ISSUED; 2603 else 2604 CMD_FLAGS(sc) |= SNIC_IO_INTERNAL_TERM_ISSUED; 2605 2606 ret = SUCCESS; 2607 2608 skip_internal_abts: 2609 SNIC_BUG_ON(!spin_is_locked(io_lock)); 2610 spin_unlock_irqrestore(io_lock, flags); 2611 2612 return ret; 2613 } /* end of snic_internal_abort_io */ 2614 2615 /* 2616 * snic_tgt_scsi_abort_io : called by snic_tgt_del 2617 */ 2618 int 2619 snic_tgt_scsi_abort_io(struct snic_tgt *tgt) 2620 { 2621 struct snic *snic = NULL; 2622 struct scsi_cmnd *sc = NULL; 2623 struct snic_tgt *sc_tgt = NULL; 2624 spinlock_t *io_lock = NULL; 2625 unsigned long flags; 2626 int ret = 0, tag, abt_cnt = 0, tmf = 0; 2627 2628 if (!tgt) 2629 return -1; 2630 2631 snic = shost_priv(snic_tgt_to_shost(tgt)); 2632 SNIC_SCSI_DBG(snic->shost, "tgt_abt_io: Cleaning Pending IOs.\n"); 2633 2634 if (tgt->tdata.typ == SNIC_TGT_DAS) 2635 tmf = SNIC_ITMF_ABTS_TASK; 2636 else 2637 tmf = SNIC_ITMF_ABTS_TASK_TERM; 2638 2639 for (tag = 0; tag < snic->max_tag_id; tag++) { 2640 io_lock = snic_io_lock_tag(snic, tag); 2641 2642 spin_lock_irqsave(io_lock, flags); 2643 sc = scsi_host_find_tag(snic->shost, tag); 2644 if (!sc) { 2645 spin_unlock_irqrestore(io_lock, flags); 2646 2647 continue; 2648 } 2649 2650 sc_tgt = starget_to_tgt(scsi_target(sc->device)); 2651 if (sc_tgt != tgt) { 2652 spin_unlock_irqrestore(io_lock, flags); 2653 2654 continue; 2655 } 2656 spin_unlock_irqrestore(io_lock, flags); 2657 2658 ret = snic_internal_abort_io(snic, sc, tmf); 2659 if (ret < 0) { 2660 SNIC_HOST_ERR(snic->shost, 2661 "tgt_abt_io: Tag %x, Failed w err = %d\n", 2662 tag, ret); 2663 2664 continue; 2665 } 2666 2667 if (ret == SUCCESS) 2668 abt_cnt++; 2669 } 2670 2671 SNIC_SCSI_DBG(snic->shost, "tgt_abt_io: abt_cnt = %d\n", abt_cnt); 2672 2673 return 0; 2674 } /* end of snic_tgt_scsi_abort_io */ 2675