root/drivers/scsi/qedf/qedf_els.c

DEFINITIONS

1. qedf_initiate_els
2. qedf_process_els_compl
3. qedf_rrq_compl
4. qedf_send_rrq
5. qedf_process_l2_frame_compl
6. qedf_restart_rport
7. qedf_l2_els_compl
8. qedf_send_adisc
9. qedf_srr_compl
10. qedf_send_srr
11. qedf_initiate_seq_cleanup
12. qedf_process_seq_cleanup_compl
13. qedf_requeue_io_req
14. qedf_rec_compl
15. qedf_send_rec

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  QLogic FCoE Offload Driver
   4  *  Copyright (c) 2016-2018 Cavium Inc.
   5  */
   6 #include "qedf.h"
   7 
   8 /* It's assumed that the lock is held when calling this function. */
   9 static int qedf_initiate_els(struct qedf_rport *fcport, unsigned int op,
  10         void *data, uint32_t data_len,
  11         void (*cb_func)(struct qedf_els_cb_arg *cb_arg),
  12         struct qedf_els_cb_arg *cb_arg, uint32_t timer_msec)
  13 {
  14         struct qedf_ctx *qedf;
  15         struct fc_lport *lport;
  16         struct qedf_ioreq *els_req;
  17         struct qedf_mp_req *mp_req;
  18         struct fc_frame_header *fc_hdr;
  19         struct e4_fcoe_task_context *task;
  20         int rc = 0;
  21         uint32_t did, sid;
  22         uint16_t xid;
  23         struct fcoe_wqe *sqe;
  24         unsigned long flags;
  25         u16 sqe_idx;
  26 
  27         if (!fcport) {
  28                 QEDF_ERR(NULL, "fcport is NULL");
  29                 rc = -EINVAL;
  30                 goto els_err;
  31         }
  32 
  33         qedf = fcport->qedf;
  34         lport = qedf->lport;
  35 
  36         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "Sending ELS\n");
  37 
  38         rc = fc_remote_port_chkready(fcport->rport);
  39         if (rc) {
  40                 QEDF_ERR(&(qedf->dbg_ctx), "els 0x%x: rport not ready\n", op);
  41                 rc = -EAGAIN;
  42                 goto els_err;
  43         }
  44         if (lport->state != LPORT_ST_READY || !(lport->link_up)) {
  45                 QEDF_ERR(&(qedf->dbg_ctx), "els 0x%x: link is not ready\n",
  46                           op);
  47                 rc = -EAGAIN;
  48                 goto els_err;
  49         }
  50 
  51         if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
  52                 QEDF_ERR(&(qedf->dbg_ctx), "els 0x%x: fcport not ready\n", op);
  53                 rc = -EINVAL;
  54                 goto els_err;
  55         }
  56 
  57         els_req = qedf_alloc_cmd(fcport, QEDF_ELS);
  58         if (!els_req) {
  59                 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_ELS,
  60                           "Failed to alloc ELS request 0x%x\n", op);
  61                 rc = -ENOMEM;
  62                 goto els_err;
  63         }
  64 
  65         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "initiate_els els_req = "
  66                    "0x%p cb_arg = %p xid = %x\n", els_req, cb_arg,
  67                    els_req->xid);
  68         els_req->sc_cmd = NULL;
  69         els_req->cmd_type = QEDF_ELS;
  70         els_req->fcport = fcport;
  71         els_req->cb_func = cb_func;
  72         cb_arg->io_req = els_req;
  73         cb_arg->op = op;
  74         els_req->cb_arg = cb_arg;
  75         els_req->data_xfer_len = data_len;
  76 
  77         /* Record which cpu this request is associated with */
  78         els_req->cpu = smp_processor_id();
  79 
  80         mp_req = (struct qedf_mp_req *)&(els_req->mp_req);
  81         rc = qedf_init_mp_req(els_req);
  82         if (rc) {
  83                 QEDF_ERR(&(qedf->dbg_ctx), "ELS MP request init failed\n");
  84                 kref_put(&els_req->refcount, qedf_release_cmd);
  85                 goto els_err;
  86         } else {
  87                 rc = 0;
  88         }
  89 
  90         /* Fill ELS Payload */
  91         if ((op >= ELS_LS_RJT) && (op <= ELS_AUTH_ELS)) {
  92                 memcpy(mp_req->req_buf, data, data_len);
  93         } else {
  94                 QEDF_ERR(&(qedf->dbg_ctx), "Invalid ELS op 0x%x\n", op);
  95                 els_req->cb_func = NULL;
  96                 els_req->cb_arg = NULL;
  97                 kref_put(&els_req->refcount, qedf_release_cmd);
  98                 rc = -EINVAL;
  99         }
 100 
 101         if (rc)
 102                 goto els_err;
 103 
 104         /* Fill FC header */
 105         fc_hdr = &(mp_req->req_fc_hdr);
 106 
 107         did = fcport->rdata->ids.port_id;
 108         sid = fcport->sid;
 109 
 110         __fc_fill_fc_hdr(fc_hdr, FC_RCTL_ELS_REQ, did, sid,
 111                            FC_TYPE_ELS, FC_FC_FIRST_SEQ | FC_FC_END_SEQ |
 112                            FC_FC_SEQ_INIT, 0);
 113 
 114         /* Obtain exchange id */
 115         xid = els_req->xid;
 116 
 117         spin_lock_irqsave(&fcport->rport_lock, flags);
 118 
 119         sqe_idx = qedf_get_sqe_idx(fcport);
 120         sqe = &fcport->sq[sqe_idx];
 121         memset(sqe, 0, sizeof(struct fcoe_wqe));
 122 
 123         /* Initialize task context for this IO request */
 124         task = qedf_get_task_mem(&qedf->tasks, xid);
 125         qedf_init_mp_task(els_req, task, sqe);
 126 
 127         /* Put timer on original I/O request */
 128         if (timer_msec)
 129                 qedf_cmd_timer_set(qedf, els_req, timer_msec);
 130 
 131         /* Ring doorbell */
 132         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "Ringing doorbell for ELS "
 133                    "req\n");
 134         qedf_ring_doorbell(fcport);
 135         set_bit(QEDF_CMD_OUTSTANDING, &els_req->flags);
 136 
 137         spin_unlock_irqrestore(&fcport->rport_lock, flags);
 138 els_err:
 139         return rc;
 140 }
 141 
 142 void qedf_process_els_compl(struct qedf_ctx *qedf, struct fcoe_cqe *cqe,
 143         struct qedf_ioreq *els_req)
 144 {
 145         struct fcoe_cqe_midpath_info *mp_info;
 146 
 147         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "Entered with xid = 0x%x"
 148                    " cmd_type = %d.\n", els_req->xid, els_req->cmd_type);
 149 
 150         clear_bit(QEDF_CMD_OUTSTANDING, &els_req->flags);
 151 
 152         /* Kill the ELS timer */
 153         cancel_delayed_work(&els_req->timeout_work);
 154 
 155         /* Get ELS response length from CQE */
 156         mp_info = &cqe->cqe_info.midpath_info;
 157         els_req->mp_req.resp_len = mp_info->data_placement_size;
 158 
 159         /* Parse ELS response */
 160         if ((els_req->cb_func) && (els_req->cb_arg)) {
 161                 els_req->cb_func(els_req->cb_arg);
 162                 els_req->cb_arg = NULL;
 163         }
 164 
 165         kref_put(&els_req->refcount, qedf_release_cmd);
 166 }
 167 
 168 static void qedf_rrq_compl(struct qedf_els_cb_arg *cb_arg)
 169 {
 170         struct qedf_ioreq *orig_io_req;
 171         struct qedf_ioreq *rrq_req;
 172         struct qedf_ctx *qedf;
 173         int refcount;
 174 
 175         rrq_req = cb_arg->io_req;
 176         qedf = rrq_req->fcport->qedf;
 177 
 178         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "Entered.\n");
 179 
 180         orig_io_req = cb_arg->aborted_io_req;
 181 
 182         if (!orig_io_req) {
 183                 QEDF_ERR(&qedf->dbg_ctx,
 184                          "Original io_req is NULL, rrq_req = %p.\n", rrq_req);
 185                 goto out_free;
 186         }
 187 
 188         if (rrq_req->event != QEDF_IOREQ_EV_ELS_TMO &&
 189             rrq_req->event != QEDF_IOREQ_EV_ELS_ERR_DETECT)
 190                 cancel_delayed_work_sync(&orig_io_req->timeout_work);
 191 
 192         refcount = kref_read(&orig_io_req->refcount);
 193         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "rrq_compl: orig io = %p,"
 194                    " orig xid = 0x%x, rrq_xid = 0x%x, refcount=%d\n",
 195                    orig_io_req, orig_io_req->xid, rrq_req->xid, refcount);
 196 
 197         /*
 198          * This should return the aborted io_req to the command pool. Note that
 199          * we need to check the refcound in case the original request was
 200          * flushed but we get a completion on this xid.
 201          */
 202         if (orig_io_req && refcount > 0)
 203                 kref_put(&orig_io_req->refcount, qedf_release_cmd);
 204 
 205 out_free:
 206         /*
 207          * Release a reference to the rrq request if we timed out as the
 208          * rrq completion handler is called directly from the timeout handler
 209          * and not from els_compl where the reference would have normally been
 210          * released.
 211          */
 212         if (rrq_req->event == QEDF_IOREQ_EV_ELS_TMO)
 213                 kref_put(&rrq_req->refcount, qedf_release_cmd);
 214         kfree(cb_arg);
 215 }
 216 
 217 /* Assumes kref is already held by caller */
 218 int qedf_send_rrq(struct qedf_ioreq *aborted_io_req)
 219 {
 220 
 221         struct fc_els_rrq rrq;
 222         struct qedf_rport *fcport;
 223         struct fc_lport *lport;
 224         struct qedf_els_cb_arg *cb_arg = NULL;
 225         struct qedf_ctx *qedf;
 226         uint32_t sid;
 227         uint32_t r_a_tov;
 228         int rc;
 229         int refcount;
 230 
 231         if (!aborted_io_req) {
 232                 QEDF_ERR(NULL, "abort_io_req is NULL.\n");
 233                 return -EINVAL;
 234         }
 235 
 236         fcport = aborted_io_req->fcport;
 237 
 238         if (!fcport) {
 239                 refcount = kref_read(&aborted_io_req->refcount);
 240                 QEDF_ERR(NULL,
 241                          "RRQ work was queued prior to a flush xid=0x%x, refcount=%d.\n",
 242                          aborted_io_req->xid, refcount);
 243                 kref_put(&aborted_io_req->refcount, qedf_release_cmd);
 244                 return -EINVAL;
 245         }
 246 
 247         /* Check that fcport is still offloaded */
 248         if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
 249                 QEDF_ERR(NULL, "fcport is no longer offloaded.\n");
 250                 return -EINVAL;
 251         }
 252 
 253         if (!fcport->qedf) {
 254                 QEDF_ERR(NULL, "fcport->qedf is NULL.\n");
 255                 return -EINVAL;
 256         }
 257 
 258         qedf = fcport->qedf;
 259 
 260         /*
 261          * Sanity check that we can send a RRQ to make sure that refcount isn't
 262          * 0
 263          */
 264         refcount = kref_read(&aborted_io_req->refcount);
 265         if (refcount != 1) {
 266                 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_ELS,
 267                           "refcount for xid=%x io_req=%p refcount=%d is not 1.\n",
 268                           aborted_io_req->xid, aborted_io_req, refcount);
 269                 return -EINVAL;
 270         }
 271 
 272         lport = qedf->lport;
 273         sid = fcport->sid;
 274         r_a_tov = lport->r_a_tov;
 275 
 276         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "Sending RRQ orig "
 277                    "io = %p, orig_xid = 0x%x\n", aborted_io_req,
 278                    aborted_io_req->xid);
 279         memset(&rrq, 0, sizeof(rrq));
 280 
 281         cb_arg = kzalloc(sizeof(struct qedf_els_cb_arg), GFP_NOIO);
 282         if (!cb_arg) {
 283                 QEDF_ERR(&(qedf->dbg_ctx), "Unable to allocate cb_arg for "
 284                           "RRQ\n");
 285                 rc = -ENOMEM;
 286                 goto rrq_err;
 287         }
 288 
 289         cb_arg->aborted_io_req = aborted_io_req;
 290 
 291         rrq.rrq_cmd = ELS_RRQ;
 292         hton24(rrq.rrq_s_id, sid);
 293         rrq.rrq_ox_id = htons(aborted_io_req->xid);
 294         rrq.rrq_rx_id =
 295             htons(aborted_io_req->task->tstorm_st_context.read_write.rx_id);
 296 
 297         rc = qedf_initiate_els(fcport, ELS_RRQ, &rrq, sizeof(rrq),
 298             qedf_rrq_compl, cb_arg, r_a_tov);
 299 
 300 rrq_err:
 301         if (rc) {
 302                 QEDF_ERR(&(qedf->dbg_ctx), "RRQ failed - release orig io "
 303                           "req 0x%x\n", aborted_io_req->xid);
 304                 kfree(cb_arg);
 305                 kref_put(&aborted_io_req->refcount, qedf_release_cmd);
 306         }
 307         return rc;
 308 }
 309 
 310 static void qedf_process_l2_frame_compl(struct qedf_rport *fcport,
 311                                         struct fc_frame *fp,
 312                                         u16 l2_oxid)
 313 {
 314         struct fc_lport *lport = fcport->qedf->lport;
 315         struct fc_frame_header *fh;
 316         u32 crc;
 317 
 318         fh = (struct fc_frame_header *)fc_frame_header_get(fp);
 319 
 320         /* Set the OXID we return to what libfc used */
 321         if (l2_oxid != FC_XID_UNKNOWN)
 322                 fh->fh_ox_id = htons(l2_oxid);
 323 
 324         /* Setup header fields */
 325         fh->fh_r_ctl = FC_RCTL_ELS_REP;
 326         fh->fh_type = FC_TYPE_ELS;
 327         /* Last sequence, end sequence */
 328         fh->fh_f_ctl[0] = 0x98;
 329         hton24(fh->fh_d_id, lport->port_id);
 330         hton24(fh->fh_s_id, fcport->rdata->ids.port_id);
 331         fh->fh_rx_id = 0xffff;
 332 
 333         /* Set frame attributes */
 334         crc = fcoe_fc_crc(fp);
 335         fc_frame_init(fp);
 336         fr_dev(fp) = lport;
 337         fr_sof(fp) = FC_SOF_I3;
 338         fr_eof(fp) = FC_EOF_T;
 339         fr_crc(fp) = cpu_to_le32(~crc);
 340 
 341         /* Send completed request to libfc */
 342         fc_exch_recv(lport, fp);
 343 }
 344 
 345 /*
 346  * In instances where an ELS command times out we may need to restart the
 347  * rport by logging out and then logging back in.
 348  */
 349 void qedf_restart_rport(struct qedf_rport *fcport)
 350 {
 351         struct fc_lport *lport;
 352         struct fc_rport_priv *rdata;
 353         u32 port_id;
 354         unsigned long flags;
 355 
 356         if (!fcport) {
 357                 QEDF_ERR(NULL, "fcport is NULL.\n");
 358                 return;
 359         }
 360 
 361         spin_lock_irqsave(&fcport->rport_lock, flags);
 362         if (test_bit(QEDF_RPORT_IN_RESET, &fcport->flags) ||
 363             !test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags) ||
 364             test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags)) {
 365                 QEDF_ERR(&(fcport->qedf->dbg_ctx), "fcport %p already in reset or not offloaded.\n",
 366                     fcport);
 367                 spin_unlock_irqrestore(&fcport->rport_lock, flags);
 368                 return;
 369         }
 370 
 371         /* Set that we are now in reset */
 372         set_bit(QEDF_RPORT_IN_RESET, &fcport->flags);
 373         spin_unlock_irqrestore(&fcport->rport_lock, flags);
 374 
 375         rdata = fcport->rdata;
 376         if (rdata && !kref_get_unless_zero(&rdata->kref)) {
 377                 fcport->rdata = NULL;
 378                 rdata = NULL;
 379         }
 380 
 381         if (rdata && rdata->rp_state == RPORT_ST_READY) {
 382                 lport = fcport->qedf->lport;
 383                 port_id = rdata->ids.port_id;
 384                 QEDF_ERR(&(fcport->qedf->dbg_ctx),
 385                     "LOGO port_id=%x.\n", port_id);
 386                 fc_rport_logoff(rdata);
 387                 kref_put(&rdata->kref, fc_rport_destroy);
 388                 mutex_lock(&lport->disc.disc_mutex);
 389                 /* Recreate the rport and log back in */
 390                 rdata = fc_rport_create(lport, port_id);
 391                 if (rdata) {
 392                         mutex_unlock(&lport->disc.disc_mutex);
 393                         fc_rport_login(rdata);
 394                         fcport->rdata = rdata;
 395                 } else {
 396                         mutex_unlock(&lport->disc.disc_mutex);
 397                         fcport->rdata = NULL;
 398                 }
 399         }
 400         clear_bit(QEDF_RPORT_IN_RESET, &fcport->flags);
 401 }
 402 
 403 static void qedf_l2_els_compl(struct qedf_els_cb_arg *cb_arg)
 404 {
 405         struct qedf_ioreq *els_req;
 406         struct qedf_rport *fcport;
 407         struct qedf_mp_req *mp_req;
 408         struct fc_frame *fp;
 409         struct fc_frame_header *fh, *mp_fc_hdr;
 410         void *resp_buf, *fc_payload;
 411         u32 resp_len;
 412         u16 l2_oxid;
 413 
 414         l2_oxid = cb_arg->l2_oxid;
 415         els_req = cb_arg->io_req;
 416 
 417         if (!els_req) {
 418                 QEDF_ERR(NULL, "els_req is NULL.\n");
 419                 goto free_arg;
 420         }
 421 
 422         /*
 423          * If we are flushing the command just free the cb_arg as none of the
 424          * response data will be valid.
 425          */
 426         if (els_req->event == QEDF_IOREQ_EV_ELS_FLUSH) {
 427                 QEDF_ERR(NULL, "els_req xid=0x%x event is flush.\n",
 428                          els_req->xid);
 429                 goto free_arg;
 430         }
 431 
 432         fcport = els_req->fcport;
 433         mp_req = &(els_req->mp_req);
 434         mp_fc_hdr = &(mp_req->resp_fc_hdr);
 435         resp_len = mp_req->resp_len;
 436         resp_buf = mp_req->resp_buf;
 437 
 438         /*
 439          * If a middle path ELS command times out, don't try to return
 440          * the command but rather do any internal cleanup and then libfc
 441          * timeout the command and clean up its internal resources.
 442          */
 443         if (els_req->event == QEDF_IOREQ_EV_ELS_TMO) {
 444                 /*
 445                  * If ADISC times out, libfc will timeout the exchange and then
 446                  * try to send a PLOGI which will timeout since the session is
 447                  * still offloaded.  Force libfc to logout the session which
 448                  * will offload the connection and allow the PLOGI response to
 449                  * flow over the LL2 path.
 450                  */
 451                 if (cb_arg->op == ELS_ADISC)
 452                         qedf_restart_rport(fcport);
 453                 return;
 454         }
 455 
 456         if (sizeof(struct fc_frame_header) + resp_len > QEDF_PAGE_SIZE) {
 457                 QEDF_ERR(&(fcport->qedf->dbg_ctx), "resp_len is "
 458                    "beyond page size.\n");
 459                 goto free_arg;
 460         }
 461 
 462         fp = fc_frame_alloc(fcport->qedf->lport, resp_len);
 463         if (!fp) {
 464                 QEDF_ERR(&(fcport->qedf->dbg_ctx),
 465                     "fc_frame_alloc failure.\n");
 466                 return;
 467         }
 468 
 469         /* Copy frame header from firmware into fp */
 470         fh = (struct fc_frame_header *)fc_frame_header_get(fp);
 471         memcpy(fh, mp_fc_hdr, sizeof(struct fc_frame_header));
 472 
 473         /* Copy payload from firmware into fp */
 474         fc_payload = fc_frame_payload_get(fp, resp_len);
 475         memcpy(fc_payload, resp_buf, resp_len);
 476 
 477         QEDF_INFO(&(fcport->qedf->dbg_ctx), QEDF_LOG_ELS,
 478             "Completing OX_ID 0x%x back to libfc.\n", l2_oxid);
 479         qedf_process_l2_frame_compl(fcport, fp, l2_oxid);
 480 
 481 free_arg:
 482         kfree(cb_arg);
 483 }
 484 
 485 int qedf_send_adisc(struct qedf_rport *fcport, struct fc_frame *fp)
 486 {
 487         struct fc_els_adisc *adisc;
 488         struct fc_frame_header *fh;
 489         struct fc_lport *lport = fcport->qedf->lport;
 490         struct qedf_els_cb_arg *cb_arg = NULL;
 491         struct qedf_ctx *qedf;
 492         uint32_t r_a_tov = lport->r_a_tov;
 493         int rc;
 494 
 495         qedf = fcport->qedf;
 496         fh = fc_frame_header_get(fp);
 497 
 498         cb_arg = kzalloc(sizeof(struct qedf_els_cb_arg), GFP_NOIO);
 499         if (!cb_arg) {
 500                 QEDF_ERR(&(qedf->dbg_ctx), "Unable to allocate cb_arg for "
 501                           "ADISC\n");
 502                 rc = -ENOMEM;
 503                 goto adisc_err;
 504         }
 505         cb_arg->l2_oxid = ntohs(fh->fh_ox_id);
 506 
 507         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 508             "Sending ADISC ox_id=0x%x.\n", cb_arg->l2_oxid);
 509 
 510         adisc = fc_frame_payload_get(fp, sizeof(*adisc));
 511 
 512         rc = qedf_initiate_els(fcport, ELS_ADISC, adisc, sizeof(*adisc),
 513             qedf_l2_els_compl, cb_arg, r_a_tov);
 514 
 515 adisc_err:
 516         if (rc) {
 517                 QEDF_ERR(&(qedf->dbg_ctx), "ADISC failed.\n");
 518                 kfree(cb_arg);
 519         }
 520         return rc;
 521 }
 522 
 523 static void qedf_srr_compl(struct qedf_els_cb_arg *cb_arg)
 524 {
 525         struct qedf_ioreq *orig_io_req;
 526         struct qedf_ioreq *srr_req;
 527         struct qedf_mp_req *mp_req;
 528         struct fc_frame_header *mp_fc_hdr, *fh;
 529         struct fc_frame *fp;
 530         void *resp_buf, *fc_payload;
 531         u32 resp_len;
 532         struct fc_lport *lport;
 533         struct qedf_ctx *qedf;
 534         int refcount;
 535         u8 opcode;
 536 
 537         srr_req = cb_arg->io_req;
 538         qedf = srr_req->fcport->qedf;
 539         lport = qedf->lport;
 540 
 541         orig_io_req = cb_arg->aborted_io_req;
 542 
 543         if (!orig_io_req) {
 544                 QEDF_ERR(NULL, "orig_io_req is NULL.\n");
 545                 goto out_free;
 546         }
 547 
 548         clear_bit(QEDF_CMD_SRR_SENT, &orig_io_req->flags);
 549 
 550         if (srr_req->event != QEDF_IOREQ_EV_ELS_TMO &&
 551             srr_req->event != QEDF_IOREQ_EV_ELS_ERR_DETECT)
 552                 cancel_delayed_work_sync(&orig_io_req->timeout_work);
 553 
 554         refcount = kref_read(&orig_io_req->refcount);
 555         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "Entered: orig_io=%p,"
 556                    " orig_io_xid=0x%x, rec_xid=0x%x, refcount=%d\n",
 557                    orig_io_req, orig_io_req->xid, srr_req->xid, refcount);
 558 
 559         /* If a SRR times out, simply free resources */
 560         if (srr_req->event == QEDF_IOREQ_EV_ELS_TMO) {
 561                 QEDF_ERR(&qedf->dbg_ctx,
 562                          "ELS timeout rec_xid=0x%x.\n", srr_req->xid);
 563                 goto out_put;
 564         }
 565 
 566         /* Normalize response data into struct fc_frame */
 567         mp_req = &(srr_req->mp_req);
 568         mp_fc_hdr = &(mp_req->resp_fc_hdr);
 569         resp_len = mp_req->resp_len;
 570         resp_buf = mp_req->resp_buf;
 571 
 572         fp = fc_frame_alloc(lport, resp_len);
 573         if (!fp) {
 574                 QEDF_ERR(&(qedf->dbg_ctx),
 575                     "fc_frame_alloc failure.\n");
 576                 goto out_put;
 577         }
 578 
 579         /* Copy frame header from firmware into fp */
 580         fh = (struct fc_frame_header *)fc_frame_header_get(fp);
 581         memcpy(fh, mp_fc_hdr, sizeof(struct fc_frame_header));
 582 
 583         /* Copy payload from firmware into fp */
 584         fc_payload = fc_frame_payload_get(fp, resp_len);
 585         memcpy(fc_payload, resp_buf, resp_len);
 586 
 587         opcode = fc_frame_payload_op(fp);
 588         switch (opcode) {
 589         case ELS_LS_ACC:
 590                 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 591                     "SRR success.\n");
 592                 break;
 593         case ELS_LS_RJT:
 594                 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_ELS,
 595                     "SRR rejected.\n");
 596                 qedf_initiate_abts(orig_io_req, true);
 597                 break;
 598         }
 599 
 600         fc_frame_free(fp);
 601 out_put:
 602         /* Put reference for original command since SRR completed */
 603         kref_put(&orig_io_req->refcount, qedf_release_cmd);
 604 out_free:
 605         kfree(cb_arg);
 606 }
 607 
 608 static int qedf_send_srr(struct qedf_ioreq *orig_io_req, u32 offset, u8 r_ctl)
 609 {
 610         struct fcp_srr srr;
 611         struct qedf_ctx *qedf;
 612         struct qedf_rport *fcport;
 613         struct fc_lport *lport;
 614         struct qedf_els_cb_arg *cb_arg = NULL;
 615         u32 r_a_tov;
 616         int rc;
 617 
 618         if (!orig_io_req) {
 619                 QEDF_ERR(NULL, "orig_io_req is NULL.\n");
 620                 return -EINVAL;
 621         }
 622 
 623         fcport = orig_io_req->fcport;
 624 
 625         /* Check that fcport is still offloaded */
 626         if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
 627                 QEDF_ERR(NULL, "fcport is no longer offloaded.\n");
 628                 return -EINVAL;
 629         }
 630 
 631         if (!fcport->qedf) {
 632                 QEDF_ERR(NULL, "fcport->qedf is NULL.\n");
 633                 return -EINVAL;
 634         }
 635 
 636         /* Take reference until SRR command completion */
 637         kref_get(&orig_io_req->refcount);
 638 
 639         qedf = fcport->qedf;
 640         lport = qedf->lport;
 641         r_a_tov = lport->r_a_tov;
 642 
 643         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "Sending SRR orig_io=%p, "
 644                    "orig_xid=0x%x\n", orig_io_req, orig_io_req->xid);
 645         memset(&srr, 0, sizeof(srr));
 646 
 647         cb_arg = kzalloc(sizeof(struct qedf_els_cb_arg), GFP_NOIO);
 648         if (!cb_arg) {
 649                 QEDF_ERR(&(qedf->dbg_ctx), "Unable to allocate cb_arg for "
 650                           "SRR\n");
 651                 rc = -ENOMEM;
 652                 goto srr_err;
 653         }
 654 
 655         cb_arg->aborted_io_req = orig_io_req;
 656 
 657         srr.srr_op = ELS_SRR;
 658         srr.srr_ox_id = htons(orig_io_req->xid);
 659         srr.srr_rx_id = htons(orig_io_req->rx_id);
 660         srr.srr_rel_off = htonl(offset);
 661         srr.srr_r_ctl = r_ctl;
 662 
 663         rc = qedf_initiate_els(fcport, ELS_SRR, &srr, sizeof(srr),
 664             qedf_srr_compl, cb_arg, r_a_tov);
 665 
 666 srr_err:
 667         if (rc) {
 668                 QEDF_ERR(&(qedf->dbg_ctx), "SRR failed - release orig_io_req"
 669                           "=0x%x\n", orig_io_req->xid);
 670                 kfree(cb_arg);
 671                 /* If we fail to queue SRR, send ABTS to orig_io */
 672                 qedf_initiate_abts(orig_io_req, true);
 673                 kref_put(&orig_io_req->refcount, qedf_release_cmd);
 674         } else
 675                 /* Tell other threads that SRR is in progress */
 676                 set_bit(QEDF_CMD_SRR_SENT, &orig_io_req->flags);
 677 
 678         return rc;
 679 }
 680 
 681 static void qedf_initiate_seq_cleanup(struct qedf_ioreq *orig_io_req,
 682         u32 offset, u8 r_ctl)
 683 {
 684         struct qedf_rport *fcport;
 685         unsigned long flags;
 686         struct qedf_els_cb_arg *cb_arg;
 687         struct fcoe_wqe *sqe;
 688         u16 sqe_idx;
 689 
 690         fcport = orig_io_req->fcport;
 691 
 692         QEDF_INFO(&(fcport->qedf->dbg_ctx), QEDF_LOG_ELS,
 693             "Doing sequence cleanup for xid=0x%x offset=%u.\n",
 694             orig_io_req->xid, offset);
 695 
 696         cb_arg = kzalloc(sizeof(struct qedf_els_cb_arg), GFP_NOIO);
 697         if (!cb_arg) {
 698                 QEDF_ERR(&(fcport->qedf->dbg_ctx), "Unable to allocate cb_arg "
 699                           "for sequence cleanup\n");
 700                 return;
 701         }
 702 
 703         /* Get reference for cleanup request */
 704         kref_get(&orig_io_req->refcount);
 705 
 706         orig_io_req->cmd_type = QEDF_SEQ_CLEANUP;
 707         cb_arg->offset = offset;
 708         cb_arg->r_ctl = r_ctl;
 709         orig_io_req->cb_arg = cb_arg;
 710 
 711         qedf_cmd_timer_set(fcport->qedf, orig_io_req,
 712             QEDF_CLEANUP_TIMEOUT * HZ);
 713 
 714         spin_lock_irqsave(&fcport->rport_lock, flags);
 715 
 716         sqe_idx = qedf_get_sqe_idx(fcport);
 717         sqe = &fcport->sq[sqe_idx];
 718         memset(sqe, 0, sizeof(struct fcoe_wqe));
 719         orig_io_req->task_params->sqe = sqe;
 720 
 721         init_initiator_sequence_recovery_fcoe_task(orig_io_req->task_params,
 722                                                    offset);
 723         qedf_ring_doorbell(fcport);
 724 
 725         spin_unlock_irqrestore(&fcport->rport_lock, flags);
 726 }
 727 
 728 void qedf_process_seq_cleanup_compl(struct qedf_ctx *qedf,
 729         struct fcoe_cqe *cqe, struct qedf_ioreq *io_req)
 730 {
 731         int rc;
 732         struct qedf_els_cb_arg *cb_arg;
 733 
 734         cb_arg = io_req->cb_arg;
 735 
 736         /* If we timed out just free resources */
 737         if (io_req->event == QEDF_IOREQ_EV_ELS_TMO || !cqe) {
 738                 QEDF_ERR(&qedf->dbg_ctx,
 739                          "cqe is NULL or timeout event (0x%x)", io_req->event);
 740                 goto free;
 741         }
 742 
 743         /* Kill the timer we put on the request */
 744         cancel_delayed_work_sync(&io_req->timeout_work);
 745 
 746         rc = qedf_send_srr(io_req, cb_arg->offset, cb_arg->r_ctl);
 747         if (rc)
 748                 QEDF_ERR(&(qedf->dbg_ctx), "Unable to send SRR, I/O will "
 749                     "abort, xid=0x%x.\n", io_req->xid);
 750 free:
 751         kfree(cb_arg);
 752         kref_put(&io_req->refcount, qedf_release_cmd);
 753 }
 754 
 755 static bool qedf_requeue_io_req(struct qedf_ioreq *orig_io_req)
 756 {
 757         struct qedf_rport *fcport;
 758         struct qedf_ioreq *new_io_req;
 759         unsigned long flags;
 760         bool rc = false;
 761 
 762         fcport = orig_io_req->fcport;
 763         if (!fcport) {
 764                 QEDF_ERR(NULL, "fcport is NULL.\n");
 765                 goto out;
 766         }
 767 
 768         if (!orig_io_req->sc_cmd) {
 769                 QEDF_ERR(&(fcport->qedf->dbg_ctx), "sc_cmd is NULL for "
 770                     "xid=0x%x.\n", orig_io_req->xid);
 771                 goto out;
 772         }
 773 
 774         new_io_req = qedf_alloc_cmd(fcport, QEDF_SCSI_CMD);
 775         if (!new_io_req) {
 776                 QEDF_ERR(&(fcport->qedf->dbg_ctx), "Could not allocate new "
 777                     "io_req.\n");
 778                 goto out;
 779         }
 780 
 781         new_io_req->sc_cmd = orig_io_req->sc_cmd;
 782 
 783         /*
 784          * This keeps the sc_cmd struct from being returned to the tape
 785          * driver and being requeued twice. We do need to put a reference
 786          * for the original I/O request since we will not do a SCSI completion
 787          * for it.
 788          */
 789         orig_io_req->sc_cmd = NULL;
 790         kref_put(&orig_io_req->refcount, qedf_release_cmd);
 791 
 792         spin_lock_irqsave(&fcport->rport_lock, flags);
 793 
 794         /* kref for new command released in qedf_post_io_req on error */
 795         if (qedf_post_io_req(fcport, new_io_req)) {
 796                 QEDF_ERR(&(fcport->qedf->dbg_ctx), "Unable to post io_req\n");
 797                 /* Return SQE to pool */
 798                 atomic_inc(&fcport->free_sqes);
 799         } else {
 800                 QEDF_INFO(&(fcport->qedf->dbg_ctx), QEDF_LOG_ELS,
 801                     "Reissued SCSI command from  orig_xid=0x%x on "
 802                     "new_xid=0x%x.\n", orig_io_req->xid, new_io_req->xid);
 803                 /*
 804                  * Abort the original I/O but do not return SCSI command as
 805                  * it has been reissued on another OX_ID.
 806                  */
 807                 spin_unlock_irqrestore(&fcport->rport_lock, flags);
 808                 qedf_initiate_abts(orig_io_req, false);
 809                 goto out;
 810         }
 811 
 812         spin_unlock_irqrestore(&fcport->rport_lock, flags);
 813 out:
 814         return rc;
 815 }
 816 
 817 
 818 static void qedf_rec_compl(struct qedf_els_cb_arg *cb_arg)
 819 {
 820         struct qedf_ioreq *orig_io_req;
 821         struct qedf_ioreq *rec_req;
 822         struct qedf_mp_req *mp_req;
 823         struct fc_frame_header *mp_fc_hdr, *fh;
 824         struct fc_frame *fp;
 825         void *resp_buf, *fc_payload;
 826         u32 resp_len;
 827         struct fc_lport *lport;
 828         struct qedf_ctx *qedf;
 829         int refcount;
 830         enum fc_rctl r_ctl;
 831         struct fc_els_ls_rjt *rjt;
 832         struct fc_els_rec_acc *acc;
 833         u8 opcode;
 834         u32 offset, e_stat;
 835         struct scsi_cmnd *sc_cmd;
 836         bool srr_needed = false;
 837 
 838         rec_req = cb_arg->io_req;
 839         qedf = rec_req->fcport->qedf;
 840         lport = qedf->lport;
 841 
 842         orig_io_req = cb_arg->aborted_io_req;
 843 
 844         if (!orig_io_req) {
 845                 QEDF_ERR(NULL, "orig_io_req is NULL.\n");
 846                 goto out_free;
 847         }
 848 
 849         if (rec_req->event != QEDF_IOREQ_EV_ELS_TMO &&
 850             rec_req->event != QEDF_IOREQ_EV_ELS_ERR_DETECT)
 851                 cancel_delayed_work_sync(&orig_io_req->timeout_work);
 852 
 853         refcount = kref_read(&orig_io_req->refcount);
 854         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "Entered: orig_io=%p,"
 855                    " orig_io_xid=0x%x, rec_xid=0x%x, refcount=%d\n",
 856                    orig_io_req, orig_io_req->xid, rec_req->xid, refcount);
 857 
 858         /* If a REC times out, free resources */
 859         if (rec_req->event == QEDF_IOREQ_EV_ELS_TMO) {
 860                 QEDF_ERR(&qedf->dbg_ctx,
 861                          "Got TMO event, orig_io_req %p orig_io_xid=0x%x.\n",
 862                          orig_io_req, orig_io_req->xid);
 863                 goto out_put;
 864         }
 865 
 866         /* Normalize response data into struct fc_frame */
 867         mp_req = &(rec_req->mp_req);
 868         mp_fc_hdr = &(mp_req->resp_fc_hdr);
 869         resp_len = mp_req->resp_len;
 870         acc = resp_buf = mp_req->resp_buf;
 871 
 872         fp = fc_frame_alloc(lport, resp_len);
 873         if (!fp) {
 874                 QEDF_ERR(&(qedf->dbg_ctx),
 875                     "fc_frame_alloc failure.\n");
 876                 goto out_put;
 877         }
 878 
 879         /* Copy frame header from firmware into fp */
 880         fh = (struct fc_frame_header *)fc_frame_header_get(fp);
 881         memcpy(fh, mp_fc_hdr, sizeof(struct fc_frame_header));
 882 
 883         /* Copy payload from firmware into fp */
 884         fc_payload = fc_frame_payload_get(fp, resp_len);
 885         memcpy(fc_payload, resp_buf, resp_len);
 886 
 887         opcode = fc_frame_payload_op(fp);
 888         if (opcode == ELS_LS_RJT) {
 889                 rjt = fc_frame_payload_get(fp, sizeof(*rjt));
 890                 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 891                     "Received LS_RJT for REC: er_reason=0x%x, "
 892                     "er_explan=0x%x.\n", rjt->er_reason, rjt->er_explan);
 893                 /*
 894                  * The following response(s) mean that we need to reissue the
 895                  * request on another exchange.  We need to do this without
 896                  * informing the upper layers lest it cause an application
 897                  * error.
 898                  */
 899                 if ((rjt->er_reason == ELS_RJT_LOGIC ||
 900                     rjt->er_reason == ELS_RJT_UNAB) &&
 901                     rjt->er_explan == ELS_EXPL_OXID_RXID) {
 902                         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 903                             "Handle CMD LOST case.\n");
 904                         qedf_requeue_io_req(orig_io_req);
 905                 }
 906         } else if (opcode == ELS_LS_ACC) {
 907                 offset = ntohl(acc->reca_fc4value);
 908                 e_stat = ntohl(acc->reca_e_stat);
 909                 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 910                     "Received LS_ACC for REC: offset=0x%x, e_stat=0x%x.\n",
 911                     offset, e_stat);
 912                 if (e_stat & ESB_ST_SEQ_INIT)  {
 913                         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 914                             "Target has the seq init\n");
 915                         goto out_free_frame;
 916                 }
 917                 sc_cmd = orig_io_req->sc_cmd;
 918                 if (!sc_cmd) {
 919                         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 920                             "sc_cmd is NULL for xid=0x%x.\n",
 921                             orig_io_req->xid);
 922                         goto out_free_frame;
 923                 }
 924                 /* SCSI write case */
 925                 if (sc_cmd->sc_data_direction == DMA_TO_DEVICE) {
 926                         if (offset == orig_io_req->data_xfer_len) {
 927                                 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 928                                     "WRITE - response lost.\n");
 929                                 r_ctl = FC_RCTL_DD_CMD_STATUS;
 930                                 srr_needed = true;
 931                                 offset = 0;
 932                         } else {
 933                                 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 934                                     "WRITE - XFER_RDY/DATA lost.\n");
 935                                 r_ctl = FC_RCTL_DD_DATA_DESC;
 936                                 /* Use data from warning CQE instead of REC */
 937                                 offset = orig_io_req->tx_buf_off;
 938                         }
 939                 /* SCSI read case */
 940                 } else {
 941                         if (orig_io_req->rx_buf_off ==
 942                             orig_io_req->data_xfer_len) {
 943                                 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 944                                     "READ - response lost.\n");
 945                                 srr_needed = true;
 946                                 r_ctl = FC_RCTL_DD_CMD_STATUS;
 947                                 offset = 0;
 948                         } else {
 949                                 QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
 950                                     "READ - DATA lost.\n");
 951                                 /*
 952                                  * For read case we always set the offset to 0
 953                                  * for sequence recovery task.
 954                                  */
 955                                 offset = 0;
 956                                 r_ctl = FC_RCTL_DD_SOL_DATA;
 957                         }
 958                 }
 959 
 960                 if (srr_needed)
 961                         qedf_send_srr(orig_io_req, offset, r_ctl);
 962                 else
 963                         qedf_initiate_seq_cleanup(orig_io_req, offset, r_ctl);
 964         }
 965 
 966 out_free_frame:
 967         fc_frame_free(fp);
 968 out_put:
 969         /* Put reference for original command since REC completed */
 970         kref_put(&orig_io_req->refcount, qedf_release_cmd);
 971 out_free:
 972         kfree(cb_arg);
 973 }
 974 
 975 /* Assumes kref is already held by caller */
 976 int qedf_send_rec(struct qedf_ioreq *orig_io_req)
 977 {
 978 
 979         struct fc_els_rec rec;
 980         struct qedf_rport *fcport;
 981         struct fc_lport *lport;
 982         struct qedf_els_cb_arg *cb_arg = NULL;
 983         struct qedf_ctx *qedf;
 984         uint32_t sid;
 985         uint32_t r_a_tov;
 986         int rc;
 987 
 988         if (!orig_io_req) {
 989                 QEDF_ERR(NULL, "orig_io_req is NULL.\n");
 990                 return -EINVAL;
 991         }
 992 
 993         fcport = orig_io_req->fcport;
 994 
 995         /* Check that fcport is still offloaded */
 996         if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
 997                 QEDF_ERR(NULL, "fcport is no longer offloaded.\n");
 998                 return -EINVAL;
 999         }
1000 
1001         if (!fcport->qedf) {
1002                 QEDF_ERR(NULL, "fcport->qedf is NULL.\n");
1003                 return -EINVAL;
1004         }
1005 
1006         /* Take reference until REC command completion */
1007         kref_get(&orig_io_req->refcount);
1008 
1009         qedf = fcport->qedf;
1010         lport = qedf->lport;
1011         sid = fcport->sid;
1012         r_a_tov = lport->r_a_tov;
1013 
1014         memset(&rec, 0, sizeof(rec));
1015 
1016         cb_arg = kzalloc(sizeof(struct qedf_els_cb_arg), GFP_NOIO);
1017         if (!cb_arg) {
1018                 QEDF_ERR(&(qedf->dbg_ctx), "Unable to allocate cb_arg for "
1019                           "REC\n");
1020                 rc = -ENOMEM;
1021                 goto rec_err;
1022         }
1023 
1024         cb_arg->aborted_io_req = orig_io_req;
1025 
1026         rec.rec_cmd = ELS_REC;
1027         hton24(rec.rec_s_id, sid);
1028         rec.rec_ox_id = htons(orig_io_req->xid);
1029         rec.rec_rx_id =
1030             htons(orig_io_req->task->tstorm_st_context.read_write.rx_id);
1031 
1032         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS, "Sending REC orig_io=%p, "
1033            "orig_xid=0x%x rx_id=0x%x\n", orig_io_req,
1034            orig_io_req->xid, rec.rec_rx_id);
1035         rc = qedf_initiate_els(fcport, ELS_REC, &rec, sizeof(rec),
1036             qedf_rec_compl, cb_arg, r_a_tov);
1037 
1038 rec_err:
1039         if (rc) {
1040                 QEDF_ERR(&(qedf->dbg_ctx), "REC failed - release orig_io_req"
1041                           "=0x%x\n", orig_io_req->xid);
1042                 kfree(cb_arg);
1043                 kref_put(&orig_io_req->refcount, qedf_release_cmd);
1044         }
1045         return rc;
1046 }