4 * Home page of code is: http://smartmontools.sourceforge.net
6 * Copyright (C) 2002-11 Bruce Allen <smartmontools-support@lists.sourceforge.net>
7 * Copyright (C) 2008-11 Christian Franke <smartmontools-support@lists.sourceforge.net>
8 * Copyright (C) 1999-2000 Michael Cornwell <cornwell@acm.org>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
15 * You should have received a copy of the GNU General Public License
16 * (for example COPYING); if not, write to the Free
17 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 * This code was originally developed as a Senior Thesis by Michael Cornwell
20 * at the Concurrent Systems Laboratory (now part of the Storage Systems
21 * Research Center), Jack Baskin School of Engineering, University of
22 * California, Santa Cruz. http://ssrc.soe.ucsc.edu/
35 #include "atacmdnames.h"
37 #include "dev_interface.h"
41 #include "knowndrives.h"
43 const char * ataprint_cpp_cvsid
= "$Id: ataprint.cpp 3357 2011-06-06 18:56:55Z chrfranke $"
47 static const char * infofound(const char *output
) {
48 return (*output
? output
: "[No Information Found]");
51 // Return true if '-T permissive' is specified,
52 // used to ignore missing capabilities
53 static bool is_permissive()
55 if (!failuretest_permissive
)
57 failuretest_permissive
--;
61 /* For the given Command Register (CR) and Features Register (FR), attempts
62 * to construct a string that describes the contents of the Status
63 * Register (ST) and Error Register (ER). The caller passes the string
64 * buffer and the return value is a pointer to this string. If the
65 * meanings of the flags of the error register are not known for the given
66 * command then it returns NULL.
68 * The meanings of the flags of the error register for all commands are
69 * described in the ATA spec and could all be supported here in theory.
70 * Currently, only a few commands are supported (those that have been seen
71 * to produce errors). If many more are to be added then this function
72 * should probably be redesigned.
75 static const char * construct_st_er_desc(
77 unsigned char CR
, unsigned char FR
,
78 unsigned char ST
, unsigned char ER
,
80 const ata_smart_errorlog_error_struct
* lba28_regs
,
81 const ata_smart_exterrlog_error
* lba48_regs
84 const char *error_flag
[8];
85 int i
, print_lba
=0, print_sector
=0;
87 // Set of character strings corresponding to different error codes.
88 // Please keep in alphabetic order if you add more.
89 const char *abrt
= "ABRT"; // ABORTED
90 const char *amnf
= "AMNF"; // ADDRESS MARK NOT FOUND
91 const char *ccto
= "CCTO"; // COMMAND COMPLETION TIMED OUT
92 const char *eom
= "EOM"; // END OF MEDIA
93 const char *icrc
= "ICRC"; // INTERFACE CRC ERROR
94 const char *idnf
= "IDNF"; // ID NOT FOUND
95 const char *ili
= "ILI"; // MEANING OF THIS BIT IS COMMAND-SET SPECIFIC
96 const char *mc
= "MC"; // MEDIA CHANGED
97 const char *mcr
= "MCR"; // MEDIA CHANGE REQUEST
98 const char *nm
= "NM"; // NO MEDIA
99 const char *obs
= "obs"; // OBSOLETE
100 const char *tk0nf
= "TK0NF"; // TRACK 0 NOT FOUND
101 const char *unc
= "UNC"; // UNCORRECTABLE
102 const char *wp
= "WP"; // WRITE PROTECTED
104 /* If for any command the Device Fault flag of the status register is
105 * not used then used_device_fault should be set to 0 (in the CR switch
108 int uses_device_fault
= 1;
110 /* A value of NULL means that the error flag isn't used */
111 for (i
= 0; i
< 8; i
++)
112 error_flag
[i
] = NULL
;
115 case 0x10: // RECALIBRATE
116 error_flag
[2] = abrt
;
117 error_flag
[1] = tk0nf
;
119 case 0x20: /* READ SECTOR(S) */
120 case 0x21: // READ SECTOR(S)
121 case 0x24: // READ SECTOR(S) EXT
122 case 0xC4: /* READ MULTIPLE */
123 case 0x29: // READ MULTIPLE EXT
126 error_flag
[4] = idnf
;
128 error_flag
[2] = abrt
;
130 error_flag
[0] = amnf
;
133 case 0x22: // READ LONG (with retries)
134 case 0x23: // READ LONG (without retries)
135 error_flag
[4] = idnf
;
136 error_flag
[2] = abrt
;
137 error_flag
[0] = amnf
;
140 case 0x2a: // READ STREAM DMA
141 case 0x2b: // READ STREAM PIO
143 error_flag
[7] = icrc
;
146 error_flag
[4] = idnf
;
148 error_flag
[2] = abrt
;
150 error_flag
[0] = ccto
;
154 case 0x3A: // WRITE STREAM DMA
155 case 0x3B: // WRITE STREAM PIO
157 error_flag
[7] = icrc
;
160 error_flag
[4] = idnf
;
162 error_flag
[2] = abrt
;
164 error_flag
[0] = ccto
;
168 case 0x25: // READ DMA EXT
169 case 0x26: // READ DMA QUEUED EXT
170 case 0xC7: // READ DMA QUEUED
171 case 0xC8: // READ DMA (with retries)
172 case 0xC9: // READ DMA (without retries, obsolete since ATA-5)
173 case 0x60: // READ FPDMA QUEUED (NCQ)
174 error_flag
[7] = icrc
;
177 error_flag
[4] = idnf
;
179 error_flag
[2] = abrt
;
181 error_flag
[0] = amnf
;
183 if (CR
==0x25 || CR
==0xC8)
186 case 0x30: /* WRITE SECTOR(S) */
187 case 0x31: // WRITE SECTOR(S)
188 case 0x34: // WRITE SECTOR(S) EXT
189 case 0xC5: /* WRITE MULTIPLE */
190 case 0x39: // WRITE MULTIPLE EXT
191 case 0xCE: // WRITE MULTIPLE FUA EXT
194 error_flag
[4] = idnf
;
196 error_flag
[2] = abrt
;
200 case 0x32: // WRITE LONG (with retries)
201 case 0x33: // WRITE LONG (without retries)
202 error_flag
[4] = idnf
;
203 error_flag
[2] = abrt
;
206 case 0x3C: // WRITE VERIFY
208 error_flag
[4] = idnf
;
209 error_flag
[2] = abrt
;
210 error_flag
[0] = amnf
;
213 case 0x40: // READ VERIFY SECTOR(S) with retries
214 case 0x41: // READ VERIFY SECTOR(S) without retries
215 case 0x42: // READ VERIFY SECTOR(S) EXT
218 error_flag
[4] = idnf
;
220 error_flag
[2] = abrt
;
222 error_flag
[0] = amnf
;
225 case 0xA0: /* PACKET */
226 /* Bits 4-7 are all used for sense key (a 'command packet set specific error
227 * indication' according to the ATA/ATAPI-7 standard), so "Sense key" will
228 * be repeated in the error description string if more than one of those
231 error_flag
[7] = "Sense key (bit 3)",
232 error_flag
[6] = "Sense key (bit 2)",
233 error_flag
[5] = "Sense key (bit 1)",
234 error_flag
[4] = "Sense key (bit 0)",
235 error_flag
[2] = abrt
;
239 case 0xA1: /* IDENTIFY PACKET DEVICE */
240 case 0xEF: /* SET FEATURES */
242 case 0xC6: /* SET MULTIPLE MODE */
243 error_flag
[2] = abrt
;
245 case 0x2F: // READ LOG EXT
247 error_flag
[4] = idnf
;
248 error_flag
[2] = abrt
;
251 case 0x3F: // WRITE LOG EXT
252 error_flag
[4] = idnf
;
253 error_flag
[2] = abrt
;
256 case 0xB0: /* SMART */
258 case 0xD0: // SMART READ DATA
259 case 0xD1: // SMART READ ATTRIBUTE THRESHOLDS
260 case 0xD5: /* SMART READ LOG */
262 error_flag
[4] = idnf
;
263 error_flag
[2] = abrt
;
266 case 0xD6: /* SMART WRITE LOG */
267 error_flag
[4] = idnf
;
268 error_flag
[2] = abrt
;
271 case 0xD2: // Enable/Disable Attribute Autosave
272 case 0xD3: // SMART SAVE ATTRIBUTE VALUES (ATA-3)
273 case 0xD8: // SMART ENABLE OPERATIONS
274 case 0xD9: /* SMART DISABLE OPERATIONS */
275 case 0xDA: /* SMART RETURN STATUS */
276 case 0xDB: // Enable/Disable Auto Offline (SFF)
277 error_flag
[2] = abrt
;
279 case 0xD4: // SMART EXECUTE IMMEDIATE OFFLINE
280 error_flag
[4] = idnf
;
281 error_flag
[2] = abrt
;
288 case 0xB1: /* DEVICE CONFIGURATION */
290 case 0xC0: /* DEVICE CONFIGURATION RESTORE */
291 error_flag
[2] = abrt
;
298 case 0xCA: // WRITE DMA (with retries)
299 case 0xCB: // WRITE DMA (without retries, obsolete since ATA-5)
300 case 0x35: // WRITE DMA EXT
301 case 0x3D: // WRITE DMA FUA EXT
302 case 0xCC: // WRITE DMA QUEUED
303 case 0x36: // WRITE DMA QUEUED EXT
304 case 0x3E: // WRITE DMA QUEUED FUA EXT
305 case 0x61: // WRITE FPDMA QUEUED (NCQ)
306 error_flag
[7] = icrc
;
309 error_flag
[4] = idnf
;
311 error_flag
[2] = abrt
;
313 error_flag
[0] = amnf
;
318 case 0xE4: // READ BUFFER
319 case 0xE8: // WRITE BUFFER
320 error_flag
[2] = abrt
;
328 /* We ignore any status flags other than Device Fault and Error */
330 if (uses_device_fault
&& (ST
& (1 << 5))) {
331 strcat(s
, "Device Fault");
332 if (ST
& 1) // Error flag
335 if (ST
& 1) { // Error flag
338 strcat(s
, "Error: ");
339 for (i
= 7; i
>= 0; i
--)
340 if ((ER
& (1 << i
)) && (error_flag
[i
])) {
343 strcat(s
, error_flag
[i
]);
347 // If the error was a READ or WRITE error, print the Logical Block
348 // Address (LBA) at which the read or write failed.
351 // print number of sectors, if known, and append to print string
353 snprintf(tmp
, 128, " %d sectors", print_sector
);
359 // bits 24-27: bits 0-3 of DH
360 lba
= 0xf & lba28_regs
->drive_head
;
363 lba
|= lba28_regs
->cylinder_high
;
366 lba
|= lba28_regs
->cylinder_low
;
369 lba
|= lba28_regs
->sector_number
;
370 snprintf(tmp
, 128, " at LBA = 0x%08x = %u", lba
, lba
);
373 else if (lba48_regs
) {
374 // This assumes that upper LBA registers are 0 for 28-bit commands
375 // (TODO: detect 48-bit commands above)
377 lba48
= lba48_regs
->lba_high_register_hi
;
379 lba48
|= lba48_regs
->lba_mid_register_hi
;
381 lba48
|= lba48_regs
->lba_low_register_hi
;
382 lba48
|= lba48_regs
->device_register
& 0xf;
384 lba48
|= lba48_regs
->lba_high_register
;
386 lba48
|= lba48_regs
->lba_mid_register
;
388 lba48
|= lba48_regs
->lba_low_register
;
389 snprintf(tmp
, 128, " at LBA = 0x%08"PRIx64
" = %"PRIu64
, lba48
, lba48
);
397 static inline const char * construct_st_er_desc(char * s
,
398 const ata_smart_errorlog_struct
* data
)
400 return construct_st_er_desc(s
,
401 data
->commands
[4].commandreg
,
402 data
->commands
[4].featuresreg
,
403 data
->error_struct
.status
,
404 data
->error_struct
.error_register
,
405 data
->error_struct
.sector_count
,
406 &data
->error_struct
, (const ata_smart_exterrlog_error
*)0);
409 static inline const char * construct_st_er_desc(char * s
,
410 const ata_smart_exterrlog_error_log
* data
)
412 return construct_st_er_desc(s
,
413 data
->commands
[4].command_register
,
414 data
->commands
[4].features_register
,
415 data
->error
.status_register
,
416 data
->error
.error_register
,
417 data
->error
.count_register_hi
<< 8 | data
->error
.count_register
,
418 (const ata_smart_errorlog_error_struct
*)0, &data
->error
);
421 static void print_drive_info(const ata_identify_device
* drive
,
422 const ata_size_info
& sizes
,
423 const drive_settings
* dbentry
)
425 // format drive information (with byte swapping as needed)
426 char model
[40+1], serial
[20+1], firmware
[8+1];
427 ata_format_id_string(model
, drive
->model
, sizeof(model
)-1);
428 ata_format_id_string(serial
, drive
->serial_no
, sizeof(serial
)-1);
429 ata_format_id_string(firmware
, drive
->fw_rev
, sizeof(firmware
)-1);
431 // Print model family if known
432 if (dbentry
&& *dbentry
->modelfamily
)
433 pout("Model Family: %s\n", dbentry
->modelfamily
);
435 pout("Device Model: %s\n", infofound(model
));
436 if (!dont_print_serial_number
) {
437 pout("Serial Number: %s\n", infofound(serial
));
439 unsigned oui
= 0; uint64_t unique_id
= 0;
440 int naa
= ata_get_wwn(drive
, oui
, unique_id
);
442 pout("LU WWN Device Id: %x %06x %09"PRIx64
"\n", naa
, oui
, unique_id
);
444 pout("Firmware Version: %s\n", infofound(firmware
));
446 if (sizes
.capacity
) {
448 char num
[64], cap
[32];
449 pout("User Capacity: %s bytes [%s]\n",
450 format_with_thousands_sep(num
, sizeof(num
), sizes
.capacity
),
451 format_capacity(cap
, sizeof(cap
), sizes
.capacity
));
453 // Print sector sizes.
454 if (sizes
.phy_sector_size
== sizes
.log_sector_size
)
455 pout("Sector Size: %u bytes logical/physical\n", sizes
.log_sector_size
);
457 pout("Sector Sizes: %u bytes logical, %u bytes physical",
458 sizes
.log_sector_size
, sizes
.phy_sector_size
);
459 if (sizes
.log_sector_offset
)
460 pout(" (offset %u bytes)", sizes
.log_sector_offset
);
465 // See if drive is recognized
466 pout("Device is: %s\n", !dbentry
?
467 "Not in smartctl database [for details use: -P showall]":
468 "In smartctl database [for details use: -P show]");
470 // now get ATA version info
471 const char *description
; unsigned short minorrev
;
472 int version
= ataVersionInfo(&description
, drive
, &minorrev
);
474 // SMART Support was first added into the ATA/ATAPI-3 Standard with
475 // Revision 3 of the document, July 25, 1995. Look at the "Document
476 // Status" revision commands at the beginning of
477 // http://www.t13.org/Documents/UploadedDocuments/project/d2008r7b-ATA-3.pdf
478 // to see this. So it's not enough to check if we are ATA-3.
479 // Version=-3 indicates ATA-3 BEFORE Revision 3.
480 // Version=0 indicates that no info is found. This may happen if
481 // the OS provides only part of the IDENTIFY data.
483 std::string majorstr
, minorstr
;
485 majorstr
= strprintf("%d", abs(version
));
487 minorstr
= description
;
489 minorstr
= "Exact ATA specification draft version not indicated";
491 minorstr
= strprintf("Not recognized. Minor revision code: 0x%04x", minorrev
);
494 pout("ATA Version is: %s\n", infofound(majorstr
.c_str()));
495 pout("ATA Standard is: %s\n", infofound(minorstr
.c_str()));
497 // print current time and date and timezone
498 char timedatetz
[DATEANDEPOCHLEN
]; dateandtimezone(timedatetz
);
499 pout("Local Time is: %s\n", timedatetz
);
501 // Print warning message, if there is one
502 if (dbentry
&& *dbentry
->warningmsg
)
503 pout("\n==> WARNING: %s\n\n", dbentry
->warningmsg
);
505 if (!version
|| version
>= 3)
508 pout("SMART is only available in ATA Version 3 Revision 3 or greater.\n");
509 pout("We will try to proceed in spite of this.\n");
512 static const char *OfflineDataCollectionStatus(unsigned char status_byte
)
514 unsigned char stat
=status_byte
& 0x7f;
518 return "was never started";
520 return "was completed without error";
522 if (status_byte
== 0x03)
523 return "is in progress";
525 return "is in a Reserved state";
527 return "was suspended by an interrupting command from host";
529 return "was aborted by an interrupting command from host";
531 return "was aborted by the device with a fatal error";
534 return "is in a Vendor Specific state";
536 return "is in a Reserved state";
541 // prints verbose value Off-line data collection status byte
542 static void PrintSmartOfflineStatus(const ata_smart_values
* data
)
544 pout("Offline data collection status: (0x%02x)\t",
545 (int)data
->offline_data_collection_status
);
547 // Off-line data collection status byte is not a reserved
548 // or vendor specific value
549 pout("Offline data collection activity\n"
550 "\t\t\t\t\t%s.\n", OfflineDataCollectionStatus(data
->offline_data_collection_status
));
552 // Report on Automatic Data Collection Status. Only IBM documents
553 // this bit. See SFF 8035i Revision 2 for details.
554 if (data
->offline_data_collection_status
& 0x80)
555 pout("\t\t\t\t\tAuto Offline Data Collection: Enabled.\n");
557 pout("\t\t\t\t\tAuto Offline Data Collection: Disabled.\n");
562 static void PrintSmartSelfExecStatus(const ata_smart_values
* data
,
563 unsigned char fix_firmwarebug
)
565 pout("Self-test execution status: ");
567 switch (data
->self_test_exec_status
>> 4)
570 pout("(%4d)\tThe previous self-test routine completed\n\t\t\t\t\t",
571 (int)data
->self_test_exec_status
);
572 pout("without error or no self-test has ever \n\t\t\t\t\tbeen run.\n");
575 pout("(%4d)\tThe self-test routine was aborted by\n\t\t\t\t\t",
576 (int)data
->self_test_exec_status
);
580 pout("(%4d)\tThe self-test routine was interrupted\n\t\t\t\t\t",
581 (int)data
->self_test_exec_status
);
582 pout("by the host with a hard or soft reset.\n");
585 pout("(%4d)\tA fatal error or unknown test error\n\t\t\t\t\t",
586 (int)data
->self_test_exec_status
);
587 pout("occurred while the device was executing\n\t\t\t\t\t");
588 pout("its self-test routine and the device \n\t\t\t\t\t");
589 pout("was unable to complete the self-test \n\t\t\t\t\t");
593 pout("(%4d)\tThe previous self-test completed having\n\t\t\t\t\t",
594 (int)data
->self_test_exec_status
);
595 pout("a test element that failed and the test\n\t\t\t\t\t");
596 pout("element that failed is not known.\n");
599 pout("(%4d)\tThe previous self-test completed having\n\t\t\t\t\t",
600 (int)data
->self_test_exec_status
);
601 pout("the electrical element of the test\n\t\t\t\t\t");
605 pout("(%4d)\tThe previous self-test completed having\n\t\t\t\t\t",
606 (int)data
->self_test_exec_status
);
607 pout("the servo (and/or seek) element of the \n\t\t\t\t\t");
608 pout("test failed.\n");
611 pout("(%4d)\tThe previous self-test completed having\n\t\t\t\t\t",
612 (int)data
->self_test_exec_status
);
613 pout("the read element of the test failed.\n");
616 pout("(%4d)\tThe previous self-test completed having\n\t\t\t\t\t",
617 (int)data
->self_test_exec_status
);
618 pout("a test element that failed and the\n\t\t\t\t\t");
619 pout("device is suspected of having handling\n\t\t\t\t\t");
623 if (fix_firmwarebug
== FIX_SAMSUNG3
&& data
->self_test_exec_status
== 0xf0) {
624 pout("(%4d)\tThe previous self-test routine completed\n\t\t\t\t\t",
625 (int)data
->self_test_exec_status
);
626 pout("with unknown result or self-test in\n\t\t\t\t\t");
627 pout("progress with less than 10%% remaining.\n");
630 pout("(%4d)\tSelf-test routine in progress...\n\t\t\t\t\t",
631 (int)data
->self_test_exec_status
);
632 pout("%1d0%% of test remaining.\n",
633 (int)(data
->self_test_exec_status
& 0x0f));
637 pout("(%4d)\tReserved.\n",
638 (int)data
->self_test_exec_status
);
644 static void PrintSmartTotalTimeCompleteOffline (const ata_smart_values
* data
)
646 pout("Total time to complete Offline \n");
647 pout("data collection: \t\t(%5d) seconds.\n",
648 (int)data
->total_time_to_complete_off_line
);
651 static void PrintSmartOfflineCollectCap(const ata_smart_values
*data
)
653 pout("Offline data collection\n");
654 pout("capabilities: \t\t\t (0x%02x) ",
655 (int)data
->offline_data_collection_capability
);
657 if (data
->offline_data_collection_capability
== 0x00){
658 pout("\tOffline data collection not supported.\n");
661 pout( "%s\n", isSupportExecuteOfflineImmediate(data
)?
662 "SMART execute Offline immediate." :
663 "No SMART execute Offline immediate.");
665 pout( "\t\t\t\t\t%s\n", isSupportAutomaticTimer(data
)?
666 "Auto Offline data collection on/off support.":
667 "No Auto Offline data collection support.");
669 pout( "\t\t\t\t\t%s\n", isSupportOfflineAbort(data
)?
670 "Abort Offline collection upon new\n\t\t\t\t\tcommand.":
671 "Suspend Offline collection upon new\n\t\t\t\t\tcommand.");
673 pout( "\t\t\t\t\t%s\n", isSupportOfflineSurfaceScan(data
)?
674 "Offline surface scan supported.":
675 "No Offline surface scan supported.");
677 pout( "\t\t\t\t\t%s\n", isSupportSelfTest(data
)?
678 "Self-test supported.":
679 "No Self-test supported.");
681 pout( "\t\t\t\t\t%s\n", isSupportConveyanceSelfTest(data
)?
682 "Conveyance Self-test supported.":
683 "No Conveyance Self-test supported.");
685 pout( "\t\t\t\t\t%s\n", isSupportSelectiveSelfTest(data
)?
686 "Selective Self-test supported.":
687 "No Selective Self-test supported.");
691 static void PrintSmartCapability(const ata_smart_values
*data
)
693 pout("SMART capabilities: ");
694 pout("(0x%04x)\t", (int)data
->smart_capability
);
696 if (data
->smart_capability
== 0x00)
698 pout("Automatic saving of SMART data\t\t\t\t\tis not implemented.\n");
703 pout( "%s\n", (data
->smart_capability
& 0x01)?
704 "Saves SMART data before entering\n\t\t\t\t\tpower-saving mode.":
705 "Does not save SMART data before\n\t\t\t\t\tentering power-saving mode.");
707 if ( data
->smart_capability
& 0x02 )
709 pout("\t\t\t\t\tSupports SMART auto save timer.\n");
714 static void PrintSmartErrorLogCapability(const ata_smart_values
* data
, const ata_identify_device
* identity
)
716 pout("Error logging capability: ");
718 if ( isSmartErrorLogCapable(data
, identity
) )
720 pout(" (0x%02x)\tError logging supported.\n",
721 (int)data
->errorlog_capability
);
724 pout(" (0x%02x)\tError logging NOT supported.\n",
725 (int)data
->errorlog_capability
);
729 static void PrintSmartShortSelfTestPollingTime(const ata_smart_values
* data
)
731 pout("Short self-test routine \n");
732 if (isSupportSelfTest(data
))
733 pout("recommended polling time: \t (%4d) minutes.\n",
734 (int)data
->short_test_completion_time
);
736 pout("recommended polling time: \t Not Supported.\n");
739 static void PrintSmartExtendedSelfTestPollingTime(const ata_smart_values
* data
)
741 pout("Extended self-test routine\n");
742 if (isSupportSelfTest(data
))
743 pout("recommended polling time: \t (%4d) minutes.\n",
744 (int)data
->extend_test_completion_time
);
746 pout("recommended polling time: \t Not Supported.\n");
749 static void PrintSmartConveyanceSelfTestPollingTime(const ata_smart_values
* data
)
751 pout("Conveyance self-test routine\n");
752 if (isSupportConveyanceSelfTest(data
))
753 pout("recommended polling time: \t (%4d) minutes.\n",
754 (int)data
->conveyance_test_completion_time
);
756 pout("recommended polling time: \t Not Supported.\n");
759 // Check SMART attribute table for Threshold failure
760 // onlyfailed=0: are or were any age or prefailure attributes <= threshold
761 // onlyfailed=1: are any prefailure attributes <= threshold now
762 static int find_failed_attr(const ata_smart_values
* data
,
763 const ata_smart_thresholds_pvt
* thresholds
,
764 const ata_vendor_attr_defs
& defs
, int onlyfailed
)
766 for (int i
= 0; i
< NUMBER_ATA_SMART_ATTRIBUTES
; i
++) {
767 const ata_smart_attribute
& attr
= data
->vendor_attributes
[i
];
769 ata_attr_state state
= ata_get_attr_state(attr
, i
, thresholds
->thres_entries
, defs
);
772 if (state
>= ATTRSTATE_FAILED_PAST
)
776 if (state
== ATTRSTATE_FAILED_NOW
&& ATTRIBUTE_FLAGS_PREFAILURE(attr
.flags
))
783 // onlyfailed=0 : print all attribute values
784 // onlyfailed=1: just ones that are currently failed and have prefailure bit set
785 // onlyfailed=2: ones that are failed, or have failed with or without prefailure bit set
786 static void PrintSmartAttribWithThres(const ata_smart_values
* data
,
787 const ata_smart_thresholds_pvt
* thresholds
,
788 const ata_vendor_attr_defs
& defs
,
789 int onlyfailed
, unsigned char format
)
791 bool needheader
= true;
793 // step through all vendor attributes
794 for (int i
= 0; i
< NUMBER_ATA_SMART_ATTRIBUTES
; i
++) {
795 const ata_smart_attribute
& attr
= data
->vendor_attributes
[i
];
797 // Check attribute and threshold
798 unsigned char threshold
= 0;
799 ata_attr_state state
= ata_get_attr_state(attr
, i
, thresholds
->thres_entries
, defs
, &threshold
);
800 if (state
== ATTRSTATE_NON_EXISTING
)
803 // These break out of the loop if we are only printing certain entries...
804 if (onlyfailed
== 1 && !(ATTRIBUTE_FLAGS_PREFAILURE(attr
.flags
) && state
== ATTRSTATE_FAILED_NOW
))
807 if (onlyfailed
== 2 && state
< ATTRSTATE_FAILED_PAST
)
810 // print header only if needed
813 pout("SMART Attributes Data Structure revision number: %d\n",(int)data
->revnumber
);
814 pout("Vendor Specific SMART Attributes with Thresholds:\n");
817 pout("ID# ATTRIBUTE_NAME FLAG VALUE WORST THRESH TYPE UPDATED WHEN_FAILED RAW_VALUE\n");
819 pout("ID# ATTRIBUTE_NAME FLAGS VALUE WORST THRESH FAIL RAW_VALUE\n");
823 // Format value, worst, threshold
824 std::string valstr
, worstr
, threstr
;
825 if (state
> ATTRSTATE_NO_NORMVAL
)
826 valstr
= strprintf("%.3d", attr
.current
);
829 if (!(defs
[attr
.id
].flags
& ATTRFLAG_NO_WORSTVAL
))
830 worstr
= strprintf("%.3d", attr
.worst
);
833 if (state
> ATTRSTATE_NO_THRESHOLD
)
834 threstr
= strprintf("%.3d", threshold
);
838 // Print line for each valid attribute
839 std::string attrname
= ata_get_smart_attr_name(attr
.id
, defs
);
840 std::string rawstr
= ata_format_attr_raw_value(attr
, defs
);
843 pout("%3d %-24s0x%04x %-3s %-3s %-3s %-10s%-9s%-12s%s\n",
844 attr
.id
, attrname
.c_str(), attr
.flags
,
845 valstr
.c_str(), worstr
.c_str(), threstr
.c_str(),
846 (ATTRIBUTE_FLAGS_PREFAILURE(attr
.flags
) ? "Pre-fail" : "Old_age"),
847 (ATTRIBUTE_FLAGS_ONLINE(attr
.flags
) ? "Always" : "Offline"),
848 (state
== ATTRSTATE_FAILED_NOW
? "FAILING_NOW" :
849 state
== ATTRSTATE_FAILED_PAST
? "In_the_past"
853 pout("%3d %-24s%c%c%c%c%c%c%c %-3s %-3s %-3s %-5s%s\n",
854 attr
.id
, attrname
.c_str(),
855 (ATTRIBUTE_FLAGS_PREFAILURE(attr
.flags
) ? 'P' : '-'),
856 (ATTRIBUTE_FLAGS_ONLINE(attr
.flags
) ? 'O' : '-'),
857 (ATTRIBUTE_FLAGS_PERFORMANCE(attr
.flags
) ? 'S' : '-'),
858 (ATTRIBUTE_FLAGS_ERRORRATE(attr
.flags
) ? 'R' : '-'),
859 (ATTRIBUTE_FLAGS_EVENTCOUNT(attr
.flags
) ? 'C' : '-'),
860 (ATTRIBUTE_FLAGS_SELFPRESERVING(attr
.flags
) ? 'K' : '-'),
861 (ATTRIBUTE_FLAGS_OTHER(attr
.flags
) ? '+' : ' '),
862 valstr
.c_str(), worstr
.c_str(), threstr
.c_str(),
863 (state
== ATTRSTATE_FAILED_NOW
? "NOW" :
864 state
== ATTRSTATE_FAILED_PAST
? "Past"
871 if (!onlyfailed
&& format
== 1)
872 pout("%28s||||||_ K auto-keep\n"
873 "%28s|||||__ C event count\n"
874 "%28s||||___ R error rate\n"
875 "%28s|||____ S speed/performance\n"
876 "%28s||_____ O updated online\n"
877 "%28s|______ P prefailure warning\n",
878 "", "", "", "", "", "");
883 // Print SMART related SCT capabilities
884 static void ataPrintSCTCapability(const ata_identify_device
*drive
)
886 unsigned short sctcaps
= drive
->words088_255
[206-88];
887 if (!(sctcaps
& 0x01))
889 pout("SCT capabilities: \t (0x%04x)\tSCT Status supported.\n", sctcaps
);
891 pout("\t\t\t\t\tSCT Error Recovery Control supported.\n");
893 pout("\t\t\t\t\tSCT Feature Control supported.\n");
895 pout("\t\t\t\t\tSCT Data Table supported.\n");
899 static void PrintGeneralSmartValues(const ata_smart_values
*data
, const ata_identify_device
*drive
,
900 unsigned char fix_firmwarebug
)
902 pout("General SMART Values:\n");
904 PrintSmartOfflineStatus(data
);
906 if (isSupportSelfTest(data
)){
907 PrintSmartSelfExecStatus(data
, fix_firmwarebug
);
910 PrintSmartTotalTimeCompleteOffline(data
);
911 PrintSmartOfflineCollectCap(data
);
912 PrintSmartCapability(data
);
914 PrintSmartErrorLogCapability(data
, drive
);
916 pout( "\t\t\t\t\t%s\n", isGeneralPurposeLoggingCapable(drive
)?
917 "General Purpose Logging supported.":
918 "No General Purpose Logging support.");
920 if (isSupportSelfTest(data
)){
921 PrintSmartShortSelfTestPollingTime (data
);
922 PrintSmartExtendedSelfTestPollingTime (data
);
924 if (isSupportConveyanceSelfTest(data
))
925 PrintSmartConveyanceSelfTestPollingTime (data
);
927 ataPrintSCTCapability(drive
);
932 // Get # sectors of a log addr, 0 if log does not exist.
933 static unsigned GetNumLogSectors(const ata_smart_log_directory
* logdir
, unsigned logaddr
, bool gpl
)
941 unsigned n
= logdir
->entry
[logaddr
-1].numsectors
;
943 // GP logs may have >255 sectors
944 n
|= logdir
->entry
[logaddr
-1].reserved
<< 8;
949 // Table A.2 of T13/2015-D Revision 4a (ACS-2), December 9, 2010.
950 static const char * GetLogName(unsigned logaddr
)
953 case 0x00: return "Log Directory";
954 case 0x01: return "Summary SMART error log";
955 case 0x02: return "Comprehensive SMART error log";
956 case 0x03: return "Ext. Comprehensive SMART error log";
957 case 0x04: return "Device Statistics";
958 case 0x05: return "Reserved for the CFA"; // ACS-2
959 case 0x06: return "SMART self-test log";
960 case 0x07: return "Extended self-test log";
961 case 0x08: return "Power Conditions"; // ACS-2
962 case 0x09: return "Selective self-test log";
963 case 0x0d: return "LPS Mis-alignment log"; // ACS-2
964 case 0x10: return "NCQ Command Error";
965 case 0x11: return "SATA Phy Event Counters";
966 case 0x20: return "Streaming performance log"; // Obsolete
967 case 0x21: return "Write stream error log";
968 case 0x22: return "Read stream error log";
969 case 0x23: return "Delayed sector log"; // Obsolete
970 case 0xe0: return "SCT Command/Status";
971 case 0xe1: return "SCT Data Transfer";
973 if (0xa0 <= logaddr
&& logaddr
<= 0xdf)
974 return "Device vendor specific log";
975 if (0x80 <= logaddr
&& logaddr
<= 0x9f)
976 return "Host vendor specific log";
977 if (0x12 <= logaddr
&& logaddr
<= 0x17)
978 return "Reserved for Serial ATA";
984 // Print SMART and/or GP Log Directory
985 static void PrintLogDirectories(const ata_smart_log_directory
* gplogdir
,
986 const ata_smart_log_directory
* smartlogdir
)
989 pout("General Purpose Log Directory Version %u\n", gplogdir
->logversion
);
991 pout("SMART %sLog Directory Version %u%s\n",
992 (gplogdir
? " " : ""), smartlogdir
->logversion
,
993 (smartlogdir
->logversion
==1 ? " [multi-sector log support]" : ""));
995 for (unsigned i
= 0; i
<= 0xff; i
++) {
996 // Get number of sectors
997 unsigned smart_numsect
= GetNumLogSectors(smartlogdir
, i
, false);
998 unsigned gp_numsect
= GetNumLogSectors(gplogdir
, i
, true );
1000 if (!(smart_numsect
|| gp_numsect
))
1001 continue; // Log does not exist
1003 const char * name
= GetLogName(i
);
1005 // Print name and length of log.
1006 // If both SMART and GP exist, print separate entries if length differ.
1007 if (smart_numsect
== gp_numsect
)
1008 pout( "GP/S Log at address 0x%02x has %4d sectors [%s]\n", i
, smart_numsect
, name
);
1011 pout("GP %sLog at address 0x%02x has %4d sectors [%s]\n", (smartlogdir
?" ":""),
1012 i
, gp_numsect
, name
);
1014 pout("SMART Log at address 0x%02x has %4d sectors [%s]\n", i
, smart_numsect
, name
);
1020 // Print hexdump of log pages.
1021 // Format is compatible with 'xxd -r'.
1022 static void PrintLogPages(const char * type
, const unsigned char * data
,
1023 unsigned char logaddr
, unsigned page
,
1024 unsigned num_pages
, unsigned max_pages
)
1026 pout("%s Log 0x%02x [%s], Page %u-%u (of %u)\n",
1027 type
, logaddr
, GetLogName(logaddr
), page
, page
+num_pages
-1, max_pages
);
1028 for (unsigned i
= 0; i
< num_pages
* 512; i
+= 16) {
1029 const unsigned char * p
= data
+i
;
1030 pout("%07x: %02x %02x %02x %02x %02x %02x %02x %02x "
1031 "%02x %02x %02x %02x %02x %02x %02x %02x ",
1033 p
[ 0], p
[ 1], p
[ 2], p
[ 3], p
[ 4], p
[ 5], p
[ 6], p
[ 7],
1034 p
[ 8], p
[ 9], p
[10], p
[11], p
[12], p
[13], p
[14], p
[15]);
1035 #define P(n) (isprint((int)(p[n]))?(int)(p[n]):'.')
1036 pout("|%c%c%c%c%c%c%c%c"
1037 "%c%c%c%c%c%c%c%c|\n",
1038 P( 0), P( 1), P( 2), P( 3), P( 4), P( 5), P( 6), P( 7),
1039 P( 8), P( 9), P(10), P(11), P(12), P(13), P(14), P(15));
1041 if ((i
& 0x1ff) == 0x1f0)
1047 static void PrintSataPhyEventCounters(const unsigned char * data
, bool reset
)
1050 checksumwarning("SATA Phy Event Counters");
1051 pout("SATA Phy Event Counters (GP Log 0x11)\n");
1052 if (data
[0] || data
[1] || data
[2] || data
[3])
1053 pout("[Reserved: 0x%02x 0x%02x 0x%02x 0x%02x]\n",
1054 data
[0], data
[1], data
[2], data
[3]);
1055 pout("ID Size Value Description\n");
1057 for (unsigned i
= 4; ; ) {
1058 // Get counter id and size (bits 14:12)
1059 unsigned id
= data
[i
] | (data
[i
+1] << 8);
1060 unsigned size
= ((id
>> 12) & 0x7) << 1;
1063 // End of counter table ?
1068 if (!(2 <= size
&& size
<= 8 && i
+ size
< 512)) {
1069 pout("0x%04x %u: Invalid entry\n", id
, size
);
1074 uint64_t val
= 0, max_val
= 0;
1075 for (unsigned j
= 0; j
< size
; j
+=2) {
1076 val
|= (uint64_t)(data
[i
+j
] | (data
[i
+j
+1] << 8)) << (j
*8);
1077 max_val
|= (uint64_t)0xffffU
<< (j
*8);
1084 case 0x001: name
= "Command failed due to ICRC error"; break; // Mandatory
1085 case 0x002: name
= "R_ERR response for data FIS"; break;
1086 case 0x003: name
= "R_ERR response for device-to-host data FIS"; break;
1087 case 0x004: name
= "R_ERR response for host-to-device data FIS"; break;
1088 case 0x005: name
= "R_ERR response for non-data FIS"; break;
1089 case 0x006: name
= "R_ERR response for device-to-host non-data FIS"; break;
1090 case 0x007: name
= "R_ERR response for host-to-device non-data FIS"; break;
1091 case 0x008: name
= "Device-to-host non-data FIS retries"; break;
1092 case 0x009: name
= "Transition from drive PhyRdy to drive PhyNRdy"; break;
1093 case 0x00A: name
= "Device-to-host register FISes sent due to a COMRESET"; break; // Mandatory
1094 case 0x00B: name
= "CRC errors within host-to-device FIS"; break;
1095 case 0x00D: name
= "Non-CRC errors within host-to-device FIS"; break;
1096 case 0x00F: name
= "R_ERR response for host-to-device data FIS, CRC"; break;
1097 case 0x010: name
= "R_ERR response for host-to-device data FIS, non-CRC"; break;
1098 case 0x012: name
= "R_ERR response for host-to-device non-data FIS, CRC"; break;
1099 case 0x013: name
= "R_ERR response for host-to-device non-data FIS, non-CRC"; break;
1100 default: name
= (id
& 0x8000 ? "Vendor specific" : "Unknown"); break;
1103 // Counters stop at max value, add '+' in this case
1104 pout("0x%04x %u %12"PRIu64
"%c %s\n", id
, size
, val
,
1105 (val
== max_val
? '+' : ' '), name
);
1108 pout("All counters reset\n");
1112 // Get description for 'state' value from SMART Error Logs
1113 static const char * get_error_log_state_desc(unsigned state
)
1117 case 0x0: return "in an unknown state";
1118 case 0x1: return "sleeping";
1119 case 0x2: return "in standby mode";
1120 case 0x3: return "active or idle";
1121 case 0x4: return "doing SMART Offline or Self-test";
1123 return (state
< 0xb ? "in a reserved state"
1124 : "in a vendor specific state");
1128 // returns number of errors
1129 static int PrintSmartErrorlog(const ata_smart_errorlog
*data
,
1130 unsigned char fix_firmwarebug
)
1132 pout("SMART Error Log Version: %d\n", (int)data
->revnumber
);
1134 // if no errors logged, return
1135 if (!data
->error_log_pointer
){
1136 pout("No Errors Logged\n\n");
1140 // If log pointer out of range, return
1141 if (data
->error_log_pointer
>5){
1142 pout("Invalid Error Log index = 0x%02x (T13/1321D rev 1c "
1143 "Section 8.41.6.8.2.2 gives valid range from 1 to 5)\n\n",
1144 (int)data
->error_log_pointer
);
1148 // Some internal consistency checking of the data structures
1149 if ((data
->ata_error_count
-data
->error_log_pointer
)%5 && fix_firmwarebug
!= FIX_SAMSUNG2
) {
1150 pout("Warning: ATA error count %d inconsistent with error log pointer %d\n\n",
1151 data
->ata_error_count
,data
->error_log_pointer
);
1154 // starting printing error log info
1155 if (data
->ata_error_count
<=5)
1156 pout( "ATA Error Count: %d\n", (int)data
->ata_error_count
);
1158 pout( "ATA Error Count: %d (device log contains only the most recent five errors)\n",
1159 (int)data
->ata_error_count
);
1161 pout("\tCR = Command Register [HEX]\n"
1162 "\tFR = Features Register [HEX]\n"
1163 "\tSC = Sector Count Register [HEX]\n"
1164 "\tSN = Sector Number Register [HEX]\n"
1165 "\tCL = Cylinder Low Register [HEX]\n"
1166 "\tCH = Cylinder High Register [HEX]\n"
1167 "\tDH = Device/Head Register [HEX]\n"
1168 "\tDC = Device Command Register [HEX]\n"
1169 "\tER = Error register [HEX]\n"
1170 "\tST = Status register [HEX]\n"
1171 "Powered_Up_Time is measured from power on, and printed as\n"
1172 "DDd+hh:mm:SS.sss where DD=days, hh=hours, mm=minutes,\n"
1173 "SS=sec, and sss=millisec. It \"wraps\" after 49.710 days.\n\n");
1175 // now step through the five error log data structures (table 39 of spec)
1176 for (int k
= 4; k
>= 0; k
-- ) {
1178 // The error log data structure entries are a circular buffer
1179 int j
, i
=(data
->error_log_pointer
+k
)%5;
1180 const ata_smart_errorlog_struct
* elog
= data
->errorlog_struct
+i
;
1181 const ata_smart_errorlog_error_struct
* summary
= &(elog
->error_struct
);
1183 // Spec says: unused error log structures shall be zero filled
1184 if (nonempty(elog
, sizeof(*elog
))){
1185 // Table 57 of T13/1532D Volume 1 Revision 3
1186 const char *msgstate
= get_error_log_state_desc(summary
->state
);
1187 int days
= (int)summary
->timestamp
/24;
1189 // See table 42 of ATA5 spec
1191 pout("Error %d occurred at disk power-on lifetime: %d hours (%d days + %d hours)\n",
1192 (int)(data
->ata_error_count
+k
-4), (int)summary
->timestamp
, days
, (int)(summary
->timestamp
-24*days
));
1194 pout(" When the command that caused the error occurred, the device was %s.\n\n",msgstate
);
1195 pout(" After command completion occurred, registers were:\n"
1196 " ER ST SC SN CL CH DH\n"
1197 " -- -- -- -- -- -- --\n"
1198 " %02x %02x %02x %02x %02x %02x %02x",
1199 (int)summary
->error_register
,
1200 (int)summary
->status
,
1201 (int)summary
->sector_count
,
1202 (int)summary
->sector_number
,
1203 (int)summary
->cylinder_low
,
1204 (int)summary
->cylinder_high
,
1205 (int)summary
->drive_head
);
1206 // Add a description of the contents of the status and error registers
1209 const char * st_er_desc
= construct_st_er_desc(descbuf
, elog
);
1211 pout(" %s", st_er_desc
);
1213 pout(" Commands leading to the command that caused the error were:\n"
1214 " CR FR SC SN CL CH DH DC Powered_Up_Time Command/Feature_Name\n"
1215 " -- -- -- -- -- -- -- -- ---------------- --------------------\n");
1216 for ( j
= 4; j
>= 0; j
--){
1217 const ata_smart_errorlog_command_struct
* thiscommand
= elog
->commands
+j
;
1219 // Spec says: unused data command structures shall be zero filled
1220 if (nonempty(thiscommand
, sizeof(*thiscommand
))) {
1221 char timestring
[32];
1223 // Convert integer milliseconds to a text-format string
1224 MsecToText(thiscommand
->timestamp
, timestring
);
1226 pout(" %02x %02x %02x %02x %02x %02x %02x %02x %16s %s\n",
1227 (int)thiscommand
->commandreg
,
1228 (int)thiscommand
->featuresreg
,
1229 (int)thiscommand
->sector_count
,
1230 (int)thiscommand
->sector_number
,
1231 (int)thiscommand
->cylinder_low
,
1232 (int)thiscommand
->cylinder_high
,
1233 (int)thiscommand
->drive_head
,
1234 (int)thiscommand
->devicecontrolreg
,
1236 look_up_ata_command(thiscommand
->commandreg
, thiscommand
->featuresreg
));
1243 if (printing_is_switchable
)
1246 return data
->ata_error_count
;
1249 // Print SMART Extended Comprehensive Error Log (GP Log 0x03)
1250 static int PrintSmartExtErrorLog(const ata_smart_exterrlog
* log
,
1251 unsigned nsectors
, unsigned max_errors
)
1253 pout("SMART Extended Comprehensive Error Log Version: %u (%u sectors)\n",
1254 log
->version
, nsectors
);
1256 if (!log
->device_error_count
) {
1257 pout("No Errors Logged\n\n");
1263 unsigned nentries
= nsectors
* 4;
1264 unsigned erridx
= log
->error_log_index
;
1265 if (!(1 <= erridx
&& erridx
<= nentries
)){
1266 // Some Samsung disks (at least SP1614C/SW100-25, HD300LJ/ZT100-12) use the
1267 // former index from Summary Error Log (byte 1, now reserved) and set byte 2-3
1269 if (!(erridx
== 0 && 1 <= log
->reserved1
&& log
->reserved1
<= nentries
)) {
1270 pout("Invalid Error Log index = 0x%04x (reserved = 0x%02x)\n", erridx
, log
->reserved1
);
1273 pout("Invalid Error Log index = 0x%04x, trying reserved byte (0x%02x) instead\n", erridx
, log
->reserved1
);
1274 erridx
= log
->reserved1
;
1277 // Index base is not clearly specified by ATA8-ACS (T13/1699-D Revision 6a),
1278 // it is 1-based in practice.
1281 // Calculate #errors to print
1282 unsigned errcnt
= log
->device_error_count
;
1284 if (errcnt
<= nentries
)
1285 pout("Device Error Count: %u\n", log
->device_error_count
);
1288 pout("Device Error Count: %u (device log contains only the most recent %u errors)\n",
1289 log
->device_error_count
, errcnt
);
1292 if (max_errors
< errcnt
)
1293 errcnt
= max_errors
;
1296 pout("\tCR = Command Register\n"
1297 "\tFEATR = Features Register\n"
1298 "\tCOUNT = Count (was: Sector Count) Register\n"
1299 "\tLBA_48 = Upper bytes of LBA High/Mid/Low Registers ] ATA-8\n"
1300 "\tLH = LBA High (was: Cylinder High) Register ] LBA\n"
1301 "\tLM = LBA Mid (was: Cylinder Low) Register ] Register\n"
1302 "\tLL = LBA Low (was: Sector Number) Register ]\n"
1303 "\tDV = Device (was: Device/Head) Register\n"
1304 "\tDC = Device Control Register\n"
1305 "\tER = Error register\n"
1306 "\tST = Status register\n"
1307 "Powered_Up_Time is measured from power on, and printed as\n"
1308 "DDd+hh:mm:SS.sss where DD=days, hh=hours, mm=minutes,\n"
1309 "SS=sec, and sss=millisec. It \"wraps\" after 49.710 days.\n\n");
1311 // Iterate through circular buffer in reverse direction
1312 for (unsigned i
= 0, errnum
= log
->device_error_count
;
1313 i
< errcnt
; i
++, errnum
--, erridx
= (erridx
> 0 ? erridx
- 1 : nentries
- 1)) {
1315 const ata_smart_exterrlog_error_log
& entry
= log
[erridx
/ 4].error_logs
[erridx
% 4];
1317 // Skip unused entries
1318 if (!nonempty(&entry
, sizeof(entry
))) {
1319 pout("Error %u [%u] log entry is empty\n", errnum
, erridx
);
1323 // Print error information
1325 const ata_smart_exterrlog_error
& err
= entry
.error
;
1326 pout("Error %u [%u] occurred at disk power-on lifetime: %u hours (%u days + %u hours)\n",
1327 errnum
, erridx
, err
.timestamp
, err
.timestamp
/ 24, err
.timestamp
% 24);
1330 pout(" When the command that caused the error occurred, the device was %s.\n\n",
1331 get_error_log_state_desc(err
.state
));
1334 pout(" After command completion occurred, registers were:\n"
1335 " ER -- ST COUNT LBA_48 LH LM LL DV DC\n"
1336 " -- -- -- == -- == == == -- -- -- -- --\n"
1337 " %02x -- %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
1339 err
.status_register
,
1340 err
.count_register_hi
,
1342 err
.lba_high_register_hi
,
1343 err
.lba_mid_register_hi
,
1344 err
.lba_low_register_hi
,
1345 err
.lba_high_register
,
1346 err
.lba_mid_register
,
1347 err
.lba_low_register
,
1348 err
.device_register
,
1349 err
.device_control_register
);
1351 // Add a description of the contents of the status and error registers
1354 const char * st_er_desc
= construct_st_er_desc(descbuf
, &entry
);
1356 pout(" %s", st_er_desc
);
1359 // Print command history
1360 pout(" Commands leading to the command that caused the error were:\n"
1361 " CR FEATR COUNT LBA_48 LH LM LL DV DC Powered_Up_Time Command/Feature_Name\n"
1362 " -- == -- == -- == == == -- -- -- -- -- --------------- --------------------\n");
1363 for (int ci
= 4; ci
>= 0; ci
--) {
1364 const ata_smart_exterrlog_command
& cmd
= entry
.commands
[ci
];
1366 // Skip unused entries
1367 if (!nonempty(&cmd
, sizeof(cmd
)))
1370 // Print registers, timestamp and ATA command name
1371 char timestring
[32];
1372 MsecToText(cmd
.timestamp
, timestring
);
1374 pout(" %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %16s %s\n",
1375 cmd
.command_register
,
1376 cmd
.features_register_hi
,
1377 cmd
.features_register
,
1378 cmd
.count_register_hi
,
1380 cmd
.lba_high_register_hi
,
1381 cmd
.lba_mid_register_hi
,
1382 cmd
.lba_low_register_hi
,
1383 cmd
.lba_high_register
,
1384 cmd
.lba_mid_register
,
1385 cmd
.lba_low_register
,
1386 cmd
.device_register
,
1387 cmd
.device_control_register
,
1389 look_up_ata_command(cmd
.command_register
, cmd
.features_register
));
1395 if (printing_is_switchable
)
1398 return log
->device_error_count
;
1401 // Print SMART Extended Self-test Log (GP Log 0x07)
1402 static int PrintSmartExtSelfTestLog(const ata_smart_extselftestlog
* log
,
1403 unsigned nsectors
, unsigned max_entries
)
1405 pout("SMART Extended Self-test Log Version: %u (%u sectors)\n",
1406 log
->version
, nsectors
);
1408 if (!log
->log_desc_index
){
1409 pout("No self-tests have been logged. [To run self-tests, use: smartctl -t]\n\n");
1414 unsigned nentries
= nsectors
* 19;
1415 unsigned logidx
= log
->log_desc_index
;
1416 if (logidx
> nentries
) {
1417 pout("Invalid Self-test Log index = 0x%04x (reserved = 0x%02x)\n", logidx
, log
->reserved1
);
1421 // Index base is not clearly specified by ATA8-ACS (T13/1699-D Revision 6a),
1422 // it is 1-based in practice.
1425 bool print_header
= true;
1426 int errcnt
= 0, igncnt
= 0;
1427 int ext_ok_testnum
= -1;
1429 // Iterate through circular buffer in reverse direction
1430 for (unsigned i
= 0, testnum
= 1;
1431 i
< nentries
&& testnum
<= max_entries
;
1432 i
++, logidx
= (logidx
> 0 ? logidx
- 1 : nentries
- 1)) {
1434 const ata_smart_extselftestlog_desc
& entry
= log
[logidx
/ 19].log_descs
[logidx
% 19];
1436 // Skip unused entries
1437 if (!nonempty(&entry
, sizeof(entry
)))
1441 const unsigned char * b
= entry
.failing_lba
;
1442 uint64_t lba48
= b
[0]
1445 | ((uint64_t)b
[3] << 24)
1446 | ((uint64_t)b
[4] << 32)
1447 | ((uint64_t)b
[5] << 40);
1450 int state
= ataPrintSmartSelfTestEntry(testnum
, entry
.self_test_type
,
1451 entry
.self_test_status
, entry
.timestamp
, lba48
,
1452 false /*!print_error_only*/, print_header
);
1455 // Self-test showed an error
1456 if (ext_ok_testnum
< 0)
1459 // Newer successful extended self-test exits
1462 else if (state
> 0 && ext_ok_testnum
< 0) {
1463 // Latest successful extended self-test
1464 ext_ok_testnum
= testnum
;
1470 pout("%d of %d failed self-tests are outdated by newer successful extended offline self-test #%2d\n",
1471 igncnt
, igncnt
+errcnt
, ext_ok_testnum
);
1477 static void ataPrintSelectiveSelfTestLog(const ata_selective_self_test_log
* log
, const ata_smart_values
* sv
)
1479 int i
,field1
,field2
;
1482 uint64_t maxl
=0,maxr
=0;
1483 uint64_t current
=log
->currentlba
;
1484 uint64_t currentend
=current
+65535;
1486 // print data structure revision number
1487 pout("SMART Selective self-test log data structure revision number %d\n",(int)log
->logversion
);
1488 if (1 != log
->logversion
)
1489 pout("Note: revision number not 1 implies that no selective self-test has ever been run\n");
1491 switch((sv
->self_test_exec_status
)>>4){
1492 case 0:msg
="Completed";
1494 case 1:msg
="Aborted_by_host";
1496 case 2:msg
="Interrupted";
1498 case 3:msg
="Fatal_error";
1500 case 4:msg
="Completed_unknown_failure";
1502 case 5:msg
="Completed_electrical_failure";
1504 case 6:msg
="Completed_servo/seek_failure";
1506 case 7:msg
="Completed_read_failure";
1508 case 8:msg
="Completed_handling_damage??";
1510 case 15:msg
="Self_test_in_progress";
1512 default:msg
="Unknown_status ";
1516 // find the number of columns needed for printing. If in use, the
1517 // start/end of span being read-scanned...
1518 if (log
->currentspan
>5) {
1522 for (i
=0; i
<5; i
++) {
1523 uint64_t start
=log
->span
[i
].start
;
1524 uint64_t end
=log
->span
[i
].end
;
1525 // ... plus max start/end of each of the five test spans.
1532 // we need at least 7 characters wide fields to accomodate the
1534 if ((field1
=snprintf(tmp
,64, "%"PRIu64
, maxl
))<7)
1536 if ((field2
=snprintf(tmp
,64, "%"PRIu64
, maxr
))<7)
1539 // now print the five test spans
1540 pout(" SPAN %*s %*s CURRENT_TEST_STATUS\n", field1
, "MIN_LBA", field2
, "MAX_LBA");
1542 for (i
=0; i
<5; i
++) {
1543 uint64_t start
=log
->span
[i
].start
;
1544 uint64_t end
=log
->span
[i
].end
;
1546 if ((i
+1)==(int)log
->currentspan
)
1547 // this span is currently under test
1548 pout(" %d %*"PRIu64
" %*"PRIu64
" %s [%01d0%% left] (%"PRIu64
"-%"PRIu64
")\n",
1549 i
+1, field1
, start
, field2
, end
, msg
,
1550 (int)(sv
->self_test_exec_status
& 0xf), current
, currentend
);
1552 // this span is not currently under test
1553 pout(" %d %*"PRIu64
" %*"PRIu64
" Not_testing\n",
1554 i
+1, field1
, start
, field2
, end
);
1557 // if we are currently read-scanning, print LBAs and the status of
1559 if (log
->currentspan
>5)
1560 pout("%5d %*"PRIu64
" %*"PRIu64
" Read_scanning %s\n",
1561 (int)log
->currentspan
, field1
, current
, field2
, currentend
,
1562 OfflineDataCollectionStatus(sv
->offline_data_collection_status
));
1564 /* Print selective self-test flags. Possible flag combinations are
1565 (numbering bits from 0-15):
1569 1 0 0 Will carry out scan after selective test
1570 1 1 0 Waiting to carry out scan after powerup
1571 1 0 1 Currently scanning
1572 1 1 1 Currently scanning
1575 pout("Selective self-test flags (0x%x):\n", (unsigned int)log
->flags
);
1576 if (log
->flags
& SELECTIVE_FLAG_DOSCAN
) {
1577 if (log
->flags
& SELECTIVE_FLAG_ACTIVE
)
1578 pout(" Currently read-scanning the remainder of the disk.\n");
1579 else if (log
->flags
& SELECTIVE_FLAG_PENDING
)
1580 pout(" Read-scan of remainder of disk interrupted; will resume %d min after power-up.\n",
1581 (int)log
->pendingtime
);
1583 pout(" After scanning selected spans, read-scan remainder of disk.\n");
1586 pout(" After scanning selected spans, do NOT read-scan remainder of disk.\n");
1588 // print pending time
1589 pout("If Selective self-test is pending on power-up, resume after %d minute delay.\n",
1590 (int)log
->pendingtime
);
1595 // Format SCT Temperature value
1596 static const char * sct_ptemp(signed char x
, char * buf
)
1598 if (x
== -128 /*0x80 = unknown*/)
1601 sprintf(buf
, "%2d", x
);
1605 static const char * sct_pbar(int x
, char * buf
)
1616 memset(buf
, '*', x
);
1622 buf
[0] = '-'; buf
[1] = 0;
1627 static const char * sct_device_state_msg(unsigned char state
)
1630 case 0: return "Active";
1631 case 1: return "Stand-by";
1632 case 2: return "Sleep";
1633 case 3: return "DST executing in background";
1634 case 4: return "SMART Off-line Data Collection executing in background";
1635 case 5: return "SCT command executing in background";
1636 default:return "Unknown";
1641 static int ataPrintSCTStatus(const ata_sct_status_response
* sts
)
1643 pout("SCT Status Version: %u\n", sts
->format_version
);
1644 pout("SCT Version (vendor specific): %u (0x%04x)\n", sts
->sct_version
, sts
->sct_version
);
1645 pout("SCT Support Level: %u\n", sts
->sct_spec
);
1646 pout("Device State: %s (%u)\n",
1647 sct_device_state_msg(sts
->device_state
), sts
->device_state
);
1648 char buf1
[20], buf2
[20];
1649 if ( !sts
->min_temp
&& !sts
->life_min_temp
&& !sts
->byte205
1650 && !sts
->under_limit_count
&& !sts
->over_limit_count
) {
1651 // "Reserved" fields not set, assume "old" format version 2
1652 // Table 11 of T13/1701DT Revision 5
1653 // Table 54 of T13/1699-D Revision 3e
1654 pout("Current Temperature: %s Celsius\n",
1655 sct_ptemp(sts
->hda_temp
, buf1
));
1656 pout("Power Cycle Max Temperature: %s Celsius\n",
1657 sct_ptemp(sts
->max_temp
, buf2
));
1658 pout("Lifetime Max Temperature: %s Celsius\n",
1659 sct_ptemp(sts
->life_max_temp
, buf2
));
1662 // Assume "new" format version 2 or version 3
1663 // T13/e06152r0-3 (Additional SCT Temperature Statistics)
1664 // Table 60 of T13/1699-D Revision 3f
1665 pout("Current Temperature: %s Celsius\n",
1666 sct_ptemp(sts
->hda_temp
, buf1
));
1667 pout("Power Cycle Min/Max Temperature: %s/%s Celsius\n",
1668 sct_ptemp(sts
->min_temp
, buf1
), sct_ptemp(sts
->max_temp
, buf2
));
1669 pout("Lifetime Min/Max Temperature: %s/%s Celsius\n",
1670 sct_ptemp(sts
->life_min_temp
, buf1
), sct_ptemp(sts
->life_max_temp
, buf2
));
1671 if (sts
->byte205
) // e06152r0-2, removed in e06152r3
1672 pout("Lifetime Average Temperature: %s Celsius\n",
1673 sct_ptemp((signed char)sts
->byte205
, buf1
));
1674 pout("Under/Over Temperature Limit Count: %2u/%u\n",
1675 sts
->under_limit_count
, sts
->over_limit_count
);
1680 // Print SCT Temperature History Table
1681 static int ataPrintSCTTempHist(const ata_sct_temperature_history_table
* tmh
)
1683 char buf1
[20], buf2
[80];
1684 pout("SCT Temperature History Version: %u\n", tmh
->format_version
);
1685 pout("Temperature Sampling Period: %u minute%s\n",
1686 tmh
->sampling_period
, (tmh
->sampling_period
==1?"":"s"));
1687 pout("Temperature Logging Interval: %u minute%s\n",
1688 tmh
->interval
, (tmh
->interval
==1?"":"s"));
1689 pout("Min/Max recommended Temperature: %s/%s Celsius\n",
1690 sct_ptemp(tmh
->min_op_limit
, buf1
), sct_ptemp(tmh
->max_op_limit
, buf2
));
1691 pout("Min/Max Temperature Limit: %s/%s Celsius\n",
1692 sct_ptemp(tmh
->under_limit
, buf1
), sct_ptemp(tmh
->over_limit
, buf2
));
1693 pout("Temperature History Size (Index): %u (%u)\n", tmh
->cb_size
, tmh
->cb_index
);
1694 if (!(0 < tmh
->cb_size
&& tmh
->cb_size
<= sizeof(tmh
->cb
) && tmh
->cb_index
< tmh
->cb_size
)) {
1695 pout("Error invalid Temperature History Size or Index\n");
1700 pout("\nIndex Estimated Time Temperature Celsius\n");
1701 unsigned n
= 0, i
= (tmh
->cb_index
+1) % tmh
->cb_size
;
1702 unsigned interval
= (tmh
->interval
> 0 ? tmh
->interval
: 1);
1703 time_t t
= time(0) - (tmh
->cb_size
-1) * interval
* 60;
1704 t
-= t
% (interval
* 60);
1705 while (n
< tmh
->cb_size
) {
1706 // Find range of identical temperatures
1707 unsigned n1
= n
, n2
= n
+1, i2
= (i
+1) % tmh
->cb_size
;
1708 while (n2
< tmh
->cb_size
&& tmh
->cb
[i2
] == tmh
->cb
[i
]) {
1709 n2
++; i2
= (i2
+1) % tmh
->cb_size
;
1713 if (n
== n1
|| n
== n2
-1 || n2
<= n1
+3) {
1715 // TODO: Don't print times < boot time
1716 strftime(date
, sizeof(date
), "%Y-%m-%d %H:%M", localtime(&t
));
1717 pout(" %3u %s %s %s\n", i
, date
,
1718 sct_ptemp(tmh
->cb
[i
], buf1
), sct_pbar(tmh
->cb
[i
], buf2
));
1720 else if (n
== n1
+1) {
1721 pout(" ... ..(%3u skipped). .. %s\n",
1722 n2
-n1
-2, sct_pbar(tmh
->cb
[i
], buf2
));
1724 t
+= interval
* 60; i
= (i
+1) % tmh
->cb_size
; n
++;
1727 //assert(n == tmh->cb_size && i == (tmh->cb_index+1) % tmh->cb_size);
1732 // Print SCT Error Recovery Control timers
1733 static void ataPrintSCTErrorRecoveryControl(bool set
, unsigned short read_timer
, unsigned short write_timer
)
1735 pout("SCT Error Recovery Control%s:\n", (set
? " set to" : ""));
1737 pout(" Read: Disabled\n");
1739 pout(" Read: %6d (%0.1f seconds)\n", read_timer
, read_timer
/10.0);
1741 pout(" Write: Disabled\n");
1743 pout(" Write: %6d (%0.1f seconds)\n", write_timer
, write_timer
/10.0);
1747 int ataPrintMain (ata_device
* device
, const ata_print_options
& options
)
1749 // If requested, check power mode first
1750 const char * powername
= 0;
1751 bool powerchg
= false;
1752 if (options
.powermode
) {
1753 unsigned char powerlimit
= 0xff;
1754 int powermode
= ataCheckPowerMode(device
);
1755 switch (powermode
) {
1757 if (device
->get_errno() == ENOSYS
) {
1758 pout("CHECK POWER MODE not implemented, ignoring -n option\n"); break;
1760 powername
= "SLEEP"; powerlimit
= 2;
1763 powername
= "STANDBY"; powerlimit
= 3; break;
1765 powername
= "IDLE"; powerlimit
= 4; break;
1767 powername
= "ACTIVE or IDLE"; break;
1769 pout("CHECK POWER MODE returned unknown value 0x%02x, ignoring -n option\n", powermode
);
1773 if (options
.powermode
>= powerlimit
) {
1774 pout("Device is in %s mode, exit(%d)\n", powername
, FAILPOWER
);
1777 powerchg
= (powermode
!= 0xff); // SMART tests will spin up drives
1781 // SMART values needed ?
1782 bool need_smart_val
= (
1783 options
.smart_check_status
1784 || options
.smart_general_values
1785 || options
.smart_vendor_attrib
1786 || options
.smart_error_log
1787 || options
.smart_selftest_log
1788 || options
.smart_selective_selftest_log
1789 || options
.smart_ext_error_log
1790 || options
.smart_ext_selftest_log
1791 || options
.smart_auto_offl_enable
1792 || options
.smart_auto_offl_disable
1793 || options
.smart_selftest_type
!= -1
1796 // SMART must be enabled ?
1797 bool need_smart_enabled
= (
1799 || options
.smart_auto_save_enable
1800 || options
.smart_auto_save_disable
1803 // SMART feature set needed ?
1804 bool need_smart_support
= (
1806 || options
.smart_enable
1807 || options
.smart_disable
1810 // SMART and GP log directories needed ?
1811 bool need_smart_logdir
= options
.smart_logdir
;
1813 bool need_gp_logdir
= (
1815 || options
.smart_ext_error_log
1816 || options
.smart_ext_selftest_log
1821 for (i
= 0; i
< options
.log_requests
.size(); i
++) {
1822 if (options
.log_requests
[i
].gpl
)
1823 need_gp_logdir
= true;
1825 need_smart_logdir
= true;
1828 // SCT commands needed ?
1829 bool need_sct_support
= (
1830 options
.sct_temp_sts
1831 || options
.sct_temp_hist
1832 || options
.sct_temp_int
1833 || options
.sct_erc_get
1834 || options
.sct_erc_set
1837 // Exit if no further options specified
1838 if (!( options
.drive_info
|| need_smart_support
1839 || need_smart_logdir
|| need_gp_logdir
1840 || need_sct_support
)) {
1842 pout("Device is in %s mode\n", powername
);
1844 pout("ATA device successfully opened\n\n"
1845 "Use 'smartctl -a' (or '-x') to print SMART (and more) information\n\n");
1849 // Start by getting Drive ID information. We need this, to know if SMART is supported.
1851 ata_identify_device drive
; memset(&drive
, 0, sizeof(drive
));
1852 device
->clear_err();
1853 int retid
= ata_read_identity(device
, &drive
, options
.fix_swapped_id
);
1855 pout("Smartctl: Device Read Identity Failed: %s\n\n",
1856 (device
->get_errno() ? device
->get_errmsg() : "Unknown error"));
1857 failuretest(MANDATORY_CMD
, returnval
|=FAILID
);
1859 else if (!nonempty(&drive
, sizeof(drive
))) {
1860 pout("Smartctl: Device Read Identity Failed: empty IDENTIFY data\n\n");
1861 failuretest(MANDATORY_CMD
, returnval
|=FAILID
);
1864 // If requested, show which presets would be used for this drive and exit.
1865 if (options
.show_presets
) {
1866 show_presets(&drive
);
1870 // Use preset vendor attribute options unless user has requested otherwise.
1871 ata_vendor_attr_defs attribute_defs
= options
.attribute_defs
;
1872 unsigned char fix_firmwarebug
= options
.fix_firmwarebug
;
1873 const drive_settings
* dbentry
= 0;
1874 if (!options
.ignore_presets
)
1875 dbentry
= lookup_drive_apply_presets(&drive
, attribute_defs
,
1878 // Get capacity and sector sizes
1879 ata_size_info sizes
;
1880 ata_get_size_info(&drive
, sizes
);
1882 // Print most drive identity information if requested
1883 if (options
.drive_info
) {
1884 pout("=== START OF INFORMATION SECTION ===\n");
1885 print_drive_info(&drive
, sizes
, dbentry
);
1888 // Check and print SMART support and state
1889 int smart_supported
= -1, smart_enabled
= -1;
1890 if (need_smart_support
|| options
.drive_info
) {
1894 pout("SMART support is: Unavailable - Packet Interface Devices [this device: %s] don't support ATA SMART\n",
1895 packetdevicetype(retid
-1));
1898 // Disk device: SMART supported and enabled ?
1899 smart_supported
= ataSmartSupport(&drive
);
1900 smart_enabled
= ataIsSmartEnabled(&drive
);
1902 if (smart_supported
< 0)
1903 pout("SMART support is: Ambiguous - ATA IDENTIFY DEVICE words 82-83 don't show if SMART supported.\n");
1904 if (smart_supported
&& smart_enabled
< 0) {
1905 pout("SMART support is: Ambiguous - ATA IDENTIFY DEVICE words 85-87 don't show if SMART is enabled.\n");
1906 if (need_smart_support
) {
1907 failuretest(MANDATORY_CMD
, returnval
|=FAILSMART
);
1908 // check SMART support by trying a command
1909 pout(" Checking to be sure by trying SMART RETURN STATUS command.\n");
1910 if (ataDoesSmartWork(device
))
1911 smart_supported
= smart_enabled
= 1;
1914 else if (smart_supported
< 0 && (smart_enabled
> 0 || dbentry
))
1915 // Assume supported if enabled or in drive database
1916 smart_supported
= 1;
1918 if (smart_supported
< 0)
1919 pout("SMART support is: Unknown - Try option -s with argument 'on' to enable it.");
1920 else if (!smart_supported
)
1921 pout("SMART support is: Unavailable - device lacks SMART capability.\n");
1923 if (options
.drive_info
)
1924 pout("SMART support is: Available - device has SMART capability.\n");
1925 if (smart_enabled
>= 0) {
1926 if (device
->ata_identify_is_cached()) {
1927 if (options
.drive_info
)
1928 pout(" %sabled status cached by OS, trying SMART RETURN STATUS cmd.\n",
1929 (smart_enabled
?"En":"Dis"));
1930 smart_enabled
= ataDoesSmartWork(device
);
1932 if (options
.drive_info
)
1933 pout("SMART support is: %s\n",
1934 (smart_enabled
? "Enabled" : "Disabled"));
1940 // Print remaining drive info
1941 if (options
.drive_info
) {
1942 // Print the (now possibly changed) power mode if available
1944 pout("Power mode %s %s\n", (powerchg
?"was:":"is: "), powername
);
1948 // Exit if SMART is not supported but must be available to proceed
1949 if (smart_supported
<= 0 && need_smart_support
)
1950 failuretest(MANDATORY_CMD
, returnval
|=FAILSMART
);
1952 // START OF THE ENABLE/DISABLE SECTION OF THE CODE
1953 if ( options
.smart_disable
|| options
.smart_enable
1954 || options
.smart_auto_save_disable
|| options
.smart_auto_save_enable
1955 || options
.smart_auto_offl_disable
|| options
.smart_auto_offl_enable
)
1956 pout("=== START OF ENABLE/DISABLE COMMANDS SECTION ===\n");
1958 // Enable/Disable SMART commands
1959 if (options
.smart_enable
) {
1960 if (ataEnableSmart(device
)) {
1961 pout("Smartctl: SMART Enable Failed.\n\n");
1962 failuretest(MANDATORY_CMD
, returnval
|=FAILSMART
);
1965 pout("SMART Enabled.\n");
1970 // Turn off SMART on device
1971 if (options
.smart_disable
) {
1972 if (ataDisableSmart(device
)) {
1973 pout( "Smartctl: SMART Disable Failed.\n\n");
1974 failuretest(MANDATORY_CMD
,returnval
|=FAILSMART
);
1978 // Exit if SMART is disabled but must be enabled to proceed
1979 if (options
.smart_disable
|| (smart_enabled
<= 0 && need_smart_enabled
)) {
1980 pout("SMART Disabled. Use option -s with argument 'on' to enable it.\n");
1984 // Enable/Disable Auto-save attributes
1985 if (options
.smart_auto_save_enable
) {
1986 if (ataEnableAutoSave(device
)){
1987 pout( "Smartctl: SMART Enable Attribute Autosave Failed.\n\n");
1988 failuretest(MANDATORY_CMD
, returnval
|=FAILSMART
);
1991 pout("SMART Attribute Autosave Enabled.\n");
1994 if (options
.smart_auto_save_disable
) {
1995 if (ataDisableAutoSave(device
)){
1996 pout( "Smartctl: SMART Disable Attribute Autosave Failed.\n\n");
1997 failuretest(MANDATORY_CMD
, returnval
|=FAILSMART
);
2000 pout("SMART Attribute Autosave Disabled.\n");
2003 // Read SMART values and thresholds if necessary
2004 ata_smart_values smartval
; memset(&smartval
, 0, sizeof(smartval
));
2005 ata_smart_thresholds_pvt smartthres
; memset(&smartthres
, 0, sizeof(smartthres
));
2006 bool smart_val_ok
= false, smart_thres_ok
= false;
2008 if (need_smart_val
) {
2009 if (ataReadSmartValues(device
, &smartval
)) {
2010 pout("Smartctl: SMART Read Values failed.\n\n");
2011 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2014 smart_val_ok
= true;
2016 if (options
.smart_check_status
|| options
.smart_vendor_attrib
) {
2017 if (ataReadSmartThresholds(device
, &smartthres
)){
2018 pout("Smartctl: SMART Read Thresholds failed.\n\n");
2019 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2022 smart_thres_ok
= true;
2027 // Enable/Disable Off-line testing
2028 bool needupdate
= false;
2029 if (options
.smart_auto_offl_enable
) {
2030 if (!isSupportAutomaticTimer(&smartval
)){
2031 pout("Warning: device does not support SMART Automatic Timers.\n\n");
2032 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2034 needupdate
= smart_val_ok
;
2035 if (ataEnableAutoOffline(device
)){
2036 pout( "Smartctl: SMART Enable Automatic Offline Failed.\n\n");
2037 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2040 pout("SMART Automatic Offline Testing Enabled every four hours.\n");
2043 if (options
.smart_auto_offl_disable
) {
2044 if (!isSupportAutomaticTimer(&smartval
)){
2045 pout("Warning: device does not support SMART Automatic Timers.\n\n");
2046 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2048 needupdate
= smart_val_ok
;
2049 if (ataDisableAutoOffline(device
)){
2050 pout("Smartctl: SMART Disable Automatic Offline Failed.\n\n");
2051 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2054 pout("SMART Automatic Offline Testing Disabled.\n");
2057 if (needupdate
&& ataReadSmartValues(device
, &smartval
)){
2058 pout("Smartctl: SMART Read Values failed.\n\n");
2059 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2060 smart_val_ok
= false;
2063 // all this for a newline!
2064 if ( options
.smart_disable
|| options
.smart_enable
2065 || options
.smart_auto_save_disable
|| options
.smart_auto_save_enable
2066 || options
.smart_auto_offl_disable
|| options
.smart_auto_offl_enable
)
2069 // START OF READ-ONLY OPTIONS APART FROM -V and -i
2070 if ( options
.smart_check_status
|| options
.smart_general_values
2071 || options
.smart_vendor_attrib
|| options
.smart_error_log
2072 || options
.smart_selftest_log
|| options
.smart_selective_selftest_log
2073 || options
.smart_ext_error_log
|| options
.smart_ext_selftest_log
2074 || options
.sct_temp_sts
|| options
.sct_temp_hist
)
2075 pout("=== START OF READ SMART DATA SECTION ===\n");
2077 // Check SMART status
2078 if (options
.smart_check_status
) {
2080 switch (ataSmartStatus2(device
)) {
2083 // The case where the disk health is OK
2084 pout("SMART overall-health self-assessment test result: PASSED\n");
2085 if (smart_thres_ok
&& find_failed_attr(&smartval
, &smartthres
, attribute_defs
, 0)) {
2086 if (options
.smart_vendor_attrib
)
2087 pout("See vendor-specific Attribute list for marginal Attributes.\n\n");
2090 pout("Please note the following marginal Attributes:\n");
2091 PrintSmartAttribWithThres(&smartval
, &smartthres
, attribute_defs
, 2, options
.output_format
);
2100 // The case where the disk health is NOT OK
2102 pout("SMART overall-health self-assessment test result: FAILED!\n"
2103 "Drive failure expected in less than 24 hours. SAVE ALL DATA.\n");
2105 if (smart_thres_ok
&& find_failed_attr(&smartval
, &smartthres
, attribute_defs
, 1)) {
2106 returnval
|=FAILATTR
;
2107 if (options
.smart_vendor_attrib
)
2108 pout("See vendor-specific Attribute list for failed Attributes.\n\n");
2111 pout("Failed Attributes:\n");
2112 PrintSmartAttribWithThres(&smartval
, &smartthres
, attribute_defs
, 1, options
.output_format
);
2116 pout("No failed Attributes found.\n\n");
2117 returnval
|=FAILSTATUS
;
2123 // Something went wrong with the SMART STATUS command.
2124 // The ATA SMART RETURN STATUS command provides the result in the ATA output
2125 // registers. Buggy ATA/SATA drivers and SAT Layers often do not properly
2126 // return the registers values.
2127 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2128 if (!(smart_val_ok
&& smart_thres_ok
)) {
2130 pout("SMART overall-health self-assessment test result: UNKNOWN!\n"
2131 "SMART Status, Attributes and Thresholds cannot be read.\n\n");
2133 else if (find_failed_attr(&smartval
, &smartthres
, attribute_defs
, 1)) {
2135 pout("SMART overall-health self-assessment test result: FAILED!\n"
2136 "Drive failure expected in less than 24 hours. SAVE ALL DATA.\n");
2138 returnval
|=FAILATTR
;
2139 returnval
|=FAILSTATUS
;
2140 if (options
.smart_vendor_attrib
)
2141 pout("See vendor-specific Attribute list for failed Attributes.\n\n");
2144 pout("Failed Attributes:\n");
2145 PrintSmartAttribWithThres(&smartval
, &smartthres
, attribute_defs
, 1, options
.output_format
);
2149 pout("SMART overall-health self-assessment test result: PASSED\n");
2150 pout("Warning: This result is based on an Attribute check.\n");
2151 if (find_failed_attr(&smartval
, &smartthres
, attribute_defs
, 0)) {
2152 if (options
.smart_vendor_attrib
)
2153 pout("See vendor-specific Attribute list for marginal Attributes.\n\n");
2156 pout("Please note the following marginal Attributes:\n");
2157 PrintSmartAttribWithThres(&smartval
, &smartthres
, attribute_defs
, 2, options
.output_format
);
2166 } // end of switch statement
2169 } // end of checking SMART Status
2171 // Print general SMART values
2172 if (smart_val_ok
&& options
.smart_general_values
)
2173 PrintGeneralSmartValues(&smartval
, &drive
, fix_firmwarebug
);
2175 // Print vendor-specific attributes
2176 if (smart_val_ok
&& options
.smart_vendor_attrib
) {
2178 PrintSmartAttribWithThres(&smartval
, &smartthres
, attribute_defs
,
2179 (printing_is_switchable
? 2 : 0), options
.output_format
);
2183 // If GP Log is supported use smart log directory for
2184 // error and selftest log support check.
2185 if ( isGeneralPurposeLoggingCapable(&drive
)
2186 && ( options
.smart_error_log
|| options
.smart_selftest_log
2187 || options
.retry_error_log
|| options
.retry_selftest_log
))
2188 need_smart_logdir
= true;
2190 ata_smart_log_directory smartlogdir_buf
, gplogdir_buf
;
2191 const ata_smart_log_directory
* smartlogdir
= 0, * gplogdir
= 0;
2193 // Read SMART Log directory
2194 if (need_smart_logdir
) {
2195 if (ataReadLogDirectory(device
, &smartlogdir_buf
, false)) {
2196 pout("Read SMART Log Directory failed.\n\n");
2197 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2200 smartlogdir
= &smartlogdir_buf
;
2203 // Read GP Log directory
2204 if (need_gp_logdir
) {
2205 if (ataReadLogDirectory(device
, &gplogdir_buf
, true)) {
2206 pout("Read GP Log Directory failed.\n\n");
2207 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2210 gplogdir
= &gplogdir_buf
;
2213 // Print log directories
2214 if ((options
.gp_logdir
&& gplogdir
) || (options
.smart_logdir
&& smartlogdir
))
2215 PrintLogDirectories(gplogdir
, smartlogdir
);
2218 for (i
= 0; i
< options
.log_requests
.size(); i
++) {
2219 const ata_log_request
& req
= options
.log_requests
[i
];
2222 unsigned max_nsectors
;
2224 type
= "General Purpose";
2225 max_nsectors
= GetNumLogSectors(gplogdir
, req
.logaddr
, true);
2229 max_nsectors
= GetNumLogSectors(smartlogdir
, req
.logaddr
, false);
2232 if (!max_nsectors
) {
2233 if (!is_permissive()) {
2234 pout("%s Log 0x%02x does not exist (override with '-T permissive' option)\n", type
, req
.logaddr
);
2237 max_nsectors
= req
.page
+1;
2239 if (max_nsectors
<= req
.page
) {
2240 pout("%s Log 0x%02x has only %u sectors, output skipped\n", type
, req
.logaddr
, max_nsectors
);
2244 unsigned ns
= req
.nsectors
;
2245 if (ns
> max_nsectors
- req
.page
) {
2246 if (req
.nsectors
!= ~0U) // "FIRST-max"
2247 pout("%s Log 0x%02x has only %u sectors, output truncated\n", type
, req
.logaddr
, max_nsectors
);
2248 ns
= max_nsectors
- req
.page
;
2251 // SMART log don't support sector offset, start with first sector
2252 unsigned offs
= (req
.gpl
? 0 : req
.page
);
2254 raw_buffer
log_buf((offs
+ ns
) * 512);
2257 ok
= ataReadLogExt(device
, req
.logaddr
, 0x00, req
.page
, log_buf
.data(), ns
);
2259 ok
= ataReadSmartLog(device
, req
.logaddr
, log_buf
.data(), offs
+ ns
);
2261 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2263 PrintLogPages(type
, log_buf
.data() + offs
*512, req
.logaddr
, req
.page
, ns
, max_nsectors
);
2266 // Print SMART Extendend Comprehensive Error Log
2267 bool do_smart_error_log
= options
.smart_error_log
;
2268 if (options
.smart_ext_error_log
) {
2270 unsigned nsectors
= GetNumLogSectors(gplogdir
, 0x03, true);
2272 pout("SMART Extended Comprehensive Error Log (GP Log 0x03) not supported\n");
2273 else if (nsectors
>= 256)
2274 pout("SMART Extended Comprehensive Error Log size %u not supported\n", nsectors
);
2276 raw_buffer
log_03_buf(nsectors
* 512);
2277 ata_smart_exterrlog
* log_03
= (ata_smart_exterrlog
*)log_03_buf
.data();
2278 if (!ataReadExtErrorLog(device
, log_03
, nsectors
))
2279 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2281 if (PrintSmartExtErrorLog(log_03
, nsectors
, options
.smart_ext_error_log
))
2282 returnval
|= FAILERR
;
2288 if (options
.retry_error_log
)
2289 do_smart_error_log
= true;
2290 else if (!do_smart_error_log
)
2291 pout("Try '-l [xerror,]error' to read traditional SMART Error Log\n");
2295 // Print SMART error log
2296 if (do_smart_error_log
) {
2297 if (!( ( smartlogdir
&& GetNumLogSectors(smartlogdir
, 0x01, false))
2298 || (!smartlogdir
&& isSmartErrorLogCapable(&smartval
, &drive
) )
2299 || is_permissive() )) {
2300 pout("SMART Error Log not supported\n");
2303 ata_smart_errorlog smarterror
; memset(&smarterror
, 0, sizeof(smarterror
));
2304 if (ataReadErrorLog(device
, &smarterror
, fix_firmwarebug
)) {
2305 pout("Smartctl: SMART Error Log Read Failed\n");
2306 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2309 // quiet mode is turned on inside PrintSmartErrorLog()
2310 if (PrintSmartErrorlog(&smarterror
, fix_firmwarebug
))
2317 // Print SMART Extendend Self-test Log
2318 bool do_smart_selftest_log
= options
.smart_selftest_log
;
2319 if (options
.smart_ext_selftest_log
) {
2321 unsigned nsectors
= GetNumLogSectors(gplogdir
, 0x07, true);
2323 pout("SMART Extended Self-test Log (GP Log 0x07) not supported\n");
2324 else if (nsectors
>= 256)
2325 pout("SMART Extended Self-test Log size %u not supported\n", nsectors
);
2327 raw_buffer
log_07_buf(nsectors
* 512);
2328 ata_smart_extselftestlog
* log_07
= (ata_smart_extselftestlog
*)log_07_buf
.data();
2329 if (!ataReadExtSelfTestLog(device
, log_07
, nsectors
))
2330 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2332 if (PrintSmartExtSelfTestLog(log_07
, nsectors
, options
.smart_ext_selftest_log
))
2333 returnval
|= FAILLOG
;
2339 if (options
.retry_selftest_log
)
2340 do_smart_selftest_log
= true;
2341 else if (!do_smart_selftest_log
)
2342 pout("Try '-l [xselftest,]selftest' to read traditional SMART Self Test Log\n");
2346 // Print SMART self-test log
2347 if (do_smart_selftest_log
) {
2348 if (!( ( smartlogdir
&& GetNumLogSectors(smartlogdir
, 0x06, false))
2349 || (!smartlogdir
&& isSmartTestLogCapable(&smartval
, &drive
) )
2350 || is_permissive() )) {
2351 pout("SMART Self-test Log not supported\n");
2354 ata_smart_selftestlog smartselftest
; memset(&smartselftest
, 0, sizeof(smartselftest
));
2355 if (ataReadSelfTestLog(device
, &smartselftest
, fix_firmwarebug
)) {
2356 pout("Smartctl: SMART Self Test Log Read Failed\n");
2357 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2361 if (ataPrintSmartSelfTestlog(&smartselftest
, !printing_is_switchable
, fix_firmwarebug
))
2362 returnval
|= FAILLOG
;
2369 // Print SMART selective self-test log
2370 if (options
.smart_selective_selftest_log
) {
2371 ata_selective_self_test_log log
;
2373 if (!isSupportSelectiveSelfTest(&smartval
))
2374 pout("Device does not support Selective Self Tests/Logging\n");
2375 else if(ataReadSelectiveSelfTestLog(device
, &log
)) {
2376 pout("Smartctl: SMART Selective Self Test Log Read Failed\n");
2377 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2381 // If any errors were found, they are logged in the SMART Self-test log.
2382 // So there is no need to print the Selective Self Test log in silent
2384 if (!printing_is_switchable
)
2385 ataPrintSelectiveSelfTestLog(&log
, &smartval
);
2392 bool sct_ok
= false;
2393 if (need_sct_support
) {
2394 if (!isSCTCapable(&drive
)) {
2395 pout("Warning: device does not support SCT Commands\n");
2396 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2402 // Print SCT status and temperature history table
2403 if (sct_ok
&& (options
.sct_temp_sts
|| options
.sct_temp_hist
|| options
.sct_temp_int
)) {
2405 if (options
.sct_temp_sts
|| options
.sct_temp_hist
) {
2406 ata_sct_status_response sts
;
2407 ata_sct_temperature_history_table tmh
;
2408 if (!options
.sct_temp_hist
) {
2409 // Read SCT status only
2410 if (ataReadSCTStatus(device
, &sts
)) {
2411 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2416 if (!isSCTDataTableCapable(&drive
)) {
2417 pout("Warning: device does not support SCT Data Table command\n");
2418 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2421 // Read SCT status and temperature history
2422 if (ataReadSCTTempHist(device
, &tmh
, &sts
)) {
2423 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2427 if (options
.sct_temp_sts
)
2428 ataPrintSCTStatus(&sts
);
2429 if (options
.sct_temp_hist
)
2430 ataPrintSCTTempHist(&tmh
);
2433 if (options
.sct_temp_int
) {
2434 // Set new temperature logging interval
2435 if (!isSCTFeatureControlCapable(&drive
)) {
2436 pout("Warning: device does not support SCT Feature Control command\n");
2437 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2440 if (ataSetSCTTempInterval(device
, options
.sct_temp_int
, options
.sct_temp_int_pers
)) {
2441 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2444 pout("Temperature Logging Interval set to %u minute%s (%s)\n",
2445 options
.sct_temp_int
, (options
.sct_temp_int
== 1 ? "" : "s"),
2446 (options
.sct_temp_int_pers
? "persistent" : "volatile"));
2452 // SCT Error Recovery Control
2453 if (sct_ok
&& (options
.sct_erc_get
|| options
.sct_erc_set
)) {
2454 if (!isSCTErrorRecoveryControlCapable(&drive
)) {
2455 pout("Warning: device does not support SCT Error Recovery Control command\n");
2456 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2459 bool sct_erc_get
= options
.sct_erc_get
;
2460 if (options
.sct_erc_set
) {
2461 // Set SCT Error Recovery Control
2462 if ( ataSetSCTErrorRecoveryControltime(device
, 1, options
.sct_erc_readtime
)
2463 || ataSetSCTErrorRecoveryControltime(device
, 2, options
.sct_erc_writetime
)) {
2464 pout("Warning: device does not support SCT (Set) Error Recovery Control command\n");
2465 if (!( (options
.sct_erc_readtime
== 70 && options
.sct_erc_writetime
== 70)
2466 || (options
.sct_erc_readtime
== 0 && options
.sct_erc_writetime
== 0)))
2467 pout("Retry with: 'scterc,70,70' to enable ERC or 'scterc,0,0' to disable\n");
2468 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2469 sct_erc_get
= false;
2471 else if (!sct_erc_get
)
2472 ataPrintSCTErrorRecoveryControl(true, options
.sct_erc_readtime
,
2473 options
.sct_erc_writetime
);
2477 // Print SCT Error Recovery Control
2478 unsigned short read_timer
, write_timer
;
2479 if ( ataGetSCTErrorRecoveryControltime(device
, 1, read_timer
)
2480 || ataGetSCTErrorRecoveryControltime(device
, 2, write_timer
)) {
2481 pout("Warning: device does not support SCT (Get) Error Recovery Control command\n");
2482 if (options
.sct_erc_set
) {
2483 pout("The previous SCT (Set) Error Recovery Control command succeeded\n");
2484 ataPrintSCTErrorRecoveryControl(true, options
.sct_erc_readtime
,
2485 options
.sct_erc_writetime
);
2487 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2490 ataPrintSCTErrorRecoveryControl(false, read_timer
, write_timer
);
2496 // Print SATA Phy Event Counters
2497 if (options
.sataphy
) {
2498 unsigned nsectors
= GetNumLogSectors(gplogdir
, 0x11, true);
2500 pout("SATA Phy Event Counters (GP Log 0x11) not supported\n");
2501 else if (nsectors
!= 1)
2502 pout("SATA Phy Event Counters with %u sectors not supported\n", nsectors
);
2504 unsigned char log_11
[512] = {0, };
2505 unsigned char features
= (options
.sataphy_reset
? 0x01 : 0x00);
2506 if (!ataReadLogExt(device
, 0x11, features
, 0, log_11
, 1))
2507 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2509 PrintSataPhyEventCounters(log_11
, options
.sataphy_reset
);
2513 // START OF THE TESTING SECTION OF THE CODE. IF NO TESTING, RETURN
2514 if (!smart_val_ok
|| options
.smart_selftest_type
== -1)
2517 pout("=== START OF OFFLINE IMMEDIATE AND SELF-TEST SECTION ===\n");
2518 // if doing a self-test, be sure it's supported by the hardware
2519 switch (options
.smart_selftest_type
) {
2520 case OFFLINE_FULL_SCAN
:
2521 if (!isSupportExecuteOfflineImmediate(&smartval
)){
2522 pout("Warning: device does not support Execute Offline Immediate function.\n\n");
2523 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2526 case ABORT_SELF_TEST
:
2527 case SHORT_SELF_TEST
:
2528 case EXTEND_SELF_TEST
:
2529 case SHORT_CAPTIVE_SELF_TEST
:
2530 case EXTEND_CAPTIVE_SELF_TEST
:
2531 if (!isSupportSelfTest(&smartval
)){
2532 pout("Warning: device does not support Self-Test functions.\n\n");
2533 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2536 case CONVEYANCE_SELF_TEST
:
2537 case CONVEYANCE_CAPTIVE_SELF_TEST
:
2538 if (!isSupportConveyanceSelfTest(&smartval
)){
2539 pout("Warning: device does not support Conveyance Self-Test functions.\n\n");
2540 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2543 case SELECTIVE_SELF_TEST
:
2544 case SELECTIVE_CAPTIVE_SELF_TEST
:
2545 if (!isSupportSelectiveSelfTest(&smartval
)){
2546 pout("Warning: device does not support Selective Self-Test functions.\n\n");
2547 failuretest(MANDATORY_CMD
, returnval
|=FAILSMART
);
2551 break; // Vendor specific type
2554 // Now do the test. Note ataSmartTest prints its own error/success
2556 if (ataSmartTest(device
, options
.smart_selftest_type
, options
.smart_selective_args
,
2557 &smartval
, sizes
.sectors
))
2558 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2560 // Tell user how long test will take to complete. This is tricky
2561 // because in the case of an Offline Full Scan, the completion
2562 // timer is volatile, and needs to be read AFTER the command is
2563 // given. If this will interrupt the Offline Full Scan, we don't
2564 // do it, just warn user.
2565 if (options
.smart_selftest_type
== OFFLINE_FULL_SCAN
) {
2566 if (isSupportOfflineAbort(&smartval
))
2567 pout("Note: giving further SMART commands will abort Offline testing\n");
2568 else if (ataReadSmartValues(device
, &smartval
)){
2569 pout("Smartctl: SMART Read Values failed.\n");
2570 failuretest(OPTIONAL_CMD
, returnval
|=FAILSMART
);
2574 // Now say how long the test will take to complete
2575 int timewait
= TestTime(&smartval
, options
.smart_selftest_type
);
2577 time_t t
=time(NULL
);
2578 if (options
.smart_selftest_type
== OFFLINE_FULL_SCAN
) {
2580 pout("Please wait %d seconds for test to complete.\n", (int)timewait
);
2583 pout("Please wait %d minutes for test to complete.\n", (int)timewait
);
2585 pout("Test will complete after %s\n", ctime(&t
));
2587 if ( options
.smart_selftest_type
!= SHORT_CAPTIVE_SELF_TEST
2588 && options
.smart_selftest_type
!= EXTEND_CAPTIVE_SELF_TEST
2589 && options
.smart_selftest_type
!= CONVEYANCE_CAPTIVE_SELF_TEST
2590 && options
.smart_selftest_type
!= SELECTIVE_CAPTIVE_SELF_TEST
)
2591 pout("Use smartctl -X to abort test.\n");