1 // SPDX-License-Identifier: GPL-2.0-only
2 // Copyright 2014 Cisco Systems, Inc. All rights reserved.
3
4 #include <linux/mempool.h>
5 #include <linux/errno.h>
6 #include <linux/init.h>
7 #include <linux/workqueue.h>
8 #include <linux/pci.h>
9 #include <linux/spinlock.h>
10 #include <linux/delay.h>
11 #include <linux/gfp.h>
12 #include <scsi/scsi.h>
13 #include <scsi/scsi_host.h>
14 #include <scsi/scsi_device.h>
15 #include <scsi/scsi_cmnd.h>
16 #include <scsi/scsi_tcq.h>
17 #include <scsi/scsi_dbg.h>
18
19 #include "snic_io.h"
20 #include "snic.h"
21
22 #define snic_cmd_tag(sc) (scsi_cmd_to_rq(sc)->tag)
23
24 const char *snic_state_str[] = {
25 [SNIC_INIT] = "SNIC_INIT",
26 [SNIC_ERROR] = "SNIC_ERROR",
27 [SNIC_ONLINE] = "SNIC_ONLINE",
28 [SNIC_OFFLINE] = "SNIC_OFFLINE",
29 [SNIC_FWRESET] = "SNIC_FWRESET",
30 };
31
32 static const char * const snic_req_state_str[] = {
33 [SNIC_IOREQ_NOT_INITED] = "SNIC_IOREQ_NOT_INITED",
34 [SNIC_IOREQ_PENDING] = "SNIC_IOREQ_PENDING",
35 [SNIC_IOREQ_ABTS_PENDING] = "SNIC_IOREQ_ABTS_PENDING",
36 [SNIC_IOREQ_ABTS_COMPLETE] = "SNIC_IOREQ_ABTS_COMPLETE",
37 [SNIC_IOREQ_LR_PENDING] = "SNIC_IOREQ_LR_PENDING",
38 [SNIC_IOREQ_LR_COMPLETE] = "SNIC_IOREQ_LR_COMPLETE",
39 [SNIC_IOREQ_COMPLETE] = "SNIC_IOREQ_CMD_COMPLETE",
40 };
41
42 /* snic cmd status strings */
43 static const char * const snic_io_status_str[] = {
44 [SNIC_STAT_IO_SUCCESS] = "SNIC_STAT_IO_SUCCESS", /* 0x0 */
45 [SNIC_STAT_INVALID_HDR] = "SNIC_STAT_INVALID_HDR",
46 [SNIC_STAT_OUT_OF_RES] = "SNIC_STAT_OUT_OF_RES",
47 [SNIC_STAT_INVALID_PARM] = "SNIC_STAT_INVALID_PARM",
48 [SNIC_STAT_REQ_NOT_SUP] = "SNIC_STAT_REQ_NOT_SUP",
49 [SNIC_STAT_IO_NOT_FOUND] = "SNIC_STAT_IO_NOT_FOUND",
50 [SNIC_STAT_ABORTED] = "SNIC_STAT_ABORTED",
51 [SNIC_STAT_TIMEOUT] = "SNIC_STAT_TIMEOUT",
52 [SNIC_STAT_SGL_INVALID] = "SNIC_STAT_SGL_INVALID",
53 [SNIC_STAT_DATA_CNT_MISMATCH] = "SNIC_STAT_DATA_CNT_MISMATCH",
54 [SNIC_STAT_FW_ERR] = "SNIC_STAT_FW_ERR",
55 [SNIC_STAT_ITMF_REJECT] = "SNIC_STAT_ITMF_REJECT",
56 [SNIC_STAT_ITMF_FAIL] = "SNIC_STAT_ITMF_FAIL",
57 [SNIC_STAT_ITMF_INCORRECT_LUN] = "SNIC_STAT_ITMF_INCORRECT_LUN",
58 [SNIC_STAT_CMND_REJECT] = "SNIC_STAT_CMND_REJECT",
59 [SNIC_STAT_DEV_OFFLINE] = "SNIC_STAT_DEV_OFFLINE",
60 [SNIC_STAT_NO_BOOTLUN] = "SNIC_STAT_NO_BOOTLUN",
61 [SNIC_STAT_SCSI_ERR] = "SNIC_STAT_SCSI_ERR",
62 [SNIC_STAT_NOT_READY] = "SNIC_STAT_NOT_READY",
63 [SNIC_STAT_FATAL_ERROR] = "SNIC_STAT_FATAL_ERROR",
64 };
65
66 static void snic_scsi_cleanup(struct snic *, int);
67
68 const char *
snic_state_to_str(unsigned int state)69 snic_state_to_str(unsigned int state)
70 {
71 if (state >= ARRAY_SIZE(snic_state_str) || !snic_state_str[state])
72 return "Unknown";
73
74 return snic_state_str[state];
75 }
76
77 static const char *
snic_io_status_to_str(unsigned int state)78 snic_io_status_to_str(unsigned int state)
79 {
80 if ((state >= ARRAY_SIZE(snic_io_status_str)) ||
81 (!snic_io_status_str[state]))
82 return "Unknown";
83
84 return snic_io_status_str[state];
85 }
86
87 static const char *
snic_ioreq_state_to_str(unsigned int state)88 snic_ioreq_state_to_str(unsigned int state)
89 {
90 if (state >= ARRAY_SIZE(snic_req_state_str) ||
91 !snic_req_state_str[state])
92 return "Unknown";
93
94 return snic_req_state_str[state];
95 }
96
97 static inline spinlock_t *
snic_io_lock_hash(struct snic * snic,struct scsi_cmnd * sc)98 snic_io_lock_hash(struct snic *snic, struct scsi_cmnd *sc)
99 {
100 u32 hash = snic_cmd_tag(sc) & (SNIC_IO_LOCKS - 1);
101
102 return &snic->io_req_lock[hash];
103 }
104
105 static inline spinlock_t *
snic_io_lock_tag(struct snic * snic,int tag)106 snic_io_lock_tag(struct snic *snic, int tag)
107 {
108 return &snic->io_req_lock[tag & (SNIC_IO_LOCKS - 1)];
109 }
110
111 /* snic_release_req_buf : Releases snic_req_info */
112 static void
snic_release_req_buf(struct snic * snic,struct snic_req_info * rqi,struct scsi_cmnd * sc)113 snic_release_req_buf(struct snic *snic,
114 struct snic_req_info *rqi,
115 struct scsi_cmnd *sc)
116 {
117 struct snic_host_req *req = rqi_to_req(rqi);
118
119 /* Freeing cmd without marking completion, not okay */
120 SNIC_BUG_ON(!((CMD_STATE(sc) == SNIC_IOREQ_COMPLETE) ||
121 (CMD_STATE(sc) == SNIC_IOREQ_ABTS_COMPLETE) ||
122 (CMD_FLAGS(sc) & SNIC_DEV_RST_NOTSUP) ||
123 (CMD_FLAGS(sc) & SNIC_IO_INTERNAL_TERM_ISSUED) ||
124 (CMD_FLAGS(sc) & SNIC_DEV_RST_TERM_ISSUED) ||
125 (CMD_FLAGS(sc) & SNIC_SCSI_CLEANUP) ||
126 (CMD_STATE(sc) == SNIC_IOREQ_LR_COMPLETE)));
127
128 SNIC_SCSI_DBG(snic->shost,
129 "Rel_req:sc %p:tag %x:rqi %p:ioreq %p:abt %p:dr %p: state %s:flags 0x%llx\n",
130 sc, snic_cmd_tag(sc), rqi, rqi->req, rqi->abort_req,
131 rqi->dr_req, snic_ioreq_state_to_str(CMD_STATE(sc)),
132 CMD_FLAGS(sc));
133
134 if (req->u.icmnd.sense_addr)
135 dma_unmap_single(&snic->pdev->dev,
136 le64_to_cpu(req->u.icmnd.sense_addr),
137 SCSI_SENSE_BUFFERSIZE,
138 DMA_FROM_DEVICE);
139
140 scsi_dma_unmap(sc);
141
142 snic_req_free(snic, rqi);
143 } /* end of snic_release_req_buf */
144
145 /*
146 * snic_queue_icmnd_req : Queues snic_icmnd request
147 */
148 static int
snic_queue_icmnd_req(struct snic * snic,struct snic_req_info * rqi,struct scsi_cmnd * sc,int sg_cnt)149 snic_queue_icmnd_req(struct snic *snic,
150 struct snic_req_info *rqi,
151 struct scsi_cmnd *sc,
152 int sg_cnt)
153 {
154 struct scatterlist *sg;
155 struct snic_sg_desc *sgd;
156 dma_addr_t pa = 0;
157 struct scsi_lun lun;
158 u16 flags = 0;
159 int ret = 0;
160 unsigned int i;
161
162 if (sg_cnt) {
163 flags = SNIC_ICMND_ESGL;
164 sgd = (struct snic_sg_desc *) req_to_sgl(rqi->req);
165
166 for_each_sg(scsi_sglist(sc), sg, sg_cnt, i) {
167 sgd->addr = cpu_to_le64(sg_dma_address(sg));
168 sgd->len = cpu_to_le32(sg_dma_len(sg));
169 sgd->_resvd = 0;
170 sgd++;
171 }
172 }
173
174 pa = dma_map_single(&snic->pdev->dev,
175 sc->sense_buffer,
176 SCSI_SENSE_BUFFERSIZE,
177 DMA_FROM_DEVICE);
178 if (dma_mapping_error(&snic->pdev->dev, pa)) {
179 SNIC_HOST_ERR(snic->shost,
180 "QIcmnd:PCI Map Failed for sns buf %p tag %x\n",
181 sc->sense_buffer, snic_cmd_tag(sc));
182 ret = -ENOMEM;
183
184 return ret;
185 }
186
187 int_to_scsilun(sc->device->lun, &lun);
188 if (sc->sc_data_direction == DMA_FROM_DEVICE)
189 flags |= SNIC_ICMND_RD;
190 if (sc->sc_data_direction == DMA_TO_DEVICE)
191 flags |= SNIC_ICMND_WR;
192
193 /* Initialize icmnd */
194 snic_icmnd_init(rqi->req,
195 snic_cmd_tag(sc),
196 snic->config.hid, /* hid */
197 (ulong) rqi,
198 flags, /* command flags */
199 rqi->tgt_id,
200 lun.scsi_lun,
201 sc->cmnd,
202 sc->cmd_len,
203 scsi_bufflen(sc),
204 sg_cnt,
205 (ulong) req_to_sgl(rqi->req),
206 pa, /* sense buffer pa */
207 SCSI_SENSE_BUFFERSIZE);
208
209 atomic64_inc(&snic->s_stats.io.active);
210 ret = snic_queue_wq_desc(snic, rqi->req, rqi->req_len);
211 if (ret) {
212 atomic64_dec(&snic->s_stats.io.active);
213 SNIC_HOST_ERR(snic->shost,
214 "QIcmnd: Queuing Icmnd Failed. ret = %d\n",
215 ret);
216 } else
217 snic_stats_update_active_ios(&snic->s_stats);
218
219 return ret;
220 } /* end of snic_queue_icmnd_req */
221
222 /*
223 * snic_issue_scsi_req : Prepares IO request and Issues to FW.
224 */
225 static int
snic_issue_scsi_req(struct snic * snic,struct snic_tgt * tgt,struct scsi_cmnd * sc)226 snic_issue_scsi_req(struct snic *snic,
227 struct snic_tgt *tgt,
228 struct scsi_cmnd *sc)
229 {
230 struct snic_req_info *rqi = NULL;
231 int sg_cnt = 0;
232 int ret = 0;
233 u32 tag = snic_cmd_tag(sc);
234 u64 cmd_trc = 0, cmd_st_flags = 0;
235 spinlock_t *io_lock = NULL;
236 unsigned long flags;
237
238 CMD_STATE(sc) = SNIC_IOREQ_NOT_INITED;
239 CMD_FLAGS(sc) = SNIC_NO_FLAGS;
240 sg_cnt = scsi_dma_map(sc);
241 if (sg_cnt < 0) {
242 SNIC_TRC((u16)snic->shost->host_no, tag, (ulong) sc, 0,
243 sc->cmnd[0], sg_cnt, CMD_STATE(sc));
244
245 SNIC_HOST_ERR(snic->shost, "issue_sc:Failed to map SG List.\n");
246 ret = -ENOMEM;
247
248 goto issue_sc_end;
249 }
250
251 rqi = snic_req_init(snic, sg_cnt);
252 if (!rqi) {
253 scsi_dma_unmap(sc);
254 ret = -ENOMEM;
255
256 goto issue_sc_end;
257 }
258
259 rqi->tgt_id = tgt->id;
260 rqi->sc = sc;
261
262 CMD_STATE(sc) = SNIC_IOREQ_PENDING;
263 CMD_SP(sc) = (char *) rqi;
264 cmd_trc = SNIC_TRC_CMD(sc);
265 CMD_FLAGS(sc) |= (SNIC_IO_INITIALIZED | SNIC_IO_ISSUED);
266 cmd_st_flags = SNIC_TRC_CMD_STATE_FLAGS(sc);
267 io_lock = snic_io_lock_hash(snic, sc);
268
269 /* create wq desc and enqueue it */
270 ret = snic_queue_icmnd_req(snic, rqi, sc, sg_cnt);
271 if (ret) {
272 SNIC_HOST_ERR(snic->shost,
273 "issue_sc: icmnd qing Failed for sc %p, err %d\n",
274 sc, ret);
275
276 spin_lock_irqsave(io_lock, flags);
277 rqi = (struct snic_req_info *) CMD_SP(sc);
278 CMD_SP(sc) = NULL;
279 CMD_STATE(sc) = SNIC_IOREQ_COMPLETE;
280 CMD_FLAGS(sc) &= ~SNIC_IO_ISSUED; /* turn off the flag */
281 spin_unlock_irqrestore(io_lock, flags);
282
283 if (rqi)
284 snic_release_req_buf(snic, rqi, sc);
285
286 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc, 0, 0, 0,
287 SNIC_TRC_CMD_STATE_FLAGS(sc));
288 } else {
289 u32 io_sz = scsi_bufflen(sc) >> 9;
290 u32 qtime = jiffies - rqi->start_time;
291 struct snic_io_stats *iostats = &snic->s_stats.io;
292
293 if (io_sz > atomic64_read(&iostats->max_io_sz))
294 atomic64_set(&iostats->max_io_sz, io_sz);
295
296 if (qtime > atomic64_read(&iostats->max_qtime))
297 atomic64_set(&iostats->max_qtime, qtime);
298
299 SNIC_SCSI_DBG(snic->shost,
300 "issue_sc:sc %p, tag %d queued to WQ.\n",
301 sc, tag);
302
303 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc, (ulong) rqi,
304 sg_cnt, cmd_trc, cmd_st_flags);
305 }
306
307 issue_sc_end:
308
309 return ret;
310 } /* end of snic_issue_scsi_req */
311
312
313 /*
314 * snic_queuecommand
315 * Routine to send a scsi cdb to LLD
316 * Called with host_lock held and interrupts disabled
317 */
318 int
snic_queuecommand(struct Scsi_Host * shost,struct scsi_cmnd * sc)319 snic_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *sc)
320 {
321 struct snic_tgt *tgt = NULL;
322 struct snic *snic = shost_priv(shost);
323 int ret;
324
325 tgt = starget_to_tgt(scsi_target(sc->device));
326 ret = snic_tgt_chkready(tgt);
327 if (ret) {
328 SNIC_HOST_ERR(shost, "Tgt %p id %d Not Ready.\n", tgt, tgt->id);
329 atomic64_inc(&snic->s_stats.misc.tgt_not_rdy);
330 sc->result = ret;
331 scsi_done(sc);
332
333 return 0;
334 }
335
336 if (snic_get_state(snic) != SNIC_ONLINE) {
337 SNIC_HOST_ERR(shost, "snic state is %s\n",
338 snic_state_str[snic_get_state(snic)]);
339
340 return SCSI_MLQUEUE_HOST_BUSY;
341 }
342 atomic_inc(&snic->ios_inflight);
343
344 SNIC_SCSI_DBG(shost, "sc %p Tag %d (sc %0x) lun %lld in snic_qcmd\n",
345 sc, snic_cmd_tag(sc), sc->cmnd[0], sc->device->lun);
346
347 ret = snic_issue_scsi_req(snic, tgt, sc);
348 if (ret) {
349 SNIC_HOST_ERR(shost, "Failed to Q, Scsi Req w/ err %d.\n", ret);
350 ret = SCSI_MLQUEUE_HOST_BUSY;
351 }
352
353 atomic_dec(&snic->ios_inflight);
354
355 return ret;
356 } /* end of snic_queuecommand */
357
358 /*
359 * snic_process_abts_pending_state:
360 * caller should hold IO lock
361 */
362 static void
snic_proc_tmreq_pending_state(struct snic * snic,struct scsi_cmnd * sc,u8 cmpl_status)363 snic_proc_tmreq_pending_state(struct snic *snic,
364 struct scsi_cmnd *sc,
365 u8 cmpl_status)
366 {
367 int state = CMD_STATE(sc);
368
369 if (state == SNIC_IOREQ_ABTS_PENDING)
370 CMD_FLAGS(sc) |= SNIC_IO_ABTS_PENDING;
371 else if (state == SNIC_IOREQ_LR_PENDING)
372 CMD_FLAGS(sc) |= SNIC_DEV_RST_PENDING;
373 else
374 SNIC_BUG_ON(1);
375
376 switch (cmpl_status) {
377 case SNIC_STAT_IO_SUCCESS:
378 CMD_FLAGS(sc) |= SNIC_IO_DONE;
379 break;
380
381 case SNIC_STAT_ABORTED:
382 CMD_FLAGS(sc) |= SNIC_IO_ABORTED;
383 break;
384
385 default:
386 SNIC_BUG_ON(1);
387 }
388 }
389
390 /*
391 * snic_process_io_failed_state:
392 * Processes IO's error states
393 */
394 static void
snic_process_io_failed_state(struct snic * snic,struct snic_icmnd_cmpl * icmnd_cmpl,struct scsi_cmnd * sc,u8 cmpl_stat)395 snic_process_io_failed_state(struct snic *snic,
396 struct snic_icmnd_cmpl *icmnd_cmpl,
397 struct scsi_cmnd *sc,
398 u8 cmpl_stat)
399 {
400 int res = 0;
401
402 switch (cmpl_stat) {
403 case SNIC_STAT_TIMEOUT: /* Req was timedout */
404 atomic64_inc(&snic->s_stats.misc.io_tmo);
405 res = DID_TIME_OUT;
406 break;
407
408 case SNIC_STAT_ABORTED: /* Req was aborted */
409 atomic64_inc(&snic->s_stats.misc.io_aborted);
410 res = DID_ABORT;
411 break;
412
413 case SNIC_STAT_DATA_CNT_MISMATCH:/* Recv/Sent more/less data than exp */
414 atomic64_inc(&snic->s_stats.misc.data_cnt_mismat);
415 scsi_set_resid(sc, le32_to_cpu(icmnd_cmpl->resid));
416 res = DID_ERROR;
417 break;
418
419 case SNIC_STAT_OUT_OF_RES: /* Out of resources to complete request */
420 atomic64_inc(&snic->s_stats.fw.out_of_res);
421 res = DID_REQUEUE;
422 break;
423
424 case SNIC_STAT_IO_NOT_FOUND: /* Requested I/O was not found */
425 atomic64_inc(&snic->s_stats.io.io_not_found);
426 res = DID_ERROR;
427 break;
428
429 case SNIC_STAT_SGL_INVALID: /* Req was aborted to due to sgl error*/
430 atomic64_inc(&snic->s_stats.misc.sgl_inval);
431 res = DID_ERROR;
432 break;
433
434 case SNIC_STAT_FW_ERR: /* Req terminated due to FW Error */
435 atomic64_inc(&snic->s_stats.fw.io_errs);
436 res = DID_ERROR;
437 break;
438
439 case SNIC_STAT_SCSI_ERR: /* FW hits SCSI Error */
440 atomic64_inc(&snic->s_stats.fw.scsi_errs);
441 break;
442
443 case SNIC_STAT_NOT_READY: /* XPT yet to initialize */
444 case SNIC_STAT_DEV_OFFLINE: /* Device offline */
445 res = DID_NO_CONNECT;
446 break;
447
448 case SNIC_STAT_INVALID_HDR: /* Hdr contains invalid data */
449 case SNIC_STAT_INVALID_PARM: /* Some param in req is invalid */
450 case SNIC_STAT_REQ_NOT_SUP: /* Req type is not supported */
451 case SNIC_STAT_CMND_REJECT: /* Req rejected */
452 case SNIC_STAT_FATAL_ERROR: /* XPT Error */
453 default:
454 SNIC_SCSI_DBG(snic->shost,
455 "Invalid Hdr/Param or Req Not Supported or Cmnd Rejected or Device Offline. or Unknown\n");
456 res = DID_ERROR;
457 break;
458 }
459
460 SNIC_HOST_ERR(snic->shost, "fw returns failed status %s flags 0x%llx\n",
461 snic_io_status_to_str(cmpl_stat), CMD_FLAGS(sc));
462
463 /* Set sc->result */
464 sc->result = (res << 16) | icmnd_cmpl->scsi_status;
465 } /* end of snic_process_io_failed_state */
466
467 /*
468 * snic_tmreq_pending : is task management in progress.
469 */
470 static int
snic_tmreq_pending(struct scsi_cmnd * sc)471 snic_tmreq_pending(struct scsi_cmnd *sc)
472 {
473 int state = CMD_STATE(sc);
474
475 return ((state == SNIC_IOREQ_ABTS_PENDING) ||
476 (state == SNIC_IOREQ_LR_PENDING));
477 }
478
479 /*
480 * snic_process_icmnd_cmpl_status:
481 * Caller should hold io_lock
482 */
483 static int
snic_process_icmnd_cmpl_status(struct snic * snic,struct snic_icmnd_cmpl * icmnd_cmpl,u8 cmpl_stat,struct scsi_cmnd * sc)484 snic_process_icmnd_cmpl_status(struct snic *snic,
485 struct snic_icmnd_cmpl *icmnd_cmpl,
486 u8 cmpl_stat,
487 struct scsi_cmnd *sc)
488 {
489 u8 scsi_stat = icmnd_cmpl->scsi_status;
490 int ret = 0;
491
492 /* Mark the IO as complete */
493 CMD_STATE(sc) = SNIC_IOREQ_COMPLETE;
494
495 if (likely(cmpl_stat == SNIC_STAT_IO_SUCCESS)) {
496 sc->result = (DID_OK << 16) | scsi_stat;
497
498 /* Update SCSI Cmd with resid value */
499 scsi_set_resid(sc, le32_to_cpu(icmnd_cmpl->resid));
500
501 if (icmnd_cmpl->flags & SNIC_ICMND_CMPL_UNDR_RUN)
502 atomic64_inc(&snic->s_stats.misc.io_under_run);
503
504 if (icmnd_cmpl->scsi_status == SAM_STAT_TASK_SET_FULL)
505 atomic64_inc(&snic->s_stats.misc.qfull);
506
507 ret = 0;
508 } else {
509 snic_process_io_failed_state(snic, icmnd_cmpl, sc, cmpl_stat);
510 atomic64_inc(&snic->s_stats.io.fail);
511 SNIC_HOST_ERR(snic->shost,
512 "icmnd_cmpl: IO Failed : Hdr Status %s flags 0x%llx\n",
513 snic_io_status_to_str(cmpl_stat), CMD_FLAGS(sc));
514 ret = 1;
515 }
516
517 return ret;
518 } /* end of snic_process_icmnd_cmpl_status */
519
520
521 /*
522 * snic_icmnd_cmpl_handler
523 * Routine to handle icmnd completions
524 */
525 static void
snic_icmnd_cmpl_handler(struct snic * snic,struct snic_fw_req * fwreq)526 snic_icmnd_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
527 {
528 u8 typ, hdr_stat;
529 u32 cmnd_id, hid;
530 ulong ctx;
531 struct scsi_cmnd *sc = NULL;
532 struct snic_icmnd_cmpl *icmnd_cmpl = NULL;
533 struct snic_host_req *req = NULL;
534 struct snic_req_info *rqi = NULL;
535 unsigned long flags, start_time;
536 spinlock_t *io_lock;
537 u8 sc_stat = 0;
538
539 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
540 icmnd_cmpl = &fwreq->u.icmnd_cmpl;
541 sc_stat = icmnd_cmpl->scsi_status;
542
543 SNIC_SCSI_DBG(snic->shost,
544 "Icmnd_cmpl: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x,i ctx = %lx\n",
545 typ, hdr_stat, cmnd_id, hid, ctx);
546
547 if (cmnd_id >= snic->max_tag_id) {
548 SNIC_HOST_ERR(snic->shost,
549 "Icmnd_cmpl:Tag Error:Out of Range Tag %d, hdr status = %s\n",
550 cmnd_id, snic_io_status_to_str(hdr_stat));
551 return;
552 }
553
554 sc = scsi_host_find_tag(snic->shost, cmnd_id);
555 WARN_ON_ONCE(!sc);
556
557 if (!sc) {
558 atomic64_inc(&snic->s_stats.io.sc_null);
559 SNIC_HOST_ERR(snic->shost,
560 "Icmnd_cmpl: Scsi Cmnd Not found, sc = NULL Hdr Status = %s tag = 0x%x fwreq = 0x%p\n",
561 snic_io_status_to_str(hdr_stat),
562 cmnd_id,
563 fwreq);
564
565 SNIC_TRC(snic->shost->host_no, cmnd_id, 0,
566 ((u64)hdr_stat << 16 |
567 (u64)sc_stat << 8 | (u64)icmnd_cmpl->flags),
568 (ulong) fwreq, le32_to_cpu(icmnd_cmpl->resid), ctx);
569
570 return;
571 }
572
573 io_lock = snic_io_lock_hash(snic, sc);
574
575 spin_lock_irqsave(io_lock, flags);
576 rqi = (struct snic_req_info *) CMD_SP(sc);
577 SNIC_SCSI_DBG(snic->shost,
578 "Icmnd_cmpl:lun %lld sc %p cmd %xtag %d flags 0x%llx rqi %p\n",
579 sc->device->lun, sc, sc->cmnd[0], snic_cmd_tag(sc),
580 CMD_FLAGS(sc), rqi);
581
582 if (CMD_FLAGS(sc) & SNIC_HOST_RESET_CMD_TERM) {
583 spin_unlock_irqrestore(io_lock, flags);
584
585 return;
586 }
587
588 SNIC_BUG_ON(rqi != (struct snic_req_info *)ctx);
589 WARN_ON_ONCE(req);
590 if (!rqi) {
591 atomic64_inc(&snic->s_stats.io.req_null);
592 CMD_FLAGS(sc) |= SNIC_IO_REQ_NULL;
593 spin_unlock_irqrestore(io_lock, flags);
594
595 SNIC_HOST_ERR(snic->shost,
596 "Icmnd_cmpl:Host Req Not Found(null), Hdr Status %s, Tag 0x%x, sc 0x%p flags 0x%llx\n",
597 snic_io_status_to_str(hdr_stat),
598 cmnd_id, sc, CMD_FLAGS(sc));
599 return;
600 }
601
602 rqi = (struct snic_req_info *) ctx;
603 start_time = rqi->start_time;
604
605 /* firmware completed the io */
606 rqi->io_cmpl = 1;
607
608 /*
609 * if SCSI-ML has already issued abort on this command,
610 * ignore completion of the IO. The abts path will clean it up
611 */
612 if (unlikely(snic_tmreq_pending(sc))) {
613 snic_proc_tmreq_pending_state(snic, sc, hdr_stat);
614 spin_unlock_irqrestore(io_lock, flags);
615
616 snic_stats_update_io_cmpl(&snic->s_stats);
617
618 /* Expected value is SNIC_STAT_ABORTED */
619 if (likely(hdr_stat == SNIC_STAT_ABORTED))
620 return;
621
622 SNIC_SCSI_DBG(snic->shost,
623 "icmnd_cmpl:TM Req Pending(%s), Hdr Status %s sc 0x%p scsi status %x resid %d flags 0x%llx\n",
624 snic_ioreq_state_to_str(CMD_STATE(sc)),
625 snic_io_status_to_str(hdr_stat),
626 sc, sc_stat, le32_to_cpu(icmnd_cmpl->resid),
627 CMD_FLAGS(sc));
628
629 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
630 jiffies_to_msecs(jiffies - start_time), (ulong) fwreq,
631 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
632
633 return;
634 }
635
636 if (snic_process_icmnd_cmpl_status(snic, icmnd_cmpl, hdr_stat, sc)) {
637 scsi_print_command(sc);
638 SNIC_HOST_ERR(snic->shost,
639 "icmnd_cmpl:IO Failed, sc 0x%p Tag %d Cmd %x Hdr Status %s flags 0x%llx\n",
640 sc, sc->cmnd[0], cmnd_id,
641 snic_io_status_to_str(hdr_stat), CMD_FLAGS(sc));
642 }
643
644 /* Break link with the SCSI Command */
645 CMD_SP(sc) = NULL;
646 CMD_FLAGS(sc) |= SNIC_IO_DONE;
647
648 spin_unlock_irqrestore(io_lock, flags);
649
650 /* For now, consider only successful IO. */
651 snic_calc_io_process_time(snic, rqi);
652
653 snic_release_req_buf(snic, rqi, sc);
654
655 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
656 jiffies_to_msecs(jiffies - start_time), (ulong) fwreq,
657 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
658
659
660 scsi_done(sc);
661
662 snic_stats_update_io_cmpl(&snic->s_stats);
663 } /* end of snic_icmnd_cmpl_handler */
664
665 static void
snic_proc_dr_cmpl_locked(struct snic * snic,struct snic_fw_req * fwreq,u8 cmpl_stat,u32 cmnd_id,struct scsi_cmnd * sc)666 snic_proc_dr_cmpl_locked(struct snic *snic,
667 struct snic_fw_req *fwreq,
668 u8 cmpl_stat,
669 u32 cmnd_id,
670 struct scsi_cmnd *sc)
671 {
672 struct snic_req_info *rqi = (struct snic_req_info *) CMD_SP(sc);
673 u32 start_time = rqi->start_time;
674
675 CMD_LR_STATUS(sc) = cmpl_stat;
676
677 SNIC_SCSI_DBG(snic->shost, "itmf_cmpl: Cmd State = %s\n",
678 snic_ioreq_state_to_str(CMD_STATE(sc)));
679
680 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) {
681 CMD_FLAGS(sc) |= SNIC_DEV_RST_ABTS_PENDING;
682
683 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
684 jiffies_to_msecs(jiffies - start_time),
685 (ulong) fwreq, 0, SNIC_TRC_CMD_STATE_FLAGS(sc));
686
687 SNIC_SCSI_DBG(snic->shost,
688 "itmf_cmpl: Terminate Pending Dev Reset Cmpl Recvd.id %x, status %s flags 0x%llx\n",
689 (int)(cmnd_id & SNIC_TAG_MASK),
690 snic_io_status_to_str(cmpl_stat),
691 CMD_FLAGS(sc));
692
693 return;
694 }
695
696
697 if (CMD_FLAGS(sc) & SNIC_DEV_RST_TIMEDOUT) {
698 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
699 jiffies_to_msecs(jiffies - start_time),
700 (ulong) fwreq, 0, SNIC_TRC_CMD_STATE_FLAGS(sc));
701
702 SNIC_SCSI_DBG(snic->shost,
703 "itmf_cmpl:Dev Reset Completion Received after timeout. id %d cmpl status %s flags 0x%llx\n",
704 (int)(cmnd_id & SNIC_TAG_MASK),
705 snic_io_status_to_str(cmpl_stat),
706 CMD_FLAGS(sc));
707
708 return;
709 }
710
711 CMD_STATE(sc) = SNIC_IOREQ_LR_COMPLETE;
712 CMD_FLAGS(sc) |= SNIC_DEV_RST_DONE;
713
714 SNIC_SCSI_DBG(snic->shost,
715 "itmf_cmpl:Dev Reset Cmpl Recvd id %d cmpl status %s flags 0x%llx\n",
716 (int)(cmnd_id & SNIC_TAG_MASK),
717 snic_io_status_to_str(cmpl_stat),
718 CMD_FLAGS(sc));
719
720 if (rqi->dr_done)
721 complete(rqi->dr_done);
722 } /* end of snic_proc_dr_cmpl_locked */
723
724 /*
725 * snic_update_abort_stats : Updates abort stats based on completion status.
726 */
727 static void
snic_update_abort_stats(struct snic * snic,u8 cmpl_stat)728 snic_update_abort_stats(struct snic *snic, u8 cmpl_stat)
729 {
730 struct snic_abort_stats *abt_stats = &snic->s_stats.abts;
731
732 SNIC_SCSI_DBG(snic->shost, "Updating Abort stats.\n");
733
734 switch (cmpl_stat) {
735 case SNIC_STAT_IO_SUCCESS:
736 break;
737
738 case SNIC_STAT_TIMEOUT:
739 atomic64_inc(&abt_stats->fw_tmo);
740 break;
741
742 case SNIC_STAT_IO_NOT_FOUND:
743 atomic64_inc(&abt_stats->io_not_found);
744 break;
745
746 default:
747 atomic64_inc(&abt_stats->fail);
748 break;
749 }
750 }
751
752 static int
snic_process_itmf_cmpl(struct snic * snic,struct snic_fw_req * fwreq,u32 cmnd_id,u8 cmpl_stat,struct scsi_cmnd * sc)753 snic_process_itmf_cmpl(struct snic *snic,
754 struct snic_fw_req *fwreq,
755 u32 cmnd_id,
756 u8 cmpl_stat,
757 struct scsi_cmnd *sc)
758 {
759 struct snic_req_info *rqi = NULL;
760 u32 tm_tags = 0;
761 spinlock_t *io_lock = NULL;
762 unsigned long flags;
763 u32 start_time = 0;
764 int ret = 0;
765
766 io_lock = snic_io_lock_hash(snic, sc);
767 spin_lock_irqsave(io_lock, flags);
768 if (CMD_FLAGS(sc) & SNIC_HOST_RESET_CMD_TERM) {
769 spin_unlock_irqrestore(io_lock, flags);
770
771 return ret;
772 }
773 rqi = (struct snic_req_info *) CMD_SP(sc);
774 WARN_ON_ONCE(!rqi);
775
776 if (!rqi) {
777 atomic64_inc(&snic->s_stats.io.req_null);
778 spin_unlock_irqrestore(io_lock, flags);
779 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL;
780 SNIC_HOST_ERR(snic->shost,
781 "itmf_cmpl: rqi is null,Hdr stat = %s Tag = 0x%x sc = 0x%p flags 0x%llx\n",
782 snic_io_status_to_str(cmpl_stat), cmnd_id, sc,
783 CMD_FLAGS(sc));
784
785 return ret;
786 }
787
788 /* Extract task management flags */
789 tm_tags = cmnd_id & ~(SNIC_TAG_MASK);
790
791 start_time = rqi->start_time;
792 cmnd_id &= (SNIC_TAG_MASK);
793
794 switch (tm_tags) {
795 case SNIC_TAG_ABORT:
796 /* Abort only issued on cmd */
797 snic_update_abort_stats(snic, cmpl_stat);
798
799 if (CMD_STATE(sc) != SNIC_IOREQ_ABTS_PENDING) {
800 /* This is a late completion. Ignore it. */
801 ret = -1;
802 spin_unlock_irqrestore(io_lock, flags);
803 break;
804 }
805
806 CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE;
807 CMD_ABTS_STATUS(sc) = cmpl_stat;
808 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_DONE;
809
810 SNIC_SCSI_DBG(snic->shost,
811 "itmf_cmpl:Abort Cmpl Recvd.Tag 0x%x Status %s flags 0x%llx\n",
812 cmnd_id,
813 snic_io_status_to_str(cmpl_stat),
814 CMD_FLAGS(sc));
815
816 /*
817 * If scsi_eh thread is blocked waiting for abts complete,
818 * signal completion to it. IO will be cleaned in the thread,
819 * else clean it in this context.
820 */
821 if (rqi->abts_done) {
822 complete(rqi->abts_done);
823 spin_unlock_irqrestore(io_lock, flags);
824
825 break; /* jump out */
826 }
827
828 CMD_SP(sc) = NULL;
829 sc->result = (DID_ERROR << 16);
830 SNIC_SCSI_DBG(snic->shost,
831 "itmf_cmpl: Completing IO. sc %p flags 0x%llx\n",
832 sc, CMD_FLAGS(sc));
833
834 spin_unlock_irqrestore(io_lock, flags);
835
836 snic_release_req_buf(snic, rqi, sc);
837
838 SNIC_TRC(snic->shost->host_no, cmnd_id, (ulong) sc,
839 jiffies_to_msecs(jiffies - start_time),
840 (ulong) fwreq, SNIC_TRC_CMD(sc),
841 SNIC_TRC_CMD_STATE_FLAGS(sc));
842
843 scsi_done(sc);
844
845 break;
846
847 case SNIC_TAG_DEV_RST:
848 case SNIC_TAG_DEV_RST | SNIC_TAG_IOCTL_DEV_RST:
849 snic_proc_dr_cmpl_locked(snic, fwreq, cmpl_stat, cmnd_id, sc);
850 spin_unlock_irqrestore(io_lock, flags);
851 ret = 0;
852
853 break;
854
855 case SNIC_TAG_ABORT | SNIC_TAG_DEV_RST:
856 /* Abort and terminate completion of device reset req */
857
858 CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE;
859 CMD_ABTS_STATUS(sc) = cmpl_stat;
860 CMD_FLAGS(sc) |= SNIC_DEV_RST_DONE;
861
862 SNIC_SCSI_DBG(snic->shost,
863 "itmf_cmpl:dev reset abts cmpl recvd. id %d status %s flags 0x%llx\n",
864 cmnd_id, snic_io_status_to_str(cmpl_stat),
865 CMD_FLAGS(sc));
866
867 if (rqi->abts_done)
868 complete(rqi->abts_done);
869
870 spin_unlock_irqrestore(io_lock, flags);
871
872 break;
873
874 default:
875 spin_unlock_irqrestore(io_lock, flags);
876 SNIC_HOST_ERR(snic->shost,
877 "itmf_cmpl: Unknown TM tag bit 0x%x\n", tm_tags);
878
879 SNIC_HOST_ERR(snic->shost,
880 "itmf_cmpl:Unexpected itmf io stat %s Tag = 0x%x flags 0x%llx\n",
881 snic_ioreq_state_to_str(CMD_STATE(sc)),
882 cmnd_id,
883 CMD_FLAGS(sc));
884 ret = -1;
885 SNIC_BUG_ON(1);
886
887 break;
888 }
889
890 return ret;
891 } /* end of snic_process_itmf_cmpl_status */
892
893 /*
894 * snic_itmf_cmpl_handler.
895 * Routine to handle itmf completions.
896 */
897 static void
snic_itmf_cmpl_handler(struct snic * snic,struct snic_fw_req * fwreq)898 snic_itmf_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
899 {
900 struct scsi_cmnd *sc = NULL;
901 struct snic_req_info *rqi = NULL;
902 struct snic_itmf_cmpl *itmf_cmpl = NULL;
903 ulong ctx;
904 u32 cmnd_id;
905 u32 hid;
906 u8 typ;
907 u8 hdr_stat;
908
909 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
910 SNIC_SCSI_DBG(snic->shost,
911 "Itmf_cmpl: %s: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x,ctx = %lx\n",
912 __func__, typ, hdr_stat, cmnd_id, hid, ctx);
913
914 itmf_cmpl = &fwreq->u.itmf_cmpl;
915 SNIC_SCSI_DBG(snic->shost,
916 "Itmf_cmpl: nterm %u , flags 0x%x\n",
917 le32_to_cpu(itmf_cmpl->nterminated), itmf_cmpl->flags);
918
919 /* spl case, dev reset issued through ioctl */
920 if (cmnd_id & SNIC_TAG_IOCTL_DEV_RST) {
921 rqi = (struct snic_req_info *) ctx;
922 sc = rqi->sc;
923
924 goto ioctl_dev_rst;
925 }
926
927 if ((cmnd_id & SNIC_TAG_MASK) >= snic->max_tag_id) {
928 SNIC_HOST_ERR(snic->shost,
929 "Itmf_cmpl: Tag 0x%x out of Range,HdrStat %s\n",
930 cmnd_id, snic_io_status_to_str(hdr_stat));
931 SNIC_BUG_ON(1);
932
933 return;
934 }
935
936 sc = scsi_host_find_tag(snic->shost, cmnd_id & SNIC_TAG_MASK);
937 WARN_ON_ONCE(!sc);
938
939 ioctl_dev_rst:
940 if (!sc) {
941 atomic64_inc(&snic->s_stats.io.sc_null);
942 SNIC_HOST_ERR(snic->shost,
943 "Itmf_cmpl: sc is NULL - Hdr Stat %s Tag 0x%x\n",
944 snic_io_status_to_str(hdr_stat), cmnd_id);
945
946 return;
947 }
948
949 snic_process_itmf_cmpl(snic, fwreq, cmnd_id, hdr_stat, sc);
950 } /* end of snic_itmf_cmpl_handler */
951
952
953
954 static void
snic_hba_reset_scsi_cleanup(struct snic * snic,struct scsi_cmnd * sc)955 snic_hba_reset_scsi_cleanup(struct snic *snic, struct scsi_cmnd *sc)
956 {
957 struct snic_stats *st = &snic->s_stats;
958 long act_ios = 0, act_fwreqs = 0;
959
960 SNIC_SCSI_DBG(snic->shost, "HBA Reset scsi cleanup.\n");
961 snic_scsi_cleanup(snic, snic_cmd_tag(sc));
962
963 /* Update stats on pending IOs */
964 act_ios = atomic64_read(&st->io.active);
965 atomic64_add(act_ios, &st->io.compl);
966 atomic64_sub(act_ios, &st->io.active);
967
968 act_fwreqs = atomic64_read(&st->fw.actv_reqs);
969 atomic64_sub(act_fwreqs, &st->fw.actv_reqs);
970 }
971
972 /*
973 * snic_hba_reset_cmpl_handler :
974 *
975 * Notes :
976 * 1. Cleanup all the scsi cmds, release all snic specific cmds
977 * 2. Issue Report Targets in case of SAN targets
978 */
979 static int
snic_hba_reset_cmpl_handler(struct snic * snic,struct snic_fw_req * fwreq)980 snic_hba_reset_cmpl_handler(struct snic *snic, struct snic_fw_req *fwreq)
981 {
982 ulong ctx;
983 u32 cmnd_id;
984 u32 hid;
985 u8 typ;
986 u8 hdr_stat;
987 struct scsi_cmnd *sc = NULL;
988 struct snic_req_info *rqi = NULL;
989 spinlock_t *io_lock = NULL;
990 unsigned long flags, gflags;
991 int ret = 0;
992
993 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
994 SNIC_HOST_INFO(snic->shost,
995 "reset_cmpl:Tag %d ctx %lx cmpl status %s HBA Reset Completion received.\n",
996 cmnd_id, ctx, snic_io_status_to_str(hdr_stat));
997
998 SNIC_SCSI_DBG(snic->shost,
999 "reset_cmpl: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x, ctx = %lx\n",
1000 typ, hdr_stat, cmnd_id, hid, ctx);
1001
1002 /* spl case, host reset issued through ioctl */
1003 if (cmnd_id == SCSI_NO_TAG) {
1004 rqi = (struct snic_req_info *) ctx;
1005 SNIC_HOST_INFO(snic->shost,
1006 "reset_cmpl:Tag %d ctx %lx cmpl stat %s\n",
1007 cmnd_id, ctx, snic_io_status_to_str(hdr_stat));
1008 sc = rqi->sc;
1009
1010 goto ioctl_hba_rst;
1011 }
1012
1013 if (cmnd_id >= snic->max_tag_id) {
1014 SNIC_HOST_ERR(snic->shost,
1015 "reset_cmpl: Tag 0x%x out of Range,HdrStat %s\n",
1016 cmnd_id, snic_io_status_to_str(hdr_stat));
1017 SNIC_BUG_ON(1);
1018
1019 return 1;
1020 }
1021
1022 sc = scsi_host_find_tag(snic->shost, cmnd_id);
1023 ioctl_hba_rst:
1024 if (!sc) {
1025 atomic64_inc(&snic->s_stats.io.sc_null);
1026 SNIC_HOST_ERR(snic->shost,
1027 "reset_cmpl: sc is NULL - Hdr Stat %s Tag 0x%x\n",
1028 snic_io_status_to_str(hdr_stat), cmnd_id);
1029 ret = 1;
1030
1031 return ret;
1032 }
1033
1034 SNIC_HOST_INFO(snic->shost,
1035 "reset_cmpl: sc %p rqi %p Tag %d flags 0x%llx\n",
1036 sc, rqi, cmnd_id, CMD_FLAGS(sc));
1037
1038 io_lock = snic_io_lock_hash(snic, sc);
1039 spin_lock_irqsave(io_lock, flags);
1040
1041 if (!snic->remove_wait) {
1042 spin_unlock_irqrestore(io_lock, flags);
1043 SNIC_HOST_ERR(snic->shost,
1044 "reset_cmpl:host reset completed after timeout\n");
1045 ret = 1;
1046
1047 return ret;
1048 }
1049
1050 rqi = (struct snic_req_info *) CMD_SP(sc);
1051 WARN_ON_ONCE(!rqi);
1052
1053 if (!rqi) {
1054 atomic64_inc(&snic->s_stats.io.req_null);
1055 spin_unlock_irqrestore(io_lock, flags);
1056 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL;
1057 SNIC_HOST_ERR(snic->shost,
1058 "reset_cmpl: rqi is null,Hdr stat %s Tag 0x%x sc 0x%p flags 0x%llx\n",
1059 snic_io_status_to_str(hdr_stat), cmnd_id, sc,
1060 CMD_FLAGS(sc));
1061
1062 ret = 1;
1063
1064 return ret;
1065 }
1066 /* stats */
1067 spin_unlock_irqrestore(io_lock, flags);
1068
1069 /* scsi cleanup */
1070 snic_hba_reset_scsi_cleanup(snic, sc);
1071
1072 SNIC_BUG_ON(snic_get_state(snic) != SNIC_OFFLINE &&
1073 snic_get_state(snic) != SNIC_FWRESET);
1074
1075 /* Careful locking between snic_lock and io lock */
1076 spin_lock_irqsave(io_lock, flags);
1077 spin_lock_irqsave(&snic->snic_lock, gflags);
1078 if (snic_get_state(snic) == SNIC_FWRESET)
1079 snic_set_state(snic, SNIC_ONLINE);
1080 spin_unlock_irqrestore(&snic->snic_lock, gflags);
1081
1082 if (snic->remove_wait)
1083 complete(snic->remove_wait);
1084
1085 spin_unlock_irqrestore(io_lock, flags);
1086 atomic64_inc(&snic->s_stats.reset.hba_reset_cmpl);
1087
1088 ret = 0;
1089 /* Rediscovery is for SAN */
1090 if (snic->config.xpt_type == SNIC_DAS)
1091 return ret;
1092
1093 SNIC_SCSI_DBG(snic->shost, "reset_cmpl: Queuing discovery work.\n");
1094 queue_work(snic_glob->event_q, &snic->disc_work);
1095
1096 return ret;
1097 }
1098
1099 static void
snic_msg_ack_handler(struct snic * snic,struct snic_fw_req * fwreq)1100 snic_msg_ack_handler(struct snic *snic, struct snic_fw_req *fwreq)
1101 {
1102 SNIC_HOST_INFO(snic->shost, "Message Ack Received.\n");
1103
1104 SNIC_ASSERT_NOT_IMPL(1);
1105 }
1106
1107 static void
snic_aen_handler(struct snic * snic,struct snic_fw_req * fwreq)1108 snic_aen_handler(struct snic *snic, struct snic_fw_req *fwreq)
1109 {
1110 u8 typ, hdr_stat;
1111 u32 cmnd_id, hid;
1112 ulong ctx;
1113 struct snic_async_evnotify *aen = &fwreq->u.async_ev;
1114 u32 event_id = 0;
1115
1116 snic_io_hdr_dec(&fwreq->hdr, &typ, &hdr_stat, &cmnd_id, &hid, &ctx);
1117 SNIC_SCSI_DBG(snic->shost,
1118 "aen: type = %x, hdr_stat = %x, cmnd_id = %x, hid = %x, ctx = %lx\n",
1119 typ, hdr_stat, cmnd_id, hid, ctx);
1120
1121 event_id = le32_to_cpu(aen->ev_id);
1122
1123 switch (event_id) {
1124 case SNIC_EV_TGT_OFFLINE:
1125 SNIC_HOST_INFO(snic->shost, "aen:TGT_OFFLINE Event Recvd.\n");
1126 break;
1127
1128 case SNIC_EV_TGT_ONLINE:
1129 SNIC_HOST_INFO(snic->shost, "aen:TGT_ONLINE Event Recvd.\n");
1130 break;
1131
1132 case SNIC_EV_LUN_OFFLINE:
1133 SNIC_HOST_INFO(snic->shost, "aen:LUN_OFFLINE Event Recvd.\n");
1134 break;
1135
1136 case SNIC_EV_LUN_ONLINE:
1137 SNIC_HOST_INFO(snic->shost, "aen:LUN_ONLINE Event Recvd.\n");
1138 break;
1139
1140 case SNIC_EV_CONF_CHG:
1141 SNIC_HOST_INFO(snic->shost, "aen:Config Change Event Recvd.\n");
1142 break;
1143
1144 case SNIC_EV_TGT_ADDED:
1145 SNIC_HOST_INFO(snic->shost, "aen:TGT_ADD Event Recvd.\n");
1146 break;
1147
1148 case SNIC_EV_TGT_DELTD:
1149 SNIC_HOST_INFO(snic->shost, "aen:TGT_DEL Event Recvd.\n");
1150 break;
1151
1152 case SNIC_EV_LUN_ADDED:
1153 SNIC_HOST_INFO(snic->shost, "aen:LUN_ADD Event Recvd.\n");
1154 break;
1155
1156 case SNIC_EV_LUN_DELTD:
1157 SNIC_HOST_INFO(snic->shost, "aen:LUN_DEL Event Recvd.\n");
1158 break;
1159
1160 case SNIC_EV_DISC_CMPL:
1161 SNIC_HOST_INFO(snic->shost, "aen:DISC_CMPL Event Recvd.\n");
1162 break;
1163
1164 default:
1165 SNIC_HOST_INFO(snic->shost, "aen:Unknown Event Recvd.\n");
1166 SNIC_BUG_ON(1);
1167 break;
1168 }
1169
1170 SNIC_ASSERT_NOT_IMPL(1);
1171 } /* end of snic_aen_handler */
1172
1173 /*
1174 * snic_io_cmpl_handler
1175 * Routine to process CQ entries(IO Completions) posted by fw.
1176 */
1177 static int
snic_io_cmpl_handler(struct vnic_dev * vdev,unsigned int cq_idx,struct snic_fw_req * fwreq)1178 snic_io_cmpl_handler(struct vnic_dev *vdev,
1179 unsigned int cq_idx,
1180 struct snic_fw_req *fwreq)
1181 {
1182 struct snic *snic = svnic_dev_priv(vdev);
1183 u64 start = jiffies, cmpl_time;
1184
1185 snic_print_desc(__func__, (char *)fwreq, sizeof(*fwreq));
1186
1187 /* Update FW Stats */
1188 if ((fwreq->hdr.type >= SNIC_RSP_REPORT_TGTS_CMPL) &&
1189 (fwreq->hdr.type <= SNIC_RSP_BOOT_LUNS_CMPL))
1190 atomic64_dec(&snic->s_stats.fw.actv_reqs);
1191
1192 SNIC_BUG_ON((fwreq->hdr.type > SNIC_RSP_BOOT_LUNS_CMPL) &&
1193 (fwreq->hdr.type < SNIC_MSG_ASYNC_EVNOTIFY));
1194
1195 /* Check for snic subsys errors */
1196 switch (fwreq->hdr.status) {
1197 case SNIC_STAT_NOT_READY: /* XPT yet to initialize */
1198 SNIC_HOST_ERR(snic->shost,
1199 "sNIC SubSystem is NOT Ready.\n");
1200 break;
1201
1202 case SNIC_STAT_FATAL_ERROR: /* XPT Error */
1203 SNIC_HOST_ERR(snic->shost,
1204 "sNIC SubSystem in Unrecoverable State.\n");
1205 break;
1206 }
1207
1208 switch (fwreq->hdr.type) {
1209 case SNIC_RSP_EXCH_VER_CMPL:
1210 snic_io_exch_ver_cmpl_handler(snic, fwreq);
1211 break;
1212
1213 case SNIC_RSP_REPORT_TGTS_CMPL:
1214 snic_report_tgt_cmpl_handler(snic, fwreq);
1215 break;
1216
1217 case SNIC_RSP_ICMND_CMPL:
1218 snic_icmnd_cmpl_handler(snic, fwreq);
1219 break;
1220
1221 case SNIC_RSP_ITMF_CMPL:
1222 snic_itmf_cmpl_handler(snic, fwreq);
1223 break;
1224
1225 case SNIC_RSP_HBA_RESET_CMPL:
1226 snic_hba_reset_cmpl_handler(snic, fwreq);
1227 break;
1228
1229 case SNIC_MSG_ACK:
1230 snic_msg_ack_handler(snic, fwreq);
1231 break;
1232
1233 case SNIC_MSG_ASYNC_EVNOTIFY:
1234 snic_aen_handler(snic, fwreq);
1235 break;
1236
1237 default:
1238 SNIC_BUG_ON(1);
1239 SNIC_SCSI_DBG(snic->shost,
1240 "Unknown Firmware completion request type %d\n",
1241 fwreq->hdr.type);
1242 break;
1243 }
1244
1245 /* Update Stats */
1246 cmpl_time = jiffies - start;
1247 if (cmpl_time > atomic64_read(&snic->s_stats.io.max_cmpl_time))
1248 atomic64_set(&snic->s_stats.io.max_cmpl_time, cmpl_time);
1249
1250 return 0;
1251 } /* end of snic_io_cmpl_handler */
1252
1253 /*
1254 * snic_fwcq_cmpl_handler
1255 * Routine to process fwCQ
1256 * This CQ is independent, and not associated with wq/rq/wq_copy queues
1257 */
1258 int
snic_fwcq_cmpl_handler(struct snic * snic,int io_cmpl_work)1259 snic_fwcq_cmpl_handler(struct snic *snic, int io_cmpl_work)
1260 {
1261 unsigned int num_ent = 0; /* number cq entries processed */
1262 unsigned int cq_idx;
1263 unsigned int nent_per_cq;
1264 struct snic_misc_stats *misc_stats = &snic->s_stats.misc;
1265
1266 for (cq_idx = snic->wq_count; cq_idx < snic->cq_count; cq_idx++) {
1267 nent_per_cq = vnic_cq_fw_service(&snic->cq[cq_idx],
1268 snic_io_cmpl_handler,
1269 io_cmpl_work);
1270 num_ent += nent_per_cq;
1271
1272 if (nent_per_cq > atomic64_read(&misc_stats->max_cq_ents))
1273 atomic64_set(&misc_stats->max_cq_ents, nent_per_cq);
1274 }
1275
1276 return num_ent;
1277 } /* end of snic_fwcq_cmpl_handler */
1278
1279 /*
1280 * snic_queue_itmf_req: Common API to queue Task Management requests.
1281 * Use rqi->tm_tag for passing special tags.
1282 * @req_id : aborted request's tag, -1 for lun reset.
1283 */
1284 static int
snic_queue_itmf_req(struct snic * snic,struct snic_host_req * tmreq,struct scsi_cmnd * sc,u32 tmf,u32 req_id)1285 snic_queue_itmf_req(struct snic *snic,
1286 struct snic_host_req *tmreq,
1287 struct scsi_cmnd *sc,
1288 u32 tmf,
1289 u32 req_id)
1290 {
1291 struct snic_req_info *rqi = req_to_rqi(tmreq);
1292 struct scsi_lun lun;
1293 int tm_tag = snic_cmd_tag(sc) | rqi->tm_tag;
1294 int ret = 0;
1295
1296 SNIC_BUG_ON(!rqi);
1297 SNIC_BUG_ON(!rqi->tm_tag);
1298
1299 /* fill in lun info */
1300 int_to_scsilun(sc->device->lun, &lun);
1301
1302 /* Initialize snic_host_req: itmf */
1303 snic_itmf_init(tmreq,
1304 tm_tag,
1305 snic->config.hid,
1306 (ulong) rqi,
1307 0 /* flags */,
1308 req_id, /* Command to be aborted. */
1309 rqi->tgt_id,
1310 lun.scsi_lun,
1311 tmf);
1312
1313 /*
1314 * In case of multiple aborts on same cmd,
1315 * use try_wait_for_completion and completion_done() to check
1316 * whether it queues aborts even after completion of abort issued
1317 * prior.SNIC_BUG_ON(completion_done(&rqi->done));
1318 */
1319
1320 ret = snic_queue_wq_desc(snic, tmreq, sizeof(*tmreq));
1321 if (ret)
1322 SNIC_HOST_ERR(snic->shost,
1323 "qitmf:Queuing ITMF(%d) Req sc %p, rqi %p, req_id %d tag %d Failed, ret = %d\n",
1324 tmf, sc, rqi, req_id, snic_cmd_tag(sc), ret);
1325 else
1326 SNIC_SCSI_DBG(snic->shost,
1327 "qitmf:Queuing ITMF(%d) Req sc %p, rqi %p, req_id %d, tag %d (req_id)- Success.",
1328 tmf, sc, rqi, req_id, snic_cmd_tag(sc));
1329
1330 return ret;
1331 } /* end of snic_queue_itmf_req */
1332
1333 static int
snic_issue_tm_req(struct snic * snic,struct snic_req_info * rqi,struct scsi_cmnd * sc,int tmf)1334 snic_issue_tm_req(struct snic *snic,
1335 struct snic_req_info *rqi,
1336 struct scsi_cmnd *sc,
1337 int tmf)
1338 {
1339 struct snic_host_req *tmreq = NULL;
1340 int req_id = 0, tag = snic_cmd_tag(sc);
1341 int ret = 0;
1342
1343 if (snic_get_state(snic) == SNIC_FWRESET)
1344 return -EBUSY;
1345
1346 atomic_inc(&snic->ios_inflight);
1347
1348 SNIC_SCSI_DBG(snic->shost,
1349 "issu_tmreq: Task mgmt req %d. rqi %p w/ tag %x\n",
1350 tmf, rqi, tag);
1351
1352
1353 if (tmf == SNIC_ITMF_LUN_RESET) {
1354 tmreq = snic_dr_req_init(snic, rqi);
1355 req_id = SCSI_NO_TAG;
1356 } else {
1357 tmreq = snic_abort_req_init(snic, rqi);
1358 req_id = tag;
1359 }
1360
1361 if (!tmreq) {
1362 ret = -ENOMEM;
1363
1364 goto tmreq_err;
1365 }
1366
1367 ret = snic_queue_itmf_req(snic, tmreq, sc, tmf, req_id);
1368
1369 tmreq_err:
1370 if (ret) {
1371 SNIC_HOST_ERR(snic->shost,
1372 "issu_tmreq: Queueing ITMF(%d) Req, sc %p rqi %p req_id %d tag %x fails err = %d\n",
1373 tmf, sc, rqi, req_id, tag, ret);
1374 } else {
1375 SNIC_SCSI_DBG(snic->shost,
1376 "issu_tmreq: Queueing ITMF(%d) Req, sc %p, rqi %p, req_id %d tag %x - Success.\n",
1377 tmf, sc, rqi, req_id, tag);
1378 }
1379
1380 atomic_dec(&snic->ios_inflight);
1381
1382 return ret;
1383 }
1384
1385 /*
1386 * snic_queue_abort_req : Queues abort req to WQ
1387 */
1388 static int
snic_queue_abort_req(struct snic * snic,struct snic_req_info * rqi,struct scsi_cmnd * sc,int tmf)1389 snic_queue_abort_req(struct snic *snic,
1390 struct snic_req_info *rqi,
1391 struct scsi_cmnd *sc,
1392 int tmf)
1393 {
1394 SNIC_SCSI_DBG(snic->shost, "q_abtreq: sc %p, rqi %p, tag %x, tmf %d\n",
1395 sc, rqi, snic_cmd_tag(sc), tmf);
1396
1397 /* Add special tag for abort */
1398 rqi->tm_tag |= SNIC_TAG_ABORT;
1399
1400 return snic_issue_tm_req(snic, rqi, sc, tmf);
1401 }
1402
1403 /*
1404 * snic_abort_finish : called by snic_abort_cmd on queuing abort successfully.
1405 */
1406 static int
snic_abort_finish(struct snic * snic,struct scsi_cmnd * sc)1407 snic_abort_finish(struct snic *snic, struct scsi_cmnd *sc)
1408 {
1409 struct snic_req_info *rqi = NULL;
1410 spinlock_t *io_lock = NULL;
1411 unsigned long flags;
1412 int ret = 0, tag = snic_cmd_tag(sc);
1413
1414 io_lock = snic_io_lock_hash(snic, sc);
1415 spin_lock_irqsave(io_lock, flags);
1416 rqi = (struct snic_req_info *) CMD_SP(sc);
1417 if (!rqi) {
1418 atomic64_inc(&snic->s_stats.io.req_null);
1419 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL;
1420
1421 SNIC_SCSI_DBG(snic->shost,
1422 "abt_fini:req info is null tag 0x%x, sc 0x%p flags 0x%llx\n",
1423 tag, sc, CMD_FLAGS(sc));
1424 ret = FAILED;
1425
1426 goto abort_fail;
1427 }
1428
1429 rqi->abts_done = NULL;
1430
1431 ret = FAILED;
1432
1433 /* Check the abort status. */
1434 switch (CMD_ABTS_STATUS(sc)) {
1435 case SNIC_INVALID_CODE:
1436 /* Firmware didn't complete abort req, timedout */
1437 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TIMEDOUT;
1438 atomic64_inc(&snic->s_stats.abts.drv_tmo);
1439 SNIC_SCSI_DBG(snic->shost,
1440 "abt_fini:sc %p Tag %x Driver Timeout.flags 0x%llx\n",
1441 sc, snic_cmd_tag(sc), CMD_FLAGS(sc));
1442 /* do not release snic request in timedout case */
1443 rqi = NULL;
1444
1445 goto abort_fail;
1446
1447 case SNIC_STAT_IO_SUCCESS:
1448 case SNIC_STAT_IO_NOT_FOUND:
1449 ret = SUCCESS;
1450 /*
1451 * If abort path doesn't call scsi_done(),
1452 * the # IO timeouts == 2, will cause the LUN offline.
1453 * Call scsi_done to complete the IO.
1454 */
1455 sc->result = (DID_ERROR << 16);
1456 scsi_done(sc);
1457 break;
1458
1459 default:
1460 /* Firmware completed abort with error */
1461 ret = FAILED;
1462 rqi = NULL;
1463 break;
1464 }
1465
1466 CMD_SP(sc) = NULL;
1467 SNIC_HOST_INFO(snic->shost,
1468 "abt_fini: Tag %x, Cmpl Status %s flags 0x%llx\n",
1469 tag, snic_io_status_to_str(CMD_ABTS_STATUS(sc)),
1470 CMD_FLAGS(sc));
1471
1472 abort_fail:
1473 spin_unlock_irqrestore(io_lock, flags);
1474 if (rqi)
1475 snic_release_req_buf(snic, rqi, sc);
1476
1477 return ret;
1478 } /* end of snic_abort_finish */
1479
1480 /*
1481 * snic_send_abort_and_wait : Issues Abort, and Waits
1482 */
1483 static int
snic_send_abort_and_wait(struct snic * snic,struct scsi_cmnd * sc)1484 snic_send_abort_and_wait(struct snic *snic, struct scsi_cmnd *sc)
1485 {
1486 struct snic_req_info *rqi = NULL;
1487 enum snic_ioreq_state sv_state;
1488 struct snic_tgt *tgt = NULL;
1489 spinlock_t *io_lock = NULL;
1490 DECLARE_COMPLETION_ONSTACK(tm_done);
1491 unsigned long flags;
1492 int ret = 0, tmf = 0, tag = snic_cmd_tag(sc);
1493
1494 tgt = starget_to_tgt(scsi_target(sc->device));
1495 if ((snic_tgt_chkready(tgt) != 0) && (tgt->tdata.typ == SNIC_TGT_SAN))
1496 tmf = SNIC_ITMF_ABTS_TASK_TERM;
1497 else
1498 tmf = SNIC_ITMF_ABTS_TASK;
1499
1500 /* stats */
1501
1502 io_lock = snic_io_lock_hash(snic, sc);
1503
1504 /*
1505 * Avoid a race between SCSI issuing the abort and the device
1506 * completing the command.
1507 *
1508 * If the command is already completed by fw_cmpl code,
1509 * we just return SUCCESS from here. This means that the abort
1510 * succeeded. In the SCSI ML, since the timeout for command has
1511 * happend, the completion wont actually complete the command
1512 * and it will be considered as an aborted command
1513 *
1514 * The CMD_SP will not be cleared except while holding io_lock
1515 */
1516 spin_lock_irqsave(io_lock, flags);
1517 rqi = (struct snic_req_info *) CMD_SP(sc);
1518 if (!rqi) {
1519 spin_unlock_irqrestore(io_lock, flags);
1520
1521 SNIC_HOST_ERR(snic->shost,
1522 "abt_cmd: rqi is null. Tag %d flags 0x%llx\n",
1523 tag, CMD_FLAGS(sc));
1524
1525 ret = SUCCESS;
1526
1527 goto send_abts_end;
1528 }
1529
1530 rqi->abts_done = &tm_done;
1531 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) {
1532 spin_unlock_irqrestore(io_lock, flags);
1533
1534 ret = 0;
1535 goto abts_pending;
1536 }
1537 SNIC_BUG_ON(!rqi->abts_done);
1538
1539 /* Save Command State, should be restored on failed to Queue. */
1540 sv_state = CMD_STATE(sc);
1541
1542 /*
1543 * Command is still pending, need to abort it
1544 * If the fw completes the command after this point,
1545 * the completion won't be done till mid-layer, since abot
1546 * has already started.
1547 */
1548 CMD_STATE(sc) = SNIC_IOREQ_ABTS_PENDING;
1549 CMD_ABTS_STATUS(sc) = SNIC_INVALID_CODE;
1550
1551 SNIC_SCSI_DBG(snic->shost, "send_abt_cmd: TAG 0x%x\n", tag);
1552
1553 spin_unlock_irqrestore(io_lock, flags);
1554
1555 /* Now Queue the abort command to firmware */
1556 ret = snic_queue_abort_req(snic, rqi, sc, tmf);
1557 if (ret) {
1558 atomic64_inc(&snic->s_stats.abts.q_fail);
1559 SNIC_HOST_ERR(snic->shost,
1560 "send_abt_cmd: IO w/ Tag 0x%x fail w/ err %d flags 0x%llx\n",
1561 tag, ret, CMD_FLAGS(sc));
1562
1563 spin_lock_irqsave(io_lock, flags);
1564 /* Restore Command's previous state */
1565 CMD_STATE(sc) = sv_state;
1566 rqi = (struct snic_req_info *) CMD_SP(sc);
1567 if (rqi)
1568 rqi->abts_done = NULL;
1569 spin_unlock_irqrestore(io_lock, flags);
1570 ret = FAILED;
1571
1572 goto send_abts_end;
1573 }
1574
1575 spin_lock_irqsave(io_lock, flags);
1576 if (tmf == SNIC_ITMF_ABTS_TASK) {
1577 CMD_FLAGS(sc) |= SNIC_IO_ABTS_ISSUED;
1578 atomic64_inc(&snic->s_stats.abts.num);
1579 } else {
1580 /* term stats */
1581 CMD_FLAGS(sc) |= SNIC_IO_TERM_ISSUED;
1582 }
1583 spin_unlock_irqrestore(io_lock, flags);
1584
1585 SNIC_SCSI_DBG(snic->shost,
1586 "send_abt_cmd: sc %p Tag %x flags 0x%llx\n",
1587 sc, tag, CMD_FLAGS(sc));
1588
1589
1590 ret = 0;
1591
1592 abts_pending:
1593 /*
1594 * Queued an abort IO, wait for its completion.
1595 * Once the fw completes the abort command, it will
1596 * wakeup this thread.
1597 */
1598 wait_for_completion_timeout(&tm_done, SNIC_ABTS_TIMEOUT);
1599
1600 send_abts_end:
1601 return ret;
1602 } /* end of snic_send_abort_and_wait */
1603
1604 /*
1605 * This function is exported to SCSI for sending abort cmnds.
1606 * A SCSI IO is represent by snic_ioreq in the driver.
1607 * The snic_ioreq is linked to the SCSI Cmd, thus a link with the ULP'S IO
1608 */
1609 int
snic_abort_cmd(struct scsi_cmnd * sc)1610 snic_abort_cmd(struct scsi_cmnd *sc)
1611 {
1612 struct snic *snic = shost_priv(sc->device->host);
1613 int ret = SUCCESS, tag = snic_cmd_tag(sc);
1614 u32 start_time = jiffies;
1615
1616 SNIC_SCSI_DBG(snic->shost, "abt_cmd:sc %p :0x%x :req = %p :tag = %d\n",
1617 sc, sc->cmnd[0], scsi_cmd_to_rq(sc), tag);
1618
1619 if (unlikely(snic_get_state(snic) != SNIC_ONLINE)) {
1620 SNIC_HOST_ERR(snic->shost,
1621 "abt_cmd: tag %x Parent Devs are not rdy\n",
1622 tag);
1623 ret = FAST_IO_FAIL;
1624
1625 goto abort_end;
1626 }
1627
1628
1629 ret = snic_send_abort_and_wait(snic, sc);
1630 if (ret)
1631 goto abort_end;
1632
1633 ret = snic_abort_finish(snic, sc);
1634
1635 abort_end:
1636 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc,
1637 jiffies_to_msecs(jiffies - start_time), 0,
1638 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
1639
1640 SNIC_SCSI_DBG(snic->shost,
1641 "abts: Abort Req Status = %s\n",
1642 (ret == SUCCESS) ? "SUCCESS" :
1643 ((ret == FAST_IO_FAIL) ? "FAST_IO_FAIL" : "FAILED"));
1644
1645 return ret;
1646 }
1647
1648
1649
1650 static int
snic_is_abts_pending(struct snic * snic,struct scsi_cmnd * lr_sc)1651 snic_is_abts_pending(struct snic *snic, struct scsi_cmnd *lr_sc)
1652 {
1653 struct snic_req_info *rqi = NULL;
1654 struct scsi_cmnd *sc = NULL;
1655 struct scsi_device *lr_sdev = NULL;
1656 spinlock_t *io_lock = NULL;
1657 u32 tag;
1658 unsigned long flags;
1659
1660 if (lr_sc)
1661 lr_sdev = lr_sc->device;
1662
1663 /* walk through the tag map, an dcheck if IOs are still pending in fw*/
1664 for (tag = 0; tag < snic->max_tag_id; tag++) {
1665 io_lock = snic_io_lock_tag(snic, tag);
1666
1667 spin_lock_irqsave(io_lock, flags);
1668 sc = scsi_host_find_tag(snic->shost, tag);
1669
1670 if (!sc || (lr_sc && (sc->device != lr_sdev || sc == lr_sc))) {
1671 spin_unlock_irqrestore(io_lock, flags);
1672
1673 continue;
1674 }
1675
1676 rqi = (struct snic_req_info *) CMD_SP(sc);
1677 if (!rqi) {
1678 spin_unlock_irqrestore(io_lock, flags);
1679
1680 continue;
1681 }
1682
1683 /*
1684 * Found IO that is still pending w/ firmware and belongs to
1685 * the LUN that is under reset, if lr_sc != NULL
1686 */
1687 SNIC_SCSI_DBG(snic->shost, "Found IO in %s on LUN\n",
1688 snic_ioreq_state_to_str(CMD_STATE(sc)));
1689
1690 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING) {
1691 spin_unlock_irqrestore(io_lock, flags);
1692
1693 return 1;
1694 }
1695
1696 spin_unlock_irqrestore(io_lock, flags);
1697 }
1698
1699 return 0;
1700 } /* end of snic_is_abts_pending */
1701
1702 static int
snic_dr_clean_single_req(struct snic * snic,u32 tag,struct scsi_device * lr_sdev)1703 snic_dr_clean_single_req(struct snic *snic,
1704 u32 tag,
1705 struct scsi_device *lr_sdev)
1706 {
1707 struct snic_req_info *rqi = NULL;
1708 struct snic_tgt *tgt = NULL;
1709 struct scsi_cmnd *sc = NULL;
1710 spinlock_t *io_lock = NULL;
1711 u32 sv_state = 0, tmf = 0;
1712 DECLARE_COMPLETION_ONSTACK(tm_done);
1713 unsigned long flags;
1714 int ret = 0;
1715
1716 io_lock = snic_io_lock_tag(snic, tag);
1717 spin_lock_irqsave(io_lock, flags);
1718 sc = scsi_host_find_tag(snic->shost, tag);
1719
1720 /* Ignore Cmd that don't belong to Lun Reset device */
1721 if (!sc || sc->device != lr_sdev)
1722 goto skip_clean;
1723
1724 rqi = (struct snic_req_info *) CMD_SP(sc);
1725
1726 if (!rqi)
1727 goto skip_clean;
1728
1729
1730 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
1731 goto skip_clean;
1732
1733
1734 if ((CMD_FLAGS(sc) & SNIC_DEVICE_RESET) &&
1735 (!(CMD_FLAGS(sc) & SNIC_DEV_RST_ISSUED))) {
1736
1737 SNIC_SCSI_DBG(snic->shost,
1738 "clean_single_req: devrst is not pending sc 0x%p\n",
1739 sc);
1740
1741 goto skip_clean;
1742 }
1743
1744 SNIC_SCSI_DBG(snic->shost,
1745 "clean_single_req: Found IO in %s on lun\n",
1746 snic_ioreq_state_to_str(CMD_STATE(sc)));
1747
1748 /* Save Command State */
1749 sv_state = CMD_STATE(sc);
1750
1751 /*
1752 * Any pending IO issued prior to reset is expected to be
1753 * in abts pending state, if not we need to set SNIC_IOREQ_ABTS_PENDING
1754 * to indicate the IO is abort pending.
1755 * When IO is completed, the IO will be handed over and handled
1756 * in this function.
1757 */
1758
1759 CMD_STATE(sc) = SNIC_IOREQ_ABTS_PENDING;
1760 SNIC_BUG_ON(rqi->abts_done);
1761
1762 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) {
1763 rqi->tm_tag = SNIC_TAG_DEV_RST;
1764
1765 SNIC_SCSI_DBG(snic->shost,
1766 "clean_single_req:devrst sc 0x%p\n", sc);
1767 }
1768
1769 CMD_ABTS_STATUS(sc) = SNIC_INVALID_CODE;
1770 rqi->abts_done = &tm_done;
1771 spin_unlock_irqrestore(io_lock, flags);
1772
1773 tgt = starget_to_tgt(scsi_target(sc->device));
1774 if ((snic_tgt_chkready(tgt) != 0) && (tgt->tdata.typ == SNIC_TGT_SAN))
1775 tmf = SNIC_ITMF_ABTS_TASK_TERM;
1776 else
1777 tmf = SNIC_ITMF_ABTS_TASK;
1778
1779 /* Now queue the abort command to firmware */
1780 ret = snic_queue_abort_req(snic, rqi, sc, tmf);
1781 if (ret) {
1782 SNIC_HOST_ERR(snic->shost,
1783 "clean_single_req_err:sc %p, tag %d abt failed. tm_tag %d flags 0x%llx\n",
1784 sc, tag, rqi->tm_tag, CMD_FLAGS(sc));
1785
1786 spin_lock_irqsave(io_lock, flags);
1787 rqi = (struct snic_req_info *) CMD_SP(sc);
1788 if (rqi)
1789 rqi->abts_done = NULL;
1790
1791 /* Restore Command State */
1792 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
1793 CMD_STATE(sc) = sv_state;
1794
1795 ret = 1;
1796 goto skip_clean;
1797 }
1798
1799 spin_lock_irqsave(io_lock, flags);
1800 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET)
1801 CMD_FLAGS(sc) |= SNIC_DEV_RST_TERM_ISSUED;
1802
1803 CMD_FLAGS(sc) |= SNIC_IO_INTERNAL_TERM_ISSUED;
1804 spin_unlock_irqrestore(io_lock, flags);
1805
1806 wait_for_completion_timeout(&tm_done, SNIC_ABTS_TIMEOUT);
1807
1808 /* Recheck cmd state to check if it now aborted. */
1809 spin_lock_irqsave(io_lock, flags);
1810 rqi = (struct snic_req_info *) CMD_SP(sc);
1811 if (!rqi) {
1812 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_REQ_NULL;
1813 goto skip_clean;
1814 }
1815 rqi->abts_done = NULL;
1816
1817 /* if abort is still pending w/ fw, fail */
1818 if (CMD_ABTS_STATUS(sc) == SNIC_INVALID_CODE) {
1819 SNIC_HOST_ERR(snic->shost,
1820 "clean_single_req_err:sc %p tag %d abt still pending w/ fw, tm_tag %d flags 0x%llx\n",
1821 sc, tag, rqi->tm_tag, CMD_FLAGS(sc));
1822
1823 CMD_FLAGS(sc) |= SNIC_IO_ABTS_TERM_DONE;
1824 ret = 1;
1825
1826 goto skip_clean;
1827 }
1828
1829 CMD_STATE(sc) = SNIC_IOREQ_ABTS_COMPLETE;
1830 CMD_SP(sc) = NULL;
1831 spin_unlock_irqrestore(io_lock, flags);
1832
1833 snic_release_req_buf(snic, rqi, sc);
1834
1835 sc->result = (DID_ERROR << 16);
1836 scsi_done(sc);
1837
1838 ret = 0;
1839
1840 return ret;
1841
1842 skip_clean:
1843 spin_unlock_irqrestore(io_lock, flags);
1844
1845 return ret;
1846 } /* end of snic_dr_clean_single_req */
1847
1848 static int
snic_dr_clean_pending_req(struct snic * snic,struct scsi_cmnd * lr_sc)1849 snic_dr_clean_pending_req(struct snic *snic, struct scsi_cmnd *lr_sc)
1850 {
1851 struct scsi_device *lr_sdev = lr_sc->device;
1852 u32 tag = 0;
1853 int ret = FAILED;
1854
1855 for (tag = 0; tag < snic->max_tag_id; tag++) {
1856 if (tag == snic_cmd_tag(lr_sc))
1857 continue;
1858
1859 ret = snic_dr_clean_single_req(snic, tag, lr_sdev);
1860 if (ret) {
1861 SNIC_HOST_ERR(snic->shost, "clean_err:tag = %d\n", tag);
1862
1863 goto clean_err;
1864 }
1865 }
1866
1867 schedule_timeout(msecs_to_jiffies(100));
1868
1869 /* Walk through all the cmds and check abts status. */
1870 if (snic_is_abts_pending(snic, lr_sc)) {
1871 ret = FAILED;
1872
1873 goto clean_err;
1874 }
1875
1876 ret = 0;
1877 SNIC_SCSI_DBG(snic->shost, "clean_pending_req: Success.\n");
1878
1879 return ret;
1880
1881 clean_err:
1882 ret = FAILED;
1883 SNIC_HOST_ERR(snic->shost,
1884 "Failed to Clean Pending IOs on %s device.\n",
1885 dev_name(&lr_sdev->sdev_gendev));
1886
1887 return ret;
1888
1889 } /* end of snic_dr_clean_pending_req */
1890
1891 /*
1892 * snic_dr_finish : Called by snic_device_reset
1893 */
1894 static int
snic_dr_finish(struct snic * snic,struct scsi_cmnd * sc)1895 snic_dr_finish(struct snic *snic, struct scsi_cmnd *sc)
1896 {
1897 struct snic_req_info *rqi = NULL;
1898 spinlock_t *io_lock = NULL;
1899 unsigned long flags;
1900 int lr_res = 0;
1901 int ret = FAILED;
1902
1903 io_lock = snic_io_lock_hash(snic, sc);
1904 spin_lock_irqsave(io_lock, flags);
1905 rqi = (struct snic_req_info *) CMD_SP(sc);
1906 if (!rqi) {
1907 spin_unlock_irqrestore(io_lock, flags);
1908 SNIC_SCSI_DBG(snic->shost,
1909 "dr_fini: rqi is null tag 0x%x sc 0x%p flags 0x%llx\n",
1910 snic_cmd_tag(sc), sc, CMD_FLAGS(sc));
1911
1912 ret = FAILED;
1913 goto dr_fini_end;
1914 }
1915
1916 rqi->dr_done = NULL;
1917
1918 lr_res = CMD_LR_STATUS(sc);
1919
1920 switch (lr_res) {
1921 case SNIC_INVALID_CODE:
1922 /* stats */
1923 SNIC_SCSI_DBG(snic->shost,
1924 "dr_fini: Tag %x Dev Reset Timedout. flags 0x%llx\n",
1925 snic_cmd_tag(sc), CMD_FLAGS(sc));
1926
1927 CMD_FLAGS(sc) |= SNIC_DEV_RST_TIMEDOUT;
1928 ret = FAILED;
1929
1930 goto dr_failed;
1931
1932 case SNIC_STAT_IO_SUCCESS:
1933 SNIC_SCSI_DBG(snic->shost,
1934 "dr_fini: Tag %x Dev Reset cmpl\n",
1935 snic_cmd_tag(sc));
1936 ret = 0;
1937 break;
1938
1939 default:
1940 SNIC_HOST_ERR(snic->shost,
1941 "dr_fini:Device Reset completed& failed.Tag = %x lr_status %s flags 0x%llx\n",
1942 snic_cmd_tag(sc),
1943 snic_io_status_to_str(lr_res), CMD_FLAGS(sc));
1944 ret = FAILED;
1945 goto dr_failed;
1946 }
1947 spin_unlock_irqrestore(io_lock, flags);
1948
1949 /*
1950 * Cleanup any IOs on this LUN that have still not completed.
1951 * If any of these fail, then LUN Reset fails.
1952 * Cleanup cleans all commands on this LUN except
1953 * the lun reset command. If all cmds get cleaned, the LUN Reset
1954 * succeeds.
1955 */
1956
1957 ret = snic_dr_clean_pending_req(snic, sc);
1958 if (ret) {
1959 spin_lock_irqsave(io_lock, flags);
1960 SNIC_SCSI_DBG(snic->shost,
1961 "dr_fini: Device Reset Failed since could not abort all IOs. Tag = %x.\n",
1962 snic_cmd_tag(sc));
1963 rqi = (struct snic_req_info *) CMD_SP(sc);
1964
1965 goto dr_failed;
1966 } else {
1967 /* Cleanup LUN Reset Command */
1968 spin_lock_irqsave(io_lock, flags);
1969 rqi = (struct snic_req_info *) CMD_SP(sc);
1970 if (rqi)
1971 ret = SUCCESS; /* Completed Successfully */
1972 else
1973 ret = FAILED;
1974 }
1975
1976 dr_failed:
1977 lockdep_assert_held(io_lock);
1978 if (rqi)
1979 CMD_SP(sc) = NULL;
1980 spin_unlock_irqrestore(io_lock, flags);
1981
1982 if (rqi)
1983 snic_release_req_buf(snic, rqi, sc);
1984
1985 dr_fini_end:
1986 return ret;
1987 } /* end of snic_dr_finish */
1988
1989 static int
snic_queue_dr_req(struct snic * snic,struct snic_req_info * rqi,struct scsi_cmnd * sc)1990 snic_queue_dr_req(struct snic *snic,
1991 struct snic_req_info *rqi,
1992 struct scsi_cmnd *sc)
1993 {
1994 /* Add special tag for device reset */
1995 rqi->tm_tag |= SNIC_TAG_DEV_RST;
1996
1997 return snic_issue_tm_req(snic, rqi, sc, SNIC_ITMF_LUN_RESET);
1998 }
1999
2000 static int
snic_send_dr_and_wait(struct snic * snic,struct scsi_cmnd * sc)2001 snic_send_dr_and_wait(struct snic *snic, struct scsi_cmnd *sc)
2002 {
2003 struct snic_req_info *rqi = NULL;
2004 enum snic_ioreq_state sv_state;
2005 spinlock_t *io_lock = NULL;
2006 unsigned long flags;
2007 DECLARE_COMPLETION_ONSTACK(tm_done);
2008 int ret = FAILED, tag = snic_cmd_tag(sc);
2009
2010 io_lock = snic_io_lock_hash(snic, sc);
2011 spin_lock_irqsave(io_lock, flags);
2012 CMD_FLAGS(sc) |= SNIC_DEVICE_RESET;
2013 rqi = (struct snic_req_info *) CMD_SP(sc);
2014 if (!rqi) {
2015 SNIC_HOST_ERR(snic->shost,
2016 "send_dr: rqi is null, Tag 0x%x flags 0x%llx\n",
2017 tag, CMD_FLAGS(sc));
2018 spin_unlock_irqrestore(io_lock, flags);
2019
2020 ret = FAILED;
2021 goto send_dr_end;
2022 }
2023
2024 /* Save Command state to restore in case Queuing failed. */
2025 sv_state = CMD_STATE(sc);
2026
2027 CMD_STATE(sc) = SNIC_IOREQ_LR_PENDING;
2028 CMD_LR_STATUS(sc) = SNIC_INVALID_CODE;
2029
2030 SNIC_SCSI_DBG(snic->shost, "dr: TAG = %x\n", tag);
2031
2032 rqi->dr_done = &tm_done;
2033 SNIC_BUG_ON(!rqi->dr_done);
2034
2035 spin_unlock_irqrestore(io_lock, flags);
2036 /*
2037 * The Command state is changed to IOREQ_PENDING,
2038 * in this case, if the command is completed, the icmnd_cmpl will
2039 * mark the cmd as completed.
2040 * This logic still makes LUN Reset is inevitable.
2041 */
2042
2043 ret = snic_queue_dr_req(snic, rqi, sc);
2044 if (ret) {
2045 SNIC_HOST_ERR(snic->shost,
2046 "send_dr: IO w/ Tag 0x%x Failed err = %d. flags 0x%llx\n",
2047 tag, ret, CMD_FLAGS(sc));
2048
2049 spin_lock_irqsave(io_lock, flags);
2050 /* Restore State */
2051 CMD_STATE(sc) = sv_state;
2052 rqi = (struct snic_req_info *) CMD_SP(sc);
2053 if (rqi)
2054 rqi->dr_done = NULL;
2055 /* rqi is freed in caller. */
2056 spin_unlock_irqrestore(io_lock, flags);
2057 ret = FAILED;
2058
2059 goto send_dr_end;
2060 }
2061
2062 spin_lock_irqsave(io_lock, flags);
2063 CMD_FLAGS(sc) |= SNIC_DEV_RST_ISSUED;
2064 spin_unlock_irqrestore(io_lock, flags);
2065
2066 ret = 0;
2067
2068 wait_for_completion_timeout(&tm_done, SNIC_LUN_RESET_TIMEOUT);
2069
2070 send_dr_end:
2071 return ret;
2072 }
2073
2074 /*
2075 * auxillary funciton to check lun reset op is supported or not
2076 * Not supported if returns 0
2077 */
2078 static int
snic_dev_reset_supported(struct scsi_device * sdev)2079 snic_dev_reset_supported(struct scsi_device *sdev)
2080 {
2081 struct snic_tgt *tgt = starget_to_tgt(scsi_target(sdev));
2082
2083 if (tgt->tdata.typ == SNIC_TGT_DAS)
2084 return 0;
2085
2086 return 1;
2087 }
2088
2089 static void
snic_unlink_and_release_req(struct snic * snic,struct scsi_cmnd * sc,int flag)2090 snic_unlink_and_release_req(struct snic *snic, struct scsi_cmnd *sc, int flag)
2091 {
2092 struct snic_req_info *rqi = NULL;
2093 spinlock_t *io_lock = NULL;
2094 unsigned long flags;
2095 u32 start_time = jiffies;
2096
2097 io_lock = snic_io_lock_hash(snic, sc);
2098 spin_lock_irqsave(io_lock, flags);
2099 rqi = (struct snic_req_info *) CMD_SP(sc);
2100 if (rqi) {
2101 start_time = rqi->start_time;
2102 CMD_SP(sc) = NULL;
2103 }
2104
2105 CMD_FLAGS(sc) |= flag;
2106 spin_unlock_irqrestore(io_lock, flags);
2107
2108 if (rqi)
2109 snic_release_req_buf(snic, rqi, sc);
2110
2111 SNIC_TRC(snic->shost->host_no, snic_cmd_tag(sc), (ulong) sc,
2112 jiffies_to_msecs(jiffies - start_time), (ulong) rqi,
2113 SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
2114 }
2115
2116 /*
2117 * SCSI Eh thread issues a LUN Reset when one or more commands on a LUN
2118 * fail to get aborted. It calls driver's eh_device_reset with a SCSI
2119 * command on the LUN.
2120 */
2121 int
snic_device_reset(struct scsi_cmnd * sc)2122 snic_device_reset(struct scsi_cmnd *sc)
2123 {
2124 struct Scsi_Host *shost = sc->device->host;
2125 struct snic *snic = shost_priv(shost);
2126 struct snic_req_info *rqi = NULL;
2127 int tag = snic_cmd_tag(sc);
2128 int start_time = jiffies;
2129 int ret = FAILED;
2130 int dr_supp = 0;
2131
2132 SNIC_SCSI_DBG(shost, "dev_reset:sc %p :0x%x :req = %p :tag = %d\n",
2133 sc, sc->cmnd[0], scsi_cmd_to_rq(sc),
2134 snic_cmd_tag(sc));
2135 dr_supp = snic_dev_reset_supported(sc->device);
2136 if (!dr_supp) {
2137 /* device reset op is not supported */
2138 SNIC_HOST_INFO(shost, "LUN Reset Op not supported.\n");
2139 snic_unlink_and_release_req(snic, sc, SNIC_DEV_RST_NOTSUP);
2140
2141 goto dev_rst_end;
2142 }
2143
2144 if (unlikely(snic_get_state(snic) != SNIC_ONLINE)) {
2145 snic_unlink_and_release_req(snic, sc, 0);
2146 SNIC_HOST_ERR(shost, "Devrst: Parent Devs are not online.\n");
2147
2148 goto dev_rst_end;
2149 }
2150
2151 /* There is no tag when lun reset is issue through ioctl. */
2152 if (unlikely(tag <= SNIC_NO_TAG)) {
2153 SNIC_HOST_INFO(snic->shost,
2154 "Devrst: LUN Reset Recvd thru IOCTL.\n");
2155
2156 rqi = snic_req_init(snic, 0);
2157 if (!rqi)
2158 goto dev_rst_end;
2159
2160 memset(scsi_cmd_priv(sc), 0,
2161 sizeof(struct snic_internal_io_state));
2162 CMD_SP(sc) = (char *)rqi;
2163 CMD_FLAGS(sc) = SNIC_NO_FLAGS;
2164
2165 /* Add special tag for dr coming from user spc */
2166 rqi->tm_tag = SNIC_TAG_IOCTL_DEV_RST;
2167 rqi->sc = sc;
2168 }
2169
2170 ret = snic_send_dr_and_wait(snic, sc);
2171 if (ret) {
2172 SNIC_HOST_ERR(snic->shost,
2173 "Devrst: IO w/ Tag %x Failed w/ err = %d\n",
2174 tag, ret);
2175
2176 snic_unlink_and_release_req(snic, sc, 0);
2177
2178 goto dev_rst_end;
2179 }
2180
2181 ret = snic_dr_finish(snic, sc);
2182
2183 dev_rst_end:
2184 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc,
2185 jiffies_to_msecs(jiffies - start_time),
2186 0, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
2187
2188 SNIC_SCSI_DBG(snic->shost,
2189 "Devrst: Returning from Device Reset : %s\n",
2190 (ret == SUCCESS) ? "SUCCESS" : "FAILED");
2191
2192 return ret;
2193 } /* end of snic_device_reset */
2194
2195 /*
2196 * SCSI Error handling calls driver's eh_host_reset if all prior
2197 * error handling levels return FAILED.
2198 *
2199 * Host Reset is the highest level of error recovery. If this fails, then
2200 * host is offlined by SCSI.
2201 */
2202 /*
2203 * snic_issue_hba_reset : Queues FW Reset Request.
2204 */
2205 static int
snic_issue_hba_reset(struct snic * snic,struct scsi_cmnd * sc)2206 snic_issue_hba_reset(struct snic *snic, struct scsi_cmnd *sc)
2207 {
2208 struct snic_req_info *rqi = NULL;
2209 struct snic_host_req *req = NULL;
2210 spinlock_t *io_lock = NULL;
2211 DECLARE_COMPLETION_ONSTACK(wait);
2212 unsigned long flags;
2213 int ret = -ENOMEM;
2214
2215 rqi = snic_req_init(snic, 0);
2216 if (!rqi) {
2217 ret = -ENOMEM;
2218
2219 goto hba_rst_end;
2220 }
2221
2222 if (snic_cmd_tag(sc) == SCSI_NO_TAG) {
2223 memset(scsi_cmd_priv(sc), 0,
2224 sizeof(struct snic_internal_io_state));
2225 SNIC_HOST_INFO(snic->shost, "issu_hr:Host reset thru ioctl.\n");
2226 rqi->sc = sc;
2227 }
2228
2229 req = rqi_to_req(rqi);
2230
2231 io_lock = snic_io_lock_hash(snic, sc);
2232 spin_lock_irqsave(io_lock, flags);
2233 SNIC_BUG_ON(CMD_SP(sc) != NULL);
2234 CMD_STATE(sc) = SNIC_IOREQ_PENDING;
2235 CMD_SP(sc) = (char *) rqi;
2236 CMD_FLAGS(sc) |= SNIC_IO_INITIALIZED;
2237 snic->remove_wait = &wait;
2238 spin_unlock_irqrestore(io_lock, flags);
2239
2240 /* Initialize Request */
2241 snic_io_hdr_enc(&req->hdr, SNIC_REQ_HBA_RESET, 0, snic_cmd_tag(sc),
2242 snic->config.hid, 0, (ulong) rqi);
2243
2244 req->u.reset.flags = 0;
2245
2246 ret = snic_queue_wq_desc(snic, req, sizeof(*req));
2247 if (ret) {
2248 SNIC_HOST_ERR(snic->shost,
2249 "issu_hr:Queuing HBA Reset Failed. w err %d\n",
2250 ret);
2251
2252 goto hba_rst_err;
2253 }
2254
2255 spin_lock_irqsave(io_lock, flags);
2256 CMD_FLAGS(sc) |= SNIC_HOST_RESET_ISSUED;
2257 spin_unlock_irqrestore(io_lock, flags);
2258 atomic64_inc(&snic->s_stats.reset.hba_resets);
2259 SNIC_HOST_INFO(snic->shost, "Queued HBA Reset Successfully.\n");
2260
2261 wait_for_completion_timeout(snic->remove_wait,
2262 SNIC_HOST_RESET_TIMEOUT);
2263
2264 if (snic_get_state(snic) == SNIC_FWRESET) {
2265 SNIC_HOST_ERR(snic->shost, "reset_cmpl: Reset Timedout.\n");
2266 ret = -ETIMEDOUT;
2267
2268 goto hba_rst_err;
2269 }
2270
2271 spin_lock_irqsave(io_lock, flags);
2272 snic->remove_wait = NULL;
2273 rqi = (struct snic_req_info *) CMD_SP(sc);
2274 CMD_SP(sc) = NULL;
2275 spin_unlock_irqrestore(io_lock, flags);
2276
2277 if (rqi)
2278 snic_req_free(snic, rqi);
2279
2280 ret = 0;
2281
2282 return ret;
2283
2284 hba_rst_err:
2285 spin_lock_irqsave(io_lock, flags);
2286 snic->remove_wait = NULL;
2287 rqi = (struct snic_req_info *) CMD_SP(sc);
2288 CMD_SP(sc) = NULL;
2289 spin_unlock_irqrestore(io_lock, flags);
2290
2291 if (rqi)
2292 snic_req_free(snic, rqi);
2293
2294 hba_rst_end:
2295 SNIC_HOST_ERR(snic->shost,
2296 "reset:HBA Reset Failed w/ err = %d.\n",
2297 ret);
2298
2299 return ret;
2300 } /* end of snic_issue_hba_reset */
2301
2302 int
snic_reset(struct Scsi_Host * shost,struct scsi_cmnd * sc)2303 snic_reset(struct Scsi_Host *shost, struct scsi_cmnd *sc)
2304 {
2305 struct snic *snic = shost_priv(shost);
2306 enum snic_state sv_state;
2307 unsigned long flags;
2308 int ret = FAILED;
2309
2310 /* Set snic state as SNIC_FWRESET*/
2311 sv_state = snic_get_state(snic);
2312
2313 spin_lock_irqsave(&snic->snic_lock, flags);
2314 if (snic_get_state(snic) == SNIC_FWRESET) {
2315 spin_unlock_irqrestore(&snic->snic_lock, flags);
2316 SNIC_HOST_INFO(shost, "reset:prev reset is in progress\n");
2317
2318 msleep(SNIC_HOST_RESET_TIMEOUT);
2319 ret = SUCCESS;
2320
2321 goto reset_end;
2322 }
2323
2324 snic_set_state(snic, SNIC_FWRESET);
2325 spin_unlock_irqrestore(&snic->snic_lock, flags);
2326
2327
2328 /* Wait for all the IOs that are entered in Qcmd */
2329 while (atomic_read(&snic->ios_inflight))
2330 schedule_timeout(msecs_to_jiffies(1));
2331
2332 ret = snic_issue_hba_reset(snic, sc);
2333 if (ret) {
2334 SNIC_HOST_ERR(shost,
2335 "reset:Host Reset Failed w/ err %d.\n",
2336 ret);
2337 spin_lock_irqsave(&snic->snic_lock, flags);
2338 snic_set_state(snic, sv_state);
2339 spin_unlock_irqrestore(&snic->snic_lock, flags);
2340 atomic64_inc(&snic->s_stats.reset.hba_reset_fail);
2341 ret = FAILED;
2342
2343 goto reset_end;
2344 }
2345
2346 ret = SUCCESS;
2347
2348 reset_end:
2349 return ret;
2350 } /* end of snic_reset */
2351
2352 /*
2353 * SCSI Error handling calls driver's eh_host_reset if all prior
2354 * error handling levels return FAILED.
2355 *
2356 * Host Reset is the highest level of error recovery. If this fails, then
2357 * host is offlined by SCSI.
2358 */
2359 int
snic_host_reset(struct scsi_cmnd * sc)2360 snic_host_reset(struct scsi_cmnd *sc)
2361 {
2362 struct Scsi_Host *shost = sc->device->host;
2363 u32 start_time = jiffies;
2364 int ret;
2365
2366 SNIC_SCSI_DBG(shost,
2367 "host reset:sc %p sc_cmd 0x%x req %p tag %d flags 0x%llx\n",
2368 sc, sc->cmnd[0], scsi_cmd_to_rq(sc),
2369 snic_cmd_tag(sc), CMD_FLAGS(sc));
2370
2371 ret = snic_reset(shost, sc);
2372
2373 SNIC_TRC(shost->host_no, snic_cmd_tag(sc), (ulong) sc,
2374 jiffies_to_msecs(jiffies - start_time),
2375 0, SNIC_TRC_CMD(sc), SNIC_TRC_CMD_STATE_FLAGS(sc));
2376
2377 return ret;
2378 } /* end of snic_host_reset */
2379
2380 /*
2381 * snic_cmpl_pending_tmreq : Caller should hold io_lock
2382 */
2383 static void
snic_cmpl_pending_tmreq(struct snic * snic,struct scsi_cmnd * sc)2384 snic_cmpl_pending_tmreq(struct snic *snic, struct scsi_cmnd *sc)
2385 {
2386 struct snic_req_info *rqi = NULL;
2387
2388 SNIC_SCSI_DBG(snic->shost,
2389 "Completing Pending TM Req sc %p, state %s flags 0x%llx\n",
2390 sc, snic_io_status_to_str(CMD_STATE(sc)), CMD_FLAGS(sc));
2391
2392 /*
2393 * CASE : FW didn't post itmf completion due to PCIe Errors.
2394 * Marking the abort status as Success to call scsi completion
2395 * in snic_abort_finish()
2396 */
2397 CMD_ABTS_STATUS(sc) = SNIC_STAT_IO_SUCCESS;
2398
2399 rqi = (struct snic_req_info *) CMD_SP(sc);
2400 if (!rqi)
2401 return;
2402
2403 if (rqi->dr_done)
2404 complete(rqi->dr_done);
2405 else if (rqi->abts_done)
2406 complete(rqi->abts_done);
2407 }
2408
2409 /*
2410 * snic_scsi_cleanup: Walks through tag map and releases the reqs
2411 */
2412 static void
snic_scsi_cleanup(struct snic * snic,int ex_tag)2413 snic_scsi_cleanup(struct snic *snic, int ex_tag)
2414 {
2415 struct snic_req_info *rqi = NULL;
2416 struct scsi_cmnd *sc = NULL;
2417 spinlock_t *io_lock = NULL;
2418 unsigned long flags;
2419 int tag;
2420 u64 st_time = 0;
2421
2422 SNIC_SCSI_DBG(snic->shost, "sc_clean: scsi cleanup.\n");
2423
2424 for (tag = 0; tag < snic->max_tag_id; tag++) {
2425 /* Skip ex_tag */
2426 if (tag == ex_tag)
2427 continue;
2428
2429 io_lock = snic_io_lock_tag(snic, tag);
2430 spin_lock_irqsave(io_lock, flags);
2431 sc = scsi_host_find_tag(snic->shost, tag);
2432 if (!sc) {
2433 spin_unlock_irqrestore(io_lock, flags);
2434
2435 continue;
2436 }
2437
2438 if (unlikely(snic_tmreq_pending(sc))) {
2439 /*
2440 * When FW Completes reset w/o sending completions
2441 * for outstanding ios.
2442 */
2443 snic_cmpl_pending_tmreq(snic, sc);
2444 spin_unlock_irqrestore(io_lock, flags);
2445
2446 continue;
2447 }
2448
2449 rqi = (struct snic_req_info *) CMD_SP(sc);
2450 if (!rqi) {
2451 spin_unlock_irqrestore(io_lock, flags);
2452
2453 goto cleanup;
2454 }
2455
2456 SNIC_SCSI_DBG(snic->shost,
2457 "sc_clean: sc %p, rqi %p, tag %d flags 0x%llx\n",
2458 sc, rqi, tag, CMD_FLAGS(sc));
2459
2460 CMD_SP(sc) = NULL;
2461 CMD_FLAGS(sc) |= SNIC_SCSI_CLEANUP;
2462 spin_unlock_irqrestore(io_lock, flags);
2463 st_time = rqi->start_time;
2464
2465 SNIC_HOST_INFO(snic->shost,
2466 "sc_clean: Releasing rqi %p : flags 0x%llx\n",
2467 rqi, CMD_FLAGS(sc));
2468
2469 snic_release_req_buf(snic, rqi, sc);
2470
2471 cleanup:
2472 sc->result = DID_TRANSPORT_DISRUPTED << 16;
2473 SNIC_HOST_INFO(snic->shost,
2474 "sc_clean: DID_TRANSPORT_DISRUPTED for sc %p, Tag %d flags 0x%llx rqi %p duration %u msecs\n",
2475 sc, scsi_cmd_to_rq(sc)->tag, CMD_FLAGS(sc), rqi,
2476 jiffies_to_msecs(jiffies - st_time));
2477
2478 /* Update IO stats */
2479 snic_stats_update_io_cmpl(&snic->s_stats);
2480
2481 SNIC_TRC(snic->shost->host_no, tag, (ulong) sc,
2482 jiffies_to_msecs(jiffies - st_time), 0,
2483 SNIC_TRC_CMD(sc),
2484 SNIC_TRC_CMD_STATE_FLAGS(sc));
2485
2486 scsi_done(sc);
2487 }
2488 } /* end of snic_scsi_cleanup */
2489
2490 void
snic_shutdown_scsi_cleanup(struct snic * snic)2491 snic_shutdown_scsi_cleanup(struct snic *snic)
2492 {
2493 SNIC_HOST_INFO(snic->shost, "Shutdown time SCSI Cleanup.\n");
2494
2495 snic_scsi_cleanup(snic, SCSI_NO_TAG);
2496 } /* end of snic_shutdown_scsi_cleanup */
2497
2498 /*
2499 * snic_internal_abort_io
2500 * called by : snic_tgt_scsi_abort_io
2501 */
2502 static int
snic_internal_abort_io(struct snic * snic,struct scsi_cmnd * sc,int tmf)2503 snic_internal_abort_io(struct snic *snic, struct scsi_cmnd *sc, int tmf)
2504 {
2505 struct snic_req_info *rqi = NULL;
2506 spinlock_t *io_lock = NULL;
2507 unsigned long flags;
2508 u32 sv_state = 0;
2509 int ret = 0;
2510
2511 io_lock = snic_io_lock_hash(snic, sc);
2512 spin_lock_irqsave(io_lock, flags);
2513 rqi = (struct snic_req_info *) CMD_SP(sc);
2514 if (!rqi)
2515 goto skip_internal_abts;
2516
2517 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
2518 goto skip_internal_abts;
2519
2520 if ((CMD_FLAGS(sc) & SNIC_DEVICE_RESET) &&
2521 (!(CMD_FLAGS(sc) & SNIC_DEV_RST_ISSUED))) {
2522
2523 SNIC_SCSI_DBG(snic->shost,
2524 "internal_abts: dev rst not pending sc 0x%p\n",
2525 sc);
2526
2527 goto skip_internal_abts;
2528 }
2529
2530
2531 if (!(CMD_FLAGS(sc) & SNIC_IO_ISSUED)) {
2532 SNIC_SCSI_DBG(snic->shost,
2533 "internal_abts: IO not yet issued sc 0x%p tag 0x%x flags 0x%llx state %d\n",
2534 sc, snic_cmd_tag(sc), CMD_FLAGS(sc), CMD_STATE(sc));
2535
2536 goto skip_internal_abts;
2537 }
2538
2539 sv_state = CMD_STATE(sc);
2540 CMD_STATE(sc) = SNIC_IOREQ_ABTS_PENDING;
2541 CMD_ABTS_STATUS(sc) = SNIC_INVALID_CODE;
2542 CMD_FLAGS(sc) |= SNIC_IO_INTERNAL_TERM_PENDING;
2543
2544 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET) {
2545 /* stats */
2546 rqi->tm_tag = SNIC_TAG_DEV_RST;
2547 SNIC_SCSI_DBG(snic->shost, "internal_abts:dev rst sc %p\n", sc);
2548 }
2549
2550 SNIC_SCSI_DBG(snic->shost, "internal_abts: Issuing abts tag %x\n",
2551 snic_cmd_tag(sc));
2552 SNIC_BUG_ON(rqi->abts_done);
2553 spin_unlock_irqrestore(io_lock, flags);
2554
2555 ret = snic_queue_abort_req(snic, rqi, sc, tmf);
2556 if (ret) {
2557 SNIC_HOST_ERR(snic->shost,
2558 "internal_abts: Tag = %x , Failed w/ err = %d\n",
2559 snic_cmd_tag(sc), ret);
2560
2561 spin_lock_irqsave(io_lock, flags);
2562
2563 if (CMD_STATE(sc) == SNIC_IOREQ_ABTS_PENDING)
2564 CMD_STATE(sc) = sv_state;
2565
2566 goto skip_internal_abts;
2567 }
2568
2569 spin_lock_irqsave(io_lock, flags);
2570 if (CMD_FLAGS(sc) & SNIC_DEVICE_RESET)
2571 CMD_FLAGS(sc) |= SNIC_DEV_RST_TERM_ISSUED;
2572 else
2573 CMD_FLAGS(sc) |= SNIC_IO_INTERNAL_TERM_ISSUED;
2574
2575 ret = SUCCESS;
2576
2577 skip_internal_abts:
2578 lockdep_assert_held(io_lock);
2579 spin_unlock_irqrestore(io_lock, flags);
2580
2581 return ret;
2582 } /* end of snic_internal_abort_io */
2583
2584 /*
2585 * snic_tgt_scsi_abort_io : called by snic_tgt_del
2586 */
2587 int
snic_tgt_scsi_abort_io(struct snic_tgt * tgt)2588 snic_tgt_scsi_abort_io(struct snic_tgt *tgt)
2589 {
2590 struct snic *snic = NULL;
2591 struct scsi_cmnd *sc = NULL;
2592 struct snic_tgt *sc_tgt = NULL;
2593 spinlock_t *io_lock = NULL;
2594 unsigned long flags;
2595 int ret = 0, tag, abt_cnt = 0, tmf = 0;
2596
2597 if (!tgt)
2598 return -1;
2599
2600 snic = shost_priv(snic_tgt_to_shost(tgt));
2601 SNIC_SCSI_DBG(snic->shost, "tgt_abt_io: Cleaning Pending IOs.\n");
2602
2603 if (tgt->tdata.typ == SNIC_TGT_DAS)
2604 tmf = SNIC_ITMF_ABTS_TASK;
2605 else
2606 tmf = SNIC_ITMF_ABTS_TASK_TERM;
2607
2608 for (tag = 0; tag < snic->max_tag_id; tag++) {
2609 io_lock = snic_io_lock_tag(snic, tag);
2610
2611 spin_lock_irqsave(io_lock, flags);
2612 sc = scsi_host_find_tag(snic->shost, tag);
2613 if (!sc) {
2614 spin_unlock_irqrestore(io_lock, flags);
2615
2616 continue;
2617 }
2618
2619 sc_tgt = starget_to_tgt(scsi_target(sc->device));
2620 if (sc_tgt != tgt) {
2621 spin_unlock_irqrestore(io_lock, flags);
2622
2623 continue;
2624 }
2625 spin_unlock_irqrestore(io_lock, flags);
2626
2627 ret = snic_internal_abort_io(snic, sc, tmf);
2628 if (ret < 0) {
2629 SNIC_HOST_ERR(snic->shost,
2630 "tgt_abt_io: Tag %x, Failed w err = %d\n",
2631 tag, ret);
2632
2633 continue;
2634 }
2635
2636 if (ret == SUCCESS)
2637 abt_cnt++;
2638 }
2639
2640 SNIC_SCSI_DBG(snic->shost, "tgt_abt_io: abt_cnt = %d\n", abt_cnt);
2641
2642 return 0;
2643 } /* end of snic_tgt_scsi_abort_io */
2644