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