From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Narsimhulu Musini (nmusini)" Subject: Re: [PATCH v4 5/9] snic:add SCSI handling, AEN, and fwreset handling Date: Mon, 13 Apr 2015 05:37:53 +0000 Message-ID: References: <1428580189-22785-1-git-send-email-nmusini@cisco.com> <1428580189-22785-6-git-send-email-nmusini@cisco.com> <55267BB9.8010009@suse.de> Mime-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Transfer-Encoding: QUOTED-PRINTABLE Return-path: Received: from alln-iport-3.cisco.com ([173.37.142.90]:51997 "EHLO alln-iport-3.cisco.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751067AbbDMFh5 convert rfc822-to-8bit (ORCPT ); Mon, 13 Apr 2015 01:37:57 -0400 In-Reply-To: <55267BB9.8010009@suse.de> Content-Language: en-US Content-ID: Sender: linux-scsi-owner@vger.kernel.org List-Id: linux-scsi@vger.kernel.org To: Hannes Reinecke , "JBottomley@Parallels.com" , "linux-scsi@vger.kernel.org" , "hch@infradead.org" Cc: "Sesidhar Baddela (sebaddel)" Hi Hannes, Thank you for reviewing patches. Please find responses inline. I will incorporate the comments and suggestions in next patch submittal= =2E On 09/04/15 6:46 pm, "Hannes Reinecke" wrote: >Hi Narsimhulu, > >please find some comments inline. > >On 04/09/2015 01:49 PM, Narsimhulu Musini wrote: >> snic_scsi.c contains scsi handling, includes queuing io, abort, lun >>reset, >> and host reset. Also it handles asynchronous event notifications fro= m >>FW. >>=20 >> Signed-off-by: Narsimhulu Musini >> Signed-off-by: Sesidhar Baddela >> --- >> * v2 >> - Changed queuecommand to lock-free version. >> - Converted custom error codes to standard error codes. >>=20 >> drivers/scsi/snic/snic_scsi.c | 2638 >>+++++++++++++++++++++++++++++++++++++++++ >> 1 file changed, 2638 insertions(+) >> create mode 100644 drivers/scsi/snic/snic_scsi.c >>=20 >> diff --git a/drivers/scsi/snic/snic_scsi.c >>b/drivers/scsi/snic/snic_scsi.c >> new file mode 100644 >> index 0000000..5d877f0 >> --- /dev/null >> +++ b/drivers/scsi/snic/snic_scsi.c >> @@ -0,0 +1,2638 @@ >> +/* >> + * Copyright 2014 Cisco Systems, Inc. All rights reserved. >> + * >> + * This program is free software; you may redistribute it and/or mo= dify >> + * it under the terms of the GNU General Public License as publishe= d by >> + * the Free Software Foundation; version 2 of the License. >> + * >> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, >> + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES = OF >> + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND >> + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLD= ERS >> + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN = AN >> + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR I= N >> + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE >> + * SOFTWARE. >> + */ >> + >> +#include >> +#include >> +#include >> +#include >> +#include > +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> +#include >> + >> +#include "snic_io.h" >> +#include "snic.h" >> + >> +#define snic_cmd_tag(sc) (((struct scsi_cmnd *) sc)->request->tag) >> + >> +const char *snic_state_str[] =3D { >> + [SNIC_INIT] =3D "SNIC_INIT", >> + [SNIC_ERROR] =3D "SNIC_ERROR", >> + [SNIC_ONLINE] =3D "SNIC_ONLINE", >> + [SNIC_OFFLINE] =3D "SNIC_OFFLINE", >> + [SNIC_FWRESET] =3D "SNIC_FWRESET", >> +}; >> + >> +static const char * const snic_req_state_str[] =3D { >> + [SNIC_IOREQ_NOT_INITED] =3D "SNIC_IOREQ_NOT_INITED", >> + [SNIC_IOREQ_PENDING] =3D "SNIC_IOREQ_PENDING", >> + [SNIC_IOREQ_ABTS_PENDING] =3D "SNIC_IOREQ_ABTS_PENDING", >> + [SNIC_IOREQ_ABTS_COMPLETE] =3D "SNIC_IOREQ_ABTS_COMPELTE", >> + [SNIC_IOREQ_LR_PENDING] =3D "SNIC_IOREQ_LR_PENDING", >> + [SNIC_IOREQ_LR_COMPLETE] =3D "SNIC_IOREQ_LR_COMPELTE", >> + [SNIC_IOREQ_COMPLETE] =3D "SNIC_IOREQ_CMD_COMPELTE", >> +}; >> + >> +/* snic cmd status strings */ >> +static const char * const snic_io_status_str[] =3D { >> + [SNIC_STAT_IO_SUCCESS] =3D "SNIC_STAT_IO_SUCCESS", /* 0x0 */ >> + [SNIC_STAT_INVALID_HDR] =3D "SNIC_STAT_INVALID_HDR", >> + [SNIC_STAT_OUT_OF_RES] =3D "SNIC_STAT_OUT_OF_RES", >> + [SNIC_STAT_INVALID_PARM] =3D "SNIC_STAT_INVALID_PARM", >> + [SNIC_STAT_REQ_NOT_SUP] =3D "SNIC_STAT_REQ_NOT_SUP", >> + [SNIC_STAT_IO_NOT_FOUND] =3D "SNIC_STAT_IO_NOT_FOUND", >> + [SNIC_STAT_ABORTED] =3D "SNIC_STAT_ABORTED", >> + [SNIC_STAT_TIMEOUT] =3D "SNIC_STAT_TIMEOUT", >> + [SNIC_STAT_SGL_INVALID] =3D "SNIC_STAT_SGL_INVALID", >> + [SNIC_STAT_DATA_CNT_MISMATCH] =3D "SNIC_STAT_DATA_CNT_MISMATCH", >> + [SNIC_STAT_FW_ERR] =3D "SNIC_STAT_FW_ERR", >> + [SNIC_STAT_ITMF_REJECT] =3D "SNIC_STAT_ITMF_REJECT", >> + [SNIC_STAT_ITMF_FAIL] =3D "SNIC_STAT_ITMF_FAIL", >> + [SNIC_STAT_ITMF_INCORRECT_LUN] =3D "SNIC_STAT_ITMF_INCORRECT_LUN", >> + [SNIC_STAT_CMND_REJECT] =3D "SNIC_STAT_CMND_REJECT", >> + [SNIC_STAT_DEV_OFFLINE] =3D "SNIC_STAT_DEV_OFFLINE", >> + [SNIC_STAT_NO_BOOTLUN] =3D "SNIC_STAT_NO_BOOTLUN", >> + [SNIC_STAT_SCSI_ERR] =3D "SNIC_STAT_SCSI_ERR", >> + [SNIC_STAT_NOT_READY] =3D "SNIC_STAT_NOT_READY", >> + [SNIC_STAT_FATAL_ERROR] =3D "SNIC_STAT_FATAL_ERROR", >> +}; >> + >> +static void snic_scsi_cleanup(struct snic *, int); >> + >> +const char * >> +snic_state_to_str(unsigned int state) >> +{ >> + if (state >=3D ARRAY_SIZE(snic_state_str) || !snic_state_str[state= ]) >> + return "Unknown"; >> + >> + return snic_state_str[state]; >> +} >> + >> +static const char * >> +snic_io_status_to_str(unsigned int state) >> +{ >> + if ((state >=3D ARRAY_SIZE(snic_io_status_str)) || >> + (!snic_io_status_str[state])) >> + return "Unknown"; >> + >> + return snic_io_status_str[state]; >> +} >> + >> +static const char * >> +snic_ioreq_state_to_str(unsigned int state) >> +{ >> + if (state >=3D ARRAY_SIZE(snic_req_state_str) || >> + !snic_req_state_str[state]) >> + return "Unknown"; >> + >> + return snic_req_state_str[state]; >> +} >> + >> +static inline spinlock_t * >> +snic_io_lock_hash(struct snic *snic, struct scsi_cmnd *sc) >> +{ >> + u32 hash =3D snic_cmd_tag(sc) & (SNIC_IO_LOCKS - 1); >> + >> + return &snic->io_req_lock[hash]; >> +} >> + >> +static inline spinlock_t * >> +snic_io_lock_tag(struct snic *snic, int tag) >> +{ >> + return &snic->io_req_lock[tag & (SNIC_IO_LOCKS - 1)]; >> +} >> + >> +/* snic_release_req_buf : Releases snic_req_info */ >> +static void >> +snic_release_req_buf(struct snic *snic, >> + struct snic_req_info *rqi, >> + struct scsi_cmnd *sc) >> +{ >> + struct snic_host_req *req =3D rqi_to_req(rqi); >> + >> + /* Freeing cmd without marking completion, not okay */ >> + SNIC_BUG_ON(!((CMD_STATE(sc) =3D=3D SNIC_IOREQ_COMPLETE) || >> + (CMD_STATE(sc) =3D=3D SNIC_IOREQ_ABTS_COMPLETE) || >> + (CMD_FLAGS(sc) & SNIC_DEV_RST_NOTSUP) || >> + (CMD_FLAGS(sc) & SNIC_IO_INTERNAL_TERM_ISSUED) || >> + (CMD_FLAGS(sc) & SNIC_DEV_RST_TERM_ISSUED) || >> + (CMD_FLAGS(sc) & SNIC_SCSI_CLEANUP) || >> + (CMD_STATE(sc) =3D=3D SNIC_IOREQ_LR_COMPLETE))); >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "Rel_req:sc %p:tag %x:rqi %p:ioreq %p:abt %p:dr %p: state >>%s:flags 0x%llx\n", >> + sc, snic_cmd_tag(sc), rqi, rqi->req, rqi->abort_req, >> + qi->dr_req, snic_ioreq_state_to_str(CMD_STATE(sc)), >> + CMD_FLAGS(sc)); >> + >> + if (req->u.icmnd.sense_addr) >> + pci_unmap_single(snic->pdev, >> + req->u.icmnd.sense_addr, >> + SCSI_SENSE_BUFFERSIZE, >> + PCI_DMA_FROMDEVICE); >> + >> + scsi_dma_unmap(sc); >> + >> + snic_req_free(snic, rqi); >> +} /* end of snic_release_req_buf */ >> + >> +/* >> + * snic_queue_icmnd_req : Queues snic_icmnd request >> + */ >> +static int >> +snic_queue_icmnd_req(struct snic *snic, >> + struct snic_req_info *rqi, >> + struct scsi_cmnd *sc, >> + int sg_cnt) >> +{ >> + struct scatterlist *sg; >> + struct snic_sg_desc *sgd; >> + dma_addr_t pa =3D 0; >> + struct scsi_lun lun; >> + int flags =3D 0; >> + int ret =3D 0; >> + unsigned int i; >> + >> + if (sg_cnt) { >> + flags =3D SNIC_ICMND_ESGL; >> + sgd =3D (struct snic_sg_desc *) req_to_sgl(rqi->req); >> + >> + for_each_sg(scsi_sglist(sc), sg, sg_cnt, i) { >> + sgd->addr =3D cpu_to_le64(sg_dma_address(sg)); >> + sgd->len =3D cpu_to_le32(sg_dma_len(sg)); >> + sgd->_resvd =3D 0; >> + sgd++; >> + } >> + } >> + >> + pa =3D pci_map_single(snic->pdev, >> + sc->sense_buffer, >> + SCSI_SENSE_BUFFERSIZE, >> + PCI_DMA_FROMDEVICE); >> + >> + if (pci_dma_mapping_error(snic->pdev, pa)) { >> + SNIC_HOST_ERR(snic->shost, >> + "QIcmnd:PCI Map Failed for sns buf %p tag %x\n", >> + sc->sense_buffer, snic_cmd_tag(sc)); >> + ret =3D -ENOMEM; >> + >> + return ret; >> + } >> + >> + int_to_scsilun(sc->device->lun, &lun); >> + if (sc->sc_data_direction =3D=3D DMA_FROM_DEVICE) >> + flags |=3D SNIC_ICMND_RD; >> + if (sc->sc_data_direction =3D=3D DMA_TO_DEVICE) >> + flags |=3D SNIC_ICMND_WR; >> + >> + /* Initialize icmnd */ >> + snic_icmnd_init(rqi->req, >> + snic_cmd_tag(sc), >> + snic->config.hid, /* hid */ >> + (u64)rqi, >> + flags, /* command flags */ >> + rqi->tgt_id, >> + lun.scsi_lun, >> + sc->cmnd, >> + sc->cmd_len, >> + scsi_bufflen(sc), >> + sg_cnt, >> + (u64)req_to_sgl(rqi->req), >> + pa, /* sense buffer pa */ >> + SCSI_SENSE_BUFFERSIZE); >> + >> + ret =3D snic_queue_wq_desc(snic, rqi->req, rqi->req_len); >> + if (ret) >> + SNIC_HOST_ERR(snic->shost, >> + "QIcmnd: Queuing Icmnd Failed. ret =3D %d\n", >> + ret); >> + >> + return ret; >> +} /* end of snic_queue_icmnd_req */ >> + >> +/* >> + * snic_issue_scsi_req : Prepares IO request and Issues to FW. >> + */ >> +static int >> +snic_issue_scsi_req(struct snic *snic, >> + struct snic_tgt *tgt, >> + struct scsi_cmnd *sc) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + int sg_cnt =3D 0; >> + int ret =3D 0; >> + u32 tag =3D snic_cmd_tag(sc); >> + u64 cmd_trc =3D 0, cmd_st_flags =3D 0; >> + spinlock_t *io_lock =3D NULL; >> + unsigned long flags; >> + >> + CMD_STATE(sc) =3D SNIC_IOREQ_NOT_INITED; >> + CMD_FLAGS(sc) =3D SNIC_NO_FLAGS; >> + sg_cnt =3D scsi_dma_map(sc); >> + if (sg_cnt < 0) { >> + SNIC_TRC((u16)snic->shost->host_no, tag, (u64)sc, 0, >> + sc->cmnd[0], sg_cnt, CMD_STATE(sc)); >> + >> + SNIC_HOST_ERR(snic->shost, "issue_sc:Failed to map SG List.\n"); >> + ret =3D -ENOMEM; >> + >> + goto issue_sc_end; >> + } >> + >> + rqi =3D snic_req_init(snic, sg_cnt); >> + if (!rqi) { >> + scsi_dma_unmap(sc); >> + ret =3D -ENOMEM; >> + >> + goto issue_sc_end; >> + } >> + >> + rqi->tgt_id =3D tgt->id; >> + rqi->sc =3D sc; >> + >> + CMD_STATE(sc) =3D SNIC_IOREQ_PENDING; >> + CMD_SP(sc) =3D (char *) rqi; >> + cmd_trc =3D SNIC_TRC_CMD(sc); >> + CMD_FLAGS(sc) |=3D (SNIC_IO_INITIALIZED | SNIC_IO_ISSUED); >> + cmd_st_flags =3D SNIC_TRC_CMD_STATE_FLAGS(sc); >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + >> + /* create wq desc and enqueue it */ >> + ret =3D snic_queue_icmnd_req(snic, rqi, sc, sg_cnt); >> + if (ret) { >> + SNIC_HOST_ERR(snic->shost, >> + "issue_sc: icmnd qing Failed for sc %p, err %d\n", >> + sc, ret); >> + >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + CMD_SP(sc) =3D NULL; >> + CMD_STATE(sc) =3D SNIC_IOREQ_COMPLETE; >> + CMD_FLAGS(sc) &=3D ~SNIC_IO_ISSUED; /* turn off the flag */ >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + if (rqi) >> + snic_release_req_buf(snic, rqi, sc); >> + >> + SNIC_TRC(snic->shost->host_no, tag, (u64)sc, 0, 0, 0, >> + SNIC_TRC_CMD_STATE_FLAGS(sc)); >> + } else { >> + u32 io_sz =3D scsi_bufflen(sc) >> 9; >> + u32 qtime =3D jiffies - rqi->start_time; >> + struct snic_io_stats *iostats =3D &snic->s_stats.io; >> + >> + if (io_sz > atomic64_read(&iostats->max_io_sz)) >> + atomic64_set(&iostats->max_io_sz, io_sz); >> + >> + if (qtime > atomic64_read(&iostats->max_qtime)) >> + atomic64_set(&iostats->max_qtime, qtime); >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "issue_sc:sc %p, tag %d queued to WQ.\n", >> + sc, tag); >> + >> + SNIC_TRC(snic->shost->host_no, tag, (u64)sc, (u64)rqi, sg_cnt, >> + cmd_trc, cmd_st_flags); >> + } >> + >> +issue_sc_end: >> + >> + return ret; >> +} /* end of snic_issue_scsi_req */ >> + >> + >> +/* >> + * snic_queuecommand >> + * Routine to send a scsi cdb to LLD >> + * Called with host_lock held and interrupts disabled >> + */ >> +int >> +snic_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc) >> +{ >> + struct snic_tgt *tgt =3D NULL; >> + struct snic *snic =3D shost_priv(shost); >> + int ret; >> + >> + tgt =3D starget_to_tgt(scsi_target(sc->device)); >> + ret =3D snic_tgt_chkready(tgt); >> + if (ret) { >> + SNIC_HOST_ERR(shost, "Tgt %p id %d Not Ready.\n", tgt, tgt->id); >> + atomic64_inc(&snic->s_stats.misc.tgt_not_rdy); >> + sc->result =3D ret; >> + sc->scsi_done(sc); >> + >> + return 0; >> + } >> + >> + if (snic_get_state(snic) !=3D SNIC_ONLINE) { >> + SNIC_HOST_ERR(shost, "snic state is %s\n", >> + snic_state_str[snic_get_state(snic)]); >> + >> + return SCSI_MLQUEUE_HOST_BUSY; >> + } >> + atomic_inc(&snic->ios_inflight); >> + >> + SNIC_SCSI_DBG(shost, "sc %p Tag %d (sc %0x) lun %lld in snic_qcmd\= n", >> + sc, snic_cmd_tag(sc), sc->cmnd[0], sc->device->lun); >> + >> + memset(scsi_cmd_priv(sc), 0, sizeof(struct snic_internal_io_state)= ); >> + >> +#ifdef SNIC_DEBUG >> + scsi_print_command(sc); >> +#endif >> + >> + ret =3D snic_issue_scsi_req(snic, tgt, sc); >> + if (ret) { >> + SNIC_HOST_ERR(shost, "Failed to Q, Scsi Req w/ err %d.\n", ret); >> + ret =3D SCSI_MLQUEUE_HOST_BUSY; >> + } else >> + snic_stats_update_active_ios(&snic->s_stats); >> + >> + atomic_dec(&snic->ios_inflight); >> + >> + return ret; >> +} /* end of snic_queuecommand */ >> + >> +/* >> + * snic_process_abts_pending_state: >> + * caller should hold IO lock >> + */ >> +static void >> +snic_proc_tmreq_pending_state(struct snic *snic, >> + struct scsi_cmnd *sc, >> + u8 cmpl_status) >> +{ >> + int state =3D CMD_STATE(sc); >> + >> + if (state =3D=3D SNIC_IOREQ_ABTS_PENDING) >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABTS_PENDING; >> + else if (state =3D=3D SNIC_IOREQ_LR_PENDING) >> + CMD_FLAGS(sc) |=3D SNIC_DEV_RST_PENDING; >> + else >> + SNIC_BUG_ON(1); >> + >> + switch (cmpl_status) { >> + case SNIC_STAT_IO_SUCCESS: >> + CMD_FLAGS(sc) |=3D SNIC_IO_DONE; >> + break; >> + >> + case SNIC_STAT_ABORTED: >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABORTED; >> + break; >> + >> + default: >> + SNIC_BUG_ON(1); >> + } >> +} >> + >> +/* >> + * snic_process_io_failed_state: >> + * Processes IO's error states >> + */ >> +static void >> +snic_process_io_failed_state(struct snic *snic, >> + struct snic_icmnd_cmpl *icmnd_cmpl, >> + struct scsi_cmnd *sc, >> + u8 cmpl_stat) >> +{ >> + int res =3D 0; >> + >> + switch (cmpl_stat) { >> + case SNIC_STAT_TIMEOUT: /* Req was timedout */ >> + atomic64_inc(&snic->s_stats.misc.io_tmo); >> + res =3D DID_TIME_OUT; >> + break; >> + >> + case SNIC_STAT_ABORTED: /* Req was aborted */ >> + atomic64_inc(&snic->s_stats.misc.io_aborted); >> + res =3D DID_ERROR; >> + break; >> + >DID_ABORTED? Sure, I will change it to DID_ABORT. > >> + case SNIC_STAT_DATA_CNT_MISMATCH:/* Recv/Sent more/less data than = exp >>*/ >> + atomic64_inc(&snic->s_stats.misc.data_cnt_mismat); >> + scsi_set_resid(sc, icmnd_cmpl->resid); >> + res =3D DID_ERROR; >> + break; >> + >> + case SNIC_STAT_OUT_OF_RES: /* Out of resources to complete request= */ >> + atomic64_inc(&snic->s_stats.fw.out_of_res); >> + res =3D DID_REQUEUE; >> + break; >> + >> + case SNIC_STAT_IO_NOT_FOUND: /* Requested I/O was not found */ >> + atomic64_inc(&snic->s_stats.io.io_not_found); >> + res =3D DID_ERROR; >> + break; >> + >> + case SNIC_STAT_SGL_INVALID: /* Req was aborted to due to sgl error= */ >> + atomic64_inc(&snic->s_stats.misc.sgl_inval); >> + res =3D DID_ERROR; >> + break; >> + >> + case SNIC_STAT_FW_ERR: /* Req terminated due to FW Error */ >> + atomic64_inc(&snic->s_stats.fw.io_errs); >> + res =3D DID_ERROR; >> + break; >> + >> + case SNIC_STAT_SCSI_ERR: /* FW hits SCSI Error */ >> + atomic64_inc(&snic->s_stats.fw.scsi_errs); >> + res =3D DID_ERROR; >> + break; >> + >SCSI error? What should stat be? If it's the normal SAM_STAT_XXX value= s >it should be decoded correctly. Thanks for pointing this, FW sends CHECKCONDITION status, sense information to midlyaer, and expect mid layer to act on it. In this cas= e, DID_ERROR causes to take no action on check condition status. So passin= g scsi status without DID_ERROR will make mid layer to act on CHECKCONDIT= ION. > >> + case SNIC_STAT_INVALID_HDR: /* Hdr contains invalid data */ >> + case SNIC_STAT_INVALID_PARM: /* Some param in req is invalid */ >> + case SNIC_STAT_REQ_NOT_SUP: /* Req type is not supported */ >> + case SNIC_STAT_CMND_REJECT: /* Req rejected */ >> + case SNIC_STAT_DEV_OFFLINE: /* Device offline */ >> + case SNIC_STAT_NOT_READY: /* XPT yet to initialize */ >> + case SNIC_STAT_FATAL_ERROR: /* XPT Error */ >> + default: >> + SNIC_SCSI_DBG(snic->shost, >> + "Invalid Hdr/Param or Req Not Supported or Cmnd Rejected o= r >>Device Offline. or Unknown\n"); >> + res =3D DID_ERROR; >> + break; >> + } >> + >You should be returning 'DID_NO_CONNECT' for DEV_OFFLINE. If NOT_READY >is temporary you should be returning DID_RETRY or similar. >Otherwise DID_NO_CONNECT is preferred, too. Sure, I will change it to DID_NO_CONNECT for DEV OFFLINE, And DID_RETRY for NOT_READY. > >> + SNIC_HOST_ERR(snic->shost, "fw returns failed status %s flags >>0x%llx\n", >> + snic_io_status_to_str(cmpl_stat), CMD_FLAGS(sc)); >> + >> + /* Set sc->result */ >> + sc->result =3D (res << 16) | icmnd_cmpl->scsi_status; >> +} /* end of snic_process_io_failed_state */ >> + >> +/* >> + * snic_tmreq_pending : is task management in progress. >> + */ >> +static int >> +snic_tmreq_pending(struct scsi_cmnd *sc) >> +{ >> + int state =3D CMD_STATE(sc); >> + >> + return ((state =3D=3D SNIC_IOREQ_ABTS_PENDING) || >> + (state =3D=3D SNIC_IOREQ_LR_PENDING)); >> +} >> + >> +/* >> + * snic_process_icmnd_cmpl_status: >> + * Caller should hold io_lock >> + */ >> +static int >> +snic_process_icmnd_cmpl_status(struct snic *snic, >> + struct snic_icmnd_cmpl *icmnd_cmpl, >> + u8 cmpl_stat, >> + struct scsi_cmnd *sc) >> +{ >> + u8 scsi_stat =3D icmnd_cmpl->scsi_status; >> + u64 xfer_len =3D 0; >> + int ret =3D 0; >> + >> + /* Mark the IO as complete */ >> + CMD_STATE(sc) =3D SNIC_IOREQ_COMPLETE; >> + >> + if (likely(cmpl_stat =3D=3D SNIC_STAT_IO_SUCCESS)) { >> + sc->result =3D (DID_OK << 16) | scsi_stat; >> + >> + xfer_len =3D scsi_bufflen(sc); >> + >> + /* Update SCSI Cmd with resid value */ >> + scsi_set_resid(sc, icmnd_cmpl->resid); >> + >> + if (icmnd_cmpl->flags & SNIC_ICMND_CMPL_UNDR_RUN) { >> + xfer_len -=3D icmnd_cmpl->resid; >> + atomic64_inc(&snic->s_stats.misc.io_under_run); >> + } >> + >> + if (icmnd_cmpl->scsi_status =3D=3D SAM_STAT_TASK_SET_FULL) >> + atomic64_inc(&snic->s_stats.misc.qfull); >> + >> + ret =3D 0; >> + } else { >> + snic_process_io_failed_state(snic, icmnd_cmpl, sc, cmpl_stat); >> + atomic64_inc(&snic->s_stats.io.fail); >> + SNIC_HOST_ERR(snic->shost, >> + "icmnd_cmpl: IO Failed : Hdr Status %s flags 0x%llx\n", >> + snic_io_status_to_str(cmpl_stat), CMD_FLAGS(sc)); >> + ret =3D 1; >> + } >> + >> + return ret; >> +} /* end of snic_process_icmnd_cmpl_status */ >> + >> + >> +/* >> + * snic_icmnd_cmpl_handler >> + * Routine to handle icmnd completions >> + */ >> +static void >> +snic_icmnd_cmpl_handler(struct snic *snic, struct snic_fw_req *fwre= q) >> +{ >> + u8 typ, hdr_stat; >> + u32 cmnd_id, hid; >> + u64 ctx; >> + struct scsi_cmnd *sc =3D NULL; >> + struct snic_icmnd_cmpl *icmnd_cmpl =3D NULL; >> + struct snic_host_req *req =3D NULL; >> + struct snic_req_info *rqi =3D NULL; >> + unsigned long flags, start_time; >> + spinlock_t *io_lock; >> + u8 sc_stat =3D 0; >> + >> + snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx= ); >> + icmnd_cmpl =3D &fwreq->u.icmnd_cmpl; >> + sc_stat =3D icmnd_cmpl->scsi_status; >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "Icmnd_cmpl: type =3D %x, hdr_stat =3D %x, cmnd_id =3D %x, = hid =3D >>%x,i ctx =3D %llx\n", >> + typ, hdr_stat, cmnd_id, hid, ctx); >> + >> + if (cmnd_id >=3D snic->max_tag_id) { >> + SNIC_HOST_ERR(snic->shost, >> + "Icmnd_cmpl:Tag Error:Out of Range Tag %d, hdr status =3D = %s\n", >> + cmnd_id, snic_io_status_to_str(hdr_stat)); >> + return; >> + } >> + >> + sc =3D scsi_host_find_tag(snic->shost, cmnd_id); >> + WARN_ON_ONCE(!sc); >> + >> + if (!sc) { >> + atomic64_inc(&snic->s_stats.io.sc_null); >> + SNIC_HOST_ERR(snic->shost, >> + "Icmnd_cmpl: Scsi Cmnd Not found, sc =3D NULL Hdr Status =3D= %s >>tag =3D 0x%x fwreq =3D 0x%p\n", >> + snic_io_status_to_str(hdr_stat), >> + cmnd_id, >> + fwreq); >> + >> + SNIC_TRC(snic->shost->host_no, cmnd_id, 0, >> + ((u64)hdr_stat << 16 | >> + (u64)sc_stat << 8 | (u64)icmnd_cmpl->flags), >> + fwreq, icmnd_cmpl->resid, ctx); >> + >> + return; >> + } >> + >> + >> +#ifdef SNIC_DEBUG >> + scsi_print_result(sc); >> +#endif >> + >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + SNIC_SCSI_DBG(snic->shost, >> + "Icmnd_cmpl:lun %lld sc %p cmd %xtag %d flags 0x%llx rqi %p= \n", >> + sc->device->lun, sc, sc->cmnd[0], snic_cmd_tag(sc), >> + CMD_FLAGS(sc), rqi); >> + >> + SNIC_BUG_ON(rqi !=3D (struct snic_req_info *)ctx); >> + WARN_ON_ONCE(req); >> + if (!rqi) { >> + atomic64_inc(&snic->s_stats.io.req_null); >> + CMD_FLAGS(sc) |=3D SNIC_IO_REQ_NULL; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + SNIC_HOST_ERR(snic->shost, >> + "Icmnd_cmpl:Host Req Not Found(null), Hdr Status %s, Tag >>0x%x, sc 0x%p flags 0x%llx\n", >> + snic_io_status_to_str(hdr_stat), >> + cmnd_id, sc, CMD_FLAGS(sc)); >> + return; >> + } >> + >> + rqi =3D (struct snic_req_info *) ctx; >> + start_time =3D rqi->start_time; >> + >> + /* firmware completed the io */ >> + rqi->io_cmpl =3D 1; >> + >> + /* >> + * if SCSI-ML has already issued abort on this command, >> + * ignore completion of the IO. The abts path will clean it up >> + */ >> + if (unlikely(snic_tmreq_pending(sc))) { >> + snic_proc_tmreq_pending_state(snic, sc, hdr_stat); >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + snic_stats_update_io_cmpl(&snic->s_stats); >> + >> + /* Expected value is SNIC_STAT_ABORTED */ >> + if (likely(hdr_stat =3D=3D SNIC_STAT_ABORTED)) >> + return; >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "icmnd_cmpl:TM Req Pending(%s), Hdr Status %s sc 0x%p scsi >>status %x resid %d flags 0x%llx\n", >> + snic_ioreq_state_to_str(CMD_STATE(sc)), >> + snic_io_status_to_str(hdr_stat), >> + sc, sc_stat, icmnd_cmpl->resid, CMD_FLAGS(sc)); >> + >> + SNIC_TRC(snic->shost->host_no, cmnd_id, sc, >> + jiffies_to_msecs(jiffies - start_time), fwreq, >> + SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); >> + >> + return; >> + } >> + >> + if (snic_process_icmnd_cmpl_status(snic, icmnd_cmpl, hdr_stat, sc)= ) { >> +#ifdef SNIC_DEBUG >> + scsi_print_command(sc); >> +#endif >> + SNIC_HOST_ERR(snic->shost, >> + "icmnd_cmpl:IO Failed, sc 0x%p Tag %d Cmd %x Hdr Status %s >>flags 0x%llx\n", >> + sc, sc->cmnd[0], cmnd_id, >> + snic_io_status_to_str(hdr_stat), CMD_FLAGS(sc)); >> + } >> + >> + /* Break link with the SCSI Command */ >> + CMD_SP(sc) =3D NULL; >> + CMD_FLAGS(sc) |=3D SNIC_IO_DONE; >> + >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + /* For now, consider only successful IO. */ >> + snic_calc_io_process_time(snic, rqi); >> + >> + snic_release_req_buf(snic, rqi, sc); >> + >> + SNIC_TRC(snic->shost->host_no, cmnd_id, (u64)sc, >> + jiffies_to_msecs(jiffies - start_time), (u64)fwreq, >> + SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); >> + >> + >> + if (sc->scsi_done) >> + sc->scsi_done(sc); >> + >> + snic_stats_update_io_cmpl(&snic->s_stats); >> +} /* end of snic_icmnd_cmpl_handler */ >> + >> +static void >> +snic_proc_dr_cmpl_locked(struct snic *snic, >> + struct snic_fw_req *fwreq, >> + u8 cmpl_stat, >> + u32 cmnd_id, >> + struct scsi_cmnd *sc) >> +{ >> + struct snic_req_info *rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + u32 start_time =3D rqi->start_time; >> + >> + CMD_LR_STATUS(sc) =3D cmpl_stat; >> + >> + SNIC_SCSI_DBG(snic->shost, "itmf_cmpl: Cmd State =3D %s\n", >> + snic_ioreq_state_to_str(CMD_STATE(sc))); >> + >> + if (CMD_STATE(sc) =3D=3D SNIC_IOREQ_ABTS_PENDING) { >> + CMD_FLAGS(sc) |=3D SNIC_DEV_RST_ABTS_PENDING; >> + >> + SNIC_TRC(snic->shost->host_no, cmnd_id, sc, >> + jiffies_to_msecs(jiffies - start_time), >> + fwreq, 0, SNIC_TRC_CMD_STATE_FLAGS(sc)); >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "itmf_cmpl: Terminate Pending Dev Reset Cmpl Recvd.id %x, >>status %s flags 0x%llx\n", >> + (int)(cmnd_id & SNIC_TAG_MASK), >> + snic_io_status_to_str(cmpl_stat), >> + CMD_FLAGS(sc)); >> + >> + return; >> + } >> + >> + >> + if (CMD_FLAGS(sc) & SNIC_DEV_RST_TIMEDOUT) { >> + SNIC_TRC(snic->shost->host_no, cmnd_id, sc, >> + jiffies_to_msecs(jiffies - start_time), >> + fwreq, 0, SNIC_TRC_CMD_STATE_FLAGS(sc)); >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "itmf_cmpl:Dev Reset Completion Received after timeout. id= %d >>cmpl status %s flags 0x%llx\n", >> + (int)(cmnd_id & SNIC_TAG_MASK), >> + snic_io_status_to_str(cmpl_stat), >> + CMD_FLAGS(sc)); >> + >> + return; >> + } >> + >> + CMD_STATE(sc) =3D SNIC_IOREQ_LR_COMPLETE; >> + CMD_FLAGS(sc) |=3D SNIC_DEV_RST_DONE; >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "itmf_cmpl:Dev Reset Cmpl Recvd id %d cmpl status %s flags >>0x%llx\n", >> + (int)(cmnd_id & SNIC_TAG_MASK), >> + snic_io_status_to_str(cmpl_stat), >> + CMD_FLAGS(sc)); >> + >> + if (rqi->dr_done) >> + complete(rqi->dr_done); >> +} /* end of snic_proc_dr_cmpl_locked */ >> + >> +/* >> + * snic_update_abort_stats : Updates abort stats based on completio= n >>status. >> + */ >> +static void >> +snic_update_abort_stats(struct snic *snic, u8 cmpl_stat) >> +{ >> + struct snic_abort_stats *abt_stats =3D &snic->s_stats.abts; >> + >> + SNIC_SCSI_DBG(snic->shost, "Updating Abort stats.\n"); >> + >> + switch (cmpl_stat) { >> + case SNIC_STAT_IO_SUCCESS: >> + break; >> + >> + case SNIC_STAT_TIMEOUT: >> + atomic64_inc(&abt_stats->fw_tmo); >> + break; >> + >> + case SNIC_STAT_IO_NOT_FOUND: >> + atomic64_inc(&abt_stats->io_not_found); >> + break; >> + >> + default: >> + atomic64_inc(&abt_stats->fail); >> + break; >> + } >> +} >> + >> +static int >> +snic_process_itmf_cmpl(struct snic *snic, >> + struct snic_fw_req *fwreq, >> + u32 cmnd_id, >> + u8 cmpl_stat, >> + struct scsi_cmnd *sc) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + u32 tm_tags =3D 0; >> + spinlock_t *io_lock =3D NULL; >> + unsigned long flags; >> + u32 start_time =3D 0; >> + int ret =3D 0; >> + >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + WARN_ON_ONCE(!rqi); >> + >> + if (!rqi) { >> + atomic64_inc(&snic->s_stats.io.req_null); >> + spin_unlock_irqrestore(io_lock, flags); >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABTS_TERM_REQ_NULL; >> + SNIC_HOST_ERR(snic->shost, >> + "itmf_cmpl: rqi is null,Hdr stat =3D %s Tag =3D 0x%x sc =3D= 0x%p >>flags 0x%llx\n", >> + snic_io_status_to_str(cmpl_stat), cmnd_id, sc, >> + CMD_FLAGS(sc)); >> + >> + return ret; >> + } >> + >> + /* Extract task management flags */ >> + tm_tags =3D cmnd_id & ~(SNIC_TAG_MASK); >> + >> + start_time =3D rqi->start_time; >> + cmnd_id &=3D (SNIC_TAG_MASK); >> + >> + switch (tm_tags) { >> + case SNIC_TAG_ABORT: >> + /* Abort only issued on cmd */ >> + snic_update_abort_stats(snic, cmpl_stat); >> + >> + if (CMD_STATE(sc) !=3D SNIC_IOREQ_ABTS_PENDING) { >> + /* This is a late completion. Ignore it. */ >> + ret =3D -1; >> + spin_unlock_irqrestore(io_lock, flags); >> + break; >> + } >> + >> + CMD_STATE(sc) =3D SNIC_IOREQ_ABTS_COMPLETE; >> + CMD_ABTS_STATUS(sc) =3D cmpl_stat; >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABTS_TERM_DONE; >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "itmf_cmpl:Abort Cmpl Recvd.Tag 0x%x Status %s flags >>0x%llx\n", >> + cmnd_id, >> + snic_io_status_to_str(cmpl_stat), >> + CMD_FLAGS(sc)); >> + >> + /* >> + * If scsi_eh thread is blocked waiting for abts complete, >> + * signal completion to it. IO will be cleaned in the thread, >> + * else clean it in this context. >> + */ >> + if (rqi->abts_done) { >> + complete(rqi->abts_done); >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + break; /* jump out */ >> + } >> + >> + CMD_SP(sc) =3D NULL; >> + sc->result =3D (DID_ERROR << 16); >> + SNIC_SCSI_DBG(snic->shost, >> + "itmf_cmpl: Completing IO. sc %p flags 0x%llx\n", >> + sc, CMD_FLAGS(sc)); >> + >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + snic_release_req_buf(snic, rqi, sc); >> + >> + if (sc->scsi_done) { >> + SNIC_TRC(snic->shost->host_no, cmnd_id, sc, >> + jiffies_to_msecs(jiffies - start_time), >> + fwreq, >> + SNIC_TRC_CMD(sc), >> + SNIC_TRC_CMD_STATE_FLAGS(sc)); >> + >> + sc->scsi_done(sc); >> + } >> + >> + break; >> + >> + case SNIC_TAG_DEV_RST: >> + case SNIC_TAG_DEV_RST | SNIC_TAG_IOCTL_DEV_RST: >> + snic_proc_dr_cmpl_locked(snic, fwreq, cmpl_stat, cmnd_id, sc); >> + spin_unlock_irqrestore(io_lock, flags); >> + ret =3D 0; >> + >> + break; >> + >> + case SNIC_TAG_ABORT | SNIC_TAG_DEV_RST: >> + /* Abort and terminate completion of device reset req */ >> + >> + CMD_STATE(sc) =3D SNIC_IOREQ_ABTS_COMPLETE; >> + CMD_ABTS_STATUS(sc) =3D cmpl_stat; >> + CMD_FLAGS(sc) |=3D SNIC_DEV_RST_DONE; >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "itmf_cmpl:dev reset abts cmpl recvd. id %d status %s flag= s >>0x%llx\n", >> + cmnd_id, snic_io_status_to_str(cmpl_stat), >> + CMD_FLAGS(sc)); >> + >> + if (rqi->abts_done) >> + complete(rqi->abts_done); >> + >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + break; >> + >> + default: >> + spin_unlock_irqrestore(io_lock, flags); >> + SNIC_HOST_ERR(snic->shost, >> + "itmf_cmpl: Unknown TM tag bit 0x%x\n", tm_tags); >> + >> + SNIC_HOST_ERR(snic->shost, >> + "itmf_cmpl:Unexpected itmf io stat %s Tag =3D 0x%x flags >>0x%llx\n", >> + snic_ioreq_state_to_str(CMD_STATE(sc)), >> + cmnd_id, >> + CMD_FLAGS(sc)); >> + ret =3D -1; >> + SNIC_BUG_ON(1); >> + >> + break; >> + } >> + >> + return ret; >> +} /* end of snic_process_itmf_cmpl_status */ >> + >> +/* >> + * snic_itmf_cmpl_handler. >> + * Routine to handle itmf completions. >> + */ >> +static void >> +snic_itmf_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq= ) >> +{ >> + struct scsi_cmnd *sc =3D NULL; >> + struct snic_req_info *rqi =3D NULL; >> + struct snic_itmf_cmpl *itmf_cmpl =3D NULL; >> + u64 ctx; >> + u32 cmnd_id; >> + u32 hid; >> + u8 typ; >> + u8 hdr_stat; >> + >> + snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx= ); >> + SNIC_SCSI_DBG(snic->shost, >> + "Itmf_cmpl: %s: type =3D %x, hdr_stat =3D %x, cmnd_id =3D %= x, hid =3D >>%x,ctx =3D %llx\n", >> + __func__, typ, hdr_stat, cmnd_id, hid, ctx); >> + >> + itmf_cmpl =3D &fwreq->u.itmf_cmpl; >> + SNIC_SCSI_DBG(snic->shost, >> + "Itmf_cmpl: nterm %u , flags 0x%x\n", >> + itmf_cmpl->nterminated, itmf_cmpl->flags); >> + >> + /* spl case, dev reset issued through ioctl */ >> + if (cmnd_id & SNIC_TAG_IOCTL_DEV_RST) { >> + rqi =3D (struct snic_req_info *) ctx; >> + sc =3D rqi->sc; >> + >> + goto ioctl_dev_rst; >> + } >> + >> + if ((cmnd_id & SNIC_TAG_MASK) >=3D snic->max_tag_id) { >> + SNIC_HOST_ERR(snic->shost, >> + "Itmf_cmpl: Tag 0x%x out of Range,HdrStat %s\n", >> + cmnd_id, snic_io_status_to_str(hdr_stat)); >> + SNIC_BUG_ON(1); >> + >> + return; >> + } >> + >> + sc =3D scsi_host_find_tag(snic->shost, cmnd_id & SNIC_TAG_MASK); >> + WARN_ON_ONCE(!sc); >> + >> +ioctl_dev_rst: >> + if (!sc) { >> + atomic64_inc(&snic->s_stats.io.sc_null); >> + SNIC_HOST_ERR(snic->shost, >> + "Itmf_cmpl: sc is NULL - Hdr Stat %s Tag 0x%x\n", >> + snic_io_status_to_str(hdr_stat), cmnd_id); >> + >> + return; >> + } >> + >> + snic_process_itmf_cmpl(snic, fwreq, cmnd_id, hdr_stat, sc); >> +} /* end of snic_itmf_cmpl_handler */ >> + >> + >> + >> +static void >> +snic_hba_reset_scsi_cleanup(struct snic *snic, struct scsi_cmnd *sc= ) >> +{ >> + struct snic_stats *st =3D &snic->s_stats; >> + long act_ios =3D 0, act_fwreqs =3D 0; >> + >> + SNIC_SCSI_DBG(snic->shost, "HBA Reset scsi cleanup.\n"); >> + snic_scsi_cleanup(snic, snic_cmd_tag(sc)); >> + >> + /* Update stats on pending IOs */ >> + act_ios =3D atomic64_read(&st->io.active); >> + atomic64_add(act_ios, &st->io.compl); >> + atomic64_sub(act_ios, &st->io.active); >> + >> + act_fwreqs =3D atomic64_read(&st->fw.actv_reqs); >> + atomic64_sub(act_fwreqs, &st->fw.actv_reqs); >> +} >> + >> +/* >> + * snic_hba_reset_cmpl_handler : >> + * >> + * Notes : >> + * 1. Cleanup all the scsi cmds, release all snic specific cmds >> + * 2. Issue Report Targets in case of SAN targets >> + */ >> +static int >> +snic_hba_reset_cmpl_handler(struct snic *snic, struct snic_fw_req >>*fwreq) >> +{ >> + u64 ctx; >> + u32 cmnd_id; >> + u32 hid; >> + u8 typ; >> + u8 hdr_stat; >> + struct scsi_cmnd *sc =3D NULL; >> + struct snic_req_info *rqi =3D NULL; >> + spinlock_t *io_lock =3D NULL; >> + unsigned long flags, gflags; >> + int ret =3D 0; >> + >> + SNIC_HOST_INFO(snic->shost, >> + "reset_cmpl:HBA Reset Completion received.\n"); >> + >> + snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx= ); >> + SNIC_SCSI_DBG(snic->shost, >> + "reset_cmpl: type =3D %x, hdr_stat =3D %x, cmnd_id =3D %x, = hid =3D %x,=20 >>ctx =3D %llx\n", >> + typ, hdr_stat, cmnd_id, hid, ctx); >> + >> + /* spl case, host reset issued through ioctl */ >> + if (cmnd_id =3D=3D SCSI_NO_TAG) { >> + rqi =3D (struct snic_req_info *) ctx; >> + sc =3D rqi->sc; >> + >> + goto ioctl_hba_rst; >> + } >> + >> + if (cmnd_id >=3D snic->max_tag_id) { >> + SNIC_HOST_ERR(snic->shost, >> + "reset_cmpl: Tag 0x%x out of Range,HdrStat %s\n", >> + cmnd_id, snic_io_status_to_str(hdr_stat)); >> + SNIC_BUG_ON(1); >> + >> + return 1; >> + } >> + >> + sc =3D scsi_host_find_tag(snic->shost, cmnd_id); >> +ioctl_hba_rst: >> + if (!sc) { >> + atomic64_inc(&snic->s_stats.io.sc_null); >> + SNIC_HOST_ERR(snic->shost, >> + "reset_cmpl: sc is NULL - Hdr Stat %s Tag 0x%x\n", >> + snic_io_status_to_str(hdr_stat), cmnd_id); >> + ret =3D 1; >> + >> + return ret; >> + } >> + >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + spin_lock_irqsave(io_lock, flags); >> + >> + if (!snic->remove_wait) { >> + spin_unlock_irqrestore(io_lock, flags); >> + SNIC_HOST_ERR(snic->shost, >> + "reset_cmpl:host reset completed after timout\n"); >> + ret =3D 1; >> + >> + return ret; >> + } >> + >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + WARN_ON_ONCE(!rqi); >> + >> + if (!rqi) { >> + atomic64_inc(&snic->s_stats.io.req_null); >> + spin_unlock_irqrestore(io_lock, flags); >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABTS_TERM_REQ_NULL; >> + SNIC_HOST_ERR(snic->shost, >> + "reset_cmpl: rqi is null,Hdr stat %s Tag 0x%x sc 0x%p flag= s=20 >>0x%llx\n", >> + snic_io_status_to_str(hdr_stat), cmnd_id, sc, >> + CMD_FLAGS(sc)); >> + >> + ret =3D 1; >> + >> + return ret; >> + } >> + /* stats */ >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + /* scsi cleanup */ >> + snic_hba_reset_scsi_cleanup(snic, sc); >> + >> + SNIC_BUG_ON(snic_get_state(snic) !=3D SNIC_OFFLINE && >> + snic_get_state(snic) !=3D SNIC_FWRESET); >> + >> + /* Careful locking between snic_lock and io lock */ >> + spin_lock_irqsave(io_lock, flags); >> + spin_lock_irqsave(&snic->snic_lock, gflags); >> + if (snic_get_state(snic) =3D=3D SNIC_FWRESET) >> + snic_set_state(snic, SNIC_ONLINE); >> + spin_unlock_irqrestore(&snic->snic_lock, gflags); >> + >> + if (snic->remove_wait) >> + complete(snic->remove_wait); >> + >> + spin_unlock_irqrestore(io_lock, flags); >> + atomic64_inc(&snic->s_stats.reset.hba_reset_cmpl); >> + >> + ret =3D 0; >> + /* Rediscovery is for SAN */ >> + if (snic->config.xpt_type =3D=3D SNIC_DAS) >> + return ret; >> + >> + SNIC_SCSI_DBG(snic->shost, "reset_cmpl: Queuing discovery work.\n"= ); >> + queue_work(snic_glob->event_q, &snic->disc_work); >> + >> + return ret; >> +} >So the hba reset relies on the firmware to process the queues? >Hmm. But if the firmware is hosed it wouldn't process commands, right? >I would have really, _really_, designed an out-of-band mechanism >for doing an HBA reset. >Having the HBA reset to rely on functionality which only is establishe= d >during startup is ... dangerous, to say the least. >We've been through this with the various RAID controller. >Eventually everyone of them implemented an out-of-band firmware reset.= =2E. We will use the out-of-band mechanism in a future-patch > >> + >> +static void >> +snic_msg_ack_handler(struct snic *snic, struct snic_fw_req *fwreq) >> +{ >> + SNIC_HOST_INFO(snic->shost, "Message Ack Received.\n"); >> + >> + SNIC_ASSERT_NOT_IMPL(1); >> +} >> + >> +static void >> +snic_aen_handler(struct snic *snic, struct snic_fw_req *fwreq) >> +{ >> + u8 typ, hdr_stat; >> + u32 cmnd_id, hid; >> + u64 ctx; >> + struct snic_async_evnotify *aen =3D &fwreq->u.async_ev; >> + >> + snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx= ); >> + SNIC_SCSI_DBG(snic->shost, >> + "aen: type =3D %x, hdr_stat =3D %x, cmnd_id =3D %x, hid =3D= %x, ctx =3D=20 >>%llx\n", >> + typ, hdr_stat, cmnd_id, hid, ctx); >> + >> + switch (aen->ev_id) { >> + case SNIC_EV_TGT_OFFLINE: >> + SNIC_HOST_INFO(snic->shost, "aen:TGT_OFFLINE Event Recvd.\n"); >> + break; >> + >> + case SNIC_EV_TGT_ONLINE: >> + SNIC_HOST_INFO(snic->shost, "aen:TGT_ONLINE Event Recvd.\n"); >> + break; >> + >> + case SNIC_EV_LUN_OFFLINE: >> + SNIC_HOST_INFO(snic->shost, "aen:LUN_OFFLINE Event Recvd.\n"); >> + break; >> + >> + case SNIC_EV_LUN_ONLINE: >> + SNIC_HOST_INFO(snic->shost, "aen:LUN_ONLINE Event Recvd.\n"); >> + break; >> + >> + case SNIC_EV_CONF_CHG: >> + SNIC_HOST_INFO(snic->shost, "aen:Config Change Event Recvd.\n"); >> + break; >> + >> + case SNIC_EV_TGT_ADDED: >> + SNIC_HOST_INFO(snic->shost, "aen:TGT_ADD Event Recvd.\n"); >> + break; >> + >> + case SNIC_EV_TGT_DELTD: >> + SNIC_HOST_INFO(snic->shost, "aen:TGT_DEL Event Recvd.\n"); >> + break; >> + >> + case SNIC_EV_LUN_ADDED: >> + SNIC_HOST_INFO(snic->shost, "aen:LUN_ADD Event Recvd.\n"); >> + break; >> + >> + case SNIC_EV_LUN_DELTD: >> + SNIC_HOST_INFO(snic->shost, "aen:LUN_DEL Event Recvd.\n"); >> + break; >> + >> + case SNIC_EV_DISC_CMPL: >> + SNIC_HOST_INFO(snic->shost, "aen:DISC_CMPL Event Recvd.\n"); >> + break; >> + >> + default: >> + SNIC_HOST_INFO(snic->shost, "aen:Unknown Event Recvd.\n"); >> + SNIC_BUG_ON(1); >> + break; >> + } >> + >> + SNIC_ASSERT_NOT_IMPL(1); >> +} /* end of snic_aen_handler */ >> + >> +/* >> + * snic_io_cmpl_handler >> + * Routine to process CQ entries(IO Completions) posted by fw. >> + */ >> +static int >> +snic_io_cmpl_handler(struct vnic_dev *vdev, >> + unsigned int cq_idx, >> + struct snic_fw_req *fwreq) >> +{ >> + struct snic *snic =3D vnic_dev_priv(vdev); >> + u64 start =3D jiffies, cmpl_time; >> + >> + snic_print_desc(__func__, (char *)fwreq, sizeof(*fwreq)); >> + >> + /* Update FW Stats */ >> + if ((fwreq->hdr.type >=3D SNIC_RSP_REPORT_TGTS_CMPL) && >> + (fwreq->hdr.type <=3D SNIC_RSP_BOOT_LUNS_CMPL)) >> + atomic64_dec(&snic->s_stats.fw.actv_reqs); >> + >> + SNIC_BUG_ON((fwreq->hdr.type > SNIC_RSP_BOOT_LUNS_CMPL) && >> + (fwreq->hdr.type < SNIC_MSG_ASYNC_EVNOTIFY)); >> + >> + /* Check for snic subsys errors */ >> + switch (fwreq->hdr.status) { >> + case SNIC_STAT_NOT_READY: /* XPT yet to initialize */ >> + SNIC_HOST_ERR(snic->shost, >> + "sNIC SubSystem is NOT Ready.\n"); >> + break; >> + >> + case SNIC_STAT_FATAL_ERROR: /* XPT Error */ >> + SNIC_HOST_ERR(snic->shost, >> + "sNIC SubSystem in Unrecoverable State.\n"); >> + break; >> + } >> + >> + switch (fwreq->hdr.type) { >> + case SNIC_RSP_EXCH_VER_CMPL: >> + snic_io_exch_ver_cmpl_handler(snic, fwreq); >> + break; >> + >> + case SNIC_RSP_REPORT_TGTS_CMPL: >> + snic_report_tgt_cmpl_handler(snic, fwreq); >> + break; >> + >> + case SNIC_RSP_ICMND_CMPL: >> + snic_icmnd_cmpl_handler(snic, fwreq); >> + break; >> + >> + case SNIC_RSP_ITMF_CMPL: >> + snic_itmf_cmpl_handler(snic, fwreq); >> + break; >> + >> + case SNIC_RSP_HBA_RESET_CMPL: >> + snic_hba_reset_cmpl_handler(snic, fwreq); >> + break; >> + >> + case SNIC_MSG_ACK: >> + snic_msg_ack_handler(snic, fwreq); >> + break; >> + >> + case SNIC_MSG_ASYNC_EVNOTIFY: >> + snic_aen_handler(snic, fwreq); >> + break; >> + >> + default: >> + SNIC_BUG_ON(1); >> + SNIC_SCSI_DBG(snic->shost, >> + "Unknown Firmwqre completion request type %d\n", >> + fwreq->hdr.type); >> + break; >> + } >> + >> + /* Update Stats */ >> + cmpl_time =3D jiffies - start; >> + if (cmpl_time > atomic64_read(&snic->s_stats.io.max_cmpl_time)) >> + atomic64_set(&snic->s_stats.io.max_cmpl_time, cmpl_time); >> + >> + return 0; >> +} /* end of snic_io_cmpl_handler */ >> + >> +/* >> + * snic_fwcq_cmpl_handler >> + * Routine to process fwCQ >> + * This CQ is independent, and not associated with wq/rq/wq_copy qu= eues >> + */ >> +int >> +snic_fwcq_cmpl_handler(struct snic *snic, int io_cmpl_work) >> +{ >> + unsigned int num_ent =3D 0; /* number cq entries processed */ >> + unsigned int cq_idx; >> + unsigned int nent_per_cq; >> + struct snic_misc_stats *misc_stats =3D &snic->s_stats.misc; >> + >> + for (cq_idx =3D snic->wq_count; cq_idx < snic->cq_count; cq_idx++)= { >> + nent_per_cq =3D vnic_cq_fw_service(&snic->cq[cq_idx], >> + snic_io_cmpl_handler, >> + io_cmpl_work); >> + num_ent +=3D nent_per_cq; >> + >> + if (nent_per_cq > atomic64_read(&misc_stats->max_cq_ents)) >> + atomic64_set(&misc_stats->max_cq_ents, nent_per_cq); >> + } >> + >> + return num_ent; >> +} /* end of snic_fwcq_cmpl_handler */ >> + >> +/* >> + * snic_queue_itmf_req: Common API to queue Task Management request= s. >> + * Use rqi->tm_tag for passing special tags. >> + * @req_id : aborted request's tag, -1 for lun reset. >> + */ >> +static int >> +snic_queue_itmf_req(struct snic *snic, >> + struct snic_host_req *tmreq, >> + struct scsi_cmnd *sc, >> + u32 tmf, >> + u32 req_id) >> +{ >> + struct snic_req_info *rqi =3D req_to_rqi(tmreq); >> + struct scsi_lun lun; >> + int tm_tag =3D snic_cmd_tag(sc) | rqi->tm_tag; >> + int ret =3D 0; >> + >> + SNIC_BUG_ON(!rqi); >> + SNIC_BUG_ON(!rqi->tm_tag); >> + >> + /* fill in lun info */ >> + int_to_scsilun(sc->device->lun, &lun); >> + >> + /* Initialize snic_host_req: itmf */ >> + snic_itmf_init(tmreq, >> + tm_tag, >> + snic->config.hid, >> + (u64) rqi, >> + 0 /* flags */, >> + req_id, /* Command to be aborted. */ >> + rqi->tgt_id, >> + lun.scsi_lun, >> + tmf); >> + >> + /* >> + * In case of multiple aborts on same cmd, >> + * use try_wait_for_completion and completion_done() to check >> + * whether it queues aborts even after completion of abort issued >> + * prior.SNIC_BUG_ON(completion_done(&rqi->done)); >> + */ >> + >> + ret =3D snic_queue_wq_desc(snic, tmreq, sizeof(*tmreq)); >> + if (ret) >> + SNIC_HOST_ERR(snic->shost, >> + "qitmf:Queuing ITMF(%d) Req sc %p, rqi %p, req_id %d tag %= d=20 >>Failed, ret =3D %d\n", >> + tmf, sc, rqi, req_id, snic_cmd_tag(sc), ret); >> + else >> + SNIC_SCSI_DBG(snic->shost, >> + "qitmf:Queuing ITMF(%d) Req sc %p, rqi %p, req_id %d, tag = %d=20 >>(req_id)- Success.", >> + tmf, sc, rqi, req_id, snic_cmd_tag(sc)); >> + >> + return ret; >> +} /* end of snic_queue_itmf_req */ >> + >> +static int >> +snic_issue_tm_req(struct snic *snic, >> + struct snic_req_info *rqi, >> + struct scsi_cmnd *sc, >> + int tmf) >> +{ >> + struct snic_host_req *tmreq =3D NULL; >> + int req_id =3D 0, tag =3D snic_cmd_tag(sc); >> + int ret =3D 0; >> + >> + if (snic_get_state(snic) =3D=3D SNIC_FWRESET) >> + return -EBUSY; >> + >> + atomic_inc(&snic->ios_inflight); >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "issu_tmreq: Task mgmt req %d. rqi %p w/ tag %x\n", >> + tmf, rqi, tag); >> + >> + >> + if (tmf =3D=3D SNIC_ITMF_LUN_RESET) { >> + tmreq =3D snic_dr_req_init(snic, rqi); >> + req_id =3D SCSI_NO_TAG; >> + } else { >> + tmreq =3D snic_abort_req_init(snic, rqi); >> + req_id =3D tag; >> + } >> + >> + if (!tmreq) { >> + ret =3D -ENOMEM; >> + >> + goto tmreq_err; >> + } >> + >> + ret =3D snic_queue_itmf_req(snic, tmreq, sc, tmf, req_id); >> + if (ret) >> + goto tmreq_err; >> + >> + ret =3D 0; >> + >> +tmreq_err: >> + if (ret) { >> + SNIC_HOST_ERR(snic->shost, >> + "issu_tmreq: Queing ITMF(%d) Req, sc %p rqi %p req_id %d t= ag=20 >>%x fails err =3D %d\n", >> + tmf, sc, rqi, req_id, tag, ret); >> + } else { >> + SNIC_SCSI_DBG(snic->shost, >> + "issu_tmreq: Queuing ITMF(%d) Req, sc %p, rqi %p, req_id %= d=20 >>tag %x - Success.\n", >> + tmf, sc, rqi, req_id, tag); >> + } >> + >> + atomic_dec(&snic->ios_inflight); >> + >> + return ret; >> +} >> + >> +/* >> + * snic_queue_abort_req : Queues abort req to WQ >> + */ >> +static int >> +snic_queue_abort_req(struct snic *snic, >> + struct snic_req_info *rqi, >> + struct scsi_cmnd *sc, >> + int tmf) >> +{ >> + SNIC_SCSI_DBG(snic->shost, "q_abtreq: sc %p, rqi %p, tag %x, tmf=20 >>%d\n", >> + sc, rqi, snic_cmd_tag(sc), tmf); >> + >> + /* Add special tag for abort */ >> + rqi->tm_tag |=3D SNIC_TAG_ABORT; >> + >> + return snic_issue_tm_req(snic, rqi, sc, tmf); >> +} >> + >> +/* >> + * snic_abort_finish : called by snic_abort_cmd on queuing abort=20 >>successfully. >> + */ >> +static int >> +snic_abort_finish(struct snic *snic, struct scsi_cmnd *sc) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + spinlock_t *io_lock =3D NULL; >> + unsigned long flags; >> + int ret =3D 0, tag =3D snic_cmd_tag(sc); >> + >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (!rqi) { >> + atomic64_inc(&snic->s_stats.io.req_null); >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABTS_TERM_REQ_NULL; >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "abt_fini:req info is null tag 0x%x, sc 0x%p flags 0x%llx\= n", >> + tag, sc, CMD_FLAGS(sc)); >> + ret =3D FAILED; >> + >> + goto abort_fail; >> + } >> + >> + rqi->abts_done =3D NULL; >> + >> + ret =3D FAILED; >> + >> + /* Check the abort status. */ >> + switch (CMD_ABTS_STATUS(sc)) { >> + case SNIC_INVALID_CODE: >> + /* Firmware didn't complete abort req, timedout */ >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABTS_TIMEDOUT; >> + atomic64_inc(&snic->s_stats.abts.drv_tmo); >> + SNIC_SCSI_DBG(snic->shost, >> + "abt_fini:sc %p Tag %x Driver Timeout.flags 0x%llx\n", >> + sc, snic_cmd_tag(sc), CMD_FLAGS(sc)); >> + /* do not release snic request in timedout case */ >> + rqi =3D NULL; >> + >> + goto abort_fail; >> + >> + case SNIC_STAT_IO_SUCCESS: >> + case SNIC_STAT_IO_NOT_FOUND: >> + ret =3D SUCCESS; >> + break; >> + >> + default: >> + /* Firmware completed abort with error */ >> + ret =3D FAILED; >> + break; >> + } >> + >> + CMD_SP(sc) =3D NULL; >> + SNIC_HOST_INFO(snic->shost, >> + "abt_fini: Tag %x, Cmpl Status %s flags 0x%llx\n", >> + tag, snic_io_status_to_str(CMD_ABTS_STATUS(sc)), >> + CMD_FLAGS(sc)); >> + >> +abort_fail: >> + spin_unlock_irqrestore(io_lock, flags); >> + if (rqi) >> + snic_release_req_buf(snic, rqi, sc); >> + >> + return ret; >> +} /* end of snic_abort_finish */ >> + >> +/* >> + * snic_send_abort_and_wait : Issues Abort, and Waits >> + */ >> +static int >> +snic_send_abort_and_wait(struct snic *snic, struct scsi_cmnd *sc) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + enum snic_ioreq_state sv_state; >> + struct snic_tgt *tgt =3D NULL; >> + spinlock_t *io_lock =3D NULL; >> + DECLARE_COMPLETION_ONSTACK(tm_done); >> + unsigned long flags; >> + int ret =3D 0, tmf =3D 0, tag =3D snic_cmd_tag(sc); >> + >> + tgt =3D starget_to_tgt(scsi_target(sc->device)); >> + if ((snic_tgt_chkready(tgt) !=3D 0) && (tgt->tdata.typ =3D=3D SNIC= _TGT_SAN)) >> + tmf =3D SNIC_ITMF_ABTS_TASK_TERM; >> + else >> + tmf =3D SNIC_ITMF_ABTS_TASK; >> + >> + /* stats */ >> + >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + >> + /* >> + * Avoid a race between SCSI issuing the abort and the device >> + * completing the command. >> + * >> + * If the command is already completed by fw_cmpl code, >> + * we just return SUCCESS from here. This means that the abort >> + * succeeded. In the SCSI ML, since the timeout for command has >> + * happend, the completion wont actually complete the command >> + * and it will be considered as an aborted command >> + * >> + * The CMD_SP will not be cleared except while holding io_lock >> + */ >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (!rqi) { >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + SNIC_HOST_ERR(snic->shost, >> + "abt_cmd: rqi is null. Tag %d flags 0x%llx\n", >> + tag, CMD_FLAGS(sc)); >> + >> + ret =3D SUCCESS; >> + >> + goto send_abts_end; >> + } >> + >> + rqi->abts_done =3D &tm_done; >> + if (CMD_STATE(sc) =3D=3D SNIC_IOREQ_ABTS_PENDING) { >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + ret =3D 0; >> + goto abts_pending; >> + } >> + SNIC_BUG_ON(!rqi->abts_done); >> + >> + /* Save Command State, should be restored on failed to Queue. */ >> + sv_state =3D CMD_STATE(sc); >> + >> + /* >> + * Command is still pending, need to abort it >> + * If the fw completes the command after this point, >> + * the completion won't be done till mid-layer, since abot >> + * has already started. >> + */ >> + CMD_STATE(sc) =3D SNIC_IOREQ_ABTS_PENDING; >> + CMD_ABTS_STATUS(sc) =3D SNIC_INVALID_CODE; >> + >> + SNIC_SCSI_DBG(snic->shost, "send_abt_cmd: TAG 0x%x\n", tag); >> + >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + /* Now Queue the abort command to firmware */ >> + ret =3D snic_queue_abort_req(snic, rqi, sc, tmf); >> + if (ret) { >> + SNIC_HOST_ERR(snic->shost, >> + "send_abt_cmd: IO w/ Tag 0x%x fail w/ err %d flags 0x%llx\= n", >> + tag, ret, CMD_FLAGS(sc)); >> + >> + spin_lock_irqsave(io_lock, flags); >> + /* Restore Command's previous state */ >> + CMD_STATE(sc) =3D sv_state; >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (rqi) >> + rqi->abts_done =3D NULL; >> + spin_unlock_irqrestore(io_lock, flags); >> + ret =3D FAILED; >> + >> + goto send_abts_end; >> + } >> + >> + spin_lock_irqsave(io_lock, flags); >> + if (tmf =3D=3D SNIC_ITMF_ABTS_TASK) { >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABTS_ISSUED; >> + atomic64_inc(&snic->s_stats.abts.num); >> + } else { >> + /* term stats */ >> + CMD_FLAGS(sc) |=3D SNIC_IO_TERM_ISSUED; >> + } >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "send_abt_cmd: sc %p Tag %x flags 0x%llx\n", >> + sc, tag, CMD_FLAGS(sc)); >> + >> + >> + ret =3D 0; >> + >> +abts_pending: >> + /* >> + * Queued an abort IO, wait for its completion. >> + * Once the fw completes the abort command, it will >> + * wakeup this thread. >> + */ >> + wait_for_completion_timeout(&tm_done, SNIC_ABTS_TIMEOUT); >> + >> +send_abts_end: >> + return ret; >> +} /* end of snic_send_abort_and_wait */ >> + >> +/* >> + * This function is exported to SCSI for sending abort cmnds. >> + * A SCSI IO is represent by snic_ioreq in the driver. >> + * The snic_ioreq is linked to the SCSI Cmd, thus a link with the=20 >>ULP'S IO >> + */ >> +int >> +snic_abort_cmd(struct scsi_cmnd *sc) >> +{ >> + struct snic *snic =3D shost_priv(sc->device->host); >> + int ret =3D SUCCESS, tag =3D snic_cmd_tag(sc); >> + u32 start_time =3D jiffies; >> + >> + SNIC_SCSI_DBG(snic->shost, "abt_cmd:sc %p :0x%x :req =3D %p :tag =3D= =20 >>%d\n", >> + sc, sc->cmnd[0], sc->request, tag); >> + >> + if (unlikely(snic_get_state(snic) !=3D SNIC_ONLINE)) { >> + SNIC_HOST_ERR(snic->shost, >> + "abt_cmd: tag %x Parent Devs are not rdy\n", >> + tag); >> + ret =3D FAST_IO_FAIL; >> + >> + goto abort_end; >> + } >> + >> + >> + ret =3D snic_send_abort_and_wait(snic, sc); >> + if (ret) >> + goto abort_end; >> + >> + ret =3D snic_abort_finish(snic, sc); >> + >> +abort_end: >> + SNIC_TRC(snic->shost->host_no, tag, sc, >> + jiffies_to_msecs(jiffies - start_time), 0, >> + SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "abts: Abort Req Status =3D %s\n", >> + (ret =3D=3D SUCCESS) ? "SUCCESS" : >> + ((ret =3D=3D FAST_IO_FAIL) ? "FAST_IO_FAIL" : "FAILED")); >> + >> + return ret; >> +} >> + >> + >> + >> +static int >> +snic_is_abts_pending(struct snic *snic, struct scsi_cmnd *lr_sc) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + struct scsi_cmnd *sc =3D NULL; >> + struct scsi_device *lr_sdev =3D NULL; >> + spinlock_t *io_lock =3D NULL; >> + u32 tag; >> + unsigned long flags; >> + >> + if (lr_sc) >> + lr_sdev =3D lr_sc->device; >> + >> + /* walk through the tag map, an dcheck if IOs are still pending in= =20 >>fw*/ >> + for (tag =3D 0; tag < snic->max_tag_id; tag++) { >> + io_lock =3D snic_io_lock_tag(snic, tag); >> + >> + spin_lock_irqsave(io_lock, flags); >> + sc =3D scsi_host_find_tag(snic->shost, tag); >> + >> + if (!sc || (lr_sc && (sc->device !=3D lr_sdev || sc =3D=3D lr_sc)= )) { >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + continue; >> + } >> + >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (!rqi) { >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + continue; >> + } >> + >> + /* >> + * Found IO that is still pending w/ firmware and belongs to >> + * the LUN that is under reset, if lr_sc !=3D NULL >> + */ >> + SNIC_SCSI_DBG(snic->shost, "Found IO in %s on LUN\n", >> + snic_ioreq_state_to_str(CMD_STATE(sc))); >> + >> + if (CMD_STATE(sc) =3D=3D SNIC_IOREQ_ABTS_PENDING) { >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + return 1; >> + } >> + >> + spin_unlock_irqrestore(io_lock, flags); >> + } >> + >> + return 0; >> +} /* end of snic_is_abts_pending */ >> + >> +static int >> +snic_dr_clean_single_req(struct snic *snic, >> + u32 tag, >> + struct scsi_device *lr_sdev) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + struct snic_tgt *tgt =3D NULL; >> + struct scsi_cmnd *sc =3D NULL; >> + spinlock_t *io_lock =3D NULL; >> + u32 sv_state =3D 0, tmf =3D 0; >> + DECLARE_COMPLETION_ONSTACK(tm_done); >> + unsigned long flags; >> + int ret =3D 0; >> + >> + io_lock =3D snic_io_lock_tag(snic, tag); >> + spin_lock_irqsave(io_lock, flags); >> + sc =3D scsi_host_find_tag(snic->shost, tag); >> + >> + /* Ignore Cmd that don't belong to Lun Reset device */ >> + if (!sc || sc->device !=3D lr_sdev) >> + goto skip_clean; >> + >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + >> + if (!rqi) >> + goto skip_clean; >> + >> + >> + if (CMD_STATE(sc) =3D=3D SNIC_IOREQ_ABTS_PENDING) >> + goto skip_clean; >> + >> + >> + if ((CMD_FLAGS(sc) & SNIC_DEVICE_RESET) && >> + (!(CMD_FLAGS(sc) & SNIC_DEV_RST_ISSUED))) { >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "clean_single_req: devrst is not pending sc 0x%p\n", >> + sc); >> + >> + goto skip_clean; >> + } >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "clean_single_req: Found IO in %s on lun\n", >> + snic_ioreq_state_to_str(CMD_STATE(sc))); >> + >> + /* Save Command State */ >> + sv_state =3D CMD_STATE(sc); >> + >> + /* >> + * Any pending IO issued prior to reset is expected to be >> + * in abts pending state, if not we need to set=20 >>SNIC_IOREQ_ABTS_PENDING >> + * to indicate the IO is abort pending. >> + * When IO is completed, the IO will be handed over and handled >> + * in this function. >> + */ >> + >> + CMD_STATE(sc) =3D SNIC_IOREQ_ABTS_PENDING; >> + SNIC_BUG_ON(rqi->abts_done); >> + >> + if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) { >> + rqi->tm_tag =3D SNIC_TAG_DEV_RST; >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "clean_single_req:devrst sc 0x%p\n", sc); >> + } >> + >> + CMD_ABTS_STATUS(sc) =3D SNIC_INVALID_CODE; >> + rqi->abts_done =3D &tm_done; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + tgt =3D starget_to_tgt(scsi_target(sc->device)); >> + if ((snic_tgt_chkready(tgt) !=3D 0) && (tgt->tdata.typ =3D=3D SNIC= _TGT_SAN)) >> + tmf =3D SNIC_ITMF_ABTS_TASK_TERM; >> + else >> + tmf =3D SNIC_ITMF_ABTS_TASK; >> + >> + /* Now queue the abort command to firmware */ >> + ret =3D snic_queue_abort_req(snic, rqi, sc, tmf); >> + if (ret) { >> + SNIC_HOST_ERR(snic->shost, >> + "clean_single_req_err:sc %p, tag %d abt failed. tm_tag %d=20 >>flags 0x%llx\n", >> + sc, tag, rqi->tm_tag, CMD_FLAGS(sc)); >> + >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (rqi) >> + rqi->abts_done =3D NULL; >> + >> + /* Restore Command State */ >> + if (CMD_STATE(sc) =3D=3D SNIC_IOREQ_ABTS_PENDING) >> + CMD_STATE(sc) =3D sv_state; >> + >> + ret =3D 1; >> + goto skip_clean; >> + } >> + >> + spin_lock_irqsave(io_lock, flags); >> + if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) >> + CMD_FLAGS(sc) |=3D SNIC_DEV_RST_TERM_ISSUED; >> + >> + CMD_FLAGS(sc) |=3D SNIC_IO_INTERNAL_TERM_ISSUED; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + wait_for_completion_timeout(&tm_done, SNIC_ABTS_TIMEOUT); >> + >> + /* Recheck cmd state to check if it now aborted. */ >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (!rqi) { >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABTS_TERM_REQ_NULL; >> + goto skip_clean; >> + } >> + rqi->abts_done =3D NULL; >> + >> + /* if abort is still pending w/ fw, fail */ >> + if (CMD_ABTS_STATUS(sc) =3D=3D SNIC_INVALID_CODE) { >> + SNIC_HOST_ERR(snic->shost, >> + "clean_single_req_err:sc %p tag %d abt still pending w/ fw= ,=20 >>tm_tag %d flags 0x%llx\n", >> + sc, tag, rqi->tm_tag, CMD_FLAGS(sc)); >> + >> + CMD_FLAGS(sc) |=3D SNIC_IO_ABTS_TERM_DONE; >> + ret =3D 1; >> + >> + goto skip_clean; >> + } >> + >> + CMD_STATE(sc) =3D SNIC_IOREQ_ABTS_COMPLETE; >> + CMD_SP(sc) =3D NULL; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + snic_release_req_buf(snic, rqi, sc); >> + >> + ret =3D 0; >> + >> + return ret; >> + >> +skip_clean: >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + return ret; >> +} /* end of snic_dr_clean_single_req */ >> + >> +static int >> +snic_dr_clean_pending_req(struct snic *snic, struct scsi_cmnd *lr_s= c) >> +{ >> + struct scsi_device *lr_sdev =3D lr_sc->device; >> + u32 tag =3D 0; >> + int ret =3D FAILED; >> + >> + for (tag =3D 0; tag < snic->max_tag_id; tag++) { >> + if (tag =3D=3D snic_cmd_tag(lr_sc)) >> + continue; >> + >> + ret =3D snic_dr_clean_single_req(snic, tag, lr_sdev); >> + if (ret) { >> + SNIC_HOST_ERR(snic->shost, "clean_err:tag =3D %d\n", tag); >> + >> + goto clean_err; >> + } >> + } >> + >> + schedule_timeout(msecs_to_jiffies(100)); >> + >> + /* Walk through all the cmds and check abts status. */ >> + if (snic_is_abts_pending(snic, lr_sc)) { >> + ret =3D FAILED; >> + >> + goto clean_err; >> + } >> + >> + ret =3D 0; >> + SNIC_SCSI_DBG(snic->shost, "clean_pending_req: Success.\n"); >> + >> + return ret; >> + >> +clean_err: >> + ret =3D FAILED; >> + SNIC_HOST_ERR(snic->shost, >> + "Failed to Clean Pending IOs on %s device.\n", >> + dev_name(&lr_sdev->sdev_gendev)); >> + >> + return ret; >> + >> +} /* end of snic_dr_clean_pending_req */ >> + >> +/* >> + * snic_dr_finish : Called by snic_device_reset >> + */ >> +static int >> +snic_dr_finish(struct snic *snic, struct scsi_cmnd *sc) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + spinlock_t *io_lock =3D NULL; >> + unsigned long flags; >> + int lr_res =3D 0; >> + int ret =3D FAILED; >> + >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (!rqi) { >> + spin_unlock_irqrestore(io_lock, flags); >> + SNIC_SCSI_DBG(snic->shost, >> + "dr_fini: rqi is null tag 0x%x sc 0x%p flags 0x%llx\n", >> + snic_cmd_tag(sc), sc, CMD_FLAGS(sc)); >> + >> + ret =3D FAILED; >> + goto dr_fini_end; >> + } >> + >> + rqi->dr_done =3D NULL; >> + >> + lr_res =3D CMD_LR_STATUS(sc); >> + >> + switch (lr_res) { >> + case SNIC_INVALID_CODE: >> + /* stats */ >> + SNIC_SCSI_DBG(snic->shost, >> + "dr_fini: Tag %x Dev Reset Timedout. flags 0x%llx\n", >> + snic_cmd_tag(sc), CMD_FLAGS(sc)); >> + >> + CMD_FLAGS(sc) |=3D SNIC_DEV_RST_TIMEDOUT; >> + ret =3D FAILED; >> + >> + goto dr_failed; >> + >> + case SNIC_STAT_IO_SUCCESS: >> + SNIC_SCSI_DBG(snic->shost, >> + "dr_fini: Tag %x Dev Reset cmpl\n", >> + snic_cmd_tag(sc)); >> + ret =3D 0; >> + break; >> + >> + default: >> + SNIC_HOST_ERR(snic->shost, >> + "dr_fini:Device Reset completed& failed.Tag =3D %x lr_stat= us %s=20 >>flags 0x%llx\n", >> + snic_cmd_tag(sc), >> + snic_io_status_to_str(lr_res), CMD_FLAGS(sc)); >> + ret =3D FAILED; >> + goto dr_failed; >> + } >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + /* >> + * Cleanup any IOs on this LUN that have still not completed. >> + * If any of these fail, then LUN Reset fails. >> + * Cleanup cleans all commands on this LUN except >> + * the lun reset command. If all cmds get cleaned, the LUN Reset >> + * succeeds. >> + */ >> + >> + ret =3D snic_dr_clean_pending_req(snic, sc); >> + if (ret) { >> + spin_lock_irqsave(io_lock, flags); >> + SNIC_SCSI_DBG(snic->shost, >> + "dr_fini: Device Reset Failed since could not abort all IO= s.=20 >>Tag =3D %x.\n", >> + snic_cmd_tag(sc)); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + >> + goto dr_failed; >> + } else { >> + /* Cleanup LUN Reset Command */ >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (rqi) >> + ret =3D SUCCESS; /* Completed Successfully */ >> + else >> + ret =3D FAILED; >> + } >> + >> +dr_failed: >> + SNIC_BUG_ON(!spin_is_locked(io_lock)); >> + if (rqi) >> + CMD_SP(sc) =3D NULL; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + if (rqi) >> + snic_release_req_buf(snic, rqi, sc); >> + >> +dr_fini_end: >> + return ret; >> +} /* end of snic_dr_finish */ >> + >> +static int >> +snic_queue_dr_req(struct snic *snic, >> + struct snic_req_info *rqi, >> + struct scsi_cmnd *sc) >> +{ >> + /* Add special tag for device reset */ >> + rqi->tm_tag |=3D SNIC_TAG_DEV_RST; >> + >> + return snic_issue_tm_req(snic, rqi, sc, SNIC_ITMF_LUN_RESET); >> +} >> + >> +static int >> +snic_send_dr_and_wait(struct snic *snic, struct scsi_cmnd *sc) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + enum snic_ioreq_state sv_state; >> + spinlock_t *io_lock =3D NULL; >> + unsigned long flags; >> + DECLARE_COMPLETION_ONSTACK(tm_done); >> + int ret =3D FAILED, tag =3D snic_cmd_tag(sc); >> + >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + spin_lock_irqsave(io_lock, flags); >> + CMD_FLAGS(sc) |=3D SNIC_DEVICE_RESET; >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (!rqi) { >> + SNIC_HOST_ERR(snic->shost, >> + "send_dr: rqi is null, Tag 0x%x flags 0x%llx\n", >> + tag, CMD_FLAGS(sc)); >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + ret =3D FAILED; >> + goto send_dr_end; >> + } >> + >> + /* Save Command state to restore in case Queuing failed. */ >> + sv_state =3D CMD_STATE(sc); >> + >> + CMD_STATE(sc) =3D SNIC_IOREQ_LR_PENDING; >> + CMD_LR_STATUS(sc) =3D SNIC_INVALID_CODE; >> + >> + SNIC_SCSI_DBG(snic->shost, "dr: TAG =3D %x\n", tag); >> + >> + rqi->dr_done =3D &tm_done; >> + SNIC_BUG_ON(!rqi->dr_done); >> + >> + spin_unlock_irqrestore(io_lock, flags); >> + /* >> + * The Command state is changed to IOREQ_PENDING, >> + * in this case, if the command is completed, the icmnd_cmpl will >> + * mark the cmd as completed. >> + * This logic still makes LUN Reset is inevitable. >> + */ >> + >> + ret =3D snic_queue_dr_req(snic, rqi, sc); >> + if (ret) { >> + SNIC_HOST_ERR(snic->shost, >> + "send_dr: IO w/ Tag 0x%x Failed err =3D %d. flags 0x%llx\n= ", >> + tag, ret, CMD_FLAGS(sc)); >> + >> + spin_lock_irqsave(io_lock, flags); >> + /* Restore State */ >> + CMD_STATE(sc) =3D sv_state; >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (rqi) >> + rqi->dr_done =3D NULL; >> + /* rqi is freed in caller. */ >> + spin_unlock_irqrestore(io_lock, flags); >> + ret =3D FAILED; >> + >> + goto send_dr_end; >> + } >> + >> + spin_lock_irqsave(io_lock, flags); >> + CMD_FLAGS(sc) |=3D SNIC_DEV_RST_ISSUED; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + ret =3D 0; >> + >> + wait_for_completion_timeout(&tm_done, SNIC_LUN_RESET_TIMEOUT); >> + >> +send_dr_end: >> + return ret; >> +} >> + >> +/* >> + * auxillary funciton to check lun reset op is supported or not >> + * Not supported if returns 0 >> + */ >> +static int >> +snic_dev_reset_supported(struct scsi_device *sdev) >> +{ >> + struct snic_tgt *tgt =3D starget_to_tgt(scsi_target(sdev)); >> + >> + if (tgt->tdata.typ =3D=3D SNIC_TGT_DAS) >> + return 0; >> + >> + return 1; >> +} >> + >> +static void >> +snic_unlink_and_release_req(struct snic *snic, struct scsi_cmnd *sc= ,=20 >>int flag) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + spinlock_t *io_lock =3D NULL; >> + unsigned long flags; >> + u32 start_time =3D jiffies; >> + >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + spin_lock_irqsave(io_lock, flags); >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + if (rqi) { >> + start_time =3D rqi->start_time; >> + CMD_SP(sc) =3D NULL; >> + } >> + >> + CMD_FLAGS(sc) |=3D flag; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + if (rqi) >> + snic_release_req_buf(snic, rqi, sc); >> + >> + SNIC_TRC(snic->shost->host_no, snic_cmd_tag(sc), sc, >> + jiffies_to_msecs(jiffies - start_time), >> + rqi, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); >> +} >> + >> +/* >> + * SCSI Eh thread issues a LUN Reset when one or more commands on a= LUN >> + * fail to get aborted. It calls driver's eh_device_reset with a SC= SI >> + * command on the LUN. >> + */ >> +int >> +snic_device_reset(struct scsi_cmnd *sc) >> +{ >> + struct Scsi_Host *shost =3D sc->device->host; >> + struct snic *snic =3D shost_priv(shost); >> + struct snic_req_info *rqi =3D NULL; >> + int tag =3D snic_cmd_tag(sc); >> + int start_time =3D jiffies; >> + int ret =3D FAILED; >> + int dr_supp =3D 0; >> + >> + SNIC_SCSI_DBG(shost, "dev_reset:sc %p :0x%x :req =3D %p :tag =3D %= d\n", >> + sc, sc->cmnd[0], sc->request, >> + snic_cmd_tag(sc)); >> + dr_supp =3D snic_dev_reset_supported(sc->device); >> + if (!dr_supp) { >> + /* device reset op is not supported */ >> + SNIC_HOST_INFO(shost, "LUN Reset Op not supported.\n"); >> + snic_unlink_and_release_req(snic, sc, SNIC_DEV_RST_NOTSUP); >> + >> + goto dev_rst_end; >> + } >> + >> + if (unlikely(snic_get_state(snic) !=3D SNIC_ONLINE)) { >> + snic_unlink_and_release_req(snic, sc, 0); >> + SNIC_HOST_ERR(shost, "Devrst: Parent Devs are not online.\n"); >> + >> + goto dev_rst_end; >> + } >> + >> + /* There is no tag when lun reset is issue through ioctl. */ >> + if (unlikely(tag <=3D SNIC_NO_TAG)) { >> + SNIC_HOST_INFO(snic->shost, >> + "Devrst: LUN Reset Recvd thru IOCTL.\n"); >> + >> + rqi =3D snic_req_init(snic, 0); >> + if (!rqi) >> + goto dev_rst_end; >> + >> + memset(scsi_cmd_priv(sc), 0, >> + sizeof(struct snic_internal_io_state)); >> + CMD_SP(sc) =3D (char *)rqi; >> + CMD_FLAGS(sc) =3D SNIC_NO_FLAGS; >> + >> + /* Add special tag for dr coming from user spc */ >> + rqi->tm_tag =3D SNIC_TAG_IOCTL_DEV_RST; >> + rqi->sc =3D sc; >> + } >> + >> + ret =3D snic_send_dr_and_wait(snic, sc); >> + if (ret) { >> + SNIC_HOST_ERR(snic->shost, >> + "Devrst: IO w/ Tag %x Failed w/ err =3D %d\n", >> + tag, ret); >> + >> + snic_unlink_and_release_req(snic, sc, 0); >> + >> + goto dev_rst_end; >> + } >> + >> + ret =3D snic_dr_finish(snic, sc); >> + >> +dev_rst_end: >> + SNIC_TRC(snic->shost->host_no, tag, sc, >> + jiffies_to_msecs(jiffies - start_time), >> + 0, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); >> + >> + SNIC_SCSI_DBG(snic->shost, >> + "Devrst: Returning from Device Reset : %s\n", >> + (ret =3D=3D SUCCESS) ? "SUCCESS" : "FAILED"); >> + >> + return ret; >> +} /* end of snic_device_reset */ >> + >> +/* >> + * SCSI Error handling calls driver's eh_host_reset if all prior >> + * error handling levels return FAILED. >> + * >> + * Host Reset is the highest level of error recovery. If this fails= ,=20 >>then >> + * host is offlined by SCSI. >> + */ >> +/* >> + * snic_issue_hba_reset : Queues FW Reset Request. >> + */ >> +static int >> +snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc) >> +{ >> + struct snic_req_info *rqi =3D NULL; >> + struct snic_host_req *req =3D NULL; >> + spinlock_t *io_lock =3D NULL; >> + DECLARE_COMPLETION_ONSTACK(wait); >> + unsigned long flags; >> + int ret =3D -ENOMEM; >> + >> + rqi =3D snic_req_init(snic, 0); >> + if (!rqi) { >> + ret =3D -ENOMEM; >> + >> + goto hba_rst_end; >> + } >> + >> + if (snic_cmd_tag(sc) =3D=3D SCSI_NO_TAG) { >> + memset(scsi_cmd_priv(sc), 0, >> + sizeof(struct snic_internal_io_state)); >> + SNIC_HOST_INFO(snic->shost, "issu_hr:Host reset thru ioctl.\n"); >> + rqi->sc =3D sc; >> + } >> + >> + req =3D rqi_to_req(rqi); >> + >> + io_lock =3D snic_io_lock_hash(snic, sc); >> + spin_lock_irqsave(io_lock, flags); >> + SNIC_BUG_ON(CMD_SP(sc) !=3D NULL); >> + CMD_STATE(sc) =3D SNIC_IOREQ_PENDING; >> + CMD_SP(sc) =3D (char *) rqi; >> + CMD_FLAGS(sc) |=3D SNIC_IO_INITIALIZED; >> + snic->remove_wait =3D &wait; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + /* Initialize Request */ >> + snic_io_hdr_enc(&req->hdr, SNIC_REQ_HBA_RESET, 0, snic_cmd_tag(sc)= , >> + snic->config.hid, 0, (u64)rqi); >> + >> + req->u.reset.flags =3D 0; >> + >> + ret =3D snic_queue_wq_desc(snic, req, sizeof(*req)); >> + if (ret) { >> + SNIC_HOST_ERR(snic->shost, >> + "issu_hr:Queuing HBA Reset Failed. w err %d\n", >> + ret); >> + >> + goto hba_rst_err; >> + } >> + >> + spin_lock_irqsave(io_lock, flags); >> + CMD_FLAGS(sc) |=3D SNIC_HOST_RESET_ISSUED; >> + spin_unlock_irqrestore(io_lock, flags); >> + atomic64_inc(&snic->s_stats.reset.hba_resets); >> + SNIC_HOST_INFO(snic->shost, "Queued HBA Reset Successfully.\n"); >> + >> + wait_for_completion_timeout(snic->remove_wait, >> + SNIC_HOST_RESET_TIMEOUT); >> + >> + if (snic_get_state(snic) =3D=3D SNIC_FWRESET) { >> + SNIC_HOST_ERR(snic->shost, "reset_cmpl: Reset Timedout.\n"); >> + ret =3D -ETIMEDOUT; >> + >> + goto hba_rst_err; >> + } >> + >> + spin_lock_irqsave(io_lock, flags); >> + snic->remove_wait =3D NULL; >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + CMD_SP(sc) =3D NULL; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + if (rqi) >> + snic_req_free(snic, rqi); >> + >> + ret =3D 0; >> + >> + return ret; >> + >> +hba_rst_err: >> + spin_lock_irqsave(io_lock, flags); >> + snic->remove_wait =3D NULL; >> + rqi =3D (struct snic_req_info *) CMD_SP(sc); >> + CMD_SP(sc) =3D NULL; >> + spin_unlock_irqrestore(io_lock, flags); >> + >> + if (rqi) >> + snic_req_free(snic, rqi); >> + >> +hba_rst_end: >> + SNIC_HOST_ERR(snic->shost, >> + "reset:HBA Reset Failed w/ err =3D %d.\n", >> + ret); >> + >> + return ret; >> +} /* end of snic_issue_hba_reset */ >> + >> +int >> +snic_reset(struct Scsi_Host *shost, struct scsi_cmnd *sc) >> +{ >> + struct snic *snic =3D shost_priv(shost); >> + enum snic_state sv_state; >> + unsigned long flags; >> + int ret =3D FAILED; >> + >> + /* Set snic state as SNIC_FWRESET*/ >> + sv_state =3D snic_get_state(snic); >> + >> + spin_lock_irqsave(&snic->snic_lock, flags); >> + if (snic_get_state(snic) =3D=3D SNIC_FWRESET) { >> + spin_unlock_irqrestore(&snic->snic_lock, flags); >> + SNIC_HOST_INFO(shost, "reset:prev reset is in progres\n"); >> + >> + msleep(SNIC_HOST_RESET_TIMEOUT); >> + ret =3D SUCCESS; >> + >> + goto reset_end; >> + } >> + >> + snic_set_state(snic, SNIC_FWRESET); >> + spin_unlock_irqrestore(&snic->snic_lock, flags); >> + >> + >> + /* Wait for all the IOs that are entered in Qcmd */ >> + while (atomic_read(&snic->ios_inflight)) >> + schedule_timeout(msecs_to_jiffies(1)); >> + >> + ret =3D snic_issue_hba_reset(snic, sc); >> + if (ret) { >> + SNIC_HOST_ERR(shost, >> + "reset:Host Reset Failed w/ err %d.\n", >> + ret); >> + spin_lock_irqsave(&snic->snic_lock, flags); >> + snic_set_state(snic, sv_state); >> + spin_unlock_irqrestore(&snic->snic_lock, flags); >> + atomic64_inc(&snic->s_stats.reset.hba_reset_fail); >> + ret =3D FAILED; >> + >> + goto reset_end; >> + } >> + >> + ret =3D SUCCESS; >> + >> +reset_end: >> + return ret; >> +} /* end of snic_reset */ >> + >> +/* >> + * SCSI Error handling calls driver's eh_host_reset if all prior >> + * error handling levels return FAILED. >> + * >> + * Host Reset is the highest level of error recovery. If this fails= ,=20 >>then >> + * host is offlined by SCSI. >> + */ >> +int >> +snic_host_reset(struct scsi_cmnd *sc) >> +{ >> + struct Scsi_Host *shost =3D sc->device->host; >> + u32 start_time =3D jiffies; >> + int ret =3D FAILED; >> + >> + SNIC_SCSI_DBG(shost, >> + "host reset:sc %p sc_cmd 0x%x req %p tag %d flags 0x%llx\n"= , >> + sc, sc->cmnd[0], sc->request, >> + snic_cmd_tag(sc), CMD_FLAGS(sc)); >> + >> + ret =3D snic_reset(shost, sc); >> + >> + SNIC_TRC(shost->host_no, snic_cmd_tag(sc), sc, >> + jiffies_to_msecs(jiffies - start_time), >> + 0, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc)); >> + >> + return ret; >> +} /* end of snic_host_reset */ >> + >As mentioned above: >The send/receive queues are established during device initialization. >So if this information get garbled for whatever reason or if the >firmware becomes hosed you've got no way of resetting the HBA. >I would rather see if there wouldn't be an out-of-be mechanism to rese= t >the HBA (via PCI reset, say), and then send a new initialisation comma= nd. >This way you can be sure to reset the HBA correctly. We will use the out-of-band mechanism in a future-patch. > >Cheers, > >Hannes >--=20 >Dr. Hannes Reinecke zSeries & Storage >hare@suse.de +49 911 74053 688 >SUSE LINUX Products GmbH, Maxfeldstr. 5, 90409 N=FCrnberg >GF: J. Hawn, J. Guild, F. Imend=F6rffer, HRB 16746 (AG N=FCrnberg) Thanks Narsimhulu > -- To unsubscribe from this list: send the line "unsubscribe linux-scsi" i= n the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html