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