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