?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / scsi / qedf / qedf_els.c
blob625e58ccb8c89f27d56ae7e178fe9621136e3c12
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 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 }
Linux with added FPC-III support