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-13 Christian Franke <smartmontools-support@lists.sourceforge.net>
8 * Copyright (C) 1999-2000 Michael Cornwell <cornwell@acm.org>
9 * Copyright (C) 2000 Andre Hedrick <andre@linux-ide.org>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2, or (at your option)
16 * You should have received a copy of the GNU General Public License
17 * (for example COPYING); If not, see <http://www.gnu.org/licenses/>.
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/
36 #include "dev_ata_cmd_set.h" // for parsed_ata_device
38 const char * atacmds_cpp_cvsid
= "$Id: atacmds.cpp 3777 2013-02-19 18:32:15Z samm2 $"
41 // Print ATA debug messages?
42 unsigned char ata_debugmode
= 0;
44 // Suppress serial number?
45 // (also used in scsiprint.cpp)
46 bool dont_print_serial_number
= false;
49 #define SMART_CYL_LOW 0x4F
50 #define SMART_CYL_HI 0xC2
52 // SMART RETURN STATUS yields SMART_CYL_HI,SMART_CYL_LOW to indicate drive
53 // is healthy and SRET_STATUS_HI_EXCEEDED,SRET_STATUS_MID_EXCEEDED to
54 // indicate that a threshhold exceeded condition has been detected.
55 // Those values (byte pairs) are placed in ATA register "LBA 23:8".
56 #define SRET_STATUS_HI_EXCEEDED 0x2C
57 #define SRET_STATUS_MID_EXCEEDED 0xF4
60 // Get ID and increase flag of current pending or offline
61 // uncorrectable attribute.
62 unsigned char get_unc_attr_id(bool offline
, const ata_vendor_attr_defs
& defs
,
65 unsigned char id
= (!offline
? 197 : 198);
66 const ata_vendor_attr_defs::entry
& def
= defs
[id
];
67 if (def
.flags
& ATTRFLAG_INCREASING
)
68 increase
= true; // '-v 19[78],increasing' option
69 else if (def
.name
.empty() || (id
== 198 && def
.name
== "Offline_Scan_UNC_SectCt"))
70 increase
= false; // no or '-v 198,offlinescanuncsectorct' option
72 id
= 0; // other '-v 19[78],...' option
76 #if 0 // TODO: never used
77 // This are the meanings of the Self-test failure checkpoint byte.
78 // This is in the self-test log at offset 4 bytes into the self-test
79 // descriptor and in the SMART READ DATA structure at byte offset
80 // 371. These codes are not well documented. The meanings returned by
81 // this routine are used (at least) by Maxtor and IBM. Returns NULL if
82 // not recognized. Currently the maximum length is 15 bytes.
83 const char *SelfTestFailureCodeName(unsigned char which
){
91 return "Servo_Random";
95 return "Handling_Damage";
105 // Table of raw print format names
106 struct format_name_entry
109 ata_attr_raw_format format
;
112 const format_name_entry format_names
[] = {
113 {"raw8" , RAWFMT_RAW8
},
114 {"raw16" , RAWFMT_RAW16
},
115 {"raw48" , RAWFMT_RAW48
},
116 {"hex48" , RAWFMT_HEX48
},
117 {"raw56" , RAWFMT_RAW56
},
118 {"hex56" , RAWFMT_HEX56
},
119 {"raw64" , RAWFMT_RAW64
},
120 {"hex64" , RAWFMT_HEX64
},
121 {"raw16(raw16)" , RAWFMT_RAW16_OPT_RAW16
},
122 {"raw16(avg16)" , RAWFMT_RAW16_OPT_AVG16
},
123 {"raw24(raw8)" , RAWFMT_RAW24_OPT_RAW8
},
124 {"raw24/raw24" , RAWFMT_RAW24_DIV_RAW24
},
125 {"raw24/raw32" , RAWFMT_RAW24_DIV_RAW32
},
126 {"sec2hour" , RAWFMT_SEC2HOUR
},
127 {"min2hour" , RAWFMT_MIN2HOUR
},
128 {"halfmin2hour" , RAWFMT_HALFMIN2HOUR
},
129 {"msec24hour32" , RAWFMT_MSEC24_HOUR32
},
130 {"tempminmax" , RAWFMT_TEMPMINMAX
},
131 {"temp10x" , RAWFMT_TEMP10X
},
134 const unsigned num_format_names
= sizeof(format_names
)/sizeof(format_names
[0]);
136 // Table to map old to new '-v' option arguments
137 const char * map_old_vendor_opts
[][2] = {
138 { "9,halfminutes" , "9,halfmin2hour,Power_On_Half_Minutes"},
139 { "9,minutes" , "9,min2hour,Power_On_Minutes"},
140 { "9,seconds" , "9,sec2hour,Power_On_Seconds"},
141 { "9,temp" , "9,tempminmax,Temperature_Celsius"},
142 {"192,emergencyretractcyclect" , "192,raw48,Emerg_Retract_Cycle_Ct"},
143 {"193,loadunload" , "193,raw24/raw24"},
144 {"194,10xCelsius" , "194,temp10x,Temperature_Celsius_x10"},
145 {"194,unknown" , "194,raw48,Unknown_Attribute"},
146 {"197,increasing" , "197,raw48+,Total_Pending_Sectors"}, // '+' sets flag
147 {"198,offlinescanuncsectorct" , "198,raw48,Offline_Scan_UNC_SectCt"}, // see also get_unc_attr_id() above
148 {"198,increasing" , "198,raw48+,Total_Offl_Uncorrectabl"}, // '+' sets flag
149 {"200,writeerrorcount" , "200,raw48,Write_Error_Count"},
150 {"201,detectedtacount" , "201,raw48,Detected_TA_Count"},
151 {"220,temp" , "220,tempminmax,Temperature_Celsius"},
154 const unsigned num_old_vendor_opts
= sizeof(map_old_vendor_opts
)/sizeof(map_old_vendor_opts
[0]);
156 // Parse vendor attribute display def (-v option).
157 // Return false on error.
158 bool parse_attribute_def(const char * opt
, ata_vendor_attr_defs
& defs
,
159 ata_vendor_def_prior priority
)
161 // Map old -> new options
163 for (i
= 0; i
< num_old_vendor_opts
; i
++) {
164 if (!strcmp(opt
, map_old_vendor_opts
[i
][0])) {
165 opt
= map_old_vendor_opts
[i
][1];
171 int len
= strlen(opt
);
172 int id
= 0, n1
= -1, n2
= -1;
173 char fmtname
[32+1], attrname
[32+1];
176 if (!( sscanf(opt
, "N,%32[^,]%n,%32[^,]%n", fmtname
, &n1
, attrname
, &n2
) >= 1
177 && (n1
== len
|| n2
== len
)))
181 // "id,format[+][,name]"
182 if (!( sscanf(opt
, "%d,%32[^,]%n,%32[^,]%n", &id
, fmtname
, &n1
, attrname
, &n2
) >= 2
183 && 1 <= id
&& id
<= 255 && (n1
== len
|| n2
== len
)))
190 // For "-v 19[78],increasing" above
191 if (fmtname
[strlen(fmtname
)-1] == '+') {
192 fmtname
[strlen(fmtname
)-1] = 0;
193 flags
= ATTRFLAG_INCREASING
;
196 // Split "format[:byteorder]"
197 char byteorder
[8+1] = "";
198 if (strchr(fmtname
, ':')) {
199 if (!( sscanf(fmtname
, "%*[^:]%n:%8[012345rvwz]%n", &n1
, byteorder
, &n2
) >= 1
200 && n2
== (int)strlen(fmtname
)))
203 if (strchr(byteorder
, 'v'))
204 flags
|= (ATTRFLAG_NO_NORMVAL
|ATTRFLAG_NO_WORSTVAL
);
205 if (strchr(byteorder
, 'w'))
206 flags
|= ATTRFLAG_NO_WORSTVAL
;
211 if (i
>= num_format_names
)
212 return false; // Not found
213 if (!strcmp(fmtname
, format_names
[i
].name
))
216 ata_attr_raw_format format
= format_names
[i
].format
;
218 // 64-bit formats use the normalized and worst value bytes.
219 if (!*byteorder
&& (format
== RAWFMT_RAW64
|| format
== RAWFMT_HEX64
))
220 flags
|= (ATTRFLAG_NO_NORMVAL
|ATTRFLAG_NO_WORSTVAL
);
223 // "N,format" -> set format for all entries
224 for (i
= 0; i
< MAX_ATTRIBUTE_NUM
; i
++) {
225 if (defs
[i
].priority
>= priority
)
228 defs
[i
].name
= attrname
;
229 defs
[i
].priority
= priority
;
230 defs
[i
].raw_format
= format
;
231 defs
[i
].flags
= flags
;
232 snprintf(defs
[i
].byteorder
, sizeof(defs
[i
].byteorder
), "%s", byteorder
);
235 else if (defs
[id
].priority
<= priority
) {
236 // "id,format[,name]"
238 defs
[id
].name
= attrname
;
239 defs
[id
].raw_format
= format
;
240 defs
[id
].priority
= priority
;
241 defs
[id
].flags
= flags
;
242 snprintf(defs
[id
].byteorder
, sizeof(defs
[id
].byteorder
), "%s", byteorder
);
249 // Return a multiline string containing a list of valid arguments for
250 // parse_attribute_def(). The strings are preceeded by tabs and followed
251 // (except for the last) by newlines.
252 std::string
create_vendor_attribute_arg_list()
256 for (i
= 0; i
< num_format_names
; i
++)
257 s
+= strprintf("%s\tN,%s[:012345rvwz][,ATTR_NAME]",
258 (i
>0 ? "\n" : ""), format_names
[i
].name
);
259 for (i
= 0; i
< num_old_vendor_opts
; i
++)
260 s
+= strprintf("\n\t%s", map_old_vendor_opts
[i
][0]);
265 // Parse firmwarebug def (-F option).
266 // Return false on error.
267 bool parse_firmwarebug_def(const char * opt
, firmwarebug_defs
& firmwarebugs
)
269 if (!strcmp(opt
, "none"))
270 firmwarebugs
.set(BUG_NONE
);
271 else if (!strcmp(opt
, "nologdir"))
272 firmwarebugs
.set(BUG_NOLOGDIR
);
273 else if (!strcmp(opt
, "samsung"))
274 firmwarebugs
.set(BUG_SAMSUNG
);
275 else if (!strcmp(opt
, "samsung2"))
276 firmwarebugs
.set(BUG_SAMSUNG2
);
277 else if (!strcmp(opt
, "samsung3"))
278 firmwarebugs
.set(BUG_SAMSUNG3
);
279 else if (!strcmp(opt
, "xerrorlba"))
280 firmwarebugs
.set(BUG_XERRORLBA
);
286 // Return a string of valid argument words for parse_firmwarebug_def()
287 const char * get_valid_firmwarebug_args()
289 return "none, nologdir, samsung, samsung2, samsung3, xerrorlba";
293 // swap two bytes. Point to low address
294 void swap2(char *location
){
296 *location
=*(location
+1);
301 // swap four bytes. Point to low address
302 void swap4(char *location
){
304 *location
=*(location
+3);
310 // swap eight bytes. Points to low address
311 void swap8(char *location
){
313 *location
=*(location
+7);
316 *(location
+1)=*(location
+6);
322 // Invalidate serial number and WWN and adjust checksum in IDENTIFY data
323 static void invalidate_serno(ata_identify_device
* id
)
325 unsigned char sum
= 0;
327 for (i
= 0; i
< sizeof(id
->serial_no
); i
++) {
328 sum
+= id
->serial_no
[i
]; sum
-= id
->serial_no
[i
] = 'X';
330 unsigned char * b
= (unsigned char *)id
;
331 for (i
= 2*108; i
< 2*112; i
++) { // words108-111: WWN
332 sum
+= b
[i
]; sum
-= b
[i
] = 0x00;
336 bool must_swap
= !!isbigendian();
338 swapx(id
->words088_255
+255-88);
340 if ((id
->words088_255
[255-88] & 0x00ff) == 0x00a5)
341 id
->words088_255
[255-88] += sum
<< 8;
344 swapx(id
->words088_255
+255-88);
348 static const char * const commandstrings
[]={
351 "SMART AUTOMATIC ATTRIBUTE SAVE",
352 "SMART IMMEDIATE OFFLINE",
353 "SMART AUTO OFFLINE",
355 "SMART STATUS CHECK",
356 "SMART READ ATTRIBUTE VALUES",
357 "SMART READ ATTRIBUTE THRESHOLDS",
360 "IDENTIFY PACKET DEVICE",
363 "WARNING (UNDEFINED COMMAND -- CONTACT DEVELOPERS AT " PACKAGE_BUGREPORT
")\n"
367 static const char * preg(const ata_register
& r
, char (& buf
)[8])
372 snprintf(buf
, sizeof(buf
), "0x%02x", r
.val());
376 static void print_regs(const char * prefix
, const ata_in_regs
& r
, const char * suffix
= "\n")
379 pout("%s FR=%s, SC=%s, LL=%s, LM=%s, LH=%s, DEV=%s, CMD=%s%s", prefix
,
380 preg(r
.features
, bufs
[0]), preg(r
.sector_count
, bufs
[1]), preg(r
.lba_low
, bufs
[2]),
381 preg(r
.lba_mid
, bufs
[3]), preg(r
.lba_high
, bufs
[4]), preg(r
.device
, bufs
[5]),
382 preg(r
.command
, bufs
[6]), suffix
);
385 static void print_regs(const char * prefix
, const ata_out_regs
& r
, const char * suffix
= "\n")
388 pout("%sERR=%s, SC=%s, LL=%s, LM=%s, LH=%s, DEV=%s, STS=%s%s", prefix
,
389 preg(r
.error
, bufs
[0]), preg(r
.sector_count
, bufs
[1]), preg(r
.lba_low
, bufs
[2]),
390 preg(r
.lba_mid
, bufs
[3]), preg(r
.lba_high
, bufs
[4]), preg(r
.device
, bufs
[5]),
391 preg(r
.status
, bufs
[6]), suffix
);
394 static void prettyprint(const unsigned char *p
, const char *name
){
395 pout("\n===== [%s] DATA START (BASE-16) =====\n", name
);
396 for (int i
=0; i
<512; i
+=16, p
+=16)
397 #define P(n) (' ' <= p[n] && p[n] <= '~' ? (int)p[n] : '.')
398 // print complete line to avoid slow tty output and extra lines in syslog.
399 pout("%03d-%03d: %02x %02x %02x %02x %02x %02x %02x %02x "
400 "%02x %02x %02x %02x %02x %02x %02x %02x"
401 " |%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c|"
404 p
[ 0], p
[ 1], p
[ 2], p
[ 3], p
[ 4], p
[ 5], p
[ 6], p
[ 7],
405 p
[ 8], p
[ 9], p
[10], p
[11], p
[12], p
[13], p
[14], p
[15],
406 P( 0), P( 1), P( 2), P( 3), P( 4), P( 5), P( 6), P( 7),
407 P( 8), P( 9), P(10), P(11), P(12), P(13), P(14), P(15),
410 pout("===== [%s] DATA END (512 Bytes) =====\n\n", name
);
413 // This function provides the pretty-print reporting for SMART
414 // commands: it implements the various -r "reporting" options for ATA
416 int smartcommandhandler(ata_device
* device
, smart_command_set command
, int select
, char *data
){
417 // TODO: Rework old stuff below
418 // This conditional is true for commands that return data
419 int getsdata
=(command
==PIDENTIFY
||
422 command
==READ_THRESHOLDS
||
423 command
==READ_VALUES
||
424 command
==CHECK_POWER_MODE
);
426 int sendsdata
=(command
==WRITE_LOG
);
428 // If reporting is enabled, say what the command will be before it's executed
430 // conditional is true for commands that use parameters
431 int usesparam
=(command
==READ_LOG
||
432 command
==AUTO_OFFLINE
||
434 command
==IMMEDIATE_OFFLINE
||
437 pout("\nREPORT-IOCTL: Device=%s Command=%s", device
->get_dev_name(), commandstrings
[command
]);
439 pout(" InputParameter=%d\n", select
);
444 if ((getsdata
|| sendsdata
) && !data
){
445 pout("REPORT-IOCTL: Unable to execute command %s : data destination address is NULL\n", commandstrings
[command
]);
449 // The reporting is cleaner, and we will find coding bugs faster, if
450 // the commands that failed clearly return empty (zeroed) data
453 if (command
==CHECK_POWER_MODE
)
456 memset(data
, '\0', 512);
460 // if requested, pretty-print the input data structure
461 if (ata_debugmode
> 1 && sendsdata
)
462 //pout("REPORT-IOCTL: Device=%s Command=%s\n", device->get_dev_name(), commandstrings[command]);
463 prettyprint((unsigned char *)data
, commandstrings
[command
]);
465 // now execute the command
469 // Set common register values
471 default: // SMART commands
472 in
.in_regs
.command
= ATA_SMART_CMD
;
473 in
.in_regs
.lba_high
= SMART_CYL_HI
; in
.in_regs
.lba_mid
= SMART_CYL_LOW
;
475 case IDENTIFY
: case PIDENTIFY
: case CHECK_POWER_MODE
: // Non SMART commands
478 // Set specific values
481 in
.in_regs
.command
= ATA_IDENTIFY_DEVICE
;
482 in
.set_data_in(data
, 1);
485 in
.in_regs
.command
= ATA_IDENTIFY_PACKET_DEVICE
;
486 in
.set_data_in(data
, 1);
488 case CHECK_POWER_MODE
:
489 in
.in_regs
.command
= ATA_CHECK_POWER_MODE
;
490 in
.out_needed
.sector_count
= true; // Powermode returned here
493 in
.in_regs
.features
= ATA_SMART_READ_VALUES
;
494 in
.set_data_in(data
, 1);
496 case READ_THRESHOLDS
:
497 in
.in_regs
.features
= ATA_SMART_READ_THRESHOLDS
;
498 in
.in_regs
.lba_low
= 1; // TODO: CORRECT ???
499 in
.set_data_in(data
, 1);
502 in
.in_regs
.features
= ATA_SMART_READ_LOG_SECTOR
;
503 in
.in_regs
.lba_low
= select
;
504 in
.set_data_in(data
, 1);
507 in
.in_regs
.features
= ATA_SMART_WRITE_LOG_SECTOR
;
508 in
.in_regs
.lba_low
= select
;
509 in
.set_data_out(data
, 1);
512 in
.in_regs
.features
= ATA_SMART_ENABLE
;
513 in
.in_regs
.lba_low
= 1; // TODO: CORRECT ???
516 in
.in_regs
.features
= ATA_SMART_DISABLE
;
517 in
.in_regs
.lba_low
= 1; // TODO: CORRECT ???
520 in
.out_needed
.lba_high
= in
.out_needed
.lba_mid
= true; // Status returned here
522 in
.in_regs
.features
= ATA_SMART_STATUS
;
525 in
.in_regs
.features
= ATA_SMART_AUTO_OFFLINE
;
526 in
.in_regs
.sector_count
= select
; // Caution: Non-DATA command!
529 in
.in_regs
.features
= ATA_SMART_AUTOSAVE
;
530 in
.in_regs
.sector_count
= select
; // Caution: Non-DATA command!
532 case IMMEDIATE_OFFLINE
:
533 in
.in_regs
.features
= ATA_SMART_IMMEDIATE_OFFLINE
;
534 in
.in_regs
.lba_low
= select
;
537 pout("Unrecognized command %d in smartcommandhandler()\n"
538 "Please contact " PACKAGE_BUGREPORT
"\n", command
);
539 device
->set_err(ENOSYS
);
544 print_regs(" Input: ", in
.in_regs
,
545 (in
.direction
==ata_cmd_in::data_in
? " IN\n":
546 in
.direction
==ata_cmd_in::data_out
? " OUT\n":"\n"));
550 int64_t start_usec
= -1;
552 start_usec
= smi()->get_timer_usec();
554 bool ok
= device
->ata_pass_through(in
, out
);
556 if (start_usec
>= 0) {
557 int64_t duration_usec
= smi()->get_timer_usec() - start_usec
;
558 if (duration_usec
>= 500)
559 pout(" [Duration: %.3fs]\n", duration_usec
/ 1000000.0);
562 if (ata_debugmode
&& out
.out_regs
.is_set())
563 print_regs(" Output: ", out
.out_regs
);
565 if (ok
) switch (command
) {
569 case CHECK_POWER_MODE
:
570 if (out
.out_regs
.sector_count
.is_set()) {
571 data
[0] = out
.out_regs
.sector_count
;
575 pout("CHECK POWER MODE: incomplete response, ATA output registers missing\n");
576 device
->set_err(ENOSYS
);
581 // Cyl low and Cyl high unchanged means "Good SMART status"
582 if ((out
.out_regs
.lba_high
== SMART_CYL_HI
) &&
583 (out
.out_regs
.lba_mid
== SMART_CYL_LOW
))
585 // These values mean "Bad SMART status"
586 else if ((out
.out_regs
.lba_high
== SRET_STATUS_HI_EXCEEDED
) &&
587 (out
.out_regs
.lba_mid
== SRET_STATUS_MID_EXCEEDED
))
589 else if (out
.out_regs
.lba_mid
== SMART_CYL_LOW
) {
592 pout("SMART STATUS RETURN: half healthy response sequence, "
593 "probable SAT/USB truncation\n");
594 } else if (out
.out_regs
.lba_mid
== SRET_STATUS_MID_EXCEEDED
) {
597 pout("SMART STATUS RETURN: half unhealthy response sequence, "
598 "probable SAT/USB truncation\n");
600 else if (!out
.out_regs
.is_set()) {
601 pout("SMART STATUS RETURN: incomplete response, ATA output registers missing\n");
602 device
->set_err(ENOSYS
);
606 // We haven't gotten output that makes sense; print out some debugging info
607 pout("SMART Status command failed\n");
608 pout("Please get assistance from %s\n", PACKAGE_HOMEPAGE
);
609 pout("Register values returned from SMART Status command are:\n");
610 print_regs(" ", out
.out_regs
);
611 device
->set_err(EIO
);
618 // If requested, invalidate serial number before any printing is done
619 if ((command
== IDENTIFY
|| command
== PIDENTIFY
) && !retval
&& dont_print_serial_number
)
620 invalidate_serno((ata_identify_device
*)data
);
622 // If reporting is enabled, say what output was produced by the command
624 if (device
->get_errno())
625 pout("REPORT-IOCTL: Device=%s Command=%s returned %d errno=%d [%s]\n",
626 device
->get_dev_name(), commandstrings
[command
], retval
,
627 device
->get_errno(), device
->get_errmsg());
629 pout("REPORT-IOCTL: Device=%s Command=%s returned %d\n",
630 device
->get_dev_name(), commandstrings
[command
], retval
);
632 // if requested, pretty-print the output data structure
633 if (ata_debugmode
> 1 && getsdata
) {
634 if (command
==CHECK_POWER_MODE
)
635 pout("Sector Count Register (BASE-16): %02x\n", (unsigned char)(*data
));
637 prettyprint((unsigned char *)data
, commandstrings
[command
]);
644 // Get capacity and sector sizes from IDENTIFY data
645 void ata_get_size_info(const ata_identify_device
* id
, ata_size_info
& sizes
)
647 sizes
.sectors
= sizes
.capacity
= 0;
648 sizes
.log_sector_size
= sizes
.phy_sector_size
= 0;
649 sizes
.log_sector_offset
= 0;
651 // Return if no LBA support
652 if (!(id
->words047_079
[49-47] & 0x0200))
655 // Determine 28-bit LBA capacity
656 unsigned lba28
= (unsigned)id
->words047_079
[61-47] << 16
657 | (unsigned)id
->words047_079
[60-47] ;
659 // Determine 48-bit LBA capacity if supported
661 if ((id
->command_set_2
& 0xc400) == 0x4400)
662 lba48
= (uint64_t)id
->words088_255
[103-88] << 48
663 | (uint64_t)id
->words088_255
[102-88] << 32
664 | (uint64_t)id
->words088_255
[101-88] << 16
665 | (uint64_t)id
->words088_255
[100-88] ;
667 // Return if capacity unknown (ATAPI CD/DVD)
668 if (!(lba28
|| lba48
))
671 // Determine sector sizes
672 sizes
.log_sector_size
= sizes
.phy_sector_size
= 512;
674 unsigned short word106
= id
->words088_255
[106-88];
675 if ((word106
& 0xc000) == 0x4000) {
676 // Long Logical/Physical Sectors (LLS/LPS) ?
677 if (word106
& 0x1000)
678 // Logical sector size is specified in 16-bit words
679 sizes
.log_sector_size
= sizes
.phy_sector_size
=
680 ((id
->words088_255
[118-88] << 16) | id
->words088_255
[117-88]) << 1;
682 if (word106
& 0x2000)
683 // Physical sector size is multiple of logical sector size
684 sizes
.phy_sector_size
<<= (word106
& 0x0f);
686 unsigned short word209
= id
->words088_255
[209-88];
687 if ((word209
& 0xc000) == 0x4000)
688 sizes
.log_sector_offset
= (word209
& 0x3fff) * sizes
.log_sector_size
;
691 // Some early 4KiB LLS disks (Samsung N3U-3) return bogus lba28 value
692 if (lba48
>= lba28
|| (lba48
&& sizes
.log_sector_size
> 512))
693 sizes
.sectors
= lba48
;
695 sizes
.sectors
= lba28
;
697 sizes
.capacity
= sizes
.sectors
* sizes
.log_sector_size
;
700 // This function computes the checksum of a single disk sector (512
701 // bytes). Returns zero if checksum is OK, nonzero if the checksum is
702 // incorrect. The size (512) is correct for all SMART structures.
703 unsigned char checksum(const void * data
)
705 unsigned char sum
= 0;
706 for (int i
= 0; i
< 512; i
++)
707 sum
+= ((const unsigned char *)data
)[i
];
711 // Copies n bytes (or n-1 if n is odd) from in to out, but swaps adjacents
713 static void swapbytes(char * out
, const char * in
, size_t n
)
715 for (size_t i
= 0; i
< n
; i
+= 2) {
721 // Copies in to out, but removes leading and trailing whitespace.
722 static void trim(char * out
, const char * in
)
724 // Find the first non-space character (maybe none).
727 for (i
= 0; in
[i
]; i
++)
728 if (!isspace((int)in
[i
])) {
734 // There are no non-space characters.
739 // Find the last non-space character.
740 for (i
= strlen(in
)-1; i
>= first
&& isspace((int)in
[i
]); i
--)
744 strncpy(out
, in
+first
, last
-first
+1);
745 out
[last
-first
+1] = '\0';
748 // Convenience function for formatting strings from ata_identify_device
749 void ata_format_id_string(char * out
, const unsigned char * in
, int n
)
751 bool must_swap
= true;
753 /* NetBSD kernel delivers IDENTIFY data in host byte order (but all else is LE) */
754 // TODO: Handle NetBSD case in os_netbsd.cpp
756 must_swap
= !must_swap
;
762 strncpy(tmp
, (const char *)in
, n
);
764 swapbytes(tmp
, (const char *)in
, n
);
769 // returns -1 if command fails or the device is in Sleep mode, else
770 // value of Sector Count register. Sector Count result values:
771 // 00h device is in Standby mode.
772 // 80h device is in Idle mode.
773 // FFh device is in Active mode or Idle mode.
775 int ataCheckPowerMode(ata_device
* device
) {
776 unsigned char result
;
778 if ((smartcommandhandler(device
, CHECK_POWER_MODE
, 0, (char *)&result
)))
781 if (result
!=0 && result
!=0x80 && result
!=0xff)
782 pout("ataCheckPowerMode(): ATA CHECK POWER MODE returned unknown Sector Count Register value %02x\n", result
);
787 // Issue a no-data ATA command with optional sector count register value
788 bool ata_nodata_command(ata_device
* device
, unsigned char command
,
789 int sector_count
/* = -1 */)
792 in
.in_regs
.command
= command
;
793 if (sector_count
>= 0)
794 in
.in_regs
.sector_count
= sector_count
;
796 return device
->ata_pass_through(in
);
799 // Issue SET FEATURES command with optional sector count register value
800 bool ata_set_features(ata_device
* device
, unsigned char features
,
801 int sector_count
/* = -1 */)
804 in
.in_regs
.command
= ATA_SET_FEATURES
;
805 in
.in_regs
.features
= features
;
806 if (sector_count
>= 0)
807 in
.in_regs
.sector_count
= sector_count
;
809 return device
->ata_pass_through(in
);
812 // Reads current Device Identity info (512 bytes) into buf. Returns 0
813 // if all OK. Returns -1 if no ATA Device identity can be
814 // established. Returns >0 if Device is ATA Packet Device (not SMART
815 // capable). The value of the integer helps identify the type of
816 // Packet device, which is useful so that the user can connect the
817 // formal device number with whatever object is inside their computer.
818 int ata_read_identity(ata_device
* device
, ata_identify_device
* buf
, bool fix_swapped_id
,
819 unsigned char * raw_buf
/* = 0 */)
821 unsigned short *rawshort
=(unsigned short *)buf
;
822 unsigned char *rawbyte
=(unsigned char *)buf
;
824 // See if device responds either to IDENTIFY DEVICE or IDENTIFY
827 if ((smartcommandhandler(device
, IDENTIFY
, 0, (char *)buf
))){
828 if (smartcommandhandler(device
, PIDENTIFY
, 0, (char *)buf
)){
835 if (fix_swapped_id
) {
837 for (i
= 0; i
< sizeof(buf
->serial_no
)-1; i
+= 2)
838 swap2((char *)(buf
->serial_no
+i
));
839 for (i
= 0; i
< sizeof(buf
->fw_rev
)-1; i
+= 2)
840 swap2((char *)(buf
->fw_rev
+i
));
841 for (i
= 0; i
< sizeof(buf
->model
)-1; i
+= 2)
842 swap2((char *)(buf
->model
+i
));
845 // If requested, save raw data before endianness adjustments
847 memcpy(raw_buf
, buf
, sizeof(*buf
));
850 // if machine is big-endian, swap byte order as needed
851 // NetBSD kernel delivers IDENTIFY data in host byte order
852 // TODO: Handle NetBSD case in os_netbsd.cpp
855 // swap various capability words that are needed
857 swap2((char *)(buf
->words047_079
+i
));
859 for (i
=80; i
<=87; i
++)
860 swap2((char *)(rawshort
+i
));
862 for (i
=0; i
<168; i
++)
863 swap2((char *)(buf
->words088_255
+i
));
867 // If there is a checksum there, validate it
868 if ((rawshort
[255] & 0x00ff) == 0x00a5 && checksum(rawbyte
))
869 checksumwarning("Drive Identity Structure");
871 // AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
872 // T13/1699-D Revision 6a (Final Draft), September 6, 2008.
873 // Sections 7.16.7 and 7.17.6:
875 // Word 0 of IDENTIFY DEVICE data:
876 // Bit 15 = 0 : ATA device
878 // Word 0 of IDENTIFY PACKET DEVICE data:
879 // Bits 15:14 = 10b : ATAPI device
880 // Bits 15:14 = 11b : Reserved
881 // Bits 12:8 : Device type (SPC-4, e.g 0x05 = CD/DVD)
883 // CF+ and CompactFlash Specification Revision 4.0, May 24, 2006.
886 // Word 0 of IDENTIFY DEVICE data:
887 // 848Ah = Signature for CompactFlash Storage Card
888 // 044Ah = Alternate value turns on ATA device while preserving all retired bits
889 // 0040h = Alternate value turns on ATA device while zeroing all retired bits
891 // Assume ATA if IDENTIFY DEVICE returns CompactFlash Signature
892 if (!packet
&& rawbyte
[1] == 0x84 && rawbyte
[0] == 0x8a)
895 // If this is a PACKET DEVICE, return device type
896 if (rawbyte
[1] & 0x80)
897 return 1+(rawbyte
[1] & 0x1f);
899 // Not a PACKET DEVICE
903 // Get World Wide Name (WWN) fields.
904 // Return NAA field or -1 if WWN is unsupported.
905 // Table 34 of T13/1699-D Revision 6a (ATA8-ACS), September 6, 2008.
906 // (WWN was introduced in ATA/ATAPI-7 and is mandatory since ATA8-ACS Revision 3b)
907 int ata_get_wwn(const ata_identify_device
* id
, unsigned & oui
, uint64_t & unique_id
)
909 // Don't use word 84 to be compatible with some older ATA-7 disks
910 unsigned short word087
= id
->csf_default
;
911 if ((word087
& 0xc100) != 0x4100)
912 return -1; // word not valid or WWN support bit 8 not set
914 unsigned short word108
= id
->words088_255
[108-88];
915 unsigned short word109
= id
->words088_255
[109-88];
916 unsigned short word110
= id
->words088_255
[110-88];
917 unsigned short word111
= id
->words088_255
[111-88];
919 oui
= ((word108
& 0x0fff) << 12) | (word109
>> 4);
920 unique_id
= ((uint64_t)(word109
& 0xf) << 32)
921 | (unsigned)((word110
<< 16) | word111
);
922 return (word108
>> 12);
925 // Get nominal media rotation rate.
926 // Returns: 0 = not reported, 1 = SSD, >1 = HDD rpm, < 0 = -(Unknown value)
927 int ata_get_rotation_rate(const ata_identify_device
* id
)
929 // Table 37 of T13/1699-D (ATA8-ACS) Revision 6a, September 6, 2008
930 // Table A.31 of T13/2161-D (ACS-3) Revision 3b, August 25, 2012
931 unsigned short word217
= id
->words088_255
[217-88];
932 if (word217
== 0x0000 || word217
== 0xffff)
934 else if (word217
== 0x0001)
936 else if (word217
> 0x0400)
939 return -(int)word217
;
942 // returns 1 if SMART supported, 0 if SMART unsupported, -1 if can't tell
943 int ataSmartSupport(const ata_identify_device
* drive
)
945 unsigned short word82
=drive
->command_set_1
;
946 unsigned short word83
=drive
->command_set_2
;
948 // check if words 82/83 contain valid info
949 if ((word83
>>14) == 0x01)
950 // return value of SMART support bit
951 return word82
& 0x0001;
953 // since we can're rely on word 82, we don't know if SMART supported
957 // returns 1 if SMART enabled, 0 if SMART disabled, -1 if can't tell
958 int ataIsSmartEnabled(const ata_identify_device
* drive
)
960 unsigned short word85
=drive
->cfs_enable_1
;
961 unsigned short word87
=drive
->csf_default
;
963 // check if words 85/86/87 contain valid info
964 if ((word87
>>14) == 0x01)
965 // return value of SMART enabled bit
966 return word85
& 0x0001;
968 // Since we can't rely word85, we don't know if SMART is enabled.
973 // Reads SMART attributes into *data
974 int ataReadSmartValues(ata_device
* device
, struct ata_smart_values
*data
){
976 if (smartcommandhandler(device
, READ_VALUES
, 0, (char *)data
)){
982 checksumwarning("SMART Attribute Data Structure");
984 // swap endian order if needed
987 swap2((char *)&(data
->revnumber
));
988 swap2((char *)&(data
->total_time_to_complete_off_line
));
989 swap2((char *)&(data
->smart_capability
));
990 swapx(&data
->extend_test_completion_time_w
);
991 for (i
=0; i
<NUMBER_ATA_SMART_ATTRIBUTES
; i
++){
992 struct ata_smart_attribute
*x
=data
->vendor_attributes
+i
;
993 swap2((char *)&(x
->flags
));
1001 // This corrects some quantities that are byte reversed in the SMART
1003 static void fixsamsungselftestlog(ata_smart_selftestlog
* data
)
1005 // bytes 508/509 (numbered from 0) swapped (swap of self-test index
1006 // with one byte of reserved.
1007 swap2((char *)&(data
->mostrecenttest
));
1009 // LBA low register (here called 'selftestnumber", containing
1010 // information about the TYPE of the self-test) is byte swapped with
1011 // Self-test execution status byte. These are bytes N, N+1 in the
1013 for (int i
= 0; i
< 21; i
++)
1014 swap2((char *)&(data
->selftest_struct
[i
].selftestnumber
));
1019 // Reads the Self Test Log (log #6)
1020 int ataReadSelfTestLog (ata_device
* device
, ata_smart_selftestlog
* data
,
1021 firmwarebug_defs firmwarebugs
)
1024 // get data from device
1025 if (smartcommandhandler(device
, READ_LOG
, 0x06, (char *)data
)){
1029 // compute its checksum, and issue a warning if needed
1031 checksumwarning("SMART Self-Test Log Structure");
1033 // fix firmware bugs in self-test log
1034 if (firmwarebugs
.is_set(BUG_SAMSUNG
))
1035 fixsamsungselftestlog(data
);
1037 // swap endian order if needed
1040 swap2((char*)&(data
->revnumber
));
1041 for (i
=0; i
<21; i
++){
1042 struct ata_smart_selftestlog_struct
*x
=data
->selftest_struct
+i
;
1043 swap2((char *)&(x
->timestamp
));
1044 swap4((char *)&(x
->lbafirstfailure
));
1051 // Print checksum warning for multi sector log
1052 static void check_multi_sector_sum(const void * data
, unsigned nsectors
, const char * msg
)
1055 for (unsigned i
= 0; i
< nsectors
; i
++) {
1056 if (checksum((const unsigned char *)data
+ i
*512))
1061 checksumwarning(msg
);
1063 checksumwarning(strprintf("%s (%u/%u)", msg
, errs
, nsectors
).c_str());
1067 // Read SMART Extended Self-test Log
1068 bool ataReadExtSelfTestLog(ata_device
* device
, ata_smart_extselftestlog
* log
,
1071 if (!ataReadLogExt(device
, 0x07, 0x00, 0, log
, nsectors
))
1074 check_multi_sector_sum(log
, nsectors
, "SMART Extended Self-test Log Structure");
1076 if (isbigendian()) {
1077 swapx(&log
->log_desc_index
);
1078 for (unsigned i
= 0; i
< nsectors
; i
++) {
1079 for (unsigned j
= 0; j
< 19; j
++)
1080 swapx(&log
->log_descs
[i
].timestamp
);
1087 // Read GP Log page(s)
1088 bool ataReadLogExt(ata_device
* device
, unsigned char logaddr
,
1089 unsigned char features
, unsigned page
,
1090 void * data
, unsigned nsectors
)
1093 in
.in_regs
.command
= ATA_READ_LOG_EXT
;
1094 in
.in_regs
.features
= features
; // log specific
1095 in
.set_data_in_48bit(data
, nsectors
);
1096 in
.in_regs
.lba_low
= logaddr
;
1097 in
.in_regs
.lba_mid_16
= page
;
1099 if (!device
->ata_pass_through(in
)) { // TODO: Debug output
1100 if (nsectors
<= 1) {
1101 pout("ATA_READ_LOG_EXT (addr=0x%02x:0x%02x, page=%u, n=%u) failed: %s\n",
1102 logaddr
, features
, page
, nsectors
, device
->get_errmsg());
1106 // Recurse to retry with single sectors,
1107 // multi-sector reads may not be supported by ioctl.
1108 for (unsigned i
= 0; i
< nsectors
; i
++) {
1109 if (!ataReadLogExt(device
, logaddr
,
1111 (char *)data
+ 512*i
, 1))
1119 // Read SMART Log page(s)
1120 bool ataReadSmartLog(ata_device
* device
, unsigned char logaddr
,
1121 void * data
, unsigned nsectors
)
1124 in
.in_regs
.command
= ATA_SMART_CMD
;
1125 in
.in_regs
.features
= ATA_SMART_READ_LOG_SECTOR
;
1126 in
.set_data_in(data
, nsectors
);
1127 in
.in_regs
.lba_high
= SMART_CYL_HI
;
1128 in
.in_regs
.lba_mid
= SMART_CYL_LOW
;
1129 in
.in_regs
.lba_low
= logaddr
;
1131 if (!device
->ata_pass_through(in
)) { // TODO: Debug output
1132 pout("ATA_SMART_READ_LOG failed: %s\n", device
->get_errmsg());
1140 // Reads the SMART or GPL Log Directory (log #0)
1141 int ataReadLogDirectory(ata_device
* device
, ata_smart_log_directory
* data
, bool gpl
)
1143 if (!gpl
) { // SMART Log directory
1144 if (smartcommandhandler(device
, READ_LOG
, 0x00, (char *)data
))
1147 else { // GP Log directory
1148 if (!ataReadLogExt(device
, 0x00, 0x00, 0, data
, 1))
1152 // swap endian order if needed
1154 swapx(&data
->logversion
);
1160 // Reads the selective self-test log (log #9)
1161 int ataReadSelectiveSelfTestLog(ata_device
* device
, struct ata_selective_self_test_log
*data
){
1163 // get data from device
1164 if (smartcommandhandler(device
, READ_LOG
, 0x09, (char *)data
)){
1168 // compute its checksum, and issue a warning if needed
1170 checksumwarning("SMART Selective Self-Test Log Structure");
1172 // swap endian order if needed
1175 swap2((char *)&(data
->logversion
));
1177 swap8((char *)&(data
->span
[i
].start
));
1178 swap8((char *)&(data
->span
[i
].end
));
1180 swap8((char *)&(data
->currentlba
));
1181 swap2((char *)&(data
->currentspan
));
1182 swap2((char *)&(data
->flags
));
1183 swap2((char *)&(data
->pendingtime
));
1189 // Writes the selective self-test log (log #9)
1190 int ataWriteSelectiveSelfTestLog(ata_device
* device
, ata_selective_selftest_args
& args
,
1191 const ata_smart_values
* sv
, uint64_t num_sectors
,
1192 const ata_selective_selftest_args
* prev_args
)
1194 // Disk size must be known
1196 pout("Disk size is unknown, unable to check selective self-test spans\n");
1201 struct ata_selective_self_test_log sstlog
, *data
=&sstlog
;
1202 unsigned char *ptr
=(unsigned char *)data
;
1203 if (ataReadSelectiveSelfTestLog(device
, data
)) {
1204 pout("SMART Read Selective Self-test Log failed: %s\n", device
->get_errmsg());
1205 pout("Since Read failed, will not attempt to WRITE Selective Self-test Log\n");
1210 data
->logversion
= 1;
1212 // Host is NOT allowed to write selective self-test log if a selective
1213 // self-test is in progress.
1214 if (0<data
->currentspan
&& data
->currentspan
<6 && ((sv
->self_test_exec_status
)>>4)==15) {
1215 pout("SMART Selective or other Self-test in progress\n");
1219 // Set start/end values based on old spans for special -t select,... options
1221 for (i
= 0; i
< args
.num_spans
; i
++) {
1222 int mode
= args
.span
[i
].mode
;
1223 uint64_t start
= args
.span
[i
].start
;
1224 uint64_t end
= args
.span
[i
].end
;
1225 if (mode
== SEL_CONT
) {// redo or next dependig on last test status
1226 switch (sv
->self_test_exec_status
>> 4) {
1227 case 1: case 2: // Aborted/Interrupted by host
1228 pout("Continue Selective Self-Test: Redo last span\n");
1231 default: // All others
1232 pout("Continue Selective Self-Test: Start next span\n");
1238 if ( (mode
== SEL_REDO
|| mode
== SEL_NEXT
)
1239 && prev_args
&& i
< prev_args
->num_spans
1240 && !data
->span
[i
].start
&& !data
->span
[i
].end
) {
1241 // Some drives do not preserve the selective self-test log accross
1242 // power-cyles. If old span on drive is cleared use span provided
1243 // by caller. This is used by smartd (first span only).
1244 data
->span
[i
].start
= prev_args
->span
[i
].start
;
1245 data
->span
[i
].end
= prev_args
->span
[i
].end
;
1249 case SEL_RANGE
: // -t select,START-END
1251 case SEL_REDO
: // -t select,redo... => Redo current
1252 start
= data
->span
[i
].start
;
1253 if (end
> 0) { // -t select,redo+SIZE
1254 end
--; end
+= start
; // [oldstart, oldstart+SIZE)
1256 else // -t select,redo
1257 end
= data
->span
[i
].end
; // [oldstart, oldend]
1259 case SEL_NEXT
: // -t select,next... => Do next
1260 if (data
->span
[i
].end
== 0) {
1261 start
= end
= 0; break; // skip empty spans
1263 start
= data
->span
[i
].end
+ 1;
1264 if (start
>= num_sectors
)
1265 start
= 0; // wrap around
1266 if (end
> 0) { // -t select,next+SIZE
1267 end
--; end
+= start
; // (oldend, oldend+SIZE]
1269 else { // -t select,next
1270 uint64_t oldsize
= data
->span
[i
].end
- data
->span
[i
].start
+ 1;
1271 end
= start
+ oldsize
- 1; // (oldend, oldend+oldsize]
1272 if (end
>= num_sectors
) {
1273 // Adjust size to allow round-robin testing without future size decrease
1274 uint64_t spans
= (num_sectors
+ oldsize
-1) / oldsize
;
1275 uint64_t newsize
= (num_sectors
+ spans
-1) / spans
;
1276 uint64_t newstart
= num_sectors
- newsize
, newend
= num_sectors
- 1;
1277 pout("Span %d changed from %"PRIu64
"-%"PRIu64
" (%"PRIu64
" sectors)\n",
1278 i
, start
, end
, oldsize
);
1279 pout(" to %"PRIu64
"-%"PRIu64
" (%"PRIu64
" sectors) (%"PRIu64
" spans)\n",
1280 newstart
, newend
, newsize
, spans
);
1281 start
= newstart
; end
= newend
;
1286 pout("ataWriteSelectiveSelfTestLog: Invalid mode %d\n", mode
);
1290 if (start
< num_sectors
&& num_sectors
<= end
) {
1291 if (end
!= ~(uint64_t)0) // -t select,N-max
1292 pout("Size of self-test span %d decreased according to disk size\n", i
);
1293 end
= num_sectors
- 1;
1295 if (!(start
<= end
&& end
< num_sectors
)) {
1296 pout("Invalid selective self-test span %d: %"PRIu64
"-%"PRIu64
" (%"PRIu64
" sectors)\n",
1297 i
, start
, end
, num_sectors
);
1300 // Return the actual mode and range to caller.
1301 args
.span
[i
].mode
= mode
;
1302 args
.span
[i
].start
= start
;
1303 args
.span
[i
].end
= end
;
1308 memset(data
->span
+i
, 0, sizeof(struct test_span
));
1310 // Set spans for testing
1311 for (i
= 0; i
< args
.num_spans
; i
++){
1312 data
->span
[i
].start
= args
.span
[i
].start
;
1313 data
->span
[i
].end
= args
.span
[i
].end
;
1316 // host must initialize to zero before initiating selective self-test
1318 data
->currentspan
=0;
1320 // Perform off-line scan after selective test?
1321 if (args
.scan_after_select
== 1)
1323 data
->flags
&= ~SELECTIVE_FLAG_DOSCAN
;
1324 else if (args
.scan_after_select
== 2)
1326 data
->flags
|= SELECTIVE_FLAG_DOSCAN
;
1328 // Must clear active and pending flags before writing
1329 data
->flags
&= ~(SELECTIVE_FLAG_ACTIVE
);
1330 data
->flags
&= ~(SELECTIVE_FLAG_PENDING
);
1332 // modify pending time?
1333 if (args
.pending_time
)
1334 data
->pendingtime
= (unsigned short)(args
.pending_time
-1);
1336 // Set checksum to zero, then compute checksum
1338 unsigned char cksum
=0;
1339 for (i
=0; i
<512; i
++)
1343 data
->checksum
=cksum
;
1345 // swap endian order if needed
1347 swap2((char *)&(data
->logversion
));
1348 for (int b
= 0; b
< 5; b
++) {
1349 swap8((char *)&(data
->span
[b
].start
));
1350 swap8((char *)&(data
->span
[b
].end
));
1352 swap8((char *)&(data
->currentlba
));
1353 swap2((char *)&(data
->currentspan
));
1354 swap2((char *)&(data
->flags
));
1355 swap2((char *)&(data
->pendingtime
));
1358 // write new selective self-test log
1359 if (smartcommandhandler(device
, WRITE_LOG
, 0x09, (char *)data
)){
1360 pout("Write Selective Self-test Log failed: %s\n", device
->get_errmsg());
1367 // This corrects some quantities that are byte reversed in the SMART
1369 static void fixsamsungerrorlog(ata_smart_errorlog
* data
)
1371 // FIXED IN SAMSUNG -25 FIRMWARE???
1372 // Device error count in bytes 452-3
1373 swap2((char *)&(data
->ata_error_count
));
1375 // FIXED IN SAMSUNG -22a FIRMWARE
1376 // step through 5 error log data structures
1377 for (int i
= 0; i
< 5; i
++){
1378 // step through 5 command data structures
1379 for (int j
= 0; j
< 5; j
++)
1380 // Command data structure 4-byte millisec timestamp. These are
1381 // bytes (N+8, N+9, N+10, N+11).
1382 swap4((char *)&(data
->errorlog_struct
[i
].commands
[j
].timestamp
));
1383 // Error data structure two-byte hour life timestamp. These are
1384 // bytes (N+28, N+29).
1385 swap2((char *)&(data
->errorlog_struct
[i
].error_struct
.timestamp
));
1390 // NEEDED ONLY FOR SAMSUNG -22 (some) -23 AND -24?? FIRMWARE
1391 static void fixsamsungerrorlog2(ata_smart_errorlog
* data
)
1393 // Device error count in bytes 452-3
1394 swap2((char *)&(data
->ata_error_count
));
1398 // Reads the Summary SMART Error Log (log #1). The Comprehensive SMART
1399 // Error Log is #2, and the Extended Comprehensive SMART Error log is
1401 int ataReadErrorLog (ata_device
* device
, ata_smart_errorlog
*data
,
1402 firmwarebug_defs firmwarebugs
)
1405 // get data from device
1406 if (smartcommandhandler(device
, READ_LOG
, 0x01, (char *)data
)){
1410 // compute its checksum, and issue a warning if needed
1412 checksumwarning("SMART ATA Error Log Structure");
1414 // Some disks have the byte order reversed in some SMART Summary
1415 // Error log entries
1416 if (firmwarebugs
.is_set(BUG_SAMSUNG
))
1417 fixsamsungerrorlog(data
);
1418 else if (firmwarebugs
.is_set(BUG_SAMSUNG2
))
1419 fixsamsungerrorlog2(data
);
1421 // swap endian order if needed
1425 // Device error count in bytes 452-3
1426 swap2((char *)&(data
->ata_error_count
));
1428 // step through 5 error log data structures
1429 for (i
=0; i
<5; i
++){
1430 // step through 5 command data structures
1432 // Command data structure 4-byte millisec timestamp
1433 swap4((char *)&(data
->errorlog_struct
[i
].commands
[j
].timestamp
));
1434 // Error data structure life timestamp
1435 swap2((char *)&(data
->errorlog_struct
[i
].error_struct
.timestamp
));
1443 // Fix LBA byte ordering of Extended Comprehensive Error Log
1444 // if little endian instead of ATA register ordering is provided
1446 static inline void fix_exterrlog_lba_cmd(T
& cmd
)
1449 cmd
.lba_mid_register_hi
= org
.lba_high_register
;
1450 cmd
.lba_low_register_hi
= org
.lba_mid_register_hi
;
1451 cmd
.lba_high_register
= org
.lba_mid_register
;
1452 cmd
.lba_mid_register
= org
.lba_low_register_hi
;
1455 static void fix_exterrlog_lba(ata_smart_exterrlog
* log
, unsigned nsectors
)
1457 for (unsigned i
= 0; i
< nsectors
; i
++) {
1458 for (int ei
= 0; ei
< 4; ei
++) {
1459 ata_smart_exterrlog_error_log
& entry
= log
[i
].error_logs
[ei
];
1460 fix_exterrlog_lba_cmd(entry
.error
);
1461 for (int ci
= 0; ci
< 5; ci
++)
1462 fix_exterrlog_lba_cmd(entry
.commands
[ci
]);
1467 // Read Extended Comprehensive Error Log
1468 bool ataReadExtErrorLog(ata_device
* device
, ata_smart_exterrlog
* log
,
1469 unsigned nsectors
, firmwarebug_defs firmwarebugs
)
1471 if (!ataReadLogExt(device
, 0x03, 0x00, 0, log
, nsectors
))
1474 check_multi_sector_sum(log
, nsectors
, "SMART Extended Comprehensive Error Log Structure");
1476 if (isbigendian()) {
1477 swapx(&log
->device_error_count
);
1478 swapx(&log
->error_log_index
);
1480 for (unsigned i
= 0; i
< nsectors
; i
++) {
1481 for (unsigned j
= 0; j
< 4; j
++)
1482 swapx(&log
->error_logs
[i
].commands
[j
].timestamp
);
1483 swapx(&log
->error_logs
[i
].error
.timestamp
);
1487 if (firmwarebugs
.is_set(BUG_XERRORLBA
))
1488 fix_exterrlog_lba(log
, nsectors
);
1494 int ataReadSmartThresholds (ata_device
* device
, struct ata_smart_thresholds_pvt
*data
){
1496 // get data from device
1497 if (smartcommandhandler(device
, READ_THRESHOLDS
, 0, (char *)data
)){
1501 // compute its checksum, and issue a warning if needed
1503 checksumwarning("SMART Attribute Thresholds Structure");
1505 // swap endian order if needed
1507 swap2((char *)&(data
->revnumber
));
1512 int ataEnableSmart (ata_device
* device
){
1513 if (smartcommandhandler(device
, ENABLE
, 0, NULL
)){
1519 int ataDisableSmart (ata_device
* device
){
1521 if (smartcommandhandler(device
, DISABLE
, 0, NULL
)){
1527 int ataEnableAutoSave(ata_device
* device
){
1528 if (smartcommandhandler(device
, AUTOSAVE
, 241, NULL
)){
1534 int ataDisableAutoSave(ata_device
* device
){
1536 if (smartcommandhandler(device
, AUTOSAVE
, 0, NULL
)){
1542 // In *ALL* ATA standards the Enable/Disable AutoOffline command is
1543 // marked "OBSOLETE". It is defined in SFF-8035i Revision 2, and most
1544 // vendors still support it for backwards compatibility. IBM documents
1545 // it for some drives.
1546 int ataEnableAutoOffline (ata_device
* device
){
1548 /* timer hard coded to 4 hours */
1549 if (smartcommandhandler(device
, AUTO_OFFLINE
, 248, NULL
)){
1555 // Another Obsolete Command. See comments directly above, associated
1556 // with the corresponding Enable command.
1557 int ataDisableAutoOffline (ata_device
* device
){
1559 if (smartcommandhandler(device
, AUTO_OFFLINE
, 0, NULL
)){
1565 // If SMART is enabled, supported, and working, then this call is
1566 // guaranteed to return 1, else zero. Note that it should return 1
1567 // regardless of whether the disk's SMART status is 'healthy' or
1569 int ataDoesSmartWork(ata_device
* device
){
1570 int retval
=smartcommandhandler(device
, STATUS
, 0, NULL
);
1578 // This function uses a different interface (DRIVE_TASK) than the
1579 // other commands in this file.
1580 int ataSmartStatus2(ata_device
* device
){
1581 return smartcommandhandler(device
, STATUS_CHECK
, 0, NULL
);
1584 // This is the way to execute ALL tests: offline, short self-test,
1585 // extended self test, with and without captive mode, etc.
1586 // TODO: Move to ataprint.cpp ?
1587 int ataSmartTest(ata_device
* device
, int testtype
, bool force
,
1588 const ata_selective_selftest_args
& selargs
,
1589 const ata_smart_values
* sv
, uint64_t num_sectors
)
1591 char cmdmsg
[128]; const char *type
, *captive
;
1592 int cap
, retval
, select
=0;
1594 // Boolean, if set, says test is captive
1595 cap
=testtype
& CAPTIVE_MASK
;
1597 // Set up strings that describe the type of test
1603 if (testtype
==OFFLINE_FULL_SCAN
)
1605 else if (testtype
==SHORT_SELF_TEST
|| testtype
==SHORT_CAPTIVE_SELF_TEST
)
1606 type
="Short self-test";
1607 else if (testtype
==EXTEND_SELF_TEST
|| testtype
==EXTEND_CAPTIVE_SELF_TEST
)
1608 type
="Extended self-test";
1609 else if (testtype
==CONVEYANCE_SELF_TEST
|| testtype
==CONVEYANCE_CAPTIVE_SELF_TEST
)
1610 type
="Conveyance self-test";
1611 else if ((select
=(testtype
==SELECTIVE_SELF_TEST
|| testtype
==SELECTIVE_CAPTIVE_SELF_TEST
)))
1612 type
="Selective self-test";
1616 // Check whether another test is already running
1617 if (type
&& (sv
->self_test_exec_status
>> 4) == 0xf) {
1619 pout("Can't start self-test without aborting current test (%d0%% remaining),\n"
1620 "%srun 'smartctl -X' to abort test.\n",
1621 sv
->self_test_exec_status
& 0x0f,
1622 (!select
? "add '-t force' option to override, or " : ""));
1629 // If doing a selective self-test, first use WRITE_LOG to write the
1630 // selective self-test log.
1631 ata_selective_selftest_args selargs_io
= selargs
; // filled with info about actual spans
1632 if (select
&& (retval
= ataWriteSelectiveSelfTestLog(device
, selargs_io
, sv
, num_sectors
))) {
1634 pout("Can't start selective self-test without aborting current test: use '-X' option to smartctl.\n");
1638 // Print ouf message that we are sending the command to test
1639 if (testtype
==ABORT_SELF_TEST
)
1640 snprintf(cmdmsg
, sizeof(cmdmsg
), "Abort SMART off-line mode self-test routine");
1642 snprintf(cmdmsg
, sizeof(cmdmsg
), "SMART EXECUTE OFF-LINE IMMEDIATE subcommand 0x%02x", testtype
);
1644 snprintf(cmdmsg
, sizeof(cmdmsg
), "Execute SMART %s routine immediately in %s mode", type
, captive
);
1645 pout("Sending command: \"%s\".\n",cmdmsg
);
1649 pout("SPAN STARTING_LBA ENDING_LBA\n");
1650 for (i
= 0; i
< selargs_io
.num_spans
; i
++)
1651 pout(" %d %20"PRId64
" %20"PRId64
"\n", i
,
1652 selargs_io
.span
[i
].start
,
1653 selargs_io
.span
[i
].end
);
1656 // Now send the command to test
1657 if (smartcommandhandler(device
, IMMEDIATE_OFFLINE
, testtype
, NULL
)) {
1658 if (!(cap
&& device
->get_errno() == EIO
)) {
1659 pout("Command \"%s\" failed: %s\n", cmdmsg
, device
->get_errmsg());
1664 // Since the command succeeded, tell user
1665 if (testtype
==ABORT_SELF_TEST
)
1666 pout("Self-testing aborted!\n");
1668 pout("Drive command \"%s\" successful.\n", cmdmsg
);
1670 pout("Testing has begun%s.\n", (force
? " (previous test aborted)" : ""));
1675 /* Test Time Functions */
1676 int TestTime(const ata_smart_values
*data
, int testtype
)
1679 case OFFLINE_FULL_SCAN
:
1680 return (int) data
->total_time_to_complete_off_line
;
1681 case SHORT_SELF_TEST
:
1682 case SHORT_CAPTIVE_SELF_TEST
:
1683 return (int) data
->short_test_completion_time
;
1684 case EXTEND_SELF_TEST
:
1685 case EXTEND_CAPTIVE_SELF_TEST
:
1686 if (data
->extend_test_completion_time_b
== 0xff
1687 && data
->extend_test_completion_time_w
!= 0x0000
1688 && data
->extend_test_completion_time_w
!= 0xffff)
1689 return data
->extend_test_completion_time_w
; // ATA-8
1691 return data
->extend_test_completion_time_b
;
1692 case CONVEYANCE_SELF_TEST
:
1693 case CONVEYANCE_CAPTIVE_SELF_TEST
:
1694 return (int) data
->conveyance_test_completion_time
;
1700 // This function tells you both about the ATA error log and the
1701 // self-test error log capability (introduced in ATA-5). The bit is
1702 // poorly documented in the ATA/ATAPI standard. Starting with ATA-6,
1703 // SMART error logging is also indicated in bit 0 of DEVICE IDENTIFY
1704 // word 84 and 87. Top two bits must match the pattern 01. BEFORE
1705 // ATA-6 these top two bits still had to match the pattern 01, but the
1706 // remaining bits were reserved (==0).
1707 int isSmartErrorLogCapable (const ata_smart_values
* data
, const ata_identify_device
* identity
)
1709 unsigned short word84
=identity
->command_set_extension
;
1710 unsigned short word87
=identity
->csf_default
;
1711 int isata6
=identity
->major_rev_num
& (0x01<<6);
1712 int isata7
=identity
->major_rev_num
& (0x01<<7);
1714 if ((isata6
|| isata7
) && (word84
>>14) == 0x01 && (word84
& 0x01))
1717 if ((isata6
|| isata7
) && (word87
>>14) == 0x01 && (word87
& 0x01))
1720 // otherwise we'll use the poorly documented capability bit
1721 return data
->errorlog_capability
& 0x01;
1724 // See previous function. If the error log exists then the self-test
1725 // log should (must?) also exist.
1726 int isSmartTestLogCapable (const ata_smart_values
* data
, const ata_identify_device
*identity
)
1728 unsigned short word84
=identity
->command_set_extension
;
1729 unsigned short word87
=identity
->csf_default
;
1730 int isata6
=identity
->major_rev_num
& (0x01<<6);
1731 int isata7
=identity
->major_rev_num
& (0x01<<7);
1733 if ((isata6
|| isata7
) && (word84
>>14) == 0x01 && (word84
& 0x02))
1736 if ((isata6
|| isata7
) && (word87
>>14) == 0x01 && (word87
& 0x02))
1740 // otherwise we'll use the poorly documented capability bit
1741 return data
->errorlog_capability
& 0x01;
1745 int isGeneralPurposeLoggingCapable(const ata_identify_device
*identity
)
1747 unsigned short word84
=identity
->command_set_extension
;
1748 unsigned short word87
=identity
->csf_default
;
1750 // If bit 14 of word 84 is set to one and bit 15 of word 84 is
1751 // cleared to zero, the contents of word 84 contains valid support
1752 // information. If not, support information is not valid in this
1754 if ((word84
>>14) == 0x01)
1755 // If bit 5 of word 84 is set to one, the device supports the
1756 // General Purpose Logging feature set.
1757 return (word84
& (0x01 << 5));
1759 // If bit 14 of word 87 is set to one and bit 15 of word 87 is
1760 // cleared to zero, the contents of words (87:85) contain valid
1761 // information. If not, information is not valid in these words.
1762 if ((word87
>>14) == 0x01)
1763 // If bit 5 of word 87 is set to one, the device supports
1764 // the General Purpose Logging feature set.
1765 return (word87
& (0x01 << 5));
1772 // SMART self-test capability is also indicated in bit 1 of DEVICE
1773 // IDENTIFY word 87 (if top two bits of word 87 match pattern 01).
1774 // However this was only introduced in ATA-6 (but self-test log was in
1776 int isSupportExecuteOfflineImmediate(const ata_smart_values
*data
)
1778 return data
->offline_data_collection_capability
& 0x01;
1781 // Note in the ATA-5 standard, the following bit is listed as "Vendor
1782 // Specific". So it may not be reliable. The only use of this that I
1783 // have found is in IBM drives, where it is well-documented. See for
1784 // example page 170, section 13.32.1.18 of the IBM Travelstar 40GNX
1785 // hard disk drive specifications page 164 Revision 1.1 22 Apr 2002.
1786 int isSupportAutomaticTimer(const ata_smart_values
* data
)
1788 return data
->offline_data_collection_capability
& 0x02;
1790 int isSupportOfflineAbort(const ata_smart_values
*data
)
1792 return data
->offline_data_collection_capability
& 0x04;
1794 int isSupportOfflineSurfaceScan(const ata_smart_values
* data
)
1796 return data
->offline_data_collection_capability
& 0x08;
1798 int isSupportSelfTest (const ata_smart_values
* data
)
1800 return data
->offline_data_collection_capability
& 0x10;
1802 int isSupportConveyanceSelfTest(const ata_smart_values
* data
)
1804 return data
->offline_data_collection_capability
& 0x20;
1806 int isSupportSelectiveSelfTest(const ata_smart_values
* data
)
1808 return data
->offline_data_collection_capability
& 0x40;
1811 // Get attribute state
1812 ata_attr_state
ata_get_attr_state(const ata_smart_attribute
& attr
,
1814 const ata_smart_threshold_entry
* thresholds
,
1815 const ata_vendor_attr_defs
& defs
,
1816 unsigned char * threshval
/* = 0 */)
1819 return ATTRSTATE_NON_EXISTING
;
1821 // Normalized values (current,worst,threshold) not valid
1822 // if specified by '-v' option.
1823 // (Some SSD disks uses these bytes to store raw value).
1824 if (defs
[attr
.id
].flags
& ATTRFLAG_NO_NORMVAL
)
1825 return ATTRSTATE_NO_NORMVAL
;
1827 // Normally threshold is at same index as attribute
1829 if (thresholds
[i
].id
!= attr
.id
) {
1830 // Find threshold id in table
1831 for (i
= 0; thresholds
[i
].id
!= attr
.id
; ) {
1832 if (++i
>= NUMBER_ATA_SMART_ATTRIBUTES
)
1833 // Threshold id missing or thresholds cannot be read
1834 return ATTRSTATE_NO_THRESHOLD
;
1837 unsigned char threshold
= thresholds
[i
].threshold
;
1839 // Return threshold if requested
1841 *threshval
= threshold
;
1843 // Don't report a failed attribute if its threshold is 0.
1844 // ATA-3 (X3T13/2008D Revision 7b) declares 0x00 as the "always passing"
1845 // threshold (Later ATA versions declare all thresholds as "obsolete").
1846 // In practice, threshold value 0 is often used for usage attributes.
1848 return ATTRSTATE_OK
;
1850 // Failed now if current value is below threshold
1851 if (attr
.current
<= threshold
)
1852 return ATTRSTATE_FAILED_NOW
;
1854 // Failed in the past if worst value is below threshold
1855 if (!(defs
[attr
.id
].flags
& ATTRFLAG_NO_WORSTVAL
) && attr
.worst
<= threshold
)
1856 return ATTRSTATE_FAILED_PAST
;
1858 return ATTRSTATE_OK
;
1861 // Get default raw value print format
1862 static ata_attr_raw_format
get_default_raw_format(unsigned char id
)
1865 case 3: // Spin-up time
1866 return RAWFMT_RAW16_OPT_AVG16
;
1868 case 5: // Reallocated sector count
1869 case 196: // Reallocated event count
1870 return RAWFMT_RAW16_OPT_RAW16
;
1872 case 9: // Power on hours
1873 return RAWFMT_RAW24_OPT_RAW8
;
1875 case 190: // Temperature
1877 return RAWFMT_TEMPMINMAX
;
1880 return RAWFMT_RAW48
;
1884 // Get attribute raw value.
1885 uint64_t ata_get_attr_raw_value(const ata_smart_attribute
& attr
,
1886 const ata_vendor_attr_defs
& defs
)
1888 const ata_vendor_attr_defs::entry
& def
= defs
[attr
.id
];
1890 // Use default byteorder if not specified
1891 const char * byteorder
= def
.byteorder
;
1893 switch (def
.raw_format
) {
1896 byteorder
= "543210wv"; break;
1899 case RAWFMT_RAW24_DIV_RAW32
:
1900 case RAWFMT_MSEC24_HOUR32
:
1901 byteorder
= "r543210"; break;
1903 byteorder
= "543210"; break;
1907 // Build 64-bit value from selected bytes
1908 uint64_t rawvalue
= 0;
1909 for (int i
= 0; byteorder
[i
]; i
++) {
1911 switch (byteorder
[i
]) {
1912 case '0': b
= attr
.raw
[0]; break;
1913 case '1': b
= attr
.raw
[1]; break;
1914 case '2': b
= attr
.raw
[2]; break;
1915 case '3': b
= attr
.raw
[3]; break;
1916 case '4': b
= attr
.raw
[4]; break;
1917 case '5': b
= attr
.raw
[5]; break;
1918 case 'r': b
= attr
.reserv
; break;
1919 case 'v': b
= attr
.current
; break;
1920 case 'w': b
= attr
.worst
; break;
1921 default : b
= 0; break;
1923 rawvalue
<<= 8; rawvalue
|= b
;
1930 // Format attribute raw value.
1931 std::string
ata_format_attr_raw_value(const ata_smart_attribute
& attr
,
1932 const ata_vendor_attr_defs
& defs
)
1934 // Get 48 bit or 64 bit raw value
1935 uint64_t rawvalue
= ata_get_attr_raw_value(attr
, defs
);
1937 // Split into bytes and words
1938 unsigned char raw
[6];
1939 raw
[0] = (unsigned char) rawvalue
;
1940 raw
[1] = (unsigned char)(rawvalue
>> 8);
1941 raw
[2] = (unsigned char)(rawvalue
>> 16);
1942 raw
[3] = (unsigned char)(rawvalue
>> 24);
1943 raw
[4] = (unsigned char)(rawvalue
>> 32);
1944 raw
[5] = (unsigned char)(rawvalue
>> 40);
1946 word
[0] = raw
[0] | (raw
[1] << 8);
1947 word
[1] = raw
[2] | (raw
[3] << 8);
1948 word
[2] = raw
[4] | (raw
[5] << 8);
1951 ata_attr_raw_format format
= defs
[attr
.id
].raw_format
;
1952 if (format
== RAWFMT_DEFAULT
)
1953 format
= get_default_raw_format(attr
.id
);
1959 s
= strprintf("%d %d %d %d %d %d",
1960 raw
[5], raw
[4], raw
[3], raw
[2], raw
[1], raw
[0]);
1964 s
= strprintf("%u %u %u", word
[2], word
[1], word
[0]);
1970 s
= strprintf("%"PRIu64
, rawvalue
);
1974 s
= strprintf("0x%012"PRIx64
, rawvalue
);
1978 s
= strprintf("0x%014"PRIx64
, rawvalue
);
1982 s
= strprintf("0x%016"PRIx64
, rawvalue
);
1985 case RAWFMT_RAW16_OPT_RAW16
:
1986 s
= strprintf("%u", word
[0]);
1987 if (word
[1] || word
[2])
1988 s
+= strprintf(" (%u %u)", word
[2], word
[1]);
1991 case RAWFMT_RAW16_OPT_AVG16
:
1992 s
= strprintf("%u", word
[0]);
1994 s
+= strprintf(" (Average %u)", word
[1]);
1997 case RAWFMT_RAW24_OPT_RAW8
:
1998 s
= strprintf("%u", (unsigned)(rawvalue
& 0x00ffffffULL
));
1999 if (raw
[3] || raw
[4] || raw
[5])
2000 s
+= strprintf(" (%d %d %d)", raw
[5], raw
[4], raw
[3]);
2003 case RAWFMT_RAW24_DIV_RAW24
:
2004 s
= strprintf("%u/%u",
2005 (unsigned)(rawvalue
>> 24), (unsigned)(rawvalue
& 0x00ffffffULL
));
2008 case RAWFMT_RAW24_DIV_RAW32
:
2009 s
= strprintf("%u/%u",
2010 (unsigned)(rawvalue
>> 32), (unsigned)(rawvalue
& 0xffffffffULL
));
2013 case RAWFMT_MIN2HOUR
:
2016 int64_t temp
= word
[0]+(word
[1]<<16);
2017 int64_t tmp1
= temp
/60;
2018 int64_t tmp2
= temp
%60;
2019 s
= strprintf("%"PRIu64
"h+%02"PRIu64
"m", tmp1
, tmp2
);
2021 s
+= strprintf(" (%u)", word
[2]);
2025 case RAWFMT_SEC2HOUR
:
2028 int64_t hours
= rawvalue
/3600;
2029 int64_t minutes
= (rawvalue
-3600*hours
)/60;
2030 int64_t seconds
= rawvalue
%60;
2031 s
= strprintf("%"PRIu64
"h+%02"PRIu64
"m+%02"PRIu64
"s", hours
, minutes
, seconds
);
2035 case RAWFMT_HALFMIN2HOUR
:
2037 // 30-second counter
2038 int64_t hours
= rawvalue
/120;
2039 int64_t minutes
= (rawvalue
-120*hours
)/2;
2040 s
+= strprintf("%"PRIu64
"h+%02"PRIu64
"m", hours
, minutes
);
2044 case RAWFMT_MSEC24_HOUR32
:
2046 // hours + milliseconds
2047 unsigned hours
= (unsigned)(rawvalue
& 0xffffffffULL
);
2048 unsigned milliseconds
= (unsigned)(rawvalue
>> 32);
2049 unsigned seconds
= milliseconds
/ 1000;
2050 s
= strprintf("%uh+%02um+%02u.%03us",
2051 hours
, seconds
/ 60, seconds
% 60, milliseconds
% 1000);
2055 case RAWFMT_TEMPMINMAX
:
2058 // Search for possible min/max values
2059 // 00 HH 00 LL 00 TT (Hitachi/IBM)
2060 // 00 00 HH LL 00 TT (Maxtor, Samsung)
2061 // 00 00 00 HH LL TT (WDC)
2062 unsigned char lo
= 0, hi
= 0;
2064 for (int i
= 1; i
< 6; i
++) {
2072 hi
= lo
; lo
= raw
[i
];
2080 unsigned char t
= raw
[0];
2082 s
= strprintf("%d", t
);
2083 else if (cnt
== 2 && 0 < lo
&& lo
<= t
&& t
<= hi
&& hi
< 128)
2084 s
= strprintf("%d (Min/Max %d/%d)", t
, lo
, hi
);
2086 s
= strprintf("%d (%d %d %d %d %d)", t
, raw
[5], raw
[4], raw
[3], raw
[2], raw
[1]);
2090 case RAWFMT_TEMP10X
:
2091 // ten times temperature in Celsius
2092 s
= strprintf("%d.%d", word
[0]/10, word
[0]%10);
2096 s
= "?"; // Should not happen
2103 // Attribute names shouldn't be longer than 23 chars, otherwise they break the
2104 // output of smartctl.
2105 static const char * get_default_attr_name(unsigned char id
, int rpm
)
2107 bool hdd
= (rpm
> 1), ssd
= (rpm
== 1);
2109 static const char Unknown_HDD_Attribute
[] = "Unknown_HDD_Attribute";
2110 static const char Unknown_SSD_Attribute
[] = "Unknown_SSD_Attribute";
2114 return "Raw_Read_Error_Rate";
2116 return "Throughput_Performance";
2118 return "Spin_Up_Time";
2120 return "Start_Stop_Count";
2122 return "Reallocated_Sector_Ct";
2124 if (ssd
) return Unknown_SSD_Attribute
;
2125 return "Read_Channel_Margin";
2127 if (ssd
) return Unknown_SSD_Attribute
;
2128 return "Seek_Error_Rate";
2130 if (ssd
) return Unknown_SSD_Attribute
;
2131 return "Seek_Time_Performance";
2133 return "Power_On_Hours";
2135 if (ssd
) return Unknown_SSD_Attribute
;
2136 return "Spin_Retry_Count";
2138 if (ssd
) return Unknown_SSD_Attribute
;
2139 return "Calibration_Retry_Count";
2141 return "Power_Cycle_Count";
2143 return "Read_Soft_Error_Rate";
2145 if (hdd
) return Unknown_HDD_Attribute
;
2146 return "Program_Fail_Count_Chip";
2148 if (hdd
) return Unknown_HDD_Attribute
;
2149 return "Erase_Fail_Count_Chip";
2151 if (hdd
) return Unknown_HDD_Attribute
;
2152 return "Wear_Leveling_Count";
2154 if (hdd
) return Unknown_HDD_Attribute
;
2155 return "Used_Rsvd_Blk_Cnt_Chip";
2157 if (hdd
) return Unknown_HDD_Attribute
;
2158 return "Used_Rsvd_Blk_Cnt_Tot";
2160 if (hdd
) return Unknown_HDD_Attribute
;
2161 return "Unused_Rsvd_Blk_Cnt_Tot";
2163 return "Program_Fail_Cnt_Total";
2165 if (hdd
) return Unknown_HDD_Attribute
;
2166 return "Erase_Fail_Count_Total";
2168 return "Runtime_Bad_Block";
2170 return "End-to-End_Error";
2172 return "Reported_Uncorrect";
2174 return "Command_Timeout";
2176 if (ssd
) return Unknown_SSD_Attribute
;
2177 return "High_Fly_Writes";
2179 // Western Digital uses this for temperature.
2180 // It's identical to Attribute 194 except that it
2181 // has a failure threshold set to correspond to the
2182 // max allowed operating temperature of the drive, which
2183 // is typically 55C. So if this attribute has failed
2184 // in the past, it indicates that the drive temp exceeded
2185 // 55C sometime in the past.
2186 return "Airflow_Temperature_Cel";
2188 if (ssd
) return Unknown_SSD_Attribute
;
2189 return "G-Sense_Error_Rate";
2191 return "Power-Off_Retract_Count";
2193 if (ssd
) return Unknown_SSD_Attribute
;
2194 return "Load_Cycle_Count";
2196 return "Temperature_Celsius";
2198 // Fujitsu: "ECC_On_The_Fly_Count";
2199 return "Hardware_ECC_Recovered";
2201 return "Reallocated_Event_Count";
2203 return "Current_Pending_Sector";
2205 return "Offline_Uncorrectable";
2207 return "UDMA_CRC_Error_Count";
2209 if (ssd
) return Unknown_SSD_Attribute
;
2211 return "Multi_Zone_Error_Rate";
2213 if (ssd
) return Unknown_SSD_Attribute
;
2214 return "Soft_Read_Error_Rate";
2216 if (ssd
) return Unknown_SSD_Attribute
;
2217 // Fujitsu: "TA_Increase_Count"
2218 return "Data_Address_Mark_Errs";
2221 return "Run_Out_Cancel";
2222 // Maxtor: ECC Errors
2224 // Fujitsu: "Shock_Count_Write_Opern"
2225 return "Soft_ECC_Correction";
2227 // Fujitsu: "Shock_Rate_Write_Opern"
2228 return "Thermal_Asperity_Rate";
2231 if (ssd
) return Unknown_SSD_Attribute
;
2232 return "Flying_Height";
2235 if (ssd
) return Unknown_SSD_Attribute
;
2236 return "Spin_High_Current";
2239 if (ssd
) return Unknown_SSD_Attribute
;
2243 if (ssd
) return Unknown_SSD_Attribute
;
2244 return "Offline_Seek_Performnce";
2246 if (ssd
) return Unknown_SSD_Attribute
;
2247 return "Disk_Shift";
2249 if (ssd
) return Unknown_SSD_Attribute
;
2250 return "G-Sense_Error_Rate";
2252 if (ssd
) return Unknown_SSD_Attribute
;
2253 return "Loaded_Hours";
2255 if (ssd
) return Unknown_SSD_Attribute
;
2256 return "Load_Retry_Count";
2258 if (ssd
) return Unknown_SSD_Attribute
;
2259 return "Load_Friction";
2261 if (ssd
) return Unknown_SSD_Attribute
;
2262 return "Load_Cycle_Count";
2264 if (ssd
) return Unknown_SSD_Attribute
;
2265 return "Load-in_Time";
2267 if (ssd
) return Unknown_SSD_Attribute
;
2268 return "Torq-amp_Count";
2270 return "Power-off_Retract_Count";
2272 // seen in IBM DTPA-353750
2273 if (ssd
) return Unknown_SSD_Attribute
;
2274 return "Head_Amplitude";
2276 return "Temperature_Celsius";
2278 // seen in Intel X25-E SSD
2279 return "Available_Reservd_Space";
2281 // seen in Intel X25-E SSD
2282 if (hdd
) return Unknown_HDD_Attribute
;
2283 return "Media_Wearout_Indicator";
2285 if (ssd
) return Unknown_SSD_Attribute
;
2286 return "Head_Flying_Hours";
2288 return "Total_LBAs_Written";
2290 return "Total_LBAs_Read";
2292 return "Read_Error_Retry_Rate";
2294 if (ssd
) return Unknown_SSD_Attribute
;
2295 return "Free_Fall_Sensor";
2297 return "Unknown_Attribute";
2301 // Get attribute name
2302 std::string
ata_get_smart_attr_name(unsigned char id
, const ata_vendor_attr_defs
& defs
,
2305 if (!defs
[id
].name
.empty())
2306 return defs
[id
].name
;
2308 return get_default_attr_name(id
, rpm
);
2311 // Find attribute index for attribute id, -1 if not found.
2312 int ata_find_attr_index(unsigned char id
, const ata_smart_values
& smartval
)
2316 for (int i
= 0; i
< NUMBER_ATA_SMART_ATTRIBUTES
; i
++) {
2317 if (smartval
.vendor_attributes
[i
].id
== id
)
2323 // Return Temperature Attribute raw value selected according to possible
2324 // non-default interpretations. If the Attribute does not exist, return 0
2325 unsigned char ata_return_temperature_value(const ata_smart_values
* data
, const ata_vendor_attr_defs
& defs
)
2327 for (int i
= 0; i
< 4; i
++) {
2328 static const unsigned char ids
[4] = {194, 190, 9, 220};
2329 unsigned char id
= ids
[i
];
2330 const ata_attr_raw_format format
= defs
[id
].raw_format
;
2331 if (!( ((id
== 194 || id
== 190) && format
== RAWFMT_DEFAULT
)
2332 || format
== RAWFMT_TEMPMINMAX
|| format
== RAWFMT_TEMP10X
))
2334 int idx
= ata_find_attr_index(id
, *data
);
2337 uint64_t raw
= ata_get_attr_raw_value(data
->vendor_attributes
[idx
], defs
);
2339 // ignore possible min/max values in high words
2340 if (format
== RAWFMT_TEMP10X
) // -v N,temp10x
2341 temp
= ((unsigned short)raw
+ 5) / 10;
2343 temp
= (unsigned char)raw
;
2344 if (!(0 < temp
&& temp
< 128))
2348 // No valid attribute found
2354 int ataReadSCTStatus(ata_device
* device
, ata_sct_status_response
* sts
)
2356 // read SCT status via SMART log 0xe0
2357 memset(sts
, 0, sizeof(*sts
));
2358 if (smartcommandhandler(device
, READ_LOG
, 0xe0, (char *)sts
)){
2359 pout("Read SCT Status failed: %s\n", device
->get_errmsg());
2363 // swap endian order if needed
2365 swapx(&sts
->format_version
);
2366 swapx(&sts
->sct_version
);
2367 swapx(&sts
->sct_spec
);
2368 swapx(&sts
->ext_status_code
);
2369 swapx(&sts
->action_code
);
2370 swapx(&sts
->function_code
);
2371 swapx(&sts
->over_limit_count
);
2372 swapx(&sts
->under_limit_count
);
2375 // Check format version
2376 if (!(sts
->format_version
== 2 || sts
->format_version
== 3)) {
2377 pout("Unknown SCT Status format version %u, should be 2 or 3.\n", sts
->format_version
);
2383 // Read SCT Temperature History Table and Status
2384 int ataReadSCTTempHist(ata_device
* device
, ata_sct_temperature_history_table
* tmh
,
2385 ata_sct_status_response
* sts
)
2387 // Check initial status
2388 if (ataReadSCTStatus(device
, sts
))
2391 // Do nothing if other SCT command is executing
2392 if (sts
->ext_status_code
== 0xffff) {
2393 pout("Another SCT command is executing, abort Read Data Table\n"
2394 "(SCT ext_status_code 0x%04x, action_code=%u, function_code=%u)\n",
2395 sts
->ext_status_code
, sts
->action_code
, sts
->function_code
);
2399 ata_sct_data_table_command cmd
; memset(&cmd
, 0, sizeof(cmd
));
2400 // CAUTION: DO NOT CHANGE THIS VALUE (SOME ACTION CODES MAY ERASE DISK)
2401 cmd
.action_code
= 5; // Data table command
2402 cmd
.function_code
= 1; // Read table
2403 cmd
.table_id
= 2; // Temperature History Table
2405 // swap endian order if needed
2406 if (isbigendian()) {
2407 swapx(&cmd
.action_code
);
2408 swapx(&cmd
.function_code
);
2409 swapx(&cmd
.table_id
);
2412 // write command via SMART log page 0xe0
2413 if (smartcommandhandler(device
, WRITE_LOG
, 0xe0, (char *)&cmd
)){
2414 pout("Write SCT Data Table failed: %s\n", device
->get_errmsg());
2418 // read SCT data via SMART log page 0xe1
2419 memset(tmh
, 0, sizeof(*tmh
));
2420 if (smartcommandhandler(device
, READ_LOG
, 0xe1, (char *)tmh
)){
2421 pout("Read SCT Data Table failed: %s\n", device
->get_errmsg());
2425 // re-read and check SCT status
2426 if (ataReadSCTStatus(device
, sts
))
2429 if (!(sts
->ext_status_code
== 0 && sts
->action_code
== 5 && sts
->function_code
== 1)) {
2430 pout("Unexpected SCT status 0x%04x (action_code=%u, function_code=%u)\n",
2431 sts
->ext_status_code
, sts
->action_code
, sts
->function_code
);
2435 // swap endian order if needed
2437 swapx(&tmh
->format_version
);
2438 swapx(&tmh
->sampling_period
);
2439 swapx(&tmh
->interval
);
2440 swapx(&tmh
->cb_index
);
2441 swapx(&tmh
->cb_size
);
2446 // Set SCT Temperature Logging Interval
2447 int ataSetSCTTempInterval(ata_device
* device
, unsigned interval
, bool persistent
)
2449 // Check initial status
2450 ata_sct_status_response sts
;
2451 if (ataReadSCTStatus(device
, &sts
))
2454 // Do nothing if other SCT command is executing
2455 if (sts
.ext_status_code
== 0xffff) {
2456 pout("Another SCT command is executing, abort Feature Control\n"
2457 "(SCT ext_status_code 0x%04x, action_code=%u, function_code=%u)\n",
2458 sts
.ext_status_code
, sts
.action_code
, sts
.function_code
);
2462 ata_sct_feature_control_command cmd
; memset(&cmd
, 0, sizeof(cmd
));
2463 // CAUTION: DO NOT CHANGE THIS VALUE (SOME ACTION CODES MAY ERASE DISK)
2464 cmd
.action_code
= 4; // Feature Control command
2465 cmd
.function_code
= 1; // Set state
2466 cmd
.feature_code
= 3; // Temperature logging interval
2467 cmd
.state
= interval
;
2468 cmd
.option_flags
= (persistent
? 0x01 : 0x00);
2470 // swap endian order if needed
2471 if (isbigendian()) {
2472 swapx(&cmd
.action_code
);
2473 swapx(&cmd
.function_code
);
2474 swapx(&cmd
.feature_code
);
2476 swapx(&cmd
.option_flags
);
2479 // write command via SMART log page 0xe0
2480 if (smartcommandhandler(device
, WRITE_LOG
, 0xe0, (char *)&cmd
)){
2481 pout("Write SCT Feature Control Command failed: %s\n", device
->get_errmsg());
2485 // re-read and check SCT status
2486 if (ataReadSCTStatus(device
, &sts
))
2489 if (!(sts
.ext_status_code
== 0 && sts
.action_code
== 4 && sts
.function_code
== 1)) {
2490 pout("Unexpected SCT status 0x%04x (action_code=%u, function_code=%u)\n",
2491 sts
.ext_status_code
, sts
.action_code
, sts
.function_code
);
2497 // Get/Set SCT Error Recovery Control
2498 static int ataGetSetSCTErrorRecoveryControltime(ata_device
* device
, unsigned type
,
2499 bool set
, unsigned short & time_limit
)
2501 // Check initial status
2502 ata_sct_status_response sts
;
2503 if (ataReadSCTStatus(device
, &sts
))
2506 // Do nothing if other SCT command is executing
2507 if (sts
.ext_status_code
== 0xffff) {
2508 pout("Another SCT command is executing, abort Error Recovery Control\n"
2509 "(SCT ext_status_code 0x%04x, action_code=%u, function_code=%u)\n",
2510 sts
.ext_status_code
, sts
.action_code
, sts
.function_code
);
2514 ata_sct_error_recovery_control_command cmd
; memset(&cmd
, 0, sizeof(cmd
));
2515 // CAUTION: DO NOT CHANGE THIS VALUE (SOME ACTION CODES MAY ERASE DISK)
2516 cmd
.action_code
= 3; // Error Recovery Control command
2517 cmd
.function_code
= (set
? 1 : 2); // 1=Set timer, 2=Get timer
2518 cmd
.selection_code
= type
; // 1=Read timer, 2=Write timer
2520 cmd
.time_limit
= time_limit
;
2522 // swap endian order if needed
2523 if (isbigendian()) {
2524 swapx(&cmd
.action_code
);
2525 swapx(&cmd
.function_code
);
2526 swapx(&cmd
.selection_code
);
2527 swapx(&cmd
.time_limit
);
2530 // write command via SMART log page 0xe0
2531 // TODO: Debug output
2533 in
.in_regs
.command
= ATA_SMART_CMD
;
2534 in
.in_regs
.lba_high
= SMART_CYL_HI
; in
.in_regs
.lba_mid
= SMART_CYL_LOW
;
2535 in
.in_regs
.features
= ATA_SMART_WRITE_LOG_SECTOR
;
2536 in
.in_regs
.lba_low
= 0xe0;
2537 in
.set_data_out(&cmd
, 1);
2540 // Time limit returned in ATA registers
2541 in
.out_needed
.sector_count
= in
.out_needed
.lba_low
= true;
2544 if (!device
->ata_pass_through(in
, out
)) {
2545 pout("Write SCT (%cet) Error Recovery Control Command failed: %s\n",
2546 (!set
? 'G' : 'S'), device
->get_errmsg());
2550 // re-read and check SCT status
2551 if (ataReadSCTStatus(device
, &sts
))
2554 if (!(sts
.ext_status_code
== 0 && sts
.action_code
== 3 && sts
.function_code
== (set
? 1 : 2))) {
2555 pout("Unexpected SCT status 0x%04x (action_code=%u, function_code=%u)\n",
2556 sts
.ext_status_code
, sts
.action_code
, sts
.function_code
);
2561 // Check whether registers are properly returned by ioctl()
2562 if (!(out
.out_regs
.sector_count
.is_set() && out
.out_regs
.lba_low
.is_set())) {
2563 // TODO: Output register support should be checked within each ata_pass_through()
2564 // implementation before command is issued.
2565 pout("SMART WRITE LOG does not return COUNT and LBA_LOW register\n");
2568 if ( out
.out_regs
.sector_count
== in
.in_regs
.sector_count
2569 && out
.out_regs
.lba_low
== in
.in_regs
.lba_low
) {
2570 // 0xe001 (5734.5s) - this is most likely a broken ATA pass-through implementation
2571 pout("SMART WRITE LOG returns COUNT and LBA_LOW register unchanged\n");
2575 // Return value to caller
2576 time_limit
= out
.out_regs
.sector_count
| (out
.out_regs
.lba_low
<< 8);
2582 // Get SCT Error Recovery Control
2583 int ataGetSCTErrorRecoveryControltime(ata_device
* device
, unsigned type
, unsigned short & time_limit
)
2585 return ataGetSetSCTErrorRecoveryControltime(device
, type
, false/*get*/, time_limit
);
2588 // Set SCT Error Recovery Control
2589 int ataSetSCTErrorRecoveryControltime(ata_device
* device
, unsigned type
, unsigned short time_limit
)
2591 return ataGetSetSCTErrorRecoveryControltime(device
, type
, true/*set*/, time_limit
);
2595 // Print one self-test log entry.
2597 // -1: self-test failed
2598 // 1: extended self-test completed without error
2600 int ataPrintSmartSelfTestEntry(unsigned testnum
, unsigned char test_type
,
2601 unsigned char test_status
,
2602 unsigned short timestamp
,
2603 uint64_t failing_lba
,
2604 bool print_error_only
, bool & print_header
)
2606 // Check status and type for return value
2608 switch (test_status
>> 4) {
2610 if ((test_type
& 0x0f) == 0x02)
2611 retval
= 1; // extended self-test completed without error
2616 retval
= -1; // self-test failed
2620 if (retval
>= 0 && print_error_only
)
2623 std::string msgtest
;
2624 switch (test_type
) {
2625 case 0x00: msgtest
= "Offline"; break;
2626 case 0x01: msgtest
= "Short offline"; break;
2627 case 0x02: msgtest
= "Extended offline"; break;
2628 case 0x03: msgtest
= "Conveyance offline"; break;
2629 case 0x04: msgtest
= "Selective offline"; break;
2630 case 0x7f: msgtest
= "Abort offline test"; break;
2631 case 0x81: msgtest
= "Short captive"; break;
2632 case 0x82: msgtest
= "Extended captive"; break;
2633 case 0x83: msgtest
= "Conveyance captive"; break;
2634 case 0x84: msgtest
= "Selective captive"; break;
2636 if ((0x40 <= test_type
&& test_type
<= 0x7e) || 0x90 <= test_type
)
2637 msgtest
= strprintf("Vendor (0x%02x)", test_type
);
2639 msgtest
= strprintf("Reserved (0x%02x)", test_type
);
2642 std::string msgstat
;
2643 switch (test_status
>> 4) {
2644 case 0x0: msgstat
= "Completed without error"; break;
2645 case 0x1: msgstat
= "Aborted by host"; break;
2646 case 0x2: msgstat
= "Interrupted (host reset)"; break;
2647 case 0x3: msgstat
= "Fatal or unknown error"; break;
2648 case 0x4: msgstat
= "Completed: unknown failure"; break;
2649 case 0x5: msgstat
= "Completed: electrical failure"; break;
2650 case 0x6: msgstat
= "Completed: servo/seek failure"; break;
2651 case 0x7: msgstat
= "Completed: read failure"; break;
2652 case 0x8: msgstat
= "Completed: handling damage??"; break;
2653 case 0xf: msgstat
= "Self-test routine in progress"; break;
2654 default: msgstat
= strprintf("Unknown status (0x%x)", test_status
>> 4);
2657 // Print header once
2659 print_header
= false;
2660 pout("Num Test_Description Status Remaining LifeTime(hours) LBA_of_first_error\n");
2664 if (retval
< 0 && failing_lba
< 0xffffffffffffULL
)
2665 snprintf(msglba
, sizeof(msglba
), "%"PRIu64
, failing_lba
);
2667 msglba
[0] = '-'; msglba
[1] = 0;
2670 pout("#%2u %-19s %-29s %1d0%% %8u %s\n", testnum
,
2671 msgtest
.c_str(), msgstat
.c_str(), test_status
& 0x0f, timestamp
, msglba
);
2676 // Print Smart self-test log, used by smartctl and smartd.
2678 // bottom 8 bits: number of entries found where self-test showed an error
2679 // remaining bits: if nonzero, power on hours of last self-test where error was found
2680 int ataPrintSmartSelfTestlog(const ata_smart_selftestlog
* data
, bool allentries
,
2681 firmwarebug_defs firmwarebugs
)
2684 pout("SMART Self-test log structure revision number %d\n",(int)data
->revnumber
);
2685 if (data
->revnumber
!= 0x0001 && allentries
&& !firmwarebugs
.is_set(BUG_SAMSUNG
))
2686 pout("Warning: ATA Specification requires self-test log structure revision number = 1\n");
2687 if (data
->mostrecenttest
==0){
2689 pout("No self-tests have been logged. [To run self-tests, use: smartctl -t]\n\n");
2693 bool noheaderprinted
= true;
2694 int errcnt
= 0, hours
= 0, igncnt
= 0;
2695 int testno
= 0, ext_ok_testno
= -1;
2698 for (int i
= 20; i
>= 0; i
--) {
2699 // log is a circular buffer
2700 int j
= (i
+data
->mostrecenttest
)%21;
2701 const ata_smart_selftestlog_struct
* log
= data
->selftest_struct
+j
;
2703 if (nonempty(log
, sizeof(*log
))) {
2704 // count entry based on non-empty structures -- needed for
2705 // Seagate only -- other vendors don't have blank entries 'in
2709 // T13/1321D revision 1c: (Data structure Rev #1)
2711 //The failing LBA shall be the LBA of the uncorrectable sector
2712 //that caused the test to fail. If the device encountered more
2713 //than one uncorrectable sector during the test, this field
2714 //shall indicate the LBA of the first uncorrectable sector
2715 //encountered. If the test passed or the test failed for some
2716 //reason other than an uncorrectable sector, the value of this
2717 //field is undefined.
2719 // This is true in ALL ATA-5 specs
2720 uint64_t lba48
= (log
->lbafirstfailure
< 0xffffffff ? log
->lbafirstfailure
: 0xffffffffffffULL
);
2723 int state
= ataPrintSmartSelfTestEntry(testno
,
2724 log
->selftestnumber
, log
->selfteststatus
,
2725 log
->timestamp
, lba48
, !allentries
, noheaderprinted
);
2728 // Self-test showed an error
2729 if (ext_ok_testno
< 0) {
2732 // keep track of time of most recent error
2734 hours
= log
->timestamp
;
2737 // Newer successful extended self-test exits
2740 else if (state
> 0 && ext_ok_testno
< 0) {
2741 // Latest successful extended self-test
2742 ext_ok_testno
= testno
;
2748 pout("%d of %d failed self-tests are outdated by newer successful extended offline self-test #%2d\n",
2749 igncnt
, igncnt
+errcnt
, ext_ok_testno
);
2751 if (!allentries
&& !noheaderprinted
)
2754 return ((hours
<< 8) | errcnt
);
2758 /////////////////////////////////////////////////////////////////////////////
2759 // Pseudo-device to parse "smartctl -r ataioctl,2 ..." output and simulate
2760 // an ATA device with same behaviour
2764 class parsed_ata_device
2765 : public /*implements*/ ata_device_with_command_set
2768 parsed_ata_device(smart_interface
* intf
, const char * dev_name
);
2770 virtual ~parsed_ata_device() throw();
2772 virtual bool is_open() const;
2774 virtual bool open();
2776 virtual bool close();
2778 virtual bool ata_identify_is_cached() const;
2781 virtual int ata_command_interface(smart_command_set command
, int select
, char * data
);
2784 // Table of parsed commands, return value, data
2785 struct parsed_ata_command
2787 smart_command_set command
;
2793 enum { max_num_commands
= 32 };
2794 parsed_ata_command m_command_table
[max_num_commands
];
2797 int m_next_replay_command
;
2798 bool m_replay_out_of_sync
;
2799 bool m_ata_identify_is_cached
;
2802 static const char * nextline(const char * s
, int & lineno
)
2804 for (s
+= strcspn(s
, "\r\n"); *s
== '\r' || *s
== '\n'; s
++) {
2805 if (*s
== '\r' && s
[1] == '\n')
2812 static int name2command(const char * s
)
2814 for (int i
= 0; i
< (int)(sizeof(commandstrings
)/sizeof(commandstrings
[0])); i
++) {
2815 if (!strcmp(s
, commandstrings
[i
]))
2821 static bool matchcpy(char * dest
, size_t size
, const char * src
, const regmatch_t
& srcmatch
)
2823 if (srcmatch
.rm_so
< 0)
2825 size_t n
= srcmatch
.rm_eo
- srcmatch
.rm_so
;
2828 memcpy(dest
, src
+ srcmatch
.rm_so
, n
);
2833 static inline int matchtoi(const char * src
, const regmatch_t
& srcmatch
, int defval
)
2835 if (srcmatch
.rm_so
< 0)
2837 return atoi(src
+ srcmatch
.rm_so
);
2840 parsed_ata_device::parsed_ata_device(smart_interface
* intf
, const char * dev_name
)
2841 : smart_device(intf
, dev_name
, "ata", ""),
2843 m_next_replay_command(0),
2844 m_replay_out_of_sync(false),
2845 m_ata_identify_is_cached(false)
2847 memset(m_command_table
, 0, sizeof(m_command_table
));
2850 parsed_ata_device::~parsed_ata_device() throw()
2855 bool parsed_ata_device::is_open() const
2857 return (m_num_commands
> 0);
2860 // Parse stdin and build command table
2861 bool parsed_ata_device::open()
2863 const char * pathname
= get_dev_name();
2864 if (strcmp(pathname
, "-"))
2865 return set_err(EINVAL
);
2866 pathname
= "<stdin>";
2868 char buffer
[64*1024];
2870 while (size
< (int)sizeof(buffer
)) {
2871 int nr
= fread(buffer
, 1, sizeof(buffer
), stdin
);
2877 return set_err(ENOENT
, "%s: Unexpected EOF", pathname
);
2878 if (size
>= (int)sizeof(buffer
))
2879 return set_err(EIO
, "%s: Buffer overflow", pathname
);
2882 // Regex to match output from "-r ataioctl,2"
2883 static const char pattern
[] = "^"
2885 "REPORT-IOCTL: DeviceF?D?=[^ ]+ Command=([A-Z ]*[A-Z])" // (2)
2887 "( InputParameter=([0-9]+))?" // (4 (5))
2889 "( returned (-?[0-9]+)( errno=([0-9]+)[^\r\n]*)?)" // (6 (7) (8 (9)))
2891 "[\r\n]" // EOL match necessary to match optional parts above
2893 "===== \\[([A-Z ]*[A-Z])\\] DATA START " // (10)
2895 " *(En|Dis)abled status cached by OS, " // (11)
2899 const regular_expression
regex(pattern
, REG_EXTENDED
);
2902 const char * errmsg
= 0;
2903 int i
= -1, state
= 0, lineno
= 1;
2904 for (const char * line
= buffer
; *line
; line
= nextline(line
, lineno
)) {
2906 if (!(line
[0] == 'R' || line
[0] == '=' || line
[0] == ' '))
2908 const int nmatch
= 1+11;
2909 regmatch_t match
[nmatch
];
2910 if (!regex
.execute(line
, nmatch
, match
))
2914 if (matchcpy(cmdname
, sizeof(cmdname
), line
, match
[2])) { // "REPORT-IOCTL:... Command=%s ..."
2915 int nc
= name2command(cmdname
);
2917 errmsg
= "Unknown ATA command name"; break;
2919 if (match
[7].rm_so
< 0) { // "returned %d"
2921 if (!(state
== 0 || state
== 2)) {
2922 errmsg
= "Missing REPORT-IOCTL result"; break;
2924 if (++i
>= max_num_commands
) {
2925 errmsg
= "Too many ATA commands"; break;
2927 m_command_table
[i
].command
= (smart_command_set
)nc
;
2928 m_command_table
[i
].select
= matchtoi(line
, match
[5], 0); // "InputParameter=%d"
2933 if (!(state
== 1 && (int)m_command_table
[i
].command
== nc
)) {
2934 errmsg
= "Missing REPORT-IOCTL start"; break;
2936 m_command_table
[i
].retval
= matchtoi(line
, match
[7], -1); // "returned %d"
2937 m_command_table
[i
].errval
= matchtoi(line
, match
[9], 0); // "errno=%d"
2941 else if (matchcpy(cmdname
, sizeof(cmdname
), line
, match
[10])) { // "===== [%s] DATA START "
2942 // Start of sector hexdump
2943 int nc
= name2command(cmdname
);
2944 if (!(state
== (nc
== WRITE_LOG
? 1 : 2) && (int)m_command_table
[i
].command
== nc
)) {
2945 errmsg
= "Unexpected DATA START"; break;
2947 line
= nextline(line
, lineno
);
2948 char * data
= (char *)malloc(512);
2950 for (j
= 0; j
< 32; j
++) {
2952 unsigned u1
, u2
; int n1
= -1;
2953 if (!(sscanf(line
, "%3u-%3u: "
2954 "%2x %2x %2x %2x %2x %2x %2x %2x "
2955 "%2x %2x %2x %2x %2x %2x %2x %2x%n",
2957 b
+ 0, b
+ 1, b
+ 2, b
+ 3, b
+ 4, b
+ 5, b
+ 6, b
+ 7,
2958 b
+ 8, b
+ 9, b
+10, b
+11, b
+12, b
+13, b
+14, b
+15, &n1
) == 18
2959 && n1
>= 56 && u1
== j
*16 && u2
== j
*16+15))
2961 for (unsigned k
= 0; k
< 16; k
++)
2962 data
[j
*16+k
] = b
[k
];
2963 line
= nextline(line
, lineno
);
2967 errmsg
= "Incomplete sector hex dump"; break;
2969 m_command_table
[i
].data
= data
;
2970 if (nc
!= WRITE_LOG
)
2973 else if (match
[11].rm_so
> 0) { // "(En|Dis)abled status cached by OS"
2974 m_ata_identify_is_cached
= true;
2978 if (!(state
== 0 || state
== 2))
2979 errmsg
= "Missing REPORT-IOCTL result";
2981 if (!errmsg
&& i
< 0)
2982 errmsg
= "No information found";
2984 m_num_commands
= i
+1;
2985 m_next_replay_command
= 0;
2986 m_replay_out_of_sync
= false;
2990 return set_err(EIO
, "%s(%d): Syntax error: %s", pathname
, lineno
, errmsg
);
2995 // Report warnings and free command table
2996 bool parsed_ata_device::close()
2998 if (m_replay_out_of_sync
)
2999 pout("REPLAY-IOCTL: Warning: commands replayed out of sync\n");
3000 else if (m_next_replay_command
!= 0)
3001 pout("REPLAY-IOCTL: Warning: %d command(s) not replayed\n", m_num_commands
-m_next_replay_command
);
3003 for (int i
= 0; i
< m_num_commands
; i
++) {
3004 if (m_command_table
[i
].data
) {
3005 free(m_command_table
[i
].data
); m_command_table
[i
].data
= 0;
3009 m_next_replay_command
= 0;
3010 m_replay_out_of_sync
= false;
3015 bool parsed_ata_device::ata_identify_is_cached() const
3017 return m_ata_identify_is_cached
;
3021 // Simulate ATA command from command table
3022 int parsed_ata_device::ata_command_interface(smart_command_set command
, int select
, char * data
)
3024 // Find command, try round-robin if out of sync
3025 int i
= m_next_replay_command
;
3026 for (int j
= 0; ; j
++) {
3027 if (j
>= m_num_commands
) {
3028 pout("REPLAY-IOCTL: Warning: Command not found\n");
3032 if (m_command_table
[i
].command
== command
&& m_command_table
[i
].select
== select
)
3034 if (!m_replay_out_of_sync
) {
3035 m_replay_out_of_sync
= true;
3036 pout("REPLAY-IOCTL: Warning: Command #%d is out of sync\n", i
+1);
3038 if (++i
>= m_num_commands
)
3041 m_next_replay_command
= i
;
3042 if (++m_next_replay_command
>= m_num_commands
)
3043 m_next_replay_command
= 0;
3045 // Return command data
3050 case READ_THRESHOLDS
:
3052 if (m_command_table
[i
].data
)
3053 memcpy(data
, m_command_table
[i
].data
, 512);
3056 if (!(m_command_table
[i
].data
&& !memcmp(data
, m_command_table
[i
].data
, 512)))
3057 pout("REPLAY-IOCTL: Warning: WRITE LOG data does not match\n");
3059 case CHECK_POWER_MODE
:
3060 data
[0] = (char)0xff;
3065 if (m_command_table
[i
].errval
)
3066 errno
= m_command_table
[i
].errval
;
3067 return m_command_table
[i
].retval
;
3072 ata_device
* get_parsed_ata_device(smart_interface
* intf
, const char * dev_name
)
3074 return new parsed_ata_device(intf
, dev_name
);