2 * libata-eh.c - libata error handling
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
8 * Copyright 2006 Tejun Heo <htejun@gmail.com>
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; see the file COPYING. If not, write to
23 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
30 * Hardware documentation available from http://www.t13.org/ and
31 * http://www.sata-io.org/
35 #include <linux/config.h>
36 #include <linux/kernel.h>
37 #include <scsi/scsi.h>
38 #include <scsi/scsi_host.h>
39 #include <scsi/scsi_eh.h>
40 #include <scsi/scsi_device.h>
41 #include <scsi/scsi_cmnd.h>
43 #include <linux/libata.h>
47 static void __ata_port_freeze(struct ata_port
*ap
);
49 static void ata_ering_record(struct ata_ering
*ering
, int is_io
,
50 unsigned int err_mask
)
52 struct ata_ering_entry
*ent
;
57 ering
->cursor
%= ATA_ERING_SIZE
;
59 ent
= &ering
->ring
[ering
->cursor
];
61 ent
->err_mask
= err_mask
;
62 ent
->timestamp
= get_jiffies_64();
65 static struct ata_ering_entry
* ata_ering_top(struct ata_ering
*ering
)
67 struct ata_ering_entry
*ent
= &ering
->ring
[ering
->cursor
];
73 static int ata_ering_map(struct ata_ering
*ering
,
74 int (*map_fn
)(struct ata_ering_entry
*, void *),
78 struct ata_ering_entry
*ent
;
82 ent
= &ering
->ring
[idx
];
85 rc
= map_fn(ent
, arg
);
88 idx
= (idx
- 1 + ATA_ERING_SIZE
) % ATA_ERING_SIZE
;
89 } while (idx
!= ering
->cursor
);
95 * ata_scsi_timed_out - SCSI layer time out callback
96 * @cmd: timed out SCSI command
98 * Handles SCSI layer timeout. We race with normal completion of
99 * the qc for @cmd. If the qc is already gone, we lose and let
100 * the scsi command finish (EH_HANDLED). Otherwise, the qc has
101 * timed out and EH should be invoked. Prevent ata_qc_complete()
102 * from finishing it by setting EH_SCHEDULED and return
105 * TODO: kill this function once old EH is gone.
108 * Called from timer context
111 * EH_HANDLED or EH_NOT_HANDLED
113 enum scsi_eh_timer_return
ata_scsi_timed_out(struct scsi_cmnd
*cmd
)
115 struct Scsi_Host
*host
= cmd
->device
->host
;
116 struct ata_port
*ap
= ata_shost_to_port(host
);
118 struct ata_queued_cmd
*qc
;
119 enum scsi_eh_timer_return ret
;
123 if (ap
->ops
->error_handler
) {
124 ret
= EH_NOT_HANDLED
;
129 spin_lock_irqsave(&ap
->host_set
->lock
, flags
);
130 qc
= ata_qc_from_tag(ap
, ap
->active_tag
);
132 WARN_ON(qc
->scsicmd
!= cmd
);
133 qc
->flags
|= ATA_QCFLAG_EH_SCHEDULED
;
134 qc
->err_mask
|= AC_ERR_TIMEOUT
;
135 ret
= EH_NOT_HANDLED
;
137 spin_unlock_irqrestore(&ap
->host_set
->lock
, flags
);
140 DPRINTK("EXIT, ret=%d\n", ret
);
145 * ata_scsi_error - SCSI layer error handler callback
146 * @host: SCSI host on which error occurred
148 * Handles SCSI-layer-thrown error events.
151 * Inherited from SCSI layer (none, can sleep)
156 void ata_scsi_error(struct Scsi_Host
*host
)
158 struct ata_port
*ap
= ata_shost_to_port(host
);
159 spinlock_t
*hs_lock
= &ap
->host_set
->lock
;
160 int i
, repeat_cnt
= ATA_EH_MAX_REPEAT
;
165 /* synchronize with port task */
166 ata_port_flush_task(ap
);
168 /* synchronize with host_set lock and sort out timeouts */
170 /* For new EH, all qcs are finished in one of three ways -
171 * normal completion, error completion, and SCSI timeout.
172 * Both cmpletions can race against SCSI timeout. When normal
173 * completion wins, the qc never reaches EH. When error
174 * completion wins, the qc has ATA_QCFLAG_FAILED set.
176 * When SCSI timeout wins, things are a bit more complex.
177 * Normal or error completion can occur after the timeout but
178 * before this point. In such cases, both types of
179 * completions are honored. A scmd is determined to have
180 * timed out iff its associated qc is active and not failed.
182 if (ap
->ops
->error_handler
) {
183 struct scsi_cmnd
*scmd
, *tmp
;
186 spin_lock_irqsave(hs_lock
, flags
);
188 list_for_each_entry_safe(scmd
, tmp
, &host
->eh_cmd_q
, eh_entry
) {
189 struct ata_queued_cmd
*qc
;
191 for (i
= 0; i
< ATA_MAX_QUEUE
; i
++) {
192 qc
= __ata_qc_from_tag(ap
, i
);
193 if (qc
->flags
& ATA_QCFLAG_ACTIVE
&&
198 if (i
< ATA_MAX_QUEUE
) {
199 /* the scmd has an associated qc */
200 if (!(qc
->flags
& ATA_QCFLAG_FAILED
)) {
201 /* which hasn't failed yet, timeout */
202 qc
->err_mask
|= AC_ERR_TIMEOUT
;
203 qc
->flags
|= ATA_QCFLAG_FAILED
;
207 /* Normal completion occurred after
208 * SCSI timeout but before this point.
209 * Successfully complete it.
211 scmd
->retries
= scmd
->allowed
;
212 scsi_eh_finish_cmd(scmd
, &ap
->eh_done_q
);
216 /* If we have timed out qcs. They belong to EH from
217 * this point but the state of the controller is
218 * unknown. Freeze the port to make sure the IRQ
219 * handler doesn't diddle with those qcs. This must
220 * be done atomically w.r.t. setting QCFLAG_FAILED.
223 __ata_port_freeze(ap
);
225 spin_unlock_irqrestore(hs_lock
, flags
);
227 spin_unlock_wait(hs_lock
);
230 /* invoke error handler */
231 if (ap
->ops
->error_handler
) {
232 /* fetch & clear EH info */
233 spin_lock_irqsave(hs_lock
, flags
);
235 memset(&ap
->eh_context
, 0, sizeof(ap
->eh_context
));
236 ap
->eh_context
.i
= ap
->eh_info
;
237 memset(&ap
->eh_info
, 0, sizeof(ap
->eh_info
));
239 ap
->flags
&= ~ATA_FLAG_EH_PENDING
;
241 spin_unlock_irqrestore(hs_lock
, flags
);
244 ap
->ops
->error_handler(ap
);
246 /* Exception might have happend after ->error_handler
247 * recovered the port but before this point. Repeat
250 spin_lock_irqsave(hs_lock
, flags
);
252 if (ap
->flags
& ATA_FLAG_EH_PENDING
) {
254 ata_port_printk(ap
, KERN_INFO
,
255 "EH pending after completion, "
256 "repeating EH (cnt=%d)\n", repeat_cnt
);
257 spin_unlock_irqrestore(hs_lock
, flags
);
260 ata_port_printk(ap
, KERN_ERR
, "EH pending after %d "
261 "tries, giving up\n", ATA_EH_MAX_REPEAT
);
264 /* this run is complete, make sure EH info is clear */
265 memset(&ap
->eh_info
, 0, sizeof(ap
->eh_info
));
267 /* Clear host_eh_scheduled while holding hs_lock such
268 * that if exception occurs after this point but
269 * before EH completion, SCSI midlayer will
272 host
->host_eh_scheduled
= 0;
274 spin_unlock_irqrestore(hs_lock
, flags
);
276 WARN_ON(ata_qc_from_tag(ap
, ap
->active_tag
) == NULL
);
277 ap
->ops
->eng_timeout(ap
);
280 /* finish or retry handled scmd's and clean up */
281 WARN_ON(host
->host_failed
|| !list_empty(&host
->eh_cmd_q
));
283 scsi_eh_flush_done_q(&ap
->eh_done_q
);
286 spin_lock_irqsave(hs_lock
, flags
);
288 if (ap
->flags
& ATA_FLAG_RECOVERED
)
289 ata_port_printk(ap
, KERN_INFO
, "EH complete\n");
290 ap
->flags
&= ~ATA_FLAG_RECOVERED
;
292 spin_unlock_irqrestore(hs_lock
, flags
);
298 * ata_qc_timeout - Handle timeout of queued command
299 * @qc: Command that timed out
301 * Some part of the kernel (currently, only the SCSI layer)
302 * has noticed that the active command on port @ap has not
303 * completed after a specified length of time. Handle this
304 * condition by disabling DMA (if necessary) and completing
305 * transactions, with error if necessary.
307 * This also handles the case of the "lost interrupt", where
308 * for some reason (possibly hardware bug, possibly driver bug)
309 * an interrupt was not delivered to the driver, even though the
310 * transaction completed successfully.
312 * TODO: kill this function once old EH is gone.
315 * Inherited from SCSI layer (none, can sleep)
317 static void ata_qc_timeout(struct ata_queued_cmd
*qc
)
319 struct ata_port
*ap
= qc
->ap
;
320 struct ata_host_set
*host_set
= ap
->host_set
;
321 u8 host_stat
= 0, drv_stat
;
326 ap
->hsm_task_state
= HSM_ST_IDLE
;
328 spin_lock_irqsave(&host_set
->lock
, flags
);
330 switch (qc
->tf
.protocol
) {
333 case ATA_PROT_ATAPI_DMA
:
334 host_stat
= ap
->ops
->bmdma_status(ap
);
336 /* before we do anything else, clear DMA-Start bit */
337 ap
->ops
->bmdma_stop(qc
);
343 drv_stat
= ata_chk_status(ap
);
345 /* ack bmdma irq events */
346 ap
->ops
->irq_clear(ap
);
348 ata_dev_printk(qc
->dev
, KERN_ERR
, "command 0x%x timeout, "
349 "stat 0x%x host_stat 0x%x\n",
350 qc
->tf
.command
, drv_stat
, host_stat
);
352 /* complete taskfile transaction */
353 qc
->err_mask
|= AC_ERR_TIMEOUT
;
357 spin_unlock_irqrestore(&host_set
->lock
, flags
);
359 ata_eh_qc_complete(qc
);
365 * ata_eng_timeout - Handle timeout of queued command
366 * @ap: Port on which timed-out command is active
368 * Some part of the kernel (currently, only the SCSI layer)
369 * has noticed that the active command on port @ap has not
370 * completed after a specified length of time. Handle this
371 * condition by disabling DMA (if necessary) and completing
372 * transactions, with error if necessary.
374 * This also handles the case of the "lost interrupt", where
375 * for some reason (possibly hardware bug, possibly driver bug)
376 * an interrupt was not delivered to the driver, even though the
377 * transaction completed successfully.
379 * TODO: kill this function once old EH is gone.
382 * Inherited from SCSI layer (none, can sleep)
384 void ata_eng_timeout(struct ata_port
*ap
)
388 ata_qc_timeout(ata_qc_from_tag(ap
, ap
->active_tag
));
394 * ata_qc_schedule_eh - schedule qc for error handling
395 * @qc: command to schedule error handling for
397 * Schedule error handling for @qc. EH will kick in as soon as
398 * other commands are drained.
401 * spin_lock_irqsave(host_set lock)
403 void ata_qc_schedule_eh(struct ata_queued_cmd
*qc
)
405 struct ata_port
*ap
= qc
->ap
;
407 WARN_ON(!ap
->ops
->error_handler
);
409 qc
->flags
|= ATA_QCFLAG_FAILED
;
410 qc
->ap
->flags
|= ATA_FLAG_EH_PENDING
;
412 /* The following will fail if timeout has already expired.
413 * ata_scsi_error() takes care of such scmds on EH entry.
414 * Note that ATA_QCFLAG_FAILED is unconditionally set after
415 * this function completes.
417 scsi_req_abort_cmd(qc
->scsicmd
);
421 * ata_port_schedule_eh - schedule error handling without a qc
422 * @ap: ATA port to schedule EH for
424 * Schedule error handling for @ap. EH will kick in as soon as
425 * all commands are drained.
428 * spin_lock_irqsave(host_set lock)
430 void ata_port_schedule_eh(struct ata_port
*ap
)
432 WARN_ON(!ap
->ops
->error_handler
);
434 ap
->flags
|= ATA_FLAG_EH_PENDING
;
435 ata_schedule_scsi_eh(ap
->host
);
437 DPRINTK("port EH scheduled\n");
441 * ata_port_abort - abort all qc's on the port
442 * @ap: ATA port to abort qc's for
444 * Abort all active qc's of @ap and schedule EH.
447 * spin_lock_irqsave(host_set lock)
450 * Number of aborted qc's.
452 int ata_port_abort(struct ata_port
*ap
)
454 int tag
, nr_aborted
= 0;
456 WARN_ON(!ap
->ops
->error_handler
);
458 for (tag
= 0; tag
< ATA_MAX_QUEUE
; tag
++) {
459 struct ata_queued_cmd
*qc
= ata_qc_from_tag(ap
, tag
);
462 qc
->flags
|= ATA_QCFLAG_FAILED
;
469 ata_port_schedule_eh(ap
);
475 * __ata_port_freeze - freeze port
476 * @ap: ATA port to freeze
478 * This function is called when HSM violation or some other
479 * condition disrupts normal operation of the port. Frozen port
480 * is not allowed to perform any operation until the port is
481 * thawed, which usually follows a successful reset.
483 * ap->ops->freeze() callback can be used for freezing the port
484 * hardware-wise (e.g. mask interrupt and stop DMA engine). If a
485 * port cannot be frozen hardware-wise, the interrupt handler
486 * must ack and clear interrupts unconditionally while the port
490 * spin_lock_irqsave(host_set lock)
492 static void __ata_port_freeze(struct ata_port
*ap
)
494 WARN_ON(!ap
->ops
->error_handler
);
499 ap
->flags
|= ATA_FLAG_FROZEN
;
501 DPRINTK("ata%u port frozen\n", ap
->id
);
505 * ata_port_freeze - abort & freeze port
506 * @ap: ATA port to freeze
508 * Abort and freeze @ap.
511 * spin_lock_irqsave(host_set lock)
514 * Number of aborted commands.
516 int ata_port_freeze(struct ata_port
*ap
)
520 WARN_ON(!ap
->ops
->error_handler
);
522 nr_aborted
= ata_port_abort(ap
);
523 __ata_port_freeze(ap
);
529 * ata_eh_freeze_port - EH helper to freeze port
530 * @ap: ATA port to freeze
537 void ata_eh_freeze_port(struct ata_port
*ap
)
541 if (!ap
->ops
->error_handler
)
544 spin_lock_irqsave(&ap
->host_set
->lock
, flags
);
545 __ata_port_freeze(ap
);
546 spin_unlock_irqrestore(&ap
->host_set
->lock
, flags
);
550 * ata_port_thaw_port - EH helper to thaw port
551 * @ap: ATA port to thaw
553 * Thaw frozen port @ap.
558 void ata_eh_thaw_port(struct ata_port
*ap
)
562 if (!ap
->ops
->error_handler
)
565 spin_lock_irqsave(&ap
->host_set
->lock
, flags
);
567 ap
->flags
&= ~ATA_FLAG_FROZEN
;
572 spin_unlock_irqrestore(&ap
->host_set
->lock
, flags
);
574 DPRINTK("ata%u port thawed\n", ap
->id
);
577 static void ata_eh_scsidone(struct scsi_cmnd
*scmd
)
582 static void __ata_eh_qc_complete(struct ata_queued_cmd
*qc
)
584 struct ata_port
*ap
= qc
->ap
;
585 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
588 spin_lock_irqsave(&ap
->host_set
->lock
, flags
);
589 qc
->scsidone
= ata_eh_scsidone
;
590 __ata_qc_complete(qc
);
591 WARN_ON(ata_tag_valid(qc
->tag
));
592 spin_unlock_irqrestore(&ap
->host_set
->lock
, flags
);
594 scsi_eh_finish_cmd(scmd
, &ap
->eh_done_q
);
598 * ata_eh_qc_complete - Complete an active ATA command from EH
599 * @qc: Command to complete
601 * Indicate to the mid and upper layers that an ATA command has
602 * completed. To be used from EH.
604 void ata_eh_qc_complete(struct ata_queued_cmd
*qc
)
606 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
607 scmd
->retries
= scmd
->allowed
;
608 __ata_eh_qc_complete(qc
);
612 * ata_eh_qc_retry - Tell midlayer to retry an ATA command after EH
613 * @qc: Command to retry
615 * Indicate to the mid and upper layers that an ATA command
616 * should be retried. To be used from EH.
618 * SCSI midlayer limits the number of retries to scmd->allowed.
619 * scmd->retries is decremented for commands which get retried
620 * due to unrelated failures (qc->err_mask is zero).
622 void ata_eh_qc_retry(struct ata_queued_cmd
*qc
)
624 struct scsi_cmnd
*scmd
= qc
->scsicmd
;
625 if (!qc
->err_mask
&& scmd
->retries
)
627 __ata_eh_qc_complete(qc
);
631 * ata_eh_about_to_do - about to perform eh_action
632 * @ap: target ATA port
633 * @action: action about to be performed
635 * Called just before performing EH actions to clear related bits
636 * in @ap->eh_info such that eh actions are not unnecessarily
642 static void ata_eh_about_to_do(struct ata_port
*ap
, unsigned int action
)
646 spin_lock_irqsave(&ap
->host_set
->lock
, flags
);
647 ap
->eh_info
.action
&= ~action
;
648 ap
->flags
|= ATA_FLAG_RECOVERED
;
649 spin_unlock_irqrestore(&ap
->host_set
->lock
, flags
);
653 * ata_err_string - convert err_mask to descriptive string
654 * @err_mask: error mask to convert to string
656 * Convert @err_mask to descriptive string. Errors are
657 * prioritized according to severity and only the most severe
664 * Descriptive string for @err_mask
666 static const char * ata_err_string(unsigned int err_mask
)
668 if (err_mask
& AC_ERR_HOST_BUS
)
669 return "host bus error";
670 if (err_mask
& AC_ERR_ATA_BUS
)
671 return "ATA bus error";
672 if (err_mask
& AC_ERR_TIMEOUT
)
674 if (err_mask
& AC_ERR_HSM
)
675 return "HSM violation";
676 if (err_mask
& AC_ERR_SYSTEM
)
677 return "internal error";
678 if (err_mask
& AC_ERR_MEDIA
)
679 return "media error";
680 if (err_mask
& AC_ERR_INVALID
)
681 return "invalid argument";
682 if (err_mask
& AC_ERR_DEV
)
683 return "device error";
684 return "unknown error";
688 * ata_read_log_page - read a specific log page
689 * @dev: target device
690 * @page: page to read
691 * @buf: buffer to store read page
692 * @sectors: number of sectors to read
694 * Read log page using READ_LOG_EXT command.
697 * Kernel thread context (may sleep).
700 * 0 on success, AC_ERR_* mask otherwise.
702 static unsigned int ata_read_log_page(struct ata_device
*dev
,
703 u8 page
, void *buf
, unsigned int sectors
)
705 struct ata_taskfile tf
;
706 unsigned int err_mask
;
708 DPRINTK("read log page - page %d\n", page
);
710 ata_tf_init(dev
, &tf
);
711 tf
.command
= ATA_CMD_READ_LOG_EXT
;
714 tf
.hob_nsect
= sectors
>> 8;
715 tf
.flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_LBA48
| ATA_TFLAG_DEVICE
;
716 tf
.protocol
= ATA_PROT_PIO
;
718 err_mask
= ata_exec_internal(dev
, &tf
, NULL
, DMA_FROM_DEVICE
,
719 buf
, sectors
* ATA_SECT_SIZE
);
721 DPRINTK("EXIT, err_mask=%x\n", err_mask
);
726 * ata_eh_read_log_10h - Read log page 10h for NCQ error details
727 * @dev: Device to read log page 10h from
728 * @tag: Resulting tag of the failed command
729 * @tf: Resulting taskfile registers of the failed command
731 * Read log page 10h to obtain NCQ error details and clear error
735 * Kernel thread context (may sleep).
738 * 0 on success, -errno otherwise.
740 static int ata_eh_read_log_10h(struct ata_device
*dev
,
741 int *tag
, struct ata_taskfile
*tf
)
743 u8
*buf
= dev
->ap
->sector_buf
;
744 unsigned int err_mask
;
748 err_mask
= ata_read_log_page(dev
, ATA_LOG_SATA_NCQ
, buf
, 1);
753 for (i
= 0; i
< ATA_SECT_SIZE
; i
++)
756 ata_dev_printk(dev
, KERN_WARNING
,
757 "invalid checksum 0x%x on log page 10h\n", csum
);
762 *tag
= buf
[0] & 0x1f;
764 tf
->command
= buf
[2];
765 tf
->feature
= buf
[3];
770 tf
->hob_lbal
= buf
[8];
771 tf
->hob_lbam
= buf
[9];
772 tf
->hob_lbah
= buf
[10];
774 tf
->hob_nsect
= buf
[13];
780 * atapi_eh_request_sense - perform ATAPI REQUEST_SENSE
781 * @dev: device to perform REQUEST_SENSE to
782 * @sense_buf: result sense data buffer (SCSI_SENSE_BUFFERSIZE bytes long)
784 * Perform ATAPI REQUEST_SENSE after the device reported CHECK
785 * SENSE. This function is EH helper.
788 * Kernel thread context (may sleep).
791 * 0 on success, AC_ERR_* mask on failure
793 static unsigned int atapi_eh_request_sense(struct ata_device
*dev
,
794 unsigned char *sense_buf
)
796 struct ata_port
*ap
= dev
->ap
;
797 struct ata_taskfile tf
;
798 u8 cdb
[ATAPI_CDB_LEN
];
800 DPRINTK("ATAPI request sense\n");
802 ata_tf_init(dev
, &tf
);
804 /* FIXME: is this needed? */
805 memset(sense_buf
, 0, SCSI_SENSE_BUFFERSIZE
);
807 /* XXX: why tf_read here? */
808 ap
->ops
->tf_read(ap
, &tf
);
810 /* fill these in, for the case where they are -not- overwritten */
812 sense_buf
[2] = tf
.feature
>> 4;
814 memset(cdb
, 0, ATAPI_CDB_LEN
);
815 cdb
[0] = REQUEST_SENSE
;
816 cdb
[4] = SCSI_SENSE_BUFFERSIZE
;
818 tf
.flags
|= ATA_TFLAG_ISADDR
| ATA_TFLAG_DEVICE
;
819 tf
.command
= ATA_CMD_PACKET
;
821 /* is it pointless to prefer PIO for "safety reasons"? */
822 if (ap
->flags
& ATA_FLAG_PIO_DMA
) {
823 tf
.protocol
= ATA_PROT_ATAPI_DMA
;
824 tf
.feature
|= ATAPI_PKT_DMA
;
826 tf
.protocol
= ATA_PROT_ATAPI
;
827 tf
.lbam
= (8 * 1024) & 0xff;
828 tf
.lbah
= (8 * 1024) >> 8;
831 return ata_exec_internal(dev
, &tf
, cdb
, DMA_FROM_DEVICE
,
832 sense_buf
, SCSI_SENSE_BUFFERSIZE
);
836 * ata_eh_analyze_serror - analyze SError for a failed port
837 * @ap: ATA port to analyze SError for
839 * Analyze SError if available and further determine cause of
845 static void ata_eh_analyze_serror(struct ata_port
*ap
)
847 struct ata_eh_context
*ehc
= &ap
->eh_context
;
848 u32 serror
= ehc
->i
.serror
;
849 unsigned int err_mask
= 0, action
= 0;
851 if (serror
& SERR_PERSISTENT
) {
852 err_mask
|= AC_ERR_ATA_BUS
;
853 action
|= ATA_EH_HARDRESET
;
856 (SERR_DATA_RECOVERED
| SERR_COMM_RECOVERED
| SERR_DATA
)) {
857 err_mask
|= AC_ERR_ATA_BUS
;
858 action
|= ATA_EH_SOFTRESET
;
860 if (serror
& SERR_PROTOCOL
) {
861 err_mask
|= AC_ERR_HSM
;
862 action
|= ATA_EH_SOFTRESET
;
864 if (serror
& SERR_INTERNAL
) {
865 err_mask
|= AC_ERR_SYSTEM
;
866 action
|= ATA_EH_SOFTRESET
;
868 if (serror
& (SERR_PHYRDY_CHG
| SERR_DEV_XCHG
)) {
869 err_mask
|= AC_ERR_ATA_BUS
;
870 action
|= ATA_EH_HARDRESET
;
873 ehc
->i
.err_mask
|= err_mask
;
874 ehc
->i
.action
|= action
;
878 * ata_eh_analyze_ncq_error - analyze NCQ error
879 * @ap: ATA port to analyze NCQ error for
881 * Read log page 10h, determine the offending qc and acquire
882 * error status TF. For NCQ device errors, all LLDDs have to do
883 * is setting AC_ERR_DEV in ehi->err_mask. This function takes
887 * Kernel thread context (may sleep).
889 static void ata_eh_analyze_ncq_error(struct ata_port
*ap
)
891 struct ata_eh_context
*ehc
= &ap
->eh_context
;
892 struct ata_device
*dev
= ap
->device
;
893 struct ata_queued_cmd
*qc
;
894 struct ata_taskfile tf
;
897 /* if frozen, we can't do much */
898 if (ap
->flags
& ATA_FLAG_FROZEN
)
901 /* is it NCQ device error? */
902 if (!ap
->sactive
|| !(ehc
->i
.err_mask
& AC_ERR_DEV
))
905 /* has LLDD analyzed already? */
906 for (tag
= 0; tag
< ATA_MAX_QUEUE
; tag
++) {
907 qc
= __ata_qc_from_tag(ap
, tag
);
909 if (!(qc
->flags
& ATA_QCFLAG_FAILED
))
916 /* okay, this error is ours */
917 rc
= ata_eh_read_log_10h(dev
, &tag
, &tf
);
919 ata_port_printk(ap
, KERN_ERR
, "failed to read log page 10h "
924 if (!(ap
->sactive
& (1 << tag
))) {
925 ata_port_printk(ap
, KERN_ERR
, "log page 10h reported "
926 "inactive tag %d\n", tag
);
930 /* we've got the perpetrator, condemn it */
931 qc
= __ata_qc_from_tag(ap
, tag
);
932 memcpy(&qc
->result_tf
, &tf
, sizeof(tf
));
933 qc
->err_mask
|= AC_ERR_DEV
;
934 ehc
->i
.err_mask
&= ~AC_ERR_DEV
;
938 * ata_eh_analyze_tf - analyze taskfile of a failed qc
940 * @tf: Taskfile registers to analyze
942 * Analyze taskfile of @qc and further determine cause of
943 * failure. This function also requests ATAPI sense data if
947 * Kernel thread context (may sleep).
950 * Determined recovery action
952 static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd
*qc
,
953 const struct ata_taskfile
*tf
)
955 unsigned int tmp
, action
= 0;
956 u8 stat
= tf
->command
, err
= tf
->feature
;
958 if ((stat
& (ATA_BUSY
| ATA_DRQ
| ATA_DRDY
)) != ATA_DRDY
) {
959 qc
->err_mask
|= AC_ERR_HSM
;
960 return ATA_EH_SOFTRESET
;
963 if (!(qc
->err_mask
& AC_ERR_DEV
))
966 switch (qc
->dev
->class) {
969 qc
->err_mask
|= AC_ERR_ATA_BUS
;
971 qc
->err_mask
|= AC_ERR_MEDIA
;
973 qc
->err_mask
|= AC_ERR_INVALID
;
977 tmp
= atapi_eh_request_sense(qc
->dev
,
978 qc
->scsicmd
->sense_buffer
);
980 /* ATA_QCFLAG_SENSE_VALID is used to tell
981 * atapi_qc_complete() that sense data is
984 * TODO: interpret sense data and set
985 * appropriate err_mask.
987 qc
->flags
|= ATA_QCFLAG_SENSE_VALID
;
992 if (qc
->err_mask
& (AC_ERR_HSM
| AC_ERR_TIMEOUT
| AC_ERR_ATA_BUS
))
993 action
|= ATA_EH_SOFTRESET
;
998 static int ata_eh_categorize_ering_entry(struct ata_ering_entry
*ent
)
1000 if (ent
->err_mask
& (AC_ERR_ATA_BUS
| AC_ERR_TIMEOUT
))
1004 if (ent
->err_mask
& AC_ERR_HSM
)
1006 if ((ent
->err_mask
&
1007 (AC_ERR_DEV
|AC_ERR_MEDIA
|AC_ERR_INVALID
)) == AC_ERR_DEV
)
1014 struct speed_down_needed_arg
{
1019 static int speed_down_needed_cb(struct ata_ering_entry
*ent
, void *void_arg
)
1021 struct speed_down_needed_arg
*arg
= void_arg
;
1023 if (ent
->timestamp
< arg
->since
)
1026 arg
->nr_errors
[ata_eh_categorize_ering_entry(ent
)]++;
1031 * ata_eh_speed_down_needed - Determine wheter speed down is necessary
1032 * @dev: Device of interest
1034 * This function examines error ring of @dev and determines
1035 * whether speed down is necessary. Speed down is necessary if
1036 * there have been more than 3 of Cat-1 errors or 10 of Cat-2
1037 * errors during last 15 minutes.
1039 * Cat-1 errors are ATA_BUS, TIMEOUT for any command and HSM
1040 * violation for known supported commands.
1042 * Cat-2 errors are unclassified DEV error for known supported
1046 * Inherited from caller.
1049 * 1 if speed down is necessary, 0 otherwise
1051 static int ata_eh_speed_down_needed(struct ata_device
*dev
)
1053 const u64 interval
= 15LLU * 60 * HZ
;
1054 static const int err_limits
[3] = { -1, 3, 10 };
1055 struct speed_down_needed_arg arg
;
1056 struct ata_ering_entry
*ent
;
1060 ent
= ata_ering_top(&dev
->ering
);
1064 err_cat
= ata_eh_categorize_ering_entry(ent
);
1068 memset(&arg
, 0, sizeof(arg
));
1070 j64
= get_jiffies_64();
1071 if (j64
>= interval
)
1072 arg
.since
= j64
- interval
;
1076 ata_ering_map(&dev
->ering
, speed_down_needed_cb
, &arg
);
1078 return arg
.nr_errors
[err_cat
] > err_limits
[err_cat
];
1082 * ata_eh_speed_down - record error and speed down if necessary
1083 * @dev: Failed device
1084 * @is_io: Did the device fail during normal IO?
1085 * @err_mask: err_mask of the error
1087 * Record error and examine error history to determine whether
1088 * adjusting transmission speed is necessary. It also sets
1089 * transmission limits appropriately if such adjustment is
1093 * Kernel thread context (may sleep).
1096 * 0 on success, -errno otherwise
1098 static int ata_eh_speed_down(struct ata_device
*dev
, int is_io
,
1099 unsigned int err_mask
)
1104 /* record error and determine whether speed down is necessary */
1105 ata_ering_record(&dev
->ering
, is_io
, err_mask
);
1107 if (!ata_eh_speed_down_needed(dev
))
1110 /* speed down SATA link speed if possible */
1111 if (sata_down_spd_limit(dev
->ap
) == 0)
1112 return ATA_EH_HARDRESET
;
1114 /* lower transfer mode */
1115 if (ata_down_xfermask_limit(dev
, 0) == 0)
1116 return ATA_EH_SOFTRESET
;
1118 ata_dev_printk(dev
, KERN_ERR
,
1119 "speed down requested but no transfer mode left\n");
1124 * ata_eh_autopsy - analyze error and determine recovery action
1125 * @ap: ATA port to perform autopsy on
1127 * Analyze why @ap failed and determine which recovery action is
1128 * needed. This function also sets more detailed AC_ERR_* values
1129 * and fills sense data for ATAPI CHECK SENSE.
1132 * Kernel thread context (may sleep).
1134 static void ata_eh_autopsy(struct ata_port
*ap
)
1136 struct ata_eh_context
*ehc
= &ap
->eh_context
;
1137 unsigned int action
= ehc
->i
.action
;
1138 struct ata_device
*failed_dev
= NULL
;
1139 unsigned int all_err_mask
= 0;
1146 /* obtain and analyze SError */
1147 rc
= sata_scr_read(ap
, SCR_ERROR
, &serror
);
1149 ehc
->i
.serror
|= serror
;
1150 ata_eh_analyze_serror(ap
);
1151 } else if (rc
!= -EOPNOTSUPP
)
1152 action
|= ATA_EH_HARDRESET
;
1154 /* analyze NCQ failure */
1155 ata_eh_analyze_ncq_error(ap
);
1157 /* any real error trumps AC_ERR_OTHER */
1158 if (ehc
->i
.err_mask
& ~AC_ERR_OTHER
)
1159 ehc
->i
.err_mask
&= ~AC_ERR_OTHER
;
1161 all_err_mask
|= ehc
->i
.err_mask
;
1163 for (tag
= 0; tag
< ATA_MAX_QUEUE
; tag
++) {
1164 struct ata_queued_cmd
*qc
= __ata_qc_from_tag(ap
, tag
);
1166 if (!(qc
->flags
& ATA_QCFLAG_FAILED
))
1169 /* inherit upper level err_mask */
1170 qc
->err_mask
|= ehc
->i
.err_mask
;
1172 if (qc
->err_mask
& AC_ERR_TIMEOUT
)
1173 action
|= ATA_EH_SOFTRESET
;
1176 action
|= ata_eh_analyze_tf(qc
, &qc
->result_tf
);
1178 /* DEV errors are probably spurious in case of ATA_BUS error */
1179 if (qc
->err_mask
& AC_ERR_ATA_BUS
)
1180 qc
->err_mask
&= ~(AC_ERR_DEV
| AC_ERR_MEDIA
|
1183 /* any real error trumps unknown error */
1184 if (qc
->err_mask
& ~AC_ERR_OTHER
)
1185 qc
->err_mask
&= ~AC_ERR_OTHER
;
1187 /* SENSE_VALID trumps dev/unknown error and revalidation */
1188 if (qc
->flags
& ATA_QCFLAG_SENSE_VALID
) {
1189 qc
->err_mask
&= ~(AC_ERR_DEV
| AC_ERR_OTHER
);
1190 action
&= ~ATA_EH_REVALIDATE
;
1193 /* accumulate error info */
1194 failed_dev
= qc
->dev
;
1195 all_err_mask
|= qc
->err_mask
;
1196 if (qc
->flags
& ATA_QCFLAG_IO
)
1200 /* speed down iff command was in progress */
1202 action
|= ata_eh_speed_down(failed_dev
, is_io
, all_err_mask
);
1205 action
|= ATA_EH_REVALIDATE
;
1207 ehc
->i
.dev
= failed_dev
;
1208 ehc
->i
.action
= action
;
1214 * ata_eh_report - report error handling to user
1215 * @ap: ATA port EH is going on
1217 * Report EH to user.
1222 static void ata_eh_report(struct ata_port
*ap
)
1224 struct ata_eh_context
*ehc
= &ap
->eh_context
;
1225 const char *frozen
, *desc
;
1226 int tag
, nr_failed
= 0;
1229 if (ehc
->i
.desc
[0] != '\0')
1232 for (tag
= 0; tag
< ATA_MAX_QUEUE
; tag
++) {
1233 struct ata_queued_cmd
*qc
= __ata_qc_from_tag(ap
, tag
);
1235 if (!(qc
->flags
& ATA_QCFLAG_FAILED
))
1237 if (qc
->flags
& ATA_QCFLAG_SENSE_VALID
&& !qc
->err_mask
)
1243 if (!nr_failed
&& !ehc
->i
.err_mask
)
1247 if (ap
->flags
& ATA_FLAG_FROZEN
)
1251 ata_dev_printk(ehc
->i
.dev
, KERN_ERR
, "exception Emask 0x%x "
1252 "SAct 0x%x SErr 0x%x action 0x%x%s\n",
1253 ehc
->i
.err_mask
, ap
->sactive
, ehc
->i
.serror
,
1254 ehc
->i
.action
, frozen
);
1256 ata_dev_printk(ehc
->i
.dev
, KERN_ERR
, "(%s)\n", desc
);
1258 ata_port_printk(ap
, KERN_ERR
, "exception Emask 0x%x "
1259 "SAct 0x%x SErr 0x%x action 0x%x%s\n",
1260 ehc
->i
.err_mask
, ap
->sactive
, ehc
->i
.serror
,
1261 ehc
->i
.action
, frozen
);
1263 ata_port_printk(ap
, KERN_ERR
, "(%s)\n", desc
);
1266 for (tag
= 0; tag
< ATA_MAX_QUEUE
; tag
++) {
1267 struct ata_queued_cmd
*qc
= __ata_qc_from_tag(ap
, tag
);
1269 if (!(qc
->flags
& ATA_QCFLAG_FAILED
) || !qc
->err_mask
)
1272 ata_dev_printk(qc
->dev
, KERN_ERR
, "tag %d cmd 0x%x "
1273 "Emask 0x%x stat 0x%x err 0x%x (%s)\n",
1274 qc
->tag
, qc
->tf
.command
, qc
->err_mask
,
1275 qc
->result_tf
.command
, qc
->result_tf
.feature
,
1276 ata_err_string(qc
->err_mask
));
1280 static int ata_eh_reset(struct ata_port
*ap
, ata_reset_fn_t softreset
,
1281 ata_reset_fn_t hardreset
, ata_postreset_fn_t postreset
)
1283 struct ata_eh_context
*ehc
= &ap
->eh_context
;
1284 unsigned int classes
[ATA_MAX_DEVICES
];
1285 int tries
= ATA_EH_RESET_TRIES
;
1286 ata_reset_fn_t reset
;
1289 if (softreset
&& (!hardreset
|| (!sata_set_spd_needed(ap
) &&
1290 !(ehc
->i
.action
& ATA_EH_HARDRESET
))))
1296 ata_port_printk(ap
, KERN_INFO
, "%s resetting port\n",
1297 reset
== softreset
? "soft" : "hard");
1300 ata_eh_about_to_do(ap
, ATA_EH_RESET_MASK
);
1301 ehc
->i
.flags
|= ATA_EHI_DID_RESET
;
1303 rc
= ata_do_reset(ap
, reset
, classes
);
1305 if (rc
&& --tries
) {
1306 ata_port_printk(ap
, KERN_WARNING
,
1307 "%sreset failed, retrying in 5 secs\n",
1308 reset
== softreset
? "soft" : "hard");
1311 if (reset
== hardreset
)
1312 sata_down_spd_limit(ap
);
1320 postreset(ap
, classes
);
1322 /* reset successful, schedule revalidation */
1324 ehc
->i
.action
&= ~ATA_EH_RESET_MASK
;
1325 ehc
->i
.action
|= ATA_EH_REVALIDATE
;
1331 static int ata_eh_revalidate(struct ata_port
*ap
,
1332 struct ata_device
**r_failed_dev
)
1334 struct ata_eh_context
*ehc
= &ap
->eh_context
;
1335 struct ata_device
*dev
;
1340 for (i
= 0; i
< ATA_MAX_DEVICES
; i
++) {
1341 dev
= &ap
->device
[i
];
1343 if (ehc
->i
.action
& ATA_EH_REVALIDATE
&& ata_dev_enabled(dev
) &&
1344 (!ehc
->i
.dev
|| ehc
->i
.dev
== dev
)) {
1345 if (ata_port_offline(ap
)) {
1350 ata_eh_about_to_do(ap
, ATA_EH_REVALIDATE
);
1351 rc
= ata_dev_revalidate(dev
,
1352 ehc
->i
.flags
& ATA_EHI_DID_RESET
);
1356 ehc
->i
.action
&= ~ATA_EH_REVALIDATE
;
1361 *r_failed_dev
= dev
;
1367 static int ata_port_nr_enabled(struct ata_port
*ap
)
1371 for (i
= 0; i
< ATA_MAX_DEVICES
; i
++)
1372 if (ata_dev_enabled(&ap
->device
[i
]))
1378 * ata_eh_recover - recover host port after error
1379 * @ap: host port to recover
1380 * @softreset: softreset method (can be NULL)
1381 * @hardreset: hardreset method (can be NULL)
1382 * @postreset: postreset method (can be NULL)
1384 * This is the alpha and omega, eum and yang, heart and soul of
1385 * libata exception handling. On entry, actions required to
1386 * recover each devices are recorded in eh_context. This
1387 * function executes all the operations with appropriate retrials
1388 * and fallbacks to resurrect failed devices.
1391 * Kernel thread context (may sleep).
1394 * 0 on success, -errno on failure.
1396 static int ata_eh_recover(struct ata_port
*ap
, ata_reset_fn_t softreset
,
1397 ata_reset_fn_t hardreset
,
1398 ata_postreset_fn_t postreset
)
1400 struct ata_eh_context
*ehc
= &ap
->eh_context
;
1401 struct ata_device
*dev
;
1402 int down_xfermask
, i
, rc
;
1406 /* prep for recovery */
1407 for (i
= 0; i
< ATA_MAX_DEVICES
; i
++) {
1408 dev
= &ap
->device
[i
];
1410 ehc
->tries
[dev
->devno
] = ATA_EH_DEV_TRIES
;
1417 /* skip EH if possible. */
1418 if (!ata_port_nr_enabled(ap
) && !(ap
->flags
& ATA_FLAG_FROZEN
))
1422 if (ehc
->i
.action
& ATA_EH_RESET_MASK
) {
1423 ata_eh_freeze_port(ap
);
1425 rc
= ata_eh_reset(ap
, softreset
, hardreset
, postreset
);
1427 ata_port_printk(ap
, KERN_ERR
,
1428 "reset failed, giving up\n");
1432 ata_eh_thaw_port(ap
);
1435 /* revalidate existing devices */
1436 rc
= ata_eh_revalidate(ap
, &dev
);
1440 /* configure transfer mode if the port has been reset */
1441 if (ehc
->i
.flags
& ATA_EHI_DID_RESET
) {
1442 rc
= ata_set_mode(ap
, &dev
);
1455 ehc
->tries
[dev
->devno
] = 0;
1458 sata_down_spd_limit(ap
);
1460 ehc
->tries
[dev
->devno
]--;
1461 if (down_xfermask
&&
1462 ata_down_xfermask_limit(dev
, ehc
->tries
[dev
->devno
] == 1))
1463 ehc
->tries
[dev
->devno
] = 0;
1466 /* disable device if it has used up all its chances */
1467 if (ata_dev_enabled(dev
) && !ehc
->tries
[dev
->devno
])
1468 ata_dev_disable(dev
);
1470 /* soft didn't work? be haaaaard */
1471 if (ehc
->i
.flags
& ATA_EHI_DID_RESET
)
1472 ehc
->i
.action
|= ATA_EH_HARDRESET
;
1474 ehc
->i
.action
|= ATA_EH_SOFTRESET
;
1476 if (ata_port_nr_enabled(ap
)) {
1477 ata_port_printk(ap
, KERN_WARNING
, "failed to recover some "
1478 "devices, retrying in 5 secs\n");
1481 /* no device left, repeat fast */
1489 for (i
= 0; i
< ATA_MAX_DEVICES
; i
++)
1490 ata_dev_disable(&ap
->device
[i
]);
1493 DPRINTK("EXIT, rc=%d\n", rc
);
1498 * ata_eh_finish - finish up EH
1499 * @ap: host port to finish EH for
1501 * Recovery is complete. Clean up EH states and retry or finish
1507 static void ata_eh_finish(struct ata_port
*ap
)
1511 /* retry or finish qcs */
1512 for (tag
= 0; tag
< ATA_MAX_QUEUE
; tag
++) {
1513 struct ata_queued_cmd
*qc
= __ata_qc_from_tag(ap
, tag
);
1515 if (!(qc
->flags
& ATA_QCFLAG_FAILED
))
1519 /* FIXME: Once EH migration is complete,
1520 * generate sense data in this function,
1521 * considering both err_mask and tf.
1523 if (qc
->err_mask
& AC_ERR_INVALID
)
1524 ata_eh_qc_complete(qc
);
1526 ata_eh_qc_retry(qc
);
1528 if (qc
->flags
& ATA_QCFLAG_SENSE_VALID
) {
1529 ata_eh_qc_complete(qc
);
1531 /* feed zero TF to sense generation */
1532 memset(&qc
->result_tf
, 0, sizeof(qc
->result_tf
));
1533 ata_eh_qc_retry(qc
);
1540 * ata_do_eh - do standard error handling
1541 * @ap: host port to handle error for
1542 * @softreset: softreset method (can be NULL)
1543 * @hardreset: hardreset method (can be NULL)
1544 * @postreset: postreset method (can be NULL)
1546 * Perform standard error handling sequence.
1549 * Kernel thread context (may sleep).
1551 void ata_do_eh(struct ata_port
*ap
, ata_reset_fn_t softreset
,
1552 ata_reset_fn_t hardreset
, ata_postreset_fn_t postreset
)
1556 ata_eh_recover(ap
, softreset
, hardreset
, postreset
);