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