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