Annotation of embedaddon/smartmontools/atacmds.cpp, revision 1.1.1.1
1.1 misho 1: /*
2: * atacmds.cpp
3: *
4: * Home page of code is: http://smartmontools.sourceforge.net
5: *
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>
9: * Copyright (C) 2000 Andre Hedrick <andre@linux-ide.org>
10: *
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)
14: * any later version.
15: *
16: * You should have received a copy of the GNU General Public License
17: * (for example COPYING); if not, write to the Free
18: * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19: *
20: * This code was originally developed as a Senior Thesis by Michael Cornwell
21: * at the Concurrent Systems Laboratory (now part of the Storage Systems
22: * Research Center), Jack Baskin School of Engineering, University of
23: * California, Santa Cruz. http://ssrc.soe.ucsc.edu/
24: *
25: */
26:
27: #include <stdio.h>
28: #include <string.h>
29: #include <errno.h>
30: #include <stdlib.h>
31: #include <ctype.h>
32:
33: #include "config.h"
34: #include "int64.h"
35: #include "atacmds.h"
36: #include "utility.h"
37: #include "dev_ata_cmd_set.h" // for parsed_ata_device
38:
39: const char * atacmds_cpp_cvsid = "$Id: atacmds.cpp 3411 2011-08-12 21:48:54Z chrfranke $"
40: ATACMDS_H_CVSID;
41:
42: // Print ATA debug messages?
43: unsigned char ata_debugmode = 0;
44:
45: // Suppress serial number?
46: // (also used in scsiprint.cpp)
47: bool dont_print_serial_number = false;
48:
49:
50: #define SMART_CYL_LOW 0x4F
51: #define SMART_CYL_HI 0xC2
52:
53: // SMART RETURN STATUS yields SMART_CYL_HI,SMART_CYL_LOW to indicate drive
54: // is healthy and SRET_STATUS_HI_EXCEEDED,SRET_STATUS_MID_EXCEEDED to
55: // indicate that a threshhold exceeded condition has been detected.
56: // Those values (byte pairs) are placed in ATA register "LBA 23:8".
57: #define SRET_STATUS_HI_EXCEEDED 0x2C
58: #define SRET_STATUS_MID_EXCEEDED 0xF4
59:
60: // These Drive Identity tables are taken from hdparm 5.2, and are also
61: // given in the ATA/ATAPI specs for the IDENTIFY DEVICE command. Note
62: // that SMART was first added into the ATA/ATAPI-3 Standard with
63: // Revision 3 of the document, July 25, 1995. Look at the "Document
64: // Status" revision commands at the beginning of
65: // http://www.t13.org/Documents/UploadedDocuments/project/d2008r7b-ATA-3.pdf
66: // to see this.
67: #define NOVAL_0 0x0000
68: #define NOVAL_1 0xffff
69: /* word 81: minor version number */
70: #define MINOR_MAX 0x22
71: static const char * const minor_str[] = { /* word 81 value: */
72: "Device does not report version", /* 0x0000 */
73: "ATA-1 X3T9.2 781D prior to revision 4", /* 0x0001 */
74: "ATA-1 published, ANSI X3.221-1994", /* 0x0002 */
75: "ATA-1 X3T9.2 781D revision 4", /* 0x0003 */
76: "ATA-2 published, ANSI X3.279-1996", /* 0x0004 */
77: "ATA-2 X3T10 948D prior to revision 2k", /* 0x0005 */
78: "ATA-3 X3T10 2008D revision 1", /* 0x0006 */ /* SMART NOT INCLUDED */
79: "ATA-2 X3T10 948D revision 2k", /* 0x0007 */
80: "ATA-3 X3T10 2008D revision 0", /* 0x0008 */
81: "ATA-2 X3T10 948D revision 3", /* 0x0009 */
82: "ATA-3 published, ANSI X3.298-199x", /* 0x000a */
83: "ATA-3 X3T10 2008D revision 6", /* 0x000b */ /* 1st VERSION WITH SMART */
84: "ATA-3 X3T13 2008D revision 7 and 7a", /* 0x000c */
85: "ATA/ATAPI-4 X3T13 1153D revision 6", /* 0x000d */
86: "ATA/ATAPI-4 T13 1153D revision 13", /* 0x000e */
87: "ATA/ATAPI-4 X3T13 1153D revision 7", /* 0x000f */
88: "ATA/ATAPI-4 T13 1153D revision 18", /* 0x0010 */
89: "ATA/ATAPI-4 T13 1153D revision 15", /* 0x0011 */
90: "ATA/ATAPI-4 published, ANSI NCITS 317-1998", /* 0x0012 */
91: "ATA/ATAPI-5 T13 1321D revision 3", /* 0x0013 */
92: "ATA/ATAPI-4 T13 1153D revision 14", /* 0x0014 */
93: "ATA/ATAPI-5 T13 1321D revision 1", /* 0x0015 */
94: "ATA/ATAPI-5 published, ANSI NCITS 340-2000", /* 0x0016 */
95: "ATA/ATAPI-4 T13 1153D revision 17", /* 0x0017 */
96: "ATA/ATAPI-6 T13 1410D revision 0", /* 0x0018 */
97: "ATA/ATAPI-6 T13 1410D revision 3a", /* 0x0019 */
98: "ATA/ATAPI-7 T13 1532D revision 1", /* 0x001a */
99: "ATA/ATAPI-6 T13 1410D revision 2", /* 0x001b */
100: "ATA/ATAPI-6 T13 1410D revision 1", /* 0x001c */
101: "ATA/ATAPI-7 published, ANSI INCITS 397-2005",/* 0x001d */
102: "ATA/ATAPI-7 T13 1532D revision 0", /* 0x001e */
103: "reserved", /* 0x001f */
104: "reserved", /* 0x0020 */
105: "ATA/ATAPI-7 T13 1532D revision 4a", /* 0x0021 */
106: "ATA/ATAPI-6 published, ANSI INCITS 361-2002" /* 0x0022 */
107: };
108:
109: // NOTE ATA/ATAPI-4 REV 4 was the LAST revision where the device
110: // attribute structures were NOT completely vendor specific. So any
111: // disk that is ATA/ATAPI-4 or above can not be trusted to show the
112: // vendor values in sensible format.
113:
114: // Negative values below are because it doesn't support SMART
115: static const int actual_ver[] = {
116: /* word 81 value: */
117: 0, /* 0x0000 WARNING: */
118: 1, /* 0x0001 WARNING: */
119: 1, /* 0x0002 WARNING: */
120: 1, /* 0x0003 WARNING: */
121: 2, /* 0x0004 WARNING: This array */
122: 2, /* 0x0005 WARNING: corresponds */
123: -3, /*<== */ /* 0x0006 WARNING: *exactly* */
124: 2, /* 0x0007 WARNING: to the ATA/ */
125: -3, /*<== */ /* 0x0008 WARNING: ATAPI version */
126: 2, /* 0x0009 WARNING: listed in */
127: 3, /* 0x000a WARNING: the */
128: 3, /* 0x000b WARNING: minor_str */
129: 3, /* 0x000c WARNING: array */
130: 4, /* 0x000d WARNING: above. */
131: 4, /* 0x000e WARNING: */
132: 4, /* 0x000f WARNING: If you change */
133: 4, /* 0x0010 WARNING: that one, */
134: 4, /* 0x0011 WARNING: change this one */
135: 4, /* 0x0012 WARNING: too!!! */
136: 5, /* 0x0013 WARNING: */
137: 4, /* 0x0014 WARNING: */
138: 5, /* 0x0015 WARNING: */
139: 5, /* 0x0016 WARNING: */
140: 4, /* 0x0017 WARNING: */
141: 6, /* 0x0018 WARNING: */
142: 6, /* 0x0019 WARNING: */
143: 7, /* 0x001a WARNING: */
144: 6, /* 0x001b WARNING: */
145: 6, /* 0x001c WARNING: */
146: 7, /* 0x001d WARNING: */
147: 7, /* 0x001e WARNING: */
148: 0, /* 0x001f WARNING: */
149: 0, /* 0x0020 WARNING: */
150: 7, /* 0x0021 WARNING: */
151: 6 /* 0x0022 WARNING: */
152: };
153:
154: // Compile time check of above array sizes
155: typedef char assert_sizeof_minor_str [sizeof(minor_str) /sizeof(minor_str[0]) == MINOR_MAX+1 ? 1 : -1];
156: typedef char assert_sizeof_actual_ver[sizeof(actual_ver)/sizeof(actual_ver[0]) == MINOR_MAX+1 ? 1 : -1];
157:
158: // Get ID and increase flag of current pending or offline
159: // uncorrectable attribute.
160: unsigned char get_unc_attr_id(bool offline, const ata_vendor_attr_defs & defs,
161: bool & increase)
162: {
163: unsigned char id = (!offline ? 197 : 198);
164: const ata_vendor_attr_defs::entry & def = defs[id];
165: if (def.flags & ATTRFLAG_INCREASING)
166: increase = true; // '-v 19[78],increasing' option
167: else if (def.name.empty() || (id == 198 && def.name == "Offline_Scan_UNC_SectCt"))
168: increase = false; // no or '-v 198,offlinescanuncsectorct' option
169: else
170: id = 0; // other '-v 19[78],...' option
171: return id;
172: }
173:
174: #if 0 // TODO: never used
175: // This are the meanings of the Self-test failure checkpoint byte.
176: // This is in the self-test log at offset 4 bytes into the self-test
177: // descriptor and in the SMART READ DATA structure at byte offset
178: // 371. These codes are not well documented. The meanings returned by
179: // this routine are used (at least) by Maxtor and IBM. Returns NULL if
180: // not recognized. Currently the maximum length is 15 bytes.
181: const char *SelfTestFailureCodeName(unsigned char which){
182:
183: switch (which) {
184: case 0:
185: return "Write_Test";
186: case 1:
187: return "Servo_Basic";
188: case 2:
189: return "Servo_Random";
190: case 3:
191: return "G-list_Scan";
192: case 4:
193: return "Handling_Damage";
194: case 5:
195: return "Read_Scan";
196: default:
197: return NULL;
198: }
199: }
200: #endif
201:
202:
203: // Table of raw print format names
204: struct format_name_entry
205: {
206: const char * name;
207: ata_attr_raw_format format;
208: };
209:
210: const format_name_entry format_names[] = {
211: {"raw8" , RAWFMT_RAW8},
212: {"raw16" , RAWFMT_RAW16},
213: {"raw48" , RAWFMT_RAW48},
214: {"hex48" , RAWFMT_HEX48},
215: {"raw64" , RAWFMT_RAW64},
216: {"hex64" , RAWFMT_HEX64},
217: {"raw16(raw16)" , RAWFMT_RAW16_OPT_RAW16},
218: {"raw16(avg16)" , RAWFMT_RAW16_OPT_AVG16},
219: {"raw24/raw24" , RAWFMT_RAW24_DIV_RAW24},
220: {"raw24/raw32" , RAWFMT_RAW24_DIV_RAW32},
221: {"sec2hour" , RAWFMT_SEC2HOUR},
222: {"min2hour" , RAWFMT_MIN2HOUR},
223: {"halfmin2hour" , RAWFMT_HALFMIN2HOUR},
224: {"msec24hour32" , RAWFMT_MSEC24_HOUR32},
225: {"tempminmax" , RAWFMT_TEMPMINMAX},
226: {"temp10x" , RAWFMT_TEMP10X},
227: };
228:
229: const unsigned num_format_names = sizeof(format_names)/sizeof(format_names[0]);
230:
231: // Table to map old to new '-v' option arguments
232: const char * map_old_vendor_opts[][2] = {
233: { "9,halfminutes" , "9,halfmin2hour,Power_On_Half_Minutes"},
234: { "9,minutes" , "9,min2hour,Power_On_Minutes"},
235: { "9,seconds" , "9,sec2hour,Power_On_Seconds"},
236: { "9,temp" , "9,tempminmax,Temperature_Celsius"},
237: {"192,emergencyretractcyclect" , "192,raw48,Emerg_Retract_Cycle_Ct"},
238: {"193,loadunload" , "193,raw24/raw24"},
239: {"194,10xCelsius" , "194,temp10x,Temperature_Celsius_x10"},
240: {"194,unknown" , "194,raw48,Unknown_Attribute"},
241: {"197,increasing" , "197,raw48+,Total_Pending_Sectors"}, // '+' sets flag
242: {"198,offlinescanuncsectorct" , "198,raw48,Offline_Scan_UNC_SectCt"}, // see also get_unc_attr_id() above
243: {"198,increasing" , "198,raw48+,Total_Offl_Uncorrectabl"}, // '+' sets flag
244: {"200,writeerrorcount" , "200,raw48,Write_Error_Count"},
245: {"201,detectedtacount" , "201,raw48,Detected_TA_Count"},
246: {"220,temp" , "220,raw48,Temperature_Celsius"},
247: };
248:
249: const unsigned num_old_vendor_opts = sizeof(map_old_vendor_opts)/sizeof(map_old_vendor_opts[0]);
250:
251: // Parse vendor attribute display def (-v option).
252: // Return false on error.
253: bool parse_attribute_def(const char * opt, ata_vendor_attr_defs & defs,
254: ata_vendor_def_prior priority)
255: {
256: // Map old -> new options
257: unsigned i;
258: for (i = 0; i < num_old_vendor_opts; i++) {
259: if (!strcmp(opt, map_old_vendor_opts[i][0])) {
260: opt = map_old_vendor_opts[i][1];
261: break;
262: }
263: }
264:
265: // Parse option
266: int len = strlen(opt);
267: int id = 0, n1 = -1, n2 = -1;
268: char fmtname[32+1], attrname[32+1];
269: if (opt[0] == 'N') {
270: // "N,format"
271: if (!( sscanf(opt, "N,%32[^,]%n,%32[^,]%n", fmtname, &n1, attrname, &n2) >= 1
272: && (n1 == len || n2 == len)))
273: return false;
274: }
275: else {
276: // "id,format[+][,name]"
277: if (!( sscanf(opt, "%d,%32[^,]%n,%32[^,]%n", &id, fmtname, &n1, attrname, &n2) >= 2
278: && 1 <= id && id <= 255 && (n1 == len || n2 == len)))
279: return false;
280: }
281: if (n1 == len)
282: attrname[0] = 0;
283:
284: unsigned flags = 0;
285: // For "-v 19[78],increasing" above
286: if (fmtname[strlen(fmtname)-1] == '+') {
287: fmtname[strlen(fmtname)-1] = 0;
288: flags = ATTRFLAG_INCREASING;
289: }
290:
291: // Split "format[:byteorder]"
292: char byteorder[8+1] = "";
293: if (strchr(fmtname, ':')) {
294: if (!( sscanf(fmtname, "%*[^:]%n:%8[012345rvwz]%n", &n1, byteorder, &n2) >= 1
295: && n2 == (int)strlen(fmtname)))
296: return false;
297: fmtname[n1] = 0;
298: if (strchr(byteorder, 'v'))
299: flags |= (ATTRFLAG_NO_NORMVAL|ATTRFLAG_NO_WORSTVAL);
300: if (strchr(byteorder, 'w'))
301: flags |= ATTRFLAG_NO_WORSTVAL;
302: }
303:
304: // Find format name
305: for (i = 0; ; i++) {
306: if (i >= num_format_names)
307: return false; // Not found
308: if (!strcmp(fmtname, format_names[i].name))
309: break;
310: }
311: ata_attr_raw_format format = format_names[i].format;
312:
313: // 64-bit formats use the normalized and worst value bytes.
314: if (!*byteorder && (format == RAWFMT_RAW64 || format == RAWFMT_HEX64))
315: flags |= (ATTRFLAG_NO_NORMVAL|ATTRFLAG_NO_WORSTVAL);
316:
317: if (!id) {
318: // "N,format" -> set format for all entries
319: for (i = 0; i < MAX_ATTRIBUTE_NUM; i++) {
320: if (defs[i].priority >= priority)
321: continue;
322: if (attrname[0])
323: defs[i].name = attrname;
324: defs[i].priority = priority;
325: defs[i].raw_format = format;
326: defs[i].flags = flags;
327: strcpy(defs[i].byteorder, byteorder);
328: }
329: }
330: else if (defs[id].priority <= priority) {
331: // "id,format[,name]"
332: if (attrname[0])
333: defs[id].name = attrname;
334: defs[id].raw_format = format;
335: defs[id].priority = priority;
336: defs[id].flags = flags;
337: strcpy(defs[id].byteorder, byteorder);
338: }
339:
340: return true;
341: }
342:
343:
344: // Return a multiline string containing a list of valid arguments for
345: // parse_attribute_def(). The strings are preceeded by tabs and followed
346: // (except for the last) by newlines.
347: std::string create_vendor_attribute_arg_list()
348: {
349: std::string s;
350: unsigned i;
351: for (i = 0; i < num_format_names; i++)
352: s += strprintf("%s\tN,%s[:012345rvwz][,ATTR_NAME]",
353: (i>0 ? "\n" : ""), format_names[i].name);
354: for (i = 0; i < num_old_vendor_opts; i++)
355: s += strprintf("\n\t%s", map_old_vendor_opts[i][0]);
356: return s;
357: }
358:
359: // swap two bytes. Point to low address
360: void swap2(char *location){
361: char tmp=*location;
362: *location=*(location+1);
363: *(location+1)=tmp;
364: return;
365: }
366:
367: // swap four bytes. Point to low address
368: void swap4(char *location){
369: char tmp=*location;
370: *location=*(location+3);
371: *(location+3)=tmp;
372: swap2(location+1);
373: return;
374: }
375:
376: // swap eight bytes. Points to low address
377: void swap8(char *location){
378: char tmp=*location;
379: *location=*(location+7);
380: *(location+7)=tmp;
381: tmp=*(location+1);
382: *(location+1)=*(location+6);
383: *(location+6)=tmp;
384: swap4(location+2);
385: return;
386: }
387:
388: // Invalidate serial number and WWN and adjust checksum in IDENTIFY data
389: static void invalidate_serno(ata_identify_device * id)
390: {
391: unsigned char sum = 0;
392: unsigned i;
393: for (i = 0; i < sizeof(id->serial_no); i++) {
394: sum += id->serial_no[i]; sum -= id->serial_no[i] = 'X';
395: }
396: unsigned char * b = (unsigned char *)id;
397: for (i = 2*108; i < 2*112; i++) { // words108-111: WWN
398: sum += b[i]; sum -= b[i] = 0x00;
399: }
400:
401: #ifndef __NetBSD__
402: bool must_swap = !!isbigendian();
403: if (must_swap)
404: swapx(id->words088_255+255-88);
405: #endif
406: if ((id->words088_255[255-88] & 0x00ff) == 0x00a5)
407: id->words088_255[255-88] += sum << 8;
408: #ifndef __NetBSD__
409: if (must_swap)
410: swapx(id->words088_255+255-88);
411: #endif
412: }
413:
414: static const char * const commandstrings[]={
415: "SMART ENABLE",
416: "SMART DISABLE",
417: "SMART AUTOMATIC ATTRIBUTE SAVE",
418: "SMART IMMEDIATE OFFLINE",
419: "SMART AUTO OFFLINE",
420: "SMART STATUS",
421: "SMART STATUS CHECK",
422: "SMART READ ATTRIBUTE VALUES",
423: "SMART READ ATTRIBUTE THRESHOLDS",
424: "SMART READ LOG",
425: "IDENTIFY DEVICE",
426: "IDENTIFY PACKET DEVICE",
427: "CHECK POWER MODE",
428: "SMART WRITE LOG",
429: "WARNING (UNDEFINED COMMAND -- CONTACT DEVELOPERS AT " PACKAGE_BUGREPORT ")\n"
430: };
431:
432:
433: static const char * preg(const ata_register & r, char * buf)
434: {
435: if (!r.is_set())
436: //return "n/a ";
437: return "....";
438: sprintf(buf, "0x%02x", r.val()); return buf;
439: }
440:
441: static void print_regs(const char * prefix, const ata_in_regs & r, const char * suffix = "\n")
442: {
443: char bufs[7][4+1+13];
444: pout("%s FR=%s, SC=%s, LL=%s, LM=%s, LH=%s, DEV=%s, CMD=%s%s", prefix,
445: preg(r.features, bufs[0]), preg(r.sector_count, bufs[1]), preg(r.lba_low, bufs[2]),
446: preg(r.lba_mid, bufs[3]), preg(r.lba_high, bufs[4]), preg(r.device, bufs[5]),
447: preg(r.command, bufs[6]), suffix);
448: }
449:
450: static void print_regs(const char * prefix, const ata_out_regs & r, const char * suffix = "\n")
451: {
452: char bufs[7][4+1+13];
453: pout("%sERR=%s, SC=%s, LL=%s, LM=%s, LH=%s, DEV=%s, STS=%s%s", prefix,
454: preg(r.error, bufs[0]), preg(r.sector_count, bufs[1]), preg(r.lba_low, bufs[2]),
455: preg(r.lba_mid, bufs[3]), preg(r.lba_high, bufs[4]), preg(r.device, bufs[5]),
456: preg(r.status, bufs[6]), suffix);
457: }
458:
459: static void prettyprint(const unsigned char *p, const char *name){
460: pout("\n===== [%s] DATA START (BASE-16) =====\n", name);
461: for (int i=0; i<512; i+=16, p+=16)
462: #define P(n) (' ' <= p[n] && p[n] <= '~' ? (int)p[n] : '.')
463: // print complete line to avoid slow tty output and extra lines in syslog.
464: pout("%03d-%03d: %02x %02x %02x %02x %02x %02x %02x %02x "
465: "%02x %02x %02x %02x %02x %02x %02x %02x"
466: " |%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c|"
467: "%c",
468: i, i+16-1,
469: p[ 0], p[ 1], p[ 2], p[ 3], p[ 4], p[ 5], p[ 6], p[ 7],
470: p[ 8], p[ 9], p[10], p[11], p[12], p[13], p[14], p[15],
471: P( 0), P( 1), P( 2), P( 3), P( 4), P( 5), P( 6), P( 7),
472: P( 8), P( 9), P(10), P(11), P(12), P(13), P(14), P(15),
473: '\n');
474: #undef P
475: pout("===== [%s] DATA END (512 Bytes) =====\n\n", name);
476: }
477:
478: // This function provides the pretty-print reporting for SMART
479: // commands: it implements the various -r "reporting" options for ATA
480: // ioctls.
481: int smartcommandhandler(ata_device * device, smart_command_set command, int select, char *data){
482: // TODO: Rework old stuff below
483: // This conditional is true for commands that return data
484: int getsdata=(command==PIDENTIFY ||
485: command==IDENTIFY ||
486: command==READ_LOG ||
487: command==READ_THRESHOLDS ||
488: command==READ_VALUES ||
489: command==CHECK_POWER_MODE);
490:
491: int sendsdata=(command==WRITE_LOG);
492:
493: // If reporting is enabled, say what the command will be before it's executed
494: if (ata_debugmode) {
495: // conditional is true for commands that use parameters
496: int usesparam=(command==READ_LOG ||
497: command==AUTO_OFFLINE ||
498: command==AUTOSAVE ||
499: command==IMMEDIATE_OFFLINE ||
500: command==WRITE_LOG);
501:
502: pout("\nREPORT-IOCTL: Device=%s Command=%s", device->get_dev_name(), commandstrings[command]);
503: if (usesparam)
504: pout(" InputParameter=%d\n", select);
505: else
506: pout("\n");
507: }
508:
509: if ((getsdata || sendsdata) && !data){
510: pout("REPORT-IOCTL: Unable to execute command %s : data destination address is NULL\n", commandstrings[command]);
511: return -1;
512: }
513:
514: // The reporting is cleaner, and we will find coding bugs faster, if
515: // the commands that failed clearly return empty (zeroed) data
516: // structures
517: if (getsdata) {
518: if (command==CHECK_POWER_MODE)
519: data[0]=0;
520: else
521: memset(data, '\0', 512);
522: }
523:
524:
525: // if requested, pretty-print the input data structure
526: if (ata_debugmode > 1 && sendsdata)
527: //pout("REPORT-IOCTL: Device=%s Command=%s\n", device->get_dev_name(), commandstrings[command]);
528: prettyprint((unsigned char *)data, commandstrings[command]);
529:
530: // now execute the command
531: int retval = -1;
532: {
533: ata_cmd_in in;
534: // Set common register values
535: switch (command) {
536: default: // SMART commands
537: in.in_regs.command = ATA_SMART_CMD;
538: in.in_regs.lba_high = SMART_CYL_HI; in.in_regs.lba_mid = SMART_CYL_LOW;
539: break;
540: case IDENTIFY: case PIDENTIFY: case CHECK_POWER_MODE: // Non SMART commands
541: break;
542: }
543: // Set specific values
544: switch (command) {
545: case IDENTIFY:
546: in.in_regs.command = ATA_IDENTIFY_DEVICE;
547: in.set_data_in(data, 1);
548: break;
549: case PIDENTIFY:
550: in.in_regs.command = ATA_IDENTIFY_PACKET_DEVICE;
551: in.set_data_in(data, 1);
552: break;
553: case CHECK_POWER_MODE:
554: in.in_regs.command = ATA_CHECK_POWER_MODE;
555: in.out_needed.sector_count = true; // Powermode returned here
556: break;
557: case READ_VALUES:
558: in.in_regs.features = ATA_SMART_READ_VALUES;
559: in.set_data_in(data, 1);
560: break;
561: case READ_THRESHOLDS:
562: in.in_regs.features = ATA_SMART_READ_THRESHOLDS;
563: in.in_regs.lba_low = 1; // TODO: CORRECT ???
564: in.set_data_in(data, 1);
565: break;
566: case READ_LOG:
567: in.in_regs.features = ATA_SMART_READ_LOG_SECTOR;
568: in.in_regs.lba_low = select;
569: in.set_data_in(data, 1);
570: break;
571: case WRITE_LOG:
572: in.in_regs.features = ATA_SMART_WRITE_LOG_SECTOR;
573: in.in_regs.lba_low = select;
574: in.set_data_out(data, 1);
575: break;
576: case ENABLE:
577: in.in_regs.features = ATA_SMART_ENABLE;
578: in.in_regs.lba_low = 1; // TODO: CORRECT ???
579: break;
580: case DISABLE:
581: in.in_regs.features = ATA_SMART_DISABLE;
582: in.in_regs.lba_low = 1; // TODO: CORRECT ???
583: break;
584: case STATUS_CHECK:
585: in.out_needed.lba_high = in.out_needed.lba_mid = true; // Status returned here
586: case STATUS:
587: in.in_regs.features = ATA_SMART_STATUS;
588: break;
589: case AUTO_OFFLINE:
590: in.in_regs.features = ATA_SMART_AUTO_OFFLINE;
591: in.in_regs.sector_count = select; // Caution: Non-DATA command!
592: break;
593: case AUTOSAVE:
594: in.in_regs.features = ATA_SMART_AUTOSAVE;
595: in.in_regs.sector_count = select; // Caution: Non-DATA command!
596: break;
597: case IMMEDIATE_OFFLINE:
598: in.in_regs.features = ATA_SMART_IMMEDIATE_OFFLINE;
599: in.in_regs.lba_low = select;
600: break;
601: default:
602: pout("Unrecognized command %d in smartcommandhandler()\n"
603: "Please contact " PACKAGE_BUGREPORT "\n", command);
604: device->set_err(ENOSYS);
605: return -1;
606: }
607:
608: if (ata_debugmode)
609: print_regs(" Input: ", in.in_regs,
610: (in.direction==ata_cmd_in::data_in ? " IN\n":
611: in.direction==ata_cmd_in::data_out ? " OUT\n":"\n"));
612:
613: ata_cmd_out out;
614: bool ok = device->ata_pass_through(in, out);
615:
616: if (ata_debugmode && out.out_regs.is_set())
617: print_regs(" Output: ", out.out_regs);
618:
619: if (ok) switch (command) {
620: default:
621: retval = 0;
622: break;
623: case CHECK_POWER_MODE:
624: if (out.out_regs.sector_count.is_set()) {
625: data[0] = out.out_regs.sector_count;
626: retval = 0;
627: }
628: else {
629: pout("CHECK POWER MODE: incomplete response, ATA output registers missing\n");
630: device->set_err(ENOSYS);
631: retval = -1;
632: }
633: break;
634: case STATUS_CHECK:
635: // Cyl low and Cyl high unchanged means "Good SMART status"
636: if ((out.out_regs.lba_high == SMART_CYL_HI) &&
637: (out.out_regs.lba_mid == SMART_CYL_LOW))
638: retval = 0;
639: // These values mean "Bad SMART status"
640: else if ((out.out_regs.lba_high == SRET_STATUS_HI_EXCEEDED) &&
641: (out.out_regs.lba_mid == SRET_STATUS_MID_EXCEEDED))
642: retval = 1;
643: else if (out.out_regs.lba_mid == SMART_CYL_LOW) {
644: retval = 0;
645: if (ata_debugmode)
646: pout("SMART STATUS RETURN: half healthy response sequence, "
647: "probable SAT/USB truncation\n");
648: } else if (out.out_regs.lba_mid == SRET_STATUS_MID_EXCEEDED) {
649: retval = 1;
650: if (ata_debugmode)
651: pout("SMART STATUS RETURN: half unhealthy response sequence, "
652: "probable SAT/USB truncation\n");
653: }
654: else if (!out.out_regs.is_set()) {
655: pout("SMART STATUS RETURN: incomplete response, ATA output registers missing\n");
656: device->set_err(ENOSYS);
657: retval = -1;
658: }
659: else {
660: // We haven't gotten output that makes sense; print out some debugging info
661: pout("Error SMART Status command failed\n");
662: pout("Please get assistance from %s\n", PACKAGE_HOMEPAGE);
663: pout("Register values returned from SMART Status command are:\n");
664: print_regs(" ", out.out_regs);
665: device->set_err(EIO);
666: retval = -1;
667: }
668: break;
669: }
670: }
671:
672: // If requested, invalidate serial number before any printing is done
673: if ((command == IDENTIFY || command == PIDENTIFY) && !retval && dont_print_serial_number)
674: invalidate_serno((ata_identify_device *)data);
675:
676: // If reporting is enabled, say what output was produced by the command
677: if (ata_debugmode) {
678: if (device->get_errno())
679: pout("REPORT-IOCTL: Device=%s Command=%s returned %d errno=%d [%s]\n",
680: device->get_dev_name(), commandstrings[command], retval,
681: device->get_errno(), device->get_errmsg());
682: else
683: pout("REPORT-IOCTL: Device=%s Command=%s returned %d\n",
684: device->get_dev_name(), commandstrings[command], retval);
685:
686: // if requested, pretty-print the output data structure
687: if (ata_debugmode > 1 && getsdata) {
688: if (command==CHECK_POWER_MODE)
689: pout("Sector Count Register (BASE-16): %02x\n", (unsigned char)(*data));
690: else
691: prettyprint((unsigned char *)data, commandstrings[command]);
692: }
693: }
694:
695: return retval;
696: }
697:
698: // Get capacity and sector sizes from IDENTIFY data
699: void ata_get_size_info(const ata_identify_device * id, ata_size_info & sizes)
700: {
701: sizes.sectors = sizes.capacity = 0;
702: sizes.log_sector_size = sizes.phy_sector_size = 0;
703: sizes.log_sector_offset = 0;
704:
705: // Return if no LBA support
706: if (!(id->words047_079[49-47] & 0x0200))
707: return;
708:
709: // Determine 28-bit LBA capacity
710: unsigned lba28 = (unsigned)id->words047_079[61-47] << 16
711: | (unsigned)id->words047_079[60-47] ;
712:
713: // Determine 48-bit LBA capacity if supported
714: uint64_t lba48 = 0;
715: if ((id->command_set_2 & 0xc400) == 0x4400)
716: lba48 = (uint64_t)id->words088_255[103-88] << 48
717: | (uint64_t)id->words088_255[102-88] << 32
718: | (uint64_t)id->words088_255[101-88] << 16
719: | (uint64_t)id->words088_255[100-88] ;
720:
721: // Return if capacity unknown (ATAPI CD/DVD)
722: if (!(lba28 || lba48))
723: return;
724:
725: // Determine sector sizes
726: sizes.log_sector_size = sizes.phy_sector_size = 512;
727:
728: unsigned short word106 = id->words088_255[106-88];
729: if ((word106 & 0xc000) == 0x4000) {
730: // Long Logical/Physical Sectors (LLS/LPS) ?
731: if (word106 & 0x1000)
732: // Logical sector size is specified in 16-bit words
733: sizes.log_sector_size = sizes.phy_sector_size =
734: ((id->words088_255[118-88] << 16) | id->words088_255[117-88]) << 1;
735:
736: if (word106 & 0x2000)
737: // Physical sector size is multiple of logical sector size
738: sizes.phy_sector_size <<= (word106 & 0x0f);
739:
740: unsigned short word209 = id->words088_255[209-88];
741: if ((word209 & 0xc000) == 0x4000)
742: sizes.log_sector_offset = (word209 & 0x3fff) * sizes.log_sector_size;
743: }
744:
745: // Some early 4KiB LLS disks (Samsung N3U-3) return bogus lba28 value
746: if (lba48 >= lba28 || (lba48 && sizes.log_sector_size > 512))
747: sizes.sectors = lba48;
748: else
749: sizes.sectors = lba28;
750:
751: sizes.capacity = sizes.sectors * sizes.log_sector_size;
752: }
753:
754: // This function computes the checksum of a single disk sector (512
755: // bytes). Returns zero if checksum is OK, nonzero if the checksum is
756: // incorrect. The size (512) is correct for all SMART structures.
757: unsigned char checksum(const void * data)
758: {
759: unsigned char sum = 0;
760: for (int i = 0; i < 512; i++)
761: sum += ((const unsigned char *)data)[i];
762: return sum;
763: }
764:
765: // Copies n bytes (or n-1 if n is odd) from in to out, but swaps adjacents
766: // bytes.
767: static void swapbytes(char * out, const char * in, size_t n)
768: {
769: for (size_t i = 0; i < n; i += 2) {
770: out[i] = in[i+1];
771: out[i+1] = in[i];
772: }
773: }
774:
775: // Copies in to out, but removes leading and trailing whitespace.
776: static void trim(char * out, const char * in)
777: {
778: // Find the first non-space character (maybe none).
779: int first = -1;
780: int i;
781: for (i = 0; in[i]; i++)
782: if (!isspace((int)in[i])) {
783: first = i;
784: break;
785: }
786:
787: if (first == -1) {
788: // There are no non-space characters.
789: out[0] = '\0';
790: return;
791: }
792:
793: // Find the last non-space character.
794: for (i = strlen(in)-1; i >= first && isspace((int)in[i]); i--)
795: ;
796: int last = i;
797:
798: strncpy(out, in+first, last-first+1);
799: out[last-first+1] = '\0';
800: }
801:
802: // Convenience function for formatting strings from ata_identify_device
803: void ata_format_id_string(char * out, const unsigned char * in, int n)
804: {
805: bool must_swap = true;
806: #ifdef __NetBSD__
807: /* NetBSD kernel delivers IDENTIFY data in host byte order (but all else is LE) */
808: // TODO: Handle NetBSD case in os_netbsd.cpp
809: if (isbigendian())
810: must_swap = !must_swap;
811: #endif
812:
813: char tmp[65];
814: n = n > 64 ? 64 : n;
815: if (!must_swap)
816: strncpy(tmp, (const char *)in, n);
817: else
818: swapbytes(tmp, (const char *)in, n);
819: tmp[n] = '\0';
820: trim(out, tmp);
821: }
822:
823: // returns -1 if command fails or the device is in Sleep mode, else
824: // value of Sector Count register. Sector Count result values:
825: // 00h device is in Standby mode.
826: // 80h device is in Idle mode.
827: // FFh device is in Active mode or Idle mode.
828:
829: int ataCheckPowerMode(ata_device * device) {
830: unsigned char result;
831:
832: if ((smartcommandhandler(device, CHECK_POWER_MODE, 0, (char *)&result)))
833: return -1;
834:
835: if (result!=0 && result!=0x80 && result!=0xff)
836: pout("ataCheckPowerMode(): ATA CHECK POWER MODE returned unknown Sector Count Register value %02x\n", result);
837:
838: return (int)result;
839: }
840:
841: // Reads current Device Identity info (512 bytes) into buf. Returns 0
842: // if all OK. Returns -1 if no ATA Device identity can be
843: // established. Returns >0 if Device is ATA Packet Device (not SMART
844: // capable). The value of the integer helps identify the type of
845: // Packet device, which is useful so that the user can connect the
846: // formal device number with whatever object is inside their computer.
847: int ata_read_identity(ata_device * device, ata_identify_device * buf, bool fix_swapped_id)
848: {
849: unsigned short *rawshort=(unsigned short *)buf;
850: unsigned char *rawbyte =(unsigned char *)buf;
851:
852: // See if device responds either to IDENTIFY DEVICE or IDENTIFY
853: // PACKET DEVICE
854: bool packet = false;
855: if ((smartcommandhandler(device, IDENTIFY, 0, (char *)buf))){
856: if (smartcommandhandler(device, PIDENTIFY, 0, (char *)buf)){
857: return -1;
858: }
859: packet = true;
860: }
861:
862: unsigned i;
863: if (fix_swapped_id) {
864: // Swap ID strings
865: for (i = 0; i < sizeof(buf->serial_no)-1; i += 2)
866: swap2((char *)(buf->serial_no+i));
867: for (i = 0; i < sizeof(buf->fw_rev)-1; i += 2)
868: swap2((char *)(buf->fw_rev+i));
869: for (i = 0; i < sizeof(buf->model)-1; i += 2)
870: swap2((char *)(buf->model+i));
871: }
872:
873: #ifndef __NetBSD__
874: // if machine is big-endian, swap byte order as needed
875: // NetBSD kernel delivers IDENTIFY data in host byte order
876: // TODO: Handle NetBSD case in os_netbsd.cpp
877: if (isbigendian()){
878:
879: // swap various capability words that are needed
880: for (i=0; i<33; i++)
881: swap2((char *)(buf->words047_079+i));
882:
883: for (i=80; i<=87; i++)
884: swap2((char *)(rawshort+i));
885:
886: for (i=0; i<168; i++)
887: swap2((char *)(buf->words088_255+i));
888: }
889: #endif
890:
891: // If there is a checksum there, validate it
892: if ((rawshort[255] & 0x00ff) == 0x00a5 && checksum(rawbyte))
893: checksumwarning("Drive Identity Structure");
894:
895: // AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
896: // T13/1699-D Revision 6a (Final Draft), September 6, 2008.
897: // Sections 7.16.7 and 7.17.6:
898: //
899: // Word 0 of IDENTIFY DEVICE data:
900: // Bit 15 = 0 : ATA device
901: //
902: // Word 0 of IDENTIFY PACKET DEVICE data:
903: // Bits 15:14 = 10b : ATAPI device
904: // Bits 15:14 = 11b : Reserved
905: // Bits 12:8 : Device type (SPC-4, e.g 0x05 = CD/DVD)
906:
907: // CF+ and CompactFlash Specification Revision 4.0, May 24, 2006.
908: // Section 6.2.1.6:
909: //
910: // Word 0 of IDENTIFY DEVICE data:
911: // 848Ah = Signature for CompactFlash Storage Card
912: // 044Ah = Alternate value turns on ATA device while preserving all retired bits
913: // 0040h = Alternate value turns on ATA device while zeroing all retired bits
914:
915: // Assume ATA if IDENTIFY DEVICE returns CompactFlash Signature
916: if (!packet && rawbyte[1] == 0x84 && rawbyte[0] == 0x8a)
917: return 0;
918:
919: // If this is a PACKET DEVICE, return device type
920: if (rawbyte[1] & 0x80)
921: return 1+(rawbyte[1] & 0x1f);
922:
923: // Not a PACKET DEVICE
924: return 0;
925: }
926:
927: // Returns ATA version as an integer, and a pointer to a string
928: // describing which revision. Note that Revision 0 of ATA-3 does NOT
929: // support SMART. For this one case we return -3 rather than +3 as
930: // the version number. See notes above.
931: int ataVersionInfo(const char ** description, const ata_identify_device * drive, unsigned short * minor)
932: {
933: // get major and minor ATA revision numbers
934: unsigned short major = drive->major_rev_num;
935: *minor=drive->minor_rev_num;
936:
937: // First check if device has ANY ATA version information in it
938: if (major==NOVAL_0 || major==NOVAL_1) {
939: *description=NULL;
940: return 0; // No info found
941: }
942:
943: // The minor revision number has more information - try there first
944: if (*minor && (*minor<=MINOR_MAX)){
945: int std = actual_ver[*minor];
946: if (std) {
947: *description=minor_str[*minor];
948: return std;
949: }
950: }
951:
952: // Try new ATA-8 ACS minor revision numbers.
953: // Table 55 of T13/2015-D Revision 4a (ACS-2), December 9, 2010.
954: // (not in actual_ver/minor_str to avoid large sparse tables)
955: const char *desc;
956: switch (*minor) {
957: case 0x0027: desc = "ATA-8-ACS revision 3c"; break;
958: case 0x0028: desc = "ATA-8-ACS revision 6"; break;
959: case 0x0029: desc = "ATA-8-ACS revision 4"; break;
960: case 0x0031: desc = "ACS-2 revision 2"; break;
961: case 0x0033: desc = "ATA-8-ACS revision 3e"; break;
962: case 0x0039: desc = "ATA-8-ACS revision 4c"; break;
963: case 0x0042: desc = "ATA-8-ACS revision 3f"; break;
964: case 0x0052: desc = "ATA-8-ACS revision 3b"; break;
965: case 0x0107: desc = "ATA-8-ACS revision 2d"; break;
966: case 0x0110: desc = "ACS-2 revision 3"; break;
967: default: desc = 0; break;
968: }
969: if (desc) {
970: *description = desc;
971: return 8;
972: }
973:
974: // HDPARM has a very complicated algorithm from here on. Since SMART only
975: // exists on ATA-3 and later standards, let's punt on this. If you don't
976: // like it, please fix it. The code's in CVS.
977: int i;
978: for (i=15; i>0; i--)
979: if (major & (0x1<<i))
980: break;
981:
982: *description=NULL;
983: if (i==0)
984: return 1;
985: else
986: return i;
987: }
988:
989: // Get World Wide Name (WWN) fields.
990: // Return NAA field or -1 if WWN is unsupported.
991: // Table 34 of T13/1699-D Revision 6a (ATA8-ACS), September 6, 2008.
992: // (WWN was introduced in ATA/ATAPI-7 and is mandatory since ATA8-ACS Revision 3b)
993: int ata_get_wwn(const ata_identify_device * id, unsigned & oui, uint64_t & unique_id)
994: {
995: // Don't use word 84 to be compatible with some older ATA-7 disks
996: unsigned short word087 = id->csf_default;
997: if ((word087 & 0xc100) != 0x4100)
998: return -1; // word not valid or WWN support bit 8 not set
999:
1000: unsigned short word108 = id->words088_255[108-88];
1001: unsigned short word109 = id->words088_255[109-88];
1002: unsigned short word110 = id->words088_255[110-88];
1003: unsigned short word111 = id->words088_255[111-88];
1004:
1005: oui = ((word108 & 0x0fff) << 12) | (word109 >> 4);
1006: unique_id = ((uint64_t)(word109 & 0xf) << 32)
1007: | (unsigned)((word110 << 16) | word111);
1008: return (word108 >> 12);
1009: }
1010:
1011: // returns 1 if SMART supported, 0 if SMART unsupported, -1 if can't tell
1012: int ataSmartSupport(const ata_identify_device * drive)
1013: {
1014: unsigned short word82=drive->command_set_1;
1015: unsigned short word83=drive->command_set_2;
1016:
1017: // check if words 82/83 contain valid info
1018: if ((word83>>14) == 0x01)
1019: // return value of SMART support bit
1020: return word82 & 0x0001;
1021:
1022: // since we can're rely on word 82, we don't know if SMART supported
1023: return -1;
1024: }
1025:
1026: // returns 1 if SMART enabled, 0 if SMART disabled, -1 if can't tell
1027: int ataIsSmartEnabled(const ata_identify_device * drive)
1028: {
1029: unsigned short word85=drive->cfs_enable_1;
1030: unsigned short word87=drive->csf_default;
1031:
1032: // check if words 85/86/87 contain valid info
1033: if ((word87>>14) == 0x01)
1034: // return value of SMART enabled bit
1035: return word85 & 0x0001;
1036:
1037: // Since we can't rely word85, we don't know if SMART is enabled.
1038: return -1;
1039: }
1040:
1041:
1042: // Reads SMART attributes into *data
1043: int ataReadSmartValues(ata_device * device, struct ata_smart_values *data){
1044:
1045: if (smartcommandhandler(device, READ_VALUES, 0, (char *)data)){
1046: pout("Error SMART Values Read failed: %s\n", device->get_errmsg());
1047: return -1;
1048: }
1049:
1050: // compute checksum
1051: if (checksum(data))
1052: checksumwarning("SMART Attribute Data Structure");
1053:
1054: // swap endian order if needed
1055: if (isbigendian()){
1056: int i;
1057: swap2((char *)&(data->revnumber));
1058: swap2((char *)&(data->total_time_to_complete_off_line));
1059: swap2((char *)&(data->smart_capability));
1060: for (i=0; i<NUMBER_ATA_SMART_ATTRIBUTES; i++){
1061: struct ata_smart_attribute *x=data->vendor_attributes+i;
1062: swap2((char *)&(x->flags));
1063: }
1064: }
1065:
1066: return 0;
1067: }
1068:
1069:
1070: // This corrects some quantities that are byte reversed in the SMART
1071: // SELF TEST LOG
1072: static void fixsamsungselftestlog(ata_smart_selftestlog * data)
1073: {
1074: // bytes 508/509 (numbered from 0) swapped (swap of self-test index
1075: // with one byte of reserved.
1076: swap2((char *)&(data->mostrecenttest));
1077:
1078: // LBA low register (here called 'selftestnumber", containing
1079: // information about the TYPE of the self-test) is byte swapped with
1080: // Self-test execution status byte. These are bytes N, N+1 in the
1081: // entries.
1082: for (int i = 0; i < 21; i++)
1083: swap2((char *)&(data->selftest_struct[i].selftestnumber));
1084:
1085: return;
1086: }
1087:
1088: // Reads the Self Test Log (log #6)
1089: int ataReadSelfTestLog (ata_device * device, ata_smart_selftestlog * data,
1090: unsigned char fix_firmwarebug)
1091: {
1092:
1093: // get data from device
1094: if (smartcommandhandler(device, READ_LOG, 0x06, (char *)data)){
1095: pout("Error SMART Error Self-Test Log Read failed: %s\n", device->get_errmsg());
1096: return -1;
1097: }
1098:
1099: // compute its checksum, and issue a warning if needed
1100: if (checksum(data))
1101: checksumwarning("SMART Self-Test Log Structure");
1102:
1103: // fix firmware bugs in self-test log
1104: if (fix_firmwarebug == FIX_SAMSUNG)
1105: fixsamsungselftestlog(data);
1106:
1107: // swap endian order if needed
1108: if (isbigendian()){
1109: int i;
1110: swap2((char*)&(data->revnumber));
1111: for (i=0; i<21; i++){
1112: struct ata_smart_selftestlog_struct *x=data->selftest_struct+i;
1113: swap2((char *)&(x->timestamp));
1114: swap4((char *)&(x->lbafirstfailure));
1115: }
1116: }
1117:
1118: return 0;
1119: }
1120:
1121: // Print checksum warning for multi sector log
1122: static void check_multi_sector_sum(const void * data, unsigned nsectors, const char * msg)
1123: {
1124: unsigned errs = 0;
1125: for (unsigned i = 0; i < nsectors; i++) {
1126: if (checksum((const unsigned char *)data + i*512))
1127: errs++;
1128: }
1129: if (errs > 0) {
1130: if (nsectors == 1)
1131: checksumwarning(msg);
1132: else
1133: checksumwarning(strprintf("%s (%u/%u)", msg, errs, nsectors).c_str());
1134: }
1135: }
1136:
1137: // Read SMART Extended Self-test Log
1138: bool ataReadExtSelfTestLog(ata_device * device, ata_smart_extselftestlog * log,
1139: unsigned nsectors)
1140: {
1141: if (!ataReadLogExt(device, 0x07, 0x00, 0, log, nsectors))
1142: return false;
1143:
1144: check_multi_sector_sum(log, nsectors, "SMART Extended Self-test Log Structure");
1145:
1146: if (isbigendian()) {
1147: swapx(&log->log_desc_index);
1148: for (unsigned i = 0; i < nsectors; i++) {
1149: for (unsigned j = 0; j < 19; j++)
1150: swapx(&log->log_descs[i].timestamp);
1151: }
1152: }
1153: return true;
1154: }
1155:
1156:
1157: // Read GP Log page(s)
1158: bool ataReadLogExt(ata_device * device, unsigned char logaddr,
1159: unsigned char features, unsigned page,
1160: void * data, unsigned nsectors)
1161: {
1162: ata_cmd_in in;
1163: in.in_regs.command = ATA_READ_LOG_EXT;
1164: in.in_regs.features = features; // log specific
1165: in.set_data_in_48bit(data, nsectors);
1166: in.in_regs.lba_low = logaddr;
1167: in.in_regs.lba_mid_16 = page;
1168:
1169: if (!device->ata_pass_through(in)) { // TODO: Debug output
1170: if (nsectors <= 1) {
1171: pout("ATA_READ_LOG_EXT (addr=0x%02x:0x%02x, page=%u, n=%u) failed: %s\n",
1172: logaddr, features, page, nsectors, device->get_errmsg());
1173: return false;
1174: }
1175:
1176: // Recurse to retry with single sectors,
1177: // multi-sector reads may not be supported by ioctl.
1178: for (unsigned i = 0; i < nsectors; i++) {
1179: if (!ataReadLogExt(device, logaddr,
1180: features, page + i,
1181: (char *)data + 512*i, 1))
1182: return false;
1183: }
1184: }
1185:
1186: return true;
1187: }
1188:
1189: // Read SMART Log page(s)
1190: bool ataReadSmartLog(ata_device * device, unsigned char logaddr,
1191: void * data, unsigned nsectors)
1192: {
1193: ata_cmd_in in;
1194: in.in_regs.command = ATA_SMART_CMD;
1195: in.in_regs.features = ATA_SMART_READ_LOG_SECTOR;
1196: in.set_data_in(data, nsectors);
1197: in.in_regs.lba_high = SMART_CYL_HI;
1198: in.in_regs.lba_mid = SMART_CYL_LOW;
1199: in.in_regs.lba_low = logaddr;
1200:
1201: if (!device->ata_pass_through(in)) { // TODO: Debug output
1202: pout("ATA_SMART_READ_LOG failed: %s\n", device->get_errmsg());
1203: return false;
1204: }
1205: return true;
1206: }
1207:
1208:
1209:
1210: // Reads the SMART or GPL Log Directory (log #0)
1211: int ataReadLogDirectory(ata_device * device, ata_smart_log_directory * data, bool gpl)
1212: {
1213: if (!gpl) { // SMART Log directory
1214: if (smartcommandhandler(device, READ_LOG, 0x00, (char *)data))
1215: return -1;
1216: }
1217: else { // GP Log directory
1218: if (!ataReadLogExt(device, 0x00, 0x00, 0, data, 1))
1219: return -1;
1220: }
1221:
1222: // swap endian order if needed
1223: if (isbigendian())
1224: swapx(&data->logversion);
1225:
1226: return 0;
1227: }
1228:
1229:
1230: // Reads the selective self-test log (log #9)
1231: int ataReadSelectiveSelfTestLog(ata_device * device, struct ata_selective_self_test_log *data){
1232:
1233: // get data from device
1234: if (smartcommandhandler(device, READ_LOG, 0x09, (char *)data)){
1235: pout("Error SMART Read Selective Self-Test Log failed: %s\n", device->get_errmsg());
1236: return -1;
1237: }
1238:
1239: // compute its checksum, and issue a warning if needed
1240: if (checksum(data))
1241: checksumwarning("SMART Selective Self-Test Log Structure");
1242:
1243: // swap endian order if needed
1244: if (isbigendian()){
1245: int i;
1246: swap2((char *)&(data->logversion));
1247: for (i=0;i<5;i++){
1248: swap8((char *)&(data->span[i].start));
1249: swap8((char *)&(data->span[i].end));
1250: }
1251: swap8((char *)&(data->currentlba));
1252: swap2((char *)&(data->currentspan));
1253: swap2((char *)&(data->flags));
1254: swap2((char *)&(data->pendingtime));
1255: }
1256:
1257: if (data->logversion != 1)
1258: pout("Note: selective self-test log revision number (%d) not 1 implies that no selective self-test has ever been run\n", data->logversion);
1259:
1260: return 0;
1261: }
1262:
1263: // Writes the selective self-test log (log #9)
1264: int ataWriteSelectiveSelfTestLog(ata_device * device, ata_selective_selftest_args & args,
1265: const ata_smart_values * sv, uint64_t num_sectors,
1266: const ata_selective_selftest_args * prev_args)
1267: {
1268: // Disk size must be known
1269: if (!num_sectors) {
1270: pout("Disk size is unknown, unable to check selective self-test spans\n");
1271: return -1;
1272: }
1273:
1274: // Read log
1275: struct ata_selective_self_test_log sstlog, *data=&sstlog;
1276: unsigned char *ptr=(unsigned char *)data;
1277: if (ataReadSelectiveSelfTestLog(device, data)) {
1278: pout("Since Read failed, will not attempt to WRITE Selective Self-test Log\n");
1279: return -1;
1280: }
1281:
1282: // Set log version
1283: data->logversion = 1;
1284:
1285: // Host is NOT allowed to write selective self-test log if a selective
1286: // self-test is in progress.
1287: if (0<data->currentspan && data->currentspan<6 && ((sv->self_test_exec_status)>>4)==15) {
1288: pout("Error SMART Selective or other Self-Test in progress.\n");
1289: return -4;
1290: }
1291:
1292: // Set start/end values based on old spans for special -t select,... options
1293: int i;
1294: for (i = 0; i < args.num_spans; i++) {
1295: int mode = args.span[i].mode;
1296: uint64_t start = args.span[i].start;
1297: uint64_t end = args.span[i].end;
1298: if (mode == SEL_CONT) {// redo or next dependig on last test status
1299: switch (sv->self_test_exec_status >> 4) {
1300: case 1: case 2: // Aborted/Interrupted by host
1301: pout("Continue Selective Self-Test: Redo last span\n");
1302: mode = SEL_REDO;
1303: break;
1304: default: // All others
1305: pout("Continue Selective Self-Test: Start next span\n");
1306: mode = SEL_NEXT;
1307: break;
1308: }
1309: }
1310:
1311: if ( (mode == SEL_REDO || mode == SEL_NEXT)
1312: && prev_args && i < prev_args->num_spans
1313: && !data->span[i].start && !data->span[i].end) {
1314: // Some drives do not preserve the selective self-test log accross
1315: // power-cyles. If old span on drive is cleared use span provided
1316: // by caller. This is used by smartd (first span only).
1317: data->span[i].start = prev_args->span[i].start;
1318: data->span[i].end = prev_args->span[i].end;
1319: }
1320:
1321: switch (mode) {
1322: case SEL_RANGE: // -t select,START-END
1323: break;
1324: case SEL_REDO: // -t select,redo... => Redo current
1325: start = data->span[i].start;
1326: if (end > 0) { // -t select,redo+SIZE
1327: end--; end += start; // [oldstart, oldstart+SIZE)
1328: }
1329: else // -t select,redo
1330: end = data->span[i].end; // [oldstart, oldend]
1331: break;
1332: case SEL_NEXT: // -t select,next... => Do next
1333: if (data->span[i].end == 0) {
1334: start = end = 0; break; // skip empty spans
1335: }
1336: start = data->span[i].end + 1;
1337: if (start >= num_sectors)
1338: start = 0; // wrap around
1339: if (end > 0) { // -t select,next+SIZE
1340: end--; end += start; // (oldend, oldend+SIZE]
1341: }
1342: else { // -t select,next
1343: uint64_t oldsize = data->span[i].end - data->span[i].start + 1;
1344: end = start + oldsize - 1; // (oldend, oldend+oldsize]
1345: if (end >= num_sectors) {
1346: // Adjust size to allow round-robin testing without future size decrease
1347: uint64_t spans = (num_sectors + oldsize-1) / oldsize;
1348: uint64_t newsize = (num_sectors + spans-1) / spans;
1349: uint64_t newstart = num_sectors - newsize, newend = num_sectors - 1;
1350: pout("Span %d changed from %"PRIu64"-%"PRIu64" (%"PRIu64" sectors)\n",
1351: i, start, end, oldsize);
1352: pout(" to %"PRIu64"-%"PRIu64" (%"PRIu64" sectors) (%"PRIu64" spans)\n",
1353: newstart, newend, newsize, spans);
1354: start = newstart; end = newend;
1355: }
1356: }
1357: break;
1358: default:
1359: pout("ataWriteSelectiveSelfTestLog: Invalid mode %d\n", mode);
1360: return -1;
1361: }
1362: // Range check
1363: if (start < num_sectors && num_sectors <= end) {
1364: if (end != ~(uint64_t)0) // -t select,N-max
1365: pout("Size of self-test span %d decreased according to disk size\n", i);
1366: end = num_sectors - 1;
1367: }
1368: if (!(start <= end && end < num_sectors)) {
1369: pout("Invalid selective self-test span %d: %"PRIu64"-%"PRIu64" (%"PRIu64" sectors)\n",
1370: i, start, end, num_sectors);
1371: return -1;
1372: }
1373: // Return the actual mode and range to caller.
1374: args.span[i].mode = mode;
1375: args.span[i].start = start;
1376: args.span[i].end = end;
1377: }
1378:
1379: // Clear spans
1380: for (i=0; i<5; i++)
1381: memset(data->span+i, 0, sizeof(struct test_span));
1382:
1383: // Set spans for testing
1384: for (i = 0; i < args.num_spans; i++){
1385: data->span[i].start = args.span[i].start;
1386: data->span[i].end = args.span[i].end;
1387: }
1388:
1389: // host must initialize to zero before initiating selective self-test
1390: data->currentlba=0;
1391: data->currentspan=0;
1392:
1393: // Perform off-line scan after selective test?
1394: if (args.scan_after_select == 1)
1395: // NO
1396: data->flags &= ~SELECTIVE_FLAG_DOSCAN;
1397: else if (args.scan_after_select == 2)
1398: // YES
1399: data->flags |= SELECTIVE_FLAG_DOSCAN;
1400:
1401: // Must clear active and pending flags before writing
1402: data->flags &= ~(SELECTIVE_FLAG_ACTIVE);
1403: data->flags &= ~(SELECTIVE_FLAG_PENDING);
1404:
1405: // modify pending time?
1406: if (args.pending_time)
1407: data->pendingtime = (unsigned short)(args.pending_time-1);
1408:
1409: // Set checksum to zero, then compute checksum
1410: data->checksum=0;
1411: unsigned char cksum=0;
1412: for (i=0; i<512; i++)
1413: cksum+=ptr[i];
1414: cksum=~cksum;
1415: cksum+=1;
1416: data->checksum=cksum;
1417:
1418: // swap endian order if needed
1419: if (isbigendian()){
1420: swap2((char *)&(data->logversion));
1421: for (int b = 0; b < 5; b++) {
1422: swap8((char *)&(data->span[b].start));
1423: swap8((char *)&(data->span[b].end));
1424: }
1425: swap8((char *)&(data->currentlba));
1426: swap2((char *)&(data->currentspan));
1427: swap2((char *)&(data->flags));
1428: swap2((char *)&(data->pendingtime));
1429: }
1430:
1431: // write new selective self-test log
1432: if (smartcommandhandler(device, WRITE_LOG, 0x09, (char *)data)){
1433: pout("Error Write Selective Self-Test Log failed: %s\n", device->get_errmsg());
1434: return -3;
1435: }
1436:
1437: return 0;
1438: }
1439:
1440: // This corrects some quantities that are byte reversed in the SMART
1441: // ATA ERROR LOG.
1442: static void fixsamsungerrorlog(ata_smart_errorlog * data)
1443: {
1444: // FIXED IN SAMSUNG -25 FIRMWARE???
1445: // Device error count in bytes 452-3
1446: swap2((char *)&(data->ata_error_count));
1447:
1448: // FIXED IN SAMSUNG -22a FIRMWARE
1449: // step through 5 error log data structures
1450: for (int i = 0; i < 5; i++){
1451: // step through 5 command data structures
1452: for (int j = 0; j < 5; j++)
1453: // Command data structure 4-byte millisec timestamp. These are
1454: // bytes (N+8, N+9, N+10, N+11).
1455: swap4((char *)&(data->errorlog_struct[i].commands[j].timestamp));
1456: // Error data structure two-byte hour life timestamp. These are
1457: // bytes (N+28, N+29).
1458: swap2((char *)&(data->errorlog_struct[i].error_struct.timestamp));
1459: }
1460: return;
1461: }
1462:
1463: // NEEDED ONLY FOR SAMSUNG -22 (some) -23 AND -24?? FIRMWARE
1464: static void fixsamsungerrorlog2(ata_smart_errorlog * data)
1465: {
1466: // Device error count in bytes 452-3
1467: swap2((char *)&(data->ata_error_count));
1468: return;
1469: }
1470:
1471: // Reads the Summary SMART Error Log (log #1). The Comprehensive SMART
1472: // Error Log is #2, and the Extended Comprehensive SMART Error log is
1473: // #3
1474: int ataReadErrorLog (ata_device * device, ata_smart_errorlog *data,
1475: unsigned char fix_firmwarebug)
1476: {
1477:
1478: // get data from device
1479: if (smartcommandhandler(device, READ_LOG, 0x01, (char *)data)){
1480: pout("Error SMART Error Log Read failed: %s\n", device->get_errmsg());
1481: return -1;
1482: }
1483:
1484: // compute its checksum, and issue a warning if needed
1485: if (checksum(data))
1486: checksumwarning("SMART ATA Error Log Structure");
1487:
1488: // Some disks have the byte order reversed in some SMART Summary
1489: // Error log entries
1490: if (fix_firmwarebug == FIX_SAMSUNG)
1491: fixsamsungerrorlog(data);
1492: else if (fix_firmwarebug == FIX_SAMSUNG2)
1493: fixsamsungerrorlog2(data);
1494:
1495: // swap endian order if needed
1496: if (isbigendian()){
1497: int i,j;
1498:
1499: // Device error count in bytes 452-3
1500: swap2((char *)&(data->ata_error_count));
1501:
1502: // step through 5 error log data structures
1503: for (i=0; i<5; i++){
1504: // step through 5 command data structures
1505: for (j=0; j<5; j++)
1506: // Command data structure 4-byte millisec timestamp
1507: swap4((char *)&(data->errorlog_struct[i].commands[j].timestamp));
1508: // Error data structure life timestamp
1509: swap2((char *)&(data->errorlog_struct[i].error_struct.timestamp));
1510: }
1511: }
1512:
1513: return 0;
1514: }
1515:
1516: // Read Extended Comprehensive Error Log
1517: bool ataReadExtErrorLog(ata_device * device, ata_smart_exterrlog * log,
1518: unsigned nsectors)
1519: {
1520: if (!ataReadLogExt(device, 0x03, 0x00, 0, log, nsectors))
1521: return false;
1522:
1523: check_multi_sector_sum(log, nsectors, "SMART Extended Comprehensive Error Log Structure");
1524:
1525: if (isbigendian()) {
1526: swapx(&log->device_error_count);
1527: swapx(&log->error_log_index);
1528:
1529: for (unsigned i = 0; i < nsectors; i++) {
1530: for (unsigned j = 0; j < 4; j++)
1531: swapx(&log->error_logs[i].commands[j].timestamp);
1532: swapx(&log->error_logs[i].error.timestamp);
1533: }
1534: }
1535:
1536: return true;
1537: }
1538:
1539:
1540: int ataReadSmartThresholds (ata_device * device, struct ata_smart_thresholds_pvt *data){
1541:
1542: // get data from device
1543: if (smartcommandhandler(device, READ_THRESHOLDS, 0, (char *)data)){
1544: pout("Error SMART Thresholds Read failed: %s\n", device->get_errmsg());
1545: return -1;
1546: }
1547:
1548: // compute its checksum, and issue a warning if needed
1549: if (checksum(data))
1550: checksumwarning("SMART Attribute Thresholds Structure");
1551:
1552: // swap endian order if needed
1553: if (isbigendian())
1554: swap2((char *)&(data->revnumber));
1555:
1556: return 0;
1557: }
1558:
1559: int ataEnableSmart (ata_device * device ){
1560: if (smartcommandhandler(device, ENABLE, 0, NULL)){
1561: pout("Error SMART Enable failed: %s\n", device->get_errmsg());
1562: return -1;
1563: }
1564: return 0;
1565: }
1566:
1567: int ataDisableSmart (ata_device * device ){
1568:
1569: if (smartcommandhandler(device, DISABLE, 0, NULL)){
1570: pout("Error SMART Disable failed: %s\n", device->get_errmsg());
1571: return -1;
1572: }
1573: return 0;
1574: }
1575:
1576: int ataEnableAutoSave(ata_device * device){
1577: if (smartcommandhandler(device, AUTOSAVE, 241, NULL)){
1578: pout("Error SMART Enable Auto-save failed: %s\n", device->get_errmsg());
1579: return -1;
1580: }
1581: return 0;
1582: }
1583:
1584: int ataDisableAutoSave(ata_device * device){
1585:
1586: if (smartcommandhandler(device, AUTOSAVE, 0, NULL)){
1587: pout("Error SMART Disable Auto-save failed: %s\n", device->get_errmsg());
1588: return -1;
1589: }
1590: return 0;
1591: }
1592:
1593: // In *ALL* ATA standards the Enable/Disable AutoOffline command is
1594: // marked "OBSOLETE". It is defined in SFF-8035i Revision 2, and most
1595: // vendors still support it for backwards compatibility. IBM documents
1596: // it for some drives.
1597: int ataEnableAutoOffline (ata_device * device){
1598:
1599: /* timer hard coded to 4 hours */
1600: if (smartcommandhandler(device, AUTO_OFFLINE, 248, NULL)){
1601: pout("Error SMART Enable Automatic Offline failed: %s\n", device->get_errmsg());
1602: return -1;
1603: }
1604: return 0;
1605: }
1606:
1607: // Another Obsolete Command. See comments directly above, associated
1608: // with the corresponding Enable command.
1609: int ataDisableAutoOffline (ata_device * device){
1610:
1611: if (smartcommandhandler(device, AUTO_OFFLINE, 0, NULL)){
1612: pout("Error SMART Disable Automatic Offline failed: %s\n", device->get_errmsg());
1613: return -1;
1614: }
1615: return 0;
1616: }
1617:
1618: // If SMART is enabled, supported, and working, then this call is
1619: // guaranteed to return 1, else zero. Note that it should return 1
1620: // regardless of whether the disk's SMART status is 'healthy' or
1621: // 'failing'.
1622: int ataDoesSmartWork(ata_device * device){
1623: int retval=smartcommandhandler(device, STATUS, 0, NULL);
1624:
1625: if (-1 == retval)
1626: return 0;
1627:
1628: return 1;
1629: }
1630:
1631: // This function uses a different interface (DRIVE_TASK) than the
1632: // other commands in this file.
1633: int ataSmartStatus2(ata_device * device){
1634: return smartcommandhandler(device, STATUS_CHECK, 0, NULL);
1635: }
1636:
1637: // This is the way to execute ALL tests: offline, short self-test,
1638: // extended self test, with and without captive mode, etc.
1639: // TODO: Move to ataprint.cpp ?
1640: int ataSmartTest(ata_device * device, int testtype, const ata_selective_selftest_args & selargs,
1641: const ata_smart_values * sv, uint64_t num_sectors)
1642: {
1643: char cmdmsg[128]; const char *type, *captive;
1644: int cap, retval, select=0;
1645:
1646: // Boolean, if set, says test is captive
1647: cap=testtype & CAPTIVE_MASK;
1648:
1649: // Set up strings that describe the type of test
1650: if (cap)
1651: captive="captive";
1652: else
1653: captive="off-line";
1654:
1655: if (testtype==OFFLINE_FULL_SCAN)
1656: type="off-line";
1657: else if (testtype==SHORT_SELF_TEST || testtype==SHORT_CAPTIVE_SELF_TEST)
1658: type="Short self-test";
1659: else if (testtype==EXTEND_SELF_TEST || testtype==EXTEND_CAPTIVE_SELF_TEST)
1660: type="Extended self-test";
1661: else if (testtype==CONVEYANCE_SELF_TEST || testtype==CONVEYANCE_CAPTIVE_SELF_TEST)
1662: type="Conveyance self-test";
1663: else if ((select=(testtype==SELECTIVE_SELF_TEST || testtype==SELECTIVE_CAPTIVE_SELF_TEST)))
1664: type="Selective self-test";
1665: else
1666: type = 0;
1667:
1668: // If doing a selective self-test, first use WRITE_LOG to write the
1669: // selective self-test log.
1670: ata_selective_selftest_args selargs_io = selargs; // filled with info about actual spans
1671: if (select && (retval = ataWriteSelectiveSelfTestLog(device, selargs_io, sv, num_sectors))) {
1672: if (retval==-4)
1673: pout("Can't start selective self-test without aborting current test: use '-X' option to smartctl.\n");
1674: return retval;
1675: }
1676:
1677: // Print ouf message that we are sending the command to test
1678: if (testtype==ABORT_SELF_TEST)
1679: sprintf(cmdmsg,"Abort SMART off-line mode self-test routine");
1680: else if (!type)
1681: sprintf(cmdmsg, "SMART EXECUTE OFF-LINE IMMEDIATE subcommand 0x%02x", testtype);
1682: else
1683: sprintf(cmdmsg,"Execute SMART %s routine immediately in %s mode",type,captive);
1684: pout("Sending command: \"%s\".\n",cmdmsg);
1685:
1686: if (select) {
1687: int i;
1688: pout("SPAN STARTING_LBA ENDING_LBA\n");
1689: for (i = 0; i < selargs_io.num_spans; i++)
1690: pout(" %d %20"PRId64" %20"PRId64"\n", i,
1691: selargs_io.span[i].start,
1692: selargs_io.span[i].end);
1693: }
1694:
1695: // Now send the command to test
1696: if (smartcommandhandler(device, IMMEDIATE_OFFLINE, testtype, NULL)) {
1697: if (!(cap && device->get_errno() == EIO)) {
1698: pout("Command \"%s\" failed: %s\n", cmdmsg, device->get_errmsg());
1699: return -1;
1700: }
1701: }
1702:
1703: // Since the command succeeded, tell user
1704: if (testtype==ABORT_SELF_TEST)
1705: pout("Self-testing aborted!\n");
1706: else {
1707: pout("Drive command \"%s\" successful.\n", cmdmsg);
1708: if (type)
1709: pout("Testing has begun.\n");
1710: }
1711: return 0;
1712: }
1713:
1714: /* Test Time Functions */
1715: int TestTime(const ata_smart_values *data, int testtype)
1716: {
1717: switch (testtype){
1718: case OFFLINE_FULL_SCAN:
1719: return (int) data->total_time_to_complete_off_line;
1720: case SHORT_SELF_TEST:
1721: case SHORT_CAPTIVE_SELF_TEST:
1722: return (int) data->short_test_completion_time;
1723: case EXTEND_SELF_TEST:
1724: case EXTEND_CAPTIVE_SELF_TEST:
1725: return (int) data->extend_test_completion_time;
1726: case CONVEYANCE_SELF_TEST:
1727: case CONVEYANCE_CAPTIVE_SELF_TEST:
1728: return (int) data->conveyance_test_completion_time;
1729: default:
1730: return 0;
1731: }
1732: }
1733:
1734: // This function tells you both about the ATA error log and the
1735: // self-test error log capability (introduced in ATA-5). The bit is
1736: // poorly documented in the ATA/ATAPI standard. Starting with ATA-6,
1737: // SMART error logging is also indicated in bit 0 of DEVICE IDENTIFY
1738: // word 84 and 87. Top two bits must match the pattern 01. BEFORE
1739: // ATA-6 these top two bits still had to match the pattern 01, but the
1740: // remaining bits were reserved (==0).
1741: int isSmartErrorLogCapable (const ata_smart_values * data, const ata_identify_device * identity)
1742: {
1743: unsigned short word84=identity->command_set_extension;
1744: unsigned short word87=identity->csf_default;
1745: int isata6=identity->major_rev_num & (0x01<<6);
1746: int isata7=identity->major_rev_num & (0x01<<7);
1747:
1748: if ((isata6 || isata7) && (word84>>14) == 0x01 && (word84 & 0x01))
1749: return 1;
1750:
1751: if ((isata6 || isata7) && (word87>>14) == 0x01 && (word87 & 0x01))
1752: return 1;
1753:
1754: // otherwise we'll use the poorly documented capability bit
1755: return data->errorlog_capability & 0x01;
1756: }
1757:
1758: // See previous function. If the error log exists then the self-test
1759: // log should (must?) also exist.
1760: int isSmartTestLogCapable (const ata_smart_values * data, const ata_identify_device *identity)
1761: {
1762: unsigned short word84=identity->command_set_extension;
1763: unsigned short word87=identity->csf_default;
1764: int isata6=identity->major_rev_num & (0x01<<6);
1765: int isata7=identity->major_rev_num & (0x01<<7);
1766:
1767: if ((isata6 || isata7) && (word84>>14) == 0x01 && (word84 & 0x02))
1768: return 1;
1769:
1770: if ((isata6 || isata7) && (word87>>14) == 0x01 && (word87 & 0x02))
1771: return 1;
1772:
1773:
1774: // otherwise we'll use the poorly documented capability bit
1775: return data->errorlog_capability & 0x01;
1776: }
1777:
1778:
1779: int isGeneralPurposeLoggingCapable(const ata_identify_device *identity)
1780: {
1781: unsigned short word84=identity->command_set_extension;
1782: unsigned short word87=identity->csf_default;
1783:
1784: // If bit 14 of word 84 is set to one and bit 15 of word 84 is
1785: // cleared to zero, the contents of word 84 contains valid support
1786: // information. If not, support information is not valid in this
1787: // word.
1788: if ((word84>>14) == 0x01)
1789: // If bit 5 of word 84 is set to one, the device supports the
1790: // General Purpose Logging feature set.
1791: return (word84 & (0x01 << 5));
1792:
1793: // If bit 14 of word 87 is set to one and bit 15 of word 87 is
1794: // cleared to zero, the contents of words (87:85) contain valid
1795: // information. If not, information is not valid in these words.
1796: if ((word87>>14) == 0x01)
1797: // If bit 5 of word 87 is set to one, the device supports
1798: // the General Purpose Logging feature set.
1799: return (word87 & (0x01 << 5));
1800:
1801: // not capable
1802: return 0;
1803: }
1804:
1805:
1806: // SMART self-test capability is also indicated in bit 1 of DEVICE
1807: // IDENTIFY word 87 (if top two bits of word 87 match pattern 01).
1808: // However this was only introduced in ATA-6 (but self-test log was in
1809: // ATA-5).
1810: int isSupportExecuteOfflineImmediate(const ata_smart_values *data)
1811: {
1812: return data->offline_data_collection_capability & 0x01;
1813: }
1814:
1815: // Note in the ATA-5 standard, the following bit is listed as "Vendor
1816: // Specific". So it may not be reliable. The only use of this that I
1817: // have found is in IBM drives, where it is well-documented. See for
1818: // example page 170, section 13.32.1.18 of the IBM Travelstar 40GNX
1819: // hard disk drive specifications page 164 Revision 1.1 22 Apr 2002.
1820: int isSupportAutomaticTimer(const ata_smart_values * data)
1821: {
1822: return data->offline_data_collection_capability & 0x02;
1823: }
1824: int isSupportOfflineAbort(const ata_smart_values *data)
1825: {
1826: return data->offline_data_collection_capability & 0x04;
1827: }
1828: int isSupportOfflineSurfaceScan(const ata_smart_values * data)
1829: {
1830: return data->offline_data_collection_capability & 0x08;
1831: }
1832: int isSupportSelfTest (const ata_smart_values * data)
1833: {
1834: return data->offline_data_collection_capability & 0x10;
1835: }
1836: int isSupportConveyanceSelfTest(const ata_smart_values * data)
1837: {
1838: return data->offline_data_collection_capability & 0x20;
1839: }
1840: int isSupportSelectiveSelfTest(const ata_smart_values * data)
1841: {
1842: return data->offline_data_collection_capability & 0x40;
1843: }
1844:
1845: // Get attribute state
1846: ata_attr_state ata_get_attr_state(const ata_smart_attribute & attr,
1847: int attridx,
1848: const ata_smart_threshold_entry * thresholds,
1849: const ata_vendor_attr_defs & defs,
1850: unsigned char * threshval /* = 0 */)
1851: {
1852: if (!attr.id)
1853: return ATTRSTATE_NON_EXISTING;
1854:
1855: // Normalized values (current,worst,threshold) not valid
1856: // if specified by '-v' option.
1857: // (Some SSD disks uses these bytes to store raw value).
1858: if (defs[attr.id].flags & ATTRFLAG_NO_NORMVAL)
1859: return ATTRSTATE_NO_NORMVAL;
1860:
1861: // Normally threshold is at same index as attribute
1862: int i = attridx;
1863: if (thresholds[i].id != attr.id) {
1864: // Find threshold id in table
1865: for (i = 0; thresholds[i].id != attr.id; ) {
1866: if (++i >= NUMBER_ATA_SMART_ATTRIBUTES)
1867: // Threshold id missing or thresholds cannot be read
1868: return ATTRSTATE_NO_THRESHOLD;
1869: }
1870: }
1871: unsigned char threshold = thresholds[i].threshold;
1872:
1873: // Return threshold if requested
1874: if (threshval)
1875: *threshval = threshold;
1876:
1877: // Don't report a failed attribute if its threshold is 0.
1878: // ATA-3 (X3T13/2008D Revision 7b) declares 0x00 as the "always passing"
1879: // threshold (Later ATA versions declare all thresholds as "obsolete").
1880: // In practice, threshold value 0 is often used for usage attributes.
1881: if (!threshold)
1882: return ATTRSTATE_OK;
1883:
1884: // Failed now if current value is below threshold
1885: if (attr.current <= threshold)
1886: return ATTRSTATE_FAILED_NOW;
1887:
1888: // Failed in the past if worst value is below threshold
1889: if (!(defs[attr.id].flags & ATTRFLAG_NO_WORSTVAL) && attr.worst <= threshold)
1890: return ATTRSTATE_FAILED_PAST;
1891:
1892: return ATTRSTATE_OK;
1893: }
1894:
1895: // Get default raw value print format
1896: static ata_attr_raw_format get_default_raw_format(unsigned char id)
1897: {
1898: switch (id) {
1899: case 3: // Spin-up time
1900: return RAWFMT_RAW16_OPT_AVG16;
1901:
1902: case 5: // Reallocated sector count
1903: case 196: // Reallocated event count
1904: return RAWFMT_RAW16_OPT_RAW16;
1905:
1906: case 190: // Temperature
1907: case 194:
1908: return RAWFMT_TEMPMINMAX;
1909:
1910: default:
1911: return RAWFMT_RAW48;
1912: }
1913: }
1914:
1915: // Get attribute raw value.
1916: uint64_t ata_get_attr_raw_value(const ata_smart_attribute & attr,
1917: const ata_vendor_attr_defs & defs)
1918: {
1919: const ata_vendor_attr_defs::entry & def = defs[attr.id];
1920:
1921: // Use default byteorder if not specified
1922: const char * byteorder = def.byteorder;
1923: if (!*byteorder) {
1924: switch (def.raw_format) {
1925: case RAWFMT_RAW64:
1926: case RAWFMT_HEX64:
1927: byteorder = "543210wv"; break;
1928: case RAWFMT_RAW24_DIV_RAW32:
1929: case RAWFMT_MSEC24_HOUR32:
1930: byteorder = "r543210"; break;
1931: default:
1932: byteorder = "543210"; break;
1933: }
1934: }
1935:
1936: // Build 64-bit value from selected bytes
1937: uint64_t rawvalue = 0;
1938: for (int i = 0; byteorder[i]; i++) {
1939: unsigned char b;
1940: switch (byteorder[i]) {
1941: case '0': b = attr.raw[0]; break;
1942: case '1': b = attr.raw[1]; break;
1943: case '2': b = attr.raw[2]; break;
1944: case '3': b = attr.raw[3]; break;
1945: case '4': b = attr.raw[4]; break;
1946: case '5': b = attr.raw[5]; break;
1947: case 'r': b = attr.reserv; break;
1948: case 'v': b = attr.current; break;
1949: case 'w': b = attr.worst; break;
1950: default : b = 0; break;
1951: }
1952: rawvalue <<= 8; rawvalue |= b;
1953: }
1954:
1955: return rawvalue;
1956: }
1957:
1958:
1959: // Format attribute raw value.
1960: std::string ata_format_attr_raw_value(const ata_smart_attribute & attr,
1961: const ata_vendor_attr_defs & defs)
1962: {
1963: // Get 48 bit or 64 bit raw value
1964: uint64_t rawvalue = ata_get_attr_raw_value(attr, defs);
1965:
1966: // Split into bytes and words
1967: unsigned char raw[6];
1968: raw[0] = (unsigned char) rawvalue;
1969: raw[1] = (unsigned char)(rawvalue >> 8);
1970: raw[2] = (unsigned char)(rawvalue >> 16);
1971: raw[3] = (unsigned char)(rawvalue >> 24);
1972: raw[4] = (unsigned char)(rawvalue >> 32);
1973: raw[5] = (unsigned char)(rawvalue >> 40);
1974: unsigned word[3];
1975: word[0] = raw[0] | (raw[1] << 8);
1976: word[1] = raw[2] | (raw[3] << 8);
1977: word[2] = raw[4] | (raw[5] << 8);
1978:
1979: // Get print format
1980: ata_attr_raw_format format = defs[attr.id].raw_format;
1981: if (format == RAWFMT_DEFAULT)
1982: format = get_default_raw_format(attr.id);
1983:
1984: // Print
1985: std::string s;
1986: switch (format) {
1987: case RAWFMT_RAW8:
1988: s = strprintf("%d %d %d %d %d %d",
1989: raw[5], raw[4], raw[3], raw[2], raw[1], raw[0]);
1990: break;
1991:
1992: case RAWFMT_RAW16:
1993: s = strprintf("%u %u %u", word[2], word[1], word[0]);
1994: break;
1995:
1996: case RAWFMT_RAW48:
1997: case RAWFMT_RAW64:
1998: s = strprintf("%"PRIu64, rawvalue);
1999: break;
2000:
2001: case RAWFMT_HEX48:
2002: s = strprintf("0x%012"PRIx64, rawvalue);
2003: break;
2004:
2005: case RAWFMT_HEX64:
2006: s = strprintf("0x%016"PRIx64, rawvalue);
2007: break;
2008:
2009: case RAWFMT_RAW16_OPT_RAW16:
2010: s = strprintf("%u", word[0]);
2011: if (word[1] || word[2])
2012: s += strprintf(" (%u, %u)", word[2], word[1]);
2013: break;
2014:
2015: case RAWFMT_RAW16_OPT_AVG16:
2016: s = strprintf("%u", word[0]);
2017: if (word[1])
2018: s += strprintf(" (Average %u)", word[1]);
2019: break;
2020:
2021: case RAWFMT_RAW24_DIV_RAW24:
2022: s = strprintf("%u/%u",
2023: (unsigned)(rawvalue >> 24), (unsigned)(rawvalue & 0x00ffffffULL));
2024: break;
2025:
2026: case RAWFMT_RAW24_DIV_RAW32:
2027: s = strprintf("%u/%u",
2028: (unsigned)(rawvalue >> 32), (unsigned)(rawvalue & 0xffffffffULL));
2029: break;
2030:
2031: case RAWFMT_MIN2HOUR:
2032: {
2033: // minutes
2034: int64_t temp = word[0]+(word[1]<<16);
2035: int64_t tmp1 = temp/60;
2036: int64_t tmp2 = temp%60;
2037: s = strprintf("%"PRIu64"h+%02"PRIu64"m", tmp1, tmp2);
2038: if (word[2])
2039: s += strprintf(" (%u)", word[2]);
2040: }
2041: break;
2042:
2043: case RAWFMT_SEC2HOUR:
2044: {
2045: // seconds
2046: int64_t hours = rawvalue/3600;
2047: int64_t minutes = (rawvalue-3600*hours)/60;
2048: int64_t seconds = rawvalue%60;
2049: s = strprintf("%"PRIu64"h+%02"PRIu64"m+%02"PRIu64"s", hours, minutes, seconds);
2050: }
2051: break;
2052:
2053: case RAWFMT_HALFMIN2HOUR:
2054: {
2055: // 30-second counter
2056: int64_t hours = rawvalue/120;
2057: int64_t minutes = (rawvalue-120*hours)/2;
2058: s += strprintf("%"PRIu64"h+%02"PRIu64"m", hours, minutes);
2059: }
2060: break;
2061:
2062: case RAWFMT_MSEC24_HOUR32:
2063: {
2064: // hours + milliseconds
2065: unsigned hours = (unsigned)(rawvalue & 0xffffffffULL);
2066: unsigned milliseconds = (unsigned)(rawvalue >> 32);
2067: unsigned seconds = milliseconds / 1000;
2068: s = strprintf("%uh+%02um+%02u.%03us",
2069: hours, seconds / 60, seconds % 60, milliseconds % 1000);
2070: }
2071: break;
2072:
2073: case RAWFMT_TEMPMINMAX:
2074: // Temperature
2075: {
2076: // Search for possible min/max values
2077: // 00 HH 00 LL 00 TT (Hitachi/IBM)
2078: // 00 00 HH LL 00 TT (Maxtor, Samsung)
2079: // 00 00 00 HH LL TT (WDC)
2080: unsigned char lo = 0, hi = 0;
2081: int cnt = 0;
2082: for (int i = 1; i < 6; i++) {
2083: if (raw[i])
2084: switch (cnt++) {
2085: case 0:
2086: lo = raw[i];
2087: break;
2088: case 1:
2089: if (raw[i] < lo) {
2090: hi = lo; lo = raw[i];
2091: }
2092: else
2093: hi = raw[i];
2094: break;
2095: }
2096: }
2097:
2098: unsigned char t = raw[0];
2099: if (cnt == 0)
2100: s = strprintf("%d", t);
2101: else if (cnt == 2 && 0 < lo && lo <= t && t <= hi && hi < 128)
2102: s = strprintf("%d (Min/Max %d/%d)", t, lo, hi);
2103: else
2104: s = strprintf("%d (%d %d %d %d %d)", t, raw[5], raw[4], raw[3], raw[2], raw[1]);
2105: }
2106: break;
2107:
2108: case RAWFMT_TEMP10X:
2109: // ten times temperature in Celsius
2110: s = strprintf("%d.%d", word[0]/10, word[0]%10);
2111: break;
2112:
2113: default:
2114: s = "?"; // Should not happen
2115: break;
2116: }
2117:
2118: return s;
2119: }
2120:
2121: // Attribute names shouldn't be longer than 23 chars, otherwise they break the
2122: // output of smartctl.
2123: static const char * get_default_attr_name(unsigned char id)
2124: {
2125: switch (id) {
2126: case 1:
2127: return "Raw_Read_Error_Rate";
2128: case 2:
2129: return "Throughput_Performance";
2130: case 3:
2131: return "Spin_Up_Time";
2132: case 4:
2133: return "Start_Stop_Count";
2134: case 5:
2135: return "Reallocated_Sector_Ct";
2136: case 6:
2137: return "Read_Channel_Margin";
2138: case 7:
2139: return "Seek_Error_Rate";
2140: case 8:
2141: return "Seek_Time_Performance";
2142: case 9:
2143: return "Power_On_Hours";
2144: case 10:
2145: return "Spin_Retry_Count";
2146: case 11:
2147: return "Calibration_Retry_Count";
2148: case 12:
2149: return "Power_Cycle_Count";
2150: case 13:
2151: return "Read_Soft_Error_Rate";
2152: case 175:
2153: return "Program_Fail_Count_Chip";
2154: case 176:
2155: return "Erase_Fail_Count_Chip";
2156: case 177:
2157: return "Wear_Leveling_Count";
2158: case 178:
2159: return "Used_Rsvd_Blk_Cnt_Chip";
2160: case 179:
2161: return "Used_Rsvd_Blk_Cnt_Tot";
2162: case 180:
2163: return "Unused_Rsvd_Blk_Cnt_Tot";
2164: case 181:
2165: return "Program_Fail_Cnt_Total";
2166: case 182:
2167: return "Erase_Fail_Count_Total";
2168: case 183:
2169: return "Runtime_Bad_Block";
2170: case 184:
2171: return "End-to-End_Error";
2172: case 187:
2173: return "Reported_Uncorrect";
2174: case 188:
2175: return "Command_Timeout";
2176: case 189:
2177: return "High_Fly_Writes";
2178: case 190:
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";
2187: case 191:
2188: return "G-Sense_Error_Rate";
2189: case 192:
2190: return "Power-Off_Retract_Count";
2191: case 193:
2192: return "Load_Cycle_Count";
2193: case 194:
2194: return "Temperature_Celsius";
2195: case 195:
2196: // Fujitsu: "ECC_On_The_Fly_Count";
2197: return "Hardware_ECC_Recovered";
2198: case 196:
2199: return "Reallocated_Event_Count";
2200: case 197:
2201: return "Current_Pending_Sector";
2202: case 198:
2203: return "Offline_Uncorrectable";
2204: case 199:
2205: return "UDMA_CRC_Error_Count";
2206: case 200:
2207: // Western Digital
2208: return "Multi_Zone_Error_Rate";
2209: case 201:
2210: return "Soft_Read_Error_Rate";
2211: case 202:
2212: // Fujitsu: "TA_Increase_Count"
2213: return "Data_Address_Mark_Errs";
2214: case 203:
2215: // Fujitsu
2216: return "Run_Out_Cancel";
2217: // Maxtor: ECC Errors
2218: case 204:
2219: // Fujitsu: "Shock_Count_Write_Opern"
2220: return "Soft_ECC_Correction";
2221: case 205:
2222: // Fujitsu: "Shock_Rate_Write_Opern"
2223: return "Thermal_Asperity_Rate";
2224: case 206:
2225: // Fujitsu
2226: return "Flying_Height";
2227: case 207:
2228: // Maxtor
2229: return "Spin_High_Current";
2230: case 208:
2231: // Maxtor
2232: return "Spin_Buzz";
2233: case 209:
2234: // Maxtor
2235: return "Offline_Seek_Performnce";
2236: case 220:
2237: return "Disk_Shift";
2238: case 221:
2239: return "G-Sense_Error_Rate";
2240: case 222:
2241: return "Loaded_Hours";
2242: case 223:
2243: return "Load_Retry_Count";
2244: case 224:
2245: return "Load_Friction";
2246: case 225:
2247: return "Load_Cycle_Count";
2248: case 226:
2249: return "Load-in_Time";
2250: case 227:
2251: return "Torq-amp_Count";
2252: case 228:
2253: return "Power-off_Retract_Count";
2254: case 230:
2255: // seen in IBM DTPA-353750
2256: return "Head_Amplitude";
2257: case 231:
2258: return "Temperature_Celsius";
2259: case 232:
2260: // seen in Intel X25-E SSD
2261: return "Available_Reservd_Space";
2262: case 233:
2263: // seen in Intel X25-E SSD
2264: return "Media_Wearout_Indicator";
2265: case 240:
2266: return "Head_Flying_Hours";
2267: case 241:
2268: return "Total_LBAs_Written";
2269: case 242:
2270: return "Total_LBAs_Read";
2271: case 250:
2272: return "Read_Error_Retry_Rate";
2273: case 254:
2274: return "Free_Fall_Sensor";
2275: default:
2276: return "Unknown_Attribute";
2277: }
2278: }
2279:
2280: // Get attribute name
2281: std::string ata_get_smart_attr_name(unsigned char id, const ata_vendor_attr_defs & defs)
2282: {
2283: if (!defs[id].name.empty())
2284: return defs[id].name;
2285: else
2286: return get_default_attr_name(id);
2287: }
2288:
2289: // Find attribute index for attribute id, -1 if not found.
2290: int ata_find_attr_index(unsigned char id, const ata_smart_values & smartval)
2291: {
2292: if (!id)
2293: return -1;
2294: for (int i = 0; i < NUMBER_ATA_SMART_ATTRIBUTES; i++) {
2295: if (smartval.vendor_attributes[i].id == id)
2296: return i;
2297: }
2298: return -1;
2299: }
2300:
2301: // Return Temperature Attribute raw value selected according to possible
2302: // non-default interpretations. If the Attribute does not exist, return 0
2303: unsigned char ata_return_temperature_value(const ata_smart_values * data, const ata_vendor_attr_defs & defs)
2304: {
2305: for (int i = 0; i < 3; i++) {
2306: static const unsigned char ids[3] = {194, 9, 220};
2307: unsigned char id = ids[i];
2308: const ata_attr_raw_format format = defs[id].raw_format;
2309: if (!( (id == 194 && format == RAWFMT_DEFAULT)
2310: || format == RAWFMT_TEMPMINMAX || format == RAWFMT_TEMP10X))
2311: continue;
2312: int idx = ata_find_attr_index(id, *data);
2313: if (idx < 0)
2314: continue;
2315: uint64_t raw = ata_get_attr_raw_value(data->vendor_attributes[idx], defs);
2316: unsigned temp;
2317: // ignore possible min/max values in high words
2318: if (format == RAWFMT_TEMP10X) // -v N,temp10x
2319: temp = ((unsigned short)raw + 5) / 10;
2320: else
2321: temp = (unsigned char)raw;
2322: if (!(0 < temp && temp < 128))
2323: continue;
2324: return temp;
2325: }
2326: // No valid attribute found
2327: return 0;
2328: }
2329:
2330:
2331: // Read SCT Status
2332: int ataReadSCTStatus(ata_device * device, ata_sct_status_response * sts)
2333: {
2334: // read SCT status via SMART log 0xe0
2335: memset(sts, 0, sizeof(*sts));
2336: if (smartcommandhandler(device, READ_LOG, 0xe0, (char *)sts)){
2337: pout("Error Read SCT Status failed: %s\n", device->get_errmsg());
2338: return -1;
2339: }
2340:
2341: // swap endian order if needed
2342: if (isbigendian()){
2343: swapx(&sts->format_version);
2344: swapx(&sts->sct_version);
2345: swapx(&sts->sct_spec);
2346: swapx(&sts->ext_status_code);
2347: swapx(&sts->action_code);
2348: swapx(&sts->function_code);
2349: swapx(&sts->over_limit_count);
2350: swapx(&sts->under_limit_count);
2351: }
2352:
2353: // Check format version
2354: if (!(sts->format_version == 2 || sts->format_version == 3)) {
2355: pout("Error unknown SCT Status format version %u, should be 2 or 3.\n", sts->format_version);
2356: return -1;
2357: }
2358: return 0;
2359: }
2360:
2361: // Read SCT Temperature History Table and Status
2362: int ataReadSCTTempHist(ata_device * device, ata_sct_temperature_history_table * tmh,
2363: ata_sct_status_response * sts)
2364: {
2365: // Check initial status
2366: if (ataReadSCTStatus(device, sts))
2367: return -1;
2368:
2369: // Do nothing if other SCT command is executing
2370: if (sts->ext_status_code == 0xffff) {
2371: pout("Another SCT command is executing, abort Read Data Table\n"
2372: "(SCT ext_status_code 0x%04x, action_code=%u, function_code=%u)\n",
2373: sts->ext_status_code, sts->action_code, sts->function_code);
2374: return -1;
2375: }
2376:
2377: ata_sct_data_table_command cmd; memset(&cmd, 0, sizeof(cmd));
2378: // CAUTION: DO NOT CHANGE THIS VALUE (SOME ACTION CODES MAY ERASE DISK)
2379: cmd.action_code = 5; // Data table command
2380: cmd.function_code = 1; // Read table
2381: cmd.table_id = 2; // Temperature History Table
2382:
2383: // swap endian order if needed
2384: if (isbigendian()) {
2385: swapx(&cmd.action_code);
2386: swapx(&cmd.function_code);
2387: swapx(&cmd.table_id);
2388: }
2389:
2390: // write command via SMART log page 0xe0
2391: if (smartcommandhandler(device, WRITE_LOG, 0xe0, (char *)&cmd)){
2392: pout("Error Write SCT Data Table command failed: %s\n", device->get_errmsg());
2393: return -1;
2394: }
2395:
2396: // read SCT data via SMART log page 0xe1
2397: memset(tmh, 0, sizeof(*tmh));
2398: if (smartcommandhandler(device, READ_LOG, 0xe1, (char *)tmh)){
2399: pout("Error Read SCT Data Table failed: %s\n", device->get_errmsg());
2400: return -1;
2401: }
2402:
2403: // re-read and check SCT status
2404: if (ataReadSCTStatus(device, sts))
2405: return -1;
2406:
2407: if (!(sts->ext_status_code == 0 && sts->action_code == 5 && sts->function_code == 1)) {
2408: pout("Error unexpected SCT status 0x%04x (action_code=%u, function_code=%u)\n",
2409: sts->ext_status_code, sts->action_code, sts->function_code);
2410: return -1;
2411: }
2412:
2413: // swap endian order if needed
2414: if (isbigendian()){
2415: swapx(&tmh->format_version);
2416: swapx(&tmh->sampling_period);
2417: swapx(&tmh->interval);
2418: }
2419:
2420: // Check format version
2421: if (tmh->format_version != 2) {
2422: pout("Error unknown SCT Temperature History Format Version (%u), should be 2.\n", tmh->format_version);
2423: return -1;
2424: }
2425: return 0;
2426: }
2427:
2428: // Set SCT Temperature Logging Interval
2429: int ataSetSCTTempInterval(ata_device * device, unsigned interval, bool persistent)
2430: {
2431: // Check initial status
2432: ata_sct_status_response sts;
2433: if (ataReadSCTStatus(device, &sts))
2434: return -1;
2435:
2436: // Do nothing if other SCT command is executing
2437: if (sts.ext_status_code == 0xffff) {
2438: pout("Another SCT command is executing, abort Feature Control\n"
2439: "(SCT ext_status_code 0x%04x, action_code=%u, function_code=%u)\n",
2440: sts.ext_status_code, sts.action_code, sts.function_code);
2441: return -1;
2442: }
2443:
2444: ata_sct_feature_control_command cmd; memset(&cmd, 0, sizeof(cmd));
2445: // CAUTION: DO NOT CHANGE THIS VALUE (SOME ACTION CODES MAY ERASE DISK)
2446: cmd.action_code = 4; // Feature Control command
2447: cmd.function_code = 1; // Set state
2448: cmd.feature_code = 3; // Temperature logging interval
2449: cmd.state = interval;
2450: cmd.option_flags = (persistent ? 0x01 : 0x00);
2451:
2452: // swap endian order if needed
2453: if (isbigendian()) {
2454: swapx(&cmd.action_code);
2455: swapx(&cmd.function_code);
2456: swapx(&cmd.feature_code);
2457: swapx(&cmd.state);
2458: swapx(&cmd.option_flags);
2459: }
2460:
2461: // write command via SMART log page 0xe0
2462: if (smartcommandhandler(device, WRITE_LOG, 0xe0, (char *)&cmd)){
2463: pout("Error Write SCT Feature Control Command failed: %s\n", device->get_errmsg());
2464: return -1;
2465: }
2466:
2467: // re-read and check SCT status
2468: if (ataReadSCTStatus(device, &sts))
2469: return -1;
2470:
2471: if (!(sts.ext_status_code == 0 && sts.action_code == 4 && sts.function_code == 1)) {
2472: pout("Error unexcepted SCT status 0x%04x (action_code=%u, function_code=%u)\n",
2473: sts.ext_status_code, sts.action_code, sts.function_code);
2474: return -1;
2475: }
2476: return 0;
2477: }
2478:
2479: // Get/Set SCT Error Recovery Control
2480: static int ataGetSetSCTErrorRecoveryControltime(ata_device * device, unsigned type,
2481: bool set, unsigned short & time_limit)
2482: {
2483: // Check initial status
2484: ata_sct_status_response sts;
2485: if (ataReadSCTStatus(device, &sts))
2486: return -1;
2487:
2488: // Do nothing if other SCT command is executing
2489: if (sts.ext_status_code == 0xffff) {
2490: pout("Another SCT command is executing, abort Error Recovery Control\n"
2491: "(SCT ext_status_code 0x%04x, action_code=%u, function_code=%u)\n",
2492: sts.ext_status_code, sts.action_code, sts.function_code);
2493: return -1;
2494: }
2495:
2496: ata_sct_error_recovery_control_command cmd; memset(&cmd, 0, sizeof(cmd));
2497: // CAUTION: DO NOT CHANGE THIS VALUE (SOME ACTION CODES MAY ERASE DISK)
2498: cmd.action_code = 3; // Error Recovery Control command
2499: cmd.function_code = (set ? 1 : 2); // 1=Set timer, 2=Get timer
2500: cmd.selection_code = type; // 1=Read timer, 2=Write timer
2501: if (set)
2502: cmd.time_limit = time_limit;
2503:
2504: // swap endian order if needed
2505: if (isbigendian()) {
2506: swapx(&cmd.action_code);
2507: swapx(&cmd.function_code);
2508: swapx(&cmd.selection_code);
2509: swapx(&cmd.time_limit);
2510: }
2511:
2512: // write command via SMART log page 0xe0
2513: // TODO: Debug output
2514: ata_cmd_in in;
2515: in.in_regs.command = ATA_SMART_CMD;
2516: in.in_regs.lba_high = SMART_CYL_HI; in.in_regs.lba_mid = SMART_CYL_LOW;
2517: in.in_regs.features = ATA_SMART_WRITE_LOG_SECTOR;
2518: in.in_regs.lba_low = 0xe0;
2519: in.set_data_out(&cmd, 1);
2520:
2521: if (!set)
2522: // Time limit returned in ATA registers
2523: in.out_needed.sector_count = in.out_needed.lba_low = true;
2524:
2525: ata_cmd_out out;
2526: if (!device->ata_pass_through(in, out)) {
2527: pout("Error Write SCT (%cet) Error Recovery Control Command failed: %s\n",
2528: (!set ? 'G' : 'S'), device->get_errmsg());
2529: return -1;
2530: }
2531:
2532: // re-read and check SCT status
2533: if (ataReadSCTStatus(device, &sts))
2534: return -1;
2535:
2536: if (!(sts.ext_status_code == 0 && sts.action_code == 3 && sts.function_code == (set ? 1 : 2))) {
2537: pout("Error unexcepted SCT status 0x%04x (action_code=%u, function_code=%u)\n",
2538: sts.ext_status_code, sts.action_code, sts.function_code);
2539: return -1;
2540: }
2541:
2542: if (!set) {
2543: // Check whether registers are properly returned by ioctl()
2544: if (!(out.out_regs.sector_count.is_set() && out.out_regs.lba_low.is_set())) {
2545: // TODO: Output register support should be checked within each ata_pass_through()
2546: // implementation before command is issued.
2547: pout("Error SMART WRITE LOG does not return COUNT and LBA_LOW register\n");
2548: return -1;
2549: }
2550: // Return value to caller
2551: time_limit = out.out_regs.sector_count | (out.out_regs.lba_low << 8);
2552: }
2553:
2554: return 0;
2555: }
2556:
2557: // Get SCT Error Recovery Control
2558: int ataGetSCTErrorRecoveryControltime(ata_device * device, unsigned type, unsigned short & time_limit)
2559: {
2560: return ataGetSetSCTErrorRecoveryControltime(device, type, false/*get*/, time_limit);
2561: }
2562:
2563: // Set SCT Error Recovery Control
2564: int ataSetSCTErrorRecoveryControltime(ata_device * device, unsigned type, unsigned short time_limit)
2565: {
2566: return ataGetSetSCTErrorRecoveryControltime(device, type, true/*set*/, time_limit);
2567: }
2568:
2569:
2570: // Print one self-test log entry.
2571: // Returns:
2572: // -1: self-test failed
2573: // 1: extended self-test completed without error
2574: // 0: otherwise
2575: int ataPrintSmartSelfTestEntry(unsigned testnum, unsigned char test_type,
2576: unsigned char test_status,
2577: unsigned short timestamp,
2578: uint64_t failing_lba,
2579: bool print_error_only, bool & print_header)
2580: {
2581: // Check status and type for return value
2582: int retval = 0;
2583: switch (test_status >> 4) {
2584: case 0x0:
2585: if ((test_type & 0x0f) == 0x02)
2586: retval = 1; // extended self-test completed without error
2587: break;
2588: case 0x3: case 0x4:
2589: case 0x5: case 0x6:
2590: case 0x7: case 0x8:
2591: retval = -1; // self-test failed
2592: break;
2593: }
2594:
2595: if (retval >= 0 && print_error_only)
2596: return retval;
2597:
2598: std::string msgtest;
2599: switch (test_type) {
2600: case 0x00: msgtest = "Offline"; break;
2601: case 0x01: msgtest = "Short offline"; break;
2602: case 0x02: msgtest = "Extended offline"; break;
2603: case 0x03: msgtest = "Conveyance offline"; break;
2604: case 0x04: msgtest = "Selective offline"; break;
2605: case 0x7f: msgtest = "Abort offline test"; break;
2606: case 0x81: msgtest = "Short captive"; break;
2607: case 0x82: msgtest = "Extended captive"; break;
2608: case 0x83: msgtest = "Conveyance captive"; break;
2609: case 0x84: msgtest = "Selective captive"; break;
2610: default:
2611: if ((0x40 <= test_type && test_type <= 0x7e) || 0x90 <= test_type)
2612: msgtest = strprintf("Vendor (0x%02x)", test_type);
2613: else
2614: msgtest = strprintf("Reserved (0x%02x)", test_type);
2615: }
2616:
2617: std::string msgstat;
2618: switch (test_status >> 4) {
2619: case 0x0: msgstat = "Completed without error"; break;
2620: case 0x1: msgstat = "Aborted by host"; break;
2621: case 0x2: msgstat = "Interrupted (host reset)"; break;
2622: case 0x3: msgstat = "Fatal or unknown error"; break;
2623: case 0x4: msgstat = "Completed: unknown failure"; break;
2624: case 0x5: msgstat = "Completed: electrical failure"; break;
2625: case 0x6: msgstat = "Completed: servo/seek failure"; break;
2626: case 0x7: msgstat = "Completed: read failure"; break;
2627: case 0x8: msgstat = "Completed: handling damage??"; break;
2628: case 0xf: msgstat = "Self-test routine in progress"; break;
2629: default: msgstat = strprintf("Unknown status (0x%x)", test_status >> 4);
2630: }
2631:
2632: // Print header once
2633: if (print_header) {
2634: print_header = false;
2635: pout("Num Test_Description Status Remaining LifeTime(hours) LBA_of_first_error\n");
2636: }
2637:
2638: char msglba[32];
2639: if (retval < 0 && failing_lba < 0xffffffffffffULL)
2640: snprintf(msglba, sizeof(msglba), "%"PRIu64, failing_lba);
2641: else
2642: strcpy(msglba, "-");
2643:
2644: pout("#%2u %-19s %-29s %1d0%% %8u %s\n", testnum,
2645: msgtest.c_str(), msgstat.c_str(), test_status & 0x0f, timestamp, msglba);
2646:
2647: return retval;
2648: }
2649:
2650: // Print Smart self-test log, used by smartctl and smartd.
2651: // return value is:
2652: // bottom 8 bits: number of entries found where self-test showed an error
2653: // remaining bits: if nonzero, power on hours of last self-test where error was found
2654: int ataPrintSmartSelfTestlog(const ata_smart_selftestlog * data, bool allentries,
2655: unsigned char fix_firmwarebug)
2656: {
2657: if (allentries)
2658: pout("SMART Self-test log structure revision number %d\n",(int)data->revnumber);
2659: if ((data->revnumber!=0x0001) && allentries && fix_firmwarebug != FIX_SAMSUNG)
2660: pout("Warning: ATA Specification requires self-test log structure revision number = 1\n");
2661: if (data->mostrecenttest==0){
2662: if (allentries)
2663: pout("No self-tests have been logged. [To run self-tests, use: smartctl -t]\n\n");
2664: return 0;
2665: }
2666:
2667: bool noheaderprinted = true;
2668: int errcnt = 0, hours = 0, igncnt = 0;
2669: int testno = 0, ext_ok_testno = -1;
2670:
2671: // print log
2672: for (int i = 20; i >= 0; i--) {
2673: // log is a circular buffer
2674: int j = (i+data->mostrecenttest)%21;
2675: const ata_smart_selftestlog_struct * log = data->selftest_struct+j;
2676:
2677: if (nonempty(log, sizeof(*log))) {
2678: // count entry based on non-empty structures -- needed for
2679: // Seagate only -- other vendors don't have blank entries 'in
2680: // the middle'
2681: testno++;
2682:
2683: // T13/1321D revision 1c: (Data structure Rev #1)
2684:
2685: //The failing LBA shall be the LBA of the uncorrectable sector
2686: //that caused the test to fail. If the device encountered more
2687: //than one uncorrectable sector during the test, this field
2688: //shall indicate the LBA of the first uncorrectable sector
2689: //encountered. If the test passed or the test failed for some
2690: //reason other than an uncorrectable sector, the value of this
2691: //field is undefined.
2692:
2693: // This is true in ALL ATA-5 specs
2694: uint64_t lba48 = (log->lbafirstfailure < 0xffffffff ? log->lbafirstfailure : 0xffffffffffffULL);
2695:
2696: // Print entry
2697: int state = ataPrintSmartSelfTestEntry(testno,
2698: log->selftestnumber, log->selfteststatus,
2699: log->timestamp, lba48, !allentries, noheaderprinted);
2700:
2701: if (state < 0) {
2702: // Self-test showed an error
2703: if (ext_ok_testno < 0) {
2704: errcnt++;
2705:
2706: // keep track of time of most recent error
2707: if (!hours)
2708: hours = log->timestamp;
2709: }
2710: else
2711: // Newer successful extended self-test exits
2712: igncnt++;
2713: }
2714: else if (state > 0 && ext_ok_testno < 0) {
2715: // Latest successful extended self-test
2716: ext_ok_testno = testno;
2717: }
2718: }
2719: }
2720:
2721: if (igncnt)
2722: pout("%d of %d failed self-tests are outdated by newer successful extended offline self-test #%2d\n",
2723: igncnt, igncnt+errcnt, ext_ok_testno);
2724:
2725: if (!allentries && !noheaderprinted)
2726: pout("\n");
2727:
2728: return ((hours << 8) | errcnt);
2729: }
2730:
2731:
2732: /////////////////////////////////////////////////////////////////////////////
2733: // Pseudo-device to parse "smartctl -r ataioctl,2 ..." output and simulate
2734: // an ATA device with same behaviour
2735:
2736: namespace {
2737:
2738: class parsed_ata_device
2739: : public /*implements*/ ata_device_with_command_set
2740: {
2741: public:
2742: parsed_ata_device(smart_interface * intf, const char * dev_name);
2743:
2744: virtual ~parsed_ata_device() throw();
2745:
2746: virtual bool is_open() const;
2747:
2748: virtual bool open();
2749:
2750: virtual bool close();
2751:
2752: virtual bool ata_identify_is_cached() const;
2753:
2754: protected:
2755: virtual int ata_command_interface(smart_command_set command, int select, char * data);
2756:
2757: private:
2758: // Table of parsed commands, return value, data
2759: struct parsed_ata_command
2760: {
2761: smart_command_set command;
2762: int select;
2763: int retval, errval;
2764: char * data;
2765: };
2766:
2767: enum { max_num_commands = 32 };
2768: parsed_ata_command m_command_table[max_num_commands];
2769:
2770: int m_num_commands;
2771: int m_next_replay_command;
2772: bool m_replay_out_of_sync;
2773: bool m_ata_identify_is_cached;
2774: };
2775:
2776: static const char * nextline(const char * s, int & lineno)
2777: {
2778: for (s += strcspn(s, "\r\n"); *s == '\r' || *s == '\n'; s++) {
2779: if (*s == '\r' && s[1] == '\n')
2780: s++;
2781: lineno++;
2782: }
2783: return s;
2784: }
2785:
2786: static int name2command(const char * s)
2787: {
2788: for (int i = 0; i < (int)(sizeof(commandstrings)/sizeof(commandstrings[0])); i++) {
2789: if (!strcmp(s, commandstrings[i]))
2790: return i;
2791: }
2792: return -1;
2793: }
2794:
2795: static bool matchcpy(char * dest, size_t size, const char * src, const regmatch_t & srcmatch)
2796: {
2797: if (srcmatch.rm_so < 0)
2798: return false;
2799: size_t n = srcmatch.rm_eo - srcmatch.rm_so;
2800: if (n >= size)
2801: n = size-1;
2802: memcpy(dest, src + srcmatch.rm_so, n);
2803: dest[n] = 0;
2804: return true;
2805: }
2806:
2807: static inline int matchtoi(const char * src, const regmatch_t & srcmatch, int defval)
2808: {
2809: if (srcmatch.rm_so < 0)
2810: return defval;
2811: return atoi(src + srcmatch.rm_so);
2812: }
2813:
2814: parsed_ata_device::parsed_ata_device(smart_interface * intf, const char * dev_name)
2815: : smart_device(intf, dev_name, "ata", ""),
2816: m_num_commands(0),
2817: m_next_replay_command(0),
2818: m_replay_out_of_sync(false),
2819: m_ata_identify_is_cached(false)
2820: {
2821: memset(m_command_table, 0, sizeof(m_command_table));
2822: }
2823:
2824: parsed_ata_device::~parsed_ata_device() throw()
2825: {
2826: close();
2827: }
2828:
2829: bool parsed_ata_device::is_open() const
2830: {
2831: return (m_num_commands > 0);
2832: }
2833:
2834: // Parse stdin and build command table
2835: bool parsed_ata_device::open()
2836: {
2837: const char * pathname = get_dev_name();
2838: if (strcmp(pathname, "-"))
2839: return set_err(EINVAL);
2840: pathname = "<stdin>";
2841: // Fill buffer
2842: char buffer[64*1024];
2843: int size = 0;
2844: while (size < (int)sizeof(buffer)) {
2845: int nr = fread(buffer, 1, sizeof(buffer), stdin);
2846: if (nr <= 0)
2847: break;
2848: size += nr;
2849: }
2850: if (size <= 0)
2851: return set_err(ENOENT, "%s: Unexpected EOF", pathname);
2852: if (size >= (int)sizeof(buffer))
2853: return set_err(EIO, "%s: Buffer overflow", pathname);
2854: buffer[size] = 0;
2855:
2856: // Regex to match output from "-r ataioctl,2"
2857: static const char pattern[] = "^"
2858: "(" // (1
2859: "REPORT-IOCTL: DeviceF?D?=[^ ]+ Command=([A-Z ]*[A-Z])" // (2)
2860: "(" // (3
2861: "( InputParameter=([0-9]+))?" // (4 (5))
2862: "|"
2863: "( returned (-?[0-9]+)( errno=([0-9]+)[^\r\n]*)?)" // (6 (7) (8 (9)))
2864: ")" // )
2865: "[\r\n]" // EOL match necessary to match optional parts above
2866: "|"
2867: "===== \\[([A-Z ]*[A-Z])\\] DATA START " // (10)
2868: "|"
2869: " *(En|Dis)abled status cached by OS, " // (11)
2870: ")"; // )
2871:
2872: // Compile regex
2873: const regular_expression regex(pattern, REG_EXTENDED);
2874:
2875: // Parse buffer
2876: const char * errmsg = 0;
2877: int i = -1, state = 0, lineno = 1;
2878: for (const char * line = buffer; *line; line = nextline(line, lineno)) {
2879: // Match line
2880: if (!(line[0] == 'R' || line[0] == '=' || line[0] == ' '))
2881: continue;
2882: const int nmatch = 1+11;
2883: regmatch_t match[nmatch];
2884: if (!regex.execute(line, nmatch, match))
2885: continue;
2886:
2887: char cmdname[40];
2888: if (matchcpy(cmdname, sizeof(cmdname), line, match[2])) { // "REPORT-IOCTL:... Command=%s ..."
2889: int nc = name2command(cmdname);
2890: if (nc < 0) {
2891: errmsg = "Unknown ATA command name"; break;
2892: }
2893: if (match[7].rm_so < 0) { // "returned %d"
2894: // Start of command
2895: if (!(state == 0 || state == 2)) {
2896: errmsg = "Missing REPORT-IOCTL result"; break;
2897: }
2898: if (++i >= max_num_commands) {
2899: errmsg = "Too many ATA commands"; break;
2900: }
2901: m_command_table[i].command = (smart_command_set)nc;
2902: m_command_table[i].select = matchtoi(line, match[5], 0); // "InputParameter=%d"
2903: state = 1;
2904: }
2905: else {
2906: // End of command
2907: if (!(state == 1 && (int)m_command_table[i].command == nc)) {
2908: errmsg = "Missing REPORT-IOCTL start"; break;
2909: }
2910: m_command_table[i].retval = matchtoi(line, match[7], -1); // "returned %d"
2911: m_command_table[i].errval = matchtoi(line, match[9], 0); // "errno=%d"
2912: state = 2;
2913: }
2914: }
2915: else if (matchcpy(cmdname, sizeof(cmdname), line, match[10])) { // "===== [%s] DATA START "
2916: // Start of sector hexdump
2917: int nc = name2command(cmdname);
2918: if (!(state == (nc == WRITE_LOG ? 1 : 2) && (int)m_command_table[i].command == nc)) {
2919: errmsg = "Unexpected DATA START"; break;
2920: }
2921: line = nextline(line, lineno);
2922: char * data = (char *)malloc(512);
2923: unsigned j;
2924: for (j = 0; j < 32; j++) {
2925: unsigned b[16];
2926: unsigned u1, u2; int n1 = -1;
2927: if (!(sscanf(line, "%3u-%3u: "
2928: "%2x %2x %2x %2x %2x %2x %2x %2x "
2929: "%2x %2x %2x %2x %2x %2x %2x %2x%n",
2930: &u1, &u2,
2931: b+ 0, b+ 1, b+ 2, b+ 3, b+ 4, b+ 5, b+ 6, b+ 7,
2932: b+ 8, b+ 9, b+10, b+11, b+12, b+13, b+14, b+15, &n1) == 18
2933: && n1 >= 56 && u1 == j*16 && u2 == j*16+15))
2934: break;
2935: for (unsigned k = 0; k < 16; k++)
2936: data[j*16+k] = b[k];
2937: line = nextline(line, lineno);
2938: }
2939: if (j < 32) {
2940: free(data);
2941: errmsg = "Incomplete sector hex dump"; break;
2942: }
2943: m_command_table[i].data = data;
2944: if (nc != WRITE_LOG)
2945: state = 0;
2946: }
2947: else if (match[11].rm_so > 0) { // "(En|Dis)abled status cached by OS"
2948: m_ata_identify_is_cached = true;
2949: }
2950: }
2951:
2952: if (!(state == 0 || state == 2))
2953: errmsg = "Missing REPORT-IOCTL result";
2954:
2955: if (!errmsg && i < 0)
2956: errmsg = "No information found";
2957:
2958: m_num_commands = i+1;
2959: m_next_replay_command = 0;
2960: m_replay_out_of_sync = false;
2961:
2962: if (errmsg) {
2963: close();
2964: return set_err(EIO, "%s(%d): Syntax error: %s", pathname, lineno, errmsg);
2965: }
2966: return true;
2967: }
2968:
2969: // Report warnings and free command table
2970: bool parsed_ata_device::close()
2971: {
2972: if (m_replay_out_of_sync)
2973: pout("REPLAY-IOCTL: Warning: commands replayed out of sync\n");
2974: else if (m_next_replay_command != 0)
2975: pout("REPLAY-IOCTL: Warning: %d command(s) not replayed\n", m_num_commands-m_next_replay_command);
2976:
2977: for (int i = 0; i < m_num_commands; i++) {
2978: if (m_command_table[i].data) {
2979: free(m_command_table[i].data); m_command_table[i].data = 0;
2980: }
2981: }
2982: m_num_commands = 0;
2983: m_next_replay_command = 0;
2984: m_replay_out_of_sync = false;
2985: return true;
2986: }
2987:
2988:
2989: bool parsed_ata_device::ata_identify_is_cached() const
2990: {
2991: return m_ata_identify_is_cached;
2992: }
2993:
2994:
2995: // Simulate ATA command from command table
2996: int parsed_ata_device::ata_command_interface(smart_command_set command, int select, char * data)
2997: {
2998: // Find command, try round-robin if out of sync
2999: int i = m_next_replay_command;
3000: for (int j = 0; ; j++) {
3001: if (j >= m_num_commands) {
3002: pout("REPLAY-IOCTL: Warning: Command not found\n");
3003: errno = ENOSYS;
3004: return -1;
3005: }
3006: if (m_command_table[i].command == command && m_command_table[i].select == select)
3007: break;
3008: if (!m_replay_out_of_sync) {
3009: m_replay_out_of_sync = true;
3010: pout("REPLAY-IOCTL: Warning: Command #%d is out of sync\n", i+1);
3011: }
3012: if (++i >= m_num_commands)
3013: i = 0;
3014: }
3015: m_next_replay_command = i;
3016: if (++m_next_replay_command >= m_num_commands)
3017: m_next_replay_command = 0;
3018:
3019: // Return command data
3020: switch (command) {
3021: case IDENTIFY:
3022: case PIDENTIFY:
3023: case READ_VALUES:
3024: case READ_THRESHOLDS:
3025: case READ_LOG:
3026: if (m_command_table[i].data)
3027: memcpy(data, m_command_table[i].data, 512);
3028: break;
3029: case WRITE_LOG:
3030: if (!(m_command_table[i].data && !memcmp(data, m_command_table[i].data, 512)))
3031: pout("REPLAY-IOCTL: Warning: WRITE LOG data does not match\n");
3032: break;
3033: case CHECK_POWER_MODE:
3034: data[0] = (char)0xff;
3035: default:
3036: break;
3037: }
3038:
3039: if (m_command_table[i].errval)
3040: errno = m_command_table[i].errval;
3041: return m_command_table[i].retval;
3042: }
3043:
3044: } // namespace
3045:
3046: ata_device * get_parsed_ata_device(smart_interface * intf, const char * dev_name)
3047: {
3048: return new parsed_ata_device(intf, dev_name);
3049: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to atacmds.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / smartmontools