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