linux/drivers/scsi/fnic/fnic_scsi.c
<<
>>
Prefs
   1/*
   2 * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
   3 * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
   4 *
   5 * This program is free software; you may redistribute it and/or modify
   6 * it under the terms of the GNU General Public License as published by
   7 * the Free Software Foundation; version 2 of the License.
   8 *
   9 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  10 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  11 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  12 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  13 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  14 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  15 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  16 * SOFTWARE.
  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/scatterlist.h>
  24#include <linux/skbuff.h>
  25#include <linux/spinlock.h>
  26#include <linux/etherdevice.h>
  27#include <linux/if_ether.h>
  28#include <linux/if_vlan.h>
  29#include <linux/delay.h>
  30#include <linux/gfp.h>
  31#include <scsi/scsi.h>
  32#include <scsi/scsi_host.h>
  33#include <scsi/scsi_device.h>
  34#include <scsi/scsi_cmnd.h>
  35#include <scsi/scsi_tcq.h>
  36#include <scsi/fc/fc_els.h>
  37#include <scsi/fc/fc_fcoe.h>
  38#include <scsi/libfc.h>
  39#include <scsi/fc_frame.h>
  40#include "fnic_io.h"
  41#include "fnic.h"
  42
  43const char *fnic_state_str[] = {
  44        [FNIC_IN_FC_MODE] =           "FNIC_IN_FC_MODE",
  45        [FNIC_IN_FC_TRANS_ETH_MODE] = "FNIC_IN_FC_TRANS_ETH_MODE",
  46        [FNIC_IN_ETH_MODE] =          "FNIC_IN_ETH_MODE",
  47        [FNIC_IN_ETH_TRANS_FC_MODE] = "FNIC_IN_ETH_TRANS_FC_MODE",
  48};
  49
  50static const char *fnic_ioreq_state_str[] = {
  51        [FNIC_IOREQ_NOT_INITED] = "FNIC_IOREQ_NOT_INITED",
  52        [FNIC_IOREQ_CMD_PENDING] = "FNIC_IOREQ_CMD_PENDING",
  53        [FNIC_IOREQ_ABTS_PENDING] = "FNIC_IOREQ_ABTS_PENDING",
  54        [FNIC_IOREQ_ABTS_COMPLETE] = "FNIC_IOREQ_ABTS_COMPLETE",
  55        [FNIC_IOREQ_CMD_COMPLETE] = "FNIC_IOREQ_CMD_COMPLETE",
  56};
  57
  58static const char *fcpio_status_str[] =  {
  59        [FCPIO_SUCCESS] = "FCPIO_SUCCESS", /*0x0*/
  60        [FCPIO_INVALID_HEADER] = "FCPIO_INVALID_HEADER",
  61        [FCPIO_OUT_OF_RESOURCE] = "FCPIO_OUT_OF_RESOURCE",
  62        [FCPIO_INVALID_PARAM] = "FCPIO_INVALID_PARAM]",
  63        [FCPIO_REQ_NOT_SUPPORTED] = "FCPIO_REQ_NOT_SUPPORTED",
  64        [FCPIO_IO_NOT_FOUND] = "FCPIO_IO_NOT_FOUND",
  65        [FCPIO_ABORTED] = "FCPIO_ABORTED", /*0x41*/
  66        [FCPIO_TIMEOUT] = "FCPIO_TIMEOUT",
  67        [FCPIO_SGL_INVALID] = "FCPIO_SGL_INVALID",
  68        [FCPIO_MSS_INVALID] = "FCPIO_MSS_INVALID",
  69        [FCPIO_DATA_CNT_MISMATCH] = "FCPIO_DATA_CNT_MISMATCH",
  70        [FCPIO_FW_ERR] = "FCPIO_FW_ERR",
  71        [FCPIO_ITMF_REJECTED] = "FCPIO_ITMF_REJECTED",
  72        [FCPIO_ITMF_FAILED] = "FCPIO_ITMF_FAILED",
  73        [FCPIO_ITMF_INCORRECT_LUN] = "FCPIO_ITMF_INCORRECT_LUN",
  74        [FCPIO_CMND_REJECTED] = "FCPIO_CMND_REJECTED",
  75        [FCPIO_NO_PATH_AVAIL] = "FCPIO_NO_PATH_AVAIL",
  76        [FCPIO_PATH_FAILED] = "FCPIO_PATH_FAILED",
  77        [FCPIO_LUNMAP_CHNG_PEND] = "FCPIO_LUNHMAP_CHNG_PEND",
  78};
  79
  80const char *fnic_state_to_str(unsigned int state)
  81{
  82        if (state >= ARRAY_SIZE(fnic_state_str) || !fnic_state_str[state])
  83                return "unknown";
  84
  85        return fnic_state_str[state];
  86}
  87
  88static const char *fnic_ioreq_state_to_str(unsigned int state)
  89{
  90        if (state >= ARRAY_SIZE(fnic_ioreq_state_str) ||
  91            !fnic_ioreq_state_str[state])
  92                return "unknown";
  93
  94        return fnic_ioreq_state_str[state];
  95}
  96
  97static const char *fnic_fcpio_status_to_str(unsigned int status)
  98{
  99        if (status >= ARRAY_SIZE(fcpio_status_str) || !fcpio_status_str[status])
 100                return "unknown";
 101
 102        return fcpio_status_str[status];
 103}
 104
 105static void fnic_cleanup_io(struct fnic *fnic);
 106
 107static inline spinlock_t *fnic_io_lock_hash(struct fnic *fnic,
 108                                            struct scsi_cmnd *sc)
 109{
 110        u32 hash = sc->request->tag & (FNIC_IO_LOCKS - 1);
 111
 112        return &fnic->io_req_lock[hash];
 113}
 114
 115static inline spinlock_t *fnic_io_lock_tag(struct fnic *fnic,
 116                                            int tag)
 117{
 118        return &fnic->io_req_lock[tag & (FNIC_IO_LOCKS - 1)];
 119}
 120
 121/*
 122 * Unmap the data buffer and sense buffer for an io_req,
 123 * also unmap and free the device-private scatter/gather list.
 124 */
 125static void fnic_release_ioreq_buf(struct fnic *fnic,
 126                                   struct fnic_io_req *io_req,
 127                                   struct scsi_cmnd *sc)
 128{
 129        if (io_req->sgl_list_pa)
 130                dma_unmap_single(&fnic->pdev->dev, io_req->sgl_list_pa,
 131                                 sizeof(io_req->sgl_list[0]) * io_req->sgl_cnt,
 132                                 DMA_TO_DEVICE);
 133        scsi_dma_unmap(sc);
 134
 135        if (io_req->sgl_cnt)
 136                mempool_free(io_req->sgl_list_alloc,
 137                             fnic->io_sgl_pool[io_req->sgl_type]);
 138        if (io_req->sense_buf_pa)
 139                dma_unmap_single(&fnic->pdev->dev, io_req->sense_buf_pa,
 140                                 SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
 141}
 142
 143/* Free up Copy Wq descriptors. Called with copy_wq lock held */
 144static int free_wq_copy_descs(struct fnic *fnic, struct vnic_wq_copy *wq)
 145{
 146        /* if no Ack received from firmware, then nothing to clean */
 147        if (!fnic->fw_ack_recd[0])
 148                return 1;
 149
 150        /*
 151         * Update desc_available count based on number of freed descriptors
 152         * Account for wraparound
 153         */
 154        if (wq->to_clean_index <= fnic->fw_ack_index[0])
 155                wq->ring.desc_avail += (fnic->fw_ack_index[0]
 156                                        - wq->to_clean_index + 1);
 157        else
 158                wq->ring.desc_avail += (wq->ring.desc_count
 159                                        - wq->to_clean_index
 160                                        + fnic->fw_ack_index[0] + 1);
 161
 162        /*
 163         * just bump clean index to ack_index+1 accounting for wraparound
 164         * this will essentially free up all descriptors between
 165         * to_clean_index and fw_ack_index, both inclusive
 166         */
 167        wq->to_clean_index =
 168                (fnic->fw_ack_index[0] + 1) % wq->ring.desc_count;
 169
 170        /* we have processed the acks received so far */
 171        fnic->fw_ack_recd[0] = 0;
 172        return 0;
 173}
 174
 175
 176/*
 177 * __fnic_set_state_flags
 178 * Sets/Clears bits in fnic's state_flags
 179 **/
 180void
 181__fnic_set_state_flags(struct fnic *fnic, unsigned long st_flags,
 182                        unsigned long clearbits)
 183{
 184        unsigned long flags = 0;
 185        unsigned long host_lock_flags = 0;
 186
 187        spin_lock_irqsave(&fnic->fnic_lock, flags);
 188        spin_lock_irqsave(fnic->lport->host->host_lock, host_lock_flags);
 189
 190        if (clearbits)
 191                fnic->state_flags &= ~st_flags;
 192        else
 193                fnic->state_flags |= st_flags;
 194
 195        spin_unlock_irqrestore(fnic->lport->host->host_lock, host_lock_flags);
 196        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 197
 198        return;
 199}
 200
 201
 202/*
 203 * fnic_fw_reset_handler
 204 * Routine to send reset msg to fw
 205 */
 206int fnic_fw_reset_handler(struct fnic *fnic)
 207{
 208        struct vnic_wq_copy *wq = &fnic->wq_copy[0];
 209        int ret = 0;
 210        unsigned long flags;
 211
 212        /* indicate fwreset to io path */
 213        fnic_set_state_flags(fnic, FNIC_FLAGS_FWRESET);
 214
 215        skb_queue_purge(&fnic->frame_queue);
 216        skb_queue_purge(&fnic->tx_queue);
 217
 218        /* wait for io cmpl */
 219        while (atomic_read(&fnic->in_flight))
 220                schedule_timeout(msecs_to_jiffies(1));
 221
 222        spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
 223
 224        if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
 225                free_wq_copy_descs(fnic, wq);
 226
 227        if (!vnic_wq_copy_desc_avail(wq))
 228                ret = -EAGAIN;
 229        else {
 230                fnic_queue_wq_copy_desc_fw_reset(wq, SCSI_NO_TAG);
 231                atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
 232                if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
 233                          atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
 234                        atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
 235                                atomic64_read(
 236                                  &fnic->fnic_stats.fw_stats.active_fw_reqs));
 237        }
 238
 239        spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
 240
 241        if (!ret) {
 242                atomic64_inc(&fnic->fnic_stats.reset_stats.fw_resets);
 243                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 244                              "Issued fw reset\n");
 245        } else {
 246                fnic_clear_state_flags(fnic, FNIC_FLAGS_FWRESET);
 247                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 248                              "Failed to issue fw reset\n");
 249        }
 250
 251        return ret;
 252}
 253
 254
 255/*
 256 * fnic_flogi_reg_handler
 257 * Routine to send flogi register msg to fw
 258 */
 259int fnic_flogi_reg_handler(struct fnic *fnic, u32 fc_id)
 260{
 261        struct vnic_wq_copy *wq = &fnic->wq_copy[0];
 262        enum fcpio_flogi_reg_format_type format;
 263        struct fc_lport *lp = fnic->lport;
 264        u8 gw_mac[ETH_ALEN];
 265        int ret = 0;
 266        unsigned long flags;
 267
 268        spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
 269
 270        if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
 271                free_wq_copy_descs(fnic, wq);
 272
 273        if (!vnic_wq_copy_desc_avail(wq)) {
 274                ret = -EAGAIN;
 275                goto flogi_reg_ioreq_end;
 276        }
 277
 278        if (fnic->ctlr.map_dest) {
 279                eth_broadcast_addr(gw_mac);
 280                format = FCPIO_FLOGI_REG_DEF_DEST;
 281        } else {
 282                memcpy(gw_mac, fnic->ctlr.dest_addr, ETH_ALEN);
 283                format = FCPIO_FLOGI_REG_GW_DEST;
 284        }
 285
 286        if ((fnic->config.flags & VFCF_FIP_CAPABLE) && !fnic->ctlr.map_dest) {
 287                fnic_queue_wq_copy_desc_fip_reg(wq, SCSI_NO_TAG,
 288                                                fc_id, gw_mac,
 289                                                fnic->data_src_addr,
 290                                                lp->r_a_tov, lp->e_d_tov);
 291                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 292                              "FLOGI FIP reg issued fcid %x src %pM dest %pM\n",
 293                              fc_id, fnic->data_src_addr, gw_mac);
 294        } else {
 295                fnic_queue_wq_copy_desc_flogi_reg(wq, SCSI_NO_TAG,
 296                                                  format, fc_id, gw_mac);
 297                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 298                              "FLOGI reg issued fcid %x map %d dest %pM\n",
 299                              fc_id, fnic->ctlr.map_dest, gw_mac);
 300        }
 301
 302        atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
 303        if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
 304                  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
 305                atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
 306                  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
 307
 308flogi_reg_ioreq_end:
 309        spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
 310        return ret;
 311}
 312
 313/*
 314 * fnic_queue_wq_copy_desc
 315 * Routine to enqueue a wq copy desc
 316 */
 317static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
 318                                          struct vnic_wq_copy *wq,
 319                                          struct fnic_io_req *io_req,
 320                                          struct scsi_cmnd *sc,
 321                                          int sg_count)
 322{
 323        struct scatterlist *sg;
 324        struct fc_rport *rport = starget_to_rport(scsi_target(sc->device));
 325        struct fc_rport_libfc_priv *rp = rport->dd_data;
 326        struct host_sg_desc *desc;
 327        struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
 328        unsigned int i;
 329        unsigned long intr_flags;
 330        int flags;
 331        u8 exch_flags;
 332        struct scsi_lun fc_lun;
 333
 334        if (sg_count) {
 335                /* For each SGE, create a device desc entry */
 336                desc = io_req->sgl_list;
 337                for_each_sg(scsi_sglist(sc), sg, sg_count, i) {
 338                        desc->addr = cpu_to_le64(sg_dma_address(sg));
 339                        desc->len = cpu_to_le32(sg_dma_len(sg));
 340                        desc->_resvd = 0;
 341                        desc++;
 342                }
 343
 344                io_req->sgl_list_pa = dma_map_single(&fnic->pdev->dev,
 345                                io_req->sgl_list,
 346                                sizeof(io_req->sgl_list[0]) * sg_count,
 347                                DMA_TO_DEVICE);
 348                if (dma_mapping_error(&fnic->pdev->dev, io_req->sgl_list_pa)) {
 349                        printk(KERN_ERR "DMA mapping failed\n");
 350                        return SCSI_MLQUEUE_HOST_BUSY;
 351                }
 352        }
 353
 354        io_req->sense_buf_pa = dma_map_single(&fnic->pdev->dev,
 355                                              sc->sense_buffer,
 356                                              SCSI_SENSE_BUFFERSIZE,
 357                                              DMA_FROM_DEVICE);
 358        if (dma_mapping_error(&fnic->pdev->dev, io_req->sense_buf_pa)) {
 359                dma_unmap_single(&fnic->pdev->dev, io_req->sgl_list_pa,
 360                                sizeof(io_req->sgl_list[0]) * sg_count,
 361                                DMA_TO_DEVICE);
 362                printk(KERN_ERR "DMA mapping failed\n");
 363                return SCSI_MLQUEUE_HOST_BUSY;
 364        }
 365
 366        int_to_scsilun(sc->device->lun, &fc_lun);
 367
 368        /* Enqueue the descriptor in the Copy WQ */
 369        spin_lock_irqsave(&fnic->wq_copy_lock[0], intr_flags);
 370
 371        if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
 372                free_wq_copy_descs(fnic, wq);
 373
 374        if (unlikely(!vnic_wq_copy_desc_avail(wq))) {
 375                spin_unlock_irqrestore(&fnic->wq_copy_lock[0], intr_flags);
 376                FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
 377                          "fnic_queue_wq_copy_desc failure - no descriptors\n");
 378                atomic64_inc(&misc_stats->io_cpwq_alloc_failures);
 379                return SCSI_MLQUEUE_HOST_BUSY;
 380        }
 381
 382        flags = 0;
 383        if (sc->sc_data_direction == DMA_FROM_DEVICE)
 384                flags = FCPIO_ICMND_RDDATA;
 385        else if (sc->sc_data_direction == DMA_TO_DEVICE)
 386                flags = FCPIO_ICMND_WRDATA;
 387
 388        exch_flags = 0;
 389        if ((fnic->config.flags & VFCF_FCP_SEQ_LVL_ERR) &&
 390            (rp->flags & FC_RP_FLAGS_RETRY))
 391                exch_flags |= FCPIO_ICMND_SRFLAG_RETRY;
 392
 393        fnic_queue_wq_copy_desc_icmnd_16(wq, sc->request->tag,
 394                                         0, exch_flags, io_req->sgl_cnt,
 395                                         SCSI_SENSE_BUFFERSIZE,
 396                                         io_req->sgl_list_pa,
 397                                         io_req->sense_buf_pa,
 398                                         0, /* scsi cmd ref, always 0 */
 399                                         FCPIO_ICMND_PTA_SIMPLE,
 400                                                /* scsi pri and tag */
 401                                         flags, /* command flags */
 402                                         sc->cmnd, sc->cmd_len,
 403                                         scsi_bufflen(sc),
 404                                         fc_lun.scsi_lun, io_req->port_id,
 405                                         rport->maxframe_size, rp->r_a_tov,
 406                                         rp->e_d_tov);
 407
 408        atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
 409        if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
 410                  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
 411                atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
 412                  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
 413
 414        spin_unlock_irqrestore(&fnic->wq_copy_lock[0], intr_flags);
 415        return 0;
 416}
 417
 418/*
 419 * fnic_queuecommand
 420 * Routine to send a scsi cdb
 421 * Called with host_lock held and interrupts disabled.
 422 */
 423static int fnic_queuecommand_lck(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
 424{
 425        struct fc_lport *lp = shost_priv(sc->device->host);
 426        struct fc_rport *rport;
 427        struct fnic_io_req *io_req = NULL;
 428        struct fnic *fnic = lport_priv(lp);
 429        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
 430        struct vnic_wq_copy *wq;
 431        int ret;
 432        u64 cmd_trace;
 433        int sg_count = 0;
 434        unsigned long flags = 0;
 435        unsigned long ptr;
 436        spinlock_t *io_lock = NULL;
 437        int io_lock_acquired = 0;
 438        struct fc_rport_libfc_priv *rp;
 439
 440        if (unlikely(fnic_chk_state_flags_locked(fnic, FNIC_FLAGS_IO_BLOCKED)))
 441                return SCSI_MLQUEUE_HOST_BUSY;
 442
 443        if (unlikely(fnic_chk_state_flags_locked(fnic, FNIC_FLAGS_FWRESET)))
 444                return SCSI_MLQUEUE_HOST_BUSY;
 445
 446        rport = starget_to_rport(scsi_target(sc->device));
 447        if (!rport) {
 448                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 449                                "returning DID_NO_CONNECT for IO as rport is NULL\n");
 450                sc->result = DID_NO_CONNECT << 16;
 451                done(sc);
 452                return 0;
 453        }
 454
 455        ret = fc_remote_port_chkready(rport);
 456        if (ret) {
 457                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 458                                "rport is not ready\n");
 459                atomic64_inc(&fnic_stats->misc_stats.rport_not_ready);
 460                sc->result = ret;
 461                done(sc);
 462                return 0;
 463        }
 464
 465        rp = rport->dd_data;
 466        if (!rp || rp->rp_state == RPORT_ST_DELETE) {
 467                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 468                        "rport 0x%x removed, returning DID_NO_CONNECT\n",
 469                        rport->port_id);
 470
 471                atomic64_inc(&fnic_stats->misc_stats.rport_not_ready);
 472                sc->result = DID_NO_CONNECT<<16;
 473                done(sc);
 474                return 0;
 475        }
 476
 477        if (rp->rp_state != RPORT_ST_READY) {
 478                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 479                        "rport 0x%x in state 0x%x, returning DID_IMM_RETRY\n",
 480                        rport->port_id, rp->rp_state);
 481
 482                sc->result = DID_IMM_RETRY << 16;
 483                done(sc);
 484                return 0;
 485        }
 486
 487        if (lp->state != LPORT_ST_READY || !(lp->link_up))
 488                return SCSI_MLQUEUE_HOST_BUSY;
 489
 490        atomic_inc(&fnic->in_flight);
 491
 492        /*
 493         * Release host lock, use driver resource specific locks from here.
 494         * Don't re-enable interrupts in case they were disabled prior to the
 495         * caller disabling them.
 496         */
 497        spin_unlock(lp->host->host_lock);
 498        CMD_STATE(sc) = FNIC_IOREQ_NOT_INITED;
 499        CMD_FLAGS(sc) = FNIC_NO_FLAGS;
 500
 501        /* Get a new io_req for this SCSI IO */
 502        io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
 503        if (!io_req) {
 504                atomic64_inc(&fnic_stats->io_stats.alloc_failures);
 505                ret = SCSI_MLQUEUE_HOST_BUSY;
 506                goto out;
 507        }
 508        memset(io_req, 0, sizeof(*io_req));
 509
 510        /* Map the data buffer */
 511        sg_count = scsi_dma_map(sc);
 512        if (sg_count < 0) {
 513                FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
 514                          sc->request->tag, sc, 0, sc->cmnd[0],
 515                          sg_count, CMD_STATE(sc));
 516                mempool_free(io_req, fnic->io_req_pool);
 517                goto out;
 518        }
 519
 520        /* Determine the type of scatter/gather list we need */
 521        io_req->sgl_cnt = sg_count;
 522        io_req->sgl_type = FNIC_SGL_CACHE_DFLT;
 523        if (sg_count > FNIC_DFLT_SG_DESC_CNT)
 524                io_req->sgl_type = FNIC_SGL_CACHE_MAX;
 525
 526        if (sg_count) {
 527                io_req->sgl_list =
 528                        mempool_alloc(fnic->io_sgl_pool[io_req->sgl_type],
 529                                      GFP_ATOMIC);
 530                if (!io_req->sgl_list) {
 531                        atomic64_inc(&fnic_stats->io_stats.alloc_failures);
 532                        ret = SCSI_MLQUEUE_HOST_BUSY;
 533                        scsi_dma_unmap(sc);
 534                        mempool_free(io_req, fnic->io_req_pool);
 535                        goto out;
 536                }
 537
 538                /* Cache sgl list allocated address before alignment */
 539                io_req->sgl_list_alloc = io_req->sgl_list;
 540                ptr = (unsigned long) io_req->sgl_list;
 541                if (ptr % FNIC_SG_DESC_ALIGN) {
 542                        io_req->sgl_list = (struct host_sg_desc *)
 543                                (((unsigned long) ptr
 544                                  + FNIC_SG_DESC_ALIGN - 1)
 545                                 & ~(FNIC_SG_DESC_ALIGN - 1));
 546                }
 547        }
 548
 549        /*
 550        * Will acquire lock defore setting to IO initialized.
 551        */
 552
 553        io_lock = fnic_io_lock_hash(fnic, sc);
 554        spin_lock_irqsave(io_lock, flags);
 555
 556        /* initialize rest of io_req */
 557        io_lock_acquired = 1;
 558        io_req->port_id = rport->port_id;
 559        io_req->start_time = jiffies;
 560        CMD_STATE(sc) = FNIC_IOREQ_CMD_PENDING;
 561        CMD_SP(sc) = (char *)io_req;
 562        CMD_FLAGS(sc) |= FNIC_IO_INITIALIZED;
 563        sc->scsi_done = done;
 564
 565        /* create copy wq desc and enqueue it */
 566        wq = &fnic->wq_copy[0];
 567        ret = fnic_queue_wq_copy_desc(fnic, wq, io_req, sc, sg_count);
 568        if (ret) {
 569                /*
 570                 * In case another thread cancelled the request,
 571                 * refetch the pointer under the lock.
 572                 */
 573                FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
 574                          sc->request->tag, sc, 0, 0, 0,
 575                          (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
 576                io_req = (struct fnic_io_req *)CMD_SP(sc);
 577                CMD_SP(sc) = NULL;
 578                CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
 579                spin_unlock_irqrestore(io_lock, flags);
 580                if (io_req) {
 581                        fnic_release_ioreq_buf(fnic, io_req, sc);
 582                        mempool_free(io_req, fnic->io_req_pool);
 583                }
 584                atomic_dec(&fnic->in_flight);
 585                /* acquire host lock before returning to SCSI */
 586                spin_lock(lp->host->host_lock);
 587                return ret;
 588        } else {
 589                atomic64_inc(&fnic_stats->io_stats.active_ios);
 590                atomic64_inc(&fnic_stats->io_stats.num_ios);
 591                if (atomic64_read(&fnic_stats->io_stats.active_ios) >
 592                          atomic64_read(&fnic_stats->io_stats.max_active_ios))
 593                        atomic64_set(&fnic_stats->io_stats.max_active_ios,
 594                             atomic64_read(&fnic_stats->io_stats.active_ios));
 595
 596                /* REVISIT: Use per IO lock in the final code */
 597                CMD_FLAGS(sc) |= FNIC_IO_ISSUED;
 598        }
 599out:
 600        cmd_trace = ((u64)sc->cmnd[0] << 56 | (u64)sc->cmnd[7] << 40 |
 601                        (u64)sc->cmnd[8] << 32 | (u64)sc->cmnd[2] << 24 |
 602                        (u64)sc->cmnd[3] << 16 | (u64)sc->cmnd[4] << 8 |
 603                        sc->cmnd[5]);
 604
 605        FNIC_TRACE(fnic_queuecommand, sc->device->host->host_no,
 606                  sc->request->tag, sc, io_req,
 607                  sg_count, cmd_trace,
 608                  (((u64)CMD_FLAGS(sc) >> 32) | CMD_STATE(sc)));
 609
 610        /* if only we issued IO, will we have the io lock */
 611        if (io_lock_acquired)
 612                spin_unlock_irqrestore(io_lock, flags);
 613
 614        atomic_dec(&fnic->in_flight);
 615        /* acquire host lock before returning to SCSI */
 616        spin_lock(lp->host->host_lock);
 617        return ret;
 618}
 619
 620DEF_SCSI_QCMD(fnic_queuecommand)
 621
 622/*
 623 * fnic_fcpio_fw_reset_cmpl_handler
 624 * Routine to handle fw reset completion
 625 */
 626static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
 627                                            struct fcpio_fw_req *desc)
 628{
 629        u8 type;
 630        u8 hdr_status;
 631        struct fcpio_tag tag;
 632        int ret = 0;
 633        unsigned long flags;
 634        struct reset_stats *reset_stats = &fnic->fnic_stats.reset_stats;
 635
 636        fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
 637
 638        atomic64_inc(&reset_stats->fw_reset_completions);
 639
 640        /* Clean up all outstanding io requests */
 641        fnic_cleanup_io(fnic);
 642
 643        atomic64_set(&fnic->fnic_stats.fw_stats.active_fw_reqs, 0);
 644        atomic64_set(&fnic->fnic_stats.io_stats.active_ios, 0);
 645        atomic64_set(&fnic->io_cmpl_skip, 0);
 646
 647        spin_lock_irqsave(&fnic->fnic_lock, flags);
 648
 649        /* fnic should be in FC_TRANS_ETH_MODE */
 650        if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE) {
 651                /* Check status of reset completion */
 652                if (!hdr_status) {
 653                        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 654                                      "reset cmpl success\n");
 655                        /* Ready to send flogi out */
 656                        fnic->state = FNIC_IN_ETH_MODE;
 657                } else {
 658                        FNIC_SCSI_DBG(KERN_DEBUG,
 659                                      fnic->lport->host,
 660                                      "fnic fw_reset : failed %s\n",
 661                                      fnic_fcpio_status_to_str(hdr_status));
 662
 663                        /*
 664                         * Unable to change to eth mode, cannot send out flogi
 665                         * Change state to fc mode, so that subsequent Flogi
 666                         * requests from libFC will cause more attempts to
 667                         * reset the firmware. Free the cached flogi
 668                         */
 669                        fnic->state = FNIC_IN_FC_MODE;
 670                        atomic64_inc(&reset_stats->fw_reset_failures);
 671                        ret = -1;
 672                }
 673        } else {
 674                FNIC_SCSI_DBG(KERN_DEBUG,
 675                              fnic->lport->host,
 676                              "Unexpected state %s while processing"
 677                              " reset cmpl\n", fnic_state_to_str(fnic->state));
 678                atomic64_inc(&reset_stats->fw_reset_failures);
 679                ret = -1;
 680        }
 681
 682        /* Thread removing device blocks till firmware reset is complete */
 683        if (fnic->remove_wait)
 684                complete(fnic->remove_wait);
 685
 686        /*
 687         * If fnic is being removed, or fw reset failed
 688         * free the flogi frame. Else, send it out
 689         */
 690        if (fnic->remove_wait || ret) {
 691                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 692                skb_queue_purge(&fnic->tx_queue);
 693                goto reset_cmpl_handler_end;
 694        }
 695
 696        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 697
 698        fnic_flush_tx(fnic);
 699
 700 reset_cmpl_handler_end:
 701        fnic_clear_state_flags(fnic, FNIC_FLAGS_FWRESET);
 702
 703        return ret;
 704}
 705
 706/*
 707 * fnic_fcpio_flogi_reg_cmpl_handler
 708 * Routine to handle flogi register completion
 709 */
 710static int fnic_fcpio_flogi_reg_cmpl_handler(struct fnic *fnic,
 711                                             struct fcpio_fw_req *desc)
 712{
 713        u8 type;
 714        u8 hdr_status;
 715        struct fcpio_tag tag;
 716        int ret = 0;
 717        unsigned long flags;
 718
 719        fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
 720
 721        /* Update fnic state based on status of flogi reg completion */
 722        spin_lock_irqsave(&fnic->fnic_lock, flags);
 723
 724        if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE) {
 725
 726                /* Check flogi registration completion status */
 727                if (!hdr_status) {
 728                        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 729                                      "flog reg succeeded\n");
 730                        fnic->state = FNIC_IN_FC_MODE;
 731                } else {
 732                        FNIC_SCSI_DBG(KERN_DEBUG,
 733                                      fnic->lport->host,
 734                                      "fnic flogi reg :failed %s\n",
 735                                      fnic_fcpio_status_to_str(hdr_status));
 736                        fnic->state = FNIC_IN_ETH_MODE;
 737                        ret = -1;
 738                }
 739        } else {
 740                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
 741                              "Unexpected fnic state %s while"
 742                              " processing flogi reg completion\n",
 743                              fnic_state_to_str(fnic->state));
 744                ret = -1;
 745        }
 746
 747        if (!ret) {
 748                if (fnic->stop_rx_link_events) {
 749                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 750                        goto reg_cmpl_handler_end;
 751                }
 752                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 753
 754                fnic_flush_tx(fnic);
 755                queue_work(fnic_event_queue, &fnic->frame_work);
 756        } else {
 757                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 758        }
 759
 760reg_cmpl_handler_end:
 761        return ret;
 762}
 763
 764static inline int is_ack_index_in_range(struct vnic_wq_copy *wq,
 765                                        u16 request_out)
 766{
 767        if (wq->to_clean_index <= wq->to_use_index) {
 768                /* out of range, stale request_out index */
 769                if (request_out < wq->to_clean_index ||
 770                    request_out >= wq->to_use_index)
 771                        return 0;
 772        } else {
 773                /* out of range, stale request_out index */
 774                if (request_out < wq->to_clean_index &&
 775                    request_out >= wq->to_use_index)
 776                        return 0;
 777        }
 778        /* request_out index is in range */
 779        return 1;
 780}
 781
 782
 783/*
 784 * Mark that ack received and store the Ack index. If there are multiple
 785 * acks received before Tx thread cleans it up, the latest value will be
 786 * used which is correct behavior. This state should be in the copy Wq
 787 * instead of in the fnic
 788 */
 789static inline void fnic_fcpio_ack_handler(struct fnic *fnic,
 790                                          unsigned int cq_index,
 791                                          struct fcpio_fw_req *desc)
 792{
 793        struct vnic_wq_copy *wq;
 794        u16 request_out = desc->u.ack.request_out;
 795        unsigned long flags;
 796        u64 *ox_id_tag = (u64 *)(void *)desc;
 797
 798        /* mark the ack state */
 799        wq = &fnic->wq_copy[cq_index - fnic->raw_wq_count - fnic->rq_count];
 800        spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
 801
 802        fnic->fnic_stats.misc_stats.last_ack_time = jiffies;
 803        if (is_ack_index_in_range(wq, request_out)) {
 804                fnic->fw_ack_index[0] = request_out;
 805                fnic->fw_ack_recd[0] = 1;
 806        } else
 807                atomic64_inc(
 808                        &fnic->fnic_stats.misc_stats.ack_index_out_of_range);
 809
 810        spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
 811        FNIC_TRACE(fnic_fcpio_ack_handler,
 812                  fnic->lport->host->host_no, 0, 0, ox_id_tag[2], ox_id_tag[3],
 813                  ox_id_tag[4], ox_id_tag[5]);
 814}
 815
 816/*
 817 * fnic_fcpio_icmnd_cmpl_handler
 818 * Routine to handle icmnd completions
 819 */
 820static void fnic_fcpio_icmnd_cmpl_handler(struct fnic *fnic,
 821                                         struct fcpio_fw_req *desc)
 822{
 823        u8 type;
 824        u8 hdr_status;
 825        struct fcpio_tag tag;
 826        u32 id;
 827        u64 xfer_len = 0;
 828        struct fcpio_icmnd_cmpl *icmnd_cmpl;
 829        struct fnic_io_req *io_req;
 830        struct scsi_cmnd *sc;
 831        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
 832        unsigned long flags;
 833        spinlock_t *io_lock;
 834        u64 cmd_trace;
 835        unsigned long start_time;
 836        unsigned long io_duration_time;
 837
 838        /* Decode the cmpl description to get the io_req id */
 839        fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
 840        fcpio_tag_id_dec(&tag, &id);
 841        icmnd_cmpl = &desc->u.icmnd_cmpl;
 842
 843        if (id >= fnic->fnic_max_tag_id) {
 844                shost_printk(KERN_ERR, fnic->lport->host,
 845                        "Tag out of range tag %x hdr status = %s\n",
 846                             id, fnic_fcpio_status_to_str(hdr_status));
 847                return;
 848        }
 849
 850        sc = scsi_host_find_tag(fnic->lport->host, id);
 851        WARN_ON_ONCE(!sc);
 852        if (!sc) {
 853                atomic64_inc(&fnic_stats->io_stats.sc_null);
 854                shost_printk(KERN_ERR, fnic->lport->host,
 855                          "icmnd_cmpl sc is null - "
 856                          "hdr status = %s tag = 0x%x desc = 0x%p\n",
 857                          fnic_fcpio_status_to_str(hdr_status), id, desc);
 858                FNIC_TRACE(fnic_fcpio_icmnd_cmpl_handler,
 859                          fnic->lport->host->host_no, id,
 860                          ((u64)icmnd_cmpl->_resvd0[1] << 16 |
 861                          (u64)icmnd_cmpl->_resvd0[0]),
 862                          ((u64)hdr_status << 16 |
 863                          (u64)icmnd_cmpl->scsi_status << 8 |
 864                          (u64)icmnd_cmpl->flags), desc,
 865                          (u64)icmnd_cmpl->residual, 0);
 866                return;
 867        }
 868
 869        io_lock = fnic_io_lock_hash(fnic, sc);
 870        spin_lock_irqsave(io_lock, flags);
 871        io_req = (struct fnic_io_req *)CMD_SP(sc);
 872        WARN_ON_ONCE(!io_req);
 873        if (!io_req) {
 874                atomic64_inc(&fnic_stats->io_stats.ioreq_null);
 875                CMD_FLAGS(sc) |= FNIC_IO_REQ_NULL;
 876                spin_unlock_irqrestore(io_lock, flags);
 877                shost_printk(KERN_ERR, fnic->lport->host,
 878                          "icmnd_cmpl io_req is null - "
 879                          "hdr status = %s tag = 0x%x sc 0x%p\n",
 880                          fnic_fcpio_status_to_str(hdr_status), id, sc);
 881                return;
 882        }
 883        start_time = io_req->start_time;
 884
 885        /* firmware completed the io */
 886        io_req->io_completed = 1;
 887
 888        /*
 889         *  if SCSI-ML has already issued abort on this command,
 890         *  set completion of the IO. The abts path will clean it up
 891         */
 892        if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
 893
 894                /*
 895                 * set the FNIC_IO_DONE so that this doesn't get
 896                 * flagged as 'out of order' if it was not aborted
 897                 */
 898                CMD_FLAGS(sc) |= FNIC_IO_DONE;
 899                CMD_FLAGS(sc) |= FNIC_IO_ABTS_PENDING;
 900                spin_unlock_irqrestore(io_lock, flags);
 901                if(FCPIO_ABORTED == hdr_status)
 902                        CMD_FLAGS(sc) |= FNIC_IO_ABORTED;
 903
 904                FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
 905                        "icmnd_cmpl abts pending "
 906                          "hdr status = %s tag = 0x%x sc = 0x%p "
 907                          "scsi_status = %x residual = %d\n",
 908                          fnic_fcpio_status_to_str(hdr_status),
 909                          id, sc,
 910                          icmnd_cmpl->scsi_status,
 911                          icmnd_cmpl->residual);
 912                return;
 913        }
 914
 915        /* Mark the IO as complete */
 916        CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
 917
 918        icmnd_cmpl = &desc->u.icmnd_cmpl;
 919
 920        switch (hdr_status) {
 921        case FCPIO_SUCCESS:
 922                sc->result = (DID_OK << 16) | icmnd_cmpl->scsi_status;
 923                xfer_len = scsi_bufflen(sc);
 924
 925                if (icmnd_cmpl->flags & FCPIO_ICMND_CMPL_RESID_UNDER) {
 926                        xfer_len -= icmnd_cmpl->residual;
 927                        scsi_set_resid(sc, icmnd_cmpl->residual);
 928                }
 929
 930                if (icmnd_cmpl->scsi_status == SAM_STAT_CHECK_CONDITION)
 931                        atomic64_inc(&fnic_stats->misc_stats.check_condition);
 932
 933                if (icmnd_cmpl->scsi_status == SAM_STAT_TASK_SET_FULL)
 934                        atomic64_inc(&fnic_stats->misc_stats.queue_fulls);
 935                break;
 936
 937        case FCPIO_TIMEOUT:          /* request was timed out */
 938                atomic64_inc(&fnic_stats->misc_stats.fcpio_timeout);
 939                sc->result = (DID_TIME_OUT << 16) | icmnd_cmpl->scsi_status;
 940                break;
 941
 942        case FCPIO_ABORTED:          /* request was aborted */
 943                atomic64_inc(&fnic_stats->misc_stats.fcpio_aborted);
 944                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
 945                break;
 946
 947        case FCPIO_DATA_CNT_MISMATCH: /* recv/sent more/less data than exp. */
 948                atomic64_inc(&fnic_stats->misc_stats.data_count_mismatch);
 949                scsi_set_resid(sc, icmnd_cmpl->residual);
 950                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
 951                break;
 952
 953        case FCPIO_OUT_OF_RESOURCE:  /* out of resources to complete request */
 954                atomic64_inc(&fnic_stats->fw_stats.fw_out_of_resources);
 955                sc->result = (DID_REQUEUE << 16) | icmnd_cmpl->scsi_status;
 956                break;
 957
 958        case FCPIO_IO_NOT_FOUND:     /* requested I/O was not found */
 959                atomic64_inc(&fnic_stats->io_stats.io_not_found);
 960                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
 961                break;
 962
 963        case FCPIO_SGL_INVALID:      /* request was aborted due to sgl error */
 964                atomic64_inc(&fnic_stats->misc_stats.sgl_invalid);
 965                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
 966                break;
 967
 968        case FCPIO_FW_ERR:           /* request was terminated due fw error */
 969                atomic64_inc(&fnic_stats->fw_stats.io_fw_errs);
 970                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
 971                break;
 972
 973        case FCPIO_MSS_INVALID:      /* request was aborted due to mss error */
 974                atomic64_inc(&fnic_stats->misc_stats.mss_invalid);
 975                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
 976                break;
 977
 978        case FCPIO_INVALID_HEADER:   /* header contains invalid data */
 979        case FCPIO_INVALID_PARAM:    /* some parameter in request invalid */
 980        case FCPIO_REQ_NOT_SUPPORTED:/* request type is not supported */
 981        default:
 982                sc->result = (DID_ERROR << 16) | icmnd_cmpl->scsi_status;
 983                break;
 984        }
 985
 986        /* Break link with the SCSI command */
 987        CMD_SP(sc) = NULL;
 988        CMD_FLAGS(sc) |= FNIC_IO_DONE;
 989
 990        spin_unlock_irqrestore(io_lock, flags);
 991
 992        if (hdr_status != FCPIO_SUCCESS) {
 993                atomic64_inc(&fnic_stats->io_stats.io_failures);
 994                shost_printk(KERN_ERR, fnic->lport->host, "hdr status = %s\n",
 995                             fnic_fcpio_status_to_str(hdr_status));
 996        }
 997
 998        fnic_release_ioreq_buf(fnic, io_req, sc);
 999
1000        mempool_free(io_req, fnic->io_req_pool);
1001
1002        cmd_trace = ((u64)hdr_status << 56) |
1003                  (u64)icmnd_cmpl->scsi_status << 48 |
1004                  (u64)icmnd_cmpl->flags << 40 | (u64)sc->cmnd[0] << 32 |
1005                  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
1006                  (u64)sc->cmnd[4] << 8 | sc->cmnd[5];
1007
1008        FNIC_TRACE(fnic_fcpio_icmnd_cmpl_handler,
1009                  sc->device->host->host_no, id, sc,
1010                  ((u64)icmnd_cmpl->_resvd0[1] << 56 |
1011                  (u64)icmnd_cmpl->_resvd0[0] << 48 |
1012                  jiffies_to_msecs(jiffies - start_time)),
1013                  desc, cmd_trace,
1014                  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
1015
1016        if (sc->sc_data_direction == DMA_FROM_DEVICE) {
1017                fnic->lport->host_stats.fcp_input_requests++;
1018                fnic->fcp_input_bytes += xfer_len;
1019        } else if (sc->sc_data_direction == DMA_TO_DEVICE) {
1020                fnic->lport->host_stats.fcp_output_requests++;
1021                fnic->fcp_output_bytes += xfer_len;
1022        } else
1023                fnic->lport->host_stats.fcp_control_requests++;
1024
1025        atomic64_dec(&fnic_stats->io_stats.active_ios);
1026        if (atomic64_read(&fnic->io_cmpl_skip))
1027                atomic64_dec(&fnic->io_cmpl_skip);
1028        else
1029                atomic64_inc(&fnic_stats->io_stats.io_completions);
1030
1031
1032        io_duration_time = jiffies_to_msecs(jiffies) -
1033                                                jiffies_to_msecs(start_time);
1034
1035        if(io_duration_time <= 10)
1036                atomic64_inc(&fnic_stats->io_stats.io_btw_0_to_10_msec);
1037        else if(io_duration_time <= 100)
1038                atomic64_inc(&fnic_stats->io_stats.io_btw_10_to_100_msec);
1039        else if(io_duration_time <= 500)
1040                atomic64_inc(&fnic_stats->io_stats.io_btw_100_to_500_msec);
1041        else if(io_duration_time <= 5000)
1042                atomic64_inc(&fnic_stats->io_stats.io_btw_500_to_5000_msec);
1043        else if(io_duration_time <= 10000)
1044                atomic64_inc(&fnic_stats->io_stats.io_btw_5000_to_10000_msec);
1045        else if(io_duration_time <= 30000)
1046                atomic64_inc(&fnic_stats->io_stats.io_btw_10000_to_30000_msec);
1047        else {
1048                atomic64_inc(&fnic_stats->io_stats.io_greater_than_30000_msec);
1049
1050                if(io_duration_time > atomic64_read(&fnic_stats->io_stats.current_max_io_time))
1051                        atomic64_set(&fnic_stats->io_stats.current_max_io_time, io_duration_time);
1052        }
1053
1054        /* Call SCSI completion function to complete the IO */
1055        if (sc->scsi_done)
1056                sc->scsi_done(sc);
1057}
1058
1059/* fnic_fcpio_itmf_cmpl_handler
1060 * Routine to handle itmf completions
1061 */
1062static void fnic_fcpio_itmf_cmpl_handler(struct fnic *fnic,
1063                                        struct fcpio_fw_req *desc)
1064{
1065        u8 type;
1066        u8 hdr_status;
1067        struct fcpio_tag tag;
1068        u32 id;
1069        struct scsi_cmnd *sc;
1070        struct fnic_io_req *io_req;
1071        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
1072        struct abort_stats *abts_stats = &fnic->fnic_stats.abts_stats;
1073        struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
1074        struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
1075        unsigned long flags;
1076        spinlock_t *io_lock;
1077        unsigned long start_time;
1078
1079        fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
1080        fcpio_tag_id_dec(&tag, &id);
1081
1082        if ((id & FNIC_TAG_MASK) >= fnic->fnic_max_tag_id) {
1083                shost_printk(KERN_ERR, fnic->lport->host,
1084                "Tag out of range tag %x hdr status = %s\n",
1085                id, fnic_fcpio_status_to_str(hdr_status));
1086                return;
1087        }
1088
1089        sc = scsi_host_find_tag(fnic->lport->host, id & FNIC_TAG_MASK);
1090        WARN_ON_ONCE(!sc);
1091        if (!sc) {
1092                atomic64_inc(&fnic_stats->io_stats.sc_null);
1093                shost_printk(KERN_ERR, fnic->lport->host,
1094                          "itmf_cmpl sc is null - hdr status = %s tag = 0x%x\n",
1095                          fnic_fcpio_status_to_str(hdr_status), id);
1096                return;
1097        }
1098        io_lock = fnic_io_lock_hash(fnic, sc);
1099        spin_lock_irqsave(io_lock, flags);
1100        io_req = (struct fnic_io_req *)CMD_SP(sc);
1101        WARN_ON_ONCE(!io_req);
1102        if (!io_req) {
1103                atomic64_inc(&fnic_stats->io_stats.ioreq_null);
1104                spin_unlock_irqrestore(io_lock, flags);
1105                CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
1106                shost_printk(KERN_ERR, fnic->lport->host,
1107                          "itmf_cmpl io_req is null - "
1108                          "hdr status = %s tag = 0x%x sc 0x%p\n",
1109                          fnic_fcpio_status_to_str(hdr_status), id, sc);
1110                return;
1111        }
1112        start_time = io_req->start_time;
1113
1114        if ((id & FNIC_TAG_ABORT) && (id & FNIC_TAG_DEV_RST)) {
1115                /* Abort and terminate completion of device reset req */
1116                /* REVISIT : Add asserts about various flags */
1117                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1118                              "dev reset abts cmpl recd. id %x status %s\n",
1119                              id, fnic_fcpio_status_to_str(hdr_status));
1120                CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
1121                CMD_ABTS_STATUS(sc) = hdr_status;
1122                CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
1123                if (io_req->abts_done)
1124                        complete(io_req->abts_done);
1125                spin_unlock_irqrestore(io_lock, flags);
1126        } else if (id & FNIC_TAG_ABORT) {
1127                /* Completion of abort cmd */
1128                switch (hdr_status) {
1129                case FCPIO_SUCCESS:
1130                        break;
1131                case FCPIO_TIMEOUT:
1132                        if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
1133                                atomic64_inc(&abts_stats->abort_fw_timeouts);
1134                        else
1135                                atomic64_inc(
1136                                        &term_stats->terminate_fw_timeouts);
1137                        break;
1138                case FCPIO_ITMF_REJECTED:
1139                        FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
1140                                "abort reject recd. id %d\n",
1141                                (int)(id & FNIC_TAG_MASK));
1142                        break;
1143                case FCPIO_IO_NOT_FOUND:
1144                        if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
1145                                atomic64_inc(&abts_stats->abort_io_not_found);
1146                        else
1147                                atomic64_inc(
1148                                        &term_stats->terminate_io_not_found);
1149                        break;
1150                default:
1151                        if (CMD_FLAGS(sc) & FNIC_IO_ABTS_ISSUED)
1152                                atomic64_inc(&abts_stats->abort_failures);
1153                        else
1154                                atomic64_inc(
1155                                        &term_stats->terminate_failures);
1156                        break;
1157                }
1158                if (CMD_STATE(sc) != FNIC_IOREQ_ABTS_PENDING) {
1159                        /* This is a late completion. Ignore it */
1160                        spin_unlock_irqrestore(io_lock, flags);
1161                        return;
1162                }
1163
1164                CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_DONE;
1165                CMD_ABTS_STATUS(sc) = hdr_status;
1166
1167                /* If the status is IO not found consider it as success */
1168                if (hdr_status == FCPIO_IO_NOT_FOUND)
1169                        CMD_ABTS_STATUS(sc) = FCPIO_SUCCESS;
1170
1171                if (!(CMD_FLAGS(sc) & (FNIC_IO_ABORTED | FNIC_IO_DONE)))
1172                        atomic64_inc(&misc_stats->no_icmnd_itmf_cmpls);
1173
1174                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1175                              "abts cmpl recd. id %d status %s\n",
1176                              (int)(id & FNIC_TAG_MASK),
1177                              fnic_fcpio_status_to_str(hdr_status));
1178
1179                /*
1180                 * If scsi_eh thread is blocked waiting for abts to complete,
1181                 * signal completion to it. IO will be cleaned in the thread
1182                 * else clean it in this context
1183                 */
1184                if (io_req->abts_done) {
1185                        complete(io_req->abts_done);
1186                        spin_unlock_irqrestore(io_lock, flags);
1187                } else {
1188                        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1189                                      "abts cmpl, completing IO\n");
1190                        CMD_SP(sc) = NULL;
1191                        sc->result = (DID_ERROR << 16);
1192
1193                        spin_unlock_irqrestore(io_lock, flags);
1194
1195                        fnic_release_ioreq_buf(fnic, io_req, sc);
1196                        mempool_free(io_req, fnic->io_req_pool);
1197                        if (sc->scsi_done) {
1198                                FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
1199                                        sc->device->host->host_no, id,
1200                                        sc,
1201                                        jiffies_to_msecs(jiffies - start_time),
1202                                        desc,
1203                                        (((u64)hdr_status << 40) |
1204                                        (u64)sc->cmnd[0] << 32 |
1205                                        (u64)sc->cmnd[2] << 24 |
1206                                        (u64)sc->cmnd[3] << 16 |
1207                                        (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
1208                                        (((u64)CMD_FLAGS(sc) << 32) |
1209                                        CMD_STATE(sc)));
1210                                sc->scsi_done(sc);
1211                                atomic64_dec(&fnic_stats->io_stats.active_ios);
1212                                if (atomic64_read(&fnic->io_cmpl_skip))
1213                                        atomic64_dec(&fnic->io_cmpl_skip);
1214                                else
1215                                        atomic64_inc(&fnic_stats->io_stats.io_completions);
1216                        }
1217                }
1218
1219        } else if (id & FNIC_TAG_DEV_RST) {
1220                /* Completion of device reset */
1221                CMD_LR_STATUS(sc) = hdr_status;
1222                if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
1223                        spin_unlock_irqrestore(io_lock, flags);
1224                        CMD_FLAGS(sc) |= FNIC_DEV_RST_ABTS_PENDING;
1225                        FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
1226                                  sc->device->host->host_no, id, sc,
1227                                  jiffies_to_msecs(jiffies - start_time),
1228                                  desc, 0,
1229                                  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
1230                        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1231                                "Terminate pending "
1232                                "dev reset cmpl recd. id %d status %s\n",
1233                                (int)(id & FNIC_TAG_MASK),
1234                                fnic_fcpio_status_to_str(hdr_status));
1235                        return;
1236                }
1237                if (CMD_FLAGS(sc) & FNIC_DEV_RST_TIMED_OUT) {
1238                        /* Need to wait for terminate completion */
1239                        spin_unlock_irqrestore(io_lock, flags);
1240                        FNIC_TRACE(fnic_fcpio_itmf_cmpl_handler,
1241                                  sc->device->host->host_no, id, sc,
1242                                  jiffies_to_msecs(jiffies - start_time),
1243                                  desc, 0,
1244                                  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
1245                        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1246                                "dev reset cmpl recd after time out. "
1247                                "id %d status %s\n",
1248                                (int)(id & FNIC_TAG_MASK),
1249                                fnic_fcpio_status_to_str(hdr_status));
1250                        return;
1251                }
1252                CMD_STATE(sc) = FNIC_IOREQ_CMD_COMPLETE;
1253                CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
1254                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1255                              "dev reset cmpl recd. id %d status %s\n",
1256                              (int)(id & FNIC_TAG_MASK),
1257                              fnic_fcpio_status_to_str(hdr_status));
1258                if (io_req->dr_done)
1259                        complete(io_req->dr_done);
1260                spin_unlock_irqrestore(io_lock, flags);
1261
1262        } else {
1263                shost_printk(KERN_ERR, fnic->lport->host,
1264                             "Unexpected itmf io state %s tag %x\n",
1265                             fnic_ioreq_state_to_str(CMD_STATE(sc)), id);
1266                spin_unlock_irqrestore(io_lock, flags);
1267        }
1268
1269}
1270
1271/*
1272 * fnic_fcpio_cmpl_handler
1273 * Routine to service the cq for wq_copy
1274 */
1275static int fnic_fcpio_cmpl_handler(struct vnic_dev *vdev,
1276                                   unsigned int cq_index,
1277                                   struct fcpio_fw_req *desc)
1278{
1279        struct fnic *fnic = vnic_dev_priv(vdev);
1280
1281        switch (desc->hdr.type) {
1282        case FCPIO_ICMND_CMPL: /* fw completed a command */
1283        case FCPIO_ITMF_CMPL: /* fw completed itmf (abort cmd, lun reset)*/
1284        case FCPIO_FLOGI_REG_CMPL: /* fw completed flogi_reg */
1285        case FCPIO_FLOGI_FIP_REG_CMPL: /* fw completed flogi_fip_reg */
1286        case FCPIO_RESET_CMPL: /* fw completed reset */
1287                atomic64_dec(&fnic->fnic_stats.fw_stats.active_fw_reqs);
1288                break;
1289        default:
1290                break;
1291        }
1292
1293        switch (desc->hdr.type) {
1294        case FCPIO_ACK: /* fw copied copy wq desc to its queue */
1295                fnic_fcpio_ack_handler(fnic, cq_index, desc);
1296                break;
1297
1298        case FCPIO_ICMND_CMPL: /* fw completed a command */
1299                fnic_fcpio_icmnd_cmpl_handler(fnic, desc);
1300                break;
1301
1302        case FCPIO_ITMF_CMPL: /* fw completed itmf (abort cmd, lun reset)*/
1303                fnic_fcpio_itmf_cmpl_handler(fnic, desc);
1304                break;
1305
1306        case FCPIO_FLOGI_REG_CMPL: /* fw completed flogi_reg */
1307        case FCPIO_FLOGI_FIP_REG_CMPL: /* fw completed flogi_fip_reg */
1308                fnic_fcpio_flogi_reg_cmpl_handler(fnic, desc);
1309                break;
1310
1311        case FCPIO_RESET_CMPL: /* fw completed reset */
1312                fnic_fcpio_fw_reset_cmpl_handler(fnic, desc);
1313                break;
1314
1315        default:
1316                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1317                              "firmware completion type %d\n",
1318                              desc->hdr.type);
1319                break;
1320        }
1321
1322        return 0;
1323}
1324
1325/*
1326 * fnic_wq_copy_cmpl_handler
1327 * Routine to process wq copy
1328 */
1329int fnic_wq_copy_cmpl_handler(struct fnic *fnic, int copy_work_to_do)
1330{
1331        unsigned int wq_work_done = 0;
1332        unsigned int i, cq_index;
1333        unsigned int cur_work_done;
1334        struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
1335        u64 start_jiffies = 0;
1336        u64 end_jiffies = 0;
1337        u64 delta_jiffies = 0;
1338        u64 delta_ms = 0;
1339
1340        for (i = 0; i < fnic->wq_copy_count; i++) {
1341                cq_index = i + fnic->raw_wq_count + fnic->rq_count;
1342
1343                start_jiffies = jiffies;
1344                cur_work_done = vnic_cq_copy_service(&fnic->cq[cq_index],
1345                                                     fnic_fcpio_cmpl_handler,
1346                                                     copy_work_to_do);
1347                end_jiffies = jiffies;
1348
1349                wq_work_done += cur_work_done;
1350                delta_jiffies = end_jiffies - start_jiffies;
1351                if (delta_jiffies >
1352                        (u64) atomic64_read(&misc_stats->max_isr_jiffies)) {
1353                        atomic64_set(&misc_stats->max_isr_jiffies,
1354                                        delta_jiffies);
1355                        delta_ms = jiffies_to_msecs(delta_jiffies);
1356                        atomic64_set(&misc_stats->max_isr_time_ms, delta_ms);
1357                        atomic64_set(&misc_stats->corr_work_done,
1358                                        cur_work_done);
1359                }
1360        }
1361        return wq_work_done;
1362}
1363
1364static bool fnic_cleanup_io_iter(struct scsi_cmnd *sc, void *data,
1365                                 bool reserved)
1366{
1367        struct fnic *fnic = data;
1368        struct fnic_io_req *io_req;
1369        unsigned long flags = 0;
1370        spinlock_t *io_lock;
1371        unsigned long start_time = 0;
1372        struct fnic_stats *fnic_stats = &fnic->fnic_stats;
1373
1374        io_lock = fnic_io_lock_tag(fnic, sc->request->tag);
1375        spin_lock_irqsave(io_lock, flags);
1376
1377        io_req = (struct fnic_io_req *)CMD_SP(sc);
1378        if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
1379            !(CMD_FLAGS(sc) & FNIC_DEV_RST_DONE)) {
1380                /*
1381                 * We will be here only when FW completes reset
1382                 * without sending completions for outstanding ios.
1383                 */
1384                CMD_FLAGS(sc) |= FNIC_DEV_RST_DONE;
1385                if (io_req && io_req->dr_done)
1386                        complete(io_req->dr_done);
1387                else if (io_req && io_req->abts_done)
1388                        complete(io_req->abts_done);
1389                spin_unlock_irqrestore(io_lock, flags);
1390                return true;
1391        } else if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
1392                spin_unlock_irqrestore(io_lock, flags);
1393                return true;
1394        }
1395        if (!io_req) {
1396                spin_unlock_irqrestore(io_lock, flags);
1397                goto cleanup_scsi_cmd;
1398        }
1399
1400        CMD_SP(sc) = NULL;
1401
1402        spin_unlock_irqrestore(io_lock, flags);
1403
1404        /*
1405         * If there is a scsi_cmnd associated with this io_req, then
1406         * free the corresponding state
1407         */
1408        start_time = io_req->start_time;
1409        fnic_release_ioreq_buf(fnic, io_req, sc);
1410        mempool_free(io_req, fnic->io_req_pool);
1411
1412cleanup_scsi_cmd:
1413        sc->result = DID_TRANSPORT_DISRUPTED << 16;
1414        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1415                      "fnic_cleanup_io: tag:0x%x : sc:0x%p duration = %lu DID_TRANSPORT_DISRUPTED\n",
1416                      sc->request->tag, sc, (jiffies - start_time));
1417
1418        if (atomic64_read(&fnic->io_cmpl_skip))
1419                atomic64_dec(&fnic->io_cmpl_skip);
1420        else
1421                atomic64_inc(&fnic_stats->io_stats.io_completions);
1422
1423        /* Complete the command to SCSI */
1424        if (sc->scsi_done) {
1425                if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED))
1426                        shost_printk(KERN_ERR, fnic->lport->host,
1427                                     "Calling done for IO not issued to fw: tag:0x%x sc:0x%p\n",
1428                                     sc->request->tag, sc);
1429
1430                FNIC_TRACE(fnic_cleanup_io,
1431                           sc->device->host->host_no, sc->request->tag, sc,
1432                           jiffies_to_msecs(jiffies - start_time),
1433                           0, ((u64)sc->cmnd[0] << 32 |
1434                               (u64)sc->cmnd[2] << 24 |
1435                               (u64)sc->cmnd[3] << 16 |
1436                               (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
1437                           (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
1438
1439                sc->scsi_done(sc);
1440        }
1441        return true;
1442}
1443
1444static void fnic_cleanup_io(struct fnic *fnic)
1445{
1446        scsi_host_busy_iter(fnic->lport->host,
1447                            fnic_cleanup_io_iter, fnic);
1448}
1449
1450void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
1451                                  struct fcpio_host_req *desc)
1452{
1453        u32 id;
1454        struct fnic *fnic = vnic_dev_priv(wq->vdev);
1455        struct fnic_io_req *io_req;
1456        struct scsi_cmnd *sc;
1457        unsigned long flags;
1458        spinlock_t *io_lock;
1459        unsigned long start_time = 0;
1460
1461        /* get the tag reference */
1462        fcpio_tag_id_dec(&desc->hdr.tag, &id);
1463        id &= FNIC_TAG_MASK;
1464
1465        if (id >= fnic->fnic_max_tag_id)
1466                return;
1467
1468        sc = scsi_host_find_tag(fnic->lport->host, id);
1469        if (!sc)
1470                return;
1471
1472        io_lock = fnic_io_lock_hash(fnic, sc);
1473        spin_lock_irqsave(io_lock, flags);
1474
1475        /* Get the IO context which this desc refers to */
1476        io_req = (struct fnic_io_req *)CMD_SP(sc);
1477
1478        /* fnic interrupts are turned off by now */
1479
1480        if (!io_req) {
1481                spin_unlock_irqrestore(io_lock, flags);
1482                goto wq_copy_cleanup_scsi_cmd;
1483        }
1484
1485        CMD_SP(sc) = NULL;
1486
1487        spin_unlock_irqrestore(io_lock, flags);
1488
1489        start_time = io_req->start_time;
1490        fnic_release_ioreq_buf(fnic, io_req, sc);
1491        mempool_free(io_req, fnic->io_req_pool);
1492
1493wq_copy_cleanup_scsi_cmd:
1494        sc->result = DID_NO_CONNECT << 16;
1495        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "wq_copy_cleanup_handler:"
1496                      " DID_NO_CONNECT\n");
1497
1498        if (sc->scsi_done) {
1499                FNIC_TRACE(fnic_wq_copy_cleanup_handler,
1500                          sc->device->host->host_no, id, sc,
1501                          jiffies_to_msecs(jiffies - start_time),
1502                          0, ((u64)sc->cmnd[0] << 32 |
1503                          (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
1504                          (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
1505                          (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
1506
1507                sc->scsi_done(sc);
1508        }
1509}
1510
1511static inline int fnic_queue_abort_io_req(struct fnic *fnic, int tag,
1512                                          u32 task_req, u8 *fc_lun,
1513                                          struct fnic_io_req *io_req)
1514{
1515        struct vnic_wq_copy *wq = &fnic->wq_copy[0];
1516        struct Scsi_Host *host = fnic->lport->host;
1517        struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
1518        unsigned long flags;
1519
1520        spin_lock_irqsave(host->host_lock, flags);
1521        if (unlikely(fnic_chk_state_flags_locked(fnic,
1522                                                FNIC_FLAGS_IO_BLOCKED))) {
1523                spin_unlock_irqrestore(host->host_lock, flags);
1524                return 1;
1525        } else
1526                atomic_inc(&fnic->in_flight);
1527        spin_unlock_irqrestore(host->host_lock, flags);
1528
1529        spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
1530
1531        if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
1532                free_wq_copy_descs(fnic, wq);
1533
1534        if (!vnic_wq_copy_desc_avail(wq)) {
1535                spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
1536                atomic_dec(&fnic->in_flight);
1537                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1538                        "fnic_queue_abort_io_req: failure: no descriptors\n");
1539                atomic64_inc(&misc_stats->abts_cpwq_alloc_failures);
1540                return 1;
1541        }
1542        fnic_queue_wq_copy_desc_itmf(wq, tag | FNIC_TAG_ABORT,
1543                                     0, task_req, tag, fc_lun, io_req->port_id,
1544                                     fnic->config.ra_tov, fnic->config.ed_tov);
1545
1546        atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
1547        if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
1548                  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
1549                atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
1550                  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
1551
1552        spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
1553        atomic_dec(&fnic->in_flight);
1554
1555        return 0;
1556}
1557
1558struct fnic_rport_abort_io_iter_data {
1559        struct fnic *fnic;
1560        u32 port_id;
1561        int term_cnt;
1562};
1563
1564static bool fnic_rport_abort_io_iter(struct scsi_cmnd *sc, void *data,
1565                                     bool reserved)
1566{
1567        struct fnic_rport_abort_io_iter_data *iter_data = data;
1568        struct fnic *fnic = iter_data->fnic;
1569        int abt_tag = sc->request->tag;
1570        struct fnic_io_req *io_req;
1571        spinlock_t *io_lock;
1572        unsigned long flags;
1573        struct reset_stats *reset_stats = &fnic->fnic_stats.reset_stats;
1574        struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
1575        struct scsi_lun fc_lun;
1576        enum fnic_ioreq_state old_ioreq_state;
1577
1578        io_lock = fnic_io_lock_tag(fnic, abt_tag);
1579        spin_lock_irqsave(io_lock, flags);
1580
1581        io_req = (struct fnic_io_req *)CMD_SP(sc);
1582
1583        if (!io_req || io_req->port_id != iter_data->port_id) {
1584                spin_unlock_irqrestore(io_lock, flags);
1585                return true;
1586        }
1587
1588        if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
1589            (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
1590                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1591                        "fnic_rport_exch_reset dev rst not pending sc 0x%p\n",
1592                        sc);
1593                spin_unlock_irqrestore(io_lock, flags);
1594                return true;
1595        }
1596
1597        /*
1598         * Found IO that is still pending with firmware and
1599         * belongs to rport that went away
1600         */
1601        if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
1602                spin_unlock_irqrestore(io_lock, flags);
1603                return true;
1604        }
1605        if (io_req->abts_done) {
1606                shost_printk(KERN_ERR, fnic->lport->host,
1607                        "fnic_rport_exch_reset: io_req->abts_done is set "
1608                        "state is %s\n",
1609                        fnic_ioreq_state_to_str(CMD_STATE(sc)));
1610        }
1611
1612        if (!(CMD_FLAGS(sc) & FNIC_IO_ISSUED)) {
1613                shost_printk(KERN_ERR, fnic->lport->host,
1614                             "rport_exch_reset "
1615                             "IO not yet issued %p tag 0x%x flags "
1616                             "%x state %d\n",
1617                             sc, abt_tag, CMD_FLAGS(sc), CMD_STATE(sc));
1618        }
1619        old_ioreq_state = CMD_STATE(sc);
1620        CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
1621        CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
1622        if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
1623                atomic64_inc(&reset_stats->device_reset_terminates);
1624                abt_tag |= FNIC_TAG_DEV_RST;
1625        }
1626        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1627                      "fnic_rport_exch_reset dev rst sc 0x%p\n", sc);
1628        BUG_ON(io_req->abts_done);
1629
1630        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1631                      "fnic_rport_reset_exch: Issuing abts\n");
1632
1633        spin_unlock_irqrestore(io_lock, flags);
1634
1635        /* Now queue the abort command to firmware */
1636        int_to_scsilun(sc->device->lun, &fc_lun);
1637
1638        if (fnic_queue_abort_io_req(fnic, abt_tag,
1639                                    FCPIO_ITMF_ABT_TASK_TERM,
1640                                    fc_lun.scsi_lun, io_req)) {
1641                /*
1642                 * Revert the cmd state back to old state, if
1643                 * it hasn't changed in between. This cmd will get
1644                 * aborted later by scsi_eh, or cleaned up during
1645                 * lun reset
1646                 */
1647                spin_lock_irqsave(io_lock, flags);
1648                if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
1649                        CMD_STATE(sc) = old_ioreq_state;
1650                spin_unlock_irqrestore(io_lock, flags);
1651        } else {
1652                spin_lock_irqsave(io_lock, flags);
1653                if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
1654                        CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
1655                else
1656                        CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
1657                spin_unlock_irqrestore(io_lock, flags);
1658                atomic64_inc(&term_stats->terminates);
1659                iter_data->term_cnt++;
1660        }
1661        return true;
1662}
1663
1664static void fnic_rport_exch_reset(struct fnic *fnic, u32 port_id)
1665{
1666        struct terminate_stats *term_stats = &fnic->fnic_stats.term_stats;
1667        struct fnic_rport_abort_io_iter_data iter_data = {
1668                .fnic = fnic,
1669                .port_id = port_id,
1670                .term_cnt = 0,
1671        };
1672
1673        FNIC_SCSI_DBG(KERN_DEBUG,
1674                      fnic->lport->host,
1675                      "fnic_rport_exch_reset called portid 0x%06x\n",
1676                      port_id);
1677
1678        if (fnic->in_remove)
1679                return;
1680
1681        scsi_host_busy_iter(fnic->lport->host, fnic_rport_abort_io_iter,
1682                            &iter_data);
1683        if (iter_data.term_cnt > atomic64_read(&term_stats->max_terminates))
1684                atomic64_set(&term_stats->max_terminates, iter_data.term_cnt);
1685
1686}
1687
1688void fnic_terminate_rport_io(struct fc_rport *rport)
1689{
1690        struct fc_rport_libfc_priv *rdata;
1691        struct fc_lport *lport;
1692        struct fnic *fnic;
1693
1694        if (!rport) {
1695                printk(KERN_ERR "fnic_terminate_rport_io: rport is NULL\n");
1696                return;
1697        }
1698        rdata = rport->dd_data;
1699
1700        if (!rdata) {
1701                printk(KERN_ERR "fnic_terminate_rport_io: rdata is NULL\n");
1702                return;
1703        }
1704        lport = rdata->local_port;
1705
1706        if (!lport) {
1707                printk(KERN_ERR "fnic_terminate_rport_io: lport is NULL\n");
1708                return;
1709        }
1710        fnic = lport_priv(lport);
1711        FNIC_SCSI_DBG(KERN_DEBUG,
1712                      fnic->lport->host, "fnic_terminate_rport_io called"
1713                      " wwpn 0x%llx, wwnn0x%llx, rport 0x%p, portid 0x%06x\n",
1714                      rport->port_name, rport->node_name, rport,
1715                      rport->port_id);
1716
1717        if (fnic->in_remove)
1718                return;
1719
1720        fnic_rport_exch_reset(fnic, rport->port_id);
1721}
1722
1723/*
1724 * This function is exported to SCSI for sending abort cmnds.
1725 * A SCSI IO is represented by a io_req in the driver.
1726 * The ioreq is linked to the SCSI Cmd, thus a link with the ULP's IO.
1727 */
1728int fnic_abort_cmd(struct scsi_cmnd *sc)
1729{
1730        struct fc_lport *lp;
1731        struct fnic *fnic;
1732        struct fnic_io_req *io_req = NULL;
1733        struct fc_rport *rport;
1734        spinlock_t *io_lock;
1735        unsigned long flags;
1736        unsigned long start_time = 0;
1737        int ret = SUCCESS;
1738        u32 task_req = 0;
1739        struct scsi_lun fc_lun;
1740        struct fnic_stats *fnic_stats;
1741        struct abort_stats *abts_stats;
1742        struct terminate_stats *term_stats;
1743        enum fnic_ioreq_state old_ioreq_state;
1744        int tag;
1745        unsigned long abt_issued_time;
1746        DECLARE_COMPLETION_ONSTACK(tm_done);
1747
1748        /* Wait for rport to unblock */
1749        fc_block_scsi_eh(sc);
1750
1751        /* Get local-port, check ready and link up */
1752        lp = shost_priv(sc->device->host);
1753
1754        fnic = lport_priv(lp);
1755        fnic_stats = &fnic->fnic_stats;
1756        abts_stats = &fnic->fnic_stats.abts_stats;
1757        term_stats = &fnic->fnic_stats.term_stats;
1758
1759        rport = starget_to_rport(scsi_target(sc->device));
1760        tag = sc->request->tag;
1761        FNIC_SCSI_DBG(KERN_DEBUG,
1762                fnic->lport->host,
1763                "Abort Cmd called FCID 0x%x, LUN 0x%llx TAG %x flags %x\n",
1764                rport->port_id, sc->device->lun, tag, CMD_FLAGS(sc));
1765
1766        CMD_FLAGS(sc) = FNIC_NO_FLAGS;
1767
1768        if (lp->state != LPORT_ST_READY || !(lp->link_up)) {
1769                ret = FAILED;
1770                goto fnic_abort_cmd_end;
1771        }
1772
1773        /*
1774         * Avoid a race between SCSI issuing the abort and the device
1775         * completing the command.
1776         *
1777         * If the command is already completed by the fw cmpl code,
1778         * we just return SUCCESS from here. This means that the abort
1779         * succeeded. In the SCSI ML, since the timeout for command has
1780         * happened, the completion wont actually complete the command
1781         * and it will be considered as an aborted command
1782         *
1783         * The CMD_SP will not be cleared except while holding io_req_lock.
1784         */
1785        io_lock = fnic_io_lock_hash(fnic, sc);
1786        spin_lock_irqsave(io_lock, flags);
1787        io_req = (struct fnic_io_req *)CMD_SP(sc);
1788        if (!io_req) {
1789                spin_unlock_irqrestore(io_lock, flags);
1790                goto fnic_abort_cmd_end;
1791        }
1792
1793        io_req->abts_done = &tm_done;
1794
1795        if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
1796                spin_unlock_irqrestore(io_lock, flags);
1797                goto wait_pending;
1798        }
1799
1800        abt_issued_time = jiffies_to_msecs(jiffies) - jiffies_to_msecs(io_req->start_time);
1801        if (abt_issued_time <= 6000)
1802                atomic64_inc(&abts_stats->abort_issued_btw_0_to_6_sec);
1803        else if (abt_issued_time > 6000 && abt_issued_time <= 20000)
1804                atomic64_inc(&abts_stats->abort_issued_btw_6_to_20_sec);
1805        else if (abt_issued_time > 20000 && abt_issued_time <= 30000)
1806                atomic64_inc(&abts_stats->abort_issued_btw_20_to_30_sec);
1807        else if (abt_issued_time > 30000 && abt_issued_time <= 40000)
1808                atomic64_inc(&abts_stats->abort_issued_btw_30_to_40_sec);
1809        else if (abt_issued_time > 40000 && abt_issued_time <= 50000)
1810                atomic64_inc(&abts_stats->abort_issued_btw_40_to_50_sec);
1811        else if (abt_issued_time > 50000 && abt_issued_time <= 60000)
1812                atomic64_inc(&abts_stats->abort_issued_btw_50_to_60_sec);
1813        else
1814                atomic64_inc(&abts_stats->abort_issued_greater_than_60_sec);
1815
1816        FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
1817                "CBD Opcode: %02x Abort issued time: %lu msec\n", sc->cmnd[0], abt_issued_time);
1818        /*
1819         * Command is still pending, need to abort it
1820         * If the firmware completes the command after this point,
1821         * the completion wont be done till mid-layer, since abort
1822         * has already started.
1823         */
1824        old_ioreq_state = CMD_STATE(sc);
1825        CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
1826        CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
1827
1828        spin_unlock_irqrestore(io_lock, flags);
1829
1830        /*
1831         * Check readiness of the remote port. If the path to remote
1832         * port is up, then send abts to the remote port to terminate
1833         * the IO. Else, just locally terminate the IO in the firmware
1834         */
1835        if (fc_remote_port_chkready(rport) == 0)
1836                task_req = FCPIO_ITMF_ABT_TASK;
1837        else {
1838                atomic64_inc(&fnic_stats->misc_stats.rport_not_ready);
1839                task_req = FCPIO_ITMF_ABT_TASK_TERM;
1840        }
1841
1842        /* Now queue the abort command to firmware */
1843        int_to_scsilun(sc->device->lun, &fc_lun);
1844
1845        if (fnic_queue_abort_io_req(fnic, sc->request->tag, task_req,
1846                                    fc_lun.scsi_lun, io_req)) {
1847                spin_lock_irqsave(io_lock, flags);
1848                if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
1849                        CMD_STATE(sc) = old_ioreq_state;
1850                io_req = (struct fnic_io_req *)CMD_SP(sc);
1851                if (io_req)
1852                        io_req->abts_done = NULL;
1853                spin_unlock_irqrestore(io_lock, flags);
1854                ret = FAILED;
1855                goto fnic_abort_cmd_end;
1856        }
1857        if (task_req == FCPIO_ITMF_ABT_TASK) {
1858                CMD_FLAGS(sc) |= FNIC_IO_ABTS_ISSUED;
1859                atomic64_inc(&fnic_stats->abts_stats.aborts);
1860        } else {
1861                CMD_FLAGS(sc) |= FNIC_IO_TERM_ISSUED;
1862                atomic64_inc(&fnic_stats->term_stats.terminates);
1863        }
1864
1865        /*
1866         * We queued an abort IO, wait for its completion.
1867         * Once the firmware completes the abort command, it will
1868         * wake up this thread.
1869         */
1870 wait_pending:
1871        wait_for_completion_timeout(&tm_done,
1872                                    msecs_to_jiffies
1873                                    (2 * fnic->config.ra_tov +
1874                                     fnic->config.ed_tov));
1875
1876        /* Check the abort status */
1877        spin_lock_irqsave(io_lock, flags);
1878
1879        io_req = (struct fnic_io_req *)CMD_SP(sc);
1880        if (!io_req) {
1881                atomic64_inc(&fnic_stats->io_stats.ioreq_null);
1882                spin_unlock_irqrestore(io_lock, flags);
1883                CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
1884                ret = FAILED;
1885                goto fnic_abort_cmd_end;
1886        }
1887        io_req->abts_done = NULL;
1888
1889        /* fw did not complete abort, timed out */
1890        if (CMD_ABTS_STATUS(sc) == FCPIO_INVALID_CODE) {
1891                spin_unlock_irqrestore(io_lock, flags);
1892                if (task_req == FCPIO_ITMF_ABT_TASK) {
1893                        atomic64_inc(&abts_stats->abort_drv_timeouts);
1894                } else {
1895                        atomic64_inc(&term_stats->terminate_drv_timeouts);
1896                }
1897                CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_TIMED_OUT;
1898                ret = FAILED;
1899                goto fnic_abort_cmd_end;
1900        }
1901
1902        /* IO out of order */
1903
1904        if (!(CMD_FLAGS(sc) & (FNIC_IO_ABORTED | FNIC_IO_DONE))) {
1905                spin_unlock_irqrestore(io_lock, flags);
1906                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1907                        "Issuing Host reset due to out of order IO\n");
1908
1909                ret = FAILED;
1910                goto fnic_abort_cmd_end;
1911        }
1912
1913        CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
1914
1915        start_time = io_req->start_time;
1916        /*
1917         * firmware completed the abort, check the status,
1918         * free the io_req if successful. If abort fails,
1919         * Device reset will clean the I/O.
1920         */
1921        if (CMD_ABTS_STATUS(sc) == FCPIO_SUCCESS)
1922                CMD_SP(sc) = NULL;
1923        else {
1924                ret = FAILED;
1925                spin_unlock_irqrestore(io_lock, flags);
1926                goto fnic_abort_cmd_end;
1927        }
1928
1929        spin_unlock_irqrestore(io_lock, flags);
1930
1931        fnic_release_ioreq_buf(fnic, io_req, sc);
1932        mempool_free(io_req, fnic->io_req_pool);
1933
1934        if (sc->scsi_done) {
1935        /* Call SCSI completion function to complete the IO */
1936                sc->result = (DID_ABORT << 16);
1937                sc->scsi_done(sc);
1938                atomic64_dec(&fnic_stats->io_stats.active_ios);
1939                if (atomic64_read(&fnic->io_cmpl_skip))
1940                        atomic64_dec(&fnic->io_cmpl_skip);
1941                else
1942                        atomic64_inc(&fnic_stats->io_stats.io_completions);
1943        }
1944
1945fnic_abort_cmd_end:
1946        FNIC_TRACE(fnic_abort_cmd, sc->device->host->host_no,
1947                  sc->request->tag, sc,
1948                  jiffies_to_msecs(jiffies - start_time),
1949                  0, ((u64)sc->cmnd[0] << 32 |
1950                  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
1951                  (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
1952                  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
1953
1954        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1955                      "Returning from abort cmd type %x %s\n", task_req,
1956                      (ret == SUCCESS) ?
1957                      "SUCCESS" : "FAILED");
1958        return ret;
1959}
1960
1961static inline int fnic_queue_dr_io_req(struct fnic *fnic,
1962                                       struct scsi_cmnd *sc,
1963                                       struct fnic_io_req *io_req)
1964{
1965        struct vnic_wq_copy *wq = &fnic->wq_copy[0];
1966        struct Scsi_Host *host = fnic->lport->host;
1967        struct misc_stats *misc_stats = &fnic->fnic_stats.misc_stats;
1968        struct scsi_lun fc_lun;
1969        int ret = 0;
1970        unsigned long intr_flags;
1971
1972        spin_lock_irqsave(host->host_lock, intr_flags);
1973        if (unlikely(fnic_chk_state_flags_locked(fnic,
1974                                                FNIC_FLAGS_IO_BLOCKED))) {
1975                spin_unlock_irqrestore(host->host_lock, intr_flags);
1976                return FAILED;
1977        } else
1978                atomic_inc(&fnic->in_flight);
1979        spin_unlock_irqrestore(host->host_lock, intr_flags);
1980
1981        spin_lock_irqsave(&fnic->wq_copy_lock[0], intr_flags);
1982
1983        if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
1984                free_wq_copy_descs(fnic, wq);
1985
1986        if (!vnic_wq_copy_desc_avail(wq)) {
1987                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
1988                          "queue_dr_io_req failure - no descriptors\n");
1989                atomic64_inc(&misc_stats->devrst_cpwq_alloc_failures);
1990                ret = -EAGAIN;
1991                goto lr_io_req_end;
1992        }
1993
1994        /* fill in the lun info */
1995        int_to_scsilun(sc->device->lun, &fc_lun);
1996
1997        fnic_queue_wq_copy_desc_itmf(wq, sc->request->tag | FNIC_TAG_DEV_RST,
1998                                     0, FCPIO_ITMF_LUN_RESET, SCSI_NO_TAG,
1999                                     fc_lun.scsi_lun, io_req->port_id,
2000                                     fnic->config.ra_tov, fnic->config.ed_tov);
2001
2002        atomic64_inc(&fnic->fnic_stats.fw_stats.active_fw_reqs);
2003        if (atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs) >
2004                  atomic64_read(&fnic->fnic_stats.fw_stats.max_fw_reqs))
2005                atomic64_set(&fnic->fnic_stats.fw_stats.max_fw_reqs,
2006                  atomic64_read(&fnic->fnic_stats.fw_stats.active_fw_reqs));
2007
2008lr_io_req_end:
2009        spin_unlock_irqrestore(&fnic->wq_copy_lock[0], intr_flags);
2010        atomic_dec(&fnic->in_flight);
2011
2012        return ret;
2013}
2014
2015struct fnic_pending_aborts_iter_data {
2016        struct fnic *fnic;
2017        struct scsi_cmnd *lr_sc;
2018        struct scsi_device *lun_dev;
2019        int ret;
2020};
2021
2022static bool fnic_pending_aborts_iter(struct scsi_cmnd *sc,
2023                                     void *data, bool reserved)
2024{
2025        struct fnic_pending_aborts_iter_data *iter_data = data;
2026        struct fnic *fnic = iter_data->fnic;
2027        struct scsi_device *lun_dev = iter_data->lun_dev;
2028        int abt_tag = sc->request->tag;
2029        struct fnic_io_req *io_req;
2030        spinlock_t *io_lock;
2031        unsigned long flags;
2032        struct scsi_lun fc_lun;
2033        DECLARE_COMPLETION_ONSTACK(tm_done);
2034        enum fnic_ioreq_state old_ioreq_state;
2035
2036        if (sc == iter_data->lr_sc || sc->device != lun_dev)
2037                return true;
2038        if (reserved)
2039                return true;
2040
2041        io_lock = fnic_io_lock_tag(fnic, abt_tag);
2042        spin_lock_irqsave(io_lock, flags);
2043        io_req = (struct fnic_io_req *)CMD_SP(sc);
2044        if (!io_req) {
2045                spin_unlock_irqrestore(io_lock, flags);
2046                return true;
2047        }
2048
2049        /*
2050         * Found IO that is still pending with firmware and
2051         * belongs to the LUN that we are resetting
2052         */
2053        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2054                      "Found IO in %s on lun\n",
2055                      fnic_ioreq_state_to_str(CMD_STATE(sc)));
2056
2057        if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING) {
2058                spin_unlock_irqrestore(io_lock, flags);
2059                return true;
2060        }
2061        if ((CMD_FLAGS(sc) & FNIC_DEVICE_RESET) &&
2062            (!(CMD_FLAGS(sc) & FNIC_DEV_RST_ISSUED))) {
2063                FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
2064                              "%s dev rst not pending sc 0x%p\n", __func__,
2065                              sc);
2066                spin_unlock_irqrestore(io_lock, flags);
2067                return true;
2068        }
2069
2070        if (io_req->abts_done)
2071                shost_printk(KERN_ERR, fnic->lport->host,
2072                             "%s: io_req->abts_done is set state is %s\n",
2073                             __func__, fnic_ioreq_state_to_str(CMD_STATE(sc)));
2074        old_ioreq_state = CMD_STATE(sc);
2075        /*
2076         * Any pending IO issued prior to reset is expected to be
2077         * in abts pending state, if not we need to set
2078         * FNIC_IOREQ_ABTS_PENDING to indicate the IO is abort pending.
2079         * When IO is completed, the IO will be handed over and
2080         * handled in this function.
2081         */
2082        CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
2083
2084        BUG_ON(io_req->abts_done);
2085
2086        if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET) {
2087                abt_tag |= FNIC_TAG_DEV_RST;
2088                FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
2089                              "%s: dev rst sc 0x%p\n", __func__, sc);
2090        }
2091
2092        CMD_ABTS_STATUS(sc) = FCPIO_INVALID_CODE;
2093        io_req->abts_done = &tm_done;
2094        spin_unlock_irqrestore(io_lock, flags);
2095
2096        /* Now queue the abort command to firmware */
2097        int_to_scsilun(sc->device->lun, &fc_lun);
2098
2099        if (fnic_queue_abort_io_req(fnic, abt_tag,
2100                                    FCPIO_ITMF_ABT_TASK_TERM,
2101                                    fc_lun.scsi_lun, io_req)) {
2102                spin_lock_irqsave(io_lock, flags);
2103                io_req = (struct fnic_io_req *)CMD_SP(sc);
2104                if (io_req)
2105                        io_req->abts_done = NULL;
2106                if (CMD_STATE(sc) == FNIC_IOREQ_ABTS_PENDING)
2107                        CMD_STATE(sc) = old_ioreq_state;
2108                spin_unlock_irqrestore(io_lock, flags);
2109                iter_data->ret = FAILED;
2110                return false;
2111        } else {
2112                spin_lock_irqsave(io_lock, flags);
2113                if (CMD_FLAGS(sc) & FNIC_DEVICE_RESET)
2114                        CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
2115                spin_unlock_irqrestore(io_lock, flags);
2116        }
2117        CMD_FLAGS(sc) |= FNIC_IO_INTERNAL_TERM_ISSUED;
2118
2119        wait_for_completion_timeout(&tm_done, msecs_to_jiffies
2120                                    (fnic->config.ed_tov));
2121
2122        /* Recheck cmd state to check if it is now aborted */
2123        spin_lock_irqsave(io_lock, flags);
2124        io_req = (struct fnic_io_req *)CMD_SP(sc);
2125        if (!io_req) {
2126                spin_unlock_irqrestore(io_lock, flags);
2127                CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_REQ_NULL;
2128                return true;
2129        }
2130
2131        io_req->abts_done = NULL;
2132
2133        /* if abort is still pending with fw, fail */
2134        if (CMD_ABTS_STATUS(sc) == FCPIO_INVALID_CODE) {
2135                spin_unlock_irqrestore(io_lock, flags);
2136                CMD_FLAGS(sc) |= FNIC_IO_ABT_TERM_DONE;
2137                iter_data->ret = FAILED;
2138                return false;
2139        }
2140        CMD_STATE(sc) = FNIC_IOREQ_ABTS_COMPLETE;
2141
2142        /* original sc used for lr is handled by dev reset code */
2143        if (sc != iter_data->lr_sc)
2144                CMD_SP(sc) = NULL;
2145        spin_unlock_irqrestore(io_lock, flags);
2146
2147        /* original sc used for lr is handled by dev reset code */
2148        if (sc != iter_data->lr_sc) {
2149                fnic_release_ioreq_buf(fnic, io_req, sc);
2150                mempool_free(io_req, fnic->io_req_pool);
2151        }
2152
2153        /*
2154         * Any IO is returned during reset, it needs to call scsi_done
2155         * to return the scsi_cmnd to upper layer.
2156         */
2157        if (sc->scsi_done) {
2158                /* Set result to let upper SCSI layer retry */
2159                sc->result = DID_RESET << 16;
2160                sc->scsi_done(sc);
2161        }
2162        return true;
2163}
2164
2165/*
2166 * Clean up any pending aborts on the lun
2167 * For each outstanding IO on this lun, whose abort is not completed by fw,
2168 * issue a local abort. Wait for abort to complete. Return 0 if all commands
2169 * successfully aborted, 1 otherwise
2170 */
2171static int fnic_clean_pending_aborts(struct fnic *fnic,
2172                                     struct scsi_cmnd *lr_sc,
2173                                     bool new_sc)
2174
2175{
2176        int ret = SUCCESS;
2177        struct fnic_pending_aborts_iter_data iter_data = {
2178                .fnic = fnic,
2179                .lun_dev = lr_sc->device,
2180                .ret = SUCCESS,
2181        };
2182
2183        if (new_sc)
2184                iter_data.lr_sc = lr_sc;
2185
2186        scsi_host_busy_iter(fnic->lport->host,
2187                            fnic_pending_aborts_iter, &iter_data);
2188        if (iter_data.ret == FAILED) {
2189                ret = iter_data.ret;
2190                goto clean_pending_aborts_end;
2191        }
2192        schedule_timeout(msecs_to_jiffies(2 * fnic->config.ed_tov));
2193
2194        /* walk again to check, if IOs are still pending in fw */
2195        if (fnic_is_abts_pending(fnic, lr_sc))
2196                ret = FAILED;
2197
2198clean_pending_aborts_end:
2199        return ret;
2200}
2201
2202/*
2203 * fnic_scsi_host_start_tag
2204 * Allocates tagid from host's tag list
2205 **/
2206static inline int
2207fnic_scsi_host_start_tag(struct fnic *fnic, struct scsi_cmnd *sc)
2208{
2209        struct request_queue *q = sc->request->q;
2210        struct request *dummy;
2211
2212        dummy = blk_mq_alloc_request(q, REQ_OP_WRITE, BLK_MQ_REQ_NOWAIT);
2213        if (IS_ERR(dummy))
2214                return SCSI_NO_TAG;
2215
2216        sc->tag = sc->request->tag = dummy->tag;
2217        sc->host_scribble = (unsigned char *)dummy;
2218
2219        return dummy->tag;
2220}
2221
2222/*
2223 * fnic_scsi_host_end_tag
2224 * frees tag allocated by fnic_scsi_host_start_tag.
2225 **/
2226static inline void
2227fnic_scsi_host_end_tag(struct fnic *fnic, struct scsi_cmnd *sc)
2228{
2229        struct request *dummy = (struct request *)sc->host_scribble;
2230
2231        blk_mq_free_request(dummy);
2232}
2233
2234/*
2235 * SCSI Eh thread issues a Lun Reset when one or more commands on a LUN
2236 * fail to get aborted. It calls driver's eh_device_reset with a SCSI command
2237 * on the LUN.
2238 */
2239int fnic_device_reset(struct scsi_cmnd *sc)
2240{
2241        struct fc_lport *lp;
2242        struct fnic *fnic;
2243        struct fnic_io_req *io_req = NULL;
2244        struct fc_rport *rport;
2245        int status;
2246        int ret = FAILED;
2247        spinlock_t *io_lock;
2248        unsigned long flags;
2249        unsigned long start_time = 0;
2250        struct scsi_lun fc_lun;
2251        struct fnic_stats *fnic_stats;
2252        struct reset_stats *reset_stats;
2253        int tag = 0;
2254        DECLARE_COMPLETION_ONSTACK(tm_done);
2255        int tag_gen_flag = 0;   /*to track tags allocated by fnic driver*/
2256        bool new_sc = 0;
2257
2258        /* Wait for rport to unblock */
2259        fc_block_scsi_eh(sc);
2260
2261        /* Get local-port, check ready and link up */
2262        lp = shost_priv(sc->device->host);
2263
2264        fnic = lport_priv(lp);
2265        fnic_stats = &fnic->fnic_stats;
2266        reset_stats = &fnic->fnic_stats.reset_stats;
2267
2268        atomic64_inc(&reset_stats->device_resets);
2269
2270        rport = starget_to_rport(scsi_target(sc->device));
2271        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2272                      "Device reset called FCID 0x%x, LUN 0x%llx sc 0x%p\n",
2273                      rport->port_id, sc->device->lun, sc);
2274
2275        if (lp->state != LPORT_ST_READY || !(lp->link_up))
2276                goto fnic_device_reset_end;
2277
2278        /* Check if remote port up */
2279        if (fc_remote_port_chkready(rport)) {
2280                atomic64_inc(&fnic_stats->misc_stats.rport_not_ready);
2281                goto fnic_device_reset_end;
2282        }
2283
2284        CMD_FLAGS(sc) = FNIC_DEVICE_RESET;
2285        /* Allocate tag if not present */
2286
2287        tag = sc->request->tag;
2288        if (unlikely(tag < 0)) {
2289                /*
2290                 * Really should fix the midlayer to pass in a proper
2291                 * request for ioctls...
2292                 */
2293                tag = fnic_scsi_host_start_tag(fnic, sc);
2294                if (unlikely(tag == SCSI_NO_TAG))
2295                        goto fnic_device_reset_end;
2296                tag_gen_flag = 1;
2297                new_sc = 1;
2298        }
2299        io_lock = fnic_io_lock_hash(fnic, sc);
2300        spin_lock_irqsave(io_lock, flags);
2301        io_req = (struct fnic_io_req *)CMD_SP(sc);
2302
2303        /*
2304         * If there is a io_req attached to this command, then use it,
2305         * else allocate a new one.
2306         */
2307        if (!io_req) {
2308                io_req = mempool_alloc(fnic->io_req_pool, GFP_ATOMIC);
2309                if (!io_req) {
2310                        spin_unlock_irqrestore(io_lock, flags);
2311                        goto fnic_device_reset_end;
2312                }
2313                memset(io_req, 0, sizeof(*io_req));
2314                io_req->port_id = rport->port_id;
2315                CMD_SP(sc) = (char *)io_req;
2316        }
2317        io_req->dr_done = &tm_done;
2318        CMD_STATE(sc) = FNIC_IOREQ_CMD_PENDING;
2319        CMD_LR_STATUS(sc) = FCPIO_INVALID_CODE;
2320        spin_unlock_irqrestore(io_lock, flags);
2321
2322        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host, "TAG %x\n", tag);
2323
2324        /*
2325         * issue the device reset, if enqueue failed, clean up the ioreq
2326         * and break assoc with scsi cmd
2327         */
2328        if (fnic_queue_dr_io_req(fnic, sc, io_req)) {
2329                spin_lock_irqsave(io_lock, flags);
2330                io_req = (struct fnic_io_req *)CMD_SP(sc);
2331                if (io_req)
2332                        io_req->dr_done = NULL;
2333                goto fnic_device_reset_clean;
2334        }
2335        spin_lock_irqsave(io_lock, flags);
2336        CMD_FLAGS(sc) |= FNIC_DEV_RST_ISSUED;
2337        spin_unlock_irqrestore(io_lock, flags);
2338
2339        /*
2340         * Wait on the local completion for LUN reset.  The io_req may be
2341         * freed while we wait since we hold no lock.
2342         */
2343        wait_for_completion_timeout(&tm_done,
2344                                    msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
2345
2346        spin_lock_irqsave(io_lock, flags);
2347        io_req = (struct fnic_io_req *)CMD_SP(sc);
2348        if (!io_req) {
2349                spin_unlock_irqrestore(io_lock, flags);
2350                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2351                                "io_req is null tag 0x%x sc 0x%p\n", tag, sc);
2352                goto fnic_device_reset_end;
2353        }
2354        io_req->dr_done = NULL;
2355
2356        status = CMD_LR_STATUS(sc);
2357
2358        /*
2359         * If lun reset not completed, bail out with failed. io_req
2360         * gets cleaned up during higher levels of EH
2361         */
2362        if (status == FCPIO_INVALID_CODE) {
2363                atomic64_inc(&reset_stats->device_reset_timeouts);
2364                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2365                              "Device reset timed out\n");
2366                CMD_FLAGS(sc) |= FNIC_DEV_RST_TIMED_OUT;
2367                spin_unlock_irqrestore(io_lock, flags);
2368                int_to_scsilun(sc->device->lun, &fc_lun);
2369                /*
2370                 * Issue abort and terminate on device reset request.
2371                 * If q'ing of terminate fails, retry it after a delay.
2372                 */
2373                while (1) {
2374                        spin_lock_irqsave(io_lock, flags);
2375                        if (CMD_FLAGS(sc) & FNIC_DEV_RST_TERM_ISSUED) {
2376                                spin_unlock_irqrestore(io_lock, flags);
2377                                break;
2378                        }
2379                        spin_unlock_irqrestore(io_lock, flags);
2380                        if (fnic_queue_abort_io_req(fnic,
2381                                tag | FNIC_TAG_DEV_RST,
2382                                FCPIO_ITMF_ABT_TASK_TERM,
2383                                fc_lun.scsi_lun, io_req)) {
2384                                wait_for_completion_timeout(&tm_done,
2385                                msecs_to_jiffies(FNIC_ABT_TERM_DELAY_TIMEOUT));
2386                        } else {
2387                                spin_lock_irqsave(io_lock, flags);
2388                                CMD_FLAGS(sc) |= FNIC_DEV_RST_TERM_ISSUED;
2389                                CMD_STATE(sc) = FNIC_IOREQ_ABTS_PENDING;
2390                                io_req->abts_done = &tm_done;
2391                                spin_unlock_irqrestore(io_lock, flags);
2392                                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2393                                "Abort and terminate issued on Device reset "
2394                                "tag 0x%x sc 0x%p\n", tag, sc);
2395                                break;
2396                        }
2397                }
2398                while (1) {
2399                        spin_lock_irqsave(io_lock, flags);
2400                        if (!(CMD_FLAGS(sc) & FNIC_DEV_RST_DONE)) {
2401                                spin_unlock_irqrestore(io_lock, flags);
2402                                wait_for_completion_timeout(&tm_done,
2403                                msecs_to_jiffies(FNIC_LUN_RESET_TIMEOUT));
2404                                break;
2405                        } else {
2406                                io_req = (struct fnic_io_req *)CMD_SP(sc);
2407                                io_req->abts_done = NULL;
2408                                goto fnic_device_reset_clean;
2409                        }
2410                }
2411        } else {
2412                spin_unlock_irqrestore(io_lock, flags);
2413        }
2414
2415        /* Completed, but not successful, clean up the io_req, return fail */
2416        if (status != FCPIO_SUCCESS) {
2417                spin_lock_irqsave(io_lock, flags);
2418                FNIC_SCSI_DBG(KERN_DEBUG,
2419                              fnic->lport->host,
2420                              "Device reset completed - failed\n");
2421                io_req = (struct fnic_io_req *)CMD_SP(sc);
2422                goto fnic_device_reset_clean;
2423        }
2424
2425        /*
2426         * Clean up any aborts on this lun that have still not
2427         * completed. If any of these fail, then LUN reset fails.
2428         * clean_pending_aborts cleans all cmds on this lun except
2429         * the lun reset cmd. If all cmds get cleaned, the lun reset
2430         * succeeds
2431         */
2432        if (fnic_clean_pending_aborts(fnic, sc, new_sc)) {
2433                spin_lock_irqsave(io_lock, flags);
2434                io_req = (struct fnic_io_req *)CMD_SP(sc);
2435                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2436                              "Device reset failed"
2437                              " since could not abort all IOs\n");
2438                goto fnic_device_reset_clean;
2439        }
2440
2441        /* Clean lun reset command */
2442        spin_lock_irqsave(io_lock, flags);
2443        io_req = (struct fnic_io_req *)CMD_SP(sc);
2444        if (io_req)
2445                /* Completed, and successful */
2446                ret = SUCCESS;
2447
2448fnic_device_reset_clean:
2449        if (io_req)
2450                CMD_SP(sc) = NULL;
2451
2452        spin_unlock_irqrestore(io_lock, flags);
2453
2454        if (io_req) {
2455                start_time = io_req->start_time;
2456                fnic_release_ioreq_buf(fnic, io_req, sc);
2457                mempool_free(io_req, fnic->io_req_pool);
2458        }
2459
2460fnic_device_reset_end:
2461        FNIC_TRACE(fnic_device_reset, sc->device->host->host_no,
2462                  sc->request->tag, sc,
2463                  jiffies_to_msecs(jiffies - start_time),
2464                  0, ((u64)sc->cmnd[0] << 32 |
2465                  (u64)sc->cmnd[2] << 24 | (u64)sc->cmnd[3] << 16 |
2466                  (u64)sc->cmnd[4] << 8 | sc->cmnd[5]),
2467                  (((u64)CMD_FLAGS(sc) << 32) | CMD_STATE(sc)));
2468
2469        /* free tag if it is allocated */
2470        if (unlikely(tag_gen_flag))
2471                fnic_scsi_host_end_tag(fnic, sc);
2472
2473        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2474                      "Returning from device reset %s\n",
2475                      (ret == SUCCESS) ?
2476                      "SUCCESS" : "FAILED");
2477
2478        if (ret == FAILED)
2479                atomic64_inc(&reset_stats->device_reset_failures);
2480
2481        return ret;
2482}
2483
2484/* Clean up all IOs, clean up libFC local port */
2485int fnic_reset(struct Scsi_Host *shost)
2486{
2487        struct fc_lport *lp;
2488        struct fnic *fnic;
2489        int ret = 0;
2490        struct reset_stats *reset_stats;
2491
2492        lp = shost_priv(shost);
2493        fnic = lport_priv(lp);
2494        reset_stats = &fnic->fnic_stats.reset_stats;
2495
2496        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2497                      "fnic_reset called\n");
2498
2499        atomic64_inc(&reset_stats->fnic_resets);
2500
2501        /*
2502         * Reset local port, this will clean up libFC exchanges,
2503         * reset remote port sessions, and if link is up, begin flogi
2504         */
2505        ret = fc_lport_reset(lp);
2506
2507        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2508                      "Returning from fnic reset %s\n",
2509                      (ret == 0) ?
2510                      "SUCCESS" : "FAILED");
2511
2512        if (ret == 0)
2513                atomic64_inc(&reset_stats->fnic_reset_completions);
2514        else
2515                atomic64_inc(&reset_stats->fnic_reset_failures);
2516
2517        return ret;
2518}
2519
2520/*
2521 * SCSI Error handling calls driver's eh_host_reset if all prior
2522 * error handling levels return FAILED. If host reset completes
2523 * successfully, and if link is up, then Fabric login begins.
2524 *
2525 * Host Reset is the highest level of error recovery. If this fails, then
2526 * host is offlined by SCSI.
2527 *
2528 */
2529int fnic_host_reset(struct scsi_cmnd *sc)
2530{
2531        int ret;
2532        unsigned long wait_host_tmo;
2533        struct Scsi_Host *shost = sc->device->host;
2534        struct fc_lport *lp = shost_priv(shost);
2535        struct fnic *fnic = lport_priv(lp);
2536        unsigned long flags;
2537
2538        spin_lock_irqsave(&fnic->fnic_lock, flags);
2539        if (!fnic->internal_reset_inprogress) {
2540                fnic->internal_reset_inprogress = true;
2541        } else {
2542                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2543                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2544                        "host reset in progress skipping another host reset\n");
2545                return SUCCESS;
2546        }
2547        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2548
2549        /*
2550         * If fnic_reset is successful, wait for fabric login to complete
2551         * scsi-ml tries to send a TUR to every device if host reset is
2552         * successful, so before returning to scsi, fabric should be up
2553         */
2554        ret = (fnic_reset(shost) == 0) ? SUCCESS : FAILED;
2555        if (ret == SUCCESS) {
2556                wait_host_tmo = jiffies + FNIC_HOST_RESET_SETTLE_TIME * HZ;
2557                ret = FAILED;
2558                while (time_before(jiffies, wait_host_tmo)) {
2559                        if ((lp->state == LPORT_ST_READY) &&
2560                            (lp->link_up)) {
2561                                ret = SUCCESS;
2562                                break;
2563                        }
2564                        ssleep(1);
2565                }
2566        }
2567
2568        spin_lock_irqsave(&fnic->fnic_lock, flags);
2569        fnic->internal_reset_inprogress = false;
2570        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2571        return ret;
2572}
2573
2574/*
2575 * This fxn is called from libFC when host is removed
2576 */
2577void fnic_scsi_abort_io(struct fc_lport *lp)
2578{
2579        int err = 0;
2580        unsigned long flags;
2581        enum fnic_state old_state;
2582        struct fnic *fnic = lport_priv(lp);
2583        DECLARE_COMPLETION_ONSTACK(remove_wait);
2584
2585        /* Issue firmware reset for fnic, wait for reset to complete */
2586retry_fw_reset:
2587        spin_lock_irqsave(&fnic->fnic_lock, flags);
2588        if (unlikely(fnic->state == FNIC_IN_FC_TRANS_ETH_MODE) &&
2589                     fnic->link_events) {
2590                /* fw reset is in progress, poll for its completion */
2591                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2592                schedule_timeout(msecs_to_jiffies(100));
2593                goto retry_fw_reset;
2594        }
2595
2596        fnic->remove_wait = &remove_wait;
2597        old_state = fnic->state;
2598        fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
2599        fnic_update_mac_locked(fnic, fnic->ctlr.ctl_src_addr);
2600        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2601
2602        err = fnic_fw_reset_handler(fnic);
2603        if (err) {
2604                spin_lock_irqsave(&fnic->fnic_lock, flags);
2605                if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE)
2606                        fnic->state = old_state;
2607                fnic->remove_wait = NULL;
2608                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2609                return;
2610        }
2611
2612        /* Wait for firmware reset to complete */
2613        wait_for_completion_timeout(&remove_wait,
2614                                    msecs_to_jiffies(FNIC_RMDEVICE_TIMEOUT));
2615
2616        spin_lock_irqsave(&fnic->fnic_lock, flags);
2617        fnic->remove_wait = NULL;
2618        FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
2619                      "fnic_scsi_abort_io %s\n",
2620                      (fnic->state == FNIC_IN_ETH_MODE) ?
2621                      "SUCCESS" : "FAILED");
2622        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2623
2624}
2625
2626/*
2627 * This fxn called from libFC to clean up driver IO state on link down
2628 */
2629void fnic_scsi_cleanup(struct fc_lport *lp)
2630{
2631        unsigned long flags;
2632        enum fnic_state old_state;
2633        struct fnic *fnic = lport_priv(lp);
2634
2635        /* issue fw reset */
2636retry_fw_reset:
2637        spin_lock_irqsave(&fnic->fnic_lock, flags);
2638        if (unlikely(fnic->state == FNIC_IN_FC_TRANS_ETH_MODE)) {
2639                /* fw reset is in progress, poll for its completion */
2640                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2641                schedule_timeout(msecs_to_jiffies(100));
2642                goto retry_fw_reset;
2643        }
2644        old_state = fnic->state;
2645        fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
2646        fnic_update_mac_locked(fnic, fnic->ctlr.ctl_src_addr);
2647        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2648
2649        if (fnic_fw_reset_handler(fnic)) {
2650                spin_lock_irqsave(&fnic->fnic_lock, flags);
2651                if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE)
2652                        fnic->state = old_state;
2653                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
2654        }
2655
2656}
2657
2658void fnic_empty_scsi_cleanup(struct fc_lport *lp)
2659{
2660}
2661
2662void fnic_exch_mgr_reset(struct fc_lport *lp, u32 sid, u32 did)
2663{
2664        struct fnic *fnic = lport_priv(lp);
2665
2666        /* Non-zero sid, nothing to do */
2667        if (sid)
2668                goto call_fc_exch_mgr_reset;
2669
2670        if (did) {
2671                fnic_rport_exch_reset(fnic, did);
2672                goto call_fc_exch_mgr_reset;
2673        }
2674
2675        /*
2676         * sid = 0, did = 0
2677         * link down or device being removed
2678         */
2679        if (!fnic->in_remove)
2680                fnic_scsi_cleanup(lp);
2681        else
2682                fnic_scsi_abort_io(lp);
2683
2684        /* call libFC exch mgr reset to reset its exchanges */
2685call_fc_exch_mgr_reset:
2686        fc_exch_mgr_reset(lp, sid, did);
2687
2688}
2689
2690static bool fnic_abts_pending_iter(struct scsi_cmnd *sc, void *data,
2691                                   bool reserved)
2692{
2693        struct fnic_pending_aborts_iter_data *iter_data = data;
2694        struct fnic *fnic = iter_data->fnic;
2695        int cmd_state;
2696        struct fnic_io_req *io_req;
2697        spinlock_t *io_lock;
2698        unsigned long flags;
2699
2700        /*
2701         * ignore this lun reset cmd or cmds that do not belong to
2702         * this lun
2703         */
2704        if (iter_data->lr_sc && sc == iter_data->lr_sc)
2705                return true;
2706        if (iter_data->lun_dev && sc->device != iter_data->lun_dev)
2707                return true;
2708
2709        io_lock = fnic_io_lock_hash(fnic, sc);
2710        spin_lock_irqsave(io_lock, flags);
2711
2712        io_req = (struct fnic_io_req *)CMD_SP(sc);
2713        if (!io_req) {
2714                spin_unlock_irqrestore(io_lock, flags);
2715                return true;
2716        }
2717
2718        /*
2719         * Found IO that is still pending with firmware and
2720         * belongs to the LUN that we are resetting
2721         */
2722        FNIC_SCSI_DBG(KERN_INFO, fnic->lport->host,
2723                      "Found IO in %s on lun\n",
2724                      fnic_ioreq_state_to_str(CMD_STATE(sc)));
2725        cmd_state = CMD_STATE(sc);
2726        spin_unlock_irqrestore(io_lock, flags);
2727        if (cmd_state == FNIC_IOREQ_ABTS_PENDING)
2728                iter_data->ret = 1;
2729
2730        return iter_data->ret ? false : true;
2731}
2732
2733/*
2734 * fnic_is_abts_pending() is a helper function that
2735 * walks through tag map to check if there is any IOs pending,if there is one,
2736 * then it returns 1 (true), otherwise 0 (false)
2737 * if @lr_sc is non NULL, then it checks IOs specific to particular LUN,
2738 * otherwise, it checks for all IOs.
2739 */
2740int fnic_is_abts_pending(struct fnic *fnic, struct scsi_cmnd *lr_sc)
2741{
2742        struct fnic_pending_aborts_iter_data iter_data = {
2743                .fnic = fnic,
2744                .lun_dev = NULL,
2745                .ret = 0,
2746        };
2747
2748        if (lr_sc) {
2749                iter_data.lun_dev = lr_sc->device;
2750                iter_data.lr_sc = lr_sc;
2751        }
2752
2753        /* walk again to check, if IOs are still pending in fw */
2754        scsi_host_busy_iter(fnic->lport->host,
2755                            fnic_abts_pending_iter, &iter_data);
2756
2757        return iter_data.ret;
2758}
2759